8b07e49a00
This particular implementation is designed to be fully backwards compatible
and to be MFC-able to 7.x (and 6.x)
Currently the only protocol that can make use of the multiple tables is IPv4
Similar functionality exists in OpenBSD and Linux.
From my notes:
-----
One thing where FreeBSD has been falling behind, and which by chance I
have some time to work on is "policy based routing", which allows
different
packet streams to be routed by more than just the destination address.
Constraints:
------------
I want to make some form of this available in the 6.x tree
(and by extension 7.x) , but FreeBSD in general needs it so I might as
well do it in -current and back port the portions I need.
One of the ways that this can be done is to have the ability to
instantiate multiple kernel routing tables (which I will now
refer to as "Forwarding Information Bases" or "FIBs" for political
correctness reasons). Which FIB a particular packet uses to make
the next hop decision can be decided by a number of mechanisms.
The policies these mechanisms implement are the "Policies" referred
to in "Policy based routing".
One of the constraints I have if I try to back port this work to
6.x is that it must be implemented as a EXTENSION to the existing
ABIs in 6.x so that third party applications do not need to be
recompiled in timespan of the branch.
This first version will not have some of the bells and whistles that
will come with later versions. It will, for example, be limited to 16
tables in the first commit.
Implementation method, Compatible version. (part 1)
-------------------------------
For this reason I have implemented a "sufficient subset" of a
multiple routing table solution in Perforce, and back-ported it
to 6.x. (also in Perforce though not always caught up with what I
have done in -current/P4). The subset allows a number of FIBs
to be defined at compile time (8 is sufficient for my purposes in 6.x)
and implements the changes needed to allow IPV4 to use them. I have not
done the changes for ipv6 simply because I do not need it, and I do not
have enough knowledge of ipv6 (e.g. neighbor discovery) needed to do it.
Other protocol families are left untouched and should there be
users with proprietary protocol families, they should continue to work
and be oblivious to the existence of the extra FIBs.
To understand how this is done, one must know that the current FIB
code starts everything off with a single dimensional array of
pointers to FIB head structures (One per protocol family), each of
which in turn points to the trie of routes available to that family.
The basic change in the ABI compatible version of the change is to
extent that array to be a 2 dimensional array, so that
instead of protocol family X looking at rt_tables[X] for the
table it needs, it looks at rt_tables[Y][X] when for all
protocol families except ipv4 Y is always 0.
Code that is unaware of the change always just sees the first row
of the table, which of course looks just like the one dimensional
array that existed before.
The entry points rtrequest(), rtalloc(), rtalloc1(), rtalloc_ign()
are all maintained, but refer only to the first row of the array,
so that existing callers in proprietary protocols can continue to
do the "right thing".
Some new entry points are added, for the exclusive use of ipv4 code
called in_rtrequest(), in_rtalloc(), in_rtalloc1() and in_rtalloc_ign(),
which have an extra argument which refers the code to the correct row.
In addition, there are some new entry points (currently called
rtalloc_fib() and friends) that check the Address family being
looked up and call either rtalloc() (and friends) if the protocol
is not IPv4 forcing the action to row 0 or to the appropriate row
if it IS IPv4 (and that info is available). These are for calling
from code that is not specific to any particular protocol. The way
these are implemented would change in the non ABI preserving code
to be added later.
One feature of the first version of the code is that for ipv4,
the interface routes show up automatically on all the FIBs, so
that no matter what FIB you select you always have the basic
direct attached hosts available to you. (rtinit() does this
automatically).
You CAN delete an interface route from one FIB should you want
to but by default it's there. ARP information is also available
in each FIB. It's assumed that the same machine would have the
same MAC address, regardless of which FIB you are using to get
to it.
This brings us as to how the correct FIB is selected for an outgoing
IPV4 packet.
Firstly, all packets have a FIB associated with them. if nothing
has been done to change it, it will be FIB 0. The FIB is changed
in the following ways.
Packets fall into one of a number of classes.
1/ locally generated packets, coming from a socket/PCB.
Such packets select a FIB from a number associated with the
socket/PCB. This in turn is inherited from the process,
but can be changed by a socket option. The process in turn
inherits it on fork. I have written a utility call setfib
that acts a bit like nice..
setfib -3 ping target.example.com # will use fib 3 for ping.
It is an obvious extension to make it a property of a jail
but I have not done so. It can be achieved by combining the setfib and
jail commands.
2/ packets received on an interface for forwarding.
By default these packets would use table 0,
(or possibly a number settable in a sysctl(not yet)).
but prior to routing the firewall can inspect them (see below).
(possibly in the future you may be able to associate a FIB
with packets received on an interface.. An ifconfig arg, but not yet.)
3/ packets inspected by a packet classifier, which can arbitrarily
associate a fib with it on a packet by packet basis.
A fib assigned to a packet by a packet classifier
(such as ipfw) would over-ride a fib associated by
a more default source. (such as cases 1 or 2).
4/ a tcp listen socket associated with a fib will generate
accept sockets that are associated with that same fib.
5/ Packets generated in response to some other packet (e.g. reset
or icmp packets). These should use the FIB associated with the
packet being reponded to.
6/ Packets generated during encapsulation.
gif, tun and other tunnel interfaces will encapsulate using the FIB
that was in effect withthe proces that set up the tunnel.
thus setfib 1 ifconfig gif0 [tunnel instructions]
will set the fib for the tunnel to use to be fib 1.
Routing messages would be associated with their
process, and thus select one FIB or another.
messages from the kernel would be associated with the fib they
refer to and would only be received by a routing socket associated
with that fib. (not yet implemented)
In addition Netstat has been edited to be able to cope with the
fact that the array is now 2 dimensional. (It looks in system
memory using libkvm (!)). Old versions of netstat see only the first FIB.
In addition two sysctls are added to give:
a) the number of FIBs compiled in (active)
b) the default FIB of the calling process.
Early testing experience:
-------------------------
Basically our (IronPort's) appliance does this functionality already
using ipfw fwd but that method has some drawbacks.
For example,
It can't fully simulate a routing table because it can't influence the
socket's choice of local address when a connect() is done.
Testing during the generating of these changes has been
remarkably smooth so far. Multiple tables have co-existed
with no notable side effects, and packets have been routes
accordingly.
ipfw has grown 2 new keywords:
setfib N ip from anay to any
count ip from any to any fib N
In pf there seems to be a requirement to be able to give symbolic names to the
fibs but I do not have that capacity. I am not sure if it is required.
SCTP has interestingly enough built in support for this, called VRFs
in Cisco parlance. it will be interesting to see how that handles it
when it suddenly actually does something.
Where to next:
--------------------
After committing the ABI compatible version and MFCing it, I'd
like to proceed in a forward direction in -current. this will
result in some roto-tilling in the routing code.
Firstly: the current code's idea of having a separate tree per
protocol family, all of the same format, and pointed to by the
1 dimensional array is a bit silly. Especially when one considers that
there is code that makes assumptions about every protocol having the
same internal structures there. Some protocols don't WANT that
sort of structure. (for example the whole idea of a netmask is foreign
to appletalk). This needs to be made opaque to the external code.
My suggested first change is to add routing method pointers to the
'domain' structure, along with information pointing the data.
instead of having an array of pointers to uniform structures,
there would be an array pointing to the 'domain' structures
for each protocol address domain (protocol family),
and the methods this reached would be called. The methods would have
an argument that gives FIB number, but the protocol would be free
to ignore it.
When the ABI can be changed it raises the possibilty of the
addition of a fib entry into the "struct route". Currently,
the structure contains the sockaddr of the desination, and the resulting
fib entry. To make this work fully, one could add a fib number
so that given an address and a fib, one can find the third element, the
fib entry.
Interaction with the ARP layer/ LL layer would need to be
revisited as well. Qing Li has been working on this already.
This work was sponsored by Ironport Systems/Cisco
Reviewed by: several including rwatson, bz and mlair (parts each)
Obtained from: Ironport systems/Cisco
2316 lines
62 KiB
C
2316 lines
62 KiB
C
/*-
|
|
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the project nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $KAME: in6.c,v 1.259 2002/01/21 11:37:50 keiichi Exp $
|
|
*/
|
|
|
|
/*-
|
|
* Copyright (c) 1982, 1986, 1991, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)in.c 8.2 (Berkeley) 11/15/93
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include "opt_inet.h"
|
|
#include "opt_inet6.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/socketvar.h>
|
|
#include <sys/sockio.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/priv.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/time.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/syslog.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/if_types.h>
|
|
#include <net/route.h>
|
|
#include <net/if_dl.h>
|
|
|
|
#include <netinet/in.h>
|
|
#include <netinet/in_var.h>
|
|
#include <netinet/if_ether.h>
|
|
#include <netinet/in_systm.h>
|
|
#include <netinet/ip.h>
|
|
#include <netinet/in_pcb.h>
|
|
|
|
#include <netinet/ip6.h>
|
|
#include <netinet6/ip6_var.h>
|
|
#include <netinet6/nd6.h>
|
|
#include <netinet6/mld6_var.h>
|
|
#include <netinet6/ip6_mroute.h>
|
|
#include <netinet6/in6_ifattach.h>
|
|
#include <netinet6/scope6_var.h>
|
|
#include <netinet6/in6_pcb.h>
|
|
|
|
MALLOC_DEFINE(M_IP6MADDR, "in6_multi", "internet multicast address");
|
|
|
|
/*
|
|
* Definitions of some costant IP6 addresses.
|
|
*/
|
|
const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
|
|
const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
|
|
const struct in6_addr in6addr_nodelocal_allnodes =
|
|
IN6ADDR_NODELOCAL_ALLNODES_INIT;
|
|
const struct in6_addr in6addr_linklocal_allnodes =
|
|
IN6ADDR_LINKLOCAL_ALLNODES_INIT;
|
|
const struct in6_addr in6addr_linklocal_allrouters =
|
|
IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
|
|
|
|
const struct in6_addr in6mask0 = IN6MASK0;
|
|
const struct in6_addr in6mask32 = IN6MASK32;
|
|
const struct in6_addr in6mask64 = IN6MASK64;
|
|
const struct in6_addr in6mask96 = IN6MASK96;
|
|
const struct in6_addr in6mask128 = IN6MASK128;
|
|
|
|
const struct sockaddr_in6 sa6_any =
|
|
{ sizeof(sa6_any), AF_INET6, 0, 0, IN6ADDR_ANY_INIT, 0 };
|
|
|
|
static int in6_lifaddr_ioctl __P((struct socket *, u_long, caddr_t,
|
|
struct ifnet *, struct thread *));
|
|
static int in6_ifinit __P((struct ifnet *, struct in6_ifaddr *,
|
|
struct sockaddr_in6 *, int));
|
|
static void in6_unlink_ifa(struct in6_ifaddr *, struct ifnet *);
|
|
|
|
struct in6_multihead in6_multihead; /* XXX BSS initialization */
|
|
int (*faithprefix_p)(struct in6_addr *);
|
|
|
|
/*
|
|
* Subroutine for in6_ifaddloop() and in6_ifremloop().
|
|
* This routine does actual work.
|
|
*/
|
|
static void
|
|
in6_ifloop_request(int cmd, struct ifaddr *ifa)
|
|
{
|
|
struct sockaddr_in6 all1_sa;
|
|
struct rtentry *nrt = NULL;
|
|
int e;
|
|
char ip6buf[INET6_ADDRSTRLEN];
|
|
|
|
bzero(&all1_sa, sizeof(all1_sa));
|
|
all1_sa.sin6_family = AF_INET6;
|
|
all1_sa.sin6_len = sizeof(struct sockaddr_in6);
|
|
all1_sa.sin6_addr = in6mask128;
|
|
|
|
/*
|
|
* We specify the address itself as the gateway, and set the
|
|
* RTF_LLINFO flag, so that the corresponding host route would have
|
|
* the flag, and thus applications that assume traditional behavior
|
|
* would be happy. Note that we assume the caller of the function
|
|
* (probably implicitly) set nd6_rtrequest() to ifa->ifa_rtrequest,
|
|
* which changes the outgoing interface to the loopback interface.
|
|
*/
|
|
e = rtrequest(cmd, ifa->ifa_addr, ifa->ifa_addr,
|
|
(struct sockaddr *)&all1_sa, RTF_UP|RTF_HOST|RTF_LLINFO, &nrt);
|
|
if (e != 0) {
|
|
/* XXX need more descriptive message */
|
|
|
|
log(LOG_ERR, "in6_ifloop_request: "
|
|
"%s operation failed for %s (errno=%d)\n",
|
|
cmd == RTM_ADD ? "ADD" : "DELETE",
|
|
ip6_sprintf(ip6buf,
|
|
&((struct in6_ifaddr *)ifa)->ia_addr.sin6_addr), e);
|
|
}
|
|
|
|
/*
|
|
* Report the addition/removal of the address to the routing socket.
|
|
* XXX: since we called rtinit for a p2p interface with a destination,
|
|
* we end up reporting twice in such a case. Should we rather
|
|
* omit the second report?
|
|
*/
|
|
if (nrt) {
|
|
RT_LOCK(nrt);
|
|
/*
|
|
* Make sure rt_ifa be equal to IFA, the second argument of
|
|
* the function. We need this because when we refer to
|
|
* rt_ifa->ia6_flags in ip6_input, we assume that the rt_ifa
|
|
* points to the address instead of the loopback address.
|
|
*/
|
|
if (cmd == RTM_ADD && ifa != nrt->rt_ifa) {
|
|
IFAFREE(nrt->rt_ifa);
|
|
IFAREF(ifa);
|
|
nrt->rt_ifa = ifa;
|
|
}
|
|
|
|
rt_newaddrmsg(cmd, ifa, e, nrt);
|
|
if (cmd == RTM_DELETE)
|
|
RTFREE_LOCKED(nrt);
|
|
else {
|
|
/* the cmd must be RTM_ADD here */
|
|
RT_REMREF(nrt);
|
|
RT_UNLOCK(nrt);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add ownaddr as loopback rtentry. We previously add the route only if
|
|
* necessary (ex. on a p2p link). However, since we now manage addresses
|
|
* separately from prefixes, we should always add the route. We can't
|
|
* rely on the cloning mechanism from the corresponding interface route
|
|
* any more.
|
|
*/
|
|
void
|
|
in6_ifaddloop(struct ifaddr *ifa)
|
|
{
|
|
struct rtentry *rt;
|
|
int need_loop;
|
|
|
|
/* If there is no loopback entry, allocate one. */
|
|
rt = rtalloc1(ifa->ifa_addr, 0, 0);
|
|
need_loop = (rt == NULL || (rt->rt_flags & RTF_HOST) == 0 ||
|
|
(rt->rt_ifp->if_flags & IFF_LOOPBACK) == 0);
|
|
if (rt)
|
|
RTFREE_LOCKED(rt);
|
|
if (need_loop)
|
|
in6_ifloop_request(RTM_ADD, ifa);
|
|
}
|
|
|
|
/*
|
|
* Remove loopback rtentry of ownaddr generated by in6_ifaddloop(),
|
|
* if it exists.
|
|
*/
|
|
void
|
|
in6_ifremloop(struct ifaddr *ifa)
|
|
{
|
|
struct in6_ifaddr *ia;
|
|
struct rtentry *rt;
|
|
int ia_count = 0;
|
|
|
|
/*
|
|
* Some of BSD variants do not remove cloned routes
|
|
* from an interface direct route, when removing the direct route
|
|
* (see comments in net/net_osdep.h). Even for variants that do remove
|
|
* cloned routes, they could fail to remove the cloned routes when
|
|
* we handle multple addresses that share a common prefix.
|
|
* So, we should remove the route corresponding to the deleted address.
|
|
*/
|
|
|
|
/*
|
|
* Delete the entry only if exact one ifa exists. More than one ifa
|
|
* can exist if we assign a same single address to multiple
|
|
* (probably p2p) interfaces.
|
|
* XXX: we should avoid such a configuration in IPv6...
|
|
*/
|
|
for (ia = in6_ifaddr; ia; ia = ia->ia_next) {
|
|
if (IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa), &ia->ia_addr.sin6_addr)) {
|
|
ia_count++;
|
|
if (ia_count > 1)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ia_count == 1) {
|
|
/*
|
|
* Before deleting, check if a corresponding loopbacked host
|
|
* route surely exists. With this check, we can avoid to
|
|
* delete an interface direct route whose destination is same
|
|
* as the address being removed. This can happen when removing
|
|
* a subnet-router anycast address on an interface attahced
|
|
* to a shared medium.
|
|
*/
|
|
rt = rtalloc1(ifa->ifa_addr, 0, 0);
|
|
if (rt != NULL) {
|
|
if ((rt->rt_flags & RTF_HOST) != 0 &&
|
|
(rt->rt_ifp->if_flags & IFF_LOOPBACK) != 0) {
|
|
RTFREE_LOCKED(rt);
|
|
in6_ifloop_request(RTM_DELETE, ifa);
|
|
} else
|
|
RT_UNLOCK(rt);
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
in6_mask2len(struct in6_addr *mask, u_char *lim0)
|
|
{
|
|
int x = 0, y;
|
|
u_char *lim = lim0, *p;
|
|
|
|
/* ignore the scope_id part */
|
|
if (lim0 == NULL || lim0 - (u_char *)mask > sizeof(*mask))
|
|
lim = (u_char *)mask + sizeof(*mask);
|
|
for (p = (u_char *)mask; p < lim; x++, p++) {
|
|
if (*p != 0xff)
|
|
break;
|
|
}
|
|
y = 0;
|
|
if (p < lim) {
|
|
for (y = 0; y < 8; y++) {
|
|
if ((*p & (0x80 >> y)) == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* when the limit pointer is given, do a stricter check on the
|
|
* remaining bits.
|
|
*/
|
|
if (p < lim) {
|
|
if (y != 0 && (*p & (0x00ff >> y)) != 0)
|
|
return (-1);
|
|
for (p = p + 1; p < lim; p++)
|
|
if (*p != 0)
|
|
return (-1);
|
|
}
|
|
|
|
return x * 8 + y;
|
|
}
|
|
|
|
#define ifa2ia6(ifa) ((struct in6_ifaddr *)(ifa))
|
|
#define ia62ifa(ia6) (&((ia6)->ia_ifa))
|
|
|
|
int
|
|
in6_control(struct socket *so, u_long cmd, caddr_t data,
|
|
struct ifnet *ifp, struct thread *td)
|
|
{
|
|
struct in6_ifreq *ifr = (struct in6_ifreq *)data;
|
|
struct in6_ifaddr *ia = NULL;
|
|
struct in6_aliasreq *ifra = (struct in6_aliasreq *)data;
|
|
struct sockaddr_in6 *sa6;
|
|
int error;
|
|
|
|
switch (cmd) {
|
|
case SIOCGETSGCNT_IN6:
|
|
case SIOCGETMIFCNT_IN6:
|
|
return (mrt6_ioctl ? mrt6_ioctl(cmd, data) : EOPNOTSUPP);
|
|
}
|
|
|
|
switch(cmd) {
|
|
case SIOCAADDRCTL_POLICY:
|
|
case SIOCDADDRCTL_POLICY:
|
|
if (td != NULL) {
|
|
error = priv_check(td, PRIV_NETINET_ADDRCTRL6);
|
|
if (error)
|
|
return (error);
|
|
}
|
|
return (in6_src_ioctl(cmd, data));
|
|
}
|
|
|
|
if (ifp == NULL)
|
|
return (EOPNOTSUPP);
|
|
|
|
switch (cmd) {
|
|
case SIOCSNDFLUSH_IN6:
|
|
case SIOCSPFXFLUSH_IN6:
|
|
case SIOCSRTRFLUSH_IN6:
|
|
case SIOCSDEFIFACE_IN6:
|
|
case SIOCSIFINFO_FLAGS:
|
|
if (td != NULL) {
|
|
error = priv_check(td, PRIV_NETINET_ND6);
|
|
if (error)
|
|
return (error);
|
|
}
|
|
/* FALLTHROUGH */
|
|
case OSIOCGIFINFO_IN6:
|
|
case SIOCGIFINFO_IN6:
|
|
case SIOCSIFINFO_IN6:
|
|
case SIOCGDRLST_IN6:
|
|
case SIOCGPRLST_IN6:
|
|
case SIOCGNBRINFO_IN6:
|
|
case SIOCGDEFIFACE_IN6:
|
|
return (nd6_ioctl(cmd, data, ifp));
|
|
}
|
|
|
|
switch (cmd) {
|
|
case SIOCSIFPREFIX_IN6:
|
|
case SIOCDIFPREFIX_IN6:
|
|
case SIOCAIFPREFIX_IN6:
|
|
case SIOCCIFPREFIX_IN6:
|
|
case SIOCSGIFPREFIX_IN6:
|
|
case SIOCGIFPREFIX_IN6:
|
|
log(LOG_NOTICE,
|
|
"prefix ioctls are now invalidated. "
|
|
"please use ifconfig.\n");
|
|
return (EOPNOTSUPP);
|
|
}
|
|
|
|
switch (cmd) {
|
|
case SIOCSSCOPE6:
|
|
if (td != NULL) {
|
|
error = priv_check(td, PRIV_NETINET_SCOPE6);
|
|
if (error)
|
|
return (error);
|
|
}
|
|
return (scope6_set(ifp,
|
|
(struct scope6_id *)ifr->ifr_ifru.ifru_scope_id));
|
|
case SIOCGSCOPE6:
|
|
return (scope6_get(ifp,
|
|
(struct scope6_id *)ifr->ifr_ifru.ifru_scope_id));
|
|
case SIOCGSCOPE6DEF:
|
|
return (scope6_get_default((struct scope6_id *)
|
|
ifr->ifr_ifru.ifru_scope_id));
|
|
}
|
|
|
|
switch (cmd) {
|
|
case SIOCALIFADDR:
|
|
if (td != NULL) {
|
|
error = priv_check(td, PRIV_NET_ADDIFADDR);
|
|
if (error)
|
|
return (error);
|
|
}
|
|
return in6_lifaddr_ioctl(so, cmd, data, ifp, td);
|
|
|
|
case SIOCDLIFADDR:
|
|
if (td != NULL) {
|
|
error = priv_check(td, PRIV_NET_DELIFADDR);
|
|
if (error)
|
|
return (error);
|
|
}
|
|
/* FALLTHROUGH */
|
|
case SIOCGLIFADDR:
|
|
return in6_lifaddr_ioctl(so, cmd, data, ifp, td);
|
|
}
|
|
|
|
/*
|
|
* Find address for this interface, if it exists.
|
|
*
|
|
* In netinet code, we have checked ifra_addr in SIOCSIF*ADDR operation
|
|
* only, and used the first interface address as the target of other
|
|
* operations (without checking ifra_addr). This was because netinet
|
|
* code/API assumed at most 1 interface address per interface.
|
|
* Since IPv6 allows a node to assign multiple addresses
|
|
* on a single interface, we almost always look and check the
|
|
* presence of ifra_addr, and reject invalid ones here.
|
|
* It also decreases duplicated code among SIOC*_IN6 operations.
|
|
*/
|
|
switch (cmd) {
|
|
case SIOCAIFADDR_IN6:
|
|
case SIOCSIFPHYADDR_IN6:
|
|
sa6 = &ifra->ifra_addr;
|
|
break;
|
|
case SIOCSIFADDR_IN6:
|
|
case SIOCGIFADDR_IN6:
|
|
case SIOCSIFDSTADDR_IN6:
|
|
case SIOCSIFNETMASK_IN6:
|
|
case SIOCGIFDSTADDR_IN6:
|
|
case SIOCGIFNETMASK_IN6:
|
|
case SIOCDIFADDR_IN6:
|
|
case SIOCGIFPSRCADDR_IN6:
|
|
case SIOCGIFPDSTADDR_IN6:
|
|
case SIOCGIFAFLAG_IN6:
|
|
case SIOCSNDFLUSH_IN6:
|
|
case SIOCSPFXFLUSH_IN6:
|
|
case SIOCSRTRFLUSH_IN6:
|
|
case SIOCGIFALIFETIME_IN6:
|
|
case SIOCSIFALIFETIME_IN6:
|
|
case SIOCGIFSTAT_IN6:
|
|
case SIOCGIFSTAT_ICMP6:
|
|
sa6 = &ifr->ifr_addr;
|
|
break;
|
|
default:
|
|
sa6 = NULL;
|
|
break;
|
|
}
|
|
if (sa6 && sa6->sin6_family == AF_INET6) {
|
|
int error = 0;
|
|
|
|
if (sa6->sin6_scope_id != 0)
|
|
error = sa6_embedscope(sa6, 0);
|
|
else
|
|
error = in6_setscope(&sa6->sin6_addr, ifp, NULL);
|
|
if (error != 0)
|
|
return (error);
|
|
ia = in6ifa_ifpwithaddr(ifp, &sa6->sin6_addr);
|
|
} else
|
|
ia = NULL;
|
|
|
|
switch (cmd) {
|
|
case SIOCSIFADDR_IN6:
|
|
case SIOCSIFDSTADDR_IN6:
|
|
case SIOCSIFNETMASK_IN6:
|
|
/*
|
|
* Since IPv6 allows a node to assign multiple addresses
|
|
* on a single interface, SIOCSIFxxx ioctls are deprecated.
|
|
*/
|
|
/* we decided to obsolete this command (20000704) */
|
|
return (EINVAL);
|
|
|
|
case SIOCDIFADDR_IN6:
|
|
/*
|
|
* for IPv4, we look for existing in_ifaddr here to allow
|
|
* "ifconfig if0 delete" to remove the first IPv4 address on
|
|
* the interface. For IPv6, as the spec allows multiple
|
|
* interface address from the day one, we consider "remove the
|
|
* first one" semantics to be not preferable.
|
|
*/
|
|
if (ia == NULL)
|
|
return (EADDRNOTAVAIL);
|
|
/* FALLTHROUGH */
|
|
case SIOCAIFADDR_IN6:
|
|
/*
|
|
* We always require users to specify a valid IPv6 address for
|
|
* the corresponding operation.
|
|
*/
|
|
if (ifra->ifra_addr.sin6_family != AF_INET6 ||
|
|
ifra->ifra_addr.sin6_len != sizeof(struct sockaddr_in6))
|
|
return (EAFNOSUPPORT);
|
|
|
|
if (td != NULL) {
|
|
error = priv_check(td, (cmd == SIOCDIFADDR_IN6) ?
|
|
PRIV_NET_DELIFADDR : PRIV_NET_ADDIFADDR);
|
|
if (error)
|
|
return (error);
|
|
}
|
|
|
|
break;
|
|
|
|
case SIOCGIFADDR_IN6:
|
|
/* This interface is basically deprecated. use SIOCGIFCONF. */
|
|
/* FALLTHROUGH */
|
|
case SIOCGIFAFLAG_IN6:
|
|
case SIOCGIFNETMASK_IN6:
|
|
case SIOCGIFDSTADDR_IN6:
|
|
case SIOCGIFALIFETIME_IN6:
|
|
/* must think again about its semantics */
|
|
if (ia == NULL)
|
|
return (EADDRNOTAVAIL);
|
|
break;
|
|
case SIOCSIFALIFETIME_IN6:
|
|
{
|
|
struct in6_addrlifetime *lt;
|
|
|
|
if (td != NULL) {
|
|
error = priv_check(td, PRIV_NETINET_ALIFETIME6);
|
|
if (error)
|
|
return (error);
|
|
}
|
|
if (ia == NULL)
|
|
return (EADDRNOTAVAIL);
|
|
/* sanity for overflow - beware unsigned */
|
|
lt = &ifr->ifr_ifru.ifru_lifetime;
|
|
if (lt->ia6t_vltime != ND6_INFINITE_LIFETIME &&
|
|
lt->ia6t_vltime + time_second < time_second) {
|
|
return EINVAL;
|
|
}
|
|
if (lt->ia6t_pltime != ND6_INFINITE_LIFETIME &&
|
|
lt->ia6t_pltime + time_second < time_second) {
|
|
return EINVAL;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGIFADDR_IN6:
|
|
ifr->ifr_addr = ia->ia_addr;
|
|
if ((error = sa6_recoverscope(&ifr->ifr_addr)) != 0)
|
|
return (error);
|
|
break;
|
|
|
|
case SIOCGIFDSTADDR_IN6:
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
|
|
return (EINVAL);
|
|
/*
|
|
* XXX: should we check if ifa_dstaddr is NULL and return
|
|
* an error?
|
|
*/
|
|
ifr->ifr_dstaddr = ia->ia_dstaddr;
|
|
if ((error = sa6_recoverscope(&ifr->ifr_dstaddr)) != 0)
|
|
return (error);
|
|
break;
|
|
|
|
case SIOCGIFNETMASK_IN6:
|
|
ifr->ifr_addr = ia->ia_prefixmask;
|
|
break;
|
|
|
|
case SIOCGIFAFLAG_IN6:
|
|
ifr->ifr_ifru.ifru_flags6 = ia->ia6_flags;
|
|
break;
|
|
|
|
case SIOCGIFSTAT_IN6:
|
|
if (ifp == NULL)
|
|
return EINVAL;
|
|
bzero(&ifr->ifr_ifru.ifru_stat,
|
|
sizeof(ifr->ifr_ifru.ifru_stat));
|
|
ifr->ifr_ifru.ifru_stat =
|
|
*((struct in6_ifextra *)ifp->if_afdata[AF_INET6])->in6_ifstat;
|
|
break;
|
|
|
|
case SIOCGIFSTAT_ICMP6:
|
|
if (ifp == NULL)
|
|
return EINVAL;
|
|
bzero(&ifr->ifr_ifru.ifru_icmp6stat,
|
|
sizeof(ifr->ifr_ifru.ifru_icmp6stat));
|
|
ifr->ifr_ifru.ifru_icmp6stat =
|
|
*((struct in6_ifextra *)ifp->if_afdata[AF_INET6])->icmp6_ifstat;
|
|
break;
|
|
|
|
case SIOCGIFALIFETIME_IN6:
|
|
ifr->ifr_ifru.ifru_lifetime = ia->ia6_lifetime;
|
|
if (ia->ia6_lifetime.ia6t_vltime != ND6_INFINITE_LIFETIME) {
|
|
time_t maxexpire;
|
|
struct in6_addrlifetime *retlt =
|
|
&ifr->ifr_ifru.ifru_lifetime;
|
|
|
|
/*
|
|
* XXX: adjust expiration time assuming time_t is
|
|
* signed.
|
|
*/
|
|
maxexpire = (-1) &
|
|
~((time_t)1 << ((sizeof(maxexpire) * 8) - 1));
|
|
if (ia->ia6_lifetime.ia6t_vltime <
|
|
maxexpire - ia->ia6_updatetime) {
|
|
retlt->ia6t_expire = ia->ia6_updatetime +
|
|
ia->ia6_lifetime.ia6t_vltime;
|
|
} else
|
|
retlt->ia6t_expire = maxexpire;
|
|
}
|
|
if (ia->ia6_lifetime.ia6t_pltime != ND6_INFINITE_LIFETIME) {
|
|
time_t maxexpire;
|
|
struct in6_addrlifetime *retlt =
|
|
&ifr->ifr_ifru.ifru_lifetime;
|
|
|
|
/*
|
|
* XXX: adjust expiration time assuming time_t is
|
|
* signed.
|
|
*/
|
|
maxexpire = (-1) &
|
|
~((time_t)1 << ((sizeof(maxexpire) * 8) - 1));
|
|
if (ia->ia6_lifetime.ia6t_pltime <
|
|
maxexpire - ia->ia6_updatetime) {
|
|
retlt->ia6t_preferred = ia->ia6_updatetime +
|
|
ia->ia6_lifetime.ia6t_pltime;
|
|
} else
|
|
retlt->ia6t_preferred = maxexpire;
|
|
}
|
|
break;
|
|
|
|
case SIOCSIFALIFETIME_IN6:
|
|
ia->ia6_lifetime = ifr->ifr_ifru.ifru_lifetime;
|
|
/* for sanity */
|
|
if (ia->ia6_lifetime.ia6t_vltime != ND6_INFINITE_LIFETIME) {
|
|
ia->ia6_lifetime.ia6t_expire =
|
|
time_second + ia->ia6_lifetime.ia6t_vltime;
|
|
} else
|
|
ia->ia6_lifetime.ia6t_expire = 0;
|
|
if (ia->ia6_lifetime.ia6t_pltime != ND6_INFINITE_LIFETIME) {
|
|
ia->ia6_lifetime.ia6t_preferred =
|
|
time_second + ia->ia6_lifetime.ia6t_pltime;
|
|
} else
|
|
ia->ia6_lifetime.ia6t_preferred = 0;
|
|
break;
|
|
|
|
case SIOCAIFADDR_IN6:
|
|
{
|
|
int i, error = 0;
|
|
struct nd_prefixctl pr0;
|
|
struct nd_prefix *pr;
|
|
|
|
/*
|
|
* first, make or update the interface address structure,
|
|
* and link it to the list.
|
|
*/
|
|
if ((error = in6_update_ifa(ifp, ifra, ia, 0)) != 0)
|
|
return (error);
|
|
if ((ia = in6ifa_ifpwithaddr(ifp, &ifra->ifra_addr.sin6_addr))
|
|
== NULL) {
|
|
/*
|
|
* this can happen when the user specify the 0 valid
|
|
* lifetime.
|
|
*/
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* then, make the prefix on-link on the interface.
|
|
* XXX: we'd rather create the prefix before the address, but
|
|
* we need at least one address to install the corresponding
|
|
* interface route, so we configure the address first.
|
|
*/
|
|
|
|
/*
|
|
* convert mask to prefix length (prefixmask has already
|
|
* been validated in in6_update_ifa().
|
|
*/
|
|
bzero(&pr0, sizeof(pr0));
|
|
pr0.ndpr_ifp = ifp;
|
|
pr0.ndpr_plen = in6_mask2len(&ifra->ifra_prefixmask.sin6_addr,
|
|
NULL);
|
|
if (pr0.ndpr_plen == 128) {
|
|
break; /* we don't need to install a host route. */
|
|
}
|
|
pr0.ndpr_prefix = ifra->ifra_addr;
|
|
/* apply the mask for safety. */
|
|
for (i = 0; i < 4; i++) {
|
|
pr0.ndpr_prefix.sin6_addr.s6_addr32[i] &=
|
|
ifra->ifra_prefixmask.sin6_addr.s6_addr32[i];
|
|
}
|
|
/*
|
|
* XXX: since we don't have an API to set prefix (not address)
|
|
* lifetimes, we just use the same lifetimes as addresses.
|
|
* The (temporarily) installed lifetimes can be overridden by
|
|
* later advertised RAs (when accept_rtadv is non 0), which is
|
|
* an intended behavior.
|
|
*/
|
|
pr0.ndpr_raf_onlink = 1; /* should be configurable? */
|
|
pr0.ndpr_raf_auto =
|
|
((ifra->ifra_flags & IN6_IFF_AUTOCONF) != 0);
|
|
pr0.ndpr_vltime = ifra->ifra_lifetime.ia6t_vltime;
|
|
pr0.ndpr_pltime = ifra->ifra_lifetime.ia6t_pltime;
|
|
|
|
/* add the prefix if not yet. */
|
|
if ((pr = nd6_prefix_lookup(&pr0)) == NULL) {
|
|
/*
|
|
* nd6_prelist_add will install the corresponding
|
|
* interface route.
|
|
*/
|
|
if ((error = nd6_prelist_add(&pr0, NULL, &pr)) != 0)
|
|
return (error);
|
|
if (pr == NULL) {
|
|
log(LOG_ERR, "nd6_prelist_add succeeded but "
|
|
"no prefix\n");
|
|
return (EINVAL); /* XXX panic here? */
|
|
}
|
|
}
|
|
|
|
/* relate the address to the prefix */
|
|
if (ia->ia6_ndpr == NULL) {
|
|
ia->ia6_ndpr = pr;
|
|
pr->ndpr_refcnt++;
|
|
|
|
/*
|
|
* If this is the first autoconf address from the
|
|
* prefix, create a temporary address as well
|
|
* (when required).
|
|
*/
|
|
if ((ia->ia6_flags & IN6_IFF_AUTOCONF) &&
|
|
ip6_use_tempaddr && pr->ndpr_refcnt == 1) {
|
|
int e;
|
|
if ((e = in6_tmpifadd(ia, 1, 0)) != 0) {
|
|
log(LOG_NOTICE, "in6_control: failed "
|
|
"to create a temporary address, "
|
|
"errno=%d\n", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* this might affect the status of autoconfigured addresses,
|
|
* that is, this address might make other addresses detached.
|
|
*/
|
|
pfxlist_onlink_check();
|
|
if (error == 0 && ia)
|
|
EVENTHANDLER_INVOKE(ifaddr_event, ifp);
|
|
break;
|
|
}
|
|
|
|
case SIOCDIFADDR_IN6:
|
|
{
|
|
struct nd_prefix *pr;
|
|
|
|
/*
|
|
* If the address being deleted is the only one that owns
|
|
* the corresponding prefix, expire the prefix as well.
|
|
* XXX: theoretically, we don't have to worry about such
|
|
* relationship, since we separate the address management
|
|
* and the prefix management. We do this, however, to provide
|
|
* as much backward compatibility as possible in terms of
|
|
* the ioctl operation.
|
|
* Note that in6_purgeaddr() will decrement ndpr_refcnt.
|
|
*/
|
|
pr = ia->ia6_ndpr;
|
|
in6_purgeaddr(&ia->ia_ifa);
|
|
if (pr && pr->ndpr_refcnt == 0)
|
|
prelist_remove(pr);
|
|
EVENTHANDLER_INVOKE(ifaddr_event, ifp);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
if (ifp == NULL || ifp->if_ioctl == 0)
|
|
return (EOPNOTSUPP);
|
|
return ((*ifp->if_ioctl)(ifp, cmd, data));
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Update parameters of an IPv6 interface address.
|
|
* If necessary, a new entry is created and linked into address chains.
|
|
* This function is separated from in6_control().
|
|
* XXX: should this be performed under splnet()?
|
|
*/
|
|
int
|
|
in6_update_ifa(struct ifnet *ifp, struct in6_aliasreq *ifra,
|
|
struct in6_ifaddr *ia, int flags)
|
|
{
|
|
int error = 0, hostIsNew = 0, plen = -1;
|
|
struct in6_ifaddr *oia;
|
|
struct sockaddr_in6 dst6;
|
|
struct in6_addrlifetime *lt;
|
|
struct in6_multi_mship *imm;
|
|
struct in6_multi *in6m_sol;
|
|
struct rtentry *rt;
|
|
int delay;
|
|
char ip6buf[INET6_ADDRSTRLEN];
|
|
|
|
/* Validate parameters */
|
|
if (ifp == NULL || ifra == NULL) /* this maybe redundant */
|
|
return (EINVAL);
|
|
|
|
/*
|
|
* The destination address for a p2p link must have a family
|
|
* of AF_UNSPEC or AF_INET6.
|
|
*/
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) != 0 &&
|
|
ifra->ifra_dstaddr.sin6_family != AF_INET6 &&
|
|
ifra->ifra_dstaddr.sin6_family != AF_UNSPEC)
|
|
return (EAFNOSUPPORT);
|
|
/*
|
|
* validate ifra_prefixmask. don't check sin6_family, netmask
|
|
* does not carry fields other than sin6_len.
|
|
*/
|
|
if (ifra->ifra_prefixmask.sin6_len > sizeof(struct sockaddr_in6))
|
|
return (EINVAL);
|
|
/*
|
|
* Because the IPv6 address architecture is classless, we require
|
|
* users to specify a (non 0) prefix length (mask) for a new address.
|
|
* We also require the prefix (when specified) mask is valid, and thus
|
|
* reject a non-consecutive mask.
|
|
*/
|
|
if (ia == NULL && ifra->ifra_prefixmask.sin6_len == 0)
|
|
return (EINVAL);
|
|
if (ifra->ifra_prefixmask.sin6_len != 0) {
|
|
plen = in6_mask2len(&ifra->ifra_prefixmask.sin6_addr,
|
|
(u_char *)&ifra->ifra_prefixmask +
|
|
ifra->ifra_prefixmask.sin6_len);
|
|
if (plen <= 0)
|
|
return (EINVAL);
|
|
} else {
|
|
/*
|
|
* In this case, ia must not be NULL. We just use its prefix
|
|
* length.
|
|
*/
|
|
plen = in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL);
|
|
}
|
|
/*
|
|
* If the destination address on a p2p interface is specified,
|
|
* and the address is a scoped one, validate/set the scope
|
|
* zone identifier.
|
|
*/
|
|
dst6 = ifra->ifra_dstaddr;
|
|
if ((ifp->if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)) != 0 &&
|
|
(dst6.sin6_family == AF_INET6)) {
|
|
struct in6_addr in6_tmp;
|
|
u_int32_t zoneid;
|
|
|
|
in6_tmp = dst6.sin6_addr;
|
|
if (in6_setscope(&in6_tmp, ifp, &zoneid))
|
|
return (EINVAL); /* XXX: should be impossible */
|
|
|
|
if (dst6.sin6_scope_id != 0) {
|
|
if (dst6.sin6_scope_id != zoneid)
|
|
return (EINVAL);
|
|
} else /* user omit to specify the ID. */
|
|
dst6.sin6_scope_id = zoneid;
|
|
|
|
/* convert into the internal form */
|
|
if (sa6_embedscope(&dst6, 0))
|
|
return (EINVAL); /* XXX: should be impossible */
|
|
}
|
|
/*
|
|
* The destination address can be specified only for a p2p or a
|
|
* loopback interface. If specified, the corresponding prefix length
|
|
* must be 128.
|
|
*/
|
|
if (ifra->ifra_dstaddr.sin6_family == AF_INET6) {
|
|
if ((ifp->if_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)) == 0) {
|
|
/* XXX: noisy message */
|
|
nd6log((LOG_INFO, "in6_update_ifa: a destination can "
|
|
"be specified for a p2p or a loopback IF only\n"));
|
|
return (EINVAL);
|
|
}
|
|
if (plen != 128) {
|
|
nd6log((LOG_INFO, "in6_update_ifa: prefixlen should "
|
|
"be 128 when dstaddr is specified\n"));
|
|
return (EINVAL);
|
|
}
|
|
}
|
|
/* lifetime consistency check */
|
|
lt = &ifra->ifra_lifetime;
|
|
if (lt->ia6t_pltime > lt->ia6t_vltime)
|
|
return (EINVAL);
|
|
if (lt->ia6t_vltime == 0) {
|
|
/*
|
|
* the following log might be noisy, but this is a typical
|
|
* configuration mistake or a tool's bug.
|
|
*/
|
|
nd6log((LOG_INFO,
|
|
"in6_update_ifa: valid lifetime is 0 for %s\n",
|
|
ip6_sprintf(ip6buf, &ifra->ifra_addr.sin6_addr)));
|
|
|
|
if (ia == NULL)
|
|
return (0); /* there's nothing to do */
|
|
}
|
|
|
|
/*
|
|
* If this is a new address, allocate a new ifaddr and link it
|
|
* into chains.
|
|
*/
|
|
if (ia == NULL) {
|
|
hostIsNew = 1;
|
|
/*
|
|
* When in6_update_ifa() is called in a process of a received
|
|
* RA, it is called under an interrupt context. So, we should
|
|
* call malloc with M_NOWAIT.
|
|
*/
|
|
ia = (struct in6_ifaddr *) malloc(sizeof(*ia), M_IFADDR,
|
|
M_NOWAIT);
|
|
if (ia == NULL)
|
|
return (ENOBUFS);
|
|
bzero((caddr_t)ia, sizeof(*ia));
|
|
LIST_INIT(&ia->ia6_memberships);
|
|
/* Initialize the address and masks, and put time stamp */
|
|
IFA_LOCK_INIT(&ia->ia_ifa);
|
|
ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
|
|
ia->ia_addr.sin6_family = AF_INET6;
|
|
ia->ia_addr.sin6_len = sizeof(ia->ia_addr);
|
|
ia->ia6_createtime = time_second;
|
|
if ((ifp->if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) != 0) {
|
|
/*
|
|
* XXX: some functions expect that ifa_dstaddr is not
|
|
* NULL for p2p interfaces.
|
|
*/
|
|
ia->ia_ifa.ifa_dstaddr =
|
|
(struct sockaddr *)&ia->ia_dstaddr;
|
|
} else {
|
|
ia->ia_ifa.ifa_dstaddr = NULL;
|
|
}
|
|
ia->ia_ifa.ifa_netmask = (struct sockaddr *)&ia->ia_prefixmask;
|
|
|
|
ia->ia_ifp = ifp;
|
|
if ((oia = in6_ifaddr) != NULL) {
|
|
for ( ; oia->ia_next; oia = oia->ia_next)
|
|
continue;
|
|
oia->ia_next = ia;
|
|
} else
|
|
in6_ifaddr = ia;
|
|
|
|
ia->ia_ifa.ifa_refcnt = 1;
|
|
TAILQ_INSERT_TAIL(&ifp->if_addrlist, &ia->ia_ifa, ifa_list);
|
|
}
|
|
|
|
/* update timestamp */
|
|
ia->ia6_updatetime = time_second;
|
|
|
|
/* set prefix mask */
|
|
if (ifra->ifra_prefixmask.sin6_len) {
|
|
/*
|
|
* We prohibit changing the prefix length of an existing
|
|
* address, because
|
|
* + such an operation should be rare in IPv6, and
|
|
* + the operation would confuse prefix management.
|
|
*/
|
|
if (ia->ia_prefixmask.sin6_len &&
|
|
in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL) != plen) {
|
|
nd6log((LOG_INFO, "in6_update_ifa: the prefix length of an"
|
|
" existing (%s) address should not be changed\n",
|
|
ip6_sprintf(ip6buf, &ia->ia_addr.sin6_addr)));
|
|
error = EINVAL;
|
|
goto unlink;
|
|
}
|
|
ia->ia_prefixmask = ifra->ifra_prefixmask;
|
|
}
|
|
|
|
/*
|
|
* If a new destination address is specified, scrub the old one and
|
|
* install the new destination. Note that the interface must be
|
|
* p2p or loopback (see the check above.)
|
|
*/
|
|
if (dst6.sin6_family == AF_INET6 &&
|
|
!IN6_ARE_ADDR_EQUAL(&dst6.sin6_addr, &ia->ia_dstaddr.sin6_addr)) {
|
|
int e;
|
|
|
|
if ((ia->ia_flags & IFA_ROUTE) != 0 &&
|
|
(e = rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST)) != 0) {
|
|
nd6log((LOG_ERR, "in6_update_ifa: failed to remove "
|
|
"a route to the old destination: %s\n",
|
|
ip6_sprintf(ip6buf, &ia->ia_addr.sin6_addr)));
|
|
/* proceed anyway... */
|
|
} else
|
|
ia->ia_flags &= ~IFA_ROUTE;
|
|
ia->ia_dstaddr = dst6;
|
|
}
|
|
|
|
/*
|
|
* Set lifetimes. We do not refer to ia6t_expire and ia6t_preferred
|
|
* to see if the address is deprecated or invalidated, but initialize
|
|
* these members for applications.
|
|
*/
|
|
ia->ia6_lifetime = ifra->ifra_lifetime;
|
|
if (ia->ia6_lifetime.ia6t_vltime != ND6_INFINITE_LIFETIME) {
|
|
ia->ia6_lifetime.ia6t_expire =
|
|
time_second + ia->ia6_lifetime.ia6t_vltime;
|
|
} else
|
|
ia->ia6_lifetime.ia6t_expire = 0;
|
|
if (ia->ia6_lifetime.ia6t_pltime != ND6_INFINITE_LIFETIME) {
|
|
ia->ia6_lifetime.ia6t_preferred =
|
|
time_second + ia->ia6_lifetime.ia6t_pltime;
|
|
} else
|
|
ia->ia6_lifetime.ia6t_preferred = 0;
|
|
|
|
/* reset the interface and routing table appropriately. */
|
|
if ((error = in6_ifinit(ifp, ia, &ifra->ifra_addr, hostIsNew)) != 0)
|
|
goto unlink;
|
|
|
|
/*
|
|
* configure address flags.
|
|
*/
|
|
ia->ia6_flags = ifra->ifra_flags;
|
|
/*
|
|
* backward compatibility - if IN6_IFF_DEPRECATED is set from the
|
|
* userland, make it deprecated.
|
|
*/
|
|
if ((ifra->ifra_flags & IN6_IFF_DEPRECATED) != 0) {
|
|
ia->ia6_lifetime.ia6t_pltime = 0;
|
|
ia->ia6_lifetime.ia6t_preferred = time_second;
|
|
}
|
|
/*
|
|
* Make the address tentative before joining multicast addresses,
|
|
* so that corresponding MLD responses would not have a tentative
|
|
* source address.
|
|
*/
|
|
ia->ia6_flags &= ~IN6_IFF_DUPLICATED; /* safety */
|
|
if (hostIsNew && in6if_do_dad(ifp))
|
|
ia->ia6_flags |= IN6_IFF_TENTATIVE;
|
|
|
|
/*
|
|
* We are done if we have simply modified an existing address.
|
|
*/
|
|
if (!hostIsNew)
|
|
return (error);
|
|
|
|
/*
|
|
* Beyond this point, we should call in6_purgeaddr upon an error,
|
|
* not just go to unlink.
|
|
*/
|
|
|
|
/* Join necessary multicast groups */
|
|
in6m_sol = NULL;
|
|
if ((ifp->if_flags & IFF_MULTICAST) != 0) {
|
|
struct sockaddr_in6 mltaddr, mltmask;
|
|
struct in6_addr llsol;
|
|
|
|
/* join solicited multicast addr for new host id */
|
|
bzero(&llsol, sizeof(struct in6_addr));
|
|
llsol.s6_addr32[0] = IPV6_ADDR_INT32_MLL;
|
|
llsol.s6_addr32[1] = 0;
|
|
llsol.s6_addr32[2] = htonl(1);
|
|
llsol.s6_addr32[3] = ifra->ifra_addr.sin6_addr.s6_addr32[3];
|
|
llsol.s6_addr8[12] = 0xff;
|
|
if ((error = in6_setscope(&llsol, ifp, NULL)) != 0) {
|
|
/* XXX: should not happen */
|
|
log(LOG_ERR, "in6_update_ifa: "
|
|
"in6_setscope failed\n");
|
|
goto cleanup;
|
|
}
|
|
delay = 0;
|
|
if ((flags & IN6_IFAUPDATE_DADDELAY)) {
|
|
/*
|
|
* We need a random delay for DAD on the address
|
|
* being configured. It also means delaying
|
|
* transmission of the corresponding MLD report to
|
|
* avoid report collision.
|
|
* [draft-ietf-ipv6-rfc2462bis-02.txt]
|
|
*/
|
|
delay = arc4random() %
|
|
(MAX_RTR_SOLICITATION_DELAY * hz);
|
|
}
|
|
imm = in6_joingroup(ifp, &llsol, &error, delay);
|
|
if (imm == NULL) {
|
|
nd6log((LOG_WARNING,
|
|
"in6_update_ifa: addmulti failed for "
|
|
"%s on %s (errno=%d)\n",
|
|
ip6_sprintf(ip6buf, &llsol), if_name(ifp),
|
|
error));
|
|
in6_purgeaddr((struct ifaddr *)ia);
|
|
return (error);
|
|
}
|
|
LIST_INSERT_HEAD(&ia->ia6_memberships,
|
|
imm, i6mm_chain);
|
|
in6m_sol = imm->i6mm_maddr;
|
|
|
|
bzero(&mltmask, sizeof(mltmask));
|
|
mltmask.sin6_len = sizeof(struct sockaddr_in6);
|
|
mltmask.sin6_family = AF_INET6;
|
|
mltmask.sin6_addr = in6mask32;
|
|
#define MLTMASK_LEN 4 /* mltmask's masklen (=32bit=4octet) */
|
|
|
|
/*
|
|
* join link-local all-nodes address
|
|
*/
|
|
bzero(&mltaddr, sizeof(mltaddr));
|
|
mltaddr.sin6_len = sizeof(struct sockaddr_in6);
|
|
mltaddr.sin6_family = AF_INET6;
|
|
mltaddr.sin6_addr = in6addr_linklocal_allnodes;
|
|
if ((error = in6_setscope(&mltaddr.sin6_addr, ifp, NULL)) !=
|
|
0)
|
|
goto cleanup; /* XXX: should not fail */
|
|
|
|
/*
|
|
* XXX: do we really need this automatic routes?
|
|
* We should probably reconsider this stuff. Most applications
|
|
* actually do not need the routes, since they usually specify
|
|
* the outgoing interface.
|
|
*/
|
|
rt = rtalloc1((struct sockaddr *)&mltaddr, 0, 0UL);
|
|
if (rt) {
|
|
/* XXX: only works in !SCOPEDROUTING case. */
|
|
if (memcmp(&mltaddr.sin6_addr,
|
|
&((struct sockaddr_in6 *)rt_key(rt))->sin6_addr,
|
|
MLTMASK_LEN)) {
|
|
RTFREE_LOCKED(rt);
|
|
rt = NULL;
|
|
}
|
|
}
|
|
if (!rt) {
|
|
/* XXX: we need RTF_CLONING to fake nd6_rtrequest */
|
|
error = rtrequest(RTM_ADD, (struct sockaddr *)&mltaddr,
|
|
(struct sockaddr *)&ia->ia_addr,
|
|
(struct sockaddr *)&mltmask, RTF_UP | RTF_CLONING,
|
|
(struct rtentry **)0);
|
|
if (error)
|
|
goto cleanup;
|
|
} else {
|
|
RTFREE_LOCKED(rt);
|
|
}
|
|
|
|
imm = in6_joingroup(ifp, &mltaddr.sin6_addr, &error, 0);
|
|
if (!imm) {
|
|
nd6log((LOG_WARNING,
|
|
"in6_update_ifa: addmulti failed for "
|
|
"%s on %s (errno=%d)\n",
|
|
ip6_sprintf(ip6buf, &mltaddr.sin6_addr),
|
|
if_name(ifp), error));
|
|
goto cleanup;
|
|
}
|
|
LIST_INSERT_HEAD(&ia->ia6_memberships, imm, i6mm_chain);
|
|
|
|
/*
|
|
* join node information group address
|
|
*/
|
|
#define hostnamelen strlen(hostname)
|
|
delay = 0;
|
|
if ((flags & IN6_IFAUPDATE_DADDELAY)) {
|
|
/*
|
|
* The spec doesn't say anything about delay for this
|
|
* group, but the same logic should apply.
|
|
*/
|
|
delay = arc4random() %
|
|
(MAX_RTR_SOLICITATION_DELAY * hz);
|
|
}
|
|
if (in6_nigroup(ifp, hostname, hostnamelen, &mltaddr.sin6_addr)
|
|
== 0) {
|
|
imm = in6_joingroup(ifp, &mltaddr.sin6_addr, &error,
|
|
delay); /* XXX jinmei */
|
|
if (!imm) {
|
|
nd6log((LOG_WARNING, "in6_update_ifa: "
|
|
"addmulti failed for %s on %s "
|
|
"(errno=%d)\n",
|
|
ip6_sprintf(ip6buf, &mltaddr.sin6_addr),
|
|
if_name(ifp), error));
|
|
/* XXX not very fatal, go on... */
|
|
} else {
|
|
LIST_INSERT_HEAD(&ia->ia6_memberships,
|
|
imm, i6mm_chain);
|
|
}
|
|
}
|
|
#undef hostnamelen
|
|
|
|
/*
|
|
* join interface-local all-nodes address.
|
|
* (ff01::1%ifN, and ff01::%ifN/32)
|
|
*/
|
|
mltaddr.sin6_addr = in6addr_nodelocal_allnodes;
|
|
if ((error = in6_setscope(&mltaddr.sin6_addr, ifp, NULL))
|
|
!= 0)
|
|
goto cleanup; /* XXX: should not fail */
|
|
/* XXX: again, do we really need the route? */
|
|
rt = rtalloc1((struct sockaddr *)&mltaddr, 0, 0UL);
|
|
if (rt) {
|
|
if (memcmp(&mltaddr.sin6_addr,
|
|
&((struct sockaddr_in6 *)rt_key(rt))->sin6_addr,
|
|
MLTMASK_LEN)) {
|
|
RTFREE_LOCKED(rt);
|
|
rt = NULL;
|
|
}
|
|
}
|
|
if (!rt) {
|
|
error = rtrequest(RTM_ADD, (struct sockaddr *)&mltaddr,
|
|
(struct sockaddr *)&ia->ia_addr,
|
|
(struct sockaddr *)&mltmask, RTF_UP | RTF_CLONING,
|
|
(struct rtentry **)0);
|
|
if (error)
|
|
goto cleanup;
|
|
} else
|
|
RTFREE_LOCKED(rt);
|
|
|
|
imm = in6_joingroup(ifp, &mltaddr.sin6_addr, &error, 0);
|
|
if (!imm) {
|
|
nd6log((LOG_WARNING, "in6_update_ifa: "
|
|
"addmulti failed for %s on %s "
|
|
"(errno=%d)\n",
|
|
ip6_sprintf(ip6buf, &mltaddr.sin6_addr),
|
|
if_name(ifp), error));
|
|
goto cleanup;
|
|
}
|
|
LIST_INSERT_HEAD(&ia->ia6_memberships, imm, i6mm_chain);
|
|
#undef MLTMASK_LEN
|
|
}
|
|
|
|
/*
|
|
* Perform DAD, if needed.
|
|
* XXX It may be of use, if we can administratively
|
|
* disable DAD.
|
|
*/
|
|
if (hostIsNew && in6if_do_dad(ifp) &&
|
|
((ifra->ifra_flags & IN6_IFF_NODAD) == 0) &&
|
|
(ia->ia6_flags & IN6_IFF_TENTATIVE))
|
|
{
|
|
int mindelay, maxdelay;
|
|
|
|
delay = 0;
|
|
if ((flags & IN6_IFAUPDATE_DADDELAY)) {
|
|
/*
|
|
* We need to impose a delay before sending an NS
|
|
* for DAD. Check if we also needed a delay for the
|
|
* corresponding MLD message. If we did, the delay
|
|
* should be larger than the MLD delay (this could be
|
|
* relaxed a bit, but this simple logic is at least
|
|
* safe).
|
|
*/
|
|
mindelay = 0;
|
|
if (in6m_sol != NULL &&
|
|
in6m_sol->in6m_state == MLD_REPORTPENDING) {
|
|
mindelay = in6m_sol->in6m_timer;
|
|
}
|
|
maxdelay = MAX_RTR_SOLICITATION_DELAY * hz;
|
|
if (maxdelay - mindelay == 0)
|
|
delay = 0;
|
|
else {
|
|
delay =
|
|
(arc4random() % (maxdelay - mindelay)) +
|
|
mindelay;
|
|
}
|
|
}
|
|
nd6_dad_start((struct ifaddr *)ia, delay);
|
|
}
|
|
|
|
return (error);
|
|
|
|
unlink:
|
|
/*
|
|
* XXX: if a change of an existing address failed, keep the entry
|
|
* anyway.
|
|
*/
|
|
if (hostIsNew)
|
|
in6_unlink_ifa(ia, ifp);
|
|
return (error);
|
|
|
|
cleanup:
|
|
in6_purgeaddr(&ia->ia_ifa);
|
|
return error;
|
|
}
|
|
|
|
void
|
|
in6_purgeaddr(struct ifaddr *ifa)
|
|
{
|
|
struct ifnet *ifp = ifa->ifa_ifp;
|
|
struct in6_ifaddr *ia = (struct in6_ifaddr *) ifa;
|
|
char ip6buf[INET6_ADDRSTRLEN];
|
|
struct in6_multi_mship *imm;
|
|
|
|
/* stop DAD processing */
|
|
nd6_dad_stop(ifa);
|
|
|
|
/*
|
|
* delete route to the destination of the address being purged.
|
|
* The interface must be p2p or loopback in this case.
|
|
*/
|
|
if ((ia->ia_flags & IFA_ROUTE) != 0 && ia->ia_dstaddr.sin6_len != 0) {
|
|
int e;
|
|
|
|
if ((e = rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST))
|
|
!= 0) {
|
|
log(LOG_ERR, "in6_purgeaddr: failed to remove "
|
|
"a route to the p2p destination: %s on %s, "
|
|
"errno=%d\n",
|
|
ip6_sprintf(ip6buf, &ia->ia_addr.sin6_addr),
|
|
if_name(ifp), e);
|
|
/* proceed anyway... */
|
|
} else
|
|
ia->ia_flags &= ~IFA_ROUTE;
|
|
}
|
|
|
|
/* Remove ownaddr's loopback rtentry, if it exists. */
|
|
in6_ifremloop(&(ia->ia_ifa));
|
|
|
|
/*
|
|
* leave from multicast groups we have joined for the interface
|
|
*/
|
|
while ((imm = ia->ia6_memberships.lh_first) != NULL) {
|
|
LIST_REMOVE(imm, i6mm_chain);
|
|
in6_leavegroup(imm);
|
|
}
|
|
|
|
in6_unlink_ifa(ia, ifp);
|
|
}
|
|
|
|
static void
|
|
in6_unlink_ifa(struct in6_ifaddr *ia, struct ifnet *ifp)
|
|
{
|
|
struct in6_ifaddr *oia;
|
|
int s = splnet();
|
|
|
|
TAILQ_REMOVE(&ifp->if_addrlist, &ia->ia_ifa, ifa_list);
|
|
|
|
oia = ia;
|
|
if (oia == (ia = in6_ifaddr))
|
|
in6_ifaddr = ia->ia_next;
|
|
else {
|
|
while (ia->ia_next && (ia->ia_next != oia))
|
|
ia = ia->ia_next;
|
|
if (ia->ia_next)
|
|
ia->ia_next = oia->ia_next;
|
|
else {
|
|
/* search failed */
|
|
printf("Couldn't unlink in6_ifaddr from in6_ifaddr\n");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Release the reference to the base prefix. There should be a
|
|
* positive reference.
|
|
*/
|
|
if (oia->ia6_ndpr == NULL) {
|
|
nd6log((LOG_NOTICE,
|
|
"in6_unlink_ifa: autoconf'ed address "
|
|
"%p has no prefix\n", oia));
|
|
} else {
|
|
oia->ia6_ndpr->ndpr_refcnt--;
|
|
oia->ia6_ndpr = NULL;
|
|
}
|
|
|
|
/*
|
|
* Also, if the address being removed is autoconf'ed, call
|
|
* pfxlist_onlink_check() since the release might affect the status of
|
|
* other (detached) addresses.
|
|
*/
|
|
if ((oia->ia6_flags & IN6_IFF_AUTOCONF)) {
|
|
pfxlist_onlink_check();
|
|
}
|
|
|
|
/*
|
|
* release another refcnt for the link from in6_ifaddr.
|
|
* Note that we should decrement the refcnt at least once for all *BSD.
|
|
*/
|
|
IFAFREE(&oia->ia_ifa);
|
|
|
|
splx(s);
|
|
}
|
|
|
|
void
|
|
in6_purgeif(struct ifnet *ifp)
|
|
{
|
|
struct ifaddr *ifa, *nifa;
|
|
|
|
for (ifa = TAILQ_FIRST(&ifp->if_addrlist); ifa != NULL; ifa = nifa) {
|
|
nifa = TAILQ_NEXT(ifa, ifa_list);
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
continue;
|
|
in6_purgeaddr(ifa);
|
|
}
|
|
|
|
in6_ifdetach(ifp);
|
|
}
|
|
|
|
/*
|
|
* SIOC[GAD]LIFADDR.
|
|
* SIOCGLIFADDR: get first address. (?)
|
|
* SIOCGLIFADDR with IFLR_PREFIX:
|
|
* get first address that matches the specified prefix.
|
|
* SIOCALIFADDR: add the specified address.
|
|
* SIOCALIFADDR with IFLR_PREFIX:
|
|
* add the specified prefix, filling hostid part from
|
|
* the first link-local address. prefixlen must be <= 64.
|
|
* SIOCDLIFADDR: delete the specified address.
|
|
* SIOCDLIFADDR with IFLR_PREFIX:
|
|
* delete the first address that matches the specified prefix.
|
|
* return values:
|
|
* EINVAL on invalid parameters
|
|
* EADDRNOTAVAIL on prefix match failed/specified address not found
|
|
* other values may be returned from in6_ioctl()
|
|
*
|
|
* NOTE: SIOCALIFADDR(with IFLR_PREFIX set) allows prefixlen less than 64.
|
|
* this is to accomodate address naming scheme other than RFC2374,
|
|
* in the future.
|
|
* RFC2373 defines interface id to be 64bit, but it allows non-RFC2374
|
|
* address encoding scheme. (see figure on page 8)
|
|
*/
|
|
static int
|
|
in6_lifaddr_ioctl(struct socket *so, u_long cmd, caddr_t data,
|
|
struct ifnet *ifp, struct thread *td)
|
|
{
|
|
struct if_laddrreq *iflr = (struct if_laddrreq *)data;
|
|
struct ifaddr *ifa;
|
|
struct sockaddr *sa;
|
|
|
|
/* sanity checks */
|
|
if (!data || !ifp) {
|
|
panic("invalid argument to in6_lifaddr_ioctl");
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
switch (cmd) {
|
|
case SIOCGLIFADDR:
|
|
/* address must be specified on GET with IFLR_PREFIX */
|
|
if ((iflr->flags & IFLR_PREFIX) == 0)
|
|
break;
|
|
/* FALLTHROUGH */
|
|
case SIOCALIFADDR:
|
|
case SIOCDLIFADDR:
|
|
/* address must be specified on ADD and DELETE */
|
|
sa = (struct sockaddr *)&iflr->addr;
|
|
if (sa->sa_family != AF_INET6)
|
|
return EINVAL;
|
|
if (sa->sa_len != sizeof(struct sockaddr_in6))
|
|
return EINVAL;
|
|
/* XXX need improvement */
|
|
sa = (struct sockaddr *)&iflr->dstaddr;
|
|
if (sa->sa_family && sa->sa_family != AF_INET6)
|
|
return EINVAL;
|
|
if (sa->sa_len && sa->sa_len != sizeof(struct sockaddr_in6))
|
|
return EINVAL;
|
|
break;
|
|
default: /* shouldn't happen */
|
|
#if 0
|
|
panic("invalid cmd to in6_lifaddr_ioctl");
|
|
/* NOTREACHED */
|
|
#else
|
|
return EOPNOTSUPP;
|
|
#endif
|
|
}
|
|
if (sizeof(struct in6_addr) * 8 < iflr->prefixlen)
|
|
return EINVAL;
|
|
|
|
switch (cmd) {
|
|
case SIOCALIFADDR:
|
|
{
|
|
struct in6_aliasreq ifra;
|
|
struct in6_addr *hostid = NULL;
|
|
int prefixlen;
|
|
|
|
if ((iflr->flags & IFLR_PREFIX) != 0) {
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
/*
|
|
* hostid is to fill in the hostid part of the
|
|
* address. hostid points to the first link-local
|
|
* address attached to the interface.
|
|
*/
|
|
ifa = (struct ifaddr *)in6ifa_ifpforlinklocal(ifp, 0);
|
|
if (!ifa)
|
|
return EADDRNOTAVAIL;
|
|
hostid = IFA_IN6(ifa);
|
|
|
|
/* prefixlen must be <= 64. */
|
|
if (64 < iflr->prefixlen)
|
|
return EINVAL;
|
|
prefixlen = iflr->prefixlen;
|
|
|
|
/* hostid part must be zero. */
|
|
sin6 = (struct sockaddr_in6 *)&iflr->addr;
|
|
if (sin6->sin6_addr.s6_addr32[2] != 0 ||
|
|
sin6->sin6_addr.s6_addr32[3] != 0) {
|
|
return EINVAL;
|
|
}
|
|
} else
|
|
prefixlen = iflr->prefixlen;
|
|
|
|
/* copy args to in6_aliasreq, perform ioctl(SIOCAIFADDR_IN6). */
|
|
bzero(&ifra, sizeof(ifra));
|
|
bcopy(iflr->iflr_name, ifra.ifra_name, sizeof(ifra.ifra_name));
|
|
|
|
bcopy(&iflr->addr, &ifra.ifra_addr,
|
|
((struct sockaddr *)&iflr->addr)->sa_len);
|
|
if (hostid) {
|
|
/* fill in hostid part */
|
|
ifra.ifra_addr.sin6_addr.s6_addr32[2] =
|
|
hostid->s6_addr32[2];
|
|
ifra.ifra_addr.sin6_addr.s6_addr32[3] =
|
|
hostid->s6_addr32[3];
|
|
}
|
|
|
|
if (((struct sockaddr *)&iflr->dstaddr)->sa_family) { /* XXX */
|
|
bcopy(&iflr->dstaddr, &ifra.ifra_dstaddr,
|
|
((struct sockaddr *)&iflr->dstaddr)->sa_len);
|
|
if (hostid) {
|
|
ifra.ifra_dstaddr.sin6_addr.s6_addr32[2] =
|
|
hostid->s6_addr32[2];
|
|
ifra.ifra_dstaddr.sin6_addr.s6_addr32[3] =
|
|
hostid->s6_addr32[3];
|
|
}
|
|
}
|
|
|
|
ifra.ifra_prefixmask.sin6_len = sizeof(struct sockaddr_in6);
|
|
in6_prefixlen2mask(&ifra.ifra_prefixmask.sin6_addr, prefixlen);
|
|
|
|
ifra.ifra_flags = iflr->flags & ~IFLR_PREFIX;
|
|
return in6_control(so, SIOCAIFADDR_IN6, (caddr_t)&ifra, ifp, td);
|
|
}
|
|
case SIOCGLIFADDR:
|
|
case SIOCDLIFADDR:
|
|
{
|
|
struct in6_ifaddr *ia;
|
|
struct in6_addr mask, candidate, match;
|
|
struct sockaddr_in6 *sin6;
|
|
int cmp;
|
|
|
|
bzero(&mask, sizeof(mask));
|
|
if (iflr->flags & IFLR_PREFIX) {
|
|
/* lookup a prefix rather than address. */
|
|
in6_prefixlen2mask(&mask, iflr->prefixlen);
|
|
|
|
sin6 = (struct sockaddr_in6 *)&iflr->addr;
|
|
bcopy(&sin6->sin6_addr, &match, sizeof(match));
|
|
match.s6_addr32[0] &= mask.s6_addr32[0];
|
|
match.s6_addr32[1] &= mask.s6_addr32[1];
|
|
match.s6_addr32[2] &= mask.s6_addr32[2];
|
|
match.s6_addr32[3] &= mask.s6_addr32[3];
|
|
|
|
/* if you set extra bits, that's wrong */
|
|
if (bcmp(&match, &sin6->sin6_addr, sizeof(match)))
|
|
return EINVAL;
|
|
|
|
cmp = 1;
|
|
} else {
|
|
if (cmd == SIOCGLIFADDR) {
|
|
/* on getting an address, take the 1st match */
|
|
cmp = 0; /* XXX */
|
|
} else {
|
|
/* on deleting an address, do exact match */
|
|
in6_prefixlen2mask(&mask, 128);
|
|
sin6 = (struct sockaddr_in6 *)&iflr->addr;
|
|
bcopy(&sin6->sin6_addr, &match, sizeof(match));
|
|
|
|
cmp = 1;
|
|
}
|
|
}
|
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
continue;
|
|
if (!cmp)
|
|
break;
|
|
|
|
/*
|
|
* XXX: this is adhoc, but is necessary to allow
|
|
* a user to specify fe80::/64 (not /10) for a
|
|
* link-local address.
|
|
*/
|
|
bcopy(IFA_IN6(ifa), &candidate, sizeof(candidate));
|
|
in6_clearscope(&candidate);
|
|
candidate.s6_addr32[0] &= mask.s6_addr32[0];
|
|
candidate.s6_addr32[1] &= mask.s6_addr32[1];
|
|
candidate.s6_addr32[2] &= mask.s6_addr32[2];
|
|
candidate.s6_addr32[3] &= mask.s6_addr32[3];
|
|
if (IN6_ARE_ADDR_EQUAL(&candidate, &match))
|
|
break;
|
|
}
|
|
if (!ifa)
|
|
return EADDRNOTAVAIL;
|
|
ia = ifa2ia6(ifa);
|
|
|
|
if (cmd == SIOCGLIFADDR) {
|
|
int error;
|
|
|
|
/* fill in the if_laddrreq structure */
|
|
bcopy(&ia->ia_addr, &iflr->addr, ia->ia_addr.sin6_len);
|
|
error = sa6_recoverscope(
|
|
(struct sockaddr_in6 *)&iflr->addr);
|
|
if (error != 0)
|
|
return (error);
|
|
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) != 0) {
|
|
bcopy(&ia->ia_dstaddr, &iflr->dstaddr,
|
|
ia->ia_dstaddr.sin6_len);
|
|
error = sa6_recoverscope(
|
|
(struct sockaddr_in6 *)&iflr->dstaddr);
|
|
if (error != 0)
|
|
return (error);
|
|
} else
|
|
bzero(&iflr->dstaddr, sizeof(iflr->dstaddr));
|
|
|
|
iflr->prefixlen =
|
|
in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL);
|
|
|
|
iflr->flags = ia->ia6_flags; /* XXX */
|
|
|
|
return 0;
|
|
} else {
|
|
struct in6_aliasreq ifra;
|
|
|
|
/* fill in6_aliasreq and do ioctl(SIOCDIFADDR_IN6) */
|
|
bzero(&ifra, sizeof(ifra));
|
|
bcopy(iflr->iflr_name, ifra.ifra_name,
|
|
sizeof(ifra.ifra_name));
|
|
|
|
bcopy(&ia->ia_addr, &ifra.ifra_addr,
|
|
ia->ia_addr.sin6_len);
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) != 0) {
|
|
bcopy(&ia->ia_dstaddr, &ifra.ifra_dstaddr,
|
|
ia->ia_dstaddr.sin6_len);
|
|
} else {
|
|
bzero(&ifra.ifra_dstaddr,
|
|
sizeof(ifra.ifra_dstaddr));
|
|
}
|
|
bcopy(&ia->ia_prefixmask, &ifra.ifra_dstaddr,
|
|
ia->ia_prefixmask.sin6_len);
|
|
|
|
ifra.ifra_flags = ia->ia6_flags;
|
|
return in6_control(so, SIOCDIFADDR_IN6, (caddr_t)&ifra,
|
|
ifp, td);
|
|
}
|
|
}
|
|
}
|
|
|
|
return EOPNOTSUPP; /* just for safety */
|
|
}
|
|
|
|
/*
|
|
* Initialize an interface's intetnet6 address
|
|
* and routing table entry.
|
|
*/
|
|
static int
|
|
in6_ifinit(struct ifnet *ifp, struct in6_ifaddr *ia,
|
|
struct sockaddr_in6 *sin6, int newhost)
|
|
{
|
|
int error = 0, plen, ifacount = 0;
|
|
int s = splimp();
|
|
struct ifaddr *ifa;
|
|
|
|
/*
|
|
* Give the interface a chance to initialize
|
|
* if this is its first address,
|
|
* and to validate the address if necessary.
|
|
*/
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
continue;
|
|
ifacount++;
|
|
}
|
|
|
|
ia->ia_addr = *sin6;
|
|
|
|
if (ifacount <= 1 && ifp->if_ioctl) {
|
|
IFF_LOCKGIANT(ifp);
|
|
error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia);
|
|
IFF_UNLOCKGIANT(ifp);
|
|
if (error) {
|
|
splx(s);
|
|
return (error);
|
|
}
|
|
}
|
|
splx(s);
|
|
|
|
ia->ia_ifa.ifa_metric = ifp->if_metric;
|
|
|
|
/* we could do in(6)_socktrim here, but just omit it at this moment. */
|
|
|
|
if (newhost) {
|
|
/*
|
|
* set the rtrequest function to create llinfo. It also
|
|
* adjust outgoing interface of the route for the local
|
|
* address when called via in6_ifaddloop() below.
|
|
*/
|
|
ia->ia_ifa.ifa_rtrequest = nd6_rtrequest;
|
|
}
|
|
|
|
/*
|
|
* Special case:
|
|
* If a new destination address is specified for a point-to-point
|
|
* interface, install a route to the destination as an interface
|
|
* direct route. In addition, if the link is expected to have neighbor
|
|
* cache entries, specify RTF_LLINFO so that a cache entry for the
|
|
* destination address will be created.
|
|
* created
|
|
* XXX: the logic below rejects assigning multiple addresses on a p2p
|
|
* interface that share the same destination.
|
|
*/
|
|
plen = in6_mask2len(&ia->ia_prefixmask.sin6_addr, NULL); /* XXX */
|
|
if (!(ia->ia_flags & IFA_ROUTE) && plen == 128 &&
|
|
ia->ia_dstaddr.sin6_family == AF_INET6) {
|
|
int rtflags = RTF_UP | RTF_HOST;
|
|
struct rtentry *rt = NULL, **rtp = NULL;
|
|
|
|
if (nd6_need_cache(ifp) != 0) {
|
|
rtflags |= RTF_LLINFO;
|
|
rtp = &rt;
|
|
}
|
|
|
|
error = rtrequest(RTM_ADD,
|
|
(struct sockaddr *)&ia->ia_dstaddr,
|
|
(struct sockaddr *)&ia->ia_addr,
|
|
(struct sockaddr *)&ia->ia_prefixmask,
|
|
ia->ia_flags | rtflags, rtp);
|
|
if (error != 0)
|
|
return (error);
|
|
if (rt != NULL) {
|
|
struct llinfo_nd6 *ln;
|
|
|
|
RT_LOCK(rt);
|
|
ln = (struct llinfo_nd6 *)rt->rt_llinfo;
|
|
if (ln != NULL) {
|
|
/*
|
|
* Set the state to STALE because we don't
|
|
* have to perform address resolution on this
|
|
* link.
|
|
*/
|
|
ln->ln_state = ND6_LLINFO_STALE;
|
|
}
|
|
RT_REMREF(rt);
|
|
RT_UNLOCK(rt);
|
|
}
|
|
ia->ia_flags |= IFA_ROUTE;
|
|
}
|
|
if (plen < 128) {
|
|
/*
|
|
* The RTF_CLONING flag is necessary for in6_is_ifloop_auto().
|
|
*/
|
|
ia->ia_ifa.ifa_flags |= RTF_CLONING;
|
|
}
|
|
|
|
/* Add ownaddr as loopback rtentry, if necessary (ex. on p2p link). */
|
|
if (newhost)
|
|
in6_ifaddloop(&(ia->ia_ifa));
|
|
|
|
return (error);
|
|
}
|
|
|
|
struct in6_multi_mship *
|
|
in6_joingroup(struct ifnet *ifp, struct in6_addr *addr,
|
|
int *errorp, int delay)
|
|
{
|
|
struct in6_multi_mship *imm;
|
|
|
|
imm = malloc(sizeof(*imm), M_IP6MADDR, M_NOWAIT);
|
|
if (!imm) {
|
|
*errorp = ENOBUFS;
|
|
return NULL;
|
|
}
|
|
imm->i6mm_maddr = in6_addmulti(addr, ifp, errorp, delay);
|
|
if (!imm->i6mm_maddr) {
|
|
/* *errorp is alrady set */
|
|
free(imm, M_IP6MADDR);
|
|
return NULL;
|
|
}
|
|
return imm;
|
|
}
|
|
|
|
int
|
|
in6_leavegroup(struct in6_multi_mship *imm)
|
|
{
|
|
|
|
if (imm->i6mm_maddr)
|
|
in6_delmulti(imm->i6mm_maddr);
|
|
free(imm, M_IP6MADDR);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Find an IPv6 interface link-local address specific to an interface.
|
|
*/
|
|
struct in6_ifaddr *
|
|
in6ifa_ifpforlinklocal(struct ifnet *ifp, int ignoreflags)
|
|
{
|
|
struct ifaddr *ifa;
|
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
continue;
|
|
if (IN6_IS_ADDR_LINKLOCAL(IFA_IN6(ifa))) {
|
|
if ((((struct in6_ifaddr *)ifa)->ia6_flags &
|
|
ignoreflags) != 0)
|
|
continue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ((struct in6_ifaddr *)ifa);
|
|
}
|
|
|
|
|
|
/*
|
|
* find the internet address corresponding to a given interface and address.
|
|
*/
|
|
struct in6_ifaddr *
|
|
in6ifa_ifpwithaddr(struct ifnet *ifp, struct in6_addr *addr)
|
|
{
|
|
struct ifaddr *ifa;
|
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
continue;
|
|
if (IN6_ARE_ADDR_EQUAL(addr, IFA_IN6(ifa)))
|
|
break;
|
|
}
|
|
|
|
return ((struct in6_ifaddr *)ifa);
|
|
}
|
|
|
|
/*
|
|
* Convert IP6 address to printable (loggable) representation. Caller
|
|
* has to make sure that ip6buf is at least INET6_ADDRSTRLEN long.
|
|
*/
|
|
static char digits[] = "0123456789abcdef";
|
|
char *
|
|
ip6_sprintf(char *ip6buf, const struct in6_addr *addr)
|
|
{
|
|
int i;
|
|
char *cp;
|
|
const u_int16_t *a = (const u_int16_t *)addr;
|
|
const u_int8_t *d;
|
|
int dcolon = 0, zero = 0;
|
|
|
|
cp = ip6buf;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
if (dcolon == 1) {
|
|
if (*a == 0) {
|
|
if (i == 7)
|
|
*cp++ = ':';
|
|
a++;
|
|
continue;
|
|
} else
|
|
dcolon = 2;
|
|
}
|
|
if (*a == 0) {
|
|
if (dcolon == 0 && *(a + 1) == 0) {
|
|
if (i == 0)
|
|
*cp++ = ':';
|
|
*cp++ = ':';
|
|
dcolon = 1;
|
|
} else {
|
|
*cp++ = '0';
|
|
*cp++ = ':';
|
|
}
|
|
a++;
|
|
continue;
|
|
}
|
|
d = (const u_char *)a;
|
|
/* Try to eliminate leading zeros in printout like in :0001. */
|
|
zero = 1;
|
|
*cp = digits[*d >> 4];
|
|
if (*cp != '0') {
|
|
zero = 0;
|
|
cp++;
|
|
}
|
|
*cp = digits[*d++ & 0xf];
|
|
if (zero == 0 || (*cp != '0')) {
|
|
zero = 0;
|
|
cp++;
|
|
}
|
|
*cp = digits[*d >> 4];
|
|
if (zero == 0 || (*cp != '0')) {
|
|
zero = 0;
|
|
cp++;
|
|
}
|
|
*cp++ = digits[*d & 0xf];
|
|
*cp++ = ':';
|
|
a++;
|
|
}
|
|
*--cp = '\0';
|
|
return (ip6buf);
|
|
}
|
|
|
|
int
|
|
in6_localaddr(struct in6_addr *in6)
|
|
{
|
|
struct in6_ifaddr *ia;
|
|
|
|
if (IN6_IS_ADDR_LOOPBACK(in6) || IN6_IS_ADDR_LINKLOCAL(in6))
|
|
return 1;
|
|
|
|
for (ia = in6_ifaddr; ia; ia = ia->ia_next) {
|
|
if (IN6_ARE_MASKED_ADDR_EQUAL(in6, &ia->ia_addr.sin6_addr,
|
|
&ia->ia_prefixmask.sin6_addr)) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
in6_is_addr_deprecated(struct sockaddr_in6 *sa6)
|
|
{
|
|
struct in6_ifaddr *ia;
|
|
|
|
for (ia = in6_ifaddr; ia; ia = ia->ia_next) {
|
|
if (IN6_ARE_ADDR_EQUAL(&ia->ia_addr.sin6_addr,
|
|
&sa6->sin6_addr) &&
|
|
(ia->ia6_flags & IN6_IFF_DEPRECATED) != 0)
|
|
return (1); /* true */
|
|
|
|
/* XXX: do we still have to go thru the rest of the list? */
|
|
}
|
|
|
|
return (0); /* false */
|
|
}
|
|
|
|
/*
|
|
* return length of part which dst and src are equal
|
|
* hard coding...
|
|
*/
|
|
int
|
|
in6_matchlen(struct in6_addr *src, struct in6_addr *dst)
|
|
{
|
|
int match = 0;
|
|
u_char *s = (u_char *)src, *d = (u_char *)dst;
|
|
u_char *lim = s + 16, r;
|
|
|
|
while (s < lim)
|
|
if ((r = (*d++ ^ *s++)) != 0) {
|
|
while (r < 128) {
|
|
match++;
|
|
r <<= 1;
|
|
}
|
|
break;
|
|
} else
|
|
match += 8;
|
|
return match;
|
|
}
|
|
|
|
/* XXX: to be scope conscious */
|
|
int
|
|
in6_are_prefix_equal(struct in6_addr *p1, struct in6_addr *p2, int len)
|
|
{
|
|
int bytelen, bitlen;
|
|
|
|
/* sanity check */
|
|
if (0 > len || len > 128) {
|
|
log(LOG_ERR, "in6_are_prefix_equal: invalid prefix length(%d)\n",
|
|
len);
|
|
return (0);
|
|
}
|
|
|
|
bytelen = len / 8;
|
|
bitlen = len % 8;
|
|
|
|
if (bcmp(&p1->s6_addr, &p2->s6_addr, bytelen))
|
|
return (0);
|
|
if (bitlen != 0 &&
|
|
p1->s6_addr[bytelen] >> (8 - bitlen) !=
|
|
p2->s6_addr[bytelen] >> (8 - bitlen))
|
|
return (0);
|
|
|
|
return (1);
|
|
}
|
|
|
|
void
|
|
in6_prefixlen2mask(struct in6_addr *maskp, int len)
|
|
{
|
|
u_char maskarray[8] = {0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};
|
|
int bytelen, bitlen, i;
|
|
|
|
/* sanity check */
|
|
if (0 > len || len > 128) {
|
|
log(LOG_ERR, "in6_prefixlen2mask: invalid prefix length(%d)\n",
|
|
len);
|
|
return;
|
|
}
|
|
|
|
bzero(maskp, sizeof(*maskp));
|
|
bytelen = len / 8;
|
|
bitlen = len % 8;
|
|
for (i = 0; i < bytelen; i++)
|
|
maskp->s6_addr[i] = 0xff;
|
|
if (bitlen)
|
|
maskp->s6_addr[bytelen] = maskarray[bitlen - 1];
|
|
}
|
|
|
|
/*
|
|
* return the best address out of the same scope. if no address was
|
|
* found, return the first valid address from designated IF.
|
|
*/
|
|
struct in6_ifaddr *
|
|
in6_ifawithifp(struct ifnet *ifp, struct in6_addr *dst)
|
|
{
|
|
int dst_scope = in6_addrscope(dst), blen = -1, tlen;
|
|
struct ifaddr *ifa;
|
|
struct in6_ifaddr *besta = 0;
|
|
struct in6_ifaddr *dep[2]; /* last-resort: deprecated */
|
|
|
|
dep[0] = dep[1] = NULL;
|
|
|
|
/*
|
|
* We first look for addresses in the same scope.
|
|
* If there is one, return it.
|
|
* If two or more, return one which matches the dst longest.
|
|
* If none, return one of global addresses assigned other ifs.
|
|
*/
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
continue;
|
|
if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_ANYCAST)
|
|
continue; /* XXX: is there any case to allow anycast? */
|
|
if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_NOTREADY)
|
|
continue; /* don't use this interface */
|
|
if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DETACHED)
|
|
continue;
|
|
if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DEPRECATED) {
|
|
if (ip6_use_deprecated)
|
|
dep[0] = (struct in6_ifaddr *)ifa;
|
|
continue;
|
|
}
|
|
|
|
if (dst_scope == in6_addrscope(IFA_IN6(ifa))) {
|
|
/*
|
|
* call in6_matchlen() as few as possible
|
|
*/
|
|
if (besta) {
|
|
if (blen == -1)
|
|
blen = in6_matchlen(&besta->ia_addr.sin6_addr, dst);
|
|
tlen = in6_matchlen(IFA_IN6(ifa), dst);
|
|
if (tlen > blen) {
|
|
blen = tlen;
|
|
besta = (struct in6_ifaddr *)ifa;
|
|
}
|
|
} else
|
|
besta = (struct in6_ifaddr *)ifa;
|
|
}
|
|
}
|
|
if (besta)
|
|
return (besta);
|
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
continue;
|
|
if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_ANYCAST)
|
|
continue; /* XXX: is there any case to allow anycast? */
|
|
if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_NOTREADY)
|
|
continue; /* don't use this interface */
|
|
if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DETACHED)
|
|
continue;
|
|
if (((struct in6_ifaddr *)ifa)->ia6_flags & IN6_IFF_DEPRECATED) {
|
|
if (ip6_use_deprecated)
|
|
dep[1] = (struct in6_ifaddr *)ifa;
|
|
continue;
|
|
}
|
|
|
|
return (struct in6_ifaddr *)ifa;
|
|
}
|
|
|
|
/* use the last-resort values, that are, deprecated addresses */
|
|
if (dep[0])
|
|
return dep[0];
|
|
if (dep[1])
|
|
return dep[1];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* perform DAD when interface becomes IFF_UP.
|
|
*/
|
|
void
|
|
in6_if_up(struct ifnet *ifp)
|
|
{
|
|
struct ifaddr *ifa;
|
|
struct in6_ifaddr *ia;
|
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
|
|
if (ifa->ifa_addr->sa_family != AF_INET6)
|
|
continue;
|
|
ia = (struct in6_ifaddr *)ifa;
|
|
if (ia->ia6_flags & IN6_IFF_TENTATIVE) {
|
|
/*
|
|
* The TENTATIVE flag was likely set by hand
|
|
* beforehand, implicitly indicating the need for DAD.
|
|
* We may be able to skip the random delay in this
|
|
* case, but we impose delays just in case.
|
|
*/
|
|
nd6_dad_start(ifa,
|
|
arc4random() % (MAX_RTR_SOLICITATION_DELAY * hz));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* special cases, like 6to4, are handled in in6_ifattach
|
|
*/
|
|
in6_ifattach(ifp, NULL);
|
|
}
|
|
|
|
int
|
|
in6if_do_dad(struct ifnet *ifp)
|
|
{
|
|
if ((ifp->if_flags & IFF_LOOPBACK) != 0)
|
|
return (0);
|
|
|
|
switch (ifp->if_type) {
|
|
#ifdef IFT_DUMMY
|
|
case IFT_DUMMY:
|
|
#endif
|
|
case IFT_FAITH:
|
|
/*
|
|
* These interfaces do not have the IFF_LOOPBACK flag,
|
|
* but loop packets back. We do not have to do DAD on such
|
|
* interfaces. We should even omit it, because loop-backed
|
|
* NS would confuse the DAD procedure.
|
|
*/
|
|
return (0);
|
|
default:
|
|
/*
|
|
* Our DAD routine requires the interface up and running.
|
|
* However, some interfaces can be up before the RUNNING
|
|
* status. Additionaly, users may try to assign addresses
|
|
* before the interface becomes up (or running).
|
|
* We simply skip DAD in such a case as a work around.
|
|
* XXX: we should rather mark "tentative" on such addresses,
|
|
* and do DAD after the interface becomes ready.
|
|
*/
|
|
if (!((ifp->if_flags & IFF_UP) &&
|
|
(ifp->if_drv_flags & IFF_DRV_RUNNING)))
|
|
return (0);
|
|
|
|
return (1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Calculate max IPv6 MTU through all the interfaces and store it
|
|
* to in6_maxmtu.
|
|
*/
|
|
void
|
|
in6_setmaxmtu(void)
|
|
{
|
|
unsigned long maxmtu = 0;
|
|
struct ifnet *ifp;
|
|
|
|
IFNET_RLOCK();
|
|
for (ifp = TAILQ_FIRST(&ifnet); ifp; ifp = TAILQ_NEXT(ifp, if_list)) {
|
|
/* this function can be called during ifnet initialization */
|
|
if (!ifp->if_afdata[AF_INET6])
|
|
continue;
|
|
if ((ifp->if_flags & IFF_LOOPBACK) == 0 &&
|
|
IN6_LINKMTU(ifp) > maxmtu)
|
|
maxmtu = IN6_LINKMTU(ifp);
|
|
}
|
|
IFNET_RUNLOCK();
|
|
if (maxmtu) /* update only when maxmtu is positive */
|
|
in6_maxmtu = maxmtu;
|
|
}
|
|
|
|
/*
|
|
* Provide the length of interface identifiers to be used for the link attached
|
|
* to the given interface. The length should be defined in "IPv6 over
|
|
* xxx-link" document. Note that address architecture might also define
|
|
* the length for a particular set of address prefixes, regardless of the
|
|
* link type. As clarified in rfc2462bis, those two definitions should be
|
|
* consistent, and those really are as of August 2004.
|
|
*/
|
|
int
|
|
in6_if2idlen(struct ifnet *ifp)
|
|
{
|
|
switch (ifp->if_type) {
|
|
case IFT_ETHER: /* RFC2464 */
|
|
#ifdef IFT_PROPVIRTUAL
|
|
case IFT_PROPVIRTUAL: /* XXX: no RFC. treat it as ether */
|
|
#endif
|
|
#ifdef IFT_L2VLAN
|
|
case IFT_L2VLAN: /* ditto */
|
|
#endif
|
|
#ifdef IFT_IEEE80211
|
|
case IFT_IEEE80211: /* ditto */
|
|
#endif
|
|
#ifdef IFT_MIP
|
|
case IFT_MIP: /* ditto */
|
|
#endif
|
|
return (64);
|
|
case IFT_FDDI: /* RFC2467 */
|
|
return (64);
|
|
case IFT_ISO88025: /* RFC2470 (IPv6 over Token Ring) */
|
|
return (64);
|
|
case IFT_PPP: /* RFC2472 */
|
|
return (64);
|
|
case IFT_ARCNET: /* RFC2497 */
|
|
return (64);
|
|
case IFT_FRELAY: /* RFC2590 */
|
|
return (64);
|
|
case IFT_IEEE1394: /* RFC3146 */
|
|
return (64);
|
|
case IFT_GIF:
|
|
return (64); /* draft-ietf-v6ops-mech-v2-07 */
|
|
case IFT_LOOP:
|
|
return (64); /* XXX: is this really correct? */
|
|
default:
|
|
/*
|
|
* Unknown link type:
|
|
* It might be controversial to use the today's common constant
|
|
* of 64 for these cases unconditionally. For full compliance,
|
|
* we should return an error in this case. On the other hand,
|
|
* if we simply miss the standard for the link type or a new
|
|
* standard is defined for a new link type, the IFID length
|
|
* is very likely to be the common constant. As a compromise,
|
|
* we always use the constant, but make an explicit notice
|
|
* indicating the "unknown" case.
|
|
*/
|
|
printf("in6_if2idlen: unknown link type (%d)\n", ifp->if_type);
|
|
return (64);
|
|
}
|
|
}
|
|
|
|
void *
|
|
in6_domifattach(struct ifnet *ifp)
|
|
{
|
|
struct in6_ifextra *ext;
|
|
|
|
ext = (struct in6_ifextra *)malloc(sizeof(*ext), M_IFADDR, M_WAITOK);
|
|
bzero(ext, sizeof(*ext));
|
|
|
|
ext->in6_ifstat = (struct in6_ifstat *)malloc(sizeof(struct in6_ifstat),
|
|
M_IFADDR, M_WAITOK);
|
|
bzero(ext->in6_ifstat, sizeof(*ext->in6_ifstat));
|
|
|
|
ext->icmp6_ifstat =
|
|
(struct icmp6_ifstat *)malloc(sizeof(struct icmp6_ifstat),
|
|
M_IFADDR, M_WAITOK);
|
|
bzero(ext->icmp6_ifstat, sizeof(*ext->icmp6_ifstat));
|
|
|
|
ext->nd_ifinfo = nd6_ifattach(ifp);
|
|
ext->scope6_id = scope6_ifattach(ifp);
|
|
return ext;
|
|
}
|
|
|
|
void
|
|
in6_domifdetach(struct ifnet *ifp, void *aux)
|
|
{
|
|
struct in6_ifextra *ext = (struct in6_ifextra *)aux;
|
|
|
|
scope6_ifdetach(ext->scope6_id);
|
|
nd6_ifdetach(ext->nd_ifinfo);
|
|
free(ext->in6_ifstat, M_IFADDR);
|
|
free(ext->icmp6_ifstat, M_IFADDR);
|
|
free(ext, M_IFADDR);
|
|
}
|
|
|
|
/*
|
|
* Convert sockaddr_in6 to sockaddr_in. Original sockaddr_in6 must be
|
|
* v4 mapped addr or v4 compat addr
|
|
*/
|
|
void
|
|
in6_sin6_2_sin(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
|
|
{
|
|
|
|
bzero(sin, sizeof(*sin));
|
|
sin->sin_len = sizeof(struct sockaddr_in);
|
|
sin->sin_family = AF_INET;
|
|
sin->sin_port = sin6->sin6_port;
|
|
sin->sin_addr.s_addr = sin6->sin6_addr.s6_addr32[3];
|
|
}
|
|
|
|
/* Convert sockaddr_in to sockaddr_in6 in v4 mapped addr format. */
|
|
void
|
|
in6_sin_2_v4mapsin6(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
|
|
{
|
|
bzero(sin6, sizeof(*sin6));
|
|
sin6->sin6_len = sizeof(struct sockaddr_in6);
|
|
sin6->sin6_family = AF_INET6;
|
|
sin6->sin6_port = sin->sin_port;
|
|
sin6->sin6_addr.s6_addr32[0] = 0;
|
|
sin6->sin6_addr.s6_addr32[1] = 0;
|
|
sin6->sin6_addr.s6_addr32[2] = IPV6_ADDR_INT32_SMP;
|
|
sin6->sin6_addr.s6_addr32[3] = sin->sin_addr.s_addr;
|
|
}
|
|
|
|
/* Convert sockaddr_in6 into sockaddr_in. */
|
|
void
|
|
in6_sin6_2_sin_in_sock(struct sockaddr *nam)
|
|
{
|
|
struct sockaddr_in *sin_p;
|
|
struct sockaddr_in6 sin6;
|
|
|
|
/*
|
|
* Save original sockaddr_in6 addr and convert it
|
|
* to sockaddr_in.
|
|
*/
|
|
sin6 = *(struct sockaddr_in6 *)nam;
|
|
sin_p = (struct sockaddr_in *)nam;
|
|
in6_sin6_2_sin(sin_p, &sin6);
|
|
}
|
|
|
|
/* Convert sockaddr_in into sockaddr_in6 in v4 mapped addr format. */
|
|
void
|
|
in6_sin_2_v4mapsin6_in_sock(struct sockaddr **nam)
|
|
{
|
|
struct sockaddr_in *sin_p;
|
|
struct sockaddr_in6 *sin6_p;
|
|
|
|
MALLOC(sin6_p, struct sockaddr_in6 *, sizeof *sin6_p, M_SONAME,
|
|
M_WAITOK);
|
|
sin_p = (struct sockaddr_in *)*nam;
|
|
in6_sin_2_v4mapsin6(sin_p, sin6_p);
|
|
FREE(*nam, M_SONAME);
|
|
*nam = (struct sockaddr *)sin6_p;
|
|
}
|