X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Fos-ip.c;h=4b7de9e690f362c5b72c7c56b3a777f6d315e48a;hb=de01a6e3d791d3458549d2ceeccf4d7e0477ff78;hp=738e97f930ed903ef16a9dce65a04476d669ce7e;hpb=7e7db2578d1f323d91ba92482988242ecb8b5c86;p=openldap

diff --git a/libraries/libldap/os-ip.c b/libraries/libldap/os-ip.c
index 738e97f930..4b7de9e690 100644
--- a/libraries/libldap/os-ip.c
+++ b/libraries/libldap/os-ip.c
@@ -1,13 +1,24 @@
+/* os-ip.c -- platform-specific TCP & UDP related code */
 /* $OpenLDAP$ */
-/*
- * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
- */
-/*  Portions
- *  Copyright (c) 1995 Regents of the University of Michigan.
- *  All rights reserved.
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1998-2007 The OpenLDAP Foundation.
+ * Portions Copyright 1999 Lars Uffmann.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
  *
- *  os-ip.c -- platform-specific TCP & UDP related code
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* Portions Copyright (c) 1995 Regents of the University of Michigan.
+ * All rights reserved.
+ */
+/* Significant additional contributors include:
+ *    Lars Uffman
  */
 
 #include "portable.h"
@@ -28,8 +39,6 @@
 
 #include "ldap-int.h"
 
-int ldap_int_tblsize = 0;
-
 #if defined( HAVE_GETADDRINFO ) && defined( HAVE_INET_NTOP )
 #  ifdef LDAP_PF_INET6
 int ldap_int_inet4or6 = AF_UNSPEC;
@@ -38,29 +47,23 @@ int ldap_int_inet4or6 = AF_INET;
 #  endif
 #endif
 
-/*
- * nonblock connect code
- * written by Lars Uffmann, <lars.uffmann@mediaway.net>.
- *
- * Copyright 1999, Lars Uffmann, All rights reserved.
- * This software is not subject to any license of my employer
- * mediaWays GmbH.
- *
- * OpenLDAP COPYING RESTRICTIONS APPLY, see COPYRIGHT file
- *
- * Read about the rationale in ldap_connect_timeout: 
- * ftp://koobera.math.uic.edu/www/docs/connect.html.
- */
+#ifdef LDAP_DEBUG
 
 #define osip_debug(ld,fmt,arg1,arg2,arg3) \
 do { \
 	ldap_log_printf(NULL, LDAP_DEBUG_TRACE, fmt, arg1, arg2, arg3); \
 } while(0)
 
+#else
+
+#define osip_debug(ld,fmt,arg1,arg2,arg3) ((void)0)
+
+#endif /* LDAP_DEBUG */
+
 static void
 ldap_pvt_set_errno(int err)
 {
-	errno = err;
+	sock_errset(err);
 }
 
 int
