gtp: add initial driver for datapath of GPRS Tunneling Protocol (GTP-U)

This is an initial implementation of a netdev driver for GTP datapath (GTP-U) v0 and v1, according to the GSM TS 09.60 and 3GPP TS 29.060 standards. This tunneling protocol is used to prevent subscribers from accessing mobile carrier core network infrastructure. This implementation requires a GGSN userspace daemon that implements the signaling protocol (GTP-C), such as OpenGGSN [1]. This userspace daemon updates the PDP context database that represents active subscriber sessions through a genetlink interface. For more context on this tunneling protocol, you can check the slides that were presented during the NetDev 1.1 [2]. Only IPv4 is supported at this time. [1] http://git.osmocom.org/openggsn/ [2] http://www.netdevconf.org/1.1/proceedings/slides/schultz-welte-osmocom-gtp.pdf

Pablo Neira committed 10 years ago

Commit 459aa661 parent c047c3b8 files · +1462 −1Browse files

Unified · Split

8 files

drivers/net/Kconfig +17 −0
drivers/net/Makefile +1 −0
drivers/net/gtp.c +1364 −0
include/net/gtp.h +34 −0
include/uapi/linux/Kbuild +1 −0
include/uapi/linux/gtp.h +33 −0
include/uapi/linux/if_link.h +10 −0
include/uapi/linux/udp.h +2 −1

drivers/net/Kconfig+17−0

@@ -192,6 +192,23 @@ config GENEVE · 191 unmodified lines
192	To compile this driver as a module, choose M here: the module	192	To compile this driver as a module, choose M here: the module
193	will be called geneve.	193	will be called geneve.
194		194
		195	config GTP
		196	tristate "GPRS Tunneling Protocol datapath (GTP-U)"
		197	depends on INET && NET_UDP_TUNNEL
		198	select NET_IP_TUNNEL
		199	---help---
		200	This allows one to create gtp virtual interfaces that provide
		201	the GPRS Tunneling Protocol datapath (GTP-U). This tunneling protocol
		202	is used to prevent subscribers from accessing mobile carrier core
		203	network infrastructure. This driver requires a userspace software that
		204	implements the signaling protocol (GTP-C) to update its PDP context
		205	base, such as OpenGGSN <http://git.osmocom.org/openggsn/). This
		206	tunneling protocol is implemented according to the GSM TS 09.60 and
		207	3GPP TS 29.060 standards.
		208
		209	To compile this drivers as a module, choose M here: the module
		210	wil be called gtp.
		211
195	config MACSEC	212	config MACSEC
196	tristate "IEEE 802.1AE MAC-level encryption (MACsec)"	213	tristate "IEEE 802.1AE MAC-level encryption (MACsec)"
197	select CRYPTO	214	select CRYPTO

drivers/net/Makefile+1−0

@@ -25,6 +25,7 @@ obj-$(CONFIG_VETH) += veth.o · 24 unmodified lines
25	obj-$(CONFIG_VIRTIO_NET) += virtio_net.o	25	obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
26	obj-$(CONFIG_VXLAN) += vxlan.o	26	obj-$(CONFIG_VXLAN) += vxlan.o
27	obj-$(CONFIG_GENEVE) += geneve.o	27	obj-$(CONFIG_GENEVE) += geneve.o
		28	obj-$(CONFIG_GTP) += gtp.o
28	obj-$(CONFIG_NLMON) += nlmon.o	29	obj-$(CONFIG_NLMON) += nlmon.o
29	obj-$(CONFIG_NET_VRF) += vrf.o	30	obj-$(CONFIG_NET_VRF) += vrf.o
30		31

drivers/net/gtp.c+1364−0

