Changeset 988 for vendor/current/source3/registry/regfio.c

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

File:

• vendor/current/source3/registry/regfio.c (modified) (75 diffs)

vendor/current/source3/registry/regfio.c

@@ -23 +23 @@
 #include "../librpc/gen_ndr/ndr_security.h"
 #include "../libcli/security/security_descriptor.h"
+#include "../libcli/security/secdesc.h"
 
 #undef DBGC_CLASS
@@ -45 +46 @@
 static bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth)
 {
-        uint32 low, high;
+        uint32_t low, high;
         if (nttime == NULL)
                 return False;
@@ -75 +76 @@
 *******************************************************************/
 
-static int write_block( REGF_FILE *file, prs_struct *ps, uint32 offset )
+static int write_block( REGF_FILE *file, prs_struct *ps, uint32_t offset )
 {
         int bytes_written, returned;
         char *buffer = prs_data_p( ps );
-        uint32 buffer_size = prs_data_size( ps );
+        uint32_t buffer_size = prs_data_size( ps );
         SMB_STRUCT_STAT sbuf;
 
@@ -113 +114 @@
 *******************************************************************/
 
-static int read_block( REGF_FILE *file, prs_struct *ps, uint32 file_offset, uint32 block_size )
+static int read_block( REGF_FILE *file, prs_struct *ps, uint32_t file_offset, uint32_t block_size )
 {
         int bytes_read, returned;
@@ -199 +200 @@
 
         if ( hbin->free_off != REGF_OFFSET_NONE ) {
-                uint32 header = 0xffffffff;
-
-                if ( !prs_set_offset( &hbin->ps, hbin->free_off-sizeof(uint32) ) )
+                uint32_t header = 0xffffffff;
+
+                if ( !prs_set_offset( &hbin->ps, hbin->free_off-sizeof(uint32_t) ) )
                         return False;
                 if ( !prs_uint32( "free_size", &hbin->ps, 0, &hbin->free_size ) )
@@ -224 +225 @@
 
         for ( p=file->block_list; p && p!=hbin; p=p->next )
-                ;;
+                ;
 
         if ( p == hbin ) {
@@ -246 +247 @@
         depth++;
         
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)file->header, sizeof( file->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t *)file->header, sizeof( file->header )) )
                 return False;
         
@@ -303 +304 @@
 static bool prs_hbin_block( const char *desc, prs_struct *ps, int depth, REGF_HBIN *hbin )
 {
-        uint32 block_size2;
+        uint32_t block_size2;
 
         prs_debug(ps, depth, desc, "prs_regf_block");
         depth++;
         
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)hbin->header, sizeof( hbin->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t*)hbin->header, sizeof( hbin->header )) )
                 return False;
 
@@ -338 +339 @@
 static bool prs_nk_rec( const char *desc, prs_struct *ps, int depth, REGF_NK_REC *nk )
 {
-        uint16 class_length, name_length;
-        uint32 start;
-        uint32 data_size, start_off, end_off;
-        uint32 unknown_off = REGF_OFFSET_NONE;
+        uint16_t class_length, name_length;
+        uint32_t start;
+        uint32_t data_size, start_off, end_off;
+        uint32_t unknown_off = REGF_OFFSET_NONE;
 
         nk->hbin_off = prs_offset( ps );
@@ -351 +352 @@
         /* back up and get the data_size */
         
-        if ( !prs_set_offset( ps, prs_offset(ps)-sizeof(uint32)) )
+        if ( !prs_set_offset( ps, prs_offset(ps)-sizeof(uint32_t)) )
                 return False;
         start_off = prs_offset( ps );
@@ -357 +358 @@
                 return False;
         
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)nk->header, sizeof( nk->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t *)nk->header, sizeof( nk->header )) )
                 return False;
                 
@@ -418 +419 @@
                 }
 
-                if ( !prs_uint8s( True, "name", ps, depth, (uint8*)nk->keyname, name_length) )
+                if ( !prs_uint8s( True, "name", ps, depth, (uint8_t *)nk->keyname, name_length) )
                         return False;
 
