2 * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
3 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
6 * Copyright (c) 1990, 1994 Regents of the University of Michigan.
9 * cldap.c - synchronous, retrying interface to the cldap protocol
14 #ifdef LDAP_CONNECTIONLESS
18 #include <ac/stdlib.h>
21 #include <ac/socket.h>
22 #include <ac/string.h>
24 #include <ac/unistd.h>
28 #define DEF_CLDAP_TIMEOUT 3
29 #define DEF_CLDAP_TRIES 4
32 struct cldap_retinfo {
39 static int add_addr LDAP_P((
40 LDAP *ld, struct sockaddr *sap ));
41 static int cldap_result LDAP_P((
42 LDAP *ld, int msgid, LDAPMessage **res,
43 struct cldap_retinfo *crip, char *base ));
44 static int cldap_parsemsg LDAP_P((
45 LDAP *ld, int msgid, BerElement *ber,
46 LDAPMessage **res, char *base ));
49 * cldap_open - initialize and connect to an ldap server. A magic cookie to
50 * be used for future communication is returned on success, NULL on failure.
54 * ld = cldap_open( hostname, port );
58 cldap_open( char *host, int port )
61 unsigned long address;
62 struct sockaddr_in sock;
68 /* buffers for ldap_pvt_gethostbyname_a ... */
69 struct hostent he_buf;
73 #define DO_RETURN(x) if (ha_buf) LDAP_FREE(ha_buf); return (x);
75 Debug( LDAP_DEBUG_TRACE, "ldap_open\n", 0, 0, 0 );
77 if ( (s = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 ) {
81 sock.sin_addr.s_addr = 0;
82 sock.sin_family = AF_INET;
84 if ( bind(s, (struct sockaddr *) &sock, sizeof(sock)) < 0) {
88 if (( ld = ldap_init( host, port )) == NULL ) {
93 ld->ld_cldapnaddr = 0;
94 ld->ld_cldapaddrs = NULL;
96 if (ber_pvt_sb_set_io( &(ld->ld_sb), &ber_pvt_sb_io_udp, NULL )<0) {
101 ld->ld_version = LDAP_VERSION2;
103 sock.sin_family = AF_INET;
104 sock.sin_port = htons( port );
107 * 'host' may be a space-separated list.
109 if ( host != NULL ) {
110 for ( ; host != NULL; host = p ) {
111 if (( p = strchr( host, ' ' )) != NULL ) {
112 for (*p++ = '\0'; *p == ' '; p++) {
117 address = inet_addr( host );
118 /* This was just a test for -1 until OSF1 let inet_addr return
119 unsigned int, which is narrower than 'unsigned long address' */
120 if ( address == 0xffffffff || address == (unsigned long) -1 ) {
121 if ((ldap_pvt_gethostbyname_a( host, &he_buf, &ha_buf,
122 &hp,&local_h_errno)<0) ||
124 errno = EHOSTUNREACH;
128 for ( i = 0; hp->h_addr_list[ i ] != 0; ++i ) {
129 SAFEMEMCPY( (char *)&sock.sin_addr.s_addr,
130 (char *)hp->h_addr_list[ i ],
131 sizeof(sock.sin_addr.s_addr));
132 if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
133 ldap_ld_free( ld, 1 );
139 sock.sin_addr.s_addr = address;
140 if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
141 ldap_ld_free( ld, 1 );
146 if ( ld->ld_host == NULL ) {
147 ld->ld_host = LDAP_STRDUP( host );
151 address = INADDR_LOOPBACK;
152 sock.sin_addr.s_addr = htonl( address );
153 if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
154 ldap_ld_free( ld, 1 );
159 if ( ld->ld_cldapaddrs == NULL
160 || ( ld->ld_defconn = ldap_new_connection( ld, NULL, 1,0,0 )) == NULL
162 ldap_ld_free( ld, 0 );
166 ber_pvt_sb_udp_set_dst( &ld->ld_sb, ld->ld_cldapaddrs[0] );
168 cldap_setretryinfo( ld, 0, 0 );
172 for ( i = 0; i < ld->ld_cldapnaddr; ++i ) {
173 Debug( LDAP_DEBUG_TRACE, "end of cldap_open address %d is %s\n",
174 i, inet_ntoa( ((struct sockaddr_in *)
175 ld->ld_cldapaddrs[ i ])->sin_addr ), 0 );
185 cldap_close( LDAP *ld )
187 ldap_ld_free( ld, 0 );
192 cldap_setretryinfo( LDAP *ld, int tries, int timeout )
194 ld->ld_cldaptries = ( tries <= 0 ) ? DEF_CLDAP_TRIES : tries;
195 ld->ld_cldaptimeout = ( timeout <= 0 ) ? DEF_CLDAP_TIMEOUT : timeout;
200 cldap_search_s( LDAP *ld, char *base, int scope, char *filter, char **attrs,
201 int attrsonly, LDAPMessage **res, char *logdn )
204 struct cldap_retinfo cri;
208 (void) memset( &cri, 0, sizeof( cri ));
210 if ( logdn != NULL ) {
211 ld->ld_cldapdn = logdn;
212 } else if ( ld->ld_cldapdn == NULL ) {
217 if ( cri.cri_try != 0 ) {
218 --ld->ld_msgid; /* use same id as before */
221 ber_pvt_sb_udp_set_dst( &(ld->ld_sb),
222 ld->ld_cldapaddrs[ cri.cri_useaddr ] );
224 Debug( LDAP_DEBUG_TRACE, "cldap_search_s try %d (to %s)\n",
225 cri.cri_try, inet_ntoa( ((struct sockaddr_in *)
226 ld->ld_cldapaddrs[ cri.cri_useaddr ])->sin_addr), 0 );
228 if ( (msgid = ldap_search( ld, base, scope, filter, attrs,
229 attrsonly )) == -1 ) {
230 return( ld->ld_errno );
233 if ( ld->ld_cache != NULL && ld->ld_responses != NULL ) {
234 Debug( LDAP_DEBUG_TRACE, "cldap_search_s res from cache\n",
236 *res = ld->ld_responses;
237 ld->ld_responses = ld->ld_responses->lm_next;
238 return( ldap_result2error( ld, *res, 0 ));
240 #endif /* LDAP_NOCACHE */
241 ret = cldap_result( ld, msgid, res, &cri, base );
249 add_addr( LDAP *ld, struct sockaddr *sap )
251 struct sockaddr *newsap, **addrs;
253 if (( newsap = (struct sockaddr *)LDAP_MALLOC( sizeof( struct sockaddr )))
255 ld->ld_errno = LDAP_NO_MEMORY;
259 addrs = (struct sockaddr **)LDAP_REALLOC( ld->ld_cldapaddrs,
260 ( ld->ld_cldapnaddr + 1 ) * sizeof(struct sockaddr *));
262 if ( addrs == NULL ) {
264 ld->ld_errno = LDAP_NO_MEMORY;
268 SAFEMEMCPY( (char *)newsap, (char *)sap, sizeof( struct sockaddr ));
269 addrs[ ld->ld_cldapnaddr++ ] = newsap;
270 ld->ld_cldapaddrs = (void **)addrs;
276 cldap_result( LDAP *ld, int msgid, LDAPMessage **res,
277 struct cldap_retinfo *crip, char *base )
279 Sockbuf *sb = &ld->ld_sb;
282 int ret, id, fromaddr, i;
287 if ( crip->cri_try == 0 ) {
288 crip->cri_maxtries = ld->ld_cldaptries * ld->ld_cldapnaddr;
289 crip->cri_timeout = ld->ld_cldaptimeout;
290 crip->cri_useaddr = 0;
291 Debug( LDAP_DEBUG_TRACE, "cldap_result tries %d timeout %d\n",
292 ld->ld_cldaptries, ld->ld_cldaptimeout, 0 );
295 if ((tv.tv_sec = crip->cri_timeout / ld->ld_cldapnaddr) < 1 ) {
300 Debug( LDAP_DEBUG_TRACE,
301 "cldap_result waiting up to %ld seconds for a response\n",
302 (long) tv.tv_sec, 0, 0 );
303 ber_init_w_nullc( &ber, 0 );
304 ldap_set_ber_options( ld, &ber );
306 if ( cldap_getmsg( ld, &tv, &ber ) == -1 ) {
308 Debug( LDAP_DEBUG_TRACE, "cldap_getmsg returned -1 (%d)\n",
310 } else if ( ld->ld_errno == LDAP_TIMEOUT ) {
311 Debug( LDAP_DEBUG_TRACE,
312 "cldap_result timed out\n", 0, 0, 0 );
314 * It timed out; is it time to give up?
316 if ( ++crip->cri_try >= crip->cri_maxtries ) {
320 if ( ++crip->cri_useaddr >= ld->ld_cldapnaddr ) {
322 * new round: reset address to first one and
325 crip->cri_useaddr = 0;
326 crip->cri_timeout <<= 1;
333 * Got a response. It should look like:
334 * { msgid, logdn, { searchresponse...}}
338 if ( ber_scanf( &ber, "ia", &id, &logdn ) == LBER_ERROR ) {
339 LDAP_FREE( ber.ber_buf ); /* gack! */
340 ret = LDAP_DECODING_ERROR;
341 Debug( LDAP_DEBUG_TRACE,
342 "cldap_result: ber_scanf returned LBER_ERROR (%d)\n",
344 } else if ( id != msgid ) {
345 LDAP_FREE( ber.ber_buf ); /* gack! */
346 Debug( LDAP_DEBUG_TRACE,
347 "cldap_result: looking for msgid %d; got %d\n",
349 ret = -1; /* ignore and keep looking */
351 struct sockaddr_in * src;
353 * got a result: determine which server it came from
354 * decode into ldap message chain
356 src = (struct sockaddr_in *) ber_pvt_sb_udp_get_src( sb );
358 for ( fromaddr = 0; fromaddr < ld->ld_cldapnaddr; ++fromaddr ) {
359 if ( memcmp( &((struct sockaddr_in *)
360 ld->ld_cldapaddrs[ fromaddr ])->sin_addr,
362 sizeof( struct in_addr )) == 0 ) {
366 ret = cldap_parsemsg( ld, msgid, &ber, res, base );
367 LDAP_FREE( ber.ber_buf ); /* gack! */
368 Debug( LDAP_DEBUG_TRACE,
369 "cldap_result got result (%d)\n", ret, 0, 0 );
372 if ( logdn != NULL ) {
379 * If we are giving up (successfully or otherwise) then
380 * abandon any outstanding requests.
384 if ( i >= ld->ld_cldapnaddr ) {
385 i = ld->ld_cldapnaddr - 1;
388 for ( ; i >= 0; --i ) {
389 if ( i == fromaddr ) {
392 ber_pvt_sb_udp_set_dst( sb, ld->ld_cldapaddrs[i] );
394 Debug( LDAP_DEBUG_TRACE, "cldap_result abandoning id %d (to %s)\n",
395 msgid, inet_ntoa( ((struct sockaddr_in *)
396 ld->ld_cldapaddrs[i])->sin_addr ), 0 );
397 (void) ldap_abandon( ld, msgid );
401 return( ld->ld_errno = ret );
406 cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber,
407 LDAPMessage **res, char *base )
409 unsigned long tag, len;
410 int baselen, slen, rc;
411 char *dn, *p, *cookie;
412 LDAPMessage *chain, *prev, *ldm;
415 rc = LDAP_DECODING_ERROR; /* pessimistic */
416 ldm = chain = prev = NULLMSG;
417 baselen = ( base == NULL ) ? 0 : strlen( base );
420 for ( tag = ber_first_element( ber, &len, &cookie );
421 tag != LBER_DEFAULT && rc != LDAP_SUCCESS;
422 tag = ber_next_element( ber, &len, cookie )) {
423 if (( ldm = (LDAPMessage *)LDAP_CALLOC( 1, sizeof(LDAPMessage)))
424 == NULL || ( ldm->lm_ber = ldap_alloc_ber_with_options( ld ))
427 break; /* return w/error*/
429 ldm->lm_msgid = msgid;
430 ldm->lm_msgtype = tag;
432 if ( tag == LDAP_RES_SEARCH_RESULT ) {
433 Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got search result\n",
436 if ( ber_get_stringal( ber, &bv ) == LBER_DEFAULT ) {
437 break; /* return w/error */
440 if ( ber_printf( ldm->lm_ber, "to", tag, bv->bv_val,
441 bv->bv_len ) == -1 ) {
442 break; /* return w/error */
448 } else if ( tag == LDAP_RES_SEARCH_ENTRY ) {
449 if ( ber_scanf( ber, "{aO", &dn, &bv ) == LBER_ERROR ) {
450 break; /* return w/error */
452 Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg entry %s\n", dn, 0, 0 );
453 if ( dn != NULL && *(dn + ( slen = strlen(dn)) - 1) == '*' &&
456 * substitute original searchbase for trailing '*'
458 if (( p = (char *)LDAP_MALLOC( slen + baselen )) == NULL ) {
461 break; /* return w/error */
464 strcpy( p + slen - 1, base );
469 if ( ber_printf( ldm->lm_ber, "t{so}", tag, dn, bv->bv_val,
470 bv->bv_len ) == -1 ) {
471 break; /* return w/error */
478 } else if ( tag == LDAP_RES_SEARCH_REFERENCE ) {
481 Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got unknown tag %lu\n",
483 rc = LDAP_PROTOCOL_ERROR;
484 break; /* return w/error */
487 /* Reset message ber so we can read from it later. Gack! */
488 ldm->lm_ber->ber_end = ldm->lm_ber->ber_ptr;
489 ldm->lm_ber->ber_ptr = ldm->lm_ber->ber_buf;
492 if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
493 fprintf( stderr, "cldap_parsemsg add message id %d type %d:\n",
494 ldm->lm_msgid, ldm->lm_msgtype );
495 ber_log_dump( LDAP_DEBUG_BER, ldap_debug, ldm->lm_ber, 1 );
497 #endif /* LDAP_DEBUG */
500 if ( ld->ld_cache != NULL ) {
501 ldap_add_result_to_cache( ld, ldm );
503 #endif /* LDAP_NOCACHE */
505 if ( chain == NULL ) {
508 prev->lm_chain = ldm;
514 /* dispose of any leftovers */
516 if ( ldm->lm_ber != NULLBER ) {
517 ber_free( ldm->lm_ber, 1 );
525 /* return chain, calling result2error if we got anything at all */
527 return(( *res == NULLMSG ) ? rc : ldap_result2error( ld, *res, 0 ));
529 #endif /* LDAP_CONNECTIONLESS */