Changeset 206 for trunk/lib


Ignore:
Timestamp:
08/25/10 11:20:32 (14 years ago)
Author:
tim
Message:

simplified part of regfi API to move string encoding to the REGFI_FILE object

additional pyregfi implementation

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/lib/regfi.c

    r203 r206  
    11311131    goto fail_locked;
    11321132
     1133  ret_val->offset = offset;
     1134  ret_val->cell_size = cell_length;
    11331135  ret_val->num_values = num_values;
    11341136
    … …  
    11751177}
    11761178
    1177 
     1179/* XXX: should give this boolean return type to indicate errors */
    11781180void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK* vk,
    11791181                               REGFI_ENCODING output_encoding, bool strict)
    … …  
    11931195  if(from_encoding == output_encoding)
    11941196  {
    1195     vk->valuename_raw = talloc_realloc(vk, vk->valuename_raw,
    1196                                             uint8_t, vk->name_length+1);
    1197     vk->valuename_raw[vk->name_length] = '\0';
    1198     vk->valuename = (char*)vk->valuename_raw;
     1197    vk->name_raw[vk->name_length] = '\0';
     1198    vk->name = (char*)vk->name_raw;
    11991199  }
    12001200  else
    12011201  {
    1202     vk->valuename = talloc_array(vk, char, vk->name_length+1);
    1203     if(vk->valuename == NULL)
    1204     {
    1205       talloc_free(vk);
     1202    vk->name = talloc_array(vk, char, vk->name_length+1);
     1203    if(vk->name == NULL)
    12061204      return;
    1207     }
    12081205
    12091206    tmp_size = regfi_conv_charset(regfi_encoding_int2str(from_encoding),
    12101207                                  regfi_encoding_int2str(output_encoding),
    1211                                   vk->valuename_raw, vk->valuename,
     1208                                  vk->name_raw, vk->name,
    12121209                                  vk->name_length, vk->name_length+1);
    12131210    if(tmp_size < 0)
    12141211    {
    12151212      regfi_log_add(REGFI_LOG_WARN, "Error occurred while converting"
    1216                         " valuename to encoding %s.  Error message: %s",
     1213                        " value name to encoding %s.  Error message: %s",
    12171214                        regfi_encoding_int2str(output_encoding),
    12181215                        strerror(-tmp_size));
    1219       talloc_free(vk->valuename);
    1220       vk->valuename = NULL;
     1216      talloc_free(vk->name);
     1217      vk->name = NULL;
    12211218    }
    12221219  }
    … …  
    12271224 ******************************************************************************/
    12281225REGFI_VK* regfi_load_value(REGFI_FILE* file, uint32_t offset,
    1229                                REGFI_ENCODING output_encoding, bool strict)
     1226                           REGFI_ENCODING output_encoding, bool strict)
    12301227{
    12311228  REGFI_VK* ret_val = NULL;
    … …  
    12721269
    12731270
     1271/* XXX: should give this boolean return type to indicate errors */
    12741272void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK* nk,
    12751273                             REGFI_ENCODING output_encoding, bool strict)
    … …  
    12881286  if(from_encoding == output_encoding)
    12891287  {
    1290     nk->keyname_raw = talloc_realloc(nk, nk->keyname_raw, uint8_t, nk->name_length+1);
    1291     nk->keyname_raw[nk->name_length] = '\0';
    1292     nk->keyname = (char*)nk->keyname_raw;
     1288    nk->name_raw[nk->name_length] = '\0';
     1289    nk->name = (char*)nk->name_raw;
    12931290  }
    12941291  else
    12951292  {
    1296     nk->keyname = talloc_array(nk, char, nk->name_length+1);
    1297     if(nk->keyname == NULL)
    1298     {
    1299       talloc_free(nk);
     1293    nk->name = talloc_array(nk, char, nk->name_length+1);
     1294    if(nk->name == NULL)
    13001295      return;
    1301     }
     1296
     1297    memset(nk->name,0,nk->name_length+1);
    13021298
    13031299    tmp_size = regfi_conv_charset(regfi_encoding_int2str(from_encoding),
    13041300                                  regfi_encoding_int2str(output_encoding),
    1305                                   nk->keyname_raw, nk->keyname,
     1301                                  nk->name_raw, nk->name,
    13061302                                  nk->name_length, nk->name_length+1);
    13071303    if(tmp_size < 0)
    13081304    {
    13091305      regfi_log_add(REGFI_LOG_WARN, "Error occurred while converting"
    1310                         " keyname to encoding %s.  Error message: %s",
     1306                        " key name to encoding %s.  Error message: %s",
    13111307                        regfi_encoding_int2str(output_encoding),
    13121308                        strerror(-tmp_size));
    1313       talloc_free(nk->keyname);
    1314       nk->keyname = NULL;
     1309      talloc_free(nk->name);
     1310      nk->name = NULL;
    13151311    }
    13161312  }
    … …  
    13221318 ******************************************************************************/
    13231319REGFI_NK* regfi_load_key(REGFI_FILE* file, uint32_t offset,
    1324                              REGFI_ENCODING output_encoding, bool strict)
     1320                         REGFI_ENCODING output_encoding, bool strict)
    13251321{
    13261322  REGFI_NK* nk;
    … …  
    14661462 ******************************************************************************/
    14671463REGFI_NK* regfi_find_root_nk(REGFI_FILE* file, const REGFI_HBIN* hbin,
    1468                                 REGFI_ENCODING output_encoding)
     1464                            REGFI_ENCODING output_encoding)
    14691465{
    14701466  REGFI_NK* nk = NULL;
    … …  
    15101506/******************************************************************************
    15111507 ******************************************************************************/
    1512 REGFI_FILE* regfi_alloc(int fd)
     1508REGFI_FILE* regfi_alloc(int fd, REGFI_ENCODING output_encoding)
    15131509{
    15141510  REGFI_FILE* ret_val;
    … …  
    15271523  file_cb->seek = &regfi_raw_seek;
    15281524 
    1529   ret_val = regfi_alloc_cb(file_cb);
     1525  ret_val = regfi_alloc_cb(file_cb, output_encoding);
    15301526  if(ret_val == NULL)
    15311527    goto fail;
    … …  
    15571553/******************************************************************************
    15581554 ******************************************************************************/
    1559 REGFI_FILE* regfi_alloc_cb(REGFI_RAW_FILE* file_cb)
     1555REGFI_FILE* regfi_alloc_cb(REGFI_RAW_FILE* file_cb,
     1556                           REGFI_ENCODING output_encoding)
    15601557{
    15611558  REGFI_FILE* rb;
    … …  
    15771574  file_cb->seek(file_cb, 0, SEEK_SET);
    15781575
     1576  if(output_encoding != REGFI_ENCODING_UTF8
     1577     && output_encoding != REGFI_ENCODING_ASCII)
     1578  {
     1579    regfi_log_add(REGFI_LOG_ERROR, "Invalid output_encoding supplied"
     1580                  " in creation of regfi iterator.");
     1581    return NULL;
     1582  }
     1583
    15791584  /* Read file header */
    15801585  if ((rb = regfi_parse_regf(file_cb, false)) == NULL)
    … …  
    15851590  rb->file_length = file_length;
    15861591  rb->cb = file_cb;
     1592  rb->string_encoding = output_encoding;
    15871593
    15881594  if(pthread_mutex_init(&rb->cb_lock, NULL) != 0)
    … …  
    16641670 * rest of the file if that fails.
    16651671 ******************************************************************************/
    1666 REGFI_NK* regfi_rootkey(REGFI_FILE* file, REGFI_ENCODING output_encoding)
     1672REGFI_NK* regfi_rootkey(REGFI_FILE* file)
    16671673{
    16681674  REGFI_NK* nk = NULL;
    … …  
    16741680
    16751681  root_offset = file->root_cell+REGFI_REGF_SIZE;
    1676   nk = regfi_load_key(file, root_offset, output_encoding, true);
     1682  nk = regfi_load_key(file, root_offset, file->string_encoding, true);
    16771683  if(nk != NULL)
    16781684  {
    … …  
    16961702  {
    16971703    hbin = (REGFI_HBIN*)range_list_get(file->hbins, i)->data;
    1698     nk = regfi_find_root_nk(file, hbin, output_encoding);
     1704    nk = regfi_find_root_nk(file, hbin, file->string_encoding);
    16991705  }
    17001706
    … …  
    17171723/******************************************************************************
    17181724 *****************************************************************************/
    1719 REGFI_ITERATOR* regfi_iterator_new(REGFI_FILE* file,
    1720                                    REGFI_ENCODING output_encoding)
     1725REGFI_ITERATOR* regfi_iterator_new(REGFI_FILE* file)
    17211726{
    17221727  REGFI_NK* root;
    17231728  REGFI_ITERATOR* ret_val;
    17241729
    1725   if(output_encoding != REGFI_ENCODING_UTF8
    1726      && output_encoding != REGFI_ENCODING_ASCII)
    1727   {
    1728     regfi_log_add(REGFI_LOG_ERROR, "Invalid output_encoding supplied"
    1729                   " in creation of regfi iterator.");
    1730     return NULL;
    1731   }
    1732 
    17331730  ret_val = talloc(NULL, REGFI_ITERATOR);
    17341731  if(ret_val == NULL)
    17351732    return NULL;
    17361733
    1737   root = regfi_rootkey(file, output_encoding);
     1734  root = regfi_rootkey(file);
    17381735  if(root == NULL)
    17391736  {
    … …  
    17551752  ret_val->cur_subkey = 0;
    17561753  ret_val->cur_value = 0;
    1757   ret_val->string_encoding = output_encoding;
    17581754   
    17591755  return ret_val;
    … …  
    18531849  while((subkey = regfi_iterator_cur_subkey(i)) != NULL && (found == false))
    18541850  {
    1855     if(subkey->keyname != NULL
    1856        && strcasecmp(subkey->keyname, subkey_name) == 0)
     1851    if(subkey->name != NULL
     1852       && strcasecmp(subkey->name, subkey_name) == 0)
    18571853      found = true;
    18581854    else
    … …  
    19031899const REGFI_NK* regfi_iterator_cur_key(REGFI_ITERATOR* i)
    19041900{
     1901  /* XXX: do we need to add a NULL talloc reference here? */
    19051902  return i->cur_key;
    19061903}
    … …  
    19091906/******************************************************************************
    19101907 *****************************************************************************/
    1911 const REGFI_SK* regfi_iterator_cur_sk(REGFI_ITERATOR* i)
    1912 {
    1913   if(i->cur_key == NULL || i->cur_key->sk_off == REGFI_OFFSET_NONE)
    1914     return NULL;
    1915 
    1916   return regfi_load_sk(i->f, i->cur_key->sk_off + REGFI_REGF_SIZE, true);
     1908const REGFI_SK* regfi_fetch_sk(REGFI_FILE* file, const REGFI_NK* key)
     1909{
     1910  if(key == NULL || key->sk_off == REGFI_OFFSET_NONE)
     1911    return NULL;
     1912
     1913  return regfi_load_sk(file, key->sk_off + REGFI_REGF_SIZE, true);
    19171914}
    19181915
    … …  
    19411938
    19421939    return regfi_load_key(i->f, nk_offset+REGFI_REGF_SIZE,
    1943                           i->string_encoding, true);
     1940                          i->f->string_encoding, true);
    19441941  }
    19451942
    … …  
    19671964  uint32_t old_value = i->cur_value;
    19681965
    1969   /* XXX: cur->valuename can be NULL in the registry. 
     1966  /* XXX: cur->name can be NULL in the registry. 
    19701967   *      Should we allow for a way to search for that?
    19711968   */
    … …  
    19761973  while((cur = regfi_iterator_cur_value(i)) != NULL && (found == false))
    19771974  {
    1978     if((cur->valuename != NULL)
    1979        && (strcasecmp(cur->valuename, value_name) == 0))
     1975    if((cur->name != NULL)
     1976       && (strcasecmp(cur->name, value_name) == 0))
    19801977      found = true;
    19811978    else
    … …  
    20192016    voffset = i->cur_key->values->elements[i->cur_value];
    20202017    ret_val = regfi_load_value(i->f, voffset+REGFI_REGF_SIZE,
    2021                                i->string_encoding, true);
     2018                               i->f->string_encoding, true);
    20222019  }
    20232020
    … …  
    20382035/******************************************************************************
    20392036 *****************************************************************************/
    2040 const REGFI_CLASSNAME* regfi_iterator_fetch_classname(REGFI_ITERATOR* i,
    2041                                                       const REGFI_NK* key)
     2037const REGFI_CLASSNAME* regfi_fetch_classname(REGFI_FILE* file,
     2038                                             const REGFI_NK* key)
    20422039{
    20432040  REGFI_CLASSNAME* ret_val;
    … …  
    20522049
    20532050  offset = key->classname_off + REGFI_REGF_SIZE;
    2054   max_size = regfi_calc_maxsize(i->f, offset);
     2051  max_size = regfi_calc_maxsize(file, offset);
    20552052  if(max_size <= 0)
    20562053    return NULL;
    20572054
    20582055  parse_length = key->classname_length;
    2059   raw = regfi_parse_classname(i->f, offset, &parse_length, max_size, true);
     2056  raw = regfi_parse_classname(file, offset, &parse_length, max_size, true);
    20602057 
    20612058  if(raw == NULL)
    … …  
    20712068    return NULL;
    20722069
     2070  ret_val->offset = offset;
    20732071  ret_val->raw = raw;
    20742072  ret_val->size = parse_length;
    … …  
    20782076
    20792077  conv_size = regfi_conv_charset(regfi_encoding_int2str(REGFI_ENCODING_UTF16LE),
    2080                                  regfi_encoding_int2str(i->string_encoding),
     2078                                 regfi_encoding_int2str(file->string_encoding),
    20812079                                 raw, interpreted,
    20822080                                 parse_length, parse_length);
    … …  
    20852083    regfi_log_add(REGFI_LOG_WARN, "Error occurred while"
    20862084                  " converting classname to charset %s.  Error message: %s",
    2087                   i->string_encoding, strerror(-conv_size));
     2085                  file->string_encoding, strerror(-conv_size));
    20882086    talloc_free(interpreted);
    20892087    ret_val->interpreted = NULL;
    … …  
    21022100/******************************************************************************
    21032101 *****************************************************************************/
    2104 const REGFI_DATA* regfi_iterator_fetch_data(REGFI_ITERATOR* i,
    2105                                             const REGFI_VK* value)
     2102const REGFI_DATA* regfi_fetch_data(REGFI_FILE* file,
     2103                                   const REGFI_VK* value)
    21062104{
    21072105  REGFI_DATA* ret_val = NULL;
    … …  
    21102108  if(value->data_size != 0)
    21112109  {
    2112     raw_data = regfi_load_data(i->f, value->data_off, value->data_size,
     2110    raw_data = regfi_load_data(file, value->data_off, value->data_size,
    21132111                              value->data_in_offset, true);
    21142112    if(raw_data.buf == NULL)
    … …  
    21322130      }
    21332131
    2134       if(!regfi_interpret_data(i->f, i->string_encoding, value->type, ret_val))
     2132      if(!regfi_interpret_data(file, file->string_encoding,
     2133                               value->type, ret_val))
    21352134      {
    21362135        regfi_log_add(REGFI_LOG_INFO, "Error occurred while"
    … …  
    23442343 *****************************************************************************/
    23452344int32_t regfi_conv_charset(const char* input_charset, const char* output_charset,
    2346                          uint8_t* input, char* output,
    2347                          uint32_t input_len, uint32_t output_max)
     2345                           uint8_t* input, char* output,
     2346                           uint32_t input_len, uint32_t output_max)
    23482347{
    23492348  iconv_t conv_desc;
    … …  
    26572656  ret_val->name_length = SVAL(nk_header, 0x48);
    26582657  ret_val->classname_length = SVAL(nk_header, 0x4A);
    2659   ret_val->keyname = NULL;
     2658  ret_val->name = NULL;
    26602659
    26612660  if(ret_val->name_length + REGFI_NK_MIN_LENGTH > ret_val->cell_size)
    … …  
    26822681  }
    26832682
    2684   ret_val->keyname_raw = talloc_array(ret_val, uint8_t, ret_val->name_length);
    2685   if(ret_val->keyname_raw == NULL)
     2683  /* +1 to length in case we decided to use this directly as a string later */
     2684  ret_val->name_raw = talloc_array(ret_val, uint8_t, ret_val->name_length+1);
     2685  if(ret_val->name_raw == NULL)
    26862686    goto fail_locked;
    26872687
    26882688  /* Don't need to seek, should be at the right offset */
    26892689  length = ret_val->name_length;
    2690   if((regfi_read(file->cb, (uint8_t*)ret_val->keyname_raw, &length) != 0)
     2690  if((regfi_read(file->cb, (uint8_t*)ret_val->name_raw, &length) != 0)
    26912691     || length != ret_val->name_length)
    26922692  {
    … …  
    27102710
    27112711uint8_t* regfi_parse_classname(REGFI_FILE* file, uint32_t offset,
    2712                              uint16_t* name_length, uint32_t max_size, bool strict)
     2712                               uint16_t* name_length, uint32_t max_size, bool strict)
    27132713{
    27142714  uint8_t* ret_val = NULL;
    … …  
    28112811  ret_val->offset = offset;
    28122812  ret_val->cell_size = cell_length;
    2813   ret_val->valuename = NULL;
    2814   ret_val->valuename_raw = NULL;
     2813  ret_val->name = NULL;
     2814  ret_val->name_raw = NULL;
    28152815 
    28162816  if(ret_val->cell_size > max_size)
    … …  
    28672867      cell_length+=8;
    28682868
    2869     ret_val->valuename_raw = talloc_array(ret_val, uint8_t, ret_val->name_length);
    2870     if(ret_val->valuename_raw == NULL)
     2869    /* +1 to length in case we decided to use this directly as a string later */
     2870    ret_val->name_raw = talloc_array(ret_val, uint8_t, ret_val->name_length+1);
     2871    if(ret_val->name_raw == NULL)
    28712872      goto fail_locked;
    28722873
    28732874    length = ret_val->name_length;
    2874     if((regfi_read(file->cb, (uint8_t*)ret_val->valuename_raw, &length) != 0)
     2875    if((regfi_read(file->cb, (uint8_t*)ret_val->name_raw, &length) != 0)
    28752876       || length != ret_val->name_length)
    28762877    {
Note: See TracChangeset for help on using the changeset viewer.