2b2ed96f91515d4234a2aa327fe7ca9e966a8e2d
[amitay/samba.git] / source3 / utils / net_rpc_registry.c
1 /* 
2    Samba Unix/Linux SMB client library 
3    Distributed SMB/CIFS Server Management Utility 
4
5    Copyright (C) Gerald (Jerry) Carter          2005-2006
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19  
20 #include "includes.h"
21 #include "registry.h"
22 #include "utils/net.h"
23 #include "utils/net_registry_util.h"
24 #include "regfio.h"
25 #include "../librpc/gen_ndr/cli_winreg.h"
26
27 /*******************************************************************
28  connect to a registry hive root (open a registry policy)
29 *******************************************************************/
30
31 static NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
32                                       uint32_t reg_type, uint32_t access_mask,
33                                       struct policy_handle *reg_hnd)
34 {
35         ZERO_STRUCTP(reg_hnd);
36
37         switch (reg_type)
38         {
39         case HKEY_CLASSES_ROOT:
40                 return rpccli_winreg_OpenHKCR( cli, mem_ctx, NULL,
41                         access_mask, reg_hnd, NULL);
42
43         case HKEY_LOCAL_MACHINE:
44                 return rpccli_winreg_OpenHKLM( cli, mem_ctx, NULL,
45                         access_mask, reg_hnd, NULL);
46
47         case HKEY_USERS:
48                 return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL,
49                         access_mask, reg_hnd, NULL);
50
51         case HKEY_CURRENT_USER:
52                 return rpccli_winreg_OpenHKCU( cli, mem_ctx, NULL,
53                         access_mask, reg_hnd, NULL);
54
55         case HKEY_PERFORMANCE_DATA:
56                 return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL,
57                         access_mask, reg_hnd, NULL);
58
59         default:
60                 /* fall through to end of function */
61                 break;
62         }
63
64         return NT_STATUS_INVALID_PARAMETER;
65 }
66
67 static bool reg_hive_key(TALLOC_CTX *ctx, const char *fullname,
68                          uint32 *reg_type, const char **key_name)
69 {
70         WERROR werr;
71         char *hivename = NULL;
72         char *tmp_keyname = NULL;
73         bool ret = false;
74         TALLOC_CTX *tmp_ctx = talloc_stackframe();
75
76         werr = split_hive_key(tmp_ctx, fullname, &hivename, &tmp_keyname);
77         if (!W_ERROR_IS_OK(werr)) {
78                 goto done;
79         }
80
81         *key_name = talloc_strdup(ctx, tmp_keyname);
82         if (*key_name == NULL) {
83                 goto done;
84         }
85
86         if (strequal(hivename, "HKLM") ||
87             strequal(hivename, "HKEY_LOCAL_MACHINE"))
88         {
89                 (*reg_type) = HKEY_LOCAL_MACHINE;
90         } else if (strequal(hivename, "HKCR") ||
91                    strequal(hivename, "HKEY_CLASSES_ROOT"))
92         {
93                 (*reg_type) = HKEY_CLASSES_ROOT;
94         } else if (strequal(hivename, "HKU") ||
95                    strequal(hivename, "HKEY_USERS"))
96         {
97                 (*reg_type) = HKEY_USERS;
98         } else if (strequal(hivename, "HKCU") ||
99                    strequal(hivename, "HKEY_CURRENT_USER"))
100         {
101                 (*reg_type) = HKEY_CURRENT_USER;
102         } else if (strequal(hivename, "HKPD") ||
103                    strequal(hivename, "HKEY_PERFORMANCE_DATA"))
104         {
105                 (*reg_type) = HKEY_PERFORMANCE_DATA;
106         } else {
107                 DEBUG(10,("reg_hive_key: unrecognised hive key %s\n",
108                           fullname));
109                 goto done;
110         }
111
112         ret = true;
113
114 done:
115         TALLOC_FREE(tmp_ctx);
116         return ret;
117 }
118
119 static NTSTATUS registry_openkey(TALLOC_CTX *mem_ctx,
120                                  struct rpc_pipe_client *pipe_hnd,
121                                  const char *name, uint32 access_mask,
122                                  struct policy_handle *hive_hnd,
123                                  struct policy_handle *key_hnd)
124 {
125         uint32 hive;
126         NTSTATUS status;
127         struct winreg_String key;
128
129         ZERO_STRUCT(key);
130
131         if (!reg_hive_key(mem_ctx, name, &hive, &key.name)) {
132                 return NT_STATUS_INVALID_PARAMETER;
133         }
134
135         status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive, access_mask,
136                                        hive_hnd);
137         if (!(NT_STATUS_IS_OK(status))) {
138                 return status;
139         }
140
141         status = rpccli_winreg_OpenKey(pipe_hnd, mem_ctx, hive_hnd, key, 0,
142                                        access_mask, key_hnd, NULL);
143         if (!(NT_STATUS_IS_OK(status))) {
144                 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, hive_hnd, NULL);
145                 return status;
146         }
147
148         return NT_STATUS_OK;
149 }
150
151 static NTSTATUS registry_enumkeys(TALLOC_CTX *ctx,
152                                   struct rpc_pipe_client *pipe_hnd,
153                                   struct policy_handle *key_hnd,
154                                   uint32 *pnum_keys, char ***pnames,
155                                   char ***pclasses, NTTIME ***pmodtimes)
156 {
157         TALLOC_CTX *mem_ctx;
158         NTSTATUS status;
159         uint32 num_subkeys, max_subkeylen, max_classlen;
160         uint32 num_values, max_valnamelen, max_valbufsize;
161         uint32 i;
162         NTTIME last_changed_time;
163         uint32 secdescsize;
164         struct winreg_String classname;
165         char **names, **classes;
166         NTTIME **modtimes;
167
168         if (!(mem_ctx = talloc_new(ctx))) {
169                 return NT_STATUS_NO_MEMORY;
170         }
171
172         ZERO_STRUCT(classname);
173         status = rpccli_winreg_QueryInfoKey(
174                 pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
175                 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
176                 &max_valbufsize, &secdescsize, &last_changed_time, NULL );
177
178         if (!NT_STATUS_IS_OK(status)) {
179                 goto error;
180         }
181
182         if (num_subkeys == 0) {
183                 *pnum_keys = 0;
184                 TALLOC_FREE(mem_ctx);
185                 return NT_STATUS_OK;
186         }
187
188         if ((!(names = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_subkeys))) ||
189             (!(classes = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_subkeys))) ||
190             (!(modtimes = TALLOC_ZERO_ARRAY(mem_ctx, NTTIME *,
191                                             num_subkeys)))) {
192                 status = NT_STATUS_NO_MEMORY;
193                 goto error;
194         }
195
196         for (i=0; i<num_subkeys; i++) {
197                 char c, n;
198                 struct winreg_StringBuf class_buf;
199                 struct winreg_StringBuf name_buf;
200                 NTTIME modtime;
201                 WERROR werr;
202
203                 c = '\0';
204                 class_buf.name = &c;
205                 class_buf.size = max_classlen+2;
206
207                 n = '\0';
208                 name_buf.name = &n;
209                 name_buf.size = max_subkeylen+2;
210
211                 ZERO_STRUCT(modtime);
212
213                 status = rpccli_winreg_EnumKey(pipe_hnd, mem_ctx, key_hnd,
214                                                i, &name_buf, &class_buf,
215                                                &modtime, &werr);
216
217                 if (W_ERROR_EQUAL(werr,
218                                   WERR_NO_MORE_ITEMS) ) {
219                         status = NT_STATUS_OK;
220                         break;
221                 }
222                 if (!NT_STATUS_IS_OK(status)) {
223                         goto error;
224                 }
225
226                 classes[i] = NULL;
227
228                 if (class_buf.name &&
229                     (!(classes[i] = talloc_strdup(classes, class_buf.name)))) {
230                         status = NT_STATUS_NO_MEMORY;
231                         goto error;
232                 }
233
234                 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
235                         status = NT_STATUS_NO_MEMORY;
236                         goto error;
237                 }
238
239                 if ((!(modtimes[i] = (NTTIME *)talloc_memdup(
240                                modtimes, &modtime, sizeof(modtime))))) {
241                         status = NT_STATUS_NO_MEMORY;
242                         goto error;
243                 }
244         }
245
246         *pnum_keys = num_subkeys;
247
248         if (pnames) {
249                 *pnames = talloc_move(ctx, &names);
250         }
251         if (pclasses) {
252                 *pclasses = talloc_move(ctx, &classes);
253         }
254         if (pmodtimes) {
255                 *pmodtimes = talloc_move(ctx, &modtimes);
256         }
257
258         status = NT_STATUS_OK;
259
260  error:
261         TALLOC_FREE(mem_ctx);
262         return status;
263 }
264
265 static NTSTATUS registry_enumvalues(TALLOC_CTX *ctx,
266                                     struct rpc_pipe_client *pipe_hnd,
267                                     struct policy_handle *key_hnd,
268                                     uint32 *pnum_values, char ***pvalnames,
269                                     struct registry_value ***pvalues)
270 {
271         TALLOC_CTX *mem_ctx;
272         NTSTATUS status;
273         uint32 num_subkeys, max_subkeylen, max_classlen;
274         uint32 num_values, max_valnamelen, max_valbufsize;
275         uint32 i;
276         NTTIME last_changed_time;
277         uint32 secdescsize;
278         struct winreg_String classname;
279         struct registry_value **values;
280         char **names;
281
282         if (!(mem_ctx = talloc_new(ctx))) {
283                 return NT_STATUS_NO_MEMORY;
284         }
285
286         ZERO_STRUCT(classname);
287         status = rpccli_winreg_QueryInfoKey(
288                 pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
289                 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
290                 &max_valbufsize, &secdescsize, &last_changed_time, NULL );
291
292         if (!NT_STATUS_IS_OK(status)) {
293                 goto error;
294         }
295
296         if (num_values == 0) {
297                 *pnum_values = 0;
298                 TALLOC_FREE(mem_ctx);
299                 return NT_STATUS_OK;
300         }
301
302         if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
303             (!(values = TALLOC_ARRAY(mem_ctx, struct registry_value *,
304                                      num_values)))) {
305                 status = NT_STATUS_NO_MEMORY;
306                 goto error;
307         }
308
309         for (i=0; i<num_values; i++) {
310                 enum winreg_Type type = REG_NONE;
311                 uint8 *data = NULL;
312                 uint32 data_size;
313                 uint32 value_length;
314
315                 char n;
316                 struct winreg_ValNameBuf name_buf;
317                 WERROR err;
318
319                 n = '\0';
320                 name_buf.name = &n;
321                 name_buf.size = max_valnamelen + 2;
322
323                 data_size = max_valbufsize;
324                 data = (uint8 *)TALLOC(mem_ctx, data_size);
325                 value_length = 0;
326
327                 status = rpccli_winreg_EnumValue(pipe_hnd, mem_ctx, key_hnd,
328                                                  i, &name_buf, &type,
329                                                  data, &data_size,
330                                                  &value_length, &err);
331
332                 if ( W_ERROR_EQUAL(err,
333                                    WERR_NO_MORE_ITEMS) ) {
334                         status = NT_STATUS_OK;
335                         break;
336                 }
337
338                 if (!(NT_STATUS_IS_OK(status))) {
339                         goto error;
340                 }
341
342                 if (name_buf.name == NULL) {
343                         status = NT_STATUS_INVALID_PARAMETER;
344                         goto error;
345                 }
346
347                 if (!(names[i] = talloc_strdup(names, name_buf.name))) {
348                         status = NT_STATUS_NO_MEMORY;
349                         goto error;
350                 }
351
352                 err = registry_pull_value(values, &values[i], type, data,
353                                           data_size, value_length);
354                 if (!W_ERROR_IS_OK(err)) {
355                         status = werror_to_ntstatus(err);
356                         goto error;
357                 }
358         }
359
360         *pnum_values = num_values;
361
362         if (pvalnames) {
363                 *pvalnames = talloc_move(ctx, &names);
364         }
365         if (pvalues) {
366                 *pvalues = talloc_move(ctx, &values);
367         }
368
369         status = NT_STATUS_OK;
370
371  error:
372         TALLOC_FREE(mem_ctx);
373         return status;
374 }
375
376 static NTSTATUS registry_getsd(TALLOC_CTX *mem_ctx,
377                                struct rpc_pipe_client *pipe_hnd,
378                                struct policy_handle *key_hnd,
379                                uint32_t sec_info,
380                                struct KeySecurityData *sd)
381 {
382         return rpccli_winreg_GetKeySecurity(pipe_hnd, mem_ctx, key_hnd,
383                                             sec_info, sd, NULL);
384 }
385
386
387 static NTSTATUS registry_setvalue(TALLOC_CTX *mem_ctx,
388                                   struct rpc_pipe_client *pipe_hnd,
389                                   struct policy_handle *key_hnd,
390                                   const char *name,
391                                   const struct registry_value *value)
392 {
393         struct winreg_String name_string;
394         DATA_BLOB blob;
395         NTSTATUS result;
396         WERROR err;
397
398         err = registry_push_value(mem_ctx, value, &blob);
399         if (!W_ERROR_IS_OK(err)) {
400                 return werror_to_ntstatus(err);
401         }
402
403         ZERO_STRUCT(name_string);
404
405         name_string.name = name;
406         result = rpccli_winreg_SetValue(pipe_hnd, blob.data, key_hnd,
407                                         name_string, value->type,
408                                         blob.data, blob.length, NULL);
409         TALLOC_FREE(blob.data);
410         return result;
411 }
412
413 static NTSTATUS rpc_registry_setvalue_internal(struct net_context *c,
414                                                const struct dom_sid *domain_sid,
415                                                const char *domain_name,
416                                                struct cli_state *cli,
417                                                struct rpc_pipe_client *pipe_hnd,
418                                                TALLOC_CTX *mem_ctx,
419                                                int argc,
420                                                const char **argv )
421 {
422         struct policy_handle hive_hnd, key_hnd;
423         NTSTATUS status;
424         struct registry_value value;
425
426         status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
427                                   SEC_FLAG_MAXIMUM_ALLOWED,
428                                   &hive_hnd, &key_hnd);
429         if (!NT_STATUS_IS_OK(status)) {
430                 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
431                           nt_errstr(status));
432                 return status;
433         }
434
435         if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
436                 d_fprintf(stderr, _("Too many args for type %s\n"), argv[2]);
437                 return NT_STATUS_NOT_IMPLEMENTED;
438         }
439
440         if (strequal(argv[2], "dword")) {
441                 value.type = REG_DWORD;
442                 value.v.dword = strtoul(argv[3], NULL, 10);
443         }
444         else if (strequal(argv[2], "sz")) {
445                 value.type = REG_SZ;
446                 value.v.sz.len = strlen(argv[3])+1;
447                 value.v.sz.str = CONST_DISCARD(char *, argv[3]);
448         }
449         else {
450                 d_fprintf(stderr, _("type \"%s\" not implemented\n"), argv[2]);
451                 status = NT_STATUS_NOT_IMPLEMENTED;
452                 goto error;
453         }
454
455         status = registry_setvalue(mem_ctx, pipe_hnd, &key_hnd,
456                                    argv[1], &value);
457
458         if (!NT_STATUS_IS_OK(status)) {
459                 d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
460                           nt_errstr(status));
461         }
462
463  error:
464         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
465         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
466
467         return NT_STATUS_OK;
468 }
469
470 static int rpc_registry_setvalue(struct net_context *c, int argc,
471                                  const char **argv )
472 {
473         if (argc < 4 || c->display_usage) {
474                 d_fprintf(stderr, "%s\n%s",
475                           _("Usage:"),
476                           _("net rpc registry setvalue <key> <valuename> "
477                             "<type> [<val>]+\n"));
478                 return -1;
479         }
480
481         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
482                 rpc_registry_setvalue_internal, argc, argv );
483 }
484
485 static NTSTATUS rpc_registry_deletevalue_internal(struct net_context *c,
486                                                   const struct dom_sid *domain_sid,
487                                                   const char *domain_name,
488                                                   struct cli_state *cli,
489                                                   struct rpc_pipe_client *pipe_hnd,
490                                                   TALLOC_CTX *mem_ctx,
491                                                   int argc,
492                                                   const char **argv )
493 {
494         struct policy_handle hive_hnd, key_hnd;
495         NTSTATUS status;
496         struct winreg_String valuename;
497
498         ZERO_STRUCT(valuename);
499
500         status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
501                                   SEC_FLAG_MAXIMUM_ALLOWED,
502                                   &hive_hnd, &key_hnd);
503         if (!NT_STATUS_IS_OK(status)) {
504                 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
505                           nt_errstr(status));
506                 return status;
507         }
508
509         valuename.name = argv[1];
510
511         status = rpccli_winreg_DeleteValue(pipe_hnd, mem_ctx, &key_hnd,
512                                            valuename, NULL);
513
514         if (!NT_STATUS_IS_OK(status)) {
515                 d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
516                           nt_errstr(status));
517         }
518
519         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
520         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
521
522         return status;
523 }
524
525 static int rpc_registry_deletevalue(struct net_context *c, int argc,
526                                     const char **argv )
527 {
528         if (argc != 2 || c->display_usage) {
529                 d_fprintf(stderr, "%s\n%s",
530                           _("Usage:"),
531                           _("net rpc registry deletevalue <key> <valuename>\n"));
532                 return -1;
533         }
534
535         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
536                 rpc_registry_deletevalue_internal, argc, argv );
537 }
538
539 static NTSTATUS rpc_registry_getvalue_internal(struct net_context *c,
540                                                const struct dom_sid *domain_sid,
541                                                const char *domain_name,
542                                                struct cli_state *cli,
543                                                struct rpc_pipe_client *pipe_hnd,
544                                                TALLOC_CTX *mem_ctx,
545                                                bool raw,
546                                                int argc,
547                                                const char **argv)
548 {
549         struct policy_handle hive_hnd, key_hnd;
550         NTSTATUS status;
551         WERROR werr;
552         struct winreg_String valuename;
553         struct registry_value *value = NULL;
554         enum winreg_Type type = REG_NONE;
555         uint8_t *data = NULL;
556         uint32_t data_size = 0;
557         uint32_t value_length = 0;
558         TALLOC_CTX *tmp_ctx = talloc_stackframe();
559
560         ZERO_STRUCT(valuename);
561
562         status = registry_openkey(tmp_ctx, pipe_hnd, argv[0],
563                                   SEC_FLAG_MAXIMUM_ALLOWED,
564                                   &hive_hnd, &key_hnd);
565         if (!NT_STATUS_IS_OK(status)) {
566                 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
567                           nt_errstr(status));
568                 return status;
569         }
570
571         valuename.name = argv[1];
572
573         /*
574          * call QueryValue once with data == NULL to get the
575          * needed memory size to be allocated, then allocate
576          * data buffer and call again.
577          */
578         status = rpccli_winreg_QueryValue(pipe_hnd, tmp_ctx, &key_hnd,
579                                           &valuename,
580                                           &type,
581                                           data,
582                                           &data_size,
583                                           &value_length,
584                                           NULL);
585
586         if (!NT_STATUS_IS_OK(status)) {
587                 d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
588                           nt_errstr(status));
589                 goto done;
590         }
591
592         data = (uint8 *)TALLOC(tmp_ctx, data_size);
593         value_length = 0;
594
595         status = rpccli_winreg_QueryValue(pipe_hnd, tmp_ctx, &key_hnd,
596                                           &valuename,
597                                           &type,
598                                           data,
599                                           &data_size,
600                                           &value_length,
601                                           NULL);
602
603         if (!NT_STATUS_IS_OK(status)) {
604                 d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
605                           nt_errstr(status));
606                 goto done;
607         }
608
609         werr = registry_pull_value(tmp_ctx, &value, type, data,
610                                    data_size, value_length);
611         if (!W_ERROR_IS_OK(werr)) {
612                 status = werror_to_ntstatus(werr);
613                 goto done;
614         }
615
616         print_registry_value(value, raw);
617
618 done:
619         rpccli_winreg_CloseKey(pipe_hnd, tmp_ctx, &key_hnd, NULL);
620         rpccli_winreg_CloseKey(pipe_hnd, tmp_ctx, &hive_hnd, NULL);
621
622         TALLOC_FREE(tmp_ctx);
623
624         return status;
625 }
626
627 static NTSTATUS rpc_registry_getvalue_full(struct net_context *c,
628                                            const struct dom_sid *domain_sid,
629                                            const char *domain_name,
630                                            struct cli_state *cli,
631                                            struct rpc_pipe_client *pipe_hnd,
632                                            TALLOC_CTX *mem_ctx,
633                                            int argc,
634                                            const char **argv)
635 {
636         return rpc_registry_getvalue_internal(c, domain_sid, domain_name,
637                                               cli, pipe_hnd, mem_ctx, false,
638                                               argc, argv);
639 }
640
641 static int rpc_registry_getvalue(struct net_context *c, int argc,
642                                  const char **argv)
643 {
644         if (argc != 2 || c->display_usage) {
645                 d_fprintf(stderr, "%s\n%s",
646                           _("Usage:"),
647                           _("net rpc registry getvalue <key> <valuename>\n"));
648                 return -1;
649         }
650
651         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
652                 rpc_registry_getvalue_full, argc, argv);
653 }
654
655 static NTSTATUS rpc_registry_getvalue_raw(struct net_context *c,
656                                           const struct dom_sid *domain_sid,
657                                           const char *domain_name,
658                                           struct cli_state *cli,
659                                           struct rpc_pipe_client *pipe_hnd,
660                                           TALLOC_CTX *mem_ctx,
661                                           int argc,
662                                           const char **argv)
663 {
664         return rpc_registry_getvalue_internal(c, domain_sid, domain_name,
665                                               cli, pipe_hnd, mem_ctx, true,
666                                               argc, argv);
667 }
668
669 static int rpc_registry_getvalueraw(struct net_context *c, int argc,
670                                     const char **argv)
671 {
672         if (argc != 2 || c->display_usage) {
673                 d_fprintf(stderr, "%s\n%s",
674                           _("Usage:"),
675                           _("net rpc registry getvalue <key> <valuename>\n"));
676                 return -1;
677         }
678
679         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
680                 rpc_registry_getvalue_raw, argc, argv);
681 }
682
683 static NTSTATUS rpc_registry_createkey_internal(struct net_context *c,
684                                                 const struct dom_sid *domain_sid,
685                                                 const char *domain_name,
686                                                 struct cli_state *cli,
687                                                 struct rpc_pipe_client *pipe_hnd,
688                                                 TALLOC_CTX *mem_ctx,
689                                                 int argc,
690                                                 const char **argv )
691 {
692         uint32 hive;
693         struct policy_handle hive_hnd, key_hnd;
694         struct winreg_String key, keyclass;
695         enum winreg_CreateAction action;
696         NTSTATUS status;
697
698         ZERO_STRUCT(key);
699         ZERO_STRUCT(keyclass);
700
701         if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
702                 return NT_STATUS_INVALID_PARAMETER;
703         }
704
705         status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
706                                        SEC_FLAG_MAXIMUM_ALLOWED,
707                                        &hive_hnd);
708         if (!(NT_STATUS_IS_OK(status))) {
709                 return status;
710         }
711
712         action = REG_ACTION_NONE;
713         keyclass.name = "";
714
715         status = rpccli_winreg_CreateKey(pipe_hnd, mem_ctx, &hive_hnd, key,
716                                          keyclass, 0, REG_KEY_READ, NULL,
717                                          &key_hnd, &action, NULL);
718         if (!NT_STATUS_IS_OK(status)) {
719                 d_fprintf(stderr, _("createkey returned %s\n"),
720                           nt_errstr(status));
721                 rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
722                 return status;
723         }
724
725         switch (action) {
726                 case REG_ACTION_NONE:
727                         d_printf(_("createkey did nothing -- huh?\n"));
728                         break;
729                 case REG_CREATED_NEW_KEY:
730                         d_printf(_("createkey created %s\n"), argv[0]);
731                         break;
732                 case REG_OPENED_EXISTING_KEY:
733                         d_printf(_("createkey opened existing %s\n"), argv[0]);
734                         break;
735         }
736
737         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
738         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
739
740         return status;
741 }
742
743 static int rpc_registry_createkey(struct net_context *c, int argc,
744                                   const char **argv )
745 {
746         if (argc != 1 || c->display_usage) {
747                 d_fprintf(stderr, "%s\n%s",
748                           _("Usage:"),
749                           _("net rpc registry createkey <key>\n"));
750                 return -1;
751         }
752
753         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
754                 rpc_registry_createkey_internal, argc, argv );
755 }
756
757 static NTSTATUS rpc_registry_deletekey_internal(struct net_context *c,
758                                                 const struct dom_sid *domain_sid,
759                                                 const char *domain_name,
760                                                 struct cli_state *cli,
761                                                 struct rpc_pipe_client *pipe_hnd,
762                                                 TALLOC_CTX *mem_ctx,
763                                                 int argc,
764                                                 const char **argv )
765 {
766         uint32 hive;
767         struct policy_handle hive_hnd;
768         struct winreg_String key;
769         NTSTATUS status;
770
771         ZERO_STRUCT(key);
772
773         if (!reg_hive_key(mem_ctx, argv[0], &hive, &key.name)) {
774                 return NT_STATUS_INVALID_PARAMETER;
775         }
776
777         status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
778                                        SEC_FLAG_MAXIMUM_ALLOWED,
779                                        &hive_hnd);
780         if (!(NT_STATUS_IS_OK(status))) {
781                 return status;
782         }
783
784         status = rpccli_winreg_DeleteKey(pipe_hnd, mem_ctx, &hive_hnd, key, NULL);
785         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
786
787         if (!NT_STATUS_IS_OK(status)) {
788                 d_fprintf(stderr, _("deletekey returned %s\n"),
789                           nt_errstr(status));
790         }
791
792         return status;
793 }
794
795 static int rpc_registry_deletekey(struct net_context *c, int argc, const char **argv )
796 {
797         if (argc != 1 || c->display_usage) {
798                 d_fprintf(stderr, "%s\n%s",
799                           _("Usage:"),
800                           _("net rpc registry deletekey <key>\n"));
801                 return -1;
802         }
803
804         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
805                 rpc_registry_deletekey_internal, argc, argv );
806 }
807
808 /********************************************************************
809 ********************************************************************/
810
811 static NTSTATUS rpc_registry_enumerate_internal(struct net_context *c,
812                                                 const struct dom_sid *domain_sid,
813                                                 const char *domain_name,
814                                                 struct cli_state *cli,
815                                                 struct rpc_pipe_client *pipe_hnd,
816                                                 TALLOC_CTX *mem_ctx,
817                                                 int argc,
818                                                 const char **argv )
819 {
820         struct policy_handle pol_hive, pol_key;
821         NTSTATUS status;
822         uint32 num_subkeys = 0;
823         uint32 num_values = 0;
824         char **names = NULL, **classes = NULL;
825         NTTIME **modtimes = NULL;
826         uint32 i;
827         struct registry_value **values = NULL;
828
829         if (argc != 1 || c->display_usage) {
830                 d_printf("%s\n%s",
831                          _("Usage:"),
832                          _("net rpc registry enumerate <path>\n"));
833                 d_printf("%s  net rpc registry enumerate "
834                          "'HKLM\\Software\\Samba'\n", _("Example:"));
835                 return NT_STATUS_INVALID_PARAMETER;
836         }
837
838         status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
839                                   &pol_hive, &pol_key);
840         if (!NT_STATUS_IS_OK(status)) {
841                 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
842                           nt_errstr(status));
843                 return status;
844         }
845
846         status = registry_enumkeys(mem_ctx, pipe_hnd, &pol_key, &num_subkeys,
847                                    &names, &classes, &modtimes);
848         if (!NT_STATUS_IS_OK(status)) {
849                 d_fprintf(stderr, _("enumerating keys failed: %s\n"),
850                           nt_errstr(status));
851                 return status;
852         }
853
854         for (i=0; i<num_subkeys; i++) {
855                 print_registry_key(names[i], modtimes[i]);
856         }
857
858         status = registry_enumvalues(mem_ctx, pipe_hnd, &pol_key, &num_values,
859                                      &names, &values);
860         if (!NT_STATUS_IS_OK(status)) {
861                 d_fprintf(stderr, _("enumerating values failed: %s\n"),
862                           nt_errstr(status));
863                 return status;
864         }
865
866         for (i=0; i<num_values; i++) {
867                 print_registry_value_with_name(names[i], values[i]);
868         }
869
870         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
871         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
872
873         return status;
874 }
875
876 /********************************************************************
877 ********************************************************************/
878
879 static int rpc_registry_enumerate(struct net_context *c, int argc,
880                                   const char **argv )
881 {
882         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
883                 rpc_registry_enumerate_internal, argc, argv );
884 }
885
886 /********************************************************************
887 ********************************************************************/
888
889 static NTSTATUS rpc_registry_save_internal(struct net_context *c,
890                                         const struct dom_sid *domain_sid,
891                                         const char *domain_name,
892                                         struct cli_state *cli,
893                                         struct rpc_pipe_client *pipe_hnd,
894                                         TALLOC_CTX *mem_ctx,
895                                         int argc,
896                                         const char **argv )
897 {
898         WERROR result = WERR_GENERAL_FAILURE;
899         struct policy_handle pol_hive, pol_key;
900         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
901         struct winreg_String filename;
902
903         if (argc != 2 || c->display_usage) {
904                 d_printf("%s\n%s",
905                          _("Usage:"),
906                          _("net rpc registry backup <path> <file> \n"));
907                 return NT_STATUS_INVALID_PARAMETER;
908         }
909
910         status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_ALL,
911                                   &pol_hive, &pol_key);
912         if (!NT_STATUS_IS_OK(status)) {
913                 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
914                           nt_errstr(status));
915                 return status;
916         }
917
918         filename.name = argv[1];
919         status = rpccli_winreg_SaveKey( pipe_hnd, mem_ctx, &pol_key, &filename, NULL, NULL);
920         if ( !W_ERROR_IS_OK(result) ) {
921                 d_fprintf(stderr, _("Unable to save [%s] to %s:%s\n"), argv[0],
922                           cli->desthost, argv[1]);
923         }
924
925         /* cleanup */
926
927         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
928         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
929
930         return status;
931 }
932
933 /********************************************************************
934 ********************************************************************/
935
936 static int rpc_registry_save(struct net_context *c, int argc, const char **argv )
937 {
938         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
939                 rpc_registry_save_internal, argc, argv );
940 }
941
942
943 /********************************************************************
944 ********************************************************************/
945
946 static void dump_values( REGF_NK_REC *nk )
947 {
948         int i, j;
949         const char *data_str = NULL;
950         uint32 data_size, data;
951         DATA_BLOB blob;
952
953         if ( !nk->values )
954                 return;
955
956         for ( i=0; i<nk->num_values; i++ ) {
957                 d_printf( "\"%s\" = ", nk->values[i].valuename ? nk->values[i].valuename : "(default)" );
958                 d_printf( "(%s) ", str_regtype( nk->values[i].type ) );
959
960                 data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
961                 switch ( nk->values[i].type ) {
962                         case REG_SZ:
963                                 blob = data_blob_const(nk->values[i].data, data_size);
964                                 pull_reg_sz(talloc_tos(), &blob, &data_str);
965                                 if (!data_str) {
966                                         break;
967                                 }
968                                 d_printf( "%s", data_str );
969                                 break;
970                         case REG_MULTI_SZ:
971                         case REG_EXPAND_SZ:
972                                 for ( j=0; j<data_size; j++ ) {
973                                         d_printf( "%c", nk->values[i].data[j] );
974                                 }
975                                 break;
976                         case REG_DWORD:
977                                 data = IVAL( nk->values[i].data, 0 );
978                                 d_printf("0x%x", data );
979                                 break;
980                         case REG_BINARY:
981                                 for ( j=0; j<data_size; j++ ) {
982                                         d_printf( "%x", nk->values[i].data[j] );
983                                 }
984                                 break;
985                         default:
986                                 d_printf(_("unknown"));
987                                 break;
988                 }
989
990                 d_printf( "\n" );
991         }
992
993 }
994
995 /********************************************************************
996 ********************************************************************/
997
998 static bool dump_registry_tree( REGF_FILE *file, REGF_NK_REC *nk, const char *parent )
999 {
1000         REGF_NK_REC *key;
1001
1002         /* depth first dump of the registry tree */
1003
1004         while ( (key = regfio_fetch_subkey( file, nk )) ) {
1005                 char *regpath;
1006                 if (asprintf(&regpath, "%s\\%s", parent, key->keyname) < 0) {
1007                         break;
1008                 }
1009                 d_printf("[%s]\n", regpath );
1010                 dump_values( key );
1011                 d_printf("\n");
1012                 dump_registry_tree( file, key, regpath );
1013                 SAFE_FREE(regpath);
1014         }
1015
1016         return true;
1017 }
1018
1019 /********************************************************************
1020 ********************************************************************/
1021
1022 static bool write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
1023                                  REGF_NK_REC *parent, REGF_FILE *outfile,
1024                                  const char *parentpath )
1025 {
1026         REGF_NK_REC *key, *subkey;
1027         struct regval_ctr *values = NULL;
1028         struct regsubkey_ctr *subkeys = NULL;
1029         int i;
1030         char *path = NULL;
1031         WERROR werr;
1032
1033         werr = regsubkey_ctr_init(infile->mem_ctx, &subkeys);
1034         if (!W_ERROR_IS_OK(werr)) {
1035                 DEBUG(0, ("write_registry_tree: regsubkey_ctr_init failed: "
1036                           "%s\n", win_errstr(werr)));
1037                 return false;
1038         }
1039
1040         if ( !(values = TALLOC_ZERO_P( subkeys, struct regval_ctr )) ) {
1041                 DEBUG(0,("write_registry_tree: talloc() failed!\n"));
1042                 TALLOC_FREE(subkeys);
1043                 return false;
1044         }
1045
1046         /* copy values into the struct regval_ctr */
1047
1048         for ( i=0; i<nk->num_values; i++ ) {
1049                 regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
1050                         nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
1051         }
1052
1053         /* copy subkeys into the struct regsubkey_ctr */
1054
1055         while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
1056                 regsubkey_ctr_addkey( subkeys, subkey->keyname );
1057         }
1058
1059         key = regfio_write_key( outfile, nk->keyname, values, subkeys, nk->sec_desc->sec_desc, parent );
1060
1061         /* write each one of the subkeys out */
1062
1063         path = talloc_asprintf(subkeys,
1064                         "%s%s%s",
1065                         parentpath,
1066                         parent ? "\\" : "",
1067                         nk->keyname);
1068         if (!path) {
1069                 TALLOC_FREE(subkeys);
1070                 return false;
1071         }
1072
1073         nk->subkey_index = 0;
1074         while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
1075                 write_registry_tree( infile, subkey, key, outfile, path );
1076         }
1077
1078         d_printf("[%s]\n", path );
1079         TALLOC_FREE(subkeys);
1080
1081         return true;
1082 }
1083
1084 /********************************************************************
1085 ********************************************************************/
1086
1087 static int rpc_registry_dump(struct net_context *c, int argc, const char **argv)
1088 {
1089         REGF_FILE   *registry;
1090         REGF_NK_REC *nk;
1091
1092         if (argc != 1 || c->display_usage) {
1093                 d_printf("%s\n%s",
1094                          _("Usage:"),
1095                          _("net rpc registry dump <file> \n"));
1096                 return -1;
1097         }
1098
1099         d_printf(_("Opening %s...."), argv[0]);
1100         if ( !(registry = regfio_open( argv[0], O_RDONLY, 0)) ) {
1101                 d_fprintf(stderr, _("Failed to open %s for reading\n"),argv[0]);
1102                 return 1;
1103         }
1104         d_printf(_("ok\n"));
1105
1106         /* get the root of the registry file */
1107
1108         if ((nk = regfio_rootkey( registry )) == NULL) {
1109                 d_fprintf(stderr, _("Could not get rootkey\n"));
1110                 regfio_close( registry );
1111                 return 1;
1112         }
1113         d_printf("[%s]\n", nk->keyname);
1114         dump_values( nk );
1115         d_printf("\n");
1116
1117         dump_registry_tree( registry, nk, nk->keyname );
1118
1119 #if 0
1120         talloc_report_full( registry->mem_ctx, stderr );
1121 #endif
1122         d_printf(_("Closing registry..."));
1123         regfio_close( registry );
1124         d_printf(_("ok\n"));
1125
1126         return 0;
1127 }
1128
1129 /********************************************************************
1130 ********************************************************************/
1131
1132 static int rpc_registry_copy(struct net_context *c, int argc, const char **argv )
1133 {
1134         REGF_FILE   *infile = NULL, *outfile = NULL;
1135         REGF_NK_REC *nk;
1136         int result = 1;
1137
1138         if (argc != 2 || c->display_usage) {
1139                 d_printf("%s\n%s",
1140                          _("Usage:"),
1141                          _("net rpc registry copy <srcfile> <newfile>\n"));
1142                 return -1;
1143         }
1144
1145         d_printf(_("Opening %s...."), argv[0]);
1146         if ( !(infile = regfio_open( argv[0], O_RDONLY, 0 )) ) {
1147                 d_fprintf(stderr, _("Failed to open %s for reading\n"),argv[0]);
1148                 return 1;
1149         }
1150         d_printf(_("ok\n"));
1151
1152         d_printf(_("Opening %s...."), argv[1]);
1153         if ( !(outfile = regfio_open( argv[1], (O_RDWR|O_CREAT|O_TRUNC), (S_IREAD|S_IWRITE) )) ) {
1154                 d_fprintf(stderr, _("Failed to open %s for writing\n"),argv[1]);
1155                 goto out;
1156         }
1157         d_printf(_("ok\n"));
1158
1159         /* get the root of the registry file */
1160
1161         if ((nk = regfio_rootkey( infile )) == NULL) {
1162                 d_fprintf(stderr, _("Could not get rootkey\n"));
1163                 goto out;
1164         }
1165         d_printf(_("RootKey: [%s]\n"), nk->keyname);
1166
1167         write_registry_tree( infile, nk, NULL, outfile, "" );
1168
1169         result = 0;
1170
1171 out:
1172
1173         d_printf(_("Closing %s..."), argv[1]);
1174         if (outfile) {
1175                 regfio_close( outfile );
1176         }
1177         d_printf(_("ok\n"));
1178
1179         d_printf(_("Closing %s..."), argv[0]);
1180         if (infile) {
1181                 regfio_close( infile );
1182         }
1183         d_printf(_("ok\n"));
1184
1185         return( result);
1186 }
1187
1188 /********************************************************************
1189 ********************************************************************/
1190
1191 static NTSTATUS rpc_registry_getsd_internal(struct net_context *c,
1192                                             const struct dom_sid *domain_sid,
1193                                             const char *domain_name,
1194                                             struct cli_state *cli,
1195                                             struct rpc_pipe_client *pipe_hnd,
1196                                             TALLOC_CTX *mem_ctx,
1197                                             int argc,
1198                                             const char **argv)
1199 {
1200         struct policy_handle pol_hive, pol_key;
1201         NTSTATUS status;
1202         enum ndr_err_code ndr_err;
1203         struct KeySecurityData *sd = NULL;
1204         uint32_t sec_info;
1205         DATA_BLOB blob;
1206         struct security_descriptor sec_desc;
1207         uint32_t access_mask = REG_KEY_READ |
1208                                SEC_FLAG_MAXIMUM_ALLOWED |
1209                                SEC_FLAG_SYSTEM_SECURITY;
1210
1211         if (argc <1 || argc > 2 || c->display_usage) {
1212                 d_printf("%s\n%s",
1213                          _("Usage:"),
1214                          _("net rpc registry getsd <path> <secinfo>\n"));
1215                 d_printf("%s  net rpc registry getsd "
1216                            "'HKLM\\Software\\Samba'\n", _("Example:"));
1217                 return NT_STATUS_INVALID_PARAMETER;
1218         }
1219
1220         status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
1221                                   access_mask,
1222                                   &pol_hive, &pol_key);
1223         if (!NT_STATUS_IS_OK(status)) {
1224                 d_fprintf(stderr, _("registry_openkey failed: %s\n"),
1225                           nt_errstr(status));
1226                 return status;
1227         }
1228
1229         sd = TALLOC_ZERO_P(mem_ctx, struct KeySecurityData);
1230         if (!sd) {
1231                 status = NT_STATUS_NO_MEMORY;
1232                 goto out;
1233         }
1234
1235         sd->size = 0x1000;
1236
1237         if (argc >= 2) {
1238                 sscanf(argv[1], "%x", &sec_info);
1239         } else {
1240                 sec_info = SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL;
1241         }
1242
1243         status = registry_getsd(mem_ctx, pipe_hnd, &pol_key, sec_info, sd);
1244         if (!NT_STATUS_IS_OK(status)) {
1245                 d_fprintf(stderr, _("getting sd failed: %s\n"),
1246                           nt_errstr(status));
1247                 goto out;
1248         }
1249
1250         blob.data = sd->data;
1251         blob.length = sd->size;
1252
1253         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &sec_desc,
1254                                        (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
1255         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1256                 status = ndr_map_error2ntstatus(ndr_err);
1257                 goto out;
1258         }
1259         status = NT_STATUS_OK;
1260
1261         display_sec_desc(&sec_desc);
1262
1263  out:
1264         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
1265         rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
1266
1267         return status;
1268 }
1269
1270
1271 static int rpc_registry_getsd(struct net_context *c, int argc, const char **argv)
1272 {
1273         return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
1274                 rpc_registry_getsd_internal, argc, argv);
1275 }
1276
1277 /********************************************************************
1278 ********************************************************************/
1279
1280 int net_rpc_registry(struct net_context *c, int argc, const char **argv)
1281 {
1282         struct functable func[] = {
1283                 {
1284                         "enumerate",
1285                         rpc_registry_enumerate,
1286                         NET_TRANSPORT_RPC,
1287                         N_("Enumerate registry keys and values"),
1288                         N_("net rpc registry enumerate\n"
1289                            "    Enumerate registry keys and values")
1290                 },
1291                 {
1292                         "createkey",
1293                         rpc_registry_createkey,
1294                         NET_TRANSPORT_RPC,
1295                         N_("Create a new registry key"),
1296                         N_("net rpc registry createkey\n"
1297                            "    Create a new registry key")
1298                 },
1299                 {
1300                         "deletekey",
1301                         rpc_registry_deletekey,
1302                         NET_TRANSPORT_RPC,
1303                         N_("Delete a registry key"),
1304                         N_("net rpc registry deletekey\n"
1305                            "    Delete a registry key")
1306                 },
1307                 {
1308                         "getvalue",
1309                         rpc_registry_getvalue,
1310                         NET_TRANSPORT_RPC,
1311                         N_("Print a registry value"),
1312                         N_("net rpc registry getvalue\n"
1313                            "    Print a registry value")
1314                 },
1315                 {
1316                         "getvalueraw",
1317                         rpc_registry_getvalueraw,
1318                         NET_TRANSPORT_RPC,
1319                         N_("Print a registry value"),
1320                         N_("net rpc registry getvalueraw\n"
1321                            "    Print a registry value (raw version)")
1322                 },
1323                 {
1324                         "setvalue",
1325                         rpc_registry_setvalue,
1326                         NET_TRANSPORT_RPC,
1327                         N_("Set a new registry value"),
1328                         N_("net rpc registry setvalue\n"
1329                            "    Set a new registry value")
1330                 },
1331                 {
1332                         "deletevalue",
1333                         rpc_registry_deletevalue,
1334                         NET_TRANSPORT_RPC,
1335                         N_("Delete a registry value"),
1336                         N_("net rpc registry deletevalue\n"
1337                            "    Delete a registry value")
1338                 },
1339                 {
1340                         "save",
1341                         rpc_registry_save,
1342                         NET_TRANSPORT_RPC,
1343                         N_("Save a registry file"),
1344                         N_("net rpc registry save\n"
1345                            "    Save a registry file")
1346                 },
1347                 {
1348                         "dump",
1349                         rpc_registry_dump,
1350                         NET_TRANSPORT_RPC,
1351                         N_("Dump a registry file"),
1352                         N_("net rpc registry dump\n"
1353                            "    Dump a registry file")
1354                 },
1355                 {
1356                         "copy",
1357                         rpc_registry_copy,
1358                         NET_TRANSPORT_RPC,
1359                         N_("Copy a registry file"),
1360                         N_("net rpc registry copy\n"
1361                            "    Copy a registry file")
1362                 },
1363                 {
1364                         "getsd",
1365                         rpc_registry_getsd,
1366                         NET_TRANSPORT_RPC,
1367                         N_("Get security descriptor"),
1368                         N_("net rpc registry getsd\n"
1369                            "    Get security descriptior")
1370                 },
1371                 {NULL, NULL, 0, NULL, NULL}
1372         };
1373
1374         return net_run_function(c, argc, argv, "net rpc registry", func);
1375 }