cregit-Linux how code gets into the kernel

Release 4.8 net/ipv4/ip_gre.c

Directory: net/ipv4
/*
 *      Linux NET3:     GRE over IP protocol decoder.
 *
 *      Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 *
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/capability.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/if_arp.h>
#include <linux/if_vlan.h>
#include <linux/init.h>
#include <linux/in6.h>
#include <linux/inetdevice.h>
#include <linux/igmp.h>
#include <linux/netfilter_ipv4.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>

#include <net/sock.h>
#include <net/ip.h>
#include <net/icmp.h>
#include <net/protocol.h>
#include <net/ip_tunnels.h>
#include <net/arp.h>
#include <net/checksum.h>
#include <net/dsfield.h>
#include <net/inet_ecn.h>
#include <net/xfrm.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
#include <net/rtnetlink.h>
#include <net/gre.h>
#include <net/dst_metadata.h>

/*
   Problems & solutions
   --------------------

   1. The most important issue is detecting local dead loops.
   They would cause complete host lockup in transmit, which
   would be "resolved" by stack overflow or, if queueing is enabled,
   with infinite looping in net_bh.

   We cannot track such dead loops during route installation,
   it is infeasible task. The most general solutions would be
   to keep skb->encapsulation counter (sort of local ttl),
   and silently drop packet when it expires. It is a good
   solution, but it supposes maintaining new variable in ALL
   skb, even if no tunneling is used.

   Current solution: xmit_recursion breaks dead loops. This is a percpu
   counter, since when we enter the first ndo_xmit(), cpu migration is
   forbidden. We force an exit if this counter reaches RECURSION_LIMIT

   2. Networking dead loops would not kill routers, but would really
   kill network. IP hop limit plays role of "t->recursion" in this case,
   if we copy it from packet being encapsulated to upper header.
   It is very good solution, but it introduces two problems:

   - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
     do not work over tunnels.
   - traceroute does not work. I planned to relay ICMP from tunnel,
     so that this problem would be solved and traceroute output
     would even more informative. This idea appeared to be wrong:
     only Linux complies to rfc1812 now (yes, guys, Linux is the only
     true router now :-)), all routers (at least, in neighbourhood of mine)
     return only 8 bytes of payload. It is the end.

   Hence, if we want that OSPF worked or traceroute said something reasonable,
   we should search for another solution.

   One of them is to parse packet trying to detect inner encapsulation
   made by our node. It is difficult or even impossible, especially,
   taking into account fragmentation. TO be short, ttl is not solution at all.

   Current solution: The solution was UNEXPECTEDLY SIMPLE.
   We force DF flag on tunnels with preconfigured hop limit,
   that is ALL. :-) Well, it does not remove the problem completely,
   but exponential growth of network traffic is changed to linear
   (branches, that exceed pmtu are pruned) and tunnel mtu
   rapidly degrades to value <68, where looping stops.
   Yes, it is not good if there exists a router in the loop,
   which does not force DF, even when encapsulating packets have DF set.
   But it is not our problem! Nobody could accuse us, we made
   all that we could make. Even if it is your gated who injected
   fatal route to network, even if it were you who configured
   fatal static route: you are innocent. :-)

   Alexey Kuznetsov.
 */


static bool log_ecn_error = true;
module_param(log_ecn_error, bool, 0644);
MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");


static struct rtnl_link_ops ipgre_link_ops __read_mostly;
static int ipgre_tunnel_init(struct net_device *dev);


static int ipgre_net_id __read_mostly;

static int gre_tap_net_id __read_mostly;


