opkg: adding the hash_table_remove API, not using yet.

Just complete the API for future usage.
Clean all the entry at initial time. This reduces planty of unnecessary check.
In order to prevent this kind of bug, using calloc to replace most malloc

git-svn-id: http://opkg.googlecode.com/svn/trunk@160 e8e0d7a0-c8d9-11dd-a880-a1081c7ac358

diff --git a/libopkg/file_util.c b/libopkg/file_util.c
index 6f249a2bc656a87654502f88def8116c9f6fe87b..fad4178901f8f9aa47961d2131acfeaa27501830 100644 (file)
--- a/libopkg/file_util.c
+++ b/libopkg/file_util.c
@@ -143,7 +143,7 @@ char *file_md5sum_alloc(const char *file_name)
     char *md5sum_hex;
     unsigned char md5sum_bin[md5sum_bin_len];
 
-    md5sum_hex = malloc(md5sum_hex_len + 1);
+    md5sum_hex = calloc(1, md5sum_hex_len + 1);
     if (md5sum_hex == NULL) {
        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
        return strdup("");

diff --git a/libopkg/hash_table.c b/libopkg/hash_table.c
index e7f5a926b1f80971324a65d94c937b0fcdab3605..713ecff605889eb349222319a9087002da5b7cdd 100644 (file)
--- a/libopkg/hash_table.c
+++ b/libopkg/hash_table.c
@@ -146,7 +146,7 @@ int hash_table_insert(hash_table_t *hash, const char *key, void *value)
                         return 0;
                     }
                }
-              hash_entry->next = (hash_entry_t *)malloc(sizeof(hash_entry_t));
+              hash_entry->next = (hash_entry_t *)calloc(1, sizeof(hash_entry_t));
               if (!hash_entry->next) {
                    return -ENOMEM;
               }
@@ -161,6 +161,37 @@ int hash_table_insert(hash_table_t *hash, const char *key, void *value)
      return 0;
 }
 
