13f587e57SKris Kennaway /* $KAME: name6.c,v 1.25 2000/06/26 16:44:40 itojun Exp $ */
273b30f0cSJun-ichiro itojun Hagino
38a16b7a1SPedro F. Giffuni /*-
48a16b7a1SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause
58a16b7a1SPedro F. Giffuni *
67d56d374SYoshinobu Inoue * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
77d56d374SYoshinobu Inoue * All rights reserved.
87d56d374SYoshinobu Inoue *
97d56d374SYoshinobu Inoue * Redistribution and use in source and binary forms, with or without
107d56d374SYoshinobu Inoue * modification, are permitted provided that the following conditions
117d56d374SYoshinobu Inoue * are met:
127d56d374SYoshinobu Inoue * 1. Redistributions of source code must retain the above copyright
137d56d374SYoshinobu Inoue * notice, this list of conditions and the following disclaimer.
147d56d374SYoshinobu Inoue * 2. Redistributions in binary form must reproduce the above copyright
157d56d374SYoshinobu Inoue * notice, this list of conditions and the following disclaimer in the
167d56d374SYoshinobu Inoue * documentation and/or other materials provided with the distribution.
177d56d374SYoshinobu Inoue * 3. Neither the name of the project nor the names of its contributors
187d56d374SYoshinobu Inoue * may be used to endorse or promote products derived from this software
197d56d374SYoshinobu Inoue * without specific prior written permission.
207d56d374SYoshinobu Inoue *
217d56d374SYoshinobu Inoue * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
227d56d374SYoshinobu Inoue * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
237d56d374SYoshinobu Inoue * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
247d56d374SYoshinobu Inoue * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
257d56d374SYoshinobu Inoue * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
267d56d374SYoshinobu Inoue * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
277d56d374SYoshinobu Inoue * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
287d56d374SYoshinobu Inoue * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
297d56d374SYoshinobu Inoue * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
307d56d374SYoshinobu Inoue * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
317d56d374SYoshinobu Inoue * SUCH DAMAGE.
327d56d374SYoshinobu Inoue */
3373b30f0cSJun-ichiro itojun Hagino /*
3473b30f0cSJun-ichiro itojun Hagino * ++Copyright++ 1985, 1988, 1993
3573b30f0cSJun-ichiro itojun Hagino * -
3673b30f0cSJun-ichiro itojun Hagino * Copyright (c) 1985, 1988, 1993
3773b30f0cSJun-ichiro itojun Hagino * The Regents of the University of California. All rights reserved.
3873b30f0cSJun-ichiro itojun Hagino *
3973b30f0cSJun-ichiro itojun Hagino * Redistribution and use in source and binary forms, with or without
4073b30f0cSJun-ichiro itojun Hagino * modification, are permitted provided that the following conditions
4173b30f0cSJun-ichiro itojun Hagino * are met:
4273b30f0cSJun-ichiro itojun Hagino * 1. Redistributions of source code must retain the above copyright
4373b30f0cSJun-ichiro itojun Hagino * notice, this list of conditions and the following disclaimer.
4473b30f0cSJun-ichiro itojun Hagino * 2. Redistributions in binary form must reproduce the above copyright
4573b30f0cSJun-ichiro itojun Hagino * notice, this list of conditions and the following disclaimer in the
4673b30f0cSJun-ichiro itojun Hagino * documentation and/or other materials provided with the distribution.
47e2e9c35fSEd Maste * 3. Neither the name of the University nor the names of its contributors
4873b30f0cSJun-ichiro itojun Hagino * may be used to endorse or promote products derived from this software
4973b30f0cSJun-ichiro itojun Hagino * without specific prior written permission.
5073b30f0cSJun-ichiro itojun Hagino *
5173b30f0cSJun-ichiro itojun Hagino * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
5273b30f0cSJun-ichiro itojun Hagino * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
5373b30f0cSJun-ichiro itojun Hagino * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
5473b30f0cSJun-ichiro itojun Hagino * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
5573b30f0cSJun-ichiro itojun Hagino * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
5673b30f0cSJun-ichiro itojun Hagino * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
5773b30f0cSJun-ichiro itojun Hagino * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
5873b30f0cSJun-ichiro itojun Hagino * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
5973b30f0cSJun-ichiro itojun Hagino * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
6073b30f0cSJun-ichiro itojun Hagino * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
6173b30f0cSJun-ichiro itojun Hagino * SUCH DAMAGE.
6273b30f0cSJun-ichiro itojun Hagino * -
6373b30f0cSJun-ichiro itojun Hagino * Portions Copyright (c) 1993 by Digital Equipment Corporation.
6473b30f0cSJun-ichiro itojun Hagino *
6573b30f0cSJun-ichiro itojun Hagino * Permission to use, copy, modify, and distribute this software for any
6673b30f0cSJun-ichiro itojun Hagino * purpose with or without fee is hereby granted, provided that the above
6773b30f0cSJun-ichiro itojun Hagino * copyright notice and this permission notice appear in all copies, and that
6873b30f0cSJun-ichiro itojun Hagino * the name of Digital Equipment Corporation not be used in advertising or
6973b30f0cSJun-ichiro itojun Hagino * publicity pertaining to distribution of the document or software without
7073b30f0cSJun-ichiro itojun Hagino * specific, written prior permission.
7173b30f0cSJun-ichiro itojun Hagino *
7273b30f0cSJun-ichiro itojun Hagino * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
7373b30f0cSJun-ichiro itojun Hagino * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
7473b30f0cSJun-ichiro itojun Hagino * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
7573b30f0cSJun-ichiro itojun Hagino * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
7673b30f0cSJun-ichiro itojun Hagino * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
7773b30f0cSJun-ichiro itojun Hagino * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
7873b30f0cSJun-ichiro itojun Hagino * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
7973b30f0cSJun-ichiro itojun Hagino * SOFTWARE.
8073b30f0cSJun-ichiro itojun Hagino * -
8173b30f0cSJun-ichiro itojun Hagino * --Copyright--
8273b30f0cSJun-ichiro itojun Hagino */
8373b30f0cSJun-ichiro itojun Hagino
847d56d374SYoshinobu Inoue /*
857d56d374SYoshinobu Inoue * Atsushi Onoe <onoe@sm.sony.co.jp>
867d56d374SYoshinobu Inoue */
877d56d374SYoshinobu Inoue
88d201fe46SDaniel Eischen #include "namespace.h"
897d56d374SYoshinobu Inoue #include <sys/param.h>
907d56d374SYoshinobu Inoue #include <sys/socket.h>
917d56d374SYoshinobu Inoue #include <sys/time.h>
92e6f35403SYoshinobu Inoue #include <sys/queue.h>
937d56d374SYoshinobu Inoue #include <netinet/in.h>
94b8b31f33SHajimu UMEMOTO #ifdef INET6
95b8b31f33SHajimu UMEMOTO #include <net/if.h>
96b8b31f33SHajimu UMEMOTO #include <sys/sysctl.h>
97146cd1bcSHajimu UMEMOTO #include <sys/ioctl.h>
98b8b31f33SHajimu UMEMOTO #include <netinet6/in6_var.h> /* XXX */
99b8b31f33SHajimu UMEMOTO #endif
1007d56d374SYoshinobu Inoue
1017d56d374SYoshinobu Inoue #include <arpa/inet.h>
1027d56d374SYoshinobu Inoue #include <arpa/nameser.h>
1037d56d374SYoshinobu Inoue
104e6f35403SYoshinobu Inoue #include <errno.h>
1057d56d374SYoshinobu Inoue #include <netdb.h>
1067d56d374SYoshinobu Inoue #include <resolv.h>
1077d56d374SYoshinobu Inoue #include <stdio.h>
1087d56d374SYoshinobu Inoue #include <stdlib.h>
1097d56d374SYoshinobu Inoue #include <string.h>
110248aee62SJacques Vidrine #include <stdarg.h>
111248aee62SJacques Vidrine #include <nsswitch.h>
1127d56d374SYoshinobu Inoue #include <unistd.h>
113d201fe46SDaniel Eischen #include "un-namespace.h"
114bcb131aaSHajimu UMEMOTO #include "netdb_private.h"
1155342d17fSHajimu UMEMOTO #include "res_private.h"
1167d56d374SYoshinobu Inoue
1177d56d374SYoshinobu Inoue #ifndef MAXALIASES
1187d56d374SYoshinobu Inoue #define MAXALIASES 10
1197d56d374SYoshinobu Inoue #endif
1207d56d374SYoshinobu Inoue #ifndef MAXADDRS
1217d56d374SYoshinobu Inoue #define MAXADDRS 20
1227d56d374SYoshinobu Inoue #endif
1237d56d374SYoshinobu Inoue #ifndef MAXDNAME
1247d56d374SYoshinobu Inoue #define MAXDNAME 1025
1257d56d374SYoshinobu Inoue #endif
1267d56d374SYoshinobu Inoue
1277d56d374SYoshinobu Inoue #ifdef INET6
1287d56d374SYoshinobu Inoue #define ADDRLEN(af) ((af) == AF_INET6 ? sizeof(struct in6_addr) : \
1297d56d374SYoshinobu Inoue sizeof(struct in_addr))
1307d56d374SYoshinobu Inoue #else
1317d56d374SYoshinobu Inoue #define ADDRLEN(af) sizeof(struct in_addr)
1327d56d374SYoshinobu Inoue #endif
1337d56d374SYoshinobu Inoue
1347d56d374SYoshinobu Inoue #define MAPADDR(ab, ina) \
1357d56d374SYoshinobu Inoue do { \
1367d56d374SYoshinobu Inoue memcpy(&(ab)->map_inaddr, ina, sizeof(struct in_addr)); \
1377d56d374SYoshinobu Inoue memset((ab)->map_zero, 0, sizeof((ab)->map_zero)); \
1387d56d374SYoshinobu Inoue memset((ab)->map_one, 0xff, sizeof((ab)->map_one)); \
1397d56d374SYoshinobu Inoue } while (0)
1407d56d374SYoshinobu Inoue #define MAPADDRENABLED(flags) \
1417d56d374SYoshinobu Inoue (((flags) & AI_V4MAPPED) || \
1423e83e4a3SMichael Bushkov (((flags) & AI_V4MAPPED_CFG)))
1437d56d374SYoshinobu Inoue
1447d56d374SYoshinobu Inoue union inx_addr {
1457d56d374SYoshinobu Inoue struct in_addr in_addr;
1467d56d374SYoshinobu Inoue #ifdef INET6
1477d56d374SYoshinobu Inoue struct in6_addr in6_addr;
1487d56d374SYoshinobu Inoue #endif
1497d56d374SYoshinobu Inoue struct {
1507d56d374SYoshinobu Inoue u_char mau_zero[10];
1517d56d374SYoshinobu Inoue u_char mau_one[2];
1527d56d374SYoshinobu Inoue struct in_addr mau_inaddr;
1537d56d374SYoshinobu Inoue } map_addr_un;
1547d56d374SYoshinobu Inoue #define map_zero map_addr_un.mau_zero
1557d56d374SYoshinobu Inoue #define map_one map_addr_un.mau_one
1567d56d374SYoshinobu Inoue #define map_inaddr map_addr_un.mau_inaddr
1577d56d374SYoshinobu Inoue };
1587d56d374SYoshinobu Inoue
159b8b31f33SHajimu UMEMOTO struct policyqueue {
160b8b31f33SHajimu UMEMOTO TAILQ_ENTRY(policyqueue) pc_entry;
161b8b31f33SHajimu UMEMOTO #ifdef INET6
162b8b31f33SHajimu UMEMOTO struct in6_addrpolicy pc_policy;
163b8b31f33SHajimu UMEMOTO #endif
164b8b31f33SHajimu UMEMOTO };
165b8b31f33SHajimu UMEMOTO TAILQ_HEAD(policyhead, policyqueue);
166b8b31f33SHajimu UMEMOTO
167146cd1bcSHajimu UMEMOTO #define AIO_SRCFLAG_DEPRECATED 0x1
168146cd1bcSHajimu UMEMOTO
169146cd1bcSHajimu UMEMOTO struct hp_order {
170146cd1bcSHajimu UMEMOTO union {
171146cd1bcSHajimu UMEMOTO struct sockaddr_storage aiou_ss;
172146cd1bcSHajimu UMEMOTO struct sockaddr aiou_sa;
173146cd1bcSHajimu UMEMOTO } aio_src_un;
174146cd1bcSHajimu UMEMOTO #define aio_srcsa aio_src_un.aiou_sa
175146cd1bcSHajimu UMEMOTO u_int32_t aio_srcflag;
176146cd1bcSHajimu UMEMOTO int aio_srcscope;
177146cd1bcSHajimu UMEMOTO int aio_dstscope;
178146cd1bcSHajimu UMEMOTO struct policyqueue *aio_srcpolicy;
179146cd1bcSHajimu UMEMOTO struct policyqueue *aio_dstpolicy;
180146cd1bcSHajimu UMEMOTO union {
181146cd1bcSHajimu UMEMOTO struct sockaddr_storage aiou_ss;
182146cd1bcSHajimu UMEMOTO struct sockaddr aiou_sa;
183146cd1bcSHajimu UMEMOTO } aio_un;
184146cd1bcSHajimu UMEMOTO #define aio_sa aio_un.aiou_sa
185146cd1bcSHajimu UMEMOTO int aio_matchlen;
186d6fd3ed8SHajimu UMEMOTO char *aio_h_addr;
187af98aa6eSAndrey A. Chernov int aio_initial_sequence;
188146cd1bcSHajimu UMEMOTO };
189146cd1bcSHajimu UMEMOTO
1905342d17fSHajimu UMEMOTO static struct hostent *_hpcopy(struct hostent *, int *);
1915342d17fSHajimu UMEMOTO static struct hostent *_hpaddr(int, const char *, void *, int *);
1927d56d374SYoshinobu Inoue #ifdef INET6
1933e83e4a3SMichael Bushkov static struct hostent *_hpmerge(struct hostent *, struct hostent *, int *);
1945342d17fSHajimu UMEMOTO static struct hostent *_hpmapv6(struct hostent *, int *);
1957d56d374SYoshinobu Inoue #endif
1965342d17fSHajimu UMEMOTO static struct hostent *_hpsort(struct hostent *, res_state);
1977d56d374SYoshinobu Inoue
198f09c52c3SHajimu UMEMOTO #ifdef INET6
1995342d17fSHajimu UMEMOTO static struct hostent *_hpreorder(struct hostent *);
200b8b31f33SHajimu UMEMOTO static int get_addrselectpolicy(struct policyhead *);
201b8b31f33SHajimu UMEMOTO static void free_addrselectpolicy(struct policyhead *);
202b8b31f33SHajimu UMEMOTO static struct policyqueue *match_addrselectpolicy(struct sockaddr *,
203b8b31f33SHajimu UMEMOTO struct policyhead *);
204146cd1bcSHajimu UMEMOTO static void set_source(struct hp_order *, struct policyhead *);
205146cd1bcSHajimu UMEMOTO static int matchlen(struct sockaddr *, struct sockaddr *);
206146cd1bcSHajimu UMEMOTO static int comp_dst(const void *, const void *);
207146cd1bcSHajimu UMEMOTO static int gai_addr2scopetype(struct sockaddr *);
208d38f4eadSHajimu UMEMOTO #endif
209b8b31f33SHajimu UMEMOTO
2107d56d374SYoshinobu Inoue /*
2117d56d374SYoshinobu Inoue * Functions defined in RFC2553
21273b30f0cSJun-ichiro itojun Hagino * getipnodebyname, getipnodebyaddr, freehostent
2137d56d374SYoshinobu Inoue */
2147d56d374SYoshinobu Inoue
2153e83e4a3SMichael Bushkov struct hostent *
getipnodebyname(const char * name,int af,int flags,int * errp)2163e83e4a3SMichael Bushkov getipnodebyname(const char *name, int af, int flags, int *errp)
2177d56d374SYoshinobu Inoue {
2187d56d374SYoshinobu Inoue struct hostent *hp;
2193e83e4a3SMichael Bushkov union inx_addr addrbuf;
2203e83e4a3SMichael Bushkov res_state statp;
2213e83e4a3SMichael Bushkov u_long options;
222248aee62SJacques Vidrine
2233e83e4a3SMichael Bushkov switch (af) {
2243e83e4a3SMichael Bushkov case AF_INET:
2253e83e4a3SMichael Bushkov #ifdef INET6
2263e83e4a3SMichael Bushkov case AF_INET6:
22706a99fe3SHajimu UMEMOTO #endif
2283e83e4a3SMichael Bushkov break;
2293e83e4a3SMichael Bushkov default:
2303e83e4a3SMichael Bushkov *errp = NO_RECOVERY;
2313e83e4a3SMichael Bushkov return NULL;
2323e83e4a3SMichael Bushkov }
2337d56d374SYoshinobu Inoue
2347d56d374SYoshinobu Inoue if (flags & AI_ADDRCONFIG) {
2357d56d374SYoshinobu Inoue int s;
2367d56d374SYoshinobu Inoue
23772531978SJilles Tjoelker if ((s = _socket(af, SOCK_DGRAM | SOCK_CLOEXEC, 0)) < 0)
2380fbf0979SHajimu UMEMOTO return NULL;
2397d56d374SYoshinobu Inoue /*
2407d56d374SYoshinobu Inoue * TODO:
2417d56d374SYoshinobu Inoue * Note that implementation dependent test for address
2427d56d374SYoshinobu Inoue * configuration should be done every time called
24332223c1bSPedro F. Giffuni * (or appropriate interval),
2447d56d374SYoshinobu Inoue * because addresses will be dynamically assigned or deleted.
2457d56d374SYoshinobu Inoue */
2469233c4d9SJason Evans _close(s);
2477d56d374SYoshinobu Inoue }
2487d56d374SYoshinobu Inoue
2497d56d374SYoshinobu Inoue #ifdef INET6
2507d56d374SYoshinobu Inoue /* special case for literal address */
2517d56d374SYoshinobu Inoue if (inet_pton(AF_INET6, name, &addrbuf) == 1) {
2527d56d374SYoshinobu Inoue if (af != AF_INET6) {
2537d56d374SYoshinobu Inoue *errp = HOST_NOT_FOUND;
2547d56d374SYoshinobu Inoue return NULL;
2557d56d374SYoshinobu Inoue }
2567d56d374SYoshinobu Inoue return _hpaddr(af, name, &addrbuf, errp);
2577d56d374SYoshinobu Inoue }
2587d56d374SYoshinobu Inoue #endif
259be26adb5SYoshinobu Inoue if (inet_aton(name, (struct in_addr *)&addrbuf) == 1) {
2607d56d374SYoshinobu Inoue if (af != AF_INET) {
2617d56d374SYoshinobu Inoue if (MAPADDRENABLED(flags)) {
2627d56d374SYoshinobu Inoue MAPADDR(&addrbuf, &addrbuf.in_addr);
2637d56d374SYoshinobu Inoue } else {
2647d56d374SYoshinobu Inoue *errp = HOST_NOT_FOUND;
2657d56d374SYoshinobu Inoue return NULL;
2667d56d374SYoshinobu Inoue }
2677d56d374SYoshinobu Inoue }
2687d56d374SYoshinobu Inoue return _hpaddr(af, name, &addrbuf, errp);
2697d56d374SYoshinobu Inoue }
2707d56d374SYoshinobu Inoue
2713e83e4a3SMichael Bushkov
2725342d17fSHajimu UMEMOTO statp = __res_state();
2735342d17fSHajimu UMEMOTO if ((statp->options & RES_INIT) == 0) {
2745342d17fSHajimu UMEMOTO if (res_ninit(statp) < 0) {
2755342d17fSHajimu UMEMOTO *errp = NETDB_INTERNAL;
2765342d17fSHajimu UMEMOTO return NULL;
2775342d17fSHajimu UMEMOTO }
2785342d17fSHajimu UMEMOTO }
2795342d17fSHajimu UMEMOTO
2803e83e4a3SMichael Bushkov options = statp->options;
2813e83e4a3SMichael Bushkov statp->options &= ~RES_USE_INET6;
2823e83e4a3SMichael Bushkov
2833e83e4a3SMichael Bushkov hp = gethostbyname2(name, af);
2843e83e4a3SMichael Bushkov hp = _hpcopy(hp, errp);
2857d56d374SYoshinobu Inoue #ifdef INET6
286f09c52c3SHajimu UMEMOTO if (af == AF_INET6)
287f09c52c3SHajimu UMEMOTO hp = _hpreorder(hp);
288f09c52c3SHajimu UMEMOTO
289946e41f1SHajimu UMEMOTO if (af == AF_INET6 && ((flags & AI_ALL) || hp == NULL) &&
290946e41f1SHajimu UMEMOTO MAPADDRENABLED(flags)) {
2913e83e4a3SMichael Bushkov struct hostent *hp2 = gethostbyname2(name, AF_INET);
2927d56d374SYoshinobu Inoue if (hp == NULL)
2933e83e4a3SMichael Bushkov if (hp2 == NULL)
2943e83e4a3SMichael Bushkov *errp = statp->res_h_errno;
2953e83e4a3SMichael Bushkov else
2967d56d374SYoshinobu Inoue hp = _hpmapv6(hp2, errp);
2977d56d374SYoshinobu Inoue else {
2983e83e4a3SMichael Bushkov if (hp2 && strcmp(hp->h_name, hp2->h_name) == 0) {
2993e83e4a3SMichael Bushkov struct hostent *hpb = hp;
3003e83e4a3SMichael Bushkov hp = _hpmerge(hpb, hp2, errp);
3013e83e4a3SMichael Bushkov freehostent(hpb);
3027d56d374SYoshinobu Inoue }
3037d56d374SYoshinobu Inoue }
3047d56d374SYoshinobu Inoue }
3057d56d374SYoshinobu Inoue #endif
3063e83e4a3SMichael Bushkov
3073e83e4a3SMichael Bushkov if (hp == NULL)
3083e83e4a3SMichael Bushkov *errp = statp->res_h_errno;
3093e83e4a3SMichael Bushkov
3103e83e4a3SMichael Bushkov statp->options = options;
311d38f4eadSHajimu UMEMOTO return _hpsort(hp, statp);
3127d56d374SYoshinobu Inoue }
3137d56d374SYoshinobu Inoue
3147d56d374SYoshinobu Inoue struct hostent *
getipnodebyaddr(const void * src,size_t len,int af,int * errp)3157d56d374SYoshinobu Inoue getipnodebyaddr(const void *src, size_t len, int af, int *errp)
3167d56d374SYoshinobu Inoue {
3177d56d374SYoshinobu Inoue struct hostent *hp;
3183e83e4a3SMichael Bushkov res_state statp;
3193e83e4a3SMichael Bushkov u_long options;
3203e83e4a3SMichael Bushkov
3217d56d374SYoshinobu Inoue #ifdef INET6
3227d56d374SYoshinobu Inoue struct in6_addr addrbuf;
3237d56d374SYoshinobu Inoue #else
3247d56d374SYoshinobu Inoue struct in_addr addrbuf;
3257d56d374SYoshinobu Inoue #endif
3267d56d374SYoshinobu Inoue
3277d56d374SYoshinobu Inoue switch (af) {
3287d56d374SYoshinobu Inoue case AF_INET:
3297d56d374SYoshinobu Inoue if (len != sizeof(struct in_addr)) {
3307d56d374SYoshinobu Inoue *errp = NO_RECOVERY;
3317d56d374SYoshinobu Inoue return NULL;
3327d56d374SYoshinobu Inoue }
33375a5de5aSPedro F. Giffuni if (rounddown2((long)src, sizeof(struct in_addr))) {
3347d56d374SYoshinobu Inoue memcpy(&addrbuf, src, len);
3357d56d374SYoshinobu Inoue src = &addrbuf;
3367d56d374SYoshinobu Inoue }
3377d56d374SYoshinobu Inoue if (((struct in_addr *)src)->s_addr == 0)
3387d56d374SYoshinobu Inoue return NULL;
3397d56d374SYoshinobu Inoue break;
3407d56d374SYoshinobu Inoue #ifdef INET6
3417d56d374SYoshinobu Inoue case AF_INET6:
3427d56d374SYoshinobu Inoue if (len != sizeof(struct in6_addr)) {
3437d56d374SYoshinobu Inoue *errp = NO_RECOVERY;
3447d56d374SYoshinobu Inoue return NULL;
3457d56d374SYoshinobu Inoue }
34675a5de5aSPedro F. Giffuni if (rounddown2((long)src, sizeof(struct in6_addr) / 2)) {
34775a5de5aSPedro F. Giffuni /* XXX */
3487d56d374SYoshinobu Inoue memcpy(&addrbuf, src, len);
3497d56d374SYoshinobu Inoue src = &addrbuf;
3507d56d374SYoshinobu Inoue }
3513d670abcSYoshinobu Inoue if (IN6_IS_ADDR_UNSPECIFIED((struct in6_addr *)src))
3523d670abcSYoshinobu Inoue return NULL;
3537d56d374SYoshinobu Inoue if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)src)
3547d56d374SYoshinobu Inoue || IN6_IS_ADDR_V4COMPAT((struct in6_addr *)src)) {
3557d56d374SYoshinobu Inoue src = (char *)src +
3567d56d374SYoshinobu Inoue (sizeof(struct in6_addr) - sizeof(struct in_addr));
3577d56d374SYoshinobu Inoue af = AF_INET;
3587d56d374SYoshinobu Inoue len = sizeof(struct in_addr);
3597d56d374SYoshinobu Inoue }
3607d56d374SYoshinobu Inoue break;
3617d56d374SYoshinobu Inoue #endif
3627d56d374SYoshinobu Inoue default:
3637d56d374SYoshinobu Inoue *errp = NO_RECOVERY;
3647d56d374SYoshinobu Inoue return NULL;
3657d56d374SYoshinobu Inoue }
3667d56d374SYoshinobu Inoue
3673e83e4a3SMichael Bushkov statp = __res_state();
3683e83e4a3SMichael Bushkov if ((statp->options & RES_INIT) == 0) {
3693e83e4a3SMichael Bushkov if (res_ninit(statp) < 0) {
3703e83e4a3SMichael Bushkov RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
3713e83e4a3SMichael Bushkov return NULL;
3723e83e4a3SMichael Bushkov }
3733e83e4a3SMichael Bushkov }
3743e83e4a3SMichael Bushkov
3753e83e4a3SMichael Bushkov options = statp->options;
3763e83e4a3SMichael Bushkov statp->options &= ~RES_USE_INET6;
3773e83e4a3SMichael Bushkov
3783e83e4a3SMichael Bushkov hp = gethostbyaddr(src, len, af);
3793e83e4a3SMichael Bushkov if (hp == NULL)
3803e83e4a3SMichael Bushkov *errp = statp->res_h_errno;
3813e83e4a3SMichael Bushkov
3823e83e4a3SMichael Bushkov statp->options = options;
3833e83e4a3SMichael Bushkov return (_hpcopy(hp, errp));
3847d56d374SYoshinobu Inoue }
3857d56d374SYoshinobu Inoue
3867d56d374SYoshinobu Inoue void
freehostent(struct hostent * ptr)3877d56d374SYoshinobu Inoue freehostent(struct hostent *ptr)
3887d56d374SYoshinobu Inoue {
3897d56d374SYoshinobu Inoue free(ptr);
3907d56d374SYoshinobu Inoue }
3917d56d374SYoshinobu Inoue
3927d56d374SYoshinobu Inoue /*
3937d56d374SYoshinobu Inoue * Private utility functions
3947d56d374SYoshinobu Inoue */
3957d56d374SYoshinobu Inoue
3967d56d374SYoshinobu Inoue /*
3977d56d374SYoshinobu Inoue * _hpcopy: allocate and copy hostent structure
3987d56d374SYoshinobu Inoue */
3997d56d374SYoshinobu Inoue static struct hostent *
_hpcopy(struct hostent * hp,int * errp)4007d56d374SYoshinobu Inoue _hpcopy(struct hostent *hp, int *errp)
4017d56d374SYoshinobu Inoue {
4027d56d374SYoshinobu Inoue struct hostent *nhp;
4037d56d374SYoshinobu Inoue char *cp, **pp;
4047d56d374SYoshinobu Inoue int size, addrsize;
4057d56d374SYoshinobu Inoue int nalias = 0, naddr = 0;
4067d56d374SYoshinobu Inoue int al_off;
4077d56d374SYoshinobu Inoue int i;
4087d56d374SYoshinobu Inoue
4097d56d374SYoshinobu Inoue if (hp == NULL)
4107d56d374SYoshinobu Inoue return hp;
4117d56d374SYoshinobu Inoue
4127d56d374SYoshinobu Inoue /* count size to be allocated */
4137d56d374SYoshinobu Inoue size = sizeof(struct hostent);
41405c36511SHajimu UMEMOTO if (hp->h_name != NULL)
4157d56d374SYoshinobu Inoue size += strlen(hp->h_name) + 1;
4167d56d374SYoshinobu Inoue if ((pp = hp->h_aliases) != NULL) {
4177d56d374SYoshinobu Inoue for (i = 0; *pp != NULL; i++, pp++) {
4187d56d374SYoshinobu Inoue if (**pp != '\0') {
4197d56d374SYoshinobu Inoue size += strlen(*pp) + 1;
4207d56d374SYoshinobu Inoue nalias++;
4217d56d374SYoshinobu Inoue }
4227d56d374SYoshinobu Inoue }
4237d56d374SYoshinobu Inoue }
4247d56d374SYoshinobu Inoue /* adjust alignment */
4257d56d374SYoshinobu Inoue size = ALIGN(size);
4267d56d374SYoshinobu Inoue al_off = size;
4277d56d374SYoshinobu Inoue size += sizeof(char *) * (nalias + 1);
4287d56d374SYoshinobu Inoue addrsize = ALIGN(hp->h_length);
4297d56d374SYoshinobu Inoue if ((pp = hp->h_addr_list) != NULL) {
4307d56d374SYoshinobu Inoue while (*pp++ != NULL)
4317d56d374SYoshinobu Inoue naddr++;
4327d56d374SYoshinobu Inoue }
4337d56d374SYoshinobu Inoue size += addrsize * naddr;
4347d56d374SYoshinobu Inoue size += sizeof(char *) * (naddr + 1);
4357d56d374SYoshinobu Inoue
4367d56d374SYoshinobu Inoue /* copy */
4377d56d374SYoshinobu Inoue if ((nhp = (struct hostent *)malloc(size)) == NULL) {
4387d56d374SYoshinobu Inoue *errp = TRY_AGAIN;
4397d56d374SYoshinobu Inoue return NULL;
4407d56d374SYoshinobu Inoue }
4417d56d374SYoshinobu Inoue cp = (char *)&nhp[1];
44205c36511SHajimu UMEMOTO if (hp->h_name != NULL) {
4437d56d374SYoshinobu Inoue nhp->h_name = cp;
4447d56d374SYoshinobu Inoue strcpy(cp, hp->h_name);
4457d56d374SYoshinobu Inoue cp += strlen(cp) + 1;
4467d56d374SYoshinobu Inoue } else
4477d56d374SYoshinobu Inoue nhp->h_name = NULL;
4487d56d374SYoshinobu Inoue nhp->h_aliases = (char **)((char *)nhp + al_off);
4497d56d374SYoshinobu Inoue if ((pp = hp->h_aliases) != NULL) {
4507d56d374SYoshinobu Inoue for (i = 0; *pp != NULL; pp++) {
4517d56d374SYoshinobu Inoue if (**pp != '\0') {
4527d56d374SYoshinobu Inoue nhp->h_aliases[i++] = cp;
4537d56d374SYoshinobu Inoue strcpy(cp, *pp);
4547d56d374SYoshinobu Inoue cp += strlen(cp) + 1;
4557d56d374SYoshinobu Inoue }
4567d56d374SYoshinobu Inoue }
4577d56d374SYoshinobu Inoue }
4587d56d374SYoshinobu Inoue nhp->h_aliases[nalias] = NULL;
4597d56d374SYoshinobu Inoue cp = (char *)&nhp->h_aliases[nalias + 1];
4607d56d374SYoshinobu Inoue nhp->h_addrtype = hp->h_addrtype;
4617d56d374SYoshinobu Inoue nhp->h_length = hp->h_length;
4627d56d374SYoshinobu Inoue nhp->h_addr_list = (char **)cp;
4637d56d374SYoshinobu Inoue if ((pp = hp->h_addr_list) != NULL) {
4647d56d374SYoshinobu Inoue cp = (char *)&nhp->h_addr_list[naddr + 1];
4657d56d374SYoshinobu Inoue for (i = 0; *pp != NULL; pp++) {
4667d56d374SYoshinobu Inoue nhp->h_addr_list[i++] = cp;
4677d56d374SYoshinobu Inoue memcpy(cp, *pp, hp->h_length);
4687d56d374SYoshinobu Inoue cp += addrsize;
4697d56d374SYoshinobu Inoue }
4707d56d374SYoshinobu Inoue }
4717d56d374SYoshinobu Inoue nhp->h_addr_list[naddr] = NULL;
4727d56d374SYoshinobu Inoue return nhp;
4737d56d374SYoshinobu Inoue }
4747d56d374SYoshinobu Inoue
4757d56d374SYoshinobu Inoue /*
4767d56d374SYoshinobu Inoue * _hpaddr: construct hostent structure with one address
4777d56d374SYoshinobu Inoue */
4787d56d374SYoshinobu Inoue static struct hostent *
_hpaddr(int af,const char * name,void * addr,int * errp)4797d56d374SYoshinobu Inoue _hpaddr(int af, const char *name, void *addr, int *errp)
4807d56d374SYoshinobu Inoue {
4817d56d374SYoshinobu Inoue struct hostent *hp, hpbuf;
4827d56d374SYoshinobu Inoue char *addrs[2];
4837d56d374SYoshinobu Inoue
4847d56d374SYoshinobu Inoue hp = &hpbuf;
4857d56d374SYoshinobu Inoue hp->h_name = (char *)name;
4867d56d374SYoshinobu Inoue hp->h_aliases = NULL;
4877d56d374SYoshinobu Inoue hp->h_addrtype = af;
4887d56d374SYoshinobu Inoue hp->h_length = ADDRLEN(af);
4897d56d374SYoshinobu Inoue hp->h_addr_list = addrs;
4907d56d374SYoshinobu Inoue addrs[0] = (char *)addr;
4917d56d374SYoshinobu Inoue addrs[1] = NULL;
4923e83e4a3SMichael Bushkov return (_hpcopy(hp, errp));
4937d56d374SYoshinobu Inoue }
4947d56d374SYoshinobu Inoue
4953e83e4a3SMichael Bushkov #ifdef INET6
4967d56d374SYoshinobu Inoue /*
4977d56d374SYoshinobu Inoue * _hpmerge: merge 2 hostent structure, arguments will be freed
4987d56d374SYoshinobu Inoue */
4997d56d374SYoshinobu Inoue static struct hostent *
_hpmerge(struct hostent * hp1,struct hostent * hp2,int * errp)5007d56d374SYoshinobu Inoue _hpmerge(struct hostent *hp1, struct hostent *hp2, int *errp)
5017d56d374SYoshinobu Inoue {
5027d56d374SYoshinobu Inoue int i, j;
5037d56d374SYoshinobu Inoue int naddr, nalias;
5047d56d374SYoshinobu Inoue char **pp;
5057d56d374SYoshinobu Inoue struct hostent *hp, hpbuf;
5067d56d374SYoshinobu Inoue char *aliases[MAXALIASES + 1], *addrs[MAXADDRS + 1];
5077d56d374SYoshinobu Inoue union inx_addr addrbuf[MAXADDRS];
5087d56d374SYoshinobu Inoue
5097d56d374SYoshinobu Inoue if (hp1 == NULL)
5103e83e4a3SMichael Bushkov return _hpcopy(hp2, errp);
5117d56d374SYoshinobu Inoue if (hp2 == NULL)
5123e83e4a3SMichael Bushkov return _hpcopy(hp1, errp);
5137d56d374SYoshinobu Inoue
5147d56d374SYoshinobu Inoue #define HP(i) (i == 1 ? hp1 : hp2)
5157d56d374SYoshinobu Inoue hp = &hpbuf;
5167d56d374SYoshinobu Inoue hp->h_name = (hp1->h_name != NULL ? hp1->h_name : hp2->h_name);
5177d56d374SYoshinobu Inoue hp->h_aliases = aliases;
5187d56d374SYoshinobu Inoue nalias = 0;
5197d56d374SYoshinobu Inoue for (i = 1; i <= 2; i++) {
5207d56d374SYoshinobu Inoue if ((pp = HP(i)->h_aliases) == NULL)
5217d56d374SYoshinobu Inoue continue;
5227d56d374SYoshinobu Inoue for (; nalias < MAXALIASES && *pp != NULL; pp++) {
5237d56d374SYoshinobu Inoue /* check duplicates */
5247d56d374SYoshinobu Inoue for (j = 0; j < nalias; j++)
5257d56d374SYoshinobu Inoue if (strcasecmp(*pp, aliases[j]) == 0)
5267d56d374SYoshinobu Inoue break;
5277d56d374SYoshinobu Inoue if (j == nalias)
5287d56d374SYoshinobu Inoue aliases[nalias++] = *pp;
5297d56d374SYoshinobu Inoue }
5307d56d374SYoshinobu Inoue }
5317d56d374SYoshinobu Inoue aliases[nalias] = NULL;
5327d56d374SYoshinobu Inoue if (hp1->h_length != hp2->h_length) {
5337d56d374SYoshinobu Inoue hp->h_addrtype = AF_INET6;
5347d56d374SYoshinobu Inoue hp->h_length = sizeof(struct in6_addr);
5357d56d374SYoshinobu Inoue } else {
5367d56d374SYoshinobu Inoue hp->h_addrtype = hp1->h_addrtype;
5377d56d374SYoshinobu Inoue hp->h_length = hp1->h_length;
5387d56d374SYoshinobu Inoue }
5393e83e4a3SMichael Bushkov
5407d56d374SYoshinobu Inoue hp->h_addr_list = addrs;
5417d56d374SYoshinobu Inoue naddr = 0;
5427d56d374SYoshinobu Inoue for (i = 1; i <= 2; i++) {
5437d56d374SYoshinobu Inoue if ((pp = HP(i)->h_addr_list) == NULL)
5447d56d374SYoshinobu Inoue continue;
5457d56d374SYoshinobu Inoue if (HP(i)->h_length == hp->h_length) {
5467d56d374SYoshinobu Inoue while (naddr < MAXADDRS && *pp != NULL)
5477d56d374SYoshinobu Inoue addrs[naddr++] = *pp++;
5487d56d374SYoshinobu Inoue } else {
5497d56d374SYoshinobu Inoue /* copy IPv4 addr as mapped IPv6 addr */
5507d56d374SYoshinobu Inoue while (naddr < MAXADDRS && *pp != NULL) {
5517d56d374SYoshinobu Inoue MAPADDR(&addrbuf[naddr], *pp++);
5527d56d374SYoshinobu Inoue addrs[naddr] = (char *)&addrbuf[naddr];
5537d56d374SYoshinobu Inoue naddr++;
5547d56d374SYoshinobu Inoue }
5557d56d374SYoshinobu Inoue }
5567d56d374SYoshinobu Inoue }
5577d56d374SYoshinobu Inoue addrs[naddr] = NULL;
5583e83e4a3SMichael Bushkov return (_hpcopy(hp, errp));
5597d56d374SYoshinobu Inoue }
5603e83e4a3SMichael Bushkov #endif
5617d56d374SYoshinobu Inoue
5627d56d374SYoshinobu Inoue /*
5637d56d374SYoshinobu Inoue * _hpmapv6: convert IPv4 hostent into IPv4-mapped IPv6 addresses
5647d56d374SYoshinobu Inoue */
5657d56d374SYoshinobu Inoue #ifdef INET6
5667d56d374SYoshinobu Inoue static struct hostent *
_hpmapv6(struct hostent * hp,int * errp)5677d56d374SYoshinobu Inoue _hpmapv6(struct hostent *hp, int *errp)
5687d56d374SYoshinobu Inoue {
5693e83e4a3SMichael Bushkov struct hostent hp6;
5707d56d374SYoshinobu Inoue
5717d56d374SYoshinobu Inoue if (hp == NULL)
5727d56d374SYoshinobu Inoue return NULL;
5737d56d374SYoshinobu Inoue if (hp->h_addrtype == AF_INET6)
5743e83e4a3SMichael Bushkov return _hpcopy(hp, errp);
5757d56d374SYoshinobu Inoue
5763e83e4a3SMichael Bushkov memset(&hp6, 0, sizeof(struct hostent));
5773e83e4a3SMichael Bushkov hp6.h_addrtype = AF_INET6;
5783e83e4a3SMichael Bushkov hp6.h_length = sizeof(struct in6_addr);
5793e83e4a3SMichael Bushkov return _hpmerge(&hp6, hp, errp);
5807d56d374SYoshinobu Inoue }
5817d56d374SYoshinobu Inoue #endif
5827d56d374SYoshinobu Inoue
5837d56d374SYoshinobu Inoue /*
5847d56d374SYoshinobu Inoue * _hpsort: sort address by sortlist
5857d56d374SYoshinobu Inoue */
5867d56d374SYoshinobu Inoue static struct hostent *
_hpsort(struct hostent * hp,res_state statp)5875342d17fSHajimu UMEMOTO _hpsort(struct hostent *hp, res_state statp)
5887d56d374SYoshinobu Inoue {
5897d56d374SYoshinobu Inoue int i, j, n;
5907d56d374SYoshinobu Inoue u_char *ap, *sp, *mp, **pp;
5917d56d374SYoshinobu Inoue char t;
5927d56d374SYoshinobu Inoue char order[MAXADDRS];
5935342d17fSHajimu UMEMOTO int nsort = statp->nsort;
5947d56d374SYoshinobu Inoue
5957d56d374SYoshinobu Inoue if (hp == NULL || hp->h_addr_list[1] == NULL || nsort == 0)
5967d56d374SYoshinobu Inoue return hp;
5977d56d374SYoshinobu Inoue for (i = 0; (ap = (u_char *)hp->h_addr_list[i]); i++) {
5987d56d374SYoshinobu Inoue for (j = 0; j < nsort; j++) {
5997d56d374SYoshinobu Inoue #ifdef INET6
6005342d17fSHajimu UMEMOTO if (statp->_u._ext.ext->sort_list[j].af !=
6015342d17fSHajimu UMEMOTO hp->h_addrtype)
6027d56d374SYoshinobu Inoue continue;
6035342d17fSHajimu UMEMOTO sp = (u_char *)&statp->_u._ext.ext->sort_list[j].addr;
6045342d17fSHajimu UMEMOTO mp = (u_char *)&statp->_u._ext.ext->sort_list[j].mask;
6057d56d374SYoshinobu Inoue #else
6065342d17fSHajimu UMEMOTO sp = (u_char *)&statp->sort_list[j].addr;
6075342d17fSHajimu UMEMOTO mp = (u_char *)&statp->sort_list[j].mask;
6087d56d374SYoshinobu Inoue #endif
6097d56d374SYoshinobu Inoue for (n = 0; n < hp->h_length; n++) {
6107d56d374SYoshinobu Inoue if ((ap[n] & mp[n]) != sp[n])
6117d56d374SYoshinobu Inoue break;
6127d56d374SYoshinobu Inoue }
6137d56d374SYoshinobu Inoue if (n == hp->h_length)
6147d56d374SYoshinobu Inoue break;
6157d56d374SYoshinobu Inoue }
6167d56d374SYoshinobu Inoue order[i] = j;
6177d56d374SYoshinobu Inoue }
6187d56d374SYoshinobu Inoue n = i;
6197d56d374SYoshinobu Inoue pp = (u_char **)hp->h_addr_list;
6207d56d374SYoshinobu Inoue for (i = 0; i < n - 1; i++) {
6217d56d374SYoshinobu Inoue for (j = i + 1; j < n; j++) {
6227d56d374SYoshinobu Inoue if (order[i] > order[j]) {
6237d56d374SYoshinobu Inoue ap = pp[i];
6247d56d374SYoshinobu Inoue pp[i] = pp[j];
6257d56d374SYoshinobu Inoue pp[j] = ap;
6267d56d374SYoshinobu Inoue t = order[i];
6277d56d374SYoshinobu Inoue order[i] = order[j];
6287d56d374SYoshinobu Inoue order[j] = t;
6297d56d374SYoshinobu Inoue }
6307d56d374SYoshinobu Inoue }
6317d56d374SYoshinobu Inoue }
6327d56d374SYoshinobu Inoue return hp;
6337d56d374SYoshinobu Inoue }
6347d56d374SYoshinobu Inoue
635f09c52c3SHajimu UMEMOTO #ifdef INET6
6367d56d374SYoshinobu Inoue /*
637b8b31f33SHajimu UMEMOTO * _hpreorder: sort address by default address selection
638b8b31f33SHajimu UMEMOTO */
639b8b31f33SHajimu UMEMOTO static struct hostent *
_hpreorder(struct hostent * hp)640b8b31f33SHajimu UMEMOTO _hpreorder(struct hostent *hp)
641b8b31f33SHajimu UMEMOTO {
642146cd1bcSHajimu UMEMOTO struct hp_order *aio;
643146cd1bcSHajimu UMEMOTO int i, n;
644d6fd3ed8SHajimu UMEMOTO char *ap;
645146cd1bcSHajimu UMEMOTO struct sockaddr *sa;
646b8b31f33SHajimu UMEMOTO struct policyhead policyhead;
647b8b31f33SHajimu UMEMOTO
648146cd1bcSHajimu UMEMOTO if (hp == NULL)
649b8b31f33SHajimu UMEMOTO return hp;
650b8b31f33SHajimu UMEMOTO
651b8b31f33SHajimu UMEMOTO switch (hp->h_addrtype) {
652b8b31f33SHajimu UMEMOTO case AF_INET:
653b8b31f33SHajimu UMEMOTO #ifdef INET6
654b8b31f33SHajimu UMEMOTO case AF_INET6:
655b8b31f33SHajimu UMEMOTO #endif
656146cd1bcSHajimu UMEMOTO break;
657b8b31f33SHajimu UMEMOTO default:
658b8b31f33SHajimu UMEMOTO return hp;
659b8b31f33SHajimu UMEMOTO }
660b8b31f33SHajimu UMEMOTO
661146cd1bcSHajimu UMEMOTO /* count the number of addrinfo elements for sorting. */
662146cd1bcSHajimu UMEMOTO for (n = 0; hp->h_addr_list[n] != NULL; n++)
663146cd1bcSHajimu UMEMOTO ;
664146cd1bcSHajimu UMEMOTO
665146cd1bcSHajimu UMEMOTO /*
666146cd1bcSHajimu UMEMOTO * If the number is small enough, we can skip the reordering process.
667146cd1bcSHajimu UMEMOTO */
668146cd1bcSHajimu UMEMOTO if (n <= 1)
669146cd1bcSHajimu UMEMOTO return hp;
670146cd1bcSHajimu UMEMOTO
671146cd1bcSHajimu UMEMOTO /* allocate a temporary array for sort and initialization of it. */
672146cd1bcSHajimu UMEMOTO if ((aio = malloc(sizeof(*aio) * n)) == NULL)
673146cd1bcSHajimu UMEMOTO return hp; /* give up reordering */
674146cd1bcSHajimu UMEMOTO memset(aio, 0, sizeof(*aio) * n);
675146cd1bcSHajimu UMEMOTO
676146cd1bcSHajimu UMEMOTO /* retrieve address selection policy from the kernel */
677146cd1bcSHajimu UMEMOTO TAILQ_INIT(&policyhead);
678146cd1bcSHajimu UMEMOTO if (!get_addrselectpolicy(&policyhead)) {
679146cd1bcSHajimu UMEMOTO /* no policy is installed into kernel, we don't sort. */
680146cd1bcSHajimu UMEMOTO free(aio);
681146cd1bcSHajimu UMEMOTO return hp;
682b8b31f33SHajimu UMEMOTO }
683b8b31f33SHajimu UMEMOTO
684146cd1bcSHajimu UMEMOTO for (i = 0; i < n; i++) {
685d6fd3ed8SHajimu UMEMOTO ap = hp->h_addr_list[i];
686146cd1bcSHajimu UMEMOTO aio[i].aio_h_addr = ap;
687146cd1bcSHajimu UMEMOTO sa = &aio[i].aio_sa;
688146cd1bcSHajimu UMEMOTO switch (hp->h_addrtype) {
689146cd1bcSHajimu UMEMOTO case AF_INET:
690146cd1bcSHajimu UMEMOTO sa->sa_family = AF_INET;
691146cd1bcSHajimu UMEMOTO sa->sa_len = sizeof(struct sockaddr_in);
692146cd1bcSHajimu UMEMOTO memcpy(&((struct sockaddr_in *)sa)->sin_addr, ap,
693146cd1bcSHajimu UMEMOTO sizeof(struct in_addr));
694146cd1bcSHajimu UMEMOTO break;
695146cd1bcSHajimu UMEMOTO #ifdef INET6
696146cd1bcSHajimu UMEMOTO case AF_INET6:
697146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) {
698146cd1bcSHajimu UMEMOTO sa->sa_family = AF_INET;
699146cd1bcSHajimu UMEMOTO sa->sa_len = sizeof(struct sockaddr_in);
700146cd1bcSHajimu UMEMOTO memcpy(&((struct sockaddr_in *)sa)->sin_addr,
701146cd1bcSHajimu UMEMOTO &ap[12], sizeof(struct in_addr));
702146cd1bcSHajimu UMEMOTO } else {
703146cd1bcSHajimu UMEMOTO sa->sa_family = AF_INET6;
704146cd1bcSHajimu UMEMOTO sa->sa_len = sizeof(struct sockaddr_in6);
705146cd1bcSHajimu UMEMOTO memcpy(&((struct sockaddr_in6 *)sa)->sin6_addr,
706146cd1bcSHajimu UMEMOTO ap, sizeof(struct in6_addr));
707146cd1bcSHajimu UMEMOTO }
708146cd1bcSHajimu UMEMOTO break;
709146cd1bcSHajimu UMEMOTO #endif
710146cd1bcSHajimu UMEMOTO }
711146cd1bcSHajimu UMEMOTO aio[i].aio_dstscope = gai_addr2scopetype(sa);
712146cd1bcSHajimu UMEMOTO aio[i].aio_dstpolicy = match_addrselectpolicy(sa, &policyhead);
713146cd1bcSHajimu UMEMOTO set_source(&aio[i], &policyhead);
714af98aa6eSAndrey A. Chernov aio[i].aio_initial_sequence = i;
715146cd1bcSHajimu UMEMOTO }
716146cd1bcSHajimu UMEMOTO
717146cd1bcSHajimu UMEMOTO /* perform sorting. */
718146cd1bcSHajimu UMEMOTO qsort(aio, n, sizeof(*aio), comp_dst);
719146cd1bcSHajimu UMEMOTO
720146cd1bcSHajimu UMEMOTO /* reorder the h_addr_list. */
721146cd1bcSHajimu UMEMOTO for (i = 0; i < n; i++)
722146cd1bcSHajimu UMEMOTO hp->h_addr_list[i] = aio[i].aio_h_addr;
723146cd1bcSHajimu UMEMOTO
724b8b31f33SHajimu UMEMOTO /* cleanup and return */
725146cd1bcSHajimu UMEMOTO free(aio);
726b8b31f33SHajimu UMEMOTO free_addrselectpolicy(&policyhead);
727b8b31f33SHajimu UMEMOTO return hp;
728b8b31f33SHajimu UMEMOTO }
729b8b31f33SHajimu UMEMOTO
730b8b31f33SHajimu UMEMOTO static int
get_addrselectpolicy(struct policyhead * head)73190d1d883SHajimu UMEMOTO get_addrselectpolicy(struct policyhead *head)
732b8b31f33SHajimu UMEMOTO {
733b8b31f33SHajimu UMEMOTO #ifdef INET6
734b8b31f33SHajimu UMEMOTO int mib[] = { CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_ADDRCTLPOLICY };
735b8b31f33SHajimu UMEMOTO size_t l;
736b8b31f33SHajimu UMEMOTO char *buf;
737b8b31f33SHajimu UMEMOTO struct in6_addrpolicy *pol, *ep;
738b8b31f33SHajimu UMEMOTO
739bf51882aSPedro F. Giffuni if (sysctl(mib, nitems(mib), NULL, &l, NULL, 0) < 0)
740b8b31f33SHajimu UMEMOTO return (0);
741b8b31f33SHajimu UMEMOTO if ((buf = malloc(l)) == NULL)
742b8b31f33SHajimu UMEMOTO return (0);
743bf51882aSPedro F. Giffuni if (sysctl(mib, nitems(mib), buf, &l, NULL, 0) < 0) {
744b8b31f33SHajimu UMEMOTO free(buf);
745b8b31f33SHajimu UMEMOTO return (0);
746b8b31f33SHajimu UMEMOTO }
747b8b31f33SHajimu UMEMOTO
748b8b31f33SHajimu UMEMOTO ep = (struct in6_addrpolicy *)(buf + l);
749b8b31f33SHajimu UMEMOTO for (pol = (struct in6_addrpolicy *)buf; pol + 1 <= ep; pol++) {
750b8b31f33SHajimu UMEMOTO struct policyqueue *new;
751b8b31f33SHajimu UMEMOTO
752b8b31f33SHajimu UMEMOTO if ((new = malloc(sizeof(*new))) == NULL) {
753b8b31f33SHajimu UMEMOTO free_addrselectpolicy(head); /* make the list empty */
754b8b31f33SHajimu UMEMOTO break;
755b8b31f33SHajimu UMEMOTO }
756b8b31f33SHajimu UMEMOTO new->pc_policy = *pol;
757b8b31f33SHajimu UMEMOTO TAILQ_INSERT_TAIL(head, new, pc_entry);
758b8b31f33SHajimu UMEMOTO }
759b8b31f33SHajimu UMEMOTO
760b8b31f33SHajimu UMEMOTO free(buf);
761b8b31f33SHajimu UMEMOTO return (1);
762b8b31f33SHajimu UMEMOTO #else
763b8b31f33SHajimu UMEMOTO return (0);
764b8b31f33SHajimu UMEMOTO #endif
765b8b31f33SHajimu UMEMOTO }
766b8b31f33SHajimu UMEMOTO
767b8b31f33SHajimu UMEMOTO static void
free_addrselectpolicy(struct policyhead * head)76890d1d883SHajimu UMEMOTO free_addrselectpolicy(struct policyhead *head)
769b8b31f33SHajimu UMEMOTO {
770b8b31f33SHajimu UMEMOTO struct policyqueue *ent, *nent;
771b8b31f33SHajimu UMEMOTO
772b8b31f33SHajimu UMEMOTO for (ent = TAILQ_FIRST(head); ent; ent = nent) {
773b8b31f33SHajimu UMEMOTO nent = TAILQ_NEXT(ent, pc_entry);
774b8b31f33SHajimu UMEMOTO TAILQ_REMOVE(head, ent, pc_entry);
775b8b31f33SHajimu UMEMOTO free(ent);
776b8b31f33SHajimu UMEMOTO }
777b8b31f33SHajimu UMEMOTO }
778b8b31f33SHajimu UMEMOTO
779b8b31f33SHajimu UMEMOTO static struct policyqueue *
match_addrselectpolicy(struct sockaddr * addr,struct policyhead * head)78090d1d883SHajimu UMEMOTO match_addrselectpolicy(struct sockaddr *addr, struct policyhead *head)
781b8b31f33SHajimu UMEMOTO {
782b8b31f33SHajimu UMEMOTO #ifdef INET6
783b8b31f33SHajimu UMEMOTO struct policyqueue *ent, *bestent = NULL;
784b8b31f33SHajimu UMEMOTO struct in6_addrpolicy *pol;
785b8b31f33SHajimu UMEMOTO int matchlen, bestmatchlen = -1;
786b8b31f33SHajimu UMEMOTO u_char *mp, *ep, *k, *p, m;
787b8b31f33SHajimu UMEMOTO struct sockaddr_in6 key;
788b8b31f33SHajimu UMEMOTO
789b8b31f33SHajimu UMEMOTO switch(addr->sa_family) {
790b8b31f33SHajimu UMEMOTO case AF_INET6:
791b8b31f33SHajimu UMEMOTO key = *(struct sockaddr_in6 *)addr;
792b8b31f33SHajimu UMEMOTO break;
793b8b31f33SHajimu UMEMOTO case AF_INET:
794b8b31f33SHajimu UMEMOTO /* convert the address into IPv4-mapped IPv6 address. */
795b8b31f33SHajimu UMEMOTO memset(&key, 0, sizeof(key));
796b8b31f33SHajimu UMEMOTO key.sin6_family = AF_INET6;
797b8b31f33SHajimu UMEMOTO key.sin6_len = sizeof(key);
798bf231994SHajimu UMEMOTO _map_v4v6_address(
799bf231994SHajimu UMEMOTO (char *)&((struct sockaddr_in *)addr)->sin_addr,
800bf231994SHajimu UMEMOTO (char *)&key.sin6_addr);
801b8b31f33SHajimu UMEMOTO break;
802b8b31f33SHajimu UMEMOTO default:
803b8b31f33SHajimu UMEMOTO return(NULL);
804b8b31f33SHajimu UMEMOTO }
805b8b31f33SHajimu UMEMOTO
806b8b31f33SHajimu UMEMOTO for (ent = TAILQ_FIRST(head); ent; ent = TAILQ_NEXT(ent, pc_entry)) {
807b8b31f33SHajimu UMEMOTO pol = &ent->pc_policy;
808b8b31f33SHajimu UMEMOTO matchlen = 0;
809b8b31f33SHajimu UMEMOTO
810b8b31f33SHajimu UMEMOTO mp = (u_char *)&pol->addrmask.sin6_addr;
811b8b31f33SHajimu UMEMOTO ep = mp + 16; /* XXX: scope field? */
812b8b31f33SHajimu UMEMOTO k = (u_char *)&key.sin6_addr;
813b8b31f33SHajimu UMEMOTO p = (u_char *)&pol->addr.sin6_addr;
814b8b31f33SHajimu UMEMOTO for (; mp < ep && *mp; mp++, k++, p++) {
815b8b31f33SHajimu UMEMOTO m = *mp;
816b8b31f33SHajimu UMEMOTO if ((*k & m) != *p)
817b8b31f33SHajimu UMEMOTO goto next; /* not match */
818b8b31f33SHajimu UMEMOTO if (m == 0xff) /* short cut for a typical case */
819b8b31f33SHajimu UMEMOTO matchlen += 8;
820b8b31f33SHajimu UMEMOTO else {
821b8b31f33SHajimu UMEMOTO while (m >= 0x80) {
822b8b31f33SHajimu UMEMOTO matchlen++;
823b8b31f33SHajimu UMEMOTO m <<= 1;
824b8b31f33SHajimu UMEMOTO }
825b8b31f33SHajimu UMEMOTO }
826b8b31f33SHajimu UMEMOTO }
827b8b31f33SHajimu UMEMOTO
828b8b31f33SHajimu UMEMOTO /* matched. check if this is better than the current best. */
829b8b31f33SHajimu UMEMOTO if (matchlen > bestmatchlen) {
830b8b31f33SHajimu UMEMOTO bestent = ent;
831b8b31f33SHajimu UMEMOTO bestmatchlen = matchlen;
832b8b31f33SHajimu UMEMOTO }
833b8b31f33SHajimu UMEMOTO
834b8b31f33SHajimu UMEMOTO next:
835b8b31f33SHajimu UMEMOTO continue;
836b8b31f33SHajimu UMEMOTO }
837b8b31f33SHajimu UMEMOTO
838b8b31f33SHajimu UMEMOTO return(bestent);
839b8b31f33SHajimu UMEMOTO #else
840b8b31f33SHajimu UMEMOTO return(NULL);
841b8b31f33SHajimu UMEMOTO #endif
842b8b31f33SHajimu UMEMOTO
843b8b31f33SHajimu UMEMOTO }
844b8b31f33SHajimu UMEMOTO
845146cd1bcSHajimu UMEMOTO static void
set_source(struct hp_order * aio,struct policyhead * ph)84690d1d883SHajimu UMEMOTO set_source(struct hp_order *aio, struct policyhead *ph)
847146cd1bcSHajimu UMEMOTO {
848146cd1bcSHajimu UMEMOTO struct sockaddr_storage ss = aio->aio_un.aiou_ss;
849943db5a2SHajimu UMEMOTO socklen_t srclen;
850943db5a2SHajimu UMEMOTO int s;
851146cd1bcSHajimu UMEMOTO
852146cd1bcSHajimu UMEMOTO /* set unspec ("no source is available"), just in case */
853146cd1bcSHajimu UMEMOTO aio->aio_srcsa.sa_family = AF_UNSPEC;
854146cd1bcSHajimu UMEMOTO aio->aio_srcscope = -1;
855146cd1bcSHajimu UMEMOTO
856146cd1bcSHajimu UMEMOTO switch(ss.ss_family) {
857146cd1bcSHajimu UMEMOTO case AF_INET:
858146cd1bcSHajimu UMEMOTO ((struct sockaddr_in *)&ss)->sin_port = htons(1);
859146cd1bcSHajimu UMEMOTO break;
860146cd1bcSHajimu UMEMOTO #ifdef INET6
861146cd1bcSHajimu UMEMOTO case AF_INET6:
862146cd1bcSHajimu UMEMOTO ((struct sockaddr_in6 *)&ss)->sin6_port = htons(1);
863146cd1bcSHajimu UMEMOTO break;
864146cd1bcSHajimu UMEMOTO #endif
865146cd1bcSHajimu UMEMOTO default: /* ignore unsupported AFs explicitly */
866146cd1bcSHajimu UMEMOTO return;
867146cd1bcSHajimu UMEMOTO }
868146cd1bcSHajimu UMEMOTO
869146cd1bcSHajimu UMEMOTO /* open a socket to get the source address for the given dst */
87072531978SJilles Tjoelker if ((s = _socket(ss.ss_family, SOCK_DGRAM | SOCK_CLOEXEC,
87172531978SJilles Tjoelker IPPROTO_UDP)) < 0)
872146cd1bcSHajimu UMEMOTO return; /* give up */
873146cd1bcSHajimu UMEMOTO if (_connect(s, (struct sockaddr *)&ss, ss.ss_len) < 0)
874146cd1bcSHajimu UMEMOTO goto cleanup;
875146cd1bcSHajimu UMEMOTO srclen = ss.ss_len;
876146cd1bcSHajimu UMEMOTO if (_getsockname(s, &aio->aio_srcsa, &srclen) < 0) {
877146cd1bcSHajimu UMEMOTO aio->aio_srcsa.sa_family = AF_UNSPEC;
878146cd1bcSHajimu UMEMOTO goto cleanup;
879146cd1bcSHajimu UMEMOTO }
880146cd1bcSHajimu UMEMOTO aio->aio_srcscope = gai_addr2scopetype(&aio->aio_srcsa);
881146cd1bcSHajimu UMEMOTO aio->aio_srcpolicy = match_addrselectpolicy(&aio->aio_srcsa, ph);
882146cd1bcSHajimu UMEMOTO aio->aio_matchlen = matchlen(&aio->aio_srcsa, (struct sockaddr *)&ss);
883146cd1bcSHajimu UMEMOTO #ifdef INET6
884146cd1bcSHajimu UMEMOTO if (ss.ss_family == AF_INET6) {
885146cd1bcSHajimu UMEMOTO struct in6_ifreq ifr6;
886146cd1bcSHajimu UMEMOTO u_int32_t flags6;
887146cd1bcSHajimu UMEMOTO
888146cd1bcSHajimu UMEMOTO memset(&ifr6, 0, sizeof(ifr6));
889146cd1bcSHajimu UMEMOTO memcpy(&ifr6.ifr_addr, &ss, ss.ss_len);
890146cd1bcSHajimu UMEMOTO if (_ioctl(s, SIOCGIFAFLAG_IN6, &ifr6) == 0) {
891146cd1bcSHajimu UMEMOTO flags6 = ifr6.ifr_ifru.ifru_flags6;
892146cd1bcSHajimu UMEMOTO if ((flags6 & IN6_IFF_DEPRECATED))
893146cd1bcSHajimu UMEMOTO aio->aio_srcflag |= AIO_SRCFLAG_DEPRECATED;
894146cd1bcSHajimu UMEMOTO }
895146cd1bcSHajimu UMEMOTO }
896146cd1bcSHajimu UMEMOTO #endif
897146cd1bcSHajimu UMEMOTO
898146cd1bcSHajimu UMEMOTO cleanup:
899146cd1bcSHajimu UMEMOTO _close(s);
900146cd1bcSHajimu UMEMOTO return;
901146cd1bcSHajimu UMEMOTO }
902146cd1bcSHajimu UMEMOTO
903146cd1bcSHajimu UMEMOTO static int
matchlen(struct sockaddr * src,struct sockaddr * dst)90490d1d883SHajimu UMEMOTO matchlen(struct sockaddr *src, struct sockaddr *dst)
905146cd1bcSHajimu UMEMOTO {
906146cd1bcSHajimu UMEMOTO int match = 0;
907146cd1bcSHajimu UMEMOTO u_char *s, *d;
908146cd1bcSHajimu UMEMOTO u_char *lim, r;
909146cd1bcSHajimu UMEMOTO int addrlen;
910146cd1bcSHajimu UMEMOTO
911146cd1bcSHajimu UMEMOTO switch (src->sa_family) {
912146cd1bcSHajimu UMEMOTO #ifdef INET6
913146cd1bcSHajimu UMEMOTO case AF_INET6:
914146cd1bcSHajimu UMEMOTO s = (u_char *)&((struct sockaddr_in6 *)src)->sin6_addr;
915146cd1bcSHajimu UMEMOTO d = (u_char *)&((struct sockaddr_in6 *)dst)->sin6_addr;
916146cd1bcSHajimu UMEMOTO addrlen = sizeof(struct in6_addr);
917146cd1bcSHajimu UMEMOTO lim = s + addrlen;
918146cd1bcSHajimu UMEMOTO break;
919146cd1bcSHajimu UMEMOTO #endif
920146cd1bcSHajimu UMEMOTO case AF_INET:
921fd57e549SGeorge V. Neville-Neil s = (u_char *)&((struct sockaddr_in *)src)->sin_addr;
922fd57e549SGeorge V. Neville-Neil d = (u_char *)&((struct sockaddr_in *)dst)->sin_addr;
923146cd1bcSHajimu UMEMOTO addrlen = sizeof(struct in_addr);
924146cd1bcSHajimu UMEMOTO lim = s + addrlen;
925146cd1bcSHajimu UMEMOTO break;
926146cd1bcSHajimu UMEMOTO default:
927146cd1bcSHajimu UMEMOTO return(0);
928146cd1bcSHajimu UMEMOTO }
929146cd1bcSHajimu UMEMOTO
930146cd1bcSHajimu UMEMOTO while (s < lim)
931146cd1bcSHajimu UMEMOTO if ((r = (*d++ ^ *s++)) != 0) {
932e1ec67bbSAndrey A. Chernov while ((r & 0x80) == 0) {
933146cd1bcSHajimu UMEMOTO match++;
934146cd1bcSHajimu UMEMOTO r <<= 1;
935146cd1bcSHajimu UMEMOTO }
936146cd1bcSHajimu UMEMOTO break;
937146cd1bcSHajimu UMEMOTO } else
938146cd1bcSHajimu UMEMOTO match += 8;
939146cd1bcSHajimu UMEMOTO return(match);
940146cd1bcSHajimu UMEMOTO }
941146cd1bcSHajimu UMEMOTO
942146cd1bcSHajimu UMEMOTO static int
comp_dst(const void * arg1,const void * arg2)94390d1d883SHajimu UMEMOTO comp_dst(const void *arg1, const void *arg2)
944146cd1bcSHajimu UMEMOTO {
945146cd1bcSHajimu UMEMOTO const struct hp_order *dst1 = arg1, *dst2 = arg2;
946146cd1bcSHajimu UMEMOTO
947146cd1bcSHajimu UMEMOTO /*
948146cd1bcSHajimu UMEMOTO * Rule 1: Avoid unusable destinations.
949146cd1bcSHajimu UMEMOTO * XXX: we currently do not consider if an appropriate route exists.
950146cd1bcSHajimu UMEMOTO */
951146cd1bcSHajimu UMEMOTO if (dst1->aio_srcsa.sa_family != AF_UNSPEC &&
952146cd1bcSHajimu UMEMOTO dst2->aio_srcsa.sa_family == AF_UNSPEC) {
953146cd1bcSHajimu UMEMOTO return(-1);
954146cd1bcSHajimu UMEMOTO }
955146cd1bcSHajimu UMEMOTO if (dst1->aio_srcsa.sa_family == AF_UNSPEC &&
956146cd1bcSHajimu UMEMOTO dst2->aio_srcsa.sa_family != AF_UNSPEC) {
957146cd1bcSHajimu UMEMOTO return(1);
958146cd1bcSHajimu UMEMOTO }
959146cd1bcSHajimu UMEMOTO
960146cd1bcSHajimu UMEMOTO /* Rule 2: Prefer matching scope. */
961146cd1bcSHajimu UMEMOTO if (dst1->aio_dstscope == dst1->aio_srcscope &&
962146cd1bcSHajimu UMEMOTO dst2->aio_dstscope != dst2->aio_srcscope) {
963146cd1bcSHajimu UMEMOTO return(-1);
964146cd1bcSHajimu UMEMOTO }
965146cd1bcSHajimu UMEMOTO if (dst1->aio_dstscope != dst1->aio_srcscope &&
966146cd1bcSHajimu UMEMOTO dst2->aio_dstscope == dst2->aio_srcscope) {
967146cd1bcSHajimu UMEMOTO return(1);
968146cd1bcSHajimu UMEMOTO }
969146cd1bcSHajimu UMEMOTO
970146cd1bcSHajimu UMEMOTO /* Rule 3: Avoid deprecated addresses. */
971146cd1bcSHajimu UMEMOTO if (dst1->aio_srcsa.sa_family != AF_UNSPEC &&
972146cd1bcSHajimu UMEMOTO dst2->aio_srcsa.sa_family != AF_UNSPEC) {
973146cd1bcSHajimu UMEMOTO if (!(dst1->aio_srcflag & AIO_SRCFLAG_DEPRECATED) &&
974146cd1bcSHajimu UMEMOTO (dst2->aio_srcflag & AIO_SRCFLAG_DEPRECATED)) {
975146cd1bcSHajimu UMEMOTO return(-1);
976146cd1bcSHajimu UMEMOTO }
977146cd1bcSHajimu UMEMOTO if ((dst1->aio_srcflag & AIO_SRCFLAG_DEPRECATED) &&
978146cd1bcSHajimu UMEMOTO !(dst2->aio_srcflag & AIO_SRCFLAG_DEPRECATED)) {
979146cd1bcSHajimu UMEMOTO return(1);
980146cd1bcSHajimu UMEMOTO }
981146cd1bcSHajimu UMEMOTO }
982146cd1bcSHajimu UMEMOTO
983146cd1bcSHajimu UMEMOTO /* Rule 4: Prefer home addresses. */
984146cd1bcSHajimu UMEMOTO /* XXX: not implemented yet */
985146cd1bcSHajimu UMEMOTO
986146cd1bcSHajimu UMEMOTO /* Rule 5: Prefer matching label. */
987146cd1bcSHajimu UMEMOTO #ifdef INET6
988146cd1bcSHajimu UMEMOTO if (dst1->aio_srcpolicy && dst1->aio_dstpolicy &&
989146cd1bcSHajimu UMEMOTO dst1->aio_srcpolicy->pc_policy.label ==
990146cd1bcSHajimu UMEMOTO dst1->aio_dstpolicy->pc_policy.label &&
991146cd1bcSHajimu UMEMOTO (dst2->aio_srcpolicy == NULL || dst2->aio_dstpolicy == NULL ||
992146cd1bcSHajimu UMEMOTO dst2->aio_srcpolicy->pc_policy.label !=
993146cd1bcSHajimu UMEMOTO dst2->aio_dstpolicy->pc_policy.label)) {
994146cd1bcSHajimu UMEMOTO return(-1);
995146cd1bcSHajimu UMEMOTO }
996146cd1bcSHajimu UMEMOTO if (dst2->aio_srcpolicy && dst2->aio_dstpolicy &&
997146cd1bcSHajimu UMEMOTO dst2->aio_srcpolicy->pc_policy.label ==
998146cd1bcSHajimu UMEMOTO dst2->aio_dstpolicy->pc_policy.label &&
999146cd1bcSHajimu UMEMOTO (dst1->aio_srcpolicy == NULL || dst1->aio_dstpolicy == NULL ||
1000146cd1bcSHajimu UMEMOTO dst1->aio_srcpolicy->pc_policy.label !=
1001146cd1bcSHajimu UMEMOTO dst1->aio_dstpolicy->pc_policy.label)) {
1002146cd1bcSHajimu UMEMOTO return(1);
1003146cd1bcSHajimu UMEMOTO }
1004146cd1bcSHajimu UMEMOTO #endif
1005146cd1bcSHajimu UMEMOTO
1006146cd1bcSHajimu UMEMOTO /* Rule 6: Prefer higher precedence. */
1007146cd1bcSHajimu UMEMOTO #ifdef INET6
1008146cd1bcSHajimu UMEMOTO if (dst1->aio_dstpolicy &&
1009146cd1bcSHajimu UMEMOTO (dst2->aio_dstpolicy == NULL ||
1010146cd1bcSHajimu UMEMOTO dst1->aio_dstpolicy->pc_policy.preced >
1011146cd1bcSHajimu UMEMOTO dst2->aio_dstpolicy->pc_policy.preced)) {
1012146cd1bcSHajimu UMEMOTO return(-1);
1013146cd1bcSHajimu UMEMOTO }
1014146cd1bcSHajimu UMEMOTO if (dst2->aio_dstpolicy &&
1015146cd1bcSHajimu UMEMOTO (dst1->aio_dstpolicy == NULL ||
1016146cd1bcSHajimu UMEMOTO dst2->aio_dstpolicy->pc_policy.preced >
1017146cd1bcSHajimu UMEMOTO dst1->aio_dstpolicy->pc_policy.preced)) {
1018146cd1bcSHajimu UMEMOTO return(1);
1019146cd1bcSHajimu UMEMOTO }
1020146cd1bcSHajimu UMEMOTO #endif
1021146cd1bcSHajimu UMEMOTO
1022146cd1bcSHajimu UMEMOTO /* Rule 7: Prefer native transport. */
1023146cd1bcSHajimu UMEMOTO /* XXX: not implemented yet */
1024146cd1bcSHajimu UMEMOTO
1025146cd1bcSHajimu UMEMOTO /* Rule 8: Prefer smaller scope. */
1026146cd1bcSHajimu UMEMOTO if (dst1->aio_dstscope >= 0 &&
1027146cd1bcSHajimu UMEMOTO dst1->aio_dstscope < dst2->aio_dstscope) {
1028146cd1bcSHajimu UMEMOTO return(-1);
1029146cd1bcSHajimu UMEMOTO }
1030146cd1bcSHajimu UMEMOTO if (dst2->aio_dstscope >= 0 &&
1031146cd1bcSHajimu UMEMOTO dst2->aio_dstscope < dst1->aio_dstscope) {
1032146cd1bcSHajimu UMEMOTO return(1);
1033146cd1bcSHajimu UMEMOTO }
1034146cd1bcSHajimu UMEMOTO
1035146cd1bcSHajimu UMEMOTO /*
1036146cd1bcSHajimu UMEMOTO * Rule 9: Use longest matching prefix.
1037146cd1bcSHajimu UMEMOTO * We compare the match length in a same AF only.
1038146cd1bcSHajimu UMEMOTO */
1039146cd1bcSHajimu UMEMOTO if (dst1->aio_sa.sa_family == dst2->aio_sa.sa_family) {
1040146cd1bcSHajimu UMEMOTO if (dst1->aio_matchlen > dst2->aio_matchlen) {
1041146cd1bcSHajimu UMEMOTO return(-1);
1042146cd1bcSHajimu UMEMOTO }
1043146cd1bcSHajimu UMEMOTO if (dst1->aio_matchlen < dst2->aio_matchlen) {
1044146cd1bcSHajimu UMEMOTO return(1);
1045146cd1bcSHajimu UMEMOTO }
1046146cd1bcSHajimu UMEMOTO }
1047146cd1bcSHajimu UMEMOTO
1048146cd1bcSHajimu UMEMOTO /* Rule 10: Otherwise, leave the order unchanged. */
1049af98aa6eSAndrey A. Chernov
1050af98aa6eSAndrey A. Chernov /*
1051af98aa6eSAndrey A. Chernov * Note that qsort is unstable; so, we can't return zero and
1052af98aa6eSAndrey A. Chernov * expect the order to be unchanged.
1053af98aa6eSAndrey A. Chernov * That also means we can't depend on the current position of
1054af98aa6eSAndrey A. Chernov * dst2 being after dst1. We must enforce the initial order
1055af98aa6eSAndrey A. Chernov * with an explicit compare on the original position.
1056af98aa6eSAndrey A. Chernov * The qsort specification requires that "When the same objects
1057af98aa6eSAndrey A. Chernov * (consisting of width bytes, irrespective of their current
1058af98aa6eSAndrey A. Chernov * positions in the array) are passed more than once to the
1059af98aa6eSAndrey A. Chernov * comparison function, the results shall be consistent with one
1060af98aa6eSAndrey A. Chernov * another."
1061af98aa6eSAndrey A. Chernov * In other words, If A < B, then we must also return B > A.
1062af98aa6eSAndrey A. Chernov */
1063af98aa6eSAndrey A. Chernov if (dst2->aio_initial_sequence < dst1->aio_initial_sequence)
1064af98aa6eSAndrey A. Chernov return(1);
1065af98aa6eSAndrey A. Chernov
1066146cd1bcSHajimu UMEMOTO return(-1);
1067146cd1bcSHajimu UMEMOTO }
1068146cd1bcSHajimu UMEMOTO
1069146cd1bcSHajimu UMEMOTO /*
1070146cd1bcSHajimu UMEMOTO * Copy from scope.c.
1071146cd1bcSHajimu UMEMOTO * XXX: we should standardize the functions and link them as standard
1072146cd1bcSHajimu UMEMOTO * library.
1073146cd1bcSHajimu UMEMOTO */
1074146cd1bcSHajimu UMEMOTO static int
gai_addr2scopetype(struct sockaddr * sa)107590d1d883SHajimu UMEMOTO gai_addr2scopetype(struct sockaddr *sa)
1076146cd1bcSHajimu UMEMOTO {
1077146cd1bcSHajimu UMEMOTO #ifdef INET6
1078146cd1bcSHajimu UMEMOTO struct sockaddr_in6 *sa6;
1079146cd1bcSHajimu UMEMOTO #endif
1080146cd1bcSHajimu UMEMOTO struct sockaddr_in *sa4;
1081146cd1bcSHajimu UMEMOTO
1082146cd1bcSHajimu UMEMOTO switch(sa->sa_family) {
1083146cd1bcSHajimu UMEMOTO #ifdef INET6
1084146cd1bcSHajimu UMEMOTO case AF_INET6:
1085146cd1bcSHajimu UMEMOTO sa6 = (struct sockaddr_in6 *)sa;
1086146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) {
1087146cd1bcSHajimu UMEMOTO /* just use the scope field of the multicast address */
1088146cd1bcSHajimu UMEMOTO return(sa6->sin6_addr.s6_addr[2] & 0x0f);
1089146cd1bcSHajimu UMEMOTO }
1090146cd1bcSHajimu UMEMOTO /*
1091146cd1bcSHajimu UMEMOTO * Unicast addresses: map scope type to corresponding scope
1092146cd1bcSHajimu UMEMOTO * value defined for multcast addresses.
1093146cd1bcSHajimu UMEMOTO * XXX: hardcoded scope type values are bad...
1094146cd1bcSHajimu UMEMOTO */
1095146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_LOOPBACK(&sa6->sin6_addr))
1096146cd1bcSHajimu UMEMOTO return(1); /* node local scope */
1097146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr))
1098146cd1bcSHajimu UMEMOTO return(2); /* link-local scope */
1099146cd1bcSHajimu UMEMOTO if (IN6_IS_ADDR_SITELOCAL(&sa6->sin6_addr))
1100146cd1bcSHajimu UMEMOTO return(5); /* site-local scope */
1101146cd1bcSHajimu UMEMOTO return(14); /* global scope */
1102146cd1bcSHajimu UMEMOTO break;
1103146cd1bcSHajimu UMEMOTO #endif
1104146cd1bcSHajimu UMEMOTO case AF_INET:
1105146cd1bcSHajimu UMEMOTO /*
1106146cd1bcSHajimu UMEMOTO * IPv4 pseudo scoping according to RFC 3484.
1107146cd1bcSHajimu UMEMOTO */
1108146cd1bcSHajimu UMEMOTO sa4 = (struct sockaddr_in *)sa;
1109146cd1bcSHajimu UMEMOTO /* IPv4 autoconfiguration addresses have link-local scope. */
1110146cd1bcSHajimu UMEMOTO if (((u_char *)&sa4->sin_addr)[0] == 169 &&
1111146cd1bcSHajimu UMEMOTO ((u_char *)&sa4->sin_addr)[1] == 254)
1112146cd1bcSHajimu UMEMOTO return(2);
1113146cd1bcSHajimu UMEMOTO /* Private addresses have site-local scope. */
1114146cd1bcSHajimu UMEMOTO if (((u_char *)&sa4->sin_addr)[0] == 10 ||
1115146cd1bcSHajimu UMEMOTO (((u_char *)&sa4->sin_addr)[0] == 172 &&
1116146cd1bcSHajimu UMEMOTO (((u_char *)&sa4->sin_addr)[1] & 0xf0) == 16) ||
1117146cd1bcSHajimu UMEMOTO (((u_char *)&sa4->sin_addr)[0] == 192 &&
1118146cd1bcSHajimu UMEMOTO ((u_char *)&sa4->sin_addr)[1] == 168))
1119146cd1bcSHajimu UMEMOTO return(14); /* XXX: It should be 5 unless NAT */
1120146cd1bcSHajimu UMEMOTO /* Loopback addresses have link-local scope. */
1121146cd1bcSHajimu UMEMOTO if (((u_char *)&sa4->sin_addr)[0] == 127)
1122146cd1bcSHajimu UMEMOTO return(2);
1123146cd1bcSHajimu UMEMOTO return(14);
1124146cd1bcSHajimu UMEMOTO break;
1125146cd1bcSHajimu UMEMOTO default:
1126146cd1bcSHajimu UMEMOTO errno = EAFNOSUPPORT; /* is this a good error? */
1127146cd1bcSHajimu UMEMOTO return(-1);
1128146cd1bcSHajimu UMEMOTO }
1129146cd1bcSHajimu UMEMOTO }
1130d38f4eadSHajimu UMEMOTO #endif
1131