Registry Functions

データ構造
struct	RegConnect
struct	RegOpenKey
struct	RegEnumKeys
struct	RegCreateKey
struct	RegDeleteKey
struct	RegDeleteValue
struct	RegQueryKeyInfo
struct	RegSaveKey
struct	RegQueryValue
struct	RegEnumValues
struct	RegSetValue
struct	RegGetVersion
struct	RegGetKeySecurity
struct	RegSetKeySecurity
関数
int	cac_RegConnect (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegConnect *op)
	Opens a handle to the registry on the server
int	cac_RegClose (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *key)
	Closes an open registry handle
int	cac_RegOpenKey (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegOpenKey *op)
	Opens a registry key
int	cac_RegEnumKeys (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegEnumKeys *op)
	Enumerates Subkeys of a given key.
int	cac_RegCreateKey (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegCreateKey *op)
	Creates a registry key, if the key already exists, it will be opened __Creating keys is not currently working__.
int	cac_RegDeleteKey (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegDeleteKey *op)
	Deletes a subkey of an open key.
int	cac_RegDeleteValue (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegDeleteValue *op)
	Deletes a registry value.
int	cac_RegQueryKeyInfo (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegQueryKeyInfo *op)
	Retrieves information about an open key
int	cac_RegSaveKey (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSaveKey *op)
	Saves a key to a file on the remote machine __Not currently working__.
int	cac_RegQueryValue (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegQueryValue *op)
	Retrieves a value (type and data) _not currently working_.
int	cac_RegEnumValues (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegEnumValues *op)
	Enumerates a number of Registry values in an open registry key.
int	cac_RegSetValue (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSetValue *op)
	Sets or creates value (type and data).
int	cac_RegGetVersion (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegGetVersion *op)
	Retrieves the registry version number
int	cac_RegGetKeySecurity (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegGetKeySecurity *op)
	Retrieves a key security descriptor.
int	cac_RegSetKeySecurity (CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSetKeySecurity *op)
	Sets the key security descriptor.

---

関数

int cac_RegConnect	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegConnect *	op
	)

Opens a handle to the registry on the server

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized Parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 28 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・RegConnect::access・cac_GetPipe()・cac_GetServer()・_SMBCSRV::cli・cli_rpc_pipe_open_noauth()・CacServerHandleInternal::ctx・err・RegConnect::in・RegConnect::key・RegConnect::out・CacServerHandleInternal::pipes・RegConnect::root・rpccli_reg_connect()・_CACSERVERHANDLE::status・werror_to_ntstatus().

参照元 cac_RegOpenKey().

{
        SMBCSRV *srv = NULL;
        struct rpc_pipe_client *pipe_hnd = NULL;
        POLICY_HND *key = NULL;
        WERROR err;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.root || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        srv = cac_GetServer( hnd );
        if ( !srv ) {
                hnd->status = NT_STATUS_INVALID_CONNECTION;
                return CAC_FAILURE;
        }

        /*initialize for winreg pipe if we have to */
        if ( !hnd->_internal.pipes[PI_WINREG] ) {
                if ( !
                     ( pipe_hnd =
                       cli_rpc_pipe_open_noauth( srv->cli, PI_WINREG,
                                                 &( hnd->status ) ) ) ) {
                        return CAC_FAILURE;
                }

                hnd->_internal.pipes[PI_WINREG] = True;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        key = talloc( mem_ctx, POLICY_HND );
        if ( !key ) {
                hnd->status = NT_STATUS_NO_MEMORY;
                return CAC_FAILURE;
        }

        err = rpccli_reg_connect( pipe_hnd, mem_ctx, op->in.root,
                                  op->in.access, key );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        op->out.key = key;

        return CAC_SUCCESS;
}

int cac_RegClose	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		POLICY_HND *	key
	)

Closes an open registry handle

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	key	The Key/Handle to close

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 92 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・CacServerHandleInternal::ctx・err・CacServerHandleInternal::pipes・rpccli_reg_close()・_CACSERVERHANDLE::status・werror_to_ntstatus().