@@ -442 +443 @@
 *******************************************************************/
 
-static uint32 regf_block_checksum( prs_struct *ps )
+static uint32_t regf_block_checksum( prs_struct *ps )
 {
         char *buffer = prs_data_p( ps );
-        uint32 checksum, x;
+        uint32_t checksum, x;
         int i;
 
@@ -466 +467 @@
 {
         prs_struct ps;
-        uint32 checksum;
+        uint32_t checksum;
         
         /* grab the first block from the file */
@@ -496 +497 @@
 {
         REGF_HBIN *hbin;
-        uint32 record_size, curr_off, block_size, header;
-        
-        if ( !(hbin = TALLOC_ZERO_P(file->mem_ctx, REGF_HBIN)) ) 
+        uint32_t record_size, curr_off, block_size, header;
+        
+        if ( !(hbin = talloc_zero(file->mem_ctx, REGF_HBIN)) ) 
                 return NULL;
         hbin->file_off = offset;
@@ -521 +522 @@
         /* remember that the record_size is in the 4 bytes preceeding the record itself */
 
-        if ( !prs_set_offset( &hbin->ps, file->data_offset+HBIN_HDR_SIZE-sizeof(uint32) ) )
-                return False;
+        if ( !prs_set_offset( &hbin->ps, file->data_offset+HBIN_HDR_SIZE-sizeof(uint32_t) ) )
+                return NULL;
 
         record_size = 0;
@@ -545 +546 @@
 
                 if ( !prs_set_offset( &hbin->ps, curr_off) )
-                        return False;
+                        return NULL;
 
                 if ( !prs_uint32( "rec_size", &hbin->ps, 0, &record_size ) )
-                        return False;
+                        return NULL;
                 if ( !prs_uint32( "header", &hbin->ps, 0, &header ) )
-                        return False;
+                        return NULL;
                 
                 SMB_ASSERT( record_size != 0 );
@@ -567 +568 @@
                    record header */
 
-                hbin->free_off = curr_off + sizeof(uint32);
+                hbin->free_off = curr_off + sizeof(uint32_t);
                 hbin->free_size = record_size;
         }
@@ -574 +575 @@
 
         if ( !prs_set_offset( &hbin->ps, file->data_offset+HBIN_HDR_SIZE )  )
-                return False;
+                return NULL;
         
         return hbin;
@@ -584 +585 @@
 *******************************************************************/
 
-static bool hbin_contains_offset( REGF_HBIN *hbin, uint32 offset )
+static bool hbin_contains_offset( REGF_HBIN *hbin, uint32_t offset )
 {
         if ( !hbin )
@@ -600 +601 @@
 *******************************************************************/
 
-static REGF_HBIN* lookup_hbin_block( REGF_FILE *file, uint32 offset )
+static REGF_HBIN* lookup_hbin_block( REGF_FILE *file, uint32_t offset )
 {
         REGF_HBIN *hbin = NULL;
-        uint32 block_off;
+        uint32_t block_off;
 
         /* start with the open list */
@@ -659 +660 @@
         int i;
         REGF_LF_REC *lf = &nk->subkeys;
-        uint32 data_size, start_off, end_off;
+        uint32_t data_size, start_off, end_off;
 
         prs_debug(&hbin->ps, depth, desc, "prs_lf_records");
@@ -676 +677 @@
         /* backup and get the data_size */
         
-        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32)) )
+        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32_t)) )
                 return False;
         start_off = prs_offset( &hbin->ps );
@@ -682 +683 @@
                 return False;
 
-        if ( !prs_uint8s( True, "header", &hbin->ps, depth, (uint8*)lf->header, sizeof( lf->header )) )
+        if ( !prs_uint8s( True, "header", &hbin->ps, depth, (uint8_t *)lf->header, sizeof( lf->header )) )
                 return False;
                 