@@ -0,0 +1,1364 @@
	1	/* GTP according to GSM TS 09.60 / 3GPP TS 29.060
	2	*
	3	* (C) 2012-2014 by sysmocom - s.f.m.c. GmbH
	4	* (C) 2016 by Pablo Neira Ayuso <pablo@netfilter.org>
	5	*
	6	* Author: Harald Welte <hwelte@sysmocom.de>
	7	* Pablo Neira Ayuso <pablo@netfilter.org>
	8	* Andreas Schultz <aschultz@travelping.com>
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public License
	12	* as published by the Free Software Foundation; either version
	13	* 2 of the License, or (at your option) any later version.
	14	*/
	15
	16	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	17
	18	#include <linux/module.h>
	19	#include <linux/version.h>
	20	#include <linux/skbuff.h>
	21	#include <linux/udp.h>
	22	#include <linux/rculist.h>
	23	#include <linux/jhash.h>
	24	#include <linux/if_tunnel.h>
	25	#include <linux/net.h>
	26	#include <linux/file.h>
	27	#include <linux/gtp.h>
	28
	29	#include <net/net_namespace.h>
	30	#include <net/protocol.h>
	31	#include <net/ip.h>
	32	#include <net/udp.h>
	33	#include <net/udp_tunnel.h>
	34	#include <net/icmp.h>
	35	#include <net/xfrm.h>
	36	#include <net/genetlink.h>
	37	#include <net/netns/generic.h>
	38	#include <net/gtp.h>
	39
	40	/* An active session for the subscriber. */
	41	struct pdp_ctx {
	42	struct hlist_node hlist_tid;
	43	struct hlist_node hlist_addr;
	44
	45	union {
	46	u64 tid;
	47	struct {
	48	u64 tid;
	49	u16 flow;
	50	} v0;
	51	struct {
	52	u32 i_tei;
	53	u32 o_tei;
	54	} v1;
	55	} u;
	56	u8 gtp_version;
	57	u16 af;
	58
	59	struct in_addr ms_addr_ip4;
	60	struct in_addr sgsn_addr_ip4;
	61
	62	atomic_t tx_seq;
	63	struct rcu_head rcu_head;
	64	};
	65
	66	/* One instance of the GTP device. */
	67	struct gtp_dev {
	68	struct list_head list;
	69
	70	struct socket *sock0;
	71	struct socket *sock1u;
	72
	73	struct net *net;
	74	struct net_device *dev;
	75
	76	unsigned int hash_size;
	77	struct hlist_head *tid_hash;
	78	struct hlist_head *addr_hash;
	79	};
	80
	81	static int gtp_net_id __read_mostly;
	82
	83	struct gtp_net {
	84	struct list_head gtp_dev_list;
	85	};
	86
	87	static u32 gtp_h_initval;
	88
	89	static inline u32 gtp0_hashfn(u64 tid)
	90	{
	91	u32 tid32 = (u32 ) &tid;
	92	return jhash_2words(tid32[0], tid32[1], gtp_h_initval);
	93	}
	94
	95	static inline u32 gtp1u_hashfn(u32 tid)
	96	{
	97	return jhash_1word(tid, gtp_h_initval);
	98	}
	99
	100	static inline u32 ipv4_hashfn(__be32 ip)
	101	{
	102	return jhash_1word((__force u32)ip, gtp_h_initval);
	103	}
	104
	105	/* Resolve a PDP context structure based on the 64bit TID. */
	106	static struct pdp_ctx gtp0_pdp_find(struct gtp_dev gtp, u64 tid)
	107	{
	108	struct hlist_head *head;
	109	struct pdp_ctx *pdp;
	110
	111	head = &gtp->tid_hash[gtp0_hashfn(tid) % gtp->hash_size];
	112
	113	hlist_for_each_entry_rcu(pdp, head, hlist_tid) {
	114	if (pdp->gtp_version == GTP_V0 &&
	115	pdp->u.v0.tid == tid)
	116	return pdp;
	117	}
	118	return NULL;
	119	}
	120
	121	/* Resolve a PDP context structure based on the 32bit TEI. */
	122	static struct pdp_ctx gtp1_pdp_find(struct gtp_dev gtp, u32 tid)
	123	{
	124	struct hlist_head *head;
	125	struct pdp_ctx *pdp;
	126
	127	head = &gtp->tid_hash[gtp1u_hashfn(tid) % gtp->hash_size];
	128
	129	hlist_for_each_entry_rcu(pdp, head, hlist_tid) {
	130	if (pdp->gtp_version == GTP_V1 &&
	131	pdp->u.v1.i_tei == tid)
	132	return pdp;
	133	}
	134	return NULL;
	135	}
	136
	137	/* Resolve a PDP context based on IPv4 address of MS. */
	138	static struct pdp_ctx ipv4_pdp_find(struct gtp_dev gtp, __be32 ms_addr)
	139	{
	140	struct hlist_head *head;
	141	struct pdp_ctx *pdp;
	142
	143	head = &gtp->addr_hash[ipv4_hashfn(ms_addr) % gtp->hash_size];
	144
	145	hlist_for_each_entry_rcu(pdp, head, hlist_addr) {
	146	if (pdp->af == AF_INET &&
	147	pdp->ms_addr_ip4.s_addr == ms_addr)
	148	return pdp;
	149	}
	150
	151	return NULL;
	152	}
	153
	154	static bool gtp_check_src_ms_ipv4(struct sk_buff skb, struct pdp_ctx pctx,
	155	unsigned int hdrlen)
	156	{
	157	struct iphdr *iph;
	158
	159	if (!pskb_may_pull(skb, hdrlen + sizeof(struct iphdr)))
	160	return false;
	161
	162	iph = (struct iphdr *)(skb->data + hdrlen + sizeof(struct iphdr));
	163
	164	return iph->saddr != pctx->ms_addr_ip4.s_addr;
	165	}
	166
	167	/* Check if the inner IP source address in this packet is assigned to any
	168	* existing mobile subscriber.
	169	*/
	170	static bool gtp_check_src_ms(struct sk_buff skb, struct pdp_ctx pctx,
	171	unsigned int hdrlen)
	172	{
	173	switch (ntohs(skb->protocol)) {
	174	case ETH_P_IP:
	175	return gtp_check_src_ms_ipv4(skb, pctx, hdrlen);
	176	}
	177	return false;
	178	}
	179
	180	/* 1 means pass up to the stack, -1 means drop and 0 means decapsulated. */
	181	static int gtp0_udp_encap_recv(struct gtp_dev gtp, struct sk_buff skb,
	182	bool xnet)
	183	{
	184	unsigned int hdrlen = sizeof(struct udphdr) +
	185	sizeof(struct gtp0_header);
	186	struct gtp0_header *gtp0;
	187	struct pdp_ctx *pctx;
	188	int ret = 0;
	189
	190	if (!pskb_may_pull(skb, hdrlen))
	191	return -1;
	192
	193	gtp0 = (struct gtp0_header *)(skb->data + sizeof(struct udphdr));
	194
	195	if ((gtp0->flags >> 5) != GTP_V0)
	196	return 1;
	197
	198	if (gtp0->type != GTP_TPDU)
	199	return 1;
	200
	201	rcu_read_lock();
	202	pctx = gtp0_pdp_find(gtp, be64_to_cpu(gtp0->tid));
	203	if (!pctx) {
	204	netdev_dbg(gtp->dev, "No PDP ctx to decap skb=%p\n", skb);
	205	ret = -1;
	206	goto out_rcu;
	207	}
	208
	209	if (!gtp_check_src_ms(skb, pctx, hdrlen)) {
	210	netdev_dbg(gtp->dev, "No PDP ctx for this MS\n");
	211	ret = -1;
	212	goto out_rcu;
	213	}
	214	rcu_read_unlock();
	215
	216	/* Get rid of the GTP + UDP headers. */
	217	return iptunnel_pull_header(skb, hdrlen, skb->protocol, xnet);
	218	out_rcu:
	219	rcu_read_unlock();
	220	return ret;
	221	}
	222
	223	static int gtp1u_udp_encap_recv(struct gtp_dev gtp, struct sk_buff skb,
	224	bool xnet)
	225	{
	226	unsigned int hdrlen = sizeof(struct udphdr) +
	227	sizeof(struct gtp1_header);
	228	struct gtp1_header *gtp1;
	229	struct pdp_ctx *pctx;
	230	int ret = 0;
	231
	232	if (!pskb_may_pull(skb, hdrlen))
	233	return -1;
	234
	235	gtp1 = (struct gtp1_header *)(skb->data + sizeof(struct udphdr));
	236
	237	if ((gtp1->flags >> 5) != GTP_V1)
	238	return 1;
	239
	240	if (gtp1->type != GTP_TPDU)
	241	return 1;
	242
	243	/* From 29.060: "This field shall be present if and only if any one or
	244	* more of the S, PN and E flags are set.".
	245	*
	246	* If any of the bit is set, then the remaining ones also have to be
	247	* set.
	248	*/
	249	if (gtp1->flags & GTP1_F_MASK)
	250	hdrlen += 4;
	251
	252	/* Make sure the header is larger enough, including extensions. */
	253	if (!pskb_may_pull(skb, hdrlen))
	254	return -1;
	255
	256	rcu_read_lock();
	257	pctx = gtp1_pdp_find(gtp, ntohl(gtp1->tid));
	258	if (!pctx) {
	259	netdev_dbg(gtp->dev, "No PDP ctx to decap skb=%p\n", skb);
	260	ret = -1;
	261	goto out_rcu;
	262	}
	263
	264	if (!gtp_check_src_ms(skb, pctx, hdrlen)) {
	265	netdev_dbg(gtp->dev, "No PDP ctx for this MS\n");
	266	ret = -1;
	267	goto out_rcu;
	268	}
	269	rcu_read_unlock();
	270
	271	/* Get rid of the GTP + UDP headers. */
	272	return iptunnel_pull_header(skb, hdrlen, skb->protocol, xnet);
	273	out_rcu:
	274	rcu_read_unlock();
	275	return ret;
	276	}
	277
	278	static void gtp_encap_disable(struct gtp_dev *gtp)
	279	{
	280	if (gtp->sock0 && gtp->sock0->sk) {
	281	udp_sk(gtp->sock0->sk)->encap_type = 0;
	282	rcu_assign_sk_user_data(gtp->sock0->sk, NULL);
	283	}
	284	if (gtp->sock1u && gtp->sock1u->sk) {
	285	udp_sk(gtp->sock1u->sk)->encap_type = 0;
	286	rcu_assign_sk_user_data(gtp->sock1u->sk, NULL);
	287	}
	288
	289	gtp->sock0 = NULL;
	290	gtp->sock1u = NULL;
	291	}
	292
	293	static void gtp_encap_destroy(struct sock *sk)
	294	{
	295	struct gtp_dev *gtp;
	296
	297	gtp = rcu_dereference_sk_user_data(sk);
	298	if (gtp)
	299	gtp_encap_disable(gtp);
	300	}
	301
	302	/* UDP encapsulation receive handler. See net/ipv4/udp.c.
	303	* Return codes: 0: success, <0: error, >0: pass up to userspace UDP socket.
	304	*/
	305	static int gtp_encap_recv(struct sock sk, struct sk_buff skb)
	306	{
	307	struct pcpu_sw_netstats *stats;
	308	struct gtp_dev *gtp;
	309	bool xnet;
	310	int ret;
	311
	312	gtp = rcu_dereference_sk_user_data(sk);
	313	if (!gtp)
	314	return 1;
	315
	316	netdev_dbg(gtp->dev, "encap_recv sk=%p\n", sk);
	317
	318	xnet = !net_eq(gtp->net, dev_net(gtp->dev));
	319
	320	switch (udp_sk(sk)->encap_type) {
	321	case UDP_ENCAP_GTP0:
	322	netdev_dbg(gtp->dev, "received GTP0 packet\n");
	323	ret = gtp0_udp_encap_recv(gtp, skb, xnet);
	324	break;
	325	case UDP_ENCAP_GTP1U:
	326	netdev_dbg(gtp->dev, "received GTP1U packet\n");
	327	ret = gtp1u_udp_encap_recv(gtp, skb, xnet);
	328	break;
	329	default:
	330	ret = -1; /* Shouldn't happen. */
	331	}
	332
	333	switch (ret) {
	334	case 1:
	335	netdev_dbg(gtp->dev, "pass up to the process\n");
	336	return 1;
	337	case 0:
	338	netdev_dbg(gtp->dev, "forwarding packet from GGSN to uplink\n");
	339	break;
	340	case -1:
	341	netdev_dbg(gtp->dev, "GTP packet has been dropped\n");
	342	kfree_skb(skb);
	343	return 0;
	344	}
	345
	346	/* Now that the UDP and the GTP header have been removed, set up the
	347	* new network header. This is required by the upper layer to
	348	* calculate the transport header.
	349	*/
	350	skb_reset_network_header(skb);
	351
	352	skb->dev = gtp->dev;
	353
	354	stats = this_cpu_ptr(gtp->dev->tstats);
	355	u64_stats_update_begin(&stats->syncp);
	356	stats->rx_packets++;
	357	stats->rx_bytes += skb->len;
	358	u64_stats_update_end(&stats->syncp);
	359
	360	netif_rx(skb);
	361
	362	return 0;
	363	}
	364
	365	static int gtp_dev_init(struct net_device *dev)
	366	{
	367	struct gtp_dev *gtp = netdev_priv(dev);
	368
	369	gtp->dev = dev;
	370
	371	dev->tstats = alloc_percpu(struct pcpu_sw_netstats);
	372	if (!dev->tstats)
	373	return -ENOMEM;
	374
	375	return 0;
	376	}
	377
	378	static void gtp_dev_uninit(struct net_device *dev)
	379	{
	380	struct gtp_dev *gtp = netdev_priv(dev);
	381
	382	gtp_encap_disable(gtp);
	383	free_percpu(dev->tstats);
	384	}
	385
	386	static struct rtable ip4_route_output_gtp(struct net net, struct flowi4 *fl4,
	387	const struct sock *sk, __be32 daddr)
	388	{
	389	memset(fl4, 0, sizeof(*fl4));
	390	fl4->flowi4_oif = sk->sk_bound_dev_if;
	391	fl4->daddr = daddr;
	392	fl4->saddr = inet_sk(sk)->inet_saddr;
	393	fl4->flowi4_tos = RT_CONN_FLAGS(sk);
	394	fl4->flowi4_proto = sk->sk_protocol;
	395
	396	return ip_route_output_key(net, fl4);
	397	}
	398
	399	static inline void gtp0_push_header(struct sk_buff skb, struct pdp_ctx pctx)
	400	{
	401	int payload_len = skb->len;
	402	struct gtp0_header *gtp0;
	403
	404	gtp0 = (struct gtp0_header ) skb_push(skb, sizeof(gtp0));
	405
	406	gtp0->flags = 0x1e; /* v0, GTP-non-prime. */
	407	gtp0->type = GTP_TPDU;
	408	gtp0->length = htons(payload_len);
	409	gtp0->seq = htons((atomic_inc_return(&pctx->tx_seq) - 1) % 0xffff);
	410	gtp0->flow = htons(pctx->u.v0.flow);
	411	gtp0->number = 0xff;
	412	gtp0->spare[0] = gtp0->spare[1] = gtp0->spare[2] = 0xff;
	413	gtp0->tid = cpu_to_be64(pctx->u.v0.tid);
	414	}
	415
	416	static inline void gtp1_push_header(struct sk_buff skb, struct pdp_ctx pctx)
	417	{
	418	int payload_len = skb->len;
	419	struct gtp1_header *gtp1;
	420
	421	gtp1 = (struct gtp1_header ) skb_push(skb, sizeof(gtp1));
	422
	423	/* Bits 8 7 6 5 4 3 2 1
	424	* +--+--+--+--+--+--+--+--+
	425	* \|version \|PT\| 1\| E\| S\|PN\|
	426	* +--+--+--+--+--+--+--+--+
	427	* 0 0 1 1 1 0 0 0
	428	*/
	429	gtp1->flags = 0x38; /* v1, GTP-non-prime. */
	430	gtp1->type = GTP_TPDU;
	431	gtp1->length = htons(payload_len);
	432	gtp1->tid = htonl(pctx->u.v1.o_tei);
	433
	434	/* TODO: Suppport for extension header, sequence number and N-PDU.
	435	* Update the length field if any of them is available.
	436	*/
	437	}
	438
	439	struct gtp_pktinfo {
	440	struct sock *sk;
	441	struct iphdr *iph;
	442	struct flowi4 fl4;
	443	struct rtable *rt;
	444	struct pdp_ctx *pctx;
	445	struct net_device *dev;
	446	__be16 gtph_port;
	447	};
	448
	449	static void gtp_push_header(struct sk_buff skb, struct gtp_pktinfo pktinfo)
	450	{
	451	switch (pktinfo->pctx->gtp_version) {
	452	case GTP_V0:
	453	pktinfo->gtph_port = htons(GTP0_PORT);
	454	gtp0_push_header(skb, pktinfo->pctx);
	455	break;
	456	case GTP_V1:
	457	pktinfo->gtph_port = htons(GTP1U_PORT);
	458	gtp1_push_header(skb, pktinfo->pctx);
	459	break;
	460	}
	461	}
	462
	463	static inline void gtp_set_pktinfo_ipv4(struct gtp_pktinfo *pktinfo,
	464	struct sock sk, struct iphdr iph,
	465	struct pdp_ctx pctx, struct rtable rt,
	466	struct flowi4 *fl4,
	467	struct net_device *dev)
	468	{
	469	pktinfo->sk = sk;
	470	pktinfo->iph = iph;
	471	pktinfo->pctx = pctx;
	472	pktinfo->rt = rt;
	473	pktinfo->fl4 = *fl4;
	474	pktinfo->dev = dev;
	475	}
	476
	477	static int gtp_build_skb_ip4(struct sk_buff skb, struct net_device dev,
	478	struct gtp_pktinfo *pktinfo)
	479	{
	480	struct gtp_dev *gtp = netdev_priv(dev);
	481	struct pdp_ctx *pctx;
	482	struct rtable *rt;
	483	struct flowi4 fl4;
	484	struct iphdr *iph;
	485	struct sock *sk;
	486	__be16 df;
	487	int mtu;
	488
	489	/* Read the IP destination address and resolve the PDP context.
	490	* Prepend PDP header with TEI/TID from PDP ctx.
	491	*/
	492	iph = ip_hdr(skb);
	493	pctx = ipv4_pdp_find(gtp, iph->daddr);
	494	if (!pctx) {
	495	netdev_dbg(dev, "no PDP ctx found for %pI4, skip\n",
	496	&iph->daddr);
	497	return -ENOENT;
	498	}
	499	netdev_dbg(dev, "found PDP context %p\n", pctx);
	500
	501	switch (pctx->gtp_version) {
	502	case GTP_V0:
	503	if (gtp->sock0)
	504	sk = gtp->sock0->sk;
	505	else
	506	sk = NULL;
	507	break;
	508	case GTP_V1:
	509	if (gtp->sock1u)
	510	sk = gtp->sock1u->sk;
	511	else
	512	sk = NULL;
	513	break;
	514	default:
	515	return -ENOENT;
	516	}
	517
	518	if (!sk) {
	519	netdev_dbg(dev, "no userspace socket is available, skip\n");
	520	return -ENOENT;
	521	}
	522
	523	rt = ip4_route_output_gtp(sock_net(sk), &fl4, gtp->sock0->sk,
	524	pctx->sgsn_addr_ip4.s_addr);
	525	if (IS_ERR(rt)) {
	526	netdev_dbg(dev, "no route to SSGN %pI4\n",
	527	&pctx->sgsn_addr_ip4.s_addr);
	528	dev->stats.tx_carrier_errors++;
	529	goto err;
	530	}
	531
	532	if (rt->dst.dev == dev) {
	533	netdev_dbg(dev, "circular route to SSGN %pI4\n",
	534	&pctx->sgsn_addr_ip4.s_addr);
	535	dev->stats.collisions++;
	536	goto err_rt;
	537	}
	538
	539	skb_dst_drop(skb);
	540
	541	/* This is similar to tnl_update_pmtu(). */
	542	df = iph->frag_off;
	543	if (df) {
	544	mtu = dst_mtu(&rt->dst) - dev->hard_header_len -
	545	sizeof(struct iphdr) - sizeof(struct udphdr);
	546	switch (pctx->gtp_version) {
	547	case GTP_V0:
	548	mtu -= sizeof(struct gtp0_header);
	549	break;
	550	case GTP_V1:
	551	mtu -= sizeof(struct gtp1_header);
	552	break;
	553	}
	554	} else {
	555	mtu = dst_mtu(&rt->dst);
	556	}
	557
	558	rt->dst.ops->update_pmtu(&rt->dst, NULL, skb, mtu);
	559
	560	if (!skb_is_gso(skb) && (iph->frag_off & htons(IP_DF)) &&
	561	mtu < ntohs(iph->tot_len)) {
	562	netdev_dbg(dev, "packet too big, fragmentation needed\n");
	563	memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
	564	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
	565	htonl(mtu));
	566	goto err_rt;
	567	}
	568
	569	gtp_set_pktinfo_ipv4(pktinfo, sk, iph, pctx, rt, &fl4, dev);
	570	gtp_push_header(skb, pktinfo);
	571
	572	return 0;
	573	err_rt:
	574	ip_rt_put(rt);
	575	err:
	576	return -EBADMSG;
	577	}
	578
	579	static netdev_tx_t gtp_dev_xmit(struct sk_buff skb, struct net_device dev)
	580	{
	581	unsigned int proto = ntohs(skb->protocol);
	582	struct gtp_pktinfo pktinfo;
	583	int err;
	584
	585	/* Ensure there is sufficient headroom. */
	586	if (skb_cow_head(skb, dev->needed_headroom))
	587	goto tx_err;
	588
	589	skb_reset_inner_headers(skb);
	590
	591	/* PDP context lookups in gtp_build_skb_() need rcu read-side lock. /
	592	rcu_read_lock();
	593	switch (proto) {
	594	case ETH_P_IP:
	595	err = gtp_build_skb_ip4(skb, dev, &pktinfo);
	596	break;
	597	default:
	598	err = -EOPNOTSUPP;
	599	break;
	600	}
	601	rcu_read_unlock();
	602
	603	if (err < 0)
	604	goto tx_err;
	605
	606	switch (proto) {
	607	case ETH_P_IP:
	608	netdev_dbg(pktinfo.dev, "gtp -> IP src: %pI4 dst: %pI4\n",
	609	&pktinfo.iph->saddr, &pktinfo.iph->daddr);
	610	udp_tunnel_xmit_skb(pktinfo.rt, pktinfo.sk, skb,
	611	pktinfo.fl4.saddr, pktinfo.fl4.daddr,
	612	pktinfo.iph->tos,
	613	ip4_dst_hoplimit(&pktinfo.rt->dst),
	614	htons(IP_DF),
	615	pktinfo.gtph_port, pktinfo.gtph_port,
	616	true, false);
	617	break;
	618	}
	619
	620	return NETDEV_TX_OK;
	621	tx_err:
	622	dev->stats.tx_errors++;
	623	dev_kfree_skb(skb);
	624	return NETDEV_TX_OK;
	625	}
	626
	627	static const struct net_device_ops gtp_netdev_ops = {
	628	.ndo_init = gtp_dev_init,
	629	.ndo_uninit = gtp_dev_uninit,
	630	.ndo_start_xmit = gtp_dev_xmit,
	631	.ndo_get_stats64 = ip_tunnel_get_stats64,
	632	};
	633
	634	static void gtp_link_setup(struct net_device *dev)
	635	{
	636	dev->netdev_ops = &gtp_netdev_ops;
	637	dev->destructor = free_netdev;
	638
	639	dev->hard_header_len = 0;
	640	dev->addr_len = 0;
	641
	642	/* Zero header length. */
	643	dev->type = ARPHRD_NONE;
	644	dev->flags = IFF_POINTOPOINT \| IFF_NOARP \| IFF_MULTICAST;
	645
	646	dev->priv_flags \|= IFF_NO_QUEUE;
	647	dev->features \|= NETIF_F_LLTX;
	648	netif_keep_dst(dev);
	649
	650	/* Assume largest header, ie. GTPv0. */
	651	dev->needed_headroom = LL_MAX_HEADER +
	652	sizeof(struct iphdr) +
	653	sizeof(struct udphdr) +
	654	sizeof(struct gtp0_header);
	655	}
	656
	657	static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize);
	658	static void gtp_hashtable_free(struct gtp_dev *gtp);
	659	static int gtp_encap_enable(struct net_device dev, struct gtp_dev gtp,
	660	int fd_gtp0, int fd_gtp1, struct net *src_net);
	661
	662	static int gtp_newlink(struct net src_net, struct net_device dev,
	663	struct nlattr tb[], struct nlattr data[])
	664	{
	665	int hashsize, err, fd0, fd1;
	666	struct gtp_dev *gtp;
	667	struct gtp_net *gn;
	668
	669	if (!data[IFLA_GTP_FD0] \|\| !data[IFLA_GTP_FD1])
	670	return -EINVAL;
	671
	672	gtp = netdev_priv(dev);
	673
	674	fd0 = nla_get_u32(data[IFLA_GTP_FD0]);
	675	fd1 = nla_get_u32(data[IFLA_GTP_FD1]);
	676
	677	err = gtp_encap_enable(dev, gtp, fd0, fd1, src_net);
	678	if (err < 0)
	679	goto out_err;
	680
	681	if (!data[IFLA_GTP_PDP_HASHSIZE])
	682	hashsize = 1024;
	683	else
	684	hashsize = nla_get_u32(data[IFLA_GTP_PDP_HASHSIZE]);
	685
	686	err = gtp_hashtable_new(gtp, hashsize);
	687	if (err < 0)
	688	goto out_encap;
	689
	690	err = register_netdevice(dev);
	691	if (err < 0) {
	692	netdev_dbg(dev, "failed to register new netdev %d\n", err);
	693	goto out_hashtable;
	694	}
	695
	696	gn = net_generic(dev_net(dev), gtp_net_id);
	697	list_add_rcu(&gtp->list, &gn->gtp_dev_list);
	698
	699	netdev_dbg(dev, "registered new GTP interface\n");
	700
	701	return 0;
	702
	703	out_hashtable:
	704	gtp_hashtable_free(gtp);
	705	out_encap:
	706	gtp_encap_disable(gtp);
	707	out_err:
	708	return err;
	709	}
	710
	711	static void gtp_dellink(struct net_device dev, struct list_head head)
	712	{
	713	struct gtp_dev *gtp = netdev_priv(dev);
	714
	715	gtp_encap_disable(gtp);
	716	gtp_hashtable_free(gtp);
	717	list_del_rcu(&gtp->list);
	718	unregister_netdevice_queue(dev, head);
	719	}
	720
	721	static const struct nla_policy gtp_policy[IFLA_GTP_MAX + 1] = {
	722	[IFLA_GTP_FD0] = { .type = NLA_U32 },
	723	[IFLA_GTP_FD1] = { .type = NLA_U32 },
	724	[IFLA_GTP_PDP_HASHSIZE] = { .type = NLA_U32 },
	725	};
	726
	727	static int gtp_validate(struct nlattr tb[], struct nlattr data[])
	728	{
	729	if (!data)
	730	return -EINVAL;
	731
	732	return 0;
	733	}
	734
	735	static size_t gtp_get_size(const struct net_device *dev)
	736	{
	737	return nla_total_size(sizeof(__u32)); /* IFLA_GTP_PDP_HASHSIZE */
	738	}
	739
	740	static int gtp_fill_info(struct sk_buff skb, const struct net_device dev)
	741	{
	742	struct gtp_dev *gtp = netdev_priv(dev);
	743
	744	if (nla_put_u32(skb, IFLA_GTP_PDP_HASHSIZE, gtp->hash_size))
	745	goto nla_put_failure;
	746
	747	return 0;
	748
	749	nla_put_failure:
	750	return -EMSGSIZE;
	751	}
	752
	753	static struct rtnl_link_ops gtp_link_ops __read_mostly = {
	754	.kind = "gtp",
	755	.maxtype = IFLA_GTP_MAX,
	756	.policy = gtp_policy,
	757	.priv_size = sizeof(struct gtp_dev),
	758	.setup = gtp_link_setup,
	759	.validate = gtp_validate,
	760	.newlink = gtp_newlink,
	761	.dellink = gtp_dellink,
	762	.get_size = gtp_get_size,
	763	.fill_info = gtp_fill_info,
	764	};
	765
	766	static struct net gtp_genl_get_net(struct net src_net, struct nlattr *tb[])
	767	{
	768	struct net *net;
	769
	770	/* Examine the link attributes and figure out which network namespace
	771	* we are talking about.
	772	*/
	773	if (tb[GTPA_NET_NS_FD])
	774	net = get_net_ns_by_fd(nla_get_u32(tb[GTPA_NET_NS_FD]));
	775	else
	776	net = get_net(src_net);
	777
	778	return net;
	779	}
	780
	781	static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize)
	782	{
	783	int i;
	784
	785	gtp->addr_hash = kmalloc(sizeof(struct hlist_head) * hsize, GFP_KERNEL);
	786	if (gtp->addr_hash == NULL)
	787	return -ENOMEM;
	788
	789	gtp->tid_hash = kmalloc(sizeof(struct hlist_head) * hsize, GFP_KERNEL);
	790	if (gtp->tid_hash == NULL)
	791	goto err1;
	792
	793	gtp->hash_size = hsize;
	794
	795	for (i = 0; i < hsize; i++) {
	796	INIT_HLIST_HEAD(&gtp->addr_hash[i]);
	797	INIT_HLIST_HEAD(&gtp->tid_hash[i]);
	798	}
	799	return 0;
	800	err1:
	801	kfree(gtp->addr_hash);
	802	return -ENOMEM;
	803	}
	804
	805	static void gtp_hashtable_free(struct gtp_dev *gtp)
	806	{
	807	struct pdp_ctx *pctx;
	808	int i;
	809
	810	for (i = 0; i < gtp->hash_size; i++) {
	811	hlist_for_each_entry_rcu(pctx, &gtp->tid_hash[i], hlist_tid) {
	812	hlist_del_rcu(&pctx->hlist_tid);
	813	hlist_del_rcu(&pctx->hlist_addr);
	814	kfree_rcu(pctx, rcu_head);
	815	}
	816	}
	817	synchronize_rcu();
	818	kfree(gtp->addr_hash);
	819	kfree(gtp->tid_hash);
	820	}
	821
	822	static int gtp_encap_enable(struct net_device dev, struct gtp_dev gtp,
	823	int fd_gtp0, int fd_gtp1, struct net *src_net)
	824	{
	825	struct udp_tunnel_sock_cfg tuncfg = {NULL};
	826	struct socket sock0, sock1u;
	827	int err;
	828
	829	netdev_dbg(dev, "enable gtp on %d, %d\n", fd_gtp0, fd_gtp1);
	830
	831	sock0 = sockfd_lookup(fd_gtp0, &err);
	832	if (sock0 == NULL) {
	833	netdev_dbg(dev, "socket fd=%d not found (gtp0)\n", fd_gtp0);
	834	return -ENOENT;
	835	}
	836
	837	if (sock0->sk->sk_protocol != IPPROTO_UDP) {
	838	netdev_dbg(dev, "socket fd=%d not UDP\n", fd_gtp0);
	839	err = -EINVAL;
	840	goto err1;
	841	}
	842
	843	sock1u = sockfd_lookup(fd_gtp1, &err);
	844	if (sock1u == NULL) {
	845	netdev_dbg(dev, "socket fd=%d not found (gtp1u)\n", fd_gtp1);
	846	err = -ENOENT;
	847	goto err1;
	848	}
	849
	850	if (sock1u->sk->sk_protocol != IPPROTO_UDP) {
	851	netdev_dbg(dev, "socket fd=%d not UDP\n", fd_gtp1);
	852	err = -EINVAL;
	853	goto err2;
	854	}
	855
	856	netdev_dbg(dev, "enable gtp on %p, %p\n", sock0, sock1u);
	857
	858	gtp->sock0 = sock0;
	859	gtp->sock1u = sock1u;
	860	gtp->net = src_net;
	861
	862	tuncfg.sk_user_data = gtp;
	863	tuncfg.encap_rcv = gtp_encap_recv;
	864	tuncfg.encap_destroy = gtp_encap_destroy;
	865
	866	tuncfg.encap_type = UDP_ENCAP_GTP0;
	867	setup_udp_tunnel_sock(sock_net(gtp->sock0->sk), gtp->sock0, &tuncfg);
	868
	869	tuncfg.encap_type = UDP_ENCAP_GTP1U;
	870	setup_udp_tunnel_sock(sock_net(gtp->sock1u->sk), gtp->sock1u, &tuncfg);
	871
	872	err = 0;
	873	err2:
	874	sockfd_put(sock1u);
	875	err1:
	876	sockfd_put(sock0);
	877	return err;
	878	}
	879
	880	static struct net_device gtp_find_dev(struct net net, int ifindex)
	881	{
	882	struct gtp_net *gn = net_generic(net, gtp_net_id);
	883	struct gtp_dev *gtp;
	884
	885	list_for_each_entry_rcu(gtp, &gn->gtp_dev_list, list) {
	886	if (ifindex == gtp->dev->ifindex)
	887	return gtp->dev;
	888	}
	889	return NULL;
	890	}
	891
	892	static void ipv4_pdp_fill(struct pdp_ctx pctx, struct genl_info info)
	893	{
	894	pctx->gtp_version = nla_get_u32(info->attrs[GTPA_VERSION]);
	895	pctx->af = AF_INET;
	896	pctx->sgsn_addr_ip4.s_addr =
	897	nla_get_be32(info->attrs[GTPA_SGSN_ADDRESS]);
	898	pctx->ms_addr_ip4.s_addr =
	899	nla_get_be32(info->attrs[GTPA_MS_ADDRESS]);
	900
	901	switch (pctx->gtp_version) {
	902	case GTP_V0:
	903	/* According to TS 09.60, sections 7.5.1 and 7.5.2, the flow
	904	* label needs to be the same for uplink and downlink packets,
	905	* so let's annotate this.
	906	*/
	907	pctx->u.v0.tid = nla_get_u64(info->attrs[GTPA_TID]);
	908	pctx->u.v0.flow = nla_get_u16(info->attrs[GTPA_FLOW]);
	909	break;
	910	case GTP_V1:
	911	pctx->u.v1.i_tei = nla_get_u32(info->attrs[GTPA_I_TEI]);
	912	pctx->u.v1.o_tei = nla_get_u32(info->attrs[GTPA_O_TEI]);
	913	break;
	914	default:
	915	break;
	916	}
	917	}
	918
	919	static int ipv4_pdp_add(struct net_device dev, struct genl_info info)
	920	{
	921	struct gtp_dev *gtp = netdev_priv(dev);
	922	u32 hash_ms, hash_tid = 0;
	923	struct pdp_ctx *pctx;
	924	bool found = false;
	925	__be32 ms_addr;
	926
	927	ms_addr = nla_get_be32(info->attrs[GTPA_MS_ADDRESS]);
	928	hash_ms = ipv4_hashfn(ms_addr) % gtp->hash_size;
	929
	930	hlist_for_each_entry_rcu(pctx, &gtp->addr_hash[hash_ms], hlist_addr) {
	931	if (pctx->ms_addr_ip4.s_addr == ms_addr) {
	932	found = true;
	933	break;
	934	}
	935	}
	936
	937	if (found) {
	938	if (info->nlhdr->nlmsg_flags & NLM_F_EXCL)
	939	return -EEXIST;
	940	if (info->nlhdr->nlmsg_flags & NLM_F_REPLACE)
	941	return -EOPNOTSUPP;
	942
	943	ipv4_pdp_fill(pctx, info);
	944
	945	if (pctx->gtp_version == GTP_V0)
	946	netdev_dbg(dev, "GTPv0-U: update tunnel id = %llx (pdp %p)\n",
	947	pctx->u.v0.tid, pctx);
	948	else if (pctx->gtp_version == GTP_V1)
	949	netdev_dbg(dev, "GTPv1-U: update tunnel id = %x/%x (pdp %p)\n",
	950	pctx->u.v1.i_tei, pctx->u.v1.o_tei, pctx);
	951
	952	return 0;
	953
	954	}
	955
	956	pctx = kmalloc(sizeof(struct pdp_ctx), GFP_KERNEL);
	957	if (pctx == NULL)
	958	return -ENOMEM;
	959
	960	ipv4_pdp_fill(pctx, info);
	961	atomic_set(&pctx->tx_seq, 0);
	962
	963	switch (pctx->gtp_version) {
	964	case GTP_V0:
	965	/* TS 09.60: "The flow label identifies unambiguously a GTP
	966	* flow.". We use the tid for this instead, I cannot find a
	967	* situation in which this doesn't unambiguosly identify the
	968	* PDP context.
	969	*/
	970	hash_tid = gtp0_hashfn(pctx->u.v0.tid) % gtp->hash_size;
	971	break;
	972	case GTP_V1:
	973	hash_tid = gtp1u_hashfn(pctx->u.v1.i_tei) % gtp->hash_size;
	974	break;
	975	}
	976
	977	hlist_add_head_rcu(&pctx->hlist_addr, &gtp->addr_hash[hash_ms]);
	978	hlist_add_head_rcu(&pctx->hlist_tid, &gtp->tid_hash[hash_tid]);
	979
	980	switch (pctx->gtp_version) {
	981	case GTP_V0:
	982	netdev_dbg(dev, "GTPv0-U: new PDP ctx id=%llx ssgn=%pI4 ms=%pI4 (pdp=%p)\n",
	983	pctx->u.v0.tid, &pctx->sgsn_addr_ip4,
	984	&pctx->ms_addr_ip4, pctx);
	985	break;
	986	case GTP_V1:
	987	netdev_dbg(dev, "GTPv1-U: new PDP ctx id=%x/%x ssgn=%pI4 ms=%pI4 (pdp=%p)\n",
	988	pctx->u.v1.i_tei, pctx->u.v1.o_tei,
	989	&pctx->sgsn_addr_ip4, &pctx->ms_addr_ip4, pctx);
	990	break;
	991	}
	992
	993	return 0;
	994	}
	995
	996	static int gtp_genl_new_pdp(struct sk_buff skb, struct genl_info info)
	997	{
	998	struct net_device *dev;
	999	struct net *net;
	1000
	1001	if (!info->attrs[GTPA_VERSION] \|\|
	1002	!info->attrs[GTPA_LINK] \|\|
	1003	!info->attrs[GTPA_SGSN_ADDRESS] \|\|
	1004	!info->attrs[GTPA_MS_ADDRESS])
	1005	return -EINVAL;
	1006
	1007	switch (nla_get_u32(info->attrs[GTPA_VERSION])) {
	1008	case GTP_V0:
	1009	if (!info->attrs[GTPA_TID] \|\|
	1010	!info->attrs[GTPA_FLOW])
	1011	return -EINVAL;
	1012	break;
	1013	case GTP_V1:
	1014	if (!info->attrs[GTPA_I_TEI] \|\|
	1015	!info->attrs[GTPA_O_TEI])
	1016	return -EINVAL;
	1017	break;
	1018
	1019	default:
	1020	return -EINVAL;
	1021	}
	1022
	1023	net = gtp_genl_get_net(sock_net(skb->sk), info->attrs);
	1024	if (IS_ERR(net))
	1025	return PTR_ERR(net);
	1026
	1027	/* Check if there's an existing gtpX device to configure */
	1028	dev = gtp_find_dev(net, nla_get_u32(info->attrs[GTPA_LINK]));
	1029	if (dev == NULL)
	1030	return -ENODEV;
	1031
	1032	return ipv4_pdp_add(dev, info);
	1033	}
	1034
	1035	static int gtp_genl_del_pdp(struct sk_buff skb, struct genl_info info)
	1036	{
	1037	struct net_device *dev;
	1038	struct pdp_ctx *pctx;
	1039	struct gtp_dev *gtp;
	1040	struct net *net;
	1041
	1042	if (!info->attrs[GTPA_VERSION] \|\|
	1043	!info->attrs[GTPA_LINK])
	1044	return -EINVAL;
	1045
	1046	net = gtp_genl_get_net(sock_net(skb->sk), info->attrs);
	1047	if (IS_ERR(net))
	1048	return PTR_ERR(net);
	1049
	1050	/* Check if there's an existing gtpX device to configure */
	1051	dev = gtp_find_dev(net, nla_get_u32(info->attrs[GTPA_LINK]));
	1052	if (dev == NULL)
	1053	return -ENODEV;
	1054
	1055	gtp = netdev_priv(dev);
	1056
	1057	switch (nla_get_u32(info->attrs[GTPA_VERSION])) {
	1058	case GTP_V0:
	1059	if (!info->attrs[GTPA_TID])
	1060	return -EINVAL;
	1061	pctx = gtp0_pdp_find(gtp, nla_get_u64(info->attrs[GTPA_TID]));
	1062	break;
	1063	case GTP_V1:
	1064	if (!info->attrs[GTPA_I_TEI])
	1065	return -EINVAL;
	1066	pctx = gtp1_pdp_find(gtp, nla_get_u64(info->attrs[GTPA_I_TEI]));
	1067	break;
	1068
	1069	default:
	1070	return -EINVAL;
	1071	}
	1072
	1073	if (pctx == NULL)
	1074	return -ENOENT;
	1075
	1076	if (pctx->gtp_version == GTP_V0)
	1077	netdev_dbg(dev, "GTPv0-U: deleting tunnel id = %llx (pdp %p)\n",
	1078	pctx->u.v0.tid, pctx);
	1079	else if (pctx->gtp_version == GTP_V1)
	1080	netdev_dbg(dev, "GTPv1-U: deleting tunnel id = %x/%x (pdp %p)\n",
	1081	pctx->u.v1.i_tei, pctx->u.v1.o_tei, pctx);
	1082
	1083	hlist_del_rcu(&pctx->hlist_tid);
	1084	hlist_del_rcu(&pctx->hlist_addr);
	1085	kfree_rcu(pctx, rcu_head);
	1086
	1087	return 0;
	1088	}
	1089
	1090	static struct genl_family gtp_genl_family = {
	1091	.id = GENL_ID_GENERATE,
	1092	.name = "gtp",
	1093	.version = 0,
	1094	.hdrsize = 0,
	1095	.maxattr = GTPA_MAX,
	1096	.netnsok = true,
	1097	};
	1098
	1099	static int gtp_genl_fill_info(struct sk_buff *skb, u32 snd_portid, u32 snd_seq,
	1100	u32 type, struct pdp_ctx *pctx)
	1101	{
	1102	void *genlh;
	1103
	1104	genlh = genlmsg_put(skb, snd_portid, snd_seq, &gtp_genl_family, 0,
	1105	type);
	1106	if (genlh == NULL)
	1107	goto nlmsg_failure;
	1108
	1109	if (nla_put_u32(skb, GTPA_VERSION, pctx->gtp_version) \|\|
	1110	nla_put_be32(skb, GTPA_SGSN_ADDRESS, pctx->sgsn_addr_ip4.s_addr) \|\|
	1111	nla_put_be32(skb, GTPA_MS_ADDRESS, pctx->ms_addr_ip4.s_addr))
	1112	goto nla_put_failure;
	1113
	1114	switch (pctx->gtp_version) {
	1115	case GTP_V0:
	1116	if (nla_put_u64_64bit(skb, GTPA_TID, pctx->u.v0.tid, GTPA_PAD) \|\|
	1117	nla_put_u16(skb, GTPA_FLOW, pctx->u.v0.flow))
	1118	goto nla_put_failure;
	1119	break;
	1120	case GTP_V1:
	1121	if (nla_put_u32(skb, GTPA_I_TEI, pctx->u.v1.i_tei) \|\|
	1122	nla_put_u32(skb, GTPA_O_TEI, pctx->u.v1.o_tei))
	1123	goto nla_put_failure;
	1124	break;
	1125	}
	1126	genlmsg_end(skb, genlh);
	1127	return 0;
	1128
	1129	nlmsg_failure:
	1130	nla_put_failure:
	1131	genlmsg_cancel(skb, genlh);
	1132	return -EMSGSIZE;
	1133	}
	1134
	1135	static int gtp_genl_get_pdp(struct sk_buff skb, struct genl_info info)
	1136	{
	1137	struct pdp_ctx *pctx = NULL;
	1138	struct net_device *dev;
	1139	struct sk_buff *skb2;
	1140	struct gtp_dev *gtp;
	1141	u32 gtp_version;
	1142	struct net *net;
	1143	int err;
	1144
	1145	if (!info->attrs[GTPA_VERSION] \|\|
	1146	!info->attrs[GTPA_LINK])
	1147	return -EINVAL;
	1148
	1149	gtp_version = nla_get_u32(info->attrs[GTPA_VERSION]);
	1150	switch (gtp_version) {
	1151	case GTP_V0:
	1152	case GTP_V1:
	1153	break;
	1154	default:
	1155	return -EINVAL;
	1156	}
	1157
	1158	net = gtp_genl_get_net(sock_net(skb->sk), info->attrs);
	1159	if (IS_ERR(net))
	1160	return PTR_ERR(net);
	1161
	1162	/* Check if there's an existing gtpX device to configure */
	1163	dev = gtp_find_dev(net, nla_get_u32(info->attrs[GTPA_LINK]));
	1164	if (dev == NULL)
	1165	return -ENODEV;
	1166
	1167	gtp = netdev_priv(dev);
	1168
	1169	rcu_read_lock();
	1170	if (gtp_version == GTP_V0 &&
	1171	info->attrs[GTPA_TID]) {
	1172	u64 tid = nla_get_u64(info->attrs[GTPA_TID]);
	1173
	1174	pctx = gtp0_pdp_find(gtp, tid);
	1175	} else if (gtp_version == GTP_V1 &&
	1176	info->attrs[GTPA_I_TEI]) {
	1177	u32 tid = nla_get_u32(info->attrs[GTPA_I_TEI]);
	1178
	1179	pctx = gtp1_pdp_find(gtp, tid);
	1180	} else if (info->attrs[GTPA_MS_ADDRESS]) {
	1181	__be32 ip = nla_get_be32(info->attrs[GTPA_MS_ADDRESS]);
	1182
	1183	pctx = ipv4_pdp_find(gtp, ip);
	1184	}
	1185
	1186	if (pctx == NULL) {
	1187	err = -ENOENT;
	1188	goto err_unlock;
	1189	}
	1190
	1191	skb2 = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	1192	if (skb2 == NULL) {
	1193	err = -ENOMEM;
	1194	goto err_unlock;
	1195	}
	1196
	1197	err = gtp_genl_fill_info(skb2, NETLINK_CB(skb).portid,
	1198	info->snd_seq, info->nlhdr->nlmsg_type, pctx);
	1199	if (err < 0)
	1200	goto err_unlock_free;
	1201
	1202	rcu_read_unlock();
	1203	return genlmsg_unicast(genl_info_net(info), skb2, info->snd_portid);
	1204
	1205	err_unlock_free:
	1206	kfree_skb(skb2);
	1207	err_unlock:
	1208	rcu_read_unlock();
	1209	return err;
	1210	}
	1211
	1212	static int gtp_genl_dump_pdp(struct sk_buff *skb,
	1213	struct netlink_callback *cb)
	1214	{
	1215	struct gtp_dev last_gtp = (struct gtp_dev )cb->args[2], *gtp;
	1216	struct net *net = sock_net(skb->sk);
	1217	struct gtp_net *gn = net_generic(net, gtp_net_id);
	1218	unsigned long tid = cb->args[1];
	1219	int i, k = cb->args[0], ret;
	1220	struct pdp_ctx *pctx;
	1221
	1222	if (cb->args[4])
	1223	return 0;
	1224
	1225	list_for_each_entry_rcu(gtp, &gn->gtp_dev_list, list) {
	1226	if (last_gtp && last_gtp != gtp)
	1227	continue;
	1228	else
	1229	last_gtp = NULL;
	1230
	1231	for (i = k; i < gtp->hash_size; i++) {
	1232	hlist_for_each_entry_rcu(pctx, &gtp->tid_hash[i], hlist_tid) {
	1233	if (tid && tid != pctx->u.tid)
	1234	continue;
	1235	else
	1236	tid = 0;
	1237
	1238	ret = gtp_genl_fill_info(skb,
	1239	NETLINK_CB(cb->skb).portid,
	1240	cb->nlh->nlmsg_seq,
	1241	cb->nlh->nlmsg_type, pctx);
	1242	if (ret < 0) {
	1243	cb->args[0] = i;
	1244	cb->args[1] = pctx->u.tid;
	1245	cb->args[2] = (unsigned long)gtp;
	1246	goto out;
	1247	}
	1248	}
	1249	}
	1250	}
	1251	cb->args[4] = 1;
	1252	out:
	1253	return skb->len;
	1254	}
	1255
	1256	static struct nla_policy gtp_genl_policy[GTPA_MAX + 1] = {
	1257	[GTPA_LINK] = { .type = NLA_U32, },
	1258	[GTPA_VERSION] = { .type = NLA_U32, },
	1259	[GTPA_TID] = { .type = NLA_U64, },
	1260	[GTPA_SGSN_ADDRESS] = { .type = NLA_U32, },
	1261	[GTPA_MS_ADDRESS] = { .type = NLA_U32, },
	1262	[GTPA_FLOW] = { .type = NLA_U16, },
	1263	[GTPA_NET_NS_FD] = { .type = NLA_U32, },
	1264	[GTPA_I_TEI] = { .type = NLA_U32, },
	1265	[GTPA_O_TEI] = { .type = NLA_U32, },
	1266	};
	1267
	1268	static const struct genl_ops gtp_genl_ops[] = {
	1269	{
	1270	.cmd = GTP_CMD_NEWPDP,
	1271	.doit = gtp_genl_new_pdp,
	1272	.policy = gtp_genl_policy,
	1273	.flags = GENL_ADMIN_PERM,
	1274	},
	1275	{
	1276	.cmd = GTP_CMD_DELPDP,
	1277	.doit = gtp_genl_del_pdp,
	1278	.policy = gtp_genl_policy,
	1279	.flags = GENL_ADMIN_PERM,
	1280	},
	1281	{
	1282	.cmd = GTP_CMD_GETPDP,
	1283	.doit = gtp_genl_get_pdp,
	1284	.dumpit = gtp_genl_dump_pdp,
	1285	.policy = gtp_genl_policy,
	1286	.flags = GENL_ADMIN_PERM,
	1287	},
	1288	};
	1289
	1290	static int __net_init gtp_net_init(struct net *net)
	1291	{
	1292	struct gtp_net *gn = net_generic(net, gtp_net_id);
	1293
	1294	INIT_LIST_HEAD(&gn->gtp_dev_list);
	1295	return 0;
	1296	}
	1297
	1298	static void __net_exit gtp_net_exit(struct net *net)
	1299	{
	1300	struct gtp_net *gn = net_generic(net, gtp_net_id);
	1301	struct gtp_dev *gtp;
	1302	LIST_HEAD(list);
	1303
	1304	rtnl_lock();
	1305	list_for_each_entry(gtp, &gn->gtp_dev_list, list)
	1306	gtp_dellink(gtp->dev, &list);
	1307
	1308	unregister_netdevice_many(&list);
	1309	rtnl_unlock();
	1310	}
	1311
	1312	static struct pernet_operations gtp_net_ops = {
	1313	.init = gtp_net_init,
	1314	.exit = gtp_net_exit,
	1315	.id = &gtp_net_id,
	1316	.size = sizeof(struct gtp_net),
	1317	};
	1318
	1319	static int __init gtp_init(void)
	1320	{
	1321	int err;
	1322
	1323	get_random_bytes(&gtp_h_initval, sizeof(gtp_h_initval));
	1324
	1325	err = rtnl_link_register(&gtp_link_ops);
	1326	if (err < 0)
	1327	goto error_out;
	1328
	1329	err = genl_register_family_with_ops(&gtp_genl_family, gtp_genl_ops);
	1330	if (err < 0)
	1331	goto unreg_rtnl_link;
	1332
	1333	err = register_pernet_subsys(&gtp_net_ops);
	1334	if (err < 0)
	1335	goto unreg_genl_family;
	1336
	1337	pr_info("GTP module loaded (pdp ctx size %Zd bytes)\n",
	1338	sizeof(struct pdp_ctx));
	1339	return 0;
	1340
	1341	unreg_genl_family:
	1342	genl_unregister_family(&gtp_genl_family);
	1343	unreg_rtnl_link:
	1344	rtnl_link_unregister(&gtp_link_ops);
	1345	error_out:
	1346	pr_err("error loading GTP module loaded\n");
	1347	return err;
	1348	}
	1349	late_initcall(gtp_init);
	1350
	1351	static void __exit gtp_fini(void)
	1352	{
	1353	unregister_pernet_subsys(&gtp_net_ops);
	1354	genl_unregister_family(&gtp_genl_family);
	1355	rtnl_link_unregister(&gtp_link_ops);
	1356
	1357	pr_info("GTP module unloaded\n");
	1358	}
	1359	module_exit(gtp_fini);
	1360
	1361	MODULE_LICENSE("GPL");
	1362	MODULE_AUTHOR("Harald Welte <hwelte@sysmocom.de>");
	1363	MODULE_DESCRIPTION("Interface driver for GTP encapsulated traffic");
	1364	MODULE_ALIAS_RTNL_LINK("gtp");

