FreeBSD/Linux Kernel Cross Reference
sys/net/if_gif.c
1 /*-
2 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the project nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $KAME: if_gif.c,v 1.87 2001/10/19 08:50:27 itojun Exp $
30 */
31
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD: releng/10.3/sys/net/if_gif.c 293411 2016-01-08 02:59:56Z araujo $");
34
35 #include "opt_inet.h"
36 #include "opt_inet6.h"
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/jail.h>
41 #include <sys/kernel.h>
42 #include <sys/lock.h>
43 #include <sys/malloc.h>
44 #include <sys/mbuf.h>
45 #include <sys/module.h>
46 #include <sys/rmlock.h>
47 #include <sys/socket.h>
48 #include <sys/sockio.h>
49 #include <sys/sx.h>
50 #include <sys/errno.h>
51 #include <sys/time.h>
52 #include <sys/sysctl.h>
53 #include <sys/syslog.h>
54 #include <sys/priv.h>
55 #include <sys/proc.h>
56 #include <sys/protosw.h>
57 #include <sys/conf.h>
58 #include <machine/cpu.h>
59
60 #include <net/if.h>
61 #include <net/if_var.h>
62 #include <net/if_clone.h>
63 #include <net/if_types.h>
64 #include <net/netisr.h>
65 #include <net/route.h>
66 #include <net/bpf.h>
67 #include <net/vnet.h>
68
69 #include <netinet/in.h>
70 #include <netinet/in_systm.h>
71 #include <netinet/ip.h>
72 #include <netinet/ip_ecn.h>
73 #ifdef INET
74 #include <netinet/in_var.h>
75 #include <netinet/ip_var.h>
76 #endif /* INET */
77
78 #ifdef INET6
79 #ifndef INET
80 #include <netinet/in.h>
81 #endif
82 #include <netinet6/in6_var.h>
83 #include <netinet/ip6.h>
84 #include <netinet6/ip6_ecn.h>
85 #include <netinet6/ip6_var.h>
86 #include <netinet6/scope6_var.h>
87 #include <netinet6/ip6protosw.h>
88 #endif /* INET6 */
89
90 #include <netinet/ip_encap.h>
91 #include <net/ethernet.h>
92 #include <net/if_bridgevar.h>
93 #include <net/if_gif.h>
94
95 #include <security/mac/mac_framework.h>
96
97 static const char gifname[] = "gif";
98
99 /*
100 * gif_mtx protects a per-vnet gif_softc_list.
101 */
102 static VNET_DEFINE(struct mtx, gif_mtx);
103 #define V_gif_mtx VNET(gif_mtx)
104 static MALLOC_DEFINE(M_GIF, "gif", "Generic Tunnel Interface");
105 static VNET_DEFINE(LIST_HEAD(, gif_softc), gif_softc_list);
106 #define V_gif_softc_list VNET(gif_softc_list)
107 static struct sx gif_ioctl_sx;
108 SX_SYSINIT(gif_ioctl_sx, &gif_ioctl_sx, "gif_ioctl");
109
110 #define GIF_LIST_LOCK_INIT(x) mtx_init(&V_gif_mtx, "gif_mtx", \
111 NULL, MTX_DEF)
112 #define GIF_LIST_LOCK_DESTROY(x) mtx_destroy(&V_gif_mtx)
113 #define GIF_LIST_LOCK(x) mtx_lock(&V_gif_mtx)
114 #define GIF_LIST_UNLOCK(x) mtx_unlock(&V_gif_mtx)
115
116 void (*ng_gif_input_p)(struct ifnet *ifp, struct mbuf **mp, int af);
117 void (*ng_gif_input_orphan_p)(struct ifnet *ifp, struct mbuf *m, int af);
118 void (*ng_gif_attach_p)(struct ifnet *ifp);
119 void (*ng_gif_detach_p)(struct ifnet *ifp);
120
121 static int gif_check_nesting(struct ifnet *, struct mbuf *);
122 static int gif_set_tunnel(struct ifnet *, struct sockaddr *,
123 struct sockaddr *);
124 static void gif_delete_tunnel(struct ifnet *);
125 static int gif_ioctl(struct ifnet *, u_long, caddr_t);
126 static int gif_transmit(struct ifnet *, struct mbuf *);
127 static void gif_qflush(struct ifnet *);
128 static int gif_clone_create(struct if_clone *, int, caddr_t);
129 static void gif_clone_destroy(struct ifnet *);
130 static VNET_DEFINE(struct if_clone *, gif_cloner);
131 #define V_gif_cloner VNET(gif_cloner)
132
133 static int gifmodevent(module_t, int, void *);
134
135 SYSCTL_DECL(_net_link);
136 static SYSCTL_NODE(_net_link, IFT_GIF, gif, CTLFLAG_RW, 0,
137 "Generic Tunnel Interface");
138 #ifndef MAX_GIF_NEST
139 /*
140 * This macro controls the default upper limitation on nesting of gif tunnels.
141 * Since, setting a large value to this macro with a careless configuration
142 * may introduce system crash, we don't allow any nestings by default.
143 * If you need to configure nested gif tunnels, you can define this macro
144 * in your kernel configuration file. However, if you do so, please be
145 * careful to configure the tunnels so that it won't make a loop.
146 */
147 #define MAX_GIF_NEST 1
148 #endif
149 static VNET_DEFINE(int, max_gif_nesting) = MAX_GIF_NEST;
150 #define V_max_gif_nesting VNET(max_gif_nesting)
151 SYSCTL_VNET_INT(_net_link_gif, OID_AUTO, max_nesting, CTLFLAG_RW,
152 &VNET_NAME(max_gif_nesting), 0, "Max nested tunnels");
153
154 /*
155 * By default, we disallow creation of multiple tunnels between the same
156 * pair of addresses. Some applications require this functionality so
157 * we allow control over this check here.
158 */
159 #ifdef XBONEHACK
160 static VNET_DEFINE(int, parallel_tunnels) = 1;
161 #else
162 static VNET_DEFINE(int, parallel_tunnels) = 0;
163 #endif
164 #define V_parallel_tunnels VNET(parallel_tunnels)
165 SYSCTL_VNET_INT(_net_link_gif, OID_AUTO, parallel_tunnels, CTLFLAG_RW,
166 &VNET_NAME(parallel_tunnels), 0, "Allow parallel tunnels?");
167
168 /* copy from src/sys/net/if_ethersubr.c */
169 static const u_char etherbroadcastaddr[ETHER_ADDR_LEN] =
170 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
171 #ifndef ETHER_IS_BROADCAST
172 #define ETHER_IS_BROADCAST(addr) \
173 (bcmp(etherbroadcastaddr, (addr), ETHER_ADDR_LEN) == 0)
174 #endif
175
176 static int
177 gif_clone_create(struct if_clone *ifc, int unit, caddr_t params)
178 {
179 struct gif_softc *sc;
180
181 sc = malloc(sizeof(struct gif_softc), M_GIF, M_WAITOK | M_ZERO);
182 sc->gif_fibnum = curthread->td_proc->p_fibnum;
183 GIF2IFP(sc) = if_alloc(IFT_GIF);
184 GIF_LOCK_INIT(sc);
185 GIF2IFP(sc)->if_softc = sc;
186 if_initname(GIF2IFP(sc), gifname, unit);
187
188 GIF2IFP(sc)->if_addrlen = 0;
189 GIF2IFP(sc)->if_mtu = GIF_MTU;
190 GIF2IFP(sc)->if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
191 #if 0
192 /* turn off ingress filter */
193 GIF2IFP(sc)->if_flags |= IFF_LINK2;
194 #endif
195 GIF2IFP(sc)->if_ioctl = gif_ioctl;
196 GIF2IFP(sc)->if_transmit = gif_transmit;
197 GIF2IFP(sc)->if_qflush = gif_qflush;
198 GIF2IFP(sc)->if_output = gif_output;
199 GIF2IFP(sc)->if_capabilities |= IFCAP_LINKSTATE;
200 GIF2IFP(sc)->if_capenable |= IFCAP_LINKSTATE;
201 if_attach(GIF2IFP(sc));
202 bpfattach(GIF2IFP(sc), DLT_NULL, sizeof(u_int32_t));
203 if (ng_gif_attach_p != NULL)
204 (*ng_gif_attach_p)(GIF2IFP(sc));
205
206 GIF_LIST_LOCK();
207 LIST_INSERT_HEAD(&V_gif_softc_list, sc, gif_list);
208 GIF_LIST_UNLOCK();
209 return (0);
210 }
211
212 static void
213 gif_clone_destroy(struct ifnet *ifp)
214 {
215 struct gif_softc *sc;
216
217 sx_xlock(&gif_ioctl_sx);
218 sc = ifp->if_softc;
219 gif_delete_tunnel(ifp);
220 GIF_LIST_LOCK();
221 LIST_REMOVE(sc, gif_list);
222 GIF_LIST_UNLOCK();
223 if (ng_gif_detach_p != NULL)
224 (*ng_gif_detach_p)(ifp);
225 bpfdetach(ifp);
226 if_detach(ifp);
227 ifp->if_softc = NULL;
228 sx_xunlock(&gif_ioctl_sx);
229
230 if_free(ifp);
231 GIF_LOCK_DESTROY(sc);
232 free(sc, M_GIF);
233 }
234
235 static void
236 vnet_gif_init(const void *unused __unused)
237 {
238
239 LIST_INIT(&V_gif_softc_list);
240 GIF_LIST_LOCK_INIT();
241 V_gif_cloner = if_clone_simple(gifname, gif_clone_create,
242 gif_clone_destroy, 0);
243 }
244 VNET_SYSINIT(vnet_gif_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
245 vnet_gif_init, NULL);
246
247 static void
248 vnet_gif_uninit(const void *unused __unused)
249 {
250
251 if_clone_detach(V_gif_cloner);
252 GIF_LIST_LOCK_DESTROY();
253 }
254 VNET_SYSUNINIT(vnet_gif_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
255 vnet_gif_uninit, NULL);
256
257 static int
258 gifmodevent(module_t mod, int type, void *data)
259 {
260
261 switch (type) {
262 case MOD_LOAD:
263 case MOD_UNLOAD:
264 break;
265 default:
266 return (EOPNOTSUPP);
267 }
268 return (0);
269 }
270
271 static moduledata_t gif_mod = {
272 "if_gif",
273 gifmodevent,
274 0
275 };
276
277 DECLARE_MODULE(if_gif, gif_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
278 MODULE_VERSION(if_gif, 1);
279
280 int
281 gif_encapcheck(const struct mbuf *m, int off, int proto, void *arg)
282 {
283 GIF_RLOCK_TRACKER;
284 struct gif_softc *sc;
285 int ret;
286 uint8_t ver;
287
288 sc = (struct gif_softc *)arg;
289 if (sc == NULL || (GIF2IFP(sc)->if_flags & IFF_UP) == 0)
290 return (0);
291
292 ret = 0;
293 GIF_RLOCK(sc);
294
295 /* no physical address */
296 if (sc->gif_family == 0)
297 goto done;
298
299 switch (proto) {
300 #ifdef INET
301 case IPPROTO_IPV4:
302 #endif
303 #ifdef INET6
304 case IPPROTO_IPV6:
305 #endif
306 case IPPROTO_ETHERIP:
307 break;
308 default:
309 goto done;
310 }
311
312 /* Bail on short packets */
313 if (m->m_pkthdr.len < sizeof(struct ip))
314 goto done;
315
316 m_copydata(m, 0, 1, &ver);
317 switch (ver >> 4) {
318 #ifdef INET
319 case 4:
320 if (sc->gif_family != AF_INET)
321 goto done;
322 ret = in_gif_encapcheck(m, off, proto, arg);
323 break;
324 #endif
325 #ifdef INET6
326 case 6:
327 if (m->m_pkthdr.len < sizeof(struct ip6_hdr))
328 goto done;
329 if (sc->gif_family != AF_INET6)
330 goto done;
331 ret = in6_gif_encapcheck(m, off, proto, arg);
332 break;
333 #endif
334 }
335 done:
336 GIF_RUNLOCK(sc);
337 return (ret);
338 }
339
340 static int
341 gif_transmit(struct ifnet *ifp, struct mbuf *m)
342 {
343 struct gif_softc *sc;
344 struct etherip_header *eth;
345 #ifdef INET
346 struct ip *ip;
347 #endif
348 #ifdef INET6
349 struct ip6_hdr *ip6;
350 uint32_t t;
351 #endif
352 uint32_t af;
353 uint8_t proto, ecn;
354 int error;
355
356 #ifdef MAC
357 error = mac_ifnet_check_transmit(ifp, m);
358 if (error) {
359 m_freem(m);
360 goto err;
361 }
362 #endif
363 error = ENETDOWN;
364 sc = ifp->if_softc;
365 if ((ifp->if_flags & IFF_MONITOR) != 0 ||
366 (ifp->if_flags & IFF_UP) == 0 ||
367 sc->gif_family == 0 ||
368 (error = gif_check_nesting(ifp, m)) != 0) {
369 m_freem(m);
370 goto err;
371 }
372 /* Now pull back the af that we stashed in the csum_data. */
373 if (ifp->if_bridge)
374 af = AF_LINK;
375 else
376 af = m->m_pkthdr.csum_data;
377 m->m_flags &= ~(M_BCAST|M_MCAST);
378 M_SETFIB(m, sc->gif_fibnum);
379 BPF_MTAP2(ifp, &af, sizeof(af), m);
380 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
381 if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len);
382 /* inner AF-specific encapsulation */
383 ecn = 0;
384 switch (af) {
385 #ifdef INET
386 case AF_INET:
387 proto = IPPROTO_IPV4;
388 if (m->m_len < sizeof(struct ip))
389 m = m_pullup(m, sizeof(struct ip));
390 if (m == NULL) {
391 error = ENOBUFS;
392 goto err;
393 }
394 ip = mtod(m, struct ip *);
395 ip_ecn_ingress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED:
396 ECN_NOCARE, &ecn, &ip->ip_tos);
397 break;
398 #endif
399 #ifdef INET6
400 case AF_INET6:
401 proto = IPPROTO_IPV6;
402 if (m->m_len < sizeof(struct ip6_hdr))
403 m = m_pullup(m, sizeof(struct ip6_hdr));
404 if (m == NULL) {
405 error = ENOBUFS;
406 goto err;
407 }
408 t = 0;
409 ip6 = mtod(m, struct ip6_hdr *);
410 ip6_ecn_ingress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED:
411 ECN_NOCARE, &t, &ip6->ip6_flow);
412 ecn = (ntohl(t) >> 20) & 0xff;
413 break;
414 #endif
415 case AF_LINK:
416 proto = IPPROTO_ETHERIP;
417 M_PREPEND(m, sizeof(struct etherip_header), M_NOWAIT);
418 if (m == NULL) {
419 error = ENOBUFS;
420 goto err;
421 }
422 eth = mtod(m, struct etherip_header *);
423 eth->eip_resvh = 0;
424 eth->eip_ver = ETHERIP_VERSION;
425 eth->eip_resvl = 0;
426 break;
427 default:
428 error = EAFNOSUPPORT;
429 m_freem(m);
430 goto err;
431 }
432 /* XXX should we check if our outer source is legal? */
433 /* dispatch to output logic based on outer AF */
434 switch (sc->gif_family) {
435 #ifdef INET
436 case AF_INET:
437 error = in_gif_output(ifp, m, proto, ecn);
438 break;
439 #endif
440 #ifdef INET6
441 case AF_INET6:
442 error = in6_gif_output(ifp, m, proto, ecn);
443 break;
444 #endif
445 default:
446 m_freem(m);
447 }
448 err:
449 if (error)
450 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
451 return (error);
452 }
453
454 static void
455 gif_qflush(struct ifnet *ifp __unused)
456 {
457
458 }
459
460 #define MTAG_GIF 1080679712
461 static int
462 gif_check_nesting(struct ifnet *ifp, struct mbuf *m)
463 {
464 struct m_tag *mtag;
465 int count;
466
467 /*
468 * gif may cause infinite recursion calls when misconfigured.
469 * We'll prevent this by detecting loops.
470 *
471 * High nesting level may cause stack exhaustion.
472 * We'll prevent this by introducing upper limit.
473 */
474 count = 1;
475 mtag = NULL;
476 while ((mtag = m_tag_locate(m, MTAG_GIF, 0, mtag)) != NULL) {
477 if (*(struct ifnet **)(mtag + 1) == ifp) {
478 log(LOG_NOTICE, "%s: loop detected\n", ifp->if_xname);
479 return (EIO);
480 }
481 count++;
482 }
483 if (count > V_max_gif_nesting) {
484 log(LOG_NOTICE,
485 "%s: if_output recursively called too many times(%d)\n",
486 if_name(ifp), count);
487 return (EIO);
488 }
489 mtag = m_tag_alloc(MTAG_GIF, 0, sizeof(struct ifnet *), M_NOWAIT);
490 if (mtag == NULL)
491 return (ENOMEM);
492 *(struct ifnet **)(mtag + 1) = ifp;
493 m_tag_prepend(m, mtag);
494 return (0);
495 }
496
497 int
498 gif_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
499 struct route *ro)
500 {
501 uint32_t af;
502
503 if (dst->sa_family == AF_UNSPEC)
504 bcopy(dst->sa_data, &af, sizeof(af));
505 else
506 af = dst->sa_family;
507 /*
508 * Now save the af in the inbound pkt csum data, this is a cheat since
509 * we are using the inbound csum_data field to carry the af over to
510 * the gif_transmit() routine, avoiding using yet another mtag.
511 */
512 m->m_pkthdr.csum_data = af;
513 return (ifp->if_transmit(ifp, m));
514 }
515
516 void
517 gif_input(struct mbuf *m, struct ifnet *ifp, int proto, uint8_t ecn)
518 {
519 struct etherip_header *eip;
520 #ifdef INET
521 struct ip *ip;
522 #endif
523 #ifdef INET6
524 struct ip6_hdr *ip6;
525 uint32_t t;
526 #endif
527 struct gif_softc *sc;
528 struct ether_header *eh;
529 struct ifnet *oldifp;
530 int isr, n, af;
531
532 if (ifp == NULL) {
533 /* just in case */
534 m_freem(m);
535 return;
536 }
537 sc = ifp->if_softc;
538 m->m_pkthdr.rcvif = ifp;
539 m_clrprotoflags(m);
540 switch (proto) {
541 #ifdef INET
542 case IPPROTO_IPV4:
543 af = AF_INET;
544 if (m->m_len < sizeof(struct ip))
545 m = m_pullup(m, sizeof(struct ip));
546 if (m == NULL)
547 goto drop;
548 ip = mtod(m, struct ip *);
549 if (ip_ecn_egress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED:
550 ECN_NOCARE, &ecn, &ip->ip_tos) == 0) {
551 m_freem(m);
552 goto drop;
553 }
554 break;
555 #endif
556 #ifdef INET6
557 case IPPROTO_IPV6:
558 af = AF_INET6;
559 if (m->m_len < sizeof(struct ip6_hdr))
560 m = m_pullup(m, sizeof(struct ip6_hdr));
561 if (m == NULL)
562 goto drop;
563 t = htonl((uint32_t)ecn << 20);
564 ip6 = mtod(m, struct ip6_hdr *);
565 if (ip6_ecn_egress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED:
566 ECN_NOCARE, &t, &ip6->ip6_flow) == 0) {
567 m_freem(m);
568 goto drop;
569 }
570 break;
571 #endif
572 case IPPROTO_ETHERIP:
573 af = AF_LINK;
574 break;
575 default:
576 m_freem(m);
577 goto drop;
578 }
579
580 #ifdef MAC
581 mac_ifnet_create_mbuf(ifp, m);
582 #endif
583
584 if (bpf_peers_present(ifp->if_bpf)) {
585 uint32_t af1 = af;
586 bpf_mtap2(ifp->if_bpf, &af1, sizeof(af1), m);
587 }
588
589 if ((ifp->if_flags & IFF_MONITOR) != 0) {
590 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
591 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len);
592 m_freem(m);
593 return;
594 }
595
596 if (ng_gif_input_p != NULL) {
597 (*ng_gif_input_p)(ifp, &m, af);
598 if (m == NULL)
599 goto drop;
600 }
601
602 /*
603 * Put the packet to the network layer input queue according to the
604 * specified address family.
605 * Note: older versions of gif_input directly called network layer
606 * input functions, e.g. ip6_input, here. We changed the policy to
607 * prevent too many recursive calls of such input functions, which
608 * might cause kernel panic. But the change may introduce another
609 * problem; if the input queue is full, packets are discarded.
610 * The kernel stack overflow really happened, and we believed
611 * queue-full rarely occurs, so we changed the policy.
612 */
613 switch (af) {
614 #ifdef INET
615 case AF_INET:
616 isr = NETISR_IP;
617 break;
618 #endif
619 #ifdef INET6
620 case AF_INET6:
621 isr = NETISR_IPV6;
622 break;
623 #endif
624 case AF_LINK:
625 n = sizeof(struct etherip_header) + sizeof(struct ether_header);
626 if (n > m->m_len)
627 m = m_pullup(m, n);
628 if (m == NULL)
629 goto drop;
630 eip = mtod(m, struct etherip_header *);
631 if (eip->eip_ver != ETHERIP_VERSION) {
632 /* discard unknown versions */
633 m_freem(m);
634 goto drop;
635 }
636 m_adj(m, sizeof(struct etherip_header));
637
638 m->m_flags &= ~(M_BCAST|M_MCAST);
639 m->m_pkthdr.rcvif = ifp;
640
641 if (ifp->if_bridge) {
642 oldifp = ifp;
643 eh = mtod(m, struct ether_header *);
644 if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
645 if (ETHER_IS_BROADCAST(eh->ether_dhost))
646 m->m_flags |= M_BCAST;
647 else
648 m->m_flags |= M_MCAST;
649 if_inc_counter(ifp, IFCOUNTER_IMCASTS, 1);
650 }
651 BRIDGE_INPUT(ifp, m);
652
653 if (m != NULL && ifp != oldifp) {
654 /*
655 * The bridge gave us back itself or one of the
656 * members for which the frame is addressed.
657 */
658 ether_demux(ifp, m);
659 return;
660 }
661 }
662 if (m != NULL)
663 m_freem(m);
664 return;
665
666 default:
667 if (ng_gif_input_orphan_p != NULL)
668 (*ng_gif_input_orphan_p)(ifp, m, af);
669 else
670 m_freem(m);
671 return;
672 }
673
674 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
675 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len);
676 M_SETFIB(m, ifp->if_fib);
677 netisr_dispatch(isr, m);
678 return;
679 drop:
680 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
681 }
682
683 /* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */
684 int
685 gif_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
686 {
687 GIF_RLOCK_TRACKER;
688 struct ifreq *ifr = (struct ifreq*)data;
689 struct sockaddr *dst, *src;
690 struct gif_softc *sc;
691 #ifdef INET
692 struct sockaddr_in *sin = NULL;
693 #endif
694 #ifdef INET6
695 struct sockaddr_in6 *sin6 = NULL;
696 #endif
697 u_int options;
698 int error;
699
700 switch (cmd) {
701 case SIOCSIFADDR:
702 ifp->if_flags |= IFF_UP;
703 case SIOCADDMULTI:
704 case SIOCDELMULTI:
705 case SIOCGIFMTU:
706 case SIOCSIFFLAGS:
707 return (0);
708 case SIOCSIFMTU:
709 if (ifr->ifr_mtu < GIF_MTU_MIN ||
710 ifr->ifr_mtu > GIF_MTU_MAX)
711 return (EINVAL);
712 else
713 ifp->if_mtu = ifr->ifr_mtu;
714 return (0);
715 }
716 sx_xlock(&gif_ioctl_sx);
717 sc = ifp->if_softc;
718 if (sc == NULL) {
719 error = ENXIO;
720 goto bad;
721 }
722 error = 0;
723 switch (cmd) {
724 case SIOCSIFPHYADDR:
725 #ifdef INET6
726 case SIOCSIFPHYADDR_IN6:
727 #endif
728 error = EINVAL;
729 switch (cmd) {
730 #ifdef INET
731 case SIOCSIFPHYADDR:
732 src = (struct sockaddr *)
733 &(((struct in_aliasreq *)data)->ifra_addr);
734 dst = (struct sockaddr *)
735 &(((struct in_aliasreq *)data)->ifra_dstaddr);
736 break;
737 #endif
738 #ifdef INET6
739 case SIOCSIFPHYADDR_IN6:
740 src = (struct sockaddr *)
741 &(((struct in6_aliasreq *)data)->ifra_addr);
742 dst = (struct sockaddr *)
743 &(((struct in6_aliasreq *)data)->ifra_dstaddr);
744 break;
745 #endif
746 default:
747 goto bad;
748 }
749 /* sa_family must be equal */
750 if (src->sa_family != dst->sa_family ||
751 src->sa_len != dst->sa_len)
752 goto bad;
753
754 /* validate sa_len */
755 /* check sa_family looks sane for the cmd */
756 switch (src->sa_family) {
757 #ifdef INET
758 case AF_INET:
759 if (src->sa_len != sizeof(struct sockaddr_in))
760 goto bad;
761 if (cmd != SIOCSIFPHYADDR) {
762 error = EAFNOSUPPORT;
763 goto bad;
764 }
765 if (satosin(src)->sin_addr.s_addr == INADDR_ANY ||
766 satosin(dst)->sin_addr.s_addr == INADDR_ANY) {
767 error = EADDRNOTAVAIL;
768 goto bad;
769 }
770 break;
771 #endif
772 #ifdef INET6
773 case AF_INET6:
774 if (src->sa_len != sizeof(struct sockaddr_in6))
775 goto bad;
776 if (cmd != SIOCSIFPHYADDR_IN6) {
777 error = EAFNOSUPPORT;
778 goto bad;
779 }
780 error = EADDRNOTAVAIL;
781 if (IN6_IS_ADDR_UNSPECIFIED(&satosin6(src)->sin6_addr)
782 ||
783 IN6_IS_ADDR_UNSPECIFIED(&satosin6(dst)->sin6_addr))
784 goto bad;
785 /*
786 * Check validity of the scope zone ID of the
787 * addresses, and convert it into the kernel
788 * internal form if necessary.
789 */
790 error = sa6_embedscope(satosin6(src), 0);
791 if (error != 0)
792 goto bad;
793 error = sa6_embedscope(satosin6(dst), 0);
794 if (error != 0)
795 goto bad;
796 break;
797 #endif
798 default:
799 error = EAFNOSUPPORT;
800 goto bad;
801 }
802 error = gif_set_tunnel(ifp, src, dst);
803 break;
804 case SIOCDIFPHYADDR:
805 gif_delete_tunnel(ifp);
806 break;
807 case SIOCGIFPSRCADDR:
808 case SIOCGIFPDSTADDR:
809 #ifdef INET6
810 case SIOCGIFPSRCADDR_IN6:
811 case SIOCGIFPDSTADDR_IN6:
812 #endif
813 if (sc->gif_family == 0) {
814 error = EADDRNOTAVAIL;
815 break;
816 }
817 GIF_RLOCK(sc);
818 switch (cmd) {
819 #ifdef INET
820 case SIOCGIFPSRCADDR:
821 case SIOCGIFPDSTADDR:
822 if (sc->gif_family != AF_INET) {
823 error = EADDRNOTAVAIL;
824 break;
825 }
826 sin = (struct sockaddr_in *)&ifr->ifr_addr;
827 memset(sin, 0, sizeof(*sin));
828 sin->sin_family = AF_INET;
829 sin->sin_len = sizeof(*sin);
830 break;
831 #endif
832 #ifdef INET6
833 case SIOCGIFPSRCADDR_IN6:
834 case SIOCGIFPDSTADDR_IN6:
835 if (sc->gif_family != AF_INET6) {
836 error = EADDRNOTAVAIL;
837 break;
838 }
839 sin6 = (struct sockaddr_in6 *)
840 &(((struct in6_ifreq *)data)->ifr_addr);
841 memset(sin6, 0, sizeof(*sin6));
842 sin6->sin6_family = AF_INET6;
843 sin6->sin6_len = sizeof(*sin6);
844 break;
845 #endif
846 default:
847 error = EAFNOSUPPORT;
848 }
849 if (error == 0) {
850 switch (cmd) {
851 #ifdef INET
852 case SIOCGIFPSRCADDR:
853 sin->sin_addr = sc->gif_iphdr->ip_src;
854 break;
855 case SIOCGIFPDSTADDR:
856 sin->sin_addr = sc->gif_iphdr->ip_dst;
857 break;
858 #endif
859 #ifdef INET6
860 case SIOCGIFPSRCADDR_IN6:
861 sin6->sin6_addr = sc->gif_ip6hdr->ip6_src;
862 break;
863 case SIOCGIFPDSTADDR_IN6:
864 sin6->sin6_addr = sc->gif_ip6hdr->ip6_dst;
865 break;
866 #endif
867 }
868 }
869 GIF_RUNLOCK(sc);
870 if (error != 0)
871 break;
872 switch (cmd) {
873 #ifdef INET
874 case SIOCGIFPSRCADDR:
875 case SIOCGIFPDSTADDR:
876 error = prison_if(curthread->td_ucred,
877 (struct sockaddr *)sin);
878 if (error != 0)
879 memset(sin, 0, sizeof(*sin));
880 break;
881 #endif
882 #ifdef INET6
883 case SIOCGIFPSRCADDR_IN6:
884 case SIOCGIFPDSTADDR_IN6:
885 error = prison_if(curthread->td_ucred,
886 (struct sockaddr *)sin6);
887 if (error == 0)
888 error = sa6_recoverscope(sin6);
889 if (error != 0)
890 memset(sin6, 0, sizeof(*sin6));
891 #endif
892 }
893 break;
894 case SIOCGTUNFIB:
895 ifr->ifr_fib = sc->gif_fibnum;
896 break;
897 case SIOCSTUNFIB:
898 if ((error = priv_check(curthread, PRIV_NET_GIF)) != 0)
899 break;
900 if (ifr->ifr_fib >= rt_numfibs)
901 error = EINVAL;
902 else
903 sc->gif_fibnum = ifr->ifr_fib;
904 break;
905 case GIFGOPTS:
906 options = sc->gif_options;
907 error = copyout(&options, ifr->ifr_data, sizeof(options));
908 break;
909 case GIFSOPTS:
910 if ((error = priv_check(curthread, PRIV_NET_GIF)) != 0)
911 break;
912 error = copyin(ifr->ifr_data, &options, sizeof(options));
913 if (error)
914 break;
915 if (options & ~GIF_OPTMASK)
916 error = EINVAL;
917 else
918 sc->gif_options = options;
919 break;
920 default:
921 error = EINVAL;
922 break;
923 }
924 bad:
925 sx_xunlock(&gif_ioctl_sx);
926 return (error);
927 }
928
929 static void
930 gif_detach(struct gif_softc *sc)
931 {
932
933 sx_assert(&gif_ioctl_sx, SA_XLOCKED);
934 if (sc->gif_ecookie != NULL)
935 encap_detach(sc->gif_ecookie);
936 sc->gif_ecookie = NULL;
937 }
938
939 static int
940 gif_attach(struct gif_softc *sc, int af)
941 {
942
943 sx_assert(&gif_ioctl_sx, SA_XLOCKED);
944 switch (af) {
945 #ifdef INET
946 case AF_INET:
947 return (in_gif_attach(sc));
948 #endif
949 #ifdef INET6
950 case AF_INET6:
951 return (in6_gif_attach(sc));
952 #endif
953 }
954 return (EAFNOSUPPORT);
955 }
956
957 static int
958 gif_set_tunnel(struct ifnet *ifp, struct sockaddr *src, struct sockaddr *dst)
959 {
960 struct gif_softc *sc = ifp->if_softc;
961 struct gif_softc *tsc;
962 #ifdef INET
963 struct ip *ip;
964 #endif
965 #ifdef INET6
966 struct ip6_hdr *ip6;
967 #endif
968 void *hdr;
969 int error = 0;
970
971 if (sc == NULL)
972 return (ENXIO);
973 /* Disallow parallel tunnels unless instructed otherwise. */
974 if (V_parallel_tunnels == 0) {
975 GIF_LIST_LOCK();
976 LIST_FOREACH(tsc, &V_gif_softc_list, gif_list) {
977 if (tsc == sc || tsc->gif_family != src->sa_family)
978 continue;
979 #ifdef INET
980 if (tsc->gif_family == AF_INET &&
981 tsc->gif_iphdr->ip_src.s_addr ==
982 satosin(src)->sin_addr.s_addr &&
983 tsc->gif_iphdr->ip_dst.s_addr ==
984 satosin(dst)->sin_addr.s_addr) {
985 error = EADDRNOTAVAIL;
986 GIF_LIST_UNLOCK();
987 goto bad;
988 }
989 #endif
990 #ifdef INET6
991 if (tsc->gif_family == AF_INET6 &&
992 IN6_ARE_ADDR_EQUAL(&tsc->gif_ip6hdr->ip6_src,
993 &satosin6(src)->sin6_addr) &&
994 IN6_ARE_ADDR_EQUAL(&tsc->gif_ip6hdr->ip6_dst,
995 &satosin6(dst)->sin6_addr)) {
996 error = EADDRNOTAVAIL;
997 GIF_LIST_UNLOCK();
998 goto bad;
999 }
1000 #endif
1001 }
1002 GIF_LIST_UNLOCK();
1003 }
1004 switch (src->sa_family) {
1005 #ifdef INET
1006 case AF_INET:
1007 hdr = ip = malloc(sizeof(struct ip), M_GIF,
1008 M_WAITOK | M_ZERO);
1009 ip->ip_src.s_addr = satosin(src)->sin_addr.s_addr;
1010 ip->ip_dst.s_addr = satosin(dst)->sin_addr.s_addr;
1011 break;
1012 #endif
1013 #ifdef INET6
1014 case AF_INET6:
1015 hdr = ip6 = malloc(sizeof(struct ip6_hdr), M_GIF,
1016 M_WAITOK | M_ZERO);
1017 ip6->ip6_src = satosin6(src)->sin6_addr;
1018 ip6->ip6_dst = satosin6(dst)->sin6_addr;
1019 ip6->ip6_vfc = IPV6_VERSION;
1020 break;
1021 #endif
1022 default:
1023 return (EAFNOSUPPORT);
1024 };
1025
1026 if (sc->gif_family != src->sa_family)
1027 gif_detach(sc);
1028 if (sc->gif_family == 0 ||
1029 sc->gif_family != src->sa_family)
1030 error = gif_attach(sc, src->sa_family);
1031
1032 GIF_WLOCK(sc);
1033 if (sc->gif_family != 0)
1034 free(sc->gif_hdr, M_GIF);
1035 sc->gif_family = src->sa_family;
1036 sc->gif_hdr = hdr;
1037 GIF_WUNLOCK(sc);
1038 #if defined(INET) || defined(INET6)
1039 bad:
1040 #endif
1041 if (error == 0 && sc->gif_family != 0) {
1042 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1043 if_link_state_change(ifp, LINK_STATE_UP);
1044 } else {
1045 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1046 if_link_state_change(ifp, LINK_STATE_DOWN);
1047 }
1048 return (error);
1049 }
1050
1051 static void
1052 gif_delete_tunnel(struct ifnet *ifp)
1053 {
1054 struct gif_softc *sc = ifp->if_softc;
1055 int family;
1056
1057 if (sc == NULL)
1058 return;
1059
1060 GIF_WLOCK(sc);
1061 family = sc->gif_family;
1062 sc->gif_family = 0;
1063 GIF_WUNLOCK(sc);
1064 if (family != 0) {
1065 gif_detach(sc);
1066 free(sc->gif_hdr, M_GIF);
1067 }
1068 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1069 if_link_state_change(ifp, LINK_STATE_DOWN);
1070 }
Cache object: 8cc3d0fa0ff1c12dc8b362bac6abb787
|