Changeset 81

Timestamp:

01/17/07 11:47:39 (18 years ago)

Author:

tim

Message:

Finished incorporating changes to reglookup to work with new regfi interface.

Compiles now, but is minimally tested.

Location:

trunk

Files:

• Makefile (modified) (1 diff)
• include/regfi.h (modified) (6 diffs)
• include/void_stack.h (modified) (2 diffs)
• lib/Makefile (modified) (1 diff)
• lib/regfi.c (modified) (10 diffs)
• lib/void_stack.c (modified) (1 diff)
• src/reglookup.c (modified) (15 diffs)

trunk/Makefile

@@ -11 +11 @@
 
 CC=gcc
-OPTS=-std=gnu89 -pedantic -Wall
+OPTS=-std=gnu89 -pedantic -Wall -ggdb
 INC=-I/usr/local/include
 LIB=-L/usr/local/lib

trunk/include/regfi.h

@@ -6 +6 @@
  * Windows NT registry I/O library
  *
- * Copyright (C) 2005-2006 Timothy D. Morgan
+ * Copyright (C) 2005-2007 Timothy D. Morgan
  * Copyright (C) 2005 Gerald (Jerry) Carter
  *
@@ -68 +68 @@
 /* XXX: Has MS defined a REG_QWORD_BE? */
 /* Not a real type in the registry */
-#define REG_KEY                        0xFFFFFFFF
+#define REG_KEY                        0x7FFFFFFF
 
 
@@ -183 +183 @@
 } REGF_SK_REC;
 
+
 /* Key Name */ 
-
 typedef struct {
   REGF_HBIN *hbin;      /* pointer to HBIN record (in memory) containing 
@@ -220 +220 @@
   /* link in the other records here */
   REGF_LF_REC subkeys;
-  REGF_VK_REC *values;
-  REGF_SK_REC *sec_desc;
+  REGF_VK_REC* values;
+  REGF_SK_REC* sec_desc;
         
 } REGF_NK_REC;
 
+
 /* REGF block */
- 
 typedef struct {
   /* run time information */
@@ -290 +290 @@
 int           regfi_close(REGF_FILE* r);
 
-REGF_NK_REC*  regfi_rootkey( REGF_FILE* file );
+REGF_NK_REC*  regfi_rootkey(REGF_FILE* file);
 /* REGF_NK_REC*  regfi_fetch_subkey( REGF_FILE* file, REGF_NK_REC* nk ); */
 
 void            regfi_key_free(REGF_NK_REC* nk);
-void            regfi_value_free(REGF_VK_REC* vk);
 
 REGFI_ITERATOR* regfi_iterator_new(REGF_FILE* fh);
@@ -302 +301 @@
 bool            regfi_iterator_to_root(REGFI_ITERATOR* i);
 
-bool            regfi_iterator_find_subkey(REGFI_ITERATOR* i, const char* subkey_name)
+bool            regfi_iterator_find_subkey(REGFI_ITERATOR* i, const char* subkey_name);
 bool            regfi_iterator_walk_path(REGFI_ITERATOR* i, const char** path);
+/* XXX: these which return NK and VK records should return them as consts */
 REGF_NK_REC*    regfi_iterator_cur_key(REGFI_ITERATOR* i);
 REGF_NK_REC*    regfi_iterator_first_subkey(REGFI_ITERATOR* i);

trunk/include/void_stack.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2005 Timothy D. Morgan
+ * Copyright (C) 2005,2007 Timothy D. Morgan
  *
  * This program is free software; you can redistribute it and/or modify
@@ -22 +22 @@
 #include <string.h>
 
+#ifndef _VOID_STACK_H
 #define _VOID_STACK_H
-#ifndef _VOID_STACK_H
 
 typedef struct _void_stack

trunk/lib/Makefile

@@ -3 +3 @@
 ################################################################################
 
-FILES=regfio.o smb_deps.o void_stack.o
+FILES=regfi.o smb_deps.o void_stack.o
 
 all: $(FILES)
 
-regfio.o: regfio.c
-        $(CC) $(CFLAGS) $(OPTS) $(INC) -c -o $@ regfio.c
+regfi.o: regfi.c
+        $(CC) $(CFLAGS) $(OPTS) $(INC) -c -o $@ regfi.c
 
 smb_deps.o: smb_deps.c

trunk/lib/regfi.c

@@ -6 +6 @@
  * Windows NT registry I/O library
  *
- * Copyright (C) 2005-2006 Timothy D. Morgan
+ * Copyright (C) 2005-2007 Timothy D. Morgan
  * Copyright (C) 2005 Gerald (Jerry) Carter
  *
@@ -25 +25 @@
  */
 
-#include "../include/regfio.h"
+#include "../include/regfi.h"
 
 
@@ -629 +629 @@
     nk->hbin->dirty = true;
   
-  nk->subkey_index = 0;
   return true;
 }