参照元 cac_RegDeleteKey().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !key || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_close( pipe_hnd, mem_ctx, key );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        return CAC_SUCCESS;
}

int cac_RegOpenKey	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegOpenKey *	op
	)

Opens a registry key

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

if they only specified the root key, return the key we just opened

cac_winreg.c の 127 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・RegConnect::access・RegOpenKey::access・cac_GetPipe()・cac_ParseRegPath()・cac_RegConnect()・CacServerHandleInternal::ctx・err・RegOpenKey::in・RegConnect::in・RegOpenKey::key・RegConnect::key・RegOpenKey::name・RegOpenKey::out・RegConnect::out・RegOpenKey::parent_key・RegConnect::root・rpccli_reg_close()・rpccli_reg_open_entry()・_CACSERVERHANDLE::status・werror_to_ntstatus().

参照元 cac_RegCreateKey()・cac_RegDeleteKey().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        POLICY_HND *key_out;
        POLICY_HND *parent_key;

        char *key_name = NULL;
        uint32 reg_type = 0;

        struct RegConnect rc;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.name || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }


        key_out = talloc( mem_ctx, POLICY_HND );
        if ( !key_out ) {
                hnd->status = NT_STATUS_NO_MEMORY;
                return CAC_FAILURE;
        }

        if ( !op->in.parent_key ) {
                /*then we need to connect to the registry */
                if ( !cac_ParseRegPath( op->in.name, &reg_type, &key_name ) ) {
                        hnd->status = NT_STATUS_INVALID_PARAMETER;
                        return CAC_FAILURE;
                }

                /*use cac_RegConnect because it handles the session setup */
                ZERO_STRUCT( rc );

                rc.in.access = op->in.access;
                rc.in.root = reg_type;

                if ( !cac_RegConnect( hnd, mem_ctx, &rc ) ) {
                        return CAC_FAILURE;
                }

      /**if they only specified the root key, return the key we just opened*/
                if ( key_name == NULL ) {
                        op->out.key = rc.out.key;
                        return CAC_SUCCESS;
                }

                parent_key = rc.out.key;
        } else {
                parent_key = op->in.parent_key;
                key_name = op->in.name;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_open_entry( pipe_hnd, mem_ctx, parent_key, key_name,
                                     op->in.access, key_out );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        if ( !op->in.parent_key ) {
                /*then close the one that we opened above */
                err = rpccli_reg_close( pipe_hnd, mem_ctx, parent_key );
                hnd->status = werror_to_ntstatus( err );

                if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                        return CAC_FAILURE;
                }
        }

        op->out.key = key_out;

        return CAC_SUCCESS;
}

int cac_RegEnumKeys	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegEnumKeys *	op
	)

Enumerates Subkeys of a given key.

Can be run in a loop. Example: while(cac_RegEnumKeys(hnd, mem_ctx, op)) { ... }

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized Parameters

参照:

CAC_OP_FAILED()

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

the only way to know how many keys to expect is to assume max_keys keys will be found

