]> git.sur5r.net Git - openldap/blob - libraries/libldap/util-int.c
Merge remote-tracking branch 'origin/mdb.master'
[openldap] / libraries / libldap / util-int.c
1 /* $OpenLDAP$ */
2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3  *
4  * Copyright 1998-2012 The OpenLDAP Foundation.
5  * Portions Copyright 1998 A. Hartgers.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted only as authorized by the OpenLDAP
10  * Public License.
11  *
12  * A copy of this license is available in the file LICENSE in the
13  * top-level directory of the distribution or, alternatively, at
14  * <http://www.OpenLDAP.org/license.html>.
15  */
16 /* ACKNOWLEDGEMENTS:
17  * This work was initially developed by Bart Hartgers for inclusion in
18  * OpenLDAP Software.
19  */
20
21 /*
22  * util-int.c   Various functions to replace missing threadsafe ones.
23  *                              Without the real *_r funcs, things will
24  *                              work, but might not be threadsafe. 
25  */
26
27 #include "portable.h"
28
29 #include <ac/stdlib.h>
30
31 #include <ac/errno.h>
32 #include <ac/socket.h>
33 #include <ac/string.h>
34 #include <ac/time.h>
35 #include <ac/unistd.h>
36
37 #include "ldap-int.h"
38
39 #ifndef h_errno
40 /* newer systems declare this in <netdb.h> for you, older ones don't.
41  * harmless to declare it again (unless defined by a macro).
42  */
43 extern int h_errno;
44 #endif
45
46 #ifdef HAVE_HSTRERROR
47 # define HSTRERROR(e)   hstrerror(e)
48 #else
49 # define HSTRERROR(e)   hp_strerror(e)
50 #endif
51
52 #ifndef LDAP_R_COMPILE
53 # undef HAVE_REENTRANT_FUNCTIONS
54 # undef HAVE_CTIME_R
55 # undef HAVE_GETHOSTBYNAME_R
56 # undef HAVE_GETHOSTBYADDR_R
57
58 #else
59 # include <ldap_pvt_thread.h>
60   ldap_pvt_thread_mutex_t ldap_int_resolv_mutex;
61   ldap_pvt_thread_mutex_t ldap_int_hostname_mutex;
62   static ldap_pvt_thread_mutex_t ldap_int_gettime_mutex;
63
64 # if (defined( HAVE_CTIME_R ) || defined( HAVE_REENTRANT_FUNCTIONS)) \
65          && defined( CTIME_R_NARGS )
66 #   define USE_CTIME_R
67 # else
68         static ldap_pvt_thread_mutex_t ldap_int_ctime_mutex;
69 # endif
70
71 /* USE_GMTIME_R and USE_LOCALTIME_R defined in ldap_pvt.h */
72
73 #ifdef LDAP_DEVEL
74         /* to be released with 2.5 */
75 #if !defined( USE_GMTIME_R ) || !defined( USE_LOCALTIME_R )
76         /* we use the same mutex for gmtime(3) and localtime(3)
77          * because implementations may use the same buffer
78          * for both functions */
79         static ldap_pvt_thread_mutex_t ldap_int_gmtime_mutex;
80 #endif
81 #else /* ! LDAP_DEVEL */
82         ldap_pvt_thread_mutex_t ldap_int_gmtime_mutex;
83 #endif /* ! LDAP_DEVEL */
84
85 # if defined(HAVE_GETHOSTBYNAME_R) && \
86         (GETHOSTBYNAME_R_NARGS < 5) || (6 < GETHOSTBYNAME_R_NARGS)
87         /* Don't know how to handle this version, pretend it's not there */
88 #       undef HAVE_GETHOSTBYNAME_R
89 # endif
90 # if defined(HAVE_GETHOSTBYADDR_R) && \
91         (GETHOSTBYADDR_R_NARGS < 7) || (8 < GETHOSTBYADDR_R_NARGS)
92         /* Don't know how to handle this version, pretend it's not there */
93 #       undef HAVE_GETHOSTBYADDR_R
94 # endif
95 #endif /* LDAP_R_COMPILE */
96
97 char *ldap_pvt_ctime( const time_t *tp, char *buf )
98 {
99 #ifdef USE_CTIME_R
100 # if (CTIME_R_NARGS > 3) || (CTIME_R_NARGS < 2)
101 #       error "CTIME_R_NARGS should be 2 or 3"
102 # elif CTIME_R_NARGS > 2 && defined(CTIME_R_RETURNS_INT)
103         return( ctime_r(tp,buf,26) < 0 ? 0 : buf );
104 # elif CTIME_R_NARGS > 2
105         return ctime_r(tp,buf,26);
106 # else
107         return ctime_r(tp,buf);
108 # endif   
109
110 #else
111
112         LDAP_MUTEX_LOCK( &ldap_int_ctime_mutex );
113         AC_MEMCPY( buf, ctime(tp), 26 );
114         LDAP_MUTEX_UNLOCK( &ldap_int_ctime_mutex );
115
116         return buf;
117 #endif  
118 }
119
120 #if !defined( USE_GMTIME_R ) || !defined( USE_LOCALTIME_R )
121 int
122 ldap_pvt_gmtime_lock( void )
123 {
124 # ifndef LDAP_R_COMPILE
125         return 0;
126 # else /* LDAP_R_COMPILE */
127         return ldap_pvt_thread_mutex_lock( &ldap_int_gmtime_mutex );
128 # endif /* LDAP_R_COMPILE */
129 }
130
131 int
132 ldap_pvt_gmtime_unlock( void )
133 {
134 # ifndef LDAP_R_COMPILE
135         return 0;
136 # else /* LDAP_R_COMPILE */
137         return ldap_pvt_thread_mutex_unlock( &ldap_int_gmtime_mutex );
138 # endif /* LDAP_R_COMPILE */
139 }
140 #endif /* !USE_GMTIME_R || !USE_LOCALTIME_R */
141
142 #ifndef USE_GMTIME_R
143 struct tm *
144 ldap_pvt_gmtime( const time_t *timep, struct tm *result )
145 {
146         struct tm *tm_ptr;
147
148         LDAP_MUTEX_LOCK( &ldap_int_gmtime_mutex );
149         tm_ptr = gmtime( timep );
150         if ( tm_ptr == NULL ) {
151                 result = NULL;
152
153         } else {
154                 *result = *tm_ptr;
155         }
156         LDAP_MUTEX_UNLOCK( &ldap_int_gmtime_mutex );
157
158         return result;
159 }
160 #endif /* !USE_GMTIME_R */
161
162 #ifndef USE_LOCALTIME_R
163 struct tm *
164 ldap_pvt_localtime( const time_t *timep, struct tm *result )
165 {
166         struct tm *tm_ptr;
167
168         LDAP_MUTEX_LOCK( &ldap_int_gmtime_mutex );
169         tm_ptr = localtime( timep );
170         if ( tm_ptr == NULL ) {
171                 result = NULL;
172
173         } else {
174                 *result = *tm_ptr;
175         }
176         LDAP_MUTEX_UNLOCK( &ldap_int_gmtime_mutex );
177
178         return result;
179 }
180 #endif /* !USE_LOCALTIME_R */
181
182 /* return a broken out time, with microseconds
183  */
184 #ifdef _WIN32
185 /* Windows SYSTEMTIME only has 10 millisecond resolution, so we
186  * also need to use a high resolution timer to get microseconds.
187  * This is pretty clunky.
188  */
189 void
190 ldap_pvt_gettime( struct lutil_tm *tm )
191 {
192         static LARGE_INTEGER cFreq;
193         static LARGE_INTEGER prevCount;
194         static int subs;
195         static int offset;
196         LARGE_INTEGER count;
197         SYSTEMTIME st;
198
199         GetSystemTime( &st );
200         QueryPerformanceCounter( &count );
201
202         /* It shouldn't ever go backwards, but multiple CPUs might
203          * be able to hit in the same tick.
204          */
205         LDAP_MUTEX_LOCK( &ldap_int_gettime_mutex );
206         if ( count.QuadPart <= prevCount.QuadPart ) {
207                 subs++;
208         } else {
209                 subs = 0;
210                 prevCount = count;
211         }
212         LDAP_MUTEX_UNLOCK( &ldap_int_gettime_mutex );
213
214         /* We assume Windows has at least a vague idea of
215          * when a second begins. So we align our microsecond count
216          * with the Windows millisecond count using this offset.
217          * We retain the submillisecond portion of our own count.
218          *
219          * Note - this also assumes that the relationship between
220          * the PerformanceCouunter and SystemTime stays constant;
221          * that assumption breaks if the SystemTime is adjusted by
222          * an external action.
223          */
224         if ( !cFreq.QuadPart ) {
225                 long long t;
226                 int usec;
227                 QueryPerformanceFrequency( &cFreq );
228
229                 /* just get sub-second portion of counter */
230                 t = count.QuadPart % cFreq.QuadPart;
231
232                 /* convert to microseconds */
233                 t *= 1000000;
234                 usec = t / cFreq.QuadPart;
235
236                 offset = usec - st.wMilliseconds * 1000;
237         }
238
239         tm->tm_usub = subs;
240
241         /* convert to microseconds */
242         count.QuadPart %= cFreq.QuadPart;
243         count.QuadPart *= 1000000;
244         count.QuadPart /= cFreq.QuadPart;
245         count.QuadPart -= offset;
246
247         tm->tm_usec = count.QuadPart % 1000000;
248         if ( tm->tm_usec < 0 )
249                 tm->tm_usec += 1000000;
250
251         /* any difference larger than microseconds is
252          * already reflected in st
253          */
254
255         tm->tm_sec = st.wSecond;
256         tm->tm_min = st.wMinute;
257         tm->tm_hour = st.wHour;
258         tm->tm_mday = st.wDay;
259         tm->tm_mon = st.wMonth - 1;
260         tm->tm_year = st.wYear - 1900;
261 }
262 #else
263 void
264 ldap_pvt_gettime( struct lutil_tm *ltm )
265 {
266         struct timeval tv;
267         static struct timeval prevTv;
268         static int subs;
269
270         struct tm tm;
271         time_t t;
272
273         gettimeofday( &tv, NULL );
274         t = tv.tv_sec;
275
276         LDAP_MUTEX_LOCK( &ldap_int_gettime_mutex );
277         if ( tv.tv_sec < prevTv.tv_sec
278                 || ( tv.tv_sec == prevTv.tv_sec && tv.tv_usec <= prevTv.tv_usec )) {
279                 subs++;
280         } else {
281                 subs = 0;
282                 prevTv = tv;
283         }
284         LDAP_MUTEX_UNLOCK( &ldap_int_gettime_mutex );
285
286         ltm->tm_usub = subs;
287
288         ldap_pvt_gmtime( &t, &tm );
289
290         ltm->tm_sec = tm.tm_sec;
291         ltm->tm_min = tm.tm_min;
292         ltm->tm_hour = tm.tm_hour;
293         ltm->tm_mday = tm.tm_mday;
294         ltm->tm_mon = tm.tm_mon;
295         ltm->tm_year = tm.tm_year;
296         ltm->tm_usec = tv.tv_usec;
297 }
298 #endif
299
300 size_t
301 ldap_pvt_csnstr(char *buf, size_t len, unsigned int replica, unsigned int mod)
302 {
303         struct lutil_tm tm;
304         int n;
305
306         ldap_pvt_gettime( &tm );
307
308         n = snprintf( buf, len,
309                 "%4d%02d%02d%02d%02d%02d.%06dZ#%06x#%03x#%06x",
310                 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,
311                 tm.tm_min, tm.tm_sec, tm.tm_usec, tm.tm_usub, replica, mod );
312
313         if( n < 0 ) return 0;
314         return ( (size_t) n < len ) ? n : 0;
315 }
316
317 #define BUFSTART (1024-32)
318 #define BUFMAX (32*1024-32)
319
320 #if defined(LDAP_R_COMPILE)
321 static char *safe_realloc( char **buf, int len );
322
323 #if !(defined(HAVE_GETHOSTBYNAME_R) && defined(HAVE_GETHOSTBYADDR_R))
324 static int copy_hostent( struct hostent *res,
325         char **buf, struct hostent * src );
326 #endif
327 #endif
328
329 int ldap_pvt_gethostbyname_a(
330         const char *name, 
331         struct hostent *resbuf,
332         char **buf,
333         struct hostent **result,
334         int *herrno_ptr )
335 {
336 #if defined( HAVE_GETHOSTBYNAME_R )
337
338 # define NEED_SAFE_REALLOC 1   
339         int r=-1;
340         int buflen=BUFSTART;
341         *buf = NULL;
342         for(;buflen<BUFMAX;) {
343                 if (safe_realloc( buf, buflen )==NULL)
344                         return r;
345
346 #if (GETHOSTBYNAME_R_NARGS < 6)
347                 *result=gethostbyname_r( name, resbuf, *buf, buflen, herrno_ptr );
348                 r = (*result == NULL) ?  -1 : 0;
349 #else
350                 r = gethostbyname_r( name, resbuf, *buf,
351                         buflen, result, herrno_ptr );
352 #endif
353
354                 Debug( LDAP_DEBUG_TRACE, "ldap_pvt_gethostbyname_a: host=%s, r=%d\n",
355                        name, r, 0 );
356
357 #ifdef NETDB_INTERNAL
358                 if ((r<0) &&
359                         (*herrno_ptr==NETDB_INTERNAL) &&
360                         (errno==ERANGE))
361                 {
362                         buflen*=2;
363                         continue;
364                 }
365 #endif
366                 return r;
367         }
368         return -1;
369 #elif defined( LDAP_R_COMPILE )
370 # define NEED_COPY_HOSTENT   
371         struct hostent *he;
372         int     retval;
373         *buf = NULL;
374         
375         LDAP_MUTEX_LOCK( &ldap_int_resolv_mutex );
376         
377         he = gethostbyname( name );
378         
379         if (he==NULL) {
380                 *herrno_ptr = h_errno;
381                 retval = -1;
382         } else if (copy_hostent( resbuf, buf, he )<0) {
383                 *herrno_ptr = -1;
384                 retval = -1;
385         } else {
386                 *result = resbuf;
387                 retval = 0;
388         }
389         
390         LDAP_MUTEX_UNLOCK( &ldap_int_resolv_mutex );
391         
392         return retval;
393 #else   
394         *buf = NULL;
395         *result = gethostbyname( name );
396
397         if (*result!=NULL) {
398                 return 0;
399         }
400
401         *herrno_ptr = h_errno;
402         
403         return -1;
404 #endif  
405 }
406
407 #if !defined( HAVE_GETNAMEINFO ) && !defined( HAVE_HSTRERROR )
408 static const char *
409 hp_strerror( int err )
410 {
411         switch (err) {
412         case HOST_NOT_FOUND:    return _("Host not found (authoritative)");
413         case TRY_AGAIN:                 return _("Host not found (server fail?)");
414         case NO_RECOVERY:               return _("Non-recoverable failure");
415         case NO_DATA:                   return _("No data of requested type");
416 #ifdef NETDB_INTERNAL
417         case NETDB_INTERNAL:    return STRERROR( errno );
418 #endif
419         }
420         return _("Unknown resolver error");
421 }
422 #endif
423
424 int ldap_pvt_get_hname(
425         const struct sockaddr *sa,
426         int len,
427         char *name,
428         int namelen,
429         char **err )
430 {
431         int rc;
432 #if defined( HAVE_GETNAMEINFO )
433
434         LDAP_MUTEX_LOCK( &ldap_int_resolv_mutex );
435         rc = getnameinfo( sa, len, name, namelen, NULL, 0, 0 );
436         LDAP_MUTEX_UNLOCK( &ldap_int_resolv_mutex );
437         if ( rc ) *err = (char *)AC_GAI_STRERROR( rc );
438         return rc;
439
440 #else /* !HAVE_GETNAMEINFO */
441         char *addr;
442         int alen;
443         struct hostent *hp = NULL;
444 #ifdef HAVE_GETHOSTBYADDR_R
445         struct hostent hb;
446         int buflen=BUFSTART, h_errno;
447         char *buf=NULL;
448 #endif
449
450 #ifdef LDAP_PF_INET6
451         if (sa->sa_family == AF_INET6) {
452                 struct sockaddr_in6 *sin = (struct sockaddr_in6 *)sa;
453                 addr = (char *)&sin->sin6_addr;
454                 alen = sizeof(sin->sin6_addr);
455         } else
456 #endif
457         if (sa->sa_family == AF_INET) {
458                 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
459                 addr = (char *)&sin->sin_addr;
460                 alen = sizeof(sin->sin_addr);
461         } else {
462                 rc = NO_RECOVERY;
463                 *err = (char *)HSTRERROR( rc );
464                 return rc;
465         }
466 #if defined( HAVE_GETHOSTBYADDR_R )
467         for(;buflen<BUFMAX;) {
468                 if (safe_realloc( &buf, buflen )==NULL) {
469                         *err = (char *)STRERROR( ENOMEM );
470                         return ENOMEM;
471                 }
472 #if (GETHOSTBYADDR_R_NARGS < 8)
473                 hp=gethostbyaddr_r( addr, alen, sa->sa_family,
474                         &hb, buf, buflen, &h_errno );
475                 rc = (hp == NULL) ? -1 : 0;
476 #else
477                 rc = gethostbyaddr_r( addr, alen, sa->sa_family,
478                         &hb, buf, buflen, 
479                         &hp, &h_errno );
480 #endif
481 #ifdef NETDB_INTERNAL
482                 if ((rc<0) &&
483                         (h_errno==NETDB_INTERNAL) &&
484                         (errno==ERANGE))
485                 {
486                         buflen*=2;
487                         continue;
488                 }
489 #endif
490                 break;
491         }
492         if (hp) {
493                 strncpy( name, hp->h_name, namelen );
494         } else {
495                 *err = (char *)HSTRERROR( h_errno );
496         }
497         LDAP_FREE(buf);
498 #else /* HAVE_GETHOSTBYADDR_R */
499
500         LDAP_MUTEX_LOCK( &ldap_int_resolv_mutex );
501         hp = gethostbyaddr( addr, alen, sa->sa_family );
502         if (hp) {
503                 strncpy( name, hp->h_name, namelen );
504                 rc = 0;
505         } else {
506                 rc = h_errno;
507                 *err = (char *)HSTRERROR( h_errno );
508         }
509         LDAP_MUTEX_UNLOCK( &ldap_int_resolv_mutex );
510
511 #endif  /* !HAVE_GETHOSTBYADDR_R */
512         return rc;
513 #endif  /* !HAVE_GETNAMEINFO */
514 }
515
516 int ldap_pvt_gethostbyaddr_a(
517         const char *addr,
518         int len,
519         int type,
520         struct hostent *resbuf,
521         char **buf,
522         struct hostent **result,
523         int *herrno_ptr )
524 {
525 #if defined( HAVE_GETHOSTBYADDR_R )
526
527 # undef NEED_SAFE_REALLOC
528 # define NEED_SAFE_REALLOC   
529         int r=-1;
530         int buflen=BUFSTART;
531         *buf = NULL;   
532         for(;buflen<BUFMAX;) {
533                 if (safe_realloc( buf, buflen )==NULL)
534                         return r;
535 #if (GETHOSTBYADDR_R_NARGS < 8)
536                 *result=gethostbyaddr_r( addr, len, type,
537                         resbuf, *buf, buflen, herrno_ptr );
538                 r = (*result == NULL) ? -1 : 0;
539 #else
540                 r = gethostbyaddr_r( addr, len, type,
541                         resbuf, *buf, buflen, 
542                         result, herrno_ptr );
543 #endif
544
545 #ifdef NETDB_INTERNAL
546                 if ((r<0) &&
547                         (*herrno_ptr==NETDB_INTERNAL) &&
548                         (errno==ERANGE))
549                 {
550                         buflen*=2;
551                         continue;
552                 }
553 #endif
554                 return r;
555         }
556         return -1;
557 #elif defined( LDAP_R_COMPILE )
558 # undef NEED_COPY_HOSTENT
559 # define NEED_COPY_HOSTENT   
560         struct hostent *he;
561         int     retval;
562         *buf = NULL;   
563         
564         LDAP_MUTEX_LOCK( &ldap_int_resolv_mutex );
565         he = gethostbyaddr( addr, len, type );
566         
567         if (he==NULL) {
568                 *herrno_ptr = h_errno;
569                 retval = -1;
570         } else if (copy_hostent( resbuf, buf, he )<0) {
571                 *herrno_ptr = -1;
572                 retval = -1;
573         } else {
574                 *result = resbuf;
575                 retval = 0;
576         }
577         LDAP_MUTEX_UNLOCK( &ldap_int_resolv_mutex );
578         
579         return retval;
580
581 #else /* gethostbyaddr() */
582         *buf = NULL;   
583         *result = gethostbyaddr( addr, len, type );
584
585         if (*result!=NULL) {
586                 return 0;
587         }
588         return -1;
589 #endif  
590 }
591 /* 
592  * ldap_int_utils_init() should be called before any other function.
593  */
594
595 void ldap_int_utils_init( void )
596 {
597         static int done=0;
598         if (done)
599           return;
600         done=1;
601
602 #ifdef LDAP_R_COMPILE
603 #if !defined( USE_CTIME_R ) && !defined( HAVE_REENTRANT_FUNCTIONS )
604         ldap_pvt_thread_mutex_init( &ldap_int_ctime_mutex );
605 #endif
606 #if !defined( USE_GMTIME_R ) && !defined( USE_LOCALTIME_R )
607         ldap_pvt_thread_mutex_init( &ldap_int_gmtime_mutex );
608 #endif
609         ldap_pvt_thread_mutex_init( &ldap_int_resolv_mutex );
610
611         ldap_pvt_thread_mutex_init( &ldap_int_hostname_mutex );
612
613         ldap_pvt_thread_mutex_init( &ldap_int_gettime_mutex );
614
615 #ifdef HAVE_CYRUS_SASL
616         ldap_pvt_thread_mutex_init( &ldap_int_sasl_mutex );
617 #endif
618 #ifdef HAVE_GSSAPI
619         ldap_pvt_thread_mutex_init( &ldap_int_gssapi_mutex );
620 #endif
621 #endif
622
623         /* call other module init functions here... */
624 }
625
626 #if defined( NEED_COPY_HOSTENT )
627 # undef NEED_SAFE_REALLOC
628 #define NEED_SAFE_REALLOC
629
630 static char *cpy_aliases(
631         char ***tgtio,
632         char *buf,
633         char **src )
634 {
635         int len;
636         char **tgt=*tgtio;
637         for( ; (*src) ; src++ ) {
638                 len = strlen( *src ) + 1;
639                 AC_MEMCPY( buf, *src, len );
640                 *tgt++=buf;
641                 buf+=len;
642         }
643         *tgtio=tgt;   
644         return buf;
645 }
646
647 static char *cpy_addresses(
648         char ***tgtio,
649         char *buf,
650         char **src,
651         int len )
652 {
653         char **tgt=*tgtio;
654         for( ; (*src) ; src++ ) {
655                 AC_MEMCPY( buf, *src, len );
656                 *tgt++=buf;
657                 buf+=len;
658         }
659         *tgtio=tgt;      
660         return buf;
661 }
662
663 static int copy_hostent(
664         struct hostent *res,
665         char **buf,
666         struct hostent * src )
667 {
668         char    **p;
669         char    **tp;
670         char    *tbuf;
671         int     name_len;
672         int     n_alias=0;
673         int     total_alias_len=0;
674         int     n_addr=0;
675         int     total_addr_len=0;
676         int     total_len;
677           
678         /* calculate the size needed for the buffer */
679         name_len = strlen( src->h_name ) + 1;
680         
681         if( src->h_aliases != NULL ) {
682                 for( p = src->h_aliases; (*p) != NULL; p++ ) {
683                         total_alias_len += strlen( *p ) + 1;
684                         n_alias++; 
685                 }
686         }
687
688         if( src->h_addr_list != NULL ) {
689                 for( p = src->h_addr_list; (*p) != NULL; p++ ) {
690                         n_addr++;
691                 }
692                 total_addr_len = n_addr * src->h_length;
693         }
694         
695         total_len = (n_alias + n_addr + 2) * sizeof( char * ) +
696                 total_addr_len + total_alias_len + name_len;
697         
698         if (safe_realloc( buf, total_len )) {                    
699                 tp = (char **) *buf;
700                 tbuf = *buf + (n_alias + n_addr + 2) * sizeof( char * );
701                 AC_MEMCPY( res, src, sizeof( struct hostent ) );
702                 /* first the name... */
703                 AC_MEMCPY( tbuf, src->h_name, name_len );
704                 res->h_name = tbuf; tbuf+=name_len;
705                 /* now the aliases */
706                 res->h_aliases = tp;
707                 if ( src->h_aliases != NULL ) {
708                         tbuf = cpy_aliases( &tp, tbuf, src->h_aliases );
709                 }
710                 *tp++=NULL;
711                 /* finally the addresses */
712                 res->h_addr_list = tp;
713                 if ( src->h_addr_list != NULL ) {
714                         tbuf = cpy_addresses( &tp, tbuf, src->h_addr_list, src->h_length );
715                 }
716                 *tp++=NULL;
717                 return 0;
718         }
719         return -1;
720 }
721 #endif
722
723 #if defined( NEED_SAFE_REALLOC )
724 static char *safe_realloc( char **buf, int len )
725 {
726         char *tmpbuf;
727         tmpbuf = LDAP_REALLOC( *buf, len );
728         if (tmpbuf) {
729                 *buf=tmpbuf;
730         } 
731         return tmpbuf;
732 }
733 #endif
734
735 char * ldap_pvt_get_fqdn( char *name )
736 {
737         char *fqdn, *ha_buf;
738         char hostbuf[MAXHOSTNAMELEN+1];
739         struct hostent *hp, he_buf;
740         int rc, local_h_errno;
741
742         if( name == NULL ) {
743                 if( gethostname( hostbuf, MAXHOSTNAMELEN ) == 0 ) {
744                         hostbuf[MAXHOSTNAMELEN] = '\0';
745                         name = hostbuf;
746                 } else {
747                         name = "localhost";
748                 }
749         }
750
751         rc = ldap_pvt_gethostbyname_a( name,
752                 &he_buf, &ha_buf, &hp, &local_h_errno );
753
754         if( rc < 0 || hp == NULL || hp->h_name == NULL ) {
755                 fqdn = LDAP_STRDUP( name );
756         } else {
757                 fqdn = LDAP_STRDUP( hp->h_name );
758         }
759
760         LDAP_FREE( ha_buf );
761         return fqdn;
762 }
763
764 #if ( defined( HAVE_GETADDRINFO ) || defined( HAVE_GETNAMEINFO ) ) \
765         && !defined( HAVE_GAI_STRERROR )
766 char *ldap_pvt_gai_strerror (int code) {
767         static struct {
768                 int code;
769                 const char *msg;
770         } values[] = {
771 #ifdef EAI_ADDRFAMILY
772                 { EAI_ADDRFAMILY, N_("Address family for hostname not supported") },
773 #endif
774                 { EAI_AGAIN, N_("Temporary failure in name resolution") },
775                 { EAI_BADFLAGS, N_("Bad value for ai_flags") },
776                 { EAI_FAIL, N_("Non-recoverable failure in name resolution") },
777                 { EAI_FAMILY, N_("ai_family not supported") },
778                 { EAI_MEMORY, N_("Memory allocation failure") },
779 #ifdef EAI_NODATA
780                 { EAI_NODATA, N_("No address associated with hostname") },
781 #endif    
782                 { EAI_NONAME, N_("Name or service not known") },
783                 { EAI_SERVICE, N_("Servname not supported for ai_socktype") },
784                 { EAI_SOCKTYPE, N_("ai_socktype not supported") },
785 #ifdef EAI_SYSTEM
786                 { EAI_SYSTEM, N_("System error") },
787 #endif
788                 { 0, NULL }
789         };
790
791         int i;
792
793         for ( i = 0; values[i].msg != NULL; i++ ) {
794                 if ( values[i].code == code ) {
795                         return (char *) _(values[i].msg);
796                 }
797         }
798         
799         return _("Unknown error");
800 }
801 #endif