1 files changed, 90 insertions, 124 deletions

diff --git a/src/xine-engine/load_plugins.c b/src/xine-engine/load_plugins.c
index 83442aa8a..c30fac308 100644
--- a/src/xine-engine/load_plugins.c
+++ b/src/xine-engine/load_plugins.c
@@ -333,8 +333,8 @@ static void _insert_node (xine_t *this,
     return;
   }
 
-  entry = xine_xmalloc(sizeof(plugin_node_t));
-  entry->info         = xine_xmalloc(sizeof(plugin_info_t));
+  entry = calloc(1, sizeof(plugin_node_t));
+  entry->info         = calloc(1, sizeof(plugin_info_t));
   *(entry->info)      = *info;
   entry->info->id     = strdup(info->id);
   entry->info->init   = info->init;
@@ -348,7 +348,7 @@ static void _insert_node (xine_t *this,
 
   case PLUGIN_VIDEO_OUT:
     vo_old = info->special_info;
-    vo_new = xine_xmalloc(sizeof(vo_info_t));
+    vo_new = calloc(1, sizeof(vo_info_t));
     entry->priority = vo_new->priority = vo_old->priority;
     vo_new->visual_type = vo_old->visual_type;
     entry->info->special_info = vo_new;
@@ -356,7 +356,7 @@ static void _insert_node (xine_t *this,
 
   case PLUGIN_AUDIO_OUT:
     ao_old = info->special_info;
-    ao_new = xine_xmalloc(sizeof(ao_info_t));
+    ao_new = calloc(1, sizeof(ao_info_t));
     entry->priority = ao_new->priority = ao_old->priority;
     entry->info->special_info = ao_new;
     break;
@@ -365,7 +365,7 @@ static void _insert_node (xine_t *this,
   case PLUGIN_VIDEO_DECODER:
   case PLUGIN_SPU_DECODER:
     decoder_old = info->special_info;
-    decoder_new = xine_xmalloc(sizeof(decoder_info_t));
+    decoder_new = calloc(1, sizeof(decoder_info_t));
     if (decoder_old == NULL) {
       if (file)
 	xprintf (this, XINE_VERBOSITY_DEBUG,
@@ -377,12 +377,13 @@ static void _insert_node (xine_t *this,
 		 info->id);
       _x_abort();
     }
-    for (i=0; decoder_old->supported_types[i] != 0; ++i);
-    types = xine_xmalloc((i+1)*sizeof(uint32_t));
-    for (i=0; decoder_old->supported_types[i] != 0; ++i){
-      types[i] = decoder_old->supported_types[i];
+    {
+      size_t supported_types_size;
+      for (supported_types_size=0; decoder_old->supported_types[supported_types_size] != 0; ++supported_types_size);
+      types = calloc((supported_types_size+1), sizeof(uint32_t));
+      memcpy(types, decoder_old->supported_types, supported_types_size*sizeof(uint32_t));
+      decoder_new->supported_types = types;
     }
-    decoder_new->supported_types = types;
     entry->priority = decoder_new->priority = decoder_old->priority;
     
     snprintf(key, sizeof(key), "engine.decoder_priorities.%s", info->id);
@@ -406,14 +407,14 @@ static void _insert_node (xine_t *this,
   
   case PLUGIN_POST:
     post_old = info->special_info;
-    post_new = xine_xmalloc(sizeof(post_info_t));
+    post_new = calloc(1, sizeof(post_info_t));
     post_new->type = post_old->type;
     entry->info->special_info = post_new;
     break;
     
   case PLUGIN_DEMUX:
     demux_old = info->special_info;
-    demux_new = xine_xmalloc(sizeof(demuxer_info_t));
+    demux_new = calloc(1, sizeof(demuxer_info_t));
     
     if (demux_old) {
       entry->priority = demux_new->priority = demux_old->priority;
@@ -430,7 +431,7 @@ static void _insert_node (xine_t *this,
 
   case PLUGIN_INPUT:
     input_old = info->special_info;
-    input_new = xine_xmalloc(sizeof(input_info_t));
+    input_new = calloc(1, sizeof(input_info_t));
     
     if (input_old) {
       entry->priority = input_new->priority = input_old->priority;
@@ -472,7 +473,7 @@ static plugin_catalog_t *_new_catalog(void){
   plugin_catalog_t *catalog;
   int i;
 
-  catalog = xine_xmalloc(sizeof(plugin_catalog_t));
+  catalog = calloc(1, sizeof(plugin_catalog_t));
 
   for (i = 0; i < PLUGIN_TYPE_MAX; i++) {
     catalog->plugin_lists[i] = xine_sarray_new(0, _plugin_node_comparator);
@@ -562,26 +563,21 @@ static void collect_plugins(xine_t *this, char *path){
   dir = opendir(path);
   if (dir) {
     struct dirent *pEntry;
-    size_t path_len, str_size;
-    char *str = NULL;
 
-    path_len = strlen(path);
-    str_size = path_len * 2 + 2; /* +2 for '/' and '\0' */
-    str = malloc(str_size);
-    xine_fast_memcpy(str, path, path_len);
-    str[path_len] = '/';
-    str[path_len + 1] = '\0';
+    size_t path_len = strlen(path);
+    size_t str_size = path_len * 2 + 2; /* +2 for '/' and '\0' */
+    char *str = malloc(str_size);
+    sprintf(str, "%s/", path);
 
     while ((pEntry = readdir (dir)) != NULL) {
-      size_t new_str_size, d_len;
       void *lib = NULL;
       plugin_info_t *info = NULL;
       plugin_node_t *node = NULL;
       
       struct stat statbuffer;
 
-      d_len = strlen(pEntry->d_name);
-      new_str_size = path_len + d_len + 2;
+      size_t d_len = strlen(pEntry->d_name);
+      size_t new_str_size = path_len + d_len + 2;
       if (str_size < new_str_size) {
 	str_size = new_str_size + new_str_size / 2;
 	str = realloc(str, str_size);
@@ -1005,8 +1001,8 @@ static void load_plugin_list(xine_t *this, FILE *fp, xine_sarray_t *plugins) {
       if( node ) {
         xine_sarray_add (plugins, node);
       }
-      node                = xine_xmalloc(sizeof(plugin_node_t));
-      file                = xine_xmalloc(sizeof(plugin_file_t));
+      node                = calloc(1, sizeof(plugin_node_t));
+      file                = calloc(1, sizeof(plugin_file_t));
       node->file          = file;
       file->filename      = strdup(line+1);
       node->info          = calloc(2, sizeof(plugin_info_t));
@@ -1045,36 +1041,36 @@ static void load_plugin_list(xine_t *this, FILE *fp, xine_sarray_t *plugins) {
           
             case PLUGIN_VIDEO_OUT:
               node->info->special_info = vo_info =
-                        xine_xmalloc(sizeof(vo_info_t));
+		calloc(1, sizeof(vo_info_t));
               break;
           
             case PLUGIN_AUDIO_OUT:
               node->info->special_info = ao_info =
-		             xine_xmalloc(sizeof(ao_info_t));
+		calloc(1, sizeof(ao_info_t));
               break;
           
             case PLUGIN_DEMUX:
               node->info->special_info = demuxer_info =
-		             xine_xmalloc(sizeof(demuxer_info_t));
+		calloc(1, sizeof(demuxer_info_t));
               break;
 
             case PLUGIN_INPUT:
               node->info->special_info = input_info =
-		           xine_xmalloc(sizeof(input_info_t));
+		calloc(1, sizeof(input_info_t));
               break;
 
             case PLUGIN_AUDIO_DECODER:
             case PLUGIN_VIDEO_DECODER:
             case PLUGIN_SPU_DECODER:
               node->info->special_info = decoder_info =
-                             xine_xmalloc(sizeof(decoder_info_t));
+		calloc(1, sizeof(decoder_info_t));
               break;
 	    
-            case PLUGIN_POST:
-              node->info->special_info = post_info =
-              xine_xmalloc(sizeof(post_info_t));
-              break;
-          }
+	    case PLUGIN_POST:
+	      node->info->special_info = post_info =
+		calloc(1, sizeof(post_info_t));
+	      break;
+          }        
           
         } else if( !strcmp("api",line) ) {
           sscanf(value," %d",&i);
@@ -2557,6 +2553,32 @@ void xine_post_dispose(xine_t *xine, xine_post_t *post_gen) {
    * their disposal if they are still in use => post.c handles the counting for us */
 }
 
+/**
+ * @brief Concantenates an array of strings into a single
+ *        string separated with a given string.
+ *
+ * @param strings Array of strings to concatenate.
+ * @param count Number of elements in the @p strings array.
+ * @param joining String to use to join the various strings together.
+ * @param final_length The pre-calculated final length of the string.
+ */
+static char *_x_concatenate_with_string(char **strings, size_t count, char *joining, size_t final_length) {
+  size_t i;
+  char *const result = malloc(final_length+1); /* Better be safe */
+  char *str = result;
+
+  size_t pos = 0;
+  for(i = 0; i < count; i++, strings++) {
+    if ( *strings ) {
+      int offset = snprintf(str, final_length, "%s%s", *strings, joining);
+      str += offset;
+      final_length -= offset;
+    }
+  }
+
+  return result;
+}
+
 /* get a list of file extensions for file types supported by xine
  * the list is separated by spaces 
  *
@@ -2564,65 +2586,35 @@ void xine_post_dispose(xine_t *xine, xine_post_t *post_gen) {
 char *xine_get_file_extensions (xine_t *self) {
 
   plugin_catalog_t *catalog = self->plugin_catalog;
-  int               len, pos;
-  plugin_node_t    *node;
-  char             *str;
-  int               list_id, list_size;
-  const char       *exts;
+  int               list_id;
 
   pthread_mutex_lock (&catalog->lock);
 
-  /* calc length of output */
+  /* calc length of output string and create an array of strings to
+     concatenate */
+  size_t len = 0;
+  const int list_size = xine_sarray_size (catalog->plugin_lists[PLUGIN_DEMUX - 1]);
+  const char **extensions = calloc(list_size, sizeof(char*));
 
-  len = 0; 
-  list_size = xine_sarray_size (catalog->plugin_lists[PLUGIN_DEMUX - 1]);
   for (list_id = 0; list_id < list_size; list_id++) {
-    demux_class_t *cls;
-
-    node = xine_sarray_get (catalog->plugin_lists[PLUGIN_DEMUX - 1], list_id);
+    plugin_node_t *const node = xine_sarray_get (catalog->plugin_lists[PLUGIN_DEMUX - 1], list_id);
     if (node->plugin_class || _load_plugin_class(self, node, NULL)) {
-
-      cls = (demux_class_t *)node->plugin_class;
-
-      if( (exts = cls->extensions) && *exts )
-	len += strlen(exts) + 1;
+      demux_class_t *const cls = (demux_class_t *)node->plugin_class;
+      if( (extensions[list_id] = cls->extensions) != NULL )
+	len += strlen(extensions[list_id]) +1;
     }
   }
 
-  /* create output */
-  str = malloc (len); /* '\0' space is already counted in the previous loop */
-  pos = 0;
-
-  list_size = xine_sarray_size (catalog->plugin_lists[PLUGIN_DEMUX - 1]);
-  for (list_id = 0; list_id < list_size; list_id++) {
-    demux_class_t *cls;
-    int            l;
-    
-    node = xine_sarray_get (catalog->plugin_lists[PLUGIN_DEMUX - 1], list_id);
-    if (node->plugin_class || _load_plugin_class(self, node, NULL)) {
-
-      cls = (demux_class_t *)node->plugin_class;
-
-      if((exts = cls->extensions) && *exts) {
-	l = strlen(exts);
-	memcpy (&str[pos], exts, l);
-      
-	pos += l;
-
-	/* Don't add ' ' char at the end of str */
-	if((pos + 1) < len) {
-	  str[pos] = ' ';
-	  pos++;
-	}
-      }
-    }
-  }
-
-  str[pos] = 0;
+  /* create output string */
+  char *const result = _x_concatenate_with_string(extensions, list_size, " ", len);
+  free(extensions);
   
+  /* Drop the last whitespace */
+  result[len-1] = '\0';
+
   pthread_mutex_unlock (&catalog->lock);
 
-  return str;
+  return result;
 }
 
 /* get a list of mime types supported by xine
@@ -2631,60 +2623,34 @@ char *xine_get_file_extensions (xine_t *self) {
 char *xine_get_mime_types (xine_t *self) {
 
   plugin_catalog_t *catalog = self->plugin_catalog;
-  int               len, pos;
-  plugin_node_t    *node;
-  char             *str;
-  int               list_id, list_size;
+  int               list_id;
 
   pthread_mutex_lock (&catalog->lock);
 
   /* calc length of output */
 
-  len = 0;
-  list_size = xine_sarray_size (catalog->plugin_lists[PLUGIN_DEMUX - 1]);
+  /* calc length of output string and create an array of strings to
+     concatenate */
+  size_t len = 0; 
+  const int list_size = xine_sarray_size (catalog->plugin_lists[PLUGIN_DEMUX - 1]);
+  const char **mimetypes = calloc(list_size, sizeof(char*));
 
   for (list_id = 0; list_id < list_size; list_id++) {
-    demux_class_t *cls;
-
-    node = xine_sarray_get (catalog->plugin_lists[PLUGIN_DEMUX - 1], list_id);
+    plugin_node_t *const node = xine_sarray_get (catalog->plugin_lists[PLUGIN_DEMUX - 1], list_id);
     if (node->plugin_class || _load_plugin_class(self, node, NULL)) {
-
-      cls = (demux_class_t *)node->plugin_class;
-
-      if ( cls->mimetypes )
-	len += strlen(cls->mimetypes);
+      demux_class_t *const cls = (demux_class_t *)node->plugin_class;
+      if( (mimetypes[list_id] = cls->mimetypes) != NULL )
+	len += strlen(mimetypes[list_id]);
     }
   }
 
-  /* create output */
-
-  str = malloc (len+1);
-  pos = 0;
+  /* create output string */
+  char *const result = _x_concatenate_with_string(mimetypes, list_size, "", len);
+  free(mimetypes);
 
-  list_size = xine_sarray_size (catalog->plugin_lists[PLUGIN_DEMUX - 1]);
-
-  for (list_id = 0; list_id < list_size; list_id++) {
-    demux_class_t *cls;
-
-    node = xine_sarray_get (catalog->plugin_lists[PLUGIN_DEMUX - 1], list_id);
-    if (node->plugin_class || _load_plugin_class(self, node, NULL)) {
-
-      cls = (demux_class_t *)node->plugin_class;
-
-      if (cls->mimetypes) {
-	const size_t l = strlen(cls->mimetypes);
-	memcpy (&str[pos], cls->mimetypes, l);
-
-	pos += l;
-      }
-    }
-  }
-
-  str[pos] = 0;
-  
   pthread_mutex_unlock (&catalog->lock);
 
-  return str;
+  return result;
 }