X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdaemon.c;h=e937ca9158af44cc9dc525b82c5487ac86034133;hb=48b63d4f165269f29c35f89cceddd880c3966ef5;hp=8ef532f043574626cd102ea80a205fdd33bba98c;hpb=db721ca82147ff4eea81629358cdacecfbd05d93;p=openldap

diff --git a/servers/slapd/daemon.c b/servers/slapd/daemon.c
index 8ef532f043..e937ca9158 100644
--- a/servers/slapd/daemon.c
+++ b/servers/slapd/daemon.c
@@ -10,7 +10,7 @@
 #include <ac/time.h>
 #include <ac/unistd.h>
 
-#include "ldapconfig.h"
+#include "ldap_defaults.h"
 #include "slap.h"
 
 #ifdef HAVE_TCPD
@@ -21,12 +21,56 @@ int deny_severity = LOG_NOTICE;
 #endif /* TCP Wrappers */
 
 /* globals */
-int dtblsize;
+time_t starttime;
+ber_socket_t dtblsize;
+
+typedef struct slap_listener {
+	char* sl_url;
+	char* sl_name;
+#ifdef HAVE_TLS
+	int		sl_is_tls;
+#endif
+	ber_socket_t		sl_sd;
+	struct sockaddr_in	sl_addr;
+} Listener;
+
+Listener **slap_listeners = NULL;
+
+#ifdef HAVE_WINSOCK2
+/* in nt_main.c */
+extern ldap_pvt_thread_cond_t			started_event;
+
+/* forward reference */
+static void hit_socket(void);
+/* In wsa_err.c */
+char *WSAGetLastErrorString();
+static ldap_pvt_thread_t hit_tid;
+
+#define WAKE_LISTENER(w) \
+do {\
+    if( w ) {\
+        ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );\
+        hit_socket(); \
+    }\
+} while(0)
+#else
+#define WAKE_LISTENER(w) \
+do {\
+    if( w ) {\
+        ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );\
+    }\
+} while(0)
+#endif
+
+#ifndef HAVE_WINSOCK
+static 
+#endif
+volatile sig_atomic_t slapd_shutdown = 0;
 
 static ldap_pvt_thread_t	listener_tid;
-static volatile sig_atomic_t slapd_shutdown = 0;
+static volatile sig_atomic_t slapd_listener = 0;
 
