Changeset 263


Ignore:
Timestamp:
06/17/11 20:06:51 (13 years ago)
Author:
tim
Message:

simplified string encoding argument passing throughout regfi API

Files:
4 edited

Legend:

Unmodified
Added
Removed

  • test/regfi-threadtest.c

    r250 r263  
    169169
    170170  regfi_iterator_free(iter);
     171  fprintf(stderr, "INFO: thread finished\n");
    171172
    172173  return NULL;
    … …  
    188189
    189190  num_threads = 10;
    190   num_iterations = 10;
     191  num_iterations = 2;
    191192
    192193  /* Process command line arguments */

  • trunk/include/regfi.h

    r262 r263  
    14831483_EXPORT()
    14841484REGFI_NK* regfi_load_key(REGFI_FILE* file, uint32_t offset,
    1485                          REGFI_ENCODING output_encoding,
    14861485                         bool strict);
    14871486
    … …  
    14951494_EXPORT()
    14961495REGFI_VK* regfi_load_value(REGFI_FILE* file, uint32_t offset,
    1497                            REGFI_ENCODING output_encoding,
    14981496                           bool strict);
    14991497
    … …  
    15581556_EXPORT()
    15591557bool regfi_interpret_data(REGFI_FILE* file,
    1560                           REGFI_ENCODING string_encoding,
    15611558                          uint32_t type, REGFI_DATA* data);
    15621559
    … …  
    17661763
    17671764_EXPORT()
    1768 void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK* nk,
    1769                              REGFI_ENCODING output_encoding, bool strict);
    1770 _EXPORT()
    1771 void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK* vk,
    1772                                REGFI_ENCODING output_encoding, bool strict);
     1765void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK* nk, bool strict);
     1766_EXPORT()
     1767void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK* vk, bool strict);
    17731768
    17741769_EXPORT()

  • trunk/lib/regfi.c

    r262 r263  
    11751175
    11761176/* XXX: should give this boolean return type to indicate errors */
    1177 void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK* vk,
    1178                                REGFI_ENCODING output_encoding, bool strict)
     1177void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK* vk, bool strict)
    11791178{
    11801179  /* XXX: Registry value names are supposedly limited to 16383 characters
    … …  
    11931192    return;
    11941193
    1195   if(from_encoding == output_encoding)
     1194  if(from_encoding == file->string_encoding)
    11961195  {
    11971196    vk->name_raw[vk->name_length] = '\0';
    … …  
    12011200  {
    12021201    tmp_buf = regfi_conv_charset(regfi_encoding_int2str(from_encoding),
    1203                                  regfi_encoding_int2str(output_encoding),
     1202                                 regfi_encoding_int2str(file->string_encoding),
    12041203                                 vk->name_raw, vk->name_length);
    12051204    if(tmp_buf.buf == NULL)
    … …  
    12071206      regfi_log_add(REGFI_LOG_WARN, "Error occurred while converting"
    12081207                        " value name to encoding %s.  Error message: %s",
    1209                         regfi_encoding_int2str(output_encoding),
     1208                        regfi_encoding_int2str(file->string_encoding),
    12101209                        strerror(errno));
    12111210      vk->name = NULL;
    … …  
    12221221/******************************************************************************
    12231222 ******************************************************************************/
    1224 REGFI_VK* regfi_load_value(REGFI_FILE* file, uint32_t offset,
    1225                            REGFI_ENCODING output_encoding, bool strict)
     1223REGFI_VK* regfi_load_value(REGFI_FILE* file, uint32_t offset, bool strict)
    12261224{
    12271225  REGFI_VK* ret_val = NULL;
    … …  
    12361234    return NULL;
    12371235
    1238   regfi_interpret_valuename(file, ret_val, output_encoding, strict);
     1236  regfi_interpret_valuename(file, ret_val, strict);
    12391237
    12401238  return ret_val;
    … …  
    12691267
    12701268/* XXX: should give this boolean return type to indicate errors */
    1271 void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK* nk,
    1272                              REGFI_ENCODING output_encoding, bool strict)
     1269void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK* nk, bool strict)
    12731270{
    12741271  /* XXX: Registry key names are supposedly limited to 255 characters according to:
    … …  
    12861283    return; 
    12871284
    1288   if(from_encoding == output_encoding)
     1285  if(from_encoding == file->string_encoding)
    12891286  {
    12901287    nk->name_raw[nk->name_length] = '\0';
    … …  
    12941291  {
    12951292    tmp_buf = regfi_conv_charset(regfi_encoding_int2str(from_encoding),
    1296                                  regfi_encoding_int2str(output_encoding),
     1293                                 regfi_encoding_int2str(file->string_encoding),
    12971294                                 nk->name_raw, nk->name_length);
    12981295    if(tmp_buf.buf == NULL)
    … …  
    13001297      regfi_log_add(REGFI_LOG_WARN, "Error occurred while converting"
    13011298                    " key name to encoding %s.  Error message: %s",
    1302                     regfi_encoding_int2str(output_encoding),
     1299                    regfi_encoding_int2str(file->string_encoding),
    13031300                    strerror(errno));
    13041301      nk->name = NULL;
    … …  
    13161313 *
    13171314 ******************************************************************************/
    1318 REGFI_NK* regfi_load_key(REGFI_FILE* file, uint32_t offset,
    1319                          REGFI_ENCODING output_encoding, bool strict)
     1315REGFI_NK* regfi_load_key(REGFI_FILE* file, uint32_t offset, bool strict)
    13201316{
    13211317  REGFI_NK* nk;
    … …  
    13531349  }
    13541350
    1355   regfi_interpret_keyname(file, nk, output_encoding, strict);
     1351  regfi_interpret_keyname(file, nk, strict);
    13561352
    13571353  /* get value list */
    … …  
    14941490/******************************************************************************
    14951491 ******************************************************************************/
    1496 REGFI_NK* regfi_find_root_nk(REGFI_FILE* file, const REGFI_HBIN* hbin,
    1497                              REGFI_ENCODING output_encoding)
     1492REGFI_NK* regfi_find_root_nk(REGFI_FILE* file, const REGFI_HBIN* hbin)
    14981493{
    14991494  REGFI_NK* nk = NULL;
    … …  
    15211516    if(!unalloc)
    15221517    {
    1523       nk = regfi_load_key(file, cur_offset, output_encoding, true);
     1518      nk = regfi_load_key(file, cur_offset, true);
    15241519      if(nk != NULL)
    15251520      {
    … …  
    17381733
    17391734  root_offset = file->root_cell+REGFI_REGF_SIZE;
    1740   nk = regfi_load_key(file, root_offset, file->string_encoding, true);
     1735  nk = regfi_load_key(file, root_offset, true);
    17411736  if(nk != NULL)
    17421737  {
    … …  
    17601755  {
    17611756    hbin = (REGFI_HBIN*)range_list_get(file->hbins, i)->data;
    1762     nk = regfi_find_root_nk(file, hbin, file->string_encoding);
     1757    nk = regfi_find_root_nk(file, hbin);
    17631758  }
    17641759
    … …  
    20422037  const REGFI_NK* ret_val = NULL;
    20432038
    2044   ret_val = regfi_load_key(i->f, i->cur->offset, i->f->string_encoding, true);
     2039  ret_val = regfi_load_key(i->f, i->cur->offset, true);
    20452040  return ret_val;
    20462041}
    … …  
    22112206      cur != NULL; cur=void_stack_iterator_next(iter))
    22122207  {
    2213     ret_val[k++] = regfi_load_key(i->f, cur->offset, i->f->string_encoding, true);
    2214   }
    2215   ret_val[k] = regfi_load_key(i->f, i->cur->offset, i->f->string_encoding, true);
     2208    ret_val[k++] = regfi_load_key(i->f, cur->offset, true);
     2209  }
     2210  ret_val[k] = regfi_load_key(i->f, i->cur->offset, true);
    22162211  void_stack_iterator_free(iter);
    22172212
    … …  
    23242319      }
    23252320
    2326       if(!regfi_interpret_data(file, file->string_encoding,
    2327                                value->type, ret_val))
     2321      if(!regfi_interpret_data(file, value->type, ret_val))
    23282322      {
    23292323        regfi_log_add(REGFI_LOG_INFO, "Error occurred while"
    … …  
    24252419  {
    24262420    return regfi_load_key(file,
    2427                           key->subkeys->elements[index].offset+REGFI_REGF_SIZE,
    2428                           file->string_encoding, true);
     2421                          key->subkeys->elements[index].offset+REGFI_REGF_SIZE,
     2422                          true);
    24292423  }
    24302424
    … …  
    24422436    return regfi_load_value(file,
    24432437                            key->values->elements[index]+REGFI_REGF_SIZE,
    2444                             file->string_encoding, true);
     2438                            true);
    24452439  }
    24462440
    … …  
    24562450  if(key != NULL && key->parent_off != REGFI_OFFSET_NONE)
    24572451    return regfi_load_key(file,
    2458                           key->parent_off+REGFI_REGF_SIZE,
    2459                           file->string_encoding, true);
     2452                          key->parent_off+REGFI_REGF_SIZE, true);
    24602453
    24612454  return NULL;
    … …  
    24892482/******************************************************************************
    24902483 *****************************************************************************/
    2491 bool regfi_interpret_data(REGFI_FILE* file, REGFI_ENCODING string_encoding,
    2492                           uint32_t type, REGFI_DATA* data)
     2484bool regfi_interpret_data(REGFI_FILE* file, uint32_t type, REGFI_DATA* data)
    24932485{
    24942486  REGFI_BUFFER tmp_buf;
    … …  
    25062498  case REG_LINK:
    25072499    tmp_buf = regfi_conv_charset(regfi_encoding_int2str(REGFI_ENCODING_UTF16LE),
    2508                                  regfi_encoding_int2str(string_encoding),
     2500                                 regfi_encoding_int2str(file->string_encoding),
    25092501                                 data->raw, data->size);
    25102502    if(tmp_buf.buf == NULL)
    … …  
    25132505                    " converting data of type %d to string encoding %d."
    25142506                    "  Error message: %s",
    2515                     type, string_encoding, strerror(errno));
     2507                    type, file->string_encoding, strerror(errno));
    25162508      data->interpreted.string = NULL;
    25172509      data->interpreted_size = 0;
    … …  
    25632555     */
    25642556    tmp_buf = regfi_conv_charset(regfi_encoding_int2str(REGFI_ENCODING_UTF16LE),
    2565                                  regfi_encoding_int2str(string_encoding),
     2557                                 regfi_encoding_int2str(file->string_encoding),
    25662558                                 data->raw, data->size);
    25672559    if(tmp_buf.buf == NULL)
    … …  
    25702562                    " converting data of type %d to string encoding %d."
    25712563                    "  Error message: %s",
    2572                     type, string_encoding, strerror(errno));
     2564                    type, file->string_encoding, strerror(errno));
    25732565      data->interpreted.multiple_string = NULL;
    25742566      data->interpreted_size = 0;

  • trunk/src/reglookup-recover.c

    r251 r263  
    7676 
    7777  /* XXX: Add command line option to choose output encoding */
    78   regfi_interpret_keyname(f, nk, REGFI_ENCODING_ASCII, true);
     78  regfi_interpret_keyname(f, nk, true);
    7979
    8080  quoted_name = get_quoted_keyname(nk);
    … …  
    112112
    113113  /* XXX: Add command line option to choose output encoding */
    114   regfi_interpret_valuename(f, vk, REGFI_ENCODING_ASCII, true);
     114  regfi_interpret_valuename(f, vk, true);
    115115 
    116116  quoted_name = get_quoted_valuename(vk);
    … …  
    129129  /* XXX: Add command line option to choose output encoding */
    130130  if(vk->data != NULL
    131      && !regfi_interpret_data(f, REGFI_ENCODING_ASCII, vk->type, vk->data))
     131     && !regfi_interpret_data(f, vk->type, vk->data))
    132132  {
    133133    fprintf(stderr, "WARN: Error occurred while interpreting data for VK record"
    … …  
    282282        {
    283283          /* XXX: Add command line option to choose output encoding */
    284           regfi_interpret_keyname(f, cur_ancestor, REGFI_ENCODING_ASCII, true);
     284          regfi_interpret_keyname(f, cur_ancestor, true);
    285285         
    286286          path_element->buf = (uint8_t*)get_quoted_keyname(cur_ancestor);
    … …  
    943943    {
    944944      /* XXX: Add command line option to choose output encoding */
    945       regfi_interpret_keyname(f, tmp_key, REGFI_ENCODING_ASCII, true);
     945      regfi_interpret_keyname(f, tmp_key, true);
    946946
    947947      tmp_name = get_quoted_keyname(tmp_key);
Note: See TracChangeset for help on using the changeset viewer.