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

diff --git a/servers/slapd/daemon.c b/servers/slapd/daemon.c
index 5aecc3bcea..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,21 +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;
+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
@@ -95,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
@@ -113,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 );
 }
 
@@ -130,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) {
@@ -186,12 +287,16 @@ 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 slap_free_listener_addresses(struct sockaddr **sal)
+static void slap_free_listener_addresses(struct sockaddr **sal)
 {
 	struct sockaddr **sap;
 
@@ -206,6 +311,63 @@ static slap_free_listener_addresses(struct sockaddr **sal)
 	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,
@@ -213,151 +375,170 @@ static int slap_get_listener_addresses(
 	struct sockaddr ***sal)
 {
 	struct sockaddr **sap;
-#ifdef HAVE_GETADDRINFO
-	struct addrinfo hints, *res, *sai;
-	int n, err;
-	
-	memset( &hints, '\0', sizeof(hints) );
-	hints.ai_flags = AI_PASSIVE;
-	hints.ai_socktype = SOCK_STREAM;
-#  ifdef LDAP_PF_LOCAL
+
+#ifdef LDAP_PF_LOCAL
 	if ( port == 0 ) {
-		hints.ai_family = AF_LOCAL;
-		/* host specifies a service in this case */
-		if (err = getaddrinfo(NULL, host, &hints, &res)) {
-			Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed: %s\n",
-				gai_strerror(err), 0, 0);
+		*sal = ch_malloc(2 * sizeof(void *));
+		if (*sal == NULL) {
 			return -1;
 		}
+
+		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
-	{		
+#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);
-		hints.ai_family = AF_UNSPEC;
-		if (err = getaddrinfo(host, serv, &hints, &res)) {
+
+		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",
-				gai_strerror(err), 0, 0);
+				AC_GAI_STRERROR(err), 0, 0);
+#endif
 			return -1;
 		}
-	}
 
-	sai = res;
-	for (n=2; (sai = sai->ai_next) != NULL; n++) {
-		/* EMPTY */ ;
-	}
-	*sal = ch_malloc(n * sizeof(*sal));
-	if (*sal == NULL) {
-		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;
+		}
 
-	sai = res;
-	sap = *sal;
-	do {
-		switch (sai->ai_family) {
-#  ifdef LDAP_PF_LOCAL
-		case AF_LOCAL: {
-			*sap = ch_malloc(sizeof(struct sockaddr_un));
-			if (*sap == NULL) {
+		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;
 			}
-			*(struct sockaddr_un *)*sap =
-				*((struct sockaddr_un *)sai->ai_addr);
-		} break;
+
+			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
-#  ifdef LDAP_PF_INET6			
-		case AF_INET6: {
-			*sap = ch_malloc(sizeof(struct sockaddr_in6));
-			if (*sap == NULL) {
-				freeaddrinfo(res);
-				goto errexit;
+			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;
 			}
-			*(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;
+
+			if (*sap != NULL) {
+				(*sap)->sa_family = sai->ai_family;
+				sap++;
+				*sap = NULL;
 			}
-			*(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++;
 		}
-	} while ((sai = sai->ai_next) != NULL);
-
-	freeaddrinfo(res);
 
+		freeaddrinfo(res);
 #else
-#  ifdef LDAP_PF_LOCAL
-	if ( port == 0 ) {
-		*sal = ch_malloc(2 * sizeof(*sal));
-		if (*sal == NULL) {
-			return -1;
-		}
-		sap = *sal;
-		*sap = ch_malloc(sizeof(struct sockaddr_un));
-		if (*sap == NULL)
-			goto errexit;
-		(void)memset( (void *)*sap, '\0', sizeof(struct sockaddr_un) );
-		(*sap)->sa_family = AF_LOCAL;
-		if ( strlen(host) >
-		     (sizeof(((struct sockaddr_un *)*sal)->sun_path) - 1) ) {
-			Debug( LDAP_DEBUG_ANY,
-			       "daemon: domain socket path (%s) too long in URL",
-			       host, 0, 0);
-			goto errexit;
-		}
-		strcpy( ((struct sockaddr_un *)*sap)->sun_path, host );
-	} else
-#  endif		
-	{
+		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 ) ) {
-			struct hostent *he = gethostbyname( host );
+			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;
 			}
-			AC_MEMCPY( &in, he->h_addr, sizeof( in ) );
+			for (n = 0; he->h_addr_list[n]; n++) ;
 		}
 
-		*sal = ch_malloc(2 * sizeof(*sal));
+		*sal = ch_malloc((n+1) * sizeof(void *));
 		if (*sal == NULL) {
 			return -1;
 		}
 
 		sap = *sal;
-		*sap = ch_malloc(sizeof(struct sockaddr_in));
-		if (*sap == NULL) {
-			goto errexit;
+		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) );
+			}
 		}
