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,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
+#include "system/filesys.h"
+#include "popt_common.h"
+#include "librpc/gen_ndr/spoolss.h"
+#include "nt_printing.h"
+#include "printing/notify.h"
+#include "libsmb/nmblib.h"
+#include "messages.h"
+#include "util_tdb.h"
#if HAVE_LIBUNWIND_H
#include <libunwind.h>
/* Send a message to a destination pid. Zero means broadcast smbd. */
-static BOOL send_message(struct messaging_context *msg_ctx,
+static bool send_message(struct messaging_context *msg_ctx,
struct server_id pid, int msg_type,
- const void *buf, int len,
- BOOL duplicates)
+ const void *buf, int len)
{
- BOOL ret;
+ 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));
+ (const uint8 *)buf, len));
- ret = message_send_all(msg_ctx, msg_type, buf, len, duplicates,
- &n_sent);
+ 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 smbcontrol_timeout(struct tevent_context *event_ctx,
+ struct tevent_timer *te,
+ 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)
+ bool multiple_replies)
{
- time_t start_time = time(NULL);
+ struct tevent_timer *te;
+ bool timed_out = False;
- /* Wait around a bit. This is pretty disgusting - we have to
- busy-wait here as there is no nicer way to do it. */
+ if (!(te = tevent_add_timer(messaging_event_context(msg_ctx), NULL,
+ timeval_current_ofs(timeout, 0),
+ smbcontrol_timeout, (void *)&timed_out))) {
+ DEBUG(0, ("tevent_add_timer failed\n"));
+ return;
+ }
- do {
- message_dispatch();
- event_loop_once(messaging_event_context(msg_ctx));
+ while (!timed_out) {
+ int ret;
if (num_replies > 0 && !multiple_replies)
break;
- sleep(1);
- } while (timeout - (time(NULL) - start_time) > 0);
+ ret = tevent_loop_once(messaging_event_context(msg_ctx));
+ if (ret != 0) {
+ break;
+ }
+ }
}
/* Message handler callback that displays the PID and a string on stdout */
struct server_id pid,
DATA_BLOB *data)
{
- printf("PID %u: %.*s", (unsigned int)procid_to_pid(&pid),
- (int)data->length, (const char *)data->data);
+ char *pidstr;
+
+ pidstr = server_id_str(talloc_tos(), &pid);
+ printf("PID %s: %.*s", pidstr, (int)data->length,
+ (const char *)data->data);
+ TALLOC_FREE(pidstr);
num_replies++;
}
struct server_id pid,
DATA_BLOB *data)
{
- printf("%.*s", (int)data->length, (const char *)data->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,
+static bool do_noop(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Send a debug string */
-static BOOL do_debug(struct messaging_context *msg_ctx,
+static bool do_debug(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx,
- pid, MSG_DEBUG, argv[1], strlen(argv[1]) + 1, False);
+ return send_message(msg_ctx, pid, MSG_DEBUG, argv[1],
+ strlen(argv[1]) + 1);
+}
+
+
+static bool do_idmap(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ static const char* usage = "Usage: "
+ "smbcontrol <dest> idmap <cmd> [arg]\n"
+ "\tcmd:\tflush [gid|uid]\n"
+ "\t\tdelete \"UID <uid>\"|\"GID <gid>\"|<sid>\n"
+ "\t\tkill \"UID <uid>\"|\"GID <gid>\"|<sid>\n";
+ const char* arg = NULL;
+ int arglen = 0;
+ int msg_type;
+
+ switch (argc) {
+ case 2:
+ break;
+ case 3:
+ arg = argv[2];
+ arglen = strlen(arg) + 1;
+ break;
+ default:
+ fprintf(stderr, "%s", usage);
+ return false;
+ }
+
+ if (strcmp(argv[1], "flush") == 0) {
+ msg_type = ID_CACHE_FLUSH;
+ }
+ else if (strcmp(argv[1], "delete") == 0) {
+ msg_type = ID_CACHE_DELETE;
+ }
+ else if (strcmp(argv[1], "kill") == 0) {
+ msg_type = ID_CACHE_KILL;
+ }
+ else if (strcmp(argv[1], "help") == 0) {
+ fprintf(stdout, "%s", usage);
+ return true;
+ }
+ else {
+ fprintf(stderr, "%s", usage);
+ return false;
+ }
+
+ return send_message(msg_ctx, pid, msg_type, arg, arglen);
}
+
#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,
ptrace(PTRACE_DETACH, pid, NULL, NULL);
}
-static int stack_trace_connection(TDB_CONTEXT * tdb,
- const struct connections_key *key,
- const struct connections_data *conn,
+static int stack_trace_connection(const struct connections_key *key,
+ const struct connections_data *crec,
+ void *priv)
{
- print_stack_trace(procid_to_pid(&conn->pid), (int *)priv);
+ print_stack_trace(procid_to_pid(&crec->pid), (int *)priv);
return 0;
}
-static BOOL do_daemon_stack_trace(struct messaging_context *msg_ctx,
+static bool do_daemon_stack_trace(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
- fprintf(stderr,
- "Daemon stack tracing is not supported on this platform\n");
- return False;
-
pid_t dest;
int count = 0;
*/
print_stack_trace(dest, &count);
} else {
- connections_traverse(stack_trace_connection, &count);
+ connections_forall_read(stack_trace_connection, &count);
}
return True;
#else /* defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE) */
-static BOOL do_daemon_stack_trace(struct messaging_context *msg_ctx,
+static bool do_daemon_stack_trace(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Inject a fault (fatal signal) into a running smbd */
-static BOOL do_inject_fault(struct messaging_context *msg_ctx,
+static bool do_inject_fault(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
}
return send_message(msg_ctx, pid, MSG_SMB_INJECT_FAULT,
- &sig, sizeof(int), False);
+ &sig, sizeof(int));
}
#endif /* DEVELOPER */
}
/* Force a browser election */
-static BOOL do_election(struct messaging_context *msg_ctx,
+static bool do_election(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx,
- pid, MSG_FORCE_ELECTION, NULL, 0, False);
+ return send_message(msg_ctx, pid, MSG_FORCE_ELECTION, NULL, 0);
}
/* Ping a samba daemon process */
struct server_id pid,
DATA_BLOB *data)
{
- char *src_string = procid_str(NULL, &pid);
+ char *src_string = server_id_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,
+static bool do_ping(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Send a message and register our interest in a reply */
- if (!send_message(msg_ctx, pid, MSG_PING, NULL, 0, False))
+ if (!send_message(msg_ctx, pid, MSG_PING, NULL, 0))
return False;
messaging_register(msg_ctx, NULL, MSG_PONG, pong_cb);
/* Set profiling options */
-static BOOL do_profile(struct messaging_context *msg_ctx,
+static bool do_profile(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx, pid, MSG_PROFILE, &v, sizeof(int), False);
+ return send_message(msg_ctx, pid, MSG_PROFILE, &v, sizeof(int));
}
/* Return the profiling level */
s = "BOGUS";
break;
}
-
+
printf("Profiling %s on pid %u\n",s,(unsigned int)procid_to_pid(&pid));
}
/* Send back a dummy reply */
- send_message(msg_ctx, pid, MSG_PROFILELEVEL, &v, sizeof(int), False);
+ send_message(msg_ctx, pid, MSG_PROFILELEVEL, &v, sizeof(int));
}
-static BOOL do_profilelevel(struct messaging_context *msg_ctx,
+static bool do_profilelevel(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Send a message and register our interest in a reply */
- if (!send_message(msg_ctx, pid, MSG_REQ_PROFILELEVEL, NULL, 0, False))
+ if (!send_message(msg_ctx, pid, MSG_REQ_PROFILELEVEL, NULL, 0))
return False;
messaging_register(msg_ctx, NULL, MSG_PROFILELEVEL, profilelevel_cb);
/* Display debug level settings */
-static BOOL do_debuglevel(struct messaging_context *msg_ctx,
+static bool do_debuglevel(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Send a message and register our interest in a reply */
- if (!send_message(msg_ctx, pid, MSG_REQ_DEBUGLEVEL, NULL, 0, False))
+ if (!send_message(msg_ctx, pid, MSG_REQ_DEBUGLEVEL, NULL, 0))
return False;
messaging_register(msg_ctx, NULL, MSG_DEBUGLEVEL, print_pid_string_cb);
/* Send a print notify message */
-static BOOL do_printnotify(struct messaging_context *msg_ctx,
+static bool do_printnotify(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
fprintf(stderr, "\tjobdelete <printername> <unix jobid>\n");
fprintf(stderr, "\tprinter <printername> <comment|port|"
"driver> <value>\n");
-
+
return False;
}
" queuepause <printername>\n");
return False;
}
-
- notify_printer_status_byname(argv[2], PRINTER_STATUS_PAUSED);
+
+ notify_printer_status_byname(messaging_event_context(msg_ctx),
+ msg_ctx, argv[2],
+ PRINTER_STATUS_PAUSED);
goto send;
" queuereume <printername>\n");
return False;
}
-
- notify_printer_status_byname(argv[2], PRINTER_STATUS_OK);
+
+ notify_printer_status_byname(messaging_event_context(msg_ctx),
+ msg_ctx, argv[2],
+ PRINTER_STATUS_OK);
goto send;
jobid = atoi(argv[3]);
notify_job_status_byname(
- argv[2], jobid, JOB_STATUS_PAUSED,
+ messaging_event_context(msg_ctx), msg_ctx,
+ argv[2], jobid, JOB_STATUS_PAUSED,
SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
goto send;
jobid = atoi(argv[3]);
notify_job_status_byname(
+ messaging_event_context(msg_ctx), msg_ctx,
argv[2], jobid, JOB_STATUS_QUEUED,
SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
jobid = atoi(argv[3]);
notify_job_status_byname(
+ messaging_event_context(msg_ctx), msg_ctx,
argv[2], jobid, JOB_STATUS_DELETING,
SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
-
+
notify_job_status_byname(
+ messaging_event_context(msg_ctx), msg_ctx,
argv[2], jobid, JOB_STATUS_DELETING|
JOB_STATUS_DELETED,
SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
} else if (strcmp(cmd, "printer") == 0) {
uint32 attribute;
-
+
if (argc != 5) {
fprintf(stderr, "Usage: smbcontrol <dest> printnotify "
"printer <printername> <comment|port|driver> "
}
if (strcmp(argv[3], "comment") == 0) {
- attribute = PRINTER_NOTIFY_COMMENT;
+ attribute = PRINTER_NOTIFY_FIELD_COMMENT;
} else if (strcmp(argv[3], "port") == 0) {
- attribute = PRINTER_NOTIFY_PORT_NAME;
+ attribute = PRINTER_NOTIFY_FIELD_PORT_NAME;
} else if (strcmp(argv[3], "driver") == 0) {
- attribute = PRINTER_NOTIFY_DRIVER_NAME;
+ attribute = PRINTER_NOTIFY_FIELD_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]));
+ notify_printer_byname(messaging_event_context(msg_ctx),
+ msg_ctx, argv[2], attribute,
+ discard_const_p(char, argv[4]));
goto send;
}
/* Close a share */
-static BOOL do_closeshare(struct messaging_context *msg_ctx,
+static bool do_closeshare(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx,
- pid, MSG_SMB_FORCE_TDIS, argv[1], strlen(argv[1]) + 1, False);
+ return send_message(msg_ctx, pid, MSG_SMB_FORCE_TDIS, argv[1],
+ strlen(argv[1]) + 1);
+}
+
+/* Tell winbindd an IP got dropped */
+
+static bool do_ip_dropped(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 2) {
+ fprintf(stderr, "Usage: smbcontrol <dest> ip-dropped "
+ "<ip-address>\n");
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_WINBIND_IP_DROPPED, argv[1],
+ strlen(argv[1]) + 1);
+}
+
+/* force a blocking lock retry */
+
+static bool do_lockretry(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> lockretry\n");
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_SMB_UNLOCK, NULL, 0);
+}
+
+/* force a validation of all brl entries, including re-sends. */
+
+static bool do_brl_revalidate(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> brl-revalidate\n");
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_SMB_BRL_VALIDATE, NULL, 0);
}
/* Force a SAM synchronisation */
-static BOOL do_samsync(struct messaging_context *msg_ctx,
+static bool do_samsync(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx,
- pid, MSG_SMB_SAM_SYNC, NULL, 0, False);
+ return send_message(msg_ctx, pid, MSG_SMB_SAM_SYNC, NULL, 0);
}
/* Force a SAM replication */
-static BOOL do_samrepl(struct messaging_context *msg_ctx,
+static bool do_samrepl(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx,
- pid, MSG_SMB_SAM_REPL, NULL, 0, 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,
+static bool do_poolusage(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Send a message and register our interest in a reply */
- if (!send_message(msg_ctx, pid, MSG_REQ_POOL_USAGE, NULL, 0, False))
+ if (!send_message(msg_ctx, pid, MSG_REQ_POOL_USAGE, NULL, 0))
return False;
wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
/* Perform a dmalloc mark */
-static BOOL do_dmalloc_mark(struct messaging_context *msg_ctx,
+static bool do_dmalloc_mark(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx,
- pid, MSG_REQ_DMALLOC_MARK, NULL, 0, False);
+ return send_message(msg_ctx, pid, MSG_REQ_DMALLOC_MARK, NULL, 0);
}
/* Perform a dmalloc changed */
-static BOOL do_dmalloc_changed(struct messaging_context *msg_ctx,
+static bool do_dmalloc_changed(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx,
- pid, MSG_REQ_DMALLOC_LOG_CHANGED, NULL, 0, False);
+ return send_message(msg_ctx, pid, MSG_REQ_DMALLOC_LOG_CHANGED,
+ NULL, 0);
}
/* Shutdown a server process */
-static BOOL do_shutdown(struct messaging_context *msg_ctx,
+static bool do_shutdown(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx, pid, MSG_SHUTDOWN, NULL, 0, False);
+ return send_message(msg_ctx, pid, MSG_SHUTDOWN, NULL, 0);
}
/* Notify a driver upgrade */
-static BOOL do_drvupgrade(struct messaging_context *msg_ctx,
+static bool do_drvupgrade(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- return send_message(msg_ctx,
- pid, MSG_DEBUG, argv[1], strlen(argv[1]) + 1, False);
+ return send_message(msg_ctx, pid, MSG_DEBUG, argv[1],
+ strlen(argv[1]) + 1);
}
-static BOOL do_winbind_online(struct messaging_context *msg_ctx,
+static bool do_winbind_online(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- 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;
- }
-
/* Remove the entry in the winbindd_cache tdb to tell a later
starting winbindd that we're online. */
- tdb = tdb_open_log(lock_path("winbindd_cache.tdb"), 0, TDB_DEFAULT, O_RDWR, 0600);
+ tdb = tdb_open_log(cache_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"));
+ cache_path("winbindd_cache.tdb"));
return False;
}
tdb_delete_bystring(tdb, "WINBINDD_OFFLINE");
tdb_close(tdb);
- return send_message(msg_ctx, pid, MSG_WINBIND_ONLINE, NULL, 0, False);
+ return send_message(msg_ctx, pid, MSG_WINBIND_ONLINE, NULL, 0);
}
-static BOOL do_winbind_offline(struct messaging_context *msg_ctx,
+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;
+ bool ret = False;
int retry = 0;
if (argc != 1) {
return False;
}
- 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;
- }
-
/* Create an entry in the winbindd_cache tdb to tell a later
starting winbindd that we're offline. We may actually create
it here... */
- tdb = tdb_open_log(lock_path("winbindd_cache.tdb"),
+ tdb = tdb_open_log(cache_path("winbindd_cache.tdb"),
WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
- TDB_DEFAULT /* TDB_CLEAR_IF_FIRST */, O_RDWR|O_CREAT, 0600);
+ TDB_DEFAULT|TDB_INCOMPATIBLE_HASH /* TDB_CLEAR_IF_FIRST */,
+ O_RDWR|O_CREAT, 0600);
if (!tdb) {
fprintf(stderr, "Cannot open the tdb %s for writing.\n",
- lock_path("winbindd_cache.tdb"));
+ cache_path("winbindd_cache.tdb"));
return False;
}
tdb_store_bystring(tdb, "WINBINDD_OFFLINE", d, TDB_INSERT);
ret = send_message(msg_ctx, pid, MSG_WINBIND_OFFLINE,
- NULL, 0, False);
+ 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"));
return ret;
}
-static BOOL do_winbind_onlinestatus(struct messaging_context *msg_ctx,
+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;
- myid = pid_to_procid(sys_getpid());
+ myid = messaging_server_id(msg_ctx);
if (argc != 1) {
fprintf(stderr, "Usage: smbcontrol winbindd onlinestatus\n");
print_pid_string_cb);
if (!send_message(msg_ctx, pid, MSG_WINBIND_ONLINESTATUS, &myid,
- sizeof(myid), False))
+ sizeof(myid)))
return False;
wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
return num_replies;
}
+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;
+
+ myid = messaging_server_id(msg_ctx);
+
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol <dest> dump-event-list\n");
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_DUMP_EVENT_LIST, NULL, 0);
+}
+
+static bool do_winbind_dump_domain_list(struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ const char *domain = NULL;
+ int domain_len = 0;
+ struct server_id myid;
+ uint8_t *buf = NULL;
+ int buf_len = 0;
+
+ myid = messaging_server_id(msg_ctx);
+
+ if (argc < 1 || argc > 2) {
+ fprintf(stderr, "Usage: smbcontrol <dest> dump-domain-list "
+ "<domain>\n");
+ return false;
+ }
+
+ if (argc == 2) {
+ domain = argv[1];
+ domain_len = strlen(argv[1]) + 1;
+ }
+
+ messaging_register(msg_ctx, NULL, MSG_WINBIND_DUMP_DOMAIN_LIST,
+ print_pid_string_cb);
+
+ buf_len = sizeof(myid)+domain_len;
+ buf = SMB_MALLOC_ARRAY(uint8_t, buf_len);
+ if (!buf) {
+ return false;
+ }
+
+ memcpy(buf, &myid, sizeof(myid));
+ memcpy(&buf[sizeof(myid)], domain, domain_len);
+
+ if (!send_message(msg_ctx, pid, MSG_WINBIND_DUMP_DOMAIN_LIST,
+ buf, buf_len))
+ {
+ SAFE_FREE(buf);
+ return false;
+ }
+
+ wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+
+ /* No replies were received within the timeout period */
+
+ SAFE_FREE(buf);
+ if (num_replies == 0) {
+ printf("No replies received\n");
+ }
+
+ messaging_deregister(msg_ctx, MSG_WINBIND_DUMP_DOMAIN_LIST, NULL);
+
+ return num_replies;
+}
-static BOOL do_reload_config(struct messaging_context *msg_ctx,
+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 = server_id_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++;
+}
+
+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;
+
+ myid = messaging_server_id(msg_ctx);
+
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol winbindd validate-cache\n");
+ return False;
+ }
+
+ messaging_register(msg_ctx, NULL, MSG_WINBIND_VALIDATE_CACHE,
+ winbind_validate_cache_cb);
+
+ 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)
{
return False;
}
- return send_message(msg_ctx, pid, MSG_SMB_CONF_UPDATED,
- NULL, 0, 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)
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);
+ push_ascii(n->scope, lp_netbios_scope(), 64, STR_TERMINATE);
}
-static BOOL do_nodestatus(struct messaging_context *msg_ctx,
+static bool do_nodestatus(struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
ZERO_STRUCT(p);
- p.ip = *interpret_addr2(argv[1]);
+ p.ip = interpret_addr2(argv[1]);
p.port = 137;
p.packet_type = NMB_PACKET;
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),
- False);
+ 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,
+ 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" },
+ { "idmap", do_idmap, "Manipulate idmap cache" },
{ "force-election", do_election,
"Force a browse election" },
{ "ping", do_ping, "Elicit a response" },
{ "debuglevel", do_debuglevel, "Display current debuglevels" },
{ "printnotify", do_printnotify, "Send a print notify message" },
{ "close-share", do_closeshare, "Forcibly disconnect a share" },
+ { "ip-dropped", do_ip_dropped, "Tell winbind that an IP got dropped" },
+ { "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" },
{ "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" },
+ { "dump-domain-list", do_winbind_dump_domain_list, "Dump winbind domain list"},
{ "noop", do_noop, "Do nothing" },
{ NULL }
};
/* Display usage information */
-static void usage(poptContext *pc)
+static void usage(poptContext pc)
{
int i;
- poptPrintHelp(*pc, stderr, 0);
+ poptPrintHelp(pc, stderr, 0);
fprintf(stderr, "\n");
fprintf(stderr, "<destination> is one of \"nmbd\", \"smbd\", \"winbindd\" or a "
/* Return the pid number for a string destination */
-static struct server_id parse_dest(const char *dest)
+static struct server_id parse_dest(struct messaging_context *msg,
+ const char *dest)
{
struct server_id result = {-1};
pid_t pid;
- /* Zero is a special return value for broadcast smbd */
+ /* Zero is a special return value for broadcast to all processes */
- if (strequal(dest, "smbd")) {
- return interpret_pid("0");
+ if (strequal(dest, "all")) {
+ return interpret_pid(MSG_BROADCAST_PID_STR);
}
/* Try self - useful for testing */
if (strequal(dest, "self")) {
- return pid_to_procid(sys_getpid());
+ return messaging_server_id(msg);
}
/* Fix winbind typo. */
dest = "winbindd";
}
-
- if (!(strequal(dest, "winbindd") || strequal(dest, "nmbd"))) {
- /* Check for numeric pid number */
-
- result = interpret_pid(dest);
+ /* Check for numeric pid number */
+ result = interpret_pid(dest);
- /* Zero isn't valid if not smbd. */
- if (result.pid && procid_valid(&result)) {
- return result;
- }
+ /* Zero isn't valid if not "all". */
+ if (result.pid && procid_valid(&result)) {
+ return result;
}
/* Look up other destinations in pidfile directory */
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,
+static bool do_command(struct messaging_context *msg_ctx,
int argc, const char **argv)
{
const char *dest = argv[0], *command = argv[1];
/* Check destination */
- pid = parse_dest(dest);
+ pid = parse_dest(msg_ctx, dest);
if (!procid_valid(&pid)) {
return False;
}
return False;
}
+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;
- struct event_context *evt_ctx;
+ struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
static struct poptOption long_options[] = {
- POPT_AUTOHELP
+ /* 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" },
POPT_COMMON_SAMBA
POPT_TABLEEND
};
+ TALLOC_CTX *frame = talloc_stackframe();
+ int ret = 0;
load_case_tables();
- setup_logging(argv[0],True);
-
+ setup_logging(argv[0], DEBUG_STDOUT);
+
/* Parse command line arguments using popt */
pc = poptGetContext(
"<parameters>");
if (argc == 1)
- usage(&pc);
+ usage(pc);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
argv = (const char **)poptGetArgs(pc);
argc = 0;
- while (argv[argc] != NULL) {
- argc++;
+ if (argv != NULL) {
+ while (argv[argc] != NULL) {
+ argc++;
+ }
}
- if (argc == 1)
- usage(&pc);
+ if (argc <= 1)
+ usage(pc);
- lp_load(dyn_CONFIGFILE,False,False,False,True);
+ lp_load_global(get_dyn_CONFIGFILE());
/* 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))) {
+
+ if (!(evt_ctx = tevent_context_init(NULL)) ||
+ !(msg_ctx = messaging_init(NULL, procid_self(), evt_ctx))) {
fprintf(stderr, "could not init messaging context\n");
+ TALLOC_FREE(frame);
exit(1);
}
-
- return !do_command(msg_ctx, argc, argv);
+
+ ret = !do_command(msg_ctx, argc, argv);
+ TALLOC_FREE(frame);
+ return ret;
}
git.samba.org / idra / samba.git / blobdiff