2 Samba Unix/Linux SMB client library
3 Distributed SMB/CIFS Server Management Utility
4 Copyright (C) Gerald (Jerry) Carter 2005
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #include "utils/net.h"
23 #include "reg_objects.h"
26 /********************************************************************
27 ********************************************************************/
29 char* dump_regval_type( uint32 type )
31 static fstring string;
35 fstrcpy( string, "REG_SZ" );
38 fstrcpy( string, "REG_MULTI_SZ" );
41 fstrcpy( string, "REG_EXPAND_SZ" );
44 fstrcpy( string, "REG_DWORD" );
47 fstrcpy( string, "REG_BINARY" );
50 fstr_sprintf( string, "UNKNOWN [%d]", type );
55 /********************************************************************
56 ********************************************************************/
58 void dump_regval_buffer( uint32 type, REGVAL_BUFFER *buffer )
65 rpcstr_pull( string, buffer->buffer, sizeof(string), -1, STR_TERMINATE );
66 d_printf("%s\n", string);
72 value = IVAL( buffer->buffer, 0 );
73 d_printf( "0x%x\n", value );
81 d_printf( "\tUnknown type [%d]\n", type );
85 /********************************************************************
86 ********************************************************************/
88 static NTSTATUS rpc_registry_enumerate_internal( const DOM_SID *domain_sid, const char *domain_name,
89 struct cli_state *cli, TALLOC_CTX *mem_ctx,
90 int argc, const char **argv )
92 WERROR result = WERR_GENERAL_FAILURE;
95 POLICY_HND pol_hive, pol_key;
99 d_printf("Usage: net rpc enumerate <path> [recurse]\n");
100 d_printf("Example:: net rpc enumerate 'HKLM\\Software\\Samba'\n");
104 if ( !reg_split_hive( argv[0], &hive, subpath ) ) {
105 d_printf("invalid registry path\n");
109 /* open the top level hive and then the registry key */
111 result = cli_reg_connect( cli, mem_ctx, hive, MAXIMUM_ALLOWED_ACCESS, &pol_hive );
112 if ( !W_ERROR_IS_OK(result) ) {
113 d_printf("Unable to connect to remote registry\n");
114 return werror_to_ntstatus(result);
117 result = cli_reg_open_entry( cli, mem_ctx, &pol_hive, subpath, MAXIMUM_ALLOWED_ACCESS, &pol_key );
118 if ( !W_ERROR_IS_OK(result) ) {
119 d_printf("Unable to open [%s]\n", argv[0]);
120 return werror_to_ntstatus(result);
123 /* get the subkeys */
127 while ( W_ERROR_IS_OK(result) ) {
129 fstring keyname, classname;
131 result = cli_reg_enum_key( cli, mem_ctx, &pol_key, idx,
132 keyname, classname, &modtime );
134 if ( W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS) ) {
139 d_printf("Keyname = %s\n", keyname );
140 d_printf("Classname = %s\n", classname );
141 d_printf("Modtime = %s\n", http_timestring(modtime) );
147 if ( !W_ERROR_IS_OK(result) )
154 while ( W_ERROR_IS_OK(result) ) {
160 ZERO_STRUCT( value );
162 result = cli_reg_enum_val( cli, mem_ctx, &pol_key, idx,
163 name, &type, &value );
165 if ( W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS) ) {
170 d_printf("Valuename = %s\n", name );
171 d_printf("Type = %s\n", dump_regval_type(type) );
172 d_printf("Data = " );
173 dump_regval_buffer( type, &value );
183 cli_reg_close( cli, mem_ctx, &pol_key );
184 cli_reg_close( cli, mem_ctx, &pol_hive );
186 return werror_to_ntstatus(result);
189 /********************************************************************
190 ********************************************************************/
192 static int rpc_registry_enumerate( int argc, const char **argv )
194 return run_rpc_command( NULL, PI_WINREG, 0,
195 rpc_registry_enumerate_internal, argc, argv );
198 /********************************************************************
199 ********************************************************************/
201 static NTSTATUS rpc_registry_save_internal( const DOM_SID *domain_sid, const char *domain_name,
202 struct cli_state *cli, TALLOC_CTX *mem_ctx,
203 int argc, const char **argv )
205 WERROR result = WERR_GENERAL_FAILURE;
208 POLICY_HND pol_hive, pol_key;
211 d_printf("Usage: net rpc backup <path> <file> \n");
215 if ( !reg_split_hive( argv[0], &hive, subpath ) ) {
216 d_printf("invalid registry path\n");
220 /* open the top level hive and then the registry key */
222 result = cli_reg_connect( cli, mem_ctx, hive, MAXIMUM_ALLOWED_ACCESS, &pol_hive );
223 if ( !W_ERROR_IS_OK(result) ) {
224 d_printf("Unable to connect to remote registry\n");
225 return werror_to_ntstatus(result);
228 result = cli_reg_open_entry( cli, mem_ctx, &pol_hive, subpath, MAXIMUM_ALLOWED_ACCESS, &pol_key );
229 if ( !W_ERROR_IS_OK(result) ) {
230 d_printf("Unable to open [%s]\n", argv[0]);
231 return werror_to_ntstatus(result);
234 result = cli_reg_save_key( cli, mem_ctx, &pol_key, argv[1] );
235 if ( !W_ERROR_IS_OK(result) ) {
236 d_printf("Unable to save [%s] to %s:%s\n", argv[0], cli->desthost, argv[1]);
242 cli_reg_close( cli, mem_ctx, &pol_key );
243 cli_reg_close( cli, mem_ctx, &pol_hive );
245 return werror_to_ntstatus(result);
248 /********************************************************************
249 ********************************************************************/
251 static int rpc_registry_save( int argc, const char **argv )
253 return run_rpc_command( NULL, PI_WINREG, 0,
254 rpc_registry_save_internal, argc, argv );
258 /********************************************************************
259 ********************************************************************/
261 static void dump_values( REGF_NK_REC *nk )
265 uint32 data_size, data;
270 for ( i=0; i<nk->num_values; i++ ) {
271 d_printf( "\"%s\" = ", nk->values[i].valuename ? nk->values[i].valuename : "(default)" );
272 d_printf( "(%s) ", dump_regval_type( nk->values[i].type ) );
274 data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
275 switch ( nk->values[i].type ) {
277 rpcstr_pull( data_str, nk->values[i].data, sizeof(data_str), -1, STR_TERMINATE );
278 d_printf( "%s", data_str );
282 for ( j=0; j<data_size; j++ ) {
283 d_printf( "%c", nk->values[i].data[j] );
287 data = IVAL( nk->values[i].data, 0 );
288 d_printf("0x%x", data );
291 for ( j=0; j<data_size; j++ ) {
292 d_printf( "%x", nk->values[i].data[j] );
305 /********************************************************************
306 ********************************************************************/
308 static BOOL dump_registry_tree( REGF_FILE *file, REGF_NK_REC *nk, const char *parent )
313 /* depth first dump of the registry tree */
315 while ( (key = regfio_fetch_subkey( file, nk )) ) {
316 pstr_sprintf( regpath, "%s\\%s", parent, key->keyname );
317 d_printf("[%s]\n", regpath );
320 dump_registry_tree( file, key, regpath );
326 /********************************************************************
327 ********************************************************************/
329 static BOOL write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
330 REGF_NK_REC *parent, REGF_FILE *outfile,
331 const char *parentpath )
333 REGF_NK_REC *key, *subkey;
335 REGSUBKEY_CTR subkeys;
339 ZERO_STRUCT( values );
340 ZERO_STRUCT( subkeys );
342 regsubkey_ctr_init( &subkeys );
343 regval_ctr_init( &values );
345 /* copy values into the REGVAL_CTR */
347 for ( i=0; i<nk->num_values; i++ ) {
348 regval_ctr_addvalue( &values, nk->values[i].valuename, nk->values[i].type,
349 nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
352 /* copy subkeys into the REGSUBKEY_CTR */
354 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
355 regsubkey_ctr_addkey( &subkeys, subkey->keyname );
358 key = regfio_write_key( outfile, nk->keyname, &values, &subkeys, nk->sec_desc->sec_desc, parent );
360 /* write each one of the subkeys out */
362 pstr_sprintf( path, "%s%s%s", parentpath, parent ? "\\" : "", nk->keyname );
363 nk->subkey_index = 0;
364 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
365 write_registry_tree( infile, subkey, key, outfile, path );
368 regval_ctr_destroy( &values );
369 regsubkey_ctr_destroy( &subkeys );
371 d_printf("[%s]\n", path );
376 /********************************************************************
377 ********************************************************************/
379 static int rpc_registry_dump( int argc, const char **argv )
385 d_printf("Usage: net rpc dump <file> \n");
389 d_printf("Opening %s....", argv[0]);
390 if ( !(registry = regfio_open( argv[0], O_RDONLY, 0)) ) {
391 d_printf("Failed to open %s for reading\n", argv[0]);
396 /* get the root of the registry file */
398 nk = regfio_rootkey( registry );
399 d_printf("[%s]\n", nk->keyname);
403 dump_registry_tree( registry, nk, nk->keyname );
406 talloc_report_full( registry->mem_ctx, stderr );
408 d_printf("Closing registry...");
409 regfio_close( registry );
415 /********************************************************************
416 ********************************************************************/
418 static int rpc_registry_copy( int argc, const char **argv )
420 REGF_FILE *infile, *outfile;
424 d_printf("Usage: net rpc copy <srcfile> <newfile>\n");
428 d_printf("Opening %s....", argv[0]);
429 if ( !(infile = regfio_open( argv[0], O_RDONLY, 0 )) ) {
430 d_printf("Failed to open %s for reading\n", argv[0]);
435 d_printf("Opening %s....", argv[1]);
436 if ( !(outfile = regfio_open( argv[1], (O_RDWR|O_CREAT|O_TRUNC), (S_IREAD|S_IWRITE) )) ) {
437 d_printf("Failed to open %s for writing\n", argv[1]);
442 /* get the root of the registry file */
444 nk = regfio_rootkey( infile );
445 d_printf("RootKey: [%s]\n", nk->keyname);
447 write_registry_tree( infile, nk, NULL, outfile, "" );
449 d_printf("Closing %s...", argv[1]);
450 regfio_close( outfile );
453 d_printf("Closing %s...", argv[0]);
454 regfio_close( infile );
460 /********************************************************************
461 ********************************************************************/
463 static int net_help_registry( int argc, const char **argv )
465 d_printf("net rpc registry enumerate <path> [recurse] Enumerate the subkeya and values for a given registry path\n");
466 d_printf("net rpc registry save <path> <file> Backup a registry tree to a file on the server\n");
467 d_printf("net rpc registry dump <file> Dump the contents of a registry file to stdout\n");
472 /********************************************************************
473 ********************************************************************/
475 int net_rpc_registry(int argc, const char **argv)
477 struct functable func[] = {
478 {"enumerate", rpc_registry_enumerate},
479 {"save", rpc_registry_save},
480 {"dump", rpc_registry_dump},
481 {"copy", rpc_registry_copy},
486 return net_run_function( argc, argv, func, net_help_registry );
488 return net_help_registry( argc, argv );