git.sur5r.net Git - openldap/blob - libraries/libldap/cldap.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /*  Portions
   7  *  Copyright (c) 1990, 1994 Regents of the University of Michigan.
   8  *  All rights reserved.
   9  *
  10  *  cldap.c - synchronous, retrying interface to the cldap protocol
  11  */
  12
  13 #include "portable.h"
  14
  15 #ifdef LDAP_CONNECTIONLESS
  16
  17 #include <stdio.h>
  18
  19 #include <ac/stdlib.h>
  20
  21 #include <ac/errno.h>
  22 #include <ac/socket.h>
  23 #include <ac/string.h>
  24 #include <ac/time.h>
  25 #include <ac/unistd.h>
  26
  27 #include "ldap-int.h"
  28
  29 #define DEF_CLDAP_TIMEOUT       3
  30 #define DEF_CLDAP_TRIES         4
  31
  32
  33 struct cldap_retinfo {
  34         int             cri_maxtries;
  35         int             cri_try;
  36         int             cri_useaddr;
  37         long            cri_timeout;
  38 };
  39
  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 ));
  48
  49 /*
  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.
  52  *
  53  * Example:
  54  *      LDAP    *ld;
  55  *      ld = cldap_open( hostname, port );
  56  */
  57
  58 LDAP *
  59 cldap_open( LDAP_CONST char *host, int port )
  60 {
  61     int                 s;
  62     unsigned long       address;
  63     struct sockaddr_in  sock;
  64     struct hostent      *hp;
  65     LDAP                *ld;
  66     char                *p;
  67     int                 i;
  68
  69     /* buffers for ldap_pvt_gethostbyname_a ... */
  70     struct hostent      he_buf;
  71     int                 local_h_errno;
  72     char                *ha_buf=NULL;
  73
  74 #define DO_RETURN(x) if (ha_buf) LDAP_FREE(ha_buf); return (x);
  75
  76     Debug( LDAP_DEBUG_TRACE, "ldap_open\n", 0, 0, 0 );
  77
  78     if ( (s = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 ) {
  79         return( NULL );
  80     }
  81
  82     sock.sin_addr.s_addr = 0;
  83     sock.sin_family = AF_INET;
  84     sock.sin_port = 0;
  85     if ( bind(s, (struct sockaddr *) &sock, sizeof(sock)) < 0)  {
  86         tcp_close( s );
  87         return( NULL );
  88     }
  89     if (( ld = ldap_init( host, port )) == NULL ) {
  90         tcp_close( s );
  91         return( NULL );
  92     }
  93
  94     ld->ld_cldapnaddr = 0;
  95     ld->ld_cldapaddrs = NULL;
  96
  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 );
 100         tcp_close( s );
 101        return NULL;
 102     }
 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 );
 106         return NULL;
 107     }
 108 #ifdef LDAP_DEBUG
 109     ber_sockbuf_add_io( ld->ld_sb, &ber_sockbuf_io_debug, INT_MAX, NULL );
 110 #endif
 111
 112     ld->ld_version = LDAP_VERSION2;
 113
 114     sock.sin_family = AF_INET;
 115     sock.sin_port = htons( port );
 116
 117     /*
 118      * 'host' may be a space-separated list.
 119      */
 120     if ( host != NULL ) {
 121         char *host_dup = LDAP_STRDUP( host );
 122         host = host_dup;
 123         for ( ; host != NULL; host = p ) {
 124             if (( p = strchr( host, ' ' )) != NULL ) {
 125                 for (*p++ = '\0'; *p == ' '; p++) {
 126                     ;
 127                 }
 128             }
 129
 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) ||
 136                     (hp==NULL)) {
 137                    errno = EHOSTUNREACH;
 138                    continue;
 139                 }
 140
 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 );
 148                         DO_RETURN( NULL );
 149                     }
 150                 }
 151
 152             } else {
 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 );
 157                     DO_RETURN( NULL );
 158                 }
 159             }
 160
 161             if ( ld->ld_host == NULL ) {
 162                     ld->ld_host = LDAP_STRDUP( host );
 163             }
 164         }
 165         LDAP_FREE( host_dup );
 166     } else {
 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 );
 170             DO_RETURN( NULL );
 171         }
 172     }
 173
 174     if ( ld->ld_cldapaddrs == NULL
 175             || ( ld->ld_defconn = ldap_new_connection( ld, NULL, 1,0,NULL )) == NULL
 176             ) {
 177         ldap_ld_free( ld, 0, NULL, NULL );
 178         DO_RETURN( NULL );
 179     }
 180
 181     ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_UDP_SET_DST,
 182         ld->ld_cldapaddrs[0] );
 183
 184     cldap_setretryinfo( ld, 0, 0 );
 185
 186 #ifdef LDAP_DEBUG
 187     putchar( '\n' );
 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 );
 192     }
 193 #endif
 194
 195     DO_RETURN( ld );
 196 }
 197
 198 #undef DO_RETURN
 199
 200 void
 201 cldap_close( LDAP *ld )
 202 {
 203         ldap_ld_free( ld, 0, NULL, NULL );
 204 }
 205
 206
 207 void
 208 cldap_setretryinfo( LDAP *ld, int tries, int timeout )
 209 {
 210     ld->ld_cldaptries = ( tries <= 0 ) ? DEF_CLDAP_TRIES : tries;
 211     ld->ld_cldaptimeout = ( timeout <= 0 ) ? DEF_CLDAP_TIMEOUT : timeout;
 212 }
 213
 214
 215 int
 216 cldap_search_s( LDAP *ld,
 217         LDAP_CONST char *base,
 218         int scope,
 219         LDAP_CONST char *filter,
 220         char **attrs,
 221         int attrsonly,
 222         LDAPMessage **res,
 223         char *logdn )
 224 {
 225     int                         ret, msgid;
 226     struct cldap_retinfo        cri;
 227
 228     *res = NULL;
 229
 230     (void) memset( &cri, 0, sizeof( cri ));
 231
 232     if ( logdn != NULL ) {
 233         ld->ld_cldapdn = logdn;
 234     } else if ( ld->ld_cldapdn == NULL ) {
 235         ld->ld_cldapdn = "";
 236     }
 237
 238     do {
 239         if ( cri.cri_try != 0 ) {
 240                 --ld->ld_msgid; /* use same id as before */
 241         }
 242
 243         ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_UDP_SET_DST,
 244             (void *)ld->ld_cldapaddrs[cri.cri_useaddr] );
 245
 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 );
 249
 250             if ( (msgid = ldap_search( ld, base, scope, filter, attrs,
 251                 attrsonly )) == -1 ) {
 252                     return( ld->ld_errno );
 253             }
 254 #ifndef LDAP_NOCACHE
 255             if ( ld->ld_cache != NULL && ld->ld_responses != NULL ) {
 256                 Debug( LDAP_DEBUG_TRACE, "cldap_search_s res from cache\n",
 257                         0, 0, 0 );
 258                 *res = ld->ld_responses;
 259                 ld->ld_responses = ld->ld_responses->lm_next;
 260                 return( ldap_result2error( ld, *res, 0 ));
 261             }
 262 #endif /* LDAP_NOCACHE */
 263             ret = cldap_result( ld, msgid, res, &cri, base );
 264         } while (ret == -1);
 265
 266         return( ret );
 267 }
 268
 269
 270 static int
 271 add_addr( LDAP *ld, struct sockaddr *sap )
 272 {
 273     struct sockaddr     *newsap, **addrs;
 274
 275     if (( newsap = (struct sockaddr *)LDAP_MALLOC( sizeof( struct sockaddr )))
 276             == NULL ) {
 277         ld->ld_errno = LDAP_NO_MEMORY;
 278         return( -1 );
 279     }
 280
 281         addrs = (struct sockaddr **)LDAP_REALLOC( ld->ld_cldapaddrs,
 282                 ( ld->ld_cldapnaddr + 1 ) * sizeof(struct sockaddr *));
 283
 284     if ( addrs == NULL ) {
 285         LDAP_FREE( newsap );
 286         ld->ld_errno = LDAP_NO_MEMORY;
 287         return( -1 );
 288     }
 289
 290     SAFEMEMCPY( (char *)newsap, (char *)sap, sizeof( struct sockaddr ));
 291     addrs[ ld->ld_cldapnaddr++ ] = newsap;
 292     ld->ld_cldapaddrs = (void **)addrs;
 293     return( 0 );
 294 }
 295
 296
 297 static int
 298 cldap_result( LDAP *ld, int msgid, LDAPMessage **res,
 299         struct cldap_retinfo *crip, const char *base )
 300 {
 301     BerElement          ber;
 302     char                *logdn;
 303     int                 ret, fromaddr, i;
 304         ber_int_t       id;
 305     struct timeval      tv;
 306
 307     fromaddr = -1;
 308
 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 );
 315     }
 316
 317     if ((tv.tv_sec = crip->cri_timeout / ld->ld_cldapnaddr) < 1 ) {
 318         tv.tv_sec = 1;
 319     }
 320     tv.tv_usec = 0;
 321
 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 );
 327
 328     if ( cldap_getmsg( ld, &tv, &ber ) == -1 ) {
 329         ret = ld->ld_errno;
 330         Debug( LDAP_DEBUG_TRACE, "cldap_getmsg returned -1 (%d)\n",
 331                 ret, 0, 0 );
 332     } else if ( ld->ld_errno == LDAP_TIMEOUT ) {
 333         Debug( LDAP_DEBUG_TRACE,
 334             "cldap_result timed out\n", 0, 0, 0 );
 335         /*
 336          * It timed out; is it time to give up?
 337          */
 338         if ( ++crip->cri_try >= crip->cri_maxtries ) {
 339             ret = LDAP_TIMEOUT;
 340             --crip->cri_try;
 341         } else {
 342             if ( ++crip->cri_useaddr >= ld->ld_cldapnaddr ) {
 343                 /*
 344                  * new round: reset address to first one and
 345                  * double the timeout
 346                  */
 347                 crip->cri_useaddr = 0;
 348                 crip->cri_timeout <<= 1;
 349             }
 350             ret = -1;
 351         }
 352
 353     } else {
 354         /*
 355          * Got a response.  It should look like:
 356          * { msgid, logdn, { searchresponse...}}
 357          */
 358         logdn = NULL;
 359
 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",
 365                     ret, 0, 0 );
 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",
 370                     msgid, id, 0 );
 371             ret = -1;   /* ignore and keep looking */
 372         } else {
 373             struct sockaddr_in * src;
 374             /*
 375              * got a result: determine which server it came from
 376              * decode into ldap message chain
 377              */
 378             ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_UDP_GET_SRC, (void *)&src );
 379
 380             for ( fromaddr = 0; fromaddr < ld->ld_cldapnaddr; ++fromaddr ) {
 381                     if ( memcmp( &((struct sockaddr_in *)
 382                             ld->ld_cldapaddrs[ fromaddr ])->sin_addr,
 383                             &(src->sin_addr),
 384                             sizeof( struct in_addr )) == 0 ) {
 385                         break;
 386                     }
 387             }
 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 );
 392         }
 393
 394         if ( logdn != NULL ) {
 395                 LDAP_FREE( logdn );
 396         }
 397     }
 398
 399
 400     /*
 401      * If we are giving up (successfully or otherwise) then
 402      * abandon any outstanding requests.
 403      */
 404     if ( ret != -1 ) {
 405         i = crip->cri_try;
 406         if ( i >= ld->ld_cldapnaddr ) {
 407             i = ld->ld_cldapnaddr - 1;
 408         }
 409
 410         for ( ; i >= 0; --i ) {
 411             if ( i == fromaddr ) {
 412                 continue;
 413             }
 414             ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_UDP_SET_DST,
 415                 (void *)ld->ld_cldapaddrs[i] );
 416
 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 );
 421         }
 422     }
 423
 424     return( ld->ld_errno = ret );
 425 }
 426
 427
 428 static int
 429 cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber,
 430         LDAPMessage **res, const char *base )
 431 {
 432     ber_tag_t   tag;
 433         ber_len_t       len;
 434     int                 baselen, slen;
 435         ber_tag_t       rc;
 436     char                *dn, *p, *cookie;
 437     LDAPMessage         *chain, *prev, *ldm;
 438     struct berval       *bv;
 439
 440     rc = LDAP_DECODING_ERROR;   /* pessimistic */
 441     ldm = chain = prev = NULL;
 442     baselen = ( base == NULL ) ? 0 : strlen( base );
 443     bv = NULL;
 444
 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 ))
 450                 == NULL ) {
 451             rc = LDAP_NO_MEMORY;
 452             break;      /* return w/error*/
 453         }
 454         ldm->lm_msgid = msgid;
 455         ldm->lm_msgtype = tag;
 456
 457         if ( tag == LDAP_RES_SEARCH_RESULT ) {
 458             Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got search result\n",
 459                     0, 0, 0 );
 460
 461             if ( ber_get_stringal( ber, &bv ) == LBER_DEFAULT ) {
 462                 break;  /* return w/error */
 463             }
 464
 465             if ( ber_printf( ldm->lm_ber, "tO", tag, bv ) == -1 ) {
 466                 break;  /* return w/error */
 467             }
 468             ber_bvfree( bv );
 469             bv = NULL;
 470             rc = LDAP_SUCCESS;
 471
 472         } else if ( tag == LDAP_RES_SEARCH_ENTRY ) {
 473             if ( ber_scanf( ber, "{aO" /*}*/, &dn, &bv ) == LBER_ERROR ) {
 474                 break;  /* return w/error */
 475             }
 476             Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg entry %s\n", dn, 0, 0 );
 477             if ( dn != NULL && *(dn + ( slen = strlen(dn)) - 1) == '*' &&
 478                     baselen > 0 ) {
 479                 /*
 480                  * substitute original searchbase for trailing '*'
 481                  */
 482                 if (( p = (char *)LDAP_MALLOC( slen + baselen )) == NULL ) {
 483                     rc = LDAP_NO_MEMORY;
 484                     LDAP_FREE( dn );
 485                     break;      /* return w/error */
 486                 }
 487                 strcpy( p, dn );
 488                 strcpy( p + slen - 1, base );
 489                 LDAP_FREE( dn );
 490                 dn = p;
 491             }
 492
 493             if ( ber_printf( ldm->lm_ber, "t{so}", tag, dn, bv->bv_val,
 494                     bv->bv_len ) == -1 ) {
 495                 break;  /* return w/error */
 496             }
 497             LDAP_FREE( dn );
 498             ber_bvfree( bv );
 499             bv = NULL;
 500
 501 #ifdef notyet
 502         } else if ( tag == LDAP_RES_SEARCH_REFERENCE ) {
 503 #endif
 504         } else {
 505             Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg got unknown tag %lu\n",
 506                     tag, 0, 0 );
 507             rc = LDAP_DECODING_ERROR;
 508             break;      /* return w/error */
 509         }
 510
 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;
 514
 515 #ifdef LDAP_DEBUG
 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 );
 520         }
 521 #endif /* LDAP_DEBUG */
 522
 523 #ifndef LDAP_NOCACHE
 524             if ( ld->ld_cache != NULL ) {
 525                 ldap_add_result_to_cache( ld, ldm );
 526             }
 527 #endif /* LDAP_NOCACHE */
 528
 529         if ( chain == NULL ) {
 530             chain = ldm;
 531         } else {
 532             prev->lm_chain = ldm;
 533         }
 534         prev = ldm;
 535         ldm = NULL;
 536     }
 537
 538     /* dispose of any leftovers */
 539     if ( ldm != NULL ) {
 540         if ( ldm->lm_ber != NULL ) {
 541             ber_free( ldm->lm_ber, 1 );
 542         }
 543         LDAP_FREE( ldm );
 544     }
 545     if ( bv != NULL ) {
 546         ber_bvfree( bv );
 547     }
 548
 549     /* return chain, calling result2error if we got anything at all */
 550     *res = chain;
 551     return(( *res == NULL ) ? rc : ldap_result2error( ld, *res, 0 ));
 552 }
 553 #endif /* LDAP_CONNECTIONLESS */