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 "ldapconfig.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
  26 static ldap_pvt_thread_t        listener_tid;
  27 static volatile sig_atomic_t slapd_shutdown = 0;
  28
  29 struct slap_daemon {
  30         ldap_pvt_thread_mutex_t sd_mutex;
  31
  32         int sd_nactives;
  33
  34 #ifndef HAVE_WINSOCK
  35         /* In winsock, accept() returns values higher than dtblsize
  36                 so don't bother with this optimization */
  37         int sd_nfds;
  38 #endif
  39
  40         fd_set sd_actives;
  41         fd_set sd_readers;
  42         fd_set sd_writers;
  43 } slap_daemon;
  44
  45 /*
  46  * Add a descriptor to daemon control
  47  */
  48 static void slapd_add(int s) {
  49         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
  50
  51         assert( !FD_ISSET( s, &slap_daemon.sd_actives ));
  52         assert( !FD_ISSET( s, &slap_daemon.sd_readers ));
  53         assert( !FD_ISSET( s, &slap_daemon.sd_writers ));
  54
  55 #ifndef HAVE_WINSOCK
  56         if (s >= slap_daemon.sd_nfds) {
  57                 slap_daemon.sd_nfds = s + 1;
  58         }
  59 #endif
  60
  61         FD_SET( s, &slap_daemon.sd_actives );
  62         FD_SET( s, &slap_daemon.sd_readers );
  63
  64         Debug( LDAP_DEBUG_CONNS, "daemon: added %d%s%s\n", s,
  65             FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
  66                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
  67
  68         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
  69 }
  70
  71 /*
  72  * Remove the descriptor from daemon control
  73  */
  74 void slapd_remove(int s) {
  75         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
  76
  77         assert( FD_ISSET( s, &slap_daemon.sd_actives ));
  78
  79         Debug( LDAP_DEBUG_CONNS, "daemon: removing %d%s%s\n", s,
  80             FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
  81                 FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
  82
  83         FD_CLR( s, &slap_daemon.sd_actives );
  84         FD_CLR( s, &slap_daemon.sd_readers );
  85         FD_CLR( s, &slap_daemon.sd_writers );
  86
  87         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
  88 }
  89
  90 void slapd_clr_write(int s, int wake) {
  91         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
  92
  93         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
  94         FD_CLR( s, &slap_daemon.sd_writers );
  95
  96         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
  97
  98         if( wake ) {
  99                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 100         }
 101 }
 102
 103 void slapd_set_write(int s, int wake) {
 104         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 105
 106         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 107         FD_SET( s, &slap_daemon.sd_writers );
 108
 109         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 110
 111         if( wake ) {
 112                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 113         }
 114 }
 115
 116 void slapd_clr_read(int s, int wake) {
 117         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 118
 119         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 120         FD_CLR( s, &slap_daemon.sd_readers );
 121
 122         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 123
 124         if( wake ) {
 125                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 126         }
 127 }
 128
 129 void slapd_set_read(int s, int wake) {
 130         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 131
 132         assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 133         FD_SET( s, &slap_daemon.sd_readers );
 134
 135         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 136
 137         if( wake ) {
 138                 ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 139         }
 140 }
 141
 142 static void slapd_close(int s) {
 143         slapd_remove(s);
 144
 145         Debug( LDAP_DEBUG_CONNS, "daemon: closing %d\n", s, 0, 0 );
 146         tcp_close(s);
 147 }
 148
 149 static void *
 150 slapd_daemon_task(
 151         void *ptr
 152 )
 153 {
 154         struct sockaddr_in *addr = ptr;
 155         int     tcps = -1;
 156
 157 #ifdef HAVE_SYSCONF
 158         dtblsize = sysconf( _SC_OPEN_MAX );
 159 #elif HAVE_GETDTABLESIZE
 160         dtblsize = getdtablesize();
 161 #else
 162         dtblsize = FD_SETSIZE
 163 #endif
 164
 165 #ifdef FD_SETSIZE
 166         if(dtblsize > FD_SETSIZE) {
 167                 dtblsize = FD_SETSIZE;
 168         }
 169 #endif  /* !FD_SETSIZE */
 170
 171         connections_init();
 172
 173         ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
 174         FD_ZERO( &slap_daemon.sd_readers );
 175         FD_ZERO( &slap_daemon.sd_writers );
 176
 177         if( addr != NULL ) {
 178                 int     tmp;
 179
 180                 if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) {
 181                         Debug( LDAP_DEBUG_ANY,
 182                                 "daemon: socket() failed errno %d (%s)", errno,
 183                         errno > -1 && errno < sys_nerr ? sys_errlist[errno] :
 184                         "unknown", 0 );
 185                         exit( 1 );
 186                 }
 187
 188 #ifndef HAVE_WINSOCK
 189                 if ( tcps >= dtblsize ) {
 190                         Debug( LDAP_DEBUG_ANY,
 191                                 "daemon: listener descriptor %d is too great",
 192                                 tcps, dtblsize, 0 );
 193                         exit( 1 );
 194                 }
 195 #endif
 196
 197                 tmp = 1;
 198                 if ( setsockopt( tcps, SOL_SOCKET, SO_REUSEADDR,
 199                         (char *) &tmp, sizeof(tmp) ) == -1 )
 200                 {
 201                         Debug( LDAP_DEBUG_ANY,
 202                                 "slapd(%d): setsockopt() failed errno %d (%s)",
 203                         tcps, errno,
 204                                 errno > -1 && errno < sys_nerr
 205                                         ? sys_errlist[errno] : "unknown" );
 206
 207                         errno = 0;
 208                 }
 209
 210                 if ( bind( tcps, (struct sockaddr *) addr, sizeof(*addr) ) == -1 ) {
 211                         Debug( LDAP_DEBUG_ANY, "daemon: bind(%d) failed errno %d (%s)\n",
 212                         tcps, errno,
 213                                 errno > -1 && errno < sys_nerr
 214                                         ? sys_errlist[errno] : "unknown" );
 215                         exit( 1 );
 216                 }
 217
 218                 if ( listen( tcps, 5 ) == -1 ) {
 219                         Debug( LDAP_DEBUG_ANY,
 220                                 "daemon: listen(%d, 5) failed errno %d (%s)\n",
 221                             tcps, errno,
 222                                 errno > -1 && errno < sys_nerr
 223                                         ? sys_errlist[errno] : "unknown" );
 224                         exit( 1 );
 225                 }
 226
 227                 slapd_add( tcps );
 228
 229         } else {
 230                 if( connection_init( 0, NULL, NULL ) ) {
 231                         Debug( LDAP_DEBUG_ANY,
 232                                 "connection_init(%d) failed.\n",
 233                                 0, 0, 0 );
 234
 235                         exit( 1 );
 236                 }
 237
 238                 slapd_add( 0 );
 239         }
 240
 241         while ( !slapd_shutdown ) {
 242                 int i, ns, nfds;
 243
 244                 fd_set                  readfds;
 245                 fd_set                  writefds;
 246
 247                 struct sockaddr_in      from;
 248                 struct hostent          *hp;
 249                 struct timeval          zero;
 250                 struct timeval          *tvp;
 251
 252                 char    *client_name;
 253                 char    *client_addr;
 254
 255                 FD_ZERO( &writefds );
 256                 FD_ZERO( &readfds );
 257
 258                 zero.tv_sec = 0;
 259                 zero.tv_usec = 0;
 260
 261                 ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 262
 263 #ifdef FD_SET_MANUAL_COPY
 264                 for( s = 0; s < nfds; s++ ) {
 265                         if(FD_ISSET( &slap_sd_writers, s )) {
 266                                 FD_SET( &writefds, s );
 267                         }
 268                         if(FD_ISSET( &slap_sd_writers, s )) {
 269                                 FD_SET( &writefds, s );
 270                         }
 271                 }
 272 #else
 273                 memcpy( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
 274                 memcpy( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
 275 #endif
 276
 277                 FD_SET( tcps, &readfds );
 278
 279 #ifndef HAVE_WINSOCK
 280                 nfds = slap_daemon.sd_nfds;
 281 #else
 282                 nfds = dtblsize;
 283 #endif
 284
 285                 ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 286
 287                 ldap_pvt_thread_mutex_lock( &active_threads_mutex );
 288 #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
 289                 tvp = NULL;
 290 #else
 291                 tvp = active_threads ? &zero : NULL;
 292 #endif
 293
 294                 Debug( LDAP_DEBUG_CONNS,
 295                         "daemon: select: tcps=%d active_threads=%d tvp=%s\n",
 296                     tcps, active_threads,
 297                         tvp == NULL ? "NULL" : "zero" );
 298
 299
 300                 ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
 301
 302                 switch(ns = select( nfds, &readfds, &writefds, 0, tvp )) {
 303                 case -1:        /* failure - try again */
 304                         if( errno != EINTR ) {
 305                                 Debug( LDAP_DEBUG_CONNS,
 306                                         "daemon: select failed (%d): %s\n",
 307                                         errno,
 308                                         errno >= 0 && errno < sys_nerr
 309                                                 ? sys_errlist[errno] : "unknown",
 310                                         0 );
 311
 312                                 slapd_shutdown = -1;
 313                         }
 314                         errno = 0;
 315                         continue;
 316
 317                 case 0:         /* timeout - let threads run */
 318                         Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
 319                             0, 0, 0 );
 320                 ldap_pvt_thread_yield();
 321                         continue;
 322
 323                 default:        /* something happened - deal with it */
 324                         Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
 325                                 ns, 0, 0 );
 326                         /* FALL THRU */
 327                 }
 328
 329                 if ( FD_ISSET( tcps, &readfds ) ) {
 330                         int s;
 331                         int len = sizeof(from);
 332                         long id;
 333
 334                         if ( (s = accept( tcps,
 335                                 (struct sockaddr *) &from, &len )) == -1 )
 336                         {
 337                                 Debug( LDAP_DEBUG_ANY,
 338                                     "daemon: accept(%d) failed errno %d (%s)", errno,
 339                                     tcps, errno >= 0 && errno < sys_nerr ?
 340                                     sys_errlist[errno] : "unknown");
 341                                 continue;
 342                         }
 343
 344                         assert( !FD_ISSET( 0, &slap_daemon.sd_actives) );
 345                         assert( !FD_ISSET( 0, &slap_daemon.sd_readers) );
 346                         assert( !FD_ISSET( 0, &slap_daemon.sd_writers) );
 347
 348 #ifndef HAVE_WINSOCK
 349                         /* make sure descriptor number isn't too great */
 350                         if ( s >= dtblsize ) {
 351                                 Debug( LDAP_DEBUG_ANY,
 352                                         "daemon: %d beyond descriptor table size %d\n",
 353                                         s, dtblsize, 0 );
 354                                 tcp_close(s);
 355                                 continue;
 356                         }
 357 #endif
 358
 359                         Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %d\n",
 360                                 s, 0, 0 );
 361
 362                         len = sizeof(from);
 363                         if ( getpeername( s, (struct sockaddr *) &from, &len ) == 0 ) {
 364                                 client_addr = inet_ntoa( from.sin_addr );
 365
 366 #if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
 367                                 hp = gethostbyaddr( (char *)
 368                                     &(from.sin_addr.s_addr),
 369                                     sizeof(from.sin_addr.s_addr), AF_INET );
 370
 371                                 if(hp) {
 372                                         char *p;
 373                                         client_name = hp->h_name;
 374
 375                                         /* normalize the domain */
 376                                         for ( p = client_name; *p; p++ ) {
 377                                                 *p = TOLOWER( (unsigned char) *p );
 378                                         }
 379
 380                                 } else {
 381                                         client_name = NULL;
 382                                 }
 383 #else
 384                                 client_name = NULL;
 385 #endif
 386
 387                         } else {
 388                                 client_name = NULL;;
 389                                 client_addr = NULL;
 390                         }
 391
 392 #ifdef HAVE_TCPD
 393                         if(!hosts_ctl("slapd",
 394                                 client_name != NULL ? client_name : STRING_UNKNOWN,
 395                                 client_addr != NULL ? client_addr : STRING_UNKNOWN,
 396                                 STRING_UNKNOWN))
 397                         {
 398                                 /* DENY ACCESS */
 399                                 Statslog( LDAP_DEBUG_ANY,
 400                                  "fd=%d connection from %s (%s) denied.\n",
 401                                         s,
 402                                         client_name == NULL ? "unknown" : client_name,
 403                                         client_addr == NULL ? "unknown" : client_addr,
 404                                   0, 0 );
 405
 406                                 tcp_close(s);
 407                                 continue;
 408                         }
 409 #endif /* HAVE_TCPD */
 410
 411                         if( (id = connection_init(s, client_name, client_addr)) < 0 ) {
 412                                 Debug( LDAP_DEBUG_ANY,
 413                                         "daemon: connection_init(%d, %s, %s) failed.\n",
 414                                         s,
 415                                         client_name == NULL ? "unknown" : client_name,
 416                                         client_addr == NULL ? "unknown" : client_addr);
 417                                 tcp_close(s);
 418                                 continue;
 419                         }
 420
 421                         Statslog( LDAP_DEBUG_STATS,
 422                                 "daemon: conn=%d fd=%d connection from %s (%s) accepted.\n",
 423                                 id, s,
 424                                 client_name == NULL ? "unknown" : client_name,
 425                                 client_addr == NULL ? "unknown" : client_addr,
 426                                 0 );
 427
 428                         slapd_add( s );
 429                         continue;
 430                 }
 431
 432 #ifdef LDAP_DEBUG
 433                 Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
 434
 435                 for ( i = 0; i < nfds; i++ ) {
 436                         int     a, r, w;
 437
 438                         r = FD_ISSET( i, &readfds );
 439                         w = FD_ISSET( i, &writefds );
 440                         if ( i != tcps && (r || w) ) {
 441                                 Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
 442                                     r ? "r" : "", w ? "w" : "" );
 443                         }
 444                 }
 445
 446                 Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
 447 #endif
 448
 449                 /* loop through the writers */
 450                 for ( i = 0; i < nfds; i++ ) {
 451                         if ( i == tcps ) {
 452                                 continue;
 453                         }
 454
 455                         if ( FD_ISSET( i, &writefds ) ) {
 456                                 Debug( LDAP_DEBUG_CONNS,
 457                                     "daemon: signaling write waiter on %d\n", i, 0, 0 );
 458
 459                                 assert( FD_ISSET( 0, &slap_daemon.sd_actives) );
 460
 461                                 /* clear the write flag */
 462                                 slapd_clr_write( i, 0 );
 463
 464                                 if( connection_write( i ) < 0 ) {
 465                                         FD_CLR( i, &readfds );
 466                                         slapd_close( i );
 467                                 }
 468                         }
 469                 }
 470
 471                 for ( i = 0; i < nfds; i++ ) {
 472                         if ( i == tcps ) {
 473                                 continue;
 474                         }
 475
 476                         if ( FD_ISSET( i, &readfds ) ) {
 477                                 Debug( LDAP_DEBUG_CONNS,
 478                                     "daemon: read activity on %d\n", i, 0, 0 );
 479
 480                                 assert( FD_ISSET( i, &slap_daemon.sd_actives) );
 481
 482                                 if( connection_read( i ) < 0) {
 483                                         slapd_close( i );
 484                                 }
 485                         }
 486                 }
 487
 488                 ldap_pvt_thread_yield();
 489         }
 490
 491         if( slapd_shutdown > 0 ) {
 492                 Debug( LDAP_DEBUG_TRACE,
 493                         "daemon: shutdown requested and initiated.\n",
 494                         0, 0, 0 );
 495
 496         } else if ( slapd_shutdown < 0 ) {
 497                 Debug( LDAP_DEBUG_TRACE,
 498                         "daemon: abnormal condition, shutdown initiated.\n",
 499                         0, 0, 0 );
 500         } else {
 501                 Debug( LDAP_DEBUG_TRACE,
 502                         "daemon: no active streams, shutdown initiated.\n",
 503                         0, 0, 0 );
 504         }
 505
 506         if( tcps >= 0 ) {
 507                 tcp_close( tcps );
 508         }
 509
 510         ldap_pvt_thread_mutex_lock( &active_threads_mutex );
 511         Debug( LDAP_DEBUG_ANY,
 512             "slapd shutdown: waiting for %d threads to terminate\n",
 513             active_threads, 0, 0 );
 514         while ( active_threads > 0 ) {
 515                 ldap_pvt_thread_cond_wait(&active_threads_cond, &active_threads_mutex);
 516         }
 517         ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
 518
 519         return NULL;
 520 }
 521
 522 int slapd_daemon( struct sockaddr_in *addr )
 523 {
 524         int status;
 525
 526         status = ldap_pvt_thread_create( &listener_tid, 0,
 527                  slapd_daemon_task, addr );
 528
 529         if ( status != 0 ) {
 530                 Debug( LDAP_DEBUG_ANY,
 531                     "listener ldap_pvt_thread_create failed (%d)\n", status, 0, 0 );
 532                 return -1;
 533         } else {
 534                 /* wait for the listener thread to complete */
 535                 ldap_pvt_thread_join( listener_tid, (void *) NULL );
 536         }
 537
 538         return 0;
 539 }
 540
 541 void
 542 slap_set_shutdown( int sig )
 543 {
 544         slapd_shutdown = 1;
 545         ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
 546
 547         /* reinstall self */
 548         (void) SIGNAL( sig, slap_set_shutdown );
 549 }
 550
 551 void
 552 slap_do_nothing( int sig )
 553 {
 554         /* reinstall self */
 555         (void) SIGNAL( sig, slap_do_nothing );
 556 }