X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdaemon.c;h=f4022fc27c4be7f938cb624a53c4b80159e3138e;hb=ecfb311f8f2b4f8b8e74c0ee88b8ef572e792c99;hp=8c496ab0bc93274c4dd7c7eac0a6b6832a8a154c;hpb=1f1993989a468c70774246b6eadb246543ac6dfe;p=openldap

diff --git a/servers/slapd/daemon.c b/servers/slapd/daemon.c
index 8c496ab0bc..f4022fc27c 100644
--- a/servers/slapd/daemon.c
+++ b/servers/slapd/daemon.c
@@ -1,6 +1,6 @@
 /* $OpenLDAP$ */
 /*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 
@@ -10,13 +10,13 @@
 
 #include <ac/ctype.h>
 #include <ac/errno.h>
-#include <ac/signal.h>
 #include <ac/socket.h>
 #include <ac/string.h>
 #include <ac/time.h>
 #include <ac/unistd.h>
 
 #include "ldap_pvt.h"
+#include "ldap_pvt_thread.h"
 #include "lutil.h"
 #include "slap.h"
 
@@ -29,36 +29,24 @@ int deny_severity = LOG_NOTICE;
 
 #ifdef LDAP_PF_LOCAL
 #include <sys/stat.h>
+/* this should go in <ldap.h> as soon as it is accepted */
+#define LDAPI_MOD_URLEXT		"x-mod"
 #endif /* LDAP_PF_LOCAL */
 
-/* globals */
-time_t starttime;
-ber_socket_t dtblsize;
-
-typedef union slap_sockaddr {
-	struct sockaddr sa_addr;
-	struct sockaddr_in sa_in_addr;
 #ifdef LDAP_PF_INET6
-	struct sockaddr_in6 sa_in6_addr;
-#endif
-#ifdef LDAP_PF_LOCAL
-	struct sockaddr_un sa_un_addr;
+int slap_inet4or6 = AF_UNSPEC;
+#else
+int slap_inet4or6 = AF_INET;
 #endif
-} Sockaddr;
 
-typedef struct slap_listener {
-	char* sl_url;
-	char* sl_name;
-#ifdef HAVE_TLS
-	int		sl_is_tls;
-#endif
-	ber_socket_t		sl_sd;
-	Sockaddr sl_sa;
-#define sl_addr	sl_sa.sa_in_addr
-} Listener;
+/* globals */
+time_t starttime;
+ber_socket_t dtblsize;
 
 Listener **slap_listeners = NULL;
 
+#define SLAPD_LISTEN 10
+
 static ber_socket_t wake_sds[2];
 
 #ifdef NO_THREADS
@@ -70,23 +58,15 @@ static int waking;
 do { if (w) tcp_write( wake_sds[1], "0", 1 ); } while(0)
 #endif
 
-#ifdef HAVE_NT_SERVICE_MANAGER
-/* in nt_main.c */
-extern ldap_pvt_thread_cond_t			started_event;
-extern int	  is_NT_Service;
-#endif
-
 #ifndef HAVE_WINSOCK
-static 
+static
 #endif
