OpenSolaris Launch

1 files changed, 614 insertions, 0 deletions

diff --git a/usr/src/lib/libldap4/common/os-ip.c b/usr/src/lib/libldap4/common/os-ip.c
new file mode 100644
index 0000000000..5f025ee548
--- /dev/null
+++ b/usr/src/lib/libldap4/common/os-ip.c
@@ -0,0 +1,614 @@
+/*
+ * Copyright (c) 1995-2001 by Sun Microsystems, Inc.
+ * All rights reserved.
+ */
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+/*
+ *  Copyright (c) 1995 Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  os-ip.c -- platform-specific TCP & UDP related code
+ */
+
+#ifndef lint
+static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of Michigan.\nAll rights reserved.\n";
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <arpa/inet.h>
+
+#ifdef _WIN32
+#include <io.h>
+#include "msdos.h"
+#else /* _WIN32 */
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#endif /* _WIN32 */
+#ifdef _AIX
+#include <sys/select.h>
+#endif /* _AIX */
+#ifdef VMS
+#include "ucx_select.h"
+#endif /* VMS */
+#include "portable.h"
+#include "lber.h"
+#include "ldap.h"
+#include "ldap-private.h"
+#include "ldap-int.h"
+
+#ifdef LDAP_REFERRALS
+#ifdef USE_SYSCONF
+#include <unistd.h>
+#endif /* USE_SYSCONF */
+#ifdef notyet
+#ifdef NEED_FILIO
+#include <sys/filio.h>
+#else /* NEED_FILIO */
+#include <sys/ioctl.h>
+#endif /* NEED_FILIO */
+#endif /* notyet */
+#endif /* LDAP_REFERRALS */
+
+#ifdef MACOS
+#define	tcp_close(s)	tcpclose(s)
+#else /* MACOS */
+#ifdef DOS
+#ifdef PCNFS
+#define	tcp_close(s)	close(s)
+#endif /* PCNFS */
+#ifdef NCSA
+#define	tcp_close(s)	netclose(s); netshut()
+#endif /* NCSA */
+#ifdef WINSOCK
+#define	tcp_close(s)	closesocket(s); WSACleanup();
+#endif /* WINSOCK */
+#else /* DOS */
+#define	tcp_close(s)	close(s)
+#endif /* DOS */
+#endif /* MACOS */
+#ifdef SUN
+#include <nss_dbdefs.h>
+#endif
+
+#include <fcntl.h>
+#include <sys/poll.h>
+
+
+/*
+ * Do an async connect or blocking connect depending on the timeout
+ * value. LDAP_X_IO_TIMEOUT_NO_TIMEOUT means do a blocking connect.
+ * Otherwise wait for timeout milliseconds for the connection.
+ * Returns 0 on success and -1 on failure.
+ */
+static int
+do_connect(int s, struct sockaddr *sin, int timeout)
+{
+	int flags, connected = 0;
+	int retval, error, n;
+	fd_set wfds;
+	struct timeval waittime, *sel_timeout;
+
+	/* set the socket to do non-blocking i/o */
+	flags = fcntl(s, F_GETFL, 0);
+	fcntl(s, F_SETFL, flags | O_NONBLOCK);
+
+	if (connect(s, sin, sizeof (struct sockaddr_in)) == 0) {
+		connected = 1;
+	} else if (errno == EINPROGRESS) {
+		/* if NO_TIMEOUT is specified do a blocking connect */
+		if (timeout <= LDAP_X_IO_TIMEOUT_NO_TIMEOUT) {
+			sel_timeout = NULL;
+		} else {
+			/* set the timeout to the specified value */
+			waittime.tv_sec = timeout / MILLISEC;
+			waittime.tv_usec = (timeout % MILLISEC) * 1000;
+			sel_timeout = &waittime;
+		}
+
+		FD_ZERO(&wfds);
+		FD_SET(s, &wfds);
+		n = sizeof (error);
+		if (select(s+1, NULL, &wfds, NULL, sel_timeout) > 0 &&
+			FD_ISSET(s, &wfds) &&
+			getsockopt(s, SOL_SOCKET, SO_ERROR, &error, &n) == 0 &&
+			error == 0) {
+			connected = 1;
+		}
+	}
+
+	/* if we are connected restore the flags for the socket */
+	if (connected) {
+		fcntl(s, F_SETFL, flags);
+	}
+
+	return (connected ? 0 : -1);
+}
+
+
+int
+connect_to_host(Sockbuf *sb, char *host, in_addr_t address,
+	int port, int async, int timeout)
+/*
+ * if host == NULL, connect using address
+ * "address" and "port" must be in network byte order
+ * zero is returned upon success, -1 if fatal error, -2 EINPROGRESS
+ * async is only used ifdef LDAP_REFERRALS (non-0 means don't wait for connect)
+ * XXX async is not used yet!
+ */
+{
+	int			rc, i, s, connected, use_hp;
+	struct sockaddr_in	sin;
+	struct hostent		*hp;
+#ifdef notyet
+#ifdef LDAP_REFERRALS
+	int			status;	/* for ioctl call */
+#endif /* LDAP_REFERRALS */
+#endif /* notyet */
+#ifdef SUN
+	struct hostent		hpret;
+	char			hpbuf[NSS_BUFLEN_HOSTS];
+	int			hperrno;
+#endif
+
+	Debug(LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 201, "connect_to_host: "
+		"%1$s:%2$d\n"), (host == NULL) ? catgets(slapdcat, 1, 202,
+		"(by address)") : host, ntohs(port), 0);
+
+	connected = use_hp = 0;
+
+	if (host != NULL && (address = inet_addr(host)) == -1) {
+#ifdef SUN
+		if ((hp = gethostbyname_r(host, &hpret, hpbuf,
+			NSS_BUFLEN_HOSTS, &hperrno)) == NULL) {
+#else
+		if ((hp = gethostbyname(host)) == NULL) {
+#endif
+			errno = EHOSTUNREACH;	/* not exactly right, but... */
+			return (-1);
+		}
+		use_hp = 1;
+	}
+
+	rc = -1;
+	for (i = 0; !use_hp || (hp->h_addr_list[i] != 0); i++) {
+		if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+			return (-1);
+		}
+#ifdef notyet
+#ifdef LDAP_REFERRALS
+		status = 1;
+		if (async && ioctl(s, FIONBIO, (caddr_t)&status) == -1) {
+			Debug(LDAP_DEBUG_ANY, catgets(slapdcat, 1, 203,
+				"FIONBIO ioctl failed on %d\n"), s, 0, 0);
+		}
+#endif /* LDAP_REFERRALS */
+#endif /* notyet */
+		(void) memset((char *)&sin, 0, sizeof (struct sockaddr_in));
+		sin.sin_family = AF_INET;
+		sin.sin_port = port;
+		SAFEMEMCPY((char *) &sin.sin_addr.s_addr,
+		    (use_hp ? (char *) hp->h_addr_list[i] :
+		    (char *)&address), sizeof (sin.sin_addr.s_addr));
+
+		if (do_connect(s, (struct sockaddr *)&sin, timeout) == 0) {
+			connected = 1;
+			break;
+		}
+
+#ifdef notyet
+#ifdef LDAP_REFERRALS
+#ifdef EAGAIN
+		if (errno == EINPROGRESS || errno == EAGAIN) {
+#else /* EAGAIN */
+		if (errno == EINPROGRESS) {
+#endif /* EAGAIN */
+			Debug(LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 204,
+				"connect would block...\n"), 0, 0, 0);
+			rc = -2;
+			break;
+		}
+#endif /* LDAP_REFERRALS */
+#endif /* notyet */
+
+#ifdef LDAP_DEBUG
+		if (ldap_debug & LDAP_DEBUG_TRACE) {
+			perror((char *)inet_ntoa(sin.sin_addr));
+		}
+#endif
+		close(s);
+		if (!use_hp) {
+			break;
+		}
+	}
+
+	if (connected) {
+		rc = 0;
+		sb->sb_sd = s;
+#ifdef notyet
+#ifdef LDAP_REFERRALS
+		status = 0;
+		if (!async && ioctl(s, FIONBIO, (caddr_t)&on) == -1) {
+			Debug(LDAP_DEBUG_ANY, catgets(slapdcat, 1, 203,
+				"FIONBIO ioctl failed on %d\n"), s, 0, 0);
+		}
+#endif /* LDAP_REFERRALS */
+#endif /* notyet */
+
+		Debug(LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 205,
+			"sd %1$d connected to: %2$s\n"), s,
+			inet_ntoa(sin.sin_addr), 0);
+	}
+
+	return (rc);
+}
+
+
+void
+close_ldap_connection( Sockbuf *sb )
+{
+#ifdef LDAP_SSL
+	if (sb->sb_ssl){
+		SSL_close(sb->sb_ssl);
+		SSL_delete(sb->sb_ssl);
+	}
+	sb->sb_ssl = NULL;
+	sb->sb_ssl_tls = 0;
+#endif
+    tcp_close( sb->sb_sd );
+}
+
+
+#ifdef KERBEROS
+char *
+host_connected_to( Sockbuf *sb )
+{
+	struct hostent		*hp;
+	char			*p;
+	int			len;
+	struct sockaddr_in	sin;
+#ifdef SUN
+    struct hostent      hpret;
+    char                hpbuf[NSS_BUFLEN_HOSTS];
+    int                 hperrno;
+#endif
+
+	(void)memset( (char *)&sin, 0, sizeof( struct sockaddr_in ));
+	len = sizeof( sin );
+	if ( getpeername( sb->sb_sd, (struct sockaddr *)&sin, &len ) == -1 ) {
+		return( NULL );
+	}
+
+	/*
+	 * do a reverse lookup on the addr to get the official hostname.
+	 * this is necessary for kerberos to work right, since the official
+	 * hostname is used as the kerberos instance.
+	 */
+#ifdef SUN
+	if (( hp = gethostbyaddr_r((char *) &sin.sin_addr,
+		   sizeof( sin.sin_addr ), AF_INET,
+		   &hpret, hpbuf, NSS_BUFLEN_HOSTS, &hperrno)) != NULL ) {
+#else
+	if (( hp = gethostbyaddr( (char *) &sin.sin_addr,
+	    sizeof( sin.sin_addr ), AF_INET )) != NULL ) {
+#endif
+		if ( hp->h_name != NULL ) {
+			return( strdup( hp->h_name ));
+		}
+	}
+
+	return( NULL );
+}
+#endif /* KERBEROS */
+
+
+#ifdef LDAP_REFERRALS
+#ifdef SUN
+/* for UNIX */
+#include <stropts.h>
+#include <poll.h>
+
+struct selectinfo {
+	struct pollfd fds[LDAP_DEFAULT_REFHOPLIMIT];
+	int nbfds;
+};
+
+
+void
+mark_select_write( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+	int i;
+	
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+	
+	/* find if sb is in fds */
+	for (i=0; i< sip->nbfds; i++) {
+		if (sip->fds[i].fd == sb->sb_sd){
+			sip->fds[i].events |= POLLOUT;
+			return;
+		}
+	}
+	if (sip->nbfds < LDAP_DEFAULT_REFHOPLIMIT) {
+		sip->fds[sip->nbfds].fd = sb->sb_sd;
+		sip->fds[sip->nbfds].events |= POLLOUT;
+		sip->nbfds++;
+	}
+	else {
+		/* Should not happen */
+		Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 206, "Mark for poll : Too many descriptors\n"), 0, 0, 0 );
+	}
+}
+
+
+void
+mark_select_read( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+	int i;
+	
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	/* find if sb is in fds */
+	for (i=0; i< sip->nbfds; i++) {
+		if (sip->fds[i].fd == sb->sb_sd) {
+			sip->fds[i].events |= POLLIN;
+			return;
+		}
+	}
+	
+	if (sip->nbfds < LDAP_DEFAULT_REFHOPLIMIT) {
+		sip->fds[sip->nbfds].fd = sb->sb_sd;
+		sip->fds[sip->nbfds].events |= POLLIN;
+		sip->nbfds++;
+	}
+	else {
+		/* Should not happen */
+		Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 206, "Mark for poll : Too many descriptors\n"), 0, 0, 0 );
+	}
+}
+
+
+void
+mark_select_clear( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+	int i;
+
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	for (i = 0; i< sip->nbfds; i++) {
+		if (sip->fds[i].fd == sb->sb_sd){
+			i++;
+			for (; i < sip->nbfds; i ++) {
+				sip->fds[ i - 1] = sip->fds[i];
+			}
+			sip->fds[i].fd = -1;
+			sip->fds[i].events = -1;
+			sip->nbfds--;
+			return;
+		}
+	}
+	/* If we reach here, there's a pb. */
+	Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 207, "Clear poll : descriptor not found\n"), 0, 0, 0 );
+}
+
+
+long
+is_write_ready( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+	int i;
+	
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	for (i=0; i< sip->nbfds; i++) {
+		if (sip->fds[i].fd == sb->sb_sd) {
+			if ( sip->fds[i].revents & (POLLERR | POLLHUP | POLLNVAL)) {
+				return (-1);
+			}
+			return( sip->fds[i].revents & POLLOUT );
+		}
+	}
+	return(0);
+}
+
+
+long
+is_read_ready( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+	int i;
+	
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	for (i=0; i< sip->nbfds; i++) {
+		if (sip->fds[i].fd == sb->sb_sd) {
+			if (sip->fds[i].revents & (POLLERR | POLLHUP | POLLNVAL)) {
+				return (-1);
+			}
+			return( sip->fds[i].revents & POLLIN );
+		}
+	}
+	return(0);
+}
+
+void *
+new_select_info()
+{
+	struct selectinfo	*sip;
+
+	sip = (struct selectinfo *)calloc( 1, sizeof( struct selectinfo ));
+
+	return( (void *)sip );
+}
+
+
+void
+free_select_info( void *sip )
+{
+	free( sip );
+}
+
+
+int
+do_ldap_select( LDAP *ld, struct timeval *timeout )
+{
+	struct selectinfo	*sip;
+	int tim;
+#if defined( SUN ) && defined( _REENTRANT )
+	int rv;
+#endif
+
+	Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 208, "do_ldap_select\n"), 0, 0, 0 );
+
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+	
+/* 	sip->fds[0].revents = 0; */
+
+	if ( timeout ) {
+		tim = (timeout->tv_sec*1000)+(timeout->tv_usec/1000);
+	} else {
+		tim = INFTIM;
+	} /* end if */
+	errno=0;
+#if defined( SUN ) && defined( _REENTRANT )
+/*        UNLOCK_LDAP(ld); */
+	LOCK_POLL(ld);
+	rv = poll(sip->fds,sip->nbfds,tim);
+/*	LOCK_LDAP(ld); */
+	UNLOCK_POLL(ld);
+	return(rv);
+#else
+	return( poll(sip->fds,sip->nbfds,tim) );
+#endif
+}
+#else
+/* for UNIX */
+struct selectinfo {
+	fd_set	si_readfds;
+	fd_set	si_writefds;
+	fd_set	si_use_readfds;
+	fd_set	si_use_writefds;
+};
+
+
+void
+mark_select_write( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	if ( !FD_ISSET( sb->sb_sd, &sip->si_writefds )) {
+		FD_SET( sb->sb_sd, &sip->si_writefds );
+	}
+}
+
+
+void
+mark_select_read( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	if ( !FD_ISSET( sb->sb_sd, &sip->si_readfds )) {
+		FD_SET( sb->sb_sd, &sip->si_readfds );
+	}
+}
+
+
+void
+mark_select_clear( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	FD_CLR( sb->sb_sd, &sip->si_writefds );
+	FD_CLR( sb->sb_sd, &sip->si_readfds );
+}
+
+
+long
+is_write_ready( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	return( FD_ISSET( sb->sb_sd, &sip->si_use_writefds ));
+}
+
+
+long
+is_read_ready( LDAP *ld, Sockbuf *sb )
+{
+	struct selectinfo	*sip;
+
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+
+	return( FD_ISSET( sb->sb_sd, &sip->si_use_readfds ));
+}
+
+
+void *
+new_select_info()
+{
+	struct selectinfo	*sip;
+
+	if (( sip = (struct selectinfo *)calloc( 1,
+	    sizeof( struct selectinfo ))) != NULL ) {
+		FD_ZERO( &sip->si_readfds );
+		FD_ZERO( &sip->si_writefds );
+	}
+
+	return( (void *)sip );
+}
+
+
+void
+free_select_info( void *sip )
+{
+	free( sip );
+}
+
+
+int
+do_ldap_select( LDAP *ld, struct timeval *timeout )
+{
+	struct selectinfo	*sip;
+	static int		tblsize;
+
+	Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 208, "do_ldap_select\n"), 0, 0, 0 );
+
+#if defined( SUN ) && defined( _REENTRANT )
+	LOCK_LDAP(ld);
+#endif	
+	if ( tblsize == 0 ) {
+#ifdef USE_SYSCONF
+		tblsize = (int)sysconf( _SC_OPEN_MAX );
+#else /* USE_SYSCONF */
+		tblsize = getdtablesize();
+#endif /* USE_SYSCONF */
+	}
+
+	sip = (struct selectinfo *)ld->ld_selectinfo;
+	sip->si_use_readfds = sip->si_readfds;
+	sip->si_use_writefds = sip->si_writefds;
+	
+#if defined( SUN ) && defined( _REENTRANT )
+	UNLOCK_LDAP(ld);
+#endif
+	return( select( tblsize, &sip->si_use_readfds, &sip->si_use_writefds,
+	    NULL, timeout ));
+}
+#endif /* SUN */
+#endif /* LDAP_REFERRALS */