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 int dtblsize;
  25 static int tcps;
  26
  27 #ifdef HAVE_WINSOCK2
  28 /* in nt_main.c */
  29 extern ldap_pvt_thread_cond_t                   started_event;
  30 /* forward reference */
  31 void hit_socket();
  32 /* In wsa_err.c */
  33 char *WSAGetLastErrorString();
  34 static ldap_pvt_thread_t hit_tid;
  35
  36 #define WAKE_LISTENER(w) \
  37 do {\
  38     if( w ) {\
  39         ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );\
  40         hit_socket(); \
  41     }\
  42 } while(0)
  43 #else
  44 #define WAKE_LISTENER(w) \
  45 do {\
  46     if( w ) {\
  47         ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );\
  48     }\
  49 } while(0)
  50 #endif
  51
  52 #ifndef HAVE_WINSOCK
  53 static
  54 #endif
  55 volatile sig_atomic_t slapd_shutdown = 0;
  56
  57 static int daemon_initialized = 0;
  58 static ldap_pvt_thread_t        listener_tid;
  59 static volatile sig_atomic_t slapd_listener = 0;
  60 void sockinit();
  61
  62 struct slap_daemon {
  63         ldap_pvt_thread_mutex_t sd_mutex;
  64
  65         int sd_nactives;
  66
  67 #ifndef HAVE_WINSOCK
  68         /* In winsock, accept() returns values higher than dtblsize
  69                 so don't bother with this optimization */
  70         int sd_nfds;
  71 #endif
  72
  73         fd_set sd_actives;
  74         fd_set sd_readers;
  75         fd_set sd_writers;
  76 } slap_daemon;
  77
  78 /*
  79  * Add a descriptor to daemon control
  80  */
  81 static void slapd_add(int s) {
  82         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
  83
  84         assert( !FD_ISSET( s, &slap_daemon.sd_actives ));
  85         assert( !FD_ISSET( s, &slap_daemon.sd_readers ));
  86         assert( !FD_ISSET( s, &slap_daemon.sd_writers ));
  87
  88 #ifndef HAVE_WINSOCK
  89         if (s >= slap_daemon.sd_nfds) {
  90                 slap_daemon.sd_nfds = s + 1;
  91         }
  92 #endif
  93
  94         FD_SET( (unsigned) s, &slap_daemon.sd_actives );
  95         FD_SET( (unsigned) s, &slap_daemon.sd_readers );
  96
  97         Debug( LDAP_DEBUG_CONNS, "daemon: added %d%s%s\n", s,
  98             FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
  99                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
 100
 101         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 102 }
 103
 104 /*
 105  * Remove the descriptor from daemon control
 106  */
 107 void slapd_remove(int s, int wake) {
 108         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 109         WAKE_LISTENER(wake);
 110
 111         Debug( LDAP_DEBUG_CONNS, "daemon: removing %d%s%s\n", s,
 112             FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 113                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
 114
 115         FD_CLR( (unsigned) s, &slap_daemon.sd_actives );
 116         FD_CLR( (unsigned) s, &slap_daemon.sd_readers );
 117         FD_CLR( (unsigned) s, &slap_daemon.sd_writers );
 118
 119         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 120 }
 121
 122 void slapd_clr_write(int s, int wake) {
 123         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 124         WAKE_LISTENER(wake);
 125
 126         assert( FD_ISSET( (unsigned) s, &slap_daemon.sd_actives) );
 127         FD_CLR( (unsigned) s, &slap_daemon.sd_writers );
 128
 129         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 130
 131         if( wake ) {
 132                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 133         }
 134 }
 135
 136 void slapd_set_write(int s, int wake) {
 137         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 138     WAKE_LISTENER(wake);
 139
 140         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 141         FD_SET( (unsigned) s, &slap_daemon.sd_writers );
 142
 143         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 144
 145         if( wake ) {
 146                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 147         }
 148 }
 149
 150 void slapd_clr_read(int s, int wake) {
 151         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 152     WAKE_LISTENER(wake);
 153
 154         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 155         FD_CLR( (unsigned) s, &slap_daemon.sd_readers );
 156
 157         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 158
 159         if( wake ) {
 160                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 161         }
 162 }
 163
 164 void slapd_set_read(int s, int wake) {
 165         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 166     WAKE_LISTENER(wake);
 167
 168         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 169         FD_SET( (unsigned) s, &slap_daemon.sd_readers );
 170
 171         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 172
 173         if( wake ) {
 174                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 175         }
 176 }
 177
 178 static void slapd_close(int s) {
 179         Debug( LDAP_DEBUG_CONNS, "daemon: closing %d\n", s, 0, 0 );
 180         tcp_close(s);
 181 }
 182
 183
 184
 185 int
 186 set_socket( struct sockaddr_in *addr )
 187 {
 188         int     tcps = -1;
 189     if ( !daemon_initialized ) sockinit();
 190
 191 #ifdef HAVE_SYSCONF
 192         dtblsize = sysconf( _SC_OPEN_MAX );
 193 #elif HAVE_GETDTABLESIZE
 194         dtblsize = getdtablesize();
 195 #else
 196         dtblsize = FD_SETSIZE;
 197 #endif
 198
 199 #ifdef FD_SETSIZE
 200         if(dtblsize > FD_SETSIZE) {
 201                 dtblsize = FD_SETSIZE;
 202         }
 203 #endif  /* !FD_SETSIZE */
 204
 205         if( addr != NULL ) {
 206                 int     tmp;
 207
 208                 if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) {
 209 #ifndef HAVE_WINSOCK
 210                         int err = errno;
 211                         Debug( LDAP_DEBUG_ANY,
 212                                 "daemon: socket() failed errno %d (%s)\n", err,
 213                         err > -1 && err < sys_nerr ? sys_errlist[err] :
 214                         "unknown", 0 );
 215 #else
 216                         Debug( LDAP_DEBUG_ANY,
 217                                 "daemon: socket() failed errno %d (%s)\n",
 218                                 WSAGetLastError(),
 219                         WSAGetLastErrorString(), 0 );
 220 #endif
 221                         return( -1 );
 222                 }
 223
 224 #ifndef HAVE_WINSOCK
 225                 if ( tcps >= dtblsize ) {
 226                         Debug( LDAP_DEBUG_ANY,
 227                                 "daemon: listener descriptor %d is too great\n",
 228                                 tcps, dtblsize, 0 );
 229                         return -1;
 230                 }
 231 #endif
 232
 233 #ifdef SO_REUSEADDR
 234                 tmp = 1;
 235                 if ( setsockopt( tcps, SOL_SOCKET, SO_REUSEADDR,
 236                         (char *) &tmp, sizeof(tmp) ) == -1 )
 237                 {
 238                         int err = errno;
 239                         Debug( LDAP_DEBUG_ANY,
 240                                "slapd(%d): setsockopt() failed errno %d (%s)\n",
 241                         tcps, err,
 242                                 err > -1 && err < sys_nerr
 243                                         ? sys_errlist[err] : "unknown" );
 244                 }
 245 #endif
 246 #ifdef SO_KEEPALIVE
 247                 tmp = 1;
 248                 if ( setsockopt( tcps, SOL_SOCKET, SO_KEEPALIVE,
 249                         (char *) &tmp, sizeof(tmp) ) == -1 )
 250                 {
 251                         int err = errno;
 252                         Debug( LDAP_DEBUG_ANY,
 253                                 "slapd(%d): setsockopt(KEEPALIVE) failed errno %d (%s)\n",
 254                         tcps, err,
 255                                 err > -1 && err < sys_nerr
 256                                         ? sys_errlist[err] : "unknown" );
 257                 }
 258 #endif
 259
 260
 261                 if ( bind( tcps, (struct sockaddr *) addr, sizeof(*addr) ) == -1 ) {
 262                         int err = errno;
 263                         Debug( LDAP_DEBUG_ANY, "daemon: bind(%d) failed errno %d (%s)\n",
 264                         tcps, err,
 265                                 err > -1 && err < sys_nerr
 266                                         ? sys_errlist[err] : "unknown" );
 267                         return -1;
 268                 }
 269         }
 270
 271         return tcps;
 272 }
 273
 274 static void *
 275 slapd_daemon_task(
 276         void *ptr
 277 )
 278 {
 279         int inetd;
 280         struct slapd_args *args = (struct slapd_args *) ptr;
 281         struct sockaddr_in *slapd_addr = args->addr;
 282
 283         tcps  = args->tcps;
 284         /*free( ptr );  This seems to be wrong unless I hosed something */
 285
 286         inetd = ( slapd_addr == NULL);
 287     if ( !daemon_initialized ) sockinit();
 288
 289         slapd_listener=1;
 290
 291         ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
 292         FD_ZERO( &slap_daemon.sd_readers );
 293         FD_ZERO( &slap_daemon.sd_writers );
 294
 295         if( !inetd ) {
 296                 if ( listen( tcps, 5 ) == -1 ) {
 297                         int err = errno;
 298                         Debug( LDAP_DEBUG_ANY,
 299                                 "daemon: listen(%d, 5) failed errno %d (%s)\n",
 300                             tcps, err,
 301                                 err > -1 && err < sys_nerr
 302                                         ? sys_errlist[err] : "unknown" );
 303                         return( (void*)-1 );
 304                 }
 305
 306                 slapd_add( tcps );
 307
 308         } else {
 309                 if( connection_init( 0, NULL, NULL ) ) {
 310                         Debug( LDAP_DEBUG_ANY,
 311                                 "connection_init(%d) failed.\n",
 312                                 0, 0, 0 );
 313                         return( (void*)-1 );
 314                 }
 315
 316                 slapd_add( 0 );
 317         }
 318
 319 #ifdef HAVE_WINSOCK
 320         if ( started_event != NULL )
 321                 ldap_pvt_thread_cond_signal( &started_event );
 322 #endif
 323         /* initialization complete. Here comes the loop. */
 324         while ( !slapd_shutdown ) {
 325                 unsigned int i;
 326                 int ns, nfds;
 327                 int ebadf = 0;
 328 #define SLAPD_EBADF_LIMIT 10
 329
 330                 fd_set                  readfds;
 331                 fd_set                  writefds;
 332
 333                 struct sockaddr_in      from;
 334 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
 335         struct hostent          *hp;
 336 #endif
 337                 struct timeval          zero;
 338                 struct timeval          *tvp;
 339
 340                 char    *client_name;
 341                 char    *client_addr;
 342
 343                 FD_ZERO( &writefds );
 344                 FD_ZERO( &readfds );
 345
 346                 zero.tv_sec = 0;
 347                 zero.tv_usec = 0;
 348
 349                 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 350
 351 #ifdef FD_SET_MANUAL_COPY
 352                 for( s = 0; s < nfds; s++ ) {
 353                         if(FD_ISSET( &slap_sd_writers, s )) {
 354                                 FD_SET( &writefds, s );
 355                         }
 356                         if(FD_ISSET( &slap_sd_writers, s )) {
 357                                 FD_SET( &writefds, s );
 358                         }
 359                 }
 360 #else
 361                 memcpy( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
 362                 memcpy( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
 363 #endif
 364
 365                 FD_SET( (unsigned) tcps, &readfds );
 366
 367 #ifndef HAVE_WINSOCK
 368                 nfds = slap_daemon.sd_nfds;
 369 #else
 370                 nfds = dtblsize;
 371 #endif
 372
 373                 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 374
 375                 ldap_pvt_thread_mutex_lock( &active_threads_mutex );
 376 #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
 377                 tvp = NULL;
 378 #else
 379                 tvp = active_threads ? &zero : NULL;
 380 #endif
 381
 382                 Debug( LDAP_DEBUG_CONNS,
 383                         "daemon: select: tcps=%d active_threads=%d tvp=%s\n",
 384                     tcps, active_threads,
 385                         tvp == NULL ? "NULL" : "zero" );
 386
 387
 388                 ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
 389
 390                 switch(ns = select( nfds, &readfds, &writefds, 0, tvp )) {
 391                 case -1: {      /* failure - try again */
 392 #ifdef HAVE_WINSOCK
 393                                 int err = WSAGetLastError();
 394 #else
 395                                 int err = errno;
 396 #endif
 397
 398                                 if( err == EBADF && ++ebadf < SLAPD_EBADF_LIMIT) {
 399                                         continue;
 400                                 }
 401
 402                                 if( err != EINTR ) {
 403                                         Debug( LDAP_DEBUG_CONNS,
 404                                                 "daemon: select failed (%d): %s\n",
 405                                                 err,
 406                                                 err >= 0 && err < sys_nerr
 407                                                         ? sys_errlist[err] : "unknown",
 408                                                 0 );
 409
 410
 411                                 slapd_shutdown = -1;
 412                                 }
 413                         }
 414                         continue;
 415
 416                 case 0:         /* timeout - let threads run */
 417                         ebadf = 0;
 418                         Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
 419                             0, 0, 0 );
 420                 ldap_pvt_thread_yield();
 421                         continue;
 422
 423                 default:        /* something happened - deal with it */
 424                         ebadf = 0;
 425                         Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
 426                                 ns, 0, 0 );
 427                         /* FALL THRU */
 428                 }
 429
 430                 if ( FD_ISSET( tcps, &readfds ) ) {
 431                         int s;
 432                         int len = sizeof(from);
 433                         long id;
 434
 435                         if ( (s = accept( tcps,
 436                                 (struct sockaddr *) &from, &len )) == -1 )
 437                         {
 438                                 int err = errno;
 439                                 Debug( LDAP_DEBUG_ANY,
 440                                     "daemon: accept(%d) failed errno %d (%s)\n", err,
 441                                     tcps, err >= 0 && err < sys_nerr ?
 442                                     sys_errlist[err] : "unknown");
 443                                 continue;
 444                         }
 445
 446 #ifdef LDAP_DEBUG
 447                         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 448
 449                         /* newly accepted stream should not be in any of the FD SETS */
 450
 451                         assert( !FD_ISSET( s, &slap_daemon.sd_actives) );
 452                         assert( !FD_ISSET( s, &slap_daemon.sd_readers) );
 453                         assert( !FD_ISSET( s, &slap_daemon.sd_writers) );
 454
 455                         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 456 #endif
 457
 458 #ifndef HAVE_WINSOCK
 459                         /* make sure descriptor number isn't too great */
 460                         if ( s >= dtblsize ) {
 461                                 Debug( LDAP_DEBUG_ANY,
 462                                         "daemon: %d beyond descriptor table size %d\n",
 463                                         s, dtblsize, 0 );
 464                                 slapd_close(s);
 465                                 continue;
 466                         }
 467 #endif
 468
 469                         Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %d\n",
 470                                 s, 0, 0 );
 471
 472                         len = sizeof(from);
 473                         if ( getpeername( s, (struct sockaddr *) &from, &len ) == 0 ) {
 474                                 client_addr = inet_ntoa( from.sin_addr );
 475
 476 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
 477                                 hp = gethostbyaddr( (char *)
 478                                     &(from.sin_addr.s_addr),
 479                                     sizeof(from.sin_addr.s_addr), AF_INET );
 480
 481                                 if(hp) {
 482                                         char *p;
 483                                         client_name = hp->h_name;
 484
 485                                         /* normalize the domain */
 486                                         for ( p = client_name; *p; p++ ) {
 487                                                 *p = TOLOWER( (unsigned char) *p );
 488                                         }
 489
 490                                 } else {
 491                                         client_name = NULL;
 492                                 }
 493 #else
 494                                 client_name = NULL;
 495 #endif
 496
 497                         } else {
 498                                 client_name = NULL;;
 499                                 client_addr = NULL;
 500                         }
 501
 502 #ifdef HAVE_TCPD
 503                         if(!hosts_ctl("slapd",
 504                                 client_name != NULL ? client_name : STRING_UNKNOWN,
 505                                 client_addr != NULL ? client_addr : STRING_UNKNOWN,
 506                                 STRING_UNKNOWN))
 507                         {
 508                                 /* DENY ACCESS */
 509                                 Statslog( LDAP_DEBUG_ANY,
 510                                  "fd=%d connection from %s (%s) denied.\n",
 511                                         s,
 512                                         client_name == NULL ? "unknown" : client_name,
 513                                         client_addr == NULL ? "unknown" : client_addr,
 514                                   0, 0 );
 515
 516                                 slapd_close(s);
 517                                 continue;
 518                         }
 519 #endif /* HAVE_TCPD */
 520
 521                         if( (id = connection_init(s, client_name, client_addr)) < 0 ) {
 522                                 Debug( LDAP_DEBUG_ANY,
 523                                         "daemon: connection_init(%d, %s, %s) failed.\n",
 524                                         s,
 525                                         client_name == NULL ? "unknown" : client_name,
 526                                         client_addr == NULL ? "unknown" : client_addr);
 527                                 slapd_close(s);
 528                                 continue;
 529                         }
 530
 531                         Statslog( LDAP_DEBUG_STATS,
 532                                 "daemon: conn=%d fd=%d connection from %s (%s) accepted.\n",
 533                                 id, s,
 534                                 client_name == NULL ? "unknown" : client_name,
 535                                 client_addr == NULL ? "unknown" : client_addr,
 536                                 0 );
 537
 538                         slapd_add( s );
 539                         continue;
 540                 }
 541
 542 #ifdef LDAP_DEBUG
 543                 Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
 544 #ifdef HAVE_WINSOCK
 545                 for ( i = 0; i < readfds.fd_count; i++ ) {
 546                         Debug( LDAP_DEBUG_CONNS, " %d%s", readfds.fd_array[i], "r" );
 547                 }
 548                 for ( i = 0; i < writefds.fd_count; i++ ) {
 549                         Debug( LDAP_DEBUG_CONNS, " %d%s", writefds.fd_array[i], "w" );
 550                 }
 551 #else
 552                 for ( i = 0; i < nfds; i++ ) {
 553                         int     a, r, w;
 554
 555                         r = FD_ISSET( i, &readfds );
 556                         w = FD_ISSET( i, &writefds );
 557                         if ( i != tcps && (r || w) ) {
 558                                 Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
 559                                     r ? "r" : "", w ? "w" : "" );
 560                         }
 561                 }
 562 #endif
 563                 Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
 564 #endif
 565
 566                 /* loop through the writers */
 567 #ifdef HAVE_WINSOCK
 568                 for ( i = 0; i < writefds.fd_count; i++ )
 569 #else
 570                 for ( i = 0; i < nfds; i++ )
 571 #endif
 572                 {
 573                         int wd;
 574
 575 #ifdef HAVE_WINSOCK
 576                         wd = writefds.fd_array[i];
 577 #else
 578                         if( ! FD_ISSET( i, &writefds ) ) {
 579                                 continue;
 580                         }
 581                         wd = i;
 582 #endif
 583
 584                         if ( wd == tcps ) {
 585                                 continue;
 586                         }
 587                         Debug( LDAP_DEBUG_CONNS,
 588                                 "daemon: write active on %d\n",
 589                                 wd, 0, 0 );
 590
 591                         /*
 592                          * NOTE: it is possible that the connection was closed
 593                          * and that the stream is now inactive.
 594                          * connection_write() must valid the stream is still
 595                          * active.
 596                          */
 597
 598                         if ( connection_write( wd ) < 0 ) {
 599                                 FD_CLR( (unsigned) wd, &readfds );
 600                                 slapd_close( wd );
 601                         }
 602                 }
 603
 604 #ifdef HAVE_WINSOCK
 605                 for ( i = 0; i < readfds.fd_count; i++ )
 606 #else
 607                 for ( i = 0; i < nfds; i++ )
 608 #endif
 609                 {
 610                         int rd;
 611
 612 #ifdef HAVE_WINSOCK
 613                         rd = readfds.fd_array[i];
 614 #else
 615                         if( ! FD_ISSET( i, &readfds ) ) {
 616                                 continue;
 617                         }
 618                         rd = i;
 619 #endif
 620
 621                         if ( rd == tcps ) {
 622                                 continue;
 623                         }
 624
 625                         Debug ( LDAP_DEBUG_CONNS,
 626                                 "daemon: read activity on %d\n", rd, 0, 0 );
 627
 628                         /*
 629                          * NOTE: it is possible that the connection was closed
 630                          * and that the stream is now inactive.
 631                          * connection_read() must valid the stream is still
 632                          * active.
 633                          */
 634
 635                         if ( connection_read( rd ) < 0 ) {
 636                                 slapd_close( rd );
 637                         }
 638                 }
 639                 ldap_pvt_thread_yield();
 640         }
 641
 642         if( slapd_shutdown > 0 ) {
 643                 Debug( LDAP_DEBUG_TRACE,
 644                         "daemon: shutdown requested and initiated.\n",
 645                         0, 0, 0 );
 646
 647         } else if ( slapd_shutdown < 0 ) {
 648                 Debug( LDAP_DEBUG_TRACE,
 649                         "daemon: abnormal condition, shutdown initiated.\n",
 650                         0, 0, 0 );
 651         } else {
 652                 Debug( LDAP_DEBUG_TRACE,
 653                         "daemon: no active streams, shutdown initiated.\n",
 654                         0, 0, 0 );
 655         }
 656
 657         if( tcps >= 0 ) {
 658                 slapd_close( tcps );
 659         }
 660
 661         ldap_pvt_thread_mutex_lock( &active_threads_mutex );
 662         Debug( LDAP_DEBUG_ANY,
 663             "slapd shutdown: waiting for %d threads to terminate\n",
 664             active_threads, 0, 0 );
 665         while ( active_threads > 0 ) {
 666                 ldap_pvt_thread_cond_wait(&active_threads_cond, &active_threads_mutex);
 667         }
 668         ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
 669
 670         return NULL;
 671 }
 672
 673
 674 int slapd_daemon( struct slapd_args *args )
 675 {
 676         int rc;
 677
 678     if ( !daemon_initialized ) sockinit();
 679
 680         connections_init();
 681
 682 #define SLAPD_LISTENER_THREAD 1
 683 #if defined( SLAPD_LISTENER_THREAD ) || !defined(HAVE_PTHREADS)
 684
 685         /* listener as a separate THREAD */
 686         rc = ldap_pvt_thread_create( &listener_tid,
 687                 0, slapd_daemon_task, args );
 688
 689         if ( rc != 0 ) {
 690                 Debug( LDAP_DEBUG_ANY,
 691                     "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
 692                 goto destory;
 693         }
 694
 695         /* wait for the listener thread to complete */
 696         ldap_pvt_thread_join( listener_tid, (void *) NULL );
 697 #else
 698         /* expermimental code */
 699         listener_tid = pthread_self();
 700         slapd_daemon_task( args );
 701 #endif
 702
 703         rc = 0;
 704
 705 destory:
 706         connections_destroy();
 707
 708 #ifdef HAVE_WINSOCK
 709     WSACleanup( );
 710 #endif
 711
 712         return rc;
 713 }
 714
 715 #ifdef HAVE_WINSOCK2
 716 void sockinit()
 717 {
 718     WORD wVersionRequested;
 719         WSADATA wsaData;
 720         int err;
 721
 722         wVersionRequested = MAKEWORD( 2, 0 );
 723
 724         err = WSAStartup( wVersionRequested, &wsaData );
 725         if ( err != 0 ) {
 726                 /* Tell the user that we couldn't find a usable */
 727                 /* WinSock DLL.                                  */
 728                 return;
 729         }
 730
 731         /* Confirm that the WinSock DLL supports 2.0.*/
 732         /* Note that if the DLL supports versions greater    */
 733         /* than 2.0 in addition to 2.0, it will still return */
 734         /* 2.0 in wVersion since that is the version we      */
 735         /* requested.                                        */
 736
 737         if ( LOBYTE( wsaData.wVersion ) != 2 ||
 738                 HIBYTE( wsaData.wVersion ) != 0 )
 739         {
 740             /* Tell the user that we couldn't find a usable */
 741             /* WinSock DLL.                                  */
 742             WSACleanup( );
 743             return;
 744         }
 745     daemon_initialized = 1;
 746 }       /* The WinSock DLL is acceptable. Proceed. */
 747
 748 void hit_socket()
 749 {
 750         int s, on = 1;
 751         extern struct sockaddr_in       bind_addr;
 752
 753         /* throw something at the socket to terminate the select() in the daemon thread. */
 754         if (( s = socket( AF_INET, SOCK_STREAM, 0 )) == INVALID_SOCKET )
 755                 Debug( LDAP_DEBUG_ANY,
 756                         "slap_set_shutdown: socket failed\n\tWSAGetLastError=%d (%s)\n",
 757                         WSAGetLastError(), WSAGetLastErrorString(), 0 );
 758
 759         if ( ioctlsocket( s, FIONBIO, &on ) == -1 )
 760                 Debug( LDAP_DEBUG_ANY,
 761                         "slap_set_shutdown:FIONBIO ioctl on %d faled\n\tWSAGetLastError=%d (%s)\n",
 762                         s, WSAGetLastError(), WSAGetLastError() );
 763
 764         bind_addr.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
 765
 766         if ( connect( s, (struct sockaddr *)&bind_addr, sizeof( struct sockaddr_in )) == SOCKET_ERROR ) {
 767                 Debug( LDAP_DEBUG_ANY,
 768                         "hit_socket: error on connect: %d\n", WSAGetLastError(), 0 );
 769                 /* we can probably expect some error to occur here, mostly WSAEWOULDBLOCK */
 770         }
 771
 772         tcp_close(s);
 773 }
 774
 775 #elif HAVE_WINSOCK
 776 void sockinit()
 777 {       WSADATA wsaData;
 778         if ( WSAStartup( 0x0101, &wsaData ) != 0 ) {
 779             return( NULL );
 780         }
 781     daemon_initialized = 1;
 782 }
 783 #else
 784 void sockinit()
 785 {
 786     daemon_initialized = 1;
 787     return;
 788 }
 789 #endif
 790
 791 void
 792 slap_set_shutdown( int sig )
 793 {
 794         slapd_shutdown = sig;
 795 #ifndef HAVE_WINSOCK
 796         if(slapd_listener) {
 797                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 798         }
 799 #else
 800         Debug( LDAP_DEBUG_TRACE, "Shutdown %d ordered", sig, 0 );
 801         /* trying to "hit" the socket seems to always get a */
 802         /* EWOULDBLOCK error, so just close the listen socket to */
 803         /* break out of the select since we're shutting down anyway */
 804         tcp_close( tcps );
 805 #endif
 806         /* reinstall self */
 807         (void) SIGNAL( sig, slap_set_shutdown );
 808 }
 809
 810 void
 811 slap_do_nothing( int sig )
 812 {
 813         /* reinstall self */
 814         (void) SIGNAL( sig, slap_do_nothing );
 815 }