cac_winreg.c の 219 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・RegEnumKeys::class_names・CacServerHandleInternal::ctx・err・RegEnumKeys::in・RegEnumKeys::key・RegEnumKeys::key_names・RegEnumKeys::max_keys・RegEnumKeys::mod_times・RegEnumKeys::num_keys・RegEnumKeys::out・CacServerHandleInternal::pipes・RegEnumKeys::resume_idx・rpccli_reg_enum_key()・_CACSERVERHANDLE::status・talloc_strdup()・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        /*buffers for rpccli_reg_enum_key call */
        fstring key_name_in;
        fstring class_name_in;

        /*output buffers */
        char **key_names_out = NULL;
        char **class_names_out = NULL;
        time_t *mod_times_out = NULL;
        uint32 num_keys_out = 0;
        uint32 resume_idx = 0;

        if ( !hnd )
                return CAC_FAILURE;

        /*this is to avoid useless rpc calls, if the last call exhausted all the keys, then we don't need to go through everything again */
        if ( NT_STATUS_V( hnd->status ) ==
             NT_STATUS_V( NT_STATUS_GUIDS_EXHAUSTED ) )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || op->in.max_keys == 0 || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

   /**the only way to know how many keys to expect is to assume max_keys keys will be found*/
        if (op->in.max_keys) {
                key_names_out = TALLOC_ARRAY( mem_ctx, char *, op->in.max_keys );
                if ( !key_names_out ) {
                        hnd->status = NT_STATUS_NO_MEMORY;
                        return CAC_FAILURE;
                }

                class_names_out = TALLOC_ARRAY( mem_ctx, char *, op->in.max_keys );
                if ( !class_names_out ) {
                        hnd->status = NT_STATUS_NO_MEMORY;
                        TALLOC_FREE( key_names_out );
                        return CAC_FAILURE;
                }

                mod_times_out = TALLOC_ARRAY( mem_ctx, time_t, op->in.max_keys );
                if ( !mod_times_out ) {
                        hnd->status = NT_STATUS_NO_MEMORY;
                        TALLOC_FREE( key_names_out );
                        TALLOC_FREE( class_names_out );

                        return CAC_FAILURE;
                }
        } else {
                key_names_out = NULL;
                class_names_out = NULL;
                mod_times_out = NULL;
        }

        resume_idx = op->out.resume_idx;

        do {
                err = rpccli_reg_enum_key( pipe_hnd, mem_ctx, op->in.key,
                                           resume_idx, key_name_in,
                                           class_name_in,
                                           &mod_times_out[num_keys_out] );
                hnd->status = werror_to_ntstatus( err );

                if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                        /*don't increment any values */
                        break;
                }

                key_names_out[num_keys_out] =
                        talloc_strdup( mem_ctx, key_name_in );

                class_names_out[num_keys_out] =
                        talloc_strdup( mem_ctx, class_name_in );

                if ( !key_names_out[num_keys_out]
                     || !class_names_out[num_keys_out] ) {
                        hnd->status = NT_STATUS_NO_MEMORY;
                        break;
                }

                resume_idx++;
                num_keys_out++;
        } while ( num_keys_out < op->in.max_keys );

        if ( CAC_OP_FAILED( hnd->status ) ) {
                op->out.num_keys = 0;
                return CAC_FAILURE;
        }

        op->out.resume_idx = resume_idx;
        op->out.num_keys = num_keys_out;
        op->out.key_names = key_names_out;
        op->out.class_names = class_names_out;
        op->out.mod_times = mod_times_out;

        return CAC_SUCCESS;
}

int cac_RegCreateKey	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegCreateKey *	op
	)

Creates a registry key, if the key already exists, it will be opened __Creating keys is not currently working__.

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized Parmeters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 333 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・RegOpenKey::access・RegCreateKey::access・cac_GetPipe()・cac_RegOpenKey()・RegCreateKey::class_name・CacServerHandleInternal::ctx・err・RegCreateKey::in・RegOpenKey::in・RegCreateKey::key・RegOpenKey::key・RegCreateKey::key_name・RegOpenKey::name・RegCreateKey::out・RegOpenKey::out・RegCreateKey::parent_key・RegOpenKey::parent_key・rpccli_reg_create_key_ex()・_CACSERVERHANDLE::status・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        POLICY_HND *key_out;

        struct RegOpenKey rok;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.parent_key || !op->in.key_name || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        /*first try to open the key - we use cac_RegOpenKey(). this doubles as a way to ensure the winreg pipe is initialized */
        ZERO_STRUCT( rok );

        rok.in.name = op->in.key_name;
        rok.in.access = op->in.access;
        rok.in.parent_key = op->in.parent_key;

        if ( cac_RegOpenKey( hnd, mem_ctx, &rok ) ) {
                /*then we got the key, return */
                op->out.key = rok.out.key;
                return CAC_SUCCESS;
        }

        /*just be ultra-safe */
        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        key_out = talloc( mem_ctx, POLICY_HND );
        if ( !key_out ) {
                hnd->status = NT_STATUS_NO_MEMORY;
                return CAC_FAILURE;
        }

        err = rpccli_reg_create_key_ex( pipe_hnd, mem_ctx, op->in.parent_key,
                                        op->in.key_name, op->in.class_name,
                                        op->in.access, key_out );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        op->out.key = key_out;

        return CAC_SUCCESS;

}

