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