/*
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
- 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"
-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;
+}
+
+static void timeout_handler(struct event_context *event_ctx,
+ struct timed_event *te,
+ const struct timeval *now,
+ void *private_data)
+{
+ bool *timed_out = (bool *)private_data;
+ TALLOC_FREE(te);
+ *timed_out = True;
+}
+
+/* Wait for one or more reply messages */
+
+static void wait_replies(struct messaging_context *msg_ctx,
+ bool multiple_replies)
+{
+ struct timed_event *te;
+ bool timed_out = False;
+
+ if (!(te = event_add_timed(messaging_event_context(msg_ctx), NULL,
+ timeval_current_ofs(timeout, 0),
+ "smbcontrol_timeout",
+ timeout_handler, (void *)&timed_out))) {
+ DEBUG(0, ("event_add_timed failed\n"));
+ return;
+ }
+
+ while (!timed_out) {
+ message_dispatch(msg_ctx);
+ if (num_replies > 0 && !multiple_replies)
+ break;
+ event_loop_once(messaging_event_context(msg_ctx));
+ }
+}
+
+/* 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);
+ }
+
+ 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);
}
- 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);
+
+ 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(&crec->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;
+ pid_t dest;
+ int count = 0;
- while ((!max_replies || (*max_replies)-- > 0)
- && (time(NULL) < timeout_end)) {
- message_dispatch();
+ 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;
+ }
+
+#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;
+ }
- 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;
+ 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;
- pstring dbgcl;
+ 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);
-
- while(next_token(&levels, dbgcl, " ", sizeof(pstring)))
- printf("%s\n", dbgcl);
-
- got_level = True;
+ return send_message(msg_ctx, pid, MSG_FORCE_ELECTION, NULL, 0);
+}
+
+/* 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)
+{
+ char *src_string = procid_str(NULL, &pid);
+ printf("PONG from pid %s\n", src_string);
+ TALLOC_FREE(src_string);
+ num_replies++;
}
-/****************************************************************************
-Prints out the current Profile level returned by MSG_PROFILELEVEL
-****************************************************************************/
-void profilelevel_function(int msg_type, pid_t src, void *buf, size_t len)
+static bool do_ping(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
{
- int level;
- const char *s=NULL;
- memcpy(&level, buf, sizeof(int));
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> ping\n");
+ return False;
+ }
+
+ /* Send a message and register our interest in a reply */
+
+ if (!send_message(msg_ctx, pid, MSG_PING, NULL, 0))
+ return False;
- if (level) {
- switch (level) {
- case 1:
+ 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);
+
+ 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");
-/**
- * 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)
+ 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;
- 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");
+ } else if (strcmp(cmd, "queueresume") == 0) {
+
+ 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;
- }
- }
+ }
+
+ 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;
+ }
- DEBUG(10,("smbcontrol/send_message: send message to pid%d\n", pid));
- return message_send_pid(pid, msg_type, buf, len, duplicates);
+ 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. */
- /* Resume a print job */
+ for (retry = 0; retry < 5; retry++) {
+ TDB_DATA d;
+ uint8 buf[4];
- if (strequal(cmd, "jobresume")) {
- int jobid;
+ ZERO_STRUCT(d);
- if (!params[1] || !params[2]) {
- fprintf(stderr, "jobresume command requires a printer name and a jobid\n");
- return False;
- }
+ SIVAL(buf, 0, time(NULL));
+ d.dptr = buf;
+ d.dsize = 4;
- jobid = atoi(params[2]);
+ tdb_store_bystring(tdb, "WINBINDD_OFFLINE", d, TDB_INSERT);
- notify_job_status_byname(
- params[1], jobid, JOB_STATUS_QUEUED,
- SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
+ ret = send_message(msg_ctx, pid, MSG_WINBIND_OFFLINE,
+ NULL, 0);
+
+ /* 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");
- case MSG_SMB_SAM_SYNC:
- if (!strequal(dest, "smbd")) {
- fprintf(stderr, "samsync can only be sent to smbd\n");
- return False;
- }
+ messaging_deregister(msg_ctx, MSG_WINBIND_ONLINESTATUS, NULL);
- if (params) {
- fprintf(stderr, "samsync does not take any parameters\n");
- return False;
- }
+ return num_replies;
+}
- retval = send_message(dest, MSG_SMB_SAM_SYNC, NULL, 0, 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;
- break;
+ myid = pid_to_procid(sys_getpid());
- case MSG_SMB_SAM_REPL: {
- uint32 seqnum;
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> dump-event-list\n");
+ return False;
+ }
- if (!strequal(dest, "smbd")) {
- fprintf(stderr, "sam repl can only be sent to smbd\n");
- return False;
- }
+ return send_message(msg_ctx, pid, MSG_DUMP_EVENT_LIST, NULL, 0);
+}
- if (!params || !params[0]) {
- fprintf(stderr, "SAM_REPL needs a parameter\n");
- return False;
- }
+static void winbind_validate_cache_cb(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id pid,
+ DATA_BLOB *data)
+{
+ char *src_string = procid_str(NULL, &pid);
+ printf("Winbindd cache is %svalid. (answer from pid %s)\n",
+ (*(data->data) == 0 ? "" : "NOT "), src_string);
+ TALLOC_FREE(src_string);
+ num_replies++;
+}
- seqnum = atoi(params[0]);
+static bool do_winbind_validate_cache(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ struct server_id myid = pid_to_procid(sys_getpid());
- retval = send_message(dest, MSG_SMB_SAM_SYNC,
- (char *)&seqnum, sizeof(uint32), False);
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol winbindd validate-cache\n");
+ return False;
+ }
- break;
- }
+ messaging_register(msg_ctx, NULL, MSG_WINBIND_VALIDATE_CACHE,
+ winbind_validate_cache_cb);
- 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 (!send_message(msg_ctx, pid, MSG_WINBIND_VALIDATE_CACHE, &myid,
+ sizeof(myid))) {
+ return False;
+ }
+
+ wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+
+ if (num_replies == 0) {
+ printf("No replies received\n");
+ }
+
+ messaging_deregister(msg_ctx, MSG_WINBIND_VALIDATE_CACHE, NULL);
+
+ return num_replies;
+}
+
+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;
+ }
+
+ return send_message(msg_ctx, pid, MSG_SMB_CONF_UPDATED, NULL, 0);
+}
+
+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);
+}
+
+static bool do_nodestatus(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ struct packet_struct p;
+
+ 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"},
+ { "validate-cache" , do_winbind_validate_cache,
+ "Validate winbind's credential cache" },
+ { "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(MSG_BROADCAST_PID_STR);
+ }
+
+ /* 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();
-
- 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
+ };
+ TALLOC_CTX *frame = talloc_stackframe();
+ int ret = 0;
+
+ 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;
+ if (argv != NULL) {
+ 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");
+ TALLOC_FREE(frame);
+ exit(1);
}
- return(0);
+
+ ret = !do_command(msg_ctx, argc, argv);
+ TALLOC_FREE(frame);
+ return ret;
}
-
git.samba.org / samba.git / blobdiff