blob: 6e1649d58533fd9a1b0a3f9f4373348a625bfb60 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
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
68#include <asm/uaccess.h>
69
70#include <linux/proc_fs.h>
71#include <linux/seq_file.h>
72
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080073#include <linux/crypto.h>
74#include <linux/scatterlist.h>
75
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080076static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070077static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
78 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Stephen Hemminger3b401a82009-09-01 19:25:04 +000082static const struct inet_connection_sock_af_ops ipv6_mapped;
83static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080084#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000085static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
86static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090087#else
88static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000089 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090090{
91 return NULL;
92}
David S. Millera9286302006-11-14 19:53:22 -080093#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Neal Cardwellfae6ef82012-08-19 03:30:38 +000095static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
96{
97 struct dst_entry *dst = skb_dst(skb);
98 const struct rt6_info *rt = (const struct rt6_info *)dst;
99
100 dst_hold(dst);
101 sk->sk_rx_dst = dst;
102 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
103 if (rt->rt6i_node)
104 inet6_sk(sk)->rx_dst_cookie = rt->rt6i_node->fn_sernum;
105}
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107static void tcp_v6_hash(struct sock *sk)
108{
109 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800110 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 tcp_prot.hash(sk);
112 return;
113 }
114 local_bh_disable();
Eric Dumazet9327f702009-12-04 03:46:54 +0000115 __inet6_hash(sk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 local_bh_enable();
117 }
118}
119
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400120static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700122 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
123 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700124 tcp_hdr(skb)->dest,
125 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126}
127
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900128static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 int addr_len)
130{
131 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900132 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800133 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 struct ipv6_pinfo *np = inet6_sk(sk);
135 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000136 struct in6_addr *saddr = NULL, *final_p, final;
David S. Miller493f3772010-12-02 12:14:29 -0800137 struct rt6_info *rt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500138 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 struct dst_entry *dst;
140 int addr_type;
141 int err;
142
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900143 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 return -EINVAL;
145
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900146 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000147 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
David S. Miller4c9483b2011-03-12 16:22:43 -0500149 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
151 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500152 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
153 IP6_ECN_flow_init(fl6.flowlabel);
154 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 struct ip6_flowlabel *flowlabel;
David S. Miller4c9483b2011-03-12 16:22:43 -0500156 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 if (flowlabel == NULL)
158 return -EINVAL;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000159 usin->sin6_addr = flowlabel->dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 fl6_sock_release(flowlabel);
161 }
162 }
163
164 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900165 * connect() to INADDR_ANY means loopback (BSD'ism).
166 */
167
168 if(ipv6_addr_any(&usin->sin6_addr))
169 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 addr_type = ipv6_addr_type(&usin->sin6_addr);
172
173 if(addr_type & IPV6_ADDR_MULTICAST)
174 return -ENETUNREACH;
175
176 if (addr_type&IPV6_ADDR_LINKLOCAL) {
177 if (addr_len >= sizeof(struct sockaddr_in6) &&
178 usin->sin6_scope_id) {
179 /* If interface is set while binding, indices
180 * must coincide.
181 */
182 if (sk->sk_bound_dev_if &&
183 sk->sk_bound_dev_if != usin->sin6_scope_id)
184 return -EINVAL;
185
186 sk->sk_bound_dev_if = usin->sin6_scope_id;
187 }
188
189 /* Connect to link-local address requires an interface */
190 if (!sk->sk_bound_dev_if)
191 return -EINVAL;
192 }
193
194 if (tp->rx_opt.ts_recent_stamp &&
195 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
196 tp->rx_opt.ts_recent = 0;
197 tp->rx_opt.ts_recent_stamp = 0;
198 tp->write_seq = 0;
199 }
200
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000201 np->daddr = usin->sin6_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500202 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
204 /*
205 * TCP over IPv4
206 */
207
208 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800209 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 struct sockaddr_in sin;
211
212 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
213
214 if (__ipv6_only_sock(sk))
215 return -ENETUNREACH;
216
217 sin.sin_family = AF_INET;
218 sin.sin_port = usin->sin6_port;
219 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
220
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800221 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800223#ifdef CONFIG_TCP_MD5SIG
224 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
225#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
227 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
228
229 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800230 icsk->icsk_ext_hdr_len = exthdrlen;
231 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800233#ifdef CONFIG_TCP_MD5SIG
234 tp->af_specific = &tcp_sock_ipv6_specific;
235#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 goto failure;
237 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000238 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
239 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
240 &np->rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 }
242
243 return err;
244 }
245
246 if (!ipv6_addr_any(&np->rcv_saddr))
247 saddr = &np->rcv_saddr;
248
David S. Miller4c9483b2011-03-12 16:22:43 -0500249 fl6.flowi6_proto = IPPROTO_TCP;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000250 fl6.daddr = np->daddr;
251 fl6.saddr = saddr ? *saddr : np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500252 fl6.flowi6_oif = sk->sk_bound_dev_if;
253 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500254 fl6.fl6_dport = usin->sin6_port;
255 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
David S. Miller4c9483b2011-03-12 16:22:43 -0500257 final_p = fl6_update_dst(&fl6, np->opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
David S. Miller4c9483b2011-03-12 16:22:43 -0500259 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700260
David S. Miller4c9483b2011-03-12 16:22:43 -0500261 dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800262 if (IS_ERR(dst)) {
263 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 goto failure;
David S. Miller14e50e52007-05-24 18:17:54 -0700265 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
267 if (saddr == NULL) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500268 saddr = &fl6.saddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000269 np->rcv_saddr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 }
271
272 /* set the source address */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000273 np->saddr = *saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000274 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700276 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700277 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
David S. Miller493f3772010-12-02 12:14:29 -0800279 rt = (struct rt6_info *) dst;
280 if (tcp_death_row.sysctl_tw_recycle &&
281 !tp->rx_opt.ts_recent_stamp &&
David S. Miller81166dd2012-07-10 03:14:24 -0700282 ipv6_addr_equal(&rt->rt6i_dst.addr, &np->daddr))
283 tcp_fetch_timewait_stamp(sk, dst);
David S. Miller493f3772010-12-02 12:14:29 -0800284
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800285 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800287 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
288 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
291
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000292 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800295 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 if (err)
297 goto late_failure;
298
Andrey Vagin2b916472012-11-22 01:13:58 +0000299 if (!tp->write_seq && likely(!tp->repair))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
301 np->daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000302 inet->inet_sport,
303 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 err = tcp_connect(sk);
306 if (err)
307 goto late_failure;
308
309 return 0;
310
311late_failure:
312 tcp_set_state(sk, TCP_CLOSE);
313 __sk_dst_reset(sk);
314failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000315 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 sk->sk_route_caps = 0;
317 return err;
318}
319
Eric Dumazet563d34d2012-07-23 09:48:52 +0200320static void tcp_v6_mtu_reduced(struct sock *sk)
321{
322 struct dst_entry *dst;
323
324 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
325 return;
326
327 dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
328 if (!dst)
329 return;
330
331 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
332 tcp_sync_mss(sk, dst_mtu(dst));
333 tcp_simple_retransmit(sk);
334 }
335}
336
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700338 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000340 const struct ipv6hdr *hdr = (const struct ipv6hdr*)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300341 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 struct ipv6_pinfo *np;
343 struct sock *sk;
344 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900345 struct tcp_sock *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 __u32 seq;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700347 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700349 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800350 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700353 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
354 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return;
356 }
357
358 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700359 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 return;
361 }
362
363 bh_lock_sock(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200364 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700365 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367 if (sk->sk_state == TCP_CLOSE)
368 goto out;
369
Stephen Hemmingere802af92010-04-22 15:24:53 -0700370 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
371 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
372 goto out;
373 }
374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900376 seq = ntohl(th->seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 if (sk->sk_state != TCP_LISTEN &&
378 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700379 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 goto out;
381 }
382
383 np = inet6_sk(sk);
384
David S. Millerec18d9a2012-07-12 00:25:15 -0700385 if (type == NDISC_REDIRECT) {
386 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
387
David S. Miller1ed5c482012-07-12 00:41:25 -0700388 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700389 dst->ops->redirect(dst, sk, skb);
Christoph Paasch50a75a82013-04-07 04:53:15 +0000390 goto out;
David S. Millerec18d9a2012-07-12 00:25:15 -0700391 }
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 if (type == ICMPV6_PKT_TOOBIG) {
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000394 /* We are not interested in TCP_LISTEN and open_requests
395 * (SYN-ACKs send out by Linux are always <576bytes so
396 * they should go through unfragmented).
397 */
398 if (sk->sk_state == TCP_LISTEN)
399 goto out;
400
Eric Dumazet563d34d2012-07-23 09:48:52 +0200401 tp->mtu_info = ntohl(info);
402 if (!sock_owned_by_user(sk))
403 tcp_v6_mtu_reduced(sk);
Julian Anastasovd013ef2a2012-09-05 10:53:18 +0000404 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
405 &tp->tsq_flags))
406 sock_hold(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 goto out;
408 }
409
410 icmpv6_err_convert(type, code, &err);
411
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700412 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700414 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 case TCP_LISTEN:
416 if (sock_owned_by_user(sk))
417 goto out;
418
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800419 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
420 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 if (!req)
422 goto out;
423
424 /* ICMPs are not backlogged, hence we cannot get
425 * an established socket here.
426 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700427 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700429 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700430 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 goto out;
432 }
433
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700434 inet_csk_reqsk_queue_drop(sk, req, prev);
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000435 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 goto out;
437
438 case TCP_SYN_SENT:
439 case TCP_SYN_RECV: /* Cannot happen.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900440 It can, it SYNs are crossed. --ANK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 sk->sk_err = err;
443 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
444
445 tcp_done(sk);
446 } else
447 sk->sk_err_soft = err;
448 goto out;
449 }
450
451 if (!sock_owned_by_user(sk) && np->recverr) {
452 sk->sk_err = err;
453 sk->sk_error_report(sk);
454 } else
455 sk->sk_err_soft = err;
456
457out:
458 bh_unlock_sock(sk);
459 sock_put(sk);
460}
461
462
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000463static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
464 struct flowi6 *fl6,
Neal Cardwell3840a062012-06-28 12:34:19 +0000465 struct request_sock *req,
Eric Dumazetfff32692012-06-01 01:47:50 +0000466 u16 queue_mapping)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800468 struct inet6_request_sock *treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 struct ipv6_pinfo *np = inet6_sk(sk);
470 struct sk_buff * skb;
Neal Cardwell94942182012-06-28 12:34:20 +0000471 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000473 /* First, grab a route. */
474 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800475 goto done;
Neal Cardwell94942182012-06-28 12:34:20 +0000476
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000477 skb = tcp_make_synack(sk, dst, req, NULL);
Neal Cardwell94942182012-06-28 12:34:20 +0000478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 if (skb) {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000480 __tcp_v6_send_check(skb, &treq->loc_addr, &treq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000482 fl6->daddr = treq->rmt_addr;
Eric Dumazetfff32692012-06-01 01:47:50 +0000483 skb_set_queue_mapping(skb, queue_mapping);
RongQing.Li43264e02012-07-01 17:18:59 +0000484 err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200485 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 }
487
488done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 return err;
490}
491
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000492static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req)
Octavian Purdila72659ec2010-01-17 19:09:39 -0800493{
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000494 struct flowi6 fl6;
Eric Dumazete6c022a2012-10-27 23:16:46 +0000495 int res;
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000496
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000497 res = tcp_v6_send_synack(sk, NULL, &fl6, req, 0);
Eric Dumazete6c022a2012-10-27 23:16:46 +0000498 if (!res)
499 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
500 return res;
Octavian Purdila72659ec2010-01-17 19:09:39 -0800501}
502
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700503static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504{
Wei Yongjun800d55f2009-02-23 21:45:33 +0000505 kfree_skb(inet6_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506}
507
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800508#ifdef CONFIG_TCP_MD5SIG
509static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000510 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800511{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000512 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800513}
514
515static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
516 struct sock *addr_sk)
517{
518 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
519}
520
521static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
522 struct request_sock *req)
523{
524 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
525}
526
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800527static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
528 int optlen)
529{
530 struct tcp_md5sig cmd;
531 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800532
533 if (optlen < sizeof(cmd))
534 return -EINVAL;
535
536 if (copy_from_user(&cmd, optval, sizeof(cmd)))
537 return -EFAULT;
538
539 if (sin6->sin6_family != AF_INET6)
540 return -EINVAL;
541
542 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700543 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000544 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
545 AF_INET);
546 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
547 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800548 }
549
550 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
551 return -EINVAL;
552
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000553 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
554 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
555 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800556
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000557 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
558 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800559}
560
Adam Langley49a72df2008-07-19 00:01:42 -0700561static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000562 const struct in6_addr *daddr,
563 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800564{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800565 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700566 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900567
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800568 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800569 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000570 bp->saddr = *saddr;
571 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700572 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700573 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800574
Adam Langley49a72df2008-07-19 00:01:42 -0700575 sg_init_one(&sg, bp, sizeof(*bp));
576 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
577}
David S. Millerc7da57a2007-10-26 00:41:21 -0700578
Adam Langley49a72df2008-07-19 00:01:42 -0700579static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000580 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400581 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700582{
583 struct tcp_md5sig_pool *hp;
584 struct hash_desc *desc;
585
586 hp = tcp_get_md5sig_pool();
587 if (!hp)
588 goto clear_hash_noput;
589 desc = &hp->md5_desc;
590
591 if (crypto_hash_init(desc))
592 goto clear_hash;
593 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
594 goto clear_hash;
595 if (tcp_md5_hash_header(hp, th))
596 goto clear_hash;
597 if (tcp_md5_hash_key(hp, key))
598 goto clear_hash;
599 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800600 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800601
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800602 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800603 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700604
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800605clear_hash:
606 tcp_put_md5sig_pool();
607clear_hash_noput:
608 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700609 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800610}
611
Adam Langley49a72df2008-07-19 00:01:42 -0700612static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400613 const struct sock *sk,
614 const struct request_sock *req,
615 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800616{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000617 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700618 struct tcp_md5sig_pool *hp;
619 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400620 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800621
622 if (sk) {
623 saddr = &inet6_sk(sk)->saddr;
624 daddr = &inet6_sk(sk)->daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700625 } else if (req) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800626 saddr = &inet6_rsk(req)->loc_addr;
627 daddr = &inet6_rsk(req)->rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700628 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000629 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700630 saddr = &ip6h->saddr;
631 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800632 }
Adam Langley49a72df2008-07-19 00:01:42 -0700633
634 hp = tcp_get_md5sig_pool();
635 if (!hp)
636 goto clear_hash_noput;
637 desc = &hp->md5_desc;
638
639 if (crypto_hash_init(desc))
640 goto clear_hash;
641
642 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
643 goto clear_hash;
644 if (tcp_md5_hash_header(hp, th))
645 goto clear_hash;
646 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
647 goto clear_hash;
648 if (tcp_md5_hash_key(hp, key))
649 goto clear_hash;
650 if (crypto_hash_final(desc, md5_hash))
651 goto clear_hash;
652
653 tcp_put_md5sig_pool();
654 return 0;
655
656clear_hash:
657 tcp_put_md5sig_pool();
658clear_hash_noput:
659 memset(md5_hash, 0, 16);
660 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800661}
662
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400663static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800664{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400665 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800666 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000667 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400668 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800669 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800670 u8 newhash[16];
671
672 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900673 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800674
David S. Miller785957d2008-07-30 03:03:15 -0700675 /* We've parsed the options - do we have a hash? */
676 if (!hash_expected && !hash_location)
677 return 0;
678
679 if (hash_expected && !hash_location) {
680 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800681 return 1;
682 }
683
David S. Miller785957d2008-07-30 03:03:15 -0700684 if (!hash_expected && hash_location) {
685 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800686 return 1;
687 }
688
689 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700690 genhash = tcp_v6_md5_hash_skb(newhash,
691 hash_expected,
692 NULL, NULL, skb);
693
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800694 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +0000695 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
696 genhash ? "failed" : "mismatch",
697 &ip6h->saddr, ntohs(th->source),
698 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800699 return 1;
700 }
701 return 0;
702}
703#endif
704
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800705struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700707 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -0800708 .rtx_syn_ack = tcp_v6_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700709 .send_ack = tcp_v6_reqsk_send_ack,
710 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800711 .send_reset = tcp_v6_send_reset,
712 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713};
714
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800715#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000716static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800717 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000718 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800719};
Andrew Mortonb6332e62006-11-30 19:16:28 -0800720#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800721
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700722static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
Andrey Vaginee684b62013-02-11 05:50:19 +0000723 u32 tsval, u32 tsecr,
724 struct tcp_md5sig_key *key, int rst, u8 tclass)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400726 const struct tcphdr *th = tcp_hdr(skb);
727 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500729 struct flowi6 fl6;
Eric Dumazetadf30902009-06-02 05:19:30 +0000730 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800731 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800732 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000733 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800734 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Andrey Vaginee684b62013-02-11 05:50:19 +0000736 if (tsecr)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700737 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800738#ifdef CONFIG_TCP_MD5SIG
739 if (key)
740 tot_len += TCPOLEN_MD5SIG_ALIGNED;
741#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
743 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
744 GFP_ATOMIC);
745 if (buff == NULL)
746 return;
747
748 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
749
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700750 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700751 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
753 /* Swap the send and the receive. */
754 memset(t1, 0, sizeof(*t1));
755 t1->dest = th->source;
756 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700757 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 t1->seq = htonl(seq);
759 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700760 t1->ack = !rst || !th->ack;
761 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800763
Al Viroe69a4adc2006-11-14 20:56:00 -0800764 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900765
Andrey Vaginee684b62013-02-11 05:50:19 +0000766 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800767 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
768 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000769 *topt++ = htonl(tsval);
770 *topt++ = htonl(tsecr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 }
772
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800773#ifdef CONFIG_TCP_MD5SIG
774 if (key) {
775 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
776 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700777 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700778 &ipv6_hdr(skb)->saddr,
779 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800780 }
781#endif
782
David S. Miller4c9483b2011-03-12 16:22:43 -0500783 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000784 fl6.daddr = ipv6_hdr(skb)->saddr;
785 fl6.saddr = ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
David S. Millere5700af2010-04-21 14:59:20 -0700787 buff->ip_summed = CHECKSUM_PARTIAL;
788 buff->csum = 0;
789
David S. Miller4c9483b2011-03-12 16:22:43 -0500790 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
David S. Miller4c9483b2011-03-12 16:22:43 -0500792 fl6.flowi6_proto = IPPROTO_TCP;
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000793 if (ipv6_addr_type(&fl6.daddr) & IPV6_ADDR_LINKLOCAL)
794 fl6.flowi6_oif = inet6_iif(skb);
David S. Miller1958b852011-03-12 16:36:19 -0500795 fl6.fl6_dport = t1->dest;
796 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500797 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700799 /* Pass a socket to ip6_dst_lookup either it is for RST
800 * Underlying function will use this to retrieve the network
801 * namespace
802 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500803 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800804 if (!IS_ERR(dst)) {
805 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400806 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800807 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
808 if (rst)
809 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
810 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 }
812
813 kfree_skb(buff);
814}
815
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700816static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
817{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400818 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700819 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700820 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000821#ifdef CONFIG_TCP_MD5SIG
822 const __u8 *hash_location = NULL;
823 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
824 unsigned char newhash[16];
825 int genhash;
826 struct sock *sk1 = NULL;
827#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700828
829 if (th->rst)
830 return;
831
832 if (!ipv6_unicast_destination(skb))
833 return;
834
835#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000836 hash_location = tcp_parse_md5sig_option(th);
837 if (!sk && hash_location) {
838 /*
839 * active side is lost. Try to find listening socket through
840 * source port, and then find md5 key through listening socket.
841 * we are not loose security here:
842 * Incoming packet is checked with md5 hash with finding key,
843 * no RST generated if md5 hash doesn't match.
844 */
845 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbert5ba24952013-01-22 09:50:39 +0000846 &tcp_hashinfo, &ipv6h->saddr,
847 th->source, &ipv6h->daddr,
Shawn Lu658ddaa2012-01-31 22:35:48 +0000848 ntohs(th->source), inet6_iif(skb));
849 if (!sk1)
850 return;
851
852 rcu_read_lock();
853 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
854 if (!key)
855 goto release_sk1;
856
857 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
858 if (genhash || memcmp(hash_location, newhash, 16) != 0)
859 goto release_sk1;
860 } else {
861 key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
862 }
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700863#endif
864
865 if (th->ack)
866 seq = ntohl(th->ack_seq);
867 else
868 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
869 (th->doff << 2);
870
Andrey Vaginee684b62013-02-11 05:50:19 +0000871 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, 0, key, 1, 0);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000872
873#ifdef CONFIG_TCP_MD5SIG
874release_sk1:
875 if (sk1) {
876 rcu_read_unlock();
877 sock_put(sk1);
878 }
879#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700880}
881
Andrey Vaginee684b62013-02-11 05:50:19 +0000882static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
883 u32 win, u32 tsval, u32 tsecr,
Eric Dumazetb903d322011-10-27 00:44:35 -0400884 struct tcp_md5sig_key *key, u8 tclass)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700885{
Andrey Vaginee684b62013-02-11 05:50:19 +0000886 tcp_v6_send_response(skb, seq, ack, win, tsval, tsecr, key, 0, tclass);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700887}
888
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
890{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700891 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800892 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900894 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700895 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000896 tcp_time_stamp + tcptw->tw_ts_offset,
Eric Dumazetb903d322011-10-27 00:44:35 -0400897 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw),
898 tw->tw_tclass);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700900 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901}
902
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700903static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
904 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905{
Andrey Vaginee684b62013-02-11 05:50:19 +0000906 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1,
907 req->rcv_wnd, tcp_time_stamp, req->ts_recent,
Eric Dumazetb903d322011-10-27 00:44:35 -0400908 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909}
910
911
912static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
913{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700914 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700915 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 struct sock *nsk;
917
918 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800919 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700920 &ipv6_hdr(skb)->saddr,
921 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 if (req)
Jerry Chu83368862012-08-31 12:29:12 +0000923 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900925 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800926 &ipv6_hdr(skb)->saddr, th->source,
927 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928
929 if (nsk) {
930 if (nsk->sk_state != TCP_TIME_WAIT) {
931 bh_lock_sock(nsk);
932 return nsk;
933 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700934 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 return NULL;
936 }
937
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800938#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +0000939 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800940 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941#endif
942 return sk;
943}
944
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945/* FIXME: this is substantially similar to the ipv4 code.
946 * Can some kind of merge be done? -- erics
947 */
948static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
949{
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000950 struct tcp_options_received tmp_opt;
951 struct request_sock *req;
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800952 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 struct ipv6_pinfo *np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000955 __u32 isn = TCP_SKB_CB(skb)->when;
David S. Miller493f3772010-12-02 12:14:29 -0800956 struct dst_entry *dst = NULL;
Neal Cardwell3840a062012-06-28 12:34:19 +0000957 struct flowi6 fl6;
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000958 bool want_cookie = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960 if (skb->protocol == htons(ETH_P_IP))
961 return tcp_v4_conn_request(sk, skb);
962
963 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900964 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700966 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Eric Dumazet946cedc2011-08-30 03:21:44 +0000967 want_cookie = tcp_syn_flood_action(sk, skb, "TCPv6");
968 if (!want_cookie)
969 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 }
971
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000972 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
973 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 goto drop;
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000975 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800977 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 if (req == NULL)
979 goto drop;
980
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800981#ifdef CONFIG_TCP_MD5SIG
982 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
983#endif
984
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 tcp_clear_options(&tmp_opt);
986 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
987 tmp_opt.user_mss = tp->rx_opt.user_mss;
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000988 tcp_parse_options(skb, &tmp_opt, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
Florian Westphal4dfc2812008-04-10 03:12:40 -0700990 if (want_cookie && !tmp_opt.saw_tstamp)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800991 tcp_clear_options(&tmp_opt);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
994 tcp_openreq_init(req, &tmp_opt, skb);
995
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800996 treq = inet6_rsk(req);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000997 treq->rmt_addr = ipv6_hdr(skb)->saddr;
998 treq->loc_addr = ipv6_hdr(skb)->daddr;
Florian Westphal172d69e2010-06-21 11:48:45 +0000999 if (!want_cookie || tmp_opt.tstamp_ok)
Hannes Frederic Sowa5d134f12013-01-05 16:10:48 +00001000 TCP_ECN_create_request(req, skb, sock_net(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Eric Dumazet4d0fe502011-11-23 17:29:23 -05001002 treq->iif = sk->sk_bound_dev_if;
1003
1004 /* So that link locals have meaning */
1005 if (!sk->sk_bound_dev_if &&
1006 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1007 treq->iif = inet6_iif(skb);
1008
Florian Westphal2bbdf382010-06-13 11:29:39 +00001009 if (!isn) {
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001010 if (ipv6_opt_accepted(sk, skb) ||
1011 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1012 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1013 atomic_inc(&skb->users);
1014 treq->pktopts = skb;
1015 }
David S. Miller493f3772010-12-02 12:14:29 -08001016
1017 if (want_cookie) {
Florian Westphal2bbdf382010-06-13 11:29:39 +00001018 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1019 req->cookie_ts = tmp_opt.tstamp_ok;
David S. Miller493f3772010-12-02 12:14:29 -08001020 goto have_isn;
Florian Westphal2bbdf382010-06-13 11:29:39 +00001021 }
David S. Miller493f3772010-12-02 12:14:29 -08001022
1023 /* VJ's idea. We save last timestamp seen
1024 * from the destination in peer table, when entering
1025 * state TIME-WAIT, and check against it before
1026 * accepting new connection request.
1027 *
1028 * If "isn" is not zero, this request hit alive
1029 * timewait bucket, so that all the necessary checks
1030 * are made in the function processing timewait state.
1031 */
1032 if (tmp_opt.saw_tstamp &&
1033 tcp_death_row.sysctl_tw_recycle &&
David S. Miller81166dd2012-07-10 03:14:24 -07001034 (dst = inet6_csk_route_req(sk, &fl6, req)) != NULL) {
1035 if (!tcp_peer_is_proven(req, dst, true)) {
David S. Miller493f3772010-12-02 12:14:29 -08001036 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1037 goto drop_and_release;
1038 }
1039 }
1040 /* Kill the following clause, if you dislike this way. */
1041 else if (!sysctl_tcp_syncookies &&
1042 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1043 (sysctl_max_syn_backlog >> 2)) &&
David S. Miller81166dd2012-07-10 03:14:24 -07001044 !tcp_peer_is_proven(req, dst, false)) {
David S. Miller493f3772010-12-02 12:14:29 -08001045 /* Without syncookies last quarter of
1046 * backlog is filled with destinations,
1047 * proven to be alive.
1048 * It means that we continue to communicate
1049 * to destinations, already remembered
1050 * to the moment of synflood.
1051 */
1052 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
1053 &treq->rmt_addr, ntohs(tcp_hdr(skb)->source));
1054 goto drop_and_release;
1055 }
1056
1057 isn = tcp_v6_init_sequence(skb);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001058 }
David S. Miller493f3772010-12-02 12:14:29 -08001059have_isn:
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001060 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
Neal Cardwell437c5b52012-06-23 19:22:00 +00001062 if (security_inet_conn_request(sk, skb, req))
1063 goto drop_and_release;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001064
Neal Cardwell9f10d3f2012-06-28 12:34:21 +00001065 if (tcp_v6_send_synack(sk, dst, &fl6, req,
Eric Dumazetfff32692012-06-01 01:47:50 +00001066 skb_get_queue_mapping(skb)) ||
William Allen Simpson4957faade2009-12-02 18:25:27 +00001067 want_cookie)
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001068 goto drop_and_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
Neal Cardwell016818d2012-09-22 04:18:55 +00001070 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Jerry Chu83368862012-08-31 12:29:12 +00001071 tcp_rsk(req)->listener = NULL;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001072 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1073 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
David S. Miller493f3772010-12-02 12:14:29 -08001075drop_and_release:
1076 dst_release(dst);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001077drop_and_free:
1078 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079drop:
Vijay Subramanian5f1e9422013-01-31 08:24:19 +00001080 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 return 0; /* don't send reset */
1082}
1083
1084static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001085 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 struct dst_entry *dst)
1087{
Vegard Nossum78d15e82008-09-12 16:17:43 -07001088 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1090 struct tcp6_sock *newtcp6sk;
1091 struct inet_sock *newinet;
1092 struct tcp_sock *newtp;
1093 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001094#ifdef CONFIG_TCP_MD5SIG
1095 struct tcp_md5sig_key *key;
1096#endif
Neal Cardwell3840a062012-06-28 12:34:19 +00001097 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
1099 if (skb->protocol == htons(ETH_P_IP)) {
1100 /*
1101 * v6 mapped
1102 */
1103
1104 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1105
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001106 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 return NULL;
1108
1109 newtcp6sk = (struct tcp6_sock *)newsk;
1110 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1111
1112 newinet = inet_sk(newsk);
1113 newnp = inet6_sk(newsk);
1114 newtp = tcp_sk(newsk);
1115
1116 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1117
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001118 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001120 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001122 newnp->rcv_saddr = newnp->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001124 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001126#ifdef CONFIG_TCP_MD5SIG
1127 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1128#endif
1129
Yan, Zheng676a1182011-09-25 02:21:30 +00001130 newnp->ipv6_ac_list = NULL;
1131 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 newnp->pktoptions = NULL;
1133 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001134 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001135 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
YOSHIFUJI Hideaki / 吉藤英明e7219852013-01-13 05:02:01 +00001136 newnp->rcv_tclass = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001138 /*
1139 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1140 * here, tcp_create_openreq_child now does this for us, see the comment in
1141 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
1144 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001145 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 Sync it now.
1147 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001148 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
1150 return newsk;
1151 }
1152
Vegard Nossum78d15e82008-09-12 16:17:43 -07001153 treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154
1155 if (sk_acceptq_is_full(sk))
1156 goto out_overflow;
1157
David S. Miller493f3772010-12-02 12:14:29 -08001158 if (!dst) {
Neal Cardwell3840a062012-06-28 12:34:19 +00001159 dst = inet6_csk_route_req(sk, &fl6, req);
David S. Miller493f3772010-12-02 12:14:29 -08001160 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001162 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
1164 newsk = tcp_create_openreq_child(sk, req, skb);
1165 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001166 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001168 /*
1169 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1170 * count here, tcp_create_openreq_child now does this for us, see the
1171 * comment in that function for the gory details. -acme
1172 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
Stephen Hemminger59eed272006-08-25 15:55:43 -07001174 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001175 __ip6_dst_store(newsk, dst, NULL, NULL);
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001176 inet6_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177
1178 newtcp6sk = (struct tcp6_sock *)newsk;
1179 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1180
1181 newtp = tcp_sk(newsk);
1182 newinet = inet_sk(newsk);
1183 newnp = inet6_sk(newsk);
1184
1185 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1186
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001187 newnp->daddr = treq->rmt_addr;
1188 newnp->saddr = treq->loc_addr;
1189 newnp->rcv_saddr = treq->loc_addr;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001190 newsk->sk_bound_dev_if = treq->iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001192 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193
1194 First: no IPv4 options.
1195 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001196 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001197 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001198 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
1200 /* Clone RX bits */
1201 newnp->rxopt.all = np->rxopt.all;
1202
1203 /* Clone pktoptions received with SYN */
1204 newnp->pktoptions = NULL;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001205 if (treq->pktopts != NULL) {
Mel Gorman99a1dec2012-07-31 16:44:14 -07001206 newnp->pktoptions = skb_clone(treq->pktopts,
1207 sk_gfp_atomic(sk, GFP_ATOMIC));
Eric Dumazetab185d72012-04-19 02:24:36 +00001208 consume_skb(treq->pktopts);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001209 treq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 if (newnp->pktoptions)
1211 skb_set_owner_r(newnp->pktoptions, newsk);
1212 }
1213 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001214 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001215 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
YOSHIFUJI Hideaki / 吉藤英明e7219852013-01-13 05:02:01 +00001216 newnp->rcv_tclass = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
1218 /* Clone native IPv6 options from listening socket (if any)
1219
1220 Yes, keeping reference count would be much more clever,
1221 but we make one more one thing there: reattach optmem
1222 to newsk.
1223 */
RongQing.Li43264e02012-07-01 17:18:59 +00001224 if (np->opt)
1225 newnp->opt = ipv6_dup_options(newsk, np->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001227 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001229 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1230 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
John Heffner5d424d52006-03-20 17:53:41 -08001232 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001234 newtp->advmss = dst_metric_advmss(dst);
Neal Cardwelld135c522012-04-22 09:45:47 +00001235 if (tcp_sk(sk)->rx_opt.user_mss &&
1236 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1237 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1238
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 tcp_initialize_rcv_mss(newsk);
Neal Cardwell623df482012-09-22 04:18:54 +00001240 tcp_synack_rtt_meas(newsk, req);
Eric Dumazete6c022a2012-10-27 23:16:46 +00001241 newtp->total_retrans = req->num_retrans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001243 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1244 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001246#ifdef CONFIG_TCP_MD5SIG
1247 /* Copy over the MD5 key from the original socket */
1248 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1249 /* We're using one, so create a matching key
1250 * on the newsk structure. If we fail to get
1251 * memory, then we end up not copying the key
1252 * across. Shucks.
1253 */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001254 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newnp->daddr,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001255 AF_INET6, key->key, key->keylen,
1256 sk_gfp_atomic(sk, GFP_ATOMIC));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001257 }
1258#endif
1259
Balazs Scheidler093d2822010-10-21 13:06:43 +02001260 if (__inet_inherit_port(sk, newsk) < 0) {
Christoph Paasche337e242012-12-14 04:07:58 +00001261 inet_csk_prepare_forced_close(newsk);
1262 tcp_done(newsk);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001263 goto out;
1264 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001265 __inet6_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
1267 return newsk;
1268
1269out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001270 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001271out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001273out:
1274 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 return NULL;
1276}
1277
Al Virob51655b2006-11-14 21:40:42 -08001278static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001280 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Herbert Xu684f2172009-01-08 10:41:23 -08001281 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001282 &ipv6_hdr(skb)->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001283 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001285 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001287
Herbert Xu684f2172009-01-08 10:41:23 -08001288 skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001289 &ipv6_hdr(skb)->saddr,
1290 &ipv6_hdr(skb)->daddr, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -08001291
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001293 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 }
1295 return 0;
1296}
1297
1298/* The socket must have it's spinlock held when we get
1299 * here.
1300 *
1301 * We have a potential double-lock case here, so even when
1302 * doing backlog processing we use the BH locking scheme.
1303 * This is because we cannot sleep with the original spinlock
1304 * held.
1305 */
1306static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1307{
1308 struct ipv6_pinfo *np = inet6_sk(sk);
1309 struct tcp_sock *tp;
1310 struct sk_buff *opt_skb = NULL;
1311
1312 /* Imagine: socket is IPv6. IPv4 packet arrives,
1313 goes to IPv4 receive handler and backlogged.
1314 From backlog it always goes here. Kerboom...
1315 Fortunately, tcp_rcv_established and rcv_established
1316 handle them correctly, but it is not case with
1317 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1318 */
1319
1320 if (skb->protocol == htons(ETH_P_IP))
1321 return tcp_v4_do_rcv(sk, skb);
1322
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001323#ifdef CONFIG_TCP_MD5SIG
1324 if (tcp_v6_inbound_md5_hash (sk, skb))
1325 goto discard;
1326#endif
1327
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001328 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 goto discard;
1330
1331 /*
1332 * socket locking is here for SMP purposes as backlog rcv
1333 * is currently called with bh processing disabled.
1334 */
1335
1336 /* Do Stevens' IPV6_PKTOPTIONS.
1337
1338 Yes, guys, it is the only place in our code, where we
1339 may make it not affecting IPv4.
1340 The rest of code is protocol independent,
1341 and I do not like idea to uglify IPv4.
1342
1343 Actually, all the idea behind IPV6_PKTOPTIONS
1344 looks not very well thought. For now we latch
1345 options, received in the last packet, enqueued
1346 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001347 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 */
1349 if (np->rxopt.all)
Mel Gorman99a1dec2012-07-31 16:44:14 -07001350 opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
1352 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet5d299f32012-08-06 05:09:33 +00001353 struct dst_entry *dst = sk->sk_rx_dst;
1354
Tom Herbertbdeab992011-08-14 19:45:55 +00001355 sock_rps_save_rxhash(sk, skb);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001356 if (dst) {
1357 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1358 dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1359 dst_release(dst);
1360 sk->sk_rx_dst = NULL;
1361 }
1362 }
1363
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001364 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 if (opt_skb)
1367 goto ipv6_pktoptions;
1368 return 0;
1369 }
1370
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001371 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 goto csum_err;
1373
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001374 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1376 if (!nsk)
1377 goto discard;
1378
1379 /*
1380 * Queue it on the new socket if the new socket is active,
1381 * otherwise we just shortcircuit this and continue with
1382 * the new socket..
1383 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001384 if(nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001385 sock_rps_save_rxhash(nsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 if (tcp_child_process(sk, nsk, skb))
1387 goto reset;
1388 if (opt_skb)
1389 __kfree_skb(opt_skb);
1390 return 0;
1391 }
Neil Horman47482f12011-04-06 13:07:09 -07001392 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001393 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001395 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 if (opt_skb)
1398 goto ipv6_pktoptions;
1399 return 0;
1400
1401reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001402 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403discard:
1404 if (opt_skb)
1405 __kfree_skb(opt_skb);
1406 kfree_skb(skb);
1407 return 0;
1408csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001409 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001410 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 goto discard;
1412
1413
1414ipv6_pktoptions:
1415 /* Do you ask, what is it?
1416
1417 1. skb was enqueued by tcp.
1418 2. skb is added to tail of read queue, rather than out of order.
1419 3. socket is not in passive state.
1420 4. Finally, it really contains options, which user wants to receive.
1421 */
1422 tp = tcp_sk(sk);
1423 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1424 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001425 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001426 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001427 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001428 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Jiri Benc4c507d22012-02-09 09:35:49 +00001429 if (np->rxopt.bits.rxtclass)
YOSHIFUJI Hideaki / 吉藤英明e7219852013-01-13 05:02:01 +00001430 np->rcv_tclass = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 if (ipv6_opt_accepted(sk, opt_skb)) {
1432 skb_set_owner_r(opt_skb, sk);
1433 opt_skb = xchg(&np->pktoptions, opt_skb);
1434 } else {
1435 __kfree_skb(opt_skb);
1436 opt_skb = xchg(&np->pktoptions, NULL);
1437 }
1438 }
1439
Wei Yongjun800d55f2009-02-23 21:45:33 +00001440 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 return 0;
1442}
1443
Herbert Xue5bbef22007-10-15 12:50:28 -07001444static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001446 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001447 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 struct sock *sk;
1449 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001450 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
1452 if (skb->pkt_type != PACKET_HOST)
1453 goto discard_it;
1454
1455 /*
1456 * Count it even if it's bad.
1457 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001458 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
1460 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1461 goto discard_it;
1462
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001463 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
1465 if (th->doff < sizeof(struct tcphdr)/4)
1466 goto bad_packet;
1467 if (!pskb_may_pull(skb, th->doff*4))
1468 goto discard_it;
1469
Herbert Xu60476372007-04-09 11:59:39 -07001470 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001471 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001473 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001474 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1476 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1477 skb->len - th->doff*4);
1478 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1479 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001480 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 TCP_SKB_CB(skb)->sacked = 0;
1482
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001483 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 if (!sk)
1485 goto no_tcp_socket;
1486
1487process:
1488 if (sk->sk_state == TCP_TIME_WAIT)
1489 goto do_time_wait;
1490
Stephen Hemmingere802af92010-04-22 15:24:53 -07001491 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1492 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1493 goto discard_and_relse;
1494 }
1495
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1497 goto discard_and_relse;
1498
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001499 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 goto discard_and_relse;
1501
Eliezer Tamir8b80cda2013-07-10 17:13:26 +03001502 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 skb->dev = NULL;
1504
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001505 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 ret = 0;
1507 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001508#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001509 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001510 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dave Jianga2bd1142012-04-04 16:10:46 -07001511 tp->ucopy.dma_chan = net_dma_find_channel();
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001512 if (tp->ucopy.dma_chan)
1513 ret = tcp_v6_do_rcv(sk, skb);
1514 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001515#endif
1516 {
1517 if (!tcp_prequeue(sk, skb))
1518 ret = tcp_v6_do_rcv(sk, skb);
1519 }
Eric Dumazetda882c12012-04-22 23:38:54 +00001520 } else if (unlikely(sk_add_backlog(sk, skb,
1521 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001522 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001523 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001524 goto discard_and_relse;
1525 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 bh_unlock_sock(sk);
1527
1528 sock_put(sk);
1529 return ret ? -1 : 0;
1530
1531no_tcp_socket:
1532 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1533 goto discard_it;
1534
1535 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001536csum_error:
1537 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001539 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001541 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 }
1543
1544discard_it:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 kfree_skb(skb);
1546 return 0;
1547
1548discard_and_relse:
1549 sock_put(sk);
1550 goto discard_it;
1551
1552do_time_wait:
1553 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001554 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 goto discard_it;
1556 }
1557
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001558 if (skb->len < (th->doff<<2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001559 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001560 goto bad_packet;
1561 }
1562 if (tcp_checksum_complete(skb)) {
1563 inet_twsk_put(inet_twsk(sk));
1564 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 }
1566
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001567 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 case TCP_TW_SYN:
1569 {
1570 struct sock *sk2;
1571
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001572 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Tom Herbert5ba24952013-01-22 09:50:39 +00001573 &ipv6_hdr(skb)->saddr, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001574 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001575 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001577 struct inet_timewait_sock *tw = inet_twsk(sk);
1578 inet_twsk_deschedule(tw, &tcp_death_row);
1579 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 sk = sk2;
1581 goto process;
1582 }
1583 /* Fall through to ACK */
1584 }
1585 case TCP_TW_ACK:
1586 tcp_v6_timewait_ack(sk, skb);
1587 break;
1588 case TCP_TW_RST:
1589 goto no_tcp_socket;
1590 case TCP_TW_SUCCESS:;
1591 }
1592 goto discard_it;
1593}
1594
Eric Dumazetc7109982012-07-26 12:18:11 +00001595static void tcp_v6_early_demux(struct sk_buff *skb)
1596{
1597 const struct ipv6hdr *hdr;
1598 const struct tcphdr *th;
1599 struct sock *sk;
1600
1601 if (skb->pkt_type != PACKET_HOST)
1602 return;
1603
1604 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1605 return;
1606
1607 hdr = ipv6_hdr(skb);
1608 th = tcp_hdr(skb);
1609
1610 if (th->doff < sizeof(struct tcphdr) / 4)
1611 return;
1612
1613 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1614 &hdr->saddr, th->source,
1615 &hdr->daddr, ntohs(th->dest),
1616 inet6_iif(skb));
1617 if (sk) {
1618 skb->sk = sk;
1619 skb->destructor = sock_edemux;
1620 if (sk->sk_state != TCP_TIME_WAIT) {
1621 struct dst_entry *dst = sk->sk_rx_dst;
Neal Cardwellf3f12132012-10-22 21:41:48 +00001622
Eric Dumazetc7109982012-07-26 12:18:11 +00001623 if (dst)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001624 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
Eric Dumazetc7109982012-07-26 12:18:11 +00001625 if (dst &&
Neal Cardwellf3f12132012-10-22 21:41:48 +00001626 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
Eric Dumazetc7109982012-07-26 12:18:11 +00001627 skb_dst_set_noref(skb, dst);
1628 }
1629 }
1630}
1631
David S. Millerccb7c412010-12-01 18:09:13 -08001632static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1633 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1634 .twsk_unique = tcp_twsk_unique,
1635 .twsk_destructor= tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001636};
1637
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001638static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001639 .queue_xmit = inet6_csk_xmit,
1640 .send_check = tcp_v6_send_check,
1641 .rebuild_header = inet6_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001642 .sk_rx_dst_set = inet6_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001643 .conn_request = tcp_v6_conn_request,
1644 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001645 .net_header_len = sizeof(struct ipv6hdr),
Eric Dumazet67469602012-04-24 07:37:38 +00001646 .net_frag_header_len = sizeof(struct frag_hdr),
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001647 .setsockopt = ipv6_setsockopt,
1648 .getsockopt = ipv6_getsockopt,
1649 .addr2sockaddr = inet6_csk_addr2sockaddr,
1650 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001651 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001652#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001653 .compat_setsockopt = compat_ipv6_setsockopt,
1654 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001655#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656};
1657
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001658#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001659static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001660 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001661 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001662 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001663};
David S. Millera9286302006-11-14 19:53:22 -08001664#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001665
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666/*
1667 * TCP over IPv4 via INET6 API
1668 */
1669
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001670static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001671 .queue_xmit = ip_queue_xmit,
1672 .send_check = tcp_v4_send_check,
1673 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet63d02d12012-08-09 14:11:00 +00001674 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001675 .conn_request = tcp_v6_conn_request,
1676 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001677 .net_header_len = sizeof(struct iphdr),
1678 .setsockopt = ipv6_setsockopt,
1679 .getsockopt = ipv6_getsockopt,
1680 .addr2sockaddr = inet6_csk_addr2sockaddr,
1681 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001682 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001683#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001684 .compat_setsockopt = compat_ipv6_setsockopt,
1685 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001686#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687};
1688
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001689#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001690static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001691 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001692 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001693 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001694};
David S. Millera9286302006-11-14 19:53:22 -08001695#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001696
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697/* NOTE: A lot of things set to zero explicitly by call to
1698 * sk_alloc() so need not be done here.
1699 */
1700static int tcp_v6_init_sock(struct sock *sk)
1701{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001702 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
Neal Cardwell900f65d2012-04-19 09:55:21 +00001704 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001706 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001708#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001709 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001710#endif
1711
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 return 0;
1713}
1714
Brian Haley7d06b2e2008-06-14 17:04:49 -07001715static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001718 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719}
1720
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001721#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001723static void get_openreq6(struct seq_file *seq,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001724 const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 int ttd = req->expires - jiffies;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001727 const struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1728 const struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
1730 if (ttd < 0)
1731 ttd = 0;
1732
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 seq_printf(seq,
1734 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001735 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 i,
1737 src->s6_addr32[0], src->s6_addr32[1],
1738 src->s6_addr32[2], src->s6_addr32[3],
KOVACS Krisztianfd507032008-10-19 23:35:58 -07001739 ntohs(inet_rsk(req)->loc_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 dest->s6_addr32[0], dest->s6_addr32[1],
1741 dest->s6_addr32[2], dest->s6_addr32[3],
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001742 ntohs(inet_rsk(req)->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 TCP_SYN_RECV,
1744 0,0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001745 1, /* timers active (only the expire timer) */
1746 jiffies_to_clock_t(ttd),
Eric Dumazete6c022a2012-10-27 23:16:46 +00001747 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001748 from_kuid_munged(seq_user_ns(seq), uid),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001749 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 0, /* open_requests have no inode */
1751 0, req);
1752}
1753
1754static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1755{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001756 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 __u16 destp, srcp;
1758 int timer_active;
1759 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001760 const struct inet_sock *inet = inet_sk(sp);
1761 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001762 const struct inet_connection_sock *icsk = inet_csk(sp);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001763 const struct ipv6_pinfo *np = inet6_sk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
1765 dest = &np->daddr;
1766 src = &np->rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001767 destp = ntohs(inet->inet_dport);
1768 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001769
1770 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001772 timer_expires = icsk->icsk_timeout;
1773 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001775 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 } else if (timer_pending(&sp->sk_timer)) {
1777 timer_active = 2;
1778 timer_expires = sp->sk_timer.expires;
1779 } else {
1780 timer_active = 0;
1781 timer_expires = jiffies;
1782 }
1783
1784 seq_printf(seq,
1785 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001786 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 i,
1788 src->s6_addr32[0], src->s6_addr32[1],
1789 src->s6_addr32[2], src->s6_addr32[3], srcp,
1790 dest->s6_addr32[0], dest->s6_addr32[1],
1791 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001792 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001793 tp->write_seq-tp->snd_una,
1794 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00001796 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001797 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001798 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001799 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 sock_i_ino(sp),
1801 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001802 jiffies_to_clock_t(icsk->icsk_rto),
1803 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001804 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001805 tp->snd_cwnd,
1806 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 );
1808}
1809
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001810static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001811 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001813 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 __u16 destp, srcp;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001815 const struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
Eric Dumazeta399a802012-08-08 21:13:53 +00001816 long delta = tw->tw_ttd - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08001818 dest = &tw6->tw_v6_daddr;
1819 src = &tw6->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 destp = ntohs(tw->tw_dport);
1821 srcp = ntohs(tw->tw_sport);
1822
1823 seq_printf(seq,
1824 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001825 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 i,
1827 src->s6_addr32[0], src->s6_addr32[1],
1828 src->s6_addr32[2], src->s6_addr32[3], srcp,
1829 dest->s6_addr32[0], dest->s6_addr32[1],
1830 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1831 tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00001832 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 atomic_read(&tw->tw_refcnt), tw);
1834}
1835
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836static int tcp6_seq_show(struct seq_file *seq, void *v)
1837{
1838 struct tcp_iter_state *st;
1839
1840 if (v == SEQ_START_TOKEN) {
1841 seq_puts(seq,
1842 " sl "
1843 "local_address "
1844 "remote_address "
1845 "st tx_queue rx_queue tr tm->when retrnsmt"
1846 " uid timeout inode\n");
1847 goto out;
1848 }
1849 st = seq->private;
1850
1851 switch (st->state) {
1852 case TCP_SEQ_STATE_LISTENING:
1853 case TCP_SEQ_STATE_ESTABLISHED:
1854 get_tcp6_sock(seq, v, st->num);
1855 break;
1856 case TCP_SEQ_STATE_OPENREQ:
1857 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1858 break;
1859 case TCP_SEQ_STATE_TIME_WAIT:
1860 get_timewait6_sock(seq, v, st->num);
1861 break;
1862 }
1863out:
1864 return 0;
1865}
1866
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001867static const struct file_operations tcp6_afinfo_seq_fops = {
1868 .owner = THIS_MODULE,
1869 .open = tcp_seq_open,
1870 .read = seq_read,
1871 .llseek = seq_lseek,
1872 .release = seq_release_net
1873};
1874
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 .name = "tcp6",
1877 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001878 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07001879 .seq_ops = {
1880 .show = tcp6_seq_show,
1881 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882};
1883
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001884int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001886 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887}
1888
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001889void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001891 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892}
1893#endif
1894
Eric Dumazetf77d6022013-05-09 10:28:16 +00001895static void tcp_v6_clear_sk(struct sock *sk, int size)
1896{
1897 struct inet_sock *inet = inet_sk(sk);
1898
1899 /* we do not want to clear pinet6 field, because of RCU lookups */
1900 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1901
1902 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1903 memset(&inet->pinet6 + 1, 0, size);
1904}
1905
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906struct proto tcpv6_prot = {
1907 .name = "TCPv6",
1908 .owner = THIS_MODULE,
1909 .close = tcp_close,
1910 .connect = tcp_v6_connect,
1911 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001912 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 .ioctl = tcp_ioctl,
1914 .init = tcp_v6_init_sock,
1915 .destroy = tcp_v6_destroy_sock,
1916 .shutdown = tcp_shutdown,
1917 .setsockopt = tcp_setsockopt,
1918 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00001920 .sendmsg = tcp_sendmsg,
1921 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 .backlog_rcv = tcp_v6_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00001923 .release_cb = tcp_release_cb,
Eric Dumazet563d34d2012-07-23 09:48:52 +02001924 .mtu_reduced = tcp_v6_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001926 .unhash = inet_unhash,
1927 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 .enter_memory_pressure = tcp_enter_memory_pressure,
1929 .sockets_allocated = &tcp_sockets_allocated,
1930 .memory_allocated = &tcp_memory_allocated,
1931 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001932 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 .sysctl_wmem = sysctl_tcp_wmem,
1934 .sysctl_rmem = sysctl_tcp_rmem,
1935 .max_header = MAX_TCP_HEADER,
1936 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001937 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001938 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001939 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07001940 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00001941 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001942#ifdef CONFIG_COMPAT
1943 .compat_setsockopt = compat_tcp_setsockopt,
1944 .compat_getsockopt = compat_tcp_getsockopt,
1945#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07001946#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001947 .proto_cgroup = tcp_proto_cgroup,
1948#endif
Eric Dumazetf77d6022013-05-09 10:28:16 +00001949 .clear_sk = tcp_v6_clear_sk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950};
1951
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00001952static const struct inet6_protocol tcpv6_protocol = {
Eric Dumazetc7109982012-07-26 12:18:11 +00001953 .early_demux = tcp_v6_early_demux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 .handler = tcp_v6_rcv,
1955 .err_handler = tcp_v6_err,
1956 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1957};
1958
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959static struct inet_protosw tcpv6_protosw = {
1960 .type = SOCK_STREAM,
1961 .protocol = IPPROTO_TCP,
1962 .prot = &tcpv6_prot,
1963 .ops = &inet6_stream_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 .no_check = 0,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001965 .flags = INET_PROTOSW_PERMANENT |
1966 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967};
1968
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001969static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001970{
Denis V. Lunev56772422008-04-03 14:28:30 -07001971 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1972 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001973}
1974
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001975static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001976{
Denis V. Lunev56772422008-04-03 14:28:30 -07001977 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001978}
1979
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001980static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001981{
1982 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001983}
1984
1985static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001986 .init = tcpv6_net_init,
1987 .exit = tcpv6_net_exit,
1988 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001989};
1990
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001991int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001993 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08001994
Vlad Yasevich33362882012-11-15 08:49:15 +00001995 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1996 if (ret)
Vlad Yasevichc6b641a2012-11-15 08:49:22 +00001997 goto out;
Vlad Yasevich33362882012-11-15 08:49:15 +00001998
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001999 /* register inet6 protocol */
2000 ret = inet6_register_protosw(&tcpv6_protosw);
2001 if (ret)
2002 goto out_tcpv6_protocol;
2003
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002004 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002005 if (ret)
2006 goto out_tcpv6_protosw;
2007out:
2008 return ret;
2009
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002010out_tcpv6_protosw:
2011 inet6_unregister_protosw(&tcpv6_protosw);
Vlad Yasevich33362882012-11-15 08:49:15 +00002012out_tcpv6_protocol:
2013 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002014 goto out;
2015}
2016
Daniel Lezcano09f77092007-12-13 05:34:58 -08002017void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002018{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002019 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002020 inet6_unregister_protosw(&tcpv6_protosw);
2021 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022}