int cac_RegDeleteKey	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegDeleteKey *	op
	)

Deletes a subkey of an open key.

Note: if you run this with op->in.recursive == True, and the operation fails, it may leave the key in an inconsistent state.

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 455 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・RegOpenKey::access・cac_delete_subkeys_recursive()・cac_GetPipe()・cac_RegClose()・cac_RegOpenKey()・CacServerHandleInternal::ctx・err・RegDeleteKey::in・RegOpenKey::in・RegOpenKey::key・RegDeleteKey::name・RegOpenKey::name・RegOpenKey::out・RegDeleteKey::parent_key・RegOpenKey::parent_key・CacServerHandleInternal::pipes・RegDeleteKey::recursive・rpccli_reg_delete_key()・_CACSERVERHANDLE::status・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.parent_key || !op->in.name || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( op->in.recursive ) {
                /*first open the key, and then delete all of it's subkeys recursively */
                struct RegOpenKey rok;

                ZERO_STRUCT( rok );

                rok.in.parent_key = op->in.parent_key;
                rok.in.name = op->in.name;
                rok.in.access = REG_KEY_ALL;

                if ( !cac_RegOpenKey( hnd, mem_ctx, &rok ) )
                        return CAC_FAILURE;

                err = cac_delete_subkeys_recursive( pipe_hnd, mem_ctx,
                                                    rok.out.key );

                /*close the key that we opened */
                cac_RegClose( hnd, mem_ctx, rok.out.key );

                hnd->status = werror_to_ntstatus( err );

                if ( NT_STATUS_V( hnd->status ) !=
                     NT_STATUS_V( NT_STATUS_GUIDS_EXHAUSTED )
                     && !NT_STATUS_IS_OK( hnd->status ) )
                        return CAC_FAILURE;

                /*now go on to actually delete the key */
        }

        err = rpccli_reg_delete_key( pipe_hnd, mem_ctx, op->in.parent_key,
                                     op->in.name );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        return CAC_SUCCESS;
}

int cac_RegDeleteValue	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegDeleteValue *	op
	)

Deletes a registry value.

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized Parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 520 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・CacServerHandleInternal::ctx・err・RegDeleteValue::in・RegDeleteValue::name・RegDeleteValue::parent_key・CacServerHandleInternal::pipes・rpccli_reg_delete_val()・_CACSERVERHANDLE::status・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.parent_key || !op->in.name || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_delete_val( pipe_hnd, mem_ctx, op->in.parent_key,
                                     op->in.name );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        return CAC_SUCCESS;
}

int cac_RegQueryKeyInfo	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegQueryKeyInfo *	op
	)

