1 /* $OpenLDAP: pkg/ldap/libraries/libldap/util-int.c,v 1.57.2.3 2008/02/11 23:26:41 kurt Exp $ */ 2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 3 * 4 * Copyright 1998-2008 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 62 # if (defined( HAVE_CTIME_R ) || defined( HAVE_REENTRANT_FUNCTIONS)) \ 63 && defined( CTIME_R_NARGS ) 64 # define USE_CTIME_R 65 # else 66 static ldap_pvt_thread_mutex_t ldap_int_ctime_mutex; 67 # endif 68 69 # if defined(HAVE_GETHOSTBYNAME_R) && \ 70 (GETHOSTBYNAME_R_NARGS < 5) || (6 < GETHOSTBYNAME_R_NARGS) 71 /* Don't know how to handle this version, pretend it's not there */ 72 # undef HAVE_GETHOSTBYNAME_R 73 # endif 74 # if defined(HAVE_GETHOSTBYADDR_R) && \ 75 (GETHOSTBYADDR_R_NARGS < 7) || (8 < GETHOSTBYADDR_R_NARGS) 76 /* Don't know how to handle this version, pretend it's not there */ 77 # undef HAVE_GETHOSTBYADDR_R 78 # endif 79 #endif /* LDAP_R_COMPILE */ 80 81 char *ldap_pvt_ctime( const time_t *tp, char *buf ) 82 { 83 #ifdef USE_CTIME_R 84 # if (CTIME_R_NARGS > 3) || (CTIME_R_NARGS < 2) 85 # error "CTIME_R_NARGS should be 2 or 3" 86 # elif CTIME_R_NARGS > 2 && defined(CTIME_R_RETURNS_INT) 87 return( ctime_r(tp,buf,26) < 0 ? 0 : buf ); 88 # elif CTIME_R_NARGS > 2 89 return ctime_r(tp,buf,26); 90 # else 91 return ctime_r(tp,buf); 92 # endif 93 94 #else 95 96 # ifdef LDAP_R_COMPILE 97 ldap_pvt_thread_mutex_lock( &ldap_int_ctime_mutex ); 98 # endif 99 100 AC_MEMCPY( buf, ctime(tp), 26 ); 101 102 # ifdef LDAP_R_COMPILE 103 ldap_pvt_thread_mutex_unlock( &ldap_int_ctime_mutex ); 104 # endif 105 106 return buf; 107 #endif 108 } 109 110 #define BUFSTART (1024-32) 111 #define BUFMAX (32*1024-32) 112 113 #if defined(LDAP_R_COMPILE) 114 static char *safe_realloc( char **buf, int len ); 115 116 #if !(defined(HAVE_GETHOSTBYNAME_R) && defined(HAVE_GETHOSTBYADDR_R)) 117 static int copy_hostent( struct hostent *res, 118 char **buf, struct hostent * src ); 119 #endif 120 #endif 121 122 int ldap_pvt_gethostbyname_a( 123 const char *name, 124 struct hostent *resbuf, 125 char **buf, 126 struct hostent **result, 127 int *herrno_ptr ) 128 { 129 #if defined( HAVE_GETHOSTBYNAME_R ) 130 131 # define NEED_SAFE_REALLOC 1 132 int r=-1; 133 int buflen=BUFSTART; 134 *buf = NULL; 135 for(;buflen<BUFMAX;) { 136 if (safe_realloc( buf, buflen )==NULL) 137 return r; 138 139 #if (GETHOSTBYNAME_R_NARGS < 6) 140 *result=gethostbyname_r( name, resbuf, *buf, buflen, herrno_ptr ); 141 r = (*result == NULL) ? -1 : 0; 142 #else 143 r = gethostbyname_r( name, resbuf, *buf, 144 buflen, result, herrno_ptr ); 145 #endif 146 147 Debug( LDAP_DEBUG_TRACE, "ldap_pvt_gethostbyname_a: host=%s, r=%d\n", 148 name, r, 0 ); 149 150 #ifdef NETDB_INTERNAL 151 if ((r<0) && 152 (*herrno_ptr==NETDB_INTERNAL) && 153 (errno==ERANGE)) 154 { 155 buflen*=2; 156 continue; 157 } 158 #endif 159 return r; 160 } 161 return -1; 162 #elif defined( LDAP_R_COMPILE ) 163 # define NEED_COPY_HOSTENT 164 struct hostent *he; 165 int retval; 166 *buf = NULL; 167 168 ldap_pvt_thread_mutex_lock( &ldap_int_resolv_mutex ); 169 170 he = gethostbyname( name ); 171 172 if (he==NULL) { 173 *herrno_ptr = h_errno; 174 retval = -1; 175 } else if (copy_hostent( resbuf, buf, he )<0) { 176 *herrno_ptr = -1; 177 retval = -1; 178 } else { 179 *result = resbuf; 180 retval = 0; 181 } 182 183 ldap_pvt_thread_mutex_unlock( &ldap_int_resolv_mutex ); 184 185 return retval; 186 #else 187 *buf = NULL; 188 *result = gethostbyname( name ); 189 190 if (*result!=NULL) { 191 return 0; 192 } 193 194 *herrno_ptr = h_errno; 195 196 return -1; 197 #endif 198 } 199 200 #if !defined( HAVE_GETNAMEINFO ) && !defined( HAVE_HSTRERROR ) 201 static const char * 202 hp_strerror( int err ) 203 { 204 switch (err) { 205 case HOST_NOT_FOUND: return _("Host not found (authoritative)"); 206 case TRY_AGAIN: return _("Host not found (server fail?)"); 207 case NO_RECOVERY: return _("Non-recoverable failure"); 208 case NO_DATA: return _("No data of requested type"); 209 #ifdef NETDB_INTERNAL 210 case NETDB_INTERNAL: return STRERROR( errno ); 211 #endif 212 } 213 return _("Unknown resolver error"); 214 } 215 #endif 216 217 int ldap_pvt_get_hname( 218 const struct sockaddr *sa, 219 int len, 220 char *name, 221 int namelen, 222 char **err ) 223 { 224 int rc; 225 #if defined( HAVE_GETNAMEINFO ) 226 227 #if defined( LDAP_R_COMPILE ) 228 ldap_pvt_thread_mutex_lock( &ldap_int_resolv_mutex ); 229 #endif 230 rc = getnameinfo( sa, len, name, namelen, NULL, 0, 0 ); 231 #if defined( LDAP_R_COMPILE ) 232 ldap_pvt_thread_mutex_unlock( &ldap_int_resolv_mutex ); 233 #endif 234 if ( rc ) *err = (char *)AC_GAI_STRERROR( rc ); 235 return rc; 236 237 #else /* !HAVE_GETNAMEINFO */ 238 char *addr; 239 int alen; 240 struct hostent *hp = NULL; 241 #ifdef HAVE_GETHOSTBYADDR_R 242 struct hostent hb; 243 int buflen=BUFSTART, h_errno; 244 char *buf=NULL; 245 #endif 246 247 #ifdef LDAP_PF_INET6 248 if (sa->sa_family == AF_INET6) { 249 struct sockaddr_in6 *sin = (struct sockaddr_in6 *)sa; 250 addr = (char *)&sin->sin6_addr; 251 alen = sizeof(sin->sin6_addr); 252 } else 253 #endif 254 if (sa->sa_family == AF_INET) { 255 struct sockaddr_in *sin = (struct sockaddr_in *)sa; 256 addr = (char *)&sin->sin_addr; 257 alen = sizeof(sin->sin_addr); 258 } else { 259 rc = NO_RECOVERY; 260 *err = (char *)HSTRERROR( rc ); 261 return rc; 262 } 263 #if defined( HAVE_GETHOSTBYADDR_R ) 264 for(;buflen<BUFMAX;) { 265 if (safe_realloc( &buf, buflen )==NULL) { 266 *err = (char *)STRERROR( ENOMEM ); 267 return ENOMEM; 268 } 269 #if (GETHOSTBYADDR_R_NARGS < 8) 270 hp=gethostbyaddr_r( addr, alen, sa->sa_family, 271 &hb, buf, buflen, &h_errno ); 272 rc = (hp == NULL) ? -1 : 0; 273 #else 274 rc = gethostbyaddr_r( addr, alen, sa->sa_family, 275 &hb, buf, buflen, 276 &hp, &h_errno ); 277 #endif 278 #ifdef NETDB_INTERNAL 279 if ((rc<0) && 280 (h_errno==NETDB_INTERNAL) && 281 (errno==ERANGE)) 282 { 283 buflen*=2; 284 continue; 285 } 286 #endif 287 break; 288 } 289 if (hp) { 290 strncpy( name, hp->h_name, namelen ); 291 } else { 292 *err = (char *)HSTRERROR( h_errno ); 293 } 294 LDAP_FREE(buf); 295 #else /* HAVE_GETHOSTBYADDR_R */ 296 297 #if defined( LDAP_R_COMPILE ) 298 ldap_pvt_thread_mutex_lock( &ldap_int_resolv_mutex ); 299 #endif 300 hp = gethostbyaddr( addr, alen, sa->sa_family ); 301 if (hp) { 302 strncpy( name, hp->h_name, namelen ); 303 rc = 0; 304 } else { 305 rc = h_errno; 306 *err = (char *)HSTRERROR( h_errno ); 307 } 308 #if defined( LDAP_R_COMPILE ) 309 ldap_pvt_thread_mutex_unlock( &ldap_int_resolv_mutex ); 310 #endif 311 312 #endif /* !HAVE_GETHOSTBYADDR_R */ 313 return rc; 314 #endif /* !HAVE_GETNAMEINFO */ 315 } 316 317 int ldap_pvt_gethostbyaddr_a( 318 const char *addr, 319 int len, 320 int type, 321 struct hostent *resbuf, 322 char **buf, 323 struct hostent **result, 324 int *herrno_ptr ) 325 { 326 #if defined( HAVE_GETHOSTBYADDR_R ) 327 328 # undef NEED_SAFE_REALLOC 329 # define NEED_SAFE_REALLOC 330 int r=-1; 331 int buflen=BUFSTART; 332 *buf = NULL; 333 for(;buflen<BUFMAX;) { 334 if (safe_realloc( buf, buflen )==NULL) 335 return r; 336 #if (GETHOSTBYADDR_R_NARGS < 8) 337 *result=gethostbyaddr_r( addr, len, type, 338 resbuf, *buf, buflen, herrno_ptr ); 339 r = (*result == NULL) ? -1 : 0; 340 #else 341 r = gethostbyaddr_r( addr, len, type, 342 resbuf, *buf, buflen, 343 result, herrno_ptr ); 344 #endif 345 346 #ifdef NETDB_INTERNAL 347 if ((r<0) && 348 (*herrno_ptr==NETDB_INTERNAL) && 349 (errno==ERANGE)) 350 { 351 buflen*=2; 352 continue; 353 } 354 #endif 355 return r; 356 } 357 return -1; 358 #elif defined( LDAP_R_COMPILE ) 359 # undef NEED_COPY_HOSTENT 360 # define NEED_COPY_HOSTENT 361 struct hostent *he; 362 int retval; 363 *buf = NULL; 364 365 ldap_pvt_thread_mutex_lock( &ldap_int_resolv_mutex ); 366 367 he = gethostbyaddr( addr, len, type ); 368 369 if (he==NULL) { 370 *herrno_ptr = h_errno; 371 retval = -1; 372 } else if (copy_hostent( resbuf, buf, he )<0) { 373 *herrno_ptr = -1; 374 retval = -1; 375 } else { 376 *result = resbuf; 377 retval = 0; 378 } 379 380 ldap_pvt_thread_mutex_unlock( &ldap_int_resolv_mutex ); 381 382 return retval; 383 384 #else /* gethostbyaddr() */ 385 *buf = NULL; 386 *result = gethostbyaddr( addr, len, type ); 387 388 if (*result!=NULL) { 389 return 0; 390 } 391 return -1; 392 #endif 393 } 394 /* 395 * ldap_int_utils_init() should be called before any other function. 396 */ 397 398 void ldap_int_utils_init( void ) 399 { 400 static int done=0; 401 if (done) 402 return; 403 done=1; 404 405 #ifdef LDAP_R_COMPILE 406 #if !defined( USE_CTIME_R ) && !defined( HAVE_REENTRANT_FUNCTIONS ) 407 ldap_pvt_thread_mutex_init( &ldap_int_ctime_mutex ); 408 #endif 409 ldap_pvt_thread_mutex_init( &ldap_int_resolv_mutex ); 410 411 #ifdef HAVE_CYRUS_SASL 412 ldap_pvt_thread_mutex_init( &ldap_int_sasl_mutex ); 413 #endif 414 #endif 415 416 /* call other module init functions here... */ 417 } 418 419 #if defined( NEED_COPY_HOSTENT ) 420 # undef NEED_SAFE_REALLOC 421 #define NEED_SAFE_REALLOC 422 423 static char *cpy_aliases( 424 char ***tgtio, 425 char *buf, 426 char **src ) 427 { 428 int len; 429 char **tgt=*tgtio; 430 for( ; (*src) ; src++ ) { 431 len = strlen( *src ) + 1; 432 AC_MEMCPY( buf, *src, len ); 433 *tgt++=buf; 434 buf+=len; 435 } 436 *tgtio=tgt; 437 return buf; 438 } 439 440 static char *cpy_addresses( 441 char ***tgtio, 442 char *buf, 443 char **src, 444 int len ) 445 { 446 char **tgt=*tgtio; 447 for( ; (*src) ; src++ ) { 448 AC_MEMCPY( buf, *src, len ); 449 *tgt++=buf; 450 buf+=len; 451 } 452 *tgtio=tgt; 453 return buf; 454 } 455 456 static int copy_hostent( 457 struct hostent *res, 458 char **buf, 459 struct hostent * src ) 460 { 461 char **p; 462 char **tp; 463 char *tbuf; 464 int name_len; 465 int n_alias=0; 466 int total_alias_len=0; 467 int n_addr=0; 468 int total_addr_len=0; 469 int total_len; 470 471 /* calculate the size needed for the buffer */ 472 name_len = strlen( src->h_name ) + 1; 473 474 if( src->h_aliases != NULL ) { 475 for( p = src->h_aliases; (*p) != NULL; p++ ) { 476 total_alias_len += strlen( *p ) + 1; 477 n_alias++; 478 } 479 } 480 481 if( src->h_addr_list != NULL ) { 482 for( p = src->h_addr_list; (*p) != NULL; p++ ) { 483 n_addr++; 484 } 485 total_addr_len = n_addr * src->h_length; 486 } 487 488 total_len = (n_alias + n_addr + 2) * sizeof( char * ) + 489 total_addr_len + total_alias_len + name_len; 490 491 if (safe_realloc( buf, total_len )) { 492 tp = (char **) *buf; 493 tbuf = *buf + (n_alias + n_addr + 2) * sizeof( char * ); 494 AC_MEMCPY( res, src, sizeof( struct hostent ) ); 495 /* first the name... */ 496 AC_MEMCPY( tbuf, src->h_name, name_len ); 497 res->h_name = tbuf; tbuf+=name_len; 498 /* now the aliases */ 499 res->h_aliases = tp; 500 if ( src->h_aliases != NULL ) { 501 tbuf = cpy_aliases( &tp, tbuf, src->h_aliases ); 502 } 503 *tp++=NULL; 504 /* finally the addresses */ 505 res->h_addr_list = tp; 506 if ( src->h_addr_list != NULL ) { 507 tbuf = cpy_addresses( &tp, tbuf, src->h_addr_list, src->h_length ); 508 } 509 *tp++=NULL; 510 return 0; 511 } 512 return -1; 513 } 514 #endif 515 516 #if defined( NEED_SAFE_REALLOC ) 517 static char *safe_realloc( char **buf, int len ) 518 { 519 char *tmpbuf; 520 tmpbuf = LDAP_REALLOC( *buf, len ); 521 if (tmpbuf) { 522 *buf=tmpbuf; 523 } 524 return tmpbuf; 525 } 526 #endif 527 528 char * ldap_pvt_get_fqdn( char *name ) 529 { 530 char *fqdn, *ha_buf; 531 char hostbuf[MAXHOSTNAMELEN+1]; 532 struct hostent *hp, he_buf; 533 int rc, local_h_errno; 534 535 if( name == NULL ) { 536 if( gethostname( hostbuf, MAXHOSTNAMELEN ) == 0 ) { 537 hostbuf[MAXHOSTNAMELEN] = '\0'; 538 name = hostbuf; 539 } else { 540 name = "localhost"; 541 } 542 } 543 544 rc = ldap_pvt_gethostbyname_a( name, 545 &he_buf, &ha_buf, &hp, &local_h_errno ); 546 547 if( rc < 0 || hp == NULL || hp->h_name == NULL ) { 548 fqdn = LDAP_STRDUP( name ); 549 } else { 550 fqdn = LDAP_STRDUP( hp->h_name ); 551 } 552 553 LDAP_FREE( ha_buf ); 554 return fqdn; 555 } 556 557 #if ( defined( HAVE_GETADDRINFO ) || defined( HAVE_GETNAMEINFO ) ) \ 558 && !defined( HAVE_GAI_STRERROR ) 559 char *ldap_pvt_gai_strerror (int code) { 560 static struct { 561 int code; 562 const char *msg; 563 } values[] = { 564 #ifdef EAI_ADDRFAMILY 565 { EAI_ADDRFAMILY, N_("Address family for hostname not supported") }, 566 #endif 567 { EAI_AGAIN, N_("Temporary failure in name resolution") }, 568 { EAI_BADFLAGS, N_("Bad value for ai_flags") }, 569 { EAI_FAIL, N_("Non-recoverable failure in name resolution") }, 570 { EAI_FAMILY, N_("ai_family not supported") }, 571 { EAI_MEMORY, N_("Memory allocation failure") }, 572 #ifdef EAI_NODATA 573 { EAI_NODATA, N_("No address associated with hostname") }, 574 #endif 575 { EAI_NONAME, N_("Name or service not known") }, 576 { EAI_SERVICE, N_("Servname not supported for ai_socktype") }, 577 { EAI_SOCKTYPE, N_("ai_socktype not supported") }, 578 { EAI_SYSTEM, N_("System error") }, 579 { 0, NULL } 580 }; 581 582 int i; 583 584 for ( i = 0; values[i].msg != NULL; i++ ) { 585 if ( values[i].code == code ) { 586 return (char *) _(values[i].msg); 587 } 588 } 589 590 return _("Unknown error"); 591 } 592 #endif 593