-volatile sig_atomic_t slapd_shutdown = 0;
-
-static ldap_pvt_thread_t	listener_tid;
+volatile sig_atomic_t slapd_shutdown = 0, slapd_gentle_shutdown = 0;
 
 static struct slap_daemon {
 	ldap_pvt_thread_mutex_t	sd_mutex;
 
-	int sd_nactives;
+	ber_socket_t sd_nactives;
 
 #ifndef HAVE_WINSOCK
 	/* In winsock, accept() returns values higher than dtblsize
@@ -97,7 +77,110 @@ static struct slap_daemon {
 	fd_set sd_actives;
 	fd_set sd_readers;
 	fd_set sd_writers;
-} slap_daemon; 
+} slap_daemon;
+
+
+
+#ifdef HAVE_SLP
+/*
+ * SLP related functions
+ */
+#include <slp.h>
+
+#define LDAP_SRVTYPE_PREFIX "service:ldap://"
+#define LDAPS_SRVTYPE_PREFIX "service:ldaps://"
+static char** slapd_srvurls = NULL;
+static SLPHandle slapd_hslp = 0;
+
+void slapd_slp_init( const char* urls ) {
+	int i;
+
+	slapd_srvurls = ldap_str2charray( urls, " " );
+
+	if( slapd_srvurls == NULL ) return;
+
+	/* find and expand INADDR_ANY URLs */
+	for( i=0; slapd_srvurls[i] != NULL; i++ ) {
+		if( strcmp( slapd_srvurls[i], "ldap:///" ) == 0) {
+			char *host = ldap_pvt_get_fqdn( NULL );
+			if ( host != NULL ) {
+				slapd_srvurls[i] = (char *) realloc( slapd_srvurls[i],
+					strlen( host ) +
+					sizeof( LDAP_SRVTYPE_PREFIX ) );
+				strcpy( lutil_strcopy(slapd_srvurls[i],
+					LDAP_SRVTYPE_PREFIX ), host );
+
+				ch_free( host );
+			}
+
+		} else if ( strcmp( slapd_srvurls[i], "ldaps:///" ) == 0) {
+			char *host = ldap_pvt_get_fqdn( NULL );
+			if ( host != NULL ) {
+				slapd_srvurls[i] = (char *) realloc( slapd_srvurls[i],
+					strlen( host ) +
+					sizeof( LDAPS_SRVTYPE_PREFIX ) );
+				strcpy( lutil_strcopy(slapd_srvurls[i],
+					LDAPS_SRVTYPE_PREFIX ), host );
+
+				ch_free( host );
+			}
+		}
+	}
+
+	/* open the SLP handle */
+	SLPOpen( "en", 0, &slapd_hslp );
+}
+
+void slapd_slp_deinit() {
+	if( slapd_srvurls == NULL ) return;
+
+	ldap_charray_free( slapd_srvurls );
+	slapd_srvurls = NULL;
+
+	/* close the SLP handle */
+	SLPClose( slapd_hslp );
+}
+
+void slapd_slp_regreport(
+	SLPHandle hslp,
+	SLPError errcode,
+	void* cookie )
+{
+	/* empty report */
+}
+
+void slapd_slp_reg() {
+	int i;
+
+	for( i=0; slapd_srvurls[i] != NULL; i++ ) {
+		if( strncmp( slapd_srvurls[i], LDAP_SRVTYPE_PREFIX,
+				sizeof( LDAP_SRVTYPE_PREFIX ) - 1 ) == 0 ||
+		    strncmp( slapd_srvurls[i], LDAPS_SRVTYPE_PREFIX,
+				sizeof( LDAPS_SRVTYPE_PREFIX ) - 1 ) == 0 )
+		{
+			SLPReg( slapd_hslp,
+				slapd_srvurls[i],
+				SLP_LIFETIME_MAXIMUM,
+				"ldap",
+				"",
+				1,
+				slapd_slp_regreport,
+				NULL );
+		}
+	}
+}
+
+void slapd_slp_dereg() {
+	int i;
+
+	for( i=0; slapd_srvurls[i] != NULL; i++ ) {
+		SLPDereg( slapd_hslp,
+			slapd_srvurls[i],
+			slapd_slp_regreport,
+			NULL );
+	}
+}
+#endif /* HAVE_SLP */
 
 /*
  * Add a descriptor to daemon control
@@ -115,14 +198,22 @@ static void slapd_add(ber_socket_t s) {
 	}
 #endif
 
+	slap_daemon.sd_nactives++;
+
 	FD_SET( s, &slap_daemon.sd_actives );
 	FD_SET( s, &slap_daemon.sd_readers );
 
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, DETAIL1, 
+		"slapd_add: added %ld%s%s\n", (long)s,
+		FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
+		FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
+#else
 	Debug( LDAP_DEBUG_CONNS, "daemon: added %ld%s%s\n",
 		(long) s,
 	    FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 		FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
-
+#endif
 	ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 }
 
@@ -132,17 +223,25 @@ static void slapd_add(ber_socket_t s) {
 void slapd_remove(ber_socket_t s, int wake) {
 	ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 
+	slap_daemon.sd_nactives--;
+
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, DETAIL1, 
+		"slapd_remove: removing %ld%s%s\n", (long) s,
+		FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
+		FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : ""  );
+#else
 	Debug( LDAP_DEBUG_CONNS, "daemon: removing %ld%s%s\n",
 		(long) s,
 	    FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
 		FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" );
-
+#endif
 	FD_CLR( s, &slap_daemon.sd_actives );
 	FD_CLR( s, &slap_daemon.sd_readers );
 	FD_CLR( s, &slap_daemon.sd_writers );
 
 	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) {
@@ -188,42 +287,312 @@ void slapd_set_read(ber_socket_t s, int wake) {
 }
 
 static void slapd_close(ber_socket_t s) {
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, DETAIL1, "slapd_close: closing %ld\n", (long)s, 0, 0);
+#else
 	Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n",
 		(long) s, 0, 0 );
+#endif
 	tcp_close(s);
 }
 
+static void slap_free_listener_addresses(struct sockaddr **sal)
+{
+	struct sockaddr **sap;
+
+	if (sal == NULL) {
+		return;
+	}
+
+	for (sap = sal; *sap != NULL; sap++) {
+		ch_free(*sap);
+	}
+
+	ch_free(sal);
+}
+
+#ifdef LDAP_PF_LOCAL
+static int get_url_perms(
+	char 	**exts,
+	mode_t	*perms,
+	int	*crit )
+{
+	int	i;
+
+	assert( exts );
+	assert( perms );
+	assert( crit );
+
+	*crit = 0;
+	for ( i = 0; exts[ i ]; i++ ) {
+		char	*type = exts[ i ];
+		int	c = 0;
+
+		if ( type[ 0 ] == '!' ) {
+			c = 1;
+			type++;
+		}
+
+		if ( strncasecmp( type, LDAPI_MOD_URLEXT "=", sizeof(LDAPI_MOD_URLEXT "=") - 1 ) == 0 ) {
+			char 	*value = type + sizeof(LDAPI_MOD_URLEXT "=") - 1;
+			mode_t	p = 0;
+			int 	j;
+
+			if ( strlen(value) != 3 ) {
+				return LDAP_OTHER;
+			} 
+
+			for ( j = 0; j < 3; j++ ) {
+				static mode_t	m[ 3 ] 
+					= { S_IRWXU, S_IRWXG, S_IRWXO };
+
+				switch ( value[ j ] ) {
+				case 'w':
+					p |= m[ j ];
+					break;
+				case '-':
+					break;
+				default:
+					return LDAP_OTHER;
+				}
+			} 
+
+			*crit = c;
+			*perms = p;
+
+			return LDAP_SUCCESS;
+		}
+	}
+
+	return LDAP_OTHER;
+}
+#endif /* LDAP_PF_LOCAL */
+
+/* port = 0 indicates AF_LOCAL */
+static int slap_get_listener_addresses(
+	const char *host,
+	unsigned short port,
+	struct sockaddr ***sal)
+{
+	struct sockaddr **sap;
+
+#ifdef LDAP_PF_LOCAL
+	if ( port == 0 ) {
+		*sal = ch_malloc(2 * sizeof(void *));
+		if (*sal == NULL) {
+			return -1;
+		}
 
-static Listener * open_listener( const char* url )
+		sap = *sal;
+		*sap = ch_malloc(sizeof(struct sockaddr_un));
+		if (*sap == NULL)
+			goto errexit;
+		sap[1] = NULL;
+
+		if ( strlen(host) >
+		     (sizeof(((struct sockaddr_un *)*sap)->sun_path) - 1) ) {
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, INFO, 
+				"slap_get_listener_addresses: domain socket path (%s) "
+				"too long in URL\n", host, 0, 0 );
+#else
+			Debug( LDAP_DEBUG_ANY,
+			       "daemon: domain socket path (%s) too long in URL",
+			       host, 0, 0);
+#endif
+			goto errexit;
+		}
+
+		(void)memset( (void *)*sap, '\0', sizeof(struct sockaddr_un) );
+		(*sap)->sa_family = AF_LOCAL;
+		strcpy( ((struct sockaddr_un *)*sap)->sun_path, host );
+	} else
+#endif
+	{
+#ifdef HAVE_GETADDRINFO
+		struct addrinfo hints, *res, *sai;
+		int n, err;
+		char serv[7];
+
+		memset( &hints, '\0', sizeof(hints) );
+		hints.ai_flags = AI_PASSIVE;
+		hints.ai_socktype = SOCK_STREAM;
+		hints.ai_family = slap_inet4or6;
+		snprintf(serv, sizeof serv, "%d", port);
+
+		if ( (err = getaddrinfo(host, serv, &hints, &res)) ) {
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, INFO, 
+				   "slap_get_listener_addresses: getaddrinfo failed: %s\n",
+				   AC_GAI_STRERROR(err), 0, 0 );
+#else
+			Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed: %s\n",
+				AC_GAI_STRERROR(err), 0, 0);
+#endif
+			return -1;
+		}
+
+		sai = res;
+		for (n=2; (sai = sai->ai_next) != NULL; n++) {
+			/* EMPTY */ ;
+		}
+		*sal = ch_calloc(n, sizeof(void *));
+		if (*sal == NULL) {
+			return -1;
+		}
+
+		sap = *sal;
+		*sap = NULL;
+
+		for ( sai=res; sai; sai=sai->ai_next ) {
+			if( sai->ai_addr == NULL ) {
+#ifdef NEW_LOGGING
+				LDAP_LOG( CONNECTION, INFO,
+					"slap_get_listener_addresses: "
+					"getaddrinfo ai_addr is NULL?\n", 0, 0, 0 );
+#else
+				Debug( LDAP_DEBUG_ANY, "slap_get_listener_addresses: "
+					"getaddrinfo ai_addr is NULL?\n", 0, 0, 0 );
+#endif
+				freeaddrinfo(res);
+				goto errexit;
+			}
+
+			switch (sai->ai_family) {
+#  ifdef LDAP_PF_INET6
+			case AF_INET6:
+				*sap = ch_malloc(sizeof(struct sockaddr_in6));
+				if (*sap == NULL) {
+					freeaddrinfo(res);
+					goto errexit;
+				}
+				*(struct sockaddr_in6 *)*sap =
+					*((struct sockaddr_in6 *)sai->ai_addr);
+				break;
+#  endif
+			case AF_INET:
+				*sap = ch_malloc(sizeof(struct sockaddr_in));
+				if (*sap == NULL) {
+					freeaddrinfo(res);
+					goto errexit;
+				}
+				*(struct sockaddr_in *)*sap =
+					*((struct sockaddr_in *)sai->ai_addr);
+				break;
+			default:
+				*sap = NULL;
+				break;
+			}
+
+			if (*sap != NULL) {
+				(*sap)->sa_family = sai->ai_family;
+				sap++;
+				*sap = NULL;
+			}
+		}
+
+		freeaddrinfo(res);
+#else
+		int i, n = 1;
+		struct in_addr in;
+		struct hostent *he = NULL;
+
+		if ( host == NULL ) {
+			in.s_addr = htonl(INADDR_ANY);
+
+		} else if ( !inet_aton( host, &in ) ) {
+			he = gethostbyname( host );
+			if( he == NULL ) {
+#ifdef NEW_LOGGING
+				LDAP_LOG( CONNECTION, INFO, 
+					"slap_get_listener_addresses: invalid host %s\n", host, 0, 0 );
+#else
+				Debug( LDAP_DEBUG_ANY,
+				       "daemon: invalid host %s", host, 0, 0);
+#endif
+				return -1;
+			}
+			for (n = 0; he->h_addr_list[n]; n++) ;
+		}
+
+		*sal = ch_malloc((n+1) * sizeof(void *));
+		if (*sal == NULL) {
+			return -1;
+		}
+
+		sap = *sal;
+		for ( i = 0; i<n; i++ ) {
+			sap[i] = ch_malloc(sizeof(struct sockaddr_in));
+			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[i] = NULL;
+#endif
+	}
+
+	return 0;
+
+errexit:
+	slap_free_listener_addresses(*sal);
+	return -1;
+}
+
+static int slap_open_listener(
+	const char* url,
+	int *listeners,
+	int *cur
+	)
 {
-	int	tmp, rc;
+	int	num, tmp, rc;
 	Listener l;
 	Listener *li;
 	LDAPURLDesc *lud;
-	char *s;
-	int port;
-#ifdef HAVE_GETADDRINFO
-	char serv[7];
-	struct addrinfo hints, *res, *sai;
-	int err;
+	unsigned short port;
+	int err, addrlen = 0;
+	struct sockaddr **sal, **psal;
+	int socktype = SOCK_STREAM;	/* default to COTS */
+
+#ifdef LDAP_PF_LOCAL
+	mode_t 	perms = S_IRWXU;
+	int	crit = 1;
 #endif
 
 	rc = ldap_url_parse( url, &lud );
 
 	if( rc != LDAP_URL_SUCCESS ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, ERR, 
+			"slap_open_listener: listen URL \"%s\" parse error %d\n",
+			url, rc , 0 );
+#else
 		Debug( LDAP_DEBUG_ANY,
 			"daemon: listen URL \"%s\" parse error=%d\n",
 			url, rc, 0 );
-		return NULL;
+#endif
+		return rc;
 	}
 
 #ifndef HAVE_TLS
 	if( ldap_pvt_url_scheme2tls( lud->lud_scheme ) ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, INFO, 
+			   "slap_open_listener: TLS is not supported (%s)\n", url, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_ANY,
 			"daemon: TLS not supported (%s)\n",
 			url, 0, 0 );
+#endif
 		ldap_free_urldesc( lud );
-		return NULL;
+		return -1;
 	}
 
 	if(! lud->lud_port ) {
@@ -238,315 +607,268 @@ static Listener * open_listener( const char* url )
 	}
 #endif
 
