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

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2009  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: getnameinfo.c,v 1.4 2009/09/02 23:48:02 tbox Exp */
  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 (0)
 146
 147 int
 148 getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host,
 149             IRS_GETNAMEINFO_BUFLEN_T hostlen, char *serv,
 150             IRS_GETNAMEINFO_BUFLEN_T servlen, IRS_GETNAMEINFO_FLAGS_T flags)
 151 {
 152         struct afd *afd;
 153         struct servent *sp;
 154         unsigned short port;
 155 #ifdef IRS_PLATFORM_HAVESALEN
 156         size_t len;
 157 #endif
 158         int family, i;
 159         const void *addr;
 160         char *p;
 161 #if 0
 162         unsigned long v4a;
 163         unsigned char pfx;
 164 #endif
 165         char numserv[sizeof("65000")];
 166         char numaddr[sizeof("abcd:abcd:abcd:abcd:abcd:abcd:255.255.255.255")
 167                     + 1 + sizeof("4294967295")];
 168         const char *proto;
 169         int result = SUCCESS;
 170
 171         if (sa == NULL)
 172                 ERR(EAI_FAIL);
 173
 174 #ifdef IRS_PLATFORM_HAVESALEN
 175         len = sa->sa_len;
 176         if (len != salen)
 177                 ERR(EAI_FAIL);
 178 #endif
 179
 180         family = sa->sa_family;
 181         for (i = 0; afdl[i].a_af; i++)
 182                 if (afdl[i].a_af == family) {
 183                         afd = &afdl[i];
 184                         goto found;
 185                 }
 186         ERR(EAI_FAMILY);
 187
 188  found:
 189         if (salen != afd->a_socklen)
 190                 ERR(EAI_FAIL);
 191
 192         switch (family) {
 193         case AF_INET:
 194                 port = ((const struct sockaddr_in *)sa)->sin_port;
 195                 addr = &((const struct sockaddr_in *)sa)->sin_addr.s_addr;
 196                 break;
 197
 198         case AF_INET6:
 199                 port = ((const struct sockaddr_in6 *)sa)->sin6_port;
 200                 addr = ((const struct sockaddr_in6 *)sa)->sin6_addr.s6_addr;
 201                 break;
 202
 203         default:
 204                 port = 0;
 205                 addr = NULL;
 206                 INSIST(0);
 207         }
 208         proto = (flags & NI_DGRAM) ? "udp" : "tcp";
 209
 210         if (serv == NULL || servlen == 0U) {
 211                 /*
 212                  * Caller does not want service.
 213                  */
 214         } else if ((flags & NI_NUMERICSERV) != 0 ||
 215                    (sp = getservbyport(port, proto)) == NULL) {
 216                 snprintf(numserv, sizeof(numserv), "%d", ntohs(port));
 217                 if ((strlen(numserv) + 1) > servlen)
 218                         ERR(EAI_OVERFLOW);
 219                 strcpy(serv, numserv);
 220         } else {
 221                 if ((strlen(sp->s_name) + 1) > servlen)
 222                         ERR(EAI_OVERFLOW);
 223                 strcpy(serv, sp->s_name);
 224         }
 225
 226 #if 0
 227         switch (sa->sa_family) {
 228         case AF_INET:
 229                 v4a = ((struct sockaddr_in *)sa)->sin_addr.s_addr;
 230                 if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
 231                         flags |= NI_NUMERICHOST;
 232                 v4a >>= IN_CLASSA_NSHIFT;
 233                 if (v4a == 0 || v4a == IN_LOOPBACKNET)
 234                         flags |= NI_NUMERICHOST;
 235                 break;
 236
 237         case AF_INET6:
 238                 pfx = ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[0];
 239                 if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
 240                         flags |= NI_NUMERICHOST;
 241                 break;
 242         }
 243 #endif
 244
 245         if (host == NULL || hostlen == 0U) {
 246                 /*
 247                  * do nothing in this case.
 248                  * in case you are wondering if "&&" is more correct than
 249                  * "||" here: RFC3493 says that host == NULL or hostlen == 0
 250                  * means that the caller does not want the result.
 251                  */
 252         } else if ((flags & NI_NUMERICHOST) != 0) {
 253                 if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
 254                     == NULL)
 255                         ERR(EAI_SYSTEM);
 256 #if defined(IRS_HAVE_SIN6_SCOPE_ID)
 257                 if (afd->a_af == AF_INET6 &&
 258                     ((const struct sockaddr_in6 *)sa)->sin6_scope_id) {
 259                         char *p = numaddr + strlen(numaddr);
 260                         const char *stringscope = NULL;
 261 #ifdef VENDOR_SPECIFIC
 262                         /*
 263                          * Vendors may want to add support for
 264                          * non-numeric scope identifier.
 265                          */
 266                         stringscope = foo;
 267 #endif
 268                         if (stringscope == NULL) {
 269                                 snprintf(p, sizeof(numaddr) - (p - numaddr),
 270                                     "%%%u",
 271                                     ((const struct sockaddr_in6 *)sa)->sin6_scope_id);
 272                         } else {
 273                                 snprintf(p, sizeof(numaddr) - (p - numaddr),
 274                                     "%%%s", stringscope);
 275                         }
 276                 }
 277 #endif
 278                 if (strlen(numaddr) + 1 > hostlen)
 279                         ERR(EAI_OVERFLOW);
 280                 strcpy(host, numaddr);
 281         } else {
 282                 isc_netaddr_t netaddr;
 283                 dns_fixedname_t ptrfname;
 284                 dns_name_t *ptrname;
 285                 irs_context_t *irsctx = NULL;
 286                 dns_client_t *client;
 287                 isc_boolean_t found = ISC_FALSE;
 288                 dns_namelist_t answerlist;
 289                 dns_rdataset_t *rdataset;
 290                 isc_region_t hostregion;
 291                 char hoststr[1024]; /* is this enough? */
 292                 isc_result_t iresult;
 293
 294                 /* Get IRS context and the associated DNS client object */
 295                 iresult = irs_context_get(&irsctx);
 296                 if (iresult != ISC_R_SUCCESS)
 297                         ERR(EAI_FAIL);
 298                 client = irs_context_getdnsclient(irsctx);
 299
 300                 /* Make query name */
 301                 isc_netaddr_fromsockaddr(&netaddr, (const isc_sockaddr_t *)sa);
 302                 dns_fixedname_init(&ptrfname);
 303                 ptrname = dns_fixedname_name(&ptrfname);
 304                 iresult = dns_byaddr_createptrname2(&netaddr, 0, ptrname);
 305                 if (iresult != ISC_R_SUCCESS)
 306                         ERR(EAI_FAIL);
 307
 308                 /* Get the PTR RRset */
 309                 ISC_LIST_INIT(answerlist);
 310                 iresult = dns_client_resolve(client, ptrname,
 311                                              dns_rdataclass_in,
 312                                              dns_rdatatype_ptr,
 313                                              DNS_CLIENTRESOPT_ALLOWRUN,
 314                                              &answerlist);
 315                 switch (iresult) {
 316                 case ISC_R_SUCCESS:
 317                 /*
 318                  * a 'non-existent' error is not necessarily fatal for
 319                  * getnameinfo().
 320                  */
 321                 case DNS_R_NCACHENXDOMAIN:
 322                 case DNS_R_NCACHENXRRSET:
 323                         break;
 324                 case DNS_R_SIGINVALID:
 325                 case DNS_R_SIGEXPIRED:
 326                 case DNS_R_SIGFUTURE:
 327                 case DNS_R_KEYUNAUTHORIZED:
 328                 case DNS_R_MUSTBESECURE:
 329                 case DNS_R_COVERINGNSEC:
 330                 case DNS_R_NOTAUTHORITATIVE:
 331                 case DNS_R_NOVALIDKEY:
 332                 case DNS_R_NOVALIDDS:
 333                 case DNS_R_NOVALIDSIG:
 334                         ERR(EAI_INSECUREDATA);
 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 }