@@ -722 +723 @@
 {
         prs_struct *ps = &hbin->ps;
-        uint16 tag = 0xFFFF;
-        uint32 data_size, start_off, end_off;
+        uint16_t tag = 0xFFFF;
+        uint32_t data_size, start_off, end_off;
 
 
@@ -734 +735 @@
         /* backup and get the data_size */
         
-        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32)) )
+        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32_t)) )
                 return False;
         start_off = prs_offset( &hbin->ps );
@@ -740 +741 @@
                 return False;
 
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)sk->header, sizeof( sk->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t *)sk->header, sizeof( sk->header )) )
                 return False;
         if ( !prs_uint16( "tag", ps, depth, &tag))
@@ -768 +769 @@
                                 return False;
                 } else {
-                        blob = data_blob_const(prs_data_p(&hbin->ps),
-                                               prs_data_size(&hbin->ps));
+                        blob = data_blob_const(
+                                prs_data_p(&hbin->ps) + prs_offset(&hbin->ps),
+                                prs_data_size(&hbin->ps) - prs_offset(&hbin->ps)
+                               );
                         status = unmarshall_sec_desc(mem_ctx,
                                                      blob.data, blob.length,
@@ -798 +801 @@
 static bool hbin_prs_vk_rec( const char *desc, REGF_HBIN *hbin, int depth, REGF_VK_REC *vk, REGF_FILE *file )
 {
-        uint32 offset;
-        uint16 name_length;
+        uint32_t offset;
+        uint16_t name_length;
         prs_struct *ps = &hbin->ps;
-        uint32 data_size, start_off, end_off;
+        uint32_t data_size, start_off, end_off;
 
         prs_debug(ps, depth, desc, "prs_vk_rec");
@@ -808 +811 @@
         /* backup and get the data_size */
         
-        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32)) )
+        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32_t)) )
                 return False;
         start_off = prs_offset( &hbin->ps );
@@ -814 +817 @@
                 return False;
 
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)vk->header, sizeof( vk->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t *)vk->header, sizeof( vk->header )) )
                 return False;
 
@@ -843 +846 @@
                                 return False;
                 }
-                if ( !prs_uint8s( True, "name", ps, depth, (uint8*)vk->valuename, name_length ) )
+                if ( !prs_uint8s( True, "name", ps, depth, (uint8_t *)vk->valuename, name_length ) )
                         return False;
         }
@@ -861 +864 @@
                 if ( !(vk->data_size & VK_DATA_IN_OFFSET) ) {
                         REGF_HBIN *hblock = hbin;
-                        uint32 data_rec_size;
+                        uint32_t data_rec_size;
 
                         if ( UNMARSHALLING(&hbin->ps) ) {
-                                if ( !(vk->data = PRS_ALLOC_MEM( ps, uint8, vk->data_size) ) )
+                                if ( !(vk->data = PRS_ALLOC_MEM( ps, uint8_t, vk->data_size) ) )
                                         return False;
                         }
@@ -873 +876 @@
                                         return False;
                         }
-                        if ( !(prs_set_offset( &hblock->ps, (vk->data_off+HBIN_HDR_SIZE-hblock->first_hbin_off)-sizeof(uint32) )) )
+                        if ( !(prs_set_offset( &hblock->ps, (vk->data_off+HBIN_HDR_SIZE-hblock->first_hbin_off)-sizeof(uint32_t) )) )
                                 return False;
 
                         if ( MARSHALLING(&hblock->ps) ) {
-                                data_rec_size = ( (vk->data_size+sizeof(uint32)) & 0xfffffff8 ) + 8;
+                                data_rec_size = ( (vk->data_size+sizeof(uint32_t)) & 0xfffffff8 ) + 8;
                                 data_rec_size = ( data_rec_size - 1 ) ^ 0xFFFFFFFF;
                         }
