*/
#include "includes.h"
+#include "system/filesys.h"
#include "popt_common.h"
+#include "smbd/smbd.h"
#include "smbd/globals.h"
-#include "librpc/gen_ndr/messaging.h"
-#include "registry.h"
+#include "registry/reg_init_full.h"
#include "libcli/auth/schannel.h"
#include "secrets.h"
#include "memcache.h"
#include "ctdbd_conn.h"
-
-#include "../librpc/gen_ndr/srv_dfs.h"
-#include "../librpc/gen_ndr/srv_dssetup.h"
-#include "../librpc/gen_ndr/srv_echo.h"
-#include "../librpc/gen_ndr/srv_eventlog.h"
-#include "../librpc/gen_ndr/srv_initshutdown.h"
-#include "../librpc/gen_ndr/srv_lsa.h"
-#include "../librpc/gen_ndr/srv_netlogon.h"
-#include "../librpc/gen_ndr/srv_ntsvcs.h"
-#include "../librpc/gen_ndr/srv_samr.h"
-#include "../librpc/gen_ndr/srv_spoolss.h"
-#include "../librpc/gen_ndr/srv_srvsvc.h"
-#include "../librpc/gen_ndr/srv_svcctl.h"
-#include "../librpc/gen_ndr/srv_winreg.h"
-#include "../librpc/gen_ndr/srv_wkssvc.h"
-
-#include "printing/nt_printing_migrate.h"
-
-static_decl_rpc;
+#include "printing/queue_process.h"
+#include "rpc_server/rpc_service_setup.h"
+#include "rpc_server/rpc_config.h"
+#include "serverid.h"
+#include "passdb.h"
+#include "auth.h"
+#include "messages.h"
+#include "smbprofile.h"
+#include "lib/id_cache.h"
+
+extern void start_epmd(struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx);
+
+extern void start_lsasd(struct event_context *ev_ctx,
+ struct messaging_context *msg_ctx);
#ifdef WITH_DFS
extern int dcelogin_atmost_once;
#endif /* WITH_DFS */
-static void smbd_set_server_fd(int fd)
-{
- struct smbd_server_connection *sconn = smbd_server_conn;
- char addr[INET6_ADDRSTRLEN];
- const char *name;
-
- sconn->sock = fd;
-
- /*
- * Initialize sconn->client_id: If we can't find the client's
- * name, default to its address.
- */
-
- client_addr(fd, sconn->client_id.addr, sizeof(sconn->client_id.addr));
-
- name = client_name(sconn->sock);
- if (strcmp(name, "UNKNOWN") != 0) {
- name = talloc_strdup(sconn, name);
- } else {
- name = NULL;
- }
- sconn->client_id.name =
- (name != NULL) ? name : sconn->client_id.addr;
-
- sub_set_socket_ids(sconn->client_id.addr, sconn->client_id.name,
- client_socket_addr(sconn->sock, addr,
- sizeof(addr)));
-}
-
-struct event_context *smbd_event_context(void)
-{
- return server_event_context();
-}
-
/*******************************************************************
What to do when smb.conf is updated.
********************************************************************/
struct server_id server_id,
DATA_BLOB *data)
{
+ struct tevent_context *ev_ctx =
+ talloc_get_type_abort(private_data, struct tevent_context);
+
DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
"updated. Reloading.\n"));
change_to_root_user();
reload_services(msg, smbd_server_conn->sock, False);
+ if (am_parent) {
+ printing_subsystem_update(ev_ctx, msg, false);
+ }
}
+/*******************************************************************
+ What to do when printcap is updated.
+ ********************************************************************/
+
+static void smb_pcap_updated(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
+{
+ struct tevent_context *ev_ctx =
+ talloc_get_type_abort(private_data, struct tevent_context);
+
+ DEBUG(10,("Got message saying pcap was updated. Reloading.\n"));
+ change_to_root_user();
+ reload_printers(ev_ctx, msg);
+}
/*******************************************************************
Delete a statcache entry.
(*cleanup_te) = NULL;
}
-static void remove_child_pid(pid_t pid, bool unclean_shutdown)
+static void remove_child_pid(struct tevent_context *ev_ctx,
+ pid_t pid,
+ bool unclean_shutdown)
{
struct child_pid *child;
static struct timed_event *cleanup_te;
if (!cleanup_te) {
/* call the cleanup timer, but not too often */
int cleanup_time = lp_parm_int(-1, "smbd", "cleanuptime", 20);
- cleanup_te = event_add_timed(smbd_event_context(), NULL,
+ cleanup_te = event_add_timed(ev_ctx, NULL,
timeval_current_ofs(cleanup_time, 0),
cleanup_timeout_fn,
&cleanup_te);
}
}
- DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid));
+ /* not all forked child processes are added to the children list */
+ DEBUG(1, ("Could not find child %d -- ignoring\n", (int)pid));
}
/****************************************************************************
if (WIFSIGNALED(status)) {
unclean_shutdown = True;
}
- remove_child_pid(pid, unclean_shutdown);
+ remove_child_pid(ev, pid, unclean_shutdown);
}
}
-static void smbd_setup_sig_chld_handler(void)
+static void smbd_setup_sig_chld_handler(struct tevent_context *ev_ctx)
{
struct tevent_signal *se;
- se = tevent_add_signal(smbd_event_context(),
- smbd_event_context(),
+ se = tevent_add_signal(ev_ctx,
+ ev_ctx, /* mem_ctx */
SIGCHLD, 0,
smbd_sig_chld_handler,
NULL);
struct smbd_parent_context *parent;
int fd;
struct tevent_fd *fde;
+ struct messaging_context *msg_ctx;
};
static void smbd_open_socket_close_fn(struct tevent_context *ev,
uint16_t flags,
void *private_data)
{
+ struct smbd_server_connection *sconn = smbd_server_conn;
struct smbd_open_socket *s = talloc_get_type_abort(private_data,
struct smbd_open_socket);
+ struct messaging_context *msg_ctx = s->msg_ctx;
struct sockaddr_storage addr;
socklen_t in_addrlen = sizeof(addr);
int fd;
uint64_t unique_id;
fd = accept(s->fd, (struct sockaddr *)(void *)&addr,&in_addrlen);
- smbd_set_server_fd(fd);
-
+ sconn->sock = fd;
if (fd == -1 && errno == EINTR)
return;
}
if (s->parent->interactive) {
- smbd_process(smbd_server_conn);
+ smbd_process(ev, sconn);
exit_server_cleanly("end of interactive mode");
return;
}
if (!allowable_number_of_smbd_processes()) {
close(fd);
- smbd_set_server_fd(-1);
+ sconn->sock = -1;
return;
}
/* close our standard file
descriptors */
- close_low_fds(False);
+ if (!debug_get_output_is_stdout()) {
+ close_low_fds(False); /* Don't close stderr */
+ }
/*
* Can't use TALLOC_FREE here. Nulling out the argument to it
talloc_free(s->parent);
s = NULL;
- status = reinit_after_fork(smbd_messaging_context(),
- smbd_event_context(), procid_self(),
+ status = reinit_after_fork(msg_ctx,
+ ev,
+ procid_self(),
true);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,
"because too many files are open\n"));
goto exit;
}
+ if (lp_clustering() &&
+ NT_STATUS_EQUAL(status,
+ NT_STATUS_INTERNAL_DB_ERROR)) {
+ DEBUG(1,("child process cannot initialize "
+ "because connection to CTDB "
+ "has failed\n"));
+ goto exit;
+ }
+
DEBUG(0,("reinit_after_fork() failed\n"));
smb_panic("reinit_after_fork() failed");
}
smbd_setup_sig_term_handler();
- smbd_setup_sig_hup_handler(server_event_context(),
- server_messaging_context());
+ smbd_setup_sig_hup_handler(ev,
+ msg_ctx);
if (!serverid_register(procid_self(),
FLAG_MSG_GENERAL|FLAG_MSG_SMBD
"serverid.tdb");
}
- smbd_process(smbd_server_conn);
+ smbd_process(ev, smbd_server_conn);
exit:
exit_server_cleanly("end of child");
return;
getpeername failure if we reopen the logs
and use %I in the filename.
*/
-
- smbd_set_server_fd(-1);
+ sconn->sock = -1;
if (pid != 0) {
add_child_pid(pid);
}
static bool smbd_open_one_socket(struct smbd_parent_context *parent,
+ struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const struct sockaddr_storage *ifss,
uint16_t port)
{
return false;
}
- s->fde = tevent_add_fd(smbd_event_context(),
+ s->msg_ctx = msg_ctx;
+ s->fde = tevent_add_fd(ev_ctx,
s,
s->fd, TEVENT_FD_READ,
smbd_accept_connection,
****************************************************************************/
static bool open_sockets_smbd(struct smbd_parent_context *parent,
+ struct tevent_context *ev_ctx,
+ struct messaging_context *msg_ctx,
const char *smb_ports)
{
int num_interfaces = iface_count();
int i;
- char *ports;
+ const char *ports;
unsigned dns_port = 0;
#ifdef HAVE_ATEXIT
#endif
/* Stop zombies */
- smbd_setup_sig_chld_handler();
+ smbd_setup_sig_chld_handler(ev_ctx);
/* use a reasonable default set of ports - listing on 445 and 139 */
if (!smb_ports) {
continue;
}
- if (!smbd_open_one_socket(parent, ifss, port)) {
+ /* Keep the first port for mDNS service
+ * registration.
+ */
+ if (dns_port == 0) {
+ dns_port = port;
+ }
+
+ if (!smbd_open_one_socket(parent,
+ ev_ctx,
+ msg_ctx,
+ ifss,
+ port)) {
return false;
}
}
continue;
}
- if (!smbd_open_one_socket(parent, &ss, port)) {
+ if (!smbd_open_one_socket(parent,
+ ev_ctx,
+ msg_ctx,
+ &ss,
+ port)) {
return false;
}
}
/* Listen to messages */
- messaging_register(smbd_messaging_context(), NULL,
- MSG_SMB_SAM_SYNC, msg_sam_sync);
- messaging_register(smbd_messaging_context(), NULL,
- MSG_SHUTDOWN, msg_exit_server);
- messaging_register(smbd_messaging_context(), NULL,
- MSG_SMB_FILE_RENAME, msg_file_was_renamed);
- messaging_register(smbd_messaging_context(), NULL,
- MSG_SMB_CONF_UPDATED, smb_conf_updated);
- messaging_register(smbd_messaging_context(), NULL,
- MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
- messaging_register(smbd_messaging_context(), NULL,
- MSG_DEBUG, smbd_msg_debug);
- brl_register_msgs(smbd_messaging_context());
+ messaging_register(msg_ctx, NULL, MSG_SMB_SAM_SYNC, msg_sam_sync);
+ messaging_register(msg_ctx, NULL, MSG_SHUTDOWN, msg_exit_server);
+ messaging_register(msg_ctx, NULL, MSG_SMB_FILE_RENAME,
+ msg_file_was_renamed);
+ messaging_register(msg_ctx, ev_ctx, MSG_SMB_CONF_UPDATED,
+ smb_conf_updated);
+ messaging_register(msg_ctx, NULL, MSG_SMB_STAT_CACHE_DELETE,
+ smb_stat_cache_delete);
+ messaging_register(msg_ctx, NULL, MSG_DEBUG, smbd_msg_debug);
+ messaging_register(msg_ctx, ev_ctx, MSG_PRINTER_PCAP,
+ smb_pcap_updated);
+ brl_register_msgs(msg_ctx);
+
+ id_cache_register_msgs(msg_ctx);
+ id_cache_register_kill_msg(msg_ctx);
#ifdef CLUSTER_SUPPORT
if (lp_clustering()) {
#endif
#ifdef DEVELOPER
- messaging_register(smbd_messaging_context(), NULL,
- MSG_SMB_INJECT_FAULT, msg_inject_fault);
+ messaging_register(msg_ctx, NULL, MSG_SMB_INJECT_FAULT,
+ msg_inject_fault);
#endif
- if (dns_port != 0) {
+ if (lp_multicast_dns_register() && (dns_port != 0)) {
#ifdef WITH_DNSSD_SUPPORT
- smbd_setup_mdns_registration(smbd_event_context(),
+ smbd_setup_mdns_registration(ev_ctx,
parent, dns_port);
#endif
#ifdef WITH_AVAHI_SUPPORT
void *avahi_conn;
- avahi_conn = avahi_start_register(
- smbd_event_context(), smbd_event_context(), dns_port);
+ avahi_conn = avahi_start_register(ev_ctx,
+ ev_ctx,
+ dns_port);
if (avahi_conn == NULL) {
DEBUG(10, ("avahi_start_register failed\n"));
}
return true;
}
-static void smbd_parent_loop(struct smbd_parent_context *parent)
+static void smbd_parent_loop(struct tevent_context *ev_ctx,
+ struct smbd_parent_context *parent)
{
/* now accept incoming connections - forking a new process
for each incoming connection */
int ret;
TALLOC_CTX *frame = talloc_stackframe();
- ret = tevent_loop_once(smbd_event_context());
+ ret = tevent_loop_once(ev_ctx);
if (ret != 0) {
exit_server_cleanly("tevent_loop_once() error");
}
if (!init_names())
return False;
- file_init();
-
if (!secrets_init())
return False;
return True;
}
-static bool spoolss_init_cb(void *ptr)
-{
- struct messaging_context *msg_ctx = talloc_get_type_abort(
- ptr, struct messaging_context);
- return nt_printing_tdb_migrate(msg_ctx);
-}
-
-static bool spoolss_shutdown_cb(void *ptr)
-{
- srv_spoolss_cleanup();
-
- return true;
-}
-
/****************************************************************************
main program.
****************************************************************************/
POPT_TABLEEND
};
struct smbd_parent_context *parent = NULL;
- TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
+ TALLOC_CTX *frame;
NTSTATUS status;
uint64_t unique_id;
- struct rpc_srv_callbacks spoolss_cb;
+ struct tevent_context *ev_ctx;
+ struct messaging_context *msg_ctx;
+
+ /*
+ * Do this before any other talloc operation
+ */
+ talloc_enable_null_tracking();
+ frame = talloc_stackframe();
+
+ setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
- /* Initialize the event context, it will panic on error */
- smbd_event_context();
+ load_case_tables();
smbd_init_globals();
log_stdout = True;
}
- setup_logging(argv[0],log_stdout);
+ if (log_stdout) {
+ setup_logging(argv[0], DEBUG_STDOUT);
+ } else {
+ setup_logging(argv[0], DEBUG_FILE);
+ }
if (print_build_options) {
build_options(True); /* Display output to screen as well as debug */
exit(0);
}
- load_case_tables();
-
#ifdef HAVE_SETLUID
/* needed for SecureWare on SCO */
setluid(0);
gain_root_privilege();
gain_root_group_privilege();
- fault_setup((void (*)(void *))exit_server_fault);
- dump_core_setup("smbd");
+ fault_setup();
+ dump_core_setup("smbd", lp_logfile());
/* we are never interested in SIGPIPE */
BlockSignals(True,SIGPIPE);
}
if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
- DEBUG(0, ("error opening config file\n"));
+ DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
exit(1);
}
/* Init the security context and global current_user */
init_sec_ctx();
- if (smbd_messaging_context() == NULL)
+ /*
+ * Initialize the event context. The event context needs to be
+ * initialized before the messaging context, cause the messaging
+ * context holds an event context.
+ * FIXME: This should be s3_tevent_context_init()
+ */
+ ev_ctx = server_event_context();
+ if (ev_ctx == NULL) {
+ exit(1);
+ }
+
+ /*
+ * Init the messaging context
+ * FIXME: This should only call messaging_init()
+ */
+ msg_ctx = server_messaging_context();
+ if (msg_ctx == NULL) {
exit(1);
+ }
/*
* Reloading of the printers will not work here as we don't have a
* server info and rpc services set up. It will be called later.
*/
- if (!reload_services(smbd_messaging_context(), -1, False)) {
+ if (!reload_services(NULL, -1, False)) {
exit(1);
}
init_structs();
#ifdef WITH_PROFILE
- if (!profile_setup(smbd_messaging_context(), False)) {
+ if (!profile_setup(msg_ctx, False)) {
DEBUG(0,("ERROR: failed to setup profiling\n"));
return -1;
}
if (is_daemon)
pidfile_create("smbd");
- status = reinit_after_fork(smbd_messaging_context(),
- smbd_event_context(),
+ status = reinit_after_fork(msg_ctx,
+ ev_ctx,
procid_self(), false);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("reinit_after_fork() failed\n"));
exit(1);
}
- smbd_server_conn->msg_ctx = smbd_messaging_context();
+ smbd_server_conn->msg_ctx = msg_ctx;
smbd_setup_sig_term_handler();
- smbd_setup_sig_hup_handler(smbd_event_context(),
- smbd_server_conn->msg_ctx);
+ smbd_setup_sig_hup_handler(ev_ctx,
+ msg_ctx);
/* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
/* Initialise the password backed before the global_sam_sid
to ensure that we fetch from ldap before we make a domain sid up */
- if(!initialize_password_db(False, smbd_event_context()))
+ if(!initialize_password_db(false, ev_ctx))
exit(1);
if (!secrets_init()) {
if (!locking_init())
exit(1);
- if (!messaging_tdb_parent_init()) {
+ if (!messaging_tdb_parent_init(ev_ctx)) {
exit(1);
}
- if (!notify_internal_parent_init()) {
+ if (!notify_internal_parent_init(ev_ctx)) {
exit(1);
}
- if (!serverid_parent_init()) {
+ if (!serverid_parent_init(ev_ctx)) {
exit(1);
}
if (!W_ERROR_IS_OK(registry_init_full()))
exit(1);
- if (!print_backend_init(smbd_messaging_context()))
- exit(1);
-
-#if 0
- if (!init_svcctl_db())
- exit(1);
-#endif
-
/* Open the share_info.tdb here, so we don't have to open
after the fork on every single connection. This is a small
performance improvment and reduces the total number of system
exit(1);
}
- if (!init_system_info()) {
- DEBUG(0,("ERROR: failed to setup system user info.\n"));
+ status = init_system_info();
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
+ nt_errstr(status)));
return -1;
}
return -1;
}
- /*
- * Initialize spoolss with an init function to convert printers first.
- * static_init_rpc will try to initialize the spoolss server too but you
- * can't register it twice.
- */
- spoolss_cb.init = spoolss_init_cb;
- spoolss_cb.shutdown = spoolss_shutdown_cb;
- spoolss_cb.private_data = smbd_server_conn->msg_ctx;
+ if (!file_init(smbd_server_conn)) {
+ DEBUG(0, ("ERROR: file_init failed\n"));
+ return -1;
+ }
- /* Spoolss depends on a winreg pipe, so start it first. */
- if (!NT_STATUS_IS_OK(rpc_winreg_init(NULL))) {
- exit(1);
+ /* This MUST be done before start_epmd() because otherwise
+ * start_epmd() forks and races against dcesrv_ep_setup() to
+ * call directory_create_or_exist() */
+ if (!directory_create_or_exist(lp_ncalrpc_dir(), geteuid(), 0755)) {
+ DEBUG(0, ("Failed to create pipe directory %s - %s\n",
+ lp_ncalrpc_dir(), strerror(errno)));
+ return -1;
}
- if (!NT_STATUS_IS_OK(rpc_spoolss_init(&spoolss_cb))) {
+ if (is_daemon && !interactive) {
+ if (rpc_epmapper_daemon() == RPC_DAEMON_FORK) {
+ start_epmd(ev_ctx, msg_ctx);
+ }
+ }
+
+ if (!dcesrv_ep_setup(ev_ctx, msg_ctx)) {
exit(1);
}
- static_init_rpc;
+ /* only start other daemons if we are running as a daemon
+ * -- bad things will happen if smbd is launched via inetd
+ * and we fork a copy of ourselves here */
+ if (is_daemon && !interactive) {
- /* Publish nt printers, this requires a working winreg pipe */
- reload_printers(smbd_messaging_context());
+ if (rpc_lsasd_daemon() == RPC_DAEMON_FORK) {
+ start_lsasd(ev_ctx, msg_ctx);
+ }
- /* only start the background queue daemon if we are
- running as a daemon -- bad things will happen if
- smbd is launched via inetd and we fork a copy of
- ourselves here */
+ if (!_lp_disable_spoolss() &&
+ (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
+ bool bgq = lp_parm_bool(-1, "smbd", "backgroundqueue", true);
- if (is_daemon && !interactive
- && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
- start_background_queue(smbd_event_context(),
- smbd_messaging_context());
+ if (!printing_subsystem_init(ev_ctx, msg_ctx, true, bgq)) {
+ exit(1);
+ }
+ }
+ } else if (!_lp_disable_spoolss() &&
+ (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
+ if (!printing_subsystem_init(ev_ctx, msg_ctx, false, false)) {
+ exit(1);
+ }
}
if (!is_daemon) {
/* Started from inetd. fd 0 is the socket. */
/* We will abort gracefully when the client or remote system
goes away */
- smbd_set_server_fd(dup(0));
+ smbd_server_conn->sock = dup(0);
/* close our standard file descriptors */
- close_low_fds(False); /* Don't close stderr */
+ if (!debug_get_output_is_stdout()) {
+ close_low_fds(False); /* Don't close stderr */
+ }
#ifdef HAVE_ATEXIT
atexit(killkids);
#endif
/* Stop zombies */
- smbd_setup_sig_chld_handler();
+ smbd_setup_sig_chld_handler(ev_ctx);
- smbd_process(smbd_server_conn);
+ smbd_process(ev_ctx, smbd_server_conn);
exit_server_cleanly(NULL);
return(0);
}
- parent = talloc_zero(smbd_event_context(), struct smbd_parent_context);
+ parent = talloc_zero(ev_ctx, struct smbd_parent_context);
if (!parent) {
exit_server("talloc(struct smbd_parent_context) failed");
}
parent->interactive = interactive;
- if (!open_sockets_smbd(parent, ports))
+ if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
exit_server("open_sockets_smbd() failed");
+ /* do a printer update now that all messaging has been set up,
+ * before we allow clients to start connecting */
+ printing_subsystem_update(ev_ctx, msg_ctx, false);
+
TALLOC_FREE(frame);
/* make sure we always have a valid stackframe */
frame = talloc_stackframe();
- smbd_parent_loop(parent);
+ smbd_parent_loop(ev_ctx, parent);
exit_server_cleanly(NULL);
TALLOC_FREE(frame);
git.samba.org / idra / samba.git / blobdiff