Context Navigation

source: rtems-libbsd/freebsd/sys/net/if_gif.c @ 66659ff

4.1155-freebsd-126-freebsd-12freebsd-9.3

Last change on this file since 66659ff was 66659ff, checked in by Sebastian Huber <sebastian.huber@…>, on 11/06/13 at 15:20:21
Update to FreeBSD 9.2
Property mode set to `100644`
File size: 23.1 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: