This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "vfstest.h"
-#define HAVE_SMB_REGISTER_AUTH
-#define HAVE_SMB_REGISTER_PASSDB
-#define HAVE_RPC_PIPE_REGISTER_COMMANDS
-#define HAVE_SMB_REGISTER_VFS
-#include "module_dummy.h"
-
/* List to hold groups of commands */
static struct cmd_list {
struct cmd_list *prev, *next;
struct cmd_set *cmd_set;
} *cmd_list;
-extern pstring user_socket_options;
+int get_client_fd(void)
+{
+ return -1;
+}
/****************************************************************************
handle completion of commands for readline
****************************************************************************/
-static char **completion_fn(char *text, int start, int end)
+static char **completion_fn(const char *text, int start, int end)
{
#define MAX_COMPLETIONS 100
char **matches;
if (!commands)
return NULL;
- matches = (char **)malloc(sizeof(matches[0])*MAX_COMPLETIONS);
+ matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);
if (!matches) return NULL;
- matches[count++] = strdup(text);
+ matches[count++] = SMB_STRDUP(text);
if (!matches[0]) return NULL;
while (commands && count < MAX_COMPLETIONS-1)
if ((strncmp(text, commands->cmd_set[i].name, strlen(text)) == 0) &&
commands->cmd_set[i].fn)
{
- matches[count] = strdup(commands->cmd_set[i].name);
+ matches[count] = SMB_STRDUP(commands->cmd_set[i].name);
if (!matches[count])
return NULL;
count++;
if (count == 2) {
SAFE_FREE(matches[0]);
- matches[0] = strdup(matches[1]);
+ matches[0] = SMB_STRDUP(matches[1]);
}
matches[count] = NULL;
return matches;
}
-static char* next_command(char** cmdstr)
+static char *next_command(TALLOC_CTX *ctx, char **cmdstr)
{
- static pstring command;
- char *p;
-
+ char *command;
+ char *p;
+
if (!cmdstr || !(*cmdstr))
return NULL;
-
+
p = strchr_m(*cmdstr, ';');
if (p)
*p = '\0';
- pstrcpy(command, *cmdstr);
+ command = talloc_strdup(ctx, *cmdstr);
*cmdstr = p;
-
+
return command;
}
/* Load specified configuration file */
static NTSTATUS cmd_conf(struct vfs_state *vfs, TALLOC_CTX *mem_ctx,
- int argc, char **argv)
+ int argc, const char **argv)
{
if (argc != 2) {
printf("Usage: %s <smb.conf>\n", argv[0]);
return NT_STATUS_OK;
}
- if (!lp_load(argv[1], False, True, False)) {
+ if (!lp_load(argv[1], False, True, False, True)) {
printf("Error loading \"%s\"\n", argv[1]);
return NT_STATUS_OK;
}
}
/* Change the debug level */
-static NTSTATUS cmd_debuglevel(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_debuglevel(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
if (argc > 2) {
printf("Usage: %s [debuglevel]\n", argv[0]);
return NT_STATUS_OK;
}
-static NTSTATUS cmd_freemem(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_freemem(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
/* Cleanup */
talloc_destroy(mem_ctx);
return NT_STATUS_OK;
}
-static NTSTATUS cmd_quit(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_quit(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
/* Cleanup */
talloc_destroy(mem_ctx);
{
struct cmd_list *entry;
- if (!(entry = (struct cmd_list *)malloc(sizeof(struct cmd_list)))) {
+ if (!(entry = SMB_MALLOC_P(struct cmd_list))) {
DEBUG(0, ("out of memory\n"));
return;
}
static NTSTATUS do_cmd(struct vfs_state *vfs, struct cmd_set *cmd_entry, char *cmd)
{
- char *p = cmd, **argv = NULL;
+ const char *p = cmd;
+ char **argv = NULL;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
- pstring buf;
- TALLOC_CTX *mem_ctx = NULL;
+ char *buf;
+ TALLOC_CTX *mem_ctx = talloc_stackframe();
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))) {
+ while(next_token_talloc(mem_ctx, &p, &buf, " ")) {
if (argv) {
- argv[argc] = strdup(buf);
+ argv[argc] = SMB_STRDUP(buf);
}
-
argc++;
}
-
- if (!argv) {
+ if (!argv) {
/* Create argument list */
- argv = (char **)malloc(sizeof(char *) * argc);
+ argv = SMB_MALLOC_ARRAY(char *, argc);
memset(argv, 0, sizeof(char *) * argc);
if (!argv) {
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, argv);
-
+ 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);
}
-
+
+ TALLOC_FREE(mem_ctx);
return result;
}
static NTSTATUS process_cmd(struct vfs_state *vfs, char *cmd)
{
struct cmd_list *temp_list;
- BOOL found = False;
- pstring buf;
- char *p = cmd;
+ bool found = False;
+ char *buf;
+ const char *p = cmd;
NTSTATUS result = NT_STATUS_OK;
+ TALLOC_CTX *mem_ctx = talloc_stackframe();
int len = 0;
if (cmd[strlen(cmd) - 1] == '\n')
cmd[strlen(cmd) - 1] = '\0';
- if (!next_token(&p, buf, " ", sizeof(buf))) {
+ if (!next_token_talloc(mem_ctx, &p, &buf, " ")) {
+ TALLOC_FREE(mem_ctx);
return NT_STATUS_OK;
}
- /* strip the trainly \n if it exsists */
+ /* Strip the trailing \n if it exists */
len = strlen(buf);
if (buf[len-1] == '\n')
buf[len-1] = '\0';
done:
if (!found && buf[0]) {
printf("command not found: %s\n", buf);
+ TALLOC_FREE(mem_ctx);
return NT_STATUS_OK;
}
printf("result was %s\n", nt_errstr(result));
}
+ TALLOC_FREE(mem_ctx);
return result;
}
exit(0);
}
+void exit_server_cleanly(const char *const reason)
+{
+ exit_server("normal exit");
+}
+
static int server_fd = -1;
int last_message = -1;
return server_fd;
}
+void reload_printers(void)
+{
+ return;
+}
+
/****************************************************************************
Reload the services file.
**************************************************************************/
-BOOL reload_services(BOOL test)
+bool reload_services(bool test)
{
- BOOL ret;
-
+ bool ret;
+
if (lp_loaded()) {
- pstring fname;
- pstrcpy(fname,lp_configfile());
+ const char *fname = lp_configfile();
if (file_exist(fname, NULL) &&
- !strcsequal(fname, dyn_CONFIGFILE)) {
- pstrcpy(dyn_CONFIGFILE, fname);
+ !strcsequal(fname, get_dyn_CONFIGFILE())) {
+ set_dyn_CONFIGFILE(fname);
test = False;
}
}
return(True);
lp_killunused(conn_snum_used);
-
- ret = lp_load(dyn_CONFIGFILE, False, False, True);
- load_printers();
+ ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
/* perhaps the config filename is now set */
if (!test)
{
if (smbd_server_fd() != -1) {
set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
- set_socket_options(smbd_server_fd(), user_socket_options);
+ set_socket_options(smbd_server_fd(),
+ lp_socket_options());
}
}
reset_stat_cache();
/* this forces service parameters to be flushed */
- set_current_service(NULL,True);
+ set_current_service(NULL,0,True);
return (ret);
}
+struct event_context *smbd_event_context(void)
+{
+ 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)
+{
+ 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;
+}
+
+struct memcache *smbd_memcache(void)
+{
+ static struct memcache *cache;
+
+ if (!cache
+ && !(cache = memcache_init(NULL,
+ lp_max_stat_cache_size()*1024))) {
+
+ smb_panic("Could not init smbd memcache");
+ }
+ return cache;
+}
+
/* Main function */
int main(int argc, char *argv[])
struct cmd_set **cmd_set;
static struct vfs_state vfs;
int i;
- static const char *filename = NULL;
+ static char *filename = NULL;
+ TALLOC_CTX *frame = talloc_stackframe();
/* make sure the vars that get altered (4th field) are in
a fixed location or certain compilers complain */
POPT_TABLEEND
};
+ load_case_tables();
setlinebuf(stdout);
}
/* some basic initialization stuff */
+ sec_init();
conn_init();
vfs.conn = conn_new();
- vfs.conn->user = "vfstest";
+ string_set(&vfs.conn->user,"vfstest");
for (i=0; i < 1024; i++)
vfs.files[i] = NULL;
if (cmdstr && cmdstr[0]) {
char *cmd;
char *p = cmdstr;
-
- while((cmd=next_command(&p)) != NULL) {
+
+ while((cmd=next_command(frame, &p)) != NULL) {
process_cmd(&vfs, cmd);
}
-
+
+ TALLOC_FREE(cmd);
return 0;
}
/* Loop around accepting commands */
while(1) {
- pstring prompt;
- char *line;
+ char *line = NULL;
- slprintf(prompt, sizeof(prompt) - 1, "vfstest $> ");
+ line = smb_readline("vfstest $> ", NULL, completion_fn);
- line = smb_readline(prompt, NULL, completion_fn);
-
- if (line == NULL)
+ if (line == NULL) {
break;
+ }
- if (line[0] != '\n')
+ if (line[0] != '\n') {
process_cmd(&vfs, line);
+ }
+ SAFE_FREE(line);
}
-
- free(vfs.conn);
+
+ conn_free(vfs.conn);
+ TALLOC_FREE(frame);
return 0;
}
git.samba.org / ira / wip.git / blobdiff