Diff for /servers/slapd/daemon.c between versions 1.211 and 1.211.2.11

version 1.211, 2002/01/28 19:26:55 version 1.211.2.11, 2002/10/10 01:40:36
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/daemon.c,v 1.210 2002/01/28 16:57:53 ando Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/daemon.c,v 1.211.2.10 2002/09/24 00:07:09 kurt Exp $ */
 /*  /*
  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.   * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
Line 10 Line 10
   
 #include <ac/ctype.h>  #include <ac/ctype.h>
 #include <ac/errno.h>  #include <ac/errno.h>
 #include <ac/signal.h>  
 #include <ac/socket.h>  #include <ac/socket.h>
 #include <ac/string.h>  #include <ac/string.h>
 #include <ac/time.h>  #include <ac/time.h>
Line 34  int deny_severity = LOG_NOTICE; Line 33  int deny_severity = LOG_NOTICE;
 #define LDAPI_MOD_URLEXT                "x-mod"  #define LDAPI_MOD_URLEXT                "x-mod"
 #endif /* LDAP_PF_LOCAL */  #endif /* LDAP_PF_LOCAL */
   
   #ifdef LDAP_PF_INET6
   int slap_inet4or6 = AF_UNSPEC;
   #else
   int slap_inet4or6 = AF_INET;
   #endif
   
 /* globals */  /* globals */
 time_t starttime;  time_t starttime;
 ber_socket_t dtblsize;  ber_socket_t dtblsize;
Line 44  Listener **slap_listeners = NULL; Line 49  Listener **slap_listeners = NULL;
   
 static ber_socket_t wake_sds[2];  static ber_socket_t wake_sds[2];
   
 #ifdef NO_THREADS  #if defined(NO_THREADS) || defined(HAVE_GNU_PTH)
 static int waking;  static int waking;
 #define WAKE_LISTENER(w) \  #define WAKE_LISTENER(w) \
 ((w && !waking) ? tcp_write( wake_sds[1], "0", 1 ), waking=1 : 0)  ((w && !waking) ? tcp_write( wake_sds[1], "0", 1 ), waking=1 : 0)
