Use xmalloc

This reverts commit 59b025e3.

src/modules/cache.c

@@ -31,7 +31,6 @@
 #include <vlc_common.h>
 #include "libvlc.h"
 
-#include <assert.h>
 #include <stdlib.h>                                      /* free(), strtol() */
 #include <stdio.h>                                              /* sprintf() */
 #include <string.h>                                              /* strdup() */
@@ -229,11 +228,8 @@ void CacheLoad( vlc_object_t *p_this, module_bank_t *p_bank, bool b_delete )
     }
 
     if( i_cache )
-    {
         pp_cache = p_bank->pp_loaded_cache =
-                   malloc( i_cache * sizeof(void *) );
-        assert( pp_cache );
-    }
+                   xmalloc( i_cache * sizeof(void *) );
 
 #define LOAD_IMMEDIATE(a) \
     if( fread( (void *)&a, sizeof(char), sizeof(a), file ) != sizeof(a) ) goto error
@@ -244,7 +240,7 @@ void CacheLoad( vlc_object_t *p_this, module_bank_t *p_bank, bool b_delete )
      || ( i_size > 16384 ) ) \
         goto error; \
     if( i_size ) { \
-        char *psz = malloc( i_size ); \
+        char *psz = xmalloc( i_size ); \
         if( fread( psz, i_size, 1, file ) != 1 ) { \
             free( psz ); \
             goto error; \
@@ -262,8 +258,7 @@ void CacheLoad( vlc_object_t *p_this, module_bank_t *p_bank, bool b_delete )
         uint16_t i_size;
         int i_submodules;
 
-        pp_cache[i] = malloc( sizeof(module_cache_t) );
-        assert( pp_cache[i] );
+        pp_cache[i] = xmalloc( sizeof(module_cache_t) );
         p_bank->i_loaded_cache++;
 
         /* Load common info */
@@ -399,7 +394,7 @@ static int CacheLoadConfig( module_t *p_module, FILE *file )
             {
                 int j;
                 p_module->p_config[i].ppsz_list =
-                    malloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
+                    xmalloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
                 if( p_module->p_config[i].ppsz_list )
                 {
                     for( j = 0; j < p_module->p_config[i].i_list; j++ )
@@ -411,7 +406,7 @@ static int CacheLoadConfig( module_t *p_module, FILE *file )
             {
                 int j;
                 p_module->p_config[i].ppsz_list_text =
-                    malloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
+                    xmalloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
                 if( p_module->p_config[i].ppsz_list_text )
                 {
                   for( j = 0; j < p_module->p_config[i].i_list; j++ )
@@ -422,7 +417,7 @@ static int CacheLoadConfig( module_t *p_module, FILE *file )
             if( p_module->p_config[i].pi_list )
             {
                 p_module->p_config[i].pi_list =
-                    malloc( (p_module->p_config[i].i_list + 1) * sizeof(int) );
+                    xmalloc( (p_module->p_config[i].i_list + 1) * sizeof(int) );
                 if( p_module->p_config[i].pi_list )
                 {
                     for (int j = 0; j < p_module->p_config[i].i_list; j++)
@@ -434,11 +429,9 @@ static int CacheLoadConfig( module_t *p_module, FILE *file )
         if( p_module->p_config[i].i_action )
         {
             p_module->p_config[i].ppf_action =
-                malloc( p_module->p_config[i].i_action * sizeof(void *) );
-            assert( p_module->p_config[i].ppf_action );
+                xmalloc( p_module->p_config[i].i_action * sizeof(void *) );
             p_module->p_config[i].ppsz_action_text =
-                malloc( p_module->p_config[i].i_action * sizeof(char *) );
-            assert( p_module->p_config[i].ppsz_action_text );
+                xmalloc( p_module->p_config[i].i_action * sizeof(char *) );
 
             for (int j = 0; j < p_module->p_config[i].i_action; j++)
             {

src/network/httpd.c

@@ -460,8 +460,7 @@ httpd_file_t *httpd_FileNew( httpd_host_t *host,
                              const vlc_acl_t *p_acl, httpd_file_callback_t pf_fill,
                              httpd_file_sys_t *p_sys )
 {
-    httpd_file_t *file = malloc( sizeof( httpd_file_t ) );
-    assert( file );
+    httpd_file_t *file = xmalloc( sizeof( httpd_file_t ) );
 
     if( ( file->url = httpd_UrlNewUnique( host, psz_url, psz_user,
                                           psz_password, p_acl )
@@ -593,8 +592,7 @@ httpd_HandlerCallBack( httpd_callback_sys_t *p_sys, httpd_client_t *cl,
         psz_status = httpd_ReasonFromCode( i_status );
         answer->i_body = sizeof("HTTP/1.0 xxx \r\n")
                         + strlen(psz_status) + i_headers - 1;
-        psz_new = (char *)malloc( answer->i_body + 1);
-        assert( psz_new );
+        psz_new = (char *)xmalloc( answer->i_body + 1);
         sprintf( psz_new, "HTTP/1.0 %03d %s\r\n", i_status, psz_status );
         memcpy( &psz_new[strlen(psz_new)], psz_headers, i_headers );
         free( answer->p_body );
@@ -611,8 +609,7 @@ httpd_handler_t *httpd_HandlerNew( httpd_host_t *host, const char *psz_url,
                                    httpd_handler_callback_t pf_fill,
                                    httpd_handler_sys_t *p_sys )
 {
-    httpd_handler_t *handler = malloc( sizeof( httpd_handler_t ) );
-    assert( handler );
+    httpd_handler_t *handler = xmalloc( sizeof( httpd_handler_t ) );
 
     if( ( handler->url = httpd_UrlNewUnique( host, psz_url, psz_user,
                                              psz_password, p_acl )
@@ -683,8 +680,7 @@ static int httpd_RedirectCallBack( httpd_callback_sys_t *p_sys,
 httpd_redirect_t *httpd_RedirectNew( httpd_host_t *host, const char *psz_url_dst,
                                      const char *psz_url_src )
 {
-    httpd_redirect_t *rdir = malloc( sizeof( httpd_redirect_t ) );
-    assert( rdir );
+    httpd_redirect_t *rdir = xmalloc( sizeof( httpd_redirect_t ) );
 
     if( !( rdir->url = httpd_UrlNewUnique( host, psz_url_src, NULL, NULL, NULL ) ) )
     {
@@ -790,8 +786,7 @@ static int httpd_StreamCallBack( httpd_callback_sys_t *p_sys,
         answer->i_type   = HTTPD_MSG_ANSWER;
 
         answer->i_body = i_write;
-        answer->p_body = malloc( i_write );
-        assert( answer->p_body );
+        answer->p_body = xmalloc( i_write );
         memcpy( answer->p_body, &stream->p_buffer[i_pos], i_write );
 
         answer->i_body_offset += i_write;
@@ -814,8 +809,7 @@ static int httpd_StreamCallBack( httpd_callback_sys_t *p_sys,
             if( stream->i_header > 0 )
             {
                 answer->i_body = stream->i_header;
-                answer->p_body = malloc( stream->i_header );
-                assert( answer->p_body );
+                answer->p_body = xmalloc( stream->i_header );
                 memcpy( answer->p_body, stream->p_header, stream->i_header );
             }
             answer->i_body_offset = stream->i_buffer_last_pos;
@@ -868,8 +862,7 @@ httpd_stream_t *httpd_StreamNew( httpd_host_t *host,
                                  const char *psz_user, const char *psz_password,
                                  const vlc_acl_t *p_acl )
 {
-    httpd_stream_t *stream = malloc( sizeof( httpd_stream_t ) );
-    assert( stream );
+    httpd_stream_t *stream = xmalloc( sizeof( httpd_stream_t ) );
 
     if( ( stream->url = httpd_UrlNewUnique( host, psz_url, psz_user,
                                             psz_password, p_acl )
@@ -890,8 +883,7 @@ httpd_stream_t *httpd_StreamNew( httpd_host_t *host,
     stream->i_header = 0;
     stream->p_header = NULL;
     stream->i_buffer_size = 5000000;    /* 5 Mo per stream */
-    stream->p_buffer = malloc( stream->i_buffer_size );
-    assert( stream->p_buffer );
+    stream->p_buffer = xmalloc( stream->i_buffer_size );
     /* We set to 1 to make life simpler
      * (this way i_body_offset can never be 0) */
     stream->i_buffer_pos = 1;
@@ -916,8 +908,7 @@ int httpd_StreamHeader( httpd_stream_t *stream, uint8_t *p_data, int i_data )
     stream->i_header = i_data;
     if( i_data > 0 )
     {
-        stream->p_header = malloc( i_data );
-        assert( stream->p_header );
+        stream->p_header = xmalloc( i_data );
         memcpy( stream->p_header, p_data, i_data );
     }
     vlc_mutex_unlock( &stream->lock );
@@ -1247,8 +1238,7 @@ static httpd_url_t *httpd_UrlNewPrivate( httpd_host_t *host, const char *psz_url
         }
     }
 
-    url = malloc( sizeof( httpd_url_t ) );
-    assert( url );
+    url = xmalloc( sizeof( httpd_url_t ) );
     url->host = host;
 
     vlc_mutex_init( &url->lock );
@@ -1416,8 +1406,7 @@ static void httpd_ClientInit( httpd_client_t *cl, mtime_t now )
     cl->i_activity_timeout = INT64_C(10000000);
     cl->i_buffer_size = HTTPD_CL_BUFSIZE;
     cl->i_buffer = 0;
-    cl->p_buffer = malloc( cl->i_buffer_size );
-    assert( cl->p_buffer );
+    cl->p_buffer = xmalloc( cl->i_buffer_size );
     cl->i_mode   = HTTPD_CLIENT_FILE;
     cl->b_read_waiting = false;
 
@@ -1565,8 +1554,7 @@ static void httpd_ClientRecv( httpd_client_t *cl )
             cl->query.i_type  = HTTPD_MSG_CHANNEL;
             cl->query.i_channel = cl->p_buffer[1];
             cl->query.i_body  = (cl->p_buffer[2] << 8)|cl->p_buffer[3];
-            cl->query.p_body  = malloc( cl->query.i_body );
-            assert( cl->query.p_body );
+            cl->query.p_body  = xmalloc( cl->query.i_body );
             cl->i_buffer      -= 4;
             memcpy( cl->query.p_body, cl->p_buffer + 4, cl->i_buffer );
         }
@@ -1847,8 +1835,7 @@ static void httpd_ClientRecv( httpd_client_t *cl )
                     /* TODO Mhh, handle the case client will only send a
                      * request and close the connection
                      * to mark and of body (probably only RTSP) */
-                    cl->query.p_body = malloc( cl->query.i_body );
-                    assert( cl->query.p_body );
+                    cl->query.p_body = xmalloc( cl->query.i_body );
                     cl->i_buffer = 0;
                 }
                 else
@@ -1936,8 +1923,7 @@ static void httpd_ClientSend( httpd_client_t *cl )
         {
             cl->i_buffer_size = i_size;
             free( cl->p_buffer );
-            cl->p_buffer = malloc( i_size );
-            assert( cl->p_buffer );
+            cl->p_buffer = xmalloc( i_size );
         }
         p = (char *)cl->p_buffer;
 
@@ -2380,8 +2366,7 @@ static void* httpd_HostThread( void *data )
                         cl->i_buffer = 0;
                         cl->i_buffer_size = 1000;
                         free( cl->p_buffer );
-                        cl->p_buffer = malloc( cl->i_buffer_size );
-                        assert( cl->p_buffer );
+                        cl->p_buffer = xmalloc( cl->i_buffer_size );
                         cl->i_state = HTTPD_CLIENT_RECEIVING;
                     }
                     else
@@ -2399,8 +2384,7 @@ static void* httpd_HostThread( void *data )
                     cl->i_buffer = 0;
                     cl->i_buffer_size = 1000;
                     free( cl->p_buffer );
-                    cl->p_buffer = malloc( cl->i_buffer_size );
-                    assert( cl->p_buffer );
+                    cl->p_buffer = xmalloc( cl->i_buffer_size );
                     cl->i_state = HTTPD_CLIENT_RECEIVING;
                     cl->b_read_waiting = false;
                 }