?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r22747: Fix some C++ warnings
[Samba/gebeck_regimport.git] / source / utils / net_rpc_registry.c
blobb439f50ee44d1b040d69b2870c0be5f26907dd8d
1 /*
2 Samba Unix/Linux SMB client library
3 Distributed SMB/CIFS Server Management Utility
4
5 Copyright (C) Gerald (Jerry) Carter 2005-2006
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 #include "includes.h"
22 #include "utils/net.h"
23 #include "regfio.h"
24 #include "reg_objects.h"
25
26 static BOOL reg_hive_key(const char *fullname, uint32 *reg_type,
27 const char **key_name)
28 {
29 const char *sep;
30 ptrdiff_t len;
31
32 sep = strchr_m(fullname, '\\');
33
34 if (sep != NULL) {
35 len = sep - fullname;
36 *key_name = sep+1;
37 }
38 else {
39 len = strlen(fullname);
40 *key_name = "";
41 }
42
43 if (strnequal(fullname, "HKLM", len) ||
44 strnequal(fullname, "HKEY_LOCAL_MACHINE", len))
45 (*reg_type) = HKEY_LOCAL_MACHINE;
46 else if (strnequal(fullname, "HKCR", len) ||
47 strnequal(fullname, "HKEY_CLASSES_ROOT", len))
48 (*reg_type) = HKEY_CLASSES_ROOT;
49 else if (strnequal(fullname, "HKU", len) ||
50 strnequal(fullname, "HKEY_USERS", len))
51 (*reg_type) = HKEY_USERS;
52 else if (strnequal(fullname, "HKPD", len) ||
53 strnequal(fullname, "HKEY_PERFORMANCE_DATA", len))
54 (*reg_type) = HKEY_PERFORMANCE_DATA;
55 else {
56 DEBUG(10,("reg_hive_key: unrecognised hive key %s\n",
57 fullname));
58 return False;
59 }
60
61 return True;
62 }
63
64 static NTSTATUS registry_openkey(TALLOC_CTX *mem_ctx,
65 struct rpc_pipe_client *pipe_hnd,
66 const char *name, uint32 access_mask,
67 struct policy_handle *hive_hnd,
68 struct policy_handle *key_hnd)
69 {
70 uint32 hive;
71 NTSTATUS status;
72 struct winreg_String key;
73
74 if (!reg_hive_key(name, &hive, &key.name)) {
75 return NT_STATUS_INVALID_PARAMETER;
76 }
77
78 status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive, access_mask,
79 hive_hnd);
80 if (!(NT_STATUS_IS_OK(status))) {
81 return status;
82 }
83
84 status = rpccli_winreg_OpenKey(pipe_hnd, mem_ctx, hive_hnd, key, 0,
85 access_mask, key_hnd);
86 if (!(NT_STATUS_IS_OK(status))) {
87 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, hive_hnd);
88 return status;
89 }
90
91 return NT_STATUS_OK;
92 }
93
94 static NTSTATUS registry_enumkeys(TALLOC_CTX *ctx,
95 struct rpc_pipe_client *pipe_hnd,
96 struct policy_handle *key_hnd,
97 uint32 *pnum_keys, char ***pnames,
98 char ***pclasses, NTTIME ***pmodtimes)
99 {
100 TALLOC_CTX *mem_ctx;
101 NTSTATUS status;
102 uint32 num_subkeys, max_subkeylen, max_classlen;
103 uint32 num_values, max_valnamelen, max_valbufsize;
104 uint32 i;
105 NTTIME last_changed_time;
106 uint32 secdescsize;
107 struct winreg_String classname;
108 char **names, **classes;
109 NTTIME **modtimes;
110
111 if (!(mem_ctx = talloc_new(ctx))) {
112 return NT_STATUS_NO_MEMORY;
113 }
114
115 ZERO_STRUCT(classname);
116 status = rpccli_winreg_QueryInfoKey(
117 pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
118 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
119 &max_valbufsize, &secdescsize, &last_changed_time );
120
121 if (!NT_STATUS_IS_OK(status)) {
122 goto error;
123 }
124
125 if (num_subkeys == 0) {
126 *pnum_keys = 0;
127 TALLOC_FREE(mem_ctx);
128 return NT_STATUS_OK;
129 }
130
131 if ((!(names = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_subkeys))) ||
132 (!(classes = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_subkeys))) ||
133 (!(modtimes = TALLOC_ZERO_ARRAY(mem_ctx, NTTIME *,
134 num_subkeys)))) {
135 status = NT_STATUS_NO_MEMORY;
136 goto error;
137 }
138
139 for (i=0; i<num_subkeys; i++) {
140 char c, n;
141 struct winreg_StringBuf class_buf;
142 struct winreg_StringBuf name_buf;
143 NTTIME modtime;
144
145 c = '\0';
146 class_buf.name = &c;
147 class_buf.size = max_classlen+2;
148
149 n = '\0';
150 name_buf.name = &n;
151 name_buf.size = max_subkeylen+2;
152
153 ZERO_STRUCT(modtime);
154
155 status = rpccli_winreg_EnumKey(pipe_hnd, mem_ctx, key_hnd,
156 i, &name_buf, &class_buf,
157 &modtime);
158
159 if (W_ERROR_EQUAL(ntstatus_to_werror(status),
160 WERR_NO_MORE_ITEMS) ) {
161 status = NT_STATUS_OK;
162 break;
163 }
164 if (!NT_STATUS_IS_OK(status)) {
165 goto error;
166 }
167
168 classes[i] = NULL;
169
170 if (class_buf.name &&
171 (!(classes[i] = talloc_strdup(classes, class_buf.name)))) {
172 status = NT_STATUS_NO_MEMORY;
173 goto error;
174 }
175
176 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
177 status = NT_STATUS_NO_MEMORY;
178 goto error;
179 }
180
181 if ((!(modtimes[i] = (NTTIME *)talloc_memdup(
182 modtimes, &modtime, sizeof(modtime))))) {
183 status = NT_STATUS_NO_MEMORY;
184 goto error;
185 }
186 }
187
188 *pnum_keys = num_subkeys;
189
190 if (pnames) {
191 *pnames = talloc_move(ctx, &names);
192 }
193 if (pclasses) {
194 *pclasses = talloc_move(ctx, &classes);
195 }
196 if (pmodtimes) {
197 *pmodtimes = talloc_move(ctx, &modtimes);
198 }
199
200 status = NT_STATUS_OK;
201
202 error:
203 TALLOC_FREE(mem_ctx);
204 return status;
205 }
206
207 static NTSTATUS registry_enumvalues(TALLOC_CTX *ctx,
208 struct rpc_pipe_client *pipe_hnd,
209 struct policy_handle *key_hnd,
210 uint32 *pnum_values, char ***pvalnames,
211 struct registry_value ***pvalues)
212 {
213 TALLOC_CTX *mem_ctx;
214 NTSTATUS status;
215 uint32 num_subkeys, max_subkeylen, max_classlen;
216 uint32 num_values, max_valnamelen, max_valbufsize;
217 uint32 i;
218 NTTIME last_changed_time;
219 uint32 secdescsize;
220 struct winreg_String classname;
221 struct registry_value **values;
222 char **names;
223
224 if (!(mem_ctx = talloc_new(ctx))) {
225 return NT_STATUS_NO_MEMORY;
226 }
227
228 ZERO_STRUCT(classname);
229 status = rpccli_winreg_QueryInfoKey(
230 pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
231 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
232 &max_valbufsize, &secdescsize, &last_changed_time );
233
234 if (!NT_STATUS_IS_OK(status)) {
235 goto error;
236 }
237
238 if (num_values == 0) {
239 *pnum_values = 0;
240 TALLOC_FREE(mem_ctx);
241 return NT_STATUS_OK;
242 }
243
244 if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
245 (!(values = TALLOC_ARRAY(mem_ctx, struct registry_value *,
246 num_values)))) {
247 status = NT_STATUS_NO_MEMORY;
248 goto error;
249 }
250
251 for (i=0; i<num_values; i++) {
252 enum winreg_Type type = REG_NONE;
253 uint8 *data = NULL;
254 uint32 data_size;
255 uint32 value_length;
256
257 char n;
258 struct winreg_ValNameBuf name_buf;
259 WERROR err;
260
261 n = '\0';
262 name_buf.name = &n;
263 name_buf.size = max_valnamelen + 2;
264
265 data_size = max_valbufsize;
266 data = (uint8 *)TALLOC(mem_ctx, data_size);
267 value_length = 0;
268
269 status = rpccli_winreg_EnumValue(pipe_hnd, mem_ctx, key_hnd,
270 i, &name_buf, &type,
271 data, &data_size,
272 &value_length );
273
274 if ( W_ERROR_EQUAL(ntstatus_to_werror(status),
275 WERR_NO_MORE_ITEMS) ) {
276 status = NT_STATUS_OK;
277 break;
278 }
279
280 if (!(NT_STATUS_IS_OK(status))) {
281 goto error;
282 }
283
284 if (name_buf.name == NULL) {
285 status = NT_STATUS_INVALID_PARAMETER;
286 goto error;
287 }
288
289 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
290 status = NT_STATUS_NO_MEMORY;
291 goto error;
292 }
293
294 err = registry_pull_value(values, &values[i], type, data,
295 data_size, value_length);
296 if (!W_ERROR_IS_OK(err)) {
297 status = werror_to_ntstatus(err);
298 goto error;
299 }
300 }
301
302 *pnum_values = num_values;
303
304 if (pvalnames) {
305 *pvalnames = talloc_move(ctx, &names);
306 }
307 if (pvalues) {
308 *pvalues = talloc_move(ctx, &values);
309 }
310
311 status = NT_STATUS_OK;
312
313 error:
314 TALLOC_FREE(mem_ctx);
315 return status;
316 }
317
318 static NTSTATUS registry_setvalue(TALLOC_CTX *mem_ctx,
319 struct rpc_pipe_client *pipe_hnd,
320 struct policy_handle *key_hnd,
321 const char *name,
322 const struct registry_value *value)
323 {
324 struct winreg_String name_string;
325 DATA_BLOB blob;
326 NTSTATUS result;
327 WERROR err;
328
329 err = registry_push_value(mem_ctx, value, &blob);
330 if (!W_ERROR_IS_OK(err)) {
331 return werror_to_ntstatus(err);
332 }
333
334 name_string.name = name;
335 result = rpccli_winreg_SetValue(pipe_hnd, blob.data, key_hnd,
336 name_string, value->type,
337 blob.data, blob.length);
338 TALLOC_FREE(blob.data);
339 return result;
340 }
341
342 static NTSTATUS rpc_registry_setvalue_internal(const DOM_SID *domain_sid,
343 const char *domain_name,
344 struct cli_state *cli,
345 struct rpc_pipe_client *pipe_hnd,
346 TALLOC_CTX *mem_ctx,
347 int argc,
348 const char **argv )
349 {
350 struct policy_handle hive_hnd, key_hnd;
351 NTSTATUS status;
352 struct registry_value value;
353
354 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_WRITE,
355 &hive_hnd, &key_hnd);
356 if (!NT_STATUS_IS_OK(status)) {
357 d_fprintf(stderr, "registry_openkey failed: %s\n",
358 nt_errstr(status));
359 return status;
360 }
361
362 if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
363 d_fprintf(stderr, "Too many args for type %s\n", argv[2]);
364 return NT_STATUS_NOT_IMPLEMENTED;
365 }
366
367 if (strequal(argv[2], "dword")) {
368 value.type = REG_DWORD;
369 value.v.dword = strtoul(argv[3], NULL, 10);
370 }
371 else if (strequal(argv[2], "sz")) {
372 value.type = REG_SZ;
373 value.v.sz.len = strlen(argv[3])+1;
374 value.v.sz.str = CONST_DISCARD(char *, argv[3]);
375 }
376 else {
377 d_fprintf(stderr, "type \"%s\" not implemented\n", argv[2]);
378 status = NT_STATUS_NOT_IMPLEMENTED;
379 goto error;
380 }
381
382 status = registry_setvalue(mem_ctx, pipe_hnd, &key_hnd,
383 argv[1], &value);
384
385 if (!NT_STATUS_IS_OK(status)) {
386 d_fprintf(stderr, "registry_setvalue failed: %s\n",
387 nt_errstr(status));
388 }
389
390 error:
391 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd);
392 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd);
393
394 return NT_STATUS_OK;
395 }
396
397 static int rpc_registry_setvalue( int argc, const char **argv )
398 {
399 if (argc < 4) {
400 d_fprintf(stderr, "usage: net rpc registry setvalue <key> "
401 "<valuename> <type> [<val>]+\n");
402 return -1;
403 }
404
405 return run_rpc_command( NULL, PI_WINREG, 0,
406 rpc_registry_setvalue_internal, argc, argv );
407 }
408
409 static NTSTATUS rpc_registry_deletevalue_internal(const DOM_SID *domain_sid,
410 const char *domain_name,
411 struct cli_state *cli,
412 struct rpc_pipe_client *pipe_hnd,
413 TALLOC_CTX *mem_ctx,
414 int argc,
415 const char **argv )
416 {
417 struct policy_handle hive_hnd, key_hnd;
418 NTSTATUS status;
419 struct winreg_String valuename;
420
421 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_WRITE,
422 &hive_hnd, &key_hnd);
423 if (!NT_STATUS_IS_OK(status)) {
424 d_fprintf(stderr, "registry_openkey failed: %s\n",
425 nt_errstr(status));
426 return status;
427 }
428
429 valuename.name = argv[1];
430
431 status = rpccli_winreg_DeleteValue(pipe_hnd, mem_ctx, &key_hnd,
432 valuename);
433
434 if (!NT_STATUS_IS_OK(status)) {
435 d_fprintf(stderr, "registry_deletevalue failed: %s\n",
436 nt_errstr(status));
437 }
438
439 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd);
440 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd);
441
442 return NT_STATUS_OK;
443 }
444
445 static int rpc_registry_deletevalue( int argc, const char **argv )
446 {
447 if (argc != 2) {
448 d_fprintf(stderr, "usage: net rpc registry deletevalue <key> "
449 "<valuename>\n");
450 return -1;
451 }
452
453 return run_rpc_command( NULL, PI_WINREG, 0,
454 rpc_registry_deletevalue_internal, argc, argv );
455 }
456
457 static NTSTATUS rpc_registry_createkey_internal(const DOM_SID *domain_sid,
458 const char *domain_name,
459 struct cli_state *cli,
460 struct rpc_pipe_client *pipe_hnd,
461 TALLOC_CTX *mem_ctx,
462 int argc,
463 const char **argv )
464 {
465 uint32 hive;
466 struct policy_handle hive_hnd, key_hnd;
467 struct winreg_String key, keyclass;
468 enum winreg_CreateAction action;
469 NTSTATUS status;
470
471 if (!reg_hive_key(argv[0], &hive, &key.name)) {
472 return NT_STATUS_INVALID_PARAMETER;
473 }
474
475 status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
476 REG_KEY_READ|REG_KEY_WRITE,
477 &hive_hnd);
478 if (!(NT_STATUS_IS_OK(status))) {
479 return status;
480 }
481
482 action = REG_ACTION_NONE;
483 keyclass.name = "";
484
485 status = rpccli_winreg_CreateKey(pipe_hnd, mem_ctx, &hive_hnd, key,
486 keyclass, 0, REG_KEY_READ, NULL,
487 &key_hnd, &action);
488 if (!NT_STATUS_IS_OK(status)) {
489 d_fprintf(stderr, "createkey returned %s\n",
490 nt_errstr(status));
491 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd);
492 return status;
493 }
494
495 switch (action) {
496 case REG_ACTION_NONE:
497 d_printf("createkey did nothing -- huh?\n");
498 break;
499 case REG_CREATED_NEW_KEY:
500 d_printf("createkey created %s\n", argv[0]);
501 break;
502 case REG_OPENED_EXISTING_KEY:
503 d_printf("createkey opened existing %s\n", argv[0]);
504 break;
505 }
506
507 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd);
508 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd);
509
510 return status;
511 }
512
513 static int rpc_registry_createkey( int argc, const char **argv )
514 {
515 if (argc != 1) {
516 d_fprintf(stderr, "usage: net rpc registry createkey <key>\n");
517 return -1;
518 }
519
520 return run_rpc_command( NULL, PI_WINREG, 0,
521 rpc_registry_createkey_internal, argc, argv );
522 }
523
524 static NTSTATUS rpc_registry_deletekey_internal(const DOM_SID *domain_sid,
525 const char *domain_name,
526 struct cli_state *cli,
527 struct rpc_pipe_client *pipe_hnd,
528 TALLOC_CTX *mem_ctx,
529 int argc,
530 const char **argv )
531 {
532 uint32 hive;
533 struct policy_handle hive_hnd;
534 struct winreg_String key;
535 NTSTATUS status;
536
537 if (!reg_hive_key(argv[0], &hive, &key.name)) {
538 return NT_STATUS_INVALID_PARAMETER;
539 }
540
541 status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive, REG_KEY_WRITE,
542 &hive_hnd);
543 if (!(NT_STATUS_IS_OK(status))) {
544 return status;
545 }
546
547 status = rpccli_winreg_DeleteKey(pipe_hnd, mem_ctx, &hive_hnd, key);
548 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd);
549
550 if (!NT_STATUS_IS_OK(status)) {
551 d_fprintf(stderr, "deletekey returned %s\n",
552 nt_errstr(status));
553 }
554
555 return status;
556 }
557
558 static int rpc_registry_deletekey( int argc, const char **argv )
559 {
560 if (argc != 1) {
561 d_fprintf(stderr, "usage: net rpc registry deletekey <key>\n");
562 return -1;
563 }
564
565 return run_rpc_command( NULL, PI_WINREG, 0,
566 rpc_registry_deletekey_internal, argc, argv );
567 }
568
569 /********************************************************************
570 ********************************************************************/
571
572 static NTSTATUS rpc_registry_enumerate_internal(const DOM_SID *domain_sid,
573 const char *domain_name,
574 struct cli_state *cli,
575 struct rpc_pipe_client *pipe_hnd,
576 TALLOC_CTX *mem_ctx,
577 int argc,
578 const char **argv )
579 {
580 POLICY_HND pol_hive, pol_key;
581 NTSTATUS status;
582 uint32 num_subkeys = 0;
583 uint32 num_values = 0;
584 char **names = NULL, **classes = NULL;
585 NTTIME **modtimes = NULL;
586 uint32 i;
587 struct registry_value **values = NULL;
588
589 if (argc != 1 ) {
590 d_printf("Usage: net rpc enumerate <path> [recurse]\n");
591 d_printf("Example: net rpc enumerate 'HKLM\\Software\\Samba'\n");
592 return NT_STATUS_OK;
593 }
594
595 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
596 &pol_hive, &pol_key);
597 if (!NT_STATUS_IS_OK(status)) {
598 d_fprintf(stderr, "registry_openkey failed: %s\n",
599 nt_errstr(status));
600 return status;
601 }
602
603 status = registry_enumkeys(mem_ctx, pipe_hnd, &pol_key, &num_subkeys,
604 &names, &classes, &modtimes);
605 if (!NT_STATUS_IS_OK(status)) {
606 d_fprintf(stderr, "enumerating keys failed: %s\n",
607 nt_errstr(status));
608 return status;
609 }
610
611 for (i=0; i<num_subkeys; i++) {
612 d_printf("Keyname = %s\n", names[i]);
613 d_printf("Modtime = %s\n", modtimes[i]
614 ? http_timestring(nt_time_to_unix(*modtimes[i]))
615 : "None");
616 d_printf("\n" );
617 }
618
619 status = registry_enumvalues(mem_ctx, pipe_hnd, &pol_key, &num_values,
620 &names, &values);
621 if (!NT_STATUS_IS_OK(status)) {
622 d_fprintf(stderr, "enumerating values failed: %s\n",
623 nt_errstr(status));
624 return status;
625 }
626
627 for (i=0; i<num_values; i++) {
628 struct registry_value *v = values[i];
629 d_printf("Valuename = %s\n", names[i]);
630 d_printf("Type = %s\n",
631 reg_type_lookup(v->type));
632 switch(v->type) {
633 case REG_DWORD:
634 d_printf("Value = %d\n", v->v.dword);
635 break;
636 case REG_SZ:
637 case REG_EXPAND_SZ:
638 d_printf("Value = \"%s\"\n", v->v.sz.str);
639 break;
640 case REG_MULTI_SZ: {
641 uint32 j;
642 for (j = 0; j < v->v.multi_sz.num_strings; j++) {
643 d_printf("Value[%3.3d] = \"%s\"\n", j,
644 v->v.multi_sz.strings[j]);
645 }
646 break;
647 }
648 case REG_BINARY:
649 d_printf("Value = %d bytes\n",
650 (int)v->v.binary.length);
651 break;
652 default:
653 d_printf("Value = <unprintable>\n");
654 break;
655 }
656
657 d_printf("\n");
658 }
659
660 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key );
661 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive );
662
663 return status;
664 }
665
666 /********************************************************************
667 ********************************************************************/
668
669 static int rpc_registry_enumerate( int argc, const char **argv )
670 {
671 return run_rpc_command( NULL, PI_WINREG, 0,
672 rpc_registry_enumerate_internal, argc, argv );
673 }
674
675 /********************************************************************
676 ********************************************************************/
677
678 static NTSTATUS rpc_registry_save_internal(const DOM_SID *domain_sid,
679 const char *domain_name,
680 struct cli_state *cli,
681 struct rpc_pipe_client *pipe_hnd,
682 TALLOC_CTX *mem_ctx,
683 int argc,
684 const char **argv )
685 {
686 WERROR result = WERR_GENERAL_FAILURE;
687 POLICY_HND pol_hive, pol_key;
688 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
689 struct winreg_String filename;
690
691 if (argc != 2 ) {
692 d_printf("Usage: net rpc backup <path> <file> \n");
693 return NT_STATUS_OK;
694 }
695
696 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_ALL,
697 &pol_hive, &pol_key);
698 if (!NT_STATUS_IS_OK(status)) {
699 d_fprintf(stderr, "registry_openkey failed: %s\n",
700 nt_errstr(status));
701 return status;
702 }
703
704 filename.name = argv[1];
705 status = rpccli_winreg_SaveKey( pipe_hnd, mem_ctx, &pol_key, &filename, NULL );
706 if ( !W_ERROR_IS_OK(result) ) {
707 d_fprintf(stderr, "Unable to save [%s] to %s:%s\n", argv[0], cli->desthost, argv[1]);
708 }
709
710 /* cleanup */
711
712 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key );
713 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive );
714
715 return status;
716 }
717
718 /********************************************************************
719 ********************************************************************/
720
721 static int rpc_registry_save( int argc, const char **argv )
722 {
723 return run_rpc_command( NULL, PI_WINREG, 0,
724 rpc_registry_save_internal, argc, argv );
725 }
726
727
728 /********************************************************************
729 ********************************************************************/
730
731 static void dump_values( REGF_NK_REC *nk )
732 {
733 int i, j;
734 pstring data_str;
735 uint32 data_size, data;
736
737 if ( !nk->values )
738 return;
739
740 for ( i=0; i<nk->num_values; i++ ) {
741 d_printf( "\"%s\" = ", nk->values[i].valuename ? nk->values[i].valuename : "(default)" );
742 d_printf( "(%s) ", reg_type_lookup( nk->values[i].type ) );
743
744 data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
745 switch ( nk->values[i].type ) {
746 case REG_SZ:
747 rpcstr_pull( data_str, nk->values[i].data, sizeof(data_str), -1, STR_TERMINATE );
748 d_printf( "%s", data_str );
749 break;
750 case REG_MULTI_SZ:
751 case REG_EXPAND_SZ:
752 for ( j=0; j<data_size; j++ ) {
753 d_printf( "%c", nk->values[i].data[j] );
754 }
755 break;
756 case REG_DWORD:
757 data = IVAL( nk->values[i].data, 0 );
758 d_printf("0x%x", data );
759 break;
760 case REG_BINARY:
761 for ( j=0; j<data_size; j++ ) {
762 d_printf( "%x", nk->values[i].data[j] );
763 }
764 break;
765 default:
766 d_printf("unknown");
767 break;
768 }
769
770 d_printf( "\n" );
771 }
772
773 }
774
775 /********************************************************************
776 ********************************************************************/
777
778 static BOOL dump_registry_tree( REGF_FILE *file, REGF_NK_REC *nk, const char *parent )
779 {
780 REGF_NK_REC *key;
781 pstring regpath;
782
783 /* depth first dump of the registry tree */
784
785 while ( (key = regfio_fetch_subkey( file, nk )) ) {
786 pstr_sprintf( regpath, "%s\\%s", parent, key->keyname );
787 d_printf("[%s]\n", regpath );
788 dump_values( key );
789 d_printf("\n");
790 dump_registry_tree( file, key, regpath );
791 }
792
793 return True;
794 }
795
796 /********************************************************************
797 ********************************************************************/
798
799 static BOOL write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
800 REGF_NK_REC *parent, REGF_FILE *outfile,
801 const char *parentpath )
802 {
803 REGF_NK_REC *key, *subkey;
804 REGVAL_CTR *values;
805 REGSUBKEY_CTR *subkeys;
806 int i;
807 pstring path;
808
809 if ( !( subkeys = TALLOC_ZERO_P( infile->mem_ctx, REGSUBKEY_CTR )) ) {
810 DEBUG(0,("write_registry_tree: talloc() failed!\n"));
811 return False;
812 }
813
814 if ( !(values = TALLOC_ZERO_P( subkeys, REGVAL_CTR )) ) {
815 DEBUG(0,("write_registry_tree: talloc() failed!\n"));
816 return False;
817 }
818
819 /* copy values into the REGVAL_CTR */
820
821 for ( i=0; i<nk->num_values; i++ ) {
822 regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
823 (const char *)nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
824 }
825
826 /* copy subkeys into the REGSUBKEY_CTR */
827
828 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
829 regsubkey_ctr_addkey( subkeys, subkey->keyname );
830 }
831
832 key = regfio_write_key( outfile, nk->keyname, values, subkeys, nk->sec_desc->sec_desc, parent );
833
834 /* write each one of the subkeys out */
835
836 pstr_sprintf( path, "%s%s%s", parentpath, parent ? "\\" : "", nk->keyname );
837 nk->subkey_index = 0;
838 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
839 write_registry_tree( infile, subkey, key, outfile, path );
840 }
841
842 TALLOC_FREE( subkeys );
843
844 d_printf("[%s]\n", path );
845
846 return True;
847 }
848
849 /********************************************************************
850 ********************************************************************/
851
852 static int rpc_registry_dump( int argc, const char **argv )
853 {
854 REGF_FILE *registry;
855 REGF_NK_REC *nk;
856
857 if (argc != 1 ) {
858 d_printf("Usage: net rpc dump <file> \n");
859 return 0;
860 }
861
862 d_printf("Opening %s....", argv[0]);
863 if ( !(registry = regfio_open( argv[0], O_RDONLY, 0)) ) {
864 d_fprintf(stderr, "Failed to open %s for reading\n", argv[0]);
865 return 1;
866 }
867 d_printf("ok\n");
868
869 /* get the root of the registry file */
870
871 if ((nk = regfio_rootkey( registry )) == NULL) {
872 d_fprintf(stderr, "Could not get rootkey\n");
873 regfio_close( registry );
874 return 1;
875 }
876 d_printf("[%s]\n", nk->keyname);
877 dump_values( nk );
878 d_printf("\n");
879
880 dump_registry_tree( registry, nk, nk->keyname );
881
882 #if 0
883 talloc_report_full( registry->mem_ctx, stderr );
884 #endif
885 d_printf("Closing registry...");
886 regfio_close( registry );
887 d_printf("ok\n");
888
889 return 0;
890 }
891
892 /********************************************************************
893 ********************************************************************/
894
895 static int rpc_registry_copy( int argc, const char **argv )
896 {
897 REGF_FILE *infile = NULL, *outfile = NULL;
898 REGF_NK_REC *nk;
899 int result = 1;
900
901 if (argc != 2 ) {
902 d_printf("Usage: net rpc copy <srcfile> <newfile>\n");
903 return 0;
904 }
905
906 d_printf("Opening %s....", argv[0]);
907 if ( !(infile = regfio_open( argv[0], O_RDONLY, 0 )) ) {
908 d_fprintf(stderr, "Failed to open %s for reading\n", argv[0]);
909 return 1;
910 }
911 d_printf("ok\n");
912
913 d_printf("Opening %s....", argv[1]);
914 if ( !(outfile = regfio_open( argv[1], (O_RDWR|O_CREAT|O_TRUNC), (S_IREAD|S_IWRITE) )) ) {
915 d_fprintf(stderr, "Failed to open %s for writing\n", argv[1]);
916 goto out;
917 }
918 d_printf("ok\n");
919
920 /* get the root of the registry file */
921
922 if ((nk = regfio_rootkey( infile )) == NULL) {
923 d_fprintf(stderr, "Could not get rootkey\n");
924 goto out;
925 }
926 d_printf("RootKey: [%s]\n", nk->keyname);
927
928 write_registry_tree( infile, nk, NULL, outfile, "" );
929
930 result = 0;
931
932 out:
933
934 d_printf("Closing %s...", argv[1]);
935 if (outfile) {
936 regfio_close( outfile );
937 }
938 d_printf("ok\n");
939
940 d_printf("Closing %s...", argv[0]);
941 if (infile) {
942 regfio_close( infile );
943 }
944 d_printf("ok\n");
945
946 return( result);
947 }
948
949 /********************************************************************
950 ********************************************************************/
951
952 int net_rpc_registry(int argc, const char **argv)
953 {
954 struct functable2 func[] = {
955 { "enumerate", rpc_registry_enumerate,
956 "Enumerate registry keys and values" },
957 { "createkey", rpc_registry_createkey,
958 "Create a new registry key" },
959 { "deletekey", rpc_registry_deletekey,
960 "Delete a registry key" },
961 { "setvalue", rpc_registry_setvalue,
962 "Set a new registry value" },
963 { "deletevalue", rpc_registry_deletevalue,
964 "Delete a registry value" },
965 { "save", rpc_registry_save,
966 "Save a registry file" },
967 { "dump", rpc_registry_dump,
968 "Dump a registry file" },
969 { "copy", rpc_registry_copy,
970 "Copy a registry file" },
971 {NULL, NULL, NULL}
972 };
973
974 return net_run_function2(argc, argv, "net rpc registry", func);
975 }
reg import