libsmbconf: Convert smbconf_drop() to sbcErr.
[samba.git] / source3 / utils / net_conf.c
1 /*
2  *  Samba Unix/Linux SMB client library
3  *  Distributed SMB/CIFS Server Management Utility
4  *  Local configuration interface
5  *  Copyright (C) Michael Adam 2007-2008
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
21 /*
22  * This is an interface to Samba's configuration as made available
23  * by the libsmbconf interface (source/lib/smbconf/smbconf.c).
24  *
25  * This currently supports local interaction with the configuration
26  * stored in the registry. But other backends and remote access via
27  * rpc might get implemented in the future.
28  */
29
30 #include "includes.h"
31 #include "system/filesys.h"
32 #include "utils/net.h"
33 #include "lib/smbconf/smbconf.h"
34 #include "lib/smbconf/smbconf_init.h"
35 #include "lib/smbconf/smbconf_reg.h"
36
37 /**********************************************************************
38  *
39  * usage functions
40  *
41  **********************************************************************/
42
43 static int net_conf_list_usage(struct net_context *c, int argc,
44                                const char **argv)
45 {
46         d_printf("%s net conf list\n", _("Usage:"));
47         return -1;
48 }
49
50 static int net_conf_import_usage(struct net_context *c, int argc,
51                                  const char**argv)
52 {
53         d_printf("%s\n%s",
54                  _("Usage:"),
55                  _(" net conf import [--test|-T] <filename> "
56                    "[<servicename>]\n"
57                    "\t[--test|-T]    testmode - do not act, just print "
58                         "what would be done\n"
59                    "\t<servicename>  only import service <servicename>, "
60                         "ignore the rest\n"));
61         return -1;
62 }
63
64 static int net_conf_listshares_usage(struct net_context *c, int argc,
65                                      const char **argv)
66 {
67         d_printf("%s\nnet conf listshares\n", _("Usage:"));
68         return -1;
69 }
70
71 static int net_conf_drop_usage(struct net_context *c, int argc,
72                                const char **argv)
73 {
74         d_printf("%s\nnet conf drop\n", _("Usage:"));
75         return -1;
76 }
77
78 static int net_conf_showshare_usage(struct net_context *c, int argc,
79                                     const char **argv)
80 {
81         d_printf("%s\n%s",
82                  _("Usage:"),
83                  _("net conf showshare <sharename>\n"));
84         return -1;
85 }
86
87 static int net_conf_addshare_usage(struct net_context *c, int argc,
88                                    const char **argv)
89 {
90         d_printf("%s\n%s",
91                  _("Usage:"),
92                  _(" net conf addshare <sharename> <path> "
93                    "[writeable={y|N} [guest_ok={y|N} [<comment>]]\n"
94                    "\t<sharename>      the new share name.\n"
95                    "\t<path>           the path on the filesystem to export.\n"
96                    "\twriteable={y|N}  set \"writeable to \"yes\" or "
97                    "\"no\" (default) on this share.\n"
98                    "\tguest_ok={y|N}   set \"guest ok\" to \"yes\" or "
99                    "\"no\" (default)   on this share.\n"
100                    "\t<comment>        optional comment for the new share.\n"));
101         return -1;
102 }
103
104 static int net_conf_delshare_usage(struct net_context *c, int argc,
105                                    const char **argv)
106 {
107         d_printf("%s\n%s",
108                  _("Usage:"),
109                  _("net conf delshare <sharename>\n"));
110         return -1;
111 }
112
113 static int net_conf_setparm_usage(struct net_context *c, int argc,
114                                   const char **argv)
115 {
116         d_printf("%s\n%s",
117                  _("Usage:"),
118                  _(" net conf setparm <section> <param> <value>\n"));
119         return -1;
120 }
121
122 static int net_conf_getparm_usage(struct net_context *c, int argc,
123                                   const char **argv)
124 {
125         d_printf("%s\n%s",
126                  _("Usage:"),
127                  _(" net conf getparm <section> <param>\n"));
128         return -1;
129 }
130
131 static int net_conf_delparm_usage(struct net_context *c, int argc,
132                                   const char **argv)
133 {
134         d_printf("%s\n%s",
135                  _("Usage:"),
136                  _(" net conf delparm <section> <param>\n"));
137         return -1;
138 }
139
140 static int net_conf_getincludes_usage(struct net_context *c, int argc,
141                                       const char **argv)
142 {
143         d_printf("%s\n%s",
144                  _("Usage:"),
145                  _(" net conf getincludes <section>\n"));
146         return -1;
147 }
148
149 static int net_conf_setincludes_usage(struct net_context *c, int argc,
150                                       const char **argv)
151 {
152         d_printf("%s\n%s",
153                  _("Usage:"),
154                  _(" net conf setincludes <section> [<filename>]*\n"));
155         return -1;
156 }
157
158 static int net_conf_delincludes_usage(struct net_context *c, int argc,
159                                       const char **argv)
160 {
161         d_printf("%s\n%s",
162                 _("Usage:"),
163                 _(" net conf delincludes <section>\n"));
164         return -1;
165 }
166
167
168 /**********************************************************************
169  *
170  * Helper functions
171  *
172  **********************************************************************/
173
174 /**
175  * This functions process a service previously loaded with libsmbconf.
176  */
177 static WERROR import_process_service(struct net_context *c,
178                                      struct smbconf_ctx *conf_ctx,
179                                      struct smbconf_service *service)
180 {
181         uint32_t idx;
182         WERROR werr = WERR_OK;
183         uint32_t num_includes = 0;
184         char **includes = NULL;
185         TALLOC_CTX *mem_ctx = talloc_stackframe();
186
187         if (c->opt_testmode) {
188                 const char *indent = "";
189                 if (service->name != NULL) {
190                         d_printf("[%s]\n", service->name);
191                         indent = "\t";
192                 }
193                 for (idx = 0; idx < service->num_params; idx++) {
194                         d_printf("%s%s = %s\n", indent,
195                                  service->param_names[idx],
196                                  service->param_values[idx]);
197                 }
198                 d_printf("\n");
199                 goto done;
200         }
201
202         if (smbconf_share_exists(conf_ctx, service->name)) {
203                 werr = smbconf_delete_share(conf_ctx, service->name);
204                 if (!W_ERROR_IS_OK(werr)) {
205                         goto done;
206                 }
207         }
208         werr = smbconf_create_share(conf_ctx, service->name);
209         if (!W_ERROR_IS_OK(werr)) {
210                 goto done;
211         }
212
213         for (idx = 0; idx < service->num_params; idx ++) {
214                 if (strequal(service->param_names[idx], "include")) {
215                         includes = TALLOC_REALLOC_ARRAY(mem_ctx,
216                                                         includes,
217                                                         char *,
218                                                         num_includes+1);
219                         if (includes == NULL) {
220                                 werr = WERR_NOMEM;
221                                 goto done;
222                         }
223                         includes[num_includes] = talloc_strdup(includes,
224                                                 service->param_values[idx]);
225                         if (includes[num_includes] == NULL) {
226                                 werr = WERR_NOMEM;
227                                 goto done;
228                         }
229                         num_includes++;
230                 } else {
231                         werr = smbconf_set_parameter(conf_ctx,
232                                                      service->name,
233                                                      service->param_names[idx],
234                                                      service->param_values[idx]);
235                         if (!W_ERROR_IS_OK(werr)) {
236                                 d_fprintf(stderr,
237                                           _("Error in section [%s], parameter \"%s\": %s\n"),
238                                           service->name, service->param_names[idx],
239                                           win_errstr(werr));
240                                 goto done;
241                         }
242                 }
243         }
244
245         werr = smbconf_set_includes(conf_ctx, service->name, num_includes,
246                                     (const char **)includes);
247
248 done:
249         TALLOC_FREE(mem_ctx);
250         return werr;
251 }
252
253
254 /**********************************************************************
255  *
256  * the main conf functions
257  *
258  **********************************************************************/
259
260 static int net_conf_list(struct net_context *c, struct smbconf_ctx *conf_ctx,
261                          int argc, const char **argv)
262 {
263         WERROR werr = WERR_OK;
264         int ret = -1;
265         TALLOC_CTX *mem_ctx;
266         uint32_t num_shares;
267         uint32_t share_count, param_count;
268         struct smbconf_service **shares = NULL;
269
270         mem_ctx = talloc_stackframe();
271
272         if (argc != 0 || c->display_usage) {
273                 net_conf_list_usage(c, argc, argv);
274                 goto done;
275         }
276
277         werr = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &shares);
278         if (!W_ERROR_IS_OK(werr)) {
279                 d_fprintf(stderr, _("Error getting config: %s\n"),
280                           win_errstr(werr));
281                 goto done;
282         }
283
284         for (share_count = 0; share_count < num_shares; share_count++) {
285                 const char *indent = "";
286                 if (shares[share_count]->name != NULL) {
287                         d_printf("[%s]\n", shares[share_count]->name);
288                         indent = "\t";
289                 }
290                 for (param_count = 0;
291                      param_count < shares[share_count]->num_params;
292                      param_count++)
293                 {
294                         d_printf("%s%s = %s\n",
295                                  indent,
296                                  shares[share_count]->param_names[param_count],
297                                  shares[share_count]->param_values[param_count]);
298                 }
299                 d_printf("\n");
300         }
301
302         ret = 0;
303
304 done:
305         TALLOC_FREE(mem_ctx);
306         return ret;
307 }
308
309 static int net_conf_import(struct net_context *c, struct smbconf_ctx *conf_ctx,
310                            int argc, const char **argv)
311 {
312         int ret = -1;
313         const char *filename = NULL;
314         const char *servicename = NULL;
315         char *conf_source = NULL;
316         TALLOC_CTX *mem_ctx;
317         struct smbconf_ctx *txt_ctx;
318         WERROR werr;
319         sbcErr err;
320
321         if (c->display_usage)
322                 return net_conf_import_usage(c, argc, argv);
323
324         mem_ctx = talloc_stackframe();
325
326         switch (argc) {
327                 case 0:
328                 default:
329                         net_conf_import_usage(c, argc, argv);
330                         goto done;
331                 case 2:
332                         servicename = talloc_strdup(mem_ctx, argv[1]);
333                         if (servicename == NULL) {
334                                 d_printf(_("error: out of memory!\n"));
335                                 goto done;
336                         }
337                 case 1:
338                         filename = argv[0];
339                         break;
340         }
341
342         DEBUG(3,("net_conf_import: reading configuration from file %s.\n",
343                 filename));
344
345         conf_source = talloc_asprintf(mem_ctx, "file:%s", filename);
346         if (conf_source == NULL) {
347                 d_printf(_("error: out of memory!\n"));
348                 goto done;
349         }
350
351         err = smbconf_init(mem_ctx, &txt_ctx, conf_source);
352         if (!SBC_ERROR_IS_OK(err)) {
353                 d_printf(_("error loading file '%s': %s\n"), filename,
354                          sbcErrorString(err));
355                 werr = WERR_NO_SUCH_SERVICE;
356                 goto done;
357         }
358
359         if (c->opt_testmode) {
360                 d_printf(_("\nTEST MODE - "
361                          "would import the following configuration:\n\n"));
362         }
363
364         if (servicename != NULL) {
365                 struct smbconf_service *service = NULL;
366
367                 werr = smbconf_get_share(txt_ctx, mem_ctx,
368                                          servicename,
369                                          &service);
370                 if (!W_ERROR_IS_OK(werr)) {
371                         goto cancel;
372                 }
373
374                 werr = smbconf_transaction_start(conf_ctx);
375                 if (!W_ERROR_IS_OK(werr)) {
376                         d_printf(_("error starting transaction: %s\n"),
377                                  win_errstr(werr));
378                         goto done;
379                 }
380
381                 werr = import_process_service(c, conf_ctx, service);
382                 if (!W_ERROR_IS_OK(werr)) {
383                         goto cancel;
384                 }
385         } else {
386                 struct smbconf_service **services = NULL;
387                 uint32_t num_shares, sidx;
388
389                 werr = smbconf_get_config(txt_ctx, mem_ctx,
390                                           &num_shares,
391                                           &services);
392                 if (!W_ERROR_IS_OK(werr)) {
393                         goto cancel;
394                 }
395                 if (!c->opt_testmode) {
396                         if (!SBC_ERROR_IS_OK(smbconf_drop(conf_ctx))) {
397                                 goto cancel;
398                         }
399                 }
400
401                 /*
402                  * Wrap the importing of shares into a transaction,
403                  * but only 100 at a time, in order to save memory.
404                  * The allocated memory accumulates across the actions
405                  * within the transaction, and for me, some 1500
406                  * imported shares, the MAX_TALLOC_SIZE of 256 MB
407                  * was exceeded.
408                  */
409                 werr = smbconf_transaction_start(conf_ctx);
410                 if (!W_ERROR_IS_OK(werr)) {
411                         d_printf(_("error starting transaction: %s\n"),
412                                  win_errstr(werr));
413                         goto done;
414                 }
415
416                 for (sidx = 0; sidx < num_shares; sidx++) {
417                         werr = import_process_service(c, conf_ctx,
418                                                       services[sidx]);
419                         if (!W_ERROR_IS_OK(werr)) {
420                                 goto cancel;
421                         }
422
423                         if (sidx % 100) {
424                                 continue;
425                         }
426
427                         werr = smbconf_transaction_commit(conf_ctx);
428                         if (!W_ERROR_IS_OK(werr)) {
429                                 d_printf(_("error committing transaction: "
430                                            "%s\n"),
431                                          win_errstr(werr));
432                                 goto done;
433                         }
434                         werr = smbconf_transaction_start(conf_ctx);
435                         if (!W_ERROR_IS_OK(werr)) {
436                                 d_printf(_("error starting transaction: %s\n"),
437                                          win_errstr(werr));
438                                 goto done;
439                         }
440                 }
441         }
442
443         werr = smbconf_transaction_commit(conf_ctx);
444         if (!W_ERROR_IS_OK(werr)) {
445                 d_printf(_("error committing transaction: %s\n"),
446                          win_errstr(werr));
447         } else {
448                 ret = 0;
449         }
450
451         goto done;
452
453 cancel:
454         werr = smbconf_transaction_cancel(conf_ctx);
455         if (!W_ERROR_IS_OK(werr)) {
456                 d_printf(_("error cancelling transaction: %s\n"),
457                          win_errstr(werr));
458         }
459
460 done:
461         TALLOC_FREE(mem_ctx);
462         return ret;
463 }
464
465 static int net_conf_listshares(struct net_context *c,
466                                struct smbconf_ctx *conf_ctx, int argc,
467                                const char **argv)
468 {
469         WERROR werr = WERR_OK;
470         int ret = -1;
471         uint32_t count, num_shares = 0;
472         char **share_names = NULL;
473         TALLOC_CTX *mem_ctx;
474
475         mem_ctx = talloc_stackframe();
476
477         if (argc != 0 || c->display_usage) {
478                 net_conf_listshares_usage(c, argc, argv);
479                 goto done;
480         }
481
482         werr = smbconf_get_share_names(conf_ctx, mem_ctx, &num_shares,
483                                        &share_names);
484         if (!W_ERROR_IS_OK(werr)) {
485                 goto done;
486         }
487
488         for (count = 0; count < num_shares; count++)
489         {
490                 d_printf("%s\n", share_names[count]);
491         }
492
493         ret = 0;
494
495 done:
496         TALLOC_FREE(mem_ctx);
497         return ret;
498 }
499
500 static int net_conf_drop(struct net_context *c, struct smbconf_ctx *conf_ctx,
501                          int argc, const char **argv)
502 {
503         int ret = -1;
504         sbcErr err;
505
506         if (argc != 0 || c->display_usage) {
507                 net_conf_drop_usage(c, argc, argv);
508                 goto done;
509         }
510
511         err = smbconf_drop(conf_ctx);
512         if (!SBC_ERROR_IS_OK(err)) {
513                 d_fprintf(stderr, _("Error deleting configuration: %s\n"),
514                           sbcErrorString(err));
515                 goto done;
516         }
517
518         ret = 0;
519
520 done:
521         return ret;
522 }
523
524 static int net_conf_showshare(struct net_context *c,
525                               struct smbconf_ctx *conf_ctx, int argc,
526                               const char **argv)
527 {
528         int ret = -1;
529         WERROR werr = WERR_OK;
530         const char *sharename = NULL;
531         TALLOC_CTX *mem_ctx;
532         uint32_t count;
533         struct smbconf_service *service = NULL;
534
535         mem_ctx = talloc_stackframe();
536
537         if (argc != 1 || c->display_usage) {
538                 net_conf_showshare_usage(c, argc, argv);
539                 goto done;
540         }
541
542         sharename = talloc_strdup(mem_ctx, argv[0]);
543         if (sharename == NULL) {
544                 d_printf("error: out of memory!\n");
545                 goto done;
546         }
547
548         werr = smbconf_get_share(conf_ctx, mem_ctx, sharename, &service);
549         if (!W_ERROR_IS_OK(werr)) {
550                 d_printf(_("error getting share parameters: %s\n"),
551                          win_errstr(werr));
552                 goto done;
553         }
554
555         d_printf("[%s]\n", service->name);
556
557         for (count = 0; count < service->num_params; count++) {
558                 d_printf("\t%s = %s\n", service->param_names[count],
559                          service->param_values[count]);
560         }
561
562         ret = 0;
563
564 done:
565         TALLOC_FREE(mem_ctx);
566         return ret;
567 }
568
569 /**
570  * Add a share, with a couple of standard parameters, partly optional.
571  *
572  * This is a high level utility function of the net conf utility,
573  * not a direct frontend to the smbconf API.
574  */
575 static int net_conf_addshare(struct net_context *c,
576                              struct smbconf_ctx *conf_ctx, int argc,
577                              const char **argv)
578 {
579         int ret = -1;
580         WERROR werr = WERR_OK;
581         char *sharename = NULL;
582         const char *path = NULL;
583         const char *comment = NULL;
584         const char *guest_ok = "no";
585         const char *writeable = "no";
586         SMB_STRUCT_STAT sbuf;
587         TALLOC_CTX *mem_ctx = talloc_stackframe();
588
589         if (c->display_usage) {
590                 net_conf_addshare_usage(c, argc, argv);
591                 ret = 0;
592                 goto done;
593         }
594
595         switch (argc) {
596                 case 0:
597                 case 1:
598                 default:
599                         net_conf_addshare_usage(c, argc, argv);
600                         goto done;
601                 case 5:
602                         comment = argv[4];
603                 case 4:
604                         if (!strnequal(argv[3], "guest_ok=", 9)) {
605                                 net_conf_addshare_usage(c, argc, argv);
606                                 goto done;
607                         }
608                         switch (argv[3][9]) {
609                                 case 'y':
610                                 case 'Y':
611                                         guest_ok = "yes";
612                                         break;
613                                 case 'n':
614                                 case 'N':
615                                         guest_ok = "no";
616                                         break;
617                                 default:
618                                         net_conf_addshare_usage(c, argc, argv);
619                                         goto done;
620                         }
621                 case 3:
622                         if (!strnequal(argv[2], "writeable=", 10)) {
623                                 net_conf_addshare_usage(c, argc, argv);
624                                 goto done;
625                         }
626                         switch (argv[2][10]) {
627                                 case 'y':
628                                 case 'Y':
629                                         writeable = "yes";
630                                         break;
631                                 case 'n':
632                                 case 'N':
633                                         writeable = "no";
634                                         break;
635                                 default:
636                                         net_conf_addshare_usage(c, argc, argv);
637                                         goto done;
638                         }
639                 case 2:
640                         path = argv[1];
641                         sharename = talloc_strdup(mem_ctx, argv[0]);
642                         if (sharename == NULL) {
643                                 d_printf(_("error: out of memory!\n"));
644                                 goto done;
645                         }
646
647                         break;
648         }
649
650         /*
651          * validate arguments
652          */
653
654         /* validate share name */
655
656         if (!validate_net_name(sharename, INVALID_SHARENAME_CHARS,
657                                strlen(sharename)))
658         {
659                 d_fprintf(stderr, _("ERROR: share name %s contains "
660                         "invalid characters (any of %s)\n"),
661                         sharename, INVALID_SHARENAME_CHARS);
662                 goto done;
663         }
664
665         if (strequal(sharename, GLOBAL_NAME)) {
666                 d_fprintf(stderr,
667                           _("ERROR: 'global' is not a valid share name.\n"));
668                 goto done;
669         }
670
671         if (smbconf_share_exists(conf_ctx, sharename)) {
672                 d_fprintf(stderr, _("ERROR: share %s already exists.\n"),
673                           sharename);
674                 goto done;
675         }
676
677         /* validate path */
678
679         if (path[0] != '/') {
680                 d_fprintf(stderr,
681                           _("Error: path '%s' is not an absolute path.\n"),
682                           path);
683                 goto done;
684         }
685
686         if (sys_stat(path, &sbuf, false) != 0) {
687                 d_fprintf(stderr,
688                           _("ERROR: cannot stat path '%s' to ensure "
689                             "this is a directory.\n"
690                             "Error was '%s'.\n"),
691                           path, strerror(errno));
692                 goto done;
693         }
694
695         if (!S_ISDIR(sbuf.st_ex_mode)) {
696                 d_fprintf(stderr,
697                           _("ERROR: path '%s' is not a directory.\n"),
698                           path);
699                 goto done;
700         }
701
702         /*
703          * start a transaction
704          */
705
706         werr = smbconf_transaction_start(conf_ctx);
707         if (!W_ERROR_IS_OK(werr)) {
708                 d_printf("error starting transaction: %s\n",
709                          win_errstr(werr));
710                 goto done;
711         }
712
713         /*
714          * create the share
715          */
716
717         werr = smbconf_create_share(conf_ctx, sharename);
718         if (!W_ERROR_IS_OK(werr)) {
719                 d_fprintf(stderr, _("Error creating share %s: %s\n"),
720                           sharename, win_errstr(werr));
721                 goto cancel;
722         }
723
724         /*
725          * fill the share with parameters
726          */
727
728         werr = smbconf_set_parameter(conf_ctx, sharename, "path", path);
729         if (!W_ERROR_IS_OK(werr)) {
730                 d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
731                           "path", win_errstr(werr));
732                 goto cancel;
733         }
734
735         if (comment != NULL) {
736                 werr = smbconf_set_parameter(conf_ctx, sharename, "comment",
737                                              comment);
738                 if (!W_ERROR_IS_OK(werr)) {
739                         d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
740                                   "comment", win_errstr(werr));
741                         goto cancel;
742                 }
743         }
744
745         werr = smbconf_set_parameter(conf_ctx, sharename, "guest ok", guest_ok);
746         if (!W_ERROR_IS_OK(werr)) {
747                 d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
748                           "'guest ok'", win_errstr(werr));
749                 goto cancel;
750         }
751
752         werr = smbconf_set_parameter(conf_ctx, sharename, "writeable",
753                                      writeable);
754         if (!W_ERROR_IS_OK(werr)) {
755                 d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
756                           "writeable", win_errstr(werr));
757                 goto cancel;
758         }
759
760         /*
761          * commit the whole thing
762          */
763
764         werr = smbconf_transaction_commit(conf_ctx);
765         if (!W_ERROR_IS_OK(werr)) {
766                 d_printf("error committing transaction: %s\n",
767                          win_errstr(werr));
768         } else {
769                 ret = 0;
770         }
771
772         goto done;
773
774 cancel:
775         werr = smbconf_transaction_cancel(conf_ctx);
776         if (!W_ERROR_IS_OK(werr)) {
777                 d_printf("error cancelling transaction: %s\n",
778                          win_errstr(werr));
779         }
780
781 done:
782         TALLOC_FREE(mem_ctx);
783         return ret;
784 }
785
786 static int net_conf_delshare(struct net_context *c,
787                              struct smbconf_ctx *conf_ctx, int argc,
788                              const char **argv)
789 {
790         int ret = -1;
791         const char *sharename = NULL;
792         WERROR werr = WERR_OK;
793         TALLOC_CTX *mem_ctx = talloc_stackframe();
794
795         if (argc != 1 || c->display_usage) {
796                 net_conf_delshare_usage(c, argc, argv);
797                 goto done;
798         }
799         sharename = talloc_strdup(mem_ctx, argv[0]);
800         if (sharename == NULL) {
801                 d_printf(_("error: out of memory!\n"));
802                 goto done;
803         }
804
805         werr = smbconf_delete_share(conf_ctx, sharename);
806         if (!W_ERROR_IS_OK(werr)) {
807                 d_fprintf(stderr, _("Error deleting share %s: %s\n"),
808                           sharename, win_errstr(werr));
809                 goto done;
810         }
811
812         ret = 0;
813 done:
814         TALLOC_FREE(mem_ctx);
815         return ret;
816 }
817
818 static int net_conf_setparm(struct net_context *c, struct smbconf_ctx *conf_ctx,
819                             int argc, const char **argv)
820 {
821         int ret = -1;
822         WERROR werr = WERR_OK;
823         char *service = NULL;
824         char *param = NULL;
825         const char *value_str = NULL;
826         TALLOC_CTX *mem_ctx = talloc_stackframe();
827
828         if (argc != 3 || c->display_usage) {
829                 net_conf_setparm_usage(c, argc, argv);
830                 goto done;
831         }
832         /*
833          * NULL service name means "dangling parameters" to libsmbconf.
834          * We use the empty string from the command line for this purpose.
835          */
836         if (strlen(argv[0]) != 0) {
837                 service = talloc_strdup(mem_ctx, argv[0]);
838                 if (service == NULL) {
839                         d_printf(_("error: out of memory!\n"));
840                         goto done;
841                 }
842         }
843         param = strlower_talloc(mem_ctx, argv[1]);
844         if (param == NULL) {
845                 d_printf(_("error: out of memory!\n"));
846                 goto done;
847         }
848         value_str = argv[2];
849
850         werr = smbconf_transaction_start(conf_ctx);
851         if (!W_ERROR_IS_OK(werr)) {
852                 d_printf(_("error starting transaction: %s\n"),
853                          win_errstr(werr));
854                 goto done;
855         }
856
857         if (!smbconf_share_exists(conf_ctx, service)) {
858                 werr = smbconf_create_share(conf_ctx, service);
859                 if (!W_ERROR_IS_OK(werr)) {
860                         d_fprintf(stderr, _("Error creating share '%s': %s\n"),
861                                   service, win_errstr(werr));
862                         goto cancel;
863                 }
864         }
865
866         werr = smbconf_set_parameter(conf_ctx, service, param, value_str);
867
868         if (!W_ERROR_IS_OK(werr)) {
869                 d_fprintf(stderr, _("Error setting value '%s': %s\n"),
870                           param, win_errstr(werr));
871                 goto cancel;
872         }
873
874         werr = smbconf_transaction_commit(conf_ctx);
875         if (!W_ERROR_IS_OK(werr)) {
876                 d_printf(_("error committing transaction: %s\n"),
877                          win_errstr(werr));
878         } else {
879                 ret = 0;
880         }
881
882         goto done;
883
884 cancel:
885         werr = smbconf_transaction_cancel(conf_ctx);
886         if (!W_ERROR_IS_OK(werr)) {
887                 d_printf(_("error cancelling transaction: %s\n"),
888                          win_errstr(werr));
889         }
890
891 done:
892         TALLOC_FREE(mem_ctx);
893         return ret;
894 }
895
896 static int net_conf_getparm(struct net_context *c, struct smbconf_ctx *conf_ctx,
897                             int argc, const char **argv)
898 {
899         int ret = -1;
900         WERROR werr = WERR_OK;
901         char *service = NULL;
902         char *param = NULL;
903         char *valstr = NULL;
904         TALLOC_CTX *mem_ctx;
905
906         mem_ctx = talloc_stackframe();
907
908         if (argc != 2 || c->display_usage) {
909                 net_conf_getparm_usage(c, argc, argv);
910                 goto done;
911         }
912         /*
913          * NULL service name means "dangling parameters" to libsmbconf.
914          * We use the empty string from the command line for this purpose.
915          */
916         if (strlen(argv[0]) != 0) {
917                 service = talloc_strdup(mem_ctx, argv[0]);
918                 if (service == NULL) {
919                         d_printf(_("error: out of memory!\n"));
920                         goto done;
921                 }
922         }
923         param = strlower_talloc(mem_ctx, argv[1]);
924         if (param == NULL) {
925                 d_printf(_("error: out of memory!\n"));
926                 goto done;
927         }
928
929         werr = smbconf_get_parameter(conf_ctx, mem_ctx, service, param, &valstr);
930
931         if (W_ERROR_EQUAL(werr, WERR_NO_SUCH_SERVICE)) {
932                 d_fprintf(stderr,
933                           _("Error: given service '%s' does not exist.\n"),
934                           service);
935                 goto done;
936         } else if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
937                 d_fprintf(stderr,
938                           _("Error: given parameter '%s' is not set.\n"),
939                           param);
940                 goto done;
941         } else if (!W_ERROR_IS_OK(werr)) {
942                 d_fprintf(stderr, _("Error getting value '%s': %s.\n"),
943                           param, win_errstr(werr));
944                 goto done;
945         }
946
947         d_printf("%s\n", valstr);
948
949         ret = 0;
950 done:
951         TALLOC_FREE(mem_ctx);
952         return ret;
953 }
954
955 static int net_conf_delparm(struct net_context *c, struct smbconf_ctx *conf_ctx,
956                             int argc, const char **argv)
957 {
958         int ret = -1;
959         WERROR werr = WERR_OK;
960         char *service = NULL;
961         char *param = NULL;
962         TALLOC_CTX *mem_ctx = talloc_stackframe();
963
964         if (argc != 2 || c->display_usage) {
965                 net_conf_delparm_usage(c, argc, argv);
966                 goto done;
967         }
968         /*
969          * NULL service name means "dangling parameters" to libsmbconf.
970          * We use the empty string from the command line for this purpose.
971          */
972         if (strlen(argv[0]) != 0) {
973                 service = talloc_strdup(mem_ctx, argv[0]);
974                 if (service == NULL) {
975                         d_printf(_("error: out of memory!\n"));
976                         goto done;
977                 }
978         }
979         param = strlower_talloc(mem_ctx, argv[1]);
980         if (param == NULL) {
981                 d_printf("error: out of memory!\n");
982                 goto done;
983         }
984
985         werr = smbconf_delete_parameter(conf_ctx, service, param);
986
987         if (W_ERROR_EQUAL(werr, WERR_NO_SUCH_SERVICE)) {
988                 d_fprintf(stderr,
989                           _("Error: given service '%s' does not exist.\n"),
990                           service);
991                 goto done;
992         } else if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
993                 d_fprintf(stderr,
994                           _("Error: given parameter '%s' is not set.\n"),
995                           param);
996                 goto done;
997         } else if (!W_ERROR_IS_OK(werr)) {
998                 d_fprintf(stderr, _("Error deleting value '%s': %s.\n"),
999                           param, win_errstr(werr));
1000                 goto done;
1001         }
1002
1003         ret = 0;
1004
1005 done:
1006         TALLOC_FREE(mem_ctx);
1007         return ret;
1008 }
1009
1010 static int net_conf_getincludes(struct net_context *c,
1011                                 struct smbconf_ctx *conf_ctx,
1012                                 int argc, const char **argv)
1013 {
1014         WERROR werr;
1015         uint32_t num_includes;
1016         uint32_t count;
1017         char *service;
1018         char **includes = NULL;
1019         int ret = -1;
1020         TALLOC_CTX *mem_ctx = talloc_stackframe();
1021
1022         if (argc != 1 || c->display_usage) {
1023                 net_conf_getincludes_usage(c, argc, argv);
1024                 goto done;
1025         }
1026
1027         service = talloc_strdup(mem_ctx, argv[0]);
1028         if (service == NULL) {
1029                 d_printf(_("error: out of memory!\n"));
1030                 goto done;
1031         }
1032
1033         werr = smbconf_get_includes(conf_ctx, mem_ctx, service,
1034                                     &num_includes, &includes);
1035         if (!W_ERROR_IS_OK(werr)) {
1036                 d_printf(_("error getting includes: %s\n"), win_errstr(werr));
1037                 goto done;
1038         }
1039
1040         for (count = 0; count < num_includes; count++) {
1041                 d_printf("include = %s\n", includes[count]);
1042         }
1043
1044         ret = 0;
1045
1046 done:
1047         TALLOC_FREE(mem_ctx);
1048         return ret;
1049 }
1050
1051 static int net_conf_setincludes(struct net_context *c,
1052                                 struct smbconf_ctx *conf_ctx,
1053                                 int argc, const char **argv)
1054 {
1055         WERROR werr;
1056         char *service;
1057         uint32_t num_includes;
1058         const char **includes;
1059         int ret = -1;
1060         TALLOC_CTX *mem_ctx = talloc_stackframe();
1061
1062         if (argc < 1 || c->display_usage) {
1063                 net_conf_setincludes_usage(c, argc, argv);
1064                 goto done;
1065         }
1066
1067         service = talloc_strdup(mem_ctx, argv[0]);
1068         if (service == NULL) {
1069                 d_printf(_("error: out of memory!\n"));
1070                 goto done;
1071         }
1072
1073         num_includes = argc - 1;
1074         if (num_includes == 0) {
1075                 includes = NULL;
1076         } else {
1077                 includes = argv + 1;
1078         }
1079
1080         werr = smbconf_set_includes(conf_ctx, service, num_includes, includes);
1081         if (!W_ERROR_IS_OK(werr)) {
1082                 d_printf(_("error setting includes: %s\n"), win_errstr(werr));
1083                 goto done;
1084         }
1085
1086         ret = 0;
1087
1088 done:
1089         TALLOC_FREE(mem_ctx);
1090         return ret;
1091 }
1092
1093 static int net_conf_delincludes(struct net_context *c,
1094                                 struct smbconf_ctx *conf_ctx,
1095                                 int argc, const char **argv)
1096 {
1097         WERROR werr;
1098         char *service;
1099         int ret = -1;
1100         TALLOC_CTX *mem_ctx = talloc_stackframe();
1101
1102         if (argc != 1 || c->display_usage) {
1103                 net_conf_delincludes_usage(c, argc, argv);
1104                 goto done;
1105         }
1106
1107         service = talloc_strdup(mem_ctx, argv[0]);
1108         if (service == NULL) {
1109                 d_printf(_("error: out of memory!\n"));
1110                 goto done;
1111         }
1112
1113         werr = smbconf_delete_includes(conf_ctx, service);
1114         if (!W_ERROR_IS_OK(werr)) {
1115                 d_printf(_("error deleting includes: %s\n"), win_errstr(werr));
1116                 goto done;
1117         }
1118
1119         ret = 0;
1120
1121 done:
1122         TALLOC_FREE(mem_ctx);
1123         return ret;
1124 }
1125
1126
1127 /**********************************************************************
1128  *
1129  * Wrapper and net_conf_run_function mechanism.
1130  *
1131  **********************************************************************/
1132
1133 /**
1134  * Wrapper function to call the main conf functions.
1135  * The wrapper calls handles opening and closing of the
1136  * configuration.
1137  */
1138 static int net_conf_wrap_function(struct net_context *c,
1139                                   int (*fn)(struct net_context *,
1140                                             struct smbconf_ctx *,
1141                                             int, const char **),
1142                                   int argc, const char **argv)
1143 {
1144         sbcErr err;
1145         TALLOC_CTX *mem_ctx = talloc_stackframe();
1146         struct smbconf_ctx *conf_ctx;
1147         int ret = -1;
1148
1149         err = smbconf_init(mem_ctx, &conf_ctx, "registry:");
1150         if (!SBC_ERROR_IS_OK(err)) {
1151                 return -1;
1152         }
1153
1154         ret = fn(c, conf_ctx, argc, argv);
1155
1156         smbconf_shutdown(conf_ctx);
1157
1158         return ret;
1159 }
1160
1161 /*
1162  * We need a functable struct of our own, because the
1163  * functions are called through a wrapper that handles
1164  * the opening and closing of the configuration, and so on.
1165  */
1166 struct conf_functable {
1167         const char *funcname;
1168         int (*fn)(struct net_context *c, struct smbconf_ctx *ctx, int argc,
1169                   const char **argv);
1170         int valid_transports;
1171         const char *description;
1172         const char *usage;
1173 };
1174
1175 /**
1176  * This imitates net_run_function but calls the main functions
1177  * through the wrapper net_conf_wrap_function().
1178  */
1179 static int net_conf_run_function(struct net_context *c, int argc,
1180                                  const char **argv, const char *whoami,
1181                                  struct conf_functable *table)
1182 {
1183         int i;
1184
1185         if (argc != 0) {
1186                 for (i=0; table[i].funcname; i++) {
1187                         if (StrCaseCmp(argv[0], table[i].funcname) == 0)
1188                                 return net_conf_wrap_function(c, table[i].fn,
1189                                                               argc-1,
1190                                                               argv+1);
1191                 }
1192         }
1193
1194         d_printf(_("Usage:\n"));
1195         for (i=0; table[i].funcname; i++) {
1196                 if (c->display_usage == false)
1197                         d_printf("%s %-15s %s\n", whoami, table[i].funcname,
1198                                  table[i].description);
1199                 else
1200                         d_printf("%s\n", table[i].usage);
1201         }
1202
1203         return c->display_usage?0:-1;
1204 }
1205
1206 /*
1207  * Entry-point for all the CONF functions.
1208  */
1209
1210 int net_conf(struct net_context *c, int argc, const char **argv)
1211 {
1212         int ret = -1;
1213         struct conf_functable func_table[] = {
1214                 {
1215                         "list",
1216                         net_conf_list,
1217                         NET_TRANSPORT_LOCAL,
1218                         N_("Dump the complete configuration in smb.conf like "
1219                            "format."),
1220                         N_("net conf list\n"
1221                            "    Dump the complete configuration in smb.conf "
1222                            "like format.")
1223
1224                 },
1225                 {
1226                         "import",
1227                         net_conf_import,
1228                         NET_TRANSPORT_LOCAL,
1229                         N_("Import configuration from file in smb.conf "
1230                            "format."),
1231                         N_("net conf import\n"
1232                            "    Import configuration from file in smb.conf "
1233                            "format.")
1234                 },
1235                 {
1236                         "listshares",
1237                         net_conf_listshares,
1238                         NET_TRANSPORT_LOCAL,
1239                         N_("List the share names."),
1240                         N_("net conf listshares\n"
1241                            "    List the share names.")
1242                 },
1243                 {
1244                         "drop",
1245                         net_conf_drop,
1246                         NET_TRANSPORT_LOCAL,
1247                         N_("Delete the complete configuration."),
1248                         N_("net conf drop\n"
1249                            "    Delete the complete configuration.")
1250                 },
1251                 {
1252                         "showshare",
1253                         net_conf_showshare,
1254                         NET_TRANSPORT_LOCAL,
1255                         N_("Show the definition of a share."),
1256                         N_("net conf showshare\n"
1257                            "    Show the definition of a share.")
1258                 },
1259                 {
1260                         "addshare",
1261                         net_conf_addshare,
1262                         NET_TRANSPORT_LOCAL,
1263                         N_("Create a new share."),
1264                         N_("net conf addshare\n"
1265                            "    Create a new share.")
1266                 },
1267                 {
1268                         "delshare",
1269                         net_conf_delshare,
1270                         NET_TRANSPORT_LOCAL,
1271                         N_("Delete a share."),
1272                         N_("net conf delshare\n"
1273                            "    Delete a share.")
1274                 },
1275                 {
1276                         "setparm",
1277                         net_conf_setparm,
1278                         NET_TRANSPORT_LOCAL,
1279                         N_("Store a parameter."),
1280                         N_("net conf setparm\n"
1281                            "    Store a parameter.")
1282                 },
1283                 {
1284                         "getparm",
1285                         net_conf_getparm,
1286                         NET_TRANSPORT_LOCAL,
1287                         N_("Retrieve the value of a parameter."),
1288                         N_("net conf getparm\n"
1289                            "    Retrieve the value of a parameter.")
1290                 },
1291                 {
1292                         "delparm",
1293                         net_conf_delparm,
1294                         NET_TRANSPORT_LOCAL,
1295                         N_("Delete a parameter."),
1296                         N_("net conf delparm\n"
1297                            "    Delete a parameter.")
1298                 },
1299                 {
1300                         "getincludes",
1301                         net_conf_getincludes,
1302                         NET_TRANSPORT_LOCAL,
1303                         N_("Show the includes of a share definition."),
1304                         N_("net conf getincludes\n"
1305                            "    Show the includes of a share definition.")
1306                 },
1307                 {
1308                         "setincludes",
1309                         net_conf_setincludes,
1310                         NET_TRANSPORT_LOCAL,
1311                         N_("Set includes for a share."),
1312                         N_("net conf setincludes\n"
1313                            "    Set includes for a share.")
1314                 },
1315                 {
1316                         "delincludes",
1317                         net_conf_delincludes,
1318                         NET_TRANSPORT_LOCAL,
1319                         N_("Delete includes from a share definition."),
1320                         N_("net conf setincludes\n"
1321                            "    Delete includes from a share definition.")
1322                 },
1323                 {NULL, NULL, 0, NULL, NULL}
1324         };
1325
1326         ret = net_conf_run_function(c, argc, argv, "net conf", func_table);
1327
1328         return ret;
1329 }
1330