-#ifdef HAVE_GETADDRINFO
-	memset( &hints, '\0', sizeof(hints) );
-	hints.ai_flags = AI_PASSIVE;
-	hints.ai_family = AF_UNSPEC;
-	hints.ai_socktype = SOCK_STREAM;
+	port = (unsigned short) lud->lud_port;
 
-#  ifdef LDAP_PF_LOCAL
-	if ( ldap_pvt_url_scheme2proto(lud->lud_scheme) == LDAP_PROTO_IPC ) {
+	tmp = ldap_pvt_url_scheme2proto(lud->lud_scheme);
+	if ( tmp == LDAP_PROTO_IPC ) {
+#ifdef LDAP_PF_LOCAL
 		if ( lud->lud_host == NULL || lud->lud_host[0] == '\0' ) {
-			err = getaddrinfo(NULL, LDAPI_SOCK, &hints, &res);
-			if (!err)
-				unlink( LDAPI_SOCK );
+			err = slap_get_listener_addresses(LDAPI_SOCK, 0, &sal);
 		} else {
-			err = getaddrinfo(NULL, lud->lud_host, &hints, &res);
-			if (!err)
-				unlink( lud->lud_host );
+			err = slap_get_listener_addresses(lud->lud_host, 0, &sal);
 		}
-	} else
-#  endif /* LDAP_PF_LOCAL */
-	{
-		snprintf(serv, sizeof serv, "%d", lud->lud_port);
+
+		if ( lud->lud_exts ) {
+			err = get_url_perms( lud->lud_exts, &perms, &crit );
+		}
+#else
+
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, INFO, 
+			"slap_open_listener: URL scheme is not supported: %s\n", url, 0, 0 );
+#else
+		Debug( LDAP_DEBUG_ANY, "daemon: URL scheme not supported: %s",
+			url, 0, 0);
+#endif
+		ldap_free_urldesc( lud );
+		return -1;
+#endif
+	} else {
+#ifdef LDAP_CONNECTIONLESS
+		l.sl_is_udp = ( tmp == LDAP_PROTO_UDP );
+#endif
 		if( lud->lud_host == NULL || lud->lud_host[0] == '\0'
 			|| strcmp(lud->lud_host, "*") == 0 )
 		{
-			err = getaddrinfo(NULL, serv, &hints, &res);
+			err = slap_get_listener_addresses(NULL, port, &sal);
 		} else {
-			err = getaddrinfo(lud->lud_host, serv, &hints, &res);
+			err = slap_get_listener_addresses(lud->lud_host, port, &sal);
 		}
 	}
 
+	ldap_free_urldesc( lud );
 	if ( err ) {
-		Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed\n", 0, 0, 0);
-		ldap_free_urldesc( lud );
-		return NULL;
+		return -1;
 	}
 
-	ldap_free_urldesc( lud );
-	sai = res;
-	do {
-		l.sl_sd = socket( sai->ai_family, sai->ai_socktype, sai->ai_protocol);
+	/* 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;
+	while ( *sal != NULL ) {
+		switch( (*sal)->sa_family ) {
+		case AF_INET:
+#ifdef LDAP_PF_INET6
+		case AF_INET6:
+#endif
+#ifdef LDAP_PF_LOCAL
+		case AF_LOCAL:
+#endif
+			break;
+		default:
+			sal++;
+			continue;
+		}
+#ifdef LDAP_CONNECTIONLESS
+		if (l.sl_is_udp)
+		    socktype = SOCK_DGRAM;
+#endif
+		l.sl_sd = socket( (*sal)->sa_family, socktype, 0);
 		if ( l.sl_sd == AC_SOCKET_INVALID ) {
 			int err = sock_errno();
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, ERR, 
+				"slap_open_listener: socket() failed errno=%d (%s)\n",
+				err, sock_errstr(err), 0 );
+#else
 			Debug( LDAP_DEBUG_ANY,
 				"daemon: socket() failed errno=%d (%s)\n", err,
 				sock_errstr(err), 0 );
+#endif
+			sal++;
 			continue;
 		}
-
-		if ( sai->ai_family != AF_LOCAL ) {
+#ifndef HAVE_WINSOCK
+		if ( l.sl_sd >= dtblsize ) {
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, ERR, 
+				"slap_open_listener: listener descriptor %ld is too "
+				"great %ld\n", (long)l.sl_sd, (long)dtblsize, 0 );
 #else
-
-	if ( ldap_pvt_url_scheme2proto(lud->lud_scheme) == LDAP_PROTO_IPC ) {
-#ifdef LDAP_PF_LOCAL
-		port = 0;
-		(void) memset( (void *)&l.sl_sa.sa_un_addr, '\0', sizeof(l.sl_sa.sa_un_addr) );
-
-		l.sl_sa.sa_un_addr.sun_family = AF_LOCAL;
-
-		/* hack: overload the host to be the path */
-		if ( lud->lud_host == NULL || lud->lud_host[0] == '\0' ) {
-			strcpy( l.sl_sa.sa_un_addr.sun_path, LDAPI_SOCK );
-		} else {
-			if ( strlen(lud->lud_host) > (sizeof(l.sl_sa.sa_un_addr.sun_path) - 1) ) {
-				Debug( LDAP_DEBUG_ANY,
-					"daemon: domain socket path (%s) too long in URL: %s",
-					lud->lud_host, url, 0);
-				ldap_free_urldesc( lud );
-				return NULL;
-			}
-			strcpy( l.sl_sa.sa_un_addr.sun_path, lud->lud_host );
+			Debug( LDAP_DEBUG_ANY,
+			       "daemon: listener descriptor %ld is too great %ld\n",
+			       (long) l.sl_sd, (long) dtblsize, 0 );
+#endif
+			tcp_close( l.sl_sd );
+			sal++;
+			continue;
 		}
-		unlink( l.sl_sa.sa_un_addr.sun_path ); 
-#if 0
-		/* I don't think we need to set this. */
-		l.sl_sa.sa_un_addr.sun_len = sizeof( l.sl_sa.sa_un_addr.sun_len ) +
-			sizeof( l.sl_sa.sa_un_addr.sun_family ) +
-			strlen( l.sl_sa.sa_un_addr.sun_path ) + 1;
 #endif
+#ifdef LDAP_PF_LOCAL
+		if ( (*sal)->sa_family == AF_LOCAL ) {
+			unlink ( ((struct sockaddr_un *)*sal)->sun_path );
+		} else
+#endif
+		{
+#ifdef SO_REUSEADDR
+			/* enable address reuse */
+			tmp = 1;
+			rc = setsockopt( l.sl_sd, SOL_SOCKET, SO_REUSEADDR,
+					 (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, SO_REUSEADDR ) "
+					"failed errno %d (%s)\n", (long)l.sl_sd, err, 
+					sock_errstr(err) );
 #else
-		Debug( LDAP_DEBUG_ANY, "daemon: URL scheme not supported: %s",
-			url, 0, 0);
-		ldap_free_urldesc( lud );
-		return NULL;
-#endif /* LDAP_PF_LOCAL */
-	} else {
-
-	port = lud->lud_port;
-
-	(void) memset( (void*) &l.sl_addr, '\0', sizeof(l.sl_addr) );
-
-	l.sl_addr.sin_family = AF_INET;
-	l.sl_addr.sin_port = htons( (unsigned short) lud->lud_port );
-
-	if( lud->lud_host == NULL || lud->lud_host[0] == '\0'
-		|| strcmp(lud->lud_host, "*") == 0 )
-	{
-		l.sl_addr.sin_addr.s_addr = htonl(INADDR_ANY);
-
-	} else {
-		/* host or address was specified */
-		if( !inet_aton( lud->lud_host, &l.sl_addr.sin_addr ) ) {
-			struct hostent *he = gethostbyname( lud->lud_host );
-			if( he == NULL ) {
 				Debug( LDAP_DEBUG_ANY,
-					"daemon: invalid host (%s) in URL: %s",
-					lud->lud_host, url, 0);
-				ldap_free_urldesc( lud );
-				return NULL;
+				       "slapd(%ld): setsockopt(SO_REUSEADDR) failed errno=%d (%s)\n",
+				       (long) l.sl_sd, err, sock_errstr(err) );
+#endif
 			}
-
-			memcpy( &l.sl_addr.sin_addr, he->h_addr,
-			       sizeof( l.sl_addr.sin_addr ) );
+#endif
 		}
-	}
-	}
 
