StdLib/BsdSocketLib/getnameinfo.c

   1 /** @file
   2   Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   3   This program and the accompanying materials are licensed and made available
   4   under the terms and conditions of the BSD License which accompanies this
   5   distribution.  The full text of the license may be found at
   6   http://opensource.org/licenses/bsd-license.php.
   7
   8   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   9   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  10 **/
  11 /*  $NetBSD: getnameinfo.c,v 1.45 2006/10/15 16:14:46 christos Exp $  */
  12 /*  $KAME: getnameinfo.c,v 1.45 2000/09/25 22:43:56 itojun Exp $  */
  13
  14 /*
  15  * Copyright (c) 2000 Ben Harris.
  16  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  17  * All rights reserved.
  18  *
  19  * Redistribution and use in source and binary forms, with or without
  20  * modification, are permitted provided that the following conditions
  21  * are met:
  22  * 1. Redistributions of source code must retain the above copyright
  23  *    notice, this list of conditions and the following disclaimer.
  24  * 2. Redistributions in binary form must reproduce the above copyright
  25  *    notice, this list of conditions and the following disclaimer in the
  26  *    documentation and/or other materials provided with the distribution.
  27  * 3. Neither the name of the project nor the names of its contributors
  28  *    may be used to endorse or promote products derived from this software
  29  *    without specific prior written permission.
  30  *
  31  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  32  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  35  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  39  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  40  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  41  * SUCH DAMAGE.
  42  */
  43
  44 /*
  45  * Issues to be discussed:
  46  * - Thread safe-ness must be checked
  47  * - RFC2553 says that we should raise error on short buffer.  X/Open says
  48  *   we need to truncate the result.  We obey RFC2553 (and X/Open should be
  49  *   modified).  ipngwg rough consensus seems to follow RFC2553.
  50  * - What is "local" in NI_FQDN?
  51  * - NI_NAMEREQD and NI_NUMERICHOST conflict with each other.
  52  * - (KAME extension) always attach textual scopeid (fe80::1%lo0), if
  53  *   sin6_scope_id is filled - standardization status?
  54  *   XXX breaks backward compat for code that expects no scopeid.
  55  *   beware on merge.
  56  */
  57
  58 #define INET6   1
  59
  60 #include <sys/cdefs.h>
  61 #if defined(LIBC_SCCS) && !defined(lint)
  62 __RCSID("$NetBSD: getnameinfo.c,v 1.45 2006/10/15 16:14:46 christos Exp $");
  63 #endif /* LIBC_SCCS and not lint */
  64
  65 #include "namespace.h"
  66 #include <sys/types.h>
  67 #include <sys/socket.h>
  68 #include <net/if.h>
  69 #include <net/if_dl.h>
  70 //#include <net/if_ieee1394.h>
  71 //#include <net/if_types.h>
  72 #include <netinet/in.h>
  73 #include <arpa/inet.h>
  74 #include <arpa/nameser.h>
  75 #include <assert.h>
  76 #include <limits.h>
  77 #include <netdb.h>
  78 #include <resolv.h>
  79 #include <stddef.h>
  80 #include <string.h>
  81
  82 #include <net/servent.h>
  83
  84 #define CLLADDR(x)          ( LLADDR(x) )
  85 #define endservent_r(svd)   endservent()
  86 #define getservbyport_r(Port,pProto,pSv,pSvd)   getservbyport(Port,pProto)
  87
  88 #ifdef __weak_alias
  89 __weak_alias(getnameinfo,_getnameinfo)
  90 #endif
  91
  92 static
  93 int
  94 hexname(
  95   const u_int8_t * cp,
  96   size_t len,
  97   char * host,
  98   socklen_t hostlen
  99   );
 100
 101 static const struct afd {
 102   int   a_af;
 103   socklen_t a_addrlen;
 104   socklen_t a_socklen;
 105   int   a_off;
 106 } afdl [] = {
 107 #ifdef INET6
 108   {PF_INET6, sizeof(struct in6_addr), sizeof(struct sockaddr_in6),
 109     offsetof(struct sockaddr_in6, sin6_addr)},
 110 #endif
 111   {PF_INET, sizeof(struct in_addr), sizeof(struct sockaddr_in),
 112     offsetof(struct sockaddr_in, sin_addr)},
 113   {0, 0, 0, 0},
 114 };
 115
 116 struct sockinet {
 117   u_char  si_len;
 118   u_char  si_family;
 119   u_short si_port;
 120 };
 121
 122 static int getnameinfo_inet __P((const struct sockaddr *, socklen_t, char *,
 123     socklen_t, char *, socklen_t, int));
 124 #ifdef INET6
 125 static int ip6_parsenumeric __P((const struct sockaddr *, const char *, char *,
 126          socklen_t, int));
 127 static int ip6_sa2str __P((const struct sockaddr_in6 *, char *, size_t,
 128          int));
 129 #endif
 130 static int getnameinfo_link __P((const struct sockaddr *, socklen_t, char *,
 131     socklen_t, char *, socklen_t, int));
 132 static int hexname __P((const u_int8_t *, size_t, char *, socklen_t));
 133
 134 /*
 135  * Top-level getnameinfo() code.  Look at the address family, and pick an
 136  * appropriate function to call.
 137  */
 138 int
 139 getnameinfo(
 140   const struct sockaddr * sa,
 141   socklen_t salen,
 142   char * host,
 143   socklen_t hostlen,
 144   char * serv,
 145   socklen_t servlen,
 146   int flags
 147   )
 148 {
 149
 150   switch (sa->sa_family) {
 151   case AF_INET:
 152   case AF_INET6:
 153     return getnameinfo_inet(sa, salen, host, hostlen,
 154         serv, servlen, flags);
 155   case AF_LINK:
 156     return getnameinfo_link(sa, salen, host, hostlen,
 157         serv, servlen, flags);
 158   default:
 159     return EAI_FAMILY;
 160   }
 161 }
 162
 163
 164 /*
 165  * getnameinfo_inet():
 166  * Format an IPv4 or IPv6 sockaddr into a printable string.
 167  */
 168 static
 169 int
 170 getnameinfo_inet(
 171   const struct sockaddr * sa,
 172   socklen_t salen,
 173   char * host,
 174   socklen_t hostlen,
 175   char * serv,
 176   socklen_t servlen,
 177   int flags
 178   )
 179 {
 180   const struct afd *afd;
 181   struct servent *sp;
 182   struct hostent *hp;
 183   u_short port;
 184   int family, i;
 185   const char *addr;
 186   u_int32_t v4a;
 187   char numserv[512];
 188   char numaddr[512];
 189
 190   /* sa is checked below */
 191   /* host may be NULL */
 192   /* serv may be NULL */
 193
 194   if (sa == NULL)
 195     return EAI_FAIL;
 196
 197 #ifdef BSD4_4
 198   if (sa->sa_len != salen)
 199     return EAI_FAIL;
 200 #endif
 201
 202   family = sa->sa_family;
 203   for (i = 0; afdl[i].a_af; i++)
 204     if (afdl[i].a_af == family) {
 205       afd = &afdl[i];
 206       goto found;
 207     }
 208   return EAI_FAMILY;
 209
 210  found:
 211   if (salen != afd->a_socklen)
 212     return EAI_FAIL;
 213
 214   /* network byte order */
 215   port = ((const struct sockinet *)(const void *)sa)->si_port;
 216   addr = (const char *)(const void *)sa + afd->a_off;
 217
 218   if (serv == NULL || servlen == 0) {
 219     /*
 220      * do nothing in this case.
 221      * in case you are wondering if "&&" is more correct than
 222      * "||" here: rfc2553bis-03 says that serv == NULL OR
 223      * servlen == 0 means that the caller does not want the result.
 224      */
 225   } else {
 226     if (flags & NI_NUMERICSERV)
 227       sp = NULL;
 228     else {
 229       struct servent_data svd;
 230 //      struct servent sv;
 231
 232       (void)memset(&svd, 0, sizeof(svd));
 233       sp = getservbyport_r(port,
 234         (flags & NI_DGRAM) ? "udp" : "tcp", &sv, &svd);
 235       endservent_r(&svd);
 236     }
 237     if (sp) {
 238       if (strlen(sp->s_name) + 1 > servlen)
 239         return EAI_MEMORY;
 240       strlcpy(serv, sp->s_name, servlen);
 241     } else {
 242       snprintf(numserv, sizeof(numserv), "%u", ntohs(port));
 243       if (strlen(numserv) + 1 > servlen)
 244         return EAI_MEMORY;
 245       strlcpy(serv, numserv, servlen);
 246     }
 247   }
 248
 249   switch (sa->sa_family) {
 250   case AF_INET:
 251     v4a = (u_int32_t)
 252         ntohl(((const struct sockaddr_in *)
 253         (const void *)sa)->sin_addr.s_addr);
 254     if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
 255       flags |= NI_NUMERICHOST;
 256     v4a >>= IN_CLASSA_NSHIFT;
 257     if (v4a == 0)
 258       flags |= NI_NUMERICHOST;
 259     break;
 260 #ifdef INET6
 261   case AF_INET6:
 262       {
 263     const struct sockaddr_in6 *sin6;
 264     sin6 = (const struct sockaddr_in6 *)(const void *)sa;
 265     switch (sin6->sin6_addr.s6_addr[0]) {
 266     case 0x00:
 267       if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
 268         ;
 269       else if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
 270         ;
 271       else
 272         flags |= NI_NUMERICHOST;
 273       break;
 274     default:
 275       if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
 276         flags |= NI_NUMERICHOST;
 277       }
 278       else if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
 279         flags |= NI_NUMERICHOST;
 280       break;
 281     }
 282       }
 283     break;
 284 #endif
 285   }
 286   if (host == NULL || hostlen == 0) {
 287     /*
 288      * do nothing in this case.
 289      * in case you are wondering if "&&" is more correct than
 290      * "||" here: rfc2553bis-03 says that host == NULL or
 291      * hostlen == 0 means that the caller does not want the result.
 292      */
 293   } else if (flags & NI_NUMERICHOST) {
 294     size_t numaddrlen;
 295
 296     /* NUMERICHOST and NAMEREQD conflicts with each other */
 297     if (flags & NI_NAMEREQD)
 298       return EAI_NONAME;
 299
 300     switch(afd->a_af) {
 301 #ifdef INET6
 302     case AF_INET6:
 303     {
 304       int error;
 305
 306       if ((error = ip6_parsenumeric(sa, addr, host,
 307                   hostlen, flags)) != 0)
 308         return(error);
 309       break;
 310     }
 311 #endif
 312     default:
 313       if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
 314           == NULL)
 315         return EAI_SYSTEM;
 316       numaddrlen = strlen(numaddr);
 317       if (numaddrlen + 1 > hostlen) /* don't forget terminator */
 318         return EAI_MEMORY;
 319       strlcpy(host, numaddr, hostlen);
 320       break;
 321     }
 322   } else {
 323     hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af);
 324
 325     if (hp) {
 326 #if 0
 327       /*
 328        * commented out, since "for local host" is not
 329        * implemented here - see RFC2553 p30
 330        */
 331       if (flags & NI_NOFQDN) {
 332         char *p;
 333         p = strchr(hp->h_name, '.');
 334         if (p)
 335           *p = '\0';
 336       }
 337 #endif
 338       if (strlen(hp->h_name) + 1 > hostlen) {
 339         return EAI_MEMORY;
 340       }
 341       strlcpy(host, hp->h_name, hostlen);
 342     } else {
 343       if (flags & NI_NAMEREQD)
 344         return EAI_NONAME;
 345       switch(afd->a_af) {
 346 #ifdef INET6
 347       case AF_INET6:
 348       {
 349         int error;
 350
 351         if ((error = ip6_parsenumeric(sa, addr, host,
 352                     hostlen,
 353                     flags)) != 0)
 354           return(error);
 355         break;
 356       }
 357 #endif
 358       default:
 359         if (inet_ntop(afd->a_af, addr, host,
 360             hostlen) == NULL)
 361           return EAI_SYSTEM;
 362         break;
 363       }
 364     }
 365   }
 366   return(0);
 367 }
 368
 369 #ifdef INET6
 370 static int
 371 ip6_parsenumeric(
 372   const struct sockaddr *sa,
 373   const char *addr,
 374   char *host,
 375   socklen_t hostlen,
 376   int flags
 377   )
 378 {
 379   size_t numaddrlen;
 380   char numaddr[512];
 381
 382   _DIAGASSERT(sa != NULL);
 383   _DIAGASSERT(addr != NULL);
 384   _DIAGASSERT(host != NULL);
 385
 386   if (inet_ntop(AF_INET6, addr, numaddr, sizeof(numaddr)) == NULL)
 387     return EAI_SYSTEM;
 388
 389   numaddrlen = strlen(numaddr);
 390   if (numaddrlen + 1 > hostlen) /* don't forget terminator */
 391     return EAI_OVERFLOW;
 392   strlcpy(host, numaddr, hostlen);
 393
 394   if (((const struct sockaddr_in6 *)(const void *)sa)->sin6_scope_id) {
 395     char zonebuf[MAXHOSTNAMELEN];
 396     int zonelen;
 397
 398     zonelen = ip6_sa2str(
 399         (const struct sockaddr_in6 *)(const void *)sa,
 400         zonebuf, sizeof(zonebuf), flags);
 401     if (zonelen < 0)
 402       return EAI_OVERFLOW;
 403     if ((size_t) zonelen + 1 + numaddrlen + 1 > hostlen)
 404       return EAI_OVERFLOW;
 405     /* construct <numeric-addr><delim><zoneid> */
 406     memcpy(host + numaddrlen + 1, zonebuf,
 407         (size_t)zonelen);
 408     host[numaddrlen] = SCOPE_DELIMITER;
 409     host[numaddrlen + 1 + zonelen] = '\0';
 410   }
 411
 412   return 0;
 413 }
 414
 415 /* ARGSUSED */
 416 static int
 417 ip6_sa2str(
 418   const struct sockaddr_in6 *sa6,
 419   char *buf,
 420   size_t bufsiz,
 421   int flags
 422   )
 423 {
 424 #if 0
 425   unsigned int ifindex;
 426   const struct in6_addr *a6;
 427 #endif
 428   int n;
 429
 430   _DIAGASSERT(sa6 != NULL);
 431   _DIAGASSERT(buf != NULL);
 432
 433 #if 0
 434   ifindex = (unsigned int)sa6->sin6_scope_id;
 435   a6 = &sa6->sin6_addr;
 436 #endif
 437
 438 #ifdef NI_NUMERICSCOPE
 439   if ((flags & NI_NUMERICSCOPE) != 0) {
 440     n = snprintf(buf, bufsiz, "%u", sa6->sin6_scope_id);
 441     if ((n < 0) || ((size_t)n >= bufsiz))
 442       return -1;
 443     else
 444       return n;
 445   }
 446 #endif
 447
 448 #if 0
 449   /* if_indextoname() does not take buffer size.  not a good api... */
 450   if ((IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6)) &&
 451       bufsiz >= IF_NAMESIZE) {
 452     char *p = if_indextoname(ifindex, buf);
 453     if (p) {
 454       return(strlen(p));
 455     }
 456   }
 457 #endif  //  0
 458
 459   /* last resort */
 460   n = snprintf(buf, bufsiz, "%u", sa6->sin6_scope_id);
 461   if (n < 0 || (size_t) n >= bufsiz)
 462     return -1;
 463   else
 464     return n;
 465 }
 466 #endif /* INET6 */
 467
 468
 469 /*
 470  * getnameinfo_link():
 471  * Format a link-layer address into a printable format, paying attention to
 472  * the interface type.
 473  */
 474 /* ARGSUSED */
 475 static
 476 int
 477 getnameinfo_link (
 478   const struct sockaddr * sa,
 479   socklen_t salen,
 480   char * host,
 481   socklen_t hostlen,
 482   char * serv,
 483   socklen_t servlen,
 484   int flags
 485   )
 486 {
 487   const struct sockaddr_dl *sdl =
 488       (const struct sockaddr_dl *)(const void *)sa;
 489 //  const struct ieee1394_hwaddr *iha;
 490   int n;
 491
 492   if (serv != NULL && servlen > 0)
 493     *serv = '\0';
 494
 495   if (sdl->sdl_nlen == 0 && sdl->sdl_alen == 0 && sdl->sdl_slen == 0) {
 496     n = snprintf(host, hostlen, "link#%u", sdl->sdl_index);
 497     if (n < 0 || (socklen_t) n > hostlen) {
 498       *host = '\0';
 499       return EAI_MEMORY;
 500     }
 501     return 0;
 502   }
 503
 504 #if 0
 505   switch (sdl->sdl_type) {
 506 #ifdef IFT_ECONET
 507   case IFT_ECONET:
 508     if (sdl->sdl_alen < 2)
 509       return EAI_FAMILY;
 510     if (CLLADDR(sdl)[1] == 0)
 511       n = snprintf(host, hostlen, "%u", CLLADDR(sdl)[0]);
 512     else
 513       n = snprintf(host, hostlen, "%u.%u",
 514           CLLADDR(sdl)[1], CLLADDR(sdl)[0]);
 515     if (n < 0 || (socklen_t) n >= hostlen) {
 516       *host = '\0';
 517       return EAI_MEMORY;
 518     } else
 519       return 0;
 520 #endif
 521   case IFT_IEEE1394:
 522     if (sdl->sdl_alen < sizeof(iha->iha_uid))
 523       return EAI_FAMILY;
 524     iha =
 525         (const struct ieee1394_hwaddr *)(const void *)CLLADDR(sdl);
 526     return hexname(iha->iha_uid, sizeof(iha->iha_uid),
 527         host, hostlen);
 528   /*
 529    * The following have zero-length addresses.
 530    * IFT_ATM  (net/if_atmsubr.c)
 531    * IFT_FAITH  (net/if_faith.c)
 532    * IFT_GIF  (net/if_gif.c)
 533    * IFT_LOOP (net/if_loop.c)
 534    * IFT_PPP  (net/if_ppp.c, net/if_spppsubr.c)
 535    * IFT_SLIP (net/if_sl.c, net/if_strip.c)
 536    * IFT_STF  (net/if_stf.c)
 537    * IFT_L2VLAN (net/if_vlan.c)
 538    * IFT_PROPVIRTUAL (net/if_bridge.h>
 539    */
 540   /*
 541    * The following use IPv4 addresses as link-layer addresses:
 542    * IFT_OTHER  (net/if_gre.c)
 543    */
 544   case IFT_ARCNET: /* default below is believed correct for all these. */
 545   case IFT_ETHER:
 546   case IFT_FDDI:
 547   case IFT_HIPPI:
 548   case IFT_ISO88025:
 549   default:
 550 #endif  //  0
 551     return hexname((const u_int8_t *)CLLADDR(sdl),
 552         (size_t)sdl->sdl_alen, host, hostlen);
 553 //  }
 554 }
 555
 556 static
 557 int
 558 hexname(
 559   const u_int8_t * cp,
 560   size_t len,
 561   char * host,
 562   socklen_t hostlen
 563   )
 564 {
 565   int n;
 566   size_t i;
 567   char *outp = host;
 568
 569   *outp = '\0';
 570   for (i = 0; i < len; i++) {
 571     n = snprintf(outp, hostlen, "%s%02x",
 572         i ? ":" : "", cp[i]);
 573     if (n < 0 || (socklen_t) n >= hostlen) {
 574       *host = '\0';
 575       return EAI_MEMORY;
 576     }
 577     outp += n;
 578     hostlen -= n;
 579   }
 580   return 0;
 581 }