Line 56  do { if (w) tcp_write( wake_sds[1], "0", Line 61  do { if (w) tcp_write( wake_sds[1], "0",
 #ifndef HAVE_WINSOCK  #ifndef HAVE_WINSOCK
 static  static
 #endif  #endif
 volatile sig_atomic_t slapd_shutdown = 0;  volatile sig_atomic_t slapd_shutdown = 0, slapd_gentle_shutdown = 0;
   
 static struct slap_daemon {  static struct slap_daemon {
         ldap_pvt_thread_mutex_t sd_mutex;          ldap_pvt_thread_mutex_t sd_mutex;
   
         int sd_nactives;          ber_socket_t sd_nactives;
   
 #ifndef HAVE_WINSOCK  #ifndef HAVE_WINSOCK
         /* In winsock, accept() returns values higher than dtblsize          /* In winsock, accept() returns values higher than dtblsize
Line 90  static SLPHandle slapd_hslp = 0; Line 95  static SLPHandle slapd_hslp = 0;
 void slapd_slp_init( const char* urls ) {  void slapd_slp_init( const char* urls ) {
         int i;          int i;
   
         slapd_srvurls = str2charray( urls, " " );          slapd_srvurls = ldap_str2charray( urls, " " );
   
         if( slapd_srvurls == NULL ) return;          if( slapd_srvurls == NULL ) return;
   
Line 102  void slapd_slp_init( const char* urls ) Line 107  void slapd_slp_init( const char* urls )
                                 slapd_srvurls[i] = (char *) realloc( slapd_srvurls[i],                                  slapd_srvurls[i] = (char *) realloc( slapd_srvurls[i],
                                         strlen( host ) +                                          strlen( host ) +
                                         sizeof( LDAP_SRVTYPE_PREFIX ) );                                          sizeof( LDAP_SRVTYPE_PREFIX ) );
                                 strcpy( slap_strcopy(slapd_srvurls[i],                                  strcpy( lutil_strcopy(slapd_srvurls[i],
                                         LDAP_SRVTYPE_PREFIX ), host );                                          LDAP_SRVTYPE_PREFIX ), host );
   
                                 ch_free( host );                                  ch_free( host );
Line 114  void slapd_slp_init( const char* urls ) Line 119  void slapd_slp_init( const char* urls )
                                 slapd_srvurls[i] = (char *) realloc( slapd_srvurls[i],                                  slapd_srvurls[i] = (char *) realloc( slapd_srvurls[i],
                                         strlen( host ) +                                          strlen( host ) +
                                         sizeof( LDAPS_SRVTYPE_PREFIX ) );                                          sizeof( LDAPS_SRVTYPE_PREFIX ) );
                                 strcpy( slap_strcopy(slapd_srvurls[i],                                  strcpy( lutil_strcopy(slapd_srvurls[i],
                                         LDAPS_SRVTYPE_PREFIX ), host );                                          LDAPS_SRVTYPE_PREFIX ), host );
   
                                 ch_free( host );                                  ch_free( host );
Line 129  void slapd_slp_init( const char* urls ) Line 134  void slapd_slp_init( const char* urls )
 void slapd_slp_deinit() {  void slapd_slp_deinit() {
         if( slapd_srvurls == NULL ) return;          if( slapd_srvurls == NULL ) return;
   
         charray_free( slapd_srvurls );          ldap_charray_free( slapd_srvurls );
         slapd_srvurls = NULL;          slapd_srvurls = NULL;
   
         /* close the SLP handle */          /* close the SLP handle */
Line 193  static void slapd_add(ber_socket_t s) { Line 198  static void slapd_add(ber_socket_t s) {
         }          }
 #endif  #endif
   
           slap_daemon.sd_nactives++;
   
         FD_SET( s, &slap_daemon.sd_actives );          FD_SET( s, &slap_daemon.sd_actives );
         FD_SET( s, &slap_daemon.sd_readers );          FD_SET( s, &slap_daemon.sd_readers );
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,          LDAP_LOG( CONNECTION, DETAIL1, 
                    "slapd_add: added %ld%s%s\n",                  "slapd_add: added %ld%s%s\n", (long)s,
                    (long)s,                  FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
                    FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",                  FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
                    FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ));  
 #else  #else
         Debug( LDAP_DEBUG_CONNS, "daemon: added %ld%s%s\n",          Debug( LDAP_DEBUG_CONNS, "daemon: added %ld%s%s\n",
                 (long) s,                  (long) s,
Line 217  static void slapd_add(ber_socket_t s) { Line 223  static void slapd_add(ber_socket_t s) {
 void slapd_remove(ber_socket_t s, int wake) {  void slapd_remove(ber_socket_t s, int wake) {
         ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );          ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
   
           slap_daemon.sd_nactives--;
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,          LDAP_LOG( CONNECTION, DETAIL1, 
                    "slapd_remove: removing %ld%s%s\n",                  "slapd_remove: removing %ld%s%s\n", (long) s,
                    (long) s,                  FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
                    FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",                  FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : ""  );
                    FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : ""  ));  
 #else  #else
         Debug( LDAP_DEBUG_CONNS, "daemon: removing %ld%s%s\n",          Debug( LDAP_DEBUG_CONNS, "daemon: removing %ld%s%s\n",
                 (long) s,                  (long) s,
Line 234  void slapd_remove(ber_socket_t s, int wa Line 241  void slapd_remove(ber_socket_t s, int wa
         FD_CLR( s, &slap_daemon.sd_writers );          FD_CLR( s, &slap_daemon.sd_writers );
   
         ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );          ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
         WAKE_LISTENER(wake);          WAKE_LISTENER(wake || slapd_gentle_shutdown == 2);
 }  }
   
 void slapd_clr_write(ber_socket_t s, int wake) {  void slapd_clr_write(ber_socket_t s, int wake) {
Line 281  void slapd_set_read(ber_socket_t s, int Line 288  void slapd_set_read(ber_socket_t s, int
   
 static void slapd_close(ber_socket_t s) {  static void slapd_close(ber_socket_t s) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,          LDAP_LOG( CONNECTION, DETAIL1, "slapd_close: closing %ld\n", (long)s, 0, 0);
                    "slapd_close: closing %ld\n", (long)s ));  
 #else  #else
         Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n",          Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n",
                 (long) s, 0, 0 );                  (long) s, 0, 0 );
Line 330  static int get_url_perms( Line 336  static int get_url_perms(
                 if ( strncasecmp( type, LDAPI_MOD_URLEXT "=", sizeof(LDAPI_MOD_URLEXT "=") - 1 ) == 0 ) {                  if ( strncasecmp( type, LDAPI_MOD_URLEXT "=", sizeof(LDAPI_MOD_URLEXT "=") - 1 ) == 0 ) {
                         char    *value = type + sizeof(LDAPI_MOD_URLEXT "=") - 1;                          char    *value = type + sizeof(LDAPI_MOD_URLEXT "=") - 1;
                         mode_t  p = 0;                          mode_t  p = 0;
                           int     j;
   
 #if 0  
                         if ( strlen( value ) != 9 ) {  
                                 return LDAP_OTHER;  
                         }  
   
                         switch ( value[ 0 ] ) {  
                         case 'r':  
                                 p |= S_IRUSR;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 1 ] ) {  
                         case 'w':  
                                 p |= S_IWUSR;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 2 ] ) {  
                         case 'x':  
                                 p |= S_IXUSR;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 3 ] ) {  
                         case 'r':  
                                 p |= S_IRGRP;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 4 ] ) {  
                         case 'w':  
                                 p |= S_IWGRP;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 5 ] ) {  
                         case 'x':  
                                 p |= S_IXGRP;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 6 ] ) {  
                         case 'r':  
                                 p |= S_IROTH;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 7 ] ) {  
                         case 'w':  
                                 p |= S_IWOTH;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 8 ] ) {  
                         case 'x':  
                                 p |= S_IXOTH;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
 #else  
                         if ( strlen(value) != 3 ) {                          if ( strlen(value) != 3 ) {
                                 return LDAP_OTHER;                                  return LDAP_OTHER;
                         }                           } 
   
                         switch ( value[ 0 ] ) {                          for ( j = 0; j < 3; j++ ) {
                         case 'w':                                  static mode_t   m[ 3 ] 
                                 p |= S_IRWXU;                                          = { S_IRWXU, S_IRWXG, S_IRWXO };
                                 break;  
                         case '-':                                  switch ( value[ j ] ) {
                                 break;                                  case 'w':
                         default:                                          p |= m[ j ];
                                 return LDAP_OTHER;                                          break;
                         }                                   case '-':
                                           break;
                         switch ( value[ 1 ] ) {                                  default:
                         case 'w':                                          return LDAP_OTHER;
                                 p |= S_IRWXG;                                  }
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }   
   
                         switch ( value[ 2 ] ) {  
                         case 'w':  
                                 p |= S_IRWXO;  
                                 break;  
                         case '-':  
                                 break;  
                         default:  
                                 return LDAP_OTHER;  
                         }                           } 
 #endif  
   
                         *crit = c;                          *crit = c;
                         *perms = p;                          *perms = p;
Line 467  static int get_url_perms( Line 363  static int get_url_perms(
                         return LDAP_SUCCESS;                          return LDAP_SUCCESS;
                 }                  }
         }          }
   
           return LDAP_OTHER;
 }  }
 #endif /* LDAP_PF_LOCAL */  #endif /* LDAP_PF_LOCAL */
   
Line 494  static int slap_get_listener_addresses( Line 392  static int slap_get_listener_addresses(
                 if ( strlen(host) >                  if ( strlen(host) >
                      (sizeof(((struct sockaddr_un *)*sap)->sun_path) - 1) ) {                       (sizeof(((struct sockaddr_un *)*sap)->sun_path) - 1) ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                          LDAP_LOG( CONNECTION, INFO, 
                                    "slap_get_listener_addresses: domain socket path (%s) too long in URL\n",                                  "slap_get_listener_addresses: domain socket path (%s) "
                                    host ));                                  "too long in URL\n", host, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                "daemon: domain socket path (%s) too long in URL",                                 "daemon: domain socket path (%s) too long in URL",
Line 519  static int slap_get_listener_addresses( Line 417  static int slap_get_listener_addresses(
                 memset( &hints, '\0', sizeof(hints) );                  memset( &hints, '\0', sizeof(hints) );
                 hints.ai_flags = AI_PASSIVE;                  hints.ai_flags = AI_PASSIVE;
                 hints.ai_socktype = SOCK_STREAM;                  hints.ai_socktype = SOCK_STREAM;
                 hints.ai_family = AF_UNSPEC;                  hints.ai_family = slap_inet4or6;
                 snprintf(serv, sizeof serv, "%d", port);                  snprintf(serv, sizeof serv, "%d", port);
   
                 if ( (err = getaddrinfo(host, serv, &hints, &res)) ) {                  if ( (err = getaddrinfo(host, serv, &hints, &res)) ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                          LDAP_LOG( CONNECTION, INFO, 
                                    "slap_get_listener_addresses: getaddrinfo failed: %s\n",                                     "slap_get_listener_addresses: getaddrinfo failed: %s\n",
                                    AC_GAI_STRERROR(err) ));                                     AC_GAI_STRERROR(err), 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed: %s\n",                          Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed: %s\n",
                                 AC_GAI_STRERROR(err), 0, 0);                                  AC_GAI_STRERROR(err), 0, 0);
Line 549  static int slap_get_listener_addresses( Line 447  static int slap_get_listener_addresses(
                 for ( sai=res; sai; sai=sai->ai_next ) {                  for ( sai=res; sai; sai=sai->ai_next ) {
                         if( sai->ai_addr == NULL ) {                          if( sai->ai_addr == NULL ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                                  LDAP_LOG( CONNECTION, INFO,
                                         "slap_get_listener_addresses: "                                          "slap_get_listener_addresses: "
                                         "getaddrinfo ai_addr is NULL?\n" ));                                          "getaddrinfo ai_addr is NULL?\n", 0, 0, 0 );
 #else  #else
                                 Debug( LDAP_DEBUG_ANY, "slap_get_listener_addresses: "                                  Debug( LDAP_DEBUG_ANY, "slap_get_listener_addresses: "
                                         "getaddrinfo ai_addr is NULL?\n", 0, 0, 0 );                                          "getaddrinfo ai_addr is NULL?\n", 0, 0, 0 );
Line 595  static int slap_get_listener_addresses( Line 493  static int slap_get_listener_addresses(
   
                 freeaddrinfo(res);                  freeaddrinfo(res);
 #else  #else
                   int i, n = 1;
                 struct in_addr in;                  struct in_addr in;
                   struct hostent *he = NULL;
   
                 if ( host == NULL ) {                  if ( host == NULL ) {
                         in.s_addr = htonl(INADDR_ANY);                          in.s_addr = htonl(INADDR_ANY);
   
                 } else if ( !inet_aton( host, &in ) ) {                  } else if ( !inet_aton( host, &in ) ) {
                         struct hostent *he = gethostbyname( host );                          he = gethostbyname( host );
                         if( he == NULL ) {                          if( he == NULL ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                                  LDAP_LOG( CONNECTION, INFO, 
                                            "slap_get_listener_addresses: invalid host %s\n",                                          "slap_get_listener_addresses: invalid host %s\n", host, 0, 0 );
                                            host ));  
 #else  #else
                                 Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                        "daemon: invalid host %s", host, 0, 0);                                         "daemon: invalid host %s", host, 0, 0);
 #endif  #endif
                                 return -1;                                  return -1;
                         }                          }
                         AC_MEMCPY( &in, he->h_addr, sizeof( in ) );                          for (n = 0; he->h_addr_list[n]; n++) ;
                 }                  }
   
                 *sal = ch_malloc(2 * sizeof(void *));                  *sal = ch_malloc((n+1) * sizeof(void *));
                 if (*sal == NULL) {                  if (*sal == NULL) {
                         return -1;                          return -1;
                 }                  }
   
                 sap = *sal;                  sap = *sal;
                 *sap = ch_malloc(sizeof(struct sockaddr_in));                  for ( i = 0; i<n; i++ ) {
                 if (*sap == NULL) {                          sap[i] = ch_malloc(sizeof(struct sockaddr_in));
                         goto errexit;                          if (*sap == NULL) {
                                   goto errexit;
                           }
                           (void)memset( (void *)sap[i], '\0', sizeof(struct sockaddr_in) );
                           sap[i]->sa_family = AF_INET;
                           ((struct sockaddr_in *)sap[i])->sin_port = htons(port);
                           if (he) {
                                   AC_MEMCPY( &((struct sockaddr_in *)sap[i])->sin_addr, he->h_addr_list[i], sizeof(struct in_addr) );
                           } else {
                                   AC_MEMCPY( &((struct sockaddr_in *)sap[i])->sin_addr, &in, sizeof(struct in_addr) );
                           }
                 }                  }
                 sap[1] = NULL;                  sap[i] = NULL;
   
                 (void)memset( (void *)*sap, '\0', sizeof(struct sockaddr_in) );  
                 (*sap)->sa_family = AF_INET;  
                 ((struct sockaddr_in *)*sap)->sin_port = htons(port);  
                 ((struct sockaddr_in *)*sap)->sin_addr = in;  
 #endif  #endif
         }          }
   
Line 642  errexit: Line 546  errexit:
         return -1;          return -1;
 }  }
   
 static Listener * slap_open_listener(  static int slap_open_listener(
         const char* url )          const char* url,
           int *listeners,
           int *cur
           )
 {  {
         int     tmp, rc;          int     num, tmp, rc;
         Listener l;          Listener l;
         Listener *li;          Listener *li;
         LDAPURLDesc *lud;          LDAPURLDesc *lud;
Line 653  static Listener * slap_open_listener( Line 560  static Listener * slap_open_listener(
         int err, addrlen = 0;          int err, addrlen = 0;
         struct sockaddr **sal, **psal;          struct sockaddr **sal, **psal;
         int socktype = SOCK_STREAM;     /* default to COTS */          int socktype = SOCK_STREAM;     /* default to COTS */
   
 #ifdef LDAP_PF_LOCAL  #ifdef LDAP_PF_LOCAL
         mode_t  perms = S_IRWXU;          mode_t  perms = S_IRWXU;
         int     crit = 1;          int     crit = 1;
Line 662  static Listener * slap_open_listener( Line 570  static Listener * slap_open_listener(
   
         if( rc != LDAP_URL_SUCCESS ) {          if( rc != LDAP_URL_SUCCESS ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                  LDAP_LOG( CONNECTION, ERR, 
                            "slap_open_listener: listen URL \"%s\" parse error %d\n",                          "slap_open_listener: listen URL \"%s\" parse error %d\n",
                            url, rc ));                          url, rc , 0 );
 #else  #else
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                         "daemon: listen URL \"%s\" parse error=%d\n",                          "daemon: listen URL \"%s\" parse error=%d\n",
                         url, rc, 0 );                          url, rc, 0 );
 #endif  #endif
                 return NULL;                  return rc;
         }          }
   
           l.sl_url = NULL;
   
 #ifndef HAVE_TLS  #ifndef HAVE_TLS
         if( ldap_pvt_url_scheme2tls( lud->lud_scheme ) ) {          if( ldap_pvt_url_scheme2tls( lud->lud_scheme ) ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                  LDAP_LOG( CONNECTION, INFO, 
                            "slap_open_listener: TLS is not supported (%s)\n",                             "slap_open_listener: TLS is not supported (%s)\n", url, 0, 0 );
                            url ));  
 #else  #else
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                         "daemon: TLS not supported (%s)\n",                          "daemon: TLS not supported (%s)\n",
                         url, 0, 0 );                          url, 0, 0 );
 #endif  #endif
                 ldap_free_urldesc( lud );                  ldap_free_urldesc( lud );
                 return NULL;                  return -1;
         }          }
   
         if(! lud->lud_port ) {          if(! lud->lud_port ) {
Line 717  static Listener * slap_open_listener( Line 626  static Listener * slap_open_listener(
 #else  #else
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                  LDAP_LOG( CONNECTION, INFO, 
                            "slap_open_listener: URL scheme is not supported: %s\n",                          "slap_open_listener: URL scheme is not supported: %s\n", url, 0, 0 );
                            url ));  
 #else  #else
                 Debug( LDAP_DEBUG_ANY, "daemon: URL scheme not supported: %s",                  Debug( LDAP_DEBUG_ANY, "daemon: URL scheme not supported: %s",
                         url, 0, 0);                          url, 0, 0);
 #endif  #endif
                 ldap_free_urldesc( lud );                  ldap_free_urldesc( lud );
                 return NULL;                  return -1;
 #endif  #endif
         } else {          } else {
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
Line 742  static Listener * slap_open_listener( Line 650  static Listener * slap_open_listener(
   
         ldap_free_urldesc( lud );          ldap_free_urldesc( lud );
         if ( err ) {          if ( err ) {
                 return NULL;                  return -1;
           }
   
           /* If we got more than one address returned, we need to make space
            * for it in the slap_listeners array.
            */
           for ( num=0; sal[num]; num++ );
           if ( num > 1 ) {
                   *listeners += num-1;
                   slap_listeners = ch_realloc( slap_listeners, (*listeners + 1) * sizeof(Listener *) );
         }          }
   
         psal = sal;          psal = sal;
Line 761  static Listener * slap_open_listener( Line 678  static Listener * slap_open_listener(
                         continue;                          continue;
                 }                  }
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
                 if (l.sl_is_udp)                  if( l.sl_is_udp ) socktype = SOCK_DGRAM;
                     socktype = SOCK_DGRAM;  
 #endif  #endif
                 l.sl_sd = socket( (*sal)->sa_family, socktype, 0);                  l.sl_sd = socket( (*sal)->sa_family, socktype, 0);
                 if ( l.sl_sd == AC_SOCKET_INVALID ) {                  if ( l.sl_sd == AC_SOCKET_INVALID ) {
                         int err = sock_errno();                          int err = sock_errno();
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                          LDAP_LOG( CONNECTION, ERR, 
                                    "slap_open_listener: socket() failed errno=%d (%s)\n",                                  "slap_open_listener: socket() failed errno=%d (%s)\n",
                                    err, sock_errstr(err) ));                                  err, sock_errstr(err), 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "daemon: socket() failed errno=%d (%s)\n", err,                                  "daemon: socket() failed errno=%d (%s)\n", err,
Line 782  static Listener * slap_open_listener( Line 698  static Listener * slap_open_listener(
 #ifndef HAVE_WINSOCK  #ifndef HAVE_WINSOCK
                 if ( l.sl_sd >= dtblsize ) {                  if ( l.sl_sd >= dtblsize ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                          LDAP_LOG( CONNECTION, ERR, 
                                    "slap_open_listener: listener descriptor %ld is too great %ld\n",                                  "slap_open_listener: listener descriptor %ld is too "
                                    (long)l.sl_sd, (long)dtblsize ));                                  "great %ld\n", (long)l.sl_sd, (long)dtblsize, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                "daemon: listener descriptor %ld is too great %ld\n",                                 "daemon: listener descriptor %ld is too great %ld\n",
Line 809  static Listener * slap_open_listener( Line 725  static Listener * slap_open_listener(
                         if ( rc == AC_SOCKET_ERROR ) {                          if ( rc == AC_SOCKET_ERROR ) {
                                 int err = sock_errno();                                  int err = sock_errno();
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                                  LDAP_LOG( CONNECTION, INFO, 
                                            "slap_open_listener: setsockopt( %ld, SO_REUSEADDR ) failed errno %d (%s)\n",                                          "slap_open_listener: setsockopt( %ld, SO_REUSEADDR ) "
                                            (long)l.sl_sd, err, sock_errstr(err) ));                                          "failed errno %d (%s)\n", (long)l.sl_sd, err, 
                                           sock_errstr(err) );
 #else  #else
                                 Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                        "slapd(%ld): setsockopt(SO_REUSEADDR) failed errno=%d (%s)\n",                                         "slapd(%ld): setsockopt(SO_REUSEADDR) failed errno=%d (%s)\n",
Line 827  static Listener * slap_open_listener( Line 744  static Listener * slap_open_listener(
                         break;                          break;
 #ifdef LDAP_PF_INET6  #ifdef LDAP_PF_INET6
                 case AF_INET6:                  case AF_INET6:
   #ifdef IPV6_V6ONLY
                           /* Try to use IPv6 sockets for IPv6 only */
                           tmp = 1;
                           rc = setsockopt( l.sl_sd, IPPROTO_IPV6, IPV6_V6ONLY,
                                            (char *) &tmp, sizeof(tmp) );
                           if ( rc == AC_SOCKET_ERROR ) {
                                   int err = sock_errno();
   #ifdef NEW_LOGGING
                                   LDAP_LOG( CONNECTION, INFO,
                                              "slap_open_listener: setsockopt( %ld, IPV6_V6ONLY ) failed errno %d (%s)\n",
                                              (long)l.sl_sd, err, sock_errstr(err) );
   #else
                                   Debug( LDAP_DEBUG_ANY,
                                          "slapd(%ld): setsockopt(IPV6_V6ONLY) failed errno=%d (%s)\n",
                                          (long) l.sl_sd, err, sock_errstr(err) );
   #endif
                           }
   #endif
                         addrlen = sizeof(struct sockaddr_in6);                          addrlen = sizeof(struct sockaddr_in6);
                         break;                          break;
 #endif  #endif
Line 837  static Listener * slap_open_listener( Line 772  static Listener * slap_open_listener(
 #endif  #endif
                 }                  }
   
                 if (!bind(l.sl_sd, *sal, addrlen))                  if (bind(l.sl_sd, *sal, addrlen)) {
                         break;                          err = sock_errno();
                 err = sock_errno();  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                  LDAP_LOG( CONNECTION, INFO, 
                            "slap_open_listener: bind(%ld) failed errno=%d (%s)\n",                          "slap_open_listener: bind(%ld) failed errno=%d (%s)\n",
                            (long)l.sl_sd, err, sock_errstr(err) ));                          (long)l.sl_sd, err, sock_errstr(err) );
 #else  #else
                 Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno=%d (%s)\n",                  Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno=%d (%s)\n",
                        (long) l.sl_sd, err, sock_errstr(err) );                         (long) l.sl_sd, err, sock_errstr(err) );
 #endif  #endif
                 tcp_close( l.sl_sd );                          tcp_close( l.sl_sd );
                 sal++;                          sal++;
         } /* while ( *sal != NULL ) */                          continue;
                   }
         if ( *sal == NULL ) {  
 #ifdef NEW_LOGGING  
                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,  
                            "slap_open_listener: bind(%ld) failed.\n", (long)l.sl_sd ));  
 #else  
                 Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed\n",  
                         (long) l.sl_sd, 0, 0 );  
 #endif  
                 slap_free_listener_addresses(psal);  
                 return NULL;  
         }  
   
         switch ( (*sal)->sa_family ) {          switch ( (*sal)->sa_family ) {
 #ifdef LDAP_PF_LOCAL  #ifdef LDAP_PF_LOCAL
Line 871  static Listener * slap_open_listener( Line 794  static Listener * slap_open_listener(
                 if ( chmod( addr, perms ) < 0 && crit ) {                  if ( chmod( addr, perms ) < 0 && crit ) {
                         int err = sock_errno();                          int err = sock_errno();
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                          LDAP_LOG( CONNECTION, INFO, 
                                    "slap_open_listener: fchmod(%ld) failed errno=%d (%s)\n",                                  "slap_open_listener: fchmod(%ld) failed errno=%d (%s)\n",
                                    (long)l.sl_sd, err, sock_errstr(err) ));                                  (long)l.sl_sd, err, sock_errstr(err) );
 #else  #else
                         Debug( LDAP_DEBUG_ANY, "daemon: fchmod(%ld) failed errno=%d (%s)",                          Debug( LDAP_DEBUG_ANY, "daemon: fchmod(%ld) failed errno=%d (%s)",
                                (long) l.sl_sd, err, sock_errstr(err) );                                 (long) l.sl_sd, err, sock_errstr(err) );
 #endif  #endif
                         tcp_close( l.sl_sd );                          tcp_close( l.sl_sd );
                         slap_free_listener_addresses(psal);                          slap_free_listener_addresses(psal);
                         return NULL;                          return -1;
                 }                  }
                 l.sl_name = ch_malloc( strlen(addr) + sizeof("PATH=") );                  l.sl_name = ch_malloc( strlen(addr) + sizeof("PATH=") );
                 sprintf( l.sl_name, "PATH=%s", addr );                  sprintf( l.sl_name, "PATH=%s", addr );
Line 897  static Listener * slap_open_listener( Line 820  static Listener * slap_open_listener(
 #else  #else
                 s = inet_ntoa( ((struct sockaddr_in *) *sal)->sin_addr );                  s = inet_ntoa( ((struct sockaddr_in *) *sal)->sin_addr );
 #endif  #endif
                 port = ((struct sockaddr_in *)*sal) ->sin_port;                  port = ntohs( ((struct sockaddr_in *)*sal) ->sin_port );
                 l.sl_name = ch_malloc( sizeof("IP=255.255.255.255:65535") );                  l.sl_name = ch_malloc( sizeof("IP=255.255.255.255:65535") );
                 sprintf( l.sl_name, "IP=%s:%d",                  sprintf( l.sl_name, "IP=%s:%d",
                          s != NULL ? s : "unknown" , port );                           s != NULL ? s : "unknown" , port );
Line 908  static Listener * slap_open_listener( Line 831  static Listener * slap_open_listener(
                 char addr[INET6_ADDRSTRLEN];                  char addr[INET6_ADDRSTRLEN];
                 inet_ntop( AF_INET6, &((struct sockaddr_in6 *)*sal)->sin6_addr,                  inet_ntop( AF_INET6, &((struct sockaddr_in6 *)*sal)->sin6_addr,
                            addr, sizeof addr);                             addr, sizeof addr);
                 port = ((struct sockaddr_in6 *)*sal)->sin6_port;                  port = ntohs( ((struct sockaddr_in6 *)*sal)->sin6_port );
                 l.sl_name = ch_malloc( strlen(addr) + sizeof("IP= 65535") );                  l.sl_name = ch_malloc( strlen(addr) + sizeof("IP= 65535") );
                 sprintf( l.sl_name, "IP=%s %d", addr, port );                  sprintf( l.sl_name, "IP=%s %d", addr, port );
         } break;          } break;
Line 916  static Listener * slap_open_listener( Line 839  static Listener * slap_open_listener(
   
         default:          default:
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                  LDAP_LOG( CONNECTION, INFO, 
                            "slap_open_listener: unsupported address family (%d)\n",                          "slap_open_listener: unsupported address family (%d)\n",
                            (int)(*sal)->sa_family ));                          (int)(*sal)->sa_family, 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_ANY, "daemon: unsupported address family (%d)\n",                  Debug( LDAP_DEBUG_ANY, "daemon: unsupported address family (%d)\n",
                         (int) (*sal)->sa_family, 0, 0 );                          (int) (*sal)->sa_family, 0, 0 );
Line 926  static Listener * slap_open_listener( Line 849  static Listener * slap_open_listener(
                 break;                  break;
         }          }
   
         slap_free_listener_addresses(psal);          AC_MEMCPY(&l.sl_sa, *sal, addrlen);
   
         l.sl_url = ch_strdup( url );          l.sl_url = ch_strdup( url );
         li = ch_malloc( sizeof( Listener ) );          li = ch_malloc( sizeof( Listener ) );
         *li = l;          *li = l;
           slap_listeners[*cur] = li;
           (*cur)++;
           sal++;
   
           } /* while ( *sal != NULL ) */
   
           slap_free_listener_addresses(psal);
   
           if ( l.sl_url == NULL )
           {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_RESULTS,                  LDAP_LOG( CONNECTION, RESULTS, 
                    "slap_open_listener: daemon initialzed %s\n", l.sl_url ));                          "slap_open_listener: failed on %s\n", url, 0, 0 );
   #else
                   Debug( LDAP_DEBUG_TRACE,
                           "slap_open_listener: failed on %s\n", url, 0, 0 );
   #endif
                   return -1;
           }
   
   #ifdef NEW_LOGGING
           LDAP_LOG( CONNECTION, RESULTS, 
                   "slap_open_listener: daemon initialized %s\n", l.sl_url, 0, 0 );
 #else  #else
         Debug( LDAP_DEBUG_TRACE, "daemon: initialized %s\n",          Debug( LDAP_DEBUG_TRACE, "daemon: initialized %s\n",
                 l.sl_url, 0, 0 );                  l.sl_url, 0, 0 );
 #endif  #endif
         return li;          return 0;
 }  }
   
 static int sockinit(void);  static int sockinit(void);
Line 947  static int sockdestroy(void); Line 888  static int sockdestroy(void);
   
 int slapd_daemon_init( const char *urls )  int slapd_daemon_init( const char *urls )
 {  {
         int i, rc;          int i, j, n, rc;
         char **u;          char **u;
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_ARGS,          LDAP_LOG( CONNECTION, ARGS, 
                    "slapd_daemon_init: %s\n",                  "slapd_daemon_init: %s\n", urls ? urls : "<null>", 0, 0 );
                    urls ? urls : "<null>" ));  
 #else  #else
         Debug( LDAP_DEBUG_ARGS, "daemon_init: %s\n",          Debug( LDAP_DEBUG_ARGS, "daemon_init: %s\n",
                 urls ? urls : "<null>", 0, 0 );                  urls ? urls : "<null>", 0, 0 );
Line 983  int slapd_daemon_init( const char *urls Line 923  int slapd_daemon_init( const char *urls
          */           */
         if( (rc = lutil_pair( wake_sds )) < 0 ) {          if( (rc = lutil_pair( wake_sds )) < 0 ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                  LDAP_LOG( CONNECTION, ERR, 
                            "slap_daemon_init: lutil_pair() failed rc=%d\n", rc ));                          "slap_daemon_init: lutil_pair() failed rc=%d\n", rc, 0, 0);
 #else  #else
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                         "daemon: lutil_pair() failed rc=%d\n", rc, 0, 0 );                          "daemon: lutil_pair() failed rc=%d\n", rc, 0, 0 );
Line 999  int slapd_daemon_init( const char *urls Line 939  int slapd_daemon_init( const char *urls
                 urls = "ldap:///";                  urls = "ldap:///";
         }          }
   
         u = str2charray( urls, " " );          u = ldap_str2charray( urls, " " );
   
         if( u == NULL || u[0] == NULL ) {          if( u == NULL || u[0] == NULL ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                  LDAP_LOG( CONNECTION, ERR, 
                            "slap_daemon_init: no urls (%s) provided.\n", urls ));                          "slap_daemon_init: no urls (%s) provided.\n", urls, 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_ANY, "daemon_init: no urls (%s) provided.\n",                  Debug( LDAP_DEBUG_ANY, "daemon_init: no urls (%s) provided.\n",
                         urls, 0, 0 );                          urls, 0, 0 );
Line 1014  int slapd_daemon_init( const char *urls Line 954  int slapd_daemon_init( const char *urls
   
         for( i=0; u[i] != NULL; i++ ) {          for( i=0; u[i] != NULL; i++ ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,                  LDAP_LOG( CONNECTION, DETAIL1, 
                            "slap_daemon_init: listen on %s\n.", u[i] ));                          "slap_daemon_init: listen on %s\n.", u[i], 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_TRACE, "daemon_init: listen on %s\n",                  Debug( LDAP_DEBUG_TRACE, "daemon_init: listen on %s\n",
                         u[i], 0, 0 );                          u[i], 0, 0 );
Line 1024  int slapd_daemon_init( const char *urls Line 964  int slapd_daemon_init( const char *urls
   
         if( i == 0 ) {          if( i == 0 ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                  LDAP_LOG( CONNECTION, INFO, 
                            "slap_daemon_init: no listeners to open (%s)\n", urls ));                           "slap_daemon_init: no listeners to open (%s)\n", urls, 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_ANY, "daemon_init: no listeners to open (%s)\n",                  Debug( LDAP_DEBUG_ANY, "daemon_init: no listeners to open (%s)\n",
                         urls, 0, 0 );                          urls, 0, 0 );
 #endif  #endif
                 charray_free( u );                  ldap_charray_free( u );
                 return -1;                  return -1;
         }          }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_INFO,          LDAP_LOG( CONNECTION, INFO, 
                    "slap_daemon_init: %d listeners to open...\n", i ));                  "slap_daemon_init: %d listeners to open...\n", i, 0, 0 );
 #else  #else
         Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners to open...\n",          Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners to open...\n",
                 i, 0, 0 );                  i, 0, 0 );
 #endif  #endif
         slap_listeners = ch_malloc( (i+1)*sizeof(Listener *) );          slap_listeners = ch_malloc( (i+1)*sizeof(Listener *) );
   
         for(i = 0; u[i] != NULL; i++ ) {          for(n = 0, j = 0; u[n]; n++ ) {
                 slap_listeners[i] = slap_open_listener( u[i] );                  if ( slap_open_listener( u[n], &i, &j ) ) {
                           ldap_charray_free( u );
                 if( slap_listeners[i] == NULL ) {  
                         charray_free( u );  
                         return -1;                          return -1;
                 }                  }
         }          }
         slap_listeners[i] = NULL;          slap_listeners[j] = NULL;
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,          LDAP_LOG( CONNECTION, DETAIL1, 
                    "slap_daemon_init: %d listeners opened\n", i ));                  "slap_daemon_init: %d listeners opened\n", i, 0, 0 );
 #else  #else
         Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners opened\n",          Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners opened\n",
                 i, 0, 0 );                  i, 0, 0 );
Line 1066  int slapd_daemon_init( const char *urls Line 1004  int slapd_daemon_init( const char *urls
         slapd_slp_reg();          slapd_slp_reg();
 #endif  #endif
   
         charray_free( u );          ldap_charray_free( u );
         ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );          ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
         return !i;          return !i;
 }  }
