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