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/>.
23 #include "utils/net.h"
24 #include "utils/net_registry_util.h"
25 #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 reg_type_lookup(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
);