1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Linux INET6 implementation
7 * Pedro Roque <roque@di.fc.ul.pt>
10 * linux/net/ipv4/tcp.c
11 * linux/net/ipv4/tcp_input.c
12 * linux/net/ipv4/tcp_output.c
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.
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>
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>
45 #include <net/ndisc.h>
46 #include <net/inet6_hashtables.h>
47 #include <net/inet6_connection_sock.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>
57 #include <net/dsfield.h>
58 #include <net/timewait_sock.h>
59 #include <net/inet_common.h>
60 #include <net/secure_seq.h>
61 #include <net/busy_poll.h>
63 #include <linux/proc_fs.h>
64 #include <linux/seq_file.h>
66 #include <crypto/hash.h>
67 #include <linux/scatterlist.h>
69 #include <trace/events/tcp.h>
71 static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb);
72 static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
73 struct request_sock *req);
75 INDIRECT_CALLABLE_SCOPE int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
77 static const struct inet_connection_sock_af_ops ipv6_mapped;
78 const struct inet_connection_sock_af_ops ipv6_specific;
79 #ifdef CONFIG_TCP_MD5SIG
80 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
81 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
83 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk,
84 const struct in6_addr *addr,
91 /* Helper returning the inet6 address from a given tcp socket.
92 * It can be used in TCP stack instead of inet6_sk(sk).
93 * This avoids a dereference and allow compiler optimizations.
94 * It is a specialized version of inet6_sk_generic().
96 static struct ipv6_pinfo *tcp_inet6_sk(const struct sock *sk)
98 unsigned int offset = sizeof(struct tcp6_sock) - sizeof(struct ipv6_pinfo);
100 return (struct ipv6_pinfo *)(((u8 *)sk) + offset);
103 static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
105 struct dst_entry *dst = skb_dst(skb);
107 if (dst && dst_hold_safe(dst)) {
108 const struct rt6_info *rt = (const struct rt6_info *)dst;
110 rcu_assign_pointer(sk->sk_rx_dst, dst);
111 sk->sk_rx_dst_ifindex = skb->skb_iif;
112 sk->sk_rx_dst_cookie = rt6_get_cookie(rt);
116 static u32 tcp_v6_init_seq(const struct sk_buff *skb)
118 return secure_tcpv6_seq(ipv6_hdr(skb)->daddr.s6_addr32,
119 ipv6_hdr(skb)->saddr.s6_addr32,
121 tcp_hdr(skb)->source);
124 static u32 tcp_v6_init_ts_off(const struct net *net, const struct sk_buff *skb)
126 return secure_tcpv6_ts_off(net, ipv6_hdr(skb)->daddr.s6_addr32,
127 ipv6_hdr(skb)->saddr.s6_addr32);
130 static int tcp_v6_pre_connect(struct sock *sk, struct sockaddr *uaddr,
133 /* This check is replicated from tcp_v6_connect() and intended to
134 * prevent BPF program called below from accessing bytes that are out
135 * of the bound specified by user in addr_len.
137 if (addr_len < SIN6_LEN_RFC2133)
140 sock_owned_by_me(sk);
142 return BPF_CGROUP_RUN_PROG_INET6_CONNECT(sk, uaddr);
145 static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
148 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
149 struct inet_sock *inet = inet_sk(sk);
150 struct inet_connection_sock *icsk = inet_csk(sk);
151 struct inet_timewait_death_row *tcp_death_row;
152 struct ipv6_pinfo *np = tcp_inet6_sk(sk);
153 struct tcp_sock *tp = tcp_sk(sk);
154 struct in6_addr *saddr = NULL, *final_p, final;
155 struct ipv6_txoptions *opt;
157 struct dst_entry *dst;
161 if (addr_len < SIN6_LEN_RFC2133)
164 if (usin->sin6_family != AF_INET6)
165 return -EAFNOSUPPORT;
167 memset(&fl6, 0, sizeof(fl6));
170 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
171 IP6_ECN_flow_init(fl6.flowlabel);
172 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
173 struct ip6_flowlabel *flowlabel;
174 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
175 if (IS_ERR(flowlabel))
177 fl6_sock_release(flowlabel);
182 * connect() to INADDR_ANY means loopback (BSD'ism).
185 if (ipv6_addr_any(&usin->sin6_addr)) {
186 if (ipv6_addr_v4mapped(&sk->sk_v6_rcv_saddr))
187 ipv6_addr_set_v4mapped(htonl(INADDR_LOOPBACK),
190 usin->sin6_addr = in6addr_loopback;
193 addr_type = ipv6_addr_type(&usin->sin6_addr);
195 if (addr_type & IPV6_ADDR_MULTICAST)
198 if (addr_type&IPV6_ADDR_LINKLOCAL) {
199 if (addr_len >= sizeof(struct sockaddr_in6) &&
200 usin->sin6_scope_id) {
201 /* If interface is set while binding, indices
204 if (!sk_dev_equal_l3scope(sk, usin->sin6_scope_id))
207 sk->sk_bound_dev_if = usin->sin6_scope_id;
210 /* Connect to link-local address requires an interface */
211 if (!sk->sk_bound_dev_if)
215 if (tp->rx_opt.ts_recent_stamp &&
216 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
217 tp->rx_opt.ts_recent = 0;
218 tp->rx_opt.ts_recent_stamp = 0;
219 WRITE_ONCE(tp->write_seq, 0);
222 sk->sk_v6_daddr = usin->sin6_addr;
223 np->flow_label = fl6.flowlabel;
229 if (addr_type & IPV6_ADDR_MAPPED) {
230 u32 exthdrlen = icsk->icsk_ext_hdr_len;
231 struct sockaddr_in sin;
233 if (ipv6_only_sock(sk))
236 sin.sin_family = AF_INET;
237 sin.sin_port = usin->sin6_port;
238 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
240 icsk->icsk_af_ops = &ipv6_mapped;
242 mptcpv6_handle_mapped(sk, true);
243 sk->sk_backlog_rcv = tcp_v4_do_rcv;
244 #ifdef CONFIG_TCP_MD5SIG
245 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
248 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
251 icsk->icsk_ext_hdr_len = exthdrlen;
252 icsk->icsk_af_ops = &ipv6_specific;
254 mptcpv6_handle_mapped(sk, false);
255 sk->sk_backlog_rcv = tcp_v6_do_rcv;
256 #ifdef CONFIG_TCP_MD5SIG
257 tp->af_specific = &tcp_sock_ipv6_specific;
261 np->saddr = sk->sk_v6_rcv_saddr;
266 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
267 saddr = &sk->sk_v6_rcv_saddr;
269 fl6.flowi6_proto = IPPROTO_TCP;
270 fl6.daddr = sk->sk_v6_daddr;
271 fl6.saddr = saddr ? *saddr : np->saddr;
272 fl6.flowi6_oif = sk->sk_bound_dev_if;
273 fl6.flowi6_mark = sk->sk_mark;
274 fl6.fl6_dport = usin->sin6_port;
275 fl6.fl6_sport = inet->inet_sport;
276 fl6.flowi6_uid = sk->sk_uid;
278 opt = rcu_dereference_protected(np->opt, lockdep_sock_is_held(sk));
279 final_p = fl6_update_dst(&fl6, opt, &final);
281 security_sk_classify_flow(sk, flowi6_to_flowi_common(&fl6));
283 dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
291 sk->sk_v6_rcv_saddr = *saddr;
294 /* set the source address */
296 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
298 sk->sk_gso_type = SKB_GSO_TCPV6;
299 ip6_dst_store(sk, dst, NULL, NULL);
301 icsk->icsk_ext_hdr_len = 0;
303 icsk->icsk_ext_hdr_len = opt->opt_flen +
306 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
308 inet->inet_dport = usin->sin6_port;
310 tcp_set_state(sk, TCP_SYN_SENT);
311 tcp_death_row = sock_net(sk)->ipv4.tcp_death_row;
312 err = inet6_hash_connect(tcp_death_row, sk);
318 if (likely(!tp->repair)) {
320 WRITE_ONCE(tp->write_seq,
321 secure_tcpv6_seq(np->saddr.s6_addr32,
322 sk->sk_v6_daddr.s6_addr32,
325 tp->tsoffset = secure_tcpv6_ts_off(sock_net(sk),
327 sk->sk_v6_daddr.s6_addr32);
330 if (tcp_fastopen_defer_connect(sk, &err))
335 err = tcp_connect(sk);
342 tcp_set_state(sk, TCP_CLOSE);
344 inet->inet_dport = 0;
345 sk->sk_route_caps = 0;
349 static void tcp_v6_mtu_reduced(struct sock *sk)
351 struct dst_entry *dst;
354 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
357 mtu = READ_ONCE(tcp_sk(sk)->mtu_info);
359 /* Drop requests trying to increase our current mss.
360 * Check done in __ip6_rt_update_pmtu() is too late.
362 if (tcp_mtu_to_mss(sk, mtu) >= tcp_sk(sk)->mss_cache)
365 dst = inet6_csk_update_pmtu(sk, mtu);
369 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
370 tcp_sync_mss(sk, dst_mtu(dst));
371 tcp_simple_retransmit(sk);
375 static int tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
376 u8 type, u8 code, int offset, __be32 info)
378 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
379 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
380 struct net *net = dev_net(skb->dev);
381 struct request_sock *fastopen;
382 struct ipv6_pinfo *np;
389 sk = __inet6_lookup_established(net, &tcp_hashinfo,
390 &hdr->daddr, th->dest,
391 &hdr->saddr, ntohs(th->source),
392 skb->dev->ifindex, inet6_sdif(skb));
395 __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev),
400 if (sk->sk_state == TCP_TIME_WAIT) {
401 inet_twsk_put(inet_twsk(sk));
404 seq = ntohl(th->seq);
405 fatal = icmpv6_err_convert(type, code, &err);
406 if (sk->sk_state == TCP_NEW_SYN_RECV) {
407 tcp_req_err(sk, seq, fatal);
412 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
413 __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS);
415 if (sk->sk_state == TCP_CLOSE)
418 if (static_branch_unlikely(&ip6_min_hopcount)) {
419 /* min_hopcount can be changed concurrently from do_ipv6_setsockopt() */
420 if (ipv6_hdr(skb)->hop_limit < READ_ONCE(tcp_inet6_sk(sk)->min_hopcount)) {
421 __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
427 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
428 fastopen = rcu_dereference(tp->fastopen_rsk);
429 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
430 if (sk->sk_state != TCP_LISTEN &&
431 !between(seq, snd_una, tp->snd_nxt)) {
432 __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
436 np = tcp_inet6_sk(sk);
438 if (type == NDISC_REDIRECT) {
439 if (!sock_owned_by_user(sk)) {
440 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
443 dst->ops->redirect(dst, sk, skb);
448 if (type == ICMPV6_PKT_TOOBIG) {
449 u32 mtu = ntohl(info);
451 /* We are not interested in TCP_LISTEN and open_requests
452 * (SYN-ACKs send out by Linux are always <576bytes so
453 * they should go through unfragmented).
455 if (sk->sk_state == TCP_LISTEN)
458 if (!ip6_sk_accept_pmtu(sk))
461 if (mtu < IPV6_MIN_MTU)
464 WRITE_ONCE(tp->mtu_info, mtu);
466 if (!sock_owned_by_user(sk))
467 tcp_v6_mtu_reduced(sk);
468 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
475 /* Might be for an request_sock */
476 switch (sk->sk_state) {
479 /* Only in fast or simultaneous open. If a fast open socket is
480 * already accepted it is treated as a connected one below.
482 if (fastopen && !fastopen->sk)
485 ipv6_icmp_error(sk, skb, err, th->dest, ntohl(info), (u8 *)th);
487 if (!sock_owned_by_user(sk)) {
489 sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
493 sk->sk_err_soft = err;
498 /* check if this ICMP message allows revert of backoff.
501 if (!fastopen && type == ICMPV6_DEST_UNREACH &&
502 code == ICMPV6_NOROUTE)
503 tcp_ld_RTO_revert(sk, seq);
506 if (!sock_owned_by_user(sk) && np->recverr) {
510 sk->sk_err_soft = err;
519 static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst,
521 struct request_sock *req,
522 struct tcp_fastopen_cookie *foc,
523 enum tcp_synack_type synack_type,
524 struct sk_buff *syn_skb)
526 struct inet_request_sock *ireq = inet_rsk(req);
527 struct ipv6_pinfo *np = tcp_inet6_sk(sk);
528 struct ipv6_txoptions *opt;
529 struct flowi6 *fl6 = &fl->u.ip6;
534 /* First, grab a route. */
535 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req,
536 IPPROTO_TCP)) == NULL)
539 skb = tcp_make_synack(sk, dst, req, foc, synack_type, syn_skb);
542 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
543 &ireq->ir_v6_rmt_addr);
545 fl6->daddr = ireq->ir_v6_rmt_addr;
546 if (np->repflow && ireq->pktopts)
547 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
549 tclass = sock_net(sk)->ipv4.sysctl_tcp_reflect_tos ?
550 (tcp_rsk(req)->syn_tos & ~INET_ECN_MASK) |
551 (np->tclass & INET_ECN_MASK) :
554 if (!INET_ECN_is_capable(tclass) &&
555 tcp_bpf_ca_needs_ecn((struct sock *)req))
556 tclass |= INET_ECN_ECT_0;
559 opt = ireq->ipv6_opt;
561 opt = rcu_dereference(np->opt);
562 err = ip6_xmit(sk, skb, fl6, skb->mark ? : sk->sk_mark, opt,
563 tclass, sk->sk_priority);
565 err = net_xmit_eval(err);
573 static void tcp_v6_reqsk_destructor(struct request_sock *req)
575 kfree(inet_rsk(req)->ipv6_opt);
576 consume_skb(inet_rsk(req)->pktopts);
579 #ifdef CONFIG_TCP_MD5SIG
580 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk,
581 const struct in6_addr *addr,
584 return tcp_md5_do_lookup(sk, l3index,
585 (union tcp_md5_addr *)addr, AF_INET6);
588 static struct tcp_md5sig_key *tcp_v6_md5_lookup(const struct sock *sk,
589 const struct sock *addr_sk)
593 l3index = l3mdev_master_ifindex_by_index(sock_net(sk),
594 addr_sk->sk_bound_dev_if);
595 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr,
599 static int tcp_v6_parse_md5_keys(struct sock *sk, int optname,
600 sockptr_t optval, int optlen)
602 struct tcp_md5sig cmd;
603 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
608 if (optlen < sizeof(cmd))
611 if (copy_from_sockptr(&cmd, optval, sizeof(cmd)))
614 if (sin6->sin6_family != AF_INET6)
617 flags = cmd.tcpm_flags & TCP_MD5SIG_FLAG_IFINDEX;
619 if (optname == TCP_MD5SIG_EXT &&
620 cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) {
621 prefixlen = cmd.tcpm_prefixlen;
622 if (prefixlen > 128 || (ipv6_addr_v4mapped(&sin6->sin6_addr) &&
626 prefixlen = ipv6_addr_v4mapped(&sin6->sin6_addr) ? 32 : 128;
629 if (optname == TCP_MD5SIG_EXT && cmd.tcpm_ifindex &&
630 cmd.tcpm_flags & TCP_MD5SIG_FLAG_IFINDEX) {
631 struct net_device *dev;
634 dev = dev_get_by_index_rcu(sock_net(sk), cmd.tcpm_ifindex);
635 if (dev && netif_is_l3_master(dev))
636 l3index = dev->ifindex;
639 /* ok to reference set/not set outside of rcu;
640 * right now device MUST be an L3 master
642 if (!dev || !l3index)
646 if (!cmd.tcpm_keylen) {
647 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
648 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
651 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
652 AF_INET6, prefixlen, l3index, flags);
655 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
658 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
659 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
660 AF_INET, prefixlen, l3index, flags,
661 cmd.tcpm_key, cmd.tcpm_keylen,
664 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
665 AF_INET6, prefixlen, l3index, flags,
666 cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
669 static int tcp_v6_md5_hash_headers(struct tcp_md5sig_pool *hp,
670 const struct in6_addr *daddr,
671 const struct in6_addr *saddr,
672 const struct tcphdr *th, int nbytes)
674 struct tcp6_pseudohdr *bp;
675 struct scatterlist sg;
679 /* 1. TCP pseudo-header (RFC2460) */
682 bp->protocol = cpu_to_be32(IPPROTO_TCP);
683 bp->len = cpu_to_be32(nbytes);
685 _th = (struct tcphdr *)(bp + 1);
686 memcpy(_th, th, sizeof(*th));
689 sg_init_one(&sg, bp, sizeof(*bp) + sizeof(*th));
690 ahash_request_set_crypt(hp->md5_req, &sg, NULL,
691 sizeof(*bp) + sizeof(*th));
692 return crypto_ahash_update(hp->md5_req);
695 static int tcp_v6_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
696 const struct in6_addr *daddr, struct in6_addr *saddr,
697 const struct tcphdr *th)
699 struct tcp_md5sig_pool *hp;
700 struct ahash_request *req;
702 hp = tcp_get_md5sig_pool();
704 goto clear_hash_noput;
707 if (crypto_ahash_init(req))
709 if (tcp_v6_md5_hash_headers(hp, daddr, saddr, th, th->doff << 2))
711 if (tcp_md5_hash_key(hp, key))
713 ahash_request_set_crypt(req, NULL, md5_hash, 0);
714 if (crypto_ahash_final(req))
717 tcp_put_md5sig_pool();
721 tcp_put_md5sig_pool();
723 memset(md5_hash, 0, 16);
727 static int tcp_v6_md5_hash_skb(char *md5_hash,
728 const struct tcp_md5sig_key *key,
729 const struct sock *sk,
730 const struct sk_buff *skb)
732 const struct in6_addr *saddr, *daddr;
733 struct tcp_md5sig_pool *hp;
734 struct ahash_request *req;
735 const struct tcphdr *th = tcp_hdr(skb);
737 if (sk) { /* valid for establish/request sockets */
738 saddr = &sk->sk_v6_rcv_saddr;
739 daddr = &sk->sk_v6_daddr;
741 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
742 saddr = &ip6h->saddr;
743 daddr = &ip6h->daddr;
746 hp = tcp_get_md5sig_pool();
748 goto clear_hash_noput;
751 if (crypto_ahash_init(req))
754 if (tcp_v6_md5_hash_headers(hp, daddr, saddr, th, skb->len))
756 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
758 if (tcp_md5_hash_key(hp, key))
760 ahash_request_set_crypt(req, NULL, md5_hash, 0);
761 if (crypto_ahash_final(req))
764 tcp_put_md5sig_pool();
768 tcp_put_md5sig_pool();
770 memset(md5_hash, 0, 16);
776 static void tcp_v6_init_req(struct request_sock *req,
777 const struct sock *sk_listener,
780 bool l3_slave = ipv6_l3mdev_skb(TCP_SKB_CB(skb)->header.h6.flags);
781 struct inet_request_sock *ireq = inet_rsk(req);
782 const struct ipv6_pinfo *np = tcp_inet6_sk(sk_listener);
784 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
785 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
787 /* So that link locals have meaning */
788 if ((!sk_listener->sk_bound_dev_if || l3_slave) &&
789 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
790 ireq->ir_iif = tcp_v6_iif(skb);
792 if (!TCP_SKB_CB(skb)->tcp_tw_isn &&
793 (ipv6_opt_accepted(sk_listener, skb, &TCP_SKB_CB(skb)->header.h6) ||
794 np->rxopt.bits.rxinfo ||
795 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
796 np->rxopt.bits.rxohlim || np->repflow)) {
797 refcount_inc(&skb->users);
802 static struct dst_entry *tcp_v6_route_req(const struct sock *sk,
805 struct request_sock *req)
807 tcp_v6_init_req(req, sk, skb);
809 if (security_inet_conn_request(sk, skb, req))
812 return inet6_csk_route_req(sk, &fl->u.ip6, req, IPPROTO_TCP);
815 struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
817 .obj_size = sizeof(struct tcp6_request_sock),
818 .rtx_syn_ack = tcp_rtx_synack,
819 .send_ack = tcp_v6_reqsk_send_ack,
820 .destructor = tcp_v6_reqsk_destructor,
821 .send_reset = tcp_v6_send_reset,
822 .syn_ack_timeout = tcp_syn_ack_timeout,
825 const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
826 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) -
827 sizeof(struct ipv6hdr),
828 #ifdef CONFIG_TCP_MD5SIG
829 .req_md5_lookup = tcp_v6_md5_lookup,
830 .calc_md5_hash = tcp_v6_md5_hash_skb,
832 #ifdef CONFIG_SYN_COOKIES
833 .cookie_init_seq = cookie_v6_init_sequence,
835 .route_req = tcp_v6_route_req,
836 .init_seq = tcp_v6_init_seq,
837 .init_ts_off = tcp_v6_init_ts_off,
838 .send_synack = tcp_v6_send_synack,
841 static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 seq,
842 u32 ack, u32 win, u32 tsval, u32 tsecr,
843 int oif, struct tcp_md5sig_key *key, int rst,
844 u8 tclass, __be32 label, u32 priority)
846 const struct tcphdr *th = tcp_hdr(skb);
848 struct sk_buff *buff;
850 struct net *net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
851 struct sock *ctl_sk = net->ipv6.tcp_sk;
852 unsigned int tot_len = sizeof(struct tcphdr);
853 __be32 mrst = 0, *topt;
854 struct dst_entry *dst;
858 tot_len += TCPOLEN_TSTAMP_ALIGNED;
859 #ifdef CONFIG_TCP_MD5SIG
861 tot_len += TCPOLEN_MD5SIG_ALIGNED;
866 mrst = mptcp_reset_option(skb);
869 tot_len += sizeof(__be32);
873 buff = alloc_skb(MAX_TCP_HEADER, GFP_ATOMIC);
877 skb_reserve(buff, MAX_TCP_HEADER);
879 t1 = skb_push(buff, tot_len);
880 skb_reset_transport_header(buff);
882 /* Swap the send and the receive. */
883 memset(t1, 0, sizeof(*t1));
884 t1->dest = th->source;
885 t1->source = th->dest;
886 t1->doff = tot_len / 4;
887 t1->seq = htonl(seq);
888 t1->ack_seq = htonl(ack);
889 t1->ack = !rst || !th->ack;
891 t1->window = htons(win);
893 topt = (__be32 *)(t1 + 1);
896 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
897 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
898 *topt++ = htonl(tsval);
899 *topt++ = htonl(tsecr);
905 #ifdef CONFIG_TCP_MD5SIG
907 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
908 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
909 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
910 &ipv6_hdr(skb)->saddr,
911 &ipv6_hdr(skb)->daddr, t1);
915 memset(&fl6, 0, sizeof(fl6));
916 fl6.daddr = ipv6_hdr(skb)->saddr;
917 fl6.saddr = ipv6_hdr(skb)->daddr;
918 fl6.flowlabel = label;
920 buff->ip_summed = CHECKSUM_PARTIAL;
922 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
924 fl6.flowi6_proto = IPPROTO_TCP;
925 if (rt6_need_strict(&fl6.daddr) && !oif)
926 fl6.flowi6_oif = tcp_v6_iif(skb);
928 if (!oif && netif_index_is_l3_master(net, skb->skb_iif))
931 fl6.flowi6_oif = oif;
935 if (sk->sk_state == TCP_TIME_WAIT) {
936 mark = inet_twsk(sk)->tw_mark;
937 /* autoflowlabel relies on buff->hash */
938 skb_set_hash(buff, inet_twsk(sk)->tw_txhash,
943 skb_set_delivery_time(buff, tcp_transmit_time(sk), true);
945 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark) ?: mark;
946 fl6.fl6_dport = t1->dest;
947 fl6.fl6_sport = t1->source;
948 fl6.flowi6_uid = sock_net_uid(net, sk && sk_fullsock(sk) ? sk : NULL);
949 security_skb_classify_flow(skb, flowi6_to_flowi_common(&fl6));
951 /* Pass a socket to ip6_dst_lookup either it is for RST
952 * Underlying function will use this to retrieve the network
955 dst = ip6_dst_lookup_flow(sock_net(ctl_sk), ctl_sk, &fl6, NULL);
957 skb_dst_set(buff, dst);
958 ip6_xmit(ctl_sk, buff, &fl6, fl6.flowi6_mark, NULL,
959 tclass & ~INET_ECN_MASK, priority);
960 TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
962 TCP_INC_STATS(net, TCP_MIB_OUTRSTS);
969 static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb)
971 const struct tcphdr *th = tcp_hdr(skb);
972 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
973 u32 seq = 0, ack_seq = 0;
974 struct tcp_md5sig_key *key = NULL;
975 #ifdef CONFIG_TCP_MD5SIG
976 const __u8 *hash_location = NULL;
977 unsigned char newhash[16];
979 struct sock *sk1 = NULL;
989 /* If sk not NULL, it means we did a successful lookup and incoming
990 * route had to be correct. prequeue might have dropped our dst.
992 if (!sk && !ipv6_unicast_destination(skb))
995 net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
996 #ifdef CONFIG_TCP_MD5SIG
998 hash_location = tcp_parse_md5sig_option(th);
999 if (sk && sk_fullsock(sk)) {
1002 /* sdif set, means packet ingressed via a device
1003 * in an L3 domain and inet_iif is set to it.
1005 l3index = tcp_v6_sdif(skb) ? tcp_v6_iif_l3_slave(skb) : 0;
1006 key = tcp_v6_md5_do_lookup(sk, &ipv6h->saddr, l3index);
1007 } else if (hash_location) {
1008 int dif = tcp_v6_iif_l3_slave(skb);
1009 int sdif = tcp_v6_sdif(skb);
1013 * active side is lost. Try to find listening socket through
1014 * source port, and then find md5 key through listening socket.
1015 * we are not loose security here:
1016 * Incoming packet is checked with md5 hash with finding key,
1017 * no RST generated if md5 hash doesn't match.
1019 sk1 = inet6_lookup_listener(net,
1020 &tcp_hashinfo, NULL, 0,
1022 th->source, &ipv6h->daddr,
1023 ntohs(th->source), dif, sdif);
1027 /* sdif set, means packet ingressed via a device
1028 * in an L3 domain and dif is set to it.
1030 l3index = tcp_v6_sdif(skb) ? dif : 0;
1032 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr, l3index);
1036 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, skb);
1037 if (genhash || memcmp(hash_location, newhash, 16) != 0)
1043 seq = ntohl(th->ack_seq);
1045 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
1049 oif = sk->sk_bound_dev_if;
1050 if (sk_fullsock(sk)) {
1051 const struct ipv6_pinfo *np = tcp_inet6_sk(sk);
1053 trace_tcp_send_reset(sk, skb);
1055 label = ip6_flowlabel(ipv6h);
1056 priority = sk->sk_priority;
1058 if (sk->sk_state == TCP_TIME_WAIT) {
1059 label = cpu_to_be32(inet_twsk(sk)->tw_flowlabel);
1060 priority = inet_twsk(sk)->tw_priority;
1063 if (net->ipv6.sysctl.flowlabel_reflect & FLOWLABEL_REFLECT_TCP_RESET)
1064 label = ip6_flowlabel(ipv6h);
1067 tcp_v6_send_response(sk, skb, seq, ack_seq, 0, 0, 0, oif, key, 1,
1068 ipv6_get_dsfield(ipv6h), label, priority);
1070 #ifdef CONFIG_TCP_MD5SIG
1076 static void tcp_v6_send_ack(const struct sock *sk, struct sk_buff *skb, u32 seq,
1077 u32 ack, u32 win, u32 tsval, u32 tsecr, int oif,
1078 struct tcp_md5sig_key *key, u8 tclass,
1079 __be32 label, u32 priority)
1081 tcp_v6_send_response(sk, skb, seq, ack, win, tsval, tsecr, oif, key, 0,
1082 tclass, label, priority);
1085 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1087 struct inet_timewait_sock *tw = inet_twsk(sk);
1088 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1090 tcp_v6_send_ack(sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
1091 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
1092 tcp_time_stamp_raw() + tcptw->tw_ts_offset,
1093 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
1094 tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel), tw->tw_priority);
1099 static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
1100 struct request_sock *req)
1104 l3index = tcp_v6_sdif(skb) ? tcp_v6_iif_l3_slave(skb) : 0;
1106 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
1107 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
1110 * The window field (SEG.WND) of every outgoing segment, with the
1111 * exception of <SYN> segments, MUST be right-shifted by
1112 * Rcv.Wind.Shift bits:
1114 tcp_v6_send_ack(sk, skb, (sk->sk_state == TCP_LISTEN) ?
1115 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
1116 tcp_rsk(req)->rcv_nxt,
1117 req->rsk_rcv_wnd >> inet_rsk(req)->rcv_wscale,
1118 tcp_time_stamp_raw() + tcp_rsk(req)->ts_off,
1119 req->ts_recent, sk->sk_bound_dev_if,
1120 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->saddr, l3index),
1121 ipv6_get_dsfield(ipv6_hdr(skb)), 0, sk->sk_priority);
1125 static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb)
1127 #ifdef CONFIG_SYN_COOKIES
1128 const struct tcphdr *th = tcp_hdr(skb);
1131 sk = cookie_v6_check(sk, skb);
1136 u16 tcp_v6_get_syncookie(struct sock *sk, struct ipv6hdr *iph,
1137 struct tcphdr *th, u32 *cookie)
1140 #ifdef CONFIG_SYN_COOKIES
1141 mss = tcp_get_syncookie_mss(&tcp6_request_sock_ops,
1142 &tcp_request_sock_ipv6_ops, sk, th);
1144 *cookie = __cookie_v6_init_sequence(iph, th, &mss);
1145 tcp_synq_overflow(sk);
1151 static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1153 if (skb->protocol == htons(ETH_P_IP))
1154 return tcp_v4_conn_request(sk, skb);
1156 if (!ipv6_unicast_destination(skb))
1159 if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
1160 __IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
1164 return tcp_conn_request(&tcp6_request_sock_ops,
1165 &tcp_request_sock_ipv6_ops, sk, skb);
1169 return 0; /* don't send reset */
1172 static void tcp_v6_restore_cb(struct sk_buff *skb)
1174 /* We need to move header back to the beginning if xfrm6_policy_check()
1175 * and tcp_v6_fill_cb() are going to be called again.
1176 * ip6_datagram_recv_specific_ctl() also expects IP6CB to be there.
1178 memmove(IP6CB(skb), &TCP_SKB_CB(skb)->header.h6,
1179 sizeof(struct inet6_skb_parm));
1182 static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
1183 struct request_sock *req,
1184 struct dst_entry *dst,
1185 struct request_sock *req_unhash,
1188 struct inet_request_sock *ireq;
1189 struct ipv6_pinfo *newnp;
1190 const struct ipv6_pinfo *np = tcp_inet6_sk(sk);
1191 struct ipv6_txoptions *opt;
1192 struct inet_sock *newinet;
1193 bool found_dup_sk = false;
1194 struct tcp_sock *newtp;
1196 #ifdef CONFIG_TCP_MD5SIG
1197 struct tcp_md5sig_key *key;
1202 if (skb->protocol == htons(ETH_P_IP)) {
1207 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst,
1208 req_unhash, own_req);
1213 inet_sk(newsk)->pinet6 = tcp_inet6_sk(newsk);
1215 newnp = tcp_inet6_sk(newsk);
1216 newtp = tcp_sk(newsk);
1218 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1220 newnp->saddr = newsk->sk_v6_rcv_saddr;
1222 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1223 if (sk_is_mptcp(newsk))
1224 mptcpv6_handle_mapped(newsk, true);
1225 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1226 #ifdef CONFIG_TCP_MD5SIG
1227 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1230 newnp->ipv6_mc_list = NULL;
1231 newnp->ipv6_ac_list = NULL;
1232 newnp->ipv6_fl_list = NULL;
1233 newnp->pktoptions = NULL;
1235 newnp->mcast_oif = inet_iif(skb);
1236 newnp->mcast_hops = ip_hdr(skb)->ttl;
1237 newnp->rcv_flowinfo = 0;
1239 newnp->flow_label = 0;
1242 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1243 * here, tcp_create_openreq_child now does this for us, see the comment in
1244 * that function for the gory details. -acme
1247 /* It is tricky place. Until this moment IPv4 tcp
1248 worked with IPv6 icsk.icsk_af_ops.
1251 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1256 ireq = inet_rsk(req);
1258 if (sk_acceptq_is_full(sk))
1262 dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_TCP);
1267 newsk = tcp_create_openreq_child(sk, req, skb);
1272 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1273 * count here, tcp_create_openreq_child now does this for us, see the
1274 * comment in that function for the gory details. -acme
1277 newsk->sk_gso_type = SKB_GSO_TCPV6;
1278 ip6_dst_store(newsk, dst, NULL, NULL);
1279 inet6_sk_rx_dst_set(newsk, skb);
1281 inet_sk(newsk)->pinet6 = tcp_inet6_sk(newsk);
1283 newtp = tcp_sk(newsk);
1284 newinet = inet_sk(newsk);
1285 newnp = tcp_inet6_sk(newsk);
1287 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1289 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1290 newnp->saddr = ireq->ir_v6_loc_addr;
1291 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1292 newsk->sk_bound_dev_if = ireq->ir_iif;
1294 /* Now IPv6 options...
1296 First: no IPv4 options.
1298 newinet->inet_opt = NULL;
1299 newnp->ipv6_mc_list = NULL;
1300 newnp->ipv6_ac_list = NULL;
1301 newnp->ipv6_fl_list = NULL;
1304 newnp->rxopt.all = np->rxopt.all;
1306 newnp->pktoptions = NULL;
1308 newnp->mcast_oif = tcp_v6_iif(skb);
1309 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1310 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
1312 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
1314 /* Set ToS of the new socket based upon the value of incoming SYN.
1315 * ECT bits are set later in tcp_init_transfer().
1317 if (sock_net(sk)->ipv4.sysctl_tcp_reflect_tos)
1318 newnp->tclass = tcp_rsk(req)->syn_tos & ~INET_ECN_MASK;
1320 /* Clone native IPv6 options from listening socket (if any)
1322 Yes, keeping reference count would be much more clever,
1323 but we make one more one thing there: reattach optmem
1326 opt = ireq->ipv6_opt;
1328 opt = rcu_dereference(np->opt);
1330 opt = ipv6_dup_options(newsk, opt);
1331 RCU_INIT_POINTER(newnp->opt, opt);
1333 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1335 inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +
1338 tcp_ca_openreq_child(newsk, dst);
1340 tcp_sync_mss(newsk, dst_mtu(dst));
1341 newtp->advmss = tcp_mss_clamp(tcp_sk(sk), dst_metric_advmss(dst));
1343 tcp_initialize_rcv_mss(newsk);
1345 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1346 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
1348 #ifdef CONFIG_TCP_MD5SIG
1349 l3index = l3mdev_master_ifindex_by_index(sock_net(sk), ireq->ir_iif);
1351 /* Copy over the MD5 key from the original socket */
1352 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr, l3index);
1354 /* We're using one, so create a matching key
1355 * on the newsk structure. If we fail to get
1356 * memory, then we end up not copying the key
1359 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
1360 AF_INET6, 128, l3index, key->flags, key->key, key->keylen,
1361 sk_gfp_mask(sk, GFP_ATOMIC));
1365 if (__inet_inherit_port(sk, newsk) < 0) {
1366 inet_csk_prepare_forced_close(newsk);
1370 *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash),
1373 tcp_move_syn(newtp, req);
1375 /* Clone pktoptions received with SYN, if we own the req */
1376 if (ireq->pktopts) {
1377 newnp->pktoptions = skb_clone(ireq->pktopts,
1378 sk_gfp_mask(sk, GFP_ATOMIC));
1379 consume_skb(ireq->pktopts);
1380 ireq->pktopts = NULL;
1381 if (newnp->pktoptions) {
1382 tcp_v6_restore_cb(newnp->pktoptions);
1383 skb_set_owner_r(newnp->pktoptions, newsk);
1387 if (!req_unhash && found_dup_sk) {
1388 /* This code path should only be executed in the
1389 * syncookie case only
1391 bh_unlock_sock(newsk);
1400 __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1408 INDIRECT_CALLABLE_DECLARE(struct dst_entry *ipv4_dst_check(struct dst_entry *,
1410 /* The socket must have it's spinlock held when we get
1411 * here, unless it is a TCP_LISTEN socket.
1413 * We have a potential double-lock case here, so even when
1414 * doing backlog processing we use the BH locking scheme.
1415 * This is because we cannot sleep with the original spinlock
1418 INDIRECT_CALLABLE_SCOPE
1419 int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1421 struct ipv6_pinfo *np = tcp_inet6_sk(sk);
1422 struct sk_buff *opt_skb = NULL;
1423 enum skb_drop_reason reason;
1424 struct tcp_sock *tp;
1426 /* Imagine: socket is IPv6. IPv4 packet arrives,
1427 goes to IPv4 receive handler and backlogged.
1428 From backlog it always goes here. Kerboom...
1429 Fortunately, tcp_rcv_established and rcv_established
1430 handle them correctly, but it is not case with
1431 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1434 if (skb->protocol == htons(ETH_P_IP))
1435 return tcp_v4_do_rcv(sk, skb);
1438 * socket locking is here for SMP purposes as backlog rcv
1439 * is currently called with bh processing disabled.
1442 /* Do Stevens' IPV6_PKTOPTIONS.
1444 Yes, guys, it is the only place in our code, where we
1445 may make it not affecting IPv4.
1446 The rest of code is protocol independent,
1447 and I do not like idea to uglify IPv4.
1449 Actually, all the idea behind IPV6_PKTOPTIONS
1450 looks not very well thought. For now we latch
1451 options, received in the last packet, enqueued
1452 by tcp. Feel free to propose better solution.
1456 opt_skb = skb_clone(skb, sk_gfp_mask(sk, GFP_ATOMIC));
1458 reason = SKB_DROP_REASON_NOT_SPECIFIED;
1459 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1460 struct dst_entry *dst;
1462 dst = rcu_dereference_protected(sk->sk_rx_dst,
1463 lockdep_sock_is_held(sk));
1465 sock_rps_save_rxhash(sk, skb);
1466 sk_mark_napi_id(sk, skb);
1468 if (sk->sk_rx_dst_ifindex != skb->skb_iif ||
1469 INDIRECT_CALL_1(dst->ops->check, ip6_dst_check,
1470 dst, sk->sk_rx_dst_cookie) == NULL) {
1471 RCU_INIT_POINTER(sk->sk_rx_dst, NULL);
1476 tcp_rcv_established(sk, skb);
1478 goto ipv6_pktoptions;
1482 if (tcp_checksum_complete(skb))
1485 if (sk->sk_state == TCP_LISTEN) {
1486 struct sock *nsk = tcp_v6_cookie_check(sk, skb);
1492 if (tcp_child_process(sk, nsk, skb))
1495 __kfree_skb(opt_skb);
1499 sock_rps_save_rxhash(sk, skb);
1501 if (tcp_rcv_state_process(sk, skb))
1504 goto ipv6_pktoptions;
1508 tcp_v6_send_reset(sk, skb);
1511 __kfree_skb(opt_skb);
1512 kfree_skb_reason(skb, reason);
1515 reason = SKB_DROP_REASON_TCP_CSUM;
1516 trace_tcp_bad_csum(skb);
1517 TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
1518 TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
1523 /* Do you ask, what is it?
1525 1. skb was enqueued by tcp.
1526 2. skb is added to tail of read queue, rather than out of order.
1527 3. socket is not in passive state.
1528 4. Finally, it really contains options, which user wants to receive.
1531 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1532 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1533 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
1534 np->mcast_oif = tcp_v6_iif(opt_skb);
1535 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1536 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1537 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
1538 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
1540 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
1541 if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) {
1542 skb_set_owner_r(opt_skb, sk);
1543 tcp_v6_restore_cb(opt_skb);
1544 opt_skb = xchg(&np->pktoptions, opt_skb);
1546 __kfree_skb(opt_skb);
1547 opt_skb = xchg(&np->pktoptions, NULL);
1551 consume_skb(opt_skb);
1555 static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr,
1556 const struct tcphdr *th)
1558 /* This is tricky: we move IP6CB at its correct location into
1559 * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because
1560 * _decode_session6() uses IP6CB().
1561 * barrier() makes sure compiler won't play aliasing games.
1563 memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
1564 sizeof(struct inet6_skb_parm));
1567 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1568 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1569 skb->len - th->doff*4);
1570 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1571 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
1572 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
1573 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
1574 TCP_SKB_CB(skb)->sacked = 0;
1575 TCP_SKB_CB(skb)->has_rxtstamp =
1576 skb->tstamp || skb_hwtstamps(skb)->hwtstamp;
1579 INDIRECT_CALLABLE_SCOPE int tcp_v6_rcv(struct sk_buff *skb)
1581 enum skb_drop_reason drop_reason;
1582 int sdif = inet6_sdif(skb);
1583 int dif = inet6_iif(skb);
1584 const struct tcphdr *th;
1585 const struct ipv6hdr *hdr;
1589 struct net *net = dev_net(skb->dev);
1591 drop_reason = SKB_DROP_REASON_NOT_SPECIFIED;
1592 if (skb->pkt_type != PACKET_HOST)
1596 * Count it even if it's bad.
1598 __TCP_INC_STATS(net, TCP_MIB_INSEGS);
1600 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1603 th = (const struct tcphdr *)skb->data;
1605 if (unlikely(th->doff < sizeof(struct tcphdr) / 4)) {
1606 drop_reason = SKB_DROP_REASON_PKT_TOO_SMALL;
1609 if (!pskb_may_pull(skb, th->doff*4))
1612 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
1615 th = (const struct tcphdr *)skb->data;
1616 hdr = ipv6_hdr(skb);
1619 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th),
1620 th->source, th->dest, inet6_iif(skb), sdif,
1626 if (sk->sk_state == TCP_TIME_WAIT)
1629 if (sk->sk_state == TCP_NEW_SYN_RECV) {
1630 struct request_sock *req = inet_reqsk(sk);
1631 bool req_stolen = false;
1634 sk = req->rsk_listener;
1635 drop_reason = tcp_inbound_md5_hash(sk, skb,
1636 &hdr->saddr, &hdr->daddr,
1637 AF_INET6, dif, sdif);
1639 sk_drops_add(sk, skb);
1643 if (tcp_checksum_complete(skb)) {
1647 if (unlikely(sk->sk_state != TCP_LISTEN)) {
1648 nsk = reuseport_migrate_sock(sk, req_to_sk(req), skb);
1650 inet_csk_reqsk_queue_drop_and_put(sk, req);
1654 /* reuseport_migrate_sock() has already held one sk_refcnt
1662 if (!tcp_filter(sk, skb)) {
1663 th = (const struct tcphdr *)skb->data;
1664 hdr = ipv6_hdr(skb);
1665 tcp_v6_fill_cb(skb, hdr, th);
1666 nsk = tcp_check_req(sk, skb, req, false, &req_stolen);
1668 drop_reason = SKB_DROP_REASON_SOCKET_FILTER;
1673 /* Another cpu got exclusive access to req
1674 * and created a full blown socket.
1675 * Try to feed this packet to this socket
1676 * instead of discarding it.
1678 tcp_v6_restore_cb(skb);
1682 goto discard_and_relse;
1686 tcp_v6_restore_cb(skb);
1687 } else if (tcp_child_process(sk, nsk, skb)) {
1688 tcp_v6_send_reset(nsk, skb);
1689 goto discard_and_relse;
1696 if (static_branch_unlikely(&ip6_min_hopcount)) {
1697 /* min_hopcount can be changed concurrently from do_ipv6_setsockopt() */
1698 if (hdr->hop_limit < READ_ONCE(tcp_inet6_sk(sk)->min_hopcount)) {
1699 __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
1700 goto discard_and_relse;
1704 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) {
1705 drop_reason = SKB_DROP_REASON_XFRM_POLICY;
1706 goto discard_and_relse;
1709 drop_reason = tcp_inbound_md5_hash(sk, skb, &hdr->saddr, &hdr->daddr,
1710 AF_INET6, dif, sdif);
1712 goto discard_and_relse;
1714 if (tcp_filter(sk, skb)) {
1715 drop_reason = SKB_DROP_REASON_SOCKET_FILTER;
1716 goto discard_and_relse;
1718 th = (const struct tcphdr *)skb->data;
1719 hdr = ipv6_hdr(skb);
1720 tcp_v6_fill_cb(skb, hdr, th);
1724 if (sk->sk_state == TCP_LISTEN) {
1725 ret = tcp_v6_do_rcv(sk, skb);
1726 goto put_and_return;
1729 sk_incoming_cpu_update(sk);
1731 bh_lock_sock_nested(sk);
1732 tcp_segs_in(tcp_sk(sk), skb);
1734 if (!sock_owned_by_user(sk)) {
1735 ret = tcp_v6_do_rcv(sk, skb);
1737 if (tcp_add_backlog(sk, skb, &drop_reason))
1738 goto discard_and_relse;
1744 return ret ? -1 : 0;
1747 drop_reason = SKB_DROP_REASON_NO_SOCKET;
1748 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1751 tcp_v6_fill_cb(skb, hdr, th);
1753 if (tcp_checksum_complete(skb)) {
1755 drop_reason = SKB_DROP_REASON_TCP_CSUM;
1756 trace_tcp_bad_csum(skb);
1757 __TCP_INC_STATS(net, TCP_MIB_CSUMERRORS);
1759 __TCP_INC_STATS(net, TCP_MIB_INERRS);
1761 tcp_v6_send_reset(NULL, skb);
1765 SKB_DR_OR(drop_reason, NOT_SPECIFIED);
1766 kfree_skb_reason(skb, drop_reason);
1770 sk_drops_add(sk, skb);
1776 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1777 drop_reason = SKB_DROP_REASON_XFRM_POLICY;
1778 inet_twsk_put(inet_twsk(sk));
1782 tcp_v6_fill_cb(skb, hdr, th);
1784 if (tcp_checksum_complete(skb)) {
1785 inet_twsk_put(inet_twsk(sk));
1789 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1794 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
1795 skb, __tcp_hdrlen(th),
1796 &ipv6_hdr(skb)->saddr, th->source,
1797 &ipv6_hdr(skb)->daddr,
1799 tcp_v6_iif_l3_slave(skb),
1802 struct inet_timewait_sock *tw = inet_twsk(sk);
1803 inet_twsk_deschedule_put(tw);
1805 tcp_v6_restore_cb(skb);
1813 tcp_v6_timewait_ack(sk, skb);
1816 tcp_v6_send_reset(sk, skb);
1817 inet_twsk_deschedule_put(inet_twsk(sk));
1819 case TCP_TW_SUCCESS:
1825 INDIRECT_CALLABLE_SCOPE void tcp_v6_early_demux(struct sk_buff *skb)
1827 const struct ipv6hdr *hdr;
1828 const struct tcphdr *th;
1831 if (skb->pkt_type != PACKET_HOST)
1834 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1837 hdr = ipv6_hdr(skb);
1840 if (th->doff < sizeof(struct tcphdr) / 4)
1843 /* Note : We use inet6_iif() here, not tcp_v6_iif() */
1844 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1845 &hdr->saddr, th->source,
1846 &hdr->daddr, ntohs(th->dest),
1847 inet6_iif(skb), inet6_sdif(skb));
1850 skb->destructor = sock_edemux;
1851 if (sk_fullsock(sk)) {
1852 struct dst_entry *dst = rcu_dereference(sk->sk_rx_dst);
1855 dst = dst_check(dst, sk->sk_rx_dst_cookie);
1857 sk->sk_rx_dst_ifindex == skb->skb_iif)
1858 skb_dst_set_noref(skb, dst);
1863 static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1864 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1865 .twsk_unique = tcp_twsk_unique,
1866 .twsk_destructor = tcp_twsk_destructor,
1869 INDIRECT_CALLABLE_SCOPE void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
1871 __tcp_v6_send_check(skb, &sk->sk_v6_rcv_saddr, &sk->sk_v6_daddr);
1874 const struct inet_connection_sock_af_ops ipv6_specific = {
1875 .queue_xmit = inet6_csk_xmit,
1876 .send_check = tcp_v6_send_check,
1877 .rebuild_header = inet6_sk_rebuild_header,
1878 .sk_rx_dst_set = inet6_sk_rx_dst_set,
1879 .conn_request = tcp_v6_conn_request,
1880 .syn_recv_sock = tcp_v6_syn_recv_sock,
1881 .net_header_len = sizeof(struct ipv6hdr),
1882 .net_frag_header_len = sizeof(struct frag_hdr),
1883 .setsockopt = ipv6_setsockopt,
1884 .getsockopt = ipv6_getsockopt,
1885 .addr2sockaddr = inet6_csk_addr2sockaddr,
1886 .sockaddr_len = sizeof(struct sockaddr_in6),
1887 .mtu_reduced = tcp_v6_mtu_reduced,
1890 #ifdef CONFIG_TCP_MD5SIG
1891 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
1892 .md5_lookup = tcp_v6_md5_lookup,
1893 .calc_md5_hash = tcp_v6_md5_hash_skb,
1894 .md5_parse = tcp_v6_parse_md5_keys,
1899 * TCP over IPv4 via INET6 API
1901 static const struct inet_connection_sock_af_ops ipv6_mapped = {
1902 .queue_xmit = ip_queue_xmit,
1903 .send_check = tcp_v4_send_check,
1904 .rebuild_header = inet_sk_rebuild_header,
1905 .sk_rx_dst_set = inet_sk_rx_dst_set,
1906 .conn_request = tcp_v6_conn_request,
1907 .syn_recv_sock = tcp_v6_syn_recv_sock,
1908 .net_header_len = sizeof(struct iphdr),
1909 .setsockopt = ipv6_setsockopt,
1910 .getsockopt = ipv6_getsockopt,
1911 .addr2sockaddr = inet6_csk_addr2sockaddr,
1912 .sockaddr_len = sizeof(struct sockaddr_in6),
1913 .mtu_reduced = tcp_v4_mtu_reduced,
1916 #ifdef CONFIG_TCP_MD5SIG
1917 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
1918 .md5_lookup = tcp_v4_md5_lookup,
1919 .calc_md5_hash = tcp_v4_md5_hash_skb,
1920 .md5_parse = tcp_v6_parse_md5_keys,
1924 /* NOTE: A lot of things set to zero explicitly by call to
1925 * sk_alloc() so need not be done here.
1927 static int tcp_v6_init_sock(struct sock *sk)
1929 struct inet_connection_sock *icsk = inet_csk(sk);
1933 icsk->icsk_af_ops = &ipv6_specific;
1935 #ifdef CONFIG_TCP_MD5SIG
1936 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
1942 static void tcp_v6_destroy_sock(struct sock *sk)
1944 tcp_v4_destroy_sock(sk);
1945 inet6_destroy_sock(sk);
1948 #ifdef CONFIG_PROC_FS
1949 /* Proc filesystem TCPv6 sock list dumping. */
1950 static void get_openreq6(struct seq_file *seq,
1951 const struct request_sock *req, int i)
1953 long ttd = req->rsk_timer.expires - jiffies;
1954 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1955 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
1961 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1962 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
1964 src->s6_addr32[0], src->s6_addr32[1],
1965 src->s6_addr32[2], src->s6_addr32[3],
1966 inet_rsk(req)->ir_num,
1967 dest->s6_addr32[0], dest->s6_addr32[1],
1968 dest->s6_addr32[2], dest->s6_addr32[3],
1969 ntohs(inet_rsk(req)->ir_rmt_port),
1971 0, 0, /* could print option size, but that is af dependent. */
1972 1, /* timers active (only the expire timer) */
1973 jiffies_to_clock_t(ttd),
1975 from_kuid_munged(seq_user_ns(seq),
1976 sock_i_uid(req->rsk_listener)),
1977 0, /* non standard timer */
1978 0, /* open_requests have no inode */
1982 static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1984 const struct in6_addr *dest, *src;
1987 unsigned long timer_expires;
1988 const struct inet_sock *inet = inet_sk(sp);
1989 const struct tcp_sock *tp = tcp_sk(sp);
1990 const struct inet_connection_sock *icsk = inet_csk(sp);
1991 const struct fastopen_queue *fastopenq = &icsk->icsk_accept_queue.fastopenq;
1995 dest = &sp->sk_v6_daddr;
1996 src = &sp->sk_v6_rcv_saddr;
1997 destp = ntohs(inet->inet_dport);
1998 srcp = ntohs(inet->inet_sport);
2000 if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
2001 icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
2002 icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
2004 timer_expires = icsk->icsk_timeout;
2005 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2007 timer_expires = icsk->icsk_timeout;
2008 } else if (timer_pending(&sp->sk_timer)) {
2010 timer_expires = sp->sk_timer.expires;
2013 timer_expires = jiffies;
2016 state = inet_sk_state_load(sp);
2017 if (state == TCP_LISTEN)
2018 rx_queue = READ_ONCE(sp->sk_ack_backlog);
2020 /* Because we don't lock the socket,
2021 * we might find a transient negative value.
2023 rx_queue = max_t(int, READ_ONCE(tp->rcv_nxt) -
2024 READ_ONCE(tp->copied_seq), 0);
2027 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2028 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
2030 src->s6_addr32[0], src->s6_addr32[1],
2031 src->s6_addr32[2], src->s6_addr32[3], srcp,
2032 dest->s6_addr32[0], dest->s6_addr32[1],
2033 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2035 READ_ONCE(tp->write_seq) - tp->snd_una,
2038 jiffies_delta_to_clock_t(timer_expires - jiffies),
2039 icsk->icsk_retransmits,
2040 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
2041 icsk->icsk_probes_out,
2043 refcount_read(&sp->sk_refcnt), sp,
2044 jiffies_to_clock_t(icsk->icsk_rto),
2045 jiffies_to_clock_t(icsk->icsk_ack.ato),
2046 (icsk->icsk_ack.quick << 1) | inet_csk_in_pingpong_mode(sp),
2048 state == TCP_LISTEN ?
2049 fastopenq->max_qlen :
2050 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
2054 static void get_timewait6_sock(struct seq_file *seq,
2055 struct inet_timewait_sock *tw, int i)
2057 long delta = tw->tw_timer.expires - jiffies;
2058 const struct in6_addr *dest, *src;
2061 dest = &tw->tw_v6_daddr;
2062 src = &tw->tw_v6_rcv_saddr;
2063 destp = ntohs(tw->tw_dport);
2064 srcp = ntohs(tw->tw_sport);
2067 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2068 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
2070 src->s6_addr32[0], src->s6_addr32[1],
2071 src->s6_addr32[2], src->s6_addr32[3], srcp,
2072 dest->s6_addr32[0], dest->s6_addr32[1],
2073 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2074 tw->tw_substate, 0, 0,
2075 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
2076 refcount_read(&tw->tw_refcnt), tw);
2079 static int tcp6_seq_show(struct seq_file *seq, void *v)
2081 struct tcp_iter_state *st;
2082 struct sock *sk = v;
2084 if (v == SEQ_START_TOKEN) {
2089 "st tx_queue rx_queue tr tm->when retrnsmt"
2090 " uid timeout inode\n");
2095 if (sk->sk_state == TCP_TIME_WAIT)
2096 get_timewait6_sock(seq, v, st->num);
2097 else if (sk->sk_state == TCP_NEW_SYN_RECV)
2098 get_openreq6(seq, v, st->num);
2100 get_tcp6_sock(seq, v, st->num);
2105 static const struct seq_operations tcp6_seq_ops = {
2106 .show = tcp6_seq_show,
2107 .start = tcp_seq_start,
2108 .next = tcp_seq_next,
2109 .stop = tcp_seq_stop,
2112 static struct tcp_seq_afinfo tcp6_seq_afinfo = {
2116 int __net_init tcp6_proc_init(struct net *net)
2118 if (!proc_create_net_data("tcp6", 0444, net->proc_net, &tcp6_seq_ops,
2119 sizeof(struct tcp_iter_state), &tcp6_seq_afinfo))
2124 void tcp6_proc_exit(struct net *net)
2126 remove_proc_entry("tcp6", net->proc_net);
2130 struct proto tcpv6_prot = {
2132 .owner = THIS_MODULE,
2134 .pre_connect = tcp_v6_pre_connect,
2135 .connect = tcp_v6_connect,
2136 .disconnect = tcp_disconnect,
2137 .accept = inet_csk_accept,
2139 .init = tcp_v6_init_sock,
2140 .destroy = tcp_v6_destroy_sock,
2141 .shutdown = tcp_shutdown,
2142 .setsockopt = tcp_setsockopt,
2143 .getsockopt = tcp_getsockopt,
2144 .bpf_bypass_getsockopt = tcp_bpf_bypass_getsockopt,
2145 .keepalive = tcp_set_keepalive,
2146 .recvmsg = tcp_recvmsg,
2147 .sendmsg = tcp_sendmsg,
2148 .sendpage = tcp_sendpage,
2149 .backlog_rcv = tcp_v6_do_rcv,
2150 .release_cb = tcp_release_cb,
2152 .unhash = inet_unhash,
2153 .get_port = inet_csk_get_port,
2154 .put_port = inet_put_port,
2155 #ifdef CONFIG_BPF_SYSCALL
2156 .psock_update_sk_prot = tcp_bpf_update_proto,
2158 .enter_memory_pressure = tcp_enter_memory_pressure,
2159 .leave_memory_pressure = tcp_leave_memory_pressure,
2160 .stream_memory_free = tcp_stream_memory_free,
2161 .sockets_allocated = &tcp_sockets_allocated,
2162 .memory_allocated = &tcp_memory_allocated,
2163 .memory_pressure = &tcp_memory_pressure,
2164 .orphan_count = &tcp_orphan_count,
2165 .sysctl_mem = sysctl_tcp_mem,
2166 .sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_tcp_wmem),
2167 .sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_tcp_rmem),
2168 .max_header = MAX_TCP_HEADER,
2169 .obj_size = sizeof(struct tcp6_sock),
2170 .slab_flags = SLAB_TYPESAFE_BY_RCU,
2171 .twsk_prot = &tcp6_timewait_sock_ops,
2172 .rsk_prot = &tcp6_request_sock_ops,
2173 .h.hashinfo = &tcp_hashinfo,
2174 .no_autobind = true,
2175 .diag_destroy = tcp_abort,
2177 EXPORT_SYMBOL_GPL(tcpv6_prot);
2179 /* thinking of making this const? Don't.
2180 * early_demux can change based on sysctl.
2182 static struct inet6_protocol tcpv6_protocol = {
2183 .early_demux = tcp_v6_early_demux,
2184 .early_demux_handler = tcp_v6_early_demux,
2185 .handler = tcp_v6_rcv,
2186 .err_handler = tcp_v6_err,
2187 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2190 static struct inet_protosw tcpv6_protosw = {
2191 .type = SOCK_STREAM,
2192 .protocol = IPPROTO_TCP,
2193 .prot = &tcpv6_prot,
2194 .ops = &inet6_stream_ops,
2195 .flags = INET_PROTOSW_PERMANENT |
2199 static int __net_init tcpv6_net_init(struct net *net)
2201 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2202 SOCK_RAW, IPPROTO_TCP, net);
2205 static void __net_exit tcpv6_net_exit(struct net *net)
2207 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
2210 static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
2212 inet_twsk_purge(&tcp_hashinfo, AF_INET6);
2215 static struct pernet_operations tcpv6_net_ops = {
2216 .init = tcpv6_net_init,
2217 .exit = tcpv6_net_exit,
2218 .exit_batch = tcpv6_net_exit_batch,
2221 int __init tcpv6_init(void)
2225 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2229 /* register inet6 protocol */
2230 ret = inet6_register_protosw(&tcpv6_protosw);
2232 goto out_tcpv6_protocol;
2234 ret = register_pernet_subsys(&tcpv6_net_ops);
2236 goto out_tcpv6_protosw;
2238 ret = mptcpv6_init();
2240 goto out_tcpv6_pernet_subsys;
2245 out_tcpv6_pernet_subsys:
2246 unregister_pernet_subsys(&tcpv6_net_ops);
2248 inet6_unregister_protosw(&tcpv6_protosw);
2250 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2254 void tcpv6_exit(void)
2256 unregister_pernet_subsys(&tcpv6_net_ops);
2257 inet6_unregister_protosw(&tcpv6_protosw);
2258 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);