inet/getnameinfo.c

   1 /* The Inner Net License, Version 2.00
   2
   3   The author(s) grant permission for redistribution and use in source and
   4 binary forms, with or without modification, of the software and documentation
   5 provided that the following conditions are met:
   6
   7 0. If you receive a version of the software that is specifically labelled
   8    as not being for redistribution (check the version message and/or README),
   9    you are not permitted to redistribute that version of the software in any
  10    way or form.
  11 1. All terms of the all other applicable copyrights and licenses must be
  12    followed.
  13 2. Redistributions of source code must retain the authors' copyright
  14    notice(s), this list of conditions, and the following disclaimer.
  15 3. Redistributions in binary form must reproduce the authors' copyright
  16    notice(s), this list of conditions, and the following disclaimer in the
  17    documentation and/or other materials provided with the distribution.
  18 4. [The copyright holder has authorized the removal of this clause.]
  19 5. Neither the name(s) of the author(s) nor the names of its contributors
  20    may be used to endorse or promote products derived from this software
  21    without specific prior written permission.
  22
  23 THIS SOFTWARE IS PROVIDED BY ITS AUTHORS AND CONTRIBUTORS ``AS IS'' AND ANY
  24 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  25 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26 DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY
  27 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  28 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  30 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33
  34   If these license terms cause you a real problem, contact the author.  */
  35
  36 /* This software is Copyright 1996 by Craig Metz, All Rights Reserved.  */
  37
  38 #include <alloca.h>
  39 #include <errno.h>
  40 #include <netdb.h>
  41 #include <stddef.h>
  42 #include <stdlib.h>
  43 #include <stdio.h>
  44 #include <string.h>
  45 #include <unistd.h>
  46 #include <arpa/inet.h>
  47 #include <net/if.h>
  48 #include <netinet/in.h>
  49 #include <sys/param.h>
  50 #include <sys/socket.h>
  51 #include <sys/types.h>
  52 #include <sys/un.h>
  53 #include <sys/utsname.h>
  54 #include <bits/libc-lock.h>
  55
  56 #ifdef HAVE_LIBIDN
  57 # include <libidn/idna.h>
  58 extern int __idna_to_unicode_lzlz (const char *input, char **output,
  59                                    int flags);
  60 #endif
  61
  62 #ifndef min
  63 # define min(x,y) (((x) > (y)) ? (y) : (x))
  64 #endif /* min */
  65
  66 libc_freeres_ptr (static char *domain);
  67
  68
  69 static char *
  70 internal_function
  71 nrl_domainname (void)
  72 {
  73   static int not_first;
  74
  75   if (! not_first)
  76     {
  77       __libc_lock_define_initialized (static, lock);
  78       __libc_lock_lock (lock);
  79
  80       if (! not_first)
  81         {
  82           char *c;
  83           struct hostent *h, th;
  84           size_t tmpbuflen = 1024;
  85           char *tmpbuf = alloca (tmpbuflen);
  86           int herror;
  87
  88           not_first = 1;
  89
  90           while (__gethostbyname_r ("localhost", &th, tmpbuf, tmpbuflen, &h,
  91                                     &herror))
  92             {
  93               if (herror == NETDB_INTERNAL && errno == ERANGE)
  94                 tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
  95               else
  96                 break;
  97             }
  98
  99           if (h && (c = strchr (h->h_name, '.')))
 100             domain = __strdup (++c);
 101           else
 102             {
 103               /* The name contains no domain information.  Use the name
 104                  now to get more information.  */
 105               while (__gethostname (tmpbuf, tmpbuflen))
 106                 tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
 107
 108               if ((c = strchr (tmpbuf, '.')))
 109                 domain = __strdup (++c);
 110               else
 111                 {
 112                   /* We need to preserve the hostname.  */
 113                   const char *hstname = strdupa (tmpbuf);
 114
 115                   while (__gethostbyname_r (hstname, &th, tmpbuf, tmpbuflen,
 116                                             &h, &herror))
 117                     {
 118                       if (herror == NETDB_INTERNAL && errno == ERANGE)
 119                         tmpbuf = extend_alloca (tmpbuf, tmpbuflen,
 120                                                 2 * tmpbuflen);
 121                       else
 122                         break;
 123                     }
 124
 125                   if (h && (c = strchr(h->h_name, '.')))
 126                     domain = __strdup (++c);
 127                   else
 128                     {
 129                       struct in_addr in_addr;
 130
 131                       in_addr.s_addr = htonl (INADDR_LOOPBACK);
 132
 133                       while (__gethostbyaddr_r ((const char *) &in_addr,
 134                                                 sizeof (struct in_addr),
 135                                                 AF_INET, &th, tmpbuf,
 136                                                 tmpbuflen, &h, &herror))
 137                         {
 138                           if (herror == NETDB_INTERNAL && errno == ERANGE)
 139                             tmpbuf = extend_alloca (tmpbuf, tmpbuflen,
 140                                                     2 * tmpbuflen);
 141                           else
 142                             break;
 143                         }
 144
 145                       if (h && (c = strchr (h->h_name, '.')))
 146                         domain = __strdup (++c);
 147                     }
 148                 }
 149             }
 150         }
 151
 152       __libc_lock_unlock (lock);
 153     }
 154
 155   return domain;
 156 };
 157
 158
 159 int
 160 getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
 161              socklen_t hostlen, char *serv, socklen_t servlen,
 162              unsigned int flags)
 163 {
 164   int serrno = errno;
 165   int tmpbuflen = 1024;
 166   int herrno;
 167   char *tmpbuf = alloca (tmpbuflen);
 168   struct hostent th;
 169   int ok = 0;
 170
 171   if (flags & ~(NI_NUMERICHOST|NI_NUMERICSERV|NI_NOFQDN|NI_NAMEREQD|NI_DGRAM
 172 #ifdef HAVE_LIBIDN
 173                 |NI_IDN|NI_IDN_ALLOW_UNASSIGNED|NI_IDN_USE_STD3_ASCII_RULES
 174 #endif
 175                 ))
 176     return EAI_BADFLAGS;
 177
 178   if (sa == NULL || addrlen < sizeof (sa_family_t))
 179     return EAI_FAMILY;
 180
 181   if ((flags & NI_NAMEREQD) && host == NULL && serv == NULL)
 182     return EAI_NONAME;
 183
 184   switch (sa->sa_family)
 185     {
 186     case AF_LOCAL:
 187       if (addrlen < (socklen_t) offsetof (struct sockaddr_un, sun_path))
 188         return EAI_FAMILY;
 189       break;
 190     case AF_INET:
 191       if (addrlen < sizeof (struct sockaddr_in))
 192         return EAI_FAMILY;
 193       break;
 194     case AF_INET6:
 195       if (addrlen < sizeof (struct sockaddr_in6))
 196         return EAI_FAMILY;
 197       break;
 198     default:
 199       return EAI_FAMILY;
 200     }
 201
 202   if (host != NULL && hostlen > 0)
 203     switch (sa->sa_family)
 204       {
 205       case AF_INET:
 206       case AF_INET6:
 207         if (!(flags & NI_NUMERICHOST))
 208           {
 209             struct hostent *h = NULL;
 210             if (sa->sa_family == AF_INET6)
 211               {
 212                 while (__gethostbyaddr_r ((const void *) &(((const struct sockaddr_in6 *) sa)->sin6_addr),
 213                                           sizeof(struct in6_addr),
 214                                           AF_INET6, &th, tmpbuf, tmpbuflen,
 215                                           &h, &herrno))
 216                   if (herrno == NETDB_INTERNAL && errno == ERANGE)
 217                     tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
 218                   else
 219                     break;
 220               }
 221             else
 222               {
 223                 while (__gethostbyaddr_r ((const void *) &(((const struct sockaddr_in *)sa)->sin_addr),
 224                                           sizeof(struct in_addr), AF_INET,
 225                                           &th, tmpbuf, tmpbuflen,
 226                                           &h, &herrno))
 227                   if (herrno == NETDB_INTERNAL && errno == ERANGE)
 228                     tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
 229                   else
 230                     break;
 231               }
 232
 233             if (h == NULL)
 234               {
 235                 if (herrno == NETDB_INTERNAL)
 236                   {
 237                     __set_h_errno (herrno);
 238                     return EAI_SYSTEM;
 239                   }
 240                 if (herrno == TRY_AGAIN)
 241                   {
 242                     __set_h_errno (herrno);
 243                     return EAI_AGAIN;
 244                   }
 245               }
 246
 247             if (h)
 248               {
 249                 char *c;
 250                 if ((flags & NI_NOFQDN)
 251                     && (c = nrl_domainname ())
 252                     && (c = strstr (h->h_name, c))
 253                     && (c != h->h_name) && (*(--c) == '.'))
 254                   /* Terminate the string after the prefix.  */
 255                   *c = '\0';
 256
 257 #ifdef HAVE_LIBIDN
 258                 /* If requested, convert from the IDN format.  */
 259                 if (flags & NI_IDN)
 260                   {
 261                     int idn_flags = 0;
 262                     if  (flags & NI_IDN_ALLOW_UNASSIGNED)
 263                       idn_flags |= IDNA_ALLOW_UNASSIGNED;
 264                     if (flags & NI_IDN_USE_STD3_ASCII_RULES)
 265                       idn_flags |= IDNA_USE_STD3_ASCII_RULES;
 266
 267                     char *out;
 268                     int rc = __idna_to_unicode_lzlz (h->h_name, &out,
 269                                                      idn_flags);
 270                     if (rc != IDNA_SUCCESS)
 271                       {
 272                         if (rc == IDNA_MALLOC_ERROR)
 273                           return EAI_MEMORY;
 274                         if (rc == IDNA_DLOPEN_ERROR)
 275                           return EAI_SYSTEM;
 276                         return EAI_IDN_ENCODE;
 277                       }
 278
 279                     if (out != h->h_name)
 280                       {
 281                         h->h_name = strdupa (out);
 282                         free (out);
 283                       }
 284                   }
 285 #endif
 286
 287                 size_t len = strlen (h->h_name) + 1;
 288                 if (len > hostlen)
 289                   return EAI_OVERFLOW;
 290
 291                 memcpy (host, h->h_name, len);
 292
 293                 ok = 1;
 294               }
 295           }
 296
 297         if (!ok)
 298           {
 299             if (flags & NI_NAMEREQD)
 300               {
 301                 __set_errno (serrno);
 302                 return EAI_NONAME;
 303               }
 304             else
 305               {
 306                 const char *c;
 307                 if (sa->sa_family == AF_INET6)
 308                   {
 309                     const struct sockaddr_in6 *sin6p;
 310                     uint32_t scopeid;
 311
 312                     sin6p = (const struct sockaddr_in6 *) sa;
 313
 314                     c = inet_ntop (AF_INET6,
 315                                    (const void *) &sin6p->sin6_addr, host, hostlen);
 316                     scopeid = sin6p->sin6_scope_id;
 317                     if (scopeid != 0)
 318                       {
 319                         /* Buffer is >= IFNAMSIZ+1.  */
 320                         char scopebuf[IFNAMSIZ + 1];
 321                         char *scopeptr;
 322                         int ni_numericscope = 0;
 323                         size_t real_hostlen = __strnlen (host, hostlen);
 324                         size_t scopelen = 0;
 325
 326                         scopebuf[0] = SCOPE_DELIMITER;
 327                         scopebuf[1] = '\0';
 328                         scopeptr = &scopebuf[1];
 329
 330                         if (IN6_IS_ADDR_LINKLOCAL (&sin6p->sin6_addr)
 331                             || IN6_IS_ADDR_MC_LINKLOCAL (&sin6p->sin6_addr))
 332                           {
 333                             if (if_indextoname (scopeid, scopeptr) == NULL)
 334                               ++ni_numericscope;
 335                             else
 336                               scopelen = strlen (scopebuf);
 337                           }
 338                         else
 339                           ++ni_numericscope;
 340
 341                         if (ni_numericscope)
 342                           scopelen = 1 + __snprintf (scopeptr,
 343                                                      (scopebuf
 344                                                       + sizeof scopebuf
 345                                                       - scopeptr),
 346                                                      "%u", scopeid);
 347
 348                         if (real_hostlen + scopelen + 1 > hostlen)
 349                           /* XXX We should not fail here.  Simply enlarge
 350                              the buffer or return with out of memory.  */
 351                           return EAI_SYSTEM;
 352                         memcpy (host + real_hostlen, scopebuf, scopelen + 1);
 353                       }
 354                   }
 355                 else
 356                   c = inet_ntop (AF_INET,
 357                                  (const void *) &(((const struct sockaddr_in *) sa)->sin_addr),
 358                                  host, hostlen);
 359                 if (c == NULL)
 360                   return EAI_SYSTEM;
 361               }
 362             ok = 1;
 363           }
 364         break;
 365
 366       case AF_LOCAL:
 367         if (!(flags & NI_NUMERICHOST))
 368           {
 369             struct utsname utsname;
 370
 371             if (!uname (&utsname))
 372               {
 373                 strncpy (host, utsname.nodename, hostlen);
 374                 break;
 375               };
 376           };
 377
 378         if (flags & NI_NAMEREQD)
 379            {
 380             __set_errno (serrno);
 381             return EAI_NONAME;
 382           }
 383
 384         strncpy (host, "localhost", hostlen);
 385         break;
 386
 387       default:
 388         return EAI_FAMILY;
 389     }
 390
 391   if (serv && (servlen > 0))
 392     switch (sa->sa_family)
 393       {
 394       case AF_INET:
 395       case AF_INET6:
 396         if (!(flags & NI_NUMERICSERV))
 397           {
 398             struct servent *s, ts;
 399             int e;
 400             while ((e = __getservbyport_r (((const struct sockaddr_in *) sa)->sin_port,
 401                                            ((flags & NI_DGRAM)
 402                                             ? "udp" : "tcp"),
 403                                            &ts, tmpbuf, tmpbuflen, &s)))
 404               {
 405                 if (e == ERANGE)
 406                   tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
 407                 else
 408                   break;
 409               }
 410             if (s)
 411               {
 412                 strncpy (serv, s->s_name, servlen);
 413                 break;
 414               }
 415           }
 416
 417         if (__snprintf (serv, servlen, "%d",
 418                         ntohs (((const struct sockaddr_in *) sa)->sin_port))
 419             + 1 > servlen)
 420           return EAI_OVERFLOW;
 421
 422         break;
 423
 424       case AF_LOCAL:
 425         strncpy (serv, ((const struct sockaddr_un *) sa)->sun_path, servlen);
 426         break;
 427     }
 428
 429   if (host && (hostlen > 0))
 430     host[hostlen-1] = 0;
 431   if (serv && (servlen > 0))
 432     serv[servlen-1] = 0;
 433   errno = serrno;
 434   return 0;
 435 }
 436 libc_hidden_def (getnameinfo)