11 #include <ac/unistd.h>
13 #include "ldapconfig.h"
19 int allow_severity = LOG_INFO;
20 int deny_severity = LOG_NOTICE;
21 #endif /* TCP Wrappers */
26 static ldap_pvt_thread_t listener_tid;
27 static volatile sig_atomic_t slapd_shutdown = 0;
28 static volatile sig_atomic_t slapd_listener = 0;
31 ldap_pvt_thread_mutex_t sd_mutex;
36 /* In winsock, accept() returns values higher than dtblsize
37 so don't bother with this optimization */
47 * Add a descriptor to daemon control
49 static void slapd_add(int s) {
50 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
52 assert( !FD_ISSET( s, &slap_daemon.sd_actives ));
53 assert( !FD_ISSET( s, &slap_daemon.sd_readers ));
54 assert( !FD_ISSET( s, &slap_daemon.sd_writers ));
57 if (s >= slap_daemon.sd_nfds) {
58 slap_daemon.sd_nfds = s + 1;
62 FD_SET( s, &slap_daemon.sd_actives );
63 FD_SET( s, &slap_daemon.sd_readers );
65 Debug( LDAP_DEBUG_CONNS, "daemon: added %d%s%s\n", s,
66 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
67 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
69 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
73 * Remove the descriptor from daemon control
75 void slapd_remove(int s) {
76 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
78 assert( FD_ISSET( s, &slap_daemon.sd_actives ));
80 Debug( LDAP_DEBUG_CONNS, "daemon: removing %d%s%s\n", s,
81 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
82 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
84 FD_CLR( s, &slap_daemon.sd_actives );
85 FD_CLR( s, &slap_daemon.sd_readers );
86 FD_CLR( s, &slap_daemon.sd_writers );
88 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
91 void slapd_clr_write(int s, int wake) {
92 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
94 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
95 FD_CLR( s, &slap_daemon.sd_writers );
97 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
100 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
104 void slapd_set_write(int s, int wake) {
105 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
107 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
108 FD_SET( s, &slap_daemon.sd_writers );
110 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
113 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
117 void slapd_clr_read(int s, int wake) {
118 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
120 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
121 FD_CLR( s, &slap_daemon.sd_readers );
123 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
126 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
130 void slapd_set_read(int s, int wake) {
131 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
133 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
134 FD_SET( s, &slap_daemon.sd_readers );
136 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
139 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
143 static void slapd_close(int s) {
146 Debug( LDAP_DEBUG_CONNS, "daemon: closing %d\n", s, 0, 0 );
151 set_socket( struct sockaddr_in *addr )
156 dtblsize = sysconf( _SC_OPEN_MAX );
157 #elif HAVE_GETDTABLESIZE
158 dtblsize = getdtablesize();
160 dtblsize = FD_SETSIZE;
164 if(dtblsize > FD_SETSIZE) {
165 dtblsize = FD_SETSIZE;
167 #endif /* !FD_SETSIZE */
171 WORD vers = MAKEWORD( 2, 0);
174 err = WSAStartup( vers, &wsaData );
181 if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) {
183 Debug( LDAP_DEBUG_ANY,
184 "daemon: socket() failed errno %d (%s)\n", err,
185 err > -1 && err < sys_nerr ? sys_errlist[err] :
191 if ( tcps >= dtblsize ) {
192 Debug( LDAP_DEBUG_ANY,
193 "daemon: listener descriptor %d is too great\n",
200 if ( setsockopt( tcps, SOL_SOCKET, SO_REUSEADDR,
201 (char *) &tmp, sizeof(tmp) ) == -1 )
204 Debug( LDAP_DEBUG_ANY,
205 "slapd(%d): setsockopt() failed errno %d (%s)\n",
207 err > -1 && err < sys_nerr
208 ? sys_errlist[err] : "unknown" );
211 if ( bind( tcps, (struct sockaddr *) addr, sizeof(*addr) ) == -1 ) {
213 Debug( LDAP_DEBUG_ANY, "daemon: bind(%d) failed errno %d (%s)\n",
215 err > -1 && err < sys_nerr
216 ? sys_errlist[err] : "unknown" );
229 int inetd = ((int *)ptr) [0];
230 int tcps = ((int *)ptr) [1];
235 ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
236 FD_ZERO( &slap_daemon.sd_readers );
237 FD_ZERO( &slap_daemon.sd_writers );
240 if ( listen( tcps, 5 ) == -1 ) {
242 Debug( LDAP_DEBUG_ANY,
243 "daemon: listen(%d, 5) failed errno %d (%s)\n",
245 err > -1 && err < sys_nerr
246 ? sys_errlist[err] : "unknown" );
253 if( connection_init( 0, NULL, NULL ) ) {
254 Debug( LDAP_DEBUG_ANY,
255 "connection_init(%d) failed.\n",
264 while ( !slapd_shutdown ) {
271 struct sockaddr_in from;
272 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
281 FD_ZERO( &writefds );
287 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
289 #ifdef FD_SET_MANUAL_COPY
290 for( s = 0; s < nfds; s++ ) {
291 if(FD_ISSET( &slap_sd_writers, s )) {
292 FD_SET( &writefds, s );
294 if(FD_ISSET( &slap_sd_writers, s )) {
295 FD_SET( &writefds, s );
299 memcpy( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
300 memcpy( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
303 FD_SET( tcps, &readfds );
306 nfds = slap_daemon.sd_nfds;
311 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
313 ldap_pvt_thread_mutex_lock( &active_threads_mutex );
314 #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
317 tvp = active_threads ? &zero : NULL;
320 Debug( LDAP_DEBUG_CONNS,
321 "daemon: select: tcps=%d active_threads=%d tvp=%s\n",
322 tcps, active_threads,
323 tvp == NULL ? "NULL" : "zero" );
326 ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
328 switch(ns = select( nfds, &readfds, &writefds, 0, tvp )) {
329 case -1: { /* failure - try again */
332 Debug( LDAP_DEBUG_CONNS,
333 "daemon: select failed (%d): %s\n",
335 err >= 0 && err < sys_nerr
336 ? sys_errlist[err] : "unknown",
344 case 0: /* timeout - let threads run */
345 Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
347 ldap_pvt_thread_yield();
350 default: /* something happened - deal with it */
351 Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
356 if ( FD_ISSET( tcps, &readfds ) ) {
358 int len = sizeof(from);
361 if ( (s = accept( tcps,
362 (struct sockaddr *) &from, &len )) == -1 )
365 Debug( LDAP_DEBUG_ANY,
366 "daemon: accept(%d) failed errno %d (%s)\n", err,
367 tcps, err >= 0 && err < sys_nerr ?
368 sys_errlist[err] : "unknown");
372 assert( !FD_ISSET( 0, &slap_daemon.sd_actives) );
373 assert( !FD_ISSET( 0, &slap_daemon.sd_readers) );
374 assert( !FD_ISSET( 0, &slap_daemon.sd_writers) );
377 /* make sure descriptor number isn't too great */
378 if ( s >= dtblsize ) {
379 Debug( LDAP_DEBUG_ANY,
380 "daemon: %d beyond descriptor table size %d\n",
387 Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %d\n",
391 if ( getpeername( s, (struct sockaddr *) &from, &len ) == 0 ) {
392 client_addr = inet_ntoa( from.sin_addr );
394 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
395 hp = gethostbyaddr( (char *)
396 &(from.sin_addr.s_addr),
397 sizeof(from.sin_addr.s_addr), AF_INET );
401 client_name = hp->h_name;
403 /* normalize the domain */
404 for ( p = client_name; *p; p++ ) {
405 *p = TOLOWER( (unsigned char) *p );
421 if(!hosts_ctl("slapd",
422 client_name != NULL ? client_name : STRING_UNKNOWN,
423 client_addr != NULL ? client_addr : STRING_UNKNOWN,
427 Statslog( LDAP_DEBUG_ANY,
428 "fd=%d connection from %s (%s) denied.\n",
430 client_name == NULL ? "unknown" : client_name,
431 client_addr == NULL ? "unknown" : client_addr,
437 #endif /* HAVE_TCPD */
439 if( (id = connection_init(s, client_name, client_addr)) < 0 ) {
440 Debug( LDAP_DEBUG_ANY,
441 "daemon: connection_init(%d, %s, %s) failed.\n",
443 client_name == NULL ? "unknown" : client_name,
444 client_addr == NULL ? "unknown" : client_addr);
449 Statslog( LDAP_DEBUG_STATS,
450 "daemon: conn=%d fd=%d connection from %s (%s) accepted.\n",
452 client_name == NULL ? "unknown" : client_name,
453 client_addr == NULL ? "unknown" : client_addr,
461 Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
463 for ( i = 0; i < readfds.fd_count; i++ )
465 Debug( LDAP_DEBUG_CONNS, " %d%s", readfds.fd_array[i], "r" );
467 for ( i = 0; i < writefds.fd_count; i++ )
469 Debug( LDAP_DEBUG_CONNS, " %d%s", writefds.fd_array[i], "w" );
472 for ( i = 0; i < nfds; i++ ) {
475 r = FD_ISSET( i, &readfds );
476 w = FD_ISSET( i, &writefds );
477 if ( i != tcps && (r || w) ) {
478 Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
479 r ? "r" : "", w ? "w" : "" );
483 Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
486 /* loop through the writers */
488 for ( i = 0; i < writefds.fd_count; i++ ) {
489 int wd = writefds.fd_array[i];
495 Debug( LDAP_DEBUG_CONNS,
496 "daemon: signalling write waiter on %d\n",
499 assert( FD_ISSET( wd, &slap_daemon.sd_actives) );
501 slapd_clr_write( wd, 0 );
502 if ( connection_write( wd ) < 0 ) {
503 FD_CLR( wd, &readfds );
508 for ( i = 0; i < nfds; i++ ) {
512 if ( FD_ISSET( i, &writefds ) ) {
513 Debug( LDAP_DEBUG_CONNS,
514 "daemon: signaling write waiter on %d\n", i, 0, 0 );
516 assert( FD_ISSET( i, &slap_daemon.sd_actives) );
518 /* clear the write flag */
519 slapd_clr_write( i, 0 );
521 if( connection_write( i ) < 0 ) {
522 FD_CLR( i, &readfds );
530 for ( i = 0; i < readfds.fd_count; i++ ) {
531 int rd = readfds.fd_array[i];
535 Debug ( LDAP_DEBUG_CONNS,
536 "daemon: read activity on %d\n", rd, 0, 0 );
537 assert( FD_ISSET( rd, &slap_daemon.sd_actives) );
539 if ( connection_read( rd ) < 0 ) {
544 for ( i = 0; i < nfds; i++ ) {
549 if ( FD_ISSET( i, &readfds ) ) {
550 Debug( LDAP_DEBUG_CONNS,
551 "daemon: read activity on %d\n", i, 0, 0 );
553 assert( FD_ISSET( i, &slap_daemon.sd_actives) );
555 if( connection_read( i ) < 0) {
561 ldap_pvt_thread_yield();
564 if( slapd_shutdown > 0 ) {
565 Debug( LDAP_DEBUG_TRACE,
566 "daemon: shutdown requested (%d) and initiated.\n",
567 (int) slapd_shutdown, 0, 0 );
569 } else if ( slapd_shutdown < 0 ) {
570 Debug( LDAP_DEBUG_TRACE,
571 "daemon: abnormal condition (%d), shutdown initiated.\n",
572 (int) slapd_shutdown, 0, 0 );
574 Debug( LDAP_DEBUG_TRACE,
575 "daemon: no active streams, shutdown initiated.\n",
583 /* we only implement "quick" shutdown */
584 connections_shutdown();
586 ldap_pvt_thread_mutex_lock( &active_threads_mutex );
587 Debug( LDAP_DEBUG_ANY,
588 "slapd shutdown: waiting for %d threads to terminate\n",
589 active_threads, 0, 0 );
590 while ( active_threads > 0 ) {
591 ldap_pvt_thread_cond_wait(&active_threads_cond, &active_threads_mutex);
593 ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
599 int slapd_daemon( int inetd, int tcps )
602 int *args = ch_malloc( sizeof( int[2] ) );
608 #define SLAPD_LISTENER_THREAD 1
609 #if SLAPD_LISTENER_THREAD
610 /* listener as a separate THREAD */
611 status = ldap_pvt_thread_create( &listener_tid,
612 0, slapd_daemon_task, args );
615 Debug( LDAP_DEBUG_ANY,
616 "listener ldap_pvt_thread_create failed (%d)\n", status, 0, 0 );
620 /* wait for the listener thread to complete */
621 ldap_pvt_thread_join( listener_tid, (void *) NULL );
623 /* expermimental code */
624 listener_tid = pthread_self();
625 slapd_daemon_task( args );
628 connections_destroy();
633 slap_set_shutdown( int sig )
635 slapd_shutdown = sig;
638 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
642 (void) SIGNAL( sig, slap_set_shutdown );
646 slap_do_nothing( int sig )
649 (void) SIGNAL( sig, slap_do_nothing );