Changeset 84 for trunk/lib

Timestamp:

01/19/07 09:52:25 (18 years ago)

Author:

tim

Message:

rearranged structure contents to reduce fragmentation on 64 bit systems.

make regfi interface return const structures to help enforce separation

removed a little cruft from some parsing functions

Location:

trunk/lib

Files:

• regfi.c (modified) (24 diffs)
• smb_deps.c (modified) (5 diffs)

trunk/lib/regfi.c

@@ -1 +1 @@
 /*
  * Branched from Samba project Subversion repository, version #7470:
- *   http://websvn.samba.org/cgi-bin/viewcvs.cgi/trunk/source/registry/regfio.c
+ *   http://viewcvs.samba.org/cgi-bin/viewcvs.cgi/trunk/source/registry/regfio.c?rev=7470&view=auto
  *
  * Unix SMB/CIFS implementation.
@@ -437 +437 @@
   depth++;
         
-  if(!prs_uint8s(true, "header", ps, depth, file->header, sizeof(file->header)))
+  if(!prs_uint8s("header", ps, depth, file->header, sizeof(file->header)))
     return false;
         
@@ -499 +499 @@
   depth++;
         
-  if(!prs_uint8s(true, "header", ps, depth, hbin->header, sizeof(hbin->header)))
+  if(!prs_uint8s("header", ps, depth, hbin->header, sizeof(hbin->header)))
     return false;
 
@@ -547 +547 @@
     return false;
         
-  if (!prs_uint8s(true, "header", ps, depth, nk->header, sizeof(nk->header)))
+  if (!prs_uint8s("header", ps, depth, nk->header, sizeof(nk->header)))
     return false;
                 
@@ -610 +610 @@
         return false;
 
-    if(!prs_uint8s(true, "name", ps, depth, (uint8*)nk->keyname, name_length))
+    if(!prs_uint8s("name", ps, depth, (uint8*)nk->keyname, name_length))
       return false;
 
@@ -848 +848 @@
   if ( !prs_uint32( "nk_off", ps, depth, &hash->nk_off ))
     return false;
-  if ( !prs_uint8s( true, "keycheck", ps, depth, hash->keycheck, sizeof( hash->keycheck )) )
+  if ( !prs_uint8s("keycheck", ps, depth, hash->keycheck, sizeof( hash->keycheck )) )
     return false;
         
@@ -884 +884 @@
     return false;
 
-  if(!prs_uint8s(true, "header", &hbin->ps, depth, 
+  if(!prs_uint8s("header", &hbin->ps, depth, 
                  lf->header, sizeof(lf->header)))
     return false;
@@ -938 +938 @@
     return false;
 
-  if (!prs_uint8s(true, "header", ps, depth, sk->header, sizeof(sk->header)))
+  if (!prs_uint8s("header", ps, depth, sk->header, sizeof(sk->header)))
     return false;
   if ( !prs_uint16( "tag", ps, depth, &tag))
@@ -990 +990 @@
     return false;
 
-  if ( !prs_uint8s( true, "header", ps, depth, vk->header, sizeof( vk->header )) )
+  if ( !prs_uint8s("header", ps, depth, vk->header, sizeof( vk->header )) )
     return false;
 
@@ -1019 +1019 @@
         return false;
     }
-    if ( !prs_uint8s(true, "name", ps, depth, 
+    if ( !prs_uint8s("name", ps, depth, 
                      (uint8*)vk->valuename, name_length) )
       return false;
@@ -1030 +1030 @@
   if ( vk->data_size != 0 ) 
   {
-    bool charmode = false;
-
-    if ( (vk->type == REG_SZ) || (vk->type == REG_MULTI_SZ) )
-      charmode = true;
-
     /* the data is stored in the offset if the size <= 4 */
     if ( !(vk->data_size & VK_DATA_IN_OFFSET) ) 
@@ -1067 +1062 @@
       if ( !prs_uint32( "data_rec_size", &hblock->ps, depth, &data_rec_size ))
         return false;