include/net/gtp.h+34−0

@@ -0,0 +1,34 @@
	1	#ifndef _GTP_H_
	2	#define _GTP_H
	3
	4	/* General GTP protocol related definitions. */
	5
	6	#define GTP0_PORT 3386
	7	#define GTP1U_PORT 2152
	8
	9	#define GTP_TPDU 255
	10
	11	struct gtp0_header { /* According to GSM TS 09.60. */
	12	__u8 flags;
	13	__u8 type;
	14	__be16 length;
	15	__be16 seq;
	16	__be16 flow;
	17	__u8 number;
	18	__u8 spare[3];
	19	__be64 tid;
	20	} __attribute__ ((packed));
	21
	22	struct gtp1_header { /* According to 3GPP TS 29.060. */
	23	__u8 flags;
	24	__u8 type;
	25	__be16 length;
	26	__be32 tid;
	27	} __attribute__ ((packed));
	28
	29	#define GTP1_F_NPDU 0x01
	30	#define GTP1_F_SEQ 0x02
	31	#define GTP1_F_EXTHDR 0x04
	32	#define GTP1_F_MASK 0x07
	33
	34	#endif

include/uapi/linux/Kbuild+1−0

@@ -141,6 +141,7 @@ header-y += gfs2_ondisk.h · 140 unmodified lines
141	header-y += gigaset_dev.h	141	header-y += gigaset_dev.h
142	header-y += gpio.h	142	header-y += gpio.h
143	header-y += gsmmux.h	143	header-y += gsmmux.h
		144	header-y += gtp.h
