3 * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
4 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
7 * Copyright (c) 1990, 1994 Regents of the University of Michigan.
10 * cldap.c - synchronous, retrying interface to the cldap protocol
15 #ifdef LDAP_CONNECTIONLESS
19 #include <ac/stdlib.h>
22 #include <ac/socket.h>
23 #include <ac/string.h>
25 #include <ac/unistd.h>
29 #define DEF_CLDAP_TIMEOUT 3
30 #define DEF_CLDAP_TRIES 4
33 struct cldap_retinfo {
40 static int add_addr LDAP_P((
41 LDAP *ld, struct sockaddr *sap ));
42 static int cldap_result LDAP_P((
43 LDAP *ld, int msgid, LDAPMessage **res,
44 struct cldap_retinfo *crip, const char *base ));
45 static int cldap_parsemsg LDAP_P((
46 LDAP *ld, int msgid, BerElement *ber,
47 LDAPMessage **res, const char *base ));
50 * cldap_open - initialize and connect to an ldap server. A magic cookie to
51 * be used for future communication is returned on success, NULL on failure.
55 * ld = cldap_open( hostname, port );
59 cldap_open( LDAP_CONST char *host, int port )
62 unsigned long address;
63 struct sockaddr_in sock;
69 /* buffers for ldap_pvt_gethostbyname_a ... */
70 struct hostent he_buf;
74 #define DO_RETURN(x) if (ha_buf) LDAP_FREE(ha_buf); return (x);
76 Debug( LDAP_DEBUG_TRACE, "ldap_open\n", 0, 0, 0 );
78 if ( (s = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 ) {
82 sock.sin_addr.s_addr = 0;
83 sock.sin_family = AF_INET;
85 if ( bind(s, (struct sockaddr *) &sock, sizeof(sock)) < 0) {
89 if (( ld = ldap_init( host, port )) == NULL ) {
94 ld->ld_cldapnaddr = 0;
95 ld->ld_cldapaddrs = NULL;
97 if ( ber_sockbuf_add_io( ld->ld_sb, &ber_sockbuf_io_udp,
98 LBER_SBIOD_LEVEL_PROVIDER, (void *)&s ) < 0 ) {
99 ldap_ld_free(ld, 1, NULL, NULL );
103 if ( ber_sockbuf_add_io( ld->ld_sb, &ber_sockbuf_io_readahead,
104 LBER_SBIOD_LEVEL_PROVIDER, NULL ) < 0 ) {
105 ldap_ld_free( ld, 1, NULL, NULL );
109 ber_sockbuf_add_io( ld->ld_sb, &ber_sockbuf_io_debug, INT_MAX, NULL );
112 ld->ld_version = LDAP_VERSION2;
114 sock.sin_family = AF_INET;
115 sock.sin_port = htons( port );
118 * 'host' may be a space-separated list.
120 if ( host != NULL ) {
121 char *host_dup = LDAP_STRDUP( host );
123 for ( ; host != NULL; host = p ) {
124 if (( p = strchr( host, ' ' )) != NULL ) {
125 for (*p++ = '\0'; *p == ' '; p++) {
130 address = inet_addr( host );
131 /* This was just a test for -1 until OSF1 let inet_addr return
132 unsigned int, which is narrower than 'unsigned long address' */
133 if ( address == 0xffffffff || address == (unsigned long) -1 ) {
134 if ((ldap_pvt_gethostbyname_a( host, &he_buf, &ha_buf,
135 &hp,&local_h_errno)<0) ||
137 errno = EHOSTUNREACH;
141 for ( i = 0; hp->h_addr_list[ i ] != 0; ++i ) {
142 SAFEMEMCPY( (char *)&sock.sin_addr,
143 (char *)hp->h_addr_list[ i ],
144 sizeof(sock.sin_addr));
145 if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
146 ldap_ld_free( ld, 1, NULL, NULL );
147 LDAP_FREE( host_dup );
153 sock.sin_addr.s_addr = address;
154 if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
155 ldap_ld_free( ld, 1, NULL, NULL );
156 LDAP_FREE( host_dup );
161 if ( ld->ld_host == NULL ) {
162 ld->ld_host = LDAP_STRDUP( host );
165 LDAP_FREE( host_dup );
167 sock.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
168 if ( add_addr( ld, (struct sockaddr *)&sock ) < 0 ) {
169 ldap_ld_free( ld, 1, NULL, NULL );
174 if ( ld->ld_cldapaddrs == NULL
175 || ( ld->ld_defconn = ldap_new_connection( ld, NULL, 1,0,NULL )) == NULL
177 ldap_ld_free( ld, 0, NULL, NULL );
181 ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_UDP_SET_DST,
182 ld->ld_cldapaddrs[0] );
184 cldap_setretryinfo( ld, 0, 0 );
188 for ( i = 0; i < ld->ld_cldapnaddr; ++i ) {
189 Debug( LDAP_DEBUG_TRACE, "end of cldap_open address %d is %s\n",
190 i, inet_ntoa( ((struct sockaddr_in *)
191 ld->ld_cldapaddrs[ i ])->sin_addr ), 0 );
201 cldap_close( LDAP *ld )
203 ldap_ld_free( ld, 0, NULL, NULL );
208 cldap_setretryinfo( LDAP *ld, int tries, int timeout )
210 ld->ld_cldaptries = ( tries <= 0 ) ? DEF_CLDAP_TRIES : tries;
211 ld->ld_cldaptimeout = ( timeout <= 0 ) ? DEF_CLDAP_TIMEOUT : timeout;
216 cldap_search_s( LDAP *ld,
217 LDAP_CONST char *base,
219 LDAP_CONST char *filter,
226 struct cldap_retinfo cri;
230 (void) memset( &cri, '\0', sizeof( cri ));
232 if ( logdn != NULL ) {
233 ld->ld_cldapdn = logdn;
234 } else if ( ld->ld_cldapdn == NULL ) {
239 if ( cri.cri_try != 0 ) {
240 --ld->ld_msgid; /* use same id as before */
243 ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_UDP_SET_DST,
244 (void *)ld->ld_cldapaddrs[cri.cri_useaddr] );
246 Debug( LDAP_DEBUG_TRACE, "cldap_search_s try %d (to %s)\n",
247 cri.cri_try, inet_ntoa( ((struct sockaddr_in *)
248 ld->ld_cldapaddrs[ cri.cri_useaddr ])->sin_addr), 0 );
250 if ( (msgid = ldap_search( ld, base, scope, filter, attrs,
251 attrsonly )) == -1 ) {
252 return( ld->ld_errno );
255 if ( ld->ld_cache != NULL && ld->ld_responses != NULL ) {
256 Debug( LDAP_DEBUG_TRACE, "cldap_search_s res from cache\n",
258 *res = ld->ld_responses;
259 ld->ld_responses = ld->ld_responses->lm_next;
260 return( ldap_result2error( ld, *res, 0 ));
262 #endif /* LDAP_NOCACHE */
263 ret = cldap_result( ld, msgid, res, &cri, base );
271 add_addr( LDAP *ld, struct sockaddr *sap )
273 struct sockaddr *newsap, **addrs;
275 if (( newsap = (struct sockaddr *)LDAP_MALLOC( sizeof( struct sockaddr )))
277 ld->ld_errno = LDAP_NO_MEMORY;
281 addrs = (struct sockaddr **)LDAP_REALLOC( ld->ld_cldapaddrs,
282 ( ld->ld_cldapnaddr + 1 ) * sizeof(struct sockaddr *));
284 if ( addrs == NULL ) {
286 ld->ld_errno = LDAP_NO_MEMORY;
290 SAFEMEMCPY( (char *)newsap, (char *)sap, sizeof( struct sockaddr ));
291 addrs[ ld->ld_cldapnaddr++ ] = newsap;
292 ld->ld_cldapaddrs = (void **)addrs;
298 cldap_result( LDAP *ld, int msgid, LDAPMessage **res,
299 struct cldap_retinfo *crip, const char *base )
303 int ret, fromaddr, i;
309 if ( crip->cri_try == 0 ) {
310 crip->cri_maxtries = ld->ld_cldaptries * ld->ld_cldapnaddr;
311 crip->cri_timeout = ld->ld_cldaptimeout;
312 crip->cri_useaddr = 0;
313 Debug( LDAP_DEBUG_TRACE, "cldap_result tries %d timeout %d\n",
314 ld->ld_cldaptries, ld->ld_cldaptimeout, 0 );
317 if ((tv.tv_sec = crip->cri_timeout / ld->ld_cldapnaddr) < 1 ) {
322 Debug( LDAP_DEBUG_TRACE,
323 "cldap_result waiting up to %ld seconds for a response\n",
324 (long) tv.tv_sec, 0, 0 );
325 ber_init_w_nullc( &ber, 0 );
326 ldap_set_ber_options( ld, &ber );
328 if ( cldap_getmsg( ld, &tv, &ber ) == -1 ) {
330 Debug( LDAP_DEBUG_TRACE, "cldap_getmsg returned -1 (%d)\n",
332 } else if ( ld->ld_errno == LDAP_TIMEOUT ) {
333 Debug( LDAP_DEBUG_TRACE,
334 "cldap_result timed out\n", 0, 0, 0 );
336 * It timed out; is it time to give up?
338 if ( ++crip->cri_try >= crip->cri_maxtries ) {
342 if ( ++crip->cri_useaddr >= ld->ld_cldapnaddr ) {
344 * new round: reset address to first one and
347 crip->cri_useaddr = 0;
348 crip->cri_timeout <<= 1;
355 * Got a response. It should look like:
356 * { msgid, logdn, { searchresponse...}}
360 if ( ber_scanf( &ber, "ia", &id, &logdn ) == LBER_ERROR ) {
361 LDAP_FREE( ber.ber_buf ); /* gack! */
362 ret = LDAP_DECODING_ERROR;
363 Debug( LDAP_DEBUG_TRACE,
364 "cldap_result: ber_scanf returned LBER_ERROR (%d)\n",
366 } else if ( id != msgid ) {
367 LDAP_FREE( ber.ber_buf ); /* gack! */
368 Debug( LDAP_DEBUG_TRACE,
369 "cldap_result: looking for msgid %d; got %d\n",
371 ret = -1; /* ignore and keep looking */
373 struct sockaddr_in * src;
375 * got a result: determine which server it came from
376 * decode into ldap message chain
378 ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_UDP_GET_SRC, (void *)&src );
380 for ( fromaddr = 0; fromaddr < ld->ld_cldapnaddr; ++fromaddr ) {
381 if ( memcmp( &((struct sockaddr_in *)
382 ld->ld_cldapaddrs[ fromaddr ])->sin_addr,
384 sizeof( struct in_addr )) == 0 ) {
388 ret = cldap_parsemsg( ld, msgid, &ber, res, base );
389 LDAP_FREE( ber.ber_buf ); /* gack! */
390 Debug( LDAP_DEBUG_TRACE,
391 "cldap_result got result (%d)\n", ret, 0, 0 );
394 if ( logdn != NULL ) {
401 * If we are giving up (successfully or otherwise) then
402 * abandon any outstanding requests.
406 if ( i >= ld->ld_cldapnaddr ) {
407 i = ld->ld_cldapnaddr - 1;
410 for ( ; i >= 0; --i ) {
411 if ( i == fromaddr ) {
414 ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_UDP_SET_DST,
415 (void *)ld->ld_cldapaddrs[i] );
417 Debug( LDAP_DEBUG_TRACE, "cldap_result abandoning id %d (to %s)\n",
418 msgid, inet_ntoa( ((struct sockaddr_in *)
419 ld->ld_cldapaddrs[i])->sin_addr ), 0 );
420 (void) ldap_abandon( ld, msgid );
424 return( ld->ld_errno = ret );
429 cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber,
430 LDAPMessage **res, const char *base )
436 char *dn, *p, *cookie;
437 LDAPMessage *chain, *prev, *ldm;
440 rc = LDAP_DECODING_ERROR; /* pessimistic */
441 ldm = chain = prev = NULL;
442 baselen = ( base == NULL ) ? 0 : strlen( base );
445 for ( tag = ber_first_element( ber, &len, &cookie );
446 tag != LBER_DEFAULT && rc != LDAP_SUCCESS;
447 tag = ber_next_element( ber, &len, cookie )) {
448 if (( ldm = (LDAPMessage *)LDAP_CALLOC( 1, sizeof(LDAPMessage)))
449 == NULL || ( ldm->lm_ber = ldap_alloc_ber_with_options( ld ))
452 break; /* return w/error*/
454 ldm->lm_msgid = msgid;
455 ldm->lm_msgtype = tag;
457 if ( tag == LDAP_RES_SEARCH_RESULT ) {
458 Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got search result\n",
461 if ( ber_get_stringal( ber, &bv ) == LBER_DEFAULT ) {
462 break; /* return w/error */
465 if ( ber_printf( ldm->lm_ber, "tO", tag, bv ) == -1 ) {
466 break; /* return w/error */
472 } else if ( tag == LDAP_RES_SEARCH_ENTRY ) {
473 if ( ber_scanf( ber, "{aO" /*}*/, &dn, &bv ) == LBER_ERROR ) {
474 break; /* return w/error */
476 Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg entry %s\n", dn, 0, 0 );
477 if ( dn != NULL && *(dn + ( slen = strlen(dn)) - 1) == '*' &&
480 * substitute original searchbase for trailing '*'
482 if (( p = (char *)LDAP_MALLOC( slen + baselen )) == NULL ) {
485 break; /* return w/error */
488 strcpy( p + slen - 1, base );
493 if ( ber_printf( ldm->lm_ber, "t{so}", tag, dn, bv->bv_val,
494 bv->bv_len ) == -1 ) {
495 break; /* return w/error */
502 } else if ( tag == LDAP_RES_SEARCH_REFERENCE ) {
505 Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got unknown tag %lu\n",
507 rc = LDAP_DECODING_ERROR;
508 break; /* return w/error */
511 /* Reset message ber so we can read from it later. Gack! */
512 ldm->lm_ber->ber_end = ldm->lm_ber->ber_ptr;
513 ldm->lm_ber->ber_ptr = ldm->lm_ber->ber_buf;
516 if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
517 fprintf( stderr, "cldap_parsemsg add message id %ld type %ld:\n",
518 (long) ldm->lm_msgid, (long) ldm->lm_msgtype );
519 ber_log_dump( LDAP_DEBUG_BER, ldap_debug, ldm->lm_ber, 1 );
521 #endif /* LDAP_DEBUG */
524 if ( ld->ld_cache != NULL ) {
525 ldap_add_result_to_cache( ld, ldm );
527 #endif /* LDAP_NOCACHE */
529 if ( chain == NULL ) {
532 prev->lm_chain = ldm;
538 /* dispose of any leftovers */
540 if ( ldm->lm_ber != NULL ) {
541 ber_free( ldm->lm_ber, 1 );
549 /* return chain, calling result2error if we got anything at all */
551 return(( *res == NULL ) ? rc : ldap_result2error( ld, *res, 0 ));
553 #endif /* LDAP_CONNECTIONLESS */