Merge tag 'spi-fix-v5.13-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/brooni...
[linux-2.6-microblaze.git] / net / xfrm / espintcp.c
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 }