Retrieves information about an open key

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 563 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・RegQueryKeyInfo::class_name・CacServerHandleInternal::ctx・err・RegQueryKeyInfo::in・RegQueryKeyInfo::key・RegQueryKeyInfo::last_write_time・RegQueryKeyInfo::longest_class・RegQueryKeyInfo::longest_subkey・RegQueryKeyInfo::longest_value_data・RegQueryKeyInfo::longest_value_name・nt_time_to_unix()・RegQueryKeyInfo::num_subkeys・RegQueryKeyInfo::num_values・RegQueryKeyInfo::out・CacServerHandleInternal::pipes・rpccli_reg_query_key()・RegQueryKeyInfo::security_desc_size・_CACSERVERHANDLE::status・talloc_strdup()・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        char *class_name_out = NULL;
        uint32 class_len = 0;
        uint32 num_subkeys_out = 0;
        uint32 long_subkey_out = 0;
        uint32 long_class_out = 0;
        uint32 num_values_out = 0;
        uint32 long_value_out = 0;
        uint32 long_data_out = 0;
        uint32 secdesc_size = 0;
        NTTIME mod_time;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.key || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_query_key( pipe_hnd, mem_ctx, op->in.key,
                                    class_name_out,
                                    &class_len,
                                    &num_subkeys_out,
                                    &long_subkey_out,
                                    &long_class_out,
                                    &num_values_out,
                                    &long_value_out,
                                    &long_data_out,
                                    &secdesc_size, &mod_time );

        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) )
                return CAC_FAILURE;

        if ( !class_name_out ) {
                op->out.class_name = talloc_strdup( mem_ctx, "" );
        } else if ( class_len != 0 && class_name_out[class_len - 1] != '\0' ) {
                /*then we need to add a '\0' */
                op->out.class_name =
                        TALLOC_SIZE( mem_ctx,
                                     sizeof( char ) * ( class_len + 1 ) );

                memcpy( op->out.class_name, class_name_out, class_len );

                op->out.class_name[class_len] = '\0';
        } else {                /*then everything worked out fine in the function */
                op->out.class_name = talloc_strdup( mem_ctx, class_name_out );
        }

        if ( !op->out.class_name ) {
                hnd->status = NT_STATUS_NO_MEMORY;
                return CAC_FAILURE;
        }

        op->out.num_subkeys = num_subkeys_out;
        op->out.longest_subkey = long_subkey_out;
        op->out.longest_class = long_class_out;
        op->out.num_values = num_values_out;
        op->out.longest_value_name = long_value_out;
        op->out.longest_value_data = long_data_out;
        op->out.security_desc_size = secdesc_size;
        op->out.last_write_time = nt_time_to_unix( &mod_time );

        return CAC_FAILURE;
}

int cac_RegSaveKey	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegSaveKey *	op
	)

Saves a key to a file on the remote machine __Not currently working__.

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 998 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・CacServerHandleInternal::ctx・err・RegSaveKey::filename・RegSaveKey::in・RegSaveKey::key・CacServerHandleInternal::pipes・rpccli_reg_save_key()・_CACSERVERHANDLE::status・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.key || !op->in.filename || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_save_key( pipe_hnd, mem_ctx, op->in.key,
                                   op->in.filename );
        hnd->status = werror_to_ntstatus( err );


        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        return CAC_SUCCESS;
}

int cac_RegQueryValue	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegQueryValue *	op
	)

Retrieves a value (type and data) _not currently working_.

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 648 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・cac_MakeRegValueData()・CacServerHandleInternal::ctx・RegQueryValue::data・err・errno・RegQueryValue::in・RegQueryValue::key・RegQueryValue::out・CacServerHandleInternal::pipes・rpccli_reg_query_value()・_CACSERVERHANDLE::status・RegQueryValue::type・RegQueryValue::val_name・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        uint32 val_type;
        REGVAL_BUFFER buffer;
        REG_VALUE_DATA *data_out = NULL;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.key || !op->in.val_name || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_query_value( pipe_hnd, mem_ctx, op->in.key,
                                      op->in.val_name, &val_type, &buffer );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) )
                return CAC_FAILURE;

        data_out = cac_MakeRegValueData( mem_ctx, val_type, buffer );
        if ( !data_out ) {
                if ( errno == ENOMEM )
                        hnd->status = NT_STATUS_NO_MEMORY;
                else
                        hnd->status = NT_STATUS_INVALID_PARAMETER;

                return CAC_FAILURE;
        }

        op->out.type = val_type;
        op->out.data = data_out;

        return CAC_SUCCESS;
}

int cac_RegEnumValues	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegEnumValues *	op
	)

Enumerates a number of Registry values in an open registry key.

Can be run in a loop. Example: while(cac_RegEnumValues(hnd, mem_ctx, op)) { ... }

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized Parameters

参照:

