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

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6
   7 #include "portable.h"
   8
   9 #include <stdio.h>
  10
  11 #include <ac/ctype.h>
  12 #include <ac/errno.h>
  13 #include <ac/socket.h>
  14 #include <ac/string.h>
  15 #include <ac/time.h>
  16 #include <ac/unistd.h>
  17
  18 #include "ldap_pvt.h"
  19 #include "ldap_pvt_thread.h"
  20 #include "lutil.h"
  21 #include "slap.h"
  22
  23 #ifdef HAVE_TCPD
  24 #include <tcpd.h>
  25 #define SLAP_STRING_UNKNOWN     STRING_UNKNOWN
  26
  27 int allow_severity = LOG_INFO;
  28 int deny_severity = LOG_NOTICE;
  29 #else /* ! TCP Wrappers */
  30 #define SLAP_STRING_UNKNOWN     "unknown"
  31 #endif /* ! TCP Wrappers */
  32
  33 #ifdef LDAP_PF_LOCAL
  34 #include <sys/stat.h>
  35 /* this should go in <ldap.h> as soon as it is accepted */
  36 #define LDAPI_MOD_URLEXT                "x-mod"
  37 #endif /* LDAP_PF_LOCAL */
  38
  39 #ifdef LDAP_PF_INET6
  40 int slap_inet4or6 = AF_UNSPEC;
  41 #else
  42 int slap_inet4or6 = AF_INET;
  43 #endif
  44
  45 /* globals */
  46 time_t starttime;
  47 ber_socket_t dtblsize;
  48
  49 Listener **slap_listeners = NULL;
  50
  51 #define SLAPD_LISTEN 10
  52
  53 static ber_socket_t wake_sds[2];
  54
  55 #if defined(NO_THREADS) || defined(HAVE_GNU_PTH)
  56 static int waking;
  57 #define WAKE_LISTENER(w) \
  58 ((w && !waking) ? tcp_write( wake_sds[1], "0", 1 ), waking=1 : 0)
  59 #else
  60 #define WAKE_LISTENER(w) \
  61 do { if (w) tcp_write( wake_sds[1], "0", 1 ); } while(0)
  62 #endif
  63
  64 #ifndef HAVE_WINSOCK
  65 static
  66 #endif
  67 volatile sig_atomic_t slapd_shutdown = 0, slapd_gentle_shutdown = 0;
  68
  69 static struct slap_daemon {
  70         ldap_pvt_thread_mutex_t sd_mutex;
  71
  72         ber_socket_t sd_nactives;
  73
  74 #ifndef HAVE_WINSOCK
  75         /* In winsock, accept() returns values higher than dtblsize
  76                 so don't bother with this optimization */
  77         int sd_nfds;
  78 #endif
  79
  80         fd_set sd_actives;
  81         fd_set sd_readers;
  82         fd_set sd_writers;
  83 } slap_daemon;
  84
  85
  86
  87 #ifdef HAVE_SLP
  88 /*
  89  * SLP related functions
  90  */
  91 #include <slp.h>
  92
  93 #define LDAP_SRVTYPE_PREFIX "service:ldap://"
  94 #define LDAPS_SRVTYPE_PREFIX "service:ldaps://"
  95 static char** slapd_srvurls = NULL;
  96 static SLPHandle slapd_hslp = 0;
  97
  98 void slapd_slp_init( const char* urls ) {
  99         int i;
 100
 101         slapd_srvurls = ldap_str2charray( urls, " " );
 102
 103         if( slapd_srvurls == NULL ) return;
 104
 105         /* find and expand INADDR_ANY URLs */
 106         for( i=0; slapd_srvurls[i] != NULL; i++ ) {
 107                 if( strcmp( slapd_srvurls[i], "ldap:///" ) == 0) {
 108                         char *host = ldap_pvt_get_fqdn( NULL );
 109                         if ( host != NULL ) {
 110                                 slapd_srvurls[i] = (char *) ch_realloc( slapd_srvurls[i],
 111                                         strlen( host ) +
 112                                         sizeof( LDAP_SRVTYPE_PREFIX ) );
 113                                 strcpy( lutil_strcopy(slapd_srvurls[i],
 114                                         LDAP_SRVTYPE_PREFIX ), host );
 115
 116                                 ch_free( host );
 117                         }
 118
 119                 } else if ( strcmp( slapd_srvurls[i], "ldaps:///" ) == 0) {
 120                         char *host = ldap_pvt_get_fqdn( NULL );
 121                         if ( host != NULL ) {
 122                                 slapd_srvurls[i] = (char *) ch_realloc( slapd_srvurls[i],
 123                                         strlen( host ) +
 124                                         sizeof( LDAPS_SRVTYPE_PREFIX ) );
 125                                 strcpy( lutil_strcopy(slapd_srvurls[i],
 126                                         LDAPS_SRVTYPE_PREFIX ), host );
 127
 128                                 ch_free( host );
 129                         }
 130                 }
 131         }
 132
 133         /* open the SLP handle */
 134         SLPOpen( "en", 0, &slapd_hslp );
 135 }
 136
 137 void slapd_slp_deinit() {
 138         if( slapd_srvurls == NULL ) return;
 139
 140         ldap_charray_free( slapd_srvurls );
 141         slapd_srvurls = NULL;
 142
 143         /* close the SLP handle */
 144         SLPClose( slapd_hslp );
 145 }
 146
 147 void slapd_slp_regreport(
 148         SLPHandle hslp,
 149         SLPError errcode,
 150         void* cookie )
 151 {
 152         /* empty report */
 153 }
 154
 155 void slapd_slp_reg() {
 156         int i;
 157
 158         for( i=0; slapd_srvurls[i] != NULL; i++ ) {
 159                 if( strncmp( slapd_srvurls[i], LDAP_SRVTYPE_PREFIX,
 160                                 sizeof( LDAP_SRVTYPE_PREFIX ) - 1 ) == 0 ||
 161                     strncmp( slapd_srvurls[i], LDAPS_SRVTYPE_PREFIX,
 162                                 sizeof( LDAPS_SRVTYPE_PREFIX ) - 1 ) == 0 )
 163                 {
 164                         SLPReg( slapd_hslp,
 165                                 slapd_srvurls[i],
 166                                 SLP_LIFETIME_MAXIMUM,
 167                                 "ldap",
 168                                 "",
 169                                 1,
 170                                 slapd_slp_regreport,
 171                                 NULL );
 172                 }
 173         }
 174 }
 175
 176 void slapd_slp_dereg() {
 177         int i;
 178
 179         if( slapd_srvurls == NULL ) return;
 180
 181         for( i=0; slapd_srvurls[i] != NULL; i++ ) {
 182                 SLPDereg( slapd_hslp,
 183                         slapd_srvurls[i],
 184                         slapd_slp_regreport,
 185                         NULL );
 186         }
 187 }
 188 #endif /* HAVE_SLP */
 189
 190 /*
 191  * Add a descriptor to daemon control
 192  */
 193 static void slapd_add(ber_socket_t s) {
 194         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 195
 196         assert( !FD_ISSET( s, &slap_daemon.sd_actives ));
 197         assert( !FD_ISSET( s, &slap_daemon.sd_readers ));
 198         assert( !FD_ISSET( s, &slap_daemon.sd_writers ));
 199
 200 #ifndef HAVE_WINSOCK
 201         if (s >= slap_daemon.sd_nfds) {
 202                 slap_daemon.sd_nfds = s + 1;
 203         }
 204 #endif
 205
 206         slap_daemon.sd_nactives++;
 207
 208         FD_SET( s, &slap_daemon.sd_actives );
 209         FD_SET( s, &slap_daemon.sd_readers );
 210
 211 #ifdef NEW_LOGGING
 212         LDAP_LOG( CONNECTION, DETAIL1,
 213                 "slapd_add: added %ld%s%s\n", (long)s,
 214                 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 215                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
 216 #else
 217         Debug( LDAP_DEBUG_CONNS, "daemon: added %ld%s%s\n",
 218                 (long) s,
 219             FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 220                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
 221 #endif
 222         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 223 }
 224
 225 /*
 226  * Remove the descriptor from daemon control
 227  */
 228 void slapd_remove(ber_socket_t s, int wake) {
 229         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 230
 231         slap_daemon.sd_nactives--;
 232
 233 #ifdef NEW_LOGGING
 234         LDAP_LOG( CONNECTION, DETAIL1,
 235                 "slapd_remove: removing %ld%s%s\n", (long) s,
 236                 FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 237                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : ""  );
 238 #else
 239         Debug( LDAP_DEBUG_CONNS, "daemon: removing %ld%s%s\n",
 240                 (long) s,
 241             FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 242                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
 243 #endif
 244         FD_CLR( s, &slap_daemon.sd_actives );
 245         FD_CLR( s, &slap_daemon.sd_readers );
 246         FD_CLR( s, &slap_daemon.sd_writers );
 247
 248         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 249         WAKE_LISTENER(wake || slapd_gentle_shutdown == 2);
 250 }
 251
 252 void slapd_clr_write(ber_socket_t s, int wake) {
 253         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 254
 255         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 256         FD_CLR( s, &slap_daemon.sd_writers );
 257
 258         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 259         WAKE_LISTENER(wake);
 260 }
 261
 262 void slapd_set_write(ber_socket_t s, int wake) {
 263         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 264
 265         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 266         if (!FD_ISSET(s, &slap_daemon.sd_writers))
 267             FD_SET( (unsigned) s, &slap_daemon.sd_writers );
 268
 269         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 270         WAKE_LISTENER(wake);
 271 }
 272
 273 void slapd_clr_read(ber_socket_t s, int wake) {
 274         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 275
 276         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 277         FD_CLR( s, &slap_daemon.sd_readers );
 278
 279         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 280         WAKE_LISTENER(wake);
 281 }
 282
 283 void slapd_set_read(ber_socket_t s, int wake) {
 284         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 285
 286         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 287         if (!FD_ISSET(s, &slap_daemon.sd_readers))
 288             FD_SET( s, &slap_daemon.sd_readers );
 289
 290         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 291         WAKE_LISTENER(wake);
 292 }
 293
 294 static void slapd_close(ber_socket_t s) {
 295 #ifdef NEW_LOGGING
 296         LDAP_LOG( CONNECTION, DETAIL1, "slapd_close: closing %ld\n", (long)s, 0, 0);
 297 #else
 298         Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n",
 299                 (long) s, 0, 0 );
 300 #endif
 301         tcp_close(s);
 302 }
 303
 304 static void slap_free_listener_addresses(struct sockaddr **sal)
 305 {
 306         struct sockaddr **sap;
 307
 308         if (sal == NULL) {
 309                 return;
 310         }
 311
 312         for (sap = sal; *sap != NULL; sap++) {
 313                 ch_free(*sap);
 314         }
 315
 316         ch_free(sal);
 317 }
 318
 319 #if defined(LDAP_PF_LOCAL) || defined(SLAP_X_LISTENER_MOD)
 320 static int get_url_perms(
 321         char    **exts,
 322         mode_t  *perms,
 323         int     *crit )
 324 {
 325         int     i;
 326
 327         assert( exts );
 328         assert( perms );
 329         assert( crit );
 330
 331         *crit = 0;
 332         for ( i = 0; exts[ i ]; i++ ) {
 333                 char    *type = exts[ i ];
 334                 int     c = 0;
 335
 336                 if ( type[ 0 ] == '!' ) {
 337                         c = 1;
 338                         type++;
 339                 }
 340
 341                 if ( strncasecmp( type, LDAPI_MOD_URLEXT "=", sizeof(LDAPI_MOD_URLEXT "=") - 1 ) == 0 ) {
 342                         char    *value = type
 343                                 + ( sizeof(LDAPI_MOD_URLEXT "=") - 1 );
 344                         mode_t  p = 0;
 345                         int     j;
 346
 347                         switch (strlen(value)) {
 348                         case 4:
 349                                 /* skip leading '0' */
 350                                 if ( value[ 0 ] != '0' ) {
 351                                         return LDAP_OTHER;
 352                                 }
 353                                 value++;
 354
 355                         case 3:
 356                                 for ( j = 0; j < 3; j++) {
 357                                         int     v;
 358
 359                                         v = value[ j ] - '0';
 360
 361                                         if ( v < 0 || v > 7 ) {
 362                                                 return LDAP_OTHER;
 363                                         }
 364
 365                                         p |= v << 3*(2-j);
 366                                 }
 367                                 break;
 368
 369                         case 10:
 370                                 for ( j = 1; j < 10; j++ ) {
 371                                         static mode_t   m[] = { 0,
 372                                                 S_IRUSR, S_IWUSR, S_IXUSR,
 373                                                 S_IRGRP, S_IWGRP, S_IXGRP,
 374                                                 S_IROTH, S_IWOTH, S_IXOTH
 375                                         };
 376                                         static char     c[] = "-rwxrwxrwx";
 377
 378                                         if ( value[ j ] == c[ j ] ) {
 379                                                 p |= m[ j ];
 380
 381                                         } else if ( value[ j ] != '-' ) {
 382                                                 return LDAP_OTHER;
 383                                         }
 384                                 }
 385                                 break;
 386
 387                         default:
 388                                 return LDAP_OTHER;
 389                         }
 390
 391                         *crit = c;
 392                         *perms = p;
 393
 394                         return LDAP_SUCCESS;
 395                 }
 396         }
 397
 398         return LDAP_OTHER;
 399 }
 400 #endif /* LDAP_PF_LOCAL || SLAP_X_LISTENER_MOD */
 401
 402 /* port = 0 indicates AF_LOCAL */
 403 static int slap_get_listener_addresses(
 404         const char *host,
 405         unsigned short port,
 406         struct sockaddr ***sal)
 407 {
 408         struct sockaddr **sap;
 409
 410 #ifdef LDAP_PF_LOCAL
 411         if ( port == 0 ) {
 412                 *sal = ch_malloc(2 * sizeof(void *));
 413                 if (*sal == NULL) {
 414                         return -1;
 415                 }
 416
 417                 sap = *sal;
 418                 *sap = ch_malloc(sizeof(struct sockaddr_un));
 419                 if (*sap == NULL)
 420                         goto errexit;
 421                 sap[1] = NULL;
 422
 423                 if ( strlen(host) >
 424                      (sizeof(((struct sockaddr_un *)*sap)->sun_path) - 1) ) {
 425 #ifdef NEW_LOGGING
 426                         LDAP_LOG( CONNECTION, INFO,
 427                                 "slap_get_listener_addresses: domain socket path (%s) "
 428                                 "too long in URL\n", host, 0, 0 );
 429 #else
 430                         Debug( LDAP_DEBUG_ANY,
 431                                "daemon: domain socket path (%s) too long in URL",
 432                                host, 0, 0);
 433 #endif
 434                         goto errexit;
 435                 }
 436
 437                 (void)memset( (void *)*sap, '\0', sizeof(struct sockaddr_un) );
 438                 (*sap)->sa_family = AF_LOCAL;
 439                 strcpy( ((struct sockaddr_un *)*sap)->sun_path, host );
 440         } else
 441 #endif
 442         {
 443 #ifdef HAVE_GETADDRINFO
 444                 struct addrinfo hints, *res, *sai;
 445                 int n, err;
 446                 char serv[7];
 447
 448                 memset( &hints, '\0', sizeof(hints) );
 449                 hints.ai_flags = AI_PASSIVE;
 450                 hints.ai_socktype = SOCK_STREAM;
 451                 hints.ai_family = slap_inet4or6;
 452                 snprintf(serv, sizeof serv, "%d", port);
 453
 454                 if ( (err = getaddrinfo(host, serv, &hints, &res)) ) {
 455 #ifdef NEW_LOGGING
 456                         LDAP_LOG( CONNECTION, INFO,
 457                                    "slap_get_listener_addresses: getaddrinfo failed: %s\n",
 458                                    AC_GAI_STRERROR(err), 0, 0 );
 459 #else
 460                         Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed: %s\n",
 461                                 AC_GAI_STRERROR(err), 0, 0);
 462 #endif
 463                         return -1;
 464                 }
 465
 466                 sai = res;
 467                 for (n=2; (sai = sai->ai_next) != NULL; n++) {
 468                         /* EMPTY */ ;
 469                 }
 470                 *sal = ch_calloc(n, sizeof(void *));
 471                 if (*sal == NULL) {
 472                         return -1;
 473                 }
 474
 475                 sap = *sal;
 476                 *sap = NULL;
 477
 478                 for ( sai=res; sai; sai=sai->ai_next ) {
 479                         if( sai->ai_addr == NULL ) {
 480 #ifdef NEW_LOGGING
 481                                 LDAP_LOG( CONNECTION, INFO,
 482                                         "slap_get_listener_addresses: "
 483                                         "getaddrinfo ai_addr is NULL?\n", 0, 0, 0 );
 484 #else
 485                                 Debug( LDAP_DEBUG_ANY, "slap_get_listener_addresses: "
 486                                         "getaddrinfo ai_addr is NULL?\n", 0, 0, 0 );
 487 #endif
 488                                 freeaddrinfo(res);
 489                                 goto errexit;
 490                         }
 491
 492                         switch (sai->ai_family) {
 493 #  ifdef LDAP_PF_INET6
 494                         case AF_INET6:
 495                                 *sap = ch_malloc(sizeof(struct sockaddr_in6));
 496                                 if (*sap == NULL) {
 497                                         freeaddrinfo(res);
 498                                         goto errexit;
 499                                 }
 500                                 *(struct sockaddr_in6 *)*sap =
 501                                         *((struct sockaddr_in6 *)sai->ai_addr);
 502                                 break;
 503 #  endif
 504                         case AF_INET:
 505                                 *sap = ch_malloc(sizeof(struct sockaddr_in));
 506                                 if (*sap == NULL) {
 507                                         freeaddrinfo(res);
 508                                         goto errexit;
 509                                 }
 510                                 *(struct sockaddr_in *)*sap =
 511                                         *((struct sockaddr_in *)sai->ai_addr);
 512                                 break;
 513                         default:
 514                                 *sap = NULL;
 515                                 break;
 516                         }
 517
 518                         if (*sap != NULL) {
 519                                 (*sap)->sa_family = sai->ai_family;
 520                                 sap++;
 521                                 *sap = NULL;
 522                         }
 523                 }
 524
 525                 freeaddrinfo(res);
 526 #else
 527                 int i, n = 1;
 528                 struct in_addr in;
 529                 struct hostent *he = NULL;
 530
 531                 if ( host == NULL ) {
 532                         in.s_addr = htonl(INADDR_ANY);
 533
 534                 } else if ( !inet_aton( host, &in ) ) {
 535                         he = gethostbyname( host );
 536                         if( he == NULL ) {
 537 #ifdef NEW_LOGGING
 538                                 LDAP_LOG( CONNECTION, INFO,
 539                                         "slap_get_listener_addresses: invalid host %s\n", host, 0, 0 );
 540 #else
 541                                 Debug( LDAP_DEBUG_ANY,
 542                                        "daemon: invalid host %s", host, 0, 0);
 543 #endif
 544                                 return -1;
 545                         }
 546                         for (n = 0; he->h_addr_list[n]; n++) ;
 547                 }
 548
 549                 *sal = ch_malloc((n+1) * sizeof(void *));
 550                 if (*sal == NULL) {
 551                         return -1;
 552                 }
 553
 554                 sap = *sal;
 555                 for ( i = 0; i<n; i++ ) {
 556                         sap[i] = ch_malloc(sizeof(struct sockaddr_in));
 557                         if (*sap == NULL) {
 558                                 goto errexit;
 559                         }
 560                         (void)memset( (void *)sap[i], '\0', sizeof(struct sockaddr_in) );
 561                         sap[i]->sa_family = AF_INET;
 562                         ((struct sockaddr_in *)sap[i])->sin_port = htons(port);
 563                         if (he) {
 564                                 AC_MEMCPY( &((struct sockaddr_in *)sap[i])->sin_addr, he->h_addr_list[i], sizeof(struct in_addr) );
 565                         } else {
 566                                 AC_MEMCPY( &((struct sockaddr_in *)sap[i])->sin_addr, &in, sizeof(struct in_addr) );
 567                         }
 568                 }
 569                 sap[i] = NULL;
 570 #endif
 571         }
 572
 573         return 0;
 574
 575 errexit:
 576         slap_free_listener_addresses(*sal);
 577         return -1;
 578 }
 579
 580 static int slap_open_listener(
 581         const char* url,
 582         int *listeners,
 583         int *cur
 584         )
 585 {
 586         int     num, tmp, rc;
 587         Listener l;
 588         Listener *li;
 589         LDAPURLDesc *lud;
 590         unsigned short port;
 591         int err, addrlen = 0;
 592         struct sockaddr **sal, **psal;
 593         int socktype = SOCK_STREAM;     /* default to COTS */
 594
 595 #if defined(LDAP_PF_LOCAL) || defined(SLAP_X_LISTENER_MOD)
 596         /*
 597          * use safe defaults
 598          */
 599         int     crit = 1;
 600 #endif /* LDAP_PF_LOCAL || SLAP_X_LISTENER_MOD */
 601
 602         rc = ldap_url_parse( url, &lud );
 603
 604         if( rc != LDAP_URL_SUCCESS ) {
 605 #ifdef NEW_LOGGING
 606                 LDAP_LOG( CONNECTION, ERR,
 607                         "slap_open_listener: listen URL \"%s\" parse error %d\n",
 608                         url, rc , 0 );
 609 #else
 610                 Debug( LDAP_DEBUG_ANY,
 611                         "daemon: listen URL \"%s\" parse error=%d\n",
 612                         url, rc, 0 );
 613 #endif
 614                 return rc;
 615         }
 616
 617         l.sl_url.bv_val = NULL;
 618
 619 #ifndef HAVE_TLS
 620         if( ldap_pvt_url_scheme2tls( lud->lud_scheme ) ) {
 621 #ifdef NEW_LOGGING
 622                 LDAP_LOG( CONNECTION, INFO,
 623                            "slap_open_listener: TLS is not supported (%s)\n", url, 0, 0 );
 624 #else
 625                 Debug( LDAP_DEBUG_ANY,
 626                         "daemon: TLS not supported (%s)\n",
 627                         url, 0, 0 );
 628 #endif
 629                 ldap_free_urldesc( lud );
 630                 return -1;
 631         }
 632
 633         if(! lud->lud_port ) {
 634                 lud->lud_port = LDAP_PORT;
 635         }
 636
 637 #else
 638         l.sl_is_tls = ldap_pvt_url_scheme2tls( lud->lud_scheme );
 639
 640         if(! lud->lud_port ) {
 641                 lud->lud_port = l.sl_is_tls ? LDAPS_PORT : LDAP_PORT;
 642         }
 643 #endif
 644
 645         port = (unsigned short) lud->lud_port;
 646
 647         tmp = ldap_pvt_url_scheme2proto(lud->lud_scheme);
 648         if ( tmp == LDAP_PROTO_IPC ) {
 649 #ifdef LDAP_PF_LOCAL
 650                 if ( lud->lud_host == NULL || lud->lud_host[0] == '\0' ) {
 651                         err = slap_get_listener_addresses(LDAPI_SOCK, 0, &sal);
 652                 } else {
 653                         err = slap_get_listener_addresses(lud->lud_host, 0, &sal);
 654                 }
 655 #else
 656
 657 #ifdef NEW_LOGGING
 658                 LDAP_LOG( CONNECTION, INFO,
 659                         "slap_open_listener: URL scheme is not supported: %s\n", url, 0, 0 );
 660 #else
 661                 Debug( LDAP_DEBUG_ANY, "daemon: URL scheme not supported: %s",
 662                         url, 0, 0);
 663 #endif
 664                 ldap_free_urldesc( lud );
 665                 return -1;
 666 #endif
 667         } else {
 668                 if( lud->lud_host == NULL || lud->lud_host[0] == '\0'
 669                         || strcmp(lud->lud_host, "*") == 0 )
 670                 {
 671                         err = slap_get_listener_addresses(NULL, port, &sal);
 672                 } else {
 673                         err = slap_get_listener_addresses(lud->lud_host, port, &sal);
 674                 }
 675         }
 676 #ifdef LDAP_CONNECTIONLESS
 677         l.sl_is_udp = ( tmp == LDAP_PROTO_UDP );
 678 #endif
 679
 680 #if defined(LDAP_PF_LOCAL) || defined(SLAP_X_LISTENER_MOD)
 681         if ( lud->lud_exts ) {
 682                 err = get_url_perms( lud->lud_exts, &l.sl_perms, &crit );
 683         } else {
 684                 l.sl_perms = S_IRWXU | S_IRWXO;
 685         }
 686 #endif /* LDAP_PF_LOCAL || SLAP_X_LISTENER_MOD */
 687
 688         ldap_free_urldesc( lud );
 689         if ( err ) {
 690                 return -1;
 691         }
 692
 693         /* If we got more than one address returned, we need to make space
 694          * for it in the slap_listeners array.
 695          */
 696         for ( num=0; sal[num]; num++ );
 697         if ( num > 1 ) {
 698                 *listeners += num-1;
 699                 slap_listeners = ch_realloc( slap_listeners, (*listeners + 1) * sizeof(Listener *) );
 700         }
 701
 702         psal = sal;
 703         while ( *sal != NULL ) {
 704                 switch( (*sal)->sa_family ) {
 705                 case AF_INET:
 706 #ifdef LDAP_PF_INET6
 707                 case AF_INET6:
 708 #endif
 709 #ifdef LDAP_PF_LOCAL
 710                 case AF_LOCAL:
 711 #endif
 712                         break;
 713                 default:
 714                         sal++;
 715                         continue;
 716                 }
 717 #ifdef LDAP_CONNECTIONLESS
 718                 if( l.sl_is_udp ) socktype = SOCK_DGRAM;
 719 #endif
 720                 l.sl_sd = socket( (*sal)->sa_family, socktype, 0);
 721                 if ( l.sl_sd == AC_SOCKET_INVALID ) {
 722                         int err = sock_errno();
 723 #ifdef NEW_LOGGING
 724                         LDAP_LOG( CONNECTION, ERR,
 725                                 "slap_open_listener: socket() failed errno=%d (%s)\n",
 726                                 err, sock_errstr(err), 0 );
 727 #else
 728                         Debug( LDAP_DEBUG_ANY,
 729                                 "daemon: socket() failed errno=%d (%s)\n", err,
 730                                 sock_errstr(err), 0 );
 731 #endif
 732                         sal++;
 733                         continue;
 734                 }
 735 #ifndef HAVE_WINSOCK
 736                 if ( l.sl_sd >= dtblsize ) {
 737 #ifdef NEW_LOGGING
 738                         LDAP_LOG( CONNECTION, ERR,
 739                                 "slap_open_listener: listener descriptor %ld is too "
 740                                 "great %ld\n", (long)l.sl_sd, (long)dtblsize, 0 );
 741 #else
 742                         Debug( LDAP_DEBUG_ANY,
 743                                "daemon: listener descriptor %ld is too great %ld\n",
 744                                (long) l.sl_sd, (long) dtblsize, 0 );
 745 #endif
 746                         tcp_close( l.sl_sd );
 747                         sal++;
 748                         continue;
 749                 }
 750 #endif
 751 #ifdef LDAP_PF_LOCAL
 752                 if ( (*sal)->sa_family == AF_LOCAL ) {
 753                         unlink ( ((struct sockaddr_un *)*sal)->sun_path );
 754                 } else
 755 #endif
 756                 {
 757 #ifdef SO_REUSEADDR
 758                         /* enable address reuse */
 759                         tmp = 1;
 760                         rc = setsockopt( l.sl_sd, SOL_SOCKET, SO_REUSEADDR,
 761                                          (char *) &tmp, sizeof(tmp) );
 762                         if ( rc == AC_SOCKET_ERROR ) {
 763                                 int err = sock_errno();
 764 #ifdef NEW_LOGGING
 765                                 LDAP_LOG( CONNECTION, INFO,
 766                                         "slap_open_listener: setsockopt( %ld, SO_REUSEADDR ) "
 767                                         "failed errno %d (%s)\n", (long)l.sl_sd, err,
 768                                         sock_errstr(err) );
 769 #else
 770                                 Debug( LDAP_DEBUG_ANY,
 771                                        "slapd(%ld): setsockopt(SO_REUSEADDR) failed errno=%d (%s)\n",
 772                                        (long) l.sl_sd, err, sock_errstr(err) );
 773 #endif
 774                         }
 775 #endif
 776                 }
 777
 778                 switch( (*sal)->sa_family ) {
 779                 case AF_INET:
 780                         addrlen = sizeof(struct sockaddr_in);
 781                         break;
 782 #ifdef LDAP_PF_INET6
 783                 case AF_INET6:
 784 #ifdef IPV6_V6ONLY
 785                         /* Try to use IPv6 sockets for IPv6 only */
 786                         tmp = 1;
 787                         rc = setsockopt( l.sl_sd, IPPROTO_IPV6, IPV6_V6ONLY,
 788                                          (char *) &tmp, sizeof(tmp) );
 789                         if ( rc == AC_SOCKET_ERROR ) {
 790                                 int err = sock_errno();
 791 #ifdef NEW_LOGGING
 792                                 LDAP_LOG( CONNECTION, INFO,
 793                                            "slap_open_listener: setsockopt( %ld, IPV6_V6ONLY ) failed errno %d (%s)\n",
 794                                            (long)l.sl_sd, err, sock_errstr(err) );
 795 #else
 796                                 Debug( LDAP_DEBUG_ANY,
 797                                        "slapd(%ld): setsockopt(IPV6_V6ONLY) failed errno=%d (%s)\n",
 798                                        (long) l.sl_sd, err, sock_errstr(err) );
 799 #endif
 800                         }
 801 #endif
 802                         addrlen = sizeof(struct sockaddr_in6);
 803                         break;
 804 #endif
 805 #ifdef LDAP_PF_LOCAL
 806                 case AF_LOCAL:
 807                         addrlen = sizeof(struct sockaddr_un);
 808                         break;
 809 #endif
 810                 }
 811
 812                 if (bind(l.sl_sd, *sal, addrlen)) {
 813                         err = sock_errno();
 814 #ifdef NEW_LOGGING
 815                 LDAP_LOG( CONNECTION, INFO,
 816                         "slap_open_listener: bind(%ld) failed errno=%d (%s)\n",
 817                         (long)l.sl_sd, err, sock_errstr(err) );
 818 #else
 819                 Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno=%d (%s)\n",
 820                        (long) l.sl_sd, err, sock_errstr(err) );
 821 #endif
 822                         tcp_close( l.sl_sd );
 823                         sal++;
 824                         continue;
 825                 }
 826
 827         switch ( (*sal)->sa_family ) {
 828 #ifdef LDAP_PF_LOCAL
 829         case AF_LOCAL: {
 830                 char *addr = ((struct sockaddr_un *)*sal)->sun_path;
 831 #if 0 /* don't muck with socket perms */
 832                 if ( chmod( addr, l.sl_perms ) < 0 && crit ) {
 833                         int err = sock_errno();
 834 #ifdef NEW_LOGGING
 835                         LDAP_LOG( CONNECTION, INFO,
 836                                 "slap_open_listener: fchmod(%ld) failed errno=%d (%s)\n",
 837                                 (long)l.sl_sd, err, sock_errstr(err) );
 838 #else
 839                         Debug( LDAP_DEBUG_ANY, "daemon: fchmod(%ld) failed errno=%d (%s)",
 840                                (long) l.sl_sd, err, sock_errstr(err) );
 841 #endif
 842                         tcp_close( l.sl_sd );
 843                         slap_free_listener_addresses(psal);
 844                         return -1;
 845                 }
 846 #endif
 847                 l.sl_name.bv_len = strlen(addr) + sizeof("PATH=") - 1;
 848                 l.sl_name.bv_val = ber_memalloc( l.sl_name.bv_len + 1 );
 849                 snprintf( l.sl_name.bv_val, l.sl_name.bv_len + 1,
 850                                 "PATH=%s", addr );
 851         } break;
 852 #endif /* LDAP_PF_LOCAL */
 853
 854         case AF_INET: {
 855                 char *s;
 856 #if defined( HAVE_GETADDRINFO ) && defined( HAVE_INET_NTOP )
 857                 char addr[INET_ADDRSTRLEN];
 858                 inet_ntop( AF_INET, &((struct sockaddr_in *)*sal)->sin_addr,
 859                            addr, sizeof(addr) );
 860                 s = addr;
 861 #else
 862                 s = inet_ntoa( ((struct sockaddr_in *) *sal)->sin_addr );
 863 #endif
 864                 port = ntohs( ((struct sockaddr_in *)*sal) ->sin_port );
 865                 l.sl_name.bv_val = ber_memalloc( sizeof("IP=255.255.255.255:65535") );
 866                 snprintf( l.sl_name.bv_val, sizeof("IP=255.255.255.255:65535"),
 867                         "IP=%s:%d",
 868                          s != NULL ? s : SLAP_STRING_UNKNOWN, port );
 869                 l.sl_name.bv_len = strlen( l.sl_name.bv_val );
 870         } break;
 871
 872 #ifdef LDAP_PF_INET6
 873         case AF_INET6: {
 874                 char addr[INET6_ADDRSTRLEN];
 875                 inet_ntop( AF_INET6, &((struct sockaddr_in6 *)*sal)->sin6_addr,
 876                            addr, sizeof addr);
 877                 port = ntohs( ((struct sockaddr_in6 *)*sal)->sin6_port );
 878                 l.sl_name.bv_len = strlen(addr) + sizeof("IP= 65535");
 879                 l.sl_name.bv_val = ber_memalloc( l.sl_name.bv_len );
 880                 snprintf( l.sl_name.bv_val, l.sl_name.bv_len, "IP=%s %d",
 881                                 addr, port );
 882                 l.sl_name.bv_len = strlen( l.sl_name.bv_val );
 883         } break;
 884 #endif /* LDAP_PF_INET6 */
 885
 886         default:
 887 #ifdef NEW_LOGGING
 888                 LDAP_LOG( CONNECTION, INFO,
 889                         "slap_open_listener: unsupported address family (%d)\n",
 890                         (int)(*sal)->sa_family, 0, 0 );
 891 #else
 892                 Debug( LDAP_DEBUG_ANY, "daemon: unsupported address family (%d)\n",
 893                         (int) (*sal)->sa_family, 0, 0 );
 894 #endif
 895                 break;
 896         }
 897
 898         AC_MEMCPY(&l.sl_sa, *sal, addrlen);
 899         ber_str2bv( url, 0, 1, &l.sl_url);
 900         li = ch_malloc( sizeof( Listener ) );
 901         *li = l;
 902         slap_listeners[*cur] = li;
 903         (*cur)++;
 904         sal++;
 905
 906         } /* while ( *sal != NULL ) */
 907
 908         slap_free_listener_addresses(psal);
 909
 910         if ( l.sl_url.bv_val == NULL )
 911         {
 912 #ifdef NEW_LOGGING
 913                 LDAP_LOG( CONNECTION, RESULTS,
 914                         "slap_open_listener: failed on %s\n", url, 0, 0 );
 915 #else
 916                 Debug( LDAP_DEBUG_TRACE,
 917                         "slap_open_listener: failed on %s\n", url, 0, 0 );
 918 #endif
 919                 return -1;
 920         }
 921
 922 #ifdef NEW_LOGGING
 923         LDAP_LOG( CONNECTION, RESULTS,
 924                 "slap_open_listener: daemon initialized %s\n",
 925                 l.sl_url.bv_val, 0, 0 );
 926 #else
 927         Debug( LDAP_DEBUG_TRACE, "daemon: initialized %s\n",
 928                 l.sl_url.bv_val, 0, 0 );
 929 #endif
 930         return 0;
 931 }
 932
 933 static int sockinit(void);
 934 static int sockdestroy(void);
 935
 936 int slapd_daemon_init( const char *urls )
 937 {
 938         int i, j, n, rc;
 939         char **u;
 940
 941 #ifdef NEW_LOGGING
 942         LDAP_LOG( CONNECTION, ARGS,
 943                 "slapd_daemon_init: %s\n", urls ? urls : "<null>", 0, 0 );
 944 #else
 945         Debug( LDAP_DEBUG_ARGS, "daemon_init: %s\n",
 946                 urls ? urls : "<null>", 0, 0 );
 947 #endif
 948         if( (rc = sockinit()) != 0 ) {
 949                 return rc;
 950         }
 951
 952 #ifdef HAVE_SYSCONF
 953         dtblsize = sysconf( _SC_OPEN_MAX );
 954 #elif HAVE_GETDTABLESIZE
 955         dtblsize = getdtablesize();
 956 #else
 957         dtblsize = FD_SETSIZE;
 958 #endif
 959
 960 #ifdef FD_SETSIZE
 961         if(dtblsize > FD_SETSIZE) {
 962                 dtblsize = FD_SETSIZE;
 963         }
 964 #endif  /* !FD_SETSIZE */
 965
 966         /* open a pipe (or something equivalent connected to itself).
 967          * we write a byte on this fd whenever we catch a signal. The main
 968          * loop will be select'ing on this socket, and will wake up when
 969          * this byte arrives.
 970          */
 971         if( (rc = lutil_pair( wake_sds )) < 0 ) {
 972 #ifdef NEW_LOGGING
 973                 LDAP_LOG( CONNECTION, ERR,
 974                         "slap_daemon_init: lutil_pair() failed rc=%d\n", rc, 0, 0);
 975 #else
 976                 Debug( LDAP_DEBUG_ANY,
 977                         "daemon: lutil_pair() failed rc=%d\n", rc, 0, 0 );
 978 #endif
 979                 return rc;
 980         }
 981
 982         FD_ZERO( &slap_daemon.sd_readers );
 983         FD_ZERO( &slap_daemon.sd_writers );
 984
 985         if( urls == NULL ) {
 986                 urls = "ldap:///";
 987         }
 988
 989         u = ldap_str2charray( urls, " " );
 990
 991         if( u == NULL || u[0] == NULL ) {
 992 #ifdef NEW_LOGGING
 993                 LDAP_LOG( CONNECTION, ERR,
 994                         "slap_daemon_init: no urls (%s) provided.\n", urls, 0, 0 );
 995 #else
 996                 Debug( LDAP_DEBUG_ANY, "daemon_init: no urls (%s) provided.\n",
 997                         urls, 0, 0 );
 998 #endif
 999                 return -1;
1000         }
1001
1002         for( i=0; u[i] != NULL; i++ ) {
1003 #ifdef NEW_LOGGING
1004                 LDAP_LOG( CONNECTION, DETAIL1,
1005                         "slap_daemon_init: listen on %s\n.", u[i], 0, 0 );
1006 #else
1007                 Debug( LDAP_DEBUG_TRACE, "daemon_init: listen on %s\n",
1008                         u[i], 0, 0 );
1009 #endif
1010         }
1011
1012         if( i == 0 ) {
1013 #ifdef NEW_LOGGING
1014                 LDAP_LOG( CONNECTION, INFO,
1015                          "slap_daemon_init: no listeners to open (%s)\n", urls, 0, 0 );
1016 #else
1017                 Debug( LDAP_DEBUG_ANY, "daemon_init: no listeners to open (%s)\n",
1018                         urls, 0, 0 );
1019 #endif
1020                 ldap_charray_free( u );
1021                 return -1;
1022         }
1023
1024 #ifdef NEW_LOGGING
1025         LDAP_LOG( CONNECTION, INFO,
1026                 "slap_daemon_init: %d listeners to open...\n", i, 0, 0 );
1027 #else
1028         Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners to open...\n",
1029                 i, 0, 0 );
1030 #endif
1031         slap_listeners = ch_malloc( (i+1)*sizeof(Listener *) );
1032
1033         for(n = 0, j = 0; u[n]; n++ ) {
1034                 if ( slap_open_listener( u[n], &i, &j ) ) {
1035                         ldap_charray_free( u );
1036                         return -1;
1037                 }
1038         }
1039         slap_listeners[j] = NULL;
1040
1041 #ifdef NEW_LOGGING
1042         LDAP_LOG( CONNECTION, DETAIL1,
1043                 "slap_daemon_init: %d listeners opened\n", i, 0, 0 );
1044 #else
1045         Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners opened\n",
1046                 i, 0, 0 );
1047 #endif
1048
1049 #ifdef HAVE_SLP
1050         slapd_slp_init( urls );
1051         slapd_slp_reg();
1052 #endif
1053
1054         ldap_charray_free( u );
1055         ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
1056         return !i;
1057 }
1058
1059
1060 int
1061 slapd_daemon_destroy(void)
1062 {
1063         connections_destroy();
1064         tcp_close( wake_sds[1] );
1065         tcp_close( wake_sds[0] );
1066         sockdestroy();
1067
1068 #ifdef HAVE_SLP
1069         slapd_slp_dereg();
1070         slapd_slp_deinit();
1071 #endif
1072
1073         return 0;
1074 }
1075
1076
1077 static void
1078 close_listeners(
1079         int remove
1080 )
1081 {
1082         int l;
1083
1084         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1085                 if ( slap_listeners[l]->sl_sd != AC_SOCKET_INVALID ) {
1086                         if ( remove )
1087                                 slapd_remove( slap_listeners[l]->sl_sd, 0 );
1088 #ifdef LDAP_PF_LOCAL
1089                         if ( slap_listeners[l]->sl_sa.sa_addr.sa_family == AF_LOCAL ) {
1090                                 unlink( slap_listeners[l]->sl_sa.sa_un_addr.sun_path );
1091                         }
1092 #endif /* LDAP_PF_LOCAL */
1093                         slapd_close( slap_listeners[l]->sl_sd );
1094                 }
1095                 if ( slap_listeners[l]->sl_url.bv_val )
1096                         ber_memfree( slap_listeners[l]->sl_url.bv_val );
1097                 if ( slap_listeners[l]->sl_name.bv_val )
1098                         ber_memfree( slap_listeners[l]->sl_name.bv_val );
1099                 free ( slap_listeners[l] );
1100                 slap_listeners[l] = NULL;
1101         }
1102 }
1103
1104
1105 static void *
1106 slapd_daemon_task(
1107         void *ptr
1108 )
1109 {
1110         int l;
1111         time_t  last_idle_check = 0;
1112         time( &starttime );
1113
1114         if ( global_idletimeout > 0 ) {
1115                 last_idle_check = slap_get_time();
1116         }
1117         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1118                 if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
1119                         continue;
1120 #ifdef LDAP_CONNECTIONLESS
1121                 /* Since this is connectionless, the data port is the
1122                  * listening port. The listen() and accept() calls
1123                  * are unnecessary.
1124                  */
1125                 if ( slap_listeners[l]->sl_is_udp ) {
1126                         slapd_add( slap_listeners[l]->sl_sd );
1127                         continue;
1128                 }
1129 #endif
1130
1131                 if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN ) == -1 ) {
1132                         int err = sock_errno();
1133
1134 #ifdef LDAP_PF_INET6
1135                         /* If error is EADDRINUSE, we are trying to listen to INADDR_ANY and
1136                          * we are already listening to in6addr_any, then we want to ignore
1137                          * this and continue.
1138                          */
1139                         if ( err == EADDRINUSE ) {
1140                                 int i;
1141                                 struct sockaddr_in sa = slap_listeners[l]->sl_sa.sa_in_addr;
1142                                 struct sockaddr_in6 sa6;
1143
1144                                 if ( sa.sin_family == AF_INET &&
1145                                      sa.sin_addr.s_addr == htonl(INADDR_ANY) ) {
1146                                         for ( i = 0 ; i < l; i++ ) {
1147                                                 sa6 = slap_listeners[i]->sl_sa.sa_in6_addr;
1148                                                 if ( sa6.sin6_family == AF_INET6 &&
1149                                                      !memcmp( &sa6.sin6_addr, &in6addr_any, sizeof(struct in6_addr) ) )
1150                                                         break;
1151                                         }
1152
1153                                         if ( i < l ) {
1154                                                 /* We are already listening to in6addr_any */
1155 #ifdef NEW_LOGGING
1156                                                 LDAP_LOG(CONNECTION, WARNING,
1157                                                            "slapd_daemon_task: Attempt to listen to 0.0.0.0 failed, already listening on ::, assuming IPv4 included\n", 0, 0, 0 );
1158 #else
1159                                                 Debug( LDAP_DEBUG_CONNS,
1160                                                        "daemon: Attempt to listen to 0.0.0.0 failed, already listening on ::, assuming IPv4 included\n",
1161                                                        0, 0, 0 );
1162 #endif
1163                                                 slapd_close( slap_listeners[l]->sl_sd );
1164                                                 slap_listeners[l]->sl_sd = AC_SOCKET_INVALID;
1165                                                 continue;
1166                                         }
1167                                 }
1168                         }
1169 #endif
1170 #ifdef NEW_LOGGING
1171                         LDAP_LOG( CONNECTION, ERR,
1172                                 "slapd_daemon_task: listen( %s, 5 ) failed errno=%d (%s)\n",
1173                                 slap_listeners[l]->sl_url.bv_val, err, sock_errstr(err) );
1174 #else
1175                         Debug( LDAP_DEBUG_ANY,
1176                                 "daemon: listen(%s, 5) failed errno=%d (%s)\n",
1177                                         slap_listeners[l]->sl_url.bv_val, err,
1178                                         sock_errstr(err) );
1179 #endif
1180                         return( (void*)-1 );
1181                 }
1182
1183                 slapd_add( slap_listeners[l]->sl_sd );
1184         }
1185
1186 #ifdef HAVE_NT_SERVICE_MANAGER
1187         if ( started_event != NULL ) {
1188                 ldap_pvt_thread_cond_signal( &started_event );
1189         }
1190 #endif
1191         /* initialization complete. Here comes the loop. */
1192
1193         while ( !slapd_shutdown ) {
1194                 ber_socket_t i;
1195                 int ns;
1196                 int at;
1197                 ber_socket_t nfds;
1198 #define SLAPD_EBADF_LIMIT 16
1199                 int ebadf = 0;
1200                 int emfile = 0;
1201
1202 #define SLAPD_IDLE_CHECK_LIMIT 4
1203                 time_t  now;
1204
1205
1206                 fd_set                  readfds;
1207                 fd_set                  writefds;
1208                 Sockaddr                from;
1209
1210                 struct timeval          zero;
1211                 struct timeval          *tvp;
1212
1213                 if( emfile ) {
1214                         now = slap_get_time();
1215                         connections_timeout_idle( now );
1216                 }
1217                 else if ( global_idletimeout > 0 ) {
1218                         now = slap_get_time();
1219                         if ( difftime( last_idle_check+global_idletimeout/SLAPD_IDLE_CHECK_LIMIT, now ) < 0 ) {
1220                                 connections_timeout_idle( now );
1221                         }
1222                 }
1223
1224 #ifdef SIGHUP
1225                 if( slapd_gentle_shutdown ) {
1226                         ber_socket_t active;
1227
1228                         if( slapd_gentle_shutdown == 1 ) {
1229                                 Debug( LDAP_DEBUG_ANY, "slapd gentle shutdown\n", 0, 0, 0 );
1230                                 close_listeners( 1 );
1231                                 global_restrictops |= SLAP_RESTRICT_OP_WRITES;
1232                                 slapd_gentle_shutdown = 2;
1233                         }
1234
1235                         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
1236                         active = slap_daemon.sd_nactives;
1237                         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
1238                         if( active == 0 ) {
1239                                 slapd_shutdown = 2;
1240                                 break;
1241                         }
1242                 }
1243 #endif
1244
1245                 FD_ZERO( &writefds );
1246                 FD_ZERO( &readfds );
1247
1248                 zero.tv_sec = 0;
1249                 zero.tv_usec = 0;
1250
1251                 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
1252
1253 #ifdef FD_SET_MANUAL_COPY
1254                 for( s = 0; s < nfds; s++ ) {
1255                         if(FD_ISSET( &slap_sd_readers, s )) {
1256                                 FD_SET( s, &readfds );
1257                         }
1258                         if(FD_ISSET( &slap_sd_writers, s )) {
1259                                 FD_SET( s, &writefds );
1260                         }
1261                 }
1262 #else
1263                 AC_MEMCPY( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
1264                 AC_MEMCPY( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
1265 #endif
1266                 assert(!FD_ISSET(wake_sds[0], &readfds));
1267                 FD_SET( wake_sds[0], &readfds );
1268
1269                 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1270                         if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
1271                                 continue;
1272                         if (!FD_ISSET(slap_listeners[l]->sl_sd, &readfds))
1273                             FD_SET( slap_listeners[l]->sl_sd, &readfds );
1274                 }
1275
1276 #ifndef HAVE_WINSOCK
1277                 nfds = slap_daemon.sd_nfds;
1278 #else
1279                 nfds = dtblsize;
1280 #endif
1281
1282                 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
1283
1284                 at = ldap_pvt_thread_pool_backload(&connection_pool);
1285
1286 #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
1287                 tvp = NULL;
1288 #else
1289                 tvp = at ? &zero : NULL;
1290 #endif
1291
1292                 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1293                         if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
1294                                 continue;
1295
1296 #ifdef NEW_LOGGING
1297                         LDAP_LOG( CONNECTION, DETAIL1,
1298                                 "slapd_daemon_task: select: listen=%d "
1299                                 "active_threads=%d tvp=%s\n",
1300                                 slap_listeners[l]->sl_sd, at, tvp == NULL ? "NULL" : "zero" );
1301 #else
1302                         Debug( LDAP_DEBUG_CONNS,
1303                                 "daemon: select: listen=%d active_threads=%d tvp=%s\n",
1304                                         slap_listeners[l]->sl_sd, at,
1305                                         tvp == NULL ? "NULL" : "zero" );
1306 #endif
1307                 }
1308
1309                 switch(ns = select( nfds, &readfds,
1310 #ifdef HAVE_WINSOCK
1311                         /* don't pass empty fd_set */
1312                         ( writefds.fd_count > 0 ? &writefds : NULL ),
1313 #else
1314                         &writefds,
1315 #endif
1316                         NULL, tvp ))
1317                 {
1318                 case -1: {      /* failure - try again */
1319                                 int err = sock_errno();
1320
1321                                 if( err == EBADF
1322 #ifdef WSAENOTSOCK
1323                                         /* you'd think this would be EBADF */
1324                                         || err == WSAENOTSOCK
1325 #endif
1326                                 ) {
1327                                         if (++ebadf < SLAPD_EBADF_LIMIT)
1328                                                 continue;
1329                                 }
1330
1331                                 if( err != EINTR ) {
1332 #ifdef NEW_LOGGING
1333                                         LDAP_LOG( CONNECTION, INFO,
1334                                                 "slapd_daemon_task: select failed (%d): %s\n",
1335                                                 err, sock_errstr(err), 0 );
1336 #else
1337                                         Debug( LDAP_DEBUG_CONNS,
1338                                                 "daemon: select failed (%d): %s\n",
1339                                                 err, sock_errstr(err), 0 );
1340 #endif
1341                                         slapd_shutdown = 2;
1342                                 }
1343                         }
1344                         continue;
1345
1346                 case 0:         /* timeout - let threads run */
1347                         ebadf = 0;
1348 #ifdef NEW_LOGGING
1349                         LDAP_LOG( CONNECTION, DETAIL2,
1350                                    "slapd_daemon_task: select timeout - yielding\n", 0, 0, 0 );
1351 #else
1352                         Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
1353                             0, 0, 0 );
1354 #endif
1355                         ldap_pvt_thread_yield();
1356                         continue;
1357
1358                 default:        /* something happened - deal with it */
1359                         if( slapd_shutdown ) continue;
1360
1361                         ebadf = 0;
1362 #ifdef NEW_LOGGING
1363                         LDAP_LOG( CONNECTION, DETAIL2,
1364                                    "slapd_daemon_task: activity on %d descriptors\n", ns, 0, 0 );
1365 #else
1366                         Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
1367                                 ns, 0, 0 );
1368 #endif
1369                         /* FALL THRU */
1370                 }
1371
1372                 if( FD_ISSET( wake_sds[0], &readfds ) ) {
1373                         char c[BUFSIZ];
1374                         tcp_read( wake_sds[0], c, sizeof(c) );
1375 #if defined(NO_THREADS) || defined(HAVE_GNU_PTH)
1376                         waking = 0;
1377 #endif
1378                         continue;
1379                 }
1380
1381                 for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1382                         ber_socket_t s;
1383                         socklen_t len = sizeof(from);
1384                         long id;
1385                         slap_ssf_t ssf = 0;
1386                         char *authid = NULL;
1387 #ifdef SLAPD_RLOOKUPS
1388                         char hbuf[NI_MAXHOST];
1389 #endif
1390
1391                         char    *dnsname = NULL;
1392                         char    *peeraddr = NULL;
1393 #ifdef LDAP_PF_LOCAL
1394                         char    peername[MAXPATHLEN + sizeof("PATH=")];
1395 #elif defined(LDAP_PF_INET6)
1396                         char    peername[sizeof("IP=ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 65535")];
1397 #else
1398                         char    peername[sizeof("IP=255.255.255.255:65336")];
1399 #endif /* LDAP_PF_LOCAL */
1400
1401                         peername[0] = '\0';
1402
1403                         if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
1404                                 continue;
1405
1406                         if ( !FD_ISSET( slap_listeners[l]->sl_sd, &readfds ) )
1407                                 continue;
1408
1409 #ifdef LDAP_CONNECTIONLESS
1410                         if ( slap_listeners[l]->sl_is_udp ) {
1411                                 /* The first time we receive a query, we set this
1412                                  * up as a "connection". It remains open for the life
1413                                  * of the slapd.
1414                                  */
1415                                 if ( slap_listeners[l]->sl_is_udp < 2 ) {
1416                                     id = connection_init(
1417                                         slap_listeners[l]->sl_sd,
1418                                         slap_listeners[l], "", "",
1419                                         2, ssf, authid );
1420                                     slap_listeners[l]->sl_is_udp++;
1421                                 }
1422                                 continue;
1423                         }
1424 #endif
1425
1426                         s = accept( slap_listeners[l]->sl_sd,
1427                                 (struct sockaddr *) &from, &len );
1428                         if ( s == AC_SOCKET_INVALID ) {
1429                                 int err = sock_errno();
1430
1431 #ifdef EMFILE
1432                                 if( err == EMFILE ) {
1433                                         emfile++;
1434                                 } else
1435 #endif
1436 #ifdef ENFILE
1437                                 if( err == ENFILE ) {
1438                                         emfile++;
1439                                 } else
1440 #endif
1441                                 {
1442                                         emfile=0;
1443                                 }
1444
1445                                 if( emfile < 3 ) {
1446 #ifdef NEW_LOGGING
1447                                         LDAP_LOG( CONNECTION, ERR,
1448                                                 "slapd_daemon_task: accept(%ld) failed errno=%d (%s)\n",
1449                                                 (long)slap_listeners[l]->sl_sd,
1450                                                 err, sock_errstr(err) );
1451 #else
1452                                         Debug( LDAP_DEBUG_ANY,
1453                                             "daemon: accept(%ld) failed errno=%d (%s)\n",
1454                                             (long) slap_listeners[l]->sl_sd, err,
1455                                             sock_errstr(err) );
1456 #endif
1457                                 } else {
1458                                         /* prevent busy loop */
1459 #  ifdef HAVE_USLEEP
1460                                         if( emfile % 4 == 3 ) usleep( 250 );
1461 #  else
1462                                         if( emfile % 8 == 7 ) sleep( 1 );
1463 #  endif
1464                                 }
1465
1466                                 ldap_pvt_thread_yield();
1467                                 continue;
1468                         }
1469                         emfile = 0;
1470
1471 #ifndef HAVE_WINSOCK
1472                         /* make sure descriptor number isn't too great */
1473                         if ( s >= dtblsize ) {
1474 #ifdef NEW_LOGGING
1475                                 LDAP_LOG( CONNECTION, ERR,
1476                                    "slapd_daemon_task: %ld beyond descriptor table size %ld\n",
1477                                    (long)s, (long)dtblsize, 0 );
1478 #else
1479                                 Debug( LDAP_DEBUG_ANY,
1480                                         "daemon: %ld beyond descriptor table size %ld\n",
1481                                         (long) s, (long) dtblsize, 0 );
1482 #endif
1483
1484                                 slapd_close(s);
1485                                 ldap_pvt_thread_yield();
1486                                 continue;
1487                         }
1488 #endif
1489
1490 #ifdef LDAP_DEBUG
1491                         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
1492
1493                         /* newly accepted stream should not be in any of the FD SETS */
1494                         assert( !FD_ISSET( s, &slap_daemon.sd_actives) );
1495                         assert( !FD_ISSET( s, &slap_daemon.sd_readers) );
1496                         assert( !FD_ISSET( s, &slap_daemon.sd_writers) );
1497
1498                         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
1499 #endif
1500
1501 #if defined( SO_KEEPALIVE ) || defined( TCP_NODELAY )
1502 #ifdef LDAP_PF_LOCAL
1503                         /* for IPv4 and IPv6 sockets only */
1504                         if ( from.sa_addr.sa_family != AF_LOCAL )
1505 #endif /* LDAP_PF_LOCAL */
1506                         {
1507                                 int rc;
1508                                 int tmp;
1509 #ifdef SO_KEEPALIVE
1510                                 /* enable keep alives */
1511                                 tmp = 1;
1512                                 rc = setsockopt( s, SOL_SOCKET, SO_KEEPALIVE,
1513                                         (char *) &tmp, sizeof(tmp) );
1514                                 if ( rc == AC_SOCKET_ERROR ) {
1515                                         int err = sock_errno();
1516 #ifdef NEW_LOGGING
1517                                         LDAP_LOG( CONNECTION, ERR,
1518                                                 "slapd_daemon_task: setsockopt( %ld, SO_KEEPALIVE)"
1519                                            " failed errno=%d (%s)\n",
1520                                                 (long)s, err, sock_errstr(err) );
1521 #else
1522                                         Debug( LDAP_DEBUG_ANY,
1523                                                 "slapd(%ld): setsockopt(SO_KEEPALIVE) failed "
1524                                                 "errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
1525 #endif
1526                                 }
1527 #endif
1528 #ifdef TCP_NODELAY
1529                                 /* enable no delay */
1530                                 tmp = 1;
1531                                 rc = setsockopt( s, IPPROTO_TCP, TCP_NODELAY,
1532                                         (char *)&tmp, sizeof(tmp) );
1533                                 if ( rc == AC_SOCKET_ERROR ) {
1534                                         int err = sock_errno();
1535 #ifdef NEW_LOGGING
1536                                         LDAP_LOG( CONNECTION, ERR,
1537                                                 "slapd_daemon_task: setsockopt( %ld, "
1538                                                 "TCP_NODELAY) failed errno=%d (%s)\n",
1539                                                 (long)s, err, sock_errstr(err) );
1540 #else
1541                                         Debug( LDAP_DEBUG_ANY,
1542                                                 "slapd(%ld): setsockopt(TCP_NODELAY) failed "
1543                                                 "errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
1544 #endif
1545                                 }
1546 #endif
1547                         }
1548 #endif
1549
1550 #ifdef NEW_LOGGING
1551                         LDAP_LOG( CONNECTION, DETAIL1,
1552                                 "slapd_daemon_task: new connection on %ld\n", (long)s, 0, 0 );
1553 #else
1554                         Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
1555                                 (long) s, 0, 0 );
1556 #endif
1557                         switch ( from.sa_addr.sa_family ) {
1558 #  ifdef LDAP_PF_LOCAL
1559                         case AF_LOCAL:
1560                                 sprintf( peername, "PATH=%s", from.sa_un_addr.sun_path );
1561                                 ssf = LDAP_PVT_SASL_LOCAL_SSF;
1562                                 {
1563                                         uid_t uid;
1564                                         gid_t gid;
1565
1566                                         if( getpeereid( s, &uid, &gid ) == 0 ) {
1567                                                 authid = ch_malloc(
1568                                                         sizeof("uidnumber=4294967295+gidnumber=4294967295,"
1569                                                                 "cn=peercred,cn=external,cn=auth"));
1570                                                 sprintf(authid, "uidnumber=%d+gidnumber=%d,"
1571                                                         "cn=peercred,cn=external,cn=auth",
1572                                                         (int) uid, (int) gid);
1573                                         }
1574                                 }
1575                                 dnsname = "local";
1576                                 break;
1577 #endif /* LDAP_PF_LOCAL */
1578
1579 #  ifdef LDAP_PF_INET6
1580                         case AF_INET6:
1581                         if ( IN6_IS_ADDR_V4MAPPED(&from.sa_in6_addr.sin6_addr) ) {
1582                                 peeraddr = inet_ntoa( *((struct in_addr *)
1583                                                         &from.sa_in6_addr.sin6_addr.s6_addr[12]) );
1584                                 sprintf( peername, "IP=%s:%d",
1585                                          peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
1586                                          (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
1587                         } else {
1588                                 char addr[INET6_ADDRSTRLEN];
1589
1590                                 peeraddr = (char *) inet_ntop( AF_INET6,
1591                                                       &from.sa_in6_addr.sin6_addr,
1592                                                       addr, sizeof addr );
1593                                 sprintf( peername, "IP=%s %d",
1594                                          peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
1595                                          (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
1596                         }
1597                         break;
1598 #  endif /* LDAP_PF_INET6 */
1599
1600                         case AF_INET:
1601                         peeraddr = inet_ntoa( from.sa_in_addr.sin_addr );
1602                         sprintf( peername, "IP=%s:%d",
1603                                 peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
1604                                 (unsigned) ntohs( from.sa_in_addr.sin_port ) );
1605                                 break;
1606
1607                         default:
1608                                 slapd_close(s);
1609                                 continue;
1610                         }
1611
1612                         if ( ( from.sa_addr.sa_family == AF_INET )
1613 #ifdef LDAP_PF_INET6
1614                                 || ( from.sa_addr.sa_family == AF_INET6 )
1615 #endif
1616                         ) {
1617 #ifdef SLAPD_RLOOKUPS
1618                                 if ( use_reverse_lookup ) {
1619                                         char *herr;
1620                                         if (ldap_pvt_get_hname( (const struct sockaddr *)&from, len, hbuf,
1621                                                 sizeof(hbuf), &herr ) == 0) {
1622                                                 ldap_pvt_str2lower( hbuf );
1623                                                 dnsname = hbuf;
1624                                         }
1625                                 }
1626 #else
1627                                 dnsname = NULL;
1628 #endif /* SLAPD_RLOOKUPS */
1629
1630 #ifdef HAVE_TCPD
1631                                 if ( !hosts_ctl("slapd",
1632                                                 dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
1633                                                 peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
1634                                                 SLAP_STRING_UNKNOWN ))
1635                                 {
1636                                         /* DENY ACCESS */
1637                                         Statslog( LDAP_DEBUG_STATS,
1638                                                 "fd=%ld DENIED from %s (%s)",
1639                                                 (long) s,
1640                                                 dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
1641                                                 peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
1642                                                 0, 0 );
1643                                         slapd_close(s);
1644                                         continue;
1645                                 }
1646 #endif /* HAVE_TCPD */
1647                         }
1648
1649                         id = connection_init(s,
1650                                 slap_listeners[l],
1651                                 dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
1652                                 peername,
1653 #ifdef HAVE_TLS
1654                                 slap_listeners[l]->sl_is_tls,
1655 #else
1656                                 0,
1657 #endif
1658                                 ssf,
1659                                 authid );
1660
1661                         if( authid ) ch_free(authid);
1662
1663                         if( id < 0 ) {
1664 #ifdef NEW_LOGGING
1665                                 LDAP_LOG( CONNECTION, INFO,
1666                                         "slapd_daemon_task: "
1667                                         "connection_init(%ld, %s, %s) "
1668                                         "failed.\n",
1669                                         (long)s, peername,
1670                                         slap_listeners[l]->sl_name.bv_val );
1671 #else
1672                                 Debug( LDAP_DEBUG_ANY,
1673                                         "daemon: connection_init(%ld, %s, %s) "
1674                                         "failed.\n",
1675                                         (long) s,
1676                                         peername,
1677                                         slap_listeners[l]->sl_name.bv_val );
1678 #endif
1679                                 slapd_close(s);
1680                                 continue;
1681                         }
1682
1683                         Statslog( LDAP_DEBUG_STATS,
1684                                 "conn=%ld fd=%ld ACCEPT from %s (%s)\n",
1685                                 id, (long) s,
1686                                 peername,
1687                                 slap_listeners[l]->sl_name.bv_val,
1688                                 0 );
1689
1690                         slapd_add( s );
1691                         continue;
1692                 }
1693
1694 #ifdef LDAP_DEBUG
1695 #ifdef NEW_LOGGING
1696                 LDAP_LOG( CONNECTION, DETAIL2,
1697                            "slapd_daemon_task: activity on ", 0, 0, 0 );
1698 #else
1699                 Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
1700 #endif
1701 #ifdef HAVE_WINSOCK
1702                 for ( i = 0; i < readfds.fd_count; i++ ) {
1703 #ifdef NEW_LOGGING
1704                         LDAP_LOG( CONNECTION, DETAIL2,
1705                                 " %d%s", readfds.fd_array[i], "r", 0, 0 );
1706 #else
1707                         Debug( LDAP_DEBUG_CONNS, " %d%s",
1708                                 readfds.fd_array[i], "r", 0 );
1709 #endif
1710                 }
1711                 for ( i = 0; i < writefds.fd_count; i++ ) {
1712 #ifdef NEW_LOGGING
1713                         LDAP_LOG( CONNECTION, DETAIL2,
1714                                 " %d%s", writefds.fd_array[i], "w" , 0 );
1715 #else
1716                         Debug( LDAP_DEBUG_CONNS, " %d%s",
1717                                 writefds.fd_array[i], "w", 0 );
1718 #endif
1719                 }
1720
1721 #else
1722                 for ( i = 0; i < nfds; i++ ) {
1723                         int     r, w;
1724                         int     is_listener = 0;
1725
1726                         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1727                                 if ( i == slap_listeners[l]->sl_sd ) {
1728 #ifdef LDAP_CONNECTIONLESS
1729                                 /* The listener is the data port. Don't
1730                                  * skip it.
1731                                  */
1732                                         if (slap_listeners[l]->sl_is_udp) continue;
1733 #endif
1734                                         is_listener = 1;
1735                                         break;
1736                                 }
1737                         }
1738                         if ( is_listener ) {
1739                                 continue;
1740                         }
1741                         r = FD_ISSET( i, &readfds );
1742                         w = FD_ISSET( i, &writefds );
1743                         if ( r || w ) {
1744 #ifdef NEW_LOGGING
1745                                 LDAP_LOG( CONNECTION, DETAIL2,
1746                                         " %d%s%s", i, r ? "r" : "", w ? "w" : "" );
1747 #else
1748                                 Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
1749                                     r ? "r" : "", w ? "w" : "" );
1750 #endif
1751                         }
1752                 }
1753 #endif
1754 #ifdef NEW_LOGGING
1755                 LDAP_LOG( CONNECTION, DETAIL2, "\n", 0, 0, 0 );
1756 #else
1757                 Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
1758 #endif
1759
1760 #endif
1761
1762                 /* loop through the writers */
1763 #ifdef HAVE_WINSOCK
1764                 for ( i = 0; i < writefds.fd_count; i++ )
1765 #else
1766                 for ( i = 0; i < nfds; i++ )
1767 #endif
1768                 {
1769                         ber_socket_t wd;
1770                         int is_listener = 0;
1771 #ifdef HAVE_WINSOCK
1772                         wd = writefds.fd_array[i];
1773 #else
1774                         if( ! FD_ISSET( i, &writefds ) ) {
1775                                 continue;
1776                         }
1777                         wd = i;
1778 #endif
1779
1780                         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1781                                 if ( i == slap_listeners[l]->sl_sd ) {
1782 #ifdef LDAP_CONNECTIONLESS
1783                                         if (slap_listeners[l]->sl_is_udp) continue;
1784 #endif
1785                                         is_listener = 1;
1786                                         break;
1787                                 }
1788                         }
1789                         if ( is_listener ) {
1790                                 continue;
1791                         }
1792 #ifdef NEW_LOGGING
1793                         LDAP_LOG( CONNECTION, DETAIL2,
1794                                 "slapd_daemon_task: write active on %d\n", wd, 0, 0 );
1795 #else
1796                         Debug( LDAP_DEBUG_CONNS,
1797                                 "daemon: write active on %d\n",
1798                                 wd, 0, 0 );
1799 #endif
1800                         /*
1801                          * NOTE: it is possible that the connection was closed
1802                          * and that the stream is now inactive.
1803                          * connection_write() must valid the stream is still
1804                          * active.
1805                          */
1806
1807                         if ( connection_write( wd ) < 0 ) {
1808                                 FD_CLR( (unsigned) wd, &readfds );
1809                                 slapd_close( wd );
1810                         }
1811                 }
1812
1813 #ifdef HAVE_WINSOCK
1814                 for ( i = 0; i < readfds.fd_count; i++ )
1815 #else
1816                 for ( i = 0; i < nfds; i++ )
1817 #endif
1818                 {
1819                         ber_socket_t rd;
1820                         int is_listener = 0;
1821
1822 #ifdef HAVE_WINSOCK
1823                         rd = readfds.fd_array[i];
1824 #else
1825                         if( ! FD_ISSET( i, &readfds ) ) {
1826                                 continue;
1827                         }
1828                         rd = i;
1829 #endif
1830
1831                         for ( l = 0; slap_listeners[l] != NULL; l++ ) {
1832                                 if ( rd == slap_listeners[l]->sl_sd ) {
1833 #ifdef LDAP_CONNECTIONLESS
1834                                         if (slap_listeners[l]->sl_is_udp) continue;
1835 #endif
1836                                         is_listener = 1;
1837                                         break;
1838                                 }
1839                         }
1840                         if ( is_listener ) {
1841                                 continue;
1842                         }
1843
1844 #ifdef NEW_LOGGING
1845                         LDAP_LOG( CONNECTION, DETAIL2,
1846                                 "slapd_daemon_task: read activity on %d\n", rd, 0, 0 );
1847 #else
1848                         Debug ( LDAP_DEBUG_CONNS,
1849                                 "daemon: read activity on %d\n", rd, 0, 0 );
1850 #endif
1851                         /*
1852                          * NOTE: it is possible that the connection was closed
1853                          * and that the stream is now inactive.
1854                          * connection_read() must valid the stream is still
1855                          * active.
1856                          */
1857
1858                         if ( connection_read( rd ) < 0 ) {
1859                                 slapd_close( rd );
1860                         }
1861                 }
1862                 ldap_pvt_thread_yield();
1863         }
1864
1865         if( slapd_shutdown == 1 ) {
1866 #ifdef NEW_LOGGING
1867                 LDAP_LOG( CONNECTION, CRIT,
1868                    "slapd_daemon_task: shutdown requested and initiated.\n", 0, 0, 0 );
1869 #else
1870                 Debug( LDAP_DEBUG_TRACE,
1871                         "daemon: shutdown requested and initiated.\n",
1872                         0, 0, 0 );
1873 #endif
1874
1875         } else if ( slapd_shutdown == 2 ) {
1876 #ifdef HAVE_NT_SERVICE_MANAGER
1877 #ifdef NEW_LOGGING
1878                         LDAP_LOG( CONNECTION, CRIT,
1879                            "slapd_daemon_task: shutdown initiated by Service Manager.\n",
1880                            0, 0, 0);
1881 #else
1882                         Debug( LDAP_DEBUG_TRACE,
1883                                "daemon: shutdown initiated by Service Manager.\n",
1884                                0, 0, 0);
1885 #endif
1886 #else /* !HAVE_NT_SERVICE_MANAGER */
1887 #ifdef NEW_LOGGING
1888                         LDAP_LOG( CONNECTION, CRIT,
1889                            "slapd_daemon_task: abnormal condition, "
1890                            "shutdown initiated.\n", 0, 0, 0 );
1891 #else
1892                         Debug( LDAP_DEBUG_TRACE,
1893                                "daemon: abnormal condition, shutdown initiated.\n",
1894                                0, 0, 0 );
1895 #endif
1896 #endif /* !HAVE_NT_SERVICE_MANAGER */
1897         } else {
1898 #ifdef NEW_LOGGING
1899                 LDAP_LOG( CONNECTION, CRIT,
1900                    "slapd_daemon_task: no active streams, shutdown initiated.\n",
1901                    0, 0, 0 );
1902 #else
1903                 Debug( LDAP_DEBUG_TRACE,
1904                        "daemon: no active streams, shutdown initiated.\n",
1905                        0, 0, 0 );
1906 #endif
1907         }
1908
1909         if( slapd_gentle_shutdown != 2 ) {
1910                 close_listeners ( 0 );
1911         }
1912
1913         free ( slap_listeners );
1914         slap_listeners = NULL;
1915
1916         if( !slapd_gentle_shutdown ) {
1917                 connections_shutdown();
1918         }
1919
1920 #ifdef NEW_LOGGING
1921         LDAP_LOG( CONNECTION, CRIT,
1922                 "slapd_daemon_task: shutdown waiting for %d threads to terminate.\n",
1923                 ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
1924 #else
1925         Debug( LDAP_DEBUG_ANY,
1926             "slapd shutdown: waiting for %d threads to terminate\n",
1927             ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
1928 #endif
1929         ldap_pvt_thread_pool_destroy(&connection_pool, 1);
1930
1931         return NULL;
1932 }
1933
1934
1935 int slapd_daemon( void )
1936 {
1937         int rc;
1938
1939         connections_init();
1940
1941 #define SLAPD_LISTENER_THREAD 1
1942 #if defined( SLAPD_LISTENER_THREAD )
1943         {
1944                 ldap_pvt_thread_t       listener_tid;
1945
1946                 /* listener as a separate THREAD */
1947                 rc = ldap_pvt_thread_create( &listener_tid,
1948                         0, slapd_daemon_task, NULL );
1949
1950                 if ( rc != 0 ) {
1951 #ifdef NEW_LOGGING
1952                         LDAP_LOG( CONNECTION, ERR,
1953                                 "slapd_daemon: listener ldap_pvt_thread_create failed (%d).\n",
1954                                 rc, 0, 0 );
1955 #else
1956                         Debug( LDAP_DEBUG_ANY,
1957                         "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
1958 #endif
1959                         return rc;
1960                 }
1961
1962                 /* wait for the listener thread to complete */
1963                 ldap_pvt_thread_join( listener_tid, (void *) NULL );
1964         }
1965 #else
1966         /* experimental code */
1967         slapd_daemon_task( NULL );
1968 #endif
1969
1970         return 0;
1971
1972 }
1973
1974 int sockinit(void)
1975 {
1976 #if defined( HAVE_WINSOCK2 )
1977     WORD wVersionRequested;
1978         WSADATA wsaData;
1979         int err;
1980
1981         wVersionRequested = MAKEWORD( 2, 0 );
1982
1983         err = WSAStartup( wVersionRequested, &wsaData );
1984         if ( err != 0 ) {
1985                 /* Tell the user that we couldn't find a usable */
1986                 /* WinSock DLL.                                  */
1987                 return -1;
1988         }
1989
1990         /* Confirm that the WinSock DLL supports 2.0.*/
1991         /* Note that if the DLL supports versions greater    */
1992         /* than 2.0 in addition to 2.0, it will still return */
1993         /* 2.0 in wVersion since that is the version we      */
1994         /* requested.                                        */
1995
1996         if ( LOBYTE( wsaData.wVersion ) != 2 ||
1997                 HIBYTE( wsaData.wVersion ) != 0 )
1998         {
1999             /* Tell the user that we couldn't find a usable */
2000             /* WinSock DLL.                                  */
2001             WSACleanup();
2002             return -1;
2003         }
2004
2005         /* The WinSock DLL is acceptable. Proceed. */
2006 #elif defined( HAVE_WINSOCK )
2007         WSADATA wsaData;
2008         if ( WSAStartup( 0x0101, &wsaData ) != 0 ) {
2009             return -1;
2010         }
2011 #endif
2012         return 0;
2013 }
2014
2015 int sockdestroy(void)
2016 {
2017 #if defined( HAVE_WINSOCK2 ) || defined( HAVE_WINSOCK )
2018         WSACleanup();
2019 #endif
2020         return 0;
2021 }
2022
2023 RETSIGTYPE
2024 slap_sig_shutdown( int sig )
2025 {
2026 #ifdef NEW_LOGGING
2027         LDAP_LOG( CONNECTION, CRIT,
2028                 "slap_sig_shutdown: signal %d\n", sig, 0, 0 );
2029 #else
2030         Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: signal %d\n", sig, 0, 0);
2031 #endif
2032
2033         /*
2034          * If the NT Service Manager is controlling the server, we don't
2035          * want SIGBREAK to kill the server. For some strange reason,
2036          * SIGBREAK is generated when a user logs out.
2037          */
2038
2039 #if HAVE_NT_SERVICE_MANAGER && SIGBREAK
2040         if (is_NT_Service && sig == SIGBREAK)
2041 #ifdef NEW_LOGGING
2042             LDAP_LOG( CONNECTION, CRIT,
2043                     "slap_sig_shutdown: SIGBREAK ignored.\n", 0, 0, 0 );
2044 #else
2045             Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: SIGBREAK ignored.\n",
2046                   0, 0, 0);
2047 #endif
2048         else
2049 #endif
2050 #ifdef SIGHUP
2051         if (sig == SIGHUP && global_gentlehup && slapd_gentle_shutdown == 0)
2052                 slapd_gentle_shutdown = 1;
2053         else
2054 #endif
2055         slapd_shutdown = 1;
2056
2057         WAKE_LISTENER(1);
2058
2059         /* reinstall self */
2060         (void) SIGNAL_REINSTALL( sig, slap_sig_shutdown );
2061 }
2062
2063 RETSIGTYPE
2064 slap_sig_wake( int sig )
2065 {
2066         WAKE_LISTENER(1);
2067
2068         /* reinstall self */
2069         (void) SIGNAL_REINSTALL( sig, slap_sig_wake );
2070 }
2071
2072
2073 void slapd_add_internal(ber_socket_t s) {
2074         slapd_add(s);
2075 }
2076
2077 Listener ** slapd_get_listeners(void) {
2078         return slap_listeners;
2079 }