-	ldap_free_urldesc( lud );
-
-	l.sl_sd = socket( l.sl_sa.sa_addr.sa_family, SOCK_STREAM, 0 );
-	if ( l.sl_sd == AC_SOCKET_INVALID ) {
-		int err = sock_errno();
-		Debug( LDAP_DEBUG_ANY,
-			"daemon: socket() failed errno=%d (%s)\n", err,
-			sock_errstr(err), 0 );
-		return NULL;
-	}
-
-#ifndef HAVE_WINSOCK
-	if ( l.sl_sd >= dtblsize ) {
-		Debug( LDAP_DEBUG_ANY,
-			"daemon: listener descriptor %ld is too great %ld\n",
-			(long) l.sl_sd, (long) dtblsize, 0 );
-		tcp_close( l.sl_sd );
-		return NULL;
-	}
+		switch( (*sal)->sa_family ) {
+		case AF_INET:
+			addrlen = sizeof(struct sockaddr_in);
+			break;
+#ifdef LDAP_PF_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
-
-#ifdef LDAP_PF_LOCAL
-	/* for IP sockets only */
-	if ( l.sl_sa.sa_addr.sa_family == AF_INET ) {
-#endif /* LDAP_PF_LOCAL */
-#endif /* HAVE_GETADDRINFO */
-
-#ifdef SO_REUSEADDR
-	/* enable address reuse */
-	tmp = 1;
-	rc = setsockopt( l.sl_sd, SOL_SOCKET, SO_REUSEADDR,
-		(char *) &tmp, sizeof(tmp) );
-	if ( rc == AC_SOCKET_ERROR ) {
-		int err = sock_errno();
-		Debug( LDAP_DEBUG_ANY,
-	       "slapd(%ld): setsockopt(SO_REUSEADDR) failed errno=%d (%s)\n",
-	    	(long) l.sl_sd, err, sock_errstr(err) );
-	}
+			}
 #endif
-#ifdef SO_KEEPALIVE
-	/* enable keep alives */
-	tmp = 1;
-	rc = setsockopt( l.sl_sd, SOL_SOCKET, SO_KEEPALIVE,
-		(char *) &tmp, sizeof(tmp) );
-	if ( rc == AC_SOCKET_ERROR ) {
-		int err = sock_errno();
-		Debug( LDAP_DEBUG_ANY,
-			"slapd(%ld): setsockopt(SO_KEEPALIVE) failed errno=%d (%s)\n",
-	    	(long) l.sl_sd, err, sock_errstr(err) );
-	}
+			addrlen = sizeof(struct sockaddr_in6);
+			break;
 #endif
-#ifdef TCP_NODELAY
-	/* enable no delay */
-	tmp = 1;
-	rc = setsockopt( l.sl_sd, IPPROTO_TCP, TCP_NODELAY,
-		(char *)&tmp, sizeof(tmp) );
-	if ( rc == AC_SOCKET_ERROR ) {
-		int err = sock_errno();
-		Debug( LDAP_DEBUG_ANY,
-			"slapd(%ld): setsockopt(TCP_NODELAY) failed errno=%d (%s)\n",
-	    	(long) l.sl_sd, err, sock_errstr(err) );
-	}
+#ifdef LDAP_PF_LOCAL
+		case AF_LOCAL:
+			addrlen = sizeof(struct sockaddr_un);
+			break;
 #endif
+		}
 
-#ifdef HAVE_GETADDRINFO
-		} /* sai->ai_family != AF_LOCAL */
-		if (!bind(l.sl_sd, sai->ai_addr, sai->ai_addrlen))
-			break;
-		err = sock_errno();
+		if (bind(l.sl_sd, *sal, addrlen)) {
+			err = sock_errno();
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, INFO, 
+			"slap_open_listener: bind(%ld) failed errno=%d (%s)\n",
+			(long)l.sl_sd, err, sock_errstr(err) );
+#else
 		Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno=%d (%s)\n",
-			(long) l.sl_sd, err, sock_errstr(err) );
-		tcp_close( l.sl_sd );
-	} while ((sai = sai->ai_next) != NULL);
-
-	if (!sai) {
-		Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed\n",
-			(long) l.sl_sd, 0, 0 );
-		return NULL;
-	}
+		       (long) l.sl_sd, err, sock_errstr(err) );
+#endif
+			tcp_close( l.sl_sd );
+			sal++;
+			continue;
+		}
 
-	switch ( sai->ai_family ) {
-#  ifdef LDAP_PF_LOCAL
-	case AF_LOCAL:
-		if ( chmod( (char *)sai->ai_addr, S_IRWXU ) < 0 ) {
+	switch ( (*sal)->sa_family ) {
+#ifdef LDAP_PF_LOCAL
+	case AF_LOCAL: {
+		char *addr = ((struct sockaddr_un *)*sal)->sun_path;
+		if ( chmod( addr, perms ) < 0 && crit ) {
 			int err = sock_errno();
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, INFO, 
+				"slap_open_listener: fchmod(%ld) failed errno=%d (%s)\n",
+				(long)l.sl_sd, err, sock_errstr(err) );
+#else
 			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
 			tcp_close( l.sl_sd );
-			return NULL;
+			slap_free_listener_addresses(psal);
+			return -1;
 		}
-		l.sl_name = ch_malloc( strlen((char *)sai->ai_addr) + sizeof("PATH=") );
-		sprintf( l.sl_name, "PATH=%s", sai->ai_addr );
-		break;
-#  endif /* LDAP_PF_LOCAL */
+		l.sl_name = ch_malloc( strlen(addr) + sizeof("PATH=") );
+		sprintf( l.sl_name, "PATH=%s", addr );
+	} break;
+#endif /* LDAP_PF_LOCAL */
 
 	case AF_INET: {
+		char *s;
+#if defined( HAVE_GETADDRINFO ) && defined( HAVE_INET_NTOP )
 		char addr[INET_ADDRSTRLEN];
-		inet_ntop( AF_INET,
-			&((struct sockaddr_in *)sai->ai_addr)->sin_addr,
-			addr, sizeof(addr) );
-		l.sl_name = ch_malloc( strlen(addr) + strlen(serv) + sizeof("IP=:") );
-		sprintf( l.sl_name, "IP=%s:%s", addr, serv );
+		inet_ntop( AF_INET, &((struct sockaddr_in *)*sal)->sin_addr,
+			   addr, sizeof(addr) );
+		s = addr;
+#else
+		s = inet_ntoa( ((struct sockaddr_in *) *sal)->sin_addr );
+#endif
+		port = ntohs( ((struct sockaddr_in *)*sal) ->sin_port );
+		l.sl_name = ch_malloc( sizeof("IP=255.255.255.255:65535") );
+		sprintf( l.sl_name, "IP=%s:%d",
+			 s != NULL ? s : "unknown" , port );
 	} break;
 
-#  ifdef LDAP_PF_INET6
+#ifdef LDAP_PF_INET6
 	case AF_INET6: {
 		char addr[INET6_ADDRSTRLEN];
-		inet_ntop( AF_INET6,
-			&((struct sockaddr_in6 *)sai->ai_addr)->sin6_addr,
-			addr, sizeof addr);
-		l.sl_name = ch_malloc( strlen(addr) + strlen(serv) + sizeof("IP= ") );
-		sprintf( l.sl_name, "IP=%s %s", addr, serv );
+		inet_ntop( AF_INET6, &((struct sockaddr_in6 *)*sal)->sin6_addr,
+			   addr, sizeof addr);
+		port = ntohs( ((struct sockaddr_in6 *)*sal)->sin6_port );
+		l.sl_name = ch_malloc( strlen(addr) + sizeof("IP= 65535") );
+		sprintf( l.sl_name, "IP=%s %d", addr, port );
 	} break;
-#  endif /* LDAP_PF_INET6 */
+#endif /* LDAP_PF_INET6 */
 
 	default:
-		Debug( LDAP_DEBUG_ANY, "daemon: unsupported address family (%d)\n",
-			(int) sai->ai_family, 0, 0 );
-		break;
-	}
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, INFO, 
+			"slap_open_listener: unsupported address family (%d)\n",
+			(int)(*sal)->sa_family, 0, 0 );
 #else
-#ifdef LDAP_PF_LOCAL
-	/* close conditional */
-	}
-#endif /* LDAP_PF_LOCAL */
-
-	switch ( l.sl_sa.sa_addr.sa_family ) {
-#ifdef LDAP_PF_LOCAL
-		case AF_LOCAL:
-			rc = bind( l.sl_sd, (struct sockaddr *)&l.sl_sa,
-				sizeof(l.sl_sa.sa_un_addr) );
-			break;
+		Debug( LDAP_DEBUG_ANY, "daemon: unsupported address family (%d)\n",
+			(int) (*sal)->sa_family, 0, 0 );
 #endif
-
-		case AF_INET:
-			rc = bind( l.sl_sd, (struct sockaddr *)&l.sl_sa,
-				sizeof(l.sl_sa.sa_in_addr) );
-			break;
-
-		default:
-			rc = AC_SOCKET_ERROR;
-			errno = EINVAL;
-			break;
-	}
-
-	if ( rc == AC_SOCKET_ERROR ) {
-		int err = sock_errno();
-		Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno=%d (%s)\n",
-	    	(long) l.sl_sd, err, sock_errstr(err) );
-		tcp_close( l.sl_sd );
-		return NULL;
-	}
-
-	switch ( l.sl_sa.sa_addr.sa_family ) {
-#ifdef LDAP_PF_LOCAL
-		case AF_LOCAL:
-			if ( chmod( l.sl_sa.sa_un_addr.sun_path, S_IRWXU ) < 0 ) {
-				int err = sock_errno();
-				Debug( LDAP_DEBUG_ANY,
-					"daemon: chmod(%ld) failed errno=%d (%s)",
-					(long) l.sl_sd, err, sock_errstr(err) );
-				tcp_close( l.sl_sd );
-				return NULL;
-			}
-
-			l.sl_name = ch_malloc( strlen(l.sl_sa.sa_un_addr.sun_path)
-				+ sizeof("PATH=") );
-			sprintf( l.sl_name, "PATH=%s", l.sl_sa.sa_un_addr.sun_path );
-			break;
-#endif /* LDAP_PF_LOCAL */
-
-		case AF_INET:
-			l.sl_name = ch_malloc( sizeof("IP=255.255.255.255:65336") );
-			s = inet_ntoa( l.sl_addr.sin_addr );
-			sprintf( l.sl_name, "IP=%s:%d",
-				s != NULL ? s : "unknown" , port );
-			break;
-
-		default:
-			l.sl_name = ch_strdup( "UNKNOWN" );
-			break;
+		break;
 	}
 
