This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
+#include "librpc/gen_ndr/messaging.h"
+#include "librpc/gen_ndr/spoolss.h"
+#include "nt_printing.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 ret;
+ bool ret;
int n_sent = 0;
if (procid_to_pid(&pid) != 0)
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(msg_ctx);
- 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 = procid_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)
{
ptrace(PTRACE_DETACH, pid, NULL, NULL);
}
-static int stack_trace_connection(struct db_record *rec,
- const struct connections_key *key,
+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_forall(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)
{
/* 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)
{
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)
{
/* 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)
{
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)
{
/* 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 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)
{
}
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]);
/* 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)
{
/* force a blocking lock retry */
-static BOOL do_lockretry(struct messaging_context *msg_ctx,
+static bool do_lockretry(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 messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
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;
}
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);
if (!tdb) {
fprintf(stderr, "Cannot open the tdb %s for writing.\n",
- lock_path("winbindd_cache.tdb"));
+ cache_path("winbindd_cache.tdb"));
return False;
}
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 = procid_self();
if (argc != 1) {
fprintf(stderr, "Usage: smbcontrol winbindd onlinestatus\n");
return num_replies;
}
-static BOOL do_dump_event_list(struct messaging_context *msg_ctx,
+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 = pid_to_procid(sys_getpid());
+ myid = procid_self();
if (argc != 1) {
fprintf(stderr, "Usage: smbcontrol <dest> dump-event-list\n");
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 = procid_self();
+
+ 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;
+ }
-static BOOL do_reload_config(struct messaging_context *msg_ctx,
+ 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 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++;
+}
+
+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 = procid_self();
+
+ 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)
{
push_ascii(n->scope, global_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;
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 */
{ "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 }
};
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 procid_self();
}
/* Fix winbind typo. */
dest = "winbindd";
}
-
- if (!(strequal(dest, "winbindd") || strequal(dest, "nmbd"))) {
- /* Check for numeric pid number */
+ /* Check for numeric pid number */
+ result = interpret_pid(dest);
- 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];
{
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_COMMON_SAMBA
POPT_TABLEEND
};
+ TALLOC_CTX *frame = talloc_stackframe();
+ int ret = 0;
load_case_tables();
argv = (const char **)poptGetArgs(pc);
argc = 0;
- while (argv[argc] != NULL) {
- argc++;
+ if (argv != NULL) {
+ while (argv[argc] != NULL) {
+ argc++;
+ }
}
- if (argc == 1)
+ if (argc <= 1)
usage(pc);
- lp_load(dyn_CONFIGFILE,False,False,False,True);
+ lp_load(get_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))) {
+ 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;
}