X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Futil-int.c;h=6a2d5bd3487481f09f20644d3196a16db3c50a58;hb=cf6a9d9d0f0b2bcacab72a87531df5df56ca08ef;hp=eb0517d9bf508c9d550e56bc86c3e030c2411d70;hpb=9bef1a2bc1c8d69d0caeaef6895cbbffe24a664c;p=openldap diff --git a/libraries/libldap/util-int.c b/libraries/libldap/util-int.c index eb0517d9bf..6a2d5bd348 100644 --- a/libraries/libldap/util-int.c +++ b/libraries/libldap/util-int.c @@ -1,5 +1,6 @@ +/* $OpenLDAP$ */ /* - * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved. + * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. * COPYING RESTRICTIONS APPLY, see COPYRIGHT file */ /* @@ -22,54 +23,51 @@ #include "portable.h" -#include +#include #include #include #include #include +#include #include "ldap-int.h" -#if defined( LDAP_R_COMPILE ) -# include -#else +#if !defined( LDAP_R_COMPILE ) # undef HAVE_REENTRANT_FUNCTIONS -#endif +# undef HAVE_CTIME_R +# undef HAVE_GETHOSTBYNAME_R +# undef HAVE_GETHOSTBYADDR_R + +#else +# include #if (defined( HAVE_CTIME_R ) || defined( HAVE_REENTRANT_FUNCTIONS)) \ && defined( CTIME_R_NARGS ) # define USE_CTIME_R +#else + static ldap_pvt_thread_mutex_t ldap_int_ctime_mutex; #endif #if defined(HAVE_GETHOSTBYNAME_R) && \ - (GETHOSTBYNAME_R_NARGS > 6 || GETHOSTBYNAME_R_NARGS < 5) + (GETHOSTBYNAME_R_NARGS < 5) || (6 < GETHOSTBYNAME_R_NARGS) /* Don't know how to handle this version, pretend it's not there */ # undef HAVE_GETHOSTBYNAME_R #endif #if defined(HAVE_GETHOSTBYADDR_R) && \ - (GETHOSTBYADDR_R_NARGS > 8 || GETHOSTBYADDR_R_NARGS < 7) + (GETHOSTBYADDR_R_NARGS < 7) || (8 < GETHOSTBYADDR_R_NARGS) /* Don't know how to handle this version, pretend it's not there */ # undef HAVE_GETHOSTBYADDR_R #endif -#ifdef LDAP_R_COMPILE -# ifndef USE_CTIME_R - static ldap_pvt_thread_mutex_t ldap_int_ctime_mutex; -# endif -# ifndef HAVE_GETHOSTBYNAME_R - static ldap_pvt_thread_mutex_t ldap_int_gethostbyname_mutex; -# endif -# ifndef HAVE_GETHOSTBYADDR_R - static ldap_pvt_thread_mutex_t ldap_int_gethostbyaddr_mutex; -# endif + ldap_pvt_thread_mutex_t ldap_int_resolv_mutex; #endif /* LDAP_R_COMPILE */ char *ldap_pvt_ctime( const time_t *tp, char *buf ) { #ifdef USE_CTIME_R # if (CTIME_R_NARGS > 3) || (CTIME_R_NARGS < 2) - choke me! nargs should have 2 or 3 +# error "CTIME_R_NARGS should be 2 or 3" # elif CTIME_R_NARGS > 2 && defined(CTIME_R_RETURNS_INT) return( ctime_r(tp,buf,26) < 0 ? 0 : buf ); # elif CTIME_R_NARGS > 2 @@ -79,22 +77,30 @@ char *ldap_pvt_ctime( const time_t *tp, char *buf ) # endif #else + # ifdef LDAP_R_COMPILE ldap_pvt_thread_mutex_lock( &ldap_int_ctime_mutex ); # endif - memcpy( buf, ctime(tp), 26 ); + + AC_MEMCPY( buf, ctime(tp), 26 ); + # ifdef LDAP_R_COMPILE ldap_pvt_thread_mutex_unlock( &ldap_int_ctime_mutex ); # endif + return buf; #endif } -#define BUFSTART 1024 -#define BUFMAX (32*1024) +#define BUFSTART (1024-32) +#define BUFMAX (32*1024-32) static char *safe_realloc( char **buf, int len ); -static int copy_hostent( struct hostent *res, char **buf, struct hostent * src ); + +#if !defined(HAVE_GETHOSTBYNAME_R) && defined(LDAP_R_COMPILE) +static int copy_hostent( struct hostent *res, + char **buf, struct hostent * src ); +#endif int ldap_pvt_gethostbyname_a( const char *name, @@ -114,15 +120,15 @@ int ldap_pvt_gethostbyname_a( return r; #if (GETHOSTBYNAME_R_NARGS < 6) - r = ((*result=gethostbyname_r( name, resbuf, *buf,\ - buflen, herrno_ptr ))== NULL) ?\ + r = ((*result=gethostbyname_r( name, resbuf, *buf, + buflen, herrno_ptr ))== NULL) ? -1 : 0; #else r = gethostbyname_r( name, resbuf, *buf, buflen, result, herrno_ptr ); #endif - Debug( LDAP_DEBUG_TRACE, "ldap_pvt_gethostbyname_a: host=%s, r=%d\n",\ + Debug( LDAP_DEBUG_TRACE, "ldap_pvt_gethostbyname_a: host=%s, r=%d\n", name, r, 0 ); #ifdef NETDB_INTERNAL @@ -141,8 +147,9 @@ int ldap_pvt_gethostbyname_a( # define NEED_COPY_HOSTENT struct hostent *he; int retval; + *buf = NULL; - ldap_pvt_thread_mutex_lock( &ldap_int_gethostbyname_mutex ); + ldap_pvt_thread_mutex_lock( &ldap_int_resolv_mutex ); he = gethostbyname( name ); @@ -157,10 +164,11 @@ int ldap_pvt_gethostbyname_a( retval = 0; } - ldap_pvt_thread_mutex_unlock( &ldap_int_gethostbyname_mutex ); + ldap_pvt_thread_mutex_unlock( &ldap_int_resolv_mutex ); return retval; #else + *buf = NULL; *result = gethostbyname( name ); if (*result!=NULL) { @@ -195,7 +203,7 @@ int ldap_pvt_gethostbyaddr_a( #if (GETHOSTBYADDR_R_NARGS < 8) r = ((*result=gethostbyaddr_r( addr, len, type, resbuf, *buf, buflen, - herrno_ptr )) == NULL) ?\ + herrno_ptr )) == NULL) ? -1 : 0; #else r = gethostbyaddr_r( addr, len, type, @@ -220,8 +228,9 @@ int ldap_pvt_gethostbyaddr_a( # define NEED_COPY_HOSTENT struct hostent *he; int retval; + *buf = NULL; - ldap_pvt_thread_mutex_lock( &ldap_int_gethostbyaddr_mutex ); + ldap_pvt_thread_mutex_lock( &ldap_int_resolv_mutex ); he = gethostbyaddr( addr, len, type ); @@ -236,10 +245,12 @@ int ldap_pvt_gethostbyaddr_a( retval = 0; } - ldap_pvt_thread_mutex_unlock( &ldap_int_gethostbyaddr_mutex ); + ldap_pvt_thread_mutex_unlock( &ldap_int_resolv_mutex ); - return retval; + return retval; + #else /* gethostbyaddr() */ + *buf = NULL; *result = gethostbyaddr( addr, len, type ); if (*result!=NULL) { @@ -249,10 +260,10 @@ int ldap_pvt_gethostbyaddr_a( #endif } /* - * ldap_pvt_init_utils() should be called before any other function. + * ldap_int_utils_init() should be called before any other function. */ -void ldap_pvt_init_utils( void ) +void ldap_int_utils_init( void ) { static int done=0; if (done) @@ -260,21 +271,13 @@ void ldap_pvt_init_utils( void ) done=1; #ifdef LDAP_R_COMPILE - #if !defined( USE_CTIME_R ) && !defined( HAVE_REENTRANT_FUNCTIONS ) ldap_pvt_thread_mutex_init( &ldap_int_ctime_mutex ); #endif - -#if !defined( HAVE_GETHOSTBYNAME_R ) - ldap_pvt_thread_mutex_init( &ldap_int_gethostbyname_mutex ); -#endif - -#if !defined( HAVE_GETHOSTBYADDR_R ) - ldap_pvt_thread_mutex_init( &ldap_int_gethostbyaddr_mutex ); + ldap_pvt_thread_mutex_init( &ldap_int_resolv_mutex ); #endif /* call other module init functions here... */ -#endif } #if defined( NEED_COPY_HOSTENT ) @@ -287,7 +290,7 @@ static char *cpy_aliases( char ***tgtio, char *buf, char **src ) char **tgt=*tgtio; for( ; (*src) ; src++ ) { len = strlen( *src ) + 1; - memcpy( buf, *src, len ); + AC_MEMCPY( buf, *src, len ); *tgt++=buf; buf+=len; } @@ -299,7 +302,7 @@ static char *cpy_addresses( char ***tgtio, char *buf, char **src, int len ) { char **tgt=*tgtio; for( ; (*src) ; src++ ) { - memcpy( buf, *src, len ); + AC_MEMCPY( buf, *src, len ); *tgt++=buf; buf+=len; } @@ -313,24 +316,28 @@ static int copy_hostent( struct hostent *res, char **buf, struct hostent * src ) char **tp; char *tbuf; int name_len; - int n_alias; - int total_alias_len; - int n_addr; + int n_alias=0; + int total_alias_len=0; + int n_addr=0; int total_addr_len; int total_len; /* calculate the size needed for the buffer */ name_len = strlen( src->h_name ) + 1; - for( n_alias=total_alias_len=0, p=src->h_aliases; (*p) ; p++ ) { - total_alias_len += strlen( *p ) + 1; - n_alias++; + if( src->h_aliases != NULL ) { + for( p = src->h_aliases; (*p) != NULL; p++ ) { + total_alias_len += strlen( *p ) + 1; + n_alias++; + } } - for( n_addr=0, p=src->h_addr_list; (*p) ; p++ ) { - n_addr++; + if( src->h_addr_list != NULL ) { + for( p = src->h_addr_list; (*p) != NULL; p++ ) { + n_addr++; + } + total_addr_len = n_addr * src->h_length; } - total_addr_len = n_addr * src->h_length; total_len = (n_alias + n_addr + 2) * sizeof( char * ) + total_addr_len + total_alias_len + name_len; @@ -338,17 +345,21 @@ static int copy_hostent( struct hostent *res, char **buf, struct hostent * src ) if (safe_realloc( buf, total_len )) { tp = (char **) *buf; tbuf = *buf + (n_alias + n_addr + 2) * sizeof( char * ); - memcpy( res, src, sizeof( struct hostent ) ); + AC_MEMCPY( res, src, sizeof( struct hostent ) ); /* first the name... */ - memcpy( tbuf, src->h_name, name_len ); + AC_MEMCPY( tbuf, src->h_name, name_len ); res->h_name = tbuf; tbuf+=name_len; /* now the aliases */ res->h_aliases = tp; - tbuf = cpy_aliases( &tp, tbuf, src->h_aliases ); + if ( src->h_aliases != NULL ) { + tbuf = cpy_aliases( &tp, tbuf, src->h_aliases ); + } *tp++=NULL; /* finally the addresses */ res->h_addr_list = tp; - tbuf = cpy_addresses( &tp, tbuf, src->h_addr_list, src->h_length ); + if ( src->h_addr_list != NULL ) { + tbuf = cpy_addresses( &tp, tbuf, src->h_addr_list, src->h_length ); + } *tp++=NULL; return 0; } @@ -360,7 +371,7 @@ static int copy_hostent( struct hostent *res, char **buf, struct hostent * src ) static char *safe_realloc( char **buf, int len ) { char *tmpbuf; - tmpbuf = realloc( *buf, len ); + tmpbuf = LDAP_REALLOC( *buf, len ); if (tmpbuf) { *buf=tmpbuf; } @@ -368,4 +379,67 @@ static char *safe_realloc( char **buf, int len ) } #endif +char * ldap_pvt_get_fqdn( char *name ) +{ + char *fqdn, *ha_buf; + char hostbuf[MAXHOSTNAMELEN+1]; + struct hostent *hp, he_buf; + int rc, local_h_errno; + + if( name == NULL ) { + if( gethostname( hostbuf, MAXHOSTNAMELEN ) == 0 ) { + hostbuf[MAXHOSTNAMELEN] = '\0'; + name = hostbuf; + } else { + name = "localhost"; + } + } + + rc = ldap_pvt_gethostbyname_a( name, + &he_buf, &ha_buf, &hp, &local_h_errno ); + if( rc < 0 || hp == NULL || hp->h_name == NULL ) { + fqdn = LDAP_STRDUP( name ); + } else { + fqdn = LDAP_STRDUP( hp->h_name ); + } + + LDAP_FREE( ha_buf ); + return fqdn; +} + +#if defined( HAVE_GETADDRINFO ) && !defined( HAVE_GAI_STRERROR ) +char *ldap_pvt_gai_strerror (int code) { + static struct { + int code; + const char *msg; + } values[] = { +#ifdef EAI_ADDRFAMILY + { EAI_ADDRFAMILY, "Address family for hostname not supported" }, +#endif + { EAI_AGAIN, "Temporary failure in name resolution" }, + { EAI_BADFLAGS, "Bad value for ai_flags" }, + { EAI_FAIL, "Non-recoverable failure in name resolution" }, + { EAI_FAMILY, "ai_family not supported" }, + { EAI_MEMORY, "Memory allocation failure" }, +#ifdef EAI_NODATA + { EAI_NODATA, "No address associated with hostname" }, +#endif + { EAI_NONAME, "Name or service not known" }, + { EAI_SERVICE, "Servname not supported for ai_socktype" }, + { EAI_SOCKTYPE, "ai_socktype not supported" }, + { EAI_SYSTEM, "System error" }, + { 0, NULL } + }; + + int i; + + for ( i = 0; values[i].msg != NULL; i++ ) { + if ( values[i].code == code ) { + return (char *) values[i].msg; + } + } + + return "Unknown error"; +} +#endif