-#endif /* HAVE_GETADDRINFO */
-
+	AC_MEMCPY(&l.sl_sa, *sal, addrlen);
 	l.sl_url = ch_strdup( url );
 	li = ch_malloc( sizeof( Listener ) );
 	*li = l;
+	slap_listeners[*cur] = li;
+	(*cur)++;
+	sal++;
+
+	} /* while ( *sal != NULL ) */
+
+	slap_free_listener_addresses(psal);
+
 
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, RESULTS, 
+			"slap_open_listener: daemon initialzed %s\n", l.sl_url, 0, 0 );
+#else
 	Debug( LDAP_DEBUG_TRACE, "daemon: initialized %s\n",
 		l.sl_url, 0, 0 );
-
-	return li;
+#endif
+	return 0;
 }
 
 static int sockinit(void);
@@ -554,12 +876,16 @@ static int sockdestroy(void);
 
 int slapd_daemon_init( const char *urls )
 {
-	int i, rc;
+	int i, j, n, rc;
 	char **u;
 
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, ARGS, 
+		"slapd_daemon_init: %s\n", urls ? urls : "<null>", 0, 0 );
+#else
 	Debug( LDAP_DEBUG_ARGS, "daemon_init: %s\n",
 		urls ? urls : "<null>", 0, 0 );
-
+#endif
 	if( (rc = sockinit()) != 0 ) {
 		return rc;
 	}
@@ -584,8 +910,13 @@ int slapd_daemon_init( const char *urls )
 	 * this byte arrives.
 	 */
 	if( (rc = lutil_pair( wake_sds )) < 0 ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, ERR, 
+			"slap_daemon_init: lutil_pair() failed rc=%d\n", rc, 0, 0);
+#else
 		Debug( LDAP_DEBUG_ANY,
 			"daemon: lutil_pair() failed rc=%d\n", rc, 0, 0 );
+#endif
 		return rc;
 	}
 
@@ -596,46 +927,72 @@ int slapd_daemon_init( const char *urls )
 		urls = "ldap:///";
 	}
 
-	u = str2charray( urls, " " );
+	u = ldap_str2charray( urls, " " );
 
 	if( u == NULL || u[0] == NULL ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, ERR, 
+			"slap_daemon_init: no urls (%s) provided.\n", urls, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_ANY, "daemon_init: no urls (%s) provided.\n",
 			urls, 0, 0 );
-
+#endif
 		return -1;
 	}
 
 	for( i=0; u[i] != NULL; i++ ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, DETAIL1, 
+			"slap_daemon_init: listen on %s\n.", u[i], 0, 0 );
+#else
 		Debug( LDAP_DEBUG_TRACE, "daemon_init: listen on %s\n",
 			u[i], 0, 0 );
+#endif
 	}
 
 	if( i == 0 ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, INFO, 
+			 "slap_daemon_init: no listeners to open (%s)\n", urls, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_ANY, "daemon_init: no listeners to open (%s)\n",
 			urls, 0, 0 );
-		charray_free( u );
+#endif
+		ldap_charray_free( u );
 		return -1;
 	}
 
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, INFO, 
+		"slap_daemon_init: %d listeners to open...\n", i, 0, 0 );
+#else
 	Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners to open...\n",
 		i, 0, 0 );
-
+#endif
 	slap_listeners = ch_malloc( (i+1)*sizeof(Listener *) );
 
-	for(i = 0; u[i] != NULL; i++ ) {
-		slap_listeners[i] = open_listener( u[i] );
-
-		if( slap_listeners[i] == NULL ) {
-			charray_free( u );
+	for(n = 0, j = 0; u[n]; n++ ) {
+		if ( slap_open_listener( u[n], &i, &j ) ) {
+			ldap_charray_free( u );
 			return -1;
 		}
 	}
-	slap_listeners[i] = NULL;
+	slap_listeners[j] = NULL;
 
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, DETAIL1, 
+		"slap_daemon_init: %d listeners opened\n", i, 0, 0 );
+#else
 	Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners opened\n",
 		i, 0, 0 );
+#endif
+
+#ifdef HAVE_SLP
+	slapd_slp_init( urls );
+	slapd_slp_reg();
+#endif
 
-	charray_free( u );
+	ldap_charray_free( u );
 	ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
 	return !i;
 }
@@ -648,29 +1005,120 @@ slapd_daemon_destroy(void)
 	tcp_close( wake_sds[1] );
 	tcp_close( wake_sds[0] );
 	sockdestroy();
+
+#ifdef HAVE_SLP
+	slapd_slp_dereg();
+	slapd_slp_deinit();
+#endif
+
 	return 0;
 }
 
 
+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 *
 slapd_daemon_task(
 	void *ptr
 )
 {
 	int l;
-	time_t	last_idle_check = slap_get_time();
+	time_t	last_idle_check = 0;
 	time( &starttime );
 
+	if ( global_idletimeout > 0 ) {
+		last_idle_check = slap_get_time();
+	}
 	for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 		if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
 			continue;
+#ifdef LDAP_CONNECTIONLESS
+		/* Since this is connectionless, the data port is the
+		 * listening port. The listen() and accept() calls
+		 * are unnecessary.
+		 */
+		if ( slap_listeners[l]->sl_is_udp )
+		{
+			slapd_add( slap_listeners[l]->sl_sd );
+			continue;
+		}
+#endif
 
-		if ( listen( slap_listeners[l]->sl_sd, 5 ) == -1 ) {
+		if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN ) == -1 ) {
 			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
+			LDAP_LOG( CONNECTION, ERR, 
+				"slapd_daemon_task: listen( %s, 5 ) failed errno=%d (%s)\n",
+				slap_listeners[l]->sl_url, err, sock_errstr(err) );
+#else
 			Debug( LDAP_DEBUG_ANY,
 				"daemon: listen(%s, 5) failed errno=%d (%s)\n",
 					slap_listeners[l]->sl_url, err,
 					sock_errstr(err) );
+#endif
 			return( (void*)-1 );
 		}
 