@@ -1516 +1515 @@
   {
     for(i=0; i < nk->num_values; i++)
-      regfi_value_free(nk->values[i]);
+    {
+      if(nk->values[i].valuename != NULL)
+        free(nk->values[i].valuename);
+      if(nk->values[i].data != NULL)
+        free(nk->values[i].data);
+    }
     free(nk->values);
   }
@@ -1533 +1537 @@
 /******************************************************************************
  *****************************************************************************/
-void regfi_value_free(REGF_VK_REC* vk)
-{
-  if(vk->valuename != NULL)
-    free(vk->valuename);
-  if(vk->data != NULL)
-    free(vk->data);  
-  
-  /* XXX: not freeing hbin because these are cached.  This needs to be reviewed. */
-  free(vk);
-}
-
-
-/******************************************************************************
- *****************************************************************************/
 REGFI_ITERATOR* regfi_iterator_new(REGF_FILE* fh)
 {
@@ -1554 +1544 @@
     return NULL;
 
-  root = regfi_rootkey(f);
+  root = regfi_rootkey(fh);
   if(root == NULL)
   {
@@ -1725 +1715 @@
 /******************************************************************************
  *****************************************************************************/
-REGF_NK_REC* regfi_iterator_cur_key(REGFI_ITERATOR* i);
+REGF_NK_REC* regfi_iterator_cur_key(REGFI_ITERATOR* i)
 {
   return i->cur_key;
@@ -1735 +1725 @@
 REGF_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
 {
-  REGF_NK_REC* subkey;
-  REGF_HBIN* hbin;
-  
   i->cur_subkey = 0;
   return regfi_iterator_cur_subkey(i);
@@ -1821 +1808 @@
        && (strcasecmp(cur->valuename, value_name) == 0))
       found = true;
-    cur = retfi_iterator_next_value(i);
+    cur = regfi_iterator_next_value(i);
   }
 
@@ -1846 +1833 @@
   REGF_VK_REC* ret_val = NULL;
   if(i->cur_value < i->cur_key->num_values)
-    ret_val = i->cur_key->values[i];
+    ret_val = &(i->cur_key->values[i->cur_value]);
 
   return ret_val;

trunk/lib/void_stack.c

@@ -4 +4 @@
  * leaks. 
  *
- * Copyright (C) 2005 Timothy D. Morgan
+ * Copyright (C) 2005,2007 Timothy D. Morgan
  *
  * This program is free software; you can redistribute it and/or modify

trunk/src/reglookup.c

@@ -3 +3 @@
  * Gerald Carter''s regfio interface.
  *
- * Copyright (C) 2005-2006 Timothy D. Morgan
+ * Copyright (C) 2005-2007 Timothy D. Morgan
  * Copyright (C) 2002 Richard Sharpe, rsharpe@richardsharpe.com
  *
@@ -382 +382 @@
 
 
-void_stack* path2Stack(const char* s)
-{
-  void_stack* ret_val;
-  void_stack* rev_ret = void_stack_new(REGF_MAX_DEPTH);
+char** splitPath(const char* s)
+{
+  char** ret_val;
   const char* cur = s;
   char* next = NULL;
   char* copy;
-
-  if (rev_ret == NULL)
+  uint32 ret_cur = 0;
+
+  ret_val = (char**)malloc((REGF_MAX_DEPTH+1+1)*sizeof(char**));
+  if (ret_val == NULL)
     return NULL;
+  ret_val[0] = NULL;
+
+  /* We return a well-formed, 0-length, path even when input is icky. */
   if (s == NULL)
-    return rev_ret;
+    return ret_val;
   
   while((next = strchr(cur, '/')) != NULL)
@@ -405 +409 @@
       memcpy(copy, cur, next-cur);
       copy[next-cur] = '\0';
-      if(!void_stack_push(rev_ret, copy))
+      ret_val[ret_cur++] = copy;
+      if(ret_cur < (REGF_MAX_DEPTH+1+1))
+        ret_val[ret_cur] = NULL;
+      else
         bailOut(2, "ERROR: Registry maximum depth exceeded.\n");
     }
     cur = next+1;
   }
+
+  /* Grab last element, if path doesn't end in '/'. */
   if(strlen(cur) > 0)
   {
     copy = strdup(cur);
-    if(!void_stack_push(rev_ret, copy))
+    ret_val[ret_cur++] = copy;
+    if(ret_cur < (REGF_MAX_DEPTH+1+1))
+      ret_val[ret_cur] = NULL;
+    else
       bailOut(2, "ERROR: Registry maximum depth exceeded.\n");
   }
 
-  ret_val = void_stack_copy_reverse(rev_ret);
-  void_stack_free(rev_ret);
-
   return ret_val;
 }
 
-/* Returns a quoted path from an nk_stack */
-char* stack2Path(void_stack* nk_stack)
-{
-  const REGF_NK_REC* cur;
+
+/* Returns a quoted path from an iterator's stack */
+/* XXX: Some way should be found to integrate this into regfi's API 
+ *      The problem is that the escaping is sorta reglookup-specific.
+ */
+char* iter2Path(REGFI_ITERATOR* i)
+{
+  const REGFI_ITER_POSITION* cur;
   uint32 buf_left = 127;
   uint32 buf_len = buf_left+1;
   uint32 name_len = 0;
   uint32 grow_amt;
-  char* buf; 
+  char* buf;
   char* new_buf;
   char* name;
+  const char* cur_name;
   void_stack_iterator* iter;
   
@@ -441 +455 @@
   buf[0] = '\0';
 
-  iter = void_stack_iterator_new(nk_stack);
+  iter = void_stack_iterator_new(i->key_positions);
   if (iter == NULL)
   {
@@ -449 +463 @@
 
   /* skip root element */
+  if(void_stack_size(i->key_positions) < 1)
+  {
+    buf[0] = '/';
+    buf[1] = '\0';
+    return buf;
+  }
   cur = void_stack_iterator_next(iter);
 
-  while((cur = void_stack_iterator_next(iter)) != NULL)
-  {
+  do
+  {
+    cur = void_stack_iterator_next(iter);
+    if (cur == NULL)
+      cur_name = i->cur_key->keyname;
+    else
+      cur_name = cur->nk->keyname;
+
     buf[buf_len-buf_left-1] = '/';
     buf_left -= 1;
-    name = quote_string(cur->keyname, key_special_chars);
+    name = quote_string(cur_name, key_special_chars);
     name_len = strlen(name);
     if(name_len+1 > buf_left)
@@ -474 +500 @@
     buf[buf_len-buf_left-1] = '\0';
     free(name);
-  }
+  } while(cur != NULL);
 
   return buf;
@@ -572 +598 @@
 
 
-void printValueList(REGFI_ITERATOR i, char* prefix)
+void printValueList(REGFI_ITERATOR* i, char* prefix)
 {
   REGF_VK_REC* value;
@@ -578 +604 @@
   value = regfi_iterator_first_value(i);
   while(value != NULL)
-    if(!type_filter_enabled || (value.type == type_filter))
+  {
+    if(!type_filter_enabled || (value->type == type_filter))
       printValue(value, prefix);
+    value = regfi_iterator_next_value(i);
+  }
 }
 
@@ -630 +659 @@
 
 
-void printKeyTree(REGF_FILE* f, void_stack* nk_stack, const char* prefix)
-{
+void printKeyTree(REGFI_ITERATOR* iter)
+{
+  REGF_NK_REC* root = NULL;
   REGF_NK_REC* cur = NULL;
   REGF_NK_REC* sub = NULL;
   char* path = NULL;
-  char* val_path = NULL;
-  uint32 val_path_len = 0;
-  uint32 path_len = 0;
-  uint32 prefix_len = strlen(prefix);
   int key_type = regfi_type_str2val("KEY");
+  bool print_this = true;
+
+  root = cur = regfi_iterator_cur_key(iter);
+  sub = regfi_iterator_first_subkey(iter);
   
-  if((cur = (REGF_NK_REC*)void_stack_cur(nk_stack)) != NULL)
-  {
-    cur->subkey_index = 0;
-    path = stack2Path(nk_stack);
-
-    if(print_verbose)
-    {
-      if(prefix[0] == '\0')
-        fprintf(stderr, "VERBOSE: Printing key tree under path: /\n");
-      else
-        fprintf(stderr, "VERBOSE: Printing key tree under path: %s\n",
-                prefix);
-    }
-
-    path_len = strlen(path);
-    val_path_len = prefix_len+path_len;
-    val_path = (char*)malloc(val_path_len+1+1);
-    if(val_path == NULL)
-      bailOut(2, "ERROR: Could not allocate val_path.\n");
-
-    strcpy(val_path, prefix);
-    strcpy(val_path+prefix_len, path);
-    if(val_path[0] == '\0')
-    {
-      val_path[0] = '/';
-      val_path[1] = '\0';
-    }
-    if(!type_filter_enabled || (key_type == type_filter))
-      printKey(cur, val_path);
-    if(!type_filter_enabled || (key_type != type_filter))
-      printValueList(cur, val_path);
+  if(root == NULL)
+    bailOut(3, "ERROR: root cannot be NULL.\n");
+  
+  do
+  {
+    if(print_this)
+    {
+      path = iter2Path(iter);
+      if(path == NULL)
+        bailOut(2, "ERROR: Could not construct iterator's path.\n");
+      
+      if(!type_filter_enabled || (key_type == type_filter))
+        printKey(cur, path);
+      if(!type_filter_enabled || (key_type != type_filter))
+        printValueList(iter, path);
+      
+      free(path);
+    }
     
-    while((cur = (REGF_NK_REC*)void_stack_cur(nk_stack)) != NULL)
-    {
-      if((sub = regfi_fetch_subkey(f, cur)) == NULL)
+    if(sub == NULL)
+    {
+      if(cur != root)
       {
-        sub = void_stack_pop(nk_stack);
-        /* XXX: This is just a shallow free.  Need to write deep free
-         * routines to replace the Samba code for this. 
-         */ 
-        if(sub != NULL)
-          free(sub);
+        /* We're done with this sub-tree, going up and hitting other branches. */
+        if(!regfi_iterator_up(iter))
+          bailOut(3, "ERROR: could not traverse iterator upward.\n");
+        
+        cur = regfi_iterator_cur_key(iter);
+        if(cur == NULL)
+          bailOut(3, "ERROR: unexpected NULL for key.\n");
+        
+        sub = regfi_iterator_next_subkey(iter);
       }
-      else
-      {
-        sub->subkey_index = 0;
-        if(!void_stack_push(nk_stack, sub))
-          bailOut(2, "ERROR: Registry maximum depth exceeded.\n");
-        path = stack2Path(nk_stack);
-        if(path != NULL)
-        {
-          path_len = strlen(path);
-          if(val_path_len < prefix_len+path_len)
-          {
-            val_path_len = prefix_len+path_len;
-            val_path = (char*)realloc(val_path, val_path_len+1);
-            if(val_path == NULL)
-              bailOut(2, "ERROR: Could not reallocate val_path.\n");
-          }
-          strcpy(val_path, prefix);
-          strcpy(val_path+prefix_len, path);
-          if(!type_filter_enabled || (key_type == type_filter))
-            printKey(sub, val_path);
-          if(!type_filter_enabled || (key_type != type_filter))
-            printValueList(sub, val_path);
-        }
-      }
-    }
-  }
-  if(val_path != NULL)
-    free(val_path);
+      print_this = false;
+    }
+    else
+    { /* We have unexplored sub-keys.  
+       * Let's move down and print this first sub-tree out. 
+       */
+      if(!regfi_iterator_down(iter))
+        bailOut(3, "ERROR: could not traverse iterator downward.\n");
+
+      cur = sub;
+      sub = regfi_iterator_first_subkey(iter);
+      print_this = true;
+    }
+  } while(!((cur == root) && (sub == NULL)));
+
   if(print_verbose)
     fprintf(stderr, "VERBOSE: Finished printing key tree.\n");
 }
+
 
 /*
@@ -724 +732 @@
 int retrievePath(REGFI_ITERATOR* iter, char** path)
 {
-  REG_VK_REC* value;
+  REGF_VK_REC* value;
+  char* tmp_path_joined;
+  const char** tmp_path;
   uint32 i;
-  char* p;
-  char* tmp_path_joined;
-  char** tmp_path;
   
   if(path == NULL)
@@ -734 +741 @@
 
   /* One extra for any value at the end, and one more for NULL */
-  tmp_path = (char**)malloc(sizeof(char**)*(REGF_MAX_DEPTH+1+1));
+  tmp_path = (const char**)malloc(sizeof(const char**)*(REGF_MAX_DEPTH+1+1));
   if(tmp_path == NULL)
     return -2;
@@ -763 +770 @@
 
     value = regfi_iterator_cur_value(iter);
-    tmp_path_joined = joinPath(tmp_path);
+    tmp_path_joined = iter2Path(iter);
 
     if((value == NULL) || (tmp_path_joined == NULL))
@@ -808 +815 @@
 int main(int argc, char** argv)
 {
-  void_stack* path_stack;
   char** path = NULL;
   REGF_FILE* f;
-  REGF_NK_REC* root;
   REGFI_ITERATOR* iter;
   int retr_path_ret;
@@ -883 +888 @@
     bailOut(3, "ERROR: Couldn't create registry iterator.\n");
 
+  if(print_header)
+  {
+    if(print_security)
+      printf("PATH,TYPE,VALUE,MTIME,OWNER,GROUP,SACL,DACL\n");
+    else
+      printf("PATH,TYPE,VALUE,MTIME\n");
+  }
+
   if(path_filter_enabled && path_filter != NULL)
     path = splitPath(path_filter);
-  
+
   if(path != NULL)
   {
@@ -892 +905 @@
       fprintf(stderr, "WARNING: specified path not found.\n");
     else if (retr_path_ret == 2)
-      printKeyTree(iter, path_filter);
+      printKeyTree(iter);
     else if(retr_path_ret != 0)
       bailOut(4, "ERROR: Unknown error occurred in retrieving path.\n");
   }
   else
-    printKeyTree(iter, "");
+    printKeyTree(iter);
 
   regfi_iterator_free(iter);