os-ip.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* 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 */