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:   switch (sa->sa_family)
  182:     {
  183:     case AF_LOCAL:
  184:       if (addrlen < (socklen_t) offsetof (struct sockaddr_un, sun_path))
  185:         return EAI_FAMILY;
  186:       break;
  187:     case AF_INET:
  188:       if (addrlen < sizeof (struct sockaddr_in))
  189:         return EAI_FAMILY;
  190:       break;
  191:     case AF_INET6:
  192:       if (addrlen < sizeof (struct sockaddr_in6))
  193:         return EAI_FAMILY;
  194:       break;
  195:     default:
  196:       return EAI_FAMILY;
  197:     }
  198: 
  199:   if (host != NULL && hostlen > 0)
  200:     switch (sa->sa_family)
  201:       {
  202:       case AF_INET:
  203:       case AF_INET6:
  204:         if (!(flags & NI_NUMERICHOST))
  205:           {
  206:             struct hostent *h = NULL;
  207:             if (sa->sa_family == AF_INET6)
  208:               {
  209:                 while (__gethostbyaddr_r ((const void *) &(((const struct sockaddr_in6 *) sa)->sin6_addr),
  210:                                           sizeof(struct in6_addr),
  211:                                           AF_INET6, &th, tmpbuf, tmpbuflen,
  212:                                           &h, &herrno))
  213:                   if (herrno == NETDB_INTERNAL && errno == ERANGE)
  214:                     tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
  215:                   else
  216:                     break;
  217:               }
  218:             else
  219:               {
  220:                 while (__gethostbyaddr_r ((const void *) &(((const struct sockaddr_in *)sa)->sin_addr),
  221:                                           sizeof(struct in_addr), AF_INET,
  222:                                           &th, tmpbuf, tmpbuflen,
  223:                                           &h, &herrno))
  224:                   if (herrno == NETDB_INTERNAL && errno == ERANGE)
  225:                     tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
  226:                   else
  227:                     break;
  228:               }
  229: 
  230:             if (h == NULL)
  231:               {
  232:                 if (herrno == NETDB_INTERNAL)
  233:                   {
  234:                     __set_h_errno (herrno);
  235:                     return EAI_SYSTEM;
  236:                   }
  237:                 if (herrno == TRY_AGAIN)
  238:                   {
  239:                     __set_h_errno (herrno);
  240:                     return EAI_AGAIN;
  241:                   }
  242:               }
  243: 
  244:             if (h)
  245:               {
  246:                 char *c;
  247:                 if ((flags & NI_NOFQDN)
  248:                     && (c = nrl_domainname ())
  249:                     && (c = strstr (h->h_name, c))
  250:                     && (c != h->h_name) && (*(--c) == '.'))
  251:                   /* Terminate the string after the prefix.  */
  252:                   *c = '\0';
  253: 
  254: #ifdef HAVE_LIBIDN
  255:                 /* If requested, convert from the IDN format.  */
  256:                 if (flags & NI_IDN)
  257:                   {
  258:                     int idn_flags = 0;
  259:                     if  (flags & NI_IDN_ALLOW_UNASSIGNED)
  260:                       idn_flags |= IDNA_ALLOW_UNASSIGNED;
  261:                     if (flags & NI_IDN_USE_STD3_ASCII_RULES)
  262:                       idn_flags |= IDNA_USE_STD3_ASCII_RULES;
  263: 
  264:                     char *out;
  265:                     int rc = __idna_to_unicode_lzlz (h->h_name, &out,
  266:                                                      idn_flags);
  267:                     if (rc != IDNA_SUCCESS)
  268:                       {
  269:                         if (rc == IDNA_MALLOC_ERROR)
  270:                           return EAI_MEMORY;
  271:                         if (rc == IDNA_DLOPEN_ERROR)
  272:                           return EAI_SYSTEM;
  273:                         return EAI_IDN_ENCODE;
  274:                       }
  275: 
  276:                     if (out != h->h_name)
  277:                       {
  278:                         h->h_name = strdupa (out);
  279:                         free (out);
  280:                       }
  281:                   }
  282: #endif
  283: 
  284:                 size_t len = strlen (h->h_name) + 1;
  285:                 if (len > hostlen)
  286:                   return EAI_OVERFLOW;
  287: 
  288:                 memcpy (host, h->h_name, len);
  289: 
  290:                 ok = 1;
  291:               }
  292:           }
  293: 
  294:         if (!ok)
  295:           {
  296:             if (flags & NI_NAMEREQD)
  297:               {
  298:                 __set_errno (serrno);
  299:                 return EAI_NONAME;
  300:               }
  301:             else
  302:               {
  303:                 const char *c;
  304:                 if (sa->sa_family == AF_INET6)
  305:                   {
  306:                     const struct sockaddr_in6 *sin6p;
  307:                     uint32_t scopeid;
  308: 
  309:                     sin6p = (const struct sockaddr_in6 *) sa;
  310: 
  311:                     c = inet_ntop (AF_INET6,
  312:                                    (const void *) &sin6p->sin6_addr, host, hostlen);
  313:                     scopeid = sin6p->sin6_scope_id;
  314:                     if (scopeid != 0)
  315:                       {
  316:                         /* Buffer is >= IFNAMSIZ+1.  */
  317:                         char scopebuf[IFNAMSIZ + 1];
  318:                         char *scopeptr;
  319:                         int ni_numericscope = 0;
  320:                         size_t real_hostlen = __strnlen (host, hostlen);
  321:                         size_t scopelen = 0;
  322: 
  323:                         scopebuf[0] = SCOPE_DELIMITER;
  324:                         scopebuf[1] = '\0';
  325:                         scopeptr = &scopebuf[1];
  326: 
  327:                         if (IN6_IS_ADDR_LINKLOCAL (&sin6p->sin6_addr)
  328:                             || IN6_IS_ADDR_MC_LINKLOCAL (&sin6p->sin6_addr))
  329:                           {
  330:                             if (if_indextoname (scopeid, scopeptr) == NULL)
  331:                               ++ni_numericscope;
  332:                             else
  333:                               scopelen = strlen (scopebuf);
  334:                           }
  335:                         else
  336:                           ++ni_numericscope;
  337: 
  338:                         if (ni_numericscope)
  339:                           scopelen = 1 + __snprintf (scopeptr,
  340:                                                      (scopebuf
  341:                                                       + sizeof scopebuf
  342:                                                       - scopeptr),
  343:                                                      "%u", scopeid);
  344: 
  345:                         if (real_hostlen + scopelen + 1 > hostlen)
  346:                           /* XXX We should not fail here.  Simply enlarge
  347:                              the buffer or return with out of memory.  */
  348:                           return EAI_SYSTEM;
  349:                         memcpy (host + real_hostlen, scopebuf, scopelen + 1);
  350:                       }
  351:                   }
  352:                 else
  353:                   c = inet_ntop (AF_INET,
  354:                                  (const void *) &(((const struct sockaddr_in *) sa)->sin_addr),
  355:                                  host, hostlen);
  356:                 if (c == NULL)
  357:                   return EAI_SYSTEM;
  358:               }
  359:             ok = 1;
  360:           }
  361:         break;
  362: 
  363:       case AF_LOCAL:
  364:         if (!(flags & NI_NUMERICHOST))
  365:           {
  366:             struct utsname utsname;
  367: 
  368:             if (!uname (&utsname))
  369:               {
  370:                 strncpy (host, utsname.nodename, hostlen);
  371:                 break;
  372:               };
  373:           };
  374: 
  375:         if (flags & NI_NAMEREQD)
  376:            {
  377:             __set_errno (serrno);
  378:             return EAI_NONAME;
  379:           }
  380: 
  381:         strncpy (host, "localhost", hostlen);
  382:         break;
  383: 
  384:       default:
  385:         return EAI_FAMILY;
  386:     }
  387: 
  388:   if (serv && (servlen > 0))
  389:     switch (sa->sa_family)
  390:       {
  391:       case AF_INET:
  392:       case AF_INET6:
  393:         if (!(flags & NI_NUMERICSERV))
  394:           {
  395:             struct servent *s, ts;
  396:             int e;
  397:             while ((e = __getservbyport_r (((const struct sockaddr_in *) sa)->sin_port,
  398:                                            ((flags & NI_DGRAM)
  399:                                             ? "udp" : "tcp"),
  400:                                            &ts, tmpbuf, tmpbuflen, &s)))
  401:               {
  402:                 if (e == ERANGE)
  403:                   tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);
  404:                 else
  405:                   break;
  406:               }
  407:             if (s)
  408:               {
  409:                 strncpy (serv, s->s_name, servlen);
  410:                 break;
  411:               }
  412:           }
  413: 
  414:         if (__snprintf (serv, servlen, "%d",
  415:                         ntohs (((const struct sockaddr_in *) sa)->sin_port))
  416:             + 1 > servlen)
  417:           return EAI_OVERFLOW;
  418: 
  419:         break;
  420: 
  421:       case AF_LOCAL:
  422:         strncpy (serv, ((const struct sockaddr_un *) sa)->sun_path, servlen);
  423:         break;
  424:     }
  425: 
  426:   if (host && (hostlen > 0))
  427:     host[hostlen-1] = 0;
  428:   if (serv && (servlen > 0))
  429:     serv[servlen-1] = 0;
  430:   errno = serrno;
  431:   return 0;
  432: }
  433: libc_hidden_def (getnameinfo)