144	header-y += hdlcdrv.h	145	header-y += hdlcdrv.h
145	header-y += hdlc.h	146	header-y += hdlc.h
146	header-y += hdreg.h	147	header-y += hdreg.h

include/uapi/linux/gtp.h+33−0

@@ -0,0 +1,33 @@
	1	#ifndef _UAPI_LINUX_GTP_H_
	2	#define _UAPI_LINUX_GTP_H__
	3
	4	enum gtp_genl_cmds {
	5	GTP_CMD_NEWPDP,
	6	GTP_CMD_DELPDP,
	7	GTP_CMD_GETPDP,
	8
	9	GTP_CMD_MAX,
	10	};
	11
	12	enum gtp_version {
	13	GTP_V0 = 0,
	14	GTP_V1,
	15	};
	16
	17	enum gtp_attrs {
	18	GTPA_UNSPEC = 0,
	19	GTPA_LINK,
	20	GTPA_VERSION,
	21	GTPA_TID, /* for GTPv0 only */
	22	GTPA_SGSN_ADDRESS,
	23	GTPA_MS_ADDRESS,
	24	GTPA_FLOW,
	25	GTPA_NET_NS_FD,
	26	GTPA_I_TEI, /* for GTPv1 only */
	27	GTPA_O_TEI, /* for GTPv1 only */
	28	GTPA_PAD,
	29	__GTPA_MAX,
	30	};
	31	#define GTPA_MAX (__GTPA_MAX + 1)
	32
	33	#endif /* _UAPI_LINUX_GTP_H_ */

