torture/vfstest.c

ソースコードを見る。

データ構造
struct	cmd_list
関数
static char **	completion_fn (const char *text, int start, int end)
static char *	next_command (char **cmdstr)
static NTSTATUS	cmd_conf (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS	cmd_help (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS	cmd_debuglevel (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS	cmd_freemem (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS	cmd_quit (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static void	add_command_set (struct cmd_set *cmd_set)
static NTSTATUS	do_cmd (struct vfs_state *vfs, struct cmd_set *cmd_entry, char *cmd)
static NTSTATUS	process_cmd (struct vfs_state *vfs, char *cmd)
static void	process_file (struct vfs_state *pvfs, char *filename)
void	exit_server (const char *reason)
void	exit_server_cleanly (const char *const reason)
int	smbd_server_fd (void)
void	reload_printers (void)
BOOL	reload_services (BOOL test)
event_context *	smbd_event_context (void)
messaging_context *	smbd_messaging_context (void)
int	main (int argc, char *argv[])
変数
pstring	user_socket_options
static struct cmd_set	vfstest_commands []
static struct cmd_set	separator_command []
cmd_set	vfs_commands []
static struct cmd_set *	vfstest_command_list []
static int	server_fd = -1
int	last_message = -1

---

関数

static char** completion_fn	(	const char *	text,
		int	start,
		int	end
	)			[static]

vfstest.c の 41 行で定義されています。

参照先 commands.

{
#define MAX_COMPLETIONS 100
        char **matches;
        int i, count=0;
        struct cmd_list *commands = cmd_list;

        if (start) 
                return NULL;

        /* make sure we have a list of valid commands */
        if (!commands) 
                return NULL;

        matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);
        if (!matches) return NULL;

        matches[count++] = SMB_STRDUP(text);
        if (!matches[0]) return NULL;

        while (commands && count < MAX_COMPLETIONS-1) 
        {
                if (!commands->cmd_set)
                        break;
                
                for (i=0; commands->cmd_set[i].name; i++)
                {
                        if ((strncmp(text, commands->cmd_set[i].name, strlen(text)) == 0) &&
                                commands->cmd_set[i].fn) 
                        {
                                matches[count] = SMB_STRDUP(commands->cmd_set[i].name);
                                if (!matches[count]) 
                                        return NULL;
                                count++;
                        }
                }
                
                commands = commands->next;
                
        }

        if (count == 2) {
                SAFE_FREE(matches[0]);
                matches[0] = SMB_STRDUP(matches[1]);
        }
        matches[count] = NULL;
        return matches;
}

static char* next_command

(

char **

cmdstr

)

[static]

vfstest.c の 90 行で定義されています。

参照先 strchr_m().

{
        static pstring          command;
        char                    *p;
        
        if (!cmdstr || !(*cmdstr))
                return NULL;
        
        p = strchr_m(*cmdstr, ';');
        if (p)
                *p = '\0';
        pstrcpy(command, *cmdstr);
        *cmdstr = p;
        
        return command;
}

static NTSTATUS cmd_conf	(	struct vfs_state *	vfs,
		TALLOC_CTX *	mem_ctx,
		int	argc,
		const char **	argv
	)			[static]

vfstest.c の 108 行で定義されています。

参照先 printf().

{
        if (argc != 2) {
                printf("Usage: %s <smb.conf>\n", argv[0]);
                return NT_STATUS_OK;
        }

        if (!lp_load(argv[1], False, True, False, True)) {
                printf("Error loading \"%s\"\n", argv[1]);
                return NT_STATUS_OK;
        }

        printf("\"%s\" successfully loaded\n", argv[1]);
        return NT_STATUS_OK;
}

static NTSTATUS cmd_help	(	struct vfs_state *	vfs,
		TALLOC_CTX *	mem_ctx,
		int	argc,
		const char **	argv
	)			[static]

vfstest.c の 126 行で定義されています。

参照先 cmd_list::cmd_set・cmd_set::name・cmd_list::next・printf()・strequal()・cmd_set::usage.

{
        struct cmd_list *tmp;
        struct cmd_set *tmp_set;

        /* Usage */
        if (argc > 2) {
                printf("Usage: %s [command]\n", argv[0]);
                return NT_STATUS_OK;
        }

        /* Help on one command */

        if (argc == 2) {
                for (tmp = cmd_list; tmp; tmp = tmp->next) {
                        
                        tmp_set = tmp->cmd_set;

                        while(tmp_set->name) {
                                if (strequal(argv[1], tmp_set->name)) {
                                        if (tmp_set->usage &&
                                            tmp_set->usage[0])
                                                printf("%s\n", tmp_set->usage);
                                        else
                                                printf("No help for %s\n", tmp_set->name);

                                        return NT_STATUS_OK;
                                }

                                tmp_set++;
                        }
                }

                printf("No such command: %s\n", argv[1]);
                return NT_STATUS_OK;
        }

        /* List all commands */

        for (tmp = cmd_list; tmp; tmp = tmp->next) {

                tmp_set = tmp->cmd_set;

                while(tmp_set->name) {

                        printf("%15s\t\t%s\n", tmp_set->name,
                               tmp_set->description ? tmp_set->description:
                               "");

                        tmp_set++;
                }
        }

        return NT_STATUS_OK;
}

static NTSTATUS cmd_debuglevel	(	struct vfs_state *	vfs,
		TALLOC_CTX *	mem_ctx,
		int	argc,
		const char **	argv
	)			[static]

vfstest.c の 184 行で定義されています。

参照先 DEBUGLEVEL・printf().

{
        if (argc > 2) {
                printf("Usage: %s [debuglevel]\n", argv[0]);
                return NT_STATUS_OK;
        }

        if (argc == 2) {
                DEBUGLEVEL = atoi(argv[1]);
        }

        printf("debuglevel is %d\n", DEBUGLEVEL);

        return NT_STATUS_OK;
}

static NTSTATUS cmd_freemem	(	struct vfs_state *	vfs,
		TALLOC_CTX *	mem_ctx,
		int	argc,
		const char **	argv
	)			[static]

vfstest.c の 200 行で定義されています。

参照先 vfs_state::data・vfs_state::data_size.

{
        /* Cleanup */
        talloc_destroy(mem_ctx);
        mem_ctx = NULL;
        vfs->data = NULL;
        vfs->data_size = 0;
        return NT_STATUS_OK;
}

static NTSTATUS cmd_quit	(	struct vfs_state *	vfs,
		TALLOC_CTX *	mem_ctx,
		int	argc,
		const char **	argv
	)			[static]

vfstest.c の 210 行で定義されています。

{
        /* Cleanup */
        talloc_destroy(mem_ctx);

        exit(0);
        return NT_STATUS_OK; /* NOTREACHED */
}

static void add_command_set

(

struct cmd_set *

cmd_set

)

[static]

vfstest.c の 247 行で定義されています。

参照先 cmd_list::cmd_set.

{
        struct cmd_list *entry;

        if (!(entry = SMB_MALLOC_P(struct cmd_list))) {
                DEBUG(0, ("out of memory\n"));
                return;
        }

        ZERO_STRUCTP(entry);

        entry->cmd_set = cmd_set;
        DLIST_ADD(cmd_list, entry);
}

static NTSTATUS do_cmd	(	struct vfs_state *	vfs,
		struct cmd_set *	cmd_entry,
		char *	cmd
	)			[static]

vfstest.c の 262 行で定義されています。

参照先 buf・cmd_set::fn・fprintf()・next_token()・result・talloc_init().

{
        const char *p = cmd;
        char **argv = NULL;
        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
        pstring buf;
        TALLOC_CTX *mem_ctx = NULL;
        int argc = 0, i;

        /* Count number of arguments first time through the loop then
           allocate memory and strdup them. */

 again:
        while(next_token(&p, buf, " ", sizeof(buf))) {
                if (argv) {
                        argv[argc] = SMB_STRDUP(buf);
                }
                
                argc++;
        }
                                
        if (!argv) {

                /* Create argument list */

                argv = SMB_MALLOC_ARRAY(char *, argc);
                memset(argv, 0, sizeof(char *) * argc);

                if (!argv) {
                        fprintf(stderr, "out of memory\n");
                        result = NT_STATUS_NO_MEMORY;
                        goto done;
                }
                                        
                p = cmd;
                argc = 0;
                                        
                goto again;
        }

        /* Call the function */

        if (cmd_entry->fn) {

                if (mem_ctx == NULL) {
                        /* Create mem_ctx */
                        if (!(mem_ctx = talloc_init("do_cmd"))) {
                                DEBUG(0, ("talloc_init() failed\n"));
                                goto done;
                        }
                }

                /* Run command */
                result = cmd_entry->fn(vfs, mem_ctx, argc, (const char **)argv);

        } else {
                fprintf (stderr, "Invalid command\n");
                goto done;
        }

 done:
                                                
        /* Cleanup */

        if (argv) {
                for (i = 0; i < argc; i++)
                        SAFE_FREE(argv[i]);
        
                SAFE_FREE(argv);
        }
        
        return result;
}

static NTSTATUS process_cmd	(	struct vfs_state *	vfs,
		char *	cmd
	)			[static]

vfstest.c の 337 行で定義されています。

参照先 buf・cmd_list::cmd_set・do_cmd()・len・cmd_list::next・next_token()・result・strequal().

{
        struct cmd_list *temp_list;
        BOOL found = False;
        pstring buf;
        const char *p = cmd;
        NTSTATUS result = NT_STATUS_OK;
        int len = 0;

        if (cmd[strlen(cmd) - 1] == '\n')
                cmd[strlen(cmd) - 1] = '\0';

        if (!next_token(&p, buf, " ", sizeof(buf))) {
                return NT_STATUS_OK;
        }

        /* strip the trainly \n if it exsists */
        len = strlen(buf);
        if (buf[len-1] == '\n')
                buf[len-1] = '\0';

        /* Search for matching commands */

        for (temp_list = cmd_list; temp_list; temp_list = temp_list->next) {
                struct cmd_set *temp_set = temp_list->cmd_set;

                while(temp_set->name) {
                        if (strequal(buf, temp_set->name)) {
                                found = True;
                                result = do_cmd(vfs, temp_set, cmd);

                                goto done;
                        }
                        temp_set++;
                }
        }

 done:
        if (!found && buf[0]) {
                printf("command not found: %s\n", buf);
                return NT_STATUS_OK;
        }

        if (!NT_STATUS_IS_OK(result)) {
                printf("result was %s\n", nt_errstr(result));
        }

        return result;
}

static void process_file	(	struct vfs_state *	pvfs,
		char *	filename
	)			[static]

vfstest.c の 387 行で定義されています。

参照先 errno・printf()・process_cmd()・strerror().

参照元 main().

                                                                 {
        FILE *file;
        char command[3 * PATH_MAX];

        if (*filename == '-') {
                file = stdin;
        } else {
                file = fopen(filename, "r");
                if (file == NULL) {
                        printf("vfstest: error reading file (%s)!", filename);
                        printf("errno n.%d: %s", errno, strerror(errno));
                        exit(-1);
                }
        }

        while (fgets(command, 3 * PATH_MAX, file) != NULL) {
                process_cmd(pvfs, command);
        }
}

void exit_server

(

const char *

reason

)

vfstest.c の 407 行で定義されています。

{
        DEBUG(3,("Server exit (%s)\n", (reason ? reason : "")));
        exit(0);
}

void exit_server_cleanly

(

const char *const

reason

)

vfstest.c の 413 行で定義されています。

参照先 exit_server().

{
        exit_server("normal exit");
}

int smbd_server_fd

(

void

)

vfstest.c の 421 行で定義されています。

{
                return server_fd;
}

void reload_printers

(

void

)

vfstest.c の 426 行で定義されています。

{
        return;
}

BOOL reload_services

(

BOOL

test

)

vfstest.c の 435 行で定義されています。

参照先 conn_snum_used()・dyn_CONFIGFILE・file_exist()・load_interfaces()・lp_file_list_changed()・lp_killunused()・lp_loaded()・mangle_reset_cache()・reload_services()・reopen_logs()・reset_stat_cache()・set_current_service()・set_socket_options()・smbd_server_fd()・strcsequal()・user_socket_options.

{
        BOOL ret;
        
        if (lp_loaded()) {
                pstring fname;
                pstrcpy(fname,lp_configfile());
                if (file_exist(fname, NULL) &&
                    !strcsequal(fname, dyn_CONFIGFILE)) {
                        pstrcpy(dyn_CONFIGFILE, fname);
                        test = False;
                }
        }

        reopen_logs();

        if (test && !lp_file_list_changed())
                return(True);

        lp_killunused(conn_snum_used);
        
        ret = lp_load(dyn_CONFIGFILE, False, False, True, True);

        /* perhaps the config filename is now set */
        if (!test)
                reload_services(True);

        reopen_logs();

        load_interfaces();

        {
                if (smbd_server_fd() != -1) {      
                        set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
                        set_socket_options(smbd_server_fd(), user_socket_options);
                }
        }

        mangle_reset_cache();
        reset_stat_cache();

        /* this forces service parameters to be flushed */
        set_current_service(NULL,0,True);

        return (ret);
}

struct event_context* smbd_event_context

(

void

)

vfstest.c の 482 行で定義されています。

参照先 ctx・event_context_init()・smb_panic().

{
        static struct event_context *ctx;

        if (!ctx && !(ctx = event_context_init(NULL))) {
                smb_panic("Could not init smbd event context\n");
        }
        return ctx;
}

struct messaging_context* smbd_messaging_context

(

void

)

vfstest.c の 492 行で定義されています。

参照先 ctx・messaging_init()・server_id_self()・smb_panic()・smbd_event_context().

{
        static struct messaging_context *ctx;

        if (!ctx && !(ctx = messaging_init(NULL, server_id_self(),
                                           smbd_event_context()))) {
                smb_panic("Could not init smbd messaging context\n");
        }
        return ctx;
}

int main	(	int	argc,
		char *	argv[]
	)

vfstest.c の 505 行で定義されています。

参照先 add_command_set()・cmdstr・completion_fn()・vfs_state::conn・conn_free()・conn_init()・conn_new()・vfs_state::files・line・load_case_tables()・next_command()・poptFreeContext()・poptGetContext()・poptGetNextOpt()・process_cmd()・process_file()・prompt・reload_services()・sec_init()・separator_command・setup_logging()・smb_readline()・smbd_vfs_init()・string_set()・connection_struct::user・vfstest_command_list.

{
        static char             *cmdstr = NULL;
        struct cmd_set          **cmd_set;
        static struct vfs_state vfs;
        int i;
        static char             *filename = NULL;

        /* make sure the vars that get altered (4th field) are in
           a fixed location or certain compilers complain */
        poptContext pc;
        struct poptOption long_options[] = {
                POPT_AUTOHELP
                {"file",        'f', POPT_ARG_STRING,   &filename, 0, },
                {"command",     'c', POPT_ARG_STRING,   &cmdstr, 0, "Execute specified list of commands" },
                POPT_COMMON_SAMBA
                POPT_TABLEEND
        };

        load_case_tables();

        setlinebuf(stdout);

        pc = poptGetContext("vfstest", argc, (const char **) argv,
                            long_options, 0);
        
        while(poptGetNextOpt(pc) != -1);


        poptFreeContext(pc);

        /* TODO: check output */
        reload_services(False);

        /* the following functions are part of the Samba debugging
           facilities.  See lib/debug.c */
        setup_logging("vfstest", True);
        
        /* Load command lists */

        cmd_set = vfstest_command_list;

        while(*cmd_set) {
                add_command_set(*cmd_set);
                add_command_set(separator_command);
                cmd_set++;
        }

        /* some basic initialization stuff */
        sec_init();
        conn_init();
        vfs.conn = conn_new();
        string_set(&vfs.conn->user,"vfstest");
        for (i=0; i < 1024; i++)
                vfs.files[i] = NULL;

        /* some advanced initiliazation stuff */
        smbd_vfs_init(vfs.conn);

        /* Do we have a file input? */
        if (filename && filename[0]) {
                process_file(&vfs, filename);
                return 0;
        }

        /* Do anything specified with -c */
        if (cmdstr && cmdstr[0]) {
                char    *cmd;
                char    *p = cmdstr;
 
                while((cmd=next_command(&p)) != NULL) {
                        process_cmd(&vfs, cmd);
                }
                
                return 0;
        }

        /* Loop around accepting commands */

        while(1) {
                pstring prompt;
                char *line;

                slprintf(prompt, sizeof(prompt) - 1, "vfstest $> ");

                line = smb_readline(prompt, NULL, completion_fn);

                if (line == NULL)
                        break;

                if (line[0] != '\n')
                        process_cmd(&vfs, line);
        }
        
        conn_free(vfs.conn);
        return 0;
}

---

変数

pstring user_socket_options

util.c の 72 行で定義されています。

struct cmd_set vfstest_commands[] [static]

初期値:

 {

        { "GENERAL OPTIONS" },

        { "conf",       cmd_conf,       "Load smb configuration file", "conf <smb.conf>" },
        { "help",       cmd_help,       "Get help on commands", "" },
        { "?",          cmd_help,       "Get help on commands", "" },
        { "debuglevel", cmd_debuglevel, "Set debug level", "" },
        { "freemem",    cmd_freemem,    "Free currently allocated buffers", "" },
        { "exit",       cmd_quit,       "Exit program", "" },
        { "quit",       cmd_quit,       "Exit program", "" },

        { NULL }
}

vfstest.c の 219 行で定義されています。

struct cmd_set separator_command[] [static]

初期値:

 {
        { "---------------", NULL,      "----------------------" },
        { NULL }
}

vfstest.c の 234 行で定義されています。

struct cmd_set vfs_commands[]

cmd_vfs.c の 1019 行で定義されています。

struct cmd_set* vfstest_command_list[] [static]

初期値:

 {
        vfstest_commands,
        vfs_commands,
        NULL
}

vfstest.c の 241 行で定義されています。

参照元 main().

int server_fd = -1 [static]

vfstest.c の 418 行で定義されています。

int last_message = -1

vfstest.c の 419 行で定義されています。

参照元 switch_message().

---