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

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