HOST_R_RETURN
gethostent_r(struct hostent *hptr, HOST_R_ARGS) {
struct hostent *he = gethostent();
#ifdef HOST_R_SETANSWER
int n = 0;
#endif
#ifdef HOST_R_ERRNO
HOST_R_ERRNO;
#endif
#ifdef HOST_R_SETANSWER
if (he == NULL || (n = copy_hostent(he, hptr, HOST_R_COPY)) != 0)
*answerp = NULL;
else
*answerp = hptr;
return (n);
#else
if (he == NULL)
return (HOST_R_BAD);
return (copy_hostent(he, hptr, HOST_R_COPY));
#endif
}
HOST_R_RETURN
gethostbyaddr_r(const char *addr, int len, int type,
struct hostent *hptr, HOST_R_ARGS) {
struct hostent *he = gethostbyaddr(addr, len, type);
#ifdef HOST_R_SETANSWER
int n = 0;
#endif
#ifdef HOST_R_ERRNO
HOST_R_ERRNO;
#endif
#ifdef HOST_R_SETANSWER
if (he == NULL || (n = copy_hostent(he, hptr, HOST_R_COPY)) != 0)
*answerp = NULL;
else
*answerp = hptr;
return (n);
#else
if (he == NULL)
return (HOST_R_BAD);
return (copy_hostent(he, hptr, HOST_R_COPY));
#endif
}
static struct hostent *my_gethostbyaddr_r(const char *addr,
int length,
int type,
struct hostent *hostp,
char *buffer,
int buflen,
int *h_errnop)
{
struct hostent dest;
struct hostent *src;
struct hostent *rval = NULL;
/* FIXME this should have been done in 'erl'_init()? */
if (!ei_resolve_initialized) ei_init_resolve();
#ifdef _REENTRANT
/* === BEGIN critical section === */
if (ei_mutex_lock(ei_gethost_sem,0) != 0) {
*h_errnop = NO_RECOVERY;
return NULL;
}
#endif /* _REENTRANT */
/* lookup the data */
if ((src = ei_gethostbyaddr(addr,length,type))) {
/* copy to caller's buffer */
if (!copy_hostent(&dest,src,buffer,buflen)) {
/* success */
*hostp = dest;
*h_errnop = 0;
rval = hostp;
}
else {
/* failure - buffer size */
#ifdef __WIN32__
SetLastError(ERROR_INSUFFICIENT_BUFFER);
#else
errno = ERANGE;
#endif
*h_errnop = 0;
}
}
else {
/* failure - lookup */
#ifdef __WIN32__
*h_errnop = WSAGetLastError();
#else
*h_errnop = h_errno;
#endif
}
#ifdef _REENTRANT
/* === END critical section === */
ei_mutex_unlock(ei_gethost_sem);
#endif /* _REENTRANT */
return rval;
}
struct hostent * get_host_by_name(const char *name,
void *buf, int buflen, int *h_err)
{
/* gethostbyname() is not thread-safe, and there is no frelling standard
* for gethostbyname_r() -- the arg list varies from system to system!
*/
struct hostent *hptr;
int n = 0;
assert(name != NULL);
assert(buf != NULL);
slurm_mutex_lock(&hostentLock);
if ((hptr = gethostbyname(name)))
n = copy_hostent(hptr, buf, buflen);
if (h_err)
*h_err = h_errno;
slurm_mutex_unlock(&hostentLock);
if (n < 0) {
errno = ERANGE;
return(NULL);
}
return(hptr ? (struct hostent *) buf : NULL);
}
static struct hostent *
gethostbyaddr_r(char const *addr, int len, int type, struct hostent *result,
char *buffer, int buflen, int *error)
{
struct hostent *hp;
#ifdef HAVE_PTHREAD_H
if (fr_hostbyaddr == 0) {
pthread_mutex_init(&fr_hostbyaddr_mutex, NULL);
fr_hostbyaddr = 1;
}
pthread_mutex_lock(&fr_hostbyaddr_mutex);
#endif
hp = gethostbyaddr(addr, len, type);
if ((!hp) || (hp->h_addrtype != AF_INET) || (hp->h_length != 4)) {
*error = h_errno;
hp = NULL;
} else {
copy_hostent(hp, result, buffer, buflen, error);
hp = result;
}
#ifdef HAVE_PTHREAD_H
pthread_mutex_unlock(&fr_hostbyaddr_mutex);
#endif
return hp;
}
U8_EXPORT struct hostent *u8_gethostbyaddr(char *addr,int len,int type)
{
struct hostent _fetched, *fetched=&_fetched, *copied;
u8_lock_mutex(&netfns_lock);
fetched=gethostbyaddr(addr,len,type);
copied=((fetched==NULL) ? (NULL) :(copy_hostent(fetched)));
u8_unlock_mutex(&netfns_lock);
return copied;
}
U8_EXPORT struct hostent *u8_gethostbyname(u8_string hname,int type)
{
char *name=u8_tolibc(hname);
struct hostent *fetched, *copied;
char _buf[1024], *buf=_buf;
int bufsiz=0, herrno=0, retval;
#if HAVE_GETHOSTBYNAME2_R
struct hostent _fetched, *result; fetched=&_fetched;
if (type>0)
retval=
gethostbyname2_r(name,type,fetched,buf,1024,&result,&herrno);
else retval=gethostbyname_r(name,fetched,buf,1024,&result,&herrno);
while (retval==ERANGE) {
if (bufsiz) bufsiz=2048; else {u8_free(buf); bufsiz=bufsiz*2;}
buf=u8_malloc(bufsiz);
if (type>0)
retval=
gethostbyname2_r(name,type,fetched,buf,1024,&result,&herrno);
else retval=gethostbyname_r(name,fetched,buf,1024,&result,&herrno);}
if (result==NULL) {
if (bufsiz) u8_free(buf);
u8_graberr(herrno,"u8_gethostbyname",u8_strdup(hname));
return NULL;}
copied=((fetched==NULL) ? (NULL) :(copy_hostent(fetched)));
if (bufsiz) u8_free(buf);
#else
u8_lock_mutex(&netfns_lock);
fetched=gethostbyname(name);
if (fetched==NULL) {
u8_seterr(UnknownHost,"u8_gethostbyname",name);
u8_unlock_mutex(&netfns_lock);
return NULL;}
copied=copy_hostent(fetched);
u8_unlock_mutex(&netfns_lock);
#endif
u8_free(name);
return copied;
}
int ldap_pvt_gethostbyaddr_a(
const char *addr,
int len,
int type,
struct hostent *resbuf,
char **buf,
struct hostent **result,
int *herrno_ptr )
{
#if defined( HAVE_GETHOSTBYADDR_R )
# undef NEED_SAFE_REALLOC
# define NEED_SAFE_REALLOC
int r=-1;
int buflen=BUFSTART;
*buf = NULL;
for(;buflen<BUFMAX;) {
if (safe_realloc( buf, buflen )==NULL)
return r;
#if (GETHOSTBYADDR_R_NARGS < 8)
*result=gethostbyaddr_r( addr, len, type,
resbuf, *buf, buflen, herrno_ptr );
r = (*result == NULL) ? -1 : 0;
#else
r = gethostbyaddr_r( addr, len, type,
resbuf, *buf, buflen,
result, herrno_ptr );
#endif
#ifdef NETDB_INTERNAL
if ((r<0) &&
(*herrno_ptr==NETDB_INTERNAL) &&
(errno==ERANGE))
{
buflen*=2;
continue;
}
#endif
return r;
}
return -1;
#elif defined( LDAP_R_COMPILE )
# undef NEED_COPY_HOSTENT
# define NEED_COPY_HOSTENT
struct hostent *he;
int retval;
*buf = NULL;
ldap_pvt_thread_mutex_lock( &ldap_int_resolv_mutex );
he = gethostbyaddr( addr, len, type );
if (he==NULL) {
*herrno_ptr = h_errno;
retval = -1;
} else if (copy_hostent( resbuf, buf, he )<0) {
*herrno_ptr = -1;
retval = -1;
} else {
*result = resbuf;
retval = 0;
}
ldap_pvt_thread_mutex_unlock( &ldap_int_resolv_mutex );
return retval;
#else /* gethostbyaddr() */
*buf = NULL;
*result = gethostbyaddr( addr, len, type );
if (*result!=NULL) {
return 0;
}
return -1;
#endif
}
int ldap_pvt_gethostbyname_a(
const char *name,
struct hostent *resbuf,
char **buf,
struct hostent **result,
int *herrno_ptr )
{
#if defined( HAVE_GETHOSTBYNAME_R )
# define NEED_SAFE_REALLOC 1
int r=-1;
int buflen=BUFSTART;
*buf = NULL;
for(;buflen<BUFMAX;) {
if (safe_realloc( buf, buflen )==NULL)
return r;
#if (GETHOSTBYNAME_R_NARGS < 6)
*result=gethostbyname_r( name, resbuf, *buf, buflen, herrno_ptr );
r = (*result == 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",
name, r, 0 );
#ifdef NETDB_INTERNAL
if ((r<0) &&
(*herrno_ptr==NETDB_INTERNAL) &&
(errno==ERANGE))
{
buflen*=2;
continue;
}
#endif
return r;
}
return -1;
#elif defined( LDAP_R_COMPILE )
# define NEED_COPY_HOSTENT
struct hostent *he;
int retval;
*buf = NULL;
ldap_pvt_thread_mutex_lock( &ldap_int_resolv_mutex );
he = gethostbyname( name );
if (he==NULL) {
*herrno_ptr = h_errno;
retval = -1;
} else if (copy_hostent( resbuf, buf, he )<0) {
*herrno_ptr = -1;
retval = -1;
} else {
*result = resbuf;
retval = 0;
}
ldap_pvt_thread_mutex_unlock( &ldap_int_resolv_mutex );
return retval;
#else
*buf = NULL;
*result = gethostbyname( name );
if (*result!=NULL) {
return 0;
}
*herrno_ptr = h_errno;
return -1;
#endif
}
I_32 hysock_getnameinfo (hysockaddr_t in_addr, I_32 sockaddr_size, char *name,
I_32 name_length, int flags)
{
/* If we have the IPv6 functions available we will call them, otherwise we'll call the IPv4 function */
#if defined(IPv6_FUNCTION_SUPPORT)
int rc = 0;
rc =
getnameinfo ((OSADDR *) & in_addr->addr, sizeof (in_addr->addr), name,
name_length, NULL, 0, flags);
if (rc != 0)
{
rc = errno;
HYSOCKDEBUG ("<gethostbyaddr failed, err=%d>\n", rc);
return portLibrary->error_set_last_error (portLibrary, rc,
findError (rc));
}
return 0;
#else /* IPv6_FUNCTION_SUPPORT */
#if !HOSTENT_DATA_R
OSHOSTENT *result;
#endif
#if GLIBC_R||OTHER_R
BOOLEAN allocBuffer = FALSE;
#endif
int herr = 0;
int i = 0;
int rc = 0;
int length;
OSSOCKADDR *addr;
#if HOSTENT_DATA_R||GLIBC_R||OTHER_R||NO_R
PortlibPTBuffers_t ptBuffers;
#endif /* HOSTENT_DATA_R || GLIBC_R || OTHER_R || NO_R */
addr = (OSSOCKADDR *) & in_addr->addr;
if (addr->sin_family == OS_AF_INET4)
{
length = 4;
}
else
{
length = 16;
}
#if HOSTENT_DATA_R||GLIBC_R||OTHER_R||NO_R
ptBuffers = hyport_tls_get ();
if (NULL == ptBuffers)
{
return HYPORT_ERROR_SOCKET_SYSTEMFULL;
}
#define hostentBuffer (&ptBuffers->hostent)
#endif /* HOSTENT_DATA_R || GLIBC_R || OTHER_R || NO_R */
/* one of several threadsafe gethostbyaddr calls must be made depending on the current platform */
/* if there is a transient error (HYPORT_ERROR_SOCKET_UNIX_TRYAGAIN), try making the call again */
for (i = 0; i < MAX_RETRIES; i++)
{
#if HOSTENT_DATA_R
#define dataBuffer (ptBuffers->hostent_data)
if (!dataBuffer)
{
dataBuffer =
portLibrary->mem_allocate_memory (portLibrary,
sizeof (OSHOSTENT_DATA));
if (!dataBuffer)
{
return HYPORT_ERROR_SOCKET_SYSTEMFULL;
}
}
herr =
gethostbyaddr_r (&addr->sin_addr, length, addr->sin_family,
hostentBuffer, dataBuffer);
#undef dataBuffer
#elif ORIGINAL_R || NO_R
#if NO_R
MUTEX_ENTER (hostentLock);
#endif
result = gethostbyaddr (&addr->sin_addr, length, addr->sin_family);
#if NO_R
if (result)
{
herr = copy_hostent (result, &ptBuffers);
}
MUTEX_EXIT (hostentLock);
if (herr != 0)
{
return herr;
}
#endif
herr = h_errno;
#elif GLIBC_R || OTHER_R
#define buffer (ptBuffers->gethostBuffer)
#define bufferSize (ptBuffers->gethostBufferSize)
if (!buffer)
{
bufferSize = GET_HOST_BUFFER_SIZE;
}
while (TRUE)
{
if (allocBuffer == TRUE || !buffer)
{
/* The buffer is allocated bufferSize + EXTRA_SPACE, while gethostby*_r is only aware of bufferSize
* because there seems to be a bug on Linux 386 where gethostbyname_r writes past the end of the
* buffer. This bug has not been observed on other platforms, but EXTRA_SPACE is added anyway as a precaution.*/
buffer = XMLVM_ATOMIC_MALLOC(bufferSize + EXTRA_SPACE);
if (!buffer)
{
return HYPORT_ERROR_SOCKET_SYSTEMFULL;
}
allocBuffer = FALSE;
}
#if GLIBC_R
gethostbyaddr_r ((char *) &addr->sin_addr, length, addr->sin_family,
hostentBuffer, buffer, bufferSize, &result, &herr);
#elif OTHER_R
result =
gethostbyaddr_r ((char *) &addr->sin_addr, length,
addr->sin_family, hostentBuffer, buffer,
bufferSize, &herr);
#endif /* GLIBC_R */
/* allocate more space if the buffer is too small */
if (errno == ERANGE || herr == ERANGE)
{
XMLVM_FREE(buffer);
bufferSize *= 2;
allocBuffer = TRUE;
}
else
{
break;
}
}
#undef buffer
#undef bufferSize
#endif
if (herr != HYPORT_ERROR_SOCKET_UNIX_TRYAGAIN)
{
break;
}
}
#if HOSTENT_DATA_R
if (herr != 0)
{
herr = h_errno;
HYSOCKDEBUGH ("<gethostbyaddr failed, err=%d>\n", herr);
return portLibrary->error_set_last_error (portLibrary, herr,
findHostError (herr));
}
#else
if (result == NULL)
{
HYSOCKDEBUGH ("<gethostbyaddr failed, err=%d>\n", herr);
return hyerror_set_last_error(herr, findError(herr));
}
#endif
else
{
memset (name, 0, sizeof (char) * name_length);
#if HOSTENT_DATA_R||NO_R
strcpy (name, hostentBuffer->h_name);
#else
strcpy (name, result->h_name);
#endif
}
#if HOSTENT_DATA_R||GLIBC_R||OTHER_R
#undef hostentBuffer
#endif /*HOSTENT_DATA_R || GLIBC_R || OTHER_R */
return 0;
#endif /* IPv6_FUNCTION_SUPPORT */
}
