2 * Samba Unix/Linux SMB client library
3 * Distributed SMB/CIFS Server Management Utility
4 * Local registry interface
6 * Copyright (C) Michael Adam 2008
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.
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.
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/>.
24 #include "utils/net.h"
25 #include "utils/net_registry_util.h"
26 #include "include/g_lock.h"
35 * split given path into hive and remaining path and open the hive key
37 static WERROR open_hive(TALLOC_CTX *ctx, const char *path,
38 uint32 desired_access,
39 struct registry_key **hive,
43 NT_USER_TOKEN *token = NULL;
44 char *hivename = NULL;
45 char *tmp_subkeyname = NULL;
46 TALLOC_CTX *tmp_ctx = talloc_stackframe();
48 if ((hive == NULL) || (subkeyname == NULL)) {
49 werr = WERR_INVALID_PARAM;
53 werr = split_hive_key(tmp_ctx, path, &hivename, &tmp_subkeyname);
54 if (!W_ERROR_IS_OK(werr)) {
57 *subkeyname = talloc_strdup(ctx, tmp_subkeyname);
58 if (*subkeyname == NULL) {
63 werr = ntstatus_to_werror(registry_create_admin_token(tmp_ctx, &token));
64 if (!W_ERROR_IS_OK(werr)) {
68 werr = reg_openhive(ctx, hivename, desired_access, token, hive);
69 if (!W_ERROR_IS_OK(werr)) {
80 static WERROR open_key(TALLOC_CTX *ctx, const char *path,
81 uint32 desired_access,
82 struct registry_key **key)
85 char *subkey_name = NULL;
86 struct registry_key *hive = NULL;
87 TALLOC_CTX *tmp_ctx = talloc_stackframe();
89 if ((path == NULL) || (key == NULL)) {
90 return WERR_INVALID_PARAM;
93 werr = open_hive(tmp_ctx, path, desired_access, &hive, &subkey_name);
94 if (!W_ERROR_IS_OK(werr)) {
95 d_fprintf(stderr, _("open_hive failed: %s\n"),
100 werr = reg_openkey(ctx, hive, subkey_name, desired_access, key);
101 if (!W_ERROR_IS_OK(werr)) {
102 d_fprintf(stderr, _("reg_openkey failed: %s\n"),
110 TALLOC_FREE(tmp_ctx);
116 * the main "net registry" function implementations
120 static int net_registry_enumerate(struct net_context *c, int argc,
124 struct registry_key *key = NULL;
125 TALLOC_CTX *ctx = talloc_stackframe();
129 char *valname = NULL;
130 struct registry_value *valvalue = NULL;
133 if (argc != 1 || c->display_usage) {
136 _("net registry enumerate <path>\n"));
139 _("net registry enumerate 'HKLM\\Software\\Samba'\n"));
143 werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
144 if (!W_ERROR_IS_OK(werr)) {
145 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
150 werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
154 print_registry_key(subkey_name, &modtime);
156 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
161 werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
165 print_registry_value_with_name(valname, valvalue);
167 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
177 static int net_registry_createkey(struct net_context *c, int argc,
181 enum winreg_CreateAction action;
183 struct registry_key *hivekey = NULL;
184 struct registry_key *subkey = NULL;
185 TALLOC_CTX *ctx = talloc_stackframe();
188 if (argc != 1 || c->display_usage) {
191 _("net registry createkey <path>\n"));
194 _("net registry createkey "
195 "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n"));
198 if (strlen(argv[0]) == 0) {
199 d_fprintf(stderr, _("error: zero length key name given\n"));
203 werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
204 if (!W_ERROR_IS_OK(werr)) {
205 d_fprintf(stderr, _("open_hive failed: %s\n"),
210 werr = reg_createkey(ctx, hivekey, subkeyname, REG_KEY_WRITE,
212 if (!W_ERROR_IS_OK(werr)) {
213 d_fprintf(stderr, _("reg_createkey failed: %s\n"),
218 case REG_ACTION_NONE:
219 d_printf(_("createkey did nothing -- huh?\n"));
221 case REG_CREATED_NEW_KEY:
222 d_printf(_("createkey created %s\n"), argv[0]);
224 case REG_OPENED_EXISTING_KEY:
225 d_printf(_("createkey opened existing %s\n"), argv[0]);
236 static int net_registry_deletekey(struct net_context *c, int argc,
241 struct registry_key *hivekey = NULL;
242 TALLOC_CTX *ctx = talloc_stackframe();
245 if (argc != 1 || c->display_usage) {
248 _("net registry deletekey <path>\n"));
251 _("net registry deletekey "
252 "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n"));
255 if (strlen(argv[0]) == 0) {
256 d_fprintf(stderr, _("error: zero length key name given\n"));
260 werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
261 if (!W_ERROR_IS_OK(werr)) {
262 d_fprintf(stderr, "open_hive %s: %s\n", _("failed"),
267 werr = reg_deletekey(hivekey, subkeyname);
268 if (!W_ERROR_IS_OK(werr)) {
269 d_fprintf(stderr, "reg_deletekey %s: %s\n", _("failed"),
281 static int net_registry_getvalue_internal(struct net_context *c, int argc,
282 const char **argv, bool raw)
286 struct registry_key *key = NULL;
287 struct registry_value *value = NULL;
288 TALLOC_CTX *ctx = talloc_stackframe();
290 if (argc != 2 || c->display_usage) {
291 d_fprintf(stderr, "%s\n%s",
293 _("net registry getvalue <key> <valuename>\n"));
297 werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
298 if (!W_ERROR_IS_OK(werr)) {
299 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
303 werr = reg_queryvalue(ctx, key, argv[1], &value);
304 if (!W_ERROR_IS_OK(werr)) {
305 d_fprintf(stderr, _("reg_queryvalue failed: %s\n"),
310 print_registry_value(value, raw);
319 static int net_registry_getvalue(struct net_context *c, int argc,
322 return net_registry_getvalue_internal(c, argc, argv, false);
325 static int net_registry_getvalueraw(struct net_context *c, int argc,
328 return net_registry_getvalue_internal(c, argc, argv, true);
331 static int net_registry_setvalue(struct net_context *c, int argc,
335 struct registry_value value;
336 struct registry_key *key = NULL;
338 TALLOC_CTX *ctx = talloc_stackframe();
340 if (argc < 4 || c->display_usage) {
341 d_fprintf(stderr, "%s\n%s",
343 _("net registry setvalue <key> <valuename> "
344 "<type> [<val>]+\n"));
348 if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
349 d_fprintf(stderr, _("Too many args for type %s\n"), argv[2]);
353 if (strequal(argv[2], "dword")) {
354 value.type = REG_DWORD;
355 value.v.dword = strtoul(argv[3], NULL, 10);
356 } else if (strequal(argv[2], "sz")) {
358 value.v.sz.len = strlen(argv[3])+1;
359 value.v.sz.str = CONST_DISCARD(char *, argv[3]);
360 } else if (strequal(argv[2], "multi_sz")) {
361 value.type = REG_MULTI_SZ;
362 value.v.multi_sz.num_strings = argc - 3;
363 value.v.multi_sz.strings = (char **)(argv + 3);
365 d_fprintf(stderr, _("type \"%s\" not implemented\n"), argv[2]);
369 werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
370 if (!W_ERROR_IS_OK(werr)) {
371 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
375 werr = reg_setvalue(key, argv[1], &value);
376 if (!W_ERROR_IS_OK(werr)) {
377 d_fprintf(stderr, _("reg_setvalue failed: %s\n"),
389 struct net_registry_increment_state {
391 const char *valuename;
397 static void net_registry_increment_fn(void *private_data)
399 struct net_registry_increment_state *state =
400 (struct net_registry_increment_state *)private_data;
401 struct registry_value *value;
402 struct registry_key *key = NULL;
404 state->werr = open_key(talloc_tos(), state->keyname,
405 REG_KEY_READ|REG_KEY_WRITE, &key);
406 if (!W_ERROR_IS_OK(state->werr)) {
407 d_fprintf(stderr, _("open_key failed: %s\n"),
408 win_errstr(state->werr));
412 state->werr = reg_queryvalue(key, key, state->valuename, &value);
413 if (!W_ERROR_IS_OK(state->werr)) {
414 d_fprintf(stderr, _("reg_queryvalue failed: %s\n"),
415 win_errstr(state->werr));
419 if (value->type != REG_DWORD) {
420 d_fprintf(stderr, _("value not a DWORD: %s\n"),
421 str_regtype(value->type));
425 value->v.dword += state->increment;
426 state->newvalue = value->v.dword;
428 state->werr = reg_setvalue(key, state->valuename, value);
429 if (!W_ERROR_IS_OK(state->werr)) {
430 d_fprintf(stderr, _("reg_setvalue failed: %s\n"),
431 win_errstr(state->werr));
440 static int net_registry_increment(struct net_context *c, int argc,
443 struct net_registry_increment_state state;
447 if (argc < 2 || c->display_usage) {
448 d_fprintf(stderr, "%s\n%s",
450 _("net registry increment <key> <valuename> "
455 state.keyname = argv[0];
456 state.valuename = argv[1];
460 state.increment = strtoul(argv[2], NULL, 10);
463 status = g_lock_do("registry_increment_lock", G_LOCK_WRITE,
465 net_registry_increment_fn, &state);
466 if (!NT_STATUS_IS_OK(status)) {
467 d_fprintf(stderr, _("g_lock_do failed: %s\n"),
471 if (!W_ERROR_IS_OK(state.werr)) {
472 d_fprintf(stderr, _("increment failed: %s\n"),
473 win_errstr(state.werr));
477 d_printf(_("%u\n"), (unsigned)state.newvalue);
485 static int net_registry_deletevalue(struct net_context *c, int argc,
489 struct registry_key *key = NULL;
490 TALLOC_CTX *ctx = talloc_stackframe();
493 if (argc != 2 || c->display_usage) {
494 d_fprintf(stderr, "%s\n%s",
496 _("net registry deletevalue <key> <valuename>\n"));
500 werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
501 if (!W_ERROR_IS_OK(werr)) {
502 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
506 werr = reg_deletevalue(key, argv[1]);
507 if (!W_ERROR_IS_OK(werr)) {
508 d_fprintf(stderr, _("reg_deletekey failed: %s\n"),
520 static WERROR net_registry_getsd_internal(struct net_context *c,
523 struct security_descriptor **sd)
526 struct registry_key *key = NULL;
527 TALLOC_CTX *ctx = talloc_stackframe();
528 uint32_t access_mask = REG_KEY_READ |
529 SEC_FLAG_MAXIMUM_ALLOWED |
530 SEC_FLAG_SYSTEM_SECURITY;
533 * net_rpc_regsitry uses SEC_FLAG_SYSTEM_SECURITY, but access
534 * is denied with these perms right now...
536 access_mask = REG_KEY_READ;
539 d_fprintf(stderr, _("internal error: invalid argument\n"));
540 werr = WERR_INVALID_PARAM;
544 if (strlen(keyname) == 0) {
545 d_fprintf(stderr, _("error: zero length key name given\n"));
546 werr = WERR_INVALID_PARAM;
550 werr = open_key(ctx, keyname, access_mask, &key);
551 if (!W_ERROR_IS_OK(werr)) {
552 d_fprintf(stderr, "%s%s\n", _("open_key failed: "),
557 werr = reg_getkeysecurity(mem_ctx, key, sd);
558 if (!W_ERROR_IS_OK(werr)) {
559 d_fprintf(stderr, "%s%s\n", _("reg_getkeysecurity failed: "),
571 static int net_registry_getsd(struct net_context *c, int argc,
576 struct security_descriptor *secdesc = NULL;
577 TALLOC_CTX *ctx = talloc_stackframe();
579 if (argc != 1 || c->display_usage) {
582 _("net registry getsd <path>\n"));
585 _("net registry getsd 'HKLM\\Software\\Samba'\n"));
589 werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
590 if (!W_ERROR_IS_OK(werr)) {
594 display_sec_desc(secdesc);
603 static int net_registry_getsd_sddl(struct net_context *c,
604 int argc, const char **argv)
608 struct security_descriptor *secdesc = NULL;
609 TALLOC_CTX *ctx = talloc_stackframe();
611 if (argc != 1 || c->display_usage) {
614 _("net registry getsd_sddl <path>\n"));
617 _("net registry getsd_sddl 'HKLM\\Software\\Samba'\n"));
621 werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
622 if (!W_ERROR_IS_OK(werr)) {
626 d_printf("%s\n", sddl_encode(ctx, secdesc, get_global_sam_sid()));
635 static WERROR net_registry_setsd_internal(struct net_context *c,
638 struct security_descriptor *sd)
641 struct registry_key *key = NULL;
642 TALLOC_CTX *ctx = talloc_stackframe();
643 uint32_t access_mask = REG_KEY_WRITE |
644 SEC_FLAG_MAXIMUM_ALLOWED |
645 SEC_FLAG_SYSTEM_SECURITY;
648 * net_rpc_regsitry uses SEC_FLAG_SYSTEM_SECURITY, but access
649 * is denied with these perms right now...
651 access_mask = REG_KEY_WRITE;
653 if (strlen(keyname) == 0) {
654 d_fprintf(stderr, _("error: zero length key name given\n"));
655 werr = WERR_INVALID_PARAM;
659 werr = open_key(ctx, keyname, access_mask, &key);
660 if (!W_ERROR_IS_OK(werr)) {
661 d_fprintf(stderr, "%s%s\n", _("open_key failed: "),
666 werr = reg_setkeysecurity(key, sd);
667 if (!W_ERROR_IS_OK(werr)) {
668 d_fprintf(stderr, "%s%s\n", _("reg_setkeysecurity failed: "),
680 static int net_registry_setsd_sddl(struct net_context *c,
681 int argc, const char **argv)
685 struct security_descriptor *secdesc = NULL;
686 TALLOC_CTX *ctx = talloc_stackframe();
688 if (argc != 2 || c->display_usage) {
691 _("net registry setsd_sddl <path> <security_descriptor>\n"));
694 _("net registry setsd_sddl 'HKLM\\Software\\Samba'\n"));
698 secdesc = sddl_decode(ctx, argv[1], get_global_sam_sid());
699 if (secdesc == NULL) {
703 werr = net_registry_setsd_internal(c, ctx, argv[0], secdesc);
704 if (!W_ERROR_IS_OK(werr)) {
715 int net_registry(struct net_context *c, int argc, const char **argv)
719 struct functable func[] = {
722 net_registry_enumerate,
724 N_("Enumerate registry keys and values"),
725 N_("net registry enumerate\n"
726 " Enumerate registry keys and values")
730 net_registry_createkey,
732 N_("Create a new registry key"),
733 N_("net registry createkey\n"
734 " Create a new registry key")
738 net_registry_deletekey,
740 N_("Delete a registry key"),
741 N_("net registry deletekey\n"
742 " Delete a registry key")
746 net_registry_getvalue,
748 N_("Print a registry value"),
749 N_("net registry getvalue\n"
750 " Print a registry value")
754 net_registry_getvalueraw,
756 N_("Print a registry value (raw format)"),
757 N_("net registry getvalueraw\n"
758 " Print a registry value (raw format)")
762 net_registry_setvalue,
764 N_("Set a new registry value"),
765 N_("net registry setvalue\n"
766 " Set a new registry value")
770 net_registry_increment,
772 N_("Increment a DWORD registry value under a lock"),
773 N_("net registry increment\n"
774 " Increment a DWORD registry value under a lock")
778 net_registry_deletevalue,
780 N_("Delete a registry value"),
781 N_("net registry deletevalue\n"
782 " Delete a registry value")
788 N_("Get security descriptor"),
789 N_("net registry getsd\n"
790 " Get security descriptor")
794 net_registry_getsd_sddl,
796 N_("Get security descriptor in sddl format"),
797 N_("net registry getsd_sddl\n"
798 " Get security descriptor in sddl format")
802 net_registry_setsd_sddl,
804 N_("Set security descriptor from sddl format string"),
805 N_("net registry setsd_sddl\n"
806 " Set security descriptor from sddl format string")
808 { NULL, NULL, 0, NULL, NULL }
811 if (!W_ERROR_IS_OK(registry_init_basic())) {
815 ret = net_run_function(c, argc, argv, "net registry", func);