xref: /openbmc/linux/net/xfrm/espintcp.c (revision f8dd95b2)
1 // SPDX-License-Identifier: GPL-2.0
2 #include <net/tcp.h>
3 #include <net/strparser.h>
4 #include <net/xfrm.h>
5 #include <net/esp.h>
6 #include <net/espintcp.h>
7 #include <linux/skmsg.h>
8 #include <net/inet_common.h>
9 #include <trace/events/sock.h>
10 #if IS_ENABLED(CONFIG_IPV6)
11 #include <net/ipv6_stubs.h>
12 #endif
13 
handle_nonesp(struct espintcp_ctx * ctx,struct sk_buff * skb,struct sock * sk)14 static void handle_nonesp(struct espintcp_ctx *ctx, struct sk_buff *skb,
15 			  struct sock *sk)
16 {
17 	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf ||
18 	    !sk_rmem_schedule(sk, skb, skb->truesize)) {
19 		XFRM_INC_STATS(sock_net(sk), LINUX_MIB_XFRMINERROR);
20 		kfree_skb(skb);
21 		return;
22 	}
23 
24 	skb_set_owner_r(skb, sk);
25 
26 	memset(skb->cb, 0, sizeof(skb->cb));
27 	skb_queue_tail(&ctx->ike_queue, skb);
28 	ctx->saved_data_ready(sk);
29 }
30 
handle_esp(struct sk_buff * skb,struct sock * sk)31 static void handle_esp(struct sk_buff *skb, struct sock *sk)
32 {
33 	struct tcp_skb_cb *tcp_cb = (struct tcp_skb_cb *)skb->cb;
34 
35 	skb_reset_transport_header(skb);
36 
37 	/* restore IP CB, we need at least IP6CB->nhoff */
38 	memmove(skb->cb, &tcp_cb->header, sizeof(tcp_cb->header));
39 
40 	rcu_read_lock();
41 	skb->dev = dev_get_by_index_rcu(sock_net(sk), skb->skb_iif);
42 	local_bh_disable();
43 #if IS_ENABLED(CONFIG_IPV6)
44 	if (sk->sk_family == AF_INET6)
45 		ipv6_stub->xfrm6_rcv_encap(skb, IPPROTO_ESP, 0, TCP_ENCAP_ESPINTCP);
46 	else
47 #endif
48 		xfrm4_rcv_encap(skb, IPPROTO_ESP, 0, TCP_ENCAP_ESPINTCP);
49 	local_bh_enable();
50 	rcu_read_unlock();
51 }
52 
espintcp_rcv(struct strparser * strp,struct sk_buff * skb)53 static void espintcp_rcv(struct strparser *strp, struct sk_buff *skb)
54 {
55 	struct espintcp_ctx *ctx = container_of(strp, struct espintcp_ctx,
56 						strp);
57 	struct strp_msg *rxm = strp_msg(skb);
58 	int len = rxm->full_len - 2;
59 	u32 nonesp_marker;
60 	int err;
61 
62 	/* keepalive packet? */
63 	if (unlikely(len == 1)) {
64 		u8 data;
65 
66 		err = skb_copy_bits(skb, rxm->offset + 2, &data, 1);
67 		if (err < 0) {
68 			XFRM_INC_STATS(sock_net(strp->sk), LINUX_MIB_XFRMINHDRERROR);
69 			kfree_skb(skb);
70 			return;
71 		}
72 
73 		if (data == 0xff) {
74 			kfree_skb(skb);
75 			return;
76 		}
77 	}
78 
79 	/* drop other short messages */
80 	if (unlikely(len <= sizeof(nonesp_marker))) {
81 		XFRM_INC_STATS(sock_net(strp->sk), LINUX_MIB_XFRMINHDRERROR);
82 		kfree_skb(skb);
83 		return;
84 	}
85 
86 	err = skb_copy_bits(skb, rxm->offset + 2, &nonesp_marker,
87 			    sizeof(nonesp_marker));
88 	if (err < 0) {
89 		XFRM_INC_STATS(sock_net(strp->sk), LINUX_MIB_XFRMINHDRERROR);
90 		kfree_skb(skb);
91 		return;
92 	}
93 
94 	/* remove header, leave non-ESP marker/SPI */
95 	if (!pskb_pull(skb, rxm->offset + 2)) {
96 		XFRM_INC_STATS(sock_net(strp->sk), LINUX_MIB_XFRMINERROR);
97 		kfree_skb(skb);
98 		return;
99 	}
100 
101 	if (pskb_trim(skb, rxm->full_len - 2) != 0) {
102 		XFRM_INC_STATS(sock_net(strp->sk), LINUX_MIB_XFRMINERROR);
103 		kfree_skb(skb);
104 		return;
105 	}
106 
107 	if (nonesp_marker == 0)
108 		handle_nonesp(ctx, skb, strp->sk);
109 	else
110 		handle_esp(skb, strp->sk);
111 }
112 
espintcp_parse(struct strparser * strp,struct sk_buff * skb)113 static int espintcp_parse(struct strparser *strp, struct sk_buff *skb)
114 {
115 	struct strp_msg *rxm = strp_msg(skb);
116 	__be16 blen;
117 	u16 len;
118 	int err;
119 
120 	if (skb->len < rxm->offset + 2)
121 		return 0;
122 
123 	err = skb_copy_bits(skb, rxm->offset, &blen, sizeof(blen));
124 	if (err < 0)
125 		return err;
126 
127 	len = be16_to_cpu(blen);
128 	if (len < 2)
129 		return -EINVAL;
130 
131 	return len;
132 }
133 
espintcp_recvmsg(struct sock * sk,struct msghdr * msg,size_t len,int flags,int * addr_len)134 static int espintcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
135 			    int flags, int *addr_len)
136 {
137 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
138 	struct sk_buff *skb;
139 	int err = 0;
140 	int copied;
141 	int off = 0;
142 
143 	skb = __skb_recv_datagram(sk, &ctx->ike_queue, flags, &off, &err);
144 	if (!skb) {
145 		if (err == -EAGAIN && sk->sk_shutdown & RCV_SHUTDOWN)
146 			return 0;
147 		return err;
148 	}
149 
150 	copied = len;
151 	if (copied > skb->len)
152 		copied = skb->len;
153 	else if (copied < skb->len)
154 		msg->msg_flags |= MSG_TRUNC;
155 
156 	err = skb_copy_datagram_msg(skb, 0, msg, copied);
157 	if (unlikely(err)) {
158 		kfree_skb(skb);
159 		return err;
160 	}
161 
162 	if (flags & MSG_TRUNC)
163 		copied = skb->len;
164 	kfree_skb(skb);
165 	return copied;
166 }
167 
espintcp_queue_out(struct sock * sk,struct sk_buff * skb)168 int espintcp_queue_out(struct sock *sk, struct sk_buff *skb)
169 {
170 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
171 
172 	if (skb_queue_len(&ctx->out_queue) >= READ_ONCE(netdev_max_backlog))
173 		return -ENOBUFS;
174 
175 	__skb_queue_tail(&ctx->out_queue, skb);
176 
177 	return 0;
178 }
179 EXPORT_SYMBOL_GPL(espintcp_queue_out);
180 
181 /* espintcp length field is 2B and length includes the length field's size */
182 #define MAX_ESPINTCP_MSG (((1 << 16) - 1) - 2)
183 
espintcp_sendskb_locked(struct sock * sk,struct espintcp_msg * emsg,int flags)184 static int espintcp_sendskb_locked(struct sock *sk, struct espintcp_msg *emsg,
185 				   int flags)
186 {
187 	do {
188 		int ret;
189 
190 		ret = skb_send_sock_locked(sk, emsg->skb,
191 					   emsg->offset, emsg->len);
192 		if (ret < 0)
193 			return ret;
194 
195 		emsg->len -= ret;
196 		emsg->offset += ret;
197 	} while (emsg->len > 0);
198 
199 	kfree_skb(emsg->skb);
200 	memset(emsg, 0, sizeof(*emsg));
201 
202 	return 0;
203 }
204 
espintcp_sendskmsg_locked(struct sock * sk,struct espintcp_msg * emsg,int flags)205 static int espintcp_sendskmsg_locked(struct sock *sk,
206 				     struct espintcp_msg *emsg, int flags)
207 {
208 	struct msghdr msghdr = {
209 		.msg_flags = flags | MSG_SPLICE_PAGES | MSG_MORE,
210 	};
211 	struct sk_msg *skmsg = &emsg->skmsg;
212 	bool more = flags & MSG_MORE;
213 	struct scatterlist *sg;
214 	int done = 0;
215 	int ret;
216 
217 	sg = &skmsg->sg.data[skmsg->sg.start];
218 	do {
219 		struct bio_vec bvec;
220 		size_t size = sg->length - emsg->offset;
221 		int offset = sg->offset + emsg->offset;
222 		struct page *p;
223 
224 		emsg->offset = 0;
225 
226 		if (sg_is_last(sg) && !more)
227 			msghdr.msg_flags &= ~MSG_MORE;
228 
229 		p = sg_page(sg);
230 retry:
231 		bvec_set_page(&bvec, p, size, offset);
232 		iov_iter_bvec(&msghdr.msg_iter, ITER_SOURCE, &bvec, 1, size);
233 		ret = tcp_sendmsg_locked(sk, &msghdr, size);
234 		if (ret < 0) {
235 			emsg->offset = offset - sg->offset;
236 			skmsg->sg.start += done;
237 			return ret;
238 		}
239 
240 		if (ret != size) {
241 			offset += ret;
242 			size -= ret;
243 			goto retry;
244 		}
245 
246 		done++;
247 		put_page(p);
248 		sk_mem_uncharge(sk, sg->length);
249 		sg = sg_next(sg);
250 	} while (sg);
251 
252 	memset(emsg, 0, sizeof(*emsg));
253 
254 	return 0;
255 }
256 
espintcp_push_msgs(struct sock * sk,int flags)257 static int espintcp_push_msgs(struct sock *sk, int flags)
258 {
259 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
260 	struct espintcp_msg *emsg = &ctx->partial;
261 	int err;
262 
263 	if (!emsg->len)
264 		return 0;
265 
266 	if (ctx->tx_running)
267 		return -EAGAIN;
268 	ctx->tx_running = 1;
269 
270 	if (emsg->skb)
271 		err = espintcp_sendskb_locked(sk, emsg, flags);
272 	else
273 		err = espintcp_sendskmsg_locked(sk, emsg, flags);
274 	if (err == -EAGAIN) {
275 		ctx->tx_running = 0;
276 		return flags & MSG_DONTWAIT ? -EAGAIN : 0;
277 	}
278 	if (!err)
279 		memset(emsg, 0, sizeof(*emsg));
280 
281 	ctx->tx_running = 0;
282 
283 	return err;
284 }
285 
espintcp_push_skb(struct sock * sk,struct sk_buff * skb)286 int espintcp_push_skb(struct sock *sk, struct sk_buff *skb)
287 {
288 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
289 	struct espintcp_msg *emsg = &ctx->partial;
290 	unsigned int len;
291 	int offset;
292 
293 	if (sk->sk_state != TCP_ESTABLISHED) {
294 		kfree_skb(skb);
295 		return -ECONNRESET;
296 	}
297 
298 	offset = skb_transport_offset(skb);
299 	len = skb->len - offset;
300 
301 	espintcp_push_msgs(sk, 0);
302 
303 	if (emsg->len) {
304 		kfree_skb(skb);
305 		return -ENOBUFS;
306 	}
307 
308 	skb_set_owner_w(skb, sk);
309 
310 	emsg->offset = offset;
311 	emsg->len = len;
312 	emsg->skb = skb;
313 
314 	espintcp_push_msgs(sk, 0);
315 
316 	return 0;
317 }
318 EXPORT_SYMBOL_GPL(espintcp_push_skb);
319 
espintcp_sendmsg(struct sock * sk,struct msghdr * msg,size_t size)320 static int espintcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
321 {
322 	long timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
323 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
324 	struct espintcp_msg *emsg = &ctx->partial;
325 	struct iov_iter pfx_iter;
326 	struct kvec pfx_iov = {};
327 	size_t msglen = size + 2;
328 	char buf[2] = {0};
329 	int err, end;
330 
331 	if (msg->msg_flags & ~MSG_DONTWAIT)
332 		return -EOPNOTSUPP;
333 
334 	if (size > MAX_ESPINTCP_MSG)
335 		return -EMSGSIZE;
336 
337 	if (msg->msg_controllen)
338 		return -EOPNOTSUPP;
339 
340 	lock_sock(sk);
341 
342 	err = espintcp_push_msgs(sk, msg->msg_flags & MSG_DONTWAIT);
343 	if (err < 0) {
344 		if (err != -EAGAIN || !(msg->msg_flags & MSG_DONTWAIT))
345 			err = -ENOBUFS;
346 		goto unlock;
347 	}
348 
349 	sk_msg_init(&emsg->skmsg);
350 	while (1) {
351 		/* only -ENOMEM is possible since we don't coalesce */
352 		err = sk_msg_alloc(sk, &emsg->skmsg, msglen, 0);
353 		if (!err)
354 			break;
355 
356 		err = sk_stream_wait_memory(sk, &timeo);
357 		if (err)
358 			goto fail;
359 	}
360 
361 	*((__be16 *)buf) = cpu_to_be16(msglen);
362 	pfx_iov.iov_base = buf;
363 	pfx_iov.iov_len = sizeof(buf);
364 	iov_iter_kvec(&pfx_iter, ITER_SOURCE, &pfx_iov, 1, pfx_iov.iov_len);
365 
366 	err = sk_msg_memcopy_from_iter(sk, &pfx_iter, &emsg->skmsg,
367 				       pfx_iov.iov_len);
368 	if (err < 0)
369 		goto fail;
370 
371 	err = sk_msg_memcopy_from_iter(sk, &msg->msg_iter, &emsg->skmsg, size);
372 	if (err < 0)
373 		goto fail;
374 
375 	end = emsg->skmsg.sg.end;
376 	emsg->len = size;
377 	sk_msg_iter_var_prev(end);
378 	sg_mark_end(sk_msg_elem(&emsg->skmsg, end));
379 
380 	tcp_rate_check_app_limited(sk);
381 
382 	err = espintcp_push_msgs(sk, msg->msg_flags & MSG_DONTWAIT);
383 	/* this message could be partially sent, keep it */
384 
385 	release_sock(sk);
386 
387 	return size;
388 
389 fail:
390 	sk_msg_free(sk, &emsg->skmsg);
391 	memset(emsg, 0, sizeof(*emsg));
392 unlock:
393 	release_sock(sk);
394 	return err;
395 }
396 
397 static struct proto espintcp_prot __ro_after_init;
398 static struct proto_ops espintcp_ops __ro_after_init;
399 static struct proto espintcp6_prot;
400 static struct proto_ops espintcp6_ops;
401 static DEFINE_MUTEX(tcpv6_prot_mutex);
402 
espintcp_data_ready(struct sock * sk)403 static void espintcp_data_ready(struct sock *sk)
404 {
405 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
406 
407 	trace_sk_data_ready(sk);
408 
409 	strp_data_ready(&ctx->strp);
410 }
411 
espintcp_tx_work(struct work_struct * work)412 static void espintcp_tx_work(struct work_struct *work)
413 {
414 	struct espintcp_ctx *ctx = container_of(work,
415 						struct espintcp_ctx, work);
416 	struct sock *sk = ctx->strp.sk;
417 
418 	lock_sock(sk);
419 	if (!ctx->tx_running)
420 		espintcp_push_msgs(sk, 0);
421 	release_sock(sk);
422 }
423 
espintcp_write_space(struct sock * sk)424 static void espintcp_write_space(struct sock *sk)
425 {
426 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
427 
428 	schedule_work(&ctx->work);
429 	ctx->saved_write_space(sk);
430 }
431 
espintcp_destruct(struct sock * sk)432 static void espintcp_destruct(struct sock *sk)
433 {
434 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
435 
436 	ctx->saved_destruct(sk);
437 	kfree(ctx);
438 }
439 
tcp_is_ulp_esp(struct sock * sk)440 bool tcp_is_ulp_esp(struct sock *sk)
441 {
442 	return sk->sk_prot == &espintcp_prot || sk->sk_prot == &espintcp6_prot;
443 }
444 EXPORT_SYMBOL_GPL(tcp_is_ulp_esp);
445 
446 static void build_protos(struct proto *espintcp_prot,
447 			 struct proto_ops *espintcp_ops,
448 			 const struct proto *orig_prot,
449 			 const struct proto_ops *orig_ops);
espintcp_init_sk(struct sock * sk)450 static int espintcp_init_sk(struct sock *sk)
451 {
452 	struct inet_connection_sock *icsk = inet_csk(sk);
453 	struct strp_callbacks cb = {
454 		.rcv_msg = espintcp_rcv,
455 		.parse_msg = espintcp_parse,
456 	};
457 	struct espintcp_ctx *ctx;
458 	int err;
459 
460 	/* sockmap is not compatible with espintcp */
461 	if (sk->sk_user_data)
462 		return -EBUSY;
463 
464 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
465 	if (!ctx)
466 		return -ENOMEM;
467 
468 	err = strp_init(&ctx->strp, sk, &cb);
469 	if (err)
470 		goto free;
471 
472 	__sk_dst_reset(sk);
473 
474 	strp_check_rcv(&ctx->strp);
475 	skb_queue_head_init(&ctx->ike_queue);
476 	skb_queue_head_init(&ctx->out_queue);
477 
478 	if (sk->sk_family == AF_INET) {
479 		sk->sk_prot = &espintcp_prot;
480 		sk->sk_socket->ops = &espintcp_ops;
481 	} else {
482 		mutex_lock(&tcpv6_prot_mutex);
483 		if (!espintcp6_prot.recvmsg)
484 			build_protos(&espintcp6_prot, &espintcp6_ops, sk->sk_prot, sk->sk_socket->ops);
485 		mutex_unlock(&tcpv6_prot_mutex);
486 
487 		sk->sk_prot = &espintcp6_prot;
488 		sk->sk_socket->ops = &espintcp6_ops;
489 	}
490 	ctx->saved_data_ready = sk->sk_data_ready;
491 	ctx->saved_write_space = sk->sk_write_space;
492 	ctx->saved_destruct = sk->sk_destruct;
493 	sk->sk_data_ready = espintcp_data_ready;
494 	sk->sk_write_space = espintcp_write_space;
495 	sk->sk_destruct = espintcp_destruct;
496 	rcu_assign_pointer(icsk->icsk_ulp_data, ctx);
497 	INIT_WORK(&ctx->work, espintcp_tx_work);
498 
499 	/* avoid using task_frag */
500 	sk->sk_allocation = GFP_ATOMIC;
501 	sk->sk_use_task_frag = false;
502 
503 	return 0;
504 
505 free:
506 	kfree(ctx);
507 	return err;
508 }
509 
espintcp_release(struct sock * sk)510 static void espintcp_release(struct sock *sk)
511 {
512 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
513 	struct sk_buff_head queue;
514 	struct sk_buff *skb;
515 
516 	__skb_queue_head_init(&queue);
517 	skb_queue_splice_init(&ctx->out_queue, &queue);
518 
519 	while ((skb = __skb_dequeue(&queue)))
520 		espintcp_push_skb(sk, skb);
521 
522 	tcp_release_cb(sk);
523 }
524 
espintcp_close(struct sock * sk,long timeout)525 static void espintcp_close(struct sock *sk, long timeout)
526 {
527 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
528 	struct espintcp_msg *emsg = &ctx->partial;
529 
530 	strp_stop(&ctx->strp);
531 
532 	sk->sk_prot = &tcp_prot;
533 	barrier();
534 
535 	cancel_work_sync(&ctx->work);
536 	strp_done(&ctx->strp);
537 
538 	skb_queue_purge(&ctx->out_queue);
539 	skb_queue_purge(&ctx->ike_queue);
540 
541 	if (emsg->len) {
542 		if (emsg->skb)
543 			kfree_skb(emsg->skb);
544 		else
545 			sk_msg_free(sk, &emsg->skmsg);
546 	}
547 
548 	tcp_close(sk, timeout);
549 }
550 
espintcp_poll(struct file * file,struct socket * sock,poll_table * wait)551 static __poll_t espintcp_poll(struct file *file, struct socket *sock,
552 			      poll_table *wait)
553 {
554 	__poll_t mask = datagram_poll(file, sock, wait);
555 	struct sock *sk = sock->sk;
556 	struct espintcp_ctx *ctx = espintcp_getctx(sk);
557 
558 	if (!skb_queue_empty(&ctx->ike_queue))
559 		mask |= EPOLLIN | EPOLLRDNORM;
560 
561 	return mask;
562 }
563 
build_protos(struct proto * espintcp_prot,struct proto_ops * espintcp_ops,const struct proto * orig_prot,const struct proto_ops * orig_ops)564 static void build_protos(struct proto *espintcp_prot,
565 			 struct proto_ops *espintcp_ops,
566 			 const struct proto *orig_prot,
567 			 const struct proto_ops *orig_ops)
568 {
569 	memcpy(espintcp_prot, orig_prot, sizeof(struct proto));
570 	memcpy(espintcp_ops, orig_ops, sizeof(struct proto_ops));
571 	espintcp_prot->sendmsg = espintcp_sendmsg;
572 	espintcp_prot->recvmsg = espintcp_recvmsg;
573 	espintcp_prot->close = espintcp_close;
574 	espintcp_prot->release_cb = espintcp_release;
575 	espintcp_ops->poll = espintcp_poll;
576 }
577 
578 static struct tcp_ulp_ops espintcp_ulp __read_mostly = {
579 	.name = "espintcp",
580 	.owner = THIS_MODULE,
581 	.init = espintcp_init_sk,
582 };
583 
espintcp_init(void)584 void __init espintcp_init(void)
585 {
586 	build_protos(&espintcp_prot, &espintcp_ops, &tcp_prot, &inet_stream_ops);
587 
588 	tcp_register_ulp(&espintcp_ulp);
589 }
590