ACE/ace/OS_NS_netdb.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_macros.h"
   3 #include "ace/OS_NS_string.h"
   4 #include "ace/OS_NS_errno.h"
   5
   6 #if defined (ACE_LACKS_NETDB_REENTRANT_FUNCTIONS)
   7 # if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
   8 #   define ACE_NETDBCALL_RETURN(OP,TYPE,FAILVALUE,TARGET,SIZE) \
   9   do \
  10   { \
  11     if (ACE_OS::netdb_acquire ())  \
  12       return FAILVALUE; \
  13     else \
  14       { \
  15         TYPE ace_result_; \
  16         ACE_OSCALL (OP, TYPE, ace_result_); \
  17         if (ace_result_ != FAILVALUE) \
  18           ACE_OS::memcpy (TARGET, \
  19                     ace_result_, \
  20                     SIZE < sizeof (TYPE) ? SIZE : sizeof (TYPE)); \
  21         ACE_OS::netdb_release (); \
  22         return ace_result_; \
  23       } \
  24   } while(0)
  25 # else /* ! (ACE_MT_SAFE && ACE_MT_SAFE != 0) */
  26 #   define ACE_NETDBCALL_RETURN(OP,TYPE,FAILVALUE,TARGET,SIZE) \
  27   do \
  28   { \
  29         TYPE ace_result_; \
  30         ACE_OSCALL(OP,TYPE,ace_result_); \
  31         if (ace_result_ != FAILVALUE) \
  32           ACE_OS::memcpy (TARGET, \
  33                     ace_result_, \
  34                     SIZE < sizeof (TYPE) ? SIZE : sizeof (TYPE)); \
  35         return ace_result_; \
  36   } while(0)
  37 # endif /* ACE_MT_SAFE && ACE_MT_SAFE != 0 */
  38 #endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */
  39
  40 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  41
  42 ACE_INLINE struct hostent *
  43 ACE_OS::gethostbyaddr (const char *addr, int length, int type)
  44 {
  45   ACE_OS_TRACE ("ACE_OS::gethostbyaddr");
  46 # if defined (ACE_LACKS_GETHOSTBYADDR)
  47   ACE_UNUSED_ARG (addr);
  48   ACE_UNUSED_ARG (length);
  49   ACE_UNUSED_ARG (type);
  50   ACE_NOTSUP_RETURN (0);
  51 # else
  52
  53   if (0 == addr || '\0' == addr[0])
  54       return 0;
  55
  56 #   if defined (ACE_VXWORKS_HAS_GETHOSTBYADDR_REENTRANT)
  57   // VxWorks 6.x has a gethostbyaddr() that is threadsafe and
  58   // returns an heap-allocated hostentry structure.
  59   // just call ACE_OS::gethostbyaddr_r () which knows how to handle this.
  60   struct hostent hentry;
  61   ACE_HOSTENT_DATA buf;
  62   int h_error;  // Not the same as errno!
  63   return ACE_OS::gethostbyaddr_r (addr, length, type, &hentry, buf, &h_error);
  64 #   elif defined (ACE_HAS_NONCONST_GETBY)
  65   //FUZZ: disable check_for_lack_ACE_OS
  66   ACE_SOCKCALL_RETURN (::gethostbyaddr (const_cast<char *> (addr),
  67                                         (ACE_SOCKET_LEN) length,
  68                                         type),
  69                        struct hostent *,
  70                        0);
  71   //FUZZ: enable check_for_lack_ACE_OS
  72 #   else
  73   //FUZZ: disable check_for_lack_ACE_OS
  74   ACE_SOCKCALL_RETURN (::gethostbyaddr (addr,
  75                                         (ACE_SOCKET_LEN) length,
  76                                         type),
  77                        struct hostent *,
  78                        0);
  79   //FUZZ: enable check_for_lack_ACE_OS
  80 #   endif /* ACE_HAS_NONCONST_GETBY */
  81 # endif /* !ACE_LACKS_GETHOSTBYADDR */
  82 }
  83
  84 ACE_INLINE struct hostent *
  85 ACE_OS::gethostbyaddr_r (const char *addr,
  86                          int length,
  87                          int type,
  88                          struct hostent *result,
  89                          ACE_HOSTENT_DATA buffer,
  90                          int *h_errnop)
  91 {
  92   ACE_OS_TRACE ("ACE_OS::gethostbyaddr_r");
  93 # if defined (ACE_LACKS_GETHOSTBYADDR_R)
  94   ACE_UNUSED_ARG (addr);
  95   ACE_UNUSED_ARG (length);
  96   ACE_UNUSED_ARG (type);
  97   ACE_UNUSED_ARG (result);
  98   ACE_UNUSED_ARG (buffer);
  99   if (h_errnop)
 100     *h_errnop = ENOTSUP;
 101   ACE_NOTSUP_RETURN (0);
 102 # elif defined (ACE_HAS_REENTRANT_FUNCTIONS)
 103
 104   if (0 == addr || '\0' == addr[0])
 105       return 0;
 106
 107 #   if defined (__GLIBC__)
 108   // GNU C library has a different signature
 109   ACE_OS::memset (buffer, 0, sizeof (ACE_HOSTENT_DATA));
 110
 111   //FUZZ: disable check_for_lack_ACE_OS
 112   if (::gethostbyaddr_r ((char *) addr,
 113                          length,
 114                          type,
 115                          result,
 116                          buffer,
 117                          sizeof (ACE_HOSTENT_DATA),
 118                          &result,
 119                          h_errnop) == 0)
 120     return result;
 121   //FUZZ: enable check_for_lack_ACE_OS
 122   else
 123     return (struct hostent *) 0;
 124 #   elif defined (ACE_VXWORKS_HAS_GETHOSTBYADDR_REENTRANT)
 125   ACE_UNUSED_ARG (h_errnop);
 126   // VxWorks 6.x has a threadsafe gethostbyaddr() which returns a heap-allocated
 127   // data structure which needs to be freed with hostentFree()
 128   //FUZZ: disable check_for_lack_ACE_OS
 129   struct hostent* hp = ::gethostbyaddr (addr, length, type);
 130   //FUZZ: enable check_for_lack_ACE_OS
 131
 132   if (hp)
 133   {
 134     result->h_addrtype = hp->h_addrtype;
 135     result->h_length = hp->h_length;
 136
 137     // buffer layout:
 138     // buffer[0-3]: h_addr_list[0], pointer to the addr.
 139     // buffer[4-7]: h_addr_list[1], null terminator for the h_addr_list.
 140     // buffer[8..(8+h_length)]: the first (and only) addr.
 141     // buffer[(8+h_length)...]: hostname
 142
 143     // Store the address list in buffer.
 144     result->h_addr_list = (char **) buffer;
 145     // Store the actual address _after_ the address list.
 146     result->h_addr_list[0] = (char *) &result->h_addr_list[2];
 147     ACE_OS::memcpy (result->h_addr_list[0], hp->h_addr_list[0], hp->h_length);
 148     // Null-terminate the list of addresses.
 149     result->h_addr_list[1] = 0;
 150     // And no aliases, so null-terminate h_aliases.
 151     result->h_aliases = &result->h_addr_list[1];
 152
 153     if (((2*sizeof(char*))+hp->h_length+ACE_OS::strlen (hp->h_name)+1) <= sizeof (ACE_HOSTENT_DATA))
 154     {
 155       result->h_name = (char *) result->h_addr_list[0] + hp->h_length;
 156       ACE_OS::strcpy (result->h_name, hp->h_name);
 157     }
 158     else
 159     {
 160       result->h_name = (char *)0;
 161     }
 162
 163     // free hostent memory
 164     ::hostentFree (hp);
 165
 166     return result;
 167   }
 168   else
 169   {
 170     return (struct hostent *) 0;
 171   }
 172 #   else
 173 #     if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS)
 174   ACE_UNUSED_ARG (result);
 175   ACE_UNUSED_ARG (h_errnop);
 176   //FUZZ: disable check_for_lack_ACE_OS
 177   ACE_NETDBCALL_RETURN (::gethostbyaddr (addr, (ACE_SOCKET_LEN) length, type),
 178                         struct hostent *, 0,
 179                         buffer, sizeof (ACE_HOSTENT_DATA));
 180   //FUZZ: enable check_for_lack_ACE_OS
 181 #     else
 182   //FUZZ: disable check_for_lack_ACE_OS
 183   ACE_SOCKCALL_RETURN (::gethostbyaddr_r (addr, length, type, result,
 184                                           buffer, sizeof (ACE_HOSTENT_DATA),
 185                                           h_errnop),
 186                        struct hostent *, 0);
 187   //FUZZ: enable check_for_lack_ACE_OS
 188 #     endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */
 189 #   endif /* defined (__GLIBC__) */
 190 # elif defined (ACE_HAS_NONCONST_GETBY)
 191   ACE_UNUSED_ARG (result);
 192   ACE_UNUSED_ARG (buffer);
 193   ACE_UNUSED_ARG (h_errnop);
 194   //FUZZ: disable check_for_lack_ACE_OS
 195   ACE_SOCKCALL_RETURN (::gethostbyaddr (const_cast<char *> (addr),
 196                                         (ACE_SOCKET_LEN) length,
 197                                         type),
 198                        struct hostent *,
 199                        0);
 200   //FUZZ: enable check_for_lack_ACE_OS
 201 # else
 202   ACE_UNUSED_ARG (h_errnop);
 203   ACE_UNUSED_ARG (buffer);
 204   ACE_UNUSED_ARG (result);
 205
 206   //FUZZ: disable check_for_lack_ACE_OS
 207   ACE_SOCKCALL_RETURN (::gethostbyaddr (addr,
 208                                         (ACE_SOCKET_LEN) length,
 209                                         type),
 210                        struct hostent *,
 211                        0);
 212   //FUZZ: enable check_for_lack_ACE_OS
 213 # endif /* ACE_LACKS_GETHOSTBYADDR_R */
 214 }
 215
 216 ACE_INLINE struct hostent *
 217 ACE_OS::gethostbyname (const char *name)
 218 {
 219   ACE_OS_TRACE ("ACE_OS::gethostbyname");
 220 # if defined (ACE_LACKS_GETHOSTBYNAME)
 221   ACE_UNUSED_ARG (name);
 222   ACE_NOTSUP_RETURN (0);
 223 # else
 224
 225   if (0 == name || '\0' == name[0])
 226       return 0;
 227
 228 #   if defined (ACE_VXWORKS_HAS_GETHOSTBYNAME_REENTRANT)
 229   // VxWorks 6.x has a gethostbyname() that is threadsafe and
 230   // returns an heap-allocated hostentry structure.
 231   // just call ACE_OS::gethostbyname_r () which knows how to handle this.
 232   // With VxWorks 7 it depends on the GETHOSTBYNAME_REENTRANT
 233   // define
 234   struct hostent hentry;
 235   ACE_HOSTENT_DATA buf;
 236   int h_error;  // Not the same as errno!
 237   return ACE_OS::gethostbyname_r (name, &hentry, buf, &h_error);
 238 #   elif defined (ACE_HAS_NONCONST_GETBY)
 239   //FUZZ: disable check_for_lack_ACE_OS
 240   ACE_SOCKCALL_RETURN (::gethostbyname (const_cast<char *> (name)),
 241                        struct hostent *,
 242                        0);
 243   //FUZZ: enable check_for_lack_ACE_OS
 244 #   else
 245   //FUZZ: disable check_for_lack_ACE_OS
 246   ACE_SOCKCALL_RETURN (::gethostbyname (name),
 247                        struct hostent *,
 248                        0);
 249   //FUZZ: enable check_for_lack_ACE_OS
 250 #   endif /* ACE_HAS_NONCONST_GETBY */
 251 # endif /* !ACE_LACKS_GETHOSTBYNAME */
 252 }
 253
 254 ACE_INLINE struct hostent *
 255 ACE_OS::gethostbyname_r (const char *name,
 256                          struct hostent *result,
 257                          ACE_HOSTENT_DATA buffer,
 258                          int *h_errnop)
 259 {
 260   ACE_OS_TRACE ("ACE_OS::gethostbyname_r");
 261 #if defined (ACE_LACKS_GETHOSTBYNAME)
 262   ACE_UNUSED_ARG (name);
 263   ACE_UNUSED_ARG (result);
 264   ACE_UNUSED_ARG (buffer);
 265   if (h_errnop)
 266     *h_errnop = ENOTSUP;
 267   ACE_NOTSUP_RETURN (0);
 268 # elif defined (ACE_HAS_REENTRANT_FUNCTIONS)
 269
 270   if (0 == name || '\0' == name[0])
 271       return (struct hostent *)0;
 272
 273 #   if defined (__GLIBC__)
 274   // GNU C library has a different signature
 275   ACE_OS::memset (buffer, 0, sizeof (ACE_HOSTENT_DATA));
 276
 277   //FUZZ: disable check_for_lack_ACE_OS
 278   if (::gethostbyname_r (name,
 279                          result,
 280                          buffer,
 281                          sizeof (ACE_HOSTENT_DATA),
 282                          &result,
 283                          h_errnop) == 0)
 284     return result;
 285   //FUZZ: enable check_for_lack_ACE_OS
 286   else
 287     return (struct hostent *) 0;
 288 #   elif defined (ACE_VXWORKS_HAS_GETHOSTBYNAME_REENTRANT)
 289   ACE_UNUSED_ARG (h_errnop);
 290   // VxWorks 6.x has a threadsafe gethostbyname() which returns a heap-allocated
 291   // data structure which needs to be freed with hostentFree()
 292   // With VxWorks 7 it depends on the GETHOSTBYNAME_REENTRANT macro
 293   //FUZZ: disable check_for_lack_ACE_OS
 294   struct hostent* hp = ::gethostbyname (name);
 295   //FUZZ: enable check_for_lack_ACE_OS
 296
 297   if (hp)
 298   {
 299     result->h_addrtype = hp->h_addrtype;
 300     result->h_length = hp->h_length;
 301
 302     // buffer layout:
 303     // buffer[0-3]: h_addr_list[0], pointer to the addr.
 304     // buffer[4-7]: h_addr_list[1], null terminator for the h_addr_list.
 305     // buffer[8...]: the first (and only) addr.
 306
 307     // Store the address list in buffer.
 308     result->h_addr_list = (char **) buffer;
 309     // Store the actual address _after_ the address list.
 310     result->h_addr_list[0] = (char *) &result->h_addr_list[2];
 311     ACE_OS::memcpy (result->h_addr_list[0], hp->h_addr_list[0], hp->h_length);
 312     // Null-terminate the list of addresses.
 313     result->h_addr_list[1] = 0;
 314     // And no aliases, so null-terminate h_aliases.
 315     result->h_aliases = &result->h_addr_list[1];
 316
 317     if (((2*sizeof(char*))+hp->h_length+ACE_OS::strlen (hp->h_name)+1) <= sizeof (ACE_HOSTENT_DATA))
 318     {
 319       result->h_name = (char *) result->h_addr_list[0] + hp->h_length;
 320       ACE_OS::strcpy (result->h_name, hp->h_name);
 321     }
 322     else
 323     {
 324       result->h_name = (char *)0;
 325     }
 326
 327     // free hostent memory
 328     ::hostentFree (hp);
 329
 330     return result;
 331   }
 332   else
 333   {
 334     return nullptr;
 335   }
 336 #   else
 337 #     if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS)
 338   ACE_UNUSED_ARG (result);
 339   ACE_UNUSED_ARG (h_errnop);
 340   //FUZZ: disable check_for_lack_ACE_OS
 341   ACE_NETDBCALL_RETURN (::gethostbyname (name),
 342                         struct hostent *, 0,
 343                         buffer, sizeof (ACE_HOSTENT_DATA));
 344   //FUZZ: enable check_for_lack_ACE_OS
 345 #     else
 346   //FUZZ: disable check_for_lack_ACE_OS
 347   ACE_SOCKCALL_RETURN (::gethostbyname_r (name, result, buffer,
 348                                           sizeof (ACE_HOSTENT_DATA),
 349                                           h_errnop),
 350                        struct hostent *,
 351                        0);
 352   //FUZZ: enable check_for_lack_ACE_OS
 353 #     endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */
 354 #   endif /* defined (__GLIBC__) */
 355 # elif defined (ACE_HAS_NONCONST_GETBY)
 356   ACE_UNUSED_ARG (result);
 357   ACE_UNUSED_ARG (buffer);
 358   ACE_UNUSED_ARG (h_errnop);
 359   //FUZZ: disable check_for_lack_ACE_OS
 360   ACE_SOCKCALL_RETURN (::gethostbyname (const_cast<char *> (name)),
 361                        struct hostent *,
 362                        0);
 363   //FUZZ: enable check_for_lack_ACE_OS
 364 # else
 365   ACE_UNUSED_ARG (result);
 366   ACE_UNUSED_ARG (buffer);
 367
 368   // FUZZ: disable check_for_lack_ACE_OS
 369   struct hostent *result2 = 0;
 370   ACE_SOCKCALL (::gethostbyname (name),
 371                 struct hostent *,
 372                 0,
 373                 result2);
 374   if (result2 == 0 && h_errnop)
 375     *h_errnop = errno;
 376   return result2;
 377   //FUZZ: enable check_for_lack_ACE_OS
 378 # endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) */
 379 }
 380
 381 ACE_INLINE struct hostent *
 382 ACE_OS::getipnodebyaddr (const void *src, size_t len, int family)
 383 {
 384 #if defined (ACE_HAS_IPV6) && !defined (ACE_WIN32)
 385 #  if defined (ACE_LACKS_GETIPNODEBYADDR)
 386   ACE_UNUSED_ARG (src);
 387   ACE_UNUSED_ARG (len);
 388   ACE_UNUSED_ARG (family);
 389   ACE_NOTSUP_RETURN (0);
 390 #  else
 391   struct hostent *hptr = 0;
 392   int errnum;
 393   //FUZZ: disable check_for_lack_ACE_OS
 394   if ((hptr = ::getipnodebyaddr (src, len, family, &errnum)) == 0)
 395     {
 396       errno = errnum;
 397     }
 398   //FUZZ: enable check_for_lack_ACE_OS
 399   return hptr;
 400 #  endif /* ACE_LACKS_GETIPNODEBYADDR */
 401 #else
 402   // IPv4-only implementation
 403   if (family == AF_INET)
 404     return ACE_OS::gethostbyaddr (static_cast<const char *> (src),
 405                                   static_cast<int> (len),
 406                                   family);
 407
 408   ACE_NOTSUP_RETURN (0);
 409 # endif /* defined (ACE_HAS_IPV6) && !defined (ACE_WIN32) */
 410 }
 411
 412 ACE_INLINE struct hostent *
 413 ACE_OS::getipnodebyname (const char *name, int family, int flags)
 414 {
 415   ACE_OS_TRACE ("ACE_OS::getipnodebyname");
 416 # if defined (ACE_HAS_IPV6) && !defined (ACE_LACKS_GETIPNODEBYNAME_IPV6)
 417 #   if defined (ACE_LACKS_GETIPNODEBYNAME)
 418   ACE_UNUSED_ARG (flags);
 419 #     if defined (ACE_HAS_NONCONST_GETBY)
 420   ACE_SOCKCALL_RETURN (::gethostbyname2 (const_cast<char *> (name),
 421                                          family),
 422                        struct hostent *, 0);
 423 #     else
 424   ACE_SOCKCALL_RETURN (::gethostbyname2 (name, family),
 425                        struct hostent *, 0);
 426 #     endif /* ACE_HAS_NONCONST_GETBY */
 427 #   else
 428   struct hostent *hptr = 0;
 429   int errnum;
 430   //FUZZ: disable check_for_lack_ACE_OS
 431   if ((hptr = ::getipnodebyname (name, family, flags, &errnum)) == 0)
 432     {
 433       errno = errnum;
 434     }
 435   //FUZZ: enable check_for_lack_ACE_OS
 436   return hptr;
 437 #   endif /* ACE_LACKS_GETIPNODEBYNAME */
 438 # else
 439   // IPv4-only implementation
 440   ACE_UNUSED_ARG (flags);
 441   if (family == AF_INET)
 442     return ACE_OS::gethostbyname (name);
 443
 444   ACE_NOTSUP_RETURN (0);
 445 # endif /* defined (ACE_HAS_IPV6) && !ACE_LACKS_GETIPNODEBYNAME_IPV6 */
 446 }
 447
 448 ACE_INLINE struct protoent *
 449 ACE_OS::getprotobyname (const char *name)
 450 {
 451 #if defined (ACE_LACKS_GETPROTOBYNAME)
 452   ACE_UNUSED_ARG (name);
 453   ACE_NOTSUP_RETURN (0);
 454 #elif defined (ACE_HAS_NONCONST_GETBY)
 455   //FUZZ: disable check_for_lack_ACE_OS
 456   ACE_SOCKCALL_RETURN (::getprotobyname (const_cast<char *> (name)),
 457                        struct protoent *,
 458                        0);
 459   //FUZZ: enable check_for_lack_ACE_OS
 460 #else
 461   //FUZZ: disable check_for_lack_ACE_OS
 462   ACE_SOCKCALL_RETURN (::getprotobyname (name),
 463                        struct protoent *,
 464                        0);
 465   //FUZZ: enable check_for_lack_ACE_OS
 466 #endif /* ACE_LACKS_GETPROTOBYNAME */
 467 }
 468
 469 ACE_INLINE struct protoent *
 470 ACE_OS::getprotobyname_r (const char *name,
 471                           struct protoent *result,
 472                           ACE_PROTOENT_DATA buffer)
 473 {
 474 #if defined (ACE_LACKS_GETPROTOBYNAME)
 475   ACE_UNUSED_ARG (name);
 476   ACE_UNUSED_ARG (result);
 477   ACE_UNUSED_ARG (buffer);
 478   ACE_NOTSUP_RETURN (0);
 479 #elif defined (ACE_HAS_REENTRANT_FUNCTIONS)
 480 #if defined (__GLIBC__)
 481   // GNU C library has a different signature
 482   //FUZZ: disable check_for_lack_ACE_OS
 483   if (::getprotobyname_r (name,
 484                           result,
 485                           buffer,
 486                           sizeof (ACE_PROTOENT_DATA),
 487                           &result) == 0)
 488   //FUZZ: enable check_for_lack_ACE_OS
 489     return result;
 490   else
 491     return 0;
 492 # else
 493 #   if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS)
 494   ACE_UNUSED_ARG (result);
 495   //FUZZ: disable check_for_lack_ACE_OS
 496   ACE_NETDBCALL_RETURN (::getprotobyname (name),
 497                         struct protoent *, 0,
 498                         buffer, sizeof (ACE_PROTOENT_DATA));
 499   //FUZZ: enable check_for_lack_ACE_OS
 500 #   else
 501     //FUZZ: disable check_for_lack_ACE_OS
 502     ACE_SOCKCALL_RETURN (::getprotobyname_r (name,
 503                                              result,
 504                                              buffer,
 505                                              sizeof (ACE_PROTOENT_DATA)),
 506                        struct protoent *, 0);
 507     //FUZZ: enable check_for_lack_ACE_OS
 508 #   endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */
 509 # endif /* defined (__GLIBC__) */
 510 #elif defined (ACE_HAS_NONCONST_GETBY)
 511   ACE_UNUSED_ARG (result);
 512   ACE_UNUSED_ARG (buffer);
 513   //FUZZ: disable check_for_lack_ACE_OS
 514   ACE_SOCKCALL_RETURN (::getprotobyname (const_cast<char *> (name)),
 515                        struct protoent *, 0);
 516   //FUZZ: enable check_for_lack_ACE_OS
 517 #else
 518   ACE_UNUSED_ARG (buffer);
 519   ACE_UNUSED_ARG (result);
 520
 521   //FUZZ: disable check_for_lack_ACE_OS
 522   ACE_SOCKCALL_RETURN (::getprotobyname (name),
 523                        struct protoent *,
 524                        0);
 525   //FUZZ: enable check_for_lack_ACE_OS
 526 #endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) */
 527 }
 528
 529 ACE_INLINE struct protoent *
 530 ACE_OS::getprotobynumber (int proto)
 531 {
 532 #if defined (ACE_LACKS_GETPROTOBYNUMBER)
 533   ACE_UNUSED_ARG (proto);
 534   ACE_NOTSUP_RETURN (0);
 535 #else
 536   //FUZZ: disable check_for_lack_ACE_OS
 537   ACE_SOCKCALL_RETURN (::getprotobynumber (proto),
 538                        struct protoent *, 0);
 539   //FUZZ: enable check_for_lack_ACE_OS
 540 #endif /* ACE_LACKS_GETPROTOBYNUMBER */
 541 }
 542
 543 ACE_INLINE struct protoent *
 544 ACE_OS::getprotobynumber_r (int proto,
 545                             struct protoent *result,
 546                             ACE_PROTOENT_DATA buffer)
 547 {
 548 #if defined (ACE_LACKS_GETPROTOBYNUMBER)
 549   ACE_UNUSED_ARG (proto);
 550   ACE_UNUSED_ARG (result);
 551   ACE_UNUSED_ARG (buffer);
 552   ACE_NOTSUP_RETURN (0);
 553 #elif defined (ACE_HAS_REENTRANT_FUNCTIONS)
 554 # if defined (__GLIBC__)
 555   // GNU C library has a different signature
 556   //FUZZ: disable check_for_lack_ACE_OS
 557   if (::getprotobynumber_r (proto,
 558                             result,
 559                             buffer,
 560                             sizeof (ACE_PROTOENT_DATA),
 561                             &result) == 0)
 562   //FUZZ: enable check_for_lack_ACE_OS
 563     return result;
 564   else
 565     return 0;
 566 # else
 567 #   if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS)
 568   ACE_UNUSED_ARG (result);
 569   //FUZZ: disable check_for_lack_ACE_OS
 570   ACE_NETDBCALL_RETURN (::getprotobynumber (proto),
 571                         struct protoent *, 0,
 572                         buffer, sizeof (ACE_PROTOENT_DATA));
 573   //FUZZ: enable check_for_lack_ACE_OS
 574 #   else
 575   //FUZZ: disable check_for_lack_ACE_OS
 576   ACE_SOCKCALL_RETURN (::getprotobynumber_r (proto, result, buffer, sizeof (ACE_PROTOENT_DATA)),
 577                        struct protoent *, 0);
 578   //FUZZ: enable check_for_lack_ACE_OS
 579 #   endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */
 580 # endif /* defined (__GLIBC__) */
 581 #else
 582   ACE_UNUSED_ARG (buffer);
 583   ACE_UNUSED_ARG (result);
 584
 585   //FUZZ: disable check_for_lack_ACE_OS
 586   ACE_SOCKCALL_RETURN (::getprotobynumber (proto),
 587                        struct protoent *, 0);
 588   //FUZZ: enable check_for_lack_ACE_OS
 589 #endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) */
 590 }
 591
 592 ACE_INLINE struct servent *
 593 ACE_OS::getservbyname (const char *svc, const char *proto)
 594 {
 595   ACE_OS_TRACE ("ACE_OS::getservbyname");
 596 #if defined (ACE_LACKS_GETSERVBYNAME)
 597   ACE_UNUSED_ARG (svc);
 598   ACE_UNUSED_ARG (proto);
 599   ACE_NOTSUP_RETURN (0);
 600 #elif defined (ACE_HAS_NONCONST_GETBY)
 601   //FUZZ: disable check_for_lack_ACE_OS
 602   ACE_SOCKCALL_RETURN (::getservbyname (const_cast<char *> (svc),
 603                                         const_cast<char *> (proto)),
 604                        struct servent *,
 605                        0);
 606   //FUZZ: enable check_for_lack_ACE_OS
 607 #else
 608   //FUZZ: disable check_for_lack_ACE_OS
 609   ACE_SOCKCALL_RETURN (::getservbyname (svc,
 610                                         proto),
 611                        struct servent *,
 612                        0);
 613   //FUZZ: enable check_for_lack_ACE_OS
 614 #endif /* ACE_HAS_NONCONST_GETBY */
 615 }
 616
 617 ACE_INLINE struct servent *
 618 ACE_OS::getservbyname_r (const char *svc,
 619                          const char *proto,
 620                          struct servent *result,
 621                          ACE_SERVENT_DATA buf)
 622 {
 623   ACE_OS_TRACE ("ACE_OS::getservbyname_r");
 624 #if defined (ACE_LACKS_GETSERVBYNAME)
 625   ACE_UNUSED_ARG (svc);
 626   ACE_UNUSED_ARG (proto);
 627   ACE_UNUSED_ARG (result);
 628   ACE_UNUSED_ARG (buf);
 629   ACE_NOTSUP_RETURN (0);
 630 #elif defined (ACE_HAS_REENTRANT_FUNCTIONS)
 631 # if defined (__GLIBC__)
 632   // GNU C library has a different signature
 633   ACE_OS::memset (buf, 0, sizeof (ACE_SERVENT_DATA));
 634
 635   //FUZZ: disable check_for_lack_ACE_OS
 636   if (::getservbyname_r (svc,
 637                          proto,
 638                          result,
 639                          buf,
 640                          sizeof (ACE_SERVENT_DATA),
 641                          &result) == 0)
 642     return result;
 643   //FUZZ: enable check_for_lack_ACE_OS
 644   else
 645     return (struct servent *) 0;
 646 # else
 647 #   if defined(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS)
 648   ACE_UNUSED_ARG (result);
 649   //FUZZ: disable check_for_lack_ACE_OS
 650   ACE_NETDBCALL_RETURN (::getservbyname (svc, proto),
 651                         struct servent *, 0,
 652                         buf, sizeof (ACE_SERVENT_DATA));
 653   //FUZZ: enable check_for_lack_ACE_OS
 654 #   else
 655   //FUZZ: disable check_for_lack_ACE_OS
 656   ACE_SOCKCALL_RETURN (::getservbyname_r (svc, proto, result, buf,
 657                                           sizeof (ACE_SERVENT_DATA)),
 658                        struct servent *, 0);
 659   //FUZZ: enable check_for_lack_ACE_OS
 660 #   endif /* ACE_LACKS_NETDB_REENTRANT_FUNCTIONS */
 661 # endif /* defined (__GLIBC__) */
 662 #elif defined (ACE_HAS_NONCONST_GETBY)
 663   ACE_UNUSED_ARG (buf);
 664   ACE_UNUSED_ARG (result);
 665   //FUZZ: disable check_for_lack_ACE_OS
 666   ACE_SOCKCALL_RETURN (::getservbyname (const_cast<char *> (svc),
 667                                         const_cast<char *> (proto)),
 668                        struct servent *,
 669                        0);
 670   //FUZZ: enable check_for_lack_ACE_OS
 671 #else
 672   ACE_UNUSED_ARG (buf);
 673   ACE_UNUSED_ARG (result);
 674   //FUZZ: disable check_for_lack_ACE_OS
 675   ACE_SOCKCALL_RETURN (::getservbyname (svc,
 676                                         proto),
 677                        struct servent *,
 678                        0);
 679   //FUZZ: enable check_for_lack_ACE_OS
 680 #endif /* defined (ACE_HAS_REENTRANT_FUNCTIONS) */
 681 }
 682
 683 ACE_INLINE int
 684 ACE_OS::getaddrinfo (const char *name, const char *service,
 685                      const addrinfo *hints, addrinfo **result)
 686 {
 687   ACE_OS_TRACE ("ACE_OS::getaddrinfo");
 688 #ifdef ACE_LACKS_GETADDRINFO
 689   ACE_UNUSED_ARG (service);
 690   ACE_UNUSED_ARG (hints);
 691   return ACE_OS::getaddrinfo_emulation (name, result);
 692 #else
 693   return ::getaddrinfo (name, service, hints, result);
 694 #endif
 695 }
 696
 697 ACE_INLINE void
 698 ACE_OS::freeaddrinfo (addrinfo *result)
 699 {
 700   ACE_OS_TRACE ("ACE_OS::freeaddrinfo");
 701 #ifdef ACE_LACKS_GETADDRINFO
 702   ACE_OS::freeaddrinfo_emulation (result);
 703 #else
 704   ::freeaddrinfo (result);
 705 #endif
 706 }
 707
 708 ACE_INLINE const ACE_TCHAR *
 709 ACE_OS::gai_strerror (int errcode)
 710 {
 711   ACE_OS_TRACE ("ACE_OS::gai_strerror");
 712 #ifdef ACE_LACKS_GAI_STRERROR
 713   switch (errcode)
 714     {
 715     case EAI_NONAME:
 716       return ACE_TEXT ("Name does not resolve to an address");
 717     case EAI_AGAIN:
 718       return ACE_TEXT ("Temporary failure, try again");
 719     case EAI_FAIL:
 720       return ACE_TEXT ("Name resolution failed");
 721     case EAI_FAMILY:
 722       return ACE_TEXT ("Address family not supported");
 723     case EAI_MEMORY:
 724       return ACE_TEXT ("Out of memory");
 725     case EAI_SYSTEM:
 726       return ACE_TEXT ("Other error, see errno");
 727     case EAI_OVERFLOW:
 728       return ACE_TEXT ("Buffer provided by caller was too small");
 729     default:
 730       return ACE_TEXT ("Unknown error");
 731     }
 732 #elif defined ACE_WIN32
 733   return ACE_TEXT_gai_strerror (errcode);
 734 #else
 735   return ACE_TEXT_CHAR_TO_TCHAR (::gai_strerror (errcode));
 736 #endif
 737 }
 738
 739 ACE_INLINE int
 740 ACE_OS::getnameinfo (const sockaddr *addr, ACE_SOCKET_LEN addr_len,
 741                      char *host, ACE_SOCKET_LEN host_len,
 742                      char *service, ACE_SOCKET_LEN service_len,
 743                      unsigned int flags)
 744 {
 745   ACE_OS_TRACE ("ACE_OS::getnameinfo");
 746 #ifdef ACE_LACKS_GETNAMEINFO
 747   ACE_UNUSED_ARG (service);
 748   ACE_UNUSED_ARG (service_len);
 749   ACE_UNUSED_ARG (flags);
 750   return ACE_OS::getnameinfo_emulation (addr, addr_len, host, host_len);
 751 #else
 752   return ::getnameinfo (addr, addr_len, host, host_len,
 753                         service, service_len, flags);
 754 #endif
 755 }
 756
 757 ACE_END_VERSIONED_NAMESPACE_DECL