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;
30 ldap_pvt_thread_mutex_t sd_mutex;
35 /* In winsock, accept() returns values higher than dtblsize
36 so don't bother with this optimization */
46 * Add a descriptor to daemon control
48 static void slapd_add(int s) {
49 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
51 assert( !FD_ISSET( s, &slap_daemon.sd_actives ));
52 assert( !FD_ISSET( s, &slap_daemon.sd_readers ));
53 assert( !FD_ISSET( s, &slap_daemon.sd_writers ));
56 if (s >= slap_daemon.sd_nfds) {
57 slap_daemon.sd_nfds = s + 1;
61 FD_SET( s, &slap_daemon.sd_actives );
62 FD_SET( s, &slap_daemon.sd_readers );
64 Debug( LDAP_DEBUG_CONNS, "daemon: added %d%s%s\n", s,
65 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
66 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
68 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
72 * Remove the descriptor from daemon control
74 void slapd_remove(int s) {
75 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
77 assert( FD_ISSET( s, &slap_daemon.sd_actives ));
79 Debug( LDAP_DEBUG_CONNS, "daemon: removing %d%s%s\n", s,
80 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
81 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
83 FD_CLR( s, &slap_daemon.sd_actives );
84 FD_CLR( s, &slap_daemon.sd_readers );
85 FD_CLR( s, &slap_daemon.sd_writers );
87 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
90 void slapd_clr_write(int s, int wake) {
91 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
93 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
94 FD_CLR( s, &slap_daemon.sd_writers );
96 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
99 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
103 void slapd_set_write(int s, int wake) {
104 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
106 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
107 FD_SET( s, &slap_daemon.sd_writers );
109 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
112 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
116 void slapd_clr_read(int s, int wake) {
117 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
119 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
120 FD_CLR( s, &slap_daemon.sd_readers );
122 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
125 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
129 void slapd_set_read(int s, int wake) {
130 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
132 assert( FD_ISSET( s, &slap_daemon.sd_actives) );
133 FD_SET( s, &slap_daemon.sd_readers );
135 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
138 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
142 static void slapd_close(int s) {
145 Debug( LDAP_DEBUG_CONNS, "daemon: closing %d\n", s, 0, 0 );
150 set_socket( struct sockaddr_in *addr )
155 dtblsize = sysconf( _SC_OPEN_MAX );
156 #elif HAVE_GETDTABLESIZE
157 dtblsize = getdtablesize();
159 dtblsize = FD_SETSIZE;
163 if(dtblsize > FD_SETSIZE) {
164 dtblsize = FD_SETSIZE;
166 #endif /* !FD_SETSIZE */
170 WORD vers = MAKEWORD( 2, 0);
173 err = WSAStartup( vers, &wsaData );
180 if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) {
182 Debug( LDAP_DEBUG_ANY,
183 "daemon: socket() failed errno %d (%s)\n", err,
184 err > -1 && err < sys_nerr ? sys_errlist[err] :
190 if ( tcps >= dtblsize ) {
191 Debug( LDAP_DEBUG_ANY,
192 "daemon: listener descriptor %d is too great\n",
199 if ( setsockopt( tcps, SOL_SOCKET, SO_REUSEADDR,
200 (char *) &tmp, sizeof(tmp) ) == -1 )
203 Debug( LDAP_DEBUG_ANY,
204 "slapd(%d): setsockopt() failed errno %d (%s)\n",
206 err > -1 && err < sys_nerr
207 ? sys_errlist[err] : "unknown" );
210 if ( bind( tcps, (struct sockaddr *) addr, sizeof(*addr) ) == -1 ) {
212 Debug( LDAP_DEBUG_ANY, "daemon: bind(%d) failed errno %d (%s)\n",
214 err > -1 && err < sys_nerr
215 ? sys_errlist[err] : "unknown" );
228 int inetd = ((int *)ptr) [0];
229 int tcps = ((int *)ptr) [1];
234 ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
235 FD_ZERO( &slap_daemon.sd_readers );
236 FD_ZERO( &slap_daemon.sd_writers );
239 if ( listen( tcps, 5 ) == -1 ) {
241 Debug( LDAP_DEBUG_ANY,
242 "daemon: listen(%d, 5) failed errno %d (%s)\n",
244 err > -1 && err < sys_nerr
245 ? sys_errlist[err] : "unknown" );
252 if( connection_init( 0, NULL, NULL ) ) {
253 Debug( LDAP_DEBUG_ANY,
254 "connection_init(%d) failed.\n",
263 while ( !slapd_shutdown ) {
270 struct sockaddr_in from;
271 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
280 FD_ZERO( &writefds );
286 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
288 #ifdef FD_SET_MANUAL_COPY
289 for( s = 0; s < nfds; s++ ) {
290 if(FD_ISSET( &slap_sd_writers, s )) {
291 FD_SET( &writefds, s );
293 if(FD_ISSET( &slap_sd_writers, s )) {
294 FD_SET( &writefds, s );
298 memcpy( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
299 memcpy( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
302 FD_SET( tcps, &readfds );
305 nfds = slap_daemon.sd_nfds;
310 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
312 ldap_pvt_thread_mutex_lock( &active_threads_mutex );
313 #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
316 tvp = active_threads ? &zero : NULL;
319 Debug( LDAP_DEBUG_CONNS,
320 "daemon: select: tcps=%d active_threads=%d tvp=%s\n",
321 tcps, active_threads,
322 tvp == NULL ? "NULL" : "zero" );
325 ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
327 switch(ns = select( nfds, &readfds, &writefds, 0, tvp )) {
328 case -1: { /* failure - try again */
331 Debug( LDAP_DEBUG_CONNS,
332 "daemon: select failed (%d): %s\n",
334 err >= 0 && err < sys_nerr
335 ? sys_errlist[err] : "unknown",
343 case 0: /* timeout - let threads run */
344 Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
346 ldap_pvt_thread_yield();
349 default: /* something happened - deal with it */
350 Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
355 if ( FD_ISSET( tcps, &readfds ) ) {
357 int len = sizeof(from);
360 if ( (s = accept( tcps,
361 (struct sockaddr *) &from, &len )) == -1 )
364 Debug( LDAP_DEBUG_ANY,
365 "daemon: accept(%d) failed errno %d (%s)\n", err,
366 tcps, err >= 0 && err < sys_nerr ?
367 sys_errlist[err] : "unknown");
371 assert( !FD_ISSET( 0, &slap_daemon.sd_actives) );
372 assert( !FD_ISSET( 0, &slap_daemon.sd_readers) );
373 assert( !FD_ISSET( 0, &slap_daemon.sd_writers) );
376 /* make sure descriptor number isn't too great */
377 if ( s >= dtblsize ) {
378 Debug( LDAP_DEBUG_ANY,
379 "daemon: %d beyond descriptor table size %d\n",
386 Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %d\n",
390 if ( getpeername( s, (struct sockaddr *) &from, &len ) == 0 ) {
391 client_addr = inet_ntoa( from.sin_addr );
393 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
394 hp = gethostbyaddr( (char *)
395 &(from.sin_addr.s_addr),
396 sizeof(from.sin_addr.s_addr), AF_INET );
400 client_name = hp->h_name;
402 /* normalize the domain */
403 for ( p = client_name; *p; p++ ) {
404 *p = TOLOWER( (unsigned char) *p );
420 if(!hosts_ctl("slapd",
421 client_name != NULL ? client_name : STRING_UNKNOWN,
422 client_addr != NULL ? client_addr : STRING_UNKNOWN,
426 Statslog( LDAP_DEBUG_ANY,
427 "fd=%d connection from %s (%s) denied.\n",
429 client_name == NULL ? "unknown" : client_name,
430 client_addr == NULL ? "unknown" : client_addr,
436 #endif /* HAVE_TCPD */
438 if( (id = connection_init(s, client_name, client_addr)) < 0 ) {
439 Debug( LDAP_DEBUG_ANY,
440 "daemon: connection_init(%d, %s, %s) failed.\n",
442 client_name == NULL ? "unknown" : client_name,
443 client_addr == NULL ? "unknown" : client_addr);
448 Statslog( LDAP_DEBUG_STATS,
449 "daemon: conn=%d fd=%d connection from %s (%s) accepted.\n",
451 client_name == NULL ? "unknown" : client_name,
452 client_addr == NULL ? "unknown" : client_addr,
460 Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
462 for ( i = 0; i < readfds.fd_count; i++ )
464 Debug( LDAP_DEBUG_CONNS, " %d%s", readfds.fd_array[i], "r" );
466 for ( i = 0; i < writefds.fd_count; i++ )
468 Debug( LDAP_DEBUG_CONNS, " %d%s", writefds.fd_array[i], "w" );
471 for ( i = 0; i < nfds; i++ ) {
474 r = FD_ISSET( i, &readfds );
475 w = FD_ISSET( i, &writefds );
476 if ( i != tcps && (r || w) ) {
477 Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
478 r ? "r" : "", w ? "w" : "" );
482 Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
485 /* loop through the writers */
487 for ( i = 0; i < writefds.fd_count; i++ ) {
488 if ( writefds.fd_array[i] == tcps ) {
491 Debug( LDAP_DEBUG_CONNS,
492 "daemon: signalling write waiter on %d\n",
493 writefds.fd_array[i], 0, 0 );
494 assert( FD_ISSET( 0, &slap_daemon.sd_actives) );
496 slapd_clr_write( writefds.fd_array[i], 0 );
497 if ( connection_write( writefds.fd_array[i] ) < 0 ) {
498 FD_CLR( writefds.fd_array[i], &readfds );
499 slapd_close( writefds.fd_array[i] );
503 for ( i = 0; i < nfds; i++ ) {
507 if ( FD_ISSET( i, &writefds ) ) {
508 Debug( LDAP_DEBUG_CONNS,
509 "daemon: signaling write waiter on %d\n", i, 0, 0 );
511 assert( FD_ISSET( 0, &slap_daemon.sd_actives) );
513 /* clear the write flag */
514 slapd_clr_write( i, 0 );
516 if( connection_write( i ) < 0 ) {
517 FD_CLR( i, &readfds );
525 for ( i = 0; i < readfds.fd_count; i++ ) {
526 if ( readfds.fd_array[i] == tcps ) {
529 Debug ( LDAP_DEBUG_CONNS,
530 "daemon: read activity on %d\n", readfds.fd_array[i], 0, 0 );
531 assert( FD_ISSET( readfds.fd_array[i], &slap_daemon.sd_actives) );
533 if ( connection_read( readfds.fd_array[i] ) < 0 ) {
538 for ( i = 0; i < nfds; i++ ) {
543 if ( FD_ISSET( i, &readfds ) ) {
544 Debug( LDAP_DEBUG_CONNS,
545 "daemon: read activity on %d\n", i, 0, 0 );
547 assert( FD_ISSET( i, &slap_daemon.sd_actives) );
549 if( connection_read( i ) < 0) {
555 ldap_pvt_thread_yield();
558 if( slapd_shutdown > 0 ) {
559 Debug( LDAP_DEBUG_TRACE,
560 "daemon: shutdown requested (%d) and initiated.\n",
561 (int) slapd_shutdown, 0, 0 );
563 } else if ( slapd_shutdown < 0 ) {
564 Debug( LDAP_DEBUG_TRACE,
565 "daemon: abnormal condition (%d), shutdown initiated.\n",
566 (int) slapd_shutdown, 0, 0 );
568 Debug( LDAP_DEBUG_TRACE,
569 "daemon: no active streams, shutdown initiated.\n",
577 ldap_pvt_thread_mutex_lock( &active_threads_mutex );
578 Debug( LDAP_DEBUG_ANY,
579 "slapd shutdown: waiting for %d threads to terminate\n",
580 active_threads, 0, 0 );
581 while ( active_threads > 0 ) {
582 ldap_pvt_thread_cond_wait(&active_threads_cond, &active_threads_mutex);
584 ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
589 int slapd_daemon( int inetd, int tcps )
592 int *args = ch_malloc( sizeof( int[2] ) );
596 status = ldap_pvt_thread_create( &listener_tid, 0,
597 slapd_daemon_task, args );
600 Debug( LDAP_DEBUG_ANY,
601 "listener ldap_pvt_thread_create failed (%d)\n", status, 0, 0 );
604 /* wait for the listener thread to complete */
605 ldap_pvt_thread_join( listener_tid, (void *) NULL );
612 slap_set_shutdown( int sig )
614 slapd_shutdown = sig;
615 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
618 (void) SIGNAL( sig, slap_set_shutdown );
622 slap_do_nothing( int sig )
625 (void) SIGNAL( sig, slap_do_nothing );