external/bsd/bind/dist/lib/irs/getnameinfo.c

   1 /*      $NetBSD: getnameinfo.c,v 1.7 2015/07/08 17:28:59 christos Exp $ */
   2
   3 /*
   4  * Copyright (C) 2009, 2011-2014  Internet Systems Consortium, Inc. ("ISC")
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  11  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  12  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  13  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  14  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  15  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16  * PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 /* Id */
  20
  21 /*! \file */
  22
  23 /*
  24  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  25  * All rights reserved.
  26  *
  27  * Redistribution and use in source and binary forms, with or without
  28  * modification, are permitted provided that the following conditions
  29  * are met:
  30  * 1. Redistributions of source code must retain the above copyright
  31  *    notice, this list of conditions and the following disclaimer.
  32  * 2. Redistributions in binary form must reproduce the above copyright
  33  *    notice, this list of conditions and the following disclaimer in the
  34  *    documentation and/or other materials provided with the distribution.
  35  * 3. Neither the name of the project nor the names of its contributors
  36  *    may be used to endorse or promote products derived from this software
  37  *    without specific prior written permission.
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  40  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  42  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  43  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  44  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  45  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  47  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  48  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  49  * SUCH DAMAGE.
  50  */
  51
  52 /**
  53  *    getnameinfo() returns the hostname for the struct sockaddr sa which is
  54  *    salen bytes long. The hostname is of length hostlen and is returned via
  55  *    *host. The maximum length of the hostname is 1025 bytes: #NI_MAXHOST.
  56  *
  57  *    The name of the service associated with the port number in sa is
  58  *    returned in *serv. It is servlen bytes long. The maximum length of the
  59  *    service name is #NI_MAXSERV - 32 bytes.
  60  *
  61  *    The flags argument sets the following bits:
  62  *
  63  * \li   #NI_NOFQDN:
  64  *           A fully qualified domain name is not required for local hosts.
  65  *           The local part of the fully qualified domain name is returned
  66  *           instead.
  67  *
  68  * \li   #NI_NUMERICHOST
  69  *           Return the address in numeric form, as if calling inet_ntop(),
  70  *           instead of a host name.
  71  *
  72  * \li   #NI_NAMEREQD
  73  *           A name is required. If the hostname cannot be found in the DNS
  74  *           and this flag is set, a non-zero error code is returned. If the
  75  *           hostname is not found and the flag is not set, the address is
  76  *           returned in numeric form.
  77  *
  78  * \li   #NI_NUMERICSERV
  79  *           The service name is returned as a digit string representing the
  80  *           port number.
  81  *
  82  * \li   #NI_DGRAM
  83  *           Specifies that the service being looked up is a datagram
  84  *           service, and causes getservbyport() to be called with a second
  85  *           argument of "udp" instead of its default of "tcp". This is
  86  *           required for the few ports (512-514) that have different
  87  *           services for UDP and TCP.
  88  *
  89  * \section getnameinfo_return Return Values
  90  *
  91  *    getnameinfo() returns 0 on success or a non-zero error code if
  92  *    an error occurs.
  93  *
  94  * \section getname_see See Also
  95  *
  96  *    RFC3493, getservbyport(),
  97  *    getnamebyaddr(). inet_ntop().
  98  */
  99
 100 #include <config.h>
 101
 102 #include <stdio.h>
 103 #include <string.h>
 104
 105 #include <isc/netaddr.h>
 106 #include <isc/print.h>
 107 #include <isc/sockaddr.h>
 108 #include <isc/util.h>
 109
 110 #include <dns/byaddr.h>
 111 #include <dns/client.h>
 112 #include <dns/fixedname.h>
 113 #include <dns/name.h>
 114 #include <dns/rdata.h>
 115 #include <dns/rdataset.h>
 116 #include <dns/rdatastruct.h>
 117 #include <dns/result.h>
 118
 119 #include <irs/context.h>
 120 #include <irs/netdb.h>
 121
 122 #define SUCCESS 0
 123
 124 /*% afd structure definition */
 125 static struct afd {
 126         int a_af;
 127         size_t a_addrlen;
 128         size_t a_socklen;
 129 } afdl [] = {
 130         /*!
 131          * First entry is linked last...
 132          */
 133         { AF_INET, sizeof(struct in_addr), sizeof(struct sockaddr_in) },
 134         { AF_INET6, sizeof(struct in6_addr), sizeof(struct sockaddr_in6) },
 135         {0, 0, 0},
 136 };
 137
 138 /*!
 139  * The test against 0 is there to keep the Solaris compiler
 140  * from complaining about "end-of-loop code not reached".
 141  */
 142 #define ERR(code) \
 143         do { result = (code);                   \
 144                 if (result != 0) goto cleanup;  \
 145         } while (/*CONSTCOND*/0)
 146
 147 int
 148 getnameinfo(const struct sockaddr *sa, IRS_GETNAMEINFO_SOCKLEN_T salen,
 149             char *host, IRS_GETNAMEINFO_BUFLEN_T hostlen,
 150             char *serv, IRS_GETNAMEINFO_BUFLEN_T servlen,
 151             IRS_GETNAMEINFO_FLAGS_T flags)
 152 {
 153         struct afd *afd = NULL;
 154         struct servent *sp;
 155         unsigned short port = 0;
 156 #ifdef IRS_PLATFORM_HAVESALEN
 157         size_t len;
 158 #endif
 159         int family, i;
 160         const void *addr = NULL;
 161         char *p;
 162 #if 0
 163         unsigned long v4a;
 164         unsigned char pfx;
 165 #endif
 166         char numserv[sizeof("65000")];
 167         char numaddr[sizeof("abcd:abcd:abcd:abcd:abcd:abcd:255.255.255.255")
 168                     + 1 + sizeof("4294967295")];
 169         const char *proto;
 170         int result = SUCCESS;
 171
 172         if (sa == NULL)
 173                 ERR(EAI_FAIL);
 174
 175 #ifdef IRS_PLATFORM_HAVESALEN
 176         len = sa->sa_len;
 177         if (len != salen)
 178                 ERR(EAI_FAIL);
 179 #endif
 180
 181         family = sa->sa_family;
 182         for (i = 0; afdl[i].a_af; i++)
 183                 if (afdl[i].a_af == family) {
 184                         afd = &afdl[i];
 185                         goto found;
 186                 }
 187         ERR(EAI_FAMILY);
 188
 189  found:
 190         if (salen != afd->a_socklen)
 191                 ERR(EAI_FAIL);
 192
 193         switch (family) {
 194         case AF_INET:
 195                 port = ((const struct sockaddr_in *)sa)->sin_port;
 196                 addr = &((const struct sockaddr_in *)sa)->sin_addr.s_addr;
 197                 break;
 198
 199         case AF_INET6:
 200                 port = ((const struct sockaddr_in6 *)sa)->sin6_port;
 201                 addr = ((const struct sockaddr_in6 *)sa)->sin6_addr.s6_addr;
 202                 break;
 203
 204         default:
 205                 INSIST(0);
 206         }
 207         proto = (flags & NI_DGRAM) ? "udp" : "tcp";
 208
 209         if (serv == NULL || servlen == 0U) {
 210                 /*
 211                  * Caller does not want service.
 212                  */
 213         } else if ((flags & NI_NUMERICSERV) != 0 ||
 214                    (sp = getservbyport(port, proto)) == NULL) {
 215                 snprintf(numserv, sizeof(numserv), "%d", ntohs(port));
 216                 if ((strlen(numserv) + 1) > servlen)
 217                         ERR(EAI_OVERFLOW);
 218                 strcpy(serv, numserv);
 219         } else {
 220                 if ((strlen(sp->s_name) + 1) > servlen)
 221                         ERR(EAI_OVERFLOW);
 222                 strcpy(serv, sp->s_name);
 223         }
 224
 225 #if 0
 226         switch (sa->sa_family) {
 227         case AF_INET:
 228                 v4a = ((struct sockaddr_in *)sa)->sin_addr.s_addr;
 229                 if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
 230                         flags |= NI_NUMERICHOST;
 231                 v4a >>= IN_CLASSA_NSHIFT;
 232                 if (v4a == 0 || v4a == IN_LOOPBACKNET)
 233                         flags |= NI_NUMERICHOST;
 234                 break;
 235
 236         case AF_INET6:
 237                 pfx = ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[0];
 238                 if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
 239                         flags |= NI_NUMERICHOST;
 240                 break;
 241         }
 242 #endif
 243
 244         if (host == NULL || hostlen == 0U) {
 245                 /*
 246                  * do nothing in this case.
 247                  * in case you are wondering if "&&" is more correct than
 248                  * "||" here: RFC3493 says that host == NULL or hostlen == 0
 249                  * means that the caller does not want the result.
 250                  */
 251         } else if ((flags & NI_NUMERICHOST) != 0) {
 252                 if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
 253                     == NULL)
 254                         ERR(EAI_SYSTEM);
 255 #if defined(IRS_HAVE_SIN6_SCOPE_ID)
 256                 if (afd->a_af == AF_INET6 &&
 257                     ((const struct sockaddr_in6 *)sa)->sin6_scope_id) {
 258                         char *p = numaddr + strlen(numaddr);
 259                         const char *stringscope = NULL;
 260 #ifdef VENDOR_SPECIFIC
 261                         /*
 262                          * Vendors may want to add support for
 263                          * non-numeric scope identifier.
 264                          */
 265                         stringscope = foo;
 266 #endif
 267                         if (stringscope == NULL) {
 268                                 snprintf(p, sizeof(numaddr) - (p - numaddr),
 269                                     "%%%u",
 270                                     ((const struct sockaddr_in6 *)sa)->sin6_scope_id);
 271                         } else {
 272                                 snprintf(p, sizeof(numaddr) - (p - numaddr),
 273                                     "%%%s", stringscope);
 274                         }
 275                 }
 276 #endif
 277                 if (strlen(numaddr) + 1 > hostlen)
 278                         ERR(EAI_OVERFLOW);
 279                 strcpy(host, numaddr);
 280         } else {
 281                 isc_netaddr_t netaddr;
 282                 dns_fixedname_t ptrfname;
 283                 dns_name_t *ptrname;
 284                 irs_context_t *irsctx = NULL;
 285                 dns_client_t *client;
 286                 isc_boolean_t found = ISC_FALSE;
 287                 dns_namelist_t answerlist;
 288                 dns_rdataset_t *rdataset;
 289                 isc_region_t hostregion;
 290                 char hoststr[1024]; /* is this enough? */
 291                 isc_result_t iresult;
 292
 293                 /* Get IRS context and the associated DNS client object */
 294                 iresult = irs_context_get(&irsctx);
 295                 if (iresult != ISC_R_SUCCESS)
 296                         ERR(EAI_FAIL);
 297                 client = irs_context_getdnsclient(irsctx);
 298
 299                 /* Make query name */
 300                 isc_netaddr_fromsockaddr(&netaddr, (const isc_sockaddr_t *)sa);
 301                 dns_fixedname_init(&ptrfname);
 302                 ptrname = dns_fixedname_name(&ptrfname);
 303                 iresult = dns_byaddr_createptrname2(&netaddr, 0, ptrname);
 304                 if (iresult != ISC_R_SUCCESS)
 305                         ERR(EAI_FAIL);
 306
 307                 /* Get the PTR RRset */
 308                 ISC_LIST_INIT(answerlist);
 309                 iresult = dns_client_resolve(client, ptrname,
 310                                              dns_rdataclass_in,
 311                                              dns_rdatatype_ptr,
 312                                              DNS_CLIENTRESOPT_ALLOWRUN,
 313                                              &answerlist);
 314                 switch (iresult) {
 315                 case ISC_R_SUCCESS:
 316                 /*
 317                  * a 'non-existent' error is not necessarily fatal for
 318                  * getnameinfo().
 319                  */
 320                 case DNS_R_NCACHENXDOMAIN:
 321                 case DNS_R_NCACHENXRRSET:
 322                         break;
 323                 case DNS_R_SIGINVALID:
 324                 case DNS_R_SIGEXPIRED:
 325                 case DNS_R_SIGFUTURE:
 326                 case DNS_R_KEYUNAUTHORIZED:
 327                 case DNS_R_MUSTBESECURE:
 328                 case DNS_R_COVERINGNSEC:
 329                 case DNS_R_NOTAUTHORITATIVE:
 330                 case DNS_R_NOVALIDKEY:
 331                 case DNS_R_NOVALIDDS:
 332                 case DNS_R_NOVALIDSIG:
 333                         ERR(EAI_INSECUREDATA);
 334                         break;
 335                 default:
 336                         ERR(EAI_FAIL);
 337                 }
 338
 339                 /* Parse the answer for the hostname */
 340                 for (ptrname = ISC_LIST_HEAD(answerlist); ptrname != NULL;
 341                      ptrname = ISC_LIST_NEXT(ptrname, link)) {
 342                         for (rdataset = ISC_LIST_HEAD(ptrname->list);
 343                              rdataset != NULL;
 344                              rdataset = ISC_LIST_NEXT(rdataset, link)) {
 345                                 if (!dns_rdataset_isassociated(rdataset))
 346                                         continue;
 347                                 if (rdataset->type != dns_rdatatype_ptr)
 348                                         continue;
 349
 350                                 for (iresult = dns_rdataset_first(rdataset);
 351                                      iresult == ISC_R_SUCCESS;
 352                                      iresult = dns_rdataset_next(rdataset)) {
 353                                         dns_rdata_t rdata;
 354                                         dns_rdata_ptr_t rdata_ptr;
 355                                         isc_buffer_t b;
 356
 357                                         dns_rdata_init(&rdata);
 358                                         dns_rdataset_current(rdataset, &rdata);
 359                                         dns_rdata_tostruct(&rdata, &rdata_ptr,
 360                                                            NULL);
 361
 362                                         isc_buffer_init(&b, hoststr,
 363                                                         sizeof(hoststr));
 364                                         iresult =
 365                                                 dns_name_totext(&rdata_ptr.ptr,
 366                                                                 ISC_TRUE, &b);
 367                                         dns_rdata_freestruct(&rdata_ptr);
 368                                         if (iresult == ISC_R_SUCCESS) {
 369                                                 /*
 370                                                  * We ignore the rest of the
 371                                                  * answer.  After all,
 372                                                  * getnameinfo() can return
 373                                                  * at most one hostname.
 374                                                  */
 375                                                 found = ISC_TRUE;
 376                                                 isc_buffer_usedregion(
 377                                                         &b, &hostregion);
 378                                                 goto ptrfound;
 379                                         }
 380
 381                                 }
 382                         }
 383                 }
 384         ptrfound:
 385                 dns_client_freeresanswer(client, &answerlist);
 386                 if (found) {
 387                         if ((flags & NI_NOFQDN) != 0) {
 388                                 p = strchr(hoststr, '.');
 389                                 if (p)
 390                                         *p = '\0';
 391                         }
 392                         if (hostregion.length + 1 > hostlen)
 393                                 ERR(EAI_OVERFLOW);
 394                         snprintf(host, hostlen, "%.*s",
 395                                  (int)hostregion.length,
 396                                  (char *)hostregion.base);
 397                 } else {
 398                         if ((flags & NI_NAMEREQD) != 0)
 399                                 ERR(EAI_NONAME);
 400                         if (inet_ntop(afd->a_af, addr, numaddr,
 401                                       sizeof(numaddr)) == NULL)
 402                                 ERR(EAI_SYSTEM);
 403                         if ((strlen(numaddr) + 1) > hostlen)
 404                                 ERR(EAI_OVERFLOW);
 405                         strcpy(host, numaddr);
 406                 }
 407         }
 408         result = SUCCESS;
 409
 410  cleanup:
 411         return (result);
 412 }