@@ -689,11 +1137,12 @@ slapd_daemon_task(
 		int ns;
 		int at;
 		ber_socket_t nfds;
-#define SLAPD_EBADF_LIMIT 10
+#define SLAPD_EBADF_LIMIT 16
 		int ebadf = 0;
+		int emfile = 0;
 
 #define SLAPD_IDLE_CHECK_LIMIT 4
-		time_t	now = slap_get_time();
+		time_t	now;
 
 
 		fd_set			readfds;
@@ -701,17 +1150,42 @@ slapd_daemon_task(
 		Sockaddr		from;
 
 #if defined(SLAPD_RLOOKUPS)
-        struct hostent		*hp;
+		struct hostent		*hp;
 #endif
 		struct timeval		zero;
 		struct timeval		*tvp;
 
-		if( global_idletimeout > 0 && difftime(
-			last_idle_check+global_idletimeout/SLAPD_IDLE_CHECK_LIMIT,
-			now ) < 0 )
-		{
-			connections_timeout_idle(now);
+		if( emfile ) {
+			now = slap_get_time();
+			connections_timeout_idle( now );
+		}
+		else if ( global_idletimeout > 0 ) {
+			now = slap_get_time();
+			if ( difftime( last_idle_check+global_idletimeout/SLAPD_IDLE_CHECK_LIMIT, now ) < 0 ) {
+				connections_timeout_idle( now );
+			}
+		}
+
+#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( &readfds );
@@ -731,8 +1205,8 @@ slapd_daemon_task(
 			}
 		}
 #else
-		memcpy( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
-		memcpy( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
+		AC_MEMCPY( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
+		AC_MEMCPY( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
 #endif
 		assert(!FD_ISSET(wake_sds[0], &readfds));
 		FD_SET( wake_sds[0], &readfds );
@@ -764,10 +1238,17 @@ slapd_daemon_task(
 			if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
 				continue;
 
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, DETAIL1, 
+				"slapd_daemon_task: select: listen=%d "
+				"active_threads=%d tvp=%s\n",
+				slap_listeners[l]->sl_sd, at, tvp == NULL ? "NULL" : "zero" );
+#else
 			Debug( LDAP_DEBUG_CONNS,
 				"daemon: select: listen=%d active_threads=%d tvp=%s\n",
 					slap_listeners[l]->sl_sd, at,
 					tvp == NULL ? "NULL" : "zero" );
+#endif
 		}
 
 		switch(ns = select( nfds, &readfds,
@@ -782,9 +1263,10 @@ slapd_daemon_task(
 		case -1: {	/* failure - try again */
 				int err = sock_errno();
 
-				if( err == EBADF 
-#ifdef HAVE_WINSOCK
-					|| err == WSAENOTSOCK	/* you'd think this would be EBADF */
+				if( err == EBADF
+#ifdef WSAENOTSOCK
+					/* you'd think this would be EBADF */
+					|| err == WSAENOTSOCK
 #endif
 				) {
 					if (++ebadf < SLAPD_EBADF_LIMIT)
@@ -792,26 +1274,43 @@ slapd_daemon_task(
 				}
 
 				if( err != EINTR ) {
+#ifdef NEW_LOGGING
+					LDAP_LOG( CONNECTION, INFO, 
+						"slapd_daemon_task: select failed (%d): %s\n",
+						err, sock_errstr(err), 0 );
+#else
 					Debug( LDAP_DEBUG_CONNS,
 						"daemon: select failed (%d): %s\n",
 						err, sock_errstr(err), 0 );
-
-					slapd_shutdown = -1;
+#endif
+					slapd_shutdown = 2;
 				}
 			}
 			continue;
 
 		case 0:		/* timeout - let threads run */
 			ebadf = 0;
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, DETAIL2,
+				   "slapd_daemon_task: select timeout - yielding\n", 0, 0, 0 );
+#else
 			Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
 			    0, 0, 0 );
-	     	ldap_pvt_thread_yield();
+#endif
+			ldap_pvt_thread_yield();
 			continue;
 
 		default:	/* something happened - deal with it */
+			if( slapd_shutdown ) continue;
+
 			ebadf = 0;
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, DETAIL2, 
+				   "slapd_daemon_task: activity on %d descriptors\n", ns, 0, 0 );
+#else
 			Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
 				ns, 0, 0 );
+#endif
 			/* FALL THRU */
 		}
 
@@ -825,11 +1324,13 @@ slapd_daemon_task(
 		}
 
 		for ( l = 0; slap_listeners[l] != NULL; l++ ) {
-			ber_int_t s;
+			ber_socket_t s;
 			socklen_t len = sizeof(from);
 			long id;
+			slap_ssf_t ssf = 0;
+			char *authid = NULL;
 
-			char	*dnsname;
+			char	*dnsname = NULL;
 			char	*peeraddr;
 #ifdef LDAP_PF_LOCAL
 			char	peername[MAXPATHLEN + sizeof("PATH=")];
@@ -847,70 +1348,185 @@ slapd_daemon_task(
 			if ( !FD_ISSET( slap_listeners[l]->sl_sd, &readfds ) )
 				continue;
 
-			if ( (s = accept( slap_listeners[l]->sl_sd,
-				(struct sockaddr *) &from, &len )) == AC_SOCKET_INVALID )
+#ifdef LDAP_CONNECTIONLESS
+			if ( slap_listeners[l]->sl_is_udp )
 			{
-				int err = sock_errno();
-				Debug( LDAP_DEBUG_ANY,
-				    "daemon: accept(%ld) failed errno=%d (%s)\n",
-				    (long) slap_listeners[l]->sl_sd, err,
-				    sock_errstr(err) );
+			/* The first time we receive a query, we set this
+			 * up as a "connection". It remains open for the life
+			 * of the slapd.
+			 */
+				if ( slap_listeners[l]->sl_is_udp < 2 )
+				{
+				    id = connection_init(
+				    	slap_listeners[l]->sl_sd,
+					slap_listeners[l]->sl_url, "", "",
+					slap_listeners[l]->sl_name,
+					2, ssf, authid );
+				    slap_listeners[l]->sl_is_udp++;
+				}
 				continue;
 			}
+#endif
 
-#ifdef LDAP_DEBUG
-			ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
-
-			/* newly accepted stream should not be in any of the FD SETS */
+			s = accept( slap_listeners[l]->sl_sd,
+				(struct sockaddr *) &from, &len );
+			if ( s == AC_SOCKET_INVALID ) {
+				int err = sock_errno();
 
-			assert( !FD_ISSET( s, &slap_daemon.sd_actives) );
-			assert( !FD_ISSET( s, &slap_daemon.sd_readers) );
-			assert( !FD_ISSET( s, &slap_daemon.sd_writers) );
+#ifdef EMFILE
+				if( err == EMFILE ) {
+					emfile++;
+				} else
+#endif
+#ifdef ENFILE
+				if( err == ENFILE ) {
+					emfile++;
+				} else 
+#endif
+				{
+					emfile=0;
+				}
 
-			ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
+				if( emfile < 3 ) {
+#ifdef NEW_LOGGING
+					LDAP_LOG( CONNECTION, ERR, 
+						"slapd_daemon_task: accept(%ld) failed errno=%d (%s)\n",
+						(long)slap_listeners[l]->sl_sd, 
+						err, sock_errstr(err) );
+#else
+					Debug( LDAP_DEBUG_ANY,
+					    "daemon: accept(%ld) failed errno=%d (%s)\n",
+					    (long) slap_listeners[l]->sl_sd, err,
+					    sock_errstr(err) );
 #endif
+				} else {
+					/* prevent busy loop */
+#  ifdef HAVE_USLEEP
+					if( emfile % 4 == 3 ) usleep( 250 );
+#  else
+					if( emfile % 8 == 7 ) sleep( 1 );
+#  endif
+				}
+
+				ldap_pvt_thread_yield();
+				continue;
+			}
+			emfile = 0;
 
 #ifndef HAVE_WINSOCK
 			/* make sure descriptor number isn't too great */
 			if ( s >= dtblsize ) {
+#ifdef NEW_LOGGING
+				LDAP_LOG( CONNECTION, ERR, 
+				   "slapd_daemon_task: %ld beyond descriptor table size %ld\n",
+				   (long)s, (long)dtblsize, 0 );
+#else
 				Debug( LDAP_DEBUG_ANY,
 					"daemon: %ld beyond descriptor table size %ld\n",
 					(long) s, (long) dtblsize, 0 );
+#endif
+
 				slapd_close(s);
+				ldap_pvt_thread_yield();
 				continue;
 			}
 #endif
-		   
-			Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
-				(long) s, 0, 0 );
 
-			len = sizeof(from);
+#ifdef LDAP_DEBUG
+			ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 
-			if ( getpeername( s, (struct sockaddr *) &from, &len ) != 0 ) {
-				int err = sock_errno();
-				Debug( LDAP_DEBUG_ANY,
-					"daemon: getpeername( %ld ) failed: errno=%d (%s)\n",
-					(long) s, err, sock_errstr(err) );
-				slapd_close(s);
-				continue;
+			/* newly accepted stream should not be in any of the FD SETS */
+			assert( !FD_ISSET( s, &slap_daemon.sd_actives) );
+			assert( !FD_ISSET( s, &slap_daemon.sd_readers) );
+			assert( !FD_ISSET( s, &slap_daemon.sd_writers) );
+
+			ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
+#endif
+
+#if defined( SO_KEEPALIVE ) || defined( TCP_NODELAY )
+#ifdef LDAP_PF_LOCAL
+			/* for IPv4 and IPv6 sockets only */
+			if ( from.sa_addr.sa_family != AF_LOCAL )
+#endif /* LDAP_PF_LOCAL */
+			{
+				int rc;
+				int tmp;
+#ifdef SO_KEEPALIVE
+				/* enable keep alives */
+				tmp = 1;
+				rc = setsockopt( s, SOL_SOCKET, SO_KEEPALIVE,
+					(char *) &tmp, sizeof(tmp) );
+				if ( rc == AC_SOCKET_ERROR ) {
+					int err = sock_errno();
+#ifdef NEW_LOGGING
+					LDAP_LOG( CONNECTION, ERR, 
+						"slapd_daemon_task: setsockopt( %ld, SO_KEEPALIVE)"
+					   " failed errno=%d (%s)\n",
+						(long)s, err, sock_errstr(err) );
+#else
+					Debug( LDAP_DEBUG_ANY,
+						"slapd(%ld): setsockopt(SO_KEEPALIVE) failed "
+						"errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
+#endif
+				}
+#endif
+#ifdef TCP_NODELAY
+				/* enable no delay */
+				tmp = 1;
+				rc = setsockopt( s, IPPROTO_TCP, TCP_NODELAY,
+					(char *)&tmp, sizeof(tmp) );
+				if ( rc == AC_SOCKET_ERROR ) {
+					int err = sock_errno();
+#ifdef NEW_LOGGING
+					LDAP_LOG( CONNECTION, ERR, 
+						"slapd_daemon_task: setsockopt( %ld, "
+						"TCP_NODELAY) failed errno=%d (%s)\n",
+						(long)s, err, sock_errstr(err) );
+#else
+					Debug( LDAP_DEBUG_ANY,
+						"slapd(%ld): setsockopt(TCP_NODELAY) failed "
+						"errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
+#endif
+				}
+#endif
 			}
+#endif
 
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, DETAIL1, 
+				"slapd_daemon_task: new connection on %ld\n", (long)s, 0, 0 );
+#else
+			Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
+				(long) s, 0, 0 );
+#endif
 			switch ( from.sa_addr.sa_family ) {
 #  ifdef LDAP_PF_LOCAL
 			case AF_LOCAL:
 				sprintf( peername, "PATH=%s", from.sa_un_addr.sun_path );
+				ssf = LDAP_PVT_SASL_LOCAL_SSF;
+				dnsname = "local";
 				break;
 #endif /* LDAP_PF_LOCAL */
 
 #  ifdef LDAP_PF_INET6
-			case AF_INET6: {
+			case AF_INET6:
+			if ( IN6_IS_ADDR_V4MAPPED(&from.sa_in6_addr.sin6_addr) ) {
+				peeraddr = inet_ntoa( *((struct in_addr *)
+							&from.sa_in6_addr.sin6_addr.s6_addr[12]) );
+				sprintf( peername, "IP=%s:%d",
+					 peeraddr != NULL ? peeraddr : "unknown",
+					 (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
+			} else {
 				char addr[INET6_ADDRSTRLEN];
+
+				peeraddr = (char *) inet_ntop( AF_INET6,
+						      &from.sa_in6_addr.sin6_addr,
+						      addr, sizeof addr );
 				sprintf( peername, "IP=%s %d",
-					inet_ntop( AF_INET6,
-						&from.sa_in6_addr.sin6_addr,
-					    addr, sizeof addr) ? addr : "unknown",
-					(unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
-			} break;
+					 peeraddr != NULL ? peeraddr : "unknown",
+					 (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
+			}
+			break;
 #  endif /* LDAP_PF_INET6 */
 
 			case AF_INET:
@@ -924,25 +1540,28 @@ slapd_daemon_task(
 				slapd_close(s);
 				continue;
 			}
-			if ( ( from.sa_addr.sa_family == AF_INET ) 
+
+			if ( ( from.sa_addr.sa_family == AF_INET )
 #ifdef LDAP_PF_INET6
 				|| ( from.sa_addr.sa_family == AF_INET6 )
 #endif
 			) {
 #ifdef SLAPD_RLOOKUPS
+				if ( use_reverse_lookup ) {
 #  ifdef LDAP_PF_INET6
-				if ( from.sa_addr.sa_family == AF_INET6 )
+					if ( from.sa_addr.sa_family == AF_INET6 )
+						hp = gethostbyaddr(
+							(char *)&(from.sa_in6_addr.sin6_addr),
+							sizeof(from.sa_in6_addr.sin6_addr),
+							AF_INET6 );
+					else
+#  endif /* LDAP_PF_INET6 */
 					hp = gethostbyaddr(
-						(char *)&(from.sa_in6_addr.sin6_addr),
-						sizeof(from.sa_in6_addr.sin6_addr),
-						AF_INET6 );
-				else
-#  endif LDAP_PF_INET6
-				hp = gethostbyaddr(
-					(char *) &(from.sa_in_addr.sin_addr),
-					sizeof(from.sa_in_addr.sin_addr),
-					AF_INET );
-				dnsname = hp ? ldap_pvt_str2lower( hp->h_name ) : NULL;
+						(char *) &(from.sa_in_addr.sin_addr),
+						sizeof(from.sa_in_addr.sin_addr),
+						AF_INET );
+					dnsname = hp ? ldap_pvt_str2lower( hp->h_name ) : NULL;
+				}
 #else
 				dnsname = NULL;
 #endif /* SLAPD_RLOOKUPS */
@@ -955,7 +1574,7 @@ slapd_daemon_task(
 				{
 					/* DENY ACCESS */
 					Statslog( LDAP_DEBUG_ANY,
-						"fd=%ld connection from %s (%s) denied.\n",
+						"fd=%ld host access from %s (%s) denied.\n",
 						(long) s,
 						dnsname != NULL ? dnsname : "unknown",
 						peeraddr != NULL ? peeraddr : "unknown",
@@ -966,23 +1585,33 @@ slapd_daemon_task(
 #endif /* HAVE_TCPD */
 			}
 
-			if( (id = connection_init(s,
+			id = connection_init(s,
 				slap_listeners[l]->sl_url,
 				dnsname != NULL ? dnsname : "unknown",
 				peername,
 				slap_listeners[l]->sl_name,
 #ifdef HAVE_TLS
-				slap_listeners[l]->sl_is_tls
+				slap_listeners[l]->sl_is_tls,
 #else
-				0
+				0,
 #endif
-				)) < 0 )
-			{
+				ssf,
+				authid );
+
+			if( authid ) ch_free(authid);
+
+			if( id < 0 ) {
+#ifdef NEW_LOGGING
+				LDAP_LOG( CONNECTION, INFO, 
+					"slapd_daemon_task: connection_init(%ld, %s, %s) failed.\n",
+					(long)s, peername, slap_listeners[l]->sl_name );
+#else
 				Debug( LDAP_DEBUG_ANY,
 					"daemon: connection_init(%ld, %s, %s) failed.\n",
 					(long) s,
 					peername,
 					slap_listeners[l]->sl_name );
+#endif
 				slapd_close(s);
 				continue;
 			}
@@ -999,16 +1628,32 @@ slapd_daemon_task(
 		}
 
 #ifdef LDAP_DEBUG
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, DETAIL2,
+			   "slapd_daemon_task: activity on ", 0, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
+#endif
 #ifdef HAVE_WINSOCK
 		for ( i = 0; i < readfds.fd_count; i++ ) {
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, DETAIL2, 
+				" %d%s", readfds.fd_array[i], "r", 0, 0 );
+#else
 			Debug( LDAP_DEBUG_CONNS, " %d%s",
 				readfds.fd_array[i], "r", 0 );
+#endif
 		}
 		for ( i = 0; i < writefds.fd_count; i++ ) {
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, DETAIL2, 
+				" %d%s", writefds.fd_array[i], "w" , 0 );
+#else
 			Debug( LDAP_DEBUG_CONNS, " %d%s",
 				writefds.fd_array[i], "w", 0 );
+#endif
 		}
+
 #else
 		for ( i = 0; i < nfds; i++ ) {
 			int	r, w;
@@ -1016,6 +1661,13 @@ slapd_daemon_task(
 
 			for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 				if ( i == slap_listeners[l]->sl_sd ) {
+#ifdef LDAP_CONNECTIONLESS
+				/* The listener is the data port. Don't
+				 * skip it.
+				 */
+					if (slap_listeners[l]->sl_is_udp)
+						continue;
+#endif
 					is_listener = 1;
 					break;
 				}
@@ -1026,12 +1678,22 @@ slapd_daemon_task(
 			r = FD_ISSET( i, &readfds );
 			w = FD_ISSET( i, &writefds );
 			if ( r || w ) {
+#ifdef NEW_LOGGING
+				LDAP_LOG( CONNECTION, DETAIL2, 
+					" %d%s%s", i, r ? "r" : "", w ? "w" : "" );
+#else
 				Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
 				    r ? "r" : "", w ? "w" : "" );
+#endif
 			}
 		}
 #endif
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, DETAIL2, "\n", 0, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
+#endif
+
 #endif
 
 		/* loop through the writers */
@@ -1054,6 +1716,10 @@ slapd_daemon_task(
 
 			for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 				if ( i == slap_listeners[l]->sl_sd ) {
+#ifdef LDAP_CONNECTIONLESS
+					if (slap_listeners[l]->sl_is_udp)
+						continue;
+#endif
 					is_listener = 1;
 					break;
 				}
@@ -1061,10 +1727,14 @@ slapd_daemon_task(
 			if ( is_listener ) {
 				continue;
 			}
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, DETAIL2, 
+				"slapd_daemon_task: write active on %d\n", wd, 0, 0 );
+#else
 			Debug( LDAP_DEBUG_CONNS,
 				"daemon: write active on %d\n",
 				wd, 0, 0 );
-
+#endif
 			/*
 			 * NOTE: it is possible that the connection was closed
 			 * and that the stream is now inactive.
@@ -1098,6 +1768,10 @@ slapd_daemon_task(
 
 			for ( l = 0; slap_listeners[l] != NULL; l++ ) {
 				if ( rd == slap_listeners[l]->sl_sd ) {
+#ifdef LDAP_CONNECTIONLESS
+					if (slap_listeners[l]->sl_is_udp)
+						continue;
+#endif
 					is_listener = 1;
 					break;
 				}
@@ -1106,9 +1780,13 @@ slapd_daemon_task(
 				continue;
 			}
 
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, DETAIL2, 
+				"slapd_daemon_task: read activity on %d\n", rd, 0, 0 );
+#else
 			Debug ( LDAP_DEBUG_CONNS,
 				"daemon: read activity on %d\n", rd, 0, 0 );
-
+#endif
 			/*
 			 * NOTE: it is possible that the connection was closed
 			 * and that the stream is now inactive.
@@ -1123,44 +1801,64 @@ slapd_daemon_task(
 		ldap_pvt_thread_yield();
 	}
 
-	if( slapd_shutdown > 0 ) {
+	if( slapd_shutdown == 1 ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, CRIT,
+		   "slapd_daemon_task: shutdown requested and initiated.\n", 0, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_TRACE,
 			"daemon: shutdown requested and initiated.\n",
 			0, 0, 0 );
+#endif
 
-	} else if ( slapd_shutdown < 0 ) {
+	} else if ( slapd_shutdown == 2 ) {
 #ifdef HAVE_NT_SERVICE_MANAGER
-		if (slapd_shutdown == -1)
-		    Debug( LDAP_DEBUG_TRACE,
-			  "daemon: shutdown initiated by Service Manager.\n",
-			  0, 0, 0);
-		else
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, CRIT,
+			   "slapd_daemon_task: shutdown initiated by Service Manager.\n",
+			   0, 0, 0);
+#else
+			Debug( LDAP_DEBUG_TRACE,
+			       "daemon: shutdown initiated by Service Manager.\n",
+			       0, 0, 0);
 #endif
-		Debug( LDAP_DEBUG_TRACE,
-			"daemon: abnormal condition, shutdown initiated.\n",
-			0, 0, 0 );
+#else /* !HAVE_NT_SERVICE_MANAGER */
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, CRIT,
+			   "slapd_daemon_task: abnormal condition, "
+			   "shutdown initiated.\n", 0, 0, 0 );
+#else
+			Debug( LDAP_DEBUG_TRACE,
+			       "daemon: abnormal condition, shutdown initiated.\n",
+			       0, 0, 0 );
+#endif
+#endif /* !HAVE_NT_SERVICE_MANAGER */
 	} else {
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, CRIT,
+		   "slapd_daemon_task: no active streams, shutdown initiated.\n", 
+		   0, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_TRACE,
-			"daemon: no active streams, shutdown initiated.\n",
-			0, 0, 0 );
+		       "daemon: no active streams, shutdown initiated.\n",
+		       0, 0, 0 );
+#endif
 	}
 
-	for ( l = 0; slap_listeners[l] != NULL; l++ ) {
-		if ( slap_listeners[l]->sl_sd != AC_SOCKET_INVALID ) {
-#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 );
-			break;
-		}
-	}
+	if( slapd_gentle_shutdown != 2 )
+		close_listeners ( 0 );
+	free ( slap_listeners );
+	slap_listeners = NULL;
 
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, CRIT, 
+		"slapd_daemon_task: shutdown waiting for %d threads to terminate.\n",
+		ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
+#else
 	Debug( LDAP_DEBUG_ANY,
 	    "slapd shutdown: waiting for %d threads to terminate\n",
 	    ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
-
+#endif
 	ldap_pvt_thread_pool_destroy(&connection_pool, 1);
 
 	return NULL;
@@ -1174,23 +1872,31 @@ int slapd_daemon( void )
 	connections_init();
 
 #define SLAPD_LISTENER_THREAD 1
-#if defined( SLAPD_LISTENER_THREAD ) || !defined(HAVE_PTHREADS)
+#if defined( SLAPD_LISTENER_THREAD )
+	{
+		ldap_pvt_thread_t	listener_tid;
 
-	/* listener as a separate THREAD */
-	rc = ldap_pvt_thread_create( &listener_tid,
-		0, slapd_daemon_task, NULL );
+		/* listener as a separate THREAD */
+		rc = ldap_pvt_thread_create( &listener_tid,
+			0, slapd_daemon_task, NULL );
 
-	if ( rc != 0 ) {
-		Debug( LDAP_DEBUG_ANY,
-		    "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
-		return rc;
+		if ( rc != 0 ) {
+#ifdef NEW_LOGGING
+			LDAP_LOG( CONNECTION, ERR, 
+				"slapd_daemon: listener ldap_pvt_thread_create failed (%d).\n",
+				rc, 0, 0 );
+#else
+			Debug( LDAP_DEBUG_ANY,
+			"listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
+#endif
+			return rc;
+		}
+ 
+  		/* wait for the listener thread to complete */
+  		ldap_pvt_thread_join( listener_tid, (void *) NULL );
 	}
-
-	/* wait for the listener thread to complete */
-	ldap_pvt_thread_join( listener_tid, (void *) NULL );
 #else
-	/* expermimental code */
-	listener_tid = pthread_self();
+	/* experimental code */
 	slapd_daemon_task( NULL );
 #endif
 
@@ -1198,77 +1904,64 @@ int slapd_daemon( void )
 
 }
 
-#ifdef HAVE_WINSOCK2
 int sockinit(void)
 {
+#if defined( HAVE_WINSOCK2 )
     WORD wVersionRequested;
 	WSADATA wsaData;
 	int err;
- 
+
 	wVersionRequested = MAKEWORD( 2, 0 );
- 
+
 	err = WSAStartup( wVersionRequested, &wsaData );
 	if ( err != 0 ) {
 		/* Tell the user that we couldn't find a usable */
-		/* WinSock DLL.                                  */
+		/* WinSock DLL.					 */
 		return -1;
 	}
- 
+
 	/* Confirm that the WinSock DLL supports 2.0.*/
 	/* Note that if the DLL supports versions greater    */
 	/* than 2.0 in addition to 2.0, it will still return */
-	/* 2.0 in wVersion since that is the version we      */
-	/* requested.                                        */
- 
+	/* 2.0 in wVersion since that is the version we	     */
+	/* requested.					     */
+
 	if ( LOBYTE( wsaData.wVersion ) != 2 ||
 		HIBYTE( wsaData.wVersion ) != 0 )
 	{
 	    /* Tell the user that we couldn't find a usable */
-	    /* WinSock DLL.                                  */
+	    /* WinSock DLL.				     */
 	    WSACleanup();
-	    return -1; 
+	    return -1;
 	}
 
 	/* The WinSock DLL is acceptable. Proceed. */
-	return 0;
-}
-
-int sockdestroy(void)
-{
-	WSACleanup();
-	return 0;
-}
-
-#elif HAVE_WINSOCK
-static int sockinit(void)
-{
+#elif defined( HAVE_WINSOCK )
 	WSADATA wsaData;
 	if ( WSAStartup( 0x0101, &wsaData ) != 0 ) {
 	    return -1;
 	}
-	return 0;
-}
-static int sockdestroy(void)
-{
-	WSACleanup();
+#endif
 	return 0;
 }
 
-#else
-static int sockinit(void)
-{
-	return 0;
-}
-static int sockdestroy(void)
+int sockdestroy(void)
 {
+#if defined( HAVE_WINSOCK2 ) || defined( HAVE_WINSOCK )
+	WSACleanup();
+#endif
 	return 0;
 }
-#endif
 
 RETSIGTYPE
 slap_sig_shutdown( int sig )
 {
+#ifdef NEW_LOGGING
+	LDAP_LOG( CONNECTION, CRIT, 
+		"slap_sig_shutdown: signal %d\n", sig, 0, 0 );
+#else
 	Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: signal %d\n", sig, 0, 0);
+#endif
 
 	/*
 	 * If the NT Service Manager is controlling the server, we don't
@@ -1278,16 +1971,26 @@ slap_sig_shutdown( int sig )
 
 #if HAVE_NT_SERVICE_MANAGER && SIGBREAK
 	if (is_NT_Service && sig == SIGBREAK)
+#ifdef NEW_LOGGING
+	    LDAP_LOG( CONNECTION, CRIT,
+		    "slap_sig_shutdown: SIGBREAK ignored.\n", 0, 0, 0 );
+#else
 	    Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: SIGBREAK ignored.\n",
 		  0, 0, 0);
+#endif
+	else
+#endif
+#ifdef SIGHUP
+	if (sig == SIGHUP && global_gentlehup && slapd_gentle_shutdown == 0)
+		slapd_gentle_shutdown = 1;
 	else
 #endif
-	slapd_shutdown = sig;
+	slapd_shutdown = 1;
 
 	WAKE_LISTENER(1);
 
 	/* reinstall self */
-	(void) SIGNAL( sig, slap_sig_shutdown );
+	(void) SIGNAL_REINSTALL( sig, slap_sig_shutdown );
 }
 
 RETSIGTYPE
@@ -1296,5 +1999,14 @@ slap_sig_wake( int sig )
 	WAKE_LISTENER(1);
 
 	/* reinstall self */
-	(void) SIGNAL( sig, slap_sig_wake );
+	(void) SIGNAL_REINSTALL( sig, slap_sig_wake );
+}
+
+
+void slapd_add_internal(ber_socket_t s) {
+	slapd_add(s);
+}
+
+Listener ** slapd_get_listeners(void) {
+	return slap_listeners;
 }