include/regfio.h

ソースコードを見る。

データ構造
struct	regf_hbin
struct	REGF_HASH_REC
struct	REGF_LF_REC
struct	REGF_VK_REC
struct	_regf_sk_rec
struct	REGF_NK_REC
struct	REGF_FILE
型定義
typedef regf_hbin	REGF_HBIN
typedef _regf_sk_rec	REGF_SK_REC
関数
REGF_FILE *	regfio_open (const char *filename, int flags, int mode)
int	regfio_close (REGF_FILE *r)
REGF_NK_REC *	regfio_rootkey (REGF_FILE *file)
REGF_NK_REC *	regfio_fetch_subkey (REGF_FILE *file, REGF_NK_REC *nk)
REGF_NK_REC *	regfio_write_key (REGF_FILE *file, const char *name, REGVAL_CTR *values, REGSUBKEY_CTR *subkeys, SEC_DESC *sec_desc, REGF_NK_REC *parent)

---

型定義

typedef struct regf_hbin REGF_HBIN

typedef struct _regf_sk_rec REGF_SK_REC

---

関数

REGF_FILE* regfio_open	(	const char *	filename,
		int	flags,
		int	mode
	)

regfio.c の 1159 行で定義されています。

参照先 errno・REGF_FILE::fd・init_regf_block()・REGF_FILE::mem_ctx・REGF_FILE::open_flags・read_regf_block()・regfio_close()・strerror()・talloc_init().

参照元 backup_registry_key()・main()・restore_registry_key()・rpc_registry_copy()・rpc_registry_dump().

{
        REGF_FILE *rb;
        
        if ( !(rb = SMB_MALLOC_P(REGF_FILE)) ) {
                DEBUG(0,("ERROR allocating memory\n"));
                return NULL;
        }
        ZERO_STRUCTP( rb );
        rb->fd = -1;
        
        if ( !(rb->mem_ctx = talloc_init( "read_regf_block" )) ) {
                regfio_close( rb );
                return NULL;
        }

        rb->open_flags = flags;
        
        /* open and existing file */

        if ( (rb->fd = open(filename, flags, mode)) == -1 ) {
                DEBUG(0,("regfio_open: failure to open %s (%s)\n", filename, strerror(errno)));
                regfio_close( rb );
                return NULL;
        }
        
        /* check if we are creating a new file or overwriting an existing one */
                
        if ( flags & (O_CREAT|O_TRUNC) ) {
                if ( !init_regf_block( rb ) ) {
                        DEBUG(0,("regfio_open: Failed to read initial REGF block\n"));
                        regfio_close( rb );
                        return NULL;
                }
                
                /* success */
                return rb;
        }
        
        /* read in an existing file */
        
        if ( !read_regf_block( rb ) ) {
                DEBUG(0,("regfio_open: Failed to read initial REGF block\n"));
                regfio_close( rb );
                return NULL;
        }
        
        /* success */
        
        return rb;
}

int regfio_close

(

REGF_FILE *

r

)

regfio.c の 1225 行で定義されています。

参照先 REGF_FILE::block_list・REGF_FILE::checksum・fd・REGF_FILE::fd・_regf_sk_rec::hbin・hbin_block_close()・hbin_prs_sk_rec()・REGF_FILE::mtime・_regf_sk_rec::next・REGF_FILE::open_flags・prs_mem_free()・prs_regf_block()・read_block()・regf_block_checksum()・regfio_mem_free()・REGF_FILE::sec_desc_list・unix_to_nt_time()・write_block().

参照元 backup_registry_key()・main()・regfio_open()・restore_registry_key()・rpc_registry_copy()・rpc_registry_dump().

