3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
10 * linux/net/ipv4/tcp_input.c
11 * linux/net/ipv4/tcp_output.c
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.
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.
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>
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>
43 #include <linux/ipv6.h>
44 #include <linux/icmpv6.h>
45 #include <linux/random.h>
48 #include <net/ndisc.h>
49 #include <net/inet6_hashtables.h>
50 #include <net/inet6_connection_sock.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>
60 #include <net/dsfield.h>
61 #include <net/timewait_sock.h>
62 #include <net/netdma.h>
63 #include <net/inet_common.h>
65 #include <asm/uaccess.h>
67 #include <linux/proc_fs.h>
68 #include <linux/seq_file.h>
70 #include <linux/crypto.h>
71 #include <linux/scatterlist.h>
73 static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
74 static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
75 struct request_sock *req);
77 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
78 static void __tcp_v6_send_check(struct sk_buff *skb,
79 const struct in6_addr *saddr,
80 const struct in6_addr *daddr);
82 static const struct inet_connection_sock_af_ops ipv6_mapped;
83 static const struct inet_connection_sock_af_ops ipv6_specific;
84 #ifdef CONFIG_TCP_MD5SIG
85 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
86 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
88 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
89 const struct in6_addr *addr)
95 static void tcp_v6_hash(struct sock *sk)
97 if (sk->sk_state != TCP_CLOSE) {
98 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
103 __inet6_hash(sk, NULL);
108 static __inline__ __sum16 tcp_v6_check(int len,
109 const struct in6_addr *saddr,
110 const struct in6_addr *daddr,
113 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
116 static __u32 tcp_v6_init_sequence(struct sk_buff *skb)
118 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
119 ipv6_hdr(skb)->saddr.s6_addr32,
121 tcp_hdr(skb)->source);
124 static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
127 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
128 struct inet_sock *inet = inet_sk(sk);
129 struct inet_connection_sock *icsk = inet_csk(sk);
130 struct ipv6_pinfo *np = inet6_sk(sk);
131 struct tcp_sock *tp = tcp_sk(sk);
132 struct in6_addr *saddr = NULL, *final_p, final;
135 struct dst_entry *dst;
139 if (addr_len < SIN6_LEN_RFC2133)
142 if (usin->sin6_family != AF_INET6)
143 return -EAFNOSUPPORT;
145 memset(&fl6, 0, sizeof(fl6));
148 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
149 IP6_ECN_flow_init(fl6.flowlabel);
150 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
151 struct ip6_flowlabel *flowlabel;
152 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
153 if (flowlabel == NULL)
155 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
156 fl6_sock_release(flowlabel);
161 * connect() to INADDR_ANY means loopback (BSD'ism).
164 if(ipv6_addr_any(&usin->sin6_addr))
165 usin->sin6_addr.s6_addr[15] = 0x1;
167 addr_type = ipv6_addr_type(&usin->sin6_addr);
169 if(addr_type & IPV6_ADDR_MULTICAST)
172 if (addr_type&IPV6_ADDR_LINKLOCAL) {
173 if (addr_len >= sizeof(struct sockaddr_in6) &&
174 usin->sin6_scope_id) {
175 /* If interface is set while binding, indices
178 if (sk->sk_bound_dev_if &&
179 sk->sk_bound_dev_if != usin->sin6_scope_id)
182 sk->sk_bound_dev_if = usin->sin6_scope_id;
185 /* Connect to link-local address requires an interface */
186 if (!sk->sk_bound_dev_if)
190 if (tp->rx_opt.ts_recent_stamp &&
191 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
192 tp->rx_opt.ts_recent = 0;
193 tp->rx_opt.ts_recent_stamp = 0;
197 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
198 np->flow_label = fl6.flowlabel;
204 if (addr_type == IPV6_ADDR_MAPPED) {
205 u32 exthdrlen = icsk->icsk_ext_hdr_len;
206 struct sockaddr_in sin;
208 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
210 if (__ipv6_only_sock(sk))
213 sin.sin_family = AF_INET;
214 sin.sin_port = usin->sin6_port;
215 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
217 icsk->icsk_af_ops = &ipv6_mapped;
218 sk->sk_backlog_rcv = tcp_v4_do_rcv;
219 #ifdef CONFIG_TCP_MD5SIG
220 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
223 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
226 icsk->icsk_ext_hdr_len = exthdrlen;
227 icsk->icsk_af_ops = &ipv6_specific;
228 sk->sk_backlog_rcv = tcp_v6_do_rcv;
229 #ifdef CONFIG_TCP_MD5SIG
230 tp->af_specific = &tcp_sock_ipv6_specific;
234 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
235 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
242 if (!ipv6_addr_any(&np->rcv_saddr))
243 saddr = &np->rcv_saddr;
245 fl6.flowi6_proto = IPPROTO_TCP;
246 ipv6_addr_copy(&fl6.daddr, &np->daddr);
247 ipv6_addr_copy(&fl6.saddr,
248 (saddr ? saddr : &np->saddr));
249 fl6.flowi6_oif = sk->sk_bound_dev_if;
250 fl6.flowi6_mark = sk->sk_mark;
251 fl6.fl6_dport = usin->sin6_port;
252 fl6.fl6_sport = inet->inet_sport;
254 final_p = fl6_update_dst(&fl6, np->opt, &final);
256 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
258 dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
266 ipv6_addr_copy(&np->rcv_saddr, saddr);
269 /* set the source address */
270 ipv6_addr_copy(&np->saddr, saddr);
271 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
273 sk->sk_gso_type = SKB_GSO_TCPV6;
274 __ip6_dst_store(sk, dst, NULL, NULL);
276 rt = (struct rt6_info *) dst;
277 if (tcp_death_row.sysctl_tw_recycle &&
278 !tp->rx_opt.ts_recent_stamp &&
279 ipv6_addr_equal(&rt->rt6i_dst.addr, &np->daddr)) {
280 struct inet_peer *peer = rt6_get_peer(rt);
282 * VJ's idea. We save last timestamp seen from
283 * the destination in peer table, when entering state
284 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
285 * when trying new connection.
288 inet_peer_refcheck(peer);
289 if ((u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) {
290 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
291 tp->rx_opt.ts_recent = peer->tcp_ts;
296 icsk->icsk_ext_hdr_len = 0;
298 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
301 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
303 inet->inet_dport = usin->sin6_port;
305 tcp_set_state(sk, TCP_SYN_SENT);
306 err = inet6_hash_connect(&tcp_death_row, sk);
311 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
316 err = tcp_connect(sk);
323 tcp_set_state(sk, TCP_CLOSE);
326 inet->inet_dport = 0;
327 sk->sk_route_caps = 0;
331 static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
332 u8 type, u8 code, int offset, __be32 info)
334 const struct ipv6hdr *hdr = (const struct ipv6hdr*)skb->data;
335 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
336 struct ipv6_pinfo *np;
341 struct net *net = dev_net(skb->dev);
343 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
344 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
347 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
352 if (sk->sk_state == TCP_TIME_WAIT) {
353 inet_twsk_put(inet_twsk(sk));
358 if (sock_owned_by_user(sk))
359 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
361 if (sk->sk_state == TCP_CLOSE)
364 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
365 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
370 seq = ntohl(th->seq);
371 if (sk->sk_state != TCP_LISTEN &&
372 !between(seq, tp->snd_una, tp->snd_nxt)) {
373 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
379 if (type == ICMPV6_PKT_TOOBIG) {
380 struct dst_entry *dst;
382 if (sock_owned_by_user(sk))
384 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
387 /* icmp should have updated the destination cache entry */
388 dst = __sk_dst_check(sk, np->dst_cookie);
391 struct inet_sock *inet = inet_sk(sk);
394 /* BUGGG_FUTURE: Again, it is not clear how
395 to handle rthdr case. Ignore this complexity
398 memset(&fl6, 0, sizeof(fl6));
399 fl6.flowi6_proto = IPPROTO_TCP;
400 ipv6_addr_copy(&fl6.daddr, &np->daddr);
401 ipv6_addr_copy(&fl6.saddr, &np->saddr);
402 fl6.flowi6_oif = sk->sk_bound_dev_if;
403 fl6.flowi6_mark = sk->sk_mark;
404 fl6.fl6_dport = inet->inet_dport;
405 fl6.fl6_sport = inet->inet_sport;
406 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
408 dst = ip6_dst_lookup_flow(sk, &fl6, NULL, false);
410 sk->sk_err_soft = -PTR_ERR(dst);
417 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
418 tcp_sync_mss(sk, dst_mtu(dst));
419 tcp_simple_retransmit(sk);
420 } /* else let the usual retransmit timer handle it */
425 icmpv6_err_convert(type, code, &err);
427 /* Might be for an request_sock */
428 switch (sk->sk_state) {
429 struct request_sock *req, **prev;
431 if (sock_owned_by_user(sk))
434 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
435 &hdr->saddr, inet6_iif(skb));
439 /* ICMPs are not backlogged, hence we cannot get
440 * an established socket here.
442 WARN_ON(req->sk != NULL);
444 if (seq != tcp_rsk(req)->snt_isn) {
445 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
449 inet_csk_reqsk_queue_drop(sk, req, prev);
453 case TCP_SYN_RECV: /* Cannot happen.
454 It can, it SYNs are crossed. --ANK */
455 if (!sock_owned_by_user(sk)) {
457 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
461 sk->sk_err_soft = err;
465 if (!sock_owned_by_user(sk) && np->recverr) {
467 sk->sk_error_report(sk);
469 sk->sk_err_soft = err;
477 static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
478 struct request_values *rvp)
480 struct inet6_request_sock *treq = inet6_rsk(req);
481 struct ipv6_pinfo *np = inet6_sk(sk);
482 struct sk_buff * skb;
483 struct ipv6_txoptions *opt = NULL;
484 struct in6_addr * final_p, final;
486 struct dst_entry *dst;
489 memset(&fl6, 0, sizeof(fl6));
490 fl6.flowi6_proto = IPPROTO_TCP;
491 ipv6_addr_copy(&fl6.daddr, &treq->rmt_addr);
492 ipv6_addr_copy(&fl6.saddr, &treq->loc_addr);
494 fl6.flowi6_oif = treq->iif;
495 fl6.flowi6_mark = sk->sk_mark;
496 fl6.fl6_dport = inet_rsk(req)->rmt_port;
497 fl6.fl6_sport = inet_rsk(req)->loc_port;
498 security_req_classify_flow(req, flowi6_to_flowi(&fl6));
501 final_p = fl6_update_dst(&fl6, opt, &final);
503 dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);
509 skb = tcp_make_synack(sk, dst, req, rvp);
512 __tcp_v6_send_check(skb, &treq->loc_addr, &treq->rmt_addr);
514 ipv6_addr_copy(&fl6.daddr, &treq->rmt_addr);
515 err = ip6_xmit(sk, skb, &fl6, opt);
516 err = net_xmit_eval(err);
520 if (opt && opt != np->opt)
521 sock_kfree_s(sk, opt, opt->tot_len);
526 static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req,
527 struct request_values *rvp)
529 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
530 return tcp_v6_send_synack(sk, req, rvp);
533 static inline void syn_flood_warning(struct sk_buff *skb)
535 #ifdef CONFIG_SYN_COOKIES
536 if (sysctl_tcp_syncookies)
538 "TCPv6: Possible SYN flooding on port %d. "
539 "Sending cookies.\n", ntohs(tcp_hdr(skb)->dest));
543 "TCPv6: Possible SYN flooding on port %d. "
544 "Dropping request.\n", ntohs(tcp_hdr(skb)->dest));
547 static void tcp_v6_reqsk_destructor(struct request_sock *req)
549 kfree_skb(inet6_rsk(req)->pktopts);
552 #ifdef CONFIG_TCP_MD5SIG
553 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
554 const struct in6_addr *addr)
556 struct tcp_sock *tp = tcp_sk(sk);
561 if (!tp->md5sig_info || !tp->md5sig_info->entries6)
564 for (i = 0; i < tp->md5sig_info->entries6; i++) {
565 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, addr))
566 return &tp->md5sig_info->keys6[i].base;
571 static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
572 struct sock *addr_sk)
574 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
577 static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
578 struct request_sock *req)
580 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
583 static int tcp_v6_md5_do_add(struct sock *sk, const struct in6_addr *peer,
584 char *newkey, u8 newkeylen)
586 /* Add key to the list */
587 struct tcp_md5sig_key *key;
588 struct tcp_sock *tp = tcp_sk(sk);
589 struct tcp6_md5sig_key *keys;
591 key = tcp_v6_md5_do_lookup(sk, peer);
593 /* modify existing entry - just update that one */
596 key->keylen = newkeylen;
598 /* reallocate new list if current one is full. */
599 if (!tp->md5sig_info) {
600 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
601 if (!tp->md5sig_info) {
605 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
607 if (tcp_alloc_md5sig_pool(sk) == NULL) {
611 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
612 keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
613 (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
616 tcp_free_md5sig_pool();
621 if (tp->md5sig_info->entries6)
622 memmove(keys, tp->md5sig_info->keys6,
623 (sizeof (tp->md5sig_info->keys6[0]) *
624 tp->md5sig_info->entries6));
626 kfree(tp->md5sig_info->keys6);
627 tp->md5sig_info->keys6 = keys;
628 tp->md5sig_info->alloced6++;
631 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
633 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.key = newkey;
634 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.keylen = newkeylen;
636 tp->md5sig_info->entries6++;
641 static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
642 u8 *newkey, __u8 newkeylen)
644 return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
648 static int tcp_v6_md5_do_del(struct sock *sk, const struct in6_addr *peer)
650 struct tcp_sock *tp = tcp_sk(sk);
653 for (i = 0; i < tp->md5sig_info->entries6; i++) {
654 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, peer)) {
656 kfree(tp->md5sig_info->keys6[i].base.key);
657 tp->md5sig_info->entries6--;
659 if (tp->md5sig_info->entries6 == 0) {
660 kfree(tp->md5sig_info->keys6);
661 tp->md5sig_info->keys6 = NULL;
662 tp->md5sig_info->alloced6 = 0;
664 /* shrink the database */
665 if (tp->md5sig_info->entries6 != i)
666 memmove(&tp->md5sig_info->keys6[i],
667 &tp->md5sig_info->keys6[i+1],
668 (tp->md5sig_info->entries6 - i)
669 * sizeof (tp->md5sig_info->keys6[0]));
671 tcp_free_md5sig_pool();
678 static void tcp_v6_clear_md5_list (struct sock *sk)
680 struct tcp_sock *tp = tcp_sk(sk);
683 if (tp->md5sig_info->entries6) {
684 for (i = 0; i < tp->md5sig_info->entries6; i++)
685 kfree(tp->md5sig_info->keys6[i].base.key);
686 tp->md5sig_info->entries6 = 0;
687 tcp_free_md5sig_pool();
690 kfree(tp->md5sig_info->keys6);
691 tp->md5sig_info->keys6 = NULL;
692 tp->md5sig_info->alloced6 = 0;
694 if (tp->md5sig_info->entries4) {
695 for (i = 0; i < tp->md5sig_info->entries4; i++)
696 kfree(tp->md5sig_info->keys4[i].base.key);
697 tp->md5sig_info->entries4 = 0;
698 tcp_free_md5sig_pool();
701 kfree(tp->md5sig_info->keys4);
702 tp->md5sig_info->keys4 = NULL;
703 tp->md5sig_info->alloced4 = 0;
706 static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
709 struct tcp_md5sig cmd;
710 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
713 if (optlen < sizeof(cmd))
716 if (copy_from_user(&cmd, optval, sizeof(cmd)))
719 if (sin6->sin6_family != AF_INET6)
722 if (!cmd.tcpm_keylen) {
723 if (!tcp_sk(sk)->md5sig_info)
725 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
726 return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
727 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
730 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
733 if (!tcp_sk(sk)->md5sig_info) {
734 struct tcp_sock *tp = tcp_sk(sk);
735 struct tcp_md5sig_info *p;
737 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
742 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
745 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
748 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) {
749 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
750 newkey, cmd.tcpm_keylen);
752 return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
755 static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
756 const struct in6_addr *daddr,
757 const struct in6_addr *saddr, int nbytes)
759 struct tcp6_pseudohdr *bp;
760 struct scatterlist sg;
762 bp = &hp->md5_blk.ip6;
763 /* 1. TCP pseudo-header (RFC2460) */
764 ipv6_addr_copy(&bp->saddr, saddr);
765 ipv6_addr_copy(&bp->daddr, daddr);
766 bp->protocol = cpu_to_be32(IPPROTO_TCP);
767 bp->len = cpu_to_be32(nbytes);
769 sg_init_one(&sg, bp, sizeof(*bp));
770 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
773 static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
774 const struct in6_addr *daddr, struct in6_addr *saddr,
777 struct tcp_md5sig_pool *hp;
778 struct hash_desc *desc;
780 hp = tcp_get_md5sig_pool();
782 goto clear_hash_noput;
783 desc = &hp->md5_desc;
785 if (crypto_hash_init(desc))
787 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
789 if (tcp_md5_hash_header(hp, th))
791 if (tcp_md5_hash_key(hp, key))
793 if (crypto_hash_final(desc, md5_hash))
796 tcp_put_md5sig_pool();
800 tcp_put_md5sig_pool();
802 memset(md5_hash, 0, 16);
806 static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
807 struct sock *sk, struct request_sock *req,
810 const struct in6_addr *saddr, *daddr;
811 struct tcp_md5sig_pool *hp;
812 struct hash_desc *desc;
813 struct tcphdr *th = tcp_hdr(skb);
816 saddr = &inet6_sk(sk)->saddr;
817 daddr = &inet6_sk(sk)->daddr;
819 saddr = &inet6_rsk(req)->loc_addr;
820 daddr = &inet6_rsk(req)->rmt_addr;
822 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
823 saddr = &ip6h->saddr;
824 daddr = &ip6h->daddr;
827 hp = tcp_get_md5sig_pool();
829 goto clear_hash_noput;
830 desc = &hp->md5_desc;
832 if (crypto_hash_init(desc))
835 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
837 if (tcp_md5_hash_header(hp, th))
839 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
841 if (tcp_md5_hash_key(hp, key))
843 if (crypto_hash_final(desc, md5_hash))
846 tcp_put_md5sig_pool();
850 tcp_put_md5sig_pool();
852 memset(md5_hash, 0, 16);
856 static int tcp_v6_inbound_md5_hash (struct sock *sk, struct sk_buff *skb)
858 __u8 *hash_location = NULL;
859 struct tcp_md5sig_key *hash_expected;
860 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
861 struct tcphdr *th = tcp_hdr(skb);
865 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
866 hash_location = tcp_parse_md5sig_option(th);
868 /* We've parsed the options - do we have a hash? */
869 if (!hash_expected && !hash_location)
872 if (hash_expected && !hash_location) {
873 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
877 if (!hash_expected && hash_location) {
878 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
882 /* check the signature */
883 genhash = tcp_v6_md5_hash_skb(newhash,
887 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
888 if (net_ratelimit()) {
889 printk(KERN_INFO "MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
890 genhash ? "failed" : "mismatch",
891 &ip6h->saddr, ntohs(th->source),
892 &ip6h->daddr, ntohs(th->dest));
900 struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
902 .obj_size = sizeof(struct tcp6_request_sock),
903 .rtx_syn_ack = tcp_v6_rtx_synack,
904 .send_ack = tcp_v6_reqsk_send_ack,
905 .destructor = tcp_v6_reqsk_destructor,
906 .send_reset = tcp_v6_send_reset,
907 .syn_ack_timeout = tcp_syn_ack_timeout,
910 #ifdef CONFIG_TCP_MD5SIG
911 static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
912 .md5_lookup = tcp_v6_reqsk_md5_lookup,
913 .calc_md5_hash = tcp_v6_md5_hash_skb,
917 static void __tcp_v6_send_check(struct sk_buff *skb,
918 const struct in6_addr *saddr, const struct in6_addr *daddr)
920 struct tcphdr *th = tcp_hdr(skb);
922 if (skb->ip_summed == CHECKSUM_PARTIAL) {
923 th->check = ~tcp_v6_check(skb->len, saddr, daddr, 0);
924 skb->csum_start = skb_transport_header(skb) - skb->head;
925 skb->csum_offset = offsetof(struct tcphdr, check);
927 th->check = tcp_v6_check(skb->len, saddr, daddr,
928 csum_partial(th, th->doff << 2,
933 static void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
935 struct ipv6_pinfo *np = inet6_sk(sk);
937 __tcp_v6_send_check(skb, &np->saddr, &np->daddr);
940 static int tcp_v6_gso_send_check(struct sk_buff *skb)
942 const struct ipv6hdr *ipv6h;
945 if (!pskb_may_pull(skb, sizeof(*th)))
948 ipv6h = ipv6_hdr(skb);
952 skb->ip_summed = CHECKSUM_PARTIAL;
953 __tcp_v6_send_check(skb, &ipv6h->saddr, &ipv6h->daddr);
957 static struct sk_buff **tcp6_gro_receive(struct sk_buff **head,
960 const struct ipv6hdr *iph = skb_gro_network_header(skb);
962 switch (skb->ip_summed) {
963 case CHECKSUM_COMPLETE:
964 if (!tcp_v6_check(skb_gro_len(skb), &iph->saddr, &iph->daddr,
966 skb->ip_summed = CHECKSUM_UNNECESSARY;
972 NAPI_GRO_CB(skb)->flush = 1;
976 return tcp_gro_receive(head, skb);
979 static int tcp6_gro_complete(struct sk_buff *skb)
981 const struct ipv6hdr *iph = ipv6_hdr(skb);
982 struct tcphdr *th = tcp_hdr(skb);
984 th->check = ~tcp_v6_check(skb->len - skb_transport_offset(skb),
985 &iph->saddr, &iph->daddr, 0);
986 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
988 return tcp_gro_complete(skb);
991 static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
992 u32 ts, struct tcp_md5sig_key *key, int rst)
994 struct tcphdr *th = tcp_hdr(skb), *t1;
995 struct sk_buff *buff;
997 struct net *net = dev_net(skb_dst(skb)->dev);
998 struct sock *ctl_sk = net->ipv6.tcp_sk;
999 unsigned int tot_len = sizeof(struct tcphdr);
1000 struct dst_entry *dst;
1004 tot_len += TCPOLEN_TSTAMP_ALIGNED;
1005 #ifdef CONFIG_TCP_MD5SIG
1007 tot_len += TCPOLEN_MD5SIG_ALIGNED;
1010 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1015 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1017 t1 = (struct tcphdr *) skb_push(buff, tot_len);
1018 skb_reset_transport_header(buff);
1020 /* Swap the send and the receive. */
1021 memset(t1, 0, sizeof(*t1));
1022 t1->dest = th->source;
1023 t1->source = th->dest;
1024 t1->doff = tot_len / 4;
1025 t1->seq = htonl(seq);
1026 t1->ack_seq = htonl(ack);
1027 t1->ack = !rst || !th->ack;
1029 t1->window = htons(win);
1031 topt = (__be32 *)(t1 + 1);
1034 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1035 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1036 *topt++ = htonl(tcp_time_stamp);
1037 *topt++ = htonl(ts);
1040 #ifdef CONFIG_TCP_MD5SIG
1042 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1043 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
1044 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
1045 &ipv6_hdr(skb)->saddr,
1046 &ipv6_hdr(skb)->daddr, t1);
1050 memset(&fl6, 0, sizeof(fl6));
1051 ipv6_addr_copy(&fl6.daddr, &ipv6_hdr(skb)->saddr);
1052 ipv6_addr_copy(&fl6.saddr, &ipv6_hdr(skb)->daddr);
1054 buff->ip_summed = CHECKSUM_PARTIAL;
1057 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
1059 fl6.flowi6_proto = IPPROTO_TCP;
1060 fl6.flowi6_oif = inet6_iif(skb);
1061 fl6.fl6_dport = t1->dest;
1062 fl6.fl6_sport = t1->source;
1063 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
1065 /* Pass a socket to ip6_dst_lookup either it is for RST
1066 * Underlying function will use this to retrieve the network
1069 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
1071 skb_dst_set(buff, dst);
1072 ip6_xmit(ctl_sk, buff, &fl6, NULL);
1073 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
1075 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
1082 static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
1084 struct tcphdr *th = tcp_hdr(skb);
1085 u32 seq = 0, ack_seq = 0;
1086 struct tcp_md5sig_key *key = NULL;
1091 if (!ipv6_unicast_destination(skb))
1094 #ifdef CONFIG_TCP_MD5SIG
1096 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
1100 seq = ntohl(th->ack_seq);
1102 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
1105 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, key, 1);
1108 static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts,
1109 struct tcp_md5sig_key *key)
1111 tcp_v6_send_response(skb, seq, ack, win, ts, key, 0);
1114 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1116 struct inet_timewait_sock *tw = inet_twsk(sk);
1117 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1119 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
1120 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
1121 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw));
1126 static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
1127 struct request_sock *req)
1129 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent,
1130 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr));
1134 static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1136 struct request_sock *req, **prev;
1137 const struct tcphdr *th = tcp_hdr(skb);
1140 /* Find possible connection requests. */
1141 req = inet6_csk_search_req(sk, &prev, th->source,
1142 &ipv6_hdr(skb)->saddr,
1143 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
1145 return tcp_check_req(sk, skb, req, prev);
1147 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
1148 &ipv6_hdr(skb)->saddr, th->source,
1149 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
1152 if (nsk->sk_state != TCP_TIME_WAIT) {
1156 inet_twsk_put(inet_twsk(nsk));
1160 #ifdef CONFIG_SYN_COOKIES
1162 sk = cookie_v6_check(sk, skb);
1167 /* FIXME: this is substantially similar to the ipv4 code.
1168 * Can some kind of merge be done? -- erics
1170 static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1172 struct tcp_extend_values tmp_ext;
1173 struct tcp_options_received tmp_opt;
1175 struct request_sock *req;
1176 struct inet6_request_sock *treq;
1177 struct ipv6_pinfo *np = inet6_sk(sk);
1178 struct tcp_sock *tp = tcp_sk(sk);
1179 __u32 isn = TCP_SKB_CB(skb)->when;
1180 struct dst_entry *dst = NULL;
1181 #ifdef CONFIG_SYN_COOKIES
1182 int want_cookie = 0;
1184 #define want_cookie 0
1187 if (skb->protocol == htons(ETH_P_IP))
1188 return tcp_v4_conn_request(sk, skb);
1190 if (!ipv6_unicast_destination(skb))
1193 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1194 if (net_ratelimit())
1195 syn_flood_warning(skb);
1196 #ifdef CONFIG_SYN_COOKIES
1197 if (sysctl_tcp_syncookies)
1204 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1207 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
1211 #ifdef CONFIG_TCP_MD5SIG
1212 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1215 tcp_clear_options(&tmp_opt);
1216 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1217 tmp_opt.user_mss = tp->rx_opt.user_mss;
1218 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
1220 if (tmp_opt.cookie_plus > 0 &&
1221 tmp_opt.saw_tstamp &&
1222 !tp->rx_opt.cookie_out_never &&
1223 (sysctl_tcp_cookie_size > 0 ||
1224 (tp->cookie_values != NULL &&
1225 tp->cookie_values->cookie_desired > 0))) {
1228 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1229 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1231 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1234 /* Secret recipe starts with IP addresses */
1235 d = (__force u32 *)&ipv6_hdr(skb)->daddr.s6_addr32[0];
1240 d = (__force u32 *)&ipv6_hdr(skb)->saddr.s6_addr32[0];
1246 /* plus variable length Initiator Cookie */
1249 *c++ ^= *hash_location++;
1251 #ifdef CONFIG_SYN_COOKIES
1252 want_cookie = 0; /* not our kind of cookie */
1254 tmp_ext.cookie_out_never = 0; /* false */
1255 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1256 } else if (!tp->rx_opt.cookie_in_always) {
1257 /* redundant indications, but ensure initialization. */
1258 tmp_ext.cookie_out_never = 1; /* true */
1259 tmp_ext.cookie_plus = 0;
1263 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
1265 if (want_cookie && !tmp_opt.saw_tstamp)
1266 tcp_clear_options(&tmp_opt);
1268 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1269 tcp_openreq_init(req, &tmp_opt, skb);
1271 treq = inet6_rsk(req);
1272 ipv6_addr_copy(&treq->rmt_addr, &ipv6_hdr(skb)->saddr);
1273 ipv6_addr_copy(&treq->loc_addr, &ipv6_hdr(skb)->daddr);
1274 if (!want_cookie || tmp_opt.tstamp_ok)
1275 TCP_ECN_create_request(req, tcp_hdr(skb));
1278 struct inet_peer *peer = NULL;
1280 if (ipv6_opt_accepted(sk, skb) ||
1281 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1282 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1283 atomic_inc(&skb->users);
1284 treq->pktopts = skb;
1286 treq->iif = sk->sk_bound_dev_if;
1288 /* So that link locals have meaning */
1289 if (!sk->sk_bound_dev_if &&
1290 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1291 treq->iif = inet6_iif(skb);
1294 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1295 req->cookie_ts = tmp_opt.tstamp_ok;
1299 /* VJ's idea. We save last timestamp seen
1300 * from the destination in peer table, when entering
1301 * state TIME-WAIT, and check against it before
1302 * accepting new connection request.
1304 * If "isn" is not zero, this request hit alive
1305 * timewait bucket, so that all the necessary checks
1306 * are made in the function processing timewait state.
1308 if (tmp_opt.saw_tstamp &&
1309 tcp_death_row.sysctl_tw_recycle &&
1310 (dst = inet6_csk_route_req(sk, req)) != NULL &&
1311 (peer = rt6_get_peer((struct rt6_info *)dst)) != NULL &&
1312 ipv6_addr_equal((struct in6_addr *)peer->daddr.addr.a6,
1314 inet_peer_refcheck(peer);
1315 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
1316 (s32)(peer->tcp_ts - req->ts_recent) >
1318 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1319 goto drop_and_release;
1322 /* Kill the following clause, if you dislike this way. */
1323 else if (!sysctl_tcp_syncookies &&
1324 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1325 (sysctl_max_syn_backlog >> 2)) &&
1326 (!peer || !peer->tcp_ts_stamp) &&
1327 (!dst || !dst_metric(dst, RTAX_RTT))) {
1328 /* Without syncookies last quarter of
1329 * backlog is filled with destinations,
1330 * proven to be alive.
1331 * It means that we continue to communicate
1332 * to destinations, already remembered
1333 * to the moment of synflood.
1335 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
1336 &treq->rmt_addr, ntohs(tcp_hdr(skb)->source));
1337 goto drop_and_release;
1340 isn = tcp_v6_init_sequence(skb);
1343 tcp_rsk(req)->snt_isn = isn;
1344 tcp_rsk(req)->snt_synack = tcp_time_stamp;
1346 security_inet_conn_request(sk, skb, req);
1348 if (tcp_v6_send_synack(sk, req,
1349 (struct request_values *)&tmp_ext) ||
1353 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1361 return 0; /* don't send reset */
1364 static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1365 struct request_sock *req,
1366 struct dst_entry *dst)
1368 struct inet6_request_sock *treq;
1369 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1370 struct tcp6_sock *newtcp6sk;
1371 struct inet_sock *newinet;
1372 struct tcp_sock *newtp;
1374 struct ipv6_txoptions *opt;
1375 #ifdef CONFIG_TCP_MD5SIG
1376 struct tcp_md5sig_key *key;
1379 if (skb->protocol == htons(ETH_P_IP)) {
1384 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1389 newtcp6sk = (struct tcp6_sock *)newsk;
1390 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1392 newinet = inet_sk(newsk);
1393 newnp = inet6_sk(newsk);
1394 newtp = tcp_sk(newsk);
1396 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1398 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
1400 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
1402 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1404 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1405 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1406 #ifdef CONFIG_TCP_MD5SIG
1407 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1410 newnp->pktoptions = NULL;
1412 newnp->mcast_oif = inet6_iif(skb);
1413 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1416 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1417 * here, tcp_create_openreq_child now does this for us, see the comment in
1418 * that function for the gory details. -acme
1421 /* It is tricky place. Until this moment IPv4 tcp
1422 worked with IPv6 icsk.icsk_af_ops.
1425 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1430 treq = inet6_rsk(req);
1433 if (sk_acceptq_is_full(sk))
1437 dst = inet6_csk_route_req(sk, req);
1442 newsk = tcp_create_openreq_child(sk, req, skb);
1447 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1448 * count here, tcp_create_openreq_child now does this for us, see the
1449 * comment in that function for the gory details. -acme
1452 newsk->sk_gso_type = SKB_GSO_TCPV6;
1453 __ip6_dst_store(newsk, dst, NULL, NULL);
1455 newtcp6sk = (struct tcp6_sock *)newsk;
1456 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1458 newtp = tcp_sk(newsk);
1459 newinet = inet_sk(newsk);
1460 newnp = inet6_sk(newsk);
1462 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1464 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1465 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1466 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1467 newsk->sk_bound_dev_if = treq->iif;
1469 /* Now IPv6 options...
1471 First: no IPv4 options.
1473 newinet->inet_opt = NULL;
1474 newnp->ipv6_fl_list = NULL;
1477 newnp->rxopt.all = np->rxopt.all;
1479 /* Clone pktoptions received with SYN */
1480 newnp->pktoptions = NULL;
1481 if (treq->pktopts != NULL) {
1482 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1483 kfree_skb(treq->pktopts);
1484 treq->pktopts = NULL;
1485 if (newnp->pktoptions)
1486 skb_set_owner_r(newnp->pktoptions, newsk);
1489 newnp->mcast_oif = inet6_iif(skb);
1490 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1492 /* Clone native IPv6 options from listening socket (if any)
1494 Yes, keeping reference count would be much more clever,
1495 but we make one more one thing there: reattach optmem
1499 newnp->opt = ipv6_dup_options(newsk, opt);
1501 sock_kfree_s(sk, opt, opt->tot_len);
1504 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1506 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1507 newnp->opt->opt_flen);
1509 tcp_mtup_init(newsk);
1510 tcp_sync_mss(newsk, dst_mtu(dst));
1511 newtp->advmss = dst_metric_advmss(dst);
1512 tcp_initialize_rcv_mss(newsk);
1513 if (tcp_rsk(req)->snt_synack)
1514 tcp_valid_rtt_meas(newsk,
1515 tcp_time_stamp - tcp_rsk(req)->snt_synack);
1516 newtp->total_retrans = req->retrans;
1518 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1519 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
1521 #ifdef CONFIG_TCP_MD5SIG
1522 /* Copy over the MD5 key from the original socket */
1523 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1524 /* We're using one, so create a matching key
1525 * on the newsk structure. If we fail to get
1526 * memory, then we end up not copying the key
1529 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1531 tcp_v6_md5_do_add(newsk, &newnp->daddr,
1532 newkey, key->keylen);
1536 if (__inet_inherit_port(sk, newsk) < 0) {
1540 __inet6_hash(newsk, NULL);
1545 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1547 if (opt && opt != np->opt)
1548 sock_kfree_s(sk, opt, opt->tot_len);
1551 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1555 static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
1557 if (skb->ip_summed == CHECKSUM_COMPLETE) {
1558 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
1559 &ipv6_hdr(skb)->daddr, skb->csum)) {
1560 skb->ip_summed = CHECKSUM_UNNECESSARY;
1565 skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
1566 &ipv6_hdr(skb)->saddr,
1567 &ipv6_hdr(skb)->daddr, 0));
1569 if (skb->len <= 76) {
1570 return __skb_checksum_complete(skb);
1575 /* The socket must have it's spinlock held when we get
1578 * We have a potential double-lock case here, so even when
1579 * doing backlog processing we use the BH locking scheme.
1580 * This is because we cannot sleep with the original spinlock
1583 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1585 struct ipv6_pinfo *np = inet6_sk(sk);
1586 struct tcp_sock *tp;
1587 struct sk_buff *opt_skb = NULL;
1589 /* Imagine: socket is IPv6. IPv4 packet arrives,
1590 goes to IPv4 receive handler and backlogged.
1591 From backlog it always goes here. Kerboom...
1592 Fortunately, tcp_rcv_established and rcv_established
1593 handle them correctly, but it is not case with
1594 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1597 if (skb->protocol == htons(ETH_P_IP))
1598 return tcp_v4_do_rcv(sk, skb);
1600 #ifdef CONFIG_TCP_MD5SIG
1601 if (tcp_v6_inbound_md5_hash (sk, skb))
1605 if (sk_filter(sk, skb))
1609 * socket locking is here for SMP purposes as backlog rcv
1610 * is currently called with bh processing disabled.
1613 /* Do Stevens' IPV6_PKTOPTIONS.
1615 Yes, guys, it is the only place in our code, where we
1616 may make it not affecting IPv4.
1617 The rest of code is protocol independent,
1618 and I do not like idea to uglify IPv4.
1620 Actually, all the idea behind IPV6_PKTOPTIONS
1621 looks not very well thought. For now we latch
1622 options, received in the last packet, enqueued
1623 by tcp. Feel free to propose better solution.
1627 opt_skb = skb_clone(skb, GFP_ATOMIC);
1629 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1630 sock_rps_save_rxhash(sk, skb->rxhash);
1631 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
1634 goto ipv6_pktoptions;
1638 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
1641 if (sk->sk_state == TCP_LISTEN) {
1642 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1647 * Queue it on the new socket if the new socket is active,
1648 * otherwise we just shortcircuit this and continue with
1652 if (tcp_child_process(sk, nsk, skb))
1655 __kfree_skb(opt_skb);
1659 sock_rps_save_rxhash(sk, skb->rxhash);
1661 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
1664 goto ipv6_pktoptions;
1668 tcp_v6_send_reset(sk, skb);
1671 __kfree_skb(opt_skb);
1675 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
1680 /* Do you ask, what is it?
1682 1. skb was enqueued by tcp.
1683 2. skb is added to tail of read queue, rather than out of order.
1684 3. socket is not in passive state.
1685 4. Finally, it really contains options, which user wants to receive.
1688 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1689 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1690 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
1691 np->mcast_oif = inet6_iif(opt_skb);
1692 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1693 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1694 if (ipv6_opt_accepted(sk, opt_skb)) {
1695 skb_set_owner_r(opt_skb, sk);
1696 opt_skb = xchg(&np->pktoptions, opt_skb);
1698 __kfree_skb(opt_skb);
1699 opt_skb = xchg(&np->pktoptions, NULL);
1707 static int tcp_v6_rcv(struct sk_buff *skb)
1710 const struct ipv6hdr *hdr;
1713 struct net *net = dev_net(skb->dev);
1715 if (skb->pkt_type != PACKET_HOST)
1719 * Count it even if it's bad.
1721 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
1723 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1728 if (th->doff < sizeof(struct tcphdr)/4)
1730 if (!pskb_may_pull(skb, th->doff*4))
1733 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
1737 hdr = ipv6_hdr(skb);
1738 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1739 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1740 skb->len - th->doff*4);
1741 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1742 TCP_SKB_CB(skb)->when = 0;
1743 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(hdr);
1744 TCP_SKB_CB(skb)->sacked = 0;
1746 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
1751 if (sk->sk_state == TCP_TIME_WAIT)
1754 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1755 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1756 goto discard_and_relse;
1759 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1760 goto discard_and_relse;
1762 if (sk_filter(sk, skb))
1763 goto discard_and_relse;
1767 bh_lock_sock_nested(sk);
1769 if (!sock_owned_by_user(sk)) {
1770 #ifdef CONFIG_NET_DMA
1771 struct tcp_sock *tp = tcp_sk(sk);
1772 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1773 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
1774 if (tp->ucopy.dma_chan)
1775 ret = tcp_v6_do_rcv(sk, skb);
1779 if (!tcp_prequeue(sk, skb))
1780 ret = tcp_v6_do_rcv(sk, skb);
1782 } else if (unlikely(sk_add_backlog(sk, skb))) {
1784 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
1785 goto discard_and_relse;
1790 return ret ? -1 : 0;
1793 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1796 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1798 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1800 tcp_v6_send_reset(NULL, skb);
1817 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1818 inet_twsk_put(inet_twsk(sk));
1822 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1823 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1824 inet_twsk_put(inet_twsk(sk));
1828 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1833 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
1834 &ipv6_hdr(skb)->daddr,
1835 ntohs(th->dest), inet6_iif(skb));
1837 struct inet_timewait_sock *tw = inet_twsk(sk);
1838 inet_twsk_deschedule(tw, &tcp_death_row);
1843 /* Fall through to ACK */
1846 tcp_v6_timewait_ack(sk, skb);
1850 case TCP_TW_SUCCESS:;
1855 static struct inet_peer *tcp_v6_get_peer(struct sock *sk, bool *release_it)
1857 struct rt6_info *rt = (struct rt6_info *) __sk_dst_get(sk);
1858 struct ipv6_pinfo *np = inet6_sk(sk);
1859 struct inet_peer *peer;
1862 !ipv6_addr_equal(&np->daddr, &rt->rt6i_dst.addr)) {
1863 peer = inet_getpeer_v6(&np->daddr, 1);
1867 rt6_bind_peer(rt, 1);
1868 peer = rt->rt6i_peer;
1869 *release_it = false;
1875 static void *tcp_v6_tw_get_peer(struct sock *sk)
1877 struct inet6_timewait_sock *tw6 = inet6_twsk(sk);
1878 struct inet_timewait_sock *tw = inet_twsk(sk);
1880 if (tw->tw_family == AF_INET)
1881 return tcp_v4_tw_get_peer(sk);
1883 return inet_getpeer_v6(&tw6->tw_v6_daddr, 1);
1886 static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1887 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1888 .twsk_unique = tcp_twsk_unique,
1889 .twsk_destructor= tcp_twsk_destructor,
1890 .twsk_getpeer = tcp_v6_tw_get_peer,
1893 static const struct inet_connection_sock_af_ops ipv6_specific = {
1894 .queue_xmit = inet6_csk_xmit,
1895 .send_check = tcp_v6_send_check,
1896 .rebuild_header = inet6_sk_rebuild_header,
1897 .conn_request = tcp_v6_conn_request,
1898 .syn_recv_sock = tcp_v6_syn_recv_sock,
1899 .get_peer = tcp_v6_get_peer,
1900 .net_header_len = sizeof(struct ipv6hdr),
1901 .setsockopt = ipv6_setsockopt,
1902 .getsockopt = ipv6_getsockopt,
1903 .addr2sockaddr = inet6_csk_addr2sockaddr,
1904 .sockaddr_len = sizeof(struct sockaddr_in6),
1905 .bind_conflict = inet6_csk_bind_conflict,
1906 #ifdef CONFIG_COMPAT
1907 .compat_setsockopt = compat_ipv6_setsockopt,
1908 .compat_getsockopt = compat_ipv6_getsockopt,
1912 #ifdef CONFIG_TCP_MD5SIG
1913 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
1914 .md5_lookup = tcp_v6_md5_lookup,
1915 .calc_md5_hash = tcp_v6_md5_hash_skb,
1916 .md5_add = tcp_v6_md5_add_func,
1917 .md5_parse = tcp_v6_parse_md5_keys,
1922 * TCP over IPv4 via INET6 API
1925 static const struct inet_connection_sock_af_ops ipv6_mapped = {
1926 .queue_xmit = ip_queue_xmit,
1927 .send_check = tcp_v4_send_check,
1928 .rebuild_header = inet_sk_rebuild_header,
1929 .conn_request = tcp_v6_conn_request,
1930 .syn_recv_sock = tcp_v6_syn_recv_sock,
1931 .get_peer = tcp_v4_get_peer,
1932 .net_header_len = sizeof(struct iphdr),
1933 .setsockopt = ipv6_setsockopt,
1934 .getsockopt = ipv6_getsockopt,
1935 .addr2sockaddr = inet6_csk_addr2sockaddr,
1936 .sockaddr_len = sizeof(struct sockaddr_in6),
1937 .bind_conflict = inet6_csk_bind_conflict,
1938 #ifdef CONFIG_COMPAT
1939 .compat_setsockopt = compat_ipv6_setsockopt,
1940 .compat_getsockopt = compat_ipv6_getsockopt,
1944 #ifdef CONFIG_TCP_MD5SIG
1945 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
1946 .md5_lookup = tcp_v4_md5_lookup,
1947 .calc_md5_hash = tcp_v4_md5_hash_skb,
1948 .md5_add = tcp_v6_md5_add_func,
1949 .md5_parse = tcp_v6_parse_md5_keys,
1953 /* NOTE: A lot of things set to zero explicitly by call to
1954 * sk_alloc() so need not be done here.
1956 static int tcp_v6_init_sock(struct sock *sk)
1958 struct inet_connection_sock *icsk = inet_csk(sk);
1959 struct tcp_sock *tp = tcp_sk(sk);
1961 skb_queue_head_init(&tp->out_of_order_queue);
1962 tcp_init_xmit_timers(sk);
1963 tcp_prequeue_init(tp);
1965 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1966 tp->mdev = TCP_TIMEOUT_INIT;
1968 /* So many TCP implementations out there (incorrectly) count the
1969 * initial SYN frame in their delayed-ACK and congestion control
1970 * algorithms that we must have the following bandaid to talk
1971 * efficiently to them. -DaveM
1975 /* See draft-stevens-tcpca-spec-01 for discussion of the
1976 * initialization of these values.
1978 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
1979 tp->snd_cwnd_clamp = ~0;
1980 tp->mss_cache = TCP_MSS_DEFAULT;
1982 tp->reordering = sysctl_tcp_reordering;
1984 sk->sk_state = TCP_CLOSE;
1986 icsk->icsk_af_ops = &ipv6_specific;
1987 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1988 icsk->icsk_sync_mss = tcp_sync_mss;
1989 sk->sk_write_space = sk_stream_write_space;
1990 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1992 #ifdef CONFIG_TCP_MD5SIG
1993 tp->af_specific = &tcp_sock_ipv6_specific;
1996 /* TCP Cookie Transactions */
1997 if (sysctl_tcp_cookie_size > 0) {
1998 /* Default, cookies without s_data_payload. */
2000 kzalloc(sizeof(*tp->cookie_values),
2002 if (tp->cookie_values != NULL)
2003 kref_init(&tp->cookie_values->kref);
2005 /* Presumed zeroed, in order of appearance:
2006 * cookie_in_always, cookie_out_never,
2007 * s_data_constant, s_data_in, s_data_out
2009 sk->sk_sndbuf = sysctl_tcp_wmem[1];
2010 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
2013 percpu_counter_inc(&tcp_sockets_allocated);
2019 static void tcp_v6_destroy_sock(struct sock *sk)
2021 #ifdef CONFIG_TCP_MD5SIG
2022 /* Clean up the MD5 key list */
2023 if (tcp_sk(sk)->md5sig_info)
2024 tcp_v6_clear_md5_list(sk);
2026 tcp_v4_destroy_sock(sk);
2027 inet6_destroy_sock(sk);
2030 #ifdef CONFIG_PROC_FS
2031 /* Proc filesystem TCPv6 sock list dumping. */
2032 static void get_openreq6(struct seq_file *seq,
2033 struct sock *sk, struct request_sock *req, int i, int uid)
2035 int ttd = req->expires - jiffies;
2036 const struct in6_addr *src = &inet6_rsk(req)->loc_addr;
2037 const struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
2043 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2044 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
2046 src->s6_addr32[0], src->s6_addr32[1],
2047 src->s6_addr32[2], src->s6_addr32[3],
2048 ntohs(inet_rsk(req)->loc_port),
2049 dest->s6_addr32[0], dest->s6_addr32[1],
2050 dest->s6_addr32[2], dest->s6_addr32[3],
2051 ntohs(inet_rsk(req)->rmt_port),
2053 0,0, /* could print option size, but that is af dependent. */
2054 1, /* timers active (only the expire timer) */
2055 jiffies_to_clock_t(ttd),
2058 0, /* non standard timer */
2059 0, /* open_requests have no inode */
2063 static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
2065 const struct in6_addr *dest, *src;
2068 unsigned long timer_expires;
2069 struct inet_sock *inet = inet_sk(sp);
2070 struct tcp_sock *tp = tcp_sk(sp);
2071 const struct inet_connection_sock *icsk = inet_csk(sp);
2072 struct ipv6_pinfo *np = inet6_sk(sp);
2075 src = &np->rcv_saddr;
2076 destp = ntohs(inet->inet_dport);
2077 srcp = ntohs(inet->inet_sport);
2079 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
2081 timer_expires = icsk->icsk_timeout;
2082 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2084 timer_expires = icsk->icsk_timeout;
2085 } else if (timer_pending(&sp->sk_timer)) {
2087 timer_expires = sp->sk_timer.expires;
2090 timer_expires = jiffies;
2094 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2095 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %pK %lu %lu %u %u %d\n",
2097 src->s6_addr32[0], src->s6_addr32[1],
2098 src->s6_addr32[2], src->s6_addr32[3], srcp,
2099 dest->s6_addr32[0], dest->s6_addr32[1],
2100 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2102 tp->write_seq-tp->snd_una,
2103 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
2105 jiffies_to_clock_t(timer_expires - jiffies),
2106 icsk->icsk_retransmits,
2108 icsk->icsk_probes_out,
2110 atomic_read(&sp->sk_refcnt), sp,
2111 jiffies_to_clock_t(icsk->icsk_rto),
2112 jiffies_to_clock_t(icsk->icsk_ack.ato),
2113 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
2115 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
2119 static void get_timewait6_sock(struct seq_file *seq,
2120 struct inet_timewait_sock *tw, int i)
2122 const struct in6_addr *dest, *src;
2124 struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
2125 int ttd = tw->tw_ttd - jiffies;
2130 dest = &tw6->tw_v6_daddr;
2131 src = &tw6->tw_v6_rcv_saddr;
2132 destp = ntohs(tw->tw_dport);
2133 srcp = ntohs(tw->tw_sport);
2136 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2137 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
2139 src->s6_addr32[0], src->s6_addr32[1],
2140 src->s6_addr32[2], src->s6_addr32[3], srcp,
2141 dest->s6_addr32[0], dest->s6_addr32[1],
2142 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2143 tw->tw_substate, 0, 0,
2144 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2145 atomic_read(&tw->tw_refcnt), tw);
2148 static int tcp6_seq_show(struct seq_file *seq, void *v)
2150 struct tcp_iter_state *st;
2152 if (v == SEQ_START_TOKEN) {
2157 "st tx_queue rx_queue tr tm->when retrnsmt"
2158 " uid timeout inode\n");
2163 switch (st->state) {
2164 case TCP_SEQ_STATE_LISTENING:
2165 case TCP_SEQ_STATE_ESTABLISHED:
2166 get_tcp6_sock(seq, v, st->num);
2168 case TCP_SEQ_STATE_OPENREQ:
2169 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2171 case TCP_SEQ_STATE_TIME_WAIT:
2172 get_timewait6_sock(seq, v, st->num);
2179 static struct tcp_seq_afinfo tcp6_seq_afinfo = {
2183 .owner = THIS_MODULE,
2186 .show = tcp6_seq_show,
2190 int __net_init tcp6_proc_init(struct net *net)
2192 return tcp_proc_register(net, &tcp6_seq_afinfo);
2195 void tcp6_proc_exit(struct net *net)
2197 tcp_proc_unregister(net, &tcp6_seq_afinfo);
2201 struct proto tcpv6_prot = {
2203 .owner = THIS_MODULE,
2205 .connect = tcp_v6_connect,
2206 .disconnect = tcp_disconnect,
2207 .accept = inet_csk_accept,
2209 .init = tcp_v6_init_sock,
2210 .destroy = tcp_v6_destroy_sock,
2211 .shutdown = tcp_shutdown,
2212 .setsockopt = tcp_setsockopt,
2213 .getsockopt = tcp_getsockopt,
2214 .recvmsg = tcp_recvmsg,
2215 .sendmsg = tcp_sendmsg,
2216 .sendpage = tcp_sendpage,
2217 .backlog_rcv = tcp_v6_do_rcv,
2218 .hash = tcp_v6_hash,
2219 .unhash = inet_unhash,
2220 .get_port = inet_csk_get_port,
2221 .enter_memory_pressure = tcp_enter_memory_pressure,
2222 .sockets_allocated = &tcp_sockets_allocated,
2223 .memory_allocated = &tcp_memory_allocated,
2224 .memory_pressure = &tcp_memory_pressure,
2225 .orphan_count = &tcp_orphan_count,
2226 .sysctl_mem = sysctl_tcp_mem,
2227 .sysctl_wmem = sysctl_tcp_wmem,
2228 .sysctl_rmem = sysctl_tcp_rmem,
2229 .max_header = MAX_TCP_HEADER,
2230 .obj_size = sizeof(struct tcp6_sock),
2231 .slab_flags = SLAB_DESTROY_BY_RCU,
2232 .twsk_prot = &tcp6_timewait_sock_ops,
2233 .rsk_prot = &tcp6_request_sock_ops,
2234 .h.hashinfo = &tcp_hashinfo,
2235 .no_autobind = true,
2236 #ifdef CONFIG_COMPAT
2237 .compat_setsockopt = compat_tcp_setsockopt,
2238 .compat_getsockopt = compat_tcp_getsockopt,
2242 static const struct inet6_protocol tcpv6_protocol = {
2243 .handler = tcp_v6_rcv,
2244 .err_handler = tcp_v6_err,
2245 .gso_send_check = tcp_v6_gso_send_check,
2246 .gso_segment = tcp_tso_segment,
2247 .gro_receive = tcp6_gro_receive,
2248 .gro_complete = tcp6_gro_complete,
2249 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2252 static struct inet_protosw tcpv6_protosw = {
2253 .type = SOCK_STREAM,
2254 .protocol = IPPROTO_TCP,
2255 .prot = &tcpv6_prot,
2256 .ops = &inet6_stream_ops,
2258 .flags = INET_PROTOSW_PERMANENT |
2262 static int __net_init tcpv6_net_init(struct net *net)
2264 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2265 SOCK_RAW, IPPROTO_TCP, net);
2268 static void __net_exit tcpv6_net_exit(struct net *net)
2270 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
2273 static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
2275 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
2278 static struct pernet_operations tcpv6_net_ops = {
2279 .init = tcpv6_net_init,
2280 .exit = tcpv6_net_exit,
2281 .exit_batch = tcpv6_net_exit_batch,
2284 int __init tcpv6_init(void)
2288 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2292 /* register inet6 protocol */
2293 ret = inet6_register_protosw(&tcpv6_protosw);
2295 goto out_tcpv6_protocol;
2297 ret = register_pernet_subsys(&tcpv6_net_ops);
2299 goto out_tcpv6_protosw;
2304 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2306 inet6_unregister_protosw(&tcpv6_protosw);
2310 void tcpv6_exit(void)
2312 unregister_pernet_subsys(&tcpv6_net_ops);
2313 inet6_unregister_protosw(&tcpv6_protosw);
2314 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);