da644668696f6908b96e0c9285adabf4f8bfc67e
[bbaumbach/samba-autobuild/.git] / 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 }