blob: 0740f93a114a26ac09150638576f523bcd53694c [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 &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700195 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 tp->rx_opt.ts_recent = 0;
197 tp->rx_opt.ts_recent_stamp = 0;
198 tp->write_seq = 0;
199 }
200
Eric Dumazetefe42082013-10-03 15:42:29 -0700201 sk->sk_v6_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,
Eric Dumazetefe42082013-10-03 15:42:29 -0700240 &sk->sk_v6_rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 }
242
243 return err;
244 }
245
Eric Dumazetefe42082013-10-03 15:42:29 -0700246 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
247 saddr = &sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
David S. Miller4c9483b2011-03-12 16:22:43 -0500249 fl6.flowi6_proto = IPPROTO_TCP;
Eric Dumazetefe42082013-10-03 15:42:29 -0700250 fl6.daddr = sk->sk_v6_daddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000251 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;
Eric Dumazetefe42082013-10-03 15:42:29 -0700269 sk->sk_v6_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 &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700282 ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
David S. Miller81166dd2012-07-10 03:14:24 -0700283 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,
Eric Dumazetefe42082013-10-03 15:42:29 -0700301 sk->sk_v6_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{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700468 struct inet_request_sock *ireq = inet_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) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700480 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
481 &ireq->ir_v6_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Eric Dumazet634fb9792013-10-09 15:21:29 -0700483 fl6->daddr = ireq->ir_v6_rmt_addr;
Eric Dumazetfff32692012-06-01 01:47:50 +0000484 skb_set_queue_mapping(skb, queue_mapping);
RongQing.Li43264e02012-07-01 17:18:59 +0000485 err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200486 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 }
488
489done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 return err;
491}
492
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000493static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req)
Octavian Purdila72659ec2010-01-17 19:09:39 -0800494{
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000495 struct flowi6 fl6;
Eric Dumazete6c022a2012-10-27 23:16:46 +0000496 int res;
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000497
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000498 res = tcp_v6_send_synack(sk, NULL, &fl6, req, 0);
Eric Dumazete6c022a2012-10-27 23:16:46 +0000499 if (!res)
500 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
501 return res;
Octavian Purdila72659ec2010-01-17 19:09:39 -0800502}
503
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700504static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700506 kfree_skb(inet_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507}
508
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800509#ifdef CONFIG_TCP_MD5SIG
510static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000511 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800512{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000513 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800514}
515
516static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
517 struct sock *addr_sk)
518{
Eric Dumazetefe42082013-10-03 15:42:29 -0700519 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800520}
521
522static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
523 struct request_sock *req)
524{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700525 return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800526}
527
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800528static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
529 int optlen)
530{
531 struct tcp_md5sig cmd;
532 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800533
534 if (optlen < sizeof(cmd))
535 return -EINVAL;
536
537 if (copy_from_user(&cmd, optval, sizeof(cmd)))
538 return -EFAULT;
539
540 if (sin6->sin6_family != AF_INET6)
541 return -EINVAL;
542
543 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700544 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000545 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
546 AF_INET);
547 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
548 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800549 }
550
551 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
552 return -EINVAL;
553
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000554 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
555 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
556 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800557
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000558 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
559 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800560}
561
Adam Langley49a72df2008-07-19 00:01:42 -0700562static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000563 const struct in6_addr *daddr,
564 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800565{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800566 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700567 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900568
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800569 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800570 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000571 bp->saddr = *saddr;
572 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700573 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700574 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800575
Adam Langley49a72df2008-07-19 00:01:42 -0700576 sg_init_one(&sg, bp, sizeof(*bp));
577 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
578}
David S. Millerc7da57a2007-10-26 00:41:21 -0700579
Adam Langley49a72df2008-07-19 00:01:42 -0700580static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000581 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400582 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700583{
584 struct tcp_md5sig_pool *hp;
585 struct hash_desc *desc;
586
587 hp = tcp_get_md5sig_pool();
588 if (!hp)
589 goto clear_hash_noput;
590 desc = &hp->md5_desc;
591
592 if (crypto_hash_init(desc))
593 goto clear_hash;
594 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
595 goto clear_hash;
596 if (tcp_md5_hash_header(hp, th))
597 goto clear_hash;
598 if (tcp_md5_hash_key(hp, key))
599 goto clear_hash;
600 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800601 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800602
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800603 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800604 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700605
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800606clear_hash:
607 tcp_put_md5sig_pool();
608clear_hash_noput:
609 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700610 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800611}
612
Adam Langley49a72df2008-07-19 00:01:42 -0700613static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400614 const struct sock *sk,
615 const struct request_sock *req,
616 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800617{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000618 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700619 struct tcp_md5sig_pool *hp;
620 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400621 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800622
623 if (sk) {
624 saddr = &inet6_sk(sk)->saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700625 daddr = &sk->sk_v6_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700626 } else if (req) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700627 saddr = &inet_rsk(req)->ir_v6_loc_addr;
628 daddr = &inet_rsk(req)->ir_v6_rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700629 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000630 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700631 saddr = &ip6h->saddr;
632 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800633 }
Adam Langley49a72df2008-07-19 00:01:42 -0700634
635 hp = tcp_get_md5sig_pool();
636 if (!hp)
637 goto clear_hash_noput;
638 desc = &hp->md5_desc;
639
640 if (crypto_hash_init(desc))
641 goto clear_hash;
642
643 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
644 goto clear_hash;
645 if (tcp_md5_hash_header(hp, th))
646 goto clear_hash;
647 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
648 goto clear_hash;
649 if (tcp_md5_hash_key(hp, key))
650 goto clear_hash;
651 if (crypto_hash_final(desc, md5_hash))
652 goto clear_hash;
653
654 tcp_put_md5sig_pool();
655 return 0;
656
657clear_hash:
658 tcp_put_md5sig_pool();
659clear_hash_noput:
660 memset(md5_hash, 0, 16);
661 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800662}
663
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400664static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800665{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400666 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800667 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000668 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400669 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800670 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800671 u8 newhash[16];
672
673 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900674 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800675
David S. Miller785957d2008-07-30 03:03:15 -0700676 /* We've parsed the options - do we have a hash? */
677 if (!hash_expected && !hash_location)
678 return 0;
679
680 if (hash_expected && !hash_location) {
681 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800682 return 1;
683 }
684
David S. Miller785957d2008-07-30 03:03:15 -0700685 if (!hash_expected && hash_location) {
686 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800687 return 1;
688 }
689
690 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700691 genhash = tcp_v6_md5_hash_skb(newhash,
692 hash_expected,
693 NULL, NULL, skb);
694
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800695 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +0000696 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
697 genhash ? "failed" : "mismatch",
698 &ip6h->saddr, ntohs(th->source),
699 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800700 return 1;
701 }
702 return 0;
703}
704#endif
705
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800706struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700708 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -0800709 .rtx_syn_ack = tcp_v6_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700710 .send_ack = tcp_v6_reqsk_send_ack,
711 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800712 .send_reset = tcp_v6_send_reset,
713 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714};
715
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800716#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000717static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800718 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000719 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800720};
Andrew Mortonb6332e62006-11-30 19:16:28 -0800721#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800722
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700723static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
Andrey Vaginee684b62013-02-11 05:50:19 +0000724 u32 tsval, u32 tsecr,
725 struct tcp_md5sig_key *key, int rst, u8 tclass)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400727 const struct tcphdr *th = tcp_hdr(skb);
728 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500730 struct flowi6 fl6;
Eric Dumazetadf30902009-06-02 05:19:30 +0000731 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800732 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800733 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000734 struct dst_entry *dst;
Al Viroe69a4ad2006-11-14 20:56:00 -0800735 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Andrey Vaginee684b62013-02-11 05:50:19 +0000737 if (tsecr)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700738 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800739#ifdef CONFIG_TCP_MD5SIG
740 if (key)
741 tot_len += TCPOLEN_MD5SIG_ALIGNED;
742#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
744 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
745 GFP_ATOMIC);
746 if (buff == NULL)
747 return;
748
749 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
750
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700751 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700752 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
754 /* Swap the send and the receive. */
755 memset(t1, 0, sizeof(*t1));
756 t1->dest = th->source;
757 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700758 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 t1->seq = htonl(seq);
760 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700761 t1->ack = !rst || !th->ack;
762 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800764
Al Viroe69a4ad2006-11-14 20:56:00 -0800765 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900766
Andrey Vaginee684b62013-02-11 05:50:19 +0000767 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800768 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
769 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000770 *topt++ = htonl(tsval);
771 *topt++ = htonl(tsecr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 }
773
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800774#ifdef CONFIG_TCP_MD5SIG
775 if (key) {
776 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
777 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700778 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700779 &ipv6_hdr(skb)->saddr,
780 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800781 }
782#endif
783
David S. Miller4c9483b2011-03-12 16:22:43 -0500784 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000785 fl6.daddr = ipv6_hdr(skb)->saddr;
786 fl6.saddr = ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
David S. Millere5700af2010-04-21 14:59:20 -0700788 buff->ip_summed = CHECKSUM_PARTIAL;
789 buff->csum = 0;
790
David S. Miller4c9483b2011-03-12 16:22:43 -0500791 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
David S. Miller4c9483b2011-03-12 16:22:43 -0500793 fl6.flowi6_proto = IPPROTO_TCP;
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000794 if (ipv6_addr_type(&fl6.daddr) & IPV6_ADDR_LINKLOCAL)
795 fl6.flowi6_oif = inet6_iif(skb);
David S. Miller1958b852011-03-12 16:36:19 -0500796 fl6.fl6_dport = t1->dest;
797 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500798 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700800 /* Pass a socket to ip6_dst_lookup either it is for RST
801 * Underlying function will use this to retrieve the network
802 * namespace
803 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500804 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800805 if (!IS_ERR(dst)) {
806 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400807 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800808 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
809 if (rst)
810 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
811 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 }
813
814 kfree_skb(buff);
815}
816
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700817static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
818{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400819 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700820 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700821 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000822#ifdef CONFIG_TCP_MD5SIG
823 const __u8 *hash_location = NULL;
824 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
825 unsigned char newhash[16];
826 int genhash;
827 struct sock *sk1 = NULL;
828#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700829
830 if (th->rst)
831 return;
832
833 if (!ipv6_unicast_destination(skb))
834 return;
835
836#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000837 hash_location = tcp_parse_md5sig_option(th);
838 if (!sk && hash_location) {
839 /*
840 * active side is lost. Try to find listening socket through
841 * source port, and then find md5 key through listening socket.
842 * we are not loose security here:
843 * Incoming packet is checked with md5 hash with finding key,
844 * no RST generated if md5 hash doesn't match.
845 */
846 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbert5ba24952013-01-22 09:50:39 +0000847 &tcp_hashinfo, &ipv6h->saddr,
848 th->source, &ipv6h->daddr,
Shawn Lu658ddaa2012-01-31 22:35:48 +0000849 ntohs(th->source), inet6_iif(skb));
850 if (!sk1)
851 return;
852
853 rcu_read_lock();
854 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
855 if (!key)
856 goto release_sk1;
857
858 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
859 if (genhash || memcmp(hash_location, newhash, 16) != 0)
860 goto release_sk1;
861 } else {
862 key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
863 }
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700864#endif
865
866 if (th->ack)
867 seq = ntohl(th->ack_seq);
868 else
869 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
870 (th->doff << 2);
871
Andrey Vaginee684b62013-02-11 05:50:19 +0000872 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, 0, key, 1, 0);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000873
874#ifdef CONFIG_TCP_MD5SIG
875release_sk1:
876 if (sk1) {
877 rcu_read_unlock();
878 sock_put(sk1);
879 }
880#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700881}
882
Andrey Vaginee684b62013-02-11 05:50:19 +0000883static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
884 u32 win, u32 tsval, u32 tsecr,
Eric Dumazetb903d322011-10-27 00:44:35 -0400885 struct tcp_md5sig_key *key, u8 tclass)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700886{
Andrey Vaginee684b62013-02-11 05:50:19 +0000887 tcp_v6_send_response(skb, seq, ack, win, tsval, tsecr, key, 0, tclass);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700888}
889
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
891{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700892 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800893 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900895 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700896 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000897 tcp_time_stamp + tcptw->tw_ts_offset,
Eric Dumazetb903d322011-10-27 00:44:35 -0400898 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw),
899 tw->tw_tclass);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700901 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902}
903
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700904static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
905 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906{
Andrey Vaginee684b62013-02-11 05:50:19 +0000907 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1,
908 req->rcv_wnd, tcp_time_stamp, req->ts_recent,
Eric Dumazetb903d322011-10-27 00:44:35 -0400909 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910}
911
912
913static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
914{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700915 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700916 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 struct sock *nsk;
918
919 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800920 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700921 &ipv6_hdr(skb)->saddr,
922 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 if (req)
Jerry Chu83368862012-08-31 12:29:12 +0000924 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900926 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800927 &ipv6_hdr(skb)->saddr, th->source,
928 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
930 if (nsk) {
931 if (nsk->sk_state != TCP_TIME_WAIT) {
932 bh_lock_sock(nsk);
933 return nsk;
934 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700935 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 return NULL;
937 }
938
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800939#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +0000940 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800941 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942#endif
943 return sk;
944}
945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946/* FIXME: this is substantially similar to the ipv4 code.
947 * Can some kind of merge be done? -- erics
948 */
949static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
950{
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000951 struct tcp_options_received tmp_opt;
952 struct request_sock *req;
Eric Dumazet634fb9792013-10-09 15:21:29 -0700953 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 struct ipv6_pinfo *np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000956 __u32 isn = TCP_SKB_CB(skb)->when;
David S. Miller493f3772010-12-02 12:14:29 -0800957 struct dst_entry *dst = NULL;
Neal Cardwell3840a062012-06-28 12:34:19 +0000958 struct flowi6 fl6;
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000959 bool want_cookie = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960
961 if (skb->protocol == htons(ETH_P_IP))
962 return tcp_v4_conn_request(sk, skb);
963
964 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900965 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
Hannes Frederic Sowa5ad37d52013-07-26 17:43:23 +0200967 if ((sysctl_tcp_syncookies == 2 ||
968 inet_csk_reqsk_queue_is_full(sk)) && !isn) {
Eric Dumazet946cedc2011-08-30 03:21:44 +0000969 want_cookie = tcp_syn_flood_action(sk, skb, "TCPv6");
970 if (!want_cookie)
971 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 }
973
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000974 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
975 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 goto drop;
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000977 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800979 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 if (req == NULL)
981 goto drop;
982
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800983#ifdef CONFIG_TCP_MD5SIG
984 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
985#endif
986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 tcp_clear_options(&tmp_opt);
988 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
989 tmp_opt.user_mss = tp->rx_opt.user_mss;
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000990 tcp_parse_options(skb, &tmp_opt, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991
Florian Westphal4dfc2812008-04-10 03:12:40 -0700992 if (want_cookie && !tmp_opt.saw_tstamp)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800993 tcp_clear_options(&tmp_opt);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800994
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
996 tcp_openreq_init(req, &tmp_opt, skb);
997
Eric Dumazet634fb9792013-10-09 15:21:29 -0700998 ireq = inet_rsk(req);
999 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
1000 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
Florian Westphal172d69e2010-06-21 11:48:45 +00001001 if (!want_cookie || tmp_opt.tstamp_ok)
Hannes Frederic Sowa5d134f12013-01-05 16:10:48 +00001002 TCP_ECN_create_request(req, skb, sock_net(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
Eric Dumazet634fb9792013-10-09 15:21:29 -07001004 ireq->ir_iif = sk->sk_bound_dev_if;
Eric Dumazet4d0fe502011-11-23 17:29:23 -05001005
1006 /* So that link locals have meaning */
1007 if (!sk->sk_bound_dev_if &&
Eric Dumazet634fb9792013-10-09 15:21:29 -07001008 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
1009 ireq->ir_iif = inet6_iif(skb);
Eric Dumazet4d0fe502011-11-23 17:29:23 -05001010
Florian Westphal2bbdf382010-06-13 11:29:39 +00001011 if (!isn) {
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001012 if (ipv6_opt_accepted(sk, skb) ||
1013 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1014 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1015 atomic_inc(&skb->users);
Eric Dumazet634fb9792013-10-09 15:21:29 -07001016 ireq->pktopts = skb;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001017 }
David S. Miller493f3772010-12-02 12:14:29 -08001018
1019 if (want_cookie) {
Florian Westphal2bbdf382010-06-13 11:29:39 +00001020 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1021 req->cookie_ts = tmp_opt.tstamp_ok;
David S. Miller493f3772010-12-02 12:14:29 -08001022 goto have_isn;
Florian Westphal2bbdf382010-06-13 11:29:39 +00001023 }
David S. Miller493f3772010-12-02 12:14:29 -08001024
1025 /* VJ's idea. We save last timestamp seen
1026 * from the destination in peer table, when entering
1027 * state TIME-WAIT, and check against it before
1028 * accepting new connection request.
1029 *
1030 * If "isn" is not zero, this request hit alive
1031 * timewait bucket, so that all the necessary checks
1032 * are made in the function processing timewait state.
1033 */
1034 if (tmp_opt.saw_tstamp &&
1035 tcp_death_row.sysctl_tw_recycle &&
David S. Miller81166dd2012-07-10 03:14:24 -07001036 (dst = inet6_csk_route_req(sk, &fl6, req)) != NULL) {
1037 if (!tcp_peer_is_proven(req, dst, true)) {
David S. Miller493f3772010-12-02 12:14:29 -08001038 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1039 goto drop_and_release;
1040 }
1041 }
1042 /* Kill the following clause, if you dislike this way. */
1043 else if (!sysctl_tcp_syncookies &&
1044 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1045 (sysctl_max_syn_backlog >> 2)) &&
David S. Miller81166dd2012-07-10 03:14:24 -07001046 !tcp_peer_is_proven(req, dst, false)) {
David S. Miller493f3772010-12-02 12:14:29 -08001047 /* Without syncookies last quarter of
1048 * backlog is filled with destinations,
1049 * proven to be alive.
1050 * It means that we continue to communicate
1051 * to destinations, already remembered
1052 * to the moment of synflood.
1053 */
1054 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
Eric Dumazet634fb9792013-10-09 15:21:29 -07001055 &ireq->ir_v6_rmt_addr, ntohs(tcp_hdr(skb)->source));
David S. Miller493f3772010-12-02 12:14:29 -08001056 goto drop_and_release;
1057 }
1058
1059 isn = tcp_v6_init_sequence(skb);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001060 }
David S. Miller493f3772010-12-02 12:14:29 -08001061have_isn:
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001062 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
Neal Cardwell437c5b52012-06-23 19:22:00 +00001064 if (security_inet_conn_request(sk, skb, req))
1065 goto drop_and_release;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001066
Neal Cardwell9f10d3f2012-06-28 12:34:21 +00001067 if (tcp_v6_send_synack(sk, dst, &fl6, req,
Eric Dumazetfff32692012-06-01 01:47:50 +00001068 skb_get_queue_mapping(skb)) ||
William Allen Simpson4957faade2009-12-02 18:25:27 +00001069 want_cookie)
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001070 goto drop_and_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
Neal Cardwell016818d2012-09-22 04:18:55 +00001072 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Jerry Chu83368862012-08-31 12:29:12 +00001073 tcp_rsk(req)->listener = NULL;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001074 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1075 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
David S. Miller493f3772010-12-02 12:14:29 -08001077drop_and_release:
1078 dst_release(dst);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001079drop_and_free:
1080 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081drop:
Vijay Subramanian5f1e9422013-01-31 08:24:19 +00001082 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 return 0; /* don't send reset */
1084}
1085
1086static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001087 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 struct dst_entry *dst)
1089{
Eric Dumazet634fb9792013-10-09 15:21:29 -07001090 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1092 struct tcp6_sock *newtcp6sk;
1093 struct inet_sock *newinet;
1094 struct tcp_sock *newtp;
1095 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001096#ifdef CONFIG_TCP_MD5SIG
1097 struct tcp_md5sig_key *key;
1098#endif
Neal Cardwell3840a062012-06-28 12:34:19 +00001099 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
1101 if (skb->protocol == htons(ETH_P_IP)) {
1102 /*
1103 * v6 mapped
1104 */
1105
1106 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1107
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001108 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 return NULL;
1110
1111 newtcp6sk = (struct tcp6_sock *)newsk;
1112 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1113
1114 newinet = inet_sk(newsk);
1115 newnp = inet6_sk(newsk);
1116 newtp = tcp_sk(newsk);
1117
1118 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1119
Eric Dumazetefe42082013-10-03 15:42:29 -07001120 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001122 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
Eric Dumazetefe42082013-10-03 15:42:29 -07001124 newsk->sk_v6_rcv_saddr = newnp->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001126 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001128#ifdef CONFIG_TCP_MD5SIG
1129 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1130#endif
1131
Yan, Zheng676a1182011-09-25 02:21:30 +00001132 newnp->ipv6_ac_list = NULL;
1133 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 newnp->pktoptions = NULL;
1135 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001136 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001137 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
YOSHIFUJI Hideaki / 吉藤英明e7219852013-01-13 05:02:01 +00001138 newnp->rcv_tclass = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001140 /*
1141 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1142 * here, tcp_create_openreq_child now does this for us, see the comment in
1143 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
1146 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001147 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 Sync it now.
1149 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001150 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
1152 return newsk;
1153 }
1154
Eric Dumazet634fb9792013-10-09 15:21:29 -07001155 ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
1157 if (sk_acceptq_is_full(sk))
1158 goto out_overflow;
1159
David S. Miller493f3772010-12-02 12:14:29 -08001160 if (!dst) {
Neal Cardwell3840a062012-06-28 12:34:19 +00001161 dst = inet6_csk_route_req(sk, &fl6, req);
David S. Miller493f3772010-12-02 12:14:29 -08001162 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001164 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
1166 newsk = tcp_create_openreq_child(sk, req, skb);
1167 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001168 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001170 /*
1171 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1172 * count here, tcp_create_openreq_child now does this for us, see the
1173 * comment in that function for the gory details. -acme
1174 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
Stephen Hemminger59eed272006-08-25 15:55:43 -07001176 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001177 __ip6_dst_store(newsk, dst, NULL, NULL);
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001178 inet6_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180 newtcp6sk = (struct tcp6_sock *)newsk;
1181 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1182
1183 newtp = tcp_sk(newsk);
1184 newinet = inet_sk(newsk);
1185 newnp = inet6_sk(newsk);
1186
1187 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1188
Eric Dumazet634fb9792013-10-09 15:21:29 -07001189 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1190 newnp->saddr = ireq->ir_v6_loc_addr;
1191 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1192 newsk->sk_bound_dev_if = ireq->ir_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001194 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
1196 First: no IPv4 options.
1197 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001198 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001199 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001200 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201
1202 /* Clone RX bits */
1203 newnp->rxopt.all = np->rxopt.all;
1204
1205 /* Clone pktoptions received with SYN */
1206 newnp->pktoptions = NULL;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001207 if (ireq->pktopts != NULL) {
1208 newnp->pktoptions = skb_clone(ireq->pktopts,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001209 sk_gfp_atomic(sk, GFP_ATOMIC));
Eric Dumazet634fb9792013-10-09 15:21:29 -07001210 consume_skb(ireq->pktopts);
1211 ireq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 if (newnp->pktoptions)
1213 skb_set_owner_r(newnp->pktoptions, newsk);
1214 }
1215 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001216 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001217 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
YOSHIFUJI Hideaki / 吉藤英明e7219852013-01-13 05:02:01 +00001218 newnp->rcv_tclass = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
1220 /* Clone native IPv6 options from listening socket (if any)
1221
1222 Yes, keeping reference count would be much more clever,
1223 but we make one more one thing there: reattach optmem
1224 to newsk.
1225 */
RongQing.Li43264e02012-07-01 17:18:59 +00001226 if (np->opt)
1227 newnp->opt = ipv6_dup_options(newsk, np->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001229 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001231 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1232 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
John Heffner5d424d52006-03-20 17:53:41 -08001234 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001236 newtp->advmss = dst_metric_advmss(dst);
Neal Cardwelld135c522012-04-22 09:45:47 +00001237 if (tcp_sk(sk)->rx_opt.user_mss &&
1238 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1239 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1240
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 tcp_initialize_rcv_mss(newsk);
1242
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 */
Eric Dumazetefe42082013-10-03 15:42:29 -07001248 if ((key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr)) != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001249 /* 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 Dumazetefe42082013-10-03 15:42:29 -07001254 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_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
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001364 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 if (opt_skb)
1366 goto ipv6_pktoptions;
1367 return 0;
1368 }
1369
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001370 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 goto csum_err;
1372
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001373 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1375 if (!nsk)
1376 goto discard;
1377
1378 /*
1379 * Queue it on the new socket if the new socket is active,
1380 * otherwise we just shortcircuit this and continue with
1381 * the new socket..
1382 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001383 if(nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001384 sock_rps_save_rxhash(nsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 if (tcp_child_process(sk, nsk, skb))
1386 goto reset;
1387 if (opt_skb)
1388 __kfree_skb(opt_skb);
1389 return 0;
1390 }
Neil Horman47482f12011-04-06 13:07:09 -07001391 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001392 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001394 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 if (opt_skb)
1397 goto ipv6_pktoptions;
1398 return 0;
1399
1400reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001401 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402discard:
1403 if (opt_skb)
1404 __kfree_skb(opt_skb);
1405 kfree_skb(skb);
1406 return 0;
1407csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001408 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001409 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 goto discard;
1411
1412
1413ipv6_pktoptions:
1414 /* Do you ask, what is it?
1415
1416 1. skb was enqueued by tcp.
1417 2. skb is added to tail of read queue, rather than out of order.
1418 3. socket is not in passive state.
1419 4. Finally, it really contains options, which user wants to receive.
1420 */
1421 tp = tcp_sk(sk);
1422 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1423 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001424 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001425 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001426 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001427 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Jiri Benc4c507d22012-02-09 09:35:49 +00001428 if (np->rxopt.bits.rxtclass)
Daniel Borkmann3a1c7562013-09-03 19:29:12 +02001429 np->rcv_tclass = ipv6_get_dsfield(ipv6_hdr(opt_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 if (ipv6_opt_accepted(sk, opt_skb)) {
1431 skb_set_owner_r(opt_skb, sk);
1432 opt_skb = xchg(&np->pktoptions, opt_skb);
1433 } else {
1434 __kfree_skb(opt_skb);
1435 opt_skb = xchg(&np->pktoptions, NULL);
1436 }
1437 }
1438
Wei Yongjun800d55f2009-02-23 21:45:33 +00001439 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 return 0;
1441}
1442
Herbert Xue5bbef22007-10-15 12:50:28 -07001443static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001445 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001446 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 struct sock *sk;
1448 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001449 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450
1451 if (skb->pkt_type != PACKET_HOST)
1452 goto discard_it;
1453
1454 /*
1455 * Count it even if it's bad.
1456 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001457 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458
1459 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1460 goto discard_it;
1461
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001462 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463
1464 if (th->doff < sizeof(struct tcphdr)/4)
1465 goto bad_packet;
1466 if (!pskb_may_pull(skb, th->doff*4))
1467 goto discard_it;
1468
Herbert Xu60476372007-04-09 11:59:39 -07001469 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001470 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001472 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001473 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1475 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1476 skb->len - th->doff*4);
1477 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1478 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001479 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 TCP_SKB_CB(skb)->sacked = 0;
1481
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001482 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 if (!sk)
1484 goto no_tcp_socket;
1485
1486process:
1487 if (sk->sk_state == TCP_TIME_WAIT)
1488 goto do_time_wait;
1489
Stephen Hemmingere802af92010-04-22 15:24:53 -07001490 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1491 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1492 goto discard_and_relse;
1493 }
1494
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1496 goto discard_and_relse;
1497
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001498 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 goto discard_and_relse;
1500
Eliezer Tamir8b80cda2013-07-10 17:13:26 +03001501 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 skb->dev = NULL;
1503
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001504 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 ret = 0;
1506 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001507#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001508 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001509 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dave Jianga2bd1142012-04-04 16:10:46 -07001510 tp->ucopy.dma_chan = net_dma_find_channel();
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001511 if (tp->ucopy.dma_chan)
1512 ret = tcp_v6_do_rcv(sk, skb);
1513 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001514#endif
1515 {
1516 if (!tcp_prequeue(sk, skb))
1517 ret = tcp_v6_do_rcv(sk, skb);
1518 }
Eric Dumazetda882c12012-04-22 23:38:54 +00001519 } else if (unlikely(sk_add_backlog(sk, skb,
1520 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001521 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001522 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001523 goto discard_and_relse;
1524 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 bh_unlock_sock(sk);
1526
1527 sock_put(sk);
1528 return ret ? -1 : 0;
1529
1530no_tcp_socket:
1531 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1532 goto discard_it;
1533
1534 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001535csum_error:
1536 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001538 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001540 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 }
1542
1543discard_it:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 kfree_skb(skb);
1545 return 0;
1546
1547discard_and_relse:
1548 sock_put(sk);
1549 goto discard_it;
1550
1551do_time_wait:
1552 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001553 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 goto discard_it;
1555 }
1556
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001557 if (skb->len < (th->doff<<2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001558 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001559 goto bad_packet;
1560 }
1561 if (tcp_checksum_complete(skb)) {
1562 inet_twsk_put(inet_twsk(sk));
1563 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 }
1565
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001566 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 case TCP_TW_SYN:
1568 {
1569 struct sock *sk2;
1570
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001571 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Tom Herbert5ba24952013-01-22 09:50:39 +00001572 &ipv6_hdr(skb)->saddr, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001573 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001574 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001576 struct inet_timewait_sock *tw = inet_twsk(sk);
1577 inet_twsk_deschedule(tw, &tcp_death_row);
1578 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 sk = sk2;
1580 goto process;
1581 }
1582 /* Fall through to ACK */
1583 }
1584 case TCP_TW_ACK:
1585 tcp_v6_timewait_ack(sk, skb);
1586 break;
1587 case TCP_TW_RST:
1588 goto no_tcp_socket;
1589 case TCP_TW_SUCCESS:;
1590 }
1591 goto discard_it;
1592}
1593
Eric Dumazetc7109982012-07-26 12:18:11 +00001594static void tcp_v6_early_demux(struct sk_buff *skb)
1595{
1596 const struct ipv6hdr *hdr;
1597 const struct tcphdr *th;
1598 struct sock *sk;
1599
1600 if (skb->pkt_type != PACKET_HOST)
1601 return;
1602
1603 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1604 return;
1605
1606 hdr = ipv6_hdr(skb);
1607 th = tcp_hdr(skb);
1608
1609 if (th->doff < sizeof(struct tcphdr) / 4)
1610 return;
1611
1612 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1613 &hdr->saddr, th->source,
1614 &hdr->daddr, ntohs(th->dest),
1615 inet6_iif(skb));
1616 if (sk) {
1617 skb->sk = sk;
1618 skb->destructor = sock_edemux;
1619 if (sk->sk_state != TCP_TIME_WAIT) {
1620 struct dst_entry *dst = sk->sk_rx_dst;
Neal Cardwellf3f12132012-10-22 21:41:48 +00001621
Eric Dumazetc7109982012-07-26 12:18:11 +00001622 if (dst)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001623 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
Eric Dumazetc7109982012-07-26 12:18:11 +00001624 if (dst &&
Neal Cardwellf3f12132012-10-22 21:41:48 +00001625 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
Eric Dumazetc7109982012-07-26 12:18:11 +00001626 skb_dst_set_noref(skb, dst);
1627 }
1628 }
1629}
1630
David S. Millerccb7c412010-12-01 18:09:13 -08001631static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1632 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1633 .twsk_unique = tcp_twsk_unique,
1634 .twsk_destructor= tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001635};
1636
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001637static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001638 .queue_xmit = inet6_csk_xmit,
1639 .send_check = tcp_v6_send_check,
1640 .rebuild_header = inet6_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001641 .sk_rx_dst_set = inet6_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001642 .conn_request = tcp_v6_conn_request,
1643 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001644 .net_header_len = sizeof(struct ipv6hdr),
Eric Dumazet67469602012-04-24 07:37:38 +00001645 .net_frag_header_len = sizeof(struct frag_hdr),
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001646 .setsockopt = ipv6_setsockopt,
1647 .getsockopt = ipv6_getsockopt,
1648 .addr2sockaddr = inet6_csk_addr2sockaddr,
1649 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001650 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001651#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001652 .compat_setsockopt = compat_ipv6_setsockopt,
1653 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001654#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655};
1656
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001657#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001658static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001659 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001660 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001661 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001662};
David S. Millera9286302006-11-14 19:53:22 -08001663#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001664
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665/*
1666 * TCP over IPv4 via INET6 API
1667 */
1668
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001669static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001670 .queue_xmit = ip_queue_xmit,
1671 .send_check = tcp_v4_send_check,
1672 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet63d02d12012-08-09 14:11:00 +00001673 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001674 .conn_request = tcp_v6_conn_request,
1675 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001676 .net_header_len = sizeof(struct iphdr),
1677 .setsockopt = ipv6_setsockopt,
1678 .getsockopt = ipv6_getsockopt,
1679 .addr2sockaddr = inet6_csk_addr2sockaddr,
1680 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001681 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001682#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001683 .compat_setsockopt = compat_ipv6_setsockopt,
1684 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001685#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686};
1687
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001688#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001689static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001690 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001691 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001692 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001693};
David S. Millera9286302006-11-14 19:53:22 -08001694#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001695
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696/* NOTE: A lot of things set to zero explicitly by call to
1697 * sk_alloc() so need not be done here.
1698 */
1699static int tcp_v6_init_sock(struct sock *sk)
1700{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001701 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702
Neal Cardwell900f65d2012-04-19 09:55:21 +00001703 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001705 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001707#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001708 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001709#endif
1710
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 return 0;
1712}
1713
Brian Haley7d06b2e2008-06-14 17:04:49 -07001714static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001717 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718}
1719
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001720#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001722static void get_openreq6(struct seq_file *seq,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001723 const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 int ttd = req->expires - jiffies;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001726 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1727 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
1729 if (ttd < 0)
1730 ttd = 0;
1731
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 seq_printf(seq,
1733 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001734 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 i,
1736 src->s6_addr32[0], src->s6_addr32[1],
1737 src->s6_addr32[2], src->s6_addr32[3],
Eric Dumazetb44084c2013-10-10 00:04:37 -07001738 inet_rsk(req)->ir_num,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 dest->s6_addr32[0], dest->s6_addr32[1],
1740 dest->s6_addr32[2], dest->s6_addr32[3],
Eric Dumazet634fb9792013-10-09 15:21:29 -07001741 ntohs(inet_rsk(req)->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 TCP_SYN_RECV,
1743 0,0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001744 1, /* timers active (only the expire timer) */
1745 jiffies_to_clock_t(ttd),
Eric Dumazete6c022a2012-10-27 23:16:46 +00001746 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001747 from_kuid_munged(seq_user_ns(seq), uid),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001748 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 0, /* open_requests have no inode */
1750 0, req);
1751}
1752
1753static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1754{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001755 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 __u16 destp, srcp;
1757 int timer_active;
1758 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001759 const struct inet_sock *inet = inet_sk(sp);
1760 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001761 const struct inet_connection_sock *icsk = inet_csk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762
Eric Dumazetefe42082013-10-03 15:42:29 -07001763 dest = &sp->sk_v6_daddr;
1764 src = &sp->sk_v6_rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001765 destp = ntohs(inet->inet_dport);
1766 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001767
1768 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001770 timer_expires = icsk->icsk_timeout;
1771 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001773 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 } else if (timer_pending(&sp->sk_timer)) {
1775 timer_active = 2;
1776 timer_expires = sp->sk_timer.expires;
1777 } else {
1778 timer_active = 0;
1779 timer_expires = jiffies;
1780 }
1781
1782 seq_printf(seq,
1783 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001784 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 i,
1786 src->s6_addr32[0], src->s6_addr32[1],
1787 src->s6_addr32[2], src->s6_addr32[3], srcp,
1788 dest->s6_addr32[0], dest->s6_addr32[1],
1789 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001790 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001791 tp->write_seq-tp->snd_una,
1792 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00001794 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001795 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001796 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001797 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 sock_i_ino(sp),
1799 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001800 jiffies_to_clock_t(icsk->icsk_rto),
1801 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001802 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001803 tp->snd_cwnd,
1804 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 );
1806}
1807
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001808static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001809 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001811 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 __u16 destp, srcp;
Eric Dumazet96f817f2013-10-03 14:27:25 -07001813 s32 delta = tw->tw_ttd - inet_tw_time_stamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
Eric Dumazetefe42082013-10-03 15:42:29 -07001815 dest = &tw->tw_v6_daddr;
1816 src = &tw->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 destp = ntohs(tw->tw_dport);
1818 srcp = ntohs(tw->tw_sport);
1819
1820 seq_printf(seq,
1821 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001822 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 i,
1824 src->s6_addr32[0], src->s6_addr32[1],
1825 src->s6_addr32[2], src->s6_addr32[3], srcp,
1826 dest->s6_addr32[0], dest->s6_addr32[1],
1827 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1828 tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00001829 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 atomic_read(&tw->tw_refcnt), tw);
1831}
1832
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833static int tcp6_seq_show(struct seq_file *seq, void *v)
1834{
1835 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001836 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837
1838 if (v == SEQ_START_TOKEN) {
1839 seq_puts(seq,
1840 " sl "
1841 "local_address "
1842 "remote_address "
1843 "st tx_queue rx_queue tr tm->when retrnsmt"
1844 " uid timeout inode\n");
1845 goto out;
1846 }
1847 st = seq->private;
1848
1849 switch (st->state) {
1850 case TCP_SEQ_STATE_LISTENING:
1851 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001852 if (sk->sk_state == TCP_TIME_WAIT)
1853 get_timewait6_sock(seq, v, st->num);
1854 else
1855 get_tcp6_sock(seq, v, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 break;
1857 case TCP_SEQ_STATE_OPENREQ:
1858 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1859 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 }
1861out:
1862 return 0;
1863}
1864
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001865static const struct file_operations tcp6_afinfo_seq_fops = {
1866 .owner = THIS_MODULE,
1867 .open = tcp_seq_open,
1868 .read = seq_read,
1869 .llseek = seq_lseek,
1870 .release = seq_release_net
1871};
1872
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 .name = "tcp6",
1875 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001876 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07001877 .seq_ops = {
1878 .show = tcp6_seq_show,
1879 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880};
1881
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001882int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001884 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885}
1886
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001887void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001889 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890}
1891#endif
1892
Eric Dumazetf77d6022013-05-09 10:28:16 +00001893static void tcp_v6_clear_sk(struct sock *sk, int size)
1894{
1895 struct inet_sock *inet = inet_sk(sk);
1896
1897 /* we do not want to clear pinet6 field, because of RCU lookups */
1898 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1899
1900 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1901 memset(&inet->pinet6 + 1, 0, size);
1902}
1903
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904struct proto tcpv6_prot = {
1905 .name = "TCPv6",
1906 .owner = THIS_MODULE,
1907 .close = tcp_close,
1908 .connect = tcp_v6_connect,
1909 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001910 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 .ioctl = tcp_ioctl,
1912 .init = tcp_v6_init_sock,
1913 .destroy = tcp_v6_destroy_sock,
1914 .shutdown = tcp_shutdown,
1915 .setsockopt = tcp_setsockopt,
1916 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00001918 .sendmsg = tcp_sendmsg,
1919 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 .backlog_rcv = tcp_v6_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00001921 .release_cb = tcp_release_cb,
Eric Dumazet563d34d2012-07-23 09:48:52 +02001922 .mtu_reduced = tcp_v6_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001924 .unhash = inet_unhash,
1925 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07001927 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 .sockets_allocated = &tcp_sockets_allocated,
1929 .memory_allocated = &tcp_memory_allocated,
1930 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001931 .orphan_count = &tcp_orphan_count,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07001932 .sysctl_mem = sysctl_tcp_mem,
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}