sys/netinet/in_gif.c

   1 /*      $KAME: in_gif.c,v 1.54 2001/05/14 14:02:16 itojun Exp $ */
   2
   3 /*-
   4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the project nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include "opt_mrouting.h"
  36 #include "opt_inet.h"
  37 #include "opt_inet6.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/socket.h>
  42 #include <sys/sockio.h>
  43 #include <sys/mbuf.h>
  44 #include <sys/errno.h>
  45 #include <sys/kernel.h>
  46 #include <sys/sysctl.h>
  47 #include <sys/protosw.h>
  48 #include <sys/malloc.h>
  49
  50 #include <net/if.h>
  51 #include <net/route.h>
  52 #include <net/vnet.h>
  53
  54 #include <netinet/in.h>
  55 #include <netinet/in_systm.h>
  56 #include <netinet/ip.h>
  57 #include <netinet/ip_var.h>
  58 #include <netinet/in_gif.h>
  59 #include <netinet/in_var.h>
  60 #include <netinet/ip_encap.h>
  61 #include <netinet/ip_ecn.h>
  62
  63 #ifdef INET6
  64 #include <netinet/ip6.h>
  65 #endif
  66
  67 #ifdef MROUTING
  68 #include <netinet/ip_mroute.h>
  69 #endif /* MROUTING */
  70
  71 #include <net/if_gif.h>
  72
  73 static int gif_validate4(const struct ip *, struct gif_softc *,
  74         struct ifnet *);
  75
  76 extern  struct domain inetdomain;
  77 struct protosw in_gif_protosw = {
  78         .pr_type =              SOCK_RAW,
  79         .pr_domain =            &inetdomain,
  80         .pr_protocol =          0/* IPPROTO_IPV[46] */,
  81         .pr_flags =             PR_ATOMIC|PR_ADDR,
  82         .pr_input =             in_gif_input,
  83         .pr_output =            (pr_output_t*)rip_output,
  84         .pr_ctloutput =         rip_ctloutput,
  85         .pr_usrreqs =           &rip_usrreqs
  86 };
  87
  88 SYSCTL_VNET_INT(_net_inet_ip, IPCTL_GIF_TTL, gifttl, CTLFLAG_RW,
  89         &VNET_NAME(ip_gif_ttl), 0, "");
  90
  91 int
  92 in_gif_output(struct ifnet *ifp, int family, struct mbuf *m)
  93 {
  94         struct gif_softc *sc = ifp->if_softc;
  95         struct sockaddr_in *dst = (struct sockaddr_in *)&sc->gif_ro.ro_dst;
  96         struct sockaddr_in *sin_src = (struct sockaddr_in *)sc->gif_psrc;
  97         struct sockaddr_in *sin_dst = (struct sockaddr_in *)sc->gif_pdst;
  98         struct ip iphdr;        /* capsule IP header, host byte ordered */
  99         struct etherip_header eiphdr;
 100         int error, len, proto;
 101         u_int8_t tos;
 102
 103         GIF_LOCK_ASSERT(sc);
 104
 105         if (sin_src == NULL || sin_dst == NULL ||
 106             sin_src->sin_family != AF_INET ||
 107             sin_dst->sin_family != AF_INET) {
 108                 m_freem(m);
 109                 return EAFNOSUPPORT;
 110         }
 111
 112         switch (family) {
 113 #ifdef INET
 114         case AF_INET:
 115             {
 116                 struct ip *ip;
 117
 118                 proto = IPPROTO_IPV4;
 119                 if (m->m_len < sizeof(*ip)) {
 120                         m = m_pullup(m, sizeof(*ip));
 121                         if (!m)
 122                                 return ENOBUFS;
 123                 }
 124                 ip = mtod(m, struct ip *);
 125                 tos = ip->ip_tos;
 126                 break;
 127             }
 128 #endif /* INET */
 129 #ifdef INET6
 130         case AF_INET6:
 131             {
 132                 struct ip6_hdr *ip6;
 133                 proto = IPPROTO_IPV6;
 134                 if (m->m_len < sizeof(*ip6)) {
 135                         m = m_pullup(m, sizeof(*ip6));
 136                         if (!m)
 137                                 return ENOBUFS;
 138                 }
 139                 ip6 = mtod(m, struct ip6_hdr *);
 140                 tos = (ntohl(ip6->ip6_flow) >> 20) & 0xff;
 141                 break;
 142             }
 143 #endif /* INET6 */
 144         case AF_LINK:
 145                 proto = IPPROTO_ETHERIP;
 146
 147                 /*
 148                  * GIF_SEND_REVETHIP (disabled by default) intentionally
 149                  * sends an EtherIP packet with revered version field in
 150                  * the header.  This is a knob for backward compatibility
 151                  * with FreeBSD 7.2R or prior.
 152                  */
 153                 if ((sc->gif_options & GIF_SEND_REVETHIP)) {
 154                         eiphdr.eip_ver = 0;
 155                         eiphdr.eip_resvl = ETHERIP_VERSION;
 156                         eiphdr.eip_resvh = 0;
 157                 } else {
 158                         eiphdr.eip_ver = ETHERIP_VERSION;
 159                         eiphdr.eip_resvl = 0;
 160                         eiphdr.eip_resvh = 0;
 161                 }
 162                 /* prepend Ethernet-in-IP header */
 163                 M_PREPEND(m, sizeof(struct etherip_header), M_DONTWAIT);
 164                 if (m && m->m_len < sizeof(struct etherip_header))
 165                         m = m_pullup(m, sizeof(struct etherip_header));
 166                 if (m == NULL)
 167                         return ENOBUFS;
 168                 bcopy(&eiphdr, mtod(m, struct etherip_header *),
 169                     sizeof(struct etherip_header));
 170                 break;
 171
 172         default:
 173 #ifdef DEBUG
 174                 printf("in_gif_output: warning: unknown family %d passed\n",
 175                         family);
 176 #endif
 177                 m_freem(m);
 178                 return EAFNOSUPPORT;
 179         }
 180
 181         bzero(&iphdr, sizeof(iphdr));
 182         iphdr.ip_src = sin_src->sin_addr;
 183         /* bidirectional configured tunnel mode */
 184         if (sin_dst->sin_addr.s_addr != INADDR_ANY)
 185                 iphdr.ip_dst = sin_dst->sin_addr;
 186         else {
 187                 m_freem(m);
 188                 return ENETUNREACH;
 189         }
 190         iphdr.ip_p = proto;
 191         /* version will be set in ip_output() */
 192         iphdr.ip_ttl = V_ip_gif_ttl;
 193         iphdr.ip_len = m->m_pkthdr.len + sizeof(struct ip);
 194         ip_ecn_ingress((ifp->if_flags & IFF_LINK1) ? ECN_ALLOWED : ECN_NOCARE,
 195                        &iphdr.ip_tos, &tos);
 196
 197         /* prepend new IP header */
 198         len = sizeof(struct ip);
 199 #ifndef __NO_STRICT_ALIGNMENT
 200         if (family == AF_LINK)
 201                 len += ETHERIP_ALIGN;
 202 #endif
 203         M_PREPEND(m, len, M_DONTWAIT);
 204         if (m != NULL && m->m_len < len)
 205                 m = m_pullup(m, len);
 206         if (m == NULL) {
 207                 printf("ENOBUFS in in_gif_output %d\n", __LINE__);
 208                 return ENOBUFS;
 209         }
 210 #ifndef __NO_STRICT_ALIGNMENT
 211         if (family == AF_LINK) {
 212                 len = mtod(m, vm_offset_t) & 3;
 213                 KASSERT(len == 0 || len == ETHERIP_ALIGN,
 214                     ("in_gif_output: unexpected misalignment"));
 215                 m->m_data += len;
 216                 m->m_len -= ETHERIP_ALIGN;
 217         }
 218 #endif
 219         bcopy(&iphdr, mtod(m, struct ip *), sizeof(struct ip));
 220
 221         M_SETFIB(m, sc->gif_fibnum);
 222
 223         if (dst->sin_family != sin_dst->sin_family ||
 224             dst->sin_addr.s_addr != sin_dst->sin_addr.s_addr) {
 225                 /* cache route doesn't match */
 226                 bzero(dst, sizeof(*dst));
 227                 dst->sin_family = sin_dst->sin_family;
 228                 dst->sin_len = sizeof(struct sockaddr_in);
 229                 dst->sin_addr = sin_dst->sin_addr;
 230                 if (sc->gif_ro.ro_rt) {
 231                         RTFREE(sc->gif_ro.ro_rt);
 232                         sc->gif_ro.ro_rt = NULL;
 233                 }
 234 #if 0
 235                 GIF2IFP(sc)->if_mtu = GIF_MTU;
 236 #endif
 237         }
 238
 239         if (sc->gif_ro.ro_rt == NULL) {
 240                 in_rtalloc_ign(&sc->gif_ro, 0, sc->gif_fibnum);
 241                 if (sc->gif_ro.ro_rt == NULL) {
 242                         m_freem(m);
 243                         return ENETUNREACH;
 244                 }
 245
 246                 /* if it constitutes infinite encapsulation, punt. */
 247                 if (sc->gif_ro.ro_rt->rt_ifp == ifp) {
 248                         m_freem(m);
 249                         return ENETUNREACH;     /* XXX */
 250                 }
 251 #if 0
 252                 ifp->if_mtu = sc->gif_ro.ro_rt->rt_ifp->if_mtu
 253                         - sizeof(struct ip);
 254 #endif
 255         }
 256
 257         error = ip_output(m, NULL, &sc->gif_ro, 0, NULL, NULL);
 258
 259         if (!(GIF2IFP(sc)->if_flags & IFF_LINK0) &&
 260             sc->gif_ro.ro_rt != NULL) {
 261                 RTFREE(sc->gif_ro.ro_rt);
 262                 sc->gif_ro.ro_rt = NULL;
 263         }
 264
 265         return (error);
 266 }
 267
 268 void
 269 in_gif_input(struct mbuf *m, int off)
 270 {
 271         struct ifnet *gifp = NULL;
 272         struct gif_softc *sc;
 273         struct ip *ip;
 274         int af;
 275         u_int8_t otos;
 276         int proto;
 277
 278         ip = mtod(m, struct ip *);
 279         proto = ip->ip_p;
 280
 281         sc = (struct gif_softc *)encap_getarg(m);
 282         if (sc == NULL) {
 283                 m_freem(m);
 284                 KMOD_IPSTAT_INC(ips_nogif);
 285                 return;
 286         }
 287
 288         gifp = GIF2IFP(sc);
 289         if (gifp == NULL || (gifp->if_flags & IFF_UP) == 0) {
 290                 m_freem(m);
 291                 KMOD_IPSTAT_INC(ips_nogif);
 292                 return;
 293         }
 294
 295         otos = ip->ip_tos;
 296         m_adj(m, off);
 297
 298         switch (proto) {
 299 #ifdef INET
 300         case IPPROTO_IPV4:
 301             {
 302                 struct ip *ip;
 303                 af = AF_INET;
 304                 if (m->m_len < sizeof(*ip)) {
 305                         m = m_pullup(m, sizeof(*ip));
 306                         if (!m)
 307                                 return;
 308                 }
 309                 ip = mtod(m, struct ip *);
 310                 if (ip_ecn_egress((gifp->if_flags & IFF_LINK1) ?
 311                                   ECN_ALLOWED : ECN_NOCARE,
 312                                   &otos, &ip->ip_tos) == 0) {
 313                         m_freem(m);
 314                         return;
 315                 }
 316                 break;
 317             }
 318 #endif
 319 #ifdef INET6
 320         case IPPROTO_IPV6:
 321             {
 322                 struct ip6_hdr *ip6;
 323                 u_int8_t itos, oitos;
 324
 325                 af = AF_INET6;
 326                 if (m->m_len < sizeof(*ip6)) {
 327                         m = m_pullup(m, sizeof(*ip6));
 328                         if (!m)
 329                                 return;
 330                 }
 331                 ip6 = mtod(m, struct ip6_hdr *);
 332                 itos = oitos = (ntohl(ip6->ip6_flow) >> 20) & 0xff;
 333                 if (ip_ecn_egress((gifp->if_flags & IFF_LINK1) ?
 334                                   ECN_ALLOWED : ECN_NOCARE,
 335                                   &otos, &itos) == 0) {
 336                         m_freem(m);
 337                         return;
 338                 }
 339                 if (itos != oitos) {
 340                         ip6->ip6_flow &= ~htonl(0xff << 20);
 341                         ip6->ip6_flow |= htonl((u_int32_t)itos << 20);
 342                 }
 343                 break;
 344             }
 345 #endif /* INET6 */
 346         case IPPROTO_ETHERIP:
 347                 af = AF_LINK;
 348                 break;
 349
 350         default:
 351                 KMOD_IPSTAT_INC(ips_nogif);
 352                 m_freem(m);
 353                 return;
 354         }
 355         gif_input(m, af, gifp);
 356         return;
 357 }
 358
 359 /*
 360  * validate outer address.
 361  */
 362 static int
 363 gif_validate4(const struct ip *ip, struct gif_softc *sc, struct ifnet *ifp)
 364 {
 365         struct sockaddr_in *src, *dst;
 366         struct in_ifaddr *ia4;
 367
 368         src = (struct sockaddr_in *)sc->gif_psrc;
 369         dst = (struct sockaddr_in *)sc->gif_pdst;
 370
 371         /* check for address match */
 372         if (src->sin_addr.s_addr != ip->ip_dst.s_addr ||
 373             dst->sin_addr.s_addr != ip->ip_src.s_addr)
 374                 return 0;
 375
 376         /* martian filters on outer source - NOT done in ip_input! */
 377         if (IN_MULTICAST(ntohl(ip->ip_src.s_addr)))
 378                 return 0;
 379         switch ((ntohl(ip->ip_src.s_addr) & 0xff000000) >> 24) {
 380         case 0: case 127: case 255:
 381                 return 0;
 382         }
 383
 384         /* reject packets with broadcast on source */
 385         /* XXXRW: should use hash lists? */
 386         IN_IFADDR_RLOCK();
 387         TAILQ_FOREACH(ia4, &V_in_ifaddrhead, ia_link) {
 388                 if ((ia4->ia_ifa.ifa_ifp->if_flags & IFF_BROADCAST) == 0)
 389                         continue;
 390                 if (ip->ip_src.s_addr == ia4->ia_broadaddr.sin_addr.s_addr) {
 391                         IN_IFADDR_RUNLOCK();
 392                         return 0;
 393                 }
 394         }
 395         IN_IFADDR_RUNLOCK();
 396
 397         /* ingress filters on outer source */
 398         if ((GIF2IFP(sc)->if_flags & IFF_LINK2) == 0 && ifp) {
 399                 struct sockaddr_in sin;
 400                 struct rtentry *rt;
 401
 402                 bzero(&sin, sizeof(sin));
 403                 sin.sin_family = AF_INET;
 404                 sin.sin_len = sizeof(struct sockaddr_in);
 405                 sin.sin_addr = ip->ip_src;
 406                 /* XXX MRT  check for the interface we would use on output */
 407                 rt = in_rtalloc1((struct sockaddr *)&sin, 0,
 408                     0UL, sc->gif_fibnum);
 409                 if (!rt || rt->rt_ifp != ifp) {
 410 #if 0
 411                         log(LOG_WARNING, "%s: packet from 0x%x dropped "
 412                             "due to ingress filter\n", if_name(GIF2IFP(sc)),
 413                             (u_int32_t)ntohl(sin.sin_addr.s_addr));
 414 #endif
 415                         if (rt)
 416                                 RTFREE_LOCKED(rt);
 417                         return 0;
 418                 }
 419                 RTFREE_LOCKED(rt);
 420         }
 421
 422         return 32 * 2;
 423 }
 424
 425 /*
 426  * we know that we are in IFF_UP, outer address available, and outer family
 427  * matched the physical addr family.  see gif_encapcheck().
 428  */
 429 int
 430 gif_encapcheck4(const struct mbuf *m, int off, int proto, void *arg)
 431 {
 432         struct ip ip;
 433         struct gif_softc *sc;
 434         struct ifnet *ifp;
 435
 436         /* sanity check done in caller */
 437         sc = (struct gif_softc *)arg;
 438
 439         /* LINTED const cast */
 440         m_copydata(m, 0, sizeof(ip), (caddr_t)&ip);
 441         ifp = ((m->m_flags & M_PKTHDR) != 0) ? m->m_pkthdr.rcvif : NULL;
 442
 443         return gif_validate4(&ip, sc, ifp);
 444 }
 445
 446 int
 447 in_gif_attach(struct gif_softc *sc)
 448 {
 449         sc->encap_cookie4 = encap_attach_func(AF_INET, -1, gif_encapcheck,
 450             &in_gif_protosw, sc);
 451         if (sc->encap_cookie4 == NULL)
 452                 return EEXIST;
 453         return 0;
 454 }
 455
 456 int
 457 in_gif_detach(struct gif_softc *sc)
 458 {
 459         int error;
 460
 461         error = encap_detach(sc->encap_cookie4);
 462         if (error == 0)
 463                 sc->encap_cookie4 = NULL;
 464         return error;
 465 }