static void ipgre_err(struct sk_buff *skb, u32 info, const struct tnl_ptk_info *tpi) { /* All the routers (except for Linux) return only 8 bytes of packet payload. It means, that precise relaying of ICMP in the real Internet is absolutely infeasible. Moreover, Cisco "wise men" put GRE key to the third word in GRE header. It makes impossible maintaining even soft state for keyed GRE tunnels with enabled checksum. Tell them "thank you". Well, I wonder, rfc1812 was written by Cisco employee, what the hell these idiots break standards established by themselves??? */ struct net *net = dev_net(skb->dev); struct ip_tunnel_net *itn; const struct iphdr *iph; const int type = icmp_hdr(skb)->type; const int code = icmp_hdr(skb)->code; unsigned int data_len = 0; struct ip_tunnel *t; switch (type) { default: case ICMP_PARAMETERPROB: return; case ICMP_DEST_UNREACH: switch (code) { case ICMP_SR_FAILED: case ICMP_PORT_UNREACH: /* Impossible event. */ return; default: /* All others are translated to HOST_UNREACH. rfc2003 contains "deep thoughts" about NET_UNREACH, I believe they are just ether pollution. --ANK */ break; } break; case ICMP_TIME_EXCEEDED: if (code != ICMP_EXC_TTL) return; data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */ break; case ICMP_REDIRECT: break; } if (tpi->proto == htons(ETH_P_TEB)) itn = net_generic(net, gre_tap_net_id); else itn = net_generic(net, ipgre_net_id); iph = (const struct iphdr *)(icmp_hdr(skb) + 1); t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags, iph->daddr, iph->saddr, tpi->key); if (!t) return; #if IS_ENABLED(CONFIG_IPV6) if (tpi->proto == htons(ETH_P_IPV6) && !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len, type, data_len)) return; #endif if (t->parms.iph.daddr == 0 || ipv4_is_multicast(t->parms.iph.daddr)) return; if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED) return; if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO)) t->err_count++; else t->err_count = 1; t->err_time = jiffies; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar15847.16%316.67%
eric dumazeteric dumazet7722.99%527.78%
pre-gitpre-git308.96%15.56%
timo terastimo teras308.96%211.11%
herbert xuherbert xu154.48%15.56%
stephen hemmingerstephen hemminger133.88%15.56%
duan jiongduan jiong72.09%15.56%
pavel emelianovpavel emelianov20.60%15.56%
ian morrisian morris10.30%15.56%
americo wangamerico wang10.30%15.56%
joe perchesjoe perches10.30%15.56%
Total335100.00%18100.00%


static void gre_err(struct sk_buff *skb, u32 info) { /* All the routers (except for Linux) return only * 8 bytes of packet payload. It means, that precise relaying of * ICMP in the real Internet is absolutely infeasible. * * Moreover, Cisco "wise men" put GRE key to the third word * in GRE header. It makes impossible maintaining even soft * state for keyed * GRE tunnels with enabled checksum. Tell them "thank you". * * Well, I wonder, rfc1812 was written by Cisco employee, * what the hell these idiots break standards established * by themselves??? */ const struct iphdr *iph = (struct iphdr *)skb->data; const int type = icmp_hdr(skb)->type; const int code = icmp_hdr(skb)->code; struct tnl_ptk_info tpi; bool csum_err = false; if (gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), iph->ihl * 4) < 0) { if (!csum_err) /* ignore csum errors. */ return; } if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) { ipv4_update_pmtu(skb, dev_net(skb->dev), info, skb->dev->ifindex, 0, IPPROTO_GRE, 0); return; } if (type == ICMP_REDIRECT) { ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0, IPPROTO_GRE, 0); return; } ipgre_err(skb, info, &tpi); }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar14883.15%116.67%
eric dumazeteric dumazet2111.80%116.67%
haishuang yanhaishuang yan52.81%116.67%
jiri bencjiri benc21.12%116.67%
tom herberttom herbert10.56%116.67%
timo terastimo teras10.56%116.67%
Total178100.00%6100.00%


static __be64 key_to_tunnel_id(__be32 key) { #ifdef __BIG_ENDIAN return (__force __be64)((__force u32)key); #else return (__force __be64)((__force u64)key << 32); #endif }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar44100.00%1100.00%
Total44100.00%1100.00%

/* Returns the least-significant 32 bits of a __be64. */
static __be32 tunnel_id_to_key(__be64 x) { #ifdef __BIG_ENDIAN return (__force __be32)x; #else return (__force __be32)((__force u64)x >> 32); #endif }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar38100.00%1100.00%
Total38100.00%1100.00%


static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi, struct ip_tunnel_net *itn, int hdr_len, bool raw_proto) { struct metadata_dst *tun_dst = NULL; const struct iphdr *iph; struct ip_tunnel *tunnel; iph = ip_hdr(skb); tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags, iph->saddr, iph->daddr, tpi->key); if (tunnel) { if (__iptunnel_pull_header(skb, hdr_len, tpi->proto, raw_proto, false) < 0) goto drop; if (tunnel->dev->type != ARPHRD_NONE) skb_pop_mac_header(skb); else skb_reset_mac_header(skb); if (tunnel->collect_md) { __be16 flags; __be64 tun_id; flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY); tun_id = key_to_tunnel_id(tpi->key); tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0); if (!tun_dst) return PACKET_REJECT; } ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error); return PACKET_RCVD; } return PACKET_NEXT; drop: kfree_skb(skb); return PACKET_RCVD; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar13562.50%430.77%
jiri bencjiri benc5927.31%323.08%
timo terastimo teras115.09%323.08%
herbert xuherbert xu52.31%17.69%
pre-gitpre-git41.85%17.69%
david s. millerdavid s. miller20.93%17.69%
Total216100.00%13100.00%


