blob: a97c95585da8debd5960c4e8b15b9c923329513c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * TCP over IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09008 * Based on:
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * linux/net/ipv4/tcp.c
10 * linux/net/ipv4/tcp_input.c
11 * linux/net/ipv4/tcp_output.c
12 *
13 * Fixes:
14 * Hideaki YOSHIFUJI : sin6_scope_id support
15 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
16 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
17 * a single port at the same time.
18 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
Herbert Xueb4dea52008-12-29 23:04:08 -080026#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/socket.h>
31#include <linux/sockios.h>
32#include <linux/net.h>
33#include <linux/jiffies.h>
34#include <linux/in.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/init.h>
38#include <linux/jhash.h>
39#include <linux/ipsec.h>
40#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090041#include <linux/slab.h>
Wang Yufen4aa956d2014-03-29 09:27:29 +080042#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
Arnaldo Carvalho de Melo5324a042005-08-12 09:26:18 -030049#include <net/inet6_hashtables.h>
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -080050#include <net/inet6_connection_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <net/ipv6.h>
52#include <net/transp_v6.h>
53#include <net/addrconf.h>
54#include <net/ip6_route.h>
55#include <net/ip6_checksum.h>
56#include <net/inet_ecn.h>
57#include <net/protocol.h>
58#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <net/snmp.h>
60#include <net/dsfield.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080061#include <net/timewait_sock.h>
Jeff Garzik18134be2007-10-26 22:53:14 -070062#include <net/netdma.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070063#include <net/inet_common.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070064#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000065#include <net/tcp_memcontrol.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030066#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/proc_fs.h>
69#include <linux/seq_file.h>
70
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080071#include <linux/crypto.h>
72#include <linux/scatterlist.h>
73
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080074static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070075static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
76 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Stephen Hemminger3b401a82009-09-01 19:25:04 +000080static const struct inet_connection_sock_af_ops ipv6_mapped;
81static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080082#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000083static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
84static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090085#else
86static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000087 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090088{
89 return NULL;
90}
David S. Millera9286302006-11-14 19:53:22 -080091#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Neal Cardwellfae6ef82012-08-19 03:30:38 +000093static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
94{
95 struct dst_entry *dst = skb_dst(skb);
96 const struct rt6_info *rt = (const struct rt6_info *)dst;
97
98 dst_hold(dst);
99 sk->sk_rx_dst = dst;
100 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
101 if (rt->rt6i_node)
102 inet6_sk(sk)->rx_dst_cookie = rt->rt6i_node->fn_sernum;
103}
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105static void tcp_v6_hash(struct sock *sk)
106{
107 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800108 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 tcp_prot.hash(sk);
110 return;
111 }
112 local_bh_disable();
Eric Dumazet9327f702009-12-04 03:46:54 +0000113 __inet6_hash(sk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 local_bh_enable();
115 }
116}
117
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400118static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700120 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
121 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700122 tcp_hdr(skb)->dest,
123 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124}
125
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900126static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 int addr_len)
128{
129 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900130 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800131 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 struct ipv6_pinfo *np = inet6_sk(sk);
133 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000134 struct in6_addr *saddr = NULL, *final_p, final;
David S. Miller493f3772010-12-02 12:14:29 -0800135 struct rt6_info *rt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500136 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 struct dst_entry *dst;
138 int addr_type;
139 int err;
140
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900141 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 return -EINVAL;
143
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900144 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000145 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
David S. Miller4c9483b2011-03-12 16:22:43 -0500147 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500150 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
151 IP6_ECN_flow_init(fl6.flowlabel);
152 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 struct ip6_flowlabel *flowlabel;
David S. Miller4c9483b2011-03-12 16:22:43 -0500154 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (flowlabel == NULL)
156 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 fl6_sock_release(flowlabel);
158 }
159 }
160
161 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900162 * connect() to INADDR_ANY means loopback (BSD'ism).
163 */
164
Weilong Chen4c99aa42013-12-19 18:44:34 +0800165 if (ipv6_addr_any(&usin->sin6_addr))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900166 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
168 addr_type = ipv6_addr_type(&usin->sin6_addr);
169
Weilong Chen4c99aa42013-12-19 18:44:34 +0800170 if (addr_type & IPV6_ADDR_MULTICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return -ENETUNREACH;
172
173 if (addr_type&IPV6_ADDR_LINKLOCAL) {
174 if (addr_len >= sizeof(struct sockaddr_in6) &&
175 usin->sin6_scope_id) {
176 /* If interface is set while binding, indices
177 * must coincide.
178 */
179 if (sk->sk_bound_dev_if &&
180 sk->sk_bound_dev_if != usin->sin6_scope_id)
181 return -EINVAL;
182
183 sk->sk_bound_dev_if = usin->sin6_scope_id;
184 }
185
186 /* Connect to link-local address requires an interface */
187 if (!sk->sk_bound_dev_if)
188 return -EINVAL;
189 }
190
191 if (tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700192 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 tp->rx_opt.ts_recent = 0;
194 tp->rx_opt.ts_recent_stamp = 0;
195 tp->write_seq = 0;
196 }
197
Eric Dumazetefe42082013-10-03 15:42:29 -0700198 sk->sk_v6_daddr = usin->sin6_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500199 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
201 /*
202 * TCP over IPv4
203 */
204
205 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800206 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 struct sockaddr_in sin;
208
209 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
210
211 if (__ipv6_only_sock(sk))
212 return -ENETUNREACH;
213
214 sin.sin_family = AF_INET;
215 sin.sin_port = usin->sin6_port;
216 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
217
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800218 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800220#ifdef CONFIG_TCP_MD5SIG
221 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
222#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
224 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
225
226 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800227 icsk->icsk_ext_hdr_len = exthdrlen;
228 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800230#ifdef CONFIG_TCP_MD5SIG
231 tp->af_specific = &tcp_sock_ipv6_specific;
232#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 goto failure;
234 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000235 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
236 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
Eric Dumazetefe42082013-10-03 15:42:29 -0700237 &sk->sk_v6_rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
239
240 return err;
241 }
242
Eric Dumazetefe42082013-10-03 15:42:29 -0700243 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
244 saddr = &sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
David S. Miller4c9483b2011-03-12 16:22:43 -0500246 fl6.flowi6_proto = IPPROTO_TCP;
Eric Dumazetefe42082013-10-03 15:42:29 -0700247 fl6.daddr = sk->sk_v6_daddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000248 fl6.saddr = saddr ? *saddr : np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500249 fl6.flowi6_oif = sk->sk_bound_dev_if;
250 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500251 fl6.fl6_dport = usin->sin6_port;
252 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
David S. Miller4c9483b2011-03-12 16:22:43 -0500254 final_p = fl6_update_dst(&fl6, np->opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
David S. Miller4c9483b2011-03-12 16:22:43 -0500256 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700257
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200258 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800259 if (IS_ERR(dst)) {
260 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 goto failure;
David S. Miller14e50e52007-05-24 18:17:54 -0700262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 if (saddr == NULL) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500265 saddr = &fl6.saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700266 sk->sk_v6_rcv_saddr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 }
268
269 /* set the source address */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000270 np->saddr = *saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000271 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700273 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700274 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
David S. Miller493f3772010-12-02 12:14:29 -0800276 rt = (struct rt6_info *) dst;
277 if (tcp_death_row.sysctl_tw_recycle &&
278 !tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700279 ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
David S. Miller81166dd2012-07-10 03:14:24 -0700280 tcp_fetch_timewait_stamp(sk, dst);
David S. Miller493f3772010-12-02 12:14:29 -0800281
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800282 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800284 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
285 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
288
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000289 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
291 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800292 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 if (err)
294 goto late_failure;
295
Andrey Vagin2b916472012-11-22 01:13:58 +0000296 if (!tp->write_seq && likely(!tp->repair))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
Eric Dumazetefe42082013-10-03 15:42:29 -0700298 sk->sk_v6_daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000299 inet->inet_sport,
300 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 err = tcp_connect(sk);
303 if (err)
304 goto late_failure;
305
306 return 0;
307
308late_failure:
309 tcp_set_state(sk, TCP_CLOSE);
310 __sk_dst_reset(sk);
311failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000312 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 sk->sk_route_caps = 0;
314 return err;
315}
316
Eric Dumazet563d34d2012-07-23 09:48:52 +0200317static void tcp_v6_mtu_reduced(struct sock *sk)
318{
319 struct dst_entry *dst;
320
321 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
322 return;
323
324 dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
325 if (!dst)
326 return;
327
328 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
329 tcp_sync_mss(sk, dst_mtu(dst));
330 tcp_simple_retransmit(sk);
331 }
332}
333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700335 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
Weilong Chen4c99aa42013-12-19 18:44:34 +0800337 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300338 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 struct ipv6_pinfo *np;
340 struct sock *sk;
341 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900342 struct tcp_sock *tp;
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700343 struct request_sock *fastopen;
344 __u32 seq, snd_una;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700345 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700347 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800348 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700351 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
352 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 return;
354 }
355
356 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700357 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return;
359 }
360
361 bh_lock_sock(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200362 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700363 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
365 if (sk->sk_state == TCP_CLOSE)
366 goto out;
367
Stephen Hemmingere802af92010-04-22 15:24:53 -0700368 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
369 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
370 goto out;
371 }
372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900374 seq = ntohl(th->seq);
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700375 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
376 fastopen = tp->fastopen_rsk;
377 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 if (sk->sk_state != TCP_LISTEN &&
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700379 !between(seq, snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700380 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 goto out;
382 }
383
384 np = inet6_sk(sk);
385
David S. Millerec18d9a2012-07-12 00:25:15 -0700386 if (type == NDISC_REDIRECT) {
387 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
388
David S. Miller1ed5c482012-07-12 00:41:25 -0700389 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700390 dst->ops->redirect(dst, sk, skb);
Christoph Paasch50a75a82013-04-07 04:53:15 +0000391 goto out;
David S. Millerec18d9a2012-07-12 00:25:15 -0700392 }
393
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 if (type == ICMPV6_PKT_TOOBIG) {
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000395 /* We are not interested in TCP_LISTEN and open_requests
396 * (SYN-ACKs send out by Linux are always <576bytes so
397 * they should go through unfragmented).
398 */
399 if (sk->sk_state == TCP_LISTEN)
400 goto out;
401
Hannes Frederic Sowa93b36cf2013-12-15 03:41:14 +0100402 if (!ip6_sk_accept_pmtu(sk))
403 goto out;
404
Eric Dumazet563d34d2012-07-23 09:48:52 +0200405 tp->mtu_info = ntohl(info);
406 if (!sock_owned_by_user(sk))
407 tcp_v6_mtu_reduced(sk);
Julian Anastasovd013ef2a2012-09-05 10:53:18 +0000408 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
409 &tp->tsq_flags))
410 sock_hold(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 goto out;
412 }
413
414 icmpv6_err_convert(type, code, &err);
415
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700416 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700418 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 case TCP_LISTEN:
420 if (sock_owned_by_user(sk))
421 goto out;
422
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800423 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
424 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 if (!req)
426 goto out;
427
428 /* ICMPs are not backlogged, hence we cannot get
429 * an established socket here.
430 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700431 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700433 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700434 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 goto out;
436 }
437
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700438 inet_csk_reqsk_queue_drop(sk, req, prev);
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000439 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 goto out;
441
442 case TCP_SYN_SENT:
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700443 case TCP_SYN_RECV:
444 /* Only in fast or simultaneous open. If a fast open socket is
445 * is already accepted it is treated as a connected one below.
446 */
447 if (fastopen && fastopen->sk == NULL)
448 break;
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 sk->sk_err = err;
452 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
453
454 tcp_done(sk);
455 } else
456 sk->sk_err_soft = err;
457 goto out;
458 }
459
460 if (!sock_owned_by_user(sk) && np->recverr) {
461 sk->sk_err = err;
462 sk->sk_error_report(sk);
463 } else
464 sk->sk_err_soft = err;
465
466out:
467 bh_unlock_sock(sk);
468 sock_put(sk);
469}
470
471
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000472static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300473 struct flowi *fl,
Neal Cardwell3840a062012-06-28 12:34:19 +0000474 struct request_sock *req,
Daniel Lee3a19ce02014-05-11 20:22:13 -0700475 u16 queue_mapping,
476 struct tcp_fastopen_cookie *foc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700478 struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 struct ipv6_pinfo *np = inet6_sk(sk);
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300480 struct flowi6 *fl6 = &fl->u.ip6;
Weilong Chen4c99aa42013-12-19 18:44:34 +0800481 struct sk_buff *skb;
Neal Cardwell94942182012-06-28 12:34:20 +0000482 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000484 /* First, grab a route. */
485 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800486 goto done;
Neal Cardwell94942182012-06-28 12:34:20 +0000487
Daniel Lee3a19ce02014-05-11 20:22:13 -0700488 skb = tcp_make_synack(sk, dst, req, foc);
Neal Cardwell94942182012-06-28 12:34:20 +0000489
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700491 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
492 &ireq->ir_v6_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Eric Dumazet634fb9792013-10-09 15:21:29 -0700494 fl6->daddr = ireq->ir_v6_rmt_addr;
Florent Fourcotdf3687f2014-01-17 17:15:03 +0100495 if (np->repflow && (ireq->pktopts != NULL))
496 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
497
Eric Dumazetfff32692012-06-01 01:47:50 +0000498 skb_set_queue_mapping(skb, queue_mapping);
RongQing.Li43264e02012-07-01 17:18:59 +0000499 err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200500 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 }
502
503done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 return err;
505}
506
Octavian Purdila72659ec2010-01-17 19:09:39 -0800507
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700508static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700510 kfree_skb(inet_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511}
512
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800513#ifdef CONFIG_TCP_MD5SIG
514static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000515 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800516{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000517 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800518}
519
520static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
521 struct sock *addr_sk)
522{
Eric Dumazetefe42082013-10-03 15:42:29 -0700523 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800524}
525
526static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
527 struct request_sock *req)
528{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700529 return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800530}
531
Wang Yufen4aa956d2014-03-29 09:27:29 +0800532static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
533 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800534{
535 struct tcp_md5sig cmd;
536 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800537
538 if (optlen < sizeof(cmd))
539 return -EINVAL;
540
541 if (copy_from_user(&cmd, optval, sizeof(cmd)))
542 return -EFAULT;
543
544 if (sin6->sin6_family != AF_INET6)
545 return -EINVAL;
546
547 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700548 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000549 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
550 AF_INET);
551 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
552 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800553 }
554
555 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
556 return -EINVAL;
557
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000558 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
559 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
560 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800561
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000562 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
563 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800564}
565
Adam Langley49a72df2008-07-19 00:01:42 -0700566static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000567 const struct in6_addr *daddr,
568 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800569{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800570 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700571 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900572
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800573 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800574 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000575 bp->saddr = *saddr;
576 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700577 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700578 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800579
Adam Langley49a72df2008-07-19 00:01:42 -0700580 sg_init_one(&sg, bp, sizeof(*bp));
581 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
582}
David S. Millerc7da57a2007-10-26 00:41:21 -0700583
Adam Langley49a72df2008-07-19 00:01:42 -0700584static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000585 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400586 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700587{
588 struct tcp_md5sig_pool *hp;
589 struct hash_desc *desc;
590
591 hp = tcp_get_md5sig_pool();
592 if (!hp)
593 goto clear_hash_noput;
594 desc = &hp->md5_desc;
595
596 if (crypto_hash_init(desc))
597 goto clear_hash;
598 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
599 goto clear_hash;
600 if (tcp_md5_hash_header(hp, th))
601 goto clear_hash;
602 if (tcp_md5_hash_key(hp, key))
603 goto clear_hash;
604 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800605 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800606
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800607 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800608 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700609
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800610clear_hash:
611 tcp_put_md5sig_pool();
612clear_hash_noput:
613 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700614 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800615}
616
Adam Langley49a72df2008-07-19 00:01:42 -0700617static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400618 const struct sock *sk,
619 const struct request_sock *req,
620 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800621{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000622 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700623 struct tcp_md5sig_pool *hp;
624 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400625 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800626
627 if (sk) {
628 saddr = &inet6_sk(sk)->saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700629 daddr = &sk->sk_v6_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700630 } else if (req) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700631 saddr = &inet_rsk(req)->ir_v6_loc_addr;
632 daddr = &inet_rsk(req)->ir_v6_rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700633 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000634 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700635 saddr = &ip6h->saddr;
636 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800637 }
Adam Langley49a72df2008-07-19 00:01:42 -0700638
639 hp = tcp_get_md5sig_pool();
640 if (!hp)
641 goto clear_hash_noput;
642 desc = &hp->md5_desc;
643
644 if (crypto_hash_init(desc))
645 goto clear_hash;
646
647 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
648 goto clear_hash;
649 if (tcp_md5_hash_header(hp, th))
650 goto clear_hash;
651 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
652 goto clear_hash;
653 if (tcp_md5_hash_key(hp, key))
654 goto clear_hash;
655 if (crypto_hash_final(desc, md5_hash))
656 goto clear_hash;
657
658 tcp_put_md5sig_pool();
659 return 0;
660
661clear_hash:
662 tcp_put_md5sig_pool();
663clear_hash_noput:
664 memset(md5_hash, 0, 16);
665 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800666}
667
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400668static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800669{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400670 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800671 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000672 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400673 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800674 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800675 u8 newhash[16];
676
677 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900678 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800679
David S. Miller785957d2008-07-30 03:03:15 -0700680 /* We've parsed the options - do we have a hash? */
681 if (!hash_expected && !hash_location)
682 return 0;
683
684 if (hash_expected && !hash_location) {
685 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800686 return 1;
687 }
688
David S. Miller785957d2008-07-30 03:03:15 -0700689 if (!hash_expected && hash_location) {
690 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800691 return 1;
692 }
693
694 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700695 genhash = tcp_v6_md5_hash_skb(newhash,
696 hash_expected,
697 NULL, NULL, skb);
698
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800699 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +0000700 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
701 genhash ? "failed" : "mismatch",
702 &ip6h->saddr, ntohs(th->source),
703 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800704 return 1;
705 }
706 return 0;
707}
708#endif
709
Octavian Purdila16bea702014-06-25 17:09:53 +0300710static void tcp_v6_init_req(struct request_sock *req, struct sock *sk,
711 struct sk_buff *skb)
712{
713 struct inet_request_sock *ireq = inet_rsk(req);
714 struct ipv6_pinfo *np = inet6_sk(sk);
715
716 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
717 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
718
719 ireq->ir_iif = sk->sk_bound_dev_if;
720
721 /* So that link locals have meaning */
722 if (!sk->sk_bound_dev_if &&
723 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
724 ireq->ir_iif = inet6_iif(skb);
725
726 if (!TCP_SKB_CB(skb)->when &&
727 (ipv6_opt_accepted(sk, skb) || np->rxopt.bits.rxinfo ||
728 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
729 np->rxopt.bits.rxohlim || np->repflow)) {
730 atomic_inc(&skb->users);
731 ireq->pktopts = skb;
732 }
733}
734
Octavian Purdilad94e0412014-06-25 17:09:55 +0300735static struct dst_entry *tcp_v6_route_req(struct sock *sk, struct flowi *fl,
736 const struct request_sock *req,
737 bool *strict)
738{
739 if (strict)
740 *strict = true;
741 return inet6_csk_route_req(sk, &fl->u.ip6, req);
742}
743
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800744struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700746 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila5db92c92014-06-25 17:09:59 +0300747 .rtx_syn_ack = tcp_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700748 .send_ack = tcp_v6_reqsk_send_ack,
749 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800750 .send_reset = tcp_v6_send_reset,
Wang Yufen4aa956d2014-03-29 09:27:29 +0800751 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752};
753
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000754static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
Octavian Purdila2aec4a22014-06-25 17:10:00 +0300755 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) -
756 sizeof(struct ipv6hdr),
Octavian Purdila16bea702014-06-25 17:09:53 +0300757#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800758 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000759 .calc_md5_hash = tcp_v6_md5_hash_skb,
Andrew Mortonb6332e62006-11-30 19:16:28 -0800760#endif
Octavian Purdila16bea702014-06-25 17:09:53 +0300761 .init_req = tcp_v6_init_req,
Octavian Purdilafb7b37a2014-06-25 17:09:54 +0300762#ifdef CONFIG_SYN_COOKIES
763 .cookie_init_seq = cookie_v6_init_sequence,
764#endif
Octavian Purdilad94e0412014-06-25 17:09:55 +0300765 .route_req = tcp_v6_route_req,
Octavian Purdila936b8bd2014-06-25 17:09:57 +0300766 .init_seq = tcp_v6_init_sequence,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300767 .send_synack = tcp_v6_send_synack,
Octavian Purdila695da142014-06-25 17:10:01 +0300768 .queue_hash_add = inet6_csk_reqsk_queue_hash_add,
Octavian Purdila16bea702014-06-25 17:09:53 +0300769};
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800770
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700771static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
Wang Yufen9c76a112014-03-29 09:27:31 +0800772 u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100773 struct tcp_md5sig_key *key, int rst, u8 tclass,
774 u32 label)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400776 const struct tcphdr *th = tcp_hdr(skb);
777 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500779 struct flowi6 fl6;
Eric Dumazetadf30902009-06-02 05:19:30 +0000780 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800781 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800782 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000783 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800784 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Andrey Vaginee684b62013-02-11 05:50:19 +0000786 if (tsecr)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700787 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800788#ifdef CONFIG_TCP_MD5SIG
789 if (key)
790 tot_len += TCPOLEN_MD5SIG_ALIGNED;
791#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
794 GFP_ATOMIC);
795 if (buff == NULL)
796 return;
797
798 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
799
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700800 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700801 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
803 /* Swap the send and the receive. */
804 memset(t1, 0, sizeof(*t1));
805 t1->dest = th->source;
806 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700807 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 t1->seq = htonl(seq);
809 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700810 t1->ack = !rst || !th->ack;
811 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800813
Al Viroe69a4adc2006-11-14 20:56:00 -0800814 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900815
Andrey Vaginee684b62013-02-11 05:50:19 +0000816 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800817 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
818 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000819 *topt++ = htonl(tsval);
820 *topt++ = htonl(tsecr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 }
822
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800823#ifdef CONFIG_TCP_MD5SIG
824 if (key) {
825 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
826 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700827 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700828 &ipv6_hdr(skb)->saddr,
829 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800830 }
831#endif
832
David S. Miller4c9483b2011-03-12 16:22:43 -0500833 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000834 fl6.daddr = ipv6_hdr(skb)->saddr;
835 fl6.saddr = ipv6_hdr(skb)->daddr;
Florent Fourcot1d13a962014-01-16 17:21:22 +0100836 fl6.flowlabel = label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
David S. Millere5700af2010-04-21 14:59:20 -0700838 buff->ip_summed = CHECKSUM_PARTIAL;
839 buff->csum = 0;
840
David S. Miller4c9483b2011-03-12 16:22:43 -0500841 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
David S. Miller4c9483b2011-03-12 16:22:43 -0500843 fl6.flowi6_proto = IPPROTO_TCP;
Lorenzo Colittia36dbdb2014-04-11 13:19:12 +0900844 if (rt6_need_strict(&fl6.daddr) && !oif)
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000845 fl6.flowi6_oif = inet6_iif(skb);
Wang Yufen9c76a112014-03-29 09:27:31 +0800846 else
847 fl6.flowi6_oif = oif;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700848 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
David S. Miller1958b852011-03-12 16:36:19 -0500849 fl6.fl6_dport = t1->dest;
850 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500851 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700853 /* Pass a socket to ip6_dst_lookup either it is for RST
854 * Underlying function will use this to retrieve the network
855 * namespace
856 */
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200857 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800858 if (!IS_ERR(dst)) {
859 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400860 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800861 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
862 if (rst)
863 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
864 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 }
866
867 kfree_skb(buff);
868}
869
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700870static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
871{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400872 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700873 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700874 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000875#ifdef CONFIG_TCP_MD5SIG
876 const __u8 *hash_location = NULL;
877 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
878 unsigned char newhash[16];
879 int genhash;
880 struct sock *sk1 = NULL;
881#endif
Wang Yufen9c76a112014-03-29 09:27:31 +0800882 int oif;
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700883
884 if (th->rst)
885 return;
886
887 if (!ipv6_unicast_destination(skb))
888 return;
889
890#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000891 hash_location = tcp_parse_md5sig_option(th);
892 if (!sk && hash_location) {
893 /*
894 * active side is lost. Try to find listening socket through
895 * source port, and then find md5 key through listening socket.
896 * we are not loose security here:
897 * Incoming packet is checked with md5 hash with finding key,
898 * no RST generated if md5 hash doesn't match.
899 */
900 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbert5ba24952013-01-22 09:50:39 +0000901 &tcp_hashinfo, &ipv6h->saddr,
902 th->source, &ipv6h->daddr,
Shawn Lu658ddaa2012-01-31 22:35:48 +0000903 ntohs(th->source), inet6_iif(skb));
904 if (!sk1)
905 return;
906
907 rcu_read_lock();
908 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
909 if (!key)
910 goto release_sk1;
911
912 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
913 if (genhash || memcmp(hash_location, newhash, 16) != 0)
914 goto release_sk1;
915 } else {
916 key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
917 }
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700918#endif
919
920 if (th->ack)
921 seq = ntohl(th->ack_seq);
922 else
923 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
924 (th->doff << 2);
925
Wang Yufen9c76a112014-03-29 09:27:31 +0800926 oif = sk ? sk->sk_bound_dev_if : 0;
927 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000928
929#ifdef CONFIG_TCP_MD5SIG
930release_sk1:
931 if (sk1) {
932 rcu_read_unlock();
933 sock_put(sk1);
934 }
935#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700936}
937
Andrey Vaginee684b62013-02-11 05:50:19 +0000938static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
Wang Yufen9c76a112014-03-29 09:27:31 +0800939 u32 win, u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100940 struct tcp_md5sig_key *key, u8 tclass,
941 u32 label)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700942{
Wang Yufen9c76a112014-03-29 09:27:31 +0800943 tcp_v6_send_response(skb, seq, ack, win, tsval, tsecr, oif, key, 0, tclass,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100944 label);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700945}
946
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
948{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700949 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800950 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900952 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700953 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000954 tcp_time_stamp + tcptw->tw_ts_offset,
Wang Yufen9c76a112014-03-29 09:27:31 +0800955 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
Florent Fourcot1d13a962014-01-16 17:21:22 +0100956 tw->tw_tclass, (tw->tw_flowlabel << 12));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700958 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959}
960
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700961static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
962 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963{
Daniel Lee3a19ce02014-05-11 20:22:13 -0700964 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
965 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
966 */
967 tcp_v6_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
968 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
969 tcp_rsk(req)->rcv_nxt,
Wang Yufen9c76a112014-03-29 09:27:31 +0800970 req->rcv_wnd, tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100971 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
972 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973}
974
975
Weilong Chen4c99aa42013-12-19 18:44:34 +0800976static struct sock *tcp_v6_hnd_req(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700978 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700979 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 struct sock *nsk;
981
982 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800983 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700984 &ipv6_hdr(skb)->saddr,
985 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 if (req)
Jerry Chu83368862012-08-31 12:29:12 +0000987 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900989 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800990 &ipv6_hdr(skb)->saddr, th->source,
991 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993 if (nsk) {
994 if (nsk->sk_state != TCP_TIME_WAIT) {
995 bh_lock_sock(nsk);
996 return nsk;
997 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700998 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 return NULL;
1000 }
1001
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001002#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001003 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001004 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005#endif
1006 return sk;
1007}
1008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1010{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 if (skb->protocol == htons(ETH_P_IP))
1012 return tcp_v4_conn_request(sk, skb);
1013
1014 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001015 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
Octavian Purdila1fb6f152014-06-25 17:10:02 +03001017 return tcp_conn_request(&tcp6_request_sock_ops,
1018 &tcp_request_sock_ipv6_ops, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020drop:
Vijay Subramanian5f1e9422013-01-31 08:24:19 +00001021 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 return 0; /* don't send reset */
1023}
1024
Weilong Chen4c99aa42013-12-19 18:44:34 +08001025static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1026 struct request_sock *req,
1027 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028{
Eric Dumazet634fb9792013-10-09 15:21:29 -07001029 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1031 struct tcp6_sock *newtcp6sk;
1032 struct inet_sock *newinet;
1033 struct tcp_sock *newtp;
1034 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001035#ifdef CONFIG_TCP_MD5SIG
1036 struct tcp_md5sig_key *key;
1037#endif
Neal Cardwell3840a062012-06-28 12:34:19 +00001038 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
1040 if (skb->protocol == htons(ETH_P_IP)) {
1041 /*
1042 * v6 mapped
1043 */
1044
1045 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1046
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001047 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 return NULL;
1049
1050 newtcp6sk = (struct tcp6_sock *)newsk;
1051 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1052
1053 newinet = inet_sk(newsk);
1054 newnp = inet6_sk(newsk);
1055 newtp = tcp_sk(newsk);
1056
1057 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1058
Eric Dumazetefe42082013-10-03 15:42:29 -07001059 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001061 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
Eric Dumazetefe42082013-10-03 15:42:29 -07001063 newsk->sk_v6_rcv_saddr = newnp->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001065 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001067#ifdef CONFIG_TCP_MD5SIG
1068 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1069#endif
1070
Yan, Zheng676a1182011-09-25 02:21:30 +00001071 newnp->ipv6_ac_list = NULL;
1072 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 newnp->pktoptions = NULL;
1074 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001075 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001076 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001077 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001078 if (np->repflow)
1079 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001081 /*
1082 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1083 * here, tcp_create_openreq_child now does this for us, see the comment in
1084 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
1087 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001088 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 Sync it now.
1090 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001091 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
1093 return newsk;
1094 }
1095
Eric Dumazet634fb9792013-10-09 15:21:29 -07001096 ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097
1098 if (sk_acceptq_is_full(sk))
1099 goto out_overflow;
1100
David S. Miller493f3772010-12-02 12:14:29 -08001101 if (!dst) {
Neal Cardwell3840a062012-06-28 12:34:19 +00001102 dst = inet6_csk_route_req(sk, &fl6, req);
David S. Miller493f3772010-12-02 12:14:29 -08001103 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001105 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
1107 newsk = tcp_create_openreq_child(sk, req, skb);
1108 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001109 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001111 /*
1112 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1113 * count here, tcp_create_openreq_child now does this for us, see the
1114 * comment in that function for the gory details. -acme
1115 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
Stephen Hemminger59eed272006-08-25 15:55:43 -07001117 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001118 __ip6_dst_store(newsk, dst, NULL, NULL);
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001119 inet6_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
1121 newtcp6sk = (struct tcp6_sock *)newsk;
1122 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1123
1124 newtp = tcp_sk(newsk);
1125 newinet = inet_sk(newsk);
1126 newnp = inet6_sk(newsk);
1127
1128 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1129
Eric Dumazet634fb9792013-10-09 15:21:29 -07001130 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1131 newnp->saddr = ireq->ir_v6_loc_addr;
1132 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1133 newsk->sk_bound_dev_if = ireq->ir_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001135 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
1137 First: no IPv4 options.
1138 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001139 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001140 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001141 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
1143 /* Clone RX bits */
1144 newnp->rxopt.all = np->rxopt.all;
1145
1146 /* Clone pktoptions received with SYN */
1147 newnp->pktoptions = NULL;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001148 if (ireq->pktopts != NULL) {
1149 newnp->pktoptions = skb_clone(ireq->pktopts,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001150 sk_gfp_atomic(sk, GFP_ATOMIC));
Eric Dumazet634fb9792013-10-09 15:21:29 -07001151 consume_skb(ireq->pktopts);
1152 ireq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 if (newnp->pktoptions)
1154 skb_set_owner_r(newnp->pktoptions, newsk);
1155 }
1156 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001157 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001158 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001159 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001160 if (np->repflow)
1161 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
1163 /* Clone native IPv6 options from listening socket (if any)
1164
1165 Yes, keeping reference count would be much more clever,
1166 but we make one more one thing there: reattach optmem
1167 to newsk.
1168 */
RongQing.Li43264e02012-07-01 17:18:59 +00001169 if (np->opt)
1170 newnp->opt = ipv6_dup_options(newsk, np->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001172 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001174 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1175 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176
1177 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001178 newtp->advmss = dst_metric_advmss(dst);
Neal Cardwelld135c522012-04-22 09:45:47 +00001179 if (tcp_sk(sk)->rx_opt.user_mss &&
1180 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1181 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 tcp_initialize_rcv_mss(newsk);
1184
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001185 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1186 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001188#ifdef CONFIG_TCP_MD5SIG
1189 /* Copy over the MD5 key from the original socket */
Wang Yufen4aa956d2014-03-29 09:27:29 +08001190 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
1191 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001192 /* We're using one, so create a matching key
1193 * on the newsk structure. If we fail to get
1194 * memory, then we end up not copying the key
1195 * across. Shucks.
1196 */
Eric Dumazetefe42082013-10-03 15:42:29 -07001197 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001198 AF_INET6, key->key, key->keylen,
1199 sk_gfp_atomic(sk, GFP_ATOMIC));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001200 }
1201#endif
1202
Balazs Scheidler093d2822010-10-21 13:06:43 +02001203 if (__inet_inherit_port(sk, newsk) < 0) {
Christoph Paasche337e242012-12-14 04:07:58 +00001204 inet_csk_prepare_forced_close(newsk);
1205 tcp_done(newsk);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001206 goto out;
1207 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001208 __inet6_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
1210 return newsk;
1211
1212out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001213 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001214out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001216out:
1217 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 return NULL;
1219}
1220
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221/* The socket must have it's spinlock held when we get
1222 * here.
1223 *
1224 * We have a potential double-lock case here, so even when
1225 * doing backlog processing we use the BH locking scheme.
1226 * This is because we cannot sleep with the original spinlock
1227 * held.
1228 */
1229static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1230{
1231 struct ipv6_pinfo *np = inet6_sk(sk);
1232 struct tcp_sock *tp;
1233 struct sk_buff *opt_skb = NULL;
1234
1235 /* Imagine: socket is IPv6. IPv4 packet arrives,
1236 goes to IPv4 receive handler and backlogged.
1237 From backlog it always goes here. Kerboom...
1238 Fortunately, tcp_rcv_established and rcv_established
1239 handle them correctly, but it is not case with
1240 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1241 */
1242
1243 if (skb->protocol == htons(ETH_P_IP))
1244 return tcp_v4_do_rcv(sk, skb);
1245
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001246#ifdef CONFIG_TCP_MD5SIG
Wang Yufen4aa956d2014-03-29 09:27:29 +08001247 if (tcp_v6_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001248 goto discard;
1249#endif
1250
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001251 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 goto discard;
1253
1254 /*
1255 * socket locking is here for SMP purposes as backlog rcv
1256 * is currently called with bh processing disabled.
1257 */
1258
1259 /* Do Stevens' IPV6_PKTOPTIONS.
1260
1261 Yes, guys, it is the only place in our code, where we
1262 may make it not affecting IPv4.
1263 The rest of code is protocol independent,
1264 and I do not like idea to uglify IPv4.
1265
1266 Actually, all the idea behind IPV6_PKTOPTIONS
1267 looks not very well thought. For now we latch
1268 options, received in the last packet, enqueued
1269 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001270 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 */
1272 if (np->rxopt.all)
Mel Gorman99a1dec2012-07-31 16:44:14 -07001273 opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet5d299f32012-08-06 05:09:33 +00001276 struct dst_entry *dst = sk->sk_rx_dst;
1277
Tom Herbertbdeab992011-08-14 19:45:55 +00001278 sock_rps_save_rxhash(sk, skb);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001279 if (dst) {
1280 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1281 dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1282 dst_release(dst);
1283 sk->sk_rx_dst = NULL;
1284 }
1285 }
1286
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001287 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 if (opt_skb)
1289 goto ipv6_pktoptions;
1290 return 0;
1291 }
1292
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001293 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 goto csum_err;
1295
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001296 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1298 if (!nsk)
1299 goto discard;
1300
1301 /*
1302 * Queue it on the new socket if the new socket is active,
1303 * otherwise we just shortcircuit this and continue with
1304 * the new socket..
1305 */
Weilong Chen4c99aa42013-12-19 18:44:34 +08001306 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001307 sock_rps_save_rxhash(nsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 if (tcp_child_process(sk, nsk, skb))
1309 goto reset;
1310 if (opt_skb)
1311 __kfree_skb(opt_skb);
1312 return 0;
1313 }
Neil Horman47482f12011-04-06 13:07:09 -07001314 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001315 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001317 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 if (opt_skb)
1320 goto ipv6_pktoptions;
1321 return 0;
1322
1323reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001324 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325discard:
1326 if (opt_skb)
1327 __kfree_skb(opt_skb);
1328 kfree_skb(skb);
1329 return 0;
1330csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001331 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07001332 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 goto discard;
1334
1335
1336ipv6_pktoptions:
1337 /* Do you ask, what is it?
1338
1339 1. skb was enqueued by tcp.
1340 2. skb is added to tail of read queue, rather than out of order.
1341 3. socket is not in passive state.
1342 4. Finally, it really contains options, which user wants to receive.
1343 */
1344 tp = tcp_sk(sk);
1345 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1346 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001347 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001348 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001349 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001350 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Florent Fourcot82e9f102013-12-08 15:46:59 +01001351 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
Florent Fourcot1397ed32013-12-08 15:46:57 +01001352 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001353 if (np->repflow)
1354 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 if (ipv6_opt_accepted(sk, opt_skb)) {
1356 skb_set_owner_r(opt_skb, sk);
1357 opt_skb = xchg(&np->pktoptions, opt_skb);
1358 } else {
1359 __kfree_skb(opt_skb);
1360 opt_skb = xchg(&np->pktoptions, NULL);
1361 }
1362 }
1363
Wei Yongjun800d55f2009-02-23 21:45:33 +00001364 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 return 0;
1366}
1367
Herbert Xue5bbef22007-10-15 12:50:28 -07001368static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001370 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001371 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 struct sock *sk;
1373 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001374 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
1376 if (skb->pkt_type != PACKET_HOST)
1377 goto discard_it;
1378
1379 /*
1380 * Count it even if it's bad.
1381 */
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07001382 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383
1384 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1385 goto discard_it;
1386
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001387 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388
1389 if (th->doff < sizeof(struct tcphdr)/4)
1390 goto bad_packet;
1391 if (!pskb_may_pull(skb, th->doff*4))
1392 goto discard_it;
1393
Tom Herberte4f45b72014-05-02 16:29:51 -07001394 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001395 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001397 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001398 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1400 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1401 skb->len - th->doff*4);
1402 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1403 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001404 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 TCP_SKB_CB(skb)->sacked = 0;
1406
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001407 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 if (!sk)
1409 goto no_tcp_socket;
1410
1411process:
1412 if (sk->sk_state == TCP_TIME_WAIT)
1413 goto do_time_wait;
1414
Stephen Hemmingere802af92010-04-22 15:24:53 -07001415 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1416 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1417 goto discard_and_relse;
1418 }
1419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1421 goto discard_and_relse;
1422
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001423 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 goto discard_and_relse;
1425
Eliezer Tamir8b80cda2013-07-10 17:13:26 +03001426 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 skb->dev = NULL;
1428
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001429 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 ret = 0;
1431 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001432#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001433 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001434 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dave Jianga2bd1142012-04-04 16:10:46 -07001435 tp->ucopy.dma_chan = net_dma_find_channel();
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001436 if (tp->ucopy.dma_chan)
1437 ret = tcp_v6_do_rcv(sk, skb);
1438 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001439#endif
1440 {
1441 if (!tcp_prequeue(sk, skb))
1442 ret = tcp_v6_do_rcv(sk, skb);
1443 }
Eric Dumazetda882c12012-04-22 23:38:54 +00001444 } else if (unlikely(sk_add_backlog(sk, skb,
1445 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001446 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001447 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001448 goto discard_and_relse;
1449 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 bh_unlock_sock(sk);
1451
1452 sock_put(sk);
1453 return ret ? -1 : 0;
1454
1455no_tcp_socket:
1456 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1457 goto discard_it;
1458
1459 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001460csum_error:
1461 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462bad_packet:
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07001463 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001465 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 }
1467
1468discard_it:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 kfree_skb(skb);
1470 return 0;
1471
1472discard_and_relse:
1473 sock_put(sk);
1474 goto discard_it;
1475
1476do_time_wait:
1477 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001478 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 goto discard_it;
1480 }
1481
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001482 if (skb->len < (th->doff<<2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001483 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001484 goto bad_packet;
1485 }
1486 if (tcp_checksum_complete(skb)) {
1487 inet_twsk_put(inet_twsk(sk));
1488 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 }
1490
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001491 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 case TCP_TW_SYN:
1493 {
1494 struct sock *sk2;
1495
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001496 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Tom Herbert5ba24952013-01-22 09:50:39 +00001497 &ipv6_hdr(skb)->saddr, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001498 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001499 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001501 struct inet_timewait_sock *tw = inet_twsk(sk);
1502 inet_twsk_deschedule(tw, &tcp_death_row);
1503 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 sk = sk2;
1505 goto process;
1506 }
1507 /* Fall through to ACK */
1508 }
1509 case TCP_TW_ACK:
1510 tcp_v6_timewait_ack(sk, skb);
1511 break;
1512 case TCP_TW_RST:
1513 goto no_tcp_socket;
Wang Yufen4aa956d2014-03-29 09:27:29 +08001514 case TCP_TW_SUCCESS:
1515 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 }
1517 goto discard_it;
1518}
1519
Eric Dumazetc7109982012-07-26 12:18:11 +00001520static void tcp_v6_early_demux(struct sk_buff *skb)
1521{
1522 const struct ipv6hdr *hdr;
1523 const struct tcphdr *th;
1524 struct sock *sk;
1525
1526 if (skb->pkt_type != PACKET_HOST)
1527 return;
1528
1529 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1530 return;
1531
1532 hdr = ipv6_hdr(skb);
1533 th = tcp_hdr(skb);
1534
1535 if (th->doff < sizeof(struct tcphdr) / 4)
1536 return;
1537
1538 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1539 &hdr->saddr, th->source,
1540 &hdr->daddr, ntohs(th->dest),
1541 inet6_iif(skb));
1542 if (sk) {
1543 skb->sk = sk;
1544 skb->destructor = sock_edemux;
1545 if (sk->sk_state != TCP_TIME_WAIT) {
1546 struct dst_entry *dst = sk->sk_rx_dst;
Neal Cardwellf3f12132012-10-22 21:41:48 +00001547
Eric Dumazetc7109982012-07-26 12:18:11 +00001548 if (dst)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001549 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
Eric Dumazetc7109982012-07-26 12:18:11 +00001550 if (dst &&
Neal Cardwellf3f12132012-10-22 21:41:48 +00001551 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
Eric Dumazetc7109982012-07-26 12:18:11 +00001552 skb_dst_set_noref(skb, dst);
1553 }
1554 }
1555}
1556
David S. Millerccb7c412010-12-01 18:09:13 -08001557static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1558 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1559 .twsk_unique = tcp_twsk_unique,
Wang Yufen4aa956d2014-03-29 09:27:29 +08001560 .twsk_destructor = tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001561};
1562
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001563static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001564 .queue_xmit = inet6_csk_xmit,
1565 .send_check = tcp_v6_send_check,
1566 .rebuild_header = inet6_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001567 .sk_rx_dst_set = inet6_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001568 .conn_request = tcp_v6_conn_request,
1569 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001570 .net_header_len = sizeof(struct ipv6hdr),
Eric Dumazet67469602012-04-24 07:37:38 +00001571 .net_frag_header_len = sizeof(struct frag_hdr),
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001572 .setsockopt = ipv6_setsockopt,
1573 .getsockopt = ipv6_getsockopt,
1574 .addr2sockaddr = inet6_csk_addr2sockaddr,
1575 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001576 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001577#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001578 .compat_setsockopt = compat_ipv6_setsockopt,
1579 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001580#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581};
1582
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001583#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001584static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001585 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001586 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001587 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001588};
David S. Millera9286302006-11-14 19:53:22 -08001589#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001590
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591/*
1592 * TCP over IPv4 via INET6 API
1593 */
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001594static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001595 .queue_xmit = ip_queue_xmit,
1596 .send_check = tcp_v4_send_check,
1597 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet63d02d12012-08-09 14:11:00 +00001598 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001599 .conn_request = tcp_v6_conn_request,
1600 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001601 .net_header_len = sizeof(struct iphdr),
1602 .setsockopt = ipv6_setsockopt,
1603 .getsockopt = ipv6_getsockopt,
1604 .addr2sockaddr = inet6_csk_addr2sockaddr,
1605 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001606 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001607#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001608 .compat_setsockopt = compat_ipv6_setsockopt,
1609 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001610#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611};
1612
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001613#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001614static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001615 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001616 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001617 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001618};
David S. Millera9286302006-11-14 19:53:22 -08001619#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001620
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621/* NOTE: A lot of things set to zero explicitly by call to
1622 * sk_alloc() so need not be done here.
1623 */
1624static int tcp_v6_init_sock(struct sock *sk)
1625{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001626 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
Neal Cardwell900f65d2012-04-19 09:55:21 +00001628 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001630 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001632#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001633 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001634#endif
1635
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 return 0;
1637}
1638
Brian Haley7d06b2e2008-06-14 17:04:49 -07001639static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001642 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643}
1644
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001645#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001647static void get_openreq6(struct seq_file *seq,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001648 const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 int ttd = req->expires - jiffies;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001651 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1652 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
1654 if (ttd < 0)
1655 ttd = 0;
1656
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 seq_printf(seq,
1658 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001659 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 i,
1661 src->s6_addr32[0], src->s6_addr32[1],
1662 src->s6_addr32[2], src->s6_addr32[3],
Eric Dumazetb44084c2013-10-10 00:04:37 -07001663 inet_rsk(req)->ir_num,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 dest->s6_addr32[0], dest->s6_addr32[1],
1665 dest->s6_addr32[2], dest->s6_addr32[3],
Eric Dumazet634fb9792013-10-09 15:21:29 -07001666 ntohs(inet_rsk(req)->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 TCP_SYN_RECV,
Weilong Chen4c99aa42013-12-19 18:44:34 +08001668 0, 0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001669 1, /* timers active (only the expire timer) */
1670 jiffies_to_clock_t(ttd),
Eric Dumazete6c022a2012-10-27 23:16:46 +00001671 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001672 from_kuid_munged(seq_user_ns(seq), uid),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001673 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 0, /* open_requests have no inode */
1675 0, req);
1676}
1677
1678static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1679{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001680 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 __u16 destp, srcp;
1682 int timer_active;
1683 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001684 const struct inet_sock *inet = inet_sk(sp);
1685 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001686 const struct inet_connection_sock *icsk = inet_csk(sp);
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001687 struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
Eric Dumazetefe42082013-10-03 15:42:29 -07001689 dest = &sp->sk_v6_daddr;
1690 src = &sp->sk_v6_rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001691 destp = ntohs(inet->inet_dport);
1692 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001693
1694 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001696 timer_expires = icsk->icsk_timeout;
1697 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001699 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 } else if (timer_pending(&sp->sk_timer)) {
1701 timer_active = 2;
1702 timer_expires = sp->sk_timer.expires;
1703 } else {
1704 timer_active = 0;
1705 timer_expires = jiffies;
1706 }
1707
1708 seq_printf(seq,
1709 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001710 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 i,
1712 src->s6_addr32[0], src->s6_addr32[1],
1713 src->s6_addr32[2], src->s6_addr32[3], srcp,
1714 dest->s6_addr32[0], dest->s6_addr32[1],
1715 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001716 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001717 tp->write_seq-tp->snd_una,
1718 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00001720 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001721 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001722 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001723 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 sock_i_ino(sp),
1725 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001726 jiffies_to_clock_t(icsk->icsk_rto),
1727 jiffies_to_clock_t(icsk->icsk_ack.ato),
Weilong Chen4c99aa42013-12-19 18:44:34 +08001728 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001729 tp->snd_cwnd,
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001730 sp->sk_state == TCP_LISTEN ?
1731 (fastopenq ? fastopenq->max_qlen : 0) :
1732 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 );
1734}
1735
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001736static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001737 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001739 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 __u16 destp, srcp;
Eric Dumazet96f817f2013-10-03 14:27:25 -07001741 s32 delta = tw->tw_ttd - inet_tw_time_stamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742
Eric Dumazetefe42082013-10-03 15:42:29 -07001743 dest = &tw->tw_v6_daddr;
1744 src = &tw->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 destp = ntohs(tw->tw_dport);
1746 srcp = ntohs(tw->tw_sport);
1747
1748 seq_printf(seq,
1749 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001750 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 i,
1752 src->s6_addr32[0], src->s6_addr32[1],
1753 src->s6_addr32[2], src->s6_addr32[3], srcp,
1754 dest->s6_addr32[0], dest->s6_addr32[1],
1755 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1756 tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00001757 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 atomic_read(&tw->tw_refcnt), tw);
1759}
1760
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761static int tcp6_seq_show(struct seq_file *seq, void *v)
1762{
1763 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001764 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765
1766 if (v == SEQ_START_TOKEN) {
1767 seq_puts(seq,
1768 " sl "
1769 "local_address "
1770 "remote_address "
1771 "st tx_queue rx_queue tr tm->when retrnsmt"
1772 " uid timeout inode\n");
1773 goto out;
1774 }
1775 st = seq->private;
1776
1777 switch (st->state) {
1778 case TCP_SEQ_STATE_LISTENING:
1779 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001780 if (sk->sk_state == TCP_TIME_WAIT)
1781 get_timewait6_sock(seq, v, st->num);
1782 else
1783 get_tcp6_sock(seq, v, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 break;
1785 case TCP_SEQ_STATE_OPENREQ:
1786 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1787 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 }
1789out:
1790 return 0;
1791}
1792
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001793static const struct file_operations tcp6_afinfo_seq_fops = {
1794 .owner = THIS_MODULE,
1795 .open = tcp_seq_open,
1796 .read = seq_read,
1797 .llseek = seq_lseek,
1798 .release = seq_release_net
1799};
1800
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 .name = "tcp6",
1803 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001804 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07001805 .seq_ops = {
1806 .show = tcp6_seq_show,
1807 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808};
1809
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001810int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001812 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813}
1814
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001815void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001817 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818}
1819#endif
1820
Eric Dumazetf77d6022013-05-09 10:28:16 +00001821static void tcp_v6_clear_sk(struct sock *sk, int size)
1822{
1823 struct inet_sock *inet = inet_sk(sk);
1824
1825 /* we do not want to clear pinet6 field, because of RCU lookups */
1826 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1827
1828 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1829 memset(&inet->pinet6 + 1, 0, size);
1830}
1831
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832struct proto tcpv6_prot = {
1833 .name = "TCPv6",
1834 .owner = THIS_MODULE,
1835 .close = tcp_close,
1836 .connect = tcp_v6_connect,
1837 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001838 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 .ioctl = tcp_ioctl,
1840 .init = tcp_v6_init_sock,
1841 .destroy = tcp_v6_destroy_sock,
1842 .shutdown = tcp_shutdown,
1843 .setsockopt = tcp_setsockopt,
1844 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00001846 .sendmsg = tcp_sendmsg,
1847 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 .backlog_rcv = tcp_v6_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00001849 .release_cb = tcp_release_cb,
Eric Dumazet563d34d2012-07-23 09:48:52 +02001850 .mtu_reduced = tcp_v6_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001852 .unhash = inet_unhash,
1853 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07001855 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 .sockets_allocated = &tcp_sockets_allocated,
1857 .memory_allocated = &tcp_memory_allocated,
1858 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001859 .orphan_count = &tcp_orphan_count,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07001860 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 .sysctl_wmem = sysctl_tcp_wmem,
1862 .sysctl_rmem = sysctl_tcp_rmem,
1863 .max_header = MAX_TCP_HEADER,
1864 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001865 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001866 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001867 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07001868 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00001869 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001870#ifdef CONFIG_COMPAT
1871 .compat_setsockopt = compat_tcp_setsockopt,
1872 .compat_getsockopt = compat_tcp_getsockopt,
1873#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07001874#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001875 .proto_cgroup = tcp_proto_cgroup,
1876#endif
Eric Dumazetf77d6022013-05-09 10:28:16 +00001877 .clear_sk = tcp_v6_clear_sk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878};
1879
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00001880static const struct inet6_protocol tcpv6_protocol = {
Eric Dumazetc7109982012-07-26 12:18:11 +00001881 .early_demux = tcp_v6_early_demux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 .handler = tcp_v6_rcv,
1883 .err_handler = tcp_v6_err,
1884 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1885};
1886
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887static struct inet_protosw tcpv6_protosw = {
1888 .type = SOCK_STREAM,
1889 .protocol = IPPROTO_TCP,
1890 .prot = &tcpv6_prot,
1891 .ops = &inet6_stream_ops,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001892 .flags = INET_PROTOSW_PERMANENT |
1893 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894};
1895
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001896static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001897{
Denis V. Lunev56772422008-04-03 14:28:30 -07001898 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1899 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001900}
1901
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001902static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001903{
Denis V. Lunev56772422008-04-03 14:28:30 -07001904 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001905}
1906
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001907static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001908{
1909 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001910}
1911
1912static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001913 .init = tcpv6_net_init,
1914 .exit = tcpv6_net_exit,
1915 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001916};
1917
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001918int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001920 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08001921
Vlad Yasevich33362882012-11-15 08:49:15 +00001922 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1923 if (ret)
Vlad Yasevichc6b641a2012-11-15 08:49:22 +00001924 goto out;
Vlad Yasevich33362882012-11-15 08:49:15 +00001925
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001926 /* register inet6 protocol */
1927 ret = inet6_register_protosw(&tcpv6_protosw);
1928 if (ret)
1929 goto out_tcpv6_protocol;
1930
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001931 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001932 if (ret)
1933 goto out_tcpv6_protosw;
1934out:
1935 return ret;
1936
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001937out_tcpv6_protosw:
1938 inet6_unregister_protosw(&tcpv6_protosw);
Vlad Yasevich33362882012-11-15 08:49:15 +00001939out_tcpv6_protocol:
1940 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001941 goto out;
1942}
1943
Daniel Lezcano09f77092007-12-13 05:34:58 -08001944void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001945{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001946 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001947 inet6_unregister_protosw(&tcpv6_protosw);
1948 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949}