+int hash_table_remove(hash_table_t *hash, const char *key)
+{
+    int ndx= hash_index(hash, key);
+    hash_entry_t *hash_entry = hash->entries + ndx;
+    hash_entry_t *next_entry=NULL, *last_entry=NULL;
+    while (hash_entry) 
+    {
+        if (hash_entry->key) 
+        {
+            if (strcmp(key, hash_entry->key) == 0) {
+                free(hash_entry->key);
+                if (last_entry) {
+                    last_entry->next = hash_entry->next;
+                    free(hash_entry);
+                } else {
+                    next_entry = hash_entry->next;
+                    if (next_entry) {
+                        memmove(hash_entry, next_entry, sizeof(hash_entry_t));
+                        free(next_entry);
+                    } else {
+                        memset(hash_entry, 0 , sizeof(hash_entry_t));
+                    }
+                }
+                return 1;
+            }
+        }
+        last_entry = hash_entry;
+        hash_entry = hash_entry->next;
+    }
+    return 0;
+}
 
 void hash_table_foreach(hash_table_t *hash, void (*f)(const char *key, void *entry, void *data), void *data)
 { 

diff --git a/libopkg/hash_table.h b/libopkg/hash_table.h
index d4e8a3d78d38450bb85d7be6541c481c8f1ab706..c065609abbc3ff241db9bfe26597e5bafc7efbcb 100644 (file)
--- a/libopkg/hash_table.h
+++ b/libopkg/hash_table.h
@@ -39,6 +39,7 @@ int hash_table_init(const char *name, hash_table_t *hash, int len);
 void hash_table_deinit(hash_table_t *hash);
 void *hash_table_get(hash_table_t *hash, const char *key);
 int hash_table_insert(hash_table_t *hash, const char *key, void *value);
+int hash_table_remove(hash_table_t *has, const char *key);
 void hash_table_foreach(hash_table_t *hash, void (*f)(const char *key, void *entry, void *data), void *data);
 
 #endif /* _HASH_TABLE_H_ */

diff --git a/libopkg/nv_pair_list.c b/libopkg/nv_pair_list.c
index a3010e2b3b28b6eaff5a72582d5cfc92ed4e02f7..544d1e0ecd9048261f98a966ae426a54f9d33f0a 100644 (file)
--- a/libopkg/nv_pair_list.c
+++ b/libopkg/nv_pair_list.c
@@ -57,7 +57,7 @@ nv_pair_t *nv_pair_list_append(nv_pair_list_t *list, const char *name, const cha
     int err;
 
     /* freed in nv_pair_list_deinit */
-    nv_pair_t *nv_pair = malloc(sizeof(nv_pair_t));
+    nv_pair_t *nv_pair = calloc(1, sizeof(nv_pair_t));
 
     if (nv_pair == NULL) {
        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);

diff --git a/libopkg/opkg.c b/libopkg/opkg.c
index 7e6775552607a871cb971a5fbb147573d2adabb1..35ddb89bcebee341774dc75aac8cce4e67e409cc 100644 (file)
--- a/libopkg/opkg.c
+++ b/libopkg/opkg.c
@@ -163,8 +163,7 @@ opkg_package_new ()
 
   opkg_package_t *p;
 
-  p = malloc (sizeof (opkg_package_t));
-  memset (p, 0, sizeof (opkg_package_t));
+  p = calloc (1, sizeof (opkg_package_t));
 
   return p;
 }
@@ -189,9 +188,9 @@ opkg_new ()
   opkg_t *opkg;
   int err;
 
-  opkg = malloc (sizeof (opkg_t));
+  opkg = calloc (1, sizeof (opkg_t));
 
-  opkg->args = malloc (sizeof (args_t));
+  opkg->args = calloc (1, sizeof (args_t));
   err = args_init (opkg->args);
   if (err)
   {
@@ -200,7 +199,7 @@ opkg_new ()
     return NULL;
   }
 
-  opkg->conf = malloc (sizeof (opkg_conf_t));
+  opkg->conf = calloc (1, sizeof (opkg_conf_t));
   err = opkg_conf_init (opkg->conf, opkg->args);
   if (err)
   {

diff --git a/libopkg/opkg_cmd.c b/libopkg/opkg_cmd.c
index 8386fcea50091136b7a9818f8736952162b35b90..cf1cc5d80bc07f28661ac143365d4c4571129ab4 100644 (file)
--- a/libopkg/opkg_cmd.c
+++ b/libopkg/opkg_cmd.c
@@ -316,7 +316,7 @@ static opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf)
     char *newpath;
     int gen;
 
-    ctx = malloc (sizeof (*ctx));
+    ctx = calloc (1, sizeof (*ctx));
     oldpath = getenv ("PATH");
     if (oldpath) {
         ctx->oldpath = strdup (oldpath);
@@ -925,7 +925,7 @@ static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv)
         available = pkg_vec_alloc();
         pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
         for (i=0; i < argc; i++) {
-           pkg_name = malloc(strlen(argv[i])+2);
+           pkg_name = calloc(1, strlen(argv[i])+2);
            strcpy(pkg_name,argv[i]);
            for (a=0; a < available->len; a++) {
                pkg = available->pkgs[a];
@@ -1086,7 +1086,7 @@ static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
      size_t used_len;
      char *buff ;
 
-     buff = (char *)malloc(buff_len);
+     buff = (char *)calloc(1, buff_len);
      if ( buff == NULL ) {
         fprintf( stderr,"%s: Unable to allocate memory \n",__FUNCTION__);
         return ENOMEM;

diff --git a/libopkg/opkg_conf.c b/libopkg/opkg_conf.c
index 99db505c21d36fb1c1ee5dae219467b7c679300b..c29e4c2ae90cf94b003e542ba09ad7ecf9001b48 100644 (file)
--- a/libopkg/opkg_conf.c
+++ b/libopkg/opkg_conf.c
@@ -73,7 +73,7 @@ int opkg_init_options_array(const opkg_conf_t *conf, opkg_option_t **options)
          { NULL }
      };
 
-     *options = (opkg_option_t *)malloc(sizeof(tmp));
+     *options = (opkg_option_t *)calloc(1, sizeof(tmp));
      if ( options == NULL ){
         fprintf(stderr,"%s: Unable to allocate memory\n",__FUNCTION__);
         return -1;
@@ -182,7 +182,7 @@ int opkg_conf_init(opkg_conf_t *conf, const args_t *args)
             lists_dir = tmp;
      }
 
-     pending_dir = malloc(strlen(lists_dir)+strlen("/pending")+5);
+     pending_dir = calloc(1, strlen(lists_dir)+strlen("/pending")+5);
      snprintf(pending_dir,strlen(lists_dir)+strlen("/pending") ,"%s%s",lists_dir,"/pending");
 
      conf->lists_dir = strdup(lists_dir);

diff --git a/libopkg/opkg_install.c b/libopkg/opkg_install.c
index dc014d3cebec8c7797308ff497c24033e5b66b9e..01d5875ac549f2a49b3aaa66dbbabaec05b64386 100644 (file)
--- a/libopkg/opkg_install.c
+++ b/libopkg/opkg_install.c
@@ -597,7 +597,7 @@ static int pkg_remove_orphan_dependent(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old
         if (found)
             continue;
         d_str = old_pkg->depends_str[i];
-        buf = malloc (strlen (d_str) + 1);
+        buf = calloc (1, strlen (d_str) + 1);
         j=0;
         while (d_str[j] != '\0' && d_str[j] != ' ') {
             buf[j]=d_str[j];

diff --git a/libopkg/opkg_remove.c b/libopkg/opkg_remove.c
index 1debf21416f0bf6e3f3a0bd93b5227cde49fc5be..3edb6de5303535acabb3e0fb872544af04f98a0a 100644 (file)
--- a/libopkg/opkg_remove.c
+++ b/libopkg/opkg_remove.c
@@ -54,7 +54,7 @@ int pkg_has_installed_dependents(opkg_conf_t *conf, abstract_pkg_t *parent_apkg,
      /* if caller requested the set of installed dependents */
      if (pdependents) {
          int p = 0;
-         abstract_pkg_t **dependents = (abstract_pkg_t **)malloc((n_installed_dependents+1)*sizeof(abstract_pkg_t *));
+         abstract_pkg_t **dependents = (abstract_pkg_t **)calloc((n_installed_dependents+1), sizeof(abstract_pkg_t *));
 
           if ( dependents == NULL ){
               fprintf(stderr,"%s Unable to allocate memory. REPORT THIS BUG IN BUGZILLA PLEASE\n", __FUNCTION__);
@@ -181,7 +181,7 @@ static int remove_autoinstalled (opkg_conf_t *conf, pkg_t *pkg)
     int x = 0;
     pkg_t *p;
     d_str = pkg->depends_str[i];
-    buffer = malloc (strlen (d_str) + 1);
+    buffer = calloc (1, strlen (d_str) + 1);
     if (!buffer)
     {
       fprintf(stderr,"%s Unable to allocate memory.\n", __FUNCTION__);

diff --git a/libopkg/opkg_utils.c b/libopkg/opkg_utils.c
index de7712e8029a979647317704f495c522e8410663..6a827e063b65ee7c57316874eb346a55b33082b5 100644 (file)
--- a/libopkg/opkg_utils.c
+++ b/libopkg/opkg_utils.c
@@ -61,7 +61,7 @@ char **read_raw_pkgs_from_stream(FILE *fp)
      int count = 0;
      size_t size = 512;
      
-     buf = malloc (size);
+     buf = calloc (1, size);
 
      while (fgets(buf, size, fp)) {
          while (strlen (buf) == (size - 1)
@@ -96,7 +96,7 @@ char *trim_alloc(char *line)
      char *new; 
      char *dest, *src, *end;
     
-     new = malloc(strlen(line) + 1);
+     new = calloc(1, strlen(line) + 1);
      if ( new == NULL ){
         fprintf(stderr,"%s: Unable to allocate memory\n",__FUNCTION__);
         return NULL;
@@ -142,7 +142,7 @@ void push_error_list(struct errlist ** errors, char * msg){
   struct errlist *err_lst_tmp;
 
 
-  err_lst_tmp = malloc ( sizeof (err_lst_tmp) );
+  err_lst_tmp = calloc (1,  sizeof (err_lst_tmp) );
   err_lst_tmp->errmsg=strdup(msg) ;
   err_lst_tmp->next = *errors;
   *errors = err_lst_tmp;

diff --git a/libopkg/pkg.c b/libopkg/pkg.c
index cc15c9b62d30a1b408b4ae52cfaa0559613b6399..7ec34985b9c7af97ed2c7f64c7460effefbeca59 100644 (file)
--- a/libopkg/pkg.c
+++ b/libopkg/pkg.c
@@ -77,7 +77,7 @@ pkg_t *pkg_new(void)
 {
      pkg_t *pkg;
 
-     pkg = malloc(sizeof(pkg_t));
+     pkg = calloc(1, sizeof(pkg_t));
      if (pkg == NULL) {
          fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
          return NULL;
@@ -429,7 +429,7 @@ abstract_pkg_t *abstract_pkg_new(void)
 {
      abstract_pkg_t * ab_pkg;
 
-     ab_pkg = malloc(sizeof(abstract_pkg_t));
+     ab_pkg = calloc(1, sizeof(abstract_pkg_t));
 
      if (ab_pkg == NULL) {
          fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
@@ -461,7 +461,7 @@ void set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){
      char **raw =NULL;
      char **raw_start=NULL; 
 
-     temp_str = (char *) malloc (strlen(pkg->dest->info_dir)+strlen(pkg->name)+12);
+     temp_str = (char *) calloc (1, strlen(pkg->dest->info_dir)+strlen(pkg->name)+12);
      if (temp_str == NULL ){
         opkg_message(conf, OPKG_INFO, "Out of memory in  %s\n", __FUNCTION__);
         return;
@@ -497,7 +497,7 @@ char * pkg_formatted_info(pkg_t *pkg )
      char *line;
      char * buff;
 
-     buff = malloc(8192);
+     buff = calloc(1, 8192);
      if (buff == NULL) {
          fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
          return NULL;
@@ -1398,9 +1398,9 @@ int pkg_free_installed_files(pkg_t *pkg)
      str_list_elt_t *iter;
 
      pkg->installed_files_ref_cnt--;
-     if (pkg->installed_files_ref_cnt > 0) {
+
+     if (pkg->installed_files_ref_cnt > 0)
          return 0;
-     }
 
      if (pkg->installed_files) {
 

diff --git a/libopkg/pkg_depends.c b/libopkg/pkg_depends.c
index 49962ba5efeb957ada4b19e945daa6f0778252be..bbe786815b1ae9171dd490c8ce84803304931a6c 100644 (file)
--- a/libopkg/pkg_depends.c
+++ b/libopkg/pkg_depends.c
@@ -653,7 +653,7 @@ int buildProvides(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
     if (pkg->provides)
       return 0;
 
-    pkg->provides = (abstract_pkg_t **)malloc(sizeof(abstract_pkg_t *) * (pkg->provides_count + 1));
+    pkg->provides = (abstract_pkg_t **)calloc((pkg->provides_count + 1), sizeof(abstract_pkg_t *));
     if (pkg->provides == NULL) {
        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
        return -1 ;
@@ -683,8 +683,7 @@ int buildConflicts(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
     if (!pkg->conflicts_count)
        return 0;
 
-    conflicts = pkg->conflicts = malloc(sizeof(compound_depend_t) *
-                                       pkg->conflicts_count);
+    conflicts = pkg->conflicts = calloc(pkg->conflicts_count, sizeof(compound_depend_t));
     if (conflicts == NULL) {
        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
        return  -1;
@@ -705,7 +704,7 @@ int buildReplaces(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
      if (!pkg->replaces_count)
          return 0;
 
-     pkg->replaces = (abstract_pkg_t **)malloc(sizeof(abstract_pkg_t *) * pkg->replaces_count);
+     pkg->replaces = (abstract_pkg_t **)calloc(pkg->replaces_count, sizeof(abstract_pkg_t *));
      if (pkg->replaces == NULL) {
         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
         return  -1;
@@ -743,7 +742,7 @@ int buildDepends(hash_table_t * hash, pkg_t * pkg)
      if (0 && pkg->pre_depends_count)
          fprintf(stderr, "pkg=%s pre_depends_count=%d depends_count=%d\n", 
                  pkg->name, pkg->pre_depends_count, pkg->depends_count);
-     depends = pkg->depends = malloc(sizeof(compound_depend_t) * count);
+     depends = pkg->depends = calloc(count, sizeof(compound_depend_t));
      if (depends == NULL) {
         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
         return  -1;
@@ -878,7 +877,7 @@ void buildDependedUponBy(pkg_t * pkg, abstract_pkg_t * ab_pkg)
 
 static depend_t * depend_init(void)
 {
-    depend_t * d = (depend_t *)malloc(sizeof(depend_t));    
+    depend_t * d = (depend_t *)calloc(1, sizeof(depend_t));    
     if ( d==NULL ){
         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
         return NULL; 
@@ -913,7 +912,7 @@ static int parseDepends(compound_depend_t *compound_depend,
      compound_depend->type = DEPEND;
 
      compound_depend->possibility_count = num_of_ors + 1;
-     possibilities = (depend_t **)malloc(sizeof(depend_t *) * (num_of_ors + 1));
+     possibilities = (depend_t **)calloc((num_of_ors + 1), sizeof(depend_t *) );
      if (!possibilities)
          return -ENOMEM;
      compound_depend->possibilities = possibilities;

diff --git a/libopkg/pkg_dest_list.c b/libopkg/pkg_dest_list.c
index ac693120f858d57fab60be49c4c1dcddfc4af280..48ca07fa771f3dd64cb9877522e06de3a149b0cd 100644 (file)
--- a/libopkg/pkg_dest_list.c
+++ b/libopkg/pkg_dest_list.c
@@ -59,7 +59,7 @@ pkg_dest_t *pkg_dest_list_append(pkg_dest_list_t *list, const char *name,
     pkg_dest_t *pkg_dest;
 
     /* freed in plg_dest_list_deinit */
-    pkg_dest = malloc(sizeof(pkg_dest_t));
+    pkg_dest = calloc(1, sizeof(pkg_dest_t));
     if (pkg_dest == NULL) {
        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
        return NULL;

diff --git a/libopkg/pkg_parse.c b/libopkg/pkg_parse.c
index af5ead76dd9671e5872983efc06d642b9f7d9eab..76cd6489119e601590f1182443516d3550ed39c6 100644 (file)
--- a/libopkg/pkg_parse.c
+++ b/libopkg/pkg_parse.c
@@ -141,7 +141,7 @@ int parseVersion(pkg_t *pkg, char *raw)
 
   if (!pkg->version)
   {
-  pkg->version= malloc(strlen(raw)+1);
+  pkg->version= calloc(1, strlen(raw)+1);
   if ( pkg->version == NULL ) {
      fprintf(stderr, "%s: out of memory \n", __FUNCTION__);
      return ENOMEM;
@@ -230,7 +230,7 @@ int pkg_parse_raw(pkg_t *pkg, char ***raw, pkg_src_t *src, pkg_dest_t *dest)
                pkg->priority = parseGenericFieldType("Priority", *lines);
            else if(isGenericFieldType("Provides", *lines)){
 /* Here we add the internal_use to align the off by one problem between provides_str and provides */
-               provide = (char * ) malloc(strlen(*lines)+ 35 ); /* Preparing the space for the new opkg_internal_use_only */
+               provide = (char * ) calloc(1, strlen(*lines)+ 35 ); /* Preparing the space for the new opkg_internal_use_only */
                if ( alterProvidesLine(*lines,provide) ){
                    return EINVAL;
                }
@@ -373,7 +373,7 @@ out:;
     if ( pkg_false_provides==1)
     {
        pkg->provides_count = 1;
-       pkg->provides_str = malloc (sizeof (char*));
+       pkg->provides_str = calloc (1, sizeof (char*));
        pkg->provides_str[0] = strdup ("opkg_internal_use_only");
     }
 

diff --git a/libopkg/pkg_src_list.c b/libopkg/pkg_src_list.c
index 4f07ca4be5c1d4d3225861187f0054fcb4c71d38..c9f02f1a2cec5b6cc234f2b7defaf3b35666000a 100644 (file)
--- a/libopkg/pkg_src_list.c
+++ b/libopkg/pkg_src_list.c
@@ -48,7 +48,7 @@ pkg_src_t *pkg_src_list_append(pkg_src_list_t *list,
     int err;
 
     /* freed in pkg_src_list_deinit */
-    pkg_src_t *pkg_src = malloc(sizeof(pkg_src_t));
+    pkg_src_t *pkg_src = calloc(1, sizeof(pkg_src_t));
 
     if (pkg_src == NULL) {
        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);

diff --git a/libopkg/pkg_vec.c b/libopkg/pkg_vec.c
index 2c1bcf9aa5acef92fcb57b8cc03870e93fd75607..56e29bc50a1f7721ca8db155d0c7b5343b55ec26 100644 (file)
--- a/libopkg/pkg_vec.c
+++ b/libopkg/pkg_vec.c
@@ -185,12 +185,9 @@ void abstract_pkg_vec_free(abstract_pkg_vec_t *vec)
  */
 void abstract_pkg_vec_insert(abstract_pkg_vec_t *vec, abstract_pkg_t *pkg)
 {
-
-       vec->pkgs = 
-         (abstract_pkg_t **)
-           realloc(vec->pkgs, (vec->len + 1) * sizeof(abstract_pkg_t *));
-       vec->pkgs[vec->len] = pkg;
-       vec->len++;
+    vec->pkgs = (abstract_pkg_t **) realloc(vec->pkgs, (vec->len + 1) * sizeof(abstract_pkg_t *));
+    vec->pkgs[vec->len] = pkg;
+    vec->len++;
 }
 
 abstract_pkg_t * abstract_pkg_vec_get(abstract_pkg_vec_t *vec, int i)

diff --git a/libopkg/sprintf_alloc.c b/libopkg/sprintf_alloc.c
index 8c669949670502d9852084a5a64bf12bae5d7408..30ab033d257dabc8f378125f853f1ed4039da8ca 100644 (file)
--- a/libopkg/sprintf_alloc.c
+++ b/libopkg/sprintf_alloc.c
@@ -44,7 +44,7 @@ int sprintf_alloc(char **str, const char *fmt, ...)
 
     /* ripped more or less straight out of PRINTF(3) */
 
-    if ((new_str = malloc(size)) == NULL) 
+    if ((new_str = calloc(1, size)) == NULL) 
       return -1;
 
     *str = new_str;

diff --git a/libopkg/str_list.c b/libopkg/str_list.c
index d6f9209e02171eaebc848bd31c5f347e5e371292..1d217469ca6218607f448cb321b4869857aa5aa2 100644 (file)
--- a/libopkg/str_list.c
+++ b/libopkg/str_list.c
@@ -31,7 +31,7 @@ void str_list_elt_deinit(str_list_elt_t *elt)
 
 str_list_t *str_list_alloc()
 {
-     str_list_t *list = (str_list_t *)malloc(sizeof(str_list_t));
+     str_list_t *list = (str_list_t *)calloc(1, sizeof(str_list_t));
      if (list)
          str_list_init(list);
      return list;

diff --git a/libopkg/void_list.c b/libopkg/void_list.c
index 8d61fbb1c8fbeae46eb3b65e10611d7020e2b6cb..3d9d6112347ec922f9d9a8ece4b63c149f56367b 100644 (file)
--- a/libopkg/void_list.c
+++ b/libopkg/void_list.c
@@ -60,7 +60,7 @@ int void_list_append(void_list_t *list, void *data)
     void_list_elt_t *elt;
 
     /* freed in void_list_deinit */
-    elt = malloc(sizeof(void_list_elt_t));
+    elt = calloc(1, sizeof(void_list_elt_t));
     if (elt == NULL) {
        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
        return ENOMEM;
@@ -84,7 +84,7 @@ int void_list_push(void_list_t *list, void *data)
 {
     void_list_elt_t *elt;
 
-    elt = malloc(sizeof(void_list_elt_t));
+    elt = calloc(1, sizeof(void_list_elt_t));
     if (elt == NULL) {
        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
        return ENOMEM;

diff --git a/libopkg/xregex.c b/libopkg/xregex.c
index 0ae54e73ae6fd2434f7449499f0f89a0d93e144a..b0cd8b9cd9e8bcfef2072de0e01573e529c0db0c 100644 (file)
--- a/libopkg/xregex.c
+++ b/libopkg/xregex.c
@@ -39,7 +39,7 @@ static void print_regcomp_err(const regex_t *preg, int err)
     
     fprintf(stderr, "%s: Error compiling regex:", __FUNCTION__);
     size = regerror(err, preg, 0, 0);
-    error = malloc(size);
+    error = calloc(1, size);
     if (error) {
        regerror(err, preg, error, size);
        fprintf(stderr, "%s\n", error);