Line 1089  slapd_daemon_destroy(void) Line 1027  slapd_daemon_destroy(void)
 }  }
   
   
   static void
   close_listeners(
           int remove
   )
   {
           int l;
   
           for ( l = 0; slap_listeners[l] != NULL; l++ ) {
                   if ( slap_listeners[l]->sl_sd != AC_SOCKET_INVALID ) {
                           if ( remove )
                                   slapd_remove( slap_listeners[l]->sl_sd, 0 );
   #ifdef LDAP_PF_LOCAL
                           if ( slap_listeners[l]->sl_sa.sa_addr.sa_family == AF_LOCAL ) {
                                   unlink( slap_listeners[l]->sl_sa.sa_un_addr.sun_path );
                           }
   #endif /* LDAP_PF_LOCAL */
                           slapd_close( slap_listeners[l]->sl_sd );
                   }
                   if ( slap_listeners[l]->sl_url )
                           free ( slap_listeners[l]->sl_url );
                   if ( slap_listeners[l]->sl_name )
                           free ( slap_listeners[l]->sl_name );
                   free ( slap_listeners[l] );
                   slap_listeners[l] = NULL;
           }
   }
   
   
 static void *  static void *
 slapd_daemon_task(  slapd_daemon_task(
         void *ptr          void *ptr
Line 1109  slapd_daemon_task( Line 1075  slapd_daemon_task(
                  * listening port. The listen() and accept() calls                   * listening port. The listen() and accept() calls
                  * are unnecessary.                   * are unnecessary.
                  */                   */
                 if ( slap_listeners[l]->sl_is_udp )                  if ( slap_listeners[l]->sl_is_udp ) {
                 {  
                         slapd_add( slap_listeners[l]->sl_sd );                          slapd_add( slap_listeners[l]->sl_sd );
                         continue;                          continue;
                 }                  }
Line 1118  slapd_daemon_task( Line 1083  slapd_daemon_task(
   
                 if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN ) == -1 ) {                  if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN ) == -1 ) {
                         int err = sock_errno();                          int err = sock_errno();
   
   #ifdef LDAP_PF_INET6
                           /* If error is EADDRINUSE, we are trying to listen to INADDR_ANY and
                            * we are already listening to in6addr_any, then we want to ignore
                            * this and continue.
                            */
                           if ( err == EADDRINUSE ) {
                                   int i;
                                   struct sockaddr_in sa = slap_listeners[l]->sl_sa.sa_in_addr;
                                   struct sockaddr_in6 sa6;
                                   
                                   if ( sa.sin_family == AF_INET &&
                                        sa.sin_addr.s_addr == htonl(INADDR_ANY) ) {
                                           for ( i = 0 ; i < l; i++ ) {
                                                   sa6 = slap_listeners[i]->sl_sa.sa_in6_addr;
                                                   if ( sa6.sin6_family == AF_INET6 &&
                                                        !memcmp( &sa6.sin6_addr, &in6addr_any, sizeof(struct in6_addr) ) )
                                                           break;
                                           }
   
                                           if ( i < l ) {
                                                   /* We are already listening to in6addr_any */
   #ifdef NEW_LOGGING
                                                   LDAP_LOG(CONNECTION, WARNING,
                                                              "slapd_daemon_task: Attempt to listen to 0.0.0.0 failed, already listening on ::, assuming IPv4 included\n", 0, 0, 0 );
   #else
                                                   Debug( LDAP_DEBUG_CONNS,
                                                          "daemon: Attempt to listen to 0.0.0.0 failed, already listening on ::, assuming IPv4 included\n",
                                                          0, 0, 0 );
   #endif
                                                   slapd_close( slap_listeners[l]->sl_sd );
                                                   slap_listeners[l]->sl_sd = AC_SOCKET_INVALID;
                                                   continue;
                                           }
                                   }
                           }
   #endif                          
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                          LDAP_LOG( CONNECTION, ERR, 
                                    "slapd_daemon_task: listen( %s, 5 ) failed errno=%d (%s)\n",                                  "slapd_daemon_task: listen( %s, 5 ) failed errno=%d (%s)\n",
                                    slap_listeners[l]->sl_url, err, sock_errstr(err) ));                                  slap_listeners[l]->sl_url, err, sock_errstr(err) );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "daemon: listen(%s, 5) failed errno=%d (%s)\n",                                  "daemon: listen(%s, 5) failed errno=%d (%s)\n",
Line 1175  slapd_daemon_task( Line 1177  slapd_daemon_task(
                         }                          }
                 }                  }
   
   #ifdef SIGHUP
                   if( slapd_gentle_shutdown ) {
                           ber_socket_t active;
   
                           if( slapd_gentle_shutdown == 1 ) {
                                   Debug( LDAP_DEBUG_ANY, "slapd gentle shutdown\n", 0, 0, 0 );
                                   close_listeners( 1 );
                                   global_restrictops |= SLAP_RESTRICT_OP_WRITES;
                                   slapd_gentle_shutdown = 2;
                           }
   
                           ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
                           active = slap_daemon.sd_nactives;
                           ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
                           if( active == 0 ) {
                                   slapd_shutdown = 2;
                                   break;
                           }
                   }
   #endif
   
                 FD_ZERO( &writefds );                  FD_ZERO( &writefds );
                 FD_ZERO( &readfds );                  FD_ZERO( &readfds );
   
