xref: /openbmc/linux/drivers/net/gtp.c (revision 28c67f0f)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* GTP according to GSM TS 09.60 / 3GPP TS 29.060
3  *
4  * (C) 2012-2014 by sysmocom - s.f.m.c. GmbH
5  * (C) 2016 by Pablo Neira Ayuso <pablo@netfilter.org>
6  *
7  * Author: Harald Welte <hwelte@sysmocom.de>
8  *	   Pablo Neira Ayuso <pablo@netfilter.org>
9  *	   Andreas Schultz <aschultz@travelping.com>
10  */
11 
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 
14 #include <linux/module.h>
15 #include <linux/skbuff.h>
16 #include <linux/udp.h>
17 #include <linux/rculist.h>
18 #include <linux/jhash.h>
19 #include <linux/if_tunnel.h>
20 #include <linux/net.h>
21 #include <linux/file.h>
22 #include <linux/gtp.h>
23 
24 #include <net/net_namespace.h>
25 #include <net/protocol.h>
26 #include <net/ip.h>
27 #include <net/udp.h>
28 #include <net/udp_tunnel.h>
29 #include <net/icmp.h>
30 #include <net/xfrm.h>
31 #include <net/genetlink.h>
32 #include <net/netns/generic.h>
33 #include <net/gtp.h>
34 
35 /* An active session for the subscriber. */
36 struct pdp_ctx {
37 	struct hlist_node	hlist_tid;
38 	struct hlist_node	hlist_addr;
39 
40 	union {
41 		struct {
42 			u64	tid;
43 			u16	flow;
44 		} v0;
45 		struct {
46 			u32	i_tei;
47 			u32	o_tei;
48 		} v1;
49 	} u;
50 	u8			gtp_version;
51 	u16			af;
52 
53 	struct in_addr		ms_addr_ip4;
54 	struct in_addr		peer_addr_ip4;
55 
56 	struct sock		*sk;
57 	struct net_device       *dev;
58 
59 	atomic_t		tx_seq;
60 	struct rcu_head		rcu_head;
61 };
62 
63 /* One instance of the GTP device. */
64 struct gtp_dev {
65 	struct list_head	list;
66 
67 	struct sock		*sk0;
68 	struct sock		*sk1u;
69 	u8			sk_created;
70 
71 	struct net_device	*dev;
72 	struct net		*net;
73 
74 	unsigned int		role;
75 	unsigned int		hash_size;
76 	struct hlist_head	*tid_hash;
77 	struct hlist_head	*addr_hash;
78 
79 	u8			restart_count;
80 };
81 
82 struct echo_info {
83 	struct in_addr		ms_addr_ip4;
84 	struct in_addr		peer_addr_ip4;
85 	u8			gtp_version;
86 };
87 
88 static unsigned int gtp_net_id __read_mostly;
89 
90 struct gtp_net {
91 	struct list_head gtp_dev_list;
92 };
93 
94 static u32 gtp_h_initval;
95 
96 static struct genl_family gtp_genl_family;
97 
98 enum gtp_multicast_groups {
99 	GTP_GENL_MCGRP,
100 };
101 
102 static const struct genl_multicast_group gtp_genl_mcgrps[] = {
103 	[GTP_GENL_MCGRP] = { .name = GTP_GENL_MCGRP_NAME },
104 };
105 
106 static void pdp_context_delete(struct pdp_ctx *pctx);
107 
gtp0_hashfn(u64 tid)108 static inline u32 gtp0_hashfn(u64 tid)
109 {
110 	u32 *tid32 = (u32 *) &tid;
111 	return jhash_2words(tid32[0], tid32[1], gtp_h_initval);
112 }
113 
gtp1u_hashfn(u32 tid)114 static inline u32 gtp1u_hashfn(u32 tid)
115 {
116 	return jhash_1word(tid, gtp_h_initval);
117 }
118 
ipv4_hashfn(__be32 ip)119 static inline u32 ipv4_hashfn(__be32 ip)
120 {
121 	return jhash_1word((__force u32)ip, gtp_h_initval);
122 }
123 
124 /* Resolve a PDP context structure based on the 64bit TID. */
gtp0_pdp_find(struct gtp_dev * gtp,u64 tid)125 static struct pdp_ctx *gtp0_pdp_find(struct gtp_dev *gtp, u64 tid)
126 {
127 	struct hlist_head *head;
128 	struct pdp_ctx *pdp;
129 
130 	head = &gtp->tid_hash[gtp0_hashfn(tid) % gtp->hash_size];
131 
132 	hlist_for_each_entry_rcu(pdp, head, hlist_tid) {
133 		if (pdp->gtp_version == GTP_V0 &&
134 		    pdp->u.v0.tid == tid)
135 			return pdp;
136 	}
137 	return NULL;
138 }
139 
140 /* Resolve a PDP context structure based on the 32bit TEI. */
gtp1_pdp_find(struct gtp_dev * gtp,u32 tid)141 static struct pdp_ctx *gtp1_pdp_find(struct gtp_dev *gtp, u32 tid)
142 {
143 	struct hlist_head *head;
144 	struct pdp_ctx *pdp;
145 
146 	head = &gtp->tid_hash[gtp1u_hashfn(tid) % gtp->hash_size];
147 
148 	hlist_for_each_entry_rcu(pdp, head, hlist_tid) {
149 		if (pdp->gtp_version == GTP_V1 &&
150 		    pdp->u.v1.i_tei == tid)
151 			return pdp;
152 	}
153 	return NULL;
154 }
155 
156 /* Resolve a PDP context based on IPv4 address of MS. */
ipv4_pdp_find(struct gtp_dev * gtp,__be32 ms_addr)157 static struct pdp_ctx *ipv4_pdp_find(struct gtp_dev *gtp, __be32 ms_addr)
158 {
159 	struct hlist_head *head;
160 	struct pdp_ctx *pdp;
161 
162 	head = &gtp->addr_hash[ipv4_hashfn(ms_addr) % gtp->hash_size];
163 
164 	hlist_for_each_entry_rcu(pdp, head, hlist_addr) {
165 		if (pdp->af == AF_INET &&
166 		    pdp->ms_addr_ip4.s_addr == ms_addr)
167 			return pdp;
168 	}
169 
170 	return NULL;
171 }
172 
gtp_check_ms_ipv4(struct sk_buff * skb,struct pdp_ctx * pctx,unsigned int hdrlen,unsigned int role)173 static bool gtp_check_ms_ipv4(struct sk_buff *skb, struct pdp_ctx *pctx,
174 				  unsigned int hdrlen, unsigned int role)
175 {
176 	struct iphdr *iph;
177 
178 	if (!pskb_may_pull(skb, hdrlen + sizeof(struct iphdr)))
179 		return false;
180 
181 	iph = (struct iphdr *)(skb->data + hdrlen);
182 
183 	if (role == GTP_ROLE_SGSN)
184 		return iph->daddr == pctx->ms_addr_ip4.s_addr;
185 	else
186 		return iph->saddr == pctx->ms_addr_ip4.s_addr;
187 }
188 
189 /* Check if the inner IP address in this packet is assigned to any
190  * existing mobile subscriber.
191  */
gtp_check_ms(struct sk_buff * skb,struct pdp_ctx * pctx,unsigned int hdrlen,unsigned int role)192 static bool gtp_check_ms(struct sk_buff *skb, struct pdp_ctx *pctx,
193 			     unsigned int hdrlen, unsigned int role)
194 {
195 	switch (ntohs(skb->protocol)) {
196 	case ETH_P_IP:
197 		return gtp_check_ms_ipv4(skb, pctx, hdrlen, role);
198 	}
199 	return false;
200 }
201 
gtp_rx(struct pdp_ctx * pctx,struct sk_buff * skb,unsigned int hdrlen,unsigned int role)202 static int gtp_rx(struct pdp_ctx *pctx, struct sk_buff *skb,
203 			unsigned int hdrlen, unsigned int role)
204 {
205 	if (!gtp_check_ms(skb, pctx, hdrlen, role)) {
206 		netdev_dbg(pctx->dev, "No PDP ctx for this MS\n");
207 		return 1;
208 	}
209 
210 	/* Get rid of the GTP + UDP headers. */
211 	if (iptunnel_pull_header(skb, hdrlen, skb->protocol,
212 			 !net_eq(sock_net(pctx->sk), dev_net(pctx->dev)))) {
213 		pctx->dev->stats.rx_length_errors++;
214 		goto err;
215 	}
216 
217 	netdev_dbg(pctx->dev, "forwarding packet from GGSN to uplink\n");
218 
219 	/* Now that the UDP and the GTP header have been removed, set up the
220 	 * new network header. This is required by the upper layer to
221 	 * calculate the transport header.
222 	 */
223 	skb_reset_network_header(skb);
224 	skb_reset_mac_header(skb);
225 
226 	skb->dev = pctx->dev;
227 
228 	dev_sw_netstats_rx_add(pctx->dev, skb->len);
229 
230 	__netif_rx(skb);
231 	return 0;
232 
233 err:
234 	pctx->dev->stats.rx_dropped++;
235 	return -1;
236 }
237 
ip4_route_output_gtp(struct flowi4 * fl4,const struct sock * sk,__be32 daddr,__be32 saddr)238 static struct rtable *ip4_route_output_gtp(struct flowi4 *fl4,
239 					   const struct sock *sk,
240 					   __be32 daddr, __be32 saddr)
241 {
242 	memset(fl4, 0, sizeof(*fl4));
243 	fl4->flowi4_oif		= sk->sk_bound_dev_if;
244 	fl4->daddr		= daddr;
245 	fl4->saddr		= saddr;
246 	fl4->flowi4_tos		= ip_sock_rt_tos(sk);
247 	fl4->flowi4_scope	= ip_sock_rt_scope(sk);
248 	fl4->flowi4_proto	= sk->sk_protocol;
249 
250 	return ip_route_output_key(sock_net(sk), fl4);
251 }
252 
253 /* GSM TS 09.60. 7.3
254  * In all Path Management messages:
255  * - TID: is not used and shall be set to 0.
256  * - Flow Label is not used and shall be set to 0
257  * In signalling messages:
258  * - number: this field is not yet used in signalling messages.
259  *   It shall be set to 255 by the sender and shall be ignored
260  *   by the receiver
261  * Returns true if the echo req was correct, false otherwise.
262  */
gtp0_validate_echo_hdr(struct gtp0_header * gtp0)263 static bool gtp0_validate_echo_hdr(struct gtp0_header *gtp0)
264 {
265 	return !(gtp0->tid || (gtp0->flags ^ 0x1e) ||
266 		gtp0->number != 0xff || gtp0->flow);
267 }
268 
269 /* msg_type has to be GTP_ECHO_REQ or GTP_ECHO_RSP */
gtp0_build_echo_msg(struct gtp0_header * hdr,__u8 msg_type)270 static void gtp0_build_echo_msg(struct gtp0_header *hdr, __u8 msg_type)
271 {
272 	int len_pkt, len_hdr;
273 
274 	hdr->flags = 0x1e; /* v0, GTP-non-prime. */
275 	hdr->type = msg_type;
276 	/* GSM TS 09.60. 7.3 In all Path Management Flow Label and TID
277 	 * are not used and shall be set to 0.
278 	 */
279 	hdr->flow = 0;
280 	hdr->tid = 0;
281 	hdr->number = 0xff;
282 	hdr->spare[0] = 0xff;
283 	hdr->spare[1] = 0xff;
284 	hdr->spare[2] = 0xff;
285 
286 	len_pkt = sizeof(struct gtp0_packet);
287 	len_hdr = sizeof(struct gtp0_header);
288 
289 	if (msg_type == GTP_ECHO_RSP)
290 		hdr->length = htons(len_pkt - len_hdr);
291 	else
292 		hdr->length = 0;
293 }
294 
gtp0_send_echo_resp(struct gtp_dev * gtp,struct sk_buff * skb)295 static int gtp0_send_echo_resp(struct gtp_dev *gtp, struct sk_buff *skb)
296 {
297 	struct gtp0_packet *gtp_pkt;
298 	struct gtp0_header *gtp0;
299 	struct rtable *rt;
300 	struct flowi4 fl4;
301 	struct iphdr *iph;
302 	__be16 seq;
303 
304 	gtp0 = (struct gtp0_header *)(skb->data + sizeof(struct udphdr));
305 
306 	if (!gtp0_validate_echo_hdr(gtp0))
307 		return -1;
308 
309 	seq = gtp0->seq;
310 
311 	/* pull GTP and UDP headers */
312 	skb_pull_data(skb, sizeof(struct gtp0_header) + sizeof(struct udphdr));
313 
314 	gtp_pkt = skb_push(skb, sizeof(struct gtp0_packet));
315 	memset(gtp_pkt, 0, sizeof(struct gtp0_packet));
316 
317 	gtp0_build_echo_msg(&gtp_pkt->gtp0_h, GTP_ECHO_RSP);
318 
319 	/* GSM TS 09.60. 7.3 The Sequence Number in a signalling response
320 	 * message shall be copied from the signalling request message
321 	 * that the GSN is replying to.
322 	 */
323 	gtp_pkt->gtp0_h.seq = seq;
324 
325 	gtp_pkt->ie.tag = GTPIE_RECOVERY;
326 	gtp_pkt->ie.val = gtp->restart_count;
327 
328 	iph = ip_hdr(skb);
329 
330 	/* find route to the sender,
331 	 * src address becomes dst address and vice versa.
332 	 */
333 	rt = ip4_route_output_gtp(&fl4, gtp->sk0, iph->saddr, iph->daddr);
334 	if (IS_ERR(rt)) {
335 		netdev_dbg(gtp->dev, "no route for echo response from %pI4\n",
336 			   &iph->saddr);
337 		return -1;
338 	}
339 
340 	udp_tunnel_xmit_skb(rt, gtp->sk0, skb,
341 			    fl4.saddr, fl4.daddr,
342 			    iph->tos,
343 			    ip4_dst_hoplimit(&rt->dst),
344 			    0,
345 			    htons(GTP0_PORT), htons(GTP0_PORT),
346 			    !net_eq(sock_net(gtp->sk1u),
347 				    dev_net(gtp->dev)),
348 			    false);
349 	return 0;
350 }
351 
gtp_genl_fill_echo(struct sk_buff * skb,u32 snd_portid,u32 snd_seq,int flags,u32 type,struct echo_info echo)352 static int gtp_genl_fill_echo(struct sk_buff *skb, u32 snd_portid, u32 snd_seq,
353 			      int flags, u32 type, struct echo_info echo)
354 {
355 	void *genlh;
356 
357 	genlh = genlmsg_put(skb, snd_portid, snd_seq, &gtp_genl_family, flags,
358 			    type);
359 	if (!genlh)
360 		goto failure;
361 
362 	if (nla_put_u32(skb, GTPA_VERSION, echo.gtp_version) ||
363 	    nla_put_be32(skb, GTPA_PEER_ADDRESS, echo.peer_addr_ip4.s_addr) ||
364 	    nla_put_be32(skb, GTPA_MS_ADDRESS, echo.ms_addr_ip4.s_addr))
365 		goto failure;
366 
367 	genlmsg_end(skb, genlh);
368 	return 0;
369 
370 failure:
371 	genlmsg_cancel(skb, genlh);
372 	return -EMSGSIZE;
373 }
374 
gtp0_handle_echo_resp(struct gtp_dev * gtp,struct sk_buff * skb)375 static int gtp0_handle_echo_resp(struct gtp_dev *gtp, struct sk_buff *skb)
376 {
377 	struct gtp0_header *gtp0;
378 	struct echo_info echo;
379 	struct sk_buff *msg;
380 	struct iphdr *iph;
381 	int ret;
382 
383 	gtp0 = (struct gtp0_header *)(skb->data + sizeof(struct udphdr));
384 
385 	if (!gtp0_validate_echo_hdr(gtp0))
386 		return -1;
387 
388 	iph = ip_hdr(skb);
389 	echo.ms_addr_ip4.s_addr = iph->daddr;
390 	echo.peer_addr_ip4.s_addr = iph->saddr;
391 	echo.gtp_version = GTP_V0;
392 
393 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
394 	if (!msg)
395 		return -ENOMEM;
396 
397 	ret = gtp_genl_fill_echo(msg, 0, 0, 0, GTP_CMD_ECHOREQ, echo);
398 	if (ret < 0) {
399 		nlmsg_free(msg);
400 		return ret;
401 	}
402 
403 	return genlmsg_multicast_netns(&gtp_genl_family, dev_net(gtp->dev),
404 				       msg, 0, GTP_GENL_MCGRP, GFP_ATOMIC);
405 }
406 
407 /* 1 means pass up to the stack, -1 means drop and 0 means decapsulated. */
gtp0_udp_encap_recv(struct gtp_dev * gtp,struct sk_buff * skb)408 static int gtp0_udp_encap_recv(struct gtp_dev *gtp, struct sk_buff *skb)
409 {
410 	unsigned int hdrlen = sizeof(struct udphdr) +
411 			      sizeof(struct gtp0_header);
412 	struct gtp0_header *gtp0;
413 	struct pdp_ctx *pctx;
414 
415 	if (!pskb_may_pull(skb, hdrlen))
416 		return -1;
417 
418 	gtp0 = (struct gtp0_header *)(skb->data + sizeof(struct udphdr));
419 
420 	if ((gtp0->flags >> 5) != GTP_V0)
421 		return 1;
422 
423 	/* If the sockets were created in kernel, it means that
424 	 * there is no daemon running in userspace which would
425 	 * handle echo request.
426 	 */
427 	if (gtp0->type == GTP_ECHO_REQ && gtp->sk_created)
428 		return gtp0_send_echo_resp(gtp, skb);
429 
430 	if (gtp0->type == GTP_ECHO_RSP && gtp->sk_created)
431 		return gtp0_handle_echo_resp(gtp, skb);
432 
433 	if (gtp0->type != GTP_TPDU)
434 		return 1;
435 
436 	pctx = gtp0_pdp_find(gtp, be64_to_cpu(gtp0->tid));
437 	if (!pctx) {
438 		netdev_dbg(gtp->dev, "No PDP ctx to decap skb=%p\n", skb);
439 		return 1;
440 	}
441 
442 	return gtp_rx(pctx, skb, hdrlen, gtp->role);
443 }
444 
445 /* msg_type has to be GTP_ECHO_REQ or GTP_ECHO_RSP */
gtp1u_build_echo_msg(struct gtp1_header_long * hdr,__u8 msg_type)446 static void gtp1u_build_echo_msg(struct gtp1_header_long *hdr, __u8 msg_type)
447 {
448 	int len_pkt, len_hdr;
449 
450 	/* S flag must be set to 1 */
451 	hdr->flags = 0x32; /* v1, GTP-non-prime. */
452 	hdr->type = msg_type;
453 	/* 3GPP TS 29.281 5.1 - TEID has to be set to 0 */
454 	hdr->tid = 0;
455 
456 	/* seq, npdu and next should be counted to the length of the GTP packet
457 	 * that's why szie of gtp1_header should be subtracted,
458 	 * not size of gtp1_header_long.
459 	 */
460 
461 	len_hdr = sizeof(struct gtp1_header);
462 
463 	if (msg_type == GTP_ECHO_RSP) {
464 		len_pkt = sizeof(struct gtp1u_packet);
465 		hdr->length = htons(len_pkt - len_hdr);
466 	} else {
467 		/* GTP_ECHO_REQ does not carry GTP Information Element,
468 		 * the why gtp1_header_long is used here.
469 		 */
470 		len_pkt = sizeof(struct gtp1_header_long);
471 		hdr->length = htons(len_pkt - len_hdr);
472 	}
473 }
474 
gtp1u_send_echo_resp(struct gtp_dev * gtp,struct sk_buff * skb)475 static int gtp1u_send_echo_resp(struct gtp_dev *gtp, struct sk_buff *skb)
476 {
477 	struct gtp1_header_long *gtp1u;
478 	struct gtp1u_packet *gtp_pkt;
479 	struct rtable *rt;
480 	struct flowi4 fl4;
481 	struct iphdr *iph;
482 
483 	gtp1u = (struct gtp1_header_long *)(skb->data + sizeof(struct udphdr));
484 
485 	/* 3GPP TS 29.281 5.1 - For the Echo Request, Echo Response,
486 	 * Error Indication and Supported Extension Headers Notification
487 	 * messages, the S flag shall be set to 1 and TEID shall be set to 0.
488 	 */
489 	if (!(gtp1u->flags & GTP1_F_SEQ) || gtp1u->tid)
490 		return -1;
491 
492 	/* pull GTP and UDP headers */
493 	skb_pull_data(skb,
494 		      sizeof(struct gtp1_header_long) + sizeof(struct udphdr));
495 
496 	gtp_pkt = skb_push(skb, sizeof(struct gtp1u_packet));
497 	memset(gtp_pkt, 0, sizeof(struct gtp1u_packet));
498 
499 	gtp1u_build_echo_msg(&gtp_pkt->gtp1u_h, GTP_ECHO_RSP);
500 
501 	/* 3GPP TS 29.281 7.7.2 - The Restart Counter value in the
502 	 * Recovery information element shall not be used, i.e. it shall
503 	 * be set to zero by the sender and shall be ignored by the receiver.
504 	 * The Recovery information element is mandatory due to backwards
505 	 * compatibility reasons.
506 	 */
507 	gtp_pkt->ie.tag = GTPIE_RECOVERY;
508 	gtp_pkt->ie.val = 0;
509 
510 	iph = ip_hdr(skb);
511 
512 	/* find route to the sender,
513 	 * src address becomes dst address and vice versa.
514 	 */
515 	rt = ip4_route_output_gtp(&fl4, gtp->sk1u, iph->saddr, iph->daddr);
516 	if (IS_ERR(rt)) {
517 		netdev_dbg(gtp->dev, "no route for echo response from %pI4\n",
518 			   &iph->saddr);
519 		return -1;
520 	}
521 
522 	udp_tunnel_xmit_skb(rt, gtp->sk1u, skb,
523 			    fl4.saddr, fl4.daddr,
524 			    iph->tos,
525 			    ip4_dst_hoplimit(&rt->dst),
526 			    0,
527 			    htons(GTP1U_PORT), htons(GTP1U_PORT),
528 			    !net_eq(sock_net(gtp->sk1u),
529 				    dev_net(gtp->dev)),
530 			    false);
531 	return 0;
532 }
533 
gtp1u_handle_echo_resp(struct gtp_dev * gtp,struct sk_buff * skb)534 static int gtp1u_handle_echo_resp(struct gtp_dev *gtp, struct sk_buff *skb)
535 {
536 	struct gtp1_header_long *gtp1u;
537 	struct echo_info echo;
538 	struct sk_buff *msg;
539 	struct iphdr *iph;
540 	int ret;
541 
542 	gtp1u = (struct gtp1_header_long *)(skb->data + sizeof(struct udphdr));
543 
544 	/* 3GPP TS 29.281 5.1 - For the Echo Request, Echo Response,
545 	 * Error Indication and Supported Extension Headers Notification
546 	 * messages, the S flag shall be set to 1 and TEID shall be set to 0.
547 	 */
548 	if (!(gtp1u->flags & GTP1_F_SEQ) || gtp1u->tid)
549 		return -1;
550 
551 	iph = ip_hdr(skb);
552 	echo.ms_addr_ip4.s_addr = iph->daddr;
553 	echo.peer_addr_ip4.s_addr = iph->saddr;
554 	echo.gtp_version = GTP_V1;
555 
556 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
557 	if (!msg)
558 		return -ENOMEM;
559 
560 	ret = gtp_genl_fill_echo(msg, 0, 0, 0, GTP_CMD_ECHOREQ, echo);
561 	if (ret < 0) {
562 		nlmsg_free(msg);
563 		return ret;
564 	}
565 
566 	return genlmsg_multicast_netns(&gtp_genl_family, dev_net(gtp->dev),
567 				       msg, 0, GTP_GENL_MCGRP, GFP_ATOMIC);
568 }
569 
gtp1u_udp_encap_recv(struct gtp_dev * gtp,struct sk_buff * skb)570 static int gtp1u_udp_encap_recv(struct gtp_dev *gtp, struct sk_buff *skb)
571 {
572 	unsigned int hdrlen = sizeof(struct udphdr) +
573 			      sizeof(struct gtp1_header);
574 	struct gtp1_header *gtp1;
575 	struct pdp_ctx *pctx;
576 
577 	if (!pskb_may_pull(skb, hdrlen))
578 		return -1;
579 
580 	gtp1 = (struct gtp1_header *)(skb->data + sizeof(struct udphdr));
581 
582 	if ((gtp1->flags >> 5) != GTP_V1)
583 		return 1;
584 
585 	/* If the sockets were created in kernel, it means that
586 	 * there is no daemon running in userspace which would
587 	 * handle echo request.
588 	 */
589 	if (gtp1->type == GTP_ECHO_REQ && gtp->sk_created)
590 		return gtp1u_send_echo_resp(gtp, skb);
591 
592 	if (gtp1->type == GTP_ECHO_RSP && gtp->sk_created)
593 		return gtp1u_handle_echo_resp(gtp, skb);
594 
595 	if (gtp1->type != GTP_TPDU)
596 		return 1;
597 
598 	/* From 29.060: "This field shall be present if and only if any one or
599 	 * more of the S, PN and E flags are set.".
600 	 *
601 	 * If any of the bit is set, then the remaining ones also have to be
602 	 * set.
603 	 */
604 	if (gtp1->flags & GTP1_F_MASK)
605 		hdrlen += 4;
606 
607 	/* Make sure the header is larger enough, including extensions. */
608 	if (!pskb_may_pull(skb, hdrlen))
609 		return -1;
610 
611 	gtp1 = (struct gtp1_header *)(skb->data + sizeof(struct udphdr));
612 
613 	pctx = gtp1_pdp_find(gtp, ntohl(gtp1->tid));
614 	if (!pctx) {
615 		netdev_dbg(gtp->dev, "No PDP ctx to decap skb=%p\n", skb);
616 		return 1;
617 	}
618 
619 	return gtp_rx(pctx, skb, hdrlen, gtp->role);
620 }
621 
__gtp_encap_destroy(struct sock * sk)622 static void __gtp_encap_destroy(struct sock *sk)
623 {
624 	struct gtp_dev *gtp;
625 
626 	lock_sock(sk);
627 	gtp = sk->sk_user_data;
628 	if (gtp) {
629 		if (gtp->sk0 == sk)
630 			gtp->sk0 = NULL;
631 		else
632 			gtp->sk1u = NULL;
633 		WRITE_ONCE(udp_sk(sk)->encap_type, 0);
634 		rcu_assign_sk_user_data(sk, NULL);
635 		release_sock(sk);
636 		sock_put(sk);
637 		return;
638 	}
639 	release_sock(sk);
640 }
641 
gtp_encap_destroy(struct sock * sk)642 static void gtp_encap_destroy(struct sock *sk)
643 {
644 	rtnl_lock();
645 	__gtp_encap_destroy(sk);
646 	rtnl_unlock();
647 }
648 
gtp_encap_disable_sock(struct sock * sk)649 static void gtp_encap_disable_sock(struct sock *sk)
650 {
651 	if (!sk)
652 		return;
653 
654 	__gtp_encap_destroy(sk);
655 }
656 
gtp_encap_disable(struct gtp_dev * gtp)657 static void gtp_encap_disable(struct gtp_dev *gtp)
658 {
659 	if (gtp->sk_created) {
660 		udp_tunnel_sock_release(gtp->sk0->sk_socket);
661 		udp_tunnel_sock_release(gtp->sk1u->sk_socket);
662 		gtp->sk_created = false;
663 		gtp->sk0 = NULL;
664 		gtp->sk1u = NULL;
665 	} else {
666 		gtp_encap_disable_sock(gtp->sk0);
667 		gtp_encap_disable_sock(gtp->sk1u);
668 	}
669 }
670 
671 /* UDP encapsulation receive handler. See net/ipv4/udp.c.
672  * Return codes: 0: success, <0: error, >0: pass up to userspace UDP socket.
673  */
gtp_encap_recv(struct sock * sk,struct sk_buff * skb)674 static int gtp_encap_recv(struct sock *sk, struct sk_buff *skb)
675 {
676 	struct gtp_dev *gtp;
677 	int ret = 0;
678 
679 	gtp = rcu_dereference_sk_user_data(sk);
680 	if (!gtp)
681 		return 1;
682 
683 	netdev_dbg(gtp->dev, "encap_recv sk=%p\n", sk);
684 
685 	switch (READ_ONCE(udp_sk(sk)->encap_type)) {
686 	case UDP_ENCAP_GTP0:
687 		netdev_dbg(gtp->dev, "received GTP0 packet\n");
688 		ret = gtp0_udp_encap_recv(gtp, skb);
689 		break;
690 	case UDP_ENCAP_GTP1U:
691 		netdev_dbg(gtp->dev, "received GTP1U packet\n");
692 		ret = gtp1u_udp_encap_recv(gtp, skb);
693 		break;
694 	default:
695 		ret = -1; /* Shouldn't happen. */
696 	}
697 
698 	switch (ret) {
699 	case 1:
700 		netdev_dbg(gtp->dev, "pass up to the process\n");
701 		break;
702 	case 0:
703 		break;
704 	case -1:
705 		netdev_dbg(gtp->dev, "GTP packet has been dropped\n");
706 		kfree_skb(skb);
707 		ret = 0;
708 		break;
709 	}
710 
711 	return ret;
712 }
713 
gtp_dev_init(struct net_device * dev)714 static int gtp_dev_init(struct net_device *dev)
715 {
716 	struct gtp_dev *gtp = netdev_priv(dev);
717 
718 	gtp->dev = dev;
719 
720 	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
721 	if (!dev->tstats)
722 		return -ENOMEM;
723 
724 	return 0;
725 }
726 
gtp_dev_uninit(struct net_device * dev)727 static void gtp_dev_uninit(struct net_device *dev)
728 {
729 	struct gtp_dev *gtp = netdev_priv(dev);
730 
731 	gtp_encap_disable(gtp);
732 	free_percpu(dev->tstats);
733 }
734 
gtp0_push_header(struct sk_buff * skb,struct pdp_ctx * pctx)735 static inline void gtp0_push_header(struct sk_buff *skb, struct pdp_ctx *pctx)
736 {
737 	int payload_len = skb->len;
738 	struct gtp0_header *gtp0;
739 
740 	gtp0 = skb_push(skb, sizeof(*gtp0));
741 
742 	gtp0->flags	= 0x1e; /* v0, GTP-non-prime. */
743 	gtp0->type	= GTP_TPDU;
744 	gtp0->length	= htons(payload_len);
745 	gtp0->seq	= htons((atomic_inc_return(&pctx->tx_seq) - 1) % 0xffff);
746 	gtp0->flow	= htons(pctx->u.v0.flow);
747 	gtp0->number	= 0xff;
748 	gtp0->spare[0]	= gtp0->spare[1] = gtp0->spare[2] = 0xff;
749 	gtp0->tid	= cpu_to_be64(pctx->u.v0.tid);
750 }
751 
gtp1_push_header(struct sk_buff * skb,struct pdp_ctx * pctx)752 static inline void gtp1_push_header(struct sk_buff *skb, struct pdp_ctx *pctx)
753 {
754 	int payload_len = skb->len;
755 	struct gtp1_header *gtp1;
756 
757 	gtp1 = skb_push(skb, sizeof(*gtp1));
758 
759 	/* Bits    8  7  6  5  4  3  2	1
760 	 *	  +--+--+--+--+--+--+--+--+
761 	 *	  |version |PT| 0| E| S|PN|
762 	 *	  +--+--+--+--+--+--+--+--+
763 	 *	    0  0  1  1	1  0  0  0
764 	 */
765 	gtp1->flags	= 0x30; /* v1, GTP-non-prime. */
766 	gtp1->type	= GTP_TPDU;
767 	gtp1->length	= htons(payload_len);
768 	gtp1->tid	= htonl(pctx->u.v1.o_tei);
769 
770 	/* TODO: Support for extension header, sequence number and N-PDU.
771 	 *	 Update the length field if any of them is available.
772 	 */
773 }
774 
775 struct gtp_pktinfo {
776 	struct sock		*sk;
777 	struct iphdr		*iph;
778 	struct flowi4		fl4;
779 	struct rtable		*rt;
780 	struct pdp_ctx		*pctx;
781 	struct net_device	*dev;
782 	__be16			gtph_port;
783 };
784 
gtp_push_header(struct sk_buff * skb,struct gtp_pktinfo * pktinfo)785 static void gtp_push_header(struct sk_buff *skb, struct gtp_pktinfo *pktinfo)
786 {
787 	switch (pktinfo->pctx->gtp_version) {
788 	case GTP_V0:
789 		pktinfo->gtph_port = htons(GTP0_PORT);
790 		gtp0_push_header(skb, pktinfo->pctx);
791 		break;
792 	case GTP_V1:
793 		pktinfo->gtph_port = htons(GTP1U_PORT);
794 		gtp1_push_header(skb, pktinfo->pctx);
795 		break;
796 	}
797 }
798 
gtp_set_pktinfo_ipv4(struct gtp_pktinfo * pktinfo,struct sock * sk,struct iphdr * iph,struct pdp_ctx * pctx,struct rtable * rt,struct flowi4 * fl4,struct net_device * dev)799 static inline void gtp_set_pktinfo_ipv4(struct gtp_pktinfo *pktinfo,
800 					struct sock *sk, struct iphdr *iph,
801 					struct pdp_ctx *pctx, struct rtable *rt,
802 					struct flowi4 *fl4,
803 					struct net_device *dev)
804 {
805 	pktinfo->sk	= sk;
806 	pktinfo->iph	= iph;
807 	pktinfo->pctx	= pctx;
808 	pktinfo->rt	= rt;
809 	pktinfo->fl4	= *fl4;
810 	pktinfo->dev	= dev;
811 }
812 
gtp_build_skb_ip4(struct sk_buff * skb,struct net_device * dev,struct gtp_pktinfo * pktinfo)813 static int gtp_build_skb_ip4(struct sk_buff *skb, struct net_device *dev,
814 			     struct gtp_pktinfo *pktinfo)
815 {
816 	struct gtp_dev *gtp = netdev_priv(dev);
817 	struct pdp_ctx *pctx;
818 	struct rtable *rt;
819 	struct flowi4 fl4;
820 	struct iphdr *iph;
821 	__be16 df;
822 	int mtu;
823 
824 	/* Read the IP destination address and resolve the PDP context.
825 	 * Prepend PDP header with TEI/TID from PDP ctx.
826 	 */
827 	iph = ip_hdr(skb);
828 	if (gtp->role == GTP_ROLE_SGSN)
829 		pctx = ipv4_pdp_find(gtp, iph->saddr);
830 	else
831 		pctx = ipv4_pdp_find(gtp, iph->daddr);
832 
833 	if (!pctx) {
834 		netdev_dbg(dev, "no PDP ctx found for %pI4, skip\n",
835 			   &iph->daddr);
836 		return -ENOENT;
837 	}
838 	netdev_dbg(dev, "found PDP context %p\n", pctx);
839 
840 	rt = ip4_route_output_gtp(&fl4, pctx->sk, pctx->peer_addr_ip4.s_addr,
841 				  inet_sk(pctx->sk)->inet_saddr);
842 	if (IS_ERR(rt)) {
843 		netdev_dbg(dev, "no route to SSGN %pI4\n",
844 			   &pctx->peer_addr_ip4.s_addr);
845 		dev->stats.tx_carrier_errors++;
846 		goto err;
847 	}
848 
849 	if (rt->dst.dev == dev) {
850 		netdev_dbg(dev, "circular route to SSGN %pI4\n",
851 			   &pctx->peer_addr_ip4.s_addr);
852 		dev->stats.collisions++;
853 		goto err_rt;
854 	}
855 
856 	/* This is similar to tnl_update_pmtu(). */
857 	df = iph->frag_off;
858 	if (df) {
859 		mtu = dst_mtu(&rt->dst) - dev->hard_header_len -
860 			sizeof(struct iphdr) - sizeof(struct udphdr);
861 		switch (pctx->gtp_version) {
862 		case GTP_V0:
863 			mtu -= sizeof(struct gtp0_header);
864 			break;
865 		case GTP_V1:
866 			mtu -= sizeof(struct gtp1_header);
867 			break;
868 		}
869 	} else {
870 		mtu = dst_mtu(&rt->dst);
871 	}
872 
873 	skb_dst_update_pmtu_no_confirm(skb, mtu);
874 
875 	if (iph->frag_off & htons(IP_DF) &&
876 	    ((!skb_is_gso(skb) && skb->len > mtu) ||
877 	     (skb_is_gso(skb) && !skb_gso_validate_network_len(skb, mtu)))) {
878 		netdev_dbg(dev, "packet too big, fragmentation needed\n");
879 		icmp_ndo_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
880 			      htonl(mtu));
881 		goto err_rt;
882 	}
883 
884 	gtp_set_pktinfo_ipv4(pktinfo, pctx->sk, iph, pctx, rt, &fl4, dev);
885 	gtp_push_header(skb, pktinfo);
886 
887 	return 0;
888 err_rt:
889 	ip_rt_put(rt);
890 err:
891 	return -EBADMSG;
892 }
893 
gtp_dev_xmit(struct sk_buff * skb,struct net_device * dev)894 static netdev_tx_t gtp_dev_xmit(struct sk_buff *skb, struct net_device *dev)
895 {
896 	unsigned int proto = ntohs(skb->protocol);
897 	struct gtp_pktinfo pktinfo;
898 	int err;
899 
900 	/* Ensure there is sufficient headroom. */
901 	if (skb_cow_head(skb, dev->needed_headroom))
902 		goto tx_err;
903 
904 	if (!pskb_inet_may_pull(skb))
905 		goto tx_err;
906 
907 	skb_reset_inner_headers(skb);
908 
909 	/* PDP context lookups in gtp_build_skb_*() need rcu read-side lock. */
910 	rcu_read_lock();
911 	switch (proto) {
912 	case ETH_P_IP:
913 		err = gtp_build_skb_ip4(skb, dev, &pktinfo);
914 		break;
915 	default:
916 		err = -EOPNOTSUPP;
917 		break;
918 	}
919 	rcu_read_unlock();
920 
921 	if (err < 0)
922 		goto tx_err;
923 
924 	switch (proto) {
925 	case ETH_P_IP:
926 		netdev_dbg(pktinfo.dev, "gtp -> IP src: %pI4 dst: %pI4\n",
927 			   &pktinfo.iph->saddr, &pktinfo.iph->daddr);
928 		udp_tunnel_xmit_skb(pktinfo.rt, pktinfo.sk, skb,
929 				    pktinfo.fl4.saddr, pktinfo.fl4.daddr,
930 				    pktinfo.iph->tos,
931 				    ip4_dst_hoplimit(&pktinfo.rt->dst),
932 				    0,
933 				    pktinfo.gtph_port, pktinfo.gtph_port,
934 				    !net_eq(sock_net(pktinfo.pctx->sk),
935 					    dev_net(dev)),
936 				    false);
937 		break;
938 	}
939 
940 	return NETDEV_TX_OK;
941 tx_err:
942 	dev->stats.tx_errors++;
943 	dev_kfree_skb(skb);
944 	return NETDEV_TX_OK;
945 }
946 
947 static const struct net_device_ops gtp_netdev_ops = {
948 	.ndo_init		= gtp_dev_init,
949 	.ndo_uninit		= gtp_dev_uninit,
950 	.ndo_start_xmit		= gtp_dev_xmit,
951 	.ndo_get_stats64	= dev_get_tstats64,
952 };
953 
954 static const struct device_type gtp_type = {
955 	.name = "gtp",
956 };
957 
gtp_link_setup(struct net_device * dev)958 static void gtp_link_setup(struct net_device *dev)
959 {
960 	unsigned int max_gtp_header_len = sizeof(struct iphdr) +
961 					  sizeof(struct udphdr) +
962 					  sizeof(struct gtp0_header);
963 
964 	dev->netdev_ops		= &gtp_netdev_ops;
965 	dev->needs_free_netdev	= true;
966 	SET_NETDEV_DEVTYPE(dev, &gtp_type);
967 
968 	dev->hard_header_len = 0;
969 	dev->addr_len = 0;
970 	dev->mtu = ETH_DATA_LEN - max_gtp_header_len;
971 
972 	/* Zero header length. */
973 	dev->type = ARPHRD_NONE;
974 	dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
975 
976 	dev->priv_flags	|= IFF_NO_QUEUE;
977 	dev->features	|= NETIF_F_LLTX;
978 	netif_keep_dst(dev);
979 
980 	dev->needed_headroom	= LL_MAX_HEADER + max_gtp_header_len;
981 }
982 
983 static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize);
984 static int gtp_encap_enable(struct gtp_dev *gtp, struct nlattr *data[]);
985 
gtp_destructor(struct net_device * dev)986 static void gtp_destructor(struct net_device *dev)
987 {
988 	struct gtp_dev *gtp = netdev_priv(dev);
989 
990 	kfree(gtp->addr_hash);
991 	kfree(gtp->tid_hash);
992 }
993 
gtp_create_sock(int type,struct gtp_dev * gtp)994 static struct sock *gtp_create_sock(int type, struct gtp_dev *gtp)
995 {
996 	struct udp_tunnel_sock_cfg tuncfg = {};
997 	struct udp_port_cfg udp_conf = {
998 		.local_ip.s_addr	= htonl(INADDR_ANY),
999 		.family			= AF_INET,
1000 	};
1001 	struct net *net = gtp->net;
1002 	struct socket *sock;
1003 	int err;
1004 
1005 	if (type == UDP_ENCAP_GTP0)
1006 		udp_conf.local_udp_port = htons(GTP0_PORT);
1007 	else if (type == UDP_ENCAP_GTP1U)
1008 		udp_conf.local_udp_port = htons(GTP1U_PORT);
1009 	else
1010 		return ERR_PTR(-EINVAL);
1011 
1012 	err = udp_sock_create(net, &udp_conf, &sock);
1013 	if (err)
1014 		return ERR_PTR(err);
1015 
1016 	tuncfg.sk_user_data = gtp;
1017 	tuncfg.encap_type = type;
1018 	tuncfg.encap_rcv = gtp_encap_recv;
1019 	tuncfg.encap_destroy = NULL;
1020 
1021 	setup_udp_tunnel_sock(net, sock, &tuncfg);
1022 
1023 	return sock->sk;
1024 }
1025 
gtp_create_sockets(struct gtp_dev * gtp,struct nlattr * data[])1026 static int gtp_create_sockets(struct gtp_dev *gtp, struct nlattr *data[])
1027 {
1028 	struct sock *sk1u = NULL;
1029 	struct sock *sk0 = NULL;
1030 
1031 	sk0 = gtp_create_sock(UDP_ENCAP_GTP0, gtp);
1032 	if (IS_ERR(sk0))
1033 		return PTR_ERR(sk0);
1034 
1035 	sk1u = gtp_create_sock(UDP_ENCAP_GTP1U, gtp);
1036 	if (IS_ERR(sk1u)) {
1037 		udp_tunnel_sock_release(sk0->sk_socket);
1038 		return PTR_ERR(sk1u);
1039 	}
1040 
1041 	gtp->sk_created = true;
1042 	gtp->sk0 = sk0;
1043 	gtp->sk1u = sk1u;
1044 
1045 	return 0;
1046 }
1047 
gtp_newlink(struct net * src_net,struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1048 static int gtp_newlink(struct net *src_net, struct net_device *dev,
1049 		       struct nlattr *tb[], struct nlattr *data[],
1050 		       struct netlink_ext_ack *extack)
1051 {
1052 	unsigned int role = GTP_ROLE_GGSN;
1053 	struct gtp_dev *gtp;
1054 	struct gtp_net *gn;
1055 	int hashsize, err;
1056 
1057 	gtp = netdev_priv(dev);
1058 
1059 	if (!data[IFLA_GTP_PDP_HASHSIZE]) {
1060 		hashsize = 1024;
1061 	} else {
1062 		hashsize = nla_get_u32(data[IFLA_GTP_PDP_HASHSIZE]);
1063 		if (!hashsize)
1064 			hashsize = 1024;
1065 	}
1066 
1067 	if (data[IFLA_GTP_ROLE]) {
1068 		role = nla_get_u32(data[IFLA_GTP_ROLE]);
1069 		if (role > GTP_ROLE_SGSN)
1070 			return -EINVAL;
1071 	}
1072 	gtp->role = role;
1073 
1074 	if (!data[IFLA_GTP_RESTART_COUNT])
1075 		gtp->restart_count = 0;
1076 	else
1077 		gtp->restart_count = nla_get_u8(data[IFLA_GTP_RESTART_COUNT]);
1078 
1079 	gtp->net = src_net;
1080 
1081 	err = gtp_hashtable_new(gtp, hashsize);
1082 	if (err < 0)
1083 		return err;
1084 
1085 	if (data[IFLA_GTP_CREATE_SOCKETS])
1086 		err = gtp_create_sockets(gtp, data);
1087 	else
1088 		err = gtp_encap_enable(gtp, data);
1089 	if (err < 0)
1090 		goto out_hashtable;
1091 
1092 	err = register_netdevice(dev);
1093 	if (err < 0) {
1094 		netdev_dbg(dev, "failed to register new netdev %d\n", err);
1095 		goto out_encap;
1096 	}
1097 
1098 	gn = net_generic(dev_net(dev), gtp_net_id);
1099 	list_add_rcu(&gtp->list, &gn->gtp_dev_list);
1100 	dev->priv_destructor = gtp_destructor;
1101 
1102 	netdev_dbg(dev, "registered new GTP interface\n");
1103 
1104 	return 0;
1105 
1106 out_encap:
1107 	gtp_encap_disable(gtp);
1108 out_hashtable:
1109 	kfree(gtp->addr_hash);
1110 	kfree(gtp->tid_hash);
1111 	return err;
1112 }
1113 
gtp_dellink(struct net_device * dev,struct list_head * head)1114 static void gtp_dellink(struct net_device *dev, struct list_head *head)
1115 {
1116 	struct gtp_dev *gtp = netdev_priv(dev);
1117 	struct hlist_node *next;
1118 	struct pdp_ctx *pctx;
1119 	int i;
1120 
1121 	for (i = 0; i < gtp->hash_size; i++)
1122 		hlist_for_each_entry_safe(pctx, next, &gtp->tid_hash[i], hlist_tid)
1123 			pdp_context_delete(pctx);
1124 
1125 	list_del_rcu(&gtp->list);
1126 	unregister_netdevice_queue(dev, head);
1127 }
1128 
1129 static const struct nla_policy gtp_policy[IFLA_GTP_MAX + 1] = {
1130 	[IFLA_GTP_FD0]			= { .type = NLA_U32 },
1131 	[IFLA_GTP_FD1]			= { .type = NLA_U32 },
1132 	[IFLA_GTP_PDP_HASHSIZE]		= { .type = NLA_U32 },
1133 	[IFLA_GTP_ROLE]			= { .type = NLA_U32 },
1134 	[IFLA_GTP_CREATE_SOCKETS]	= { .type = NLA_U8 },
1135 	[IFLA_GTP_RESTART_COUNT]	= { .type = NLA_U8 },
1136 };
1137 
gtp_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1138 static int gtp_validate(struct nlattr *tb[], struct nlattr *data[],
1139 			struct netlink_ext_ack *extack)
1140 {
1141 	if (!data)
1142 		return -EINVAL;
1143 
1144 	return 0;
1145 }
1146 
gtp_get_size(const struct net_device * dev)1147 static size_t gtp_get_size(const struct net_device *dev)
1148 {
1149 	return nla_total_size(sizeof(__u32)) + /* IFLA_GTP_PDP_HASHSIZE */
1150 		nla_total_size(sizeof(__u32)) + /* IFLA_GTP_ROLE */
1151 		nla_total_size(sizeof(__u8)); /* IFLA_GTP_RESTART_COUNT */
1152 }
1153 
gtp_fill_info(struct sk_buff * skb,const struct net_device * dev)1154 static int gtp_fill_info(struct sk_buff *skb, const struct net_device *dev)
1155 {
1156 	struct gtp_dev *gtp = netdev_priv(dev);
1157 
1158 	if (nla_put_u32(skb, IFLA_GTP_PDP_HASHSIZE, gtp->hash_size))
1159 		goto nla_put_failure;
1160 	if (nla_put_u32(skb, IFLA_GTP_ROLE, gtp->role))
1161 		goto nla_put_failure;
1162 	if (nla_put_u8(skb, IFLA_GTP_RESTART_COUNT, gtp->restart_count))
1163 		goto nla_put_failure;
1164 
1165 	return 0;
1166 
1167 nla_put_failure:
1168 	return -EMSGSIZE;
1169 }
1170 
1171 static struct rtnl_link_ops gtp_link_ops __read_mostly = {
1172 	.kind		= "gtp",
1173 	.maxtype	= IFLA_GTP_MAX,
1174 	.policy		= gtp_policy,
1175 	.priv_size	= sizeof(struct gtp_dev),
1176 	.setup		= gtp_link_setup,
1177 	.validate	= gtp_validate,
1178 	.newlink	= gtp_newlink,
1179 	.dellink	= gtp_dellink,
1180 	.get_size	= gtp_get_size,
1181 	.fill_info	= gtp_fill_info,
1182 };
1183 
gtp_hashtable_new(struct gtp_dev * gtp,int hsize)1184 static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize)
1185 {
1186 	int i;
1187 
1188 	gtp->addr_hash = kmalloc_array(hsize, sizeof(struct hlist_head),
1189 				       GFP_KERNEL | __GFP_NOWARN);
1190 	if (gtp->addr_hash == NULL)
1191 		return -ENOMEM;
1192 
1193 	gtp->tid_hash = kmalloc_array(hsize, sizeof(struct hlist_head),
1194 				      GFP_KERNEL | __GFP_NOWARN);
1195 	if (gtp->tid_hash == NULL)
1196 		goto err1;
1197 
1198 	gtp->hash_size = hsize;
1199 
1200 	for (i = 0; i < hsize; i++) {
1201 		INIT_HLIST_HEAD(&gtp->addr_hash[i]);
1202 		INIT_HLIST_HEAD(&gtp->tid_hash[i]);
1203 	}
1204 	return 0;
1205 err1:
1206 	kfree(gtp->addr_hash);
1207 	return -ENOMEM;
1208 }
1209 
gtp_encap_enable_socket(int fd,int type,struct gtp_dev * gtp)1210 static struct sock *gtp_encap_enable_socket(int fd, int type,
1211 					    struct gtp_dev *gtp)
1212 {
1213 	struct udp_tunnel_sock_cfg tuncfg = {NULL};
1214 	struct socket *sock;
1215 	struct sock *sk;
1216 	int err;
1217 
1218 	pr_debug("enable gtp on %d, %d\n", fd, type);
1219 
1220 	sock = sockfd_lookup(fd, &err);
1221 	if (!sock) {
1222 		pr_debug("gtp socket fd=%d not found\n", fd);
1223 		return ERR_PTR(err);
1224 	}
1225 
1226 	sk = sock->sk;
1227 	if (sk->sk_protocol != IPPROTO_UDP ||
1228 	    sk->sk_type != SOCK_DGRAM ||
1229 	    (sk->sk_family != AF_INET && sk->sk_family != AF_INET6)) {
1230 		pr_debug("socket fd=%d not UDP\n", fd);
1231 		sk = ERR_PTR(-EINVAL);
1232 		goto out_sock;
1233 	}
1234 
1235 	lock_sock(sk);
1236 	if (sk->sk_user_data) {
1237 		sk = ERR_PTR(-EBUSY);
1238 		goto out_rel_sock;
1239 	}
1240 
1241 	sock_hold(sk);
1242 
1243 	tuncfg.sk_user_data = gtp;
1244 	tuncfg.encap_type = type;
1245 	tuncfg.encap_rcv = gtp_encap_recv;
1246 	tuncfg.encap_destroy = gtp_encap_destroy;
1247 
1248 	setup_udp_tunnel_sock(sock_net(sock->sk), sock, &tuncfg);
1249 
1250 out_rel_sock:
1251 	release_sock(sock->sk);
1252 out_sock:
1253 	sockfd_put(sock);
1254 	return sk;
1255 }
1256 
gtp_encap_enable(struct gtp_dev * gtp,struct nlattr * data[])1257 static int gtp_encap_enable(struct gtp_dev *gtp, struct nlattr *data[])
1258 {
1259 	struct sock *sk1u = NULL;
1260 	struct sock *sk0 = NULL;
1261 
1262 	if (!data[IFLA_GTP_FD0] && !data[IFLA_GTP_FD1])
1263 		return -EINVAL;
1264 
1265 	if (data[IFLA_GTP_FD0]) {
1266 		u32 fd0 = nla_get_u32(data[IFLA_GTP_FD0]);
1267 
1268 		sk0 = gtp_encap_enable_socket(fd0, UDP_ENCAP_GTP0, gtp);
1269 		if (IS_ERR(sk0))
1270 			return PTR_ERR(sk0);
1271 	}
1272 
1273 	if (data[IFLA_GTP_FD1]) {
1274 		u32 fd1 = nla_get_u32(data[IFLA_GTP_FD1]);
1275 
1276 		sk1u = gtp_encap_enable_socket(fd1, UDP_ENCAP_GTP1U, gtp);
1277 		if (IS_ERR(sk1u)) {
1278 			gtp_encap_disable_sock(sk0);
1279 			return PTR_ERR(sk1u);
1280 		}
1281 	}
1282 
1283 	gtp->sk0 = sk0;
1284 	gtp->sk1u = sk1u;
1285 
1286 	return 0;
1287 }
1288 
gtp_find_dev(struct net * src_net,struct nlattr * nla[])1289 static struct gtp_dev *gtp_find_dev(struct net *src_net, struct nlattr *nla[])
1290 {
1291 	struct gtp_dev *gtp = NULL;
1292 	struct net_device *dev;
1293 	struct net *net;
1294 
1295 	/* Examine the link attributes and figure out which network namespace
1296 	 * we are talking about.
1297 	 */
1298 	if (nla[GTPA_NET_NS_FD])
1299 		net = get_net_ns_by_fd(nla_get_u32(nla[GTPA_NET_NS_FD]));
1300 	else
1301 		net = get_net(src_net);
1302 
1303 	if (IS_ERR(net))
1304 		return NULL;
1305 
1306 	/* Check if there's an existing gtpX device to configure */
1307 	dev = dev_get_by_index_rcu(net, nla_get_u32(nla[GTPA_LINK]));
1308 	if (dev && dev->netdev_ops == &gtp_netdev_ops)
1309 		gtp = netdev_priv(dev);
1310 
1311 	put_net(net);
1312 	return gtp;
1313 }
1314 
ipv4_pdp_fill(struct pdp_ctx * pctx,struct genl_info * info)1315 static void ipv4_pdp_fill(struct pdp_ctx *pctx, struct genl_info *info)
1316 {
1317 	pctx->gtp_version = nla_get_u32(info->attrs[GTPA_VERSION]);
1318 	pctx->af = AF_INET;
1319 	pctx->peer_addr_ip4.s_addr =
1320 		nla_get_be32(info->attrs[GTPA_PEER_ADDRESS]);
1321 	pctx->ms_addr_ip4.s_addr =
1322 		nla_get_be32(info->attrs[GTPA_MS_ADDRESS]);
1323 
1324 	switch (pctx->gtp_version) {
1325 	case GTP_V0:
1326 		/* According to TS 09.60, sections 7.5.1 and 7.5.2, the flow
1327 		 * label needs to be the same for uplink and downlink packets,
1328 		 * so let's annotate this.
1329 		 */
1330 		pctx->u.v0.tid = nla_get_u64(info->attrs[GTPA_TID]);
1331 		pctx->u.v0.flow = nla_get_u16(info->attrs[GTPA_FLOW]);
1332 		break;
1333 	case GTP_V1:
1334 		pctx->u.v1.i_tei = nla_get_u32(info->attrs[GTPA_I_TEI]);
1335 		pctx->u.v1.o_tei = nla_get_u32(info->attrs[GTPA_O_TEI]);
1336 		break;
1337 	default:
1338 		break;
1339 	}
1340 }
1341 
gtp_pdp_add(struct gtp_dev * gtp,struct sock * sk,struct genl_info * info)1342 static struct pdp_ctx *gtp_pdp_add(struct gtp_dev *gtp, struct sock *sk,
1343 				   struct genl_info *info)
1344 {
1345 	struct pdp_ctx *pctx, *pctx_tid = NULL;
1346 	struct net_device *dev = gtp->dev;
1347 	u32 hash_ms, hash_tid = 0;
1348 	unsigned int version;
1349 	bool found = false;
1350 	__be32 ms_addr;
1351 
1352 	ms_addr = nla_get_be32(info->attrs[GTPA_MS_ADDRESS]);
1353 	hash_ms = ipv4_hashfn(ms_addr) % gtp->hash_size;
1354 	version = nla_get_u32(info->attrs[GTPA_VERSION]);
1355 
1356 	pctx = ipv4_pdp_find(gtp, ms_addr);
1357 	if (pctx)
1358 		found = true;
1359 	if (version == GTP_V0)
1360 		pctx_tid = gtp0_pdp_find(gtp,
1361 					 nla_get_u64(info->attrs[GTPA_TID]));
1362 	else if (version == GTP_V1)
1363 		pctx_tid = gtp1_pdp_find(gtp,
1364 					 nla_get_u32(info->attrs[GTPA_I_TEI]));
1365 	if (pctx_tid)
1366 		found = true;
1367 
1368 	if (found) {
1369 		if (info->nlhdr->nlmsg_flags & NLM_F_EXCL)
1370 			return ERR_PTR(-EEXIST);
1371 		if (info->nlhdr->nlmsg_flags & NLM_F_REPLACE)
1372 			return ERR_PTR(-EOPNOTSUPP);
1373 
1374 		if (pctx && pctx_tid)
1375 			return ERR_PTR(-EEXIST);
1376 		if (!pctx)
1377 			pctx = pctx_tid;
1378 
1379 		ipv4_pdp_fill(pctx, info);
1380 
1381 		if (pctx->gtp_version == GTP_V0)
1382 			netdev_dbg(dev, "GTPv0-U: update tunnel id = %llx (pdp %p)\n",
1383 				   pctx->u.v0.tid, pctx);
1384 		else if (pctx->gtp_version == GTP_V1)
1385 			netdev_dbg(dev, "GTPv1-U: update tunnel id = %x/%x (pdp %p)\n",
1386 				   pctx->u.v1.i_tei, pctx->u.v1.o_tei, pctx);
1387 
1388 		return pctx;
1389 
1390 	}
1391 
1392 	pctx = kmalloc(sizeof(*pctx), GFP_ATOMIC);
1393 	if (pctx == NULL)
1394 		return ERR_PTR(-ENOMEM);
1395 
1396 	sock_hold(sk);
1397 	pctx->sk = sk;
1398 	pctx->dev = gtp->dev;
1399 	ipv4_pdp_fill(pctx, info);
1400 	atomic_set(&pctx->tx_seq, 0);
1401 
1402 	switch (pctx->gtp_version) {
1403 	case GTP_V0:
1404 		/* TS 09.60: "The flow label identifies unambiguously a GTP
1405 		 * flow.". We use the tid for this instead, I cannot find a
1406 		 * situation in which this doesn't unambiguosly identify the
1407 		 * PDP context.
1408 		 */
1409 		hash_tid = gtp0_hashfn(pctx->u.v0.tid) % gtp->hash_size;
1410 		break;
1411 	case GTP_V1:
1412 		hash_tid = gtp1u_hashfn(pctx->u.v1.i_tei) % gtp->hash_size;
1413 		break;
1414 	}
1415 
1416 	hlist_add_head_rcu(&pctx->hlist_addr, &gtp->addr_hash[hash_ms]);
1417 	hlist_add_head_rcu(&pctx->hlist_tid, &gtp->tid_hash[hash_tid]);
1418 
1419 	switch (pctx->gtp_version) {
1420 	case GTP_V0:
1421 		netdev_dbg(dev, "GTPv0-U: new PDP ctx id=%llx ssgn=%pI4 ms=%pI4 (pdp=%p)\n",
1422 			   pctx->u.v0.tid, &pctx->peer_addr_ip4,
1423 			   &pctx->ms_addr_ip4, pctx);
1424 		break;
1425 	case GTP_V1:
1426 		netdev_dbg(dev, "GTPv1-U: new PDP ctx id=%x/%x ssgn=%pI4 ms=%pI4 (pdp=%p)\n",
1427 			   pctx->u.v1.i_tei, pctx->u.v1.o_tei,
1428 			   &pctx->peer_addr_ip4, &pctx->ms_addr_ip4, pctx);
1429 		break;
1430 	}
1431 
1432 	return pctx;
1433 }
1434 
pdp_context_free(struct rcu_head * head)1435 static void pdp_context_free(struct rcu_head *head)
1436 {
1437 	struct pdp_ctx *pctx = container_of(head, struct pdp_ctx, rcu_head);
1438 
1439 	sock_put(pctx->sk);
1440 	kfree(pctx);
1441 }
1442 
pdp_context_delete(struct pdp_ctx * pctx)1443 static void pdp_context_delete(struct pdp_ctx *pctx)
1444 {
1445 	hlist_del_rcu(&pctx->hlist_tid);
1446 	hlist_del_rcu(&pctx->hlist_addr);
1447 	call_rcu(&pctx->rcu_head, pdp_context_free);
1448 }
1449 
1450 static int gtp_tunnel_notify(struct pdp_ctx *pctx, u8 cmd, gfp_t allocation);
1451 
gtp_genl_new_pdp(struct sk_buff * skb,struct genl_info * info)1452 static int gtp_genl_new_pdp(struct sk_buff *skb, struct genl_info *info)
1453 {
1454 	unsigned int version;
1455 	struct pdp_ctx *pctx;
1456 	struct gtp_dev *gtp;
1457 	struct sock *sk;
1458 	int err;
1459 
1460 	if (!info->attrs[GTPA_VERSION] ||
1461 	    !info->attrs[GTPA_LINK] ||
1462 	    !info->attrs[GTPA_PEER_ADDRESS] ||
1463 	    !info->attrs[GTPA_MS_ADDRESS])
1464 		return -EINVAL;
1465 
1466 	version = nla_get_u32(info->attrs[GTPA_VERSION]);
1467 
1468 	switch (version) {
1469 	case GTP_V0:
1470 		if (!info->attrs[GTPA_TID] ||
1471 		    !info->attrs[GTPA_FLOW])
1472 			return -EINVAL;
1473 		break;
1474 	case GTP_V1:
1475 		if (!info->attrs[GTPA_I_TEI] ||
1476 		    !info->attrs[GTPA_O_TEI])
1477 			return -EINVAL;
1478 		break;
1479 
1480 	default:
1481 		return -EINVAL;
1482 	}
1483 
1484 	rtnl_lock();
1485 
1486 	gtp = gtp_find_dev(sock_net(skb->sk), info->attrs);
1487 	if (!gtp) {
1488 		err = -ENODEV;
1489 		goto out_unlock;
1490 	}
1491 
1492 	if (version == GTP_V0)
1493 		sk = gtp->sk0;
1494 	else if (version == GTP_V1)
1495 		sk = gtp->sk1u;
1496 	else
1497 		sk = NULL;
1498 
1499 	if (!sk) {
1500 		err = -ENODEV;
1501 		goto out_unlock;
1502 	}
1503 
1504 	pctx = gtp_pdp_add(gtp, sk, info);
1505 	if (IS_ERR(pctx)) {
1506 		err = PTR_ERR(pctx);
1507 	} else {
1508 		gtp_tunnel_notify(pctx, GTP_CMD_NEWPDP, GFP_KERNEL);
1509 		err = 0;
1510 	}
1511 
1512 out_unlock:
1513 	rtnl_unlock();
1514 	return err;
1515 }
1516 
gtp_find_pdp_by_link(struct net * net,struct nlattr * nla[])1517 static struct pdp_ctx *gtp_find_pdp_by_link(struct net *net,
1518 					    struct nlattr *nla[])
1519 {
1520 	struct gtp_dev *gtp;
1521 
1522 	gtp = gtp_find_dev(net, nla);
1523 	if (!gtp)
1524 		return ERR_PTR(-ENODEV);
1525 
1526 	if (nla[GTPA_MS_ADDRESS]) {
1527 		__be32 ip = nla_get_be32(nla[GTPA_MS_ADDRESS]);
1528 
1529 		return ipv4_pdp_find(gtp, ip);
1530 	} else if (nla[GTPA_VERSION]) {
1531 		u32 gtp_version = nla_get_u32(nla[GTPA_VERSION]);
1532 
1533 		if (gtp_version == GTP_V0 && nla[GTPA_TID])
1534 			return gtp0_pdp_find(gtp, nla_get_u64(nla[GTPA_TID]));
1535 		else if (gtp_version == GTP_V1 && nla[GTPA_I_TEI])
1536 			return gtp1_pdp_find(gtp, nla_get_u32(nla[GTPA_I_TEI]));
1537 	}
1538 
1539 	return ERR_PTR(-EINVAL);
1540 }
1541 
gtp_find_pdp(struct net * net,struct nlattr * nla[])1542 static struct pdp_ctx *gtp_find_pdp(struct net *net, struct nlattr *nla[])
1543 {
1544 	struct pdp_ctx *pctx;
1545 
1546 	if (nla[GTPA_LINK])
1547 		pctx = gtp_find_pdp_by_link(net, nla);
1548 	else
1549 		pctx = ERR_PTR(-EINVAL);
1550 
1551 	if (!pctx)
1552 		pctx = ERR_PTR(-ENOENT);
1553 
1554 	return pctx;
1555 }
1556 
gtp_genl_del_pdp(struct sk_buff * skb,struct genl_info * info)1557 static int gtp_genl_del_pdp(struct sk_buff *skb, struct genl_info *info)
1558 {
1559 	struct pdp_ctx *pctx;
1560 	int err = 0;
1561 
1562 	if (!info->attrs[GTPA_VERSION])
1563 		return -EINVAL;
1564 
1565 	rcu_read_lock();
1566 
1567 	pctx = gtp_find_pdp(sock_net(skb->sk), info->attrs);
1568 	if (IS_ERR(pctx)) {
1569 		err = PTR_ERR(pctx);
1570 		goto out_unlock;
1571 	}
1572 
1573 	if (pctx->gtp_version == GTP_V0)
1574 		netdev_dbg(pctx->dev, "GTPv0-U: deleting tunnel id = %llx (pdp %p)\n",
1575 			   pctx->u.v0.tid, pctx);
1576 	else if (pctx->gtp_version == GTP_V1)
1577 		netdev_dbg(pctx->dev, "GTPv1-U: deleting tunnel id = %x/%x (pdp %p)\n",
1578 			   pctx->u.v1.i_tei, pctx->u.v1.o_tei, pctx);
1579 
1580 	gtp_tunnel_notify(pctx, GTP_CMD_DELPDP, GFP_ATOMIC);
1581 	pdp_context_delete(pctx);
1582 
1583 out_unlock:
1584 	rcu_read_unlock();
1585 	return err;
1586 }
1587 
gtp_genl_fill_info(struct sk_buff * skb,u32 snd_portid,u32 snd_seq,int flags,u32 type,struct pdp_ctx * pctx)1588 static int gtp_genl_fill_info(struct sk_buff *skb, u32 snd_portid, u32 snd_seq,
1589 			      int flags, u32 type, struct pdp_ctx *pctx)
1590 {
1591 	void *genlh;
1592 
1593 	genlh = genlmsg_put(skb, snd_portid, snd_seq, &gtp_genl_family, flags,
1594 			    type);
1595 	if (genlh == NULL)
1596 		goto nlmsg_failure;
1597 
1598 	if (nla_put_u32(skb, GTPA_VERSION, pctx->gtp_version) ||
1599 	    nla_put_u32(skb, GTPA_LINK, pctx->dev->ifindex) ||
1600 	    nla_put_be32(skb, GTPA_PEER_ADDRESS, pctx->peer_addr_ip4.s_addr) ||
1601 	    nla_put_be32(skb, GTPA_MS_ADDRESS, pctx->ms_addr_ip4.s_addr))
1602 		goto nla_put_failure;
1603 
1604 	switch (pctx->gtp_version) {
1605 	case GTP_V0:
1606 		if (nla_put_u64_64bit(skb, GTPA_TID, pctx->u.v0.tid, GTPA_PAD) ||
1607 		    nla_put_u16(skb, GTPA_FLOW, pctx->u.v0.flow))
1608 			goto nla_put_failure;
1609 		break;
1610 	case GTP_V1:
1611 		if (nla_put_u32(skb, GTPA_I_TEI, pctx->u.v1.i_tei) ||
1612 		    nla_put_u32(skb, GTPA_O_TEI, pctx->u.v1.o_tei))
1613 			goto nla_put_failure;
1614 		break;
1615 	}
1616 	genlmsg_end(skb, genlh);
1617 	return 0;
1618 
1619 nlmsg_failure:
1620 nla_put_failure:
1621 	genlmsg_cancel(skb, genlh);
1622 	return -EMSGSIZE;
1623 }
1624 
gtp_tunnel_notify(struct pdp_ctx * pctx,u8 cmd,gfp_t allocation)1625 static int gtp_tunnel_notify(struct pdp_ctx *pctx, u8 cmd, gfp_t allocation)
1626 {
1627 	struct sk_buff *msg;
1628 	int ret;
1629 
1630 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, allocation);
1631 	if (!msg)
1632 		return -ENOMEM;
1633 
1634 	ret = gtp_genl_fill_info(msg, 0, 0, 0, cmd, pctx);
1635 	if (ret < 0) {
1636 		nlmsg_free(msg);
1637 		return ret;
1638 	}
1639 
1640 	ret = genlmsg_multicast_netns(&gtp_genl_family, dev_net(pctx->dev), msg,
1641 				      0, GTP_GENL_MCGRP, GFP_ATOMIC);
1642 	return ret;
1643 }
1644 
gtp_genl_get_pdp(struct sk_buff * skb,struct genl_info * info)1645 static int gtp_genl_get_pdp(struct sk_buff *skb, struct genl_info *info)
1646 {
1647 	struct pdp_ctx *pctx = NULL;
1648 	struct sk_buff *skb2;
1649 	int err;
1650 
1651 	if (!info->attrs[GTPA_VERSION])
1652 		return -EINVAL;
1653 
1654 	rcu_read_lock();
1655 
1656 	pctx = gtp_find_pdp(sock_net(skb->sk), info->attrs);
1657 	if (IS_ERR(pctx)) {
1658 		err = PTR_ERR(pctx);
1659 		goto err_unlock;
1660 	}
1661 
1662 	skb2 = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
1663 	if (skb2 == NULL) {
1664 		err = -ENOMEM;
1665 		goto err_unlock;
1666 	}
1667 
1668 	err = gtp_genl_fill_info(skb2, NETLINK_CB(skb).portid, info->snd_seq,
1669 				 0, info->nlhdr->nlmsg_type, pctx);
1670 	if (err < 0)
1671 		goto err_unlock_free;
1672 
1673 	rcu_read_unlock();
1674 	return genlmsg_unicast(genl_info_net(info), skb2, info->snd_portid);
1675 
1676 err_unlock_free:
1677 	kfree_skb(skb2);
1678 err_unlock:
1679 	rcu_read_unlock();
1680 	return err;
1681 }
1682 
gtp_genl_dump_pdp(struct sk_buff * skb,struct netlink_callback * cb)1683 static int gtp_genl_dump_pdp(struct sk_buff *skb,
1684 				struct netlink_callback *cb)
1685 {
1686 	struct gtp_dev *last_gtp = (struct gtp_dev *)cb->args[2], *gtp;
1687 	int i, j, bucket = cb->args[0], skip = cb->args[1];
1688 	struct net *net = sock_net(skb->sk);
1689 	struct pdp_ctx *pctx;
1690 	struct gtp_net *gn;
1691 
1692 	gn = net_generic(net, gtp_net_id);
1693 
1694 	if (cb->args[4])
1695 		return 0;
1696 
1697 	rcu_read_lock();
1698 	list_for_each_entry_rcu(gtp, &gn->gtp_dev_list, list) {
1699 		if (last_gtp && last_gtp != gtp)
1700 			continue;
1701 		else
1702 			last_gtp = NULL;
1703 
1704 		for (i = bucket; i < gtp->hash_size; i++) {
1705 			j = 0;
1706 			hlist_for_each_entry_rcu(pctx, &gtp->tid_hash[i],
1707 						 hlist_tid) {
1708 				if (j >= skip &&
1709 				    gtp_genl_fill_info(skb,
1710 					    NETLINK_CB(cb->skb).portid,
1711 					    cb->nlh->nlmsg_seq,
1712 					    NLM_F_MULTI,
1713 					    cb->nlh->nlmsg_type, pctx)) {
1714 					cb->args[0] = i;
1715 					cb->args[1] = j;
1716 					cb->args[2] = (unsigned long)gtp;
1717 					goto out;
1718 				}
1719 				j++;
1720 			}
1721 			skip = 0;
1722 		}
1723 		bucket = 0;
1724 	}
1725 	cb->args[4] = 1;
1726 out:
1727 	rcu_read_unlock();
1728 	return skb->len;
1729 }
1730 
gtp_genl_send_echo_req(struct sk_buff * skb,struct genl_info * info)1731 static int gtp_genl_send_echo_req(struct sk_buff *skb, struct genl_info *info)
1732 {
1733 	struct sk_buff *skb_to_send;
1734 	__be32 src_ip, dst_ip;
1735 	unsigned int version;
1736 	struct gtp_dev *gtp;
1737 	struct flowi4 fl4;
1738 	struct rtable *rt;
1739 	struct sock *sk;
1740 	__be16 port;
1741 	int len;
1742 
1743 	if (!info->attrs[GTPA_VERSION] ||
1744 	    !info->attrs[GTPA_LINK] ||
1745 	    !info->attrs[GTPA_PEER_ADDRESS] ||
1746 	    !info->attrs[GTPA_MS_ADDRESS])
1747 		return -EINVAL;
1748 
1749 	version = nla_get_u32(info->attrs[GTPA_VERSION]);
1750 	dst_ip = nla_get_be32(info->attrs[GTPA_PEER_ADDRESS]);
1751 	src_ip = nla_get_be32(info->attrs[GTPA_MS_ADDRESS]);
1752 
1753 	gtp = gtp_find_dev(sock_net(skb->sk), info->attrs);
1754 	if (!gtp)
1755 		return -ENODEV;
1756 
1757 	if (!gtp->sk_created)
1758 		return -EOPNOTSUPP;
1759 	if (!(gtp->dev->flags & IFF_UP))
1760 		return -ENETDOWN;
1761 
1762 	if (version == GTP_V0) {
1763 		struct gtp0_header *gtp0_h;
1764 
1765 		len = LL_RESERVED_SPACE(gtp->dev) + sizeof(struct gtp0_header) +
1766 			sizeof(struct iphdr) + sizeof(struct udphdr);
1767 
1768 		skb_to_send = netdev_alloc_skb_ip_align(gtp->dev, len);
1769 		if (!skb_to_send)
1770 			return -ENOMEM;
1771 
1772 		sk = gtp->sk0;
1773 		port = htons(GTP0_PORT);
1774 
1775 		gtp0_h = skb_push(skb_to_send, sizeof(struct gtp0_header));
1776 		memset(gtp0_h, 0, sizeof(struct gtp0_header));
1777 		gtp0_build_echo_msg(gtp0_h, GTP_ECHO_REQ);
1778 	} else if (version == GTP_V1) {
1779 		struct gtp1_header_long *gtp1u_h;
1780 
1781 		len = LL_RESERVED_SPACE(gtp->dev) +
1782 			sizeof(struct gtp1_header_long) +
1783 			sizeof(struct iphdr) + sizeof(struct udphdr);
1784 
1785 		skb_to_send = netdev_alloc_skb_ip_align(gtp->dev, len);
1786 		if (!skb_to_send)
1787 			return -ENOMEM;
1788 
1789 		sk = gtp->sk1u;
1790 		port = htons(GTP1U_PORT);
1791 
1792 		gtp1u_h = skb_push(skb_to_send,
1793 				   sizeof(struct gtp1_header_long));
1794 		memset(gtp1u_h, 0, sizeof(struct gtp1_header_long));
1795 		gtp1u_build_echo_msg(gtp1u_h, GTP_ECHO_REQ);
1796 	} else {
1797 		return -ENODEV;
1798 	}
1799 
1800 	rt = ip4_route_output_gtp(&fl4, sk, dst_ip, src_ip);
1801 	if (IS_ERR(rt)) {
1802 		netdev_dbg(gtp->dev, "no route for echo request to %pI4\n",
1803 			   &dst_ip);
1804 		kfree_skb(skb_to_send);
1805 		return -ENODEV;
1806 	}
1807 
1808 	udp_tunnel_xmit_skb(rt, sk, skb_to_send,
1809 			    fl4.saddr, fl4.daddr,
1810 			    fl4.flowi4_tos,
1811 			    ip4_dst_hoplimit(&rt->dst),
1812 			    0,
1813 			    port, port,
1814 			    !net_eq(sock_net(sk),
1815 				    dev_net(gtp->dev)),
1816 			    false);
1817 	return 0;
1818 }
1819 
1820 static const struct nla_policy gtp_genl_policy[GTPA_MAX + 1] = {
1821 	[GTPA_LINK]		= { .type = NLA_U32, },
1822 	[GTPA_VERSION]		= { .type = NLA_U32, },
1823 	[GTPA_TID]		= { .type = NLA_U64, },
1824 	[GTPA_PEER_ADDRESS]	= { .type = NLA_U32, },
1825 	[GTPA_MS_ADDRESS]	= { .type = NLA_U32, },
1826 	[GTPA_FLOW]		= { .type = NLA_U16, },
1827 	[GTPA_NET_NS_FD]	= { .type = NLA_U32, },
1828 	[GTPA_I_TEI]		= { .type = NLA_U32, },
1829 	[GTPA_O_TEI]		= { .type = NLA_U32, },
1830 };
1831 
1832 static const struct genl_small_ops gtp_genl_ops[] = {
1833 	{
1834 		.cmd = GTP_CMD_NEWPDP,
1835 		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1836 		.doit = gtp_genl_new_pdp,
1837 		.flags = GENL_ADMIN_PERM,
1838 	},
1839 	{
1840 		.cmd = GTP_CMD_DELPDP,
1841 		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1842 		.doit = gtp_genl_del_pdp,
1843 		.flags = GENL_ADMIN_PERM,
1844 	},
1845 	{
1846 		.cmd = GTP_CMD_GETPDP,
1847 		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1848 		.doit = gtp_genl_get_pdp,
1849 		.dumpit = gtp_genl_dump_pdp,
1850 		.flags = GENL_ADMIN_PERM,
1851 	},
1852 	{
1853 		.cmd = GTP_CMD_ECHOREQ,
1854 		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1855 		.doit = gtp_genl_send_echo_req,
1856 		.flags = GENL_ADMIN_PERM,
1857 	},
1858 };
1859 
1860 static struct genl_family gtp_genl_family __ro_after_init = {
1861 	.name		= "gtp",
1862 	.version	= 0,
1863 	.hdrsize	= 0,
1864 	.maxattr	= GTPA_MAX,
1865 	.policy = gtp_genl_policy,
1866 	.netnsok	= true,
1867 	.module		= THIS_MODULE,
1868 	.small_ops	= gtp_genl_ops,
1869 	.n_small_ops	= ARRAY_SIZE(gtp_genl_ops),
1870 	.resv_start_op	= GTP_CMD_ECHOREQ + 1,
1871 	.mcgrps		= gtp_genl_mcgrps,
1872 	.n_mcgrps	= ARRAY_SIZE(gtp_genl_mcgrps),
1873 };
1874 
gtp_net_init(struct net * net)1875 static int __net_init gtp_net_init(struct net *net)
1876 {
1877 	struct gtp_net *gn = net_generic(net, gtp_net_id);
1878 
1879 	INIT_LIST_HEAD(&gn->gtp_dev_list);
1880 	return 0;
1881 }
1882 
gtp_net_exit(struct net * net)1883 static void __net_exit gtp_net_exit(struct net *net)
1884 {
1885 	struct gtp_net *gn = net_generic(net, gtp_net_id);
1886 	struct gtp_dev *gtp;
1887 	LIST_HEAD(list);
1888 
1889 	rtnl_lock();
1890 	list_for_each_entry(gtp, &gn->gtp_dev_list, list)
1891 		gtp_dellink(gtp->dev, &list);
1892 
1893 	unregister_netdevice_many(&list);
1894 	rtnl_unlock();
1895 }
1896 
1897 static struct pernet_operations gtp_net_ops = {
1898 	.init	= gtp_net_init,
1899 	.exit	= gtp_net_exit,
1900 	.id	= &gtp_net_id,
1901 	.size	= sizeof(struct gtp_net),
1902 };
1903 
gtp_init(void)1904 static int __init gtp_init(void)
1905 {
1906 	int err;
1907 
1908 	get_random_bytes(&gtp_h_initval, sizeof(gtp_h_initval));
1909 
1910 	err = register_pernet_subsys(&gtp_net_ops);
1911 	if (err < 0)
1912 		goto error_out;
1913 
1914 	err = rtnl_link_register(&gtp_link_ops);
1915 	if (err < 0)
1916 		goto unreg_pernet_subsys;
1917 
1918 	err = genl_register_family(&gtp_genl_family);
1919 	if (err < 0)
1920 		goto unreg_rtnl_link;
1921 
1922 	pr_info("GTP module loaded (pdp ctx size %zd bytes)\n",
1923 		sizeof(struct pdp_ctx));
1924 	return 0;
1925 
1926 unreg_rtnl_link:
1927 	rtnl_link_unregister(&gtp_link_ops);
1928 unreg_pernet_subsys:
1929 	unregister_pernet_subsys(&gtp_net_ops);
1930 error_out:
1931 	pr_err("error loading GTP module loaded\n");
1932 	return err;
1933 }
1934 late_initcall(gtp_init);
1935 
gtp_fini(void)1936 static void __exit gtp_fini(void)
1937 {
1938 	genl_unregister_family(&gtp_genl_family);
1939 	rtnl_link_unregister(&gtp_link_ops);
1940 	unregister_pernet_subsys(&gtp_net_ops);
1941 
1942 	pr_info("GTP module unloaded\n");
1943 }
1944 module_exit(gtp_fini);
1945 
1946 MODULE_LICENSE("GPL");
1947 MODULE_AUTHOR("Harald Welte <hwelte@sysmocom.de>");
1948 MODULE_DESCRIPTION("Interface driver for GTP encapsulated traffic");
1949 MODULE_ALIAS_RTNL_LINK("gtp");
1950 MODULE_ALIAS_GENL_FAMILY("gtp");
1951