Changeset 150 for trunk


Ignore:
Timestamp:
03/01/09 21:17:46 (16 years ago)
Author:
tim
Message:

integrated talloc into most of the rest of the regfi library
fixed a length validation issue

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/regfi.h

    r149 r150  
    224224
    225225
    226 /* Key Value */
     226/* Value record */
    227227typedef struct
    228228{
    … …  
    230230  uint32 cell_size;     /* ((start_offset - end_offset) & 0xfffffff8) */
    231231
    232   REGFI_HBIN* hbin;     /* pointer to HBIN record (in memory) containing
    233                          * this nk record
    234                          */
    235232  uint8* data;
     233  char*  valuename;
    236234  uint16 name_length;
    237   char*  valuename;
    238235  uint32 hbin_off;      /* offset from beginning of this hbin block */
    239236 
    … …  
    420417const REGFI_NK_REC*   regfi_iterator_cur_key(REGFI_ITERATOR* i);
    421418const REGFI_SK_REC*   regfi_iterator_cur_sk(REGFI_ITERATOR* i);
    422 const REGFI_NK_REC*   regfi_iterator_first_subkey(REGFI_ITERATOR* i);
    423 const REGFI_NK_REC*   regfi_iterator_cur_subkey(REGFI_ITERATOR* i);
    424 const REGFI_NK_REC*   regfi_iterator_next_subkey(REGFI_ITERATOR* i);
     419
     420REGFI_NK_REC*         regfi_iterator_first_subkey(REGFI_ITERATOR* i);
     421REGFI_NK_REC*         regfi_iterator_cur_subkey(REGFI_ITERATOR* i);
     422REGFI_NK_REC*         regfi_iterator_next_subkey(REGFI_ITERATOR* i);
    425423
    426424bool                  regfi_iterator_find_value(REGFI_ITERATOR* i,
    427425                                                const char* value_name);
    428 const REGFI_VK_REC*   regfi_iterator_first_value(REGFI_ITERATOR* i);
    429 const REGFI_VK_REC*   regfi_iterator_cur_value(REGFI_ITERATOR* i);
    430 const REGFI_VK_REC*   regfi_iterator_next_value(REGFI_ITERATOR* i);
     426REGFI_VK_REC*         regfi_iterator_first_value(REGFI_ITERATOR* i);
     427REGFI_VK_REC*         regfi_iterator_cur_value(REGFI_ITERATOR* i);
     428REGFI_VK_REC*         regfi_iterator_next_value(REGFI_ITERATOR* i);
    431429
    432430
    … …  
    471469 *   A newly allocated NK record structure, or NULL on failure.
    472470 */
    473 REGFI_NK_REC*         regfi_parse_nk(REGFI_FILE* file, uint32 offset, 
     471REGFI_NK_REC*         regfi_parse_nk(REGFI_FILE* file, uint32 offset,
    474472                                     uint32 max_size, bool strict);
    475473
    … …  
    498496                                            uint32 max_size, bool strict);
    499497
     498/* Dispose of previously parsed records */
     499void                  regfi_free_key(REGFI_NK_REC* nk);
     500void                  regfi_free_value(REGFI_VK_REC* vk);
     501
     502
    500503
    501504/************************************/
    … …  
    503506/************************************/
    504507REGFI_NK_REC*         regfi_rootkey(REGFI_FILE* file);
    505 void                  regfi_key_free(REGFI_NK_REC* nk);
    506508void                  regfi_subkeylist_free(REGFI_SUBKEY_LIST* list);
    507509uint32                regfi_read(int fd, uint8* buf, uint32* length);

  • trunk/include/void_stack.h

    r111 r150  
    11/*
    2  * Copyright (C) 2005,2007 Timothy D. Morgan
     2 * Copyright (C) 2005,2007,2009 Timothy D. Morgan
    33 *
    44 * This program is free software; you can redistribute it and/or modify
    … …  
    1818 */
    1919
     20#ifndef _VOID_STACK_H
     21#define _VOID_STACK_H
     22
    2023#include <stdlib.h>
    2124#include <stdbool.h>
    2225#include <string.h>
    23 
    24 #ifndef _VOID_STACK_H
    25 #define _VOID_STACK_H
     26#include "talloc.h"
    2627
    2728typedef struct _void_stack

  • trunk/lib/range_list.c

    r148 r150  
    143143void range_list_free(range_list* rl)
    144144{
    145   if(rl == NULL)
    146     return;
    147 
    148   talloc_free(rl);
     145  if(rl != NULL)
     146    talloc_free(rl);
    149147}
    150148

  • trunk/lib/regfi.c

    r148 r150  
    560560  {
    561561    num_sublists = ret_val->num_children;
    562     sublists = (REGFI_SUBKEY_LIST**)zalloc(num_sublists
     562    sublists = (REGFI_SUBKEY_LIST**)malloc(num_sublists
    563563                                           * sizeof(REGFI_SUBKEY_LIST*));
    564564    for(i=0; i < num_sublists; i++)
    … …  
    575575      }
    576576    }
    577     free(ret_val);
     577    talloc_free(ret_val);
    578578
    579579    return regfi_merge_subkeylists(num_sublists, sublists, strict);
    … …  
    590590{
    591591  REGFI_SUBKEY_LIST* ret_val;
    592   uint32 i, cell_length, length, elem_size;
    593   uint8* elements;
     592  uint32 i, cell_length, length, elem_size, read_len;
     593  uint8* elements = NULL;
    594594  uint8 buf[REGFI_SUBKEY_LIST_MIN_LEN];
    595595  bool unalloc;
    … …  
    631631  }
    632632
    633   ret_val = (REGFI_SUBKEY_LIST*)zalloc(sizeof(REGFI_SUBKEY_LIST));
     633  ret_val = talloc(NULL, REGFI_SUBKEY_LIST);
    634634  if(ret_val == NULL)
    635635    return NULL;
    … …  
    652652                      offset);
    653653    if(strict)
    654     {
    655       free(ret_val);
    656       return NULL;
    657     }
     654      goto fail;
    658655    length = cell_length - REGFI_SUBKEY_LIST_MIN_LEN - sizeof(uint32);
    659656  }
    660657
    661   ret_val->elements
    662     = (REGFI_SUBKEY_LIST_ELEM*)zalloc(ret_val->num_children
    663                                       * sizeof(REGFI_SUBKEY_LIST_ELEM));
     658  ret_val->elements = talloc_array(ret_val, REGFI_SUBKEY_LIST_ELEM,
     659                                   ret_val->num_children);
    664660  if(ret_val->elements == NULL)
    665   {
    666     free(ret_val);
    667     return NULL;
    668   }
    669 
    670   elements = (uint8*)zalloc(length);
     661    goto fail;
     662
     663  elements = (uint8*)malloc(length);
    671664  if(elements == NULL)
    672   {
    673     free(ret_val->elements);
    674     free(ret_val);
    675     return NULL;
    676   }
    677 
    678   if(regfi_read(file->fd, elements, &length) != 0
    679      || length != elem_size*ret_val->num_children)
    680   {
    681     free(ret_val->elements);
    682     free(ret_val);
    683     return NULL;
    684   }
     665    goto fail;
     666
     667  read_len = length;
     668  if(regfi_read(file->fd, elements, &read_len) != 0 || read_len != length)
     669    goto fail;
    685670
    686671  if(elem_size == sizeof(uint32))
    … …  
    703688
    704689  return ret_val;
     690
     691 fail:
     692  if(elements != NULL)
     693    free(elements);
     694  talloc_free(ret_val);
     695  return NULL;
    705696}
    706697
    … …  
    717708  if(lists == NULL)
    718709    return NULL;
    719   ret_val = (REGFI_SUBKEY_LIST*)zalloc(sizeof(REGFI_SUBKEY_LIST));
     710  ret_val = talloc(NULL, REGFI_SUBKEY_LIST);
    720711
    721712  if(ret_val == NULL)
    … …  
    733724  if(ret_val->num_keys > 0)
    734725  {
    735     ret_val->elements =
    736       (REGFI_SUBKEY_LIST_ELEM*)zalloc(sizeof(REGFI_SUBKEY_LIST_ELEM)
    737                                      * ret_val->num_keys);
     726    ret_val->elements = talloc_array(ret_val, REGFI_SUBKEY_LIST_ELEM,
     727                                     ret_val->num_keys);
    738728    k=0;
    739729
    … …  
    746736          for(j=0; j < lists[i]->num_keys; j++)
    747737          {
    748             ret_val->elements[k].hash=lists[i]->elements[j].hash;
    749             ret_val->elements[k++].offset=lists[i]->elements[j].offset;
     738            ret_val->elements[k].hash = lists[i]->elements[j].hash;
     739            ret_val->elements[k++].offset = lists[i]->elements[j].offset;
    750740          }
    751741        }
    … …  
    789779  }
    790780
    791   /*  ret_val = (REGFI_SK_REC*)zalloc(sizeof(REGFI_SK_REC));*/
    792781  ret_val = talloc(NULL, REGFI_SK_REC);
    793782  if(ret_val == NULL)
    … …  
    903892
    904893  read_len = num_values*sizeof(uint32);
    905   ret_val = (REGFI_VALUE_LIST*)malloc(sizeof(REGFI_VALUE_LIST));
     894  ret_val = talloc(NULL, REGFI_VALUE_LIST);
    906895  if(ret_val == NULL)
    907896    return NULL;
    908897
    909   ret_val->elements = (REGFI_VALUE_LIST_ELEM*)malloc(read_len);
     898  ret_val->elements = (REGFI_VALUE_LIST_ELEM*)talloc_size(ret_val, read_len);
    910899  if(ret_val->elements == NULL)
    911900  {
    912     free(ret_val);
     901    talloc_free(ret_val);
    913902    return NULL;
    914903  }
    … …  
    921910    regfi_add_message(file, REGFI_MSG_ERROR, "Failed to read value pointers"
    922911                      " while parsing value list at offset 0x%.8X.", offset);
    923     free(ret_val->elements);
    924     free(ret_val);
     912    talloc_free(ret_val);
    925913    return NULL;
    926914  }
    … …  
    942930                          " (0x%.8X) found while parsing value list at offset"
    943931                          " 0x%.8X.", ret_val->elements[i], offset);
    944         free(ret_val->elements);
    945         free(ret_val);
     932        talloc_free(ret_val);
    946933        return NULL;
    947934      }
    … …  
    956943/******************************************************************************
    957944 ******************************************************************************/
    958 REGFI_VK_REC* regfi_load_value(REGFI_FILE* file, uint32 offset,
    959                                bool strict)
     945REGFI_VK_REC* regfi_load_value(REGFI_FILE* file, uint32 offset, bool strict)
    960946{
    961947  REGFI_VK_REC* ret_val = NULL;
    … …  
    1009995                        ret_val->offset);
    1010996    }
     997    else
     998      talloc_steal(ret_val, ret_val->data);
    1011999  }
    10121000
    … …  
    10761064      if(strict)
    10771065      {
    1078         free(nk);
     1066        regfi_free_key(nk);
    10791067        return NULL;
    10801068      }
    … …  
    10951083        if(strict)
    10961084        {
    1097           free(nk);
     1085          regfi_free_key(nk);
    10981086          return NULL;
    10991087        }
    11001088      }
     1089      talloc_steal(nk, nk->values);
    11011090    }
    11021091  }
    … …  
    11091098      sub_hbin = regfi_lookup_hbin(file, nk->subkeys_off);
    11101099
    1111     if (sub_hbin == NULL)
     1100    if(sub_hbin == NULL)
    11121101    {
    11131102      if(strict)
    11141103      {
    1115         regfi_key_free(nk);
     1104        regfi_free_key(nk);
    11161105        return NULL;
    11171106      }
    … …  
    11321121        nk->num_subkeys = 0;
    11331122      }
     1123      talloc_steal(nk, nk->subkeys);
    11341124    }
    11351125  }
    … …  
    12141204          *root_offset = nk->offset;
    12151205        }
    1216         free(nk);
     1206        regfi_free_key(nk);
    12171207      }
    12181208    }
    … …  
    12671257  {
    12681258    /* fprintf(stderr, "regfi_open: Failed to create HBIN list.\n"); */
    1269     range_list_free(rb->hbins);
    12701259    close(fd);
    1271     free(rb);
    1272     return NULL;
    1273   }
    1274  
     1260    talloc_free(rb);
     1261    return NULL;
     1262  }
     1263  talloc_steal(rb, rb->hbins);
     1264
    12751265  rla = true;
    12761266  hbin_off = REGFI_REGF_SIZE;
    … …  
    12921282
    12931283  /* Cache an unlimited number of SK records.  Typically there are very few. */
    1294   rb->sk_cache = lru_cache_create_ctx(NULL, 0, cache_secret, true);
     1284  rb->sk_cache = lru_cache_create_ctx(rb, 0, cache_secret, true);
    12951285
    12961286  /* Default message mask */
    … …  
    13201310    lru_cache_destroy(file->sk_cache);
    13211311
    1322   free(file);
     1312  talloc_free(file);
    13231313  return close(fd);
    13241314}
    … …  
    13611351/******************************************************************************
    13621352 *****************************************************************************/
    1363 void regfi_key_free(REGFI_NK_REC* nk)
    1364 {
    1365   if((nk->values != NULL) && (nk->values_off!=REGFI_OFFSET_NONE))
    1366   {
    1367     if(nk->values->elements != NULL)
    1368       free(nk->values->elements);
    1369     free(nk->values);
    1370   }
    1371 
     1353void regfi_free_key(REGFI_NK_REC* nk)
     1354{
    13721355  regfi_subkeylist_free(nk->subkeys);
    1373 
    1374   if(nk->keyname != NULL)
    1375     free(nk->keyname);
    1376   if(nk->classname != NULL)
    1377     free(nk->classname);
    1378 
    1379   /* XXX: not freeing sec_desc because these are cached.  This needs to be reviewed. */
    1380   free(nk);
     1356  talloc_free(nk);
     1357}
     1358
     1359
     1360/******************************************************************************
     1361 *****************************************************************************/
     1362void regfi_free_value(REGFI_VK_REC* vk)
     1363{
     1364  talloc_free(vk);
    13811365}
    13821366
    … …  
    13881372  if(list != NULL)
    13891373  {
    1390     free(list->elements);
    1391     free(list);
     1374    talloc_free(list);
    13921375  }
    13931376}
    … …  
    13991382{
    14001383  REGFI_NK_REC* root;
    1401   REGFI_ITERATOR* ret_val = (REGFI_ITERATOR*)malloc(sizeof(REGFI_ITERATOR));
     1384  REGFI_ITERATOR* ret_val = talloc(NULL, REGFI_ITERATOR);
    14021385  if(ret_val == NULL)
    14031386    return NULL;
    … …  
    14061389  if(root == NULL)
    14071390  {
    1408     free(ret_val);
     1391    talloc_free(ret_val);
    14091392    return NULL;
    14101393  }
    … …  
    14131396  if(ret_val->key_positions == NULL)
    14141397  {
    1415     free(ret_val);
    1416     return NULL;
    1417   }
     1398    talloc_free(ret_val);
     1399    return NULL;
     1400  }
     1401  talloc_steal(ret_val, ret_val->key_positions);
    14181402
    14191403  ret_val->f = fh;
    … …  
    14301414void regfi_iterator_free(REGFI_ITERATOR* i)
    14311415{
    1432   REGFI_ITER_POSITION* cur;
    1433 
    1434   if(i->cur_key != NULL)
    1435     regfi_key_free(i->cur_key);
    1436 
    1437   while((cur = (REGFI_ITER_POSITION*)void_stack_pop(i->key_positions)) != NULL)
    1438   {
    1439     regfi_key_free(cur->nk);
    1440     free(cur);
    1441   }
    1442  
    1443   void_stack_free(i->key_positions);
    1444   free(i);
     1416  talloc_free(i);
    14451417}
    14461418
    … …  
    14551427  REGFI_ITER_POSITION* pos;
    14561428
    1457   pos = (REGFI_ITER_POSITION*)malloc(sizeof(REGFI_ITER_POSITION));
     1429  pos = talloc(i->key_positions, REGFI_ITER_POSITION);
    14581430  if(pos == NULL)
    14591431    return false;
    … …  
    14621434  if(subkey == NULL)
    14631435  {
    1464     free(pos);
     1436    talloc_free(pos);
    14651437    return false;
    14661438  }
    … …  
    14701442  if(!void_stack_push(i->key_positions, pos))
    14711443  {
    1472     free(pos);
    1473     regfi_key_free(subkey);
     1444    talloc_free(pos);
     1445    regfi_free_key(subkey);
    14741446    return false;
    14751447  }
     1448  talloc_steal(i, subkey);
    14761449
    14771450  i->cur_key = subkey;
    … …  
    14931466    return false;
    14941467
    1495   regfi_key_free(i->cur_key);
     1468  regfi_free_key(i->cur_key);
    14961469  i->cur_key = pos->nk;
    14971470  i->cur_subkey = pos->cur_subkey;
    14981471  i->cur_value = 0;
    1499   free(pos);
     1472  talloc_free(pos);
    15001473
    15011474  return true;
    … …  
    15341507    else
    15351508    {
    1536       regfi_key_free(subkey);
     1509      regfi_free_key(subkey);
    15371510      subkey = (REGFI_NK_REC*)regfi_iterator_next_subkey(i);
    15381511    }
    … …  
    15451518  }
    15461519
    1547   regfi_key_free(subkey);
     1520  regfi_free_key(subkey);
    15481521  return true;
    15491522}
    … …  
    15961569/******************************************************************************
    15971570 *****************************************************************************/
    1598 const REGFI_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
     1571REGFI_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
    15991572{
    16001573  i->cur_subkey = 0;
    … …  
    16051578/******************************************************************************
    16061579 *****************************************************************************/
    1607 const REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
     1580REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
    16081581{
    16091582  uint32 nk_offset;
    … …  
    16231596 *****************************************************************************/
    16241597/* XXX: some way of indicating reason for failure should be added. */
    1625 const REGFI_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i)
    1626 {
    1627   const REGFI_NK_REC* subkey;
     1598REGFI_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i)
     1599{
     1600  REGFI_NK_REC* subkey;
    16281601
    16291602  i->cur_subkey++;
    … …  
    16411614bool regfi_iterator_find_value(REGFI_ITERATOR* i, const char* value_name)
    16421615{
    1643   const REGFI_VK_REC* cur;
     1616  REGFI_VK_REC* cur;
    16441617  bool found = false;
    16451618
    … …  
    16571630      found = true;
    16581631    else
     1632    {
     1633      regfi_free_value(cur);
    16591634      cur = regfi_iterator_next_value(i);
     1635    }
    16601636  }
    16611637
    … …  
    16661642/******************************************************************************
    16671643 *****************************************************************************/
    1668 const REGFI_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i)
     1644REGFI_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i)
    16691645{
    16701646  i->cur_value = 0;
    … …  
    16751651/******************************************************************************
    16761652 *****************************************************************************/
    1677 const REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
    1678 {
    1679   const REGFI_VK_REC* ret_val = NULL;
     1653REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
     1654{
     1655  REGFI_VK_REC* ret_val = NULL;
    16801656  uint32 voffset;
    16811657
    … …  
    16951671/******************************************************************************
    16961672 *****************************************************************************/
    1697 const REGFI_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i)
    1698 {
    1699   const REGFI_VK_REC* ret_val;
     1673REGFI_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i)
     1674{
     1675  REGFI_VK_REC* ret_val;
    17001676
    17011677  i->cur_value++;
    … …  
    17391715  REGFI_FILE* ret_val;
    17401716
    1741   ret_val = (REGFI_FILE*)zalloc(sizeof(REGFI_FILE));
     1717  ret_val = talloc(NULL, REGFI_FILE);
    17421718  if(ret_val == NULL)
    17431719    return NULL;
    17441720
    17451721  ret_val->fd = fd;
    1746 
     1722  ret_val->sk_cache = NULL;
     1723  ret_val->last_message = NULL;
     1724  ret_val->hbins = NULL;
     1725 
    17471726  length = REGFI_REGF_SIZE;
    1748   if((regfi_read(fd, file_header, &length)) != 0
    1749      || length != REGFI_REGF_SIZE)
    1750   {
    1751     free(ret_val);
    1752     return NULL;
    1753   }
    1754 
     1727  if((regfi_read(fd, file_header, &length)) != 0 || length != REGFI_REGF_SIZE)
     1728    goto fail;
     1729 
    17551730  ret_val->checksum = IVAL(file_header, 0x1FC);
    17561731  ret_val->computed_checksum = regfi_compute_header_checksum(file_header);
    17571732  if (strict && (ret_val->checksum != ret_val->computed_checksum))
    1758   {
    1759     free(ret_val);
    1760     return NULL;
    1761   }
     1733    goto fail;
    17621734
    17631735  memcpy(ret_val->magic, file_header, REGFI_REGF_MAGIC_SIZE);
    1764   if(strict && (memcmp(ret_val->magic, "regf", REGFI_REGF_MAGIC_SIZE) != 0))
    1765   {
    1766     free(ret_val);
    1767     return NULL;
     1736  if(memcmp(ret_val->magic, "regf", REGFI_REGF_MAGIC_SIZE) != 0)
     1737  {
     1738    if(strict)
     1739      goto fail;
     1740    regfi_add_message(ret_val, REGFI_MSG_WARN, "Magic number mismatch "
     1741                      "(%.2X %.2X %.2X %.2X) while parsing hive header",
     1742                      ret_val->magic[0],ret_val->magic[1],
     1743                      ret_val->magic[2], ret_val->magic[3]);
    17681744  }
    17691745 
    … …  
    17851761
    17861762  return ret_val;
     1763
     1764 fail:
     1765  talloc_free(ret_val);
     1766  return NULL;
    17871767}
    17881768
    … …  
    18911871  }
    18921872
    1893   ret_val = (REGFI_NK_REC*)zalloc(sizeof(REGFI_NK_REC));
     1873  ret_val = talloc(NULL, REGFI_NK_REC);
    18941874  if(ret_val == NULL)
    18951875  {
    … …  
    18991879  }
    19001880
     1881  ret_val->values = NULL;
     1882  ret_val->subkeys = NULL;
    19011883  ret_val->offset = offset;
    19021884  ret_val->cell_size = cell_length;
    … …  
    19091891    regfi_add_message(file, REGFI_MSG_WARN, "A length check failed while"
    19101892                      " parsing NK record at offset 0x%.8X.", offset);
    1911     free(ret_val);
     1893    talloc_free(ret_val);
    19121894    return NULL;
    19131895  }
    … …  
    19691951      regfi_add_message(file, REGFI_MSG_ERROR, "Contents too large for cell"
    19701952                        " while parsing NK record at offset 0x%.8X.", offset);
    1971       free(ret_val);
     1953      talloc_free(ret_val);
    19721954      return NULL;
    19731955    }
    … …  
    19871969  }
    19881970
    1989   ret_val->keyname = (char*)zalloc(sizeof(char)*(ret_val->name_length+1));
     1971  ret_val->keyname = talloc_array(ret_val, char, ret_val->name_length+1);
    19901972  if(ret_val->keyname == NULL)
    19911973  {
    1992     free(ret_val);
     1974    talloc_free(ret_val);
    19931975    return NULL;
    19941976  }
    … …  
    20011983    regfi_add_message(file, REGFI_MSG_ERROR, "Failed to read key name"
    20021984                      " while parsing NK record at offset 0x%.8X.", offset);
    2003     free(ret_val->keyname);
    2004     free(ret_val);
     1985    talloc_free(ret_val);
    20051986    return NULL;
    20061987  }
    20071988  ret_val->keyname[ret_val->name_length] = '\0';
    20081989
     1990  /* XXX: This linking should be moved up to regfi_load_key */
    20091991  if(ret_val->classname_off != REGFI_OFFSET_NONE)
    20101992  {
    … …  
    20312013                        " name while parsing NK record at offset 0x%.8X.",
    20322014                        offset);
    2033       return NULL;
    2034     }
     2015    }
     2016    else
     2017      talloc_steal(ret_val, ret_val->classname);
    20352018  }
    20362019
    … …  
    20842067    }
    20852068   
    2086     ret_val = (char*)zalloc(*name_length);
     2069    ret_val = talloc_array(NULL, char, *name_length);
    20872070    if(ret_val != NULL)
    20882071    {
    … …  
    20932076        regfi_add_message(file, REGFI_MSG_ERROR, "Could not read class name"
    20942077                          " while parsing class name at offset 0x%.8X.", offset);
    2095         free(ret_val);
     2078        talloc_free(ret_val);
    20962079        return NULL;
    20972080      }
    … …  
    21212104  }
    21222105
    2123   ret_val = (REGFI_VK_REC*)zalloc(sizeof(REGFI_VK_REC));
     2106  ret_val = talloc(NULL, REGFI_VK_REC);
    21242107  if(ret_val == NULL)
    21252108    return NULL;
    … …  
    21272110  ret_val->offset = offset;
    21282111  ret_val->cell_size = cell_length;
    2129 
     2112  ret_val->data = NULL;
     2113  ret_val->valuename = NULL;
     2114 
    21302115  if(ret_val->cell_size > max_size)
    21312116    ret_val->cell_size = max_size & 0xFFFFFFF8;
    … …  
    21352120    regfi_add_message(file, REGFI_MSG_WARN, "Invalid cell size encountered"
    21362121                      " while parsing VK record at offset 0x%.8X.", offset);
    2137     free(ret_val);
     2122    talloc_free(ret_val);
    21382123    return NULL;
    21392124  }
    … …  
    21492134    regfi_add_message(file, REGFI_MSG_WARN, "Magic number mismatch"
    21502135                      " while parsing VK record at offset 0x%.8X.", offset);
    2151     free(ret_val);
     2136    talloc_free(ret_val);
    21522137    return NULL;
    21532138  }
    … …  
    21712156      if(strict)
    21722157      {
    2173         free(ret_val);
     2158        talloc_free(ret_val);
    21742159        return NULL;
    21752160      }
    … …  
    21832168      cell_length+=8;
    21842169
    2185     ret_val->valuename = (char*)zalloc(sizeof(char)*(ret_val->name_length+1));
     2170    ret_val->valuename = talloc_array(ret_val, char, ret_val->name_length+1);
    21862171    if(ret_val->valuename == NULL)
    21872172    {
    2188       free(ret_val);
     2173      talloc_free(ret_val);
    21892174      return NULL;
    21902175    }
    … …  
    21962181      regfi_add_message(file, REGFI_MSG_ERROR, "Could not read value name"
    21972182                        " while parsing VK record at offset 0x%.8X.", offset);
    2198       free(ret_val->valuename);
    2199       free(ret_val);
     2183      talloc_free(ret_val);
    22002184      return NULL;
    22012185    }
    … …  
    22382222    }
    22392223
    2240     if((ret_val = (uint8*)zalloc(sizeof(uint8)*length)) == NULL)
     2224    if((ret_val = talloc_array(NULL, uint8_t, length)) == NULL)
    22412225      return NULL;
    22422226
    … …  
    22892273    }
    22902274
    2291     if((ret_val = (uint8*)zalloc(sizeof(uint8)*length)) == NULL)
     2275    if((ret_val = talloc_array(NULL, uint8_t, length)) == NULL)
    22922276      return NULL;
    22932277
    … …  
    22982282      regfi_add_message(file, REGFI_MSG_ERROR, "Could not read data block while"
    22992283                        " parsing data record at offset 0x%.8X.", offset);
    2300       free(ret_val);
     2284      talloc_free(ret_val);
    23012285      return NULL;
    23022286    }

  • trunk/lib/void_stack.c

    r147 r150  
    44 * leaks.
    55 *
    6  * Copyright (C) 2005,2007 Timothy D. Morgan
     6 * Copyright (C) 2005,2007,2009 Timothy D. Morgan
    77 *
    88 * This program is free software; you can redistribute it and/or modify
    … …  
    2626void_stack* void_stack_new(unsigned short max_size)
    2727{
    28   void_stack* ret_val = (void_stack*)malloc(sizeof(void_stack));
     28  void_stack* ret_val = talloc(NULL, void_stack);
    2929
    3030  if (ret_val != NULL)
    3131  {
    3232    memset(ret_val, 0, sizeof(*ret_val));
    33     ret_val->elements = (void**)malloc(max_size*sizeof(void*));
     33    ret_val->elements = talloc_array(ret_val, void*, max_size);
    3434    if (ret_val->elements == NULL)
    3535    {
    36       free(ret_val);
     36      talloc_free(ret_val);
    3737      ret_val = NULL;
    3838    }
    … …  
    9090void void_stack_free(void_stack* stack)
    9191{
    92   free(stack->elements);
    93   free(stack);
     92  talloc_free(stack);
    9493}
    9594
    … …  
    10099  for(i=0; i < stack->top; i++)
    101100    free(stack->elements[i]);
    102   free(stack->elements);
    103   free(stack);
     101  talloc_free(stack);
    104102}
    105103
    … …  
    154152  if(stack != NULL)
    155153  {
    156     ret_val = (void_stack_iterator*)malloc(sizeof(void_stack_iterator));
     154    ret_val = talloc(stack, void_stack_iterator);
    157155    if (ret_val != NULL)
    158156    {
    … …  
    168166void void_stack_iterator_free(void_stack_iterator* iter)
    169167{
    170   free(iter);
     168  talloc_free(iter);
    171169}
    172170

  • trunk/src/reglookup-recover.c

    r149 r150  
    1515 * You should have received a copy of the GNU General Public License
    1616 * along with this program; if not, write to the Free Software
    17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
     17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    1818 *
    1919 * $Id$
    … …  
    8484    quoted_name = malloc(1*sizeof(char));
    8585    if(quoted_name == NULL)
    86       bailOut(REGLOOKUP_EXIT_OSERR, "ERROR: Could not allocate sufficient memory.\n");
     86      bailOut(REGLOOKUP_EXIT_OSERR,
     87              "ERROR: Could not allocate sufficient memory.\n");
    8788    quoted_name[0] = '\0';
    8889
    … …  
    297298          virt_offset = cur_ancestor->parent_off;
    298299       
    299         path_element = (struct name_holder*)malloc(sizeof(struct name_holder));
     300        path_element = talloc(path_stack, struct name_holder);
    300301        if(path_element != NULL)
    301302          path_element->quoted_name = quote_string(cur_ancestor->keyname,
    … …  
    305306           || !void_stack_push(path_stack, path_element))
    306307        {
    307           free(cur_ancestor->keyname);
    308           free(cur_ancestor);
    309           void_stack_free_deep(path_stack);
     308          /* XXX: Need to add a warning here */
     309          regfi_free_key(cur_ancestor);
     310          void_stack_free(path_stack);
    310311          return NULL;
    311312        }
    … …  
    318319        ret_val_size += path_element->length + 1;
    319320
    320         regfi_key_free(cur_ancestor);
     321        regfi_free_key(cur_ancestor);
    321322      }
    322323    }
    … …  
    328329  if(ret_val == NULL)
    329330  {
    330     void_stack_free_deep(path_stack);
     331    void_stack_free(path_stack);
    331332    return NULL;
    332333  }
    … …  
    340341    ret_val_used += path_element->length + 1;
    341342    free(path_element->quoted_name);
    342     free(path_element);
     343    talloc_free(path_element);
    343344  }
    344345  void_stack_free(path_stack);
    … …  
    532533  REGFI_NK_REC* key;
    533534  uint32 i, j;
     535  int error_code = 0;
    534536
    535537  for(i=0; i < range_list_size(unalloc_cells); i++)
    … …  
    550552        {
    551553          fprintf(stderr, "ERROR: Couldn't add key to unalloc_keys.\n");
    552           return 20;
     554          error_code = 20;
     555          goto fail;
    553556        }
     557        talloc_steal(unalloc_keys, key);
    554558        j+=key->cell_size-8;
    555559      }
    … …  
    561565    cur_elem = range_list_get(unalloc_keys, i);
    562566    if(!removeRange(unalloc_cells, cur_elem->offset, cur_elem->length))
    563       return 30;
     567    {
     568      error_code = 30;
     569      goto fail;
     570    }
    564571  }
    565572
    566573  return 0;
     574
     575 fail:
     576  regfi_free_key(key);
     577  return error_code;
    567578}
    568579
    … …  
    611622             * so prune it.
    612623             */
    613             free(nk->values->elements);
    614             free(nk->values);
     624            talloc_free(nk->values);
    615625            nk->values = NULL;
    616626          }
    … …  
    639649                                     vk->cell_size, vk))
    640650                  {
    641                     free(vk);
     651                    talloc_free(vk);
    642652                    return 30;
    643653                  }
    … …  
    647657                }
    648658                else
    649                   free(vk);
     659                  talloc_free(vk);
    650660              }
    651661            }

  • trunk/src/reglookup.c

    r147 r150  
    275275void printValueList(REGFI_ITERATOR* iter, char* prefix)
    276276{
    277   const REGFI_VK_REC* value;
     277  REGFI_VK_REC* value;
    278278
    279279  value = regfi_iterator_first_value(iter);
    … …  
    282282    if(!type_filter_enabled || (value->type == type_filter))
    283283      printValue(value, prefix);
     284    regfi_free_value(value);
    284285    value = regfi_iterator_next_value(iter);
    285286    printMsgs(iter->f);
    … …  
    373374  const REGFI_NK_REC* root = NULL;
    374375  const REGFI_NK_REC* cur = NULL;
    375   const REGFI_NK_REC* sub = NULL;
     376  REGFI_NK_REC* sub = NULL;
    376377  char* path = NULL;
    377378  int key_type = regfi_type_str2val("KEY");
    … …  
    418419          bailOut(REGLOOKUP_EXIT_DATAERR, "ERROR: unexpected NULL for key.\n");
    419420        }
    420 
     421       
    421422        sub = regfi_iterator_next_subkey(iter);
    422423      }
    … …  
    433434      }
    434435
    435       cur = sub;
     436      cur = regfi_iterator_cur_key(iter);
     437      regfi_free_key(sub);
    436438      sub = regfi_iterator_first_subkey(iter);
    437439      print_this = true;
    … …  
    456458int retrievePath(REGFI_ITERATOR* iter, char** path)
    457459{
    458   const REGFI_VK_REC* value;
     460  REGFI_VK_REC* value;
    459461  char* tmp_path_joined;
    460462  const char** tmp_path;
    … …  
    511513      printValue(value, tmp_path_joined);
    512514
     515    regfi_free_value(value);
    513516    free(tmp_path);
    514517    free(tmp_path_joined);
Note: See TracChangeset for help on using the changeset viewer.