X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Futil-int.c;h=4bf3f6fa71e6833f56f0060737fed7dfdbbf8b0b;hb=864f05497e23f8884652c061209a730458512c53;hp=cfac8e336f25a2ce8dc59826603203d840b6af26;hpb=d8032bcbaaeb9144213c6dfd5a0b86b440675821;p=openldap diff --git a/libraries/libldap/util-int.c b/libraries/libldap/util-int.c index cfac8e336f..4bf3f6fa71 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,12 +23,13 @@ #include "portable.h" -#include +#include #include #include #include #include +#include #include "ldap-int.h" @@ -57,11 +59,11 @@ # 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; +# if !defined( HAVE_GETHOSTBYNAME_R ) || !defined( HAVE_GETHOSTBYADDR_R ) + static ldap_pvt_thread_mutex_t ldap_int_gethostby_mutex; # endif -# ifndef HAVE_GETHOSTBYADDR_R - static ldap_pvt_thread_mutex_t ldap_int_gethostbyaddr_mutex; +# ifdef HAVE_RES_QUERY + ldap_pvt_thread_mutex_t ldap_int_resolv_mutex; # endif #endif /* LDAP_R_COMPILE */ @@ -82,7 +84,7 @@ char *ldap_pvt_ctime( const time_t *tp, char *buf ) # 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 @@ -90,11 +92,14 @@ char *ldap_pvt_ctime( const time_t *tp, char *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 ); + +#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, @@ -141,8 +146,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_gethostby_mutex ); he = gethostbyname( name ); @@ -157,10 +163,11 @@ int ldap_pvt_gethostbyname_a( retval = 0; } - ldap_pvt_thread_mutex_unlock( &ldap_int_gethostbyname_mutex ); + ldap_pvt_thread_mutex_unlock( &ldap_int_gethostby_mutex ); return retval; #else + *buf = NULL; *result = gethostbyname( name ); if (*result!=NULL) { @@ -220,8 +227,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_gethostby_mutex ); he = gethostbyaddr( addr, len, type ); @@ -236,10 +244,11 @@ int ldap_pvt_gethostbyaddr_a( retval = 0; } - ldap_pvt_thread_mutex_unlock( &ldap_int_gethostbyaddr_mutex ); + ldap_pvt_thread_mutex_unlock( &ldap_int_gethostby_mutex ); return retval; #else /* gethostbyaddr() */ + *buf = NULL; *result = gethostbyaddr( addr, len, type ); if (*result!=NULL) { @@ -265,12 +274,12 @@ void ldap_int_utils_init( void ) ldap_pvt_thread_mutex_init( &ldap_int_ctime_mutex ); #endif -#if !defined( HAVE_GETHOSTBYNAME_R ) - ldap_pvt_thread_mutex_init( &ldap_int_gethostbyname_mutex ); +#if !defined( HAVE_GETHOSTBYNAME_R ) || !defined( HAVE_GETHOSTBYADDR_R ) + ldap_pvt_thread_mutex_init( &ldap_int_gethostby_mutex ); #endif -#if !defined( HAVE_GETHOSTBYADDR_R ) - ldap_pvt_thread_mutex_init( &ldap_int_gethostbyaddr_mutex ); +#ifdef HAVE_RES_QUERY + ldap_pvt_thread_mutex_init( &ldap_int_resolv_mutex ); #endif /* call other module init functions here... */ @@ -287,7 +296,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 +308,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 +322,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 +351,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; } @@ -368,4 +385,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