static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi, int hdr_len) { struct net *net = dev_net(skb->dev); struct ip_tunnel_net *itn; int res; if (tpi->proto == htons(ETH_P_TEB)) itn = net_generic(net, gre_tap_net_id); else itn = net_generic(net, ipgre_net_id); res = __ipgre_rcv(skb, tpi, itn, hdr_len, false); if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) { /* ipgre tunnels in collect metadata mode should receive * also ETH_P_TEB traffic. */ itn = net_generic(net, ipgre_net_id); res = __ipgre_rcv(skb, tpi, itn, hdr_len, true); } return res; }

Contributors

PersonTokensPropCommitsCommitProp
jiri bencjiri benc130100.00%1100.00%
Total130100.00%1100.00%


static int gre_rcv(struct sk_buff *skb) { struct tnl_ptk_info tpi; bool csum_err = false; int hdr_len; #ifdef CONFIG_NET_IPGRE_BROADCAST if (ipv4_is_multicast(ip_hdr(skb)->daddr)) { /* Looped back packet, drop it! */ if (rt_is_output_route(skb_rtable(skb))) goto drop; } #endif hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0); if (hdr_len < 0) goto drop; if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD) return 0; icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0); drop: kfree_skb(skb); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar10484.55%116.67%
jiri bencjiri benc86.50%233.33%
haishuang yanhaishuang yan54.07%116.67%
tom herberttom herbert43.25%116.67%
eric dumazeteric dumazet21.63%116.67%
Total123100.00%6100.00%


static void __gre_xmit(struct sk_buff *skb, struct net_device *dev, const struct iphdr *tnl_params, __be16 proto) { struct ip_tunnel *tunnel = netdev_priv(dev); if (tunnel->parms.o_flags & TUNNEL_SEQ) tunnel->o_seqno++; /* Push GRE header. */ gre_build_header(skb, tunnel->tun_hlen, tunnel->parms.o_flags, proto, tunnel->parms.o_key, htonl(tunnel->o_seqno)); ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol); }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar9398.94%150.00%
tom herberttom herbert11.06%150.00%
Total94100.00%2100.00%


static int gre_handle_offloads(struct sk_buff *skb, bool csum) { return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE); }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar2596.15%150.00%
alexander duyckalexander duyck13.85%150.00%
Total26100.00%2100.00%


static struct rtable *gre_get_rt(struct sk_buff *skb, struct net_device *dev, struct flowi4 *fl, const struct ip_tunnel_key *key) { struct net *net = dev_net(dev); memset(fl, 0, sizeof(*fl)); fl->daddr = key->u.ipv4.dst; fl->saddr = key->u.ipv4.src; fl->flowi4_tos = RT_TOS(key->tos); fl->flowi4_mark = skb->mark; fl->flowi4_proto = IPPROTO_GRE; return ip_route_output_key(net, fl); }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar109100.00%2100.00%
Total109100.00%2100.00%


static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev, __be16 proto) { struct ip_tunnel_info *tun_info; const struct ip_tunnel_key *key; struct rtable *rt = NULL; struct flowi4 fl; int min_headroom; int tunnel_hlen; __be16 df, flags; bool use_cache; int err; tun_info = skb_tunnel_info(skb); if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) || ip_tunnel_info_af(tun_info) != AF_INET)) goto err_free_skb; key = &tun_info->key; use_cache = ip_tunnel_dst_cache_usable(skb, tun_info); if (use_cache) rt = dst_cache_get_ip4(&tun_info->dst_cache, &fl.saddr); if (!rt) { rt = gre_get_rt(skb, dev, &fl, key); if (IS_ERR(rt)) goto err_free_skb; if (use_cache) dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst, fl.saddr); } tunnel_hlen = gre_calc_hlen(key->tun_flags); min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len + tunnel_hlen + sizeof(struct iphdr); if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) { int head_delta = SKB_DATA_ALIGN(min_headroom - skb_headroom(skb) + 16); err = pskb_expand_head(skb, max_t(int, head_delta, 0), 0, GFP_ATOMIC); if (unlikely(err)) goto err_free_rt; } /* Push Tunnel header. */ if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM))) goto err_free_rt; flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY); gre_build_header(skb, tunnel_hlen, flags, proto, tunnel_id_to_key(tun_info->key.tun_id), 0); df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0; iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE, key->tos, key->ttl, df, false); return; err_free_rt: ip_rt_put(rt); err_free_skb: kfree_skb(skb); dev->stats.tx_dropped++; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar30675.18%316.67%
paolo abenipaolo abeni4310.57%15.56%
daniel borkmanndaniel borkmann235.65%15.56%
jiri bencjiri benc225.41%527.78%
tom herberttom herbert51.23%316.67%
pavel emelianovpavel emelianov30.74%15.56%
alexander duyckalexander duyck20.49%15.56%
herbert xuherbert xu10.25%15.56%
nicolas dichtelnicolas dichtel10.25%15.56%
stephen hemmingerstephen hemminger10.25%15.56%
Total407100.00%18100.00%


