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 } 413