/***************************************************************************
handle DNS queries arriving from the parent
****************************************************************************/
static void asyncdns_process(void)
{
struct query_record r;
unstring qname;
DEBUGLEVEL = -1;
while (1) {
if (read_data(fd_in, (char *)&r, sizeof(r)) != sizeof(r))
break;
pull_ascii_nstring( qname, sizeof(qname), r.name.name);
r.result.s_addr = interpret_addr(qname);
if (write_data(fd_out, (char *)&r, sizeof(r)) != sizeof(r))
break;
}
_exit(0);
}
/* check to see if nmbd is running on localhost by looking for a __SAMBA__
response */
BOOL nmbd_running(void)
{
extern struct in_addr loopback_ip;
int fd, count, flags;
struct in_addr *ip_list;
if ((fd = open_socket_in(SOCK_DGRAM, 0, 3,
interpret_addr("127.0.0.1"), True)) != -1) {
if ((ip_list = name_query(fd, "__SAMBA__", 0,
True, True, loopback_ip,
&count, &flags, NULL)) != NULL) {
SAFE_FREE(ip_list);
close(fd);
return True;
}
close (fd);
}
return False;
}
/********************************************************
resolve via "bcast" method
*********************************************************/
static BOOL resolve_bcast(const char *name, struct in_addr *return_ip, int name_type)
{
int sock, i;
/*
* "bcast" means do a broadcast lookup on all the local interfaces.
*/
DEBUG(3,("resolve_name: Attempting broadcast lookup for name %s<0x%x>\n", name, name_type));
sock = open_socket_in( SOCK_DGRAM, 0, 3,
interpret_addr(lp_socket_address()), True );
if (sock != -1) {
struct in_addr *iplist = NULL;
int count;
int num_interfaces = iface_count();
static char so_broadcast[] = "SO_BROADCAST";
set_socket_options(sock, so_broadcast);
/*
* Lookup the name on all the interfaces, return on
* the first successful match.
*/
for( i = 0; i < num_interfaces; i++) {
struct in_addr sendto_ip;
/* Done this way to fix compiler error on IRIX 5.x */
sendto_ip = *iface_bcast(*iface_n_ip(i));
iplist = name_query(sock, name, name_type, True,
True, sendto_ip, &count, NULL);
if(iplist != NULL) {
*return_ip = iplist[0];
free((char *)iplist);
close(sock);
return True;
}
}
close(sock);
}
return False;
}
/***************************************************************************
we use this when we can't do async DNS lookups
****************************************************************************/
BOOL queue_dns_query(struct packet_struct *p,struct nmb_name *question,
struct name_record **n)
{
char *qname = question->name;
struct in_addr dns_ip;
DEBUG(3,("DNS search for %s - ", nmb_namestr(question)));
/* Unblock TERM signal so we can be killed in DNS lookup. */
BlockSignals(False, SIGTERM);
dns_ip.s_addr = interpret_addr(qname);
/* Re-block TERM signal. */
BlockSignals(True, SIGTERM);
*n = add_dns_result(question, dns_ip);
if(*n == NULL)
send_wins_name_query_response(NAM_ERR, p, NULL);
else
send_wins_name_query_response(0, p, *n);
return False;
}
static int init_sockets_smbd(const char *smb_ports, int listenset[FD_SETSIZE])
{
int num_interfaces = iface_count();
char * ports;
int num_sockets = 0;
int i, s;
/* use a reasonable default set of ports - listing on 445 and 139 */
if (!smb_ports) {
ports = lp_smb_ports();
if (!ports || !*ports) {
ports = smb_xstrdup(SMB_PORTS);
} else {
ports = smb_xstrdup(ports);
}
} else {
ports = smb_xstrdup(smb_ports);
}
if (lp_interfaces() && lp_bind_interfaces_only()) {
/* We have been given an interfaces line, and been
told to only bind to those interfaces. Create a
socket per interface and bind to only these.
*/
/* Now open a listen socket for each of the
interfaces. */
for(i = 0; i < num_interfaces; i++) {
struct in_addr *ifip = iface_n_ip(i);
fstring tok;
const char *ptr;
if(ifip == NULL) {
DEBUG(0,("init_sockets_smbd: interface %d has NULL IP address !\n", i));
continue;
}
for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
unsigned port = atoi(tok);
if (port == 0) {
continue;
}
s = listenset[num_sockets] = open_socket_in(SOCK_STREAM, port, 0, ifip->s_addr, True);
if (s < 0 || s >= FD_SETSIZE)
return 0;
/* ready to listen */
set_socket_options(s,"SO_KEEPALIVE");
set_socket_options(s,user_socket_options);
/* Set server socket to non-blocking for the accept. */
set_blocking(s,False);
if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
DEBUG(0,("listen: %s\n",strerror(errno)));
close(s);
return 0;
}
num_sockets++;
if (num_sockets >= FD_SETSIZE) {
DEBUG(0,("init_sockets_smbd: Too many sockets to bind to\n"));
return 0;
}
}
}
} else {
/* Just bind to 0.0.0.0 - accept connections
from anywhere. */
fstring tok;
const char *ptr;
num_interfaces = 1;
for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
unsigned port = atoi(tok);
if (port == 0) continue;
/* open an incoming socket */
s = open_socket_in(SOCK_STREAM, port, 0,
interpret_addr(lp_socket_address()),True);
if (s < 0 || s >= FD_SETSIZE)
return 0;
/* ready to listen */
set_socket_options(s,"SO_KEEPALIVE");
set_socket_options(s,user_socket_options);
/* Set server socket to non-blocking for the accept. */
set_blocking(s,False);
if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
DEBUG(0,("init_sockets_smbd: listen: %s\n",
strerror(errno)));
close(s);
return 0;
}
listenset[num_sockets] = s;
num_sockets++;
if (num_sockets >= FD_SETSIZE) {
DEBUG(0,("init_sockets_smbd: Too many sockets to bind to\n"));
return 0;
}
}
}
SAFE_FREE(ports);
return num_sockets;
}
static BOOL open_sockets_smbd(BOOL is_daemon, BOOL interactive, const char *smb_ports)
{
int num_interfaces = iface_count();
int num_sockets = 0;
int fd_listenset[FD_SETSIZE];
fd_set listen_set;
int s;
int maxfd = 0;
int i;
char *ports;
if (!is_daemon) {
return open_sockets_inetd();
}
#ifdef HAVE_ATEXIT
{
static int atexit_set;
if(atexit_set == 0) {
atexit_set=1;
atexit(killkids);
}
}
#endif
#ifndef _XBOX
/* Stop zombies */
CatchChild();
#endif
FD_ZERO(&listen_set);
/* use a reasonable default set of ports - listing on 445 and 139 */
if (!smb_ports) {
ports = lp_smb_ports();
if (!ports || !*ports) {
ports = smb_xstrdup(SMB_PORTS);
} else {
ports = smb_xstrdup(ports);
}
} else {
ports = smb_xstrdup(smb_ports);
}
if (lp_interfaces() && lp_bind_interfaces_only()) {
/* We have been given an interfaces line, and been
told to only bind to those interfaces. Create a
socket per interface and bind to only these.
*/
/* Now open a listen socket for each of the
interfaces. */
for(i = 0; i < num_interfaces; i++) {
struct in_addr *ifip = iface_n_ip(i);
fstring tok;
const char *ptr;
if(ifip == NULL) {
DEBUG(0,("open_sockets_smbd: interface %d has NULL IP address !\n", i));
continue;
}
for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
unsigned port = atoi(tok);
if (port == 0) {
continue;
}
s = fd_listenset[num_sockets] = open_socket_in(SOCK_STREAM, port, 0, ifip->s_addr, True);
if(s == -1)
return False;
/* ready to listen */
set_socket_options(s,"SO_KEEPALIVE");
set_socket_options(s,user_socket_options);
/* Set server socket to non-blocking for the accept. */
set_blocking(s,False);
if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
DEBUG(0,("listen: %s\n",strerror(errno)));
close(s);
return False;
}
FD_SET(s,&listen_set);
maxfd = MAX( maxfd, s);
num_sockets++;
if (num_sockets >= FD_SETSIZE) {
DEBUG(0,("open_sockets_smbd: Too many sockets to bind to\n"));
return False;
}
}
}
} else {
/* Just bind to 0.0.0.0 - accept connections
from anywhere. */
fstring tok;
const char *ptr;
num_interfaces = 1;
for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
unsigned port = atoi(tok);
if (port == 0) continue;
/* open an incoming socket */
s = open_socket_in(SOCK_STREAM, port, 0,
interpret_addr(lp_socket_address()),True);
if (s == -1)
return(False);
/* ready to listen */
#ifndef _XBOX
set_socket_options(s,"SO_KEEPALIVE");
#endif
set_socket_options(s,user_socket_options);
/* Set server socket to non-blocking for the accept. */
set_blocking(s,False);
if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
DEBUG(0,("open_sockets_smbd: listen: %s\n",
strerror(errno)));
close(s);
return False;
}
fd_listenset[num_sockets] = s;
FD_SET(s,&listen_set);
maxfd = MAX( maxfd, s);
num_sockets++;
if (num_sockets >= FD_SETSIZE) {
DEBUG(0,("open_sockets_smbd: Too many sockets to bind to\n"));
return False;
}
}
}
SAFE_FREE(ports);
/* Listen to messages */
message_register(MSG_SMB_SAM_SYNC, msg_sam_sync);
message_register(MSG_SMB_SAM_REPL, msg_sam_repl);
message_register(MSG_SHUTDOWN, msg_exit_server);
message_register(MSG_SMB_FILE_RENAME, msg_file_was_renamed);
message_register(MSG_SMB_CONF_UPDATED, smb_conf_updated);
#ifdef DEVELOPER
message_register(MSG_SMB_INJECT_FAULT, msg_inject_fault);
#endif
/* now accept incoming connections - forking a new process
for each incoming connection */
DEBUG(2,("waiting for a connection\n"));
while (1) {
fd_set lfds;
int num;
/* Free up temporary memory from the main smbd. */
lp_TALLOC_FREE();
/* Ensure we respond to PING and DEBUG messages from the main smbd. */
message_dispatch();
memcpy((char *)&lfds, (char *)&listen_set,
sizeof(listen_set));
num = sys_select(maxfd+1,&lfds,NULL,NULL,NULL);
if (num == -1 && errno == EINTR) {
if (got_sig_term) {
exit_server_cleanly(NULL);
}
/* check for sighup processing */
if (reload_after_sighup) {
change_to_root_user();
DEBUG(1,("Reloading services after SIGHUP\n"));
reload_services(False);
reload_after_sighup = 0;
}
continue;
}
/* check if we need to reload services */
check_reload(time(NULL));
/* Find the sockets that are read-ready -
accept on these. */
for( ; num > 0; num--) {
struct sockaddr addr;
socklen_t in_addrlen = sizeof(addr);
s = -1;
for(i = 0; i < num_sockets; i++) {
if(FD_ISSET(fd_listenset[i],&lfds)) {
s = fd_listenset[i];
/* Clear this so we don't look
at it again. */
FD_CLR(fd_listenset[i],&lfds);
break;
}
}
smbd_set_server_fd(accept(s,&addr,&in_addrlen));
if (smbd_server_fd() == -1 && errno == EINTR)
continue;
if (smbd_server_fd() == -1) {
DEBUG(0,("open_sockets_smbd: accept: %s\n",
strerror(errno)));
continue;
}
/* Ensure child is set to blocking mode */
set_blocking(smbd_server_fd(),True);
if (smbd_server_fd() != -1 && interactive) {
#ifdef _XBOX
xb_IncClientCount();
#endif
return True;
}
if (allowable_number_of_smbd_processes() && smbd_server_fd() != -1 && sys_fork()==0) {
/* Child code ... */
/* close the listening socket(s) */
for(i = 0; i < num_sockets; i++)
close(fd_listenset[i]);
/* close our standard file
descriptors */
close_low_fds(False);
am_parent = 0;
set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
set_socket_options(smbd_server_fd(),user_socket_options);
/* this is needed so that we get decent entries
in smbstatus for port 445 connects */
set_remote_machine_name(get_peer_addr(smbd_server_fd()), False);
/* Reset the state of the random
* number generation system, so
* children do not get the same random
* numbers as each other */
set_need_random_reseed();
/* tdb needs special fork handling - remove CLEAR_IF_FIRST flags */
if (tdb_reopen_all(1) == -1) {
DEBUG(0,("tdb_reopen_all failed.\n"));
smb_panic("tdb_reopen_all failed.");
}
return True;
}
/* The parent doesn't need this socket */
close(smbd_server_fd());
/* Sun May 6 18:56:14 2001 [email protected]:
Clear the closed fd info out of server_fd --
and more importantly, out of client_fd in
util_sock.c, to avoid a possible
getpeername failure if we reopen the logs
and use %I in the filename.
*/
smbd_set_server_fd(-1);
/* Force parent to check log size after
* spawning child. Fix from
* [email protected]. The
* parent smbd will log to logserver.smb. It
* writes only two messages for each child
* started/finished. But each child writes,
* say, 50 messages also in logserver.smb,
* begining with the debug_count of the
* parent, before the child opens its own log
* file logserver.client. In a worst case
* scenario the size of logserver.smb would be
* checked after about 50*50=2500 messages
* (ca. 100kb).
* */
force_check_log_size();
} /* end for num */
} /* end while 1 */
/* NOTREACHED return True; */
}
static void onefs_smb_statistics_end(struct smb_perfcount_data *pcd)
{
struct onefs_stats_context *ctxt = pcd->context;
struct onefs_op_counter *tmp;
uint64_t uid;
static in_addr_t rem_addr = 0;
static in_addr_t loc_addr = 0;
/* not enabled */
if (pcd->context == NULL)
return;
uid = current_user.ut.uid ? current_user.ut.uid : ISC_UNKNOWN_CLIENT_ID;
/* get address info once, doesn't change for process */
if (rem_addr == 0) {
#error Isilon, please remove this after testing the code below
char *addr;
addr = talloc_sub_basic(talloc_tos(), "", "", "%I");
if (addr != NULL) {
rem_addr = interpret_addr(addr);
TALLOC_FREE(addr);
} else {
rem_addr = ISC_MASKED_ADDR;
}
addr = talloc_sub_basic(talloc_tos(), "", "", "%i");
if (addr != NULL) {
loc_addr = interpret_addr(addr);
TALLOC_FREE(addr);
} else {
loc_addr = ISC_MASKED_ADDR;
}
}
/*
* bug here - we aren't getting the outlens right,
* when dealing w/ chained requests.
*/
for (tmp = ctxt->ops_chain; tmp; tmp = tmp->next) {
tmp->iod.out_bytes = ctxt->iod.out_bytes;
isc_cookie_init(&tmp->iod.cookie, rem_addr, loc_addr, uid);
ISP_OP_END(&tmp->iod);
#ifdef ONEFS_PERF_DEBUG
DEBUG(0,("******** Finalized CHAIN op %s uid %llu in:%llu"
", out:%llu\n",
onefs_stat_debug(&tmp->iod), uid,
tmp->iod.in_bytes, tmp->iod.out_bytes));
#endif
SAFE_FREE(DLIST_PREV(tmp));
}
isc_cookie_init(&ctxt->iod.cookie, rem_addr, loc_addr, uid);
ISP_OP_END(&ctxt->iod);
#ifdef ONEFS_PERF_DEBUG
DEBUG(0,("******** Finalized op %s uid %llu in:%llu, out:%llu\n",
onefs_stat_debug(&ctxt->iod), uid,
ctxt->iod.in_bytes, ctxt->iod.out_bytes));
#endif
if (ctxt->alloced)
SAFE_FREE(ctxt);
else
ZERO_STRUCTP(ctxt);
pcd->context = NULL;
}
