libs/ldap/libldap/url.c

   1 /* LIBLDAP url.c -- LDAP URL (RFC 4516) related routines */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1998-2022 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16 /* Portions Copyright (c) 1996 Regents of the University of Michigan.
  17  * All rights reserved.
  18  */
  19
  20
  21 /*
  22  *  LDAP URLs look like this:
  23  *    [p]ldap[is]://host[:port][/[dn[?[attributes][?[scope][?[filter][?exts]]]]]]
  24  *
  25  *  where:
  26  *   attributes is a comma separated list
  27  *   scope is one of these three strings:  base one sub (default=base)
  28  *   filter is an string-represented filter as in RFC 4515
  29  *
  30  *  e.g.,  ldap://host:port/dc=com?o,cn?base?(o=openldap)?extension
  31  *
  32  *  We also tolerate URLs that look like: <ldapurl> and <URL:ldapurl>
  33  */
  34
  35 #include "portable.h"
  36
  37 #include <stdio.h>
  38
  39 #include <ac/stdlib.h>
  40 #include <ac/ctype.h>
  41
  42 #include <ac/socket.h>
  43 #include <ac/string.h>
  44 #include <ac/time.h>
  45
  46 #include "ldap-int.h"
  47
  48 /* local functions */
  49 static const char* skip_url_prefix LDAP_P((
  50         const char *url,
  51         int *enclosedp,
  52         const char **scheme ));
  53
  54 int ldap_pvt_url_scheme2proto( const char *scheme )
  55 {
  56         assert( scheme != NULL );
  57
  58         if( scheme == NULL ) {
  59                 return -1;
  60         }
  61
  62         if( strcmp("ldap", scheme) == 0 || strcmp("pldap", scheme) == 0 ) {
  63                 return LDAP_PROTO_TCP;
  64         }
  65
  66         if( strcmp("ldapi", scheme) == 0 ) {
  67                 return LDAP_PROTO_IPC;
  68         }
  69
  70         if( strcmp("ldaps", scheme) == 0 || strcmp("pldaps", scheme) == 0 ) {
  71                 return LDAP_PROTO_TCP;
  72         }
  73 #ifdef LDAP_CONNECTIONLESS
  74         if( strcmp("cldap", scheme) == 0 ) {
  75                 return LDAP_PROTO_UDP;
  76         }
  77 #endif
  78
  79         return -1;
  80 }
  81
  82 int ldap_pvt_url_scheme_port( const char *scheme, int port )
  83 {
  84         assert( scheme != NULL );
  85
  86         if( port ) return port;
  87         if( scheme == NULL ) return port;
  88
  89         if( strcmp("ldap", scheme) == 0 || strcmp("pldap", scheme) == 0 ) {
  90                 return LDAP_PORT;
  91         }
  92
  93         if( strcmp("ldapi", scheme) == 0 ) {
  94                 return -1;
  95         }
  96
  97         if( strcmp("ldaps", scheme) == 0 || strcmp("pldaps", scheme) == 0 ) {
  98                 return LDAPS_PORT;
  99         }
 100
 101 #ifdef LDAP_CONNECTIONLESS
 102         if( strcmp("cldap", scheme) == 0 ) {
 103                 return LDAP_PORT;
 104         }
 105 #endif
 106
 107         return -1;
 108 }
 109
 110 int
 111 ldap_pvt_url_scheme2tls( const char *scheme )
 112 {
 113         assert( scheme != NULL );
 114
 115         if( scheme == NULL ) {
 116                 return -1;
 117         }
 118
 119         return strcmp("ldaps", scheme) == 0 || strcmp("pldaps", scheme) == 0;
 120 }
 121
 122 int
 123 ldap_pvt_url_scheme2proxied( const char *scheme )
 124 {
 125         assert( scheme != NULL );
 126
 127         if( scheme == NULL ) {
 128                 return -1;
 129         }
 130
 131         return strcmp("pldap", scheme) == 0 || strcmp("pldaps", scheme) == 0;
 132 }
 133
 134 int
 135 ldap_is_ldap_url( LDAP_CONST char *url )
 136 {
 137         int     enclosed;
 138         const char * scheme;
 139
 140         if( url == NULL ) {
 141                 return 0;
 142         }
 143
 144         if( skip_url_prefix( url, &enclosed, &scheme ) == NULL ) {
 145                 return 0;
 146         }
 147
 148         return 1;
 149 }
 150
 151 int
 152 ldap_is_ldaps_url( LDAP_CONST char *url )
 153 {
 154         int     enclosed;
 155         const char * scheme;
 156
 157         if( url == NULL ) {
 158                 return 0;
 159         }
 160
 161         if( skip_url_prefix( url, &enclosed, &scheme ) == NULL ) {
 162                 return 0;
 163         }
 164
 165         return strcmp(scheme, "ldaps") == 0 || strcmp(scheme, "pldaps") == 0;
 166 }
 167
 168 int
 169 ldap_is_ldapi_url( LDAP_CONST char *url )
 170 {
 171         int     enclosed;
 172         const char * scheme;
 173
 174         if( url == NULL ) {
 175                 return 0;
 176         }
 177
 178         if( skip_url_prefix( url, &enclosed, &scheme ) == NULL ) {
 179                 return 0;
 180         }
 181
 182         return strcmp(scheme, "ldapi") == 0;
 183 }
 184
 185 #ifdef LDAP_CONNECTIONLESS
 186 int
 187 ldap_is_ldapc_url( LDAP_CONST char *url )
 188 {
 189         int     enclosed;
 190         const char * scheme;
 191
 192         if( url == NULL ) {
 193                 return 0;
 194         }
 195
 196         if( skip_url_prefix( url, &enclosed, &scheme ) == NULL ) {
 197                 return 0;
 198         }
 199
 200         return strcmp(scheme, "cldap") == 0;
 201 }
 202 #endif
 203
 204 static const char*
 205 skip_url_prefix(
 206         const char *url,
 207         int *enclosedp,
 208         const char **scheme )
 209 {
 210         /*
 211          * return non-zero if this looks like a LDAP URL; zero if not
 212          * if non-zero returned, *urlp will be moved past "ldap://" part of URL
 213          */
 214         const char *p;
 215
 216         if ( url == NULL ) {
 217                 return( NULL );
 218         }
 219
 220         p = url;
 221
 222         /* skip leading '<' (if any) */
 223         if ( *p == '<' ) {
 224                 *enclosedp = 1;
 225                 ++p;
 226         } else {
 227                 *enclosedp = 0;
 228         }
 229
 230         /* skip leading "URL:" (if any) */
 231         if ( strncasecmp( p, LDAP_URL_URLCOLON, LDAP_URL_URLCOLON_LEN ) == 0 ) {
 232                 p += LDAP_URL_URLCOLON_LEN;
 233         }
 234
 235         /* check for "ldap://" prefix */
 236         if ( strncasecmp( p, LDAP_URL_PREFIX, LDAP_URL_PREFIX_LEN ) == 0 ) {
 237                 /* skip over "ldap://" prefix and return success */
 238                 p += LDAP_URL_PREFIX_LEN;
 239                 *scheme = "ldap";
 240                 return( p );
 241         }
 242
 243         /* check for "pldap://" prefix */
 244         if ( strncasecmp( p, PLDAP_URL_PREFIX, PLDAP_URL_PREFIX_LEN ) == 0 ) {
 245                 /* skip over "pldap://" prefix and return success */
 246                 p += PLDAP_URL_PREFIX_LEN;
 247                 *scheme = "pldap";
 248                 return( p );
 249         }
 250
 251         /* check for "ldaps://" prefix */
 252         if ( strncasecmp( p, LDAPS_URL_PREFIX, LDAPS_URL_PREFIX_LEN ) == 0 ) {
 253                 /* skip over "ldaps://" prefix and return success */
 254                 p += LDAPS_URL_PREFIX_LEN;
 255                 *scheme = "ldaps";
 256                 return( p );
 257         }
 258
 259         /* check for "pldaps://" prefix */
 260         if ( strncasecmp( p, PLDAPS_URL_PREFIX, PLDAPS_URL_PREFIX_LEN ) == 0 ) {
 261                 /* skip over "pldaps://" prefix and return success */
 262                 p += PLDAPS_URL_PREFIX_LEN;
 263                 *scheme = "pldaps";
 264                 return( p );
 265         }
 266
 267         /* check for "ldapi://" prefix */
 268         if ( strncasecmp( p, LDAPI_URL_PREFIX, LDAPI_URL_PREFIX_LEN ) == 0 ) {
 269                 /* skip over "ldapi://" prefix and return success */
 270                 p += LDAPI_URL_PREFIX_LEN;
 271                 *scheme = "ldapi";
 272                 return( p );
 273         }
 274
 275 #ifdef LDAP_CONNECTIONLESS
 276         /* check for "cldap://" prefix */
 277         if ( strncasecmp( p, LDAPC_URL_PREFIX, LDAPC_URL_PREFIX_LEN ) == 0 ) {
 278                 /* skip over "cldap://" prefix and return success */
 279                 p += LDAPC_URL_PREFIX_LEN;
 280                 *scheme = "cldap";
 281                 return( p );
 282         }
 283 #endif
 284
 285         return( NULL );
 286 }
 287
 288 int
 289 ldap_pvt_scope2bv( int scope, struct berval *bv )
 290 {
 291         switch ( scope ) {
 292         case LDAP_SCOPE_BASE:
 293                 BER_BVSTR( bv, "base" );
 294                 break;
 295
 296         case LDAP_SCOPE_ONELEVEL:
 297                 BER_BVSTR( bv, "one" );
 298                 break;
 299
 300         case LDAP_SCOPE_SUBTREE:
 301                 BER_BVSTR( bv, "sub" );
 302                 break;
 303
 304         case LDAP_SCOPE_SUBORDINATE:
 305                 BER_BVSTR( bv, "subordinate" );
 306                 break;
 307
 308         default:
 309                 return LDAP_OTHER;
 310         }
 311
 312         return LDAP_SUCCESS;
 313 }
 314
 315 const char *
 316 ldap_pvt_scope2str( int scope )
 317 {
 318         struct berval   bv;
 319
 320         if ( ldap_pvt_scope2bv( scope, &bv ) == LDAP_SUCCESS ) {
 321                 return bv.bv_val;
 322         }
 323
 324         return NULL;
 325 }
 326
 327 int
 328 ldap_pvt_bv2scope( struct berval *bv )
 329 {
 330         static struct {
 331                 struct berval   bv;
 332                 int             scope;
 333         }       v[] = {
 334                 { BER_BVC( "one" ),             LDAP_SCOPE_ONELEVEL },
 335                 { BER_BVC( "onelevel" ),        LDAP_SCOPE_ONELEVEL },
 336                 { BER_BVC( "base" ),            LDAP_SCOPE_BASE },
 337                 { BER_BVC( "sub" ),             LDAP_SCOPE_SUBTREE },
 338                 { BER_BVC( "subtree" ),         LDAP_SCOPE_SUBTREE },
 339                 { BER_BVC( "subord" ),          LDAP_SCOPE_SUBORDINATE },
 340                 { BER_BVC( "subordinate" ),     LDAP_SCOPE_SUBORDINATE },
 341                 { BER_BVC( "children" ),        LDAP_SCOPE_SUBORDINATE },
 342                 { BER_BVNULL,                   -1 }
 343         };
 344         int     i;
 345
 346         for ( i = 0; v[ i ].scope != -1; i++ ) {
 347                 if ( ber_bvstrcasecmp( bv, &v[ i ].bv ) == 0 ) {
 348                         return v[ i ].scope;
 349                 }
 350         }
 351
 352         return( -1 );
 353 }
 354
 355 int
 356 ldap_pvt_str2scope( const char *p )
 357 {
 358         struct berval   bv;
 359
 360         ber_str2bv( p, 0, 0, &bv );
 361
 362         return ldap_pvt_bv2scope( &bv );
 363 }
 364
 365 static const char       hex[] = "0123456789ABCDEF";
 366
 367 #define URLESC_NONE     0x0000U
 368 #define URLESC_COMMA    0x0001U
 369 #define URLESC_SLASH    0x0002U
 370
 371 static int
 372 hex_escape_len( const char *s, unsigned list )
 373 {
 374         int     len;
 375
 376         if ( s == NULL ) {
 377                 return 0;
 378         }
 379
 380         for ( len = 0; s[0]; s++ ) {
 381                 switch ( s[0] ) {
 382                 /* RFC 2396: reserved */
 383                 case '?':
 384                         len += 3;
 385                         break;
 386
 387                 case ',':
 388                         if ( list & URLESC_COMMA ) {
 389                                 len += 3;
 390                         } else {
 391                                 len++;
 392                         }
 393                         break;
 394
 395                 case '/':
 396                         if ( list & URLESC_SLASH ) {
 397                                 len += 3;
 398                         } else {
 399                                 len++;
 400                         }
 401                         break;
 402
 403                 case ';':
 404                 case ':':
 405                 case '@':
 406                 case '&':
 407                 case '=':
 408                 case '+':
 409                 case '$':
 410
 411                 /* RFC 2396: unreserved mark */
 412                 case '-':
 413                 case '_':
 414                 case '.':
 415                 case '!':
 416                 case '~':
 417                 case '*':
 418                 case '\'':
 419                 case '(':
 420                 case ')':
 421                         len++;
 422                         break;
 423
 424                 /* RFC 2396: unreserved alphanum */
 425                 default:
 426                         if ( !isalnum( (unsigned char) s[0] ) ) {
 427                                 len += 3;
 428                         } else {
 429                                 len++;
 430                         }
 431                         break;
 432                 }
 433         }
 434
 435         return len;
 436 }
 437
 438 static int
 439 hex_escape( char *buf, int len, const char *s, unsigned list )
 440 {
 441         int     i;
 442         int     pos;
 443
 444         if ( s == NULL ) {
 445                 return 0;
 446         }
 447
 448         for ( pos = 0, i = 0; s[i] && pos < len; i++ ) {
 449                 int     escape = 0;
 450
 451                 switch ( s[i] ) {
 452                 /* RFC 2396: reserved */
 453                 case '?':
 454                         escape = 1;
 455                         break;
 456
 457                 case ',':
 458                         if ( list & URLESC_COMMA ) {
 459                                 escape = 1;
 460                         }
 461                         break;
 462
 463                 case '/':
 464                         if ( list & URLESC_SLASH ) {
 465                                 escape = 1;
 466                         }
 467                         break;
 468
 469                 case ';':
 470                 case ':':
 471                 case '@':
 472                 case '&':
 473                 case '=':
 474                 case '+':
 475                 case '$':
 476
 477                 /* RFC 2396: unreserved mark */
 478                 case '-':
 479                 case '_':
 480                 case '.':
 481                 case '!':
 482                 case '~':
 483                 case '*':
 484                 case '\'':
 485                 case '(':
 486                 case ')':
 487                         break;
 488
 489                 /* RFC 2396: unreserved alphanum */
 490                 default:
 491                         if ( !isalnum( (unsigned char) s[i] ) ) {
 492                                 escape = 1;
 493                         }
 494                         break;
 495                 }
 496
 497                 if ( escape ) {
 498                         buf[pos++] = '%';
 499                         buf[pos++] = hex[ (s[i] >> 4) & 0x0f ];
 500                         buf[pos++] = hex[ s[i] & 0x0f ];
 501
 502                 } else {
 503                         buf[pos++] = s[i];
 504                 }
 505         }
 506
 507         buf[pos] = '\0';
 508
 509         return pos;
 510 }
 511
 512 static int
 513 hex_escape_len_list( char **s, unsigned flags )
 514 {
 515         int     len;
 516         int     i;
 517
 518         if ( s == NULL ) {
 519                 return 0;
 520         }
 521
 522         len = 0;
 523         for ( i = 0; s[i] != NULL; i++ ) {
 524                 if ( len ) {
 525                         len++;
 526                 }
 527                 len += hex_escape_len( s[i], flags );
 528         }
 529
 530         return len;
 531 }
 532
 533 static int
 534 hex_escape_list( char *buf, int len, char **s, unsigned flags )
 535 {
 536         int     pos;
 537         int     i;
 538
 539         if ( s == NULL ) {
 540                 return 0;
 541         }
 542
 543         pos = 0;
 544         for ( i = 0; s[i] != NULL; i++ ) {
 545                 int     curlen;
 546
 547                 if ( pos ) {
 548                         buf[pos++] = ',';
 549                         len--;
 550                 }
 551                 curlen = hex_escape( &buf[pos], len, s[i], flags );
 552                 len -= curlen;
 553                 pos += curlen;
 554         }
 555
 556         return pos;
 557 }
 558
 559 static int
 560 desc2str_len( LDAPURLDesc *u )
 561 {
 562         int             sep = 0;
 563         int             len = 0;
 564         int             is_ipc = 0;
 565         struct berval   scope;
 566
 567         if ( u == NULL || u->lud_scheme == NULL ) {
 568                 return -1;
 569         }
 570
 571         if ( !strcmp( "ldapi", u->lud_scheme )) {
 572                 is_ipc = 1;
 573         }
 574
 575         if ( u->lud_exts ) {
 576                 len += hex_escape_len_list( u->lud_exts, URLESC_COMMA );
 577                 if ( !sep ) {
 578                         sep = 5;
 579                 }
 580         }
 581
 582         if ( u->lud_filter ) {
 583                 len += hex_escape_len( u->lud_filter, URLESC_NONE );
 584                 if ( !sep ) {
 585                         sep = 4;
 586                 }
 587         }
 588
 589         if ( ldap_pvt_scope2bv( u->lud_scope, &scope ) == LDAP_SUCCESS ) {
 590                 len += scope.bv_len;
 591                 if ( !sep ) {
 592                         sep = 3;
 593                 }
 594         }
 595
 596         if ( u->lud_attrs ) {
 597                 len += hex_escape_len_list( u->lud_attrs, URLESC_NONE );
 598                 if ( !sep ) {
 599                         sep = 2;
 600                 }
 601         }
 602
 603         if ( u->lud_dn && u->lud_dn[0] ) {
 604                 len += hex_escape_len( u->lud_dn, URLESC_NONE );
 605                 if ( !sep ) {
 606                         sep = 1;
 607                 }
 608         };
 609
 610         len += sep;
 611
 612         if ( u->lud_port ) {
 613                 unsigned p = u->lud_port;
 614                 if ( p > 65535 )
 615                         return -1;
 616
 617                 len += (p > 999 ? 5 + (p > 9999) : p > 99 ? 4 : 2 + (p > 9));
 618         }
 619
 620         if ( u->lud_host && u->lud_host[0] ) {
 621                 char *ptr;
 622                 len += hex_escape_len( u->lud_host, URLESC_SLASH );
 623                 if ( !is_ipc && ( ptr = strchr( u->lud_host, ':' ))) {
 624                         if ( strchr( ptr+1, ':' ))
 625                                 len += 2;       /* IPv6, [] */
 626                 }
 627         }
 628
 629         len += strlen( u->lud_scheme ) + STRLENOF( "://" );
 630
 631         return len;
 632 }
 633
 634 static int
 635 desc2str( LDAPURLDesc *u, char *s, int len )
 636 {
 637         int             i;
 638         int             sep = 0;
 639         int             sofar = 0;
 640         int             is_v6 = 0;
 641         int             is_ipc = 0;
 642         struct berval   scope = BER_BVNULL;
 643         char            *ptr;
 644
 645         if ( u == NULL ) {
 646                 return -1;
 647         }
 648
 649         if ( s == NULL ) {
 650                 return -1;
 651         }
 652
 653         if ( u->lud_scheme && !strcmp( "ldapi", u->lud_scheme )) {
 654                 is_ipc = 1;
 655         }
 656
 657         ldap_pvt_scope2bv( u->lud_scope, &scope );
 658
 659         if ( u->lud_exts ) {
 660                 sep = 5;
 661         } else if ( u->lud_filter ) {
 662                 sep = 4;
 663         } else if ( !BER_BVISEMPTY( &scope ) ) {
 664                 sep = 3;
 665         } else if ( u->lud_attrs ) {
 666                 sep = 2;
 667         } else if ( u->lud_dn && u->lud_dn[0] ) {
 668                 sep = 1;
 669         }
 670
 671         if ( !is_ipc && u->lud_host && ( ptr = strchr( u->lud_host, ':' ))) {
 672                 if ( strchr( ptr+1, ':' ))
 673                         is_v6 = 1;
 674         }
 675
 676         if ( u->lud_port ) {
 677                 sofar = sprintf( s, "%s://%s%s%s:%d", u->lud_scheme,
 678                                 is_v6 ? "[" : "",
 679                                 u->lud_host ? u->lud_host : "",
 680                                 is_v6 ? "]" : "",
 681                                 u->lud_port );
 682                 len -= sofar;
 683
 684         } else {
 685                 sofar = sprintf( s, "%s://", u->lud_scheme );
 686                 len -= sofar;
 687                 if ( u->lud_host && u->lud_host[0] ) {
 688                         if ( is_v6 ) {
 689                                 s[sofar++] = '[';
 690                                 len--;
 691                         }
 692                         i = hex_escape( &s[sofar], len, u->lud_host, URLESC_SLASH );
 693                         sofar += i;
 694                         len -= i;
 695                         if ( is_v6 ) {
 696                                 s[sofar++] = ']';
 697                                 len--;
 698                         }
 699                 }
 700         }
 701
 702         assert( len >= 0 );
 703
 704         if ( sep < 1 ) {
 705                 goto done;
 706         }
 707
 708         s[sofar++] = '/';
 709         len--;
 710
 711         assert( len >= 0 );
 712
 713         if ( u->lud_dn && u->lud_dn[0] ) {
 714                 i = hex_escape( &s[sofar], len, u->lud_dn, URLESC_NONE );
 715                 sofar += i;
 716                 len -= i;
 717
 718                 assert( len >= 0 );
 719         }
 720
 721         if ( sep < 2 ) {
 722                 goto done;
 723         }
 724         s[sofar++] = '?';
 725         len--;
 726
 727         assert( len >= 0 );
 728
 729         i = hex_escape_list( &s[sofar], len, u->lud_attrs, URLESC_NONE );
 730         sofar += i;
 731         len -= i;
 732
 733         assert( len >= 0 );
 734
 735         if ( sep < 3 ) {
 736                 goto done;
 737         }
 738         s[sofar++] = '?';
 739         len--;
 740
 741         assert( len >= 0 );
 742
 743         if ( !BER_BVISNULL( &scope ) ) {
 744                 strcpy( &s[sofar], scope.bv_val );
 745                 sofar += scope.bv_len;
 746                 len -= scope.bv_len;
 747         }
 748
 749         assert( len >= 0 );
 750
 751         if ( sep < 4 ) {
 752                 goto done;
 753         }
 754         s[sofar++] = '?';
 755         len--;
 756
 757         assert( len >= 0 );
 758
 759         i = hex_escape( &s[sofar], len, u->lud_filter, URLESC_NONE );
 760         sofar += i;
 761         len -= i;
 762
 763         assert( len >= 0 );
 764
 765         if ( sep < 5 ) {
 766                 goto done;
 767         }
 768         s[sofar++] = '?';
 769         len--;
 770
 771         assert( len >= 0 );
 772
 773         i = hex_escape_list( &s[sofar], len, u->lud_exts, URLESC_COMMA );
 774         sofar += i;
 775         len -= i;
 776
 777         assert( len >= 0 );
 778
 779 done:
 780         if ( len < 0 ) {
 781                 return -1;
 782         }
 783
 784         return sofar;
 785 }
 786
 787 char *
 788 ldap_url_desc2str( LDAPURLDesc *u )
 789 {
 790         int     len;
 791         char    *s;
 792
 793         if ( u == NULL ) {
 794                 return NULL;
 795         }
 796
 797         len = desc2str_len( u );
 798         if ( len < 0 ) {
 799                 return NULL;
 800         }
 801
 802         /* allocate enough to hex escape everything -- overkill */
 803         s = LDAP_MALLOC( len + 1 );
 804
 805         if ( s == NULL ) {
 806                 return NULL;
 807         }
 808
 809         if ( desc2str( u, s, len ) != len ) {
 810                 LDAP_FREE( s );
 811                 return NULL;
 812         }
 813
 814         s[len] = '\0';
 815
 816         return s;
 817 }
 818
 819 int
 820 ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp, unsigned flags )
 821 {
 822 /*
 823  *  Pick apart the pieces of an LDAP URL.
 824  */
 825
 826         LDAPURLDesc     *ludp;
 827         char    *p, *q, *r;
 828         int             i, enclosed, proto, is_v6 = 0;
 829         const char *scheme = NULL;
 830         const char *url_tmp;
 831         char *url;
 832
 833         int     check_dn = 1;
 834
 835         if( url_in == NULL || ludpp == NULL ) {
 836                 return LDAP_URL_ERR_PARAM;
 837         }
 838
 839 #ifndef LDAP_INT_IN_KERNEL
 840         /* Global options may not be created yet
 841          * We can't test if the global options are initialized
 842          * because a call to LDAP_INT_GLOBAL_OPT() will try to allocate
 843          * the options and cause infinite recursion
 844          */
 845         Debug1( LDAP_DEBUG_TRACE, "ldap_url_parse_ext(%s)\n", url_in );
 846 #endif
 847
 848         *ludpp = NULL;  /* pessimistic */
 849
 850         url_tmp = skip_url_prefix( url_in, &enclosed, &scheme );
 851
 852         if ( url_tmp == NULL ) {
 853                 return LDAP_URL_ERR_BADSCHEME;
 854         }
 855
 856         assert( scheme != NULL );
 857
 858         proto = ldap_pvt_url_scheme2proto( scheme );
 859         if ( proto == -1 ) {
 860                 return LDAP_URL_ERR_BADSCHEME;
 861         }
 862
 863         /* make working copy of the remainder of the URL */
 864         url = LDAP_STRDUP( url_tmp );
 865         if ( url == NULL ) {
 866                 return LDAP_URL_ERR_MEM;
 867         }
 868
 869         if ( enclosed ) {
 870                 p = &url[strlen(url)-1];
 871
 872                 if( *p != '>' ) {
 873                         LDAP_FREE( url );
 874                         return LDAP_URL_ERR_BADENCLOSURE;
 875                 }
 876
 877                 *p = '\0';
 878         }
 879
 880         /* allocate return struct */
 881         ludp = (LDAPURLDesc *)LDAP_CALLOC( 1, sizeof( LDAPURLDesc ));
 882
 883         if ( ludp == NULL ) {
 884                 LDAP_FREE( url );
 885                 return LDAP_URL_ERR_MEM;
 886         }
 887
 888         ludp->lud_next = NULL;
 889         ludp->lud_host = NULL;
 890         ludp->lud_port = 0;
 891         ludp->lud_dn = NULL;
 892         ludp->lud_attrs = NULL;
 893         ludp->lud_scope = ( flags & LDAP_PVT_URL_PARSE_NODEF_SCOPE ) ? LDAP_SCOPE_BASE : LDAP_SCOPE_DEFAULT;
 894         ludp->lud_filter = NULL;
 895         ludp->lud_exts = NULL;
 896
 897         ludp->lud_scheme = LDAP_STRDUP( scheme );
 898
 899         if ( ludp->lud_scheme == NULL ) {
 900                 LDAP_FREE( url );
 901                 ldap_free_urldesc( ludp );
 902                 return LDAP_URL_ERR_MEM;
 903         }
 904
 905         /* scan forward for '/' that marks end of hostport and begin. of dn */
 906         p = strchr( url, '/' );
 907         q = NULL;
 908
 909         if( p != NULL ) {
 910                 /* terminate hostport; point to start of dn */
 911                 *p++ = '\0';
 912         } else {
 913                 /* check for Novell kludge, see below */
 914                 p = strchr( url, '?' );
 915                 if ( p ) {
 916                         *p++ = '\0';
 917                         q = p;
 918                         p = NULL;
 919                 }
 920         }
 921
 922         if ( proto != LDAP_PROTO_IPC ) {
 923                 /* IPv6 syntax with [ip address]:port */
 924                 if ( *url == '[' ) {
 925                         r = strchr( url, ']' );
 926                         if ( r == NULL ) {
 927                                 LDAP_FREE( url );
 928                                 ldap_free_urldesc( ludp );
 929                                 return LDAP_URL_ERR_BADURL;
 930                         }
 931                         *r++ = '\0';
 932                         q = strchr( r, ':' );
 933                         if ( q && q != r ) {
 934                                 LDAP_FREE( url );
 935                                 ldap_free_urldesc( ludp );
 936                                 return LDAP_URL_ERR_BADURL;
 937                         }
 938                         is_v6 = 1;
 939                 } else {
 940                         q = strchr( url, ':' );
 941                 }
 942
 943                 if ( q != NULL ) {
 944                         char    *next;
 945
 946                         *q++ = '\0';
 947                         ldap_pvt_hex_unescape( q );
 948
 949                         if( *q == '\0' ) {
 950                                 LDAP_FREE( url );
 951                                 ldap_free_urldesc( ludp );
 952                                 return LDAP_URL_ERR_BADURL;
 953                         }
 954
 955                         ludp->lud_port = strtol( q, &next, 10 );
 956                         if ( next == q || next[0] != '\0' ) {
 957                                 LDAP_FREE( url );
 958                                 ldap_free_urldesc( ludp );
 959                                 return LDAP_URL_ERR_BADURL;
 960                         }
 961                         /* check for Novell kludge */
 962                         if ( !p ) {
 963                                 if ( *next != '\0' ) {
 964                                         q = &next[1];
 965                                 } else {
 966                                         q = NULL;
 967                                 }
 968                         }
 969                 }
 970
 971                 if ( ( flags & LDAP_PVT_URL_PARSE_DEF_PORT ) && ludp->lud_port == 0 ) {
 972                         if ( strcmp( ludp->lud_scheme, "ldaps" ) == 0 ) {
 973                                 ludp->lud_port = LDAPS_PORT;
 974                         } else {
 975                                 ludp->lud_port = LDAP_PORT;
 976                         }
 977                 }
 978         }
 979
 980         ldap_pvt_hex_unescape( url );
 981
 982         /* If [ip address]:port syntax, url is [ip and we skip the [ */
 983         ludp->lud_host = LDAP_STRDUP( url + is_v6 );
 984
 985         if( ludp->lud_host == NULL ) {
 986                 LDAP_FREE( url );
 987                 ldap_free_urldesc( ludp );
 988                 return LDAP_URL_ERR_MEM;
 989         }
 990
 991         if ( ( flags & LDAP_PVT_URL_PARSE_NOEMPTY_HOST )
 992                 && ludp->lud_host != NULL
 993                 && *ludp->lud_host == '\0' )
 994         {
 995                 LDAP_FREE( ludp->lud_host );
 996                 ludp->lud_host = NULL;
 997         }
 998
 999         /*
1000          * Kludge.  ldap://111.222.333.444:389??cn=abc,o=company
1001          *
1002          * On early Novell releases, search references/referrals were returned
1003          * in this format, i.e., the dn was kind of in the scope position,
1004          * but the required slash is missing. The whole thing is illegal syntax,
1005          * but we need to account for it. Fortunately it can't be confused with
1006          * anything real.
1007          */
1008         if( (p == NULL) && (q != NULL) && (*q == '?') ) {
1009                 /* ? immediately followed by question */
1010                 q++;
1011                 if( *q != '\0' ) {
1012                         /* parse dn part */
1013                         ldap_pvt_hex_unescape( q );
1014                         ludp->lud_dn = LDAP_STRDUP( q );
1015
1016                 } else if ( !( flags & LDAP_PVT_URL_PARSE_NOEMPTY_DN ) ) {
1017                         ludp->lud_dn = LDAP_STRDUP( "" );
1018
1019                 } else {
1020                         check_dn = 0;
1021                 }
1022
1023                 if ( check_dn && ludp->lud_dn == NULL ) {
1024                         LDAP_FREE( url );
1025                         ldap_free_urldesc( ludp );
1026                         return LDAP_URL_ERR_MEM;
1027                 }
1028         }
1029
1030         if( p == NULL ) {
1031                 LDAP_FREE( url );
1032                 *ludpp = ludp;
1033                 return LDAP_URL_SUCCESS;
1034         }
1035
1036         /* scan forward for '?' that may marks end of dn */
1037         q = strchr( p, '?' );
1038
1039         if( q != NULL ) {
1040                 /* terminate dn part */
1041                 *q++ = '\0';
1042         }
1043
1044         if( *p != '\0' ) {
1045                 /* parse dn part */
1046                 ldap_pvt_hex_unescape( p );
1047                 ludp->lud_dn = LDAP_STRDUP( p );
1048
1049         } else if ( !( flags & LDAP_PVT_URL_PARSE_NOEMPTY_DN ) ) {
1050                 ludp->lud_dn = LDAP_STRDUP( "" );
1051
1052         } else {
1053                 check_dn = 0;
1054         }
1055
1056         if( check_dn && ludp->lud_dn == NULL ) {
1057                 LDAP_FREE( url );
1058                 ldap_free_urldesc( ludp );
1059                 return LDAP_URL_ERR_MEM;
1060         }
1061
1062         if( q == NULL ) {
1063                 /* no more */
1064                 LDAP_FREE( url );
1065                 *ludpp = ludp;
1066                 return LDAP_URL_SUCCESS;
1067         }
1068
1069         /* scan forward for '?' that may marks end of attributes */
1070         p = q;
1071         q = strchr( p, '?' );
1072
1073         if( q != NULL ) {
1074                 /* terminate attributes part */
1075                 *q++ = '\0';
1076         }
1077
1078         if( *p != '\0' ) {
1079                 /* parse attributes */
1080                 ldap_pvt_hex_unescape( p );
1081                 ludp->lud_attrs = ldap_str2charray( p, "," );
1082
1083                 if( ludp->lud_attrs == NULL ) {
1084                         LDAP_FREE( url );
1085                         ldap_free_urldesc( ludp );
1086                         return LDAP_URL_ERR_BADATTRS;
1087                 }
1088         }
1089
1090         if ( q == NULL ) {
1091                 /* no more */
1092                 LDAP_FREE( url );
1093                 *ludpp = ludp;
1094                 return LDAP_URL_SUCCESS;
1095         }
1096
1097         /* scan forward for '?' that may marks end of scope */
1098         p = q;
1099         q = strchr( p, '?' );
1100
1101         if( q != NULL ) {
1102                 /* terminate the scope part */
1103                 *q++ = '\0';
1104         }
1105
1106         if( *p != '\0' ) {
1107                 /* parse the scope */
1108                 ldap_pvt_hex_unescape( p );
1109                 ludp->lud_scope = ldap_pvt_str2scope( p );
1110
1111                 if( ludp->lud_scope == -1 ) {
1112                         LDAP_FREE( url );
1113                         ldap_free_urldesc( ludp );
1114                         return LDAP_URL_ERR_BADSCOPE;
1115                 }
1116         }
1117
1118         if ( q == NULL ) {
1119                 /* no more */
1120                 LDAP_FREE( url );
1121                 *ludpp = ludp;
1122                 return LDAP_URL_SUCCESS;
1123         }
1124
1125         /* scan forward for '?' that may marks end of filter */
1126         p = q;
1127         q = strchr( p, '?' );
1128
1129         if( q != NULL ) {
1130                 /* terminate the filter part */
1131                 *q++ = '\0';
1132         }
1133
1134         if( *p != '\0' ) {
1135                 /* parse the filter */
1136                 ldap_pvt_hex_unescape( p );
1137
1138                 if( ! *p ) {
1139                         /* missing filter */
1140                         LDAP_FREE( url );
1141                         ldap_free_urldesc( ludp );
1142                         return LDAP_URL_ERR_BADFILTER;
1143                 }
1144
1145                 ludp->lud_filter = LDAP_STRDUP( p );
1146
1147                 if( ludp->lud_filter == NULL ) {
1148                         LDAP_FREE( url );
1149                         ldap_free_urldesc( ludp );
1150                         return LDAP_URL_ERR_MEM;
1151                 }
1152         }
1153
1154         if ( q == NULL ) {
1155                 /* no more */
1156                 LDAP_FREE( url );
1157                 *ludpp = ludp;
1158                 return LDAP_URL_SUCCESS;
1159         }
1160
1161         /* scan forward for '?' that may marks end of extensions */
1162         p = q;
1163         q = strchr( p, '?' );
1164
1165         if( q != NULL ) {
1166                 /* extra '?' */
1167                 LDAP_FREE( url );
1168                 ldap_free_urldesc( ludp );
1169                 return LDAP_URL_ERR_BADURL;
1170         }
1171
1172         /* parse the extensions */
1173         ludp->lud_exts = ldap_str2charray( p, "," );
1174
1175         if( ludp->lud_exts == NULL ) {
1176                 LDAP_FREE( url );
1177                 ldap_free_urldesc( ludp );
1178                 return LDAP_URL_ERR_BADEXTS;
1179         }
1180
1181         for( i=0; ludp->lud_exts[i] != NULL; i++ ) {
1182                 ldap_pvt_hex_unescape( ludp->lud_exts[i] );
1183
1184                 if( *ludp->lud_exts[i] == '!' ) {
1185                         /* count the number of critical extensions */
1186                         ludp->lud_crit_exts++;
1187                 }
1188         }
1189
1190         if( i == 0 ) {
1191                 /* must have 1 or more */
1192                 LDAP_FREE( url );
1193                 ldap_free_urldesc( ludp );
1194                 return LDAP_URL_ERR_BADEXTS;
1195         }
1196
1197         /* no more */
1198         *ludpp = ludp;
1199         LDAP_FREE( url );
1200         return LDAP_URL_SUCCESS;
1201 }
1202
1203 int
1204 ldap_url_parse( LDAP_CONST char *url_in, LDAPURLDesc **ludpp )
1205 {
1206         return ldap_url_parse_ext( url_in, ludpp, LDAP_PVT_URL_PARSE_HISTORIC );
1207 }
1208
1209 LDAPURLDesc *
1210 ldap_url_dup ( LDAPURLDesc *ludp )
1211 {
1212         LDAPURLDesc *dest;
1213
1214         if ( ludp == NULL ) {
1215                 return NULL;
1216         }
1217
1218         dest = LDAP_MALLOC( sizeof(LDAPURLDesc) );
1219         if (dest == NULL)
1220                 return NULL;
1221
1222         *dest = *ludp;
1223         dest->lud_scheme = NULL;
1224         dest->lud_host = NULL;
1225         dest->lud_dn = NULL;
1226         dest->lud_filter = NULL;
1227         dest->lud_attrs = NULL;
1228         dest->lud_exts = NULL;
1229         dest->lud_next = NULL;
1230
1231         if ( ludp->lud_scheme != NULL ) {
1232                 dest->lud_scheme = LDAP_STRDUP( ludp->lud_scheme );
1233                 if (dest->lud_scheme == NULL) {
1234                         ldap_free_urldesc(dest);
1235                         return NULL;
1236                 }
1237         }
1238
1239         if ( ludp->lud_host != NULL ) {
1240                 dest->lud_host = LDAP_STRDUP( ludp->lud_host );
1241                 if (dest->lud_host == NULL) {
1242                         ldap_free_urldesc(dest);
1243                         return NULL;
1244                 }
1245         }
1246
1247         if ( ludp->lud_dn != NULL ) {
1248                 dest->lud_dn = LDAP_STRDUP( ludp->lud_dn );
1249                 if (dest->lud_dn == NULL) {
1250                         ldap_free_urldesc(dest);
1251                         return NULL;
1252                 }
1253         }
1254
1255         if ( ludp->lud_filter != NULL ) {
1256                 dest->lud_filter = LDAP_STRDUP( ludp->lud_filter );
1257                 if (dest->lud_filter == NULL) {
1258                         ldap_free_urldesc(dest);
1259                         return NULL;
1260                 }
1261         }
1262
1263         if ( ludp->lud_attrs != NULL ) {
1264                 dest->lud_attrs = ldap_charray_dup( ludp->lud_attrs );
1265                 if (dest->lud_attrs == NULL) {
1266                         ldap_free_urldesc(dest);
1267                         return NULL;
1268                 }
1269         }
1270
1271         if ( ludp->lud_exts != NULL ) {
1272                 dest->lud_exts = ldap_charray_dup( ludp->lud_exts );
1273                 if (dest->lud_exts == NULL) {
1274                         ldap_free_urldesc(dest);
1275                         return NULL;
1276                 }
1277         }
1278
1279         return dest;
1280 }
1281
1282 LDAPURLDesc *
1283 ldap_url_duplist (LDAPURLDesc *ludlist)
1284 {
1285         LDAPURLDesc *dest, *tail, *ludp, *newludp;
1286
1287         dest = NULL;
1288         tail = NULL;
1289         for (ludp = ludlist; ludp != NULL; ludp = ludp->lud_next) {
1290                 newludp = ldap_url_dup(ludp);
1291                 if (newludp == NULL) {
1292                         ldap_free_urllist(dest);
1293                         return NULL;
1294                 }
1295                 if (tail == NULL)
1296                         dest = newludp;
1297                 else
1298                         tail->lud_next = newludp;
1299                 tail = newludp;
1300         }
1301         return dest;
1302 }
1303
1304 static int
1305 ldap_url_parselist_int (LDAPURLDesc **ludlist, const char *url, const char *sep, unsigned flags )
1306
1307 {
1308         int i, rc;
1309         LDAPURLDesc *ludp;
1310         char **urls;
1311
1312         assert( ludlist != NULL );
1313         assert( url != NULL );
1314
1315         *ludlist = NULL;
1316
1317         if ( sep == NULL ) {
1318                 sep = ", ";
1319         }
1320
1321         urls = ldap_str2charray( url, sep );
1322         if (urls == NULL)
1323                 return LDAP_URL_ERR_MEM;
1324
1325         /* count the URLs... */
1326         for (i = 0; urls[i] != NULL; i++) ;
1327         /* ...and put them in the "stack" backward */
1328         while (--i >= 0) {
1329                 rc = ldap_url_parse_ext( urls[i], &ludp, flags );
1330                 if ( rc != 0 ) {
1331                         ldap_charray_free( urls );
1332                         ldap_free_urllist( *ludlist );
1333                         *ludlist = NULL;
1334                         return rc;
1335                 }
1336                 ludp->lud_next = *ludlist;
1337                 *ludlist = ludp;
1338         }
1339         ldap_charray_free( urls );
1340         return LDAP_URL_SUCCESS;
1341 }
1342
1343 int
1344 ldap_url_parselist (LDAPURLDesc **ludlist, const char *url )
1345 {
1346         return ldap_url_parselist_int( ludlist, url, ", ", LDAP_PVT_URL_PARSE_HISTORIC );
1347 }
1348
1349 int
1350 ldap_url_parselist_ext (LDAPURLDesc **ludlist, const char *url, const char *sep, unsigned flags )
1351 {
1352         return ldap_url_parselist_int( ludlist, url, sep, flags );
1353 }
1354
1355 int
1356 ldap_url_parsehosts(
1357         LDAPURLDesc **ludlist,
1358         const char *hosts,
1359         int port )
1360 {
1361         int i;
1362         LDAPURLDesc *ludp;
1363         char **specs, *p;
1364
1365         assert( ludlist != NULL );
1366         assert( hosts != NULL );
1367
1368         *ludlist = NULL;
1369
1370         specs = ldap_str2charray(hosts, ", ");
1371         if (specs == NULL)
1372                 return LDAP_NO_MEMORY;
1373
1374         /* count the URLs... */
1375         for (i = 0; specs[i] != NULL; i++) /* EMPTY */;
1376
1377         /* ...and put them in the "stack" backward */
1378         while (--i >= 0) {
1379                 ludp = LDAP_CALLOC( 1, sizeof(LDAPURLDesc) );
1380                 if (ludp == NULL) {
1381                         ldap_charray_free(specs);
1382                         ldap_free_urllist(*ludlist);
1383                         *ludlist = NULL;
1384                         return LDAP_NO_MEMORY;
1385                 }
1386                 ludp->lud_port = port;
1387                 ludp->lud_host = specs[i];
1388                 p = strchr(ludp->lud_host, ':');
1389                 if (p != NULL) {
1390                         /* more than one :, IPv6 address */
1391                         if ( strchr(p+1, ':') != NULL ) {
1392                                 /* allow [address] and [address]:port */
1393                                 if ( *ludp->lud_host == '[' ) {
1394                                         p = strchr( ludp->lud_host+1, ']' );
1395                                         if ( p == NULL ) {
1396                                                 LDAP_FREE(ludp);
1397                                                 ldap_charray_free(specs);
1398                                                 return LDAP_PARAM_ERROR;
1399                                         }
1400                                         /* Truncate trailing ']' and shift hostname down 1 char */
1401                                         *p = '\0';
1402                                         AC_MEMCPY( ludp->lud_host, ludp->lud_host+1, p - ludp->lud_host );
1403                                         p++;
1404                                         if ( *p != ':' ) {
1405                                                 if ( *p != '\0' ) {
1406                                                         LDAP_FREE(ludp);
1407                                                         ldap_charray_free(specs);
1408                                                         return LDAP_PARAM_ERROR;
1409                                                 }
1410                                                 p = NULL;
1411                                         }
1412                                 } else {
1413                                         p = NULL;
1414                                 }
1415                         }
1416                         if (p != NULL) {
1417                                 char    *next;
1418
1419                                 *p++ = 0;
1420                                 ldap_pvt_hex_unescape(p);
1421                                 ludp->lud_port = strtol( p, &next, 10 );
1422                                 if ( next == p || next[0] != '\0' ) {
1423                                         LDAP_FREE(ludp);
1424                                         ldap_charray_free(specs);
1425                                         return LDAP_PARAM_ERROR;
1426                                 }
1427                         }
1428                 }
1429                 ludp->lud_scheme = LDAP_STRDUP("ldap");
1430                 if ( ludp->lud_scheme == NULL ) {
1431                         LDAP_FREE(ludp);
1432                         ldap_charray_free(specs);
1433                         return LDAP_NO_MEMORY;
1434                 }
1435                 specs[i] = NULL;
1436                 ldap_pvt_hex_unescape(ludp->lud_host);
1437                 ludp->lud_next = *ludlist;
1438                 *ludlist = ludp;
1439         }
1440
1441         /* this should be an array of NULLs now */
1442         ldap_charray_free(specs);
1443         return LDAP_SUCCESS;
1444 }
1445
1446 char *
1447 ldap_url_list2hosts (LDAPURLDesc *ludlist)
1448 {
1449         LDAPURLDesc *ludp;
1450         int size;
1451         char *s, *p, buf[32];   /* big enough to hold a long decimal # (overkill) */
1452
1453         if (ludlist == NULL)
1454                 return NULL;
1455
1456         /* figure out how big the string is */
1457         size = 1;       /* nul-term */
1458         for (ludp = ludlist; ludp != NULL; ludp = ludp->lud_next) {
1459                 if ( ludp->lud_host == NULL ) continue;
1460                 size += strlen(ludp->lud_host) + 1;             /* host and space */
1461                 if (strchr(ludp->lud_host, ':'))        /* will add [ ] below */
1462                         size += 2;
1463                 if (ludp->lud_port != 0)
1464                         size += sprintf(buf, ":%d", ludp->lud_port);
1465         }
1466         s = LDAP_MALLOC(size);
1467         if (s == NULL)
1468                 return NULL;
1469
1470         p = s;
1471         for (ludp = ludlist; ludp != NULL; ludp = ludp->lud_next) {
1472                 if ( ludp->lud_host == NULL ) continue;
1473                 if (strchr(ludp->lud_host, ':')) {
1474                         p += sprintf(p, "[%s]", ludp->lud_host);
1475                 } else {
1476                         strcpy(p, ludp->lud_host);
1477                         p += strlen(ludp->lud_host);
1478                 }
1479                 if (ludp->lud_port != 0)
1480                         p += sprintf(p, ":%d", ludp->lud_port);
1481                 *p++ = ' ';
1482         }
1483         if (p != s)
1484                 p--;    /* nuke that extra space */
1485         *p = '\0';
1486         return s;
1487 }
1488
1489 char *
1490 ldap_url_list2urls(
1491         LDAPURLDesc *ludlist )
1492 {
1493         LDAPURLDesc     *ludp;
1494         int             size, sofar;
1495         char            *s;
1496
1497         if ( ludlist == NULL ) {
1498                 return NULL;
1499         }
1500
1501         /* figure out how big the string is */
1502         for ( size = 0, ludp = ludlist; ludp != NULL; ludp = ludp->lud_next ) {
1503                 int     len = desc2str_len( ludp );
1504                 if ( len < 0 ) {
1505                         return NULL;
1506                 }
1507                 size += len + 1;
1508         }
1509
1510         s = LDAP_MALLOC( size );
1511
1512         if ( s == NULL ) {
1513                 return NULL;
1514         }
1515
1516         for ( sofar = 0, ludp = ludlist; ludp != NULL; ludp = ludp->lud_next ) {
1517                 int     len;
1518
1519                 len = desc2str( ludp, &s[sofar], size );
1520
1521                 if ( len < 0 ) {
1522                         LDAP_FREE( s );
1523                         return NULL;
1524                 }
1525
1526                 sofar += len;
1527                 size -= len;
1528
1529                 s[sofar++] = ' ';
1530                 size--;
1531
1532                 assert( size >= 0 );
1533         }
1534
1535         s[sofar - 1] = '\0';
1536
1537         return s;
1538 }
1539
1540 void
1541 ldap_free_urllist( LDAPURLDesc *ludlist )
1542 {
1543         LDAPURLDesc *ludp, *next;
1544
1545         for (ludp = ludlist; ludp != NULL; ludp = next) {
1546                 next = ludp->lud_next;
1547                 ldap_free_urldesc(ludp);
1548         }
1549 }
1550
1551 void
1552 ldap_free_urldesc( LDAPURLDesc *ludp )
1553 {
1554         if ( ludp == NULL ) {
1555                 return;
1556         }
1557
1558         if ( ludp->lud_scheme != NULL ) {
1559                 LDAP_FREE( ludp->lud_scheme );
1560         }
1561
1562         if ( ludp->lud_host != NULL ) {
1563                 LDAP_FREE( ludp->lud_host );
1564         }
1565
1566         if ( ludp->lud_dn != NULL ) {
1567                 LDAP_FREE( ludp->lud_dn );
1568         }
1569
1570         if ( ludp->lud_filter != NULL ) {
1571                 LDAP_FREE( ludp->lud_filter);
1572         }
1573
1574         if ( ludp->lud_attrs != NULL ) {
1575                 LDAP_VFREE( ludp->lud_attrs );
1576         }
1577
1578         if ( ludp->lud_exts != NULL ) {
1579                 LDAP_VFREE( ludp->lud_exts );
1580         }
1581
1582         LDAP_FREE( ludp );
1583 }
1584
1585 static int
1586 ldap_int_is_hexpair( char *s )
1587 {
1588         int     i;
1589
1590         for ( i = 0; i < 2; i++ ) {
1591                 if ( s[i] >= '0' && s[i] <= '9' ) {
1592                         continue;
1593                 }
1594
1595                 if ( s[i] >= 'A' && s[i] <= 'F' ) {
1596                         continue;
1597                 }
1598
1599                 if ( s[i] >= 'a' && s[i] <= 'f' ) {
1600                         continue;
1601                 }
1602
1603                 return 0;
1604         }
1605
1606         return 1;
1607 }
1608
1609 static int
1610 ldap_int_unhex( int c )
1611 {
1612         return( c >= '0' && c <= '9' ? c - '0'
1613             : c >= 'A' && c <= 'F' ? c - 'A' + 10
1614             : c - 'a' + 10 );
1615 }
1616
1617 void
1618 ldap_pvt_hex_unescape( char *s )
1619 {
1620         /*
1621          * Remove URL hex escapes from s... done in place.  The basic concept for
1622          * this routine is borrowed from the WWW library HTUnEscape() routine.
1623          */
1624         char    *p,
1625                 *save_s = s;
1626
1627         for ( p = s; *s != '\0'; ++s ) {
1628                 if ( *s == '%' ) {
1629                         /*
1630                          * FIXME: what if '%' is followed
1631                          * by non-hexpair chars?
1632                          */
1633                         if ( !ldap_int_is_hexpair( s + 1 ) ) {
1634                                 p = save_s;
1635                                 break;
1636                         }
1637
1638                         if ( *++s == '\0' ) {
1639                                 break;
1640                         }
1641                         *p = ldap_int_unhex( *s ) << 4;
1642                         if ( *++s == '\0' ) {
1643                                 break;
1644                         }
1645                         *p++ += ldap_int_unhex( *s );
1646                 } else {
1647                         *p++ = *s;
1648                 }
1649         }
1650
1651         *p = '\0';
1652 }