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

   1 /*
   2  *  Copyright (c) 1995 Regents of the University of Michigan.
   3  *  All rights reserved.
   4  *
   5  *  request.c - sending of ldap requests; handling of referrals
   6  */
   7
   8 #include "portable.h"
   9
  10 #ifndef lint
  11 static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of Michigan.\nAll rights reserved.\n";
  12 #endif
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16
  17 #include <ac/errno.h>
  18 #include <ac/socket.h>
  19 #include <ac/string.h>
  20 #include <ac/time.h>
  21 #include <ac/unistd.h>
  22
  23 #include "lber.h"
  24 #include "ldap.h"
  25 #include "ldap-int.h"
  26
  27 #if defined( LDAP_REFERRALS ) || defined( LDAP_DNS )
  28 static LDAPConn *find_connection LDAP_P(( LDAP *ld, LDAPServer *srv, int any ));
  29 static void use_connection LDAP_P(( LDAP *ld, LDAPConn *lc ));
  30 static void free_servers LDAP_P(( LDAPServer *srvlist ));
  31 #endif /* LDAP_REFERRALS || LDAP_DNS */
  32
  33
  34 #ifdef LDAP_DNS
  35 static LDAPServer *dn2servers LDAP_P(( LDAP *ld, char *dn ));
  36 #endif /* LDAP_DNS */
  37
  38 #ifdef LDAP_REFERRALS
  39 static BerElement *re_encode_request LDAP_P(( LDAP *ld, BerElement *origber,
  40     int msgid, char **dnp ));
  41 #endif /* LDAP_REFERRALS */
  42
  43
  44 BerElement *
  45 ldap_alloc_ber_with_options( LDAP *ld )
  46 {
  47         BerElement      *ber;
  48
  49         if (( ber = ber_alloc_t( ld->ld_lberoptions )) == NULLBER ) {
  50                 ld->ld_errno = LDAP_NO_MEMORY;
  51 #ifdef STR_TRANSLATION
  52         } else {
  53                 ldap_set_ber_options( ld, ber );
  54 #endif /* STR_TRANSLATION */
  55         }
  56
  57         return( ber );
  58 }
  59
  60
  61 void
  62 ldap_set_ber_options( LDAP *ld, BerElement *ber )
  63 {
  64         ber->ber_options = ld->ld_lberoptions;
  65 #ifdef STR_TRANSLATION
  66         if (( ld->ld_lberoptions & LBER_TRANSLATE_STRINGS ) != 0 ) {
  67                 ber_set_string_translators( ber,
  68                     ld->ld_lber_encode_translate_proc,
  69                     ld->ld_lber_decode_translate_proc );
  70         }
  71 #endif /* STR_TRANSLATION */
  72 }
  73
  74
  75 int
  76 ldap_send_initial_request( LDAP *ld, unsigned long msgtype, char *dn,
  77         BerElement *ber )
  78 {
  79 #if defined( LDAP_REFERRALS ) || defined( LDAP_DNS )
  80         LDAPServer      *servers;
  81 #endif /* LDAP_REFERRALS || LDAP_DNS */
  82
  83         Debug( LDAP_DEBUG_TRACE, "ldap_send_initial_request\n", 0, 0, 0 );
  84
  85 #if !defined( LDAP_REFERRALS ) && !defined( LDAP_DNS )
  86         if ( ber_flush( &ld->ld_sb, ber, 1 ) != 0 ) {
  87                 ld->ld_errno = LDAP_SERVER_DOWN;
  88                 return( -1 );
  89         }
  90
  91         ld->ld_errno = LDAP_SUCCESS;
  92         return( ld->ld_msgid );
  93 #else /* !LDAP_REFERRALS && !LDAP_DNS */
  94
  95 #ifdef LDAP_DNS
  96         if (( ld->ld_options & LDAP_OPT_DNS ) != 0 && ldap_is_dns_dn( dn )) {
  97                 if (( servers = dn2servers( ld, dn )) == NULL ) {
  98                         ber_free( ber, 1 );
  99                         return( -1 );
 100                 }
 101
 102 #ifdef LDAP_DEBUG
 103                 if ( ldap_debug & LDAP_DEBUG_TRACE ) {
 104                         LDAPServer      *srv;
 105
 106                         for ( srv = servers; srv != NULL;
 107                             srv = srv->lsrv_next ) {
 108                                 fprintf( stderr,
 109                                     "LDAP server %s:  dn %s, port %d\n",
 110                                     srv->lsrv_host, ( srv->lsrv_dn == NULL ) ?
 111                                     "(default)" : srv->lsrv_dn,
 112                                     srv->lsrv_port );
 113                         }
 114                 }
 115 #endif /* LDAP_DEBUG */
 116         } else {
 117 #endif /* LDAP_DNS */
 118                 /*
 119                  * use of DNS is turned off or this is an X.500 DN...
 120                  * use our default connection
 121                  */
 122                 servers = NULL;
 123 #ifdef LDAP_DNS
 124         }
 125 #endif /* LDAP_DNS */
 126
 127         return( ldap_send_server_request( ld, ber, ld->ld_msgid, NULL, servers,
 128             NULL, 0 ));
 129 #endif /* !LDAP_REFERRALS && !LDAP_DNS */
 130 }
 131
 132
 133
 134 #if defined( LDAP_REFERRALS ) || defined( LDAP_DNS )
 135 int
 136 ldap_send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest
 137         *parentreq, LDAPServer *srvlist, LDAPConn *lc, int bind )
 138 {
 139         LDAPRequest     *lr;
 140         int incparent;
 141
 142         Debug( LDAP_DEBUG_TRACE, "ldap_send_server_request\n", 0, 0, 0 );
 143
 144         incparent = 0;
 145         ld->ld_errno = LDAP_SUCCESS;    /* optimistic */
 146
 147         if ( lc == NULL ) {
 148                 if ( srvlist == NULL ) {
 149                         lc = ld->ld_defconn;
 150                 } else {
 151                         if (( lc = find_connection( ld, srvlist, 1 )) ==
 152                             NULL ) {
 153                                 if ( bind && (parentreq != NULL) ) {
 154                                         /* Remember the bind in the parent */
 155                                         incparent = 1;
 156                                         ++parentreq->lr_outrefcnt;
 157                                 }
 158                                 lc = ldap_new_connection( ld, &srvlist, 0, 1, bind );
 159                         }
 160                         free_servers( srvlist );
 161                 }
 162         }
 163
 164         if ( lc == NULL || lc->lconn_status != LDAP_CONNST_CONNECTED ) {
 165                 ber_free( ber, 1 );
 166                 if ( ld->ld_errno == LDAP_SUCCESS ) {
 167                         ld->ld_errno = LDAP_SERVER_DOWN;
 168                 }
 169                 if ( incparent ) {
 170                         /* Forget about the bind */
 171                         --parentreq->lr_outrefcnt;
 172                 }
 173                 return( -1 );
 174         }
 175
 176         use_connection( ld, lc );
 177         if (( lr = (LDAPRequest *)calloc( 1, sizeof( LDAPRequest ))) ==
 178             NULL ) {
 179                 ld->ld_errno = LDAP_NO_MEMORY;
 180                 ldap_free_connection( ld, lc, 0, 0 );
 181                 ber_free( ber, 1 );
 182                 if ( incparent ) {
 183                         /* Forget about the bind */
 184                         --parentreq->lr_outrefcnt;
 185                 }
 186                 return( -1 );
 187         }
 188         lr->lr_msgid = msgid;
 189         lr->lr_status = LDAP_REQST_INPROGRESS;
 190         lr->lr_res_errno = LDAP_SUCCESS;        /* optimistic */
 191         lr->lr_ber = ber;
 192         lr->lr_conn = lc;
 193         if ( parentreq != NULL ) {      /* sub-request */
 194                 if ( !incparent ) {
 195                         /* Increment if we didn't do it before the bind */
 196                         ++parentreq->lr_outrefcnt;
 197                 }
 198                 lr->lr_origid = parentreq->lr_origid;
 199                 lr->lr_parentcnt = parentreq->lr_parentcnt + 1;
 200                 lr->lr_parent = parentreq;
 201                 lr->lr_refnext = parentreq->lr_refnext;
 202                 parentreq->lr_refnext = lr;
 203         } else {                        /* original request */
 204                 lr->lr_origid = lr->lr_msgid;
 205         }
 206
 207         if (( lr->lr_next = ld->ld_requests ) != NULL ) {
 208                 lr->lr_next->lr_prev = lr;
 209         }
 210         ld->ld_requests = lr;
 211         lr->lr_prev = NULL;
 212
 213         if ( ber_flush( lc->lconn_sb, ber, 0 ) != 0 ) {
 214 #ifdef notyet
 215                 extern int      errno;
 216
 217                 if ( errno == EWOULDBLOCK ) {
 218                         /* need to continue write later */
 219                         lr->lr_status = LDAP_REQST_WRITING;
 220                         ldap_mark_select_write( ld, lc->lconn_sb );
 221                 } else {
 222 #else /* notyet */
 223                         ld->ld_errno = LDAP_SERVER_DOWN;
 224                         ldap_free_request( ld, lr );
 225                         ldap_free_connection( ld, lc, 0, 0 );
 226                         return( -1 );
 227 #endif /* notyet */
 228 #ifdef notyet
 229                 }
 230 #endif /* notyet */
 231         } else {
 232                 if ( parentreq == NULL ) {
 233                         ber->ber_end = ber->ber_ptr;
 234                         ber->ber_ptr = ber->ber_buf;
 235                 }
 236
 237                 /* sent -- waiting for a response */
 238                 ldap_mark_select_read( ld, lc->lconn_sb );
 239         }
 240
 241         ld->ld_errno = LDAP_SUCCESS;
 242         return( msgid );
 243 }
 244
 245
 246 LDAPConn *
 247 ldap_new_connection( LDAP *ld, LDAPServer **srvlistp, int use_ldsb,
 248         int connect, int bind )
 249 {
 250         LDAPConn        *lc;
 251         LDAPServer      *prevsrv, *srv;
 252         Sockbuf         *sb;
 253
 254         /*
 255          * make a new LDAP server connection
 256          * XXX open connection synchronously for now
 257          */
 258         if (( lc = (LDAPConn *)calloc( 1, sizeof( LDAPConn ))) == NULL ||
 259             ( !use_ldsb && ( sb = (Sockbuf *)calloc( 1, sizeof( Sockbuf )))
 260             == NULL )) {
 261                 if ( lc != NULL ) {
 262                         free( (char *)lc );
 263                 }
 264                 ld->ld_errno = LDAP_NO_MEMORY;
 265                 return( NULL );
 266         }
 267
 268         lc->lconn_sb = ( use_ldsb ) ? &ld->ld_sb : sb;
 269
 270         if ( connect ) {
 271                 prevsrv = NULL;
 272
 273                 for ( srv = *srvlistp; srv != NULL; srv = srv->lsrv_next ) {
 274                         if ( open_ldap_connection( ld, lc->lconn_sb,
 275                             srv->lsrv_host, srv->lsrv_port,
 276                             &lc->lconn_krbinstance, 0 ) != -1 ) {
 277                                 break;
 278                         }
 279                         prevsrv = srv;
 280                 }
 281
 282                 if ( srv == NULL ) {
 283                     if ( !use_ldsb ) {
 284                         free( (char *)lc->lconn_sb );
 285                     }
 286                     free( (char *)lc );
 287                     ld->ld_errno = LDAP_SERVER_DOWN;
 288                     return( NULL );
 289                 }
 290
 291                 if ( prevsrv == NULL ) {
 292                     *srvlistp = srv->lsrv_next;
 293                 } else {
 294                     prevsrv->lsrv_next = srv->lsrv_next;
 295                 }
 296                 lc->lconn_server = srv;
 297         }
 298
 299         lc->lconn_status = LDAP_CONNST_CONNECTED;
 300         lc->lconn_next = ld->ld_conns;
 301         ld->ld_conns = lc;
 302
 303         /*
 304          * XXX for now, we always do a synchronous bind.  This will have
 305          * to change in the long run...
 306          */
 307         if ( bind ) {
 308                 int             err, freepasswd, authmethod;
 309                 char            *binddn, *passwd;
 310                 LDAPConn        *savedefconn;
 311
 312                 freepasswd = err = 0;
 313
 314                 if ( ld->ld_rebindproc == NULL ) {
 315                         binddn = passwd = "";
 316                         authmethod = LDAP_AUTH_SIMPLE;
 317                 } else {
 318                         if (( err = (*ld->ld_rebindproc)( ld, &binddn, &passwd,
 319                             &authmethod, 0 )) == LDAP_SUCCESS ) {
 320                                 freepasswd = 1;
 321                         } else {
 322                                 ld->ld_errno = err;
 323                                 err = -1;
 324                         }
 325                 }
 326
 327
 328                 if ( err == 0 ) {
 329                         savedefconn = ld->ld_defconn;
 330                         ld->ld_defconn = lc;
 331                         ++lc->lconn_refcnt;     /* avoid premature free */
 332
 333                         if ( ldap_bind_s( ld, binddn, passwd, authmethod ) !=
 334                             LDAP_SUCCESS ) {
 335                                 err = -1;
 336                         }
 337                         --lc->lconn_refcnt;
 338                         ld->ld_defconn = savedefconn;
 339                 }
 340
 341                 if ( freepasswd ) {
 342                         (*ld->ld_rebindproc)( ld, &binddn, &passwd,
 343                                 &authmethod, 1 );
 344                 }
 345
 346                 if ( err != 0 ) {
 347                         ldap_free_connection( ld, lc, 1, 0 );
 348                         lc = NULL;
 349                 }
 350         }
 351
 352         return( lc );
 353 }
 354
 355
 356 static LDAPConn *
 357 find_connection( LDAP *ld, LDAPServer *srv, int any )
 358 /*
 359  * return an existing connection (if any) to the server srv
 360  * if "any" is non-zero, check for any server in the "srv" chain
 361  */
 362 {
 363         LDAPConn        *lc;
 364         LDAPServer      *ls;
 365
 366         for ( lc = ld->ld_conns; lc != NULL; lc = lc->lconn_next ) {
 367                 for ( ls = srv; ls != NULL; ls = ls->lsrv_next ) {
 368                         if ( lc->lconn_server->lsrv_host != NULL &&
 369                             ls->lsrv_host != NULL && strcasecmp(
 370                             ls->lsrv_host, lc->lconn_server->lsrv_host ) == 0
 371                             && ls->lsrv_port == lc->lconn_server->lsrv_port ) {
 372                                 return( lc );
 373                         }
 374                         if ( !any ) {
 375                                 break;
 376                         }
 377                 }
 378         }
 379
 380         return( NULL );
 381 }
 382
 383
 384
 385 static void
 386 use_connection( LDAP *ld, LDAPConn *lc )
 387 {
 388         ++lc->lconn_refcnt;
 389         lc->lconn_lastused = time( 0 );
 390 }
 391
 392
 393 void
 394 ldap_free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind )
 395 {
 396         LDAPConn        *tmplc, *prevlc;
 397
 398         Debug( LDAP_DEBUG_TRACE, "ldap_free_connection\n", 0, 0, 0 );
 399
 400         if ( force || --lc->lconn_refcnt <= 0 ) {
 401                 if ( lc->lconn_status == LDAP_CONNST_CONNECTED ) {
 402                         ldap_mark_select_clear( ld, lc->lconn_sb );
 403                         if ( unbind ) {
 404                                 ldap_send_unbind( ld, lc->lconn_sb );
 405                         }
 406                         ldap_close_connection( lc->lconn_sb );
 407                         if ( lc->lconn_sb->sb_ber.ber_buf != NULL ) {
 408                                 free( lc->lconn_sb->sb_ber.ber_buf );
 409                         }
 410                 }
 411                 prevlc = NULL;
 412                 for ( tmplc = ld->ld_conns; tmplc != NULL;
 413                     tmplc = tmplc->lconn_next ) {
 414                         if ( tmplc == lc ) {
 415                                 if ( prevlc == NULL ) {
 416                                     ld->ld_conns = tmplc->lconn_next;
 417                                 } else {
 418                                     prevlc->lconn_next = tmplc->lconn_next;
 419                                 }
 420                                 break;
 421                         }
 422                         prevlc = tmplc;
 423                 }
 424                 free_servers( lc->lconn_server );
 425                 if ( lc->lconn_krbinstance != NULL ) {
 426                         free( lc->lconn_krbinstance );
 427                 }
 428                 if ( lc->lconn_sb != &ld->ld_sb ) {
 429                         free( (char *)lc->lconn_sb );
 430                 }
 431                 free( lc );
 432                 Debug( LDAP_DEBUG_TRACE, "ldap_free_connection: actually freed\n",
 433                     0, 0, 0 );
 434         } else {
 435                 lc->lconn_lastused = time( 0 );
 436                 Debug( LDAP_DEBUG_TRACE, "ldap_free_connection: refcnt %d\n",
 437                     lc->lconn_refcnt, 0, 0 );
 438         }
 439 }
 440
 441
 442 #ifdef LDAP_DEBUG
 443 void
 444 ldap_dump_connection( LDAP *ld, LDAPConn *lconns, int all )
 445 {
 446         LDAPConn        *lc;
 447
 448         fprintf( stderr, "** Connection%s:\n", all ? "s" : "" );
 449         for ( lc = lconns; lc != NULL; lc = lc->lconn_next ) {
 450                 if ( lc->lconn_server != NULL ) {
 451                         fprintf( stderr, "* host: %s  port: %d%s\n",
 452                             ( lc->lconn_server->lsrv_host == NULL ) ? "(null)"
 453                             : lc->lconn_server->lsrv_host,
 454                             lc->lconn_server->lsrv_port, ( lc->lconn_sb ==
 455                             &ld->ld_sb ) ? "  (default)" : "" );
 456                 }
 457                 fprintf( stderr, "  refcnt: %d  status: %s\n", lc->lconn_refcnt,
 458                     ( lc->lconn_status == LDAP_CONNST_NEEDSOCKET ) ?
 459                     "NeedSocket" : ( lc->lconn_status ==
 460                     LDAP_CONNST_CONNECTING ) ? "Connecting" : "Connected" );
 461                 fprintf( stderr, "  last used: %s\n",
 462                     ctime( &lc->lconn_lastused ));
 463                 if ( !all ) {
 464                         break;
 465                 }
 466         }
 467 }
 468
 469
 470 void
 471 ldap_dump_requests_and_responses( LDAP *ld )
 472 {
 473         LDAPRequest     *lr;
 474         LDAPMessage     *lm, *l;
 475
 476         fprintf( stderr, "** Outstanding Requests:\n" );
 477         if (( lr = ld->ld_requests ) == NULL ) {
 478                 fprintf( stderr, "   Empty\n" );
 479         }
 480         for ( ; lr != NULL; lr = lr->lr_next ) {
 481             fprintf( stderr, " * msgid %d,  origid %d, status %s\n",
 482                 lr->lr_msgid, lr->lr_origid, ( lr->lr_status ==
 483                 LDAP_REQST_INPROGRESS ) ? "InProgress" :
 484                 ( lr->lr_status == LDAP_REQST_CHASINGREFS ) ? "ChasingRefs" :
 485                 ( lr->lr_status == LDAP_REQST_NOTCONNECTED ) ? "NotConnected" :
 486                 "Writing" );
 487             fprintf( stderr, "   outstanding referrals %d, parent count %d\n",
 488                     lr->lr_outrefcnt, lr->lr_parentcnt );
 489         }
 490
 491         fprintf( stderr, "** Response Queue:\n" );
 492         if (( lm = ld->ld_responses ) == NULLMSG ) {
 493                 fprintf( stderr, "   Empty\n" );
 494         }
 495         for ( ; lm != NULLMSG; lm = lm->lm_next ) {
 496                 fprintf( stderr, " * msgid %d,  type %d\n",
 497                     lm->lm_msgid, lm->lm_msgtype );
 498                 if (( l = lm->lm_chain ) != NULL ) {
 499                         fprintf( stderr, "   chained responses:\n" );
 500                         for ( ; l != NULLMSG; l = l->lm_chain ) {
 501                                 fprintf( stderr,
 502                                     "  * msgid %d,  type %d\n",
 503                                     l->lm_msgid, l->lm_msgtype );
 504                         }
 505                 }
 506         }
 507 }
 508 #endif /* LDAP_DEBUG */
 509
 510
 511 void
 512 ldap_free_request( LDAP *ld, LDAPRequest *lr )
 513 {
 514         LDAPRequest     *tmplr, *nextlr;
 515
 516         Debug( LDAP_DEBUG_TRACE, "ldap_free_request (origid %d, msgid %d)\n",
 517                 lr->lr_origid, lr->lr_msgid, 0 );
 518
 519         if ( lr->lr_parent != NULL ) {
 520                 --lr->lr_parent->lr_outrefcnt;
 521         } else {
 522                 /* free all referrals (child requests) */
 523                 for ( tmplr = lr->lr_refnext; tmplr != NULL; tmplr = nextlr ) {
 524                         nextlr = tmplr->lr_refnext;
 525                         ldap_free_request( ld, tmplr );
 526                 }
 527         }
 528
 529         if ( lr->lr_prev == NULL ) {
 530                 ld->ld_requests = lr->lr_next;
 531         } else {
 532                 lr->lr_prev->lr_next = lr->lr_next;
 533         }
 534
 535         if ( lr->lr_next != NULL ) {
 536                 lr->lr_next->lr_prev = lr->lr_prev;
 537         }
 538
 539         if ( lr->lr_ber != NULL ) {
 540                 ber_free( lr->lr_ber, 1 );
 541         }
 542
 543         if ( lr->lr_res_error != NULL ) {
 544                 free( lr->lr_res_error );
 545         }
 546
 547         if ( lr->lr_res_matched != NULL ) {
 548                 free( lr->lr_res_matched );
 549         }
 550
 551         free( lr );
 552 }
 553
 554
 555 static void
 556 free_servers( LDAPServer *srvlist )
 557 {
 558     LDAPServer  *nextsrv;
 559
 560     while ( srvlist != NULL ) {
 561         nextsrv = srvlist->lsrv_next;
 562         if ( srvlist->lsrv_dn != NULL ) {
 563                 free( srvlist->lsrv_dn );
 564         }
 565         if ( srvlist->lsrv_host != NULL ) {
 566                 free( srvlist->lsrv_host );
 567         }
 568         free( srvlist );
 569         srvlist = nextsrv;
 570     }
 571 }
 572 #endif /* LDAP_REFERRALS || LDAP_DNS */
 573
 574
 575 #ifdef LDAP_REFERRALS
 576 /*
 577  * XXX merging of errors in this routine needs to be improved
 578  */
 579 int
 580 ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp )
 581 {
 582         int             rc, count, len, newdn;
 583 #ifdef LDAP_DNS
 584         int             ldapref;
 585 #endif /* LDAP_DNS */
 586         char            *p, *ports, *ref, *tmpref, *refdn, *unfollowed;
 587         LDAPRequest     *origreq;
 588         LDAPServer      *srv;
 589         BerElement      *ber;
 590
 591         Debug( LDAP_DEBUG_TRACE, "ldap_chase_referrals\n", 0, 0, 0 );
 592
 593         ld->ld_errno = LDAP_SUCCESS;    /* optimistic */
 594         *hadrefp = 0;
 595
 596         if ( *errstrp == NULL ) {
 597                 return( 0 );
 598         }
 599
 600         len = strlen( *errstrp );
 601         for ( p = *errstrp; len >= LDAP_REF_STR_LEN; ++p, --len ) {
 602                 if (( *p == 'R' || *p == 'r' ) && strncasecmp( p,
 603                     LDAP_REF_STR, LDAP_REF_STR_LEN ) == 0 ) {
 604                         *p = '\0';
 605                         p += LDAP_REF_STR_LEN;
 606                         break;
 607                 }
 608         }
 609
 610         if ( len < LDAP_REF_STR_LEN ) {
 611                 return( 0 );
 612         }
 613
 614         if ( lr->lr_parentcnt >= ld->ld_refhoplimit ) {
 615                 Debug( LDAP_DEBUG_ANY,
 616                     "more than %d referral hops (dropping)\n",
 617                     ld->ld_refhoplimit, 0, 0 );
 618                     /* XXX report as error in ld->ld_errno? */
 619                     return( 0 );
 620         }
 621
 622         /* find original request */
 623         for ( origreq = lr; origreq->lr_parent != NULL;
 624              origreq = origreq->lr_parent ) {
 625                 ;
 626         }
 627
 628         unfollowed = NULL;
 629         rc = count = 0;
 630
 631         /* parse out & follow referrals */
 632         for ( ref = p; rc == 0 && ref != NULL; ref = p ) {
 633 #ifdef LDAP_DNS
 634                 ldapref = 0;
 635 #endif /* LDAP_DNS */
 636
 637                 if (( p = strchr( ref, '\n' )) != NULL ) {
 638                         *p++ = '\0';
 639                 } else {
 640                         p = NULL;
 641                 }
 642
 643                 len = strlen( ref );
 644                 if ( len > LDAP_LDAP_REF_STR_LEN && strncasecmp( ref,
 645                     LDAP_LDAP_REF_STR, LDAP_LDAP_REF_STR_LEN ) == 0 ) {
 646                         Debug( LDAP_DEBUG_TRACE,
 647                             "chasing LDAP referral: <%s>\n", ref, 0, 0 );
 648 #ifdef LDAP_DNS
 649                         ldapref = 1;
 650 #endif /* LDAP_DNS */
 651                         tmpref = ref + LDAP_LDAP_REF_STR_LEN;
 652 #ifdef LDAP_DNS
 653                 } else if ( len > LDAP_DX_REF_STR_LEN && strncasecmp( ref,
 654                     LDAP_DX_REF_STR, LDAP_DX_REF_STR_LEN ) == 0 ) {
 655                         Debug( LDAP_DEBUG_TRACE,
 656                             "chasing DX referral: <%s>\n", ref, 0, 0 );
 657                         tmpref = ref + LDAP_DX_REF_STR_LEN;
 658 #endif /* LDAP_DNS */
 659                 } else {
 660                         Debug( LDAP_DEBUG_TRACE,
 661                             "ignoring unknown referral <%s>\n", ref, 0, 0 );
 662                         rc = ldap_append_referral( ld, &unfollowed, ref );
 663                         *hadrefp = 1;
 664                         continue;
 665                 }
 666
 667                 *hadrefp = 1;
 668                 if (( refdn = strchr( tmpref, '/' )) != NULL ) {
 669                         *refdn++ = '\0';
 670                         newdn = 1;
 671                 } else {
 672                         newdn = 0;
 673                 }
 674
 675                 if (( ber = re_encode_request( ld, origreq->lr_ber,
 676                     ++ld->ld_msgid, &refdn )) == NULL ) {
 677                         return( -1 );
 678                 }
 679
 680 #ifdef LDAP_DNS
 681                 if ( ldapref ) {
 682 #endif /* LDAP_DNS */
 683                         if (( srv = (LDAPServer *)calloc( 1,
 684                             sizeof( LDAPServer ))) == NULL ) {
 685                                 ber_free( ber, 1 );
 686                                 ld->ld_errno = LDAP_NO_MEMORY;
 687                                 return( -1 );
 688                         }
 689
 690                         if (( srv->lsrv_host = ldap_strdup( tmpref )) == NULL ) {
 691                                 free( (char *)srv );
 692                                 ber_free( ber, 1 );
 693                                 ld->ld_errno = LDAP_NO_MEMORY;
 694                                 return( -1 );
 695                         }
 696
 697                         if (( ports = strchr( srv->lsrv_host, ':' )) != NULL ) {
 698                                 *ports++ = '\0';
 699                                 srv->lsrv_port = atoi( ports );
 700                         } else {
 701                                 srv->lsrv_port = openldap_ldap_global_options.ldo_defport;
 702                         }
 703 #ifdef LDAP_DNS
 704                 } else {
 705                         srv = dn2servers( ld, tmpref );
 706                 }
 707 #endif /* LDAP_DNS */
 708
 709                 if ( srv != NULL && ldap_send_server_request( ld, ber, ld->ld_msgid,
 710                     lr, srv, NULL, 1 ) >= 0 ) {
 711                         ++count;
 712                 } else {
 713                         Debug( LDAP_DEBUG_ANY,
 714                             "Unable to chase referral (%s)\n",
 715                             ldap_err2string( ld->ld_errno ), 0, 0 );
 716                         rc = ldap_append_referral( ld, &unfollowed, ref );
 717                 }
 718
 719                 if ( !newdn && refdn != NULL ) {
 720                         free( refdn );
 721                 }
 722         }
 723
 724         free( *errstrp );
 725         *errstrp = unfollowed;
 726
 727         return(( rc == 0 ) ? count : rc );
 728 }
 729
 730
 731 int
 732 ldap_append_referral( LDAP *ld, char **referralsp, char *s )
 733 {
 734         int     first;
 735
 736         if ( *referralsp == NULL ) {
 737                 first = 1;
 738                 *referralsp = (char *)malloc( strlen( s ) + LDAP_REF_STR_LEN
 739                     + 1 );
 740         } else {
 741                 first = 0;
 742                 *referralsp = (char *)realloc( *referralsp,
 743                     strlen( *referralsp ) + strlen( s ) + 2 );
 744         }
 745
 746         if ( *referralsp == NULL ) {
 747                 ld->ld_errno = LDAP_NO_MEMORY;
 748                 return( -1 );
 749         }
 750
 751         if ( first ) {
 752                 strcpy( *referralsp, LDAP_REF_STR );
 753         } else {
 754                 strcat( *referralsp, "\n" );
 755         }
 756         strcat( *referralsp, s );
 757
 758         return( 0 );
 759 }
 760
 761
 762
 763 static BerElement *
 764 re_encode_request( LDAP *ld, BerElement *origber, int msgid, char **dnp )
 765 {
 766 /*
 767  * XXX this routine knows way too much about how the lber library works!
 768  */
 769         unsigned long   along, tag;
 770         long            ver;
 771         int             rc;
 772         BerElement      tmpber, *ber;
 773         char            *orig_dn;
 774
 775         Debug( LDAP_DEBUG_TRACE,
 776             "re_encode_request: new msgid %d, new dn <%s>\n",
 777             msgid, ( *dnp == NULL ) ? "NONE" : *dnp, 0 );
 778
 779         tmpber = *origber;
 780
 781         /*
 782          * all LDAP requests are sequences that start with a message id,
 783          * followed by a sequence that is tagged with the operation code
 784          */
 785         if ( ber_scanf( &tmpber, "{i", &along ) != LDAP_TAG_MSGID ||
 786             ( tag = ber_skip_tag( &tmpber, &along )) == LBER_DEFAULT ) {
 787                 ld->ld_errno = LDAP_DECODING_ERROR;
 788                 return( NULL );
 789         }
 790
 791         if (( ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) {
 792                 return( NULL );
 793         }
 794
 795         /* bind requests have a version number before the DN & other stuff */
 796         if ( tag == LDAP_REQ_BIND && ber_get_int( &tmpber, (long *)&ver ) ==
 797             LBER_DEFAULT ) {
 798                 ld->ld_errno = LDAP_DECODING_ERROR;
 799                 ber_free( ber, 1 );
 800                 return( NULL );
 801         }
 802
 803         /* the rest of the request is the DN followed by other stuff */
 804         if ( ber_get_stringa( &tmpber, &orig_dn ) == LBER_DEFAULT ) {
 805                 ber_free( ber, 1 );
 806                 return( NULL );
 807         }
 808
 809         if ( *dnp == NULL ) {
 810                 *dnp = orig_dn;
 811         } else {
 812                 free( orig_dn );
 813         }
 814
 815         if ( tag == LDAP_REQ_BIND ) {
 816                 rc = ber_printf( ber, "{it{is", msgid, tag, ver, *dnp );
 817         } else {
 818                 rc = ber_printf( ber, "{it{s", msgid, tag, *dnp );
 819         }
 820
 821         if ( rc == -1 ) {
 822                 ber_free( ber, 1 );
 823                 return( NULL );
 824         }
 825
 826         if ( ber_write( ber, tmpber.ber_ptr, ( tmpber.ber_end -
 827             tmpber.ber_ptr ), 0 ) != ( tmpber.ber_end - tmpber.ber_ptr ) ||
 828             ber_printf( ber, "}}" ) == -1 ) {
 829                 ld->ld_errno = LDAP_ENCODING_ERROR;
 830                 ber_free( ber, 1 );
 831                 return( NULL );
 832         }
 833
 834 #ifdef LDAP_DEBUG
 835         if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
 836                 Debug( LDAP_DEBUG_ANY, "re_encode_request new request is:\n",
 837                     0, 0, 0 );
 838                 ber_dump( ber, 0 );
 839         }
 840 #endif /* LDAP_DEBUG */
 841
 842         return( ber );
 843 }
 844
 845
 846 LDAPRequest *
 847 ldap_find_request_by_msgid( LDAP *ld, int msgid )
 848 {
 849         LDAPRequest     *lr;
 850
 851         for ( lr = ld->ld_requests; lr != NULL; lr = lr->lr_next ) {
 852                 if ( msgid == lr->lr_msgid ) {
 853                         break;
 854                 }
 855         }
 856
 857         return( lr );
 858 }
 859 #endif /* LDAP_REFERRALS */
 860
 861
 862 #ifdef LDAP_DNS
 863 static LDAPServer *
 864 dn2servers( LDAP *ld, char *dn )        /* dn can also be a domain.... */
 865 {
 866         char            *p, *domain, *host, *server_dn, **dxs;
 867         int             i, port;
 868         LDAPServer      *srvlist, *prevsrv, *srv;
 869
 870         if (( domain = strrchr( dn, '@' )) != NULL ) {
 871                 ++domain;
 872         } else {
 873                 domain = dn;
 874         }
 875
 876         if (( dxs = ldap_getdxbyname( domain )) == NULL ) {
 877                 ld->ld_errno = LDAP_NO_MEMORY;
 878                 return( NULL );
 879         }
 880
 881         srvlist = NULL;
 882
 883         for ( i = 0; dxs[ i ] != NULL; ++i ) {
 884                 port = openldap_ldap_global_options.ldo_defport;
 885                 server_dn = NULL;
 886                 if ( strchr( dxs[ i ], ':' ) == NULL ) {
 887                         host = dxs[ i ];
 888                 } else if ( strlen( dxs[ i ] ) >= 7 &&
 889                     strncmp( dxs[ i ], "ldap://", 7 ) == 0 ) {
 890                         host = dxs[ i ] + 7;
 891                         if (( p = strchr( host, ':' )) == NULL ) {
 892                                 p = host;
 893                         } else {
 894                                 *p++ = '\0';
 895                                 port = atoi( p );
 896                         }
 897                         if (( p = strchr( p, '/' )) != NULL ) {
 898                                 server_dn = ++p;
 899                                 if ( *server_dn == '\0' ) {
 900                                         server_dn = NULL;
 901                                 }
 902                         }
 903                 } else {
 904                         host = NULL;
 905                 }
 906
 907                 if ( host != NULL ) {   /* found a server we can use */
 908                         if (( srv = (LDAPServer *)calloc( 1,
 909                             sizeof( LDAPServer ))) == NULL ) {
 910                                 free_servers( srvlist );
 911                                 srvlist = NULL;
 912                                 break;          /* exit loop & return */
 913                         }
 914
 915                         /* add to end of list of servers */
 916                         if ( srvlist == NULL ) {
 917                                 srvlist = srv;
 918                         } else {
 919                                 prevsrv->lsrv_next = srv;
 920                         }
 921                         prevsrv = srv;
 922
 923                         /* copy in info. */
 924                         if (( srv->lsrv_host = ldap_strdup( host )) == NULL ||
 925                             ( server_dn != NULL && ( srv->lsrv_dn =
 926                             ldap_strdup( server_dn )) == NULL )) {
 927                                 free_servers( srvlist );
 928                                 srvlist = NULL;
 929                                 break;          /* exit loop & return */
 930                         }
 931                         srv->lsrv_port = port;
 932                 }
 933         }
 934
 935         ldap_value_free( dxs );
 936
 937         if ( srvlist == NULL ) {
 938                 ld->ld_errno = LDAP_SERVER_DOWN;
 939         }
 940
 941         return( srvlist );
 942 }
 943 #endif /* LDAP_DNS */