@@ -120,20 +123,31 @@ ldap_pvt_close_socket(LDAP *ld, int s)
 static int
 ldap_int_prepare_socket(LDAP *ld, int s, int proto )
 {
-	osip_debug(ld, "ldap_prepare_socket: %d\n", s,0,0);
+	osip_debug( ld, "ldap_prepare_socket: %d\n", s, 0, 0 );
 
-#ifdef TCP_NODELAY
-	if( proto == LDAP_PROTO_TCP ) {
+#if defined( SO_KEEPALIVE ) || defined( TCP_NODELAY )
+	if ( proto == LDAP_PROTO_TCP ) {
 		int dummy = 1;
+#ifdef SO_KEEPALIVE
+		if ( setsockopt( s, SOL_SOCKET, SO_KEEPALIVE,
+			(char*) &dummy, sizeof(dummy) ) == AC_SOCKET_ERROR )
+		{
+			osip_debug( ld, "ldap_prepare_socket: "
+				"setsockopt(%d, SO_KEEPALIVE) failed (ignored).\n",
+				s, 0, 0 );
+		}
+#endif /* SO_KEEPALIVE */
+#ifdef TCP_NODELAY
 		if ( setsockopt( s, IPPROTO_TCP, TCP_NODELAY,
 			(char*) &dummy, sizeof(dummy) ) == AC_SOCKET_ERROR )
 		{
-			osip_debug(ld, "ldap_prepare_socket: "
+			osip_debug( ld, "ldap_prepare_socket: "
 				"setsockopt(%d, TCP_NODELAY) failed (ignored).\n",
-				s, 0, 0);
+				s, 0, 0 );
 		}
+#endif /* TCP_NODELAY */
 	}
-#endif
+#endif /* SO_KEEPALIVE || TCP_NODELAY */
 
 	return 0;
 }
@@ -200,17 +214,147 @@ ldap_pvt_is_socket_ready(LDAP *ld, int s)
 
 #endif /* HAVE_WINSOCK */
 
+/* NOTE: this is identical to analogous code in os-local.c */
+int
+ldap_int_poll(
+	LDAP *ld,
+	ber_socket_t s,
+	struct timeval *tvp )
+{
+	int		rc;
+		
+
+	osip_debug(ld, "ldap_int_poll: fd: %d tm: %ld\n",
+		s, tvp ? tvp->tv_sec : -1L, 0);
+
+#ifdef HAVE_POLL
+	{
+		struct pollfd fd;
+		int timeout = INFTIM;
+
+		fd.fd = s;
+		fd.events = POLL_WRITE;
+
+		if ( tvp != NULL ) {
+			timeout = TV2MILLISEC( tvp );
+		}
+		do {
+			fd.revents = 0;
+			rc = poll( &fd, 1, timeout );
+		
+		} while ( rc == AC_SOCKET_ERROR && errno == EINTR &&
+			LDAP_BOOL_GET( &ld->ld_options, LDAP_BOOL_RESTART ) );
+
+		if ( rc == AC_SOCKET_ERROR ) {
+			return rc;
+		}
+
+		if ( timeout == 0 && rc == 0 ) {
+			return -2;
+		}
+
+		if ( fd.revents & POLL_WRITE ) {
+			if ( ldap_pvt_is_socket_ready( ld, s ) == -1 ) {
+				return -1;
+			}
+
+			if ( ldap_pvt_ndelay_off( ld, s ) == -1 ) {
+				return -1;
+			}
+			return 0;
+		}
+	}
+#else
+	{
+		fd_set		wfds, *z = NULL;
+#ifdef HAVE_WINSOCK
+		fd_set		efds;
+#endif
+		struct timeval	tv = { 0 };
+
+#if defined( FD_SETSIZE ) && !defined( HAVE_WINSOCK )
+		if ( s >= FD_SETSIZE ) {
+			rc = AC_SOCKET_ERROR;
+			tcp_close( s );
+			ldap_pvt_set_errno( EMFILE );
+			return rc;
+		}
+#endif
+
+		if ( tvp != NULL ) {
+			tv = *tvp;
+		}
+
+		do {
+			FD_ZERO(&wfds);
+			FD_SET(s, &wfds );
+
+#ifdef HAVE_WINSOCK
+			FD_ZERO(&efds);
+			FD_SET(s, &efds );
+#endif
+
+			rc = select( ldap_int_tblsize, z, &wfds,
+#ifdef HAVE_WINSOCK
+				&efds,
+#else
+				z,
+#endif
+				tvp ? &tv : NULL );
+		} while ( rc == AC_SOCKET_ERROR && errno == EINTR &&
+			LDAP_BOOL_GET( &ld->ld_options, LDAP_BOOL_RESTART ) );
+
+		if ( rc == AC_SOCKET_ERROR ) {
+			return rc;
+		}
+
+		if ( rc == 0 && tvp && tvp->tv_sec == 0 && tvp->tv_usec == 0 ) {
+			return -2;
+		}
+
+#ifdef HAVE_WINSOCK
+		/* This means the connection failed */
+		if ( FD_ISSET(s, &efds) ) {
+			int so_errno;
+			int dummy = sizeof(so_errno);
+			if ( getsockopt( s, SOL_SOCKET, SO_ERROR,
+				(char *) &so_errno, &dummy ) == AC_SOCKET_ERROR || !so_errno )
+			{
+				/* impossible */
+				so_errno = WSAGetLastError();
+			}
+			ldap_pvt_set_errno( so_errno );
+			osip_debug(ld, "ldap_int_poll: error on socket %d: "
+			       "errno: %d (%s)\n", s, errno, sock_errstr( errno ));
+			return -1;
+		}
+#endif
+		if ( FD_ISSET(s, &wfds) ) {
+#ifndef HAVE_WINSOCK
+			if ( ldap_pvt_is_socket_ready( ld, s ) == -1 ) {
+				return -1;
+			}
+#endif
+			if ( ldap_pvt_ndelay_off(ld, s) == -1 ) {
+				return -1;
+			}
+			return 0;
+		}
+	}
+#endif
+
+	osip_debug(ld, "ldap_int_poll: timed out\n",0,0,0);
+	ldap_pvt_set_errno( ETIMEDOUT );
+	return -1;
+}
+
 static int
 ldap_pvt_connect(LDAP *ld, ber_socket_t s,
 	struct sockaddr *sin, socklen_t addrlen,
 	int async)
 {
-	int rc;
-	struct timeval	tv, *opt_tv=NULL;
-	fd_set		wfds, *z=NULL;
-#ifdef HAVE_WINSOCK
-	fd_set		efds;
-#endif
+	int rc, err;
+	struct timeval	tv, *opt_tv = NULL;
 
 #ifdef LDAP_CONNECTIONLESS
 	/* We could do a connect() but that would interfere with
@@ -224,85 +368,38 @@ ldap_pvt_connect(LDAP *ld, ber_socket_t s,
 		return ( 0 );
 	}
 #endif
-	if ( (opt_tv = ld->ld_options.ldo_tm_net) != NULL ) {
-		tv.tv_usec = opt_tv->tv_usec;
-		tv.tv_sec = opt_tv->tv_sec;
+	if ( ld->ld_options.ldo_tm_net.tv_sec >= 0 ) {
+		tv = ld->ld_options.ldo_tm_net;
+		opt_tv = &tv;
 	}
 
-	osip_debug(ld, "ldap_connect_timeout: fd: %d tm: %ld async: %d\n",
+	osip_debug(ld, "ldap_pvt_connect: fd: %d tm: %ld async: %d\n",
 			s, opt_tv ? tv.tv_sec : -1L, async);
 
-	if ( ldap_pvt_ndelay_on(ld, s) == -1 )
+	if ( opt_tv && ldap_pvt_ndelay_on(ld, s) == -1 )
 		return ( -1 );
 
 	if ( connect(s, sin, addrlen) != AC_SOCKET_ERROR ) {
-		if ( ldap_pvt_ndelay_off(ld, s) == -1 )
+		if ( opt_tv && ldap_pvt_ndelay_off(ld, s) == -1 )
 			return ( -1 );
 		return ( 0 );
 	}
 
-#ifdef HAVE_WINSOCK
-	ldap_pvt_set_errno( WSAGetLastError() );
-#endif
-
-	if ( errno != EINPROGRESS && errno != EWOULDBLOCK ) {
+	err = sock_errno();
+	if ( err != EINPROGRESS && err != EWOULDBLOCK ) {
 		return ( -1 );
 	}
 	
-#ifdef notyet
-	if ( async ) return ( -2 );
-#endif
-
-	FD_ZERO(&wfds);
-	FD_SET(s, &wfds );
+	if ( async ) {
+		/* caller will call ldap_int_poll() as appropriate? */
+		return ( -2 );
+	}
 
-#ifdef HAVE_WINSOCK
-	FD_ZERO(&efds);
-	FD_SET(s, &efds );
-#endif
+	rc = ldap_int_poll( ld, s, opt_tv );
 
-	do {
-		rc = select(ldap_int_tblsize, z, &wfds,
-#ifdef HAVE_WINSOCK
-			&efds,
-#else
-			z,
-#endif
-			opt_tv ? &tv : NULL);
-	} while( rc == AC_SOCKET_ERROR && errno == EINTR &&
-		LDAP_BOOL_GET(&ld->ld_options, LDAP_BOOL_RESTART ));
+	osip_debug(ld, "ldap_pvt_connect: %d\n", rc, 0, 0);
 
-	if( rc == AC_SOCKET_ERROR ) return rc;
-
-#ifdef HAVE_WINSOCK
-	/* This means the connection failed */
-	if ( FD_ISSET(s, &efds) ) {
-	    int so_errno;
-	    int dummy = sizeof(so_errno);
-	    if ( getsockopt( s, SOL_SOCKET, SO_ERROR,
-			(char *) &so_errno, &dummy ) == AC_SOCKET_ERROR || !so_errno )
-	    {
-	    	/* impossible */
-	    	so_errno = WSAGetLastError();
-	    }
-	    ldap_pvt_set_errno(so_errno);
-	    osip_debug(ld, "ldap_pvt_connect: error on socket %d: "
-		       "errno: %d (%s)\n", s, errno, sock_errstr(errno));
-	    return -1;
-	}
-#endif
-	if ( FD_ISSET(s, &wfds) ) {
-#ifndef HAVE_WINSOCK
-		if ( ldap_pvt_is_socket_ready(ld, s) == -1 )
-			return ( -1 );
-#endif
-		if ( ldap_pvt_ndelay_off(ld, s) == -1 )
-			return ( -1 );
-		return ( 0 );
-	}
-	osip_debug(ld, "ldap_connect_timeout: timed out\n",0,0,0);
-	ldap_pvt_set_errno( ETIMEDOUT );
-	return ( -1 );
+	return rc;
 }
 
 #ifndef HAVE_INET_ATON