@@ -889 +892 @@
                 }
                 else {
-                        if ( !(vk->data = PRS_ALLOC_MEM( ps, uint8, 4 ) ) )
+                        if ( !(vk->data = PRS_ALLOC_MEM( ps, uint8_t, 4 ) ) )
                                 return False;
                         SIVAL( vk->data, 0, vk->data_off );
@@ -916 +919 @@
 {
         int i;
-        uint32 record_size;
+        uint32_t record_size;
 
         prs_debug(&hbin->ps, depth, desc, "prs_vk_records");
@@ -933 +936 @@
         /* convert the offset to something relative to this HBIN block */
         
-        if ( !prs_set_offset( &hbin->ps, nk->values_off+HBIN_HDR_SIZE-hbin->first_hbin_off-sizeof(uint32)) )
+        if ( !prs_set_offset( &hbin->ps, nk->values_off+HBIN_HDR_SIZE-hbin->first_hbin_off-sizeof(uint32_t)) )
                 return False;
 
         if ( MARSHALLING( &hbin->ps) ) { 
-                record_size = ( ( nk->num_values * sizeof(uint32) ) & 0xfffffff8 ) + 8;
+                record_size = ( ( nk->num_values * sizeof(uint32_t) ) & 0xfffffff8 ) + 8;
                 record_size = (record_size - 1) ^ 0xFFFFFFFF;
         }
@@ -951 +954 @@
         for ( i=0; i<nk->num_values; i++ ) {
                 REGF_HBIN *sub_hbin = hbin;
-                uint32 new_offset;
+                uint32_t new_offset;
         
                 if ( !hbin_contains_offset( hbin, nk->values[i].rec_off ) ) {
@@ -980 +983 @@
 *******************************************************************/
 
-static REGF_SK_REC* find_sk_record_by_offset( REGF_FILE *file, uint32 offset )
+static REGF_SK_REC* find_sk_record_by_offset( REGF_FILE *file, uint32_t offset )
 {
         REGF_SK_REC *p_sk;
@@ -1067 +1070 @@
                         sub_hbin = lookup_hbin_block( file, nk->sk_off );
                         if ( !sub_hbin ) {
-                                DEBUG(0,("hbin_prs_key: Failed to find HBIN block containing sk_offset [0x%x]\n", 
-                                        nk->subkeys_off));
+                                DEBUG(0,("hbin_prs_key: Failed to find HBIN block containing sk_off [0x%x]\n",
+                                        nk->sk_off));
                                 return False;
                         }
                 }
                 
-                if ( !(nk->sec_desc = TALLOC_ZERO_P( file->mem_ctx, REGF_SK_REC )) )
+                if ( !(nk->sec_desc = talloc_zero( file->mem_ctx, REGF_SK_REC )) )
                         return False;
                 nk->sec_desc->sk_off = nk->sk_off;
@@ -1093 +1096 @@
 static bool next_record( REGF_HBIN *hbin, const char *hdr, bool *eob )
 {
-        uint8 header[REC_HDR_SIZE];
-        uint32 record_size;
-        uint32 curr_off, block_size;
+        uint8_t header[REC_HDR_SIZE];
+        uint32_t record_size;
+        uint32_t curr_off, block_size;
         bool found = False;
         prs_struct *ps = &hbin->ps;
@@ -1106 +1109 @@
            and we need to backup to read the record size */
 
-        curr_off -= sizeof(uint32);
+        curr_off -= sizeof(uint32_t);
 
         block_size = prs_data_size( ps );
         record_size = 0;
-        memset( header, 0x0, sizeof(uint8)*REC_HDR_SIZE );
+        memset( header, 0x0, sizeof(uint8_t)*REC_HDR_SIZE );
         while ( !found ) {
 
@@ -1132 +1135 @@
                 if ( memcmp( header, hdr, REC_HDR_SIZE ) == 0 ) {
                         found = True;
-                        curr_off += sizeof(uint32);
+                        curr_off += sizeof(uint32_t);
                 }
         } 
@@ -1372 +1375 @@
         REGF_NK_REC *nk;
         REGF_HBIN   *hbin;
-        uint32      offset = REGF_BLOCKSIZE;
+        uint32_t      offset = REGF_BLOCKSIZE;
         bool        found = False;
         bool        eob;
@@ -1379 +1382 @@
                 return NULL;
                 
-        if ( !(nk = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) ) {
+        if ( !(nk = talloc_zero( file->mem_ctx, REGF_NK_REC )) ) {
                 DEBUG(0,("regfio_rootkey: talloc() failed!\n"));
                 return NULL;
@@ -1427 +1430 @@
         REGF_NK_REC *subkey;
         REGF_HBIN   *hbin;
-        uint32      nk_offset;
+        uint32_t      nk_offset;
 
         /* see if there is anything left to report */
@@ -1447 +1450 @@
                 
         nk->subkey_index++;
-        if ( !(subkey = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) )
+        if ( !(subkey = talloc_zero( file->mem_ctx, REGF_NK_REC )) )
                 return NULL;
                 
@@ -1460 +1463 @@
 *******************************************************************/
 
-static REGF_HBIN* regf_hbin_allocate( REGF_FILE *file, uint32 block_size )
+static REGF_HBIN* regf_hbin_allocate( REGF_FILE *file, uint32_t block_size )
 {
         REGF_HBIN *hbin;
         SMB_STRUCT_STAT sbuf;
 
-        if ( !(hbin = TALLOC_ZERO_P( file->mem_ctx, REGF_HBIN )) )
+        if ( !(hbin = talloc_zero( file->mem_ctx, REGF_HBIN )) )
                 return NULL;
 
@@ -1479 +1482 @@
 
         hbin->free_off       = HBIN_HEADER_REC_SIZE;
-        hbin->free_size      = block_size - hbin->free_off + sizeof(uint32);
+        hbin->free_size      = block_size - hbin->free_off + sizeof(uint32_t);
 
         hbin->block_size     = block_size;
@@ -1501 +1504 @@
 *******************************************************************/
 
-static void update_free_space( REGF_HBIN *hbin, uint32 size_used )
+static void update_free_space( REGF_HBIN *hbin, uint32_t size_used )
 {
         hbin->free_off  += size_used;
@@ -1516 +1519 @@
 *******************************************************************/
 
-static REGF_HBIN* find_free_space( REGF_FILE *file, uint32 size )
+static REGF_HBIN* find_free_space( REGF_FILE *file, uint32_t size )
 {
         REGF_HBIN *hbin, *p_hbin;
-        uint32 block_off;
+        uint32_t block_off;
         bool cached;
 
@@ -1575 +1578 @@
 
         if ( !hbin ) {
-                uint32 alloc_size;
+                uint32_t alloc_size;
 
                 /* allocate in multiples of REGF_ALLOC_BLOCK; make sure (size + hbin_header) fits */
@@ -1591 +1594 @@
         /* set the offset to be ready to write */
 
-        if ( !prs_set_offset( &hbin->ps, hbin->free_off-sizeof(uint32) ) )
+        if ( !prs_set_offset( &hbin->ps, hbin->free_off-sizeof(uint32_t) ) )
                 return NULL;
 
@@ -1599 +1602 @@
 
         if ( !prs_uint32("allocated_size", &hbin->ps, 0, &size) )
-                return False;
+                return NULL;
 
         update_free_space( hbin, size );
@@ -1609 +1612 @@
 *******************************************************************/
 
-static uint32 sk_record_data_size( struct security_descriptor * sd )
-{
-        uint32 size, size_mod8;
+static uint32_t sk_record_data_size( struct security_descriptor * sd )
+{
+        uint32_t size, size_mod8;
 
         size_mod8 = 0;
@@ -1617 +1620 @@
         /* the record size is sizeof(hdr) + name + static members + data_size_field */
 
-        size = sizeof(uint32)*5 + ndr_size_security_descriptor(sd, 0) + sizeof(uint32);
+        size = sizeof(uint32_t)*5 + ndr_size_security_descriptor(sd, 0) + sizeof(uint32_t);
 
         /* multiple of 8 */
@@ -1630 +1633 @@
 *******************************************************************/
 
-static uint32 vk_record_data_size( REGF_VK_REC *vk )
-{
-        uint32 size, size_mod8;
+static uint32_t vk_record_data_size( REGF_VK_REC *vk )
+{
+        uint32_t size, size_mod8;
 
         size_mod8 = 0;
@@ -1638 +1641 @@
         /* the record size is sizeof(hdr) + name + static members + data_size_field */
 
-        size = REC_HDR_SIZE + (sizeof(uint16)*3) + (sizeof(uint32)*3) + sizeof(uint32);
+        size = REC_HDR_SIZE + (sizeof(uint16_t)*3) + (sizeof(uint32_t)*3) + sizeof(uint32_t);
 
         if ( vk->valuename )
@@ -1654 +1657 @@
 *******************************************************************/
 
-static uint32 lf_record_data_size( uint32 num_keys )
-{
-        uint32 size, size_mod8;
+static uint32_t lf_record_data_size( uint32_t num_keys )
+{
+        uint32_t size, size_mod8;
 
         size_mod8 = 0;
 
-        /* the record size is sizeof(hdr) + num_keys + sizeof of hash_array + data_size_uint32 */
-
-        size = REC_HDR_SIZE + sizeof(uint16) + (sizeof(REGF_HASH_REC) * num_keys) + sizeof(uint32);
+        /* the record size is sizeof(hdr) + num_keys + sizeof of hash_array + data_size_uint32_t */
+
+        size = REC_HDR_SIZE + sizeof(uint16_t) + (sizeof(REGF_HASH_REC) * num_keys) + sizeof(uint32_t);
 
         /* multiple of 8 */
@@ -1675 +1678 @@
 *******************************************************************/
 
-static uint32 nk_record_data_size( REGF_NK_REC *nk )
-{
-        uint32 size, size_mod8;
+static uint32_t nk_record_data_size( REGF_NK_REC *nk )
+{
+        uint32_t size, size_mod8;
 
         size_mod8 = 0;
 
-        /* the record size is static + length_of_keyname + length_of_classname + data_size_uint32 */
-
-        size = 0x4c + strlen(nk->keyname) + sizeof(uint32);
+        /* the record size is static + length_of_keyname + length_of_classname + data_size_uint32_t */
+
+        size = 0x4c + strlen(nk->keyname) + sizeof(uint32_t);
 
         if ( nk->classname )
@@ -1717 +1720 @@
         vk->type      = regval_type( value );
 
-        if ( vk->data_size > sizeof(uint32) ) {
-                uint32 data_size = ( (vk->data_size+sizeof(uint32)) & 0xfffffff8 ) + 8;
-
-                vk->data = (uint8 *)TALLOC_MEMDUP( file->mem_ctx,
+        if ( vk->data_size > sizeof(uint32_t) ) {
+                uint32_t data_size = ( (vk->data_size+sizeof(uint32_t)) & 0xfffffff8 ) + 8;
+
+                vk->data = (uint8_t *)talloc_memdup( file->mem_ctx,
                                                    regval_data_p(value),
                                                    vk->data_size );
@@ -1739 +1742 @@
 
                 if ( vk->data_size != 0 ) 
-                        memcpy( &vk->data_off, regval_data_p(value), sizeof(uint32) );
+                        memcpy( &vk->data_off, regval_data_p(value), vk->data_size);
                 vk->data_size |= VK_DATA_IN_OFFSET;             
         }
@@ -1751 +1754 @@
 static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
 {
-        return StrCaseCmp( h1->fullname, h2->fullname );
+        return strcasecmp_m( h1->fullname, h2->fullname );
 }
 
@@ -1763 +1766 @@
         REGF_NK_REC *nk;
         REGF_HBIN *vlist_hbin = NULL;
-        uint32 size;
-
-        if ( !(nk = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) )
+        uint32_t size;
+
+        if ( !(nk = talloc_zero( file->mem_ctx, REGF_NK_REC )) )
                 return NULL;
 
@@ -1804 +1807 @@
 
                 hash->nk_off = prs_offset( &nk->hbin->ps ) + nk->hbin->first_hbin_off - HBIN_HDR_SIZE;
-                memcpy( hash->keycheck, name, sizeof(uint32) );
+                memcpy(hash->keycheck, name, MIN(strlen(name),sizeof(uint32_t)));
                 hash->fullname = talloc_strdup( file->mem_ctx, name );
                 parent->subkey_index++;
@@ -1812 +1815 @@
 
                 if ( !hbin_prs_lf_records( "lf_rec", parent->subkeys.hbin, 0, parent ) )
-                        return False;
+                        return NULL;
         }
 
@@ -1819 +1822 @@
         nk->sk_off = REGF_OFFSET_NONE;
         if ( sec_desc ) {
-                uint32 sk_size = sk_record_data_size( sec_desc );
+                uint32_t sk_size = sk_record_data_size( sec_desc );
                 REGF_HBIN *sk_hbin;
 
@@ -1831 +1834 @@
                         }
 
-                        if ( !(nk->sec_desc = TALLOC_ZERO_P( file->mem_ctx, REGF_SK_REC )) )
+                        if ( !(nk->sec_desc = talloc_zero( file->mem_ctx, REGF_SK_REC )) )
                                 return NULL;
         
@@ -1848 +1851 @@
                         /* size value must be self-inclusive */
                         nk->sec_desc->size      = ndr_size_security_descriptor(sec_desc, 0)
-                                + sizeof(uint32);
-
-                        DLIST_ADD_END( file->sec_desc_list, nk->sec_desc, REGF_SK_REC *);
+                                + sizeof(uint32_t);
+
+                        DLIST_ADD_END( file->sec_desc_list, nk->sec_desc);
 
                         /* update the offsets for us and the previous sd in the list.
@@ -1883 +1886 @@
         nk->subkeys_off = REGF_OFFSET_NONE;
         if ( (nk->num_subkeys = regsubkey_ctr_numkeys( subkeys )) != 0 ) {
-                uint32 lf_size = lf_record_data_size( nk->num_subkeys );
-                uint32 namelen;
+                uint32_t lf_size = lf_record_data_size( nk->num_subkeys );
+                uint32_t namelen;
                 int i;
                 
@@ -1898 +1901 @@
                 nk->subkeys.num_keys = nk->num_subkeys;
                 if (nk->subkeys.num_keys) {
-                        if ( !(nk->subkeys.hashes = TALLOC_ZERO_ARRAY( file->mem_ctx, REGF_HASH_REC, nk->subkeys.num_keys )) )
+                        if ( !(nk->subkeys.hashes = talloc_zero_array( file->mem_ctx, REGF_HASH_REC, nk->subkeys.num_keys )) )
                                 return NULL;
                 } else {
@@ -1917 +1920 @@
         nk->values_off = REGF_OFFSET_NONE;
         if ( (nk->num_values = regval_ctr_numvals( values )) != 0 ) {
-                uint32 vlist_size = ( ( nk->num_values * sizeof(uint32) ) & 0xfffffff8 ) + 8;
+                uint32_t vlist_size = ( ( nk->num_values * sizeof(uint32_t) ) & 0xfffffff8 ) + 8;
                 int i;
                 
@@ -1926 +1929 @@
         
                 if (nk->num_values) {
-                        if ( !(nk->values = TALLOC_ARRAY( file->mem_ctx, REGF_VK_REC, nk->num_values )) )
+                        if ( !(nk->values = talloc_array( file->mem_ctx, REGF_VK_REC, nk->num_values )) )
                                 return NULL;
                 } else {
@@ -1935 +1938 @@
 
                 for ( i=0; i<nk->num_values; i++ ) {
-                        uint32 vk_size, namelen, datalen;
+                        uint32_t vk_size, namelen, datalen;
                         struct regval_blob *r;
 
@@ -1964 +1967 @@
         prs_set_offset( &nk->hbin->ps, nk->hbin_off );
         if ( !prs_nk_rec( "nk_rec", &nk->hbin->ps, 0, nk ) )
-                return False;
+                return NULL;
 
         if ( nk->num_values ) {
                 if ( !hbin_prs_vk_records( "vk_records", vlist_hbin, 0, nk, file ) )
-                        return False;
+                        return NULL;
         }