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"
34 * split given path into hive and remaining path and open the hive key
36 static WERROR
open_hive(TALLOC_CTX
*ctx
, const char *path
,
37 uint32 desired_access
,
38 struct registry_key
**hive
,
42 NT_USER_TOKEN
*token
= NULL
;
43 char *hivename
= NULL
;
44 char *tmp_subkeyname
= NULL
;
45 TALLOC_CTX
*tmp_ctx
= talloc_stackframe();
47 if ((hive
== NULL
) || (subkeyname
== NULL
)) {
48 werr
= WERR_INVALID_PARAM
;
52 werr
= split_hive_key(tmp_ctx
, path
, &hivename
, &tmp_subkeyname
);
53 if (!W_ERROR_IS_OK(werr
)) {
56 *subkeyname
= talloc_strdup(ctx
, tmp_subkeyname
);
57 if (*subkeyname
== NULL
) {
62 werr
= ntstatus_to_werror(registry_create_admin_token(tmp_ctx
, &token
));
63 if (!W_ERROR_IS_OK(werr
)) {
67 werr
= reg_openhive(ctx
, hivename
, desired_access
, token
, hive
);
68 if (!W_ERROR_IS_OK(werr
)) {
79 static WERROR
open_key(TALLOC_CTX
*ctx
, const char *path
,
80 uint32 desired_access
,
81 struct registry_key
**key
)
84 char *subkey_name
= NULL
;
85 struct registry_key
*hive
= NULL
;
86 TALLOC_CTX
*tmp_ctx
= talloc_stackframe();
88 if ((path
== NULL
) || (key
== NULL
)) {
89 return WERR_INVALID_PARAM
;
92 werr
= open_hive(tmp_ctx
, path
, desired_access
, &hive
, &subkey_name
);
93 if (!W_ERROR_IS_OK(werr
)) {
94 d_fprintf(stderr
, _("open_hive failed: %s\n"),
99 werr
= reg_openkey(ctx
, hive
, subkey_name
, desired_access
, key
);
100 if (!W_ERROR_IS_OK(werr
)) {
101 d_fprintf(stderr
, _("reg_openkey failed: %s\n"),
109 TALLOC_FREE(tmp_ctx
);
115 * the main "net registry" function implementations
119 static int net_registry_enumerate(struct net_context
*c
, int argc
,
123 struct registry_key
*key
= NULL
;
124 TALLOC_CTX
*ctx
= talloc_stackframe();
128 char *valname
= NULL
;
129 struct registry_value
*valvalue
= NULL
;
132 if (argc
!= 1 || c
->display_usage
) {
135 _("net registry enumerate <path>\n"));
138 _("net registry enumerate 'HKLM\\Software\\Samba'\n"));
142 werr
= open_key(ctx
, argv
[0], REG_KEY_READ
, &key
);
143 if (!W_ERROR_IS_OK(werr
)) {
144 d_fprintf(stderr
, _("open_key failed: %s\n"), win_errstr(werr
));
149 werr
= reg_enumkey(ctx
, key
, count
, &subkey_name
, &modtime
),
153 print_registry_key(subkey_name
, &modtime
);
155 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS
, werr
)) {
160 werr
= reg_enumvalue(ctx
, key
, count
, &valname
, &valvalue
),
164 print_registry_value_with_name(valname
, valvalue
);
166 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS
, werr
)) {
176 static int net_registry_createkey(struct net_context
*c
, int argc
,
180 enum winreg_CreateAction action
;
182 struct registry_key
*hivekey
= NULL
;
183 struct registry_key
*subkey
= NULL
;
184 TALLOC_CTX
*ctx
= talloc_stackframe();
187 if (argc
!= 1 || c
->display_usage
) {
190 _("net registry createkey <path>\n"));
193 _("net registry createkey "
194 "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n"));
197 if (strlen(argv
[0]) == 0) {
198 d_fprintf(stderr
, _("error: zero length key name given\n"));
202 werr
= open_hive(ctx
, argv
[0], REG_KEY_WRITE
, &hivekey
, &subkeyname
);
203 if (!W_ERROR_IS_OK(werr
)) {
204 d_fprintf(stderr
, _("open_hive failed: %s\n"),
209 werr
= reg_createkey(ctx
, hivekey
, subkeyname
, REG_KEY_WRITE
,
211 if (!W_ERROR_IS_OK(werr
)) {
212 d_fprintf(stderr
, _("reg_createkey failed: %s\n"),
217 case REG_ACTION_NONE
:
218 d_printf(_("createkey did nothing -- huh?\n"));
220 case REG_CREATED_NEW_KEY
:
221 d_printf(_("createkey created %s\n"), argv
[0]);
223 case REG_OPENED_EXISTING_KEY
:
224 d_printf(_("createkey opened existing %s\n"), argv
[0]);
235 static int net_registry_deletekey(struct net_context
*c
, int argc
,
240 struct registry_key
*hivekey
= NULL
;
241 TALLOC_CTX
*ctx
= talloc_stackframe();
244 if (argc
!= 1 || c
->display_usage
) {
247 _("net registry deletekey <path>\n"));
250 _("net registry deletekey "
251 "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n"));
254 if (strlen(argv
[0]) == 0) {
255 d_fprintf(stderr
, _("error: zero length key name given\n"));
259 werr
= open_hive(ctx
, argv
[0], REG_KEY_WRITE
, &hivekey
, &subkeyname
);
260 if (!W_ERROR_IS_OK(werr
)) {
261 d_fprintf(stderr
, "open_hive %s: %s\n", _("failed"),
266 werr
= reg_deletekey(hivekey
, subkeyname
);
267 if (!W_ERROR_IS_OK(werr
)) {
268 d_fprintf(stderr
, "reg_deletekey %s: %s\n", _("failed"),
280 static int net_registry_getvalue_internal(struct net_context
*c
, int argc
,
281 const char **argv
, bool raw
)
285 struct registry_key
*key
= NULL
;
286 struct registry_value
*value
= NULL
;
287 TALLOC_CTX
*ctx
= talloc_stackframe();
289 if (argc
!= 2 || c
->display_usage
) {
290 d_fprintf(stderr
, "%s\n%s",
292 _("net rpc registry getvalue <key> <valuename>\n"));
296 werr
= open_key(ctx
, argv
[0], REG_KEY_READ
, &key
);
297 if (!W_ERROR_IS_OK(werr
)) {
298 d_fprintf(stderr
, _("open_key failed: %s\n"), win_errstr(werr
));
302 werr
= reg_queryvalue(ctx
, key
, argv
[1], &value
);
303 if (!W_ERROR_IS_OK(werr
)) {
304 d_fprintf(stderr
, _("reg_queryvalue failed: %s\n"),
309 print_registry_value(value
, raw
);
318 static int net_registry_getvalue(struct net_context
*c
, int argc
,
321 return net_registry_getvalue_internal(c
, argc
, argv
, false);
324 static int net_registry_getvalueraw(struct net_context
*c
, int argc
,
327 return net_registry_getvalue_internal(c
, argc
, argv
, true);
330 static int net_registry_setvalue(struct net_context
*c
, int argc
,
334 struct registry_value value
;
335 struct registry_key
*key
= NULL
;
337 TALLOC_CTX
*ctx
= talloc_stackframe();
339 if (argc
< 4 || c
->display_usage
) {
340 d_fprintf(stderr
, "%s\n%s",
342 _("net rpc registry setvalue <key> <valuename> "
343 "<type> [<val>]+\n"));
347 if (!strequal(argv
[2], "multi_sz") && (argc
!= 4)) {
348 d_fprintf(stderr
, _("Too many args for type %s\n"), argv
[2]);
352 if (strequal(argv
[2], "dword")) {
353 value
.type
= REG_DWORD
;
354 value
.v
.dword
= strtoul(argv
[3], NULL
, 10);
355 } else if (strequal(argv
[2], "sz")) {
357 value
.v
.sz
.len
= strlen(argv
[3])+1;
358 value
.v
.sz
.str
= CONST_DISCARD(char *, argv
[3]);
359 } else if (strequal(argv
[2], "multi_sz")) {
360 value
.type
= REG_MULTI_SZ
;
361 value
.v
.multi_sz
.num_strings
= argc
- 3;
362 value
.v
.multi_sz
.strings
= (char **)(argv
+ 3);
364 d_fprintf(stderr
, _("type \"%s\" not implemented\n"), argv
[2]);
368 werr
= open_key(ctx
, argv
[0], REG_KEY_WRITE
, &key
);
369 if (!W_ERROR_IS_OK(werr
)) {
370 d_fprintf(stderr
, _("open_key failed: %s\n"), win_errstr(werr
));
374 werr
= reg_setvalue(key
, argv
[1], &value
);
375 if (!W_ERROR_IS_OK(werr
)) {
376 d_fprintf(stderr
, _("reg_setvalue failed: %s\n"),
388 static int net_registry_deletevalue(struct net_context
*c
, int argc
,
392 struct registry_key
*key
= NULL
;
393 TALLOC_CTX
*ctx
= talloc_stackframe();
396 if (argc
!= 2 || c
->display_usage
) {
397 d_fprintf(stderr
, "%s\n%s",
399 _("net rpc registry deletevalue <key> <valuename>\n"));
403 werr
= open_key(ctx
, argv
[0], REG_KEY_WRITE
, &key
);
404 if (!W_ERROR_IS_OK(werr
)) {
405 d_fprintf(stderr
, _("open_key failed: %s\n"), win_errstr(werr
));
409 werr
= reg_deletevalue(key
, argv
[1]);
410 if (!W_ERROR_IS_OK(werr
)) {
411 d_fprintf(stderr
, _("reg_deletekey failed: %s\n"),
423 static int net_registry_getsd(struct net_context
*c
, int argc
,
428 struct registry_key
*key
= NULL
;
429 struct security_descriptor
*secdesc
= NULL
;
430 TALLOC_CTX
*ctx
= talloc_stackframe();
431 uint32_t access_mask
= REG_KEY_READ
|
432 SEC_FLAG_MAXIMUM_ALLOWED
|
433 SEC_FLAG_SYSTEM_SECURITY
;
436 * net_rpc_regsitry uses SEC_FLAG_SYSTEM_SECURITY, but access
437 * is denied with these perms right now...
439 access_mask
= REG_KEY_READ
;
441 if (argc
!= 1 || c
->display_usage
) {
444 _("net registry getsd <path>\n"));
447 _("net registry getsd 'HKLM\\Software\\Samba'\n"));
450 if (strlen(argv
[0]) == 0) {
451 d_fprintf(stderr
, "error: zero length key name given\n");
455 werr
= open_key(ctx
, argv
[0], access_mask
, &key
);
456 if (!W_ERROR_IS_OK(werr
)) {
457 d_fprintf(stderr
, _("open_key failed: %s\n"), win_errstr(werr
));
461 werr
= reg_getkeysecurity(ctx
, key
, &secdesc
);
462 if (!W_ERROR_IS_OK(werr
)) {
463 d_fprintf(stderr
, _("reg_getkeysecurity failed: %s\n"),
468 display_sec_desc(secdesc
);
477 int net_registry(struct net_context
*c
, int argc
, const char **argv
)
481 struct functable func
[] = {
484 net_registry_enumerate
,
486 N_("Enumerate registry keys and values"),
487 N_("net registry enumerate\n"
488 " Enumerate registry keys and values")
492 net_registry_createkey
,
494 N_("Create a new registry key"),
495 N_("net registry createkey\n"
496 " Create a new registry key")
500 net_registry_deletekey
,
502 N_("Delete a registry key"),
503 N_("net registry deletekey\n"
504 " Delete a registry key")
508 net_registry_getvalue
,
510 N_("Print a registry value"),
511 N_("net registry getvalue\n"
512 " Print a registry value")
516 net_registry_getvalueraw
,
518 N_("Print a registry value (raw format)"),
519 N_("net registry getvalueraw\n"
520 " Print a registry value (raw format)")
524 net_registry_setvalue
,
526 N_("Set a new registry value"),
527 N_("net registry setvalue\n"
528 " Set a new registry value")
532 net_registry_deletevalue
,
534 N_("Delete a registry value"),
535 N_("net registry deletevalue\n"
536 " Delete a registry value")
542 N_("Get security descriptor"),
543 N_("net registry getsd\n"
544 " Get security descriptor")
546 { NULL
, NULL
, 0, NULL
, NULL
}
549 if (!W_ERROR_IS_OK(registry_init_basic())) {
553 ret
= net_run_function(c
, argc
, argv
, "net registry", func
);