X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdaemon.c;h=f9606c928e899aaad03615bf7b88e3f3e1227aa7;hb=0121f8c01dcdef0827c8e6a1770d0a5ae3b0806e;hp=1cbfd5012fadb7491d2f5302ee35e4314b0bcbc2;hpb=40a893a07eb711b41cf3c07a78b892a0b6504c93;p=openldap diff --git a/servers/slapd/daemon.c b/servers/slapd/daemon.c index 1cbfd5012f..f9606c928e 100644 --- a/servers/slapd/daemon.c +++ b/servers/slapd/daemon.c @@ -1,7 +1,8 @@ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * Copyright 1998-2006 The OpenLDAP Foundation. + * Copyright 1998-2009 The OpenLDAP Foundation. + * Portions Copyright 2007 by Howard Chu, Symas Corporation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -50,14 +51,9 @@ #endif /* ! epoll && ! /dev/poll */ #ifdef HAVE_TCPD -# include int allow_severity = LOG_INFO; int deny_severity = LOG_NOTICE; - -# define SLAP_STRING_UNKNOWN STRING_UNKNOWN -#else /* ! TCP Wrappers */ -# define SLAP_STRING_UNKNOWN "unknown" -#endif /* ! TCP Wrappers */ +#endif /* TCP Wrappers */ #ifdef LDAP_PF_LOCAL # include @@ -83,20 +79,26 @@ Listener **slap_listeners = NULL; #define SLAPD_LISTEN_BACKLOG 1024 #endif /* ! SLAPD_LISTEN_BACKLOG */ -static ber_socket_t wake_sds[2]; +static ber_socket_t wake_sds[2] +#ifdef HAVE_WINSOCK + = { INVALID_SOCKET, INVALID_SOCKET } +#endif /* HAVE_WINSOCK */ + ; static int emfile; +static time_t chk_writetime; + static volatile int waking; #ifdef NO_THREADS #define WAKE_LISTENER(w) do { \ if ((w) && ++waking < 5) { \ - tcp_write( wake_sds[1], "0", 1 ); \ + tcp_write( SLAP_FD2SOCK(wake_sds[1]), "0", 1 ); \ } \ } while (0) #else /* ! NO_THREADS */ #define WAKE_LISTENER(w) do { \ if (w) { \ - tcp_write( wake_sds[1], "0", 1 ); \ + tcp_write( SLAP_FD2SOCK(wake_sds[1]), "0", 1 ); \ } \ } while (0) #endif /* ! NO_THREADS */ @@ -105,6 +107,15 @@ volatile sig_atomic_t slapd_shutdown = 0; volatile sig_atomic_t slapd_gentle_shutdown = 0; volatile sig_atomic_t slapd_abrupt_shutdown = 0; +#ifdef HAVE_WINSOCK +ldap_pvt_thread_mutex_t slapd_ws_mutex; +SOCKET *slapd_ws_sockets; +#define SD_READ 1 +#define SD_WRITE 2 +#define SD_ACTIVE 4 +#define SD_LISTENER 8 +#endif + static struct slap_daemon { ldap_pvt_thread_mutex_t sd_mutex; #ifdef HAVE_TCPD @@ -113,28 +124,27 @@ static struct slap_daemon { ber_socket_t sd_nactives; int sd_nwriters; + int sd_nfds; #if defined(HAVE_EPOLL) struct epoll_event *sd_epolls; int *sd_index; int sd_epfd; - int sd_nfds; #elif defined(SLAP_X_DEVPOLL) && defined(HAVE_DEVPOLL) /* eXperimental */ struct pollfd *sd_pollfd; int *sd_index; Listener **sd_l; int sd_dpfd; - int sd_nfds; #else /* ! epoll && ! /dev/poll */ -#ifndef HAVE_WINSOCK - /* In winsock, accept() returns values higher than dtblsize - so don't bother with this optimization */ - int sd_nfds; -#endif /* ! HAVE_WINSOCK */ +#ifdef HAVE_WINSOCK + char *sd_flags; + char *sd_rflags; +#else /* ! HAVE_WINSOCK */ fd_set sd_actives; fd_set sd_readers; fd_set sd_writers; +#endif /* ! HAVE_WINSOCK */ #endif /* ! epoll && ! /dev/poll */ } slap_daemon; @@ -187,14 +197,12 @@ static struct slap_daemon { # define SLAP_SOCK_CLR_READ(s) SLAP_EPOLL_SOCK_CLR((s), EPOLLIN) # define SLAP_SOCK_CLR_WRITE(s) SLAP_EPOLL_SOCK_CLR((s), EPOLLOUT) -# ifdef SLAP_LIGHTWEIGHT_DISPATCHER # define SLAP_SOCK_SET_SUSPEND(s) \ ( slap_daemon.sd_suspend[SLAP_EPOLL_SOCK_IX(s)] = 1 ) # define SLAP_SOCK_CLR_SUSPEND(s) \ ( slap_daemon.sd_suspend[SLAP_EPOLL_SOCK_IX(s)] = 0 ) # define SLAP_SOCK_IS_SUSPEND(s) \ ( slap_daemon.sd_suspend[SLAP_EPOLL_SOCK_IX(s)] == 1 ) -# endif /* SLAP_LIGHTWEIGHT_DISPATCHER */ # define SLAP_EPOLL_EVENT_CLR(i, mode) (revents[(i)].events &= ~(mode)) @@ -227,7 +235,8 @@ static struct slap_daemon { (int *)(ptr) <= &slap_daemon.sd_index[dtblsize]) ? 0 : 1 ) # define SLAP_EPOLL_EV_PTRFD(ptr) (SLAP_EPOLL_EV_LISTENER(ptr) ? \ - ((Listener *)ptr)->sl_sd : (int *)(ptr) - slap_daemon.sd_index) + ((Listener *)ptr)->sl_sd : \ + (ber_socket_t) ((int *)(ptr) - slap_daemon.sd_index)) # define SLAP_SOCK_DEL(s) do { \ int fd, rc, index = SLAP_EPOLL_SOCK_IX((s)); \ @@ -328,7 +337,7 @@ static struct slap_daemon { } while (0) # define SLAP_DEVPOLL_SOCK_SET(s, mode) do { \ - fprintf( stderr, "SLAP_SOCK_SET_%s(%d) = %d\n", \ + Debug( LDAP_DEBUG_CONNS, "SLAP_SOCK_SET_%s(%d)=%d\n", \ (mode) == POLLIN ? "READ" : "WRITE", (s), \ ( (SLAP_DEVPOLL_SOCK_EV((s)) & (mode)) != (mode) ) ); \ if ( (SLAP_DEVPOLL_SOCK_EV((s)) & (mode)) != (mode) ) { \ @@ -341,7 +350,7 @@ static struct slap_daemon { } while (0) # define SLAP_DEVPOLL_SOCK_CLR(s, mode) do { \ - fprintf( stderr, "SLAP_SOCK_CLR_%s(%d) = %d\n", \ + Debug( LDAP_DEBUG_CONNS, "SLAP_SOCK_CLR_%s(%d)=%d\n", \ (mode) == POLLIN ? "READ" : "WRITE", (s), \ ( (SLAP_DEVPOLL_SOCK_EV((s)) & (mode)) == (mode) ) ); \ if ((SLAP_DEVPOLL_SOCK_EV((s)) & (mode)) == (mode) ) { \ @@ -360,14 +369,12 @@ static struct slap_daemon { # define SLAP_SOCK_CLR_READ(s) SLAP_DEVPOLL_SOCK_CLR((s), POLLIN) # define SLAP_SOCK_CLR_WRITE(s) SLAP_DEVPOLL_SOCK_CLR((s), POLLOUT) -# ifdef SLAP_LIGHTWEIGHT_DISPATCHER # define SLAP_SOCK_SET_SUSPEND(s) \ ( slap_daemon.sd_suspend[SLAP_DEVPOLL_SOCK_IX((s))] = 1 ) # define SLAP_SOCK_CLR_SUSPEND(s) \ ( slap_daemon.sd_suspend[SLAP_DEVPOLL_SOCK_IX((s))] = 0 ) # define SLAP_SOCK_IS_SUSPEND(s) \ ( slap_daemon.sd_suspend[SLAP_DEVPOLL_SOCK_IX((s))] == 1 ) -# endif /* SLAP_LIGHTWEIGHT_DISPATCHER */ # define SLAP_DEVPOLL_EVENT_CLR(i, mode) (revents[(i)].events &= ~(mode)) @@ -378,7 +385,7 @@ static struct slap_daemon { * need to shutdown. */ # define SLAP_SOCK_ADD(s, l) do { \ - fprintf( stderr, "SLAP_SOCK_ADD(%d, %p)\n", (s), (l) ); \ + Debug( LDAP_DEBUG_CONNS, "SLAP_SOCK_ADD(%d, %p)\n", (s), (l), 0 ); \ SLAP_DEVPOLL_SOCK_IX((s)) = slap_daemon.sd_nfds; \ SLAP_DEVPOLL_SOCK_LX((s)) = (l); \ SLAP_DEVPOLL_SOCK_FD((s)) = (s); \ @@ -391,7 +398,7 @@ static struct slap_daemon { # define SLAP_SOCK_DEL(s) do { \ int fd, index = SLAP_DEVPOLL_SOCK_IX((s)); \ - fprintf( stderr, "SLAP_SOCK_DEL(%d)\n", (s) ); \ + Debug( LDAP_DEBUG_CONNS, "SLAP_SOCK_DEL(%d)\n", (s), 0, 0 ); \ if ( index < 0 ) break; \ if ( index < slap_daemon.sd_nfds - 1 ) { \ struct pollfd pfd = slap_daemon.sd_pollfd[index]; \ @@ -465,13 +472,119 @@ static struct slap_daemon { } while (0) #else /* ! epoll && ! /dev/poll */ +# ifdef HAVE_WINSOCK +# define SLAP_EVENT_FNAME "WSselect" +/* Winsock provides a "select" function but its fd_sets are + * actually arrays of sockets. Since these sockets are handles + * and not a contiguous range of small integers, we manage our + * own "fd" table of socket handles and use their indices as + * descriptors. + * + * All of our listener/connection structures use fds; the actual + * I/O functions use sockets. The SLAP_FD2SOCK macro in proto-slap.h + * handles the mapping. + * + * Despite the mapping overhead, this is about 45% more efficient + * than just using Winsock's select and FD_ISSET directly. + * + * Unfortunately Winsock's select implementation doesn't scale well + * as the number of connections increases. This probably needs to be + * rewritten to use the Winsock overlapped/asynchronous I/O functions. + */ +# define SLAP_EVENTS_ARE_INDEXED 1 +# define SLAP_EVENT_DECL fd_set readfds, writefds +# define SLAP_EVENT_INIT do { \ + int i; \ + FD_ZERO( &readfds ); \ + FD_ZERO( &writefds ); \ + memset( slap_daemon.sd_rflags, 0, slap_daemon.sd_nfds ); \ + for ( i=0; i 0 ? &writefds : NULL, NULL, (tvp) ); \ + for ( i=0; i= 0 ) { \ + slap_daemon.sd_rflags[fd] = SD_READ; \ + if ( fd >= *(nsp)) *(nsp) = fd+1; \ + } \ + } \ + for ( i=0; i= 0 ) { \ + slap_daemon.sd_rflags[fd] = SD_WRITE; \ + if ( fd >= *(nsp)) *(nsp) = fd+1; \ + } \ + } \ +} while (0) + +# define SLAP_EVENT_IS_READ(fd) (slap_daemon.sd_rflags[fd] & SD_READ) +# define SLAP_EVENT_IS_WRITE(fd) (slap_daemon.sd_rflags[fd] & SD_WRITE) + +# define SLAP_EVENT_CLR_READ(fd) slap_daemon.sd_rflags[fd] &= ~SD_READ; +# define SLAP_EVENT_CLR_WRITE(fd) slap_daemon.sd_rflags[fd] &= ~SD_WRITE; + +# define SLAP_SOCK_INIT do { \ + ldap_pvt_thread_mutex_init( &slapd_ws_mutex ); \ + slapd_ws_sockets = ch_malloc( dtblsize * ( sizeof(SOCKET) + 2)); \ + slap_daemon.sd_flags = (char *)(slapd_ws_sockets + dtblsize); \ + slap_daemon.sd_rflags = slap_daemon.sd_flags + dtblsize; \ + memset( slapd_ws_sockets, -1, dtblsize * sizeof(SOCKET) ); \ + slapd_ws_sockets[0] = wake_sds[0]; \ + slapd_ws_sockets[1] = wake_sds[1]; \ + wake_sds[0] = 0; \ + wake_sds[1] = 1; \ + slap_daemon.sd_nfds = 2; \ + } while ( 0 ) + +# define SLAP_SOCK_DESTROY do { \ + ch_free( slapd_ws_sockets ); slapd_ws_sockets = NULL; \ + slap_daemon.sd_flags = NULL; \ + slap_daemon.sd_rflags = NULL; \ + ldap_pvt_thread_mutex_destroy( &slapd_ws_mutex ); \ + } while ( 0 ) + +# define SLAP_SOCK_IS_ACTIVE(fd) ( slap_daemon.sd_flags[fd] & SD_ACTIVE ) +# define SLAP_SOCK_IS_READ(fd) ( slap_daemon.sd_flags[fd] & SD_READ ) +# define SLAP_SOCK_IS_WRITE(fd) ( slap_daemon.sd_flags[fd] & SD_WRITE ) +# define SLAP_SOCK_NOT_ACTIVE(fd) (!slap_daemon.sd_flags[fd]) + +# define SLAP_SOCK_SET_READ(fd) ( slap_daemon.sd_flags[fd] |= SD_READ ) +# define SLAP_SOCK_SET_WRITE(fd) ( slap_daemon.sd_flags[fd] |= SD_WRITE ) + +# define SLAP_SELECT_ADDTEST(s) do { \ + if ((s) >= slap_daemon.sd_nfds) slap_daemon.sd_nfds = (s)+1; \ +} while (0) + +# define SLAP_SOCK_CLR_READ(fd) ( slap_daemon.sd_flags[fd] &= ~SD_READ ) +# define SLAP_SOCK_CLR_WRITE(fd) ( slap_daemon.sd_flags[fd] &= ~SD_WRITE ) + +# define SLAP_SOCK_ADD(s, l) do { \ + SLAP_SELECT_ADDTEST((s)); \ + slap_daemon.sd_flags[s] = SD_ACTIVE|SD_READ; \ +} while ( 0 ) + +# define SLAP_SOCK_DEL(s) do { \ + slap_daemon.sd_flags[s] = 0; \ + slapd_sockdel( s ); \ +} while ( 0 ) + +# else /* !HAVE_WINSOCK */ /************************************** * Use select system call - select(2) * **************************************/ # define SLAP_EVENT_FNAME "select" /* select */ - # define SLAP_EVENTS_ARE_INDEXED 1 # define SLAP_EVENT_DECL fd_set readfds, writefds @@ -494,6 +607,7 @@ static struct slap_daemon { # define SLAP_SOCK_INIT do { \ SLAP_SELECT_CHK_SETSIZE; \ + FD_ZERO(&slap_daemon.sd_actives); \ FD_ZERO(&slap_daemon.sd_readers); \ FD_ZERO(&slap_daemon.sd_writers); \ } while (0) @@ -507,25 +621,13 @@ static struct slap_daemon { # define SLAP_SOCK_NOT_ACTIVE(fd) (!SLAP_SOCK_IS_ACTIVE(fd) && \ !SLAP_SOCK_IS_READ(fd) && !SLAP_SOCK_IS_WRITE(fd)) -# ifdef HAVE_WINSOCK -# define SLAP_SOCK_SET_READ(fd) do { \ - if (!SLAP_SOCK_IS_READ(fd)) { FD_SET((fd), &slap_daemon.sd_readers); } \ -} while (0) -# define SLAP_SOCK_SET_WRITE(fd) do { \ - if (!SLAP_SOCK_IS_WRITE(fd)) { FD_SET((fd), &slap_daemon.sd_writers); } \ -} while (0) - -# define SLAP_SELECT_ADDTEST(s) -# define SLAP_EVENT_MAX dtblsize -# else /* ! HAVE_WINSOCK */ -# define SLAP_SOCK_SET_READ(fd) FD_SET((fd), &slap_daemon.sd_readers) -# define SLAP_SOCK_SET_WRITE(fd) FD_SET((fd), &slap_daemon.sd_writers) +# define SLAP_SOCK_SET_READ(fd) FD_SET((fd), &slap_daemon.sd_readers) +# define SLAP_SOCK_SET_WRITE(fd) FD_SET((fd), &slap_daemon.sd_writers) -# define SLAP_EVENT_MAX slap_daemon.sd_nfds -# define SLAP_SELECT_ADDTEST(s) do { \ +# define SLAP_EVENT_MAX slap_daemon.sd_nfds +# define SLAP_SELECT_ADDTEST(s) do { \ if ((s) >= slap_daemon.sd_nfds) slap_daemon.sd_nfds = (s)+1; \ } while (0) -# endif /* ! HAVE_WINSOCK */ # define SLAP_SOCK_CLR_READ(fd) FD_CLR((fd), &slap_daemon.sd_readers) # define SLAP_SOCK_CLR_WRITE(fd) FD_CLR((fd), &slap_daemon.sd_writers) @@ -552,6 +654,7 @@ static struct slap_daemon { *(nsp) = select( SLAP_EVENT_MAX, &readfds, \ nwriters > 0 ? &writefds : NULL, NULL, (tvp) ); \ } while (0) +# endif /* !HAVE_WINSOCK */ #endif /* ! epoll && ! /dev/poll */ #ifdef HAVE_SLP @@ -582,28 +685,17 @@ slapd_slp_init( const char* urls ) /* find and expand INADDR_ANY URLs */ for ( i = 0; slapd_srvurls[i] != NULL; i++ ) { if ( strcmp( slapd_srvurls[i], "ldap:///" ) == 0 ) { - char *host = ldap_pvt_get_fqdn( NULL ); - if ( host != NULL ) { - slapd_srvurls[i] = (char *) ch_realloc( slapd_srvurls[i], - strlen( host ) + - sizeof( LDAP_SRVTYPE_PREFIX ) ); - strcpy( lutil_strcopy(slapd_srvurls[i], - LDAP_SRVTYPE_PREFIX ), host ); - - ch_free( host ); - } - + slapd_srvurls[i] = (char *) ch_realloc( slapd_srvurls[i], + strlen( global_host ) + + sizeof( LDAP_SRVTYPE_PREFIX ) ); + strcpy( lutil_strcopy(slapd_srvurls[i], + LDAP_SRVTYPE_PREFIX ), global_host ); } else if ( strcmp( slapd_srvurls[i], "ldaps:///" ) == 0 ) { - char *host = ldap_pvt_get_fqdn( NULL ); - if ( host != NULL ) { - slapd_srvurls[i] = (char *) ch_realloc( slapd_srvurls[i], - strlen( host ) + - sizeof( LDAPS_SRVTYPE_PREFIX ) ); - strcpy( lutil_strcopy(slapd_srvurls[i], - LDAPS_SRVTYPE_PREFIX ), host ); - - ch_free( host ); - } + slapd_srvurls[i] = (char *) ch_realloc( slapd_srvurls[i], + strlen( global_host ) + + sizeof( LDAPS_SRVTYPE_PREFIX ) ); + strcpy( lutil_strcopy(slapd_srvurls[i], + LDAPS_SRVTYPE_PREFIX ), global_host ); } } @@ -693,6 +785,42 @@ slapd_slp_dereg( void ) } #endif /* HAVE_SLP */ +#ifdef HAVE_WINSOCK +/* Manage the descriptor to socket table */ +ber_socket_t +slapd_socknew( ber_socket_t s ) +{ + ber_socket_t i; + ldap_pvt_thread_mutex_lock( &slapd_ws_mutex ); + for ( i = 0; i < dtblsize && slapd_ws_sockets[i] != INVALID_SOCKET; i++ ); + if ( i == dtblsize ) { + WSASetLastError( WSAEMFILE ); + } else { + slapd_ws_sockets[i] = s; + } + ldap_pvt_thread_mutex_unlock( &slapd_ws_mutex ); + return i; +} + +void +slapd_sockdel( ber_socket_t s ) +{ + ldap_pvt_thread_mutex_lock( &slapd_ws_mutex ); + slapd_ws_sockets[s] = INVALID_SOCKET; + ldap_pvt_thread_mutex_unlock( &slapd_ws_mutex ); +} + +ber_socket_t +slapd_sock2fd( ber_socket_t s ) +{ + ber_socket_t i; + for ( i=0; ilud_scheme ) ) { @@ -1242,8 +1392,8 @@ slap_open_listener( if( l.sl_is_udp ) socktype = SOCK_DGRAM; #endif /* LDAP_CONNECTIONLESS */ - l.sl_sd = socket( (*sal)->sa_family, socktype, 0); - if ( l.sl_sd == AC_SOCKET_INVALID ) { + s = socket( (*sal)->sa_family, socktype, 0); + if ( s == AC_SOCKET_INVALID ) { int err = sock_errno(); Debug( LDAP_DEBUG_ANY, "daemon: %s socket() failed errno=%d (%s)\n", @@ -1251,17 +1401,16 @@ slap_open_listener( sal++; continue; } + l.sl_sd = SLAP_SOCKNEW( s ); -#ifndef HAVE_WINSOCK if ( l.sl_sd >= dtblsize ) { Debug( LDAP_DEBUG_ANY, "daemon: listener descriptor %ld is too great %ld\n", (long) l.sl_sd, (long) dtblsize, 0 ); - tcp_close( l.sl_sd ); + tcp_close( s ); sal++; continue; } -#endif /* ! HAVE_WINSOCK */ #ifdef LDAP_PF_LOCAL if ( (*sal)->sa_family == AF_LOCAL ) { @@ -1272,7 +1421,7 @@ slap_open_listener( #ifdef SO_REUSEADDR /* enable address reuse */ tmp = 1; - rc = setsockopt( l.sl_sd, SOL_SOCKET, SO_REUSEADDR, + rc = setsockopt( s, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, sizeof(tmp) ); if ( rc == AC_SOCKET_ERROR ) { int err = sock_errno(); @@ -1292,7 +1441,7 @@ slap_open_listener( #ifdef IPV6_V6ONLY /* Try to use IPv6 sockets for IPv6 only */ tmp = 1; - rc = setsockopt( l.sl_sd, IPPROTO_IPV6, IPV6_V6ONLY, + rc = setsockopt( s , IPPROTO_IPV6, IPV6_V6ONLY, (char *) &tmp, sizeof(tmp) ); if ( rc == AC_SOCKET_ERROR ) { int err = sock_errno(); @@ -1310,7 +1459,7 @@ slap_open_listener( #ifdef LOCAL_CREDS { int one = 1; - setsockopt( l.sl_sd, 0, LOCAL_CREDS, &one, sizeof( one ) ); + setsockopt( s, 0, LOCAL_CREDS, &one, sizeof( one ) ); } #endif /* LOCAL_CREDS */ @@ -1334,7 +1483,7 @@ slap_open_listener( old_umask = umask( 0 ); } #endif /* LDAP_PF_LOCAL */ - rc = bind( l.sl_sd, *sal, addrlen ); + rc = bind( s, *sal, addrlen ); #ifdef LDAP_PF_LOCAL if ( (*sal)->sa_family == AF_LOCAL ) { umask( old_umask ); @@ -1346,7 +1495,7 @@ slap_open_listener( Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno=%d (%s)\n", (long)l.sl_sd, err, sock_errstr( err ) ); - tcp_close( l.sl_sd ); + tcp_close( s ); sal++; continue; } @@ -1387,9 +1536,9 @@ slap_open_listener( inet_ntop( AF_INET6, &((struct sockaddr_in6 *)*sal)->sin6_addr, addr, sizeof addr); port = ntohs( ((struct sockaddr_in6 *)*sal)->sin6_port ); - l.sl_name.bv_len = strlen(addr) + sizeof("IP= 65535"); + l.sl_name.bv_len = strlen(addr) + sizeof("IP=[]:65535"); l.sl_name.bv_val = ber_memalloc( l.sl_name.bv_len ); - snprintf( l.sl_name.bv_val, l.sl_name.bv_len, "IP=%s %d", + snprintf( l.sl_name.bv_val, l.sl_name.bv_len, "IP=[%s]:%d", addr, port ); l.sl_name.bv_len = strlen( l.sl_name.bv_val ); } break; @@ -1444,7 +1593,7 @@ slapd_daemon_init( const char *urls ) #ifdef HAVE_SYSCONF dtblsize = sysconf( _SC_OPEN_MAX ); -#elif HAVE_GETDTABLESIZE +#elif defined(HAVE_GETDTABLESIZE) dtblsize = getdtablesize(); #else /* ! HAVE_SYSCONF && ! HAVE_GETDTABLESIZE */ dtblsize = FD_SETSIZE; @@ -1520,8 +1669,14 @@ int slapd_daemon_destroy( void ) { connections_destroy(); - tcp_close( wake_sds[1] ); - tcp_close( wake_sds[0] ); +#ifdef HAVE_WINSOCK + if ( wake_sds[1] != INVALID_SOCKET && wake_sds[1] != wake_sds[0] ) +#endif /* HAVE_WINSOCK */ + tcp_close( SLAP_FD2SOCK(wake_sds[1]) ); +#ifdef HAVE_WINSOCK + if ( wake_sds[0] != INVALID_SOCKET ) +#endif /* HAVE_WINSOCK */ + tcp_close( SLAP_FD2SOCK(wake_sds[0]) ); sockdestroy(); #ifdef HAVE_SLP @@ -1580,9 +1735,9 @@ slap_listener( { Sockaddr from; - ber_socket_t s; - socklen_t len = sizeof(from); - long id; + ber_socket_t s, sfd; + ber_socklen_t len = sizeof(from); + Connection *c; slap_ssf_t ssf = 0; struct berval authid = BER_BVNULL; #ifdef SLAPD_RLOOKUPS @@ -1593,11 +1748,20 @@ slap_listener( char *peeraddr = NULL; #ifdef LDAP_PF_LOCAL char peername[MAXPATHLEN + sizeof("PATH=")]; +#ifdef LDAP_PF_LOCAL_SENDMSG + char peerbuf[8]; + struct berval peerbv = BER_BVNULL; +#endif #elif defined(LDAP_PF_INET6) - char peername[sizeof("IP=ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 65535")]; + char peername[sizeof("IP=[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535")]; #else /* ! LDAP_PF_LOCAL && ! LDAP_PF_INET6 */ char peername[sizeof("IP=255.255.255.255:65336")]; #endif /* LDAP_PF_LOCAL */ + int cflag; + + Debug( LDAP_DEBUG_TRACE, + ">>> slap_listener(%s)\n", + sl->sl_url.bv_val, 0, 0 ); peername[0] = '\0'; @@ -1611,15 +1775,13 @@ slap_listener( from.sa_un_addr.sun_path[0] = '\0'; # endif /* LDAP_PF_LOCAL */ - s = accept( sl->sl_sd, (struct sockaddr *) &from, &len ); + s = accept( SLAP_FD2SOCK( sl->sl_sd ), (struct sockaddr *) &from, &len ); -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER /* Resume the listener FD to allow concurrent-processing of * additional incoming connections. */ sl->sl_busy = 0; WAKE_LISTENER(1); -#endif /* SLAP_LIGHTWEIGHT_DISPATCHER */ if ( s == AC_SOCKET_INVALID ) { int err = sock_errno(); @@ -1646,24 +1808,23 @@ slap_listener( ldap_pvt_thread_yield(); return 0; } + sfd = SLAP_SOCKNEW( s ); -#ifndef HAVE_WINSOCK /* make sure descriptor number isn't too great */ - if ( s >= dtblsize ) { + if ( sfd >= dtblsize ) { Debug( LDAP_DEBUG_ANY, "daemon: %ld beyond descriptor table size %ld\n", - (long) s, (long) dtblsize, 0 ); + (long) sfd, (long) dtblsize, 0 ); - slapd_close(s); + tcp_close(s); ldap_pvt_thread_yield(); return 0; } -#endif /* ! HAVE_WINSOCK */ #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( SLAP_SOCK_NOT_ACTIVE( s )); + assert( SLAP_SOCK_NOT_ACTIVE( sfd )); ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); #endif /* LDAP_DEBUG */ @@ -1684,7 +1845,7 @@ slap_listener( int err = sock_errno(); Debug( LDAP_DEBUG_ANY, "slapd(%ld): setsockopt(SO_KEEPALIVE) failed " - "errno=%d (%s)\n", (long) s, err, sock_errstr(err) ); + "errno=%d (%s)\n", (long) sfd, err, sock_errstr(err) ); } #endif /* SO_KEEPALIVE */ #ifdef TCP_NODELAY @@ -1696,7 +1857,7 @@ slap_listener( int err = sock_errno(); Debug( LDAP_DEBUG_ANY, "slapd(%ld): setsockopt(TCP_NODELAY) failed " - "errno=%d (%s)\n", (long) s, err, sock_errstr(err) ); + "errno=%d (%s)\n", (long) sfd, err, sock_errstr(err) ); } #endif /* TCP_NODELAY */ } @@ -1704,11 +1865,14 @@ slap_listener( Debug( LDAP_DEBUG_CONNS, "daemon: listen=%ld, new connection on %ld\n", - (long) sl->sl_sd, (long) s, 0 ); + (long) sl->sl_sd, (long) sfd, 0 ); + cflag = 0; switch ( from.sa_addr.sa_family ) { # ifdef LDAP_PF_LOCAL case AF_LOCAL: + cflag |= CONN_IS_IPC; + /* FIXME: apparently accept doesn't fill * the sun_path sun_path member */ if ( from.sa_un_addr.sun_path[0] == '\0' ) { @@ -1723,7 +1887,11 @@ slap_listener( uid_t uid; gid_t gid; - if( getpeereid( s, &uid, &gid ) == 0 ) { +#ifdef LDAP_PF_LOCAL_SENDMSG + peerbv.bv_val = peerbuf; + peerbv.bv_len = sizeof( peerbuf ); +#endif + if( LUTIL_GETPEEREID( s, &uid, &gid, &peerbv ) == 0 ) { authid.bv_val = ch_malloc( STRLENOF( "gidNumber=4294967295+uidNumber=4294967295," "cn=peercred,cn=external,cn=auth" ) + 1 ); @@ -1754,7 +1922,7 @@ slap_listener( peeraddr = (char *) inet_ntop( AF_INET6, &from.sa_in6_addr.sin6_addr, addr, sizeof addr ); - sprintf( peername, "IP=%s %d", + sprintf( peername, "IP=[%s]:%d", peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN, (unsigned) ntohs( from.sa_in6_addr.sin6_port ) ); } @@ -1762,14 +1930,14 @@ slap_listener( # endif /* LDAP_PF_INET6 */ case AF_INET: - peeraddr = inet_ntoa( from.sa_in_addr.sin_addr ); - sprintf( peername, "IP=%s:%d", - peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN, - (unsigned) ntohs( from.sa_in_addr.sin_port ) ); + peeraddr = inet_ntoa( from.sa_in_addr.sin_addr ); + sprintf( peername, "IP=%s:%d", + peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN, + (unsigned) ntohs( from.sa_in_addr.sin_port ) ); break; default: - slapd_close(s); + slapd_close(sfd); return 0; } @@ -1804,59 +1972,58 @@ slap_listener( /* DENY ACCESS */ Statslog( LDAP_DEBUG_STATS, "fd=%ld DENIED from %s (%s)\n", - (long) s, + (long) sfd, dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN, peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN, 0, 0 ); - slapd_close(s); + slapd_close(sfd); return 0; } } #endif /* HAVE_TCPD */ } - id = connection_init(s, sl, - dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN, - peername, #ifdef HAVE_TLS - sl->sl_is_tls ? CONN_IS_TLS : 0, -#else /* ! HAVE_TLS */ - 0, -#endif /* ! HAVE_TLS */ - ssf, - authid.bv_val ? &authid : NULL ); + if ( sl->sl_is_tls ) cflag |= CONN_IS_TLS; +#endif + c = connection_init(sfd, sl, + dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN, + peername, cflag, ssf, + authid.bv_val ? &authid : NULL + LDAP_PF_LOCAL_SENDMSG_ARG(&peerbv)); if( authid.bv_val ) ch_free(authid.bv_val); - if( id < 0 ) { + if( !c ) { Debug( LDAP_DEBUG_ANY, "daemon: connection_init(%ld, %s, %s) failed.\n", - (long) s, peername, sl->sl_name.bv_val ); - slapd_close(s); + (long) sfd, peername, sl->sl_name.bv_val ); + slapd_close(sfd); return 0; } Statslog( LDAP_DEBUG_STATS, "conn=%ld fd=%ld ACCEPT from %s (%s)\n", - id, (long) s, peername, sl->sl_name.bv_val, + c->c_connid, (long) sfd, peername, sl->sl_name.bv_val, 0 ); return 0; } -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER static void* slap_listener_thread( void* ctx, void* ptr ) { - int rc; + int rc; + Listener *sl = (Listener *)ptr; - rc = slap_listener( (Listener*)ptr ); + rc = slap_listener( sl ); if( rc != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_ANY, - "listener_thread: failed %d", rc, 0, 0 ); + "slap_listener_thread(%s): failed err=%d", + sl->sl_url.bv_val, rc, 0 ); } return (void*)NULL; @@ -1883,7 +2050,6 @@ slap_listener_activate( } return rc; } -#endif /* SLAP_LIGHTWEIGHT_DISPATCHER */ static void * slapd_daemon_task( @@ -1891,24 +2057,12 @@ slapd_daemon_task( { int l; time_t last_idle_check = 0; - struct timeval idle; int ebadf = 0; #define SLAPD_IDLE_CHECK_LIMIT 4 if ( global_idletimeout > 0 ) { last_idle_check = slap_get_time(); - /* Set the select timeout. - * Don't just truncate, preserve the fractions of - * seconds to prevent sleeping for zero time. - */ - idle.tv_sec = global_idletimeout / SLAPD_IDLE_CHECK_LIMIT; - idle.tv_usec = global_idletimeout - \ - ( idle.tv_sec * SLAPD_IDLE_CHECK_LIMIT ); - idle.tv_usec *= 1000000 / SLAPD_IDLE_CHECK_LIMIT; - } else { - idle.tv_sec = 0; - idle.tv_usec = 0; } slapd_add( wake_sds[0], 0, NULL ); @@ -1925,7 +2079,7 @@ slapd_daemon_task( continue; #endif /* LDAP_CONNECTIONLESS */ - if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN_BACKLOG ) == -1 ) { + if ( listen( SLAP_FD2SOCK( slap_listeners[l]->sl_sd ), SLAPD_LISTEN_BACKLOG ) == -1 ) { int err = sock_errno(); #ifdef LDAP_PF_INET6 @@ -1970,16 +2124,14 @@ slapd_daemon_task( return (void*)-1; } -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER /* make the listening socket non-blocking */ - if ( ber_pvt_socket_set_nonblock( slap_listeners[l]->sl_sd, 1 ) < 0 ) { + if ( ber_pvt_socket_set_nonblock( SLAP_FD2SOCK( slap_listeners[l]->sl_sd ), 1 ) < 0 ) { Debug( LDAP_DEBUG_ANY, "slapd_daemon_task: " "set nonblocking on a listening socket failed\n", 0, 0, 0 ); slapd_shutdown = 2; return (void*)-1; } -#endif /* SLAP_LIGHTWEIGHT_DISPATCHER */ slapd_add( slap_listeners[l]->sl_sd, 0, slap_listeners[l] ); } @@ -1990,15 +2142,6 @@ slapd_daemon_task( } #endif /* HAVE_NT_SERVICE_MANAGER */ -#ifdef SLAP_SEM_LOAD_CONTROL - /* - * initialize count and lazyness of a semaphore - */ - (void) ldap_lazy_sem_init( - SLAP_MAX_WORKER_THREADS + 4 /* max workers + margin */, - 4 /* lazyness */ ); -#endif /* SLAP_SEM_LOAD_CONTROL */ - /* initialization complete. Here comes the loop. */ while ( !slapd_shutdown ) { @@ -2024,14 +2167,34 @@ slapd_daemon_task( now = slap_get_time(); - if ( ( global_idletimeout > 0 ) && - difftime( last_idle_check + - global_idletimeout/SLAPD_IDLE_CHECK_LIMIT, now ) < 0 ) - { - connections_timeout_idle( now ); - last_idle_check = now; + if ( global_idletimeout > 0 || chk_writetime ) { + int check = 0; + /* Set the select timeout. + * Don't just truncate, preserve the fractions of + * seconds to prevent sleeping for zero time. + */ + if ( chk_writetime ) { + tv.tv_sec = global_writetimeout; + tv.tv_usec = global_writetimeout; + if ( difftime( chk_writetime, now ) < 0 ) + check = 2; + } else { + tv.tv_sec = global_idletimeout / SLAPD_IDLE_CHECK_LIMIT; + tv.tv_usec = global_idletimeout - \ + ( tv.tv_sec * SLAPD_IDLE_CHECK_LIMIT ); + tv.tv_usec *= 1000000 / SLAPD_IDLE_CHECK_LIMIT; + if ( difftime( last_idle_check + + global_idletimeout/SLAPD_IDLE_CHECK_LIMIT, now ) < 0 ) + check = 1; + } + if ( check ) { + connections_timeout_idle( now ); + last_idle_check = now; + } + } else { + tv.tv_sec = 0; + tv.tv_usec = 0; } - tv = idle; #ifdef SIGHUP if ( slapd_gentle_shutdown ) { @@ -2068,11 +2231,7 @@ slapd_daemon_task( if ( lr->sl_sd == AC_SOCKET_INVALID ) continue; -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER if ( lr->sl_mute || lr->sl_busy ) -#else /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ - if ( lr->sl_mute ) -#endif /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ { SLAP_SOCK_CLR_READ( lr->sl_sd ); } else { @@ -2117,8 +2276,14 @@ slapd_daemon_task( ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); if ( rtask && cat.tv_sec ) { - time_t diff = difftime( cat.tv_sec, now ); - if ( diff == 0 ) diff = tdelta; + /* NOTE: diff __should__ always be >= 0, + * AFAI understand; however (ITS#4872), + * time_t might be unsigned in some systems, + * while difftime() returns a double */ + double diff = difftime( cat.tv_sec, now ); + if ( diff <= 0 ) { + diff = tdelta; + } if ( tvp == NULL || diff < tv.tv_sec ) { tv.tv_sec = diff; tv.tv_usec = 0; @@ -2141,7 +2306,6 @@ slapd_daemon_task( continue; } -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER if ( lr->sl_busy ) { Debug( LDAP_DEBUG_CONNS, "daemon: " SLAP_EVENT_FNAME ": " @@ -2149,7 +2313,6 @@ slapd_daemon_task( lr->sl_sd, 0, 0 ); continue; } -#endif /* SLAP_LIGHTWEIGHT_DISPATCHER */ Debug( LDAP_DEBUG_CONNS, "daemon: " SLAP_EVENT_FNAME ": " @@ -2170,7 +2333,7 @@ slapd_daemon_task( Debug( LDAP_DEBUG_ANY, "daemon: " SLAP_EVENT_FNAME - "failed count %d " + " failed count %d " "err (%d): %s\n", ebadf, err, sock_errstr( err ) ); @@ -2208,7 +2371,7 @@ slapd_daemon_task( char c[BUFSIZ]; SLAP_EVENT_CLR_READ( wake_sds[0] ); waking = 0; - tcp_read( wake_sds[0], c, sizeof(c) ); + tcp_read( SLAP_FD2SOCK(wake_sds[0]), c, sizeof(c) ); Debug( LDAP_DEBUG_CONNS, "daemon: waked\n", 0, 0, 0 ); continue; } @@ -2232,11 +2395,7 @@ slapd_daemon_task( SLAP_EVENT_CLR_WRITE( slap_listeners[l]->sl_sd ); ns--; -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER rc = slap_listener_activate( slap_listeners[l] ); -#else /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ - rc = slap_listener( slap_listeners[l] ); -#endif /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ } /* bypass the following tests if no descriptors left */ @@ -2248,19 +2407,6 @@ slapd_daemon_task( } Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 ); -#ifdef HAVE_WINSOCK - nrfds = readfds.fd_count; - nwfds = writefds.fd_count; - 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 /* ! HAVE_WINSOCK */ nrfds = 0; nwfds = 0; for ( i = 0; i < nfds; i++ ) { @@ -2283,18 +2429,13 @@ slapd_daemon_task( } if ( ns <= 0 ) break; } -#endif /* ! HAVE_WINSOCK */ Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 ); /* loop through the writers */ for ( i = 0; nwfds > 0; i++ ) { ber_socket_t wd; -#ifdef HAVE_WINSOCK - wd = writefds.fd_array[i]; -#else /* ! HAVE_WINSOCK */ if ( ! SLAP_EVENT_IS_WRITE( i ) ) continue; wd = i; -#endif /* ! HAVE_WINSOCK */ SLAP_EVENT_CLR_WRITE( wd ); nwfds--; @@ -2322,12 +2463,8 @@ slapd_daemon_task( for ( i = 0; nrfds > 0; i++ ) { ber_socket_t rd; -#ifdef HAVE_WINSOCK - rd = readfds.fd_array[i]; -#else /* ! HAVE_WINSOCK */ if ( ! SLAP_EVENT_IS_READ( i ) ) continue; rd = i; -#endif /* ! HAVE_WINSOCK */ SLAP_EVENT_CLR_READ( rd ); nrfds--; @@ -2340,11 +2477,7 @@ slapd_daemon_task( * active. */ -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER connection_read_activate( rd ); -#else /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ - connection_read( rd ); -#endif /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ } #else /* !SLAP_EVENTS_ARE_INDEXED */ /* FIXME */ @@ -2367,7 +2500,7 @@ slapd_daemon_task( Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 ); for ( i = 0; i < ns; i++ ) { - int r, w; + int r, w, fd; /* Don't log listener events */ if ( SLAP_EVENT_IS_LISTENER( i ) @@ -2379,13 +2512,14 @@ slapd_daemon_task( continue; } + fd = SLAP_EVENT_FD( i ); /* Don't log internal wake events */ - if ( SLAP_EVENT_FD( i ) == wake_sds[0] ) continue; + if ( fd == wake_sds[0] ) continue; r = SLAP_EVENT_IS_READ( i ); w = SLAP_EVENT_IS_WRITE( i ); if ( r || w ) { - Debug( LDAP_DEBUG_CONNS, " %d%s%s", SLAP_EVENT_FD(i), + Debug( LDAP_DEBUG_CONNS, " %d%s%s", fd, r ? "r" : "", w ? "w" : "" ); } } @@ -2393,14 +2527,10 @@ slapd_daemon_task( #endif /* LDAP_DEBUG */ for ( i = 0; i < ns; i++ ) { - int rc = 1, fd; + int rc = 1, fd, w = 0; if ( SLAP_EVENT_IS_LISTENER( i ) ) { -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER rc = slap_listener_activate( SLAP_EVENT_LISTENER( i ) ); -#else /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ - rc = slap_listener( SLAP_EVENT_LISTENER( i ) ); -#endif /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ } /* If we found a regular listener, rc is now zero, and we @@ -2414,8 +2544,8 @@ slapd_daemon_task( if ( fd == wake_sds[0] ) { char c[BUFSIZ]; waking = 0; - tcp_read( wake_sds[0], c, sizeof(c) ); - break; + tcp_read( SLAP_FD2SOCK(wake_sds[0]), c, sizeof(c) ); + continue; } if ( SLAP_EVENT_IS_WRITE( i ) ) { @@ -2424,6 +2554,7 @@ slapd_daemon_task( fd, 0, 0 ); SLAP_EVENT_CLR_WRITE( i ); + w = 1; /* * NOTE: it is possible that the connection was closed @@ -2442,20 +2573,18 @@ slapd_daemon_task( fd, 0, 0 ); SLAP_EVENT_CLR_READ( i ); -#ifdef SLAP_LIGHTWEIGHT_DISPATCHER connection_read_activate( fd ); -#else /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ - /* - * 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. - */ - connection_read( fd ); -#endif /* ! SLAP_LIGHTWEIGHT_DISPATCHER */ - } else { + } else if ( !w ) { Debug( LDAP_DEBUG_CONNS, "daemon: hangup on %d\n", fd, 0, 0 ); + if ( SLAP_SOCK_IS_ACTIVE( fd )) { +#ifdef HAVE_EPOLL + /* Don't keep reporting the hangup + */ + SLAP_EPOLL_SOCK_SET( fd, EPOLLET ); +#endif + connection_hangup( fd ); + } } } } @@ -2494,9 +2623,12 @@ slapd_daemon_task( connections_shutdown(); } - Debug( LDAP_DEBUG_ANY, - "slapd shutdown: waiting for %d threads to terminate\n", - ldap_pvt_thread_pool_backload( &connection_pool ), 0, 0 ); + if ( LogTest( LDAP_DEBUG_ANY )) { + int t = ldap_pvt_thread_pool_backload( &connection_pool ); + Debug( LDAP_DEBUG_ANY, + "slapd shutdown: waiting for %d operations/tasks to finish\n", + t, 0, 0 ); + } ldap_pvt_thread_pool_destroy( &connection_pool, 1 ); free( slap_listeners ); @@ -2514,16 +2646,17 @@ connectionless_init( void ) for ( l = 0; slap_listeners[l] != NULL; l++ ) { Listener *lr = slap_listeners[l]; - long id; + Connection *c; if ( !lr->sl_is_udp ) { continue; } - id = connection_init( lr->sl_sd, lr, "", "", - CONN_IS_UDP, (slap_ssf_t) 0, NULL ); + c = connection_init( lr->sl_sd, lr, "", "", + CONN_IS_UDP, (slap_ssf_t) 0, NULL + LDAP_PF_LOCAL_SENDMSG_ARG(NULL)); - if ( id < 0 ) { + if ( !c ) { Debug( LDAP_DEBUG_TRACE, "connectionless_init: failed on %s (%d)\n", lr->sl_url, lr->sl_sd, 0 ); @@ -2541,7 +2674,6 @@ slapd_daemon( void ) { int rc; - connections_init(); #ifdef LDAP_CONNECTIONLESS connectionless_init(); #endif /* LDAP_CONNECTIONLESS */ @@ -2637,7 +2769,7 @@ slap_sig_shutdown( int sig ) * SIGBREAK is generated when a user logs out. */ -#if HAVE_NT_SERVICE_MANAGER && SIGBREAK +#if defined(HAVE_NT_SERVICE_MANAGER) && defined(SIGBREAK) if (is_NT_Service && sig == SIGBREAK) { /* empty */; } else