Changeset 168 for trunk

Timestamp:

03/02/10 19:08:42 (15 years ago)

Author:

tim

Message:

merged remaining smb_deps items into regfi

began formatting API comments for use with doxygen

Location:

trunk

Files:

• include/byteorder.h (modified) (7 diffs)
• include/lru_cache.h (modified) (1 diff)
• include/range_list.h (modified) (1 diff)
• include/regfi.h (modified) (27 diffs)
• include/smb_deps.h (deleted)
• include/talloc.h (modified) (1 diff)
• include/void_stack.h (modified) (1 diff)
• include/winsec.h (modified) (3 diffs)
• lib/Makefile (modified) (2 diffs)
• lib/lru_cache.c (modified) (1 diff)
• lib/range_list.c (modified) (1 diff)
• lib/regfi.c (modified) (77 diffs)
• lib/smb_deps.c (deleted)
• lib/void_stack.c (modified) (1 diff)
• lib/winsec.c (modified) (1 diff)
• src/common.c (modified) (1 diff)
• src/reglookup-recover.c (modified) (13 diffs)
• src/reglookup.c (modified) (7 diffs)

trunk/include/byteorder.h

@@ -1 @@
-/* 
+/*
  * Branched from Samba project Subversion repository, version #2:
  *  http://websvn.samba.org/cgi-bin/viewcvs.cgi/trunk/source/include/byteorder.h
@@ -28 +28 @@
 #define _BYTEORDER_H
 
-/*
-   This file implements macros for machine independent short and 
-   int manipulation
+/**
+ * @file
+ *
+ * This file implements macros for machine independent short and 
+ * int manipulation
+
+@verbatim
 
 Here is a description of this file that I emailed to the samba list once:
@@ -54 +58 @@
 Ok, now to the macros themselves. I'll take a simple example, say we
 want to extract a 2 byte integer from a SMB packet and put it into a
-type called uint16 that is in the local machines byte order, and you
-want to do it with only the assumption that uint16 is _at_least_ 16
+type called uint16_t that is in the local machines byte order, and you
+want to do it with only the assumption that uint16_t is _at_least_ 16
 bits long (this last condition is very important for architectures
 that don't have any int types that are 2 bytes long)
@@ -65 +69 @@
 #define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)
 
-then to extract a uint16 value at offset 25 in a buffer you do this:
+then to extract a uint16_t value at offset 25 in a buffer you do this:
 
 char *buffer = foo_bar();
-uint16 xx = SVAL(buffer,25);
+uint16_t xx = SVAL(buffer,25);
 
 We are using the byteoder independence of the ANSI C bitshifts to do
@@ -98 +102 @@
 it also defines lots of intermediate macros, just ignore those :-)
 
+@endverbatim
+
 */
 
@@ -124 +130 @@
 #define SSVALX(buf,pos,val) (CVAL_NC(buf,pos)=(unsigned char)((val)&0xFF),CVAL_NC(buf,pos+1)=(unsigned char)((val)>>8))
 #define SIVALX(buf,pos,val) (SSVALX(buf,pos,val&0xFFFF),SSVALX(buf,pos+2,val>>16))
-#define SVALS(buf,pos) ((int16)SVAL(buf,pos))
-#define IVALS(buf,pos) ((int32)IVAL(buf,pos))
-#define SSVAL(buf,pos,val) SSVALX((buf),(pos),((uint16)(val)))
-#define SIVAL(buf,pos,val) SIVALX((buf),(pos),((uint32)(val)))
-#define SSVALS(buf,pos,val) SSVALX((buf),(pos),((int16)(val)))
-#define SIVALS(buf,pos,val) SIVALX((buf),(pos),((int32)(val)))
+#define SVALS(buf,pos) ((int16_t)SVAL(buf,pos))
+#define IVALS(buf,pos) ((int32_t)IVAL(buf,pos))
+#define SSVAL(buf,pos,val) SSVALX((buf),(pos),((uint16_t)(val)))
+#define SIVAL(buf,pos,val) SIVALX((buf),(pos),((uint32_t)(val)))
+#define SSVALS(buf,pos,val) SSVALX((buf),(pos),((int16_t)(val)))
+#define SIVALS(buf,pos,val) SIVALX((buf),(pos),((int32_t)(val)))
 
 #else /* CAREFUL_ALIGNMENT */
@@ -136 +142 @@
    alignment errors */
 /*
-   WARNING: This section is dependent on the length of int16 and int32
+   WARNING: This section is dependent on the length of int16_t and int32_t
    being correct 
 */
 
 /* get single value from an SMB buffer */
-#define SVAL(buf,pos) (*(const uint16 *)((const char *)(buf) + (pos)))
-#define SVAL_NC(buf,pos) (*(uint16 *)((char *)(buf) + (pos))) /* Non const version of above. */
-#define IVAL(buf,pos) (*(const uint32 *)((const char *)(buf) + (pos)))
-#define IVAL_NC(buf,pos) (*(uint32 *)((char *)(buf) + (pos))) /* Non const version of above. */
-#define SVALS(buf,pos) (*(const int16 *)((const char *)(buf) + (pos)))
-#define SVALS_NC(buf,pos) (*(int16 *)((char *)(buf) + (pos))) /* Non const version of above. */
-#define IVALS(buf,pos) (*(const int32 *)((const char *)(buf) + (pos)))
-#define IVALS_NC(buf,pos) (*(int32 *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define SVAL(buf,pos) (*(const uint16_t *)((const char *)(buf) + (pos)))
+#define SVAL_NC(buf,pos) (*(uint16_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define IVAL(buf,pos) (*(const uint32_t *)((const char *)(buf) + (pos)))
+#define IVAL_NC(buf,pos) (*(uint32_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define SVALS(buf,pos) (*(const int16_t *)((const char *)(buf) + (pos)))
+#define SVALS_NC(buf,pos) (*(int16_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define IVALS(buf,pos) (*(const int32_t *)((const char *)(buf) + (pos)))
+#define IVALS_NC(buf,pos) (*(int32_t *)((char *)(buf) + (pos))) /* Non const version of above. */
 
 /* store single value in an SMB buffer */
-#define SSVAL(buf,pos,val) SVAL_NC(buf,pos)=((uint16)(val))
-#define SIVAL(buf,pos,val) IVAL_NC(buf,pos)=((uint32)(val))
-#define SSVALS(buf,pos,val) SVALS_NC(buf,pos)=((int16)(val))
-#define SIVALS(buf,pos,val) IVALS_NC(buf,pos)=((int32)(val))
+#define SSVAL(buf,pos,val) SVAL_NC(buf,pos)=((uint16_t)(val))
+#define SIVAL(buf,pos,val) IVAL_NC(buf,pos)=((uint32_t)(val))
+#define SSVALS(buf,pos,val) SVALS_NC(buf,pos)=((int16_t)(val))
+#define SIVALS(buf,pos,val) IVALS_NC(buf,pos)=((int32_t)(val))
 
 #endif /* CAREFUL_ALIGNMENT */

trunk/include/lru_cache.h

@@ -1 @@
-/*
+/**
+ * @file
+ *
  * Copyright (C) 2008-2009 Timothy D. Morgan
  *

trunk/include/range_list.h

@@ -1 @@
-/*
+/**
+ * @file 
+ *
  * Copyright (C) 2008-2009 Timothy D. Morgan
  *

trunk/include/regfi.h

@@ -1 @@
-/*
+/** @file
+ * Windows NT (and later) registry parsing library
+ *
  * Branched from Samba project Subversion repository, version #6903:
  *   http://viewcvs.samba.org/cgi-bin/viewcvs.cgi/trunk/source/include/regfio.h?rev=6903&view=auto
  *
- * Windows NT (and later) registry parsing library
- *
- * Copyright (C) 2005-2009 Timothy D. Morgan
+ * Copyright (C) 2005-2010 Timothy D. Morgan
  * Copyright (C) 2005 Gerald (Jerry) Carter
  *
@@ -29 +29 @@
  * Thanks Nigel!
  ***********************************************************/
+
+/**
+ * @mainpage Home
+ *
+ * See \ref regfiTopLayer
+ */
 
 #ifndef _REGFI_H
@@ -47 +53 @@
 #include <iconv.h>
 
+#include "byteorder.h"
 #include "talloc.h"
-#include "smb_deps.h"
 #include "winsec.h"
 #include "void_stack.h"
@@ -61 +67 @@
 #define REGFI_MSG_ERROR 0x0010
 
-typedef uint8 REGFI_ENCODING;
+typedef uint8_t REGFI_ENCODING;
 /* regfi library supported character encodings */
 #define REGFI_ENCODING_ASCII   0
@@ -210 +216 @@
                                     | REGFI_NK_FLAG_UNKNOWN3)
 
+
+#define CHAR_BIT 8
+#define TIME_T_MIN ((time_t)0 < (time_t) -1 ? (time_t) 0 \
+                    : ~ (time_t) 0 << (sizeof (time_t) * CHAR_BIT - 1))
+#define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
+#define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60))
+
+typedef struct _regfi_nttime
+{
+  uint32_t low;
+  uint32_t high;
+} REGFI_NTTIME;
+
+
 /* HBIN block */
 typedef struct _regfi_hbin 
 {
-  uint32 file_off;       /* my offset in the registry file */
-  uint32 ref_count;      /* how many active records are pointing to this
+  uint32_t file_off;       /* my offset in the registry file */
+  uint32_t ref_count;      /* how many active records are pointing to this
                           * block (not used currently) 
                           */
   
-  uint32 first_hbin_off; /* offset from first hbin block */
-  uint32 block_size;     /* block size of this block 
+  uint32_t first_hbin_off; /* offset from first hbin block */
+  uint32_t block_size;     /* block size of this block 
                           * Should be a multiple of 4096 (0x1000)
                           */
-  uint32 next_block;     /* relative offset to next block.  
+  uint32_t next_block;     /* relative offset to next block.  
                           * NOTE: This value may be unreliable!
                           */
 
-  uint8 magic[REGFI_HBIN_MAGIC_SIZE]; /* "hbin" */
+  uint8_t magic[REGFI_HBIN_MAGIC_SIZE]; /* "hbin" */
 } REGFI_HBIN;
 
@@ -236 +256 @@
    * depending on this list's type. 
    */
-  uint32 offset;
-
-  uint32 hash;
+  uint32_t offset;
+
+  uint32_t hash;
 } REGFI_SUBKEY_LIST_ELEM;
 
@@ -245 +265 @@
 {
   /* Real offset of this record's cell in the file */
-  uint32 offset;
-
-  uint32 cell_size;
+  uint32_t offset;
+
+  uint32_t cell_size;
   
   /* Number of immediate children */
-  uint32 num_children;  
+  uint32_t num_children;  
 
   /* Total number of keys referenced by this list and it's children */
-  uint32 num_keys;      
+  uint32_t num_keys;      
 
   REGFI_SUBKEY_LIST_ELEM* elements;
-  uint8 magic[REGFI_CELL_MAGIC_SIZE];
+  uint8_t magic[REGFI_CELL_MAGIC_SIZE];
 
   /* Set if the magic indicates this subkey list points to child subkey lists */
@@ -263 +283 @@
 
 
-typedef uint32 REGFI_VALUE_LIST_ELEM;
+typedef uint32_t REGFI_VALUE_LIST_ELEM;
 typedef struct _regfi_value_list
 {
@@ -269 +289 @@
    * May differ from parent key's num_values if there were parsing errors. 
    */
-  uint32 num_values;
+  uint32_t num_values;
 
   REGFI_VALUE_LIST_ELEM* elements;
@@ -281 +301 @@
 
   /* Represents raw buffer read from classname cell. */
-  uint8* raw;
+  uint8_t* raw;
 
   /* Length of the raw data. May be shorter than that indicated by parent key.*/
-  uint16 size;
+  uint16_t size;
 } REGFI_CLASSNAME;
 
@@ -290 +310 @@
 typedef struct _regfi_data
 {
-  uint32 type;
+  uint32_t type;
 
   /* Length of the raw data. */
-  uint32 size;
+  uint32_t size;
 
   /* This is always present, representing the raw data cell contents. */
-  uint8* raw;
+  uint8_t* raw;
 
   /* Represents the length of the interpreted value. Meaning is type-specific.*/
-  uint32 interpreted_size;
+  uint32_t interpreted_size;
 
   /* These items represent interpreted versions of the raw attribute above. 
@@ -307 +327 @@
   union _regfi_data_interpreted
   {
-    uint8* none; /* */
-    uint8* string;
-    uint8* expand_string;
-    uint8* binary; /* */
-    uint32 dword;
-    uint32 dword_be;
-    uint8* link;
-    uint8** multiple_string;
-    uint64 qword;
+    uint8_t* none; /* */
+    uint8_t* string;
+    uint8_t* expand_string;
+    uint8_t* binary; /* */
+    uint32_t dword;
+    uint32_t dword_be;
+    uint8_t* link;
+    uint8_t** multiple_string;
+    uint64_t qword;
 
     /* The following are treated as binary currently, but this may change in
      * the future as the formats become better understood.
      */
-    uint8* resource_list;
-    uint8* full_resource_descriptor;
-    uint8* resource_requirements_list;
+    uint8_t* resource_list;
+    uint8_t* full_resource_descriptor;
+    uint8_t* resource_requirements_list;
   } interpreted;
 } REGFI_DATA;
