2007-10-31 02:22:24 +03:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
1996-05-04 11:50:46 +04:00
Main SMB server routines
2002-01-15 05:15:58 +03:00
Copyright ( C ) Andrew Tridgell 1992 - 1998
Copyright ( C ) Martin Pool 2002
2003-04-14 07:30:20 +04:00
Copyright ( C ) Jelmer Vernooij 2002 - 2003
2007-10-31 02:22:24 +03:00
Copyright ( C ) Volker Lendecke 1993 - 2007
Copyright ( C ) Jeremy Allison 1993 - 2007
1996-05-04 11:50:46 +04:00
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
2007-07-09 23:25:36 +04:00
the Free Software Foundation ; either version 3 of the License , or
1996-05-04 11:50:46 +04:00
( at your option ) any later version .
2007-10-31 02:22:24 +03:00
1996-05-04 11:50:46 +04:00
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
2007-10-31 02:22:24 +03:00
1996-05-04 11:50:46 +04:00
You should have received a copy of the GNU General Public License
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
1996-05-04 11:50:46 +04:00
*/
# include "includes.h"
2009-01-08 14:03:45 +03:00
# include "smbd/globals.h"
1996-05-04 11:50:46 +04:00
2006-04-26 19:41:25 +04:00
static_decl_rpc ;
1998-07-29 07:08:05 +04:00
# ifdef WITH_DFS
1998-03-04 04:50:47 +03:00
extern int dcelogin_atmost_once ;
1998-07-29 07:08:05 +04:00
# endif /* WITH_DFS */
1998-03-04 04:50:47 +03:00
2000-04-11 17:55:53 +04:00
int smbd_server_fd ( void )
{
return server_fd ;
}
2002-07-15 14:35:28 +04:00
static void smbd_set_server_fd ( int fd )
2000-04-11 17:55:53 +04:00
{
server_fd = fd ;
}
2007-11-04 09:20:10 +03:00
int get_client_fd ( void )
{
return server_fd ;
}
2007-10-31 02:22:24 +03:00
2007-01-17 15:59:14 +03:00
struct event_context * smbd_event_context ( void )
{
2009-01-08 14:03:45 +03:00
if ( ! smbd_event_ctx ) {
smbd_event_ctx = event_context_init ( talloc_autofree_context ( ) ) ;
}
if ( ! smbd_event_ctx ) {
2007-06-16 01:58:49 +04:00
smb_panic ( " Could not init smbd event context " ) ;
2007-01-17 15:59:14 +03:00
}
2009-01-08 14:03:45 +03:00
return smbd_event_ctx ;
2007-01-17 15:59:14 +03:00
}
2007-01-31 17:28:08 +03:00
struct messaging_context * smbd_messaging_context ( void )
{
2009-01-08 14:03:45 +03:00
if ( smbd_msg_ctx = = NULL ) {
smbd_msg_ctx = messaging_init ( talloc_autofree_context ( ) ,
server_id_self ( ) ,
smbd_event_context ( ) ) ;
2008-06-23 19:35:08 +04:00
}
2009-01-08 14:03:45 +03:00
if ( smbd_msg_ctx = = NULL ) {
2008-06-23 19:32:32 +04:00
DEBUG ( 0 , ( " Could not init smbd messaging context. \n " ) ) ;
2007-01-31 17:28:08 +03:00
}
2009-01-08 14:03:45 +03:00
return smbd_msg_ctx ;
2007-01-31 17:28:08 +03:00
}
2007-12-18 11:41:03 +03:00
struct memcache * smbd_memcache ( void )
{
2009-01-08 14:03:45 +03:00
if ( ! smbd_memcache_ctx ) {
smbd_memcache_ctx = memcache_init ( talloc_autofree_context ( ) ,
lp_max_stat_cache_size ( ) * 1024 ) ;
}
if ( ! smbd_memcache_ctx ) {
2007-12-18 11:41:03 +03:00
smb_panic ( " Could not init smbd memcache " ) ;
}
2009-01-08 14:03:45 +03:00
return smbd_memcache_ctx ;
2007-12-18 11:41:03 +03:00
}
2006-02-04 01:19:41 +03:00
/*******************************************************************
What to do when smb . conf is updated .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-05-16 18:24:06 +04:00
static void smb_conf_updated ( struct messaging_context * msg ,
void * private_data ,
uint32_t msg_type ,
struct server_id server_id ,
DATA_BLOB * data )
2006-02-04 01:19:41 +03:00
{
2007-05-16 18:24:06 +04:00
DEBUG ( 10 , ( " smb_conf_updated: Got message saying smb.conf was "
" updated. Reloading. \n " ) ) ;
2006-02-04 01:19:41 +03:00
reload_services ( False ) ;
}
2007-01-20 00:46:12 +03:00
/*******************************************************************
Delete a statcache entry .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-05-16 18:24:06 +04:00
static void smb_stat_cache_delete ( struct messaging_context * msg ,
void * private_data ,
uint32_t msg_tnype ,
struct server_id server_id ,
DATA_BLOB * data )
2007-01-20 00:46:12 +03:00
{
2007-05-16 18:24:06 +04:00
const char * name = ( const char * ) data - > data ;
2007-01-20 00:46:12 +03:00
DEBUG ( 10 , ( " smb_stat_cache_delete: delete name %s \n " , name ) ) ;
stat_cache_delete ( name ) ;
}
1996-12-10 21:00:22 +03:00
/****************************************************************************
Send a SIGTERM to our process group .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2002-03-14 05:15:08 +03:00
1998-09-05 09:07:05 +04:00
static void killkids ( void )
1996-12-10 21:00:22 +03:00
{
1998-08-17 18:11:44 +04:00
if ( am_parent ) kill ( 0 , SIGTERM ) ;
1996-12-10 21:00:22 +03:00
}
1996-05-04 11:50:46 +04:00
2001-08-28 10:34:53 +04:00
/****************************************************************************
2002-03-14 05:15:08 +03:00
Process a sam sync message - not sure whether to do this here or
somewhere else .
2001-08-28 10:34:53 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2002-03-14 05:15:08 +03:00
2007-05-16 18:24:06 +04:00
static void msg_sam_sync ( struct messaging_context * msg ,
void * private_data ,
uint32_t msg_type ,
struct server_id server_id ,
DATA_BLOB * data )
2001-08-28 10:34:53 +04:00
{
DEBUG ( 10 , ( " ** sam sync message received, ignoring \n " ) ) ;
}
2007-05-16 18:24:06 +04:00
static void msg_exit_server ( struct messaging_context * msg ,
void * private_data ,
uint32_t msg_type ,
struct server_id server_id ,
DATA_BLOB * data )
2002-03-29 17:28:38 +03:00
{
2006-04-04 04:27:50 +04:00
DEBUG ( 3 , ( " got a SHUTDOWN message \n " ) ) ;
2006-04-11 02:47:09 +04:00
exit_server_cleanly ( NULL ) ;
2006-04-04 04:27:50 +04:00
}
# ifdef DEVELOPER
2007-05-16 18:24:06 +04:00
static void msg_inject_fault ( struct messaging_context * msg ,
void * private_data ,
uint32_t msg_type ,
struct server_id src ,
DATA_BLOB * data )
2006-04-04 04:27:50 +04:00
{
int sig ;
2007-05-16 18:24:06 +04:00
if ( data - > length ! = sizeof ( sig ) ) {
2006-04-04 04:27:50 +04:00
2007-05-16 18:24:06 +04:00
DEBUG ( 0 , ( " Process %s sent bogus signal injection request \n " ,
procid_str_static ( & src ) ) ) ;
2006-04-04 04:27:50 +04:00
return ;
}
2007-05-16 18:24:06 +04:00
sig = * ( int * ) data - > data ;
2006-04-04 04:27:50 +04:00
if ( sig = = - 1 ) {
exit_server ( " internal error injected " ) ;
return ;
}
# if HAVE_STRSIGNAL
2007-05-16 18:24:06 +04:00
DEBUG ( 0 , ( " Process %s requested injection of signal %d (%s) \n " ,
procid_str_static ( & src ) , sig , strsignal ( sig ) ) ) ;
2006-04-04 04:27:50 +04:00
# else
2007-05-16 18:24:06 +04:00
DEBUG ( 0 , ( " Process %s requested injection of signal %d \n " ,
procid_str_static ( & src ) , sig ) ) ;
2006-04-04 04:27:50 +04:00
# endif
kill ( sys_getpid ( ) , sig ) ;
2002-03-29 17:28:38 +03:00
}
2006-04-04 04:27:50 +04:00
# endif /* DEVELOPER */
2002-03-29 17:28:38 +03:00
2006-08-16 14:36:19 +04:00
struct child_pid {
struct child_pid * prev , * next ;
pid_t pid ;
} ;
static void add_child_pid ( pid_t pid )
{
struct child_pid * child ;
if ( lp_max_smbd_processes ( ) = = 0 ) {
/* Don't bother with the child list if we don't care anyway */
return ;
}
child = SMB_MALLOC_P ( struct child_pid ) ;
if ( child = = NULL ) {
DEBUG ( 0 , ( " Could not add child struct -- malloc failed \n " ) ) ;
return ;
}
child - > pid = pid ;
DLIST_ADD ( children , child ) ;
num_children + = 1 ;
}
2008-01-16 12:09:48 +03:00
static void remove_child_pid ( pid_t pid , bool unclean_shutdown )
2006-08-16 14:36:19 +04:00
{
struct child_pid * child ;
2008-01-16 12:09:48 +03:00
if ( unclean_shutdown ) {
/* a child terminated uncleanly so tickle all processes to see
if they can grab any of the pending locks
*/
2009-02-24 03:22:43 +03:00
DEBUG ( 3 , ( __location__ " Unclean shutdown of pid %u \n " , ( unsigned int ) pid ) ) ;
2008-01-16 12:09:48 +03:00
messaging_send_buf ( smbd_messaging_context ( ) , procid_self ( ) ,
MSG_SMB_BRL_VALIDATE , NULL , 0 ) ;
message_send_all ( smbd_messaging_context ( ) ,
MSG_SMB_UNLOCK , NULL , 0 , NULL ) ;
}
2006-08-16 14:36:19 +04:00
if ( lp_max_smbd_processes ( ) = = 0 ) {
/* Don't bother with the child list if we don't care anyway */
return ;
}
for ( child = children ; child ! = NULL ; child = child - > next ) {
if ( child - > pid = = pid ) {
struct child_pid * tmp = child ;
DLIST_REMOVE ( children , child ) ;
SAFE_FREE ( tmp ) ;
num_children - = 1 ;
return ;
}
}
DEBUG ( 0 , ( " Could not find child %d -- ignoring \n " , ( int ) pid ) ) ;
}
1997-09-25 04:25:44 +04:00
2003-02-06 00:16:55 +03:00
/****************************************************************************
Have we reached the process limit ?
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
static bool allowable_number_of_smbd_processes ( void )
2003-02-06 00:16:55 +03:00
{
int max_processes = lp_max_smbd_processes ( ) ;
if ( ! max_processes )
return True ;
2006-08-16 14:36:19 +04:00
return num_children < max_processes ;
2003-02-06 00:16:55 +03:00
}
2009-01-22 01:24:18 +03:00
static void smbd_sig_chld_handler ( struct tevent_context * ev ,
struct tevent_signal * se ,
int signum ,
int count ,
void * siginfo ,
void * private_data )
{
pid_t pid ;
int status ;
while ( ( pid = sys_waitpid ( - 1 , & status , WNOHANG ) ) > 0 ) {
bool unclean_shutdown = False ;
/* If the child terminated normally, assume
it was an unclean shutdown unless the
status is 0
*/
if ( WIFEXITED ( status ) ) {
unclean_shutdown = WEXITSTATUS ( status ) ;
}
/* If the child terminated due to a signal
we always assume it was unclean .
*/
if ( WIFSIGNALED ( status ) ) {
unclean_shutdown = True ;
}
remove_child_pid ( pid , unclean_shutdown ) ;
}
}
static void smbd_setup_sig_chld_handler ( void )
{
struct tevent_signal * se ;
se = tevent_add_signal ( smbd_event_context ( ) ,
smbd_event_context ( ) ,
SIGCHLD , 0 ,
smbd_sig_chld_handler ,
NULL ) ;
if ( ! se ) {
exit_server ( " failed to setup SIGCHLD handler " ) ;
}
}
2009-01-27 12:02:43 +03:00
struct smbd_open_socket ;
struct smbd_parent_context {
bool interactive ;
/* the list of listening sockets */
struct smbd_open_socket * sockets ;
} ;
struct smbd_open_socket {
struct smbd_open_socket * prev , * next ;
struct smbd_parent_context * parent ;
int fd ;
struct tevent_fd * fde ;
} ;
static void smbd_open_socket_close_fn ( struct tevent_context * ev ,
struct tevent_fd * fde ,
int fd ,
void * private_data )
{
/* this might be the socket_wrapper swrap_close() */
close ( fd ) ;
}
static void smbd_accept_connection ( struct tevent_context * ev ,
struct tevent_fd * fde ,
uint16_t flags ,
void * private_data )
{
struct smbd_open_socket * s = talloc_get_type_abort ( private_data ,
struct smbd_open_socket ) ;
struct sockaddr_storage addr ;
socklen_t in_addrlen = sizeof ( addr ) ;
pid_t pid = 0 ;
smbd_set_server_fd ( accept ( s - > fd , ( struct sockaddr * ) & addr , & in_addrlen ) ) ;
if ( smbd_server_fd ( ) = = - 1 & & errno = = EINTR )
return ;
if ( smbd_server_fd ( ) = = - 1 ) {
DEBUG ( 0 , ( " open_sockets_smbd: accept: %s \n " ,
strerror ( errno ) ) ) ;
return ;
}
if ( s - > parent - > interactive ) {
smbd_process ( ) ;
exit_server_cleanly ( " end of interactive mode " ) ;
return ;
}
if ( ! allowable_number_of_smbd_processes ( ) ) {
close ( smbd_server_fd ( ) ) ;
smbd_set_server_fd ( - 1 ) ;
return ;
}
pid = sys_fork ( ) ;
if ( pid = = 0 ) {
/* Child code ... */
am_parent = 0 ;
/* Stop zombies, the parent explicitly handles
* them , counting worker smbds . */
CatchChild ( ) ;
/* close our standard file
descriptors */
close_low_fds ( False ) ;
2009-02-14 10:07:29 +03:00
/*
* Can ' t use TALLOC_FREE here . Nulling out the argument to it
* would overwrite memory we ' ve just freed .
*/
talloc_free ( s - > parent ) ;
2009-01-27 12:02:43 +03:00
s = NULL ;
if ( ! reinit_after_fork (
smbd_messaging_context ( ) ,
smbd_event_context ( ) ,
true ) ) {
DEBUG ( 0 , ( " reinit_after_fork() failed \n " ) ) ;
smb_panic ( " reinit_after_fork() failed " ) ;
}
smbd_setup_sig_term_handler ( ) ;
smbd_setup_sig_hup_handler ( ) ;
smbd_process ( ) ;
exit_server_cleanly ( " end of child " ) ;
return ;
} else if ( pid < 0 ) {
DEBUG ( 0 , ( " smbd_accept_connection: sys_fork() failed: %s \n " ,
strerror ( errno ) ) ) ;
}
/* The parent doesn't need this socket */
close ( smbd_server_fd ( ) ) ;
/* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
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 ) ;
if ( pid ! = 0 ) {
add_child_pid ( pid ) ;
}
/* Force parent to check log size after
* spawning child . Fix from
* klausr @ ITAP . Physik . Uni - Stuttgart . De . 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 . 100 kb ) .
* */
force_check_log_size ( ) ;
}
2009-01-29 17:42:10 +03:00
static bool smbd_open_one_socket ( struct smbd_parent_context * parent ,
const struct sockaddr_storage * ifss ,
uint16_t port )
2009-01-27 12:02:43 +03:00
{
struct smbd_open_socket * s ;
s = talloc ( parent , struct smbd_open_socket ) ;
if ( ! s ) {
return false ;
}
s - > parent = parent ;
s - > fd = open_socket_in ( SOCK_STREAM ,
port ,
parent - > sockets = = NULL ? 0 : 2 ,
ifss ,
true ) ;
if ( s - > fd = = - 1 ) {
DEBUG ( 0 , ( " smbd_open_once_socket: open_socket_in: "
" %s \n " , strerror ( errno ) ) ) ;
TALLOC_FREE ( s ) ;
2009-01-29 17:30:38 +03:00
/*
* We ignore an error here , as we ' ve done before
*/
return true ;
2009-01-27 12:02:43 +03:00
}
/* ready to listen */
set_socket_options ( s - > fd , " SO_KEEPALIVE " ) ;
set_socket_options ( s - > fd , lp_socket_options ( ) ) ;
/* Set server socket to
* non - blocking for the accept . */
set_blocking ( s - > fd , False ) ;
if ( listen ( s - > fd , SMBD_LISTEN_BACKLOG ) = = - 1 ) {
DEBUG ( 0 , ( " open_sockets_smbd: listen: "
" %s \n " , strerror ( errno ) ) ) ;
close ( s - > fd ) ;
TALLOC_FREE ( s ) ;
return false ;
}
s - > fde = tevent_add_fd ( smbd_event_context ( ) ,
s ,
s - > fd , TEVENT_FD_READ ,
smbd_accept_connection ,
s ) ;
if ( ! s - > fde ) {
DEBUG ( 0 , ( " open_sockets_smbd: "
" tevent_add_fd: %s \n " ,
strerror ( errno ) ) ) ;
close ( s - > fd ) ;
TALLOC_FREE ( s ) ;
return false ;
}
tevent_fd_set_close_fn ( s - > fde , smbd_open_socket_close_fn ) ;
DLIST_ADD_END ( parent - > sockets , s , struct smbd_open_socket * ) ;
return true ;
}
2007-04-21 01:09:44 +04:00
/****************************************************************************
Open the socket communication .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-01-27 12:02:43 +03:00
static bool open_sockets_smbd ( struct smbd_parent_context * parent ,
const char * smb_ports )
2007-04-21 01:09:44 +04:00
{
2007-10-11 00:34:30 +04:00
int num_interfaces = iface_count ( ) ;
2007-04-21 01:09:44 +04:00
int i ;
2007-10-11 00:34:30 +04:00
char * ports ;
2007-12-14 07:56:29 +03:00
unsigned dns_port = 0 ;
2007-04-21 01:09:44 +04:00
# ifdef HAVE_ATEXIT
2009-01-08 13:52:52 +03:00
atexit ( killkids ) ;
2007-04-21 01:09:44 +04:00
# endif
/* Stop zombies */
2009-01-22 01:24:18 +03:00
smbd_setup_sig_chld_handler ( ) ;
2007-10-25 01:16:54 +04:00
2007-10-11 00:34:30 +04:00
/* use a reasonable default set of ports - listing on 445 and 139 */
if ( ! smb_ports ) {
ports = lp_smb_ports ( ) ;
if ( ! ports | | ! * ports ) {
2009-01-27 12:02:43 +03:00
ports = talloc_strdup ( talloc_tos ( ) , SMB_PORTS ) ;
2007-10-11 00:34:30 +04:00
} else {
2009-01-27 12:02:43 +03:00
ports = talloc_strdup ( talloc_tos ( ) , ports ) ;
2007-10-11 00:34:30 +04:00
}
} else {
2009-01-27 12:02:43 +03:00
ports = talloc_strdup ( talloc_tos ( ) , smb_ports ) ;
2007-04-21 01:09:44 +04:00
}
2007-10-11 00:34:30 +04:00
if ( lp_interfaces ( ) & & lp_bind_interfaces_only ( ) ) {
2007-10-25 01:16:54 +04:00
/* We have been given an interfaces line, and been
2007-10-11 00:34:30 +04:00
told to only bind to those interfaces . Create a
socket per interface and bind to only these .
*/
2007-10-25 01:16:54 +04:00
2007-10-11 00:34:30 +04:00
/* Now open a listen socket for each of the
interfaces . */
for ( i = 0 ; i < num_interfaces ; i + + ) {
2007-10-11 05:25:16 +04:00
const struct sockaddr_storage * ifss =
iface_n_sockaddr_storage ( i ) ;
2007-12-08 04:32:32 +03:00
char * tok ;
2007-10-11 00:34:30 +04:00
const char * ptr ;
2007-10-11 05:25:16 +04:00
if ( ifss = = NULL ) {
2007-10-25 01:16:54 +04:00
DEBUG ( 0 , ( " open_sockets_smbd: "
" interface %d has NULL IP address ! \n " ,
i ) ) ;
2007-10-11 00:34:30 +04:00
continue ;
}
2007-12-08 04:32:32 +03:00
for ( ptr = ports ;
2009-01-27 12:02:43 +03:00
next_token_talloc ( talloc_tos ( ) , & ptr , & tok , " \t , " ) ; ) {
2007-10-11 00:34:30 +04:00
unsigned port = atoi ( tok ) ;
if ( port = = 0 | | port > 0xffff ) {
continue ;
}
2007-12-14 07:56:29 +03:00
2009-01-27 12:02:43 +03:00
if ( ! smbd_open_one_socket ( parent , ifss , port ) ) {
return false ;
2007-10-11 00:34:30 +04:00
}
}
}
} else {
/* Just bind to 0.0.0.0 - accept connections
from anywhere . */
2007-12-08 04:32:32 +03:00
char * tok ;
2007-10-11 00:34:30 +04:00
const char * ptr ;
2007-10-25 01:16:54 +04:00
const char * sock_addr = lp_socket_address ( ) ;
2007-12-08 04:32:32 +03:00
char * sock_tok ;
2007-10-25 01:16:54 +04:00
const char * sock_ptr ;
2008-12-06 00:37:51 +03:00
if ( strequal ( sock_addr , " 0.0.0.0 " ) | |
strequal ( sock_addr , " :: " ) ) {
2007-10-25 01:16:54 +04:00
# if HAVE_IPV6
sock_addr = " ::,0.0.0.0 " ;
# else
sock_addr = " 0.0.0.0 " ;
# endif
}
2007-10-11 00:34:30 +04:00
2007-12-08 04:32:32 +03:00
for ( sock_ptr = sock_addr ;
2009-01-27 12:02:43 +03:00
next_token_talloc ( talloc_tos ( ) , & sock_ptr , & sock_tok , " \t , " ) ; ) {
for ( ptr = ports ; next_token_talloc ( talloc_tos ( ) , & ptr , & tok , " \t , " ) ; ) {
2007-10-25 01:16:54 +04:00
struct sockaddr_storage ss ;
unsigned port = atoi ( tok ) ;
if ( port = = 0 | | port > 0xffff ) {
continue ;
}
2007-12-14 07:56:29 +03:00
/* Keep the first port for mDNS service
* registration .
*/
if ( dns_port = = 0 ) {
dns_port = port ;
}
2007-10-25 01:16:54 +04:00
/* open an incoming socket */
if ( ! interpret_string_addr ( & ss , sock_tok ,
AI_NUMERICHOST | AI_PASSIVE ) ) {
2007-10-25 03:11:01 +04:00
continue ;
2007-10-25 01:16:54 +04:00
}
2007-10-11 00:34:30 +04:00
2009-01-27 12:02:43 +03:00
if ( ! smbd_open_one_socket ( parent , & ss , port ) ) {
return false ;
2007-10-25 01:16:54 +04:00
}
2007-10-11 00:34:30 +04:00
}
}
2007-10-25 01:16:54 +04:00
}
2007-10-11 00:34:30 +04:00
2009-01-27 12:02:43 +03:00
if ( parent - > sockets = = NULL ) {
2007-10-26 01:11:35 +04:00
DEBUG ( 0 , ( " open_sockets_smbd: No "
" sockets available to bind to. \n " ) ) ;
return false ;
}
2007-07-24 14:35:10 +04:00
/* Setup the main smbd so that we can get messages. Note that
do this after starting listening . This is needed as when in
clustered mode , ctdb won ' t allow us to start doing database
operations until it has gone thru a full startup , which
includes checking to see that smbd is listening . */
2008-04-01 16:01:28 +04:00
claim_connection ( NULL , " " ,
FLAG_MSG_GENERAL | FLAG_MSG_SMBD | FLAG_MSG_DBWRAP ) ;
2007-07-24 14:35:10 +04:00
2001-08-28 10:34:53 +04:00
/* Listen to messages */
2007-05-16 18:24:06 +04:00
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 ,
2007-10-25 01:16:54 +04:00
MSG_SMB_CONF_UPDATED , smb_conf_updated ) ;
2007-05-16 18:24:06 +04:00
messaging_register ( smbd_messaging_context ( ) , NULL ,
MSG_SMB_STAT_CACHE_DELETE , smb_stat_cache_delete ) ;
2007-05-29 18:49:19 +04:00
brl_register_msgs ( smbd_messaging_context ( ) ) ;
2001-08-28 10:34:53 +04:00
2008-08-08 14:31:03 +04:00
# ifdef CLUSTER_SUPPORT
2008-08-11 18:30:36 +04:00
if ( lp_clustering ( ) ) {
ctdbd_register_reconfigure ( messaging_ctdbd_connection ( ) ) ;
}
2008-08-08 14:31:03 +04:00
# endif
2006-04-04 04:27:50 +04:00
# ifdef DEVELOPER
2007-05-16 18:24:06 +04:00
messaging_register ( smbd_messaging_context ( ) , NULL ,
MSG_SMB_INJECT_FAULT , msg_inject_fault ) ;
2006-04-04 04:27:50 +04:00
# endif
2009-01-26 16:55:54 +03:00
if ( dns_port ! = 0 ) {
smbd_setup_mdns_registration ( smbd_event_context ( ) ,
2009-01-27 12:02:43 +03:00
parent , dns_port ) ;
2009-01-26 16:55:54 +03:00
}
2009-01-27 12:02:43 +03:00
return true ;
}
static void smbd_parent_loop ( struct smbd_parent_context * parent )
{
1998-08-17 18:11:44 +04:00
/* now accept incoming connections - forking a new process
for each incoming connection */
DEBUG ( 2 , ( " waiting for a connection \n " ) ) ;
while ( 1 ) {
2007-10-11 00:34:30 +04:00
struct timeval now , idle_timeout ;
2007-05-30 17:41:38 +04:00
fd_set r_fds , w_fds ;
2009-01-27 12:02:43 +03:00
int maxfd = 0 ;
1998-08-17 18:11:44 +04:00
int num ;
2009-01-27 12:02:43 +03:00
TALLOC_CTX * frame = talloc_stackframe ( ) ;
2007-10-25 01:16:54 +04:00
2009-01-20 06:14:20 +03:00
if ( run_events ( smbd_event_context ( ) , 0 , NULL , NULL ) ) {
2009-01-27 12:02:43 +03:00
TALLOC_FREE ( frame ) ;
2009-01-20 06:14:20 +03:00
continue ;
}
2007-10-11 00:34:30 +04:00
idle_timeout = timeval_zero ( ) ;
2007-05-30 17:41:38 +04:00
FD_ZERO ( & w_fds ) ;
2009-01-27 12:02:43 +03:00
FD_ZERO ( & r_fds ) ;
2007-05-30 17:41:38 +04:00
GetTimeOfDay ( & now ) ;
2007-04-21 01:09:44 +04:00
2007-05-30 17:41:38 +04:00
event_add_to_select_args ( smbd_event_context ( ) , & now ,
& r_fds , & w_fds , & idle_timeout ,
& maxfd ) ;
2007-10-11 00:34:30 +04:00
num = sys_select ( maxfd + 1 , & r_fds , & w_fds , NULL ,
timeval_is_zero ( & idle_timeout ) ?
NULL : & idle_timeout ) ;
2007-06-14 22:48:51 +04:00
2009-01-27 12:02:43 +03:00
/* check if we need to reload services */
check_reload ( time ( NULL ) ) ;
2009-01-20 06:14:20 +03:00
if ( run_events ( smbd_event_context ( ) , num , & r_fds , & w_fds ) ) {
2009-01-27 12:02:43 +03:00
TALLOC_FREE ( frame ) ;
2009-01-20 06:14:20 +03:00
continue ;
}
2009-02-12 11:11:38 +03:00
/* socket error */
if ( num < 0 )
exit_server_cleanly ( " socket error " ) ;
2009-01-27 12:02:43 +03:00
TALLOC_FREE ( frame ) ;
1998-08-17 18:11:44 +04:00
} /* end while 1 */
1998-08-28 00:38:53 +04:00
/* NOTREACHED return True; */
1997-11-19 02:30:49 +03:00
}
2005-01-05 19:20:35 +03:00
/****************************************************************************
Reload printers
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void reload_printers ( void )
{
int snum ;
int n_services = lp_numservices ( ) ;
int pnum = lp_servicenumber ( PRINTERS_NAME ) ;
const char * pname ;
pcap_cache_reload ( ) ;
/* remove stale printers */
for ( snum = 0 ; snum < n_services ; snum + + ) {
/* avoid removing PRINTERS_NAME or non-autoloaded printers */
if ( snum = = pnum | | ! ( lp_snum_ok ( snum ) & & lp_print_ok ( snum ) & &
lp_autoloaded ( snum ) ) )
continue ;
pname = lp_printername ( snum ) ;
if ( ! pcap_printername_ok ( pname ) ) {
DEBUG ( 3 , ( " removing stale printer %s \n " , pname ) ) ;
if ( is_printer_published ( NULL , snum , NULL ) )
2009-02-27 01:40:58 +03:00
nt_printer_publish ( NULL , snum , DSPRINT_UNPUBLISH ) ;
2005-01-05 19:20:35 +03:00
del_a_printer ( pname ) ;
lp_killservice ( snum ) ;
}
}
load_printers ( ) ;
}
1996-05-04 11:50:46 +04:00
/****************************************************************************
2002-03-14 05:15:08 +03:00
Reload the services file .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
bool reload_services ( bool test )
1996-05-04 11:50:46 +04:00
{
2007-10-19 04:40:25 +04:00
bool ret ;
2007-12-07 23:26:32 +03:00
1998-08-14 21:38:29 +04:00
if ( lp_loaded ( ) ) {
2007-11-12 08:46:52 +03:00
char * fname = lp_configfile ( ) ;
2008-10-17 14:48:19 +04:00
if ( file_exist ( fname ) & &
2007-12-10 22:30:37 +03:00
! strcsequal ( fname , get_dyn_CONFIGFILE ( ) ) ) {
set_dyn_CONFIGFILE ( fname ) ;
1998-08-17 17:11:34 +04:00
test = False ;
1998-08-14 21:38:29 +04:00
}
}
1996-05-04 11:50:46 +04:00
1998-08-17 17:11:34 +04:00
reopen_logs ( ) ;
1996-05-04 11:50:46 +04:00
1998-08-17 17:11:34 +04:00
if ( test & & ! lp_file_list_changed ( ) )
return ( True ) ;
1996-05-04 11:50:46 +04:00
1998-08-17 17:11:34 +04:00
lp_killunused ( conn_snum_used ) ;
2004-11-12 20:39:32 +03:00
2007-12-10 22:30:37 +03:00
ret = lp_load ( get_dyn_CONFIGFILE ( ) , False , False , True , True ) ;
1996-05-04 11:50:46 +04:00
2005-01-05 19:20:35 +03:00
reload_printers ( ) ;
1996-05-04 11:50:46 +04:00
1998-08-17 17:11:34 +04:00
/* perhaps the config filename is now set */
if ( ! test )
reload_services ( True ) ;
1997-10-08 04:21:39 +04:00
1998-08-17 17:11:34 +04:00
reopen_logs ( ) ;
1996-05-04 11:50:46 +04:00
1998-08-17 17:11:34 +04:00
load_interfaces ( ) ;
1996-05-04 11:50:46 +04:00
2007-12-07 23:26:32 +03:00
if ( smbd_server_fd ( ) ! = - 1 ) {
2004-06-15 22:36:45 +04:00
set_socket_options ( smbd_server_fd ( ) , " SO_KEEPALIVE " ) ;
2007-11-01 20:13:00 +03:00
set_socket_options ( smbd_server_fd ( ) , lp_socket_options ( ) ) ;
1998-08-14 21:38:29 +04:00
}
1998-01-31 17:31:08 +03:00
2002-04-11 06:20:56 +04:00
mangle_reset_cache ( ) ;
2000-05-10 15:45:16 +04:00
reset_stat_cache ( ) ;
1998-01-31 17:31:08 +03:00
1998-08-17 17:11:34 +04:00
/* this forces service parameters to be flushed */
2004-06-15 22:36:45 +04:00
set_current_service ( NULL , 0 , True ) ;
1998-01-31 17:31:08 +03:00
1998-08-17 17:11:34 +04:00
return ( ret ) ;
1998-01-31 17:31:08 +03:00
}
1996-05-04 11:50:46 +04:00
/****************************************************************************
2002-03-14 05:15:08 +03:00
Exit the server .
1996-05-04 11:50:46 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2002-03-14 05:15:08 +03:00
2006-04-04 04:27:50 +04:00
/* Reasons for shutting down a server process. */
enum server_exit_reason { SERVER_EXIT_NORMAL , SERVER_EXIT_ABNORMAL } ;
static void exit_server_common ( enum server_exit_reason how ,
2008-10-18 23:45:49 +04:00
const char * const reason ) _NORETURN_ ;
2006-04-04 04:27:50 +04:00
static void exit_server_common ( enum server_exit_reason how ,
const char * const reason )
1996-05-04 11:50:46 +04:00
{
2008-08-08 16:34:59 +04:00
bool had_open_conn ;
1996-05-04 11:50:46 +04:00
2009-01-08 14:03:45 +03:00
if ( ! exit_firsttime )
2001-10-19 00:15:12 +04:00
exit ( 0 ) ;
2009-01-08 14:03:45 +03:00
exit_firsttime = false ;
1998-08-17 10:13:32 +04:00
2001-10-19 00:15:12 +04:00
change_to_root_user ( ) ;
1998-08-17 18:11:44 +04:00
2002-01-05 07:55:41 +03:00
if ( negprot_global_auth_context ) {
2002-01-09 10:52:51 +03:00
( negprot_global_auth_context - > free ) ( & negprot_global_auth_context ) ;
2002-01-05 07:55:41 +03:00
}
This is another rather major change to the samba authenticaion
subystem.
The particular aim is to modularized the interface - so that we
can have arbitrary password back-ends.
This code adds one such back-end, a 'winbind' module to authenticate
against the winbind_auth_crap functionality. While fully-functional
this code is mainly useful as a demonstration, because we don't get
back the info3 as we would for direct ntdomain authentication.
This commit introduced the new 'auth methods' parameter, in the
spirit of the 'auth order' discussed on the lists. It is renamed
because not all the methods may be consulted, even if previous
methods fail - they may not have a suitable challenge for example.
Also, we have a 'local' authentication method, for old-style
'unix if plaintext, sam if encrypted' authentication and a
'guest' module to handle guest logins in a single place.
While this current design is not ideal, I feel that it does
provide a better infrastructure than the current design, and can
be built upon.
The following parameters have changed:
- use rhosts =
This has been replaced by the 'rhosts' authentication method,
and can be specified like 'auth methods = guest rhosts'
- hosts equiv =
This needs both this parameter and an 'auth methods' entry
to be effective. (auth methods = guest hostsequiv ....)
- plaintext to smbpasswd =
This is replaced by specifying 'sam' rather than 'local'
in the auth methods.
The security = parameter is unchanged, and now provides defaults
for the 'auth methods' parameter.
The available auth methods are:
guest
rhosts
hostsequiv
sam (passdb direct hash access)
unix (PAM, crypt() etc)
local (the combination of the above, based on encryption)
smbserver (old security=server)
ntdomain (old security=domain)
winbind (use winbind to cache DC connections)
Assistance in testing, or the production of new and interesting
authentication modules is always appreciated.
Andrew Bartlett
(This used to be commit 8d31eae52a9757739711dbb82035a4dfe6b40c99)
2001-11-24 15:12:38 +03:00
2008-08-08 16:34:59 +04:00
had_open_conn = conn_close_all ( ) ;
1998-08-17 10:13:32 +04:00
2001-04-18 20:41:04 +04:00
invalidate_all_vuids ( ) ;
2007-05-15 00:31:28 +04:00
/* 3 second timeout. */
print_notify_send_messages ( smbd_messaging_context ( ) , 3 ) ;
2002-09-25 19:19:00 +04:00
2001-01-09 00:19:15 +03:00
/* delete our entry in the connections database. */
2002-01-14 22:34:28 +03:00
yield_connection ( NULL , " " ) ;
2001-01-09 00:19:15 +03:00
1998-07-29 07:08:05 +04:00
# ifdef WITH_DFS
1998-08-17 18:11:44 +04:00
if ( dcelogin_atmost_once ) {
dfs_unlogin ( ) ;
}
1996-05-04 11:50:46 +04:00
# endif
1998-08-17 18:11:44 +04:00
2008-04-08 15:19:01 +04:00
# ifdef USE_DMAPI
/* Destroy Samba DMAPI session only if we are master smbd process */
if ( am_parent ) {
if ( ! dmapi_destroy_session ( ) ) {
DEBUG ( 0 , ( " Unable to close Samba DMAPI session \n " ) ) ;
}
}
# endif
2006-04-04 04:27:50 +04:00
locking_end ( ) ;
printing_end ( ) ;
if ( how ! = SERVER_EXIT_NORMAL ) {
1998-08-17 18:11:44 +04:00
int oldlevel = DEBUGLEVEL ;
2006-04-04 04:27:50 +04:00
1998-08-17 18:11:44 +04:00
DEBUGLEVEL = 10 ;
2006-04-04 04:27:50 +04:00
DEBUGSEP ( 0 ) ;
DEBUG ( 0 , ( " Abnormal server exit: %s \n " ,
reason ? reason : " no explanation provided " ) ) ;
DEBUGSEP ( 0 ) ;
log_stack_trace ( ) ;
1998-08-17 18:11:44 +04:00
DEBUGLEVEL = oldlevel ;
2006-04-01 09:41:34 +04:00
dump_core ( ) ;
1997-01-09 21:02:17 +03:00
2006-04-04 04:27:50 +04:00
} else {
DEBUG ( 3 , ( " Server exit (%s) \n " ,
( reason ? reason : " normal exit " ) ) ) ;
}
1997-01-09 21:02:17 +03:00
2008-08-08 16:47:04 +04:00
/* if we had any open SMB connections when we exited then we
need to tell the parent smbd so that it can trigger a retry
of any locks we may have been holding or open files we were
blocking */
2008-08-08 16:34:59 +04:00
if ( had_open_conn ) {
exit ( 1 ) ;
} else {
exit ( 0 ) ;
}
1996-05-04 11:50:46 +04:00
}
2006-04-04 04:27:50 +04:00
void exit_server ( const char * const explanation )
{
exit_server_common ( SERVER_EXIT_ABNORMAL , explanation ) ;
}
2006-04-11 02:47:09 +04:00
void exit_server_cleanly ( const char * const explanation )
2006-04-04 04:27:50 +04:00
{
2006-04-11 02:47:09 +04:00
exit_server_common ( SERVER_EXIT_NORMAL , explanation ) ;
2006-04-04 04:27:50 +04:00
}
void exit_server_fault ( void )
{
exit_server ( " critical server fault " ) ;
}
1996-05-04 11:50:46 +04:00
/****************************************************************************
2002-03-14 05:15:08 +03:00
Initialise connect , service and file structs .
1996-05-04 11:50:46 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2002-03-14 05:15:08 +03:00
2007-10-19 04:40:25 +04:00
static bool init_structs ( void )
1996-05-04 11:50:46 +04:00
{
1999-12-13 16:27:58 +03:00
/*
* Set the machine NETBIOS name if not already
* set from the config file .
*/
2002-11-13 02:20:50 +03:00
if ( ! init_names ( ) )
return False ;
1999-12-13 16:27:58 +03:00
1998-08-17 18:11:44 +04:00
conn_init ( ) ;
1999-12-13 16:27:58 +03:00
1998-08-17 18:11:44 +04:00
file_init ( ) ;
1999-12-13 16:27:58 +03:00
1998-08-17 18:11:44 +04:00
init_dptrs ( ) ;
2000-05-08 14:42:21 +04:00
2008-02-18 02:21:50 +03:00
if ( ! secrets_init ( ) )
return False ;
2002-01-26 09:24:53 +03:00
2002-11-13 02:20:50 +03:00
return True ;
1996-05-04 11:50:46 +04:00
}
/****************************************************************************
2002-03-14 05:15:08 +03:00
main program .
1996-05-04 11:50:46 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2002-03-14 05:15:08 +03:00
2003-05-27 06:35:53 +04:00
/* Declare prototype for build_options() to avoid having to run it through
mkproto . h . Mixing $ ( builddir ) and $ ( srcdir ) source files in the current
prototype generation system is too complicated . */
2007-10-19 04:40:25 +04:00
extern void build_options ( bool screen ) ;
2003-05-27 06:35:53 +04:00
2002-11-09 20:08:58 +03:00
int main ( int argc , const char * argv [ ] )
1996-05-04 11:50:46 +04:00
{
1998-08-17 18:11:44 +04:00
/* shall I run as a daemon */
2009-01-08 14:00:15 +03:00
bool is_daemon = false ;
bool interactive = false ;
bool Fork = true ;
bool no_process_group = false ;
bool log_stdout = false ;
char * ports = NULL ;
char * profile_level = NULL ;
1998-08-17 18:11:44 +04:00
int opt ;
2002-11-09 20:08:58 +03:00
poptContext pc ;
2007-10-19 04:40:25 +04:00
bool print_build_options = False ;
2007-10-19 22:38:36 +04:00
enum {
OPT_DAEMON = 1000 ,
OPT_INTERACTIVE ,
OPT_FORK ,
OPT_NO_PROCESS_GROUP ,
OPT_LOG_STDOUT
} ;
2002-11-09 20:08:58 +03:00
struct poptOption long_options [ ] = {
2006-05-24 08:02:14 +04:00
POPT_AUTOHELP
2007-10-19 22:38:36 +04:00
{ " daemon " , ' D ' , POPT_ARG_NONE , NULL , OPT_DAEMON , " Become a daemon (default) " } ,
{ " interactive " , ' i ' , POPT_ARG_NONE , NULL , OPT_INTERACTIVE , " Run interactive (not a daemon) " } ,
{ " foreground " , ' F ' , POPT_ARG_NONE , NULL , OPT_FORK , " Run daemon in foreground (for daemontools, etc.) " } ,
{ " no-process-group " , ' \0 ' , POPT_ARG_NONE , NULL , OPT_NO_PROCESS_GROUP , " Don't create a new process group " } ,
{ " log-stdout " , ' S ' , POPT_ARG_NONE , NULL , OPT_LOG_STDOUT , " Log to stdout " } ,
2002-11-09 20:08:58 +03:00
{ " build-options " , ' b ' , POPT_ARG_NONE , NULL , ' b ' , " Print build options " } ,
{ " port " , ' p ' , POPT_ARG_STRING , & ports , 0 , " Listen on the specified ports " } ,
2007-04-20 05:52:44 +04:00
{ " profiling-level " , ' P ' , POPT_ARG_STRING , & profile_level , 0 , " Set profiling level " , " PROFILE_LEVEL " } ,
2003-04-14 07:30:20 +04:00
POPT_COMMON_SAMBA
2006-05-24 08:02:14 +04:00
POPT_COMMON_DYNCONFIG
POPT_TABLEEND
2002-11-09 20:08:58 +03:00
} ;
2009-01-27 12:02:43 +03:00
struct smbd_parent_context * parent = NULL ;
2007-11-16 01:19:52 +03:00
TALLOC_CTX * frame = talloc_stackframe ( ) ; /* Setup tos. */
2001-11-19 05:49:53 +03:00
2009-01-08 14:03:45 +03:00
smbd_init_globals ( ) ;
2007-02-07 23:20:56 +03:00
TimeInit ( ) ;
1998-07-29 07:08:05 +04:00
# ifdef HAVE_SET_AUTH_PARAMETERS
1998-08-17 18:11:44 +04:00
set_auth_parameters ( argc , argv ) ;
1996-05-04 11:50:46 +04:00
# endif
2002-11-09 20:08:58 +03:00
pc = poptGetContext ( " smbd " , argc , argv , long_options , 0 ) ;
while ( ( opt = poptGetNextOpt ( pc ) ) ! = - 1 ) {
1998-08-17 18:11:44 +04:00
switch ( opt ) {
2007-10-19 22:38:36 +04:00
case OPT_DAEMON :
is_daemon = true ;
break ;
case OPT_INTERACTIVE :
interactive = true ;
break ;
case OPT_FORK :
Fork = false ;
break ;
case OPT_NO_PROCESS_GROUP :
no_process_group = true ;
break ;
case OPT_LOG_STDOUT :
log_stdout = true ;
break ;
2001-09-19 13:44:12 +04:00
case ' b ' :
2007-08-22 16:06:27 +04:00
print_build_options = True ;
break ;
2007-08-21 18:22:16 +04:00
default :
2007-08-22 16:06:27 +04:00
d_fprintf ( stderr , " \n Invalid option %s: %s \n \n " ,
2007-08-21 18:22:16 +04:00
poptBadOption ( pc , 0 ) , poptStrerror ( opt ) ) ;
2007-08-22 16:06:27 +04:00
poptPrintUsage ( pc , stderr , 0 ) ;
2007-08-21 18:22:16 +04:00
exit ( 1 ) ;
1998-08-17 18:11:44 +04:00
}
2002-11-09 20:08:58 +03:00
}
poptFreeContext ( pc ) ;
1996-05-04 11:50:46 +04:00
2007-12-14 07:56:29 +03:00
if ( interactive ) {
Fork = False ;
log_stdout = True ;
}
setup_logging ( argv [ 0 ] , log_stdout ) ;
2007-08-22 16:06:27 +04:00
if ( print_build_options ) {
build_options ( True ) ; /* Display output to screen as well as debug */
exit ( 0 ) ;
}
2007-12-14 07:56:29 +03:00
load_case_tables ( ) ;
1999-12-13 16:27:58 +03:00
# ifdef HAVE_SETLUID
/* needed for SecureWare on SCO */
setluid ( 0 ) ;
# endif
2001-06-25 04:46:34 +04:00
sec_init ( ) ;
1999-12-13 16:27:58 +03:00
2003-03-18 12:52:55 +03:00
set_remote_machine_name ( " smbd " , False ) ;
1999-12-13 16:27:58 +03:00
2007-10-11 00:34:30 +04:00
if ( interactive & & ( DEBUGLEVEL > = 9 ) ) {
talloc_enable_leak_report ( ) ;
}
if ( log_stdout & & Fork ) {
2003-01-03 20:39:30 +03:00
DEBUG ( 0 , ( " ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i) \n " ) ) ;
exit ( 1 ) ;
}
1999-12-13 16:27:58 +03:00
/* we want to re-seed early to prevent time delays causing
client problems at a later date . ( tridge ) */
2004-07-14 08:36:01 +04:00
generate_random_buffer ( NULL , 0 ) ;
1999-12-13 16:27:58 +03:00
/* make absolutely sure we run as root - to handle cases where people
are crazy enough to have it setuid */
gain_root_privilege ( ) ;
gain_root_group_privilege ( ) ;
2006-04-04 04:27:50 +04:00
fault_setup ( ( void ( * ) ( void * ) ) exit_server_fault ) ;
dump_core_setup ( " smbd " ) ;
1999-12-13 16:27:58 +03:00
/* we are never interested in SIGPIPE */
BlockSignals ( True , SIGPIPE ) ;
# if defined(SIGFPE)
/* we are never interested in SIGFPE */
BlockSignals ( True , SIGFPE ) ;
# endif
2000-10-13 01:19:49 +04:00
# if defined(SIGUSR2)
/* We are no longer interested in USR2 */
BlockSignals ( True , SIGUSR2 ) ;
# endif
2001-01-25 19:36:42 +03:00
/* POSIX demands that signals are inherited. If the invoking process has
* these signals masked , we will have problems , as we won ' t recieve them . */
BlockSignals ( False , SIGHUP ) ;
BlockSignals ( False , SIGUSR1 ) ;
2002-03-14 05:15:08 +03:00
BlockSignals ( False , SIGTERM ) ;
2001-01-25 19:36:42 +03:00
1999-12-13 16:27:58 +03:00
/* we want total control over the permissions on created files,
so set our umask to 0 */
umask ( 0 ) ;
2000-06-23 09:54:49 +04:00
init_sec_ctx ( ) ;
1999-12-13 16:27:58 +03:00
1998-08-17 18:11:44 +04:00
reopen_logs ( ) ;
1996-05-04 11:50:46 +04:00
2009-01-16 00:27:52 +03:00
DEBUG ( 0 , ( " smbd version %s started. \n " , samba_version_string ( ) ) ) ;
2007-10-30 17:44:27 +03:00
DEBUGADD ( 0 , ( " %s \n " , COPYRIGHT_STARTUP_MESSAGE ) ) ;
1996-05-04 11:50:46 +04:00
1998-08-17 18:11:44 +04:00
DEBUG ( 2 , ( " uid=%d gid=%d euid=%d egid=%d \n " ,
( int ) getuid ( ) , ( int ) getgid ( ) , ( int ) geteuid ( ) , ( int ) getegid ( ) ) ) ;
1996-05-04 11:50:46 +04:00
2001-09-19 13:44:12 +04:00
/* Output the build options to the debug log */
build_options ( False ) ;
1998-08-17 18:11:44 +04:00
if ( sizeof ( uint16 ) < 2 | | sizeof ( uint32 ) < 4 ) {
DEBUG ( 0 , ( " ERROR: Samba is not configured correctly for the word size on your machine \n " ) ) ;
exit ( 1 ) ;
}
1996-05-04 11:50:46 +04:00
2008-04-15 12:57:45 +04:00
if ( ! lp_load_initial_only ( get_dyn_CONFIGFILE ( ) ) ) {
DEBUG ( 0 , ( " error opening config file \n " ) ) ;
exit ( 1 ) ;
}
if ( smbd_messaging_context ( ) = = NULL )
exit ( 1 ) ;
1998-08-17 18:11:44 +04:00
if ( ! reload_services ( False ) )
return ( - 1 ) ;
1996-05-04 11:50:46 +04:00
1999-02-08 04:46:46 +03:00
init_structs ( ) ;
2001-07-10 06:28:17 +04:00
1999-04-01 09:22:58 +04:00
# ifdef WITH_PROFILE
2007-05-15 16:18:17 +04:00
if ( ! profile_setup ( smbd_messaging_context ( ) , False ) ) {
1999-04-01 09:22:58 +04:00
DEBUG ( 0 , ( " ERROR: failed to setup profiling \n " ) ) ;
return - 1 ;
}
2007-04-20 05:52:44 +04:00
if ( profile_level ! = NULL ) {
int pl = atoi ( profile_level ) ;
2007-05-07 13:35:35 +04:00
struct server_id src ;
2007-04-20 05:52:44 +04:00
DEBUG ( 1 , ( " setting profiling level: %s \n " , profile_level ) ) ;
src . pid = getpid ( ) ;
set_profile_level ( pl , src ) ;
}
1999-04-01 09:22:58 +04:00
# endif
1998-08-17 18:11:44 +04:00
DEBUG ( 3 , ( " loaded services \n " ) ) ;
1996-05-04 11:50:46 +04:00
2007-10-11 00:34:30 +04:00
if ( ! is_daemon & & ! is_a_socket ( 0 ) ) {
if ( ! interactive )
DEBUG ( 0 , ( " standard input is not a socket, assuming -D option \n " ) ) ;
/*
* Setting is_daemon here prevents us from eventually calling
* the open_sockets_inetd ( )
*/
is_daemon = True ;
1998-08-17 18:11:44 +04:00
}
1997-11-11 03:48:42 +03:00
2007-10-11 00:34:30 +04:00
if ( is_daemon & & ! interactive ) {
1998-08-17 18:11:44 +04:00
DEBUG ( 3 , ( " Becoming a daemon. \n " ) ) ;
2007-10-11 00:34:30 +04:00
become_daemon ( Fork , no_process_group ) ;
1998-08-17 18:11:44 +04:00
}
2000-02-07 19:22:16 +03:00
2001-12-30 04:46:38 +03:00
# if HAVE_SETPGID
/*
* If we ' re interactive we want to set our own process group for
* signal management .
*/
2007-10-11 00:34:30 +04:00
if ( interactive & & ! no_process_group )
2001-12-30 04:46:38 +03:00
setpgid ( ( pid_t ) 0 , ( pid_t ) 0 ) ;
# endif
2008-10-17 14:48:19 +04:00
if ( ! directory_exist ( lp_lockdir ( ) ) )
1998-08-17 18:11:44 +04:00
mkdir ( lp_lockdir ( ) , 0755 ) ;
1996-05-04 11:50:46 +04:00
2007-10-11 00:34:30 +04:00
if ( is_daemon )
1998-08-17 18:11:44 +04:00
pidfile_create ( " smbd " ) ;
1996-08-15 19:11:34 +04:00
2009-01-05 14:47:45 +03:00
if ( ! reinit_after_fork ( smbd_messaging_context ( ) ,
smbd_event_context ( ) , false ) ) {
2008-04-15 12:57:45 +04:00
DEBUG ( 0 , ( " reinit_after_fork() failed \n " ) ) ;
2000-10-12 23:42:18 +04:00
exit ( 1 ) ;
2008-04-15 12:57:45 +04:00
}
2009-01-22 01:24:18 +03:00
smbd_setup_sig_term_handler ( ) ;
smbd_setup_sig_hup_handler ( ) ;
2008-04-15 12:57:45 +04:00
/* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
2002-12-20 23:21:31 +03:00
2007-12-20 12:55:45 +03:00
if ( smbd_memcache ( ) = = NULL ) {
exit ( 1 ) ;
}
memcache_set_global ( smbd_memcache ( ) ) ;
2006-04-18 13:02:58 +04:00
/* Initialise the password backed before the global_sam_sid
to ensure that we fetch from ldap before we make a domain sid up */
2007-03-11 19:49:16 +03:00
if ( ! initialize_password_db ( False , smbd_event_context ( ) ) )
2006-04-18 13:02:58 +04:00
exit ( 1 ) ;
if ( ! secrets_init ( ) ) {
DEBUG ( 0 , ( " ERROR: smbd can not open secrets.tdb \n " ) ) ;
exit ( 1 ) ;
}
if ( ! get_global_sam_sid ( ) ) {
DEBUG ( 0 , ( " ERROR: Samba cannot create a SAM SID. \n " ) ) ;
exit ( 1 ) ;
}
2004-02-19 04:55:24 +03:00
if ( ! session_init ( ) )
exit ( 1 ) ;
2007-05-08 17:44:36 +04:00
if ( ! connections_init ( True ) )
2004-02-19 04:55:24 +03:00
exit ( 1 ) ;
2007-12-05 22:53:22 +03:00
if ( ! locking_init ( ) )
2004-02-19 04:55:24 +03:00
exit ( 1 ) ;
namecache_enable ( ) ;
2008-04-13 17:33:12 +04:00
if ( ! W_ERROR_IS_OK ( registry_init_full ( ) ) )
2004-02-19 04:55:24 +03:00
exit ( 1 ) ;
2005-06-16 04:46:43 +04:00
#if 0
2005-06-14 07:17:31 +04:00
if ( ! init_svcctl_db ( ) )
exit ( 1 ) ;
2005-06-16 04:46:43 +04:00
# endif
2005-06-14 07:17:31 +04:00
2007-05-17 00:56:39 +04:00
if ( ! print_backend_init ( smbd_messaging_context ( ) ) )
2002-11-01 02:41:00 +03:00
exit ( 1 ) ;
2006-02-04 01:19:41 +03:00
if ( ! init_guest_info ( ) ) {
DEBUG ( 0 , ( " ERROR: failed to setup guest info. \n " ) ) ;
return - 1 ;
}
2004-05-27 19:38:54 +04:00
/* 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 */
2007-10-11 00:34:30 +04:00
2008-04-15 03:50:13 +04:00
if ( is_daemon & & ! interactive
& & lp_parm_bool ( - 1 , " smbd " , " backgroundqueue " , true ) ) {
start_background_queue ( ) ;
}
2001-10-17 03:16:00 +04:00
2009-01-23 15:08:22 +03:00
if ( ! is_daemon ) {
/* inetd mode */
TALLOC_FREE ( frame ) ;
/* 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 ) ) ;
/* close our standard file descriptors */
close_low_fds ( False ) ; /* Don't close stderr */
smbd_process ( ) ;
exit_server_cleanly ( NULL ) ;
return ( 0 ) ;
}
2009-01-27 12:02:43 +03:00
parent = talloc_zero ( smbd_event_context ( ) , struct smbd_parent_context ) ;
if ( ! parent ) {
exit_server ( " talloc(struct smbd_parent_context) failed " ) ;
}
parent - > interactive = interactive ;
if ( ! open_sockets_smbd ( parent , ports ) )
exit_server ( " open_sockets_smbd() failed " ) ;
1998-05-19 03:57:28 +04:00
2007-11-16 01:19:52 +03:00
TALLOC_FREE ( frame ) ;
2009-01-27 12:02:43 +03:00
smbd_parent_loop ( parent ) ;
2006-04-04 04:27:50 +04:00
2006-04-11 02:47:09 +04:00
exit_server_cleanly ( NULL ) ;
1998-08-17 18:11:44 +04:00
return ( 0 ) ;
1996-05-04 11:50:46 +04:00
}