Annotation of sys/netinet6/in6_src.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: in6_src.c,v 1.22 2006/12/11 11:26:05 itojun Exp $ */
! 2: /* $KAME: in6_src.c,v 1.36 2001/02/06 04:08:17 itojun Exp $ */
! 3:
! 4: /*
! 5: * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. Neither the name of the project nor the names of its contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: */
! 32:
! 33: /*
! 34: * Copyright (c) 1982, 1986, 1991, 1993
! 35: * The Regents of the University of California. All rights reserved.
! 36: *
! 37: * Redistribution and use in source and binary forms, with or without
! 38: * modification, are permitted provided that the following conditions
! 39: * are met:
! 40: * 1. Redistributions of source code must retain the above copyright
! 41: * notice, this list of conditions and the following disclaimer.
! 42: * 2. Redistributions in binary form must reproduce the above copyright
! 43: * notice, this list of conditions and the following disclaimer in the
! 44: * documentation and/or other materials provided with the distribution.
! 45: * 3. Neither the name of the University nor the names of its contributors
! 46: * may be used to endorse or promote products derived from this software
! 47: * without specific prior written permission.
! 48: *
! 49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 59: * SUCH DAMAGE.
! 60: *
! 61: * @(#)in_pcb.c 8.2 (Berkeley) 1/4/94
! 62: */
! 63:
! 64: #include <sys/param.h>
! 65: #include <sys/systm.h>
! 66: #include <sys/malloc.h>
! 67: #include <sys/mbuf.h>
! 68: #include <sys/protosw.h>
! 69: #include <sys/socket.h>
! 70: #include <sys/socketvar.h>
! 71: #include <sys/ioctl.h>
! 72: #include <sys/errno.h>
! 73: #include <sys/time.h>
! 74: #include <sys/proc.h>
! 75:
! 76: #include <net/if.h>
! 77: #include <net/route.h>
! 78:
! 79: #include <netinet/in.h>
! 80: #include <netinet/in_var.h>
! 81: #include <netinet/in_systm.h>
! 82: #include <netinet/ip.h>
! 83: #include <netinet/in_pcb.h>
! 84: #include <netinet6/in6_var.h>
! 85: #include <netinet/ip6.h>
! 86: #include <netinet6/ip6_var.h>
! 87: #include <netinet6/nd6.h>
! 88:
! 89: static int selectroute(struct sockaddr_in6 *, struct ip6_pktopts *,
! 90: struct ip6_moptions *, struct route_in6 *, struct ifnet **,
! 91: struct rtentry **, int);
! 92:
! 93: /*
! 94: * Return an IPv6 address, which is the most appropriate for a given
! 95: * destination and user specified options.
! 96: * If necessary, this function lookups the routing table and returns
! 97: * an entry to the caller for later use.
! 98: */
! 99: struct in6_addr *
! 100: in6_selectsrc(dstsock, opts, mopts, ro, laddr, errorp)
! 101: struct sockaddr_in6 *dstsock;
! 102: struct ip6_pktopts *opts;
! 103: struct ip6_moptions *mopts;
! 104: struct route_in6 *ro;
! 105: struct in6_addr *laddr;
! 106: int *errorp;
! 107: {
! 108: struct in6_addr *dst;
! 109: struct in6_ifaddr *ia6 = 0;
! 110: struct in6_pktinfo *pi = NULL;
! 111:
! 112: dst = &dstsock->sin6_addr;
! 113: *errorp = 0;
! 114:
! 115: /*
! 116: * If the source address is explicitly specified by the caller,
! 117: * use it.
! 118: */
! 119: if (opts && (pi = opts->ip6po_pktinfo) &&
! 120: !IN6_IS_ADDR_UNSPECIFIED(&pi->ipi6_addr))
! 121: return (&pi->ipi6_addr);
! 122:
! 123: /*
! 124: * If the source address is not specified but the socket(if any)
! 125: * is already bound, use the bound address.
! 126: */
! 127: if (laddr && !IN6_IS_ADDR_UNSPECIFIED(laddr))
! 128: return (laddr);
! 129:
! 130: /*
! 131: * If the caller doesn't specify the source address but
! 132: * the outgoing interface, use an address associated with
! 133: * the interface.
! 134: */
! 135: if (pi && pi->ipi6_ifindex) {
! 136: /* XXX boundary check is assumed to be already done. */
! 137: ia6 = in6_ifawithscope(ifindex2ifnet[pi->ipi6_ifindex],
! 138: dst);
! 139: if (ia6 == 0) {
! 140: *errorp = EADDRNOTAVAIL;
! 141: return (0);
! 142: }
! 143: return (&satosin6(&ia6->ia_addr)->sin6_addr);
! 144: }
! 145:
! 146: /*
! 147: * If the destination address is a link-local unicast address or
! 148: * a link/interface-local multicast address, and if the outgoing
! 149: * interface is specified by the sin6_scope_id filed, use an address
! 150: * associated with the interface.
! 151: * XXX: We're now trying to define more specific semantics of
! 152: * sin6_scope_id field, so this part will be rewritten in
! 153: * the near future.
! 154: */
! 155: if ((IN6_IS_ADDR_LINKLOCAL(dst) || IN6_IS_ADDR_MC_LINKLOCAL(dst) ||
! 156: IN6_IS_ADDR_MC_INTFACELOCAL(dst)) && dstsock->sin6_scope_id) {
! 157: /*
! 158: * I'm not sure if boundary check for scope_id is done
! 159: * somewhere...
! 160: */
! 161: if (dstsock->sin6_scope_id < 0 ||
! 162: if_indexlim <= dstsock->sin6_scope_id ||
! 163: !ifindex2ifnet[dstsock->sin6_scope_id]) {
! 164: *errorp = ENXIO; /* XXX: better error? */
! 165: return (0);
! 166: }
! 167: ia6 = in6_ifawithscope(ifindex2ifnet[dstsock->sin6_scope_id],
! 168: dst);
! 169: if (ia6 == 0) {
! 170: *errorp = EADDRNOTAVAIL;
! 171: return (0);
! 172: }
! 173: return (&satosin6(&ia6->ia_addr)->sin6_addr);
! 174: }
! 175:
! 176: /*
! 177: * If the destination address is a multicast address and
! 178: * the outgoing interface for the address is specified
! 179: * by the caller, use an address associated with the interface.
! 180: * Even if the outgoing interface is not specified, we also
! 181: * choose a loopback interface as the outgoing interface.
! 182: */
! 183: if (IN6_IS_ADDR_MULTICAST(dst)) {
! 184: struct ifnet *ifp = mopts ? mopts->im6o_multicast_ifp : NULL;
! 185:
! 186: if (!ifp && dstsock->sin6_scope_id)
! 187: ifp = ifindex2ifnet[htons(dstsock->sin6_scope_id)];
! 188:
! 189: if (ifp) {
! 190: ia6 = in6_ifawithscope(ifp, dst);
! 191: if (ia6 == 0) {
! 192: *errorp = EADDRNOTAVAIL;
! 193: return (0);
! 194: }
! 195: return (&satosin6(&ia6->ia_addr)->sin6_addr);
! 196: }
! 197: }
! 198:
! 199: /*
! 200: * If the next hop address for the packet is specified
! 201: * by caller, use an address associated with the route
! 202: * to the next hop.
! 203: */
! 204: {
! 205: struct sockaddr_in6 *sin6_next;
! 206: struct rtentry *rt;
! 207:
! 208: if (opts && opts->ip6po_nexthop) {
! 209: sin6_next = satosin6(opts->ip6po_nexthop);
! 210: rt = nd6_lookup(&sin6_next->sin6_addr, 1, NULL);
! 211: if (rt) {
! 212: ia6 = in6_ifawithscope(rt->rt_ifp, dst);
! 213: if (ia6 == 0)
! 214: ia6 = ifatoia6(rt->rt_ifa);
! 215: }
! 216: if (ia6 == 0) {
! 217: *errorp = EADDRNOTAVAIL;
! 218: return (0);
! 219: }
! 220: return (&satosin6(&ia6->ia_addr)->sin6_addr);
! 221: }
! 222: }
! 223:
! 224: /*
! 225: * If route is known or can be allocated now,
! 226: * our src addr is taken from the i/f, else punt.
! 227: */
! 228: if (ro) {
! 229: if (ro->ro_rt &&
! 230: !IN6_ARE_ADDR_EQUAL(&satosin6(&ro->ro_dst)->sin6_addr, dst)) {
! 231: RTFREE(ro->ro_rt);
! 232: ro->ro_rt = (struct rtentry *)0;
! 233: }
! 234: if (ro->ro_rt == (struct rtentry *)0 ||
! 235: ro->ro_rt->rt_ifp == (struct ifnet *)0) {
! 236: struct sockaddr_in6 *sa6;
! 237:
! 238: /* No route yet, so try to acquire one */
! 239: bzero(&ro->ro_dst, sizeof(struct sockaddr_in6));
! 240: sa6 = (struct sockaddr_in6 *)&ro->ro_dst;
! 241: sa6->sin6_family = AF_INET6;
! 242: sa6->sin6_len = sizeof(struct sockaddr_in6);
! 243: sa6->sin6_addr = *dst;
! 244: sa6->sin6_scope_id = dstsock->sin6_scope_id;
! 245: if (IN6_IS_ADDR_MULTICAST(dst)) {
! 246: ro->ro_rt = rtalloc1(&((struct route *)ro)
! 247: ->ro_dst, 0, 0);
! 248: } else {
! 249: rtalloc_mpath((struct route *)ro, NULL, 0);
! 250: }
! 251: }
! 252:
! 253: /*
! 254: * in_pcbconnect() checks out IFF_LOOPBACK to skip using
! 255: * the address. But we don't know why it does so.
! 256: * It is necessary to ensure the scope even for lo0
! 257: * so doesn't check out IFF_LOOPBACK.
! 258: */
! 259:
! 260: if (ro->ro_rt) {
! 261: ia6 = in6_ifawithscope(ro->ro_rt->rt_ifa->ifa_ifp, dst);
! 262: if (ia6 == 0) /* xxx scope error ?*/
! 263: ia6 = ifatoia6(ro->ro_rt->rt_ifa);
! 264: }
! 265: #if 0
! 266: /*
! 267: * xxx The followings are necessary? (kazu)
! 268: * I don't think so.
! 269: * It's for SO_DONTROUTE option in IPv4.(jinmei)
! 270: */
! 271: if (ia6 == 0) {
! 272: struct sockaddr_in6 sin6 = {sizeof(sin6), AF_INET6, 0};
! 273:
! 274: sin6->sin6_addr = *dst;
! 275:
! 276: ia6 = ifatoia6(ifa_ifwithdstaddr(sin6tosa(&sin6)));
! 277: if (ia6 == 0)
! 278: ia6 = ifatoia6(ifa_ifwithnet(sin6tosa(&sin6)));
! 279: if (ia6 == 0)
! 280: return (0);
! 281: return (&satosin6(&ia6->ia_addr)->sin6_addr);
! 282: }
! 283: #endif /* 0 */
! 284: if (ia6 == 0) {
! 285: *errorp = EHOSTUNREACH; /* no route */
! 286: return (0);
! 287: }
! 288: return (&satosin6(&ia6->ia_addr)->sin6_addr);
! 289: }
! 290:
! 291: *errorp = EADDRNOTAVAIL;
! 292: return (0);
! 293: }
! 294:
! 295: static int
! 296: selectroute(dstsock, opts, mopts, ro, retifp, retrt, norouteok)
! 297: struct sockaddr_in6 *dstsock;
! 298: struct ip6_pktopts *opts;
! 299: struct ip6_moptions *mopts;
! 300: struct route_in6 *ro;
! 301: struct ifnet **retifp;
! 302: struct rtentry **retrt;
! 303: int norouteok;
! 304: {
! 305: int error = 0;
! 306: struct ifnet *ifp = NULL;
! 307: struct rtentry *rt = NULL;
! 308: struct sockaddr_in6 *sin6_next;
! 309: struct in6_pktinfo *pi = NULL;
! 310: struct in6_addr *dst;
! 311:
! 312: dst = &dstsock->sin6_addr;
! 313:
! 314: #if 0
! 315: if (dstsock->sin6_addr.s6_addr32[0] == 0 &&
! 316: dstsock->sin6_addr.s6_addr32[1] == 0 &&
! 317: !IN6_IS_ADDR_LOOPBACK(&dstsock->sin6_addr)) {
! 318: printf("in6_selectroute: strange destination %s\n",
! 319: ip6_sprintf(&dstsock->sin6_addr));
! 320: } else {
! 321: printf("in6_selectroute: destination = %s%%%d\n",
! 322: ip6_sprintf(&dstsock->sin6_addr),
! 323: dstsock->sin6_scope_id); /* for debug */
! 324: }
! 325: #endif
! 326:
! 327: /* If the caller specify the outgoing interface explicitly, use it. */
! 328: if (opts && (pi = opts->ip6po_pktinfo) != NULL && pi->ipi6_ifindex) {
! 329: /* XXX boundary check is assumed to be already done. */
! 330: ifp = ifindex2ifnet[pi->ipi6_ifindex];
! 331: if (ifp != NULL &&
! 332: (norouteok || retrt == NULL ||
! 333: IN6_IS_ADDR_MULTICAST(dst))) {
! 334: /*
! 335: * we do not have to check or get the route for
! 336: * multicast.
! 337: */
! 338: goto done;
! 339: } else
! 340: goto getroute;
! 341: }
! 342:
! 343: /*
! 344: * If the destination address is a multicast address and the outgoing
! 345: * interface for the address is specified by the caller, use it.
! 346: */
! 347: if (IN6_IS_ADDR_MULTICAST(dst) &&
! 348: mopts != NULL && (ifp = mopts->im6o_multicast_ifp) != NULL) {
! 349: goto done; /* we do not need a route for multicast. */
! 350: }
! 351:
! 352: getroute:
! 353: /*
! 354: * If the next hop address for the packet is specified by the caller,
! 355: * use it as the gateway.
! 356: */
! 357: if (opts && opts->ip6po_nexthop) {
! 358: struct route_in6 *ron;
! 359:
! 360: sin6_next = satosin6(opts->ip6po_nexthop);
! 361:
! 362: /* at this moment, we only support AF_INET6 next hops */
! 363: if (sin6_next->sin6_family != AF_INET6) {
! 364: error = EAFNOSUPPORT; /* or should we proceed? */
! 365: goto done;
! 366: }
! 367:
! 368: /*
! 369: * If the next hop is an IPv6 address, then the node identified
! 370: * by that address must be a neighbor of the sending host.
! 371: */
! 372: ron = &opts->ip6po_nextroute;
! 373: if ((ron->ro_rt &&
! 374: (ron->ro_rt->rt_flags & (RTF_UP | RTF_GATEWAY)) !=
! 375: RTF_UP) ||
! 376: !IN6_ARE_ADDR_EQUAL(&satosin6(&ron->ro_dst)->sin6_addr,
! 377: &sin6_next->sin6_addr)) {
! 378: if (ron->ro_rt) {
! 379: RTFREE(ron->ro_rt);
! 380: ron->ro_rt = NULL;
! 381: }
! 382: *satosin6(&ron->ro_dst) = *sin6_next;
! 383: }
! 384: if (ron->ro_rt == NULL) {
! 385: rtalloc((struct route *)ron); /* multi path case? */
! 386: if (ron->ro_rt == NULL ||
! 387: (ron->ro_rt->rt_flags & RTF_GATEWAY)) {
! 388: if (ron->ro_rt) {
! 389: RTFREE(ron->ro_rt);
! 390: ron->ro_rt = NULL;
! 391: }
! 392: error = EHOSTUNREACH;
! 393: goto done;
! 394: }
! 395: }
! 396: if (!nd6_is_addr_neighbor(sin6_next, ron->ro_rt->rt_ifp)) {
! 397: RTFREE(ron->ro_rt);
! 398: ron->ro_rt = NULL;
! 399: error = EHOSTUNREACH;
! 400: goto done;
! 401: }
! 402: rt = ron->ro_rt;
! 403: ifp = rt->rt_ifp;
! 404:
! 405: /*
! 406: * When cloning is required, try to allocate a route to the
! 407: * destination so that the caller can store path MTU
! 408: * information.
! 409: */
! 410: goto done;
! 411: }
! 412:
! 413: /*
! 414: * Use a cached route if it exists and is valid, else try to allocate
! 415: * a new one. Note that we should check the address family of the
! 416: * cached destination, in case of sharing the cache with IPv4.
! 417: */
! 418: if (ro) {
! 419: if (ro->ro_rt &&
! 420: (!(ro->ro_rt->rt_flags & RTF_UP) ||
! 421: ((struct sockaddr *)(&ro->ro_dst))->sa_family != AF_INET6 ||
! 422: !IN6_ARE_ADDR_EQUAL(&satosin6(&ro->ro_dst)->sin6_addr,
! 423: dst))) {
! 424: RTFREE(ro->ro_rt);
! 425: ro->ro_rt = (struct rtentry *)NULL;
! 426: }
! 427: if (ro->ro_rt == (struct rtentry *)NULL) {
! 428: struct sockaddr_in6 *sa6;
! 429:
! 430: /* No route yet, so try to acquire one */
! 431: bzero(&ro->ro_dst, sizeof(struct sockaddr_in6));
! 432: sa6 = (struct sockaddr_in6 *)&ro->ro_dst;
! 433: *sa6 = *dstsock;
! 434: sa6->sin6_scope_id = 0;
! 435: rtalloc_mpath((struct route *)ro, NULL, 0);
! 436: }
! 437:
! 438: /*
! 439: * do not care about the result if we have the nexthop
! 440: * explicitly specified.
! 441: */
! 442: if (opts && opts->ip6po_nexthop)
! 443: goto done;
! 444:
! 445: if (ro->ro_rt) {
! 446: ifp = ro->ro_rt->rt_ifp;
! 447:
! 448: if (ifp == NULL) { /* can this really happen? */
! 449: RTFREE(ro->ro_rt);
! 450: ro->ro_rt = NULL;
! 451: }
! 452: }
! 453: if (ro->ro_rt == NULL)
! 454: error = EHOSTUNREACH;
! 455: rt = ro->ro_rt;
! 456:
! 457: /*
! 458: * Check if the outgoing interface conflicts with
! 459: * the interface specified by ipi6_ifindex (if specified).
! 460: * Note that loopback interface is always okay.
! 461: * (this may happen when we are sending a packet to one of
! 462: * our own addresses.)
! 463: */
! 464: if (opts && opts->ip6po_pktinfo &&
! 465: opts->ip6po_pktinfo->ipi6_ifindex) {
! 466: if (!(ifp->if_flags & IFF_LOOPBACK) &&
! 467: ifp->if_index !=
! 468: opts->ip6po_pktinfo->ipi6_ifindex) {
! 469: error = EHOSTUNREACH;
! 470: goto done;
! 471: }
! 472: }
! 473: }
! 474:
! 475: done:
! 476: if (ifp == NULL && rt == NULL) {
! 477: /*
! 478: * This can happen if the caller did not pass a cached route
! 479: * nor any other hints. We treat this case an error.
! 480: */
! 481: error = EHOSTUNREACH;
! 482: }
! 483: if (error == EHOSTUNREACH)
! 484: ip6stat.ip6s_noroute++;
! 485:
! 486: if (retifp != NULL)
! 487: *retifp = ifp;
! 488: if (retrt != NULL)
! 489: *retrt = rt; /* rt may be NULL */
! 490:
! 491: return (error);
! 492: }
! 493:
! 494: int
! 495: in6_selectroute(dstsock, opts, mopts, ro, retifp, retrt)
! 496: struct sockaddr_in6 *dstsock;
! 497: struct ip6_pktopts *opts;
! 498: struct ip6_moptions *mopts;
! 499: struct route_in6 *ro;
! 500: struct ifnet **retifp;
! 501: struct rtentry **retrt;
! 502: {
! 503:
! 504: return (selectroute(dstsock, opts, mopts, ro, retifp, retrt, 0));
! 505: }
! 506:
! 507: /*
! 508: * Default hop limit selection. The precedence is as follows:
! 509: * 1. Hoplimit value specified via ioctl.
! 510: * 2. (If the outgoing interface is detected) the current
! 511: * hop limit of the interface specified by router advertisement.
! 512: * 3. The system default hoplimit.
! 513: */
! 514: #define in6pcb inpcb
! 515: #define in6p_hops inp_hops
! 516: int
! 517: in6_selecthlim(in6p, ifp)
! 518: struct in6pcb *in6p;
! 519: struct ifnet *ifp;
! 520: {
! 521: if (in6p && in6p->in6p_hops >= 0)
! 522: return (in6p->in6p_hops);
! 523: else if (ifp)
! 524: return (ND_IFINFO(ifp)->chlim);
! 525: else
! 526: return (ip6_defhlim);
! 527: }
! 528: #undef in6pcb
! 529: #undef in6p_hops
! 530:
! 531: /*
! 532: * generate kernel-internal form (scopeid embedded into s6_addr16[1]).
! 533: * If the address scope of is link-local, embed the interface index in the
! 534: * address. The routine determines our precedence
! 535: * between advanced API scope/interface specification and basic API
! 536: * specification.
! 537: *
! 538: * this function should be nuked in the future, when we get rid of
! 539: * embedded scopeid thing.
! 540: *
! 541: * XXX actually, it is over-specification to return ifp against sin6_scope_id.
! 542: * there can be multiple interfaces that belong to a particular scope zone
! 543: * (in specification, we have 1:N mapping between a scope zone and interfaces).
! 544: * we may want to change the function to return something other than ifp.
! 545: */
! 546: int
! 547: in6_embedscope(in6, sin6, in6p, ifpp)
! 548: struct in6_addr *in6;
! 549: const struct sockaddr_in6 *sin6;
! 550: struct inpcb *in6p;
! 551: #define in6p_outputopts inp_outputopts6
! 552: #define in6p_moptions inp_moptions6
! 553: struct ifnet **ifpp;
! 554: {
! 555: struct ifnet *ifp = NULL;
! 556: u_int32_t scopeid;
! 557:
! 558: *in6 = sin6->sin6_addr;
! 559: scopeid = sin6->sin6_scope_id;
! 560: if (ifpp)
! 561: *ifpp = NULL;
! 562:
! 563: /*
! 564: * don't try to read sin6->sin6_addr beyond here, since the caller may
! 565: * ask us to overwrite existing sockaddr_in6
! 566: */
! 567:
! 568: if (IN6_IS_SCOPE_EMBED(in6)) {
! 569: struct in6_pktinfo *pi;
! 570:
! 571: /*
! 572: * KAME assumption: link id == interface id
! 573: */
! 574:
! 575: if (in6p && in6p->in6p_outputopts &&
! 576: (pi = in6p->in6p_outputopts->ip6po_pktinfo) &&
! 577: pi->ipi6_ifindex) {
! 578: ifp = ifindex2ifnet[pi->ipi6_ifindex];
! 579: in6->s6_addr16[1] = htons(pi->ipi6_ifindex);
! 580: } else if (in6p && IN6_IS_ADDR_MULTICAST(in6) &&
! 581: in6p->in6p_moptions &&
! 582: in6p->in6p_moptions->im6o_multicast_ifp) {
! 583: ifp = in6p->in6p_moptions->im6o_multicast_ifp;
! 584: in6->s6_addr16[1] = htons(ifp->if_index);
! 585: } else if (scopeid) {
! 586: /* boundary check */
! 587: if (scopeid < 0 || if_indexlim <= scopeid ||
! 588: !ifindex2ifnet[scopeid])
! 589: return ENXIO; /* XXX EINVAL? */
! 590: ifp = ifindex2ifnet[scopeid];
! 591: /*XXX assignment to 16bit from 32bit variable */
! 592: in6->s6_addr16[1] = htons(scopeid & 0xffff);
! 593: }
! 594:
! 595: if (ifpp)
! 596: *ifpp = ifp;
! 597: }
! 598:
! 599: return 0;
! 600: }
! 601: #undef in6p_outputopts
! 602: #undef in6p_moptions
! 603:
! 604: /*
! 605: * generate standard sockaddr_in6 from embedded form.
! 606: * touches sin6_addr and sin6_scope_id only.
! 607: *
! 608: * this function should be nuked in the future, when we get rid of
! 609: * embedded scopeid thing.
! 610: */
! 611: int
! 612: in6_recoverscope(sin6, in6, ifp)
! 613: struct sockaddr_in6 *sin6;
! 614: const struct in6_addr *in6;
! 615: struct ifnet *ifp;
! 616: {
! 617: u_int32_t scopeid;
! 618:
! 619: sin6->sin6_addr = *in6;
! 620:
! 621: /*
! 622: * don't try to read *in6 beyond here, since the caller may
! 623: * ask us to overwrite existing sockaddr_in6
! 624: */
! 625:
! 626: sin6->sin6_scope_id = 0;
! 627: if (IN6_IS_SCOPE_EMBED(in6)) {
! 628: /*
! 629: * KAME assumption: link id == interface id
! 630: */
! 631: scopeid = ntohs(sin6->sin6_addr.s6_addr16[1]);
! 632: if (scopeid) {
! 633: /* sanity check */
! 634: if (scopeid < 0 || if_indexlim <= scopeid ||
! 635: !ifindex2ifnet[scopeid])
! 636: return ENXIO;
! 637: if (ifp && ifp->if_index != scopeid)
! 638: return ENXIO;
! 639: sin6->sin6_addr.s6_addr16[1] = 0;
! 640: sin6->sin6_scope_id = scopeid;
! 641: }
! 642: }
! 643:
! 644: return 0;
! 645: }
! 646:
! 647: /*
! 648: * just clear the embedded scope identifer.
! 649: */
! 650: void
! 651: in6_clearscope(addr)
! 652: struct in6_addr *addr;
! 653: {
! 654: if (IN6_IS_SCOPE_EMBED(addr))
! 655: addr->s6_addr16[1] = 0;
! 656: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to in6_src.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet6