git.sur5r.net Git - openldap/blob - libraries/libldap/url.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) 1996 Regents of the University of Michigan.
   8  *  All rights reserved.
   9  *
  10  *  LIBLDAP url.c -- LDAP URL (RFC 2255) related routines
  11  *
  12  *  LDAP URLs look like this:
  13  *    ldap[is]://host:port[/[dn[?[attributes][?[scope][?[filter][?exts]]]]]]
  14  *
  15  *  where:
  16  *   attributes is a comma separated list
  17  *   scope is one of these three strings:  base one sub (default=base)
  18  *   filter is an string-represented filter as in RFC 2254
  19  *
  20  *  e.g.,  ldap://host:port/dc=com?o,cn?base?o=openldap?extension
  21  *
  22  *  We also tolerate URLs that look like: <ldapurl> and <URL:ldapurl>
  23  */
  24
  25 #include "portable.h"
  26
  27 #include <stdio.h>
  28
  29 #include <ac/stdlib.h>
  30
  31 #include <ac/ctype.h>
  32 #include <ac/socket.h>
  33 #include <ac/string.h>
  34 #include <ac/time.h>
  35
  36 #include "ldap-int.h"
  37
  38
  39 /* local functions */
  40 static const char* skip_url_prefix LDAP_P((
  41         const char *url,
  42         int *enclosedp,
  43         const char **scheme ));
  44
  45 int ldap_pvt_url_scheme2proto( const char *scheme )
  46 {
  47         assert( scheme );
  48
  49         if( scheme == NULL ) {
  50                 return -1;
  51         }
  52
  53         if( strcmp("ldap", scheme) == 0 ) {
  54                 return LDAP_PROTO_TCP;
  55         }
  56
  57         if( strcmp("ldapi", scheme) == 0 ) {
  58                 return LDAP_PROTO_IPC;
  59         }
  60
  61         if( strcmp("ldaps", scheme) == 0 ) {
  62                 return LDAP_PROTO_TCP;
  63         }
  64
  65         return -1;
  66 }
  67
  68 int ldap_pvt_url_scheme2tls( const char *scheme )
  69 {
  70         assert( scheme );
  71
  72         if( scheme == NULL ) {
  73                 return -1;
  74         }
  75
  76         return strcmp("ldaps", scheme) == 0;
  77 }
  78
  79 int
  80 ldap_is_ldap_url( LDAP_CONST char *url )
  81 {
  82         int     enclosed;
  83         const char * scheme;
  84
  85         if( url == NULL ) {
  86                 return 0;
  87         }
  88
  89         if( skip_url_prefix( url, &enclosed, &scheme ) == NULL ) {
  90                 return 0;
  91         }
  92
  93         return 1;
  94 }
  95
  96 int
  97 ldap_is_ldaps_url( LDAP_CONST char *url )
  98 {
  99         int     enclosed;
 100         const char * scheme;
 101
 102         if( url == NULL ) {
 103                 return 0;
 104         }
 105
 106         if( skip_url_prefix( url, &enclosed, &scheme ) == NULL ) {
 107                 return 0;
 108         }
 109
 110         return strcmp(scheme, "ldaps") == 0;
 111 }
 112
 113 int
 114 ldap_is_ldapi_url( LDAP_CONST char *url )
 115 {
 116         int     enclosed;
 117         const char * scheme;
 118
 119         if( url == NULL ) {
 120                 return 0;
 121         }
 122
 123         if( skip_url_prefix( url, &enclosed, &scheme ) == NULL ) {
 124                 return 0;
 125         }
 126
 127         return strcmp(scheme, "ldapi") == 0;
 128 }
 129
 130 static const char*
 131 skip_url_prefix(
 132         const char *url,
 133         int *enclosedp,
 134         const char **scheme )
 135 {
 136 /*
 137  * return non-zero if this looks like a LDAP URL; zero if not
 138  * if non-zero returned, *urlp will be moved past "ldap://" part of URL
 139  */
 140         const char *p;
 141
 142         if ( url == NULL ) {
 143                 return( NULL );
 144         }
 145
 146         p = url;
 147
 148         /* skip leading '<' (if any) */
 149         if ( *p == '<' ) {
 150                 *enclosedp = 1;
 151                 ++p;
 152         } else {
 153                 *enclosedp = 0;
 154         }
 155
 156         /* skip leading "URL:" (if any) */
 157         if ( strncasecmp( p, LDAP_URL_URLCOLON, LDAP_URL_URLCOLON_LEN ) == 0 )
 158         {
 159                 p += LDAP_URL_URLCOLON_LEN;
 160         }
 161
 162         /* check for "ldap://" prefix */
 163         if ( strncasecmp( p, LDAP_URL_PREFIX, LDAP_URL_PREFIX_LEN ) == 0 ) {
 164                 /* skip over "ldap://" prefix and return success */
 165                 p += LDAP_URL_PREFIX_LEN;
 166                 *scheme = "ldap";
 167                 return( p );
 168         }
 169
 170         /* check for "ldaps://" prefix */
 171         if ( strncasecmp( p, LDAPS_URL_PREFIX, LDAPS_URL_PREFIX_LEN ) == 0 ) {
 172                 /* skip over "ldaps://" prefix and return success */
 173                 p += LDAPS_URL_PREFIX_LEN;
 174                 *scheme = "ldaps";
 175                 return( p );
 176         }
 177
 178         /* check for "ldapi://" prefix */
 179         if ( strncasecmp( p, LDAPI_URL_PREFIX, LDAPI_URL_PREFIX_LEN ) == 0 ) {
 180                 /* skip over "ldapi://" prefix and return success */
 181                 p += LDAPI_URL_PREFIX_LEN;
 182                 *scheme = "ldapi";
 183                 return( p );
 184         }
 185
 186         return( NULL );
 187 }
 188
 189
 190 static int str2scope( const char *p )
 191 {
 192         if ( strcasecmp( p, "one" ) == 0 ) {
 193                 return LDAP_SCOPE_ONELEVEL;
 194
 195         } else if ( strcasecmp( p, "onetree" ) == 0 ) {
 196                 return LDAP_SCOPE_ONELEVEL;
 197
 198         } else if ( strcasecmp( p, "base" ) == 0 ) {
 199                 return LDAP_SCOPE_BASE;
 200
 201         } else if ( strcasecmp( p, "sub" ) == 0 ) {
 202                 return LDAP_SCOPE_SUBTREE;
 203
 204         } else if ( strcasecmp( p, "subtree" ) == 0 ) {
 205                 return LDAP_SCOPE_SUBTREE;
 206         }
 207
 208         return( -1 );
 209 }
 210
 211
 212 int
 213 ldap_url_parse( LDAP_CONST char *url_in, LDAPURLDesc **ludpp )
 214 {
 215 /*
 216  *  Pick apart the pieces of an LDAP URL.
 217  */
 218
 219         LDAPURLDesc     *ludp;
 220         char    *p, *q;
 221         int             i, enclosed;
 222         const char *scheme = NULL;
 223         const char *url_tmp;
 224         char *url;
 225
 226         if( url_in == NULL && ludpp == NULL ) {
 227                 return LDAP_URL_ERR_PARAM;
 228         }
 229
 230 #ifndef LDAP_INT_IN_KERNEL
 231         /* Global options may not be created yet
 232          * We can't test if the global options are initialized
 233          * because a call to LDAP_INT_GLOBAL_OPT() will try to allocate
 234          * the options and cause infinite recursion
 235          */
 236         Debug( LDAP_DEBUG_TRACE, "ldap_url_parse(%s)\n", url_in, 0, 0 );
 237 #endif
 238
 239         *ludpp = NULL;  /* pessimistic */
 240
 241         url_tmp = skip_url_prefix( url_in, &enclosed, &scheme );
 242
 243         if ( url_tmp == NULL ) {
 244                 return LDAP_URL_ERR_BADSCHEME;
 245         }
 246
 247         assert( scheme );
 248
 249         /* make working copy of the remainder of the URL */
 250         url = LDAP_STRDUP( url_tmp );
 251         if ( url == NULL ) {
 252                 return LDAP_URL_ERR_MEM;
 253         }
 254
 255         if ( enclosed ) {
 256                 p = &url[strlen(url)-1];
 257
 258                 if( *p != '>' ) {
 259                         LDAP_FREE( url );
 260                         return LDAP_URL_ERR_BADENCLOSURE;
 261                 }
 262
 263                 *p = '\0';
 264         }
 265
 266         /* allocate return struct */
 267         ludp = (LDAPURLDesc *)LDAP_CALLOC( 1, sizeof( LDAPURLDesc ));
 268
 269         if ( ludp == NULL ) {
 270                 LDAP_FREE( url );
 271                 return LDAP_URL_ERR_MEM;
 272         }
 273
 274         ludp->lud_next = NULL;
 275         ludp->lud_host = NULL;
 276         ludp->lud_port = 0;
 277         ludp->lud_dn = NULL;
 278         ludp->lud_attrs = NULL;
 279         ludp->lud_filter = NULL;
 280         ludp->lud_scope = LDAP_SCOPE_BASE;
 281         ludp->lud_filter = NULL;
 282
 283         ludp->lud_scheme = LDAP_STRDUP( scheme );
 284
 285         if ( ludp->lud_scheme == NULL ) {
 286                 LDAP_FREE( url );
 287                 ldap_free_urldesc( ludp );
 288                 return LDAP_URL_ERR_MEM;
 289         }
 290
 291         /* scan forward for '/' that marks end of hostport and begin. of dn */
 292         p = strchr( url, '/' );
 293
 294         if( p != NULL ) {
 295                 /* terminate hostport; point to start of dn */
 296                 *p++ = '\0';
 297         }
 298
 299         q = strchr( url, ':' );
 300
 301         if ( q != NULL ) {
 302                 *q++ = '\0';
 303                 ldap_pvt_hex_unescape( q );
 304
 305                 if( *q == '\0' ) {
 306                         LDAP_FREE( url );
 307                         ldap_free_urldesc( ludp );
 308                         return LDAP_URL_ERR_BADURL;
 309                 }
 310
 311                 ludp->lud_port = atoi( q );
 312         }
 313
 314         ldap_pvt_hex_unescape( url );
 315         ludp->lud_host = LDAP_STRDUP( url );
 316
 317         if( ludp->lud_host == NULL ) {
 318                 LDAP_FREE( url );
 319                 ldap_free_urldesc( ludp );
 320                 return LDAP_URL_ERR_MEM;
 321         }
 322
 323         /*
 324          * Kludge.  ldap://111.222.333.444:389??cn=abc,o=company
 325          *
 326          * On early Novell releases, search references/referrals were returned
 327          * in this format, i.e., the dn was kind of in the scope position,
 328          * but the required slash is missing. The whole thing is illegal syntax,
 329          * but we need to account for it. Fortunately it can't be confused with
 330          * anything real.
 331          */
 332         if( (p == NULL) && (q != NULL) && ((q = strchr( q, '?')) != NULL)) {
 333                 q++;
 334                 /* ? immediately followed by question */
 335                 if( *q == '?') {
 336                         q++;
 337                         if( *q != '\0' ) {
 338                                 /* parse dn part */
 339                                 ldap_pvt_hex_unescape( q );
 340                                 ludp->lud_dn = LDAP_STRDUP( q );
 341                         } else {
 342                                 ludp->lud_dn = LDAP_STRDUP( "" );
 343                         }
 344
 345                         if( ludp->lud_dn == NULL ) {
 346                                 LDAP_FREE( url );
 347                                 ldap_free_urldesc( ludp );
 348                                 return LDAP_URL_ERR_MEM;
 349                         }
 350                 }
 351         }
 352
 353         if( p == NULL ) {
 354                 LDAP_FREE( url );
 355                 *ludpp = ludp;
 356                 return LDAP_URL_SUCCESS;
 357         }
 358
 359         /* scan forward for '?' that may marks end of dn */
 360         q = strchr( p, '?' );
 361
 362         if( q != NULL ) {
 363                 /* terminate dn part */
 364                 *q++ = '\0';
 365         }
 366
 367         if( *p != '\0' ) {
 368                 /* parse dn part */
 369                 ldap_pvt_hex_unescape( p );
 370                 ludp->lud_dn = LDAP_STRDUP( p );
 371         } else {
 372                 ludp->lud_dn = LDAP_STRDUP( "" );
 373         }
 374
 375         if( ludp->lud_dn == NULL ) {
 376                 LDAP_FREE( url );
 377                 ldap_free_urldesc( ludp );
 378                 return LDAP_URL_ERR_MEM;
 379         }
 380
 381         if( q == NULL ) {
 382                 /* no more */
 383                 LDAP_FREE( url );
 384                 *ludpp = ludp;
 385                 return LDAP_URL_SUCCESS;
 386         }
 387
 388         /* scan forward for '?' that may marks end of attributes */
 389         p = q;
 390         q = strchr( p, '?' );
 391
 392         if( q != NULL ) {
 393                 /* terminate attributes part */
 394                 *q++ = '\0';
 395         }
 396
 397         if( *p != '\0' ) {
 398                 /* parse attributes */
 399                 ldap_pvt_hex_unescape( p );
 400                 ludp->lud_attrs = ldap_str2charray( p, "," );
 401
 402                 if( ludp->lud_attrs == NULL ) {
 403                         LDAP_FREE( url );
 404                         ldap_free_urldesc( ludp );
 405                         return LDAP_URL_ERR_BADATTRS;
 406                 }
 407         }
 408
 409         if ( q == NULL ) {
 410                 /* no more */
 411                 LDAP_FREE( url );
 412                 *ludpp = ludp;
 413                 return LDAP_URL_SUCCESS;
 414         }
 415
 416         /* scan forward for '?' that may marks end of scope */
 417         p = q;
 418         q = strchr( p, '?' );
 419
 420         if( q != NULL ) {
 421                 /* terminate the scope part */
 422                 *q++ = '\0';
 423         }
 424
 425         if( *p != '\0' ) {
 426                 /* parse the scope */
 427                 ldap_pvt_hex_unescape( p );
 428                 ludp->lud_scope = str2scope( p );
 429
 430                 if( ludp->lud_scope == -1 ) {
 431                         LDAP_FREE( url );
 432                         ldap_free_urldesc( ludp );
 433                         return LDAP_URL_ERR_BADSCOPE;
 434                 }
 435         }
 436
 437         if ( q == NULL ) {
 438                 /* no more */
 439                 LDAP_FREE( url );
 440                 *ludpp = ludp;
 441                 return LDAP_URL_SUCCESS;
 442         }
 443
 444         /* scan forward for '?' that may marks end of filter */
 445         p = q;
 446         q = strchr( p, '?' );
 447
 448         if( q != NULL ) {
 449                 /* terminate the filter part */
 450                 *q++ = '\0';
 451         }
 452
 453         if( *p != '\0' ) {
 454                 /* parse the filter */
 455                 ldap_pvt_hex_unescape( p );
 456
 457                 if( ! *p ) {
 458                         /* missing filter */
 459                         LDAP_FREE( url );
 460                         ldap_free_urldesc( ludp );
 461                         return LDAP_URL_ERR_BADFILTER;
 462                 }
 463
 464                 LDAP_FREE( ludp->lud_filter );
 465                 ludp->lud_filter = LDAP_STRDUP( p );
 466
 467                 if( ludp->lud_filter == NULL ) {
 468                         LDAP_FREE( url );
 469                         ldap_free_urldesc( ludp );
 470                         return LDAP_URL_ERR_MEM;
 471                 }
 472         }
 473
 474         if ( q == NULL ) {
 475                 /* no more */
 476                 LDAP_FREE( url );
 477                 *ludpp = ludp;
 478                 return LDAP_URL_SUCCESS;
 479         }
 480
 481         /* scan forward for '?' that may marks end of extensions */
 482         p = q;
 483         q = strchr( p, '?' );
 484
 485         if( q != NULL ) {
 486                 /* extra '?' */
 487                 LDAP_FREE( url );
 488                 ldap_free_urldesc( ludp );
 489                 return LDAP_URL_ERR_BADURL;
 490         }
 491
 492         /* parse the extensions */
 493         ludp->lud_exts = ldap_str2charray( p, "," );
 494
 495         if( ludp->lud_exts == NULL ) {
 496                 LDAP_FREE( url );
 497                 ldap_free_urldesc( ludp );
 498                 return LDAP_URL_ERR_BADEXTS;
 499         }
 500
 501         for( i=0; ludp->lud_exts[i] != NULL; i++ ) {
 502                 ldap_pvt_hex_unescape( ludp->lud_exts[i] );
 503         }
 504
 505         if( i == 0 ) {
 506                 /* must have 1 or more */
 507                 ldap_charray_free( ludp->lud_exts );
 508                 LDAP_FREE( url );
 509                 ldap_free_urldesc( ludp );
 510                 return LDAP_URL_ERR_BADEXTS;
 511         }
 512
 513         /* no more */
 514         *ludpp = ludp;
 515         LDAP_FREE( url );
 516         return LDAP_URL_SUCCESS;
 517 }
 518
 519 LDAPURLDesc *
 520 ldap_url_dup ( LDAPURLDesc *ludp )
 521 {
 522         LDAPURLDesc *dest;
 523
 524         if ( ludp == NULL ) {
 525                 return NULL;
 526         }
 527
 528         dest = LDAP_MALLOC( sizeof(LDAPURLDesc) );
 529         if (dest == NULL)
 530                 return NULL;
 531
 532         *dest = *ludp;
 533         dest->lud_scheme = NULL;
 534         dest->lud_host = NULL;
 535         dest->lud_dn = NULL;
 536         dest->lud_filter = NULL;
 537         dest->lud_attrs = NULL;
 538         dest->lud_exts = NULL;
 539         dest->lud_next = NULL;
 540
 541         if ( ludp->lud_scheme != NULL ) {
 542                 dest->lud_scheme = LDAP_STRDUP( ludp->lud_scheme );
 543                 if (dest->lud_scheme == NULL) {
 544                         ldap_free_urldesc(dest);
 545                         return NULL;
 546                 }
 547         }
 548
 549         if ( ludp->lud_host != NULL ) {
 550                 dest->lud_host = LDAP_STRDUP( ludp->lud_host );
 551                 if (dest->lud_host == NULL) {
 552                         ldap_free_urldesc(dest);
 553                         return NULL;
 554                 }
 555         }
 556
 557         if ( ludp->lud_dn != NULL ) {
 558                 dest->lud_dn = LDAP_STRDUP( ludp->lud_dn );
 559                 if (dest->lud_dn == NULL) {
 560                         ldap_free_urldesc(dest);
 561                         return NULL;
 562                 }
 563         }
 564
 565         if ( ludp->lud_filter != NULL ) {
 566                 dest->lud_filter = LDAP_STRDUP( ludp->lud_filter );
 567                 if (dest->lud_filter == NULL) {
 568                         ldap_free_urldesc(dest);
 569                         return NULL;
 570                 }
 571         }
 572
 573         if ( ludp->lud_attrs != NULL ) {
 574                 dest->lud_attrs = ldap_charray_dup( ludp->lud_attrs );
 575                 if (dest->lud_attrs == NULL) {
 576                         ldap_free_urldesc(dest);
 577                         return NULL;
 578                 }
 579         }
 580
 581         if ( ludp->lud_exts != NULL ) {
 582                 dest->lud_exts = ldap_charray_dup( ludp->lud_exts );
 583                 if (dest->lud_exts == NULL) {
 584                         ldap_free_urldesc(dest);
 585                         return NULL;
 586                 }
 587         }
 588
 589         return dest;
 590 }
 591
 592 LDAPURLDesc *
 593 ldap_url_duplist (LDAPURLDesc *ludlist)
 594 {
 595         LDAPURLDesc *dest, *tail, *ludp, *newludp;
 596
 597         dest = NULL;
 598         tail = NULL;
 599         for (ludp = ludlist; ludp != NULL; ludp = ludp->lud_next) {
 600                 newludp = ldap_url_dup(ludp);
 601                 if (newludp == NULL) {
 602                         ldap_free_urllist(dest);
 603                         return NULL;
 604                 }
 605                 if (tail == NULL)
 606                         dest = newludp;
 607                 else
 608                         tail->lud_next = newludp;
 609                 tail = newludp;
 610         }
 611         return dest;
 612 }
 613
 614 int
 615 ldap_url_parselist (LDAPURLDesc **ludlist, const char *url )
 616 {
 617         int i, rc;
 618         LDAPURLDesc *ludp;
 619         char **urls;
 620
 621         *ludlist = NULL;
 622
 623         if (url == NULL)
 624                 return LDAP_PARAM_ERROR;
 625
 626         urls = ldap_str2charray((char *)url, ", ");
 627         if (urls == NULL)
 628                 return LDAP_NO_MEMORY;
 629
 630         /* count the URLs... */
 631         for (i = 0; urls[i] != NULL; i++) ;
 632         /* ...and put them in the "stack" backward */
 633         while (--i >= 0) {
 634                 rc = ldap_url_parse( urls[i], &ludp );
 635                 if ( rc != 0 ) {
 636                         ldap_charray_free(urls);
 637                         ldap_free_urllist(*ludlist);
 638                         *ludlist = NULL;
 639                         return rc;
 640                 }
 641                 ludp->lud_next = *ludlist;
 642                 *ludlist = ludp;
 643         }
 644         ldap_charray_free(urls);
 645         return LDAP_SUCCESS;
 646 }
 647
 648 int
 649 ldap_url_parsehosts (LDAPURLDesc **ludlist, const char *hosts )
 650 {
 651         int i;
 652         LDAPURLDesc *ludp;
 653         char **specs, *p;
 654
 655         *ludlist = NULL;
 656
 657         if (hosts == NULL)
 658                 return LDAP_PARAM_ERROR;
 659
 660         specs = ldap_str2charray((char *)hosts, ", ");
 661         if (specs == NULL)
 662                 return LDAP_NO_MEMORY;
 663
 664         /* count the URLs... */
 665         for (i = 0; specs[i] != NULL; i++) /* EMPTY */;
 666
 667         /* ...and put them in the "stack" backward */
 668         while (--i >= 0) {
 669                 ludp = LDAP_CALLOC( 1, sizeof(LDAPURLDesc) );
 670                 if (ludp == NULL) {
 671                         ldap_charray_free(specs);
 672                         ldap_free_urllist(*ludlist);
 673                         *ludlist = NULL;
 674                         return LDAP_NO_MEMORY;
 675                 }
 676                 ludp->lud_host = specs[i];
 677                 specs[i] = NULL;
 678                 p = strchr(ludp->lud_host, ':');
 679                 if (p != NULL) {
 680                         *p++ = 0;
 681                         ldap_pvt_hex_unescape(p);
 682                         ludp->lud_port = atoi(p);
 683                 }
 684                 ldap_pvt_hex_unescape(ludp->lud_host);
 685                 ludp->lud_scheme = LDAP_STRDUP("ldap");
 686                 ludp->lud_next = *ludlist;
 687                 *ludlist = ludp;
 688         }
 689
 690         /* this should be an array of NULLs now */
 691         ldap_charray_free(specs);
 692         return LDAP_SUCCESS;
 693 }
 694
 695 char *
 696 ldap_url_list2hosts (LDAPURLDesc *ludlist)
 697 {
 698         LDAPURLDesc *ludp;
 699         int size;
 700         char *s, *p, buf[32];   /* big enough to hold a long decimal # (overkill) */
 701
 702         if (ludlist == NULL)
 703                 return NULL;
 704
 705         /* figure out how big the string is */
 706         size = 1;       /* nul-term */
 707         for (ludp = ludlist; ludp != NULL; ludp = ludp->lud_next) {
 708                 size += strlen(ludp->lud_host) + 1;             /* host and space */
 709                 if (ludp->lud_port != 0)
 710                         size += sprintf(buf, ":%d", ludp->lud_port);
 711         }
 712         s = LDAP_MALLOC(size);
 713         if (s == NULL)
 714                 return NULL;
 715
 716         p = s;
 717         for (ludp = ludlist; ludp != NULL; ludp = ludp->lud_next) {
 718                 strcpy(p, ludp->lud_host);
 719                 p += strlen(ludp->lud_host);
 720                 if (ludp->lud_port != 0)
 721                         p += sprintf(p, ":%d", ludp->lud_port);
 722                 *p++ = ' ';
 723         }
 724         if (p != s)
 725                 p--;    /* nuke that extra space */
 726         *p = 0;
 727         return s;
 728 }
 729
 730 char *
 731 ldap_url_list2urls(
 732         LDAPURLDesc *ludlist )
 733 {
 734         LDAPURLDesc *ludp;
 735         int size;
 736         char *s, *p, buf[32];   /* big enough to hold a long decimal # (overkill) */
 737
 738         if (ludlist == NULL)
 739                 return NULL;
 740
 741         /* figure out how big the string is */
 742         size = 1;       /* nul-term */
 743         for (ludp = ludlist; ludp != NULL; ludp = ludp->lud_next) {
 744                 size += strlen(ludp->lud_scheme) + strlen(ludp->lud_host);
 745                 size += sizeof(":/// ");
 746
 747                 if (ludp->lud_port != 0) {
 748                         size += sprintf(buf, ":%d", ludp->lud_port);
 749                 }
 750         }
 751
 752         s = LDAP_MALLOC(size);
 753         if (s == NULL) {
 754                 return NULL;
 755         }
 756
 757         p = s;
 758         for (ludp = ludlist; ludp != NULL; ludp = ludp->lud_next) {
 759                 p += sprintf(p, "%s://%s", ludp->lud_scheme, ludp->lud_host);
 760                 if (ludp->lud_port != 0)
 761                         p += sprintf(p, ":%d", ludp->lud_port);
 762                 *p++ = '/';
 763                 *p++ = ' ';
 764         }
 765         if (p != s)
 766                 p--;    /* nuke that extra space */
 767         *p = 0;
 768         return s;
 769 }
 770
 771 void
 772 ldap_free_urllist( LDAPURLDesc *ludlist )
 773 {
 774         LDAPURLDesc *ludp, *next;
 775
 776         for (ludp = ludlist; ludp != NULL; ludp = next) {
 777                 next = ludp->lud_next;
 778                 ldap_free_urldesc(ludp);
 779         }
 780 }
 781
 782 void
 783 ldap_free_urldesc( LDAPURLDesc *ludp )
 784 {
 785         if ( ludp == NULL ) {
 786                 return;
 787         }
 788
 789         if ( ludp->lud_scheme != NULL ) {
 790                 LDAP_FREE( ludp->lud_scheme );
 791         }
 792
 793         if ( ludp->lud_host != NULL ) {
 794                 LDAP_FREE( ludp->lud_host );
 795         }
 796
 797         if ( ludp->lud_dn != NULL ) {
 798                 LDAP_FREE( ludp->lud_dn );
 799         }
 800
 801         if ( ludp->lud_filter != NULL ) {
 802                 LDAP_FREE( ludp->lud_filter);
 803         }
 804
 805         if ( ludp->lud_attrs != NULL ) {
 806                 LDAP_VFREE( ludp->lud_attrs );
 807         }
 808
 809         if ( ludp->lud_exts != NULL ) {
 810                 LDAP_VFREE( ludp->lud_exts );
 811         }
 812
 813         LDAP_FREE( ludp );
 814 }
 815
 816
 817
 818 int
 819 ldap_url_search( LDAP *ld, LDAP_CONST char *url, int attrsonly )
 820 {
 821         int             err;
 822         LDAPURLDesc     *ludp;
 823         BerElement      *ber;
 824         LDAPreqinfo  bind;
 825
 826         if ( ldap_url_parse( url, &ludp ) != 0 ) {
 827                 ld->ld_errno = LDAP_PARAM_ERROR;
 828                 return( -1 );
 829         }
 830
 831         ber = ldap_build_search_req( ld, ludp->lud_dn, ludp->lud_scope,
 832             ludp->lud_filter, ludp->lud_attrs, attrsonly, NULL, NULL,
 833                 -1, -1 );
 834
 835         if ( ber == NULL ) {
 836                 err = -1;
 837         } else {
 838                 bind.ri_request = LDAP_REQ_SEARCH;
 839                 bind.ri_msgid = ld->ld_msgid;
 840                 bind.ri_url = (char *)url;
 841                 err = ldap_send_server_request(
 842                                         ld, ber, ld->ld_msgid, NULL,
 843                                         (ludp->lud_host != NULL || ludp->lud_port != 0)
 844                                                 ? ludp : NULL,
 845                                         NULL, &bind );
 846         }
 847
 848         ldap_free_urldesc( ludp );
 849         return( err );
 850 }
 851
 852
 853 int
 854 ldap_url_search_st( LDAP *ld, LDAP_CONST char *url, int attrsonly,
 855         struct timeval *timeout, LDAPMessage **res )
 856 {
 857         int     msgid;
 858
 859         if (( msgid = ldap_url_search( ld, url, attrsonly )) == -1 ) {
 860                 return( ld->ld_errno );
 861         }
 862
 863         if ( ldap_result( ld, msgid, 1, timeout, res ) == -1 ) {
 864                 return( ld->ld_errno );
 865         }
 866
 867         if ( ld->ld_errno == LDAP_TIMEOUT ) {
 868                 (void) ldap_abandon( ld, msgid );
 869                 ld->ld_errno = LDAP_TIMEOUT;
 870                 return( ld->ld_errno );
 871         }
 872
 873         return( ldap_result2error( ld, *res, 0 ));
 874 }
 875
 876
 877 int
 878 ldap_url_search_s(
 879         LDAP *ld, LDAP_CONST char *url, int attrsonly, LDAPMessage **res )
 880 {
 881         int     msgid;
 882
 883         if (( msgid = ldap_url_search( ld, url, attrsonly )) == -1 ) {
 884                 return( ld->ld_errno );
 885         }
 886
 887         if ( ldap_result( ld, msgid, 1, (struct timeval *)NULL, res ) == -1 ) {
 888                 return( ld->ld_errno );
 889         }
 890
 891         return( ldap_result2error( ld, *res, 0 ));
 892 }
 893
 894
 895 void
 896 ldap_pvt_hex_unescape( char *s )
 897 {
 898 /*
 899 * Remove URL hex escapes from s... done in place.  The basic concept for
 900 * this routine is borrowed from the WWW library HTUnEscape() routine.
 901 */
 902         char    *p;
 903
 904         for ( p = s; *s != '\0'; ++s ) {
 905                 if ( *s == '%' ) {
 906                         if ( *++s != '\0' ) {
 907                                 *p = ldap_pvt_unhex( *s ) << 4;
 908                         }
 909                         if ( *++s != '\0' ) {
 910                                 *p++ += ldap_pvt_unhex( *s );
 911                         }
 912                 } else {
 913                         *p++ = *s;
 914                 }
 915         }
 916
 917         *p = '\0';
 918 }
 919
 920
 921 int
 922 ldap_pvt_unhex( int c )
 923 {
 924         return( c >= '0' && c <= '9' ? c - '0'
 925             : c >= 'A' && c <= 'F' ? c - 'A' + 10
 926             : c - 'a' + 10 );
 927 }