-
-		(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;
-	}
-	sap++;
+		sap[i] = NULL;
 #endif
+	}
 
-	*sap = NULL;
 	return 0;
 
 errexit:
@@ -365,33 +546,53 @@ errexit:
 	return -1;
 }
 
-static Listener * slap_open_listener(
-	const char* url )
+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;
 	unsigned short port;
-	int err, addrlen;
+	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 ) {
@@ -407,21 +608,35 @@ static Listener * slap_open_listener(
 #endif
 
 	port = (unsigned short) lud->lud_port;
-	
-	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 = slap_get_listener_addresses(LDAPI_SOCK, 0, &sal);
 		} else {
 			err = slap_get_listener_addresses(lud->lud_host, 0, &sal);
 		}
+
+		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 NULL;
+		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 )
 		{
@@ -433,7 +648,16 @@ static Listener * slap_open_listener(
 
 	ldap_free_urldesc( lud );
 	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;
@@ -451,20 +675,36 @@ static Listener * slap_open_listener(
 			sal++;
 			continue;
 		}
-		l.sl_sd = socket( (*sal)->sa_family, SOCK_STREAM, 0);
+#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;
 		}
 #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
 			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;
@@ -483,19 +723,44 @@ static Listener * slap_open_listener(
 					 (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,
 				       "slapd(%ld): setsockopt(SO_REUSEADDR) failed errno=%d (%s)\n",
 				       (long) l.sl_sd, err, sock_errstr(err) );
+#endif
 			}
 #endif
 		}
-	
+
 		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
+			}
+#endif
 			addrlen = sizeof(struct sockaddr_in6);
 			break;
 #endif
@@ -505,34 +770,39 @@ static Listener * slap_open_listener(
 			break;
 #endif
 		}
-	
-		if (!bind(l.sl_sd, *sal, 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 );
-		sal++;
-	} /* while ( *sal != NULL ) */
-
-	if ( *sal == NULL ) {
-		Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed\n",
-			(long) l.sl_sd, 0, 0 );
-		slap_free_listener_addresses(psal);
-		return NULL;
-	}
+#endif
+			tcp_close( l.sl_sd );
+			sal++;
+			continue;
+		}
 
 	switch ( (*sal)->sa_family ) {
 #ifdef LDAP_PF_LOCAL
 	case AF_LOCAL: {
 		char *addr = ((struct sockaddr_un *)*sal)->sun_path;
-		if ( chmod( addr, S_IRWXU ) < 0 ) {
+		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) );
+#endif
 			tcp_close( l.sl_sd );
 			slap_free_listener_addresses(psal);
-			return NULL;
+			return -1;
 		}
 		l.sl_name = ch_malloc( strlen(addr) + sizeof("PATH=") );
 		sprintf( l.sl_name, "PATH=%s", addr );
@@ -541,14 +811,15 @@ static Listener * slap_open_listener(
 
 	case AF_INET: {
 		char *s;
-#ifdef HAVE_GETADDRINFO		
+#if defined( HAVE_GETADDRINFO ) && defined( HAVE_INET_NTOP )
 		char addr[INET_ADDRSTRLEN];
 		inet_ntop( AF_INET, &((struct sockaddr_in *)*sal)->sin_addr,
 			   addr, sizeof(addr) );
 		s = addr;
 #else
-		s = inet_ntoa( l.sl_addr.sin_addr );
-#endif		
+		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 );
@@ -559,27 +830,45 @@ static Listener * slap_open_listener(
 		char addr[INET6_ADDRSTRLEN];
 		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 */
 
 	default:
+#ifdef NEW_LOGGING
+		LDAP_LOG( CONNECTION, INFO, 
+			"slap_open_listener: unsupported address family (%d)\n",
+			(int)(*sal)->sa_family, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_ANY, "daemon: unsupported address family (%d)\n",
 			(int) (*sal)->sa_family, 0, 0 );
+#endif
 		break;
 	}
 
-	slap_free_listener_addresses(psal);
-
+	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);
@@ -587,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;
 	}