CAC_OP_FAILED()

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 701 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・cac_MakeRegValueData()・CacServerHandleInternal::ctx・err・RegEnumValues::in・RegEnumValues::key・RegEnumValues::max_values・RegEnumValues::num_values・RegEnumValues::out・CacServerHandleInternal::pipes・RegEnumValues::resume_idx・rpccli_reg_enum_val()・_CACSERVERHANDLE::status・talloc_strdup()・RegEnumValues::types・RegEnumValues::value_names・RegEnumValues::values・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        /*buffers for rpccli_reg_enum_key call */
        fstring val_name_buf;
        REGVAL_BUFFER val_buf;

        /*output buffers */
        uint32 *types_out = NULL;
        REG_VALUE_DATA **values_out = NULL;
        char **val_names_out = NULL;
        uint32 num_values_out = 0;
        uint32 resume_idx = 0;

        if ( !hnd )
                return CAC_FAILURE;

        /*this is to avoid useless rpc calls, if the last call exhausted all the keys, then we don't need to go through everything again */
        if ( NT_STATUS_V( hnd->status ) ==
             NT_STATUS_V( NT_STATUS_GUIDS_EXHAUSTED ) )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.key || op->in.max_values == 0 || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        /*we need to assume that the max number of values will be enumerated */
        if (op->in.max_values) {
                types_out =
                        ( uint32 * ) TALLOC_ARRAY( mem_ctx, int, op->in.max_values );
                if ( !types_out ) {
                        hnd->status = NT_STATUS_NO_MEMORY;
                        return CAC_FAILURE;
                }

                values_out =
                        TALLOC_ARRAY( mem_ctx, REG_VALUE_DATA *, op->in.max_values );
                if ( !values_out ) {
                        TALLOC_FREE( types_out );
                        hnd->status = NT_STATUS_NO_MEMORY;
                        return CAC_FAILURE;
                }

                val_names_out = TALLOC_ARRAY( mem_ctx, char *, op->in.max_values );
                if ( !val_names_out ) {
                        TALLOC_FREE( types_out );
                        TALLOC_FREE( values_out );
                        hnd->status = NT_STATUS_NO_MEMORY;
                        return CAC_FAILURE;
                }
        } else {
                types_out = NULL;
                values_out = NULL;
                val_names_out = NULL;
        }

        resume_idx = op->out.resume_idx;
        do {
                ZERO_STRUCT( val_buf );

                err = rpccli_reg_enum_val( pipe_hnd, mem_ctx, op->in.key,
                                           resume_idx, val_name_buf,
                                           &types_out[num_values_out],
                                           &val_buf );
                hnd->status = werror_to_ntstatus( err );

                if ( !NT_STATUS_IS_OK( hnd->status ) )
                        break;

                values_out[num_values_out] =
                        cac_MakeRegValueData( mem_ctx,
                                              types_out[num_values_out],
                                              val_buf );
                val_names_out[num_values_out] =
                        talloc_strdup( mem_ctx, val_name_buf );

                if ( !val_names_out[num_values_out]
                     || !values_out[num_values_out] ) {
                        hnd->status = NT_STATUS_NO_MEMORY;
                        break;
                }

                num_values_out++;
                resume_idx++;
        } while ( num_values_out < op->in.max_values );

        if ( CAC_OP_FAILED( hnd->status ) )
                return CAC_FAILURE;

        op->out.types = types_out;
        op->out.num_values = num_values_out;
        op->out.value_names = val_names_out;
        op->out.values = values_out;
        op->out.resume_idx = resume_idx;

        return CAC_SUCCESS;
}

int cac_RegSetValue	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegSetValue *	op
	)

Sets or creates value (type and data).

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 814 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・cac_MakeRpcDataBlob()・CacServerHandleInternal::ctx・err・errno・RegSetValue::in・RegSetValue::key・CacServerHandleInternal::pipes・rpccli_reg_flush_key()・rpccli_reg_set_val()・_CACSERVERHANDLE::status・RegSetValue::type・RegSetValue::val_name・RegSetValue::value・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        RPC_DATA_BLOB *buffer;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.key || !op->in.val_name || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        buffer = cac_MakeRpcDataBlob( mem_ctx, op->in.type, op->in.value );

        if ( !buffer ) {
                if ( errno == ENOMEM )
                        hnd->status = NT_STATUS_NO_MEMORY;
                else
                        hnd->status = NT_STATUS_INVALID_PARAMETER;

                return CAC_FAILURE;
        }

        err = rpccli_reg_set_val( pipe_hnd, mem_ctx, op->in.key,
                                  op->in.val_name, op->in.type, buffer );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) )
                return CAC_FAILURE;

        /*flush */
        err = rpccli_reg_flush_key( pipe_hnd, mem_ctx, op->in.key );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) )
                return CAC_FAILURE;

        return CAC_SUCCESS;
}

int cac_RegGetVersion	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegGetVersion *	op
	)

Retrieves the registry version number

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 871 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・CacServerHandleInternal::ctx・err・RegGetVersion::in・RegGetVersion::key・RegGetVersion::out・CacServerHandleInternal::pipes・rpccli_reg_getversion()・_CACSERVERHANDLE::status・RegGetVersion::version・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        uint32 version_out;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.key || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_getversion( pipe_hnd, mem_ctx, op->in.key,
                                     &version_out );
        hnd->status = werror_to_ntstatus( err );

        if ( !NT_STATUS_IS_OK( hnd->status ) )
                return CAC_FAILURE;

        op->out.version = version_out;

        return CAC_SUCCESS;
}

int cac_RegGetKeySecurity	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegGetKeySecurity *	op
	)

Retrieves a key security descriptor.

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 910 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・buf・cac_GetPipe()・CacServerHandleInternal::ctx・RegGetKeySecurity::descriptor・dup_sec_desc()・err・RegGetKeySecurity::in・RegGetKeySecurity::info_type・RegGetKeySecurity::key・RegGetKeySecurity::out・CacServerHandleInternal::pipes・rpccli_reg_get_key_sec()・RegGetKeySecurity::size・_CACSERVERHANDLE::status・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        uint32 buf_size;
        SEC_DESC_BUF buf;

        ZERO_STRUCT( buf );

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.key || op->in.info_type == 0 || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_get_key_sec( pipe_hnd, mem_ctx, op->in.key,
                                      op->in.info_type, &buf_size, &buf );
        hnd->status = werror_to_ntstatus( err );


        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        op->out.size = buf.len;
        op->out.descriptor = dup_sec_desc( mem_ctx, buf.sec );

        if ( op->out.descriptor == NULL ) {
                return CAC_FAILURE;
        }

        return CAC_SUCCESS;
}

int cac_RegSetKeySecurity	(	CacServerHandle *	hnd,
		TALLOC_CTX *	mem_ctx,
		struct RegSetKeySecurity *	op
	)

Sets the key security descriptor.

引数:

	hnd	Initialized and connected server handle
	mem_ctx	Context for memory allocation
	op	Initialized parameters

戻り値:

CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code

CAC_SUCCESS The operation completed successfully

cac_winreg.c の 959 行で定義されています。

参照先 _CACSERVERHANDLE::_internal・cac_GetPipe()・CacServerHandleInternal::ctx・RegSetKeySecurity::descriptor・err・RegSetKeySecurity::in・RegSetKeySecurity::info_type・RegSetKeySecurity::key・CacServerHandleInternal::pipes・rpccli_reg_set_key_sec()・RegSetKeySecurity::size・_CACSERVERHANDLE::status・werror_to_ntstatus().

{
        struct rpc_pipe_client *pipe_hnd = NULL;
        WERROR err;

        if ( !hnd )
                return CAC_FAILURE;

        if ( !hnd->_internal.ctx || !hnd->_internal.pipes[PI_WINREG] ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        if ( !op || !op->in.key || op->in.info_type == 0 || op->in.size == 0
             || !op->in.descriptor || !mem_ctx ) {
                hnd->status = NT_STATUS_INVALID_PARAMETER;
                return CAC_FAILURE;
        }

        pipe_hnd = cac_GetPipe( hnd, PI_WINREG );
        if ( !pipe_hnd ) {
                hnd->status = NT_STATUS_INVALID_HANDLE;
                return CAC_FAILURE;
        }

        err = rpccli_reg_set_key_sec( pipe_hnd, mem_ctx, op->in.key,
                                      op->in.info_type, op->in.size,
                                      op->in.descriptor );
        hnd->status = werror_to_ntstatus( err );


        if ( !NT_STATUS_IS_OK( hnd->status ) ) {
                return CAC_FAILURE;
        }

        return CAC_SUCCESS;
}

---