#include "includes.h"
#include "smbd/globals.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 "librpc/gen_ndr/netlogon.h"
#include "librpc/gen_ndr/messaging.h"
-#include "printing/nt_printing_migrate.h"
extern bool global_machine_password_needs_changing;
void *siginfo,
void *private_data)
{
+ struct messaging_context *msg_ctx = talloc_get_type_abort(
+ private_data, struct messaging_context);
change_to_root_user();
DEBUG(1,("Reloading services after SIGHUP\n"));
- reload_services(False);
+ reload_services(msg_ctx, False);
}
-void smbd_setup_sig_hup_handler(void)
+void smbd_setup_sig_hup_handler(struct tevent_context *ev,
+ struct messaging_context *msg_ctx)
{
struct tevent_signal *se;
- se = tevent_add_signal(smbd_event_context(),
- smbd_event_context(),
- SIGHUP, 0,
- smbd_sig_hup_handler,
- NULL);
+ se = tevent_add_signal(ev, ev, SIGHUP, 0, smbd_sig_hup_handler,
+ msg_ctx);
if (!se) {
exit_server("failed to setup SIGHUP handler");
}
true, req->seqnum+1,
IS_CONN_ENCRYPTED(req->conn)||req->encrypted,
&req->pcd)) {
- exit_server_cleanly("construct_reply: srv_send_smb failed.");
+ exit_server_cleanly("chain_reply: srv_send_smb failed.");
}
TALLOC_FREE(req->chain_outbuf);
req->done = true;
Check if services need reloading.
****************************************************************************/
-void check_reload(time_t t)
+static void check_reload(struct messaging_context *msg_ctx, time_t t)
{
time_t printcap_cache_time = (time_t)lp_printcap_cache_time();
}
if (t >= last_smb_conf_reload_time+SMBD_RELOAD_CHECK) {
- reload_services(True);
+ reload_services(msg_ctx, True);
last_smb_conf_reload_time = t;
}
|| (t-last_printer_reload_time < 0) )
{
DEBUG( 3,( "Printcap cache time expired.\n"));
- reload_printers();
+ reload_printers(msg_ctx);
last_printer_reload_time = t;
}
}
NTSTATUS status;
uint32_t seqnum;
- bool from_client = (smbd_server_fd() == fd)?true:false;
+ bool from_client = (smbd_server_fd() == fd);
if (from_client) {
smbd_lock_socket(conn);
if (flags & EVENT_FD_WRITE) {
smbd_server_connection_write_handler(conn);
- } else if (flags & EVENT_FD_READ) {
+ return;
+ }
+ if (flags & EVENT_FD_READ) {
smbd_server_connection_read_handler(conn, smbd_server_fd());
+ return;
}
}
if (flags & EVENT_FD_WRITE) {
smbd_server_connection_write_handler(conn);
- } else if (flags & EVENT_FD_READ) {
+ return;
+ }
+ if (flags & EVENT_FD_READ) {
smbd_server_connection_read_handler(
conn, conn->smb1.echo_handler.trusted_fd);
+ return;
}
}
*/
static bool deadtime_fn(const struct timeval *now, void *private_data)
{
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn =
+ (struct smbd_server_connection *)private_data;
if (sconn->using_smb2) {
/* TODO: implement real idle check */
return true;
}
DEBUG( 2, ( "Closing idle SMB2 connection\n" ) );
- messaging_send(smbd_messaging_context(), procid_self(),
+ messaging_send(sconn->msg_ctx, procid_self(),
MSG_SHUTDOWN, &data_blob_null);
return false;
}
if ((conn_num_open(sconn) == 0)
|| (conn_idle_all(sconn, now->tv_sec))) {
DEBUG( 2, ( "Closing idle SMB1 connection\n" ) );
- messaging_send(smbd_messaging_context(), procid_self(),
+ messaging_send(sconn->msg_ctx, procid_self(),
MSG_SHUTDOWN, &data_blob_null);
return False;
}
static bool housekeeping_fn(const struct timeval *now, void *private_data)
{
+ struct messaging_context *msg_ctx = talloc_get_type_abort(
+ private_data, struct messaging_context);
change_to_root_user();
/* update printer queue caches if necessary */
- update_monitored_printq_cache();
+ update_monitored_printq_cache(msg_ctx);
/* check if we need to reload services */
- check_reload(time(NULL));
+ check_reload(msg_ctx, time(NULL));
/* Change machine password if neccessary. */
attempt_machine_password_change();
bool ok;
bool encrypted = false;
+ smb_msleep(1000);
+
ok = smbd_lock_socket_internal(sconn);
if (!ok) {
DEBUG(0, ("%s: failed to lock socket\n",
close(listener_pipe[0]);
- status = reinit_after_fork(smbd_messaging_context(),
+ status = reinit_after_fork(sconn->msg_ctx,
smbd_event_context(),
procid_self(), false);
if (!NT_STATUS_IS_OK(status)) {
return false;
}
-static bool spoolss_init_cb(void *ptr)
-{
- return nt_printing_tdb_migrate();
-}
-
/****************************************************************************
Process commands from the client
****************************************************************************/
-void smbd_process(void)
+void smbd_process(struct smbd_server_connection *sconn)
{
TALLOC_CTX *frame = talloc_stackframe();
struct sockaddr_storage ss;
struct tsocket_address *remote_address = NULL;
const char *remaddr = NULL;
int ret;
- struct rpc_srv_callbacks spoolss_cb;
if (lp_maxprotocol() == PROTOCOL_SMB2 &&
lp_security() != SEC_SHARE &&
* with the first negprot
* packet.
*/
- smbd_server_conn->using_smb2 = true;
+ sconn->using_smb2 = true;
}
/* Ensure child is set to blocking mode */
DEBUG(level,("getpeername() failed - %s\n", strerror(errno)));
exit_server_cleanly("getpeername() failed.\n");
}
- ret = tsocket_address_bsd_from_sockaddr(smbd_server_conn,
+ ret = tsocket_address_bsd_from_sockaddr(sconn,
sa, sa_len,
&remote_address);
if (ret != 0) {
DEBUG(level,("getsockname() failed - %s\n", strerror(errno)));
exit_server_cleanly("getsockname() failed.\n");
}
- ret = tsocket_address_bsd_from_sockaddr(smbd_server_conn,
+ ret = tsocket_address_bsd_from_sockaddr(sconn,
sa, sa_len,
&local_address);
if (ret != 0) {
exit_server_cleanly("tsocket_address_bsd_from_sockaddr remote failed.\n");
}
- smbd_server_conn->local_address = local_address;
- smbd_server_conn->remote_address = remote_address;
+ sconn->local_address = local_address;
+ sconn->remote_address = remote_address;
if (tsocket_address_is_inet(remote_address, "ip")) {
remaddr = tsocket_address_inet_addr_string(
- smbd_server_conn->remote_address,
+ sconn->remote_address,
talloc_tos());
if (remaddr == NULL) {
/* this is needed so that we get decent entries
in smbstatus for port 445 connects */
set_remote_machine_name(remaddr, false);
- reload_services(true);
+ reload_services(sconn->msg_ctx, true);
/*
* Before the first packet, check the global hosts allow/ hosts deny
DEBUG(0,("Changed root to %s\n", lp_rootdir()));
}
- if (!srv_init_signing(smbd_server_conn)) {
+ if (!srv_init_signing(sconn)) {
exit_server("Failed to init smb_signing");
}
- if (lp_async_smb_echo_handler() && !fork_echo_handler(smbd_server_conn)) {
+ if (lp_async_smb_echo_handler() && !fork_echo_handler(sconn)) {
exit_server("Failed to fork echo handler");
}
/* Setup oplocks */
- if (!init_oplocks(smbd_messaging_context()))
+ if (!init_oplocks(sconn->msg_ctx))
exit_server("Failed to init oplocks");
/* register our message handlers */
- messaging_register(smbd_messaging_context(), NULL,
+ messaging_register(sconn->msg_ctx, NULL,
MSG_SMB_FORCE_TDIS, msg_force_tdis);
- messaging_register(smbd_messaging_context(), NULL,
+ messaging_register(sconn->msg_ctx, NULL,
MSG_SMB_RELEASE_IP, msg_release_ip);
- messaging_register(smbd_messaging_context(), NULL,
+ messaging_register(sconn->msg_ctx, NULL,
MSG_SMB_CLOSE_FILE, msg_close_file);
/*
* Use the default MSG_DEBUG handler to avoid rebroadcasting
* MSGs to all child processes
*/
- messaging_deregister(smbd_messaging_context(),
+ messaging_deregister(sconn->msg_ctx,
MSG_DEBUG, NULL);
- messaging_register(smbd_messaging_context(), NULL,
+ messaging_register(sconn->msg_ctx, NULL,
MSG_DEBUG, debug_message);
if ((lp_keepalive() != 0)
if (!(event_add_idle(smbd_event_context(), NULL,
timeval_set(IDLE_CLOSED_TIMEOUT, 0),
- "deadtime", deadtime_fn, NULL))) {
+ "deadtime", deadtime_fn, sconn))) {
DEBUG(0, ("Could not add deadtime event\n"));
exit(1);
}
if (!(event_add_idle(smbd_event_context(), NULL,
timeval_set(SMBD_SELECT_TIMEOUT, 0),
- "housekeeping", housekeeping_fn, NULL))) {
+ "housekeeping", housekeeping_fn,
+ sconn->msg_ctx))) {
DEBUG(0, ("Could not add housekeeping event\n"));
exit(1);
}
#endif
- smbd_server_conn->nbt.got_session = false;
+ sconn->nbt.got_session = false;
- smbd_server_conn->smb1.negprot.max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
+ sconn->smb1.negprot.max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
- smbd_server_conn->smb1.sessions.done_sesssetup = false;
- smbd_server_conn->smb1.sessions.max_send = BUFFER_SIZE;
- smbd_server_conn->smb1.sessions.last_session_tag = UID_FIELD_INVALID;
+ sconn->smb1.sessions.done_sesssetup = false;
+ sconn->smb1.sessions.max_send = BUFFER_SIZE;
+ sconn->smb1.sessions.last_session_tag = UID_FIELD_INVALID;
/* users from session setup */
- smbd_server_conn->smb1.sessions.session_userlist = NULL;
+ sconn->smb1.sessions.session_userlist = NULL;
/* workgroup from session setup. */
- smbd_server_conn->smb1.sessions.session_workgroup = NULL;
+ sconn->smb1.sessions.session_workgroup = NULL;
/* this holds info on user ids that are already validated for this VC */
- smbd_server_conn->smb1.sessions.validated_users = NULL;
- smbd_server_conn->smb1.sessions.next_vuid = VUID_OFFSET;
- smbd_server_conn->smb1.sessions.num_validated_vuids = 0;
+ sconn->smb1.sessions.validated_users = NULL;
+ sconn->smb1.sessions.next_vuid = VUID_OFFSET;
+ sconn->smb1.sessions.num_validated_vuids = 0;
- conn_init(smbd_server_conn);
- if (!init_dptrs(smbd_server_conn)) {
+ conn_init(sconn);
+ if (!init_dptrs(sconn)) {
exit_server("init_dptrs() failed");
}
- smbd_server_conn->smb1.fde = event_add_fd(smbd_event_context(),
- smbd_server_conn,
+ sconn->smb1.fde = event_add_fd(smbd_event_context(),
+ sconn,
smbd_server_fd(),
EVENT_FD_READ,
smbd_server_connection_handler,
- smbd_server_conn);
- if (!smbd_server_conn->smb1.fde) {
+ sconn);
+ if (!sconn->smb1.fde) {
exit_server("failed to create smbd_server_connection fde");
}
- /*
- * 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 = NULL;
-
-
- if (!NT_STATUS_IS_OK(rpc_winreg_init(NULL))) {
- exit(1);
- }
-
- if (!NT_STATUS_IS_OK(rpc_spoolss_init(&spoolss_cb))) {
- exit(1);
- }
-
- static_init_rpc;
-
TALLOC_FREE(frame);
while (True) {
errno = 0;
- status = smbd_server_connection_loop_once(smbd_server_conn);
+ status = smbd_server_connection_loop_once(sconn);
if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY) &&
!NT_STATUS_IS_OK(status)) {
DEBUG(3, ("smbd_server_connection_loop_once failed: %s,"
git.samba.org / amitay / samba.git / blobdiff