-/*
+/*
Unix SMB/CIFS implementation.
Send messages to other Samba daemons
#include "libsmb/nmblib.h"
#include "messages.h"
#include "util_tdb.h"
+#include "../lib/util/pidfile.h"
#if HAVE_LIBUNWIND_H
#include <libunwind.h>
/* Wait for one or more reply messages */
-static void wait_replies(struct messaging_context *msg_ctx,
+static void wait_replies(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
bool multiple_replies)
{
struct tevent_timer *te;
bool timed_out = False;
- if (!(te = tevent_add_timer(messaging_event_context(msg_ctx), NULL,
- timeval_current_ofs(timeout, 0),
- smbcontrol_timeout, (void *)&timed_out))) {
+ te = tevent_add_timer(ev_ctx, NULL,
+ timeval_current_ofs(timeout, 0),
+ smbcontrol_timeout, (void *)&timed_out);
+ if (te == NULL) {
DEBUG(0, ("tevent_add_timer failed\n"));
return;
}
int ret;
if (num_replies > 0 && !multiple_replies)
break;
- ret = tevent_loop_once(messaging_event_context(msg_ctx));
+ ret = tevent_loop_once(ev_ctx);
if (ret != 0) {
break;
}
/* Send no message. Useful for testing. */
-static bool do_noop(struct messaging_context *msg_ctx,
+static bool do_noop(struct tevent_context *ev_ctx,
+ 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 tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
}
-static bool do_idmap(struct messaging_context *msg_ctx,
+static bool do_idmap(struct tevent_context *ev,
+ 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"
+ "\tcmd:"
+ "\tdelete \"UID <uid>\"|\"GID <gid>\"|<sid>\n"
"\t\tkill \"UID <uid>\"|\"GID <gid>\"|<sid>\n";
const char* arg = NULL;
int arglen = 0;
return false;
}
- if (strcmp(argv[1], "flush") == 0) {
- msg_type = MSG_IDMAP_FLUSH;
- }
- else if (strcmp(argv[1], "delete") == 0) {
- msg_type = MSG_IDMAP_DELETE;
+ if (strcmp(argv[1], "delete") == 0) {
+ msg_type = ID_CACHE_DELETE;
}
else if (strcmp(argv[1], "kill") == 0) {
- msg_type = MSG_IDMAP_KILL;
+ msg_type = ID_CACHE_KILL;
}
else if (strcmp(argv[1], "help") == 0) {
fprintf(stdout, "%s", usage);
ptrace(PTRACE_DETACH, pid, NULL, NULL);
}
-static int stack_trace_connection(const struct connections_key *key,
- const struct connections_data *crec,
- void *priv)
+static int stack_trace_server(const struct server_id *id,
+ uint32_t msg_flags,
+ void *priv)
{
- print_stack_trace(procid_to_pid(&crec->pid), (int *)priv);
-
+ if (id->vnn == get_my_vnn()) {
+ print_stack_trace(procid_to_pid(&id->pid), (int *)priv);
+ }
return 0;
}
-static bool do_daemon_stack_trace(struct messaging_context *msg_ctx,
+static bool do_daemon_stack_trace(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
- const int argc, const char **argv)
+ const int argc, const char **argv)
{
pid_t dest;
int count = 0;
*/
print_stack_trace(dest, &count);
} else {
- connections_forall_read(stack_trace_connection, &count);
+ serverid_traverse_read(stack_trace_server, &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 tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
- const int argc, const char **argv)
+ const int argc, const char **argv)
{
fprintf(stderr,
"Daemon stack tracing is not supported on this platform\n");
/* 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 tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
- const int argc, const char **argv)
+ const int argc, const char **argv)
{
if (argc != 2) {
fprintf(stderr, "Usage: smbcontrol <dest> inject "
/* Force a browser election */
-static bool do_election(struct messaging_context *msg_ctx,
+static bool do_election(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
num_replies++;
}
-static bool do_ping(struct messaging_context *msg_ctx,
+static bool do_ping(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
messaging_register(msg_ctx, NULL, MSG_PONG, pong_cb);
- wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+ wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
/* No replies were received within the timeout period */
/* Set profiling options */
-static bool do_profile(struct messaging_context *msg_ctx,
+static bool do_profile(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
send_message(msg_ctx, pid, MSG_PROFILELEVEL, &v, sizeof(int));
}
-static bool do_profilelevel(struct messaging_context *msg_ctx,
+static bool do_profilelevel(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
messaging_register(msg_ctx, NULL, MSG_REQ_PROFILELEVEL,
profilelevel_rqst);
- wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+ wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
/* No replies were received within the timeout period */
/* Display debug level settings */
-static bool do_debuglevel(struct messaging_context *msg_ctx,
+static bool do_debuglevel(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
messaging_register(msg_ctx, NULL, MSG_DEBUGLEVEL, print_pid_string_cb);
- wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+ wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
/* No replies were received within the timeout period */
/* Send a print notify message */
-static bool do_printnotify(struct messaging_context *msg_ctx,
+static bool do_printnotify(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- notify_printer_status_byname(messaging_event_context(msg_ctx),
- msg_ctx, argv[2],
+ notify_printer_status_byname(ev_ctx, msg_ctx, argv[2],
PRINTER_STATUS_PAUSED);
goto send;
return False;
}
- notify_printer_status_byname(messaging_event_context(msg_ctx),
- msg_ctx, argv[2],
+ notify_printer_status_byname(ev_ctx, msg_ctx, argv[2],
PRINTER_STATUS_OK);
goto send;
jobid = atoi(argv[3]);
notify_job_status_byname(
- messaging_event_context(msg_ctx), msg_ctx,
+ ev_ctx, msg_ctx,
argv[2], jobid, JOB_STATUS_PAUSED,
SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
jobid = atoi(argv[3]);
notify_job_status_byname(
- messaging_event_context(msg_ctx), msg_ctx,
+ ev_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,
+ ev_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,
+ ev_ctx, msg_ctx,
argv[2], jobid, JOB_STATUS_DELETING|
JOB_STATUS_DELETED,
SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
return False;
}
- notify_printer_byname(messaging_event_context(msg_ctx),
- msg_ctx, argv[2], attribute,
+ notify_printer_byname(ev_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 tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Tell winbindd an IP got dropped */
-static bool do_ip_dropped(struct messaging_context *msg_ctx,
+static bool do_ip_dropped(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* force a blocking lock retry */
-static bool do_lockretry(struct messaging_context *msg_ctx,
+static bool do_lockretry(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* force a validation of all brl entries, including re-sends. */
-static bool do_brl_revalidate(struct messaging_context *msg_ctx,
+static bool do_brl_revalidate(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
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,
- const struct server_id pid,
- const int argc, const char **argv)
-{
- if (argc != 1) {
- fprintf(stderr, "Usage: smbcontrol <dest> samsync\n");
- return 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,
- const struct server_id pid,
- const int argc, const char **argv)
-{
- if (argc != 1) {
- fprintf(stderr, "Usage: smbcontrol <dest> samrepl\n");
- 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,
+static bool do_poolusage(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
if (!send_message(msg_ctx, pid, MSG_REQ_POOL_USAGE, NULL, 0))
return False;
- wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+ wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
/* No replies were received within the timeout period */
/* Perform a dmalloc mark */
-static bool do_dmalloc_mark(struct messaging_context *msg_ctx,
+static bool do_dmalloc_mark(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Perform a dmalloc changed */
-static bool do_dmalloc_changed(struct messaging_context *msg_ctx,
+static bool do_dmalloc_changed(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Shutdown a server process */
-static bool do_shutdown(struct messaging_context *msg_ctx,
+static bool do_shutdown(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* Notify a driver upgrade */
-static bool do_drvupgrade(struct messaging_context *msg_ctx,
+static bool do_drvupgrade(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
strlen(argv[1]) + 1);
}
-static bool do_winbind_online(struct messaging_context *msg_ctx,
+static bool do_winbind_online(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
- const int argc, const char **argv)
+ const int argc, const char **argv)
{
TDB_CONTEXT *tdb;
/* Remove the entry in the winbindd_cache tdb to tell a later
starting winbindd that we're online. */
- tdb = tdb_open_log(cache_path("winbindd_cache.tdb"), 0, TDB_DEFAULT, O_RDWR, 0600);
+ tdb = tdb_open_log(state_path("winbindd_cache.tdb"), 0, TDB_DEFAULT, O_RDWR, 0600);
if (!tdb) {
fprintf(stderr, "Cannot open the tdb %s for writing.\n",
- cache_path("winbindd_cache.tdb"));
+ state_path("winbindd_cache.tdb"));
return 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 tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
- const int argc, const char **argv)
+ const int argc, const char **argv)
{
TDB_CONTEXT *tdb;
bool ret = False;
starting winbindd that we're offline. We may actually create
it here... */
- tdb = tdb_open_log(cache_path("winbindd_cache.tdb"),
+ tdb = tdb_open_log(state_path("winbindd_cache.tdb"),
WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
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",
- cache_path("winbindd_cache.tdb"));
+ state_path("winbindd_cache.tdb"));
return False;
}
return ret;
}
-static bool do_winbind_onlinestatus(struct messaging_context *msg_ctx,
+static bool do_winbind_onlinestatus(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
sizeof(myid)))
return False;
- wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+ wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
/* No replies were received within the timeout period */
return num_replies;
}
-static bool do_dump_event_list(struct messaging_context *msg_ctx,
+static bool do_dump_event_list(struct tevent_context *ev_ctx,
+ 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,
+static bool do_winbind_dump_domain_list(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return false;
}
- wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+ wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
/* No replies were received within the timeout period */
num_replies++;
}
-static bool do_winbind_validate_cache(struct messaging_context *msg_ctx,
+static bool do_winbind_validate_cache(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return False;
}
- wait_replies(msg_ctx, procid_to_pid(&pid) == 0);
+ wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
if (num_replies == 0) {
printf("No replies received\n");
return num_replies;
}
-static bool do_reload_config(struct messaging_context *msg_ctx,
+static bool do_reload_config(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return send_message(msg_ctx, pid, MSG_SMB_CONF_UPDATED, NULL, 0);
}
+static bool do_reload_printers(struct tevent_context *ev_ctx,
+ 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-printers\n");
+ return False;
+ }
+
+ return send_message(msg_ctx, pid, MSG_PRINTER_PCAP, 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);
+ (void)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, lp_netbios_scope(), 64, STR_TERMINATE);
}
-static bool do_nodestatus(struct messaging_context *msg_ctx,
+static bool do_nodestatus(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
return send_message(msg_ctx, pid, MSG_SEND_PACKET, &p, sizeof(p));
}
+static bool do_notify_cleanup(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
+ const struct server_id pid,
+ const int argc, const char **argv)
+{
+ if (argc != 1) {
+ fprintf(stderr, "Usage: smbcontrol smbd notify-cleanup\n");
+ return false;
+ }
+ return send_message(msg_ctx, pid, MSG_SMB_NOTIFY_CLEANUP, NULL, 0);
+}
+
/* A list of message type supported */
static const struct {
const char *name; /* Option name */
- bool (*fn)(struct messaging_context *msg_ctx,
+ bool (*fn)(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv);
const char *help; /* Short help text */
{ "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" },
{ "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"},
+ { "reload-printers", do_reload_printers, "Force smbd to reload printers"},
{ "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"},
{ "validate-cache" , do_winbind_validate_cache,
"Validate winbind's credential cache" },
{ "dump-domain-list", do_winbind_dump_domain_list, "Dump winbind domain list"},
+ { "notify-cleanup", do_notify_cleanup },
{ "noop", do_noop, "Do nothing" },
{ NULL }
};
/* Look up other destinations in pidfile directory */
- if ((pid = pidfile_pid(dest)) != 0) {
+ if ((pid = pidfile_pid(lp_piddir(), dest)) != 0) {
return pid_to_procid(pid);
}
/* Execute smbcontrol command */
-static bool do_command(struct messaging_context *msg_ctx,
+static bool do_command(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
int argc, const char **argv)
{
const char *dest = argv[0], *command = argv[1];
for (i = 0; msg_types[i].name; i++) {
if (strequal(command, msg_types[i].name))
- return msg_types[i].fn(msg_ctx, pid,
+ return msg_types[i].fn(ev_ctx, msg_ctx, pid,
argc - 1, argv + 1);
}
if (argc <= 1)
usage(pc);
- lp_load(get_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 = tevent_context_init(NULL)) ||
- !(msg_ctx = messaging_init(NULL, procid_self(), evt_ctx))) {
+ !(msg_ctx = messaging_init(NULL, evt_ctx))) {
fprintf(stderr, "could not init messaging context\n");
TALLOC_FREE(frame);
exit(1);
}
- ret = !do_command(msg_ctx, argc, argv);
+ ret = !do_command(evt_ctx, msg_ctx, argc, argv);
TALLOC_FREE(frame);
return ret;
}
git.samba.org / kai / samba.git / blobdiff