?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
python:tests: make test_export_keytab_nochange_update() more reliable
[Samba.git] / source3 / utils / net_registry.c
blob65b7136583aeb29ebf0d20a60939464b7ede5a11
1 /*
2 * Samba Unix/Linux SMB client library
3 * Distributed SMB/CIFS Server Management Utility
4 * Local registry interface
5 *
6 * Copyright (C) Michael Adam 2008
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "registry.h"
24 #include "registry/reg_api.h"
25 #include "registry/reg_util_token.h"
26 #include "registry/reg_init_basic.h"
27 #include "utils/net.h"
28 #include "utils/net_registry_util.h"
29 #include "include/g_lock.h"
30 #include "registry/reg_backend_db.h"
31 #include "registry/reg_import.h"
32 #include "registry/reg_format.h"
33 #include "registry/reg_api_util.h"
34 #include <assert.h>
35 #include "../libcli/security/display_sec.h"
36 #include "../libcli/security/sddl.h"
37 #include "../libcli/registry/util_reg.h"
38 #include "passdb/machine_sid.h"
39 #include "net_registry_check.h"
40 #include "lib/util/util_tdb.h"
41 #include "lib/util/smb_strtox.h"
42
43 /*
44 *
45 * Helper functions
46 *
47 */
48
49 /**
50 * split given path into hive and remaining path and open the hive key
51 */
52 static WERROR open_hive(TALLOC_CTX *ctx, const char *path,
53 uint32_t desired_access,
54 struct registry_key **hive,
55 char **subkeyname)
56 {
57 WERROR werr;
58 struct security_token *token = NULL;
59 char *hivename = NULL;
60 char *tmp_subkeyname = NULL;
61 TALLOC_CTX *tmp_ctx = talloc_stackframe();
62
63 if ((hive == NULL) || (subkeyname == NULL)) {
64 werr = WERR_INVALID_PARAMETER;
65 goto done;
66 }
67
68 werr = split_hive_key(tmp_ctx, path, &hivename, &tmp_subkeyname);
69 if (!W_ERROR_IS_OK(werr)) {
70 goto done;
71 }
72 *subkeyname = talloc_strdup(ctx, tmp_subkeyname);
73 if (*subkeyname == NULL) {
74 werr = WERR_NOT_ENOUGH_MEMORY;
75 goto done;
76 }
77
78 werr = ntstatus_to_werror(registry_create_admin_token(tmp_ctx, &token));
79 if (!W_ERROR_IS_OK(werr)) {
80 goto done;
81 }
82
83 werr = reg_openhive(ctx, hivename, desired_access, token, hive);
84 if (!W_ERROR_IS_OK(werr)) {
85 goto done;
86 }
87
88 werr = WERR_OK;
89
90 done:
91 TALLOC_FREE(tmp_ctx);
92 return werr;
93 }
94
95 static WERROR open_key(TALLOC_CTX *ctx, const char *path,
96 uint32_t desired_access,
97 struct registry_key **key)
98 {
99 WERROR werr;
100 char *subkey_name = NULL;
101 struct registry_key *hive = NULL;
102 TALLOC_CTX *tmp_ctx = talloc_stackframe();
103
104 if ((path == NULL) || (key == NULL)) {
105 return WERR_INVALID_PARAMETER;
106 }
107
108 werr = open_hive(tmp_ctx, path, desired_access, &hive, &subkey_name);
109 if (!W_ERROR_IS_OK(werr)) {
110 d_fprintf(stderr, _("open_hive failed: %s\n"),
111 win_errstr(werr));
112 goto done;
113 }
114
115 werr = reg_openkey(ctx, hive, subkey_name, desired_access, key);
116 if (!W_ERROR_IS_OK(werr)) {
117 d_fprintf(stderr, _("reg_openkey failed: %s\n"),
118 win_errstr(werr));
119 goto done;
120 }
121
122 werr = WERR_OK;
123
124 done:
125 TALLOC_FREE(tmp_ctx);
126 return werr;
127 }
128
129 static WERROR registry_enumkey(struct registry_key *parent, const char *keyname,
130 bool recursive)
131 {
132 WERROR werr;
133 TALLOC_CTX *ctx = talloc_stackframe();
134 char *subkey_name;
135 NTTIME modtime;
136 uint32_t count;
137 char *valname = NULL;
138 struct registry_value *valvalue = NULL;
139 struct registry_key *key = NULL;
140
141 werr = reg_openkey(ctx, parent, keyname, REG_KEY_READ, &key);
142 if (!W_ERROR_IS_OK(werr)) {
143 goto done;
144 }
145
146 if (recursive) {
147 printf("[%s]\n\n", key->key->name);
148 } else {
149 for (count = 0;
150 werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
151 W_ERROR_IS_OK(werr);
152 count++)
153 {
154 print_registry_key(subkey_name, &modtime);
155 }
156 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
157 goto done;
158 }
159 }
160
161 for (count = 0;
162 werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
163 W_ERROR_IS_OK(werr);
164 count++)
165 {
166 print_registry_value_with_name(valname, valvalue);
167 }
168 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
169 goto done;
170 }
171
172 if (!recursive) {
173 werr = WERR_OK;
174 goto done;
175 }
176
177 for (count = 0;
178 werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
179 W_ERROR_IS_OK(werr);
180 count++)
181 {
182 werr = registry_enumkey(key, subkey_name, recursive);
183 if (!W_ERROR_IS_OK(werr)) {
184 goto done;
185 }
186 }
187 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
188 goto done;
189 }
190
191 werr = WERR_OK;
192
193 done:
194 TALLOC_FREE(ctx);
195 return werr;
196 }
197
198
199
200 /*
201 *
202 * the main "net registry" function implementations
203 *
204 */
205 static int net_registry_enumerate(struct net_context *c, int argc,
206 const char **argv)
207 {
208 WERROR werr;
209 struct registry_key *key = NULL;
210 char *name = NULL;
211 TALLOC_CTX *ctx = talloc_stackframe();
212 int ret = -1;
213
214 if (argc != 1 || c->display_usage) {
215 d_printf("%s\n%s",
216 _("Usage:"),
217 _("net registry enumerate <path>\n"));
218 d_printf("%s\n%s",
219 _("Example:"),
220 _("net registry enumerate 'HKLM\\Software\\Samba'\n"));
221 goto done;
222 }
223
224 werr = open_hive(ctx, argv[0], REG_KEY_READ, &key, &name);
225 if (!W_ERROR_IS_OK(werr)) {
226 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
227 goto done;
228 }
229
230 werr = registry_enumkey(key, name, c->opt_reboot);
231 if (W_ERROR_IS_OK(werr)) {
232 ret = 0;
233 }
234 done:
235 TALLOC_FREE(ctx);
236 return ret;
237 }
238
239 static int net_registry_enumerate_recursive(struct net_context *c, int argc,
240 const char **argv)
241 {
242 WERROR werr;
243 struct registry_key *key = NULL;
244 char *name = NULL;
245 TALLOC_CTX *ctx = talloc_stackframe();
246 int ret = -1;
247
248 if (argc != 1 || c->display_usage) {
249 d_printf("%s\n%s",
250 _("Usage:"),
251 _("net registry enumerate <path>\n"));
252 d_printf("%s\n%s",
253 _("Example:"),
254 _("net registry enumerate 'HKLM\\Software\\Samba'\n"));
255 goto done;
256 }
257
258 werr = open_hive(ctx, argv[0], REG_KEY_READ, &key, &name);
259 if (!W_ERROR_IS_OK(werr)) {
260 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
261 goto done;
262 }
263
264 werr = registry_enumkey(key, name, true);
265 if (W_ERROR_IS_OK(werr)) {
266 ret = 0;
267 }
268 done:
269 TALLOC_FREE(ctx);
270 return ret;
271 }
272
273
274 static int net_registry_createkey(struct net_context *c, int argc,
275 const char **argv)
276 {
277 WERROR werr;
278 enum winreg_CreateAction action;
279 char *subkeyname = NULL;
280 struct registry_key *hivekey = NULL;
281 struct registry_key *subkey = NULL;
282 TALLOC_CTX *ctx = talloc_stackframe();
283 int ret = -1;
284
285 if (argc != 1 || c->display_usage) {
286 d_printf("%s\n%s",
287 _("Usage:"),
288 _("net registry createkey <path>\n"));
289 d_printf("%s\n%s",
290 _("Example:"),
291 _("net registry createkey "
292 "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n"));
293 goto done;
294 }
295 if (strlen(argv[0]) == 0) {
296 d_fprintf(stderr, _("error: zero length key name given\n"));
297 goto done;
298 }
299
300 werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
301 if (!W_ERROR_IS_OK(werr)) {
302 d_fprintf(stderr, _("open_hive failed: %s\n"),
303 win_errstr(werr));
304 goto done;
305 }
306
307 werr = reg_createkey(ctx, hivekey, subkeyname, REG_KEY_WRITE,
308 &subkey, &action);
309 if (!W_ERROR_IS_OK(werr)) {
310 d_fprintf(stderr, _("reg_createkey failed: %s\n"),
311 win_errstr(werr));
312 goto done;
313 }
314 switch (action) {
315 case REG_ACTION_NONE:
316 d_printf(_("createkey did nothing -- huh?\n"));
317 break;
318 case REG_CREATED_NEW_KEY:
319 d_printf(_("createkey created %s\n"), argv[0]);
320 break;
321 case REG_OPENED_EXISTING_KEY:
322 d_printf(_("createkey opened existing %s\n"), argv[0]);
323 break;
324 }
325
326 ret = 0;
327
328 done:
329 TALLOC_FREE(ctx);
330 return ret;
331 }
332
333 static int net_registry_deletekey_internal(struct net_context *c, int argc,
334 const char **argv,
335 bool recursive)
336 {
337 WERROR werr;
338 char *subkeyname = NULL;
339 struct registry_key *hivekey = NULL;
340 TALLOC_CTX *ctx = talloc_stackframe();
341 int ret = -1;
342
343 if (argc != 1 || c->display_usage) {
344 d_printf("%s\n%s",
345 _("Usage:"),
346 _("net registry deletekey <path>\n"));
347 d_printf("%s\n%s",
348 _("Example:"),
349 _("net registry deletekey "
350 "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n"));
351 goto done;
352 }
353 if (strlen(argv[0]) == 0) {
354 d_fprintf(stderr, _("error: zero length key name given\n"));
355 goto done;
356 }
357
358 werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
359 if (!W_ERROR_IS_OK(werr)) {
360 d_fprintf(stderr, "open_hive %s: %s\n", _("failed"),
361 win_errstr(werr));
362 goto done;
363 }
364
365 if (recursive) {
366 werr = reg_deletekey_recursive(hivekey, subkeyname);
367 } else {
368 werr = reg_deletekey(hivekey, subkeyname);
369 }
370 if (!W_ERROR_IS_OK(werr) &&
371 !(c->opt_force && W_ERROR_EQUAL(werr, WERR_FILE_NOT_FOUND)))
372 {
373 d_fprintf(stderr, "reg_deletekey %s: %s\n", _("failed"),
374 win_errstr(werr));
375 goto done;
376 }
377
378 ret = 0;
379
380 done:
381 TALLOC_FREE(ctx);
382 return ret;
383 }
384
385 static int net_registry_deletekey(struct net_context *c, int argc,
386 const char **argv)
387 {
388 return net_registry_deletekey_internal(c, argc, argv, false);
389 }
390
391 static int net_registry_deletekey_recursive(struct net_context *c, int argc,
392 const char **argv)
393 {
394 return net_registry_deletekey_internal(c, argc, argv, true);
395 }
396
397 static int net_registry_getvalue_internal(struct net_context *c, int argc,
398 const char **argv, bool raw)
399 {
400 WERROR werr;
401 int ret = -1;
402 struct registry_key *key = NULL;
403 struct registry_value *value = NULL;
404 TALLOC_CTX *ctx = talloc_stackframe();
405
406 if (argc != 2 || c->display_usage) {
407 d_fprintf(stderr, "%s\n%s",
408 _("Usage:"),
409 _("net registry getvalue <key> <valuename>\n"));
410 goto done;
411 }
412
413 werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
414 if (!W_ERROR_IS_OK(werr)) {
415 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
416 goto done;
417 }
418
419 werr = reg_queryvalue(ctx, key, argv[1], &value);
420 if (!W_ERROR_IS_OK(werr)) {
421 d_fprintf(stderr, _("reg_queryvalue failed: %s\n"),
422 win_errstr(werr));
423 goto done;
424 }
425
426 print_registry_value(value, raw);
427
428 ret = 0;
429
430 done:
431 TALLOC_FREE(ctx);
432 return ret;
433 }
434
435 static int net_registry_getvalue(struct net_context *c, int argc,
436 const char **argv)
437 {
438 return net_registry_getvalue_internal(c, argc, argv, false);
439 }
440
441 static int net_registry_getvalueraw(struct net_context *c, int argc,
442 const char **argv)
443 {
444 return net_registry_getvalue_internal(c, argc, argv, true);
445 }
446
447 static int net_registry_getvaluesraw(struct net_context *c, int argc,
448 const char **argv)
449 {
450 WERROR werr;
451 int ret = -1;
452 struct registry_key *key = NULL;
453 TALLOC_CTX *ctx = talloc_stackframe();
454 uint32_t idx;
455
456 if (argc != 1 || c->display_usage) {
457 d_fprintf(stderr, "usage: net rpc registry getvaluesraw "
458 "<key>\n");
459 goto done;
460 }
461
462 werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
463 if (!W_ERROR_IS_OK(werr)) {
464 d_fprintf(stderr, "open_key failed: %s\n", win_errstr(werr));
465 goto done;
466 }
467
468 idx = 0;
469 while (true) {
470 struct registry_value *val;
471
472 werr = reg_enumvalue(talloc_tos(), key, idx, NULL, &val);
473
474 if (W_ERROR_EQUAL(werr, WERR_NO_MORE_ITEMS)) {
475 ret = 0;
476 break;
477 }
478 if (!W_ERROR_IS_OK(werr)) {
479 break;
480 }
481 print_registry_value(val, true);
482 TALLOC_FREE(val);
483 idx += 1;
484 }
485 done:
486 TALLOC_FREE(ctx);
487 return ret;
488 }
489
490 static int net_registry_setvalue(struct net_context *c, int argc,
491 const char **argv)
492 {
493 WERROR werr;
494 struct registry_value value;
495 struct registry_key *key = NULL;
496 int ret = -1;
497 TALLOC_CTX *ctx = talloc_stackframe();
498
499 if (argc < 4 || c->display_usage) {
500 d_fprintf(stderr, "%s\n%s",
501 _("Usage:"),
502 _("net registry setvalue <key> <valuename> "
503 "<type> [<val>]+\n"));
504 goto done;
505 }
506
507 if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
508 d_fprintf(stderr, _("Too many args for type %s\n"), argv[2]);
509 goto done;
510 }
511
512 if (strequal(argv[2], "dword")) {
513 int error = 0;
514 uint32_t v;
515
516 v = smb_strtoul(argv[3], NULL, 10, &error, SMB_STR_STANDARD);
517 if (error != 0) {
518 goto done;
519 }
520
521 value.type = REG_DWORD;
522 value.data = data_blob_talloc(ctx, NULL, 4);
523 SIVAL(value.data.data, 0, v);
524 } else if (strequal(argv[2], "sz")) {
525 value.type = REG_SZ;
526 if (!push_reg_sz(ctx, &value.data, argv[3])) {
527 goto done;
528 }
529 } else if (strequal(argv[2], "multi_sz")) {
530 const char **array;
531 int count = argc - 3;
532 int i;
533 value.type = REG_MULTI_SZ;
534 array = talloc_zero_array(ctx, const char *, count + 1);
535 if (array == NULL) {
536 goto done;
537 }
538 for (i=0; i < count; i++) {
539 array[i] = talloc_strdup(array, argv[count+i]);
540 if (array[i] == NULL) {
541 goto done;
542 }
543 }
544 if (!push_reg_multi_sz(ctx, &value.data, array)) {
545 goto done;
546 }
547 } else {
548 d_fprintf(stderr, _("type \"%s\" not implemented\n"), argv[2]);
549 goto done;
550 }
551
552 werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
553 if (!W_ERROR_IS_OK(werr)) {
554 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
555 goto done;
556 }
557
558 werr = reg_setvalue(key, argv[1], &value);
559 if (!W_ERROR_IS_OK(werr)) {
560 d_fprintf(stderr, _("reg_setvalue failed: %s\n"),
561 win_errstr(werr));
562 goto done;
563 }
564
565 ret = 0;
566
567 done:
568 TALLOC_FREE(ctx);
569 return ret;
570 }
571
572 static int net_registry_increment(struct net_context *c, int argc,
573 const char **argv)
574 {
575 TDB_DATA lock_key = string_term_tdb_data("registry_increment_lock");
576 struct g_lock_ctx *ctx = NULL;
577 const char *keyname = NULL;
578 struct registry_key *key = NULL;
579 const char *valuename = NULL;
580 struct registry_value *value = NULL;
581 uint32_t v;
582 uint32_t increment;
583 uint32_t newvalue;
584 NTSTATUS status;
585 WERROR werr;
586 int ret = -1;
587
588 if (argc < 2 || c->display_usage) {
589 d_fprintf(stderr, "%s\n%s",
590 _("Usage:"),
591 _("net registry increment <key> <valuename> "
592 "[<increment>]\n"));
593 goto done;
594 }
595
596 keyname = argv[0];
597 valuename = argv[1];
598
599 increment = 1;
600 if (argc == 3) {
601 int error = 0;
602
603 increment = smb_strtoul(
604 argv[2], NULL, 10, &error, SMB_STR_STANDARD);
605 if (error != 0) {
606 goto done;
607 }
608 }
609
610 ctx = g_lock_ctx_init(c, c->msg_ctx);
611 if (ctx == NULL) {
612 d_fprintf(stderr, _("g_lock_ctx_init failed\n"));
613 goto done;
614 }
615
616 status = g_lock_lock(ctx,
617 lock_key,
618 G_LOCK_WRITE,
619 tevent_timeval_set(600, 0),
620 NULL,
621 NULL);
622 if (!NT_STATUS_IS_OK(status)) {
623 d_fprintf(stderr, _("g_lock_lock failed: %s\n"),
624 nt_errstr(status));
625 goto done;
626 }
627
628 werr = open_key(c, keyname, REG_KEY_READ|REG_KEY_WRITE, &key);
629 if (!W_ERROR_IS_OK(werr)) {
630 d_fprintf(stderr, _("open_key failed: %s\n"),
631 win_errstr(werr));
632 goto done;
633 }
634
635 werr = reg_queryvalue(key, key, valuename, &value);
636 if (!W_ERROR_IS_OK(werr)) {
637 d_fprintf(stderr, _("reg_queryvalue failed: %s\n"),
638 win_errstr(werr));
639 goto done;
640 }
641
642 if (value->type != REG_DWORD) {
643 d_fprintf(stderr, _("value not a DWORD: %s\n"),
644 str_regtype(value->type));
645 goto done;
646 }
647
648 if (value->data.length < 4) {
649 d_fprintf(stderr, _("value too short for regular DWORD\n"));
650 goto done;
651 }
652
653 v = IVAL(value->data.data, 0);
654 v += increment;
655 newvalue = v;
656
657 SIVAL(value->data.data, 0, v);
658
659 werr = reg_setvalue(key, valuename, value);
660 if (!W_ERROR_IS_OK(werr)) {
661 d_fprintf(stderr, _("reg_setvalue failed: %s\n"),
662 win_errstr(werr));
663 goto done;
664 }
665
666 if (!W_ERROR_IS_OK(werr)) {
667 d_fprintf(stderr, _("increment failed: %s\n"),
668 win_errstr(werr));
669 goto done;
670 }
671
672 g_lock_unlock(ctx, lock_key);
673
674 d_printf(_("%"PRIu32"\n"), newvalue);
675
676 ret = 0;
677
678 done:
679 TALLOC_FREE(value);
680 TALLOC_FREE(key);
681 TALLOC_FREE(ctx);
682 return ret;
683 }
684
685 static int net_registry_deletevalue(struct net_context *c, int argc,
686 const char **argv)
687 {
688 WERROR werr;
689 struct registry_key *key = NULL;
690 TALLOC_CTX *ctx = talloc_stackframe();
691 int ret = -1;
692
693 if (argc != 2 || c->display_usage) {
694 d_fprintf(stderr, "%s\n%s",
695 _("Usage:"),
696 _("net registry deletevalue <key> <valuename>\n"));
697 goto done;
698 }
699
700 werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
701 if (!W_ERROR_IS_OK(werr)) {
702 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
703 goto done;
704 }
705
706 werr = reg_deletevalue(key, argv[1]);
707 if (!W_ERROR_IS_OK(werr)) {
708 d_fprintf(stderr, _("reg_deletevalue failed: %s\n"),
709 win_errstr(werr));
710 goto done;
711 }
712
713 ret = 0;
714
715 done:
716 TALLOC_FREE(ctx);
717 return ret;
718 }
719
720 static WERROR net_registry_getsd_internal(struct net_context *c,
721 TALLOC_CTX *mem_ctx,
722 const char *keyname,
723 struct security_descriptor **sd)
724 {
725 WERROR werr;
726 struct registry_key *key = NULL;
727 TALLOC_CTX *ctx = talloc_stackframe();
728 uint32_t access_mask = REG_KEY_READ |
729 SEC_FLAG_MAXIMUM_ALLOWED |
730 SEC_FLAG_SYSTEM_SECURITY;
731
732 /*
733 * net_rpc_regsitry uses SEC_FLAG_SYSTEM_SECURITY, but access
734 * is denied with these perms right now...
735 */
736 access_mask = REG_KEY_READ;
737
738 if (sd == NULL) {
739 d_fprintf(stderr, _("internal error: invalid argument\n"));
740 werr = WERR_INVALID_PARAMETER;
741 goto done;
742 }
743
744 if (strlen(keyname) == 0) {
745 d_fprintf(stderr, _("error: zero length key name given\n"));
746 werr = WERR_INVALID_PARAMETER;
747 goto done;
748 }
749
750 werr = open_key(ctx, keyname, access_mask, &key);
751 if (!W_ERROR_IS_OK(werr)) {
752 d_fprintf(stderr, "%s%s\n", _("open_key failed: "),
753 win_errstr(werr));
754 goto done;
755 }
756
757 werr = reg_getkeysecurity(mem_ctx, key, sd);
758 if (!W_ERROR_IS_OK(werr)) {
759 d_fprintf(stderr, "%s%s\n", _("reg_getkeysecurity failed: "),
760 win_errstr(werr));
761 goto done;
762 }
763
764 werr = WERR_OK;
765
766 done:
767 TALLOC_FREE(ctx);
768 return werr;
769 }
770
771 static int net_registry_getsd(struct net_context *c, int argc,
772 const char **argv)
773 {
774 WERROR werr;
775 int ret = -1;
776 struct security_descriptor *secdesc = NULL;
777 TALLOC_CTX *ctx = talloc_stackframe();
778
779 if (argc != 1 || c->display_usage) {
780 d_printf("%s\n%s",
781 _("Usage:"),
782 _("net registry getsd <path>\n"));
783 d_printf("%s\n%s",
784 _("Example:"),
785 _("net registry getsd 'HKLM\\Software\\Samba'\n"));
786 goto done;
787 }
788
789 werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
790 if (!W_ERROR_IS_OK(werr)) {
791 goto done;
792 }
793
794 display_sec_desc(secdesc);
795
796 ret = 0;
797
798 done:
799 TALLOC_FREE(ctx);
800 return ret;
801 }
802
803 static int net_registry_getsd_sddl(struct net_context *c,
804 int argc, const char **argv)
805 {
806 WERROR werr;
807 int ret = -1;
808 struct security_descriptor *secdesc = NULL;
809 TALLOC_CTX *ctx = talloc_stackframe();
810
811 if (argc != 1 || c->display_usage) {
812 d_printf("%s\n%s",
813 _("Usage:"),
814 _("net registry getsd_sddl <path>\n"));
815 d_printf("%s\n%s",
816 _("Example:"),
817 _("net registry getsd_sddl 'HKLM\\Software\\Samba'\n"));
818 goto done;
819 }
820
821 werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
822 if (!W_ERROR_IS_OK(werr)) {
823 goto done;
824 }
825
826 d_printf("%s\n", sddl_encode(ctx, secdesc, get_global_sam_sid()));
827
828 ret = 0;
829
830 done:
831 TALLOC_FREE(ctx);
832 return ret;
833 }
834
835 static WERROR net_registry_setsd_internal(struct net_context *c,
836 TALLOC_CTX *mem_ctx,
837 const char *keyname,
838 struct security_descriptor *sd)
839 {
840 WERROR werr;
841 struct registry_key *key = NULL;
842 TALLOC_CTX *ctx = talloc_stackframe();
843 uint32_t access_mask = REG_KEY_WRITE |
844 SEC_FLAG_MAXIMUM_ALLOWED |
845 SEC_FLAG_SYSTEM_SECURITY;
846
847 /*
848 * net_rpc_regsitry uses SEC_FLAG_SYSTEM_SECURITY, but access
849 * is denied with these perms right now...
850 */
851 access_mask = REG_KEY_WRITE;
852
853 if (strlen(keyname) == 0) {
854 d_fprintf(stderr, _("error: zero length key name given\n"));
855 werr = WERR_INVALID_PARAMETER;
856 goto done;
857 }
858
859 werr = open_key(ctx, keyname, access_mask, &key);
860 if (!W_ERROR_IS_OK(werr)) {
861 d_fprintf(stderr, "%s%s\n", _("open_key failed: "),
862 win_errstr(werr));
863 goto done;
864 }
865
866 werr = reg_setkeysecurity(key, sd);
867 if (!W_ERROR_IS_OK(werr)) {
868 d_fprintf(stderr, "%s%s\n", _("reg_setkeysecurity failed: "),
869 win_errstr(werr));
870 goto done;
871 }
872
873 werr = WERR_OK;
874
875 done:
876 TALLOC_FREE(ctx);
877 return werr;
878 }
879
880 static int net_registry_setsd_sddl(struct net_context *c,
881 int argc, const char **argv)
882 {
883 WERROR werr;
884 int ret = -1;
885 struct security_descriptor *secdesc = NULL;
886 TALLOC_CTX *ctx = talloc_stackframe();
887
888 if (argc != 2 || c->display_usage) {
889 d_printf("%s\n%s",
890 _("Usage:"),
891 _("net registry setsd_sddl <path> <security_descriptor>\n"));
892 d_printf("%s\n%s",
893 _("Example:"),
894 _("net registry setsd_sddl 'HKLM\\Software\\Samba'\n"));
895 goto done;
896 }
897
898 secdesc = sddl_decode(ctx, argv[1], get_global_sam_sid());
899 if (secdesc == NULL) {
900 goto done;
901 }
902
903 werr = net_registry_setsd_internal(c, ctx, argv[0], secdesc);
904 if (!W_ERROR_IS_OK(werr)) {
905 goto done;
906 }
907
908 ret = 0;
909
910 done:
911 TALLOC_FREE(ctx);
912 return ret;
913 }
914
915 /******************************************************************************/
916 /**
917 * @defgroup net_registry net registry
918 */
919
920 /**
921 * @defgroup net_registry_import Import
922 * @ingroup net_registry
923 * @{
924 */
925
926 struct import_ctx {
927 TALLOC_CTX *mem_ctx;
928 };
929
930
931 static WERROR import_create_key(struct import_ctx *ctx,
932 struct registry_key *parent,
933 const char *name, void **pkey, bool *existing)
934 {
935 WERROR werr;
936 TALLOC_CTX *mem_ctx = talloc_new(ctx->mem_ctx);
937
938 struct registry_key *key = NULL;
939 enum winreg_CreateAction action;
940
941 if (parent == NULL) {
942 char *subkeyname = NULL;
943 werr = open_hive(mem_ctx, name, REG_KEY_WRITE,
944 &parent, &subkeyname);
945 if (!W_ERROR_IS_OK(werr)) {
946 d_fprintf(stderr, _("open_hive failed: %s\n"),
947 win_errstr(werr));
948 goto done;
949 }
950 name = subkeyname;
951 }
952
953 action = REG_ACTION_NONE;
954 werr = reg_createkey(mem_ctx, parent, name, REG_KEY_WRITE,
955 &key, &action);
956 if (!W_ERROR_IS_OK(werr)) {
957 d_fprintf(stderr, _("reg_createkey failed: %s\n"),
958 win_errstr(werr));
959 goto done;
960 }
961
962 if (action == REG_ACTION_NONE) {
963 d_fprintf(stderr, _("createkey did nothing -- huh?\n"));
964 werr = WERR_CREATE_FAILED;
965 goto done;
966 }
967
968 if (existing != NULL) {
969 *existing = (action == REG_OPENED_EXISTING_KEY);
970 }
971
972 if (pkey!=NULL) {
973 *pkey = talloc_steal(ctx->mem_ctx, key);
974 }
975
976 done:
977 talloc_free(mem_ctx);
978 return werr;
979 }
980
981 static WERROR import_close_key(struct import_ctx *ctx,
982 struct registry_key *key)
983 {
984 return WERR_OK;
985 }
986
987 static WERROR import_delete_key(struct import_ctx *ctx,
988 struct registry_key *parent, const char *name)
989 {
990 WERROR werr;
991 TALLOC_CTX *mem_ctx = talloc_new(talloc_tos());
992
993 if (parent == NULL) {
994 char *subkeyname = NULL;
995 werr = open_hive(mem_ctx, name, REG_KEY_WRITE,
996 &parent, &subkeyname);
997 if (!W_ERROR_IS_OK(werr)) {
998 d_fprintf(stderr, _("open_hive failed: %s\n"),
999 win_errstr(werr));
1000 goto done;
1001 }
1002 name = subkeyname;
1003 }
1004
1005 werr = reg_deletekey_recursive(parent, name);
1006 if (!W_ERROR_IS_OK(werr)) {
1007 d_fprintf(stderr, "reg_deletekey_recursive %s: %s\n",
1008 _("failed"), win_errstr(werr));
1009 goto done;
1010 }
1011
1012 done:
1013 talloc_free(mem_ctx);
1014 return werr;
1015 }
1016
1017 static WERROR import_create_val (struct import_ctx *ctx,
1018 struct registry_key *parent, const char *name,
1019 const struct registry_value *value)
1020 {
1021 WERROR werr;
1022
1023 if (parent == NULL) {
1024 return WERR_INVALID_PARAMETER;
1025 }
1026
1027 werr = reg_setvalue(parent, name, value);
1028 if (!W_ERROR_IS_OK(werr)) {
1029 d_fprintf(stderr, _("reg_setvalue failed: %s\n"),
1030 win_errstr(werr));
1031 }
1032 return werr;
1033 }
1034
1035 static WERROR import_delete_val (struct import_ctx *ctx,
1036 struct registry_key *parent, const char *name)
1037 {
1038 WERROR werr;
1039
1040 if (parent == NULL) {
1041 return WERR_INVALID_PARAMETER;
1042 }
1043
1044 werr = reg_deletevalue(parent, name);
1045 if (!W_ERROR_IS_OK(werr)) {
1046 d_fprintf(stderr, _("reg_deletevalue failed: %s\n"),
1047 win_errstr(werr));
1048 }
1049
1050 return werr;
1051 }
1052
1053 struct precheck_ctx {
1054 TALLOC_CTX *mem_ctx;
1055 bool failed;
1056 };
1057
1058 static WERROR precheck_create_key(struct precheck_ctx *ctx,
1059 struct registry_key *parent,
1060 const char *name, void **pkey, bool *existing)
1061 {
1062 WERROR werr;
1063 TALLOC_CTX *frame = talloc_stackframe();
1064 struct registry_key *key = NULL;
1065
1066 if (parent == NULL) {
1067 char *subkeyname = NULL;
1068 werr = open_hive(frame, name, REG_KEY_READ,
1069 &parent, &subkeyname);
1070 if (!W_ERROR_IS_OK(werr)) {
1071 d_printf("Precheck: open_hive of [%s] failed: %s\n",
1072 name, win_errstr(werr));
1073 goto done;
1074 }
1075 name = subkeyname;
1076 }
1077
1078 werr = reg_openkey(frame, parent, name, 0, &key);
1079 if (!W_ERROR_IS_OK(werr)) {
1080 d_printf("Precheck: openkey [%s] failed: %s\n",
1081 name, win_errstr(werr));
1082 goto done;
1083 }
1084
1085 if (existing != NULL) {
1086 *existing = true;
1087 }
1088
1089 if (pkey != NULL) {
1090 *pkey = talloc_steal(ctx->mem_ctx, key);
1091 }
1092
1093 done:
1094 talloc_free(frame);
1095 ctx->failed = !W_ERROR_IS_OK(werr);
1096 return werr;
1097 }
1098
1099 static WERROR precheck_close_key(struct precheck_ctx *ctx,
1100 struct registry_key *key)
1101 {
1102 talloc_free(key);
1103 return WERR_OK;
1104 }
1105
1106 static WERROR precheck_delete_key(struct precheck_ctx *ctx,
1107 struct registry_key *parent, const char *name)
1108 {
1109 WERROR werr;
1110 TALLOC_CTX *frame = talloc_stackframe();
1111 struct registry_key *key;
1112
1113 if (parent == NULL) {
1114 char *subkeyname = NULL;
1115 werr = open_hive(frame, name, REG_KEY_READ,
1116 &parent, &subkeyname);
1117 if (!W_ERROR_IS_OK(werr)) {
1118 d_printf("Precheck: open_hive of [%s] failed: %s\n",
1119 name, win_errstr(werr));
1120 goto done;
1121 }
1122 name = subkeyname;
1123 }
1124
1125 werr = reg_openkey(ctx->mem_ctx, parent, name, 0, &key);
1126 if (W_ERROR_IS_OK(werr)) {
1127 d_printf("Precheck: key [%s\\%s] should not exist\n",
1128 parent->key->name, name);
1129 werr = WERR_FILE_EXISTS;
1130 } else if (W_ERROR_EQUAL(werr, WERR_FILE_NOT_FOUND)) {
1131 werr = WERR_OK;
1132 } else {
1133 d_printf("Precheck: openkey [%s\\%s] failed: %s\n",
1134 parent->key->name, name, win_errstr(werr));
1135 }
1136
1137 done:
1138 talloc_free(frame);
1139 ctx->failed = !W_ERROR_IS_OK(werr);
1140 return werr;
1141 }
1142
1143 static int registry_value_cmp(
1144 const struct registry_value* v1, const struct registry_value* v2)
1145 {
1146 if (v1->type == v2->type) {
1147 return data_blob_cmp(&v1->data, &v2->data);
1148 }
1149 return NUMERIC_CMP(v1->type, v2->type);
1150 }
1151
1152 static WERROR precheck_create_val(struct precheck_ctx *ctx,
1153 struct registry_key *parent,
1154 const char *name,
1155 const struct registry_value *value)
1156 {
1157 TALLOC_CTX *frame = talloc_stackframe();
1158 struct registry_value *old;
1159 WERROR werr;
1160
1161 SMB_ASSERT(parent);
1162
1163 werr = reg_queryvalue(frame, parent, name, &old);
1164 if (!W_ERROR_IS_OK(werr)) {
1165 d_printf("Precheck: queryvalue \"%s\" of [%s] failed: %s\n",
1166 name, parent->key->name, win_errstr(werr));
1167 goto done;
1168 }
1169 if (registry_value_cmp(value, old) != 0) {
1170 d_printf("Precheck: unexpected value \"%s\" of key [%s]\n",
1171 name, parent->key->name);
1172 ctx->failed = true;
1173 }
1174 done:
1175 talloc_free(frame);
1176 return werr;
1177 }
1178
1179 static WERROR precheck_delete_val(struct precheck_ctx *ctx,
1180 struct registry_key *parent,
1181 const char *name)
1182 {
1183 TALLOC_CTX *frame = talloc_stackframe();
1184 struct registry_value *old;
1185 WERROR werr;
1186
1187 SMB_ASSERT(parent);
1188
1189 werr = reg_queryvalue(frame, parent, name, &old);
1190 if (W_ERROR_IS_OK(werr)) {
1191 d_printf("Precheck: value \"%s\" of key [%s] should not exist\n",
1192 name, parent->key->name);
1193 werr = WERR_FILE_EXISTS;
1194 } else if (W_ERROR_EQUAL(werr, WERR_FILE_NOT_FOUND)) {
1195 werr = WERR_OK;
1196 } else {
1197 printf("Precheck: queryvalue \"%s\" of key [%s] failed: %s\n",
1198 name, parent->key->name, win_errstr(werr));
1199 }
1200
1201 talloc_free(frame);
1202 ctx->failed = !W_ERROR_IS_OK(werr);
1203 return werr;
1204 }
1205
1206 static bool import_precheck(const char *fname, const char *parse_options)
1207 {
1208 TALLOC_CTX *mem_ctx = talloc_tos();
1209 struct precheck_ctx precheck_ctx = {
1210 .mem_ctx = mem_ctx,
1211 .failed = false,
1212 };
1213 struct reg_import_callback precheck_callback = {
1214 .openkey = NULL,
1215 .closekey = (reg_import_callback_closekey_t)&precheck_close_key,
1216 .createkey = (reg_import_callback_createkey_t)&precheck_create_key,
1217 .deletekey = (reg_import_callback_deletekey_t)&precheck_delete_key,
1218 .deleteval = (reg_import_callback_deleteval_t)&precheck_delete_val,
1219 .setval = {
1220 .registry_value = (reg_import_callback_setval_registry_value_t)
1221 &precheck_create_val,
1222 },
1223 .setval_type = REGISTRY_VALUE,
1224 .data = &precheck_ctx
1225 };
1226 struct reg_parse_callback *parse_callback;
1227 int ret;
1228
1229 if (!fname) {
1230 return true;
1231 }
1232
1233 parse_callback = reg_import_adapter(mem_ctx, precheck_callback);
1234 if (parse_callback == NULL) {
1235 d_printf("talloc failed\n");
1236 return false;
1237 }
1238
1239 ret = reg_parse_file(fname, parse_callback, parse_options);
1240
1241 if (ret < 0 || precheck_ctx.failed) {
1242 d_printf("Precheck failed\n");
1243 return false;
1244 }
1245 return true;
1246 }
1247
1248 static int import_with_precheck_action(const char *import_fname,
1249 const char *precheck_fname,
1250 const char *parse_options)
1251 {
1252 TALLOC_CTX *frame = talloc_stackframe();
1253 struct import_ctx import_ctx = {
1254 .mem_ctx = frame,
1255 };
1256 struct reg_import_callback import_callback = {
1257 .openkey = NULL,
1258 .closekey = (reg_import_callback_closekey_t)&import_close_key,
1259 .createkey = (reg_import_callback_createkey_t)&import_create_key,
1260 .deletekey = (reg_import_callback_deletekey_t)&import_delete_key,
1261 .deleteval = (reg_import_callback_deleteval_t)&import_delete_val,
1262 .setval = {
1263 .registry_value = (reg_import_callback_setval_registry_value_t)
1264 &import_create_val,
1265 },
1266 .setval_type = REGISTRY_VALUE,
1267 .data = &import_ctx
1268 };
1269 struct reg_parse_callback *parse_callback;
1270 int ret = -1;
1271 bool precheck_ok;
1272
1273 precheck_ok = import_precheck(precheck_fname, parse_options);
1274 if (!precheck_ok) {
1275 goto done;
1276 }
1277
1278 parse_callback = reg_import_adapter(frame, import_callback);
1279 if (parse_callback == NULL) {
1280 d_printf("talloc failed\n");
1281 goto done;
1282 }
1283
1284 ret = reg_parse_file(import_fname, parse_callback, parse_options);
1285
1286 done:
1287 talloc_free(frame);
1288 return ret;
1289 }
1290
1291 static int net_registry_import(struct net_context *c, int argc,
1292 const char **argv)
1293 {
1294 const char *parse_options = (argc > 1) ? argv[1] : NULL;
1295 int ret = -1;
1296 WERROR werr;
1297
1298 if (argc < 1 || argc > 2 || c->display_usage) {
1299 d_printf("%s\n%s",
1300 _("Usage:"),
1301 _("net registry import <reg> [options]\n"));
1302 d_printf("%s\n%s",
1303 _("Example:"),
1304 _("net registry import file.reg enc=CP1252\n"));
1305 return -1;
1306 }
1307
1308 werr = regdb_open();
1309 if (!W_ERROR_IS_OK(werr)) {
1310 d_printf("Failed to open regdb: %s\n", win_errstr(werr));
1311 return -1;
1312 }
1313
1314 werr = regdb_transaction_start();
1315 if (!W_ERROR_IS_OK(werr)) {
1316 d_printf("Failed to start transaction on regdb: %s\n",
1317 win_errstr(werr));
1318 goto done;
1319 }
1320
1321 ret = import_with_precheck_action(argv[0], c->opt_precheck,
1322 parse_options);
1323
1324 if (ret < 0) {
1325 d_printf("Transaction canceled!\n");
1326 regdb_transaction_cancel();
1327 goto done;
1328 }
1329
1330 SMB_ASSERT(ret == 0);
1331
1332 if (c->opt_testmode) {
1333 d_printf("Testmode: not committing changes.\n");
1334 regdb_transaction_cancel();
1335 goto done;
1336 }
1337
1338 werr = regdb_transaction_commit();
1339 if (!W_ERROR_IS_OK(werr)) {
1340 d_printf("Failed to commit transaction on regdb: %s\n",
1341 win_errstr(werr));
1342 ret = -1;
1343 }
1344
1345 done:
1346 regdb_close();
1347 return ret;
1348 }
1349 /**@}*/
1350
1351 /******************************************************************************/
1352
1353 /**
1354 * @defgroup net_registry_export Export
1355 * @ingroup net_registry
1356 * @{
1357 */
1358
1359 static int registry_export(TALLOC_CTX *ctx, /*const*/ struct registry_key *key,
1360 struct reg_format *f)
1361 {
1362 int ret=-1;
1363 WERROR werr;
1364 uint32_t count;
1365
1366 struct registry_value *valvalue = NULL;
1367 char *valname = NULL;
1368
1369 char *subkey_name = NULL;
1370 NTTIME modtime = 0;
1371
1372 reg_format_registry_key(f, key, false);
1373
1374 /* print values */
1375 for (count = 0;
1376 werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
1377 W_ERROR_IS_OK(werr);
1378 count++)
1379 {
1380 reg_format_registry_value(f, valname, valvalue);
1381 }
1382 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
1383 d_fprintf(stderr, _("reg_enumvalue failed: %s\n"),
1384 win_errstr(werr));
1385 goto done;
1386 }
1387
1388 /* recurse on subkeys */
1389 for (count = 0;
1390 werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
1391 W_ERROR_IS_OK(werr);
1392 count++)
1393 {
1394 struct registry_key *subkey = NULL;
1395
1396 werr = reg_openkey(ctx, key, subkey_name, REG_KEY_READ,
1397 &subkey);
1398 if (!W_ERROR_IS_OK(werr)) {
1399 d_fprintf(stderr, _("reg_openkey failed: %s\n"),
1400 win_errstr(werr));
1401 goto done;
1402 }
1403
1404 registry_export(ctx, subkey, f);
1405 TALLOC_FREE(subkey);
1406 }
1407 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
1408 d_fprintf(stderr, _("reg_enumkey failed: %s\n"),
1409 win_errstr(werr));
1410 goto done;
1411 }
1412 ret = 0;
1413 done:
1414 return ret;
1415 }
1416
1417 static int net_registry_export(struct net_context *c, int argc,
1418 const char **argv)
1419 {
1420 int ret=-1;
1421 WERROR werr;
1422 struct registry_key *key = NULL;
1423 TALLOC_CTX *ctx = talloc_stackframe();
1424 struct reg_format *f=NULL;
1425
1426 if (argc < 2 || argc > 3 || c->display_usage) {
1427 d_printf("%s\n%s",
1428 _("Usage:"),
1429 _("net registry export <path> <file> [opt]\n"));
1430 d_printf("%s\n%s",
1431 _("Example:"),
1432 _("net registry export 'HKLM\\Software\\Samba' "
1433 "samba.reg regedit5\n"));
1434 goto done;
1435 }
1436
1437 werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
1438 if (!W_ERROR_IS_OK(werr)) {
1439 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
1440 goto done;
1441 }
1442
1443 f = reg_format_file(ctx, argv[1], (argc > 2) ? argv[2] : NULL);
1444 if (f == NULL) {
1445 d_fprintf(stderr, _("open file failed: %s\n"), strerror(errno));
1446 goto done;
1447 }
1448
1449 ret = registry_export(ctx, key, f);
1450
1451 done:
1452 TALLOC_FREE(ctx);
1453 return ret;
1454 }
1455 /**@}*/
1456
1457 /******************************************************************************/
1458 /**
1459 * @defgroup net_registry_convert Convert
1460 * @ingroup net_registry
1461 * @{
1462 */
1463
1464 static int net_registry_convert(struct net_context *c, int argc,
1465 const char **argv)
1466 {
1467 int ret;
1468 TALLOC_CTX *mem_ctx;
1469 const char *in_opt = NULL;
1470 const char *out_opt = NULL;
1471
1472 if (argc < 2 || argc > 4|| c->display_usage) {
1473 d_printf("%s\n%s",
1474 _("Usage:"),
1475 _("net registry convert <in> <out> [in_opt] [out_opt]\n"
1476 "net registry convert <in> <out> [out_opt]\n"));
1477 d_printf("%s\n%s",
1478 _("Example:"),
1479 _("net registry convert in.reg out.reg regedit4,enc=CP1252\n"));
1480 return -1;
1481 }
1482
1483 mem_ctx = talloc_stackframe();
1484
1485 switch (argc ) {
1486 case 2:
1487 break;
1488 case 3:
1489 out_opt = argv[2];
1490 break;
1491 case 4:
1492 out_opt = argv[3];
1493 in_opt = argv[2];
1494 break;
1495 default:
1496 assert(false);
1497 }
1498
1499
1500 ret = reg_parse_file(argv[0], (struct reg_parse_callback*)
1501 reg_format_file(mem_ctx, argv[1], out_opt),
1502 in_opt);
1503
1504 talloc_free(mem_ctx);
1505
1506 return ret;
1507 }
1508 /**@}*/
1509
1510 static int net_registry_check(struct net_context *c, int argc,
1511 const char **argv)
1512 {
1513 char *dbfile;
1514 struct check_options opts;
1515 int ret;
1516
1517 if (argc > 1|| c->display_usage) {
1518 d_printf("%s\n%s",
1519 _("Usage:"),
1520 _("net registry check [-vraTfl] [-o <ODB>] [--wipe] [<TDB>]\n"
1521 " Check a registry database.\n"
1522 " -v|--verbose\t be verbose\n"
1523 " -r|--repair\t\t interactive repair mode\n"
1524 " -a|--auto\t\t noninteractive repair mode\n"
1525 " -T|--test\t\t dry run\n"
1526 " -f|--force\t\t force\n"
1527 " -l|--lock\t\t lock <TDB> while doing the check\n"
1528 " -o|--output=<ODB>\t output database\n"
1529 " --reg-version=n\t assume database format version {n|1,2,3}\n"
1530 " --wipe\t\t create a new database from scratch\n"
1531 " --db=<TDB>\t\t registry database to open\n"));
1532 return c->display_usage ? 0 : -1;
1533 }
1534
1535 if (c->opt_db != NULL) {
1536 dbfile = talloc_strdup(talloc_tos(), c->opt_db);
1537 } else if (argc > 0) {
1538 dbfile = talloc_strdup(talloc_tos(), argv[0]);
1539 } else {
1540 dbfile = state_path(talloc_tos(), "registry.tdb");
1541 }
1542 if (dbfile == NULL) {
1543 return -1;
1544 }
1545
1546 opts = (struct check_options) {
1547 .lock = c->opt_lock || c->opt_long_list_entries,
1548 .test = c->opt_testmode,
1549 .automatic = c->opt_auto,
1550 .verbose = c->opt_verbose,
1551 .force = c->opt_force,
1552 .repair = c->opt_repair || c->opt_reboot,
1553 .version = c->opt_reg_version,
1554 .output = c->opt_output,
1555 .wipe = c->opt_wipe,
1556 .implicit_db = (c->opt_db == NULL) && (argc == 0),
1557 };
1558
1559 ret = net_registry_check_db(dbfile, &opts);
1560 talloc_free(dbfile);
1561 return ret;
1562 }
1563
1564
1565 /******************************************************************************/
1566
1567 int net_registry(struct net_context *c, int argc, const char **argv)
1568 {
1569 int ret = -1;
1570
1571 struct functable func[] = {
1572 {
1573 "enumerate",
1574 net_registry_enumerate,
1575 NET_TRANSPORT_LOCAL,
1576 N_("Enumerate registry keys and values"),
1577 N_("net registry enumerate\n"
1578 " Enumerate registry keys and values")
1579 },
1580 {
1581 "enumerate_recursive",
1582 net_registry_enumerate_recursive,
1583 NET_TRANSPORT_LOCAL,
1584 N_("Enumerate registry keys and values"),
1585 N_("net registry enumerate_recursive\n"
1586 " Enumerate registry keys and values")
1587 },
1588 {
1589 "createkey",
1590 net_registry_createkey,
1591 NET_TRANSPORT_LOCAL,
1592 N_("Create a new registry key"),
1593 N_("net registry createkey\n"
1594 " Create a new registry key")
1595 },
1596 {
1597 "deletekey",
1598 net_registry_deletekey,
1599 NET_TRANSPORT_LOCAL,
1600 N_("Delete a registry key"),
1601 N_("net registry deletekey\n"
1602 " Delete a registry key")
1603 },
1604 {
1605 "deletekey_recursive",
1606 net_registry_deletekey_recursive,
1607 NET_TRANSPORT_LOCAL,
1608 N_("Delete a registry key with subkeys"),
1609 N_("net registry deletekey_recursive\n"
1610 " Delete a registry key with subkeys")
1611 },
1612 {
1613 "getvalue",
1614 net_registry_getvalue,
1615 NET_TRANSPORT_LOCAL,
1616 N_("Print a registry value"),
1617 N_("net registry getvalue\n"
1618 " Print a registry value")
1619 },
1620 {
1621 "getvalueraw",
1622 net_registry_getvalueraw,
1623 NET_TRANSPORT_LOCAL,
1624 N_("Print a registry value (raw format)"),
1625 N_("net registry getvalueraw\n"
1626 " Print a registry value (raw format)")
1627 },
1628 {
1629 "getvaluesraw",
1630 net_registry_getvaluesraw,
1631 NET_TRANSPORT_LOCAL,
1632 "Print all values of a key in raw format",
1633 "net registry getvaluesraw <key>\n"
1634 " Print a registry value (raw format)"
1635 },
1636 {
1637 "setvalue",
1638 net_registry_setvalue,
1639 NET_TRANSPORT_LOCAL,
1640 N_("Set a new registry value"),
1641 N_("net registry setvalue\n"
1642 " Set a new registry value")
1643 },
1644 {
1645 "increment",
1646 net_registry_increment,
1647 NET_TRANSPORT_LOCAL,
1648 N_("Increment a DWORD registry value under a lock"),
1649 N_("net registry increment\n"
1650 " Increment a DWORD registry value under a lock")
1651 },
1652 {
1653 "deletevalue",
1654 net_registry_deletevalue,
1655 NET_TRANSPORT_LOCAL,
1656 N_("Delete a registry value"),
1657 N_("net registry deletevalue\n"
1658 " Delete a registry value")
1659 },
1660 {
1661 "getsd",
1662 net_registry_getsd,
1663 NET_TRANSPORT_LOCAL,
1664 N_("Get security descriptor"),
1665 N_("net registry getsd\n"
1666 " Get security descriptor")
1667 },
1668 {
1669 "getsd_sddl",
1670 net_registry_getsd_sddl,
1671 NET_TRANSPORT_LOCAL,
1672 N_("Get security descriptor in sddl format"),
1673 N_("net registry getsd_sddl\n"
1674 " Get security descriptor in sddl format")
1675 },
1676 {
1677 "setsd_sddl",
1678 net_registry_setsd_sddl,
1679 NET_TRANSPORT_LOCAL,
1680 N_("Set security descriptor from sddl format string"),
1681 N_("net registry setsd_sddl\n"
1682 " Set security descriptor from sddl format string")
1683 },
1684 {
1685 "import",
1686 net_registry_import,
1687 NET_TRANSPORT_LOCAL,
1688 N_("Import .reg file"),
1689 N_("net registry import\n"
1690 " Import .reg file")
1691 },
1692 {
1693 "export",
1694 net_registry_export,
1695 NET_TRANSPORT_LOCAL,
1696 N_("Export .reg file"),
1697 N_("net registry export\n"
1698 " Export .reg file")
1699 },
1700 {
1701 "convert",
1702 net_registry_convert,
1703 NET_TRANSPORT_LOCAL,
1704 N_("Convert .reg file"),
1705 N_("net registry convert\n"
1706 " Convert .reg file")
1707 },
1708 {
1709 "check",
1710 net_registry_check,
1711 NET_TRANSPORT_LOCAL,
1712 N_("Check a registry database"),
1713 N_("net registry check\n"
1714 " Check a registry database")
1715 },
1716 { NULL, NULL, 0, NULL, NULL }
1717 };
1718
1719 if (!c->display_usage
1720 && argc > 0
1721 && (strcasecmp_m(argv[0], "convert") != 0)
1722 && (strcasecmp_m(argv[0], "check") != 0))
1723 {
1724 if (!W_ERROR_IS_OK(registry_init_basic())) {
1725 return -1;
1726 }
1727 }
1728
1729 ret = net_run_function(c, argc, argv, "net registry", func);
1730
1731 return ret;
1732 }
Samba GIT mirror