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