Changeset 203 for trunk/lib

Timestamp:

08/21/10 12:53:19 (14 years ago)

Author:

tim

Message:

misc fixes

stripped _REC from some data type names

File:

• trunk/lib/regfi.c (modified) (25 diffs)

trunk/lib/regfi.c

@@ -833 +833 @@
   }
   else if(buf[0] == 'l' && buf[1] == 'i')
+  {
     elem_size = sizeof(uint32_t);
+  }
   else if((buf[0] == 'l') && (buf[1] == 'f' || buf[1] == 'h'))
     elem_size = sizeof(REGFI_SUBKEY_LIST_ELEM);
@@ -973 +975 @@
  *
  ******************************************************************************/
-REGFI_SK_REC* regfi_parse_sk(REGFI_FILE* file, uint32_t offset, uint32_t max_size, 
+REGFI_SK* regfi_parse_sk(REGFI_FILE* file, uint32_t offset, uint32_t max_size, 
                              bool strict)
 {
-  REGFI_SK_REC* ret_val = NULL;
+  REGFI_SK* ret_val = NULL;
   uint8_t* sec_desc_buf = NULL;
   uint32_t cell_length, length;
@@ -1000 +1002 @@
   }
 
-  ret_val = talloc(NULL, REGFI_SK_REC);
+  ret_val = talloc(NULL, REGFI_SK);
   if(ret_val == NULL)
     goto fail_locked;
@@ -1174 +1176 @@
 
 
-void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK_REC* vk, 
+void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK* vk, 
                                REGFI_ENCODING output_encoding, bool strict)
 {
@@ -1224 +1226 @@
 /******************************************************************************
  ******************************************************************************/
-REGFI_VK_REC* regfi_load_value(REGFI_FILE* file, uint32_t offset, 
+REGFI_VK* regfi_load_value(REGFI_FILE* file, uint32_t offset, 
                                REGFI_ENCODING output_encoding, bool strict)
 {
-  REGFI_VK_REC* ret_val = NULL;
+  REGFI_VK* ret_val = NULL;
   int32_t max_size;
 
@@ -1270 +1272 @@
 
 
-void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK_REC* nk, 
+void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK* nk, 
                              REGFI_ENCODING output_encoding, bool strict)
 {
@@ -1319 +1321 @@
  *
  ******************************************************************************/
-REGFI_NK_REC* regfi_load_key(REGFI_FILE* file, uint32_t offset,
+REGFI_NK* regfi_load_key(REGFI_FILE* file, uint32_t offset,
                              REGFI_ENCODING output_encoding, bool strict)
 {
-  REGFI_NK_REC* nk;
+  REGFI_NK* nk;
   uint32_t off;
   int32_t max_size;
@@ -1410 +1412 @@
 /******************************************************************************
  ******************************************************************************/
-const REGFI_SK_REC* regfi_load_sk(REGFI_FILE* file, uint32_t offset, bool strict)
-{
-  REGFI_SK_REC* ret_val = NULL;
+const REGFI_SK* regfi_load_sk(REGFI_FILE* file, uint32_t offset, bool strict)
+{
+  REGFI_SK* ret_val = NULL;
   int32_t max_size;
   void* failure_ptr = NULL;
@@ -1427 +1429 @@
 
   /* First look if we have already parsed it */
-  ret_val = (REGFI_SK_REC*)lru_cache_find(file->sk_cache, &offset, 4);
+  ret_val = (REGFI_SK*)lru_cache_find(file->sk_cache, &offset, 4);
 
   /* Bail out if we have previously cached a parse failure at this offset. */
@@ -1463 +1465 @@
 /******************************************************************************
  ******************************************************************************/
-REGFI_NK_REC* regfi_find_root_nk(REGFI_FILE* file, const REGFI_HBIN* hbin, 
+REGFI_NK* regfi_find_root_nk(REGFI_FILE* file, const REGFI_HBIN* hbin, 
                                  REGFI_ENCODING output_encoding)
 {
-  REGFI_NK_REC* nk = NULL;
+  REGFI_NK* nk = NULL;
   uint32_t cell_length;
   uint32_t cur_offset = hbin->file_off+REGFI_HBIN_HEADER_SIZE;
@@ -1576 +1578 @@
 
   /* Read file header */
-  if ((rb = regfi_parse_regf(file_cb, false)) == NULL) 
+  if ((rb = regfi_parse_regf(file_cb, false)) == NULL)
   {
     regfi_log_add(REGFI_LOG_ERROR, "Failed to read REGF block.");
     return NULL;
   }
-  rb->file_length = file_length;  
+  rb->file_length = file_length;
   rb->cb = file_cb;
 
@@ -1662 +1664 @@
  * rest of the file if that fails.
  ******************************************************************************/
-REGFI_NK_REC* regfi_rootkey(REGFI_FILE* file, REGFI_ENCODING output_encoding)
-{
-  REGFI_NK_REC* nk = NULL;
+REGFI_NK* regfi_rootkey(REGFI_FILE* file, REGFI_ENCODING output_encoding)
+{
+  REGFI_NK* nk = NULL;
   REGFI_HBIN* hbin;
   uint32_t root_offset, i, num_hbins;
@@ -1718 +1720 @@
                                    REGFI_ENCODING output_encoding)
 {
-  REGFI_NK_REC* root;
+  REGFI_NK* root;
   REGFI_ITERATOR* ret_val;
 
@@ -1773 +1775 @@
 bool regfi_iterator_down(REGFI_ITERATOR* i)
 {
-  REGFI_NK_REC* subkey;
+  REGFI_NK* subkey;
   REGFI_ITER_POSITION* pos;
 
@@ -1780 +1782 @@
     return false;
 
-  subkey = (REGFI_NK_REC*)regfi_iterator_cur_subkey(i);
+  subkey = (REGFI_NK*)regfi_iterator_cur_subkey(i);
   if(subkey == NULL)
   {
@@ -1840 +1842 @@
 bool regfi_iterator_find_subkey(REGFI_ITERATOR* i, const char* subkey_name)
 {
-  REGFI_NK_REC* subkey;
+  REGFI_NK* subkey;
   bool found = false;
   uint32_t old_subkey = i->cur_subkey;
@@ -1899 +1901 @@
 /******************************************************************************
  *****************************************************************************/
-const REGFI_NK_REC* regfi_iterator_cur_key(REGFI_ITERATOR* i)
+const REGFI_NK* regfi_iterator_cur_key(REGFI_ITERATOR* i)
 {
   return i->cur_key;
@@ -1907 +1909 @@
 /******************************************************************************
  *****************************************************************************/
-const REGFI_SK_REC* regfi_iterator_cur_sk(REGFI_ITERATOR* i)
+const REGFI_SK* regfi_iterator_cur_sk(REGFI_ITERATOR* i)
 {
   if(i->cur_key == NULL || i->cur_key->sk_off == REGFI_OFFSET_NONE)
@@ -1929 +1931 @@
 /******************************************************************************
  *****************************************************************************/
-const REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
+const REGFI_NK* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
 {
   uint32_t nk_offset;
@@ -1961 +1963 @@
 bool regfi_iterator_find_value(REGFI_ITERATOR* i, const char* value_name)
 {
-  const REGFI_VK_REC* cur;
+  const REGFI_VK* cur;
   bool found = false;
   uint32_t old_value = i->cur_value;
@@ -2007 +2009 @@
 /******************************************************************************
  *****************************************************************************/
-const REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
-{
-  REGFI_VK_REC* ret_val = NULL;
+const REGFI_VK* regfi_iterator_cur_value(REGFI_ITERATOR* i)
+{
+  REGFI_VK* ret_val = NULL;
   uint32_t voffset;
 
@@ -2037 +2039 @@
  *****************************************************************************/
 const REGFI_CLASSNAME* regfi_iterator_fetch_classname(REGFI_ITERATOR* i,
-                                                      const REGFI_NK_REC* key)
+                                                      const REGFI_NK* key)
 {
   REGFI_CLASSNAME* ret_val;
@@ -2101 +2103 @@
  *****************************************************************************/
 const REGFI_DATA* regfi_iterator_fetch_data(REGFI_ITERATOR* i, 
-                                            const REGFI_VK_REC* value)
+                                            const REGFI_VK* value)
 {
   REGFI_DATA* ret_val = NULL;
@@ -2565 +2567 @@
 /*******************************************************************
  *******************************************************************/
-REGFI_NK_REC* regfi_parse_nk(REGFI_FILE* file, uint32_t offset, 
-                             uint32_t max_size, bool strict)
+REGFI_NK* regfi_parse_nk(REGFI_FILE* file, uint32_t offset, 
+                         uint32_t max_size, bool strict)
 {
   uint8_t nk_header[REGFI_NK_MIN_LENGTH];
-  REGFI_NK_REC* ret_val;
+  REGFI_NK* ret_val;
   uint32_t length,cell_length;
   bool unalloc = false;
 
-  ret_val = talloc(NULL, REGFI_NK_REC);
+  ret_val = talloc(NULL, REGFI_NK);
   if(ret_val == NULL)
   {
@@ -2784 +2786 @@
 /******************************************************************************
 *******************************************************************************/
-REGFI_VK_REC* regfi_parse_vk(REGFI_FILE* file, uint32_t offset, 
+REGFI_VK* regfi_parse_vk(REGFI_FILE* file, uint32_t offset, 
                              uint32_t max_size, bool strict)
 {
-  REGFI_VK_REC* ret_val;
+  REGFI_VK* ret_val;
   uint8_t vk_header[REGFI_VK_MIN_LENGTH];
   uint32_t raw_data_size, length, cell_length;
   bool unalloc = false;
 
-  ret_val = talloc(NULL, REGFI_VK_REC);
+  ret_val = talloc(NULL, REGFI_VK);
   if(ret_val == NULL)
     goto fail;