source: vendor/3.5.0/source3/torture/vfstest.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 12.4 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 VFS module tester
4
5 Copyright (C) Simo Sorce 2002
6 Copyright (C) Eric Lorimer 2002
7 Copyright (C) Jelmer Vernooij 2002,2003
8
9 Most of this code was ripped off of rpcclient.
10 Copyright (C) Tim Potter 2000-2001
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
24*/
25
26#include "includes.h"
27#include "vfstest.h"
28
29/* List to hold groups of commands */
30static struct cmd_list {
31 struct cmd_list *prev, *next;
32 struct cmd_set *cmd_set;
33} *cmd_list;
34
35int get_client_fd(void)
36{
37 return -1;
38}
39
40/****************************************************************************
41handle completion of commands for readline
42****************************************************************************/
43static char **completion_fn(const char *text, int start, int end)
44{
45#define MAX_COMPLETIONS 100
46 char **matches;
47 int i, count=0;
48 struct cmd_list *commands = cmd_list;
49
50 if (start)
51 return NULL;
52
53 /* make sure we have a list of valid commands */
54 if (!commands)
55 return NULL;
56
57 matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);
58 if (!matches) return NULL;
59
60 matches[count++] = SMB_STRDUP(text);
61 if (!matches[0]) return NULL;
62
63 while (commands && count < MAX_COMPLETIONS-1)
64 {
65 if (!commands->cmd_set)
66 break;
67
68 for (i=0; commands->cmd_set[i].name; i++)
69 {
70 if ((strncmp(text, commands->cmd_set[i].name, strlen(text)) == 0) &&
71 commands->cmd_set[i].fn)
72 {
73 matches[count] = SMB_STRDUP(commands->cmd_set[i].name);
74 if (!matches[count])
75 return NULL;
76 count++;
77 }
78 }
79
80 commands = commands->next;
81
82 }
83
84 if (count == 2) {
85 SAFE_FREE(matches[0]);
86 matches[0] = SMB_STRDUP(matches[1]);
87 }
88 matches[count] = NULL;
89 return matches;
90}
91
92static char *next_command(TALLOC_CTX *ctx, char **cmdstr)
93{
94 char *command;
95 char *p;
96
97 if (!cmdstr || !(*cmdstr))
98 return NULL;
99
100 p = strchr_m(*cmdstr, ';');
101 if (p)
102 *p = '\0';
103 command = talloc_strdup(ctx, *cmdstr);
104 *cmdstr = p;
105
106 return command;
107}
108
109/* Load specified configuration file */
110static NTSTATUS cmd_conf(struct vfs_state *vfs, TALLOC_CTX *mem_ctx,
111 int argc, const char **argv)
112{
113 if (argc != 2) {
114 printf("Usage: %s <smb.conf>\n", argv[0]);
115 return NT_STATUS_OK;
116 }
117
118 if (!lp_load(argv[1], False, True, False, True)) {
119 printf("Error loading \"%s\"\n", argv[1]);
120 return NT_STATUS_OK;
121 }
122
123 printf("\"%s\" successfully loaded\n", argv[1]);
124 return NT_STATUS_OK;
125}
126
127/* Display help on commands */
128static NTSTATUS cmd_help(struct vfs_state *vfs, TALLOC_CTX *mem_ctx,
129 int argc, const char **argv)
130{
131 struct cmd_list *tmp;
132 struct cmd_set *tmp_set;
133
134 /* Usage */
135 if (argc > 2) {
136 printf("Usage: %s [command]\n", argv[0]);
137 return NT_STATUS_OK;
138 }
139
140 /* Help on one command */
141
142 if (argc == 2) {
143 for (tmp = cmd_list; tmp; tmp = tmp->next) {
144
145 tmp_set = tmp->cmd_set;
146
147 while(tmp_set->name) {
148 if (strequal(argv[1], tmp_set->name)) {
149 if (tmp_set->usage &&
150 tmp_set->usage[0])
151 printf("%s\n", tmp_set->usage);
152 else
153 printf("No help for %s\n", tmp_set->name);
154
155 return NT_STATUS_OK;
156 }
157
158 tmp_set++;
159 }
160 }
161
162 printf("No such command: %s\n", argv[1]);
163 return NT_STATUS_OK;
164 }
165
166 /* List all commands */
167
168 for (tmp = cmd_list; tmp; tmp = tmp->next) {
169
170 tmp_set = tmp->cmd_set;
171
172 while(tmp_set->name) {
173
174 printf("%15s\t\t%s\n", tmp_set->name,
175 tmp_set->description ? tmp_set->description:
176 "");
177
178 tmp_set++;
179 }
180 }
181
182 return NT_STATUS_OK;
183}
184
185/* Change the debug level */
186static NTSTATUS cmd_debuglevel(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
187{
188 if (argc > 2) {
189 printf("Usage: %s [debuglevel]\n", argv[0]);
190 return NT_STATUS_OK;
191 }
192
193 if (argc == 2) {
194 DEBUGLEVEL = atoi(argv[1]);
195 }
196
197 printf("debuglevel is %d\n", DEBUGLEVEL);
198
199 return NT_STATUS_OK;
200}
201
202static NTSTATUS cmd_freemem(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
203{
204 /* Cleanup */
205 talloc_destroy(mem_ctx);
206 mem_ctx = NULL;
207 vfs->data = NULL;
208 vfs->data_size = 0;
209 return NT_STATUS_OK;
210}
211
212static NTSTATUS cmd_quit(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
213{
214 /* Cleanup */
215 talloc_destroy(mem_ctx);
216
217 exit(0);
218 return NT_STATUS_OK; /* NOTREACHED */
219}
220
221static struct cmd_set vfstest_commands[] = {
222
223 { "GENERAL OPTIONS" },
224
225 { "conf", cmd_conf, "Load smb configuration file", "conf <smb.conf>" },
226 { "help", cmd_help, "Get help on commands", "" },
227 { "?", cmd_help, "Get help on commands", "" },
228 { "debuglevel", cmd_debuglevel, "Set debug level", "" },
229 { "freemem", cmd_freemem, "Free currently allocated buffers", "" },
230 { "exit", cmd_quit, "Exit program", "" },
231 { "quit", cmd_quit, "Exit program", "" },
232
233 { NULL }
234};
235
236static struct cmd_set separator_command[] = {
237 { "---------------", NULL, "----------------------" },
238 { NULL }
239};
240
241
242extern struct cmd_set vfs_commands[];
243static struct cmd_set *vfstest_command_list[] = {
244 vfstest_commands,
245 vfs_commands,
246 NULL
247};
248
249static void add_command_set(struct cmd_set *cmd_set)
250{
251 struct cmd_list *entry;
252
253 if (!(entry = SMB_MALLOC_P(struct cmd_list))) {
254 DEBUG(0, ("out of memory\n"));
255 return;
256 }
257
258 ZERO_STRUCTP(entry);
259
260 entry->cmd_set = cmd_set;
261 DLIST_ADD(cmd_list, entry);
262}
263
264static NTSTATUS do_cmd(struct vfs_state *vfs, struct cmd_set *cmd_entry, char *cmd)
265{
266 const char *p = cmd;
267 char **argv = NULL;
268 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
269 char *buf;
270 TALLOC_CTX *mem_ctx = talloc_stackframe();
271 int argc = 0, i;
272
273 /* Count number of arguments first time through the loop then
274 allocate memory and strdup them. */
275
276 again:
277 while(next_token_talloc(mem_ctx, &p, &buf, " ")) {
278 if (argv) {
279 argv[argc] = SMB_STRDUP(buf);
280 }
281 argc++;
282 }
283
284 if (!argv) {
285 /* Create argument list */
286
287 argv = SMB_MALLOC_ARRAY(char *, argc);
288 memset(argv, 0, sizeof(char *) * argc);
289
290 if (!argv) {
291 fprintf(stderr, "out of memory\n");
292 result = NT_STATUS_NO_MEMORY;
293 goto done;
294 }
295
296 p = cmd;
297 argc = 0;
298
299 goto again;
300 }
301
302 /* Call the function */
303
304 if (cmd_entry->fn) {
305 /* Run command */
306 result = cmd_entry->fn(vfs, mem_ctx, argc, (const char **)argv);
307 } else {
308 fprintf (stderr, "Invalid command\n");
309 goto done;
310 }
311
312 done:
313
314 /* Cleanup */
315
316 if (argv) {
317 for (i = 0; i < argc; i++)
318 SAFE_FREE(argv[i]);
319
320 SAFE_FREE(argv);
321 }
322
323 TALLOC_FREE(mem_ctx);
324 return result;
325}
326
327/* Process a command entered at the prompt or as part of -c */
328static NTSTATUS process_cmd(struct vfs_state *vfs, char *cmd)
329{
330 struct cmd_list *temp_list;
331 bool found = False;
332 char *buf;
333 const char *p = cmd;
334 NTSTATUS result = NT_STATUS_OK;
335 TALLOC_CTX *mem_ctx = talloc_stackframe();
336 int len = 0;
337
338 if (cmd[strlen(cmd) - 1] == '\n')
339 cmd[strlen(cmd) - 1] = '\0';
340
341 if (!next_token_talloc(mem_ctx, &p, &buf, " ")) {
342 TALLOC_FREE(mem_ctx);
343 return NT_STATUS_OK;
344 }
345
346 /* Strip the trailing \n if it exists */
347 len = strlen(buf);
348 if (buf[len-1] == '\n')
349 buf[len-1] = '\0';
350
351 /* Search for matching commands */
352
353 for (temp_list = cmd_list; temp_list; temp_list = temp_list->next) {
354 struct cmd_set *temp_set = temp_list->cmd_set;
355
356 while(temp_set->name) {
357 if (strequal(buf, temp_set->name)) {
358 found = True;
359 result = do_cmd(vfs, temp_set, cmd);
360
361 goto done;
362 }
363 temp_set++;
364 }
365 }
366
367 done:
368 if (!found && buf[0]) {
369 printf("command not found: %s\n", buf);
370 TALLOC_FREE(mem_ctx);
371 return NT_STATUS_OK;
372 }
373
374 if (!NT_STATUS_IS_OK(result)) {
375 printf("result was %s\n", nt_errstr(result));
376 }
377
378 TALLOC_FREE(mem_ctx);
379 return result;
380}
381
382static void process_file(struct vfs_state *pvfs, char *filename) {
383 FILE *file;
384 char command[3 * PATH_MAX];
385
386 if (*filename == '-') {
387 file = stdin;
388 } else {
389 file = fopen(filename, "r");
390 if (file == NULL) {
391 printf("vfstest: error reading file (%s)!", filename);
392 printf("errno n.%d: %s", errno, strerror(errno));
393 exit(-1);
394 }
395 }
396
397 while (fgets(command, 3 * PATH_MAX, file) != NULL) {
398 process_cmd(pvfs, command);
399 }
400
401 if (file != stdin) {
402 fclose(file);
403 }
404}
405
406void exit_server(const char *reason)
407{
408 DEBUG(3,("Server exit (%s)\n", (reason ? reason : "")));
409 exit(0);
410}
411
412void exit_server_cleanly(const char *const reason)
413{
414 exit_server("normal exit");
415}
416
417static int server_fd = -1;
418int last_message = -1;
419
420int smbd_server_fd(void)
421{
422 return server_fd;
423}
424
425void reload_printers(void)
426{
427 return;
428}
429
430/****************************************************************************
431 Reload the services file.
432**************************************************************************/
433
434bool reload_services(bool test)
435{
436 bool ret;
437
438 if (lp_loaded()) {
439 const char *fname = lp_configfile();
440 if (file_exist(fname) &&
441 !strcsequal(fname, get_dyn_CONFIGFILE())) {
442 set_dyn_CONFIGFILE(fname);
443 test = False;
444 }
445 }
446
447 reopen_logs();
448
449 if (test && !lp_file_list_changed())
450 return(True);
451
452 lp_killunused(conn_snum_used);
453
454 ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
455
456 /* perhaps the config filename is now set */
457 if (!test)
458 reload_services(True);
459
460 reopen_logs();
461
462 load_interfaces();
463
464 {
465 if (smbd_server_fd() != -1) {
466 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
467 set_socket_options(smbd_server_fd(),
468 lp_socket_options());
469 }
470 }
471
472 mangle_reset_cache();
473 reset_stat_cache();
474
475 /* this forces service parameters to be flushed */
476 set_current_service(NULL,0,True);
477
478 return (ret);
479}
480
481struct event_context *smbd_event_context(void)
482{
483 static struct event_context *ctx;
484
485 if (!ctx && !(ctx = event_context_init(NULL))) {
486 smb_panic("Could not init smbd event context\n");
487 }
488 return ctx;
489}
490
491struct messaging_context *smbd_messaging_context(void)
492{
493 static struct messaging_context *ctx;
494
495 if (!ctx && !(ctx = messaging_init(NULL, server_id_self(),
496 smbd_event_context()))) {
497 smb_panic("Could not init smbd messaging context\n");
498 }
499 return ctx;
500}
501
502struct memcache *smbd_memcache(void)
503{
504 static struct memcache *cache;
505
506 if (!cache
507 && !(cache = memcache_init(NULL,
508 lp_max_stat_cache_size()*1024))) {
509
510 smb_panic("Could not init smbd memcache");
511 }
512 return cache;
513}
514
515/* Main function */
516
517int main(int argc, char *argv[])
518{
519 static char *cmdstr = NULL;
520 struct cmd_set **cmd_set;
521 static struct vfs_state vfs;
522 int i;
523 static char *filename = NULL;
524 TALLOC_CTX *frame = talloc_stackframe();
525
526 /* make sure the vars that get altered (4th field) are in
527 a fixed location or certain compilers complain */
528 poptContext pc;
529 struct poptOption long_options[] = {
530 POPT_AUTOHELP
531 {"file", 'f', POPT_ARG_STRING, &filename, 0, },
532 {"command", 'c', POPT_ARG_STRING, &cmdstr, 0, "Execute specified list of commands" },
533 POPT_COMMON_SAMBA
534 POPT_TABLEEND
535 };
536
537 load_case_tables();
538
539 setlinebuf(stdout);
540
541 pc = poptGetContext("vfstest", argc, (const char **) argv,
542 long_options, 0);
543
544 while(poptGetNextOpt(pc) != -1);
545
546
547 poptFreeContext(pc);
548
549 /* TODO: check output */
550 reload_services(False);
551
552 /* the following functions are part of the Samba debugging
553 facilities. See lib/debug.c */
554 setup_logging("vfstest", True);
555
556 /* Load command lists */
557
558 cmd_set = vfstest_command_list;
559
560 while(*cmd_set) {
561 add_command_set(*cmd_set);
562 add_command_set(separator_command);
563 cmd_set++;
564 }
565
566 /* some basic initialization stuff */
567 sec_init();
568 vfs.conn = TALLOC_ZERO_P(NULL, connection_struct);
569 vfs.conn->params = TALLOC_P(vfs.conn, struct share_params);
570 for (i=0; i < 1024; i++)
571 vfs.files[i] = NULL;
572
573 /* some advanced initiliazation stuff */
574 smbd_vfs_init(vfs.conn);
575
576 /* Do we have a file input? */
577 if (filename && filename[0]) {
578 process_file(&vfs, filename);
579 return 0;
580 }
581
582 /* Do anything specified with -c */
583 if (cmdstr && cmdstr[0]) {
584 char *cmd;
585 char *p = cmdstr;
586
587 while((cmd=next_command(frame, &p)) != NULL) {
588 process_cmd(&vfs, cmd);
589 }
590
591 TALLOC_FREE(cmd);
592 return 0;
593 }
594
595 /* Loop around accepting commands */
596
597 while(1) {
598 char *line = NULL;
599
600 line = smb_readline("vfstest $> ", NULL, completion_fn);
601
602 if (line == NULL) {
603 break;
604 }
605
606 if (line[0] != '\n') {
607 process_cmd(&vfs, line);
608 }
609 SAFE_FREE(line);
610 }
611
612 TALLOC_FREE(vfs.conn);
613 TALLOC_FREE(frame);
614 return 0;
615}
Note: See TracBrowser for help on using the repository browser.