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
pthread_mutex_init(LDAP_MUTEX_T * mp,void * attr)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 *
pthread_mutex_alloc(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
pthread_mutex_destroy(LDAP_MUTEX_T * mp)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
pthread_mutex_free(void * mutexp)121 pthread_mutex_free( void *mutexp )
122 {
123         pthread_mutex_destroy( (LDAP_MUTEX_T *) mutexp );
124         free( mutexp );
125 }
126 
127 int
pthread_mutex_lock(LDAP_MUTEX_T * mp)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
pthread_mutex_unlock(LDAP_MUTEX_T * mp)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
get_errno(void)146 get_errno( void )
147 {
148 	return errno;
149 }
150 
151 static void
set_errno(int Errno)152 set_errno( int Errno )
153 {
154 	errno = Errno;
155 }
156 
157 static int
get_ld_error(char ** LDMatched,char ** LDError,void * Args)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
set_ld_error(int LDErrno,char * LDMatched,char * LDError,void * Args)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 *
pthread_mutex_alloc(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
pthread_mutex_free(void * mutexp)202 pthread_mutex_free( void *mutexp )
203 {
204 	pthread_mutex_destroy( (pthread_mutex_t *) mutexp );
205 	free( mutexp );
206 }
207 
208 static void
set_ld_error(int err,char * matched,char * errmsg,void * dummy)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
get_ld_error(char ** matched,char ** errmsg,void * dummy)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
set_errno(int err)265 set_errno( int err )
266 {
267         errno = err;
268 }
269 
270 static int
get_errno(void)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))(uintptr_t)pthread_self
296 #endif /* _WINDOWS */
297 		};
298 
299 void
nsldapi_initialize_defaults(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
ldap_version(LDAPVersion * ver)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
ldap_open(const char * host,int port)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
ldap_init(const char * defhost,int defport)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
nsldapi_mutex_alloc_all(LDAP * ld)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
nsldapi_mutex_free_all(LDAP * ld)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
nsldapi_open_ldap_defconn(LDAP * ld)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
ldap_x_hostlist_first(const char * hostlist,int defport,char ** hostp,int * portp,struct ldap_x_hostlist_status ** statusp)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
ldap_x_hostlist_next(char ** hostp,int * portp,struct ldap_x_hostlist_status * status)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
ldap_x_hostlist_statusfree(struct ldap_x_hostlist_status * status)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 *
ldap_x_malloc(size_t size)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 *
ldap_x_calloc(size_t nelem,size_t elsize)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 *
ldap_x_realloc(void * ptr,size_t size)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
ldap_x_free(void * ptr)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 *
nsldapi_strdup(const char * s)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 }
804