s3:registry: move reg_objects.h to registry/ and use it only where needed

[kai/samba.git] / source3 / registry / regfio.c

diff --git a/source3/registry/regfio.c b/source3/registry/regfio.c
index e1c04c4777bb3f531b86e289cec636a1231a0903..60a05040e264fd13ed05125cf376de9b155428ff 100644 (file)
--- a/source3/registry/regfio.c
+++ b/source3/registry/regfio.c
@@ -19,6 +19,7 @@
 
 #include "includes.h"
 #include "regfio.h"
+#include "reg_objects.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
@@ -45,7 +46,7 @@ static int write_block( REGF_FILE *file, prs_struct *ps, uint32 offset )
 
        /* check for end of file */
 
-       if ( sys_fstat( file->fd, &sbuf ) ) {
+       if (sys_fstat(file->fd, &sbuf, false)) {
                DEBUG(0,("write_block: stat() failed! (%s)\n", strerror(errno)));
                return -1;
        }
@@ -79,12 +80,12 @@ static int read_block( REGF_FILE *file, prs_struct *ps, uint32 file_offset, uint
 
        /* check for end of file */
 
-       if ( sys_fstat( file->fd, &sbuf ) ) {
+       if (sys_fstat(file->fd, &sbuf, false)) {
                DEBUG(0,("read_block: stat() failed! (%s)\n", strerror(errno)));
                return -1;
        }
 
-       if ( (size_t)file_offset >= sbuf.st_size )
+       if ( (size_t)file_offset >= sbuf.st_ex_size )
                return -1;
        
        /* if block_size == 0, we are parsing HBIN records and need 
@@ -953,12 +954,12 @@ static REGF_SK_REC* find_sk_record_by_offset( REGF_FILE *file, uint32 offset )
 /*******************************************************************
 *******************************************************************/
 
-static REGF_SK_REC* find_sk_record_by_sec_desc( REGF_FILE *file, SEC_DESC *sd )
+static REGF_SK_REC* find_sk_record_by_sec_desc( REGF_FILE *file, struct security_descriptor *sd )
 {
        REGF_SK_REC *p;
 
        for ( p=file->sec_desc_list; p; p=p->next ) {
-               if ( sec_desc_equal( p->sec_desc, sd ) )
+               if ( security_descriptor_equal( p->sec_desc, sd ) )
                        return p;
        }
 
@@ -1429,12 +1430,12 @@ static REGF_HBIN* regf_hbin_allocate( REGF_FILE *file, uint32 block_size )
        memcpy( hbin->header, "hbin", sizeof(HBIN_HDR_SIZE) );
 
 
-       if ( sys_fstat( file->fd, &sbuf ) ) {
+       if (sys_fstat(file->fd, &sbuf, false)) {
                DEBUG(0,("regf_hbin_allocate: stat() failed! (%s)\n", strerror(errno)));
                return NULL;
        }
 
-       hbin->file_off       = sbuf.st_size;
+       hbin->file_off       = sbuf.st_ex_size;
 
        hbin->free_off       = HBIN_HEADER_REC_SIZE;
        hbin->free_size      = block_size - hbin->free_off + sizeof(uint32);;
@@ -1567,7 +1568,7 @@ done:
 /*******************************************************************
 *******************************************************************/
 
-static uint32 sk_record_data_size( SEC_DESC * sd )
+static uint32 sk_record_data_size( struct security_descriptor * sd )
 {
        uint32 size, size_mod8;
 
@@ -1575,7 +1576,7 @@ static uint32 sk_record_data_size( SEC_DESC * sd )
 
        /* the record size is sizeof(hdr) + name + static members + data_size_field */
 
-       size = sizeof(uint32)*5 + ndr_size_security_descriptor(sd, NULL, 0) + sizeof(uint32);
+       size = sizeof(uint32)*5 + ndr_size_security_descriptor(sd, 0) + sizeof(uint32);
 
        /* multiple of 8 */
        size_mod8 = size & 0xfffffff8;
@@ -1657,7 +1658,8 @@ static uint32 nk_record_data_size( REGF_NK_REC *nk )
 /*******************************************************************
 *******************************************************************/
 
-static bool create_vk_record( REGF_FILE *file, REGF_VK_REC *vk, REGISTRY_VALUE *value )
+static bool create_vk_record(REGF_FILE *file, REGF_VK_REC *vk,
+                            struct regval_blob *value)
 {
        char *name = regval_name(value);
        REGF_HBIN *data_hbin;
@@ -1714,9 +1716,9 @@ static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
 /*******************************************************************
 *******************************************************************/
 
- REGF_NK_REC* regfio_write_key( REGF_FILE *file, const char *name, 
-                               REGVAL_CTR *values, struct regsubkey_ctr *subkeys,
-                               SEC_DESC *sec_desc, REGF_NK_REC *parent )
+ REGF_NK_REC* regfio_write_key( REGF_FILE *file, const char *name,
+                               struct regval_ctr *values, struct regsubkey_ctr *subkeys,
+                               struct security_descriptor *sec_desc, REGF_NK_REC *parent )
 {
        REGF_NK_REC *nk;
        REGF_HBIN *vlist_hbin = NULL;
@@ -1766,8 +1768,7 @@ static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
                parent->subkey_index++;
 
                /* sort the list by keyname */
-
-               qsort( parent->subkeys.hashes, parent->subkey_index, sizeof(REGF_HASH_REC), QSORT_CAST hashrec_cmp );
+               TYPESAFE_QSORT(parent->subkeys.hashes, parent->subkey_index, hashrec_cmp);
 
                if ( !hbin_prs_lf_records( "lf_rec", parent->subkeys.hbin, 0, parent ) )
                        return False;
@@ -1805,7 +1806,7 @@ static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
                        nk->sec_desc->ref_count = 0;
                        
                        /* size value must be self-inclusive */
-                       nk->sec_desc->size      = ndr_size_security_descriptor(sec_desc, NULL, 0)
+                       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 *);
@@ -1814,8 +1815,8 @@ static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
                           if this is the first record, then just set the next and prev
                           offsets to ourself. */
 
-                       if ( nk->sec_desc->prev ) {
-                               REGF_SK_REC *prev = nk->sec_desc->prev;
+                       if ( DLIST_PREV(nk->sec_desc) ) {
+                               REGF_SK_REC *prev = DLIST_PREV(nk->sec_desc);
 
                                nk->sec_desc->prev_sk_off = prev->hbin_off + prev->hbin->first_hbin_off - HBIN_HDR_SIZE;
                                prev->next_sk_off = nk->sec_desc->sk_off;
@@ -1894,7 +1895,7 @@ static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
 
                for ( i=0; i<nk->num_values; i++ ) {
                        uint32 vk_size, namelen, datalen;
-                       REGISTRY_VALUE *r;
+                       struct regval_blob *r;
 
                        r = regval_ctr_specific_value( values, i );
                        create_vk_record( file, &nk->values[i], r );