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