source4/utils/net/net.c

   1 /*
   2    Samba Unix/Linux SMB client library
   3    Distributed SMB/CIFS Server Management Utility
   4    Copyright (C) 2001 Steve French  (sfrench@us.ibm.com)
   5    Copyright (C) 2001 Jim McDonough (jmcd@us.ibm.com)
   6    Copyright (C) 2001 Andrew Tridgell (tridge@samba.org)
   7    Copyright (C) 2001 Andrew Bartlett (abartlet@samba.org)
   8    Copyright (C) 2004 Stefan Metzmacher (metze@samba.org)
   9
  10    Largely rewritten by metze in August 2004
  11
  12    Originally written by Steve and Jim. Largely rewritten by tridge in
  13    November 2001.
  14
  15    Reworked again by abartlet in December 2001
  16
  17    This program is free software; you can redistribute it and/or modify
  18    it under the terms of the GNU General Public License as published by
  19    the Free Software Foundation; either version 2 of the License, or
  20    (at your option) any later version.
  21
  22    This program is distributed in the hope that it will be useful,
  23    but WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25    GNU General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public License
  28    along with this program; if not, write to the Free Software
  29    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  30 */
  31
  32 /*****************************************************/
  33 /*                                                   */
  34 /*   Distributed SMB/CIFS Server Management Utility  */
  35 /*                                                   */
  36 /*   The intent was to make the syntax similar       */
  37 /*   to the NET utility (first developed in DOS      */
  38 /*   with additional interesting & useful functions  */
  39 /*   added in later SMB server network operating     */
  40 /*   systems).                                       */
  41 /*                                                   */
  42 /*****************************************************/
  43
  44 #include "includes.h"
  45
  46 /*
  47   run a function from a function table. If not found then
  48   call the specified usage function
  49 */
  50 int net_run_function(struct net_context *ctx,
  51                         int argc, const char **argv,
  52                         const struct net_functable *functable,
  53                         int (*usage_fn)(struct net_context *ctx, int argc, const char **argv))
  54 {
  55         int i;
  56
  57         if (argc < 1) {
  58                 d_printf("Usage: \n");
  59                 return usage_fn(ctx, argc, argv);
  60         }
  61
  62         for (i=0; functable[i].name; i++) {
  63                 if (StrCaseCmp(argv[0], functable[i].name) == 0)
  64                         return functable[i].fn(ctx, argc-1, argv+1);
  65         }
  66
  67         d_printf("No command: %s\n", argv[0]);
  68         return usage_fn(ctx, argc, argv);
  69 }
  70
  71 /*
  72   run a usage function from a function table. If not found then fail
  73 */
  74 int net_run_usage(struct net_context *ctx,
  75                         int argc, const char **argv,
  76                         const struct net_functable *functable)
  77 {
  78         int i;
  79
  80         if (argc < 1) {
  81                 d_printf("net_run_usage: TODO (argc < 1)\n");
  82                 return 1;
  83         }
  84
  85         for (i=0; functable[i].name; i++) {
  86                 if (StrCaseCmp(argv[0], functable[i].name) == 0)
  87                         if (functable[i].usage) {
  88                                 return functable[i].usage(ctx, argc-1, argv+1);
  89                         }
  90         }
  91
  92         d_printf("No usage for command: %s\n", argv[0]);
  93
  94         return 1;
  95 }
  96
  97 /*
  98   run a usage function from a function table. If not found then fail
  99 */
 100 int net_run_help(struct net_context *ctx,
 101                         int argc, const char **argv,
 102                         const struct net_functable *functable)
 103 {
 104         int i;
 105
 106         if (argc < 1) {
 107                 d_printf("net_run_help: TODO (argc < 1)\n");
 108                 return 1;
 109         }
 110
 111         for (i=0; functable[i].name; i++) {
 112                 if (StrCaseCmp(argv[0], functable[i].name) == 0)
 113                         if (functable[i].help) {
 114                                 return functable[i].help(ctx, argc-1, argv+1);
 115                         }
 116         }
 117
 118         d_printf("No help for command: %s\n", argv[0]);
 119
 120         return 1;
 121 }
 122
 123 static int net_help(struct net_context *ctx, int argc, const char **argv)
 124 {
 125         d_printf("net_help: TODO\n");
 126         return 0;
 127 }
 128
 129 static int net_help_usage(struct net_context *ctx, int argc, const char **argv)
 130 {
 131         d_printf("net_help_usage: TODO\n");
 132         return 0;
 133 }
 134
 135 /* main function table */
 136 static const struct net_functable const net_functable[] = {
 137         {"password", net_password, net_password_usage, net_password_help},
 138
 139         {"help", net_help, net_help_usage, net_help},
 140         {NULL, NULL}
 141 };
 142
 143 static int net_usage(struct net_context *ctx, int argc, const char **argv)
 144 {
 145         return net_run_usage(ctx, argc, argv, net_functable);
 146 }
 147
 148 /****************************************************************************
 149   main program
 150 ****************************************************************************/
 151 static int binary_net(int argc, const char **argv)
 152 {
 153         int opt,i;
 154         int rc;
 155         int argc_new;
 156         const char **argv_new;
 157         TALLOC_CTX *mem_ctx;
 158         struct net_context *ctx;
 159         poptContext pc;
 160         struct poptOption long_options[] = {
 161                 POPT_AUTOHELP
 162                 POPT_COMMON_SAMBA
 163                 POPT_COMMON_CONNECTION
 164                 POPT_COMMON_CREDENTIALS
 165                 POPT_COMMON_VERSION
 166                 POPT_TABLEEND
 167         };
 168
 169         setup_logging("net", DEBUG_STDOUT);
 170
 171 #ifdef HAVE_SETBUFFER
 172         setbuffer(stdout, NULL, 0);
 173 #endif
 174
 175         pc = poptGetContext("net", argc, (const char **) argv, long_options,
 176                                 POPT_CONTEXT_KEEP_FIRST);
 177
 178         while((opt = poptGetNextOpt(pc)) != -1) {
 179                 switch (opt) {
 180                 default:
 181                         d_printf("Invalid option %s: %s\n",
 182                                  poptBadOption(pc, 0), poptStrerror(opt));
 183                         net_help(ctx, argc, argv);
 184                         exit(1);
 185                 }
 186         }
 187
 188         lp_load(dyn_CONFIGFILE,True,False,False);
 189         load_interfaces();
 190
 191         argv_new = (const char **)poptGetArgs(pc);
 192
 193         argc_new = argc;
 194         for (i=0; i<argc; i++) {
 195                 if (argv_new[i] == NULL) {
 196                         argc_new = i;
 197                         break;
 198                 }
 199         }
 200
 201         if (argc_new < 2) {
 202                 d_printf("Usage: TODO\n");
 203                 return 1;
 204         }
 205
 206         mem_ctx = talloc_init("net_context");
 207         ctx = talloc_p(mem_ctx, struct net_context);
 208         if (!ctx) {
 209                 d_printf("talloc_init(net_context) failed\n");
 210                 exit(1);
 211         }
 212
 213         ZERO_STRUCTP(ctx);
 214         ctx->mem_ctx = mem_ctx;
 215         ctx->user.account_name = talloc_strdup(ctx->mem_ctx, cmdline_get_username());
 216         ctx->user.domain_name = talloc_strdup(ctx->mem_ctx, cmdline_get_userdomain());
 217         ctx->user.password = talloc_strdup(ctx->mem_ctx, cmdline_get_userpassword());
 218
 219         rc = net_run_function(ctx, argc_new-1, argv_new+1, net_functable, net_usage);
 220
 221         if (rc != 0) {
 222                 DEBUG(0,("return code = %d\n", rc));
 223         }
 224
 225         talloc_destroy(mem_ctx);
 226         return rc;
 227 }
 228
 229  int main(int argc, const char **argv)
 230 {
 231         return binary_net(argc, argv);
 232 }