@@ -330 +350 @@
 typedef struct 
 {
-  uint32 offset;        /* Real offset of this record's cell in the file */
-  uint32 cell_size;     /* ((start_offset - end_offset) & 0xfffffff8) */
+  uint32_t offset;      /* Real offset of this record's cell in the file */
+  uint32_t cell_size;   /* ((start_offset - end_offset) & 0xfffffff8) */
 
   REGFI_DATA* data;     /* XXX: deprecated */
 
   char*  valuename;
-  uint8* valuename_raw;
-  uint16 name_length;
-  uint32 hbin_off;      /* offset from beginning of this hbin block */
+  uint8_t* valuename_raw;
+  uint16_t name_length;
+  uint32_t hbin_off;    /* offset from beginning of this hbin block */
   
-  uint32 data_size;     /* As reported in the VK record.  May be different than
+  uint32_t data_size;     /* As reported in the VK record.  May be different than
                          * That obtained while parsing the data cell itself. */
-  uint32 data_off;      /* Offset of data cell (virtual) */
-  uint32 type;
-  uint8  magic[REGFI_CELL_MAGIC_SIZE];
-  uint16 flags;
-  uint16 unknown1;
+  uint32_t data_off;      /* Offset of data cell (virtual) */
+  uint32_t type;
+  uint8_t  magic[REGFI_CELL_MAGIC_SIZE];
+  uint16_t flags;
+  uint16_t unknown1;
   bool data_in_offset;
 } REGFI_VK_REC;
@@ -356 +376 @@
 typedef struct _regfi_sk_rec 
 {
-  uint32 offset;        /* Real file offset of this record */
-  uint32 cell_size;     /* ((start_offset - end_offset) & 0xfffffff8) */
+  uint32_t offset;        /* Real file offset of this record */
+  uint32_t cell_size;   /* ((start_offset - end_offset) & 0xfffffff8) */
 
   WINSEC_DESC* sec_desc;
-  uint32 hbin_off;      /* offset from beginning of this hbin block */
+  uint32_t hbin_off;    /* offset from beginning of this hbin block */
   
-  uint32 prev_sk_off;
-  uint32 next_sk_off;
-  uint32 ref_count;
-  uint32 desc_size;     /* size of security descriptor */
-  uint16 unknown_tag;
-  uint8  magic[REGFI_CELL_MAGIC_SIZE];
+  uint32_t prev_sk_off;
+  uint32_t next_sk_off;
+  uint32_t ref_count;
+  uint32_t desc_size;     /* size of security descriptor */
+  uint16_t unknown_tag;
+  uint8_t  magic[REGFI_CELL_MAGIC_SIZE];
 } REGFI_SK_REC;
 
@@ -374 +394 @@
 typedef struct
 {
-  uint32 offset;        /* Real offset of this record's cell in the file */
-  uint32 cell_size;     /* Actual or estimated length of the cell.  
+  uint32_t offset;      /* Real offset of this record's cell in the file */
+  uint32_t cell_size;   /* Actual or estimated length of the cell.  
                          * Always in multiples of 8. 
                          */
@@ -384 +404 @@
   
   /* header information */
-  uint16 flags;
-  uint8  magic[REGFI_CELL_MAGIC_SIZE];
-  NTTIME mtime;
-  uint16 name_length;
-  uint16 classname_length;
+  uint16_t flags;
+  uint8_t  magic[REGFI_CELL_MAGIC_SIZE];
+  REGFI_NTTIME mtime;
+  uint16_t name_length;
+  uint16_t classname_length;
   char* keyname;
-  uint8* keyname_raw;
-  uint32 parent_off;                /* pointer to parent key */
-  uint32 classname_off;
+  uint8_t* keyname_raw;
+  uint32_t parent_off;              /* pointer to parent key */
+  uint32_t classname_off;
   
   /* max lengths */
-  uint32 max_bytes_subkeyname;      /* max subkey name * 2 */
-  uint32 max_bytes_subkeyclassname; /* max subkey classname length (as if) */
-  uint32 max_bytes_valuename;       /* max valuename * 2 */
-  uint32 max_bytes_value;           /* max value data size */
+  uint32_t max_bytes_subkeyname;            /* max subkey name * 2 */
+  uint32_t max_bytes_subkeyclassname; /* max subkey classname length (as if) */
+  uint32_t max_bytes_valuename;     /* max valuename * 2 */
+  uint32_t max_bytes_value;           /* max value data size */
   
   /* unknowns */
-  uint32 unknown1;
-  uint32 unknown2;
-  uint32 unknown3;
-  uint32 unk_index;                 /* nigel says run time index ? */
+  uint32_t unknown1;
+  uint32_t unknown2;
+  uint32_t unknown3;
+  uint32_t unk_index;               /* nigel says run time index ? */
   
   /* children */
-  uint32 num_subkeys;
-  uint32 subkeys_off;   /* offset of subkey list that points to NK records */
-  uint32 num_values;
-  uint32 values_off;    /* value lists which point to VK records */
-  uint32 sk_off;        /* offset to SK record */
+  uint32_t num_subkeys;
+  uint32_t subkeys_off; /* offset of subkey list that points to NK records */
+  uint32_t num_values;
+  uint32_t values_off;  /* value lists which point to VK records */
+  uint32_t sk_off;      /* offset to SK record */
 } REGFI_NK_REC;
 
@@ -425 +445 @@
 
   /* For sanity checking (not part of the registry header) */
-  uint32 file_length;
+  uint32_t file_length;
 
   /* Metadata about hbins */
@@ -437 +457 @@
 
   /* Mask for error message types that will be stored. */
-  uint16 msg_mask;
+  uint16_t msg_mask;
 
 
   /* Data parsed from file header */
   /********************************/
-  uint8  magic[REGFI_REGF_MAGIC_SIZE];/* "regf" */
+  uint8_t  magic[REGFI_REGF_MAGIC_SIZE];/* "regf" */
 
  /* These sequence numbers should match if
   * the hive was properly synced to disk.
   */
-  uint32 sequence1;            
-  uint32 sequence2;
-
-  NTTIME mtime;
-  uint32 major_version;  /* Set to 1 in all known hives */
-  uint32 minor_version;  /* Set to 3 or 5 in all known hives */
-  uint32 type;           /* XXX: Unverified.  Set to 0 in all known hives */
-  uint32 format;         /* XXX: Unverified.  Set to 1 in all known hives */
-
-  uint32 root_cell;  /* Offset to root cell in the first (or any?) hbin block */
-  uint32 last_block; /* Offset to last hbin block in file */
-
-  uint32 cluster;    /* XXX: Unverified. Set to 1 in all known hives */
+  uint32_t sequence1;            
+  uint32_t sequence2;
+
+  REGFI_NTTIME mtime;
+  uint32_t major_version;  /* Set to 1 in all known hives */
+  uint32_t minor_version;  /* Set to 3 or 5 in all known hives */
+  uint32_t type;           /* XXX: Unverified.  Set to 0 in all known hives */
+  uint32_t format;         /* XXX: Unverified.  Set to 1 in all known hives */
+
+  uint32_t root_cell;  /* Offset to root cell in the first (or any?) hbin block */
+  uint32_t last_block; /* Offset to last hbin block in file */
+
+  uint32_t cluster;    /* XXX: Unverified. Set to 1 in all known hives */
 
   /* Matches hive's base file name. Stored in UTF-16LE */
-  uint8 file_name[REGFI_REGF_NAME_SIZE];
+  uint8_t file_name[REGFI_REGF_NAME_SIZE];
 
   WINSEC_UUID* rm_id;       /* XXX: Unverified. */
   WINSEC_UUID* log_id;      /* XXX: Unverified. */
   WINSEC_UUID* tm_id;       /* XXX: Unverified. */
-  uint32 flags;             /* XXX: Unverified. */
-  uint32 guid_signature;    /* XXX: Unverified. */
-
-  uint32 checksum;          /* Stored checksum from file */
-  uint32 computed_checksum; /* Our own calculation of the checksum. 
+  uint32_t flags;             /* XXX: Unverified. */
+  uint32_t guid_signature;    /* XXX: Unverified. */
+
+  uint32_t checksum;          /* Stored checksum from file */
+  uint32_t computed_checksum; /* Our own calculation of the checksum. 
                              * (XOR of bytes 0x0000 - 0x01FB) */
 
@@ -477 +497 @@
   WINSEC_UUID* thaw_rm_id;  /* XXX: Unverified. */
   WINSEC_UUID* thaw_log_id; /* XXX: Unverified. */
-  uint32 boot_type;         /* XXX: Unverified. */
-  uint32 boot_recover;      /* XXX: Unverified. */
+  uint32_t boot_type;         /* XXX: Unverified. */
+  uint32_t boot_recover;      /* XXX: Unverified. */
 
   /* This seems to include random junk.  Possibly unsanitized memory left over
    * from when header block was written.  For instance, chunks of nk records 
    * can be found, though often it's all 0s. */
-  uint8 reserved1[REGFI_REGF_RESERVED1_SIZE];
+  uint8_t reserved1[REGFI_REGF_RESERVED1_SIZE];
 
   /* This is likely reserved and unusued currently.  (Should be all 0s.)
    * Included here for easier access in looking for hidden data 
    * or doing research. */
-  uint8 reserved2[REGFI_REGF_RESERVED2_SIZE];
+  uint8_t reserved2[REGFI_REGF_RESERVED2_SIZE];
 
 } REGFI_FILE;
@@ -499 +519 @@
   REGFI_NK_REC* cur_key;
   REGFI_ENCODING string_encoding;
-  uint32 cur_subkey;
-  uint32 cur_value;
+  uint32_t cur_subkey;
+  uint32_t cur_value;
 } REGFI_ITERATOR;
 