include/uapi/linux/if_link.h+10−0

@@ -529,6 +529,16 @@ enum { · 528 unmodified lines
529	};	529	};
530	#define IFLA_PPP_MAX (__IFLA_PPP_MAX - 1)	530	#define IFLA_PPP_MAX (__IFLA_PPP_MAX - 1)
531		531
		532	/* GTP section */
		533	enum {
		534	IFLA_GTP_UNSPEC,
		535	IFLA_GTP_FD0,
		536	IFLA_GTP_FD1,
		537	IFLA_GTP_PDP_HASHSIZE,
		538	__IFLA_GTP_MAX,
		539	};
		540	#define IFLA_GTP_MAX (__IFLA_GTP_MAX - 1)
		541
532	/* Bonding section */	542	/* Bonding section */
533		543
534	enum {	544	enum {

include/uapi/linux/udp.h+2−1

@@ -36,6 +36,7 @@ struct udphdr { · 35 unmodified lines
36	#define UDP_ENCAP_ESPINUDP_NON_IKE 1 /* draft-ietf-ipsec-nat-t-ike-00/01 */	36	#define UDP_ENCAP_ESPINUDP_NON_IKE 1 /* draft-ietf-ipsec-nat-t-ike-00/01 */
37	#define UDP_ENCAP_ESPINUDP 2 /* draft-ietf-ipsec-udp-encaps-06 */	37	#define UDP_ENCAP_ESPINUDP 2 /* draft-ietf-ipsec-udp-encaps-06 */
38	#define UDP_ENCAP_L2TPINUDP 3 /* rfc2661 */	38	#define UDP_ENCAP_L2TPINUDP 3 /* rfc2661 */
39		39	#define UDP_ENCAP_GTP0 4 /* GSM TS 09.60 */
		40	#define UDP_ENCAP_GTP1U 5 /* 3GPP TS 29.060 */
40		41
41	#endif /* _UAPI_LINUX_UDP_H */	42	#endif /* _UAPI_LINUX_UDP_H */