ip_tunnel.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2013 Nicira, Inc.
 */

#define pr_fmt(fmt) …

#include <linux/capability.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/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/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 <linux/if_vlan.h>
#include <linux/rculist.h>
#include <linux/err.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/udp.h>
#include <net/dst_metadata.h>

#if IS_ENABLED(CONFIG_IPV6)
#include <net/ipv6.h>
#include <net/ip6_fib.h>
#include <net/ip6_route.h>
#endif

static unsigned int ip_tunnel_hash(__be32 key, __be32 remote)
{ … }

static bool ip_tunnel_key_match(const struct ip_tunnel_parm_kern *p,
				const unsigned long *flags, __be32 key)
{ … }

/* Fallback tunnel: no source, no destination, no key, no options

   Tunnel hash table:
   We require exact key match i.e. if a key is present in packet
   it will match only tunnel with the same key; if it is not present,
   it will match only keyless tunnel.

   All keysless packets, if not matched configured keyless tunnels
   will match fallback tunnel.
   Given src, dst and key, find appropriate for input tunnel.
*/
struct ip_tunnel *ip_tunnel_lookup(struct ip_tunnel_net *itn,
				   int link, const unsigned long *flags,
				   __be32 remote, __be32 local,
				   __be32 key)
{ … }
EXPORT_SYMBOL_GPL(…);

static struct hlist_head *ip_bucket(struct ip_tunnel_net *itn,
				    struct ip_tunnel_parm_kern *parms)
{ … }

static void ip_tunnel_add(struct ip_tunnel_net *itn, struct ip_tunnel *t)
{ … }

static void ip_tunnel_del(struct ip_tunnel_net *itn, struct ip_tunnel *t)
{ … }

static struct ip_tunnel *ip_tunnel_find(struct ip_tunnel_net *itn,
					struct ip_tunnel_parm_kern *parms,
					int type)
{ … }

static struct net_device *__ip_tunnel_create(struct net *net,
					     const struct rtnl_link_ops *ops,
					     struct ip_tunnel_parm_kern *parms)
{ … }

static int ip_tunnel_bind_dev(struct net_device *dev)
{ … }

static struct ip_tunnel *ip_tunnel_create(struct net *net,
					  struct ip_tunnel_net *itn,
					  struct ip_tunnel_parm_kern *parms)
{ … }

void ip_tunnel_md_udp_encap(struct sk_buff *skb, struct ip_tunnel_info *info)
{ … }
EXPORT_SYMBOL(…);

int ip_tunnel_rcv(struct ip_tunnel *tunnel, struct sk_buff *skb,
		  const struct tnl_ptk_info *tpi, struct metadata_dst *tun_dst,
		  bool log_ecn_error)
{ … }
EXPORT_SYMBOL_GPL(…);

int ip_tunnel_encap_add_ops(const struct ip_tunnel_encap_ops *ops,
			    unsigned int num)
{ … }
EXPORT_SYMBOL(…);

int ip_tunnel_encap_del_ops(const struct ip_tunnel_encap_ops *ops,
			    unsigned int num)
{ … }
EXPORT_SYMBOL(…);

int ip_tunnel_encap_setup(struct ip_tunnel *t,
			  struct ip_tunnel_encap *ipencap)
{ … }
EXPORT_SYMBOL_GPL(…);

static int tnl_update_pmtu(struct net_device *dev, struct sk_buff *skb,
			    struct rtable *rt, __be16 df,
			    const struct iphdr *inner_iph,
			    int tunnel_hlen, __be32 dst, bool md)
{ … }

static void ip_tunnel_adj_headroom(struct net_device *dev, unsigned int headroom)
{ … }

void ip_md_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
		       u8 proto, int tunnel_hlen)
{ … }
EXPORT_SYMBOL_GPL(…);

void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
		    const struct iphdr *tnl_params, u8 protocol)
{ … }
EXPORT_SYMBOL_GPL(…);

static void ip_tunnel_update(struct ip_tunnel_net *itn,
			     struct ip_tunnel *t,
			     struct net_device *dev,
			     struct ip_tunnel_parm_kern *p,
			     bool set_mtu,
			     __u32 fwmark)
{ … }

int ip_tunnel_ctl(struct net_device *dev, struct ip_tunnel_parm_kern *p,
		  int cmd)
{ … }
EXPORT_SYMBOL_GPL(…);

bool ip_tunnel_parm_from_user(struct ip_tunnel_parm_kern *kp,
			      const void __user *data)
{ … }
EXPORT_SYMBOL_GPL(…);

bool ip_tunnel_parm_to_user(void __user *data, struct ip_tunnel_parm_kern *kp)
{ … }
EXPORT_SYMBOL_GPL(…);

int ip_tunnel_siocdevprivate(struct net_device *dev, struct ifreq *ifr,
			     void __user *data, int cmd)
{ … }
EXPORT_SYMBOL_GPL(…);

int __ip_tunnel_change_mtu(struct net_device *dev, int new_mtu, bool strict)
{ … }
EXPORT_SYMBOL_GPL(…);

int ip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
{ … }
EXPORT_SYMBOL_GPL(…);

static void ip_tunnel_dev_free(struct net_device *dev)
{ … }

void ip_tunnel_dellink(struct net_device *dev, struct list_head *head)
{ … }
EXPORT_SYMBOL_GPL(…);

struct net *ip_tunnel_get_link_net(const struct net_device *dev)
{ … }
EXPORT_SYMBOL(…);

int ip_tunnel_get_iflink(const struct net_device *dev)
{ … }
EXPORT_SYMBOL(…);

int ip_tunnel_init_net(struct net *net, unsigned int ip_tnl_net_id,
				  struct rtnl_link_ops *ops, char *devname)
{ … }
EXPORT_SYMBOL_GPL(…);

static void ip_tunnel_destroy(struct net *net, struct ip_tunnel_net *itn,
			      struct list_head *head,
			      struct rtnl_link_ops *ops)
{ … }

void ip_tunnel_delete_nets(struct list_head *net_list, unsigned int id,
			   struct rtnl_link_ops *ops,
			   struct list_head *dev_to_kill)
{ … }
EXPORT_SYMBOL_GPL(…);

int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[],
		      struct ip_tunnel_parm_kern *p, __u32 fwmark)
{ … }
EXPORT_SYMBOL_GPL(…);

int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
			 struct ip_tunnel_parm_kern *p, __u32 fwmark)
{ … }
EXPORT_SYMBOL_GPL(…);

int ip_tunnel_init(struct net_device *dev)
{ … }
EXPORT_SYMBOL_GPL(…);

void ip_tunnel_uninit(struct net_device *dev)
{ … }
EXPORT_SYMBOL_GPL(…);

/* Do least required initialization, rest of init is done in tunnel_init call */
void ip_tunnel_setup(struct net_device *dev, unsigned int net_id)
{ … }
EXPORT_SYMBOL_GPL(…);

MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;
linux/net/ipv4/ip_tunnel.c
