3 * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
4 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
13 #include <ac/signal.h>
14 #include <ac/socket.h>
15 #include <ac/string.h>
17 #include <ac/unistd.h>
20 #include "ldap_pvt_thread.h"
27 int allow_severity = LOG_INFO;
28 int deny_severity = LOG_NOTICE;
29 #endif /* TCP Wrappers */
33 /* this should go in <ldap.h> as soon as it is accepted */
34 #define LDAPI_MOD_URLEXT "x-mod"
35 #endif /* LDAP_PF_LOCAL */
39 ber_socket_t dtblsize;
41 Listener **slap_listeners = NULL;
43 #define SLAPD_LISTEN 10
45 static ber_socket_t wake_sds[2];
49 #define WAKE_LISTENER(w) \
50 ((w && !waking) ? tcp_write( wake_sds[1], "0", 1 ), waking=1 : 0)
52 #define WAKE_LISTENER(w) \
53 do { if (w) tcp_write( wake_sds[1], "0", 1 ); } while(0)
59 volatile sig_atomic_t slapd_shutdown = 0;
61 static struct slap_daemon {
62 ldap_pvt_thread_mutex_t sd_mutex;
67 /* In winsock, accept() returns values higher than dtblsize
68 so don't bother with this optimization */
81 * SLP related functions
85 #define LDAP_SRVTYPE_PREFIX "service:ldap://"
86 #define LDAPS_SRVTYPE_PREFIX "service:ldaps://"
87 static char** slapd_srvurls = NULL;
88 static SLPHandle slapd_hslp = 0;
90 void slapd_slp_init( const char* urls ) {
93 slapd_srvurls = str2charray( urls, " " );
95 if( slapd_srvurls == NULL ) return;
97 /* find and expand INADDR_ANY URLs */
98 for( i=0; slapd_srvurls[i] != NULL; i++ ) {
99 if( strcmp( slapd_srvurls[i], "ldap:///" ) == 0) {
100 char *host = ldap_pvt_get_fqdn( NULL );
101 if ( host != NULL ) {
102 slapd_srvurls[i] = (char *) realloc( slapd_srvurls[i],
104 sizeof( LDAP_SRVTYPE_PREFIX ) );
105 strcpy( slap_strcopy(slapd_srvurls[i],
106 LDAP_SRVTYPE_PREFIX ), host );
111 } else if ( strcmp( slapd_srvurls[i], "ldaps:///" ) == 0) {
112 char *host = ldap_pvt_get_fqdn( NULL );
113 if ( host != NULL ) {
114 slapd_srvurls[i] = (char *) realloc( slapd_srvurls[i],
116 sizeof( LDAPS_SRVTYPE_PREFIX ) );
117 strcpy( slap_strcopy(slapd_srvurls[i],
118 LDAPS_SRVTYPE_PREFIX ), host );
125 /* open the SLP handle */
126 SLPOpen( "en", 0, &slapd_hslp );
129 void slapd_slp_deinit() {
130 if( slapd_srvurls == NULL ) return;
132 charray_free( slapd_srvurls );
133 slapd_srvurls = NULL;
135 /* close the SLP handle */
136 SLPClose( slapd_hslp );
139 void slapd_slp_regreport(
147 void slapd_slp_reg() {
150 for( i=0; slapd_srvurls[i] != NULL; i++ ) {
151 if( strncmp( slapd_srvurls[i], LDAP_SRVTYPE_PREFIX,
152 sizeof( LDAP_SRVTYPE_PREFIX ) - 1 ) == 0 ||
153 strncmp( slapd_srvurls[i], LDAPS_SRVTYPE_PREFIX,
154 sizeof( LDAPS_SRVTYPE_PREFIX ) - 1 ) == 0 )
158 SLP_LIFETIME_MAXIMUM,
168 void slapd_slp_dereg() {
171 for( i=0; slapd_srvurls[i] != NULL; i++ ) {
172 SLPDereg( slapd_hslp,
178 #endif /* HAVE_SLP */
181 * Add a descriptor to daemon control
183 static void slapd_add(ber_socket_t s) {
184 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
186 assert( !FD_ISSET( s, &slap_daemon.sd_actives ));
187 assert( !FD_ISSET( s, &slap_daemon.sd_readers ));
188 assert( !FD_ISSET( s, &slap_daemon.sd_writers ));
191 if (s >= slap_daemon.sd_nfds) {
192 slap_daemon.sd_nfds = s + 1;
196 FD_SET( s, &slap_daemon.sd_actives );
197 FD_SET( s, &slap_daemon.sd_readers );
200 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
201 "slapd_add: added %ld%s%s\n",
203 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
204 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ));
206 Debug( LDAP_DEBUG_CONNS, "daemon: added %ld%s%s\n",
208 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
209 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
211 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
215 * Remove the descriptor from daemon control
217 void slapd_remove(ber_socket_t s, int wake) {
218 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
221 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
222 "slapd_remove: removing %ld%s%s\n",
224 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
225 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ));
227 Debug( LDAP_DEBUG_CONNS, "daemon: removing %ld%s%s\n",
229 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
230 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
232 FD_CLR( s, &slap_daemon.sd_actives );
233 FD_CLR( s, &slap_daemon.sd_readers );
234 FD_CLR( s, &slap_daemon.sd_writers );
236 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
240 void slapd_clr_write(ber_socket_t s, int wake) {
241 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
243 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
244 FD_CLR( s, &slap_daemon.sd_writers );
246 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
250 void slapd_set_write(ber_socket_t s, int wake) {
251 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
253 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
254 if (!FD_ISSET(s, &slap_daemon.sd_writers))
255 FD_SET( (unsigned) s, &slap_daemon.sd_writers );
257 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
261 void slapd_clr_read(ber_socket_t s, int wake) {
262 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
264 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
265 FD_CLR( s, &slap_daemon.sd_readers );
267 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
271 void slapd_set_read(ber_socket_t s, int wake) {
272 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
274 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
275 if (!FD_ISSET(s, &slap_daemon.sd_readers))
276 FD_SET( s, &slap_daemon.sd_readers );
278 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
282 static void slapd_close(ber_socket_t s) {
284 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
285 "slapd_close: closing %ld\n", (long)s ));
287 Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n",
293 static void slap_free_listener_addresses(struct sockaddr **sal)
295 struct sockaddr **sap;
301 for (sap = sal; *sap != NULL; sap++) {
309 static int get_url_perms(
321 for ( i = 0; exts[ i ]; i++ ) {
322 char *type = exts[ i ];
325 if ( type[ 0 ] == '!' ) {
330 if ( strncasecmp( type, LDAPI_MOD_URLEXT "=", sizeof(LDAPI_MOD_URLEXT "=") - 1 ) == 0 ) {
331 char *value = type + sizeof(LDAPI_MOD_URLEXT "=") - 1;
335 if ( strlen( value ) != 9 ) {
339 switch ( value[ 0 ] ) {
349 switch ( value[ 1 ] ) {
359 switch ( value[ 2 ] ) {
369 switch ( value[ 3 ] ) {
379 switch ( value[ 4 ] ) {
389 switch ( value[ 5 ] ) {
399 switch ( value[ 6 ] ) {
409 switch ( value[ 7 ] ) {
419 switch ( value[ 8 ] ) {
429 if ( strlen(value) != 3 ) {
433 switch ( value[ 0 ] ) {
443 switch ( value[ 1 ] ) {
453 switch ( value[ 2 ] ) {
471 #endif /* LDAP_PF_LOCAL */
473 /* port = 0 indicates AF_LOCAL */
474 static int slap_get_listener_addresses(
477 struct sockaddr ***sal)
479 struct sockaddr **sap;
483 *sal = ch_malloc(2 * sizeof(void *));
489 *sap = ch_malloc(sizeof(struct sockaddr_un));
495 (sizeof(((struct sockaddr_un *)*sap)->sun_path) - 1) ) {
497 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
498 "slap_get_listener_addresses: domain socket path (%s) too long in URL\n",
501 Debug( LDAP_DEBUG_ANY,
502 "daemon: domain socket path (%s) too long in URL",
508 (void)memset( (void *)*sap, '\0', sizeof(struct sockaddr_un) );
509 (*sap)->sa_family = AF_LOCAL;
510 strcpy( ((struct sockaddr_un *)*sap)->sun_path, host );
514 #ifdef HAVE_GETADDRINFO
515 struct addrinfo hints, *res, *sai;
519 memset( &hints, '\0', sizeof(hints) );
520 hints.ai_flags = AI_PASSIVE;
521 hints.ai_socktype = SOCK_STREAM;
522 hints.ai_family = AF_UNSPEC;
523 snprintf(serv, sizeof serv, "%d", port);
525 if ( (err = getaddrinfo(host, serv, &hints, &res)) ) {
527 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
528 "slap_get_listener_addresses: getaddrinfo failed: %s\n",
529 AC_GAI_STRERROR(err) ));
531 Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed: %s\n",
532 AC_GAI_STRERROR(err), 0, 0);
538 for (n=2; (sai = sai->ai_next) != NULL; n++) {
541 *sal = ch_calloc(n, sizeof(void *));
549 for ( sai=res; sai; sai=sai->ai_next ) {
550 if( sai->ai_addr == NULL ) {
552 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
553 "slap_get_listener_addresses: "
554 "getaddrinfo ai_addr is NULL?\n" ));
556 Debug( LDAP_DEBUG_ANY, "slap_get_listener_addresses: "
557 "getaddrinfo ai_addr is NULL?\n", 0, 0, 0 );
563 switch (sai->ai_family) {
564 # ifdef LDAP_PF_INET6
566 *sap = ch_malloc(sizeof(struct sockaddr_in6));
571 *(struct sockaddr_in6 *)*sap =
572 *((struct sockaddr_in6 *)sai->ai_addr);
576 *sap = ch_malloc(sizeof(struct sockaddr_in));
581 *(struct sockaddr_in *)*sap =
582 *((struct sockaddr_in *)sai->ai_addr);
590 (*sap)->sa_family = sai->ai_family;
600 if ( host == NULL ) {
601 in.s_addr = htonl(INADDR_ANY);
603 } else if ( !inet_aton( host, &in ) ) {
604 struct hostent *he = gethostbyname( host );
607 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
608 "slap_get_listener_addresses: invalid host %s\n",
611 Debug( LDAP_DEBUG_ANY,
612 "daemon: invalid host %s", host, 0, 0);
616 AC_MEMCPY( &in, he->h_addr, sizeof( in ) );
619 *sal = ch_malloc(2 * sizeof(void *));
625 *sap = ch_malloc(sizeof(struct sockaddr_in));
631 (void)memset( (void *)*sap, '\0', sizeof(struct sockaddr_in) );
632 (*sap)->sa_family = AF_INET;
633 ((struct sockaddr_in *)*sap)->sin_port = htons(port);
634 ((struct sockaddr_in *)*sap)->sin_addr = in;
641 slap_free_listener_addresses(*sal);
645 static Listener * slap_open_listener(
653 int err, addrlen = 0;
654 struct sockaddr **sal, **psal;
655 int socktype = SOCK_STREAM; /* default to COTS */
657 mode_t perms = S_IRWXU;
661 rc = ldap_url_parse( url, &lud );
663 if( rc != LDAP_URL_SUCCESS ) {
665 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
666 "slap_open_listener: listen URL \"%s\" parse error %d\n",
669 Debug( LDAP_DEBUG_ANY,
670 "daemon: listen URL \"%s\" parse error=%d\n",
677 if( ldap_pvt_url_scheme2tls( lud->lud_scheme ) ) {
679 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
680 "slap_open_listener: TLS is not supported (%s)\n",
683 Debug( LDAP_DEBUG_ANY,
684 "daemon: TLS not supported (%s)\n",
687 ldap_free_urldesc( lud );
691 if(! lud->lud_port ) {
692 lud->lud_port = LDAP_PORT;
696 l.sl_is_tls = ldap_pvt_url_scheme2tls( lud->lud_scheme );
698 if(! lud->lud_port ) {
699 lud->lud_port = l.sl_is_tls ? LDAPS_PORT : LDAP_PORT;
703 port = (unsigned short) lud->lud_port;
705 tmp = ldap_pvt_url_scheme2proto(lud->lud_scheme);
706 if ( tmp == LDAP_PROTO_IPC ) {
708 if ( lud->lud_host == NULL || lud->lud_host[0] == '\0' ) {
709 err = slap_get_listener_addresses(LDAPI_SOCK, 0, &sal);
711 err = slap_get_listener_addresses(lud->lud_host, 0, &sal);
714 if ( lud->lud_exts ) {
715 err = get_url_perms( lud->lud_exts, &perms, &crit );
720 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
721 "slap_open_listener: URL scheme is not supported: %s\n",
724 Debug( LDAP_DEBUG_ANY, "daemon: URL scheme not supported: %s",
727 ldap_free_urldesc( lud );
731 #ifdef LDAP_CONNECTIONLESS
732 l.sl_is_udp = ( tmp == LDAP_PROTO_UDP );
734 if( lud->lud_host == NULL || lud->lud_host[0] == '\0'
735 || strcmp(lud->lud_host, "*") == 0 )
737 err = slap_get_listener_addresses(NULL, port, &sal);
739 err = slap_get_listener_addresses(lud->lud_host, port, &sal);
743 ldap_free_urldesc( lud );
749 while ( *sal != NULL ) {
750 switch( (*sal)->sa_family ) {
763 #ifdef LDAP_CONNECTIONLESS
765 socktype = SOCK_DGRAM;
767 l.sl_sd = socket( (*sal)->sa_family, socktype, 0);
768 if ( l.sl_sd == AC_SOCKET_INVALID ) {
769 int err = sock_errno();
771 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
772 "slap_open_listener: socket() failed errno=%d (%s)\n",
773 err, sock_errstr(err) ));
775 Debug( LDAP_DEBUG_ANY,
776 "daemon: socket() failed errno=%d (%s)\n", err,
777 sock_errstr(err), 0 );
783 if ( l.sl_sd >= dtblsize ) {
785 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
786 "slap_open_listener: listener descriptor %ld is too great %ld\n",
787 (long)l.sl_sd, (long)dtblsize ));
789 Debug( LDAP_DEBUG_ANY,
790 "daemon: listener descriptor %ld is too great %ld\n",
791 (long) l.sl_sd, (long) dtblsize, 0 );
793 tcp_close( l.sl_sd );
799 if ( (*sal)->sa_family == AF_LOCAL ) {
800 unlink ( ((struct sockaddr_un *)*sal)->sun_path );
805 /* enable address reuse */
807 rc = setsockopt( l.sl_sd, SOL_SOCKET, SO_REUSEADDR,
808 (char *) &tmp, sizeof(tmp) );
809 if ( rc == AC_SOCKET_ERROR ) {
810 int err = sock_errno();
812 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
813 "slap_open_listener: setsockopt( %ld, SO_REUSEADDR ) failed errno %d (%s)\n",
814 (long)l.sl_sd, err, sock_errstr(err) ));
816 Debug( LDAP_DEBUG_ANY,
817 "slapd(%ld): setsockopt(SO_REUSEADDR) failed errno=%d (%s)\n",
818 (long) l.sl_sd, err, sock_errstr(err) );
824 switch( (*sal)->sa_family ) {
826 addrlen = sizeof(struct sockaddr_in);
830 addrlen = sizeof(struct sockaddr_in6);
835 addrlen = sizeof(struct sockaddr_un);
840 if (!bind(l.sl_sd, *sal, addrlen))
844 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
845 "slap_open_listener: bind(%ld) failed errno=%d (%s)\n",
846 (long)l.sl_sd, err, sock_errstr(err) ));
848 Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno=%d (%s)\n",
849 (long) l.sl_sd, err, sock_errstr(err) );
851 tcp_close( l.sl_sd );
853 } /* while ( *sal != NULL ) */
855 if ( *sal == NULL ) {
857 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
858 "slap_open_listener: bind(%ld) failed.\n", (long)l.sl_sd ));
860 Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed\n",
861 (long) l.sl_sd, 0, 0 );
863 slap_free_listener_addresses(psal);
867 switch ( (*sal)->sa_family ) {
870 char *addr = ((struct sockaddr_un *)*sal)->sun_path;
871 if ( chmod( addr, perms ) < 0 && crit ) {
872 int err = sock_errno();
874 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
875 "slap_open_listener: fchmod(%ld) failed errno=%d (%s)\n",
876 (long)l.sl_sd, err, sock_errstr(err) ));
878 Debug( LDAP_DEBUG_ANY, "daemon: fchmod(%ld) failed errno=%d (%s)",
879 (long) l.sl_sd, err, sock_errstr(err) );
881 tcp_close( l.sl_sd );
882 slap_free_listener_addresses(psal);
885 l.sl_name = ch_malloc( strlen(addr) + sizeof("PATH=") );
886 sprintf( l.sl_name, "PATH=%s", addr );
888 #endif /* LDAP_PF_LOCAL */
892 #if defined( HAVE_GETADDRINFO ) && defined( HAVE_INET_NTOP )
893 char addr[INET_ADDRSTRLEN];
894 inet_ntop( AF_INET, &((struct sockaddr_in *)*sal)->sin_addr,
895 addr, sizeof(addr) );
898 s = inet_ntoa( ((struct sockaddr_in *) *sal)->sin_addr );
900 port = ((struct sockaddr_in *)*sal) ->sin_port;
901 l.sl_name = ch_malloc( sizeof("IP=255.255.255.255:65535") );
902 sprintf( l.sl_name, "IP=%s:%d",
903 s != NULL ? s : "unknown" , port );
908 char addr[INET6_ADDRSTRLEN];
909 inet_ntop( AF_INET6, &((struct sockaddr_in6 *)*sal)->sin6_addr,
911 port = ((struct sockaddr_in6 *)*sal)->sin6_port;
912 l.sl_name = ch_malloc( strlen(addr) + sizeof("IP= 65535") );
913 sprintf( l.sl_name, "IP=%s %d", addr, port );
915 #endif /* LDAP_PF_INET6 */
919 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
920 "slap_open_listener: unsupported address family (%d)\n",
921 (int)(*sal)->sa_family ));
923 Debug( LDAP_DEBUG_ANY, "daemon: unsupported address family (%d)\n",
924 (int) (*sal)->sa_family, 0, 0 );
929 slap_free_listener_addresses(psal);
931 l.sl_url = ch_strdup( url );
932 li = ch_malloc( sizeof( Listener ) );
936 LDAP_LOG(( "connection", LDAP_LEVEL_RESULTS,
937 "slap_open_listener: daemon initialzed %s\n", l.sl_url ));
939 Debug( LDAP_DEBUG_TRACE, "daemon: initialized %s\n",
945 static int sockinit(void);
946 static int sockdestroy(void);
948 int slapd_daemon_init( const char *urls )
954 LDAP_LOG(( "connection", LDAP_LEVEL_ARGS,
955 "slapd_daemon_init: %s\n",
956 urls ? urls : "<null>" ));
958 Debug( LDAP_DEBUG_ARGS, "daemon_init: %s\n",
959 urls ? urls : "<null>", 0, 0 );
961 if( (rc = sockinit()) != 0 ) {
966 dtblsize = sysconf( _SC_OPEN_MAX );
967 #elif HAVE_GETDTABLESIZE
968 dtblsize = getdtablesize();
970 dtblsize = FD_SETSIZE;
974 if(dtblsize > FD_SETSIZE) {
975 dtblsize = FD_SETSIZE;
977 #endif /* !FD_SETSIZE */
979 /* open a pipe (or something equivalent connected to itself).
980 * we write a byte on this fd whenever we catch a signal. The main
981 * loop will be select'ing on this socket, and will wake up when
984 if( (rc = lutil_pair( wake_sds )) < 0 ) {
986 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
987 "slap_daemon_init: lutil_pair() failed rc=%d\n", rc ));
989 Debug( LDAP_DEBUG_ANY,
990 "daemon: lutil_pair() failed rc=%d\n", rc, 0, 0 );
995 FD_ZERO( &slap_daemon.sd_readers );
996 FD_ZERO( &slap_daemon.sd_writers );
1002 u = str2charray( urls, " " );
1004 if( u == NULL || u[0] == NULL ) {
1006 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
1007 "slap_daemon_init: no urls (%s) provided.\n", urls ));
1009 Debug( LDAP_DEBUG_ANY, "daemon_init: no urls (%s) provided.\n",
1015 for( i=0; u[i] != NULL; i++ ) {
1017 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
1018 "slap_daemon_init: listen on %s\n.", u[i] ));
1020 Debug( LDAP_DEBUG_TRACE, "daemon_init: listen on %s\n",
1027 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
1028 "slap_daemon_init: no listeners to open (%s)\n", urls ));
1030 Debug( LDAP_DEBUG_ANY, "daemon_init: no listeners to open (%s)\n",
1038 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
1039 "slap_daemon_init: %d listeners to open...\n", i ));
1041 Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners to open...\n",
1044 slap_listeners = ch_malloc( (i+1)*sizeof(Listener *) );
1046 for(i = 0; u[i] != NULL; i++ ) {
1047 slap_listeners[i] = slap_open_listener( u[i] );
1049 if( slap_listeners[i] == NULL ) {
1054 slap_listeners[i] = NULL;
1057 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
1058 "slap_daemon_init: %d listeners opened\n", i ));
1060 Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners opened\n",
1065 slapd_slp_init( urls );
1070 ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
1076 slapd_daemon_destroy(void)
1078 connections_destroy();
1079 tcp_close( wake_sds[1] );
1080 tcp_close( wake_sds[0] );
1098 time_t last_idle_check = 0;
1101 if ( global_idletimeout > 0 ) {
1102 last_idle_check = slap_get_time();
1104 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1105 if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
1107 #ifdef LDAP_CONNECTIONLESS
1108 /* Since this is connectionless, the data port is the
1109 * listening port. The listen() and accept() calls
1112 if ( slap_listeners[l]->sl_is_udp )
1114 slapd_add( slap_listeners[l]->sl_sd );
1119 if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN ) == -1 ) {
1120 int err = sock_errno();
1122 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
1123 "slapd_daemon_task: listen( %s, 5 ) failed errno=%d (%s)\n",
1124 slap_listeners[l]->sl_url, err, sock_errstr(err) ));
1126 Debug( LDAP_DEBUG_ANY,
1127 "daemon: listen(%s, 5) failed errno=%d (%s)\n",
1128 slap_listeners[l]->sl_url, err,
1131 return( (void*)-1 );
1134 slapd_add( slap_listeners[l]->sl_sd );
1137 #ifdef HAVE_NT_SERVICE_MANAGER
1138 if ( started_event != NULL ) {
1139 ldap_pvt_thread_cond_signal( &started_event );
1142 /* initialization complete. Here comes the loop. */
1144 while ( !slapd_shutdown ) {
1149 #define SLAPD_EBADF_LIMIT 16
1153 #define SLAPD_IDLE_CHECK_LIMIT 4
1161 #if defined(SLAPD_RLOOKUPS)
1164 struct timeval zero;
1165 struct timeval *tvp;
1168 now = slap_get_time();
1169 connections_timeout_idle( now );
1171 else if ( global_idletimeout > 0 ) {
1172 now = slap_get_time();
1173 if ( difftime( last_idle_check+global_idletimeout/SLAPD_IDLE_CHECK_LIMIT, now ) < 0 ) {
1174 connections_timeout_idle( now );
1178 FD_ZERO( &writefds );
1179 FD_ZERO( &readfds );
1184 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
1186 #ifdef FD_SET_MANUAL_COPY
1187 for( s = 0; s < nfds; s++ ) {
1188 if(FD_ISSET( &slap_sd_readers, s )) {
1189 FD_SET( s, &readfds );
1191 if(FD_ISSET( &slap_sd_writers, s )) {
1192 FD_SET( s, &writefds );
1196 AC_MEMCPY( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
1197 AC_MEMCPY( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
1199 assert(!FD_ISSET(wake_sds[0], &readfds));
1200 FD_SET( wake_sds[0], &readfds );
1202 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1203 if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
1205 if (!FD_ISSET(slap_listeners[l]->sl_sd, &readfds))
1206 FD_SET( slap_listeners[l]->sl_sd, &readfds );
1209 #ifndef HAVE_WINSOCK
1210 nfds = slap_daemon.sd_nfds;
1215 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
1217 at = ldap_pvt_thread_pool_backload(&connection_pool);
1219 #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
1222 tvp = at ? &zero : NULL;
1225 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1226 if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
1230 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
1231 "slapd_daemon_task: select: listen=%d active_threads=%d tvp=%s\n",
1232 slap_listeners[l]->sl_sd, at, tvp == NULL ? "NULL" : "zero" ));
1234 Debug( LDAP_DEBUG_CONNS,
1235 "daemon: select: listen=%d active_threads=%d tvp=%s\n",
1236 slap_listeners[l]->sl_sd, at,
1237 tvp == NULL ? "NULL" : "zero" );
1241 switch(ns = select( nfds, &readfds,
1243 /* don't pass empty fd_set */
1244 ( writefds.fd_count > 0 ? &writefds : NULL ),
1250 case -1: { /* failure - try again */
1251 int err = sock_errno();
1255 /* you'd think this would be EBADF */
1256 || err == WSAENOTSOCK
1259 if (++ebadf < SLAPD_EBADF_LIMIT)
1263 if( err != EINTR ) {
1265 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
1266 "slapd_daemon_task: select failed (%d): %s\n",
1267 err, sock_errstr(err) ));
1269 Debug( LDAP_DEBUG_CONNS,
1270 "daemon: select failed (%d): %s\n",
1271 err, sock_errstr(err), 0 );
1273 slapd_shutdown = -1;
1278 case 0: /* timeout - let threads run */
1281 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
1282 "slapd_daemon_task: select timeout - yielding\n" ));
1284 Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
1287 ldap_pvt_thread_yield();
1290 default: /* something happened - deal with it */
1291 if( slapd_shutdown ) continue;
1295 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
1296 "slapd_daemon_task: activity on %d descriptors\n", ns ));
1298 Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
1304 if( FD_ISSET( wake_sds[0], &readfds ) ) {
1306 tcp_read( wake_sds[0], c, sizeof(c) );
1313 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1315 socklen_t len = sizeof(from);
1318 char *authid = NULL;
1320 char *dnsname = NULL;
1322 #ifdef LDAP_PF_LOCAL
1323 char peername[MAXPATHLEN + sizeof("PATH=")];
1324 #elif defined(LDAP_PF_INET6)
1325 char peername[sizeof("IP=ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 65535")];
1327 char peername[sizeof("IP=255.255.255.255:65336")];
1328 #endif /* LDAP_PF_LOCAL */
1332 if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
1335 if ( !FD_ISSET( slap_listeners[l]->sl_sd, &readfds ) )
1338 #ifdef LDAP_CONNECTIONLESS
1339 if ( slap_listeners[l]->sl_is_udp )
1341 /* The first time we receive a query, we set this
1342 * up as a "connection". It remains open for the life
1345 if ( slap_listeners[l]->sl_is_udp < 2 )
1347 id = connection_init(
1348 slap_listeners[l]->sl_sd,
1349 slap_listeners[l]->sl_url, "", "",
1350 slap_listeners[l]->sl_name,
1352 slap_listeners[l]->sl_is_udp++;
1358 s = accept( slap_listeners[l]->sl_sd,
1359 (struct sockaddr *) &from, &len );
1360 if ( s == AC_SOCKET_INVALID ) {
1361 int err = sock_errno();
1364 if( err == EMFILE ) {
1369 if( err == ENFILE ) {
1379 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
1380 "slapd_daemon_task: accept(%ld) failed errno=%d (%s)\n",
1381 (long)slap_listeners[l]->sl_sd, err, sock_errstr(err) ));
1383 Debug( LDAP_DEBUG_ANY,
1384 "daemon: accept(%ld) failed errno=%d (%s)\n",
1385 (long) slap_listeners[l]->sl_sd, err,
1389 /* prevent busy loop */
1391 if( emfile % 4 == 3 ) usleep( 250 );
1393 if( emfile % 8 == 7 ) sleep( 1 );
1397 ldap_pvt_thread_yield();
1402 #ifndef HAVE_WINSOCK
1403 /* make sure descriptor number isn't too great */
1404 if ( s >= dtblsize ) {
1406 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
1407 "slapd_daemon_task: %ld beyond descriptor table size %ld\n",
1408 (long)s, (long)dtblsize ));
1410 Debug( LDAP_DEBUG_ANY,
1411 "daemon: %ld beyond descriptor table size %ld\n",
1412 (long) s, (long) dtblsize, 0 );
1416 ldap_pvt_thread_yield();
1422 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
1424 /* newly accepted stream should not be in any of the FD SETS */
1425 assert( !FD_ISSET( s, &slap_daemon.sd_actives) );
1426 assert( !FD_ISSET( s, &slap_daemon.sd_readers) );
1427 assert( !FD_ISSET( s, &slap_daemon.sd_writers) );
1429 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
1432 #if defined( SO_KEEPALIVE ) || defined( TCP_NODELAY )
1433 #ifdef LDAP_PF_LOCAL
1434 /* for IPv4 and IPv6 sockets only */
1435 if ( from.sa_addr.sa_family != AF_LOCAL )
1436 #endif /* LDAP_PF_LOCAL */
1441 /* enable keep alives */
1443 rc = setsockopt( s, SOL_SOCKET, SO_KEEPALIVE,
1444 (char *) &tmp, sizeof(tmp) );
1445 if ( rc == AC_SOCKET_ERROR ) {
1446 int err = sock_errno();
1448 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
1449 "slapd_daemon_task: setsockopt( %ld, SO_KEEPALIVE) failed errno=%d (%s)\n",
1450 (long)s, err, sock_errstr(err) ));
1452 Debug( LDAP_DEBUG_ANY,
1453 "slapd(%ld): setsockopt(SO_KEEPALIVE) failed "
1454 "errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
1459 /* enable no delay */
1461 rc = setsockopt( s, IPPROTO_TCP, TCP_NODELAY,
1462 (char *)&tmp, sizeof(tmp) );
1463 if ( rc == AC_SOCKET_ERROR ) {
1464 int err = sock_errno();
1466 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
1467 "slapd_daemon_task: setsockopt( %ld, TCP_NODELAY) failed errno=%d (%s)\n",
1468 (long)s, err, sock_errstr(err) ));
1470 Debug( LDAP_DEBUG_ANY,
1471 "slapd(%ld): setsockopt(TCP_NODELAY) failed "
1472 "errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
1480 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
1481 "slapd_daemon_task: new connection on %ld\n", (long)s ));
1483 Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
1486 switch ( from.sa_addr.sa_family ) {
1487 # ifdef LDAP_PF_LOCAL
1489 sprintf( peername, "PATH=%s", from.sa_un_addr.sun_path );
1490 ssf = LDAP_PVT_SASL_LOCAL_SSF;
1493 #endif /* LDAP_PF_LOCAL */
1495 # ifdef LDAP_PF_INET6
1497 if ( IN6_IS_ADDR_V4MAPPED(&from.sa_in6_addr.sin6_addr) ) {
1498 peeraddr = inet_ntoa( *((struct in_addr *)
1499 &from.sa_in6_addr.sin6_addr.s6_addr[12]) );
1500 sprintf( peername, "IP=%s:%d",
1501 peeraddr != NULL ? peeraddr : "unknown",
1502 (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
1504 char addr[INET6_ADDRSTRLEN];
1505 sprintf( peername, "IP=%s %d",
1506 inet_ntop( AF_INET6,
1507 &from.sa_in6_addr.sin6_addr,
1508 addr, sizeof addr) ? addr : "unknown",
1509 (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
1512 # endif /* LDAP_PF_INET6 */
1515 peeraddr = inet_ntoa( from.sa_in_addr.sin_addr );
1516 sprintf( peername, "IP=%s:%d",
1517 peeraddr != NULL ? peeraddr : "unknown",
1518 (unsigned) ntohs( from.sa_in_addr.sin_port ) );
1526 if ( ( from.sa_addr.sa_family == AF_INET )
1527 #ifdef LDAP_PF_INET6
1528 || ( from.sa_addr.sa_family == AF_INET6 )
1531 #ifdef SLAPD_RLOOKUPS
1532 # ifdef LDAP_PF_INET6
1533 if ( from.sa_addr.sa_family == AF_INET6 )
1535 (char *)&(from.sa_in6_addr.sin6_addr),
1536 sizeof(from.sa_in6_addr.sin6_addr),
1539 # endif /* LDAP_PF_INET6 */
1541 (char *) &(from.sa_in_addr.sin_addr),
1542 sizeof(from.sa_in_addr.sin_addr),
1544 dnsname = hp ? ldap_pvt_str2lower( hp->h_name ) : NULL;
1547 #endif /* SLAPD_RLOOKUPS */
1550 if ( !hosts_ctl("slapd",
1551 dnsname != NULL ? dnsname : STRING_UNKNOWN,
1552 peeraddr != NULL ? peeraddr : STRING_UNKNOWN,
1556 Statslog( LDAP_DEBUG_ANY,
1557 "fd=%ld host access from %s (%s) denied.\n",
1559 dnsname != NULL ? dnsname : "unknown",
1560 peeraddr != NULL ? peeraddr : "unknown",
1565 #endif /* HAVE_TCPD */
1568 id = connection_init(s,
1569 slap_listeners[l]->sl_url,
1570 dnsname != NULL ? dnsname : "unknown",
1572 slap_listeners[l]->sl_name,
1574 slap_listeners[l]->sl_is_tls,
1581 if( authid ) ch_free(authid);
1585 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
1586 "slapd_daemon_task: connection_init(%ld, %s, %s) failed.\n",
1587 (long)s, peername, slap_listeners[l]->sl_name ));
1589 Debug( LDAP_DEBUG_ANY,
1590 "daemon: connection_init(%ld, %s, %s) failed.\n",
1593 slap_listeners[l]->sl_name );
1599 Statslog( LDAP_DEBUG_STATS,
1600 "daemon: conn=%ld fd=%ld connection from %s (%s) accepted.\n",
1603 slap_listeners[l]->sl_name,
1612 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
1613 "slapd_daemon_task: activity on " ));
1615 Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
1618 for ( i = 0; i < readfds.fd_count; i++ ) {
1620 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
1621 " %d%s", readfds.fd_array[i], "r", 0 ));
1623 Debug( LDAP_DEBUG_CONNS, " %d%s",
1624 readfds.fd_array[i], "r", 0 );
1627 for ( i = 0; i < writefds.fd_count; i++ ) {
1629 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
1630 " %d%s", writefds.fd_array[i], "w" ));
1632 Debug( LDAP_DEBUG_CONNS, " %d%s",
1633 writefds.fd_array[i], "w", 0 );
1638 for ( i = 0; i < nfds; i++ ) {
1640 int is_listener = 0;
1642 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1643 if ( i == slap_listeners[l]->sl_sd ) {
1644 #ifdef LDAP_CONNECTIONLESS
1645 /* The listener is the data port. Don't
1648 if (slap_listeners[l]->sl_is_udp)
1655 if ( is_listener ) {
1658 r = FD_ISSET( i, &readfds );
1659 w = FD_ISSET( i, &writefds );
1662 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
1664 r ? "r" : "", w ? "w" : "" ));
1666 Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
1667 r ? "r" : "", w ? "w" : "" );
1673 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2, "\n" ));
1675 Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
1680 /* loop through the writers */
1682 for ( i = 0; i < writefds.fd_count; i++ )
1684 for ( i = 0; i < nfds; i++ )
1688 int is_listener = 0;
1690 wd = writefds.fd_array[i];
1692 if( ! FD_ISSET( i, &writefds ) ) {
1698 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1699 if ( i == slap_listeners[l]->sl_sd ) {
1700 #ifdef LDAP_CONNECTIONLESS
1701 if (slap_listeners[l]->sl_is_udp)
1708 if ( is_listener ) {
1712 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
1713 "slapd_daemon_task: write active on %d\n", wd ));
1715 Debug( LDAP_DEBUG_CONNS,
1716 "daemon: write active on %d\n",
1720 * NOTE: it is possible that the connection was closed
1721 * and that the stream is now inactive.
1722 * connection_write() must valid the stream is still
1726 if ( connection_write( wd ) < 0 ) {
1727 FD_CLR( (unsigned) wd, &readfds );
1733 for ( i = 0; i < readfds.fd_count; i++ )
1735 for ( i = 0; i < nfds; i++ )
1739 int is_listener = 0;
1742 rd = readfds.fd_array[i];
1744 if( ! FD_ISSET( i, &readfds ) ) {
1750 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1751 if ( rd == slap_listeners[l]->sl_sd ) {
1752 #ifdef LDAP_CONNECTIONLESS
1753 if (slap_listeners[l]->sl_is_udp)
1760 if ( is_listener ) {
1765 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
1766 "slapd_daemon_task: read activity on %d\n", rd ));
1768 Debug ( LDAP_DEBUG_CONNS,
1769 "daemon: read activity on %d\n", rd, 0, 0 );
1772 * NOTE: it is possible that the connection was closed
1773 * and that the stream is now inactive.
1774 * connection_read() must valid the stream is still
1778 if ( connection_read( rd ) < 0 ) {
1782 ldap_pvt_thread_yield();
1785 if( slapd_shutdown > 0 ) {
1787 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
1788 "slapd_daemon_task: shutdown requested and initiated.\n"));
1790 Debug( LDAP_DEBUG_TRACE,
1791 "daemon: shutdown requested and initiated.\n",
1795 } else if ( slapd_shutdown < 0 ) {
1796 #ifdef HAVE_NT_SERVICE_MANAGER
1797 if (slapd_shutdown == -1)
1800 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
1801 "slapd_daemon_task: shutdown initiated by Service Manager.\n"));
1803 Debug( LDAP_DEBUG_TRACE,
1804 "daemon: shutdown initiated by Service Manager.\n",
1812 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
1813 "slapd_daemon_task: abnormal condition, shutdown initiated.\n" ));
1815 Debug( LDAP_DEBUG_TRACE,
1816 "daemon: abnormal condition, shutdown initiated.\n",
1822 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
1823 "slapd_daemon_task: no active streams, shutdown initiated.\n" ));
1825 Debug( LDAP_DEBUG_TRACE,
1826 "daemon: no active streams, shutdown initiated.\n",
1831 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1832 if ( slap_listeners[l]->sl_sd != AC_SOCKET_INVALID ) {
1833 #ifdef LDAP_PF_LOCAL
1834 if ( slap_listeners[l]->sl_sa.sa_addr.sa_family == AF_LOCAL ) {
1835 unlink( slap_listeners[l]->sl_sa.sa_un_addr.sun_path );
1837 #endif /* LDAP_PF_LOCAL */
1838 slapd_close( slap_listeners[l]->sl_sd );
1840 if ( slap_listeners[l]->sl_url )
1841 free ( slap_listeners[l]->sl_url );
1842 if ( slap_listeners[l]->sl_name )
1843 free ( slap_listeners[l]->sl_name );
1844 free ( slap_listeners[l] );
1846 free ( slap_listeners );
1847 slap_listeners = NULL;
1850 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
1851 "slapd_daemon_task: shutdown waiting for %d threads to terminate.\n",
1852 ldap_pvt_thread_pool_backload(&connection_pool) ));
1854 Debug( LDAP_DEBUG_ANY,
1855 "slapd shutdown: waiting for %d threads to terminate\n",
1856 ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
1858 ldap_pvt_thread_pool_destroy(&connection_pool, 1);
1864 int slapd_daemon( void )
1870 #define SLAPD_LISTENER_THREAD 1
1871 #if defined( SLAPD_LISTENER_THREAD )
1873 ldap_pvt_thread_t listener_tid;
1875 /* listener as a separate THREAD */
1876 rc = ldap_pvt_thread_create( &listener_tid,
1877 0, slapd_daemon_task, NULL );
1881 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
1882 "slapd_daemon: listener ldap_pvt_thread_create failed (%d).\n", rc ));
1884 Debug( LDAP_DEBUG_ANY,
1885 "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
1890 /* wait for the listener thread to complete */
1891 ldap_pvt_thread_join( listener_tid, (void *) NULL );
1894 /* experimental code */
1895 slapd_daemon_task( NULL );
1904 #if defined( HAVE_WINSOCK2 )
1905 WORD wVersionRequested;
1909 wVersionRequested = MAKEWORD( 2, 0 );
1911 err = WSAStartup( wVersionRequested, &wsaData );
1913 /* Tell the user that we couldn't find a usable */
1918 /* Confirm that the WinSock DLL supports 2.0.*/
1919 /* Note that if the DLL supports versions greater */
1920 /* than 2.0 in addition to 2.0, it will still return */
1921 /* 2.0 in wVersion since that is the version we */
1924 if ( LOBYTE( wsaData.wVersion ) != 2 ||
1925 HIBYTE( wsaData.wVersion ) != 0 )
1927 /* Tell the user that we couldn't find a usable */
1933 /* The WinSock DLL is acceptable. Proceed. */
1934 #elif defined( HAVE_WINSOCK )
1936 if ( WSAStartup( 0x0101, &wsaData ) != 0 ) {
1943 int sockdestroy(void)
1945 #if defined( HAVE_WINSOCK2 ) || defined( HAVE_WINSOCK )
1952 slap_sig_shutdown( int sig )
1955 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
1956 "slap_sig_shutdown: signal %d\n", sig ));
1958 Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: signal %d\n", sig, 0, 0);
1962 * If the NT Service Manager is controlling the server, we don't
1963 * want SIGBREAK to kill the server. For some strange reason,
1964 * SIGBREAK is generated when a user logs out.
1967 #if HAVE_NT_SERVICE_MANAGER && SIGBREAK
1968 if (is_NT_Service && sig == SIGBREAK)
1970 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
1971 "slap_sig_shutdown: SIGBREAK ignored.\n" ));
1973 Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: SIGBREAK ignored.\n",
1978 slapd_shutdown = sig;
1982 /* reinstall self */
1983 (void) SIGNAL_REINSTALL( sig, slap_sig_shutdown );
1987 slap_sig_wake( int sig )
1991 /* reinstall self */
1992 (void) SIGNAL_REINSTALL( sig, slap_sig_wake );
1996 void slapd_add_internal(ber_socket_t s) {
2000 Listener ** slapd_get_listeners(void) {
2001 return slap_listeners;