@@ -617,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;
 	}
 
@@ -629,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] = slap_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;
 }
@@ -681,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 );
 		}
 
@@ -724,9 +1139,10 @@ slapd_daemon_task(
 		ber_socket_t nfds;
 #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;
@@ -734,18 +1150,43 @@ 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 );
 
@@ -797,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,
@@ -815,7 +1263,7 @@ slapd_daemon_task(
 		case -1: {	/* failure - try again */
 				int err = sock_errno();
 
-				if( err == EBADF 
+				if( err == EBADF
 #ifdef WSAENOTSOCK
 					/* you'd think this would be EBADF */
 					|| err == WSAENOTSOCK
@@ -826,28 +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 */
 		}
 
@@ -861,13 +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=")];
@@ -885,24 +1348,86 @@ slapd_daemon_task(
 			if ( !FD_ISSET( slap_listeners[l]->sl_sd, &readfds ) )
 				continue;
 
+#ifdef LDAP_CONNECTIONLESS
+			if ( slap_listeners[l]->sl_is_udp )
+			{
+			/* 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
+
 			s = accept( slap_listeners[l]->sl_sd,
 				(struct sockaddr *) &from, &len );
 			if ( s == AC_SOCKET_INVALID ) {
 				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) );
+
+#ifdef EMFILE
+				if( err == EMFILE ) {
+					emfile++;
+				} else
+#endif
+#ifdef ENFILE
+				if( err == ENFILE ) {
+					emfile++;
+				} else 
+#endif
+				{
+					emfile=0;
+				}
+
+				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
@@ -933,9 +1458,16 @@ slapd_daemon_task(
 					(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
@@ -945,22 +1477,34 @@ slapd_daemon_task(
 					(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 */
 
@@ -974,10 +1518,12 @@ slapd_daemon_task(
 					 (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",
+					 peeraddr != NULL ? peeraddr : "unknown",
 					 (unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
 			}
 			break;
@@ -995,25 +1541,27 @@ slapd_daemon_task(
 				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 )
-					hp = gethostbyaddr(
-						(char *)&(from.sa_in6_addr.sin6_addr),
-						sizeof(from.sa_in6_addr.sin6_addr),
-						AF_INET6 );
-				else
+					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_in_addr.sin_addr),
-					sizeof(from.sa_in_addr.sin_addr),
-					AF_INET );
-				dnsname = hp ? ldap_pvt_str2lower( hp->h_name ) : NULL;
+					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;
+				}
 #else
 				dnsname = NULL;
 #endif /* SLAPD_RLOOKUPS */
@@ -1053,11 +1601,17 @@ slapd_daemon_task(
 			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;
 			}
@@ -1074,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;
@@ -1091,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;
 				}
@@ -1101,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 */
@@ -1129,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;
 				}
@@ -1136,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.
@@ -1173,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;
 				}
@@ -1181,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.
@@ -1198,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;
@@ -1258,14 +1881,20 @@ int slapd_daemon( void )
 			0, slapd_daemon_task, NULL );
 
 		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 );
+			"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
 	/* experimental code */
 	slapd_daemon_task( NULL );
@@ -1281,29 +1910,29 @@ int sockinit(void)
     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. */
@@ -1327,7 +1956,12 @@ int sockdestroy(void)
 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
@@ -1337,11 +1971,21 @@ 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);
 
@@ -1362,3 +2006,7 @@ slap_sig_wake( int sig )
 void slapd_add_internal(ber_socket_t s) {
 	slapd_add(s);
 }
+
+Listener ** slapd_get_listeners(void) {
+	return slap_listeners;
+}