Bug Summary

File:net/if_gre.c
Warning:line 3249, column 41
The right operand of '>>' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name if_gre.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/net/if_gre.c
1/* $OpenBSD: if_gre.c,v 1.178 2023/12/23 10:52:54 bluhm Exp $ */
2/* $NetBSD: if_gre.c,v 1.9 1999/10/25 19:18:11 drochner Exp $ */
3
4/*
5 * Copyright (c) 1998 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Heiko W.Rupp <hwr@pilhuhn.de>
10 *
11 * IPv6-over-GRE contributed by Gert Doering <gert@greenie.muc.de>
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35/*
36 * Encapsulate L3 protocols into IP, per RFC 1701 and 1702.
37 * See gre(4) for more details.
38 * Also supported: IP in IP encapsulation (proto 55) per RFC 2004.
39 */
40
41#include "bpfilter.h"
42#include "pf.h"
43
44#include <sys/param.h>
45#include <sys/mbuf.h>
46#include <sys/socket.h>
47#include <sys/sockio.h>
48#include <sys/kernel.h>
49#include <sys/systm.h>
50#include <sys/errno.h>
51#include <sys/timeout.h>
52#include <sys/queue.h>
53#include <sys/tree.h>
54#include <sys/pool.h>
55#include <sys/rwlock.h>
56
57#include <crypto/siphash.h>
58
59#include <net/if.h>
60#include <net/if_var.h>
61#include <net/if_types.h>
62#include <net/if_media.h>
63#include <net/route.h>
64
65#include <netinet/in.h>
66#include <netinet/in_var.h>
67#include <netinet/if_ether.h>
68#include <netinet/ip.h>
69#include <netinet/ip_var.h>
70#include <netinet/ip_ecn.h>
71
72#ifdef INET61
73#include <netinet/ip6.h>
74#include <netinet6/ip6_var.h>
75#include <netinet6/in6_var.h>
76#endif
77
78#ifdef PIPEX1
79#include <net/pipex.h>
80#endif
81
82#ifdef MPLS1
83#include <netmpls/mpls.h>
84#endif /* MPLS */
85
86#if NBPFILTER1 > 0
87#include <net/bpf.h>
88#endif
89
90#if NPF1 > 0
91#include <net/pfvar.h>
92#endif
93
94#include <net/if_gre.h>
95
96#include <netinet/ip_gre.h>
97#include <sys/sysctl.h>
98
99/* for nvgre bridge shizz */
100#include <net/if_bridge.h>
101#include <net/if_etherbridge.h>
102
103/*
104 * packet formats
105 */
106struct gre_header {
107 uint16_t gre_flags;
108#define GRE_CP0x8000 0x8000 /* Checksum Present */
109#define GRE_KP0x2000 0x2000 /* Key Present */
110#define GRE_SP0x1000 0x1000 /* Sequence Present */
111
112#define GRE_VERS_MASK0x0007 0x0007
113#define GRE_VERS_00x0000 0x0000
114#define GRE_VERS_10x0001 0x0001
115
116 uint16_t gre_proto;
117} __packed__attribute__((__packed__)) __aligned(4)__attribute__((__aligned__(4)));
118
119struct gre_h_cksum {
120 uint16_t gre_cksum;
121 uint16_t gre_reserved1;
122} __packed__attribute__((__packed__)) __aligned(4)__attribute__((__aligned__(4)));
123
124struct gre_h_key {
125 uint32_t gre_key;
126} __packed__attribute__((__packed__)) __aligned(4)__attribute__((__aligned__(4)));
127
128#define GRE_EOIP0x6400 0x6400
129
130struct gre_h_key_eoip {
131 uint16_t eoip_len; /* network order */
132 uint16_t eoip_tunnel_id; /* little endian */
133} __packed__attribute__((__packed__)) __aligned(4)__attribute__((__aligned__(4)));
134
135#define NVGRE_VSID_RES_MIN0x000000 0x000000 /* reserved for future use */
136#define NVGRE_VSID_RES_MAX0x000fff 0x000fff
137#define NVGRE_VSID_NVE2NVE0xffffff 0xffffff /* vendor specific NVE-to-NVE comms */
138
139struct gre_h_seq {
140 uint32_t gre_seq;
141} __packed__attribute__((__packed__)) __aligned(4)__attribute__((__aligned__(4)));
142
143struct gre_h_wccp {
144 uint8_t wccp_flags;
145 uint8_t service_id;
146 uint8_t alt_bucket;
147 uint8_t pri_bucket;
148} __packed__attribute__((__packed__)) __aligned(4)__attribute__((__aligned__(4)));
149
150#define GRE_WCCP0x883e 0x883e
151
152#define GRE_HDRLEN(sizeof(struct ip) + sizeof(struct gre_header)) (sizeof(struct ip) + sizeof(struct gre_header))
153
154/*
155 * GRE tunnel metadata
156 */
157
158#define GRE_KA_NONE0 0
159#define GRE_KA_DOWN1 1
160#define GRE_KA_HOLD2 2
161#define GRE_KA_UP3 3
162
163union gre_addr {
164 struct in_addr in4;
165 struct in6_addr in6;
166};
167
168static inline int
169 gre_ip_cmp(int, const union gre_addr *,
170 const union gre_addr *);
171
172#define GRE_KEY_MIN0x00000000U 0x00000000U
173#define GRE_KEY_MAX0xffffffffU 0xffffffffU
174#define GRE_KEY_SHIFT0 0
175
176#define GRE_KEY_ENTROPY_MIN0x00000000U 0x00000000U
177#define GRE_KEY_ENTROPY_MAX0x00ffffffU 0x00ffffffU
178#define GRE_KEY_ENTROPY_SHIFT8 8
179
180struct gre_tunnel {
181 uint32_t t_key_mask;
182#define GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U)) htonl(0x00000000U)(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U))
183#define GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U)) htonl(0xffffff00U)(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U))
184#define GRE_KEY_MASK(__uint32_t)(__builtin_constant_p(0xffffffffU) ? (__uint32_t)
(((__uint32_t)(0xffffffffU) & 0xff) << 24 | ((__uint32_t
)(0xffffffffU) & 0xff00) << 8 | ((__uint32_t)(0xffffffffU
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffffffU) &
0xff000000) >> 24) : __swap32md(0xffffffffU)) htonl(0xffffffffU)(__uint32_t)(__builtin_constant_p(0xffffffffU) ? (__uint32_t)
(((__uint32_t)(0xffffffffU) & 0xff) << 24 | ((__uint32_t
)(0xffffffffU) & 0xff00) << 8 | ((__uint32_t)(0xffffffffU
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffffffU) &
0xff000000) >> 24) : __swap32md(0xffffffffU))
185 uint32_t t_key;
186
187 u_int t_rtableid;
188 union gre_addr t_src;
189#define t_src4t_src.in4 t_src.in4
190#define t_src6t_src.in6 t_src.in6
191 union gre_addr t_dst;
192#define t_dst4t_dst.in4 t_dst.in4
193#define t_dst6t_dst.in6 t_dst.in6
194 int t_ttl;
195 int t_txhprio;
196 int t_rxhprio;
197 int t_ecn;
198 uint16_t t_df;
199 sa_family_t t_af;
200};
201
202static int
203 gre_cmp_src(const struct gre_tunnel *,
204 const struct gre_tunnel *);
205static int
206 gre_cmp(const struct gre_tunnel *, const struct gre_tunnel *);
207
208static int gre_set_tunnel(struct gre_tunnel *, struct if_laddrreq *, int);
209static int gre_get_tunnel(struct gre_tunnel *, struct if_laddrreq *);
210static int gre_del_tunnel(struct gre_tunnel *);
211
212static int gre_set_vnetid(struct gre_tunnel *, struct ifreq *);
213static int gre_get_vnetid(struct gre_tunnel *, struct ifreq *);
214static int gre_del_vnetid(struct gre_tunnel *);
215
216static int gre_set_vnetflowid(struct gre_tunnel *, struct ifreq *);
217static int gre_get_vnetflowid(struct gre_tunnel *, struct ifreq *);
218
219static struct mbuf *
220 gre_encap_dst(const struct gre_tunnel *, const union gre_addr *,
221 struct mbuf *, uint16_t, uint8_t, uint8_t);
222#define gre_encap(_t, _m, _p, _ttl, _tos)gre_encap_dst((_t), &(_t)->t_dst, (_m), (_p), (_ttl), (
_tos)) \
223 gre_encap_dst((_t), &(_t)->t_dst, (_m), (_p), (_ttl), (_tos))
224
225static struct mbuf *
226 gre_encap_dst_ip(const struct gre_tunnel *,
227 const union gre_addr *, struct mbuf *, uint8_t, uint8_t);
228#define gre_encap_ip(_t, _m, _ttl, _tos)gre_encap_dst_ip((_t), &(_t)->t_dst, (_m), (_ttl), (_tos
)) \
229 gre_encap_dst_ip((_t), &(_t)->t_dst, (_m), (_ttl), (_tos))
230
231static int
232 gre_ip_output(const struct gre_tunnel *, struct mbuf *);
233
234static int gre_tunnel_ioctl(struct ifnet *, struct gre_tunnel *,
235 u_long, void *);
236
237static uint8_t gre_l2_tos(const struct gre_tunnel *, const struct mbuf *);
238static uint8_t gre_l3_tos(const struct gre_tunnel *,
239 const struct mbuf *, uint8_t);
240
241/*
242 * layer 3 GRE tunnels
243 */
244
245struct gre_softc {
246 struct gre_tunnel sc_tunnel; /* must be first */
247 TAILQ_ENTRY(gre_softc)struct { struct gre_softc *tqe_next; struct gre_softc **tqe_prev
; } sc_entry;
248
249 struct ifnet sc_if;
250
251 struct timeout sc_ka_send;
252 struct timeout sc_ka_hold;
253
254 unsigned int sc_ka_state;
255 unsigned int sc_ka_timeo;
256 unsigned int sc_ka_count;
257
258 unsigned int sc_ka_holdmax;
259 unsigned int sc_ka_holdcnt;
260
261 SIPHASH_KEY sc_ka_key;
262 uint32_t sc_ka_bias;
263 int sc_ka_recvtm;
264};
265
266TAILQ_HEAD(gre_list, gre_softc)struct gre_list { struct gre_softc *tqh_first; struct gre_softc
**tqh_last; };
267
268struct gre_keepalive {
269 uint32_t gk_uptime;
270 uint32_t gk_random;
271 uint8_t gk_digest[SIPHASH_DIGEST_LENGTH8];
272} __packed__attribute__((__packed__)) __aligned(4)__attribute__((__aligned__(4)));
273
274static int gre_clone_create(struct if_clone *, int);
275static int gre_clone_destroy(struct ifnet *);
276
277struct if_clone gre_cloner =
278 IF_CLONE_INITIALIZER("gre", gre_clone_create, gre_clone_destroy){ .ifc_list = { ((void *)0), ((void *)0) }, .ifc_name = "gre"
, .ifc_namelen = sizeof("gre") - 1, .ifc_create = gre_clone_create
, .ifc_destroy = gre_clone_destroy, };
279
280/* protected by NET_LOCK */
281struct gre_list gre_list = TAILQ_HEAD_INITIALIZER(gre_list){ ((void *)0), &(gre_list).tqh_first };
282
283static int gre_output(struct ifnet *, struct mbuf *, struct sockaddr *,
284 struct rtentry *);
285static void gre_start(struct ifnet *);
286static int gre_ioctl(struct ifnet *, u_long, caddr_t);
287
288static int gre_up(struct gre_softc *);
289static int gre_down(struct gre_softc *);
290static void gre_link_state(struct ifnet *, unsigned int);
291
292static int gre_input_key(struct mbuf **, int *, int, int, uint8_t,
293 struct gre_tunnel *);
294
295static struct mbuf *
296 gre_ipv4_patch(const struct gre_tunnel *, struct mbuf *,
297 uint8_t *, uint8_t);
298#ifdef INET61
299static struct mbuf *
300 gre_ipv6_patch(const struct gre_tunnel *, struct mbuf *,
301 uint8_t *, uint8_t);
302#endif
303#ifdef MPLS1
304static struct mbuf *
305 gre_mpls_patch(const struct gre_tunnel *, struct mbuf *,
306 uint8_t *, uint8_t);
307#endif
308static void gre_keepalive_send(void *);
309static void gre_keepalive_recv(struct ifnet *ifp, struct mbuf *);
310static void gre_keepalive_hold(void *);
311
312static struct mbuf *
313 gre_l3_encap_dst(const struct gre_tunnel *, const void *,
314 struct mbuf *m, sa_family_t);
315
316#define gre_l3_encap(_t, _m, _af)gre_l3_encap_dst((_t), &(_t)->t_dst, (_m), (_af)) \
317 gre_l3_encap_dst((_t), &(_t)->t_dst, (_m), (_af))
318
319struct mgre_softc {
320 struct gre_tunnel sc_tunnel; /* must be first */
321 RBT_ENTRY(mgre_softc)struct rb_entry sc_entry;
322
323 struct ifnet sc_if;
324};
325
326RBT_HEAD(mgre_tree, mgre_softc)struct mgre_tree { struct rb_tree rbh_root; };
327
328static inline int
329 mgre_cmp(const struct mgre_softc *, const struct mgre_softc *);
330
331RBT_PROTOTYPE(mgre_tree, mgre_softc, sc_entry, mgre_cmp)extern const struct rb_type *const mgre_tree_RBT_TYPE; __attribute__
((__unused__)) static inline void mgre_tree_RBT_INIT(struct mgre_tree
*head) { _rb_init(&head->rbh_root); } __attribute__((
__unused__)) static inline struct mgre_softc * mgre_tree_RBT_INSERT
(struct mgre_tree *head, struct mgre_softc *elm) { return _rb_insert
(mgre_tree_RBT_TYPE, &head->rbh_root, elm); } __attribute__
((__unused__)) static inline struct mgre_softc * mgre_tree_RBT_REMOVE
(struct mgre_tree *head, struct mgre_softc *elm) { return _rb_remove
(mgre_tree_RBT_TYPE, &head->rbh_root, elm); } __attribute__
((__unused__)) static inline struct mgre_softc * mgre_tree_RBT_FIND
(struct mgre_tree *head, const struct mgre_softc *key) { return
_rb_find(mgre_tree_RBT_TYPE, &head->rbh_root, key); }
__attribute__((__unused__)) static inline struct mgre_softc *
mgre_tree_RBT_NFIND(struct mgre_tree *head, const struct mgre_softc
*key) { return _rb_nfind(mgre_tree_RBT_TYPE, &head->rbh_root
, key); } __attribute__((__unused__)) static inline struct mgre_softc
* mgre_tree_RBT_ROOT(struct mgre_tree *head) { return _rb_root
(mgre_tree_RBT_TYPE, &head->rbh_root); } __attribute__
((__unused__)) static inline int mgre_tree_RBT_EMPTY(struct mgre_tree
*head) { return _rb_empty(&head->rbh_root); } __attribute__
((__unused__)) static inline struct mgre_softc * mgre_tree_RBT_MIN
(struct mgre_tree *head) { return _rb_min(mgre_tree_RBT_TYPE,
&head->rbh_root); } __attribute__((__unused__)) static
inline struct mgre_softc * mgre_tree_RBT_MAX(struct mgre_tree
*head) { return _rb_max(mgre_tree_RBT_TYPE, &head->rbh_root
); } __attribute__((__unused__)) static inline struct mgre_softc
* mgre_tree_RBT_NEXT(struct mgre_softc *elm) { return _rb_next
(mgre_tree_RBT_TYPE, elm); } __attribute__((__unused__)) static
inline struct mgre_softc * mgre_tree_RBT_PREV(struct mgre_softc
*elm) { return _rb_prev(mgre_tree_RBT_TYPE, elm); } __attribute__
((__unused__)) static inline struct mgre_softc * mgre_tree_RBT_LEFT
(struct mgre_softc *elm) { return _rb_left(mgre_tree_RBT_TYPE
, elm); } __attribute__((__unused__)) static inline struct mgre_softc
* mgre_tree_RBT_RIGHT(struct mgre_softc *elm) { return _rb_right
(mgre_tree_RBT_TYPE, elm); } __attribute__((__unused__)) static
inline struct mgre_softc * mgre_tree_RBT_PARENT(struct mgre_softc
*elm) { return _rb_parent(mgre_tree_RBT_TYPE, elm); } __attribute__
((__unused__)) static inline void mgre_tree_RBT_SET_LEFT(struct
mgre_softc *elm, struct mgre_softc *left) { _rb_set_left(mgre_tree_RBT_TYPE
, elm, left); } __attribute__((__unused__)) static inline void
mgre_tree_RBT_SET_RIGHT(struct mgre_softc *elm, struct mgre_softc
*right) { _rb_set_right(mgre_tree_RBT_TYPE, elm, right); } __attribute__
((__unused__)) static inline void mgre_tree_RBT_SET_PARENT(struct
mgre_softc *elm, struct mgre_softc *parent) { _rb_set_parent
(mgre_tree_RBT_TYPE, elm, parent); } __attribute__((__unused__
)) static inline void mgre_tree_RBT_POISON(struct mgre_softc *
elm, unsigned long poison) { _rb_poison(mgre_tree_RBT_TYPE, elm
, poison); } __attribute__((__unused__)) static inline int mgre_tree_RBT_CHECK
(struct mgre_softc *elm, unsigned long poison) { return _rb_check
(mgre_tree_RBT_TYPE, elm, poison); };
332
333static int mgre_clone_create(struct if_clone *, int);
334static int mgre_clone_destroy(struct ifnet *);
335
336struct if_clone mgre_cloner =
337 IF_CLONE_INITIALIZER("mgre", mgre_clone_create, mgre_clone_destroy){ .ifc_list = { ((void *)0), ((void *)0) }, .ifc_name = "mgre"
, .ifc_namelen = sizeof("mgre") - 1, .ifc_create = mgre_clone_create
, .ifc_destroy = mgre_clone_destroy, };
338
339static void mgre_rtrequest(struct ifnet *, int, struct rtentry *);
340static int mgre_output(struct ifnet *, struct mbuf *, struct sockaddr *,
341 struct rtentry *);
342static void mgre_start(struct ifnet *);
343static int mgre_ioctl(struct ifnet *, u_long, caddr_t);
344
345static int mgre_set_tunnel(struct mgre_softc *, struct if_laddrreq *);
346static int mgre_get_tunnel(struct mgre_softc *, struct if_laddrreq *);
347static int mgre_up(struct mgre_softc *);
348static int mgre_down(struct mgre_softc *);
349
350/* protected by NET_LOCK */
351struct mgre_tree mgre_tree = RBT_INITIALIZER(){ { ((void *)0) } };
352
353/*
354 * Ethernet GRE tunnels
355 */
356
357static struct mbuf *
358 gre_ether_align(struct mbuf *, int);
359
360struct egre_softc {
361 struct gre_tunnel sc_tunnel; /* must be first */
362 RBT_ENTRY(egre_softc)struct rb_entry sc_entry;
363
364 struct arpcom sc_ac;
365 struct ifmedia sc_media;
366};
367
368RBT_HEAD(egre_tree, egre_softc)struct egre_tree { struct rb_tree rbh_root; };
369
370static inline int
371 egre_cmp(const struct egre_softc *, const struct egre_softc *);
372
373RBT_PROTOTYPE(egre_tree, egre_softc, sc_entry, egre_cmp)extern const struct rb_type *const egre_tree_RBT_TYPE; __attribute__
((__unused__)) static inline void egre_tree_RBT_INIT(struct egre_tree
*head) { _rb_init(&head->rbh_root); } __attribute__((
__unused__)) static inline struct egre_softc * egre_tree_RBT_INSERT
(struct egre_tree *head, struct egre_softc *elm) { return _rb_insert
(egre_tree_RBT_TYPE, &head->rbh_root, elm); } __attribute__
((__unused__)) static inline struct egre_softc * egre_tree_RBT_REMOVE
(struct egre_tree *head, struct egre_softc *elm) { return _rb_remove
(egre_tree_RBT_TYPE, &head->rbh_root, elm); } __attribute__
((__unused__)) static inline struct egre_softc * egre_tree_RBT_FIND
(struct egre_tree *head, const struct egre_softc *key) { return
_rb_find(egre_tree_RBT_TYPE, &head->rbh_root, key); }
__attribute__((__unused__)) static inline struct egre_softc *
egre_tree_RBT_NFIND(struct egre_tree *head, const struct egre_softc
*key) { return _rb_nfind(egre_tree_RBT_TYPE, &head->rbh_root
, key); } __attribute__((__unused__)) static inline struct egre_softc
* egre_tree_RBT_ROOT(struct egre_tree *head) { return _rb_root
(egre_tree_RBT_TYPE, &head->rbh_root); } __attribute__
((__unused__)) static inline int egre_tree_RBT_EMPTY(struct egre_tree
*head) { return _rb_empty(&head->rbh_root); } __attribute__
((__unused__)) static inline struct egre_softc * egre_tree_RBT_MIN
(struct egre_tree *head) { return _rb_min(egre_tree_RBT_TYPE,
&head->rbh_root); } __attribute__((__unused__)) static
inline struct egre_softc * egre_tree_RBT_MAX(struct egre_tree
*head) { return _rb_max(egre_tree_RBT_TYPE, &head->rbh_root
); } __attribute__((__unused__)) static inline struct egre_softc
* egre_tree_RBT_NEXT(struct egre_softc *elm) { return _rb_next
(egre_tree_RBT_TYPE, elm); } __attribute__((__unused__)) static
inline struct egre_softc * egre_tree_RBT_PREV(struct egre_softc
*elm) { return _rb_prev(egre_tree_RBT_TYPE, elm); } __attribute__
((__unused__)) static inline struct egre_softc * egre_tree_RBT_LEFT
(struct egre_softc *elm) { return _rb_left(egre_tree_RBT_TYPE
, elm); } __attribute__((__unused__)) static inline struct egre_softc
* egre_tree_RBT_RIGHT(struct egre_softc *elm) { return _rb_right
(egre_tree_RBT_TYPE, elm); } __attribute__((__unused__)) static
inline struct egre_softc * egre_tree_RBT_PARENT(struct egre_softc
*elm) { return _rb_parent(egre_tree_RBT_TYPE, elm); } __attribute__
((__unused__)) static inline void egre_tree_RBT_SET_LEFT(struct
egre_softc *elm, struct egre_softc *left) { _rb_set_left(egre_tree_RBT_TYPE
, elm, left); } __attribute__((__unused__)) static inline void
egre_tree_RBT_SET_RIGHT(struct egre_softc *elm, struct egre_softc
*right) { _rb_set_right(egre_tree_RBT_TYPE, elm, right); } __attribute__
((__unused__)) static inline void egre_tree_RBT_SET_PARENT(struct
egre_softc *elm, struct egre_softc *parent) { _rb_set_parent
(egre_tree_RBT_TYPE, elm, parent); } __attribute__((__unused__
)) static inline void egre_tree_RBT_POISON(struct egre_softc *
elm, unsigned long poison) { _rb_poison(egre_tree_RBT_TYPE, elm
, poison); } __attribute__((__unused__)) static inline int egre_tree_RBT_CHECK
(struct egre_softc *elm, unsigned long poison) { return _rb_check
(egre_tree_RBT_TYPE, elm, poison); };
374
375static int egre_clone_create(struct if_clone *, int);
376static int egre_clone_destroy(struct ifnet *);
377
378static void egre_start(struct ifnet *);
379static int egre_ioctl(struct ifnet *, u_long, caddr_t);
380static int egre_media_change(struct ifnet *);
381static void egre_media_status(struct ifnet *, struct ifmediareq *);
382
383static int egre_up(struct egre_softc *);
384static int egre_down(struct egre_softc *);
385
386static int egre_input(const struct gre_tunnel *, struct mbuf *, int,
387 uint8_t);
388struct if_clone egre_cloner =
389 IF_CLONE_INITIALIZER("egre", egre_clone_create, egre_clone_destroy){ .ifc_list = { ((void *)0), ((void *)0) }, .ifc_name = "egre"
, .ifc_namelen = sizeof("egre") - 1, .ifc_create = egre_clone_create
, .ifc_destroy = egre_clone_destroy, };
390
391/* protected by NET_LOCK */
392struct egre_tree egre_tree = RBT_INITIALIZER(){ { ((void *)0) } };
393
394/*
395 * Network Virtualisation Using Generic Routing Encapsulation (NVGRE)
396 */
397
398struct nvgre_softc {
399 struct gre_tunnel sc_tunnel; /* must be first */
400 unsigned int sc_ifp0;
401 RBT_ENTRY(nvgre_softc)struct rb_entry sc_uentry;
402 RBT_ENTRY(nvgre_softc)struct rb_entry sc_mentry;
403
404 struct arpcom sc_ac;
405 struct ifmedia sc_media;
406
407 struct mbuf_queue sc_send_list;
408 struct task sc_send_task;
409
410 void *sc_inm;
411 struct task sc_ltask;
412 struct task sc_dtask;
413
414 struct etherbridge sc_eb;
415};
416
417RBT_HEAD(nvgre_ucast_tree, nvgre_softc)struct nvgre_ucast_tree { struct rb_tree rbh_root; };
418RBT_HEAD(nvgre_mcast_tree, nvgre_softc)struct nvgre_mcast_tree { struct rb_tree rbh_root; };
419
420static inline int
421 nvgre_cmp_ucast(const struct nvgre_softc *,
422 const struct nvgre_softc *);
423static int
424 nvgre_cmp_mcast(const struct gre_tunnel *,
425 const union gre_addr *, unsigned int,
426 const struct gre_tunnel *, const union gre_addr *,
427 unsigned int);
428static inline int
429 nvgre_cmp_mcast_sc(const struct nvgre_softc *,
430 const struct nvgre_softc *);
431
432RBT_PROTOTYPE(nvgre_ucast_tree, nvgre_softc, sc_uentry, nvgre_cmp_ucast)extern const struct rb_type *const nvgre_ucast_tree_RBT_TYPE;
__attribute__((__unused__)) static inline void nvgre_ucast_tree_RBT_INIT
(struct nvgre_ucast_tree *head) { _rb_init(&head->rbh_root
); } __attribute__((__unused__)) static inline struct nvgre_softc
* nvgre_ucast_tree_RBT_INSERT(struct nvgre_ucast_tree *head,
struct nvgre_softc *elm) { return _rb_insert(nvgre_ucast_tree_RBT_TYPE
, &head->rbh_root, elm); } __attribute__((__unused__))
static inline struct nvgre_softc * nvgre_ucast_tree_RBT_REMOVE
(struct nvgre_ucast_tree *head, struct nvgre_softc *elm) { return
_rb_remove(nvgre_ucast_tree_RBT_TYPE, &head->rbh_root
, elm); } __attribute__((__unused__)) static inline struct nvgre_softc
* nvgre_ucast_tree_RBT_FIND(struct nvgre_ucast_tree *head, const
struct nvgre_softc *key) { return _rb_find(nvgre_ucast_tree_RBT_TYPE
, &head->rbh_root, key); } __attribute__((__unused__))
static inline struct nvgre_softc * nvgre_ucast_tree_RBT_NFIND
(struct nvgre_ucast_tree *head, const struct nvgre_softc *key
) { return _rb_nfind(nvgre_ucast_tree_RBT_TYPE, &head->
rbh_root, key); } __attribute__((__unused__)) static inline struct
nvgre_softc * nvgre_ucast_tree_RBT_ROOT(struct nvgre_ucast_tree
*head) { return _rb_root(nvgre_ucast_tree_RBT_TYPE, &head
->rbh_root); } __attribute__((__unused__)) static inline int
nvgre_ucast_tree_RBT_EMPTY(struct nvgre_ucast_tree *head) { return
_rb_empty(&head->rbh_root); } __attribute__((__unused__
)) static inline struct nvgre_softc * nvgre_ucast_tree_RBT_MIN
(struct nvgre_ucast_tree *head) { return _rb_min(nvgre_ucast_tree_RBT_TYPE
, &head->rbh_root); } __attribute__((__unused__)) static
inline struct nvgre_softc * nvgre_ucast_tree_RBT_MAX(struct nvgre_ucast_tree
*head) { return _rb_max(nvgre_ucast_tree_RBT_TYPE, &head
->rbh_root); } __attribute__((__unused__)) static inline struct
nvgre_softc * nvgre_ucast_tree_RBT_NEXT(struct nvgre_softc *
elm) { return _rb_next(nvgre_ucast_tree_RBT_TYPE, elm); } __attribute__
((__unused__)) static inline struct nvgre_softc * nvgre_ucast_tree_RBT_PREV
(struct nvgre_softc *elm) { return _rb_prev(nvgre_ucast_tree_RBT_TYPE
, elm); } __attribute__((__unused__)) static inline struct nvgre_softc
* nvgre_ucast_tree_RBT_LEFT(struct nvgre_softc *elm) { return
_rb_left(nvgre_ucast_tree_RBT_TYPE, elm); } __attribute__((__unused__
)) static inline struct nvgre_softc * nvgre_ucast_tree_RBT_RIGHT
(struct nvgre_softc *elm) { return _rb_right(nvgre_ucast_tree_RBT_TYPE
, elm); } __attribute__((__unused__)) static inline struct nvgre_softc
* nvgre_ucast_tree_RBT_PARENT(struct nvgre_softc *elm) { return
_rb_parent(nvgre_ucast_tree_RBT_TYPE, elm); } __attribute__(
(__unused__)) static inline void nvgre_ucast_tree_RBT_SET_LEFT
(struct nvgre_softc *elm, struct nvgre_softc *left) { _rb_set_left
(nvgre_ucast_tree_RBT_TYPE, elm, left); } __attribute__((__unused__
)) static inline void nvgre_ucast_tree_RBT_SET_RIGHT(struct nvgre_softc
*elm, struct nvgre_softc *right) { _rb_set_right(nvgre_ucast_tree_RBT_TYPE
, elm, right); } __attribute__((__unused__)) static inline void
nvgre_ucast_tree_RBT_SET_PARENT(struct nvgre_softc *elm, struct
nvgre_softc *parent) { _rb_set_parent(nvgre_ucast_tree_RBT_TYPE
, elm, parent); } __attribute__((__unused__)) static inline void
nvgre_ucast_tree_RBT_POISON(struct nvgre_softc *elm, unsigned
long poison) { _rb_poison(nvgre_ucast_tree_RBT_TYPE, elm, poison
); } __attribute__((__unused__)) static inline int nvgre_ucast_tree_RBT_CHECK
(struct nvgre_softc *elm, unsigned long poison) { return _rb_check
(nvgre_ucast_tree_RBT_TYPE, elm, poison); };
433RBT_PROTOTYPE(nvgre_mcast_tree, nvgre_softc, sc_mentry, nvgre_cmp_mcast_sc)extern const struct rb_type *const nvgre_mcast_tree_RBT_TYPE;
__attribute__((__unused__)) static inline void nvgre_mcast_tree_RBT_INIT
(struct nvgre_mcast_tree *head) { _rb_init(&head->rbh_root
); } __attribute__((__unused__)) static inline struct nvgre_softc
* nvgre_mcast_tree_RBT_INSERT(struct nvgre_mcast_tree *head,
struct nvgre_softc *elm) { return _rb_insert(nvgre_mcast_tree_RBT_TYPE
, &head->rbh_root, elm); } __attribute__((__unused__))
static inline struct nvgre_softc * nvgre_mcast_tree_RBT_REMOVE
(struct nvgre_mcast_tree *head, struct nvgre_softc *elm) { return
_rb_remove(nvgre_mcast_tree_RBT_TYPE, &head->rbh_root
, elm); } __attribute__((__unused__)) static inline struct nvgre_softc
* nvgre_mcast_tree_RBT_FIND(struct nvgre_mcast_tree *head, const
struct nvgre_softc *key) { return _rb_find(nvgre_mcast_tree_RBT_TYPE
, &head->rbh_root, key); } __attribute__((__unused__))
static inline struct nvgre_softc * nvgre_mcast_tree_RBT_NFIND
(struct nvgre_mcast_tree *head, const struct nvgre_softc *key
) { return _rb_nfind(nvgre_mcast_tree_RBT_TYPE, &head->
rbh_root, key); } __attribute__((__unused__)) static inline struct
nvgre_softc * nvgre_mcast_tree_RBT_ROOT(struct nvgre_mcast_tree
*head) { return _rb_root(nvgre_mcast_tree_RBT_TYPE, &head
->rbh_root); } __attribute__((__unused__)) static inline int
nvgre_mcast_tree_RBT_EMPTY(struct nvgre_mcast_tree *head) { return
_rb_empty(&head->rbh_root); } __attribute__((__unused__
)) static inline struct nvgre_softc * nvgre_mcast_tree_RBT_MIN
(struct nvgre_mcast_tree *head) { return _rb_min(nvgre_mcast_tree_RBT_TYPE
, &head->rbh_root); } __attribute__((__unused__)) static
inline struct nvgre_softc * nvgre_mcast_tree_RBT_MAX(struct nvgre_mcast_tree
*head) { return _rb_max(nvgre_mcast_tree_RBT_TYPE, &head
->rbh_root); } __attribute__((__unused__)) static inline struct
nvgre_softc * nvgre_mcast_tree_RBT_NEXT(struct nvgre_softc *
elm) { return _rb_next(nvgre_mcast_tree_RBT_TYPE, elm); } __attribute__
((__unused__)) static inline struct nvgre_softc * nvgre_mcast_tree_RBT_PREV
(struct nvgre_softc *elm) { return _rb_prev(nvgre_mcast_tree_RBT_TYPE
, elm); } __attribute__((__unused__)) static inline struct nvgre_softc
* nvgre_mcast_tree_RBT_LEFT(struct nvgre_softc *elm) { return
_rb_left(nvgre_mcast_tree_RBT_TYPE, elm); } __attribute__((__unused__
)) static inline struct nvgre_softc * nvgre_mcast_tree_RBT_RIGHT
(struct nvgre_softc *elm) { return _rb_right(nvgre_mcast_tree_RBT_TYPE
, elm); } __attribute__((__unused__)) static inline struct nvgre_softc
* nvgre_mcast_tree_RBT_PARENT(struct nvgre_softc *elm) { return
_rb_parent(nvgre_mcast_tree_RBT_TYPE, elm); } __attribute__(
(__unused__)) static inline void nvgre_mcast_tree_RBT_SET_LEFT
(struct nvgre_softc *elm, struct nvgre_softc *left) { _rb_set_left
(nvgre_mcast_tree_RBT_TYPE, elm, left); } __attribute__((__unused__
)) static inline void nvgre_mcast_tree_RBT_SET_RIGHT(struct nvgre_softc
*elm, struct nvgre_softc *right) { _rb_set_right(nvgre_mcast_tree_RBT_TYPE
, elm, right); } __attribute__((__unused__)) static inline void
nvgre_mcast_tree_RBT_SET_PARENT(struct nvgre_softc *elm, struct
nvgre_softc *parent) { _rb_set_parent(nvgre_mcast_tree_RBT_TYPE
, elm, parent); } __attribute__((__unused__)) static inline void
nvgre_mcast_tree_RBT_POISON(struct nvgre_softc *elm, unsigned
long poison) { _rb_poison(nvgre_mcast_tree_RBT_TYPE, elm, poison
); } __attribute__((__unused__)) static inline int nvgre_mcast_tree_RBT_CHECK
(struct nvgre_softc *elm, unsigned long poison) { return _rb_check
(nvgre_mcast_tree_RBT_TYPE, elm, poison); };
434
435static int nvgre_clone_create(struct if_clone *, int);
436static int nvgre_clone_destroy(struct ifnet *);
437
438static void nvgre_start(struct ifnet *);
439static int nvgre_ioctl(struct ifnet *, u_long, caddr_t);
440
441static int nvgre_up(struct nvgre_softc *);
442static int nvgre_down(struct nvgre_softc *);
443static int nvgre_set_parent(struct nvgre_softc *, const char *);
444static void nvgre_link_change(void *);
445static void nvgre_detach(void *);
446
447static int nvgre_input(const struct gre_tunnel *, struct mbuf *, int,
448 uint8_t);
449static void nvgre_send(void *);
450
451static int nvgre_add_addr(struct nvgre_softc *, const struct ifbareq *);
452static int nvgre_del_addr(struct nvgre_softc *, const struct ifbareq *);
453
454static int nvgre_eb_port_eq(void *, void *, void *);
455static void *nvgre_eb_port_take(void *, void *);
456static void nvgre_eb_port_rele(void *, void *);
457static size_t nvgre_eb_port_ifname(void *, char *, size_t, void *);
458static void nvgre_eb_port_sa(void *, struct sockaddr_storage *, void *);
459
460static const struct etherbridge_ops nvgre_etherbridge_ops = {
461 nvgre_eb_port_eq,
462 nvgre_eb_port_take,
463 nvgre_eb_port_rele,
464 nvgre_eb_port_ifname,
465 nvgre_eb_port_sa,
466};
467
468struct if_clone nvgre_cloner =
469 IF_CLONE_INITIALIZER("nvgre", nvgre_clone_create, nvgre_clone_destroy){ .ifc_list = { ((void *)0), ((void *)0) }, .ifc_name = "nvgre"
, .ifc_namelen = sizeof("nvgre") - 1, .ifc_create = nvgre_clone_create
, .ifc_destroy = nvgre_clone_destroy, };
470
471struct pool nvgre_endpoint_pool;
472
473/* protected by NET_LOCK */
474struct nvgre_ucast_tree nvgre_ucast_tree = RBT_INITIALIZER(){ { ((void *)0) } };
475struct nvgre_mcast_tree nvgre_mcast_tree = RBT_INITIALIZER(){ { ((void *)0) } };
476
477/*
478 * MikroTik Ethernet over IP protocol (eoip)
479 */
480
481struct eoip_softc {
482 struct gre_tunnel sc_tunnel; /* must be first */
483 uint16_t sc_tunnel_id;
484 RBT_ENTRY(eoip_softc)struct rb_entry sc_entry;
485
486 struct arpcom sc_ac;
487 struct ifmedia sc_media;
488
489 struct timeout sc_ka_send;
490 struct timeout sc_ka_hold;
491
492 unsigned int sc_ka_state;
493 unsigned int sc_ka_timeo;
494 unsigned int sc_ka_count;
495
496 unsigned int sc_ka_holdmax;
497 unsigned int sc_ka_holdcnt;
498};
499
500RBT_HEAD(eoip_tree, eoip_softc)struct eoip_tree { struct rb_tree rbh_root; };
501
502static inline int
503 eoip_cmp(const struct eoip_softc *, const struct eoip_softc *);
504
505RBT_PROTOTYPE(eoip_tree, eoip_softc, sc_entry, eoip_cmp)extern const struct rb_type *const eoip_tree_RBT_TYPE; __attribute__
((__unused__)) static inline void eoip_tree_RBT_INIT(struct eoip_tree
*head) { _rb_init(&head->rbh_root); } __attribute__((
__unused__)) static inline struct eoip_softc * eoip_tree_RBT_INSERT
(struct eoip_tree *head, struct eoip_softc *elm) { return _rb_insert
(eoip_tree_RBT_TYPE, &head->rbh_root, elm); } __attribute__
((__unused__)) static inline struct eoip_softc * eoip_tree_RBT_REMOVE
(struct eoip_tree *head, struct eoip_softc *elm) { return _rb_remove
(eoip_tree_RBT_TYPE, &head->rbh_root, elm); } __attribute__
((__unused__)) static inline struct eoip_softc * eoip_tree_RBT_FIND
(struct eoip_tree *head, const struct eoip_softc *key) { return
_rb_find(eoip_tree_RBT_TYPE, &head->rbh_root, key); }
__attribute__((__unused__)) static inline struct eoip_softc *
eoip_tree_RBT_NFIND(struct eoip_tree *head, const struct eoip_softc
*key) { return _rb_nfind(eoip_tree_RBT_TYPE, &head->rbh_root
, key); } __attribute__((__unused__)) static inline struct eoip_softc
* eoip_tree_RBT_ROOT(struct eoip_tree *head) { return _rb_root
(eoip_tree_RBT_TYPE, &head->rbh_root); } __attribute__
((__unused__)) static inline int eoip_tree_RBT_EMPTY(struct eoip_tree
*head) { return _rb_empty(&head->rbh_root); } __attribute__
((__unused__)) static inline struct eoip_softc * eoip_tree_RBT_MIN
(struct eoip_tree *head) { return _rb_min(eoip_tree_RBT_TYPE,
&head->rbh_root); } __attribute__((__unused__)) static
inline struct eoip_softc * eoip_tree_RBT_MAX(struct eoip_tree
*head) { return _rb_max(eoip_tree_RBT_TYPE, &head->rbh_root
); } __attribute__((__unused__)) static inline struct eoip_softc
* eoip_tree_RBT_NEXT(struct eoip_softc *elm) { return _rb_next
(eoip_tree_RBT_TYPE, elm); } __attribute__((__unused__)) static
inline struct eoip_softc * eoip_tree_RBT_PREV(struct eoip_softc
*elm) { return _rb_prev(eoip_tree_RBT_TYPE, elm); } __attribute__
((__unused__)) static inline struct eoip_softc * eoip_tree_RBT_LEFT
(struct eoip_softc *elm) { return _rb_left(eoip_tree_RBT_TYPE
, elm); } __attribute__((__unused__)) static inline struct eoip_softc
* eoip_tree_RBT_RIGHT(struct eoip_softc *elm) { return _rb_right
(eoip_tree_RBT_TYPE, elm); } __attribute__((__unused__)) static
inline struct eoip_softc * eoip_tree_RBT_PARENT(struct eoip_softc
*elm) { return _rb_parent(eoip_tree_RBT_TYPE, elm); } __attribute__
((__unused__)) static inline void eoip_tree_RBT_SET_LEFT(struct
eoip_softc *elm, struct eoip_softc *left) { _rb_set_left(eoip_tree_RBT_TYPE
, elm, left); } __attribute__((__unused__)) static inline void
eoip_tree_RBT_SET_RIGHT(struct eoip_softc *elm, struct eoip_softc
*right) { _rb_set_right(eoip_tree_RBT_TYPE, elm, right); } __attribute__
((__unused__)) static inline void eoip_tree_RBT_SET_PARENT(struct
eoip_softc *elm, struct eoip_softc *parent) { _rb_set_parent
(eoip_tree_RBT_TYPE, elm, parent); } __attribute__((__unused__
)) static inline void eoip_tree_RBT_POISON(struct eoip_softc *
elm, unsigned long poison) { _rb_poison(eoip_tree_RBT_TYPE, elm
, poison); } __attribute__((__unused__)) static inline int eoip_tree_RBT_CHECK
(struct eoip_softc *elm, unsigned long poison) { return _rb_check
(eoip_tree_RBT_TYPE, elm, poison); };
506
507static int eoip_clone_create(struct if_clone *, int);
508static int eoip_clone_destroy(struct ifnet *);
509
510static void eoip_start(struct ifnet *);
511static int eoip_ioctl(struct ifnet *, u_long, caddr_t);
512
513static void eoip_keepalive_send(void *);
514static void eoip_keepalive_recv(struct eoip_softc *);
515static void eoip_keepalive_hold(void *);
516
517static int eoip_up(struct eoip_softc *);
518static int eoip_down(struct eoip_softc *);
519
520static struct mbuf *
521 eoip_encap(struct eoip_softc *, struct mbuf *, uint8_t);
522
523static struct mbuf *
524 eoip_input(struct gre_tunnel *, struct mbuf *,
525 const struct gre_header *, uint8_t, int);
526struct if_clone eoip_cloner =
527 IF_CLONE_INITIALIZER("eoip", eoip_clone_create, eoip_clone_destroy){ .ifc_list = { ((void *)0), ((void *)0) }, .ifc_name = "eoip"
, .ifc_namelen = sizeof("eoip") - 1, .ifc_create = eoip_clone_create
, .ifc_destroy = eoip_clone_destroy, };
528
529/* protected by NET_LOCK */
530struct eoip_tree eoip_tree = RBT_INITIALIZER(){ { ((void *)0) } };
531
532/*
533 * It is not easy to calculate the right value for a GRE MTU.
534 * We leave this task to the admin and use the same default that
535 * other vendors use.
536 */
537#define GREMTU1476 1476
538
539/*
540 * We can control the acceptance of GRE and MobileIP packets by
541 * altering the sysctl net.inet.gre.allow values
542 * respectively. Zero means drop them, all else is acceptance. We can also
543 * control acceptance of WCCPv1-style GRE packets through the
544 * net.inet.gre.wccp value, but be aware it depends upon normal GRE being
545 * allowed as well.
546 *
547 */
548int gre_allow = 0;
549int gre_wccp = 0;
550
551void
552greattach(int n)
553{
554 if_clone_attach(&gre_cloner);
555 if_clone_attach(&mgre_cloner);
556 if_clone_attach(&egre_cloner);
557 if_clone_attach(&nvgre_cloner);
558 if_clone_attach(&eoip_cloner);
559}
560
561static int
562gre_clone_create(struct if_clone *ifc, int unit)
563{
564 struct gre_softc *sc;
565 struct ifnet *ifp;
566
567 sc = malloc(sizeof(*sc), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);
568 snprintf(sc->sc_if.if_xname, sizeof sc->sc_if.if_xname, "%s%d",
569 ifc->ifc_name, unit);
570
571 ifp = &sc->sc_if;
572 ifp->if_softc = sc;
573 ifp->if_typeif_data.ifi_type = IFT_TUNNEL0x83;
574 ifp->if_hdrlenif_data.ifi_hdrlen = GRE_HDRLEN(sizeof(struct ip) + sizeof(struct gre_header));
575 ifp->if_mtuif_data.ifi_mtu = GREMTU1476;
576 ifp->if_flags = IFF_POINTOPOINT0x10|IFF_MULTICAST0x8000;
577 ifp->if_xflags = IFXF_CLONED0x2;
578 ifp->if_bpf_mtap = p2p_bpf_mtap;
579 ifp->if_input = p2p_input;
580 ifp->if_output = gre_output;
581 ifp->if_start = gre_start;
582 ifp->if_ioctl = gre_ioctl;
583 ifp->if_rtrequest = p2p_rtrequest;
584
585 sc->sc_tunnel.t_ttl = ip_defttl;
586 sc->sc_tunnel.t_txhprio = IF_HDRPRIO_PAYLOAD-2;
587 sc->sc_tunnel.t_rxhprio = IF_HDRPRIO_PACKET-1;
588 sc->sc_tunnel.t_df = htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0));
589 sc->sc_tunnel.t_ecn = ECN_ALLOWED1;
590
591 timeout_set(&sc->sc_ka_send, gre_keepalive_send, sc);
592 timeout_set_proc(&sc->sc_ka_hold, gre_keepalive_hold, sc);
593 sc->sc_ka_state = GRE_KA_NONE0;
594
595 if_counters_alloc(ifp);
596 if_attach(ifp);
597 if_alloc_sadl(ifp);
598
599#if NBPFILTER1 > 0
600 bpfattach(&ifp->if_bpf, ifp, DLT_LOOP12, sizeof(uint32_t));
601#endif
602
603 ifp->if_llprio = IFQ_TOS2PRIO(IPTOS_PREC_INTERNETCONTROL)((0xc0) >> 5);
604
605 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
606 TAILQ_INSERT_TAIL(&gre_list, sc, sc_entry)do { (sc)->sc_entry.tqe_next = ((void *)0); (sc)->sc_entry
.tqe_prev = (&gre_list)->tqh_last; *(&gre_list)->
tqh_last = (sc); (&gre_list)->tqh_last = &(sc)->
sc_entry.tqe_next; } while (0);
607 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
608
609 return (0);
610}
611
612static int
613gre_clone_destroy(struct ifnet *ifp)
614{
615 struct gre_softc *sc = ifp->if_softc;
616
617 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
618 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
619 gre_down(sc);
620
621 TAILQ_REMOVE(&gre_list, sc, sc_entry)do { if (((sc)->sc_entry.tqe_next) != ((void *)0)) (sc)->
sc_entry.tqe_next->sc_entry.tqe_prev = (sc)->sc_entry.tqe_prev
; else (&gre_list)->tqh_last = (sc)->sc_entry.tqe_prev
; *(sc)->sc_entry.tqe_prev = (sc)->sc_entry.tqe_next; (
(sc)->sc_entry.tqe_prev) = ((void *)-1); ((sc)->sc_entry
.tqe_next) = ((void *)-1); } while (0);
622 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
623
624 if_detach(ifp);
625
626 free(sc, M_DEVBUF2, sizeof(*sc));
627
628 return (0);
629}
630
631static int
632mgre_clone_create(struct if_clone *ifc, int unit)
633{
634 struct mgre_softc *sc;
635 struct ifnet *ifp;
636
637 sc = malloc(sizeof(*sc), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);
638 ifp = &sc->sc_if;
639
640 snprintf(ifp->if_xname, sizeof(ifp->if_xname),
641 "%s%d", ifc->ifc_name, unit);
642
643 ifp->if_softc = sc;
644 ifp->if_typeif_data.ifi_type = IFT_L3IPVLAN0x88;
645 ifp->if_hdrlenif_data.ifi_hdrlen = GRE_HDRLEN(sizeof(struct ip) + sizeof(struct gre_header));
646 ifp->if_mtuif_data.ifi_mtu = GREMTU1476;
647 ifp->if_flags = IFF_MULTICAST0x8000|IFF_SIMPLEX0x800;
648 ifp->if_xflags = IFXF_CLONED0x2;
649 ifp->if_bpf_mtap = p2p_bpf_mtap;
650 ifp->if_input = p2p_input;
651 ifp->if_rtrequest = mgre_rtrequest;
652 ifp->if_output = mgre_output;
653 ifp->if_start = mgre_start;
654 ifp->if_ioctl = mgre_ioctl;
655
656 sc->sc_tunnel.t_ttl = ip_defttl;
657 sc->sc_tunnel.t_txhprio = IF_HDRPRIO_PAYLOAD-2;
658 sc->sc_tunnel.t_rxhprio = IF_HDRPRIO_PACKET-1;
659 sc->sc_tunnel.t_df = htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0));
660 sc->sc_tunnel.t_ecn = ECN_ALLOWED1;
661
662 if_counters_alloc(ifp);
663 if_attach(ifp);
664 if_alloc_sadl(ifp);
665
666#if NBPFILTER1 > 0
667 bpfattach(&ifp->if_bpf, ifp, DLT_LOOP12, sizeof(uint32_t));
668#endif
669
670 return (0);
671}
672
673static int
674mgre_clone_destroy(struct ifnet *ifp)
675{
676 struct mgre_softc *sc = ifp->if_softc;
677
678 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
679 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
680 mgre_down(sc);
681 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
682
683 if_detach(ifp);
684
685 free(sc, M_DEVBUF2, sizeof(*sc));
686
687 return (0);
688}
689
690static int
691egre_clone_create(struct if_clone *ifc, int unit)
692{
693 struct egre_softc *sc;
694 struct ifnet *ifp;
695
696 sc = malloc(sizeof(*sc), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);
697 ifp = &sc->sc_ac.ac_if;
698
699 snprintf(ifp->if_xname, sizeof(ifp->if_xname), "%s%d",
700 ifc->ifc_name, unit);
701
702 ifp->if_softc = sc;
703 ifp->if_hardmtu = ETHER_MAX_HARDMTU_LEN65435;
704 ifp->if_ioctl = egre_ioctl;
705 ifp->if_start = egre_start;
706 ifp->if_xflags = IFXF_CLONED0x2;
707 ifp->if_flags = IFF_BROADCAST0x2 | IFF_SIMPLEX0x800 | IFF_MULTICAST0x8000;
708 ether_fakeaddr(ifp);
709
710 sc->sc_tunnel.t_ttl = ip_defttl;
711 sc->sc_tunnel.t_txhprio = 0;
712 sc->sc_tunnel.t_rxhprio = IF_HDRPRIO_PACKET-1;
713 sc->sc_tunnel.t_df = htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0));
714
715 ifmedia_init(&sc->sc_media, 0, egre_media_change, egre_media_status);
716 ifmedia_add(&sc->sc_media, IFM_ETHER0x0000000000000100ULL | IFM_AUTO0ULL, 0, NULL((void *)0));
717 ifmedia_set(&sc->sc_media, IFM_ETHER0x0000000000000100ULL | IFM_AUTO0ULL);
718
719 if_counters_alloc(ifp);
720 if_attach(ifp);
721 ether_ifattach(ifp);
722
723 return (0);
724}
725
726static int
727egre_clone_destroy(struct ifnet *ifp)
728{
729 struct egre_softc *sc = ifp->if_softc;
730
731 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
732 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
733 egre_down(sc);
734 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
735
736 ifmedia_delete_instance(&sc->sc_media, IFM_INST_ANY((uint64_t) -1));
737 ether_ifdetach(ifp);
738 if_detach(ifp);
739
740 free(sc, M_DEVBUF2, sizeof(*sc));
741
742 return (0);
743}
744
745static int
746nvgre_clone_create(struct if_clone *ifc, int unit)
747{
748 struct nvgre_softc *sc;
749 struct ifnet *ifp;
750 struct gre_tunnel *tunnel;
751 int error;
752
753 if (nvgre_endpoint_pool.pr_size == 0) {
754 pool_init(&nvgre_endpoint_pool, sizeof(union gre_addr),
755 0, IPL_SOFTNET0x2, 0, "nvgreep", NULL((void *)0));
756 }
757
758 sc = malloc(sizeof(*sc), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);
759 ifp = &sc->sc_ac.ac_if;
760
761 snprintf(ifp->if_xname, sizeof(ifp->if_xname), "%s%d",
762 ifc->ifc_name, unit);
763
764 error = etherbridge_init(&sc->sc_eb, ifp->if_xname,
765 &nvgre_etherbridge_ops, sc);
766 if (error != 0) {
767 free(sc, M_DEVBUF2, sizeof(*sc));
768 return (error);
769 }
770
771 ifp->if_softc = sc;
772 ifp->if_hardmtu = ETHER_MAX_HARDMTU_LEN65435;
773 ifp->if_ioctl = nvgre_ioctl;
774 ifp->if_start = nvgre_start;
775 ifp->if_xflags = IFXF_CLONED0x2;
776 ifp->if_flags = IFF_BROADCAST0x2 | IFF_SIMPLEX0x800 | IFF_MULTICAST0x8000;
777 ether_fakeaddr(ifp);
778
779 tunnel = &sc->sc_tunnel;
780 tunnel->t_ttl = IP_DEFAULT_MULTICAST_TTL1;
781 tunnel->t_txhprio = 0;
782 sc->sc_tunnel.t_rxhprio = IF_HDRPRIO_PACKET-1;
783 tunnel->t_df = htons(IP_DF)(__uint16_t)(__builtin_constant_p(0x4000) ? (__uint16_t)(((__uint16_t
)(0x4000) & 0xffU) << 8 | ((__uint16_t)(0x4000) &
0xff00U) >> 8) : __swap16md(0x4000));
784 tunnel->t_key_mask = GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
785 tunnel->t_key = htonl((NVGRE_VSID_RES_MAX + 1) <<(__uint32_t)(__builtin_constant_p((0x000fff + 1) << 8) ?
(__uint32_t)(((__uint32_t)((0x000fff + 1) << 8) & 0xff
) << 24 | ((__uint32_t)((0x000fff + 1) << 8) &
0xff00) << 8 | ((__uint32_t)((0x000fff + 1) << 8
) & 0xff0000) >> 8 | ((__uint32_t)((0x000fff + 1) <<
8) & 0xff000000) >> 24) : __swap32md((0x000fff + 1
) << 8))
786 GRE_KEY_ENTROPY_SHIFT)(__uint32_t)(__builtin_constant_p((0x000fff + 1) << 8) ?
(__uint32_t)(((__uint32_t)((0x000fff + 1) << 8) & 0xff
) << 24 | ((__uint32_t)((0x000fff + 1) << 8) &
0xff00) << 8 | ((__uint32_t)((0x000fff + 1) << 8
) & 0xff0000) >> 8 | ((__uint32_t)((0x000fff + 1) <<
8) & 0xff000000) >> 24) : __swap32md((0x000fff + 1
) << 8));
787
788 mq_init(&sc->sc_send_list, IFQ_MAXLEN256 * 2, IPL_SOFTNET0x2);
789 task_set(&sc->sc_send_task, nvgre_send, sc);
790 task_set(&sc->sc_ltask, nvgre_link_change, sc);
791 task_set(&sc->sc_dtask, nvgre_detach, sc);
792
793 ifmedia_init(&sc->sc_media, 0, egre_media_change, egre_media_status);
794 ifmedia_add(&sc->sc_media, IFM_ETHER0x0000000000000100ULL | IFM_AUTO0ULL, 0, NULL((void *)0));
795 ifmedia_set(&sc->sc_media, IFM_ETHER0x0000000000000100ULL | IFM_AUTO0ULL);
796
797 if_counters_alloc(ifp);
798 if_attach(ifp);
799 ether_ifattach(ifp);
800
801 return (0);
802}
803
804static int
805nvgre_clone_destroy(struct ifnet *ifp)
806{
807 struct nvgre_softc *sc = ifp->if_softc;
808
809 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
810 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
811 nvgre_down(sc);
812 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
813
814 etherbridge_destroy(&sc->sc_eb);
815
816 ifmedia_delete_instance(&sc->sc_media, IFM_INST_ANY((uint64_t) -1));
817 ether_ifdetach(ifp);
818 if_detach(ifp);
819
820 free(sc, M_DEVBUF2, sizeof(*sc));
821
822 return (0);
823}
824
825static int
826eoip_clone_create(struct if_clone *ifc, int unit)
827{
828 struct eoip_softc *sc;
829 struct ifnet *ifp;
830
831 sc = malloc(sizeof(*sc), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008);
832 ifp = &sc->sc_ac.ac_if;
833
834 snprintf(ifp->if_xname, sizeof(ifp->if_xname), "%s%d",
835 ifc->ifc_name, unit);
836
837 ifp->if_softc = sc;
838 ifp->if_hardmtu = ETHER_MAX_HARDMTU_LEN65435;
839 ifp->if_ioctl = eoip_ioctl;
840 ifp->if_start = eoip_start;
841 ifp->if_xflags = IFXF_CLONED0x2;
842 ifp->if_flags = IFF_BROADCAST0x2 | IFF_SIMPLEX0x800 | IFF_MULTICAST0x8000;
843 ether_fakeaddr(ifp);
844
845 sc->sc_tunnel.t_ttl = ip_defttl;
846 sc->sc_tunnel.t_txhprio = 0;
847 sc->sc_tunnel.t_rxhprio = IF_HDRPRIO_PACKET-1;
848 sc->sc_tunnel.t_df = htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0));
849
850 sc->sc_ka_timeo = 10;
851 sc->sc_ka_count = 10;
852
853 timeout_set(&sc->sc_ka_send, eoip_keepalive_send, sc);
854 timeout_set_proc(&sc->sc_ka_hold, eoip_keepalive_hold, sc);
855 sc->sc_ka_state = GRE_KA_DOWN1;
856
857 ifmedia_init(&sc->sc_media, 0, egre_media_change, egre_media_status);
858 ifmedia_add(&sc->sc_media, IFM_ETHER0x0000000000000100ULL | IFM_AUTO0ULL, 0, NULL((void *)0));
859 ifmedia_set(&sc->sc_media, IFM_ETHER0x0000000000000100ULL | IFM_AUTO0ULL);
860
861 if_counters_alloc(ifp);
862 if_attach(ifp);
863 ether_ifattach(ifp);
864
865 return (0);
866}
867
868static int
869eoip_clone_destroy(struct ifnet *ifp)
870{
871 struct eoip_softc *sc = ifp->if_softc;
872
873 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
874 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
875 eoip_down(sc);
876 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
877
878 ifmedia_delete_instance(&sc->sc_media, IFM_INST_ANY((uint64_t) -1));
879 ether_ifdetach(ifp);
880 if_detach(ifp);
881
882 free(sc, M_DEVBUF2, sizeof(*sc));
883
884 return (0);
885}
886
887int
888gre_input(struct mbuf **mp, int *offp, int type, int af)
889{
890 struct mbuf *m = *mp;
891 struct gre_tunnel key;
892 struct ip *ip;
893
894 ip = mtod(m, struct ip *)((struct ip *)((m)->m_hdr.mh_data));
895
896 /* XXX check if ip_src is sane for nvgre? */
897
898 key.t_af = AF_INET2;
899 key.t_src4t_src.in4 = ip->ip_dst;
900 key.t_dst4t_dst.in4 = ip->ip_src;
901
902 if (gre_input_key(mp, offp, type, af, ip->ip_tos, &key) == -1)
903 return (rip_input(mp, offp, type, af));
904
905 return (IPPROTO_DONE257);
906}
907
908#ifdef INET61
909int
910gre_input6(struct mbuf **mp, int *offp, int type, int af)
911{
912 struct mbuf *m = *mp;
913 struct gre_tunnel key;
914 struct ip6_hdr *ip6;
915 uint32_t flow;
916
917 ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
918
919 /* XXX check if ip6_src is sane for nvgre? */
920
921 key.t_af = AF_INET624;
922 key.t_src6t_src.in6 = ip6->ip6_dst;
923 key.t_dst6t_dst.in6 = ip6->ip6_src;
924
925 flow = bemtoh32(&ip6->ip6_flow)(__uint32_t)(__builtin_constant_p(*(__uint32_t *)(&ip6->
ip6_ctlun.ip6_un1.ip6_un1_flow)) ? (__uint32_t)(((__uint32_t)
(*(__uint32_t *)(&ip6->ip6_ctlun.ip6_un1.ip6_un1_flow)
) & 0xff) << 24 | ((__uint32_t)(*(__uint32_t *)(&
ip6->ip6_ctlun.ip6_un1.ip6_un1_flow)) & 0xff00) <<
8 | ((__uint32_t)(*(__uint32_t *)(&ip6->ip6_ctlun.ip6_un1
.ip6_un1_flow)) & 0xff0000) >> 8 | ((__uint32_t)(*(
__uint32_t *)(&ip6->ip6_ctlun.ip6_un1.ip6_un1_flow)) &
0xff000000) >> 24) : __swap32md(*(__uint32_t *)(&ip6
->ip6_ctlun.ip6_un1.ip6_un1_flow)));
926
927 if (gre_input_key(mp, offp, type, af, flow >> 20, &key) == -1)
928 return (rip6_input(mp, offp, type, af));
929
930 return (IPPROTO_DONE257);
931}
932#endif /* INET6 */
933
934static inline struct ifnet *
935gre_find(const struct gre_tunnel *key)
936{
937 struct gre_softc *sc;
938
939 TAILQ_FOREACH(sc, &gre_list, sc_entry)for((sc) = ((&gre_list)->tqh_first); (sc) != ((void *)
0); (sc) = ((sc)->sc_entry.tqe_next)) {
940 if (gre_cmp(key, &sc->sc_tunnel) != 0)
941 continue;
942
943 if (!ISSET(sc->sc_if.if_flags, IFF_RUNNING)((sc->sc_if.if_flags) & (0x40)))
944 continue;
945
946 return (&sc->sc_if);
947 }
948
949 return (NULL((void *)0));
950}
951
952static inline struct ifnet *
953mgre_find(const struct gre_tunnel *key)
954{
955 struct mgre_softc *sc;
956
957 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
958 sc = RBT_FIND(mgre_tree, &mgre_tree, (const struct mgre_softc *)key)mgre_tree_RBT_FIND(&mgre_tree, (const struct mgre_softc *
)key);
959 if (sc != NULL((void *)0))
960 return (&sc->sc_if);
961
962 return (NULL((void *)0));
963}
964
965static struct mbuf *
966gre_input_1(struct gre_tunnel *key, struct mbuf *m,
967 const struct gre_header *gh, uint8_t otos, int iphlen)
968{
969 switch (gh->gre_proto) {
970 case htons(ETHERTYPE_PPP)(__uint16_t)(__builtin_constant_p(0x880B) ? (__uint16_t)(((__uint16_t
)(0x880B) & 0xffU) << 8 | ((__uint16_t)(0x880B) &
0xff00U) >> 8) : __swap16md(0x880B)):
971#ifdef PIPEX1
972 if (pipex_enable) {
973 struct pipex_session *session;
974
975 session = pipex_pptp_lookup_session(m);
976 if (session != NULL((void *)0)) {
977 struct mbuf *m0;
978
979 m0 = pipex_pptp_input(m, session);
980 pipex_rele_session(session);
981
982 if (m0 == NULL((void *)0))
983 return (NULL((void *)0));
984 }
985 }
986#endif
987 break;
988 case htons(GRE_EOIP)(__uint16_t)(__builtin_constant_p(0x6400) ? (__uint16_t)(((__uint16_t
)(0x6400) & 0xffU) << 8 | ((__uint16_t)(0x6400) &
0xff00U) >> 8) : __swap16md(0x6400)):
989 return (eoip_input(key, m, gh, otos, iphlen));
990 break;
991 }
992
993 return (m);
994}
995
996static int
997gre_input_key(struct mbuf **mp, int *offp, int type, int af, uint8_t otos,
998 struct gre_tunnel *key)
999{
1000 struct mbuf *m = *mp;
1001 int iphlen = *offp, hlen, rxprio;
1002 struct ifnet *ifp;
1003 const struct gre_tunnel *tunnel;
1004 caddr_t buf;
1005 struct gre_header *gh;
1006 struct gre_h_key *gkh;
1007 struct mbuf *(*patch)(const struct gre_tunnel *, struct mbuf *,
1008 uint8_t *, uint8_t);
1009 int mcast = 0;
1010 uint8_t itos;
1011
1012 if (!gre_allow)
1013 goto decline;
1014
1015 key->t_rtableid = m->m_pkthdrM_dat.MH.MH_pkthdr.ph_rtableid;
1016
1017 hlen = iphlen + sizeof(*gh);
1018 if (m->m_pkthdrM_dat.MH.MH_pkthdr.len < hlen)
1019 goto decline;
1020
1021 m = m_pullup(m, hlen);
1022 if (m == NULL((void *)0))
1023 return (IPPROTO_DONE257);
1024
1025 buf = mtod(m, caddr_t)((caddr_t)((m)->m_hdr.mh_data));
1026 gh = (struct gre_header *)(buf + iphlen);
1027
1028 /* check the version */
1029 switch (gh->gre_flags & htons(GRE_VERS_MASK)(__uint16_t)(__builtin_constant_p(0x0007) ? (__uint16_t)(((__uint16_t
)(0x0007) & 0xffU) << 8 | ((__uint16_t)(0x0007) &
0xff00U) >> 8) : __swap16md(0x0007))) {
1030 case htons(GRE_VERS_0)(__uint16_t)(__builtin_constant_p(0x0000) ? (__uint16_t)(((__uint16_t
)(0x0000) & 0xffU) << 8 | ((__uint16_t)(0x0000) &
0xff00U) >> 8) : __swap16md(0x0000)):
1031 break;
1032
1033 case htons(GRE_VERS_1)(__uint16_t)(__builtin_constant_p(0x0001) ? (__uint16_t)(((__uint16_t
)(0x0001) & 0xffU) << 8 | ((__uint16_t)(0x0001) &
0xff00U) >> 8) : __swap16md(0x0001)):
1034 m = gre_input_1(key, m, gh, otos, iphlen);
1035 if (m == NULL((void *)0))
1036 return (IPPROTO_DONE257);
1037 /* FALLTHROUGH */
1038 default:
1039 goto decline;
1040 }
1041
1042 /* the only optional bit in the header is K flag */
1043 if ((gh->gre_flags & htons(~(GRE_KP|GRE_VERS_MASK))(__uint16_t)(__builtin_constant_p(~(0x2000|0x0007)) ? (__uint16_t
)(((__uint16_t)(~(0x2000|0x0007)) & 0xffU) << 8 | (
(__uint16_t)(~(0x2000|0x0007)) & 0xff00U) >> 8) : __swap16md
(~(0x2000|0x0007)))) != htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0)))
1044 goto decline;
1045
1046 if (gh->gre_flags & htons(GRE_KP)(__uint16_t)(__builtin_constant_p(0x2000) ? (__uint16_t)(((__uint16_t
)(0x2000) & 0xffU) << 8 | ((__uint16_t)(0x2000) &
0xff00U) >> 8) : __swap16md(0x2000))) {
1047 hlen += sizeof(*gkh);
1048 if (m->m_pkthdrM_dat.MH.MH_pkthdr.len < hlen)
1049 goto decline;
1050
1051 m = m_pullup(m, hlen);
1052 if (m == NULL((void *)0))
1053 return (IPPROTO_DONE257);
1054
1055 buf = mtod(m, caddr_t)((caddr_t)((m)->m_hdr.mh_data));
1056 gh = (struct gre_header *)(buf + iphlen);
1057 gkh = (struct gre_h_key *)(gh + 1);
1058
1059 key->t_key_mask = GRE_KEY_MASK(__uint32_t)(__builtin_constant_p(0xffffffffU) ? (__uint32_t)
(((__uint32_t)(0xffffffffU) & 0xff) << 24 | ((__uint32_t
)(0xffffffffU) & 0xff00) << 8 | ((__uint32_t)(0xffffffffU
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffffffU) &
0xff000000) >> 24) : __swap32md(0xffffffffU));
1060 key->t_key = gkh->gre_key;
1061 } else
1062 key->t_key_mask = GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U));
1063
1064 if (gh->gre_proto == htons(ETHERTYPE_TRANSETHER)(__uint16_t)(__builtin_constant_p(0x6558) ? (__uint16_t)(((__uint16_t
)(0x6558) & 0xffU) << 8 | ((__uint16_t)(0x6558) &
0xff00U) >> 8) : __swap16md(0x6558))) {
1065 if (egre_input(key, m, hlen, otos) == -1 &&
1066 nvgre_input(key, m, hlen, otos) == -1)
1067 goto decline;
1068
1069 return (IPPROTO_DONE257);
1070 }
1071
1072 ifp = gre_find(key);
1073 if (ifp == NULL((void *)0)) {
1074 ifp = mgre_find(key);
1075 if (ifp == NULL((void *)0))
1076 goto decline;
1077 }
1078
1079 switch (gh->gre_proto) {
1080 case htons(GRE_WCCP)(__uint16_t)(__builtin_constant_p(0x883e) ? (__uint16_t)(((__uint16_t
)(0x883e) & 0xffU) << 8 | ((__uint16_t)(0x883e) &
0xff00U) >> 8) : __swap16md(0x883e)): {
1081 struct mbuf *n;
1082 int off;
1083
1084 /* WCCP/GRE:
1085 * So far as I can see (and test) it seems that Cisco's WCCP
1086 * GRE tunnel is precisely a IP-in-GRE tunnel that differs
1087 * only in its protocol number. At least, it works for me.
1088 *
1089 * The Internet Drafts can be found if you look for
1090 * the following:
1091 * draft-forster-wrec-wccp-v1-00.txt
1092 * draft-wilson-wrec-wccp-v2-01.txt
1093 */
1094
1095 if (!gre_wccp && !ISSET(ifp->if_flags, IFF_LINK0)((ifp->if_flags) & (0x1000)))
1096 goto decline;
1097
1098 /*
1099 * If the first nibble of the payload does not look like
1100 * IPv4, assume it is WCCP v2.
1101 */
1102 n = m_getptr(m, hlen, &off);
1103 if (n == NULL((void *)0))
1104 goto decline;
1105 if (n->m_datam_hdr.mh_data[off] >> 4 != IPVERSION4)
1106 hlen += 4; /* four-octet Redirect header */
1107
1108 /* FALLTHROUGH */
1109 }
1110 case htons(ETHERTYPE_IP)(__uint16_t)(__builtin_constant_p(0x0800) ? (__uint16_t)(((__uint16_t
)(0x0800) & 0xffU) << 8 | ((__uint16_t)(0x0800) &
0xff00U) >> 8) : __swap16md(0x0800)):
1111 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family = AF_INET2;
1112 patch = gre_ipv4_patch;
1113 break;
1114#ifdef INET61
1115 case htons(ETHERTYPE_IPV6)(__uint16_t)(__builtin_constant_p(0x86DD) ? (__uint16_t)(((__uint16_t
)(0x86DD) & 0xffU) << 8 | ((__uint16_t)(0x86DD) &
0xff00U) >> 8) : __swap16md(0x86DD)):
1116 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family = AF_INET624;
1117 patch = gre_ipv6_patch;
1118 break;
1119#endif
1120#ifdef MPLS1
1121 case htons(ETHERTYPE_MPLS_MCAST)(__uint16_t)(__builtin_constant_p(0x8848) ? (__uint16_t)(((__uint16_t
)(0x8848) & 0xffU) << 8 | ((__uint16_t)(0x8848) &
0xff00U) >> 8) : __swap16md(0x8848)):
1122 mcast = M_MCAST0x0200|M_BCAST0x0100;
1123 /* fallthrough */
1124 case htons(ETHERTYPE_MPLS)(__uint16_t)(__builtin_constant_p(0x8847) ? (__uint16_t)(((__uint16_t
)(0x8847) & 0xffU) << 8 | ((__uint16_t)(0x8847) &
0xff00U) >> 8) : __swap16md(0x8847)):
1125 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family = AF_MPLS33;
1126 patch = gre_mpls_patch;
1127 break;
1128#endif
1129 case htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0)):
1130 if (ifp->if_typeif_data.ifi_type != IFT_TUNNEL0x83) {
1131 /* keepalives dont make sense for mgre */
1132 goto decline;
1133 }
1134
1135 m_adj(m, hlen);
1136 gre_keepalive_recv(ifp, m);
1137 return (IPPROTO_DONE257);
1138
1139 default:
1140 goto decline;
1141 }
1142
1143 /* it's ours now */
1144
1145 m_adj(m, hlen);
1146
1147 tunnel = ifp->if_softc; /* gre and mgre tunnel info is at the front */
1148
1149 m = (*patch)(tunnel, m, &itos, otos);
1150 if (m == NULL((void *)0))
1151 return (IPPROTO_DONE257);
1152
1153 if (tunnel->t_key_mask == GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U))) {
1154 SET(m->m_pkthdr.csum_flags, M_FLOWID)((m->M_dat.MH.MH_pkthdr.csum_flags) |= (0x4000));
1155 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_flowid =
1156 bemtoh32(&key->t_key)(__uint32_t)(__builtin_constant_p(*(__uint32_t *)(&key->
t_key)) ? (__uint32_t)(((__uint32_t)(*(__uint32_t *)(&key
->t_key)) & 0xff) << 24 | ((__uint32_t)(*(__uint32_t
*)(&key->t_key)) & 0xff00) << 8 | ((__uint32_t
)(*(__uint32_t *)(&key->t_key)) & 0xff0000) >>
8 | ((__uint32_t)(*(__uint32_t *)(&key->t_key)) &
0xff000000) >> 24) : __swap32md(*(__uint32_t *)(&key
->t_key))) & ~GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
1157 }
1158
1159 rxprio = tunnel->t_rxhprio;
1160 switch (rxprio) {
1161 case IF_HDRPRIO_PACKET-1:
1162 /* nop */
1163 break;
1164 case IF_HDRPRIO_OUTER-3:
1165 m->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio = IFQ_TOS2PRIO(otos)((otos) >> 5);
1166 break;
1167 case IF_HDRPRIO_PAYLOAD-2:
1168 m->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio = IFQ_TOS2PRIO(itos)((itos) >> 5);
1169 break;
1170 default:
1171 m->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio = rxprio;
1172 break;
1173 }
1174
1175 m->m_flagsm_hdr.mh_flags &= ~(M_MCAST0x0200|M_BCAST0x0100);
1176 m->m_flagsm_hdr.mh_flags |= mcast;
1177
1178 if_vinput(ifp, m);
1179 return (IPPROTO_DONE257);
1180decline:
1181 *mp = m;
1182 return (-1);
1183}
1184
1185static struct mbuf *
1186gre_ipv4_patch(const struct gre_tunnel *tunnel, struct mbuf *m,
1187 uint8_t *itosp, uint8_t otos)
1188{
1189 struct ip *ip;
1190 uint8_t itos;
1191
1192 m = m_pullup(m, sizeof(*ip));
1193 if (m == NULL((void *)0))
1194 return (NULL((void *)0));
1195
1196 ip = mtod(m, struct ip *)((struct ip *)((m)->m_hdr.mh_data));
1197
1198 itos = ip->ip_tos;
1199 if (ip_ecn_egress(tunnel->t_ecn, &otos, &itos) == 0) {
1200 m_freem(m);
1201 return (NULL((void *)0));
1202 }
1203 if (itos != ip->ip_tos)
1204 ip_tos_patch(ip, itos);
1205
1206 *itosp = itos;
1207
1208 return (m);
1209}
1210
1211#ifdef INET61
1212static struct mbuf *
1213gre_ipv6_patch(const struct gre_tunnel *tunnel, struct mbuf *m,
1214 uint8_t *itosp, uint8_t otos)
1215{
1216 struct ip6_hdr *ip6;
1217 uint32_t flow;
1218 uint8_t itos;
1219
1220 m = m_pullup(m, sizeof(*ip6));
1221 if (m == NULL((void *)0))
1222 return (NULL((void *)0));
1223
1224 ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
1225
1226 flow = bemtoh32(&ip6->ip6_flow)(__uint32_t)(__builtin_constant_p(*(__uint32_t *)(&ip6->
ip6_ctlun.ip6_un1.ip6_un1_flow)) ? (__uint32_t)(((__uint32_t)
(*(__uint32_t *)(&ip6->ip6_ctlun.ip6_un1.ip6_un1_flow)
) & 0xff) << 24 | ((__uint32_t)(*(__uint32_t *)(&
ip6->ip6_ctlun.ip6_un1.ip6_un1_flow)) & 0xff00) <<
8 | ((__uint32_t)(*(__uint32_t *)(&ip6->ip6_ctlun.ip6_un1
.ip6_un1_flow)) & 0xff0000) >> 8 | ((__uint32_t)(*(
__uint32_t *)(&ip6->ip6_ctlun.ip6_un1.ip6_un1_flow)) &
0xff000000) >> 24) : __swap32md(*(__uint32_t *)(&ip6
->ip6_ctlun.ip6_un1.ip6_un1_flow)));
1227 itos = flow >> 20;
1228 if (ip_ecn_egress(tunnel->t_ecn, &otos, &itos) == 0) {
1229 m_freem(m);
1230 return (NULL((void *)0));
1231 }
1232
1233 CLR(flow, 0xff << 20)((flow) &= ~(0xff << 20));
1234 SET(flow, itos << 20)((flow) |= (itos << 20));
1235 htobem32(&ip6->ip6_flow, flow)(*(__uint32_t *)(&ip6->ip6_ctlun.ip6_un1.ip6_un1_flow)
= (__uint32_t)(__builtin_constant_p(flow) ? (__uint32_t)(((__uint32_t
)(flow) & 0xff) << 24 | ((__uint32_t)(flow) & 0xff00
) << 8 | ((__uint32_t)(flow) & 0xff0000) >> 8
| ((__uint32_t)(flow) & 0xff000000) >> 24) : __swap32md
(flow)));
1236
1237 *itosp = itos;
1238
1239 return (m);
1240}
1241#endif
1242
1243#ifdef MPLS1
1244static struct mbuf *
1245gre_mpls_patch(const struct gre_tunnel *tunnel, struct mbuf *m,
1246 uint8_t *itosp, uint8_t otos)
1247{
1248 uint8_t itos;
1249 uint32_t shim;
1250
1251 m = m_pullup(m, sizeof(shim));
1252 if (m == NULL((void *)0))
1253 return (NULL((void *)0));
1254
1255 shim = *mtod(m, uint32_t *)((uint32_t *)((m)->m_hdr.mh_data));
1256 itos = (ntohl(shim & MPLS_EXP_MASK)(__uint32_t)(__builtin_constant_p(shim & ((u_int32_t)(__uint32_t
)(__builtin_constant_p((u_int32_t)(0x00000e00U)) ? (__uint32_t
)(((__uint32_t)((u_int32_t)(0x00000e00U)) & 0xff) <<
24 | ((__uint32_t)((u_int32_t)(0x00000e00U)) & 0xff00) <<
8 | ((__uint32_t)((u_int32_t)(0x00000e00U)) & 0xff0000) >>
8 | ((__uint32_t)((u_int32_t)(0x00000e00U)) & 0xff000000
) >> 24) : __swap32md((u_int32_t)(0x00000e00U))))) ? (__uint32_t
)(((__uint32_t)(shim & ((u_int32_t)(__uint32_t)(__builtin_constant_p
((u_int32_t)(0x00000e00U)) ? (__uint32_t)(((__uint32_t)((u_int32_t
)(0x00000e00U)) & 0xff) << 24 | ((__uint32_t)((u_int32_t
)(0x00000e00U)) & 0xff00) << 8 | ((__uint32_t)((u_int32_t
)(0x00000e00U)) & 0xff0000) >> 8 | ((__uint32_t)((u_int32_t
)(0x00000e00U)) & 0xff000000) >> 24) : __swap32md((
u_int32_t)(0x00000e00U))))) & 0xff) << 24 | ((__uint32_t
)(shim & ((u_int32_t)(__uint32_t)(__builtin_constant_p((u_int32_t
)(0x00000e00U)) ? (__uint32_t)(((__uint32_t)((u_int32_t)(0x00000e00U
)) & 0xff) << 24 | ((__uint32_t)((u_int32_t)(0x00000e00U
)) & 0xff00) << 8 | ((__uint32_t)((u_int32_t)(0x00000e00U
)) & 0xff0000) >> 8 | ((__uint32_t)((u_int32_t)(0x00000e00U
)) & 0xff000000) >> 24) : __swap32md((u_int32_t)(0x00000e00U
))))) & 0xff00) << 8 | ((__uint32_t)(shim & ((u_int32_t
)(__uint32_t)(__builtin_constant_p((u_int32_t)(0x00000e00U)) ?
(__uint32_t)(((__uint32_t)((u_int32_t)(0x00000e00U)) & 0xff
) << 24 | ((__uint32_t)((u_int32_t)(0x00000e00U)) &
0xff00) << 8 | ((__uint32_t)((u_int32_t)(0x00000e00U))
& 0xff0000) >> 8 | ((__uint32_t)((u_int32_t)(0x00000e00U
)) & 0xff000000) >> 24) : __swap32md((u_int32_t)(0x00000e00U
))))) & 0xff0000) >> 8 | ((__uint32_t)(shim & (
(u_int32_t)(__uint32_t)(__builtin_constant_p((u_int32_t)(0x00000e00U
)) ? (__uint32_t)(((__uint32_t)((u_int32_t)(0x00000e00U)) &
0xff) << 24 | ((__uint32_t)((u_int32_t)(0x00000e00U)) &
0xff00) << 8 | ((__uint32_t)((u_int32_t)(0x00000e00U))
& 0xff0000) >> 8 | ((__uint32_t)((u_int32_t)(0x00000e00U
)) & 0xff000000) >> 24) : __swap32md((u_int32_t)(0x00000e00U
))))) & 0xff000000) >> 24) : __swap32md(shim & (
(u_int32_t)(__uint32_t)(__builtin_constant_p((u_int32_t)(0x00000e00U
)) ? (__uint32_t)(((__uint32_t)((u_int32_t)(0x00000e00U)) &
0xff) << 24 | ((__uint32_t)((u_int32_t)(0x00000e00U)) &
0xff00) << 8 | ((__uint32_t)((u_int32_t)(0x00000e00U))
& 0xff0000) >> 8 | ((__uint32_t)((u_int32_t)(0x00000e00U
)) & 0xff000000) >> 24) : __swap32md((u_int32_t)(0x00000e00U
)))))) >> MPLS_EXP_OFFSET9) << 5;
1257
1258 if (ip_ecn_egress(tunnel->t_ecn, &otos, &itos) == 0) {
1259 m_freem(m);
1260 return (NULL((void *)0));
1261 }
1262
1263 *itosp = itos;
1264
1265 return (m);
1266}
1267#endif
1268
1269#define gre_l2_prio(_t, _m, _otos)do { int rxprio = (_t)->t_rxhprio; switch (rxprio) { case -
1: break; case -3: (_m)->M_dat.MH.MH_pkthdr.pf.prio = (((_otos
)) >> 5); break; default: (_m)->M_dat.MH.MH_pkthdr.pf
.prio = rxprio; break; } } while (0) do { \
1270 int rxprio = (_t)->t_rxhprio; \
1271 switch (rxprio) { \
1272 case IF_HDRPRIO_PACKET-1: \
1273 /* nop */ \
1274 break; \
1275 case IF_HDRPRIO_OUTER-3: \
1276 (_m)->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio = IFQ_TOS2PRIO((_otos))(((_otos)) >> 5); \
1277 break; \
1278 default: \
1279 (_m)->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio = rxprio; \
1280 break; \
1281 } \
1282} while (0)
1283
1284static int
1285egre_input(const struct gre_tunnel *key, struct mbuf *m, int hlen, uint8_t otos)
1286{
1287 struct egre_softc *sc;
1288
1289 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
1290 sc = RBT_FIND(egre_tree, &egre_tree, (const struct egre_softc *)key)egre_tree_RBT_FIND(&egre_tree, (const struct egre_softc *
)key);
1291 if (sc == NULL((void *)0))
1292 return (-1);
1293
1294 /* it's ours now */
1295 m = gre_ether_align(m, hlen);
1296 if (m == NULL((void *)0))
1297 return (0);
1298
1299 if (sc->sc_tunnel.t_key_mask == GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U))) {
1300 SET(m->m_pkthdr.csum_flags, M_FLOWID)((m->M_dat.MH.MH_pkthdr.csum_flags) |= (0x4000));
1301 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_flowid =
1302 bemtoh32(&key->t_key)(__uint32_t)(__builtin_constant_p(*(__uint32_t *)(&key->
t_key)) ? (__uint32_t)(((__uint32_t)(*(__uint32_t *)(&key
->t_key)) & 0xff) << 24 | ((__uint32_t)(*(__uint32_t
*)(&key->t_key)) & 0xff00) << 8 | ((__uint32_t
)(*(__uint32_t *)(&key->t_key)) & 0xff0000) >>
8 | ((__uint32_t)(*(__uint32_t *)(&key->t_key)) &
0xff000000) >> 24) : __swap32md(*(__uint32_t *)(&key
->t_key))) & ~GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
1303 }
1304
1305 m->m_flagsm_hdr.mh_flags &= ~(M_MCAST0x0200|M_BCAST0x0100);
1306
1307 gre_l2_prio(&sc->sc_tunnel, m, otos)do { int rxprio = (&sc->sc_tunnel)->t_rxhprio; switch
(rxprio) { case -1: break; case -3: (m)->M_dat.MH.MH_pkthdr
.pf.prio = (((otos)) >> 5); break; default: (m)->M_dat
.MH.MH_pkthdr.pf.prio = rxprio; break; } } while (0);
1308
1309 if_vinput(&sc->sc_ac.ac_if, m);
1310
1311 return (0);
1312}
1313
1314static inline struct nvgre_softc *
1315nvgre_mcast_find(const struct gre_tunnel *key, unsigned int if0idx)
1316{
1317 struct nvgre_softc *sc;
1318 int rv;
1319
1320 /*
1321 * building an nvgre_softc to use with RBT_FIND is expensive, and
1322 * would need to swap the src and dst addresses in the key. so do the
1323 * find by hand.
1324 */
1325
1326 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
1327 sc = RBT_ROOT(nvgre_mcast_tree, &nvgre_mcast_tree)nvgre_mcast_tree_RBT_ROOT(&nvgre_mcast_tree);
1328 while (sc != NULL((void *)0)) {
1329 rv = nvgre_cmp_mcast(key, &key->t_src, if0idx,
1330 &sc->sc_tunnel, &sc->sc_tunnel.t_dst, sc->sc_ifp0);
1331 if (rv == 0)
1332 return (sc);
1333 if (rv < 0)
1334 sc = RBT_LEFT(nvgre_mcast_tree, sc)nvgre_mcast_tree_RBT_LEFT(sc);
1335 else
1336 sc = RBT_RIGHT(nvgre_mcast_tree, sc)nvgre_mcast_tree_RBT_RIGHT(sc);
1337 }
1338
1339 return (NULL((void *)0));
1340}
1341
1342static inline struct nvgre_softc *
1343nvgre_ucast_find(const struct gre_tunnel *key)
1344{
1345 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
1346 return (RBT_FIND(nvgre_ucast_tree, &nvgre_ucast_tree,nvgre_ucast_tree_RBT_FIND(&nvgre_ucast_tree, (struct nvgre_softc
*)key)
1347 (struct nvgre_softc *)key)nvgre_ucast_tree_RBT_FIND(&nvgre_ucast_tree, (struct nvgre_softc
*)key));
1348}
1349
1350static int
1351nvgre_input(const struct gre_tunnel *key, struct mbuf *m, int hlen,
1352 uint8_t otos)
1353{
1354 struct nvgre_softc *sc;
1355 struct ether_header *eh;
1356
1357 if (ISSET(m->m_flags, M_MCAST|M_BCAST)((m->m_hdr.mh_flags) & (0x0200|0x0100)))
1358 sc = nvgre_mcast_find(key, m->m_pkthdrM_dat.MH.MH_pkthdr.ph_ifidx);
1359 else
1360 sc = nvgre_ucast_find(key);
1361
1362 if (sc == NULL((void *)0))
1363 return (-1);
1364
1365 /* it's ours now */
1366 m = gre_ether_align(m, hlen);
1367 if (m == NULL((void *)0))
1368 return (0);
1369
1370 eh = mtod(m, struct ether_header *)((struct ether_header *)((m)->m_hdr.mh_data));
1371 etherbridge_map_ea(&sc->sc_eb, (void *)&key->t_dst,
1372 (struct ether_addr *)eh->ether_shost);
1373
1374 SET(m->m_pkthdr.csum_flags, M_FLOWID)((m->M_dat.MH.MH_pkthdr.csum_flags) |= (0x4000));
1375 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_flowid = bemtoh32(&key->t_key)(__uint32_t)(__builtin_constant_p(*(__uint32_t *)(&key->
t_key)) ? (__uint32_t)(((__uint32_t)(*(__uint32_t *)(&key
->t_key)) & 0xff) << 24 | ((__uint32_t)(*(__uint32_t
*)(&key->t_key)) & 0xff00) << 8 | ((__uint32_t
)(*(__uint32_t *)(&key->t_key)) & 0xff0000) >>
8 | ((__uint32_t)(*(__uint32_t *)(&key->t_key)) &
0xff000000) >> 24) : __swap32md(*(__uint32_t *)(&key
->t_key))) & ~GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
1376
1377 m->m_flagsm_hdr.mh_flags &= ~(M_MCAST0x0200|M_BCAST0x0100);
1378
1379 gre_l2_prio(&sc->sc_tunnel, m, otos)do { int rxprio = (&sc->sc_tunnel)->t_rxhprio; switch
(rxprio) { case -1: break; case -3: (m)->M_dat.MH.MH_pkthdr
.pf.prio = (((otos)) >> 5); break; default: (m)->M_dat
.MH.MH_pkthdr.pf.prio = rxprio; break; } } while (0);
1380
1381 if_vinput(&sc->sc_ac.ac_if, m);
1382
1383 return (0);
1384}
1385
1386static struct mbuf *
1387gre_ether_align(struct mbuf *m, int hlen)
1388{
1389 struct mbuf *n;
1390 int off;
1391
1392 m_adj(m, hlen);
1393
1394 if (m->m_pkthdrM_dat.MH.MH_pkthdr.len < sizeof(struct ether_header)) {
1395 m_freem(m);
1396 return (NULL((void *)0));
1397 }
1398
1399 m = m_pullup(m, sizeof(struct ether_header));
1400 if (m == NULL((void *)0))
1401 return (NULL((void *)0));
1402
1403 n = m_getptr(m, sizeof(struct ether_header), &off);
1404 if (n == NULL((void *)0)) {
1405 m_freem(m);
1406 return (NULL((void *)0));
1407 }
1408
1409 if (!ALIGNED_POINTER(mtod(n, caddr_t) + off, uint32_t)1) {
1410 n = m_dup_pkt(m, ETHER_ALIGN2, M_NOWAIT0x0002);
1411 m_freem(m);
1412 if (n == NULL((void *)0))
1413 return (NULL((void *)0));
1414 m = n;
1415 }
1416
1417 return (m);
1418}
1419
1420static void
1421gre_keepalive_recv(struct ifnet *ifp, struct mbuf *m)
1422{
1423 struct gre_softc *sc = ifp->if_softc;
1424 struct gre_keepalive *gk;
1425 SIPHASH_CTX ctx;
1426 uint8_t digest[SIPHASH_DIGEST_LENGTH8];
1427 int uptime, delta;
1428 int tick = ticks;
1429
1430 if (sc->sc_ka_state == GRE_KA_NONE0 ||
1431 sc->sc_tunnel.t_rtableid != sc->sc_if.if_rdomainif_data.ifi_rdomain)
1432 goto drop;
1433
1434 if (m->m_pkthdrM_dat.MH.MH_pkthdr.len < sizeof(*gk))
1435 goto drop;
1436 m = m_pullup(m, sizeof(*gk));
1437 if (m == NULL((void *)0))
1438 return;
1439
1440 gk = mtod(m, struct gre_keepalive *)((struct gre_keepalive *)((m)->m_hdr.mh_data));
1441 uptime = bemtoh32(&gk->gk_uptime)(__uint32_t)(__builtin_constant_p(*(__uint32_t *)(&gk->
gk_uptime)) ? (__uint32_t)(((__uint32_t)(*(__uint32_t *)(&
gk->gk_uptime)) & 0xff) << 24 | ((__uint32_t)(*(
__uint32_t *)(&gk->gk_uptime)) & 0xff00) << 8
| ((__uint32_t)(*(__uint32_t *)(&gk->gk_uptime)) &
0xff0000) >> 8 | ((__uint32_t)(*(__uint32_t *)(&gk
->gk_uptime)) & 0xff000000) >> 24) : __swap32md(
*(__uint32_t *)(&gk->gk_uptime))) - sc->sc_ka_bias;
1442 delta = tick - uptime;
1443 if (delta < 0)
1444 goto drop;
1445 if (delta > hz * 10) /* magic */
1446 goto drop;
1447
1448 /* avoid too much siphash work */
1449 delta = tick - sc->sc_ka_recvtm;
1450 if (delta > 0 && delta < (hz / 10))
1451 goto drop;
1452
1453 SipHash24_Init(&ctx, &sc->sc_ka_key)SipHash_Init((&ctx), (&sc->sc_ka_key));
1454 SipHash24_Update(&ctx, &gk->gk_uptime, sizeof(gk->gk_uptime))SipHash_Update((&ctx), 2, 4, (&gk->gk_uptime), (sizeof
(gk->gk_uptime)));
1455 SipHash24_Update(&ctx, &gk->gk_random, sizeof(gk->gk_random))SipHash_Update((&ctx), 2, 4, (&gk->gk_random), (sizeof
(gk->gk_random)));
1456 SipHash24_Final(digest, &ctx)SipHash_Final((digest), (&ctx), 2, 4);
1457
1458 if (memcmp(digest, gk->gk_digest, sizeof(digest))__builtin_memcmp((digest), (gk->gk_digest), (sizeof(digest
))) != 0)
1459 goto drop;
1460
1461 sc->sc_ka_recvtm = tick;
1462
1463 switch (sc->sc_ka_state) {
1464 case GRE_KA_DOWN1:
1465 sc->sc_ka_state = GRE_KA_HOLD2;
1466 sc->sc_ka_holdcnt = sc->sc_ka_holdmax;
1467 sc->sc_ka_holdmax = MIN(sc->sc_ka_holdmax * 2,(((sc->sc_ka_holdmax * 2)<(16 * sc->sc_ka_count))?(sc
->sc_ka_holdmax * 2):(16 * sc->sc_ka_count))
1468 16 * sc->sc_ka_count)(((sc->sc_ka_holdmax * 2)<(16 * sc->sc_ka_count))?(sc
->sc_ka_holdmax * 2):(16 * sc->sc_ka_count));
1469 break;
1470 case GRE_KA_HOLD2:
1471 if (--sc->sc_ka_holdcnt > 0)
1472 break;
1473
1474 sc->sc_ka_state = GRE_KA_UP3;
1475 gre_link_state(&sc->sc_if, sc->sc_ka_state);
1476 break;
1477
1478 case GRE_KA_UP3:
1479 sc->sc_ka_holdmax--;
1480 sc->sc_ka_holdmax = MAX(sc->sc_ka_holdmax, sc->sc_ka_count)(((sc->sc_ka_holdmax)>(sc->sc_ka_count))?(sc->sc_ka_holdmax
):(sc->sc_ka_count));
1481 break;
1482 }
1483
1484 timeout_add_sec(&sc->sc_ka_hold, sc->sc_ka_timeo * sc->sc_ka_count);
1485
1486drop:
1487 m_freem(m);
1488}
1489
1490static int
1491gre_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
1492 struct rtentry *rt)
1493{
1494 struct m_tag *mtag;
1495 int error = 0;
1496
1497 if (!gre_allow) {
1498 error = EACCES13;
1499 goto drop;
1500 }
1501
1502 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
1503 error = ENETDOWN50;
1504 goto drop;
1505 }
1506
1507 switch (dst->sa_family) {
1508 case AF_INET2:
1509#ifdef INET61
1510 case AF_INET624:
1511#endif
1512#ifdef MPLS1
1513 case AF_MPLS33:
1514#endif
1515 break;
1516 default:
1517 error = EAFNOSUPPORT47;
1518 goto drop;
1519 }
1520
1521 /* Try to limit infinite recursion through misconfiguration. */
1522 for (mtag = m_tag_find(m, PACKET_TAG_GRE0x0080, NULL((void *)0)); mtag;
1523 mtag = m_tag_find(m, PACKET_TAG_GRE0x0080, mtag)) {
1524 if (memcmp((caddr_t)(mtag + 1), &ifp->if_index,__builtin_memcmp(((caddr_t)(mtag + 1)), (&ifp->if_index
), (sizeof(ifp->if_index)))
1525 sizeof(ifp->if_index))__builtin_memcmp(((caddr_t)(mtag + 1)), (&ifp->if_index
), (sizeof(ifp->if_index))) == 0) {
1526 m_freem(m);
1527 error = EIO5;
1528 goto end;
1529 }
1530 }
1531
1532 mtag = m_tag_get(PACKET_TAG_GRE0x0080, sizeof(ifp->if_index), M_NOWAIT0x0002);
1533 if (mtag == NULL((void *)0)) {
1534 m_freem(m);
1535 error = ENOBUFS55;
1536 goto end;
1537 }
1538 memcpy((caddr_t)(mtag + 1), &ifp->if_index, sizeof(ifp->if_index))__builtin_memcpy(((caddr_t)(mtag + 1)), (&ifp->if_index
), (sizeof(ifp->if_index)));
1539 m_tag_prepend(m, mtag);
1540
1541 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family = dst->sa_family;
1542
1543 error = if_enqueue(ifp, m);
1544end:
1545 if (error)
1546 ifp->if_oerrorsif_data.ifi_oerrors++;
1547 return (error);
1548
1549drop:
1550 m_freem(m);
1551 return (error);
1552}
1553
1554void
1555gre_start(struct ifnet *ifp)
1556{
1557 struct gre_softc *sc = ifp->if_softc;
1558 struct mbuf *m;
1559 int af;
1560#if NBPFILTER1 > 0
1561 caddr_t if_bpf;
1562#endif
1563
1564 while ((m = ifq_dequeue(&ifp->if_snd)) != NULL((void *)0)) {
1565 af = m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family;
1566
1567#if NBPFILTER1 > 0
1568 if_bpf = ifp->if_bpf;
1569 if (if_bpf)
1570 bpf_mtap_af(if_bpf, af, m, BPF_DIRECTION_OUT(1 << 1));
1571#endif
1572
1573 m = gre_l3_encap(&sc->sc_tunnel, m, af)gre_l3_encap_dst((&sc->sc_tunnel), &(&sc->sc_tunnel
)->t_dst, (m), (af));
1574 if (m == NULL((void *)0) || gre_ip_output(&sc->sc_tunnel, m) != 0) {
1575 ifp->if_oerrorsif_data.ifi_oerrors++;
1576 continue;
1577 }
1578 }
1579}
1580
1581void
1582mgre_rtrequest(struct ifnet *ifp, int req, struct rtentry *rt)
1583{
1584 struct ifnet *lo0ifp;
1585 struct ifaddr *ifa, *lo0ifa;
1586
1587 switch (req) {
1588 case RTM_ADD0x1:
1589 if (!ISSET(rt->rt_flags, RTF_LOCAL)((rt->rt_flags) & (0x200000)))
1590 break;
1591
1592 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list)for((ifa) = ((&ifp->if_addrlist)->tqh_first); (ifa)
!= ((void *)0); (ifa) = ((ifa)->ifa_list.tqe_next)) {
1593 if (memcmp(rt_key(rt), ifa->ifa_addr,__builtin_memcmp((((rt)->rt_dest)), (ifa->ifa_addr), ((
(rt)->rt_dest)->sa_len))
1594 rt_key(rt)->sa_len)__builtin_memcmp((((rt)->rt_dest)), (ifa->ifa_addr), ((
(rt)->rt_dest)->sa_len)) == 0)
1595 break;
1596 }
1597
1598 if (ifa == NULL((void *)0))
1599 break;
1600
1601 KASSERT(ifa == rt->rt_ifa)((ifa == rt->rt_ifa) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/net/if_gre.c"
, 1601, "ifa == rt->rt_ifa"));
1602
1603 lo0ifp = if_get(rtable_loindex(ifp->if_rdomainif_data.ifi_rdomain));
1604 KASSERT(lo0ifp != NULL)((lo0ifp != ((void *)0)) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/net/if_gre.c"
, 1604, "lo0ifp != NULL"));
1605 TAILQ_FOREACH(lo0ifa, &lo0ifp->if_addrlist, ifa_list)for((lo0ifa) = ((&lo0ifp->if_addrlist)->tqh_first);
(lo0ifa) != ((void *)0); (lo0ifa) = ((lo0ifa)->ifa_list.tqe_next
)) {
1606 if (lo0ifa->ifa_addr->sa_family ==
1607 ifa->ifa_addr->sa_family)
1608 break;
1609 }
1610 if_put(lo0ifp);
1611
1612 if (lo0ifa == NULL((void *)0))
1613 break;
1614
1615 rt->rt_flags &= ~RTF_LLINFO0x400;
1616 break;
1617 case RTM_DELETE0x2:
1618 case RTM_RESOLVE0xb:
1619 default:
1620 break;
1621 }
1622}
1623
1624static int
1625mgre_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dest,
1626 struct rtentry *rt0)
1627{
1628 struct mgre_softc *sc = ifp->if_softc;
1629 struct sockaddr *gate;
1630 struct rtentry *rt;
1631 struct m_tag *mtag;
1632 int error = 0;
1633 sa_family_t af;
1634 const void *addr;
1635
1636 if (!gre_allow) {
1637 error = EACCES13;
1638 goto drop;
1639 }
1640
1641 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
1642 error = ENETDOWN50;
1643 goto drop;
1644 }
1645
1646 switch (dest->sa_family) {
1647 case AF_INET2:
1648#ifdef INET61
1649 case AF_INET624:
1650#endif
1651#ifdef MPLS1
1652 case AF_MPLS33:
1653#endif
1654 break;
1655 default:
1656 error = EAFNOSUPPORT47;
1657 goto drop;
1658 }
1659
1660 if (ISSET(m->m_flags, M_MCAST|M_BCAST)((m->m_hdr.mh_flags) & (0x0200|0x0100))) {
1661 error = ENETUNREACH51;
1662 goto drop;
1663 }
1664
1665 rt = rt_getll(rt0);
1666
1667 /* check rt_expire? */
1668 if (ISSET(rt->rt_flags, RTF_REJECT)((rt->rt_flags) & (0x8))) {
1669 error = (rt == rt0) ? EHOSTDOWN64 : EHOSTUNREACH65;
1670 goto drop;
1671 }
1672 if (!ISSET(rt->rt_flags, RTF_HOST)((rt->rt_flags) & (0x4))) {
1673 error = EHOSTUNREACH65;
1674 goto drop;
1675 }
1676 if (ISSET(rt->rt_flags, RTF_GATEWAY)((rt->rt_flags) & (0x2))) {
1677 error = EINVAL22;
1678 goto drop;
1679 }
1680
1681 gate = rt->rt_gateway;
1682 af = gate->sa_family;
1683 if (af != sc->sc_tunnel.t_af) {
1684 error = EAGAIN35;
1685 goto drop;
1686 }
1687
1688 /* Try to limit infinite recursion through misconfiguration. */
1689 for (mtag = m_tag_find(m, PACKET_TAG_GRE0x0080, NULL((void *)0)); mtag;
1690 mtag = m_tag_find(m, PACKET_TAG_GRE0x0080, mtag)) {
1691 if (memcmp((caddr_t)(mtag + 1), &ifp->if_index,__builtin_memcmp(((caddr_t)(mtag + 1)), (&ifp->if_index
), (sizeof(ifp->if_index)))
1692 sizeof(ifp->if_index))__builtin_memcmp(((caddr_t)(mtag + 1)), (&ifp->if_index
), (sizeof(ifp->if_index))) == 0) {
1693 error = EIO5;
1694 goto drop;
1695 }
1696 }
1697
1698 mtag = m_tag_get(PACKET_TAG_GRE0x0080, sizeof(ifp->if_index), M_NOWAIT0x0002);
1699 if (mtag == NULL((void *)0)) {
1700 error = ENOBUFS55;
1701 goto drop;
1702 }
1703 memcpy((caddr_t)(mtag + 1), &ifp->if_index, sizeof(ifp->if_index))__builtin_memcpy(((caddr_t)(mtag + 1)), (&ifp->if_index
), (sizeof(ifp->if_index)));
1704 m_tag_prepend(m, mtag);
1705
1706 switch (af) {
1707 case AF_INET2: {
1708 struct sockaddr_in *sin = (struct sockaddr_in *)gate;
1709 addr = &sin->sin_addr;
1710 break;
1711 }
1712#ifdef INET61
1713 case AF_INET624: {
1714 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)gate;
1715 addr = &sin6->sin6_addr;
1716 break;
1717 }
1718 #endif
1719 default:
1720 unhandled_af(af);
1721 /* NOTREACHED */
1722 }
1723
1724 m = gre_l3_encap_dst(&sc->sc_tunnel, addr, m, dest->sa_family);
1725 if (m == NULL((void *)0)) {
1726 ifp->if_oerrorsif_data.ifi_oerrors++;
1727 return (ENOBUFS55);
1728 }
1729
1730 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family = dest->sa_family;
1731
1732 error = if_enqueue(ifp, m);
1733 if (error)
1734 ifp->if_oerrorsif_data.ifi_oerrors++;
1735 return (error);
1736
1737drop:
1738 m_freem(m);
1739 return (error);
1740}
1741
1742static void
1743mgre_start(struct ifnet *ifp)
1744{
1745 struct mgre_softc *sc = ifp->if_softc;
1746 struct mbuf *m;
1747#if NBPFILTER1 > 0
1748 caddr_t if_bpf;
1749#endif
1750
1751 while ((m = ifq_dequeue(&ifp->if_snd)) != NULL((void *)0)) {
1752#if NBPFILTER1 > 0
1753 if_bpf = ifp->if_bpf;
1754 if (if_bpf) {
1755 struct m_hdr mh;
1756 struct mbuf *n;
1757 int off;
1758
1759 n = m_getptr(m, ifp->if_hdrlenif_data.ifi_hdrlen, &off);
1760 KASSERT(n != NULL)((n != ((void *)0)) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/net/if_gre.c"
, 1760, "n != NULL"));
1761
1762 mh.mh_flags = 0;
1763 mh.mh_next = n->m_nextm_hdr.mh_next;
1764 mh.mh_len = n->m_lenm_hdr.mh_len - off;
1765 mh.mh_data = n->m_datam_hdr.mh_data + off;
1766
1767 bpf_mtap_af(if_bpf, m->m_pkthdrM_dat.MH.MH_pkthdr.ph_family,
1768 (struct mbuf *)&mh, BPF_DIRECTION_OUT(1 << 1));
1769 }
1770#endif
1771
1772 if (gre_ip_output(&sc->sc_tunnel, m) != 0) {
1773 ifp->if_oerrorsif_data.ifi_oerrors++;
1774 continue;
1775 }
1776 }
1777}
1778
1779static void
1780egre_start(struct ifnet *ifp)
1781{
1782 struct egre_softc *sc = ifp->if_softc;
1783 struct mbuf *m0, *m;
1784#if NBPFILTER1 > 0
1785 caddr_t if_bpf;
1786#endif
1787
1788 if (!gre_allow) {
1789 ifq_purge(&ifp->if_snd);
1790 return;
1791 }
1792
1793 while ((m0 = ifq_dequeue(&ifp->if_snd)) != NULL((void *)0)) {
1794#if NBPFILTER1 > 0
1795 if_bpf = ifp->if_bpf;
1796 if (if_bpf)
1797 bpf_mtap_ether(if_bpf, m0, BPF_DIRECTION_OUT(1 << 1));
1798#endif
1799
1800 /* force prepend mbuf because of alignment problems */
1801 m = m_get(M_DONTWAIT0x0002, m0->m_typem_hdr.mh_type);
1802 if (m == NULL((void *)0)) {
1803 m_freem(m0);
1804 continue;
1805 }
1806
1807 M_MOVE_PKTHDR(m, m0)do { (m)->m_hdr.mh_flags = ((m)->m_hdr.mh_flags & (
0x0001 | 0x0008)); (m)->m_hdr.mh_flags |= (m0)->m_hdr.mh_flags
& (0x0002|0x0004|0x0010|0x0100|0x0200|0x0400|0x4000| 0x0800
|0x0040|0x1000|0x8000|0x0020|0x2000); do { ((m))->M_dat.MH
.MH_pkthdr = ((m0))->M_dat.MH.MH_pkthdr; ((m0))->m_hdr.
mh_flags &= ~0x0002; { ((&((m0))->M_dat.MH.MH_pkthdr
.ph_tags)->slh_first) = ((void *)0); }; ((m0))->M_dat.MH
.MH_pkthdr.pf.statekey = ((void *)0); } while ( 0); if (((m)->
m_hdr.mh_flags & 0x0001) == 0) (m)->m_hdr.mh_data = (m
)->M_dat.MH.MH_dat.MH_databuf; } while ( 0);
1808 m->m_nextm_hdr.mh_next = m0;
1809
1810 m_align(m, 0);
1811 m->m_lenm_hdr.mh_len = 0;
1812
1813 m = gre_encap(&sc->sc_tunnel, m, htons(ETHERTYPE_TRANSETHER),gre_encap_dst((&sc->sc_tunnel), &(&sc->sc_tunnel
)->t_dst, (m), ((__uint16_t)(__builtin_constant_p(0x6558) ?
(__uint16_t)(((__uint16_t)(0x6558) & 0xffU) << 8 |
((__uint16_t)(0x6558) & 0xff00U) >> 8) : __swap16md
(0x6558))), (sc->sc_tunnel.t_ttl), (gre_l2_tos(&sc->
sc_tunnel, m)))
1814 sc->sc_tunnel.t_ttl, gre_l2_tos(&sc->sc_tunnel, m))gre_encap_dst((&sc->sc_tunnel), &(&sc->sc_tunnel
)->t_dst, (m), ((__uint16_t)(__builtin_constant_p(0x6558) ?
(__uint16_t)(((__uint16_t)(0x6558) & 0xffU) << 8 |
((__uint16_t)(0x6558) & 0xff00U) >> 8) : __swap16md
(0x6558))), (sc->sc_tunnel.t_ttl), (gre_l2_tos(&sc->
sc_tunnel, m)));
1815 if (m == NULL((void *)0) || gre_ip_output(&sc->sc_tunnel, m) != 0) {
1816 ifp->if_oerrorsif_data.ifi_oerrors++;
1817 continue;
1818 }
1819 }
1820}
1821
1822static struct mbuf *
1823gre_l3_encap_dst(const struct gre_tunnel *tunnel, const void *dst,
1824 struct mbuf *m, sa_family_t af)
1825{
1826 uint16_t proto;
1827 uint8_t ttl, itos, otos;
1828 int tttl = tunnel->t_ttl;
1829 int ttloff;
1830
1831 switch (af) {
1832 case AF_INET2: {
1833 struct ip *ip;
1834
1835 m = m_pullup(m, sizeof(*ip));
1836 if (m == NULL((void *)0))
1837 return (NULL((void *)0));
1838
1839 ip = mtod(m, struct ip *)((struct ip *)((m)->m_hdr.mh_data));
1840 itos = ip->ip_tos;
1841
1842 ttloff = offsetof(struct ip, ip_ttl)__builtin_offsetof(struct ip, ip_ttl);
1843 proto = htons(ETHERTYPE_IP)(__uint16_t)(__builtin_constant_p(0x0800) ? (__uint16_t)(((__uint16_t
)(0x0800) & 0xffU) << 8 | ((__uint16_t)(0x0800) &
0xff00U) >> 8) : __swap16md(0x0800));
1844 break;
1845 }
1846#ifdef INET61
1847 case AF_INET624: {
1848 struct ip6_hdr *ip6;
1849
1850 m = m_pullup(m, sizeof(*ip6));
1851 if (m == NULL((void *)0))
1852 return (NULL((void *)0));
1853
1854 ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
1855 itos = (ntohl(ip6->ip6_flow)(__uint32_t)(__builtin_constant_p(ip6->ip6_ctlun.ip6_un1.ip6_un1_flow
) ? (__uint32_t)(((__uint32_t)(ip6->ip6_ctlun.ip6_un1.ip6_un1_flow
) & 0xff) << 24 | ((__uint32_t)(ip6->ip6_ctlun.ip6_un1
.ip6_un1_flow) & 0xff00) << 8 | ((__uint32_t)(ip6->
ip6_ctlun.ip6_un1.ip6_un1_flow) & 0xff0000) >> 8 | (
(__uint32_t)(ip6->ip6_ctlun.ip6_un1.ip6_un1_flow) & 0xff000000
) >> 24) : __swap32md(ip6->ip6_ctlun.ip6_un1.ip6_un1_flow
)) & 0x0ff00000) >> 20;
1856
1857 ttloff = offsetof(struct ip6_hdr, ip6_hlim)__builtin_offsetof(struct ip6_hdr, ip6_ctlun.ip6_un1.ip6_un1_hlim
);
1858 proto = htons(ETHERTYPE_IPV6)(__uint16_t)(__builtin_constant_p(0x86DD) ? (__uint16_t)(((__uint16_t
)(0x86DD) & 0xffU) << 8 | ((__uint16_t)(0x86DD) &
0xff00U) >> 8) : __swap16md(0x86DD));
1859 break;
1860 }
1861 #endif
1862#ifdef MPLS1
1863 case AF_MPLS33: {
1864 uint32_t shim;
1865
1866 m = m_pullup(m, sizeof(shim));
1867 if (m == NULL((void *)0))
1868 return (NULL((void *)0));
1869
1870 shim = bemtoh32(mtod(m, uint32_t *))(__uint32_t)(__builtin_constant_p(*(__uint32_t *)(((uint32_t *
)((m)->m_hdr.mh_data)))) ? (__uint32_t)(((__uint32_t)(*(__uint32_t
*)(((uint32_t *)((m)->m_hdr.mh_data)))) & 0xff) <<
24 | ((__uint32_t)(*(__uint32_t *)(((uint32_t *)((m)->m_hdr
.mh_data)))) & 0xff00) << 8 | ((__uint32_t)(*(__uint32_t
*)(((uint32_t *)((m)->m_hdr.mh_data)))) & 0xff0000) >>
8 | ((__uint32_t)(*(__uint32_t *)(((uint32_t *)((m)->m_hdr
.mh_data)))) & 0xff000000) >> 24) : __swap32md(*(__uint32_t
*)(((uint32_t *)((m)->m_hdr.mh_data))))) & MPLS_EXP_MASK((u_int32_t)(__uint32_t)(__builtin_constant_p((u_int32_t)(0x00000e00U
)) ? (__uint32_t)(((__uint32_t)((u_int32_t)(0x00000e00U)) &
0xff) << 24 | ((__uint32_t)((u_int32_t)(0x00000e00U)) &
0xff00) << 8 | ((__uint32_t)((u_int32_t)(0x00000e00U))
& 0xff0000) >> 8 | ((__uint32_t)((u_int32_t)(0x00000e00U
)) & 0xff000000) >> 24) : __swap32md((u_int32_t)(0x00000e00U
))));
1871 itos = (shim >> MPLS_EXP_OFFSET9) << 5;
1872
1873 ttloff = 3;
1874
1875 if (m->m_flagsm_hdr.mh_flags & (M_BCAST0x0100 | M_MCAST0x0200))
1876 proto = htons(ETHERTYPE_MPLS_MCAST)(__uint16_t)(__builtin_constant_p(0x8848) ? (__uint16_t)(((__uint16_t
)(0x8848) & 0xffU) << 8 | ((__uint16_t)(0x8848) &
0xff00U) >> 8) : __swap16md(0x8848));
1877 else
1878 proto = htons(ETHERTYPE_MPLS)(__uint16_t)(__builtin_constant_p(0x8847) ? (__uint16_t)(((__uint16_t
)(0x8847) & 0xffU) << 8 | ((__uint16_t)(0x8847) &
0xff00U) >> 8) : __swap16md(0x8847));
1879 break;
1880 }
1881#endif
1882 default:
1883 unhandled_af(af);
1884 }
1885
1886 if (tttl == -1) {
1887 KASSERT(m->m_len > ttloff)((m->m_hdr.mh_len > ttloff) ? (void)0 : __assert("diagnostic "
, "/usr/src/sys/net/if_gre.c", 1887, "m->m_len > ttloff"
)); /* m_pullup has happened */
1888
1889 ttl = *(m->m_datam_hdr.mh_data + ttloff);
1890 } else
1891 ttl = tttl;
1892
1893 itos = gre_l3_tos(tunnel, m, itos);
1894 ip_ecn_ingress(tunnel->t_ecn, &otos, &itos);
1895
1896 return (gre_encap_dst(tunnel, dst, m, proto, ttl, otos));
1897}
1898
1899static struct mbuf *
1900gre_encap_dst(const struct gre_tunnel *tunnel, const union gre_addr *dst,
1901 struct mbuf *m, uint16_t proto, uint8_t ttl, uint8_t tos)
1902{
1903 struct gre_header *gh;
1904 struct gre_h_key *gkh;
1905 int hlen;
1906
1907 hlen = sizeof(*gh);
1908 if (tunnel->t_key_mask != GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U)))
1909 hlen += sizeof(*gkh);
1910
1911 m = m_prepend(m, hlen, M_DONTWAIT0x0002);
1912 if (m == NULL((void *)0))
1913 return (NULL((void *)0));
1914
1915 gh = mtod(m, struct gre_header *)((struct gre_header *)((m)->m_hdr.mh_data));
1916 gh->gre_flags = GRE_VERS_00x0000;
1917 gh->gre_proto = proto;
1918 if (tunnel->t_key_mask != GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U))) {
1919 gh->gre_flags |= htons(GRE_KP)(__uint16_t)(__builtin_constant_p(0x2000) ? (__uint16_t)(((__uint16_t
)(0x2000) & 0xffU) << 8 | ((__uint16_t)(0x2000) &
0xff00U) >> 8) : __swap16md(0x2000));
1920
1921 gkh = (struct gre_h_key *)(gh + 1);
1922 gkh->gre_key = tunnel->t_key;
1923
1924 if (tunnel->t_key_mask == GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U)) &&
1925 ISSET(m->m_pkthdr.csum_flags, M_FLOWID)((m->M_dat.MH.MH_pkthdr.csum_flags) & (0x4000))) {
1926 gkh->gre_key |= htonl(~GRE_KEY_ENTROPY &(__uint32_t)(__builtin_constant_p(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) ? (__uint32_t)(((__uint32_t)(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff) << 24 | ((__uint32_t)(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff00) << 8 | ((__uint32_t)(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff0000) >> 8 | ((__uint32_t)(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff000000) >> 24) : __swap32md(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
))
1927 m->m_pkthdr.ph_flowid)(__uint32_t)(__builtin_constant_p(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) ? (__uint32_t)(((__uint32_t)(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff) << 24 | ((__uint32_t)(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff00) << 8 | ((__uint32_t)(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff0000) >> 8 | ((__uint32_t)(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff000000) >> 24) : __swap32md(~(__uint32_t)(__builtin_constant_p
(0xffffff00U) ? (__uint32_t)(((__uint32_t)(0xffffff00U) &
0xff) << 24 | ((__uint32_t)(0xffffff00U) & 0xff00)
<< 8 | ((__uint32_t)(0xffffff00U) & 0xff0000) >>
8 | ((__uint32_t)(0xffffff00U) & 0xff000000) >> 24
) : __swap32md(0xffffff00U)) & m->M_dat.MH.MH_pkthdr.ph_flowid
));
1928 }
1929 }
1930
1931 return (gre_encap_dst_ip(tunnel, dst, m, ttl, tos));
1932}
1933
1934static struct mbuf *
1935gre_encap_dst_ip(const struct gre_tunnel *tunnel, const union gre_addr *dst,
1936 struct mbuf *m, uint8_t ttl, uint8_t tos)
1937{
1938 switch (tunnel->t_af) {
1939 case AF_UNSPEC0:
1940 /* packets may arrive before tunnel is set up */
1941 m_freem(m);
1942 return (NULL((void *)0));
1943 case AF_INET2: {
1944 struct ip *ip;
1945
1946 m = m_prepend(m, sizeof(*ip), M_DONTWAIT0x0002);
1947 if (m == NULL((void *)0))
1948 return (NULL((void *)0));
1949
1950 ip = mtod(m, struct ip *)((struct ip *)((m)->m_hdr.mh_data));
1951 ip->ip_v = IPVERSION4;
1952 ip->ip_hl = sizeof(*ip) >> 2;
1953 ip->ip_off = tunnel->t_df;
1954 ip->ip_tos = tos;
1955 ip->ip_len = htons(m->m_pkthdr.len)(__uint16_t)(__builtin_constant_p(m->M_dat.MH.MH_pkthdr.len
) ? (__uint16_t)(((__uint16_t)(m->M_dat.MH.MH_pkthdr.len) &
0xffU) << 8 | ((__uint16_t)(m->M_dat.MH.MH_pkthdr.len
) & 0xff00U) >> 8) : __swap16md(m->M_dat.MH.MH_pkthdr
.len));
1956 ip->ip_ttl = ttl;
1957 ip->ip_p = IPPROTO_GRE47;
1958 ip->ip_src = tunnel->t_src4t_src.in4;
1959 ip->ip_dst = dst->in4;
1960 break;
1961 }
1962#ifdef INET61
1963 case AF_INET624: {
1964 struct ip6_hdr *ip6;
1965 int len = m->m_pkthdrM_dat.MH.MH_pkthdr.len;
1966
1967 m = m_prepend(m, sizeof(*ip6), M_DONTWAIT0x0002);
1968 if (m == NULL((void *)0))
1969 return (NULL((void *)0));
1970
1971 ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
1972 ip6->ip6_flowip6_ctlun.ip6_un1.ip6_un1_flow = ISSET(m->m_pkthdr.csum_flags, M_FLOWID)((m->M_dat.MH.MH_pkthdr.csum_flags) & (0x4000)) ?
1973 htonl(m->m_pkthdr.ph_flowid)(__uint32_t)(__builtin_constant_p(m->M_dat.MH.MH_pkthdr.ph_flowid
) ? (__uint32_t)(((__uint32_t)(m->M_dat.MH.MH_pkthdr.ph_flowid
) & 0xff) << 24 | ((__uint32_t)(m->M_dat.MH.MH_pkthdr
.ph_flowid) & 0xff00) << 8 | ((__uint32_t)(m->M_dat
.MH.MH_pkthdr.ph_flowid) & 0xff0000) >> 8 | ((__uint32_t
)(m->M_dat.MH.MH_pkthdr.ph_flowid) & 0xff000000) >>
24) : __swap32md(m->M_dat.MH.MH_pkthdr.ph_flowid)) : 0;
1974 ip6->ip6_vfcip6_ctlun.ip6_un2_vfc |= IPV6_VERSION0x60;
1975 ip6->ip6_flowip6_ctlun.ip6_un1.ip6_un1_flow |= htonl((uint32_t)tos << 20)(__uint32_t)(__builtin_constant_p((uint32_t)tos << 20) ?
(__uint32_t)(((__uint32_t)((uint32_t)tos << 20) & 0xff
) << 24 | ((__uint32_t)((uint32_t)tos << 20) &
0xff00) << 8 | ((__uint32_t)((uint32_t)tos << 20
) & 0xff0000) >> 8 | ((__uint32_t)((uint32_t)tos <<
20) & 0xff000000) >> 24) : __swap32md((uint32_t)tos
<< 20));
1976 ip6->ip6_plenip6_ctlun.ip6_un1.ip6_un1_plen = htons(len)(__uint16_t)(__builtin_constant_p(len) ? (__uint16_t)(((__uint16_t
)(len) & 0xffU) << 8 | ((__uint16_t)(len) & 0xff00U
) >> 8) : __swap16md(len));
1977 ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt = IPPROTO_GRE47;
1978 ip6->ip6_hlimip6_ctlun.ip6_un1.ip6_un1_hlim = ttl;
1979 ip6->ip6_src = tunnel->t_src6t_src.in6;
1980 ip6->ip6_dst = dst->in6;
1981
1982 if (tunnel->t_df)
1983 SET(m->m_pkthdr.csum_flags, M_IPV6_DF_OUT)((m->M_dat.MH.MH_pkthdr.csum_flags) |= (0x1000));
1984
1985 break;
1986 }
1987#endif /* INET6 */
1988 default:
1989 unhandled_af(tunnel->t_af);
1990 }
1991
1992 return (m);
1993}
1994
1995static int
1996gre_ip_output(const struct gre_tunnel *tunnel, struct mbuf *m)
1997{
1998 m->m_flagsm_hdr.mh_flags &= ~(M_BCAST0x0100|M_MCAST0x0200);
1999 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_rtableid = tunnel->t_rtableid;
2000
2001#if NPF1 > 0
2002 pf_pkt_addr_changed(m);
2003#endif
2004
2005 switch (tunnel->t_af) {
2006 case AF_INET2:
2007 ip_send(m);
2008 break;
2009#ifdef INET61
2010 case AF_INET624:
2011 ip6_send(m);
2012 break;
2013#endif
2014 default:
2015 unhandled_af(tunnel->t_af);
2016 }
2017
2018 return (0);
2019}
2020
2021static int
2022gre_tunnel_ioctl(struct ifnet *ifp, struct gre_tunnel *tunnel,
2023 u_long cmd, void *data)
2024{
2025 struct ifreq *ifr = (struct ifreq *)data;
2026 int error = 0;
2027
2028 switch(cmd) {
2029 case SIOCSIFMTU((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((127))):
2030 if (ifr->ifr_mtuifr_ifru.ifru_metric < 576) {
2031 error = EINVAL22;
2032 break;
2033 }
2034 ifp->if_mtuif_data.ifi_mtu = ifr->ifr_mtuifr_ifru.ifru_metric;
2035 break;
2036 case SIOCADDMULTI((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((49))):
2037 case SIOCDELMULTI((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((50))):
2038 break;
2039
2040 case SIOCSVNETID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((166))):
2041 error = gre_set_vnetid(tunnel, ifr);
2042 break;
2043
2044 case SIOCGVNETID(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((167))):
2045 error = gre_get_vnetid(tunnel, ifr);
2046 break;
2047 case SIOCDVNETID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((175))):
2048 error = gre_del_vnetid(tunnel);
2049 break;
2050
2051 case SIOCSVNETFLOWID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((195))):
2052 error = gre_set_vnetflowid(tunnel, ifr);
2053 break;
2054
2055 case SIOCGVNETFLOWID(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((196))):
2056 error = gre_get_vnetflowid(tunnel, ifr);
2057 break;
2058
2059 case SIOCSLIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct if_laddrreq) &
0x1fff) << 16) | ((('i')) << 8) | ((74))):
2060 error = gre_set_tunnel(tunnel, (struct if_laddrreq *)data, 1);
2061 break;
2062 case SIOCGLIFPHYADDR(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct if_laddrreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((75))):
2063 error = gre_get_tunnel(tunnel, (struct if_laddrreq *)data);
2064 break;
2065 case SIOCDIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((73))):
2066 error = gre_del_tunnel(tunnel);
2067 break;
2068
2069 case SIOCSLIFPHYRTABLE((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((161))):
2070 if (ifr->ifr_rdomainidifr_ifru.ifru_metric < 0 ||
2071 ifr->ifr_rdomainidifr_ifru.ifru_metric > RT_TABLEID_MAX255 ||
2072 !rtable_exists(ifr->ifr_rdomainidifr_ifru.ifru_metric)) {
2073 error = EINVAL22;
2074 break;
2075 }
2076 tunnel->t_rtableid = ifr->ifr_rdomainidifr_ifru.ifru_metric;
2077 break;
2078 case SIOCGLIFPHYRTABLE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((162))):
2079 ifr->ifr_rdomainidifr_ifru.ifru_metric = tunnel->t_rtableid;
2080 break;
2081
2082 case SIOCSLIFPHYDF((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((193))):
2083 /* commit */
2084 tunnel->t_df = ifr->ifr_dfifr_ifru.ifru_metric ? htons(IP_DF)(__uint16_t)(__builtin_constant_p(0x4000) ? (__uint16_t)(((__uint16_t
)(0x4000) & 0xffU) << 8 | ((__uint16_t)(0x4000) &
0xff00U) >> 8) : __swap16md(0x4000)) : htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0));
2085 break;
2086 case SIOCGLIFPHYDF(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((194))):
2087 ifr->ifr_dfifr_ifru.ifru_metric = tunnel->t_df ? 1 : 0;
2088 break;
2089
2090 default:
2091 error = ENOTTY25;
2092 break;
2093 }
2094
2095 return (error);
2096}
2097
2098static uint8_t
2099gre_l2_tos(const struct gre_tunnel *t, const struct mbuf *m)
2100{
2101 uint8_t prio;
2102
2103 switch (t->t_txhprio) {
2104 case IF_HDRPRIO_PACKET-1:
2105 prio = m->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio;
2106 break;
2107 default:
2108 prio = t->t_txhprio;
2109 break;
2110 }
2111
2112 return (IFQ_PRIO2TOS(prio)((prio) << 5));
2113}
2114
2115static uint8_t
2116gre_l3_tos(const struct gre_tunnel *t, const struct mbuf *m, uint8_t tos)
2117{
2118 uint8_t prio;
2119
2120 switch (t->t_txhprio) {
2121 case IF_HDRPRIO_PAYLOAD-2:
2122 return (tos);
2123 case IF_HDRPRIO_PACKET-1:
2124 prio = m->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio;
2125 break;
2126 default:
2127 prio = t->t_txhprio;
2128 break;
2129 }
2130
2131 return (IFQ_PRIO2TOS(prio)((prio) << 5) | (tos & IPTOS_ECN_MASK0x03));
2132}
2133
2134static int
2135gre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2136{
2137 struct gre_softc *sc = ifp->if_softc;
2138 struct ifreq *ifr = (struct ifreq *)data;
2139 struct ifkalivereq *ikar = (struct ifkalivereq *)data;
2140 int error = 0;
2141
2142 switch(cmd) {
2143 case SIOCSIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((12))):
2144 ifp->if_flags |= IFF_UP0x1;
2145 /* FALLTHROUGH */
2146 case SIOCSIFFLAGS((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((16))):
2147 if (ISSET(ifp->if_flags, IFF_UP)((ifp->if_flags) & (0x1))) {
2148 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2149 error = gre_up(sc);
2150 else
2151 error = 0;
2152 } else {
2153 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2154 error = gre_down(sc);
2155 }
2156 break;
2157 case SIOCSIFRDOMAIN((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((159))):
2158 /* let if_rdomain do its thing */
2159 error = ENOTTY25;
2160 break;
2161
2162 case SIOCSETKALIVE((unsigned long)0x80000000 | ((sizeof(struct ifkalivereq) &
0x1fff) << 16) | ((('i')) << 8) | ((163))):
2163 if (ikar->ikar_timeo < 0 || ikar->ikar_timeo > 86400 ||
2164 ikar->ikar_cnt < 0 || ikar->ikar_cnt > 256 ||
2165 (ikar->ikar_timeo == 0) != (ikar->ikar_cnt == 0))
2166 return (EINVAL22);
2167
2168 if (ikar->ikar_timeo == 0 || ikar->ikar_cnt == 0) {
2169 sc->sc_ka_count = 0;
2170 sc->sc_ka_timeo = 0;
2171 sc->sc_ka_state = GRE_KA_NONE0;
2172 } else {
2173 sc->sc_ka_count = ikar->ikar_cnt;
2174 sc->sc_ka_timeo = ikar->ikar_timeo;
2175 sc->sc_ka_state = GRE_KA_DOWN1;
2176
2177 arc4random_buf(&sc->sc_ka_key, sizeof(sc->sc_ka_key));
2178 sc->sc_ka_bias = arc4random();
2179 sc->sc_ka_holdmax = sc->sc_ka_count;
2180
2181 sc->sc_ka_recvtm = ticks - hz;
2182 timeout_add(&sc->sc_ka_send, 1);
2183 timeout_add_sec(&sc->sc_ka_hold,
2184 sc->sc_ka_timeo * sc->sc_ka_count);
2185 }
2186 break;
2187
2188 case SIOCGETKALIVE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifkalivereq) & 0x1fff) << 16) | ((('i')) <<
8) | ((164))):
2189 ikar->ikar_cnt = sc->sc_ka_count;
2190 ikar->ikar_timeo = sc->sc_ka_timeo;
2191 break;
2192
2193 case SIOCSLIFPHYTTL((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((168))):
2194 if (ifr->ifr_ttlifr_ifru.ifru_metric != -1 &&
2195 (ifr->ifr_ttlifr_ifru.ifru_metric < 1 || ifr->ifr_ttlifr_ifru.ifru_metric > 0xff)) {
2196 error = EINVAL22;
2197 break;
2198 }
2199
2200 /* commit */
2201 sc->sc_tunnel.t_ttl = ifr->ifr_ttlifr_ifru.ifru_metric;
2202 break;
2203
2204 case SIOCGLIFPHYTTL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((169))):
2205 ifr->ifr_ttlifr_ifru.ifru_metric = sc->sc_tunnel.t_ttl;
2206 break;
2207
2208 case SIOCSLIFPHYECN((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((199))):
2209 sc->sc_tunnel.t_ecn =
2210 ifr->ifr_metricifr_ifru.ifru_metric ? ECN_ALLOWED1 : ECN_FORBIDDEN0;
2211 break;
2212 case SIOCGLIFPHYECN(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((200))):
2213 ifr->ifr_metricifr_ifru.ifru_metric = (sc->sc_tunnel.t_ecn == ECN_ALLOWED1);
2214 break;
2215
2216 case SIOCSTXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((197))):
2217 error = if_txhprio_l3_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2218 if (error != 0)
2219 break;
2220
2221 sc->sc_tunnel.t_txhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2222 break;
2223 case SIOCGTXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((198))):
2224 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_txhprio;
2225 break;
2226
2227 case SIOCSRXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((219))):
2228 error = if_rxhprio_l3_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2229 if (error != 0)
2230 break;
2231
2232 sc->sc_tunnel.t_rxhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2233 break;
2234 case SIOCGRXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((219))):
2235 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_rxhprio;
2236 break;
2237
2238 default:
2239 error = gre_tunnel_ioctl(ifp, &sc->sc_tunnel, cmd, data);
2240 break;
2241 }
2242
2243 return (error);
2244}
2245
2246static int
2247mgre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2248{
2249 struct mgre_softc *sc = ifp->if_softc;
2250 struct ifreq *ifr = (struct ifreq *)data;
2251 int error = 0;
2252
2253 switch(cmd) {
2254 case SIOCSIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((12))):
2255 break;
2256 case SIOCSIFFLAGS((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((16))):
2257 if (ISSET(ifp->if_flags, IFF_UP)((ifp->if_flags) & (0x1))) {
2258 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2259 error = mgre_up(sc);
2260 else
2261 error = 0;
2262 } else {
2263 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2264 error = mgre_down(sc);
2265 }
2266 break;
2267
2268 case SIOCSLIFPHYTTL((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((168))):
2269 if (ifr->ifr_ttlifr_ifru.ifru_metric != -1 &&
2270 (ifr->ifr_ttlifr_ifru.ifru_metric < 1 || ifr->ifr_ttlifr_ifru.ifru_metric > 0xff)) {
2271 error = EINVAL22;
2272 break;
2273 }
2274
2275 /* commit */
2276 sc->sc_tunnel.t_ttl = ifr->ifr_ttlifr_ifru.ifru_metric;
2277 break;
2278
2279 case SIOCGLIFPHYTTL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((169))):
2280 ifr->ifr_ttlifr_ifru.ifru_metric = sc->sc_tunnel.t_ttl;
2281 break;
2282
2283 case SIOCSLIFPHYECN((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((199))):
2284 sc->sc_tunnel.t_ecn =
2285 ifr->ifr_metricifr_ifru.ifru_metric ? ECN_ALLOWED1 : ECN_FORBIDDEN0;
2286 break;
2287 case SIOCGLIFPHYECN(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((200))):
2288 ifr->ifr_metricifr_ifru.ifru_metric = (sc->sc_tunnel.t_ecn == ECN_ALLOWED1);
2289 break;
2290
2291 case SIOCSLIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct if_laddrreq) &
0x1fff) << 16) | ((('i')) << 8) | ((74))):
2292 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2293 error = EBUSY16;
2294 break;
2295 }
2296 error = mgre_set_tunnel(sc, (struct if_laddrreq *)data);
2297 break;
2298 case SIOCGLIFPHYADDR(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct if_laddrreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((75))):
2299 error = mgre_get_tunnel(sc, (struct if_laddrreq *)data);
2300 break;
2301
2302 case SIOCSTXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((197))):
2303 error = if_txhprio_l3_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2304 if (error != 0)
2305 break;
2306
2307 sc->sc_tunnel.t_txhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2308 break;
2309 case SIOCGTXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((198))):
2310 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_txhprio;
2311 break;
2312
2313 case SIOCSRXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((219))):
2314 error = if_rxhprio_l3_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2315 if (error != 0)
2316 break;
2317
2318 sc->sc_tunnel.t_rxhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2319 break;
2320 case SIOCGRXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((219))):
2321 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_rxhprio;
2322 break;
2323
2324 case SIOCSVNETID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((166))):
2325 case SIOCDVNETID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((175))):
2326 case SIOCDIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((73))):
2327 case SIOCSLIFPHYRTABLE((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((161))):
2328 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2329 error = EBUSY16;
2330 break;
2331 }
2332
2333 /* FALLTHROUGH */
2334 default:
2335 error = gre_tunnel_ioctl(ifp, &sc->sc_tunnel, cmd, data);
2336 break;
2337 }
2338
2339 return (error);
2340}
2341
2342static int
2343mgre_set_tunnel(struct mgre_softc *sc, struct if_laddrreq *req)
2344{
2345 struct gre_tunnel *tunnel = &sc->sc_tunnel;
2346 struct sockaddr *addr = (struct sockaddr *)&req->addr;
2347 struct sockaddr *dstaddr = (struct sockaddr *)&req->dstaddr;
2348 struct sockaddr_in *addr4;
2349#ifdef INET61
2350 struct sockaddr_in6 *addr6;
2351 int error;
2352#endif
2353
2354 if (dstaddr->sa_family != AF_UNSPEC0)
2355 return (EINVAL22);
2356
2357 /* validate */
2358 switch (addr->sa_family) {
2359 case AF_INET2:
2360 if (addr->sa_len != sizeof(*addr4))
2361 return (EINVAL22);
2362
2363 addr4 = (struct sockaddr_in *)addr;
2364 if (in_nullhost(addr4->sin_addr)((addr4->sin_addr).s_addr == ((u_int32_t) (__uint32_t)(__builtin_constant_p
((u_int32_t)(0x00000000)) ? (__uint32_t)(((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff) << 24 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff00) << 8 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff0000) >> 8 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff000000) >> 24) : __swap32md((u_int32_t
)(0x00000000))))) ||
2365 IN_MULTICAST(addr4->sin_addr.s_addr)(((u_int32_t)(addr4->sin_addr.s_addr) & ((u_int32_t) (
__uint32_t)(__builtin_constant_p((u_int32_t)(0xf0000000)) ? (
__uint32_t)(((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff
) << 24 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff00
) << 8 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff0000
) >> 8 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff000000
) >> 24) : __swap32md((u_int32_t)(0xf0000000))))) == ((
u_int32_t) (__uint32_t)(__builtin_constant_p((u_int32_t)(0xe0000000
)) ? (__uint32_t)(((__uint32_t)((u_int32_t)(0xe0000000)) &
0xff) << 24 | ((__uint32_t)((u_int32_t)(0xe0000000)) &
0xff00) << 8 | ((__uint32_t)((u_int32_t)(0xe0000000)) &
0xff0000) >> 8 | ((__uint32_t)((u_int32_t)(0xe0000000)
) & 0xff000000) >> 24) : __swap32md((u_int32_t)(0xe0000000
))))))
2366 return (EINVAL22);
2367
2368 tunnel->t_src4t_src.in4 = addr4->sin_addr;
2369 tunnel->t_dst4t_dst.in4.s_addr = INADDR_ANY((u_int32_t) (__uint32_t)(__builtin_constant_p((u_int32_t)(0x00000000
)) ? (__uint32_t)(((__uint32_t)((u_int32_t)(0x00000000)) &
0xff) << 24 | ((__uint32_t)((u_int32_t)(0x00000000)) &
0xff00) << 8 | ((__uint32_t)((u_int32_t)(0x00000000)) &
0xff0000) >> 8 | ((__uint32_t)((u_int32_t)(0x00000000)
) & 0xff000000) >> 24) : __swap32md((u_int32_t)(0x00000000
))));
2370
2371 break;
2372#ifdef INET61
2373 case AF_INET624:
2374 if (addr->sa_len != sizeof(*addr6))
2375 return (EINVAL22);
2376
2377 addr6 = (struct sockaddr_in6 *)addr;
2378 if (IN6_IS_ADDR_UNSPECIFIED(&addr6->sin6_addr)((*(const u_int32_t *)(const void *)(&(&addr6->sin6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
*)(const void *)(&(&addr6->sin6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
*)(&(&addr6->sin6_addr)->__u6_addr.__u6_addr8[
8]) == 0) && (*(const u_int32_t *)(const void *)(&
(&addr6->sin6_addr)->__u6_addr.__u6_addr8[12]) == 0
)) ||
2379 IN6_IS_ADDR_MULTICAST(&addr6->sin6_addr)((&addr6->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff
))
2380 return (EINVAL22);
2381
2382 error = in6_embedscope(&tunnel->t_src6t_src.in6, addr6, NULL((void *)0), NULL((void *)0));
2383 if (error != 0)
2384 return (error);
2385
2386 memset(&tunnel->t_dst6, 0, sizeof(tunnel->t_dst6))__builtin_memset((&tunnel->t_dst.in6), (0), (sizeof(tunnel
->t_dst.in6)));
2387
2388 break;
2389#endif
2390 default:
2391 return (EAFNOSUPPORT47);
2392 }
2393
2394 /* commit */
2395 tunnel->t_af = addr->sa_family;
2396
2397 return (0);
2398}
2399
2400static int
2401mgre_get_tunnel(struct mgre_softc *sc, struct if_laddrreq *req)
2402{
2403 struct gre_tunnel *tunnel = &sc->sc_tunnel;
2404 struct sockaddr *dstaddr = (struct sockaddr *)&req->dstaddr;
2405 struct sockaddr_in *sin;
2406#ifdef INET61
2407 struct sockaddr_in6 *sin6;
2408#endif
2409
2410 switch (tunnel->t_af) {
2411 case AF_UNSPEC0:
2412 return (EADDRNOTAVAIL49);
2413 case AF_INET2:
2414 sin = (struct sockaddr_in *)&req->addr;
2415 memset(sin, 0, sizeof(*sin))__builtin_memset((sin), (0), (sizeof(*sin)));
2416 sin->sin_family = AF_INET2;
2417 sin->sin_len = sizeof(*sin);
2418 sin->sin_addr = tunnel->t_src4t_src.in4;
2419 break;
2420
2421#ifdef INET61
2422 case AF_INET624:
2423 sin6 = (struct sockaddr_in6 *)&req->addr;
2424 memset(sin6, 0, sizeof(*sin6))__builtin_memset((sin6), (0), (sizeof(*sin6)));
2425 sin6->sin6_family = AF_INET624;
2426 sin6->sin6_len = sizeof(*sin6);
2427 in6_recoverscope(sin6, &tunnel->t_src6t_src.in6);
2428 break;
2429#endif
2430 default:
2431 unhandled_af(tunnel->t_af);
2432 }
2433
2434 dstaddr->sa_len = 2;
2435 dstaddr->sa_family = AF_UNSPEC0;
2436
2437 return (0);
2438}
2439
2440static int
2441egre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2442{
2443 struct egre_softc *sc = ifp->if_softc;
2444 struct ifreq *ifr = (struct ifreq *)data;
2445 int error = 0;
2446
2447 switch(cmd) {
2448 case SIOCSIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((12))):
2449 break;
2450 case SIOCSIFFLAGS((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((16))):
2451 if (ISSET(ifp->if_flags, IFF_UP)((ifp->if_flags) & (0x1))) {
2452 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2453 error = egre_up(sc);
2454 else
2455 error = 0;
2456 } else {
2457 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2458 error = egre_down(sc);
2459 }
2460 break;
2461
2462 case SIOCSLIFPHYTTL((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((168))):
2463 if (ifr->ifr_ttlifr_ifru.ifru_metric < 1 || ifr->ifr_ttlifr_ifru.ifru_metric > 0xff) {
2464 error = EINVAL22;
2465 break;
2466 }
2467
2468 /* commit */
2469 sc->sc_tunnel.t_ttl = (uint8_t)ifr->ifr_ttlifr_ifru.ifru_metric;
2470 break;
2471
2472 case SIOCGLIFPHYTTL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((169))):
2473 ifr->ifr_ttlifr_ifru.ifru_metric = (int)sc->sc_tunnel.t_ttl;
2474 break;
2475
2476 case SIOCSTXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((197))):
2477 error = if_txhprio_l2_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2478 if (error != 0)
2479 break;
2480
2481 sc->sc_tunnel.t_txhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2482 break;
2483 case SIOCGTXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((198))):
2484 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_txhprio;
2485 break;
2486
2487 case SIOCSRXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((219))):
2488 error = if_rxhprio_l2_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2489 if (error != 0)
2490 break;
2491
2492 sc->sc_tunnel.t_rxhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2493 break;
2494 case SIOCGRXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((219))):
2495 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_rxhprio;
2496 break;
2497
2498 case SIOCSVNETID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((166))):
2499 case SIOCDVNETID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((175))):
2500 case SIOCSVNETFLOWID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((195))):
2501 case SIOCSLIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct if_laddrreq) &
0x1fff) << 16) | ((('i')) << 8) | ((74))):
2502 case SIOCDIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((73))):
2503 case SIOCSLIFPHYRTABLE((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((161))):
2504 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2505 error = EBUSY16;
2506 break;
2507 }
2508
2509 /* FALLTHROUGH */
2510 default:
2511 error = gre_tunnel_ioctl(ifp, &sc->sc_tunnel, cmd, data);
2512 if (error == ENOTTY25)
2513 error = ether_ioctl(ifp, &sc->sc_ac, cmd, data);
2514 break;
2515 }
2516
2517 if (error == ENETRESET52) {
2518 /* no hardware to program */
2519 error = 0;
2520 }
2521
2522 return (error);
2523}
2524
2525static int
2526nvgre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2527{
2528 struct nvgre_softc *sc = ifp->if_softc;
2529 struct gre_tunnel *tunnel = &sc->sc_tunnel;
2530
2531 struct ifreq *ifr = (struct ifreq *)data;
2532 struct if_parent *parent = (struct if_parent *)data;
2533 struct ifbrparam *bparam = (struct ifbrparam *)data;
2534 struct ifnet *ifp0;
2535
2536 int error = 0;
2537
2538 switch (cmd) {
1
Control jumps to 'case 3223349671:' at line 2619
→
2539 case SIOCSIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((12))):
2540 break;
2541 case SIOCSIFFLAGS((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((16))):
2542 if (ISSET(ifp->if_flags, IFF_UP)((ifp->if_flags) & (0x1))) {
2543 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2544 error = nvgre_up(sc);
2545 else
2546 error = ENETRESET52;
2547 } else {
2548 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2549 error = nvgre_down(sc);
2550 }
2551 break;
2552
2553 case SIOCSLIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct if_laddrreq) &
0x1fff) << 16) | ((('i')) << 8) | ((74))):
2554 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2555 error = EBUSY16;
2556 break;
2557 }
2558 error = gre_set_tunnel(tunnel, (struct if_laddrreq *)data, 0);
2559 if (error == 0)
2560 etherbridge_flush(&sc->sc_eb, IFBF_FLUSHALL0x1);
2561 break;
2562 case SIOCGLIFPHYADDR(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct if_laddrreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((75))):
2563 error = gre_get_tunnel(tunnel, (struct if_laddrreq *)data);
2564 break;
2565 case SIOCDIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((73))):
2566 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2567 error = EBUSY16;
2568 break;
2569 }
2570 error = gre_del_tunnel(tunnel);
2571 if (error == 0)
2572 etherbridge_flush(&sc->sc_eb, IFBF_FLUSHALL0x1);
2573 break;
2574
2575 case SIOCSIFPARENT((unsigned long)0x80000000 | ((sizeof(struct if_parent) &
0x1fff) << 16) | ((('i')) << 8) | ((178))):
2576 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2577 error = EBUSY16;
2578 break;
2579 }
2580 error = nvgre_set_parent(sc, parent->ifp_parent);
2581 if (error == 0)
2582 etherbridge_flush(&sc->sc_eb, IFBF_FLUSHALL0x1);
2583 break;
2584 case SIOCGIFPARENT(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct if_parent) & 0x1fff) << 16) | ((('i')) <<
8) | ((179))):
2585 ifp0 = if_get(sc->sc_ifp0);
2586 if (ifp0 == NULL((void *)0))
2587 error = EADDRNOTAVAIL49;
2588 else {
2589 memcpy(parent->ifp_parent, ifp0->if_xname,__builtin_memcpy((parent->ifp_parent), (ifp0->if_xname)
, (sizeof(parent->ifp_parent)))
2590 sizeof(parent->ifp_parent))__builtin_memcpy((parent->ifp_parent), (ifp0->if_xname)
, (sizeof(parent->ifp_parent)));
2591 }
2592 if_put(ifp0);
2593 break;
2594 case SIOCDIFPARENT((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((180))):
2595 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2596 error = EBUSY16;
2597 break;
2598 }
2599 /* commit */
2600 sc->sc_ifp0 = 0;
2601 etherbridge_flush(&sc->sc_eb, IFBF_FLUSHALL0x1);
2602 break;
2603
2604 case SIOCSVNETID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((166))):
2605 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2606 error = EBUSY16;
2607 break;
2608 }
2609 if (ifr->ifr_vnetidifr_ifru.ifru_vnetid < GRE_KEY_ENTROPY_MIN0x00000000U ||
2610 ifr->ifr_vnetidifr_ifru.ifru_vnetid > GRE_KEY_ENTROPY_MAX0x00ffffffU) {
2611 error = EINVAL22;
2612 break;
2613 }
2614
2615 /* commit */
2616 tunnel->t_key = htonl(ifr->ifr_vnetid << GRE_KEY_ENTROPY_SHIFT)(__uint32_t)(__builtin_constant_p(ifr->ifr_ifru.ifru_vnetid
<< 8) ? (__uint32_t)(((__uint32_t)(ifr->ifr_ifru.ifru_vnetid
<< 8) & 0xff) << 24 | ((__uint32_t)(ifr->
ifr_ifru.ifru_vnetid << 8) & 0xff00) << 8 | (
(__uint32_t)(ifr->ifr_ifru.ifru_vnetid << 8) & 0xff0000
) >> 8 | ((__uint32_t)(ifr->ifr_ifru.ifru_vnetid <<
8) & 0xff000000) >> 24) : __swap32md(ifr->ifr_ifru
.ifru_vnetid << 8));
2617 etherbridge_flush(&sc->sc_eb, IFBF_FLUSHALL0x1);
2618 break;
2619 case SIOCGVNETID(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((167))):
2620 error = gre_get_vnetid(tunnel, ifr);
2
←
Calling 'gre_get_vnetid'
→
2621 break;
2622
2623 case SIOCSLIFPHYRTABLE((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((161))):
2624 if (ifr->ifr_rdomainidifr_ifru.ifru_metric < 0 ||
2625 ifr->ifr_rdomainidifr_ifru.ifru_metric > RT_TABLEID_MAX255 ||
2626 !rtable_exists(ifr->ifr_rdomainidifr_ifru.ifru_metric)) {
2627 error = EINVAL22;
2628 break;
2629 }
2630 tunnel->t_rtableid = ifr->ifr_rdomainidifr_ifru.ifru_metric;
2631 etherbridge_flush(&sc->sc_eb, IFBF_FLUSHALL0x1);
2632 break;
2633 case SIOCGLIFPHYRTABLE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((162))):
2634 ifr->ifr_rdomainidifr_ifru.ifru_metric = tunnel->t_rtableid;
2635 break;
2636
2637 case SIOCSLIFPHYDF((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((193))):
2638 /* commit */
2639 tunnel->t_df = ifr->ifr_dfifr_ifru.ifru_metric ? htons(IP_DF)(__uint16_t)(__builtin_constant_p(0x4000) ? (__uint16_t)(((__uint16_t
)(0x4000) & 0xffU) << 8 | ((__uint16_t)(0x4000) &
0xff00U) >> 8) : __swap16md(0x4000)) : htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0));
2640 break;
2641 case SIOCGLIFPHYDF(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((194))):
2642 ifr->ifr_dfifr_ifru.ifru_metric = tunnel->t_df ? 1 : 0;
2643 break;
2644
2645 case SIOCSLIFPHYTTL((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((168))):
2646 if (ifr->ifr_ttlifr_ifru.ifru_metric < 1 || ifr->ifr_ttlifr_ifru.ifru_metric > 0xff) {
2647 error = EINVAL22;
2648 break;
2649 }
2650
2651 /* commit */
2652 tunnel->t_ttl = ifr->ifr_ttlifr_ifru.ifru_metric;
2653 break;
2654
2655 case SIOCGLIFPHYTTL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((169))):
2656 ifr->ifr_ttlifr_ifru.ifru_metric = tunnel->t_ttl;
2657 break;
2658
2659 case SIOCSTXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((197))):
2660 error = if_txhprio_l2_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2661 if (error != 0)
2662 break;
2663
2664 sc->sc_tunnel.t_txhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2665 break;
2666 case SIOCGTXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((198))):
2667 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_txhprio;
2668 break;
2669
2670 case SIOCSRXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((219))):
2671 error = if_rxhprio_l2_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2672 if (error != 0)
2673 break;
2674
2675 sc->sc_tunnel.t_rxhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2676 break;
2677 case SIOCGRXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((219))):
2678 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_rxhprio;
2679 break;
2680
2681 case SIOCBRDGSCACHE((unsigned long)0x80000000 | ((sizeof(struct ifbrparam) &
0x1fff) << 16) | ((('i')) << 8) | ((64))):
2682 error = etherbridge_set_max(&sc->sc_eb, bparam);
2683 break;
2684 case SIOCBRDGGCACHE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifbrparam) & 0x1fff) << 16) | ((('i')) <<
8) | ((65))):
2685 error = etherbridge_get_max(&sc->sc_eb, bparam);
2686 break;
2687
2688 case SIOCBRDGSTO((unsigned long)0x80000000 | ((sizeof(struct ifbrparam) &
0x1fff) << 16) | ((('i')) << 8) | ((69))):
2689 error = etherbridge_set_tmo(&sc->sc_eb, bparam);
2690 break;
2691 case SIOCBRDGGTO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifbrparam) & 0x1fff) << 16) | ((('i')) <<
8) | ((70))):
2692 error = etherbridge_get_tmo(&sc->sc_eb, bparam);
2693 break;
2694
2695 case SIOCBRDGRTS(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifbaconf) & 0x1fff) << 16) | ((('i')) <<
8) | ((67))):
2696 error = etherbridge_rtfind(&sc->sc_eb,
2697 (struct ifbaconf *)data);
2698 break;
2699 case SIOCBRDGFLUSH((unsigned long)0x80000000 | ((sizeof(struct ifbreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((72))):
2700 etherbridge_flush(&sc->sc_eb,
2701 ((struct ifbreq *)data)->ifbr_ifsflags);
2702 break;
2703 case SIOCBRDGSADDR(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifbareq) & 0x1fff) << 16) | ((('i')) <<
8) | ((68))):
2704 error = nvgre_add_addr(sc, (struct ifbareq *)data);
2705 break;
2706 case SIOCBRDGDADDR((unsigned long)0x80000000 | ((sizeof(struct ifbareq) & 0x1fff
) << 16) | ((('i')) << 8) | ((71))):
2707 error = nvgre_del_addr(sc, (struct ifbareq *)data);
2708 break;
2709
2710 case SIOCADDMULTI((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((49))):
2711 case SIOCDELMULTI((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((50))):
2712 break;
2713
2714 default:
2715 error = ether_ioctl(ifp, &sc->sc_ac, cmd, data);
2716 break;
2717 }
2718
2719 if (error == ENETRESET52) {
2720 /* no hardware to program */
2721 error = 0;
2722 }
2723
2724 return (error);
2725}
2726
2727static int
2728eoip_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2729{
2730 struct eoip_softc *sc = ifp->if_softc;
2731 struct ifreq *ifr = (struct ifreq *)data;
2732 struct ifkalivereq *ikar = (struct ifkalivereq *)data;
2733 int error = 0;
2734
2735 switch(cmd) {
2736 case SIOCSIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((12))):
2737 break;
2738 case SIOCSIFFLAGS((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((16))):
2739 if (ISSET(ifp->if_flags, IFF_UP)((ifp->if_flags) & (0x1))) {
2740 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2741 error = eoip_up(sc);
2742 else
2743 error = 0;
2744 } else {
2745 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
2746 error = eoip_down(sc);
2747 }
2748 break;
2749
2750 case SIOCSETKALIVE((unsigned long)0x80000000 | ((sizeof(struct ifkalivereq) &
0x1fff) << 16) | ((('i')) << 8) | ((163))):
2751 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2752 error = EBUSY16;
2753 break;
2754 }
2755
2756 if (ikar->ikar_timeo < 0 || ikar->ikar_timeo > 86400 ||
2757 ikar->ikar_cnt < 0 || ikar->ikar_cnt > 256)
2758 return (EINVAL22);
2759
2760 if (ikar->ikar_timeo == 0 || ikar->ikar_cnt == 0) {
2761 sc->sc_ka_count = 0;
2762 sc->sc_ka_timeo = 0;
2763 sc->sc_ka_state = GRE_KA_NONE0;
2764 } else {
2765 sc->sc_ka_count = ikar->ikar_cnt;
2766 sc->sc_ka_timeo = ikar->ikar_timeo;
2767 sc->sc_ka_state = GRE_KA_DOWN1;
2768 }
2769 break;
2770
2771 case SIOCGETKALIVE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifkalivereq) & 0x1fff) << 16) | ((('i')) <<
8) | ((164))):
2772 ikar->ikar_cnt = sc->sc_ka_count;
2773 ikar->ikar_timeo = sc->sc_ka_timeo;
2774 break;
2775
2776 case SIOCSVNETID((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((166))):
2777 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2778 error = EBUSY16;
2779 break;
2780 }
2781 if (ifr->ifr_vnetidifr_ifru.ifru_vnetid < 0 || ifr->ifr_vnetidifr_ifru.ifru_vnetid > 0xffff)
2782 return (EINVAL22);
2783
2784 sc->sc_tunnel.t_key = htole16(ifr->ifr_vnetid)((__uint16_t)(ifr->ifr_ifru.ifru_vnetid)); /* for cmp */
2785 sc->sc_tunnel_id = htole16(ifr->ifr_vnetid)((__uint16_t)(ifr->ifr_ifru.ifru_vnetid));
2786 break;
2787
2788 case SIOCGVNETID(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((167))):
2789 ifr->ifr_vnetidifr_ifru.ifru_vnetid = letoh16(sc->sc_tunnel_id)((__uint16_t)(sc->sc_tunnel_id));
2790 break;
2791
2792 case SIOCSLIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct if_laddrreq) &
0x1fff) << 16) | ((('i')) << 8) | ((74))):
2793 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2794 error = EBUSY16;
2795 break;
2796 }
2797
2798 error = gre_set_tunnel(&sc->sc_tunnel,
2799 (struct if_laddrreq *)data, 1);
2800 break;
2801 case SIOCGLIFPHYADDR(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct if_laddrreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((75))):
2802 error = gre_get_tunnel(&sc->sc_tunnel,
2803 (struct if_laddrreq *)data);
2804 break;
2805 case SIOCDIFPHYADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((73))):
2806 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2807 error = EBUSY16;
2808 break;
2809 }
2810
2811 error = gre_del_tunnel(&sc->sc_tunnel);
2812 break;
2813
2814 case SIOCSLIFPHYRTABLE((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((161))):
2815 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2816 error = EBUSY16;
2817 break;
2818 }
2819
2820 if (ifr->ifr_rdomainidifr_ifru.ifru_metric < 0 ||
2821 ifr->ifr_rdomainidifr_ifru.ifru_metric > RT_TABLEID_MAX255 ||
2822 !rtable_exists(ifr->ifr_rdomainidifr_ifru.ifru_metric)) {
2823 error = EINVAL22;
2824 break;
2825 }
2826 sc->sc_tunnel.t_rtableid = ifr->ifr_rdomainidifr_ifru.ifru_metric;
2827 break;
2828 case SIOCGLIFPHYRTABLE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((162))):
2829 ifr->ifr_rdomainidifr_ifru.ifru_metric = sc->sc_tunnel.t_rtableid;
2830 break;
2831
2832 case SIOCSLIFPHYTTL((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((168))):
2833 if (ifr->ifr_ttlifr_ifru.ifru_metric < 1 || ifr->ifr_ttlifr_ifru.ifru_metric > 0xff) {
2834 error = EINVAL22;
2835 break;
2836 }
2837
2838 /* commit */
2839 sc->sc_tunnel.t_ttl = (uint8_t)ifr->ifr_ttlifr_ifru.ifru_metric;
2840 break;
2841 case SIOCGLIFPHYTTL(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((169))):
2842 ifr->ifr_ttlifr_ifru.ifru_metric = (int)sc->sc_tunnel.t_ttl;
2843 break;
2844
2845 case SIOCSLIFPHYDF((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((193))):
2846 /* commit */
2847 sc->sc_tunnel.t_df = ifr->ifr_dfifr_ifru.ifru_metric ? htons(IP_DF)(__uint16_t)(__builtin_constant_p(0x4000) ? (__uint16_t)(((__uint16_t
)(0x4000) & 0xffU) << 8 | ((__uint16_t)(0x4000) &
0xff00U) >> 8) : __swap16md(0x4000)) : htons(0)(__uint16_t)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t
)(0) & 0xffU) << 8 | ((__uint16_t)(0) & 0xff00U
) >> 8) : __swap16md(0));
2848 break;
2849 case SIOCGLIFPHYDF(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((194))):
2850 ifr->ifr_dfifr_ifru.ifru_metric = sc->sc_tunnel.t_df ? 1 : 0;
2851 break;
2852
2853 case SIOCSTXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((197))):
2854 error = if_txhprio_l2_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2855 if (error != 0)
2856 break;
2857
2858 sc->sc_tunnel.t_txhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2859 break;
2860 case SIOCGTXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((198))):
2861 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_txhprio;
2862 break;
2863
2864 case SIOCSRXHPRIO((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((219))):
2865 error = if_rxhprio_l2_check(ifr->ifr_hdrprioifr_ifru.ifru_metric);
2866 if (error != 0)
2867 break;
2868
2869 sc->sc_tunnel.t_rxhprio = ifr->ifr_hdrprioifr_ifru.ifru_metric;
2870 break;
2871 case SIOCGRXHPRIO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
8) | ((219))):
2872 ifr->ifr_hdrprioifr_ifru.ifru_metric = sc->sc_tunnel.t_rxhprio;
2873 break;
2874
2875 case SIOCADDMULTI((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((49))):
2876 case SIOCDELMULTI((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff
) << 16) | ((('i')) << 8) | ((50))):
2877 break;
2878
2879 default:
2880 error = ether_ioctl(ifp, &sc->sc_ac, cmd, data);
2881 break;
2882 }
2883
2884 if (error == ENETRESET52) {
2885 /* no hardware to program */
2886 error = 0;
2887 }
2888
2889 return (error);
2890}
2891
2892static int
2893gre_up(struct gre_softc *sc)
2894{
2895 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
2896 SET(sc->sc_if.if_flags, IFF_RUNNING)((sc->sc_if.if_flags) |= (0x40));
2897
2898 if (sc->sc_ka_state != GRE_KA_NONE0)
2899 gre_keepalive_send(sc);
2900
2901 return (0);
2902}
2903
2904static int
2905gre_down(struct gre_softc *sc)
2906{
2907 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
2908 CLR(sc->sc_if.if_flags, IFF_RUNNING)((sc->sc_if.if_flags) &= ~(0x40));
2909
2910 if (sc->sc_ka_state != GRE_KA_NONE0) {
2911 timeout_del_barrier(&sc->sc_ka_hold);
2912 timeout_del_barrier(&sc->sc_ka_send);
2913
2914 sc->sc_ka_state = GRE_KA_DOWN1;
2915 gre_link_state(&sc->sc_if, sc->sc_ka_state);
2916 }
2917
2918 return (0);
2919}
2920
2921static void
2922gre_link_state(struct ifnet *ifp, unsigned int state)
2923{
2924 int link_state = LINK_STATE_UNKNOWN0;
2925
2926 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
2927 switch (state) {
2928 case GRE_KA_NONE0:
2929 /* maybe up? or down? it's unknown, really */
2930 break;
2931 case GRE_KA_UP3:
2932 link_state = LINK_STATE_UP4;
2933 break;
2934 default:
2935 link_state = LINK_STATE_KALIVE_DOWN3;
2936 break;
2937 }
2938 }
2939
2940 if (ifp->if_link_stateif_data.ifi_link_state != link_state) {
2941 ifp->if_link_stateif_data.ifi_link_state = link_state;
2942 if_link_state_change(ifp);
2943 }
2944}
2945
2946static void
2947gre_keepalive_send(void *arg)
2948{
2949 struct gre_tunnel t;
2950 struct gre_softc *sc = arg;
2951 struct mbuf *m;
2952 struct gre_keepalive *gk;
2953 SIPHASH_CTX ctx;
2954 int linkhdr, len;
2955 uint16_t proto;
2956 uint8_t ttl;
2957 uint8_t tos;
2958
2959 /*
2960 * re-schedule immediately, so we deal with incomplete configuration
2961 * or temporary errors.
2962 */
2963 if (sc->sc_ka_timeo)
2964 timeout_add_sec(&sc->sc_ka_send, sc->sc_ka_timeo);
2965
2966 if (!ISSET(sc->sc_if.if_flags, IFF_RUNNING)((sc->sc_if.if_flags) & (0x40)) ||
2967 sc->sc_ka_state == GRE_KA_NONE0 ||
2968 sc->sc_tunnel.t_af == AF_UNSPEC0 ||
2969 sc->sc_tunnel.t_rtableid != sc->sc_if.if_rdomainif_data.ifi_rdomain)
2970 return;
2971
2972 /* this is really conservative */
2973#ifdef INET61
2974 linkhdr = max_linkhdr + MAX(sizeof(struct ip), sizeof(struct ip6_hdr))(((sizeof(struct ip))>(sizeof(struct ip6_hdr)))?(sizeof(struct
ip)):(sizeof(struct ip6_hdr))) +
2975 sizeof(struct gre_header) + sizeof(struct gre_h_key);
2976#else
2977 linkhdr = max_linkhdr + sizeof(struct ip) +
2978 sizeof(struct gre_header) + sizeof(struct gre_h_key);
2979#endif
2980 len = linkhdr + sizeof(*gk);
2981
2982 MGETHDR(m, M_DONTWAIT, MT_DATA)m = m_gethdr((0x0002), (1));
2983 if (m == NULL((void *)0))
2984 return;
2985
2986 if (len > MHLEN((256 - sizeof(struct m_hdr)) - sizeof(struct pkthdr))) {
2987 MCLGETL(m, M_DONTWAIT, len)m_clget((m), (0x0002), (len));
2988 if (!ISSET(m->m_flags, M_EXT)((m->m_hdr.mh_flags) & (0x0001))) {
2989 m_freem(m);
2990 return;
2991 }
2992 }
2993
2994 m->m_pkthdrM_dat.MH.MH_pkthdr.len = m->m_lenm_hdr.mh_len = len;
2995 m_adj(m, linkhdr);
2996
2997 /*
2998 * build the inside packet
2999 */
3000 gk = mtod(m, struct gre_keepalive *)((struct gre_keepalive *)((m)->m_hdr.mh_data));
3001 htobem32(&gk->gk_uptime, sc->sc_ka_bias + ticks)(*(__uint32_t *)(&gk->gk_uptime) = (__uint32_t)(__builtin_constant_p
(sc->sc_ka_bias + ticks) ? (__uint32_t)(((__uint32_t)(sc->
sc_ka_bias + ticks) & 0xff) << 24 | ((__uint32_t)(sc
->sc_ka_bias + ticks) & 0xff00) << 8 | ((__uint32_t
)(sc->sc_ka_bias + ticks) & 0xff0000) >> 8 | ((__uint32_t
)(sc->sc_ka_bias + ticks) & 0xff000000) >> 24) :
__swap32md(sc->sc_ka_bias + ticks)));
3002 htobem32(&gk->gk_random, arc4random())(*(__uint32_t *)(&gk->gk_random) = (__uint32_t)(__builtin_constant_p
(arc4random()) ? (__uint32_t)(((__uint32_t)(arc4random()) &
0xff) << 24 | ((__uint32_t)(arc4random()) & 0xff00
) << 8 | ((__uint32_t)(arc4random()) & 0xff0000) >>
8 | ((__uint32_t)(arc4random()) & 0xff000000) >> 24
) : __swap32md(arc4random())));
3003
3004 SipHash24_Init(&ctx, &sc->sc_ka_key)SipHash_Init((&ctx), (&sc->sc_ka_key));
3005 SipHash24_Update(&ctx, &gk->gk_uptime, sizeof(gk->gk_uptime))SipHash_Update((&ctx), 2, 4, (&gk->gk_uptime), (sizeof
(gk->gk_uptime)));
3006 SipHash24_Update(&ctx, &gk->gk_random, sizeof(gk->gk_random))SipHash_Update((&ctx), 2, 4, (&gk->gk_random), (sizeof
(gk->gk_random)));
3007 SipHash24_Final(gk->gk_digest, &ctx)SipHash_Final((gk->gk_digest), (&ctx), 2, 4);
3008
3009 ttl = sc->sc_tunnel.t_ttl == -1 ? ip_defttl : sc->sc_tunnel.t_ttl;
3010
3011 m->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio = sc->sc_if.if_llprio;
3012 tos = gre_l3_tos(&sc->sc_tunnel, m, IFQ_PRIO2TOS(m->m_pkthdr.pf.prio)((m->M_dat.MH.MH_pkthdr.pf.prio) << 5));
3013
3014 t.t_af = sc->sc_tunnel.t_af;
3015 t.t_df = sc->sc_tunnel.t_df;
3016 t.t_src = sc->sc_tunnel.t_dst;
3017 t.t_dst = sc->sc_tunnel.t_src;
3018 t.t_key = sc->sc_tunnel.t_key;
3019 t.t_key_mask = sc->sc_tunnel.t_key_mask;
3020
3021 m = gre_encap(&t, m, htons(0), ttl, tos)gre_encap_dst((&t), &(&t)->t_dst, (m), ((__uint16_t
)(__builtin_constant_p(0) ? (__uint16_t)(((__uint16_t)(0) &
0xffU) << 8 | ((__uint16_t)(0) & 0xff00U) >>
8) : __swap16md(0))), (ttl), (tos));
3022 if (m == NULL((void *)0))
3023 return;
3024
3025 switch (sc->sc_tunnel.t_af) {
3026 case AF_INET2: {
3027 struct ip *ip;
3028
3029 ip = mtod(m, struct ip *)((struct ip *)((m)->m_hdr.mh_data));
3030 ip->ip_id = htons(ip_randomid())(__uint16_t)(__builtin_constant_p(ip_randomid()) ? (__uint16_t
)(((__uint16_t)(ip_randomid()) & 0xffU) << 8 | ((__uint16_t
)(ip_randomid()) & 0xff00U) >> 8) : __swap16md(ip_randomid
()));
3031 in_hdr_cksum_out(m, NULL((void *)0));
3032
3033 proto = htons(ETHERTYPE_IP)(__uint16_t)(__builtin_constant_p(0x0800) ? (__uint16_t)(((__uint16_t
)(0x0800) & 0xffU) << 8 | ((__uint16_t)(0x0800) &
0xff00U) >> 8) : __swap16md(0x0800));
3034 break;
3035 }
3036#ifdef INET61
3037 case AF_INET624:
3038 proto = htons(ETHERTYPE_IPV6)(__uint16_t)(__builtin_constant_p(0x86DD) ? (__uint16_t)(((__uint16_t
)(0x86DD) & 0xffU) << 8 | ((__uint16_t)(0x86DD) &
0xff00U) >> 8) : __swap16md(0x86DD));
3039 break;
3040#endif
3041 default:
3042 m_freem(m);
3043 return;
3044 }
3045
3046 /*
3047 * put it in the tunnel
3048 */
3049 m = gre_encap(&sc->sc_tunnel, m, proto, ttl, tos)gre_encap_dst((&sc->sc_tunnel), &(&sc->sc_tunnel
)->t_dst, (m), (proto), (ttl), (tos));
3050 if (m == NULL((void *)0))
3051 return;
3052
3053 gre_ip_output(&sc->sc_tunnel, m);
3054}
3055
3056static void
3057gre_keepalive_hold(void *arg)
3058{
3059 struct gre_softc *sc = arg;
3060 struct ifnet *ifp = &sc->sc_if;
3061
3062 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)) ||
3063 sc->sc_ka_state == GRE_KA_NONE0)
3064 return;
3065
3066 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
3067 sc->sc_ka_state = GRE_KA_DOWN1;
3068 gre_link_state(ifp, sc->sc_ka_state);
3069 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
3070}
3071
3072static int
3073gre_set_tunnel(struct gre_tunnel *tunnel, struct if_laddrreq *req, int ucast)
3074{
3075 struct sockaddr *src = (struct sockaddr *)&req->addr;
3076 struct sockaddr *dst = (struct sockaddr *)&req->dstaddr;
3077 struct sockaddr_in *src4, *dst4;
3078#ifdef INET61
3079 struct sockaddr_in6 *src6, *dst6;
3080 int error;
3081#endif
3082
3083 /* sa_family and sa_len must be equal */
3084 if (src->sa_family != dst->sa_family || src->sa_len != dst->sa_len)
3085 return (EINVAL22);
3086
3087 /* validate */
3088 switch (dst->sa_family) {
3089 case AF_INET2:
3090 if (dst->sa_len != sizeof(*dst4))
3091 return (EINVAL22);
3092
3093 src4 = (struct sockaddr_in *)src;
3094 if (in_nullhost(src4->sin_addr)((src4->sin_addr).s_addr == ((u_int32_t) (__uint32_t)(__builtin_constant_p
((u_int32_t)(0x00000000)) ? (__uint32_t)(((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff) << 24 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff00) << 8 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff0000) >> 8 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff000000) >> 24) : __swap32md((u_int32_t
)(0x00000000))))) ||
3095 IN_MULTICAST(src4->sin_addr.s_addr)(((u_int32_t)(src4->sin_addr.s_addr) & ((u_int32_t) (__uint32_t
)(__builtin_constant_p((u_int32_t)(0xf0000000)) ? (__uint32_t
)(((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff) <<
24 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff00) <<
8 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff0000) >>
8 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff000000)
>> 24) : __swap32md((u_int32_t)(0xf0000000))))) == ((u_int32_t
) (__uint32_t)(__builtin_constant_p((u_int32_t)(0xe0000000)) ?
(__uint32_t)(((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff
) << 24 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff00
) << 8 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff0000
) >> 8 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff000000
) >> 24) : __swap32md((u_int32_t)(0xe0000000))))))
3096 return (EINVAL22);
3097
3098 dst4 = (struct sockaddr_in *)dst;
3099 if (in_nullhost(dst4->sin_addr)((dst4->sin_addr).s_addr == ((u_int32_t) (__uint32_t)(__builtin_constant_p
((u_int32_t)(0x00000000)) ? (__uint32_t)(((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff) << 24 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff00) << 8 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff0000) >> 8 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff000000) >> 24) : __swap32md((u_int32_t
)(0x00000000))))) ||
3100 (IN_MULTICAST(dst4->sin_addr.s_addr)(((u_int32_t)(dst4->sin_addr.s_addr) & ((u_int32_t) (__uint32_t
)(__builtin_constant_p((u_int32_t)(0xf0000000)) ? (__uint32_t
)(((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff) <<
24 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff00) <<
8 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff0000) >>
8 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff000000)
>> 24) : __swap32md((u_int32_t)(0xf0000000))))) == ((u_int32_t
) (__uint32_t)(__builtin_constant_p((u_int32_t)(0xe0000000)) ?
(__uint32_t)(((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff
) << 24 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff00
) << 8 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff0000
) >> 8 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff000000
) >> 24) : __swap32md((u_int32_t)(0xe0000000))))) != !ucast))
3101 return (EINVAL22);
3102
3103 tunnel->t_src4t_src.in4 = src4->sin_addr;
3104 tunnel->t_dst4t_dst.in4 = dst4->sin_addr;
3105
3106 break;
3107#ifdef INET61
3108 case AF_INET624:
3109 if (dst->sa_len != sizeof(*dst6))
3110 return (EINVAL22);
3111
3112 src6 = (struct sockaddr_in6 *)src;
3113 if (IN6_IS_ADDR_UNSPECIFIED(&src6->sin6_addr)((*(const u_int32_t *)(const void *)(&(&src6->sin6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
*)(const void *)(&(&src6->sin6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
*)(&(&src6->sin6_addr)->__u6_addr.__u6_addr8[8
]) == 0) && (*(const u_int32_t *)(const void *)(&
(&src6->sin6_addr)->__u6_addr.__u6_addr8[12]) == 0)
) ||
3114 IN6_IS_ADDR_MULTICAST(&src6->sin6_addr)((&src6->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff
))
3115 return (EINVAL22);
3116
3117 dst6 = (struct sockaddr_in6 *)dst;
3118 if (IN6_IS_ADDR_UNSPECIFIED(&dst6->sin6_addr)((*(const u_int32_t *)(const void *)(&(&dst6->sin6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
*)(const void *)(&(&dst6->sin6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
*)(&(&dst6->sin6_addr)->__u6_addr.__u6_addr8[8
]) == 0) && (*(const u_int32_t *)(const void *)(&
(&dst6->sin6_addr)->__u6_addr.__u6_addr8[12]) == 0)
) ||
3119 IN6_IS_ADDR_MULTICAST(&dst6->sin6_addr)((&dst6->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff
) != !ucast)
3120 return (EINVAL22);
3121
3122 if (src6->sin6_scope_id != dst6->sin6_scope_id)
3123 return (EINVAL22);
3124
3125 error = in6_embedscope(&tunnel->t_src6t_src.in6, src6, NULL((void *)0), NULL((void *)0));
3126 if (error != 0)
3127 return (error);
3128
3129 error = in6_embedscope(&tunnel->t_dst6t_dst.in6, dst6, NULL((void *)0), NULL((void *)0));
3130 if (error != 0)
3131 return (error);
3132
3133 break;
3134#endif
3135 default:
3136 return (EAFNOSUPPORT47);
3137 }
3138
3139 /* commit */
3140 tunnel->t_af = dst->sa_family;
3141
3142 return (0);
3143}
3144
3145static int
3146gre_get_tunnel(struct gre_tunnel *tunnel, struct if_laddrreq *req)
3147{
3148 struct sockaddr *src = (struct sockaddr *)&req->addr;
3149 struct sockaddr *dst = (struct sockaddr *)&req->dstaddr;
3150 struct sockaddr_in *sin;
3151#ifdef INET61 /* ifconfig already embeds the scopeid */
3152 struct sockaddr_in6 *sin6;
3153#endif
3154
3155 switch (tunnel->t_af) {
3156 case AF_UNSPEC0:
3157 return (EADDRNOTAVAIL49);
3158 case AF_INET2:
3159 sin = (struct sockaddr_in *)src;
3160 memset(sin, 0, sizeof(*sin))__builtin_memset((sin), (0), (sizeof(*sin)));
3161 sin->sin_family = AF_INET2;
3162 sin->sin_len = sizeof(*sin);
3163 sin->sin_addr = tunnel->t_src4t_src.in4;
3164
3165 sin = (struct sockaddr_in *)dst;
3166 memset(sin, 0, sizeof(*sin))__builtin_memset((sin), (0), (sizeof(*sin)));
3167 sin->sin_family = AF_INET2;
3168 sin->sin_len = sizeof(*sin);
3169 sin->sin_addr = tunnel->t_dst4t_dst.in4;
3170
3171 break;
3172
3173#ifdef INET61
3174 case AF_INET624:
3175 sin6 = (struct sockaddr_in6 *)src;
3176 memset(sin6, 0, sizeof(*sin6))__builtin_memset((sin6), (0), (sizeof(*sin6)));
3177 sin6->sin6_family = AF_INET624;
3178 sin6->sin6_len = sizeof(*sin6);
3179 in6_recoverscope(sin6, &tunnel->t_src6t_src.in6);
3180
3181 sin6 = (struct sockaddr_in6 *)dst;
3182 memset(sin6, 0, sizeof(*sin6))__builtin_memset((sin6), (0), (sizeof(*sin6)));
3183 sin6->sin6_family = AF_INET624;
3184 sin6->sin6_len = sizeof(*sin6);
3185 in6_recoverscope(sin6, &tunnel->t_dst6t_dst.in6);
3186
3187 break;
3188#endif
3189 default:
3190 return (EAFNOSUPPORT47);
3191 }
3192
3193 return (0);
3194}
3195
3196static int
3197gre_del_tunnel(struct gre_tunnel *tunnel)
3198{
3199 /* commit */
3200 tunnel->t_af = AF_UNSPEC0;
3201
3202 return (0);
3203}
3204
3205static int
3206gre_set_vnetid(struct gre_tunnel *tunnel, struct ifreq *ifr)
3207{
3208 uint32_t key;
3209 uint32_t min = GRE_KEY_MIN0x00000000U;
3210 uint32_t max = GRE_KEY_MAX0xffffffffU;
3211 unsigned int shift = GRE_KEY_SHIFT0;
3212 uint32_t mask = GRE_KEY_MASK(__uint32_t)(__builtin_constant_p(0xffffffffU) ? (__uint32_t)
(((__uint32_t)(0xffffffffU) & 0xff) << 24 | ((__uint32_t
)(0xffffffffU) & 0xff00) << 8 | ((__uint32_t)(0xffffffffU
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffffffU) &
0xff000000) >> 24) : __swap32md(0xffffffffU));
3213
3214 if (tunnel->t_key_mask == GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U))) {
3215 min = GRE_KEY_ENTROPY_MIN0x00000000U;
3216 max = GRE_KEY_ENTROPY_MAX0x00ffffffU;
3217 shift = GRE_KEY_ENTROPY_SHIFT8;
3218 mask = GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
3219 }
3220
3221 if (ifr->ifr_vnetidifr_ifru.ifru_vnetid < min || ifr->ifr_vnetidifr_ifru.ifru_vnetid > max)
3222 return (EINVAL22);
3223
3224 key = htonl(ifr->ifr_vnetid << shift)(__uint32_t)(__builtin_constant_p(ifr->ifr_ifru.ifru_vnetid
<< shift) ? (__uint32_t)(((__uint32_t)(ifr->ifr_ifru
.ifru_vnetid << shift) & 0xff) << 24 | ((__uint32_t
)(ifr->ifr_ifru.ifru_vnetid << shift) & 0xff00) <<
8 | ((__uint32_t)(ifr->ifr_ifru.ifru_vnetid << shift
) & 0xff0000) >> 8 | ((__uint32_t)(ifr->ifr_ifru
.ifru_vnetid << shift) & 0xff000000) >> 24) :
__swap32md(ifr->ifr_ifru.ifru_vnetid << shift));
3225
3226 /* commit */
3227 tunnel->t_key_mask = mask;
3228 tunnel->t_key = key;
3229
3230 return (0);
3231}
3232
3233static int
3234gre_get_vnetid(struct gre_tunnel *tunnel, struct ifreq *ifr)
3235{
3236 int shift;
3
←
'shift' declared without an initial value
→
3237
3238 switch (tunnel->t_key_mask) {
3239 case GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U)):
3240 return (EADDRNOTAVAIL49);
3241 case GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U)):
3242 shift = GRE_KEY_ENTROPY_SHIFT8;
3243 break;
3244 case GRE_KEY_MASK(__uint32_t)(__builtin_constant_p(0xffffffffU) ? (__uint32_t)
(((__uint32_t)(0xffffffffU) & 0xff) << 24 | ((__uint32_t
)(0xffffffffU) & 0xff00) << 8 | ((__uint32_t)(0xffffffffU
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffffffU) &
0xff000000) >> 24) : __swap32md(0xffffffffU)):
3245 shift = GRE_KEY_SHIFT0;
3246 break;
3247 }
3248
3249 ifr->ifr_vnetidifr_ifru.ifru_vnetid = ntohl(tunnel->t_key)(__uint32_t)(__builtin_constant_p(tunnel->t_key) ? (__uint32_t
)(((__uint32_t)(tunnel->t_key) & 0xff) << 24 | (
(__uint32_t)(tunnel->t_key) & 0xff00) << 8 | ((__uint32_t
)(tunnel->t_key) & 0xff0000) >> 8 | ((__uint32_t
)(tunnel->t_key) & 0xff000000) >> 24) : __swap32md
(tunnel->t_key)) >> shift;
4
←
'Default' branch taken. Execution continues on line 3249
→
5
←
'?' condition is false
→
6
←
The right operand of '>>' is a garbage value
3250
3251 return (0);
3252}
3253
3254static int
3255gre_del_vnetid(struct gre_tunnel *tunnel)
3256{
3257 tunnel->t_key_mask = GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U));
3258
3259 return (0);
3260}
3261
3262static int
3263gre_set_vnetflowid(struct gre_tunnel *tunnel, struct ifreq *ifr)
3264{
3265 uint32_t mask, key;
3266
3267 if (tunnel->t_key_mask == GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U)))
3268 return (EADDRNOTAVAIL49);
3269
3270 mask = ifr->ifr_vnetidifr_ifru.ifru_vnetid ? GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U)) : GRE_KEY_MASK(__uint32_t)(__builtin_constant_p(0xffffffffU) ? (__uint32_t)
(((__uint32_t)(0xffffffffU) & 0xff) << 24 | ((__uint32_t
)(0xffffffffU) & 0xff00) << 8 | ((__uint32_t)(0xffffffffU
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffffffU) &
0xff000000) >> 24) : __swap32md(0xffffffffU));
3271 if (tunnel->t_key_mask == mask) {
3272 /* nop */
3273 return (0);
3274 }
3275
3276 key = ntohl(tunnel->t_key)(__uint32_t)(__builtin_constant_p(tunnel->t_key) ? (__uint32_t
)(((__uint32_t)(tunnel->t_key) & 0xff) << 24 | (
(__uint32_t)(tunnel->t_key) & 0xff00) << 8 | ((__uint32_t
)(tunnel->t_key) & 0xff0000) >> 8 | ((__uint32_t
)(tunnel->t_key) & 0xff000000) >> 24) : __swap32md
(tunnel->t_key));
3277 if (mask == GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U))) {
3278 if (key > GRE_KEY_ENTROPY_MAX0x00ffffffU)
3279 return (ERANGE34);
3280
3281 key = htonl(key << GRE_KEY_ENTROPY_SHIFT)(__uint32_t)(__builtin_constant_p(key << 8) ? (__uint32_t
)(((__uint32_t)(key << 8) & 0xff) << 24 | ((__uint32_t
)(key << 8) & 0xff00) << 8 | ((__uint32_t)(key
<< 8) & 0xff0000) >> 8 | ((__uint32_t)(key <<
8) & 0xff000000) >> 24) : __swap32md(key << 8
));
3282 } else
3283 key = htonl(key >> GRE_KEY_ENTROPY_SHIFT)(__uint32_t)(__builtin_constant_p(key >> 8) ? (__uint32_t
)(((__uint32_t)(key >> 8) & 0xff) << 24 | ((__uint32_t
)(key >> 8) & 0xff00) << 8 | ((__uint32_t)(key
>> 8) & 0xff0000) >> 8 | ((__uint32_t)(key >>
8) & 0xff000000) >> 24) : __swap32md(key >> 8
));
3284
3285 /* commit */
3286 tunnel->t_key_mask = mask;
3287 tunnel->t_key = key;
3288
3289 return (0);
3290}
3291
3292static int
3293gre_get_vnetflowid(struct gre_tunnel *tunnel, struct ifreq *ifr)
3294{
3295 if (tunnel->t_key_mask == GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U)))
3296 return (EADDRNOTAVAIL49);
3297
3298 ifr->ifr_vnetidifr_ifru.ifru_vnetid = tunnel->t_key_mask == GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
3299
3300 return (0);
3301}
3302
3303static int
3304mgre_up(struct mgre_softc *sc)
3305{
3306 unsigned int hlen;
3307
3308 switch (sc->sc_tunnel.t_af) {
3309 case AF_UNSPEC0:
3310 return (EDESTADDRREQ39);
3311 case AF_INET2:
3312 hlen = sizeof(struct ip);
3313 break;
3314#ifdef INET61
3315 case AF_INET624:
3316 hlen = sizeof(struct ip6_hdr);
3317 break;
3318#endif /* INET6 */
3319 default:
3320 unhandled_af(sc->sc_tunnel.t_af);
3321 }
3322
3323 hlen += sizeof(struct gre_header);
3324 if (sc->sc_tunnel.t_key_mask != GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U)))
3325 hlen += sizeof(struct gre_h_key);
3326
3327 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
3328
3329 if (RBT_INSERT(mgre_tree, &mgre_tree, sc)mgre_tree_RBT_INSERT(&mgre_tree, sc) != NULL((void *)0))
3330 return (EADDRINUSE48);
3331
3332 sc->sc_if.if_hdrlenif_data.ifi_hdrlen = hlen;
3333 SET(sc->sc_if.if_flags, IFF_RUNNING)((sc->sc_if.if_flags) |= (0x40));
3334
3335 return (0);
3336}
3337
3338static int
3339mgre_down(struct mgre_softc *sc)
3340{
3341 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
3342
3343 CLR(sc->sc_if.if_flags, IFF_RUNNING)((sc->sc_if.if_flags) &= ~(0x40));
3344 sc->sc_if.if_hdrlenif_data.ifi_hdrlen = GRE_HDRLEN(sizeof(struct ip) + sizeof(struct gre_header)); /* symmetry */
3345
3346 RBT_REMOVE(mgre_tree, &mgre_tree, sc)mgre_tree_RBT_REMOVE(&mgre_tree, sc);
3347
3348 /* barrier? */
3349
3350 return (0);
3351}
3352
3353static int
3354egre_up(struct egre_softc *sc)
3355{
3356 if (sc->sc_tunnel.t_af == AF_UNSPEC0)
3357 return (EDESTADDRREQ39);
3358
3359 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
3360
3361 if (RBT_INSERT(egre_tree, &egre_tree, sc)egre_tree_RBT_INSERT(&egre_tree, sc) != NULL((void *)0))
3362 return (EADDRINUSE48);
3363
3364 SET(sc->sc_ac.ac_if.if_flags, IFF_RUNNING)((sc->sc_ac.ac_if.if_flags) |= (0x40));
3365
3366 return (0);
3367}
3368
3369static int
3370egre_down(struct egre_softc *sc)
3371{
3372 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
3373
3374 CLR(sc->sc_ac.ac_if.if_flags, IFF_RUNNING)((sc->sc_ac.ac_if.if_flags) &= ~(0x40));
3375
3376 RBT_REMOVE(egre_tree, &egre_tree, sc)egre_tree_RBT_REMOVE(&egre_tree, sc);
3377
3378 /* barrier? */
3379
3380 return (0);
3381}
3382
3383static int
3384egre_media_change(struct ifnet *ifp)
3385{
3386 return (ENOTTY25);
3387}
3388
3389static void
3390egre_media_status(struct ifnet *ifp, struct ifmediareq *imr)
3391{
3392 imr->ifm_active = IFM_ETHER0x0000000000000100ULL | IFM_AUTO0ULL;
3393 imr->ifm_status = IFM_AVALID0x0000000000000001ULL | IFM_ACTIVE0x0000000000000002ULL;
3394}
3395
3396static int
3397nvgre_up(struct nvgre_softc *sc)
3398{
3399 struct gre_tunnel *tunnel = &sc->sc_tunnel;
3400 struct ifnet *ifp0;
3401 void *inm;
3402 int error;
3403
3404 if (tunnel->t_af == AF_UNSPEC0)
3405 return (EDESTADDRREQ39);
3406
3407 ifp0 = if_get(sc->sc_ifp0);
3408 if (ifp0 == NULL((void *)0))
3409 return (ENXIO6);
3410 if (!ISSET(ifp0->if_flags, IFF_MULTICAST)((ifp0->if_flags) & (0x8000))) {
3411 error = ENODEV19;
3412 goto put;
3413 }
3414
3415 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
3416
3417 if (RBT_INSERT(nvgre_mcast_tree, &nvgre_mcast_tree, sc)nvgre_mcast_tree_RBT_INSERT(&nvgre_mcast_tree, sc) != NULL((void *)0)) {
3418 error = EADDRINUSE48;
3419 goto put;
3420 }
3421 if (RBT_INSERT(nvgre_ucast_tree, &nvgre_ucast_tree, sc)nvgre_ucast_tree_RBT_INSERT(&nvgre_ucast_tree, sc) != NULL((void *)0)) {
3422 error = EADDRINUSE48;
3423 goto remove_mcast;
3424 }
3425
3426 switch (tunnel->t_af) {
3427 case AF_INET2:
3428 inm = in_addmulti(&tunnel->t_dst4t_dst.in4, ifp0);
3429 if (inm == NULL((void *)0)) {
3430 error = ECONNABORTED53;
3431 goto remove_ucast;
3432 }
3433 break;
3434#ifdef INET61
3435 case AF_INET624:
3436 inm = in6_addmulti(&tunnel->t_dst6t_dst.in6, ifp0, &error);
3437 if (inm == NULL((void *)0)) {
3438 /* error is already set */
3439 goto remove_ucast;
3440 }
3441 break;
3442#endif /* INET6 */
3443 default:
3444 unhandled_af(tunnel->t_af);
3445 }
3446
3447 if_linkstatehook_add(ifp0, &sc->sc_ltask);
3448 if_detachhook_add(ifp0, &sc->sc_dtask);
3449
3450 if_put(ifp0);
3451
3452 sc->sc_inm = inm;
3453 SET(sc->sc_ac.ac_if.if_flags, IFF_RUNNING)((sc->sc_ac.ac_if.if_flags) |= (0x40));
3454
3455 return (0);
3456
3457remove_ucast:
3458 RBT_REMOVE(nvgre_ucast_tree, &nvgre_ucast_tree, sc)nvgre_ucast_tree_RBT_REMOVE(&nvgre_ucast_tree, sc);
3459remove_mcast:
3460 RBT_REMOVE(nvgre_mcast_tree, &nvgre_mcast_tree, sc)nvgre_mcast_tree_RBT_REMOVE(&nvgre_mcast_tree, sc);
3461put:
3462 if_put(ifp0);
3463 return (error);
3464}
3465
3466static int
3467nvgre_down(struct nvgre_softc *sc)
3468{
3469 struct gre_tunnel *tunnel = &sc->sc_tunnel;
3470 struct ifnet *ifp = &sc->sc_ac.ac_if;
3471 struct taskq *softnet = net_tq(ifp->if_index);
3472 struct ifnet *ifp0;
3473
3474 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
3475
3476 CLR(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) &= ~(0x40));
3477
3478 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
3479 ifq_barrier(&ifp->if_snd);
3480 if (!task_del(softnet, &sc->sc_send_task))
3481 taskq_barrier(softnet);
3482 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
3483
3484 mq_purge(&sc->sc_send_list);
3485
3486 ifp0 = if_get(sc->sc_ifp0);
3487 if (ifp0 != NULL((void *)0)) {
3488 if_detachhook_del(ifp0, &sc->sc_dtask);
3489 if_linkstatehook_del(ifp0, &sc->sc_ltask);
3490 }
3491 if_put(ifp0);
3492
3493 switch (tunnel->t_af) {
3494 case AF_INET2:
3495 in_delmulti(sc->sc_inm);
3496 break;
3497
3498#ifdef INET61
3499 case AF_INET624:
3500 in6_delmulti(sc->sc_inm);
3501 break;
3502#endif
3503 default:
3504 unhandled_af(tunnel->t_af);
3505 }
3506
3507 RBT_REMOVE(nvgre_ucast_tree, &nvgre_ucast_tree, sc)nvgre_ucast_tree_RBT_REMOVE(&nvgre_ucast_tree, sc);
3508 RBT_REMOVE(nvgre_mcast_tree, &nvgre_mcast_tree, sc)nvgre_mcast_tree_RBT_REMOVE(&nvgre_mcast_tree, sc);
3509
3510 return (0);
3511}
3512
3513static void
3514nvgre_link_change(void *arg)
3515{
3516 /* nop */
3517}
3518
3519static void
3520nvgre_detach(void *arg)
3521{
3522 struct nvgre_softc *sc = arg;
3523 struct ifnet *ifp = &sc->sc_ac.ac_if;
3524
3525 if (ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40))) {
3526 nvgre_down(sc);
3527 if_down(ifp);
3528 }
3529
3530 sc->sc_ifp0 = 0;
3531}
3532
3533static int
3534nvgre_set_parent(struct nvgre_softc *sc, const char *parent)
3535{
3536 struct ifnet *ifp0;
3537
3538 ifp0 = if_unit(parent);
3539 if (ifp0 == NULL((void *)0))
3540 return (EINVAL22);
3541
3542 if (!ISSET(ifp0->if_flags, IFF_MULTICAST)((ifp0->if_flags) & (0x8000))) {
3543 if_put(ifp0);
3544 return (EPROTONOSUPPORT43);
3545 }
3546
3547 ifsetlro(ifp0, 0);
3548
3549 /* commit */
3550 sc->sc_ifp0 = ifp0->if_index;
3551 if_put(ifp0);
3552
3553 return (0);
3554}
3555
3556static int
3557nvgre_add_addr(struct nvgre_softc *sc, const struct ifbareq *ifba)
3558{
3559 struct sockaddr_in *sin;
3560#ifdef INET61
3561 struct sockaddr_in6 *sin6;
3562 struct sockaddr_in6 src6 = {
3563 .sin6_len = sizeof(src6),
3564 .sin6_family = AF_UNSPEC0,
3565 };
3566 int error;
3567#endif
3568 union gre_addr endpoint;
3569 unsigned int type;
3570
3571 /* ignore ifba_ifsname */
3572
3573 if (ISSET(ifba->ifba_flags, ~IFBAF_TYPEMASK)((ifba->ifba_flags) & (~0x03)))
3574 return (EINVAL22);
3575 switch (ifba->ifba_flags & IFBAF_TYPEMASK0x03) {
3576 case IFBAF_DYNAMIC0x00:
3577 type = EBE_DYNAMIC0x0;
3578 break;
3579 case IFBAF_STATIC0x01:
3580 type = EBE_STATIC0x1;
3581 break;
3582 default:
3583 return (EINVAL22);
3584 }
3585
3586 memset(&endpoint, 0, sizeof(endpoint))__builtin_memset((&endpoint), (0), (sizeof(endpoint)));
3587
3588 if (ifba->ifba_dstsa.ss_family != sc->sc_tunnel.t_af)
3589 return (EAFNOSUPPORT47);
3590 switch (ifba->ifba_dstsa.ss_family) {
3591 case AF_INET2:
3592 sin = (struct sockaddr_in *)&ifba->ifba_dstsa;
3593 if (in_nullhost(sin->sin_addr)((sin->sin_addr).s_addr == ((u_int32_t) (__uint32_t)(__builtin_constant_p
((u_int32_t)(0x00000000)) ? (__uint32_t)(((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff) << 24 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff00) << 8 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff0000) >> 8 | ((__uint32_t)((u_int32_t
)(0x00000000)) & 0xff000000) >> 24) : __swap32md((u_int32_t
)(0x00000000))))) ||
3594 IN_MULTICAST(sin->sin_addr.s_addr)(((u_int32_t)(sin->sin_addr.s_addr) & ((u_int32_t) (__uint32_t
)(__builtin_constant_p((u_int32_t)(0xf0000000)) ? (__uint32_t
)(((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff) <<
24 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff00) <<
8 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff0000) >>
8 | ((__uint32_t)((u_int32_t)(0xf0000000)) & 0xff000000)
>> 24) : __swap32md((u_int32_t)(0xf0000000))))) == ((u_int32_t
) (__uint32_t)(__builtin_constant_p((u_int32_t)(0xe0000000)) ?
(__uint32_t)(((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff
) << 24 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff00
) << 8 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff0000
) >> 8 | ((__uint32_t)((u_int32_t)(0xe0000000)) & 0xff000000
) >> 24) : __swap32md((u_int32_t)(0xe0000000))))))
3595 return (EADDRNOTAVAIL49);
3596
3597 endpoint.in4 = sin->sin_addr;
3598 break;
3599
3600#ifdef INET61
3601 case AF_INET624:
3602 sin6 = (struct sockaddr_in6 *)&ifba->ifba_dstsa;
3603 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)((*(const u_int32_t *)(const void *)(&(&sin6->sin6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
*)(const void *)(&(&sin6->sin6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
*)(&(&sin6->sin6_addr)->__u6_addr.__u6_addr8[8
]) == 0) && (*(const u_int32_t *)(const void *)(&
(&sin6->sin6_addr)->__u6_addr.__u6_addr8[12]) == 0)
) ||
3604 IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)((&sin6->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff
))
3605 return (EADDRNOTAVAIL49);
3606
3607 in6_recoverscope(&src6, &sc->sc_tunnel.t_src6t_src.in6);
3608
3609 if (src6.sin6_scope_id != sin6->sin6_scope_id)
3610 return (EADDRNOTAVAIL49);
3611
3612 error = in6_embedscope(&endpoint.in6, sin6, NULL((void *)0), NULL((void *)0));
3613 if (error != 0)
3614 return (error);
3615
3616 break;
3617#endif
3618 default: /* AF_UNSPEC */
3619 return (EADDRNOTAVAIL49);
3620 }
3621
3622 return (etherbridge_add_addr(&sc->sc_eb, &endpoint,
3623 &ifba->ifba_dst, type));
3624}
3625
3626static int
3627nvgre_del_addr(struct nvgre_softc *sc, const struct ifbareq *ifba)
3628{
3629 return (etherbridge_del_addr(&sc->sc_eb, &ifba->ifba_dst));
3630}
3631
3632static void
3633nvgre_start(struct ifnet *ifp)
3634{
3635 struct nvgre_softc *sc = ifp->if_softc;
3636 const struct gre_tunnel *tunnel = &sc->sc_tunnel;
3637 union gre_addr gateway;
3638 struct mbuf_list ml = MBUF_LIST_INITIALIZER(){ ((void *)0), ((void *)0), 0 };
3639 struct ether_header *eh;
3640 struct mbuf *m, *m0;
3641#if NBPFILTER1 > 0
3642 caddr_t if_bpf;
3643#endif
3644
3645 if (!gre_allow) {
3646 ifq_purge(&ifp->if_snd);
3647 return;
3648 }
3649
3650 while ((m0 = ifq_dequeue(&ifp->if_snd)) != NULL((void *)0)) {
3651#if NBPFILTER1 > 0
3652 if_bpf = ifp->if_bpf;
3653 if (if_bpf)
3654 bpf_mtap_ether(if_bpf, m0, BPF_DIRECTION_OUT(1 << 1));
3655#endif
3656
3657 eh = mtod(m0, struct ether_header *)((struct ether_header *)((m0)->m_hdr.mh_data));
3658 if (ETHER_IS_BROADCAST(eh->ether_dhost)(((eh->ether_dhost)[0] & (eh->ether_dhost)[1] &
(eh->ether_dhost)[2] & (eh->ether_dhost)[3] & (
eh->ether_dhost)[4] & (eh->ether_dhost)[5]) == 0xff
))
3659 gateway = tunnel->t_dst;
3660 else {
3661 const union gre_addr *endpoint;
3662
3663 smr_read_enter();
3664 endpoint = etherbridge_resolve_ea(&sc->sc_eb,
3665 (struct ether_addr *)eh->ether_dhost);
3666 if (endpoint == NULL((void *)0)) {
3667 /* "flood" to unknown hosts */
3668 endpoint = &tunnel->t_dst;
3669 }
3670 gateway = *endpoint;
3671 smr_read_leave();
3672 }
3673
3674 /* force prepend mbuf because of alignment problems */
3675 m = m_get(M_DONTWAIT0x0002, m0->m_typem_hdr.mh_type);
3676 if (m == NULL((void *)0)) {
3677 m_freem(m0);
3678 continue;
3679 }
3680
3681 M_MOVE_PKTHDR(m, m0)do { (m)->m_hdr.mh_flags = ((m)->m_hdr.mh_flags & (
0x0001 | 0x0008)); (m)->m_hdr.mh_flags |= (m0)->m_hdr.mh_flags
& (0x0002|0x0004|0x0010|0x0100|0x0200|0x0400|0x4000| 0x0800
|0x0040|0x1000|0x8000|0x0020|0x2000); do { ((m))->M_dat.MH
.MH_pkthdr = ((m0))->M_dat.MH.MH_pkthdr; ((m0))->m_hdr.
mh_flags &= ~0x0002; { ((&((m0))->M_dat.MH.MH_pkthdr
.ph_tags)->slh_first) = ((void *)0); }; ((m0))->M_dat.MH
.MH_pkthdr.pf.statekey = ((void *)0); } while ( 0); if (((m)->
m_hdr.mh_flags & 0x0001) == 0) (m)->m_hdr.mh_data = (m
)->M_dat.MH.MH_dat.MH_databuf; } while ( 0);
3682 m->m_nextm_hdr.mh_next = m0;
3683
3684 m_align(m, 0);
3685 m->m_lenm_hdr.mh_len = 0;
3686
3687 m = gre_encap_dst(tunnel, &gateway, m,
3688 htons(ETHERTYPE_TRANSETHER)(__uint16_t)(__builtin_constant_p(0x6558) ? (__uint16_t)(((__uint16_t
)(0x6558) & 0xffU) << 8 | ((__uint16_t)(0x6558) &
0xff00U) >> 8) : __swap16md(0x6558)),
3689 tunnel->t_ttl, gre_l2_tos(tunnel, m));
3690 if (m == NULL((void *)0))
3691 continue;
3692
3693 m->m_flagsm_hdr.mh_flags &= ~(M_BCAST0x0100|M_MCAST0x0200);
3694 m->m_pkthdrM_dat.MH.MH_pkthdr.ph_rtableid = tunnel->t_rtableid;
3695
3696#if NPF1 > 0
3697 pf_pkt_addr_changed(m);
3698#endif
3699
3700 ml_enqueue(&ml, m);
3701 }
3702
3703 if (!ml_empty(&ml)((&ml)->ml_len == 0)) {
3704 if (mq_enlist(&sc->sc_send_list, &ml) == 0)
3705 task_add(net_tq(ifp->if_index), &sc->sc_send_task);
3706 /* else set OACTIVE? */
3707 }
3708}
3709
3710static uint64_t
3711nvgre_send4(struct nvgre_softc *sc, struct mbuf_list *ml)
3712{
3713 struct ip_moptions imo;
3714 struct mbuf *m;
3715 uint64_t oerrors = 0;
3716
3717 imo.imo_ifidx = sc->sc_ifp0;
3718 imo.imo_ttl = sc->sc_tunnel.t_ttl;
3719 imo.imo_loop = 0;
3720
3721 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
3722 while ((m = ml_dequeue(ml)) != NULL((void *)0)) {
3723 if (ip_output(m, NULL((void *)0), NULL((void *)0), IP_RAWOUTPUT0x2, &imo, NULL((void *)0), 0) != 0)
3724 oerrors++;
3725 }
3726 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
3727
3728 return (oerrors);
3729}
3730
3731#ifdef INET61
3732static uint64_t
3733nvgre_send6(struct nvgre_softc *sc, struct mbuf_list *ml)
3734{
3735 struct ip6_moptions im6o;
3736 struct mbuf *m;
3737 uint64_t oerrors = 0;
3738
3739 im6o.im6o_ifidx = sc->sc_ifp0;
3740 im6o.im6o_hlim = sc->sc_tunnel.t_ttl;
3741 im6o.im6o_loop = 0;
3742
3743 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
3744 while ((m = ml_dequeue(ml)) != NULL((void *)0)) {
3745 if (ip6_output(m, NULL((void *)0), NULL((void *)0), 0, &im6o, NULL((void *)0)) != 0)
3746 oerrors++;
3747 }
3748 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
3749
3750 return (oerrors);
3751}
3752#endif /* INET6 */
3753
3754static void
3755nvgre_send(void *arg)
3756{
3757 struct nvgre_softc *sc = arg;
3758 struct ifnet *ifp = &sc->sc_ac.ac_if;
3759 sa_family_t af = sc->sc_tunnel.t_af;
3760 struct mbuf_list ml;
3761 uint64_t oerrors;
3762
3763 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
3764 return;
3765
3766 mq_delist(&sc->sc_send_list, &ml);
3767 if (ml_empty(&ml)((&ml)->ml_len == 0))
3768 return;
3769
3770 switch (af) {
3771 case AF_INET2:
3772 oerrors = nvgre_send4(sc, &ml);
3773 break;
3774#ifdef INET61
3775 case AF_INET624:
3776 oerrors = nvgre_send6(sc, &ml);
3777 break;
3778#endif
3779 default:
3780 unhandled_af(af);
3781 /* NOTREACHED */
3782 }
3783
3784 ifp->if_oerrorsif_data.ifi_oerrors += oerrors; /* XXX should be ifq_oerrors */
3785}
3786
3787static int
3788eoip_up(struct eoip_softc *sc)
3789{
3790 if (sc->sc_tunnel.t_af == AF_UNSPEC0)
3791 return (EDESTADDRREQ39);
3792
3793 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
3794
3795 if (RBT_INSERT(eoip_tree, &eoip_tree, sc)eoip_tree_RBT_INSERT(&eoip_tree, sc) != NULL((void *)0))
3796 return (EADDRINUSE48);
3797
3798 SET(sc->sc_ac.ac_if.if_flags, IFF_RUNNING)((sc->sc_ac.ac_if.if_flags) |= (0x40));
3799
3800 if (sc->sc_ka_state != GRE_KA_NONE0) {
3801 sc->sc_ka_holdmax = sc->sc_ka_count;
3802 eoip_keepalive_send(sc);
3803 }
3804
3805 return (0);
3806}
3807
3808static int
3809eoip_down(struct eoip_softc *sc)
3810{
3811 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
3812 CLR(sc->sc_ac.ac_if.if_flags, IFF_RUNNING)((sc->sc_ac.ac_if.if_flags) &= ~(0x40));
3813
3814 if (sc->sc_ka_state != GRE_KA_NONE0) {
3815 timeout_del_barrier(&sc->sc_ka_hold);
3816 timeout_del_barrier(&sc->sc_ka_send);
3817
3818 sc->sc_ka_state = GRE_KA_DOWN1;
3819 gre_link_state(&sc->sc_ac.ac_if, sc->sc_ka_state);
3820 }
3821
3822 RBT_REMOVE(eoip_tree, &eoip_tree, sc)eoip_tree_RBT_REMOVE(&eoip_tree, sc);
3823
3824 return (0);
3825}
3826
3827static void
3828eoip_start(struct ifnet *ifp)
3829{
3830 struct eoip_softc *sc = ifp->if_softc;
3831 struct mbuf *m0, *m;
3832#if NBPFILTER1 > 0
3833 caddr_t if_bpf;
3834#endif
3835
3836 if (!gre_allow) {
3837 ifq_purge(&ifp->if_snd);
3838 return;
3839 }
3840
3841 while ((m0 = ifq_dequeue(&ifp->if_snd)) != NULL((void *)0)) {
3842#if NBPFILTER1 > 0
3843 if_bpf = ifp->if_bpf;
3844 if (if_bpf)
3845 bpf_mtap_ether(if_bpf, m0, BPF_DIRECTION_OUT(1 << 1));
3846#endif
3847
3848 /* force prepend mbuf because of alignment problems */
3849 m = m_get(M_DONTWAIT0x0002, m0->m_typem_hdr.mh_type);
3850 if (m == NULL((void *)0)) {
3851 m_freem(m0);
3852 continue;
3853 }
3854
3855 M_MOVE_PKTHDR(m, m0)do { (m)->m_hdr.mh_flags = ((m)->m_hdr.mh_flags & (
0x0001 | 0x0008)); (m)->m_hdr.mh_flags |= (m0)->m_hdr.mh_flags
& (0x0002|0x0004|0x0010|0x0100|0x0200|0x0400|0x4000| 0x0800
|0x0040|0x1000|0x8000|0x0020|0x2000); do { ((m))->M_dat.MH
.MH_pkthdr = ((m0))->M_dat.MH.MH_pkthdr; ((m0))->m_hdr.
mh_flags &= ~0x0002; { ((&((m0))->M_dat.MH.MH_pkthdr
.ph_tags)->slh_first) = ((void *)0); }; ((m0))->M_dat.MH
.MH_pkthdr.pf.statekey = ((void *)0); } while ( 0); if (((m)->
m_hdr.mh_flags & 0x0001) == 0) (m)->m_hdr.mh_data = (m
)->M_dat.MH.MH_dat.MH_databuf; } while ( 0);
3856 m->m_nextm_hdr.mh_next = m0;
3857
3858 m_align(m, 0);
3859 m->m_lenm_hdr.mh_len = 0;
3860
3861 m = eoip_encap(sc, m, gre_l2_tos(&sc->sc_tunnel, m));
3862 if (m == NULL((void *)0) || gre_ip_output(&sc->sc_tunnel, m) != 0) {
3863 ifp->if_oerrorsif_data.ifi_oerrors++;
3864 continue;
3865 }
3866 }
3867}
3868
3869static struct mbuf *
3870eoip_encap(struct eoip_softc *sc, struct mbuf *m, uint8_t tos)
3871{
3872 struct gre_header *gh;
3873 struct gre_h_key_eoip *eoiph;
3874 int len = m->m_pkthdrM_dat.MH.MH_pkthdr.len;
3875
3876 m = m_prepend(m, sizeof(*gh) + sizeof(*eoiph), M_DONTWAIT0x0002);
3877 if (m == NULL((void *)0))
3878 return (NULL((void *)0));
3879
3880 gh = mtod(m, struct gre_header *)((struct gre_header *)((m)->m_hdr.mh_data));
3881 gh->gre_flags = htons(GRE_VERS_1 | GRE_KP)(__uint16_t)(__builtin_constant_p(0x0001 | 0x2000) ? (__uint16_t
)(((__uint16_t)(0x0001 | 0x2000) & 0xffU) << 8 | ((
__uint16_t)(0x0001 | 0x2000) & 0xff00U) >> 8) : __swap16md
(0x0001 | 0x2000));
3882 gh->gre_proto = htons(GRE_EOIP)(__uint16_t)(__builtin_constant_p(0x6400) ? (__uint16_t)(((__uint16_t
)(0x6400) & 0xffU) << 8 | ((__uint16_t)(0x6400) &
0xff00U) >> 8) : __swap16md(0x6400));
3883
3884 eoiph = (struct gre_h_key_eoip *)(gh + 1);
3885 htobem16(&eoiph->eoip_len, len)(*(__uint16_t *)(&eoiph->eoip_len) = (__uint16_t)(__builtin_constant_p
(len) ? (__uint16_t)(((__uint16_t)(len) & 0xffU) <<
8 | ((__uint16_t)(len) & 0xff00U) >> 8) : __swap16md
(len)));
3886 eoiph->eoip_tunnel_id = sc->sc_tunnel_id;
3887
3888 return (gre_encap_ip(&sc->sc_tunnel, m, sc->sc_tunnel.t_ttl, tos)gre_encap_dst_ip((&sc->sc_tunnel), &(&sc->sc_tunnel
)->t_dst, (m), (sc->sc_tunnel.t_ttl), (tos)));
3889}
3890
3891static void
3892eoip_keepalive_send(void *arg)
3893{
3894 struct eoip_softc *sc = arg;
3895 struct ifnet *ifp = &sc->sc_ac.ac_if;
3896 struct mbuf *m;
3897 int linkhdr;
3898
3899 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
3900 return;
3901
3902 /* this is really conservative */
3903#ifdef INET61
3904 linkhdr = max_linkhdr + MAX(sizeof(struct ip), sizeof(struct ip6_hdr))(((sizeof(struct ip))>(sizeof(struct ip6_hdr)))?(sizeof(struct
ip)):(sizeof(struct ip6_hdr))) +
3905 sizeof(struct gre_header) + sizeof(struct gre_h_key_eoip);
3906#else
3907 linkhdr = max_linkhdr + sizeof(struct ip) +
3908 sizeof(struct gre_header) + sizeof(struct gre_h_key_eoip);
3909#endif
3910 MGETHDR(m, M_DONTWAIT, MT_DATA)m = m_gethdr((0x0002), (1));
3911 if (m == NULL((void *)0))
3912 return;
3913
3914 if (linkhdr > MHLEN((256 - sizeof(struct m_hdr)) - sizeof(struct pkthdr))) {
3915 MCLGETL(m, M_DONTWAIT, linkhdr)m_clget((m), (0x0002), (linkhdr));
3916 if (!ISSET(m->m_flags, M_EXT)((m->m_hdr.mh_flags) & (0x0001))) {
3917 m_freem(m);
3918 return;
3919 }
3920 }
3921
3922 m->m_pkthdrM_dat.MH.MH_pkthdr.pf.prio = ifp->if_llprio;
3923 m->m_pkthdrM_dat.MH.MH_pkthdr.len = m->m_lenm_hdr.mh_len = linkhdr;
3924 m_adj(m, linkhdr);
3925
3926 m = eoip_encap(sc, m, gre_l2_tos(&sc->sc_tunnel, m));
3927 if (m == NULL((void *)0))
3928 return;
3929
3930 gre_ip_output(&sc->sc_tunnel, m);
3931
3932 timeout_add_sec(&sc->sc_ka_send, sc->sc_ka_timeo);
3933}
3934
3935static void
3936eoip_keepalive_hold(void *arg)
3937{
3938 struct eoip_softc *sc = arg;
3939 struct ifnet *ifp = &sc->sc_ac.ac_if;
3940
3941 if (!ISSET(ifp->if_flags, IFF_RUNNING)((ifp->if_flags) & (0x40)))
3942 return;
3943
3944 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
3945 sc->sc_ka_state = GRE_KA_DOWN1;
3946 gre_link_state(ifp, sc->sc_ka_state);
3947 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
3948}
3949
3950static void
3951eoip_keepalive_recv(struct eoip_softc *sc)
3952{
3953 switch (sc->sc_ka_state) {
3954 case GRE_KA_NONE0:
3955 return;
3956 case GRE_KA_DOWN1:
3957 sc->sc_ka_state = GRE_KA_HOLD2;
3958 sc->sc_ka_holdcnt = sc->sc_ka_holdmax;
3959 sc->sc_ka_holdmax = MIN(sc->sc_ka_holdmax * 2,(((sc->sc_ka_holdmax * 2)<(16 * sc->sc_ka_count))?(sc
->sc_ka_holdmax * 2):(16 * sc->sc_ka_count))
3960 16 * sc->sc_ka_count)(((sc->sc_ka_holdmax * 2)<(16 * sc->sc_ka_count))?(sc
->sc_ka_holdmax * 2):(16 * sc->sc_ka_count));
3961 break;
3962 case GRE_KA_HOLD2:
3963 if (--sc->sc_ka_holdcnt > 0)
3964 break;
3965
3966 sc->sc_ka_state = GRE_KA_UP3;
3967 gre_link_state(&sc->sc_ac.ac_if, sc->sc_ka_state);
3968 break;
3969
3970 case GRE_KA_UP3:
3971 sc->sc_ka_holdmax--;
3972 sc->sc_ka_holdmax = MAX(sc->sc_ka_holdmax, sc->sc_ka_count)(((sc->sc_ka_holdmax)>(sc->sc_ka_count))?(sc->sc_ka_holdmax
):(sc->sc_ka_count));
3973 break;
3974 }
3975
3976 timeout_add_sec(&sc->sc_ka_hold, sc->sc_ka_timeo * sc->sc_ka_count);
3977}
3978
3979static struct mbuf *
3980eoip_input(struct gre_tunnel *key, struct mbuf *m,
3981 const struct gre_header *gh, uint8_t otos, int iphlen)
3982{
3983 struct eoip_softc *sc;
3984 struct gre_h_key_eoip *eoiph;
3985 int hlen, len;
3986 caddr_t buf;
3987
3988 if (gh->gre_flags != htons(GRE_KP | GRE_VERS_1)(__uint16_t)(__builtin_constant_p(0x2000 | 0x0001) ? (__uint16_t
)(((__uint16_t)(0x2000 | 0x0001) & 0xffU) << 8 | ((
__uint16_t)(0x2000 | 0x0001) & 0xff00U) >> 8) : __swap16md
(0x2000 | 0x0001)))
3989 goto decline;
3990
3991 hlen = iphlen + sizeof(*gh) + sizeof(*eoiph);
3992 if (m->m_pkthdrM_dat.MH.MH_pkthdr.len < hlen)
3993 goto decline;
3994
3995 m = m_pullup(m, hlen);
3996 if (m == NULL((void *)0))
3997 return (NULL((void *)0));
3998
3999 buf = mtod(m, caddr_t)((caddr_t)((m)->m_hdr.mh_data));
4000 gh = (struct gre_header *)(buf + iphlen);
4001 eoiph = (struct gre_h_key_eoip *)(gh + 1);
4002
4003 key->t_key = eoiph->eoip_tunnel_id;
4004
4005 NET_ASSERT_LOCKED()do { int _s = rw_status(&netlock); if ((splassert_ctl >
0) && (_s != 0x0001UL && _s != 0x0002UL)) splassert_fail
(0x0002UL, _s, __func__); } while (0);
4006 sc = RBT_FIND(eoip_tree, &eoip_tree, (const struct eoip_softc *)key)eoip_tree_RBT_FIND(&eoip_tree, (const struct eoip_softc *
)key);
4007 if (sc == NULL((void *)0))
4008 goto decline;
4009
4010 /* it's ours now */
4011 len = bemtoh16(&eoiph->eoip_len)(__uint16_t)(__builtin_constant_p(*(__uint16_t *)(&eoiph->
eoip_len)) ? (__uint16_t)(((__uint16_t)(*(__uint16_t *)(&
eoiph->eoip_len)) & 0xffU) << 8 | ((__uint16_t)(
*(__uint16_t *)(&eoiph->eoip_len)) & 0xff00U) >>
8) : __swap16md(*(__uint16_t *)(&eoiph->eoip_len)));
4012 if (len == 0) {
4013 eoip_keepalive_recv(sc);
4014 goto drop;
4015 }
4016
4017 m = gre_ether_align(m, hlen);
4018 if (m == NULL((void *)0))
4019 return (NULL((void *)0));
4020
4021 if (m->m_pkthdrM_dat.MH.MH_pkthdr.len < len)
4022 goto drop;
4023 if (m->m_pkthdrM_dat.MH.MH_pkthdr.len != len)
4024 m_adj(m, len - m->m_pkthdrM_dat.MH.MH_pkthdr.len);
4025
4026 m->m_flagsm_hdr.mh_flags &= ~(M_MCAST0x0200|M_BCAST0x0100);
4027
4028 gre_l2_prio(&sc->sc_tunnel, m, otos)do { int rxprio = (&sc->sc_tunnel)->t_rxhprio; switch
(rxprio) { case -1: break; case -3: (m)->M_dat.MH.MH_pkthdr
.pf.prio = (((otos)) >> 5); break; default: (m)->M_dat
.MH.MH_pkthdr.pf.prio = rxprio; break; } } while (0);
4029
4030 if_vinput(&sc->sc_ac.ac_if, m);
4031
4032 return (NULL((void *)0));
4033
4034decline:
4035 return (m);
4036drop:
4037 m_freem(m);
4038 return (NULL((void *)0));
4039}
4040
4041const struct sysctl_bounded_args gre_vars[] = {
4042 { GRECTL_ALLOW1, &gre_allow, 0, 1 },
4043 { GRECTL_WCCP2, &gre_wccp, 0, 1 },
4044};
4045
4046int
4047gre_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
4048 size_t newlen)
4049{
4050 int error;
4051
4052 NET_LOCK()do { rw_enter_write(&netlock); } while (0);
4053 error = sysctl_bounded_arr(gre_vars, nitems(gre_vars)(sizeof((gre_vars)) / sizeof((gre_vars)[0])), name,
4054 namelen, oldp, oldlenp, newp, newlen);
4055 NET_UNLOCK()do { rw_exit_write(&netlock); } while (0);
4056 return error;
4057}
4058
4059static inline int
4060gre_ip_cmp(int af, const union gre_addr *a, const union gre_addr *b)
4061{
4062 switch (af) {
4063#ifdef INET61
4064 case AF_INET624:
4065 return (memcmp(&a->in6, &b->in6, sizeof(a->in6))__builtin_memcmp((&a->in6), (&b->in6), (sizeof(
a->in6))));
4066#endif /* INET6 */
4067 case AF_INET2:
4068 return (memcmp(&a->in4, &b->in4, sizeof(a->in4))__builtin_memcmp((&a->in4), (&b->in4), (sizeof(
a->in4))));
4069 default:
4070 unhandled_af(af);
4071 }
4072
4073 return (0);
4074}
4075
4076static int
4077gre_cmp_src(const struct gre_tunnel *a, const struct gre_tunnel *b)
4078{
4079 uint32_t ka, kb;
4080 uint32_t mask;
4081 int rv;
4082
4083 /* is K set at all? */
4084 ka = a->t_key_mask & GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
4085 kb = b->t_key_mask & GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
4086
4087 /* sort by whether K is set */
4088 if (ka > kb)
4089 return (1);
4090 if (ka < kb)
4091 return (-1);
4092
4093 /* is K set on both? */
4094 if (ka != GRE_KEY_NONE(__uint32_t)(__builtin_constant_p(0x00000000U) ? (__uint32_t)
(((__uint32_t)(0x00000000U) & 0xff) << 24 | ((__uint32_t
)(0x00000000U) & 0xff00) << 8 | ((__uint32_t)(0x00000000U
) & 0xff0000) >> 8 | ((__uint32_t)(0x00000000U) &
0xff000000) >> 24) : __swap32md(0x00000000U))) {
4095 /* get common prefix */
4096 mask = a->t_key_mask & b->t_key_mask;
4097
4098 ka = a->t_key & mask;
4099 kb = b->t_key & mask;
4100
4101 /* sort by common prefix */
4102 if (ka > kb)
4103 return (1);
4104 if (ka < kb)
4105 return (-1);
4106 }
4107
4108 /* sort by routing table */
4109 if (a->t_rtableid > b->t_rtableid)
4110 return (1);
4111 if (a->t_rtableid < b->t_rtableid)
4112 return (-1);
4113
4114 /* sort by address */
4115 if (a->t_af > b->t_af)
4116 return (1);
4117 if (a->t_af < b->t_af)
4118 return (-1);
4119
4120 rv = gre_ip_cmp(a->t_af, &a->t_src, &b->t_src);
4121 if (rv != 0)
4122 return (rv);
4123
4124 return (0);
4125}
4126
4127static int
4128gre_cmp(const struct gre_tunnel *a, const struct gre_tunnel *b)
4129{
4130 int rv;
4131
4132 rv = gre_cmp_src(a, b);
4133 if (rv != 0)
4134 return (rv);
4135
4136 return (gre_ip_cmp(a->t_af, &a->t_dst, &b->t_dst));
4137}
4138
4139static inline int
4140mgre_cmp(const struct mgre_softc *a, const struct mgre_softc *b)
4141{
4142 return (gre_cmp_src(&a->sc_tunnel, &b->sc_tunnel));
4143}
4144
4145RBT_GENERATE(mgre_tree, mgre_softc, sc_entry, mgre_cmp)static int mgre_tree_RBT_COMPARE(const void *lptr, const void
*rptr) { const struct mgre_softc *l = lptr, *r = rptr; return
mgre_cmp(l, r); } static const struct rb_type mgre_tree_RBT_INFO
= { mgre_tree_RBT_COMPARE, ((void *)0), __builtin_offsetof(struct
mgre_softc, sc_entry), }; const struct rb_type *const mgre_tree_RBT_TYPE
= &mgre_tree_RBT_INFO;
4146
4147static inline int
4148egre_cmp(const struct egre_softc *a, const struct egre_softc *b)
4149{
4150 return (gre_cmp(&a->sc_tunnel, &b->sc_tunnel));
4151}
4152
4153RBT_GENERATE(egre_tree, egre_softc, sc_entry, egre_cmp)static int egre_tree_RBT_COMPARE(const void *lptr, const void
*rptr) { const struct egre_softc *l = lptr, *r = rptr; return
egre_cmp(l, r); } static const struct rb_type egre_tree_RBT_INFO
= { egre_tree_RBT_COMPARE, ((void *)0), __builtin_offsetof(struct
egre_softc, sc_entry), }; const struct rb_type *const egre_tree_RBT_TYPE
= &egre_tree_RBT_INFO;
4154
4155static int
4156nvgre_cmp_tunnel(const struct gre_tunnel *a, const struct gre_tunnel *b)
4157{
4158 uint32_t ka, kb;
4159
4160 ka = a->t_key & GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
4161 kb = b->t_key & GRE_KEY_ENTROPY(__uint32_t)(__builtin_constant_p(0xffffff00U) ? (__uint32_t)
(((__uint32_t)(0xffffff00U) & 0xff) << 24 | ((__uint32_t
)(0xffffff00U) & 0xff00) << 8 | ((__uint32_t)(0xffffff00U
) & 0xff0000) >> 8 | ((__uint32_t)(0xffffff00U) &
0xff000000) >> 24) : __swap32md(0xffffff00U));
4162
4163 /* sort by common prefix */
4164 if (ka > kb)
4165 return (1);
4166 if (ka < kb)
4167 return (-1);
4168
4169 /* sort by routing table */
4170 if (a->t_rtableid > b->t_rtableid)
4171 return (1);
4172 if (a->t_rtableid < b->t_rtableid)
4173 return (-1);
4174
4175 /* sort by address */
4176 if (a->t_af > b->t_af)
4177 return (1);
4178 if (a->t_af < b->t_af)
4179 return (-1);
4180
4181 return (0);
4182}
4183
4184static inline int
4185nvgre_cmp_ucast(const struct nvgre_softc *na, const struct nvgre_softc *nb)
4186{
4187 const struct gre_tunnel *a = &na->sc_tunnel;
4188 const struct gre_tunnel *b = &nb->sc_tunnel;
4189 int rv;
4190
4191 rv = nvgre_cmp_tunnel(a, b);
4192 if (rv != 0)
4193 return (rv);
4194
4195 rv = gre_ip_cmp(a->t_af, &a->t_src, &b->t_src);
4196 if (rv != 0)
4197 return (rv);
4198
4199 return (0);
4200}
4201
4202static int
4203nvgre_cmp_mcast(const struct gre_tunnel *a, const union gre_addr *aa,
4204 unsigned int if0idxa, const struct gre_tunnel *b,
4205 const union gre_addr *ab,unsigned int if0idxb)
4206{
4207 int rv;
4208
4209 rv = nvgre_cmp_tunnel(a, b);
4210 if (rv != 0)
4211 return (rv);
4212
4213 rv = gre_ip_cmp(a->t_af, aa, ab);
4214 if (rv != 0)
4215 return (rv);
4216
4217 if (if0idxa > if0idxb)
4218 return (1);
4219 if (if0idxa < if0idxb)
4220 return (-1);
4221
4222 return (0);
4223}
4224
4225static inline int
4226nvgre_cmp_mcast_sc(const struct nvgre_softc *na, const struct nvgre_softc *nb)
4227{
4228 const struct gre_tunnel *a = &na->sc_tunnel;
4229 const struct gre_tunnel *b = &nb->sc_tunnel;
4230
4231 return (nvgre_cmp_mcast(a, &a->t_dst, na->sc_ifp0,
4232 b, &b->t_dst, nb->sc_ifp0));
4233}
4234
4235RBT_GENERATE(nvgre_ucast_tree, nvgre_softc, sc_uentry, nvgre_cmp_ucast)static int nvgre_ucast_tree_RBT_COMPARE(const void *lptr, const
void *rptr) { const struct nvgre_softc *l = lptr, *r = rptr;
return nvgre_cmp_ucast(l, r); } static const struct rb_type nvgre_ucast_tree_RBT_INFO
= { nvgre_ucast_tree_RBT_COMPARE, ((void *)0), __builtin_offsetof
(struct nvgre_softc, sc_uentry), }; const struct rb_type *const
nvgre_ucast_tree_RBT_TYPE = &nvgre_ucast_tree_RBT_INFO;
4236RBT_GENERATE(nvgre_mcast_tree, nvgre_softc, sc_mentry, nvgre_cmp_mcast_sc)static int nvgre_mcast_tree_RBT_COMPARE(const void *lptr, const
void *rptr) { const struct nvgre_softc *l = lptr, *r = rptr;
return nvgre_cmp_mcast_sc(l, r); } static const struct rb_type
nvgre_mcast_tree_RBT_INFO = { nvgre_mcast_tree_RBT_COMPARE, (
(void *)0), __builtin_offsetof(struct nvgre_softc, sc_mentry)
, }; const struct rb_type *const nvgre_mcast_tree_RBT_TYPE = &
nvgre_mcast_tree_RBT_INFO;
4237
4238static inline int
4239eoip_cmp(const struct eoip_softc *ea, const struct eoip_softc *eb)
4240{
4241 const struct gre_tunnel *a = &ea->sc_tunnel;
4242 const struct gre_tunnel *b = &eb->sc_tunnel;
4243 int rv;
4244
4245 if (a->t_key > b->t_key)
4246 return (1);
4247 if (a->t_key < b->t_key)
4248 return (-1);
4249
4250 /* sort by routing table */
4251 if (a->t_rtableid > b->t_rtableid)
4252 return (1);
4253 if (a->t_rtableid < b->t_rtableid)
4254 return (-1);
4255
4256 /* sort by address */
4257 if (a->t_af > b->t_af)
4258 return (1);
4259 if (a->t_af < b->t_af)
4260 return (-1);
4261
4262 rv = gre_ip_cmp(a->t_af, &a->t_src, &b->t_src);
4263 if (rv != 0)
4264 return (rv);
4265
4266 rv = gre_ip_cmp(a->t_af, &a->t_dst, &b->t_dst);
4267 if (rv != 0)
4268 return (rv);
4269
4270 return (0);
4271}
4272
4273RBT_GENERATE(eoip_tree, eoip_softc, sc_entry, eoip_cmp)static int eoip_tree_RBT_COMPARE(const void *lptr, const void
*rptr) { const struct eoip_softc *l = lptr, *r = rptr; return
eoip_cmp(l, r); } static const struct rb_type eoip_tree_RBT_INFO
= { eoip_tree_RBT_COMPARE, ((void *)0), __builtin_offsetof(struct
eoip_softc, sc_entry), }; const struct rb_type *const eoip_tree_RBT_TYPE
= &eoip_tree_RBT_INFO;
4274
4275static int
4276nvgre_eb_port_eq(void *arg, void *a, void *b)
4277{
4278 struct nvgre_softc *sc = arg;
4279
4280 return (gre_ip_cmp(sc->sc_tunnel.t_af, a, b) == 0);
4281}
4282
4283static void *
4284nvgre_eb_port_take(void *arg, void *port)
4285{
4286 union gre_addr *ea = port;
4287 union gre_addr *endpoint;
4288
4289 endpoint = pool_get(&nvgre_endpoint_pool, PR_NOWAIT0x0002);
4290 if (endpoint == NULL((void *)0))
4291 return (NULL((void *)0));
4292
4293 *endpoint = *ea;
4294
4295 return (endpoint);
4296}
4297
4298static void
4299nvgre_eb_port_rele(void *arg, void *port)
4300{
4301 union gre_addr *endpoint = port;
4302
4303 pool_put(&nvgre_endpoint_pool, endpoint);
4304}
4305
4306static size_t
4307nvgre_eb_port_ifname(void *arg, char *dst, size_t len, void *port)
4308{
4309 struct nvgre_softc *sc = arg;
4310
4311 return (strlcpy(dst, sc->sc_ac.ac_if.if_xname, len));
4312}
4313
4314static void
4315nvgre_eb_port_sa(void *arg, struct sockaddr_storage *ss, void *port)
4316{
4317 struct nvgre_softc *sc = arg;
4318 union gre_addr *endpoint = port;
4319
4320 switch (sc->sc_tunnel.t_af) {
4321 case AF_INET2: {
4322 struct sockaddr_in *sin = (struct sockaddr_in *)ss;
4323
4324 sin->sin_len = sizeof(*sin);
4325 sin->sin_family = AF_INET2;
4326 sin->sin_addr = endpoint->in4;
4327 break;
4328 }
4329#ifdef INET61
4330 case AF_INET624: {
4331 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ss;
4332
4333 sin6->sin6_len = sizeof(*sin6);
4334 sin6->sin6_family = AF_INET624;
4335 in6_recoverscope(sin6, &endpoint->in6);
4336
4337 break;
4338 }
4339#endif /* INET6 */
4340 default:
4341 unhandled_af(sc->sc_tunnel.t_af);
4342 }
4343}