Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d362232877
NetBSD/sys/net/if_stf.c

741 lines
18 KiB
C
Raw Normal View History

Make the routing table and rtcaches MP-safe See the following descriptions for details. Proposed on tech-kern and tech-net Overview -------- We protect the routing table with a rwock and protect rtcaches with another rwlock. Each rtentry is protected from being freed or updated via reference counting and psref. Global rwlocks -------------- There are two rwlocks; one for the routing table (rt_lock) and the other for rtcaches (rtcache_lock). rtcache_lock covers all existing rtcaches; there may have room for optimizations (future work). The locking order is rtcache_lock first and rt_lock is next. rtentry references ------------------ References to an rtentry is managed with reference counting and psref. Either of the two mechanisms is used depending on where a rtentry is obtained. Reference counting is used when we obtain a rtentry from the routing table directly via rtalloc1 and rtrequest{,1} while psref is used when we obtain a rtentry from a rtcache via rtcache_* APIs. In both cases, a caller can sleep/block with holding an obtained rtentry. The reasons why we use two different mechanisms are (i) only using reference counting hurts the performance due to atomic instructions (rtcache case) (ii) ease of implementation; applying psref to APIs such rtaloc1 and rtrequest{,1} requires additional works (adding a local variable and an argument). We will finally migrate to use only psref but we can do it when we have a lockless routing table alternative. Reference counting for rtentry ------------------------------ rt_refcnt now doesn't count permanent references such as for rt_timers and rtcaches, instead it is used only for temporal references when obtaining a rtentry via rtalloc1 and rtrequest{,1}. We can do so because destroying a rtentry always involves removing references of rt_timers and rtcaches to the rtentry and we don't need to track such references. This also makes it easy to wait for readers to release references on deleting or updating a rtentry, i.e., we can simply wait until the reference counter is 0 or 1. (If there are permanent references the counter can be arbitrary.) rt_ref increments a reference counter of a rtentry and rt_unref decrements it. rt_ref is called inside APIs (rtalloc1 and rtrequest{,1} so users don't need to care about it while users must call rt_unref to an obtained rtentry after using it. rtfree is removed and we use rt_unref and rt_free instead. rt_unref now just decrements the counter of a given rtentry and rt_free just tries to destroy a given rtentry. See the next section for destructions of rtentries by rt_free. Destructions of rtentries ------------------------- We destroy a rtentry only when we call rtrequst{,1}(RTM_DELETE); the original implementation can destroy in any rtfree where it's the last reference. If we use reference counting or psref, it's easy to understand if the place that a rtentry is destroyed is fixed. rt_free waits for references to a given rtentry to be released before actually destroying the rtentry. rt_free uses a condition variable (cv_wait) (and psref_target_destroy for psref) to wait. Unfortunately rtrequst{,1}(RTM_DELETE) can be called in softint that we cannot use cv_wait. In that case, we have to defer the destruction to a workqueue. rtentry#rt_cv, rtentry#rt_psref and global variables (see rt_free_global) are added to conduct the procedure. Updates of rtentries -------------------- One difficulty to use refcnt/psref instead of rwlock for rtentry is updates of rtentries. We need an additional mechanism to prevent readers from seeing inconsistency of a rtentry being updated. We introduce RTF_UPDATING flag to rtentries that are updating. While the flag is set to a rtentry, users cannot acquire the rtentry. By doing so, we avoid users to see inconsistent rtentries. There are two options when a user tries to acquire a rtentry with the RTF_UPDATING flag; if a user runs in softint context the user fails to acquire a rtentry (NULL is returned). Otherwise a user waits until the update completes by waiting on cv. The procedure of a updater is simpler to destruction of a rtentry. Wait on cv (and psref) and after all readers left, proceed with the update. Global variables (see rt_update_global) are added to conduct the procedure. Currently we apply the mechanism to only RTM_CHANGE in rtsock.c. We would have to apply other codes. See "Known issues" section. psref for rtentry ----------------- When we obtain a rtentry from a rtcache via rtcache_* APIs, psref is used to reference to the rtentry. rtcache_ref acquires a reference to a rtentry with psref and rtcache_unref releases the reference after using it. rtcache_ref is called inside rtcache_* APIs and users don't need to take care of it while users must call rtcache_unref to release the reference. struct psref and int bound that is needed for psref is embedded into struct route. By doing so we don't need to add local variables and additional argument to APIs. However this adds another constraint to psref other than reference counting one's; holding a reference of an rtentry via a rtcache is allowed by just one caller at the same time. So we must not acquire a rtentry via a rtcache twice and avoid a recursive use of a rtcache. And also a rtcache must be arranged to be used by a LWP/softint at the same time somehow. For IP forwarding case, we have per-CPU rtcaches used in softint so the constraint is guaranteed. For a h rtcache of a PCB case, the constraint is guaranteed by the solock of each PCB. Any other cases (pf, ipf, stf and ipsec) are currently guaranteed by only the existence of the global locks (softnet_lock and/or KERNEL_LOCK). If we've found the cases that we cannot guarantee the constraint, we would need to introduce other rtcache APIs that use simple reference counting. psref of rtcache is created with IPL_SOFTNET and so rtcache shouldn't used at an IPL higher than IPL_SOFTNET. Note that rtcache_free is used to invalidate a given rtcache. We don't need another care by my change; just keep them as they are. Performance impact ------------------ When NET_MPSAFE is disabled the performance drop is 3% while when it's enabled the drop is increased to 11%. The difference comes from that currently we don't take any global locks and don't use psref if NET_MPSAFE is disabled. We can optimize the performance of the case of NET_MPSAFE on by reducing lookups of rtcache that uses psref; currently we do two lookups but we should be able to trim one of two. This is a future work. Known issues ------------ There are two known issues to be solved; one is that a caller of rtrequest(RTM_ADD) may change rtentry (see rtinit). We need to prevent new references during the update. Or we may be able to remove the code (perhaps, need more investigations). The other is rtredirect that updates a rtentry. We need to apply our update mechanism, however it's not easy because rtredirect is called in softint and we cannot apply our mechanism simply. One solution is to defer rtredirect to a workqueue but it requires some code restructuring.
2016-12-12 06:55:57 +03:00
/* $NetBSD: if_stf.c,v 1.101 2016/12/12 03:55:57 ozaki-r Exp $ */
lwp::l_acflag is no longer used.
2007-03-29 20:51:21 +04:00
/* $KAME: if_stf.c,v 1.62 2001/06/07 22:32:16 itojun Exp $ */
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
/*
* Copyright (C) 2000 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.
*/
/*
update comment to meet 6to4 RFC. sync with kame
2001-02-17 07:29:59 +03:00
* 6to4 interface, based on RFC3056.
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
*
* 6to4 interface is NOT capable of link-layer (I mean, IPv4) multicasting.
* There is no address mapping defined from IPv6 multicast address to IPv4
* address. Therefore, we do not have IFF_MULTICAST on the interface.
*
* Due to the lack of address mapping for link-local addresses, we cannot
* throw packets toward link-local addresses (fe80::x). Also, we cannot throw
* packets to link-local multicast addresses (ff02::x).
*
* Here are interesting symptoms due to the lack of link-local address:
*
* Unicast routing exchange:
update comment (analysis on 04 draft)
2000-04-21 06:40:53 +04:00
* - RIPng: Impossible. Uses link-local multicast packet toward ff02::9,
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
* and link-local addresses as nexthop.
* - OSPFv6: Impossible. OSPFv6 assumes that there's link-local address
* assigned to the link, and makes use of them. Also, HELLO packets use
* link-local multicast addresses (ff02::5 and ff02::6).
* - BGP4+: Maybe. You can only use global address as nexthop, and global
* address as TCP endpoint address.
*
* Multicast routing protocols:
* - PIM: Hello packet cannot be used to discover adjacent PIM routers.
* Adjacent PIM routers must be configured manually (is it really spec-wise
* correct thing to do?).
*
* ICMPv6:
* - Redirects cannot be used due to the lack of link-local address.
*
nuke trailing whitespace
2005-02-27 01:45:09 +03:00
* stf interface does not have, and will not need, a link-local address.
update comment to meet 6to4 RFC. sync with kame
2001-02-17 07:29:59 +03:00
* It seems to have no real benefit and does not help the above symptoms much.
* Even if we assign link-locals to interface, we cannot really
* use link-local unicast/multicast on top of 6to4 cloud (since there's no
* encapsulation defined for link-local address), and the above analysis does
* not change. RFC3056 does not mandate the assignment of link-local address
* either.
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
*
* 6to4 interface has security issues. Refer to
* http://playground.iijlab.net/i-d/draft-itojun-ipv6-transition-abuse-00.txt
* for details. The code tries to filter out some of malicious packets.
* Note that there is no way to be 100% secure.
*/
add RCSIDs
2001-11-13 02:49:33 +03:00
#include <sys/cdefs.h>
Make the routing table and rtcaches MP-safe See the following descriptions for details. Proposed on tech-kern and tech-net Overview -------- We protect the routing table with a rwock and protect rtcaches with another rwlock. Each rtentry is protected from being freed or updated via reference counting and psref. Global rwlocks -------------- There are two rwlocks; one for the routing table (rt_lock) and the other for rtcaches (rtcache_lock). rtcache_lock covers all existing rtcaches; there may have room for optimizations (future work). The locking order is rtcache_lock first and rt_lock is next. rtentry references ------------------ References to an rtentry is managed with reference counting and psref. Either of the two mechanisms is used depending on where a rtentry is obtained. Reference counting is used when we obtain a rtentry from the routing table directly via rtalloc1 and rtrequest{,1} while psref is used when we obtain a rtentry from a rtcache via rtcache_* APIs. In both cases, a caller can sleep/block with holding an obtained rtentry. The reasons why we use two different mechanisms are (i) only using reference counting hurts the performance due to atomic instructions (rtcache case) (ii) ease of implementation; applying psref to APIs such rtaloc1 and rtrequest{,1} requires additional works (adding a local variable and an argument). We will finally migrate to use only psref but we can do it when we have a lockless routing table alternative. Reference counting for rtentry ------------------------------ rt_refcnt now doesn't count permanent references such as for rt_timers and rtcaches, instead it is used only for temporal references when obtaining a rtentry via rtalloc1 and rtrequest{,1}. We can do so because destroying a rtentry always involves removing references of rt_timers and rtcaches to the rtentry and we don't need to track such references. This also makes it easy to wait for readers to release references on deleting or updating a rtentry, i.e., we can simply wait until the reference counter is 0 or 1. (If there are permanent references the counter can be arbitrary.) rt_ref increments a reference counter of a rtentry and rt_unref decrements it. rt_ref is called inside APIs (rtalloc1 and rtrequest{,1} so users don't need to care about it while users must call rt_unref to an obtained rtentry after using it. rtfree is removed and we use rt_unref and rt_free instead. rt_unref now just decrements the counter of a given rtentry and rt_free just tries to destroy a given rtentry. See the next section for destructions of rtentries by rt_free. Destructions of rtentries ------------------------- We destroy a rtentry only when we call rtrequst{,1}(RTM_DELETE); the original implementation can destroy in any rtfree where it's the last reference. If we use reference counting or psref, it's easy to understand if the place that a rtentry is destroyed is fixed. rt_free waits for references to a given rtentry to be released before actually destroying the rtentry. rt_free uses a condition variable (cv_wait) (and psref_target_destroy for psref) to wait. Unfortunately rtrequst{,1}(RTM_DELETE) can be called in softint that we cannot use cv_wait. In that case, we have to defer the destruction to a workqueue. rtentry#rt_cv, rtentry#rt_psref and global variables (see rt_free_global) are added to conduct the procedure. Updates of rtentries -------------------- One difficulty to use refcnt/psref instead of rwlock for rtentry is updates of rtentries. We need an additional mechanism to prevent readers from seeing inconsistency of a rtentry being updated. We introduce RTF_UPDATING flag to rtentries that are updating. While the flag is set to a rtentry, users cannot acquire the rtentry. By doing so, we avoid users to see inconsistent rtentries. There are two options when a user tries to acquire a rtentry with the RTF_UPDATING flag; if a user runs in softint context the user fails to acquire a rtentry (NULL is returned). Otherwise a user waits until the update completes by waiting on cv. The procedure of a updater is simpler to destruction of a rtentry. Wait on cv (and psref) and after all readers left, proceed with the update. Global variables (see rt_update_global) are added to conduct the procedure. Currently we apply the mechanism to only RTM_CHANGE in rtsock.c. We would have to apply other codes. See "Known issues" section. psref for rtentry ----------------- When we obtain a rtentry from a rtcache via rtcache_* APIs, psref is used to reference to the rtentry. rtcache_ref acquires a reference to a rtentry with psref and rtcache_unref releases the reference after using it. rtcache_ref is called inside rtcache_* APIs and users don't need to take care of it while users must call rtcache_unref to release the reference. struct psref and int bound that is needed for psref is embedded into struct route. By doing so we don't need to add local variables and additional argument to APIs. However this adds another constraint to psref other than reference counting one's; holding a reference of an rtentry via a rtcache is allowed by just one caller at the same time. So we must not acquire a rtentry via a rtcache twice and avoid a recursive use of a rtcache. And also a rtcache must be arranged to be used by a LWP/softint at the same time somehow. For IP forwarding case, we have per-CPU rtcaches used in softint so the constraint is guaranteed. For a h rtcache of a PCB case, the constraint is guaranteed by the solock of each PCB. Any other cases (pf, ipf, stf and ipsec) are currently guaranteed by only the existence of the global locks (softnet_lock and/or KERNEL_LOCK). If we've found the cases that we cannot guarantee the constraint, we would need to introduce other rtcache APIs that use simple reference counting. psref of rtcache is created with IPL_SOFTNET and so rtcache shouldn't used at an IPL higher than IPL_SOFTNET. Note that rtcache_free is used to invalidate a given rtcache. We don't need another care by my change; just keep them as they are. Performance impact ------------------ When NET_MPSAFE is disabled the performance drop is 3% while when it's enabled the drop is increased to 11%. The difference comes from that currently we don't take any global locks and don't use psref if NET_MPSAFE is disabled. We can optimize the performance of the case of NET_MPSAFE on by reducing lookups of rtcache that uses psref; currently we do two lookups but we should be able to trim one of two. This is a future work. Known issues ------------ There are two known issues to be solved; one is that a caller of rtrequest(RTM_ADD) may change rtentry (see rtinit). We need to prevent new references during the update. Or we may be able to remove the code (perhaps, need more investigations). The other is rtredirect that updates a rtentry. We need to apply our update mechanism, however it's not easy because rtredirect is called in softint and we cannot apply our mechanism simply. One solution is to defer rtredirect to a workqueue but it requires some code restructuring.
2016-12-12 06:55:57 +03:00
__KERNEL_RCSID(0, "$NetBSD: if_stf.c,v 1.101 2016/12/12 03:55:57 ozaki-r Exp $");
add RCSIDs
2001-11-13 02:49:33 +03:00
sprinkle _KERNEL_OPT
2015-08-25 01:21:26 +03:00
#ifdef _KERNEL_OPT
sync IPv4 rogue address filter with RFC1122. (sync with kame)
2000-05-14 07:44:02 +04:00
#include "opt_inet.h"
modularize some more drivers and merge the module glue
2016-08-07 20:38:33 +03:00
#include "stf.h"
sprinkle _KERNEL_OPT
2015-08-25 01:21:26 +03:00
#endif
PR/48901: Fail at compile time when trying to compile stf without inet6, and print an explanatory message.
2014-06-12 20:43:09 +04:00
#ifndef INET6
#error "pseudo-device stf requires options INET6"
#endif
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/mbuf.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
#include <sys/proc.h>
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
#include <sys/queue.h>
make it possible to turn off ingress filter on gif/stf tunnel egress, by using IFF_LINK2. (part of) PR 11163 from Ken Raeburn.
2001-01-22 10:51:01 +03:00
#include <sys/syslog.h>
modularize some more drivers and merge the module glue
2016-08-07 20:38:33 +03:00
#include <sys/device.h>
#include <sys/module.h>
integrate kauth.
2006-05-15 01:19:33 +04:00
machine/{bus,cpu,intr}.h -> sys/{bus,cpu,intr}.h
2007-10-19 15:59:34 +04:00
#include <sys/cpu.h>
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
#include <net/if.h>
#include <net/route.h>
#include <net/netisr.h>
#include <net/if_types.h>
#include <net/if_stf.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/in_var.h>
#include <netinet/ip6.h>
#include <netinet6/ip6_var.h>
#include <netinet6/in6_var.h>
#include <netinet/ip_ecn.h>
#include <netinet/ip_encap.h>
#include <net/net_osdep.h>
#include <net/bpf.h>
include "ioconf.h" to get the 'void <driver>attach(int count);' prototype.
2015-08-20 17:40:16 +03:00
#include "ioconf.h"
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
#define IN6_IS_ADDR_6TO4(x) (ntohs((x)->s6_addr16[0]) == 0x2002)
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
#define GET_V4(x) ((const struct in_addr *)(&(x)->s6_addr16[1]))
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
struct stf_softc {
struct ifnet sc_if; /* common area */
Eliminate address family-specific route caches (struct route, struct route_in6, struct route_iso), replacing all caches with a struct route. The principle benefit of this change is that all of the protocol families can benefit from route cache-invalidation, which is necessary for correct routing. Route-cache invalidation fixes an ancient PR, kern/3508, at long last; it fixes various other PRs, also. Discussions with and ideas from Joerg Sonnenberger influenced this work tremendously. Of course, all design oversights and bugs are mine. DETAILS 1 I added to each address family a pool of sockaddrs. I have introduced routines for allocating, copying, and duplicating, and freeing sockaddrs: struct sockaddr *sockaddr_alloc(sa_family_t af, int flags); struct sockaddr *sockaddr_copy(struct sockaddr *dst, const struct sockaddr *src); struct sockaddr *sockaddr_dup(const struct sockaddr *src, int flags); void sockaddr_free(struct sockaddr *sa); sockaddr_alloc() returns either a sockaddr from the pool belonging to the specified family, or NULL if the pool is exhausted. The returned sockaddr has the right size for that family; sa_family and sa_len fields are initialized to the family and sockaddr length---e.g., sa_family = AF_INET and sa_len = sizeof(struct sockaddr_in). sockaddr_free() puts the given sockaddr back into its family's pool. sockaddr_dup() and sockaddr_copy() work analogously to strdup() and strcpy(), respectively. sockaddr_copy() KASSERTs that the family of the destination and source sockaddrs are alike. The 'flags' argumet for sockaddr_alloc() and sockaddr_dup() is passed directly to pool_get(9). 2 I added routines for initializing sockaddrs in each address family, sockaddr_in_init(), sockaddr_in6_init(), sockaddr_iso_init(), etc. They are fairly self-explanatory. 3 structs route_in6 and route_iso are no more. All protocol families use struct route. I have changed the route cache, 'struct route', so that it does not contain storage space for a sockaddr. Instead, struct route points to a sockaddr coming from the pool the sockaddr belongs to. I added a new method to struct route, rtcache_setdst(), for setting the cache destination: int rtcache_setdst(struct route *, const struct sockaddr *); rtcache_setdst() returns 0 on success, or ENOMEM if no memory is available to create the sockaddr storage. It is now possible for rtcache_getdst() to return NULL if, say, rtcache_setdst() failed. I check the return value for NULL everywhere in the kernel. 4 Each routing domain (struct domain) has a list of live route caches, dom_rtcache. rtflushall(sa_family_t af) looks up the domain indicated by 'af', walks the domain's list of route caches and invalidates each one.
2007-05-03 00:40:22 +04:00
struct route sc_ro;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
const struct encaptab *encap_cookie;
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
LIST_ENTRY(stf_softc) sc_list;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
};
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
static LIST_HEAD(, stf_softc) stf_softc_list;
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
static int stf_clone_create(struct if_clone *, int);
static int stf_clone_destroy(struct ifnet *);
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
struct if_clone stf_cloner =
IF_CLONE_INITIALIZER("stf", stf_clone_create, stf_clone_destroy);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
eliminate stf(4)'s dependency on gif(4). stf(4) depends on not gif(4) but ip_encap.
2016-08-18 14:38:58 +03:00
static int ip_stf_ttl = STF_TTL;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
Back out previous change to introduce struct encapsw. This change was intended, but Nakahara-san had already made a better one locally! So I'll let him commit that one, and I'll try not to step on anyone's toes again.
2016-01-23 02:27:12 +03:00
extern struct domain inetdomain;
implement encapsw instead of protosw and uniform prototype. suggested and advised by riastradh@n.o, thanks. BTW, It seems in_stf_input() had bugs...
2016-01-26 08:58:05 +03:00
static const struct encapsw in_stf_encapsw =
Back out previous change to introduce struct encapsw. This change was intended, but Nakahara-san had already made a better one locally! So I'll let him commit that one, and I'll try not to step on anyone's toes again.
2016-01-23 02:27:12 +03:00
{
fix my wrong modification
2016-01-28 03:28:11 +03:00
.encapsw4 = {
implement encapsw instead of protosw and uniform prototype. suggested and advised by riastradh@n.o, thanks. BTW, It seems in_stf_input() had bugs...
2016-01-26 08:58:05 +03:00
.pr_input = in_stf_input,
.pr_ctlinput = NULL,
}
move protosw fragment for gif/stf to their own source code. reduce #ifdef in stf code. sync with kame
2001-12-21 06:21:50 +03:00
};
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
static int stf_encapcheck(struct mbuf *, int, int, void *);
static struct in6_ifaddr *stf_getsrcifa6(struct ifnet *);
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
static int stf_output(struct ifnet *, struct mbuf *, const struct sockaddr *,
Constify rtentry of if_output We no longer need to change rtentry below if_output. The change makes it clear where rtentries are changed (or not) and helps forthcoming locking (os psrefing) rtentries.
2016-04-28 03:16:56 +03:00
const struct rtentry *);
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
static int isrfc1918addr(const struct in_addr *);
static int stf_checkaddr4(struct stf_softc *, const struct in_addr *,
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
struct ifnet *);
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
static int stf_checkaddr6(struct stf_softc *, const struct in6_addr *,
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
struct ifnet *);
Constify the rt_addrinfo argument to the ifa_rtrequest member function of struct ifaddr.
2008-10-24 21:07:33 +04:00
static void stf_rtrequest(int, struct rtentry *, const struct rt_addrinfo *);
Kill caddr_t; there will be some MI fallout, but it will be fixed shortly.
2007-03-04 08:59:00 +03:00
static int stf_ioctl(struct ifnet *, u_long, void *);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
/* ARGSUSED */
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
void
__unused removal on arguments; approved by core.
2006-11-16 04:32:37 +03:00
stfattach(int count)
modularize some more drivers and merge the module glue
2016-08-07 20:38:33 +03:00
{
/*
* Nothing to do here, initialization is handled by the
* module initialization code in stfinit() below).
*/
}
static void
stfinit(void)
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
{
LIST_INIT(&stf_softc_list);
if_clone_attach(&stf_cloner);
}
modularize some more drivers and merge the module glue
2016-08-07 20:38:33 +03:00
static int
stfdetach(void)
{
int error = 0;
if (!LIST_EMPTY(&stf_softc_list))
error = EBUSY;
if (error == 0)
if_clone_detach(&stf_cloner);
return error;
}
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
static int
stf_clone_create(struct if_clone *ifc, int unit)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
struct stf_softc *sc;
make encap_lock_{enter,exit} interruptable.
2016-07-04 07:35:09 +03:00
int error;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
let gif(4) promise softint(9) contract (2/2) : ip_encap side The last commit does not care encaptab. This commit fixes encaptab race which is used not only gif(4).
2016-07-04 07:17:25 +03:00
sc = malloc(sizeof(struct stf_softc), M_DEVBUF, M_WAIT|M_ZERO);
if_initname(&sc->sc_if, ifc->ifc_name, unit);
make encap_lock_{enter,exit} interruptable.
2016-07-04 07:35:09 +03:00
error = encap_lock_enter();
if (error) {
free(sc, M_DEVBUF);
return error;
}
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
if (LIST_FIRST(&stf_softc_list) != NULL) {
/* Only one stf interface is allowed. */
let gif(4) promise softint(9) contract (2/2) : ip_encap side The last commit does not care encaptab. This commit fixes encaptab race which is used not only gif(4).
2016-07-04 07:17:25 +03:00
encap_lock_exit();
free(sc, M_DEVBUF);
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
return (EEXIST);
}
sc->encap_cookie = encap_attach_func(AF_INET, IPPROTO_IPV6,
implement encapsw instead of protosw and uniform prototype. suggested and advised by riastradh@n.o, thanks. BTW, It seems in_stf_input() had bugs...
2016-01-26 08:58:05 +03:00
stf_encapcheck, &in_stf_encapsw, sc);
let gif(4) promise softint(9) contract (2/2) : ip_encap side The last commit does not care encaptab. This commit fixes encaptab race which is used not only gif(4).
2016-07-04 07:17:25 +03:00
encap_lock_exit();
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
if (sc->encap_cookie == NULL) {
printf("%s: unable to attach encap\n", if_name(&sc->sc_if));
free(sc, M_DEVBUF);
return (EIO); /* XXX */
}
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
sc->sc_if.if_mtu = STF_MTU;
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
sc->sc_if.if_flags = 0;
sc->sc_if.if_ioctl = stf_ioctl;
sc->sc_if.if_output = stf_output;
sc->sc_if.if_type = IFT_STF;
Fill in if_dlt.
2000-12-18 22:44:33 +03:00
sc->sc_if.if_dlt = DLT_NULL;
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
if_attach(&sc->sc_if);
Fix a rather annoying problem where the sockaddr_dl which holds the link level name for the interface (ifp->if_sadl) is allocated before ifp->if_addrlen is initialized, which could lead to allocating too little space for the link level address. Do this by splitting allocation of the link level name out of if_attach() and into if_alloc_sadl(), which is normally called by functions like ether_ifattach(). Network interfaces which don't have a link-specific attach routine must call if_alloc_sadl() themselves (example: gif). Link level names are freed by if_free_sadl(), which can be called from e.g. ether_ifdetach(). Drivers never need call if_free_sadl() themselves as if_detach() will do it if it is not already done. While here, add the ability to pass an AF_LINK address to SIOCSIFADDR in ether_ioctl() (this is what caused me to notice the problem that the above fixes).
2001-01-17 03:30:49 +03:00
if_alloc_sadl(&sc->sc_if);
Push the bpf_ops usage back into bpf.h. Push the common ifp->if_bpf check into the inline functions as well the fourth argument for bpf_attach.
2010-04-05 11:19:28 +04:00
bpf_attach(&sc->sc_if, DLT_NULL, sizeof(u_int));
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
LIST_INSERT_HEAD(&stf_softc_list, sc, sc_list);
return (0);
}
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
static int
stf_clone_destroy(struct ifnet *ifp)
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
{
struct stf_softc *sc = (void *) ifp;
let gif(4) promise softint(9) contract (2/2) : ip_encap side The last commit does not care encaptab. This commit fixes encaptab race which is used not only gif(4).
2016-07-04 07:17:25 +03:00
encap_lock_enter();
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
LIST_REMOVE(sc, sc_list);
encap_detach(sc->encap_cookie);
let gif(4) promise softint(9) contract (2/2) : ip_encap side The last commit does not care encaptab. This commit fixes encaptab race which is used not only gif(4).
2016-07-04 07:17:25 +03:00
encap_lock_exit();
Push the bpf_ops usage back into bpf.h. Push the common ifp->if_bpf check into the inline functions as well the fourth argument for bpf_attach.
2010-04-05 11:19:28 +04:00
bpf_detach(ifp);
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
if_detach(ifp);
Eliminate address family-specific route caches (struct route, struct route_in6, struct route_iso), replacing all caches with a struct route. The principle benefit of this change is that all of the protocol families can benefit from route cache-invalidation, which is necessary for correct routing. Route-cache invalidation fixes an ancient PR, kern/3508, at long last; it fixes various other PRs, also. Discussions with and ideas from Joerg Sonnenberger influenced this work tremendously. Of course, all design oversights and bugs are mine. DETAILS 1 I added to each address family a pool of sockaddrs. I have introduced routines for allocating, copying, and duplicating, and freeing sockaddrs: struct sockaddr *sockaddr_alloc(sa_family_t af, int flags); struct sockaddr *sockaddr_copy(struct sockaddr *dst, const struct sockaddr *src); struct sockaddr *sockaddr_dup(const struct sockaddr *src, int flags); void sockaddr_free(struct sockaddr *sa); sockaddr_alloc() returns either a sockaddr from the pool belonging to the specified family, or NULL if the pool is exhausted. The returned sockaddr has the right size for that family; sa_family and sa_len fields are initialized to the family and sockaddr length---e.g., sa_family = AF_INET and sa_len = sizeof(struct sockaddr_in). sockaddr_free() puts the given sockaddr back into its family's pool. sockaddr_dup() and sockaddr_copy() work analogously to strdup() and strcpy(), respectively. sockaddr_copy() KASSERTs that the family of the destination and source sockaddrs are alike. The 'flags' argumet for sockaddr_alloc() and sockaddr_dup() is passed directly to pool_get(9). 2 I added routines for initializing sockaddrs in each address family, sockaddr_in_init(), sockaddr_in6_init(), sockaddr_iso_init(), etc. They are fairly self-explanatory. 3 structs route_in6 and route_iso are no more. All protocol families use struct route. I have changed the route cache, 'struct route', so that it does not contain storage space for a sockaddr. Instead, struct route points to a sockaddr coming from the pool the sockaddr belongs to. I added a new method to struct route, rtcache_setdst(), for setting the cache destination: int rtcache_setdst(struct route *, const struct sockaddr *); rtcache_setdst() returns 0 on success, or ENOMEM if no memory is available to create the sockaddr storage. It is now possible for rtcache_getdst() to return NULL if, say, rtcache_setdst() failed. I check the return value for NULL everywhere in the kernel. 4 Each routing domain (struct domain) has a list of live route caches, dom_rtcache. rtflushall(sa_family_t af) looks up the domain indicated by 'af', walks the domain's list of route caches and invalidates each one.
2007-05-03 00:40:22 +04:00
rtcache_free(&sc->sc_ro);
stf(4) is now a cloning network interface (although, only one is allowed to be created).
2000-07-05 21:08:18 +04:00
free(sc, M_DEVBUF);
Change ifc_destroy to return an int instead of void, so that it can pass back errors to ifconfig.
2004-12-04 21:31:43 +03:00
return (0);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
static int
__unused removal on arguments; approved by core.
2006-11-16 04:32:37 +03:00
stf_encapcheck(struct mbuf *m, int off, int proto, void *arg)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
struct ip ip;
struct in6_ifaddr *ia6;
struct stf_softc *sc;
struct in_addr a, b;
sc = (struct stf_softc *)arg;
if (sc == NULL)
return 0;
if ((sc->sc_if.if_flags & IFF_UP) == 0)
return 0;
correct outbound outer IPv4 destination address selection. IFF_LINK0 disables inbound path, removes security worries. more examples in manpage.
2001-04-29 07:56:06 +04:00
/* IFF_LINK0 means "no decapsulation" */
if ((sc->sc_if.if_flags & IFF_LINK0) != 0)
return 0;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
if (proto != IPPROTO_IPV6)
return 0;
Kill caddr_t; there will be some MI fallout, but it will be fixed shortly.
2007-03-04 08:59:00 +03:00
m_copydata(m, 0, sizeof(ip), (void *)&ip);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
if (ip.ip_v != 4)
return 0;
ia6 = stf_getsrcifa6(&sc->sc_if);
if (ia6 == NULL)
return 0;
/*
* check if IPv4 dst matches the IPv4 address derived from the
* local 6to4 address.
* success on: dst = 10.1.1.1, ia6->ia_addr = 2002:0a01:0101:...
*/
bcmp -> memcmp
2009-03-18 18:14:29 +03:00
if (memcmp(GET_V4(&ia6->ia_addr.sin6_addr), &ip.ip_dst,
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
sizeof(ip.ip_dst)) != 0)
return 0;
/*
* check if IPv4 src matches the IPv4 address derived from the
* local 6to4 address masked by prefixmask.
* success on: src = 10.1.1.1, ia6->ia_addr = 2002:0a00:.../24
* fail on: src = 10.1.1.1, ia6->ia_addr = 2002:0b00:.../24
*/
bzero -> memset
2001-07-18 20:43:09 +04:00
memset(&a, 0, sizeof(a));
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
a.s_addr = GET_V4(&ia6->ia_addr.sin6_addr)->s_addr;
a.s_addr &= GET_V4(&ia6->ia_prefixmask.sin6_addr)->s_addr;
b = ip.ip_src;
b.s_addr &= GET_V4(&ia6->ia_prefixmask.sin6_addr)->s_addr;
if (a.s_addr != b.s_addr)
return 0;
/* stf interface makes single side match only */
return 32;
}
static struct in6_ifaddr *
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
stf_getsrcifa6(struct ifnet *ifp)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
Switch to using ifa for ifaddr's instead of ia (which are traditionally used for in_ifaddr's) which could lead to confusion.
2005-01-25 20:22:08 +03:00
struct ifaddr *ifa;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
struct in_ifaddr *ia4;
struct sockaddr_in6 *sin6;
struct in_addr in;
Apply pserialize and psref to struct ifaddr and its variants This change makes struct ifaddr and its variants (in_ifaddr and in6_ifaddr) MP-safe by using pserialize and psref. At this moment, pserialize_perform and psref_target_destroy are disabled because (1) we don't need them because of softnet_lock (2) they cause a deadlock because of softnet_lock. So we'll enable them when we remove softnet_lock in the future.
2016-08-01 06:15:30 +03:00
int s;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
Apply pserialize and psref to struct ifaddr and its variants This change makes struct ifaddr and its variants (in_ifaddr and in6_ifaddr) MP-safe by using pserialize and psref. At this moment, pserialize_perform and psref_target_destroy are disabled because (1) we don't need them because of softnet_lock (2) they cause a deadlock because of softnet_lock. So we'll enable them when we remove softnet_lock in the future.
2016-08-01 06:15:30 +03:00
s = pserialize_read_enter();
IFADDR_READER_FOREACH(ifa, ifp) {
Switch to using ifa for ifaddr's instead of ia (which are traditionally used for in_ifaddr's) which could lead to confusion.
2005-01-25 20:22:08 +03:00
if (ifa->ifa_addr->sa_family != AF_INET6)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
continue;
Switch to using ifa for ifaddr's instead of ia (which are traditionally used for in_ifaddr's) which could lead to confusion.
2005-01-25 20:22:08 +03:00
sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
if (!IN6_IS_ADDR_6TO4(&sin6->sin6_addr))
continue;
Remove extra whitespace added by a stupid tool. XXX: more in src/sys/arch
2009-04-18 18:58:02 +04:00
memcpy(&in, GET_V4(&sin6->sin6_addr), sizeof(in));
Replace macros to get an IP address with proper inline functions The inline functions are more friendly for applying psz/psref; they consist of only simple interations.
2016-07-08 07:33:30 +03:00
ia4 = in_get_ia(in);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
if (ia4 == NULL)
continue;
Apply pserialize and psref to struct ifaddr and its variants This change makes struct ifaddr and its variants (in_ifaddr and in6_ifaddr) MP-safe by using pserialize and psref. At this moment, pserialize_perform and psref_target_destroy are disabled because (1) we don't need them because of softnet_lock (2) they cause a deadlock because of softnet_lock. So we'll enable them when we remove softnet_lock in the future.
2016-08-01 06:15:30 +03:00
pserialize_read_exit(s);
/* TODO NOMPSAFE */
Switch to using ifa for ifaddr's instead of ia (which are traditionally used for in_ifaddr's) which could lead to confusion.
2005-01-25 20:22:08 +03:00
return (struct in6_ifaddr *)ifa;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
Apply pserialize and psref to struct ifaddr and its variants This change makes struct ifaddr and its variants (in_ifaddr and in6_ifaddr) MP-safe by using pserialize and psref. At this moment, pserialize_perform and psref_target_destroy are disabled because (1) we don't need them because of softnet_lock (2) they cause a deadlock because of softnet_lock. So we'll enable them when we remove softnet_lock in the future.
2016-08-01 06:15:30 +03:00
pserialize_read_exit(s);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
return NULL;
}
static int
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
stf_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
Constify rtentry of if_output We no longer need to change rtentry below if_output. The change makes it clear where rtentries are changed (or not) and helps forthcoming locking (os psrefing) rtentries.
2016-04-28 03:16:56 +03:00
const struct rtentry *rt0)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
Poison struct route->ro_rt uses in the kernel by changing the name to _ro_rt. Use rtcache_getrt() to access a route cache's struct rtentry *. Introduce struct ifnet->if_dl that always points at the interface identifier/link-layer address. Make code that treated the first ifaddr on struct ifnet->if_addrlist as the interface address use if_dl, instead. Remove stale debugging code from net/route.c. Move the rtflush() code into rtcache_clear() and delete rtflush(). Delete rtalloc(), because nothing uses it any more. Make ND6_HINT an inline, lowercase subroutine, nd6_hint. I've done my best to convert IP Filter, the ISO stack, and the AppleTalk stack to rtcache_getrt(). They compile, but I have not tested them. I have given the changes to PF, GRE, IPv4 and IPv6 stacks a lot of exercise.
2007-12-20 22:53:29 +03:00
struct rtentry *rt;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
struct stf_softc *sc;
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
const struct sockaddr_in6 *dst6;
const struct in_addr *in4;
s/u_\(int[0-9]*_t\)/u\1/g (change u_int*_t to uint*_t)
2008-02-20 20:05:52 +03:00
uint8_t tos;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
struct ip *ip;
struct ip6_hdr *ip6;
struct in6_ifaddr *ia6;
Eliminate address family-specific route caches (struct route, struct route_in6, struct route_iso), replacing all caches with a struct route. The principle benefit of this change is that all of the protocol families can benefit from route cache-invalidation, which is necessary for correct routing. Route-cache invalidation fixes an ancient PR, kern/3508, at long last; it fixes various other PRs, also. Discussions with and ideas from Joerg Sonnenberger influenced this work tremendously. Of course, all design oversights and bugs are mine. DETAILS 1 I added to each address family a pool of sockaddrs. I have introduced routines for allocating, copying, and duplicating, and freeing sockaddrs: struct sockaddr *sockaddr_alloc(sa_family_t af, int flags); struct sockaddr *sockaddr_copy(struct sockaddr *dst, const struct sockaddr *src); struct sockaddr *sockaddr_dup(const struct sockaddr *src, int flags); void sockaddr_free(struct sockaddr *sa); sockaddr_alloc() returns either a sockaddr from the pool belonging to the specified family, or NULL if the pool is exhausted. The returned sockaddr has the right size for that family; sa_family and sa_len fields are initialized to the family and sockaddr length---e.g., sa_family = AF_INET and sa_len = sizeof(struct sockaddr_in). sockaddr_free() puts the given sockaddr back into its family's pool. sockaddr_dup() and sockaddr_copy() work analogously to strdup() and strcpy(), respectively. sockaddr_copy() KASSERTs that the family of the destination and source sockaddrs are alike. The 'flags' argumet for sockaddr_alloc() and sockaddr_dup() is passed directly to pool_get(9). 2 I added routines for initializing sockaddrs in each address family, sockaddr_in_init(), sockaddr_in6_init(), sockaddr_iso_init(), etc. They are fairly self-explanatory. 3 structs route_in6 and route_iso are no more. All protocol families use struct route. I have changed the route cache, 'struct route', so that it does not contain storage space for a sockaddr. Instead, struct route points to a sockaddr coming from the pool the sockaddr belongs to. I added a new method to struct route, rtcache_setdst(), for setting the cache destination: int rtcache_setdst(struct route *, const struct sockaddr *); rtcache_setdst() returns 0 on success, or ENOMEM if no memory is available to create the sockaddr storage. It is now possible for rtcache_getdst() to return NULL if, say, rtcache_setdst() failed. I check the return value for NULL everywhere in the kernel. 4 Each routing domain (struct domain) has a list of live route caches, dom_rtcache. rtflushall(sa_family_t af) looks up the domain indicated by 'af', walks the domain's list of route caches and invalidates each one.
2007-05-03 00:40:22 +04:00
union {
struct sockaddr dst;
struct sockaddr_in dst4;
} u;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
sc = (struct stf_softc*)ifp;
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
dst6 = (const struct sockaddr_in6 *)dst;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
/* just in case */
if ((ifp->if_flags & IFF_UP) == 0) {
m_freem(m);
return ENETDOWN;
}
/*
* If we don't have an ip4 address that match my inner ip6 address,
* we shouldn't generate output. Without this check, we'll end up
* using wrong IPv4 source.
*/
ia6 = stf_getsrcifa6(ifp);
if (ia6 == NULL) {
m_freem(m);
Increase interface output error count in case of a failure.
2002-07-23 10:59:51 +04:00
ifp->if_oerrors++;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
return ENETDOWN;
}
if (m->m_len < sizeof(*ip6)) {
m = m_pullup(m, sizeof(*ip6));
Increase interface output error count in case of a failure.
2002-07-23 10:59:51 +04:00
if (m == NULL) {
ifp->if_oerrors++;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
return ENOBUFS;
Increase interface output error count in case of a failure.
2002-07-23 10:59:51 +04:00
}
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
ip6 = mtod(m, struct ip6_hdr *);
tos = (ntohl(ip6->ip6_flow) >> 20) & 0xff;
correct outbound outer IPv4 destination address selection. IFF_LINK0 disables inbound path, removes security worries. more examples in manpage.
2001-04-29 07:56:06 +04:00
/*
* Pickup the right outer dst addr from the list of candidates.
* ip6_dst has priority as it may be able to give us shorter IPv4 hops.
*/
if (IN6_IS_ADDR_6TO4(&ip6->ip6_dst))
in4 = GET_V4(&ip6->ip6_dst);
else if (IN6_IS_ADDR_6TO4(&dst6->sin6_addr))
in4 = GET_V4(&dst6->sin6_addr);
else {
m_freem(m);
Increase interface output error count in case of a failure.
2002-07-23 10:59:51 +04:00
ifp->if_oerrors++;
correct outbound outer IPv4 destination address selection. IFF_LINK0 disables inbound path, removes security worries. more examples in manpage.
2001-04-29 07:56:06 +04:00
return ENETUNREACH;
}
Push the bpf_ops usage back into bpf.h. Push the common ifp->if_bpf check into the inline functions as well the fourth argument for bpf_attach.
2010-04-05 11:19:28 +04:00
bpf_mtap_af(ifp, AF_INET6, m);
inject outgoing packet to bpf. KAME PR 358.
2001-06-08 04:17:05 +04:00
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
M_PREPEND(m, sizeof(struct ip), M_DONTWAIT);
if (m && m->m_len < sizeof(struct ip))
m = m_pullup(m, sizeof(struct ip));
Increase interface output error count in case of a failure.
2002-07-23 10:59:51 +04:00
if (m == NULL) {
ifp->if_oerrors++;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
return ENOBUFS;
Increase interface output error count in case of a failure.
2002-07-23 10:59:51 +04:00
}
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
ip = mtod(m, struct ip *);
bzero -> memset
2001-07-18 20:43:09 +04:00
memset(ip, 0, sizeof(*ip));
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
bcopy(GET_V4(&((struct sockaddr_in6 *)&ia6->ia_addr)->sin6_addr),
&ip->ip_src, sizeof(ip->ip_src));
Remove extra whitespace added by a stupid tool. XXX: more in src/sys/arch
2009-04-18 18:58:02 +04:00
memcpy(&ip->ip_dst, in4, sizeof(ip->ip_dst));
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
ip->ip_p = IPPROTO_IPV6;
eliminate stf(4)'s dependency on gif(4). stf(4) depends on not gif(4) but ip_encap.
2016-08-18 14:38:58 +03:00
ip->ip_ttl = ip_stf_ttl;
avoid swapping endian of ip_len and ip_off on mbuf, to meet with M_LEADINGSPACE optimization made last year. should solve PR 17867 and 10195. IP_HDRINCL behavior of raw ip socket is kept unchanged. we may want to provide IP_HDRINCL variant that does not swap endian.
2002-08-14 04:23:27 +04:00
ip->ip_len = htons(m->m_pkthdr.len);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
if (ifp->if_flags & IFF_LINK1)
ip_ecn_ingress(ECN_ALLOWED, &ip->ip_tos, &tos);
correct ecn consideration on tunnel encap/decap. sync with kame.
2001-05-10 05:37:42 +04:00
else
ip_ecn_ingress(ECN_NOCARE, &ip->ip_tos, &tos);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
Eliminate address family-specific route caches (struct route, struct route_in6, struct route_iso), replacing all caches with a struct route. The principle benefit of this change is that all of the protocol families can benefit from route cache-invalidation, which is necessary for correct routing. Route-cache invalidation fixes an ancient PR, kern/3508, at long last; it fixes various other PRs, also. Discussions with and ideas from Joerg Sonnenberger influenced this work tremendously. Of course, all design oversights and bugs are mine. DETAILS 1 I added to each address family a pool of sockaddrs. I have introduced routines for allocating, copying, and duplicating, and freeing sockaddrs: struct sockaddr *sockaddr_alloc(sa_family_t af, int flags); struct sockaddr *sockaddr_copy(struct sockaddr *dst, const struct sockaddr *src); struct sockaddr *sockaddr_dup(const struct sockaddr *src, int flags); void sockaddr_free(struct sockaddr *sa); sockaddr_alloc() returns either a sockaddr from the pool belonging to the specified family, or NULL if the pool is exhausted. The returned sockaddr has the right size for that family; sa_family and sa_len fields are initialized to the family and sockaddr length---e.g., sa_family = AF_INET and sa_len = sizeof(struct sockaddr_in). sockaddr_free() puts the given sockaddr back into its family's pool. sockaddr_dup() and sockaddr_copy() work analogously to strdup() and strcpy(), respectively. sockaddr_copy() KASSERTs that the family of the destination and source sockaddrs are alike. The 'flags' argumet for sockaddr_alloc() and sockaddr_dup() is passed directly to pool_get(9). 2 I added routines for initializing sockaddrs in each address family, sockaddr_in_init(), sockaddr_in6_init(), sockaddr_iso_init(), etc. They are fairly self-explanatory. 3 structs route_in6 and route_iso are no more. All protocol families use struct route. I have changed the route cache, 'struct route', so that it does not contain storage space for a sockaddr. Instead, struct route points to a sockaddr coming from the pool the sockaddr belongs to. I added a new method to struct route, rtcache_setdst(), for setting the cache destination: int rtcache_setdst(struct route *, const struct sockaddr *); rtcache_setdst() returns 0 on success, or ENOMEM if no memory is available to create the sockaddr storage. It is now possible for rtcache_getdst() to return NULL if, say, rtcache_setdst() failed. I check the return value for NULL everywhere in the kernel. 4 Each routing domain (struct domain) has a list of live route caches, dom_rtcache. rtflushall(sa_family_t af) looks up the domain indicated by 'af', walks the domain's list of route caches and invalidates each one.
2007-05-03 00:40:22 +04:00
sockaddr_in_init(&u.dst4, &ip->ip_dst, 0);
Poison struct route->ro_rt uses in the kernel by changing the name to _ro_rt. Use rtcache_getrt() to access a route cache's struct rtentry *. Introduce struct ifnet->if_dl that always points at the interface identifier/link-layer address. Make code that treated the first ifaddr on struct ifnet->if_addrlist as the interface address use if_dl, instead. Remove stale debugging code from net/route.c. Move the rtflush() code into rtcache_clear() and delete rtflush(). Delete rtalloc(), because nothing uses it any more. Make ND6_HINT an inline, lowercase subroutine, nd6_hint. I've done my best to convert IP Filter, the ISO stack, and the AppleTalk stack to rtcache_getrt(). They compile, but I have not tested them. I have given the changes to PF, GRE, IPv4 and IPv6 stacks a lot of exercise.
2007-12-20 22:53:29 +03:00
if ((rt = rtcache_lookup(&sc->sc_ro, &u.dst)) == NULL) {
Eliminate address family-specific route caches (struct route, struct route_in6, struct route_iso), replacing all caches with a struct route. The principle benefit of this change is that all of the protocol families can benefit from route cache-invalidation, which is necessary for correct routing. Route-cache invalidation fixes an ancient PR, kern/3508, at long last; it fixes various other PRs, also. Discussions with and ideas from Joerg Sonnenberger influenced this work tremendously. Of course, all design oversights and bugs are mine. DETAILS 1 I added to each address family a pool of sockaddrs. I have introduced routines for allocating, copying, and duplicating, and freeing sockaddrs: struct sockaddr *sockaddr_alloc(sa_family_t af, int flags); struct sockaddr *sockaddr_copy(struct sockaddr *dst, const struct sockaddr *src); struct sockaddr *sockaddr_dup(const struct sockaddr *src, int flags); void sockaddr_free(struct sockaddr *sa); sockaddr_alloc() returns either a sockaddr from the pool belonging to the specified family, or NULL if the pool is exhausted. The returned sockaddr has the right size for that family; sa_family and sa_len fields are initialized to the family and sockaddr length---e.g., sa_family = AF_INET and sa_len = sizeof(struct sockaddr_in). sockaddr_free() puts the given sockaddr back into its family's pool. sockaddr_dup() and sockaddr_copy() work analogously to strdup() and strcpy(), respectively. sockaddr_copy() KASSERTs that the family of the destination and source sockaddrs are alike. The 'flags' argumet for sockaddr_alloc() and sockaddr_dup() is passed directly to pool_get(9). 2 I added routines for initializing sockaddrs in each address family, sockaddr_in_init(), sockaddr_in6_init(), sockaddr_iso_init(), etc. They are fairly self-explanatory. 3 structs route_in6 and route_iso are no more. All protocol families use struct route. I have changed the route cache, 'struct route', so that it does not contain storage space for a sockaddr. Instead, struct route points to a sockaddr coming from the pool the sockaddr belongs to. I added a new method to struct route, rtcache_setdst(), for setting the cache destination: int rtcache_setdst(struct route *, const struct sockaddr *); rtcache_setdst() returns 0 on success, or ENOMEM if no memory is available to create the sockaddr storage. It is now possible for rtcache_getdst() to return NULL if, say, rtcache_setdst() failed. I check the return value for NULL everywhere in the kernel. 4 Each routing domain (struct domain) has a list of live route caches, dom_rtcache. rtflushall(sa_family_t af) looks up the domain indicated by 'af', walks the domain's list of route caches and invalidates each one.
2007-05-03 00:40:22 +04:00
m_freem(m);
ifp->if_oerrors++;
return ENETUNREACH;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
Introduce new helper functions to abstract the route caching. rtcache_init and rtcache_init_noclone lookup ro_dst and store the result in ro_rt, taking care of the reference counting and calling the domain specific route cache. rtcache_free checks if a route was cashed and frees the reference. rtcache_copy copies ro_dst of the given struct route, checking that enough space is available and incrementing the reference count of the cached rtentry if necessary. rtcache_check validates that the cached route is still up. If it isn't, it tries to look it up again. Afterwards ro_rt is either a valid again or NULL. rtcache_copy is used internally. Adjust to callers of rtalloc/rtflush in the tree to check the sanity of ro_dst first (if necessary). If it doesn't fit the expectations, free the cache, otherwise check if the cached route is still valid. After that combination, a single check for ro_rt == NULL is enough to decide whether a new lookup needs to be done with a different ro_dst. Make the route checking in gre stricter by repeating the loop check after revalidation. Remove some unused RADIX_MPATH code in in6_src.c. The logic is slightly changed here to first validate the route and check RTF_GATEWAY afterwards. This is sementically equivalent though. etherip doesn't need sc_route_expire similiar to the gif changes from dyoung@ earlier. Based on the earlier patch from dyoung@, reviewed and discussed with him.
2006-12-16 00:18:52 +03:00
/* If the route constitutes infinite encapsulation, punt. */
Poison struct route->ro_rt uses in the kernel by changing the name to _ro_rt. Use rtcache_getrt() to access a route cache's struct rtentry *. Introduce struct ifnet->if_dl that always points at the interface identifier/link-layer address. Make code that treated the first ifaddr on struct ifnet->if_addrlist as the interface address use if_dl, instead. Remove stale debugging code from net/route.c. Move the rtflush() code into rtcache_clear() and delete rtflush(). Delete rtalloc(), because nothing uses it any more. Make ND6_HINT an inline, lowercase subroutine, nd6_hint. I've done my best to convert IP Filter, the ISO stack, and the AppleTalk stack to rtcache_getrt(). They compile, but I have not tested them. I have given the changes to PF, GRE, IPv4 and IPv6 stacks a lot of exercise.
2007-12-20 22:53:29 +03:00
if (rt->rt_ifp == ifp) {
Add rtcache_unref to release points of rtentry stemming from rtcache In the MP-safe world, a rtentry stemming from a rtcache can be freed at any points. So we need to protect rtentries somehow say by reference couting or passive references. Regardless of the method, we need to call some release function of a rtentry after using it. The change adds a new function rtcache_unref to release a rtentry. At this point, this function does nothing because for now we don't add a reference to a rtentry when we get one from a rtcache. We will add something useful in a further commit. This change is a part of changes for MP-safe routing table. It is separated to avoid one big change that makes difficult to debug by bisecting.
2016-12-08 08:16:33 +03:00
rtcache_unref(rt, &sc->sc_ro);
Introduce new helper functions to abstract the route caching. rtcache_init and rtcache_init_noclone lookup ro_dst and store the result in ro_rt, taking care of the reference counting and calling the domain specific route cache. rtcache_free checks if a route was cashed and frees the reference. rtcache_copy copies ro_dst of the given struct route, checking that enough space is available and incrementing the reference count of the cached rtentry if necessary. rtcache_check validates that the cached route is still up. If it isn't, it tries to look it up again. Afterwards ro_rt is either a valid again or NULL. rtcache_copy is used internally. Adjust to callers of rtalloc/rtflush in the tree to check the sanity of ro_dst first (if necessary). If it doesn't fit the expectations, free the cache, otherwise check if the cached route is still valid. After that combination, a single check for ro_rt == NULL is enough to decide whether a new lookup needs to be done with a different ro_dst. Make the route checking in gre stricter by repeating the loop check after revalidation. Remove some unused RADIX_MPATH code in in6_src.c. The logic is slightly changed here to first validate the route and check RTF_GATEWAY afterwards. This is sementically equivalent though. etherip doesn't need sc_route_expire similiar to the gif changes from dyoung@ earlier. Based on the earlier patch from dyoung@, reviewed and discussed with him.
2006-12-16 00:18:52 +03:00
rtcache_free(&sc->sc_ro);
m_freem(m);
ifp->if_oerrors++;
return ENETUNREACH;
}
Add rtcache_unref to release points of rtentry stemming from rtcache In the MP-safe world, a rtentry stemming from a rtcache can be freed at any points. So we need to protect rtentries somehow say by reference couting or passive references. Regardless of the method, we need to call some release function of a rtentry after using it. The change adds a new function rtcache_unref to release a rtentry. At this point, this function does nothing because for now we don't add a reference to a rtentry when we get one from a rtcache. We will add something useful in a further commit. This change is a part of changes for MP-safe routing table. It is separated to avoid one big change that makes difficult to debug by bisecting.
2016-12-08 08:16:33 +03:00
rtcache_unref(rt, &sc->sc_ro);
Introduce new helper functions to abstract the route caching. rtcache_init and rtcache_init_noclone lookup ro_dst and store the result in ro_rt, taking care of the reference counting and calling the domain specific route cache. rtcache_free checks if a route was cashed and frees the reference. rtcache_copy copies ro_dst of the given struct route, checking that enough space is available and incrementing the reference count of the cached rtentry if necessary. rtcache_check validates that the cached route is still up. If it isn't, it tries to look it up again. Afterwards ro_rt is either a valid again or NULL. rtcache_copy is used internally. Adjust to callers of rtalloc/rtflush in the tree to check the sanity of ro_dst first (if necessary). If it doesn't fit the expectations, free the cache, otherwise check if the cached route is still valid. After that combination, a single check for ro_rt == NULL is enough to decide whether a new lookup needs to be done with a different ro_dst. Make the route checking in gre stricter by repeating the loop check after revalidation. Remove some unused RADIX_MPATH code in in6_src.c. The logic is slightly changed here to first validate the route and check RTF_GATEWAY afterwards. This is sementically equivalent though. etherip doesn't need sc_route_expire similiar to the gif changes from dyoung@ earlier. Based on the earlier patch from dyoung@, reviewed and discussed with him.
2006-12-16 00:18:52 +03:00
Increase interface output counter for every encapsulated packet sent to IP.
2002-07-23 10:44:53 +04:00
ifp->if_opackets++;
PR/42285: PR/41559: Daniel Hagerty: if_stf doesn't count output bytes
2009-11-08 21:44:45 +03:00
ifp->if_obytes += m->m_pkthdr.len - sizeof(struct ip);
Eliminate address family-specific route caches (struct route, struct route_in6, struct route_iso), replacing all caches with a struct route. The principle benefit of this change is that all of the protocol families can benefit from route cache-invalidation, which is necessary for correct routing. Route-cache invalidation fixes an ancient PR, kern/3508, at long last; it fixes various other PRs, also. Discussions with and ideas from Joerg Sonnenberger influenced this work tremendously. Of course, all design oversights and bugs are mine. DETAILS 1 I added to each address family a pool of sockaddrs. I have introduced routines for allocating, copying, and duplicating, and freeing sockaddrs: struct sockaddr *sockaddr_alloc(sa_family_t af, int flags); struct sockaddr *sockaddr_copy(struct sockaddr *dst, const struct sockaddr *src); struct sockaddr *sockaddr_dup(const struct sockaddr *src, int flags); void sockaddr_free(struct sockaddr *sa); sockaddr_alloc() returns either a sockaddr from the pool belonging to the specified family, or NULL if the pool is exhausted. The returned sockaddr has the right size for that family; sa_family and sa_len fields are initialized to the family and sockaddr length---e.g., sa_family = AF_INET and sa_len = sizeof(struct sockaddr_in). sockaddr_free() puts the given sockaddr back into its family's pool. sockaddr_dup() and sockaddr_copy() work analogously to strdup() and strcpy(), respectively. sockaddr_copy() KASSERTs that the family of the destination and source sockaddrs are alike. The 'flags' argumet for sockaddr_alloc() and sockaddr_dup() is passed directly to pool_get(9). 2 I added routines for initializing sockaddrs in each address family, sockaddr_in_init(), sockaddr_in6_init(), sockaddr_iso_init(), etc. They are fairly self-explanatory. 3 structs route_in6 and route_iso are no more. All protocol families use struct route. I have changed the route cache, 'struct route', so that it does not contain storage space for a sockaddr. Instead, struct route points to a sockaddr coming from the pool the sockaddr belongs to. I added a new method to struct route, rtcache_setdst(), for setting the cache destination: int rtcache_setdst(struct route *, const struct sockaddr *); rtcache_setdst() returns 0 on success, or ENOMEM if no memory is available to create the sockaddr storage. It is now possible for rtcache_getdst() to return NULL if, say, rtcache_setdst() failed. I check the return value for NULL everywhere in the kernel. 4 Each routing domain (struct domain) has a list of live route caches, dom_rtcache. rtflushall(sa_family_t af) looks up the domain indicated by 'af', walks the domain's list of route caches and invalidates each one.
2007-05-03 00:40:22 +04:00
return ip_output(m, NULL, &sc->sc_ro, 0, NULL, NULL);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
reject SIOCAIFADDR if embedded address is in private address range. sync w/kame
2002-09-17 09:56:37 +04:00
static int
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
isrfc1918addr(const struct in_addr *in)
reject SIOCAIFADDR if embedded address is in private address range. sync w/kame
2002-09-17 09:56:37 +04:00
{
/*
* returns 1 if private address range:
* 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16
*/
if ((ntohl(in->s_addr) & 0xff000000) >> 24 == 10 ||
(ntohl(in->s_addr) & 0xfff00000) >> 16 == 172 * 256 + 16 ||
(ntohl(in->s_addr) & 0xffff0000) >> 16 == 192 * 256 + 168)
return 1;
return 0;
}
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
static int
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
stf_checkaddr4(struct stf_softc *sc, const struct in_addr *in,
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
struct ifnet *inifp /*incoming interface*/)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
struct in_ifaddr *ia4;
/*
* reject packets with the following address:
sync IPv4 rogue address filter with RFC1122. (sync with kame)
2000-05-14 07:44:02 +04:00
* 224.0.0.0/4 0.0.0.0/8 127.0.0.0/8 255.0.0.0/8
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
*/
sync IPv4 rogue address filter with RFC1122. (sync with kame)
2000-05-14 07:44:02 +04:00
if (IN_MULTICAST(in->s_addr))
return -1;
switch ((ntohl(in->s_addr) & 0xff000000) >> 24) {
case 0: case 127: case 255:
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
return -1;
}
reject packets with IPv4 private address range. sync w/kame
2002-06-20 11:43:39 +04:00
/*
reject SIOCAIFADDR if embedded address is in private address range. sync w/kame
2002-09-17 09:56:37 +04:00
* reject packets with private address range.
* (requirement from RFC3056 section 2 1st paragraph)
reject packets with IPv4 private address range. sync w/kame
2002-06-20 11:43:39 +04:00
*/
reject SIOCAIFADDR if embedded address is in private address range. sync w/kame
2002-09-17 09:56:37 +04:00
if (isrfc1918addr(in))
reject packets with IPv4 private address range. sync w/kame
2002-06-20 11:43:39 +04:00
return -1;
more pickier packet validation, based on draft-savola-v6ops-6to4-security-00.txt. sync w/kame
2002-11-17 22:29:31 +03:00
/*
* reject packet with IPv4 link-local (169.254.0.0/16),
* as suggested in draft-savola-v6ops-6to4-security-00.txt
*/
if (((ntohl(in->s_addr) & 0xff000000) >> 24) == 169 &&
((ntohl(in->s_addr) & 0x00ff0000) >> 16) == 254)
return -1;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
/*
* reject packets with broadcast
*/
Switch the IPv4 address list to pslist(9) Note that we leave the old list just in case; it seems there are some kvm(3) users accessing the list. We can remove it later if we confirmed nobody does actually.
2016-07-06 11:42:34 +03:00
IN_ADDRLIST_READER_FOREACH(ia4) {
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
if ((ia4->ia_ifa.ifa_ifp->if_flags & IFF_BROADCAST) == 0)
continue;
if (in->s_addr == ia4->ia_broadaddr.sin_addr.s_addr)
return -1;
}
/*
* perform ingress filter
*/
make it possible to turn off ingress filter on gif/stf tunnel egress, by using IFF_LINK2. (part of) PR 11163 from Ken Raeburn.
2001-01-22 10:51:01 +03:00
if (sc && (sc->sc_if.if_flags & IFF_LINK2) == 0 && inifp) {
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
struct sockaddr_in sin;
struct rtentry *rt;
bzero -> memset
2001-07-18 20:43:09 +04:00
memset(&sin, 0, sizeof(sin));
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
sin.sin_family = AF_INET;
sin.sin_len = sizeof(struct sockaddr_in);
sin.sin_addr = *in;
rt = rtalloc1((struct sockaddr *)&sin, 0);
make it possible to turn off ingress filter on gif/stf tunnel egress, by using IFF_LINK2. (part of) PR 11163 from Ken Raeburn.
2001-01-22 10:51:01 +03:00
if (!rt || rt->rt_ifp != inifp) {
#if 0
log(LOG_WARNING, "%s: packet from 0x%x dropped "
"due to ingress filter\n", if_name(&sc->sc_if),
s/u_\(int[0-9]*_t\)/u\1/g (change u_int*_t to uint*_t)
2008-02-20 20:05:52 +03:00
(uint32_t)ntohl(sin.sin_addr.s_addr));
make it possible to turn off ingress filter on gif/stf tunnel egress, by using IFF_LINK2. (part of) PR 11163 from Ken Raeburn.
2001-01-22 10:51:01 +03:00
#endif
if (rt)
Make the routing table and rtcaches MP-safe See the following descriptions for details. Proposed on tech-kern and tech-net Overview -------- We protect the routing table with a rwock and protect rtcaches with another rwlock. Each rtentry is protected from being freed or updated via reference counting and psref. Global rwlocks -------------- There are two rwlocks; one for the routing table (rt_lock) and the other for rtcaches (rtcache_lock). rtcache_lock covers all existing rtcaches; there may have room for optimizations (future work). The locking order is rtcache_lock first and rt_lock is next. rtentry references ------------------ References to an rtentry is managed with reference counting and psref. Either of the two mechanisms is used depending on where a rtentry is obtained. Reference counting is used when we obtain a rtentry from the routing table directly via rtalloc1 and rtrequest{,1} while psref is used when we obtain a rtentry from a rtcache via rtcache_* APIs. In both cases, a caller can sleep/block with holding an obtained rtentry. The reasons why we use two different mechanisms are (i) only using reference counting hurts the performance due to atomic instructions (rtcache case) (ii) ease of implementation; applying psref to APIs such rtaloc1 and rtrequest{,1} requires additional works (adding a local variable and an argument). We will finally migrate to use only psref but we can do it when we have a lockless routing table alternative. Reference counting for rtentry ------------------------------ rt_refcnt now doesn't count permanent references such as for rt_timers and rtcaches, instead it is used only for temporal references when obtaining a rtentry via rtalloc1 and rtrequest{,1}. We can do so because destroying a rtentry always involves removing references of rt_timers and rtcaches to the rtentry and we don't need to track such references. This also makes it easy to wait for readers to release references on deleting or updating a rtentry, i.e., we can simply wait until the reference counter is 0 or 1. (If there are permanent references the counter can be arbitrary.) rt_ref increments a reference counter of a rtentry and rt_unref decrements it. rt_ref is called inside APIs (rtalloc1 and rtrequest{,1} so users don't need to care about it while users must call rt_unref to an obtained rtentry after using it. rtfree is removed and we use rt_unref and rt_free instead. rt_unref now just decrements the counter of a given rtentry and rt_free just tries to destroy a given rtentry. See the next section for destructions of rtentries by rt_free. Destructions of rtentries ------------------------- We destroy a rtentry only when we call rtrequst{,1}(RTM_DELETE); the original implementation can destroy in any rtfree where it's the last reference. If we use reference counting or psref, it's easy to understand if the place that a rtentry is destroyed is fixed. rt_free waits for references to a given rtentry to be released before actually destroying the rtentry. rt_free uses a condition variable (cv_wait) (and psref_target_destroy for psref) to wait. Unfortunately rtrequst{,1}(RTM_DELETE) can be called in softint that we cannot use cv_wait. In that case, we have to defer the destruction to a workqueue. rtentry#rt_cv, rtentry#rt_psref and global variables (see rt_free_global) are added to conduct the procedure. Updates of rtentries -------------------- One difficulty to use refcnt/psref instead of rwlock for rtentry is updates of rtentries. We need an additional mechanism to prevent readers from seeing inconsistency of a rtentry being updated. We introduce RTF_UPDATING flag to rtentries that are updating. While the flag is set to a rtentry, users cannot acquire the rtentry. By doing so, we avoid users to see inconsistent rtentries. There are two options when a user tries to acquire a rtentry with the RTF_UPDATING flag; if a user runs in softint context the user fails to acquire a rtentry (NULL is returned). Otherwise a user waits until the update completes by waiting on cv. The procedure of a updater is simpler to destruction of a rtentry. Wait on cv (and psref) and after all readers left, proceed with the update. Global variables (see rt_update_global) are added to conduct the procedure. Currently we apply the mechanism to only RTM_CHANGE in rtsock.c. We would have to apply other codes. See "Known issues" section. psref for rtentry ----------------- When we obtain a rtentry from a rtcache via rtcache_* APIs, psref is used to reference to the rtentry. rtcache_ref acquires a reference to a rtentry with psref and rtcache_unref releases the reference after using it. rtcache_ref is called inside rtcache_* APIs and users don't need to take care of it while users must call rtcache_unref to release the reference. struct psref and int bound that is needed for psref is embedded into struct route. By doing so we don't need to add local variables and additional argument to APIs. However this adds another constraint to psref other than reference counting one's; holding a reference of an rtentry via a rtcache is allowed by just one caller at the same time. So we must not acquire a rtentry via a rtcache twice and avoid a recursive use of a rtcache. And also a rtcache must be arranged to be used by a LWP/softint at the same time somehow. For IP forwarding case, we have per-CPU rtcaches used in softint so the constraint is guaranteed. For a h rtcache of a PCB case, the constraint is guaranteed by the solock of each PCB. Any other cases (pf, ipf, stf and ipsec) are currently guaranteed by only the existence of the global locks (softnet_lock and/or KERNEL_LOCK). If we've found the cases that we cannot guarantee the constraint, we would need to introduce other rtcache APIs that use simple reference counting. psref of rtcache is created with IPL_SOFTNET and so rtcache shouldn't used at an IPL higher than IPL_SOFTNET. Note that rtcache_free is used to invalidate a given rtcache. We don't need another care by my change; just keep them as they are. Performance impact ------------------ When NET_MPSAFE is disabled the performance drop is 3% while when it's enabled the drop is increased to 11%. The difference comes from that currently we don't take any global locks and don't use psref if NET_MPSAFE is disabled. We can optimize the performance of the case of NET_MPSAFE on by reducing lookups of rtcache that uses psref; currently we do two lookups but we should be able to trim one of two. This is a future work. Known issues ------------ There are two known issues to be solved; one is that a caller of rtrequest(RTM_ADD) may change rtentry (see rtinit). We need to prevent new references during the update. Or we may be able to remove the code (perhaps, need more investigations). The other is rtredirect that updates a rtentry. We need to apply our update mechanism, however it's not easy because rtredirect is called in softint and we cannot apply our mechanism simply. One solution is to defer rtredirect to a workqueue but it requires some code restructuring.
2016-12-12 06:55:57 +03:00
rt_unref(rt);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
return -1;
}
Make the routing table and rtcaches MP-safe See the following descriptions for details. Proposed on tech-kern and tech-net Overview -------- We protect the routing table with a rwock and protect rtcaches with another rwlock. Each rtentry is protected from being freed or updated via reference counting and psref. Global rwlocks -------------- There are two rwlocks; one for the routing table (rt_lock) and the other for rtcaches (rtcache_lock). rtcache_lock covers all existing rtcaches; there may have room for optimizations (future work). The locking order is rtcache_lock first and rt_lock is next. rtentry references ------------------ References to an rtentry is managed with reference counting and psref. Either of the two mechanisms is used depending on where a rtentry is obtained. Reference counting is used when we obtain a rtentry from the routing table directly via rtalloc1 and rtrequest{,1} while psref is used when we obtain a rtentry from a rtcache via rtcache_* APIs. In both cases, a caller can sleep/block with holding an obtained rtentry. The reasons why we use two different mechanisms are (i) only using reference counting hurts the performance due to atomic instructions (rtcache case) (ii) ease of implementation; applying psref to APIs such rtaloc1 and rtrequest{,1} requires additional works (adding a local variable and an argument). We will finally migrate to use only psref but we can do it when we have a lockless routing table alternative. Reference counting for rtentry ------------------------------ rt_refcnt now doesn't count permanent references such as for rt_timers and rtcaches, instead it is used only for temporal references when obtaining a rtentry via rtalloc1 and rtrequest{,1}. We can do so because destroying a rtentry always involves removing references of rt_timers and rtcaches to the rtentry and we don't need to track such references. This also makes it easy to wait for readers to release references on deleting or updating a rtentry, i.e., we can simply wait until the reference counter is 0 or 1. (If there are permanent references the counter can be arbitrary.) rt_ref increments a reference counter of a rtentry and rt_unref decrements it. rt_ref is called inside APIs (rtalloc1 and rtrequest{,1} so users don't need to care about it while users must call rt_unref to an obtained rtentry after using it. rtfree is removed and we use rt_unref and rt_free instead. rt_unref now just decrements the counter of a given rtentry and rt_free just tries to destroy a given rtentry. See the next section for destructions of rtentries by rt_free. Destructions of rtentries ------------------------- We destroy a rtentry only when we call rtrequst{,1}(RTM_DELETE); the original implementation can destroy in any rtfree where it's the last reference. If we use reference counting or psref, it's easy to understand if the place that a rtentry is destroyed is fixed. rt_free waits for references to a given rtentry to be released before actually destroying the rtentry. rt_free uses a condition variable (cv_wait) (and psref_target_destroy for psref) to wait. Unfortunately rtrequst{,1}(RTM_DELETE) can be called in softint that we cannot use cv_wait. In that case, we have to defer the destruction to a workqueue. rtentry#rt_cv, rtentry#rt_psref and global variables (see rt_free_global) are added to conduct the procedure. Updates of rtentries -------------------- One difficulty to use refcnt/psref instead of rwlock for rtentry is updates of rtentries. We need an additional mechanism to prevent readers from seeing inconsistency of a rtentry being updated. We introduce RTF_UPDATING flag to rtentries that are updating. While the flag is set to a rtentry, users cannot acquire the rtentry. By doing so, we avoid users to see inconsistent rtentries. There are two options when a user tries to acquire a rtentry with the RTF_UPDATING flag; if a user runs in softint context the user fails to acquire a rtentry (NULL is returned). Otherwise a user waits until the update completes by waiting on cv. The procedure of a updater is simpler to destruction of a rtentry. Wait on cv (and psref) and after all readers left, proceed with the update. Global variables (see rt_update_global) are added to conduct the procedure. Currently we apply the mechanism to only RTM_CHANGE in rtsock.c. We would have to apply other codes. See "Known issues" section. psref for rtentry ----------------- When we obtain a rtentry from a rtcache via rtcache_* APIs, psref is used to reference to the rtentry. rtcache_ref acquires a reference to a rtentry with psref and rtcache_unref releases the reference after using it. rtcache_ref is called inside rtcache_* APIs and users don't need to take care of it while users must call rtcache_unref to release the reference. struct psref and int bound that is needed for psref is embedded into struct route. By doing so we don't need to add local variables and additional argument to APIs. However this adds another constraint to psref other than reference counting one's; holding a reference of an rtentry via a rtcache is allowed by just one caller at the same time. So we must not acquire a rtentry via a rtcache twice and avoid a recursive use of a rtcache. And also a rtcache must be arranged to be used by a LWP/softint at the same time somehow. For IP forwarding case, we have per-CPU rtcaches used in softint so the constraint is guaranteed. For a h rtcache of a PCB case, the constraint is guaranteed by the solock of each PCB. Any other cases (pf, ipf, stf and ipsec) are currently guaranteed by only the existence of the global locks (softnet_lock and/or KERNEL_LOCK). If we've found the cases that we cannot guarantee the constraint, we would need to introduce other rtcache APIs that use simple reference counting. psref of rtcache is created with IPL_SOFTNET and so rtcache shouldn't used at an IPL higher than IPL_SOFTNET. Note that rtcache_free is used to invalidate a given rtcache. We don't need another care by my change; just keep them as they are. Performance impact ------------------ When NET_MPSAFE is disabled the performance drop is 3% while when it's enabled the drop is increased to 11%. The difference comes from that currently we don't take any global locks and don't use psref if NET_MPSAFE is disabled. We can optimize the performance of the case of NET_MPSAFE on by reducing lookups of rtcache that uses psref; currently we do two lookups but we should be able to trim one of two. This is a future work. Known issues ------------ There are two known issues to be solved; one is that a caller of rtrequest(RTM_ADD) may change rtentry (see rtinit). We need to prevent new references during the update. Or we may be able to remove the code (perhaps, need more investigations). The other is rtredirect that updates a rtentry. We need to apply our update mechanism, however it's not easy because rtredirect is called in softint and we cannot apply our mechanism simply. One solution is to defer rtredirect to a workqueue but it requires some code restructuring.
2016-12-12 06:55:57 +03:00
rt_unref(rt);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
return 0;
}
static int
KNF: de-__P, bzero -> memset, bcmp -> memcmp. Remove extraneous parentheses in return statements. Cosmetic: don't open-code TAILQ_FOREACH(). Cosmetic: change types of variables to avoid oodles of casts: in in6_src.c, avoid casts by changing several route_in6 pointers to struct route pointers. Remove unnecessary casts to caddr_t elsewhere. Pave the way for eliminating address family-specific route caches: soon, struct route will not embed a sockaddr, but it will hold a reference to an external sockaddr, instead. We will set the destination sockaddr using rtcache_setdst(). (I created a stub for it, but it isn't used anywhere, yet.) rtcache_free() will free the sockaddr. I have extracted from rtcache_free() a helper subroutine, rtcache_clear(). rtcache_clear() will "forget" a cached route, but it will not forget the destination by releasing the sockaddr. I use rtcache_clear() instead of rtcache_free() in rtcache_update(), because rtcache_update() is not supposed to forget the destination. Constify: 1 Introduce const accessor for route->ro_dst, rtcache_getdst(). 2 Constify the 'dst' argument to ifnet->if_output(). This led me to constify a lot of code called by output routines. 3 Constify the sockaddr argument to protosw->pr_ctlinput. This led me to constify a lot of code called by ctlinput routines. 4 Introduce const macros for converting from a generic sockaddr to family-specific sockaddrs, e.g., sockaddr_in: satocsin6, satocsin, et cetera.
2007-02-18 01:34:07 +03:00
stf_checkaddr6(struct stf_softc *sc, const struct in6_addr *in6,
ANSI function decls and application of static.
2005-12-12 02:05:24 +03:00
struct ifnet *inifp /*incoming interface*/)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
more pickier packet validation, based on draft-savola-v6ops-6to4-security-00.txt. sync w/kame
2002-11-17 22:29:31 +03:00
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
/*
* check 6to4 addresses
*/
if (IN6_IS_ADDR_6TO4(in6))
make it possible to turn off ingress filter on gif/stf tunnel egress, by using IFF_LINK2. (part of) PR 11163 from Ken Raeburn.
2001-01-22 10:51:01 +03:00
return stf_checkaddr4(sc, GET_V4(in6), inifp);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
/*
* reject anything that look suspicious. the test is implemented
* in ip6_input too, but we check here as well to
* (1) reject bad packets earlier, and
* (2) to be safe against future ip6_input change.
*/
if (IN6_IS_ADDR_V4COMPAT(in6) || IN6_IS_ADDR_V4MAPPED(in6))
return -1;
more pickier packet validation, based on draft-savola-v6ops-6to4-security-00.txt. sync w/kame
2002-11-17 22:29:31 +03:00
/*
* reject link-local and site-local unicast
* as suggested in draft-savola-v6ops-6to4-security-00.txt
*/
if (IN6_IS_ADDR_LINKLOCAL(in6) || IN6_IS_ADDR_SITELOCAL(in6))
return -1;
/*
* reject node-local and link-local multicast
* as suggested in draft-savola-v6ops-6to4-security-00.txt
*/
if (IN6_IS_ADDR_MC_NODELOCAL(in6) || IN6_IS_ADDR_MC_LINKLOCAL(in6))
return -1;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
return 0;
}
fix my wrong modification
2016-01-28 03:28:11 +03:00
void
in_stf_input(struct mbuf *m, int off, int proto)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
implement encapsw instead of protosw and uniform prototype. suggested and advised by riastradh@n.o, thanks. BTW, It seems in_stf_input() had bugs...
2016-01-26 08:58:05 +03:00
int s;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
struct stf_softc *sc;
struct ip *ip;
struct ip6_hdr *ip6;
s/u_\(int[0-9]*_t\)/u\1/g (change u_int*_t to uint*_t)
2008-02-20 20:05:52 +03:00
uint8_t otos, itos;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
struct ifnet *ifp;
- Implement pktqueue interface for lockless IP input queue. - Replace ipintrq and ip6intrq with the pktqueue mechanism. - Eliminate kernel-lock from ipintr() and ip6intr(). - Some preparation work to push softnet_lock out of ipintr(). Discussed on tech-net.
2014-06-06 03:48:16 +04:00
size_t pktlen;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
if (proto != IPPROTO_IPV6) {
m_freem(m);
fix my wrong modification
2016-01-28 03:28:11 +03:00
return;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
ip = mtod(m, struct ip *);
sc = (struct stf_softc *)encap_getarg(m);
if (sc == NULL || (sc->sc_if.if_flags & IFF_UP) == 0) {
m_freem(m);
fix my wrong modification
2016-01-28 03:28:11 +03:00
return;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
ifp = &sc->sc_if;
/*
* perform sanity check against outer src/dst.
* for source, perform ingress filter as well.
*/
make it possible to turn off ingress filter on gif/stf tunnel egress, by using IFF_LINK2. (part of) PR 11163 from Ken Raeburn.
2001-01-22 10:51:01 +03:00
if (stf_checkaddr4(sc, &ip->ip_dst, NULL) < 0 ||
Avoid storing a pointer of an interface in a mbuf Having a pointer of an interface in a mbuf isn't safe if we remove big kernel locks; an interface object (ifnet) can be destroyed anytime in any packet processing and accessing such object via a pointer is racy. Instead we have to get an object from the interface collection (ifindex2ifnet) via an interface index (if_index) that is stored to a mbuf instead of an pointer. The change provides two APIs: m_{get,put}_rcvif_psref that use psref(9) for sleep-able critical sections and m_{get,put}_rcvif that use pserialize(9) for other critical sections. The change also adds another API called m_get_rcvif_NOMPSAFE, that is NOT MP-safe and for transition moratorium, i.e., it is intended to be used for places where are not planned to be MP-ified soon. The change adds some overhead due to psref to performance sensitive paths, however the overhead is not serious, 2% down at worst. Proposed on tech-kern and tech-net.
2016-06-10 16:31:43 +03:00
stf_checkaddr4(sc, &ip->ip_src, m_get_rcvif_NOMPSAFE(m)) < 0) {
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
m_freem(m);
fix my wrong modification
2016-01-28 03:28:11 +03:00
return;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
otos = ip->ip_tos;
m_adj(m, off);
if (m->m_len < sizeof(*ip6)) {
m = m_pullup(m, sizeof(*ip6));
if (!m)
fix my wrong modification
2016-01-28 03:28:11 +03:00
return;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
ip6 = mtod(m, struct ip6_hdr *);
/*
* perform sanity check against inner src/dst.
* for source, perform ingress filter as well.
*/
make it possible to turn off ingress filter on gif/stf tunnel egress, by using IFF_LINK2. (part of) PR 11163 from Ken Raeburn.
2001-01-22 10:51:01 +03:00
if (stf_checkaddr6(sc, &ip6->ip6_dst, NULL) < 0 ||
Avoid storing a pointer of an interface in a mbuf Having a pointer of an interface in a mbuf isn't safe if we remove big kernel locks; an interface object (ifnet) can be destroyed anytime in any packet processing and accessing such object via a pointer is racy. Instead we have to get an object from the interface collection (ifindex2ifnet) via an interface index (if_index) that is stored to a mbuf instead of an pointer. The change provides two APIs: m_{get,put}_rcvif_psref that use psref(9) for sleep-able critical sections and m_{get,put}_rcvif that use pserialize(9) for other critical sections. The change also adds another API called m_get_rcvif_NOMPSAFE, that is NOT MP-safe and for transition moratorium, i.e., it is intended to be used for places where are not planned to be MP-ified soon. The change adds some overhead due to psref to performance sensitive paths, however the overhead is not serious, 2% down at worst. Proposed on tech-kern and tech-net.
2016-06-10 16:31:43 +03:00
stf_checkaddr6(sc, &ip6->ip6_src, m_get_rcvif_NOMPSAFE(m)) < 0) {
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
m_freem(m);
fix my wrong modification
2016-01-28 03:28:11 +03:00
return;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
itos = (ntohl(ip6->ip6_flow) >> 20) & 0xff;
if ((ifp->if_flags & IFF_LINK1) != 0)
ip_ecn_egress(ECN_ALLOWED, &otos, &itos);
correct ecn consideration on tunnel encap/decap. sync with kame.
2001-05-10 05:37:42 +04:00
else
ip_ecn_egress(ECN_NOCARE, &otos, &itos);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
ip6->ip6_flow &= ~htonl(0xff << 20);
s/u_\(int[0-9]*_t\)/u\1/g (change u_int*_t to uint*_t)
2008-02-20 20:05:52 +03:00
ip6->ip6_flow |= htonl((uint32_t)itos << 20);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
- Implement pktqueue interface for lockless IP input queue. - Replace ipintrq and ip6intrq with the pktqueue mechanism. - Eliminate kernel-lock from ipintr() and ip6intr(). - Some preparation work to push softnet_lock out of ipintr(). Discussed on tech-net.
2014-06-06 03:48:16 +04:00
pktlen = m->m_pkthdr.len;
Introduce m_set_rcvif and m_reset_rcvif The API is used to set (or reset) a received interface of a mbuf. They are counterpart of m_get_rcvif, which will come in another commit, hide internal of rcvif operation, and reduce the diff of the upcoming change. No functional change.
2016-06-10 16:27:10 +03:00
m_set_rcvif(m, ifp);
nuke trailing whitespace
2005-02-27 01:45:09 +03:00
Push the bpf_ops usage back into bpf.h. Push the common ifp->if_bpf check into the inline functions as well the fourth argument for bpf_attach.
2010-04-05 11:19:28 +04:00
bpf_mtap_af(ifp, AF_INET6, m);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
/*
* Put the packet to the network layer input queue according to the
* specified address family.
* See net/if_gif.c for possible issues with packet processing
* reorder due to extra queueing.
*/
Remove the use of splimp() from the NetBSD kernel. splnet() and only splnet() is allowed for the protection of data structures used by network devices.
2001-04-14 03:29:55 +04:00
s = splnet();
- Implement pktqueue interface for lockless IP input queue. - Replace ipintrq and ip6intrq with the pktqueue mechanism. - Eliminate kernel-lock from ipintr() and ip6intr(). - Some preparation work to push softnet_lock out of ipintr(). Discussed on tech-net.
2014-06-06 03:48:16 +04:00
if (__predict_true(pktq_enqueue(ip6_pktq, m, 0))) {
ifp->if_ipackets++;
ifp->if_ibytes += pktlen;
} else {
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
m_freem(m);
}
splx(s);
implement encapsw instead of protosw and uniform prototype. suggested and advised by riastradh@n.o, thanks. BTW, It seems in_stf_input() had bugs...
2016-01-26 08:58:05 +03:00
fix my wrong modification
2016-01-28 03:28:11 +03:00
return;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
/* ARGSUSED */
static void
__unused removal on arguments; approved by core.
2006-11-16 04:32:37 +03:00
stf_rtrequest(int cmd, struct rtentry *rt,
Constify the rt_addrinfo argument to the ifa_rtrequest member function of struct ifaddr.
2008-10-24 21:07:33 +04:00
const struct rt_addrinfo *info)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
if (rt != NULL) {
struct stf_softc *sc;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
sc = LIST_FIRST(&stf_softc_list);
rt->rt_rmx.rmx_mtu = (sc != NULL) ? sc->sc_if.if_mtu : STF_MTU;
}
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
}
static int
Kill caddr_t; there will be some MI fallout, but it will be fixed shortly.
2007-03-04 08:59:00 +03:00
stf_ioctl(struct ifnet *ifp, u_long cmd, void *data)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
{
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
struct ifaddr *ifa;
Start patching up the kernel so that a network driver always has the opportunity to handle an ioctl before generic ifioctl handling occurs. This will ease extending the kernel and sharing of code between drivers. First steps: Make the signature of ifioctl_common() match struct ifinet->if_ioctl. Convert SIOCSIFCAP and SIOCSIFMTU to the new ifioctl() regime, throughout the kernel.
2008-02-07 04:21:52 +03:00
struct ifreq *ifr = data;
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
struct sockaddr_in6 *sin6;
int error;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
error = 0;
switch (cmd) {
*** Summary *** When a link-layer address changes (e.g., ifconfig ex0 link 02:de:ad:be:ef:02 active), send a gratuitous ARP and/or a Neighbor Advertisement to update the network-/link-layer address bindings on our LAN peers. Refuse a change of ethernet address to the address 00:00:00:00:00:00 or to any multicast/broadcast address. (Thanks matt@.) Reorder ifnet ioctl operations so that driver ioctls may inherit the functions of their "class"---ether_ioctl(), fddi_ioctl(), et cetera---and the class ioctls may inherit from the generic ioctl, ifioctl_common(), but both driver- and class-ioctls may override the generic behavior. Make network drivers share more code. Distinguish a "factory" link-layer address from others for the purposes of both protecting that address from deletion and computing EUI64. Return consistent, appropriate error codes from network drivers. Improve readability. KNF. *** Details *** In if_attach(), always initialize the interface ioctl routine, ifnet->if_ioctl, if the driver has not already initialized it. Delete if_ioctl == NULL tests everywhere else, because it cannot happen. In the ioctl routines of network interfaces, inherit common ioctl behaviors by calling either ifioctl_common() or whichever ioctl routine is appropriate for the class of interface---e.g., ether_ioctl() for ethernets. Stop (ab)using SIOCSIFADDR and start to use SIOCINITIFADDR. In the user->kernel interface, SIOCSIFADDR's argument was an ifreq, but on the protocol->ifnet interface, SIOCSIFADDR's argument was an ifaddr. That was confusing, and it would work against me as I make it possible for a network interface to overload most ioctls. On the protocol->ifnet interface, replace SIOCSIFADDR with SIOCINITIFADDR. In ifioctl(), return EPERM if userland tries to invoke SIOCINITIFADDR. In ifioctl(), give the interface the first shot at handling most interface ioctls, and give the protocol the second shot, instead of the other way around. Finally, let compatibility code (COMPAT_OSOCK) take a shot. Pull device initialization out of switch statements under SIOCINITIFADDR. For example, pull ..._init() out of any switch statement that looks like this: switch (...->sa_family) { case ...: ..._init(); ... break; ... default: ..._init(); ... break; } Rewrite many if-else clauses that handle all permutations of IFF_UP and IFF_RUNNING to use a switch statement, switch (x & (IFF_UP|IFF_RUNNING)) { case 0: ... break; case IFF_RUNNING: ... break; case IFF_UP: ... break; case IFF_UP|IFF_RUNNING: ... break; } unifdef lots of code containing #ifdef FreeBSD, #ifdef NetBSD, and #ifdef SIOCSIFMTU, especially in fwip(4) and in ndis(4). In ipw(4), remove an if_set_sadl() call that is out of place. In nfe(4), reuse the jumbo MTU logic in ether_ioctl(). Let ethernets register a callback for setting h/w state such as promiscuous mode and the multicast filter in accord with a change in the if_flags: ether_set_ifflags_cb() registers a callback that returns ENETRESET if the caller should reset the ethernet by calling if_init(), 0 on success, != 0 on failure. Pull common code from ex(4), gem(4), nfe(4), sip(4), tlp(4), vge(4) into ether_ioctl(), and register if_flags callbacks for those drivers. Return ENOTTY instead of EINVAL for inappropriate ioctls. In zyd(4), use ENXIO instead of ENOTTY to indicate that the device is not any longer attached. Add to if_set_sadl() a boolean 'factory' argument that indicates whether a link-layer address was assigned by the factory or some other source. In a comment, recommend using the factory address for generating an EUI64, and update in6_get_hw_ifid() to prefer a factory address to any other link-layer address. Add a routing message, RTM_LLINFO_UPD, that tells protocols to update the binding of network-layer addresses to link-layer addresses. Implement this message in IPv4 and IPv6 by sending a gratuitous ARP or a neighbor advertisement, respectively. Generate RTM_LLINFO_UPD messages on a change of an interface's link-layer address. In ether_ioctl(), do not let SIOCALIFADDR set a link-layer address that is broadcast/multicast or equal to 00:00:00:00:00:00. Make ether_ioctl() call ifioctl_common() to handle ioctls that it does not understand. In gif(4), initialize if_softc and use it, instead of assuming that the gif_softc and ifp overlap. Let ifioctl_common() handle SIOCGIFADDR. Sprinkle rtcache_invariants(), which checks on DIAGNOSTIC kernels that certain invariants on a struct route are satisfied. In agr(4), rewrite agr_ioctl_filter() to be a bit more explicit about the ioctls that we do not allow on an agr(4) member interface. bzero -> memset. Delete unnecessary casts to void *. Use sockaddr_in_init() and sockaddr_in6_init(). Compare pointers with NULL instead of "testing truth". Replace some instances of (type *)0 with NULL. Change some K&R prototypes to ANSI C, and join lines.
2008-11-07 03:20:01 +03:00
case SIOCINITIFADDR:
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
ifa = (struct ifaddr *)data;
if (ifa == NULL || ifa->ifa_addr->sa_family != AF_INET6) {
error = EAFNOSUPPORT;
break;
}
sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
reject SIOCAIFADDR if embedded address is in private address range. sync w/kame
2002-09-17 09:56:37 +04:00
if (IN6_IS_ADDR_6TO4(&sin6->sin6_addr) &&
!isrfc1918addr(GET_V4(&sin6->sin6_addr))) {
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
ifa->ifa_rtrequest = stf_rtrequest;
ifp->if_flags |= IFF_UP;
} else
error = EINVAL;
break;
case SIOCADDMULTI:
case SIOCDELMULTI:
Use ifreq_setaddr(), ifreq_getaddr(), sockaddr_in_init(), and sockaddr_copy(). Constify. Compare pointers with NULL, not 0. Don't "test truth" of pointers, but compare with NULL.
2007-09-01 08:32:50 +04:00
if (ifr != NULL &&
ifreq_getaddr(cmd, ifr)->sa_family == AF_INET6)
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
;
else
error = EAFNOSUPPORT;
break;
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
case SIOCSIFMTU:
Start patching up the kernel so that a network driver always has the opportunity to handle an ioctl before generic ifioctl handling occurs. This will ease extending the kernel and sharing of code between drivers. First steps: Make the signature of ifioctl_common() match struct ifinet->if_ioctl. Convert SIOCSIFCAP and SIOCSIFMTU to the new ifioctl() regime, throughout the kernel.
2008-02-07 04:21:52 +03:00
if (ifr->ifr_mtu < STF_MTU_MIN || ifr->ifr_mtu > STF_MTU_MAX)
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
return EINVAL;
Start patching up the kernel so that a network driver always has the opportunity to handle an ioctl before generic ifioctl handling occurs. This will ease extending the kernel and sharing of code between drivers. First steps: Make the signature of ifioctl_common() match struct ifinet->if_ioctl. Convert SIOCSIFCAP and SIOCSIFMTU to the new ifioctl() regime, throughout the kernel.
2008-02-07 04:21:52 +03:00
else if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET)
error = 0;
Add support for changing the MTU to stf(4).
2005-03-11 16:28:25 +03:00
break;
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
default:
*** Summary *** When a link-layer address changes (e.g., ifconfig ex0 link 02:de:ad:be:ef:02 active), send a gratuitous ARP and/or a Neighbor Advertisement to update the network-/link-layer address bindings on our LAN peers. Refuse a change of ethernet address to the address 00:00:00:00:00:00 or to any multicast/broadcast address. (Thanks matt@.) Reorder ifnet ioctl operations so that driver ioctls may inherit the functions of their "class"---ether_ioctl(), fddi_ioctl(), et cetera---and the class ioctls may inherit from the generic ioctl, ifioctl_common(), but both driver- and class-ioctls may override the generic behavior. Make network drivers share more code. Distinguish a "factory" link-layer address from others for the purposes of both protecting that address from deletion and computing EUI64. Return consistent, appropriate error codes from network drivers. Improve readability. KNF. *** Details *** In if_attach(), always initialize the interface ioctl routine, ifnet->if_ioctl, if the driver has not already initialized it. Delete if_ioctl == NULL tests everywhere else, because it cannot happen. In the ioctl routines of network interfaces, inherit common ioctl behaviors by calling either ifioctl_common() or whichever ioctl routine is appropriate for the class of interface---e.g., ether_ioctl() for ethernets. Stop (ab)using SIOCSIFADDR and start to use SIOCINITIFADDR. In the user->kernel interface, SIOCSIFADDR's argument was an ifreq, but on the protocol->ifnet interface, SIOCSIFADDR's argument was an ifaddr. That was confusing, and it would work against me as I make it possible for a network interface to overload most ioctls. On the protocol->ifnet interface, replace SIOCSIFADDR with SIOCINITIFADDR. In ifioctl(), return EPERM if userland tries to invoke SIOCINITIFADDR. In ifioctl(), give the interface the first shot at handling most interface ioctls, and give the protocol the second shot, instead of the other way around. Finally, let compatibility code (COMPAT_OSOCK) take a shot. Pull device initialization out of switch statements under SIOCINITIFADDR. For example, pull ..._init() out of any switch statement that looks like this: switch (...->sa_family) { case ...: ..._init(); ... break; ... default: ..._init(); ... break; } Rewrite many if-else clauses that handle all permutations of IFF_UP and IFF_RUNNING to use a switch statement, switch (x & (IFF_UP|IFF_RUNNING)) { case 0: ... break; case IFF_RUNNING: ... break; case IFF_UP: ... break; case IFF_UP|IFF_RUNNING: ... break; } unifdef lots of code containing #ifdef FreeBSD, #ifdef NetBSD, and #ifdef SIOCSIFMTU, especially in fwip(4) and in ndis(4). In ipw(4), remove an if_set_sadl() call that is out of place. In nfe(4), reuse the jumbo MTU logic in ether_ioctl(). Let ethernets register a callback for setting h/w state such as promiscuous mode and the multicast filter in accord with a change in the if_flags: ether_set_ifflags_cb() registers a callback that returns ENETRESET if the caller should reset the ethernet by calling if_init(), 0 on success, != 0 on failure. Pull common code from ex(4), gem(4), nfe(4), sip(4), tlp(4), vge(4) into ether_ioctl(), and register if_flags callbacks for those drivers. Return ENOTTY instead of EINVAL for inappropriate ioctls. In zyd(4), use ENXIO instead of ENOTTY to indicate that the device is not any longer attached. Add to if_set_sadl() a boolean 'factory' argument that indicates whether a link-layer address was assigned by the factory or some other source. In a comment, recommend using the factory address for generating an EUI64, and update in6_get_hw_ifid() to prefer a factory address to any other link-layer address. Add a routing message, RTM_LLINFO_UPD, that tells protocols to update the binding of network-layer addresses to link-layer addresses. Implement this message in IPv4 and IPv6 by sending a gratuitous ARP or a neighbor advertisement, respectively. Generate RTM_LLINFO_UPD messages on a change of an interface's link-layer address. In ether_ioctl(), do not let SIOCALIFADDR set a link-layer address that is broadcast/multicast or equal to 00:00:00:00:00:00. Make ether_ioctl() call ifioctl_common() to handle ioctls that it does not understand. In gif(4), initialize if_softc and use it, instead of assuming that the gif_softc and ifp overlap. Let ifioctl_common() handle SIOCGIFADDR. Sprinkle rtcache_invariants(), which checks on DIAGNOSTIC kernels that certain invariants on a struct route are satisfied. In agr(4), rewrite agr_ioctl_filter() to be a bit more explicit about the ioctls that we do not allow on an agr(4) member interface. bzero -> memset. Delete unnecessary casts to void *. Use sockaddr_in_init() and sockaddr_in6_init(). Compare pointers with NULL instead of "testing truth". Replace some instances of (type *)0 with NULL. Change some K&R prototypes to ANSI C, and join lines.
2008-11-07 03:20:01 +03:00
error = ifioctl_common(ifp, cmd, data);
introduce sys/netinet/ip_encap.c, to dispatch inbound packets to protocol handlers, based on src/dst (for ip proto #4/41). see comment in ip_encap.c for details of the problem we have. there are too many protocol specs for ip proto #4/41. backward compatibility with MROUTING case is now provided in ip_encap.c. fix ipip to work with gif (using ip_encap.c). sorry for breakage. gif now uses ip_encap.c. introduce stf pseudo interface (implements 6to4, another IPv6-over-IPv4 code with ip proto #41).
2000-04-19 10:30:51 +04:00
break;
}
return error;
}
modularize some more drivers and merge the module glue
2016-08-07 20:38:33 +03:00
/*
* Module infrastructure
*/
#include "if_module.h"
IF_MODULE(MODULE_CLASS_DRIVER, stf, "")
Reference in New Issue Copy Permalink