/*
+ * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+ */
+/* Portions
* Copyright (c) 1990, 1994 Regents of the University of Michigan.
* All rights reserved.
*
#ifdef LDAP_CONNECTIONLESS
-#ifndef lint
-static char copyright[] = "@(#) Copyright (c) 1990, 1994 Regents of the University of Michigan.\nAll rights reserved.\n";
-#endif
-
#include <stdio.h>
-#include <stdlib.h>
+
+#include <ac/stdlib.h>
#include <ac/errno.h>
#include <ac/socket.h>
#include <ac/string.h>
#include <ac/time.h>
+#include <ac/unistd.h>
-#include "lber.h"
-#include "ldap.h"
#include "ldap-int.h"
#define DEF_CLDAP_TIMEOUT 3
char *p;
int i;
- Debug( LDAP_DEBUG_TRACE, "ldap_open\n", 0, 0, 0 );
+ /* buffers for ldap_pvt_gethostbyname_a ... */
+ struct hostent he_buf;
+ int local_h_errno;
+ char *ha_buf=NULL;
- if ( port == 0 ) {
- port = LDAP_PORT;
- }
+#define DO_RETURN(x) if (ha_buf) LDAP_FREE(ha_buf); return (x);
+
+ Debug( LDAP_DEBUG_TRACE, "ldap_open\n", 0, 0, 0 );
if ( (s = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 ) {
return( NULL );
sock.sin_family = AF_INET;
sock.sin_port = 0;
if ( bind(s, (struct sockaddr *) &sock, sizeof(sock)) < 0) {
- close( s );
+ tcp_close( s );
return( NULL );
}
-
if (( ld = ldap_init( host, port )) == NULL ) {
- close( s );
+ tcp_close( s );
return( NULL );
}
- if ( (ld->ld_sb.sb_fromaddr = (void *) calloc( 1,
- sizeof( struct sockaddr ))) == NULL ) {
- free( ld );
- close( s );
- return( NULL );
- }
- ld->ld_sb.sb_sd = s;
- ld->ld_sb.sb_naddr = 0;
- ld->ld_version = LDAP_VERSION;
+
+ ld->ld_cldapnaddr = 0;
+ ld->ld_cldapaddrs = NULL;
+
+ if (ber_pvt_sb_set_io( &(ld->ld_sb), &ber_pvt_sb_io_udp, NULL )<0) {
+ ldap_ld_free(ld, 1 );
+ return NULL;
+ }
+
+ ld->ld_version = LDAP_VERSION2;
sock.sin_family = AF_INET;
sock.sin_port = htons( port );
}
}
- if ( (address = inet_addr( host )) == -1 ) {
- if ( (hp = gethostbyname( host )) == NULL ) {
- errno = EHOSTUNREACH;
- continue;
+ address = inet_addr( host );
+ /* This was just a test for -1 until OSF1 let inet_addr return
+ unsigned int, which is narrower than 'unsigned long address' */
+ if ( address == 0xffffffff || address == (unsigned long) -1 ) {
+ if ((ldap_pvt_gethostbyname_a( host, &he_buf, &ha_buf,
+ &hp,&local_h_errno)<0) ||
+ (hp==NULL)) {
+ errno = EHOSTUNREACH;
+ continue;
}
for ( i = 0; hp->h_addr_list[ i ] != 0; ++i ) {
(char *)hp->h_addr_list[ i ],
sizeof(sock.sin_addr.s_addr));
if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
- close( s );
- free( ld );
- return( NULL );
+ ldap_ld_free( ld, 1 );
+ DO_RETURN( NULL );
}
}
} else {
sock.sin_addr.s_addr = address;
if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
- close( s );
- free( ld );
- return( NULL );
+ ldap_ld_free( ld, 1 );
+ DO_RETURN( NULL );
}
}
if ( ld->ld_host == NULL ) {
- ld->ld_host = strdup( host );
+ ld->ld_host = LDAP_STRDUP( host );
}
}
-
} else {
address = INADDR_LOOPBACK;
sock.sin_addr.s_addr = htonl( address );
if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
- close( s );
- free( ld );
- return( NULL );
+ ldap_ld_free( ld, 1 );
+ DO_RETURN( NULL );
}
}
- if ( ld->ld_sb.sb_addrs == NULL
-#ifdef LDAP_REFERRALS
+ if ( ld->ld_cldapaddrs == NULL
|| ( ld->ld_defconn = ldap_new_connection( ld, NULL, 1,0,0 )) == NULL
-#endif /* LDAP_REFERRALS */
) {
- free( ld );
- return( NULL );
+ ldap_ld_free( ld, 0 );
+ DO_RETURN( NULL );
}
- ld->ld_sb.sb_useaddr = ld->ld_sb.sb_addrs[ 0 ];
+ ber_pvt_sb_udp_set_dst( &ld->ld_sb, ld->ld_cldapaddrs[0] );
+
cldap_setretryinfo( ld, 0, 0 );
#ifdef LDAP_DEBUG
putchar( '\n' );
- for ( i = 0; i < ld->ld_sb.sb_naddr; ++i ) {
+ for ( i = 0; i < ld->ld_cldapnaddr; ++i ) {
Debug( LDAP_DEBUG_TRACE, "end of cldap_open address %d is %s\n",
i, inet_ntoa( ((struct sockaddr_in *)
- ld->ld_sb.sb_addrs[ i ])->sin_addr ), 0 );
+ ld->ld_cldapaddrs[ i ])->sin_addr ), 0 );
}
#endif
- return( ld );
+ DO_RETURN( ld );
}
-
+#undef DO_RETURN
void
cldap_close( LDAP *ld )
if ( cri.cri_try != 0 ) {
--ld->ld_msgid; /* use same id as before */
}
- ld->ld_sb.sb_useaddr = ld->ld_sb.sb_addrs[ cri.cri_useaddr ];
+
+ ber_pvt_sb_udp_set_dst( &(ld->ld_sb),
+ ld->ld_cldapaddrs[ cri.cri_useaddr ] );
Debug( LDAP_DEBUG_TRACE, "cldap_search_s try %d (to %s)\n",
cri.cri_try, inet_ntoa( ((struct sockaddr_in *)
- ld->ld_sb.sb_useaddr)->sin_addr ), 0 );
+ ld->ld_cldapaddrs[ cri.cri_useaddr ])->sin_addr), 0 );
if ( (msgid = ldap_search( ld, base, scope, filter, attrs,
attrsonly )) == -1 ) {
{
struct sockaddr *newsap, **addrs;
- if (( newsap = (struct sockaddr *)malloc( sizeof( struct sockaddr )))
+ if (( newsap = (struct sockaddr *)LDAP_MALLOC( sizeof( struct sockaddr )))
== NULL ) {
ld->ld_errno = LDAP_NO_MEMORY;
return( -1 );
}
-
- if ( ld->ld_sb.sb_naddr == 0 ) {
- addrs = (struct sockaddr **)malloc( sizeof(struct sockaddr *));
- } else {
- addrs = (struct sockaddr **)realloc( ld->ld_sb.sb_addrs,
- ( ld->ld_sb.sb_naddr + 1 ) * sizeof(struct sockaddr *));
- }
+
+ addrs = (struct sockaddr **)LDAP_REALLOC( ld->ld_cldapaddrs,
+ ( ld->ld_cldapnaddr + 1 ) * sizeof(struct sockaddr *));
if ( addrs == NULL ) {
- free( newsap );
+ LDAP_FREE( newsap );
ld->ld_errno = LDAP_NO_MEMORY;
return( -1 );
}
SAFEMEMCPY( (char *)newsap, (char *)sap, sizeof( struct sockaddr ));
- addrs[ ld->ld_sb.sb_naddr++ ] = newsap;
- ld->ld_sb.sb_addrs = (void **)addrs;
+ addrs[ ld->ld_cldapnaddr++ ] = newsap;
+ ld->ld_cldapaddrs = (void **)addrs;
return( 0 );
}
Sockbuf *sb = &ld->ld_sb;
BerElement ber;
char *logdn;
- int ret, id, fromaddr, i;
+ int ret, fromaddr, i;
+ ber_int_t id;
struct timeval tv;
fromaddr = -1;
if ( crip->cri_try == 0 ) {
- crip->cri_maxtries = ld->ld_cldaptries * sb->sb_naddr;
+ crip->cri_maxtries = ld->ld_cldaptries * ld->ld_cldapnaddr;
crip->cri_timeout = ld->ld_cldaptimeout;
crip->cri_useaddr = 0;
Debug( LDAP_DEBUG_TRACE, "cldap_result tries %d timeout %d\n",
ld->ld_cldaptries, ld->ld_cldaptimeout, 0 );
}
- if ((tv.tv_sec = crip->cri_timeout / sb->sb_naddr) < 1 ) {
+ if ((tv.tv_sec = crip->cri_timeout / ld->ld_cldapnaddr) < 1 ) {
tv.tv_sec = 1;
}
tv.tv_usec = 0;
Debug( LDAP_DEBUG_TRACE,
- "cldap_result waiting up to %d seconds for a response\n",
- tv.tv_sec, 0, 0 );
- ber_init( &ber, 0 );
+ "cldap_result waiting up to %ld seconds for a response\n",
+ (long) tv.tv_sec, 0, 0 );
+ ber_init_w_nullc( &ber, 0 );
ldap_set_ber_options( ld, &ber );
if ( cldap_getmsg( ld, &tv, &ber ) == -1 ) {
ret = LDAP_TIMEOUT;
--crip->cri_try;
} else {
- if ( ++crip->cri_useaddr >= sb->sb_naddr ) {
+ if ( ++crip->cri_useaddr >= ld->ld_cldapnaddr ) {
/*
* new round: reset address to first one and
* double the timeout
logdn = NULL;
if ( ber_scanf( &ber, "ia", &id, &logdn ) == LBER_ERROR ) {
- free( ber.ber_buf ); /* gack! */
+ LDAP_FREE( ber.ber_buf ); /* gack! */
ret = LDAP_DECODING_ERROR;
Debug( LDAP_DEBUG_TRACE,
"cldap_result: ber_scanf returned LBER_ERROR (%d)\n",
ret, 0, 0 );
} else if ( id != msgid ) {
- free( ber.ber_buf ); /* gack! */
+ LDAP_FREE( ber.ber_buf ); /* gack! */
Debug( LDAP_DEBUG_TRACE,
"cldap_result: looking for msgid %d; got %d\n",
msgid, id, 0 );
ret = -1; /* ignore and keep looking */
} else {
+ struct sockaddr_in * src;
/*
* got a result: determine which server it came from
* decode into ldap message chain
*/
- for ( fromaddr = 0; fromaddr < sb->sb_naddr; ++fromaddr ) {
+ src = (struct sockaddr_in *) ber_pvt_sb_udp_get_src( sb );
+
+ for ( fromaddr = 0; fromaddr < ld->ld_cldapnaddr; ++fromaddr ) {
if ( memcmp( &((struct sockaddr_in *)
- sb->sb_addrs[ fromaddr ])->sin_addr,
- &((struct sockaddr_in *)sb->sb_fromaddr)->sin_addr,
+ ld->ld_cldapaddrs[ fromaddr ])->sin_addr,
+ &(src->sin_addr),
sizeof( struct in_addr )) == 0 ) {
break;
}
}
ret = cldap_parsemsg( ld, msgid, &ber, res, base );
- free( ber.ber_buf ); /* gack! */
+ LDAP_FREE( ber.ber_buf ); /* gack! */
Debug( LDAP_DEBUG_TRACE,
"cldap_result got result (%d)\n", ret, 0, 0 );
}
if ( logdn != NULL ) {
- free( logdn );
+ LDAP_FREE( logdn );
}
}
*/
if ( ret != -1 ) {
i = crip->cri_try;
- if ( i >= sb->sb_naddr ) {
- i = sb->sb_naddr - 1;
+ if ( i >= ld->ld_cldapnaddr ) {
+ i = ld->ld_cldapnaddr - 1;
}
for ( ; i >= 0; --i ) {
if ( i == fromaddr ) {
continue;
}
- sb->sb_useaddr = sb->sb_addrs[ i ];
+ ber_pvt_sb_udp_set_dst( sb, ld->ld_cldapaddrs[i] );
+
Debug( LDAP_DEBUG_TRACE, "cldap_result abandoning id %d (to %s)\n",
msgid, inet_ntoa( ((struct sockaddr_in *)
- sb->sb_useaddr)->sin_addr ), 0 );
+ ld->ld_cldapaddrs[i])->sin_addr ), 0 );
(void) ldap_abandon( ld, msgid );
}
}
cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber,
LDAPMessage **res, char *base )
{
- unsigned long tag, len;
- int baselen, slen, rc;
+ ber_tag_t tag;
+ ber_len_t len;
+ int baselen, slen;
+ ber_tag_t rc;
char *dn, *p, *cookie;
LDAPMessage *chain, *prev, *ldm;
struct berval *bv;
for ( tag = ber_first_element( ber, &len, &cookie );
tag != LBER_DEFAULT && rc != LDAP_SUCCESS;
tag = ber_next_element( ber, &len, cookie )) {
- if (( ldm = (LDAPMessage *)calloc( 1, sizeof(LDAPMessage)))
+ if (( ldm = (LDAPMessage *)LDAP_CALLOC( 1, sizeof(LDAPMessage)))
== NULL || ( ldm->lm_ber = ldap_alloc_ber_with_options( ld ))
- == NULLBER ) {
+ == NULL ) {
rc = LDAP_NO_MEMORY;
break; /* return w/error*/
}
break; /* return w/error */
}
- if ( ber_printf( ldm->lm_ber, "to", tag, bv->bv_val,
- bv->bv_len ) == -1 ) {
+ if ( ber_printf( ldm->lm_ber, "tO", tag, bv ) == -1 ) {
break; /* return w/error */
}
ber_bvfree( bv );
rc = LDAP_SUCCESS;
} else if ( tag == LDAP_RES_SEARCH_ENTRY ) {
- if ( ber_scanf( ber, "{aO", &dn, &bv ) == LBER_ERROR ) {
+ if ( ber_scanf( ber, "{aO" /*}*/, &dn, &bv ) == LBER_ERROR ) {
break; /* return w/error */
}
Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg entry %s\n", dn, 0, 0 );
/*
* substitute original searchbase for trailing '*'
*/
- if (( p = (char *)malloc( slen + baselen )) == NULL ) {
+ if (( p = (char *)LDAP_MALLOC( slen + baselen )) == NULL ) {
rc = LDAP_NO_MEMORY;
- free( dn );
+ LDAP_FREE( dn );
break; /* return w/error */
}
strcpy( p, dn );
strcpy( p + slen - 1, base );
- free( dn );
+ LDAP_FREE( dn );
dn = p;
}
bv->bv_len ) == -1 ) {
break; /* return w/error */
}
- free( dn );
+ LDAP_FREE( dn );
ber_bvfree( bv );
bv = NULL;
+#ifdef notyet
+ } else if ( tag == LDAP_RES_SEARCH_REFERENCE ) {
+#endif
} else {
- Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got unknown tag %d\n",
+ Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got unknown tag %lu\n",
tag, 0, 0 );
rc = LDAP_PROTOCOL_ERROR;
break; /* return w/error */
if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
fprintf( stderr, "cldap_parsemsg add message id %d type %d:\n",
ldm->lm_msgid, ldm->lm_msgtype );
- ber_dump( ldm->lm_ber, 1 );
+ ber_log_dump( LDAP_DEBUG_BER, ldap_debug, ldm->lm_ber, 1 );
}
#endif /* LDAP_DEBUG */
/* dispose of any leftovers */
if ( ldm != NULL ) {
- if ( ldm->lm_ber != NULLBER ) {
+ if ( ldm->lm_ber != NULL ) {
ber_free( ldm->lm_ber, 1 );
}
- free( ldm );
+ LDAP_FREE( ldm );
}
if ( bv != NULL ) {
ber_bvfree( bv );
projects / openldap / blobdiff