Line 1227  slapd_daemon_task( Line 1250  slapd_daemon_task(
                                 continue;                                  continue;
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,                          LDAP_LOG( CONNECTION, DETAIL1, 
                                    "slapd_daemon_task: select: listen=%d active_threads=%d tvp=%s\n",                                  "slapd_daemon_task: select: listen=%d "
                                    slap_listeners[l]->sl_sd, at, tvp == NULL ? "NULL" : "zero" ));                                  "active_threads=%d tvp=%s\n",
                                   slap_listeners[l]->sl_sd, at, tvp == NULL ? "NULL" : "zero" );
 #else  #else
                         Debug( LDAP_DEBUG_CONNS,                          Debug( LDAP_DEBUG_CONNS,
                                 "daemon: select: listen=%d active_threads=%d tvp=%s\n",                                  "daemon: select: listen=%d active_threads=%d tvp=%s\n",
Line 1262  slapd_daemon_task( Line 1286  slapd_daemon_task(
   
                                 if( err != EINTR ) {                                  if( err != EINTR ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                         LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                                          LDAP_LOG( CONNECTION, INFO, 
                                                    "slapd_daemon_task: select failed (%d): %s\n",                                                  "slapd_daemon_task: select failed (%d): %s\n",
                                                    err, sock_errstr(err) ));                                                  err, sock_errstr(err), 0 );
 #else  #else
                                         Debug( LDAP_DEBUG_CONNS,                                          Debug( LDAP_DEBUG_CONNS,
                                                 "daemon: select failed (%d): %s\n",                                                  "daemon: select failed (%d): %s\n",
                                                 err, sock_errstr(err), 0 );                                                  err, sock_errstr(err), 0 );
 #endif  #endif
                                         slapd_shutdown = -1;                                          slapd_shutdown = 2;
                                 }                                  }
                         }                          }
                         continue;                          continue;
