s3:net: fix some i18n messages in net_registry_getsd_internal().
[amitay/samba.git] / source3 / utils / net_registry.c
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 "utils/net.h"
24 #include "utils/net_registry_util.h"
25
26
27 /*
28  *
29  * Helper functions
30  *
31  */
32
33 /**
34  * split given path into hive and remaining path and open the hive key
35  */
36 static WERROR open_hive(TALLOC_CTX *ctx, const char *path,
37                         uint32 desired_access,
38                         struct registry_key **hive,
39                         char **subkeyname)
40 {
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();
46
47         if ((hive == NULL) || (subkeyname == NULL)) {
48                 werr = WERR_INVALID_PARAM;
49                 goto done;
50         }
51
52         werr = split_hive_key(tmp_ctx, path, &hivename, &tmp_subkeyname);
53         if (!W_ERROR_IS_OK(werr)) {
54                 goto done;
55         }
56         *subkeyname = talloc_strdup(ctx, tmp_subkeyname);
57         if (*subkeyname == NULL) {
58                 werr = WERR_NOMEM;
59                 goto done;
60         }
61
62         werr = ntstatus_to_werror(registry_create_admin_token(tmp_ctx, &token));
63         if (!W_ERROR_IS_OK(werr)) {
64                 goto done;
65         }
66
67         werr = reg_openhive(ctx, hivename, desired_access, token, hive);
68         if (!W_ERROR_IS_OK(werr)) {
69                 goto done;
70         }
71
72         werr = WERR_OK;
73
74 done:
75         TALLOC_FREE(tmp_ctx);
76         return werr;
77 }
78
79 static WERROR open_key(TALLOC_CTX *ctx, const char *path,
80                        uint32 desired_access,
81                        struct registry_key **key)
82 {
83         WERROR werr;
84         char *subkey_name = NULL;
85         struct registry_key *hive = NULL;
86         TALLOC_CTX *tmp_ctx = talloc_stackframe();
87
88         if ((path == NULL) || (key == NULL)) {
89                 return WERR_INVALID_PARAM;
90         }
91
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"),
95                           win_errstr(werr));
96                 goto done;
97         }
98
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"),
102                           win_errstr(werr));
103                 goto done;
104         }
105
106         werr = WERR_OK;
107
108 done:
109         TALLOC_FREE(tmp_ctx);
110         return werr;
111 }
112
113 /*
114  *
115  * the main "net registry" function implementations
116  *
117  */
118
119 static int net_registry_enumerate(struct net_context *c, int argc,
120                                   const char **argv)
121 {
122         WERROR werr;
123         struct registry_key *key = NULL;
124         TALLOC_CTX *ctx = talloc_stackframe();
125         char *subkey_name;
126         NTTIME modtime;
127         uint32_t count;
128         char *valname = NULL;
129         struct registry_value *valvalue = NULL;
130         int ret = -1;
131
132         if (argc != 1 || c->display_usage) {
133                 d_printf("%s\n%s",
134                          _("Usage:"),
135                          _("net registry enumerate <path>\n"));
136                 d_printf("%s\n%s",
137                          _("Example:"),
138                          _("net registry enumerate 'HKLM\\Software\\Samba'\n"));
139                 goto done;
140         }
141
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));
145                 goto done;
146         }
147
148         for (count = 0;
149              werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
150              W_ERROR_IS_OK(werr);
151              count++)
152         {
153                 print_registry_key(subkey_name, &modtime);
154         }
155         if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
156                 goto done;
157         }
158
159         for (count = 0;
160              werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
161              W_ERROR_IS_OK(werr);
162              count++)
163         {
164                 print_registry_value_with_name(valname, valvalue);
165         }
166         if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
167                 goto done;
168         }
169
170         ret = 0;
171 done:
172         TALLOC_FREE(ctx);
173         return ret;
174 }
175
176 static int net_registry_createkey(struct net_context *c, int argc,
177                                   const char **argv)
178 {
179         WERROR werr;
180         enum winreg_CreateAction action;
181         char *subkeyname;
182         struct registry_key *hivekey = NULL;
183         struct registry_key *subkey = NULL;
184         TALLOC_CTX *ctx = talloc_stackframe();
185         int ret = -1;
186
187         if (argc != 1 || c->display_usage) {
188                 d_printf("%s\n%s",
189                          _("Usage:"),
190                          _("net registry createkey <path>\n"));
191                 d_printf("%s\n%s",
192                          _("Example:"),
193                          _("net registry createkey "
194                            "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n"));
195                 goto done;
196         }
197         if (strlen(argv[0]) == 0) {
198                 d_fprintf(stderr, _("error: zero length key name given\n"));
199                 goto done;
200         }
201
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"),
205                           win_errstr(werr));
206                 goto done;
207         }
208
209         werr = reg_createkey(ctx, hivekey, subkeyname, REG_KEY_WRITE,
210                              &subkey, &action);
211         if (!W_ERROR_IS_OK(werr)) {
212                 d_fprintf(stderr, _("reg_createkey failed: %s\n"),
213                           win_errstr(werr));
214                 goto done;
215         }
216         switch (action) {
217                 case REG_ACTION_NONE:
218                         d_printf(_("createkey did nothing -- huh?\n"));
219                         break;
220                 case REG_CREATED_NEW_KEY:
221                         d_printf(_("createkey created %s\n"), argv[0]);
222                         break;
223                 case REG_OPENED_EXISTING_KEY:
224                         d_printf(_("createkey opened existing %s\n"), argv[0]);
225                         break;
226         }
227
228         ret = 0;
229
230 done:
231         TALLOC_FREE(ctx);
232         return ret;
233 }
234
235 static int net_registry_deletekey(struct net_context *c, int argc,
236                                   const char **argv)
237 {
238         WERROR werr;
239         char *subkeyname;
240         struct registry_key *hivekey = NULL;
241         TALLOC_CTX *ctx = talloc_stackframe();
242         int ret = -1;
243
244         if (argc != 1 || c->display_usage) {
245                 d_printf("%s\n%s",
246                          _("Usage:"),
247                          _("net registry deletekey <path>\n"));
248                 d_printf("%s\n%s",
249                          _("Example:"),
250                          _("net registry deletekey "
251                            "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n"));
252                 goto done;
253         }
254         if (strlen(argv[0]) == 0) {
255                 d_fprintf(stderr, _("error: zero length key name given\n"));
256                 goto done;
257         }
258
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"),
262                           win_errstr(werr));
263                 goto done;
264         }
265
266         werr = reg_deletekey(hivekey, subkeyname);
267         if (!W_ERROR_IS_OK(werr)) {
268                 d_fprintf(stderr, "reg_deletekey %s: %s\n", _("failed"),
269                           win_errstr(werr));
270                 goto done;
271         }
272
273         ret = 0;
274
275 done:
276         TALLOC_FREE(ctx);
277         return ret;
278 }
279
280 static int net_registry_getvalue_internal(struct net_context *c, int argc,
281                                           const char **argv, bool raw)
282 {
283         WERROR werr;
284         int ret = -1;
285         struct registry_key *key = NULL;
286         struct registry_value *value = NULL;
287         TALLOC_CTX *ctx = talloc_stackframe();
288
289         if (argc != 2 || c->display_usage) {
290                 d_fprintf(stderr, "%s\n%s",
291                           _("Usage:"),
292                           _("net rpc registry getvalue <key> <valuename>\n"));
293                 goto done;
294         }
295
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));
299                 goto done;
300         }
301
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"),
305                           win_errstr(werr));
306                 goto done;
307         }
308
309         print_registry_value(value, raw);
310
311         ret = 0;
312
313 done:
314         TALLOC_FREE(ctx);
315         return ret;
316 }
317
318 static int net_registry_getvalue(struct net_context *c, int argc,
319                                  const char **argv)
320 {
321         return net_registry_getvalue_internal(c, argc, argv, false);
322 }
323
324 static int net_registry_getvalueraw(struct net_context *c, int argc,
325                                     const char **argv)
326 {
327         return net_registry_getvalue_internal(c, argc, argv, true);
328 }
329
330 static int net_registry_setvalue(struct net_context *c, int argc,
331                                  const char **argv)
332 {
333         WERROR werr;
334         struct registry_value value;
335         struct registry_key *key = NULL;
336         int ret = -1;
337         TALLOC_CTX *ctx = talloc_stackframe();
338
339         if (argc < 4 || c->display_usage) {
340                 d_fprintf(stderr, "%s\n%s",
341                           _("Usage:"),
342                           _("net rpc registry setvalue <key> <valuename> "
343                             "<type> [<val>]+\n"));
344                 goto done;
345         }
346
347         if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
348                 d_fprintf(stderr, _("Too many args for type %s\n"), argv[2]);
349                 goto done;
350         }
351
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")) {
356                 value.type = REG_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);
363         } else {
364                 d_fprintf(stderr, _("type \"%s\" not implemented\n"), argv[2]);
365                 goto done;
366         }
367
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));
371                 goto done;
372         }
373
374         werr = reg_setvalue(key, argv[1], &value);
375         if (!W_ERROR_IS_OK(werr)) {
376                 d_fprintf(stderr, _("reg_setvalue failed: %s\n"),
377                           win_errstr(werr));
378                 goto done;
379         }
380
381         ret = 0;
382
383 done:
384         TALLOC_FREE(ctx);
385         return ret;
386 }
387
388 static int net_registry_deletevalue(struct net_context *c, int argc,
389                                     const char **argv)
390 {
391         WERROR werr;
392         struct registry_key *key = NULL;
393         TALLOC_CTX *ctx = talloc_stackframe();
394         int ret = -1;
395
396         if (argc != 2 || c->display_usage) {
397                 d_fprintf(stderr, "%s\n%s",
398                           _("Usage:"),
399                           _("net rpc registry deletevalue <key> <valuename>\n"));
400                 goto done;
401         }
402
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));
406                 goto done;
407         }
408
409         werr = reg_deletevalue(key, argv[1]);
410         if (!W_ERROR_IS_OK(werr)) {
411                 d_fprintf(stderr, _("reg_deletekey failed: %s\n"),
412                           win_errstr(werr));
413                 goto done;
414         }
415
416         ret = 0;
417
418 done:
419         TALLOC_FREE(ctx);
420         return ret;
421 }
422
423 static WERROR net_registry_getsd_internal(struct net_context *c,
424                                           TALLOC_CTX *mem_ctx,
425                                           const char *keyname,
426                                           struct security_descriptor **sd)
427 {
428         WERROR werr;
429         struct registry_key *key = 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;
434
435         /*
436          * net_rpc_regsitry uses SEC_FLAG_SYSTEM_SECURITY, but access
437          * is denied with these perms right now...
438          */
439         access_mask = REG_KEY_READ;
440
441         if (sd == NULL) {
442                 d_fprintf(stderr, _("internal error: invalid argument\n"));
443                 werr = WERR_INVALID_PARAM;
444                 goto done;
445         }
446
447         if (strlen(keyname) == 0) {
448                 d_fprintf(stderr, _("error: zero length key name given\n"));
449                 werr = WERR_INVALID_PARAM;
450                 goto done;
451         }
452
453         werr = open_key(ctx, keyname, access_mask, &key);
454         if (!W_ERROR_IS_OK(werr)) {
455                 d_fprintf(stderr, "%s%s\n", _("open_key failed: "),
456                           win_errstr(werr));
457                 goto done;
458         }
459
460         werr = reg_getkeysecurity(mem_ctx, key, sd);
461         if (!W_ERROR_IS_OK(werr)) {
462                 d_fprintf(stderr, "%s%s\n", _("reg_getkeysecurity failed: "),
463                           win_errstr(werr));
464                 goto done;
465         }
466
467         werr = WERR_OK;
468
469 done:
470         TALLOC_FREE(ctx);
471         return werr;
472 }
473
474 static int net_registry_getsd(struct net_context *c, int argc,
475                               const char **argv)
476 {
477         WERROR werr;
478         int ret = -1;
479         struct security_descriptor *secdesc = NULL;
480         TALLOC_CTX *ctx = talloc_stackframe();
481
482         if (argc != 1 || c->display_usage) {
483                 d_printf("%s\n%s",
484                          _("Usage:"),
485                          _("net registry getsd <path>\n"));
486                 d_printf("%s\n%s",
487                          _("Example:"),
488                          _("net registry getsd 'HKLM\\Software\\Samba'\n"));
489                 goto done;
490         }
491
492         werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
493         if (!W_ERROR_IS_OK(werr)) {
494                 goto done;
495         }
496
497         display_sec_desc(secdesc);
498
499         ret = 0;
500
501 done:
502         TALLOC_FREE(ctx);
503         return ret;
504 }
505
506 static int net_registry_getsd_sddl(struct net_context *c,
507                                    int argc, const char **argv)
508 {
509         WERROR werr;
510         int ret = -1;
511         struct security_descriptor *secdesc = NULL;
512         TALLOC_CTX *ctx = talloc_stackframe();
513
514         if (argc != 1 || c->display_usage) {
515                 d_printf("%s\n%s",
516                          _("Usage:"),
517                          _("net registry getsd_sddl <path>\n"));
518                 d_printf("%s\n%s",
519                          _("Example:"),
520                          _("net registry getsd_sddl 'HKLM\\Software\\Samba'\n"));
521                 goto done;
522         }
523
524         werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
525         if (!W_ERROR_IS_OK(werr)) {
526                 goto done;
527         }
528
529         d_printf("%s\n", sddl_encode(ctx, secdesc, get_global_sam_sid()));
530
531         ret = 0;
532
533 done:
534         TALLOC_FREE(ctx);
535         return ret;
536 }
537
538 int net_registry(struct net_context *c, int argc, const char **argv)
539 {
540         int ret = -1;
541
542         struct functable func[] = {
543                 {
544                         "enumerate",
545                         net_registry_enumerate,
546                         NET_TRANSPORT_LOCAL,
547                         N_("Enumerate registry keys and values"),
548                         N_("net registry enumerate\n"
549                            "    Enumerate registry keys and values")
550                 },
551                 {
552                         "createkey",
553                         net_registry_createkey,
554                         NET_TRANSPORT_LOCAL,
555                         N_("Create a new registry key"),
556                         N_("net registry createkey\n"
557                            "    Create a new registry key")
558                 },
559                 {
560                         "deletekey",
561                         net_registry_deletekey,
562                         NET_TRANSPORT_LOCAL,
563                         N_("Delete a registry key"),
564                         N_("net registry deletekey\n"
565                            "    Delete a registry key")
566                 },
567                 {
568                         "getvalue",
569                         net_registry_getvalue,
570                         NET_TRANSPORT_LOCAL,
571                         N_("Print a registry value"),
572                         N_("net registry getvalue\n"
573                            "    Print a registry value")
574                 },
575                 {
576                         "getvalueraw",
577                         net_registry_getvalueraw,
578                         NET_TRANSPORT_LOCAL,
579                         N_("Print a registry value (raw format)"),
580                         N_("net registry getvalueraw\n"
581                            "    Print a registry value (raw format)")
582                 },
583                 {
584                         "setvalue",
585                         net_registry_setvalue,
586                         NET_TRANSPORT_LOCAL,
587                         N_("Set a new registry value"),
588                         N_("net registry setvalue\n"
589                            "    Set a new registry value")
590                 },
591                 {
592                         "deletevalue",
593                         net_registry_deletevalue,
594                         NET_TRANSPORT_LOCAL,
595                         N_("Delete a registry value"),
596                         N_("net registry deletevalue\n"
597                            "    Delete a registry value")
598                 },
599                 {
600                         "getsd",
601                         net_registry_getsd,
602                         NET_TRANSPORT_LOCAL,
603                         N_("Get security descriptor"),
604                         N_("net registry getsd\n"
605                            "    Get security descriptor")
606                 },
607                 {
608                         "getsd_sddl",
609                         net_registry_getsd_sddl,
610                         NET_TRANSPORT_LOCAL,
611                         N_("Get security descriptor in sddl format"),
612                         N_("net registry getsd_sddl\n"
613                            "    Get security descriptor in sddl format")
614                 },
615         { NULL, NULL, 0, NULL, NULL }
616         };
617
618         if (!W_ERROR_IS_OK(registry_init_basic())) {
619                 return -1;
620         }
621
622         ret = net_run_function(c, argc, argv, "net registry", func);
623
624         return ret;
625 }