-struct slap_daemon {
+static struct slap_daemon {
 	ldap_pvt_thread_mutex_t	sd_mutex;
 
 	int sd_nactives;
@@ -45,7 +89,7 @@ struct slap_daemon {
 /*
  * Add a descriptor to daemon control
  */
-static void slapd_add(int s) {
+static void slapd_add(ber_socket_t s) {
 	ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
 
 	assert( !FD_ISSET( s, &slap_daemon.sd_actives ));
@@ -61,7 +105,8 @@ static void slapd_add(int s) {
 	FD_SET( s, &slap_daemon.sd_actives );
 	FD_SET( s, &slap_daemon.sd_readers );
 
-	Debug( LDAP_DEBUG_CONNS, "daemon: added %d%s%s\n", s,
+	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" : "" );
 
@@ -71,12 +116,12 @@ static void slapd_add(int s) {
 /*
  * Remove the descriptor from daemon control
  */
-void slapd_remove(int s) {
+void slapd_remove(ber_socket_t s, int wake) {
 	ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+	WAKE_LISTENER(wake);
 
-	assert( FD_ISSET( s, &slap_daemon.sd_actives ));
-
-	Debug( LDAP_DEBUG_CONNS, "daemon: removing %d%s%s\n", s,
+	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" : "" );
 
@@ -87,8 +132,9 @@ void slapd_remove(int s) {
 	ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 }
 
-void slapd_clr_write(int s, int wake) {
+void slapd_clr_write(ber_socket_t s, int wake) {
 	ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+	WAKE_LISTENER(wake);
 
 	assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 	FD_CLR( s, &slap_daemon.sd_writers );
@@ -100,11 +146,12 @@ void slapd_clr_write(int s, int wake) {
 	}
 }
 
-void slapd_set_write(int s, int wake) {
+void slapd_set_write(ber_socket_t s, int wake) {
 	ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+    WAKE_LISTENER(wake);
 
 	assert( FD_ISSET( s, &slap_daemon.sd_actives) );
-	FD_SET( s, &slap_daemon.sd_writers );
+	FD_SET( (unsigned) s, &slap_daemon.sd_writers );
 
 	ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 
@@ -113,8 +160,9 @@ void slapd_set_write(int s, int wake) {
 	}
 }
 
-void slapd_clr_read(int s, int wake) {
+void slapd_clr_read(ber_socket_t s, int wake) {
 	ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+    WAKE_LISTENER(wake);
 
 	assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 	FD_CLR( s, &slap_daemon.sd_readers );
@@ -126,8 +174,9 @@ void slapd_clr_read(int s, int wake) {
 	}
 }
 
-void slapd_set_read(int s, int wake) {
+void slapd_set_read(ber_socket_t s, int wake) {
 	ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+    WAKE_LISTENER(wake);
 
 	assert( FD_ISSET( s, &slap_daemon.sd_actives) );
 	FD_SET( s, &slap_daemon.sd_readers );
@@ -139,27 +188,203 @@ void slapd_set_read(int s, int wake) {
 	}
 }
 
-static void slapd_close(int s) {
-	slapd_remove(s);
-
-	Debug( LDAP_DEBUG_CONNS, "daemon: closing %d\n", s, 0, 0 );
+static void slapd_close(ber_socket_t s) {
+	Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n",
+		(long) s, 0, 0 );
 	tcp_close(s);
 }
 
-static void *
-slapd_daemon_task(
-	void *ptr
-)
+
+Listener *
+open_listener(
+	const char* url,
+	int port,
+	int tls_port )
 {
-	struct sockaddr_in *addr = ptr;
-	int	tcps = -1;
+	int	tmp, rc;
+	Listener l;
+	Listener *li;
+	LDAPURLDesc *lud;
+	char *s;
+
+	rc = ldap_url_parse( url, &lud );
+
+	if( rc != LDAP_URL_SUCCESS ) {
+		Debug( LDAP_DEBUG_ANY,
+			"daemon: listen URL \"%s\" parse error=%d\n",
+			url, rc, 0 );
+		return NULL;
+	}
+
+#ifndef HAVE_TLS
+	if( lud->lud_ldaps ) {
+		Debug( LDAP_DEBUG_ANY,
+			"daemon: TLS not supported (%s)\n",
+			url, 0, 0 );
+		ldap_free_urldesc( lud );
+		return NULL;
+	}
+
+	if(! lud->lud_port ) {
+		lud->lud_port = port;
+	}
+
+#else
+	l.sl_is_tls = lud->lud_ldaps;
+
+	if(! lud->lud_port ) {
+		lud->lud_port = lud->lud_ldaps ? tls_port : port;
+	}
+#endif
+
+	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, "invalid host (%s) in URL: %s",
+					lud->lud_host, url, 0);
+				ldap_free_urldesc( lud );
+				return NULL;
+			}
+
+			memcpy( &l.sl_addr.sin_addr, he->h_addr,
+			       sizeof( l.sl_addr.sin_addr ) );
+		}
+	}
+
+	ldap_free_urldesc( lud );
+
+
+	if ( (l.sl_sd = socket( AF_INET, SOCK_STREAM, 0 )) == AC_SOCKET_INVALID ) {
+#ifndef HAVE_WINSOCK
+		int err = errno;
+		Debug( LDAP_DEBUG_ANY,
+			"daemon: socket() failed errno %d (%s)\n", err,
+	    	err > -1 && err < sys_nerr ? sys_errlist[err] :
+	    	"unknown", 0 );
+#else
+		Debug( LDAP_DEBUG_ANY, 
+			"daemon: socket() failed errno %d (%s)\n",
+			WSAGetLastError(),
+	    	WSAGetLastErrorString(), 0 );
+#endif
+		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;
+	}
+#endif
+
+#ifdef SO_REUSEADDR
+	tmp = 1;
+	if ( setsockopt( l.sl_sd, SOL_SOCKET, SO_REUSEADDR,
+		(char *) &tmp, sizeof(tmp) ) == -1 )
+	{
+		int err = errno;
+		Debug( LDAP_DEBUG_ANY,
+	       "slapd(%ld): setsockopt(SO_REUSEADDR) failed errno %d (%s)\n",
+	    	(long) l.sl_sd, err,
+			err > -1 && err < sys_nerr
+				? sys_errlist[err] : "unknown" );
+	}
+#endif
+#ifdef SO_KEEPALIVE
+	tmp = 1;
+	if ( setsockopt( l.sl_sd, SOL_SOCKET, SO_KEEPALIVE,
+		(char *) &tmp, sizeof(tmp) ) == -1 )
+	{
+		int err = errno;
+		Debug( LDAP_DEBUG_ANY,
+			"slapd(%ld): setsockopt(SO_KEEPALIVE) failed errno %d (%s)\n",
+	    	(long) l.sl_sd, err,
+			err > -1 && err < sys_nerr
+				? sys_errlist[err] : "unknown" );
+	}
+#endif
+#ifdef TCP_NODELAY
+	tmp = 1;
+	if ( setsockopt( l.sl_sd, IPPROTO_TCP, TCP_NODELAY,
+		(char *)&tmp, sizeof(tmp) ) )
+	{
+		int err = errno;
+		Debug( LDAP_DEBUG_ANY,
+			"slapd(%ld): setsockopt(TCP_NODELAY) failed errno %d (%s)\n",
+	    	(long) l.sl_sd, err,
+			err > -1 && err < sys_nerr
+				? sys_errlist[err] : "unknown" );
+	}
+#endif
+
+	if ( bind( l.sl_sd, (struct sockaddr *) &l.sl_addr, sizeof(l.sl_addr) ) == -1 ) {
+		int err = errno;
+		Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno %d (%s)\n",
+	    	(long) l.sl_sd, err,
+			err > -1 && err < sys_nerr
+				? sys_errlist[err] : "unknown" );
+		tcp_close( l.sl_sd );
+		return NULL;
+	}
+
+	l.sl_url = ch_strdup( url );
+
+	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 );
+
+	li = ch_malloc( sizeof( Listener ) );
+	*li = l;
+
+	Debug( LDAP_DEBUG_TRACE, "daemon: initialized %s\n",
+		l.sl_url, 0, 0 );
+
+	return li;
+}
+
+static int sockinit(void);
+static int sockdestroy(void);
+
+int slapd_daemon_init(char *urls, int port, int tls_port )
+{
+	int i, rc;
+	char **u;
+
+#ifndef HAVE_TLS
+	assert( tls_port == 0 );
+#endif
+
+	Debug( LDAP_DEBUG_ARGS, "daemon_init: %s (%d/%d)\n",
+		urls ? urls : "<null>", port, tls_port );
+
+	if( rc = sockinit() ) {
+		return rc;
+	}
 
 #ifdef HAVE_SYSCONF
 	dtblsize = sysconf( _SC_OPEN_MAX );
 #elif HAVE_GETDTABLESIZE
 	dtblsize = getdtablesize();
 #else
-	dtblsize = FD_SETSIZE
+	dtblsize = FD_SETSIZE;
 #endif
 
 #ifdef FD_SETSIZE
@@ -168,89 +393,127 @@ slapd_daemon_task(
 	}
 #endif	/* !FD_SETSIZE */
 
-	connections_init();
-
-	ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
 	FD_ZERO( &slap_daemon.sd_readers );
 	FD_ZERO( &slap_daemon.sd_writers );
 
-	if( addr != NULL ) {
-		int	tmp;
+	if( urls == NULL ) {
+		urls = "ldap:///";
+	}
 
-		if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) {
-			Debug( LDAP_DEBUG_ANY,
-				"daemon: socket() failed errno %d (%s)", errno,
-		    	errno > -1 && errno < sys_nerr ? sys_errlist[errno] :
-		    	"unknown", 0 );
-			exit( 1 );
-		}
+	u = str2charray( urls, " " );
 
-#ifndef HAVE_WINSOCK
-		if ( tcps >= dtblsize ) {
-			Debug( LDAP_DEBUG_ANY,
-				"daemon: listener descriptor %d is too great",
-				tcps, dtblsize, 0 );
-			exit( 1 );
-		}
-#endif
+	if( u == NULL || u[0] == NULL ) {
+		Debug( LDAP_DEBUG_ANY, "daemon_init: no urls (%s) provided.\n",
+			urls, 0, 0 );
 
-		tmp = 1;
-		if ( setsockopt( tcps, SOL_SOCKET, SO_REUSEADDR,
-			(char *) &tmp, sizeof(tmp) ) == -1 )
-		{
-			Debug( LDAP_DEBUG_ANY,
-				"slapd(%d): setsockopt() failed errno %d (%s)",
-		    	tcps, errno,
-				errno > -1 && errno < sys_nerr
-					? sys_errlist[errno] : "unknown" );
+		return -1;
+	}
 
-			errno = 0;
-		}
+	for( i=0; u[i] != NULL; i++ ) {
+		Debug( LDAP_DEBUG_TRACE, "daemon_init: listen on %s\n",
+			u[i], 0, 0 );
+	}
 
-		if ( bind( tcps, (struct sockaddr *) addr, sizeof(*addr) ) == -1 ) {
-			Debug( LDAP_DEBUG_ANY, "daemon: bind(%d) failed errno %d (%s)\n",
-		    	tcps, errno,
-				errno > -1 && errno < sys_nerr
-					? sys_errlist[errno] : "unknown" );
-			exit( 1 );
-		}
+	if( i == 0 ) {
+		Debug( LDAP_DEBUG_ANY, "daemon_init: no listeners to open (%s)\n",
+			urls, 0, 0 );
+		return -1;
+	}
 
-		if ( listen( tcps, 5 ) == -1 ) {
-			Debug( LDAP_DEBUG_ANY,
-				"daemon: listen(%d, 5) failed errno %d (%s)\n",
-			    tcps, errno,
-				errno > -1 && errno < sys_nerr
-					? sys_errlist[errno] : "unknown" );
-			exit( 1 );
+	Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners to open...\n",
+		i, 0, 0 );
+
+	slap_listeners = ch_malloc( (i+1)*sizeof(Listener *) );
+
+	for(i = 0; u[i] != NULL; i++ ) {
+		slap_listeners[i] = open_listener( u[i], port, tls_port );
+
+		if( slap_listeners[i] == NULL ) {
+			return -1;
 		}
+	}
+	slap_listeners[i] = NULL;
 
-		slapd_add( tcps );
+	Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners opened.\n",
+		i, 0, 0 );
 
-	} else {
-		if( connection_init( 0, NULL, NULL ) ) {
+	charray_free( u );
+	ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
+	return !i;
+}
+
+
+slapd_daemon_destroy(void)
+{
+	connections_destroy();
+	sockdestroy();
+	return 0;
+}
+
+
+static void *
+slapd_daemon_task(
+	void *ptr
+)
+{
+	int l;
+
+	time( &starttime );
+
+	for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+		if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
+			continue;
+
+		if ( listen( slap_listeners[l]->sl_sd, 5 ) == -1 ) {
+			int err = errno;
 			Debug( LDAP_DEBUG_ANY,
-				"connection_init(%d) failed.\n",
-				0, 0, 0 );
+				"daemon: listen(%s, 5) failed errno %d (%s)\n",
+					(long) slap_listeners[l]->sl_url, err,
+					err > -1 && err < sys_nerr
+					? sys_errlist[err] : "unknown" );
 
-			exit( 1 );
+			return( (void*)-1 );
 		}
 
-		slapd_add( 0 );
+		slapd_add( slap_listeners[l]->sl_sd );
 	}
 
+#ifdef HAVE_WINSOCK
+	if ( started_event != NULL ) {
+		ldap_pvt_thread_cond_signal( &started_event );
+	}
+#endif
+	/* initialization complete. Here comes the loop. */
+
 	while ( !slapd_shutdown ) {
-		int i, ns, nfds;
+		ber_socket_t i;
+		int ns;
+		int at;
+		ber_socket_t nfds;
+#define SLAPD_EBADF_LIMIT 10
+		int ebadf = 0;
+
+#define SLAPD_IDLE_CHECK_LIMIT 4
+		time_t	last_idle_check = slap_get_time();
+		time_t	now;
+
 
 		fd_set			readfds;
 		fd_set			writefds;
 
 		struct sockaddr_in	from;
-		struct hostent		*hp;
+#if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
+        struct hostent		*hp;
+#endif
 		struct timeval		zero;
 		struct timeval		*tvp;
 
-		char	*client_name;
-		char	*client_addr;
+		if( global_idletimeout > 0 && difftime(
+			last_idle_check+global_idletimeout/SLAPD_IDLE_CHECK_LIMIT,
+			now ) < 0 )
+		{
+			connections_timeout_idle(now);
+		}
 
 		FD_ZERO( &writefds );
 		FD_ZERO( &readfds );
@@ -274,7 +537,11 @@ slapd_daemon_task(
 		memcpy( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
 #endif
 
-		FD_SET( tcps, &readfds );
+		for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+			if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
+				continue;
+			FD_SET( slap_listeners[l]->sl_sd, &readfds );
+		}
 
 #ifndef HAVE_WINSOCK
 		nfds = slap_daemon.sd_nfds;
@@ -285,144 +552,205 @@ slapd_daemon_task(
 		ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
 
 		ldap_pvt_thread_mutex_lock( &active_threads_mutex );
+		at = active_threads;
+		ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
+
 #if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
 		tvp = NULL;
 #else
-		tvp = active_threads ? &zero : NULL;
+		tvp = at ? &zero : NULL;
 #endif
 
-		Debug( LDAP_DEBUG_CONNS,
-			"daemon: select: tcps=%d active_threads=%d tvp=%s\n",
-		    tcps, active_threads,
-			tvp == NULL ? "NULL" : "zero" );
-	   
+		for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+			if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
+				continue;
 
-		ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
+			Debug( LDAP_DEBUG_CONNS,
+				"daemon: select: listen=%d active_threads=%d tvp=%s\n",
+					slap_listeners[l]->sl_sd, at,
+					tvp == NULL ? "NULL" : "zero" );
+		}
+
+		switch(ns = select( nfds, &readfds,
+#ifdef HAVE_WINSOCK
+			/* don't pass empty fd_set */
+			( writefds.fd_count > 0 ? &writefds : NULL ),
+#else
+			&writefds,
+#endif
+			NULL, tvp ))
+		{
+		case -1: {	/* failure - try again */
+#ifdef HAVE_WINSOCK
+				int err = WSAGetLastError();
+#else
+				int err = errno;
+#endif
+
+				if( err == EBADF && ++ebadf < SLAPD_EBADF_LIMIT) {
+					continue;
+				}
+
+				if( err != EINTR ) {
+					Debug( LDAP_DEBUG_CONNS,
+						"daemon: select failed (%d): %s\n",
+						err,
+						err >= 0 && err < sys_nerr
+							? sys_errlist[err] : "unknown",
+						0 );
 
-		switch(ns = select( nfds, &readfds, &writefds, 0, tvp )) {
-		case -1:	/* failure - try again */
-			if( errno != EINTR ) {
-				Debug( LDAP_DEBUG_CONNS,
-					"daemon: select failed (%d): %s\n",
-					errno,
-					errno >= 0 && errno < sys_nerr
-						? sys_errlist[errno] : "unknown",
-					0 );
 
 				slapd_shutdown = -1;
+				}
 			}
-			errno = 0;
 			continue;
 
 		case 0:		/* timeout - let threads run */
+			ebadf = 0;
 			Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
 			    0, 0, 0 );
 	     	ldap_pvt_thread_yield();
 			continue;
 
 		default:	/* something happened - deal with it */
+			ebadf = 0;
 			Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
 				ns, 0, 0 );
 			/* FALL THRU */
 		}
 
-		if ( FD_ISSET( tcps, &readfds ) ) {
-			int s;
-			int len = sizeof(from);
+		for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+			ber_int_t s;
+			socklen_t len = sizeof(from);
 			long id;
 
-			if ( (s = accept( tcps,
-				(struct sockaddr *) &from, &len )) == -1 )
+			char	*dnsname;
+			char	*peeraddr;
+
+			char	peername[sizeof("IP=255.255.255.255:65336")];
+
+			if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
+				continue;
+
+			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 )
 			{
+				int err = errno;
 				Debug( LDAP_DEBUG_ANY,
-				    "daemon: accept(%d) failed errno %d (%s)", errno,
-				    tcps, errno >= 0 && errno < sys_nerr ?
-				    sys_errlist[errno] : "unknown");
+				    "daemon: accept(%ld) failed errno %d (%s)\n", err,
+				    (long) slap_listeners[l]->sl_sd,
+				    err >= 0 && err < sys_nerr ?
+				    sys_errlist[err] : "unknown");
 				continue;
 			}
 
-			assert( !FD_ISSET( 0, &slap_daemon.sd_actives) );
-			assert( !FD_ISSET( 0, &slap_daemon.sd_readers) );
-			assert( !FD_ISSET( 0, &slap_daemon.sd_writers) );
+#ifdef LDAP_DEBUG
+			ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+
+			/* 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
 
 #ifndef HAVE_WINSOCK
 			/* make sure descriptor number isn't too great */
 			if ( s >= dtblsize ) {
 				Debug( LDAP_DEBUG_ANY,
-					"daemon: %d beyond descriptor table size %d\n",
-					s, dtblsize, 0 );
-				tcp_close(s);
+					"daemon: %ld beyond descriptor table size %ld\n",
+					(long) s, (long) dtblsize, 0 );
+				slapd_close(s);
 				continue;
 			}
 #endif
 		   
-			Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %d\n",
-				s, 0, 0 );
+			Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
+				(long) s, 0, 0 );
 
 			len = sizeof(from);
-			if ( getpeername( s, (struct sockaddr *) &from, &len ) == 0 ) {
-				client_addr = inet_ntoa( from.sin_addr );
 
-#if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
-				hp = gethostbyaddr( (char *)
-				    &(from.sin_addr.s_addr),
-				    sizeof(from.sin_addr.s_addr), AF_INET );
+			if ( getpeername( s, (struct sockaddr *) &from, &len ) != 0 ) {
+				int err = errno;
+				Debug( LDAP_DEBUG_ANY,
+					"daemon: getpeername( %ld ) failed: errno=%d (%s)\n",
+					(long) s, err,
+				    err >= 0 && err < sys_nerr ?
+				    sys_errlist[err] : "unknown" );
+				slapd_close(s);
+				continue;
+			}
 
-				if(hp) {
-					char *p;
-					client_name = hp->h_name;
+			peeraddr = inet_ntoa( from.sin_addr );
+			sprintf( peername, "IP=%s:%d",
+				peeraddr != NULL ? peeraddr : "unknown",
+				(unsigned) ntohs( from.sin_port ) );
 
-					/* normalize the domain */
-					for ( p = client_name; *p; p++ ) {
-						*p = TOLOWER( (unsigned char) *p );
-					}
+#if defined(SLAPD_RLOOKUPS) || defined(HAVE_TCPD)
+			hp = gethostbyaddr( (char *)
+			    &(from.sin_addr.s_addr),
+			    sizeof(from.sin_addr.s_addr), AF_INET );
 
-				} else {
-					client_name = NULL;
-				}
-#else
-				client_name = NULL;
-#endif
+			if(hp) {
+				dnsname = str2lower( hp->h_name );
 
 			} else {
-				client_name = NULL;;
-				client_addr = NULL;
+				dnsname = NULL;
 			}
+#else
+			dnsname = NULL;
+#endif
 
 #ifdef HAVE_TCPD
-			if(!hosts_ctl("slapd",
-				client_name != NULL ? client_name : STRING_UNKNOWN,
-				client_addr != NULL ? client_addr : STRING_UNKNOWN,
-				STRING_UNKNOWN))
+			if( !hosts_ctl("slapd",
+				dnsname != NULL ? dnsname : STRING_UNKNOWN,
+				peeraddr != NULL ? peeraddr : STRING_UNKNOWN,
+				STRING_UNKNOWN ))
 			{
 				/* DENY ACCESS */
 				Statslog( LDAP_DEBUG_ANY,
-			   	 "fd=%d connection from %s (%s) denied.\n",
-			   	 	s,
-					client_name == NULL ? "unknown" : client_name,
-					client_addr == NULL ? "unknown" : client_addr,
+			   	 "fd=%ld connection from %s (%s) denied.\n",
+			   	 	(long) s,
+					dnsname != NULL ? dnsname : "unknown",
+					peeraddr != NULL ? peeraddr : "unknown",
 			   	  0, 0 );
 
-				tcp_close(s);
+				slapd_close(s);
 				continue;
 			}
 #endif /* HAVE_TCPD */
 
-			if( (id = connection_init(s, client_name, client_addr)) < 0 ) {
+			if( (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
+#else
+				0
+#endif
+				)) < 0 )
+			{
 				Debug( LDAP_DEBUG_ANY,
-					"daemon: connection_init(%d, %s, %s) failed.\n",
-					s,
-					client_name == NULL ? "unknown" : client_name,
-					client_addr == NULL ? "unknown" : client_addr);
-				tcp_close(s);
+					"daemon: connection_init(%ld, %s, %s) failed.\n",
+					(long) s,
+					peername,
+					slap_listeners[l]->sl_name );
+				slapd_close(s);
 				continue;
 			}
 
 			Statslog( LDAP_DEBUG_STATS,
-				"daemon: conn=%d fd=%d connection from %s (%s) accepted.\n",
-				id, s,
-				client_name == NULL ? "unknown" : client_name,
-				client_addr == NULL ? "unknown" : client_addr,
+				"daemon: conn=%d fd=%ld connection from %s (%s) accepted.\n",
+				id, (long) s,
+				peername,
+				slap_listeners[l]->sl_name,
 				0 );
 
 			slapd_add( s );
@@ -431,60 +759,126 @@ slapd_daemon_task(
 
 #ifdef LDAP_DEBUG
 		Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
-
+#ifdef HAVE_WINSOCK
+		for ( i = 0; i < readfds.fd_count; i++ ) {
+			Debug( LDAP_DEBUG_CONNS, " %d%s",
+				readfds.fd_array[i], "r", 0 );
+		}
+		for ( i = 0; i < writefds.fd_count; i++ ) {
+			Debug( LDAP_DEBUG_CONNS, " %d%s",
+				writefds.fd_array[i], "w", 0 );
+		}
+#else
 		for ( i = 0; i < nfds; i++ ) {
 			int	a, r, w;
+			int	is_listener = 0;
 
+			for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+				if ( i == slap_listeners[l]->sl_sd ) {
+					is_listener = 1;
+					break;
+				}
+			}
+			if ( is_listener ) {
+				continue;
+			}
 			r = FD_ISSET( i, &readfds );
 			w = FD_ISSET( i, &writefds );
-			if ( i != tcps && (r || w) ) {
+			if ( r || w ) {
 				Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
 				    r ? "r" : "", w ? "w" : "" );
 			}
 		}
-
+#endif
 		Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
 #endif
 
 		/* loop through the writers */
-		for ( i = 0; i < nfds; i++ ) {
-			if ( i == tcps ) {
+#ifdef HAVE_WINSOCK
+		for ( i = 0; i < writefds.fd_count; i++ )
+#else
+		for ( i = 0; i < nfds; i++ )
+#endif
+		{
+			ber_socket_t wd;
+			int is_listener = 0;
+#ifdef HAVE_WINSOCK
+			wd = writefds.fd_array[i];
+#else
+			if( ! FD_ISSET( i, &writefds ) ) {
 				continue;
 			}
+			wd = i;
+#endif
 
-			if ( FD_ISSET( i, &writefds ) ) {
-				Debug( LDAP_DEBUG_CONNS,
-				    "daemon: signaling write waiter on %d\n", i, 0, 0 );
-
-				assert( FD_ISSET( 0, &slap_daemon.sd_actives) );
-
-				/* clear the write flag */
-				slapd_clr_write( i, 0 );
-				
-				if( connection_write( i ) < 0 ) { 
-					FD_CLR( i, &readfds );
-					slapd_close( i );
+			for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+				if ( i == slap_listeners[l]->sl_sd ) {
+					is_listener = 1;
+					break;
 				}
 			}
+			if ( is_listener ) {
+				continue;
+			}
+			Debug( LDAP_DEBUG_CONNS,
+				"daemon: write active on %d\n",
+				wd, 0, 0 );
+
+			/*
+			 * NOTE: it is possible that the connection was closed
+			 * and that the stream is now inactive.
+			 * connection_write() must valid the stream is still
+			 * active.
+			 */
+
+			if ( connection_write( wd ) < 0 ) {
+				FD_CLR( (unsigned) wd, &readfds );
+				slapd_close( wd );
+			}
 		}
 
-		for ( i = 0; i < nfds; i++ ) {
-			if ( i == tcps ) {
+#ifdef HAVE_WINSOCK
+		for ( i = 0; i < readfds.fd_count; i++ )
+#else
+		for ( i = 0; i < nfds; i++ )
+#endif
+		{
+			ber_socket_t rd;
+			int is_listener = 0;
+
+#ifdef HAVE_WINSOCK
+			rd = readfds.fd_array[i];
+#else
+			if( ! FD_ISSET( i, &readfds ) ) {
 				continue;
 			}
+			rd = i;
+#endif
 
-			if ( FD_ISSET( i, &readfds ) ) {
-				Debug( LDAP_DEBUG_CONNS,
-				    "daemon: read activity on %d\n", i, 0, 0 );
+			for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+				if ( rd == slap_listeners[l]->sl_sd ) {
+					is_listener = 1;
+					break;
+				}
+			}
+			if ( is_listener ) {
+				continue;
+			}
 
-				assert( FD_ISSET( i, &slap_daemon.sd_actives) );
+			Debug ( LDAP_DEBUG_CONNS,
+				"daemon: read activity on %d\n", rd, 0, 0 );
 
-				if( connection_read( i ) < 0) {
-					slapd_close( i );
-				}
+			/*
+			 * NOTE: it is possible that the connection was closed
+			 * and that the stream is now inactive.
+			 * connection_read() must valid the stream is still
+			 * active.
+			 */
+
+			if ( connection_read( rd ) < 0 ) {
+				slapd_close( rd );
 			}
 		}
-
 		ldap_pvt_thread_yield();
 	}
 
@@ -503,8 +897,11 @@ slapd_daemon_task(
 			0, 0, 0 );
 	}
 
-	if( tcps >= 0 ) {
-		tcp_close( tcps );
+	for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+		if ( slap_listeners[l]->sl_sd != AC_SOCKET_INVALID ) {
+			slapd_close( slap_listeners[l]->sl_sd );
+			break;
+		}
 	}
 
 	ldap_pvt_thread_mutex_lock( &active_threads_mutex );
@@ -519,31 +916,152 @@ slapd_daemon_task(
 	return NULL;
 }
 
-int slapd_daemon( struct sockaddr_in *addr )
+
+int slapd_daemon( void )
 {
-	int status;
+	int rc;
+
+	connections_init();
+
+#define SLAPD_LISTENER_THREAD 1
+#if defined( SLAPD_LISTENER_THREAD ) || !defined(HAVE_PTHREADS)
 
-	status = ldap_pvt_thread_create( &listener_tid, 0,
-		 slapd_daemon_task, addr );
+	/* listener as a separate THREAD */
+	rc = ldap_pvt_thread_create( &listener_tid,
+		0, slapd_daemon_task, NULL );
 
-	if ( status != 0 ) {
+	if ( rc != 0 ) {
 		Debug( LDAP_DEBUG_ANY,
-		    "listener ldap_pvt_thread_create failed (%d)\n", status, 0, 0 );
+		    "listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
+		return rc;
+	}
+
+	/* wait for the listener thread to complete */
+	ldap_pvt_thread_join( listener_tid, (void *) NULL );
+#else
+	/* expermimental code */
+	listener_tid = pthread_self();
+	slapd_daemon_task( NULL );
+#endif
+
+	return 0;
+
+}
+
+#ifdef HAVE_WINSOCK2
+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.                                  */
 		return -1;
-	} else {
-		/* wait for the listener thread to complete */
-		ldap_pvt_thread_join( listener_tid, (void *) NULL );
+	}
+ 
+	/* 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.                                        */
+ 
+	if ( LOBYTE( wsaData.wVersion ) != 2 ||
+		HIBYTE( wsaData.wVersion ) != 0 )
+	{
+	    /* Tell the user that we couldn't find a usable */
+	    /* WinSock DLL.                                  */
+	    WSACleanup();
+	    return -1; 
 	}
 
+	/* The WinSock DLL is acceptable. Proceed. */
 	return 0;
 }
 
+int sockdestroy(void)
+{
+	WSACleanup();
+	return 0;
+}
+
+void hit_socket(void)
+{
+	ber_socket_t s;
+	int on = 1;
+	extern struct sockaddr_in	bind_addr;
+
+	/* throw something at the socket to terminate the select() in the daemon thread. */
+	if (( s = socket( AF_INET, SOCK_STREAM, 0 )) == AC_SOCKET_INVALID )
+		Debug( LDAP_DEBUG_ANY,
+			"slap_set_shutdown: socket failed\n\tWSAGetLastError=%d (%s)\n",
+			WSAGetLastError(), WSAGetLastErrorString(), 0 );
+
+	if ( ioctlsocket( s, FIONBIO, &on ) == -1 ) 
+		Debug( LDAP_DEBUG_ANY,
+			"slap_set_shutdown:FIONBIO ioctl on %d faled\n\tWSAGetLastError=%d (%s)\n",
+			s, WSAGetLastError(), WSAGetLastError() );
+	
+	bind_addr.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
+
+	if ( connect( s, (struct sockaddr *)&bind_addr, sizeof( struct sockaddr_in )) == SOCKET_ERROR ) {
+		Debug( LDAP_DEBUG_ANY,
+			"hit_socket: error on connect: %d\n",
+			WSAGetLastError(), 0, 0 );
+		/* we can probably expect some error to occur here, mostly WSAEWOULDBLOCK */
+	}
+
+	tcp_close(s);
+}
+
+#elif HAVE_WINSOCK
+static int sockinit(void)
+{	WSADATA wsaData;
+	if ( WSAStartup( 0x0101, &wsaData ) != 0 ) {
+	    return -1;
+	}
+	return 0;
+}
+static int sockdestroy(void)
+{
+	WSACleanup();
+	return 0;
+}
+
+#else
+static int sockinit(void)
+{
+	return 0;
+}
+static int sockdestroy(void)
+{
+	return 0;
+}
+#endif
+
 void
 slap_set_shutdown( int sig )
 {
-	slapd_shutdown = 1;
-	ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
-
+	int l;
+	slapd_shutdown = sig;
+#ifndef HAVE_WINSOCK
+	if(slapd_listener) {
+		ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
+	}
+#else
+	/* trying to "hit" the socket seems to always get a */
+	/* EWOULDBLOCK error, so just close the listen socket to */
+	/* break out of the select since we're shutting down anyway */
+	for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+		if ( slap_listeners[l]->sl_sd >= 0 ) {
+			tcp_close( slap_listeners[l]->sl_sd );
+		}
+	}
+#endif
 	/* reinstall self */
 	(void) SIGNAL( sig, slap_set_shutdown );
 }