#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"
+#include "../lib/async_req/async_sock.h"
+#include "ctdbd_conn.h"
+#include "../lib/util/select.h"
extern bool global_machine_password_needs_changing;
Send an smb to a fd.
****************************************************************************/
-bool srv_send_smb(int fd, char *buffer,
+bool srv_send_smb(struct smbd_server_connection *sconn, char *buffer,
bool do_signing, uint32_t seqnum,
bool do_encrypt,
struct smb_perfcount_data *pcd)
ssize_t ret;
char *buf_out = buffer;
- smbd_lock_socket(smbd_server_conn);
+ smbd_lock_socket(sconn);
if (do_signing) {
/* Sign the outgoing packet if required. */
- srv_calculate_sign_mac(smbd_server_conn, buf_out, seqnum);
+ srv_calculate_sign_mac(sconn, buf_out, seqnum);
}
if (do_encrypt) {
len = smb_len(buf_out) + 4;
- ret = write_data(fd,buf_out+nwritten,len - nwritten);
+ ret = write_data(sconn->sock, buf_out+nwritten, len - nwritten);
if (ret <= 0) {
- DEBUG(0,("pid[%d] Error writing %d bytes to client. %d. (%s)\n",
- (int)sys_getpid(), (int)len,(int)ret, strerror(errno) ));
+
+ char addr[INET6_ADDRSTRLEN];
+ /*
+ * Try and give an error message saying what
+ * client failed.
+ */
+ DEBUG(1,("pid[%d] Error writing %d bytes to client %s. %d. (%s)\n",
+ (int)sys_getpid(), (int)len,
+ get_peer_addr(sconn->sock, addr, sizeof(addr)),
+ (int)ret, strerror(errno) ));
+
srv_free_enc_buffer(buf_out);
goto out;
}
out:
SMB_PERFCOUNT_END(pcd);
- smbd_unlock_socket(smbd_server_conn);
+ smbd_unlock_socket(sconn);
return true;
}
static NTSTATUS read_packet_remainder(int fd, char *buffer,
unsigned int timeout, ssize_t len)
{
+ NTSTATUS status;
+
if (len <= 0) {
return NT_STATUS_OK;
}
- return read_fd_with_timeout(fd, buffer, len, len, timeout, NULL);
+ status = read_fd_with_timeout(fd, buffer, len, len, timeout, NULL);
+ if (!NT_STATUS_IS_OK(status)) {
+ char addr[INET6_ADDRSTRLEN];
+ DEBUG(0, ("read_fd_with_timeout failed for client %s read "
+ "error = %s.\n",
+ get_peer_addr(fd, addr, sizeof(addr)),
+ nt_errstr(status)));
+ }
+ return status;
}
/****************************************************************************
timeout, NULL);
if (!NT_STATUS_IS_OK(status)) {
+ char addr[INET6_ADDRSTRLEN];
+ DEBUG(0, ("read_fd_with_timeout failed for client %s read "
+ "error = %s.\n",
+ get_peer_addr(fd, addr, sizeof(addr)),
+ nt_errstr(status)));
return status;
}
if (doff > STANDARD_WRITE_AND_X_HEADER_SIZE) {
size_t drain = doff - STANDARD_WRITE_AND_X_HEADER_SIZE;
- if (drain_socket(smbd_server_fd(), drain) != drain) {
+ if (drain_socket(fd, drain) != drain) {
smb_panic("receive_smb_raw_talloc_partial_read:"
" failed to drain pending bytes");
}
status = read_smb_length_return_keepalive(fd, lenbuf, timeout, &len);
if (!NT_STATUS_IS_OK(status)) {
- DEBUG(10, ("receive_smb_raw: %s\n", nt_errstr(status)));
return status;
}
status = receive_smb_raw_talloc(mem_ctx, fd, buffer, timeout,
p_unread, &len);
if (!NT_STATUS_IS_OK(status)) {
+ char addr[INET6_ADDRSTRLEN];
+ DEBUG(1, ("read_smb_length_return_keepalive failed for "
+ "client %s read error = %s.\n",
+ get_peer_addr(fd, addr, sizeof(addr)),
+ nt_errstr(status)));
return status;
}
private_data, struct messaging_context);
change_to_root_user();
DEBUG(1,("Reloading services after SIGHUP\n"));
- reload_services(msg_ctx, False);
+ reload_services(msg_ctx, smbd_server_conn->sock, False);
}
void smbd_setup_sig_hup_handler(struct tevent_context *ev,
errno = sav;
}
+ /* Check if error */
+ if (selrtn == -1) {
+ /* something is wrong. Maybe the socket is dead? */
+ return map_nt_error_from_unix(errno);
+ }
+
if ((conn->smb1.echo_handler.trusted_fd != -1)
- && FD_ISSET(smbd_server_fd(), &r_fds)
+ && FD_ISSET(conn->sock, &r_fds)
&& FD_ISSET(conn->smb1.echo_handler.trusted_fd, &r_fds)) {
/*
* Prefer to read pending requests from the echo handler. To
* quote Jeremy (da70f8ab1): This is a hack of monstrous
* proportions...
*/
- FD_CLR(smbd_server_fd(), &r_fds);
+ FD_CLR(conn->sock, &r_fds);
}
if (run_events(smbd_event_context(), selrtn, &r_fds, &w_fds)) {
return NT_STATUS_RETRY;
}
- /* Check if error */
- if (selrtn == -1) {
- /* something is wrong. Maybe the socket is dead? */
- return map_nt_error_from_unix(errno);
- }
-
/* Did we timeout ? */
if (selrtn == 0) {
return NT_STATUS_RETRY;
/* does this protocol need to be run as guest? */
if ((flags & AS_GUEST)
&& (!change_to_guest() ||
- !check_access(smbd_server_fd(), lp_hostsallow(-1),
- lp_hostsdeny(-1)))) {
+ !allow_access(lp_hostsdeny(-1), lp_hostsallow(-1),
+ sconn->client_id.name,
+ sconn->client_id.addr))) {
reply_nterror(req, NT_STATUS_ACCESS_DENIED);
return conn;
}
if (req->unread_bytes) {
/* writeX failed. drain socket. */
- if (drain_socket(smbd_server_fd(), req->unread_bytes) !=
+ if (drain_socket(req->sconn->sock, req->unread_bytes) !=
req->unread_bytes) {
smb_panic("failed to drain pending bytes");
}
show_msg((char *)req->outbuf);
}
- if (!srv_send_smb(smbd_server_fd(),
+ if (!srv_send_smb(req->sconn,
(char *)req->outbuf,
true, req->seqnum+1,
IS_CONN_ENCRYPTED(conn)||req->encrypted,
DEBUG( 6, ( "got message type 0x%x of len 0x%x\n", msg_type,
smb_len(inbuf) ) );
- DEBUG( 3, ( "Transaction %d of length %d (%u toread)\n", trans_num,
- (int)nread,
- (unsigned int)unread_bytes ));
+ DEBUG(3, ("Transaction %d of length %d (%u toread)\n",
+ conn->trans_num, (int)nread, (unsigned int)unread_bytes));
if (msg_type != 0) {
/*
* NetBIOS session request, keepalive, etc.
*/
- reply_special(conn, (char *)inbuf);
+ reply_special(conn, (char *)inbuf, nread);
goto done;
}
show_msg((char *)inbuf);
construct_reply((char *)inbuf,nread,unread_bytes,seqnum,encrypted,deferred_pcd);
- trans_num++;
+ conn->trans_num++;
done:
conn->smb1.num_requests++;
smb_setlen((char *)(req->chain_outbuf),
talloc_get_size(req->chain_outbuf) - 4);
- if (!srv_send_smb(smbd_server_fd(), (char *)req->chain_outbuf,
+ if (!srv_send_smb(req->sconn, (char *)req->chain_outbuf,
true, req->seqnum+1,
IS_CONN_ENCRYPTED(req->conn)
||req->encrypted,
show_msg((char *)(req->chain_outbuf));
- if (!srv_send_smb(smbd_server_fd(), (char *)req->chain_outbuf,
+ if (!srv_send_smb(req->sconn, (char *)req->chain_outbuf,
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.
****************************************************************************/
-static void check_reload(struct messaging_context *msg_ctx, time_t t)
+static void check_reload(struct smbd_server_connection *sconn, 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(msg_ctx, True);
+ reload_services(sconn->msg_ctx, sconn->sock, True);
last_smb_conf_reload_time = t;
}
|| (t-last_printer_reload_time < 0) )
{
DEBUG( 3,( "Printcap cache time expired.\n"));
- reload_printers(msg_ctx);
+ reload_printers(sconn->msg_ctx);
last_printer_reload_time = t;
}
}
NTSTATUS status;
uint32_t seqnum;
- bool from_client = (smbd_server_fd() == fd)?true:false;
+ bool from_client = (conn->sock == fd);
if (from_client) {
smbd_lock_socket(conn);
- if (!fd_is_readable(smbd_server_fd())) {
+ if (!fd_is_readable(fd)) {
DEBUG(10,("the echo listener was faster\n"));
smbd_unlock_socket(conn);
return;
if (flags & EVENT_FD_WRITE) {
smbd_server_connection_write_handler(conn);
- } else if (flags & EVENT_FD_READ) {
- smbd_server_connection_read_handler(conn, smbd_server_fd());
+ return;
+ }
+ if (flags & EVENT_FD_READ) {
+ smbd_server_connection_read_handler(conn, conn->sock);
+ 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 void release_ip(const char *ip, void *priv)
{
- char addr[INET6_ADDRSTRLEN];
- char *p = addr;
-
- client_socket_addr(get_client_fd(),addr,sizeof(addr));
+ const char *addr = (const char *)priv;
+ const char *p = addr;
if (strncmp("::ffff:", addr, 7) == 0) {
p = addr + 7;
static void msg_release_ip(struct messaging_context *msg_ctx, void *private_data,
uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)
{
- release_ip((char *)data->data, NULL);
+ struct smbd_server_connection *sconn = talloc_get_type_abort(
+ private_data, struct smbd_server_connection);
+
+ release_ip((char *)data->data, sconn->client_id.addr);
}
#ifdef CLUSTER_SUPPORT
-static int client_get_tcp_info(struct sockaddr_storage *server,
+static int client_get_tcp_info(int sock, struct sockaddr_storage *server,
struct sockaddr_storage *client)
{
socklen_t length;
- if (server_fd == -1) {
- return -1;
- }
length = sizeof(*server);
- if (getsockname(server_fd, (struct sockaddr *)server, &length) != 0) {
+ if (getsockname(sock, (struct sockaddr *)server, &length) != 0) {
return -1;
}
length = sizeof(*client);
- if (getpeername(server_fd, (struct sockaddr *)client, &length) != 0) {
+ if (getpeername(sock, (struct sockaddr *)client, &length) != 0) {
return -1;
}
return 0;
}
smbd_lock_socket(smbd_server_conn);
- ret = send_keepalive(smbd_server_fd());
+ ret = send_keepalive(sconn->sock);
smbd_unlock_socket(smbd_server_conn);
if (!ret) {
- DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
+ char addr[INET6_ADDRSTRLEN];
+ /*
+ * Try and give an error message saying what
+ * client failed.
+ */
+ DEBUG(0, ("send_keepalive failed for client %s. "
+ "Error %s - exiting\n",
+ get_peer_addr(sconn->sock, addr, sizeof(addr)),
+ strerror(errno)));
return False;
}
return True;
return true;
}
DEBUG( 2, ( "Closing idle SMB2 connection\n" ) );
- messaging_send(sconn->msg_ctx, procid_self(),
+ messaging_send(sconn->msg_ctx,
+ messaging_server_id(sconn->msg_ctx),
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(sconn->msg_ctx, procid_self(),
+ messaging_send(sconn->msg_ctx,
+ messaging_server_id(sconn->msg_ctx),
MSG_SHUTDOWN, &data_blob_null);
return False;
}
static bool housekeeping_fn(const struct timeval *now, void *private_data)
{
+ struct smbd_server_connection *sconn = talloc_get_type_abort(
+ private_data, struct smbd_server_connection);
change_to_root_user();
/* update printer queue caches if necessary */
- update_monitored_printq_cache(smbd_messaging_context());
+ update_monitored_printq_cache(sconn->msg_ctx);
/* check if we need to reload services */
- check_reload(smbd_messaging_context(), time(NULL));
+ check_reload(sconn, time(NULL));
/* Change machine password if neccessary. */
attempt_machine_password_change();
smbd_echo_activate_writer(state);
}
-static bool smbd_echo_reply(int fd,
- uint8_t *inbuf, size_t inbuf_len,
+static bool smbd_echo_reply(uint8_t *inbuf, size_t inbuf_len,
uint32_t seqnum)
{
struct smb_request req;
out_len = smb_len(req.outbuf) + 4;
- ok = srv_send_smb(smbd_server_fd(),
+ ok = srv_send_smb(req.sconn,
(char *)outbuf,
true, seqnum+1,
false, &req.pcd);
size_t unread, num_pending;
NTSTATUS status;
struct iovec *tmp;
+ size_t iov_len;
uint32_t seqnum = 0;
bool reply;
bool ok;
bool encrypted = false;
+ smb_msleep(1000);
+
ok = smbd_lock_socket_internal(sconn);
if (!ok) {
DEBUG(0, ("%s: failed to lock socket\n",
exit(1);
}
- if (!fd_is_readable(smbd_server_fd())) {
+ if (!fd_is_readable(sconn->sock)) {
DEBUG(10,("echo_handler[%d] the parent smbd was faster\n",
(int)sys_getpid()));
ok = smbd_unlock_socket_internal(sconn);
DEBUG(10,("echo_handler[%d]: reading pdu\n", (int)sys_getpid()));
- status = receive_smb_talloc(state->pending, smbd_server_fd(),
+ status = receive_smb_talloc(state->pending, sconn->sock,
(char **)(void *)&state->pending[num_pending].iov_base,
0 /* timeout */,
&unread,
&encrypted,
- &state->pending[num_pending].iov_len,
+ &iov_len,
&seqnum,
false /* trusted_channel*/);
if (!NT_STATUS_IS_OK(status)) {
(int)sys_getpid(), nt_errstr(status)));
exit(1);
}
+ state->pending[num_pending].iov_len = iov_len;
ok = smbd_unlock_socket_internal(sconn);
if (!ok) {
SIVAL((uint8_t *)state->pending[num_pending].iov_base, smb_ss_field, seqnum);
SIVAL((uint8_t *)state->pending[num_pending].iov_base, smb_ss_field+4, NT_STATUS_V(NT_STATUS_OK));
- reply = smbd_echo_reply(smbd_server_fd(),
- (uint8_t *)state->pending[num_pending].iov_base,
+ reply = smbd_echo_reply((uint8_t *)state->pending[num_pending].iov_base,
state->pending[num_pending].iov_len,
seqnum);
if (reply) {
TALLOC_FREE(state);
return;
}
- state->read_fde = tevent_add_fd(state->ev, state, smbd_server_fd(),
+ state->read_fde = tevent_add_fd(state->ev, state, sconn->sock,
TEVENT_FD_READ, smbd_echo_reader,
state);
if (state->read_fde == NULL) {
return false;
}
-static bool spoolss_init_cb(void *ptr)
+#if CLUSTER_SUPPORT
+
+static NTSTATUS smbd_register_ips(struct smbd_server_connection *sconn,
+ struct sockaddr_storage *srv,
+ struct sockaddr_storage *clnt)
{
- return nt_printing_tdb_migrate(smbd_messaging_context());
+ struct ctdbd_connection *cconn;
+ char tmp_addr[INET6_ADDRSTRLEN];
+ char *addr;
+
+ cconn = messaging_ctdbd_connection();
+ if (cconn == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ client_socket_addr(sconn->sock, tmp_addr, sizeof(tmp_addr));
+ addr = talloc_strdup(cconn, tmp_addr);
+ if (addr == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ return ctdbd_register_ips(cconn, srv, clnt, release_ip, addr);
}
+#endif
+
/****************************************************************************
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 sockaddr *sa = NULL;
- socklen_t sa_len;
+ socklen_t sa_socklen;
struct tsocket_address *local_address = NULL;
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 */
- set_blocking(smbd_server_fd(),True);
+ set_blocking(sconn->sock,True);
- set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
- set_socket_options(smbd_server_fd(), lp_socket_options());
+ set_socket_options(sconn->sock, "SO_KEEPALIVE");
+ set_socket_options(sconn->sock, lp_socket_options());
sa = (struct sockaddr *)(void *)&ss;
- sa_len = sizeof(ss);
- ret = getpeername(smbd_server_fd(), sa, &sa_len);
+ sa_socklen = sizeof(ss);
+ ret = getpeername(sconn->sock, sa, &sa_socklen);
if (ret != 0) {
int level = (errno == ENOTCONN)?2:0;
DEBUG(level,("getpeername() failed - %s\n", strerror(errno)));
exit_server_cleanly("getpeername() failed.\n");
}
- ret = tsocket_address_bsd_from_sockaddr(smbd_server_conn,
- sa, sa_len,
+ ret = tsocket_address_bsd_from_sockaddr(sconn,
+ sa, sa_socklen,
&remote_address);
if (ret != 0) {
DEBUG(0,("%s: tsocket_address_bsd_from_sockaddr remote failed - %s\n",
}
sa = (struct sockaddr *)(void *)&ss;
- sa_len = sizeof(ss);
- ret = getsockname(smbd_server_fd(), sa, &sa_len);
+ sa_socklen = sizeof(ss);
+ ret = getsockname(sconn->sock, sa, &sa_socklen);
if (ret != 0) {
int level = (errno == ENOTCONN)?2:0;
DEBUG(level,("getsockname() failed - %s\n", strerror(errno)));
exit_server_cleanly("getsockname() failed.\n");
}
- ret = tsocket_address_bsd_from_sockaddr(smbd_server_conn,
- sa, sa_len,
+ ret = tsocket_address_bsd_from_sockaddr(sconn,
+ sa, sa_socklen,
&local_address);
if (ret != 0) {
DEBUG(0,("%s: tsocket_address_bsd_from_sockaddr remote failed - %s\n",
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(smbd_server_conn->msg_ctx, true);
+ reload_services(sconn->msg_ctx, sconn->sock, true);
/*
* Before the first packet, check the global hosts allow/ hosts deny
* the hosts allow list.
*/
- if (!check_access(smbd_server_fd(), lp_hostsallow(-1),
- lp_hostsdeny(-1))) {
+ if (!allow_access(lp_hostsdeny(-1), lp_hostsallow(-1),
+ sconn->client_id.name,
+ sconn->client_id.addr)) {
/*
* send a negative session response "not listening on calling
* name"
DEBUG( 1, ("Connection denied from %s to %s\n",
tsocket_address_string(remote_address, talloc_tos()),
tsocket_address_string(local_address, talloc_tos())));
- (void)srv_send_smb(smbd_server_fd(),(char *)buf, false,
+ (void)srv_send_smb(sconn,(char *)buf, false,
0, false, NULL);
exit_server_cleanly("connection denied");
}
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, sconn,
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, smbd_server_conn))) {
+ "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))) {
DEBUG(0, ("Could not add housekeeping event\n"));
exit(1);
}
struct sockaddr_storage srv, clnt;
- if (client_get_tcp_info(&srv, &clnt) == 0) {
-
+ if (client_get_tcp_info(sconn->sock, &srv, &clnt) == 0) {
NTSTATUS status;
-
- status = ctdbd_register_ips(
- messaging_ctdbd_connection(procid_self()),
- &srv, &clnt, release_ip, NULL);
-
+ status = smbd_register_ips(sconn, &srv, &clnt);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("ctdbd_register_ips failed: %s\n",
nt_errstr(status)));
#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,
- smbd_server_fd(),
+ sconn->smb1.fde = event_add_fd(smbd_event_context(),
+ sconn,
+ sconn->sock,
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 / idra / samba.git / blobdiff