Line 1278  slapd_daemon_task( Line 1302  slapd_daemon_task(
                 case 0:         /* timeout - let threads run */                  case 0:         /* timeout - let threads run */
                         ebadf = 0;                          ebadf = 0;
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,                          LDAP_LOG( CONNECTION, DETAIL2,
                                    "slapd_daemon_task: select timeout - yielding\n" ));                                     "slapd_daemon_task: select timeout - yielding\n", 0, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",                          Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
                             0, 0, 0 );                              0, 0, 0 );
Line 1292  slapd_daemon_task( Line 1316  slapd_daemon_task(
   
                         ebadf = 0;                          ebadf = 0;
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,                          LDAP_LOG( CONNECTION, DETAIL2, 
                                    "slapd_daemon_task: activity on %d descriptors\n", ns ));                                     "slapd_daemon_task: activity on %d descriptors\n", ns, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",                          Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
                                 ns, 0, 0 );                                  ns, 0, 0 );
Line 1304  slapd_daemon_task( Line 1328  slapd_daemon_task(
                 if( FD_ISSET( wake_sds[0], &readfds ) ) {                  if( FD_ISSET( wake_sds[0], &readfds ) ) {
                         char c[BUFSIZ];                          char c[BUFSIZ];
                         tcp_read( wake_sds[0], c, sizeof(c) );                          tcp_read( wake_sds[0], c, sizeof(c) );
 #ifdef NO_THREADS  #if defined(NO_THREADS) || defined(HAVE_GNU_PTH)
                         waking = 0;                          waking = 0;
 #endif  #endif
                         continue;                          continue;
Line 1336  slapd_daemon_task( Line 1360  slapd_daemon_task(
                                 continue;                                  continue;
   
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
                         if ( slap_listeners[l]->sl_is_udp )                          if ( slap_listeners[l]->sl_is_udp ) {
                         {                                  /* The first time we receive a query, we set this
                         /* The first time we receive a query, we set this                                   * up as a "connection". It remains open for the life
                          * up as a "connection". It remains open for the life                                   * of the slapd.
                          * of the slapd.                                   */
                          */                                  if ( slap_listeners[l]->sl_is_udp < 2 ) {
                                 if ( slap_listeners[l]->sl_is_udp < 2 )  
                                 {  
                                     id = connection_init(                                      id = connection_init(
                                         slap_listeners[l]->sl_sd,                                          slap_listeners[l]->sl_sd,
                                         slap_listeners[l]->sl_url, "", "",                                          slap_listeners[l]->sl_url, "", "",
Line 1376  slapd_daemon_task( Line 1398  slapd_daemon_task(
   
                                 if( emfile < 3 ) {                                  if( emfile < 3 ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                         LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                                          LDAP_LOG( CONNECTION, ERR, 
                                                 "slapd_daemon_task: accept(%ld) failed errno=%d (%s)\n",                                                  "slapd_daemon_task: accept(%ld) failed errno=%d (%s)\n",
                                                 (long)slap_listeners[l]->sl_sd, err, sock_errstr(err) ));                                                  (long)slap_listeners[l]->sl_sd, 
                                                   err, sock_errstr(err) );
 #else  #else
                                         Debug( LDAP_DEBUG_ANY,                                          Debug( LDAP_DEBUG_ANY,
                                             "daemon: accept(%ld) failed errno=%d (%s)\n",                                              "daemon: accept(%ld) failed errno=%d (%s)\n",
Line 1403  slapd_daemon_task( Line 1426  slapd_daemon_task(
                         /* make sure descriptor number isn't too great */                          /* make sure descriptor number isn't too great */
                         if ( s >= dtblsize ) {                          if ( s >= dtblsize ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                                  LDAP_LOG( CONNECTION, ERR, 
                                    "slapd_daemon_task: %ld beyond descriptor table size %ld\n",                                     "slapd_daemon_task: %ld beyond descriptor table size %ld\n",
                                    (long)s, (long)dtblsize ));                                     (long)s, (long)dtblsize, 0 );
 #else  #else
                                 Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                         "daemon: %ld beyond descriptor table size %ld\n",                                          "daemon: %ld beyond descriptor table size %ld\n",
Line 1445  slapd_daemon_task( Line 1468  slapd_daemon_task(
                                 if ( rc == AC_SOCKET_ERROR ) {                                  if ( rc == AC_SOCKET_ERROR ) {
                                         int err = sock_errno();                                          int err = sock_errno();
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                         LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                                          LDAP_LOG( CONNECTION, ERR, 
                                                    "slapd_daemon_task: setsockopt( %ld, SO_KEEPALIVE) failed errno=%d (%s)\n",                                                  "slapd_daemon_task: setsockopt( %ld, SO_KEEPALIVE)"
                                                    (long)s, err, sock_errstr(err) ));                                             " failed errno=%d (%s)\n",
                                                   (long)s, err, sock_errstr(err) );
 #else  #else
                                         Debug( LDAP_DEBUG_ANY,                                          Debug( LDAP_DEBUG_ANY,
                                                 "slapd(%ld): setsockopt(SO_KEEPALIVE) failed "                                                  "slapd(%ld): setsockopt(SO_KEEPALIVE) failed "
Line 1463  slapd_daemon_task( Line 1487  slapd_daemon_task(
                                 if ( rc == AC_SOCKET_ERROR ) {                                  if ( rc == AC_SOCKET_ERROR ) {
                                         int err = sock_errno();                                          int err = sock_errno();
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                         LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                                          LDAP_LOG( CONNECTION, ERR, 
                                                    "slapd_daemon_task: setsockopt( %ld, TCP_NODELAY) failed errno=%d (%s)\n",                                                  "slapd_daemon_task: setsockopt( %ld, "
                                                    (long)s, err, sock_errstr(err) ));                                                  "TCP_NODELAY) failed errno=%d (%s)\n",
                                                   (long)s, err, sock_errstr(err) );
 #else  #else
                                         Debug( LDAP_DEBUG_ANY,                                          Debug( LDAP_DEBUG_ANY,
                                                 "slapd(%ld): setsockopt(TCP_NODELAY) failed "                                                  "slapd(%ld): setsockopt(TCP_NODELAY) failed "
Line 1477  slapd_daemon_task( Line 1502  slapd_daemon_task(
 #endif  #endif
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,                          LDAP_LOG( CONNECTION, DETAIL1, 
                                    "slapd_daemon_task: new connection on %ld\n", (long)s ));                                  "slapd_daemon_task: new connection on %ld\n", (long)s, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",                          Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
                                 (long) s, 0, 0 );                                  (long) s, 0, 0 );
Line 1502  slapd_daemon_task( Line 1527  slapd_daemon_task(
                                          (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );                                           (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
                         } else {                          } else {
                                 char addr[INET6_ADDRSTRLEN];                                  char addr[INET6_ADDRSTRLEN];
   
                                   peeraddr = (char *) inet_ntop( AF_INET6,
                                                         &from.sa_in6_addr.sin6_addr,
                                                         addr, sizeof addr );
                                 sprintf( peername, "IP=%s %d",                                  sprintf( peername, "IP=%s %d",
                                          inet_ntop( AF_INET6,                                           peeraddr != NULL ? peeraddr : "unknown",
                                                     &from.sa_in6_addr.sin6_addr,  
                                                     addr, sizeof addr) ? addr : "unknown",  
                                          (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );                                           (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
                         }                          }
                         break;                          break;
Line 1529  slapd_daemon_task( Line 1556  slapd_daemon_task(
 #endif  #endif
                         ) {                          ) {
 #ifdef SLAPD_RLOOKUPS  #ifdef SLAPD_RLOOKUPS
                                   if ( use_reverse_lookup ) {
 #  ifdef LDAP_PF_INET6  #  ifdef LDAP_PF_INET6
                                 if ( from.sa_addr.sa_family == AF_INET6 )                                          if ( from.sa_addr.sa_family == AF_INET6 )
                                         hp = gethostbyaddr(                                                  hp = gethostbyaddr(
                                                 (char *)&(from.sa_in6_addr.sin6_addr),                                                          (char *)&(from.sa_in6_addr.sin6_addr),
                                                 sizeof(from.sa_in6_addr.sin6_addr),                                                          sizeof(from.sa_in6_addr.sin6_addr),
                                                 AF_INET6 );                                                          AF_INET6 );
                                 else                                          else
 #  endif /* LDAP_PF_INET6 */  #  endif /* LDAP_PF_INET6 */
                                 hp = gethostbyaddr(                                          hp = gethostbyaddr(
                                         (char *) &(from.sa_in_addr.sin_addr),                                                  (char *) &(from.sa_in_addr.sin_addr),
                                         sizeof(from.sa_in_addr.sin_addr),                                                  sizeof(from.sa_in_addr.sin_addr),
                                         AF_INET );                                                  AF_INET );
                                 dnsname = hp ? ldap_pvt_str2lower( hp->h_name ) : NULL;                                          dnsname = hp ? ldap_pvt_str2lower( hp->h_name ) : NULL;
                                   }
 #else  #else
                                 dnsname = NULL;                                  dnsname = NULL;
 #endif /* SLAPD_RLOOKUPS */  #endif /* SLAPD_RLOOKUPS */
Line 1582  slapd_daemon_task( Line 1611  slapd_daemon_task(
   
                         if( id < 0 ) {                          if( id < 0 ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG(( "connection", LDAP_LEVEL_INFO,                                  LDAP_LOG( CONNECTION, INFO, 
                                            "slapd_daemon_task: connection_init(%ld, %s, %s) failed.\n",                                          "slapd_daemon_task: connection_init(%ld, %s, %s) failed.\n",
                                            (long)s, peername, slap_listeners[l]->sl_name ));                                          (long)s, peername, slap_listeners[l]->sl_name );
 #else  #else
                                 Debug( LDAP_DEBUG_ANY,                                  Debug( LDAP_DEBUG_ANY,
                                         "daemon: connection_init(%ld, %s, %s) failed.\n",                                          "daemon: connection_init(%ld, %s, %s) failed.\n",
Line 1609  slapd_daemon_task( Line 1638  slapd_daemon_task(
   
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,                  LDAP_LOG( CONNECTION, DETAIL2,
                            "slapd_daemon_task: activity on " ));                             "slapd_daemon_task: activity on ", 0, 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );                  Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
 #endif  #endif
 #ifdef HAVE_WINSOCK  #ifdef HAVE_WINSOCK
                 for ( i = 0; i < readfds.fd_count; i++ ) {                  for ( i = 0; i < readfds.fd_count; i++ ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,                          LDAP_LOG( CONNECTION, DETAIL2, 
                                    " %d%s", readfds.fd_array[i], "r", 0 ));                                  " %d%s", readfds.fd_array[i], "r", 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_CONNS, " %d%s",                          Debug( LDAP_DEBUG_CONNS, " %d%s",
                                 readfds.fd_array[i], "r", 0 );                                  readfds.fd_array[i], "r", 0 );
Line 1626  slapd_daemon_task( Line 1655  slapd_daemon_task(
                 }                  }
                 for ( i = 0; i < writefds.fd_count; i++ ) {                  for ( i = 0; i < writefds.fd_count; i++ ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,                          LDAP_LOG( CONNECTION, DETAIL2, 
                                    " %d%s", writefds.fd_array[i], "w" ));                                  " %d%s", writefds.fd_array[i], "w" , 0 );
 #else  #else
                         Debug( LDAP_DEBUG_CONNS, " %d%s",                          Debug( LDAP_DEBUG_CONNS, " %d%s",
                                 writefds.fd_array[i], "w", 0 );                                  writefds.fd_array[i], "w", 0 );
Line 1645  slapd_daemon_task( Line 1674  slapd_daemon_task(
                                 /* The listener is the data port. Don't                                  /* The listener is the data port. Don't
                                  * skip it.                                   * skip it.
                                  */                                   */
                                         if (slap_listeners[l]->sl_is_udp)                                          if (slap_listeners[l]->sl_is_udp) continue;
                                                 continue;  
 #endif  #endif
                                         is_listener = 1;                                          is_listener = 1;
                                         break;                                          break;
Line 1659  slapd_daemon_task( Line 1687  slapd_daemon_task(
                         w = FD_ISSET( i, &writefds );                          w = FD_ISSET( i, &writefds );
                         if ( r || w ) {                          if ( r || w ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,                                  LDAP_LOG( CONNECTION, DETAIL2, 
                                            " %d%s%s", i,                                          " %d%s%s", i, r ? "r" : "", w ? "w" : "" );
                                            r ? "r" : "", w ? "w" : "" ));  
 #else  #else
                                 Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,                                  Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
                                     r ? "r" : "", w ? "w" : "" );                                      r ? "r" : "", w ? "w" : "" );
Line 1670  slapd_daemon_task( Line 1697  slapd_daemon_task(
                 }                  }
 #endif  #endif
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2, "\n" ));                  LDAP_LOG( CONNECTION, DETAIL2, "\n", 0, 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
 #endif  #endif
Line 1698  slapd_daemon_task( Line 1725  slapd_daemon_task(
                         for ( l = 0; slap_listeners[l] != NULL; l++ ) {                          for ( l = 0; slap_listeners[l] != NULL; l++ ) {
                                 if ( i == slap_listeners[l]->sl_sd ) {                                  if ( i == slap_listeners[l]->sl_sd ) {
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
                                         if (slap_listeners[l]->sl_is_udp)                                          if (slap_listeners[l]->sl_is_udp) continue;
                                                 continue;  
 #endif  #endif
                                         is_listener = 1;                                          is_listener = 1;
                                         break;                                          break;
Line 1709  slapd_daemon_task( Line 1735  slapd_daemon_task(
                                 continue;                                  continue;
                         }                          }
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,                          LDAP_LOG( CONNECTION, DETAIL2, 
                                    "slapd_daemon_task: write active on %d\n", wd ));                                  "slapd_daemon_task: write active on %d\n", wd, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_CONNS,                          Debug( LDAP_DEBUG_CONNS,
                                 "daemon: write active on %d\n",                                  "daemon: write active on %d\n",
Line 1750  slapd_daemon_task( Line 1776  slapd_daemon_task(
                         for ( l = 0; slap_listeners[l] != NULL; l++ ) {                          for ( l = 0; slap_listeners[l] != NULL; l++ ) {
                                 if ( rd == slap_listeners[l]->sl_sd ) {                                  if ( rd == slap_listeners[l]->sl_sd ) {
 #ifdef LDAP_CONNECTIONLESS  #ifdef LDAP_CONNECTIONLESS
                                         if (slap_listeners[l]->sl_is_udp)                                          if (slap_listeners[l]->sl_is_udp) continue;
                                                 continue;  
 #endif  #endif
                                         is_listener = 1;                                          is_listener = 1;
                                         break;                                          break;
Line 1762  slapd_daemon_task( Line 1787  slapd_daemon_task(
                         }                          }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,                          LDAP_LOG( CONNECTION, DETAIL2, 
                                    "slapd_daemon_task: read activity on %d\n", rd ));                                  "slapd_daemon_task: read activity on %d\n", rd, 0, 0 );
 #else  #else
                         Debug ( LDAP_DEBUG_CONNS,                          Debug ( LDAP_DEBUG_CONNS,
                                 "daemon: read activity on %d\n", rd, 0, 0 );                                  "daemon: read activity on %d\n", rd, 0, 0 );
Line 1782  slapd_daemon_task( Line 1807  slapd_daemon_task(
                 ldap_pvt_thread_yield();                  ldap_pvt_thread_yield();
         }          }
   
         if( slapd_shutdown > 0 ) {          if( slapd_shutdown == 1 ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,                  LDAP_LOG( CONNECTION, CRIT,
                            "slapd_daemon_task: shutdown requested and initiated.\n"));                     "slapd_daemon_task: shutdown requested and initiated.\n", 0, 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "daemon: shutdown requested and initiated.\n",                          "daemon: shutdown requested and initiated.\n",
                         0, 0, 0 );                          0, 0, 0 );
 #endif  #endif
   
         } else if ( slapd_shutdown < 0 ) {          } else if ( slapd_shutdown == 2 ) {
 #ifdef HAVE_NT_SERVICE_MANAGER  #ifdef HAVE_NT_SERVICE_MANAGER
                 if (slapd_shutdown == -1)  
                 {  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,                          LDAP_LOG( CONNECTION, CRIT,
                                    "slapd_daemon_task: shutdown initiated by Service Manager.\n"));                             "slapd_daemon_task: shutdown initiated by Service Manager.\n",
                              0, 0, 0);
 #else  #else
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                "daemon: shutdown initiated by Service Manager.\n",                                 "daemon: shutdown initiated by Service Manager.\n",
                                0, 0, 0);                                 0, 0, 0);
 #endif  #endif
                 }  #else /* !HAVE_NT_SERVICE_MANAGER */
                 else  
 #endif  
                 {  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,                          LDAP_LOG( CONNECTION, CRIT,
                                    "slapd_daemon_task: abnormal condition, shutdown initiated.\n" ));                             "slapd_daemon_task: abnormal condition, "
                              "shutdown initiated.\n", 0, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                "daemon: abnormal condition, shutdown initiated.\n",                                 "daemon: abnormal condition, shutdown initiated.\n",
                                0, 0, 0 );                                 0, 0, 0 );
 #endif  #endif
                 }  #endif /* !HAVE_NT_SERVICE_MANAGER */
         } else {          } else {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,                  LDAP_LOG( CONNECTION, CRIT,
                            "slapd_daemon_task: no active streams, shutdown initiated.\n" ));                     "slapd_daemon_task: no active streams, shutdown initiated.\n", 
                      0, 0, 0 );
 #else  #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                        "daemon: no active streams, shutdown initiated.\n",                         "daemon: no active streams, shutdown initiated.\n",
Line 1828  slapd_daemon_task( Line 1851  slapd_daemon_task(
 #endif  #endif
         }          }
   
         for ( l = 0; slap_listeners[l] != NULL; l++ ) {          if( slapd_gentle_shutdown != 2 )
                 if ( slap_listeners[l]->sl_sd != AC_SOCKET_INVALID ) {                  close_listeners ( 0 );
 #ifdef LDAP_PF_LOCAL  
                         if ( slap_listeners[l]->sl_sa.sa_addr.sa_family == AF_LOCAL ) {  
                                 unlink( slap_listeners[l]->sl_sa.sa_un_addr.sun_path );  
                         }  
 #endif /* LDAP_PF_LOCAL */  
                         slapd_close( slap_listeners[l]->sl_sd );  
                 }  
                 if ( slap_listeners[l]->sl_url )  
                         free ( slap_listeners[l]->sl_url );  
                 if ( slap_listeners[l]->sl_name )  
                         free ( slap_listeners[l]->sl_name );  
                 free ( slap_listeners[l] );  
         }  
         free ( slap_listeners );          free ( slap_listeners );
         slap_listeners = NULL;          slap_listeners = NULL;
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,          LDAP_LOG( CONNECTION, CRIT, 
                    "slapd_daemon_task: shutdown waiting for %d threads to terminate.\n",                  "slapd_daemon_task: shutdown waiting for %d threads to terminate.\n",
                    ldap_pvt_thread_pool_backload(&connection_pool) ));                  ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
 #else  #else
         Debug( LDAP_DEBUG_ANY,          Debug( LDAP_DEBUG_ANY,
             "slapd shutdown: waiting for %d threads to terminate\n",              "slapd shutdown: waiting for %d threads to terminate\n",
Line 1878  int slapd_daemon( void ) Line 1888  int slapd_daemon( void )
   
                 if ( rc != 0 ) {                  if ( rc != 0 ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG(( "connection", LDAP_LEVEL_ERR,                          LDAP_LOG( CONNECTION, ERR, 
                                    "slapd_daemon: listener ldap_pvt_thread_create failed (%d).\n", rc ));                                  "slapd_daemon: listener ldap_pvt_thread_create failed (%d).\n",
                                   rc, 0, 0 );
 #else  #else
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                         "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );                          "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
Line 1952  RETSIGTYPE Line 1963  RETSIGTYPE
 slap_sig_shutdown( int sig )  slap_sig_shutdown( int sig )
 {  {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,          LDAP_LOG( CONNECTION, CRIT, 
                    "slap_sig_shutdown: signal %d\n", sig ));                  "slap_sig_shutdown: signal %d\n", sig, 0, 0 );
 #else  #else
         Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: signal %d\n", sig, 0, 0);          Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: signal %d\n", sig, 0, 0);
 #endif  #endif
Line 1967  slap_sig_shutdown( int sig ) Line 1978  slap_sig_shutdown( int sig )
 #if HAVE_NT_SERVICE_MANAGER && SIGBREAK  #if HAVE_NT_SERVICE_MANAGER && SIGBREAK
         if (is_NT_Service && sig == SIGBREAK)          if (is_NT_Service && sig == SIGBREAK)
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
             LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,              LDAP_LOG( CONNECTION, CRIT,
                        "slap_sig_shutdown: SIGBREAK ignored.\n" ));                      "slap_sig_shutdown: SIGBREAK ignored.\n", 0, 0, 0 );
 #else  #else
             Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: SIGBREAK ignored.\n",              Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: SIGBREAK ignored.\n",
                   0, 0, 0);                    0, 0, 0);
 #endif  #endif
         else          else
 #endif  #endif
         slapd_shutdown = sig;  #ifdef SIGHUP
           if (sig == SIGHUP && global_gentlehup && slapd_gentle_shutdown == 0)
                   slapd_gentle_shutdown = 1;
           else
   #endif
           slapd_shutdown = 1;
   
         WAKE_LISTENER(1);          WAKE_LISTENER(1);
   

Removed from v.1.211  
changed lines
  Added in v.1.211.2.11


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org