diff options
Diffstat (limited to 'ldap/c-sdk/libldap/open.c')
| -rw-r--r-- | ldap/c-sdk/libldap/open.c | 912 |
1 files changed, 912 insertions, 0 deletions
diff --git a/ldap/c-sdk/libldap/open.c b/ldap/c-sdk/libldap/open.c new file mode 100644 index 000000000..06cb629cb --- /dev/null +++ b/ldap/c-sdk/libldap/open.c @@ -0,0 +1,912 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Mozilla Communicator client code, released + * March 31, 1998. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ +/* + * Copyright (c) 1995 Regents of the University of Michigan. + * All rights reserved. + */ +/* + * open.c + */ + +#if 0 +#ifndef lint +static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of Michigan.\nAll rights reserved.\n"; +#endif +#endif + +#include "ldap-int.h" +#ifdef LDAP_SASLIO_HOOKS +/* Valid for any ANSI C compiler */ +#include <limits.h> +extern sasl_callback_t client_callbacks[]; +#endif + +#define VI_PRODUCTVERSION 3 + +#ifndef INADDR_LOOPBACK +#define INADDR_LOOPBACK ((unsigned long) 0x7f000001) +#endif + +#ifdef LDAP_DEBUG +int ldap_debug = 0; +#endif + +#ifdef _WINDOWS +#define USE_WINDOWS_TLS /* thread local storage */ +#endif + +/* + * global defaults for callbacks are stored here. callers of the API set + * these by passing a NULL "ld" to ldap_set_option(). Everything in + * nsldapi_ld_defaults can be overridden on a per-ld basis as well (the + * memory allocation functions are global to all ld's). + */ +struct ldap nsldapi_ld_defaults; +struct ldap_memalloc_fns nsldapi_memalloc_fns = { 0, 0, 0, 0 }; +int nsldapi_initialized = 0; + +#ifdef USE_PTHREADS +#include <pthread.h> +#ifdef VMS +/* +** pthread_self() is not a routine on OpenVMS; it's inline assembler code. +** Since we need a real address which we can stuff away into a table, we need +** to make sure that pthread_self maps to the real pthread_self routine (yes, +** we do have one fortunately). +*/ +#undef pthread_self +#define pthread_self PTHREAD_SELF +extern pthread_t pthread_self (void); +#endif +static pthread_key_t nsldapi_key; +static pthread_mutex_t nsldapi_init_mutex = PTHREAD_MUTEX_INITIALIZER; + +struct nsldapi_ldap_error { + int le_errno; + char *le_matched; + char *le_errmsg; +}; +#elif defined (USE_WINDOWS_TLS) +static DWORD dwTlsIndex; +struct nsldapi_ldap_error { + int le_errno; + char *le_matched; + char *le_errmsg; +}; +#elif defined (_WINDOWS) /* use static tls */ +__declspec ( thread ) int nsldapi_gldaperrno; +__declspec ( thread ) char *nsldapi_gmatched = NULL; +__declspec ( thread ) char *nsldapi_gldaperror = NULL; +#endif /* USE_WINDOWS_TLS */ + + +#ifdef _WINDOWS +#define LDAP_MUTEX_T HANDLE +static LDAP_MUTEX_T nsldapi_init_mutex; + +int +pthread_mutex_init( LDAP_MUTEX_T *mp, void *attr) +{ + if ( (*mp = CreateMutex(NULL, FALSE, NULL)) == NULL ) + return( 1 ); + else + return( 0 ); +} + +static void * +pthread_mutex_alloc( void ) +{ + LDAP_MUTEX_T *mutexp; + + if ( (mutexp = malloc( sizeof(LDAP_MUTEX_T) )) != NULL ) { + pthread_mutex_init( mutexp, NULL ); + } + return( mutexp ); +} + +int +pthread_mutex_destroy( LDAP_MUTEX_T *mp ) +{ + if ( !(CloseHandle(*mp)) ) + return( 1 ); + else + return( 0 ); +} + +static void +pthread_mutex_free( void *mutexp ) +{ + pthread_mutex_destroy( (LDAP_MUTEX_T *) mutexp ); + free( mutexp ); +} + +int +pthread_mutex_lock( LDAP_MUTEX_T *mp ) +{ + if ( (WaitForSingleObject(*mp, INFINITE) != WAIT_OBJECT_0) ) + return( 1 ); + else + return( 0 ); +} + +int +pthread_mutex_unlock( LDAP_MUTEX_T *mp ) +{ + if ( !(ReleaseMutex(*mp)) ) + return( 1 ); + else + return( 0 ); +} + +static int +get_errno( void ) +{ + return errno; +} + +static void +set_errno( int Errno ) +{ + errno = Errno; +} + +#ifdef USE_WINDOWS_TLS +static void +set_ld_error( int err, char *matched, char *errmsg, void *dummy ) +{ + struct nsldapi_ldap_error *le; + void *tsd; + + le = TlsGetValue( dwTlsIndex ); + + if (le == NULL) { + tsd = (void *)calloc(1, sizeof(struct nsldapi_ldap_error)); + TlsSetValue( dwTlsIndex, tsd ); + } + + le = TlsGetValue ( dwTlsIndex ); + + if (le == NULL) + return; + + le->le_errno = err; + + if ( le->le_matched != NULL ) { + ldap_memfree( le->le_matched ); + } + le->le_matched = matched; + + if ( le->le_errmsg != NULL ) { + ldap_memfree( le->le_errmsg ); + } + le->le_errmsg = errmsg; +} + +static int +get_ld_error ( char **matched, char **errmsg, void *dummy ) +{ + struct nsldapi_ldap_error *le; + + le = TlsGetValue( dwTlsIndex ); + if ( matched != NULL ) { + *matched = le->le_matched; + } + + if ( errmsg != NULL ) { + *errmsg = le->le_errmsg; + } + + return( le->le_errno ); +} +#else +static int +get_ld_error( char **LDMatched, char **LDError, void * Args ) +{ + if ( LDMatched != NULL ) + { + *LDMatched = nsldapi_gmatched; + } + if ( LDError != NULL ) + { + *LDError = nsldapi_gldaperror; + } + return nsldapi_gldaperrno; +} + +static void +set_ld_error( int LDErrno, char * LDMatched, char * LDError, + void * Args ) +{ + /* Clean up any previous string storage. */ + if ( nsldapi_gmatched != NULL ) + { + ldap_memfree( nsldapi_gmatched ); + } + if ( nsldapi_gldaperror != NULL ) + { + ldap_memfree( nsldapi_gldaperror ); + } + + nsldapi_gldaperrno = LDErrno; + nsldapi_gmatched = LDMatched; + nsldapi_gldaperror = LDError; +} +#endif /* USE_WINDOWS_TLS */ +#endif /* ! _WINDOWS */ + +#ifdef USE_PTHREADS +static void * +pthread_mutex_alloc( void ) +{ + pthread_mutex_t *mutexp; + + if ( (mutexp = malloc( sizeof(pthread_mutex_t) )) != NULL ) { + pthread_mutex_init( mutexp, NULL ); + } + return( mutexp ); +} + +static void +pthread_mutex_free( void *mutexp ) +{ + pthread_mutex_destroy( (pthread_mutex_t *) mutexp ); + free( mutexp ); +} + +static void +set_ld_error( int err, char *matched, char *errmsg, void *dummy ) +{ + struct nsldapi_ldap_error *le; + void *tsd; + + le = pthread_getspecific( nsldapi_key ); + + if (le == NULL) { + tsd = (void *)calloc(1, sizeof(struct nsldapi_ldap_error)); + pthread_setspecific( nsldapi_key, tsd ); + } + + le = pthread_getspecific( nsldapi_key ); + + if (le == NULL) + return; + + le->le_errno = err; + + if ( le->le_matched != NULL ) { + ldap_memfree( le->le_matched ); + } + le->le_matched = matched; + + if ( le->le_errmsg != NULL ) { + ldap_memfree( le->le_errmsg ); + } + le->le_errmsg = errmsg; +} + +static int +get_ld_error( char **matched, char **errmsg, void *dummy ) +{ + struct nsldapi_ldap_error *le; + + le = pthread_getspecific( nsldapi_key ); + + if (le == NULL) + return( LDAP_SUCCESS ); + + if ( matched != NULL ) { + *matched = le->le_matched; + } + if ( errmsg != NULL ) { + *errmsg = le->le_errmsg; + } + return( le->le_errno ); +} + +static void +set_errno( int err ) +{ + errno = err; +} + +static int +get_errno( void ) +{ + return( errno ); +} +#endif /* use_pthreads */ + +#if defined(USE_PTHREADS) || defined(_WINDOWS) +static struct ldap_thread_fns + nsldapi_default_thread_fns = { + (void *(*)(void))pthread_mutex_alloc, + (void (*)(void *))pthread_mutex_free, + (int (*)(void *))pthread_mutex_lock, + (int (*)(void *))pthread_mutex_unlock, + (int (*)(void))get_errno, + (void (*)(int))set_errno, + (int (*)(char **, char **, void *))get_ld_error, + (void (*)(int, char *, char *, void *))set_ld_error, + 0 }; + +static struct ldap_extra_thread_fns + nsldapi_default_extra_thread_fns = { + 0, 0, 0, 0, 0, +#ifdef _WINDOWS + 0 +#else + (void *(*)(void))pthread_self +#endif /* _WINDOWS */ + }; +#endif /* use_pthreads || _windows */ + +void +nsldapi_initialize_defaults( void ) +{ +#ifdef _WINDOWS + pthread_mutex_init( &nsldapi_init_mutex, NULL ); +#endif /* _WINDOWS */ + +#if defined(USE_PTHREADS) || defined(_WINDOWS) + pthread_mutex_lock( &nsldapi_init_mutex ); + + if ( nsldapi_initialized ) { + pthread_mutex_unlock( &nsldapi_init_mutex ); + return; + } +#else + if ( nsldapi_initialized ) { + return; + } +#endif /* use_pthreads || _windows */ + +#ifdef USE_PTHREADS + if ( pthread_key_create(&nsldapi_key, free ) != 0) { + perror("pthread_key_create"); + } +#elif defined(USE_WINDOWS_TLS) + dwTlsIndex = TlsAlloc(); +#endif /* USE_WINDOWS_TLS */ + + memset( &nsldapi_memalloc_fns, 0, sizeof( nsldapi_memalloc_fns )); + memset( &nsldapi_ld_defaults, 0, sizeof( nsldapi_ld_defaults )); + nsldapi_ld_defaults.ld_options = LDAP_BITOPT_REFERRALS; + nsldapi_ld_defaults.ld_version = LDAP_VERSION3; + nsldapi_ld_defaults.ld_lberoptions = LBER_OPT_USE_DER; + nsldapi_ld_defaults.ld_refhoplimit = LDAP_DEFAULT_REFHOPLIMIT; + +#ifdef LDAP_SASLIO_HOOKS + /* SASL default option settings */ + nsldapi_ld_defaults.ld_def_sasl_mech = NULL; + nsldapi_ld_defaults.ld_def_sasl_realm = NULL; + nsldapi_ld_defaults.ld_def_sasl_authcid = NULL; + nsldapi_ld_defaults.ld_def_sasl_authzid = NULL; + /* SASL Security properties */ + nsldapi_ld_defaults.ld_sasl_secprops.max_ssf = UINT_MAX; + nsldapi_ld_defaults.ld_sasl_secprops.maxbufsize = SASL_MAX_BUFF_SIZE; + nsldapi_ld_defaults.ld_sasl_secprops.security_flags = + SASL_SEC_NOPLAINTEXT | SASL_SEC_NOANONYMOUS; + + /* SASL mutex function callbacks */ + sasl_set_mutex( + (sasl_mutex_alloc_t *)nsldapi_default_thread_fns.ltf_mutex_alloc, + (sasl_mutex_lock_t *)nsldapi_default_thread_fns.ltf_mutex_lock, + (sasl_mutex_unlock_t *)nsldapi_default_thread_fns.ltf_mutex_unlock, + (sasl_mutex_free_t *)nsldapi_default_thread_fns.ltf_mutex_free ); + + /* SASL memory allocation function callbacks */ + sasl_set_alloc( + (sasl_malloc_t *)ldap_x_malloc, + (sasl_calloc_t *)ldap_x_calloc, + (sasl_realloc_t *)ldap_x_realloc, + (sasl_free_t *)ldap_x_free ); + + /* SASL library initialization */ + if ( sasl_client_init( client_callbacks ) != SASL_OK ) { + nsldapi_initialized = 0; + pthread_mutex_unlock( &nsldapi_init_mutex ); + return; + } +#endif + +#if defined( STR_TRANSLATION ) && defined( LDAP_DEFAULT_CHARSET ) + nsldapi_ld_defaults.ld_lberoptions |= LBER_OPT_TRANSLATE_STRINGS; +#if LDAP_CHARSET_8859 == LDAP_DEFAULT_CHARSET + ldap_set_string_translators( &nsldapi_ld_defaults, ldap_8859_to_t61, + ldap_t61_to_8859 ); +#endif /* LDAP_CHARSET_8859 == LDAP_DEFAULT_CHARSET */ +#endif /* STR_TRANSLATION && LDAP_DEFAULT_CHARSET */ + + /* set default connect timeout (in milliseconds) */ + /* this was picked as it is the standard tcp timeout as well */ + nsldapi_ld_defaults.ld_connect_timeout = LDAP_X_IO_TIMEOUT_NO_TIMEOUT; + +#if defined(USE_PTHREADS) || defined(_WINDOWS) + /* load up default platform specific locking routines */ + if (ldap_set_option( &nsldapi_ld_defaults, LDAP_OPT_THREAD_FN_PTRS, + (void *)&nsldapi_default_thread_fns) != LDAP_SUCCESS) { + nsldapi_initialized = 0; + pthread_mutex_unlock( &nsldapi_init_mutex ); + return; + } + +#ifndef _WINDOWS + /* load up default threadid function */ + if (ldap_set_option( &nsldapi_ld_defaults, LDAP_OPT_EXTRA_THREAD_FN_PTRS, + (void *)&nsldapi_default_extra_thread_fns) != LDAP_SUCCESS) { + nsldapi_initialized = 0; + pthread_mutex_unlock( &nsldapi_init_mutex ); + return; + } +#endif /* _WINDOWS */ + nsldapi_initialized = 1; + pthread_mutex_unlock( &nsldapi_init_mutex ); +#else + nsldapi_initialized = 1; +#endif /* use_pthreads || _windows */ +} + + +/* + * ldap_version - report version levels for important properties + * This function is deprecated. Use ldap_get_option( ..., LDAP_OPT_API_INFO, + * ... ) instead. + * + * Example: + * LDAPVersion ver; + * ldap_version( &ver ); + * if ( (ver.sdk_version < 100) || (ver.SSL_version < 300) ) + * fprintf( stderr, "LDAP SDK level insufficient\n" ); + * + * or: + * if ( ldap_version(NULL) < 100 ) + * fprintf( stderr, "LDAP SDK level insufficient\n" ); + * + */ + +int +LDAP_CALL +ldap_version( LDAPVersion *ver ) +{ + if ( NULL != ver ) + { + memset( ver, 0, sizeof(*ver) ); + ver->sdk_version = (int)(VI_PRODUCTVERSION * 100); + ver->protocol_version = LDAP_VERSION_MAX * 100; + ver->SSL_version = SSL_VERSION * 100; + /* + * set security to none by default + */ + + ver->security_level = LDAP_SECURITY_NONE; +#if defined(LINK_SSL) +#if defined(NS_DOMESTIC) + ver->security_level = 128; +#elif defined(NSS_EXPORT) + ver->security_level = 40; +#endif +#endif + + } + return (int)(VI_PRODUCTVERSION * 100); +} + +/* + * ldap_open - initialize and connect to an ldap server. A magic cookie to + * be used for future communication is returned on success, NULL on failure. + * "host" may be a space-separated list of hosts or IP addresses + * + * Example: + * LDAP *ld; + * ld = ldap_open( hostname, port ); + */ + +LDAP * +LDAP_CALL +ldap_open( const char *host, int port ) +{ + LDAP *ld; + + LDAPDebug( LDAP_DEBUG_TRACE, "ldap_open\n", 0, 0, 0 ); + + if (( ld = ldap_init( host, port )) == NULL ) { + return( NULL ); + } + + LDAP_MUTEX_LOCK( ld, LDAP_CONN_LOCK ); + if ( nsldapi_open_ldap_defconn( ld ) < 0 ) { + LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK ); + ldap_ld_free( ld, NULL, NULL, 0 ); + return( NULL ); + } + + LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK ); + LDAPDebug( LDAP_DEBUG_TRACE, "ldap_open successful, ld_host is %s\n", + ( ld->ld_host == NULL ) ? "(null)" : ld->ld_host, 0, 0 ); + + return( ld ); +} + + +/* + * ldap_init - initialize the LDAP library. A magic cookie to be used for + * future communication is returned on success, NULL on failure. + * "defhost" may be a space-separated list of hosts or IP addresses + * + * NOTE: If you want to use IPv6, you must use prldap creating a LDAP handle + * with prldap_init instead of ldap_init. Or install the NSPR functions + * by calling prldap_install_routines. (See the nspr samples in examples) + * + * Example: + * LDAP *ld; + * ld = ldap_init( default_hostname, default_port ); + */ +LDAP * +LDAP_CALL +ldap_init( const char *defhost, int defport ) +{ + LDAP *ld; + + if ( !nsldapi_initialized ) { + nsldapi_initialize_defaults(); + } + + if ( defport < 0 || defport > LDAP_PORT_MAX ) { + LDAPDebug( LDAP_DEBUG_ANY, + "ldap_init: port %d is invalid (port numbers must range from 1 to %d)\n", + defport, LDAP_PORT_MAX, 0 ); +#if !defined( macintosh ) && !defined( DOS ) && !defined( BEOS ) + errno = EINVAL; +#endif + return( NULL ); + } + + LDAPDebug( LDAP_DEBUG_TRACE, "ldap_init\n", 0, 0, 0 ); + + if ( (ld = (LDAP*)NSLDAPI_MALLOC( sizeof(struct ldap) )) == NULL ) { + return( NULL ); + } + + /* copy defaults */ + SAFEMEMCPY( ld, &nsldapi_ld_defaults, sizeof( struct ldap )); + if ( nsldapi_ld_defaults.ld_io_fns_ptr != NULL ) { + if (( ld->ld_io_fns_ptr = (struct ldap_io_fns *)NSLDAPI_MALLOC( + sizeof( struct ldap_io_fns ))) == NULL ) { + NSLDAPI_FREE( (char *)ld ); + return( NULL ); + } + /* struct copy */ + *(ld->ld_io_fns_ptr) = *(nsldapi_ld_defaults.ld_io_fns_ptr); + } + + /* call the new handle I/O callback if one is defined */ + if ( ld->ld_extnewhandle_fn != NULL ) { + /* + * We always pass the session extended I/O argument to + * the new handle callback. + */ + if ( ld->ld_extnewhandle_fn( ld, ld->ld_ext_session_arg ) + != LDAP_SUCCESS ) { + NSLDAPI_FREE( (char*)ld ); + return( NULL ); + } + } + + /* allocate session-specific resources */ + if (( ld->ld_sbp = ber_sockbuf_alloc()) == NULL || + ( defhost != NULL && + ( ld->ld_defhost = nsldapi_strdup( defhost )) == NULL ) || + ((ld->ld_mutex = (void **) NSLDAPI_CALLOC( LDAP_MAX_LOCK, sizeof(void *))) == NULL )) { + if ( ld->ld_sbp != NULL ) { + ber_sockbuf_free( ld->ld_sbp ); + } + if( ld->ld_mutex != NULL ) { + NSLDAPI_FREE( ld->ld_mutex ); + } + NSLDAPI_FREE( (char*)ld ); + return( NULL ); + } + + /* install Sockbuf I/O functions if set in LDAP * */ + if ( ld->ld_extread_fn != NULL || ld->ld_extwrite_fn != NULL ) { + struct lber_x_ext_io_fns lberiofns; + + memset( &lberiofns, 0, sizeof( lberiofns )); + + lberiofns.lbextiofn_size = LBER_X_EXTIO_FNS_SIZE; + lberiofns.lbextiofn_read = ld->ld_extread_fn; + lberiofns.lbextiofn_write = ld->ld_extwrite_fn; + lberiofns.lbextiofn_writev = ld->ld_extwritev_fn; + lberiofns.lbextiofn_socket_arg = NULL; + ber_sockbuf_set_option( ld->ld_sbp, LBER_SOCKBUF_OPT_EXT_IO_FNS, + (void *)&lberiofns ); + } + + /* allocate mutexes */ + nsldapi_mutex_alloc_all( ld ); + + /* set default port */ + ld->ld_defport = ( defport == 0 ) ? LDAP_PORT : defport; + + return( ld ); +} + + +void +nsldapi_mutex_alloc_all( LDAP *ld ) +{ + int i; + + if ( ld != &nsldapi_ld_defaults && ld->ld_mutex != NULL ) { + for ( i = 0; i<LDAP_MAX_LOCK; i++ ) { + ld->ld_mutex[i] = LDAP_MUTEX_ALLOC( ld ); + ld->ld_mutex_threadid[i] = (void *) -1; + ld->ld_mutex_refcnt[i] = 0; + } + } +} + + +void +nsldapi_mutex_free_all( LDAP *ld ) +{ + int i; + + if ( ld != &nsldapi_ld_defaults && ld->ld_mutex != NULL ) { + for ( i = 0; i<LDAP_MAX_LOCK; i++ ) { + LDAP_MUTEX_FREE( ld, ld->ld_mutex[i] ); + } + } +} + + +/* returns 0 if connection opened and -1 if an error occurs */ +int +nsldapi_open_ldap_defconn( LDAP *ld ) +{ + LDAPServer *srv; + + if (( srv = (LDAPServer *)NSLDAPI_CALLOC( 1, sizeof( LDAPServer ))) == + NULL || ( ld->ld_defhost != NULL && ( srv->lsrv_host = + nsldapi_strdup( ld->ld_defhost )) == NULL )) { + LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL ); + return( -1 ); + } + srv->lsrv_port = ld->ld_defport; + + if (( ld->ld_options & LDAP_BITOPT_SSL ) != 0 ) { + srv->lsrv_options |= LDAP_SRV_OPT_SECURE; + } + + if (( ld->ld_defconn = nsldapi_new_connection( ld, &srv, 1, 1, 0 )) + == NULL ) { + if ( ld->ld_defhost != NULL ) { + NSLDAPI_FREE( srv->lsrv_host ); + } + NSLDAPI_FREE( (char *)srv ); + return( -1 ); + } + ++ld->ld_defconn->lconn_refcnt; /* so it never gets closed/freed */ + + return( 0 ); +} + + +struct ldap_x_hostlist_status { + char *lhs_hostlist; + char *lhs_nexthost; + int lhs_defport; +}; + +/* + * Return the first host and port in hostlist (setting *hostp and *portp). + * Return value is an LDAP API error code (LDAP_SUCCESS if all goes well). + * Note that a NULL or zero-length hostlist causes the host "127.0.0.1" to + * be returned. + */ +int LDAP_CALL +ldap_x_hostlist_first( const char *hostlist, int defport, char **hostp, + int *portp, struct ldap_x_hostlist_status **statusp ) +{ + + if ( NULL == hostp || NULL == portp || NULL == statusp ) { + return( LDAP_PARAM_ERROR ); + } + + if ( NULL == hostlist || *hostlist == '\0' ) { + *hostp = nsldapi_strdup( "127.0.0.1" ); + if ( NULL == *hostp ) { + return( LDAP_NO_MEMORY ); + } + *portp = defport; + *statusp = NULL; + return( LDAP_SUCCESS ); + } + + *statusp = NSLDAPI_CALLOC( 1, sizeof( struct ldap_x_hostlist_status )); + if ( NULL == *statusp ) { + return( LDAP_NO_MEMORY ); + } + (*statusp)->lhs_hostlist = nsldapi_strdup( hostlist ); + if ( NULL == (*statusp)->lhs_hostlist ) { + return( LDAP_NO_MEMORY ); + } + (*statusp)->lhs_nexthost = (*statusp)->lhs_hostlist; + (*statusp)->lhs_defport = defport; + return( ldap_x_hostlist_next( hostp, portp, *statusp )); +} + +/* + * Return the next host and port in hostlist (setting *hostp and *portp). + * Return value is an LDAP API error code (LDAP_SUCCESS if all goes well). + * If no more hosts are available, LDAP_SUCCESS is returned but *hostp is set + * to NULL. + */ +int LDAP_CALL +ldap_x_hostlist_next( char **hostp, int *portp, + struct ldap_x_hostlist_status *status ) +{ + char *q; + int squarebrackets = 0; + + if ( NULL == hostp || NULL == portp ) { + return( LDAP_PARAM_ERROR ); + } + + if ( NULL == status || NULL == status->lhs_nexthost ) { + *hostp = NULL; + return( LDAP_SUCCESS ); + } + + /* + * skip past leading '[' if present (IPv6 addresses may be surrounded + * with square brackets, e.g., [fe80::a00:20ff:fee5:c0b4]:389 + */ + if ( status->lhs_nexthost[0] == '[' ) { + ++status->lhs_nexthost; + squarebrackets = 1; + } + + /* copy host into *hostp */ + if ( NULL != ( q = strchr( status->lhs_nexthost, ' ' ))) { + size_t len = q - status->lhs_nexthost; + *hostp = NSLDAPI_MALLOC( len + 1 ); + if ( NULL == *hostp ) { + return( LDAP_NO_MEMORY ); + } + strncpy( *hostp, status->lhs_nexthost, len ); + (*hostp)[len] = '\0'; + status->lhs_nexthost += ( len + 1 ); + } else { /* last host */ + *hostp = nsldapi_strdup( status->lhs_nexthost ); + if ( NULL == *hostp ) { + return( LDAP_NO_MEMORY ); + } + status->lhs_nexthost = NULL; + } + + /* + * Look for closing ']' and skip past it before looking for port. + */ + if ( squarebrackets && NULL != ( q = strchr( *hostp, ']' ))) { + *q++ = '\0'; + } else { + q = *hostp; + } + + /* determine and set port */ + if ( NULL != ( q = strchr( q, ':' ))) { + *q++ = '\0'; + *portp = atoi( q ); + } else { + *portp = status->lhs_defport; + } + + return( LDAP_SUCCESS ); +} + + +void LDAP_CALL +ldap_x_hostlist_statusfree( struct ldap_x_hostlist_status *status ) +{ + if ( NULL != status ) { + if ( NULL != status->lhs_hostlist ) { + NSLDAPI_FREE( status->lhs_hostlist ); + } + NSLDAPI_FREE( status ); + } +} + + + +/* + * memory allocation functions. we include these in open.c since every + * LDAP application is likely to pull the rest of the code in this file + * in anyways. + */ +void * +ldap_x_malloc( size_t size ) +{ + return( nsldapi_memalloc_fns.ldapmem_malloc == NULL ? + malloc( size ) : + nsldapi_memalloc_fns.ldapmem_malloc( size )); +} + + +void * +ldap_x_calloc( size_t nelem, size_t elsize ) +{ + return( nsldapi_memalloc_fns.ldapmem_calloc == NULL ? + calloc( nelem, elsize ) : + nsldapi_memalloc_fns.ldapmem_calloc( nelem, elsize )); +} + + +void * +ldap_x_realloc( void *ptr, size_t size ) +{ + return( nsldapi_memalloc_fns.ldapmem_realloc == NULL ? + realloc( ptr, size ) : + nsldapi_memalloc_fns.ldapmem_realloc( ptr, size )); +} + + +void +ldap_x_free( void *ptr ) +{ + if ( nsldapi_memalloc_fns.ldapmem_free == NULL ) { + free( ptr ); + } else { + nsldapi_memalloc_fns.ldapmem_free( ptr ); + } +} + + +/* if s is NULL, returns NULL */ +char * +nsldapi_strdup( const char *s ) +{ + char *p; + + if ( s == NULL || + (p = (char *)NSLDAPI_MALLOC( strlen( s ) + 1 )) == NULL ) + return( NULL ); + + strcpy( p, s ); + + return( p ); +} |