@@ -310,11 +407,14 @@ int
 ldap_pvt_inet_aton( const char *host, struct in_addr *in)
 {
 	unsigned long u = inet_addr( host );
-	if ( u != 0xffffffff || u != (unsigned long) -1 ) {
-		in->s_addr = u;
-		return 1;
-	}
-	return 0;
+
+#ifdef INADDR_NONE
+	if ( u == INADDR_NONE ) return 0;
+#endif
+	if ( u == 0xffffffffUL || u == (unsigned long) -1L ) return 0;
+
+	in->s_addr = u;
+	return 1;
 }
 #endif
 
@@ -322,82 +422,92 @@ ldap_pvt_inet_aton( const char *host, struct in_addr *in)
 int
 ldap_connect_to_host(LDAP *ld, Sockbuf *sb,
 	int proto,
-	const char *host,
-	unsigned long address, int port, int async )
+	const char *host, int port,
+	int async )
 {
+	int	rc;
+	int	socktype;
 	ber_socket_t		s = AC_SOCKET_INVALID;
-	int			rc, i, use_hp = 0;
-	struct hostent		*hp = NULL;
-#if !defined( HAVE_GETADDRINFO ) || !defined( HAVE_INET_NTOP )
+
+#if defined( HAVE_GETADDRINFO ) && defined( HAVE_INET_NTOP )
+	char serv[7];
+	int err;
+	struct addrinfo hints, *res, *sai;
+#else
+	int i;
+	int use_hp = 0;
+	struct hostent *hp = NULL;
 	struct hostent he_buf;
+	struct in_addr in;
+	char *ha_buf=NULL;
 #endif
-	char   			*ha_buf=NULL, *p, *q;
-	int			socktype;
 
+	if( host == NULL ) host = "localhost";
 	
 	switch(proto) {
 	case LDAP_PROTO_TCP: socktype = SOCK_STREAM;
-		osip_debug(ld, "ldap_connect_to_host: TCP %s:%d\n",host,port,0);
+		osip_debug( ld,
+			"ldap_connect_to_host: TCP %s:%d\n",
+			host, port, 0);
 		break;
 	case LDAP_PROTO_UDP: socktype = SOCK_DGRAM;
-		osip_debug(ld, "ldap_connect_to_host: UDP %s:%d\n",host,port,0);
+		osip_debug( ld,
+			"ldap_connect_to_host: UDP %s:%d\n",
+			host, port, 0);
 		break;
-
 	default:
-		osip_debug(ld, "ldap_connect_to_host: unknown proto: %d\n",
-			proto, 0, 0);
+		osip_debug( ld, "ldap_connect_to_host: unknown proto: %d\n",
+			proto, 0, 0 );
 		return -1;
 	}
 
-	if (host != NULL) {
 #if defined( HAVE_GETADDRINFO ) && defined( HAVE_INET_NTOP )
-		char serv[7];
-		int err;
-		struct addrinfo hints, *res, *sai;
-
-		memset( &hints, '\0', sizeof(hints) );
-		hints.ai_family = ldap_int_inet4or6;
-		hints.ai_socktype = socktype;
-
-		snprintf(serv, sizeof serv, "%d", port );
+	memset( &hints, '\0', sizeof(hints) );
+#ifdef USE_AI_ATTRCONFIG /* FIXME: configure test needed */
+	/* Use AI_ATTRCONFIG only on systems where its known to be needed. */
+	hints.ai_flags = AI_ATTRCONFIG;
+#endif
+	hints.ai_family = ldap_int_inet4or6;
+	hints.ai_socktype = socktype;
+	snprintf(serv, sizeof serv, "%d", port );
 
 #ifdef LDAP_R_COMPILE
-		/* most getaddrinfo(3) use non-threadsafe resolver libraries */
-		ldap_pvt_thread_mutex_lock(&ldap_int_resolv_mutex);
+	/* most getaddrinfo(3) use non-threadsafe resolver libraries */
+	ldap_pvt_thread_mutex_lock(&ldap_int_resolv_mutex);
 #endif
 
-		err = getaddrinfo( host, serv, &hints, &res );
+	err = getaddrinfo( host, serv, &hints, &res );
 
 #ifdef LDAP_R_COMPILE
-		ldap_pvt_thread_mutex_unlock(&ldap_int_resolv_mutex);
+	ldap_pvt_thread_mutex_unlock(&ldap_int_resolv_mutex);
 #endif
 
-		if ( err != 0 ) {
-			osip_debug(ld, "ldap_connect_to_host: getaddrinfo failed: %s\n",
-				AC_GAI_STRERROR(err), 0, 0);
-			return -1;
-		}
-		rc = -1;
+	if ( err != 0 ) {
+		osip_debug(ld, "ldap_connect_to_host: getaddrinfo failed: %s\n",
+			AC_GAI_STRERROR(err), 0, 0);
+		return -1;
+	}
+	rc = -1;
 
-		for( sai=res; sai != NULL; sai=sai->ai_next) {
-			if( sai->ai_addr == NULL ) {
-				osip_debug(ld, "ldap_connect_to_host: getaddrinfo "
-					"ai_addr is NULL?\n", 0, 0, 0);
-				continue;
-			}
+	for( sai=res; sai != NULL; sai=sai->ai_next) {
+		if( sai->ai_addr == NULL ) {
+			osip_debug(ld, "ldap_connect_to_host: getaddrinfo "
+				"ai_addr is NULL?\n", 0, 0, 0);
+			continue;
+		}
 
-			/* we assume AF_x and PF_x are equal for all x */
-			s = ldap_int_socket( ld, sai->ai_family, socktype );
-			if ( s == AC_SOCKET_INVALID ) {
-				continue;
-			}
+		/* we assume AF_x and PF_x are equal for all x */
+		s = ldap_int_socket( ld, sai->ai_family, socktype );
+		if ( s == AC_SOCKET_INVALID ) {
+			continue;
+		}
 
-			if ( ldap_int_prepare_socket(ld, s, proto ) == -1 ) {
-				ldap_pvt_close_socket(ld, s);
-				break;
-			}
+		if ( ldap_int_prepare_socket(ld, s, proto ) == -1 ) {
+			ldap_pvt_close_socket(ld, s);
+			break;
+		}
 
-			switch (sai->ai_family) {
+		switch (sai->ai_family) {
 #ifdef LDAP_PF_INET6
 			case AF_INET6: {
 				char addr[INET6_ADDRSTRLEN];
@@ -416,39 +526,36 @@ ldap_connect_to_host(LDAP *ld, Sockbuf *sb,
 				osip_debug(ld, "ldap_connect_to_host: Trying %s:%s\n", 
 					addr, serv, 0);
 			} break;
-			}
+		}
 
-			rc = ldap_pvt_connect(ld, s, sai->ai_addr, sai->ai_addrlen, async);
-			if ( (rc == 0) || (rc == -2) ) {
-				ber_sockbuf_ctrl( sb, LBER_SB_OPT_SET_FD, &s );
-				break;
-			}
-			ldap_pvt_close_socket(ld, s);
+		rc = ldap_pvt_connect( ld, s,
+			sai->ai_addr, sai->ai_addrlen, async );
+		if ( rc == 0 || rc == -2 ) {
+			ber_sockbuf_ctrl( sb, LBER_SB_OPT_SET_FD, &s );
+			break;
 		}
-		freeaddrinfo(res);
-		return rc;
+		ldap_pvt_close_socket(ld, s);
+	}
+	freeaddrinfo(res);
 
 #else
-		struct in_addr in;
-		if (! inet_aton( host, &in) ) {
-			int local_h_errno;
-			rc = ldap_pvt_gethostbyname_a(host, &he_buf, &ha_buf,
-					&hp, &local_h_errno);
+	if (! inet_aton( host, &in ) ) {
+		int local_h_errno;
+		rc = ldap_pvt_gethostbyname_a( host, &he_buf, &ha_buf,
+			&hp, &local_h_errno );
 
-			if ( (rc < 0) || (hp == NULL) ) {
+		if ( (rc < 0) || (hp == NULL) ) {
 #ifdef HAVE_WINSOCK
-				ldap_pvt_set_errno( WSAGetLastError() );
+			ldap_pvt_set_errno( WSAGetLastError() );
 #else
-				/* not exactly right, but... */
-				ldap_pvt_set_errno( EHOSTUNREACH );
+			/* not exactly right, but... */
+			ldap_pvt_set_errno( EHOSTUNREACH );
 #endif
-				if (ha_buf) LDAP_FREE(ha_buf);
-				return -1;
-			}
-			use_hp = 1;
+			if (ha_buf) LDAP_FREE(ha_buf);
+			return -1;
 		}
-		address = in.s_addr;
-#endif
+
+		use_hp = 1;
 	}
 
 	rc = s = -1;
@@ -469,15 +576,30 @@ ldap_connect_to_host(LDAP *ld, Sockbuf *sb,
 		(void)memset((char *)&sin, '\0', sizeof sin);
 		sin.sin_family = AF_INET;
 		sin.sin_port = htons((short) port);
-		p = (char *)&sin.sin_addr;
-		q = use_hp ? (char *)hp->h_addr_list[i] : (char *)&address;
-		AC_MEMCPY(p, q, sizeof(sin.sin_addr) );
 
+		if( use_hp ) {
+			AC_MEMCPY( &sin.sin_addr, hp->h_addr_list[i],
+				sizeof(sin.sin_addr) );
+		} else {
+			AC_MEMCPY( &sin.sin_addr, &in.s_addr,
+				sizeof(sin.sin_addr) );
+		}
+
+#ifdef HAVE_INET_NTOA_B
+		{
+			/* for VxWorks */
+			char address[INET_ADDR_LEN];
+			inet_ntoa_b(sin.sin_address, address);
+			osip_debug(ld, "ldap_connect_to_host: Trying %s:%d\n", 
+				address, port, 0);
+		}
+#else
 		osip_debug(ld, "ldap_connect_to_host: Trying %s:%d\n", 
-			inet_ntoa(sin.sin_addr),port,0);
+			inet_ntoa(sin.sin_addr), port, 0);
+#endif
 
 		rc = ldap_pvt_connect(ld, s,
-			(struct sockaddr *)&sin, sizeof(struct sockaddr_in),
+			(struct sockaddr *)&sin, sizeof(sin),
 			async);
    
 		if ( (rc == 0) || (rc == -2) ) {
@@ -487,17 +609,17 @@ ldap_connect_to_host(LDAP *ld, Sockbuf *sb,
 
 		ldap_pvt_close_socket(ld, s);
 
-		if (!use_hp)
-			break;
+		if (!use_hp) break;
 	}
 	if (ha_buf) LDAP_FREE(ha_buf);
+#endif
+
 	return rc;
 }
 
-#if defined( LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND ) || \
-	defined( HAVE_CYRUS_SASL )
+#if defined( HAVE_CYRUS_SASL )
 char *
-ldap_host_connected_to( Sockbuf *sb )
+ldap_host_connected_to( Sockbuf *sb, const char *host )
 {
 	socklen_t		len;
 #ifdef LDAP_PF_INET6
@@ -506,9 +628,6 @@ ldap_host_connected_to( Sockbuf *sb )
 	struct sockaddr sabuf;
 #endif
 	struct sockaddr	*sa = (struct sockaddr *) &sabuf;
-	char			*host = NULL, *herr;
-	char hbuf[NI_MAXHOST];
-	int rc;
 	ber_socket_t	sd;
 
 	(void)memset( (char *)sa, '\0', sizeof sabuf );
@@ -570,27 +689,43 @@ ldap_host_connected_to( Sockbuf *sb )
 		break;
 	}
 
-	hbuf[0] = 0;
-	if (ldap_pvt_get_hname( sa, len, hbuf, sizeof(hbuf), &herr ) == 0 &&
-		hbuf[0] ) 
 	{
-		host = LDAP_STRDUP( hbuf );   
+		char *herr;
+#ifdef NI_MAXHOST
+		char hbuf[NI_MAXHOST];
+#elif defined( MAXHOSTNAMELEN
+		char hbuf[MAXHOSTNAMELEN];
+#else
+		char hbuf[256];
+#endif
+		hbuf[0] = 0;
+
+		if (ldap_pvt_get_hname( sa, len, hbuf, sizeof(hbuf), &herr ) == 0
+			&& hbuf[0] ) 
+		{
+			return LDAP_STRDUP( hbuf );   
+		}
 	}
 
-	return host;
+	return host ? LDAP_STRDUP( host ) : NULL;
 }
 #endif
 
 
-/* for UNIX */
 struct selectinfo {
+#ifdef HAVE_POLL
+	/* for UNIX poll(2) */
+	int si_maxfd;
+	struct pollfd si_fds[FD_SETSIZE];
+#else
+	/* for UNIX select(2) */
 	fd_set	si_readfds;
 	fd_set	si_writefds;
 	fd_set	si_use_readfds;
 	fd_set	si_use_writefds;
+#endif
 };
 
-
 void
 ldap_mark_select_write( LDAP *ld, Sockbuf *sb )
 {
@@ -600,9 +735,39 @@ ldap_mark_select_write( LDAP *ld, Sockbuf *sb )
 	sip = (struct selectinfo *)ld->ld_selectinfo;
 	
 	ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_FD, &sd );
+
+#ifdef HAVE_POLL
+	/* for UNIX poll(2) */
+	{
+		int empty=-1;
+		int i;
+		for(i=0; i < sip->si_maxfd; i++) {
+			if( sip->si_fds[i].fd == sd ) {
+				sip->si_fds[i].events |= POLL_WRITE;
+				return;
+			}
+			if( empty==-1 && sip->si_fds[i].fd == -1 ) {
+				empty=i;
+			}
+		}
+
+		if( empty == -1 ) {
+			if( sip->si_maxfd >= FD_SETSIZE ) {
+				/* FIXME */
+				return;
+			}
+			empty = sip->si_maxfd++;
+		}
+
+		sip->si_fds[empty].fd = sd;
+		sip->si_fds[empty].events = POLL_WRITE;
+	}
+#else
+	/* for UNIX select(2) */
 	if ( !FD_ISSET( sd, &sip->si_writefds )) {
 		FD_SET( sd, &sip->si_writefds );
 	}
+#endif
 }
 
 
@@ -615,9 +780,39 @@ ldap_mark_select_read( LDAP *ld, Sockbuf *sb )
 	sip = (struct selectinfo *)ld->ld_selectinfo;
 
 	ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_FD, &sd );
+
+#ifdef HAVE_POLL
+	/* for UNIX poll(2) */
+	{
+		int empty=-1;
+		int i;
+		for(i=0; i < sip->si_maxfd; i++) {
+			if( sip->si_fds[i].fd == sd ) {
+				sip->si_fds[i].events |= POLL_READ;
+				return;
+			}
+			if( empty==-1 && sip->si_fds[i].fd == -1 ) {
+				empty=i;
+			}
+		}
+
+		if( empty == -1 ) {
+			if( sip->si_maxfd >= FD_SETSIZE ) {
+				/* FIXME */
+				return;
+			}
+			empty = sip->si_maxfd++;
+		}
+
+		sip->si_fds[empty].fd = sd;
+		sip->si_fds[empty].events = POLL_READ;
+	}
+#else
+	/* for UNIX select(2) */
 	if ( !FD_ISSET( sd, &sip->si_readfds )) {
 		FD_SET( sd, &sip->si_readfds );
 	}
+#endif
 }
 
 
@@ -630,8 +825,22 @@ ldap_mark_select_clear( LDAP *ld, Sockbuf *sb )
 	sip = (struct selectinfo *)ld->ld_selectinfo;
 
 	ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_FD, &sd );
