X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdaemon.c;h=f8a45f357b72c9a56b2bf9108b92dee8c67bc9bd;hb=e2b5b211558ee778f07954d3843b914f19f6c6b5;hp=8ef532f043574626cd102ea80a205fdd33bba98c;hpb=db721ca82147ff4eea81629358cdacecfbd05d93;p=openldap diff --git a/servers/slapd/daemon.c b/servers/slapd/daemon.c index 8ef532f043..f8a45f357b 100644 --- a/servers/slapd/daemon.c +++ b/servers/slapd/daemon.c @@ -10,7 +10,7 @@ #include #include -#include "ldapconfig.h" +#include "ldap_defaults.h" #include "slap.h" #ifdef HAVE_TCPD @@ -21,10 +21,44 @@ int deny_severity = LOG_NOTICE; #endif /* TCP Wrappers */ /* globals */ -int dtblsize; +ber_socket_t dtblsize; +static ber_socket_t tcps; + +#ifdef HAVE_WINSOCK2 +/* in nt_main.c */ +extern ldap_pvt_thread_cond_t started_event; + +/* forward reference */ +void hit_socket(); +/* In wsa_err.c */ +char *WSAGetLastErrorString(); +static ldap_pvt_thread_t hit_tid; + +#define WAKE_LISTENER(w) \ +do {\ + if( w ) {\ + ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );\ + hit_socket(); \ + }\ +} while(0) +#else +#define WAKE_LISTENER(w) \ +do {\ + if( w ) {\ + ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );\ + }\ +} while(0) +#endif + +#ifndef HAVE_WINSOCK +static +#endif +volatile sig_atomic_t slapd_shutdown = 0; +static int daemon_initialized = 0; static ldap_pvt_thread_t listener_tid; -static volatile sig_atomic_t slapd_shutdown = 0; +static volatile sig_atomic_t slapd_listener = 0; +void sockinit(); struct slap_daemon { ldap_pvt_thread_mutex_t sd_mutex; @@ -45,7 +79,7 @@ struct slap_daemon { /* * Add a descriptor to daemon control */ -static void slapd_add(int s) { +static void slapd_add(ber_socket_t s) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); assert( !FD_ISSET( s, &slap_daemon.sd_actives )); @@ -61,7 +95,8 @@ static void slapd_add(int s) { FD_SET( s, &slap_daemon.sd_actives ); FD_SET( s, &slap_daemon.sd_readers ); - Debug( LDAP_DEBUG_CONNS, "daemon: added %d%s%s\n", s, + Debug( LDAP_DEBUG_CONNS, "daemon: added %ld%s%s\n", + (long) s, FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "", FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ); @@ -71,12 +106,12 @@ static void slapd_add(int s) { /* * Remove the descriptor from daemon control */ -void slapd_remove(int s) { +void slapd_remove(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); + WAKE_LISTENER(wake); - assert( FD_ISSET( s, &slap_daemon.sd_actives )); - - Debug( LDAP_DEBUG_CONNS, "daemon: removing %d%s%s\n", s, + Debug( LDAP_DEBUG_CONNS, "daemon: removing %ld%s%s\n", + (long) s, FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "", FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ); @@ -87,8 +122,9 @@ void slapd_remove(int s) { ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); } -void slapd_clr_write(int s, int wake) { +void slapd_clr_write(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); + WAKE_LISTENER(wake); assert( FD_ISSET( s, &slap_daemon.sd_actives) ); FD_CLR( s, &slap_daemon.sd_writers ); @@ -100,11 +136,12 @@ void slapd_clr_write(int s, int wake) { } } -void slapd_set_write(int s, int wake) { +void slapd_set_write(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); + WAKE_LISTENER(wake); assert( FD_ISSET( s, &slap_daemon.sd_actives) ); - FD_SET( s, &slap_daemon.sd_writers ); + FD_SET( (unsigned) s, &slap_daemon.sd_writers ); ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); @@ -113,8 +150,9 @@ void slapd_set_write(int s, int wake) { } } -void slapd_clr_read(int s, int wake) { +void slapd_clr_read(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); + WAKE_LISTENER(wake); assert( FD_ISSET( s, &slap_daemon.sd_actives) ); FD_CLR( s, &slap_daemon.sd_readers ); @@ -126,8 +164,9 @@ void slapd_clr_read(int s, int wake) { } } -void slapd_set_read(int s, int wake) { +void slapd_set_read(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); + WAKE_LISTENER(wake); assert( FD_ISSET( s, &slap_daemon.sd_actives) ); FD_SET( s, &slap_daemon.sd_readers ); @@ -139,27 +178,27 @@ void slapd_set_read(int s, int wake) { } } -static void slapd_close(int s) { - slapd_remove(s); - - Debug( LDAP_DEBUG_CONNS, "daemon: closing %d\n", s, 0, 0 ); +static void slapd_close(ber_socket_t s) { + Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n", + (long) s, 0, 0 ); tcp_close(s); } -static void * -slapd_daemon_task( - void *ptr -) + + +int +set_socket( struct sockaddr_in *addr ) { - struct sockaddr_in *addr = ptr; - int tcps = -1; + ber_socket_t tcps = AC_SOCKET_INVALID; + + if ( !daemon_initialized ) sockinit(); #ifdef HAVE_SYSCONF dtblsize = sysconf( _SC_OPEN_MAX ); #elif HAVE_GETDTABLESIZE dtblsize = getdtablesize(); #else - dtblsize = FD_SETSIZE + dtblsize = FD_SETSIZE; #endif #ifdef FD_SETSIZE @@ -168,90 +207,158 @@ slapd_daemon_task( } #endif /* !FD_SETSIZE */ - connections_init(); - - ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex ); - FD_ZERO( &slap_daemon.sd_readers ); - FD_ZERO( &slap_daemon.sd_writers ); - if( addr != NULL ) { int tmp; - if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) { + if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == AC_SOCKET_INVALID ) { +#ifndef HAVE_WINSOCK + int err = errno; Debug( LDAP_DEBUG_ANY, - "daemon: socket() failed errno %d (%s)", errno, - errno > -1 && errno < sys_nerr ? sys_errlist[errno] : + "daemon: socket() failed errno %d (%s)\n", err, + err > -1 && err < sys_nerr ? sys_errlist[err] : "unknown", 0 ); - exit( 1 ); +#else + Debug( LDAP_DEBUG_ANY, + "daemon: socket() failed errno %d (%s)\n", + WSAGetLastError(), + WSAGetLastErrorString(), 0 ); +#endif + return( -1 ); } #ifndef HAVE_WINSOCK if ( tcps >= dtblsize ) { Debug( LDAP_DEBUG_ANY, - "daemon: listener descriptor %d is too great", - tcps, dtblsize, 0 ); - exit( 1 ); + "daemon: listener descriptor %ld is too great %ld\n", + (long) tcps, (long) dtblsize, 0 ); + return( -1); } #endif +#ifdef SO_REUSEADDR tmp = 1; if ( setsockopt( tcps, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, sizeof(tmp) ) == -1 ) { + int err = errno; Debug( LDAP_DEBUG_ANY, - "slapd(%d): setsockopt() failed errno %d (%s)", - tcps, errno, - errno > -1 && errno < sys_nerr - ? sys_errlist[errno] : "unknown" ); - - errno = 0; + "slapd(%ld): setsockopt() failed errno %d (%s)\n", + (long) tcps, err, + err > -1 && err < sys_nerr + ? sys_errlist[err] : "unknown" ); + } +#endif +#ifdef SO_KEEPALIVE + tmp = 1; + if ( setsockopt( tcps, SOL_SOCKET, SO_KEEPALIVE, + (char *) &tmp, sizeof(tmp) ) == -1 ) + { + int err = errno; + Debug( LDAP_DEBUG_ANY, + "slapd(%ld): setsockopt(KEEPALIVE) failed errno %d (%s)\n", + (long) tcps, err, + err > -1 && err < sys_nerr + ? sys_errlist[err] : "unknown" ); } +#endif + if ( bind( tcps, (struct sockaddr *) addr, sizeof(*addr) ) == -1 ) { - Debug( LDAP_DEBUG_ANY, "daemon: bind(%d) failed errno %d (%s)\n", - tcps, errno, - errno > -1 && errno < sys_nerr - ? sys_errlist[errno] : "unknown" ); - exit( 1 ); + int err = errno; + Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno %d (%s)\n", + (long) tcps, err, + err > -1 && err < sys_nerr + ? sys_errlist[err] : "unknown" ); + return -1; } + } + return tcps; +} + +static void * +slapd_daemon_task( + void *ptr +) +{ + int inetd; + struct slapd_args *args = (struct slapd_args *) ptr; + struct sockaddr_in *slapd_addr = args->addr; + + tcps = args->tcps; + + inetd = ( slapd_addr == NULL); + if ( !daemon_initialized ) sockinit(); + + slapd_listener=1; + + ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex ); + FD_ZERO( &slap_daemon.sd_readers ); + FD_ZERO( &slap_daemon.sd_writers ); + + if( !inetd ) { if ( listen( tcps, 5 ) == -1 ) { + int err = errno; Debug( LDAP_DEBUG_ANY, - "daemon: listen(%d, 5) failed errno %d (%s)\n", - tcps, errno, - errno > -1 && errno < sys_nerr - ? sys_errlist[errno] : "unknown" ); - exit( 1 ); + "daemon: listen(%ld, 5) failed errno %d (%s)\n", + (long) tcps, err, + err > -1 && err < sys_nerr + ? sys_errlist[err] : "unknown" ); + return( (void*)-1 ); } slapd_add( tcps ); } else { - if( connection_init( 0, NULL, NULL ) ) { + if( connection_init( (ber_socket_t) 0, NULL, NULL ) ) { Debug( LDAP_DEBUG_ANY, "connection_init(%d) failed.\n", 0, 0, 0 ); - - exit( 1 ); + return( (void*)-1 ); } slapd_add( 0 ); } +#ifdef HAVE_WINSOCK + if ( started_event != NULL ) + ldap_pvt_thread_cond_signal( &started_event ); +#endif + /* initialization complete. Here comes the loop. */ + while ( !slapd_shutdown ) { - int i, ns, nfds; + ber_socket_t i; + int ns; + int at; + ber_socket_t nfds; +#define SLAPD_EBADF_LIMIT 10 + int ebadf = 0; + +#define SLAPD_IDLE_CHECK_LIMIT 4 + time_t last_idle_check = slap_get_time(); + time_t now; + fd_set readfds; fd_set writefds; struct sockaddr_in from; - struct hostent *hp; +#if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD) + struct hostent *hp; +#endif struct timeval zero; struct timeval *tvp; char *client_name; char *client_addr; + if( global_idletimeout > 0 && difftime( + last_idle_check+global_idletimeout/SLAPD_IDLE_CHECK_LIMIT, + now ) < 0 ) + { + connections_timeout_idle(now); + } + FD_ZERO( &writefds ); FD_ZERO( &readfds ); @@ -274,7 +381,7 @@ slapd_daemon_task( memcpy( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) ); #endif - FD_SET( tcps, &readfds ); + FD_SET( (unsigned) tcps, &readfds ); #ifndef HAVE_WINSOCK nfds = slap_daemon.sd_nfds; @@ -285,79 +392,111 @@ slapd_daemon_task( ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); ldap_pvt_thread_mutex_lock( &active_threads_mutex ); + at = active_threads; + ldap_pvt_thread_mutex_unlock( &active_threads_mutex ); + #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS ) tvp = NULL; #else - tvp = active_threads ? &zero : NULL; + tvp = at ? &zero : NULL; #endif Debug( LDAP_DEBUG_CONNS, "daemon: select: tcps=%d active_threads=%d tvp=%s\n", - tcps, active_threads, + tcps, at, tvp == NULL ? "NULL" : "zero" ); - ldap_pvt_thread_mutex_unlock( &active_threads_mutex ); - switch(ns = select( nfds, &readfds, &writefds, 0, tvp )) { - case -1: /* failure - try again */ - if( errno != EINTR ) { - Debug( LDAP_DEBUG_CONNS, - "daemon: select failed (%d): %s\n", - errno, - errno >= 0 && errno < sys_nerr - ? sys_errlist[errno] : "unknown", - 0 ); + switch(ns = select( nfds, &readfds, +#ifdef HAVE_WINSOCK + /* don't pass empty fd_set */ + ( writefds.fd_count > 0 ? &writefds : NULL ), +#else + &writefds, +#endif + NULL, tvp )) + { + case -1: { /* failure - try again */ +#ifdef HAVE_WINSOCK + int err = WSAGetLastError(); +#else + int err = errno; +#endif + + if( err == EBADF && ++ebadf < SLAPD_EBADF_LIMIT) { + continue; + } + + if( err != EINTR ) { + Debug( LDAP_DEBUG_CONNS, + "daemon: select failed (%d): %s\n", + err, + err >= 0 && err < sys_nerr + ? sys_errlist[err] : "unknown", + 0 ); + slapd_shutdown = -1; + } } - errno = 0; continue; case 0: /* timeout - let threads run */ + ebadf = 0; Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n", 0, 0, 0 ); ldap_pvt_thread_yield(); continue; default: /* something happened - deal with it */ + ebadf = 0; Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n", ns, 0, 0 ); /* FALL THRU */ } if ( FD_ISSET( tcps, &readfds ) ) { - int s; + ber_int_t s; int len = sizeof(from); long id; if ( (s = accept( tcps, - (struct sockaddr *) &from, &len )) == -1 ) + (struct sockaddr *) &from, &len )) == AC_SOCKET_INVALID ) { + int err = errno; Debug( LDAP_DEBUG_ANY, - "daemon: accept(%d) failed errno %d (%s)", errno, - tcps, errno >= 0 && errno < sys_nerr ? - sys_errlist[errno] : "unknown"); + "daemon: accept(%ld) failed errno %d (%s)\n", err, + (long) tcps, err >= 0 && err < sys_nerr ? + sys_errlist[err] : "unknown"); continue; } - assert( !FD_ISSET( 0, &slap_daemon.sd_actives) ); - assert( !FD_ISSET( 0, &slap_daemon.sd_readers) ); - assert( !FD_ISSET( 0, &slap_daemon.sd_writers) ); +#ifdef LDAP_DEBUG + ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); + + /* newly accepted stream should not be in any of the FD SETS */ + + assert( !FD_ISSET( s, &slap_daemon.sd_actives) ); + assert( !FD_ISSET( s, &slap_daemon.sd_readers) ); + assert( !FD_ISSET( s, &slap_daemon.sd_writers) ); + + ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); +#endif #ifndef HAVE_WINSOCK /* make sure descriptor number isn't too great */ if ( s >= dtblsize ) { Debug( LDAP_DEBUG_ANY, - "daemon: %d beyond descriptor table size %d\n", - s, dtblsize, 0 ); - tcp_close(s); + "daemon: %ld beyond descriptor table size %ld\n", + (long) s, (long) dtblsize, 0 ); + slapd_close(s); continue; } #endif - Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %d\n", - s, 0, 0 ); + Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n", + (long) s, 0, 0 ); len = sizeof(from); if ( getpeername( s, (struct sockaddr *) &from, &len ) == 0 ) { @@ -397,30 +536,30 @@ slapd_daemon_task( { /* DENY ACCESS */ Statslog( LDAP_DEBUG_ANY, - "fd=%d connection from %s (%s) denied.\n", - s, + "fd=%ld connection from %s (%s) denied.\n", + (long) s, client_name == NULL ? "unknown" : client_name, client_addr == NULL ? "unknown" : client_addr, 0, 0 ); - tcp_close(s); + slapd_close(s); continue; } #endif /* HAVE_TCPD */ if( (id = connection_init(s, client_name, client_addr)) < 0 ) { Debug( LDAP_DEBUG_ANY, - "daemon: connection_init(%d, %s, %s) failed.\n", - s, + "daemon: connection_init(%ld, %s, %s) failed.\n", + (long) s, client_name == NULL ? "unknown" : client_name, client_addr == NULL ? "unknown" : client_addr); - tcp_close(s); + slapd_close(s); continue; } Statslog( LDAP_DEBUG_STATS, - "daemon: conn=%d fd=%d connection from %s (%s) accepted.\n", - id, s, + "daemon: conn=%d fd=%ld connection from %s (%s) accepted.\n", + id, (long) s, client_name == NULL ? "unknown" : client_name, client_addr == NULL ? "unknown" : client_addr, 0 ); @@ -431,7 +570,16 @@ slapd_daemon_task( #ifdef LDAP_DEBUG Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 ); - +#ifdef HAVE_WINSOCK + for ( i = 0; i < readfds.fd_count; i++ ) { + Debug( LDAP_DEBUG_CONNS, " %d%s", + readfds.fd_array[i], "r", 0 ); + } + for ( i = 0; i < writefds.fd_count; i++ ) { + Debug( LDAP_DEBUG_CONNS, " %d%s", + writefds.fd_array[i], "w", 0 ); + } +#else for ( i = 0; i < nfds; i++ ) { int a, r, w; @@ -442,49 +590,83 @@ slapd_daemon_task( r ? "r" : "", w ? "w" : "" ); } } - +#endif Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 ); #endif /* loop through the writers */ - for ( i = 0; i < nfds; i++ ) { - if ( i == tcps ) { +#ifdef HAVE_WINSOCK + for ( i = 0; i < writefds.fd_count; i++ ) +#else + for ( i = 0; i < nfds; i++ ) +#endif + { + ber_socket_t wd; + +#ifdef HAVE_WINSOCK + wd = writefds.fd_array[i]; +#else + if( ! FD_ISSET( i, &writefds ) ) { continue; } + wd = i; +#endif - if ( FD_ISSET( i, &writefds ) ) { - Debug( LDAP_DEBUG_CONNS, - "daemon: signaling write waiter on %d\n", i, 0, 0 ); + if ( wd == tcps ) { + continue; + } + Debug( LDAP_DEBUG_CONNS, + "daemon: write active on %d\n", + wd, 0, 0 ); + + /* + * NOTE: it is possible that the connection was closed + * and that the stream is now inactive. + * connection_write() must valid the stream is still + * active. + */ + + if ( connection_write( wd ) < 0 ) { + FD_CLR( (unsigned) wd, &readfds ); + slapd_close( wd ); + } + } - assert( FD_ISSET( 0, &slap_daemon.sd_actives) ); +#ifdef HAVE_WINSOCK + for ( i = 0; i < readfds.fd_count; i++ ) +#else + for ( i = 0; i < nfds; i++ ) +#endif + { + ber_socket_t rd; - /* clear the write flag */ - slapd_clr_write( i, 0 ); - - if( connection_write( i ) < 0 ) { - FD_CLR( i, &readfds ); - slapd_close( i ); - } +#ifdef HAVE_WINSOCK + rd = readfds.fd_array[i]; +#else + if( ! FD_ISSET( i, &readfds ) ) { + continue; } - } + rd = i; +#endif - for ( i = 0; i < nfds; i++ ) { - if ( i == tcps ) { + if ( rd == tcps ) { continue; } - if ( FD_ISSET( i, &readfds ) ) { - Debug( LDAP_DEBUG_CONNS, - "daemon: read activity on %d\n", i, 0, 0 ); + Debug ( LDAP_DEBUG_CONNS, + "daemon: read activity on %d\n", rd, 0, 0 ); - assert( FD_ISSET( i, &slap_daemon.sd_actives) ); + /* + * NOTE: it is possible that the connection was closed + * and that the stream is now inactive. + * connection_read() must valid the stream is still + * active. + */ - if( connection_read( i ) < 0) { - slapd_close( i ); - } + if ( connection_read( rd ) < 0 ) { + slapd_close( rd ); } } - ldap_pvt_thread_yield(); } @@ -504,7 +686,7 @@ slapd_daemon_task( } if( tcps >= 0 ) { - tcp_close( tcps ); + slapd_close( tcps ); } ldap_pvt_thread_mutex_lock( &active_threads_mutex ); @@ -519,31 +701,140 @@ slapd_daemon_task( return NULL; } -int slapd_daemon( struct sockaddr_in *addr ) + +int slapd_daemon( struct slapd_args *args ) { - int status; + int rc; - status = ldap_pvt_thread_create( &listener_tid, 0, - slapd_daemon_task, addr ); + if ( !daemon_initialized ) sockinit(); - if ( status != 0 ) { + connections_init(); + +#define SLAPD_LISTENER_THREAD 1 +#if defined( SLAPD_LISTENER_THREAD ) || !defined(HAVE_PTHREADS) + + /* listener as a separate THREAD */ + rc = ldap_pvt_thread_create( &listener_tid, + 0, slapd_daemon_task, args ); + + if ( rc != 0 ) { Debug( LDAP_DEBUG_ANY, - "listener ldap_pvt_thread_create failed (%d)\n", status, 0, 0 ); - return -1; - } else { - /* wait for the listener thread to complete */ - ldap_pvt_thread_join( listener_tid, (void *) NULL ); + "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 ); + goto destory; } - return 0; + /* wait for the listener thread to complete */ + ldap_pvt_thread_join( listener_tid, (void *) NULL ); +#else + /* expermimental code */ + listener_tid = pthread_self(); + slapd_daemon_task( args ); +#endif + + rc = 0; + +destory: + connections_destroy(); + +#ifdef HAVE_WINSOCK + WSACleanup( ); +#endif + + return rc; +} + +#ifdef HAVE_WINSOCK2 +void sockinit() +{ + WORD wVersionRequested; + WSADATA wsaData; + int err; + + wVersionRequested = MAKEWORD( 2, 0 ); + + err = WSAStartup( wVersionRequested, &wsaData ); + if ( err != 0 ) { + /* Tell the user that we couldn't find a usable */ + /* WinSock DLL. */ + return; + } + + /* Confirm that the WinSock DLL supports 2.0.*/ + /* Note that if the DLL supports versions greater */ + /* than 2.0 in addition to 2.0, it will still return */ + /* 2.0 in wVersion since that is the version we */ + /* requested. */ + + if ( LOBYTE( wsaData.wVersion ) != 2 || + HIBYTE( wsaData.wVersion ) != 0 ) + { + /* Tell the user that we couldn't find a usable */ + /* WinSock DLL. */ + WSACleanup( ); + return; + } + daemon_initialized = 1; +} /* The WinSock DLL is acceptable. Proceed. */ + +void hit_socket() +{ + ber_socket_t s; + int on = 1; + extern struct sockaddr_in bind_addr; + + /* throw something at the socket to terminate the select() in the daemon thread. */ + if (( s = socket( AF_INET, SOCK_STREAM, 0 )) == AC_SOCKET_INVALID ) + Debug( LDAP_DEBUG_ANY, + "slap_set_shutdown: socket failed\n\tWSAGetLastError=%d (%s)\n", + WSAGetLastError(), WSAGetLastErrorString(), 0 ); + + if ( ioctlsocket( s, FIONBIO, &on ) == -1 ) + Debug( LDAP_DEBUG_ANY, + "slap_set_shutdown:FIONBIO ioctl on %d faled\n\tWSAGetLastError=%d (%s)\n", + s, WSAGetLastError(), WSAGetLastError() ); + + bind_addr.sin_addr.s_addr = htonl( INADDR_LOOPBACK ); + + if ( connect( s, (struct sockaddr *)&bind_addr, sizeof( struct sockaddr_in )) == SOCKET_ERROR ) { + Debug( LDAP_DEBUG_ANY, + "hit_socket: error on connect: %d\n", + WSAGetLastError(), 0, 0 ); + /* we can probably expect some error to occur here, mostly WSAEWOULDBLOCK */ + } + + tcp_close(s); +} + +#elif HAVE_WINSOCK +void sockinit() +{ WSADATA wsaData; + if ( WSAStartup( 0x0101, &wsaData ) != 0 ) { + return( NULL ); + } + daemon_initialized = 1; +} +#else +void sockinit() +{ + daemon_initialized = 1; } +#endif void slap_set_shutdown( int sig ) { - slapd_shutdown = 1; - ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 ); - + slapd_shutdown = sig; +#ifndef HAVE_WINSOCK + if(slapd_listener) { + ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 ); + } +#else + Debug( LDAP_DEBUG_TRACE, "Shutdown %d ordered", sig, 0, 0 ); + /* trying to "hit" the socket seems to always get a */ + /* EWOULDBLOCK error, so just close the listen socket to */ + /* break out of the select since we're shutting down anyway */ + tcp_close( tcps ); +#endif /* reinstall self */ (void) SIGNAL( sig, slap_set_shutdown ); }