static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb) { struct ip_tunnel_info *info = skb_tunnel_info(skb); struct rtable *rt; struct flowi4 fl4; if (ip_tunnel_info_af(info) != AF_INET) return -EINVAL; rt = gre_get_rt(skb, dev, &fl4, &info->key); if (IS_ERR(rt)) return PTR_ERR(rt); ip_rt_put(rt); info->key.u.ipv4.src = fl4.saddr; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar100100.00%1100.00%
Total100100.00%1100.00%


static netdev_tx_t ipgre_xmit(struct sk_buff *skb, struct net_device *dev) { struct ip_tunnel *tunnel = netdev_priv(dev); const struct iphdr *tnl_params; if (tunnel->collect_md) { gre_fb_xmit(skb, dev, skb->protocol); return NETDEV_TX_OK; } if (dev->header_ops) { /* Need space for new headers */ if (skb_cow_head(skb, dev->needed_headroom - (tunnel->hlen + sizeof(struct iphdr)))) goto free_skb; tnl_params = (const struct iphdr *)skb->data; /* Pull skb since ip_tunnel_xmit() needs skb->data pointing * to gre header. */ skb_pull(skb, tunnel->hlen + sizeof(struct iphdr)); skb_reset_mac_header(skb); } else { if (skb_cow_head(skb, dev->needed_headroom)) goto free_skb; tnl_params = &tunnel->parms.iph; } if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM))) goto free_skb; __gre_xmit(skb, dev, tnl_params, skb->protocol); return NETDEV_TX_OK; free_skb: kfree_skb(skb); dev->stats.tx_dropped++; return NETDEV_TX_OK; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar14269.95%214.29%
timo terastimo teras2411.82%17.14%
pre-gitpre-git136.40%321.43%
willem de bruijnwillem de bruijn83.94%17.14%
pavel emelianovpavel emelianov41.97%214.29%
jiri bencjiri benc41.97%17.14%
alexander duyckalexander duyck31.48%17.14%
patrick mchardypatrick mchardy31.48%17.14%
eric dumazeteric dumazet10.49%17.14%
paul e. erkkilapaul e. erkkila10.49%17.14%
Total203100.00%14100.00%


static netdev_tx_t gre_tap_xmit(struct sk_buff *skb, struct net_device *dev) { struct ip_tunnel *tunnel = netdev_priv(dev); if (tunnel->collect_md) { gre_fb_xmit(skb, dev, htons(ETH_P_TEB)); return NETDEV_TX_OK; } if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM))) goto free_skb; if (skb_cow_head(skb, dev->needed_headroom)) goto free_skb; __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB)); return NETDEV_TX_OK; free_skb: kfree_skb(skb); dev->stats.tx_dropped++; return NETDEV_TX_OK; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar8971.77%325.00%
pre-gitpre-git1512.10%433.33%
pavel emelianovpavel emelianov97.26%18.33%
jiri bencjiri benc54.03%18.33%
alexander duyckalexander duyck32.42%18.33%
patrick mchardypatrick mchardy21.61%18.33%
eric dumazeteric dumazet10.81%18.33%
Total124100.00%12100.00%


