usr/src/lib/libldap5/sources/ldap/common/open.c

   1 /*
   2  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  */
   5
   6
   7 /*
   8  * The contents of this file are subject to the Netscape Public
   9  * License Version 1.1 (the "License"); you may not use this file
  10  * except in compliance with the License. You may obtain a copy of
  11  * the License at http://www.mozilla.org/NPL/
  12  *
  13  * Software distributed under the License is distributed on an "AS
  14  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  15  * implied. See the License for the specific language governing
  16  * rights and limitations under the License.
  17  *
  18  * The Original Code is Mozilla Communicator client code, released
  19  * March 31, 1998.
  20  *
  21  * The Initial Developer of the Original Code is Netscape
  22  * Communications Corporation. Portions created by Netscape are
  23  * Copyright (C) 1998-1999 Netscape Communications Corporation. All
  24  * Rights Reserved.
  25  *
  26  * Contributor(s):
  27  */
  28 /*
  29  *  Copyright (c) 1995 Regents of the University of Michigan.
  30  *  All rights reserved.
  31  */
  32 /*
  33  *  open.c
  34  */
  35
  36 #if 0
  37 #ifndef lint
  38 static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of Michigan.\nAll rights reserved.\n";
  39 #endif
  40 #endif
  41
  42 #include "ldap-int.h"
  43 #ifdef LDAP_SASLIO_HOOKS
  44 /* Valid for any ANSI C compiler */
  45 #include <limits.h>
  46 #endif
  47
  48 #define VI_PRODUCTVERSION 3
  49
  50 #ifndef INADDR_LOOPBACK
  51 #define INADDR_LOOPBACK ((unsigned long) 0x7f000001)
  52 #endif
  53
  54 #ifndef MAXHOSTNAMELEN
  55 #define MAXHOSTNAMELEN  64
  56 #endif
  57
  58 #ifdef LDAP_DEBUG
  59 int     ldap_debug;
  60 #endif
  61
  62
  63 /*
  64  * global defaults for callbacks are stored here.  callers of the API set
  65  *    these by passing a NULL "ld" to ldap_set_option().  Everything in
  66  *    nsldapi_ld_defaults can be overridden on a per-ld basis as well (the
  67  *    memory allocation functions are global to all ld's).
  68  */
  69 struct ldap                     nsldapi_ld_defaults;
  70 struct ldap_memalloc_fns        nsldapi_memalloc_fns = { 0, 0, 0, 0 };
  71 int                             nsldapi_initialized = 0;
  72
  73 #ifndef _WINDOWS
  74 #include <pthread.h>
  75 static pthread_key_t            nsldapi_key;
  76
  77 struct nsldapi_ldap_error {
  78         int     le_errno;
  79         char    *le_matched;
  80         char    *le_errmsg;
  81 };
  82 #else
  83 __declspec ( thread ) int       nsldapi_gldaperrno;
  84 __declspec ( thread ) char      *nsldapi_gmatched = NULL;
  85 __declspec ( thread ) char      *nsldapi_gldaperror = NULL;
  86 #endif /* _WINDOWS */
  87
  88 #ifdef _WINDOWS
  89 #define LDAP_MUTEX_T    HANDLE
  90
  91 int
  92 pthread_mutex_init( LDAP_MUTEX_T *mp, void *attr)
  93 {
  94         if ( (*mp = CreateMutex(NULL, FALSE, NULL)) == NULL )
  95                 return( 1 );
  96         else
  97                 return( 0 );
  98 }
  99
 100 static void *
 101 pthread_mutex_alloc( void )
 102 {
 103         LDAP_MUTEX_T *mutexp;
 104
 105         if ( (mutexp = malloc( sizeof(LDAP_MUTEX_T) )) != NULL ) {
 106                 pthread_mutex_init( mutexp, NULL );
 107         }
 108         return( mutexp );
 109 }
 110
 111 int
 112 pthread_mutex_destroy( LDAP_MUTEX_T *mp )
 113 {
 114         if ( !(CloseHandle(*mp)) )
 115                 return( 1 );
 116         else
 117                 return( 0 );
 118 }
 119
 120 static void
 121 pthread_mutex_free( void *mutexp )
 122 {
 123         pthread_mutex_destroy( (LDAP_MUTEX_T *) mutexp );
 124         free( mutexp );
 125 }
 126
 127 int
 128 pthread_mutex_lock( LDAP_MUTEX_T *mp )
 129 {
 130         if ( (WaitForSingleObject(*mp, INFINITE) != WAIT_OBJECT_0) )
 131                 return( 1 );
 132         else
 133                 return( 0 );
 134 }
 135
 136 int
 137 pthread_mutex_unlock( LDAP_MUTEX_T *mp )
 138 {
 139         if ( !(ReleaseMutex(*mp)) )
 140                 return( 1 );
 141         else
 142                 return( 0 );
 143 }
 144
 145 static int
 146 get_errno( void )
 147 {
 148         return errno;
 149 }
 150
 151 static void
 152 set_errno( int Errno )
 153 {
 154         errno = Errno;
 155 }
 156
 157 static int
 158 get_ld_error( char **LDMatched, char **LDError, void * Args )
 159 {
 160         if ( LDMatched != NULL )
 161         {
 162                 *LDMatched = nsldapi_gmatched;
 163         }
 164         if ( LDError != NULL )
 165         {
 166                 *LDError = nsldapi_gldaperror;
 167         }
 168         return nsldapi_gldaperrno;
 169 }
 170
 171 static void
 172 set_ld_error( int LDErrno, char *  LDMatched, char *  LDError,
 173         void *  Args )
 174 {
 175         /* Clean up any previous string storage. */
 176         if ( nsldapi_gmatched != NULL )
 177         {
 178                 ldap_memfree( nsldapi_gmatched );
 179         }
 180         if ( nsldapi_gldaperror != NULL )
 181         {
 182                 ldap_memfree( nsldapi_gldaperror );
 183         }
 184
 185         nsldapi_gldaperrno  = LDErrno;
 186         nsldapi_gmatched    = LDMatched;
 187         nsldapi_gldaperror  = LDError;
 188 }
 189 #else
 190 static void *
 191 pthread_mutex_alloc( void )
 192 {
 193         pthread_mutex_t *mutexp;
 194
 195         if ( (mutexp = malloc( sizeof(pthread_mutex_t) )) != NULL ) {
 196                 pthread_mutex_init( mutexp, NULL );
 197         }
 198         return( mutexp );
 199 }
 200
 201 static void
 202 pthread_mutex_free( void *mutexp )
 203 {
 204         pthread_mutex_destroy( (pthread_mutex_t *) mutexp );
 205         free( mutexp );
 206 }
 207
 208 static void
 209 set_ld_error( int err, char *matched, char *errmsg, void *dummy )
 210 {
 211         struct nsldapi_ldap_error *le;
 212         void *tsd;
 213
 214         le = pthread_getspecific( nsldapi_key );
 215
 216         if (le == NULL) {
 217                 tsd = (void *)calloc(1, sizeof(struct nsldapi_ldap_error));
 218                 pthread_setspecific( nsldapi_key, tsd );
 219         }
 220
 221         le = pthread_getspecific( nsldapi_key );
 222
 223         if (le == NULL) {
 224                 free(tsd);
 225                 return;
 226         }
 227
 228         le->le_errno = err;
 229
 230         if ( le->le_matched != NULL ) {
 231                 ldap_memfree( le->le_matched );
 232         }
 233         le->le_matched = matched;
 234
 235         if ( le->le_errmsg != NULL ) {
 236                 ldap_memfree( le->le_errmsg );
 237         }
 238         le->le_errmsg = errmsg;
 239 }
 240
 241 static int
 242 get_ld_error( char **matched, char **errmsg, void *dummy )
 243 {
 244         struct nsldapi_ldap_error *le;
 245
 246         le = pthread_getspecific( nsldapi_key );
 247         if (le != NULL) {
 248                 if ( matched != NULL ) {
 249                         *matched = le->le_matched;
 250                 }
 251                 if ( errmsg != NULL ) {
 252                         *errmsg = le->le_errmsg;
 253                 }
 254                 return( le->le_errno );
 255         } else {
 256                 if ( matched != NULL )
 257                         *matched = NULL;
 258                 if ( errmsg != NULL )
 259                         *errmsg = NULL;
 260         }
 261         return (LDAP_SUCCESS);
 262 }
 263
 264 static void
 265 set_errno( int err )
 266 {
 267         errno = err;
 268 }
 269
 270 static int
 271 get_errno( void )
 272 {
 273         return( errno );
 274 }
 275 #endif /* _WINDOWS */
 276
 277 static struct ldap_thread_fns
 278         nsldapi_default_thread_fns = {
 279                 (void *(*)(void))pthread_mutex_alloc,
 280                 (void (*)(void *))pthread_mutex_free,
 281                 (int (*)(void *))pthread_mutex_lock,
 282                 (int (*)(void *))pthread_mutex_unlock,
 283                 (int (*)(void))get_errno,
 284                 (void (*)(int))set_errno,
 285                 (int (*)(char **, char **, void *))get_ld_error,
 286                 (void (*)(int, char *, char *, void *))set_ld_error,
 287                 0 };
 288
 289 static struct ldap_extra_thread_fns
 290         nsldapi_default_extra_thread_fns = {
 291                 0, 0, 0, 0, 0,
 292 #ifdef _WINDOWS
 293                 0
 294 #else
 295                 (void *(*)(void))pthread_self
 296 #endif /* _WINDOWS */
 297                 };
 298
 299 void
 300 nsldapi_initialize_defaults( void )
 301 {
 302
 303         if ( nsldapi_initialized ) {
 304                 return;
 305         }
 306 #ifdef  _SOLARIS_SDK
 307         /*
 308          * This has to be called before nsldapi_initialized is set to 1
 309          * because nsldapi_initialized does not have mutex protection
 310          */
 311         prldap_nspr_init();
 312 #endif
 313
 314 #ifndef _WINDOWS
 315         if ( pthread_key_create(&nsldapi_key, free ) != 0) {
 316                 perror("pthread_key_create");
 317         }
 318 #endif /* _WINDOWS */
 319
 320         nsldapi_initialized = 1;
 321         memset( &nsldapi_memalloc_fns, 0, sizeof( nsldapi_memalloc_fns ));
 322         memset( &nsldapi_ld_defaults, 0, sizeof( nsldapi_ld_defaults ));
 323         nsldapi_ld_defaults.ld_options = LDAP_BITOPT_REFERRALS;
 324         nsldapi_ld_defaults.ld_version = LDAP_VERSION2;
 325         nsldapi_ld_defaults.ld_lberoptions = LBER_OPT_USE_DER;
 326         nsldapi_ld_defaults.ld_refhoplimit = LDAP_DEFAULT_REFHOPLIMIT;
 327
 328 #ifdef LDAP_SASLIO_HOOKS
 329         /* SASL default option settings */
 330         nsldapi_ld_defaults.ld_def_sasl_mech = NULL;
 331         nsldapi_ld_defaults.ld_def_sasl_realm = NULL;
 332         nsldapi_ld_defaults.ld_def_sasl_authcid = NULL;
 333         nsldapi_ld_defaults.ld_def_sasl_authzid = NULL;
 334         /* SASL Security properties */
 335         nsldapi_ld_defaults.ld_sasl_secprops.max_ssf = UINT_MAX;
 336         nsldapi_ld_defaults.ld_sasl_secprops.maxbufsize = SASL_MAX_BUFF_SIZE;
 337         nsldapi_ld_defaults.ld_sasl_secprops.security_flags =
 338                 SASL_SEC_NOPLAINTEXT | SASL_SEC_NOANONYMOUS;
 339 #endif
 340
 341 #if defined( STR_TRANSLATION ) && defined( LDAP_DEFAULT_CHARSET )
 342         nsldapi_ld_defaults.ld_lberoptions |= LBER_OPT_TRANSLATE_STRINGS;
 343 #if LDAP_CHARSET_8859 == LDAP_DEFAULT_CHARSET
 344         ldap_set_string_translators( &nsldapi_ld_defaults, ldap_8859_to_t61,
 345             ldap_t61_to_8859 );
 346 #endif /* LDAP_CHARSET_8859 == LDAP_DEFAULT_CHARSET */
 347 #endif /* STR_TRANSLATION && LDAP_DEFAULT_CHARSET */
 348
 349         /* set default connect timeout (in milliseconds) */
 350         /* this was picked as it is the standard tcp timeout as well */
 351         nsldapi_ld_defaults.ld_connect_timeout = LDAP_X_IO_TIMEOUT_NO_TIMEOUT;
 352
 353         /* load up default platform specific locking routines */
 354         if (ldap_set_option( NULL, LDAP_OPT_THREAD_FN_PTRS,
 355                 (void *)&nsldapi_default_thread_fns) != LDAP_SUCCESS) {
 356                 return;
 357         }
 358
 359 #ifndef _WINDOWS
 360         /* load up default threadid function */
 361         if (ldap_set_option( NULL, LDAP_OPT_EXTRA_THREAD_FN_PTRS,
 362                 (void *)&nsldapi_default_extra_thread_fns) != LDAP_SUCCESS) {
 363                 return;
 364         }
 365 #endif /* _WINDOWS */
 366 }
 367
 368
 369 /*
 370  * ldap_version - report version levels for important properties
 371  * This function is deprecated.  Use ldap_get_option( ..., LDAP_OPT_API_INFO,
 372  *      ... ) instead.
 373  *
 374  * Example:
 375  *      LDAPVersion ver;
 376  *      ldap_version( &ver );
 377  *  if ( (ver.sdk_version < 100) || (ver.SSL_version < 300) )
 378  *      fprintf( stderr, "LDAP SDK level insufficient\n" );
 379  *
 380  * or:
 381  *  if ( ldap_version(NULL) < 100 )
 382  *      fprintf( stderr, "LDAP SDK level insufficient\n" );
 383  *
 384  */
 385
 386 int
 387 LDAP_CALL
 388 ldap_version( LDAPVersion *ver )
 389 {
 390         if ( NULL != ver )
 391         {
 392                 memset( ver, 0, sizeof(*ver) );
 393                 ver->sdk_version = (int)(VI_PRODUCTVERSION * 100);
 394                 ver->protocol_version = LDAP_VERSION_MAX * 100;
 395                 ver->SSL_version = SSL_VERSION * 100;
 396                 /*
 397                  * set security to none by default
 398                  */
 399
 400                 ver->security_level = LDAP_SECURITY_NONE;
 401 #if defined(LINK_SSL)
 402                 ver->security_level = 128;
 403 #endif
 404
 405         }
 406         return (int)(VI_PRODUCTVERSION * 100);
 407 }
 408
 409 /*
 410  * ldap_open - initialize and connect to an ldap server.  A magic cookie to
 411  * be used for future communication is returned on success, NULL on failure.
 412  * "host" may be a space-separated list of hosts or IP addresses
 413  *
 414  * Example:
 415  *      LDAP    *ld;
 416  *      ld = ldap_open( hostname, port );
 417  */
 418
 419 LDAP *
 420 LDAP_CALL
 421 ldap_open( const char *host, int port )
 422 {
 423         LDAP    *ld;
 424
 425         LDAPDebug( LDAP_DEBUG_TRACE, "ldap_open\n", 0, 0, 0 );
 426
 427         if (( ld = ldap_init( host, port )) == NULL ) {
 428                 return( NULL );
 429         }
 430
 431         LDAP_MUTEX_LOCK( ld, LDAP_CONN_LOCK );
 432         if ( nsldapi_open_ldap_defconn( ld ) < 0 ) {
 433                 LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
 434                 ldap_ld_free( ld, NULL, NULL, 0 );
 435                 return( NULL );
 436         }
 437
 438         LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
 439         LDAPDebug( LDAP_DEBUG_TRACE, "ldap_open successful, ld_host is %s\n",
 440                 ( ld->ld_host == NULL ) ? "(null)" : ld->ld_host, 0, 0 );
 441
 442         return( ld );
 443 }
 444
 445
 446 /*
 447  * ldap_init - initialize the LDAP library.  A magic cookie to be used for
 448  * future communication is returned on success, NULL on failure.
 449  * "defhost" may be a space-separated list of hosts or IP addresses
 450  *
 451  * Example:
 452  *      LDAP    *ld;
 453  *      ld = ldap_init( default_hostname, default_port );
 454  */
 455 LDAP *
 456 LDAP_CALL
 457 ldap_init( const char *defhost, int defport )
 458 {
 459         LDAP    *ld;
 460
 461         if ( !nsldapi_initialized ) {
 462                 nsldapi_initialize_defaults();
 463         }
 464
 465         if ( defport < 0 || defport > LDAP_PORT_MAX ) {
 466             LDAPDebug( LDAP_DEBUG_ANY,
 467                     "ldap_init: port %d is invalid (port numbers must range from 1 to %d)\n",
 468                     defport, LDAP_PORT_MAX, 0 );
 469 #if !defined( macintosh ) && !defined( DOS )
 470             errno = EINVAL;
 471 #endif
 472             return( NULL );
 473         }
 474
 475         LDAPDebug( LDAP_DEBUG_TRACE, "ldap_init\n", 0, 0, 0 );
 476
 477         if ( (ld = (LDAP*)NSLDAPI_MALLOC( sizeof(struct ldap) )) == NULL ) {
 478                 return( NULL );
 479         }
 480
 481         /* copy defaults */
 482         SAFEMEMCPY( ld, &nsldapi_ld_defaults, sizeof( struct ldap ));
 483         if ( nsldapi_ld_defaults.ld_io_fns_ptr != NULL ) {
 484                 if (( ld->ld_io_fns_ptr = (struct ldap_io_fns *)NSLDAPI_MALLOC(
 485                     sizeof( struct ldap_io_fns ))) == NULL ) {
 486                         NSLDAPI_FREE( (char *)ld );
 487                         return( NULL );
 488                 }
 489                 /* struct copy */
 490                 *(ld->ld_io_fns_ptr) = *(nsldapi_ld_defaults.ld_io_fns_ptr);
 491         }
 492
 493         /* call the new handle I/O callback if one is defined */
 494         if ( ld->ld_extnewhandle_fn != NULL ) {
 495                 /*
 496                  * We always pass the session extended I/O argument to
 497                  * the new handle callback.
 498                  */
 499                 if ( ld->ld_extnewhandle_fn( ld, ld->ld_ext_session_arg )
 500                     != LDAP_SUCCESS ) {
 501                         NSLDAPI_FREE( (char*)ld );
 502                         return( NULL );
 503                 }
 504         }
 505
 506         /* allocate session-specific resources */
 507         if (( ld->ld_sbp = ber_sockbuf_alloc()) == NULL ||
 508             ( defhost != NULL &&
 509             ( ld->ld_defhost = nsldapi_strdup( defhost )) == NULL ) ||
 510             ((ld->ld_mutex = (void **) NSLDAPI_CALLOC( LDAP_MAX_LOCK, sizeof(void *))) == NULL )) {
 511                 if ( ld->ld_sbp != NULL ) {
 512                         ber_sockbuf_free( ld->ld_sbp );
 513                 }
 514                 if( ld->ld_mutex != NULL ) {
 515                         NSLDAPI_FREE( ld->ld_mutex );
 516                 }
 517                 NSLDAPI_FREE( (char*)ld );
 518                 return( NULL );
 519         }
 520
 521         /* install Sockbuf I/O functions if set in LDAP * */
 522         if ( ld->ld_extread_fn != NULL || ld->ld_extwrite_fn != NULL ) {
 523                 struct lber_x_ext_io_fns lberiofns;
 524
 525                 memset( &lberiofns, 0, sizeof( lberiofns ));
 526
 527                 lberiofns.lbextiofn_size = LBER_X_EXTIO_FNS_SIZE;
 528                 lberiofns.lbextiofn_read = ld->ld_extread_fn;
 529                 lberiofns.lbextiofn_write = ld->ld_extwrite_fn;
 530                 lberiofns.lbextiofn_writev = ld->ld_extwritev_fn;
 531                 lberiofns.lbextiofn_socket_arg = NULL;
 532                 ber_sockbuf_set_option( ld->ld_sbp, LBER_SOCKBUF_OPT_EXT_IO_FNS,
 533                         (void *)&lberiofns );
 534         }
 535
 536 #ifdef _SOLARIS_SDK
 537         /* Install the functions for IPv6 support       */
 538         /* code sequencing is critical from here to nsldapi_mutex_alloc_all */
 539         if ( prldap_install_thread_functions( ld, 1 ) != 0 ||
 540              prldap_install_io_functions( ld, 1 ) != 0 ||
 541              prldap_install_dns_functions( ld ) != 0 ) {
 542                 /* go through ld and free resources */
 543                 ldap_unbind( ld );
 544                 ld = NULL;
 545                 return( NULL );
 546         }
 547 #else
 548
 549         /* allocate mutexes */
 550         nsldapi_mutex_alloc_all( ld );
 551 #endif
 552
 553         /* set default port */
 554         ld->ld_defport = ( defport == 0 ) ? LDAP_PORT : defport;
 555
 556         return( ld );
 557 }
 558
 559 void
 560 nsldapi_mutex_alloc_all( LDAP *ld )
 561 {
 562         int     i;
 563
 564         if ( ld != &nsldapi_ld_defaults && ld->ld_mutex != NULL ) {
 565                 for ( i = 0; i<LDAP_MAX_LOCK; i++ ) {
 566                         ld->ld_mutex[i] = LDAP_MUTEX_ALLOC( ld );
 567                         ld->ld_mutex_threadid[i] = (void *) -1;
 568                         ld->ld_mutex_refcnt[i] = 0;
 569                 }
 570         }
 571 }
 572
 573
 574 void
 575 nsldapi_mutex_free_all( LDAP *ld )
 576 {
 577         int     i;
 578
 579         if ( ld != &nsldapi_ld_defaults && ld->ld_mutex != NULL ) {
 580                 for ( i = 0; i<LDAP_MAX_LOCK; i++ ) {
 581                         LDAP_MUTEX_FREE( ld, ld->ld_mutex[i] );
 582                 }
 583         }
 584 }
 585
 586 /* returns 0 if connection opened and -1 if an error occurs */
 587 int
 588 nsldapi_open_ldap_defconn( LDAP *ld )
 589 {
 590         LDAPServer      *srv;
 591
 592         if (( srv = (LDAPServer *)NSLDAPI_CALLOC( 1, sizeof( LDAPServer ))) ==
 593             NULL || ( ld->ld_defhost != NULL && ( srv->lsrv_host =
 594             nsldapi_strdup( ld->ld_defhost )) == NULL )) {
 595                 LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL );
 596                 return( -1 );
 597         }
 598         srv->lsrv_port = ld->ld_defport;
 599
 600 #ifdef LDAP_SSLIO_HOOKS
 601         if (( ld->ld_options & LDAP_BITOPT_SSL ) != 0 ) {
 602                 srv->lsrv_options |= LDAP_SRV_OPT_SECURE;
 603         }
 604 #endif
 605
 606         if (( ld->ld_defconn = nsldapi_new_connection( ld, &srv, 1, 1, 0 ))
 607             == NULL ) {
 608                 if ( ld->ld_defhost != NULL ) {
 609                         NSLDAPI_FREE( srv->lsrv_host );
 610                 }
 611                 NSLDAPI_FREE( (char *)srv );
 612                 return( -1 );
 613         }
 614         ++ld->ld_defconn->lconn_refcnt; /* so it never gets closed/freed */
 615
 616         return( 0 );
 617 }
 618
 619
 620 struct ldap_x_hostlist_status {
 621         char    *lhs_hostlist;
 622         char    *lhs_nexthost;
 623         int     lhs_defport;
 624 };
 625
 626 /*
 627  * Return the first host and port in hostlist (setting *hostp and *portp).
 628  * Return value is an LDAP API error code (LDAP_SUCCESS if all goes well).
 629  * Note that a NULL or zero-length hostlist causes the host "127.0.0.1" to
 630  * be returned.
 631  */
 632 int LDAP_CALL
 633 ldap_x_hostlist_first( const char *hostlist, int defport, char **hostp,
 634     int *portp, struct ldap_x_hostlist_status **statusp )
 635 {
 636
 637         if ( NULL == hostp || NULL == portp || NULL == statusp ) {
 638                 return( LDAP_PARAM_ERROR );
 639         }
 640
 641         if ( NULL == hostlist || *hostlist == '\0' ) {
 642                 *hostp = nsldapi_strdup( "127.0.0.1" );
 643                 if ( NULL == *hostp ) {
 644                         return( LDAP_NO_MEMORY );
 645                 }
 646                 *portp = defport;
 647                 *statusp = NULL;
 648                 return( LDAP_SUCCESS );
 649         }
 650
 651         *statusp = NSLDAPI_CALLOC( 1, sizeof( struct ldap_x_hostlist_status ));
 652         if ( NULL == *statusp ) {
 653                 return( LDAP_NO_MEMORY );
 654         }
 655         (*statusp)->lhs_hostlist = nsldapi_strdup( hostlist );
 656         if ( NULL == (*statusp)->lhs_hostlist ) {
 657                 return( LDAP_NO_MEMORY );
 658         }
 659         (*statusp)->lhs_nexthost = (*statusp)->lhs_hostlist;
 660         (*statusp)->lhs_defport = defport;
 661         return( ldap_x_hostlist_next( hostp, portp, *statusp ));
 662 }
 663
 664 /*
 665  * Return the next host and port in hostlist (setting *hostp and *portp).
 666  * Return value is an LDAP API error code (LDAP_SUCCESS if all goes well).
 667  * If no more hosts are available, LDAP_SUCCESS is returned but *hostp is set
 668  * to NULL.
 669  */
 670 int LDAP_CALL
 671 ldap_x_hostlist_next( char **hostp, int *portp,
 672         struct ldap_x_hostlist_status *status )
 673 {
 674         char    *q;
 675         int             squarebrackets = 0;
 676
 677         if ( NULL == hostp || NULL == portp ) {
 678                 return( LDAP_PARAM_ERROR );
 679         }
 680
 681         if ( NULL == status || NULL == status->lhs_nexthost ) {
 682                 *hostp = NULL;
 683                 return( LDAP_SUCCESS );
 684         }
 685
 686         /*
 687          * skip past leading '[' if present (IPv6 addresses may be surrounded
 688          * with square brackets, e.g., [fe80::a00:20ff:fee5:c0b4]:389
 689          */
 690         if ( status->lhs_nexthost[0] == '[' ) {
 691                 ++status->lhs_nexthost;
 692                 squarebrackets = 1;
 693         }
 694
 695         /* copy host into *hostp */
 696         if ( NULL != ( q = strchr( status->lhs_nexthost, ' ' ))) {
 697                 size_t  len = q - status->lhs_nexthost;
 698                 *hostp = NSLDAPI_MALLOC( len + 1 );
 699                 if ( NULL == *hostp ) {
 700                         return( LDAP_NO_MEMORY );
 701                 }
 702                 strncpy( *hostp, status->lhs_nexthost, len );
 703                 (*hostp)[len] = '\0';
 704                 status->lhs_nexthost += ( len + 1 );
 705         } else {        /* last host */
 706                 *hostp = nsldapi_strdup( status->lhs_nexthost );
 707                 if ( NULL == *hostp ) {
 708                         return( LDAP_NO_MEMORY );
 709                 }
 710                 status->lhs_nexthost = NULL;
 711         }
 712
 713         /*
 714          * Look for closing ']' and skip past it before looking for port.
 715          */
 716         if ( squarebrackets && NULL != ( q = strchr( *hostp, ']' ))) {
 717                 *q++ = '\0';
 718         } else {
 719                 q = *hostp;
 720         }
 721
 722         /* determine and set port */
 723         if ( NULL != ( q = strchr( q, ':' ))) {
 724                 *q++ = '\0';
 725                 *portp = atoi( q );
 726         } else {
 727                 *portp = status->lhs_defport;
 728         }
 729
 730         return( LDAP_SUCCESS );
 731 }
 732
 733
 734 void LDAP_CALL
 735 ldap_x_hostlist_statusfree( struct ldap_x_hostlist_status *status )
 736 {
 737         if ( NULL != status ) {
 738                 if ( NULL != status->lhs_hostlist ) {
 739                         NSLDAPI_FREE( status->lhs_hostlist );
 740                 }
 741                 NSLDAPI_FREE( status );
 742         }
 743 }
 744
 745
 746
 747 /*
 748  * memory allocation functions.  we include these in open.c since every
 749  *    LDAP application is likely to pull the rest of the code in this file
 750  *    in anyways.
 751  */
 752 void *
 753 ldap_x_malloc( size_t size )
 754 {
 755         return( nsldapi_memalloc_fns.ldapmem_malloc == NULL ?
 756             malloc( size ) :
 757             nsldapi_memalloc_fns.ldapmem_malloc( size ));
 758 }
 759
 760
 761 void *
 762 ldap_x_calloc( size_t nelem, size_t elsize )
 763 {
 764         return( nsldapi_memalloc_fns.ldapmem_calloc == NULL ?
 765             calloc(  nelem, elsize ) :
 766             nsldapi_memalloc_fns.ldapmem_calloc( nelem, elsize ));
 767 }
 768
 769
 770 void *
 771 ldap_x_realloc( void *ptr, size_t size )
 772 {
 773         return( nsldapi_memalloc_fns.ldapmem_realloc == NULL ?
 774             realloc( ptr, size ) :
 775             nsldapi_memalloc_fns.ldapmem_realloc( ptr, size ));
 776 }
 777
 778
 779 void
 780 ldap_x_free( void *ptr )
 781 {
 782         if ( nsldapi_memalloc_fns.ldapmem_free == NULL ) {
 783                 free( ptr );
 784         } else {
 785                 nsldapi_memalloc_fns.ldapmem_free( ptr );
 786         }
 787 }
 788
 789
 790 /* if s is NULL, returns NULL */
 791 char *
 792 nsldapi_strdup( const char *s )
 793 {
 794         char    *p;
 795
 796         if ( s == NULL ||
 797             (p = (char *)NSLDAPI_MALLOC( strlen( s ) + 1 )) == NULL )
 798                 return( NULL );
 799
 800         strcpy( p, s );
 801
 802         return( p );
 803 }