blob: 1985b4933a6bbc6a24ae502f601afac29896fab8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * TCP over IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09008 * Based on:
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * linux/net/ipv4/tcp.c
10 * linux/net/ipv4/tcp_input.c
11 * linux/net/ipv4/tcp_output.c
12 *
13 * Fixes:
14 * Hideaki YOSHIFUJI : sin6_scope_id support
15 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
16 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
17 * a single port at the same time.
18 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
Herbert Xueb4dea52008-12-29 23:04:08 -080026#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/socket.h>
31#include <linux/sockios.h>
32#include <linux/net.h>
33#include <linux/jiffies.h>
34#include <linux/in.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/init.h>
38#include <linux/jhash.h>
39#include <linux/ipsec.h>
40#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090041#include <linux/slab.h>
Wang Yufen4aa956d2014-03-29 09:27:29 +080042#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
Arnaldo Carvalho de Melo5324a042005-08-12 09:26:18 -030049#include <net/inet6_hashtables.h>
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -080050#include <net/inet6_connection_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <net/ipv6.h>
52#include <net/transp_v6.h>
53#include <net/addrconf.h>
54#include <net/ip6_route.h>
55#include <net/ip6_checksum.h>
56#include <net/inet_ecn.h>
57#include <net/protocol.h>
58#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <net/snmp.h>
60#include <net/dsfield.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080061#include <net/timewait_sock.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070062#include <net/inet_common.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070063#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000064#include <net/tcp_memcontrol.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030065#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/proc_fs.h>
68#include <linux/seq_file.h>
69
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080070#include <linux/crypto.h>
71#include <linux/scatterlist.h>
72
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080073static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070074static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
75 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Stephen Hemminger3b401a82009-09-01 19:25:04 +000079static const struct inet_connection_sock_af_ops ipv6_mapped;
80static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080081#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000082static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
83static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090084#else
85static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000086 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090087{
88 return NULL;
89}
David S. Millera9286302006-11-14 19:53:22 -080090#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Neal Cardwellfae6ef82012-08-19 03:30:38 +000092static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
93{
94 struct dst_entry *dst = skb_dst(skb);
Neal Cardwellfae6ef82012-08-19 03:30:38 +000095
Eric Dumazetca777ef2014-09-08 08:06:07 -070096 if (dst) {
97 const struct rt6_info *rt = (const struct rt6_info *)dst;
98
99 dst_hold(dst);
100 sk->sk_rx_dst = dst;
101 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
102 if (rt->rt6i_node)
103 inet6_sk(sk)->rx_dst_cookie = rt->rt6i_node->fn_sernum;
104 }
Neal Cardwellfae6ef82012-08-19 03:30:38 +0000105}
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 fl6_sock_release(flowlabel);
160 }
161 }
162
163 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900164 * connect() to INADDR_ANY means loopback (BSD'ism).
165 */
166
Weilong Chen4c99aa42013-12-19 18:44:34 +0800167 if (ipv6_addr_any(&usin->sin6_addr))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900168 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 addr_type = ipv6_addr_type(&usin->sin6_addr);
171
Weilong Chen4c99aa42013-12-19 18:44:34 +0800172 if (addr_type & IPV6_ADDR_MULTICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return -ENETUNREACH;
174
175 if (addr_type&IPV6_ADDR_LINKLOCAL) {
176 if (addr_len >= sizeof(struct sockaddr_in6) &&
177 usin->sin6_scope_id) {
178 /* If interface is set while binding, indices
179 * must coincide.
180 */
181 if (sk->sk_bound_dev_if &&
182 sk->sk_bound_dev_if != usin->sin6_scope_id)
183 return -EINVAL;
184
185 sk->sk_bound_dev_if = usin->sin6_scope_id;
186 }
187
188 /* Connect to link-local address requires an interface */
189 if (!sk->sk_bound_dev_if)
190 return -EINVAL;
191 }
192
193 if (tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700194 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 tp->rx_opt.ts_recent = 0;
196 tp->rx_opt.ts_recent_stamp = 0;
197 tp->write_seq = 0;
198 }
199
Eric Dumazetefe42082013-10-03 15:42:29 -0700200 sk->sk_v6_daddr = usin->sin6_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500201 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
203 /*
204 * TCP over IPv4
205 */
206
207 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800208 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 struct sockaddr_in sin;
210
211 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
212
213 if (__ipv6_only_sock(sk))
214 return -ENETUNREACH;
215
216 sin.sin_family = AF_INET;
217 sin.sin_port = usin->sin6_port;
218 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
219
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800220 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800222#ifdef CONFIG_TCP_MD5SIG
223 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
224#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
227
228 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800229 icsk->icsk_ext_hdr_len = exthdrlen;
230 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800232#ifdef CONFIG_TCP_MD5SIG
233 tp->af_specific = &tcp_sock_ipv6_specific;
234#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 goto failure;
236 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000237 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
238 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
Eric Dumazetefe42082013-10-03 15:42:29 -0700239 &sk->sk_v6_rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 }
241
242 return err;
243 }
244
Eric Dumazetefe42082013-10-03 15:42:29 -0700245 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
246 saddr = &sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
David S. Miller4c9483b2011-03-12 16:22:43 -0500248 fl6.flowi6_proto = IPPROTO_TCP;
Eric Dumazetefe42082013-10-03 15:42:29 -0700249 fl6.daddr = sk->sk_v6_daddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000250 fl6.saddr = saddr ? *saddr : np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500251 fl6.flowi6_oif = sk->sk_bound_dev_if;
252 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500253 fl6.fl6_dport = usin->sin6_port;
254 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
David S. Miller4c9483b2011-03-12 16:22:43 -0500256 final_p = fl6_update_dst(&fl6, np->opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
David S. Miller4c9483b2011-03-12 16:22:43 -0500258 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700259
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200260 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800261 if (IS_ERR(dst)) {
262 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 goto failure;
David S. Miller14e50e52007-05-24 18:17:54 -0700264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266 if (saddr == NULL) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500267 saddr = &fl6.saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700268 sk->sk_v6_rcv_saddr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 }
270
271 /* set the source address */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000272 np->saddr = *saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000273 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700275 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700276 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
David S. Miller493f3772010-12-02 12:14:29 -0800278 rt = (struct rt6_info *) dst;
279 if (tcp_death_row.sysctl_tw_recycle &&
280 !tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700281 ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
David S. Miller81166dd2012-07-10 03:14:24 -0700282 tcp_fetch_timewait_stamp(sk, dst);
David S. Miller493f3772010-12-02 12:14:29 -0800283
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800284 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800286 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
287 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
290
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000291 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800294 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 if (err)
296 goto late_failure;
297
Sathya Perla9e7ceb02014-10-22 21:42:01 +0530298 ip6_set_txhash(sk);
299
Andrey Vagin2b916472012-11-22 01:13:58 +0000300 if (!tp->write_seq && likely(!tp->repair))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
Eric Dumazetefe42082013-10-03 15:42:29 -0700302 sk->sk_v6_daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000303 inet->inet_sport,
304 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306 err = tcp_connect(sk);
307 if (err)
308 goto late_failure;
309
310 return 0;
311
312late_failure:
313 tcp_set_state(sk, TCP_CLOSE);
314 __sk_dst_reset(sk);
315failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000316 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 sk->sk_route_caps = 0;
318 return err;
319}
320
Eric Dumazet563d34d2012-07-23 09:48:52 +0200321static void tcp_v6_mtu_reduced(struct sock *sk)
322{
323 struct dst_entry *dst;
324
325 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
326 return;
327
328 dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
329 if (!dst)
330 return;
331
332 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
333 tcp_sync_mss(sk, dst_mtu(dst));
334 tcp_simple_retransmit(sk);
335 }
336}
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700339 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
Weilong Chen4c99aa42013-12-19 18:44:34 +0800341 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300342 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 struct ipv6_pinfo *np;
344 struct sock *sk;
345 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900346 struct tcp_sock *tp;
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700347 struct request_sock *fastopen;
348 __u32 seq, snd_una;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700349 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700351 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800352 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700355 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
356 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 return;
358 }
359
360 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700361 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 return;
363 }
364
365 bh_lock_sock(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200366 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700367 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
369 if (sk->sk_state == TCP_CLOSE)
370 goto out;
371
Stephen Hemmingere802af92010-04-22 15:24:53 -0700372 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
373 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
374 goto out;
375 }
376
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900378 seq = ntohl(th->seq);
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700379 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
380 fastopen = tp->fastopen_rsk;
381 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 if (sk->sk_state != TCP_LISTEN &&
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700383 !between(seq, snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700384 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 goto out;
386 }
387
388 np = inet6_sk(sk);
389
David S. Millerec18d9a2012-07-12 00:25:15 -0700390 if (type == NDISC_REDIRECT) {
391 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
392
David S. Miller1ed5c482012-07-12 00:41:25 -0700393 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700394 dst->ops->redirect(dst, sk, skb);
Christoph Paasch50a75a82013-04-07 04:53:15 +0000395 goto out;
David S. Millerec18d9a2012-07-12 00:25:15 -0700396 }
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 if (type == ICMPV6_PKT_TOOBIG) {
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000399 /* We are not interested in TCP_LISTEN and open_requests
400 * (SYN-ACKs send out by Linux are always <576bytes so
401 * they should go through unfragmented).
402 */
403 if (sk->sk_state == TCP_LISTEN)
404 goto out;
405
Hannes Frederic Sowa93b36cf2013-12-15 03:41:14 +0100406 if (!ip6_sk_accept_pmtu(sk))
407 goto out;
408
Eric Dumazet563d34d2012-07-23 09:48:52 +0200409 tp->mtu_info = ntohl(info);
410 if (!sock_owned_by_user(sk))
411 tcp_v6_mtu_reduced(sk);
Julian Anastasovd013ef2a2012-09-05 10:53:18 +0000412 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
413 &tp->tsq_flags))
414 sock_hold(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 goto out;
416 }
417
418 icmpv6_err_convert(type, code, &err);
419
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700420 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700422 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 case TCP_LISTEN:
424 if (sock_owned_by_user(sk))
425 goto out;
426
Eric Dumazet870c3152014-10-17 09:17:20 -0700427 /* Note : We use inet6_iif() here, not tcp_v6_iif() */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800428 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
429 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 if (!req)
431 goto out;
432
433 /* ICMPs are not backlogged, hence we cannot get
434 * an established socket here.
435 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700436 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700438 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700439 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 goto out;
441 }
442
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700443 inet_csk_reqsk_queue_drop(sk, req, prev);
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000444 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 goto out;
446
447 case TCP_SYN_SENT:
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700448 case TCP_SYN_RECV:
449 /* Only in fast or simultaneous open. If a fast open socket is
450 * is already accepted it is treated as a connected one below.
451 */
452 if (fastopen && fastopen->sk == NULL)
453 break;
454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 sk->sk_err = err;
457 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
458
459 tcp_done(sk);
460 } else
461 sk->sk_err_soft = err;
462 goto out;
463 }
464
465 if (!sock_owned_by_user(sk) && np->recverr) {
466 sk->sk_err = err;
467 sk->sk_error_report(sk);
468 } else
469 sk->sk_err_soft = err;
470
471out:
472 bh_unlock_sock(sk);
473 sock_put(sk);
474}
475
476
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000477static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300478 struct flowi *fl,
Neal Cardwell3840a062012-06-28 12:34:19 +0000479 struct request_sock *req,
Daniel Lee3a19ce02014-05-11 20:22:13 -0700480 u16 queue_mapping,
481 struct tcp_fastopen_cookie *foc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700483 struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 struct ipv6_pinfo *np = inet6_sk(sk);
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300485 struct flowi6 *fl6 = &fl->u.ip6;
Weilong Chen4c99aa42013-12-19 18:44:34 +0800486 struct sk_buff *skb;
Neal Cardwell94942182012-06-28 12:34:20 +0000487 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000489 /* First, grab a route. */
490 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800491 goto done;
Neal Cardwell94942182012-06-28 12:34:20 +0000492
Daniel Lee3a19ce02014-05-11 20:22:13 -0700493 skb = tcp_make_synack(sk, dst, req, foc);
Neal Cardwell94942182012-06-28 12:34:20 +0000494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700496 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
497 &ireq->ir_v6_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Eric Dumazet634fb9792013-10-09 15:21:29 -0700499 fl6->daddr = ireq->ir_v6_rmt_addr;
Florent Fourcotdf3687f2014-01-17 17:15:03 +0100500 if (np->repflow && (ireq->pktopts != NULL))
501 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
502
Eric Dumazetfff32692012-06-01 01:47:50 +0000503 skb_set_queue_mapping(skb, queue_mapping);
RongQing.Li43264e02012-07-01 17:18:59 +0000504 err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200505 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507
508done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 return err;
510}
511
Octavian Purdila72659ec2010-01-17 19:09:39 -0800512
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700513static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700515 kfree_skb(inet_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516}
517
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800518#ifdef CONFIG_TCP_MD5SIG
519static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000520 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800521{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000522 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800523}
524
525static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
526 struct sock *addr_sk)
527{
Eric Dumazetefe42082013-10-03 15:42:29 -0700528 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800529}
530
531static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
532 struct request_sock *req)
533{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700534 return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800535}
536
Wang Yufen4aa956d2014-03-29 09:27:29 +0800537static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
538 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800539{
540 struct tcp_md5sig cmd;
541 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800542
543 if (optlen < sizeof(cmd))
544 return -EINVAL;
545
546 if (copy_from_user(&cmd, optval, sizeof(cmd)))
547 return -EFAULT;
548
549 if (sin6->sin6_family != AF_INET6)
550 return -EINVAL;
551
552 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700553 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000554 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
555 AF_INET);
556 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
557 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800558 }
559
560 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
561 return -EINVAL;
562
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000563 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
564 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
565 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800566
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000567 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
568 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800569}
570
Adam Langley49a72df2008-07-19 00:01:42 -0700571static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000572 const struct in6_addr *daddr,
573 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800574{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800575 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700576 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900577
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800578 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800579 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000580 bp->saddr = *saddr;
581 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700582 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700583 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800584
Adam Langley49a72df2008-07-19 00:01:42 -0700585 sg_init_one(&sg, bp, sizeof(*bp));
586 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
587}
David S. Millerc7da57a2007-10-26 00:41:21 -0700588
Adam Langley49a72df2008-07-19 00:01:42 -0700589static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000590 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400591 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700592{
593 struct tcp_md5sig_pool *hp;
594 struct hash_desc *desc;
595
596 hp = tcp_get_md5sig_pool();
597 if (!hp)
598 goto clear_hash_noput;
599 desc = &hp->md5_desc;
600
601 if (crypto_hash_init(desc))
602 goto clear_hash;
603 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
604 goto clear_hash;
605 if (tcp_md5_hash_header(hp, th))
606 goto clear_hash;
607 if (tcp_md5_hash_key(hp, key))
608 goto clear_hash;
609 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800610 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800611
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800612 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800613 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700614
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800615clear_hash:
616 tcp_put_md5sig_pool();
617clear_hash_noput:
618 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700619 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800620}
621
Adam Langley49a72df2008-07-19 00:01:42 -0700622static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400623 const struct sock *sk,
624 const struct request_sock *req,
625 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800626{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000627 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700628 struct tcp_md5sig_pool *hp;
629 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400630 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800631
632 if (sk) {
633 saddr = &inet6_sk(sk)->saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700634 daddr = &sk->sk_v6_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700635 } else if (req) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700636 saddr = &inet_rsk(req)->ir_v6_loc_addr;
637 daddr = &inet_rsk(req)->ir_v6_rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700638 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000639 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700640 saddr = &ip6h->saddr;
641 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800642 }
Adam Langley49a72df2008-07-19 00:01:42 -0700643
644 hp = tcp_get_md5sig_pool();
645 if (!hp)
646 goto clear_hash_noput;
647 desc = &hp->md5_desc;
648
649 if (crypto_hash_init(desc))
650 goto clear_hash;
651
652 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
653 goto clear_hash;
654 if (tcp_md5_hash_header(hp, th))
655 goto clear_hash;
656 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
657 goto clear_hash;
658 if (tcp_md5_hash_key(hp, key))
659 goto clear_hash;
660 if (crypto_hash_final(desc, md5_hash))
661 goto clear_hash;
662
663 tcp_put_md5sig_pool();
664 return 0;
665
666clear_hash:
667 tcp_put_md5sig_pool();
668clear_hash_noput:
669 memset(md5_hash, 0, 16);
670 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800671}
672
Dmitry Popov9ea88a12014-08-07 02:38:22 +0400673static int __tcp_v6_inbound_md5_hash(struct sock *sk,
674 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800675{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400676 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800677 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000678 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400679 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800680 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800681 u8 newhash[16];
682
683 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900684 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800685
David S. Miller785957d2008-07-30 03:03:15 -0700686 /* We've parsed the options - do we have a hash? */
687 if (!hash_expected && !hash_location)
688 return 0;
689
690 if (hash_expected && !hash_location) {
691 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800692 return 1;
693 }
694
David S. Miller785957d2008-07-30 03:03:15 -0700695 if (!hash_expected && hash_location) {
696 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800697 return 1;
698 }
699
700 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700701 genhash = tcp_v6_md5_hash_skb(newhash,
702 hash_expected,
703 NULL, NULL, skb);
704
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800705 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +0000706 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
707 genhash ? "failed" : "mismatch",
708 &ip6h->saddr, ntohs(th->source),
709 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800710 return 1;
711 }
712 return 0;
713}
Dmitry Popov9ea88a12014-08-07 02:38:22 +0400714
715static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
716{
717 int ret;
718
719 rcu_read_lock();
720 ret = __tcp_v6_inbound_md5_hash(sk, skb);
721 rcu_read_unlock();
722
723 return ret;
724}
725
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800726#endif
727
Octavian Purdila16bea702014-06-25 17:09:53 +0300728static void tcp_v6_init_req(struct request_sock *req, struct sock *sk,
729 struct sk_buff *skb)
730{
731 struct inet_request_sock *ireq = inet_rsk(req);
732 struct ipv6_pinfo *np = inet6_sk(sk);
733
734 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
735 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
736
737 ireq->ir_iif = sk->sk_bound_dev_if;
738
739 /* So that link locals have meaning */
740 if (!sk->sk_bound_dev_if &&
741 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
Eric Dumazet870c3152014-10-17 09:17:20 -0700742 ireq->ir_iif = tcp_v6_iif(skb);
Octavian Purdila16bea702014-06-25 17:09:53 +0300743
Eric Dumazet04317da2014-09-05 15:33:32 -0700744 if (!TCP_SKB_CB(skb)->tcp_tw_isn &&
Eric Dumazeta2247722014-09-27 09:50:56 -0700745 (ipv6_opt_accepted(sk, skb, &TCP_SKB_CB(skb)->header.h6) ||
746 np->rxopt.bits.rxinfo ||
Octavian Purdila16bea702014-06-25 17:09:53 +0300747 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
748 np->rxopt.bits.rxohlim || np->repflow)) {
749 atomic_inc(&skb->users);
750 ireq->pktopts = skb;
751 }
752}
753
Octavian Purdilad94e0412014-06-25 17:09:55 +0300754static struct dst_entry *tcp_v6_route_req(struct sock *sk, struct flowi *fl,
755 const struct request_sock *req,
756 bool *strict)
757{
758 if (strict)
759 *strict = true;
760 return inet6_csk_route_req(sk, &fl->u.ip6, req);
761}
762
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800763struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700765 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila5db92c92014-06-25 17:09:59 +0300766 .rtx_syn_ack = tcp_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700767 .send_ack = tcp_v6_reqsk_send_ack,
768 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800769 .send_reset = tcp_v6_send_reset,
Wang Yufen4aa956d2014-03-29 09:27:29 +0800770 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771};
772
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000773static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
Octavian Purdila2aec4a22014-06-25 17:10:00 +0300774 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) -
775 sizeof(struct ipv6hdr),
Octavian Purdila16bea702014-06-25 17:09:53 +0300776#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800777 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000778 .calc_md5_hash = tcp_v6_md5_hash_skb,
Andrew Mortonb6332e62006-11-30 19:16:28 -0800779#endif
Octavian Purdila16bea702014-06-25 17:09:53 +0300780 .init_req = tcp_v6_init_req,
Octavian Purdilafb7b37a2014-06-25 17:09:54 +0300781#ifdef CONFIG_SYN_COOKIES
782 .cookie_init_seq = cookie_v6_init_sequence,
783#endif
Octavian Purdilad94e0412014-06-25 17:09:55 +0300784 .route_req = tcp_v6_route_req,
Octavian Purdila936b8bd2014-06-25 17:09:57 +0300785 .init_seq = tcp_v6_init_sequence,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300786 .send_synack = tcp_v6_send_synack,
Octavian Purdila695da142014-06-25 17:10:01 +0300787 .queue_hash_add = inet6_csk_reqsk_queue_hash_add,
Octavian Purdila16bea702014-06-25 17:09:53 +0300788};
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800789
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700790static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
Wang Yufen9c76a112014-03-29 09:27:31 +0800791 u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100792 struct tcp_md5sig_key *key, int rst, u8 tclass,
793 u32 label)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400795 const struct tcphdr *th = tcp_hdr(skb);
796 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500798 struct flowi6 fl6;
Eric Dumazetadf30902009-06-02 05:19:30 +0000799 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800800 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800801 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000802 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800803 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Andrey Vaginee684b62013-02-11 05:50:19 +0000805 if (tsecr)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700806 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800807#ifdef CONFIG_TCP_MD5SIG
808 if (key)
809 tot_len += TCPOLEN_MD5SIG_ALIGNED;
810#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
812 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
813 GFP_ATOMIC);
814 if (buff == NULL)
815 return;
816
817 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
818
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700819 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700820 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
822 /* Swap the send and the receive. */
823 memset(t1, 0, sizeof(*t1));
824 t1->dest = th->source;
825 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700826 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 t1->seq = htonl(seq);
828 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700829 t1->ack = !rst || !th->ack;
830 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800832
Al Viroe69a4adc2006-11-14 20:56:00 -0800833 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900834
Andrey Vaginee684b62013-02-11 05:50:19 +0000835 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800836 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
837 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000838 *topt++ = htonl(tsval);
839 *topt++ = htonl(tsecr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
841
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800842#ifdef CONFIG_TCP_MD5SIG
843 if (key) {
844 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
845 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700846 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700847 &ipv6_hdr(skb)->saddr,
848 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800849 }
850#endif
851
David S. Miller4c9483b2011-03-12 16:22:43 -0500852 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000853 fl6.daddr = ipv6_hdr(skb)->saddr;
854 fl6.saddr = ipv6_hdr(skb)->daddr;
Florent Fourcot1d13a962014-01-16 17:21:22 +0100855 fl6.flowlabel = label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
David S. Millere5700af2010-04-21 14:59:20 -0700857 buff->ip_summed = CHECKSUM_PARTIAL;
858 buff->csum = 0;
859
David S. Miller4c9483b2011-03-12 16:22:43 -0500860 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
David S. Miller4c9483b2011-03-12 16:22:43 -0500862 fl6.flowi6_proto = IPPROTO_TCP;
Lorenzo Colittia36dbdb2014-04-11 13:19:12 +0900863 if (rt6_need_strict(&fl6.daddr) && !oif)
Eric Dumazet870c3152014-10-17 09:17:20 -0700864 fl6.flowi6_oif = tcp_v6_iif(skb);
Wang Yufen9c76a112014-03-29 09:27:31 +0800865 else
866 fl6.flowi6_oif = oif;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700867 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
David S. Miller1958b852011-03-12 16:36:19 -0500868 fl6.fl6_dport = t1->dest;
869 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500870 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700872 /* Pass a socket to ip6_dst_lookup either it is for RST
873 * Underlying function will use this to retrieve the network
874 * namespace
875 */
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200876 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800877 if (!IS_ERR(dst)) {
878 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400879 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800880 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
881 if (rst)
882 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
883 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 }
885
886 kfree_skb(buff);
887}
888
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700889static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
890{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400891 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700892 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700893 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000894#ifdef CONFIG_TCP_MD5SIG
895 const __u8 *hash_location = NULL;
896 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
897 unsigned char newhash[16];
898 int genhash;
899 struct sock *sk1 = NULL;
900#endif
Wang Yufen9c76a112014-03-29 09:27:31 +0800901 int oif;
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700902
903 if (th->rst)
904 return;
905
906 if (!ipv6_unicast_destination(skb))
907 return;
908
909#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000910 hash_location = tcp_parse_md5sig_option(th);
911 if (!sk && hash_location) {
912 /*
913 * active side is lost. Try to find listening socket through
914 * source port, and then find md5 key through listening socket.
915 * we are not loose security here:
916 * Incoming packet is checked with md5 hash with finding key,
917 * no RST generated if md5 hash doesn't match.
918 */
919 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbert5ba24952013-01-22 09:50:39 +0000920 &tcp_hashinfo, &ipv6h->saddr,
921 th->source, &ipv6h->daddr,
Eric Dumazet870c3152014-10-17 09:17:20 -0700922 ntohs(th->source), tcp_v6_iif(skb));
Shawn Lu658ddaa2012-01-31 22:35:48 +0000923 if (!sk1)
924 return;
925
926 rcu_read_lock();
927 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
928 if (!key)
929 goto release_sk1;
930
931 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
932 if (genhash || memcmp(hash_location, newhash, 16) != 0)
933 goto release_sk1;
934 } else {
935 key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
936 }
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700937#endif
938
939 if (th->ack)
940 seq = ntohl(th->ack_seq);
941 else
942 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
943 (th->doff << 2);
944
Wang Yufen9c76a112014-03-29 09:27:31 +0800945 oif = sk ? sk->sk_bound_dev_if : 0;
946 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000947
948#ifdef CONFIG_TCP_MD5SIG
949release_sk1:
950 if (sk1) {
951 rcu_read_unlock();
952 sock_put(sk1);
953 }
954#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700955}
956
Andrey Vaginee684b62013-02-11 05:50:19 +0000957static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
Wang Yufen9c76a112014-03-29 09:27:31 +0800958 u32 win, u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100959 struct tcp_md5sig_key *key, u8 tclass,
960 u32 label)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700961{
Wang Yufen9c76a112014-03-29 09:27:31 +0800962 tcp_v6_send_response(skb, seq, ack, win, tsval, tsecr, oif, key, 0, tclass,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100963 label);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700964}
965
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
967{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700968 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800969 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900971 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700972 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000973 tcp_time_stamp + tcptw->tw_ts_offset,
Wang Yufen9c76a112014-03-29 09:27:31 +0800974 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
Florent Fourcot1d13a962014-01-16 17:21:22 +0100975 tw->tw_tclass, (tw->tw_flowlabel << 12));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700977 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978}
979
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700980static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
981 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982{
Daniel Lee3a19ce02014-05-11 20:22:13 -0700983 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
984 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
985 */
986 tcp_v6_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
987 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
988 tcp_rsk(req)->rcv_nxt,
Wang Yufen9c76a112014-03-29 09:27:31 +0800989 req->rcv_wnd, tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100990 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
991 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992}
993
994
Weilong Chen4c99aa42013-12-19 18:44:34 +0800995static struct sock *tcp_v6_hnd_req(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700997 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700998 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 struct sock *nsk;
1000
1001 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -08001002 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001003 &ipv6_hdr(skb)->saddr,
Eric Dumazet870c3152014-10-17 09:17:20 -07001004 &ipv6_hdr(skb)->daddr, tcp_v6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 if (req)
Jerry Chu83368862012-08-31 12:29:12 +00001006 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001008 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Eric Dumazet870c3152014-10-17 09:17:20 -07001009 &ipv6_hdr(skb)->saddr, th->source,
1010 &ipv6_hdr(skb)->daddr, ntohs(th->dest),
1011 tcp_v6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
1013 if (nsk) {
1014 if (nsk->sk_state != TCP_TIME_WAIT) {
1015 bh_lock_sock(nsk);
1016 return nsk;
1017 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001018 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 return NULL;
1020 }
1021
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001022#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001023 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001024 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025#endif
1026 return sk;
1027}
1028
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1030{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 if (skb->protocol == htons(ETH_P_IP))
1032 return tcp_v4_conn_request(sk, skb);
1033
1034 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001035 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036
Octavian Purdila1fb6f152014-06-25 17:10:02 +03001037 return tcp_conn_request(&tcp6_request_sock_ops,
1038 &tcp_request_sock_ipv6_ops, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040drop:
Vijay Subramanian5f1e9422013-01-31 08:24:19 +00001041 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 return 0; /* don't send reset */
1043}
1044
Weilong Chen4c99aa42013-12-19 18:44:34 +08001045static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1046 struct request_sock *req,
1047 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048{
Eric Dumazet634fb9792013-10-09 15:21:29 -07001049 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1051 struct tcp6_sock *newtcp6sk;
1052 struct inet_sock *newinet;
1053 struct tcp_sock *newtp;
1054 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001055#ifdef CONFIG_TCP_MD5SIG
1056 struct tcp_md5sig_key *key;
1057#endif
Neal Cardwell3840a062012-06-28 12:34:19 +00001058 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059
1060 if (skb->protocol == htons(ETH_P_IP)) {
1061 /*
1062 * v6 mapped
1063 */
1064
1065 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1066
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001067 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return NULL;
1069
1070 newtcp6sk = (struct tcp6_sock *)newsk;
1071 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1072
1073 newinet = inet_sk(newsk);
1074 newnp = inet6_sk(newsk);
1075 newtp = tcp_sk(newsk);
1076
1077 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1078
Eric Dumazetefe42082013-10-03 15:42:29 -07001079 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001081 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
Eric Dumazetefe42082013-10-03 15:42:29 -07001083 newsk->sk_v6_rcv_saddr = newnp->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001085 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001087#ifdef CONFIG_TCP_MD5SIG
1088 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1089#endif
1090
Yan, Zheng676a1182011-09-25 02:21:30 +00001091 newnp->ipv6_ac_list = NULL;
1092 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 newnp->pktoptions = NULL;
1094 newnp->opt = NULL;
Eric Dumazet870c3152014-10-17 09:17:20 -07001095 newnp->mcast_oif = tcp_v6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001096 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001097 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001098 if (np->repflow)
1099 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001101 /*
1102 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1103 * here, tcp_create_openreq_child now does this for us, see the comment in
1104 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
1107 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001108 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 Sync it now.
1110 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001111 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
1113 return newsk;
1114 }
1115
Eric Dumazet634fb9792013-10-09 15:21:29 -07001116 ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
1118 if (sk_acceptq_is_full(sk))
1119 goto out_overflow;
1120
David S. Miller493f3772010-12-02 12:14:29 -08001121 if (!dst) {
Neal Cardwell3840a062012-06-28 12:34:19 +00001122 dst = inet6_csk_route_req(sk, &fl6, req);
David S. Miller493f3772010-12-02 12:14:29 -08001123 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001125 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
1127 newsk = tcp_create_openreq_child(sk, req, skb);
1128 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001129 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001131 /*
1132 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1133 * count here, tcp_create_openreq_child now does this for us, see the
1134 * comment in that function for the gory details. -acme
1135 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
Stephen Hemminger59eed272006-08-25 15:55:43 -07001137 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001138 __ip6_dst_store(newsk, dst, NULL, NULL);
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001139 inet6_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
1141 newtcp6sk = (struct tcp6_sock *)newsk;
1142 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1143
1144 newtp = tcp_sk(newsk);
1145 newinet = inet_sk(newsk);
1146 newnp = inet6_sk(newsk);
1147
1148 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1149
Eric Dumazet634fb9792013-10-09 15:21:29 -07001150 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1151 newnp->saddr = ireq->ir_v6_loc_addr;
1152 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1153 newsk->sk_bound_dev_if = ireq->ir_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154
Tom Herbertb73c3d02014-07-01 21:32:17 -07001155 ip6_set_txhash(newsk);
1156
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001157 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
1159 First: no IPv4 options.
1160 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001161 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001162 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001163 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
1165 /* Clone RX bits */
1166 newnp->rxopt.all = np->rxopt.all;
1167
1168 /* Clone pktoptions received with SYN */
1169 newnp->pktoptions = NULL;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001170 if (ireq->pktopts != NULL) {
1171 newnp->pktoptions = skb_clone(ireq->pktopts,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001172 sk_gfp_atomic(sk, GFP_ATOMIC));
Eric Dumazet634fb9792013-10-09 15:21:29 -07001173 consume_skb(ireq->pktopts);
1174 ireq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 if (newnp->pktoptions)
1176 skb_set_owner_r(newnp->pktoptions, newsk);
1177 }
1178 newnp->opt = NULL;
Eric Dumazet870c3152014-10-17 09:17:20 -07001179 newnp->mcast_oif = tcp_v6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001180 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001181 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001182 if (np->repflow)
1183 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185 /* Clone native IPv6 options from listening socket (if any)
1186
1187 Yes, keeping reference count would be much more clever,
1188 but we make one more one thing there: reattach optmem
1189 to newsk.
1190 */
RongQing.Li43264e02012-07-01 17:18:59 +00001191 if (np->opt)
1192 newnp->opt = ipv6_dup_options(newsk, np->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001194 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001196 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1197 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
1199 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001200 newtp->advmss = dst_metric_advmss(dst);
Neal Cardwelld135c522012-04-22 09:45:47 +00001201 if (tcp_sk(sk)->rx_opt.user_mss &&
1202 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1203 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1204
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 tcp_initialize_rcv_mss(newsk);
1206
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001207 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1208 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001210#ifdef CONFIG_TCP_MD5SIG
1211 /* Copy over the MD5 key from the original socket */
Wang Yufen4aa956d2014-03-29 09:27:29 +08001212 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
1213 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001214 /* We're using one, so create a matching key
1215 * on the newsk structure. If we fail to get
1216 * memory, then we end up not copying the key
1217 * across. Shucks.
1218 */
Eric Dumazetefe42082013-10-03 15:42:29 -07001219 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001220 AF_INET6, key->key, key->keylen,
1221 sk_gfp_atomic(sk, GFP_ATOMIC));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001222 }
1223#endif
1224
Balazs Scheidler093d2822010-10-21 13:06:43 +02001225 if (__inet_inherit_port(sk, newsk) < 0) {
Christoph Paasche337e242012-12-14 04:07:58 +00001226 inet_csk_prepare_forced_close(newsk);
1227 tcp_done(newsk);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001228 goto out;
1229 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001230 __inet6_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
1232 return newsk;
1233
1234out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001235 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001236out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001238out:
1239 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 return NULL;
1241}
1242
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243/* The socket must have it's spinlock held when we get
1244 * here.
1245 *
1246 * We have a potential double-lock case here, so even when
1247 * doing backlog processing we use the BH locking scheme.
1248 * This is because we cannot sleep with the original spinlock
1249 * held.
1250 */
1251static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1252{
1253 struct ipv6_pinfo *np = inet6_sk(sk);
1254 struct tcp_sock *tp;
1255 struct sk_buff *opt_skb = NULL;
1256
1257 /* Imagine: socket is IPv6. IPv4 packet arrives,
1258 goes to IPv4 receive handler and backlogged.
1259 From backlog it always goes here. Kerboom...
1260 Fortunately, tcp_rcv_established and rcv_established
1261 handle them correctly, but it is not case with
1262 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1263 */
1264
1265 if (skb->protocol == htons(ETH_P_IP))
1266 return tcp_v4_do_rcv(sk, skb);
1267
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001268 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 goto discard;
1270
1271 /*
1272 * socket locking is here for SMP purposes as backlog rcv
1273 * is currently called with bh processing disabled.
1274 */
1275
1276 /* Do Stevens' IPV6_PKTOPTIONS.
1277
1278 Yes, guys, it is the only place in our code, where we
1279 may make it not affecting IPv4.
1280 The rest of code is protocol independent,
1281 and I do not like idea to uglify IPv4.
1282
1283 Actually, all the idea behind IPV6_PKTOPTIONS
1284 looks not very well thought. For now we latch
1285 options, received in the last packet, enqueued
1286 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001287 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 */
1289 if (np->rxopt.all)
Mel Gorman99a1dec2012-07-31 16:44:14 -07001290 opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
1292 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet5d299f32012-08-06 05:09:33 +00001293 struct dst_entry *dst = sk->sk_rx_dst;
1294
Tom Herbertbdeab992011-08-14 19:45:55 +00001295 sock_rps_save_rxhash(sk, skb);
Eric Dumazet3d973792014-11-11 05:54:27 -08001296 sk_mark_napi_id(sk, skb);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001297 if (dst) {
1298 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1299 dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1300 dst_release(dst);
1301 sk->sk_rx_dst = NULL;
1302 }
1303 }
1304
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001305 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 if (opt_skb)
1307 goto ipv6_pktoptions;
1308 return 0;
1309 }
1310
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001311 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 goto csum_err;
1313
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001314 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1316 if (!nsk)
1317 goto discard;
1318
1319 /*
1320 * Queue it on the new socket if the new socket is active,
1321 * otherwise we just shortcircuit this and continue with
1322 * the new socket..
1323 */
Weilong Chen4c99aa42013-12-19 18:44:34 +08001324 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001325 sock_rps_save_rxhash(nsk, skb);
Eric Dumazet3d973792014-11-11 05:54:27 -08001326 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 if (tcp_child_process(sk, nsk, skb))
1328 goto reset;
1329 if (opt_skb)
1330 __kfree_skb(opt_skb);
1331 return 0;
1332 }
Neil Horman47482f12011-04-06 13:07:09 -07001333 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001334 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001336 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 if (opt_skb)
1339 goto ipv6_pktoptions;
1340 return 0;
1341
1342reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001343 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344discard:
1345 if (opt_skb)
1346 __kfree_skb(opt_skb);
1347 kfree_skb(skb);
1348 return 0;
1349csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001350 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001351 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 goto discard;
1353
1354
1355ipv6_pktoptions:
1356 /* Do you ask, what is it?
1357
1358 1. skb was enqueued by tcp.
1359 2. skb is added to tail of read queue, rather than out of order.
1360 3. socket is not in passive state.
1361 4. Finally, it really contains options, which user wants to receive.
1362 */
1363 tp = tcp_sk(sk);
1364 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1365 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001366 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Eric Dumazet870c3152014-10-17 09:17:20 -07001367 np->mcast_oif = tcp_v6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001368 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001369 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Florent Fourcot82e9f102013-12-08 15:46:59 +01001370 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
Florent Fourcot1397ed32013-12-08 15:46:57 +01001371 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001372 if (np->repflow)
1373 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
Eric Dumazeta2247722014-09-27 09:50:56 -07001374 if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 skb_set_owner_r(opt_skb, sk);
1376 opt_skb = xchg(&np->pktoptions, opt_skb);
1377 } else {
1378 __kfree_skb(opt_skb);
1379 opt_skb = xchg(&np->pktoptions, NULL);
1380 }
1381 }
1382
Wei Yongjun800d55f2009-02-23 21:45:33 +00001383 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 return 0;
1385}
1386
Herbert Xue5bbef22007-10-15 12:50:28 -07001387static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001389 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001390 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 struct sock *sk;
1392 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001393 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
1395 if (skb->pkt_type != PACKET_HOST)
1396 goto discard_it;
1397
1398 /*
1399 * Count it even if it's bad.
1400 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001401 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
1403 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1404 goto discard_it;
1405
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001406 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407
1408 if (th->doff < sizeof(struct tcphdr)/4)
1409 goto bad_packet;
1410 if (!pskb_may_pull(skb, th->doff*4))
1411 goto discard_it;
1412
Tom Herberte4f45b72014-05-02 16:29:51 -07001413 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001414 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001416 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001417 hdr = ipv6_hdr(skb);
Eric Dumazet971f10e2014-09-27 09:50:57 -07001418 /* This is tricky : We move IPCB at its correct location into TCP_SKB_CB()
1419 * barrier() makes sure compiler wont play fool^Waliasing games.
1420 */
1421 memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
1422 sizeof(struct inet6_skb_parm));
1423 barrier();
1424
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1426 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1427 skb->len - th->doff*4);
1428 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
Eric Dumazete11ecdd2014-09-15 04:19:51 -07001429 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
Eric Dumazet04317da2014-09-05 15:33:32 -07001430 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001431 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 TCP_SKB_CB(skb)->sacked = 0;
1433
Eric Dumazet870c3152014-10-17 09:17:20 -07001434 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest,
1435 tcp_v6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 if (!sk)
1437 goto no_tcp_socket;
1438
1439process:
1440 if (sk->sk_state == TCP_TIME_WAIT)
1441 goto do_time_wait;
1442
Stephen Hemmingere802af92010-04-22 15:24:53 -07001443 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1444 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1445 goto discard_and_relse;
1446 }
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1449 goto discard_and_relse;
1450
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001451#ifdef CONFIG_TCP_MD5SIG
1452 if (tcp_v6_inbound_md5_hash(sk, skb))
1453 goto discard_and_relse;
1454#endif
1455
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001456 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 goto discard_and_relse;
1458
Eric Dumazet2c8c56e2014-11-11 05:54:28 -08001459 sk_incoming_cpu_update(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 skb->dev = NULL;
1461
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001462 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 ret = 0;
1464 if (!sock_owned_by_user(sk)) {
Dan Williams7bced392013-12-30 12:37:29 -08001465 if (!tcp_prequeue(sk, skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001466 ret = tcp_v6_do_rcv(sk, skb);
Eric Dumazetda882c12012-04-22 23:38:54 +00001467 } else if (unlikely(sk_add_backlog(sk, skb,
1468 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001469 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001470 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001471 goto discard_and_relse;
1472 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 bh_unlock_sock(sk);
1474
1475 sock_put(sk);
1476 return ret ? -1 : 0;
1477
1478no_tcp_socket:
1479 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1480 goto discard_it;
1481
1482 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001483csum_error:
1484 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001486 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001488 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 }
1490
1491discard_it:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 kfree_skb(skb);
1493 return 0;
1494
1495discard_and_relse:
1496 sock_put(sk);
1497 goto discard_it;
1498
1499do_time_wait:
1500 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001501 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 goto discard_it;
1503 }
1504
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001505 if (skb->len < (th->doff<<2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001506 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001507 goto bad_packet;
1508 }
1509 if (tcp_checksum_complete(skb)) {
1510 inet_twsk_put(inet_twsk(sk));
1511 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 }
1513
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001514 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 case TCP_TW_SYN:
1516 {
1517 struct sock *sk2;
1518
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001519 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Tom Herbert5ba24952013-01-22 09:50:39 +00001520 &ipv6_hdr(skb)->saddr, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001521 &ipv6_hdr(skb)->daddr,
Eric Dumazet870c3152014-10-17 09:17:20 -07001522 ntohs(th->dest), tcp_v6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001524 struct inet_timewait_sock *tw = inet_twsk(sk);
1525 inet_twsk_deschedule(tw, &tcp_death_row);
1526 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 sk = sk2;
1528 goto process;
1529 }
1530 /* Fall through to ACK */
1531 }
1532 case TCP_TW_ACK:
1533 tcp_v6_timewait_ack(sk, skb);
1534 break;
1535 case TCP_TW_RST:
1536 goto no_tcp_socket;
Wang Yufen4aa956d2014-03-29 09:27:29 +08001537 case TCP_TW_SUCCESS:
1538 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 }
1540 goto discard_it;
1541}
1542
Eric Dumazetc7109982012-07-26 12:18:11 +00001543static void tcp_v6_early_demux(struct sk_buff *skb)
1544{
1545 const struct ipv6hdr *hdr;
1546 const struct tcphdr *th;
1547 struct sock *sk;
1548
1549 if (skb->pkt_type != PACKET_HOST)
1550 return;
1551
1552 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1553 return;
1554
1555 hdr = ipv6_hdr(skb);
1556 th = tcp_hdr(skb);
1557
1558 if (th->doff < sizeof(struct tcphdr) / 4)
1559 return;
1560
Eric Dumazet870c3152014-10-17 09:17:20 -07001561 /* Note : We use inet6_iif() here, not tcp_v6_iif() */
Eric Dumazetc7109982012-07-26 12:18:11 +00001562 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1563 &hdr->saddr, th->source,
1564 &hdr->daddr, ntohs(th->dest),
1565 inet6_iif(skb));
1566 if (sk) {
1567 skb->sk = sk;
1568 skb->destructor = sock_edemux;
1569 if (sk->sk_state != TCP_TIME_WAIT) {
1570 struct dst_entry *dst = sk->sk_rx_dst;
Neal Cardwellf3f12132012-10-22 21:41:48 +00001571
Eric Dumazetc7109982012-07-26 12:18:11 +00001572 if (dst)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001573 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
Eric Dumazetc7109982012-07-26 12:18:11 +00001574 if (dst &&
Neal Cardwellf3f12132012-10-22 21:41:48 +00001575 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
Eric Dumazetc7109982012-07-26 12:18:11 +00001576 skb_dst_set_noref(skb, dst);
1577 }
1578 }
1579}
1580
David S. Millerccb7c412010-12-01 18:09:13 -08001581static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1582 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1583 .twsk_unique = tcp_twsk_unique,
Wang Yufen4aa956d2014-03-29 09:27:29 +08001584 .twsk_destructor = tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001585};
1586
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001587static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001588 .queue_xmit = inet6_csk_xmit,
1589 .send_check = tcp_v6_send_check,
1590 .rebuild_header = inet6_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001591 .sk_rx_dst_set = inet6_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001592 .conn_request = tcp_v6_conn_request,
1593 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001594 .net_header_len = sizeof(struct ipv6hdr),
Eric Dumazet67469602012-04-24 07:37:38 +00001595 .net_frag_header_len = sizeof(struct frag_hdr),
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001596 .setsockopt = ipv6_setsockopt,
1597 .getsockopt = ipv6_getsockopt,
1598 .addr2sockaddr = inet6_csk_addr2sockaddr,
1599 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001600 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001601#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001602 .compat_setsockopt = compat_ipv6_setsockopt,
1603 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001604#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001605 .mtu_reduced = tcp_v6_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606};
1607
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001608#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001609static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001610 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001611 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001612 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001613};
David S. Millera9286302006-11-14 19:53:22 -08001614#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001615
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616/*
1617 * TCP over IPv4 via INET6 API
1618 */
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001619static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001620 .queue_xmit = ip_queue_xmit,
1621 .send_check = tcp_v4_send_check,
1622 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet63d02d12012-08-09 14:11:00 +00001623 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001624 .conn_request = tcp_v6_conn_request,
1625 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001626 .net_header_len = sizeof(struct iphdr),
1627 .setsockopt = ipv6_setsockopt,
1628 .getsockopt = ipv6_getsockopt,
1629 .addr2sockaddr = inet6_csk_addr2sockaddr,
1630 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001631 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001632#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001633 .compat_setsockopt = compat_ipv6_setsockopt,
1634 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001635#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001636 .mtu_reduced = tcp_v4_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637};
1638
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001639#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001640static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001641 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001642 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001643 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001644};
David S. Millera9286302006-11-14 19:53:22 -08001645#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001646
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647/* NOTE: A lot of things set to zero explicitly by call to
1648 * sk_alloc() so need not be done here.
1649 */
1650static int tcp_v6_init_sock(struct sock *sk)
1651{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001652 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Neal Cardwell900f65d2012-04-19 09:55:21 +00001654 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001656 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001658#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001659 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001660#endif
1661
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 return 0;
1663}
1664
Brian Haley7d06b2e2008-06-14 17:04:49 -07001665static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001668 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669}
1670
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001671#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001673static void get_openreq6(struct seq_file *seq,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001674 const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 int ttd = req->expires - jiffies;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001677 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1678 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
1680 if (ttd < 0)
1681 ttd = 0;
1682
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 seq_printf(seq,
1684 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001685 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 i,
1687 src->s6_addr32[0], src->s6_addr32[1],
1688 src->s6_addr32[2], src->s6_addr32[3],
Eric Dumazetb44084c2013-10-10 00:04:37 -07001689 inet_rsk(req)->ir_num,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 dest->s6_addr32[0], dest->s6_addr32[1],
1691 dest->s6_addr32[2], dest->s6_addr32[3],
Eric Dumazet634fb9792013-10-09 15:21:29 -07001692 ntohs(inet_rsk(req)->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 TCP_SYN_RECV,
Weilong Chen4c99aa42013-12-19 18:44:34 +08001694 0, 0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001695 1, /* timers active (only the expire timer) */
1696 jiffies_to_clock_t(ttd),
Eric Dumazete6c022a2012-10-27 23:16:46 +00001697 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001698 from_kuid_munged(seq_user_ns(seq), uid),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001699 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 0, /* open_requests have no inode */
1701 0, req);
1702}
1703
1704static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1705{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001706 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 __u16 destp, srcp;
1708 int timer_active;
1709 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001710 const struct inet_sock *inet = inet_sk(sp);
1711 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001712 const struct inet_connection_sock *icsk = inet_csk(sp);
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001713 struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714
Eric Dumazetefe42082013-10-03 15:42:29 -07001715 dest = &sp->sk_v6_daddr;
1716 src = &sp->sk_v6_rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001717 destp = ntohs(inet->inet_dport);
1718 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001719
1720 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001722 timer_expires = icsk->icsk_timeout;
1723 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001725 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 } else if (timer_pending(&sp->sk_timer)) {
1727 timer_active = 2;
1728 timer_expires = sp->sk_timer.expires;
1729 } else {
1730 timer_active = 0;
1731 timer_expires = jiffies;
1732 }
1733
1734 seq_printf(seq,
1735 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001736 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 i,
1738 src->s6_addr32[0], src->s6_addr32[1],
1739 src->s6_addr32[2], src->s6_addr32[3], srcp,
1740 dest->s6_addr32[0], dest->s6_addr32[1],
1741 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001742 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001743 tp->write_seq-tp->snd_una,
1744 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00001746 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001747 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001748 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001749 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 sock_i_ino(sp),
1751 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001752 jiffies_to_clock_t(icsk->icsk_rto),
1753 jiffies_to_clock_t(icsk->icsk_ack.ato),
Weilong Chen4c99aa42013-12-19 18:44:34 +08001754 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001755 tp->snd_cwnd,
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001756 sp->sk_state == TCP_LISTEN ?
1757 (fastopenq ? fastopenq->max_qlen : 0) :
1758 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 );
1760}
1761
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001762static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001763 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001765 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 __u16 destp, srcp;
Eric Dumazet96f817f2013-10-03 14:27:25 -07001767 s32 delta = tw->tw_ttd - inet_tw_time_stamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768
Eric Dumazetefe42082013-10-03 15:42:29 -07001769 dest = &tw->tw_v6_daddr;
1770 src = &tw->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 destp = ntohs(tw->tw_dport);
1772 srcp = ntohs(tw->tw_sport);
1773
1774 seq_printf(seq,
1775 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001776 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 i,
1778 src->s6_addr32[0], src->s6_addr32[1],
1779 src->s6_addr32[2], src->s6_addr32[3], srcp,
1780 dest->s6_addr32[0], dest->s6_addr32[1],
1781 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1782 tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00001783 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 atomic_read(&tw->tw_refcnt), tw);
1785}
1786
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787static int tcp6_seq_show(struct seq_file *seq, void *v)
1788{
1789 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001790 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
1792 if (v == SEQ_START_TOKEN) {
1793 seq_puts(seq,
1794 " sl "
1795 "local_address "
1796 "remote_address "
1797 "st tx_queue rx_queue tr tm->when retrnsmt"
1798 " uid timeout inode\n");
1799 goto out;
1800 }
1801 st = seq->private;
1802
1803 switch (st->state) {
1804 case TCP_SEQ_STATE_LISTENING:
1805 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001806 if (sk->sk_state == TCP_TIME_WAIT)
1807 get_timewait6_sock(seq, v, st->num);
1808 else
1809 get_tcp6_sock(seq, v, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 break;
1811 case TCP_SEQ_STATE_OPENREQ:
1812 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1813 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 }
1815out:
1816 return 0;
1817}
1818
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001819static const struct file_operations tcp6_afinfo_seq_fops = {
1820 .owner = THIS_MODULE,
1821 .open = tcp_seq_open,
1822 .read = seq_read,
1823 .llseek = seq_lseek,
1824 .release = seq_release_net
1825};
1826
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 .name = "tcp6",
1829 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001830 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07001831 .seq_ops = {
1832 .show = tcp6_seq_show,
1833 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834};
1835
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001836int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001838 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839}
1840
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001841void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001843 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844}
1845#endif
1846
Eric Dumazetf77d6022013-05-09 10:28:16 +00001847static void tcp_v6_clear_sk(struct sock *sk, int size)
1848{
1849 struct inet_sock *inet = inet_sk(sk);
1850
1851 /* we do not want to clear pinet6 field, because of RCU lookups */
1852 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1853
1854 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1855 memset(&inet->pinet6 + 1, 0, size);
1856}
1857
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858struct proto tcpv6_prot = {
1859 .name = "TCPv6",
1860 .owner = THIS_MODULE,
1861 .close = tcp_close,
1862 .connect = tcp_v6_connect,
1863 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001864 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 .ioctl = tcp_ioctl,
1866 .init = tcp_v6_init_sock,
1867 .destroy = tcp_v6_destroy_sock,
1868 .shutdown = tcp_shutdown,
1869 .setsockopt = tcp_setsockopt,
1870 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00001872 .sendmsg = tcp_sendmsg,
1873 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 .backlog_rcv = tcp_v6_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00001875 .release_cb = tcp_release_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001877 .unhash = inet_unhash,
1878 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07001880 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 .sockets_allocated = &tcp_sockets_allocated,
1882 .memory_allocated = &tcp_memory_allocated,
1883 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001884 .orphan_count = &tcp_orphan_count,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07001885 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 .sysctl_wmem = sysctl_tcp_wmem,
1887 .sysctl_rmem = sysctl_tcp_rmem,
1888 .max_header = MAX_TCP_HEADER,
1889 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001890 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001891 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001892 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07001893 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00001894 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001895#ifdef CONFIG_COMPAT
1896 .compat_setsockopt = compat_tcp_setsockopt,
1897 .compat_getsockopt = compat_tcp_getsockopt,
1898#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07001899#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001900 .proto_cgroup = tcp_proto_cgroup,
1901#endif
Eric Dumazetf77d6022013-05-09 10:28:16 +00001902 .clear_sk = tcp_v6_clear_sk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903};
1904
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00001905static const struct inet6_protocol tcpv6_protocol = {
Eric Dumazetc7109982012-07-26 12:18:11 +00001906 .early_demux = tcp_v6_early_demux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 .handler = tcp_v6_rcv,
1908 .err_handler = tcp_v6_err,
1909 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1910};
1911
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912static struct inet_protosw tcpv6_protosw = {
1913 .type = SOCK_STREAM,
1914 .protocol = IPPROTO_TCP,
1915 .prot = &tcpv6_prot,
1916 .ops = &inet6_stream_ops,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001917 .flags = INET_PROTOSW_PERMANENT |
1918 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919};
1920
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001921static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001922{
Denis V. Lunev56772422008-04-03 14:28:30 -07001923 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1924 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001925}
1926
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001927static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001928{
Denis V. Lunev56772422008-04-03 14:28:30 -07001929 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001930}
1931
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001932static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001933{
1934 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001935}
1936
1937static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001938 .init = tcpv6_net_init,
1939 .exit = tcpv6_net_exit,
1940 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001941};
1942
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001943int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001945 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08001946
Vlad Yasevich33362882012-11-15 08:49:15 +00001947 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1948 if (ret)
Vlad Yasevichc6b641a2012-11-15 08:49:22 +00001949 goto out;
Vlad Yasevich33362882012-11-15 08:49:15 +00001950
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001951 /* register inet6 protocol */
1952 ret = inet6_register_protosw(&tcpv6_protosw);
1953 if (ret)
1954 goto out_tcpv6_protocol;
1955
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001956 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001957 if (ret)
1958 goto out_tcpv6_protosw;
1959out:
1960 return ret;
1961
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001962out_tcpv6_protosw:
1963 inet6_unregister_protosw(&tcpv6_protosw);
Vlad Yasevich33362882012-11-15 08:49:15 +00001964out_tcpv6_protocol:
1965 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001966 goto out;
1967}
1968
Daniel Lezcano09f77092007-12-13 05:34:58 -08001969void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001970{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001971 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001972 inet6_unregister_protosw(&tcpv6_protosw);
1973 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974}