@@ -507 +527 @@
 {
   REGFI_NK_REC* nk;
-  uint32 cur_subkey;
+  uint32_t cur_subkey;
   /* We could store a cur_value here as well, but didn't see 
    * the use in it right now.
@@ -516 +536 @@
 typedef struct _regfi_buffer
 {
-  uint8* buf;
+  uint8_t* buf;
   uint32_t len;
 } REGFI_BUFFER;
 
 
-
-
 /******************************************************************************/
-/*                         Main iterator API                                  */
+/** 
+ * @defgroup regfiBase Base Functions: Usable with Any Layer
+ *
+ * These functions don't fit particularly well in any of the other layers or
+ * are intended for use with any of the API layers.
+ */
 /******************************************************************************/
 
-/* regfi_open: Attempts to open a registry hive and allocate related data
- *             structures.
- *
- * Arguments:
- *   filename -- A string containing the relative or absolute path of the
+
+/** Attempts to open a registry hive and allocate related data structures.
+ * 
+ * @param filename A string containing the relative or absolute path of the
  *               registry hive to be opened.
  *
- * Returns:
- *   A reference to a newly allocated REGFI_FILE structure, if successful. 
- *   NULL on error.
+ * @return A reference to a newly allocated REGFI_FILE structure, 
+ *         if successful;  NULL on error.
+ *
+ * @ingroup regfiBase
  */
 REGFI_FILE*           regfi_open(const char* filename);
 
 
-/* regfi_alloc: Parses file headers of an already open registry hive file and 
- *              allocates related structures for further parsing.
- *
- * Arguments:
- *   fd       -- A file descriptor of an already open file.  Must be seekable.
- *
- * Returns:
- *   A reference to a newly allocated REGFI_FILE structure, if successful. 
- *   NULL on error.
+/** Parses file headers of an already open registry hive file and 
+ *  allocates related structures for further parsing.
+ *
+ * @param fd A file descriptor of an already open file.  Must be seekable.
+ *
+ * @return A reference to a newly allocated REGFI_FILE structure, if successful;
+ *         NULL on error.
+ *
+ * @ingroup regfiBase
  */
 REGFI_FILE*           regfi_alloc(int fd);
 
 
-/* regfi_close: Closes and frees an open registry hive.
- *
- * Arguments:
- *   file     -- The registry structure to close.
- *
- * Returns:
- *   0 on success, -1 on failure with errno set.  
- *   errno codes are similar to those of close(2).
+/** Closes and frees an open registry hive.
+ *
+ * @param file The registry structure to close.
+ *
+ * @return 0 on success, -1 on failure with errno set.  
+ *         errno codes are similar to those of close(2).
+ *
+ * @ingroup regfiBase
  */
 int                   regfi_close(REGFI_FILE* file);
 
 
-/* regfi_free: Frees a hive's data structures without closing the underlying
- *             file.
- *
- * Arguments:
- *   file     -- The registry structure to free.
+/** Frees a hive's data structures without closing the underlying file.
+ *
+ * @param file The registry structure to free.
+ *
+ * @ingroup regfiBase
  */
 void                  regfi_free(REGFI_FILE* file);
 
 
-/* regfi_get_messages: Get errors, warnings, and/or verbose information
- *                     relating to processing of the given registry file.
- *
- * Arguments:
- *   file     -- the structure for the registry file
- *
- * Returns:
- *   A newly allocated char* which must be free()d by the caller.
+/** Get errors, warnings, and/or verbose information relating to processing of
+ *  the given registry file.
+ *
+ * @param file the structure for the registry file
+ *
+ * @return A newly allocated char* which must be free()d by the caller.
+ *
+ * @ingroup regfiBase
  */
 char*                 regfi_get_messages(REGFI_FILE* file);
 
 
-/* regfi_set_message_mask: Set the verbosity level of errors and warnings
- *                         generated by the library 
- *                         (as accessible via regfi_get_messages).
- *
- * Arguments:
- *   file     -- the structure for the registry file
- *   mask     -- an integer representing the types of messages desired.
+/** Set the verbosity level of errors and warnings generated by the library
+ *  (as accessible via regfi_get_messages).
+ *
+ * This may be called at any time and will take effect immediately.
+ *
+ * @param file   the structure for the registry file
+ *
+ * @param mask   an integer representing the types of messages desired.
  *               Acceptable values are created through bitwise ORs of 
  *               REGFI_MSG_* values.  For instance, if only errors and
@@ -606 +630 @@
  *               will prevent message accumulation.  
  *
- * This may be called at any time and will take effect immediately.
- */
-void                  regfi_set_message_mask(REGFI_FILE* file, uint16 mask);
-
-
-/* regfi_iterator_new: Creates a new iterator for the provided registry file.
- *
- * Arguments:
- *   file            -- The opened registry file the iterator should be
- *                      created for.
- *   output_encoding -- Character encoding that strings should be returned in.
- *                      Only supply the REGFI_ENCODING_* constants, as others 
- *                      will be rejected.
- *                      The following values are currently accepted:
- *                      REGFI_ENCODING_DEFAULT (currently REGFI_ENCODING_ASCII)
- *                      REGFI_ENCODING_ASCII
- *                      REGFI_ENCODING_UTF8
- *
- * Returns:
- *   A newly allocated REGFI_ITERATOR. Must be free()d with regfi_iterator_free.
+ * @ingroup regfiBase
+ */
+void                  regfi_set_message_mask(REGFI_FILE* file, uint16_t mask);
+
+
+/* Dispose of previously parsed records */
+
+/** Frees a key structure previously returned by one of the API functions
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBase
+ */
+void                  regfi_free_key(REGFI_NK_REC* nk);
+
+
+/** Frees a value structure previously returned by one of the API functions
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBase
+ */
+void                  regfi_free_value(REGFI_VK_REC* vk);
+
+
+
+/******************************************************************************/
+/** 
+ * @defgroup regfiTopLayer Top Layer: Primary regfi Library Interface
+ *
+ * This top layer of API functions provides an iterator interface which makes
+ * traversing registry data structures easy in both single-threaded and 
+ * multi-threaded scenarios.
+ */
+/******************************************************************************/
+
+/** Creates a new iterator for the provided registry file.
+ *
+ * @param file The opened registry file the iterator should be created for.
+ *
+ * @param output_encoding Character encoding that strings should be returned in.
+ *                        Only supply the REGFI_ENCODING_* constants, as others 
+ *                        will be rejected.
+ *                        The following values are currently accepted:
+ *                        REGFI_ENCODING_DEFAULT (currently REGFI_ENCODING_ASCII)
+ *                        REGFI_ENCODING_ASCII
+ *                        REGFI_ENCODING_UTF8
+ *
+ * @return A newly allocated REGFI_ITERATOR. 
+ *         Must be free()d with regfi_iterator_free.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_ITERATOR*       regfi_iterator_new(REGFI_FILE* file,
@@ -631 +687 @@
 
 
-/* regfi_iterator_free: Frees a registry file iterator previously created by 
- *                      regfi_iterator_new.
+/** Frees a registry file iterator previously created by regfi_iterator_new.
  *
  * This does not affect the underlying registry file's allocation status.
  *
- * Arguments:
- *   file            -- the iterator to be freed
+ * @param i the iterator to be freed
+ *
+ * @ingroup regfiTopLayer
  */
 void                  regfi_iterator_free(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_down: Traverse deeper into the registry tree at the
- *                      current subkey.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   true on success, false on failure.  Note that subkey and value indexes
- *   are preserved.  That is, if a regfi_iterator_up call occurs later
- *   (reversing the effect of this call) then the subkey and value referenced
- *   prior to the regfi_iterator_down call will still be referenced.  This 
- *   makes depth-first iteration particularly easy.
+/** Traverse deeper into the registry tree at the current subkey.
+ *
+ * @param i the iterator
+ *
+ * @return  true on success, false on failure.  
+ *          Note that subkey and value indexes are preserved.  That is, if a
+ *          regfi_iterator_up call occurs later (reversing the effect of this
+ *          call) then the subkey and value referenced prior to the
+ *          regfi_iterator_down call will still be referenced.  This  makes
+ *          depth-first iteration particularly easy.
+ *
+ * @ingroup regfiTopLayer
  */
 bool                  regfi_iterator_down(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_up: Traverse up to the current key's parent key.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   true on success, false on failure.  Any subkey or value state
- *   associated with the current key is lost.
+/** Traverse up to the current key's parent key.
+ *
+ * @param i the iterator
+ *
+ * @return  true on success, false on failure.  Any subkey or value state
+ *          associated with the current key is lost.
+ *
+ * @ingroup regfiTopLayer
  */
 bool                  regfi_iterator_up(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_to_root: Traverse up to the root key of the hive.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   true on success, false on failure.
+/** Traverse up to the root key of the hive.
+ *
+ * @param i the iterator
+ *
+ * @return true on success, false on failure.
+ *
+ * @ingroup regfiTopLayer
  */
 bool                  regfi_iterator_to_root(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_walk_path: Traverse down multiple levels in the registry hive.
- *
- * Arguments:
- *   i            -- the iterator
- *   path         -- a list of key names representing the path.  This list must
- *                   contain NUL terminated strings.  The list itself is
- *                   terminated with a NULL pointer.  All path elements must be
- *                   keys; value names are not accepted (even as the last
- *                   element).
+/** Traverse down multiple levels in the registry hive.
  *
  * XXX: This currently only accepts ASCII key names.  Need to look into
  *      accepting other encodings.
  *
- * Returns:
- *   true on success, false on failure.  If any element of path is not found,
- *   false will be returned and the iterator will remain in its original
- *   position.
- */
-bool                  regfi_iterator_walk_path(REGFI_ITERATOR* i, 
-                                               const char** path);
-
-
-/* regfi_iterator_cur_key: Returns the currently referenced key.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   A read-only key structure for the current key, or NULL on failure.
+ * @param i    the iterator
+ * @param path a list of key names representing the path.  This list must
+ *             contain NUL terminated strings.  The list itself is
+ *             terminated with a NULL pointer.  All path elements must be
+ *             keys; value names are not accepted (even as the last
+ *             element).
+ *
+ * @return true on success, false on failure.  If any element of path is not
+ *                 found, false will be returned and the iterator will remain
+ *                 in its original position.
+ *
+ * @ingroup regfiTopLayer
+ */
+bool regfi_iterator_walk_path(REGFI_ITERATOR* i, const char** path);
+
+
+/** Returns the currently referenced key.
+ *
+ * @param i the iterator
+ *
+ * @return A read-only key structure for the current key, or NULL on failure.
+ *
+ * @ingroup regfiTopLayer
  */
 const REGFI_NK_REC*   regfi_iterator_cur_key(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_cur_sk: Returns the SK (security) record referenced by the 
- *                        current key.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   A read-only SK structure, or NULL on failure.
+/** Returns the SK (security) record referenced by the current key.
+ *
+ * @param i the iterator
+ *
+ * @return A read-only SK structure, or NULL on failure.
+ *
+ * @ingroup regfiTopLayer
  */
 const REGFI_SK_REC*   regfi_iterator_cur_sk(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_first_subkey: Sets the internal subkey index to the first
- *                              subkey referenced by the current key and returns
- *                              that key.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   A newly allocated key structure for the newly referenced first subkey, or
- *   NULL on failure.  Failure may be due to a lack of any subkeys or other
- *   errors.  Newly allocated keys must be freed with regfi_free_key.
+/** Sets the internal subkey index to the first subkey referenced by the current
+ *  key and returns that key.
+ *
+ * @param i the iterator
+ *
+ * @return A newly allocated key structure for the newly referenced first 
+ *         subkey, or NULL on failure.  Failure may be due to a lack of any
+ *         subkeys or other errors.  Newly allocated keys must be freed with
+ *         regfi_free_key.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_NK_REC*         regfi_iterator_first_subkey(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_cur_subkey: Returns the currently indexed subkey.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   A newly allocated key structure for the currently referenced subkey,
- *   or NULL on failure.  Newly allocated keys must be freed with 
- *   regfi_free_key.
+/** Returns the currently indexed subkey.
+ *
+ * @param i the iterator
+ *
+ * @return A newly allocated key structure for the currently referenced subkey,
+ *         or NULL on failure.  Newly allocated keys must be freed with 
+ *         regfi_free_key.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_NK_REC*         regfi_iterator_cur_subkey(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_next_subkey: Increments the internal subkey index to the next
- *                             key in the subkey-list and returns the subkey
- *                             for that index.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   A newly allocated key structure for the next subkey or NULL on
- *   failure.  Newly allocated keys must be freed with
- *   regfi_free_key.
+/** Increments the internal subkey index to the next key in the subkey-list and
+ *  returns the subkey for that index.
+ *
+ * @param i the iterator
+ *
+ * @return A newly allocated key structure for the next subkey or NULL on
+ *         failure.  Newly allocated keys must be freed with regfi_free_key.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_NK_REC*         regfi_iterator_next_subkey(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_find_subkey: Searches for a subkey with a given name under the
- *                             current key.
- *
- * Arguments:
- *   i            -- the iterator
- *   subkey_name  -- subkey name to search for
- *
- * Returns:
- *   True if such a subkey was found, false otherwise.  If a subkey is found,
- *   the current subkey index is set to that subkey.  Otherwise, the subkey
- *   index remains at the same location as before the call.
+/** Searches for a subkey with a given name under the current key.
+ *
+ * @param i           the iterator
+ * @param subkey_name subkey name to search for
+ *
+ * @return True if such a subkey was found, false otherwise.  If a subkey is
+ *         found, the current subkey index is set to that subkey.  Otherwise,
+ *         the subkey index remains at the same location as before the call.
+ *
+ * @ingroup regfiTopLayer
  */
 bool                  regfi_iterator_find_subkey(REGFI_ITERATOR* i, 
                                                  const char* subkey_name);
 
-/* regfi_iterator_first_value: Sets the internal value index to the first
- *                             value referenced by the current key and returns
- *                             that value.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   A newly allocated value structure for the newly referenced first value, 
- *   or NULL on failure.  Failure may be due to a lack of any values or other
- *   errors.  Newly allocated keys must be freed with regfi_free_value.
+/** Sets the internal value index to the first value referenced by the current
+ *  key and returns that value.
+ *
+ * @param i the iterator
+ *
+ * @return  A newly allocated value structure for the newly referenced first
+ *          value, or NULL on failure.  Failure may be due to a lack of any
+ *          values or other errors.  Newly allocated keys must be freed with
+ *          regfi_free_value.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_VK_REC*         regfi_iterator_first_value(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_cur_value: Returns the currently indexed value.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   A newly allocated value structure for the currently referenced value, 
- *   or NULL on failure.  Newly allocated values must be freed with 
- *   regfi_free_value.
+/** Returns the currently indexed value.
+ *
+ * @param i the iterator
+ *
+ * @return A newly allocated value structure for the currently referenced value,
+ *         or NULL on failure.  Newly allocated values must be freed with 
+ *         regfi_free_value.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_VK_REC*         regfi_iterator_cur_value(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_next_value: Increments the internal value index to the next
- *                            value in the value-list and returns the value
- *                            for that index.
- *
- * Arguments:
- *   i            -- the iterator
- *
- * Returns:
- *   A newly allocated key structure for the next value or NULL on failure.
- *   Newly allocated keys must be freed with regfi_free_value.
+/** Increments the internal value index to the next value in the value-list and
+ *  returns the value for that index.
+ *
+ * @param i the iterator
+ *
+ * @return  A newly allocated key structure for the next value or NULL on 
+ *          failure.  Newly allocated keys must be freed with regfi_free_value.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_VK_REC*         regfi_iterator_next_value(REGFI_ITERATOR* i);
 
 
-/* regfi_iterator_find_value: Searches for a value with a given name under the
- *                            current key.
- *
- * Arguments:
- *   i            -- the iterator
- *   value_name   -- value name to search for
- *
- * Returns:
- *   True if such a value was found, false otherwise.  If a value is found,
- *   the current value index is set to that value.  Otherwise, the value
- *   index remains at the same location as before the call.
+/** Searches for a value with a given name under the current key.
+ *
+ * @param i          the iterator
+ * @param value_name value name to search for
+ *
+ * @return True if such a value was found, false otherwise.  If a value is 
+ *         found, the current value index is set to that value.  Otherwise,
+ *         the value index remains at the same location as before the call.
+ *
+ * @ingroup regfiTopLayer
  */
 bool                  regfi_iterator_find_value(REGFI_ITERATOR* i, 
                                                 const char* value_name);
 
-
-/* regfi_iterator_fetch_classname: Retrieves classname for a given key.
- *
- * Arguments:
- *   i            -- the iterator
- *   key          -- the key whose classname is desired
- *
- * Returns:
- *   Returns a newly allocated classname structure, or NULL on failure.
- *   Classname structures must be freed with regfi_free_classname.
+/** Retrieves classname for a given key.
+ *
+ * @param i   the iterator
+ * @param key the key whose classname is desired
+ *
+ * @return Returns a newly allocated classname structure, or NULL on failure.
+ *         Classname structures must be freed with regfi_free_classname.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_CLASSNAME*      regfi_iterator_fetch_classname(REGFI_ITERATOR* i, 
@@ -856 +904 @@
 
 
-/* regfi_iterator_fetch_data: Retrieves data for a given value.
- *
- * Arguments:
- *   i            -- the iterator
- *   value        -- the value whose data is desired
- *
- * Returns:
- *   Returns a newly allocated data structure, or NULL on failure.
- *   Data structures must be freed with regfi_free_data.
+/** Retrieves data for a given value.
+ *
+ * @param i     the iterator
+ * @param value the value whose data is desired
+ *
+ * @return Returns a newly allocated data structure, or NULL on failure.
+ *         Data structures must be freed with regfi_free_data.
+ *
+ * @ingroup regfiTopLayer
  */
 REGFI_DATA*           regfi_iterator_fetch_data(REGFI_ITERATOR* i, 
@@ -870 +918 @@
 
 
-/********************************************************/
-/* Middle-layer structure loading, linking, and caching */
-/********************************************************/
-REGFI_NK_REC*         regfi_load_key(REGFI_FILE* file, uint32 offset, 
+
+/******************************************************************************/
+/** 
+ * @defgroup regfiMiddleLayer Middle Layer: Logical Data Structure Loading 
+ */
+/******************************************************************************/
+
+/** Loads a key at a given file offset along with associated data structures.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
+REGFI_NK_REC*         regfi_load_key(REGFI_FILE* file, uint32_t offset, 
                                      REGFI_ENCODING output_encoding, 
                                      bool strict);
-REGFI_VK_REC*         regfi_load_value(REGFI_FILE* file, uint32 offset, 
+
+
+/** Loads a value at a given file offset alng with associated data structures.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
+REGFI_VK_REC*         regfi_load_value(REGFI_FILE* file, uint32_t offset, 
                                        REGFI_ENCODING output_encoding, 
                                        bool strict);
-REGFI_SUBKEY_LIST*    regfi_load_subkeylist(REGFI_FILE* file, uint32 offset,
-                                            uint32 num_keys, uint32 max_size,
+
+
+/** Loads a logical subkey list in its entirety which may span multiple records.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
+REGFI_SUBKEY_LIST*    regfi_load_subkeylist(REGFI_FILE* file, uint32_t offset,
+                                            uint32_t num_keys, uint32_t max_size,
                                             bool strict);
-REGFI_VALUE_LIST*     regfi_load_valuelist(REGFI_FILE* file, uint32 offset, 
-                                           uint32 num_values, uint32 max_size,
+
+
+/** Loads a valuelist.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
+REGFI_VALUE_LIST*     regfi_load_valuelist(REGFI_FILE* file, uint32_t offset, 
+                                           uint32_t num_values, uint32_t max_size,
                                            bool strict);
 
-REGFI_BUFFER          regfi_load_data(REGFI_FILE* file, uint32 voffset,
-                                      uint32 length, bool data_in_offset,
+
+/** Loads a data record which may be contained in the virtual offset, in a
+ *  single cell, or in multiple cells through big data records.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
+REGFI_BUFFER          regfi_load_data(REGFI_FILE* file, uint32_t voffset,
+                                      uint32_t length, bool data_in_offset,
                                       bool strict);
 
-REGFI_BUFFER          regfi_load_big_data(REGFI_FILE* file, uint32 offset, 
-                                          uint32 data_length,uint32 cell_length,
+
+/** Loads the data associated with a big data record at the specified offset.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
+REGFI_BUFFER          regfi_load_big_data(REGFI_FILE* file, uint32_t offset, 
+                                          uint32_t data_length,uint32_t cell_length,
                                           range_list* used_ranges,
                                           bool strict);
+
+
+/** Given raw data, attempts to interpret the data based on a specified registry
+ *  data type.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
 bool                  regfi_interpret_data(REGFI_FILE* file, 
                                            REGFI_ENCODING string_encoding,
-                                           uint32 type, REGFI_DATA* data);
+                                           uint32_t type, REGFI_DATA* data);
+
+
+/** Frees the memory associated with a REGFI_CLASSNAME data structure.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
 void                  regfi_free_classname(REGFI_CLASSNAME* classname);
+
+
+/** Frees the memory associated with a REGFI_DATA data structure.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
 void                  regfi_free_data(REGFI_DATA* data);
 
 
 /* These are cached so return values don't need to be freed. */
-const REGFI_SK_REC*   regfi_load_sk(REGFI_FILE* file, uint32 offset,
+
+/** Loads an "sk" security record at the specified offset.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
+const REGFI_SK_REC*   regfi_load_sk(REGFI_FILE* file, uint32_t offset,
                                     bool strict);
-const REGFI_HBIN*     regfi_lookup_hbin(REGFI_FILE* file, uint32 offset);
-
-
-/************************************/
-/*  Low-layer data structure access */
-/************************************/
+
+
+/** Retrieves the HBIN data structure stored at the specified offset.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiMiddleLayer
+ */
+const REGFI_HBIN*     regfi_lookup_hbin(REGFI_FILE* file, uint32_t offset);
+
+
+
+/******************************************************************************/
+/**
+ * @defgroup regfiBottomLayer Bottom Layer: Direct Data Structure Access 
+ */
+/******************************************************************************/
+
 REGFI_FILE*           regfi_parse_regf(int fd, bool strict);
-REGFI_HBIN*           regfi_parse_hbin(REGFI_FILE* file, uint32 offset, 
+REGFI_HBIN*           regfi_parse_hbin(REGFI_FILE* file, uint32_t offset, 
                                        bool strict);
 
 
-/* regfi_parse_nk: Parses an NK record.
- *
- * Arguments:
- *   f        -- the registry file structure
- *   offset   -- the offset of the cell (not the record) to be parsed.
- *   max_size -- the maximum size the NK cell could be. (for validation)
- *   strict   -- if true, rejects any malformed records.  Otherwise,
- *               tries to minimally validate integrity.
- * Returns:
- *   A newly allocated NK record structure, or NULL on failure.
- */
-REGFI_NK_REC*         regfi_parse_nk(REGFI_FILE* file, uint32 offset,
-                                     uint32 max_size, bool strict);
-
-REGFI_SUBKEY_LIST*    regfi_parse_subkeylist(REGFI_FILE* file, uint32 offset,
-                                             uint32 max_size, bool strict);
-
-REGFI_VK_REC*         regfi_parse_vk(REGFI_FILE* file, uint32 offset, 
-                                     uint32 max_size, bool strict);
-
-REGFI_SK_REC*         regfi_parse_sk(REGFI_FILE* file, uint32 offset, 
-                                     uint32 max_size, bool strict);
-
+/** Parses an NK record at the specified offset
+ *
+ * @param file     the registry file structure
+ * @param offset   the offset of the cell (not the record) to be parsed.
+ * @param max_size the maximum size the NK cell could be. (for validation)
+ * @param strict   if true, rejects any malformed records.  Otherwise,
+ *                 tries to minimally validate integrity.
+ *
+ * @return A newly allocated NK record structure, or NULL on failure.
+ *
+ * @ingroup regfiBottomLayer
+ */
+REGFI_NK_REC*         regfi_parse_nk(REGFI_FILE* file, uint32_t offset,
+                                     uint32_t max_size, bool strict);
+
+
+/** Parses a single cell containing a subkey-list record.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBottomLayer
+ */
+REGFI_SUBKEY_LIST*    regfi_parse_subkeylist(REGFI_FILE* file, uint32_t offset,
+                                             uint32_t max_size, bool strict);
+
+
+/** Parses a VK (value) record at the specified offset
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBottomLayer
+ */
+REGFI_VK_REC*         regfi_parse_vk(REGFI_FILE* file, uint32_t offset, 
+                                     uint32_t max_size, bool strict);
+
+
+/** Parses an SK (security) record at the specified offset
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBottomLayer
+ */
+REGFI_SK_REC*         regfi_parse_sk(REGFI_FILE* file, uint32_t offset, 
+                                     uint32_t max_size, bool strict);
+
+
+/** Retrieves information on all cells in the registry hive which are 
+ *  currently in the unallocated status.  
+ *
+ * The unallocated status is determined based soley on the cell length sign.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBottomLayer
+ */
 range_list*           regfi_parse_unalloc_cells(REGFI_FILE* file);
 
-bool                  regfi_parse_cell(int fd, uint32 offset, 
-                                       uint8* hdr, uint32 hdr_len,
-                                       uint32* cell_length, bool* unalloc);
-
-uint8*                regfi_parse_classname(REGFI_FILE* file, uint32 offset,
-                                            uint16* name_length, 
-                                            uint32 max_size, bool strict);
-
-REGFI_BUFFER          regfi_parse_data(REGFI_FILE* file, uint32 offset,
-                                       uint32 length, bool strict);
-
-REGFI_BUFFER          regfi_parse_little_data(REGFI_FILE* file, uint32 voffset, 
-                                              uint32 length, bool strict);
-
-
-/* Dispose of previously parsed records */
-void                  regfi_free_key(REGFI_NK_REC* nk);
-void                  regfi_free_value(REGFI_VK_REC* vk);
-
-
-
-/************************************/
-/*    Private Functions             */
-/************************************/
+
+/** Helper function to parse a cell
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBottomLayer
+ */
+bool                  regfi_parse_cell(int fd, uint32_t offset, 
+                                       uint8_t* hdr, uint32_t hdr_len,
+                                       uint32_t* cell_length, bool* unalloc);
+
+
+/** Parses a classname cell
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBottomLayer
+ */
+uint8_t*                regfi_parse_classname(REGFI_FILE* file, uint32_t offset,
+                                            uint16_t* name_length, 
+                                            uint32_t max_size, bool strict);
+
+
+/** Parses a single-cell data record
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBottomLayer
+ */
+REGFI_BUFFER          regfi_parse_data(REGFI_FILE* file, uint32_t offset,
+                                       uint32_t length, bool strict);
+
+
+/** Parses a "little data" record which is stored entirely within the 
+ *  provided virtual offset.
+ *
+ * XXX: finish documenting
+ *
+ * @ingroup regfiBottomLayer
+ */
+REGFI_BUFFER          regfi_parse_little_data(REGFI_FILE* file, uint32_t voffset, 
+                                              uint32_t length, bool strict);
+
+
+/******************************************************************************/
+/*    Private Functions                                                       */
+/******************************************************************************/
 REGFI_NK_REC*         regfi_rootkey(REGFI_FILE* file, 
                                     REGFI_ENCODING output_encoding);
 void                  regfi_subkeylist_free(REGFI_SUBKEY_LIST* list);
-uint32                regfi_read(int fd, uint8* buf, uint32* length);
+uint32_t                regfi_read(int fd, uint8_t* buf, uint32_t* length);
 
 const char*           regfi_type_val2str(unsigned int val);
@@ -977 +1173 @@
 char*                 regfi_get_group(WINSEC_DESC* sec_desc);
 
-REGFI_SUBKEY_LIST*    regfi_merge_subkeylists(uint16 num_lists, 
+REGFI_SUBKEY_LIST*    regfi_merge_subkeylists(uint16_t num_lists, 
                                               REGFI_SUBKEY_LIST** lists,
                                               bool strict);
-REGFI_SUBKEY_LIST*    regfi_load_subkeylist_aux(REGFI_FILE* file, uint32 offset,
-                                                uint32 max_size, bool strict,
-                                                uint8 depth_left);
-void                  regfi_add_message(REGFI_FILE* file, uint16 msg_type, 
+REGFI_SUBKEY_LIST*    regfi_load_subkeylist_aux(REGFI_FILE* file, uint32_t offset,
+                                                uint32_t max_size, bool strict,
+                                                uint8_t depth_left);
+void                  regfi_add_message(REGFI_FILE* file, uint16_t msg_type, 
                                         const char* fmt, ...);
 REGFI_NK_REC*         regfi_copy_nk(const REGFI_NK_REC* nk);
 REGFI_VK_REC*         regfi_copy_vk(const REGFI_VK_REC* vk);
-int32                 regfi_calc_maxsize(REGFI_FILE* file, uint32 offset);
-int32                 regfi_conv_charset(const char* input_charset, 
+int32_t               regfi_calc_maxsize(REGFI_FILE* file, uint32_t offset);
+int32_t               regfi_conv_charset(const char* input_charset, 
                                          const char* output_charset,
-                                         uint8* input, char* output, 
-                                         uint32 input_len, uint32 output_max);
+                                         uint8_t* input, char* output, 
+                                         uint32_t input_len, uint32_t output_max);
 REGFI_DATA*           regfi_buffer_to_data(REGFI_BUFFER raw_data);
 
+/* XXX: move to base API and document */
+void                  regfi_unix2nt_time(REGFI_NTTIME* nt, time_t t);
+time_t                regfi_nt2unix_time(const REGFI_NTTIME* nt);
+
+
 #endif  /* _REGFI_H */

trunk/include/talloc.h

@@ -33 +33 @@
 #include <string.h>
 #include <stdbool.h>
-#include "smb_deps.h" /* MAX macro */
+
+#ifndef MAX
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#endif
+
+#ifndef MIN
+#define MIN(a,b) ((a)<(b)?(a):(b))
+#endif
 
 /*

trunk/include/void_stack.h

@@ -1 @@
-/*
+/**
+ * @file
+ *
  * Copyright (C) 2005,2007,2009 Timothy D. Morgan
  *

trunk/include/winsec.h

@@ -1 @@
-/*
+/** @file
  * This file contains refactored Samba code used to interpret Windows
  * Security Descriptors. See:
@@ -41 +41 @@
 #include <unistd.h>
 
-#include "smb_deps.h"
 #include "talloc.h"
+#include "byteorder.h"
 
 
@@ -72 +72 @@
 typedef struct _winsec_uuid
 {
-       uint32 time_low;
-       uint16 time_mid;
-       uint16 time_hi_and_version;
-       uint8  clock_seq[2];
-       uint8  node[6];
+       uint32_t time_low;
+       uint16_t time_mid;
+       uint16_t time_hi_and_version;
+       uint8_t  clock_seq[2];
+       uint8_t  node[6];
 } WINSEC_UUID;
 

trunk/lib/Makefile

@@ -3 +3 @@
 ################################################################################
 
-FILES=regfi.o smb_deps.o winsec.o void_stack.o range_list.o lru_cache.o talloc.o
+FILES=regfi.o winsec.o void_stack.o range_list.o lru_cache.o talloc.o
 
 all: $(FILES)
@@ -9 +9 @@
 regfi.o: regfi.c
         $(CC) $(CFLAGS) $(OPTS) $(INC) -c -o $@ regfi.c
-
-smb_deps.o: smb_deps.c
-        $(CC) $(CFLAGS) $(OPTS) $(INC) -c -o $@ smb_deps.c
 
 winsec.o: winsec.c

trunk/lib/lru_cache.c

@@ -1 @@
-/*
+/**
+ * @file
+ *
  * Copyright (C) 2008-2009 Timothy D. Morgan
  *

trunk/lib/range_list.c

@@ -1 @@
-/*
+/**
+ * @file
+ *
  * Copyright (C) 2008-2009 Timothy D. Morgan
  *

trunk/lib/regfi.c

@@ -24 +24 @@
  */
 
+/** @file */
+
 #include "regfi.h"
 
@@ -39 +41 @@
 /******************************************************************************
  ******************************************************************************/
-void regfi_add_message(REGFI_FILE* file, uint16 msg_type, const char* fmt, ...)
+void regfi_add_message(REGFI_FILE* file, uint16_t msg_type, const char* fmt, ...)
 {
   /* XXX: This function is not particularly efficient,
    *      but then it is mostly used during errors. 
    */
-  uint32 buf_size, buf_used;
+  uint32_t buf_size, buf_used;
   char* new_msg;
   va_list args;
@@ -98 +100 @@
 
 
-void regfi_set_message_mask(REGFI_FILE* file, uint16 mask)
+void regfi_set_message_mask(REGFI_FILE* file, uint16_t mask)
 {
   file->msg_mask = mask;
@@ -154 +156 @@
 /* Security descriptor formatting functions  */
 
-const char* regfi_ace_type2str(uint8 type)
+const char* regfi_ace_type2str(uint8_t type)
 {
   static const char* map[7] 
@@ -174 +176 @@
  *   http://msdn2.microsoft.com/en-us/library/aa772242.aspx
  */
-char* regfi_ace_flags2str(uint8 flags)
+char* regfi_ace_flags2str(uint8_t flags)
 {
   static const char* flag_map[32] = 
@@ -189 +191 @@
   char* ret_val = malloc(35*sizeof(char));
   char* fo = ret_val;
-  uint32 i;
-  uint8 f;
+  uint32_t i;
+  uint8_t f;
 
   if(ret_val == NULL)
@@ -223 +225 @@
 
 
-char* regfi_ace_perms2str(uint32 perms)
-{
-  uint32 i, p;
+char* regfi_ace_perms2str(uint32_t perms)
+{
+  uint32_t i, p;
   /* This is more than is needed by a fair margin. */
   char* ret_val = malloc(350*sizeof(char));
@@ -304 +306 @@
 char* regfi_sid2str(WINSEC_DOM_SID* sid)
 {
-  uint32 i, size = WINSEC_MAX_SUBAUTHS*11 + 24;
-  uint32 left = size;
-  uint8 comps = sid->num_auths;
+  uint32_t i, size = WINSEC_MAX_SUBAUTHS*11 + 24;
+  uint32_t left = size;
+  uint8_t comps = sid->num_auths;
   char* ret_val = malloc(size);
   
@@ -326 +328 @@
 char* regfi_get_acl(WINSEC_ACL* acl)
 {
-  uint32 i, extra, size = 0;
+  uint32_t i, extra, size = 0;
   const char* type_str;
   char* flags_str;
@@ -425 +427 @@
  * returned as 0, then EOF was encountered immediately
  *****************************************************************************/
-uint32 regfi_read(int fd, uint8* buf, uint32* length)
-{
-  uint32 rsize = 0;
-  uint32 rret = 0;
+uint32_t regfi_read(int fd, uint8_t* buf, uint32_t* length)
+{
+  uint32_t rsize = 0;
+  uint32_t rret = 0;
 
   do
@@ -449 +451 @@
  *
  *****************************************************************************/
-bool regfi_parse_cell(int fd, uint32 offset, uint8* hdr, uint32 hdr_len,
-                      uint32* cell_length, bool* unalloc)
-{
-  uint32 length;
-  int32 raw_length;
-  uint8 tmp[4];
+bool regfi_parse_cell(int fd, uint32_t offset, uint8_t* hdr, uint32_t hdr_len,
+                      uint32_t* cell_length, bool* unalloc)
+{
+  uint32_t length;
+  int32_t raw_length;
+  uint8_t tmp[4];
 
   if(lseek(fd, offset, SEEK_SET) == -1)
@@ -493 +495 @@
  * The offset is a virtual file offset.
  ******************************************************************************/
-static bool regfi_offset_in_hbin(const REGFI_HBIN* hbin, uint32 voffset)
+static bool regfi_offset_in_hbin(const REGFI_HBIN* hbin, uint32_t voffset)
 {
   if(!hbin)
@@ -511 +513 @@
  * block for it.  NULL if one doesn't exist.
  ******************************************************************************/
-const REGFI_HBIN* regfi_lookup_hbin(REGFI_FILE* file, uint32 offset)
+const REGFI_HBIN* regfi_lookup_hbin(REGFI_FILE* file, uint32_t offset)
 {
   return (const REGFI_HBIN*)range_list_find_data(file->hbins, offset);
@@ -523 +525 @@
  * (Since cells can only be ~2^31 in size, this works out.)
  ******************************************************************************/
-int32 regfi_calc_maxsize(REGFI_FILE* file, uint32 offset)
+int32_t regfi_calc_maxsize(REGFI_FILE* file, uint32_t offset)
 {
   const REGFI_HBIN* hbin = regfi_lookup_hbin(file, offset);
@@ -535 +537 @@
 /******************************************************************************
  ******************************************************************************/
-REGFI_SUBKEY_LIST* regfi_load_subkeylist(REGFI_FILE* file, uint32 offset, 
-                                         uint32 num_keys, uint32 max_size, 
+REGFI_SUBKEY_LIST* regfi_load_subkeylist(REGFI_FILE* file, uint32_t offset, 
+                                         uint32_t num_keys, uint32_t max_size, 
                                          bool strict)
 {
@@ -568 +570 @@
 /******************************************************************************
  ******************************************************************************/
-REGFI_SUBKEY_LIST* regfi_load_subkeylist_aux(REGFI_FILE* file, uint32 offset, 
-                                             uint32 max_size, bool strict,
-                                             uint8 depth_left)
+REGFI_SUBKEY_LIST* regfi_load_subkeylist_aux(REGFI_FILE* file, uint32_t offset, 
+                                             uint32_t max_size, bool strict,
+                                             uint8_t depth_left)
 {
   REGFI_SUBKEY_LIST* ret_val;
   REGFI_SUBKEY_LIST** sublists;
-  uint32 i, num_sublists, off;
-  int32 sublist_maxsize;
+  uint32_t i, num_sublists, off;
+  int32_t sublist_maxsize;
 
   if(depth_left == 0)
@@ -616 +618 @@
 /******************************************************************************
  ******************************************************************************/
-REGFI_SUBKEY_LIST* regfi_parse_subkeylist(REGFI_FILE* file, uint32 offset, 
-                                          uint32 max_size, bool strict)
+REGFI_SUBKEY_LIST* regfi_parse_subkeylist(REGFI_FILE* file, uint32_t offset, 
+                                          uint32_t max_size, bool strict)
 {
   REGFI_SUBKEY_LIST* ret_val;
-  uint32 i, cell_length, length, elem_size, read_len;
-  uint8* elements = NULL;
-  uint8 buf[REGFI_SUBKEY_LIST_MIN_LEN];
+  uint32_t i, cell_length, length, elem_size, read_len;
+  uint8_t* elements = NULL;
+  uint8_t buf[REGFI_SUBKEY_LIST_MIN_LEN];
   bool unalloc;
   bool recursive_type;
@@ -647 +649 @@
   {
     recursive_type = true;
-    elem_size = sizeof(uint32);
+    elem_size = sizeof(uint32_t);
   }
   else if(buf[0] == 'l' && buf[1] == 'i')
-    elem_size = sizeof(uint32);
+    elem_size = sizeof(uint32_t);
   else if((buf[0] == 'l') && (buf[1] == 'f' || buf[1] == 'h'))
     elem_size = sizeof(REGFI_SUBKEY_LIST_ELEM);
@@ -676 +678 @@
 
   length = elem_size*ret_val->num_children;
-  if(cell_length - REGFI_SUBKEY_LIST_MIN_LEN - sizeof(uint32) < length)
+  if(cell_length - REGFI_SUBKEY_LIST_MIN_LEN - sizeof(uint32_t) < length)
   {
     regfi_add_message(file, REGFI_MSG_WARN, "Number of elements too large for"
@@ -683 +685 @@
     if(strict)
       goto fail;
-    length = cell_length - REGFI_SUBKEY_LIST_MIN_LEN - sizeof(uint32);
+    length = cell_length - REGFI_SUBKEY_LIST_MIN_LEN - sizeof(uint32_t);
   }
 
@@ -691 +693 @@
     goto fail;
 
-  elements = (uint8*)malloc(length);
+  elements = (uint8_t*)malloc(length);
   if(elements == NULL)
     goto fail;
@@ -699 +701 @@
     goto fail;
 
-  if(elem_size == sizeof(uint32))
+  if(elem_size == sizeof(uint32_t))
   {
     for (i=0; i < ret_val->num_children; i++)
@@ -729 +731 @@
 /*******************************************************************
  *******************************************************************/
-REGFI_SUBKEY_LIST* regfi_merge_subkeylists(uint16 num_lists, 
+REGFI_SUBKEY_LIST* regfi_merge_subkeylists(uint16_t num_lists, 
                                            REGFI_SUBKEY_LIST** lists,
                                            bool strict)
 {
-  uint32 i,j,k;
+  uint32_t i,j,k;
   REGFI_SUBKEY_LIST* ret_val;
 
@@ -785 +787 @@
  *
  ******************************************************************************/
-REGFI_SK_REC* regfi_parse_sk(REGFI_FILE* file, uint32 offset, uint32 max_size, 
+REGFI_SK_REC* regfi_parse_sk(REGFI_FILE* file, uint32_t offset, uint32_t max_size, 
                              bool strict)
 {
   REGFI_SK_REC* ret_val;
-  uint8* sec_desc_buf = NULL;
-  uint32 cell_length, length;
-  uint8 sk_header[REGFI_SK_MIN_LENGTH];
+  uint8_t* sec_desc_buf = NULL;
+  uint32_t cell_length, length;
+  uint8_t sk_header[REGFI_SK_MIN_LENGTH];
   bool unalloc = false;
 
@@ -855 +857 @@
   }
 
-  sec_desc_buf = (uint8*)malloc(ret_val->desc_size);
+  sec_desc_buf = (uint8_t*)malloc(ret_val->desc_size);
   if(sec_desc_buf == NULL)
     goto fail;
@@ -889 +891 @@
 
 
-REGFI_VALUE_LIST* regfi_parse_valuelist(REGFI_FILE* file, uint32 offset, 
-                                        uint32 num_values, bool strict)
+REGFI_VALUE_LIST* regfi_parse_valuelist(REGFI_FILE* file, uint32_t offset, 
+                                        uint32_t num_values, bool strict)
 {
   REGFI_VALUE_LIST* ret_val;
-  uint32 i, cell_length, length, read_len;
+  uint32_t i, cell_length, length, read_len;
   bool unalloc;
 
@@ -912 +914 @@
   }
 
-  if((num_values * sizeof(uint32)) > cell_length-sizeof(uint32))
+  if((num_values * sizeof(uint32_t)) > cell_length-sizeof(uint32_t))
   {
     regfi_add_message(file, REGFI_MSG_WARN, "Too many values found"
@@ -918 +920 @@
     if(strict)
       return NULL;
-    num_values = cell_length/sizeof(uint32) - sizeof(uint32);
-  }
-
-  read_len = num_values*sizeof(uint32);
+    num_values = cell_length/sizeof(uint32_t) - sizeof(uint32_t);
+  }
+
+  read_len = num_values*sizeof(uint32_t);
   ret_val = talloc(NULL, REGFI_VALUE_LIST);
   if(ret_val == NULL)
@@ -935 +937 @@
 
   length = read_len;
-  if((regfi_read(file->fd, (uint8*)ret_val->elements, &length) != 0) 
+  if((regfi_read(file->fd, (uint8_t*)ret_val->elements, &length) != 0) 
      || length != read_len)
   {
@@ -973 +975 @@
 /******************************************************************************
  ******************************************************************************/
-REGFI_VK_REC* regfi_load_value(REGFI_FILE* file, uint32 offset, 
+REGFI_VK_REC* regfi_load_value(REGFI_FILE* file, uint32_t offset, 
                                REGFI_ENCODING output_encoding, bool strict)
 {
   REGFI_VK_REC* ret_val = NULL;
-  int32 max_size, tmp_size;
+  int32_t max_size, tmp_size;
   REGFI_ENCODING from_encoding;
 
@@ -1003 +1005 @@
   {
     ret_val->valuename_raw = talloc_realloc(ret_val, ret_val->valuename_raw,
-                                            uint8, ret_val->name_length+1);
+                                            uint8_t, ret_val->name_length+1);
     ret_val->valuename_raw[ret_val->name_length] = '\0';
     ret_val->valuename = (char*)ret_val->valuename_raw;
@@ -1038 +1040 @@
  * If !strict, the list may contain NULLs, VK records may point to NULL.
  ******************************************************************************/
-REGFI_VALUE_LIST* regfi_load_valuelist(REGFI_FILE* file, uint32 offset, 
-                                       uint32 num_values, uint32 max_size,
+REGFI_VALUE_LIST* regfi_load_valuelist(REGFI_FILE* file, uint32_t offset, 
+                                       uint32_t num_values, uint32_t max_size,
                                        bool strict)
 {
-  uint32 usable_num_values;
-
-  if((num_values+1) * sizeof(uint32) > max_size)
+  uint32_t usable_num_values;
+
+  if((num_values+1) * sizeof(uint32_t) > max_size)
   {
     regfi_add_message(file, REGFI_MSG_WARN, "Number of values indicated by"
@@ -1052 +1054 @@
     if(strict)
       return NULL;
-    usable_num_values = max_size/sizeof(uint32) - sizeof(uint32);
+    usable_num_values = max_size/sizeof(uint32_t) - sizeof(uint32_t);
   }
   else
@@ -1065 +1067 @@
  *
  ******************************************************************************/
-REGFI_NK_REC* regfi_load_key(REGFI_FILE* file, uint32 offset, 
+REGFI_NK_REC* regfi_load_key(REGFI_FILE* file, uint32_t offset, 
                              REGFI_ENCODING output_encoding, bool strict)
 {
   REGFI_NK_REC* nk;
-  uint32 off;
-  int32 max_size, tmp_size;
+  uint32_t off;
+  int32_t max_size, tmp_size;
   REGFI_ENCODING from_encoding;
 
@@ -1097 +1099 @@
   if(from_encoding == output_encoding)
   {
-    nk->keyname_raw = talloc_realloc(nk, nk->keyname_raw, uint8, nk->name_length+1);
+    nk->keyname_raw = talloc_realloc(nk, nk->keyname_raw, uint8_t, nk->name_length+1);
     nk->keyname_raw[nk->name_length] = '\0';
     nk->keyname = (char*)nk->keyname_raw;
@@ -1196 +1198 @@
 /******************************************************************************
  ******************************************************************************/
-const REGFI_SK_REC* regfi_load_sk(REGFI_FILE* file, uint32 offset, bool strict)
+const REGFI_SK_REC* regfi_load_sk(REGFI_FILE* file, uint32_t offset, bool strict)
 {
   REGFI_SK_REC* ret_val = NULL;
-  int32 max_size;
+  int32_t max_size;
   void* failure_ptr = NULL;
   
@@ -1240 +1242 @@
 {
   REGFI_NK_REC* nk = NULL;
-  uint32 cell_length;
-  uint32 cur_offset = hbin->file_off+REGFI_HBIN_HEADER_SIZE;
-  uint32 hbin_end = hbin->file_off+hbin->block_size;
+  uint32_t cell_length;
+  uint32_t cur_offset = hbin->file_off+REGFI_HBIN_HEADER_SIZE;
+  uint32_t hbin_end = hbin->file_off+hbin->block_size;
   bool unalloc;
 
@@ -1301 +1303 @@
   REGFI_FILE* rb;
   REGFI_HBIN* hbin = NULL;
-  uint32 hbin_off, file_length, cache_secret;
+  uint32_t hbin_off, file_length, cache_secret;
   bool rla;
 
@@ -1397 +1399 @@
   REGFI_NK_REC* nk = NULL;
   REGFI_HBIN* hbin;
-  uint32 root_offset, i, num_hbins;
+  uint32_t root_offset, i, num_hbins;
   
   if(!file)
@@ -1584 +1586 @@
   REGFI_NK_REC* subkey;
   bool found = false;
-  uint32 old_subkey = i->cur_subkey;
+  uint32_t old_subkey = i->cur_subkey;
 
   if(subkey_name == NULL)
@@ -1618 +1620 @@
 bool regfi_iterator_walk_path(REGFI_ITERATOR* i, const char** path)
 {
-  uint32 x;
+  uint32_t x;
   if(path == NULL)
     return false;
@@ -1671 +1673 @@
 REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
 {
-  uint32 nk_offset;
+  uint32_t nk_offset;
 
   /* see if there is anything left to report */
@@ -1708 +1710 @@
   REGFI_VK_REC* cur;
   bool found = false;
-  uint32 old_value = i->cur_value;
+  uint32_t old_value = i->cur_value;
 
   /* XXX: cur->valuename can be NULL in the registry.  
@@ -1754 +1756 @@
 {
   REGFI_VK_REC* ret_val = NULL;
-  uint32 voffset;
+  uint32_t voffset;
 
   if(i->cur_key->values != NULL && i->cur_key->values->elements != NULL)
@@ -1791 +1793 @@
 {
   REGFI_CLASSNAME* ret_val;
-  uint8* raw;
+  uint8_t* raw;
   char* interpreted;
-  uint32 offset;
-  int32 conv_size, max_size;
-  uint16 parse_length;
+  uint32_t offset;
+  int32_t conv_size, max_size;
+  uint16_t parse_length;
 
   if(key->classname_off == REGFI_OFFSET_NONE || key->classname_length == 0)
@@ -1935 +1937 @@
  *****************************************************************************/
 bool regfi_interpret_data(REGFI_FILE* file, REGFI_ENCODING string_encoding,
-                          uint32 type, REGFI_DATA* data)
-{
-  uint8** tmp_array;
-  uint8* tmp_str;
-  int32 tmp_size;
-  uint32 i, j, array_size;
+                          uint32_t type, REGFI_DATA* data)
+{
+  uint8_t** tmp_array;
+  uint8_t* tmp_str;
+  int32_t tmp_size;
+  uint32_t i, j, array_size;
 
   if(data == NULL)
@@ -1951 +1953 @@
   /* REG_LINK is a symbolic link, stored as a unicode string. */
   case REG_LINK:
-    tmp_str = talloc_array(NULL, uint8, data->size);
+    tmp_str = talloc_array(NULL, uint8_t, data->size);
     if(tmp_str == NULL)
     {
@@ -1974 +1976 @@
     }
 
-    tmp_str = talloc_realloc(NULL, tmp_str, uint8, tmp_size);
+    tmp_str = talloc_realloc(NULL, tmp_str, uint8_t, tmp_size);
     data->interpreted.string = tmp_str;
     data->interpreted_size = tmp_size;
@@ -2010 +2012 @@
     }
     data->interpreted.qword = 
-      (uint64)IVAL(data->raw, 0) + (((uint64)IVAL(data->raw, 4))<<32);
+      (uint64_t)IVAL(data->raw, 0) + (((uint64_t)IVAL(data->raw, 4))<<32);
     data->interpreted_size = 8;
     break;
     
   case REG_MULTI_SZ:
-    tmp_str = talloc_array(NULL, uint8, data->size);
+    tmp_str = talloc_array(NULL, uint8_t, data->size);
     if(tmp_str == NULL)
     {
@@ -2042 +2044 @@
 
     array_size = tmp_size+1;
-    tmp_array = talloc_array(NULL, uint8*, array_size);
+    tmp_array = talloc_array(NULL, uint8_t*, array_size);
     if(tmp_array == NULL)
     {
@@ -2058 +2060 @@
     }
     tmp_array[j] = NULL;
-    tmp_array = talloc_realloc(NULL, tmp_array, uint8*, j+1);
+    tmp_array = talloc_realloc(NULL, tmp_array, uint8_t*, j+1);
     data->interpreted.multiple_string = tmp_array;
     /* XXX: how meaningful is this?  should we store number of strings instead? */
@@ -2107 +2109 @@
  * On error, returns a negative errno code.
  *****************************************************************************/
-int32 regfi_conv_charset(const char* input_charset, const char* output_charset,
-                         uint8* input, char* output, 
-                         uint32 input_len, uint32 output_max)
+int32_t regfi_conv_charset(const char* input_charset, const char* output_charset,
+                         uint8_t* input, char* output, 
+                         uint32_t input_len, uint32_t output_max)
 {
   iconv_t conv_desc;
@@ -2144 +2146 @@
  * buffer must be at least the size of a regf header (4096 bytes).
  *******************************************************************/
-static uint32 regfi_compute_header_checksum(uint8* buffer)
-{
-  uint32 checksum, x;
+static uint32_t regfi_compute_header_checksum(uint8_t* buffer)
+{
+  uint32_t checksum, x;
   int i;
 
@@ -2167 +2169 @@
 REGFI_FILE* regfi_parse_regf(int fd, bool strict)
 {
-  uint8 file_header[REGFI_REGF_SIZE];
-  uint32 length;
+  uint8_t file_header[REGFI_REGF_SIZE];
+  uint32_t length;
   REGFI_FILE* ret_val;
 
@@ -2243 +2245 @@
  * along with it's associated cells.
  ******************************************************************************/
-REGFI_HBIN* regfi_parse_hbin(REGFI_FILE* file, uint32 offset, bool strict)
+REGFI_HBIN* regfi_parse_hbin(REGFI_FILE* file, uint32_t offset, bool strict)
 {
   REGFI_HBIN *hbin;
-  uint8 hbin_header[REGFI_HBIN_HEADER_SIZE];
-  uint32 length;
+  uint8_t hbin_header[REGFI_HBIN_HEADER_SIZE];
+  uint32_t length;
   
   if(offset >= file->file_length)
@@ -2315 +2317 @@
 /*******************************************************************
  *******************************************************************/
-REGFI_NK_REC* regfi_parse_nk(REGFI_FILE* file, uint32 offset, 
-                             uint32 max_size, bool strict)
-{
-  uint8 nk_header[REGFI_NK_MIN_LENGTH];
+REGFI_NK_REC* 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;
-  uint32 length,cell_length;
+  uint32_t length,cell_length;
   bool unalloc = false;
 
@@ -2432 +2434 @@
   }
 
-  ret_val->keyname_raw = talloc_array(ret_val, uint8, ret_val->name_length);
+  ret_val->keyname_raw = talloc_array(ret_val, uint8_t, ret_val->name_length);
   if(ret_val->keyname_raw == NULL)
   {
@@ -2441 +2443 @@
   /* Don't need to seek, should be at the right offset */
   length = ret_val->name_length;
-  if((regfi_read(file->fd, (uint8*)ret_val->keyname_raw, &length) != 0)
+  if((regfi_read(file->fd, (uint8_t*)ret_val->keyname_raw, &length) != 0)
      || length != ret_val->name_length)
   {
@@ -2454 +2456 @@
 
 
-uint8* regfi_parse_classname(REGFI_FILE* file, uint32 offset, 
-                             uint16* name_length, uint32 max_size, bool strict)
-{
-  uint8* ret_val = NULL;
-  uint32 length;
-  uint32 cell_length;
+uint8_t* regfi_parse_classname(REGFI_FILE* file, uint32_t offset, 
+                             uint16_t* name_length, uint32_t max_size, bool strict)
+{
+  uint8_t* ret_val = NULL;
+  uint32_t length;
+  uint32_t cell_length;
   bool unalloc = false;
 
@@ -2499 +2501 @@
     }
     
-    ret_val = talloc_array(NULL, uint8, *name_length);
+    ret_val = talloc_array(NULL, uint8_t, *name_length);
     if(ret_val != NULL)
     {
@@ -2520 +2522 @@
 /******************************************************************************
 *******************************************************************************/
-REGFI_VK_REC* regfi_parse_vk(REGFI_FILE* file, uint32 offset, 
-                             uint32 max_size, bool strict)
+REGFI_VK_REC* regfi_parse_vk(REGFI_FILE* file, uint32_t offset, 
+                             uint32_t max_size, bool strict)
 {
   REGFI_VK_REC* ret_val;
-  uint8 vk_header[REGFI_VK_MIN_LENGTH];
-  uint32 raw_data_size, length, cell_length;
+  uint8_t vk_header[REGFI_VK_MIN_LENGTH];
+  uint32_t raw_data_size, length, cell_length;
   bool unalloc = false;
 
@@ -2604 +2606 @@
       cell_length+=8;
 
-    ret_val->valuename_raw = talloc_array(ret_val, uint8, ret_val->name_length);
+    ret_val->valuename_raw = talloc_array(ret_val, uint8_t, ret_val->name_length);
     if(ret_val->valuename_raw == NULL)
     {
@@ -2612 +2614 @@
 
     length = ret_val->name_length;
-    if((regfi_read(file->fd, (uint8*)ret_val->valuename_raw, &length) != 0)
+    if((regfi_read(file->fd, (uint8_t*)ret_val->valuename_raw, &length) != 0)
        || length != ret_val->name_length)
     {
@@ -2638 +2640 @@
  *
  ******************************************************************************/
-REGFI_BUFFER regfi_load_data(REGFI_FILE* file, uint32 voffset,
-                             uint32 length, bool data_in_offset,
+REGFI_BUFFER regfi_load_data(REGFI_FILE* file, uint32_t voffset,
+                             uint32_t length, bool data_in_offset,
                              bool strict)
 {
   REGFI_BUFFER ret_val;
-  uint32 cell_length, offset;
-  int32 max_size;
+  uint32_t cell_length, offset;
+  int32_t max_size;
   bool unalloc;
   
@@ -2744 +2746 @@
  * Parses the common case data records stored in a single cell.
  ******************************************************************************/
-REGFI_BUFFER regfi_parse_data(REGFI_FILE* file, uint32 offset,
-                              uint32 length, bool strict)
+REGFI_BUFFER regfi_parse_data(REGFI_FILE* file, uint32_t offset,
+                              uint32_t length, bool strict)
 {
   REGFI_BUFFER ret_val;
-  uint32 read_length;
+  uint32_t read_length;
 
   ret_val.buf = NULL;
@@ -2760 +2762 @@
   }
 
-  if((ret_val.buf = talloc_array(NULL, uint8, length)) == NULL)
+  if((ret_val.buf = talloc_array(NULL, uint8_t, length)) == NULL)
     return ret_val;
   ret_val.len = length;
@@ -2783 +2785 @@
  *
  ******************************************************************************/
-REGFI_BUFFER regfi_parse_little_data(REGFI_FILE* file, uint32 voffset,
-                                     uint32 length, bool strict)
+REGFI_BUFFER regfi_parse_little_data(REGFI_FILE* file, uint32_t voffset,
+                                     uint32_t length, bool strict)
 {
   REGFI_BUFFER ret_val;
-  uint8 i;
+  uint8_t i;
 
   ret_val.buf = NULL;
@@ -2800 +2802 @@
   }
 
-  if((ret_val.buf = talloc_array(NULL, uint8, length)) == NULL)
+  if((ret_val.buf = talloc_array(NULL, uint8_t, length)) == NULL)
     return ret_val;
   ret_val.len = length;
   
   for(i = 0; i < length; i++)
-    ret_val.buf[i] = (uint8)((voffset >> i*8) & 0xFF);
+    ret_val.buf[i] = (uint8_t)((voffset >> i*8) & 0xFF);
 
   return ret_val;
@@ -2812 +2814 @@
 /******************************************************************************
 *******************************************************************************/
-REGFI_BUFFER regfi_parse_big_data_header(REGFI_FILE* file, uint32 offset, 
-                                         uint32 max_size, bool strict)
+REGFI_BUFFER regfi_parse_big_data_header(REGFI_FILE* file, uint32_t offset, 
+                                         uint32_t max_size, bool strict)
 {
   REGFI_BUFFER ret_val;
-  uint32 cell_length;
+  uint32_t cell_length;
   bool unalloc;
 
   /* XXX: do something with unalloc? */
-  ret_val.buf = (uint8*)talloc_array(NULL, uint8, REGFI_BIG_DATA_MIN_LENGTH);
+  ret_val.buf = (uint8_t*)talloc_array(NULL, uint8_t, REGFI_BIG_DATA_MIN_LENGTH);
   if(ret_val.buf == NULL)
     goto fail;
@@ -2866 +2868 @@
  *
  ******************************************************************************/
-uint32* regfi_parse_big_data_indirect(REGFI_FILE* file, uint32 offset,
-                                      uint16 num_chunks, bool strict)
-{
-  uint32* ret_val;
-  uint32 indirect_length;
-  int32 max_size;
-  uint16 i;
+uint32_t* regfi_parse_big_data_indirect(REGFI_FILE* file, uint32_t offset,
+                                      uint16_t num_chunks, bool strict)
+{
+  uint32_t* ret_val;
+  uint32_t indirect_length;
+  int32_t max_size;
+  uint16_t i;
   bool unalloc;
 
@@ -2878 +2880 @@
 
   max_size = regfi_calc_maxsize(file, offset);
-  if((max_size < 0) || (num_chunks*sizeof(uint32) + 4 > max_size))
-    return NULL;
-
-  ret_val = (uint32*)talloc_array(NULL, uint32, num_chunks);
+  if((max_size < 0) || (num_chunks*sizeof(uint32_t) + 4 > max_size))
+    return NULL;
+
+  ret_val = (uint32_t*)talloc_array(NULL, uint32_t, num_chunks);
   if(ret_val == NULL)
     goto fail;
 
-  if(!regfi_parse_cell(file->fd, offset, (uint8*)ret_val,
-                       num_chunks*sizeof(uint32),
+  if(!regfi_parse_cell(file->fd, offset, (uint8_t*)ret_val,
+                       num_chunks*sizeof(uint32_t),
                        &indirect_length, &unalloc))
   {
@@ -2898 +2900 @@
   for(i=0; i<num_chunks; i++)
   {
-    ret_val[i] = IVAL(ret_val, i*sizeof(uint32));
+    ret_val[i] = IVAL(ret_val, i*sizeof(uint32_t));
     if((ret_val[i] & 0x00000007) != 0)
       goto fail;
@@ -2924 +2926 @@
  *  No data in range_list elements.
  ******************************************************************************/
-range_list* regfi_parse_big_data_cells(REGFI_FILE* file, uint32* offsets,
-                                       uint16 num_chunks, bool strict)
-{
-  uint32 cell_length, chunk_offset;
+range_list* regfi_parse_big_data_cells(REGFI_FILE* file, uint32_t* offsets,
+                                       uint16_t num_chunks, bool strict)
+{
+  uint32_t cell_length, chunk_offset;
   range_list* ret_val;
-  uint16 i;
+  uint16_t i;
   bool unalloc;
   
@@ -2965 +2967 @@
 *******************************************************************************/
 REGFI_BUFFER regfi_load_big_data(REGFI_FILE* file, 
-                                 uint32 offset, uint32 data_length, 
-                                 uint32 cell_length, range_list* used_ranges,
+                                 uint32_t offset, uint32_t data_length, 
+                                 uint32_t cell_length, range_list* used_ranges,
                                  bool strict)
 {
   REGFI_BUFFER ret_val;
-  uint16 num_chunks, i;
-  uint32 read_length, data_left, tmp_len, indirect_offset;
-  uint32* indirect_ptrs = NULL;
+  uint16_t num_chunks, i;
+  uint32_t read_length, data_left, tmp_len, indirect_offset;
+  uint32_t* indirect_ptrs = NULL;
   REGFI_BUFFER bd_header;
   range_list* bd_cells = NULL;
@@ -3048 +3050 @@
     }
 
-    if(lseek(file->fd, cell_info->offset+sizeof(uint32), SEEK_SET) == -1)
+    if(lseek(file->fd, cell_info->offset+sizeof(uint32_t), SEEK_SET) == -1)
     {
       regfi_add_message(file, REGFI_MSG_WARN, "Could not seek to chunk while "
@@ -3095 +3097 @@
   REGFI_HBIN* hbin;
   const range_list_element* hbins_elem;
-  uint32 i, num_hbins, curr_off, cell_len;
+  uint32_t i, num_hbins, curr_off, cell_len;
   bool is_unalloc;
 
@@ -3142 +3144 @@
   return ret_val;
 }
+
+
+/* From lib/time.c */
+
+/****************************************************************************
+ Put a 8 byte filetime from a time_t
+ This takes real GMT as input and converts to kludge-GMT
+****************************************************************************/
+void regfi_unix2nt_time(REGFI_NTTIME *nt, time_t t)
+{
+  double d;
+  
+  if (t==0) 
+  {
+    nt->low = 0;
+    nt->high = 0;
+    return;
+  }
+  
+  if (t == TIME_T_MAX) 
+  {
+    nt->low = 0xffffffff;
+    nt->high = 0x7fffffff;
+    return;
+  }             
+  
+  if (t == -1) 
+  {
+    nt->low = 0xffffffff;
+    nt->high = 0xffffffff;
+    return;
+  }             
+  
+  /* this converts GMT to kludge-GMT */
+  /* XXX: This was removed due to difficult dependency requirements.  
+   *      So far, times appear to be correct without this adjustment, but 
+   *      that may be proven wrong with adequate testing. 
+   */
+  /* t -= TimeDiff(t) - get_serverzone(); */
+  
+  d = (double)(t);
+  d += TIME_FIXUP_CONSTANT;
+  d *= 1.0e7;
+  
+  nt->high = (uint32_t)(d * (1.0/(4.0*(double)(1<<30))));
+  nt->low  = (uint32_t)(d - ((double)nt->high)*4.0*(double)(1<<30));
+}
+
+
+/****************************************************************************
+ Interpret an 8 byte "filetime" structure to a time_t
+ It's originally in "100ns units since jan 1st 1601"
+
+ An 8 byte value of 0xffffffffffffffff will be returned as (time_t)0.
+
+ It appears to be kludge-GMT (at least for file listings). This means
+ its the GMT you get by taking a localtime and adding the
+ serverzone. This is NOT the same as GMT in some cases. This routine
+ converts this to real GMT.
+****************************************************************************/
+time_t regfi_nt2unix_time(const REGFI_NTTIME* nt)
+{
+  double d;
+  time_t ret;
+  /* The next two lines are a fix needed for the 
+     broken SCO compiler. JRA. */
+  time_t l_time_min = TIME_T_MIN;
+  time_t l_time_max = TIME_T_MAX;
+  
+  if (nt->high == 0 || (nt->high == 0xffffffff && nt->low == 0xffffffff))
+    return(0);
+  
+  d = ((double)nt->high)*4.0*(double)(1<<30);
+  d += (nt->low&0xFFF00000);
+  d *= 1.0e-7;
+  
+  /* now adjust by 369 years to make the secs since 1970 */
+  d -= TIME_FIXUP_CONSTANT;
+  
+  if (d <= l_time_min)
+    return (l_time_min);
+  
+  if (d >= l_time_max)
+    return (l_time_max);
+  
+  ret = (time_t)(d+0.5);
+  
+  /* this takes us from kludge-GMT to real GMT */
+  /* XXX: This was removed due to difficult dependency requirements.  
+   *      So far, times appear to be correct without this adjustment, but 
+   *      that may be proven wrong with adequate testing. 
+   */
+  /*
+    ret -= get_serverzone();
+    ret += LocTimeDiff(ret);
+  */
+
+  return(ret);
+}
+
+/* End of stuff from lib/time.c */

trunk/lib/void_stack.c

@@ -1 @@
-/*
+/**
+ * @file
+ *
  * This is a really simple implementation of a stack which stores chunks
- * of memory of any type.  It still needs work to eliminate memory
- * leaks. 
+ * of memory of any type.
  *
  * Copyright (C) 2005,2007,2009 Timothy D. Morgan

trunk/lib/winsec.c

@@ -1 @@
-/*
+/**
+ * @file
  * This file contains refactored Samba code used to interpret Windows
  * Security Descriptors. See:

trunk/src/common.c

@@ -160 +160 @@
   char* tmp_ptr;
   char* delim;
-  uint32 ret_val_left, i, tmp_len;
+  uint32_t ret_val_left, i, tmp_len;
 
   if(data == NULL || data->size == 0)

trunk/src/reglookup-recover.c

@@ -40 +40 @@
 
 
-char* getQuotedData(int fd, uint32 offset, uint32 length)
-{
-  uint8* buf;
+char* getQuotedData(int fd, uint32_t offset, uint32_t length)
+{
+  uint8_t* buf;
   char* quoted_buf;
-  uint32 len;
+  uint32_t len;
 
   if((lseek(fd, offset, SEEK_SET)) == -1)
     return NULL;
 
-  buf = (uint8*)malloc(length);
+  buf = (uint8_t*)malloc(length);
   if(buf == NULL)
     return NULL;
@@ -75 +75 @@
   char* quoted_raw = "";
 
-  *tmp_time = nt_time_to_unix(&nk->mtime);
+  *tmp_time = regfi_nt2unix_time(&nk->mtime);
   tmp_time_s = gmtime(tmp_time);
   strftime(mtime, sizeof(mtime), "%Y-%m-%d %H:%M:%S", tmp_time_s);
@@ -217 +217 @@
 
 
-int printCell(REGFI_FILE* f, uint32 offset)
+int printCell(REGFI_FILE* f, uint32_t offset)
 {
   char* quoted_buf;
-  uint32 cell_length;
+  uint32_t cell_length;
   bool unalloc;
 
@@ -249 +249 @@
   REGFI_NK_REC* cur_ancestor;
   char* ret_val;
-  uint32 virt_offset, i, stack_size, ret_val_size, ret_val_used, offset;
-  int32 max_size;
+  uint32_t virt_offset, i, stack_size, ret_val_size, ret_val_used, offset;
+  int32_t max_size;
   REGFI_BUFFER* path_element;
   
@@ -278 +278 @@
         path_element = talloc(path_stack, REGFI_BUFFER);
         if(path_element != NULL)
-          path_element->buf = (uint8*)quote_string(cur_ancestor->keyname, 
+          path_element->buf = (uint8_t*)quote_string(cur_ancestor->keyname, 
                                                    key_special_chars);
           
@@ -343 +343 @@
 
 
-bool removeRange(range_list* rl, uint32 offset, uint32 length)
-{
-  int32 rm_idx;
+bool removeRange(range_list* rl, uint32_t offset, uint32_t length)
+{
+  int32_t rm_idx;
   const range_list_element* cur_elem;
 
@@ -405 +405 @@
   const range_list_element* cur_elem;
   REGFI_VK_REC* vk;
-  uint32 i, j;
+  uint32_t i, j;
 
   for(i=0; i < range_list_size(unalloc_cells); i++)
@@ -450 +450 @@
   range_list* bd_cells;
   REGFI_BUFFER data;
-  uint32 i, j, offset, cell_length, length;
-  int32 max_size;
+  uint32_t i, j, offset, cell_length, length;
+  int32_t max_size;
   bool unalloc;
 
@@ -583 +583 @@
   const range_list_element* cur_elem;
   REGFI_NK_REC* key;
-  uint32 i, j;
+  uint32_t i, j;
   int error_code = 0;
 
@@ -637 +637 @@
   REGFI_VK_REC* vk;
   const range_list_element* cur_elem;
-  uint32 i, j, num_keys, off, values_length;
-  int32 max_size;
+  uint32_t i, j, num_keys, off, values_length;
+  int32_t max_size;
 
   num_keys=range_list_size(unalloc_keys);
@@ -663 +663 @@
            * parsed structure.
            */
-          values_length = (nk->values->num_values+1)*sizeof(uint32);
+          values_length = (nk->values->num_values+1)*sizeof(uint32_t);
           if(values_length != (values_length & 0xFFFFFFF8))
             values_length = (values_length & 0xFFFFFFF8) + 8;
@@ -727 +727 @@
   const range_list_element* cur_elem;
   REGFI_SK_REC* sk;
-  uint32 i, j;
+  uint32_t i, j;
 
   for(i=0; i < range_list_size(unalloc_cells); i++)
@@ -778 +778 @@
   REGFI_NK_REC* tmp_key;
   REGFI_VK_REC* tmp_value;
-  uint32 argi, arge, i, j, ret, num_unalloc_keys;
+  uint32_t argi, arge, i, j, ret, num_unalloc_keys;
   
   /* Process command line arguments */

trunk/src/reglookup.c

@@ -132 +132 @@
   char* next = NULL;
   char* copy;
-  uint32 ret_cur = 0;
+  uint32_t ret_cur = 0;
 
   ret_val = (char**)malloc((REGFI_MAX_DEPTH+1+1)*sizeof(char**));
@@ -179 +179 @@
 void freePath(char** path)
 {
-  uint32 i;
+  uint32_t i;
 
   if(path == NULL)
@@ -196 +196 @@
   const REGFI_ITER_POSITION* cur;
   const REGFI_NK_REC* tmp_key;
-  uint32 buf_left = 127;
-  uint32 buf_len = buf_left+1;
-  uint32 name_len = 0;
-  uint32 grow_amt;
+  uint32_t buf_left = 127;
+  uint32_t buf_len = buf_left+1;
+  uint32_t name_len = 0;
+  uint32_t grow_amt;
   char* buf;
   char* new_buf;
@@ -245 +245 @@
     if(name_len+1 > buf_left)
     {
-      grow_amt = (uint32)(buf_len/2);
+      grow_amt = (uint32_t)(buf_len/2);
       buf_len += name_len+1+grow_amt-buf_left;
       if((new_buf = realloc(buf, buf_len)) == NULL)
@@ -298 +298 @@
   REGFI_CLASSNAME* classname;
 
-  *tmp_time = nt_time_to_unix(&k->mtime);
+  *tmp_time = regfi_nt2unix_time(&k->mtime);
   tmp_time_s = gmtime(tmp_time);
   strftime(mtime, sizeof(mtime), "%Y-%m-%d %H:%M:%S", tmp_time_s);
@@ -454 +454 @@
   char* tmp_path_joined;
   const char** tmp_path;
-  uint32 i;
+  uint32_t i;
   
   if(path == NULL)
@@ -557 +557 @@
   REGFI_ITERATOR* iter;
   int retr_path_ret;
-  uint32 argi, arge;
+  uint32_t argi, arge;
 
   /* Process command line arguments */