+
+#ifdef HAVE_POLL
+	/* for UNIX poll(2) */
+	{
+		int i;
+		for(i=0; i < sip->si_maxfd; i++) {
+			if( sip->si_fds[i].fd == sd ) {
+				sip->si_fds[i].fd = -1;
+			}
+		}
+	}
+#else
+	/* for UNIX select(2) */
 	FD_CLR( sd, &sip->si_writefds );
 	FD_CLR( sd, &sip->si_readfds );
+#endif
 }
 
 
@@ -644,7 +853,23 @@ ldap_is_write_ready( LDAP *ld, Sockbuf *sb )
 	sip = (struct selectinfo *)ld->ld_selectinfo;
 
 	ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_FD, &sd );
+
+#ifdef HAVE_POLL
+	/* for UNIX poll(2) */
+	{
+		int i;
+		for(i=0; i < sip->si_maxfd; i++) {
+			if( sip->si_fds[i].fd == sd ) {
+				return sip->si_fds[i].revents & POLL_WRITE;
+			}
+		}
+
+		return 0;
+	}
+#else
+	/* for UNIX select(2) */
 	return( FD_ISSET( sd, &sip->si_use_writefds ));
+#endif
 }
 
 
@@ -657,7 +882,23 @@ ldap_is_read_ready( LDAP *ld, Sockbuf *sb )
 	sip = (struct selectinfo *)ld->ld_selectinfo;
 
 	ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_FD, &sd );
