?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-net: add command rpc registry export
[Samba.git] / source3 / utils / net_rpc_registry.c
blobd0d09481ed4efe95e79c3076ac3cfa4618c068cc
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 3 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, see <http://www.gnu.org/licenses/>. */
19
20 #include "includes.h"
21 #include "popt_common.h"
22 #include "registry.h"
23 #include "utils/net.h"
24 #include "utils/net_registry_util.h"
25 #include "registry/regfio.h"
26 #include "../librpc/gen_ndr/cli_winreg.h"
27 #include "registry/reg_objects.h"
28 #include "../librpc/gen_ndr/ndr_security.h"
29 #include "registry/reg_format.h"
30 #include <assert.h>
31
32
33 /*******************************************************************
34 connect to a registry hive root (open a registry policy)
35 *******************************************************************/
36
37 static NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
38 uint32_t reg_type, uint32_t access_mask,
39 struct policy_handle *reg_hnd, WERROR *werr)
40 {
41 ZERO_STRUCTP(reg_hnd);
42
43 switch (reg_type)
44 {
45 case HKEY_CLASSES_ROOT:
46 return rpccli_winreg_OpenHKCR( cli, mem_ctx, NULL,
47 access_mask, reg_hnd, werr);
48
49 case HKEY_LOCAL_MACHINE:
50 return rpccli_winreg_OpenHKLM( cli, mem_ctx, NULL,
51 access_mask, reg_hnd, werr);
52
53 case HKEY_USERS:
54 return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL,
55 access_mask, reg_hnd, werr);
56
57 case HKEY_CURRENT_USER:
58 return rpccli_winreg_OpenHKCU( cli, mem_ctx, NULL,
59 access_mask, reg_hnd, werr);
60
61 case HKEY_PERFORMANCE_DATA:
62 return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL,
63 access_mask, reg_hnd, werr);
64
65 default:
66 /* fall through to end of function */
67 break;
68 }
69
70 return NT_STATUS_INVALID_PARAMETER;
71 }
72
73 static bool reg_hive_key(TALLOC_CTX *ctx, const char *fullname,
74 uint32 *reg_type, const char **key_name)
75 {
76 WERROR werr;
77 char *hivename = NULL;
78 char *tmp_keyname = NULL;
79 bool ret = false;
80 TALLOC_CTX *tmp_ctx = talloc_stackframe();
81
82 werr = split_hive_key(tmp_ctx, fullname, &hivename, &tmp_keyname);
83 if (!W_ERROR_IS_OK(werr)) {
84 goto done;
85 }
86
87 *key_name = talloc_strdup(ctx, tmp_keyname);
88 if (*key_name == NULL) {
89 goto done;
90 }
91
92 if (strequal(hivename, "HKLM") ||
93 strequal(hivename, "HKEY_LOCAL_MACHINE"))
94 {
95 (*reg_type) = HKEY_LOCAL_MACHINE;
96 } else if (strequal(hivename, "HKCR") ||
97 strequal(hivename, "HKEY_CLASSES_ROOT"))
98 {
99 (*reg_type) = HKEY_CLASSES_ROOT;
100 } else if (strequal(hivename, "HKU") ||
101 strequal(hivename, "HKEY_USERS"))
102 {
103 (*reg_type) = HKEY_USERS;
104 } else if (strequal(hivename, "HKCU") ||
105 strequal(hivename, "HKEY_CURRENT_USER"))
106 {
107 (*reg_type) = HKEY_CURRENT_USER;
108 } else if (strequal(hivename, "HKPD") ||
109 strequal(hivename, "HKEY_PERFORMANCE_DATA"))
110 {
111 (*reg_type) = HKEY_PERFORMANCE_DATA;
112 } else {
113 DEBUG(10,("reg_hive_key: unrecognised hive key %s\n",
114 fullname));
115 goto done;
116 }
117
118 ret = true;
119
120 done:
121 TALLOC_FREE(tmp_ctx);
122 return ret;
123 }
124
125 static NTSTATUS registry_openkey(TALLOC_CTX *mem_ctx,
126 struct rpc_pipe_client *pipe_hnd,
127 const char *name, uint32 access_mask,
128 struct policy_handle *hive_hnd,
129 struct policy_handle *key_hnd)
130 {
131 uint32 hive;
132 NTSTATUS status;
133 struct winreg_String key;
134
135 ZERO_STRUCT(key);
136
137 if (!reg_hive_key(mem_ctx, name, &hive, &key.name)) {
138 return NT_STATUS_INVALID_PARAMETER;
139 }
140
141 status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive, access_mask,
142 hive_hnd, NULL);
143 if (!(NT_STATUS_IS_OK(status))) {
144 return status;
145 }
146
147 status = rpccli_winreg_OpenKey(pipe_hnd, mem_ctx, hive_hnd, key, 0,
148 access_mask, key_hnd, NULL);
149 if (!(NT_STATUS_IS_OK(status))) {
150 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, hive_hnd, NULL);
151 return status;
152 }
153
154 return NT_STATUS_OK;
155 }
156
157 static NTSTATUS registry_enumkeys(TALLOC_CTX *ctx,
158 struct rpc_pipe_client *pipe_hnd,
159 struct policy_handle *key_hnd,
160 uint32 *pnum_keys, char ***pnames,
161 char ***pclasses, NTTIME ***pmodtimes)
162 {
163 TALLOC_CTX *mem_ctx;
164 NTSTATUS status;
165 uint32 num_subkeys, max_subkeylen, max_classlen;
166 uint32 num_values, max_valnamelen, max_valbufsize;
167 uint32 i;
168 NTTIME last_changed_time;
169 uint32 secdescsize;
170 struct winreg_String classname;
171 char **names, **classes;
172 NTTIME **modtimes;
173
174 if (!(mem_ctx = talloc_new(ctx))) {
175 return NT_STATUS_NO_MEMORY;
176 }
177
178 ZERO_STRUCT(classname);
179 status = rpccli_winreg_QueryInfoKey(
180 pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
181 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
182 &max_valbufsize, &secdescsize, &last_changed_time, NULL );
183
184 if (!NT_STATUS_IS_OK(status)) {
185 goto error;
186 }
187
188 if (num_subkeys == 0) {
189 *pnum_keys = 0;
190 TALLOC_FREE(mem_ctx);
191 return NT_STATUS_OK;
192 }
193
194 if ((!(names = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_subkeys))) ||
195 (!(classes = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_subkeys))) ||
196 (!(modtimes = TALLOC_ZERO_ARRAY(mem_ctx, NTTIME *,
197 num_subkeys)))) {
198 status = NT_STATUS_NO_MEMORY;
199 goto error;
200 }
201
202 for (i=0; i<num_subkeys; i++) {
203 char c, n;
204 struct winreg_StringBuf class_buf;
205 struct winreg_StringBuf name_buf;
206 NTTIME modtime;
207 WERROR werr;
208
209 c = '\0';
210 class_buf.name = &c;
211 class_buf.size = max_classlen+2;
212
213 n = '\0';
214 name_buf.name = &n;
215 name_buf.size = max_subkeylen+2;
216
217 ZERO_STRUCT(modtime);
218
219 status = rpccli_winreg_EnumKey(pipe_hnd, mem_ctx, key_hnd,
220 i, &name_buf, &class_buf,
221 &modtime, &werr);
222
223 if (W_ERROR_EQUAL(werr,
224 WERR_NO_MORE_ITEMS) ) {
225 status = NT_STATUS_OK;
226 break;
227 }
228 if (!NT_STATUS_IS_OK(status)) {
229 goto error;
230 }
231
232 classes[i] = NULL;
233
234 if (class_buf.name &&
235 (!(classes[i] = talloc_strdup(classes, class_buf.name)))) {
236 status = NT_STATUS_NO_MEMORY;
237 goto error;
238 }
239
240 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
241 status = NT_STATUS_NO_MEMORY;
242 goto error;
243 }
244
245 if ((!(modtimes[i] = (NTTIME *)talloc_memdup(
246 modtimes, &modtime, sizeof(modtime))))) {
247 status = NT_STATUS_NO_MEMORY;
248 goto error;
249 }
250 }
251
252 *pnum_keys = num_subkeys;
253
254 if (pnames) {
255 *pnames = talloc_move(ctx, &names);
256 }
257 if (pclasses) {
258 *pclasses = talloc_move(ctx, &classes);
259 }
260 if (pmodtimes) {
261 *pmodtimes = talloc_move(ctx, &modtimes);
262 }
263
264 status = NT_STATUS_OK;
265
266 error:
267 TALLOC_FREE(mem_ctx);
268 return status;
269 }
270
271 static NTSTATUS registry_enumvalues(TALLOC_CTX *ctx,
272 struct rpc_pipe_client *pipe_hnd,
273 struct policy_handle *key_hnd,
274 uint32 *pnum_values, char ***pvalnames,
275 struct registry_value ***pvalues)
276 {
277 TALLOC_CTX *mem_ctx;
278 NTSTATUS status;
279 uint32 num_subkeys, max_subkeylen, max_classlen;
280 uint32 num_values, max_valnamelen, max_valbufsize;
281 uint32 i;
282 NTTIME last_changed_time;
283 uint32 secdescsize;
284 struct winreg_String classname;
285 struct registry_value **values;
286 char **names;
287
288 if (!(mem_ctx = talloc_new(ctx))) {
289 return NT_STATUS_NO_MEMORY;
290 }
291
292 ZERO_STRUCT(classname);
293 status = rpccli_winreg_QueryInfoKey(
294 pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
295 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
296 &max_valbufsize, &secdescsize, &last_changed_time, NULL );
297
298 if (!NT_STATUS_IS_OK(status)) {
299 goto error;
300 }
301
302 if (num_values == 0) {
303 *pnum_values = 0;
304 TALLOC_FREE(mem_ctx);
305 return NT_STATUS_OK;
306 }
307
308 if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
309 (!(values = TALLOC_ARRAY(mem_ctx, struct registry_value *,
310 num_values)))) {
311 status = NT_STATUS_NO_MEMORY;
312 goto error;
313 }
314
315 for (i=0; i<num_values; i++) {
316 enum winreg_Type type = REG_NONE;
317 uint8 *data = NULL;
318 uint32 data_size;
319 uint32 value_length;
320
321 char n;
322 struct winreg_ValNameBuf name_buf;
323 WERROR err;
324
325 n = '\0';
326 name_buf.name = &n;
327 name_buf.size = max_valnamelen + 2;
328
329 data_size = max_valbufsize;
330 data = (uint8 *)TALLOC(mem_ctx, data_size);
331 value_length = 0;
332
333 status = rpccli_winreg_EnumValue(pipe_hnd, mem_ctx, key_hnd,
334 i, &name_buf, &type,
335 data, &data_size,
336 &value_length, &err);
337
338 if ( W_ERROR_EQUAL(err,
339 WERR_NO_MORE_ITEMS) ) {
340 status = NT_STATUS_OK;
341 break;
342 }
343
344 if (!(NT_STATUS_IS_OK(status))) {
345 goto error;
346 }
347
348 if (name_buf.name == NULL) {
349 status = NT_STATUS_INVALID_PARAMETER;
350 goto error;
351 }
352
353 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
354 status = NT_STATUS_NO_MEMORY;
355 goto error;
356 }
357
358 values[i] = talloc_zero(values, struct registry_value);
359 if (values[i] == NULL) {
360 status = NT_STATUS_NO_MEMORY;
361 goto error;
362 }
363
364 values[i]->type = type;
365 values[i]->data = data_blob_talloc(values[i], data, data_size);
366 }
367
368 *pnum_values = num_values;
369
370 if (pvalnames) {
371 *pvalnames = talloc_move(ctx, &names);
372 }
373 if (pvalues) {
374 *pvalues = talloc_move(ctx, &values);
375 }
376
377 status = NT_STATUS_OK;
378
379 error:
380 TALLOC_FREE(mem_ctx);
381 return status;
382 }
383
384 static NTSTATUS registry_enumvalues2(TALLOC_CTX *ctx,
385 struct rpc_pipe_client *pipe_hnd,
386 struct policy_handle *key_hnd,
387 uint32 *pnum_values, char ***pvalnames,
388 struct regval_blob ***pvalues)
389 {
390 TALLOC_CTX *mem_ctx;
391 NTSTATUS status;
392 uint32 num_subkeys, max_subkeylen, max_classlen;
393 uint32 num_values, max_valnamelen, max_valbufsize;
394 uint32 i;
395 NTTIME last_changed_time;
396 uint32 secdescsize;
397 struct winreg_String classname;
398 struct regval_blob **values;
399 char **names;
400
401 if (!(mem_ctx = talloc_new(ctx))) {
402 return NT_STATUS_NO_MEMORY;
403 }
404
405 ZERO_STRUCT(classname);
406 status = rpccli_winreg_QueryInfoKey(
407 pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
408 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
409 &max_valbufsize, &secdescsize, &last_changed_time, NULL );
410
411 if (!NT_STATUS_IS_OK(status)) {
412 goto error;
413 }
414
415 if (num_values == 0) {
416 *pnum_values = 0;
417 TALLOC_FREE(mem_ctx);
418 return NT_STATUS_OK;
419 }
420
421 if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
422 (!(values = TALLOC_ARRAY(mem_ctx, struct regval_blob *,
423 num_values)))) {
424 status = NT_STATUS_NO_MEMORY;
425 goto error;
426 }
427
428 for (i=0; i<num_values; i++) {
429 enum winreg_Type type = REG_NONE;
430 uint8 *data = NULL;
431 uint32 data_size;
432 uint32 value_length;
433
434 char n;
435 struct winreg_ValNameBuf name_buf;
436 WERROR err;
437
438 n = '\0';
439 name_buf.name = &n;
440 name_buf.size = max_valnamelen + 2;
441
442 data_size = max_valbufsize;
443 data = (uint8 *)TALLOC(mem_ctx, data_size);
444 value_length = 0;
445
446 status = rpccli_winreg_EnumValue(pipe_hnd, mem_ctx, key_hnd,
447 i, &name_buf, &type,
448 data, &data_size,
449 &value_length, &err);
450
451 if ( W_ERROR_EQUAL(err, WERR_NO_MORE_ITEMS) ) {
452 status = NT_STATUS_OK;
453 break;
454 }
455
456 if (!(NT_STATUS_IS_OK(status))) {
457 goto error;
458 }
459
460 if (name_buf.name == NULL) {
461 status = NT_STATUS_INVALID_PARAMETER;
462 goto error;
463 }
464
465 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
466 status = NT_STATUS_NO_MEMORY;
467 goto error;
468 }
469
470 assert(value_length<=data_size); //???
471
472 values[i] = regval_compose(values,
473 name_buf.name,
474 type,
475 data, value_length);
476 if (!values[i]) {
477 status = NT_STATUS_NO_MEMORY;
478 goto error;
479 }
480 }
481
482 *pnum_values = num_values;
483
484 if (pvalnames) {
485 *pvalnames = talloc_move(ctx, &names);
486 }
487 if (pvalues) {
488 *pvalues = talloc_move(ctx, &values);
489 }
490
491 status = NT_STATUS_OK;
492
493 error:
494 TALLOC_FREE(mem_ctx);
495 return status;
496 }
497
498 static NTSTATUS registry_getsd(TALLOC_CTX *mem_ctx,
499 struct rpc_pipe_client *pipe_hnd,
500 struct policy_handle *key_hnd,
501 uint32_t sec_info,
502 struct KeySecurityData *sd)
503 {
504 return rpccli_winreg_GetKeySecurity(pipe_hnd, mem_ctx, key_hnd,
505 sec_info, sd, NULL);
506 }
507
508
509 static NTSTATUS registry_setvalue(TALLOC_CTX *mem_ctx,
510 struct rpc_pipe_client *pipe_hnd,
511 struct policy_handle *key_hnd,
512 const char *name,
513 const struct registry_value *value)
514 {
515 struct winreg_String name_string;
516 NTSTATUS result;
517
518 ZERO_STRUCT(name_string);
519
520 name_string.name = name;
521 result = rpccli_winreg_SetValue(pipe_hnd, mem_ctx, key_hnd,
522 name_string, value->type,
523 value->data.data, value->data.length, NULL);
524 return result;
525 }
526
527 static NTSTATUS rpc_registry_setvalue_internal(struct net_context *c,
528 const struct dom_sid *domain_sid,
529 const char *domain_name,
530 struct cli_state *cli,
531 struct rpc_pipe_client *pipe_hnd,
532 TALLOC_CTX *mem_ctx,
533 int argc,
534 const char **argv )
535 {
536 struct policy_handle hive_hnd, key_hnd;
537 NTSTATUS status;
538 struct registry_value value;
539
540 status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
541 SEC_FLAG_MAXIMUM_ALLOWED,
542 &hive_hnd, &key_hnd);
543 if (!NT_STATUS_IS_OK(status)) {
544 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
545 nt_errstr(status));
546 return status;
547 }
548
549 if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
550 d_fprintf(stderr, _("Too many args for type %s\n"), argv[2]);
551 return NT_STATUS_NOT_IMPLEMENTED;
552 }
553
554 if (strequal(argv[2], "dword")) {
555 uint32_t v = strtoul(argv[3], NULL, 10);
556 value.type = REG_DWORD;
557 value.data = data_blob_talloc(mem_ctx, NULL, 4);
558 SIVAL(value.data.data, 0, v);
559 }
560 else if (strequal(argv[2], "sz")) {
561 value.type = REG_SZ;
562 if (!push_reg_sz(mem_ctx, &value.data, argv[3])) {
563 status = NT_STATUS_NO_MEMORY;
564 goto error;
565 }
566 }
567 else {
568 d_fprintf(stderr, _("type \"%s\" not implemented\n"), argv[2]);
569 status = NT_STATUS_NOT_IMPLEMENTED;
570 goto error;
571 }
572
573 status = registry_setvalue(mem_ctx, pipe_hnd, &key_hnd,
574 argv[1], &value);
575
576 if (!NT_STATUS_IS_OK(status)) {
577 d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
578 nt_errstr(status));
579 }
580
581 error:
582 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
583 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
584
585 return NT_STATUS_OK;
586 }
587
588 static int rpc_registry_setvalue(struct net_context *c, int argc,
589 const char **argv )
590 {
591 if (argc < 4 || c->display_usage) {
592 d_fprintf(stderr, "%s\n%s",
593 _("Usage:"),
594 _("net rpc registry setvalue <key> <valuename> "
595 "<type> [<val>]+\n"));
596 return -1;
597 }
598
599 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
600 rpc_registry_setvalue_internal, argc, argv );
601 }
602
603 static NTSTATUS rpc_registry_deletevalue_internal(struct net_context *c,
604 const struct dom_sid *domain_sid,
605 const char *domain_name,
606 struct cli_state *cli,
607 struct rpc_pipe_client *pipe_hnd,
608 TALLOC_CTX *mem_ctx,
609 int argc,
610 const char **argv )
611 {
612 struct policy_handle hive_hnd, key_hnd;
613 NTSTATUS status;
614 struct winreg_String valuename;
615
616 ZERO_STRUCT(valuename);
617
618 status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
619 SEC_FLAG_MAXIMUM_ALLOWED,
620 &hive_hnd, &key_hnd);
621 if (!NT_STATUS_IS_OK(status)) {
622 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
623 nt_errstr(status));
624 return status;
625 }
626
627 valuename.name = argv[1];
628
629 status = rpccli_winreg_DeleteValue(pipe_hnd, mem_ctx, &key_hnd,
630 valuename, NULL);
631
632 if (!NT_STATUS_IS_OK(status)) {
633 d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
634 nt_errstr(status));
635 }
636
637 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
638 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
639
640 return status;
641 }
642
643 static int rpc_registry_deletevalue(struct net_context *c, int argc,
644 const char **argv )
645 {
646 if (argc != 2 || c->display_usage) {
647 d_fprintf(stderr, "%s\n%s",
648 _("Usage:"),
649 _("net rpc registry deletevalue <key> <valuename>\n"));
650 return -1;
651 }
652
653 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
654 rpc_registry_deletevalue_internal, argc, argv );
655 }
656
657 static NTSTATUS rpc_registry_getvalue_internal(struct net_context *c,
658 const struct dom_sid *domain_sid,
659 const char *domain_name,
660 struct cli_state *cli,
661 struct rpc_pipe_client *pipe_hnd,
662 TALLOC_CTX *mem_ctx,
663 bool raw,
664 int argc,
665 const char **argv)
666 {
667 struct policy_handle hive_hnd, key_hnd;
668 NTSTATUS status;
669 struct winreg_String valuename;
670 struct registry_value *value = NULL;
671 enum winreg_Type type = REG_NONE;
672 uint32_t data_size = 0;
673 uint32_t value_length = 0;
674 TALLOC_CTX *tmp_ctx = talloc_stackframe();
675
676 ZERO_STRUCT(valuename);
677
678 status = registry_openkey(tmp_ctx, pipe_hnd, argv[0],
679 SEC_FLAG_MAXIMUM_ALLOWED,
680 &hive_hnd, &key_hnd);
681 if (!NT_STATUS_IS_OK(status)) {
682 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
683 nt_errstr(status));
684 return status;
685 }
686
687 valuename.name = argv[1];
688
689 value = talloc_zero(tmp_ctx, struct registry_value);
690 if (value == NULL) {
691 return NT_STATUS_NO_MEMORY;
692 }
693
694 /*
695 * call QueryValue once with data == NULL to get the
696 * needed memory size to be allocated, then allocate
697 * data buffer and call again.
698 */
699 status = rpccli_winreg_QueryValue(pipe_hnd, tmp_ctx, &key_hnd,
700 &valuename,
701 &type,
702 NULL,
703 &data_size,
704 &value_length,
705 NULL);
706
707 if (!NT_STATUS_IS_OK(status)) {
708 d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
709 nt_errstr(status));
710 goto done;
711 }
712
713 value->data = data_blob_talloc(tmp_ctx, NULL, data_size);
714
715 status = rpccli_winreg_QueryValue(pipe_hnd, tmp_ctx, &key_hnd,
716 &valuename,
717 &type,
718 value->data.data,
719 &data_size,
720 &value_length,
721 NULL);
722
723 if (!NT_STATUS_IS_OK(status)) {
724 d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
725 nt_errstr(status));
726 goto done;
727 }
728
729 value->type = type;
730
731 print_registry_value(value, raw);
732
733 done:
734 rpccli_winreg_CloseKey(pipe_hnd, tmp_ctx, &key_hnd, NULL);
735 rpccli_winreg_CloseKey(pipe_hnd, tmp_ctx, &hive_hnd, NULL);
736
737 TALLOC_FREE(tmp_ctx);
738
739 return status;
740 }
741
742 static NTSTATUS rpc_registry_getvalue_full(struct net_context *c,
743 const struct dom_sid *domain_sid,
744 const char *domain_name,
745 struct cli_state *cli,
746 struct rpc_pipe_client *pipe_hnd,
747 TALLOC_CTX *mem_ctx,
748 int argc,
749 const char **argv)
750 {
751 return rpc_registry_getvalue_internal(c, domain_sid, domain_name,
752 cli, pipe_hnd, mem_ctx, false,
753 argc, argv);
754 }
755
756 static int rpc_registry_getvalue(struct net_context *c, int argc,
757 const char **argv)
758 {
759 if (argc != 2 || c->display_usage) {
760 d_fprintf(stderr, "%s\n%s",
761 _("Usage:"),
762 _("net rpc registry getvalue <key> <valuename>\n"));
763 return -1;
764 }
765
766 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
767 rpc_registry_getvalue_full, argc, argv);
768 }
769
770 static NTSTATUS rpc_registry_getvalue_raw(struct net_context *c,
771 const struct dom_sid *domain_sid,
772 const char *domain_name,
773 struct cli_state *cli,
774 struct rpc_pipe_client *pipe_hnd,
775 TALLOC_CTX *mem_ctx,
776 int argc,
777 const char **argv)
778 {
779 return rpc_registry_getvalue_internal(c, domain_sid, domain_name,
780 cli, pipe_hnd, mem_ctx, true,
781 argc, argv);
782 }
783
784 static int rpc_registry_getvalueraw(struct net_context *c, int argc,
785 const char **argv)
786 {
787 if (argc != 2 || c->display_usage) {
788 d_fprintf(stderr, "%s\n%s",
789 _("Usage:"),
790 _("net rpc registry getvalue <key> <valuename>\n"));
791 return -1;
792 }
793
794 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
795 rpc_registry_getvalue_raw, argc, argv);
796 }
797
798 static NTSTATUS rpc_registry_createkey_internal(struct net_context *c,
799 const struct dom_sid *domain_sid,
800 const char *domain_name,
801 struct cli_state *cli,
802 struct rpc_pipe_client *pipe_hnd,
803 TALLOC_CTX *mem_ctx,
804 int argc,
805 const char **argv )
806 {
807 uint32 hive;
808 struct policy_handle hive_hnd, key_hnd;
809 struct winreg_String key, keyclass;
810 enum winreg_CreateAction action;
811 NTSTATUS status;
812
813 ZERO_STRUCT(key);
814 ZERO_STRUCT(keyclass);
815
816 if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
817 return NT_STATUS_INVALID_PARAMETER;
818 }
819
820 status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
821 SEC_FLAG_MAXIMUM_ALLOWED,
822 &hive_hnd, NULL);
823 if (!(NT_STATUS_IS_OK(status))) {
824 return status;
825 }
826
827 action = REG_ACTION_NONE;
828 keyclass.name = "";
829
830 status = rpccli_winreg_CreateKey(pipe_hnd, mem_ctx, &hive_hnd, key,
831 keyclass, 0, REG_KEY_READ, NULL,
832 &key_hnd, &action, NULL);
833 if (!NT_STATUS_IS_OK(status)) {
834 d_fprintf(stderr, _("createkey returned %s\n"),
835 nt_errstr(status));
836 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
837 return status;
838 }
839
840 switch (action) {
841 case REG_ACTION_NONE:
842 d_printf(_("createkey did nothing -- huh?\n"));
843 break;
844 case REG_CREATED_NEW_KEY:
845 d_printf(_("createkey created %s\n"), argv[0]);
846 break;
847 case REG_OPENED_EXISTING_KEY:
848 d_printf(_("createkey opened existing %s\n"), argv[0]);
849 break;
850 }
851
852 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
853 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
854
855 return status;
856 }
857
858 static int rpc_registry_createkey(struct net_context *c, int argc,
859 const char **argv )
860 {
861 if (argc != 1 || c->display_usage) {
862 d_fprintf(stderr, "%s\n%s",
863 _("Usage:"),
864 _("net rpc registry createkey <key>\n"));
865 return -1;
866 }
867
868 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
869 rpc_registry_createkey_internal, argc, argv );
870 }
871
872 static NTSTATUS rpc_registry_deletekey_internal(struct net_context *c,
873 const struct dom_sid *domain_sid,
874 const char *domain_name,
875 struct cli_state *cli,
876 struct rpc_pipe_client *pipe_hnd,
877 TALLOC_CTX *mem_ctx,
878 int argc,
879 const char **argv )
880 {
881 uint32 hive;
882 struct policy_handle hive_hnd;
883 struct winreg_String key;
884 NTSTATUS status;
885
886 ZERO_STRUCT(key);
887
888 if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
889 return NT_STATUS_INVALID_PARAMETER;
890 }
891
892 status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
893 SEC_FLAG_MAXIMUM_ALLOWED,
894 &hive_hnd, NULL);
895 if (!(NT_STATUS_IS_OK(status))) {
896 return status;
897 }
898
899 status = rpccli_winreg_DeleteKey(pipe_hnd, mem_ctx, &hive_hnd, key, NULL);
900 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
901
902 if (!NT_STATUS_IS_OK(status)) {
903 d_fprintf(stderr, _("deletekey returned %s\n"),
904 nt_errstr(status));
905 }
906
907 return status;
908 }
909
910 static int rpc_registry_deletekey(struct net_context *c, int argc, const char **argv )
911 {
912 if (argc != 1 || c->display_usage) {
913 d_fprintf(stderr, "%s\n%s",
914 _("Usage:"),
915 _("net rpc registry deletekey <key>\n"));
916 return -1;
917 }
918
919 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
920 rpc_registry_deletekey_internal, argc, argv );
921 }
922
923 /********************************************************************
924 ********************************************************************/
925
926 static NTSTATUS rpc_registry_enumerate_internal(struct net_context *c,
927 const struct dom_sid *domain_sid,
928 const char *domain_name,
929 struct cli_state *cli,
930 struct rpc_pipe_client *pipe_hnd,
931 TALLOC_CTX *mem_ctx,
932 int argc,
933 const char **argv )
934 {
935 struct policy_handle pol_hive, pol_key;
936 NTSTATUS status;
937 uint32 num_subkeys = 0;
938 uint32 num_values = 0;
939 char **names = NULL, **classes = NULL;
940 NTTIME **modtimes = NULL;
941 uint32 i;
942 struct registry_value **values = NULL;
943
944 if (argc != 1 || c->display_usage) {
945 d_printf("%s\n%s",
946 _("Usage:"),
947 _("net rpc registry enumerate <path>\n"));
948 d_printf("%s net rpc registry enumerate "
949 "'HKLM\\Software\\Samba'\n", _("Example:"));
950 return NT_STATUS_INVALID_PARAMETER;
951 }
952
953 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
954 &pol_hive, &pol_key);
955 if (!NT_STATUS_IS_OK(status)) {
956 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
957 nt_errstr(status));
958 return status;
959 }
960
961 status = registry_enumkeys(mem_ctx, pipe_hnd, &pol_key, &num_subkeys,
962 &names, &classes, &modtimes);
963 if (!NT_STATUS_IS_OK(status)) {
964 d_fprintf(stderr, _("enumerating keys failed: %s\n"),
965 nt_errstr(status));
966 return status;
967 }
968
969 for (i=0; i<num_subkeys; i++) {
970 print_registry_key(names[i], modtimes[i]);
971 }
972
973 status = registry_enumvalues(mem_ctx, pipe_hnd, &pol_key, &num_values,
974 &names, &values);
975 if (!NT_STATUS_IS_OK(status)) {
976 d_fprintf(stderr, _("enumerating values failed: %s\n"),
977 nt_errstr(status));
978 return status;
979 }
980
981 for (i=0; i<num_values; i++) {
982 print_registry_value_with_name(names[i], values[i]);
983 }
984
985 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
986 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
987
988 return status;
989 }
990
991 /********************************************************************
992 ********************************************************************/
993
994 static int rpc_registry_enumerate(struct net_context *c, int argc,
995 const char **argv )
996 {
997 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
998 rpc_registry_enumerate_internal, argc, argv );
999 }
1000
1001 /********************************************************************
1002 ********************************************************************/
1003
1004 static NTSTATUS rpc_registry_save_internal(struct net_context *c,
1005 const struct dom_sid *domain_sid,
1006 const char *domain_name,
1007 struct cli_state *cli,
1008 struct rpc_pipe_client *pipe_hnd,
1009 TALLOC_CTX *mem_ctx,
1010 int argc,
1011 const char **argv )
1012 {
1013 WERROR result = WERR_GENERAL_FAILURE;
1014 struct policy_handle pol_hive, pol_key;
1015 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
1016 struct winreg_String filename;
1017
1018 if (argc != 2 || c->display_usage) {
1019 d_printf("%s\n%s",
1020 _("Usage:"),
1021 _("net rpc registry backup <path> <file> \n"));
1022 return NT_STATUS_INVALID_PARAMETER;
1023 }
1024
1025 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_ALL,
1026 &pol_hive, &pol_key);
1027 if (!NT_STATUS_IS_OK(status)) {
1028 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
1029 nt_errstr(status));
1030 return status;
1031 }
1032
1033 filename.name = argv[1];
1034 status = rpccli_winreg_SaveKey( pipe_hnd, mem_ctx, &pol_key, &filename, NULL, NULL);
1035 if ( !W_ERROR_IS_OK(result) ) {
1036 d_fprintf(stderr, _("Unable to save [%s] to %s:%s\n"), argv[0],
1037 cli->desthost, argv[1]);
1038 }
1039
1040 /* cleanup */
1041
1042 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
1043 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
1044
1045 return status;
1046 }
1047
1048 /********************************************************************
1049 ********************************************************************/
1050
1051 static int rpc_registry_save(struct net_context *c, int argc, const char **argv )
1052 {
1053 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1054 rpc_registry_save_internal, argc, argv );
1055 }
1056
1057
1058 /********************************************************************
1059 ********************************************************************/
1060
1061 static void dump_values( REGF_NK_REC *nk )
1062 {
1063 int i, j;
1064 const char *data_str = NULL;
1065 uint32 data_size, data;
1066 DATA_BLOB blob;
1067
1068 if ( !nk->values )
1069 return;
1070
1071 for ( i=0; i<nk->num_values; i++ ) {
1072 d_printf( "\"%s\" = ", nk->values[i].valuename ? nk->values[i].valuename : "(default)" );
1073 d_printf( "(%s) ", str_regtype( nk->values[i].type ) );
1074
1075 data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
1076 switch ( nk->values[i].type ) {
1077 case REG_SZ:
1078 blob = data_blob_const(nk->values[i].data, data_size);
1079 pull_reg_sz(talloc_tos(), &blob, &data_str);
1080 if (!data_str) {
1081 break;
1082 }
1083 d_printf( "%s", data_str );
1084 break;
1085 case REG_MULTI_SZ:
1086 case REG_EXPAND_SZ:
1087 for ( j=0; j<data_size; j++ ) {
1088 d_printf( "%c", nk->values[i].data[j] );
1089 }
1090 break;
1091 case REG_DWORD:
1092 data = IVAL( nk->values[i].data, 0 );
1093 d_printf("0x%x", data );
1094 break;
1095 case REG_BINARY:
1096 for ( j=0; j<data_size; j++ ) {
1097 d_printf( "%x", nk->values[i].data[j] );
1098 }
1099 break;
1100 default:
1101 d_printf(_("unknown"));
1102 break;
1103 }
1104
1105 d_printf( "\n" );
1106 }
1107
1108 }
1109
1110 /********************************************************************
1111 ********************************************************************/
1112
1113 static bool dump_registry_tree( REGF_FILE *file, REGF_NK_REC *nk, const char *parent )
1114 {
1115 REGF_NK_REC *key;
1116
1117 /* depth first dump of the registry tree */
1118
1119 while ( (key = regfio_fetch_subkey( file, nk )) ) {
1120 char *regpath;
1121 if (asprintf(&regpath, "%s\\%s", parent, key->keyname) < 0) {
1122 break;
1123 }
1124 d_printf("[%s]\n", regpath );
1125 dump_values( key );
1126 d_printf("\n");
1127 dump_registry_tree( file, key, regpath );
1128 SAFE_FREE(regpath);
1129 }
1130
1131 return true;
1132 }
1133
1134 /********************************************************************
1135 ********************************************************************/
1136
1137 static bool write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
1138 REGF_NK_REC *parent, REGF_FILE *outfile,
1139 const char *parentpath )
1140 {
1141 REGF_NK_REC *key, *subkey;
1142 struct regval_ctr *values = NULL;
1143 struct regsubkey_ctr *subkeys = NULL;
1144 int i;
1145 char *path = NULL;
1146 WERROR werr;
1147
1148 werr = regsubkey_ctr_init(infile->mem_ctx, &subkeys);
1149 if (!W_ERROR_IS_OK(werr)) {
1150 DEBUG(0, ("write_registry_tree: regsubkey_ctr_init failed: "
1151 "%s\n", win_errstr(werr)));
1152 return false;
1153 }
1154
1155 werr = regval_ctr_init(subkeys, &values);
1156 if (!W_ERROR_IS_OK(werr)) {
1157 DEBUG(0,("write_registry_tree: talloc() failed!\n"));
1158 TALLOC_FREE(subkeys);
1159 return false;
1160 }
1161
1162 /* copy values into the struct regval_ctr */
1163
1164 for ( i=0; i<nk->num_values; i++ ) {
1165 regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
1166 nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
1167 }
1168
1169 /* copy subkeys into the struct regsubkey_ctr */
1170
1171 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
1172 regsubkey_ctr_addkey( subkeys, subkey->keyname );
1173 }
1174
1175 key = regfio_write_key( outfile, nk->keyname, values, subkeys, nk->sec_desc->sec_desc, parent );
1176
1177 /* write each one of the subkeys out */
1178
1179 path = talloc_asprintf(subkeys,
1180 "%s%s%s",
1181 parentpath,
1182 parent ? "\\" : "",
1183 nk->keyname);
1184 if (!path) {
1185 TALLOC_FREE(subkeys);
1186 return false;
1187 }
1188
1189 nk->subkey_index = 0;
1190 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
1191 write_registry_tree( infile, subkey, key, outfile, path );
1192 }
1193
1194 d_printf("[%s]\n", path );
1195 TALLOC_FREE(subkeys);
1196
1197 return true;
1198 }
1199
1200 /********************************************************************
1201 ********************************************************************/
1202
1203 static int rpc_registry_dump(struct net_context *c, int argc, const char **argv)
1204 {
1205 REGF_FILE *registry;
1206 REGF_NK_REC *nk;
1207
1208 if (argc != 1 || c->display_usage) {
1209 d_printf("%s\n%s",
1210 _("Usage:"),
1211 _("net rpc registry dump <file> \n"));
1212 return -1;
1213 }
1214
1215 d_printf(_("Opening %s...."), argv[0]);
1216 if ( !(registry = regfio_open( argv[0], O_RDONLY, 0)) ) {
1217 d_fprintf(stderr, _("Failed to open %s for reading\n"),argv[0]);
1218 return 1;
1219 }
1220 d_printf(_("ok\n"));
1221
1222 /* get the root of the registry file */
1223
1224 if ((nk = regfio_rootkey( registry )) == NULL) {
1225 d_fprintf(stderr, _("Could not get rootkey\n"));
1226 regfio_close( registry );
1227 return 1;
1228 }
1229 d_printf("[%s]\n", nk->keyname);
1230 dump_values( nk );
1231 d_printf("\n");
1232
1233 dump_registry_tree( registry, nk, nk->keyname );
1234
1235 #if 0
1236 talloc_report_full( registry->mem_ctx, stderr );
1237 #endif
1238 d_printf(_("Closing registry..."));
1239 regfio_close( registry );
1240 d_printf(_("ok\n"));
1241
1242 return 0;
1243 }
1244
1245 /********************************************************************
1246 ********************************************************************/
1247
1248 static int rpc_registry_copy(struct net_context *c, int argc, const char **argv )
1249 {
1250 REGF_FILE *infile = NULL, *outfile = NULL;
1251 REGF_NK_REC *nk;
1252 int result = 1;
1253
1254 if (argc != 2 || c->display_usage) {
1255 d_printf("%s\n%s",
1256 _("Usage:"),
1257 _("net rpc registry copy <srcfile> <newfile>\n"));
1258 return -1;
1259 }
1260
1261 d_printf(_("Opening %s...."), argv[0]);
1262 if ( !(infile = regfio_open( argv[0], O_RDONLY, 0 )) ) {
1263 d_fprintf(stderr, _("Failed to open %s for reading\n"),argv[0]);
1264 return 1;
1265 }
1266 d_printf(_("ok\n"));
1267
1268 d_printf(_("Opening %s...."), argv[1]);
1269 if ( !(outfile = regfio_open( argv[1], (O_RDWR|O_CREAT|O_TRUNC), (S_IREAD|S_IWRITE) )) ) {
1270 d_fprintf(stderr, _("Failed to open %s for writing\n"),argv[1]);
1271 goto out;
1272 }
1273 d_printf(_("ok\n"));
1274
1275 /* get the root of the registry file */
1276
1277 if ((nk = regfio_rootkey( infile )) == NULL) {
1278 d_fprintf(stderr, _("Could not get rootkey\n"));
1279 goto out;
1280 }
1281 d_printf(_("RootKey: [%s]\n"), nk->keyname);
1282
1283 write_registry_tree( infile, nk, NULL, outfile, "" );
1284
1285 result = 0;
1286
1287 out:
1288
1289 d_printf(_("Closing %s..."), argv[1]);
1290 if (outfile) {
1291 regfio_close( outfile );
1292 }
1293 d_printf(_("ok\n"));
1294
1295 d_printf(_("Closing %s..."), argv[0]);
1296 if (infile) {
1297 regfio_close( infile );
1298 }
1299 d_printf(_("ok\n"));
1300
1301 return( result);
1302 }
1303
1304 /********************************************************************
1305 ********************************************************************/
1306
1307 static NTSTATUS rpc_registry_getsd_internal(struct net_context *c,
1308 const struct dom_sid *domain_sid,
1309 const char *domain_name,
1310 struct cli_state *cli,
1311 struct rpc_pipe_client *pipe_hnd,
1312 TALLOC_CTX *mem_ctx,
1313 int argc,
1314 const char **argv)
1315 {
1316 struct policy_handle pol_hive, pol_key;
1317 NTSTATUS status;
1318 enum ndr_err_code ndr_err;
1319 struct KeySecurityData *sd = NULL;
1320 uint32_t sec_info;
1321 DATA_BLOB blob;
1322 struct security_descriptor sec_desc;
1323 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED |
1324 SEC_FLAG_SYSTEM_SECURITY;
1325
1326 if (argc <1 || argc > 2 || c->display_usage) {
1327 d_printf("%s\n%s",
1328 _("Usage:"),
1329 _("net rpc registry getsd <path> <secinfo>\n"));
1330 d_printf("%s net rpc registry getsd "
1331 "'HKLM\\Software\\Samba'\n", _("Example:"));
1332 return NT_STATUS_INVALID_PARAMETER;
1333 }
1334
1335 status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
1336 access_mask,
1337 &pol_hive, &pol_key);
1338 if (!NT_STATUS_IS_OK(status)) {
1339 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
1340 nt_errstr(status));
1341 return status;
1342 }
1343
1344 sd = TALLOC_ZERO_P(mem_ctx, struct KeySecurityData);
1345 if (!sd) {
1346 status = NT_STATUS_NO_MEMORY;
1347 goto out;
1348 }
1349
1350 sd->size = 0x1000;
1351
1352 if (argc >= 2) {
1353 sscanf(argv[1], "%x", &sec_info);
1354 } else {
1355 sec_info = SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL;
1356 }
1357
1358 status = registry_getsd(mem_ctx, pipe_hnd, &pol_key, sec_info, sd);
1359 if (!NT_STATUS_IS_OK(status)) {
1360 d_fprintf(stderr, _("getting sd failed: %s\n"),
1361 nt_errstr(status));
1362 goto out;
1363 }
1364
1365 blob.data = sd->data;
1366 blob.length = sd->size;
1367
1368 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &sec_desc,
1369 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
1370 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1371 status = ndr_map_error2ntstatus(ndr_err);
1372 goto out;
1373 }
1374 status = NT_STATUS_OK;
1375
1376 display_sec_desc(&sec_desc);
1377
1378 out:
1379 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
1380 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
1381
1382 return status;
1383 }
1384
1385
1386 static int rpc_registry_getsd(struct net_context *c, int argc, const char **argv)
1387 {
1388 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1389 rpc_registry_getsd_internal, argc, argv);
1390 }
1391
1392 /********************************************************************
1393 ********************************************************************/
1394 /**
1395 * @defgroup net_rpc_registry net rpc registry
1396 */
1397
1398 /**
1399 * @defgroup net_rpc_registry_export Export
1400 * @ingroup net_rpc_registry
1401 * @{
1402 */
1403
1404 static NTSTATUS registry_export(struct rpc_pipe_client* pipe_hnd,
1405 TALLOC_CTX* ctx,
1406 struct policy_handle* key_hnd,
1407 struct reg_format* f,
1408 const char* parentfullname,
1409 const char* name)
1410 {
1411 NTSTATUS status;
1412 uint32 num_subkeys = 0;
1413 uint32 num_values = 0;
1414 char **names = NULL, **classes = NULL;
1415 NTTIME **modtimes = NULL;
1416 struct regval_blob **values = NULL;
1417 uint32 i;
1418
1419 TALLOC_CTX* mem_ctx = talloc_new(ctx);
1420
1421
1422 const char* fullname = name
1423 ? talloc_asprintf(mem_ctx, "%s\\%s", parentfullname, name)
1424 : parentfullname;
1425 reg_format_key(f, &fullname, 1, false);
1426
1427 status = registry_enumvalues2(mem_ctx, pipe_hnd, key_hnd, &num_values,
1428 &names, &values);
1429 if (!NT_STATUS_IS_OK(status)) {
1430 d_fprintf(stderr, _("enumerating values failed: %s\n"),
1431 nt_errstr(status));
1432 goto done;
1433 }
1434
1435 for (i=0; i<num_values; i++) {
1436 reg_format_regval_blob(f, names[i], values[i]);
1437 }
1438
1439
1440 status = registry_enumkeys(mem_ctx, pipe_hnd, key_hnd, &num_subkeys,
1441 &names, &classes, &modtimes);
1442 if (!NT_STATUS_IS_OK(status)) {
1443 d_fprintf(stderr, _("enumerating keys failed: %s\n"),
1444 nt_errstr(status));
1445 goto done;
1446 }
1447
1448 for (i=0; i<num_subkeys; i++) {
1449 struct policy_handle subkey_hnd;
1450 struct winreg_String key;
1451 ZERO_STRUCT(key);
1452 /* key.name = talloc_strdup(mem_ctx, names[i]); ??? */
1453 key.name = names[i];
1454
1455 status = rpccli_winreg_OpenKey(pipe_hnd, mem_ctx, key_hnd, key,
1456 0, REG_KEY_READ,
1457 &subkey_hnd, NULL);
1458 if (NT_STATUS_IS_OK(status)) {
1459 status = registry_export(pipe_hnd, mem_ctx, &subkey_hnd,
1460 f, fullname, names[i]);
1461 if (!(NT_STATUS_IS_OK(status)))
1462 d_fprintf(stderr,
1463 _("export key failed: %s %s\n"),
1464 names[i], nt_errstr(status));
1465
1466 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx,
1467 &subkey_hnd, NULL);
1468 } else {
1469 d_fprintf(stderr,
1470 _("rpccli_winreg_OpenKey failed: %s %s\n"),
1471 names[i], nt_errstr(status));
1472 }
1473 }
1474 done:
1475 talloc_free(mem_ctx);
1476 return status;
1477 }
1478
1479 static NTSTATUS rpc_registry_export_internal(struct net_context *c,
1480 const struct dom_sid *domain_sid,
1481 const char *domain_name,
1482 struct cli_state *cli,
1483 struct rpc_pipe_client *pipe_hnd,
1484 TALLOC_CTX *mem_ctx,
1485 int argc,
1486 const char **argv )
1487 {
1488 struct policy_handle pol_hive, pol_key;
1489 NTSTATUS status;
1490 struct reg_format* f;
1491
1492 if (argc < 2 || argc > 3 || c->display_usage) {
1493 d_printf("%s\n%s",
1494 _("Usage:"),
1495 _("net rpc registry export <path> <file> [opt]\n"));
1496 d_printf("%s net rpc registry export "
1497 "'HKLM\\Software\\Samba' samba.reg\n", _("Example:"));
1498 return NT_STATUS_INVALID_PARAMETER;
1499 }
1500
1501 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
1502 &pol_hive, &pol_key);
1503 if (!NT_STATUS_IS_OK(status)) {
1504 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
1505 nt_errstr(status));
1506 return status;
1507 }
1508
1509 f = reg_format_file(mem_ctx, argv[1], (argc > 2) ? argv[2] : NULL);
1510 if (f == NULL) {
1511 d_fprintf(stderr, _("open file failed: %s\n"), strerror(errno));
1512 return map_nt_error_from_unix(errno);
1513 }
1514
1515 status = registry_export(pipe_hnd, mem_ctx, &pol_key,
1516 f, argv[0], NULL );
1517 if (!NT_STATUS_IS_OK(status))
1518 return status;
1519
1520 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
1521 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
1522
1523 return status;
1524 }
1525 /********************************************************************
1526 ********************************************************************/
1527
1528 static int rpc_registry_export(struct net_context *c, int argc,
1529 const char **argv )
1530 {
1531 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1532 rpc_registry_export_internal, argc, argv );
1533 }
1534
1535 /**@}*/
1536
1537
1538 int net_rpc_registry(struct net_context *c, int argc, const char **argv)
1539 {
1540 struct functable func[] = {
1541 {
1542 "enumerate",
1543 rpc_registry_enumerate,
1544 NET_TRANSPORT_RPC,
1545 N_("Enumerate registry keys and values"),
1546 N_("net rpc registry enumerate\n"
1547 " Enumerate registry keys and values")
1548 },
1549 {
1550 "createkey",
1551 rpc_registry_createkey,
1552 NET_TRANSPORT_RPC,
1553 N_("Create a new registry key"),
1554 N_("net rpc registry createkey\n"
1555 " Create a new registry key")
1556 },
1557 {
1558 "deletekey",
1559 rpc_registry_deletekey,
1560 NET_TRANSPORT_RPC,
1561 N_("Delete a registry key"),
1562 N_("net rpc registry deletekey\n"
1563 " Delete a registry key")
1564 },
1565 {
1566 "getvalue",
1567 rpc_registry_getvalue,
1568 NET_TRANSPORT_RPC,
1569 N_("Print a registry value"),
1570 N_("net rpc registry getvalue\n"
1571 " Print a registry value")
1572 },
1573 {
1574 "getvalueraw",
1575 rpc_registry_getvalueraw,
1576 NET_TRANSPORT_RPC,
1577 N_("Print a registry value"),
1578 N_("net rpc registry getvalueraw\n"
1579 " Print a registry value (raw version)")
1580 },
1581 {
1582 "setvalue",
1583 rpc_registry_setvalue,
1584 NET_TRANSPORT_RPC,
1585 N_("Set a new registry value"),
1586 N_("net rpc registry setvalue\n"
1587 " Set a new registry value")
1588 },
1589 {
1590 "deletevalue",
1591 rpc_registry_deletevalue,
1592 NET_TRANSPORT_RPC,
1593 N_("Delete a registry value"),
1594 N_("net rpc registry deletevalue\n"
1595 " Delete a registry value")
1596 },
1597 {
1598 "save",
1599 rpc_registry_save,
1600 NET_TRANSPORT_RPC,
1601 N_("Save a registry file"),
1602 N_("net rpc registry save\n"
1603 " Save a registry file")
1604 },
1605 {
1606 "dump",
1607 rpc_registry_dump,
1608 NET_TRANSPORT_RPC,
1609 N_("Dump a registry file"),
1610 N_("net rpc registry dump\n"
1611 " Dump a registry file")
1612 },
1613 {
1614 "copy",
1615 rpc_registry_copy,
1616 NET_TRANSPORT_RPC,
1617 N_("Copy a registry file"),
1618 N_("net rpc registry copy\n"
1619 " Copy a registry file")
1620 },
1621 {
1622 "getsd",
1623 rpc_registry_getsd,
1624 NET_TRANSPORT_RPC,
1625 N_("Get security descriptor"),
1626 N_("net rpc registry getsd\n"
1627 " Get security descriptior")
1628 },
1629 {
1630 "export",
1631 rpc_registry_export,
1632 NET_TRANSPORT_RPC,
1633 N_("net registry export\n"
1634 " Export .reg file")
1635 },
1636 {NULL, NULL, 0, NULL, NULL}
1637 };
1638 return net_run_function(c, argc, argv, "net rpc registry", func);
1639 }
Samba GIT mirror