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  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)if_loop.c   8.2 (Berkeley) 1/9/95
  34  * $FreeBSD$
  35  */
  36
  37 /*
  38  * Loopback interface driver for protocol testing and timing.
  39  */
  40
  41 #include "opt_atalk.h"
  42 #include "opt_inet.h"
  43 #include "opt_inet6.h"
  44 #include "opt_ipx.h"
  45 #include "opt_mac.h"
  46
  47 #include <sys/param.h>
  48 #include <sys/systm.h>
  49 #include <sys/kernel.h>
  50 #include <sys/mac.h>
  51 #include <sys/malloc.h>
  52 #include <sys/mbuf.h>
  53 #include <sys/module.h>
  54 #include <machine/bus.h>
  55 #include <sys/rman.h>
  56 #include <sys/socket.h>
  57 #include <sys/sockio.h>
  58 #include <sys/sysctl.h>
  59
  60 #include <net/if.h>
  61 #include <net/if_types.h>
  62 #include <net/netisr.h>
  63 #include <net/route.h>
  64 #include <net/bpf.h>
  65 #include <net/bpfdesc.h>
  66
  67 #ifdef  INET
  68 #include <netinet/in.h>
  69 #include <netinet/in_var.h>
  70 #endif
  71
  72 #ifdef IPX
  73 #include <netipx/ipx.h>
  74 #include <netipx/ipx_if.h>
  75 #endif
  76
  77 #ifdef INET6
  78 #ifndef INET
  79 #include <netinet/in.h>
  80 #endif
  81 #include <netinet6/in6_var.h>
  82 #include <netinet/ip6.h>
  83 #endif
  84
  85 #ifdef NETATALK
  86 #include <netatalk/at.h>
  87 #include <netatalk/at_var.h>
  88 #endif
  89
  90 #ifdef TINY_LOMTU
  91 #define LOMTU   (1024+512)
  92 #elif defined(LARGE_LOMTU)
  93 #define LOMTU   131072
  94 #else
  95 #define LOMTU   16384
  96 #endif
  97
  98 #define LONAME  "lo"
  99
 100 struct lo_softc {
 101         struct  ifnet sc_if;            /* network-visible interface */
 102         LIST_ENTRY(lo_softc) sc_next;
 103 };
 104
 105 int             loioctl(struct ifnet *, u_long, caddr_t);
 106 static void     lortrequest(int, struct rtentry *, struct rt_addrinfo *);
 107 int             looutput(struct ifnet *ifp, struct mbuf *m,
 108                     struct sockaddr *dst, struct rtentry *rt);
 109 int             lo_clone_create(struct if_clone *, int);
 110 void            lo_clone_destroy(struct ifnet *);
 111
 112 struct ifnet *loif = NULL;                      /* Used externally */
 113
 114 static MALLOC_DEFINE(M_LO, LONAME, "Loopback Interface");
 115
 116 static LIST_HEAD(lo_list, lo_softc) lo_list;
 117
 118 struct if_clone lo_cloner = IF_CLONE_INITIALIZER(LONAME,
 119     lo_clone_create, lo_clone_destroy, 1, IF_MAXUNIT);
 120
 121 void
 122 lo_clone_destroy(ifp)
 123         struct ifnet *ifp;
 124 {
 125         struct lo_softc *sc;
 126
 127         sc = ifp->if_softc;
 128
 129         /* XXX: destroying lo0 will lead to panics. */
 130         KASSERT(loif != ifp, ("%s: destroying lo0", __func__));
 131
 132         bpfdetach(ifp);
 133         if_detach(ifp);
 134         LIST_REMOVE(sc, sc_next);
 135         free(sc, M_LO);
 136 }
 137
 138 int
 139 lo_clone_create(ifc, unit)
 140         struct if_clone *ifc;
 141         int unit;
 142 {
 143         struct lo_softc *sc;
 144
 145         MALLOC(sc, struct lo_softc *, sizeof(*sc), M_LO, M_WAITOK | M_ZERO);
 146
 147         sc->sc_if.if_name = LONAME;
 148         sc->sc_if.if_unit = unit;
 149         sc->sc_if.if_mtu = LOMTU;
 150         sc->sc_if.if_flags = IFF_LOOPBACK | IFF_MULTICAST;
 151         sc->sc_if.if_ioctl = loioctl;
 152         sc->sc_if.if_output = looutput;
 153         sc->sc_if.if_type = IFT_LOOP;
 154         sc->sc_if.if_snd.ifq_maxlen = ifqmaxlen;
 155         sc->sc_if.if_softc = sc;
 156         if_attach(&sc->sc_if);
 157         bpfattach(&sc->sc_if, DLT_NULL, sizeof(u_int));
 158         LIST_INSERT_HEAD(&lo_list, sc, sc_next);
 159         if (loif == NULL)
 160                 loif = &sc->sc_if;
 161
 162         return (0);
 163 }
 164
 165 static int
 166 loop_modevent(module_t mod, int type, void *data)
 167 {
 168         switch (type) {
 169         case MOD_LOAD:
 170                 LIST_INIT(&lo_list);
 171                 if_clone_attach(&lo_cloner);
 172                 break;
 173         case MOD_UNLOAD:
 174                 printf("loop module unload - not possible for this module type\n");
 175                 return EINVAL;
 176         }
 177         return 0;
 178 }
 179
 180 static moduledata_t loop_mod = {
 181         "loop",
 182         loop_modevent,
 183         0
 184 };
 185
 186 DECLARE_MODULE(loop, loop_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
 187
 188 int
 189 looutput(ifp, m, dst, rt)
 190         struct ifnet *ifp;
 191         register struct mbuf *m;
 192         struct sockaddr *dst;
 193         register struct rtentry *rt;
 194 {
 195 #ifdef INET6
 196         struct mbuf *n;
 197 #endif
 198
 199         M_ASSERTPKTHDR(m); /* check if we have the packet header */
 200
 201         if (rt && rt->rt_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
 202                 m_freem(m);
 203                 return (rt->rt_flags & RTF_BLACKHOLE ? 0 :
 204                         rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
 205         }
 206 #ifdef INET6
 207         /*
 208          * KAME requires that the packet to be contiguous on the
 209          * mbuf.  We need to make that sure.
 210          * this kind of code should be avoided.
 211          *
 212          * XXX: KAME may no longer need contiguous packets.  Once
 213          * that has been verified, the following code _should_ be
 214          * removed.
 215          */
 216
 217         if (m && m->m_next != NULL) {
 218
 219                 n = m_defrag(m, M_DONTWAIT);
 220
 221                 if (n == NULL) {
 222                         m_freem(m);
 223                         return (ENOBUFS);
 224                 } else {
 225                         m = n;
 226                 }
 227         }
 228 #endif
 229
 230         ifp->if_opackets++;
 231         ifp->if_obytes += m->m_pkthdr.len;
 232 #if 1   /* XXX */
 233         switch (dst->sa_family) {
 234         case AF_INET:
 235         case AF_INET6:
 236         case AF_IPX:
 237         case AF_APPLETALK:
 238                 break;
 239         default:
 240                 printf("looutput: af=%d unexpected\n", dst->sa_family);
 241                 m_freem(m);
 242                 return (EAFNOSUPPORT);
 243         }
 244 #endif
 245         return(if_simloop(ifp, m, dst->sa_family, 0));
 246 }
 247
 248 /*
 249  * if_simloop()
 250  *
 251  * This function is to support software emulation of hardware loopback,
 252  * i.e., for interfaces with the IFF_SIMPLEX attribute. Since they can't
 253  * hear their own broadcasts, we create a copy of the packet that we
 254  * would normally receive via a hardware loopback.
 255  *
 256  * This function expects the packet to include the media header of length hlen.
 257  */
 258
 259 int
 260 if_simloop(ifp, m, af, hlen)
 261         struct ifnet *ifp;
 262         struct mbuf *m;
 263         int af;
 264         int hlen;
 265 {
 266         int isr;
 267
 268         M_ASSERTPKTHDR(m);
 269         m->m_pkthdr.rcvif = ifp;
 270
 271         /* BPF write needs to be handled specially */
 272         if (af == AF_UNSPEC) {
 273                 KASSERT(m->m_len >= sizeof(int), ("if_simloop: m_len"));
 274                 af = *(mtod(m, int *));
 275                 m->m_len -= sizeof(int);
 276                 m->m_pkthdr.len -= sizeof(int);
 277                 m->m_data += sizeof(int);
 278         }
 279
 280         /* Let BPF see incoming packet */
 281         if (ifp->if_bpf) {
 282                 struct mbuf m0, *n = m;
 283
 284                 if (ifp->if_bpf->bif_dlt == DLT_NULL) {
 285                         /*
 286                          * We need to prepend the address family as
 287                          * a four byte field.  Cons up a dummy header
 288                          * to pacify bpf.  This is safe because bpf
 289                          * will only read from the mbuf (i.e., it won't
 290                          * try to free it or keep a pointer a to it).
 291                          */
 292                         m0.m_next = m;
 293                         m0.m_len = 4;
 294                         m0.m_data = (char *)&af;
 295                         n = &m0;
 296                 }
 297                 BPF_MTAP(ifp, n);
 298         }
 299
 300         /* Strip away media header */
 301         if (hlen > 0) {
 302                 m_adj(m, hlen);
 303 #if defined(__alpha__) || defined(__ia64__) || defined(__sparc64__)
 304                 /* The alpha doesn't like unaligned data.
 305                  * We move data down in the first mbuf */
 306                 if (mtod(m, vm_offset_t) & 3) {
 307                         KASSERT(hlen >= 3, ("if_simloop: hlen too small"));
 308                         bcopy(m->m_data,
 309                             (char *)(mtod(m, vm_offset_t)
 310                                 - (mtod(m, vm_offset_t) & 3)),
 311                             m->m_len);
 312                         mtod(m,vm_offset_t) -= (mtod(m, vm_offset_t) & 3);
 313                 }
 314 #endif
 315         }
 316
 317         /* Deliver to upper layer protocol */
 318         switch (af) {
 319 #ifdef INET
 320         case AF_INET:
 321                 isr = NETISR_IP;
 322                 break;
 323 #endif
 324 #ifdef INET6
 325         case AF_INET6:
 326                 m->m_flags |= M_LOOP;
 327                 isr = NETISR_IPV6;
 328                 break;
 329 #endif
 330 #ifdef IPX
 331         case AF_IPX:
 332                 isr = NETISR_IPX;
 333                 break;
 334 #endif
 335 #ifdef NETATALK
 336         case AF_APPLETALK:
 337                 isr = NETISR_ATALK2;
 338                 break;
 339 #endif
 340         default:
 341                 printf("if_simloop: can't handle af=%d\n", af);
 342                 m_freem(m);
 343                 return (EAFNOSUPPORT);
 344         }
 345         ifp->if_ipackets++;
 346         ifp->if_ibytes += m->m_pkthdr.len;
 347         netisr_dispatch(isr, m);
 348         return (0);
 349 }
 350
 351 /* ARGSUSED */
 352 static void
 353 lortrequest(cmd, rt, info)
 354         int cmd;
 355         struct rtentry *rt;
 356         struct rt_addrinfo *info;
 357 {
 358         RT_LOCK_ASSERT(rt);
 359
 360         if (rt) {
 361                 rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu; /* for ISO */
 362                 /*
 363                  * For optimal performance, the send and receive buffers
 364                  * should be at least twice the MTU plus a little more for
 365                  * overhead.
 366                  */
 367                 rt->rt_rmx.rmx_recvpipe =
 368                         rt->rt_rmx.rmx_sendpipe = 3 * LOMTU;
 369         }
 370 }
 371
 372 /*
 373  * Process an ioctl request.
 374  */
 375 /* ARGSUSED */
 376 int
 377 loioctl(ifp, cmd, data)
 378         register struct ifnet *ifp;
 379         u_long cmd;
 380         caddr_t data;
 381 {
 382         register struct ifaddr *ifa;
 383         register struct ifreq *ifr = (struct ifreq *)data;
 384         register int error = 0;
 385
 386         switch (cmd) {
 387
 388         case SIOCSIFADDR:
 389                 ifp->if_flags |= IFF_UP | IFF_RUNNING;
 390                 ifa = (struct ifaddr *)data;
 391                 ifa->ifa_rtrequest = lortrequest;
 392                 /*
 393                  * Everything else is done at a higher level.
 394                  */
 395                 break;
 396
 397         case SIOCADDMULTI:
 398         case SIOCDELMULTI:
 399                 if (ifr == 0) {
 400                         error = EAFNOSUPPORT;           /* XXX */
 401                         break;
 402                 }
 403                 switch (ifr->ifr_addr.sa_family) {
 404
 405 #ifdef INET
 406                 case AF_INET:
 407                         break;
 408 #endif
 409 #ifdef INET6
 410                 case AF_INET6:
 411                         break;
 412 #endif
 413
 414                 default:
 415                         error = EAFNOSUPPORT;
 416                         break;
 417                 }
 418                 break;
 419
 420         case SIOCSIFMTU:
 421                 ifp->if_mtu = ifr->ifr_mtu;
 422                 break;
 423
 424         case SIOCSIFFLAGS:
 425                 break;
 426
 427         default:
 428                 error = EINVAL;
 429         }
 430         return (error);
 431 }