{
        int fd;

        /* cleanup for a file opened for write */

        if ( file->open_flags & (O_WRONLY|O_RDWR) ) {
                prs_struct ps;
                REGF_SK_REC *sk;

                /* write of sd list */

                for ( sk=file->sec_desc_list; sk; sk=sk->next ) {
                        hbin_prs_sk_rec( "sk_rec", sk->hbin, 0, sk );
                }

                /* flush any dirty blocks */

                while ( file->block_list ) {
                        hbin_block_close( file, file->block_list );
                } 

                ZERO_STRUCT( ps );

                unix_to_nt_time( &file->mtime, time(NULL) );

                if ( read_block( file, &ps, 0, REGF_BLOCKSIZE ) != -1 ) {
                        /* now use for writing */
                        prs_switch_type( &ps, MARSHALL );

                        /* stream the block once, generate the checksum, 
                           and stream it again */
                        prs_set_offset( &ps, 0 );
                        prs_regf_block( "regf_blocK", &ps, 0, file );
                        file->checksum = regf_block_checksum( &ps );
                        prs_set_offset( &ps, 0 );
                        prs_regf_block( "regf_blocK", &ps, 0, file );

                        /* now we are ready to write it to disk */
                        if ( write_block( file, &ps, 0 ) == -1 )
                                DEBUG(0,("regfio_close: failed to update the regf header block!\n"));
                }

                prs_mem_free( &ps );
        }
        
        regfio_mem_free( file );

        /* nothing tdo do if there is no open file */

        if ( !file || (file->fd == -1) )
                return 0;
                
        fd = file->fd;
        file->fd = -1;
        SAFE_FREE( file );

        return close( fd );
}

REGF_NK_REC* regfio_rootkey

(

REGF_FILE *

file

)

regfio.c の 1302 行で定義されています。

参照先 REGF_FILE::block_list・regf_hbin::block_size・REGF_NK_REC::key_type・REGF_FILE::mem_ctx・next_nk_record()・prs_mem_free()・regf_hbin::ps・read_hbin_block().

参照元 main()・restore_registry_key()・rpc_registry_copy()・rpc_registry_dump().

{
        REGF_NK_REC *nk;
        REGF_HBIN   *hbin;
        uint32      offset = REGF_BLOCKSIZE;
        BOOL        found = False;
        BOOL        eob;
        
        if ( !file )
                return NULL;
                
        if ( !(nk = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) ) {
                DEBUG(0,("regfio_rootkey: talloc() failed!\n"));
                return NULL;
        }
        
        /* scan through the file on HBIN block at a time looking 
           for an NK record with a type == 0x002c.
           Normally this is the first nk record in the first hbin 
           block (but I'm not assuming that for now) */
        
        while ( (hbin = read_hbin_block( file, offset )) ) {
                eob = False;

                while ( !eob) {
                        if ( next_nk_record( file, hbin, nk, &eob ) ) {
                                if ( nk->key_type == NK_TYPE_ROOTKEY ) {
                                        found = True;
                                        break;
                                }
                        }
                        prs_mem_free( &hbin->ps );
                }
                
                if ( found ) 
                        break;

                offset += hbin->block_size;
        }
        
        if ( !found ) {
                DEBUG(0,("regfio_rootkey: corrupt registry file ?  No root key record located\n"));
                return NULL;
        }

        DLIST_ADD( file->block_list, hbin );

        return nk;              
}

REGF_NK_REC* regfio_fetch_subkey	(	REGF_FILE *	file,
		REGF_NK_REC *	nk
	)

regfio.c の 1357 行で定義されています。

参照先 regf_hbin::first_hbin_off・REGF_LF_REC::hashes・hbin_prs_key()・lookup_hbin_block()・REGF_FILE::mem_ctx・REGF_HASH_REC::nk_off・REGF_NK_REC::num_subkeys・regf_hbin::ps・REGF_NK_REC::subkey_index・REGF_NK_REC::subkeys・REGF_NK_REC::subkeys_off.

参照元 copy_registry_tree()・dump_registry_tree()・reg_load_tree()・write_registry_tree().

{
        REGF_NK_REC *subkey;
        REGF_HBIN   *hbin;
        uint32      nk_offset;

        /* see if there is anything left to report */
        
        if ( !nk || (nk->subkeys_off==REGF_OFFSET_NONE) || (nk->subkey_index >= nk->num_subkeys) )
                return NULL;

        /* find the HBIN block which should contain the nk record */
        
        if ( !(hbin = lookup_hbin_block( file, nk->subkeys.hashes[nk->subkey_index].nk_off )) ) {
                DEBUG(0,("hbin_prs_key: Failed to find HBIN block containing offset [0x%x]\n", 
                        nk->subkeys.hashes[nk->subkey_index].nk_off));
                return NULL;
        }
        
        nk_offset = nk->subkeys.hashes[nk->subkey_index].nk_off;
        if ( !prs_set_offset( &hbin->ps, (HBIN_HDR_SIZE + nk_offset - hbin->first_hbin_off) ) )
                return NULL;
                
        nk->subkey_index++;
        if ( !(subkey = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) )
                return NULL;
                
        if ( !hbin_prs_key( file, hbin, subkey ) )
                return NULL;
        
        return subkey;
}

REGF_NK_REC* regfio_write_key	(	REGF_FILE *	file,
		const char *	name,
		REGVAL_CTR *	values,
		REGSUBKEY_CTR *	subkeys,
		SEC_DESC *	sec_desc,
		REGF_NK_REC *	parent
	)

regfio.c の 1690 行で定義されています。

参照先 REGF_NK_REC::classname・REGF_NK_REC::classname_off・create_vk_record()・regf_hbin::file_off・find_free_space()・find_sk_record_by_sec_desc()・regf_hbin::first_hbin_off・REGF_HASH_REC::fullname・REGF_LF_REC::hashes・hashrec_cmp()・REGF_NK_REC::hbin・REGF_LF_REC::hbin・_regf_sk_rec::hbin・REGF_VK_REC::hbin・REGF_NK_REC::hbin_off・_regf_sk_rec::hbin_off・REGF_LF_REC::hbin_off・REGF_VK_REC::hbin_off・hbin_prs_lf_records()・hbin_prs_vk_records()・REGF_NK_REC::header・_regf_sk_rec::header・REGF_LF_REC::header・REGF_NK_REC::key_type・REGF_HASH_REC::keycheck・REGF_NK_REC::keyname・lf_record_data_size()・REGF_NK_REC::max_bytes_subkeyname・REGF_NK_REC::max_bytes_value・REGF_NK_REC::max_bytes_valuename・REGF_FILE::mem_ctx・REGF_NK_REC::mtime・_regf_sk_rec::next_sk_off・REGF_HASH_REC::nk_off・nk_record_data_size()・REGF_LF_REC::num_keys・REGF_NK_REC::num_subkeys・REGF_NK_REC::num_values・REGF_NK_REC::parent_off・_regf_sk_rec::prev・_regf_sk_rec::prev_sk_off・prs_nk_rec()・regf_hbin::ps・REGF_VK_REC::rec_off・REGF_NK_REC::rec_size・_regf_sk_rec::rec_size・REGF_LF_REC::rec_size・REGF_VK_REC::rec_size・_regf_sk_rec::ref_count・regfio_flush()・regsubkey_ctr_numkeys()・regsubkey_ctr_specific_key()・regval_ctr_numvals()・regval_ctr_specific_value()・regval_name()・regval_size()・REGF_NK_REC::sec_desc・_regf_sk_rec::sec_desc・REGF_FILE::sec_desc_list・sec_desc_size()・size・_regf_sk_rec::size・REGF_NK_REC::sk_off・_regf_sk_rec::sk_off・sk_record_data_size()・REGF_NK_REC::subkey_index・REGF_NK_REC::subkeys・REGF_NK_REC::subkeys_off・talloc_strdup()・unix_to_nt_time()・values・REGF_NK_REC::values・REGF_NK_REC::values_off・vk_record_data_size().

