13f587e57SKris Kennaway /* $KAME: name6.c,v 1.25 2000/06/26 16:44:40 itojun Exp $ */ 273b30f0cSJun-ichiro itojun Hagino 37d56d374SYoshinobu Inoue /* 47d56d374SYoshinobu Inoue * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project. 57d56d374SYoshinobu Inoue * All rights reserved. 67d56d374SYoshinobu Inoue * 77d56d374SYoshinobu Inoue * Redistribution and use in source and binary forms, with or without 87d56d374SYoshinobu Inoue * modification, are permitted provided that the following conditions 97d56d374SYoshinobu Inoue * are met: 107d56d374SYoshinobu Inoue * 1. Redistributions of source code must retain the above copyright 117d56d374SYoshinobu Inoue * notice, this list of conditions and the following disclaimer. 127d56d374SYoshinobu Inoue * 2. Redistributions in binary form must reproduce the above copyright 137d56d374SYoshinobu Inoue * notice, this list of conditions and the following disclaimer in the 147d56d374SYoshinobu Inoue * documentation and/or other materials provided with the distribution. 157d56d374SYoshinobu Inoue * 3. Neither the name of the project nor the names of its contributors 167d56d374SYoshinobu Inoue * may be used to endorse or promote products derived from this software 177d56d374SYoshinobu Inoue * without specific prior written permission. 187d56d374SYoshinobu Inoue * 197d56d374SYoshinobu Inoue * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 207d56d374SYoshinobu Inoue * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 217d56d374SYoshinobu Inoue * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 227d56d374SYoshinobu Inoue * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 237d56d374SYoshinobu Inoue * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 247d56d374SYoshinobu Inoue * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 257d56d374SYoshinobu Inoue * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 267d56d374SYoshinobu Inoue * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 277d56d374SYoshinobu Inoue * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 287d56d374SYoshinobu Inoue * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 297d56d374SYoshinobu Inoue * SUCH DAMAGE. 307d56d374SYoshinobu Inoue */ 3173b30f0cSJun-ichiro itojun Hagino /* 3273b30f0cSJun-ichiro itojun Hagino * ++Copyright++ 1985, 1988, 1993 3373b30f0cSJun-ichiro itojun Hagino * - 3473b30f0cSJun-ichiro itojun Hagino * Copyright (c) 1985, 1988, 1993 3573b30f0cSJun-ichiro itojun Hagino * The Regents of the University of California. All rights reserved. 3673b30f0cSJun-ichiro itojun Hagino * 3773b30f0cSJun-ichiro itojun Hagino * Redistribution and use in source and binary forms, with or without 3873b30f0cSJun-ichiro itojun Hagino * modification, are permitted provided that the following conditions 3973b30f0cSJun-ichiro itojun Hagino * are met: 4073b30f0cSJun-ichiro itojun Hagino * 1. Redistributions of source code must retain the above copyright 4173b30f0cSJun-ichiro itojun Hagino * notice, this list of conditions and the following disclaimer. 4273b30f0cSJun-ichiro itojun Hagino * 2. Redistributions in binary form must reproduce the above copyright 4373b30f0cSJun-ichiro itojun Hagino * notice, this list of conditions and the following disclaimer in the 4473b30f0cSJun-ichiro itojun Hagino * documentation and/or other materials provided with the distribution. 4573b30f0cSJun-ichiro itojun Hagino * 3. All advertising materials mentioning features or use of this software 4673b30f0cSJun-ichiro itojun Hagino * must display the following acknowledgement: 4773b30f0cSJun-ichiro itojun Hagino * This product includes software developed by the University of 4873b30f0cSJun-ichiro itojun Hagino * California, Berkeley and its contributors. 4973b30f0cSJun-ichiro itojun Hagino * 4. Neither the name of the University nor the names of its contributors 5073b30f0cSJun-ichiro itojun Hagino * may be used to endorse or promote products derived from this software 5173b30f0cSJun-ichiro itojun Hagino * without specific prior written permission. 5273b30f0cSJun-ichiro itojun Hagino * 5373b30f0cSJun-ichiro itojun Hagino * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 5473b30f0cSJun-ichiro itojun Hagino * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 5573b30f0cSJun-ichiro itojun Hagino * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 5673b30f0cSJun-ichiro itojun Hagino * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 5773b30f0cSJun-ichiro itojun Hagino * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 5873b30f0cSJun-ichiro itojun Hagino * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 5973b30f0cSJun-ichiro itojun Hagino * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 6073b30f0cSJun-ichiro itojun Hagino * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 6173b30f0cSJun-ichiro itojun Hagino * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 6273b30f0cSJun-ichiro itojun Hagino * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 6373b30f0cSJun-ichiro itojun Hagino * SUCH DAMAGE. 6473b30f0cSJun-ichiro itojun Hagino * - 6573b30f0cSJun-ichiro itojun Hagino * Portions Copyright (c) 1993 by Digital Equipment Corporation. 6673b30f0cSJun-ichiro itojun Hagino * 6773b30f0cSJun-ichiro itojun Hagino * Permission to use, copy, modify, and distribute this software for any 6873b30f0cSJun-ichiro itojun Hagino * purpose with or without fee is hereby granted, provided that the above 6973b30f0cSJun-ichiro itojun Hagino * copyright notice and this permission notice appear in all copies, and that 7073b30f0cSJun-ichiro itojun Hagino * the name of Digital Equipment Corporation not be used in advertising or 7173b30f0cSJun-ichiro itojun Hagino * publicity pertaining to distribution of the document or software without 7273b30f0cSJun-ichiro itojun Hagino * specific, written prior permission. 7373b30f0cSJun-ichiro itojun Hagino * 7473b30f0cSJun-ichiro itojun Hagino * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL 7573b30f0cSJun-ichiro itojun Hagino * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES 7673b30f0cSJun-ichiro itojun Hagino * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT 7773b30f0cSJun-ichiro itojun Hagino * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 7873b30f0cSJun-ichiro itojun Hagino * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 7973b30f0cSJun-ichiro itojun Hagino * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 8073b30f0cSJun-ichiro itojun Hagino * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 8173b30f0cSJun-ichiro itojun Hagino * SOFTWARE. 8273b30f0cSJun-ichiro itojun Hagino * - 8373b30f0cSJun-ichiro itojun Hagino * --Copyright-- 8473b30f0cSJun-ichiro itojun Hagino */ 8573b30f0cSJun-ichiro itojun Hagino 867d56d374SYoshinobu Inoue /* 877d56d374SYoshinobu Inoue * Atsushi Onoe <onoe@sm.sony.co.jp> 887d56d374SYoshinobu Inoue */ 897d56d374SYoshinobu Inoue 90333fc21eSDavid E. O'Brien #include <sys/cdefs.h> 91333fc21eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 92333fc21eSDavid E. O'Brien 93d201fe46SDaniel Eischen #include "namespace.h" 94b8ab0f45SHajimu UMEMOTO #ifdef ICMPNL 952424b118SHajimu UMEMOTO #include "reentrant.h" 96e8ffd816SHajimu UMEMOTO #endif 977d56d374SYoshinobu Inoue #include <sys/param.h> 987d56d374SYoshinobu Inoue #include <sys/socket.h> 997d56d374SYoshinobu Inoue #include <sys/time.h> 100e6f35403SYoshinobu Inoue #include <sys/queue.h> 1017d56d374SYoshinobu Inoue #include <netinet/in.h> 102b8b31f33SHajimu UMEMOTO #ifdef INET6 103b8b31f33SHajimu UMEMOTO #include <net/if.h> 104b8b31f33SHajimu UMEMOTO #include <net/if_var.h> 105b8b31f33SHajimu UMEMOTO #include <sys/sysctl.h> 106146cd1bcSHajimu UMEMOTO #include <sys/ioctl.h> 107b8b31f33SHajimu UMEMOTO #include <netinet6/in6_var.h> /* XXX */ 108b8b31f33SHajimu UMEMOTO #endif 1097d56d374SYoshinobu Inoue 1107d56d374SYoshinobu Inoue #include <arpa/inet.h> 1117d56d374SYoshinobu Inoue #include <arpa/nameser.h> 1127d56d374SYoshinobu Inoue 113e6f35403SYoshinobu Inoue #include <errno.h> 1147d56d374SYoshinobu Inoue #include <netdb.h> 1157d56d374SYoshinobu Inoue #include <resolv.h> 1167d56d374SYoshinobu Inoue #include <stdio.h> 1177d56d374SYoshinobu Inoue #include <stdlib.h> 1187d56d374SYoshinobu Inoue #include <string.h> 119248aee62SJacques Vidrine #include <stdarg.h> 120248aee62SJacques Vidrine #include <nsswitch.h> 1217d56d374SYoshinobu Inoue #include <unistd.h> 122d201fe46SDaniel Eischen #include "un-namespace.h" 123bcb131aaSHajimu UMEMOTO #include "netdb_private.h" 1244a58c5f5SHajimu UMEMOTO #include "res_config.h" 1255342d17fSHajimu UMEMOTO #include "res_private.h" 12606a99fe3SHajimu UMEMOTO #ifdef NS_CACHING 12706a99fe3SHajimu UMEMOTO #include "nscache.h" 12806a99fe3SHajimu UMEMOTO #endif 1297d56d374SYoshinobu Inoue 1307d56d374SYoshinobu Inoue #ifndef _PATH_HOSTS 1317d56d374SYoshinobu Inoue #define _PATH_HOSTS "/etc/hosts" 1327d56d374SYoshinobu Inoue #endif 1337d56d374SYoshinobu Inoue 1347d56d374SYoshinobu Inoue #ifndef MAXALIASES 1357d56d374SYoshinobu Inoue #define MAXALIASES 10 1367d56d374SYoshinobu Inoue #endif 1377d56d374SYoshinobu Inoue #ifndef MAXADDRS 1387d56d374SYoshinobu Inoue #define MAXADDRS 20 1397d56d374SYoshinobu Inoue #endif 1407d56d374SYoshinobu Inoue #ifndef MAXDNAME 1417d56d374SYoshinobu Inoue #define MAXDNAME 1025 1427d56d374SYoshinobu Inoue #endif 1437d56d374SYoshinobu Inoue 1447d56d374SYoshinobu Inoue #ifdef INET6 1457d56d374SYoshinobu Inoue #define ADDRLEN(af) ((af) == AF_INET6 ? sizeof(struct in6_addr) : \ 1467d56d374SYoshinobu Inoue sizeof(struct in_addr)) 1477d56d374SYoshinobu Inoue #else 1487d56d374SYoshinobu Inoue #define ADDRLEN(af) sizeof(struct in_addr) 1497d56d374SYoshinobu Inoue #endif 1507d56d374SYoshinobu Inoue 1517d56d374SYoshinobu Inoue #define MAPADDR(ab, ina) \ 1527d56d374SYoshinobu Inoue do { \ 1537d56d374SYoshinobu Inoue memcpy(&(ab)->map_inaddr, ina, sizeof(struct in_addr)); \ 1547d56d374SYoshinobu Inoue memset((ab)->map_zero, 0, sizeof((ab)->map_zero)); \ 1557d56d374SYoshinobu Inoue memset((ab)->map_one, 0xff, sizeof((ab)->map_one)); \ 1567d56d374SYoshinobu Inoue } while (0) 1577d56d374SYoshinobu Inoue #define MAPADDRENABLED(flags) \ 1587d56d374SYoshinobu Inoue (((flags) & AI_V4MAPPED) || \ 1597d56d374SYoshinobu Inoue (((flags) & AI_V4MAPPED_CFG) && _mapped_addr_enabled())) 1607d56d374SYoshinobu Inoue 1617d56d374SYoshinobu Inoue union inx_addr { 1627d56d374SYoshinobu Inoue struct in_addr in_addr; 1637d56d374SYoshinobu Inoue #ifdef INET6 1647d56d374SYoshinobu Inoue struct in6_addr in6_addr; 1657d56d374SYoshinobu Inoue #endif 1667d56d374SYoshinobu Inoue struct { 1677d56d374SYoshinobu Inoue u_char mau_zero[10]; 1687d56d374SYoshinobu Inoue u_char mau_one[2]; 1697d56d374SYoshinobu Inoue struct in_addr mau_inaddr; 1707d56d374SYoshinobu Inoue } map_addr_un; 1717d56d374SYoshinobu Inoue #define map_zero map_addr_un.mau_zero 1727d56d374SYoshinobu Inoue #define map_one map_addr_un.mau_one 1737d56d374SYoshinobu Inoue #define map_inaddr map_addr_un.mau_inaddr 1747d56d374SYoshinobu Inoue }; 1757d56d374SYoshinobu Inoue 176b8b31f33SHajimu UMEMOTO struct policyqueue { 177b8b31f33SHajimu UMEMOTO TAILQ_ENTRY(policyqueue) pc_entry; 178b8b31f33SHajimu UMEMOTO #ifdef INET6 179b8b31f33SHajimu UMEMOTO struct in6_addrpolicy pc_policy; 180b8b31f33SHajimu UMEMOTO #endif 181b8b31f33SHajimu UMEMOTO }; 182b8b31f33SHajimu UMEMOTO TAILQ_HEAD(policyhead, policyqueue); 183b8b31f33SHajimu UMEMOTO 184146cd1bcSHajimu UMEMOTO #define AIO_SRCFLAG_DEPRECATED 0x1 185146cd1bcSHajimu UMEMOTO 186146cd1bcSHajimu UMEMOTO struct hp_order { 187146cd1bcSHajimu UMEMOTO union { 188146cd1bcSHajimu UMEMOTO struct sockaddr_storage aiou_ss; 189146cd1bcSHajimu UMEMOTO struct sockaddr aiou_sa; 190146cd1bcSHajimu UMEMOTO } aio_src_un; 191146cd1bcSHajimu UMEMOTO #define aio_srcsa aio_src_un.aiou_sa 192146cd1bcSHajimu UMEMOTO u_int32_t aio_srcflag; 193146cd1bcSHajimu UMEMOTO int aio_srcscope; 194146cd1bcSHajimu UMEMOTO int aio_dstscope; 195146cd1bcSHajimu UMEMOTO struct policyqueue *aio_srcpolicy; 196146cd1bcSHajimu UMEMOTO struct policyqueue *aio_dstpolicy; 197146cd1bcSHajimu UMEMOTO union { 198146cd1bcSHajimu UMEMOTO struct sockaddr_storage aiou_ss; 199146cd1bcSHajimu UMEMOTO struct sockaddr aiou_sa; 200146cd1bcSHajimu UMEMOTO } aio_un; 201146cd1bcSHajimu UMEMOTO #define aio_sa aio_un.aiou_sa 202146cd1bcSHajimu UMEMOTO int aio_matchlen; 203d6fd3ed8SHajimu UMEMOTO char *aio_h_addr; 204146cd1bcSHajimu UMEMOTO }; 205146cd1bcSHajimu UMEMOTO 2065342d17fSHajimu UMEMOTO static struct hostent *_hpcopy(struct hostent *, int *); 2075342d17fSHajimu UMEMOTO static struct hostent *_hpaddr(int, const char *, void *, int *); 2085342d17fSHajimu UMEMOTO static struct hostent *_hpmerge(struct hostent *, struct hostent *, int *); 2097d56d374SYoshinobu Inoue #ifdef INET6 2105342d17fSHajimu UMEMOTO static struct hostent *_hpmapv6(struct hostent *, int *); 2117d56d374SYoshinobu Inoue #endif 2125342d17fSHajimu UMEMOTO static struct hostent *_hpsort(struct hostent *, res_state); 2135342d17fSHajimu UMEMOTO static struct hostent *_ghbyname(const char *, int, int, int *); 2145342d17fSHajimu UMEMOTO static char *_hgetword(char **); 2157d56d374SYoshinobu Inoue static int _mapped_addr_enabled(void); 2167d56d374SYoshinobu Inoue 2175342d17fSHajimu UMEMOTO static struct hostent *_hpreorder(struct hostent *); 218b8b31f33SHajimu UMEMOTO static int get_addrselectpolicy(struct policyhead *); 219b8b31f33SHajimu UMEMOTO static void free_addrselectpolicy(struct policyhead *); 220b8b31f33SHajimu UMEMOTO static struct policyqueue *match_addrselectpolicy(struct sockaddr *, 221b8b31f33SHajimu UMEMOTO struct policyhead *); 222146cd1bcSHajimu UMEMOTO static void set_source(struct hp_order *, struct policyhead *); 223146cd1bcSHajimu UMEMOTO static int matchlen(struct sockaddr *, struct sockaddr *); 224146cd1bcSHajimu UMEMOTO static int comp_dst(const void *, const void *); 225146cd1bcSHajimu UMEMOTO static int gai_addr2scopetype(struct sockaddr *); 226b8b31f33SHajimu UMEMOTO 2275342d17fSHajimu UMEMOTO static FILE *_files_open(int *); 228248aee62SJacques Vidrine static int _files_ghbyname(void *, void *, va_list); 229248aee62SJacques Vidrine static int _files_ghbyaddr(void *, void *, va_list); 230f468e837SHajimu UMEMOTO #ifdef YP 231248aee62SJacques Vidrine static int _nis_ghbyname(void *, void *, va_list); 232248aee62SJacques Vidrine static int _nis_ghbyaddr(void *, void *, va_list); 233f468e837SHajimu UMEMOTO #endif 234248aee62SJacques Vidrine static int _dns_ghbyname(void *, void *, va_list); 235248aee62SJacques Vidrine static int _dns_ghbyaddr(void *, void *, va_list); 2365342d17fSHajimu UMEMOTO static void _dns_shent(int) __unused; 237e0554a53SJacques Vidrine static void _dns_ehent(void) __unused; 2387d56d374SYoshinobu Inoue #ifdef ICMPNL 239248aee62SJacques Vidrine static int _icmp_ghbyaddr(void *, void *, va_list); 2407d56d374SYoshinobu Inoue #endif /* ICMPNL */ 24106a99fe3SHajimu UMEMOTO #ifdef NS_CACHING 24206a99fe3SHajimu UMEMOTO static int ipnode_id_func(char *, size_t *, va_list, void *); 24306a99fe3SHajimu UMEMOTO static int ipnode_marshal_func(char *, size_t *, void *, va_list, void *); 24406a99fe3SHajimu UMEMOTO static int ipnode_unmarshal_func(char *, size_t, void *, va_list, void *); 24506a99fe3SHajimu UMEMOTO #endif 2467d56d374SYoshinobu Inoue 247b8ab0f45SHajimu UMEMOTO #ifdef ICMPNL 2482424b118SHajimu UMEMOTO static mutex_t _getipnodeby_thread_lock = MUTEX_INITIALIZER; 2492424b118SHajimu UMEMOTO #define THREAD_LOCK() mutex_lock(&_getipnodeby_thread_lock); 2502424b118SHajimu UMEMOTO #define THREAD_UNLOCK() mutex_unlock(&_getipnodeby_thread_lock); 251e8ffd816SHajimu UMEMOTO #endif 25271918af6SHajimu UMEMOTO 253248aee62SJacques Vidrine /* Host lookup order if nsswitch.conf is broken or nonexistant */ 254248aee62SJacques Vidrine static const ns_src default_src[] = { 255248aee62SJacques Vidrine { NSSRC_FILES, NS_SUCCESS }, 256248aee62SJacques Vidrine { NSSRC_DNS, NS_SUCCESS }, 2577d56d374SYoshinobu Inoue #ifdef ICMPNL 258248aee62SJacques Vidrine #define NSSRC_ICMP "icmp" 259248aee62SJacques Vidrine { NSSRC_ICMP, NS_SUCCESS }, 26073b30f0cSJun-ichiro itojun Hagino #endif 261248aee62SJacques Vidrine { 0 } 262248aee62SJacques Vidrine }; 2637d56d374SYoshinobu Inoue 2647d56d374SYoshinobu Inoue /* 2657d56d374SYoshinobu Inoue * Check if kernel supports mapped address. 2667d56d374SYoshinobu Inoue * implementation dependent 2677d56d374SYoshinobu Inoue */ 2687d56d374SYoshinobu Inoue #ifdef __KAME__ 2697d56d374SYoshinobu Inoue #include <sys/sysctl.h> 2707d56d374SYoshinobu Inoue #endif /* __KAME__ */ 2717d56d374SYoshinobu Inoue 2727d56d374SYoshinobu Inoue static int 2737d56d374SYoshinobu Inoue _mapped_addr_enabled(void) 2747d56d374SYoshinobu Inoue { 2757d56d374SYoshinobu Inoue /* implementation dependent check */ 2767d56d374SYoshinobu Inoue #if defined(__KAME__) && defined(IPV6CTL_MAPPED_ADDR) 2777d56d374SYoshinobu Inoue int mib[4]; 2787d56d374SYoshinobu Inoue size_t len; 2797d56d374SYoshinobu Inoue int val; 2807d56d374SYoshinobu Inoue 2817d56d374SYoshinobu Inoue mib[0] = CTL_NET; 2827d56d374SYoshinobu Inoue mib[1] = PF_INET6; 2837d56d374SYoshinobu Inoue mib[2] = IPPROTO_IPV6; 2847d56d374SYoshinobu Inoue mib[3] = IPV6CTL_MAPPED_ADDR; 2857d56d374SYoshinobu Inoue len = sizeof(val); 2867d56d374SYoshinobu Inoue if (sysctl(mib, 4, &val, &len, 0, 0) == 0 && val != 0) 2877d56d374SYoshinobu Inoue return 1; 2887d56d374SYoshinobu Inoue #endif /* __KAME__ && IPV6CTL_MAPPED_ADDR */ 2897d56d374SYoshinobu Inoue return 0; 2907d56d374SYoshinobu Inoue } 2917d56d374SYoshinobu Inoue 29206a99fe3SHajimu UMEMOTO #ifdef NS_CACHING 29306a99fe3SHajimu UMEMOTO static int 29406a99fe3SHajimu UMEMOTO ipnode_id_func(char *buffer, size_t *buffer_size, va_list ap, 29506a99fe3SHajimu UMEMOTO void *cache_mdata) 29606a99fe3SHajimu UMEMOTO { 29706a99fe3SHajimu UMEMOTO res_state statp; 29806a99fe3SHajimu UMEMOTO u_long res_options; 29906a99fe3SHajimu UMEMOTO 30006a99fe3SHajimu UMEMOTO const int op_id = 2; 30106a99fe3SHajimu UMEMOTO char *name; 30206a99fe3SHajimu UMEMOTO int af; 30306a99fe3SHajimu UMEMOTO size_t len; 30406a99fe3SHajimu UMEMOTO void *src; 30506a99fe3SHajimu UMEMOTO 30606a99fe3SHajimu UMEMOTO char *p; 30706a99fe3SHajimu UMEMOTO size_t desired_size, size; 30806a99fe3SHajimu UMEMOTO enum nss_lookup_type lookup_type; 30906a99fe3SHajimu UMEMOTO int res = NS_UNAVAIL; 31006a99fe3SHajimu UMEMOTO 31106a99fe3SHajimu UMEMOTO statp = __res_state(); 31206a99fe3SHajimu UMEMOTO res_options = statp->options & (RES_RECURSE | RES_DEFNAMES | 31306a99fe3SHajimu UMEMOTO RES_DNSRCH | RES_NOALIASES | RES_USE_INET6); 31406a99fe3SHajimu UMEMOTO 31506a99fe3SHajimu UMEMOTO lookup_type = (enum nss_lookup_type)cache_mdata; 31606a99fe3SHajimu UMEMOTO switch (lookup_type) { 31706a99fe3SHajimu UMEMOTO case nss_lt_name: 31806a99fe3SHajimu UMEMOTO name = va_arg(ap, char *); 31906a99fe3SHajimu UMEMOTO af = va_arg(ap, int); 32006a99fe3SHajimu UMEMOTO 32106a99fe3SHajimu UMEMOTO size = strlen(name); 32206a99fe3SHajimu UMEMOTO desired_size = sizeof(res_options) + sizeof(int) + 32306a99fe3SHajimu UMEMOTO sizeof(enum nss_lookup_type) + sizeof(int) + size + 1; 32406a99fe3SHajimu UMEMOTO 32506a99fe3SHajimu UMEMOTO if (desired_size > *buffer_size) { 32606a99fe3SHajimu UMEMOTO res = NS_RETURN; 32706a99fe3SHajimu UMEMOTO goto fin; 32806a99fe3SHajimu UMEMOTO } 32906a99fe3SHajimu UMEMOTO 33006a99fe3SHajimu UMEMOTO p = buffer; 33106a99fe3SHajimu UMEMOTO memcpy(p, &res_options, sizeof(res_options)); 33206a99fe3SHajimu UMEMOTO p += sizeof(res_options); 33306a99fe3SHajimu UMEMOTO 33406a99fe3SHajimu UMEMOTO memcpy(p, &op_id, sizeof(int)); 33506a99fe3SHajimu UMEMOTO p += sizeof(int); 33606a99fe3SHajimu UMEMOTO 33706a99fe3SHajimu UMEMOTO memcpy(p, &lookup_type, sizeof(enum nss_lookup_type)); 33806a99fe3SHajimu UMEMOTO p += sizeof(enum nss_lookup_type); 33906a99fe3SHajimu UMEMOTO 34006a99fe3SHajimu UMEMOTO memcpy(p, &af, sizeof(int)); 34106a99fe3SHajimu UMEMOTO p += sizeof(int); 34206a99fe3SHajimu UMEMOTO 34306a99fe3SHajimu UMEMOTO memcpy(p, name, size + 1); 34406a99fe3SHajimu UMEMOTO 34506a99fe3SHajimu UMEMOTO res = NS_SUCCESS; 34606a99fe3SHajimu UMEMOTO break; 34706a99fe3SHajimu UMEMOTO case nss_lt_id: 34806a99fe3SHajimu UMEMOTO src = va_arg(ap, void *); 34906a99fe3SHajimu UMEMOTO len = va_arg(ap, size_t); 35006a99fe3SHajimu UMEMOTO af = va_arg(ap, int); 35106a99fe3SHajimu UMEMOTO 35206a99fe3SHajimu UMEMOTO desired_size = sizeof(res_options) + sizeof(int) + 35306a99fe3SHajimu UMEMOTO sizeof(enum nss_lookup_type) + sizeof(int) + 35406a99fe3SHajimu UMEMOTO sizeof(size_t) + len; 35506a99fe3SHajimu UMEMOTO 35606a99fe3SHajimu UMEMOTO if (desired_size > *buffer_size) { 35706a99fe3SHajimu UMEMOTO res = NS_RETURN; 35806a99fe3SHajimu UMEMOTO goto fin; 35906a99fe3SHajimu UMEMOTO } 36006a99fe3SHajimu UMEMOTO 36106a99fe3SHajimu UMEMOTO p = buffer; 36206a99fe3SHajimu UMEMOTO memcpy(p, &res_options, sizeof(res_options)); 36306a99fe3SHajimu UMEMOTO p += sizeof(res_options); 36406a99fe3SHajimu UMEMOTO 36506a99fe3SHajimu UMEMOTO memcpy(p, &op_id, sizeof(int)); 36606a99fe3SHajimu UMEMOTO p += sizeof(int); 36706a99fe3SHajimu UMEMOTO 36806a99fe3SHajimu UMEMOTO memcpy(p, &lookup_type, sizeof(enum nss_lookup_type)); 36906a99fe3SHajimu UMEMOTO p += sizeof(enum nss_lookup_type); 37006a99fe3SHajimu UMEMOTO 37106a99fe3SHajimu UMEMOTO memcpy(p, &af, sizeof(int)); 37206a99fe3SHajimu UMEMOTO p += sizeof(int); 37306a99fe3SHajimu UMEMOTO 37406a99fe3SHajimu UMEMOTO memcpy(p, &len, sizeof(size_t)); 37506a99fe3SHajimu UMEMOTO p += sizeof(size_t); 37606a99fe3SHajimu UMEMOTO 37706a99fe3SHajimu UMEMOTO memcpy(p, src, len); 37806a99fe3SHajimu UMEMOTO 37906a99fe3SHajimu UMEMOTO res = NS_SUCCESS; 38006a99fe3SHajimu UMEMOTO break; 38106a99fe3SHajimu UMEMOTO default: 38206a99fe3SHajimu UMEMOTO /* should be unreachable */ 38306a99fe3SHajimu UMEMOTO return (NS_UNAVAIL); 38406a99fe3SHajimu UMEMOTO } 38506a99fe3SHajimu UMEMOTO 38606a99fe3SHajimu UMEMOTO fin: 38706a99fe3SHajimu UMEMOTO *buffer_size = desired_size; 38806a99fe3SHajimu UMEMOTO return (res); 38906a99fe3SHajimu UMEMOTO } 39006a99fe3SHajimu UMEMOTO 39106a99fe3SHajimu UMEMOTO static int 39206a99fe3SHajimu UMEMOTO ipnode_marshal_func(char *buffer, size_t *buffer_size, void *retval, 39306a99fe3SHajimu UMEMOTO va_list ap, void *cache_mdata) 39406a99fe3SHajimu UMEMOTO { 39506a99fe3SHajimu UMEMOTO struct hostent *ht; 39606a99fe3SHajimu UMEMOTO 39706a99fe3SHajimu UMEMOTO struct hostent new_ht; 39806a99fe3SHajimu UMEMOTO size_t desired_size, aliases_size, addr_size, size; 39906a99fe3SHajimu UMEMOTO char *p, **iter; 40006a99fe3SHajimu UMEMOTO 40106a99fe3SHajimu UMEMOTO ht = *((struct hostent **)retval); 40206a99fe3SHajimu UMEMOTO 40306a99fe3SHajimu UMEMOTO desired_size = _ALIGNBYTES + sizeof(struct hostent) + sizeof(char *); 40406a99fe3SHajimu UMEMOTO if (ht->h_name != NULL) 40506a99fe3SHajimu UMEMOTO desired_size += strlen(ht->h_name) + 1; 40606a99fe3SHajimu UMEMOTO 40706a99fe3SHajimu UMEMOTO if (ht->h_aliases != NULL) { 40806a99fe3SHajimu UMEMOTO aliases_size = 0; 40906a99fe3SHajimu UMEMOTO for (iter = ht->h_aliases; *iter; ++iter) { 41006a99fe3SHajimu UMEMOTO desired_size += strlen(*iter) + 1; 41106a99fe3SHajimu UMEMOTO ++aliases_size; 41206a99fe3SHajimu UMEMOTO } 41306a99fe3SHajimu UMEMOTO 41406a99fe3SHajimu UMEMOTO desired_size += _ALIGNBYTES + 41506a99fe3SHajimu UMEMOTO (aliases_size + 1) * sizeof(char *); 41606a99fe3SHajimu UMEMOTO } 41706a99fe3SHajimu UMEMOTO 41806a99fe3SHajimu UMEMOTO if (ht->h_addr_list != NULL) { 41906a99fe3SHajimu UMEMOTO addr_size = 0; 42006a99fe3SHajimu UMEMOTO for (iter = ht->h_addr_list; *iter; ++iter) 42106a99fe3SHajimu UMEMOTO ++addr_size; 42206a99fe3SHajimu UMEMOTO 42306a99fe3SHajimu UMEMOTO desired_size += addr_size * _ALIGN(ht->h_length); 42406a99fe3SHajimu UMEMOTO desired_size += _ALIGNBYTES + (addr_size + 1) * sizeof(char *); 42506a99fe3SHajimu UMEMOTO } 42606a99fe3SHajimu UMEMOTO 42706a99fe3SHajimu UMEMOTO if (desired_size > *buffer_size) { 42806a99fe3SHajimu UMEMOTO /* this assignment is here for future use */ 42906a99fe3SHajimu UMEMOTO *buffer_size = desired_size; 43006a99fe3SHajimu UMEMOTO return (NS_RETURN); 43106a99fe3SHajimu UMEMOTO } 43206a99fe3SHajimu UMEMOTO 43306a99fe3SHajimu UMEMOTO memcpy(&new_ht, ht, sizeof(struct hostent)); 43406a99fe3SHajimu UMEMOTO memset(buffer, 0, desired_size); 43506a99fe3SHajimu UMEMOTO 43606a99fe3SHajimu UMEMOTO *buffer_size = desired_size; 43706a99fe3SHajimu UMEMOTO p = buffer + sizeof(struct hostent) + sizeof(char *); 43806a99fe3SHajimu UMEMOTO memcpy(buffer + sizeof(struct hostent), &p, sizeof(char *)); 43906a99fe3SHajimu UMEMOTO p = (char *)_ALIGN(p); 44006a99fe3SHajimu UMEMOTO 44106a99fe3SHajimu UMEMOTO if (new_ht.h_name != NULL) { 44206a99fe3SHajimu UMEMOTO size = strlen(new_ht.h_name); 44306a99fe3SHajimu UMEMOTO memcpy(p, new_ht.h_name, size); 44406a99fe3SHajimu UMEMOTO new_ht.h_name = p; 44506a99fe3SHajimu UMEMOTO p += size + 1; 44606a99fe3SHajimu UMEMOTO } 44706a99fe3SHajimu UMEMOTO 44806a99fe3SHajimu UMEMOTO if (new_ht.h_aliases != NULL) { 44906a99fe3SHajimu UMEMOTO p = (char *)_ALIGN(p); 45006a99fe3SHajimu UMEMOTO memcpy(p, new_ht.h_aliases, sizeof(char *) * aliases_size); 45106a99fe3SHajimu UMEMOTO new_ht.h_aliases = (char **)p; 45206a99fe3SHajimu UMEMOTO p += sizeof(char *) * (aliases_size + 1); 45306a99fe3SHajimu UMEMOTO 45406a99fe3SHajimu UMEMOTO for (iter = new_ht.h_aliases; *iter; ++iter) { 45506a99fe3SHajimu UMEMOTO size = strlen(*iter); 45606a99fe3SHajimu UMEMOTO memcpy(p, *iter, size); 45706a99fe3SHajimu UMEMOTO *iter = p; 45806a99fe3SHajimu UMEMOTO p += size + 1; 45906a99fe3SHajimu UMEMOTO } 46006a99fe3SHajimu UMEMOTO } 46106a99fe3SHajimu UMEMOTO 46206a99fe3SHajimu UMEMOTO if (new_ht.h_addr_list != NULL) { 46306a99fe3SHajimu UMEMOTO p = (char *)_ALIGN(p); 46406a99fe3SHajimu UMEMOTO memcpy(p, new_ht.h_addr_list, sizeof(char *) * addr_size); 46506a99fe3SHajimu UMEMOTO new_ht.h_addr_list = (char **)p; 46606a99fe3SHajimu UMEMOTO p += sizeof(char *) * (addr_size + 1); 46706a99fe3SHajimu UMEMOTO 46806a99fe3SHajimu UMEMOTO size = _ALIGN(new_ht.h_length); 46906a99fe3SHajimu UMEMOTO for (iter = new_ht.h_addr_list; *iter; ++iter) { 47006a99fe3SHajimu UMEMOTO memcpy(p, *iter, size); 47106a99fe3SHajimu UMEMOTO *iter = p; 47206a99fe3SHajimu UMEMOTO p += size + 1; 47306a99fe3SHajimu UMEMOTO } 47406a99fe3SHajimu UMEMOTO } 47506a99fe3SHajimu UMEMOTO memcpy(buffer, &new_ht, sizeof(struct hostent)); 47606a99fe3SHajimu UMEMOTO return (NS_SUCCESS); 47706a99fe3SHajimu UMEMOTO } 47806a99fe3SHajimu UMEMOTO 47906a99fe3SHajimu UMEMOTO static int 48006a99fe3SHajimu UMEMOTO ipnode_unmarshal_func(char *buffer, size_t buffer_size, void *retval, 48106a99fe3SHajimu UMEMOTO va_list ap, void *cache_mdata) 48206a99fe3SHajimu UMEMOTO { 48306a99fe3SHajimu UMEMOTO struct hostent new_ht; 48406a99fe3SHajimu UMEMOTO struct hostent *ht; 48506a99fe3SHajimu UMEMOTO 48606a99fe3SHajimu UMEMOTO char *p; 48706a99fe3SHajimu UMEMOTO char **iter; 48806a99fe3SHajimu UMEMOTO char *orig_buf; 48906a99fe3SHajimu UMEMOTO int err; 49006a99fe3SHajimu UMEMOTO 49106a99fe3SHajimu UMEMOTO ht = &new_ht; 49206a99fe3SHajimu UMEMOTO 49306a99fe3SHajimu UMEMOTO memcpy(ht, buffer, sizeof(struct hostent)); 49406a99fe3SHajimu UMEMOTO memcpy(&p, buffer + sizeof(struct hostent), sizeof(char *)); 49506a99fe3SHajimu UMEMOTO 49606a99fe3SHajimu UMEMOTO orig_buf = buffer + sizeof(struct hostent) + sizeof(char *) + 49706a99fe3SHajimu UMEMOTO _ALIGN(p) - (size_t)p; 49806a99fe3SHajimu UMEMOTO p = (char *)_ALIGN(p); 49906a99fe3SHajimu UMEMOTO 50006a99fe3SHajimu UMEMOTO 50106a99fe3SHajimu UMEMOTO NS_APPLY_OFFSET(ht->h_name, orig_buf, p, char *); 50206a99fe3SHajimu UMEMOTO if (ht->h_aliases != NULL) { 50306a99fe3SHajimu UMEMOTO NS_APPLY_OFFSET(ht->h_aliases, orig_buf, p, char **); 50406a99fe3SHajimu UMEMOTO 50506a99fe3SHajimu UMEMOTO for (iter = ht->h_aliases; *iter; ++iter) 50606a99fe3SHajimu UMEMOTO NS_APPLY_OFFSET(*iter, orig_buf, p, char *); 50706a99fe3SHajimu UMEMOTO } 50806a99fe3SHajimu UMEMOTO 50906a99fe3SHajimu UMEMOTO if (ht->h_addr_list != NULL) { 51006a99fe3SHajimu UMEMOTO NS_APPLY_OFFSET(ht->h_addr_list, orig_buf, p, char **); 51106a99fe3SHajimu UMEMOTO 51206a99fe3SHajimu UMEMOTO for (iter = ht->h_addr_list; *iter; ++iter) 51306a99fe3SHajimu UMEMOTO NS_APPLY_OFFSET(*iter, orig_buf, p, char *); 51406a99fe3SHajimu UMEMOTO } 51506a99fe3SHajimu UMEMOTO 51606a99fe3SHajimu UMEMOTO ht = _hpcopy(ht, &err); 51706a99fe3SHajimu UMEMOTO if (ht == NULL) 51806a99fe3SHajimu UMEMOTO return (NS_UNAVAIL); 51906a99fe3SHajimu UMEMOTO 52006a99fe3SHajimu UMEMOTO *((struct hostent **)retval) = ht; 52106a99fe3SHajimu UMEMOTO return (NS_SUCCESS); 52206a99fe3SHajimu UMEMOTO } 52306a99fe3SHajimu UMEMOTO #endif 52406a99fe3SHajimu UMEMOTO 5257d56d374SYoshinobu Inoue /* 5267d56d374SYoshinobu Inoue * Functions defined in RFC2553 52773b30f0cSJun-ichiro itojun Hagino * getipnodebyname, getipnodebyaddr, freehostent 5287d56d374SYoshinobu Inoue */ 5297d56d374SYoshinobu Inoue 5307d56d374SYoshinobu Inoue static struct hostent * 5317d56d374SYoshinobu Inoue _ghbyname(const char *name, int af, int flags, int *errp) 5327d56d374SYoshinobu Inoue { 5337d56d374SYoshinobu Inoue struct hostent *hp; 534cb0600bdSJacques Vidrine int rval; 535248aee62SJacques Vidrine 53606a99fe3SHajimu UMEMOTO #ifdef NS_CACHING 53706a99fe3SHajimu UMEMOTO static const nss_cache_info cache_info = 53806a99fe3SHajimu UMEMOTO NS_COMMON_CACHE_INFO_INITIALIZER( 53906a99fe3SHajimu UMEMOTO hosts, (void *)nss_lt_name, 54006a99fe3SHajimu UMEMOTO ipnode_id_func, ipnode_marshal_func, ipnode_unmarshal_func); 54106a99fe3SHajimu UMEMOTO #endif 542248aee62SJacques Vidrine static const ns_dtab dtab[] = { 543248aee62SJacques Vidrine NS_FILES_CB(_files_ghbyname, NULL) 544248aee62SJacques Vidrine { NSSRC_DNS, _dns_ghbyname, NULL }, 545248aee62SJacques Vidrine NS_NIS_CB(_nis_ghbyname, NULL) 54606a99fe3SHajimu UMEMOTO #ifdef NS_CACHING 54706a99fe3SHajimu UMEMOTO NS_CACHE_CB(&cache_info) 54806a99fe3SHajimu UMEMOTO #endif 549248aee62SJacques Vidrine { 0 } 550248aee62SJacques Vidrine }; 5517d56d374SYoshinobu Inoue 5527d56d374SYoshinobu Inoue if (flags & AI_ADDRCONFIG) { 5537d56d374SYoshinobu Inoue int s; 5547d56d374SYoshinobu Inoue 5550fbf0979SHajimu UMEMOTO if ((s = _socket(af, SOCK_DGRAM, 0)) < 0) 5560fbf0979SHajimu UMEMOTO return NULL; 5577d56d374SYoshinobu Inoue /* 5587d56d374SYoshinobu Inoue * TODO: 5597d56d374SYoshinobu Inoue * Note that implementation dependent test for address 5607d56d374SYoshinobu Inoue * configuration should be done everytime called 5617d56d374SYoshinobu Inoue * (or apropriate interval), 5627d56d374SYoshinobu Inoue * because addresses will be dynamically assigned or deleted. 5637d56d374SYoshinobu Inoue */ 5649233c4d9SJason Evans _close(s); 5657d56d374SYoshinobu Inoue } 5667d56d374SYoshinobu Inoue 56720e0e084SJacques Vidrine rval = _nsdispatch(&hp, dtab, NSDB_HOSTS, "ghbyname", default_src, 568248aee62SJacques Vidrine name, af, errp); 569248aee62SJacques Vidrine return (rval == NS_SUCCESS) ? hp : NULL; 5707d56d374SYoshinobu Inoue } 5717d56d374SYoshinobu Inoue 5720fbf0979SHajimu UMEMOTO struct hostent * 5730fbf0979SHajimu UMEMOTO getipnodebyname(const char *name, int af, int flags, int *errp) 5747d56d374SYoshinobu Inoue { 5757d56d374SYoshinobu Inoue struct hostent *hp; 5767d56d374SYoshinobu Inoue union inx_addr addrbuf; 5775342d17fSHajimu UMEMOTO res_state statp; 5787d56d374SYoshinobu Inoue 579946e41f1SHajimu UMEMOTO switch (af) { 580946e41f1SHajimu UMEMOTO case AF_INET: 5817d56d374SYoshinobu Inoue #ifdef INET6 582946e41f1SHajimu UMEMOTO case AF_INET6: 5837d56d374SYoshinobu Inoue #endif 584946e41f1SHajimu UMEMOTO break; 585946e41f1SHajimu UMEMOTO default: 5867d56d374SYoshinobu Inoue *errp = NO_RECOVERY; 5877d56d374SYoshinobu Inoue return NULL; 5887d56d374SYoshinobu Inoue } 5897d56d374SYoshinobu Inoue 5907d56d374SYoshinobu Inoue #ifdef INET6 5917d56d374SYoshinobu Inoue /* special case for literal address */ 5927d56d374SYoshinobu Inoue if (inet_pton(AF_INET6, name, &addrbuf) == 1) { 5937d56d374SYoshinobu Inoue if (af != AF_INET6) { 5947d56d374SYoshinobu Inoue *errp = HOST_NOT_FOUND; 5957d56d374SYoshinobu Inoue return NULL; 5967d56d374SYoshinobu Inoue } 5977d56d374SYoshinobu Inoue return _hpaddr(af, name, &addrbuf, errp); 5987d56d374SYoshinobu Inoue } 5997d56d374SYoshinobu Inoue #endif 600be26adb5SYoshinobu Inoue if (inet_aton(name, (struct in_addr *)&addrbuf) == 1) { 6017d56d374SYoshinobu Inoue if (af != AF_INET) { 6027d56d374SYoshinobu Inoue if (MAPADDRENABLED(flags)) { 6037d56d374SYoshinobu Inoue MAPADDR(&addrbuf, &addrbuf.in_addr); 6047d56d374SYoshinobu Inoue } else { 6057d56d374SYoshinobu Inoue *errp = HOST_NOT_FOUND; 6067d56d374SYoshinobu Inoue return NULL; 6077d56d374SYoshinobu Inoue } 6087d56d374SYoshinobu Inoue } 6097d56d374SYoshinobu Inoue return _hpaddr(af, name, &addrbuf, errp); 6107d56d374SYoshinobu Inoue } 6117d56d374SYoshinobu Inoue 6125342d17fSHajimu UMEMOTO statp = __res_state(); 6135342d17fSHajimu UMEMOTO if ((statp->options & RES_INIT) == 0) { 6145342d17fSHajimu UMEMOTO if (res_ninit(statp) < 0) { 6155342d17fSHajimu UMEMOTO *errp = NETDB_INTERNAL; 6165342d17fSHajimu UMEMOTO return NULL; 6175342d17fSHajimu UMEMOTO } 6185342d17fSHajimu UMEMOTO } 6195342d17fSHajimu UMEMOTO 6207d56d374SYoshinobu Inoue *errp = HOST_NOT_FOUND; 6217d56d374SYoshinobu Inoue hp = _ghbyname(name, af, flags, errp); 6227d56d374SYoshinobu Inoue 6237d56d374SYoshinobu Inoue #ifdef INET6 624946e41f1SHajimu UMEMOTO if (af == AF_INET6 && ((flags & AI_ALL) || hp == NULL) && 625946e41f1SHajimu UMEMOTO MAPADDRENABLED(flags)) { 6267d56d374SYoshinobu Inoue struct hostent *hp2 = _ghbyname(name, AF_INET, flags, errp); 6277d56d374SYoshinobu Inoue if (hp == NULL) 6287d56d374SYoshinobu Inoue hp = _hpmapv6(hp2, errp); 6297d56d374SYoshinobu Inoue else { 6307d56d374SYoshinobu Inoue if (hp2 && strcmp(hp->h_name, hp2->h_name) != 0) { 6317d56d374SYoshinobu Inoue freehostent(hp2); 6327d56d374SYoshinobu Inoue hp2 = NULL; 6337d56d374SYoshinobu Inoue } 6347d56d374SYoshinobu Inoue hp = _hpmerge(hp, hp2, errp); 6357d56d374SYoshinobu Inoue } 6367d56d374SYoshinobu Inoue } 6377d56d374SYoshinobu Inoue #endif 6385342d17fSHajimu UMEMOTO return _hpreorder(_hpsort(hp, statp)); 6397d56d374SYoshinobu Inoue } 6407d56d374SYoshinobu Inoue 6417d56d374SYoshinobu Inoue struct hostent * 6427d56d374SYoshinobu Inoue getipnodebyaddr(const void *src, size_t len, int af, int *errp) 6437d56d374SYoshinobu Inoue { 6447d56d374SYoshinobu Inoue struct hostent *hp; 645cb0600bdSJacques Vidrine int rval; 6467d56d374SYoshinobu Inoue #ifdef INET6 6477d56d374SYoshinobu Inoue struct in6_addr addrbuf; 6487d56d374SYoshinobu Inoue #else 6497d56d374SYoshinobu Inoue struct in_addr addrbuf; 6507d56d374SYoshinobu Inoue #endif 6517d56d374SYoshinobu Inoue 65206a99fe3SHajimu UMEMOTO #ifdef NS_CACHING 65306a99fe3SHajimu UMEMOTO static const nss_cache_info cache_info = 65406a99fe3SHajimu UMEMOTO NS_COMMON_CACHE_INFO_INITIALIZER( 65506a99fe3SHajimu UMEMOTO hosts, (void *)nss_lt_id, 65606a99fe3SHajimu UMEMOTO ipnode_id_func, ipnode_marshal_func, ipnode_unmarshal_func); 65706a99fe3SHajimu UMEMOTO #endif 658248aee62SJacques Vidrine static const ns_dtab dtab[] = { 659248aee62SJacques Vidrine NS_FILES_CB(_files_ghbyaddr, NULL) 660248aee62SJacques Vidrine { NSSRC_DNS, _dns_ghbyaddr, NULL }, 661248aee62SJacques Vidrine NS_NIS_CB(_nis_ghbyaddr, NULL) 662248aee62SJacques Vidrine #ifdef ICMPNL 663248aee62SJacques Vidrine { NSSRC_ICMP, _icmp_ghbyaddr, NULL }, 664248aee62SJacques Vidrine #endif 66506a99fe3SHajimu UMEMOTO #ifdef NS_CACHING 66606a99fe3SHajimu UMEMOTO NS_CACHE_CB(&cache_info) 66706a99fe3SHajimu UMEMOTO #endif 668248aee62SJacques Vidrine { 0 } 669248aee62SJacques Vidrine }; 670248aee62SJacques Vidrine 6717d56d374SYoshinobu Inoue *errp = HOST_NOT_FOUND; 6727d56d374SYoshinobu Inoue 6737d56d374SYoshinobu Inoue switch (af) { 6747d56d374SYoshinobu Inoue case AF_INET: 6757d56d374SYoshinobu Inoue if (len != sizeof(struct in_addr)) { 6767d56d374SYoshinobu Inoue *errp = NO_RECOVERY; 6777d56d374SYoshinobu Inoue return NULL; 6787d56d374SYoshinobu Inoue } 6797d56d374SYoshinobu Inoue if ((long)src & ~(sizeof(struct in_addr) - 1)) { 6807d56d374SYoshinobu Inoue memcpy(&addrbuf, src, len); 6817d56d374SYoshinobu Inoue src = &addrbuf; 6827d56d374SYoshinobu Inoue } 6837d56d374SYoshinobu Inoue if (((struct in_addr *)src)->s_addr == 0) 6847d56d374SYoshinobu Inoue return NULL; 6857d56d374SYoshinobu Inoue break; 6867d56d374SYoshinobu Inoue #ifdef INET6 6877d56d374SYoshinobu Inoue case AF_INET6: 6887d56d374SYoshinobu Inoue if (len != sizeof(struct in6_addr)) { 6897d56d374SYoshinobu Inoue *errp = NO_RECOVERY; 6907d56d374SYoshinobu Inoue return NULL; 6917d56d374SYoshinobu Inoue } 6927d56d374SYoshinobu Inoue if ((long)src & ~(sizeof(struct in6_addr) / 2 - 1)) { /*XXX*/ 6937d56d374SYoshinobu Inoue memcpy(&addrbuf, src, len); 6947d56d374SYoshinobu Inoue src = &addrbuf; 6957d56d374SYoshinobu Inoue } 6963d670abcSYoshinobu Inoue if (IN6_IS_ADDR_UNSPECIFIED((struct in6_addr *)src)) 6973d670abcSYoshinobu Inoue return NULL; 6987d56d374SYoshinobu Inoue if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)src) 6997d56d374SYoshinobu Inoue || IN6_IS_ADDR_V4COMPAT((struct in6_addr *)src)) { 7007d56d374SYoshinobu Inoue src = (char *)src + 7017d56d374SYoshinobu Inoue (sizeof(struct in6_addr) - sizeof(struct in_addr)); 7027d56d374SYoshinobu Inoue af = AF_INET; 7037d56d374SYoshinobu Inoue len = sizeof(struct in_addr); 7047d56d374SYoshinobu Inoue } 7057d56d374SYoshinobu Inoue break; 7067d56d374SYoshinobu Inoue #endif 7077d56d374SYoshinobu Inoue default: 7087d56d374SYoshinobu Inoue *errp = NO_RECOVERY; 7097d56d374SYoshinobu Inoue return NULL; 7107d56d374SYoshinobu Inoue } 7117d56d374SYoshinobu Inoue 71220e0e084SJacques Vidrine rval = _nsdispatch(&hp, dtab, NSDB_HOSTS, "ghbyaddr", default_src, 713248aee62SJacques Vidrine src, len, af, errp); 714248aee62SJacques Vidrine return (rval == NS_SUCCESS) ? hp : NULL; 7157d56d374SYoshinobu Inoue } 7167d56d374SYoshinobu Inoue 7177d56d374SYoshinobu Inoue void 7187d56d374SYoshinobu Inoue freehostent(struct hostent *ptr) 7197d56d374SYoshinobu Inoue { 7207d56d374SYoshinobu Inoue free(ptr); 7217d56d374SYoshinobu Inoue } 7227d56d374SYoshinobu Inoue 7237d56d374SYoshinobu Inoue /* 7247d56d374SYoshinobu Inoue * Private utility functions 7257d56d374SYoshinobu Inoue */ 7267d56d374SYoshinobu Inoue 7277d56d374SYoshinobu Inoue /* 7287d56d374SYoshinobu Inoue * _hpcopy: allocate and copy hostent structure 7297d56d374SYoshinobu Inoue */ 7307d56d374SYoshinobu Inoue static struct hostent * 7317d56d374SYoshinobu Inoue _hpcopy(struct hostent *hp, int *errp) 7327d56d374SYoshinobu Inoue { 7337d56d374SYoshinobu Inoue struct hostent *nhp; 7347d56d374SYoshinobu Inoue char *cp, **pp; 7357d56d374SYoshinobu Inoue int size, addrsize; 7367d56d374SYoshinobu Inoue int nalias = 0, naddr = 0; 7377d56d374SYoshinobu Inoue int al_off; 7387d56d374SYoshinobu Inoue int i; 7397d56d374SYoshinobu Inoue 7407d56d374SYoshinobu Inoue if (hp == NULL) 7417d56d374SYoshinobu Inoue return hp; 7427d56d374SYoshinobu Inoue 7437d56d374SYoshinobu Inoue /* count size to be allocated */ 7447d56d374SYoshinobu Inoue size = sizeof(struct hostent); 74505c36511SHajimu UMEMOTO if (hp->h_name != NULL) 7467d56d374SYoshinobu Inoue size += strlen(hp->h_name) + 1; 7477d56d374SYoshinobu Inoue if ((pp = hp->h_aliases) != NULL) { 7487d56d374SYoshinobu Inoue for (i = 0; *pp != NULL; i++, pp++) { 7497d56d374SYoshinobu Inoue if (**pp != '\0') { 7507d56d374SYoshinobu Inoue size += strlen(*pp) + 1; 7517d56d374SYoshinobu Inoue nalias++; 7527d56d374SYoshinobu Inoue } 7537d56d374SYoshinobu Inoue } 7547d56d374SYoshinobu Inoue } 7557d56d374SYoshinobu Inoue /* adjust alignment */ 7567d56d374SYoshinobu Inoue size = ALIGN(size); 7577d56d374SYoshinobu Inoue al_off = size; 7587d56d374SYoshinobu Inoue size += sizeof(char *) * (nalias + 1); 7597d56d374SYoshinobu Inoue addrsize = ALIGN(hp->h_length); 7607d56d374SYoshinobu Inoue if ((pp = hp->h_addr_list) != NULL) { 7617d56d374SYoshinobu Inoue while (*pp++ != NULL) 7627d56d374SYoshinobu Inoue naddr++; 7637d56d374SYoshinobu Inoue } 7647d56d374SYoshinobu Inoue size += addrsize * naddr; 7657d56d374SYoshinobu Inoue size += sizeof(char *) * (naddr + 1); 7667d56d374SYoshinobu Inoue 7677d56d374SYoshinobu Inoue /* copy */ 7687d56d374SYoshinobu Inoue if ((nhp = (struct hostent *)malloc(size)) == NULL) { 7697d56d374SYoshinobu Inoue *errp = TRY_AGAIN; 7707d56d374SYoshinobu Inoue return NULL; 7717d56d374SYoshinobu Inoue } 7727d56d374SYoshinobu Inoue cp = (char *)&nhp[1]; 77305c36511SHajimu UMEMOTO if (hp->h_name != NULL) { 7747d56d374SYoshinobu Inoue nhp->h_name = cp; 7757d56d374SYoshinobu Inoue strcpy(cp, hp->h_name); 7767d56d374SYoshinobu Inoue cp += strlen(cp) + 1; 7777d56d374SYoshinobu Inoue } else 7787d56d374SYoshinobu Inoue nhp->h_name = NULL; 7797d56d374SYoshinobu Inoue nhp->h_aliases = (char **)((char *)nhp + al_off); 7807d56d374SYoshinobu Inoue if ((pp = hp->h_aliases) != NULL) { 7817d56d374SYoshinobu Inoue for (i = 0; *pp != NULL; pp++) { 7827d56d374SYoshinobu Inoue if (**pp != '\0') { 7837d56d374SYoshinobu Inoue nhp->h_aliases[i++] = cp; 7847d56d374SYoshinobu Inoue strcpy(cp, *pp); 7857d56d374SYoshinobu Inoue cp += strlen(cp) + 1; 7867d56d374SYoshinobu Inoue } 7877d56d374SYoshinobu Inoue } 7887d56d374SYoshinobu Inoue } 7897d56d374SYoshinobu Inoue nhp->h_aliases[nalias] = NULL; 7907d56d374SYoshinobu Inoue cp = (char *)&nhp->h_aliases[nalias + 1]; 7917d56d374SYoshinobu Inoue nhp->h_addrtype = hp->h_addrtype; 7927d56d374SYoshinobu Inoue nhp->h_length = hp->h_length; 7937d56d374SYoshinobu Inoue nhp->h_addr_list = (char **)cp; 7947d56d374SYoshinobu Inoue if ((pp = hp->h_addr_list) != NULL) { 7957d56d374SYoshinobu Inoue cp = (char *)&nhp->h_addr_list[naddr + 1]; 7967d56d374SYoshinobu Inoue for (i = 0; *pp != NULL; pp++) { 7977d56d374SYoshinobu Inoue nhp->h_addr_list[i++] = cp; 7987d56d374SYoshinobu Inoue memcpy(cp, *pp, hp->h_length); 7997d56d374SYoshinobu Inoue cp += addrsize; 8007d56d374SYoshinobu Inoue } 8017d56d374SYoshinobu Inoue } 8027d56d374SYoshinobu Inoue nhp->h_addr_list[naddr] = NULL; 8037d56d374SYoshinobu Inoue return nhp; 8047d56d374SYoshinobu Inoue } 8057d56d374SYoshinobu Inoue 8067d56d374SYoshinobu Inoue /* 8077d56d374SYoshinobu Inoue * _hpaddr: construct hostent structure with one address 8087d56d374SYoshinobu Inoue */ 8097d56d374SYoshinobu Inoue static struct hostent * 8107d56d374SYoshinobu Inoue _hpaddr(int af, const char *name, void *addr, int *errp) 8117d56d374SYoshinobu Inoue { 8127d56d374SYoshinobu Inoue struct hostent *hp, hpbuf; 8137d56d374SYoshinobu Inoue char *addrs[2]; 8147d56d374SYoshinobu Inoue 8157d56d374SYoshinobu Inoue hp = &hpbuf; 8167d56d374SYoshinobu Inoue hp->h_name = (char *)name; 8177d56d374SYoshinobu Inoue hp->h_aliases = NULL; 8187d56d374SYoshinobu Inoue hp->h_addrtype = af; 8197d56d374SYoshinobu Inoue hp->h_length = ADDRLEN(af); 8207d56d374SYoshinobu Inoue hp->h_addr_list = addrs; 8217d56d374SYoshinobu Inoue addrs[0] = (char *)addr; 8227d56d374SYoshinobu Inoue addrs[1] = NULL; 8237d56d374SYoshinobu Inoue return _hpcopy(hp, errp); 8247d56d374SYoshinobu Inoue } 8257d56d374SYoshinobu Inoue 8267d56d374SYoshinobu Inoue /* 8277d56d374SYoshinobu Inoue * _hpmerge: merge 2 hostent structure, arguments will be freed 8287d56d374SYoshinobu Inoue */ 8297d56d374SYoshinobu Inoue static struct hostent * 8307d56d374SYoshinobu Inoue _hpmerge(struct hostent *hp1, struct hostent *hp2, int *errp) 8317d56d374SYoshinobu Inoue { 8327d56d374SYoshinobu Inoue int i, j; 8337d56d374SYoshinobu Inoue int naddr, nalias; 8347d56d374SYoshinobu Inoue char **pp; 8357d56d374SYoshinobu Inoue struct hostent *hp, hpbuf; 8367d56d374SYoshinobu Inoue char *aliases[MAXALIASES + 1], *addrs[MAXADDRS + 1]; 8377d56d374SYoshinobu Inoue union inx_addr addrbuf[MAXADDRS]; 8387d56d374SYoshinobu Inoue 8397d56d374SYoshinobu Inoue if (hp1 == NULL) 8407d56d374SYoshinobu Inoue return hp2; 8417d56d374SYoshinobu Inoue if (hp2 == NULL) 8427d56d374SYoshinobu Inoue return hp1; 8437d56d374SYoshinobu Inoue 8447d56d374SYoshinobu Inoue #define HP(i) (i == 1 ? hp1 : hp2) 8457d56d374SYoshinobu Inoue hp = &hpbuf; 8467d56d374SYoshinobu Inoue hp->h_name = (hp1->h_name != NULL ? hp1->h_name : hp2->h_name); 8477d56d374SYoshinobu Inoue hp->h_aliases = aliases; 8487d56d374SYoshinobu Inoue nalias = 0; 8497d56d374SYoshinobu Inoue for (i = 1; i <= 2; i++) { 8507d56d374SYoshinobu Inoue if ((pp = HP(i)->h_aliases) == NULL) 8517d56d374SYoshinobu Inoue continue; 8527d56d374SYoshinobu Inoue for (; nalias < MAXALIASES && *pp != NULL; pp++) { 8537d56d374SYoshinobu Inoue /* check duplicates */ 8547d56d374SYoshinobu Inoue for (j = 0; j < nalias; j++) 8557d56d374SYoshinobu Inoue if (strcasecmp(*pp, aliases[j]) == 0) 8567d56d374SYoshinobu Inoue break; 8577d56d374SYoshinobu Inoue if (j == nalias) 8587d56d374SYoshinobu Inoue aliases[nalias++] = *pp; 8597d56d374SYoshinobu Inoue } 8607d56d374SYoshinobu Inoue } 8617d56d374SYoshinobu Inoue aliases[nalias] = NULL; 8627d56d374SYoshinobu Inoue #ifdef INET6 8637d56d374SYoshinobu Inoue if (hp1->h_length != hp2->h_length) { 8647d56d374SYoshinobu Inoue hp->h_addrtype = AF_INET6; 8657d56d374SYoshinobu Inoue hp->h_length = sizeof(struct in6_addr); 8667d56d374SYoshinobu Inoue } else { 8677d56d374SYoshinobu Inoue #endif 8687d56d374SYoshinobu Inoue hp->h_addrtype = hp1->h_addrtype; 8697d56d374SYoshinobu Inoue hp->h_length = hp1->h_length; 8707d56d374SYoshinobu Inoue #ifdef INET6 8717d56d374SYoshinobu Inoue } 8727d56d374SYoshinobu Inoue #endif 8737d56d374SYoshinobu Inoue hp->h_addr_list = addrs; 8747d56d374SYoshinobu Inoue naddr = 0; 8757d56d374SYoshinobu Inoue for (i = 1; i <= 2; i++) { 8767d56d374SYoshinobu Inoue if ((pp = HP(i)->h_addr_list) == NULL) 8777d56d374SYoshinobu Inoue continue; 8787d56d374SYoshinobu Inoue if (HP(i)->h_length == hp->h_length) { 8797d56d374SYoshinobu Inoue while (naddr < MAXADDRS && *pp != NULL) 8807d56d374SYoshinobu Inoue addrs[naddr++] = *pp++; 8817d56d374SYoshinobu Inoue } else { 8827d56d374SYoshinobu Inoue /* copy IPv4 addr as mapped IPv6 addr */ 8837d56d374SYoshinobu Inoue while (naddr < MAXADDRS && *pp != NULL) { 8847d56d374SYoshinobu Inoue MAPADDR(&addrbuf[naddr], *pp++); 8857d56d374SYoshinobu Inoue addrs[naddr] = (char *)&addrbuf[naddr]; 8867d56d374SYoshinobu Inoue naddr++; 8877d56d374SYoshinobu Inoue } 8887d56d374SYoshinobu Inoue } 8897d56d374SYoshinobu Inoue } 8907d56d374SYoshinobu Inoue addrs[naddr] = NULL; 8917d56d374SYoshinobu Inoue hp = _hpcopy(hp, errp); 8927d56d374SYoshinobu Inoue freehostent(hp1); 8937d56d374SYoshinobu Inoue freehostent(hp2); 8947d56d374SYoshinobu Inoue return hp; 8957d56d374SYoshinobu Inoue } 8967d56d374SYoshinobu Inoue 8977d56d374SYoshinobu Inoue /* 8987d56d374SYoshinobu Inoue * _hpmapv6: convert IPv4 hostent into IPv4-mapped IPv6 addresses 8997d56d374SYoshinobu Inoue */ 9007d56d374SYoshinobu Inoue #ifdef INET6 9017d56d374SYoshinobu Inoue static struct hostent * 9027d56d374SYoshinobu Inoue _hpmapv6(struct hostent *hp, int *errp) 9037d56d374SYoshinobu Inoue { 9047d56d374SYoshinobu Inoue struct hostent *hp6; 9057d56d374SYoshinobu Inoue 9067d56d374SYoshinobu Inoue if (hp == NULL) 9077d56d374SYoshinobu Inoue return NULL; 9087d56d374SYoshinobu Inoue if (hp->h_addrtype == AF_INET6) 9097d56d374SYoshinobu Inoue return hp; 9107d56d374SYoshinobu Inoue 9117d56d374SYoshinobu Inoue /* make dummy hostent to convert IPv6 address */ 9127d56d374SYoshinobu Inoue if ((hp6 = (struct hostent *)malloc(sizeof(struct hostent))) == NULL) { 9137d56d374SYoshinobu Inoue *errp = TRY_AGAIN; 9147d56d374SYoshinobu Inoue return NULL; 9157d56d374SYoshinobu Inoue } 9167d56d374SYoshinobu Inoue hp6->h_name = NULL; 9177d56d374SYoshinobu Inoue hp6->h_aliases = NULL; 9187d56d374SYoshinobu Inoue hp6->h_addrtype = AF_INET6; 9197d56d374SYoshinobu Inoue hp6->h_length = sizeof(struct in6_addr); 9207d56d374SYoshinobu Inoue hp6->h_addr_list = NULL; 9217d56d374SYoshinobu Inoue return _hpmerge(hp6, hp, errp); 9227d56d374SYoshinobu Inoue } 9237d56d374SYoshinobu Inoue #endif 9247d56d374SYoshinobu Inoue 9257d56d374SYoshinobu Inoue /* 9267d56d374SYoshinobu Inoue * _hpsort: sort address by sortlist 9277d56d374SYoshinobu Inoue */ 9287d56d374SYoshinobu Inoue static struct hostent * 9295342d17fSHajimu UMEMOTO _hpsort(struct hostent *hp, res_state statp) 9307d56d374SYoshinobu Inoue { 9317d56d374SYoshinobu Inoue int i, j, n; 9327d56d374SYoshinobu Inoue u_char *ap, *sp, *mp, **pp; 9337d56d374SYoshinobu Inoue char t; 9347d56d374SYoshinobu Inoue char order[MAXADDRS]; 9355342d17fSHajimu UMEMOTO int nsort = statp->nsort; 9367d56d374SYoshinobu Inoue 9377d56d374SYoshinobu Inoue if (hp == NULL || hp->h_addr_list[1] == NULL || nsort == 0) 9387d56d374SYoshinobu Inoue return hp; 9397d56d374SYoshinobu Inoue for (i = 0; (ap = (u_char *)hp->h_addr_list[i]); i++) { 9407d56d374SYoshinobu Inoue for (j = 0; j < nsort; j++) { 9417d56d374SYoshinobu Inoue #ifdef INET6 9425342d17fSHajimu UMEMOTO if (statp->_u._ext.ext->sort_list[j].af != 9435342d17fSHajimu UMEMOTO hp->h_addrtype) 9447d56d374SYoshinobu Inoue continue; 9455342d17fSHajimu UMEMOTO sp = (u_char *)&statp->_u._ext.ext->sort_list[j].addr; 9465342d17fSHajimu UMEMOTO mp = (u_char *)&statp->_u._ext.ext->sort_list[j].mask; 9477d56d374SYoshinobu Inoue #else 9485342d17fSHajimu UMEMOTO sp = (u_char *)&statp->sort_list[j].addr; 9495342d17fSHajimu UMEMOTO mp = (u_char *)&statp->sort_list[j].mask; 9507d56d374SYoshinobu Inoue #endif 9517d56d374SYoshinobu Inoue for (n = 0; n < hp->h_length; n++) { 9527d56d374SYoshinobu Inoue if ((ap[n] & mp[n]) != sp[n]) 9537d56d374SYoshinobu Inoue break; 9547d56d374SYoshinobu Inoue } 9557d56d374SYoshinobu Inoue if (n == hp->h_length) 9567d56d374SYoshinobu Inoue break; 9577d56d374SYoshinobu Inoue } 9587d56d374SYoshinobu Inoue order[i] = j; 9597d56d374SYoshinobu Inoue } 9607d56d374SYoshinobu Inoue n = i; 9617d56d374SYoshinobu Inoue pp = (u_char **)hp->h_addr_list; 9627d56d374SYoshinobu Inoue for (i = 0; i < n - 1; i++) { 9637d56d374SYoshinobu Inoue for (j = i + 1; j < n; j++) { 9647d56d374SYoshinobu Inoue if (order[i] > order[j]) { 9657d56d374SYoshinobu Inoue ap = pp[i]; 9667d56d374SYoshinobu Inoue pp[i] = pp[j]; 9677d56d374SYoshinobu Inoue pp[j] = ap; 9687d56d374SYoshinobu Inoue t = order[i]; 9697d56d374SYoshinobu Inoue order[i] = order[j]; 9707d56d374SYoshinobu Inoue order[j] = t; 9717d56d374SYoshinobu Inoue } 9727d56d374SYoshinobu Inoue } 9737d56d374SYoshinobu Inoue } 9747d56d374SYoshinobu Inoue return hp; 9757d56d374SYoshinobu Inoue } 9767d56d374SYoshinobu Inoue 9777d56d374SYoshinobu Inoue static char * 9787d56d374SYoshinobu Inoue _hgetword(char **pp) 9797d56d374SYoshinobu Inoue { 9807d56d374SYoshinobu Inoue char c, *p, *ret; 9817d56d374SYoshinobu Inoue const char *sp; 9827d56d374SYoshinobu Inoue static const char sep[] = "# \t\n"; 9837d56d374SYoshinobu Inoue 9847d56d374SYoshinobu Inoue ret = NULL; 9857d56d374SYoshinobu Inoue for (p = *pp; (c = *p) != '\0'; p++) { 9867d56d374SYoshinobu Inoue for (sp = sep; *sp != '\0'; sp++) { 9877d56d374SYoshinobu Inoue if (c == *sp) 9887d56d374SYoshinobu Inoue break; 9897d56d374SYoshinobu Inoue } 9907d56d374SYoshinobu Inoue if (c == '#') 9917d56d374SYoshinobu Inoue p[1] = '\0'; /* ignore rest of line */ 9927d56d374SYoshinobu Inoue if (ret == NULL) { 9937d56d374SYoshinobu Inoue if (*sp == '\0') 9947d56d374SYoshinobu Inoue ret = p; 9957d56d374SYoshinobu Inoue } else { 9967d56d374SYoshinobu Inoue if (*sp != '\0') { 9977d56d374SYoshinobu Inoue *p++ = '\0'; 9987d56d374SYoshinobu Inoue break; 9997d56d374SYoshinobu Inoue } 10007d56d374SYoshinobu Inoue } 10017d56d374SYoshinobu Inoue } 10027d56d374SYoshinobu Inoue *pp = p; 10037d56d374SYoshinobu Inoue if (ret == NULL || *ret == '\0') 10047d56d374SYoshinobu Inoue return NULL; 10057d56d374SYoshinobu Inoue return ret; 10067d56d374SYoshinobu Inoue } 10077d56d374SYoshinobu Inoue 10087d56d374SYoshinobu Inoue /* 1009b8b31f33SHajimu UMEMOTO * _hpreorder: sort address by default address selection 1010b8b31f33SHajimu UMEMOTO */ 1011b8b31f33SHajimu UMEMOTO static struct hostent * 1012b8b31f33SHajimu UMEMOTO _hpreorder(struct hostent *hp) 1013b8b31f33SHajimu UMEMOTO { 1014146cd1bcSHajimu UMEMOTO struct hp_order *aio; 1015146cd1bcSHajimu UMEMOTO int i, n; 1016d6fd3ed8SHajimu UMEMOTO char *ap; 1017146cd1bcSHajimu UMEMOTO struct sockaddr *sa; 1018b8b31f33SHajimu UMEMOTO struct policyhead policyhead; 1019b8b31f33SHajimu UMEMOTO 1020146cd1bcSHajimu UMEMOTO if (hp == NULL) 1021b8b31f33SHajimu UMEMOTO return hp; 1022b8b31f33SHajimu UMEMOTO 1023b8b31f33SHajimu UMEMOTO switch (hp->h_addrtype) { 1024b8b31f33SHajimu UMEMOTO case AF_INET: 1025b8b31f33SHajimu UMEMOTO #ifdef INET6 1026b8b31f33SHajimu UMEMOTO case AF_INET6: 1027b8b31f33SHajimu UMEMOTO #endif 1028146cd1bcSHajimu UMEMOTO break; 1029b8b31f33SHajimu UMEMOTO default: 1030b8b31f33SHajimu UMEMOTO free_addrselectpolicy(&policyhead); 1031b8b31f33SHajimu UMEMOTO return hp; 1032b8b31f33SHajimu UMEMOTO } 1033b8b31f33SHajimu UMEMOTO 1034146cd1bcSHajimu UMEMOTO /* count the number of addrinfo elements for sorting. */ 1035146cd1bcSHajimu UMEMOTO for (n = 0; hp->h_addr_list[n] != NULL; n++) 1036146cd1bcSHajimu UMEMOTO ; 1037146cd1bcSHajimu UMEMOTO 1038146cd1bcSHajimu UMEMOTO /* 1039146cd1bcSHajimu UMEMOTO * If the number is small enough, we can skip the reordering process. 1040146cd1bcSHajimu UMEMOTO */ 1041146cd1bcSHajimu UMEMOTO if (n <= 1) 1042146cd1bcSHajimu UMEMOTO return hp; 1043146cd1bcSHajimu UMEMOTO 1044146cd1bcSHajimu UMEMOTO /* allocate a temporary array for sort and initialization of it. */ 1045146cd1bcSHajimu UMEMOTO if ((aio = malloc(sizeof(*aio) * n)) == NULL) 1046146cd1bcSHajimu UMEMOTO return hp; /* give up reordering */ 1047146cd1bcSHajimu UMEMOTO memset(aio, 0, sizeof(*aio) * n); 1048146cd1bcSHajimu UMEMOTO 1049146cd1bcSHajimu UMEMOTO /* retrieve address selection policy from the kernel */ 1050146cd1bcSHajimu UMEMOTO TAILQ_INIT(&policyhead); 1051146cd1bcSHajimu UMEMOTO if (!get_addrselectpolicy(&policyhead)) { 1052146cd1bcSHajimu UMEMOTO /* no policy is installed into kernel, we don't sort. */ 1053146cd1bcSHajimu UMEMOTO free(aio); 1054146cd1bcSHajimu UMEMOTO return hp; 1055b8b31f33SHajimu UMEMOTO } 1056b8b31f33SHajimu UMEMOTO 1057146cd1bcSHajimu UMEMOTO for (i = 0; i < n; i++) { 1058d6fd3ed8SHajimu UMEMOTO ap = hp->h_addr_list[i]; 1059146cd1bcSHajimu UMEMOTO aio[i].aio_h_addr = ap; 1060146cd1bcSHajimu UMEMOTO sa = &aio[i].aio_sa; 1061146cd1bcSHajimu UMEMOTO switch (hp->h_addrtype) { 1062146cd1bcSHajimu UMEMOTO case AF_INET: 1063146cd1bcSHajimu UMEMOTO sa->sa_family = AF_INET; 1064146cd1bcSHajimu UMEMOTO sa->sa_len = sizeof(struct sockaddr_in); 1065146cd1bcSHajimu UMEMOTO memcpy(&((struct sockaddr_in *)sa)->sin_addr, ap, 1066146cd1bcSHajimu UMEMOTO sizeof(struct in_addr)); 1067146cd1bcSHajimu UMEMOTO break; 1068146cd1bcSHajimu UMEMOTO #ifdef INET6 1069146cd1bcSHajimu UMEMOTO case AF_INET6: 1070146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) { 1071146cd1bcSHajimu UMEMOTO sa->sa_family = AF_INET; 1072146cd1bcSHajimu UMEMOTO sa->sa_len = sizeof(struct sockaddr_in); 1073146cd1bcSHajimu UMEMOTO memcpy(&((struct sockaddr_in *)sa)->sin_addr, 1074146cd1bcSHajimu UMEMOTO &ap[12], sizeof(struct in_addr)); 1075146cd1bcSHajimu UMEMOTO } else { 1076146cd1bcSHajimu UMEMOTO sa->sa_family = AF_INET6; 1077146cd1bcSHajimu UMEMOTO sa->sa_len = sizeof(struct sockaddr_in6); 1078146cd1bcSHajimu UMEMOTO memcpy(&((struct sockaddr_in6 *)sa)->sin6_addr, 1079146cd1bcSHajimu UMEMOTO ap, sizeof(struct in6_addr)); 1080146cd1bcSHajimu UMEMOTO } 1081146cd1bcSHajimu UMEMOTO break; 1082146cd1bcSHajimu UMEMOTO #endif 1083146cd1bcSHajimu UMEMOTO } 1084146cd1bcSHajimu UMEMOTO aio[i].aio_dstscope = gai_addr2scopetype(sa); 1085146cd1bcSHajimu UMEMOTO aio[i].aio_dstpolicy = match_addrselectpolicy(sa, &policyhead); 1086146cd1bcSHajimu UMEMOTO set_source(&aio[i], &policyhead); 1087146cd1bcSHajimu UMEMOTO } 1088146cd1bcSHajimu UMEMOTO 1089146cd1bcSHajimu UMEMOTO /* perform sorting. */ 1090146cd1bcSHajimu UMEMOTO qsort(aio, n, sizeof(*aio), comp_dst); 1091146cd1bcSHajimu UMEMOTO 1092146cd1bcSHajimu UMEMOTO /* reorder the h_addr_list. */ 1093146cd1bcSHajimu UMEMOTO for (i = 0; i < n; i++) 1094146cd1bcSHajimu UMEMOTO hp->h_addr_list[i] = aio[i].aio_h_addr; 1095146cd1bcSHajimu UMEMOTO 1096b8b31f33SHajimu UMEMOTO /* cleanup and return */ 1097146cd1bcSHajimu UMEMOTO free(aio); 1098b8b31f33SHajimu UMEMOTO free_addrselectpolicy(&policyhead); 1099b8b31f33SHajimu UMEMOTO return hp; 1100b8b31f33SHajimu UMEMOTO } 1101b8b31f33SHajimu UMEMOTO 1102b8b31f33SHajimu UMEMOTO static int 110390d1d883SHajimu UMEMOTO get_addrselectpolicy(struct policyhead *head) 1104b8b31f33SHajimu UMEMOTO { 1105b8b31f33SHajimu UMEMOTO #ifdef INET6 1106b8b31f33SHajimu UMEMOTO int mib[] = { CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_ADDRCTLPOLICY }; 1107b8b31f33SHajimu UMEMOTO size_t l; 1108b8b31f33SHajimu UMEMOTO char *buf; 1109b8b31f33SHajimu UMEMOTO struct in6_addrpolicy *pol, *ep; 1110b8b31f33SHajimu UMEMOTO 1111b8b31f33SHajimu UMEMOTO if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &l, NULL, 0) < 0) 1112b8b31f33SHajimu UMEMOTO return (0); 1113b8b31f33SHajimu UMEMOTO if ((buf = malloc(l)) == NULL) 1114b8b31f33SHajimu UMEMOTO return (0); 1115b8b31f33SHajimu UMEMOTO if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), buf, &l, NULL, 0) < 0) { 1116b8b31f33SHajimu UMEMOTO free(buf); 1117b8b31f33SHajimu UMEMOTO return (0); 1118b8b31f33SHajimu UMEMOTO } 1119b8b31f33SHajimu UMEMOTO 1120b8b31f33SHajimu UMEMOTO ep = (struct in6_addrpolicy *)(buf + l); 1121b8b31f33SHajimu UMEMOTO for (pol = (struct in6_addrpolicy *)buf; pol + 1 <= ep; pol++) { 1122b8b31f33SHajimu UMEMOTO struct policyqueue *new; 1123b8b31f33SHajimu UMEMOTO 1124b8b31f33SHajimu UMEMOTO if ((new = malloc(sizeof(*new))) == NULL) { 1125b8b31f33SHajimu UMEMOTO free_addrselectpolicy(head); /* make the list empty */ 1126b8b31f33SHajimu UMEMOTO break; 1127b8b31f33SHajimu UMEMOTO } 1128b8b31f33SHajimu UMEMOTO new->pc_policy = *pol; 1129b8b31f33SHajimu UMEMOTO TAILQ_INSERT_TAIL(head, new, pc_entry); 1130b8b31f33SHajimu UMEMOTO } 1131b8b31f33SHajimu UMEMOTO 1132b8b31f33SHajimu UMEMOTO free(buf); 1133b8b31f33SHajimu UMEMOTO return (1); 1134b8b31f33SHajimu UMEMOTO #else 1135b8b31f33SHajimu UMEMOTO return (0); 1136b8b31f33SHajimu UMEMOTO #endif 1137b8b31f33SHajimu UMEMOTO } 1138b8b31f33SHajimu UMEMOTO 1139b8b31f33SHajimu UMEMOTO static void 114090d1d883SHajimu UMEMOTO free_addrselectpolicy(struct policyhead *head) 1141b8b31f33SHajimu UMEMOTO { 1142b8b31f33SHajimu UMEMOTO struct policyqueue *ent, *nent; 1143b8b31f33SHajimu UMEMOTO 1144b8b31f33SHajimu UMEMOTO for (ent = TAILQ_FIRST(head); ent; ent = nent) { 1145b8b31f33SHajimu UMEMOTO nent = TAILQ_NEXT(ent, pc_entry); 1146b8b31f33SHajimu UMEMOTO TAILQ_REMOVE(head, ent, pc_entry); 1147b8b31f33SHajimu UMEMOTO free(ent); 1148b8b31f33SHajimu UMEMOTO } 1149b8b31f33SHajimu UMEMOTO } 1150b8b31f33SHajimu UMEMOTO 1151b8b31f33SHajimu UMEMOTO static struct policyqueue * 115290d1d883SHajimu UMEMOTO match_addrselectpolicy(struct sockaddr *addr, struct policyhead *head) 1153b8b31f33SHajimu UMEMOTO { 1154b8b31f33SHajimu UMEMOTO #ifdef INET6 1155b8b31f33SHajimu UMEMOTO struct policyqueue *ent, *bestent = NULL; 1156b8b31f33SHajimu UMEMOTO struct in6_addrpolicy *pol; 1157b8b31f33SHajimu UMEMOTO int matchlen, bestmatchlen = -1; 1158b8b31f33SHajimu UMEMOTO u_char *mp, *ep, *k, *p, m; 1159b8b31f33SHajimu UMEMOTO struct sockaddr_in6 key; 1160b8b31f33SHajimu UMEMOTO 1161b8b31f33SHajimu UMEMOTO switch(addr->sa_family) { 1162b8b31f33SHajimu UMEMOTO case AF_INET6: 1163b8b31f33SHajimu UMEMOTO key = *(struct sockaddr_in6 *)addr; 1164b8b31f33SHajimu UMEMOTO break; 1165b8b31f33SHajimu UMEMOTO case AF_INET: 1166b8b31f33SHajimu UMEMOTO /* convert the address into IPv4-mapped IPv6 address. */ 1167b8b31f33SHajimu UMEMOTO memset(&key, 0, sizeof(key)); 1168b8b31f33SHajimu UMEMOTO key.sin6_family = AF_INET6; 1169b8b31f33SHajimu UMEMOTO key.sin6_len = sizeof(key); 1170b8b31f33SHajimu UMEMOTO key.sin6_addr.s6_addr[10] = 0xff; 1171b8b31f33SHajimu UMEMOTO key.sin6_addr.s6_addr[11] = 0xff; 1172b8b31f33SHajimu UMEMOTO memcpy(&key.sin6_addr.s6_addr[12], 1173b8b31f33SHajimu UMEMOTO &((struct sockaddr_in *)addr)->sin_addr, 4); 1174b8b31f33SHajimu UMEMOTO break; 1175b8b31f33SHajimu UMEMOTO default: 1176b8b31f33SHajimu UMEMOTO return(NULL); 1177b8b31f33SHajimu UMEMOTO } 1178b8b31f33SHajimu UMEMOTO 1179b8b31f33SHajimu UMEMOTO for (ent = TAILQ_FIRST(head); ent; ent = TAILQ_NEXT(ent, pc_entry)) { 1180b8b31f33SHajimu UMEMOTO pol = &ent->pc_policy; 1181b8b31f33SHajimu UMEMOTO matchlen = 0; 1182b8b31f33SHajimu UMEMOTO 1183b8b31f33SHajimu UMEMOTO mp = (u_char *)&pol->addrmask.sin6_addr; 1184b8b31f33SHajimu UMEMOTO ep = mp + 16; /* XXX: scope field? */ 1185b8b31f33SHajimu UMEMOTO k = (u_char *)&key.sin6_addr; 1186b8b31f33SHajimu UMEMOTO p = (u_char *)&pol->addr.sin6_addr; 1187b8b31f33SHajimu UMEMOTO for (; mp < ep && *mp; mp++, k++, p++) { 1188b8b31f33SHajimu UMEMOTO m = *mp; 1189b8b31f33SHajimu UMEMOTO if ((*k & m) != *p) 1190b8b31f33SHajimu UMEMOTO goto next; /* not match */ 1191b8b31f33SHajimu UMEMOTO if (m == 0xff) /* short cut for a typical case */ 1192b8b31f33SHajimu UMEMOTO matchlen += 8; 1193b8b31f33SHajimu UMEMOTO else { 1194b8b31f33SHajimu UMEMOTO while (m >= 0x80) { 1195b8b31f33SHajimu UMEMOTO matchlen++; 1196b8b31f33SHajimu UMEMOTO m <<= 1; 1197b8b31f33SHajimu UMEMOTO } 1198b8b31f33SHajimu UMEMOTO } 1199b8b31f33SHajimu UMEMOTO } 1200b8b31f33SHajimu UMEMOTO 1201b8b31f33SHajimu UMEMOTO /* matched. check if this is better than the current best. */ 1202b8b31f33SHajimu UMEMOTO if (matchlen > bestmatchlen) { 1203b8b31f33SHajimu UMEMOTO bestent = ent; 1204b8b31f33SHajimu UMEMOTO bestmatchlen = matchlen; 1205b8b31f33SHajimu UMEMOTO } 1206b8b31f33SHajimu UMEMOTO 1207b8b31f33SHajimu UMEMOTO next: 1208b8b31f33SHajimu UMEMOTO continue; 1209b8b31f33SHajimu UMEMOTO } 1210b8b31f33SHajimu UMEMOTO 1211b8b31f33SHajimu UMEMOTO return(bestent); 1212b8b31f33SHajimu UMEMOTO #else 1213b8b31f33SHajimu UMEMOTO return(NULL); 1214b8b31f33SHajimu UMEMOTO #endif 1215b8b31f33SHajimu UMEMOTO 1216b8b31f33SHajimu UMEMOTO } 1217b8b31f33SHajimu UMEMOTO 1218146cd1bcSHajimu UMEMOTO static void 121990d1d883SHajimu UMEMOTO set_source(struct hp_order *aio, struct policyhead *ph) 1220146cd1bcSHajimu UMEMOTO { 1221146cd1bcSHajimu UMEMOTO struct sockaddr_storage ss = aio->aio_un.aiou_ss; 1222943db5a2SHajimu UMEMOTO socklen_t srclen; 1223943db5a2SHajimu UMEMOTO int s; 1224146cd1bcSHajimu UMEMOTO 1225146cd1bcSHajimu UMEMOTO /* set unspec ("no source is available"), just in case */ 1226146cd1bcSHajimu UMEMOTO aio->aio_srcsa.sa_family = AF_UNSPEC; 1227146cd1bcSHajimu UMEMOTO aio->aio_srcscope = -1; 1228146cd1bcSHajimu UMEMOTO 1229146cd1bcSHajimu UMEMOTO switch(ss.ss_family) { 1230146cd1bcSHajimu UMEMOTO case AF_INET: 1231146cd1bcSHajimu UMEMOTO ((struct sockaddr_in *)&ss)->sin_port = htons(1); 1232146cd1bcSHajimu UMEMOTO break; 1233146cd1bcSHajimu UMEMOTO #ifdef INET6 1234146cd1bcSHajimu UMEMOTO case AF_INET6: 1235146cd1bcSHajimu UMEMOTO ((struct sockaddr_in6 *)&ss)->sin6_port = htons(1); 1236146cd1bcSHajimu UMEMOTO break; 1237146cd1bcSHajimu UMEMOTO #endif 1238146cd1bcSHajimu UMEMOTO default: /* ignore unsupported AFs explicitly */ 1239146cd1bcSHajimu UMEMOTO return; 1240146cd1bcSHajimu UMEMOTO } 1241146cd1bcSHajimu UMEMOTO 1242146cd1bcSHajimu UMEMOTO /* open a socket to get the source address for the given dst */ 1243146cd1bcSHajimu UMEMOTO if ((s = _socket(ss.ss_family, SOCK_DGRAM, IPPROTO_UDP)) < 0) 1244146cd1bcSHajimu UMEMOTO return; /* give up */ 1245146cd1bcSHajimu UMEMOTO if (_connect(s, (struct sockaddr *)&ss, ss.ss_len) < 0) 1246146cd1bcSHajimu UMEMOTO goto cleanup; 1247146cd1bcSHajimu UMEMOTO srclen = ss.ss_len; 1248146cd1bcSHajimu UMEMOTO if (_getsockname(s, &aio->aio_srcsa, &srclen) < 0) { 1249146cd1bcSHajimu UMEMOTO aio->aio_srcsa.sa_family = AF_UNSPEC; 1250146cd1bcSHajimu UMEMOTO goto cleanup; 1251146cd1bcSHajimu UMEMOTO } 1252146cd1bcSHajimu UMEMOTO aio->aio_srcscope = gai_addr2scopetype(&aio->aio_srcsa); 1253146cd1bcSHajimu UMEMOTO aio->aio_srcpolicy = match_addrselectpolicy(&aio->aio_srcsa, ph); 1254146cd1bcSHajimu UMEMOTO aio->aio_matchlen = matchlen(&aio->aio_srcsa, (struct sockaddr *)&ss); 1255146cd1bcSHajimu UMEMOTO #ifdef INET6 1256146cd1bcSHajimu UMEMOTO if (ss.ss_family == AF_INET6) { 1257146cd1bcSHajimu UMEMOTO struct in6_ifreq ifr6; 1258146cd1bcSHajimu UMEMOTO u_int32_t flags6; 1259146cd1bcSHajimu UMEMOTO 1260146cd1bcSHajimu UMEMOTO /* XXX: interface name should not be hardcoded */ 1261146cd1bcSHajimu UMEMOTO strncpy(ifr6.ifr_name, "lo0", sizeof(ifr6.ifr_name)); 1262146cd1bcSHajimu UMEMOTO memset(&ifr6, 0, sizeof(ifr6)); 1263146cd1bcSHajimu UMEMOTO memcpy(&ifr6.ifr_addr, &ss, ss.ss_len); 1264146cd1bcSHajimu UMEMOTO if (_ioctl(s, SIOCGIFAFLAG_IN6, &ifr6) == 0) { 1265146cd1bcSHajimu UMEMOTO flags6 = ifr6.ifr_ifru.ifru_flags6; 1266146cd1bcSHajimu UMEMOTO if ((flags6 & IN6_IFF_DEPRECATED)) 1267146cd1bcSHajimu UMEMOTO aio->aio_srcflag |= AIO_SRCFLAG_DEPRECATED; 1268146cd1bcSHajimu UMEMOTO } 1269146cd1bcSHajimu UMEMOTO } 1270146cd1bcSHajimu UMEMOTO #endif 1271146cd1bcSHajimu UMEMOTO 1272146cd1bcSHajimu UMEMOTO cleanup: 1273146cd1bcSHajimu UMEMOTO _close(s); 1274146cd1bcSHajimu UMEMOTO return; 1275146cd1bcSHajimu UMEMOTO } 1276146cd1bcSHajimu UMEMOTO 1277146cd1bcSHajimu UMEMOTO static int 127890d1d883SHajimu UMEMOTO matchlen(struct sockaddr *src, struct sockaddr *dst) 1279146cd1bcSHajimu UMEMOTO { 1280146cd1bcSHajimu UMEMOTO int match = 0; 1281146cd1bcSHajimu UMEMOTO u_char *s, *d; 1282146cd1bcSHajimu UMEMOTO u_char *lim, r; 1283146cd1bcSHajimu UMEMOTO int addrlen; 1284146cd1bcSHajimu UMEMOTO 1285146cd1bcSHajimu UMEMOTO switch (src->sa_family) { 1286146cd1bcSHajimu UMEMOTO #ifdef INET6 1287146cd1bcSHajimu UMEMOTO case AF_INET6: 1288146cd1bcSHajimu UMEMOTO s = (u_char *)&((struct sockaddr_in6 *)src)->sin6_addr; 1289146cd1bcSHajimu UMEMOTO d = (u_char *)&((struct sockaddr_in6 *)dst)->sin6_addr; 1290146cd1bcSHajimu UMEMOTO addrlen = sizeof(struct in6_addr); 1291146cd1bcSHajimu UMEMOTO lim = s + addrlen; 1292146cd1bcSHajimu UMEMOTO break; 1293146cd1bcSHajimu UMEMOTO #endif 1294146cd1bcSHajimu UMEMOTO case AF_INET: 1295fd57e549SGeorge V. Neville-Neil s = (u_char *)&((struct sockaddr_in *)src)->sin_addr; 1296fd57e549SGeorge V. Neville-Neil d = (u_char *)&((struct sockaddr_in *)dst)->sin_addr; 1297146cd1bcSHajimu UMEMOTO addrlen = sizeof(struct in_addr); 1298146cd1bcSHajimu UMEMOTO lim = s + addrlen; 1299146cd1bcSHajimu UMEMOTO break; 1300146cd1bcSHajimu UMEMOTO default: 1301146cd1bcSHajimu UMEMOTO return(0); 1302146cd1bcSHajimu UMEMOTO } 1303146cd1bcSHajimu UMEMOTO 1304146cd1bcSHajimu UMEMOTO while (s < lim) 1305146cd1bcSHajimu UMEMOTO if ((r = (*d++ ^ *s++)) != 0) { 1306146cd1bcSHajimu UMEMOTO while (r < addrlen * 8) { 1307146cd1bcSHajimu UMEMOTO match++; 1308146cd1bcSHajimu UMEMOTO r <<= 1; 1309146cd1bcSHajimu UMEMOTO } 1310146cd1bcSHajimu UMEMOTO break; 1311146cd1bcSHajimu UMEMOTO } else 1312146cd1bcSHajimu UMEMOTO match += 8; 1313146cd1bcSHajimu UMEMOTO return(match); 1314146cd1bcSHajimu UMEMOTO } 1315146cd1bcSHajimu UMEMOTO 1316146cd1bcSHajimu UMEMOTO static int 131790d1d883SHajimu UMEMOTO comp_dst(const void *arg1, const void *arg2) 1318146cd1bcSHajimu UMEMOTO { 1319146cd1bcSHajimu UMEMOTO const struct hp_order *dst1 = arg1, *dst2 = arg2; 1320146cd1bcSHajimu UMEMOTO 1321146cd1bcSHajimu UMEMOTO /* 1322146cd1bcSHajimu UMEMOTO * Rule 1: Avoid unusable destinations. 1323146cd1bcSHajimu UMEMOTO * XXX: we currently do not consider if an appropriate route exists. 1324146cd1bcSHajimu UMEMOTO */ 1325146cd1bcSHajimu UMEMOTO if (dst1->aio_srcsa.sa_family != AF_UNSPEC && 1326146cd1bcSHajimu UMEMOTO dst2->aio_srcsa.sa_family == AF_UNSPEC) { 1327146cd1bcSHajimu UMEMOTO return(-1); 1328146cd1bcSHajimu UMEMOTO } 1329146cd1bcSHajimu UMEMOTO if (dst1->aio_srcsa.sa_family == AF_UNSPEC && 1330146cd1bcSHajimu UMEMOTO dst2->aio_srcsa.sa_family != AF_UNSPEC) { 1331146cd1bcSHajimu UMEMOTO return(1); 1332146cd1bcSHajimu UMEMOTO } 1333146cd1bcSHajimu UMEMOTO 1334146cd1bcSHajimu UMEMOTO /* Rule 2: Prefer matching scope. */ 1335146cd1bcSHajimu UMEMOTO if (dst1->aio_dstscope == dst1->aio_srcscope && 1336146cd1bcSHajimu UMEMOTO dst2->aio_dstscope != dst2->aio_srcscope) { 1337146cd1bcSHajimu UMEMOTO return(-1); 1338146cd1bcSHajimu UMEMOTO } 1339146cd1bcSHajimu UMEMOTO if (dst1->aio_dstscope != dst1->aio_srcscope && 1340146cd1bcSHajimu UMEMOTO dst2->aio_dstscope == dst2->aio_srcscope) { 1341146cd1bcSHajimu UMEMOTO return(1); 1342146cd1bcSHajimu UMEMOTO } 1343146cd1bcSHajimu UMEMOTO 1344146cd1bcSHajimu UMEMOTO /* Rule 3: Avoid deprecated addresses. */ 1345146cd1bcSHajimu UMEMOTO if (dst1->aio_srcsa.sa_family != AF_UNSPEC && 1346146cd1bcSHajimu UMEMOTO dst2->aio_srcsa.sa_family != AF_UNSPEC) { 1347146cd1bcSHajimu UMEMOTO if (!(dst1->aio_srcflag & AIO_SRCFLAG_DEPRECATED) && 1348146cd1bcSHajimu UMEMOTO (dst2->aio_srcflag & AIO_SRCFLAG_DEPRECATED)) { 1349146cd1bcSHajimu UMEMOTO return(-1); 1350146cd1bcSHajimu UMEMOTO } 1351146cd1bcSHajimu UMEMOTO if ((dst1->aio_srcflag & AIO_SRCFLAG_DEPRECATED) && 1352146cd1bcSHajimu UMEMOTO !(dst2->aio_srcflag & AIO_SRCFLAG_DEPRECATED)) { 1353146cd1bcSHajimu UMEMOTO return(1); 1354146cd1bcSHajimu UMEMOTO } 1355146cd1bcSHajimu UMEMOTO } 1356146cd1bcSHajimu UMEMOTO 1357146cd1bcSHajimu UMEMOTO /* Rule 4: Prefer home addresses. */ 1358146cd1bcSHajimu UMEMOTO /* XXX: not implemented yet */ 1359146cd1bcSHajimu UMEMOTO 1360146cd1bcSHajimu UMEMOTO /* Rule 5: Prefer matching label. */ 1361146cd1bcSHajimu UMEMOTO #ifdef INET6 1362146cd1bcSHajimu UMEMOTO if (dst1->aio_srcpolicy && dst1->aio_dstpolicy && 1363146cd1bcSHajimu UMEMOTO dst1->aio_srcpolicy->pc_policy.label == 1364146cd1bcSHajimu UMEMOTO dst1->aio_dstpolicy->pc_policy.label && 1365146cd1bcSHajimu UMEMOTO (dst2->aio_srcpolicy == NULL || dst2->aio_dstpolicy == NULL || 1366146cd1bcSHajimu UMEMOTO dst2->aio_srcpolicy->pc_policy.label != 1367146cd1bcSHajimu UMEMOTO dst2->aio_dstpolicy->pc_policy.label)) { 1368146cd1bcSHajimu UMEMOTO return(-1); 1369146cd1bcSHajimu UMEMOTO } 1370146cd1bcSHajimu UMEMOTO if (dst2->aio_srcpolicy && dst2->aio_dstpolicy && 1371146cd1bcSHajimu UMEMOTO dst2->aio_srcpolicy->pc_policy.label == 1372146cd1bcSHajimu UMEMOTO dst2->aio_dstpolicy->pc_policy.label && 1373146cd1bcSHajimu UMEMOTO (dst1->aio_srcpolicy == NULL || dst1->aio_dstpolicy == NULL || 1374146cd1bcSHajimu UMEMOTO dst1->aio_srcpolicy->pc_policy.label != 1375146cd1bcSHajimu UMEMOTO dst1->aio_dstpolicy->pc_policy.label)) { 1376146cd1bcSHajimu UMEMOTO return(1); 1377146cd1bcSHajimu UMEMOTO } 1378146cd1bcSHajimu UMEMOTO #endif 1379146cd1bcSHajimu UMEMOTO 1380146cd1bcSHajimu UMEMOTO /* Rule 6: Prefer higher precedence. */ 1381146cd1bcSHajimu UMEMOTO #ifdef INET6 1382146cd1bcSHajimu UMEMOTO if (dst1->aio_dstpolicy && 1383146cd1bcSHajimu UMEMOTO (dst2->aio_dstpolicy == NULL || 1384146cd1bcSHajimu UMEMOTO dst1->aio_dstpolicy->pc_policy.preced > 1385146cd1bcSHajimu UMEMOTO dst2->aio_dstpolicy->pc_policy.preced)) { 1386146cd1bcSHajimu UMEMOTO return(-1); 1387146cd1bcSHajimu UMEMOTO } 1388146cd1bcSHajimu UMEMOTO if (dst2->aio_dstpolicy && 1389146cd1bcSHajimu UMEMOTO (dst1->aio_dstpolicy == NULL || 1390146cd1bcSHajimu UMEMOTO dst2->aio_dstpolicy->pc_policy.preced > 1391146cd1bcSHajimu UMEMOTO dst1->aio_dstpolicy->pc_policy.preced)) { 1392146cd1bcSHajimu UMEMOTO return(1); 1393146cd1bcSHajimu UMEMOTO } 1394146cd1bcSHajimu UMEMOTO #endif 1395146cd1bcSHajimu UMEMOTO 1396146cd1bcSHajimu UMEMOTO /* Rule 7: Prefer native transport. */ 1397146cd1bcSHajimu UMEMOTO /* XXX: not implemented yet */ 1398146cd1bcSHajimu UMEMOTO 1399146cd1bcSHajimu UMEMOTO /* Rule 8: Prefer smaller scope. */ 1400146cd1bcSHajimu UMEMOTO if (dst1->aio_dstscope >= 0 && 1401146cd1bcSHajimu UMEMOTO dst1->aio_dstscope < dst2->aio_dstscope) { 1402146cd1bcSHajimu UMEMOTO return(-1); 1403146cd1bcSHajimu UMEMOTO } 1404146cd1bcSHajimu UMEMOTO if (dst2->aio_dstscope >= 0 && 1405146cd1bcSHajimu UMEMOTO dst2->aio_dstscope < dst1->aio_dstscope) { 1406146cd1bcSHajimu UMEMOTO return(1); 1407146cd1bcSHajimu UMEMOTO } 1408146cd1bcSHajimu UMEMOTO 1409146cd1bcSHajimu UMEMOTO /* 1410146cd1bcSHajimu UMEMOTO * Rule 9: Use longest matching prefix. 1411146cd1bcSHajimu UMEMOTO * We compare the match length in a same AF only. 1412146cd1bcSHajimu UMEMOTO */ 1413146cd1bcSHajimu UMEMOTO if (dst1->aio_sa.sa_family == dst2->aio_sa.sa_family) { 1414146cd1bcSHajimu UMEMOTO if (dst1->aio_matchlen > dst2->aio_matchlen) { 1415146cd1bcSHajimu UMEMOTO return(-1); 1416146cd1bcSHajimu UMEMOTO } 1417146cd1bcSHajimu UMEMOTO if (dst1->aio_matchlen < dst2->aio_matchlen) { 1418146cd1bcSHajimu UMEMOTO return(1); 1419146cd1bcSHajimu UMEMOTO } 1420146cd1bcSHajimu UMEMOTO } 1421146cd1bcSHajimu UMEMOTO 1422146cd1bcSHajimu UMEMOTO /* Rule 10: Otherwise, leave the order unchanged. */ 1423146cd1bcSHajimu UMEMOTO return(-1); 1424146cd1bcSHajimu UMEMOTO } 1425146cd1bcSHajimu UMEMOTO 1426146cd1bcSHajimu UMEMOTO /* 1427146cd1bcSHajimu UMEMOTO * Copy from scope.c. 1428146cd1bcSHajimu UMEMOTO * XXX: we should standardize the functions and link them as standard 1429146cd1bcSHajimu UMEMOTO * library. 1430146cd1bcSHajimu UMEMOTO */ 1431146cd1bcSHajimu UMEMOTO static int 143290d1d883SHajimu UMEMOTO gai_addr2scopetype(struct sockaddr *sa) 1433146cd1bcSHajimu UMEMOTO { 1434146cd1bcSHajimu UMEMOTO #ifdef INET6 1435146cd1bcSHajimu UMEMOTO struct sockaddr_in6 *sa6; 1436146cd1bcSHajimu UMEMOTO #endif 1437146cd1bcSHajimu UMEMOTO struct sockaddr_in *sa4; 1438146cd1bcSHajimu UMEMOTO 1439146cd1bcSHajimu UMEMOTO switch(sa->sa_family) { 1440146cd1bcSHajimu UMEMOTO #ifdef INET6 1441146cd1bcSHajimu UMEMOTO case AF_INET6: 1442146cd1bcSHajimu UMEMOTO sa6 = (struct sockaddr_in6 *)sa; 1443146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) { 1444146cd1bcSHajimu UMEMOTO /* just use the scope field of the multicast address */ 1445146cd1bcSHajimu UMEMOTO return(sa6->sin6_addr.s6_addr[2] & 0x0f); 1446146cd1bcSHajimu UMEMOTO } 1447146cd1bcSHajimu UMEMOTO /* 1448146cd1bcSHajimu UMEMOTO * Unicast addresses: map scope type to corresponding scope 1449146cd1bcSHajimu UMEMOTO * value defined for multcast addresses. 1450146cd1bcSHajimu UMEMOTO * XXX: hardcoded scope type values are bad... 1451146cd1bcSHajimu UMEMOTO */ 1452146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_LOOPBACK(&sa6->sin6_addr)) 1453146cd1bcSHajimu UMEMOTO return(1); /* node local scope */ 1454146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr)) 1455146cd1bcSHajimu UMEMOTO return(2); /* link-local scope */ 1456146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_SITELOCAL(&sa6->sin6_addr)) 1457146cd1bcSHajimu UMEMOTO return(5); /* site-local scope */ 1458146cd1bcSHajimu UMEMOTO return(14); /* global scope */ 1459146cd1bcSHajimu UMEMOTO break; 1460146cd1bcSHajimu UMEMOTO #endif 1461146cd1bcSHajimu UMEMOTO case AF_INET: 1462146cd1bcSHajimu UMEMOTO /* 1463146cd1bcSHajimu UMEMOTO * IPv4 pseudo scoping according to RFC 3484. 1464146cd1bcSHajimu UMEMOTO */ 1465146cd1bcSHajimu UMEMOTO sa4 = (struct sockaddr_in *)sa; 1466146cd1bcSHajimu UMEMOTO /* IPv4 autoconfiguration addresses have link-local scope. */ 1467146cd1bcSHajimu UMEMOTO if (((u_char *)&sa4->sin_addr)[0] == 169 && 1468146cd1bcSHajimu UMEMOTO ((u_char *)&sa4->sin_addr)[1] == 254) 1469146cd1bcSHajimu UMEMOTO return(2); 1470146cd1bcSHajimu UMEMOTO /* Private addresses have site-local scope. */ 1471146cd1bcSHajimu UMEMOTO if (((u_char *)&sa4->sin_addr)[0] == 10 || 1472146cd1bcSHajimu UMEMOTO (((u_char *)&sa4->sin_addr)[0] == 172 && 1473146cd1bcSHajimu UMEMOTO (((u_char *)&sa4->sin_addr)[1] & 0xf0) == 16) || 1474146cd1bcSHajimu UMEMOTO (((u_char *)&sa4->sin_addr)[0] == 192 && 1475146cd1bcSHajimu UMEMOTO ((u_char *)&sa4->sin_addr)[1] == 168)) 1476146cd1bcSHajimu UMEMOTO return(14); /* XXX: It should be 5 unless NAT */ 1477146cd1bcSHajimu UMEMOTO /* Loopback addresses have link-local scope. */ 1478146cd1bcSHajimu UMEMOTO if (((u_char *)&sa4->sin_addr)[0] == 127) 1479146cd1bcSHajimu UMEMOTO return(2); 1480146cd1bcSHajimu UMEMOTO return(14); 1481146cd1bcSHajimu UMEMOTO break; 1482146cd1bcSHajimu UMEMOTO default: 1483146cd1bcSHajimu UMEMOTO errno = EAFNOSUPPORT; /* is this a good error? */ 1484146cd1bcSHajimu UMEMOTO return(-1); 1485146cd1bcSHajimu UMEMOTO } 1486146cd1bcSHajimu UMEMOTO } 1487146cd1bcSHajimu UMEMOTO 1488b8b31f33SHajimu UMEMOTO /* 14897d56d374SYoshinobu Inoue * FILES (/etc/hosts) 14907d56d374SYoshinobu Inoue */ 14917d56d374SYoshinobu Inoue 14927d56d374SYoshinobu Inoue static FILE * 14937d56d374SYoshinobu Inoue _files_open(int *errp) 14947d56d374SYoshinobu Inoue { 14957d56d374SYoshinobu Inoue FILE *fp; 14967d56d374SYoshinobu Inoue fp = fopen(_PATH_HOSTS, "r"); 14977d56d374SYoshinobu Inoue if (fp == NULL) 14987d56d374SYoshinobu Inoue *errp = NO_RECOVERY; 14997d56d374SYoshinobu Inoue return fp; 15007d56d374SYoshinobu Inoue } 15017d56d374SYoshinobu Inoue 1502248aee62SJacques Vidrine static int 1503248aee62SJacques Vidrine _files_ghbyname(void *rval, void *cb_data, va_list ap) 15047d56d374SYoshinobu Inoue { 1505248aee62SJacques Vidrine const char *name; 1506248aee62SJacques Vidrine int af; 1507248aee62SJacques Vidrine int *errp; 15087d56d374SYoshinobu Inoue int match, nalias; 15097d56d374SYoshinobu Inoue char *p, *line, *addrstr, *cname; 15107d56d374SYoshinobu Inoue FILE *fp; 15117d56d374SYoshinobu Inoue struct hostent *rethp, *hp, hpbuf; 15127d56d374SYoshinobu Inoue char *aliases[MAXALIASES + 1], *addrs[2]; 15137d56d374SYoshinobu Inoue union inx_addr addrbuf; 15147d56d374SYoshinobu Inoue char buf[BUFSIZ]; 15157d56d374SYoshinobu Inoue 1516248aee62SJacques Vidrine name = va_arg(ap, const char *); 1517248aee62SJacques Vidrine af = va_arg(ap, int); 1518248aee62SJacques Vidrine errp = va_arg(ap, int *); 1519248aee62SJacques Vidrine 1520248aee62SJacques Vidrine *(struct hostent **)rval = NULL; 1521248aee62SJacques Vidrine 15227d56d374SYoshinobu Inoue if ((fp = _files_open(errp)) == NULL) 1523248aee62SJacques Vidrine return NS_UNAVAIL; 15247d56d374SYoshinobu Inoue rethp = hp = NULL; 15257d56d374SYoshinobu Inoue 15267d56d374SYoshinobu Inoue while (fgets(buf, sizeof(buf), fp)) { 15277d56d374SYoshinobu Inoue line = buf; 15287d56d374SYoshinobu Inoue if ((addrstr = _hgetword(&line)) == NULL 15297d56d374SYoshinobu Inoue || (cname = _hgetword(&line)) == NULL) 15307d56d374SYoshinobu Inoue continue; 15317d56d374SYoshinobu Inoue match = (strcasecmp(cname, name) == 0); 15327d56d374SYoshinobu Inoue nalias = 0; 15337d56d374SYoshinobu Inoue while ((p = _hgetword(&line)) != NULL) { 15347d56d374SYoshinobu Inoue if (!match) 15357d56d374SYoshinobu Inoue match = (strcasecmp(p, name) == 0); 15367d56d374SYoshinobu Inoue if (nalias < MAXALIASES) 15377d56d374SYoshinobu Inoue aliases[nalias++] = p; 15387d56d374SYoshinobu Inoue } 15397d56d374SYoshinobu Inoue if (!match) 15407d56d374SYoshinobu Inoue continue; 15410fbf0979SHajimu UMEMOTO switch (af) { 1542e6f35403SYoshinobu Inoue case AF_INET: 1543e6f35403SYoshinobu Inoue if (inet_aton(addrstr, (struct in_addr *)&addrbuf) 1544e6f35403SYoshinobu Inoue != 1) { 15457d56d374SYoshinobu Inoue *errp = NO_DATA; /* name found */ 15467d56d374SYoshinobu Inoue continue; 15477d56d374SYoshinobu Inoue } 1548e6f35403SYoshinobu Inoue break; 1549e6f35403SYoshinobu Inoue #ifdef INET6 1550e6f35403SYoshinobu Inoue case AF_INET6: 1551e6f35403SYoshinobu Inoue if (inet_pton(af, addrstr, &addrbuf) != 1) { 1552e6f35403SYoshinobu Inoue *errp = NO_DATA; /* name found */ 1553e6f35403SYoshinobu Inoue continue; 1554e6f35403SYoshinobu Inoue } 1555e6f35403SYoshinobu Inoue break; 1556e6f35403SYoshinobu Inoue #endif 1557e6f35403SYoshinobu Inoue } 15587d56d374SYoshinobu Inoue hp = &hpbuf; 15597d56d374SYoshinobu Inoue hp->h_name = cname; 15607d56d374SYoshinobu Inoue hp->h_aliases = aliases; 15617d56d374SYoshinobu Inoue aliases[nalias] = NULL; 15627d56d374SYoshinobu Inoue hp->h_addrtype = af; 15637d56d374SYoshinobu Inoue hp->h_length = ADDRLEN(af); 15647d56d374SYoshinobu Inoue hp->h_addr_list = addrs; 15657d56d374SYoshinobu Inoue addrs[0] = (char *)&addrbuf; 15667d56d374SYoshinobu Inoue addrs[1] = NULL; 15677d56d374SYoshinobu Inoue hp = _hpcopy(hp, errp); 15687d56d374SYoshinobu Inoue rethp = _hpmerge(rethp, hp, errp); 15697d56d374SYoshinobu Inoue } 15707d56d374SYoshinobu Inoue fclose(fp); 1571248aee62SJacques Vidrine *(struct hostent **)rval = rethp; 1572248aee62SJacques Vidrine return (rethp != NULL) ? NS_SUCCESS : NS_NOTFOUND; 15737d56d374SYoshinobu Inoue } 15747d56d374SYoshinobu Inoue 1575248aee62SJacques Vidrine static int 1576248aee62SJacques Vidrine _files_ghbyaddr(void *rval, void *cb_data, va_list ap) 15777d56d374SYoshinobu Inoue { 1578248aee62SJacques Vidrine const void *addr; 1579248aee62SJacques Vidrine int addrlen; 1580248aee62SJacques Vidrine int af; 1581248aee62SJacques Vidrine int *errp; 15827d56d374SYoshinobu Inoue int nalias; 15837d56d374SYoshinobu Inoue char *p, *line; 15847d56d374SYoshinobu Inoue FILE *fp; 15857d56d374SYoshinobu Inoue struct hostent *hp, hpbuf; 15867d56d374SYoshinobu Inoue char *aliases[MAXALIASES + 1], *addrs[2]; 15877d56d374SYoshinobu Inoue union inx_addr addrbuf; 15887d56d374SYoshinobu Inoue char buf[BUFSIZ]; 15897d56d374SYoshinobu Inoue 1590248aee62SJacques Vidrine addr = va_arg(ap, const void *); 1591248aee62SJacques Vidrine addrlen = va_arg(ap, int); 1592248aee62SJacques Vidrine af = va_arg(ap, int); 1593248aee62SJacques Vidrine errp = va_arg(ap, int *); 1594248aee62SJacques Vidrine 1595248aee62SJacques Vidrine *(struct hostent**)rval = NULL; 1596248aee62SJacques Vidrine 15977d56d374SYoshinobu Inoue if ((fp = _files_open(errp)) == NULL) 1598248aee62SJacques Vidrine return NS_UNAVAIL; 15997d56d374SYoshinobu Inoue hp = NULL; 16007d56d374SYoshinobu Inoue while (fgets(buf, sizeof(buf), fp)) { 16017d56d374SYoshinobu Inoue line = buf; 16027d56d374SYoshinobu Inoue if ((p = _hgetword(&line)) == NULL 1603be26adb5SYoshinobu Inoue || (af == AF_INET 1604be26adb5SYoshinobu Inoue ? inet_aton(p, (struct in_addr *)&addrbuf) 1605be26adb5SYoshinobu Inoue : inet_pton(af, p, &addrbuf)) != 1 16067d56d374SYoshinobu Inoue || memcmp(addr, &addrbuf, addrlen) != 0 16077d56d374SYoshinobu Inoue || (p = _hgetword(&line)) == NULL) 16087d56d374SYoshinobu Inoue continue; 16097d56d374SYoshinobu Inoue hp = &hpbuf; 16107d56d374SYoshinobu Inoue hp->h_name = p; 16117d56d374SYoshinobu Inoue hp->h_aliases = aliases; 16127d56d374SYoshinobu Inoue nalias = 0; 16137d56d374SYoshinobu Inoue while ((p = _hgetword(&line)) != NULL) { 16147d56d374SYoshinobu Inoue if (nalias < MAXALIASES) 16157d56d374SYoshinobu Inoue aliases[nalias++] = p; 16167d56d374SYoshinobu Inoue } 16177d56d374SYoshinobu Inoue aliases[nalias] = NULL; 16187d56d374SYoshinobu Inoue hp->h_addrtype = af; 16197d56d374SYoshinobu Inoue hp->h_length = addrlen; 16207d56d374SYoshinobu Inoue hp->h_addr_list = addrs; 16217d56d374SYoshinobu Inoue addrs[0] = (char *)&addrbuf; 16227d56d374SYoshinobu Inoue addrs[1] = NULL; 16237d56d374SYoshinobu Inoue hp = _hpcopy(hp, errp); 16247d56d374SYoshinobu Inoue break; 16257d56d374SYoshinobu Inoue } 16267d56d374SYoshinobu Inoue fclose(fp); 1627248aee62SJacques Vidrine *(struct hostent **)rval = hp; 1628248aee62SJacques Vidrine return (hp != NULL) ? NS_SUCCESS : NS_NOTFOUND; 16297d56d374SYoshinobu Inoue } 16307d56d374SYoshinobu Inoue 1631f468e837SHajimu UMEMOTO #ifdef YP 163263858012SJonathan Lemon /* 163363858012SJonathan Lemon * NIS 163463858012SJonathan Lemon * 16356bd1d1a1SHajimu UMEMOTO * XXX actually a hack. 163663858012SJonathan Lemon */ 1637248aee62SJacques Vidrine static int 1638248aee62SJacques Vidrine _nis_ghbyname(void *rval, void *cb_data, va_list ap) 163963858012SJonathan Lemon { 1640248aee62SJacques Vidrine const char *name; 1641248aee62SJacques Vidrine int af; 1642248aee62SJacques Vidrine int *errp; 164338775c5eSJonathan Lemon struct hostent *hp = NULL; 164463858012SJonathan Lemon 1645248aee62SJacques Vidrine name = va_arg(ap, const char *); 1646248aee62SJacques Vidrine af = va_arg(ap, int); 1647248aee62SJacques Vidrine errp = va_arg(ap, int *); 1648248aee62SJacques Vidrine 164963858012SJonathan Lemon hp = _gethostbynisname(name, af); 165063858012SJonathan Lemon if (hp != NULL) 165163858012SJonathan Lemon hp = _hpcopy(hp, errp); 1652248aee62SJacques Vidrine 1653248aee62SJacques Vidrine *(struct hostent **)rval = hp; 1654248aee62SJacques Vidrine return (hp != NULL) ? NS_SUCCESS : NS_NOTFOUND; 165563858012SJonathan Lemon } 165663858012SJonathan Lemon 1657248aee62SJacques Vidrine static int 1658248aee62SJacques Vidrine _nis_ghbyaddr(void *rval, void *cb_data, va_list ap) 165963858012SJonathan Lemon { 1660248aee62SJacques Vidrine const void *addr; 1661248aee62SJacques Vidrine int addrlen; 1662248aee62SJacques Vidrine int af; 1663248aee62SJacques Vidrine int *errp; 166463858012SJonathan Lemon struct hostent *hp = NULL; 166563858012SJonathan Lemon 1666248aee62SJacques Vidrine addr = va_arg(ap, const void *); 1667248aee62SJacques Vidrine addrlen = va_arg(ap, int); 1668248aee62SJacques Vidrine af = va_arg(ap, int); 1669248aee62SJacques Vidrine 167063858012SJonathan Lemon hp = _gethostbynisaddr(addr, addrlen, af); 167163858012SJonathan Lemon if (hp != NULL) 167263858012SJonathan Lemon hp = _hpcopy(hp, errp); 1673248aee62SJacques Vidrine *(struct hostent **)rval = hp; 1674248aee62SJacques Vidrine return (hp != NULL) ? NS_SUCCESS : NS_NOTFOUND; 16756bd1d1a1SHajimu UMEMOTO } 1676f468e837SHajimu UMEMOTO #endif 16777d56d374SYoshinobu Inoue 16789832619cSHajimu UMEMOTO #define MAXPACKET (64*1024) 167973b30f0cSJun-ichiro itojun Hagino 168073b30f0cSJun-ichiro itojun Hagino typedef union { 168173b30f0cSJun-ichiro itojun Hagino HEADER hdr; 168273b30f0cSJun-ichiro itojun Hagino u_char buf[MAXPACKET]; 168373b30f0cSJun-ichiro itojun Hagino } querybuf; 168473b30f0cSJun-ichiro itojun Hagino 16851372519bSDavid E. O'Brien static struct hostent *getanswer(const querybuf *, int, const char *, int, 16861372519bSDavid E. O'Brien struct hostent *, int *); 168773b30f0cSJun-ichiro itojun Hagino 168873b30f0cSJun-ichiro itojun Hagino /* 168973b30f0cSJun-ichiro itojun Hagino * we don't need to take care about sorting, nor IPv4 mapped address here. 169073b30f0cSJun-ichiro itojun Hagino */ 16917d56d374SYoshinobu Inoue static struct hostent * 169290d1d883SHajimu UMEMOTO getanswer(const querybuf *answer, int anslen, const char *qname, int qtype, 169390d1d883SHajimu UMEMOTO struct hostent *template, int *errp) 16947d56d374SYoshinobu Inoue { 16958fb3f3f6SDavid E. O'Brien const HEADER *hp; 16968fb3f3f6SDavid E. O'Brien const u_char *cp; 16978fb3f3f6SDavid E. O'Brien int n; 169873b30f0cSJun-ichiro itojun Hagino const u_char *eom, *erdata; 1699d6af58f5SWarner Losh char *bp, *ep, **ap, **hap; 1700d6af58f5SWarner Losh int type, class, ancount, qdcount; 170173b30f0cSJun-ichiro itojun Hagino int haveanswer, had_error; 170273b30f0cSJun-ichiro itojun Hagino char tbuf[MAXDNAME]; 170373b30f0cSJun-ichiro itojun Hagino const char *tname; 1704c05ac53bSDavid E. O'Brien int (*name_ok)(const char *); 170573b30f0cSJun-ichiro itojun Hagino static char *h_addr_ptrs[MAXADDRS + 1]; 170673b30f0cSJun-ichiro itojun Hagino static char *host_aliases[MAXALIASES]; 170773b30f0cSJun-ichiro itojun Hagino static char hostbuf[8*1024]; 17087d56d374SYoshinobu Inoue 170973b30f0cSJun-ichiro itojun Hagino #define BOUNDED_INCR(x) \ 171073b30f0cSJun-ichiro itojun Hagino do { \ 171173b30f0cSJun-ichiro itojun Hagino cp += x; \ 171273b30f0cSJun-ichiro itojun Hagino if (cp > eom) { \ 171373b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; \ 171473b30f0cSJun-ichiro itojun Hagino return (NULL); \ 171573b30f0cSJun-ichiro itojun Hagino } \ 171673b30f0cSJun-ichiro itojun Hagino } while (0) 17177d56d374SYoshinobu Inoue 171873b30f0cSJun-ichiro itojun Hagino #define BOUNDS_CHECK(ptr, count) \ 171973b30f0cSJun-ichiro itojun Hagino do { \ 172073b30f0cSJun-ichiro itojun Hagino if ((ptr) + (count) > eom) { \ 172173b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; \ 172273b30f0cSJun-ichiro itojun Hagino return (NULL); \ 172373b30f0cSJun-ichiro itojun Hagino } \ 172473b30f0cSJun-ichiro itojun Hagino } while (0) 172573b30f0cSJun-ichiro itojun Hagino 17263f587e57SKris Kennaway /* XXX do {} while (0) cannot be put here */ 172773b30f0cSJun-ichiro itojun Hagino #define DNS_ASSERT(x) \ 17283f587e57SKris Kennaway { \ 172973b30f0cSJun-ichiro itojun Hagino if (!(x)) { \ 173073b30f0cSJun-ichiro itojun Hagino cp += n; \ 173173b30f0cSJun-ichiro itojun Hagino continue; \ 173273b30f0cSJun-ichiro itojun Hagino } \ 17333f587e57SKris Kennaway } 173473b30f0cSJun-ichiro itojun Hagino 17353f587e57SKris Kennaway /* XXX do {} while (0) cannot be put here */ 173673b30f0cSJun-ichiro itojun Hagino #define DNS_FATAL(x) \ 17373f587e57SKris Kennaway { \ 173873b30f0cSJun-ichiro itojun Hagino if (!(x)) { \ 173973b30f0cSJun-ichiro itojun Hagino had_error++; \ 174073b30f0cSJun-ichiro itojun Hagino continue; \ 174173b30f0cSJun-ichiro itojun Hagino } \ 17423f587e57SKris Kennaway } 174373b30f0cSJun-ichiro itojun Hagino 174473b30f0cSJun-ichiro itojun Hagino tname = qname; 174573b30f0cSJun-ichiro itojun Hagino template->h_name = NULL; 174673b30f0cSJun-ichiro itojun Hagino eom = answer->buf + anslen; 174773b30f0cSJun-ichiro itojun Hagino switch (qtype) { 17487d56d374SYoshinobu Inoue case T_A: 17497d56d374SYoshinobu Inoue case T_AAAA: 175073b30f0cSJun-ichiro itojun Hagino name_ok = res_hnok; 175173b30f0cSJun-ichiro itojun Hagino break; 175273b30f0cSJun-ichiro itojun Hagino case T_PTR: 175373b30f0cSJun-ichiro itojun Hagino name_ok = res_dnok; 17547d56d374SYoshinobu Inoue break; 17557d56d374SYoshinobu Inoue default: 175673b30f0cSJun-ichiro itojun Hagino return (NULL); /* XXX should be abort(); */ 175773b30f0cSJun-ichiro itojun Hagino } 175873b30f0cSJun-ichiro itojun Hagino /* 175973b30f0cSJun-ichiro itojun Hagino * find first satisfactory answer 176073b30f0cSJun-ichiro itojun Hagino */ 176173b30f0cSJun-ichiro itojun Hagino hp = &answer->hdr; 176273b30f0cSJun-ichiro itojun Hagino ancount = ntohs(hp->ancount); 176373b30f0cSJun-ichiro itojun Hagino qdcount = ntohs(hp->qdcount); 176473b30f0cSJun-ichiro itojun Hagino bp = hostbuf; 1765d6af58f5SWarner Losh ep = hostbuf + sizeof hostbuf; 176673b30f0cSJun-ichiro itojun Hagino cp = answer->buf; 176773b30f0cSJun-ichiro itojun Hagino BOUNDED_INCR(HFIXEDSZ); 176873b30f0cSJun-ichiro itojun Hagino if (qdcount != 1) { 176973b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; 177073b30f0cSJun-ichiro itojun Hagino return (NULL); 177173b30f0cSJun-ichiro itojun Hagino } 1772d6af58f5SWarner Losh n = dn_expand(answer->buf, eom, cp, bp, ep - bp); 177373b30f0cSJun-ichiro itojun Hagino if ((n < 0) || !(*name_ok)(bp)) { 177473b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; 177573b30f0cSJun-ichiro itojun Hagino return (NULL); 177673b30f0cSJun-ichiro itojun Hagino } 177773b30f0cSJun-ichiro itojun Hagino BOUNDED_INCR(n + QFIXEDSZ); 177873b30f0cSJun-ichiro itojun Hagino if (qtype == T_A || qtype == T_AAAA) { 177973b30f0cSJun-ichiro itojun Hagino /* res_send() has already verified that the query name is the 178073b30f0cSJun-ichiro itojun Hagino * same as the one we sent; this just gets the expanded name 178173b30f0cSJun-ichiro itojun Hagino * (i.e., with the succeeding search-domain tacked on). 178273b30f0cSJun-ichiro itojun Hagino */ 178373b30f0cSJun-ichiro itojun Hagino n = strlen(bp) + 1; /* for the \0 */ 178473b30f0cSJun-ichiro itojun Hagino if (n >= MAXHOSTNAMELEN) { 178573b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; 178673b30f0cSJun-ichiro itojun Hagino return (NULL); 178773b30f0cSJun-ichiro itojun Hagino } 178873b30f0cSJun-ichiro itojun Hagino template->h_name = bp; 178973b30f0cSJun-ichiro itojun Hagino bp += n; 179073b30f0cSJun-ichiro itojun Hagino /* The qname can be abbreviated, but h_name is now absolute. */ 179173b30f0cSJun-ichiro itojun Hagino qname = template->h_name; 179273b30f0cSJun-ichiro itojun Hagino } 179373b30f0cSJun-ichiro itojun Hagino ap = host_aliases; 179473b30f0cSJun-ichiro itojun Hagino *ap = NULL; 179573b30f0cSJun-ichiro itojun Hagino template->h_aliases = host_aliases; 179673b30f0cSJun-ichiro itojun Hagino hap = h_addr_ptrs; 179773b30f0cSJun-ichiro itojun Hagino *hap = NULL; 179873b30f0cSJun-ichiro itojun Hagino template->h_addr_list = h_addr_ptrs; 179973b30f0cSJun-ichiro itojun Hagino haveanswer = 0; 180073b30f0cSJun-ichiro itojun Hagino had_error = 0; 180173b30f0cSJun-ichiro itojun Hagino while (ancount-- > 0 && cp < eom && !had_error) { 1802d6af58f5SWarner Losh n = dn_expand(answer->buf, eom, cp, bp, ep - bp); 180373b30f0cSJun-ichiro itojun Hagino DNS_FATAL(n >= 0); 180473b30f0cSJun-ichiro itojun Hagino DNS_FATAL((*name_ok)(bp)); 180573b30f0cSJun-ichiro itojun Hagino cp += n; /* name */ 180673b30f0cSJun-ichiro itojun Hagino BOUNDS_CHECK(cp, 3 * INT16SZ + INT32SZ); 180773b30f0cSJun-ichiro itojun Hagino type = _getshort(cp); 180873b30f0cSJun-ichiro itojun Hagino cp += INT16SZ; /* type */ 180973b30f0cSJun-ichiro itojun Hagino class = _getshort(cp); 181073b30f0cSJun-ichiro itojun Hagino cp += INT16SZ + INT32SZ; /* class, TTL */ 181173b30f0cSJun-ichiro itojun Hagino n = _getshort(cp); 181273b30f0cSJun-ichiro itojun Hagino cp += INT16SZ; /* len */ 181373b30f0cSJun-ichiro itojun Hagino BOUNDS_CHECK(cp, n); 181473b30f0cSJun-ichiro itojun Hagino erdata = cp + n; 181573b30f0cSJun-ichiro itojun Hagino DNS_ASSERT(class == C_IN); 181673b30f0cSJun-ichiro itojun Hagino if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) { 181773b30f0cSJun-ichiro itojun Hagino if (ap >= &host_aliases[MAXALIASES-1]) 181873b30f0cSJun-ichiro itojun Hagino continue; 181973b30f0cSJun-ichiro itojun Hagino n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf); 182073b30f0cSJun-ichiro itojun Hagino DNS_FATAL(n >= 0); 182173b30f0cSJun-ichiro itojun Hagino DNS_FATAL((*name_ok)(tbuf)); 18227d56d374SYoshinobu Inoue cp += n; 182373b30f0cSJun-ichiro itojun Hagino if (cp != erdata) { 182473b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; 182573b30f0cSJun-ichiro itojun Hagino return (NULL); 182673b30f0cSJun-ichiro itojun Hagino } 182773b30f0cSJun-ichiro itojun Hagino /* Store alias. */ 182873b30f0cSJun-ichiro itojun Hagino *ap++ = bp; 182973b30f0cSJun-ichiro itojun Hagino n = strlen(bp) + 1; /* for the \0 */ 183073b30f0cSJun-ichiro itojun Hagino DNS_FATAL(n < MAXHOSTNAMELEN); 183173b30f0cSJun-ichiro itojun Hagino bp += n; 183273b30f0cSJun-ichiro itojun Hagino /* Get canonical name. */ 183373b30f0cSJun-ichiro itojun Hagino n = strlen(tbuf) + 1; /* for the \0 */ 1834d6af58f5SWarner Losh DNS_FATAL(n <= ep - bp); 183573b30f0cSJun-ichiro itojun Hagino DNS_FATAL(n < MAXHOSTNAMELEN); 183673b30f0cSJun-ichiro itojun Hagino strcpy(bp, tbuf); 183773b30f0cSJun-ichiro itojun Hagino template->h_name = bp; 183873b30f0cSJun-ichiro itojun Hagino bp += n; 183973b30f0cSJun-ichiro itojun Hagino continue; 184073b30f0cSJun-ichiro itojun Hagino } 184173b30f0cSJun-ichiro itojun Hagino if (qtype == T_PTR && type == T_CNAME) { 184273b30f0cSJun-ichiro itojun Hagino n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf); 184373b30f0cSJun-ichiro itojun Hagino if (n < 0 || !res_dnok(tbuf)) { 184473b30f0cSJun-ichiro itojun Hagino had_error++; 184573b30f0cSJun-ichiro itojun Hagino continue; 184673b30f0cSJun-ichiro itojun Hagino } 184773b30f0cSJun-ichiro itojun Hagino cp += n; 184873b30f0cSJun-ichiro itojun Hagino if (cp != erdata) { 184973b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; 185073b30f0cSJun-ichiro itojun Hagino return (NULL); 185173b30f0cSJun-ichiro itojun Hagino } 185273b30f0cSJun-ichiro itojun Hagino /* Get canonical name. */ 185373b30f0cSJun-ichiro itojun Hagino n = strlen(tbuf) + 1; /* for the \0 */ 1854d6af58f5SWarner Losh if (n > ep - bp || n >= MAXHOSTNAMELEN) { 185573b30f0cSJun-ichiro itojun Hagino had_error++; 185673b30f0cSJun-ichiro itojun Hagino continue; 185773b30f0cSJun-ichiro itojun Hagino } 185873b30f0cSJun-ichiro itojun Hagino strcpy(bp, tbuf); 18593f587e57SKris Kennaway tname = bp; 186073b30f0cSJun-ichiro itojun Hagino bp += n; 186173b30f0cSJun-ichiro itojun Hagino continue; 186273b30f0cSJun-ichiro itojun Hagino } 186373b30f0cSJun-ichiro itojun Hagino DNS_ASSERT(type == qtype); 186473b30f0cSJun-ichiro itojun Hagino switch (type) { 186573b30f0cSJun-ichiro itojun Hagino case T_PTR: 186673b30f0cSJun-ichiro itojun Hagino DNS_ASSERT(strcasecmp(tname, bp) == 0); 1867d6af58f5SWarner Losh n = dn_expand(answer->buf, eom, cp, bp, ep - bp); 186873b30f0cSJun-ichiro itojun Hagino DNS_FATAL(n >= 0); 186973b30f0cSJun-ichiro itojun Hagino DNS_FATAL(res_hnok(bp)); 187073b30f0cSJun-ichiro itojun Hagino #if MULTI_PTRS_ARE_ALIASES 187173b30f0cSJun-ichiro itojun Hagino cp += n; 187273b30f0cSJun-ichiro itojun Hagino if (cp != erdata) { 187373b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; 187473b30f0cSJun-ichiro itojun Hagino return (NULL); 187573b30f0cSJun-ichiro itojun Hagino } 187673b30f0cSJun-ichiro itojun Hagino if (!haveanswer) 187773b30f0cSJun-ichiro itojun Hagino template->h_name = bp; 187873b30f0cSJun-ichiro itojun Hagino else if (ap < &host_aliases[MAXALIASES-1]) 187973b30f0cSJun-ichiro itojun Hagino *ap++ = bp; 188073b30f0cSJun-ichiro itojun Hagino else 188173b30f0cSJun-ichiro itojun Hagino n = -1; 188273b30f0cSJun-ichiro itojun Hagino if (n != -1) { 188373b30f0cSJun-ichiro itojun Hagino n = strlen(bp) + 1; /* for the \0 */ 188473b30f0cSJun-ichiro itojun Hagino if (n >= MAXHOSTNAMELEN) { 188573b30f0cSJun-ichiro itojun Hagino had_error++; 18867d56d374SYoshinobu Inoue break; 18877d56d374SYoshinobu Inoue } 188873b30f0cSJun-ichiro itojun Hagino bp += n; 18897d56d374SYoshinobu Inoue } 189073b30f0cSJun-ichiro itojun Hagino break; 189173b30f0cSJun-ichiro itojun Hagino #else 189273b30f0cSJun-ichiro itojun Hagino template->h_name = bp; 189373b30f0cSJun-ichiro itojun Hagino *errp = NETDB_SUCCESS; 189473b30f0cSJun-ichiro itojun Hagino return (template); 189573b30f0cSJun-ichiro itojun Hagino #endif 189673b30f0cSJun-ichiro itojun Hagino case T_A: 189773b30f0cSJun-ichiro itojun Hagino case T_AAAA: 189873b30f0cSJun-ichiro itojun Hagino DNS_ASSERT(strcasecmp(template->h_name, bp) == 0); 189973b30f0cSJun-ichiro itojun Hagino DNS_ASSERT(n == template->h_length); 190073b30f0cSJun-ichiro itojun Hagino if (!haveanswer) { 19018fb3f3f6SDavid E. O'Brien int nn; 190273b30f0cSJun-ichiro itojun Hagino 190373b30f0cSJun-ichiro itojun Hagino template->h_name = bp; 190473b30f0cSJun-ichiro itojun Hagino nn = strlen(bp) + 1; /* for the \0 */ 190573b30f0cSJun-ichiro itojun Hagino bp += nn; 190673b30f0cSJun-ichiro itojun Hagino } 190773b30f0cSJun-ichiro itojun Hagino bp = (char *)ALIGN(bp); 190873b30f0cSJun-ichiro itojun Hagino 1909d6af58f5SWarner Losh DNS_FATAL(bp + n < ep); 191073b30f0cSJun-ichiro itojun Hagino DNS_ASSERT(hap < &h_addr_ptrs[MAXADDRS-1]); 191173b30f0cSJun-ichiro itojun Hagino #ifdef FILTER_V4MAPPED 191273b30f0cSJun-ichiro itojun Hagino if (type == T_AAAA) { 191373b30f0cSJun-ichiro itojun Hagino struct in6_addr in6; 191473b30f0cSJun-ichiro itojun Hagino memcpy(&in6, cp, sizeof(in6)); 191573b30f0cSJun-ichiro itojun Hagino DNS_ASSERT(IN6_IS_ADDR_V4MAPPED(&in6) == 0); 191673b30f0cSJun-ichiro itojun Hagino } 191773b30f0cSJun-ichiro itojun Hagino #endif 191873b30f0cSJun-ichiro itojun Hagino bcopy(cp, *hap++ = bp, n); 191973b30f0cSJun-ichiro itojun Hagino bp += n; 192073b30f0cSJun-ichiro itojun Hagino cp += n; 192173b30f0cSJun-ichiro itojun Hagino if (cp != erdata) { 19227d56d374SYoshinobu Inoue *errp = NO_RECOVERY; 192373b30f0cSJun-ichiro itojun Hagino return (NULL); 19247d56d374SYoshinobu Inoue } 192573b30f0cSJun-ichiro itojun Hagino break; 192673b30f0cSJun-ichiro itojun Hagino default: 192773b30f0cSJun-ichiro itojun Hagino abort(); 192873b30f0cSJun-ichiro itojun Hagino } 192973b30f0cSJun-ichiro itojun Hagino if (!had_error) 193073b30f0cSJun-ichiro itojun Hagino haveanswer++; 193173b30f0cSJun-ichiro itojun Hagino } 193273b30f0cSJun-ichiro itojun Hagino if (haveanswer) { 193373b30f0cSJun-ichiro itojun Hagino *ap = NULL; 193473b30f0cSJun-ichiro itojun Hagino *hap = NULL; 193573b30f0cSJun-ichiro itojun Hagino if (!template->h_name) { 193673b30f0cSJun-ichiro itojun Hagino n = strlen(qname) + 1; /* for the \0 */ 1937d6af58f5SWarner Losh if (n > ep - bp || n >= MAXHOSTNAMELEN) 193873b30f0cSJun-ichiro itojun Hagino goto no_recovery; 193973b30f0cSJun-ichiro itojun Hagino strcpy(bp, qname); 194073b30f0cSJun-ichiro itojun Hagino template->h_name = bp; 194173b30f0cSJun-ichiro itojun Hagino bp += n; 194273b30f0cSJun-ichiro itojun Hagino } 194373b30f0cSJun-ichiro itojun Hagino *errp = NETDB_SUCCESS; 194473b30f0cSJun-ichiro itojun Hagino return (template); 194573b30f0cSJun-ichiro itojun Hagino } 194673b30f0cSJun-ichiro itojun Hagino no_recovery: 194773b30f0cSJun-ichiro itojun Hagino *errp = NO_RECOVERY; 194873b30f0cSJun-ichiro itojun Hagino return (NULL); 194973b30f0cSJun-ichiro itojun Hagino 195073b30f0cSJun-ichiro itojun Hagino #undef BOUNDED_INCR 195173b30f0cSJun-ichiro itojun Hagino #undef BOUNDS_CHECK 195273b30f0cSJun-ichiro itojun Hagino #undef DNS_ASSERT 195373b30f0cSJun-ichiro itojun Hagino #undef DNS_FATAL 19547d56d374SYoshinobu Inoue } 19557d56d374SYoshinobu Inoue 1956248aee62SJacques Vidrine static int 1957248aee62SJacques Vidrine _dns_ghbyname(void *rval, void *cb_data, va_list ap) 1958e6f35403SYoshinobu Inoue { 1959248aee62SJacques Vidrine const char *name; 1960248aee62SJacques Vidrine int af; 1961248aee62SJacques Vidrine int *errp; 19620fbf0979SHajimu UMEMOTO int n; 19630fbf0979SHajimu UMEMOTO struct hostent *hp; 19640fbf0979SHajimu UMEMOTO int qtype; 19650fbf0979SHajimu UMEMOTO struct hostent hbuf; 19660fbf0979SHajimu UMEMOTO querybuf *buf; 19675342d17fSHajimu UMEMOTO res_state statp; 1968e6f35403SYoshinobu Inoue 1969248aee62SJacques Vidrine name = va_arg(ap, const char *); 1970248aee62SJacques Vidrine af = va_arg(ap, int); 1971248aee62SJacques Vidrine errp = va_arg(ap, int *); 1972248aee62SJacques Vidrine 19735342d17fSHajimu UMEMOTO statp = __res_state(); 19745342d17fSHajimu UMEMOTO 19750fbf0979SHajimu UMEMOTO memset(&hbuf, 0, sizeof(hbuf)); 19760fbf0979SHajimu UMEMOTO hbuf.h_addrtype = af; 19770fbf0979SHajimu UMEMOTO hbuf.h_length = ADDRLEN(af); 19780fbf0979SHajimu UMEMOTO 19790fbf0979SHajimu UMEMOTO switch (af) { 19800fbf0979SHajimu UMEMOTO #ifdef INET6 19810fbf0979SHajimu UMEMOTO case AF_INET6: 19820fbf0979SHajimu UMEMOTO qtype = T_AAAA; 19830fbf0979SHajimu UMEMOTO break; 1984e6f35403SYoshinobu Inoue #endif 19850fbf0979SHajimu UMEMOTO case AF_INET: 19860fbf0979SHajimu UMEMOTO qtype = T_A; 19870fbf0979SHajimu UMEMOTO break; 19880fbf0979SHajimu UMEMOTO default: 19890fbf0979SHajimu UMEMOTO *errp = NO_RECOVERY; 19900fbf0979SHajimu UMEMOTO return NS_NOTFOUND; 19910fbf0979SHajimu UMEMOTO } 19920fbf0979SHajimu UMEMOTO buf = malloc(sizeof(*buf)); 19930fbf0979SHajimu UMEMOTO if (buf == NULL) { 19940fbf0979SHajimu UMEMOTO *errp = NETDB_INTERNAL; 19950fbf0979SHajimu UMEMOTO return NS_UNAVAIL; 19960fbf0979SHajimu UMEMOTO } 19975342d17fSHajimu UMEMOTO n = res_nsearch(statp, name, C_IN, qtype, buf->buf, sizeof(buf->buf)); 19980fbf0979SHajimu UMEMOTO if (n < 0) { 19990fbf0979SHajimu UMEMOTO free(buf); 20005342d17fSHajimu UMEMOTO *errp = statp->res_h_errno; 20010fbf0979SHajimu UMEMOTO return NS_UNAVAIL; 20020fbf0979SHajimu UMEMOTO } 20030fbf0979SHajimu UMEMOTO hp = getanswer(buf, n, name, qtype, &hbuf, errp); 20040fbf0979SHajimu UMEMOTO free(buf); 20050fbf0979SHajimu UMEMOTO if (!hp) { 20060fbf0979SHajimu UMEMOTO *errp = NO_RECOVERY; 20070fbf0979SHajimu UMEMOTO return NS_NOTFOUND; 20080fbf0979SHajimu UMEMOTO } 20090fbf0979SHajimu UMEMOTO *(struct hostent **)rval = _hpcopy(&hbuf, errp); 2010e651d83aSPierre Beyssac if (*(struct hostent **)rval != NULL) 2011e651d83aSPierre Beyssac return NS_SUCCESS; 2012e651d83aSPierre Beyssac else if (*errp == TRY_AGAIN) 2013e651d83aSPierre Beyssac return NS_TRYAGAIN; 2014e651d83aSPierre Beyssac else 2015e651d83aSPierre Beyssac return NS_NOTFOUND; 2016e6f35403SYoshinobu Inoue } 2017e6f35403SYoshinobu Inoue 2018248aee62SJacques Vidrine static int 2019248aee62SJacques Vidrine _dns_ghbyaddr(void *rval, void *cb_data, va_list ap) 20207d56d374SYoshinobu Inoue { 2021248aee62SJacques Vidrine const void *addr; 2022248aee62SJacques Vidrine int addrlen; 2023248aee62SJacques Vidrine int af; 2024248aee62SJacques Vidrine int *errp; 20257d56d374SYoshinobu Inoue int n; 2026aadad922SHajimu UMEMOTO int err; 202773b30f0cSJun-ichiro itojun Hagino struct hostent *hp; 202873b30f0cSJun-ichiro itojun Hagino u_char c, *cp; 20297d56d374SYoshinobu Inoue char *bp; 20307d56d374SYoshinobu Inoue struct hostent hbuf; 20317d56d374SYoshinobu Inoue #ifdef INET6 20327d56d374SYoshinobu Inoue static const char hex[] = "0123456789abcdef"; 20337d56d374SYoshinobu Inoue #endif 20349832619cSHajimu UMEMOTO querybuf *buf; 203573b30f0cSJun-ichiro itojun Hagino char qbuf[MAXDNAME+1]; 203673b30f0cSJun-ichiro itojun Hagino char *hlist[2]; 20370def575fSHajimu UMEMOTO char *tld6[] = { "ip6.arpa", NULL }; 2038aadad922SHajimu UMEMOTO char *tld4[] = { "in-addr.arpa", NULL }; 2039aadad922SHajimu UMEMOTO char **tld; 20405342d17fSHajimu UMEMOTO res_state statp; 20417d56d374SYoshinobu Inoue 2042248aee62SJacques Vidrine addr = va_arg(ap, const void *); 2043248aee62SJacques Vidrine addrlen = va_arg(ap, int); 2044248aee62SJacques Vidrine af = va_arg(ap, int); 2045248aee62SJacques Vidrine errp = va_arg(ap, int *); 2046248aee62SJacques Vidrine 2047248aee62SJacques Vidrine *(struct hostent **)rval = NULL; 2048248aee62SJacques Vidrine 20497d56d374SYoshinobu Inoue #ifdef INET6 20507d56d374SYoshinobu Inoue /* XXX */ 20517d56d374SYoshinobu Inoue if (af == AF_INET6 && IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)addr)) 2052248aee62SJacques Vidrine return NS_NOTFOUND; 20537d56d374SYoshinobu Inoue #endif 20547d56d374SYoshinobu Inoue 2055aadad922SHajimu UMEMOTO switch (af) { 2056aadad922SHajimu UMEMOTO #ifdef INET6 2057aadad922SHajimu UMEMOTO case AF_INET6: 2058aadad922SHajimu UMEMOTO tld = tld6; 2059aadad922SHajimu UMEMOTO break; 2060aadad922SHajimu UMEMOTO #endif 2061aadad922SHajimu UMEMOTO case AF_INET: 2062aadad922SHajimu UMEMOTO tld = tld4; 2063aadad922SHajimu UMEMOTO break; 2064aadad922SHajimu UMEMOTO default: 2065aadad922SHajimu UMEMOTO return NS_NOTFOUND; 2066aadad922SHajimu UMEMOTO } 2067aadad922SHajimu UMEMOTO 20685342d17fSHajimu UMEMOTO statp = __res_state(); 20695342d17fSHajimu UMEMOTO if ((statp->options & RES_INIT) == 0) { 20705342d17fSHajimu UMEMOTO if (res_ninit(statp) < 0) { 20715342d17fSHajimu UMEMOTO *errp = NETDB_INTERNAL; 2072248aee62SJacques Vidrine return NS_UNAVAIL; 20737d56d374SYoshinobu Inoue } 20747d56d374SYoshinobu Inoue } 207573b30f0cSJun-ichiro itojun Hagino memset(&hbuf, 0, sizeof(hbuf)); 20767d56d374SYoshinobu Inoue hbuf.h_name = NULL; 20777d56d374SYoshinobu Inoue hbuf.h_addrtype = af; 20787d56d374SYoshinobu Inoue hbuf.h_length = addrlen; 20797d56d374SYoshinobu Inoue 2080aadad922SHajimu UMEMOTO buf = malloc(sizeof(*buf)); 2081aadad922SHajimu UMEMOTO if (buf == NULL) { 2082aadad922SHajimu UMEMOTO *errp = NETDB_INTERNAL; 2083aadad922SHajimu UMEMOTO return NS_UNAVAIL; 2084aadad922SHajimu UMEMOTO } 2085aadad922SHajimu UMEMOTO err = NS_SUCCESS; 2086aadad922SHajimu UMEMOTO for (/* nothing */; *tld; tld++) { 2087aadad922SHajimu UMEMOTO /* 2088aadad922SHajimu UMEMOTO * XXX assumes that MAXDNAME is big enough - error checks 2089aadad922SHajimu UMEMOTO * has been made by callers 2090aadad922SHajimu UMEMOTO */ 20917d56d374SYoshinobu Inoue n = 0; 209273b30f0cSJun-ichiro itojun Hagino bp = qbuf; 20937d56d374SYoshinobu Inoue cp = (u_char *)addr+addrlen-1; 20947d56d374SYoshinobu Inoue switch (af) { 20957d56d374SYoshinobu Inoue #ifdef INET6 20967d56d374SYoshinobu Inoue case AF_INET6: 20977d56d374SYoshinobu Inoue for (; n < addrlen; n++, cp--) { 20987d56d374SYoshinobu Inoue c = *cp; 20997d56d374SYoshinobu Inoue *bp++ = hex[c & 0xf]; 21007d56d374SYoshinobu Inoue *bp++ = '.'; 21017d56d374SYoshinobu Inoue *bp++ = hex[c >> 4]; 21027d56d374SYoshinobu Inoue *bp++ = '.'; 21037d56d374SYoshinobu Inoue } 2104aadad922SHajimu UMEMOTO strcpy(bp, *tld); 21057d56d374SYoshinobu Inoue break; 21067d56d374SYoshinobu Inoue #endif 2107aadad922SHajimu UMEMOTO case AF_INET: 21087d56d374SYoshinobu Inoue for (; n < addrlen; n++, cp--) { 21097d56d374SYoshinobu Inoue c = *cp; 21107d56d374SYoshinobu Inoue if (c >= 100) 21117d56d374SYoshinobu Inoue *bp++ = '0' + c / 100; 21127d56d374SYoshinobu Inoue if (c >= 10) 21137d56d374SYoshinobu Inoue *bp++ = '0' + (c % 100) / 10; 21147d56d374SYoshinobu Inoue *bp++ = '0' + c % 10; 21157d56d374SYoshinobu Inoue *bp++ = '.'; 21167d56d374SYoshinobu Inoue } 2117aadad922SHajimu UMEMOTO strcpy(bp, *tld); 21187d56d374SYoshinobu Inoue break; 21197d56d374SYoshinobu Inoue } 21207d56d374SYoshinobu Inoue 21215342d17fSHajimu UMEMOTO n = res_nquery(statp, qbuf, C_IN, T_PTR, buf->buf, 21225342d17fSHajimu UMEMOTO sizeof buf->buf); 21237d56d374SYoshinobu Inoue if (n < 0) { 21245342d17fSHajimu UMEMOTO *errp = statp->res_h_errno; 2125aadad922SHajimu UMEMOTO err = NS_UNAVAIL; 2126aadad922SHajimu UMEMOTO continue; 21279832619cSHajimu UMEMOTO } else if (n > sizeof(buf->buf)) { 212854384cf3SJacques Vidrine #if 0 212954384cf3SJacques Vidrine errno = ERANGE; /* XXX is it OK to set errno here? */ 213054384cf3SJacques Vidrine #endif 213154384cf3SJacques Vidrine *errp = NETDB_INTERNAL; 2132aadad922SHajimu UMEMOTO err = NS_UNAVAIL; 2133aadad922SHajimu UMEMOTO continue; 21347d56d374SYoshinobu Inoue } 21359832619cSHajimu UMEMOTO hp = getanswer(buf, n, qbuf, T_PTR, &hbuf, errp); 2136aadad922SHajimu UMEMOTO if (!hp) { 2137aadad922SHajimu UMEMOTO err = NS_NOTFOUND; 2138aadad922SHajimu UMEMOTO continue; 2139aadad922SHajimu UMEMOTO } 21409832619cSHajimu UMEMOTO free(buf); 214173b30f0cSJun-ichiro itojun Hagino hbuf.h_addrtype = af; 214273b30f0cSJun-ichiro itojun Hagino hbuf.h_length = addrlen; 214373b30f0cSJun-ichiro itojun Hagino hbuf.h_addr_list = hlist; 214473b30f0cSJun-ichiro itojun Hagino hlist[0] = (char *)addr; 214573b30f0cSJun-ichiro itojun Hagino hlist[1] = NULL; 2146248aee62SJacques Vidrine *(struct hostent **)rval = _hpcopy(&hbuf, errp); 2147248aee62SJacques Vidrine return NS_SUCCESS; 21487d56d374SYoshinobu Inoue } 2149aadad922SHajimu UMEMOTO free(buf); 2150aadad922SHajimu UMEMOTO return err; 2151aadad922SHajimu UMEMOTO } 21527d56d374SYoshinobu Inoue 215373b30f0cSJun-ichiro itojun Hagino static void 215473b30f0cSJun-ichiro itojun Hagino _dns_shent(int stayopen) 215573b30f0cSJun-ichiro itojun Hagino { 21565342d17fSHajimu UMEMOTO res_state statp; 21575342d17fSHajimu UMEMOTO 21585342d17fSHajimu UMEMOTO statp = __res_state(); 21595342d17fSHajimu UMEMOTO if ((statp->options & RES_INIT) == 0) { 21605342d17fSHajimu UMEMOTO if (res_ninit(statp) < 0) 216173b30f0cSJun-ichiro itojun Hagino return; 216273b30f0cSJun-ichiro itojun Hagino } 216373b30f0cSJun-ichiro itojun Hagino if (stayopen) 21645342d17fSHajimu UMEMOTO statp->options |= RES_STAYOPEN | RES_USEVC; 216573b30f0cSJun-ichiro itojun Hagino } 216673b30f0cSJun-ichiro itojun Hagino 216773b30f0cSJun-ichiro itojun Hagino static void 216873b30f0cSJun-ichiro itojun Hagino _dns_ehent(void) 216973b30f0cSJun-ichiro itojun Hagino { 21705342d17fSHajimu UMEMOTO res_state statp; 21715342d17fSHajimu UMEMOTO 21725342d17fSHajimu UMEMOTO statp = __res_state(); 21735342d17fSHajimu UMEMOTO statp->options &= ~(RES_STAYOPEN | RES_USEVC); 21745342d17fSHajimu UMEMOTO res_nclose(statp); 217573b30f0cSJun-ichiro itojun Hagino } 217673b30f0cSJun-ichiro itojun Hagino 21777d56d374SYoshinobu Inoue #ifdef ICMPNL 21787d56d374SYoshinobu Inoue 21797d56d374SYoshinobu Inoue /* 21807d56d374SYoshinobu Inoue * experimental: 21817d56d374SYoshinobu Inoue * draft-ietf-ipngwg-icmp-namelookups-02.txt 21827d56d374SYoshinobu Inoue * ifindex is assumed to be encoded in addr. 21837d56d374SYoshinobu Inoue */ 21847d56d374SYoshinobu Inoue #include <sys/uio.h> 21857d56d374SYoshinobu Inoue #include <netinet/ip6.h> 21867d56d374SYoshinobu Inoue #include <netinet/icmp6.h> 21877d56d374SYoshinobu Inoue 21887d56d374SYoshinobu Inoue struct _icmp_host_cache { 21897d56d374SYoshinobu Inoue struct _icmp_host_cache *hc_next; 21907d56d374SYoshinobu Inoue int hc_ifindex; 21917d56d374SYoshinobu Inoue struct in6_addr hc_addr; 21927d56d374SYoshinobu Inoue char *hc_name; 21937d56d374SYoshinobu Inoue }; 21947d56d374SYoshinobu Inoue 21957d56d374SYoshinobu Inoue static char * 21967d56d374SYoshinobu Inoue _icmp_fqdn_query(const struct in6_addr *addr, int ifindex) 21977d56d374SYoshinobu Inoue { 21987d56d374SYoshinobu Inoue int s; 21997d56d374SYoshinobu Inoue struct icmp6_filter filter; 22007d56d374SYoshinobu Inoue struct msghdr msg; 22017d56d374SYoshinobu Inoue struct cmsghdr *cmsg; 22027d56d374SYoshinobu Inoue struct in6_pktinfo *pkt; 22037d56d374SYoshinobu Inoue char cbuf[256]; 22047d56d374SYoshinobu Inoue char buf[1024]; 22057d56d374SYoshinobu Inoue int cc; 22067d56d374SYoshinobu Inoue struct icmp6_fqdn_query *fq; 22077d56d374SYoshinobu Inoue struct icmp6_fqdn_reply *fr; 22087d56d374SYoshinobu Inoue struct _icmp_host_cache *hc; 22097d56d374SYoshinobu Inoue struct sockaddr_in6 sin6; 22107d56d374SYoshinobu Inoue struct iovec iov; 22117d56d374SYoshinobu Inoue fd_set s_fds, fds; 22127d56d374SYoshinobu Inoue struct timeval tout; 22137d56d374SYoshinobu Inoue int len; 22147d56d374SYoshinobu Inoue char *name; 22157d56d374SYoshinobu Inoue static struct _icmp_host_cache *hc_head; 22167d56d374SYoshinobu Inoue 221733dee819SBrian Feldman THREAD_LOCK(); 22187d56d374SYoshinobu Inoue for (hc = hc_head; hc; hc = hc->hc_next) { 22197d56d374SYoshinobu Inoue if (hc->hc_ifindex == ifindex 222033dee819SBrian Feldman && IN6_ARE_ADDR_EQUAL(&hc->hc_addr, addr)) { 222133dee819SBrian Feldman THREAD_UNLOCK(); 222233dee819SBrian Feldman return hc->hc_name; /* XXX: never freed */ 22237d56d374SYoshinobu Inoue } 222433dee819SBrian Feldman } 222578ebcde8SHajimu UMEMOTO THREAD_UNLOCK(); 22267d56d374SYoshinobu Inoue 22277d56d374SYoshinobu Inoue ICMP6_FILTER_SETBLOCKALL(&filter); 22287d56d374SYoshinobu Inoue ICMP6_FILTER_SETPASS(ICMP6_FQDN_REPLY, &filter); 22297d56d374SYoshinobu Inoue 22307d56d374SYoshinobu Inoue FD_ZERO(&s_fds); 22317d56d374SYoshinobu Inoue tout.tv_sec = 0; 22327d56d374SYoshinobu Inoue tout.tv_usec = 200000; /*XXX: 200ms*/ 22337d56d374SYoshinobu Inoue 22347d56d374SYoshinobu Inoue fq = (struct icmp6_fqdn_query *)buf; 22357d56d374SYoshinobu Inoue fq->icmp6_fqdn_type = ICMP6_FQDN_QUERY; 22367d56d374SYoshinobu Inoue fq->icmp6_fqdn_code = 0; 22377d56d374SYoshinobu Inoue fq->icmp6_fqdn_cksum = 0; 223833dee819SBrian Feldman fq->icmp6_fqdn_id = (u_short)getpid(); 22397d56d374SYoshinobu Inoue fq->icmp6_fqdn_unused = 0; 22407d56d374SYoshinobu Inoue fq->icmp6_fqdn_cookie[0] = 0; 22417d56d374SYoshinobu Inoue fq->icmp6_fqdn_cookie[1] = 0; 22427d56d374SYoshinobu Inoue 22437d56d374SYoshinobu Inoue memset(&sin6, 0, sizeof(sin6)); 22447d56d374SYoshinobu Inoue sin6.sin6_family = AF_INET6; 22457d56d374SYoshinobu Inoue sin6.sin6_addr = *addr; 22467d56d374SYoshinobu Inoue 22477d56d374SYoshinobu Inoue memset(&msg, 0, sizeof(msg)); 22487d56d374SYoshinobu Inoue msg.msg_name = (caddr_t)&sin6; 22497d56d374SYoshinobu Inoue msg.msg_namelen = sizeof(sin6); 22507d56d374SYoshinobu Inoue msg.msg_iov = &iov; 22517d56d374SYoshinobu Inoue msg.msg_iovlen = 1; 22527d56d374SYoshinobu Inoue msg.msg_control = NULL; 22537d56d374SYoshinobu Inoue msg.msg_controllen = 0; 22547d56d374SYoshinobu Inoue iov.iov_base = (caddr_t)buf; 22557d56d374SYoshinobu Inoue iov.iov_len = sizeof(struct icmp6_fqdn_query); 22567d56d374SYoshinobu Inoue 22577d56d374SYoshinobu Inoue if (ifindex) { 22587d56d374SYoshinobu Inoue msg.msg_control = cbuf; 22597d56d374SYoshinobu Inoue msg.msg_controllen = sizeof(cbuf); 22607d56d374SYoshinobu Inoue cmsg = CMSG_FIRSTHDR(&msg); 22617d56d374SYoshinobu Inoue cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo)); 22627d56d374SYoshinobu Inoue cmsg->cmsg_level = IPPROTO_IPV6; 22637d56d374SYoshinobu Inoue cmsg->cmsg_type = IPV6_PKTINFO; 22647d56d374SYoshinobu Inoue pkt = (struct in6_pktinfo *)&cmsg[1]; 22657d56d374SYoshinobu Inoue memset(&pkt->ipi6_addr, 0, sizeof(struct in6_addr)); 22667d56d374SYoshinobu Inoue pkt->ipi6_ifindex = ifindex; 22677d56d374SYoshinobu Inoue cmsg = CMSG_NXTHDR(&msg, cmsg); 22687d56d374SYoshinobu Inoue msg.msg_controllen = (char *)cmsg - cbuf; 22697d56d374SYoshinobu Inoue } 22707d56d374SYoshinobu Inoue 2271d201fe46SDaniel Eischen if ((s = _socket(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) < 0) 22727d56d374SYoshinobu Inoue return NULL; 2273d201fe46SDaniel Eischen (void)_setsockopt(s, IPPROTO_ICMPV6, ICMP6_FILTER, 22747d56d374SYoshinobu Inoue (char *)&filter, sizeof(filter)); 2275d201fe46SDaniel Eischen cc = _sendmsg(s, &msg, 0); 22767d56d374SYoshinobu Inoue if (cc < 0) { 22779233c4d9SJason Evans _close(s); 22787d56d374SYoshinobu Inoue return NULL; 22797d56d374SYoshinobu Inoue } 22807d56d374SYoshinobu Inoue FD_SET(s, &s_fds); 22817d56d374SYoshinobu Inoue for (;;) { 22827d56d374SYoshinobu Inoue fds = s_fds; 2283d201fe46SDaniel Eischen if (_select(s + 1, &fds, NULL, NULL, &tout) <= 0) { 22849233c4d9SJason Evans _close(s); 22857d56d374SYoshinobu Inoue return NULL; 22867d56d374SYoshinobu Inoue } 22877d56d374SYoshinobu Inoue len = sizeof(sin6); 2288d201fe46SDaniel Eischen cc = _recvfrom(s, buf, sizeof(buf), 0, 22897d56d374SYoshinobu Inoue (struct sockaddr *)&sin6, &len); 22907d56d374SYoshinobu Inoue if (cc <= 0) { 22919233c4d9SJason Evans _close(s); 22927d56d374SYoshinobu Inoue return NULL; 22937d56d374SYoshinobu Inoue } 22947d56d374SYoshinobu Inoue if (cc < sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr)) 22957d56d374SYoshinobu Inoue continue; 22967d56d374SYoshinobu Inoue if (!IN6_ARE_ADDR_EQUAL(addr, &sin6.sin6_addr)) 22977d56d374SYoshinobu Inoue continue; 22987d56d374SYoshinobu Inoue fr = (struct icmp6_fqdn_reply *)(buf + sizeof(struct ip6_hdr)); 22997d56d374SYoshinobu Inoue if (fr->icmp6_fqdn_type == ICMP6_FQDN_REPLY) 23007d56d374SYoshinobu Inoue break; 23017d56d374SYoshinobu Inoue } 23029233c4d9SJason Evans _close(s); 23037d56d374SYoshinobu Inoue if (fr->icmp6_fqdn_cookie[1] != 0) { 23047d56d374SYoshinobu Inoue /* rfc1788 type */ 23057d56d374SYoshinobu Inoue name = buf + sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr) + 4; 23067d56d374SYoshinobu Inoue len = (buf + cc) - name; 23077d56d374SYoshinobu Inoue } else { 23087d56d374SYoshinobu Inoue len = fr->icmp6_fqdn_namelen; 23097d56d374SYoshinobu Inoue name = fr->icmp6_fqdn_name; 23107d56d374SYoshinobu Inoue } 23117d56d374SYoshinobu Inoue if (len <= 0) 23127d56d374SYoshinobu Inoue return NULL; 23137d56d374SYoshinobu Inoue name[len] = 0; 23147d56d374SYoshinobu Inoue 23157d56d374SYoshinobu Inoue if ((hc = (struct _icmp_host_cache *)malloc(sizeof(*hc))) == NULL) 23167d56d374SYoshinobu Inoue return NULL; 23177d56d374SYoshinobu Inoue /* XXX: limit number of cached entries */ 23187d56d374SYoshinobu Inoue hc->hc_ifindex = ifindex; 23197d56d374SYoshinobu Inoue hc->hc_addr = *addr; 23207d56d374SYoshinobu Inoue hc->hc_name = strdup(name); 232133dee819SBrian Feldman THREAD_LOCK(); 23227d56d374SYoshinobu Inoue hc->hc_next = hc_head; 23237d56d374SYoshinobu Inoue hc_head = hc; 232433dee819SBrian Feldman THREAD_UNLOCK(); 23257d56d374SYoshinobu Inoue return hc->hc_name; 23267d56d374SYoshinobu Inoue } 23277d56d374SYoshinobu Inoue 23287d56d374SYoshinobu Inoue static struct hostent * 23297d56d374SYoshinobu Inoue _icmp_ghbyaddr(const void *addr, int addrlen, int af, int *errp) 23307d56d374SYoshinobu Inoue { 23317d56d374SYoshinobu Inoue char *hname; 23327d56d374SYoshinobu Inoue int ifindex; 23337d56d374SYoshinobu Inoue struct in6_addr addr6; 23347d56d374SYoshinobu Inoue 23357d56d374SYoshinobu Inoue if (af != AF_INET6) { 23367d56d374SYoshinobu Inoue /* 23377d56d374SYoshinobu Inoue * Note: rfc1788 defines Who Are You for IPv4, 23387d56d374SYoshinobu Inoue * but no one implements it. 23397d56d374SYoshinobu Inoue */ 23407d56d374SYoshinobu Inoue return NULL; 23417d56d374SYoshinobu Inoue } 23427d56d374SYoshinobu Inoue 23437d56d374SYoshinobu Inoue memcpy(&addr6, addr, addrlen); 23447d56d374SYoshinobu Inoue ifindex = (addr6.s6_addr[2] << 8) | addr6.s6_addr[3]; 23457d56d374SYoshinobu Inoue addr6.s6_addr[2] = addr6.s6_addr[3] = 0; 23467d56d374SYoshinobu Inoue 23477d56d374SYoshinobu Inoue if (!IN6_IS_ADDR_LINKLOCAL(&addr6)) 23487d56d374SYoshinobu Inoue return NULL; /*XXX*/ 23497d56d374SYoshinobu Inoue 23507d56d374SYoshinobu Inoue if ((hname = _icmp_fqdn_query(&addr6, ifindex)) == NULL) 23517d56d374SYoshinobu Inoue return NULL; 23527d56d374SYoshinobu Inoue return _hpaddr(af, hname, &addr6, errp); 23537d56d374SYoshinobu Inoue } 23547d56d374SYoshinobu Inoue #endif /* ICMPNL */ 2355