+
+#ifdef HAVE_POLL
+	/* for UNIX poll(2) */
+	{
+		int i;
+		for(i=0; i < sip->si_maxfd; i++) {
+			if( sip->si_fds[i].fd == sd ) {
+				return sip->si_fds[i].revents & POLL_READ;
+			}
+		}
+
+		return 0;
+	}
+#else
+	/* for UNIX select(2) */
 	return( FD_ISSET( sd, &sip->si_use_readfds ));
+#endif
 }
 
 
@@ -666,11 +907,18 @@ ldap_new_select_info( void )
 {
 	struct selectinfo	*sip;
 
-	if (( sip = (struct selectinfo *)LDAP_CALLOC( 1,
-	    sizeof( struct selectinfo ))) != NULL ) {
-		FD_ZERO( &sip->si_readfds );
-		FD_ZERO( &sip->si_writefds );
-	}
+	sip = (struct selectinfo *)LDAP_CALLOC( 1, sizeof( struct selectinfo ));
+
+	if ( sip == NULL ) return NULL;
+
+#ifdef HAVE_POLL
+	/* for UNIX poll(2) */
+	/* sip->si_maxfd=0 */
+#else
+	/* for UNIX select(2) */
+	FD_ZERO( &sip->si_readfds );
+	FD_ZERO( &sip->si_writefds );
+#endif
 
 	return( (void *)sip );
 }
