X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Fcldap.c;h=de6208136b3d5f89b6d1c0df4b3b531a6239c800;hb=91e24173d0fa168bdd3e585af2d56f3299a20c00;hp=8639ee255057b0246a1b63450d9dcf8a09da0f53;hpb=0c0f011dc0302348484d0278e2e8f2cbe53d1961;p=openldap diff --git a/libraries/libldap/cldap.c b/libraries/libldap/cldap.c index 8639ee2550..de6208136b 100644 --- a/libraries/libldap/cldap.c +++ b/libraries/libldap/cldap.c @@ -1,48 +1,34 @@ +/* $OpenLDAP$ */ /* + * 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. * * cldap.c - synchronous, retrying interface to the cldap protocol */ -#define DISABLE_BRIDGE #include "portable.h" -#ifdef CLDAP - -#ifndef lint -static char copyright[] = "@(#) Copyright (c) 1990, 1994 Regents of the University of Michigan.\nAll rights reserved.\n"; -#endif +#ifdef LDAP_CONNECTIONLESS #include + +#include + +#include +#include #include -#include -#include - -#ifdef MACOS -#include "macos.h" -#endif /* MACOS */ -#ifdef DOS -#include "msdos.h" -#endif /* DOS */ - -#include -#include -#include -#include -#include - -#include "lber.h" -#include "ldap.h" +#include +#include + #include "ldap-int.h" #define DEF_CLDAP_TIMEOUT 3 #define DEF_CLDAP_TRIES 4 -#ifndef INADDR_LOOPBACK -#define INADDR_LOOPBACK ((unsigned long) 0x7f000001) -#endif - struct cldap_retinfo { int cri_maxtries; @@ -51,17 +37,14 @@ struct cldap_retinfo { long cri_timeout; }; -#ifdef NEEDPROTOS -static int add_addr( LDAP *ld, struct sockaddr *sap ); -static int cldap_result( LDAP *ld, int msgid, LDAPMessage **res, - struct cldap_retinfo *crip, char *base ); -static int cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, - LDAPMessage **res, char *base ); -#else /* NEEDPROTOS */ -static int add_addr(); -static int cldap_result(); -static int cldap_parsemsg(); -#endif /* NEEDPROTOS */ +static int add_addr LDAP_P(( + LDAP *ld, struct sockaddr *sap )); +static int cldap_result LDAP_P(( + LDAP *ld, int msgid, LDAPMessage **res, + struct cldap_retinfo *crip, const char *base )); +static int cldap_parsemsg LDAP_P(( + LDAP *ld, int msgid, BerElement *ber, + LDAPMessage **res, const char *base )); /* * cldap_open - initialize and connect to an ldap server. A magic cookie to @@ -73,7 +56,7 @@ static int cldap_parsemsg(); */ LDAP * -cldap_open( char *host, int port ) +cldap_open( LDAP_CONST char *host, int port ) { int s; unsigned long address; @@ -83,11 +66,14 @@ cldap_open( char *host, int port ) 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 ); @@ -97,23 +83,23 @@ cldap_open( char *host, int port ) 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, NULL, NULL ); + return NULL; + } + + ld->ld_version = LDAP_VERSION2; sock.sin_family = AF_INET; sock.sin_port = htons( port ); @@ -122,6 +108,8 @@ cldap_open( char *host, int port ) * 'host' may be a space-separated list. */ if ( host != NULL ) { + char *host_dup = LDAP_STRDUP( host ); + host = host_dup; for ( ; host != NULL; host = p ) { if (( p = strchr( host, ' ' )) != NULL ) { for (*p++ = '\0'; *p == ' '; p++) { @@ -129,10 +117,15 @@ cldap_open( char *host, int 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 ) { @@ -140,66 +133,63 @@ cldap_open( char *host, int port ) (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, NULL, NULL ); + LDAP_FREE( host_dup ); + 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, NULL, NULL ); + LDAP_FREE( host_dup ); + DO_RETURN( NULL ); } } if ( ld->ld_host == NULL ) { - ld->ld_host = strdup( host ); + ld->ld_host = LDAP_STRDUP( host ); } } - + LDAP_FREE( host_dup ); } else { - address = INADDR_LOOPBACK; - sock.sin_addr.s_addr = htonl( address ); + sock.sin_addr.s_addr = htonl( INADDR_LOOPBACK ); if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) { - close( s ); - free( ld ); - return( NULL ); + ldap_ld_free( ld, 1, NULL, NULL ); + 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, NULL, NULL ); + 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 ) { - ldap_ld_free( ld, 0 ); + ldap_ld_free( ld, 0, NULL, NULL ); } @@ -212,13 +202,19 @@ cldap_setretryinfo( LDAP *ld, int tries, int timeout ) int -cldap_search_s( LDAP *ld, char *base, int scope, char *filter, char **attrs, - int attrsonly, LDAPMessage **res, char *logdn ) +cldap_search_s( LDAP *ld, + LDAP_CONST char *base, + int scope, + LDAP_CONST char *filter, + char **attrs, + int attrsonly, + LDAPMessage **res, + char *logdn ) { int ret, msgid; struct cldap_retinfo cri; - *res = NULLMSG; + *res = NULL; (void) memset( &cri, 0, sizeof( cri )); @@ -232,17 +228,19 @@ cldap_search_s( LDAP *ld, char *base, int scope, char *filter, char **attrs, 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 ) { return( ld->ld_errno ); } -#ifndef NO_CACHE +#ifndef LDAP_NOCACHE if ( ld->ld_cache != NULL && ld->ld_responses != NULL ) { Debug( LDAP_DEBUG_TRACE, "cldap_search_s res from cache\n", 0, 0, 0 ); @@ -250,7 +248,7 @@ cldap_search_s( LDAP *ld, char *base, int scope, char *filter, char **attrs, ld->ld_responses = ld->ld_responses->lm_next; return( ldap_result2error( ld, *res, 0 )); } -#endif /* NO_CACHE */ +#endif /* LDAP_NOCACHE */ ret = cldap_result( ld, msgid, res, &cri, base ); } while (ret == -1); @@ -263,61 +261,58 @@ add_addr( LDAP *ld, struct sockaddr *sap ) { 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 ); } static int cldap_result( LDAP *ld, int msgid, LDAPMessage **res, - struct cldap_retinfo *crip, char *base ) + struct cldap_retinfo *crip, const char *base ) { 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 ) { @@ -334,7 +329,7 @@ cldap_result( LDAP *ld, int msgid, LDAPMessage **res, 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 @@ -353,38 +348,41 @@ cldap_result( LDAP *ld, int msgid, LDAPMessage **res, 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 ); } } @@ -395,18 +393,19 @@ cldap_result( LDAP *ld, int msgid, LDAPMessage **res, */ 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 ); } } @@ -417,25 +416,27 @@ cldap_result( LDAP *ld, int msgid, LDAPMessage **res, static int cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, - LDAPMessage **res, char *base ) + LDAPMessage **res, const 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; rc = LDAP_DECODING_ERROR; /* pessimistic */ - ldm = chain = prev = NULLMSG; + ldm = chain = prev = NULL; baselen = ( base == NULL ) ? 0 : strlen( base ); bv = NULL; 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*/ } @@ -450,8 +451,7 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, 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 ); @@ -459,7 +459,7 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, 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 ); @@ -468,14 +468,14 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, /* * 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; } @@ -483,14 +483,17 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, 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; + rc = LDAP_DECODING_ERROR; break; /* return w/error */ } @@ -500,17 +503,17 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, #ifdef LDAP_DEBUG 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 ); + fprintf( stderr, "cldap_parsemsg add message id %ld type %ld:\n", + (long) ldm->lm_msgid, (long) ldm->lm_msgtype ); + ber_log_dump( LDAP_DEBUG_BER, ldap_debug, ldm->lm_ber, 1 ); } #endif /* LDAP_DEBUG */ -#ifndef NO_CACHE +#ifndef LDAP_NOCACHE if ( ld->ld_cache != NULL ) { ldap_add_result_to_cache( ld, ldm ); } -#endif /* NO_CACHE */ +#endif /* LDAP_NOCACHE */ if ( chain == NULL ) { chain = ldm; @@ -523,10 +526,10 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, /* 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 ); @@ -534,6 +537,6 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, /* return chain, calling result2error if we got anything at all */ *res = chain; - return(( *res == NULLMSG ) ? rc : ldap_result2error( ld, *res, 0 )); + return(( *res == NULL ) ? rc : ldap_result2error( ld, *res, 0 )); } -#endif /* CLDAP */ +#endif /* LDAP_CONNECTIONLESS */