Back to index

openldap  2.4.31
Defines | Functions | Variables
util-int.c File Reference
#include "portable.h"
#include <ac/stdlib.h>
#include <ac/errno.h>
#include <ac/socket.h>
#include <ac/string.h>
#include <ac/time.h>
#include <ac/unistd.h>
#include "ldap-int.h"

Go to the source code of this file.

Defines

#define HSTRERROR(e)   hp_strerror(e)
#define BUFSTART   (1024-32)
#define BUFMAX   (32*1024-32)

Functions

char * ldap_pvt_ctime (const time_t *tp, char *buf)
int ldap_pvt_gmtime_lock (void)
int ldap_pvt_gmtime_unlock (void)
struct tmldap_pvt_gmtime (const time_t *timep, struct tm *result)
struct tmldap_pvt_localtime (const time_t *timep, struct tm *result)
void ldap_pvt_gettime (struct lutil_tm *ltm)
size_t ldap_pvt_csnstr (char *buf, size_t len, unsigned int replica, unsigned int mod)
int ldap_pvt_gethostbyname_a (const char *name, struct hostent *resbuf, char **buf, struct hostent **result, int *herrno_ptr)
static const char * hp_strerror (int err)
int ldap_pvt_get_hname (const struct sockaddr *sa, int len, char *name, int namelen, char **err)
int ldap_pvt_gethostbyaddr_a (const char *addr, int len, int type, struct hostent *resbuf, char **buf, struct hostent **result, int *herrno_ptr)
void ldap_int_utils_init (void)
char * ldap_pvt_get_fqdn (char *name)

Variables

int h_errno

Define Documentation

#define BUFMAX   (32*1024-32)

Definition at line 313 of file util-int.c.

#define BUFSTART   (1024-32)

Definition at line 312 of file util-int.c.

#define HSTRERROR (   e)    hp_strerror(e)

Definition at line 49 of file util-int.c.


Function Documentation

static const char* hp_strerror ( int  err) [static]

Definition at line 404 of file util-int.c.

{
       switch (err) {
       case HOST_NOT_FOUND: return _("Host not found (authoritative)");
       case TRY_AGAIN:                    return _("Host not found (server fail?)");
       case NO_RECOVERY:           return _("Non-recoverable failure");
       case NO_DATA:               return _("No data of requested type");
#ifdef NETDB_INTERNAL
       case NETDB_INTERNAL: return STRERROR( errno );
#endif
       }
       return _("Unknown resolver error");
}

Definition at line 590 of file util-int.c.

{
       static int done=0;
       if (done)
         return;
       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( USE_GMTIME_R ) && !defined( USE_LOCALTIME_R )
       ldap_pvt_thread_mutex_init( &ldap_int_gmtime_mutex );
#endif
       ldap_pvt_thread_mutex_init( &ldap_int_resolv_mutex );

#ifdef HAVE_CYRUS_SASL
       ldap_pvt_thread_mutex_init( &ldap_int_sasl_mutex );
#endif
#ifdef HAVE_GSSAPI
       ldap_pvt_thread_mutex_init( &ldap_int_gssapi_mutex );
#endif
#endif

       /* call other module init functions here... */
}

Here is the caller graph for this function:

size_t ldap_pvt_csnstr ( char *  buf,
size_t  len,
unsigned int  replica,
unsigned int  mod 
)

Definition at line 296 of file util-int.c.

{
       struct lutil_tm tm;
       int n;

       ldap_pvt_gettime( &tm );

       n = snprintf( buf, len,
              "%4d%02d%02d%02d%02d%02d.%06dZ#%06x#%03x#%06x",
              tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,
              tm.tm_min, tm.tm_sec, tm.tm_usec, tm.tm_usub, replica, mod );

       if( n < 0 ) return 0;
       return ( (size_t) n < len ) ? n : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* ldap_pvt_ctime ( const time_t *  tp,
char *  buf 
)

Definition at line 95 of file util-int.c.

{
#ifdef USE_CTIME_R
# if (CTIME_R_NARGS > 3) || (CTIME_R_NARGS < 2)
#      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
       return ctime_r(tp,buf,26);
# else
       return ctime_r(tp,buf);
# endif         

#else

       LDAP_MUTEX_LOCK( &ldap_int_ctime_mutex );
       AC_MEMCPY( buf, ctime(tp), 26 );
       LDAP_MUTEX_UNLOCK( &ldap_int_ctime_mutex );

       return buf;
#endif 
}
char* ldap_pvt_get_fqdn ( char *  name)

Definition at line 726 of file util-int.c.

{
       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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ldap_pvt_get_hname ( const struct sockaddr *  sa,
int  len,
char *  name,
int  namelen,
char **  err 
)

Definition at line 419 of file util-int.c.

{
       int rc;
#if defined( HAVE_GETNAMEINFO )

       LDAP_MUTEX_LOCK( &ldap_int_resolv_mutex );
       rc = getnameinfo( sa, len, name, namelen, NULL, 0, 0 );
       LDAP_MUTEX_UNLOCK( &ldap_int_resolv_mutex );
       if ( rc ) *err = (char *)AC_GAI_STRERROR( rc );
       return rc;

#else /* !HAVE_GETNAMEINFO */
       char *addr;
       int alen;
       struct hostent *hp = NULL;
#ifdef HAVE_GETHOSTBYADDR_R
       struct hostent hb;
       int buflen=BUFSTART, h_errno;
       char *buf=NULL;
#endif

#ifdef LDAP_PF_INET6
       if (sa->sa_family == AF_INET6) {
              struct sockaddr_in6 *sin = (struct sockaddr_in6 *)sa;
              addr = (char *)&sin->sin6_addr;
              alen = sizeof(sin->sin6_addr);
       } else
#endif
       if (sa->sa_family == AF_INET) {
              struct sockaddr_in *sin = (struct sockaddr_in *)sa;
              addr = (char *)&sin->sin_addr;
              alen = sizeof(sin->sin_addr);
       } else {
              rc = NO_RECOVERY;
              *err = (char *)HSTRERROR( rc );
              return rc;
       }
#if defined( HAVE_GETHOSTBYADDR_R )
       for(;buflen<BUFMAX;) {
              if (safe_realloc( &buf, buflen )==NULL) {
                     *err = (char *)STRERROR( ENOMEM );
                     return ENOMEM;
              }
#if (GETHOSTBYADDR_R_NARGS < 8)
              hp=gethostbyaddr_r( addr, alen, sa->sa_family,
                     &hb, buf, buflen, &h_errno );
              rc = (hp == NULL) ? -1 : 0;
#else
              rc = gethostbyaddr_r( addr, alen, sa->sa_family,
                     &hb, buf, buflen, 
                     &hp, &h_errno );
#endif
#ifdef NETDB_INTERNAL
              if ((rc<0) &&
                     (h_errno==NETDB_INTERNAL) &&
                     (errno==ERANGE))
              {
                     buflen*=2;
                     continue;
              }
#endif
              break;
       }
       if (hp) {
              strncpy( name, hp->h_name, namelen );
       } else {
              *err = (char *)HSTRERROR( h_errno );
       }
       LDAP_FREE(buf);
#else /* HAVE_GETHOSTBYADDR_R */

       LDAP_MUTEX_LOCK( &ldap_int_resolv_mutex );
       hp = gethostbyaddr( addr, alen, sa->sa_family );
       if (hp) {
              strncpy( name, hp->h_name, namelen );
              rc = 0;
       } else {
              rc = h_errno;
              *err = (char *)HSTRERROR( h_errno );
       }
       LDAP_MUTEX_UNLOCK( &ldap_int_resolv_mutex );

#endif /* !HAVE_GETHOSTBYADDR_R */
       return rc;
#endif /* !HAVE_GETNAMEINFO */
}

Here is the caller graph for this function:

int ldap_pvt_gethostbyaddr_a ( const char *  addr,
int  len,
int  type,
struct hostent *  resbuf,
char **  buf,
struct hostent **  result,
int herrno_ptr 
)

Definition at line 511 of file util-int.c.

{
#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_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_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 
)

Definition at line 324 of file util-int.c.

{
#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_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_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 
}

Here is the caller graph for this function:

void ldap_pvt_gettime ( struct lutil_tm ltm)

Definition at line 261 of file util-int.c.

{
       struct timeval tv;
       static struct timeval prevTv;
       static int subs;

       struct tm tm;
       time_t t;

       gettimeofday( &tv, NULL );
       t = tv.tv_sec;

       if ( tv.tv_sec < prevTv.tv_sec
              || ( tv.tv_sec == prevTv.tv_sec && tv.tv_usec <= prevTv.tv_usec )) {
              subs++;
       } else {
              subs = 0;
              prevTv = tv;
       }

       ltm->tm_usub = subs;

       ldap_pvt_gmtime( &t, &tm );

       ltm->tm_sec = tm.tm_sec;
       ltm->tm_min = tm.tm_min;
       ltm->tm_hour = tm.tm_hour;
       ltm->tm_mday = tm.tm_mday;
       ltm->tm_mon = tm.tm_mon;
       ltm->tm_year = tm.tm_year;
       ltm->tm_usec = tv.tv_usec;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct tm* ldap_pvt_gmtime ( const time_t *  timep,
struct tm result 
) [read]

Definition at line 142 of file util-int.c.

{
       struct tm *tm_ptr;

       LDAP_MUTEX_LOCK( &ldap_int_gmtime_mutex );
       tm_ptr = gmtime( timep );
       if ( tm_ptr == NULL ) {
              result = NULL;

       } else {
              *result = *tm_ptr;
       }
       LDAP_MUTEX_UNLOCK( &ldap_int_gmtime_mutex );

       return result;
}

Here is the caller graph for this function:

Definition at line 120 of file util-int.c.

{
# ifndef LDAP_R_COMPILE
       return 0;
# else /* LDAP_R_COMPILE */
       return ldap_pvt_thread_mutex_lock( &ldap_int_gmtime_mutex );
# endif /* LDAP_R_COMPILE */
}

Definition at line 130 of file util-int.c.

{
# ifndef LDAP_R_COMPILE
       return 0;
# else /* LDAP_R_COMPILE */
       return ldap_pvt_thread_mutex_unlock( &ldap_int_gmtime_mutex );
# endif /* LDAP_R_COMPILE */
}
struct tm* ldap_pvt_localtime ( const time_t *  timep,
struct tm result 
) [read]

Definition at line 162 of file util-int.c.

{
       struct tm *tm_ptr;

       LDAP_MUTEX_LOCK( &ldap_int_gmtime_mutex );
       tm_ptr = localtime( timep );
       if ( tm_ptr == NULL ) {
              result = NULL;

       } else {
              *result = *tm_ptr;
       }
       LDAP_MUTEX_UNLOCK( &ldap_int_gmtime_mutex );

       return result;
}

Variable Documentation