Loading...
1/*
2 * TCP over IPv6
3 * Linux INET6 implementation
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * Based on:
9 * linux/net/ipv4/tcp.c
10 * linux/net/ipv4/tcp_input.c
11 * linux/net/ipv4/tcp_output.c
12 *
13 * Fixes:
14 * Hideaki YOSHIFUJI : sin6_scope_id support
15 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
16 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
17 * a single port at the same time.
18 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
26#include <linux/bottom_half.h>
27#include <linux/module.h>
28#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/socket.h>
31#include <linux/sockios.h>
32#include <linux/net.h>
33#include <linux/jiffies.h>
34#include <linux/in.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/init.h>
38#include <linux/jhash.h>
39#include <linux/ipsec.h>
40#include <linux/times.h>
41#include <linux/slab.h>
42#include <linux/uaccess.h>
43#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
49#include <net/inet6_hashtables.h>
50#include <net/inet6_connection_sock.h>
51#include <net/ipv6.h>
52#include <net/transp_v6.h>
53#include <net/addrconf.h>
54#include <net/ip6_route.h>
55#include <net/ip6_checksum.h>
56#include <net/inet_ecn.h>
57#include <net/protocol.h>
58#include <net/xfrm.h>
59#include <net/snmp.h>
60#include <net/dsfield.h>
61#include <net/timewait_sock.h>
62#include <net/inet_common.h>
63#include <net/secure_seq.h>
64#include <net/busy_poll.h>
65
66#include <linux/proc_fs.h>
67#include <linux/seq_file.h>
68
69#include <crypto/hash.h>
70#include <linux/scatterlist.h>
71
72static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb);
73static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
74 struct request_sock *req);
75
76static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
77
78static const struct inet_connection_sock_af_ops ipv6_mapped;
79static const struct inet_connection_sock_af_ops ipv6_specific;
80#ifdef CONFIG_TCP_MD5SIG
81static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
82static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
83#else
84static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk,
85 const struct in6_addr *addr)
86{
87 return NULL;
88}
89#endif
90
91static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
92{
93 struct dst_entry *dst = skb_dst(skb);
94
95 if (dst && dst_hold_safe(dst)) {
96 const struct rt6_info *rt = (const struct rt6_info *)dst;
97
98 sk->sk_rx_dst = dst;
99 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
100 inet6_sk(sk)->rx_dst_cookie = rt6_get_cookie(rt);
101 }
102}
103
104static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
105{
106 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
107 ipv6_hdr(skb)->saddr.s6_addr32,
108 tcp_hdr(skb)->dest,
109 tcp_hdr(skb)->source);
110}
111
112static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
113 int addr_len)
114{
115 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
116 struct inet_sock *inet = inet_sk(sk);
117 struct inet_connection_sock *icsk = inet_csk(sk);
118 struct ipv6_pinfo *np = inet6_sk(sk);
119 struct tcp_sock *tp = tcp_sk(sk);
120 struct in6_addr *saddr = NULL, *final_p, final;
121 struct ipv6_txoptions *opt;
122 struct flowi6 fl6;
123 struct dst_entry *dst;
124 int addr_type;
125 int err;
126
127 if (addr_len < SIN6_LEN_RFC2133)
128 return -EINVAL;
129
130 if (usin->sin6_family != AF_INET6)
131 return -EAFNOSUPPORT;
132
133 memset(&fl6, 0, sizeof(fl6));
134
135 if (np->sndflow) {
136 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
137 IP6_ECN_flow_init(fl6.flowlabel);
138 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
139 struct ip6_flowlabel *flowlabel;
140 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
141 if (!flowlabel)
142 return -EINVAL;
143 fl6_sock_release(flowlabel);
144 }
145 }
146
147 /*
148 * connect() to INADDR_ANY means loopback (BSD'ism).
149 */
150
151 if (ipv6_addr_any(&usin->sin6_addr))
152 usin->sin6_addr.s6_addr[15] = 0x1;
153
154 addr_type = ipv6_addr_type(&usin->sin6_addr);
155
156 if (addr_type & IPV6_ADDR_MULTICAST)
157 return -ENETUNREACH;
158
159 if (addr_type&IPV6_ADDR_LINKLOCAL) {
160 if (addr_len >= sizeof(struct sockaddr_in6) &&
161 usin->sin6_scope_id) {
162 /* If interface is set while binding, indices
163 * must coincide.
164 */
165 if (sk->sk_bound_dev_if &&
166 sk->sk_bound_dev_if != usin->sin6_scope_id)
167 return -EINVAL;
168
169 sk->sk_bound_dev_if = usin->sin6_scope_id;
170 }
171
172 /* Connect to link-local address requires an interface */
173 if (!sk->sk_bound_dev_if)
174 return -EINVAL;
175 }
176
177 if (tp->rx_opt.ts_recent_stamp &&
178 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
179 tp->rx_opt.ts_recent = 0;
180 tp->rx_opt.ts_recent_stamp = 0;
181 tp->write_seq = 0;
182 }
183
184 sk->sk_v6_daddr = usin->sin6_addr;
185 np->flow_label = fl6.flowlabel;
186
187 /*
188 * TCP over IPv4
189 */
190
191 if (addr_type == IPV6_ADDR_MAPPED) {
192 u32 exthdrlen = icsk->icsk_ext_hdr_len;
193 struct sockaddr_in sin;
194
195 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
196
197 if (__ipv6_only_sock(sk))
198 return -ENETUNREACH;
199
200 sin.sin_family = AF_INET;
201 sin.sin_port = usin->sin6_port;
202 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
203
204 icsk->icsk_af_ops = &ipv6_mapped;
205 sk->sk_backlog_rcv = tcp_v4_do_rcv;
206#ifdef CONFIG_TCP_MD5SIG
207 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
208#endif
209
210 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
211
212 if (err) {
213 icsk->icsk_ext_hdr_len = exthdrlen;
214 icsk->icsk_af_ops = &ipv6_specific;
215 sk->sk_backlog_rcv = tcp_v6_do_rcv;
216#ifdef CONFIG_TCP_MD5SIG
217 tp->af_specific = &tcp_sock_ipv6_specific;
218#endif
219 goto failure;
220 }
221 np->saddr = sk->sk_v6_rcv_saddr;
222
223 return err;
224 }
225
226 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
227 saddr = &sk->sk_v6_rcv_saddr;
228
229 fl6.flowi6_proto = IPPROTO_TCP;
230 fl6.daddr = sk->sk_v6_daddr;
231 fl6.saddr = saddr ? *saddr : np->saddr;
232 fl6.flowi6_oif = sk->sk_bound_dev_if;
233 fl6.flowi6_mark = sk->sk_mark;
234 fl6.fl6_dport = usin->sin6_port;
235 fl6.fl6_sport = inet->inet_sport;
236
237 opt = rcu_dereference_protected(np->opt, sock_owned_by_user(sk));
238 final_p = fl6_update_dst(&fl6, opt, &final);
239
240 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
241
242 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
243 if (IS_ERR(dst)) {
244 err = PTR_ERR(dst);
245 goto failure;
246 }
247
248 if (!saddr) {
249 saddr = &fl6.saddr;
250 sk->sk_v6_rcv_saddr = *saddr;
251 }
252
253 /* set the source address */
254 np->saddr = *saddr;
255 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
256
257 sk->sk_gso_type = SKB_GSO_TCPV6;
258 ip6_dst_store(sk, dst, NULL, NULL);
259
260 if (tcp_death_row.sysctl_tw_recycle &&
261 !tp->rx_opt.ts_recent_stamp &&
262 ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr))
263 tcp_fetch_timewait_stamp(sk, dst);
264
265 icsk->icsk_ext_hdr_len = 0;
266 if (opt)
267 icsk->icsk_ext_hdr_len = opt->opt_flen +
268 opt->opt_nflen;
269
270 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
271
272 inet->inet_dport = usin->sin6_port;
273
274 tcp_set_state(sk, TCP_SYN_SENT);
275 err = inet6_hash_connect(&tcp_death_row, sk);
276 if (err)
277 goto late_failure;
278
279 sk_set_txhash(sk);
280
281 if (!tp->write_seq && likely(!tp->repair))
282 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
283 sk->sk_v6_daddr.s6_addr32,
284 inet->inet_sport,
285 inet->inet_dport);
286
287 err = tcp_connect(sk);
288 if (err)
289 goto late_failure;
290
291 return 0;
292
293late_failure:
294 tcp_set_state(sk, TCP_CLOSE);
295 __sk_dst_reset(sk);
296failure:
297 inet->inet_dport = 0;
298 sk->sk_route_caps = 0;
299 return err;
300}
301
302static void tcp_v6_mtu_reduced(struct sock *sk)
303{
304 struct dst_entry *dst;
305
306 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
307 return;
308
309 dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
310 if (!dst)
311 return;
312
313 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
314 tcp_sync_mss(sk, dst_mtu(dst));
315 tcp_simple_retransmit(sk);
316 }
317}
318
319static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
320 u8 type, u8 code, int offset, __be32 info)
321{
322 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
323 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
324 struct net *net = dev_net(skb->dev);
325 struct request_sock *fastopen;
326 struct ipv6_pinfo *np;
327 struct tcp_sock *tp;
328 __u32 seq, snd_una;
329 struct sock *sk;
330 bool fatal;
331 int err;
332
333 sk = __inet6_lookup_established(net, &tcp_hashinfo,
334 &hdr->daddr, th->dest,
335 &hdr->saddr, ntohs(th->source),
336 skb->dev->ifindex);
337
338 if (!sk) {
339 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
340 ICMP6_MIB_INERRORS);
341 return;
342 }
343
344 if (sk->sk_state == TCP_TIME_WAIT) {
345 inet_twsk_put(inet_twsk(sk));
346 return;
347 }
348 seq = ntohl(th->seq);
349 fatal = icmpv6_err_convert(type, code, &err);
350 if (sk->sk_state == TCP_NEW_SYN_RECV)
351 return tcp_req_err(sk, seq, fatal);
352
353 bh_lock_sock(sk);
354 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
355 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
356
357 if (sk->sk_state == TCP_CLOSE)
358 goto out;
359
360 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
361 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
362 goto out;
363 }
364
365 tp = tcp_sk(sk);
366 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
367 fastopen = tp->fastopen_rsk;
368 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
369 if (sk->sk_state != TCP_LISTEN &&
370 !between(seq, snd_una, tp->snd_nxt)) {
371 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
372 goto out;
373 }
374
375 np = inet6_sk(sk);
376
377 if (type == NDISC_REDIRECT) {
378 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
379
380 if (dst)
381 dst->ops->redirect(dst, sk, skb);
382 goto out;
383 }
384
385 if (type == ICMPV6_PKT_TOOBIG) {
386 /* We are not interested in TCP_LISTEN and open_requests
387 * (SYN-ACKs send out by Linux are always <576bytes so
388 * they should go through unfragmented).
389 */
390 if (sk->sk_state == TCP_LISTEN)
391 goto out;
392
393 if (!ip6_sk_accept_pmtu(sk))
394 goto out;
395
396 tp->mtu_info = ntohl(info);
397 if (!sock_owned_by_user(sk))
398 tcp_v6_mtu_reduced(sk);
399 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
400 &tp->tsq_flags))
401 sock_hold(sk);
402 goto out;
403 }
404
405
406 /* Might be for an request_sock */
407 switch (sk->sk_state) {
408 case TCP_SYN_SENT:
409 case TCP_SYN_RECV:
410 /* Only in fast or simultaneous open. If a fast open socket is
411 * is already accepted it is treated as a connected one below.
412 */
413 if (fastopen && !fastopen->sk)
414 break;
415
416 if (!sock_owned_by_user(sk)) {
417 sk->sk_err = err;
418 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
419
420 tcp_done(sk);
421 } else
422 sk->sk_err_soft = err;
423 goto out;
424 }
425
426 if (!sock_owned_by_user(sk) && np->recverr) {
427 sk->sk_err = err;
428 sk->sk_error_report(sk);
429 } else
430 sk->sk_err_soft = err;
431
432out:
433 bh_unlock_sock(sk);
434 sock_put(sk);
435}
436
437
438static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst,
439 struct flowi *fl,
440 struct request_sock *req,
441 struct tcp_fastopen_cookie *foc,
442 bool attach_req)
443{
444 struct inet_request_sock *ireq = inet_rsk(req);
445 struct ipv6_pinfo *np = inet6_sk(sk);
446 struct flowi6 *fl6 = &fl->u.ip6;
447 struct sk_buff *skb;
448 int err = -ENOMEM;
449
450 /* First, grab a route. */
451 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req,
452 IPPROTO_TCP)) == NULL)
453 goto done;
454
455 skb = tcp_make_synack(sk, dst, req, foc, attach_req);
456
457 if (skb) {
458 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
459 &ireq->ir_v6_rmt_addr);
460
461 fl6->daddr = ireq->ir_v6_rmt_addr;
462 if (np->repflow && ireq->pktopts)
463 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
464
465 rcu_read_lock();
466 err = ip6_xmit(sk, skb, fl6, rcu_dereference(np->opt),
467 np->tclass);
468 rcu_read_unlock();
469 err = net_xmit_eval(err);
470 }
471
472done:
473 return err;
474}
475
476
477static void tcp_v6_reqsk_destructor(struct request_sock *req)
478{
479 kfree_skb(inet_rsk(req)->pktopts);
480}
481
482#ifdef CONFIG_TCP_MD5SIG
483static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk,
484 const struct in6_addr *addr)
485{
486 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
487}
488
489static struct tcp_md5sig_key *tcp_v6_md5_lookup(const struct sock *sk,
490 const struct sock *addr_sk)
491{
492 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
493}
494
495static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
496 int optlen)
497{
498 struct tcp_md5sig cmd;
499 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
500
501 if (optlen < sizeof(cmd))
502 return -EINVAL;
503
504 if (copy_from_user(&cmd, optval, sizeof(cmd)))
505 return -EFAULT;
506
507 if (sin6->sin6_family != AF_INET6)
508 return -EINVAL;
509
510 if (!cmd.tcpm_keylen) {
511 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
512 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
513 AF_INET);
514 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
515 AF_INET6);
516 }
517
518 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
519 return -EINVAL;
520
521 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
522 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
523 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
524
525 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
526 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
527}
528
529static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
530 const struct in6_addr *daddr,
531 const struct in6_addr *saddr, int nbytes)
532{
533 struct tcp6_pseudohdr *bp;
534 struct scatterlist sg;
535
536 bp = &hp->md5_blk.ip6;
537 /* 1. TCP pseudo-header (RFC2460) */
538 bp->saddr = *saddr;
539 bp->daddr = *daddr;
540 bp->protocol = cpu_to_be32(IPPROTO_TCP);
541 bp->len = cpu_to_be32(nbytes);
542
543 sg_init_one(&sg, bp, sizeof(*bp));
544 ahash_request_set_crypt(hp->md5_req, &sg, NULL, sizeof(*bp));
545 return crypto_ahash_update(hp->md5_req);
546}
547
548static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
549 const struct in6_addr *daddr, struct in6_addr *saddr,
550 const struct tcphdr *th)
551{
552 struct tcp_md5sig_pool *hp;
553 struct ahash_request *req;
554
555 hp = tcp_get_md5sig_pool();
556 if (!hp)
557 goto clear_hash_noput;
558 req = hp->md5_req;
559
560 if (crypto_ahash_init(req))
561 goto clear_hash;
562 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
563 goto clear_hash;
564 if (tcp_md5_hash_header(hp, th))
565 goto clear_hash;
566 if (tcp_md5_hash_key(hp, key))
567 goto clear_hash;
568 ahash_request_set_crypt(req, NULL, md5_hash, 0);
569 if (crypto_ahash_final(req))
570 goto clear_hash;
571
572 tcp_put_md5sig_pool();
573 return 0;
574
575clear_hash:
576 tcp_put_md5sig_pool();
577clear_hash_noput:
578 memset(md5_hash, 0, 16);
579 return 1;
580}
581
582static int tcp_v6_md5_hash_skb(char *md5_hash,
583 const struct tcp_md5sig_key *key,
584 const struct sock *sk,
585 const struct sk_buff *skb)
586{
587 const struct in6_addr *saddr, *daddr;
588 struct tcp_md5sig_pool *hp;
589 struct ahash_request *req;
590 const struct tcphdr *th = tcp_hdr(skb);
591
592 if (sk) { /* valid for establish/request sockets */
593 saddr = &sk->sk_v6_rcv_saddr;
594 daddr = &sk->sk_v6_daddr;
595 } else {
596 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
597 saddr = &ip6h->saddr;
598 daddr = &ip6h->daddr;
599 }
600
601 hp = tcp_get_md5sig_pool();
602 if (!hp)
603 goto clear_hash_noput;
604 req = hp->md5_req;
605
606 if (crypto_ahash_init(req))
607 goto clear_hash;
608
609 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
610 goto clear_hash;
611 if (tcp_md5_hash_header(hp, th))
612 goto clear_hash;
613 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
614 goto clear_hash;
615 if (tcp_md5_hash_key(hp, key))
616 goto clear_hash;
617 ahash_request_set_crypt(req, NULL, md5_hash, 0);
618 if (crypto_ahash_final(req))
619 goto clear_hash;
620
621 tcp_put_md5sig_pool();
622 return 0;
623
624clear_hash:
625 tcp_put_md5sig_pool();
626clear_hash_noput:
627 memset(md5_hash, 0, 16);
628 return 1;
629}
630
631#endif
632
633static bool tcp_v6_inbound_md5_hash(const struct sock *sk,
634 const struct sk_buff *skb)
635{
636#ifdef CONFIG_TCP_MD5SIG
637 const __u8 *hash_location = NULL;
638 struct tcp_md5sig_key *hash_expected;
639 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
640 const struct tcphdr *th = tcp_hdr(skb);
641 int genhash;
642 u8 newhash[16];
643
644 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
645 hash_location = tcp_parse_md5sig_option(th);
646
647 /* We've parsed the options - do we have a hash? */
648 if (!hash_expected && !hash_location)
649 return false;
650
651 if (hash_expected && !hash_location) {
652 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
653 return true;
654 }
655
656 if (!hash_expected && hash_location) {
657 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
658 return true;
659 }
660
661 /* check the signature */
662 genhash = tcp_v6_md5_hash_skb(newhash,
663 hash_expected,
664 NULL, skb);
665
666 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
667 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
668 genhash ? "failed" : "mismatch",
669 &ip6h->saddr, ntohs(th->source),
670 &ip6h->daddr, ntohs(th->dest));
671 return true;
672 }
673#endif
674 return false;
675}
676
677static void tcp_v6_init_req(struct request_sock *req,
678 const struct sock *sk_listener,
679 struct sk_buff *skb)
680{
681 struct inet_request_sock *ireq = inet_rsk(req);
682 const struct ipv6_pinfo *np = inet6_sk(sk_listener);
683
684 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
685 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
686
687 /* So that link locals have meaning */
688 if (!sk_listener->sk_bound_dev_if &&
689 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
690 ireq->ir_iif = tcp_v6_iif(skb);
691
692 if (!TCP_SKB_CB(skb)->tcp_tw_isn &&
693 (ipv6_opt_accepted(sk_listener, skb, &TCP_SKB_CB(skb)->header.h6) ||
694 np->rxopt.bits.rxinfo ||
695 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
696 np->rxopt.bits.rxohlim || np->repflow)) {
697 atomic_inc(&skb->users);
698 ireq->pktopts = skb;
699 }
700}
701
702static struct dst_entry *tcp_v6_route_req(const struct sock *sk,
703 struct flowi *fl,
704 const struct request_sock *req,
705 bool *strict)
706{
707 if (strict)
708 *strict = true;
709 return inet6_csk_route_req(sk, &fl->u.ip6, req, IPPROTO_TCP);
710}
711
712struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
713 .family = AF_INET6,
714 .obj_size = sizeof(struct tcp6_request_sock),
715 .rtx_syn_ack = tcp_rtx_synack,
716 .send_ack = tcp_v6_reqsk_send_ack,
717 .destructor = tcp_v6_reqsk_destructor,
718 .send_reset = tcp_v6_send_reset,
719 .syn_ack_timeout = tcp_syn_ack_timeout,
720};
721
722static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
723 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) -
724 sizeof(struct ipv6hdr),
725#ifdef CONFIG_TCP_MD5SIG
726 .req_md5_lookup = tcp_v6_md5_lookup,
727 .calc_md5_hash = tcp_v6_md5_hash_skb,
728#endif
729 .init_req = tcp_v6_init_req,
730#ifdef CONFIG_SYN_COOKIES
731 .cookie_init_seq = cookie_v6_init_sequence,
732#endif
733 .route_req = tcp_v6_route_req,
734 .init_seq = tcp_v6_init_sequence,
735 .send_synack = tcp_v6_send_synack,
736};
737
738static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 seq,
739 u32 ack, u32 win, u32 tsval, u32 tsecr,
740 int oif, struct tcp_md5sig_key *key, int rst,
741 u8 tclass, u32 label)
742{
743 const struct tcphdr *th = tcp_hdr(skb);
744 struct tcphdr *t1;
745 struct sk_buff *buff;
746 struct flowi6 fl6;
747 struct net *net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
748 struct sock *ctl_sk = net->ipv6.tcp_sk;
749 unsigned int tot_len = sizeof(struct tcphdr);
750 struct dst_entry *dst;
751 __be32 *topt;
752
753 if (tsecr)
754 tot_len += TCPOLEN_TSTAMP_ALIGNED;
755#ifdef CONFIG_TCP_MD5SIG
756 if (key)
757 tot_len += TCPOLEN_MD5SIG_ALIGNED;
758#endif
759
760 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
761 GFP_ATOMIC);
762 if (!buff)
763 return;
764
765 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
766
767 t1 = (struct tcphdr *) skb_push(buff, tot_len);
768 skb_reset_transport_header(buff);
769
770 /* Swap the send and the receive. */
771 memset(t1, 0, sizeof(*t1));
772 t1->dest = th->source;
773 t1->source = th->dest;
774 t1->doff = tot_len / 4;
775 t1->seq = htonl(seq);
776 t1->ack_seq = htonl(ack);
777 t1->ack = !rst || !th->ack;
778 t1->rst = rst;
779 t1->window = htons(win);
780
781 topt = (__be32 *)(t1 + 1);
782
783 if (tsecr) {
784 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
785 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
786 *topt++ = htonl(tsval);
787 *topt++ = htonl(tsecr);
788 }
789
790#ifdef CONFIG_TCP_MD5SIG
791 if (key) {
792 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
793 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
794 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
795 &ipv6_hdr(skb)->saddr,
796 &ipv6_hdr(skb)->daddr, t1);
797 }
798#endif
799
800 memset(&fl6, 0, sizeof(fl6));
801 fl6.daddr = ipv6_hdr(skb)->saddr;
802 fl6.saddr = ipv6_hdr(skb)->daddr;
803 fl6.flowlabel = label;
804
805 buff->ip_summed = CHECKSUM_PARTIAL;
806 buff->csum = 0;
807
808 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
809
810 fl6.flowi6_proto = IPPROTO_TCP;
811 if (rt6_need_strict(&fl6.daddr) && !oif)
812 fl6.flowi6_oif = tcp_v6_iif(skb);
813 else {
814 if (!oif && netif_index_is_l3_master(net, skb->skb_iif))
815 oif = skb->skb_iif;
816
817 fl6.flowi6_oif = oif;
818 }
819
820 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
821 fl6.fl6_dport = t1->dest;
822 fl6.fl6_sport = t1->source;
823 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
824
825 /* Pass a socket to ip6_dst_lookup either it is for RST
826 * Underlying function will use this to retrieve the network
827 * namespace
828 */
829 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
830 if (!IS_ERR(dst)) {
831 skb_dst_set(buff, dst);
832 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
833 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
834 if (rst)
835 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
836 return;
837 }
838
839 kfree_skb(buff);
840}
841
842static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb)
843{
844 const struct tcphdr *th = tcp_hdr(skb);
845 u32 seq = 0, ack_seq = 0;
846 struct tcp_md5sig_key *key = NULL;
847#ifdef CONFIG_TCP_MD5SIG
848 const __u8 *hash_location = NULL;
849 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
850 unsigned char newhash[16];
851 int genhash;
852 struct sock *sk1 = NULL;
853#endif
854 int oif;
855
856 if (th->rst)
857 return;
858
859 /* If sk not NULL, it means we did a successful lookup and incoming
860 * route had to be correct. prequeue might have dropped our dst.
861 */
862 if (!sk && !ipv6_unicast_destination(skb))
863 return;
864
865#ifdef CONFIG_TCP_MD5SIG
866 hash_location = tcp_parse_md5sig_option(th);
867 if (sk && sk_fullsock(sk)) {
868 key = tcp_v6_md5_do_lookup(sk, &ipv6h->saddr);
869 } else if (hash_location) {
870 /*
871 * active side is lost. Try to find listening socket through
872 * source port, and then find md5 key through listening socket.
873 * we are not loose security here:
874 * Incoming packet is checked with md5 hash with finding key,
875 * no RST generated if md5 hash doesn't match.
876 */
877 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
878 &tcp_hashinfo, NULL, 0,
879 &ipv6h->saddr,
880 th->source, &ipv6h->daddr,
881 ntohs(th->source), tcp_v6_iif(skb));
882 if (!sk1)
883 return;
884
885 rcu_read_lock();
886 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
887 if (!key)
888 goto release_sk1;
889
890 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, skb);
891 if (genhash || memcmp(hash_location, newhash, 16) != 0)
892 goto release_sk1;
893 }
894#endif
895
896 if (th->ack)
897 seq = ntohl(th->ack_seq);
898 else
899 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
900 (th->doff << 2);
901
902 oif = sk ? sk->sk_bound_dev_if : 0;
903 tcp_v6_send_response(sk, skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
904
905#ifdef CONFIG_TCP_MD5SIG
906release_sk1:
907 if (sk1) {
908 rcu_read_unlock();
909 sock_put(sk1);
910 }
911#endif
912}
913
914static void tcp_v6_send_ack(const struct sock *sk, struct sk_buff *skb, u32 seq,
915 u32 ack, u32 win, u32 tsval, u32 tsecr, int oif,
916 struct tcp_md5sig_key *key, u8 tclass,
917 u32 label)
918{
919 tcp_v6_send_response(sk, skb, seq, ack, win, tsval, tsecr, oif, key, 0,
920 tclass, label);
921}
922
923static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
924{
925 struct inet_timewait_sock *tw = inet_twsk(sk);
926 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
927
928 tcp_v6_send_ack(sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
929 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
930 tcp_time_stamp + tcptw->tw_ts_offset,
931 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
932 tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel));
933
934 inet_twsk_put(tw);
935}
936
937static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
938 struct request_sock *req)
939{
940 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
941 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
942 */
943 tcp_v6_send_ack(sk, skb, (sk->sk_state == TCP_LISTEN) ?
944 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
945 tcp_rsk(req)->rcv_nxt, req->rsk_rcv_wnd,
946 tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
947 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
948 0, 0);
949}
950
951
952static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb)
953{
954#ifdef CONFIG_SYN_COOKIES
955 const struct tcphdr *th = tcp_hdr(skb);
956
957 if (!th->syn)
958 sk = cookie_v6_check(sk, skb);
959#endif
960 return sk;
961}
962
963static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
964{
965 if (skb->protocol == htons(ETH_P_IP))
966 return tcp_v4_conn_request(sk, skb);
967
968 if (!ipv6_unicast_destination(skb))
969 goto drop;
970
971 return tcp_conn_request(&tcp6_request_sock_ops,
972 &tcp_request_sock_ipv6_ops, sk, skb);
973
974drop:
975 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
976 return 0; /* don't send reset */
977}
978
979static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
980 struct request_sock *req,
981 struct dst_entry *dst,
982 struct request_sock *req_unhash,
983 bool *own_req)
984{
985 struct inet_request_sock *ireq;
986 struct ipv6_pinfo *newnp;
987 const struct ipv6_pinfo *np = inet6_sk(sk);
988 struct ipv6_txoptions *opt;
989 struct tcp6_sock *newtcp6sk;
990 struct inet_sock *newinet;
991 struct tcp_sock *newtp;
992 struct sock *newsk;
993#ifdef CONFIG_TCP_MD5SIG
994 struct tcp_md5sig_key *key;
995#endif
996 struct flowi6 fl6;
997
998 if (skb->protocol == htons(ETH_P_IP)) {
999 /*
1000 * v6 mapped
1001 */
1002
1003 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst,
1004 req_unhash, own_req);
1005
1006 if (!newsk)
1007 return NULL;
1008
1009 newtcp6sk = (struct tcp6_sock *)newsk;
1010 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1011
1012 newinet = inet_sk(newsk);
1013 newnp = inet6_sk(newsk);
1014 newtp = tcp_sk(newsk);
1015
1016 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1017
1018 newnp->saddr = newsk->sk_v6_rcv_saddr;
1019
1020 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1021 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1022#ifdef CONFIG_TCP_MD5SIG
1023 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1024#endif
1025
1026 newnp->ipv6_ac_list = NULL;
1027 newnp->ipv6_fl_list = NULL;
1028 newnp->pktoptions = NULL;
1029 newnp->opt = NULL;
1030 newnp->mcast_oif = tcp_v6_iif(skb);
1031 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1032 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
1033 if (np->repflow)
1034 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
1035
1036 /*
1037 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1038 * here, tcp_create_openreq_child now does this for us, see the comment in
1039 * that function for the gory details. -acme
1040 */
1041
1042 /* It is tricky place. Until this moment IPv4 tcp
1043 worked with IPv6 icsk.icsk_af_ops.
1044 Sync it now.
1045 */
1046 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1047
1048 return newsk;
1049 }
1050
1051 ireq = inet_rsk(req);
1052
1053 if (sk_acceptq_is_full(sk))
1054 goto out_overflow;
1055
1056 if (!dst) {
1057 dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_TCP);
1058 if (!dst)
1059 goto out;
1060 }
1061
1062 newsk = tcp_create_openreq_child(sk, req, skb);
1063 if (!newsk)
1064 goto out_nonewsk;
1065
1066 /*
1067 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1068 * count here, tcp_create_openreq_child now does this for us, see the
1069 * comment in that function for the gory details. -acme
1070 */
1071
1072 newsk->sk_gso_type = SKB_GSO_TCPV6;
1073 ip6_dst_store(newsk, dst, NULL, NULL);
1074 inet6_sk_rx_dst_set(newsk, skb);
1075
1076 newtcp6sk = (struct tcp6_sock *)newsk;
1077 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1078
1079 newtp = tcp_sk(newsk);
1080 newinet = inet_sk(newsk);
1081 newnp = inet6_sk(newsk);
1082
1083 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1084
1085 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1086 newnp->saddr = ireq->ir_v6_loc_addr;
1087 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1088 newsk->sk_bound_dev_if = ireq->ir_iif;
1089
1090 /* Now IPv6 options...
1091
1092 First: no IPv4 options.
1093 */
1094 newinet->inet_opt = NULL;
1095 newnp->ipv6_ac_list = NULL;
1096 newnp->ipv6_fl_list = NULL;
1097
1098 /* Clone RX bits */
1099 newnp->rxopt.all = np->rxopt.all;
1100
1101 newnp->pktoptions = NULL;
1102 newnp->opt = NULL;
1103 newnp->mcast_oif = tcp_v6_iif(skb);
1104 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1105 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
1106 if (np->repflow)
1107 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
1108
1109 /* Clone native IPv6 options from listening socket (if any)
1110
1111 Yes, keeping reference count would be much more clever,
1112 but we make one more one thing there: reattach optmem
1113 to newsk.
1114 */
1115 opt = rcu_dereference(np->opt);
1116 if (opt) {
1117 opt = ipv6_dup_options(newsk, opt);
1118 RCU_INIT_POINTER(newnp->opt, opt);
1119 }
1120 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1121 if (opt)
1122 inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +
1123 opt->opt_flen;
1124
1125 tcp_ca_openreq_child(newsk, dst);
1126
1127 tcp_sync_mss(newsk, dst_mtu(dst));
1128 newtp->advmss = dst_metric_advmss(dst);
1129 if (tcp_sk(sk)->rx_opt.user_mss &&
1130 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1131 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1132
1133 tcp_initialize_rcv_mss(newsk);
1134
1135 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1136 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
1137
1138#ifdef CONFIG_TCP_MD5SIG
1139 /* Copy over the MD5 key from the original socket */
1140 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
1141 if (key) {
1142 /* We're using one, so create a matching key
1143 * on the newsk structure. If we fail to get
1144 * memory, then we end up not copying the key
1145 * across. Shucks.
1146 */
1147 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
1148 AF_INET6, key->key, key->keylen,
1149 sk_gfp_mask(sk, GFP_ATOMIC));
1150 }
1151#endif
1152
1153 if (__inet_inherit_port(sk, newsk) < 0) {
1154 inet_csk_prepare_forced_close(newsk);
1155 tcp_done(newsk);
1156 goto out;
1157 }
1158 *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash));
1159 if (*own_req) {
1160 tcp_move_syn(newtp, req);
1161
1162 /* Clone pktoptions received with SYN, if we own the req */
1163 if (ireq->pktopts) {
1164 newnp->pktoptions = skb_clone(ireq->pktopts,
1165 sk_gfp_mask(sk, GFP_ATOMIC));
1166 consume_skb(ireq->pktopts);
1167 ireq->pktopts = NULL;
1168 if (newnp->pktoptions)
1169 skb_set_owner_r(newnp->pktoptions, newsk);
1170 }
1171 }
1172
1173 return newsk;
1174
1175out_overflow:
1176 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1177out_nonewsk:
1178 dst_release(dst);
1179out:
1180 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1181 return NULL;
1182}
1183
1184/* The socket must have it's spinlock held when we get
1185 * here, unless it is a TCP_LISTEN socket.
1186 *
1187 * We have a potential double-lock case here, so even when
1188 * doing backlog processing we use the BH locking scheme.
1189 * This is because we cannot sleep with the original spinlock
1190 * held.
1191 */
1192static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1193{
1194 struct ipv6_pinfo *np = inet6_sk(sk);
1195 struct tcp_sock *tp;
1196 struct sk_buff *opt_skb = NULL;
1197
1198 /* Imagine: socket is IPv6. IPv4 packet arrives,
1199 goes to IPv4 receive handler and backlogged.
1200 From backlog it always goes here. Kerboom...
1201 Fortunately, tcp_rcv_established and rcv_established
1202 handle them correctly, but it is not case with
1203 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1204 */
1205
1206 if (skb->protocol == htons(ETH_P_IP))
1207 return tcp_v4_do_rcv(sk, skb);
1208
1209 if (sk_filter(sk, skb))
1210 goto discard;
1211
1212 /*
1213 * socket locking is here for SMP purposes as backlog rcv
1214 * is currently called with bh processing disabled.
1215 */
1216
1217 /* Do Stevens' IPV6_PKTOPTIONS.
1218
1219 Yes, guys, it is the only place in our code, where we
1220 may make it not affecting IPv4.
1221 The rest of code is protocol independent,
1222 and I do not like idea to uglify IPv4.
1223
1224 Actually, all the idea behind IPV6_PKTOPTIONS
1225 looks not very well thought. For now we latch
1226 options, received in the last packet, enqueued
1227 by tcp. Feel free to propose better solution.
1228 --ANK (980728)
1229 */
1230 if (np->rxopt.all)
1231 opt_skb = skb_clone(skb, sk_gfp_mask(sk, GFP_ATOMIC));
1232
1233 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1234 struct dst_entry *dst = sk->sk_rx_dst;
1235
1236 sock_rps_save_rxhash(sk, skb);
1237 sk_mark_napi_id(sk, skb);
1238 if (dst) {
1239 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1240 dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1241 dst_release(dst);
1242 sk->sk_rx_dst = NULL;
1243 }
1244 }
1245
1246 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
1247 if (opt_skb)
1248 goto ipv6_pktoptions;
1249 return 0;
1250 }
1251
1252 if (tcp_checksum_complete(skb))
1253 goto csum_err;
1254
1255 if (sk->sk_state == TCP_LISTEN) {
1256 struct sock *nsk = tcp_v6_cookie_check(sk, skb);
1257
1258 if (!nsk)
1259 goto discard;
1260
1261 if (nsk != sk) {
1262 sock_rps_save_rxhash(nsk, skb);
1263 sk_mark_napi_id(nsk, skb);
1264 if (tcp_child_process(sk, nsk, skb))
1265 goto reset;
1266 if (opt_skb)
1267 __kfree_skb(opt_skb);
1268 return 0;
1269 }
1270 } else
1271 sock_rps_save_rxhash(sk, skb);
1272
1273 if (tcp_rcv_state_process(sk, skb))
1274 goto reset;
1275 if (opt_skb)
1276 goto ipv6_pktoptions;
1277 return 0;
1278
1279reset:
1280 tcp_v6_send_reset(sk, skb);
1281discard:
1282 if (opt_skb)
1283 __kfree_skb(opt_skb);
1284 kfree_skb(skb);
1285 return 0;
1286csum_err:
1287 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
1288 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
1289 goto discard;
1290
1291
1292ipv6_pktoptions:
1293 /* Do you ask, what is it?
1294
1295 1. skb was enqueued by tcp.
1296 2. skb is added to tail of read queue, rather than out of order.
1297 3. socket is not in passive state.
1298 4. Finally, it really contains options, which user wants to receive.
1299 */
1300 tp = tcp_sk(sk);
1301 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1302 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1303 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
1304 np->mcast_oif = tcp_v6_iif(opt_skb);
1305 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1306 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1307 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
1308 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
1309 if (np->repflow)
1310 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
1311 if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) {
1312 skb_set_owner_r(opt_skb, sk);
1313 opt_skb = xchg(&np->pktoptions, opt_skb);
1314 } else {
1315 __kfree_skb(opt_skb);
1316 opt_skb = xchg(&np->pktoptions, NULL);
1317 }
1318 }
1319
1320 kfree_skb(opt_skb);
1321 return 0;
1322}
1323
1324static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr,
1325 const struct tcphdr *th)
1326{
1327 /* This is tricky: we move IP6CB at its correct location into
1328 * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because
1329 * _decode_session6() uses IP6CB().
1330 * barrier() makes sure compiler won't play aliasing games.
1331 */
1332 memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
1333 sizeof(struct inet6_skb_parm));
1334 barrier();
1335
1336 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1337 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1338 skb->len - th->doff*4);
1339 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1340 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
1341 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
1342 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
1343 TCP_SKB_CB(skb)->sacked = 0;
1344}
1345
1346static void tcp_v6_restore_cb(struct sk_buff *skb)
1347{
1348 /* We need to move header back to the beginning if xfrm6_policy_check()
1349 * and tcp_v6_fill_cb() are going to be called again.
1350 */
1351 memmove(IP6CB(skb), &TCP_SKB_CB(skb)->header.h6,
1352 sizeof(struct inet6_skb_parm));
1353}
1354
1355static int tcp_v6_rcv(struct sk_buff *skb)
1356{
1357 const struct tcphdr *th;
1358 const struct ipv6hdr *hdr;
1359 struct sock *sk;
1360 int ret;
1361 struct net *net = dev_net(skb->dev);
1362
1363 if (skb->pkt_type != PACKET_HOST)
1364 goto discard_it;
1365
1366 /*
1367 * Count it even if it's bad.
1368 */
1369 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
1370
1371 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1372 goto discard_it;
1373
1374 th = tcp_hdr(skb);
1375
1376 if (th->doff < sizeof(struct tcphdr)/4)
1377 goto bad_packet;
1378 if (!pskb_may_pull(skb, th->doff*4))
1379 goto discard_it;
1380
1381 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
1382 goto csum_error;
1383
1384 th = tcp_hdr(skb);
1385 hdr = ipv6_hdr(skb);
1386
1387lookup:
1388 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th),
1389 th->source, th->dest, inet6_iif(skb));
1390 if (!sk)
1391 goto no_tcp_socket;
1392
1393process:
1394 if (sk->sk_state == TCP_TIME_WAIT)
1395 goto do_time_wait;
1396
1397 if (sk->sk_state == TCP_NEW_SYN_RECV) {
1398 struct request_sock *req = inet_reqsk(sk);
1399 struct sock *nsk;
1400
1401 sk = req->rsk_listener;
1402 tcp_v6_fill_cb(skb, hdr, th);
1403 if (tcp_v6_inbound_md5_hash(sk, skb)) {
1404 reqsk_put(req);
1405 goto discard_it;
1406 }
1407 if (unlikely(sk->sk_state != TCP_LISTEN)) {
1408 inet_csk_reqsk_queue_drop_and_put(sk, req);
1409 goto lookup;
1410 }
1411 sock_hold(sk);
1412 nsk = tcp_check_req(sk, skb, req, false);
1413 if (!nsk) {
1414 reqsk_put(req);
1415 goto discard_and_relse;
1416 }
1417 if (nsk == sk) {
1418 reqsk_put(req);
1419 tcp_v6_restore_cb(skb);
1420 } else if (tcp_child_process(sk, nsk, skb)) {
1421 tcp_v6_send_reset(nsk, skb);
1422 goto discard_and_relse;
1423 } else {
1424 sock_put(sk);
1425 return 0;
1426 }
1427 }
1428 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1429 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1430 goto discard_and_relse;
1431 }
1432
1433 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1434 goto discard_and_relse;
1435
1436 tcp_v6_fill_cb(skb, hdr, th);
1437
1438 if (tcp_v6_inbound_md5_hash(sk, skb))
1439 goto discard_and_relse;
1440
1441 if (sk_filter(sk, skb))
1442 goto discard_and_relse;
1443
1444 skb->dev = NULL;
1445
1446 if (sk->sk_state == TCP_LISTEN) {
1447 ret = tcp_v6_do_rcv(sk, skb);
1448 goto put_and_return;
1449 }
1450
1451 sk_incoming_cpu_update(sk);
1452
1453 bh_lock_sock_nested(sk);
1454 tcp_segs_in(tcp_sk(sk), skb);
1455 ret = 0;
1456 if (!sock_owned_by_user(sk)) {
1457 if (!tcp_prequeue(sk, skb))
1458 ret = tcp_v6_do_rcv(sk, skb);
1459 } else if (unlikely(sk_add_backlog(sk, skb,
1460 sk->sk_rcvbuf + sk->sk_sndbuf))) {
1461 bh_unlock_sock(sk);
1462 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
1463 goto discard_and_relse;
1464 }
1465 bh_unlock_sock(sk);
1466
1467put_and_return:
1468 sock_put(sk);
1469 return ret ? -1 : 0;
1470
1471no_tcp_socket:
1472 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1473 goto discard_it;
1474
1475 tcp_v6_fill_cb(skb, hdr, th);
1476
1477 if (tcp_checksum_complete(skb)) {
1478csum_error:
1479 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
1480bad_packet:
1481 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1482 } else {
1483 tcp_v6_send_reset(NULL, skb);
1484 }
1485
1486discard_it:
1487 kfree_skb(skb);
1488 return 0;
1489
1490discard_and_relse:
1491 sock_put(sk);
1492 goto discard_it;
1493
1494do_time_wait:
1495 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1496 inet_twsk_put(inet_twsk(sk));
1497 goto discard_it;
1498 }
1499
1500 tcp_v6_fill_cb(skb, hdr, th);
1501
1502 if (tcp_checksum_complete(skb)) {
1503 inet_twsk_put(inet_twsk(sk));
1504 goto csum_error;
1505 }
1506
1507 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1508 case TCP_TW_SYN:
1509 {
1510 struct sock *sk2;
1511
1512 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
1513 skb, __tcp_hdrlen(th),
1514 &ipv6_hdr(skb)->saddr, th->source,
1515 &ipv6_hdr(skb)->daddr,
1516 ntohs(th->dest), tcp_v6_iif(skb));
1517 if (sk2) {
1518 struct inet_timewait_sock *tw = inet_twsk(sk);
1519 inet_twsk_deschedule_put(tw);
1520 sk = sk2;
1521 tcp_v6_restore_cb(skb);
1522 goto process;
1523 }
1524 /* Fall through to ACK */
1525 }
1526 case TCP_TW_ACK:
1527 tcp_v6_timewait_ack(sk, skb);
1528 break;
1529 case TCP_TW_RST:
1530 tcp_v6_restore_cb(skb);
1531 tcp_v6_send_reset(sk, skb);
1532 inet_twsk_deschedule_put(inet_twsk(sk));
1533 goto discard_it;
1534 case TCP_TW_SUCCESS:
1535 ;
1536 }
1537 goto discard_it;
1538}
1539
1540static void tcp_v6_early_demux(struct sk_buff *skb)
1541{
1542 const struct ipv6hdr *hdr;
1543 const struct tcphdr *th;
1544 struct sock *sk;
1545
1546 if (skb->pkt_type != PACKET_HOST)
1547 return;
1548
1549 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1550 return;
1551
1552 hdr = ipv6_hdr(skb);
1553 th = tcp_hdr(skb);
1554
1555 if (th->doff < sizeof(struct tcphdr) / 4)
1556 return;
1557
1558 /* Note : We use inet6_iif() here, not tcp_v6_iif() */
1559 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1560 &hdr->saddr, th->source,
1561 &hdr->daddr, ntohs(th->dest),
1562 inet6_iif(skb));
1563 if (sk) {
1564 skb->sk = sk;
1565 skb->destructor = sock_edemux;
1566 if (sk_fullsock(sk)) {
1567 struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst);
1568
1569 if (dst)
1570 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
1571 if (dst &&
1572 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
1573 skb_dst_set_noref(skb, dst);
1574 }
1575 }
1576}
1577
1578static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1579 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1580 .twsk_unique = tcp_twsk_unique,
1581 .twsk_destructor = tcp_twsk_destructor,
1582};
1583
1584static const struct inet_connection_sock_af_ops ipv6_specific = {
1585 .queue_xmit = inet6_csk_xmit,
1586 .send_check = tcp_v6_send_check,
1587 .rebuild_header = inet6_sk_rebuild_header,
1588 .sk_rx_dst_set = inet6_sk_rx_dst_set,
1589 .conn_request = tcp_v6_conn_request,
1590 .syn_recv_sock = tcp_v6_syn_recv_sock,
1591 .net_header_len = sizeof(struct ipv6hdr),
1592 .net_frag_header_len = sizeof(struct frag_hdr),
1593 .setsockopt = ipv6_setsockopt,
1594 .getsockopt = ipv6_getsockopt,
1595 .addr2sockaddr = inet6_csk_addr2sockaddr,
1596 .sockaddr_len = sizeof(struct sockaddr_in6),
1597 .bind_conflict = inet6_csk_bind_conflict,
1598#ifdef CONFIG_COMPAT
1599 .compat_setsockopt = compat_ipv6_setsockopt,
1600 .compat_getsockopt = compat_ipv6_getsockopt,
1601#endif
1602 .mtu_reduced = tcp_v6_mtu_reduced,
1603};
1604
1605#ifdef CONFIG_TCP_MD5SIG
1606static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
1607 .md5_lookup = tcp_v6_md5_lookup,
1608 .calc_md5_hash = tcp_v6_md5_hash_skb,
1609 .md5_parse = tcp_v6_parse_md5_keys,
1610};
1611#endif
1612
1613/*
1614 * TCP over IPv4 via INET6 API
1615 */
1616static const struct inet_connection_sock_af_ops ipv6_mapped = {
1617 .queue_xmit = ip_queue_xmit,
1618 .send_check = tcp_v4_send_check,
1619 .rebuild_header = inet_sk_rebuild_header,
1620 .sk_rx_dst_set = inet_sk_rx_dst_set,
1621 .conn_request = tcp_v6_conn_request,
1622 .syn_recv_sock = tcp_v6_syn_recv_sock,
1623 .net_header_len = sizeof(struct iphdr),
1624 .setsockopt = ipv6_setsockopt,
1625 .getsockopt = ipv6_getsockopt,
1626 .addr2sockaddr = inet6_csk_addr2sockaddr,
1627 .sockaddr_len = sizeof(struct sockaddr_in6),
1628 .bind_conflict = inet6_csk_bind_conflict,
1629#ifdef CONFIG_COMPAT
1630 .compat_setsockopt = compat_ipv6_setsockopt,
1631 .compat_getsockopt = compat_ipv6_getsockopt,
1632#endif
1633 .mtu_reduced = tcp_v4_mtu_reduced,
1634};
1635
1636#ifdef CONFIG_TCP_MD5SIG
1637static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
1638 .md5_lookup = tcp_v4_md5_lookup,
1639 .calc_md5_hash = tcp_v4_md5_hash_skb,
1640 .md5_parse = tcp_v6_parse_md5_keys,
1641};
1642#endif
1643
1644/* NOTE: A lot of things set to zero explicitly by call to
1645 * sk_alloc() so need not be done here.
1646 */
1647static int tcp_v6_init_sock(struct sock *sk)
1648{
1649 struct inet_connection_sock *icsk = inet_csk(sk);
1650
1651 tcp_init_sock(sk);
1652
1653 icsk->icsk_af_ops = &ipv6_specific;
1654
1655#ifdef CONFIG_TCP_MD5SIG
1656 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
1657#endif
1658
1659 return 0;
1660}
1661
1662static void tcp_v6_destroy_sock(struct sock *sk)
1663{
1664 tcp_v4_destroy_sock(sk);
1665 inet6_destroy_sock(sk);
1666}
1667
1668#ifdef CONFIG_PROC_FS
1669/* Proc filesystem TCPv6 sock list dumping. */
1670static void get_openreq6(struct seq_file *seq,
1671 const struct request_sock *req, int i)
1672{
1673 long ttd = req->rsk_timer.expires - jiffies;
1674 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1675 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
1676
1677 if (ttd < 0)
1678 ttd = 0;
1679
1680 seq_printf(seq,
1681 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1682 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
1683 i,
1684 src->s6_addr32[0], src->s6_addr32[1],
1685 src->s6_addr32[2], src->s6_addr32[3],
1686 inet_rsk(req)->ir_num,
1687 dest->s6_addr32[0], dest->s6_addr32[1],
1688 dest->s6_addr32[2], dest->s6_addr32[3],
1689 ntohs(inet_rsk(req)->ir_rmt_port),
1690 TCP_SYN_RECV,
1691 0, 0, /* could print option size, but that is af dependent. */
1692 1, /* timers active (only the expire timer) */
1693 jiffies_to_clock_t(ttd),
1694 req->num_timeout,
1695 from_kuid_munged(seq_user_ns(seq),
1696 sock_i_uid(req->rsk_listener)),
1697 0, /* non standard timer */
1698 0, /* open_requests have no inode */
1699 0, req);
1700}
1701
1702static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1703{
1704 const struct in6_addr *dest, *src;
1705 __u16 destp, srcp;
1706 int timer_active;
1707 unsigned long timer_expires;
1708 const struct inet_sock *inet = inet_sk(sp);
1709 const struct tcp_sock *tp = tcp_sk(sp);
1710 const struct inet_connection_sock *icsk = inet_csk(sp);
1711 const struct fastopen_queue *fastopenq = &icsk->icsk_accept_queue.fastopenq;
1712 int rx_queue;
1713 int state;
1714
1715 dest = &sp->sk_v6_daddr;
1716 src = &sp->sk_v6_rcv_saddr;
1717 destp = ntohs(inet->inet_dport);
1718 srcp = ntohs(inet->inet_sport);
1719
1720 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1721 timer_active = 1;
1722 timer_expires = icsk->icsk_timeout;
1723 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1724 timer_active = 4;
1725 timer_expires = icsk->icsk_timeout;
1726 } else if (timer_pending(&sp->sk_timer)) {
1727 timer_active = 2;
1728 timer_expires = sp->sk_timer.expires;
1729 } else {
1730 timer_active = 0;
1731 timer_expires = jiffies;
1732 }
1733
1734 state = sk_state_load(sp);
1735 if (state == TCP_LISTEN)
1736 rx_queue = sp->sk_ack_backlog;
1737 else
1738 /* Because we don't lock the socket,
1739 * we might find a transient negative value.
1740 */
1741 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
1742
1743 seq_printf(seq,
1744 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1745 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
1746 i,
1747 src->s6_addr32[0], src->s6_addr32[1],
1748 src->s6_addr32[2], src->s6_addr32[3], srcp,
1749 dest->s6_addr32[0], dest->s6_addr32[1],
1750 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1751 state,
1752 tp->write_seq - tp->snd_una,
1753 rx_queue,
1754 timer_active,
1755 jiffies_delta_to_clock_t(timer_expires - jiffies),
1756 icsk->icsk_retransmits,
1757 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
1758 icsk->icsk_probes_out,
1759 sock_i_ino(sp),
1760 atomic_read(&sp->sk_refcnt), sp,
1761 jiffies_to_clock_t(icsk->icsk_rto),
1762 jiffies_to_clock_t(icsk->icsk_ack.ato),
1763 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1764 tp->snd_cwnd,
1765 state == TCP_LISTEN ?
1766 fastopenq->max_qlen :
1767 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
1768 );
1769}
1770
1771static void get_timewait6_sock(struct seq_file *seq,
1772 struct inet_timewait_sock *tw, int i)
1773{
1774 long delta = tw->tw_timer.expires - jiffies;
1775 const struct in6_addr *dest, *src;
1776 __u16 destp, srcp;
1777
1778 dest = &tw->tw_v6_daddr;
1779 src = &tw->tw_v6_rcv_saddr;
1780 destp = ntohs(tw->tw_dport);
1781 srcp = ntohs(tw->tw_sport);
1782
1783 seq_printf(seq,
1784 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1785 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
1786 i,
1787 src->s6_addr32[0], src->s6_addr32[1],
1788 src->s6_addr32[2], src->s6_addr32[3], srcp,
1789 dest->s6_addr32[0], dest->s6_addr32[1],
1790 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1791 tw->tw_substate, 0, 0,
1792 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
1793 atomic_read(&tw->tw_refcnt), tw);
1794}
1795
1796static int tcp6_seq_show(struct seq_file *seq, void *v)
1797{
1798 struct tcp_iter_state *st;
1799 struct sock *sk = v;
1800
1801 if (v == SEQ_START_TOKEN) {
1802 seq_puts(seq,
1803 " sl "
1804 "local_address "
1805 "remote_address "
1806 "st tx_queue rx_queue tr tm->when retrnsmt"
1807 " uid timeout inode\n");
1808 goto out;
1809 }
1810 st = seq->private;
1811
1812 if (sk->sk_state == TCP_TIME_WAIT)
1813 get_timewait6_sock(seq, v, st->num);
1814 else if (sk->sk_state == TCP_NEW_SYN_RECV)
1815 get_openreq6(seq, v, st->num);
1816 else
1817 get_tcp6_sock(seq, v, st->num);
1818out:
1819 return 0;
1820}
1821
1822static const struct file_operations tcp6_afinfo_seq_fops = {
1823 .owner = THIS_MODULE,
1824 .open = tcp_seq_open,
1825 .read = seq_read,
1826 .llseek = seq_lseek,
1827 .release = seq_release_net
1828};
1829
1830static struct tcp_seq_afinfo tcp6_seq_afinfo = {
1831 .name = "tcp6",
1832 .family = AF_INET6,
1833 .seq_fops = &tcp6_afinfo_seq_fops,
1834 .seq_ops = {
1835 .show = tcp6_seq_show,
1836 },
1837};
1838
1839int __net_init tcp6_proc_init(struct net *net)
1840{
1841 return tcp_proc_register(net, &tcp6_seq_afinfo);
1842}
1843
1844void tcp6_proc_exit(struct net *net)
1845{
1846 tcp_proc_unregister(net, &tcp6_seq_afinfo);
1847}
1848#endif
1849
1850static void tcp_v6_clear_sk(struct sock *sk, int size)
1851{
1852 struct inet_sock *inet = inet_sk(sk);
1853
1854 /* we do not want to clear pinet6 field, because of RCU lookups */
1855 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1856
1857 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1858 memset(&inet->pinet6 + 1, 0, size);
1859}
1860
1861struct proto tcpv6_prot = {
1862 .name = "TCPv6",
1863 .owner = THIS_MODULE,
1864 .close = tcp_close,
1865 .connect = tcp_v6_connect,
1866 .disconnect = tcp_disconnect,
1867 .accept = inet_csk_accept,
1868 .ioctl = tcp_ioctl,
1869 .init = tcp_v6_init_sock,
1870 .destroy = tcp_v6_destroy_sock,
1871 .shutdown = tcp_shutdown,
1872 .setsockopt = tcp_setsockopt,
1873 .getsockopt = tcp_getsockopt,
1874 .recvmsg = tcp_recvmsg,
1875 .sendmsg = tcp_sendmsg,
1876 .sendpage = tcp_sendpage,
1877 .backlog_rcv = tcp_v6_do_rcv,
1878 .release_cb = tcp_release_cb,
1879 .hash = inet6_hash,
1880 .unhash = inet_unhash,
1881 .get_port = inet_csk_get_port,
1882 .enter_memory_pressure = tcp_enter_memory_pressure,
1883 .stream_memory_free = tcp_stream_memory_free,
1884 .sockets_allocated = &tcp_sockets_allocated,
1885 .memory_allocated = &tcp_memory_allocated,
1886 .memory_pressure = &tcp_memory_pressure,
1887 .orphan_count = &tcp_orphan_count,
1888 .sysctl_mem = sysctl_tcp_mem,
1889 .sysctl_wmem = sysctl_tcp_wmem,
1890 .sysctl_rmem = sysctl_tcp_rmem,
1891 .max_header = MAX_TCP_HEADER,
1892 .obj_size = sizeof(struct tcp6_sock),
1893 .slab_flags = SLAB_DESTROY_BY_RCU,
1894 .twsk_prot = &tcp6_timewait_sock_ops,
1895 .rsk_prot = &tcp6_request_sock_ops,
1896 .h.hashinfo = &tcp_hashinfo,
1897 .no_autobind = true,
1898#ifdef CONFIG_COMPAT
1899 .compat_setsockopt = compat_tcp_setsockopt,
1900 .compat_getsockopt = compat_tcp_getsockopt,
1901#endif
1902 .clear_sk = tcp_v6_clear_sk,
1903 .diag_destroy = tcp_abort,
1904};
1905
1906static const struct inet6_protocol tcpv6_protocol = {
1907 .early_demux = tcp_v6_early_demux,
1908 .handler = tcp_v6_rcv,
1909 .err_handler = tcp_v6_err,
1910 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1911};
1912
1913static struct inet_protosw tcpv6_protosw = {
1914 .type = SOCK_STREAM,
1915 .protocol = IPPROTO_TCP,
1916 .prot = &tcpv6_prot,
1917 .ops = &inet6_stream_ops,
1918 .flags = INET_PROTOSW_PERMANENT |
1919 INET_PROTOSW_ICSK,
1920};
1921
1922static int __net_init tcpv6_net_init(struct net *net)
1923{
1924 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1925 SOCK_RAW, IPPROTO_TCP, net);
1926}
1927
1928static void __net_exit tcpv6_net_exit(struct net *net)
1929{
1930 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
1931}
1932
1933static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
1934{
1935 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
1936}
1937
1938static struct pernet_operations tcpv6_net_ops = {
1939 .init = tcpv6_net_init,
1940 .exit = tcpv6_net_exit,
1941 .exit_batch = tcpv6_net_exit_batch,
1942};
1943
1944int __init tcpv6_init(void)
1945{
1946 int ret;
1947
1948 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1949 if (ret)
1950 goto out;
1951
1952 /* register inet6 protocol */
1953 ret = inet6_register_protosw(&tcpv6_protosw);
1954 if (ret)
1955 goto out_tcpv6_protocol;
1956
1957 ret = register_pernet_subsys(&tcpv6_net_ops);
1958 if (ret)
1959 goto out_tcpv6_protosw;
1960out:
1961 return ret;
1962
1963out_tcpv6_protosw:
1964 inet6_unregister_protosw(&tcpv6_protosw);
1965out_tcpv6_protocol:
1966 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
1967 goto out;
1968}
1969
1970void tcpv6_exit(void)
1971{
1972 unregister_pernet_subsys(&tcpv6_net_ops);
1973 inet6_unregister_protosw(&tcpv6_protosw);
1974 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
1975}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * TCP over IPv6
4 * Linux INET6 implementation
5 *
6 * Authors:
7 * Pedro Roque <roque@di.fc.ul.pt>
8 *
9 * Based on:
10 * linux/net/ipv4/tcp.c
11 * linux/net/ipv4/tcp_input.c
12 * linux/net/ipv4/tcp_output.c
13 *
14 * Fixes:
15 * Hideaki YOSHIFUJI : sin6_scope_id support
16 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
17 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
18 * a single port at the same time.
19 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
20 */
21
22#include <linux/bottom_half.h>
23#include <linux/module.h>
24#include <linux/errno.h>
25#include <linux/types.h>
26#include <linux/socket.h>
27#include <linux/sockios.h>
28#include <linux/net.h>
29#include <linux/jiffies.h>
30#include <linux/in.h>
31#include <linux/in6.h>
32#include <linux/netdevice.h>
33#include <linux/init.h>
34#include <linux/jhash.h>
35#include <linux/ipsec.h>
36#include <linux/times.h>
37#include <linux/slab.h>
38#include <linux/uaccess.h>
39#include <linux/ipv6.h>
40#include <linux/icmpv6.h>
41#include <linux/random.h>
42#include <linux/indirect_call_wrapper.h>
43
44#include <net/tcp.h>
45#include <net/ndisc.h>
46#include <net/inet6_hashtables.h>
47#include <net/inet6_connection_sock.h>
48#include <net/ipv6.h>
49#include <net/transp_v6.h>
50#include <net/addrconf.h>
51#include <net/ip6_route.h>
52#include <net/ip6_checksum.h>
53#include <net/inet_ecn.h>
54#include <net/protocol.h>
55#include <net/xfrm.h>
56#include <net/snmp.h>
57#include <net/dsfield.h>
58#include <net/timewait_sock.h>
59#include <net/inet_common.h>
60#include <net/secure_seq.h>
61#include <net/busy_poll.h>
62
63#include <linux/proc_fs.h>
64#include <linux/seq_file.h>
65
66#include <crypto/hash.h>
67#include <linux/scatterlist.h>
68
69#include <trace/events/tcp.h>
70
71static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb);
72static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
73 struct request_sock *req);
74
75INDIRECT_CALLABLE_SCOPE int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
76
77static const struct inet_connection_sock_af_ops ipv6_mapped;
78const struct inet_connection_sock_af_ops ipv6_specific;
79#ifdef CONFIG_TCP_MD5SIG
80static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
81static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
82#else
83static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk,
84 const struct in6_addr *addr,
85 int l3index)
86{
87 return NULL;
88}
89#endif
90
91/* Helper returning the inet6 address from a given tcp socket.
92 * It can be used in TCP stack instead of inet6_sk(sk).
93 * This avoids a dereference and allow compiler optimizations.
94 * It is a specialized version of inet6_sk_generic().
95 */
96static struct ipv6_pinfo *tcp_inet6_sk(const struct sock *sk)
97{
98 unsigned int offset = sizeof(struct tcp6_sock) - sizeof(struct ipv6_pinfo);
99
100 return (struct ipv6_pinfo *)(((u8 *)sk) + offset);
101}
102
103static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
104{
105 struct dst_entry *dst = skb_dst(skb);
106
107 if (dst && dst_hold_safe(dst)) {
108 const struct rt6_info *rt = (const struct rt6_info *)dst;
109
110 rcu_assign_pointer(sk->sk_rx_dst, dst);
111 sk->sk_rx_dst_ifindex = skb->skb_iif;
112 sk->sk_rx_dst_cookie = rt6_get_cookie(rt);
113 }
114}
115
116static u32 tcp_v6_init_seq(const struct sk_buff *skb)
117{
118 return secure_tcpv6_seq(ipv6_hdr(skb)->daddr.s6_addr32,
119 ipv6_hdr(skb)->saddr.s6_addr32,
120 tcp_hdr(skb)->dest,
121 tcp_hdr(skb)->source);
122}
123
124static u32 tcp_v6_init_ts_off(const struct net *net, const struct sk_buff *skb)
125{
126 return secure_tcpv6_ts_off(net, ipv6_hdr(skb)->daddr.s6_addr32,
127 ipv6_hdr(skb)->saddr.s6_addr32);
128}
129
130static int tcp_v6_pre_connect(struct sock *sk, struct sockaddr *uaddr,
131 int addr_len)
132{
133 /* This check is replicated from tcp_v6_connect() and intended to
134 * prevent BPF program called below from accessing bytes that are out
135 * of the bound specified by user in addr_len.
136 */
137 if (addr_len < SIN6_LEN_RFC2133)
138 return -EINVAL;
139
140 sock_owned_by_me(sk);
141
142 return BPF_CGROUP_RUN_PROG_INET6_CONNECT(sk, uaddr);
143}
144
145static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
146 int addr_len)
147{
148 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
149 struct inet_connection_sock *icsk = inet_csk(sk);
150 struct in6_addr *saddr = NULL, *final_p, final;
151 struct inet_timewait_death_row *tcp_death_row;
152 struct ipv6_pinfo *np = tcp_inet6_sk(sk);
153 struct inet_sock *inet = inet_sk(sk);
154 struct tcp_sock *tp = tcp_sk(sk);
155 struct net *net = sock_net(sk);
156 struct ipv6_txoptions *opt;
157 struct dst_entry *dst;
158 struct flowi6 fl6;
159 int addr_type;
160 int err;
161
162 if (addr_len < SIN6_LEN_RFC2133)
163 return -EINVAL;
164
165 if (usin->sin6_family != AF_INET6)
166 return -EAFNOSUPPORT;
167
168 memset(&fl6, 0, sizeof(fl6));
169
170 if (np->sndflow) {
171 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
172 IP6_ECN_flow_init(fl6.flowlabel);
173 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
174 struct ip6_flowlabel *flowlabel;
175 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
176 if (IS_ERR(flowlabel))
177 return -EINVAL;
178 fl6_sock_release(flowlabel);
179 }
180 }
181
182 /*
183 * connect() to INADDR_ANY means loopback (BSD'ism).
184 */
185
186 if (ipv6_addr_any(&usin->sin6_addr)) {
187 if (ipv6_addr_v4mapped(&sk->sk_v6_rcv_saddr))
188 ipv6_addr_set_v4mapped(htonl(INADDR_LOOPBACK),
189 &usin->sin6_addr);
190 else
191 usin->sin6_addr = in6addr_loopback;
192 }
193
194 addr_type = ipv6_addr_type(&usin->sin6_addr);
195
196 if (addr_type & IPV6_ADDR_MULTICAST)
197 return -ENETUNREACH;
198
199 if (addr_type&IPV6_ADDR_LINKLOCAL) {
200 if (addr_len >= sizeof(struct sockaddr_in6) &&
201 usin->sin6_scope_id) {
202 /* If interface is set while binding, indices
203 * must coincide.
204 */
205 if (!sk_dev_equal_l3scope(sk, usin->sin6_scope_id))
206 return -EINVAL;
207
208 sk->sk_bound_dev_if = usin->sin6_scope_id;
209 }
210
211 /* Connect to link-local address requires an interface */
212 if (!sk->sk_bound_dev_if)
213 return -EINVAL;
214 }
215
216 if (tp->rx_opt.ts_recent_stamp &&
217 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
218 tp->rx_opt.ts_recent = 0;
219 tp->rx_opt.ts_recent_stamp = 0;
220 WRITE_ONCE(tp->write_seq, 0);
221 }
222
223 sk->sk_v6_daddr = usin->sin6_addr;
224 np->flow_label = fl6.flowlabel;
225
226 /*
227 * TCP over IPv4
228 */
229
230 if (addr_type & IPV6_ADDR_MAPPED) {
231 u32 exthdrlen = icsk->icsk_ext_hdr_len;
232 struct sockaddr_in sin;
233
234 if (ipv6_only_sock(sk))
235 return -ENETUNREACH;
236
237 sin.sin_family = AF_INET;
238 sin.sin_port = usin->sin6_port;
239 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
240
241 /* Paired with READ_ONCE() in tcp_(get|set)sockopt() */
242 WRITE_ONCE(icsk->icsk_af_ops, &ipv6_mapped);
243 if (sk_is_mptcp(sk))
244 mptcpv6_handle_mapped(sk, true);
245 sk->sk_backlog_rcv = tcp_v4_do_rcv;
246#ifdef CONFIG_TCP_MD5SIG
247 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
248#endif
249
250 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
251
252 if (err) {
253 icsk->icsk_ext_hdr_len = exthdrlen;
254 /* Paired with READ_ONCE() in tcp_(get|set)sockopt() */
255 WRITE_ONCE(icsk->icsk_af_ops, &ipv6_specific);
256 if (sk_is_mptcp(sk))
257 mptcpv6_handle_mapped(sk, false);
258 sk->sk_backlog_rcv = tcp_v6_do_rcv;
259#ifdef CONFIG_TCP_MD5SIG
260 tp->af_specific = &tcp_sock_ipv6_specific;
261#endif
262 goto failure;
263 }
264 np->saddr = sk->sk_v6_rcv_saddr;
265
266 return err;
267 }
268
269 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
270 saddr = &sk->sk_v6_rcv_saddr;
271
272 fl6.flowi6_proto = IPPROTO_TCP;
273 fl6.daddr = sk->sk_v6_daddr;
274 fl6.saddr = saddr ? *saddr : np->saddr;
275 fl6.flowlabel = ip6_make_flowinfo(np->tclass, np->flow_label);
276 fl6.flowi6_oif = sk->sk_bound_dev_if;
277 fl6.flowi6_mark = sk->sk_mark;
278 fl6.fl6_dport = usin->sin6_port;
279 fl6.fl6_sport = inet->inet_sport;
280 fl6.flowi6_uid = sk->sk_uid;
281
282 opt = rcu_dereference_protected(np->opt, lockdep_sock_is_held(sk));
283 final_p = fl6_update_dst(&fl6, opt, &final);
284
285 security_sk_classify_flow(sk, flowi6_to_flowi_common(&fl6));
286
287 dst = ip6_dst_lookup_flow(net, sk, &fl6, final_p);
288 if (IS_ERR(dst)) {
289 err = PTR_ERR(dst);
290 goto failure;
291 }
292
293 tcp_death_row = &sock_net(sk)->ipv4.tcp_death_row;
294
295 if (!saddr) {
296 saddr = &fl6.saddr;
297
298 err = inet_bhash2_update_saddr(sk, saddr, AF_INET6);
299 if (err)
300 goto failure;
301 }
302
303 /* set the source address */
304 np->saddr = *saddr;
305 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
306
307 sk->sk_gso_type = SKB_GSO_TCPV6;
308 ip6_dst_store(sk, dst, NULL, NULL);
309
310 icsk->icsk_ext_hdr_len = 0;
311 if (opt)
312 icsk->icsk_ext_hdr_len = opt->opt_flen +
313 opt->opt_nflen;
314
315 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
316
317 inet->inet_dport = usin->sin6_port;
318
319 tcp_set_state(sk, TCP_SYN_SENT);
320 err = inet6_hash_connect(tcp_death_row, sk);
321 if (err)
322 goto late_failure;
323
324 sk_set_txhash(sk);
325
326 if (likely(!tp->repair)) {
327 if (!tp->write_seq)
328 WRITE_ONCE(tp->write_seq,
329 secure_tcpv6_seq(np->saddr.s6_addr32,
330 sk->sk_v6_daddr.s6_addr32,
331 inet->inet_sport,
332 inet->inet_dport));
333 tp->tsoffset = secure_tcpv6_ts_off(net, np->saddr.s6_addr32,
334 sk->sk_v6_daddr.s6_addr32);
335 }
336
337 if (tcp_fastopen_defer_connect(sk, &err))
338 return err;
339 if (err)
340 goto late_failure;
341
342 err = tcp_connect(sk);
343 if (err)
344 goto late_failure;
345
346 return 0;
347
348late_failure:
349 tcp_set_state(sk, TCP_CLOSE);
350 inet_bhash2_reset_saddr(sk);
351failure:
352 inet->inet_dport = 0;
353 sk->sk_route_caps = 0;
354 return err;
355}
356
357static void tcp_v6_mtu_reduced(struct sock *sk)
358{
359 struct dst_entry *dst;
360 u32 mtu;
361
362 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
363 return;
364
365 mtu = READ_ONCE(tcp_sk(sk)->mtu_info);
366
367 /* Drop requests trying to increase our current mss.
368 * Check done in __ip6_rt_update_pmtu() is too late.
369 */
370 if (tcp_mtu_to_mss(sk, mtu) >= tcp_sk(sk)->mss_cache)
371 return;
372
373 dst = inet6_csk_update_pmtu(sk, mtu);
374 if (!dst)
375 return;
376
377 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
378 tcp_sync_mss(sk, dst_mtu(dst));
379 tcp_simple_retransmit(sk);
380 }
381}
382
383static int tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
384 u8 type, u8 code, int offset, __be32 info)
385{
386 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
387 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
388 struct net *net = dev_net(skb->dev);
389 struct request_sock *fastopen;
390 struct ipv6_pinfo *np;
391 struct tcp_sock *tp;
392 __u32 seq, snd_una;
393 struct sock *sk;
394 bool fatal;
395 int err;
396
397 sk = __inet6_lookup_established(net, net->ipv4.tcp_death_row.hashinfo,
398 &hdr->daddr, th->dest,
399 &hdr->saddr, ntohs(th->source),
400 skb->dev->ifindex, inet6_sdif(skb));
401
402 if (!sk) {
403 __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev),
404 ICMP6_MIB_INERRORS);
405 return -ENOENT;
406 }
407
408 if (sk->sk_state == TCP_TIME_WAIT) {
409 inet_twsk_put(inet_twsk(sk));
410 return 0;
411 }
412 seq = ntohl(th->seq);
413 fatal = icmpv6_err_convert(type, code, &err);
414 if (sk->sk_state == TCP_NEW_SYN_RECV) {
415 tcp_req_err(sk, seq, fatal);
416 return 0;
417 }
418
419 bh_lock_sock(sk);
420 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
421 __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS);
422
423 if (sk->sk_state == TCP_CLOSE)
424 goto out;
425
426 if (static_branch_unlikely(&ip6_min_hopcount)) {
427 /* min_hopcount can be changed concurrently from do_ipv6_setsockopt() */
428 if (ipv6_hdr(skb)->hop_limit < READ_ONCE(tcp_inet6_sk(sk)->min_hopcount)) {
429 __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
430 goto out;
431 }
432 }
433
434 tp = tcp_sk(sk);
435 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
436 fastopen = rcu_dereference(tp->fastopen_rsk);
437 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
438 if (sk->sk_state != TCP_LISTEN &&
439 !between(seq, snd_una, tp->snd_nxt)) {
440 __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
441 goto out;
442 }
443
444 np = tcp_inet6_sk(sk);
445
446 if (type == NDISC_REDIRECT) {
447 if (!sock_owned_by_user(sk)) {
448 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
449
450 if (dst)
451 dst->ops->redirect(dst, sk, skb);
452 }
453 goto out;
454 }
455
456 if (type == ICMPV6_PKT_TOOBIG) {
457 u32 mtu = ntohl(info);
458
459 /* We are not interested in TCP_LISTEN and open_requests
460 * (SYN-ACKs send out by Linux are always <576bytes so
461 * they should go through unfragmented).
462 */
463 if (sk->sk_state == TCP_LISTEN)
464 goto out;
465
466 if (!ip6_sk_accept_pmtu(sk))
467 goto out;
468
469 if (mtu < IPV6_MIN_MTU)
470 goto out;
471
472 WRITE_ONCE(tp->mtu_info, mtu);
473
474 if (!sock_owned_by_user(sk))
475 tcp_v6_mtu_reduced(sk);
476 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
477 &sk->sk_tsq_flags))
478 sock_hold(sk);
479 goto out;
480 }
481
482
483 /* Might be for an request_sock */
484 switch (sk->sk_state) {
485 case TCP_SYN_SENT:
486 case TCP_SYN_RECV:
487 /* Only in fast or simultaneous open. If a fast open socket is
488 * already accepted it is treated as a connected one below.
489 */
490 if (fastopen && !fastopen->sk)
491 break;
492
493 ipv6_icmp_error(sk, skb, err, th->dest, ntohl(info), (u8 *)th);
494
495 if (!sock_owned_by_user(sk)) {
496 sk->sk_err = err;
497 sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
498
499 tcp_done(sk);
500 } else
501 sk->sk_err_soft = err;
502 goto out;
503 case TCP_LISTEN:
504 break;
505 default:
506 /* check if this ICMP message allows revert of backoff.
507 * (see RFC 6069)
508 */
509 if (!fastopen && type == ICMPV6_DEST_UNREACH &&
510 code == ICMPV6_NOROUTE)
511 tcp_ld_RTO_revert(sk, seq);
512 }
513
514 if (!sock_owned_by_user(sk) && np->recverr) {
515 sk->sk_err = err;
516 sk_error_report(sk);
517 } else
518 sk->sk_err_soft = err;
519
520out:
521 bh_unlock_sock(sk);
522 sock_put(sk);
523 return 0;
524}
525
526
527static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst,
528 struct flowi *fl,
529 struct request_sock *req,
530 struct tcp_fastopen_cookie *foc,
531 enum tcp_synack_type synack_type,
532 struct sk_buff *syn_skb)
533{
534 struct inet_request_sock *ireq = inet_rsk(req);
535 struct ipv6_pinfo *np = tcp_inet6_sk(sk);
536 struct ipv6_txoptions *opt;
537 struct flowi6 *fl6 = &fl->u.ip6;
538 struct sk_buff *skb;
539 int err = -ENOMEM;
540 u8 tclass;
541
542 /* First, grab a route. */
543 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req,
544 IPPROTO_TCP)) == NULL)
545 goto done;
546
547 skb = tcp_make_synack(sk, dst, req, foc, synack_type, syn_skb);
548
549 if (skb) {
550 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
551 &ireq->ir_v6_rmt_addr);
552
553 fl6->daddr = ireq->ir_v6_rmt_addr;
554 if (np->repflow && ireq->pktopts)
555 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
556
557 tclass = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_reflect_tos) ?
558 (tcp_rsk(req)->syn_tos & ~INET_ECN_MASK) |
559 (np->tclass & INET_ECN_MASK) :
560 np->tclass;
561
562 if (!INET_ECN_is_capable(tclass) &&
563 tcp_bpf_ca_needs_ecn((struct sock *)req))
564 tclass |= INET_ECN_ECT_0;
565
566 rcu_read_lock();
567 opt = ireq->ipv6_opt;
568 if (!opt)
569 opt = rcu_dereference(np->opt);
570 err = ip6_xmit(sk, skb, fl6, skb->mark ? : sk->sk_mark, opt,
571 tclass, sk->sk_priority);
572 rcu_read_unlock();
573 err = net_xmit_eval(err);
574 }
575
576done:
577 return err;
578}
579
580
581static void tcp_v6_reqsk_destructor(struct request_sock *req)
582{
583 kfree(inet_rsk(req)->ipv6_opt);
584 consume_skb(inet_rsk(req)->pktopts);
585}
586
587#ifdef CONFIG_TCP_MD5SIG
588static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk,
589 const struct in6_addr *addr,
590 int l3index)
591{
592 return tcp_md5_do_lookup(sk, l3index,
593 (union tcp_md5_addr *)addr, AF_INET6);
594}
595
596static struct tcp_md5sig_key *tcp_v6_md5_lookup(const struct sock *sk,
597 const struct sock *addr_sk)
598{
599 int l3index;
600
601 l3index = l3mdev_master_ifindex_by_index(sock_net(sk),
602 addr_sk->sk_bound_dev_if);
603 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr,
604 l3index);
605}
606
607static int tcp_v6_parse_md5_keys(struct sock *sk, int optname,
608 sockptr_t optval, int optlen)
609{
610 struct tcp_md5sig cmd;
611 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
612 int l3index = 0;
613 u8 prefixlen;
614 u8 flags;
615
616 if (optlen < sizeof(cmd))
617 return -EINVAL;
618
619 if (copy_from_sockptr(&cmd, optval, sizeof(cmd)))
620 return -EFAULT;
621
622 if (sin6->sin6_family != AF_INET6)
623 return -EINVAL;
624
625 flags = cmd.tcpm_flags & TCP_MD5SIG_FLAG_IFINDEX;
626
627 if (optname == TCP_MD5SIG_EXT &&
628 cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) {
629 prefixlen = cmd.tcpm_prefixlen;
630 if (prefixlen > 128 || (ipv6_addr_v4mapped(&sin6->sin6_addr) &&
631 prefixlen > 32))
632 return -EINVAL;
633 } else {
634 prefixlen = ipv6_addr_v4mapped(&sin6->sin6_addr) ? 32 : 128;
635 }
636
637 if (optname == TCP_MD5SIG_EXT && cmd.tcpm_ifindex &&
638 cmd.tcpm_flags & TCP_MD5SIG_FLAG_IFINDEX) {
639 struct net_device *dev;
640
641 rcu_read_lock();
642 dev = dev_get_by_index_rcu(sock_net(sk), cmd.tcpm_ifindex);
643 if (dev && netif_is_l3_master(dev))
644 l3index = dev->ifindex;
645 rcu_read_unlock();
646
647 /* ok to reference set/not set outside of rcu;
648 * right now device MUST be an L3 master
649 */
650 if (!dev || !l3index)
651 return -EINVAL;
652 }
653
654 if (!cmd.tcpm_keylen) {
655 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
656 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
657 AF_INET, prefixlen,
658 l3index, flags);
659 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
660 AF_INET6, prefixlen, l3index, flags);
661 }
662
663 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
664 return -EINVAL;
665
666 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
667 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
668 AF_INET, prefixlen, l3index, flags,
669 cmd.tcpm_key, cmd.tcpm_keylen);
670
671 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
672 AF_INET6, prefixlen, l3index, flags,
673 cmd.tcpm_key, cmd.tcpm_keylen);
674}
675
676static int tcp_v6_md5_hash_headers(struct tcp_md5sig_pool *hp,
677 const struct in6_addr *daddr,
678 const struct in6_addr *saddr,
679 const struct tcphdr *th, int nbytes)
680{
681 struct tcp6_pseudohdr *bp;
682 struct scatterlist sg;
683 struct tcphdr *_th;
684
685 bp = hp->scratch;
686 /* 1. TCP pseudo-header (RFC2460) */
687 bp->saddr = *saddr;
688 bp->daddr = *daddr;
689 bp->protocol = cpu_to_be32(IPPROTO_TCP);
690 bp->len = cpu_to_be32(nbytes);
691
692 _th = (struct tcphdr *)(bp + 1);
693 memcpy(_th, th, sizeof(*th));
694 _th->check = 0;
695
696 sg_init_one(&sg, bp, sizeof(*bp) + sizeof(*th));
697 ahash_request_set_crypt(hp->md5_req, &sg, NULL,
698 sizeof(*bp) + sizeof(*th));
699 return crypto_ahash_update(hp->md5_req);
700}
701
702static int tcp_v6_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
703 const struct in6_addr *daddr, struct in6_addr *saddr,
704 const struct tcphdr *th)
705{
706 struct tcp_md5sig_pool *hp;
707 struct ahash_request *req;
708
709 hp = tcp_get_md5sig_pool();
710 if (!hp)
711 goto clear_hash_noput;
712 req = hp->md5_req;
713
714 if (crypto_ahash_init(req))
715 goto clear_hash;
716 if (tcp_v6_md5_hash_headers(hp, daddr, saddr, th, th->doff << 2))
717 goto clear_hash;
718 if (tcp_md5_hash_key(hp, key))
719 goto clear_hash;
720 ahash_request_set_crypt(req, NULL, md5_hash, 0);
721 if (crypto_ahash_final(req))
722 goto clear_hash;
723
724 tcp_put_md5sig_pool();
725 return 0;
726
727clear_hash:
728 tcp_put_md5sig_pool();
729clear_hash_noput:
730 memset(md5_hash, 0, 16);
731 return 1;
732}
733
734static int tcp_v6_md5_hash_skb(char *md5_hash,
735 const struct tcp_md5sig_key *key,
736 const struct sock *sk,
737 const struct sk_buff *skb)
738{
739 const struct in6_addr *saddr, *daddr;
740 struct tcp_md5sig_pool *hp;
741 struct ahash_request *req;
742 const struct tcphdr *th = tcp_hdr(skb);
743
744 if (sk) { /* valid for establish/request sockets */
745 saddr = &sk->sk_v6_rcv_saddr;
746 daddr = &sk->sk_v6_daddr;
747 } else {
748 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
749 saddr = &ip6h->saddr;
750 daddr = &ip6h->daddr;
751 }
752
753 hp = tcp_get_md5sig_pool();
754 if (!hp)
755 goto clear_hash_noput;
756 req = hp->md5_req;
757
758 if (crypto_ahash_init(req))
759 goto clear_hash;
760
761 if (tcp_v6_md5_hash_headers(hp, daddr, saddr, th, skb->len))
762 goto clear_hash;
763 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
764 goto clear_hash;
765 if (tcp_md5_hash_key(hp, key))
766 goto clear_hash;
767 ahash_request_set_crypt(req, NULL, md5_hash, 0);
768 if (crypto_ahash_final(req))
769 goto clear_hash;
770
771 tcp_put_md5sig_pool();
772 return 0;
773
774clear_hash:
775 tcp_put_md5sig_pool();
776clear_hash_noput:
777 memset(md5_hash, 0, 16);
778 return 1;
779}
780
781#endif
782
783static void tcp_v6_init_req(struct request_sock *req,
784 const struct sock *sk_listener,
785 struct sk_buff *skb)
786{
787 bool l3_slave = ipv6_l3mdev_skb(TCP_SKB_CB(skb)->header.h6.flags);
788 struct inet_request_sock *ireq = inet_rsk(req);
789 const struct ipv6_pinfo *np = tcp_inet6_sk(sk_listener);
790
791 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
792 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
793
794 /* So that link locals have meaning */
795 if ((!sk_listener->sk_bound_dev_if || l3_slave) &&
796 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
797 ireq->ir_iif = tcp_v6_iif(skb);
798
799 if (!TCP_SKB_CB(skb)->tcp_tw_isn &&
800 (ipv6_opt_accepted(sk_listener, skb, &TCP_SKB_CB(skb)->header.h6) ||
801 np->rxopt.bits.rxinfo ||
802 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
803 np->rxopt.bits.rxohlim || np->repflow)) {
804 refcount_inc(&skb->users);
805 ireq->pktopts = skb;
806 }
807}
808
809static struct dst_entry *tcp_v6_route_req(const struct sock *sk,
810 struct sk_buff *skb,
811 struct flowi *fl,
812 struct request_sock *req)
813{
814 tcp_v6_init_req(req, sk, skb);
815
816 if (security_inet_conn_request(sk, skb, req))
817 return NULL;
818
819 return inet6_csk_route_req(sk, &fl->u.ip6, req, IPPROTO_TCP);
820}
821
822struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
823 .family = AF_INET6,
824 .obj_size = sizeof(struct tcp6_request_sock),
825 .rtx_syn_ack = tcp_rtx_synack,
826 .send_ack = tcp_v6_reqsk_send_ack,
827 .destructor = tcp_v6_reqsk_destructor,
828 .send_reset = tcp_v6_send_reset,
829 .syn_ack_timeout = tcp_syn_ack_timeout,
830};
831
832const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
833 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) -
834 sizeof(struct ipv6hdr),
835#ifdef CONFIG_TCP_MD5SIG
836 .req_md5_lookup = tcp_v6_md5_lookup,
837 .calc_md5_hash = tcp_v6_md5_hash_skb,
838#endif
839#ifdef CONFIG_SYN_COOKIES
840 .cookie_init_seq = cookie_v6_init_sequence,
841#endif
842 .route_req = tcp_v6_route_req,
843 .init_seq = tcp_v6_init_seq,
844 .init_ts_off = tcp_v6_init_ts_off,
845 .send_synack = tcp_v6_send_synack,
846};
847
848static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 seq,
849 u32 ack, u32 win, u32 tsval, u32 tsecr,
850 int oif, struct tcp_md5sig_key *key, int rst,
851 u8 tclass, __be32 label, u32 priority, u32 txhash)
852{
853 const struct tcphdr *th = tcp_hdr(skb);
854 struct tcphdr *t1;
855 struct sk_buff *buff;
856 struct flowi6 fl6;
857 struct net *net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
858 struct sock *ctl_sk = net->ipv6.tcp_sk;
859 unsigned int tot_len = sizeof(struct tcphdr);
860 __be32 mrst = 0, *topt;
861 struct dst_entry *dst;
862 __u32 mark = 0;
863
864 if (tsecr)
865 tot_len += TCPOLEN_TSTAMP_ALIGNED;
866#ifdef CONFIG_TCP_MD5SIG
867 if (key)
868 tot_len += TCPOLEN_MD5SIG_ALIGNED;
869#endif
870
871#ifdef CONFIG_MPTCP
872 if (rst && !key) {
873 mrst = mptcp_reset_option(skb);
874
875 if (mrst)
876 tot_len += sizeof(__be32);
877 }
878#endif
879
880 buff = alloc_skb(MAX_TCP_HEADER, GFP_ATOMIC);
881 if (!buff)
882 return;
883
884 skb_reserve(buff, MAX_TCP_HEADER);
885
886 t1 = skb_push(buff, tot_len);
887 skb_reset_transport_header(buff);
888
889 /* Swap the send and the receive. */
890 memset(t1, 0, sizeof(*t1));
891 t1->dest = th->source;
892 t1->source = th->dest;
893 t1->doff = tot_len / 4;
894 t1->seq = htonl(seq);
895 t1->ack_seq = htonl(ack);
896 t1->ack = !rst || !th->ack;
897 t1->rst = rst;
898 t1->window = htons(win);
899
900 topt = (__be32 *)(t1 + 1);
901
902 if (tsecr) {
903 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
904 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
905 *topt++ = htonl(tsval);
906 *topt++ = htonl(tsecr);
907 }
908
909 if (mrst)
910 *topt++ = mrst;
911
912#ifdef CONFIG_TCP_MD5SIG
913 if (key) {
914 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
915 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
916 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
917 &ipv6_hdr(skb)->saddr,
918 &ipv6_hdr(skb)->daddr, t1);
919 }
920#endif
921
922 memset(&fl6, 0, sizeof(fl6));
923 fl6.daddr = ipv6_hdr(skb)->saddr;
924 fl6.saddr = ipv6_hdr(skb)->daddr;
925 fl6.flowlabel = label;
926
927 buff->ip_summed = CHECKSUM_PARTIAL;
928
929 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
930
931 fl6.flowi6_proto = IPPROTO_TCP;
932 if (rt6_need_strict(&fl6.daddr) && !oif)
933 fl6.flowi6_oif = tcp_v6_iif(skb);
934 else {
935 if (!oif && netif_index_is_l3_master(net, skb->skb_iif))
936 oif = skb->skb_iif;
937
938 fl6.flowi6_oif = oif;
939 }
940
941 if (sk) {
942 if (sk->sk_state == TCP_TIME_WAIT)
943 mark = inet_twsk(sk)->tw_mark;
944 else
945 mark = sk->sk_mark;
946 skb_set_delivery_time(buff, tcp_transmit_time(sk), true);
947 }
948 if (txhash) {
949 /* autoflowlabel/skb_get_hash_flowi6 rely on buff->hash */
950 skb_set_hash(buff, txhash, PKT_HASH_TYPE_L4);
951 }
952 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark) ?: mark;
953 fl6.fl6_dport = t1->dest;
954 fl6.fl6_sport = t1->source;
955 fl6.flowi6_uid = sock_net_uid(net, sk && sk_fullsock(sk) ? sk : NULL);
956 security_skb_classify_flow(skb, flowi6_to_flowi_common(&fl6));
957
958 /* Pass a socket to ip6_dst_lookup either it is for RST
959 * Underlying function will use this to retrieve the network
960 * namespace
961 */
962 if (sk && sk->sk_state != TCP_TIME_WAIT)
963 dst = ip6_dst_lookup_flow(net, sk, &fl6, NULL); /*sk's xfrm_policy can be referred*/
964 else
965 dst = ip6_dst_lookup_flow(net, ctl_sk, &fl6, NULL);
966 if (!IS_ERR(dst)) {
967 skb_dst_set(buff, dst);
968 ip6_xmit(ctl_sk, buff, &fl6, fl6.flowi6_mark, NULL,
969 tclass & ~INET_ECN_MASK, priority);
970 TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
971 if (rst)
972 TCP_INC_STATS(net, TCP_MIB_OUTRSTS);
973 return;
974 }
975
976 kfree_skb(buff);
977}
978
979static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb)
980{
981 const struct tcphdr *th = tcp_hdr(skb);
982 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
983 u32 seq = 0, ack_seq = 0;
984 struct tcp_md5sig_key *key = NULL;
985#ifdef CONFIG_TCP_MD5SIG
986 const __u8 *hash_location = NULL;
987 unsigned char newhash[16];
988 int genhash;
989 struct sock *sk1 = NULL;
990#endif
991 __be32 label = 0;
992 u32 priority = 0;
993 struct net *net;
994 u32 txhash = 0;
995 int oif = 0;
996
997 if (th->rst)
998 return;
999
1000 /* If sk not NULL, it means we did a successful lookup and incoming
1001 * route had to be correct. prequeue might have dropped our dst.
1002 */
1003 if (!sk && !ipv6_unicast_destination(skb))
1004 return;
1005
1006 net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
1007#ifdef CONFIG_TCP_MD5SIG
1008 rcu_read_lock();
1009 hash_location = tcp_parse_md5sig_option(th);
1010 if (sk && sk_fullsock(sk)) {
1011 int l3index;
1012
1013 /* sdif set, means packet ingressed via a device
1014 * in an L3 domain and inet_iif is set to it.
1015 */
1016 l3index = tcp_v6_sdif(skb) ? tcp_v6_iif_l3_slave(skb) : 0;
1017 key = tcp_v6_md5_do_lookup(sk, &ipv6h->saddr, l3index);
1018 } else if (hash_location) {
1019 int dif = tcp_v6_iif_l3_slave(skb);
1020 int sdif = tcp_v6_sdif(skb);
1021 int l3index;
1022
1023 /*
1024 * active side is lost. Try to find listening socket through
1025 * source port, and then find md5 key through listening socket.
1026 * we are not loose security here:
1027 * Incoming packet is checked with md5 hash with finding key,
1028 * no RST generated if md5 hash doesn't match.
1029 */
1030 sk1 = inet6_lookup_listener(net, net->ipv4.tcp_death_row.hashinfo,
1031 NULL, 0, &ipv6h->saddr, th->source,
1032 &ipv6h->daddr, ntohs(th->source),
1033 dif, sdif);
1034 if (!sk1)
1035 goto out;
1036
1037 /* sdif set, means packet ingressed via a device
1038 * in an L3 domain and dif is set to it.
1039 */
1040 l3index = tcp_v6_sdif(skb) ? dif : 0;
1041
1042 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr, l3index);
1043 if (!key)
1044 goto out;
1045
1046 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, skb);
1047 if (genhash || memcmp(hash_location, newhash, 16) != 0)
1048 goto out;
1049 }
1050#endif
1051
1052 if (th->ack)
1053 seq = ntohl(th->ack_seq);
1054 else
1055 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
1056 (th->doff << 2);
1057
1058 if (sk) {
1059 oif = sk->sk_bound_dev_if;
1060 if (sk_fullsock(sk)) {
1061 const struct ipv6_pinfo *np = tcp_inet6_sk(sk);
1062
1063 trace_tcp_send_reset(sk, skb);
1064 if (np->repflow)
1065 label = ip6_flowlabel(ipv6h);
1066 priority = sk->sk_priority;
1067 txhash = sk->sk_hash;
1068 }
1069 if (sk->sk_state == TCP_TIME_WAIT) {
1070 label = cpu_to_be32(inet_twsk(sk)->tw_flowlabel);
1071 priority = inet_twsk(sk)->tw_priority;
1072 txhash = inet_twsk(sk)->tw_txhash;
1073 }
1074 } else {
1075 if (net->ipv6.sysctl.flowlabel_reflect & FLOWLABEL_REFLECT_TCP_RESET)
1076 label = ip6_flowlabel(ipv6h);
1077 }
1078
1079 tcp_v6_send_response(sk, skb, seq, ack_seq, 0, 0, 0, oif, key, 1,
1080 ipv6_get_dsfield(ipv6h), label, priority, txhash);
1081
1082#ifdef CONFIG_TCP_MD5SIG
1083out:
1084 rcu_read_unlock();
1085#endif
1086}
1087
1088static void tcp_v6_send_ack(const struct sock *sk, struct sk_buff *skb, u32 seq,
1089 u32 ack, u32 win, u32 tsval, u32 tsecr, int oif,
1090 struct tcp_md5sig_key *key, u8 tclass,
1091 __be32 label, u32 priority, u32 txhash)
1092{
1093 tcp_v6_send_response(sk, skb, seq, ack, win, tsval, tsecr, oif, key, 0,
1094 tclass, label, priority, txhash);
1095}
1096
1097static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1098{
1099 struct inet_timewait_sock *tw = inet_twsk(sk);
1100 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1101
1102 tcp_v6_send_ack(sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
1103 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
1104 tcp_time_stamp_raw() + tcptw->tw_ts_offset,
1105 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
1106 tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel), tw->tw_priority,
1107 tw->tw_txhash);
1108
1109 inet_twsk_put(tw);
1110}
1111
1112static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
1113 struct request_sock *req)
1114{
1115 int l3index;
1116
1117 l3index = tcp_v6_sdif(skb) ? tcp_v6_iif_l3_slave(skb) : 0;
1118
1119 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
1120 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
1121 */
1122 /* RFC 7323 2.3
1123 * The window field (SEG.WND) of every outgoing segment, with the
1124 * exception of <SYN> segments, MUST be right-shifted by
1125 * Rcv.Wind.Shift bits:
1126 */
1127 tcp_v6_send_ack(sk, skb, (sk->sk_state == TCP_LISTEN) ?
1128 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
1129 tcp_rsk(req)->rcv_nxt,
1130 req->rsk_rcv_wnd >> inet_rsk(req)->rcv_wscale,
1131 tcp_time_stamp_raw() + tcp_rsk(req)->ts_off,
1132 req->ts_recent, sk->sk_bound_dev_if,
1133 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->saddr, l3index),
1134 ipv6_get_dsfield(ipv6_hdr(skb)), 0, sk->sk_priority,
1135 tcp_rsk(req)->txhash);
1136}
1137
1138
1139static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb)
1140{
1141#ifdef CONFIG_SYN_COOKIES
1142 const struct tcphdr *th = tcp_hdr(skb);
1143
1144 if (!th->syn)
1145 sk = cookie_v6_check(sk, skb);
1146#endif
1147 return sk;
1148}
1149
1150u16 tcp_v6_get_syncookie(struct sock *sk, struct ipv6hdr *iph,
1151 struct tcphdr *th, u32 *cookie)
1152{
1153 u16 mss = 0;
1154#ifdef CONFIG_SYN_COOKIES
1155 mss = tcp_get_syncookie_mss(&tcp6_request_sock_ops,
1156 &tcp_request_sock_ipv6_ops, sk, th);
1157 if (mss) {
1158 *cookie = __cookie_v6_init_sequence(iph, th, &mss);
1159 tcp_synq_overflow(sk);
1160 }
1161#endif
1162 return mss;
1163}
1164
1165static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1166{
1167 if (skb->protocol == htons(ETH_P_IP))
1168 return tcp_v4_conn_request(sk, skb);
1169
1170 if (!ipv6_unicast_destination(skb))
1171 goto drop;
1172
1173 if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
1174 __IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
1175 return 0;
1176 }
1177
1178 return tcp_conn_request(&tcp6_request_sock_ops,
1179 &tcp_request_sock_ipv6_ops, sk, skb);
1180
1181drop:
1182 tcp_listendrop(sk);
1183 return 0; /* don't send reset */
1184}
1185
1186static void tcp_v6_restore_cb(struct sk_buff *skb)
1187{
1188 /* We need to move header back to the beginning if xfrm6_policy_check()
1189 * and tcp_v6_fill_cb() are going to be called again.
1190 * ip6_datagram_recv_specific_ctl() also expects IP6CB to be there.
1191 */
1192 memmove(IP6CB(skb), &TCP_SKB_CB(skb)->header.h6,
1193 sizeof(struct inet6_skb_parm));
1194}
1195
1196static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
1197 struct request_sock *req,
1198 struct dst_entry *dst,
1199 struct request_sock *req_unhash,
1200 bool *own_req)
1201{
1202 struct inet_request_sock *ireq;
1203 struct ipv6_pinfo *newnp;
1204 const struct ipv6_pinfo *np = tcp_inet6_sk(sk);
1205 struct ipv6_txoptions *opt;
1206 struct inet_sock *newinet;
1207 bool found_dup_sk = false;
1208 struct tcp_sock *newtp;
1209 struct sock *newsk;
1210#ifdef CONFIG_TCP_MD5SIG
1211 struct tcp_md5sig_key *key;
1212 int l3index;
1213#endif
1214 struct flowi6 fl6;
1215
1216 if (skb->protocol == htons(ETH_P_IP)) {
1217 /*
1218 * v6 mapped
1219 */
1220
1221 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst,
1222 req_unhash, own_req);
1223
1224 if (!newsk)
1225 return NULL;
1226
1227 inet_sk(newsk)->pinet6 = tcp_inet6_sk(newsk);
1228
1229 newnp = tcp_inet6_sk(newsk);
1230 newtp = tcp_sk(newsk);
1231
1232 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1233
1234 newnp->saddr = newsk->sk_v6_rcv_saddr;
1235
1236 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1237 if (sk_is_mptcp(newsk))
1238 mptcpv6_handle_mapped(newsk, true);
1239 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1240#ifdef CONFIG_TCP_MD5SIG
1241 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1242#endif
1243
1244 newnp->ipv6_mc_list = NULL;
1245 newnp->ipv6_ac_list = NULL;
1246 newnp->ipv6_fl_list = NULL;
1247 newnp->pktoptions = NULL;
1248 newnp->opt = NULL;
1249 newnp->mcast_oif = inet_iif(skb);
1250 newnp->mcast_hops = ip_hdr(skb)->ttl;
1251 newnp->rcv_flowinfo = 0;
1252 if (np->repflow)
1253 newnp->flow_label = 0;
1254
1255 /*
1256 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1257 * here, tcp_create_openreq_child now does this for us, see the comment in
1258 * that function for the gory details. -acme
1259 */
1260
1261 /* It is tricky place. Until this moment IPv4 tcp
1262 worked with IPv6 icsk.icsk_af_ops.
1263 Sync it now.
1264 */
1265 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1266
1267 return newsk;
1268 }
1269
1270 ireq = inet_rsk(req);
1271
1272 if (sk_acceptq_is_full(sk))
1273 goto out_overflow;
1274
1275 if (!dst) {
1276 dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_TCP);
1277 if (!dst)
1278 goto out;
1279 }
1280
1281 newsk = tcp_create_openreq_child(sk, req, skb);
1282 if (!newsk)
1283 goto out_nonewsk;
1284
1285 /*
1286 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1287 * count here, tcp_create_openreq_child now does this for us, see the
1288 * comment in that function for the gory details. -acme
1289 */
1290
1291 newsk->sk_gso_type = SKB_GSO_TCPV6;
1292 ip6_dst_store(newsk, dst, NULL, NULL);
1293 inet6_sk_rx_dst_set(newsk, skb);
1294
1295 inet_sk(newsk)->pinet6 = tcp_inet6_sk(newsk);
1296
1297 newtp = tcp_sk(newsk);
1298 newinet = inet_sk(newsk);
1299 newnp = tcp_inet6_sk(newsk);
1300
1301 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1302
1303 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1304 newnp->saddr = ireq->ir_v6_loc_addr;
1305 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1306 newsk->sk_bound_dev_if = ireq->ir_iif;
1307
1308 /* Now IPv6 options...
1309
1310 First: no IPv4 options.
1311 */
1312 newinet->inet_opt = NULL;
1313 newnp->ipv6_mc_list = NULL;
1314 newnp->ipv6_ac_list = NULL;
1315 newnp->ipv6_fl_list = NULL;
1316
1317 /* Clone RX bits */
1318 newnp->rxopt.all = np->rxopt.all;
1319
1320 newnp->pktoptions = NULL;
1321 newnp->opt = NULL;
1322 newnp->mcast_oif = tcp_v6_iif(skb);
1323 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1324 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
1325 if (np->repflow)
1326 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
1327
1328 /* Set ToS of the new socket based upon the value of incoming SYN.
1329 * ECT bits are set later in tcp_init_transfer().
1330 */
1331 if (READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_reflect_tos))
1332 newnp->tclass = tcp_rsk(req)->syn_tos & ~INET_ECN_MASK;
1333
1334 /* Clone native IPv6 options from listening socket (if any)
1335
1336 Yes, keeping reference count would be much more clever,
1337 but we make one more one thing there: reattach optmem
1338 to newsk.
1339 */
1340 opt = ireq->ipv6_opt;
1341 if (!opt)
1342 opt = rcu_dereference(np->opt);
1343 if (opt) {
1344 opt = ipv6_dup_options(newsk, opt);
1345 RCU_INIT_POINTER(newnp->opt, opt);
1346 }
1347 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1348 if (opt)
1349 inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +
1350 opt->opt_flen;
1351
1352 tcp_ca_openreq_child(newsk, dst);
1353
1354 tcp_sync_mss(newsk, dst_mtu(dst));
1355 newtp->advmss = tcp_mss_clamp(tcp_sk(sk), dst_metric_advmss(dst));
1356
1357 tcp_initialize_rcv_mss(newsk);
1358
1359 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1360 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
1361
1362#ifdef CONFIG_TCP_MD5SIG
1363 l3index = l3mdev_master_ifindex_by_index(sock_net(sk), ireq->ir_iif);
1364
1365 /* Copy over the MD5 key from the original socket */
1366 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr, l3index);
1367 if (key) {
1368 const union tcp_md5_addr *addr;
1369
1370 addr = (union tcp_md5_addr *)&newsk->sk_v6_daddr;
1371 if (tcp_md5_key_copy(newsk, addr, AF_INET6, 128, l3index, key)) {
1372 inet_csk_prepare_forced_close(newsk);
1373 tcp_done(newsk);
1374 goto out;
1375 }
1376 }
1377#endif
1378
1379 if (__inet_inherit_port(sk, newsk) < 0) {
1380 inet_csk_prepare_forced_close(newsk);
1381 tcp_done(newsk);
1382 goto out;
1383 }
1384 *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash),
1385 &found_dup_sk);
1386 if (*own_req) {
1387 tcp_move_syn(newtp, req);
1388
1389 /* Clone pktoptions received with SYN, if we own the req */
1390 if (ireq->pktopts) {
1391 newnp->pktoptions = skb_clone_and_charge_r(ireq->pktopts, newsk);
1392 consume_skb(ireq->pktopts);
1393 ireq->pktopts = NULL;
1394 if (newnp->pktoptions)
1395 tcp_v6_restore_cb(newnp->pktoptions);
1396 }
1397 } else {
1398 if (!req_unhash && found_dup_sk) {
1399 /* This code path should only be executed in the
1400 * syncookie case only
1401 */
1402 bh_unlock_sock(newsk);
1403 sock_put(newsk);
1404 newsk = NULL;
1405 }
1406 }
1407
1408 return newsk;
1409
1410out_overflow:
1411 __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1412out_nonewsk:
1413 dst_release(dst);
1414out:
1415 tcp_listendrop(sk);
1416 return NULL;
1417}
1418
1419INDIRECT_CALLABLE_DECLARE(struct dst_entry *ipv4_dst_check(struct dst_entry *,
1420 u32));
1421/* The socket must have it's spinlock held when we get
1422 * here, unless it is a TCP_LISTEN socket.
1423 *
1424 * We have a potential double-lock case here, so even when
1425 * doing backlog processing we use the BH locking scheme.
1426 * This is because we cannot sleep with the original spinlock
1427 * held.
1428 */
1429INDIRECT_CALLABLE_SCOPE
1430int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1431{
1432 struct ipv6_pinfo *np = tcp_inet6_sk(sk);
1433 struct sk_buff *opt_skb = NULL;
1434 enum skb_drop_reason reason;
1435 struct tcp_sock *tp;
1436
1437 /* Imagine: socket is IPv6. IPv4 packet arrives,
1438 goes to IPv4 receive handler and backlogged.
1439 From backlog it always goes here. Kerboom...
1440 Fortunately, tcp_rcv_established and rcv_established
1441 handle them correctly, but it is not case with
1442 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1443 */
1444
1445 if (skb->protocol == htons(ETH_P_IP))
1446 return tcp_v4_do_rcv(sk, skb);
1447
1448 /*
1449 * socket locking is here for SMP purposes as backlog rcv
1450 * is currently called with bh processing disabled.
1451 */
1452
1453 /* Do Stevens' IPV6_PKTOPTIONS.
1454
1455 Yes, guys, it is the only place in our code, where we
1456 may make it not affecting IPv4.
1457 The rest of code is protocol independent,
1458 and I do not like idea to uglify IPv4.
1459
1460 Actually, all the idea behind IPV6_PKTOPTIONS
1461 looks not very well thought. For now we latch
1462 options, received in the last packet, enqueued
1463 by tcp. Feel free to propose better solution.
1464 --ANK (980728)
1465 */
1466 if (np->rxopt.all)
1467 opt_skb = skb_clone_and_charge_r(skb, sk);
1468
1469 reason = SKB_DROP_REASON_NOT_SPECIFIED;
1470 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1471 struct dst_entry *dst;
1472
1473 dst = rcu_dereference_protected(sk->sk_rx_dst,
1474 lockdep_sock_is_held(sk));
1475
1476 sock_rps_save_rxhash(sk, skb);
1477 sk_mark_napi_id(sk, skb);
1478 if (dst) {
1479 if (sk->sk_rx_dst_ifindex != skb->skb_iif ||
1480 INDIRECT_CALL_1(dst->ops->check, ip6_dst_check,
1481 dst, sk->sk_rx_dst_cookie) == NULL) {
1482 RCU_INIT_POINTER(sk->sk_rx_dst, NULL);
1483 dst_release(dst);
1484 }
1485 }
1486
1487 tcp_rcv_established(sk, skb);
1488 if (opt_skb)
1489 goto ipv6_pktoptions;
1490 return 0;
1491 }
1492
1493 if (tcp_checksum_complete(skb))
1494 goto csum_err;
1495
1496 if (sk->sk_state == TCP_LISTEN) {
1497 struct sock *nsk = tcp_v6_cookie_check(sk, skb);
1498
1499 if (!nsk)
1500 goto discard;
1501
1502 if (nsk != sk) {
1503 if (tcp_child_process(sk, nsk, skb))
1504 goto reset;
1505 if (opt_skb)
1506 __kfree_skb(opt_skb);
1507 return 0;
1508 }
1509 } else
1510 sock_rps_save_rxhash(sk, skb);
1511
1512 if (tcp_rcv_state_process(sk, skb))
1513 goto reset;
1514 if (opt_skb)
1515 goto ipv6_pktoptions;
1516 return 0;
1517
1518reset:
1519 tcp_v6_send_reset(sk, skb);
1520discard:
1521 if (opt_skb)
1522 __kfree_skb(opt_skb);
1523 kfree_skb_reason(skb, reason);
1524 return 0;
1525csum_err:
1526 reason = SKB_DROP_REASON_TCP_CSUM;
1527 trace_tcp_bad_csum(skb);
1528 TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
1529 TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
1530 goto discard;
1531
1532
1533ipv6_pktoptions:
1534 /* Do you ask, what is it?
1535
1536 1. skb was enqueued by tcp.
1537 2. skb is added to tail of read queue, rather than out of order.
1538 3. socket is not in passive state.
1539 4. Finally, it really contains options, which user wants to receive.
1540 */
1541 tp = tcp_sk(sk);
1542 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1543 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1544 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
1545 np->mcast_oif = tcp_v6_iif(opt_skb);
1546 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1547 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1548 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
1549 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
1550 if (np->repflow)
1551 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
1552 if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) {
1553 tcp_v6_restore_cb(opt_skb);
1554 opt_skb = xchg(&np->pktoptions, opt_skb);
1555 } else {
1556 __kfree_skb(opt_skb);
1557 opt_skb = xchg(&np->pktoptions, NULL);
1558 }
1559 }
1560
1561 consume_skb(opt_skb);
1562 return 0;
1563}
1564
1565static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr,
1566 const struct tcphdr *th)
1567{
1568 /* This is tricky: we move IP6CB at its correct location into
1569 * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because
1570 * _decode_session6() uses IP6CB().
1571 * barrier() makes sure compiler won't play aliasing games.
1572 */
1573 memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
1574 sizeof(struct inet6_skb_parm));
1575 barrier();
1576
1577 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1578 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1579 skb->len - th->doff*4);
1580 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1581 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
1582 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
1583 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
1584 TCP_SKB_CB(skb)->sacked = 0;
1585 TCP_SKB_CB(skb)->has_rxtstamp =
1586 skb->tstamp || skb_hwtstamps(skb)->hwtstamp;
1587}
1588
1589INDIRECT_CALLABLE_SCOPE int tcp_v6_rcv(struct sk_buff *skb)
1590{
1591 enum skb_drop_reason drop_reason;
1592 int sdif = inet6_sdif(skb);
1593 int dif = inet6_iif(skb);
1594 const struct tcphdr *th;
1595 const struct ipv6hdr *hdr;
1596 bool refcounted;
1597 struct sock *sk;
1598 int ret;
1599 struct net *net = dev_net(skb->dev);
1600
1601 drop_reason = SKB_DROP_REASON_NOT_SPECIFIED;
1602 if (skb->pkt_type != PACKET_HOST)
1603 goto discard_it;
1604
1605 /*
1606 * Count it even if it's bad.
1607 */
1608 __TCP_INC_STATS(net, TCP_MIB_INSEGS);
1609
1610 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1611 goto discard_it;
1612
1613 th = (const struct tcphdr *)skb->data;
1614
1615 if (unlikely(th->doff < sizeof(struct tcphdr) / 4)) {
1616 drop_reason = SKB_DROP_REASON_PKT_TOO_SMALL;
1617 goto bad_packet;
1618 }
1619 if (!pskb_may_pull(skb, th->doff*4))
1620 goto discard_it;
1621
1622 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
1623 goto csum_error;
1624
1625 th = (const struct tcphdr *)skb->data;
1626 hdr = ipv6_hdr(skb);
1627
1628lookup:
1629 sk = __inet6_lookup_skb(net->ipv4.tcp_death_row.hashinfo, skb, __tcp_hdrlen(th),
1630 th->source, th->dest, inet6_iif(skb), sdif,
1631 &refcounted);
1632 if (!sk)
1633 goto no_tcp_socket;
1634
1635process:
1636 if (sk->sk_state == TCP_TIME_WAIT)
1637 goto do_time_wait;
1638
1639 if (sk->sk_state == TCP_NEW_SYN_RECV) {
1640 struct request_sock *req = inet_reqsk(sk);
1641 bool req_stolen = false;
1642 struct sock *nsk;
1643
1644 sk = req->rsk_listener;
1645 drop_reason = tcp_inbound_md5_hash(sk, skb,
1646 &hdr->saddr, &hdr->daddr,
1647 AF_INET6, dif, sdif);
1648 if (drop_reason) {
1649 sk_drops_add(sk, skb);
1650 reqsk_put(req);
1651 goto discard_it;
1652 }
1653 if (tcp_checksum_complete(skb)) {
1654 reqsk_put(req);
1655 goto csum_error;
1656 }
1657 if (unlikely(sk->sk_state != TCP_LISTEN)) {
1658 nsk = reuseport_migrate_sock(sk, req_to_sk(req), skb);
1659 if (!nsk) {
1660 inet_csk_reqsk_queue_drop_and_put(sk, req);
1661 goto lookup;
1662 }
1663 sk = nsk;
1664 /* reuseport_migrate_sock() has already held one sk_refcnt
1665 * before returning.
1666 */
1667 } else {
1668 sock_hold(sk);
1669 }
1670 refcounted = true;
1671 nsk = NULL;
1672 if (!tcp_filter(sk, skb)) {
1673 th = (const struct tcphdr *)skb->data;
1674 hdr = ipv6_hdr(skb);
1675 tcp_v6_fill_cb(skb, hdr, th);
1676 nsk = tcp_check_req(sk, skb, req, false, &req_stolen);
1677 } else {
1678 drop_reason = SKB_DROP_REASON_SOCKET_FILTER;
1679 }
1680 if (!nsk) {
1681 reqsk_put(req);
1682 if (req_stolen) {
1683 /* Another cpu got exclusive access to req
1684 * and created a full blown socket.
1685 * Try to feed this packet to this socket
1686 * instead of discarding it.
1687 */
1688 tcp_v6_restore_cb(skb);
1689 sock_put(sk);
1690 goto lookup;
1691 }
1692 goto discard_and_relse;
1693 }
1694 if (nsk == sk) {
1695 reqsk_put(req);
1696 tcp_v6_restore_cb(skb);
1697 } else if (tcp_child_process(sk, nsk, skb)) {
1698 tcp_v6_send_reset(nsk, skb);
1699 goto discard_and_relse;
1700 } else {
1701 sock_put(sk);
1702 return 0;
1703 }
1704 }
1705
1706 if (static_branch_unlikely(&ip6_min_hopcount)) {
1707 /* min_hopcount can be changed concurrently from do_ipv6_setsockopt() */
1708 if (hdr->hop_limit < READ_ONCE(tcp_inet6_sk(sk)->min_hopcount)) {
1709 __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
1710 goto discard_and_relse;
1711 }
1712 }
1713
1714 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) {
1715 drop_reason = SKB_DROP_REASON_XFRM_POLICY;
1716 goto discard_and_relse;
1717 }
1718
1719 drop_reason = tcp_inbound_md5_hash(sk, skb, &hdr->saddr, &hdr->daddr,
1720 AF_INET6, dif, sdif);
1721 if (drop_reason)
1722 goto discard_and_relse;
1723
1724 if (tcp_filter(sk, skb)) {
1725 drop_reason = SKB_DROP_REASON_SOCKET_FILTER;
1726 goto discard_and_relse;
1727 }
1728 th = (const struct tcphdr *)skb->data;
1729 hdr = ipv6_hdr(skb);
1730 tcp_v6_fill_cb(skb, hdr, th);
1731
1732 skb->dev = NULL;
1733
1734 if (sk->sk_state == TCP_LISTEN) {
1735 ret = tcp_v6_do_rcv(sk, skb);
1736 goto put_and_return;
1737 }
1738
1739 sk_incoming_cpu_update(sk);
1740
1741 bh_lock_sock_nested(sk);
1742 tcp_segs_in(tcp_sk(sk), skb);
1743 ret = 0;
1744 if (!sock_owned_by_user(sk)) {
1745 ret = tcp_v6_do_rcv(sk, skb);
1746 } else {
1747 if (tcp_add_backlog(sk, skb, &drop_reason))
1748 goto discard_and_relse;
1749 }
1750 bh_unlock_sock(sk);
1751put_and_return:
1752 if (refcounted)
1753 sock_put(sk);
1754 return ret ? -1 : 0;
1755
1756no_tcp_socket:
1757 drop_reason = SKB_DROP_REASON_NO_SOCKET;
1758 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1759 goto discard_it;
1760
1761 tcp_v6_fill_cb(skb, hdr, th);
1762
1763 if (tcp_checksum_complete(skb)) {
1764csum_error:
1765 drop_reason = SKB_DROP_REASON_TCP_CSUM;
1766 trace_tcp_bad_csum(skb);
1767 __TCP_INC_STATS(net, TCP_MIB_CSUMERRORS);
1768bad_packet:
1769 __TCP_INC_STATS(net, TCP_MIB_INERRS);
1770 } else {
1771 tcp_v6_send_reset(NULL, skb);
1772 }
1773
1774discard_it:
1775 SKB_DR_OR(drop_reason, NOT_SPECIFIED);
1776 kfree_skb_reason(skb, drop_reason);
1777 return 0;
1778
1779discard_and_relse:
1780 sk_drops_add(sk, skb);
1781 if (refcounted)
1782 sock_put(sk);
1783 goto discard_it;
1784
1785do_time_wait:
1786 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1787 drop_reason = SKB_DROP_REASON_XFRM_POLICY;
1788 inet_twsk_put(inet_twsk(sk));
1789 goto discard_it;
1790 }
1791
1792 tcp_v6_fill_cb(skb, hdr, th);
1793
1794 if (tcp_checksum_complete(skb)) {
1795 inet_twsk_put(inet_twsk(sk));
1796 goto csum_error;
1797 }
1798
1799 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1800 case TCP_TW_SYN:
1801 {
1802 struct sock *sk2;
1803
1804 sk2 = inet6_lookup_listener(net, net->ipv4.tcp_death_row.hashinfo,
1805 skb, __tcp_hdrlen(th),
1806 &ipv6_hdr(skb)->saddr, th->source,
1807 &ipv6_hdr(skb)->daddr,
1808 ntohs(th->dest),
1809 tcp_v6_iif_l3_slave(skb),
1810 sdif);
1811 if (sk2) {
1812 struct inet_timewait_sock *tw = inet_twsk(sk);
1813 inet_twsk_deschedule_put(tw);
1814 sk = sk2;
1815 tcp_v6_restore_cb(skb);
1816 refcounted = false;
1817 goto process;
1818 }
1819 }
1820 /* to ACK */
1821 fallthrough;
1822 case TCP_TW_ACK:
1823 tcp_v6_timewait_ack(sk, skb);
1824 break;
1825 case TCP_TW_RST:
1826 tcp_v6_send_reset(sk, skb);
1827 inet_twsk_deschedule_put(inet_twsk(sk));
1828 goto discard_it;
1829 case TCP_TW_SUCCESS:
1830 ;
1831 }
1832 goto discard_it;
1833}
1834
1835void tcp_v6_early_demux(struct sk_buff *skb)
1836{
1837 struct net *net = dev_net(skb->dev);
1838 const struct ipv6hdr *hdr;
1839 const struct tcphdr *th;
1840 struct sock *sk;
1841
1842 if (skb->pkt_type != PACKET_HOST)
1843 return;
1844
1845 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1846 return;
1847
1848 hdr = ipv6_hdr(skb);
1849 th = tcp_hdr(skb);
1850
1851 if (th->doff < sizeof(struct tcphdr) / 4)
1852 return;
1853
1854 /* Note : We use inet6_iif() here, not tcp_v6_iif() */
1855 sk = __inet6_lookup_established(net, net->ipv4.tcp_death_row.hashinfo,
1856 &hdr->saddr, th->source,
1857 &hdr->daddr, ntohs(th->dest),
1858 inet6_iif(skb), inet6_sdif(skb));
1859 if (sk) {
1860 skb->sk = sk;
1861 skb->destructor = sock_edemux;
1862 if (sk_fullsock(sk)) {
1863 struct dst_entry *dst = rcu_dereference(sk->sk_rx_dst);
1864
1865 if (dst)
1866 dst = dst_check(dst, sk->sk_rx_dst_cookie);
1867 if (dst &&
1868 sk->sk_rx_dst_ifindex == skb->skb_iif)
1869 skb_dst_set_noref(skb, dst);
1870 }
1871 }
1872}
1873
1874static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1875 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1876 .twsk_unique = tcp_twsk_unique,
1877 .twsk_destructor = tcp_twsk_destructor,
1878};
1879
1880INDIRECT_CALLABLE_SCOPE void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
1881{
1882 __tcp_v6_send_check(skb, &sk->sk_v6_rcv_saddr, &sk->sk_v6_daddr);
1883}
1884
1885const struct inet_connection_sock_af_ops ipv6_specific = {
1886 .queue_xmit = inet6_csk_xmit,
1887 .send_check = tcp_v6_send_check,
1888 .rebuild_header = inet6_sk_rebuild_header,
1889 .sk_rx_dst_set = inet6_sk_rx_dst_set,
1890 .conn_request = tcp_v6_conn_request,
1891 .syn_recv_sock = tcp_v6_syn_recv_sock,
1892 .net_header_len = sizeof(struct ipv6hdr),
1893 .net_frag_header_len = sizeof(struct frag_hdr),
1894 .setsockopt = ipv6_setsockopt,
1895 .getsockopt = ipv6_getsockopt,
1896 .addr2sockaddr = inet6_csk_addr2sockaddr,
1897 .sockaddr_len = sizeof(struct sockaddr_in6),
1898 .mtu_reduced = tcp_v6_mtu_reduced,
1899};
1900
1901#ifdef CONFIG_TCP_MD5SIG
1902static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
1903 .md5_lookup = tcp_v6_md5_lookup,
1904 .calc_md5_hash = tcp_v6_md5_hash_skb,
1905 .md5_parse = tcp_v6_parse_md5_keys,
1906};
1907#endif
1908
1909/*
1910 * TCP over IPv4 via INET6 API
1911 */
1912static const struct inet_connection_sock_af_ops ipv6_mapped = {
1913 .queue_xmit = ip_queue_xmit,
1914 .send_check = tcp_v4_send_check,
1915 .rebuild_header = inet_sk_rebuild_header,
1916 .sk_rx_dst_set = inet_sk_rx_dst_set,
1917 .conn_request = tcp_v6_conn_request,
1918 .syn_recv_sock = tcp_v6_syn_recv_sock,
1919 .net_header_len = sizeof(struct iphdr),
1920 .setsockopt = ipv6_setsockopt,
1921 .getsockopt = ipv6_getsockopt,
1922 .addr2sockaddr = inet6_csk_addr2sockaddr,
1923 .sockaddr_len = sizeof(struct sockaddr_in6),
1924 .mtu_reduced = tcp_v4_mtu_reduced,
1925};
1926
1927#ifdef CONFIG_TCP_MD5SIG
1928static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
1929 .md5_lookup = tcp_v4_md5_lookup,
1930 .calc_md5_hash = tcp_v4_md5_hash_skb,
1931 .md5_parse = tcp_v6_parse_md5_keys,
1932};
1933#endif
1934
1935/* NOTE: A lot of things set to zero explicitly by call to
1936 * sk_alloc() so need not be done here.
1937 */
1938static int tcp_v6_init_sock(struct sock *sk)
1939{
1940 struct inet_connection_sock *icsk = inet_csk(sk);
1941
1942 tcp_init_sock(sk);
1943
1944 icsk->icsk_af_ops = &ipv6_specific;
1945
1946#ifdef CONFIG_TCP_MD5SIG
1947 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
1948#endif
1949
1950 return 0;
1951}
1952
1953#ifdef CONFIG_PROC_FS
1954/* Proc filesystem TCPv6 sock list dumping. */
1955static void get_openreq6(struct seq_file *seq,
1956 const struct request_sock *req, int i)
1957{
1958 long ttd = req->rsk_timer.expires - jiffies;
1959 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1960 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
1961
1962 if (ttd < 0)
1963 ttd = 0;
1964
1965 seq_printf(seq,
1966 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1967 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
1968 i,
1969 src->s6_addr32[0], src->s6_addr32[1],
1970 src->s6_addr32[2], src->s6_addr32[3],
1971 inet_rsk(req)->ir_num,
1972 dest->s6_addr32[0], dest->s6_addr32[1],
1973 dest->s6_addr32[2], dest->s6_addr32[3],
1974 ntohs(inet_rsk(req)->ir_rmt_port),
1975 TCP_SYN_RECV,
1976 0, 0, /* could print option size, but that is af dependent. */
1977 1, /* timers active (only the expire timer) */
1978 jiffies_to_clock_t(ttd),
1979 req->num_timeout,
1980 from_kuid_munged(seq_user_ns(seq),
1981 sock_i_uid(req->rsk_listener)),
1982 0, /* non standard timer */
1983 0, /* open_requests have no inode */
1984 0, req);
1985}
1986
1987static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1988{
1989 const struct in6_addr *dest, *src;
1990 __u16 destp, srcp;
1991 int timer_active;
1992 unsigned long timer_expires;
1993 const struct inet_sock *inet = inet_sk(sp);
1994 const struct tcp_sock *tp = tcp_sk(sp);
1995 const struct inet_connection_sock *icsk = inet_csk(sp);
1996 const struct fastopen_queue *fastopenq = &icsk->icsk_accept_queue.fastopenq;
1997 int rx_queue;
1998 int state;
1999
2000 dest = &sp->sk_v6_daddr;
2001 src = &sp->sk_v6_rcv_saddr;
2002 destp = ntohs(inet->inet_dport);
2003 srcp = ntohs(inet->inet_sport);
2004
2005 if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
2006 icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
2007 icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
2008 timer_active = 1;
2009 timer_expires = icsk->icsk_timeout;
2010 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2011 timer_active = 4;
2012 timer_expires = icsk->icsk_timeout;
2013 } else if (timer_pending(&sp->sk_timer)) {
2014 timer_active = 2;
2015 timer_expires = sp->sk_timer.expires;
2016 } else {
2017 timer_active = 0;
2018 timer_expires = jiffies;
2019 }
2020
2021 state = inet_sk_state_load(sp);
2022 if (state == TCP_LISTEN)
2023 rx_queue = READ_ONCE(sp->sk_ack_backlog);
2024 else
2025 /* Because we don't lock the socket,
2026 * we might find a transient negative value.
2027 */
2028 rx_queue = max_t(int, READ_ONCE(tp->rcv_nxt) -
2029 READ_ONCE(tp->copied_seq), 0);
2030
2031 seq_printf(seq,
2032 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2033 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
2034 i,
2035 src->s6_addr32[0], src->s6_addr32[1],
2036 src->s6_addr32[2], src->s6_addr32[3], srcp,
2037 dest->s6_addr32[0], dest->s6_addr32[1],
2038 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2039 state,
2040 READ_ONCE(tp->write_seq) - tp->snd_una,
2041 rx_queue,
2042 timer_active,
2043 jiffies_delta_to_clock_t(timer_expires - jiffies),
2044 icsk->icsk_retransmits,
2045 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
2046 icsk->icsk_probes_out,
2047 sock_i_ino(sp),
2048 refcount_read(&sp->sk_refcnt), sp,
2049 jiffies_to_clock_t(icsk->icsk_rto),
2050 jiffies_to_clock_t(icsk->icsk_ack.ato),
2051 (icsk->icsk_ack.quick << 1) | inet_csk_in_pingpong_mode(sp),
2052 tcp_snd_cwnd(tp),
2053 state == TCP_LISTEN ?
2054 fastopenq->max_qlen :
2055 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
2056 );
2057}
2058
2059static void get_timewait6_sock(struct seq_file *seq,
2060 struct inet_timewait_sock *tw, int i)
2061{
2062 long delta = tw->tw_timer.expires - jiffies;
2063 const struct in6_addr *dest, *src;
2064 __u16 destp, srcp;
2065
2066 dest = &tw->tw_v6_daddr;
2067 src = &tw->tw_v6_rcv_saddr;
2068 destp = ntohs(tw->tw_dport);
2069 srcp = ntohs(tw->tw_sport);
2070
2071 seq_printf(seq,
2072 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2073 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
2074 i,
2075 src->s6_addr32[0], src->s6_addr32[1],
2076 src->s6_addr32[2], src->s6_addr32[3], srcp,
2077 dest->s6_addr32[0], dest->s6_addr32[1],
2078 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2079 tw->tw_substate, 0, 0,
2080 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
2081 refcount_read(&tw->tw_refcnt), tw);
2082}
2083
2084static int tcp6_seq_show(struct seq_file *seq, void *v)
2085{
2086 struct tcp_iter_state *st;
2087 struct sock *sk = v;
2088
2089 if (v == SEQ_START_TOKEN) {
2090 seq_puts(seq,
2091 " sl "
2092 "local_address "
2093 "remote_address "
2094 "st tx_queue rx_queue tr tm->when retrnsmt"
2095 " uid timeout inode\n");
2096 goto out;
2097 }
2098 st = seq->private;
2099
2100 if (sk->sk_state == TCP_TIME_WAIT)
2101 get_timewait6_sock(seq, v, st->num);
2102 else if (sk->sk_state == TCP_NEW_SYN_RECV)
2103 get_openreq6(seq, v, st->num);
2104 else
2105 get_tcp6_sock(seq, v, st->num);
2106out:
2107 return 0;
2108}
2109
2110static const struct seq_operations tcp6_seq_ops = {
2111 .show = tcp6_seq_show,
2112 .start = tcp_seq_start,
2113 .next = tcp_seq_next,
2114 .stop = tcp_seq_stop,
2115};
2116
2117static struct tcp_seq_afinfo tcp6_seq_afinfo = {
2118 .family = AF_INET6,
2119};
2120
2121int __net_init tcp6_proc_init(struct net *net)
2122{
2123 if (!proc_create_net_data("tcp6", 0444, net->proc_net, &tcp6_seq_ops,
2124 sizeof(struct tcp_iter_state), &tcp6_seq_afinfo))
2125 return -ENOMEM;
2126 return 0;
2127}
2128
2129void tcp6_proc_exit(struct net *net)
2130{
2131 remove_proc_entry("tcp6", net->proc_net);
2132}
2133#endif
2134
2135struct proto tcpv6_prot = {
2136 .name = "TCPv6",
2137 .owner = THIS_MODULE,
2138 .close = tcp_close,
2139 .pre_connect = tcp_v6_pre_connect,
2140 .connect = tcp_v6_connect,
2141 .disconnect = tcp_disconnect,
2142 .accept = inet_csk_accept,
2143 .ioctl = tcp_ioctl,
2144 .init = tcp_v6_init_sock,
2145 .destroy = tcp_v4_destroy_sock,
2146 .shutdown = tcp_shutdown,
2147 .setsockopt = tcp_setsockopt,
2148 .getsockopt = tcp_getsockopt,
2149 .bpf_bypass_getsockopt = tcp_bpf_bypass_getsockopt,
2150 .keepalive = tcp_set_keepalive,
2151 .recvmsg = tcp_recvmsg,
2152 .sendmsg = tcp_sendmsg,
2153 .sendpage = tcp_sendpage,
2154 .backlog_rcv = tcp_v6_do_rcv,
2155 .release_cb = tcp_release_cb,
2156 .hash = inet6_hash,
2157 .unhash = inet_unhash,
2158 .get_port = inet_csk_get_port,
2159 .put_port = inet_put_port,
2160#ifdef CONFIG_BPF_SYSCALL
2161 .psock_update_sk_prot = tcp_bpf_update_proto,
2162#endif
2163 .enter_memory_pressure = tcp_enter_memory_pressure,
2164 .leave_memory_pressure = tcp_leave_memory_pressure,
2165 .stream_memory_free = tcp_stream_memory_free,
2166 .sockets_allocated = &tcp_sockets_allocated,
2167
2168 .memory_allocated = &tcp_memory_allocated,
2169 .per_cpu_fw_alloc = &tcp_memory_per_cpu_fw_alloc,
2170
2171 .memory_pressure = &tcp_memory_pressure,
2172 .orphan_count = &tcp_orphan_count,
2173 .sysctl_mem = sysctl_tcp_mem,
2174 .sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_tcp_wmem),
2175 .sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_tcp_rmem),
2176 .max_header = MAX_TCP_HEADER,
2177 .obj_size = sizeof(struct tcp6_sock),
2178 .slab_flags = SLAB_TYPESAFE_BY_RCU,
2179 .twsk_prot = &tcp6_timewait_sock_ops,
2180 .rsk_prot = &tcp6_request_sock_ops,
2181 .h.hashinfo = NULL,
2182 .no_autobind = true,
2183 .diag_destroy = tcp_abort,
2184};
2185EXPORT_SYMBOL_GPL(tcpv6_prot);
2186
2187static const struct inet6_protocol tcpv6_protocol = {
2188 .handler = tcp_v6_rcv,
2189 .err_handler = tcp_v6_err,
2190 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2191};
2192
2193static struct inet_protosw tcpv6_protosw = {
2194 .type = SOCK_STREAM,
2195 .protocol = IPPROTO_TCP,
2196 .prot = &tcpv6_prot,
2197 .ops = &inet6_stream_ops,
2198 .flags = INET_PROTOSW_PERMANENT |
2199 INET_PROTOSW_ICSK,
2200};
2201
2202static int __net_init tcpv6_net_init(struct net *net)
2203{
2204 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2205 SOCK_RAW, IPPROTO_TCP, net);
2206}
2207
2208static void __net_exit tcpv6_net_exit(struct net *net)
2209{
2210 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
2211}
2212
2213static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
2214{
2215 tcp_twsk_purge(net_exit_list, AF_INET6);
2216}
2217
2218static struct pernet_operations tcpv6_net_ops = {
2219 .init = tcpv6_net_init,
2220 .exit = tcpv6_net_exit,
2221 .exit_batch = tcpv6_net_exit_batch,
2222};
2223
2224int __init tcpv6_init(void)
2225{
2226 int ret;
2227
2228 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2229 if (ret)
2230 goto out;
2231
2232 /* register inet6 protocol */
2233 ret = inet6_register_protosw(&tcpv6_protosw);
2234 if (ret)
2235 goto out_tcpv6_protocol;
2236
2237 ret = register_pernet_subsys(&tcpv6_net_ops);
2238 if (ret)
2239 goto out_tcpv6_protosw;
2240
2241 ret = mptcpv6_init();
2242 if (ret)
2243 goto out_tcpv6_pernet_subsys;
2244
2245out:
2246 return ret;
2247
2248out_tcpv6_pernet_subsys:
2249 unregister_pernet_subsys(&tcpv6_net_ops);
2250out_tcpv6_protosw:
2251 inet6_unregister_protosw(&tcpv6_protosw);
2252out_tcpv6_protocol:
2253 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2254 goto out;
2255}
2256
2257void tcpv6_exit(void)
2258{
2259 unregister_pernet_subsys(&tcpv6_net_ops);
2260 inet6_unregister_protosw(&tcpv6_protosw);
2261 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2262}