git.sur5r.net Git - openldap/blob - servers/slapd/daemon.c

   1 #include "portable.h"
   2
   3 #include <stdio.h>
   4
   5 #include <ac/ctype.h>
   6 #include <ac/errno.h>
   7 #include <ac/signal.h>
   8 #include <ac/socket.h>
   9 #include <ac/string.h>
  10 #include <ac/time.h>
  11 #include <ac/unistd.h>
  12
  13 #include "ldap_defaults.h"
  14 #include "slap.h"
  15
  16 #ifdef HAVE_TCPD
  17 #include <tcpd.h>
  18
  19 int allow_severity = LOG_INFO;
  20 int deny_severity = LOG_NOTICE;
  21 #endif /* TCP Wrappers */
  22
  23 /* globals */
  24 time_t starttime;
  25 ber_socket_t dtblsize;
  26
  27 typedef struct slap_listener {
  28         char* sl_url;
  29 #ifdef HAVE_TLS
  30         int             sl_is_tls;
  31 #endif
  32         ber_socket_t            sl_sd;
  33         struct sockaddr_in      sl_addr;
  34 } Listener;
  35
  36 Listener **slap_listeners = NULL;
  37
  38 #ifdef HAVE_WINSOCK2
  39 /* in nt_main.c */
  40 extern ldap_pvt_thread_cond_t                   started_event;
  41
  42 /* forward reference */
  43 static void hit_socket(void);
  44 /* In wsa_err.c */
  45 char *WSAGetLastErrorString();
  46 static ldap_pvt_thread_t hit_tid;
  47
  48 #define WAKE_LISTENER(w) \
  49 do {\
  50     if( w ) {\
  51         ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );\
  52         hit_socket(); \
  53     }\
  54 } while(0)
  55 #else
  56 #define WAKE_LISTENER(w) \
  57 do {\
  58     if( w ) {\
  59         ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );\
  60     }\
  61 } while(0)
  62 #endif
  63
  64 #ifndef HAVE_WINSOCK
  65 static
  66 #endif
  67 volatile sig_atomic_t slapd_shutdown = 0;
  68
  69 static ldap_pvt_thread_t        listener_tid;
  70 static volatile sig_atomic_t slapd_listener = 0;
  71
  72 static struct slap_daemon {
  73         ldap_pvt_thread_mutex_t sd_mutex;
  74
  75         int sd_nactives;
  76
  77 #ifndef HAVE_WINSOCK
  78         /* In winsock, accept() returns values higher than dtblsize
  79                 so don't bother with this optimization */
  80         int sd_nfds;
  81 #endif
  82
  83         fd_set sd_actives;
  84         fd_set sd_readers;
  85         fd_set sd_writers;
  86 } slap_daemon;
  87
  88 /*
  89  * Add a descriptor to daemon control
  90  */
  91 static void slapd_add(ber_socket_t s) {
  92         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
  93
  94         assert( !FD_ISSET( s, &slap_daemon.sd_actives ));
  95         assert( !FD_ISSET( s, &slap_daemon.sd_readers ));
  96         assert( !FD_ISSET( s, &slap_daemon.sd_writers ));
  97
  98 #ifndef HAVE_WINSOCK
  99         if (s >= slap_daemon.sd_nfds) {
 100                 slap_daemon.sd_nfds = s + 1;
 101         }
 102 #endif
 103
 104         FD_SET( s, &slap_daemon.sd_actives );
 105         FD_SET( s, &slap_daemon.sd_readers );
 106
 107         Debug( LDAP_DEBUG_CONNS, "daemon: added %ld%s%s\n",
 108                 (long) s,
 109             FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 110                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
 111
 112         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 113 }
 114
 115 /*
 116  * Remove the descriptor from daemon control
 117  */
 118 void slapd_remove(ber_socket_t s, int wake) {
 119         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 120         WAKE_LISTENER(wake);
 121
 122         Debug( LDAP_DEBUG_CONNS, "daemon: removing %ld%s%s\n",
 123                 (long) s,
 124             FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 125                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
 126
 127         FD_CLR( s, &slap_daemon.sd_actives );
 128         FD_CLR( s, &slap_daemon.sd_readers );
 129         FD_CLR( s, &slap_daemon.sd_writers );
 130
 131         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 132 }
 133
 134 void slapd_clr_write(ber_socket_t s, int wake) {
 135         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 136         WAKE_LISTENER(wake);
 137
 138         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 139         FD_CLR( s, &slap_daemon.sd_writers );
 140
 141         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 142
 143         if( wake ) {
 144                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 145         }
 146 }
 147
 148 void slapd_set_write(ber_socket_t s, int wake) {
 149         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 150     WAKE_LISTENER(wake);
 151
 152         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 153         FD_SET( (unsigned) s, &slap_daemon.sd_writers );
 154
 155         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 156
 157         if( wake ) {
 158                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 159         }
 160 }
 161
 162 void slapd_clr_read(ber_socket_t s, int wake) {
 163         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 164     WAKE_LISTENER(wake);
 165
 166         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 167         FD_CLR( s, &slap_daemon.sd_readers );
 168
 169         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 170
 171         if( wake ) {
 172                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 173         }
 174 }
 175
 176 void slapd_set_read(ber_socket_t s, int wake) {
 177         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 178     WAKE_LISTENER(wake);
 179
 180         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 181         FD_SET( s, &slap_daemon.sd_readers );
 182
 183         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 184
 185         if( wake ) {
 186                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 187         }
 188 }
 189
 190 static void slapd_close(ber_socket_t s) {
 191         Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n",
 192                 (long) s, 0, 0 );
 193         tcp_close(s);
 194 }
 195
 196
 197 Listener *
 198 open_listener(
 199         const char* url,
 200         int port,
 201         int tls_port )
 202 {
 203         int     tmp, rc;
 204         Listener l;
 205         Listener *li;
 206         LDAPURLDesc *lud;
 207
 208         rc = ldap_url_parse( url, &lud );
 209
 210         if( rc != LDAP_URL_SUCCESS ) {
 211                 Debug( LDAP_DEBUG_ANY,
 212                         "daemon: listen URL \"%s\" parse error=%d\n",
 213                         url, rc, 0 );
 214                 return NULL;
 215         }
 216
 217 #ifndef HAVE_TLS
 218         if( lud->lud_ldaps ) {
 219                 Debug( LDAP_DEBUG_ANY,
 220                         "daemon: TLS not supported (%s)\n",
 221                         url, 0, 0 );
 222                 ldap_free_urldesc( lud );
 223                 return NULL;
 224         }
 225
 226         if(! lud->lud_port ) {
 227                 lud->lud_port = port;
 228         }
 229
 230 #else
 231         l.sl_is_tls = lud->lud_ldaps;
 232
 233         if(! lud->lud_port ) {
 234                 lud->lud_port = lud->lud_ldaps ? tls_port : port;
 235         }
 236 #endif
 237
 238         (void) memset( (void*) &l.sl_addr, '\0', sizeof(l.sl_addr) );
 239
 240         l.sl_addr.sin_family = AF_INET;
 241         l.sl_addr.sin_port = htons( (unsigned short) lud->lud_port );
 242
 243         if( lud->lud_host == NULL || lud->lud_host[0] == '\0'
 244                 || strcmp(lud->lud_host, "*") == 0 )
 245         {
 246                 l.sl_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 247
 248         } else {
 249                 /* host or address was specified */
 250
 251                 if( isdigit( lud->lud_host[0] ) ) {
 252 #ifdef HAVE_WINSOCK
 253                         if(!(l.sl_addr.sin_addr.S_un.S_addr = inet_addr(lud->lud_host)))
 254 #else
 255                         if(!inet_aton(lud->lud_host, &l.sl_addr.sin_addr))
 256 #endif
 257                         {
 258                                 Debug( LDAP_DEBUG_ANY, "invalid address (%s) in URL: %s",
 259                                         lud->lud_host, url, 0);
 260                                 ldap_free_urldesc( lud );
 261                                 return NULL;
 262                         }
 263
 264                 } else {
 265                         struct hostent *he = gethostbyname( lud->lud_host );
 266                         if( he == NULL ) {
 267                                 Debug( LDAP_DEBUG_ANY, "invalid host (%s) in URL: %s",
 268                                         lud->lud_host, url, 0);
 269                                 ldap_free_urldesc( lud );
 270                                 return NULL;
 271                         }
 272
 273 #ifdef HAVE_WINSOCK
 274                         if(!(l.sl_addr.sin_addr.S_un.S_addr = inet_addr(he->h_addr)))
 275 #else
 276                         if(!inet_aton(he->h_addr, &l.sl_addr.sin_addr))
 277 #endif
 278                         {
 279                                 Debug( LDAP_DEBUG_ANY, "%s has invalid address (%s) in URL: %s",
 280                                         lud->lud_host, he->h_addr, url );
 281                                 ldap_free_urldesc( lud );
 282                                 return NULL;
 283                         }
 284                 }
 285         }
 286
 287         ldap_free_urldesc( lud );
 288
 289
 290         if ( (l.sl_sd = socket( AF_INET, SOCK_STREAM, 0 )) == AC_SOCKET_INVALID ) {
 291 #ifndef HAVE_WINSOCK
 292                 int err = errno;
 293                 Debug( LDAP_DEBUG_ANY,
 294                         "daemon: socket() failed errno %d (%s)\n", err,
 295                 err > -1 && err < sys_nerr ? sys_errlist[err] :
 296                 "unknown", 0 );
 297 #else
 298                 Debug( LDAP_DEBUG_ANY,
 299                         "daemon: socket() failed errno %d (%s)\n",
 300                         WSAGetLastError(),
 301                 WSAGetLastErrorString(), 0 );
 302 #endif
 303                 return NULL;
 304         }
 305
 306 #ifndef HAVE_WINSOCK
 307         if ( l.sl_sd >= dtblsize ) {
 308                 Debug( LDAP_DEBUG_ANY,
 309                         "daemon: listener descriptor %ld is too great %ld\n",
 310                         (long) l.sl_sd, (long) dtblsize, 0 );
 311                 tcp_close( l.sl_sd );
 312                 return NULL;
 313         }
 314 #endif
 315
 316 #ifdef SO_REUSEADDR
 317         tmp = 1;
 318         if ( setsockopt( l.sl_sd, SOL_SOCKET, SO_REUSEADDR,
 319                 (char *) &tmp, sizeof(tmp) ) == -1 )
 320         {
 321                 int err = errno;
 322                 Debug( LDAP_DEBUG_ANY,
 323                "slapd(%ld): setsockopt() failed errno %d (%s)\n",
 324                 (long) l.sl_sd, err,
 325                         err > -1 && err < sys_nerr
 326                                 ? sys_errlist[err] : "unknown" );
 327         }
 328 #endif
 329 #ifdef SO_KEEPALIVE
 330         tmp = 1;
 331         if ( setsockopt( l.sl_sd, SOL_SOCKET, SO_KEEPALIVE,
 332                 (char *) &tmp, sizeof(tmp) ) == -1 )
 333         {
 334                 int err = errno;
 335                 Debug( LDAP_DEBUG_ANY,
 336                         "slapd(%ld): setsockopt(KEEPALIVE) failed errno %d (%s)\n",
 337                 (long) l.sl_sd, err,
 338                         err > -1 && err < sys_nerr
 339                                 ? sys_errlist[err] : "unknown" );
 340         }
 341 #endif
 342
 343         if ( bind( l.sl_sd, (struct sockaddr *) &l.sl_addr, sizeof(l.sl_addr) ) == -1 ) {
 344                 int err = errno;
 345                 Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno %d (%s)\n",
 346                 (long) l.sl_sd, err,
 347                         err > -1 && err < sys_nerr
 348                                 ? sys_errlist[err] : "unknown" );
 349                 tcp_close( l.sl_sd );
 350                 return NULL;
 351         }
 352
 353         l.sl_url = ch_strdup( url );
 354
 355         li = ch_malloc( sizeof( Listener ) );
 356         *li = l;
 357
 358         Debug( LDAP_DEBUG_TRACE, "daemon: initialized %s\n",
 359                 l.sl_url, 0, 0 );
 360
 361         return li;
 362 }
 363
 364 static int sockinit(void);
 365 static int sockdestroy(void);
 366
 367 int slapd_daemon_init(char *urls, int port, int tls_port )
 368 {
 369         int i, rc;
 370         char **u;
 371
 372 #ifndef HAVE_TLS
 373         assert( tls_port == 0 );
 374 #endif
 375
 376         Debug( LDAP_DEBUG_ARGS, "daemon_init: %s (%d/%d)\n",
 377                 urls ? urls : "<null>", port, tls_port );
 378
 379         if( rc = sockinit() ) {
 380                 return rc;
 381         }
 382
 383 #ifdef HAVE_SYSCONF
 384         dtblsize = sysconf( _SC_OPEN_MAX );
 385 #elif HAVE_GETDTABLESIZE
 386         dtblsize = getdtablesize();
 387 #else
 388         dtblsize = FD_SETSIZE;
 389 #endif
 390
 391 #ifdef FD_SETSIZE
 392         if(dtblsize > FD_SETSIZE) {
 393                 dtblsize = FD_SETSIZE;
 394         }
 395 #endif  /* !FD_SETSIZE */
 396
 397         FD_ZERO( &slap_daemon.sd_readers );
 398         FD_ZERO( &slap_daemon.sd_writers );
 399
 400         if( urls == NULL ) {
 401                 urls = "ldap:///";
 402         }
 403
 404         u = str2charray( urls, " " );
 405
 406         if( u == NULL || u[0] == NULL ) {
 407                 Debug( LDAP_DEBUG_ANY, "daemon_init: no urls (%s) provided.\n",
 408                         urls, 0, 0 );
 409
 410                 return -1;
 411         }
 412
 413         for( i=0; u[i] != NULL; i++ ) {
 414                 Debug( LDAP_DEBUG_TRACE, "daemon_init: listen on %s\n",
 415                         u[i], 0, 0 );
 416         }
 417
 418         if( i == 0 ) {
 419                 Debug( LDAP_DEBUG_ANY, "daemon_init: no listeners to open (%s)\n",
 420                         urls, 0, 0 );
 421                 return -1;
 422         }
 423
 424         Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners to open...\n",
 425                 i, 0, 0 );
 426
 427         slap_listeners = ch_malloc( (i+1)*sizeof(Listener *) );
 428
 429         for(i = 0; u[i] != NULL; i++ ) {
 430                 slap_listeners[i] = open_listener( u[i], port, tls_port );
 431
 432                 if( slap_listeners[i] == NULL ) {
 433                         return -1;
 434                 }
 435         }
 436         slap_listeners[i] = NULL;
 437
 438         Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners opened.\n",
 439                 i, 0, 0 );
 440
 441         charray_free( u );
 442         ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
 443         return !i;
 444 }
 445
 446
 447 slapd_daemon_destroy(void)
 448 {
 449         connections_destroy();
 450         sockdestroy();
 451         return 0;
 452 }
 453
 454
 455 static void *
 456 slapd_daemon_task(
 457         void *ptr
 458 )
 459 {
 460         int l;
 461
 462         time( &starttime );
 463
 464         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 465                 if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
 466                         continue;
 467
 468                 if ( listen( slap_listeners[l]->sl_sd, 5 ) == -1 ) {
 469                         int err = errno;
 470                         Debug( LDAP_DEBUG_ANY,
 471                                 "daemon: listen(%s, 5) failed errno %d (%s)\n",
 472                                         (long) slap_listeners[l]->sl_url, err,
 473                                         err > -1 && err < sys_nerr
 474                                         ? sys_errlist[err] : "unknown" );
 475
 476                         return( (void*)-1 );
 477                 }
 478
 479                 slapd_add( slap_listeners[l]->sl_sd );
 480         }
 481
 482 #ifdef HAVE_WINSOCK
 483         if ( started_event != NULL ) {
 484                 ldap_pvt_thread_cond_signal( &started_event );
 485         }
 486 #endif
 487         /* initialization complete. Here comes the loop. */
 488
 489         while ( !slapd_shutdown ) {
 490                 ber_socket_t i;
 491                 int ns;
 492                 int at;
 493                 ber_socket_t nfds;
 494 #define SLAPD_EBADF_LIMIT 10
 495                 int ebadf = 0;
 496
 497 #define SLAPD_IDLE_CHECK_LIMIT 4
 498                 time_t  last_idle_check = slap_get_time();
 499                 time_t  now;
 500
 501
 502                 fd_set                  readfds;
 503                 fd_set                  writefds;
 504
 505                 struct sockaddr_in      from;
 506 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
 507         struct hostent          *hp;
 508 #endif
 509                 struct timeval          zero;
 510                 struct timeval          *tvp;
 511
 512                 char    *client_name;
 513                 char    *client_addr;
 514
 515                 if( global_idletimeout > 0 && difftime(
 516                         last_idle_check+global_idletimeout/SLAPD_IDLE_CHECK_LIMIT,
 517                         now ) < 0 )
 518                 {
 519                         connections_timeout_idle(now);
 520                 }
 521
 522                 FD_ZERO( &writefds );
 523                 FD_ZERO( &readfds );
 524
 525                 zero.tv_sec = 0;
 526                 zero.tv_usec = 0;
 527
 528                 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 529
 530 #ifdef FD_SET_MANUAL_COPY
 531                 for( s = 0; s < nfds; s++ ) {
 532                         if(FD_ISSET( &slap_sd_writers, s )) {
 533                                 FD_SET( &writefds, s );
 534                         }
 535                         if(FD_ISSET( &slap_sd_writers, s )) {
 536                                 FD_SET( &writefds, s );
 537                         }
 538                 }
 539 #else
 540                 memcpy( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
 541                 memcpy( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
 542 #endif
 543
 544                 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 545                         if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
 546                                 continue;
 547                         FD_SET( slap_listeners[l]->sl_sd, &readfds );
 548                 }
 549
 550 #ifndef HAVE_WINSOCK
 551                 nfds = slap_daemon.sd_nfds;
 552 #else
 553                 nfds = dtblsize;
 554 #endif
 555
 556                 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 557
 558                 ldap_pvt_thread_mutex_lock( &active_threads_mutex );
 559                 at = active_threads;
 560                 ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
 561
 562 #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
 563                 tvp = NULL;
 564 #else
 565                 tvp = at ? &zero : NULL;
 566 #endif
 567
 568                 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 569                         if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
 570                                 continue;
 571
 572                         Debug( LDAP_DEBUG_CONNS,
 573                                 "daemon: select: listen=%d active_threads=%d tvp=%s\n",
 574                                         slap_listeners[l]->sl_sd, at,
 575                                         tvp == NULL ? "NULL" : "zero" );
 576                 }
 577
 578                 switch(ns = select( nfds, &readfds,
 579 #ifdef HAVE_WINSOCK
 580                         /* don't pass empty fd_set */
 581                         ( writefds.fd_count > 0 ? &writefds : NULL ),
 582 #else
 583                         &writefds,
 584 #endif
 585                         NULL, tvp ))
 586                 {
 587                 case -1: {      /* failure - try again */
 588 #ifdef HAVE_WINSOCK
 589                                 int err = WSAGetLastError();
 590 #else
 591                                 int err = errno;
 592 #endif
 593
 594                                 if( err == EBADF && ++ebadf < SLAPD_EBADF_LIMIT) {
 595                                         continue;
 596                                 }
 597
 598                                 if( err != EINTR ) {
 599                                         Debug( LDAP_DEBUG_CONNS,
 600                                                 "daemon: select failed (%d): %s\n",
 601                                                 err,
 602                                                 err >= 0 && err < sys_nerr
 603                                                         ? sys_errlist[err] : "unknown",
 604                                                 0 );
 605
 606
 607                                 slapd_shutdown = -1;
 608                                 }
 609                         }
 610                         continue;
 611
 612                 case 0:         /* timeout - let threads run */
 613                         ebadf = 0;
 614                         Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
 615                             0, 0, 0 );
 616                 ldap_pvt_thread_yield();
 617                         continue;
 618
 619                 default:        /* something happened - deal with it */
 620                         ebadf = 0;
 621                         Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
 622                                 ns, 0, 0 );
 623                         /* FALL THRU */
 624                 }
 625
 626                 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 627                         ber_int_t s;
 628                         socklen_t len = sizeof(from);
 629                         long id;
 630
 631                         if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
 632                                 continue;
 633
 634                         if ( !FD_ISSET( slap_listeners[l]->sl_sd, &readfds ) )
 635                                 continue;
 636
 637                         if ( (s = accept( slap_listeners[l]->sl_sd,
 638                                 (struct sockaddr *) &from, &len )) == AC_SOCKET_INVALID )
 639                         {
 640                                 int err = errno;
 641                                 Debug( LDAP_DEBUG_ANY,
 642                                     "daemon: accept(%ld) failed errno %d (%s)\n", err,
 643                                     (long) slap_listeners[l]->sl_sd,
 644                                     err >= 0 && err < sys_nerr ?
 645                                     sys_errlist[err] : "unknown");
 646                                 continue;
 647                         }
 648
 649 #ifdef LDAP_DEBUG
 650                         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 651
 652                         /* newly accepted stream should not be in any of the FD SETS */
 653
 654                         assert( !FD_ISSET( s, &slap_daemon.sd_actives) );
 655                         assert( !FD_ISSET( s, &slap_daemon.sd_readers) );
 656                         assert( !FD_ISSET( s, &slap_daemon.sd_writers) );
 657
 658                         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 659 #endif
 660
 661 #ifndef HAVE_WINSOCK
 662                         /* make sure descriptor number isn't too great */
 663                         if ( s >= dtblsize ) {
 664                                 Debug( LDAP_DEBUG_ANY,
 665                                         "daemon: %ld beyond descriptor table size %ld\n",
 666                                         (long) s, (long) dtblsize, 0 );
 667                                 slapd_close(s);
 668                                 continue;
 669                         }
 670 #endif
 671
 672                         Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
 673                                 (long) s, 0, 0 );
 674
 675                         len = sizeof(from);
 676                         if ( getpeername( s, (struct sockaddr *) &from, &len ) == 0 ) {
 677                                 client_addr = inet_ntoa( from.sin_addr );
 678
 679 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
 680                                 hp = gethostbyaddr( (char *)
 681                                     &(from.sin_addr.s_addr),
 682                                     sizeof(from.sin_addr.s_addr), AF_INET );
 683
 684                                 if(hp) {
 685                                         char *p;
 686                                         client_name = hp->h_name;
 687
 688                                         /* normalize the domain */
 689                                         for ( p = client_name; *p; p++ ) {
 690                                                 *p = TOLOWER( (unsigned char) *p );
 691                                         }
 692
 693                                 } else {
 694                                         client_name = NULL;
 695                                 }
 696 #else
 697                                 client_name = NULL;
 698 #endif
 699
 700                         } else {
 701                                 client_name = NULL;;
 702                                 client_addr = NULL;
 703                         }
 704
 705 #ifdef HAVE_TCPD
 706                         if(!hosts_ctl("slapd",
 707                                 client_name != NULL ? client_name : STRING_UNKNOWN,
 708                                 client_addr != NULL ? client_addr : STRING_UNKNOWN,
 709                                 STRING_UNKNOWN))
 710                         {
 711                                 /* DENY ACCESS */
 712                                 Statslog( LDAP_DEBUG_ANY,
 713                                  "fd=%ld connection from %s (%s) denied.\n",
 714                                         (long) s,
 715                                         client_name == NULL ? "unknown" : client_name,
 716                                         client_addr == NULL ? "unknown" : client_addr,
 717                                   0, 0 );
 718
 719                                 slapd_close(s);
 720                                 continue;
 721                         }
 722 #endif /* HAVE_TCPD */
 723
 724                         if( (id = connection_init(s, client_name, client_addr,
 725 #ifdef HAVE_TLS
 726                                 slap_listeners[l]->sl_is_tls
 727 #else
 728                                 0
 729 #endif
 730                                 )) < 0 )
 731                         {
 732                                 Debug( LDAP_DEBUG_ANY,
 733                                         "daemon: connection_init(%ld, %s, %s) failed.\n",
 734                                         (long) s,
 735                                         client_name == NULL ? "unknown" : client_name,
 736                                         client_addr == NULL ? "unknown" : client_addr);
 737                                 slapd_close(s);
 738                                 continue;
 739                         }
 740
 741                         Statslog( LDAP_DEBUG_STATS,
 742                                 "daemon: conn=%d fd=%ld connection from %s (%s) accepted.\n",
 743                                 id, (long) s,
 744                                 client_name == NULL ? "unknown" : client_name,
 745                                 client_addr == NULL ? "unknown" : client_addr,
 746                                 0 );
 747
 748                         slapd_add( s );
 749                         continue;
 750                 }
 751
 752 #ifdef LDAP_DEBUG
 753                 Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
 754 #ifdef HAVE_WINSOCK
 755                 for ( i = 0; i < readfds.fd_count; i++ ) {
 756                         Debug( LDAP_DEBUG_CONNS, " %d%s",
 757                                 readfds.fd_array[i], "r", 0 );
 758                 }
 759                 for ( i = 0; i < writefds.fd_count; i++ ) {
 760                         Debug( LDAP_DEBUG_CONNS, " %d%s",
 761                                 writefds.fd_array[i], "w", 0 );
 762                 }
 763 #else
 764                 for ( i = 0; i < nfds; i++ ) {
 765                         int     a, r, w;
 766                         int     is_listener = 0;
 767
 768                         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 769                                 if ( i == slap_listeners[l]->sl_sd ) {
 770                                         is_listener = 1;
 771                                         break;
 772                                 }
 773                         }
 774                         if ( is_listener ) {
 775                                 continue;
 776                         }
 777                         r = FD_ISSET( i, &readfds );
 778                         w = FD_ISSET( i, &writefds );
 779                         if ( r || w ) {
 780                                 Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
 781                                     r ? "r" : "", w ? "w" : "" );
 782                         }
 783                 }
 784 #endif
 785                 Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
 786 #endif
 787
 788                 /* loop through the writers */
 789 #ifdef HAVE_WINSOCK
 790                 for ( i = 0; i < writefds.fd_count; i++ )
 791 #else
 792                 for ( i = 0; i < nfds; i++ )
 793 #endif
 794                 {
 795                         ber_socket_t wd;
 796                         int is_listener = 0;
 797 #ifdef HAVE_WINSOCK
 798                         wd = writefds.fd_array[i];
 799 #else
 800                         if( ! FD_ISSET( i, &writefds ) ) {
 801                                 continue;
 802                         }
 803                         wd = i;
 804 #endif
 805
 806                         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 807                                 if ( i == slap_listeners[l]->sl_sd ) {
 808                                         is_listener = 1;
 809                                         break;
 810                                 }
 811                         }
 812                         if ( is_listener ) {
 813                                 continue;
 814                         }
 815                         Debug( LDAP_DEBUG_CONNS,
 816                                 "daemon: write active on %d\n",
 817                                 wd, 0, 0 );
 818
 819                         /*
 820                          * NOTE: it is possible that the connection was closed
 821                          * and that the stream is now inactive.
 822                          * connection_write() must valid the stream is still
 823                          * active.
 824                          */
 825
 826                         if ( connection_write( wd ) < 0 ) {
 827                                 FD_CLR( (unsigned) wd, &readfds );
 828                                 slapd_close( wd );
 829                         }
 830                 }
 831
 832 #ifdef HAVE_WINSOCK
 833                 for ( i = 0; i < readfds.fd_count; i++ )
 834 #else
 835                 for ( i = 0; i < nfds; i++ )
 836 #endif
 837                 {
 838                         ber_socket_t rd;
 839                         int is_listener = 0;
 840                         int rc;
 841
 842 #ifdef HAVE_WINSOCK
 843                         rd = readfds.fd_array[i];
 844 #else
 845                         if( ! FD_ISSET( i, &readfds ) ) {
 846                                 continue;
 847                         }
 848                         rd = i;
 849 #endif
 850
 851                         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 852                                 if ( i == slap_listeners[l]->sl_sd ) {
 853                                         is_listener = 1;
 854                                         break;
 855                                 }
 856                         }
 857                         if ( is_listener ) {
 858                                 continue;
 859                         }
 860
 861                         Debug ( LDAP_DEBUG_CONNS,
 862                                 "daemon: read activity on %d\n", rd, 0, 0 );
 863
 864                         /*
 865                          * NOTE: it is possible that the connection was closed
 866                          * and that the stream is now inactive.
 867                          * connection_read() must valid the stream is still
 868                          * active.
 869                          */
 870
 871                         while ( ( rc = connection_read( rd ) ) > 0 )
 872                                 ;
 873                         if ( rc < 0 ) {
 874                                 slapd_close( rd );
 875                         }
 876                 }
 877                 ldap_pvt_thread_yield();
 878         }
 879
 880         if( slapd_shutdown > 0 ) {
 881                 Debug( LDAP_DEBUG_TRACE,
 882                         "daemon: shutdown requested and initiated.\n",
 883                         0, 0, 0 );
 884
 885         } else if ( slapd_shutdown < 0 ) {
 886                 Debug( LDAP_DEBUG_TRACE,
 887                         "daemon: abnormal condition, shutdown initiated.\n",
 888                         0, 0, 0 );
 889         } else {
 890                 Debug( LDAP_DEBUG_TRACE,
 891                         "daemon: no active streams, shutdown initiated.\n",
 892                         0, 0, 0 );
 893         }
 894
 895         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 896                 if ( slap_listeners[l]->sl_sd != AC_SOCKET_INVALID ) {
 897                         slapd_close( slap_listeners[l]->sl_sd );
 898                         break;
 899                 }
 900         }
 901
 902         ldap_pvt_thread_mutex_lock( &active_threads_mutex );
 903         Debug( LDAP_DEBUG_ANY,
 904             "slapd shutdown: waiting for %d threads to terminate\n",
 905             active_threads, 0, 0 );
 906         while ( active_threads > 0 ) {
 907                 ldap_pvt_thread_cond_wait(&active_threads_cond, &active_threads_mutex);
 908         }
 909         ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
 910
 911         return NULL;
 912 }
 913
 914
 915 int slapd_daemon( void )
 916 {
 917         int rc;
 918
 919         connections_init();
 920
 921 #define SLAPD_LISTENER_THREAD 1
 922 #if defined( SLAPD_LISTENER_THREAD ) || !defined(HAVE_PTHREADS)
 923
 924         /* listener as a separate THREAD */
 925         rc = ldap_pvt_thread_create( &listener_tid,
 926                 0, slapd_daemon_task, NULL );
 927
 928         if ( rc != 0 ) {
 929                 Debug( LDAP_DEBUG_ANY,
 930                     "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
 931                 return rc;
 932         }
 933
 934         /* wait for the listener thread to complete */
 935         ldap_pvt_thread_join( listener_tid, (void *) NULL );
 936 #else
 937         /* expermimental code */
 938         listener_tid = pthread_self();
 939         slapd_daemon_task( NULL );
 940 #endif
 941
 942         return 0;
 943
 944 }
 945
 946 #ifdef HAVE_WINSOCK2
 947 int sockinit(void)
 948 {
 949     WORD wVersionRequested;
 950         WSADATA wsaData;
 951         int err;
 952
 953         wVersionRequested = MAKEWORD( 2, 0 );
 954
 955         err = WSAStartup( wVersionRequested, &wsaData );
 956         if ( err != 0 ) {
 957                 /* Tell the user that we couldn't find a usable */
 958                 /* WinSock DLL.                                  */
 959                 return -1;
 960         }
 961
 962         /* Confirm that the WinSock DLL supports 2.0.*/
 963         /* Note that if the DLL supports versions greater    */
 964         /* than 2.0 in addition to 2.0, it will still return */
 965         /* 2.0 in wVersion since that is the version we      */
 966         /* requested.                                        */
 967
 968         if ( LOBYTE( wsaData.wVersion ) != 2 ||
 969                 HIBYTE( wsaData.wVersion ) != 0 )
 970         {
 971             /* Tell the user that we couldn't find a usable */
 972             /* WinSock DLL.                                  */
 973             WSACleanup();
 974             return -1;
 975         }
 976
 977         /* The WinSock DLL is acceptable. Proceed. */
 978         return 0;
 979 }
 980
 981 int sockdestroy(void)
 982 {
 983         WSACleanup();
 984         return 0;
 985 }
 986
 987 void hit_socket(void)
 988 {
 989         ber_socket_t s;
 990         int on = 1;
 991         extern struct sockaddr_in       bind_addr;
 992
 993         /* throw something at the socket to terminate the select() in the daemon thread. */
 994         if (( s = socket( AF_INET, SOCK_STREAM, 0 )) == AC_SOCKET_INVALID )
 995                 Debug( LDAP_DEBUG_ANY,
 996                         "slap_set_shutdown: socket failed\n\tWSAGetLastError=%d (%s)\n",
 997                         WSAGetLastError(), WSAGetLastErrorString(), 0 );
 998
 999         if ( ioctlsocket( s, FIONBIO, &on ) == -1 )
1000                 Debug( LDAP_DEBUG_ANY,
1001                         "slap_set_shutdown:FIONBIO ioctl on %d faled\n\tWSAGetLastError=%d (%s)\n",
1002                         s, WSAGetLastError(), WSAGetLastError() );
1003
1004         bind_addr.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
1005
1006         if ( connect( s, (struct sockaddr *)&bind_addr, sizeof( struct sockaddr_in )) == SOCKET_ERROR ) {
1007                 Debug( LDAP_DEBUG_ANY,
1008                         "hit_socket: error on connect: %d\n",
1009                         WSAGetLastError(), 0, 0 );
1010                 /* we can probably expect some error to occur here, mostly WSAEWOULDBLOCK */
1011         }
1012
1013         tcp_close(s);
1014 }
1015
1016 #elif HAVE_WINSOCK
1017 static int sockinit(void)
1018 {       WSADATA wsaData;
1019         if ( WSAStartup( 0x0101, &wsaData ) != 0 ) {
1020             return -1;
1021         }
1022         return 0;
1023 }
1024 static int sockdestroy(void)
1025 {
1026         WSACleanup();
1027         return 0;
1028 }
1029
1030 #else
1031 static int sockinit(void)
1032 {
1033         return 0;
1034 }
1035 static int sockdestroy(void)
1036 {
1037         return 0;
1038 }
1039 #endif
1040
1041 void
1042 slap_set_shutdown( int sig )
1043 {
1044         int l;
1045         slapd_shutdown = sig;
1046 #ifndef HAVE_WINSOCK
1047         if(slapd_listener) {
1048                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
1049         }
1050 #else
1051         Debug( LDAP_DEBUG_TRACE, "Shutdown %d ordered", sig, 0, 0 );
1052         /* trying to "hit" the socket seems to always get a */
1053         /* EWOULDBLOCK error, so just close the listen socket to */
1054         /* break out of the select since we're shutting down anyway */
1055         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1056                 if ( slap_listeners[l]->sl_sd >= 0 ) {
1057                         tcp_close( slap_listeners[l]->sl_sd );
1058                 }
1059         }
1060 #endif
1061         /* reinstall self */
1062         (void) SIGNAL( sig, slap_set_shutdown );
1063 }
1064
1065 void
1066 slap_do_nothing( int sig )
1067 {
1068         /* reinstall self */
1069         (void) SIGNAL( sig, slap_do_nothing );
1070 }