source: trunk-3.0/source/utils/net_rpc_registry.c@ 102

Last change on this file since 102 was 1, checked in by Paul Smedley, 19 years ago

Initial code import
File size: 13.4 KB
Line 
1/*
2 Samba Unix/Linux SMB client library
3 Distributed SMB/CIFS Server Management Utility
4 Copyright (C) Gerald (Jerry) Carter 2005
5
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.
10
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.
15
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. */
19
20#include "includes.h"
21#include "utils/net.h"
22#include "regfio.h"
23#include "reg_objects.h"
24
25/********************************************************************
26********************************************************************/
27
28char* dump_regval_type( uint32 type )
29{
30 static fstring string;
31
32 switch (type) {
33 case REG_SZ:
34 fstrcpy( string, "REG_SZ" );
35 break;
36 case REG_MULTI_SZ:
37 fstrcpy( string, "REG_MULTI_SZ" );
38 break;
39 case REG_EXPAND_SZ:
40 fstrcpy( string, "REG_EXPAND_SZ" );
41 break;
42 case REG_DWORD:
43 fstrcpy( string, "REG_DWORD" );
44 break;
45 case REG_BINARY:
46 fstrcpy( string, "REG_BINARY" );
47 break;
48 default:
49 fstr_sprintf( string, "UNKNOWN [%d]", type );
50 }
51
52 return string;
53}
54/********************************************************************
55********************************************************************/
56
57void dump_regval_buffer( uint32 type, REGVAL_BUFFER *buffer )
58{
59 pstring string;
60 uint32 value;
61
62 switch (type) {
63 case REG_SZ:
64 rpcstr_pull( string, buffer->buffer, sizeof(string), -1, STR_TERMINATE );
65 d_printf("%s\n", string);
66 break;
67 case REG_MULTI_SZ:
68 d_printf("\n");
69 break;
70 case REG_DWORD:
71 value = IVAL( buffer->buffer, 0 );
72 d_printf( "0x%x\n", value );
73 break;
74 case REG_BINARY:
75 d_printf("\n");
76 break;
77
78
79 default:
80 d_printf( "\tUnknown type [%d]\n", type );
81 }
82}
83
84/********************************************************************
85********************************************************************/
86
87static NTSTATUS rpc_registry_enumerate_internal(const DOM_SID *domain_sid,
88 const char *domain_name,
89 struct cli_state *cli,
90 struct rpc_pipe_client *pipe_hnd,
91 TALLOC_CTX *mem_ctx,
92 int argc,
93 const char **argv )
94{
95 WERROR result = WERR_GENERAL_FAILURE;
96 uint32 hive;
97 pstring subpath;
98 POLICY_HND pol_hive, pol_key;
99 uint32 idx;
100
101 if (argc != 1 ) {
102 d_printf("Usage: net rpc enumerate <path> [recurse]\n");
103 d_printf("Example: net rpc enumerate 'HKLM\\Software\\Samba'\n");
104 return NT_STATUS_OK;
105 }
106
107 if ( !reg_split_hive( argv[0], &hive, subpath ) ) {
108 d_fprintf(stderr, "invalid registry path\n");
109 return NT_STATUS_OK;
110 }
111
112 /* open the top level hive and then the registry key */
113
114 result = rpccli_reg_connect(pipe_hnd, mem_ctx, hive, MAXIMUM_ALLOWED_ACCESS, &pol_hive );
115 if ( !W_ERROR_IS_OK(result) ) {
116 d_fprintf(stderr, "Unable to connect to remote registry\n");
117 return werror_to_ntstatus(result);
118 }
119
120 if ( strlen( subpath ) != 0 ) {
121 result = rpccli_reg_open_entry(pipe_hnd, mem_ctx, &pol_hive, subpath, MAXIMUM_ALLOWED_ACCESS, &pol_key );
122 if ( !W_ERROR_IS_OK(result) ) {
123 d_fprintf(stderr, "Unable to open [%s]\n", argv[0]);
124 return werror_to_ntstatus(result);
125 }
126 }
127
128 /* get the subkeys */
129
130 result = WERR_OK;
131 idx = 0;
132 while ( W_ERROR_IS_OK(result) ) {
133 time_t modtime;
134 fstring keyname, classname;
135
136 result = rpccli_reg_enum_key(pipe_hnd, mem_ctx, &pol_key, idx,
137 keyname, classname, &modtime );
138
139 if ( W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS) ) {
140 result = WERR_OK;
141 break;
142 }
143
144 d_printf("Keyname = %s\n", keyname );
145 d_printf("Classname = %s\n", classname );
146 d_printf("Modtime = %s\n", http_timestring(modtime) );
147 d_printf("\n" );
148
149 idx++;
150 }
151
152 if ( !W_ERROR_IS_OK(result) )
153 goto out;
154
155 /* get the values */
156
157 result = WERR_OK;
158 idx = 0;
159 while ( W_ERROR_IS_OK(result) ) {
160 uint32 type;
161 fstring name;
162 REGVAL_BUFFER value;
163
164 fstrcpy( name, "" );
165 ZERO_STRUCT( value );
166
167 result = rpccli_reg_enum_val(pipe_hnd, mem_ctx, &pol_key, idx,
168 name, &type, &value );
169
170 if ( W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS) ) {
171 result = WERR_OK;
172 break;
173 }
174
175 d_printf("Valuename = %s\n", name );
176 d_printf("Type = %s\n", dump_regval_type(type) );
177 d_printf("Data = " );
178 dump_regval_buffer( type, &value );
179 d_printf("\n" );
180
181 idx++;
182 }
183
184
185out:
186 /* cleanup */
187
188 if ( strlen( subpath ) != 0 )
189 rpccli_reg_close(pipe_hnd, mem_ctx, &pol_key );
190 rpccli_reg_close(pipe_hnd, mem_ctx, &pol_hive );
191
192 return werror_to_ntstatus(result);
193}
194
195/********************************************************************
196********************************************************************/
197
198static int rpc_registry_enumerate( int argc, const char **argv )
199{
200 return run_rpc_command( NULL, PI_WINREG, 0,
201 rpc_registry_enumerate_internal, argc, argv );
202}
203
204/********************************************************************
205********************************************************************/
206
207static NTSTATUS rpc_registry_save_internal(const DOM_SID *domain_sid,
208 const char *domain_name,
209 struct cli_state *cli,
210 struct rpc_pipe_client *pipe_hnd,
211 TALLOC_CTX *mem_ctx,
212 int argc,
213 const char **argv )
214{
215 WERROR result = WERR_GENERAL_FAILURE;
216 uint32 hive;
217 pstring subpath;
218 POLICY_HND pol_hive, pol_key;
219
220 if (argc != 2 ) {
221 d_printf("Usage: net rpc backup <path> <file> \n");
222 return NT_STATUS_OK;
223 }
224
225 if ( !reg_split_hive( argv[0], &hive, subpath ) ) {
226 d_fprintf(stderr, "invalid registry path\n");
227 return NT_STATUS_OK;
228 }
229
230 /* open the top level hive and then the registry key */
231
232 result = rpccli_reg_connect(pipe_hnd, mem_ctx, hive, MAXIMUM_ALLOWED_ACCESS, &pol_hive );
233 if ( !W_ERROR_IS_OK(result) ) {
234 d_fprintf(stderr, "Unable to connect to remote registry\n");
235 return werror_to_ntstatus(result);
236 }
237
238 result = rpccli_reg_open_entry(pipe_hnd, mem_ctx, &pol_hive, subpath, MAXIMUM_ALLOWED_ACCESS, &pol_key );
239 if ( !W_ERROR_IS_OK(result) ) {
240 d_fprintf(stderr, "Unable to open [%s]\n", argv[0]);
241 return werror_to_ntstatus(result);
242 }
243
244 result = rpccli_reg_save_key(pipe_hnd, mem_ctx, &pol_key, argv[1] );
245 if ( !W_ERROR_IS_OK(result) ) {
246 d_fprintf(stderr, "Unable to save [%s] to %s:%s\n", argv[0], cli->desthost, argv[1]);
247 }
248
249
250 /* cleanup */
251
252 rpccli_reg_close(pipe_hnd, mem_ctx, &pol_key );
253 rpccli_reg_close(pipe_hnd, mem_ctx, &pol_hive );
254
255 return werror_to_ntstatus(result);
256}
257
258/********************************************************************
259********************************************************************/
260
261static int rpc_registry_save( int argc, const char **argv )
262{
263 return run_rpc_command( NULL, PI_WINREG, 0,
264 rpc_registry_save_internal, argc, argv );
265}
266
267
268/********************************************************************
269********************************************************************/
270
271static void dump_values( REGF_NK_REC *nk )
272{
273 int i, j;
274 pstring data_str;
275 uint32 data_size, data;
276
277 if ( !nk->values )
278 return;
279
280 for ( i=0; i<nk->num_values; i++ ) {
281 d_printf( "\"%s\" = ", nk->values[i].valuename ? nk->values[i].valuename : "(default)" );
282 d_printf( "(%s) ", dump_regval_type( nk->values[i].type ) );
283
284 data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
285 switch ( nk->values[i].type ) {
286 case REG_SZ:
287 rpcstr_pull( data_str, nk->values[i].data, sizeof(data_str), -1, STR_TERMINATE );
288 d_printf( "%s", data_str );
289 break;
290 case REG_MULTI_SZ:
291 case REG_EXPAND_SZ:
292 for ( j=0; j<data_size; j++ ) {
293 d_printf( "%c", nk->values[i].data[j] );
294 }
295 break;
296 case REG_DWORD:
297 data = IVAL( nk->values[i].data, 0 );
298 d_printf("0x%x", data );
299 break;
300 case REG_BINARY:
301 for ( j=0; j<data_size; j++ ) {
302 d_printf( "%x", nk->values[i].data[j] );
303 }
304 break;
305 default:
306 d_printf("unknown");
307 break;
308 }
309
310 d_printf( "\n" );
311 }
312
313}
314
315/********************************************************************
316********************************************************************/
317
318static BOOL dump_registry_tree( REGF_FILE *file, REGF_NK_REC *nk, const char *parent )
319{
320 REGF_NK_REC *key;
321 pstring regpath;
322
323 /* depth first dump of the registry tree */
324
325 while ( (key = regfio_fetch_subkey( file, nk )) ) {
326 pstr_sprintf( regpath, "%s\\%s", parent, key->keyname );
327 d_printf("[%s]\n", regpath );
328 dump_values( key );
329 d_printf("\n");
330 dump_registry_tree( file, key, regpath );
331 }
332
333 return True;
334}
335
336/********************************************************************
337********************************************************************/
338
339static BOOL write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
340 REGF_NK_REC *parent, REGF_FILE *outfile,
341 const char *parentpath )
342{
343 REGF_NK_REC *key, *subkey;
344 REGVAL_CTR *values;
345 REGSUBKEY_CTR *subkeys;
346 int i;
347 pstring path;
348
349 if ( !( subkeys = TALLOC_ZERO_P( infile->mem_ctx, REGSUBKEY_CTR )) ) {
350 DEBUG(0,("write_registry_tree: talloc() failed!\n"));
351 return False;
352 }
353
354 if ( !(values = TALLOC_ZERO_P( subkeys, REGVAL_CTR )) ) {
355 DEBUG(0,("write_registry_tree: talloc() failed!\n"));
356 return False;
357 }
358
359 /* copy values into the REGVAL_CTR */
360
361 for ( i=0; i<nk->num_values; i++ ) {
362 regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
363 (const char *)nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
364 }
365
366 /* copy subkeys into the REGSUBKEY_CTR */
367
368 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
369 regsubkey_ctr_addkey( subkeys, subkey->keyname );
370 }
371
372 key = regfio_write_key( outfile, nk->keyname, values, subkeys, nk->sec_desc->sec_desc, parent );
373
374 /* write each one of the subkeys out */
375
376 pstr_sprintf( path, "%s%s%s", parentpath, parent ? "\\" : "", nk->keyname );
377 nk->subkey_index = 0;
378 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
379 write_registry_tree( infile, subkey, key, outfile, path );
380 }
381
382 TALLOC_FREE( subkeys );
383
384 d_printf("[%s]\n", path );
385
386 return True;
387}
388
389/********************************************************************
390********************************************************************/
391
392static int rpc_registry_dump( int argc, const char **argv )
393{
394 REGF_FILE *registry;
395 REGF_NK_REC *nk;
396
397 if (argc != 1 ) {
398 d_printf("Usage: net rpc dump <file> \n");
399 return 0;
400 }
401
402 d_printf("Opening %s....", argv[0]);
403 if ( !(registry = regfio_open( argv[0], O_RDONLY, 0)) ) {
404 d_fprintf(stderr, "Failed to open %s for reading\n", argv[0]);
405 return 1;
406 }
407 d_printf("ok\n");
408
409 /* get the root of the registry file */
410
411 if ((nk = regfio_rootkey( registry )) == NULL) {
412 d_fprintf(stderr, "Could not get rootkey\n");
413 regfio_close( registry );
414 return 1;
415 }
416 d_printf("[%s]\n", nk->keyname);
417 dump_values( nk );
418 d_printf("\n");
419
420 dump_registry_tree( registry, nk, nk->keyname );
421
422#if 0
423 talloc_report_full( registry->mem_ctx, stderr );
424#endif
425 d_printf("Closing registry...");
426 regfio_close( registry );
427 d_printf("ok\n");
428
429 return 0;
430}
431
432/********************************************************************
433********************************************************************/
434
435static int rpc_registry_copy( int argc, const char **argv )
436{
437 REGF_FILE *infile = NULL, *outfile = NULL;
438 REGF_NK_REC *nk;
439 int result = 1;
440
441 if (argc != 2 ) {
442 d_printf("Usage: net rpc copy <srcfile> <newfile>\n");
443 return 0;
444 }
445
446 d_printf("Opening %s....", argv[0]);
447 if ( !(infile = regfio_open( argv[0], O_RDONLY, 0 )) ) {
448 d_fprintf(stderr, "Failed to open %s for reading\n", argv[0]);
449 return 1;
450 }
451 d_printf("ok\n");
452
453 d_printf("Opening %s....", argv[1]);
454 if ( !(outfile = regfio_open( argv[1], (O_RDWR|O_CREAT|O_TRUNC), (S_IREAD|S_IWRITE) )) ) {
455 d_fprintf(stderr, "Failed to open %s for writing\n", argv[1]);
456 goto out;
457 }
458 d_printf("ok\n");
459
460 /* get the root of the registry file */
461
462 if ((nk = regfio_rootkey( infile )) == NULL) {
463 d_fprintf(stderr, "Could not get rootkey\n");
464 goto out;
465 }
466 d_printf("RootKey: [%s]\n", nk->keyname);
467
468 write_registry_tree( infile, nk, NULL, outfile, "" );
469
470 result = 0;
471
472out:
473
474 d_printf("Closing %s...", argv[1]);
475 if (outfile) {
476 regfio_close( outfile );
477 }
478 d_printf("ok\n");
479
480 d_printf("Closing %s...", argv[0]);
481 if (infile) {
482 regfio_close( infile );
483 }
484 d_printf("ok\n");
485
486 return( result);
487}
488
489/********************************************************************
490********************************************************************/
491
492static int net_help_registry( int argc, const char **argv )
493{
494 d_printf("net rpc registry enumerate <path> [recurse] Enumerate the subkeya and values for a given registry path\n");
495 d_printf("net rpc registry save <path> <file> Backup a registry tree to a file on the server\n");
496 d_printf("net rpc registry dump <file> Dump the contents of a registry file to stdout\n");
497
498 return -1;
499}
500
501/********************************************************************
502********************************************************************/
503
504int net_rpc_registry(int argc, const char **argv)
505{
506 struct functable func[] = {
507 {"enumerate", rpc_registry_enumerate},
508 {"save", rpc_registry_save},
509 {"dump", rpc_registry_dump},
510 {"copy", rpc_registry_copy},
511 {NULL, NULL}
512 };
513
514 if ( argc )
515 return net_run_function( argc, argv, func, net_help_registry );
516
517 return net_help_registry( argc, argv );
518}
Note: See TracBrowser for help on using the repository browser.