参照元 copy_registry_tree()・reg_write_tree()・write_registry_tree().

{
        REGF_NK_REC *nk;
        REGF_HBIN *vlist_hbin = NULL;
        uint32 size;

        if ( !(nk = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) )
                return NULL;

        memcpy( nk->header, "nk", REC_HDR_SIZE );

        if ( !parent )
                nk->key_type = NK_TYPE_ROOTKEY;
        else
                nk->key_type = NK_TYPE_NORMALKEY;

        /* store the parent offset (or -1 if a the root key */

        nk->parent_off = parent ? (parent->hbin_off + parent->hbin->file_off - REGF_BLOCKSIZE - HBIN_HDR_SIZE ) : REGF_OFFSET_NONE;

        /* no classname currently */

        nk->classname_off = REGF_OFFSET_NONE;
        nk->classname = NULL;
        nk->keyname = talloc_strdup( file->mem_ctx, name );

        /* current modification time */

        unix_to_nt_time( &nk->mtime, time(NULL) );

        /* allocate the record on disk */

        size = nk_record_data_size( nk );
        nk->rec_size = ( size - 1 ) ^ 0XFFFFFFFF;
        if ((nk->hbin = find_free_space( file, size )) == NULL) {
                return NULL;
        }
        nk->hbin_off = prs_offset( &nk->hbin->ps );

        /* Update the hash record in the parent */
        
        if ( parent ) {
                REGF_HASH_REC *hash = &parent->subkeys.hashes[parent->subkey_index];

                hash->nk_off = prs_offset( &nk->hbin->ps ) + nk->hbin->first_hbin_off - HBIN_HDR_SIZE;
                memcpy( hash->keycheck, name, sizeof(uint32) );
                hash->fullname = talloc_strdup( file->mem_ctx, name );
                parent->subkey_index++;

                /* sort the list by keyname */

                qsort( parent->subkeys.hashes, parent->subkey_index, sizeof(REGF_HASH_REC), QSORT_CAST hashrec_cmp );

                if ( !hbin_prs_lf_records( "lf_rec", parent->subkeys.hbin, 0, parent ) )
                        return False;
        }

        /* write the security descriptor */

        nk->sk_off = REGF_OFFSET_NONE;
        if ( sec_desc ) {
                uint32 sk_size = sk_record_data_size( sec_desc );
                REGF_HBIN *sk_hbin;

                /* search for it in the existing list of sd's */

                if ( (nk->sec_desc = find_sk_record_by_sec_desc( file, sec_desc )) == NULL ) {
                        /* not found so add it to the list */

                        if (!(sk_hbin = find_free_space( file, sk_size ))) {
                                return NULL;
                        }

                        if ( !(nk->sec_desc = TALLOC_ZERO_P( file->mem_ctx, REGF_SK_REC )) )
                                return NULL;
        
                        /* now we have to store the security descriptor in the list and 
                           update the offsets */

                        memcpy( nk->sec_desc->header, "sk", REC_HDR_SIZE );
                        nk->sec_desc->hbin      = sk_hbin;
                        nk->sec_desc->hbin_off  = prs_offset( &sk_hbin->ps );
                        nk->sec_desc->sk_off    = prs_offset( &sk_hbin->ps ) + sk_hbin->first_hbin_off - HBIN_HDR_SIZE;
                        nk->sec_desc->rec_size  = (sk_size-1)  ^ 0xFFFFFFFF;

                        nk->sec_desc->sec_desc  = sec_desc;
                        nk->sec_desc->ref_count = 0;
                        
                        /* size value must be self-inclusive */
                        nk->sec_desc->size      = sec_desc_size(sec_desc) + sizeof(uint32);

                        DLIST_ADD_END( file->sec_desc_list, nk->sec_desc, REGF_SK_REC *);

                        /* update the offsets for us and the previous sd in the list.
                           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;

                                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;

                                /* the end must loop around to the front */
                                nk->sec_desc->next_sk_off = file->sec_desc_list->sk_off;

                                /* and first must loop around to the tail */
                                file->sec_desc_list->prev_sk_off = nk->sec_desc->sk_off;
                        } else {
                                nk->sec_desc->prev_sk_off = nk->sec_desc->sk_off;
                                nk->sec_desc->next_sk_off = nk->sec_desc->sk_off;
                        }
                }

                /* bump the reference count +1 */

                nk->sk_off = nk->sec_desc->sk_off;
                nk->sec_desc->ref_count++;
        }

        /* write the subkeys */

        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;
                int i;
                
                if (!(nk->subkeys.hbin = find_free_space( file, lf_size ))) {
                        return NULL;
                }
                nk->subkeys.hbin_off = prs_offset( &nk->subkeys.hbin->ps );
                nk->subkeys.rec_size = (lf_size-1) ^ 0xFFFFFFFF;
                nk->subkeys_off = prs_offset( &nk->subkeys.hbin->ps ) + nk->subkeys.hbin->first_hbin_off - HBIN_HDR_SIZE;

                memcpy( nk->subkeys.header, "lf", REC_HDR_SIZE );
                
                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 )) )
                                return NULL;
                } else {
                        nk->subkeys.hashes = NULL;
                }
                nk->subkey_index = 0;

                /* update the max_bytes_subkey{name,classname} fields */
                for ( i=0; i<nk->num_subkeys; i++ ) {
                        namelen = strlen( regsubkey_ctr_specific_key(subkeys, i) );
                        if ( namelen*2 > nk->max_bytes_subkeyname )
                                nk->max_bytes_subkeyname = namelen * 2;
                }
        }

        /* write the values */

        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;
                int i;
                
                if (!(vlist_hbin = find_free_space( file, vlist_size ))) {
                        return NULL;
                }
                nk->values_off = prs_offset( &vlist_hbin->ps ) + vlist_hbin->first_hbin_off - HBIN_HDR_SIZE;
        
                if (nk->num_values) {
                        if ( !(nk->values = TALLOC_ARRAY( file->mem_ctx, REGF_VK_REC, nk->num_values )) )
                                return NULL;
                } else {
                        nk->values = NULL;
                }

                /* create the vk records */

                for ( i=0; i<nk->num_values; i++ ) {
                        uint32 vk_size, namelen, datalen;
                        REGISTRY_VALUE *r;

                        r = regval_ctr_specific_value( values, i );
                        create_vk_record( file, &nk->values[i], r );
                        vk_size = vk_record_data_size( &nk->values[i] );
                        nk->values[i].hbin = find_free_space( file, vk_size );
                        nk->values[i].hbin_off = prs_offset( &nk->values[i].hbin->ps );
                        nk->values[i].rec_size = ( vk_size - 1 ) ^ 0xFFFFFFFF;
                        nk->values[i].rec_off = prs_offset( &nk->values[i].hbin->ps ) 
                                + nk->values[i].hbin->first_hbin_off 
                                - HBIN_HDR_SIZE;

                        /* update the max bytes fields if necessary */

                        namelen = strlen( regval_name(r) );
                        if ( namelen*2 > nk->max_bytes_valuename )
                                nk->max_bytes_valuename = namelen * 2;

                        datalen = regval_size( r );
                        if ( datalen > nk->max_bytes_value )
                                nk->max_bytes_value = datalen;
                }
        }

        /* stream the records */        
        
        prs_set_offset( &nk->hbin->ps, nk->hbin_off );
        if ( !prs_nk_rec( "nk_rec", &nk->hbin->ps, 0, nk ) )
                return False;

        if ( nk->num_values ) {
                if ( !hbin_prs_vk_records( "vk_records", vlist_hbin, 0, nk, file ) )
                        return False;
        }


        regfio_flush( file );

        return nk;
}

---