blob: e289830ed6e35a3be4feda700b5b6789dac20292 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * TCP over IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09008 * Based on:
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * linux/net/ipv4/tcp.c
10 * linux/net/ipv4/tcp_input.c
11 * linux/net/ipv4/tcp_output.c
12 *
13 * Fixes:
14 * Hideaki YOSHIFUJI : sin6_scope_id support
15 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
16 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
17 * a single port at the same time.
18 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
Herbert Xueb4dea52008-12-29 23:04:08 -080026#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/socket.h>
31#include <linux/sockios.h>
32#include <linux/net.h>
33#include <linux/jiffies.h>
34#include <linux/in.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/init.h>
38#include <linux/jhash.h>
39#include <linux/ipsec.h>
40#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090041#include <linux/slab.h>
Wang Yufen4aa956d2014-03-29 09:27:29 +080042#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
Arnaldo Carvalho de Melo5324a042005-08-12 09:26:18 -030049#include <net/inet6_hashtables.h>
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -080050#include <net/inet6_connection_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <net/ipv6.h>
52#include <net/transp_v6.h>
53#include <net/addrconf.h>
54#include <net/ip6_route.h>
55#include <net/ip6_checksum.h>
56#include <net/inet_ecn.h>
57#include <net/protocol.h>
58#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <net/snmp.h>
60#include <net/dsfield.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080061#include <net/timewait_sock.h>
Jeff Garzik18134be2007-10-26 22:53:14 -070062#include <net/netdma.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070063#include <net/inet_common.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070064#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000065#include <net/tcp_memcontrol.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030066#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/proc_fs.h>
69#include <linux/seq_file.h>
70
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080071#include <linux/crypto.h>
72#include <linux/scatterlist.h>
73
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080074static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070075static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
76 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Stephen Hemminger3b401a82009-09-01 19:25:04 +000080static const struct inet_connection_sock_af_ops ipv6_mapped;
81static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080082#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000083static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
84static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090085#else
86static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000087 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090088{
89 return NULL;
90}
David S. Millera9286302006-11-14 19:53:22 -080091#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Neal Cardwellfae6ef82012-08-19 03:30:38 +000093static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
94{
95 struct dst_entry *dst = skb_dst(skb);
96 const struct rt6_info *rt = (const struct rt6_info *)dst;
97
98 dst_hold(dst);
99 sk->sk_rx_dst = dst;
100 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
101 if (rt->rt6i_node)
102 inet6_sk(sk)->rx_dst_cookie = rt->rt6i_node->fn_sernum;
103}
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105static void tcp_v6_hash(struct sock *sk)
106{
107 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800108 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 tcp_prot.hash(sk);
110 return;
111 }
112 local_bh_disable();
Eric Dumazet9327f702009-12-04 03:46:54 +0000113 __inet6_hash(sk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 local_bh_enable();
115 }
116}
117
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400118static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700120 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
121 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700122 tcp_hdr(skb)->dest,
123 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124}
125
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900126static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 int addr_len)
128{
129 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900130 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800131 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 struct ipv6_pinfo *np = inet6_sk(sk);
133 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000134 struct in6_addr *saddr = NULL, *final_p, final;
David S. Miller493f3772010-12-02 12:14:29 -0800135 struct rt6_info *rt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500136 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 struct dst_entry *dst;
138 int addr_type;
139 int err;
140
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900141 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 return -EINVAL;
143
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900144 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000145 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
David S. Miller4c9483b2011-03-12 16:22:43 -0500147 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500150 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
151 IP6_ECN_flow_init(fl6.flowlabel);
152 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 struct ip6_flowlabel *flowlabel;
David S. Miller4c9483b2011-03-12 16:22:43 -0500154 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (flowlabel == NULL)
156 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 fl6_sock_release(flowlabel);
158 }
159 }
160
161 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900162 * connect() to INADDR_ANY means loopback (BSD'ism).
163 */
164
Weilong Chen4c99aa42013-12-19 18:44:34 +0800165 if (ipv6_addr_any(&usin->sin6_addr))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900166 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
168 addr_type = ipv6_addr_type(&usin->sin6_addr);
169
Weilong Chen4c99aa42013-12-19 18:44:34 +0800170 if (addr_type & IPV6_ADDR_MULTICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return -ENETUNREACH;
172
173 if (addr_type&IPV6_ADDR_LINKLOCAL) {
174 if (addr_len >= sizeof(struct sockaddr_in6) &&
175 usin->sin6_scope_id) {
176 /* If interface is set while binding, indices
177 * must coincide.
178 */
179 if (sk->sk_bound_dev_if &&
180 sk->sk_bound_dev_if != usin->sin6_scope_id)
181 return -EINVAL;
182
183 sk->sk_bound_dev_if = usin->sin6_scope_id;
184 }
185
186 /* Connect to link-local address requires an interface */
187 if (!sk->sk_bound_dev_if)
188 return -EINVAL;
189 }
190
191 if (tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700192 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 tp->rx_opt.ts_recent = 0;
194 tp->rx_opt.ts_recent_stamp = 0;
195 tp->write_seq = 0;
196 }
197
Eric Dumazetefe42082013-10-03 15:42:29 -0700198 sk->sk_v6_daddr = usin->sin6_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500199 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
201 /*
202 * TCP over IPv4
203 */
204
205 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800206 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 struct sockaddr_in sin;
208
209 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
210
211 if (__ipv6_only_sock(sk))
212 return -ENETUNREACH;
213
214 sin.sin_family = AF_INET;
215 sin.sin_port = usin->sin6_port;
216 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
217
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800218 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800220#ifdef CONFIG_TCP_MD5SIG
221 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
222#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
224 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
225
226 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800227 icsk->icsk_ext_hdr_len = exthdrlen;
228 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800230#ifdef CONFIG_TCP_MD5SIG
231 tp->af_specific = &tcp_sock_ipv6_specific;
232#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 goto failure;
234 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000235 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
236 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
Eric Dumazetefe42082013-10-03 15:42:29 -0700237 &sk->sk_v6_rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
239
240 return err;
241 }
242
Eric Dumazetefe42082013-10-03 15:42:29 -0700243 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
244 saddr = &sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
David S. Miller4c9483b2011-03-12 16:22:43 -0500246 fl6.flowi6_proto = IPPROTO_TCP;
Eric Dumazetefe42082013-10-03 15:42:29 -0700247 fl6.daddr = sk->sk_v6_daddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000248 fl6.saddr = saddr ? *saddr : np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500249 fl6.flowi6_oif = sk->sk_bound_dev_if;
250 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500251 fl6.fl6_dport = usin->sin6_port;
252 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
David S. Miller4c9483b2011-03-12 16:22:43 -0500254 final_p = fl6_update_dst(&fl6, np->opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
David S. Miller4c9483b2011-03-12 16:22:43 -0500256 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700257
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200258 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800259 if (IS_ERR(dst)) {
260 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 goto failure;
David S. Miller14e50e52007-05-24 18:17:54 -0700262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 if (saddr == NULL) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500265 saddr = &fl6.saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700266 sk->sk_v6_rcv_saddr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 }
268
269 /* set the source address */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000270 np->saddr = *saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000271 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700273 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700274 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
David S. Miller493f3772010-12-02 12:14:29 -0800276 rt = (struct rt6_info *) dst;
277 if (tcp_death_row.sysctl_tw_recycle &&
278 !tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700279 ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
David S. Miller81166dd2012-07-10 03:14:24 -0700280 tcp_fetch_timewait_stamp(sk, dst);
David S. Miller493f3772010-12-02 12:14:29 -0800281
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800282 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800284 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
285 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
288
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000289 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
291 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800292 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 if (err)
294 goto late_failure;
295
Andrey Vagin2b916472012-11-22 01:13:58 +0000296 if (!tp->write_seq && likely(!tp->repair))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
Eric Dumazetefe42082013-10-03 15:42:29 -0700298 sk->sk_v6_daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000299 inet->inet_sport,
300 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 err = tcp_connect(sk);
303 if (err)
304 goto late_failure;
305
306 return 0;
307
308late_failure:
309 tcp_set_state(sk, TCP_CLOSE);
310 __sk_dst_reset(sk);
311failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000312 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 sk->sk_route_caps = 0;
314 return err;
315}
316
Eric Dumazet563d34d2012-07-23 09:48:52 +0200317static void tcp_v6_mtu_reduced(struct sock *sk)
318{
319 struct dst_entry *dst;
320
321 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
322 return;
323
324 dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
325 if (!dst)
326 return;
327
328 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
329 tcp_sync_mss(sk, dst_mtu(dst));
330 tcp_simple_retransmit(sk);
331 }
332}
333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700335 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
Weilong Chen4c99aa42013-12-19 18:44:34 +0800337 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300338 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 struct ipv6_pinfo *np;
340 struct sock *sk;
341 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900342 struct tcp_sock *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 __u32 seq;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700344 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700346 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800347 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700350 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
351 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 return;
353 }
354
355 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700356 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 return;
358 }
359
360 bh_lock_sock(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200361 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700362 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364 if (sk->sk_state == TCP_CLOSE)
365 goto out;
366
Stephen Hemmingere802af92010-04-22 15:24:53 -0700367 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
368 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
369 goto out;
370 }
371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900373 seq = ntohl(th->seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 if (sk->sk_state != TCP_LISTEN &&
375 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700376 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 goto out;
378 }
379
380 np = inet6_sk(sk);
381
David S. Millerec18d9a2012-07-12 00:25:15 -0700382 if (type == NDISC_REDIRECT) {
383 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
384
David S. Miller1ed5c482012-07-12 00:41:25 -0700385 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700386 dst->ops->redirect(dst, sk, skb);
Christoph Paasch50a75a82013-04-07 04:53:15 +0000387 goto out;
David S. Millerec18d9a2012-07-12 00:25:15 -0700388 }
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 if (type == ICMPV6_PKT_TOOBIG) {
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000391 /* We are not interested in TCP_LISTEN and open_requests
392 * (SYN-ACKs send out by Linux are always <576bytes so
393 * they should go through unfragmented).
394 */
395 if (sk->sk_state == TCP_LISTEN)
396 goto out;
397
Hannes Frederic Sowa93b36cf2013-12-15 03:41:14 +0100398 if (!ip6_sk_accept_pmtu(sk))
399 goto out;
400
Eric Dumazet563d34d2012-07-23 09:48:52 +0200401 tp->mtu_info = ntohl(info);
402 if (!sock_owned_by_user(sk))
403 tcp_v6_mtu_reduced(sk);
Julian Anastasovd013ef2a2012-09-05 10:53:18 +0000404 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
405 &tp->tsq_flags))
406 sock_hold(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 goto out;
408 }
409
410 icmpv6_err_convert(type, code, &err);
411
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700412 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700414 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 case TCP_LISTEN:
416 if (sock_owned_by_user(sk))
417 goto out;
418
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800419 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
420 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 if (!req)
422 goto out;
423
424 /* ICMPs are not backlogged, hence we cannot get
425 * an established socket here.
426 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700427 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700429 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700430 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 goto out;
432 }
433
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700434 inet_csk_reqsk_queue_drop(sk, req, prev);
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000435 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 goto out;
437
438 case TCP_SYN_SENT:
439 case TCP_SYN_RECV: /* Cannot happen.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900440 It can, it SYNs are crossed. --ANK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 sk->sk_err = err;
443 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
444
445 tcp_done(sk);
446 } else
447 sk->sk_err_soft = err;
448 goto out;
449 }
450
451 if (!sock_owned_by_user(sk) && np->recverr) {
452 sk->sk_err = err;
453 sk->sk_error_report(sk);
454 } else
455 sk->sk_err_soft = err;
456
457out:
458 bh_unlock_sock(sk);
459 sock_put(sk);
460}
461
462
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000463static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
464 struct flowi6 *fl6,
Neal Cardwell3840a062012-06-28 12:34:19 +0000465 struct request_sock *req,
Eric Dumazetfff32692012-06-01 01:47:50 +0000466 u16 queue_mapping)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700468 struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 struct ipv6_pinfo *np = inet6_sk(sk);
Weilong Chen4c99aa42013-12-19 18:44:34 +0800470 struct sk_buff *skb;
Neal Cardwell94942182012-06-28 12:34:20 +0000471 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000473 /* First, grab a route. */
474 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800475 goto done;
Neal Cardwell94942182012-06-28 12:34:20 +0000476
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000477 skb = tcp_make_synack(sk, dst, req, NULL);
Neal Cardwell94942182012-06-28 12:34:20 +0000478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700480 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
481 &ireq->ir_v6_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Eric Dumazet634fb9792013-10-09 15:21:29 -0700483 fl6->daddr = ireq->ir_v6_rmt_addr;
Florent Fourcotdf3687f2014-01-17 17:15:03 +0100484 if (np->repflow && (ireq->pktopts != NULL))
485 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
486
Eric Dumazetfff32692012-06-01 01:47:50 +0000487 skb_set_queue_mapping(skb, queue_mapping);
RongQing.Li43264e02012-07-01 17:18:59 +0000488 err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200489 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 }
491
492done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 return err;
494}
495
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000496static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req)
Octavian Purdila72659ec2010-01-17 19:09:39 -0800497{
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000498 struct flowi6 fl6;
Eric Dumazete6c022a2012-10-27 23:16:46 +0000499 int res;
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000500
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000501 res = tcp_v6_send_synack(sk, NULL, &fl6, req, 0);
Yuchung Chengf19c29e2014-03-03 12:31:36 -0800502 if (!res) {
Eric Dumazete6c022a2012-10-27 23:16:46 +0000503 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
Yuchung Chengf19c29e2014-03-03 12:31:36 -0800504 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
505 }
Eric Dumazete6c022a2012-10-27 23:16:46 +0000506 return res;
Octavian Purdila72659ec2010-01-17 19:09:39 -0800507}
508
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700509static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700511 kfree_skb(inet_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512}
513
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800514#ifdef CONFIG_TCP_MD5SIG
515static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000516 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800517{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000518 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800519}
520
521static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
522 struct sock *addr_sk)
523{
Eric Dumazetefe42082013-10-03 15:42:29 -0700524 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800525}
526
527static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
528 struct request_sock *req)
529{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700530 return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800531}
532
Wang Yufen4aa956d2014-03-29 09:27:29 +0800533static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
534 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800535{
536 struct tcp_md5sig cmd;
537 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800538
539 if (optlen < sizeof(cmd))
540 return -EINVAL;
541
542 if (copy_from_user(&cmd, optval, sizeof(cmd)))
543 return -EFAULT;
544
545 if (sin6->sin6_family != AF_INET6)
546 return -EINVAL;
547
548 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700549 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000550 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
551 AF_INET);
552 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
553 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800554 }
555
556 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
557 return -EINVAL;
558
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000559 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
560 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
561 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800562
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000563 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
564 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800565}
566
Adam Langley49a72df2008-07-19 00:01:42 -0700567static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000568 const struct in6_addr *daddr,
569 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800570{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800571 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700572 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900573
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800574 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800575 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000576 bp->saddr = *saddr;
577 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700578 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700579 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800580
Adam Langley49a72df2008-07-19 00:01:42 -0700581 sg_init_one(&sg, bp, sizeof(*bp));
582 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
583}
David S. Millerc7da57a2007-10-26 00:41:21 -0700584
Adam Langley49a72df2008-07-19 00:01:42 -0700585static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000586 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400587 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700588{
589 struct tcp_md5sig_pool *hp;
590 struct hash_desc *desc;
591
592 hp = tcp_get_md5sig_pool();
593 if (!hp)
594 goto clear_hash_noput;
595 desc = &hp->md5_desc;
596
597 if (crypto_hash_init(desc))
598 goto clear_hash;
599 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
600 goto clear_hash;
601 if (tcp_md5_hash_header(hp, th))
602 goto clear_hash;
603 if (tcp_md5_hash_key(hp, key))
604 goto clear_hash;
605 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800606 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800607
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800608 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800609 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700610
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800611clear_hash:
612 tcp_put_md5sig_pool();
613clear_hash_noput:
614 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700615 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800616}
617
Adam Langley49a72df2008-07-19 00:01:42 -0700618static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400619 const struct sock *sk,
620 const struct request_sock *req,
621 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800622{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000623 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700624 struct tcp_md5sig_pool *hp;
625 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400626 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800627
628 if (sk) {
629 saddr = &inet6_sk(sk)->saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700630 daddr = &sk->sk_v6_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700631 } else if (req) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700632 saddr = &inet_rsk(req)->ir_v6_loc_addr;
633 daddr = &inet_rsk(req)->ir_v6_rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700634 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000635 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700636 saddr = &ip6h->saddr;
637 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800638 }
Adam Langley49a72df2008-07-19 00:01:42 -0700639
640 hp = tcp_get_md5sig_pool();
641 if (!hp)
642 goto clear_hash_noput;
643 desc = &hp->md5_desc;
644
645 if (crypto_hash_init(desc))
646 goto clear_hash;
647
648 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
649 goto clear_hash;
650 if (tcp_md5_hash_header(hp, th))
651 goto clear_hash;
652 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
653 goto clear_hash;
654 if (tcp_md5_hash_key(hp, key))
655 goto clear_hash;
656 if (crypto_hash_final(desc, md5_hash))
657 goto clear_hash;
658
659 tcp_put_md5sig_pool();
660 return 0;
661
662clear_hash:
663 tcp_put_md5sig_pool();
664clear_hash_noput:
665 memset(md5_hash, 0, 16);
666 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800667}
668
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400669static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800670{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400671 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800672 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000673 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400674 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800675 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800676 u8 newhash[16];
677
678 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900679 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800680
David S. Miller785957d2008-07-30 03:03:15 -0700681 /* We've parsed the options - do we have a hash? */
682 if (!hash_expected && !hash_location)
683 return 0;
684
685 if (hash_expected && !hash_location) {
686 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800687 return 1;
688 }
689
David S. Miller785957d2008-07-30 03:03:15 -0700690 if (!hash_expected && hash_location) {
691 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800692 return 1;
693 }
694
695 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700696 genhash = tcp_v6_md5_hash_skb(newhash,
697 hash_expected,
698 NULL, NULL, skb);
699
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800700 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +0000701 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
702 genhash ? "failed" : "mismatch",
703 &ip6h->saddr, ntohs(th->source),
704 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800705 return 1;
706 }
707 return 0;
708}
709#endif
710
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800711struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700713 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -0800714 .rtx_syn_ack = tcp_v6_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700715 .send_ack = tcp_v6_reqsk_send_ack,
716 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800717 .send_reset = tcp_v6_send_reset,
Wang Yufen4aa956d2014-03-29 09:27:29 +0800718 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719};
720
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800721#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000722static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800723 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000724 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800725};
Andrew Mortonb6332e62006-11-30 19:16:28 -0800726#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800727
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700728static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
Wang Yufen9c76a112014-03-29 09:27:31 +0800729 u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100730 struct tcp_md5sig_key *key, int rst, u8 tclass,
731 u32 label)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400733 const struct tcphdr *th = tcp_hdr(skb);
734 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500736 struct flowi6 fl6;
Eric Dumazetadf30902009-06-02 05:19:30 +0000737 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800738 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800739 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000740 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800741 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Andrey Vaginee684b62013-02-11 05:50:19 +0000743 if (tsecr)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700744 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800745#ifdef CONFIG_TCP_MD5SIG
746 if (key)
747 tot_len += TCPOLEN_MD5SIG_ALIGNED;
748#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
750 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
751 GFP_ATOMIC);
752 if (buff == NULL)
753 return;
754
755 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
756
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700757 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700758 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760 /* Swap the send and the receive. */
761 memset(t1, 0, sizeof(*t1));
762 t1->dest = th->source;
763 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700764 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 t1->seq = htonl(seq);
766 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700767 t1->ack = !rst || !th->ack;
768 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800770
Al Viroe69a4adc2006-11-14 20:56:00 -0800771 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900772
Andrey Vaginee684b62013-02-11 05:50:19 +0000773 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800774 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
775 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000776 *topt++ = htonl(tsval);
777 *topt++ = htonl(tsecr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 }
779
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800780#ifdef CONFIG_TCP_MD5SIG
781 if (key) {
782 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
783 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700784 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700785 &ipv6_hdr(skb)->saddr,
786 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800787 }
788#endif
789
David S. Miller4c9483b2011-03-12 16:22:43 -0500790 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000791 fl6.daddr = ipv6_hdr(skb)->saddr;
792 fl6.saddr = ipv6_hdr(skb)->daddr;
Florent Fourcot1d13a962014-01-16 17:21:22 +0100793 fl6.flowlabel = label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
David S. Millere5700af2010-04-21 14:59:20 -0700795 buff->ip_summed = CHECKSUM_PARTIAL;
796 buff->csum = 0;
797
David S. Miller4c9483b2011-03-12 16:22:43 -0500798 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
David S. Miller4c9483b2011-03-12 16:22:43 -0500800 fl6.flowi6_proto = IPPROTO_TCP;
Lorenzo Colittia36dbdb2014-04-11 13:19:12 +0900801 if (rt6_need_strict(&fl6.daddr) && !oif)
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000802 fl6.flowi6_oif = inet6_iif(skb);
Wang Yufen9c76a112014-03-29 09:27:31 +0800803 else
804 fl6.flowi6_oif = oif;
David S. Miller1958b852011-03-12 16:36:19 -0500805 fl6.fl6_dport = t1->dest;
806 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500807 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700809 /* Pass a socket to ip6_dst_lookup either it is for RST
810 * Underlying function will use this to retrieve the network
811 * namespace
812 */
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200813 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800814 if (!IS_ERR(dst)) {
815 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400816 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800817 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
818 if (rst)
819 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
820 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 }
822
823 kfree_skb(buff);
824}
825
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700826static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
827{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400828 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700829 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700830 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000831#ifdef CONFIG_TCP_MD5SIG
832 const __u8 *hash_location = NULL;
833 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
834 unsigned char newhash[16];
835 int genhash;
836 struct sock *sk1 = NULL;
837#endif
Wang Yufen9c76a112014-03-29 09:27:31 +0800838 int oif;
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700839
840 if (th->rst)
841 return;
842
843 if (!ipv6_unicast_destination(skb))
844 return;
845
846#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000847 hash_location = tcp_parse_md5sig_option(th);
848 if (!sk && hash_location) {
849 /*
850 * active side is lost. Try to find listening socket through
851 * source port, and then find md5 key through listening socket.
852 * we are not loose security here:
853 * Incoming packet is checked with md5 hash with finding key,
854 * no RST generated if md5 hash doesn't match.
855 */
856 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbert5ba24952013-01-22 09:50:39 +0000857 &tcp_hashinfo, &ipv6h->saddr,
858 th->source, &ipv6h->daddr,
Shawn Lu658ddaa2012-01-31 22:35:48 +0000859 ntohs(th->source), inet6_iif(skb));
860 if (!sk1)
861 return;
862
863 rcu_read_lock();
864 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
865 if (!key)
866 goto release_sk1;
867
868 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
869 if (genhash || memcmp(hash_location, newhash, 16) != 0)
870 goto release_sk1;
871 } else {
872 key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
873 }
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700874#endif
875
876 if (th->ack)
877 seq = ntohl(th->ack_seq);
878 else
879 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
880 (th->doff << 2);
881
Wang Yufen9c76a112014-03-29 09:27:31 +0800882 oif = sk ? sk->sk_bound_dev_if : 0;
883 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000884
885#ifdef CONFIG_TCP_MD5SIG
886release_sk1:
887 if (sk1) {
888 rcu_read_unlock();
889 sock_put(sk1);
890 }
891#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700892}
893
Andrey Vaginee684b62013-02-11 05:50:19 +0000894static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
Wang Yufen9c76a112014-03-29 09:27:31 +0800895 u32 win, u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100896 struct tcp_md5sig_key *key, u8 tclass,
897 u32 label)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700898{
Wang Yufen9c76a112014-03-29 09:27:31 +0800899 tcp_v6_send_response(skb, seq, ack, win, tsval, tsecr, oif, key, 0, tclass,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100900 label);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700901}
902
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
904{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700905 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800906 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900908 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700909 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000910 tcp_time_stamp + tcptw->tw_ts_offset,
Wang Yufen9c76a112014-03-29 09:27:31 +0800911 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
Florent Fourcot1d13a962014-01-16 17:21:22 +0100912 tw->tw_tclass, (tw->tw_flowlabel << 12));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700914 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915}
916
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700917static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
918 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
Andrey Vaginee684b62013-02-11 05:50:19 +0000920 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1,
Wang Yufen9c76a112014-03-29 09:27:31 +0800921 req->rcv_wnd, tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100922 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
923 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924}
925
926
Weilong Chen4c99aa42013-12-19 18:44:34 +0800927static struct sock *tcp_v6_hnd_req(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700929 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700930 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 struct sock *nsk;
932
933 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800934 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700935 &ipv6_hdr(skb)->saddr,
936 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 if (req)
Jerry Chu83368862012-08-31 12:29:12 +0000938 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900940 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800941 &ipv6_hdr(skb)->saddr, th->source,
942 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
944 if (nsk) {
945 if (nsk->sk_state != TCP_TIME_WAIT) {
946 bh_lock_sock(nsk);
947 return nsk;
948 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700949 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 return NULL;
951 }
952
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800953#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +0000954 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800955 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956#endif
957 return sk;
958}
959
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960/* FIXME: this is substantially similar to the ipv4 code.
961 * Can some kind of merge be done? -- erics
962 */
963static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
964{
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000965 struct tcp_options_received tmp_opt;
966 struct request_sock *req;
Eric Dumazet634fb9792013-10-09 15:21:29 -0700967 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 struct ipv6_pinfo *np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000970 __u32 isn = TCP_SKB_CB(skb)->when;
David S. Miller493f3772010-12-02 12:14:29 -0800971 struct dst_entry *dst = NULL;
Neal Cardwell3840a062012-06-28 12:34:19 +0000972 struct flowi6 fl6;
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000973 bool want_cookie = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974
975 if (skb->protocol == htons(ETH_P_IP))
976 return tcp_v4_conn_request(sk, skb);
977
978 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900979 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980
Hannes Frederic Sowa5ad37d52013-07-26 17:43:23 +0200981 if ((sysctl_tcp_syncookies == 2 ||
982 inet_csk_reqsk_queue_is_full(sk)) && !isn) {
Eric Dumazet946cedc2011-08-30 03:21:44 +0000983 want_cookie = tcp_syn_flood_action(sk, skb, "TCPv6");
984 if (!want_cookie)
985 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 }
987
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000988 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
989 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 goto drop;
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000991 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800993 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 if (req == NULL)
995 goto drop;
996
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800997#ifdef CONFIG_TCP_MD5SIG
998 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
999#endif
1000
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 tcp_clear_options(&tmp_opt);
1002 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1003 tmp_opt.user_mss = tp->rx_opt.user_mss;
Christoph Paasch1a2c6182013-03-17 08:23:34 +00001004 tcp_parse_options(skb, &tmp_opt, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
Florian Westphal4dfc2812008-04-10 03:12:40 -07001006 if (want_cookie && !tmp_opt.saw_tstamp)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001007 tcp_clear_options(&tmp_opt);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1010 tcp_openreq_init(req, &tmp_opt, skb);
1011
Eric Dumazet634fb9792013-10-09 15:21:29 -07001012 ireq = inet_rsk(req);
1013 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
1014 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
Florian Westphal172d69e2010-06-21 11:48:45 +00001015 if (!want_cookie || tmp_opt.tstamp_ok)
Hannes Frederic Sowa5d134f12013-01-05 16:10:48 +00001016 TCP_ECN_create_request(req, skb, sock_net(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017
Eric Dumazet634fb9792013-10-09 15:21:29 -07001018 ireq->ir_iif = sk->sk_bound_dev_if;
Eric Dumazet4d0fe502011-11-23 17:29:23 -05001019
1020 /* So that link locals have meaning */
1021 if (!sk->sk_bound_dev_if &&
Eric Dumazet634fb9792013-10-09 15:21:29 -07001022 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
1023 ireq->ir_iif = inet6_iif(skb);
Eric Dumazet4d0fe502011-11-23 17:29:23 -05001024
Florian Westphal2bbdf382010-06-13 11:29:39 +00001025 if (!isn) {
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001026 if (ipv6_opt_accepted(sk, skb) ||
1027 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001028 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim ||
1029 np->repflow) {
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001030 atomic_inc(&skb->users);
Eric Dumazet634fb9792013-10-09 15:21:29 -07001031 ireq->pktopts = skb;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001032 }
David S. Miller493f3772010-12-02 12:14:29 -08001033
1034 if (want_cookie) {
Florian Westphal2bbdf382010-06-13 11:29:39 +00001035 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1036 req->cookie_ts = tmp_opt.tstamp_ok;
David S. Miller493f3772010-12-02 12:14:29 -08001037 goto have_isn;
Florian Westphal2bbdf382010-06-13 11:29:39 +00001038 }
David S. Miller493f3772010-12-02 12:14:29 -08001039
1040 /* VJ's idea. We save last timestamp seen
1041 * from the destination in peer table, when entering
1042 * state TIME-WAIT, and check against it before
1043 * accepting new connection request.
1044 *
1045 * If "isn" is not zero, this request hit alive
1046 * timewait bucket, so that all the necessary checks
1047 * are made in the function processing timewait state.
1048 */
1049 if (tmp_opt.saw_tstamp &&
1050 tcp_death_row.sysctl_tw_recycle &&
David S. Miller81166dd2012-07-10 03:14:24 -07001051 (dst = inet6_csk_route_req(sk, &fl6, req)) != NULL) {
1052 if (!tcp_peer_is_proven(req, dst, true)) {
David S. Miller493f3772010-12-02 12:14:29 -08001053 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1054 goto drop_and_release;
1055 }
1056 }
1057 /* Kill the following clause, if you dislike this way. */
1058 else if (!sysctl_tcp_syncookies &&
1059 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1060 (sysctl_max_syn_backlog >> 2)) &&
David S. Miller81166dd2012-07-10 03:14:24 -07001061 !tcp_peer_is_proven(req, dst, false)) {
David S. Miller493f3772010-12-02 12:14:29 -08001062 /* Without syncookies last quarter of
1063 * backlog is filled with destinations,
1064 * proven to be alive.
1065 * It means that we continue to communicate
1066 * to destinations, already remembered
1067 * to the moment of synflood.
1068 */
1069 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
Eric Dumazet634fb9792013-10-09 15:21:29 -07001070 &ireq->ir_v6_rmt_addr, ntohs(tcp_hdr(skb)->source));
David S. Miller493f3772010-12-02 12:14:29 -08001071 goto drop_and_release;
1072 }
1073
1074 isn = tcp_v6_init_sequence(skb);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001075 }
David S. Miller493f3772010-12-02 12:14:29 -08001076have_isn:
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001077 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078
Neal Cardwell437c5b52012-06-23 19:22:00 +00001079 if (security_inet_conn_request(sk, skb, req))
1080 goto drop_and_release;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001081
Neal Cardwell9f10d3f2012-06-28 12:34:21 +00001082 if (tcp_v6_send_synack(sk, dst, &fl6, req,
Eric Dumazetfff32692012-06-01 01:47:50 +00001083 skb_get_queue_mapping(skb)) ||
William Allen Simpson4957faade2009-12-02 18:25:27 +00001084 want_cookie)
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001085 goto drop_and_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
Neal Cardwell016818d2012-09-22 04:18:55 +00001087 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Jerry Chu83368862012-08-31 12:29:12 +00001088 tcp_rsk(req)->listener = NULL;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001089 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1090 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
David S. Miller493f3772010-12-02 12:14:29 -08001092drop_and_release:
1093 dst_release(dst);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001094drop_and_free:
1095 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096drop:
Vijay Subramanian5f1e9422013-01-31 08:24:19 +00001097 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 return 0; /* don't send reset */
1099}
1100
Weilong Chen4c99aa42013-12-19 18:44:34 +08001101static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1102 struct request_sock *req,
1103 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104{
Eric Dumazet634fb9792013-10-09 15:21:29 -07001105 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1107 struct tcp6_sock *newtcp6sk;
1108 struct inet_sock *newinet;
1109 struct tcp_sock *newtp;
1110 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001111#ifdef CONFIG_TCP_MD5SIG
1112 struct tcp_md5sig_key *key;
1113#endif
Neal Cardwell3840a062012-06-28 12:34:19 +00001114 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116 if (skb->protocol == htons(ETH_P_IP)) {
1117 /*
1118 * v6 mapped
1119 */
1120
1121 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1122
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001123 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 return NULL;
1125
1126 newtcp6sk = (struct tcp6_sock *)newsk;
1127 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1128
1129 newinet = inet_sk(newsk);
1130 newnp = inet6_sk(newsk);
1131 newtp = tcp_sk(newsk);
1132
1133 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1134
Eric Dumazetefe42082013-10-03 15:42:29 -07001135 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001137 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Eric Dumazetefe42082013-10-03 15:42:29 -07001139 newsk->sk_v6_rcv_saddr = newnp->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001141 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001143#ifdef CONFIG_TCP_MD5SIG
1144 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1145#endif
1146
Yan, Zheng676a1182011-09-25 02:21:30 +00001147 newnp->ipv6_ac_list = NULL;
1148 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 newnp->pktoptions = NULL;
1150 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001151 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001152 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001153 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001154 if (np->repflow)
1155 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001157 /*
1158 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1159 * here, tcp_create_openreq_child now does this for us, see the comment in
1160 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
1163 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001164 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 Sync it now.
1166 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001167 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
1169 return newsk;
1170 }
1171
Eric Dumazet634fb9792013-10-09 15:21:29 -07001172 ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
1174 if (sk_acceptq_is_full(sk))
1175 goto out_overflow;
1176
David S. Miller493f3772010-12-02 12:14:29 -08001177 if (!dst) {
Neal Cardwell3840a062012-06-28 12:34:19 +00001178 dst = inet6_csk_route_req(sk, &fl6, req);
David S. Miller493f3772010-12-02 12:14:29 -08001179 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001181 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
1183 newsk = tcp_create_openreq_child(sk, req, skb);
1184 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001185 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001187 /*
1188 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1189 * count here, tcp_create_openreq_child now does this for us, see the
1190 * comment in that function for the gory details. -acme
1191 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
Stephen Hemminger59eed272006-08-25 15:55:43 -07001193 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001194 __ip6_dst_store(newsk, dst, NULL, NULL);
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001195 inet6_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
1197 newtcp6sk = (struct tcp6_sock *)newsk;
1198 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1199
1200 newtp = tcp_sk(newsk);
1201 newinet = inet_sk(newsk);
1202 newnp = inet6_sk(newsk);
1203
1204 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1205
Eric Dumazet634fb9792013-10-09 15:21:29 -07001206 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1207 newnp->saddr = ireq->ir_v6_loc_addr;
1208 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1209 newsk->sk_bound_dev_if = ireq->ir_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001211 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
1213 First: no IPv4 options.
1214 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001215 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001216 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001217 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
1219 /* Clone RX bits */
1220 newnp->rxopt.all = np->rxopt.all;
1221
1222 /* Clone pktoptions received with SYN */
1223 newnp->pktoptions = NULL;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001224 if (ireq->pktopts != NULL) {
1225 newnp->pktoptions = skb_clone(ireq->pktopts,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001226 sk_gfp_atomic(sk, GFP_ATOMIC));
Eric Dumazet634fb9792013-10-09 15:21:29 -07001227 consume_skb(ireq->pktopts);
1228 ireq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 if (newnp->pktoptions)
1230 skb_set_owner_r(newnp->pktoptions, newsk);
1231 }
1232 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001233 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001234 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001235 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001236 if (np->repflow)
1237 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
1239 /* Clone native IPv6 options from listening socket (if any)
1240
1241 Yes, keeping reference count would be much more clever,
1242 but we make one more one thing there: reattach optmem
1243 to newsk.
1244 */
RongQing.Li43264e02012-07-01 17:18:59 +00001245 if (np->opt)
1246 newnp->opt = ipv6_dup_options(newsk, np->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001248 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001250 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1251 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252
1253 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001254 newtp->advmss = dst_metric_advmss(dst);
Neal Cardwelld135c522012-04-22 09:45:47 +00001255 if (tcp_sk(sk)->rx_opt.user_mss &&
1256 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1257 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1258
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 tcp_initialize_rcv_mss(newsk);
1260
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001261 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1262 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001264#ifdef CONFIG_TCP_MD5SIG
1265 /* Copy over the MD5 key from the original socket */
Wang Yufen4aa956d2014-03-29 09:27:29 +08001266 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
1267 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001268 /* We're using one, so create a matching key
1269 * on the newsk structure. If we fail to get
1270 * memory, then we end up not copying the key
1271 * across. Shucks.
1272 */
Eric Dumazetefe42082013-10-03 15:42:29 -07001273 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001274 AF_INET6, key->key, key->keylen,
1275 sk_gfp_atomic(sk, GFP_ATOMIC));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001276 }
1277#endif
1278
Balazs Scheidler093d2822010-10-21 13:06:43 +02001279 if (__inet_inherit_port(sk, newsk) < 0) {
Christoph Paasche337e242012-12-14 04:07:58 +00001280 inet_csk_prepare_forced_close(newsk);
1281 tcp_done(newsk);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001282 goto out;
1283 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001284 __inet6_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
1286 return newsk;
1287
1288out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001289 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001290out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001292out:
1293 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 return NULL;
1295}
1296
Al Virob51655b2006-11-14 21:40:42 -08001297static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001299 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Herbert Xu684f2172009-01-08 10:41:23 -08001300 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001301 &ipv6_hdr(skb)->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001302 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001304 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001306
Herbert Xu684f2172009-01-08 10:41:23 -08001307 skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001308 &ipv6_hdr(skb)->saddr,
1309 &ipv6_hdr(skb)->daddr, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -08001310
Wang Yufen4aa956d2014-03-29 09:27:29 +08001311 if (skb->len <= 76)
Herbert Xufb286bb2005-11-10 13:01:24 -08001312 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 return 0;
1314}
1315
1316/* The socket must have it's spinlock held when we get
1317 * here.
1318 *
1319 * We have a potential double-lock case here, so even when
1320 * doing backlog processing we use the BH locking scheme.
1321 * This is because we cannot sleep with the original spinlock
1322 * held.
1323 */
1324static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1325{
1326 struct ipv6_pinfo *np = inet6_sk(sk);
1327 struct tcp_sock *tp;
1328 struct sk_buff *opt_skb = NULL;
1329
1330 /* Imagine: socket is IPv6. IPv4 packet arrives,
1331 goes to IPv4 receive handler and backlogged.
1332 From backlog it always goes here. Kerboom...
1333 Fortunately, tcp_rcv_established and rcv_established
1334 handle them correctly, but it is not case with
1335 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1336 */
1337
1338 if (skb->protocol == htons(ETH_P_IP))
1339 return tcp_v4_do_rcv(sk, skb);
1340
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001341#ifdef CONFIG_TCP_MD5SIG
Wang Yufen4aa956d2014-03-29 09:27:29 +08001342 if (tcp_v6_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001343 goto discard;
1344#endif
1345
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001346 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 goto discard;
1348
1349 /*
1350 * socket locking is here for SMP purposes as backlog rcv
1351 * is currently called with bh processing disabled.
1352 */
1353
1354 /* Do Stevens' IPV6_PKTOPTIONS.
1355
1356 Yes, guys, it is the only place in our code, where we
1357 may make it not affecting IPv4.
1358 The rest of code is protocol independent,
1359 and I do not like idea to uglify IPv4.
1360
1361 Actually, all the idea behind IPV6_PKTOPTIONS
1362 looks not very well thought. For now we latch
1363 options, received in the last packet, enqueued
1364 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001365 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 */
1367 if (np->rxopt.all)
Mel Gorman99a1dec2012-07-31 16:44:14 -07001368 opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
1370 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet5d299f32012-08-06 05:09:33 +00001371 struct dst_entry *dst = sk->sk_rx_dst;
1372
Tom Herbertbdeab992011-08-14 19:45:55 +00001373 sock_rps_save_rxhash(sk, skb);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001374 if (dst) {
1375 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1376 dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1377 dst_release(dst);
1378 sk->sk_rx_dst = NULL;
1379 }
1380 }
1381
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001382 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 if (opt_skb)
1384 goto ipv6_pktoptions;
1385 return 0;
1386 }
1387
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001388 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 goto csum_err;
1390
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001391 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1393 if (!nsk)
1394 goto discard;
1395
1396 /*
1397 * Queue it on the new socket if the new socket is active,
1398 * otherwise we just shortcircuit this and continue with
1399 * the new socket..
1400 */
Weilong Chen4c99aa42013-12-19 18:44:34 +08001401 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001402 sock_rps_save_rxhash(nsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 if (tcp_child_process(sk, nsk, skb))
1404 goto reset;
1405 if (opt_skb)
1406 __kfree_skb(opt_skb);
1407 return 0;
1408 }
Neil Horman47482f12011-04-06 13:07:09 -07001409 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001410 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001412 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 if (opt_skb)
1415 goto ipv6_pktoptions;
1416 return 0;
1417
1418reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001419 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420discard:
1421 if (opt_skb)
1422 __kfree_skb(opt_skb);
1423 kfree_skb(skb);
1424 return 0;
1425csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001426 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001427 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 goto discard;
1429
1430
1431ipv6_pktoptions:
1432 /* Do you ask, what is it?
1433
1434 1. skb was enqueued by tcp.
1435 2. skb is added to tail of read queue, rather than out of order.
1436 3. socket is not in passive state.
1437 4. Finally, it really contains options, which user wants to receive.
1438 */
1439 tp = tcp_sk(sk);
1440 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1441 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001442 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001443 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001444 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001445 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Florent Fourcot82e9f102013-12-08 15:46:59 +01001446 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
Florent Fourcot1397ed32013-12-08 15:46:57 +01001447 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001448 if (np->repflow)
1449 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 if (ipv6_opt_accepted(sk, opt_skb)) {
1451 skb_set_owner_r(opt_skb, sk);
1452 opt_skb = xchg(&np->pktoptions, opt_skb);
1453 } else {
1454 __kfree_skb(opt_skb);
1455 opt_skb = xchg(&np->pktoptions, NULL);
1456 }
1457 }
1458
Wei Yongjun800d55f2009-02-23 21:45:33 +00001459 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 return 0;
1461}
1462
Herbert Xue5bbef22007-10-15 12:50:28 -07001463static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001465 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001466 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 struct sock *sk;
1468 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001469 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
1471 if (skb->pkt_type != PACKET_HOST)
1472 goto discard_it;
1473
1474 /*
1475 * Count it even if it's bad.
1476 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001477 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478
1479 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1480 goto discard_it;
1481
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001482 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
1484 if (th->doff < sizeof(struct tcphdr)/4)
1485 goto bad_packet;
1486 if (!pskb_may_pull(skb, th->doff*4))
1487 goto discard_it;
1488
Herbert Xu60476372007-04-09 11:59:39 -07001489 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001490 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001492 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001493 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1495 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1496 skb->len - th->doff*4);
1497 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1498 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001499 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 TCP_SKB_CB(skb)->sacked = 0;
1501
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001502 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 if (!sk)
1504 goto no_tcp_socket;
1505
1506process:
1507 if (sk->sk_state == TCP_TIME_WAIT)
1508 goto do_time_wait;
1509
Stephen Hemmingere802af92010-04-22 15:24:53 -07001510 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1511 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1512 goto discard_and_relse;
1513 }
1514
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1516 goto discard_and_relse;
1517
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001518 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 goto discard_and_relse;
1520
Eliezer Tamir8b80cda2013-07-10 17:13:26 +03001521 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 skb->dev = NULL;
1523
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001524 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 ret = 0;
1526 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001527#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001528 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001529 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dave Jianga2bd1142012-04-04 16:10:46 -07001530 tp->ucopy.dma_chan = net_dma_find_channel();
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001531 if (tp->ucopy.dma_chan)
1532 ret = tcp_v6_do_rcv(sk, skb);
1533 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001534#endif
1535 {
1536 if (!tcp_prequeue(sk, skb))
1537 ret = tcp_v6_do_rcv(sk, skb);
1538 }
Eric Dumazetda882c12012-04-22 23:38:54 +00001539 } else if (unlikely(sk_add_backlog(sk, skb,
1540 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001541 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001542 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001543 goto discard_and_relse;
1544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 bh_unlock_sock(sk);
1546
1547 sock_put(sk);
1548 return ret ? -1 : 0;
1549
1550no_tcp_socket:
1551 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1552 goto discard_it;
1553
1554 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001555csum_error:
1556 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001558 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001560 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 }
1562
1563discard_it:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 kfree_skb(skb);
1565 return 0;
1566
1567discard_and_relse:
1568 sock_put(sk);
1569 goto discard_it;
1570
1571do_time_wait:
1572 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001573 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 goto discard_it;
1575 }
1576
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001577 if (skb->len < (th->doff<<2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001578 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001579 goto bad_packet;
1580 }
1581 if (tcp_checksum_complete(skb)) {
1582 inet_twsk_put(inet_twsk(sk));
1583 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 }
1585
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001586 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 case TCP_TW_SYN:
1588 {
1589 struct sock *sk2;
1590
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001591 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Tom Herbert5ba24952013-01-22 09:50:39 +00001592 &ipv6_hdr(skb)->saddr, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001593 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001594 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001596 struct inet_timewait_sock *tw = inet_twsk(sk);
1597 inet_twsk_deschedule(tw, &tcp_death_row);
1598 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 sk = sk2;
1600 goto process;
1601 }
1602 /* Fall through to ACK */
1603 }
1604 case TCP_TW_ACK:
1605 tcp_v6_timewait_ack(sk, skb);
1606 break;
1607 case TCP_TW_RST:
1608 goto no_tcp_socket;
Wang Yufen4aa956d2014-03-29 09:27:29 +08001609 case TCP_TW_SUCCESS:
1610 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 }
1612 goto discard_it;
1613}
1614
Eric Dumazetc7109982012-07-26 12:18:11 +00001615static void tcp_v6_early_demux(struct sk_buff *skb)
1616{
1617 const struct ipv6hdr *hdr;
1618 const struct tcphdr *th;
1619 struct sock *sk;
1620
1621 if (skb->pkt_type != PACKET_HOST)
1622 return;
1623
1624 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1625 return;
1626
1627 hdr = ipv6_hdr(skb);
1628 th = tcp_hdr(skb);
1629
1630 if (th->doff < sizeof(struct tcphdr) / 4)
1631 return;
1632
1633 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1634 &hdr->saddr, th->source,
1635 &hdr->daddr, ntohs(th->dest),
1636 inet6_iif(skb));
1637 if (sk) {
1638 skb->sk = sk;
1639 skb->destructor = sock_edemux;
1640 if (sk->sk_state != TCP_TIME_WAIT) {
1641 struct dst_entry *dst = sk->sk_rx_dst;
Neal Cardwellf3f12132012-10-22 21:41:48 +00001642
Eric Dumazetc7109982012-07-26 12:18:11 +00001643 if (dst)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001644 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
Eric Dumazetc7109982012-07-26 12:18:11 +00001645 if (dst &&
Neal Cardwellf3f12132012-10-22 21:41:48 +00001646 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
Eric Dumazetc7109982012-07-26 12:18:11 +00001647 skb_dst_set_noref(skb, dst);
1648 }
1649 }
1650}
1651
David S. Millerccb7c412010-12-01 18:09:13 -08001652static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1653 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1654 .twsk_unique = tcp_twsk_unique,
Wang Yufen4aa956d2014-03-29 09:27:29 +08001655 .twsk_destructor = tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001656};
1657
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001658static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001659 .queue_xmit = inet6_csk_xmit,
1660 .send_check = tcp_v6_send_check,
1661 .rebuild_header = inet6_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001662 .sk_rx_dst_set = inet6_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001663 .conn_request = tcp_v6_conn_request,
1664 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001665 .net_header_len = sizeof(struct ipv6hdr),
Eric Dumazet67469602012-04-24 07:37:38 +00001666 .net_frag_header_len = sizeof(struct frag_hdr),
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001667 .setsockopt = ipv6_setsockopt,
1668 .getsockopt = ipv6_getsockopt,
1669 .addr2sockaddr = inet6_csk_addr2sockaddr,
1670 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001671 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001672#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001673 .compat_setsockopt = compat_ipv6_setsockopt,
1674 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001675#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676};
1677
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001678#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001679static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001680 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001681 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001682 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001683};
David S. Millera9286302006-11-14 19:53:22 -08001684#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001685
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686/*
1687 * TCP over IPv4 via INET6 API
1688 */
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001689static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001690 .queue_xmit = ip_queue_xmit,
1691 .send_check = tcp_v4_send_check,
1692 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet63d02d12012-08-09 14:11:00 +00001693 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001694 .conn_request = tcp_v6_conn_request,
1695 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001696 .net_header_len = sizeof(struct iphdr),
1697 .setsockopt = ipv6_setsockopt,
1698 .getsockopt = ipv6_getsockopt,
1699 .addr2sockaddr = inet6_csk_addr2sockaddr,
1700 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001701 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001702#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001703 .compat_setsockopt = compat_ipv6_setsockopt,
1704 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001705#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706};
1707
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001708#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001709static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001710 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001711 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001712 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001713};
David S. Millera9286302006-11-14 19:53:22 -08001714#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001715
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716/* NOTE: A lot of things set to zero explicitly by call to
1717 * sk_alloc() so need not be done here.
1718 */
1719static int tcp_v6_init_sock(struct sock *sk)
1720{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001721 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722
Neal Cardwell900f65d2012-04-19 09:55:21 +00001723 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001725 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001727#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001728 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001729#endif
1730
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 return 0;
1732}
1733
Brian Haley7d06b2e2008-06-14 17:04:49 -07001734static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001737 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738}
1739
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001740#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001742static void get_openreq6(struct seq_file *seq,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001743 const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 int ttd = req->expires - jiffies;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001746 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1747 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748
1749 if (ttd < 0)
1750 ttd = 0;
1751
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 seq_printf(seq,
1753 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001754 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 i,
1756 src->s6_addr32[0], src->s6_addr32[1],
1757 src->s6_addr32[2], src->s6_addr32[3],
Eric Dumazetb44084c2013-10-10 00:04:37 -07001758 inet_rsk(req)->ir_num,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 dest->s6_addr32[0], dest->s6_addr32[1],
1760 dest->s6_addr32[2], dest->s6_addr32[3],
Eric Dumazet634fb9792013-10-09 15:21:29 -07001761 ntohs(inet_rsk(req)->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 TCP_SYN_RECV,
Weilong Chen4c99aa42013-12-19 18:44:34 +08001763 0, 0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001764 1, /* timers active (only the expire timer) */
1765 jiffies_to_clock_t(ttd),
Eric Dumazete6c022a2012-10-27 23:16:46 +00001766 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001767 from_kuid_munged(seq_user_ns(seq), uid),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001768 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 0, /* open_requests have no inode */
1770 0, req);
1771}
1772
1773static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1774{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001775 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 __u16 destp, srcp;
1777 int timer_active;
1778 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001779 const struct inet_sock *inet = inet_sk(sp);
1780 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001781 const struct inet_connection_sock *icsk = inet_csk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
Eric Dumazetefe42082013-10-03 15:42:29 -07001783 dest = &sp->sk_v6_daddr;
1784 src = &sp->sk_v6_rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001785 destp = ntohs(inet->inet_dport);
1786 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001787
1788 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001790 timer_expires = icsk->icsk_timeout;
1791 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001793 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 } else if (timer_pending(&sp->sk_timer)) {
1795 timer_active = 2;
1796 timer_expires = sp->sk_timer.expires;
1797 } else {
1798 timer_active = 0;
1799 timer_expires = jiffies;
1800 }
1801
1802 seq_printf(seq,
1803 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001804 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 i,
1806 src->s6_addr32[0], src->s6_addr32[1],
1807 src->s6_addr32[2], src->s6_addr32[3], srcp,
1808 dest->s6_addr32[0], dest->s6_addr32[1],
1809 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001810 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001811 tp->write_seq-tp->snd_una,
1812 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00001814 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001815 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001816 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001817 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 sock_i_ino(sp),
1819 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001820 jiffies_to_clock_t(icsk->icsk_rto),
1821 jiffies_to_clock_t(icsk->icsk_ack.ato),
Weilong Chen4c99aa42013-12-19 18:44:34 +08001822 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001823 tp->snd_cwnd,
1824 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 );
1826}
1827
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001828static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001829 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001831 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 __u16 destp, srcp;
Eric Dumazet96f817f2013-10-03 14:27:25 -07001833 s32 delta = tw->tw_ttd - inet_tw_time_stamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
Eric Dumazetefe42082013-10-03 15:42:29 -07001835 dest = &tw->tw_v6_daddr;
1836 src = &tw->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 destp = ntohs(tw->tw_dport);
1838 srcp = ntohs(tw->tw_sport);
1839
1840 seq_printf(seq,
1841 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001842 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 i,
1844 src->s6_addr32[0], src->s6_addr32[1],
1845 src->s6_addr32[2], src->s6_addr32[3], srcp,
1846 dest->s6_addr32[0], dest->s6_addr32[1],
1847 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1848 tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00001849 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 atomic_read(&tw->tw_refcnt), tw);
1851}
1852
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853static int tcp6_seq_show(struct seq_file *seq, void *v)
1854{
1855 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001856 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857
1858 if (v == SEQ_START_TOKEN) {
1859 seq_puts(seq,
1860 " sl "
1861 "local_address "
1862 "remote_address "
1863 "st tx_queue rx_queue tr tm->when retrnsmt"
1864 " uid timeout inode\n");
1865 goto out;
1866 }
1867 st = seq->private;
1868
1869 switch (st->state) {
1870 case TCP_SEQ_STATE_LISTENING:
1871 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001872 if (sk->sk_state == TCP_TIME_WAIT)
1873 get_timewait6_sock(seq, v, st->num);
1874 else
1875 get_tcp6_sock(seq, v, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 break;
1877 case TCP_SEQ_STATE_OPENREQ:
1878 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1879 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 }
1881out:
1882 return 0;
1883}
1884
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001885static const struct file_operations tcp6_afinfo_seq_fops = {
1886 .owner = THIS_MODULE,
1887 .open = tcp_seq_open,
1888 .read = seq_read,
1889 .llseek = seq_lseek,
1890 .release = seq_release_net
1891};
1892
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 .name = "tcp6",
1895 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001896 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07001897 .seq_ops = {
1898 .show = tcp6_seq_show,
1899 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900};
1901
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001902int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001904 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905}
1906
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001907void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001909 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910}
1911#endif
1912
Eric Dumazetf77d6022013-05-09 10:28:16 +00001913static void tcp_v6_clear_sk(struct sock *sk, int size)
1914{
1915 struct inet_sock *inet = inet_sk(sk);
1916
1917 /* we do not want to clear pinet6 field, because of RCU lookups */
1918 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1919
1920 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1921 memset(&inet->pinet6 + 1, 0, size);
1922}
1923
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924struct proto tcpv6_prot = {
1925 .name = "TCPv6",
1926 .owner = THIS_MODULE,
1927 .close = tcp_close,
1928 .connect = tcp_v6_connect,
1929 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001930 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 .ioctl = tcp_ioctl,
1932 .init = tcp_v6_init_sock,
1933 .destroy = tcp_v6_destroy_sock,
1934 .shutdown = tcp_shutdown,
1935 .setsockopt = tcp_setsockopt,
1936 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00001938 .sendmsg = tcp_sendmsg,
1939 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 .backlog_rcv = tcp_v6_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00001941 .release_cb = tcp_release_cb,
Eric Dumazet563d34d2012-07-23 09:48:52 +02001942 .mtu_reduced = tcp_v6_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001944 .unhash = inet_unhash,
1945 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07001947 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 .sockets_allocated = &tcp_sockets_allocated,
1949 .memory_allocated = &tcp_memory_allocated,
1950 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001951 .orphan_count = &tcp_orphan_count,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07001952 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 .sysctl_wmem = sysctl_tcp_wmem,
1954 .sysctl_rmem = sysctl_tcp_rmem,
1955 .max_header = MAX_TCP_HEADER,
1956 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001957 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001958 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001959 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07001960 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00001961 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001962#ifdef CONFIG_COMPAT
1963 .compat_setsockopt = compat_tcp_setsockopt,
1964 .compat_getsockopt = compat_tcp_getsockopt,
1965#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07001966#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001967 .proto_cgroup = tcp_proto_cgroup,
1968#endif
Eric Dumazetf77d6022013-05-09 10:28:16 +00001969 .clear_sk = tcp_v6_clear_sk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970};
1971
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00001972static const struct inet6_protocol tcpv6_protocol = {
Eric Dumazetc7109982012-07-26 12:18:11 +00001973 .early_demux = tcp_v6_early_demux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 .handler = tcp_v6_rcv,
1975 .err_handler = tcp_v6_err,
1976 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1977};
1978
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979static struct inet_protosw tcpv6_protosw = {
1980 .type = SOCK_STREAM,
1981 .protocol = IPPROTO_TCP,
1982 .prot = &tcpv6_prot,
1983 .ops = &inet6_stream_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 .no_check = 0,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001985 .flags = INET_PROTOSW_PERMANENT |
1986 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987};
1988
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001989static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001990{
Denis V. Lunev56772422008-04-03 14:28:30 -07001991 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1992 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001993}
1994
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001995static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001996{
Denis V. Lunev56772422008-04-03 14:28:30 -07001997 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001998}
1999
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002000static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002001{
2002 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002003}
2004
2005static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002006 .init = tcpv6_net_init,
2007 .exit = tcpv6_net_exit,
2008 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002009};
2010
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002011int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002013 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08002014
Vlad Yasevich33362882012-11-15 08:49:15 +00002015 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2016 if (ret)
Vlad Yasevichc6b641a2012-11-15 08:49:22 +00002017 goto out;
Vlad Yasevich33362882012-11-15 08:49:15 +00002018
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002019 /* register inet6 protocol */
2020 ret = inet6_register_protosw(&tcpv6_protosw);
2021 if (ret)
2022 goto out_tcpv6_protocol;
2023
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002024 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002025 if (ret)
2026 goto out_tcpv6_protosw;
2027out:
2028 return ret;
2029
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002030out_tcpv6_protosw:
2031 inet6_unregister_protosw(&tcpv6_protosw);
Vlad Yasevich33362882012-11-15 08:49:15 +00002032out_tcpv6_protocol:
2033 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002034 goto out;
2035}
2036
Daniel Lezcano09f77092007-12-13 05:34:58 -08002037void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002038{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002039 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002040 inet6_unregister_protosw(&tcpv6_protosw);
2041 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042}