@@ -683,45 +931,59 @@ ldap_free_select_info( void *sip )
 }
 
 
+#ifndef HAVE_POLL
+int ldap_int_tblsize = 0;
+
 void
 ldap_int_ip_init( void )
 {
-	int tblsize;
 #if defined( HAVE_SYSCONF )
-	tblsize = sysconf( _SC_OPEN_MAX );
+	long tblsize = sysconf( _SC_OPEN_MAX );
+	if( tblsize > INT_MAX ) tblsize = INT_MAX;
+
 #elif defined( HAVE_GETDTABLESIZE )
-	tblsize = getdtablesize();
+	int tblsize = getdtablesize();
 #else
-	tblsize = FD_SETSIZE;
+	int tblsize = FD_SETSIZE;
 #endif /* !USE_SYSCONF */
 
 #ifdef FD_SETSIZE
-	if( tblsize > FD_SETSIZE )
-		tblsize = FD_SETSIZE;
-#endif	/* FD_SETSIZE*/
+	if( tblsize > FD_SETSIZE ) tblsize = FD_SETSIZE;
+#endif	/* FD_SETSIZE */
+
 	ldap_int_tblsize = tblsize;
 }
+#endif
 
 
 int
 ldap_int_select( LDAP *ld, struct timeval *timeout )
 {
+	int rc;
 	struct selectinfo	*sip;
 
-#ifdef NEW_LOGGING
-	LDAP_LOG ( CONNECTION, ENTRY, "ldap_int_select\n", 0, 0, 0 );
-#else
 	Debug( LDAP_DEBUG_TRACE, "ldap_int_select\n", 0, 0, 0 );
-#endif
 
-	if ( ldap_int_tblsize == 0 )
-		ldap_int_ip_init();
+#ifndef HAVE_POLL
+	if ( ldap_int_tblsize == 0 ) ldap_int_ip_init();
+#endif
 
 	sip = (struct selectinfo *)ld->ld_selectinfo;
+	assert( sip != NULL );
+
+#ifdef HAVE_POLL
+	{
+		int to = timeout ? TV2MILLISEC( timeout ) : INFTIM;
+		rc = poll( sip->si_fds, sip->si_maxfd, to );
+	}
+#else
 	sip->si_use_readfds = sip->si_readfds;
 	sip->si_use_writefds = sip->si_writefds;
 	
-	return( select( ldap_int_tblsize,
-	                &sip->si_use_readfds, &sip->si_use_writefds,
-	                NULL, timeout ));
+	rc = select( ldap_int_tblsize,
+		&sip->si_use_readfds, &sip->si_use_writefds,
+		NULL, timeout );
+#endif
+
+	return rc;
 }