?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-smbclient: Fix cli_errstr() usage (part of bug #7864)
[Samba/gebeck_regimport.git] / source3 / utils / net_rpc_registry.c
blob32c202357bbd9b5d88a05b10907e091c9891fb58
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/ndr_winreg_c.h"
27 #include "registry/reg_objects.h"
28 #include "../librpc/gen_ndr/ndr_security.h"
29 #include "registry/reg_format.h"
30 #include "registry/reg_import.h"
31 #include <assert.h>
32
33
34 /*******************************************************************
35 connect to a registry hive root (open a registry policy)
36 *******************************************************************/
37
38 static NTSTATUS dcerpc_winreg_Connect(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
39 uint32_t reg_type, uint32_t access_mask,
40 struct policy_handle *reg_hnd, WERROR *werr)
41 {
42 ZERO_STRUCTP(reg_hnd);
43
44 switch (reg_type)
45 {
46 case HKEY_CLASSES_ROOT:
47 return dcerpc_winreg_OpenHKCR(b, mem_ctx, NULL,
48 access_mask, reg_hnd, werr);
49
50 case HKEY_LOCAL_MACHINE:
51 return dcerpc_winreg_OpenHKLM(b, mem_ctx, NULL,
52 access_mask, reg_hnd, werr);
53
54 case HKEY_USERS:
55 return dcerpc_winreg_OpenHKU(b, mem_ctx, NULL,
56 access_mask, reg_hnd, werr);
57
58 case HKEY_CURRENT_USER:
59 return dcerpc_winreg_OpenHKCU(b, mem_ctx, NULL,
60 access_mask, reg_hnd, werr);
61
62 case HKEY_PERFORMANCE_DATA:
63 return dcerpc_winreg_OpenHKPD(b, mem_ctx, NULL,
64 access_mask, reg_hnd, werr);
65
66 default:
67 /* fall through to end of function */
68 break;
69 }
70
71 return NT_STATUS_INVALID_PARAMETER;
72 }
73
74 static bool reg_hive_key(TALLOC_CTX *ctx, const char *fullname,
75 uint32 *reg_type, const char **key_name)
76 {
77 WERROR werr;
78 char *hivename = NULL;
79 char *tmp_keyname = NULL;
80 bool ret = false;
81 TALLOC_CTX *tmp_ctx = talloc_stackframe();
82
83 werr = split_hive_key(tmp_ctx, fullname, &hivename, &tmp_keyname);
84 if (!W_ERROR_IS_OK(werr)) {
85 goto done;
86 }
87
88 *key_name = talloc_strdup(ctx, tmp_keyname);
89 if (*key_name == NULL) {
90 goto done;
91 }
92
93 if (strequal(hivename, "HKLM") ||
94 strequal(hivename, "HKEY_LOCAL_MACHINE"))
95 {
96 (*reg_type) = HKEY_LOCAL_MACHINE;
97 } else if (strequal(hivename, "HKCR") ||
98 strequal(hivename, "HKEY_CLASSES_ROOT"))
99 {
100 (*reg_type) = HKEY_CLASSES_ROOT;
101 } else if (strequal(hivename, "HKU") ||
102 strequal(hivename, "HKEY_USERS"))
103 {
104 (*reg_type) = HKEY_USERS;
105 } else if (strequal(hivename, "HKCU") ||
106 strequal(hivename, "HKEY_CURRENT_USER"))
107 {
108 (*reg_type) = HKEY_CURRENT_USER;
109 } else if (strequal(hivename, "HKPD") ||
110 strequal(hivename, "HKEY_PERFORMANCE_DATA"))
111 {
112 (*reg_type) = HKEY_PERFORMANCE_DATA;
113 } else {
114 DEBUG(10,("reg_hive_key: unrecognised hive key %s\n",
115 fullname));
116 goto done;
117 }
118
119 ret = true;
120
121 done:
122 TALLOC_FREE(tmp_ctx);
123 return ret;
124 }
125
126 static NTSTATUS registry_openkey(TALLOC_CTX *mem_ctx,
127 struct rpc_pipe_client *pipe_hnd,
128 const char *name, uint32 access_mask,
129 struct policy_handle *hive_hnd,
130 struct policy_handle *key_hnd)
131 {
132 uint32 hive;
133 NTSTATUS status;
134 WERROR werr;
135 struct winreg_String key;
136 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
137
138 ZERO_STRUCT(key);
139
140 if (!reg_hive_key(mem_ctx, name, &hive, &key.name)) {
141 return NT_STATUS_INVALID_PARAMETER;
142 }
143
144 status = dcerpc_winreg_Connect(b, mem_ctx, hive, access_mask,
145 hive_hnd, &werr);
146 if (!(NT_STATUS_IS_OK(status))) {
147 return status;
148 }
149 if (!W_ERROR_IS_OK(werr)) {
150 return werror_to_ntstatus(werr);
151 }
152
153 status = dcerpc_winreg_OpenKey(b, mem_ctx, hive_hnd, key, 0,
154 access_mask, key_hnd, &werr);
155 if (!(NT_STATUS_IS_OK(status))) {
156 dcerpc_winreg_CloseKey(b, mem_ctx, hive_hnd, &werr);
157 return status;
158 }
159 if (!(W_ERROR_IS_OK(werr))) {
160 WERROR _werr;
161 dcerpc_winreg_CloseKey(b, mem_ctx, hive_hnd, &_werr);
162 return werror_to_ntstatus(werr);
163 }
164
165 return NT_STATUS_OK;
166 }
167
168 static NTSTATUS registry_enumkeys(TALLOC_CTX *ctx,
169 struct rpc_pipe_client *pipe_hnd,
170 struct policy_handle *key_hnd,
171 uint32 *pnum_keys, char ***pnames,
172 char ***pclasses, NTTIME ***pmodtimes)
173 {
174 TALLOC_CTX *mem_ctx;
175 NTSTATUS status;
176 WERROR werr;
177 uint32 num_subkeys, max_subkeylen, max_classlen;
178 uint32 num_values, max_valnamelen, max_valbufsize;
179 uint32 i;
180 NTTIME last_changed_time;
181 uint32 secdescsize;
182 struct winreg_String classname;
183 char **names, **classes;
184 NTTIME **modtimes;
185 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
186
187 if (!(mem_ctx = talloc_new(ctx))) {
188 return NT_STATUS_NO_MEMORY;
189 }
190
191 ZERO_STRUCT(classname);
192 status = dcerpc_winreg_QueryInfoKey(
193 b, mem_ctx, key_hnd, &classname, &num_subkeys,
194 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
195 &max_valbufsize, &secdescsize, &last_changed_time, &werr);
196
197 if (!NT_STATUS_IS_OK(status)) {
198 goto error;
199 }
200 if (!W_ERROR_IS_OK(werr)) {
201 status = werror_to_ntstatus(werr);
202 goto error;
203 }
204
205 if (num_subkeys == 0) {
206 *pnum_keys = 0;
207 TALLOC_FREE(mem_ctx);
208 return NT_STATUS_OK;
209 }
210
211 if ((!(names = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_subkeys))) ||
212 (!(classes = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_subkeys))) ||
213 (!(modtimes = TALLOC_ZERO_ARRAY(mem_ctx, NTTIME *,
214 num_subkeys)))) {
215 status = NT_STATUS_NO_MEMORY;
216 goto error;
217 }
218
219 for (i=0; i<num_subkeys; i++) {
220 char c, n;
221 struct winreg_StringBuf class_buf;
222 struct winreg_StringBuf name_buf;
223 NTTIME modtime;
224
225 c = '\0';
226 class_buf.name = &c;
227 class_buf.size = max_classlen+2;
228
229 n = '\0';
230 name_buf.name = &n;
231 name_buf.size = max_subkeylen+2;
232
233 ZERO_STRUCT(modtime);
234
235 status = dcerpc_winreg_EnumKey(b, mem_ctx, key_hnd,
236 i, &name_buf, &class_buf,
237 &modtime, &werr);
238 if (!NT_STATUS_IS_OK(status)) {
239 goto error;
240 }
241 if (W_ERROR_EQUAL(werr,
242 WERR_NO_MORE_ITEMS) ) {
243 status = NT_STATUS_OK;
244 break;
245 }
246 if (!W_ERROR_IS_OK(werr)) {
247 status = werror_to_ntstatus(werr);
248 goto error;
249 }
250
251 classes[i] = NULL;
252
253 if (class_buf.name &&
254 (!(classes[i] = talloc_strdup(classes, class_buf.name)))) {
255 status = NT_STATUS_NO_MEMORY;
256 goto error;
257 }
258
259 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
260 status = NT_STATUS_NO_MEMORY;
261 goto error;
262 }
263
264 if ((!(modtimes[i] = (NTTIME *)talloc_memdup(
265 modtimes, &modtime, sizeof(modtime))))) {
266 status = NT_STATUS_NO_MEMORY;
267 goto error;
268 }
269 }
270
271 *pnum_keys = num_subkeys;
272
273 if (pnames) {
274 *pnames = talloc_move(ctx, &names);
275 }
276 if (pclasses) {
277 *pclasses = talloc_move(ctx, &classes);
278 }
279 if (pmodtimes) {
280 *pmodtimes = talloc_move(ctx, &modtimes);
281 }
282
283 status = NT_STATUS_OK;
284
285 error:
286 TALLOC_FREE(mem_ctx);
287 return status;
288 }
289
290 static NTSTATUS registry_enumvalues(TALLOC_CTX *ctx,
291 struct rpc_pipe_client *pipe_hnd,
292 struct policy_handle *key_hnd,
293 uint32 *pnum_values, char ***pvalnames,
294 struct registry_value ***pvalues)
295 {
296 TALLOC_CTX *mem_ctx;
297 NTSTATUS status;
298 WERROR werr;
299 uint32 num_subkeys, max_subkeylen, max_classlen;
300 uint32 num_values, max_valnamelen, max_valbufsize;
301 uint32 i;
302 NTTIME last_changed_time;
303 uint32 secdescsize;
304 struct winreg_String classname;
305 struct registry_value **values;
306 char **names;
307 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
308
309 if (!(mem_ctx = talloc_new(ctx))) {
310 return NT_STATUS_NO_MEMORY;
311 }
312
313 ZERO_STRUCT(classname);
314 status = dcerpc_winreg_QueryInfoKey(
315 b, mem_ctx, key_hnd, &classname, &num_subkeys,
316 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
317 &max_valbufsize, &secdescsize, &last_changed_time, &werr);
318
319 if (!NT_STATUS_IS_OK(status)) {
320 goto error;
321 }
322 if (!W_ERROR_IS_OK(werr)) {
323 status = werror_to_ntstatus(werr);
324 goto error;
325 }
326
327 if (num_values == 0) {
328 *pnum_values = 0;
329 TALLOC_FREE(mem_ctx);
330 return NT_STATUS_OK;
331 }
332
333 if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
334 (!(values = TALLOC_ARRAY(mem_ctx, struct registry_value *,
335 num_values)))) {
336 status = NT_STATUS_NO_MEMORY;
337 goto error;
338 }
339
340 for (i=0; i<num_values; i++) {
341 enum winreg_Type type = REG_NONE;
342 uint8 *data = NULL;
343 uint32 data_size;
344 uint32 value_length;
345
346 char n;
347 struct winreg_ValNameBuf name_buf;
348 WERROR err;
349
350 n = '\0';
351 name_buf.name = &n;
352 name_buf.size = max_valnamelen + 2;
353
354 data_size = max_valbufsize;
355 data = (uint8 *)TALLOC(mem_ctx, data_size);
356 value_length = 0;
357
358 status = dcerpc_winreg_EnumValue(b, mem_ctx, key_hnd,
359 i, &name_buf, &type,
360 data, &data_size,
361 &value_length, &err);
362 if (!(NT_STATUS_IS_OK(status))) {
363 goto error;
364 }
365
366 if ( W_ERROR_EQUAL(err,
367 WERR_NO_MORE_ITEMS) ) {
368 status = NT_STATUS_OK;
369 break;
370 }
371
372 if (!W_ERROR_IS_OK(err)) {
373 status = werror_to_ntstatus(err);
374 goto error;
375 }
376
377 if (name_buf.name == NULL) {
378 status = NT_STATUS_INVALID_PARAMETER;
379 goto error;
380 }
381
382 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
383 status = NT_STATUS_NO_MEMORY;
384 goto error;
385 }
386
387 values[i] = talloc_zero(values, struct registry_value);
388 if (values[i] == NULL) {
389 status = NT_STATUS_NO_MEMORY;
390 goto error;
391 }
392
393 values[i]->type = type;
394 values[i]->data = data_blob_talloc(values[i], data, data_size);
395 }
396
397 *pnum_values = num_values;
398
399 if (pvalnames) {
400 *pvalnames = talloc_move(ctx, &names);
401 }
402 if (pvalues) {
403 *pvalues = talloc_move(ctx, &values);
404 }
405
406 status = NT_STATUS_OK;
407
408 error:
409 TALLOC_FREE(mem_ctx);
410 return status;
411 }
412
413 static NTSTATUS registry_enumvalues2(TALLOC_CTX *ctx,
414 struct rpc_pipe_client *pipe_hnd,
415 struct policy_handle *key_hnd,
416 uint32 *pnum_values, char ***pvalnames,
417 struct regval_blob ***pvalues)
418 {
419 TALLOC_CTX *mem_ctx;
420 NTSTATUS status;
421 WERROR werr;
422 uint32 num_subkeys, max_subkeylen, max_classlen;
423 uint32 num_values, max_valnamelen, max_valbufsize;
424 uint32 i;
425 NTTIME last_changed_time;
426 uint32 secdescsize;
427 struct winreg_String classname;
428 struct regval_blob **values;
429 char **names;
430 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
431
432 if (!(mem_ctx = talloc_new(ctx))) {
433 return NT_STATUS_NO_MEMORY;
434 }
435
436 ZERO_STRUCT(classname);
437 status = dcerpc_winreg_QueryInfoKey(
438 b, mem_ctx, key_hnd, &classname, &num_subkeys,
439 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
440 &max_valbufsize, &secdescsize, &last_changed_time, &werr);
441
442 if (!NT_STATUS_IS_OK(status)) {
443 goto error;
444 }
445 if (!W_ERROR_IS_OK(werr)) {
446 status = werror_to_ntstatus(werr);
447 goto error;
448 }
449
450 if (num_values == 0) {
451 *pnum_values = 0;
452 TALLOC_FREE(mem_ctx);
453 return NT_STATUS_OK;
454 }
455
456 if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
457 (!(values = TALLOC_ARRAY(mem_ctx, struct regval_blob *,
458 num_values)))) {
459 status = NT_STATUS_NO_MEMORY;
460 goto error;
461 }
462
463 for (i=0; i<num_values; i++) {
464 enum winreg_Type type = REG_NONE;
465 uint8 *data = NULL;
466 uint32 data_size;
467 uint32 value_length;
468
469 char n;
470 struct winreg_ValNameBuf name_buf;
471 WERROR err;
472
473 n = '\0';
474 name_buf.name = &n;
475 name_buf.size = max_valnamelen + 2;
476
477 data_size = max_valbufsize;
478 data = (uint8 *)TALLOC(mem_ctx, data_size);
479 value_length = 0;
480
481 status = dcerpc_winreg_EnumValue(b, mem_ctx, key_hnd,
482 i, &name_buf, &type,
483 data, &data_size,
484 &value_length, &err);
485 if (!(NT_STATUS_IS_OK(status))) {
486 goto error;
487 }
488
489 if ( W_ERROR_EQUAL(err, WERR_NO_MORE_ITEMS) ) {
490 status = NT_STATUS_OK;
491 break;
492 }
493
494 if (!W_ERROR_IS_OK(err)) {
495 status = werror_to_ntstatus(err);
496 goto error;
497 }
498
499 if (name_buf.name == NULL) {
500 status = NT_STATUS_INVALID_PARAMETER;
501 goto error;
502 }
503
504 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
505 status = NT_STATUS_NO_MEMORY;
506 goto error;
507 }
508
509 assert(value_length<=data_size); //???
510
511 values[i] = regval_compose(values,
512 name_buf.name,
513 type,
514 data, value_length);
515 if (!values[i]) {
516 status = NT_STATUS_NO_MEMORY;
517 goto error;
518 }
519 }
520
521 *pnum_values = num_values;
522
523 if (pvalnames) {
524 *pvalnames = talloc_move(ctx, &names);
525 }
526 if (pvalues) {
527 *pvalues = talloc_move(ctx, &values);
528 }
529
530 status = NT_STATUS_OK;
531
532 error:
533 TALLOC_FREE(mem_ctx);
534 return status;
535 }
536
537 static NTSTATUS registry_getsd(TALLOC_CTX *mem_ctx,
538 struct dcerpc_binding_handle *b,
539 struct policy_handle *key_hnd,
540 uint32_t sec_info,
541 struct KeySecurityData *sd,
542 WERROR *werr)
543 {
544 return dcerpc_winreg_GetKeySecurity(b, mem_ctx, key_hnd,
545 sec_info, sd, werr);
546 }
547
548
549 static NTSTATUS registry_setvalue(TALLOC_CTX *mem_ctx,
550 struct rpc_pipe_client *pipe_hnd,
551 struct policy_handle *key_hnd,
552 const char *name,
553 const struct registry_value *value)
554 {
555 struct winreg_String name_string;
556 NTSTATUS result;
557 WERROR werr;
558 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
559
560 ZERO_STRUCT(name_string);
561
562 name_string.name = name;
563 result = dcerpc_winreg_SetValue(b, mem_ctx, key_hnd,
564 name_string, value->type,
565 value->data.data, value->data.length, &werr);
566 if (!NT_STATUS_IS_OK(result)) {
567 return result;
568 }
569
570 return werror_to_ntstatus(werr);
571 }
572
573 static NTSTATUS rpc_registry_setvalue_internal(struct net_context *c,
574 const struct dom_sid *domain_sid,
575 const char *domain_name,
576 struct cli_state *cli,
577 struct rpc_pipe_client *pipe_hnd,
578 TALLOC_CTX *mem_ctx,
579 int argc,
580 const char **argv )
581 {
582 struct policy_handle hive_hnd, key_hnd;
583 NTSTATUS status;
584 WERROR werr;
585 struct registry_value value;
586 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
587
588 status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
589 SEC_FLAG_MAXIMUM_ALLOWED,
590 &hive_hnd, &key_hnd);
591 if (!NT_STATUS_IS_OK(status)) {
592 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
593 nt_errstr(status));
594 return status;
595 }
596
597 if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
598 d_fprintf(stderr, _("Too many args for type %s\n"), argv[2]);
599 return NT_STATUS_NOT_IMPLEMENTED;
600 }
601
602 if (strequal(argv[2], "dword")) {
603 uint32_t v = strtoul(argv[3], NULL, 10);
604 value.type = REG_DWORD;
605 value.data = data_blob_talloc(mem_ctx, NULL, 4);
606 SIVAL(value.data.data, 0, v);
607 }
608 else if (strequal(argv[2], "sz")) {
609 value.type = REG_SZ;
610 if (!push_reg_sz(mem_ctx, &value.data, argv[3])) {
611 status = NT_STATUS_NO_MEMORY;
612 goto error;
613 }
614 }
615 else {
616 d_fprintf(stderr, _("type \"%s\" not implemented\n"), argv[2]);
617 status = NT_STATUS_NOT_IMPLEMENTED;
618 goto error;
619 }
620
621 status = registry_setvalue(mem_ctx, pipe_hnd, &key_hnd,
622 argv[1], &value);
623
624 if (!NT_STATUS_IS_OK(status)) {
625 d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
626 nt_errstr(status));
627 }
628
629 error:
630 dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
631 dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
632
633 return NT_STATUS_OK;
634 }
635
636 static int rpc_registry_setvalue(struct net_context *c, int argc,
637 const char **argv )
638 {
639 if (argc < 4 || c->display_usage) {
640 d_fprintf(stderr, "%s\n%s",
641 _("Usage:"),
642 _("net rpc registry setvalue <key> <valuename> "
643 "<type> [<val>]+\n"));
644 return -1;
645 }
646
647 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
648 rpc_registry_setvalue_internal, argc, argv );
649 }
650
651 static NTSTATUS rpc_registry_deletevalue_internal(struct net_context *c,
652 const struct dom_sid *domain_sid,
653 const char *domain_name,
654 struct cli_state *cli,
655 struct rpc_pipe_client *pipe_hnd,
656 TALLOC_CTX *mem_ctx,
657 int argc,
658 const char **argv )
659 {
660 struct policy_handle hive_hnd, key_hnd;
661 NTSTATUS status;
662 WERROR werr;
663 struct winreg_String valuename;
664 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
665
666 ZERO_STRUCT(valuename);
667
668 status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
669 SEC_FLAG_MAXIMUM_ALLOWED,
670 &hive_hnd, &key_hnd);
671 if (!NT_STATUS_IS_OK(status)) {
672 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
673 nt_errstr(status));
674 return status;
675 }
676
677 valuename.name = argv[1];
678
679 status = dcerpc_winreg_DeleteValue(b, mem_ctx, &key_hnd,
680 valuename, &werr);
681 if (!NT_STATUS_IS_OK(status)) {
682 d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
683 nt_errstr(status));
684 }
685 if (!W_ERROR_IS_OK(werr)) {
686 status = werror_to_ntstatus(werr);
687 d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
688 win_errstr(werr));
689 }
690
691 dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
692 dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
693
694 return status;
695 }
696
697 static int rpc_registry_deletevalue(struct net_context *c, int argc,
698 const char **argv )
699 {
700 if (argc != 2 || c->display_usage) {
701 d_fprintf(stderr, "%s\n%s",
702 _("Usage:"),
703 _("net rpc registry deletevalue <key> <valuename>\n"));
704 return -1;
705 }
706
707 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
708 rpc_registry_deletevalue_internal, argc, argv );
709 }
710
711 static NTSTATUS rpc_registry_getvalue_internal(struct net_context *c,
712 const struct dom_sid *domain_sid,
713 const char *domain_name,
714 struct cli_state *cli,
715 struct rpc_pipe_client *pipe_hnd,
716 TALLOC_CTX *mem_ctx,
717 bool raw,
718 int argc,
719 const char **argv)
720 {
721 struct policy_handle hive_hnd, key_hnd;
722 NTSTATUS status;
723 WERROR werr;
724 struct winreg_String valuename;
725 struct registry_value *value = NULL;
726 enum winreg_Type type = REG_NONE;
727 uint32_t data_size = 0;
728 uint32_t value_length = 0;
729 TALLOC_CTX *tmp_ctx = talloc_stackframe();
730 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
731
732 ZERO_STRUCT(valuename);
733
734 status = registry_openkey(tmp_ctx, pipe_hnd, argv[0],
735 SEC_FLAG_MAXIMUM_ALLOWED,
736 &hive_hnd, &key_hnd);
737 if (!NT_STATUS_IS_OK(status)) {
738 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
739 nt_errstr(status));
740 return status;
741 }
742
743 valuename.name = argv[1];
744
745 value = talloc_zero(tmp_ctx, struct registry_value);
746 if (value == NULL) {
747 return NT_STATUS_NO_MEMORY;
748 }
749
750 /*
751 * call QueryValue once with data == NULL to get the
752 * needed memory size to be allocated, then allocate
753 * data buffer and call again.
754 */
755 status = dcerpc_winreg_QueryValue(b, tmp_ctx, &key_hnd,
756 &valuename,
757 &type,
758 NULL,
759 &data_size,
760 &value_length,
761 &werr);
762
763 if (!NT_STATUS_IS_OK(status)) {
764 d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
765 nt_errstr(status));
766 goto done;
767 }
768 if (!W_ERROR_IS_OK(werr)) {
769 status = werror_to_ntstatus(werr);
770 d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
771 nt_errstr(status));
772 goto done;
773 }
774
775 value->data = data_blob_talloc(tmp_ctx, NULL, data_size);
776
777 status = dcerpc_winreg_QueryValue(b, tmp_ctx, &key_hnd,
778 &valuename,
779 &type,
780 value->data.data,
781 &data_size,
782 &value_length,
783 &werr);
784
785 if (!NT_STATUS_IS_OK(status)) {
786 d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
787 nt_errstr(status));
788 goto done;
789 }
790 if (!W_ERROR_IS_OK(werr)) {
791 status = werror_to_ntstatus(werr);
792 d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
793 win_errstr(werr));
794 goto done;
795 }
796
797
798 value->type = type;
799
800 print_registry_value(value, raw);
801
802 done:
803 dcerpc_winreg_CloseKey(b, tmp_ctx, &key_hnd, &werr);
804 dcerpc_winreg_CloseKey(b, tmp_ctx, &hive_hnd, &werr);
805
806 TALLOC_FREE(tmp_ctx);
807
808 return status;
809 }
810
811 static NTSTATUS rpc_registry_getvalue_full(struct net_context *c,
812 const struct dom_sid *domain_sid,
813 const char *domain_name,
814 struct cli_state *cli,
815 struct rpc_pipe_client *pipe_hnd,
816 TALLOC_CTX *mem_ctx,
817 int argc,
818 const char **argv)
819 {
820 return rpc_registry_getvalue_internal(c, domain_sid, domain_name,
821 cli, pipe_hnd, mem_ctx, false,
822 argc, argv);
823 }
824
825 static int rpc_registry_getvalue(struct net_context *c, int argc,
826 const char **argv)
827 {
828 if (argc != 2 || c->display_usage) {
829 d_fprintf(stderr, "%s\n%s",
830 _("Usage:"),
831 _("net rpc registry getvalue <key> <valuename>\n"));
832 return -1;
833 }
834
835 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
836 rpc_registry_getvalue_full, argc, argv);
837 }
838
839 static NTSTATUS rpc_registry_getvalue_raw(struct net_context *c,
840 const struct dom_sid *domain_sid,
841 const char *domain_name,
842 struct cli_state *cli,
843 struct rpc_pipe_client *pipe_hnd,
844 TALLOC_CTX *mem_ctx,
845 int argc,
846 const char **argv)
847 {
848 return rpc_registry_getvalue_internal(c, domain_sid, domain_name,
849 cli, pipe_hnd, mem_ctx, true,
850 argc, argv);
851 }
852
853 static int rpc_registry_getvalueraw(struct net_context *c, int argc,
854 const char **argv)
855 {
856 if (argc != 2 || c->display_usage) {
857 d_fprintf(stderr, "%s\n%s",
858 _("Usage:"),
859 _("net rpc registry getvalue <key> <valuename>\n"));
860 return -1;
861 }
862
863 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
864 rpc_registry_getvalue_raw, argc, argv);
865 }
866
867 static NTSTATUS rpc_registry_createkey_internal(struct net_context *c,
868 const struct dom_sid *domain_sid,
869 const char *domain_name,
870 struct cli_state *cli,
871 struct rpc_pipe_client *pipe_hnd,
872 TALLOC_CTX *mem_ctx,
873 int argc,
874 const char **argv )
875 {
876 uint32 hive;
877 struct policy_handle hive_hnd, key_hnd;
878 struct winreg_String key, keyclass;
879 enum winreg_CreateAction action;
880 NTSTATUS status;
881 WERROR werr;
882 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
883
884 ZERO_STRUCT(key);
885 ZERO_STRUCT(keyclass);
886
887 if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
888 return NT_STATUS_INVALID_PARAMETER;
889 }
890
891 status = dcerpc_winreg_Connect(b, mem_ctx, hive,
892 SEC_FLAG_MAXIMUM_ALLOWED,
893 &hive_hnd, &werr);
894 if (!(NT_STATUS_IS_OK(status))) {
895 return status;
896 }
897 if (!W_ERROR_IS_OK(werr)) {
898 return werror_to_ntstatus(werr);
899 }
900
901 action = REG_ACTION_NONE;
902 keyclass.name = "";
903
904 status = dcerpc_winreg_CreateKey(b, mem_ctx, &hive_hnd, key,
905 keyclass, 0, REG_KEY_READ, NULL,
906 &key_hnd, &action, &werr);
907 if (!NT_STATUS_IS_OK(status)) {
908 d_fprintf(stderr, _("createkey returned %s\n"),
909 nt_errstr(status));
910 dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
911 return status;
912 }
913 if (!W_ERROR_IS_OK(werr)) {
914 WERROR _werr;
915 d_fprintf(stderr, _("createkey returned %s\n"),
916 win_errstr(werr));
917 dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &_werr);
918 return werror_to_ntstatus(werr);
919 }
920
921 switch (action) {
922 case REG_ACTION_NONE:
923 d_printf(_("createkey did nothing -- huh?\n"));
924 break;
925 case REG_CREATED_NEW_KEY:
926 d_printf(_("createkey created %s\n"), argv[0]);
927 break;
928 case REG_OPENED_EXISTING_KEY:
929 d_printf(_("createkey opened existing %s\n"), argv[0]);
930 break;
931 }
932
933 dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
934 dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
935
936 return status;
937 }
938
939 static int rpc_registry_createkey(struct net_context *c, int argc,
940 const char **argv )
941 {
942 if (argc != 1 || c->display_usage) {
943 d_fprintf(stderr, "%s\n%s",
944 _("Usage:"),
945 _("net rpc registry createkey <key>\n"));
946 return -1;
947 }
948
949 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
950 rpc_registry_createkey_internal, argc, argv );
951 }
952
953 static NTSTATUS rpc_registry_deletekey_internal(struct net_context *c,
954 const struct dom_sid *domain_sid,
955 const char *domain_name,
956 struct cli_state *cli,
957 struct rpc_pipe_client *pipe_hnd,
958 TALLOC_CTX *mem_ctx,
959 int argc,
960 const char **argv )
961 {
962 uint32 hive;
963 struct policy_handle hive_hnd;
964 struct winreg_String key;
965 NTSTATUS status;
966 WERROR werr;
967 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
968
969 ZERO_STRUCT(key);
970
971 if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
972 return NT_STATUS_INVALID_PARAMETER;
973 }
974
975 status = dcerpc_winreg_Connect(b, mem_ctx, hive,
976 SEC_FLAG_MAXIMUM_ALLOWED,
977 &hive_hnd, &werr);
978 if (!(NT_STATUS_IS_OK(status))) {
979 return status;
980 }
981 if (!W_ERROR_IS_OK(werr)) {
982 return werror_to_ntstatus(werr);
983 }
984
985 status = dcerpc_winreg_DeleteKey(b, mem_ctx, &hive_hnd, key, &werr);
986 if (is_valid_policy_hnd(&hive_hnd)) {
987 WERROR _werr;
988 dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &_werr);
989 }
990
991 if (!NT_STATUS_IS_OK(status)) {
992 d_fprintf(stderr, _("deletekey returned %s\n"),
993 nt_errstr(status));
994 return status;
995 }
996
997 if (!W_ERROR_IS_OK(werr)) {
998 d_fprintf(stderr, _("deletekey returned %s\n"),
999 win_errstr(werr));
1000 return werror_to_ntstatus(werr);
1001 }
1002
1003 return status;
1004 }
1005
1006 static int rpc_registry_deletekey(struct net_context *c, int argc, const char **argv )
1007 {
1008 if (argc != 1 || c->display_usage) {
1009 d_fprintf(stderr, "%s\n%s",
1010 _("Usage:"),
1011 _("net rpc registry deletekey <key>\n"));
1012 return -1;
1013 }
1014
1015 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1016 rpc_registry_deletekey_internal, argc, argv );
1017 }
1018
1019 /********************************************************************
1020 ********************************************************************/
1021
1022 static NTSTATUS rpc_registry_enumerate_internal(struct net_context *c,
1023 const struct dom_sid *domain_sid,
1024 const char *domain_name,
1025 struct cli_state *cli,
1026 struct rpc_pipe_client *pipe_hnd,
1027 TALLOC_CTX *mem_ctx,
1028 int argc,
1029 const char **argv )
1030 {
1031 struct policy_handle pol_hive, pol_key;
1032 NTSTATUS status;
1033 WERROR werr;
1034 uint32 num_subkeys = 0;
1035 uint32 num_values = 0;
1036 char **names = NULL, **classes = NULL;
1037 NTTIME **modtimes = NULL;
1038 uint32 i;
1039 struct registry_value **values = NULL;
1040 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1041
1042 if (argc != 1 || c->display_usage) {
1043 d_printf("%s\n%s",
1044 _("Usage:"),
1045 _("net rpc registry enumerate <path>\n"));
1046 d_printf("%s net rpc registry enumerate "
1047 "'HKLM\\Software\\Samba'\n", _("Example:"));
1048 return NT_STATUS_INVALID_PARAMETER;
1049 }
1050
1051 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
1052 &pol_hive, &pol_key);
1053 if (!NT_STATUS_IS_OK(status)) {
1054 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
1055 nt_errstr(status));
1056 return status;
1057 }
1058
1059 status = registry_enumkeys(mem_ctx, pipe_hnd, &pol_key, &num_subkeys,
1060 &names, &classes, &modtimes);
1061 if (!NT_STATUS_IS_OK(status)) {
1062 d_fprintf(stderr, _("enumerating keys failed: %s\n"),
1063 nt_errstr(status));
1064 return status;
1065 }
1066
1067 for (i=0; i<num_subkeys; i++) {
1068 print_registry_key(names[i], modtimes[i]);
1069 }
1070
1071 status = registry_enumvalues(mem_ctx, pipe_hnd, &pol_key, &num_values,
1072 &names, &values);
1073 if (!NT_STATUS_IS_OK(status)) {
1074 d_fprintf(stderr, _("enumerating values failed: %s\n"),
1075 nt_errstr(status));
1076 return status;
1077 }
1078
1079 for (i=0; i<num_values; i++) {
1080 print_registry_value_with_name(names[i], values[i]);
1081 }
1082
1083 dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
1084 dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
1085
1086 return status;
1087 }
1088
1089 /********************************************************************
1090 ********************************************************************/
1091
1092 static int rpc_registry_enumerate(struct net_context *c, int argc,
1093 const char **argv )
1094 {
1095 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1096 rpc_registry_enumerate_internal, argc, argv );
1097 }
1098
1099 /********************************************************************
1100 ********************************************************************/
1101
1102 static NTSTATUS rpc_registry_save_internal(struct net_context *c,
1103 const struct dom_sid *domain_sid,
1104 const char *domain_name,
1105 struct cli_state *cli,
1106 struct rpc_pipe_client *pipe_hnd,
1107 TALLOC_CTX *mem_ctx,
1108 int argc,
1109 const char **argv )
1110 {
1111 WERROR result = WERR_GENERAL_FAILURE;
1112 struct policy_handle pol_hive, pol_key;
1113 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
1114 struct winreg_String filename;
1115 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1116
1117 if (argc != 2 || c->display_usage) {
1118 d_printf("%s\n%s",
1119 _("Usage:"),
1120 _("net rpc registry backup <path> <file> \n"));
1121 return NT_STATUS_INVALID_PARAMETER;
1122 }
1123
1124 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_ALL,
1125 &pol_hive, &pol_key);
1126 if (!NT_STATUS_IS_OK(status)) {
1127 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
1128 nt_errstr(status));
1129 return status;
1130 }
1131
1132 filename.name = argv[1];
1133 status = dcerpc_winreg_SaveKey(b, mem_ctx, &pol_key, &filename, NULL, &result);
1134 if (!NT_STATUS_IS_OK(status)) {
1135 d_fprintf(stderr, _("Unable to save [%s] to %s:%s\n"), argv[0],
1136 cli->desthost, argv[1]);
1137 }
1138 if (!W_ERROR_IS_OK(result)) {
1139 status = werror_to_ntstatus(result);
1140 d_fprintf(stderr, _("Unable to save [%s] to %s:%s\n"), argv[0],
1141 cli->desthost, argv[1]);
1142 }
1143
1144 /* cleanup */
1145
1146 dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &result);
1147 dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &result);
1148
1149 return status;
1150 }
1151
1152 /********************************************************************
1153 ********************************************************************/
1154
1155 static int rpc_registry_save(struct net_context *c, int argc, const char **argv )
1156 {
1157 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1158 rpc_registry_save_internal, argc, argv );
1159 }
1160
1161
1162 /********************************************************************
1163 ********************************************************************/
1164
1165 static void dump_values( REGF_NK_REC *nk )
1166 {
1167 int i, j;
1168 const char *data_str = NULL;
1169 uint32 data_size, data;
1170 DATA_BLOB blob;
1171
1172 if ( !nk->values )
1173 return;
1174
1175 for ( i=0; i<nk->num_values; i++ ) {
1176 d_printf( "\"%s\" = ", nk->values[i].valuename ? nk->values[i].valuename : "(default)" );
1177 d_printf( "(%s) ", str_regtype( nk->values[i].type ) );
1178
1179 data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
1180 switch ( nk->values[i].type ) {
1181 case REG_SZ:
1182 blob = data_blob_const(nk->values[i].data, data_size);
1183 pull_reg_sz(talloc_tos(), &blob, &data_str);
1184 if (!data_str) {
1185 break;
1186 }
1187 d_printf( "%s", data_str );
1188 break;
1189 case REG_MULTI_SZ:
1190 case REG_EXPAND_SZ:
1191 for ( j=0; j<data_size; j++ ) {
1192 d_printf( "%c", nk->values[i].data[j] );
1193 }
1194 break;
1195 case REG_DWORD:
1196 data = IVAL( nk->values[i].data, 0 );
1197 d_printf("0x%x", data );
1198 break;
1199 case REG_BINARY:
1200 for ( j=0; j<data_size; j++ ) {
1201 d_printf( "%x", nk->values[i].data[j] );
1202 }
1203 break;
1204 default:
1205 d_printf(_("unknown"));
1206 break;
1207 }
1208
1209 d_printf( "\n" );
1210 }
1211
1212 }
1213
1214 /********************************************************************
1215 ********************************************************************/
1216
1217 static bool dump_registry_tree( REGF_FILE *file, REGF_NK_REC *nk, const char *parent )
1218 {
1219 REGF_NK_REC *key;
1220
1221 /* depth first dump of the registry tree */
1222
1223 while ( (key = regfio_fetch_subkey( file, nk )) ) {
1224 char *regpath;
1225 if (asprintf(&regpath, "%s\\%s", parent, key->keyname) < 0) {
1226 break;
1227 }
1228 d_printf("[%s]\n", regpath );
1229 dump_values( key );
1230 d_printf("\n");
1231 dump_registry_tree( file, key, regpath );
1232 SAFE_FREE(regpath);
1233 }
1234
1235 return true;
1236 }
1237
1238 /********************************************************************
1239 ********************************************************************/
1240
1241 static bool write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
1242 REGF_NK_REC *parent, REGF_FILE *outfile,
1243 const char *parentpath )
1244 {
1245 REGF_NK_REC *key, *subkey;
1246 struct regval_ctr *values = NULL;
1247 struct regsubkey_ctr *subkeys = NULL;
1248 int i;
1249 char *path = NULL;
1250 WERROR werr;
1251
1252 werr = regsubkey_ctr_init(infile->mem_ctx, &subkeys);
1253 if (!W_ERROR_IS_OK(werr)) {
1254 DEBUG(0, ("write_registry_tree: regsubkey_ctr_init failed: "
1255 "%s\n", win_errstr(werr)));
1256 return false;
1257 }
1258
1259 werr = regval_ctr_init(subkeys, &values);
1260 if (!W_ERROR_IS_OK(werr)) {
1261 DEBUG(0,("write_registry_tree: talloc() failed!\n"));
1262 TALLOC_FREE(subkeys);
1263 return false;
1264 }
1265
1266 /* copy values into the struct regval_ctr */
1267
1268 for ( i=0; i<nk->num_values; i++ ) {
1269 regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
1270 nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
1271 }
1272
1273 /* copy subkeys into the struct regsubkey_ctr */
1274
1275 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
1276 regsubkey_ctr_addkey( subkeys, subkey->keyname );
1277 }
1278
1279 key = regfio_write_key( outfile, nk->keyname, values, subkeys, nk->sec_desc->sec_desc, parent );
1280
1281 /* write each one of the subkeys out */
1282
1283 path = talloc_asprintf(subkeys,
1284 "%s%s%s",
1285 parentpath,
1286 parent ? "\\" : "",
1287 nk->keyname);
1288 if (!path) {
1289 TALLOC_FREE(subkeys);
1290 return false;
1291 }
1292
1293 nk->subkey_index = 0;
1294 while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
1295 write_registry_tree( infile, subkey, key, outfile, path );
1296 }
1297
1298 d_printf("[%s]\n", path );
1299 TALLOC_FREE(subkeys);
1300
1301 return true;
1302 }
1303
1304 /********************************************************************
1305 ********************************************************************/
1306
1307 static int rpc_registry_dump(struct net_context *c, int argc, const char **argv)
1308 {
1309 REGF_FILE *registry;
1310 REGF_NK_REC *nk;
1311
1312 if (argc != 1 || c->display_usage) {
1313 d_printf("%s\n%s",
1314 _("Usage:"),
1315 _("net rpc registry dump <file> \n"));
1316 return -1;
1317 }
1318
1319 d_printf(_("Opening %s...."), argv[0]);
1320 if ( !(registry = regfio_open( argv[0], O_RDONLY, 0)) ) {
1321 d_fprintf(stderr, _("Failed to open %s for reading\n"),argv[0]);
1322 return 1;
1323 }
1324 d_printf(_("ok\n"));
1325
1326 /* get the root of the registry file */
1327
1328 if ((nk = regfio_rootkey( registry )) == NULL) {
1329 d_fprintf(stderr, _("Could not get rootkey\n"));
1330 regfio_close( registry );
1331 return 1;
1332 }
1333 d_printf("[%s]\n", nk->keyname);
1334 dump_values( nk );
1335 d_printf("\n");
1336
1337 dump_registry_tree( registry, nk, nk->keyname );
1338
1339 #if 0
1340 talloc_report_full( registry->mem_ctx, stderr );
1341 #endif
1342 d_printf(_("Closing registry..."));
1343 regfio_close( registry );
1344 d_printf(_("ok\n"));
1345
1346 return 0;
1347 }
1348
1349 /********************************************************************
1350 ********************************************************************/
1351
1352 static int rpc_registry_copy(struct net_context *c, int argc, const char **argv )
1353 {
1354 REGF_FILE *infile = NULL, *outfile = NULL;
1355 REGF_NK_REC *nk;
1356 int result = 1;
1357
1358 if (argc != 2 || c->display_usage) {
1359 d_printf("%s\n%s",
1360 _("Usage:"),
1361 _("net rpc registry copy <srcfile> <newfile>\n"));
1362 return -1;
1363 }
1364
1365 d_printf(_("Opening %s...."), argv[0]);
1366 if ( !(infile = regfio_open( argv[0], O_RDONLY, 0 )) ) {
1367 d_fprintf(stderr, _("Failed to open %s for reading\n"),argv[0]);
1368 return 1;
1369 }
1370 d_printf(_("ok\n"));
1371
1372 d_printf(_("Opening %s...."), argv[1]);
1373 if ( !(outfile = regfio_open( argv[1], (O_RDWR|O_CREAT|O_TRUNC),
1374 (S_IRUSR|S_IWUSR) )) ) {
1375 d_fprintf(stderr, _("Failed to open %s for writing\n"),argv[1]);
1376 goto out;
1377 }
1378 d_printf(_("ok\n"));
1379
1380 /* get the root of the registry file */
1381
1382 if ((nk = regfio_rootkey( infile )) == NULL) {
1383 d_fprintf(stderr, _("Could not get rootkey\n"));
1384 goto out;
1385 }
1386 d_printf(_("RootKey: [%s]\n"), nk->keyname);
1387
1388 write_registry_tree( infile, nk, NULL, outfile, "" );
1389
1390 result = 0;
1391
1392 out:
1393
1394 d_printf(_("Closing %s..."), argv[1]);
1395 if (outfile) {
1396 regfio_close( outfile );
1397 }
1398 d_printf(_("ok\n"));
1399
1400 d_printf(_("Closing %s..."), argv[0]);
1401 if (infile) {
1402 regfio_close( infile );
1403 }
1404 d_printf(_("ok\n"));
1405
1406 return( result);
1407 }
1408
1409 /********************************************************************
1410 ********************************************************************/
1411
1412 static NTSTATUS rpc_registry_getsd_internal(struct net_context *c,
1413 const struct dom_sid *domain_sid,
1414 const char *domain_name,
1415 struct cli_state *cli,
1416 struct rpc_pipe_client *pipe_hnd,
1417 TALLOC_CTX *mem_ctx,
1418 int argc,
1419 const char **argv)
1420 {
1421 struct policy_handle pol_hive, pol_key;
1422 NTSTATUS status;
1423 WERROR werr;
1424 enum ndr_err_code ndr_err;
1425 struct KeySecurityData *sd = NULL;
1426 uint32_t sec_info;
1427 DATA_BLOB blob;
1428 struct security_descriptor sec_desc;
1429 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED |
1430 SEC_FLAG_SYSTEM_SECURITY;
1431 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1432
1433 if (argc <1 || argc > 2 || c->display_usage) {
1434 d_printf("%s\n%s",
1435 _("Usage:"),
1436 _("net rpc registry getsd <path> <secinfo>\n"));
1437 d_printf("%s net rpc registry getsd "
1438 "'HKLM\\Software\\Samba'\n", _("Example:"));
1439 return NT_STATUS_INVALID_PARAMETER;
1440 }
1441
1442 status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
1443 access_mask,
1444 &pol_hive, &pol_key);
1445 if (!NT_STATUS_IS_OK(status)) {
1446 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
1447 nt_errstr(status));
1448 return status;
1449 }
1450
1451 sd = TALLOC_ZERO_P(mem_ctx, struct KeySecurityData);
1452 if (!sd) {
1453 status = NT_STATUS_NO_MEMORY;
1454 goto out;
1455 }
1456
1457 sd->size = 0x1000;
1458
1459 if (argc >= 2) {
1460 sscanf(argv[1], "%x", &sec_info);
1461 } else {
1462 sec_info = SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL;
1463 }
1464
1465 status = registry_getsd(mem_ctx, b, &pol_key, sec_info, sd, &werr);
1466 if (!NT_STATUS_IS_OK(status)) {
1467 d_fprintf(stderr, _("getting sd failed: %s\n"),
1468 nt_errstr(status));
1469 goto out;
1470 }
1471 if (!W_ERROR_IS_OK(werr)) {
1472 status = werror_to_ntstatus(werr);
1473 d_fprintf(stderr, _("getting sd failed: %s\n"),
1474 win_errstr(werr));
1475 goto out;
1476 }
1477
1478 blob.data = sd->data;
1479 blob.length = sd->size;
1480
1481 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &sec_desc,
1482 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
1483 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1484 status = ndr_map_error2ntstatus(ndr_err);
1485 goto out;
1486 }
1487 status = NT_STATUS_OK;
1488
1489 display_sec_desc(&sec_desc);
1490
1491 out:
1492 dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
1493 dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
1494
1495 return status;
1496 }
1497
1498
1499 static int rpc_registry_getsd(struct net_context *c, int argc, const char **argv)
1500 {
1501 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1502 rpc_registry_getsd_internal, argc, argv);
1503 }
1504
1505 /********************************************************************
1506 ********************************************************************/
1507 /**
1508 * @defgroup net_rpc_registry net rpc registry
1509 */
1510
1511 /**
1512 * @defgroup net_rpc_registry_export Export
1513 * @ingroup net_rpc_registry
1514 * @{
1515 */
1516
1517 static NTSTATUS registry_export(struct rpc_pipe_client* pipe_hnd,
1518 TALLOC_CTX* ctx,
1519 struct policy_handle* key_hnd,
1520 struct reg_format* f,
1521 const char* parentfullname,
1522 const char* name)
1523 {
1524 NTSTATUS status;
1525 uint32 num_subkeys = 0;
1526 uint32 num_values = 0;
1527 char **names = NULL, **classes = NULL;
1528 NTTIME **modtimes = NULL;
1529 struct regval_blob **values = NULL;
1530 uint32 i;
1531 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1532
1533 TALLOC_CTX* mem_ctx = talloc_new(ctx);
1534
1535
1536 const char* fullname = name
1537 ? talloc_asprintf(mem_ctx, "%s\\%s", parentfullname, name)
1538 : parentfullname;
1539 reg_format_key(f, &fullname, 1, false);
1540
1541 status = registry_enumvalues2(mem_ctx, pipe_hnd, key_hnd, &num_values,
1542 &names, &values);
1543 if (!NT_STATUS_IS_OK(status)) {
1544 d_fprintf(stderr, _("enumerating values failed: %s\n"),
1545 nt_errstr(status));
1546 goto done;
1547 }
1548
1549 for (i=0; i<num_values; i++) {
1550 reg_format_regval_blob(f, names[i], values[i]);
1551 }
1552
1553
1554 status = registry_enumkeys(mem_ctx, pipe_hnd, key_hnd, &num_subkeys,
1555 &names, &classes, &modtimes);
1556 if (!NT_STATUS_IS_OK(status)) {
1557 d_fprintf(stderr, _("enumerating keys failed: %s\n"),
1558 nt_errstr(status));
1559 goto done;
1560 }
1561
1562 for (i=0; i<num_subkeys; i++) {
1563 struct policy_handle subkey_hnd;
1564 struct winreg_String key;
1565 WERROR werr;
1566 ZERO_STRUCT(key);
1567 /* key.name = talloc_strdup(mem_ctx, names[i]); ??? */
1568 key.name = names[i];
1569
1570 status = dcerpc_winreg_OpenKey(b, mem_ctx, key_hnd, key,
1571 0, REG_KEY_READ,
1572 &subkey_hnd, &werr);
1573 if (!NT_STATUS_IS_OK(status)) {
1574 d_fprintf(stderr,
1575 _("dcerpc_winreg_OpenKey failed: %s %s\n"),
1576 names[i], nt_errstr(status));
1577 continue;
1578 }
1579 if (!W_ERROR_IS_OK(werr)) {
1580 status = werror_to_ntstatus(werr);
1581 d_fprintf(stderr,
1582 _("dcerpc_winreg_OpenKey failed: %s %s\n"),
1583 names[i], win_errstr(werr));
1584 continue;
1585 }
1586
1587 status = registry_export(pipe_hnd, mem_ctx, &subkey_hnd,
1588 f, fullname, names[i]);
1589 if (!(NT_STATUS_IS_OK(status))) {
1590 d_fprintf(stderr,
1591 _("export key failed: %s %s\n"),
1592 names[i], nt_errstr(status));
1593 }
1594 dcerpc_winreg_CloseKey(b, mem_ctx,
1595 &subkey_hnd, &werr);
1596 }
1597 done:
1598 talloc_free(mem_ctx);
1599 return status;
1600 }
1601
1602 static NTSTATUS rpc_registry_export_internal(struct net_context *c,
1603 const struct dom_sid *domain_sid,
1604 const char *domain_name,
1605 struct cli_state *cli,
1606 struct rpc_pipe_client *pipe_hnd,
1607 TALLOC_CTX *mem_ctx,
1608 int argc,
1609 const char **argv )
1610 {
1611 struct policy_handle pol_hive, pol_key;
1612 NTSTATUS status;
1613 WERROR werr;
1614 struct reg_format* f;
1615 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1616
1617 if (argc < 2 || argc > 3 || c->display_usage) {
1618 d_printf("%s\n%s",
1619 _("Usage:"),
1620 _("net rpc registry export <path> <file> [opt]\n"));
1621 d_printf("%s net rpc registry export "
1622 "'HKLM\\Software\\Samba' samba.reg\n", _("Example:"));
1623 return NT_STATUS_INVALID_PARAMETER;
1624 }
1625
1626 status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
1627 &pol_hive, &pol_key);
1628 if (!NT_STATUS_IS_OK(status)) {
1629 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
1630 nt_errstr(status));
1631 return status;
1632 }
1633
1634 f = reg_format_file(mem_ctx, argv[1], (argc > 2) ? argv[2] : NULL);
1635 if (f == NULL) {
1636 d_fprintf(stderr, _("open file failed: %s\n"), strerror(errno));
1637 return map_nt_error_from_unix(errno);
1638 }
1639
1640 status = registry_export(pipe_hnd, mem_ctx, &pol_key,
1641 f, argv[0], NULL );
1642 if (!NT_STATUS_IS_OK(status))
1643 return status;
1644
1645 dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
1646 dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
1647
1648 return status;
1649 }
1650 /********************************************************************
1651 ********************************************************************/
1652
1653 static int rpc_registry_export(struct net_context *c, int argc,
1654 const char **argv )
1655 {
1656 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1657 rpc_registry_export_internal, argc, argv );
1658 }
1659
1660 /**@}*/
1661
1662 /********************************************************************
1663 ********************************************************************/
1664
1665 /**
1666 * @defgroup net_rpc_registry_import Import
1667 * @ingroup net_rpc_registry
1668 * @{
1669 */
1670
1671 struct import_ctx {
1672 struct rpc_pipe_client *pipe_hnd;
1673 TALLOC_CTX *mem_ctx;
1674 };
1675
1676 static WERROR import_create_key(struct import_ctx* ctx,
1677 struct policy_handle* parent, const char* name,
1678 void** pkey, bool* existing)
1679 {
1680 WERROR werr;
1681 NTSTATUS status;
1682 void* mem_ctx = talloc_new(ctx->mem_ctx);
1683
1684 struct policy_handle* key = NULL;
1685 struct policy_handle hive;
1686 struct winreg_String keyclass, keyname;
1687 enum winreg_CreateAction action = REG_ACTION_NONE;
1688 struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
1689
1690 ZERO_STRUCT(keyname);
1691 keyname.name = name;
1692
1693 if (parent == NULL) {
1694 uint32 hive_idx = 0;
1695 if (!reg_hive_key(mem_ctx, name, &hive_idx, &keyname.name)) {
1696 werr = WERR_FOOBAR;
1697 goto done;
1698 }
1699
1700 status = dcerpc_winreg_Connect(b, mem_ctx,
1701 hive_idx, SEC_FLAG_MAXIMUM_ALLOWED,
1702 &hive, &werr);
1703 if (!NT_STATUS_IS_OK(status)) {
1704 werr = ntstatus_to_werror(status);
1705 d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
1706 nt_errstr(status));
1707 goto done;
1708 }
1709 if (!W_ERROR_IS_OK(werr)) {
1710 d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
1711 win_errstr(werr));
1712 goto done;
1713 }
1714
1715 parent = &hive;
1716 }
1717
1718 key = talloc_zero(mem_ctx, struct policy_handle);
1719 if (key == NULL) {
1720 werr = WERR_NOMEM;
1721 goto done;
1722 }
1723
1724 ZERO_STRUCT(keyclass);
1725 keyclass.name = "";
1726
1727 status = dcerpc_winreg_CreateKey(b, mem_ctx,
1728 parent, keyname,
1729 keyclass, 0, REG_KEY_READ, NULL,
1730 key, &action, &werr);
1731 if (!NT_STATUS_IS_OK(status)) {
1732 werr = ntstatus_to_werror(status);
1733 d_fprintf(stderr, _("dcerpc_winreg_CreateKey returned %s\n"),
1734 nt_errstr(status));
1735 goto done;
1736 }
1737 if (!W_ERROR_IS_OK(werr)) {
1738 d_fprintf(stderr, _("dcerpc_winreg_CreateKey returned %s\n"),
1739 win_errstr(werr));
1740 goto done;
1741 }
1742
1743 switch (action) {
1744 case REG_CREATED_NEW_KEY:
1745 d_printf(_("createkey created %s\n"), name);
1746 if (existing != NULL)
1747 *existing = false;
1748 break;
1749
1750 case REG_OPENED_EXISTING_KEY:
1751 d_printf(_("createkey opened existing %s\n"), name);
1752 if (existing != NULL)
1753 *existing = true;
1754 break;
1755
1756 case REG_ACTION_NONE:
1757 d_printf(_("createkey did nothing -- huh?\n"));
1758 werr = WERR_CREATE_FAILED;
1759 break;
1760 default:
1761 assert(false);
1762 }
1763
1764 done:
1765 if ( parent == &hive ) {
1766 WERROR _result;
1767 dcerpc_winreg_CloseKey(b, mem_ctx,
1768 parent, &_result);
1769 }
1770
1771 if (pkey!=NULL) {
1772 *pkey = talloc_steal(ctx->mem_ctx, key);
1773 }
1774
1775 talloc_free(mem_ctx);
1776 return werr;
1777 }
1778
1779 static WERROR import_delete_key(struct import_ctx* ctx,
1780 struct policy_handle* parent, const char* name)
1781 {
1782 WERROR werr;
1783 NTSTATUS status;
1784 void* mem_ctx = talloc_new(ctx->mem_ctx);
1785 struct winreg_String keyname;
1786 struct policy_handle hive;
1787 struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
1788
1789 keyname.name = name;
1790
1791 if (parent == NULL) {
1792 uint32 hive_idx;
1793 if (!reg_hive_key(mem_ctx, name, &hive_idx, &keyname.name)) {
1794 werr = WERR_FOOBAR;
1795 goto done;
1796 }
1797
1798 status = dcerpc_winreg_Connect(b, mem_ctx, hive_idx,
1799 SEC_FLAG_MAXIMUM_ALLOWED, &hive,
1800 &werr);
1801 if (!NT_STATUS_IS_OK(status)) {
1802 werr = ntstatus_to_werror(status);
1803 d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
1804 nt_errstr(status));
1805 goto done;
1806 }
1807 if (!W_ERROR_IS_OK(werr)) {
1808 d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
1809 win_errstr(werr));
1810 goto done;
1811 }
1812
1813 parent = &hive;
1814 }
1815
1816 status = dcerpc_winreg_DeleteKey(b, mem_ctx, parent,
1817 keyname, &werr);
1818 if (!NT_STATUS_IS_OK(status)) {
1819 werr = ntstatus_to_werror(status);
1820 d_fprintf(stderr, _("dcerpc_winreg_DeleteKey returned %s\n"),
1821 nt_errstr(status));
1822 goto done;
1823 }
1824 if (!W_ERROR_IS_OK(werr)) {
1825 d_fprintf(stderr, _("dcerpc_winreg_DeleteKey returned %s\n"),
1826 win_errstr(werr));
1827 goto done;
1828 }
1829
1830 done:
1831 if ( parent == &hive ) {
1832 WERROR _result;
1833 dcerpc_winreg_CloseKey(b, mem_ctx, parent, &_result);
1834 }
1835
1836 talloc_free(mem_ctx);
1837 return werr;
1838 }
1839
1840 static WERROR import_close_key(struct import_ctx* ctx,
1841 struct policy_handle* key)
1842 {
1843 WERROR werr;
1844 NTSTATUS status;
1845 void* mem_ctx = talloc_new(ctx->mem_ctx);
1846 struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
1847
1848 status = dcerpc_winreg_CloseKey(b, mem_ctx, key, &werr);
1849 if (!NT_STATUS_IS_OK(status)) {
1850 werr = ntstatus_to_werror(status);
1851 d_fprintf(stderr, _("dcerpc_winreg_CloseKey returned %s\n"),
1852 nt_errstr(status));
1853 goto done;
1854 }
1855 if (!W_ERROR_IS_OK(werr)) {
1856 d_fprintf(stderr, _("dcerpc_winreg_CloseKey returned %s\n"),
1857 win_errstr(werr));
1858 goto done;
1859 }
1860
1861 werr = (talloc_free(key) == 0) ? WERR_OK : WERR_GENERAL_FAILURE;
1862 done:
1863 talloc_free(mem_ctx);
1864 return werr;
1865 }
1866
1867 static WERROR import_create_val(struct import_ctx* ctx,
1868 struct policy_handle* parent, const char* name,
1869 uint32_t type, const uint8_t* val, uint32_t len)
1870 {
1871 WERROR werr;
1872 NTSTATUS status;
1873 void* mem_ctx = talloc_new(ctx->mem_ctx);
1874 struct winreg_String valuename;
1875 struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
1876
1877 if (parent == NULL) {
1878 return WERR_INVALID_PARAM;
1879 }
1880
1881 ZERO_STRUCT(valuename);
1882 valuename.name = name;
1883
1884 status = dcerpc_winreg_SetValue(b, mem_ctx, parent,
1885 valuename, type,
1886 (uint8_t *)discard_const(val), len, &werr);
1887 if (!NT_STATUS_IS_OK(status)) {
1888 werr = ntstatus_to_werror(status);
1889 d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
1890 nt_errstr(status));
1891 goto done;
1892 }
1893 if (!W_ERROR_IS_OK(werr)) {
1894 d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
1895 win_errstr(werr));
1896 goto done;
1897 }
1898
1899 done:
1900 talloc_free(mem_ctx);
1901 return werr;
1902 }
1903
1904 static WERROR import_delete_val(struct import_ctx* ctx,
1905 struct policy_handle* parent, const char* name)
1906 {
1907 WERROR werr;
1908 NTSTATUS status;
1909 void* mem_ctx = talloc_new(ctx->mem_ctx);
1910 struct winreg_String valuename;
1911 struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
1912
1913 if (parent == NULL) {
1914 return WERR_INVALID_PARAM;
1915 }
1916
1917 ZERO_STRUCT(valuename);
1918 valuename.name = name;
1919
1920 status = dcerpc_winreg_DeleteValue(b, mem_ctx,
1921 parent, valuename, &werr);
1922
1923 if (!NT_STATUS_IS_OK(status)) {
1924 werr = ntstatus_to_werror(status);
1925 d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
1926 nt_errstr(status));
1927 goto done;
1928 }
1929 if (!NT_STATUS_IS_OK(status)) {
1930 d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
1931 win_errstr(werr));
1932 goto done;
1933 }
1934
1935 done:
1936 talloc_free(mem_ctx);
1937 return werr;
1938 }
1939
1940
1941
1942 static NTSTATUS rpc_registry_import_internal(struct net_context *c,
1943 const struct dom_sid *domain_sid,
1944 const char *domain_name,
1945 struct cli_state *cli,
1946 struct rpc_pipe_client *pipe_hnd,
1947 TALLOC_CTX *mem_ctx,
1948 int argc,
1949 const char **argv )
1950 {
1951 struct import_ctx import_ctx;
1952
1953 struct reg_import_callback import_callback = {
1954 .openkey = NULL,
1955 .closekey = (reg_import_callback_closekey_t)&import_close_key,
1956 .createkey = (reg_import_callback_createkey_t)&import_create_key,
1957 .deletekey = (reg_import_callback_deletekey_t)&import_delete_key,
1958 .deleteval = (reg_import_callback_deleteval_t)&import_delete_val,
1959 .setval.blob = (reg_import_callback_setval_blob_t)&import_create_val,
1960 .setval_type = BLOB,
1961 .data = &import_ctx
1962 };
1963
1964 int ret;
1965 if (argc < 1 || argc > 2 || c->display_usage) {
1966 d_printf("%s\n%s",
1967 _("Usage:"),
1968 _("net rpc registry import <file> [options]\n"));
1969 d_printf("%s net rpc registry export "
1970 "samba.reg enc=CP1252,flags=0\n", _("Example:"));
1971 return NT_STATUS_INVALID_PARAMETER;
1972 }
1973 ZERO_STRUCT(import_ctx);
1974 import_ctx.pipe_hnd = pipe_hnd;
1975 import_ctx.mem_ctx = mem_ctx;
1976 ret = reg_parse_file(argv[0],
1977 reg_import_adapter(import_ctx.mem_ctx,
1978 import_callback
1979 ),
1980 (argc > 1) ? argv[1] : NULL
1981 );
1982
1983 return ret==0 ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1984 }
1985
1986 /********************************************************************
1987 ********************************************************************/
1988
1989 static int rpc_registry_import(struct net_context *c, int argc,
1990 const char **argv )
1991 {
1992 return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1993 rpc_registry_import_internal, argc, argv );
1994 }
1995
1996 /**@}*/
1997 /********************************************************************
1998 ********************************************************************/
1999
2000 int net_rpc_registry(struct net_context *c, int argc, const char **argv)
2001 {
2002 struct functable func[] = {
2003 {
2004 "enumerate",
2005 rpc_registry_enumerate,
2006 NET_TRANSPORT_RPC,
2007 N_("Enumerate registry keys and values"),
2008 N_("net rpc registry enumerate\n"
2009 " Enumerate registry keys and values")
2010 },
2011 {
2012 "createkey",
2013 rpc_registry_createkey,
2014 NET_TRANSPORT_RPC,
2015 N_("Create a new registry key"),
2016 N_("net rpc registry createkey\n"
2017 " Create a new registry key")
2018 },
2019 {
2020 "deletekey",
2021 rpc_registry_deletekey,
2022 NET_TRANSPORT_RPC,
2023 N_("Delete a registry key"),
2024 N_("net rpc registry deletekey\n"
2025 " Delete a registry key")
2026 },
2027 {
2028 "getvalue",
2029 rpc_registry_getvalue,
2030 NET_TRANSPORT_RPC,
2031 N_("Print a registry value"),
2032 N_("net rpc registry getvalue\n"
2033 " Print a registry value")
2034 },
2035 {
2036 "getvalueraw",
2037 rpc_registry_getvalueraw,
2038 NET_TRANSPORT_RPC,
2039 N_("Print a registry value"),
2040 N_("net rpc registry getvalueraw\n"
2041 " Print a registry value (raw version)")
2042 },
2043 {
2044 "setvalue",
2045 rpc_registry_setvalue,
2046 NET_TRANSPORT_RPC,
2047 N_("Set a new registry value"),
2048 N_("net rpc registry setvalue\n"
2049 " Set a new registry value")
2050 },
2051 {
2052 "deletevalue",
2053 rpc_registry_deletevalue,
2054 NET_TRANSPORT_RPC,
2055 N_("Delete a registry value"),
2056 N_("net rpc registry deletevalue\n"
2057 " Delete a registry value")
2058 },
2059 {
2060 "save",
2061 rpc_registry_save,
2062 NET_TRANSPORT_RPC,
2063 N_("Save a registry file"),
2064 N_("net rpc registry save\n"
2065 " Save a registry file")
2066 },
2067 {
2068 "dump",
2069 rpc_registry_dump,
2070 NET_TRANSPORT_RPC,
2071 N_("Dump a registry file"),
2072 N_("net rpc registry dump\n"
2073 " Dump a registry file")
2074 },
2075 {
2076 "copy",
2077 rpc_registry_copy,
2078 NET_TRANSPORT_RPC,
2079 N_("Copy a registry file"),
2080 N_("net rpc registry copy\n"
2081 " Copy a registry file")
2082 },
2083 {
2084 "getsd",
2085 rpc_registry_getsd,
2086 NET_TRANSPORT_RPC,
2087 N_("Get security descriptor"),
2088 N_("net rpc registry getsd\n"
2089 " Get security descriptior")
2090 },
2091 {
2092 "import",
2093 rpc_registry_import,
2094 NET_TRANSPORT_RPC,
2095 N_("Import .reg file"),
2096 N_("net rpc registry import\n"
2097 " Import .reg file")
2098 },
2099 {
2100 "export",
2101 rpc_registry_export,
2102 NET_TRANSPORT_RPC,
2103 N_("net registry export\n"
2104 " Export .reg file")
2105 },
2106 {NULL, NULL, 0, NULL, NULL}
2107 };
2108 return net_run_function(c, argc, argv, "net rpc registry", func);
2109 }
reg import