/*
Unix SMB/CIFS implementation.
- program to send control messages to Samba processes
+
+ Send messages to other Samba daemons
+
+ Copyright (C) Tim Potter 2003
Copyright (C) Andrew Tridgell 1994-1998
- Copyright (C) 2001, 2002 by Martin Pool
+ Copyright (C) Martin Pool 2001-2002
Copyright (C) Simo Sorce 2002
+ Copyright (C) James Peach 2006
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
#include "includes.h"
-extern BOOL AllowDebugChange;
+#if HAVE_LIBUNWIND_H
+#include <libunwind.h>
+#endif
-static const struct {
- const char *name;
- int value;
-} msg_types[] = {
- {"debug", MSG_DEBUG},
- {"force-election", MSG_FORCE_ELECTION},
- {"ping", MSG_PING},
- {"profile", MSG_PROFILE},
- {"profilelevel", MSG_REQ_PROFILELEVEL},
- {"debuglevel", MSG_REQ_DEBUGLEVEL},
- {"printnotify", MSG_PRINTER_NOTIFY2 },
- {"close-share", MSG_SMB_FORCE_TDIS},
- {"samsync", MSG_SMB_SAM_SYNC},
- {"samrepl", MSG_SMB_SAM_REPL},
- {"pool-usage", MSG_REQ_POOL_USAGE },
- {"dmalloc-mark", MSG_REQ_DMALLOC_MARK },
- {"dmalloc-log-changed", MSG_REQ_DMALLOC_LOG_CHANGED },
- {"shutdown", MSG_SHUTDOWN },
- {"drvupgrade", MSG_PRINTER_DRVUPGRADE},
- {"tallocdump", MSG_REQ_TALLOC_USAGE},
- {NULL, -1}
-};
+#if HAVE_LIBUNWIND_PTRACE_H
+#include <libunwind-ptrace.h>
+#endif
-time_t timeout_start;
+#if HAVE_SYS_PTRACE_H
+#include <sys/ptrace.h>
+#endif
-#define MAX_WAIT 10
+/* Default timeout value when waiting for replies (in seconds) */
-/* we need these because we link to printing*.o */
+#define DEFAULT_TIMEOUT 10
-void become_root(void) {}
-void unbecome_root(void) {}
+static int timeout = DEFAULT_TIMEOUT;
+static int num_replies; /* Used by message callback fns */
+/* Send a message to a destination pid. Zero means broadcast smbd. */
-static void usage(BOOL doexit)
+static BOOL send_message(struct messaging_context *msg_ctx,
+ struct server_id pid, int msg_type,
+ const void *buf, int len)
{
- int i;
- if (doexit) {
- printf("Usage: smbcontrol -i -s configfile\n");
- printf(" smbcontrol <destination> <message-type> <parameters>\n\n");
+ BOOL ret;
+ int n_sent = 0;
+
+ if (procid_to_pid(&pid) != 0)
+ return NT_STATUS_IS_OK(
+ messaging_send_buf(msg_ctx, pid, msg_type,
+ (uint8 *)buf, len));
+
+ ret = message_send_all(msg_ctx, msg_type, buf, len, &n_sent);
+ DEBUG(10,("smbcontrol/send_message: broadcast message to "
+ "%d processes\n", n_sent));
+
+ return ret;
+}
+
+/* Wait for one or more reply messages */
+
+static void wait_replies(struct messaging_context *msg_ctx,
+ BOOL multiple_replies)
+{
+ time_t start_time = time(NULL);
+
+ /* Wait around a bit. This is pretty disgusting - we have to
+ busy-wait here as there is no nicer way to do it. */
+
+ do {
+ message_dispatch(msg_ctx);
+ event_loop_once(messaging_event_context(msg_ctx));
+ if (num_replies > 0 && !multiple_replies)
+ break;
+ sleep(1);
+ } while (timeout - (time(NULL) - start_time) > 0);
+}
+
+/* Message handler callback that displays the PID and a string on stdout */
+
+static void print_pid_string_cb(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id pid,
+ DATA_BLOB *data)
+{
+ printf("PID %u: %.*s", (unsigned int)procid_to_pid(&pid),
+ (int)data->length, (const char *)data->data);
+ num_replies++;
+}
+
+/* Message handler callback that displays a string on stdout */
+
+static void print_string_cb(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id pid,
+ DATA_BLOB *data)
+{
+ printf("%.*s", (int)data->length, (const char *)data->data);
+ num_replies++;
+}
+
+/* Send no message. Useful for testing. */
+
+static BOOL do_noop(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> noop\n");
+ return False;
+ }
+
+ /* Move along, nothing to see here */
+
+ return True;
+}
+
+/* Send a debug string */
+
+static BOOL do_debug(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 2) {
+ fprintf(stderr, "Usage: smbcontrol <dest> debug "
+ "<debug-string>\n");
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_DEBUG, argv[1],
+ strlen(argv[1]) + 1);
+}
+
+#if defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE)
+
+/* Return the name of a process given it's PID. This will only work on Linux,
+ * but that's probably moot since this whole stack tracing implementatino is
+ * Linux-specific anyway.
+ */
+static const char * procname(pid_t pid, char * buf, size_t bufsz)
+{
+ char path[64];
+ FILE * fp;
+
+ snprintf(path, sizeof(path), "/proc/%llu/cmdline",
+ (unsigned long long)pid);
+ if ((fp = fopen(path, "r")) == NULL) {
+ return NULL;
+ }
+
+ fgets(buf, bufsz, fp);
+
+ fclose(fp);
+ return buf;
+}
+
+static void print_stack_trace(pid_t pid, int * count)
+{
+ void * pinfo = NULL;
+ unw_addr_space_t aspace = NULL;
+ unw_cursor_t cursor;
+ unw_word_t ip, sp;
+
+ char nbuf[256];
+ unw_word_t off;
+
+ int ret;
+
+ if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0) {
+ fprintf(stderr,
+ "Failed to attach to process %llu: %s\n",
+ (unsigned long long)pid, strerror(errno));
+ return;
+ }
+
+ /* Wait until the attach is complete. */
+ waitpid(pid, NULL, 0);
+
+ if (((pinfo = _UPT_create(pid)) == NULL) ||
+ ((aspace = unw_create_addr_space(&_UPT_accessors, 0)) == NULL)) {
+ /* Probably out of memory. */
+ fprintf(stderr,
+ "Unable to initialize stack unwind for process %llu\n",
+ (unsigned long long)pid);
+ goto cleanup;
+ }
+
+ if ((ret = unw_init_remote(&cursor, aspace, pinfo))) {
+ fprintf(stderr,
+ "Unable to unwind stack for process %llu: %s\n",
+ (unsigned long long)pid, unw_strerror(ret));
+ goto cleanup;
+ }
+
+ if (*count > 0) {
+ printf("\n");
+ }
+
+ if (procname(pid, nbuf, sizeof(nbuf))) {
+ printf("Stack trace for process %llu (%s):\n",
+ (unsigned long long)pid, nbuf);
} else {
- printf("<destination> <message-type> <parameters>\n\n");
+ printf("Stack trace for process %llu:\n",
+ (unsigned long long)pid);
}
- printf("\t<destination> is one of \"nmbd\", \"smbd\" or a process ID\n");
- printf("\t<message-type> is one of:\n");
- for (i=0; msg_types[i].name; i++)
- printf("\t\t%s\n", msg_types[i].name);
- printf("\n");
- if (doexit) exit(1);
+
+ while (unw_step(&cursor) > 0) {
+ ip = sp = off = 0;
+ unw_get_reg(&cursor, UNW_REG_IP, &ip);
+ unw_get_reg(&cursor, UNW_REG_SP, &sp);
+
+ ret = unw_get_proc_name(&cursor, nbuf, sizeof(nbuf), &off);
+ if (ret != 0 && ret != -UNW_ENOMEM) {
+ snprintf(nbuf, sizeof(nbuf), "<unknown symbol>");
+ }
+ printf(" %s + %#llx [ip=%#llx] [sp=%#llx]\n",
+ nbuf, (long long)off, (long long)ip,
+ (long long)sp);
+ }
+
+ (*count)++;
+
+cleanup:
+ if (aspace) {
+ unw_destroy_addr_space(aspace);
+ }
+
+ if (pinfo) {
+ _UPT_destroy(pinfo);
+ }
+
+ ptrace(PTRACE_DETACH, pid, NULL, NULL);
}
-static int pong_count;
-static BOOL got_level;
-static BOOL got_pool;
-static BOOL pong_registered = False;
-static BOOL debuglevel_registered = False;
-static BOOL poolusage_registered = False;
-static BOOL profilelevel_registered = False;
+static int stack_trace_connection(struct db_record *rec,
+ const struct connections_key *key,
+ const struct connections_data *crec,
+ void *priv)
+{
+ print_stack_trace(procid_to_pid(&conn->pid), (int *)priv);
+ return 0;
+}
-/**
- * Wait for replies for up to @p *max_secs seconds, or until @p
- * max_replies are received. max_replies may be NULL in which case it
- * is ignored.
- *
- * @note This is a pretty lame timeout; all it means is that after
- * max_secs we won't look for any more messages.
- **/
-static void wait_for_replies(int max_secs, int *max_replies)
+static BOOL do_daemon_stack_trace(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- time_t timeout_end = time(NULL) + max_secs;
+ fprintf(stderr,
+ "Daemon stack tracing is not supported on this platform\n");
+ return False;
- while ((!max_replies || (*max_replies)-- > 0)
- && (time(NULL) < timeout_end)) {
- message_dispatch();
+ pid_t dest;
+ int count = 0;
+
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> stacktrace\n");
+ return False;
+ }
+
+ dest = procid_to_pid(&pid);
+
+ if (dest != 0) {
+ /* It would be nice to be able to make sure that this PID is
+ * the PID of a smbd/winbind/nmbd process, not some random PID
+ * the user liked the look of. It doesn't seem like it's worth
+ * the effort at the moment, however.
+ */
+ print_stack_trace(dest, &count);
+ } else {
+ connections_forall(stack_trace_connection, &count);
}
+
+ return True;
}
+#else /* defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE) */
-/****************************************************************************
-a useful function for testing the message system
-****************************************************************************/
-void pong_function(int msg_type, pid_t src, void *buf, size_t len)
+static BOOL do_daemon_stack_trace(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- pong_count++;
- printf("PONG from PID %u\n",(unsigned int)src);
+ fprintf(stderr,
+ "Daemon stack tracing is not supported on this platform\n");
+ return False;
}
-/****************************************************************************
- Prints out the current talloc list.
-****************************************************************************/
-void tallocdump_function(int msg_type, pid_t src, void *buf, size_t len)
+#endif /* defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE) */
+
+/* Inject a fault (fatal signal) into a running smbd */
+
+static BOOL do_inject_fault(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- char *info = (char *)buf;
+ if (argc != 2) {
+ fprintf(stderr, "Usage: smbcontrol <dest> inject "
+ "<bus|hup|term|internal|segv>\n");
+ return False;
+ }
- printf("Current talloc contexts for process %u\n", (unsigned int)src );
- if (len == 0)
- printf("None returned\n");
- else
- printf(info);
- printf("\n");
- got_pool = True;
+#ifndef DEVELOPER
+ fprintf(stderr, "Fault injection is only available in "
+ "developer builds\n");
+ return False;
+#else /* DEVELOPER */
+ {
+ int sig = 0;
+
+ if (strcmp(argv[1], "bus") == 0) {
+ sig = SIGBUS;
+ } else if (strcmp(argv[1], "hup") == 0) {
+ sig = SIGHUP;
+ } else if (strcmp(argv[1], "term") == 0) {
+ sig = SIGTERM;
+ } else if (strcmp(argv[1], "segv") == 0) {
+ sig = SIGSEGV;
+ } else if (strcmp(argv[1], "internal") == 0) {
+ /* Force an internal error, ie. an unclean exit. */
+ sig = -1;
+ } else {
+ fprintf(stderr, "Unknown signal name '%s'\n", argv[1]);
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_SMB_INJECT_FAULT,
+ &sig, sizeof(int));
+ }
+#endif /* DEVELOPER */
}
-/****************************************************************************
-Prints out the current Debug level returned by MSG_DEBUGLEVEL
-****************************************************************************/
-void debuglevel_function(int msg_type, pid_t src, void *buf, size_t len)
+/* Force a browser election */
+
+static BOOL do_election(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- const char *levels = (char *)buf;
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> force-election\n");
+ return False;
+ }
- printf("Current debug levels of PID %u are:\n",(unsigned int)src);
- printf("%s\n", levels);
-
- got_level = True;
+ return send_message(msg_ctx, pid, MSG_FORCE_ELECTION, NULL, 0);
}
-/****************************************************************************
-Prints out the current Profile level returned by MSG_PROFILELEVEL
-****************************************************************************/
-void profilelevel_function(int msg_type, pid_t src, void *buf, size_t len)
+/* Ping a samba daemon process */
+
+static void pong_cb(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id pid,
+ DATA_BLOB *data)
{
- int level;
- const char *s=NULL;
- memcpy(&level, buf, sizeof(int));
+ char *src_string = procid_str(NULL, &pid);
+ printf("PONG from pid %s\n", src_string);
+ TALLOC_FREE(src_string);
+ num_replies++;
+}
+
+static BOOL do_ping(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> ping\n");
+ return False;
+ }
+
+ /* Send a message and register our interest in a reply */
- if (level) {
- switch (level) {
- case 1:
+ if (!send_message(msg_ctx, pid, MSG_PING, NULL, 0))
+ return False;
+
+ messaging_register(msg_ctx, NULL, MSG_PONG, pong_cb);
+
+ wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+
+ /* No replies were received within the timeout period */
+
+ if (num_replies == 0)
+ printf("No replies received\n");
+
+ messaging_deregister(msg_ctx, MSG_PONG, NULL);
+
+ return num_replies;
+}
+
+/* Set profiling options */
+
+static BOOL do_profile(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ int v;
+
+ if (argc != 2) {
+ fprintf(stderr, "Usage: smbcontrol <dest> profile "
+ "<off|count|on|flush>\n");
+ return False;
+ }
+
+ if (strcmp(argv[1], "off") == 0) {
+ v = 0;
+ } else if (strcmp(argv[1], "count") == 0) {
+ v = 1;
+ } else if (strcmp(argv[1], "on") == 0) {
+ v = 2;
+ } else if (strcmp(argv[1], "flush") == 0) {
+ v = 3;
+ } else {
+ fprintf(stderr, "Unknown profile command '%s'\n", argv[1]);
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_PROFILE, &v, sizeof(int));
+}
+
+/* Return the profiling level */
+
+static void profilelevel_cb(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id pid,
+ DATA_BLOB *data)
+{
+ int level;
+ const char *s;
+
+ num_replies++;
+
+ if (data->length != sizeof(int)) {
+ fprintf(stderr, "invalid message length %ld returned\n",
+ (unsigned long)data->length);
+ return;
+ }
+
+ memcpy(&level, data->data, sizeof(int));
+
+ switch (level) {
+ case 0:
+ s = "not enabled";
+ break;
+ case 1:
s = "off";
break;
- case 3:
+ case 3:
s = "count only";
break;
- case 7:
+ case 7:
s = "count and time";
break;
- default:
- s = "BOGUS";
- break;
- }
- printf("Profiling %s on PID %u\n",s,(unsigned int)src);
- } else {
- printf("Profiling not available on PID %u\n",(unsigned int)src);
+ default:
+ s = "BOGUS";
+ break;
}
- got_level = True;
+
+ printf("Profiling %s on pid %u\n",s,(unsigned int)procid_to_pid(&pid));
}
-/**
- * Handle reply from POOL_USAGE.
- **/
-static void pool_usage_cb(int msg_type, pid_t src_pid, void *buf, size_t len)
+static void profilelevel_rqst(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id pid,
+ DATA_BLOB *data)
{
- printf("Got POOL_USAGE reply from pid%u:\n%.*s",
- (unsigned int) src_pid, (int) len, (const char *) buf);
+ int v = 0;
+
+ /* Send back a dummy reply */
+
+ send_message(msg_ctx, pid, MSG_PROFILELEVEL, &v, sizeof(int));
}
+static BOOL do_profilelevel(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> profilelevel\n");
+ return False;
+ }
+
+ /* Send a message and register our interest in a reply */
+
+ if (!send_message(msg_ctx, pid, MSG_REQ_PROFILELEVEL, NULL, 0))
+ return False;
+
+ messaging_register(msg_ctx, NULL, MSG_PROFILELEVEL, profilelevel_cb);
+ messaging_register(msg_ctx, NULL, MSG_REQ_PROFILELEVEL,
+ profilelevel_rqst);
-/**
- * Send a message to a named destination
- *
- * @return False if an error occurred.
- **/
-static BOOL send_message(char *dest, int msg_type, void *buf, int len, BOOL duplicates)
+ wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+
+ /* No replies were received within the timeout period */
+
+ if (num_replies == 0)
+ printf("No replies received\n");
+
+ messaging_deregister(msg_ctx, MSG_PROFILE, NULL);
+
+ return num_replies;
+}
+
+/* Display debug level settings */
+
+static BOOL do_debuglevel(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- pid_t pid;
- /* "smbd" is the only broadcast operation */
- if (strequal(dest,"smbd")) {
- TDB_CONTEXT *tdb;
- BOOL ret;
- int n_sent = 0;
-
- tdb = tdb_open_log(lock_path("connections.tdb"), 0, TDB_DEFAULT, O_RDWR, 0);
- if (!tdb) {
- fprintf(stderr,"Failed to open connections database in send_message.\n");
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> debuglevel\n");
+ return False;
+ }
+
+ /* Send a message and register our interest in a reply */
+
+ if (!send_message(msg_ctx, pid, MSG_REQ_DEBUGLEVEL, NULL, 0))
+ return False;
+
+ messaging_register(msg_ctx, NULL, MSG_DEBUGLEVEL, print_pid_string_cb);
+
+ wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+
+ /* No replies were received within the timeout period */
+
+ if (num_replies == 0)
+ printf("No replies received\n");
+
+ messaging_deregister(msg_ctx, MSG_DEBUGLEVEL, NULL);
+
+ return num_replies;
+}
+
+/* Send a print notify message */
+
+static BOOL do_printnotify(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ const char *cmd;
+
+ /* Check for subcommand */
+
+ if (argc == 1) {
+ fprintf(stderr, "Must specify subcommand:\n");
+ fprintf(stderr, "\tqueuepause <printername>\n");
+ fprintf(stderr, "\tqueueresume <printername>\n");
+ fprintf(stderr, "\tjobpause <printername> <unix jobid>\n");
+ fprintf(stderr, "\tjobresume <printername> <unix jobid>\n");
+ fprintf(stderr, "\tjobdelete <printername> <unix jobid>\n");
+ fprintf(stderr, "\tprinter <printername> <comment|port|"
+ "driver> <value>\n");
+
+ return False;
+ }
+
+ cmd = argv[1];
+
+ if (strcmp(cmd, "queuepause") == 0) {
+
+ if (argc != 3) {
+ fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
+ " queuepause <printername>\n");
return False;
}
+
+ notify_printer_status_byname(argv[2], PRINTER_STATUS_PAUSED);
+
+ goto send;
+
+ } else if (strcmp(cmd, "queueresume") == 0) {
- ret = message_send_all(tdb,msg_type, buf, len, duplicates,
- &n_sent);
- DEBUG(10,("smbcontrol/send_message: broadcast message to "
- "%d processes\n", n_sent));
- tdb_close(tdb);
-
- return ret;
- } else if (strequal(dest,"nmbd")) {
- pid = pidfile_pid(dest);
- if (pid == 0) {
- fprintf(stderr,"Can't find pid for nmbd\n");
+ if (argc != 3) {
+ fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
+ " queuereume <printername>\n");
return False;
}
- } else if (strequal(dest,"self")) {
- pid = sys_getpid();
- } else {
- pid = atoi(dest);
- if (pid == 0) {
- fprintf(stderr,"Not a valid pid\n");
+
+ notify_printer_status_byname(argv[2], PRINTER_STATUS_OK);
+
+ goto send;
+
+ } else if (strcmp(cmd, "jobpause") == 0) {
+ int jobid;
+
+ if (argc != 4) {
+ fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
+ " jobpause <printername> <unix-jobid>\n");
return False;
- }
- }
+ }
- DEBUG(10,("smbcontrol/send_message: send message to pid%d\n", pid));
- return message_send_pid(pid, msg_type, buf, len, duplicates);
+ jobid = atoi(argv[3]);
+
+ notify_job_status_byname(
+ argv[2], jobid, JOB_STATUS_PAUSED,
+ SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
+
+ goto send;
+
+ } else if (strcmp(cmd, "jobresume") == 0) {
+ int jobid;
+
+ if (argc != 4) {
+ fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
+ " jobpause <printername> <unix-jobid>\n");
+ return False;
+ }
+
+ jobid = atoi(argv[3]);
+
+ notify_job_status_byname(
+ argv[2], jobid, JOB_STATUS_QUEUED,
+ SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
+
+ goto send;
+
+ } else if (strcmp(cmd, "jobdelete") == 0) {
+ int jobid;
+
+ if (argc != 4) {
+ fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
+ " jobpause <printername> <unix-jobid>\n");
+ return False;
+ }
+
+ jobid = atoi(argv[3]);
+
+ notify_job_status_byname(
+ argv[2], jobid, JOB_STATUS_DELETING,
+ SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
+
+ notify_job_status_byname(
+ argv[2], jobid, JOB_STATUS_DELETING|
+ JOB_STATUS_DELETED,
+ SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
+
+ goto send;
+
+ } else if (strcmp(cmd, "printer") == 0) {
+ uint32 attribute;
+
+ if (argc != 5) {
+ fprintf(stderr, "Usage: smbcontrol <dest> printnotify "
+ "printer <printername> <comment|port|driver> "
+ "<value>\n");
+ return False;
+ }
+
+ if (strcmp(argv[3], "comment") == 0) {
+ attribute = PRINTER_NOTIFY_COMMENT;
+ } else if (strcmp(argv[3], "port") == 0) {
+ attribute = PRINTER_NOTIFY_PORT_NAME;
+ } else if (strcmp(argv[3], "driver") == 0) {
+ attribute = PRINTER_NOTIFY_DRIVER_NAME;
+ } else {
+ fprintf(stderr, "Invalid printer command '%s'\n",
+ argv[3]);
+ return False;
+ }
+
+ notify_printer_byname(argv[2], attribute,
+ CONST_DISCARD(char *, argv[4]));
+
+ goto send;
+ }
+
+ fprintf(stderr, "Invalid subcommand '%s'\n", cmd);
+ return False;
+
+send:
+ print_notify_send_messages(msg_ctx, 0);
+ return True;
}
-/****************************************************************************
-evaluate a message type string
-****************************************************************************/
-static int parse_type(char *mtype)
+/* Close a share */
+
+static BOOL do_closeshare(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- int i;
- for (i=0;msg_types[i].name;i++) {
- if (strequal(mtype, msg_types[i].name)) return msg_types[i].value;
+ if (argc != 2) {
+ fprintf(stderr, "Usage: smbcontrol <dest> close-share "
+ "<sharename>\n");
+ return False;
}
- return -1;
+
+ return send_message(msg_ctx, pid, MSG_SMB_FORCE_TDIS, argv[1],
+ strlen(argv[1]) + 1);
}
+/* force a blocking lock retry */
-static void register_all(void)
+static BOOL do_lockretry(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- message_register(MSG_POOL_USAGE, pool_usage_cb);
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> lockretry\n");
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_SMB_UNLOCK, NULL, 0);
}
-/* This guy is here so we can link printing/notify.c to the smbcontrol
- binary without having to pull in tons of other crap. */
+/* force a validation of all brl entries, including re-sends. */
-TDB_CONTEXT *conn_tdb_ctx(void)
+static BOOL do_brl_revalidate(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- static TDB_CONTEXT *tdb;
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> brl-revalidate\n");
+ return False;
+ }
- if (tdb)
- return tdb;
+ return send_message(msg_ctx, pid, MSG_SMB_BRL_VALIDATE, NULL, 0);
+}
- tdb = tdb_open_log(lock_path("connections.tdb"), 0, TDB_DEFAULT, O_RDONLY, 0);
+/* Force a SAM synchronisation */
- if (!tdb)
- DEBUG(3, ("Failed to open connections database in send_spoolss_notify2_msg\n"));
+static BOOL do_samsync(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> samsync\n");
+ return False;
+ }
- return tdb;
+ return send_message(msg_ctx, pid, MSG_SMB_SAM_SYNC, NULL, 0);
}
-/****************************************************************************
-do command
-****************************************************************************/
-static BOOL do_command(char *dest, char *msg_name, int iparams, char **params)
+/* Force a SAM replication */
+
+static BOOL do_samrepl(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- int i, n, v;
- int mtype;
- BOOL retval=False;
- BOOL check_notify_msgs = False;
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> samrepl\n");
+ return False;
+ }
- mtype = parse_type(msg_name);
- if (mtype == -1) {
- fprintf(stderr,"Couldn't resolve message type: %s\n", msg_name);
- return(False);
+ return send_message(msg_ctx, pid, MSG_SMB_SAM_REPL, NULL, 0);
+}
+
+/* Display talloc pool usage */
+
+static BOOL do_poolusage(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> pool-usage\n");
+ return False;
}
- switch (mtype) {
- case MSG_DEBUG: {
- char *buf, *b;
- char **p;
- int dim = 0;
+ messaging_register(msg_ctx, NULL, MSG_POOL_USAGE, print_string_cb);
- if (!params || !params[0]) {
- fprintf(stderr,"MSG_DEBUG needs a parameter\n");
- return(False);
- }
+ /* Send a message and register our interest in a reply */
- /* first pass retrieve total lenght */
- for (p = params; p && *p ; p++)
- dim += (strnlen(*p, 1024) +1); /* lenght + space */
- b = buf = malloc(dim);
- if (!buf) {
- fprintf(stderr, "Out of memory!");
- return(False);
- }
- /* now build a single string with all parameters */
- for(p = params; p && *p; p++) {
- int l = strnlen(*p, 1024);
- strncpy(b, *p, l);
- b[l] = ' ';
- b = b + l + 1;
- }
- b[-1] = '\0';
+ if (!send_message(msg_ctx, pid, MSG_REQ_POOL_USAGE, NULL, 0))
+ return False;
- send_message(dest, MSG_DEBUG, buf, dim, False);
+ wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
- free(buf);
-
- break;
+ /* No replies were received within the timeout period */
+
+ if (num_replies == 0)
+ printf("No replies received\n");
+
+ messaging_deregister(msg_ctx, MSG_POOL_USAGE, NULL);
+
+ return num_replies;
+}
+
+/* Perform a dmalloc mark */
+
+static BOOL do_dmalloc_mark(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> dmalloc-mark\n");
+ return False;
}
- case MSG_PROFILE:
- if (!params || !params[0]) {
- fprintf(stderr,"MSG_PROFILE needs a parameter\n");
- return(False);
- }
- if (strequal(params[0], "off")) {
- v = 0;
- } else if (strequal(params[0], "count")) {
- v = 1;
- } else if (strequal(params[0], "on")) {
- v = 2;
- } else if (strequal(params[0], "flush")) {
- v = 3;
- } else {
- fprintf(stderr,
- "MSG_PROFILE parameter must be off, count, on, or flush\n");
- return(False);
- }
- send_message(dest, MSG_PROFILE, &v, sizeof(int), False);
- break;
+ return send_message(msg_ctx, pid, MSG_REQ_DMALLOC_MARK, NULL, 0);
+}
- case MSG_FORCE_ELECTION:
- if (!strequal(dest, "nmbd")) {
- fprintf(stderr,"force-election can only be sent to nmbd\n");
- return(False);
- }
- send_message(dest, MSG_FORCE_ELECTION, NULL, 0, False);
- break;
+/* Perform a dmalloc changed */
- case MSG_REQ_PROFILELEVEL:
- if (!profilelevel_registered) {
- message_register(MSG_PROFILELEVEL, profilelevel_function);
- profilelevel_registered = True;
- }
- got_level = False;
- retval = send_message(dest, MSG_REQ_PROFILELEVEL, NULL, 0, True);
- if (retval) {
- timeout_start = time(NULL);
- while (!got_level) {
- message_dispatch();
- if ((time(NULL) - timeout_start) > MAX_WAIT) {
- fprintf(stderr,"profilelevel timeout\n");
- break;
- }
- }
- }
- break;
+static BOOL do_dmalloc_changed(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> "
+ "dmalloc-log-changed\n");
+ return False;
+ }
- case MSG_REQ_TALLOC_USAGE:
- if (!poolusage_registered) {
- message_register(MSG_TALLOC_USAGE, tallocdump_function);
- poolusage_registered = True;
- }
- got_pool = False;
- retval = send_message(dest, MSG_REQ_TALLOC_USAGE, NULL, 0, True);
- if (retval) {
- timeout_start = time(NULL);
- while (!got_pool) {
- message_dispatch();
- if ((time(NULL) - timeout_start) > MAX_WAIT) {
- fprintf(stderr,"tallocdump timeout\n");
- break;
- }
- }
- }
- break;
+ return send_message(msg_ctx, pid, MSG_REQ_DMALLOC_LOG_CHANGED,
+ NULL, 0);
+}
- case MSG_REQ_DEBUGLEVEL:
- if (!debuglevel_registered) {
- message_register(MSG_DEBUGLEVEL, debuglevel_function);
- debuglevel_registered = True;
- }
- got_level = False;
- retval = send_message(dest, MSG_REQ_DEBUGLEVEL, NULL, 0, True);
- if (retval) {
- timeout_start = time(NULL);
- while (!got_level) {
- message_dispatch();
- if ((time(NULL) - timeout_start) > MAX_WAIT) {
- fprintf(stderr,"debuglevel timeout\n");
- break;
- }
- }
- }
- break;
+/* Shutdown a server process */
- /* Send a notification message to a printer */
+static BOOL do_shutdown(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> shutdown\n");
+ return False;
+ }
- case MSG_PRINTER_NOTIFY2: {
- char *cmd;
+ return send_message(msg_ctx, pid, MSG_SHUTDOWN, NULL, 0);
+}
- /* Read subcommand */
+/* Notify a driver upgrade */
- if (!params || !params[0]) {
- fprintf(stderr, "Must specify subcommand:\n");
- fprintf(stderr, "\tqueuepause <printername>\n");
- fprintf(stderr, "\tqueueresume <printername>\n");
- fprintf(stderr, "\tjobpause <printername> <unix jobid>\n");
- fprintf(stderr, "\tjobresume <printername> <unix jobid>\n");
- fprintf(stderr, "\tjobdelete <printername> <unix jobid>\n");
- fprintf(stderr, "\tprinter <printername> <comment|port|driver> <new value>\n");
- return False;
- }
+static BOOL do_drvupgrade(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 2) {
+ fprintf(stderr, "Usage: smbcontrol <dest> drvupgrade "
+ "<driver-name>\n");
+ return False;
+ }
- cmd = params[0];
+ return send_message(msg_ctx, pid, MSG_DEBUG, argv[1],
+ strlen(argv[1]) + 1);
+}
- check_notify_msgs = True;
+static BOOL do_winbind_online(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ TDB_CONTEXT *tdb;
- /* Pause a print queue */
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol winbindd online\n");
+ return False;
+ }
- if (strequal(cmd, "queuepause")) {
+ if (!lp_winbind_offline_logon()) {
+ fprintf(stderr, "The parameter \"winbind offline logon\" must "
+ "be set in the [global] section of smb.conf for this "
+ "command to be allowed.\n");
+ return False;
+ }
- if (!params[1]) {
- fprintf(stderr, "queuepause command requires a printer name\n");
- return False;
- }
+ /* Remove the entry in the winbindd_cache tdb to tell a later
+ starting winbindd that we're online. */
- notify_printer_status_byname(params[1], PRINTER_STATUS_PAUSED);
- break;
- }
+ tdb = tdb_open_log(lock_path("winbindd_cache.tdb"), 0, TDB_DEFAULT, O_RDWR, 0600);
+ if (!tdb) {
+ fprintf(stderr, "Cannot open the tdb %s for writing.\n",
+ lock_path("winbindd_cache.tdb"));
+ return False;
+ }
- /* Resume a print queue */
+ tdb_delete_bystring(tdb, "WINBINDD_OFFLINE");
+ tdb_close(tdb);
- if (strequal(cmd, "queueresume")) {
+ return send_message(msg_ctx, pid, MSG_WINBIND_ONLINE, NULL, 0);
+}
- if (!params[1]) {
- fprintf(stderr, "queueresume command requires a printer name\n");
- return False;
- }
+static BOOL do_winbind_offline(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ TDB_CONTEXT *tdb;
+ BOOL ret = False;
+ int retry = 0;
- notify_printer_status_byname(params[1], PRINTER_STATUS_OK);
- break;
- }
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol winbindd offline\n");
+ return False;
+ }
- /* Pause a print job */
+ if (!lp_winbind_offline_logon()) {
+ fprintf(stderr, "The parameter \"winbind offline logon\" must "
+ "be set in the [global] section of smb.conf for this "
+ "command to be allowed.\n");
+ return False;
+ }
- if (strequal(cmd, "jobpause")) {
- int jobid;
+ /* Create an entry in the winbindd_cache tdb to tell a later
+ starting winbindd that we're offline. We may actually create
+ it here... */
- if (!params[1] || !params[2]) {
- fprintf(stderr, "jobpause command requires a printer name and a jobid\n");
- return False;
- }
+ tdb = tdb_open_log(lock_path("winbindd_cache.tdb"),
+ WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
+ TDB_DEFAULT /* TDB_CLEAR_IF_FIRST */, O_RDWR|O_CREAT, 0600);
- jobid = atoi(params[2]);
+ if (!tdb) {
+ fprintf(stderr, "Cannot open the tdb %s for writing.\n",
+ lock_path("winbindd_cache.tdb"));
+ return False;
+ }
- notify_job_status_byname(
- params[1], jobid, JOB_STATUS_PAUSED,
- SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
- break;
- }
+ /* There's a potential race condition that if a child
+ winbindd detects a domain is online at the same time
+ we're trying to tell it to go offline that it might
+ delete the record we add between us adding it and
+ sending the message. Minimize this by retrying up to
+ 5 times. */
+
+ for (retry = 0; retry < 5; retry++) {
+ TDB_DATA d;
+ uint8 buf[4];
- /* Resume a print job */
+ ZERO_STRUCT(d);
- if (strequal(cmd, "jobresume")) {
- int jobid;
+ SIVAL(buf, 0, time(NULL));
+ d.dptr = buf;
+ d.dsize = 4;
- if (!params[1] || !params[2]) {
- fprintf(stderr, "jobresume command requires a printer name and a jobid\n");
- return False;
- }
+ tdb_store_bystring(tdb, "WINBINDD_OFFLINE", d, TDB_INSERT);
- jobid = atoi(params[2]);
+ ret = send_message(msg_ctx, pid, MSG_WINBIND_OFFLINE,
+ NULL, 0);
- notify_job_status_byname(
- params[1], jobid, JOB_STATUS_QUEUED,
- SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
+ /* Check that the entry "WINBINDD_OFFLINE" still exists. */
+ d = tdb_fetch_bystring( tdb, "WINBINDD_OFFLINE" );
+
+ if (!d.dptr || d.dsize != 4) {
+ SAFE_FREE(d.dptr);
+ DEBUG(10,("do_winbind_offline: offline state not set - retrying.\n"));
+ } else {
+ SAFE_FREE(d.dptr);
break;
}
+ }
- /* Delete a print job */
+ tdb_close(tdb);
+ return ret;
+}
- if (strequal(cmd, "jobdelete")) {
- int jobid;
+static BOOL do_winbind_onlinestatus(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ struct server_id myid;
- if (!params[1] || !params[2]) {
- fprintf(stderr, "jobdelete command requires a printer name and a jobid\n");
- return False;
- }
+ myid = pid_to_procid(sys_getpid());
- jobid = atoi(params[2]);
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol winbindd onlinestatus\n");
+ return False;
+ }
- notify_job_status_byname(
- params[1], jobid, JOB_STATUS_DELETING,
- SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
+ messaging_register(msg_ctx, NULL, MSG_WINBIND_ONLINESTATUS,
+ print_pid_string_cb);
- notify_job_status_byname(
- params[1], jobid, JOB_STATUS_DELETING|
- JOB_STATUS_DELETED,
- SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
- }
-
- /* printer change notify */
-
- if (strequal(cmd, "printer")) {
- int attribute = -1;
-
- if (!params[1] || !params[2] || !params[3]) {
- fprintf(stderr, "printer command requires an and attribute name and value!\n");
- fprintf(stderr, "supported attributes:\n");
- fprintf(stderr, "\tcomment:\n");
- fprintf(stderr, "\tport:\n");
- fprintf(stderr, "\tdriver:\n");
- return False;
- }
- if ( strequal(params[2], "comment") )
- attribute = PRINTER_NOTIFY_COMMENT;
- else if ( strequal(params[2], "port") )
- attribute = PRINTER_NOTIFY_PORT_NAME;
- else if ( strequal(params[2], "driver") )
- attribute = PRINTER_NOTIFY_DRIVER_NAME;
-
- if ( attribute == -1 ) {
- fprintf(stderr, "bad attribute!\n");
- return False;
- }
-
- notify_printer_byname( params[1], attribute, params[3]);
-
- break;
- }
-
- break;
- }
+ if (!send_message(msg_ctx, pid, MSG_WINBIND_ONLINESTATUS, &myid,
+ sizeof(myid)))
+ return False;
+ wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
- case MSG_SMB_FORCE_TDIS:
- if (!strequal(dest, "smbd")) {
- fprintf(stderr,"close-share can only be sent to smbd\n");
- return(False);
- }
- if (!params || !params[0]) {
- fprintf(stderr, "close-share needs a share name or '*'\n");
- return (False);
- }
- retval = send_message(dest, MSG_SMB_FORCE_TDIS, params[0],
- strlen(params[0]) + 1, False);
- break;
+ /* No replies were received within the timeout period */
+
+ if (num_replies == 0)
+ printf("No replies received\n");
+
+ messaging_deregister(msg_ctx, MSG_WINBIND_ONLINESTATUS, NULL);
- case MSG_SMB_SAM_SYNC:
- if (!strequal(dest, "smbd")) {
- fprintf(stderr, "samsync can only be sent to smbd\n");
- return False;
- }
+ return num_replies;
+}
- if (params) {
- fprintf(stderr, "samsync does not take any parameters\n");
- return False;
- }
+static BOOL do_dump_event_list(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ struct server_id myid;
- retval = send_message(dest, MSG_SMB_SAM_SYNC, NULL, 0, False);
+ myid = pid_to_procid(sys_getpid());
- break;
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> dump-event-list\n");
+ return False;
+ }
- case MSG_SMB_SAM_REPL: {
- uint32 seqnum;
+ return send_message(msg_ctx, pid, MSG_DUMP_EVENT_LIST, NULL, 0);
+}
- if (!strequal(dest, "smbd")) {
- fprintf(stderr, "sam repl can only be sent to smbd\n");
- return False;
- }
- if (!params || !params[0]) {
- fprintf(stderr, "SAM_REPL needs a parameter\n");
- return False;
- }
+static BOOL do_reload_config(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> reload-config\n");
+ return False;
+ }
- seqnum = atoi(params[0]);
+ return send_message(msg_ctx, pid, MSG_SMB_CONF_UPDATED, NULL, 0);
+}
- retval = send_message(dest, MSG_SMB_SAM_SYNC,
- (char *)&seqnum, sizeof(uint32), False);
+static void my_make_nmb_name( struct nmb_name *n, const char *name, int type)
+{
+ fstring unix_name;
+ memset( (char *)n, '\0', sizeof(struct nmb_name) );
+ fstrcpy(unix_name, name);
+ strupper_m(unix_name);
+ push_ascii(n->name, unix_name, sizeof(n->name), STR_TERMINATE);
+ n->name_type = (unsigned int)type & 0xFF;
+ push_ascii(n->scope, global_scope(), 64, STR_TERMINATE);
+}
- break;
- }
+static BOOL do_nodestatus(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ struct packet_struct p;
- case MSG_PING:
- if (!pong_registered) {
- message_register(MSG_PONG, pong_function);
- pong_registered = True;
- }
- if (!params || !params[0]) {
- fprintf(stderr,"MSG_PING needs a parameter\n");
- return(False);
- }
- n = atoi(params[0]);
- pong_count = 0;
- for (i=0;i<n;i++) {
- if (iparams > 1)
- retval = send_message(dest, MSG_PING, params[1], strlen(params[1]) + 1, True);
- else
- retval = send_message(dest, MSG_PING, NULL, 0, True);
- if (retval == False)
- return False;
- }
- wait_for_replies(MAX_WAIT, &n);
- if (n > 0) {
- fprintf(stderr,"PING timeout\n");
+ if (argc != 2) {
+ fprintf(stderr, "Usage: smbcontrol nmbd nodestatus <ip>\n");
+ return False;
+ }
+
+ ZERO_STRUCT(p);
+
+ p.ip = *interpret_addr2(argv[1]);
+ p.port = 137;
+ p.packet_type = NMB_PACKET;
+
+ p.packet.nmb.header.name_trn_id = 10;
+ p.packet.nmb.header.opcode = 0;
+ p.packet.nmb.header.response = False;
+ p.packet.nmb.header.nm_flags.bcast = False;
+ p.packet.nmb.header.nm_flags.recursion_available = False;
+ p.packet.nmb.header.nm_flags.recursion_desired = False;
+ p.packet.nmb.header.nm_flags.trunc = False;
+ p.packet.nmb.header.nm_flags.authoritative = False;
+ p.packet.nmb.header.rcode = 0;
+ p.packet.nmb.header.qdcount = 1;
+ p.packet.nmb.header.ancount = 0;
+ p.packet.nmb.header.nscount = 0;
+ p.packet.nmb.header.arcount = 0;
+ my_make_nmb_name(&p.packet.nmb.question.question_name, "*", 0x00);
+ p.packet.nmb.question.question_type = 0x21;
+ p.packet.nmb.question.question_class = 0x1;
+
+ return send_message(msg_ctx, pid, MSG_SEND_PACKET, &p, sizeof(p));
+}
+
+/* A list of message type supported */
+
+static const struct {
+ const char *name; /* Option name */
+ BOOL (*fn)(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv);
+ const char *help; /* Short help text */
+} msg_types[] = {
+ { "debug", do_debug, "Set debuglevel" },
+ { "force-election", do_election,
+ "Force a browse election" },
+ { "ping", do_ping, "Elicit a response" },
+ { "profile", do_profile, "" },
+ { "inject", do_inject_fault,
+ "Inject a fatal signal into a running smbd"},
+ { "stacktrace", do_daemon_stack_trace,
+ "Display a stack trace of a daemon" },
+ { "profilelevel", do_profilelevel, "" },
+ { "debuglevel", do_debuglevel, "Display current debuglevels" },
+ { "printnotify", do_printnotify, "Send a print notify message" },
+ { "close-share", do_closeshare, "Forcibly disconnect a share" },
+ { "lockretry", do_lockretry, "Force a blocking lock retry" },
+ { "brl-revalidate", do_brl_revalidate, "Revalidate all brl entries" },
+ { "samsync", do_samsync, "Initiate SAM synchronisation" },
+ { "samrepl", do_samrepl, "Initiate SAM replication" },
+ { "pool-usage", do_poolusage, "Display talloc memory usage" },
+ { "dmalloc-mark", do_dmalloc_mark, "" },
+ { "dmalloc-log-changed", do_dmalloc_changed, "" },
+ { "shutdown", do_shutdown, "Shut down daemon" },
+ { "drvupgrade", do_drvupgrade, "Notify a printer driver has changed" },
+ { "reload-config", do_reload_config, "Force smbd or winbindd to reload config file"},
+ { "nodestatus", do_nodestatus, "Ask nmbd to do a node status request"},
+ { "online", do_winbind_online, "Ask winbind to go into online state"},
+ { "offline", do_winbind_offline, "Ask winbind to go into offline state"},
+ { "onlinestatus", do_winbind_onlinestatus, "Request winbind online status"},
+ { "dump-event-list", do_dump_event_list, "Dump event list"},
+ { "noop", do_noop, "Do nothing" },
+ { NULL }
+};
+
+/* Display usage information */
+
+static void usage(poptContext pc)
+{
+ int i;
+
+ poptPrintHelp(pc, stderr, 0);
+
+ fprintf(stderr, "\n");
+ fprintf(stderr, "<destination> is one of \"nmbd\", \"smbd\", \"winbindd\" or a "
+ "process ID\n");
+
+ fprintf(stderr, "\n");
+ fprintf(stderr, "<message-type> is one of:\n");
+
+ for (i = 0; msg_types[i].name; i++)
+ fprintf(stderr, "\t%-30s%s\n", msg_types[i].name,
+ msg_types[i].help);
+
+ fprintf(stderr, "\n");
+
+ exit(1);
+}
+
+/* Return the pid number for a string destination */
+
+static struct server_id parse_dest(const char *dest)
+{
+ struct server_id result = {-1};
+ pid_t pid;
+
+ /* Zero is a special return value for broadcast smbd */
+
+ if (strequal(dest, "smbd")) {
+ return interpret_pid("0");
+ }
+
+ /* Try self - useful for testing */
+
+ if (strequal(dest, "self")) {
+ return pid_to_procid(sys_getpid());
+ }
+
+ /* Fix winbind typo. */
+ if (strequal(dest, "winbind")) {
+ dest = "winbindd";
+ }
+
+
+ if (!(strequal(dest, "winbindd") || strequal(dest, "nmbd"))) {
+ /* Check for numeric pid number */
+
+ result = interpret_pid(dest);
+
+ /* Zero isn't valid if not smbd. */
+ if (result.pid && procid_valid(&result)) {
+ return result;
}
- break;
+ }
- case MSG_REQ_POOL_USAGE:
- if (!send_message(dest, MSG_REQ_POOL_USAGE, NULL, 0, True))
- return False;
- wait_for_replies(MAX_WAIT, NULL);
-
- break;
+ /* Look up other destinations in pidfile directory */
- case MSG_REQ_DMALLOC_LOG_CHANGED:
- case MSG_REQ_DMALLOC_MARK:
- if (!send_message(dest, mtype, NULL, 0, False))
- return False;
- break;
+ if ((pid = pidfile_pid(dest)) != 0) {
+ return pid_to_procid(pid);
+ }
- case MSG_SHUTDOWN:
- if (!send_message(dest, MSG_SHUTDOWN, NULL, 0, False))
- return False;
- break;
- case MSG_PRINTER_DRVUPGRADE:
- if (!send_message(dest, MSG_PRINTER_DRVUPGRADE, params[0], 0, False))
- return False;
- break;
+ fprintf(stderr,"Can't find pid for destination '%s'\n", dest);
+
+ return result;
+}
+
+/* Execute smbcontrol command */
+
+static BOOL do_command(struct messaging_context *msg_ctx,
+ int argc, const char **argv)
+{
+ const char *dest = argv[0], *command = argv[1];
+ struct server_id pid;
+ int i;
+
+ /* Check destination */
+
+ pid = parse_dest(dest);
+ if (!procid_valid(&pid)) {
+ return False;
}
- /* check if we have any pending print notify messages */
+ /* Check command */
- if ( check_notify_msgs )
- print_notify_send_messages(0);
-
- return (True);
+ for (i = 0; msg_types[i].name; i++) {
+ if (strequal(command, msg_types[i].name))
+ return msg_types[i].fn(msg_ctx, pid,
+ argc - 1, argv + 1);
+ }
+
+ fprintf(stderr, "smbcontrol: unknown command '%s'\n", command);
+
+ return False;
}
- int main(int argc, char *argv[])
+static void smbcontrol_help(poptContext pc,
+ enum poptCallbackReason preason,
+ struct poptOption * poption,
+ const char * parg,
+ void * pdata)
{
+ if (poption->shortName != '?') {
+ poptPrintUsage(pc, stdout, 0);
+ } else {
+ usage(pc);
+ }
+
+ exit(0);
+}
+
+struct poptOption help_options[] = {
+ { NULL, '\0', POPT_ARG_CALLBACK, (void *)&smbcontrol_help, '\0',
+ NULL, NULL },
+ { "help", '?', 0, NULL, '?', "Show this help message", NULL },
+ { "usage", '\0', 0, NULL, 'u', "Display brief usage message", NULL },
+ { NULL }
+} ;
+
+/* Main program */
+
+int main(int argc, const char **argv)
+{
+ poptContext pc;
int opt;
- char temp[255];
- extern int optind;
- BOOL interactive = False;
+ struct event_context *evt_ctx;
+ struct messaging_context *msg_ctx;
+
+ static struct poptOption long_options[] = {
+ /* POPT_AUTOHELP */
+ { NULL, '\0', POPT_ARG_INCLUDE_TABLE, help_options,
+ 0, "Help options:", NULL },
+ { "timeout", 't', POPT_ARG_INT, &timeout, 't',
+ "Set timeout value in seconds", "TIMEOUT" },
- AllowDebugChange = False;
- DEBUGLEVEL = 0;
+ POPT_COMMON_SAMBA
+ POPT_TABLEEND
+ };
+
+ load_case_tables();
setup_logging(argv[0],True);
- if (argc < 2) usage(True);
+ /* Parse command line arguments using popt */
- while ((opt = getopt(argc, argv,"is:")) != EOF) {
- switch (opt) {
- case 'i':
- interactive = True;
- break;
- case 's':
- pstrcpy(dyn_CONFIGFILE, optarg);
+ pc = poptGetContext(
+ "smbcontrol", argc, (const char **)argv, long_options, 0);
+
+ poptSetOtherOptionHelp(pc, "[OPTION...] <destination> <message-type> "
+ "<parameters>");
+
+ if (argc == 1)
+ usage(pc);
+
+ while ((opt = poptGetNextOpt(pc)) != -1) {
+ switch(opt) {
+ case 't': /* --timeout */
break;
default:
- printf("Unknown option %c (%d)\n", (char)opt, opt);
- usage(True);
+ fprintf(stderr, "Invalid option\n");
+ poptPrintHelp(pc, stderr, 0);
+ break;
}
}
- lp_load(dyn_CONFIGFILE,False,False,False);
-
- if (!message_init()) exit(1);
-
- argc -= optind;
- argv = &argv[optind];
-
- register_all();
+ /* We should now have the remaining command line arguments in
+ argv. The argc parameter should have been decremented to the
+ correct value in the above switch statement. */
- if (!interactive) {
- if (argc < 2) usage(True);
- /* Need to invert sense of return code -- samba
- * routines mostly return True==1 for success, but
- * shell needs 0. */
- return ! do_command(argv[0],argv[1], argc-2, argc > 2 ? &argv[2] : 0);
+ argv = (const char **)poptGetArgs(pc);
+ argc = 0;
+ while (argv[argc] != NULL) {
+ argc++;
}
- while (True) {
- char *myargv[4];
- int myargc;
+ if (argc == 1)
+ usage(pc);
- printf("smbcontrol> ");
- if (!fgets(temp, sizeof(temp)-1, stdin)) break;
- myargc = 0;
- while ((myargc < 4) &&
- (myargv[myargc] = strtok(myargc?NULL:temp," \t\n"))) {
- myargc++;
- }
- if (!myargc) break;
- if (strequal(myargv[0],"q")) break;
- if (myargc < 2)
- usage(False);
- else if (!do_command(myargv[0],myargv[1],myargc-2,myargc > 2 ? &myargv[2] : 0))
- usage(False);
+ lp_load(dyn_CONFIGFILE,False,False,False,True);
+
+ /* Need to invert sense of return code -- samba
+ * routines mostly return True==1 for success, but
+ * shell needs 0. */
+
+ if (!(evt_ctx = event_context_init(NULL)) ||
+ !(msg_ctx = messaging_init(NULL, server_id_self(), evt_ctx))) {
+ fprintf(stderr, "could not init messaging context\n");
+ exit(1);
}
- return(0);
+
+ return !do_command(msg_ctx, argc, argv);
}
-
git.samba.org / sfrench / samba-autobuild / .git / blobdiff