Implement type multi_sz for "net registry setvalue"
[Samba/bb.git] / source / utils / net_registry.c
blobfc1cc36741cb8b64370cf73ff3725b406e5d74f9
1 /*
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/>.
22 #include "includes.h"
23 #include "utils/net.h"
24 #include "utils/net_registry_util.h"
29 * Helper functions
33 /**
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,
39 char **subkeyname)
41 WERROR werr;
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;
49 goto done;
52 werr = split_hive_key(tmp_ctx, path, &hivename, &tmp_subkeyname);
53 if (!W_ERROR_IS_OK(werr)) {
54 goto done;
56 *subkeyname = talloc_strdup(ctx, tmp_subkeyname);
57 if (*subkeyname == NULL) {
58 werr = WERR_NOMEM;
59 goto done;
62 werr = ntstatus_to_werror(registry_create_admin_token(tmp_ctx, &token));
63 if (!W_ERROR_IS_OK(werr)) {
64 goto done;
67 werr = reg_openhive(ctx, hivename, desired_access, token, hive);
68 if (!W_ERROR_IS_OK(werr)) {
69 goto done;
72 werr = WERR_OK;
74 done:
75 TALLOC_FREE(tmp_ctx);
76 return werr;
79 static WERROR open_key(TALLOC_CTX *ctx, const char *path,
80 uint32 desired_access,
81 struct registry_key **key)
83 WERROR werr;
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", dos_errstr(werr));
95 goto done;
98 werr = reg_openkey(ctx, hive, subkey_name, desired_access, key);
99 if (!W_ERROR_IS_OK(werr)) {
100 d_fprintf(stderr, "reg_openkey failed: %s\n",
101 dos_errstr(werr));
102 goto done;
105 werr = WERR_OK;
107 done:
108 TALLOC_FREE(tmp_ctx);
109 return werr;
114 * the main "net registry" function implementations
118 static int net_registry_enumerate(struct net_context *c, int argc,
119 const char **argv)
121 WERROR werr;
122 struct registry_key *key = NULL;
123 TALLOC_CTX *ctx = talloc_stackframe();
124 char *subkey_name;
125 NTTIME modtime;
126 uint32_t count;
127 char *valname = NULL;
128 struct registry_value *valvalue = NULL;
129 int ret = -1;
131 if (argc != 1 || c->display_usage) {
132 d_printf("Usage: net registry enumerate <path>\n");
133 d_printf("Example: net registry enumerate "
134 "'HKLM\\Software\\Samba'\n");
135 goto done;
138 werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
139 if (!W_ERROR_IS_OK(werr)) {
140 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
141 goto done;
144 for (count = 0;
145 werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
146 W_ERROR_IS_OK(werr);
147 count++)
149 print_registry_key(subkey_name, &modtime);
151 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
152 goto done;
155 for (count = 0;
156 werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
157 W_ERROR_IS_OK(werr);
158 count++)
160 print_registry_value_with_name(valname, valvalue);
162 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
163 goto done;
166 ret = 0;
167 done:
168 TALLOC_FREE(ctx);
169 return ret;
172 static int net_registry_createkey(struct net_context *c, int argc,
173 const char **argv)
175 WERROR werr;
176 enum winreg_CreateAction action;
177 char *subkeyname;
178 struct registry_key *hivekey = NULL;
179 struct registry_key *subkey = NULL;
180 TALLOC_CTX *ctx = talloc_stackframe();
181 int ret = -1;
183 if (argc != 1 || c->display_usage) {
184 d_printf("Usage: net registry createkey <path>\n");
185 d_printf("Example: net registry createkey "
186 "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n");
187 goto done;
189 if (strlen(argv[0]) == 0) {
190 d_fprintf(stderr, "error: zero length key name given\n");
191 goto done;
194 werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
195 if (!W_ERROR_IS_OK(werr)) {
196 d_fprintf(stderr, "open_hive failed: %s\n", dos_errstr(werr));
197 goto done;
200 werr = reg_createkey(ctx, hivekey, subkeyname, REG_KEY_WRITE,
201 &subkey, &action);
202 if (!W_ERROR_IS_OK(werr)) {
203 d_fprintf(stderr, "reg_createkey failed: %s\n",
204 dos_errstr(werr));
205 goto done;
207 switch (action) {
208 case REG_ACTION_NONE:
209 d_printf("createkey did nothing -- huh?\n");
210 break;
211 case REG_CREATED_NEW_KEY:
212 d_printf("createkey created %s\n", argv[0]);
213 break;
214 case REG_OPENED_EXISTING_KEY:
215 d_printf("createkey opened existing %s\n", argv[0]);
216 break;
219 ret = 0;
221 done:
222 TALLOC_FREE(ctx);
223 return ret;
226 static int net_registry_deletekey(struct net_context *c, int argc,
227 const char **argv)
229 WERROR werr;
230 char *subkeyname;
231 struct registry_key *hivekey = NULL;
232 TALLOC_CTX *ctx = talloc_stackframe();
233 int ret = -1;
235 if (argc != 1 || c->display_usage) {
236 d_printf("Usage: net registry deletekey <path>\n");
237 d_printf("Example: net registry deletekey "
238 "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n");
239 goto done;
241 if (strlen(argv[0]) == 0) {
242 d_fprintf(stderr, "error: zero length key name given\n");
243 goto done;
246 werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
247 if (!W_ERROR_IS_OK(werr)) {
248 d_fprintf(stderr, "open_hive failed: %s\n", dos_errstr(werr));
249 goto done;
252 werr = reg_deletekey(hivekey, subkeyname);
253 if (!W_ERROR_IS_OK(werr)) {
254 d_fprintf(stderr, "reg_deletekey failed: %s\n",
255 dos_errstr(werr));
256 goto done;
259 ret = 0;
261 done:
262 TALLOC_FREE(ctx);
263 return ret;
266 static int net_registry_getvalue_internal(struct net_context *c, int argc,
267 const char **argv, bool raw)
269 WERROR werr;
270 int ret = -1;
271 struct registry_key *key = NULL;
272 struct registry_value *value = NULL;
273 TALLOC_CTX *ctx = talloc_stackframe();
275 if (argc != 2 || c->display_usage) {
276 d_fprintf(stderr, "usage: net rpc registry getvalue <key> "
277 "<valuename>\n");
278 goto done;
281 werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
282 if (!W_ERROR_IS_OK(werr)) {
283 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
284 goto done;
287 werr = reg_queryvalue(ctx, key, argv[1], &value);
288 if (!W_ERROR_IS_OK(werr)) {
289 d_fprintf(stderr, "reg_queryvalue failed: %s\n",
290 dos_errstr(werr));
291 goto done;
294 print_registry_value(value, raw);
296 ret = 0;
298 done:
299 TALLOC_FREE(ctx);
300 return ret;
303 static int net_registry_getvalue(struct net_context *c, int argc,
304 const char **argv)
306 return net_registry_getvalue_internal(c, argc, argv, false);
309 static int net_registry_getvalueraw(struct net_context *c, int argc,
310 const char **argv)
312 return net_registry_getvalue_internal(c, argc, argv, true);
315 static int net_registry_setvalue(struct net_context *c, int argc,
316 const char **argv)
318 WERROR werr;
319 struct registry_value value;
320 struct registry_key *key = NULL;
321 int ret = -1;
322 TALLOC_CTX *ctx = talloc_stackframe();
324 if (argc < 4 || c->display_usage) {
325 d_fprintf(stderr, "usage: net rpc registry setvalue <key> "
326 "<valuename> <type> [<val>]+\n");
327 goto done;
330 if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
331 d_fprintf(stderr, "Too many args for type %s\n", argv[2]);
332 goto done;
335 if (strequal(argv[2], "dword")) {
336 value.type = REG_DWORD;
337 value.v.dword = strtoul(argv[3], NULL, 10);
338 } else if (strequal(argv[2], "sz")) {
339 value.type = REG_SZ;
340 value.v.sz.len = strlen(argv[3])+1;
341 value.v.sz.str = CONST_DISCARD(char *, argv[3]);
342 } else if (strequal(argv[2], "multi_sz")) {
343 value.type = REG_MULTI_SZ;
344 value.v.multi_sz.num_strings = argc - 3;
345 value.v.multi_sz.strings = (char **)(argv + 3);
346 } else {
347 d_fprintf(stderr, "type \"%s\" not implemented\n", argv[2]);
348 goto done;
351 werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
352 if (!W_ERROR_IS_OK(werr)) {
353 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
354 goto done;
357 werr = reg_setvalue(key, argv[1], &value);
358 if (!W_ERROR_IS_OK(werr)) {
359 d_fprintf(stderr, "reg_setvalue failed: %s\n",
360 dos_errstr(werr));
361 goto done;
364 ret = 0;
366 done:
367 TALLOC_FREE(ctx);
368 return ret;
371 static int net_registry_deletevalue(struct net_context *c, int argc,
372 const char **argv)
374 WERROR werr;
375 struct registry_key *key = NULL;
376 TALLOC_CTX *ctx = talloc_stackframe();
377 int ret = -1;
379 if (argc != 2 || c->display_usage) {
380 d_fprintf(stderr, "usage: net rpc registry deletevalue <key> "
381 "<valuename>\n");
382 goto done;
385 werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
386 if (!W_ERROR_IS_OK(werr)) {
387 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
388 goto done;
391 werr = reg_deletevalue(key, argv[1]);
392 if (!W_ERROR_IS_OK(werr)) {
393 d_fprintf(stderr, "reg_deletekey failed: %s\n",
394 dos_errstr(werr));
395 goto done;
398 ret = 0;
400 done:
401 TALLOC_FREE(ctx);
402 return ret;
405 static int net_registry_getsd(struct net_context *c, int argc,
406 const char **argv)
408 WERROR werr;
409 int ret = -1;
410 struct registry_key *key = NULL;
411 struct security_descriptor *secdesc = NULL;
412 TALLOC_CTX *ctx = talloc_stackframe();
413 uint32_t access_mask = REG_KEY_READ |
414 SEC_RIGHT_MAXIMUM_ALLOWED |
415 SEC_RIGHT_SYSTEM_SECURITY;
418 * net_rpc_regsitry uses SEC_RIGHT_SYSTEM_SECURITY, but access
419 * is denied with these perms right now...
421 access_mask = REG_KEY_READ;
423 if (argc != 1 || c->display_usage) {
424 d_printf("Usage: net registry getsd <path>\n");
425 d_printf("Example: net registry getsd "
426 "'HKLM\\Software\\Samba'\n");
427 goto done;
429 if (strlen(argv[0]) == 0) {
430 d_fprintf(stderr, "error: zero length key name given\n");
431 goto done;
434 werr = open_key(ctx, argv[0], access_mask, &key);
435 if (!W_ERROR_IS_OK(werr)) {
436 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
437 goto done;
440 werr = reg_getkeysecurity(ctx, key, &secdesc);
441 if (!W_ERROR_IS_OK(werr)) {
442 d_fprintf(stderr, "reg_getkeysecurity failed: %s\n",
443 dos_errstr(werr));
444 goto done;
447 display_sec_desc(secdesc);
449 ret = 0;
451 done:
452 TALLOC_FREE(ctx);
453 return ret;
456 int net_registry(struct net_context *c, int argc, const char **argv)
458 int ret = -1;
460 struct functable func[] = {
462 "enumerate",
463 net_registry_enumerate,
464 NET_TRANSPORT_LOCAL,
465 "Enumerate registry keys and values",
466 "net registry enumerate\n"
467 " Enumerate registry keys and values"
470 "createkey",
471 net_registry_createkey,
472 NET_TRANSPORT_LOCAL,
473 "Create a new registry key",
474 "net registry createkey\n"
475 " Create a new registry key"
478 "deletekey",
479 net_registry_deletekey,
480 NET_TRANSPORT_LOCAL,
481 "Delete a registry key",
482 "net registry deletekey\n"
483 " Delete a registry key"
486 "getvalue",
487 net_registry_getvalue,
488 NET_TRANSPORT_LOCAL,
489 "Print a registry value",
490 "net registry getvalue\n"
491 " Print a registry value"
494 "getvalueraw",
495 net_registry_getvalueraw,
496 NET_TRANSPORT_LOCAL,
497 "Print a registry value (raw format)",
498 "net registry getvalueraw\n"
499 " Print a registry value (raw format)"
502 "setvalue",
503 net_registry_setvalue,
504 NET_TRANSPORT_LOCAL,
505 "Set a new registry value",
506 "net registry setvalue\n"
507 " Set a new registry value"
510 "deletevalue",
511 net_registry_deletevalue,
512 NET_TRANSPORT_LOCAL,
513 "Delete a registry value",
514 "net registry deletevalue\n"
515 " Delete a registry value"
518 "getsd",
519 net_registry_getsd,
520 NET_TRANSPORT_LOCAL,
521 "Get security descriptor",
522 "net registry getsd\n"
523 " Get security descriptor"
525 { NULL, NULL, 0, NULL, NULL }
528 if (!W_ERROR_IS_OK(registry_init_basic())) {
529 return -1;
532 ret = net_run_function(c, argc, argv, "net registry", func);
534 return ret;