static int ipgre_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) { int err; struct ip_tunnel_parm p; if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) return -EFAULT; if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) { if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE || p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) || ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING))) return -EINVAL; } p.i_flags = gre_flags_to_tnl_flags(p.i_flags); p.o_flags = gre_flags_to_tnl_flags(p.o_flags); err = ip_tunnel_ioctl(dev, &p, cmd); if (err) return err; p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags); p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags); if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p))) return -EFAULT; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar13061.32%110.00%
pre-gitpre-git3717.45%110.00%
eric dumazeteric dumazet157.08%220.00%
americo wangamerico wang115.19%110.00%
stephen hemmingerstephen hemminger104.72%110.00%
ville nuorvalaville nuorvala41.89%110.00%
tom herberttom herbert20.94%110.00%
arnaldo carvalho de meloarnaldo carvalho de melo20.94%110.00%
adrian bunkadrian bunk10.47%110.00%
Total212100.00%10100.00%

/* Nice toy. Unfortunately, useless in real life :-) It allows to construct virtual multiprotocol broadcast "LAN" over the Internet, provided multicast routing is tuned. I have no idea was this bicycle invented before me, so that I had to set ARPHRD_IPGRE to a random value. I have an impression, that Cisco could make something similar, but this feature is apparently missing in IOS<=11.2(8). I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks with broadcast 224.66.66.66. If you have access to mbone, play with me :-) ping -t 255 224.66.66.66 If nobody answers, mbone does not work. ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255 ip addr add 10.66.66.<somewhat>/24 dev Universe ifconfig Universe up ifconfig Universe add fe80::<Your_real_addr>/10 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96 ftp 10.66.66.66 ... ftp fec0:6666:6666::193.233.7.65 ... */
static int ipgre_header(struct sk_buff *skb, struct net_device *dev, unsigned short type, const void *daddr, const void *saddr, unsigned int len) { struct ip_tunnel *t = netdev_priv(dev); struct iphdr *iph; struct gre_base_hdr *greh; iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph)); greh = (struct gre_base_hdr *)(iph+1); greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags); greh->protocol = htons(type); memcpy(iph, &t->parms.iph, sizeof(struct iphdr)); /* Set the source hardware address. */ if (saddr) memcpy(&iph->saddr, saddr, 4); if (daddr) memcpy(&iph->daddr, daddr, 4); if (iph->daddr) return t->hlen + sizeof(*iph); return -(t->hlen + sizeof(*iph)); }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar11258.03%15.56%
pavel emelianovpavel emelianov2915.03%316.67%
pre-gitpre-git2412.44%316.67%
eric dumazeteric dumazet115.70%316.67%
timo terastimo teras63.11%15.56%
ville nuorvalaville nuorvala31.55%15.56%
patrick mchardypatrick mchardy31.55%15.56%
stephen hemmingerstephen hemminger21.04%211.11%
adrian bunkadrian bunk10.52%15.56%
tom herberttom herbert10.52%15.56%
alexey dobriyanalexey dobriyan10.52%15.56%
Total193100.00%18100.00%


static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr) { const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb); memcpy(haddr, &iph->saddr, 4); return 4; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar3367.35%125.00%
pavel emelianovpavel emelianov1428.57%250.00%
eric dumazeteric dumazet24.08%125.00%
Total49100.00%4100.00%

static const struct header_ops ipgre_header_ops = { .create = ipgre_header, .parse = ipgre_header_parse, }; #ifdef CONFIG_NET_IPGRE_BROADCAST
static int ipgre_open(struct net_device *dev) { struct ip_tunnel *t = netdev_priv(dev); if (ipv4_is_multicast(t->parms.iph.daddr)) { struct flowi4 fl4; struct rtable *rt; rt = ip_route_output_gre(t->net, &fl4, t->parms.iph.daddr, t->parms.iph.saddr, t->parms.o_key, RT_TOS(t->parms.iph.tos), t->parms.link); if (IS_ERR(rt)) return -EADDRNOTAVAIL; dev = rt->dst.dev; ip_rt_put(rt); if (!__in_dev_get_rtnl(dev)) return -EADDRNOTAVAIL; t->mlink = dev->ifindex; ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr); } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar12477.99%19.09%
herbert xuherbert xu95.66%19.09%
pavel emelianovpavel emelianov95.66%218.18%
david s. millerdavid s. miller85.03%218.18%
pre-gitpre-git31.89%19.09%
nicolas dichtelnicolas dichtel31.89%19.09%
ian morrisian morris10.63%19.09%
al viroal viro10.63%19.09%
stephen hemmingerstephen hemminger10.63%19.09%
Total159100.00%11100.00%


static int ipgre_close(struct net_device *