]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - sys/net/if_loop.c
Merge OpenSSL 1.0.1j.
[FreeBSD/FreeBSD.git] / sys / net / if_loop.c
1 /*-
2  * Copyright (c) 1982, 1986, 1993
3  *      The Regents of the University of California.  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  * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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  *      @(#)if_loop.c   8.2 (Berkeley) 1/9/95
30  * $FreeBSD$
31  */
32
33 /*
34  * Loopback interface driver for protocol testing and timing.
35  */
36
37 #include "opt_inet.h"
38 #include "opt_inet6.h"
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/kernel.h>
43 #include <sys/mbuf.h>
44 #include <sys/module.h>
45 #include <machine/bus.h>
46 #include <sys/rman.h>
47 #include <sys/socket.h>
48 #include <sys/sockio.h>
49 #include <sys/sysctl.h>
50
51 #include <net/if.h>
52 #include <net/if_var.h>
53 #include <net/if_clone.h>
54 #include <net/if_types.h>
55 #include <net/netisr.h>
56 #include <net/route.h>
57 #include <net/bpf.h>
58 #include <net/vnet.h>
59
60 #ifdef  INET
61 #include <netinet/in.h>
62 #include <netinet/in_var.h>
63 #endif
64
65 #ifdef INET6
66 #ifndef INET
67 #include <netinet/in.h>
68 #endif
69 #include <netinet6/in6_var.h>
70 #include <netinet/ip6.h>
71 #endif
72
73 #include <security/mac/mac_framework.h>
74
75 #ifdef TINY_LOMTU
76 #define LOMTU   (1024+512)
77 #elif defined(LARGE_LOMTU)
78 #define LOMTU   131072
79 #else
80 #define LOMTU   16384
81 #endif
82
83 #define LO_CSUM_FEATURES        (CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_SCTP)
84 #define LO_CSUM_FEATURES6       (CSUM_TCP_IPV6 | CSUM_UDP_IPV6 | CSUM_SCTP_IPV6)
85 #define LO_CSUM_SET             (CSUM_DATA_VALID | CSUM_DATA_VALID_IPV6 | \
86                                     CSUM_PSEUDO_HDR | \
87                                     CSUM_IP_CHECKED | CSUM_IP_VALID | \
88                                     CSUM_SCTP_VALID)
89
90 int             loioctl(struct ifnet *, u_long, caddr_t);
91 static void     lortrequest(int, struct rtentry *, struct rt_addrinfo *);
92 int             looutput(struct ifnet *ifp, struct mbuf *m,
93                     const struct sockaddr *dst, struct route *ro);
94 static int      lo_clone_create(struct if_clone *, int, caddr_t);
95 static void     lo_clone_destroy(struct ifnet *);
96
97 VNET_DEFINE(struct ifnet *, loif);      /* Used externally */
98
99 #ifdef VIMAGE
100 static VNET_DEFINE(struct if_clone *, lo_cloner);
101 #define V_lo_cloner             VNET(lo_cloner)
102 #endif
103
104 static struct if_clone *lo_cloner;
105 static const char loname[] = "lo";
106
107 static void
108 lo_clone_destroy(struct ifnet *ifp)
109 {
110
111 #ifndef VIMAGE
112         /* XXX: destroying lo0 will lead to panics. */
113         KASSERT(V_loif != ifp, ("%s: destroying lo0", __func__));
114 #endif
115
116         bpfdetach(ifp);
117         if_detach(ifp);
118         if_free(ifp);
119 }
120
121 static int
122 lo_clone_create(struct if_clone *ifc, int unit, caddr_t params)
123 {
124         struct ifnet *ifp;
125
126         ifp = if_alloc(IFT_LOOP);
127         if (ifp == NULL)
128                 return (ENOSPC);
129
130         if_initname(ifp, loname, unit);
131         ifp->if_mtu = LOMTU;
132         ifp->if_flags = IFF_LOOPBACK | IFF_MULTICAST;
133         ifp->if_ioctl = loioctl;
134         ifp->if_output = looutput;
135         ifp->if_snd.ifq_maxlen = ifqmaxlen;
136         ifp->if_capabilities = ifp->if_capenable =
137             IFCAP_HWCSUM | IFCAP_HWCSUM_IPV6;
138         ifp->if_hwassist = LO_CSUM_FEATURES | LO_CSUM_FEATURES6;
139         if_attach(ifp);
140         bpfattach(ifp, DLT_NULL, sizeof(u_int32_t));
141         if (V_loif == NULL)
142                 V_loif = ifp;
143
144         return (0);
145 }
146
147 static void
148 vnet_loif_init(const void *unused __unused)
149 {
150
151 #ifdef VIMAGE
152         lo_cloner = if_clone_simple(loname, lo_clone_create, lo_clone_destroy,
153             1);
154         V_lo_cloner = lo_cloner;
155 #else
156         lo_cloner = if_clone_simple(loname, lo_clone_create, lo_clone_destroy,
157             1);
158 #endif
159 }
160 VNET_SYSINIT(vnet_loif_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
161     vnet_loif_init, NULL);
162
163 #ifdef VIMAGE
164 static void
165 vnet_loif_uninit(const void *unused __unused)
166 {
167
168         if_clone_detach(V_lo_cloner);
169         V_loif = NULL;
170 }
171 VNET_SYSUNINIT(vnet_loif_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
172     vnet_loif_uninit, NULL);
173 #endif
174
175 static int
176 loop_modevent(module_t mod, int type, void *data)
177 {
178
179         switch (type) {
180         case MOD_LOAD:
181                 break;
182
183         case MOD_UNLOAD:
184                 printf("loop module unload - not possible for this module type\n");
185                 return (EINVAL);
186
187         default:
188                 return (EOPNOTSUPP);
189         }
190         return (0);
191 }
192
193 static moduledata_t loop_mod = {
194         "if_lo",
195         loop_modevent,
196         0
197 };
198
199 DECLARE_MODULE(if_lo, loop_mod, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY);
200
201 int
202 looutput(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
203     struct route *ro)
204 {
205         u_int32_t af;
206         struct rtentry *rt = NULL;
207 #ifdef MAC
208         int error;
209 #endif
210
211         M_ASSERTPKTHDR(m); /* check if we have the packet header */
212
213         if (ro != NULL)
214                 rt = ro->ro_rt;
215 #ifdef MAC
216         error = mac_ifnet_check_transmit(ifp, m);
217         if (error) {
218                 m_freem(m);
219                 return (error);
220         }
221 #endif
222
223         if (rt && rt->rt_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
224                 m_freem(m);
225                 return (rt->rt_flags & RTF_BLACKHOLE ? 0 :
226                         rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
227         }
228
229         if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
230         if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len);
231
232         /* BPF writes need to be handled specially. */
233         if (dst->sa_family == AF_UNSPEC)
234                 bcopy(dst->sa_data, &af, sizeof(af));
235         else
236                 af = dst->sa_family;
237
238 #if 1   /* XXX */
239         switch (af) {
240         case AF_INET:
241                 if (ifp->if_capenable & IFCAP_RXCSUM) {
242                         m->m_pkthdr.csum_data = 0xffff;
243                         m->m_pkthdr.csum_flags = LO_CSUM_SET;
244                 }
245                 m->m_pkthdr.csum_flags &= ~LO_CSUM_FEATURES;
246                 break;
247         case AF_INET6:
248 #if 0
249                 /*
250                  * XXX-BZ for now always claim the checksum is good despite
251                  * any interface flags.   This is a workaround for 9.1-R and
252                  * a proper solution ought to be sought later.
253                  */
254                 if (ifp->if_capenable & IFCAP_RXCSUM_IPV6) {
255                         m->m_pkthdr.csum_data = 0xffff;
256                         m->m_pkthdr.csum_flags = LO_CSUM_SET;
257                 }
258 #else
259                 m->m_pkthdr.csum_data = 0xffff;
260                 m->m_pkthdr.csum_flags = LO_CSUM_SET;
261 #endif
262                 m->m_pkthdr.csum_flags &= ~LO_CSUM_FEATURES6;
263                 break;
264         default:
265                 printf("looutput: af=%d unexpected\n", af);
266                 m_freem(m);
267                 return (EAFNOSUPPORT);
268         }
269 #endif
270         return (if_simloop(ifp, m, af, 0));
271 }
272
273 /*
274  * if_simloop()
275  *
276  * This function is to support software emulation of hardware loopback,
277  * i.e., for interfaces with the IFF_SIMPLEX attribute. Since they can't
278  * hear their own broadcasts, we create a copy of the packet that we
279  * would normally receive via a hardware loopback.
280  *
281  * This function expects the packet to include the media header of length hlen.
282  */
283 int
284 if_simloop(struct ifnet *ifp, struct mbuf *m, int af, int hlen)
285 {
286         int isr;
287
288         M_ASSERTPKTHDR(m);
289         m_tag_delete_nonpersistent(m);
290         m->m_pkthdr.rcvif = ifp;
291
292 #ifdef MAC
293         mac_ifnet_create_mbuf(ifp, m);
294 #endif
295
296         /*
297          * Let BPF see incoming packet in the following manner:
298          *  - Emulated packet loopback for a simplex interface
299          *    (net/if_ethersubr.c)
300          *      -> passes it to ifp's BPF
301          *  - IPv4/v6 multicast packet loopback (netinet(6)/ip(6)_output.c)
302          *      -> not passes it to any BPF
303          *  - Normal packet loopback from myself to myself (net/if_loop.c)
304          *      -> passes to lo0's BPF (even in case of IPv6, where ifp!=lo0)
305          */
306         if (hlen > 0) {
307                 if (bpf_peers_present(ifp->if_bpf)) {
308                         bpf_mtap(ifp->if_bpf, m);
309                 }
310         } else {
311                 if (bpf_peers_present(V_loif->if_bpf)) {
312                         if ((m->m_flags & M_MCAST) == 0 || V_loif == ifp) {
313                                 /* XXX beware sizeof(af) != 4 */
314                                 u_int32_t af1 = af;
315
316                                 /*
317                                  * We need to prepend the address family.
318                                  */
319                                 bpf_mtap2(V_loif->if_bpf, &af1, sizeof(af1), m);
320                         }
321                 }
322         }
323
324         /* Strip away media header */
325         if (hlen > 0) {
326                 m_adj(m, hlen);
327 #ifndef __NO_STRICT_ALIGNMENT
328                 /*
329                  * Some archs do not like unaligned data, so
330                  * we move data down in the first mbuf.
331                  */
332                 if (mtod(m, vm_offset_t) & 3) {
333                         KASSERT(hlen >= 3, ("if_simloop: hlen too small"));
334                         bcopy(m->m_data,
335                             (char *)(mtod(m, vm_offset_t)
336                                 - (mtod(m, vm_offset_t) & 3)),
337                             m->m_len);
338                         m->m_data -= (mtod(m,vm_offset_t) & 3);
339                 }
340 #endif
341         }
342
343         /* Deliver to upper layer protocol */
344         switch (af) {
345 #ifdef INET
346         case AF_INET:
347                 isr = NETISR_IP;
348                 break;
349 #endif
350 #ifdef INET6
351         case AF_INET6:
352                 m->m_flags |= M_LOOP;
353                 isr = NETISR_IPV6;
354                 break;
355 #endif
356         default:
357                 printf("if_simloop: can't handle af=%d\n", af);
358                 m_freem(m);
359                 return (EAFNOSUPPORT);
360         }
361         if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
362         if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len);
363         netisr_queue(isr, m);   /* mbuf is free'd on failure. */
364         return (0);
365 }
366
367 /* ARGSUSED */
368 static void
369 lortrequest(int cmd, struct rtentry *rt, struct rt_addrinfo *info)
370 {
371
372         RT_LOCK_ASSERT(rt);
373         rt->rt_mtu = rt->rt_ifp->if_mtu;
374 }
375
376 /*
377  * Process an ioctl request.
378  */
379 /* ARGSUSED */
380 int
381 loioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
382 {
383         struct ifaddr *ifa;
384         struct ifreq *ifr = (struct ifreq *)data;
385         int error = 0, mask;
386
387         switch (cmd) {
388         case SIOCSIFADDR:
389                 ifp->if_flags |= IFF_UP;
390                 ifp->if_drv_flags |= IFF_DRV_RUNNING;
391                 ifa = (struct ifaddr *)data;
392                 ifa->ifa_rtrequest = lortrequest;
393                 /*
394                  * Everything else is done at a higher level.
395                  */
396                 break;
397
398         case SIOCADDMULTI:
399         case SIOCDELMULTI:
400                 if (ifr == 0) {
401                         error = EAFNOSUPPORT;           /* XXX */
402                         break;
403                 }
404                 switch (ifr->ifr_addr.sa_family) {
405
406 #ifdef INET
407                 case AF_INET:
408                         break;
409 #endif
410 #ifdef INET6
411                 case AF_INET6:
412                         break;
413 #endif
414
415                 default:
416                         error = EAFNOSUPPORT;
417                         break;
418                 }
419                 break;
420
421         case SIOCSIFMTU:
422                 ifp->if_mtu = ifr->ifr_mtu;
423                 break;
424
425         case SIOCSIFFLAGS:
426                 break;
427
428         case SIOCSIFCAP:
429                 mask = ifp->if_capenable ^ ifr->ifr_reqcap;
430                 if ((mask & IFCAP_RXCSUM) != 0)
431                         ifp->if_capenable ^= IFCAP_RXCSUM;
432                 if ((mask & IFCAP_TXCSUM) != 0)
433                         ifp->if_capenable ^= IFCAP_TXCSUM;
434                 if ((mask & IFCAP_RXCSUM_IPV6) != 0) {
435 #if 0
436                         ifp->if_capenable ^= IFCAP_RXCSUM_IPV6;
437 #else
438                         error = EOPNOTSUPP;
439                         break;
440 #endif
441                 }
442                 if ((mask & IFCAP_TXCSUM_IPV6) != 0) {
443 #if 0
444                         ifp->if_capenable ^= IFCAP_TXCSUM_IPV6;
445 #else
446                         error = EOPNOTSUPP;
447                         break;
448 #endif
449                 }
450                 ifp->if_hwassist = 0;
451                 if (ifp->if_capenable & IFCAP_TXCSUM)
452                         ifp->if_hwassist = LO_CSUM_FEATURES;
453 #if 0
454                 if (ifp->if_capenable & IFCAP_TXCSUM_IPV6)
455                         ifp->if_hwassist |= LO_CSUM_FEATURES6;
456 #endif
457                 break;
458
459         default:
460                 error = EINVAL;
461         }
462         return (error);
463 }