2003-11-21 08:28:36 +03:00
/*
Unix SMB / CIFS implementation .
test suite for winreg rpc operations
Copyright ( C ) Tim Potter 2003
2004-05-14 22:59:00 +04:00
Copyright ( C ) Jelmer Vernooij 2004
2003-11-21 08:28:36 +03:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
along with this program ; if not , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
2004-11-01 13:30:34 +03:00
# include "librpc/gen_ndr/ndr_winreg.h"
2003-11-21 08:28:36 +03:00
2003-11-21 09:14:14 +03:00
static void init_winreg_String ( struct winreg_String * name , const char * s )
{
name - > name = s ;
2003-11-23 09:31:10 +03:00
if ( s ) {
name - > name_len = 2 * ( strlen_m ( s ) + 1 ) ;
name - > name_size = name - > name_len ;
} else {
name - > name_len = 0 ;
name - > name_size = 0 ;
}
2003-11-21 09:14:14 +03:00
}
2003-11-21 08:28:36 +03:00
static BOOL test_GetVersion ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle )
{
NTSTATUS status ;
struct winreg_GetVersion r ;
printf ( " \n testing GetVersion \n " ) ;
r . in . handle = handle ;
status = dcerpc_winreg_GetVersion ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " GetVersion failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2004-10-29 03:06:12 +04:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " GetVersion failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2003-11-21 08:28:36 +03:00
return True ;
}
2004-04-05 17:50:45 +04:00
static BOOL test_CreateKey ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
2004-06-14 03:50:55 +04:00
struct policy_handle * handle , const char * name ,
const char * class )
2004-04-05 17:50:45 +04:00
{
struct winreg_CreateKey r ;
struct policy_handle newhandle ;
NTSTATUS status ;
2004-05-25 20:24:13 +04:00
uint32_t sec_info = 0 ;
2004-04-05 17:50:45 +04:00
printf ( " \n testing CreateKey \n " ) ;
r . in . handle = handle ;
r . out . handle = & newhandle ;
init_winreg_String ( & r . in . key , name ) ;
2004-04-09 02:39:47 +04:00
init_winreg_String ( & r . in . class , class ) ;
2004-04-05 17:50:45 +04:00
r . in . reserved = 0x0 ;
r . in . access_mask = 0x02000000 ;
2004-04-09 02:39:47 +04:00
r . in . sec_info = & sec_info ;
r . in . sec_desc = NULL ;
2004-04-05 17:50:45 +04:00
status = dcerpc_winreg_CreateKey ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " CreateKey failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2004-04-06 00:44:33 +04:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " CreateKey failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2004-04-05 17:50:45 +04:00
return True ;
}
2003-11-21 08:28:36 +03:00
static BOOL test_CloseKey ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle )
{
NTSTATUS status ;
struct winreg_CloseKey r ;
printf ( " \n testing CloseKey \n " ) ;
r . in . handle = r . out . handle = handle ;
status = dcerpc_winreg_CloseKey ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " CloseKey failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2004-10-29 03:06:12 +04:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " CloseKey failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2003-11-21 08:28:36 +03:00
return True ;
}
2003-11-21 09:14:14 +03:00
static BOOL test_FlushKey ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle )
{
NTSTATUS status ;
struct winreg_FlushKey r ;
printf ( " \n testing FlushKey \n " ) ;
r . in . handle = handle ;
status = dcerpc_winreg_FlushKey ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " FlushKey failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2004-10-29 01:24:29 +04:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " FlushKey failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2003-11-21 09:14:14 +03:00
return True ;
}
2003-11-22 08:34:25 +03:00
static BOOL test_OpenKey ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * hive_handle ,
2004-04-06 02:34:24 +04:00
const char * keyname , struct policy_handle * key_handle )
2003-11-22 08:34:25 +03:00
{
NTSTATUS status ;
struct winreg_OpenKey r ;
printf ( " \n testing OpenKey \n " ) ;
r . in . handle = hive_handle ;
init_winreg_String ( & r . in . keyname , keyname ) ;
r . in . unknown = 0x00000000 ;
r . in . access_mask = 0x02000000 ;
r . out . handle = key_handle ;
status = dcerpc_winreg_OpenKey ( p , mem_ctx , & r ) ;
2004-04-09 02:39:47 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " OpenKey failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2003-11-22 08:34:25 +03:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
2004-12-09 01:02:49 +03:00
printf ( " OpenKey failed - %s \n " , win_errstr ( r . out . result ) ) ;
2003-11-22 08:34:25 +03:00
return False ;
}
return True ;
}
2003-11-21 09:14:14 +03:00
static BOOL test_DeleteKey ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
2004-04-06 02:34:24 +04:00
struct policy_handle * handle , const char * key )
2003-11-21 09:14:14 +03:00
{
NTSTATUS status ;
struct winreg_DeleteKey r ;
printf ( " \n testing DeleteKey \n " ) ;
r . in . handle = handle ;
init_winreg_String ( & r . in . key , key ) ;
status = dcerpc_winreg_DeleteKey ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " DeleteKey failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2004-04-06 00:44:33 +04:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " DeleteKey failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2003-11-21 09:14:14 +03:00
return True ;
}
2003-11-22 08:34:25 +03:00
static BOOL test_QueryInfoKey ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle , char * class )
{
NTSTATUS status ;
struct winreg_QueryInfoKey r ;
printf ( " \n testing QueryInfoKey \n " ) ;
r . in . handle = handle ;
init_winreg_String ( & r . in . class , class ) ;
status = dcerpc_winreg_QueryInfoKey ( p , mem_ctx , & r ) ;
2004-04-09 02:39:47 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " QueryInfoKey failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2003-11-22 08:34:25 +03:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " QueryInfoKey failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
return True ;
}
2003-12-12 14:49:29 +03:00
static BOOL test_key ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle , int depth ) ;
2003-12-12 09:29:21 +03:00
2003-12-12 14:49:29 +03:00
static BOOL test_EnumKey ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle , int depth )
2003-11-22 08:34:25 +03:00
{
2003-12-12 14:49:29 +03:00
struct winreg_EnumKey r ;
struct winreg_EnumKeyNameRequest keyname ;
struct winreg_String classname ;
struct winreg_Time tm ;
2003-11-22 08:34:25 +03:00
NTSTATUS status ;
2004-10-29 03:06:12 +04:00
printf ( " Testing EnumKey \n \n " ) ;
2003-12-12 14:49:29 +03:00
r . in . handle = handle ;
r . in . enum_index = 0 ;
r . in . key_name_len = r . out . key_name_len = 0 ;
r . in . unknown = r . out . unknown = 0x0414 ;
keyname . unknown = 0x0000020a ;
init_winreg_String ( & keyname . key_name , NULL ) ;
init_winreg_String ( & classname , NULL ) ;
r . in . in_name = & keyname ;
r . in . class = & classname ;
tm . low = tm . high = 0x7fffffff ;
r . in . last_changed_time = & tm ;
2003-11-22 08:34:25 +03:00
2003-12-12 14:49:29 +03:00
do {
status = dcerpc_winreg_EnumKey ( p , mem_ctx , & r ) ;
2003-11-22 08:34:25 +03:00
2003-12-12 14:49:29 +03:00
if ( NT_STATUS_IS_OK ( status ) & & W_ERROR_IS_OK ( r . out . result ) ) {
struct policy_handle key_handle ;
2003-11-22 08:34:25 +03:00
2004-10-29 05:10:40 +04:00
printf ( " EnumKey: %d: %s \n " , r . in . enum_index , r . out . out_name - > name ) ;
2003-12-12 14:49:29 +03:00
if ( ! test_OpenKey (
p , mem_ctx , handle , r . out . out_name - > name ,
& key_handle ) ) {
2004-10-29 05:10:40 +04:00
} else {
test_key ( p , mem_ctx , & key_handle , depth + 1 ) ;
2003-12-12 14:49:29 +03:00
}
}
r . in . enum_index + + ;
2004-10-29 01:24:29 +04:00
} while ( NT_STATUS_IS_OK ( status ) & & W_ERROR_IS_OK ( r . out . result ) ) ;
2003-12-12 14:49:29 +03:00
2004-10-29 05:10:40 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " EnumKey failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
if ( ! W_ERROR_IS_OK ( r . out . result ) & & ! W_ERROR_EQUAL ( r . out . result , WERR_NO_MORE_ITEMS ) ) {
printf ( " EnumKey failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2003-12-12 14:49:29 +03:00
return True ;
}
2004-12-09 01:02:49 +03:00
static BOOL test_QueryValue ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx , struct policy_handle * handle , const char * valuename )
{
struct winreg_QueryValue r ;
NTSTATUS status ;
uint32 zero = 0 ;
uint32 offered = 0xfff ;
printf ( " Testing QueryValue \n " ) ;
r . in . handle = handle ;
r . in . value_name . name = valuename ;
r . in . type = & zero ;
2004-12-09 10:05:47 +03:00
r . in . size = & offered ;
r . in . length = & zero ;
2004-12-09 01:02:49 +03:00
status = dcerpc_winreg_QueryValue ( p , mem_ctx , & r ) ;
if ( NT_STATUS_IS_ERR ( status ) ) {
printf ( " QueryValue failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " QueryValue failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
return True ;
}
2003-12-12 14:49:29 +03:00
static BOOL test_EnumValue ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
2004-04-13 01:59:41 +04:00
struct policy_handle * handle , int max_valnamelen , int max_valbufsize )
2003-12-12 14:49:29 +03:00
{
struct winreg_EnumValue r ;
2004-12-11 01:35:35 +03:00
uint32 type = 0 ;
2004-12-09 10:52:00 +03:00
uint32 size = max_valbufsize , zero = 0 ;
2004-12-09 01:02:49 +03:00
BOOL ret = True ;
2004-12-09 10:52:00 +03:00
uint8_t buf8 ;
uint16_t buf16 ;
2003-11-22 08:34:25 +03:00
2004-10-11 03:03:12 +04:00
printf ( " testing EnumValue \n " ) ;
2003-11-22 08:34:25 +03:00
2004-10-11 03:03:12 +04:00
r . in . handle = handle ;
r . in . enum_index = 0 ;
2004-12-09 10:52:00 +03:00
r . in . name_in . length = 0 ;
r . in . name_in . size = 0x200 ;
r . in . name_in . name = & buf16 ;
2004-10-11 03:03:12 +04:00
r . in . type = & type ;
2004-12-09 10:52:00 +03:00
r . in . value = & buf8 ;
r . in . length = & zero ;
r . in . size = & size ;
2004-10-11 03:03:12 +04:00
2003-11-22 08:34:25 +03:00
do {
2004-10-11 03:03:12 +04:00
NTSTATUS status = dcerpc_winreg_EnumValue ( p , mem_ctx , & r ) ;
2004-04-13 01:59:41 +04:00
if ( NT_STATUS_IS_ERR ( status ) ) {
printf ( " EnumValue failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2004-10-11 03:03:12 +04:00
2004-12-09 01:02:49 +03:00
if ( W_ERROR_IS_OK ( r . out . result ) ) {
ret & = test_QueryValue ( p , mem_ctx , handle , r . out . name_out . name ) ;
}
2003-12-12 14:49:29 +03:00
r . in . enum_index + + ;
2003-11-22 08:34:25 +03:00
} while ( W_ERROR_IS_OK ( r . out . result ) ) ;
2004-04-13 01:59:41 +04:00
if ( ! W_ERROR_EQUAL ( r . out . result , WERR_NO_MORE_ITEMS ) ) {
printf ( " EnumValue failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2004-10-11 03:03:12 +04:00
2004-12-09 01:02:49 +03:00
return ret ;
2003-11-22 08:34:25 +03:00
}
static BOOL test_OpenHKLM ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle )
2003-11-21 08:28:36 +03:00
{
NTSTATUS status ;
struct winreg_OpenHKLM r ;
2003-11-22 08:34:25 +03:00
struct winreg_OpenUnknown unknown ;
2003-11-21 08:28:36 +03:00
BOOL ret = True ;
printf ( " \n testing OpenHKLM \n " ) ;
unknown . unknown0 = 0x84e0 ;
unknown . unknown1 = 0x0000 ;
r . in . unknown = & unknown ;
2004-12-02 07:37:36 +03:00
r . in . access_required = SEC_FLAG_MAXIMUM_ALLOWED ;
2003-11-22 08:34:25 +03:00
r . out . handle = handle ;
2003-11-21 08:28:36 +03:00
status = dcerpc_winreg_OpenHKLM ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " OpenHKLM failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
2004-10-29 01:24:29 +04:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " OpenHKLM failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2003-11-22 08:34:25 +03:00
return ret ;
}
static BOOL test_OpenHKU ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle )
{
NTSTATUS status ;
struct winreg_OpenHKU r ;
struct winreg_OpenUnknown unknown ;
BOOL ret = True ;
printf ( " \n testing OpenHKU \n " ) ;
unknown . unknown0 = 0x84e0 ;
unknown . unknown1 = 0x0000 ;
r . in . unknown = & unknown ;
2004-12-02 07:37:36 +03:00
r . in . access_required = SEC_FLAG_MAXIMUM_ALLOWED ;
2003-11-22 08:34:25 +03:00
r . out . handle = handle ;
status = dcerpc_winreg_OpenHKU ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " OpenHKU failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
2003-11-21 08:28:36 +03:00
}
2004-12-11 02:20:24 +03:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " OpenHKU failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2003-11-22 08:34:25 +03:00
return ret ;
}
static BOOL test_OpenHKCR ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle )
{
NTSTATUS status ;
struct winreg_OpenHKCR r ;
struct winreg_OpenUnknown unknown ;
BOOL ret = True ;
printf ( " \n testing OpenHKCR \n " ) ;
unknown . unknown0 = 0x84e0 ;
unknown . unknown1 = 0x0000 ;
r . in . unknown = & unknown ;
2004-12-02 07:37:36 +03:00
r . in . access_required = SEC_FLAG_MAXIMUM_ALLOWED ;
2003-11-22 08:34:25 +03:00
r . out . handle = handle ;
status = dcerpc_winreg_OpenHKCR ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " OpenHKCR failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
2003-11-21 09:14:14 +03:00
}
2004-12-11 02:20:24 +03:00
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " OpenHKU failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
2003-11-22 08:34:25 +03:00
return ret ;
}
2004-04-09 02:39:47 +04:00
static BOOL test_InitiateSystemShutdown ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
2004-05-25 20:24:13 +04:00
const char * msg , uint32_t timeout )
2004-04-09 02:39:47 +04:00
{
struct winreg_InitiateSystemShutdown r ;
NTSTATUS status ;
2004-12-10 23:07:04 +03:00
init_winreg_String ( & r . in . hostname , NULL ) ;
2004-04-09 02:39:47 +04:00
init_winreg_String ( & r . in . message , msg ) ;
r . in . flags = 0 ;
r . in . timeout = timeout ;
status = dcerpc_winreg_InitiateSystemShutdown ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " InitiateSystemShutdown failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " InitiateSystemShutdown failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
return True ;
}
static BOOL test_AbortSystemShutdown ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx )
{
struct winreg_AbortSystemShutdown r ;
NTSTATUS status ;
2004-05-25 21:24:24 +04:00
uint16_t server = 0x0 ;
2004-04-09 02:39:47 +04:00
2004-04-11 20:04:06 +04:00
r . in . server = & server ;
2004-04-09 02:39:47 +04:00
status = dcerpc_winreg_AbortSystemShutdown ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " AbortSystemShutdown failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " AbortSystemShutdown failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
return True ;
}
2003-11-22 08:34:25 +03:00
static BOOL test_OpenHKCU ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle )
{
NTSTATUS status ;
struct winreg_OpenHKCU r ;
struct winreg_OpenUnknown unknown ;
BOOL ret = True ;
printf ( " \n testing OpenHKCU \n " ) ;
unknown . unknown0 = 0x84e0 ;
unknown . unknown1 = 0x0000 ;
r . in . unknown = & unknown ;
2004-12-02 07:37:36 +03:00
r . in . access_required = SEC_FLAG_MAXIMUM_ALLOWED ;
2003-11-22 08:34:25 +03:00
r . out . handle = handle ;
status = dcerpc_winreg_OpenHKCU ( p , mem_ctx , & r ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " OpenHKCU failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
2003-11-21 08:28:36 +03:00
}
return ret ;
}
2003-11-23 14:57:15 +03:00
# define MAX_DEPTH 2 /* Only go this far down the tree */
2003-11-23 09:31:10 +03:00
2003-11-23 14:57:15 +03:00
static BOOL test_key ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle , int depth )
2003-11-23 09:31:10 +03:00
{
2003-11-23 14:57:15 +03:00
if ( depth = = MAX_DEPTH )
return True ;
2003-11-23 09:38:37 +03:00
2003-11-23 14:57:15 +03:00
if ( ! test_QueryInfoKey ( p , mem_ctx , handle , NULL ) ) {
2003-11-23 09:31:10 +03:00
}
2003-12-12 14:49:29 +03:00
if ( ! test_EnumKey ( p , mem_ctx , handle , depth ) ) {
}
2003-11-23 09:31:10 +03:00
2004-10-11 03:03:12 +04:00
if ( ! test_EnumValue ( p , mem_ctx , handle , 0xFF , 0xFFFF ) ) {
2003-12-12 14:49:29 +03:00
}
2003-12-12 09:29:21 +03:00
2003-11-23 14:57:15 +03:00
test_CloseKey ( p , mem_ctx , handle ) ;
return True ;
}
typedef BOOL winreg_open_fn ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx ,
struct policy_handle * handle ) ;
static BOOL test_Open ( struct dcerpc_pipe * p , TALLOC_CTX * mem_ctx , void * fn )
{
2004-04-06 00:44:33 +04:00
struct policy_handle handle , newhandle ;
2004-04-05 17:50:45 +04:00
BOOL ret = True ;
2003-11-23 14:57:15 +03:00
winreg_open_fn * open_fn = ( winreg_open_fn * ) fn ;
2004-08-21 05:54:46 +04:00
if ( ! open_fn ( p , mem_ctx , & handle ) ) {
2003-11-23 14:57:15 +03:00
return False ;
2004-08-21 05:54:46 +04:00
}
2003-11-23 14:57:15 +03:00
2004-04-09 02:39:47 +04:00
if ( ! test_CreateKey ( p , mem_ctx , & handle , " spottyfoot " , NULL ) ) {
2004-04-05 17:50:45 +04:00
printf ( " CreateKey failed \n " ) ;
ret = False ;
2003-11-23 09:31:10 +03:00
}
2004-04-12 03:16:47 +04:00
if ( ! test_FlushKey ( p , mem_ctx , & handle ) ) {
printf ( " FlushKey failed \n " ) ;
ret = False ;
}
2004-04-06 00:44:33 +04:00
if ( ! test_OpenKey ( p , mem_ctx , & handle , " spottyfoot " , & newhandle ) ) {
printf ( " CreateKey failed (OpenKey after Create didn't work) \n " ) ;
ret = False ;
}
2003-11-23 14:57:15 +03:00
if ( ! test_DeleteKey ( p , mem_ctx , & handle , " spottyfoot " ) ) {
2003-12-12 09:29:21 +03:00
printf ( " DeleteKey failed \n " ) ;
2004-04-05 17:50:45 +04:00
ret = False ;
2003-11-23 14:57:15 +03:00
}
2004-04-12 03:16:47 +04:00
if ( ! test_FlushKey ( p , mem_ctx , & handle ) ) {
printf ( " FlushKey failed \n " ) ;
ret = False ;
}
2004-04-06 00:44:33 +04:00
if ( test_OpenKey ( p , mem_ctx , & handle , " spottyfoot " , & newhandle ) ) {
printf ( " DeleteKey failed (OpenKey after Delete didn't work) \n " ) ;
ret = False ;
}
2004-04-09 02:39:47 +04:00
if ( ! test_GetVersion ( p , mem_ctx , & handle ) ) {
printf ( " GetVersion failed \n " ) ;
ret = False ;
}
2003-11-23 14:57:15 +03:00
/* The HKCR hive has a very large fanout */
2004-04-05 17:50:45 +04:00
if ( open_fn = = test_OpenHKCR ) {
if ( ! test_key ( p , mem_ctx , & handle , MAX_DEPTH - 1 ) ) {
ret = False ;
}
}
2003-11-23 14:57:15 +03:00
2004-04-05 17:50:45 +04:00
if ( ! test_key ( p , mem_ctx , & handle , 0 ) ) {
ret = False ;
}
return ret ;
2003-11-23 09:31:10 +03:00
}
2003-11-22 08:34:25 +03:00
2004-10-28 17:40:50 +04:00
BOOL torture_rpc_winreg ( void )
2003-11-21 08:28:36 +03:00
{
NTSTATUS status ;
2004-04-09 02:39:47 +04:00
struct dcerpc_pipe * p ;
2003-11-21 08:28:36 +03:00
TALLOC_CTX * mem_ctx ;
BOOL ret = True ;
2003-11-23 14:57:15 +03:00
winreg_open_fn * open_fns [ ] = { test_OpenHKLM , test_OpenHKU ,
test_OpenHKCR , test_OpenHKCU } ;
2003-11-22 08:34:25 +03:00
int i ;
2003-11-21 08:28:36 +03:00
mem_ctx = talloc_init ( " torture_rpc_winreg " ) ;
status = torture_rpc_connection ( & p ,
DCERPC_WINREG_NAME ,
DCERPC_WINREG_UUID ,
DCERPC_WINREG_VERSION ) ;
2003-11-23 09:31:10 +03:00
2003-11-21 08:28:36 +03:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
return False ;
}
2004-04-09 02:39:47 +04:00
if ( ! test_InitiateSystemShutdown ( p , mem_ctx , " spottyfood " , 30 ) )
ret = False ;
2004-04-11 20:04:06 +04:00
if ( ! test_AbortSystemShutdown ( p , mem_ctx ) )
ret = False ;
2003-11-22 08:34:25 +03:00
for ( i = 0 ; i < ARRAY_SIZE ( open_fns ) ; i + + ) {
2003-11-23 09:31:10 +03:00
if ( ! test_Open ( p , mem_ctx , open_fns [ i ] ) )
2003-11-22 08:34:25 +03:00
ret = False ;
2003-11-21 08:28:36 +03:00
}
2003-11-22 11:11:32 +03:00
talloc_destroy ( mem_ctx ) ;
2003-11-21 08:28:36 +03:00
torture_rpc_close ( p ) ;
return ret ;
}