-      if(!prs_uint8s(charmode, "data", &hblock->ps, depth, 
+      if(!prs_uint8s("data", &hblock->ps, depth, 
                      vk->data, vk->data_size))
         return false;
@@ -1323 +1318 @@
     if ( !prs_uint32( "record_size", ps, 0, &record_size ) )
       return false;
-    if ( !prs_uint8s( true, "header", ps, 0, header, REC_HDR_SIZE ) )
+    if ( !prs_uint8s("header", ps, 0, header, REC_HDR_SIZE ) )
       return false;
 
@@ -1600 +1595 @@
     return false;
 
-  subkey = regfi_iterator_cur_subkey(i);
+  subkey = (REGF_NK_REC*)regfi_iterator_cur_subkey(i);
   if(subkey == NULL)
   {
@@ -1667 +1662 @@
 
   /* XXX: this alloc/free of each sub key might be a bit excessive */
-  subkey = regfi_iterator_first_subkey(i);
+  subkey = (REGF_NK_REC*)regfi_iterator_first_subkey(i);
   while((subkey != NULL) && (found == false))
   {
@@ -1676 +1671 @@
     {
       regfi_key_free(subkey);
-      subkey = regfi_iterator_next_subkey(i);
+      subkey = (REGF_NK_REC*)regfi_iterator_next_subkey(i);
     }
   }
@@ -1718 +1713 @@
 /******************************************************************************
  *****************************************************************************/
-REGF_NK_REC* regfi_iterator_cur_key(REGFI_ITERATOR* i)
+const REGF_NK_REC* regfi_iterator_cur_key(REGFI_ITERATOR* i)
 {
   return i->cur_key;
@@ -1726 +1721 @@
 /******************************************************************************
  *****************************************************************************/
-REGF_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
+const REGF_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
 {
   i->cur_subkey = 0;
@@ -1735 +1730 @@
 /******************************************************************************
  *****************************************************************************/
-REGF_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
+const REGF_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
 {
   REGF_NK_REC* subkey;
@@ -1778 +1773 @@
  *****************************************************************************/
 /* XXX: some way of indicating reason for failure should be added. */
-REGF_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i)
-{
-  REGF_NK_REC* subkey;
+const REGF_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i)
+{
+  const REGF_NK_REC* subkey;
 
   i->cur_subkey++;
@@ -1796 +1791 @@
 bool regfi_iterator_find_value(REGFI_ITERATOR* i, const char* value_name)
 {
-  REGF_VK_REC* cur;
+  const REGF_VK_REC* cur;
   bool found = false;
 
@@ -1823 +1818 @@
 /******************************************************************************
  *****************************************************************************/
-REGF_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i)
+const REGF_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i)
 {
   i->cur_value = 0;
@@ -1832 +1827 @@
 /******************************************************************************
  *****************************************************************************/
-REGF_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
+const REGF_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
 {
   REGF_VK_REC* ret_val = NULL;
@@ -1844 +1839 @@
 /******************************************************************************
  *****************************************************************************/
-REGF_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i)
-{
-  REGF_VK_REC* ret_val;
+const REGF_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i)
+{
+  const REGF_VK_REC* ret_val;
 
   i->cur_value++;

trunk/lib/smb_deps.c

@@ -101 +101 @@
  converts this to real GMT.
 ****************************************************************************/
-time_t nt_time_to_unix(NTTIME *nt)
+time_t nt_time_to_unix(const NTTIME* nt)
 {
   double d;
@@ -316 +316 @@
  Stream an array of uint32s. Length is number of uint32s.
  ********************************************************************/
-bool prs_uint32s(bool charmode, const char *name, prs_struct *ps, 
+bool prs_uint32s(const char *name, prs_struct *ps, 
                  int depth, uint32 *data32s, int len)
 {
@@ -462 +462 @@
  Stream an array of uint8s. Length is number of uint8s.
  ********************************************************************/
-bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, 
+bool prs_uint8s(const char *name, prs_struct *ps, int depth, 
                 uint8* data8s, int len)
 {
@@ -526 +526 @@
     return false;
   
-  if(!prs_uint8s (false, "data   ", ps, depth, 
+  if(!prs_uint8s ("data   ", ps, depth, 
                   uuid->clock_seq, sizeof(uuid->clock_seq)))
     return false;
 
-  if(!prs_uint8s (false, "data   ", ps, depth, uuid->node, sizeof(uuid->node)))
+  if(!prs_uint8s ("data   ", ps, depth, uuid->node, sizeof(uuid->node)))
     return false;
   
@@ -587 +587 @@
     sid->num_auths = MAXSUBAUTHS;
 
-  if(!prs_uint32s(false, "sub_auths ", ps, depth, 
+  if(!prs_uint32s("sub_auths ", ps, depth, 
                   sid->sub_auths, sid->num_auths))
   { return false; }