blob: 36131d122a6f3f9007776ff343a9197bd0430b0a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * TCP over IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09008 * Based on:
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * linux/net/ipv4/tcp.c
10 * linux/net/ipv4/tcp_input.c
11 * linux/net/ipv4/tcp_output.c
12 *
13 * Fixes:
14 * Hideaki YOSHIFUJI : sin6_scope_id support
15 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
16 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
17 * a single port at the same time.
18 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
Herbert Xueb4dea52008-12-29 23:04:08 -080026#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/socket.h>
31#include <linux/sockios.h>
32#include <linux/net.h>
33#include <linux/jiffies.h>
34#include <linux/in.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/init.h>
38#include <linux/jhash.h>
39#include <linux/ipsec.h>
40#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090041#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
Arnaldo Carvalho de Melo5324a042005-08-12 09:26:18 -030049#include <net/inet6_hashtables.h>
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -080050#include <net/inet6_connection_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <net/ipv6.h>
52#include <net/transp_v6.h>
53#include <net/addrconf.h>
54#include <net/ip6_route.h>
55#include <net/ip6_checksum.h>
56#include <net/inet_ecn.h>
57#include <net/protocol.h>
58#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <net/snmp.h>
60#include <net/dsfield.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080061#include <net/timewait_sock.h>
Jeff Garzik18134be2007-10-26 22:53:14 -070062#include <net/netdma.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070063#include <net/inet_common.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070064#include <net/secure_seq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66#include <asm/uaccess.h>
67
68#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);
Herbert Xu8ad50d92010-04-11 02:15:54 +000079static void __tcp_v6_send_check(struct sk_buff *skb,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000080 const struct in6_addr *saddr,
81 const struct in6_addr *daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Stephen Hemminger3b401a82009-09-01 19:25:04 +000083static const struct inet_connection_sock_af_ops ipv6_mapped;
84static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080085#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000086static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
87static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090088#else
89static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000090 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090091{
92 return NULL;
93}
David S. Millera9286302006-11-14 19:53:22 -080094#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Linus Torvalds1da177e2005-04-16 15:20:36 -070096static void tcp_v6_hash(struct sock *sk)
97{
98 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -080099 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 tcp_prot.hash(sk);
101 return;
102 }
103 local_bh_disable();
Eric Dumazet9327f702009-12-04 03:46:54 +0000104 __inet6_hash(sk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 local_bh_enable();
106 }
107}
108
Herbert Xu684f2172009-01-08 10:41:23 -0800109static __inline__ __sum16 tcp_v6_check(int len,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000110 const struct in6_addr *saddr,
111 const struct in6_addr *daddr,
Al Viro868c86b2006-11-14 21:35:48 -0800112 __wsum base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
114 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
115}
116
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400117static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700119 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
120 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700121 tcp_hdr(skb)->dest,
122 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
124
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900125static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 int addr_len)
127{
128 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900129 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800130 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 struct ipv6_pinfo *np = inet6_sk(sk);
132 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000133 struct in6_addr *saddr = NULL, *final_p, final;
David S. Miller493f3772010-12-02 12:14:29 -0800134 struct rt6_info *rt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500135 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 struct dst_entry *dst;
137 int addr_type;
138 int err;
139
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900140 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 return -EINVAL;
142
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900143 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000144 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
David S. Miller4c9483b2011-03-12 16:22:43 -0500146 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500149 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
150 IP6_ECN_flow_init(fl6.flowlabel);
151 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 struct ip6_flowlabel *flowlabel;
David S. Miller4c9483b2011-03-12 16:22:43 -0500153 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 if (flowlabel == NULL)
155 return -EINVAL;
156 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
157 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
165 if(ipv6_addr_any(&usin->sin6_addr))
166 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
170 if(addr_type & IPV6_ADDR_MULTICAST)
171 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 &&
192 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
193 tp->rx_opt.ts_recent = 0;
194 tp->rx_opt.ts_recent_stamp = 0;
195 tp->write_seq = 0;
196 }
197
198 ipv6_addr_copy(&np->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,
237 &np->rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
239
240 return err;
241 }
242
243 if (!ipv6_addr_any(&np->rcv_saddr))
244 saddr = &np->rcv_saddr;
245
David S. Miller4c9483b2011-03-12 16:22:43 -0500246 fl6.flowi6_proto = IPPROTO_TCP;
247 ipv6_addr_copy(&fl6.daddr, &np->daddr);
248 ipv6_addr_copy(&fl6.saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 (saddr ? saddr : &np->saddr));
David S. Miller4c9483b2011-03-12 16:22:43 -0500250 fl6.flowi6_oif = sk->sk_bound_dev_if;
251 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500252 fl6.fl6_dport = usin->sin6_port;
253 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
David S. Miller4c9483b2011-03-12 16:22:43 -0500255 final_p = fl6_update_dst(&fl6, np->opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
David S. Miller4c9483b2011-03-12 16:22:43 -0500257 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700258
David S. Miller4c9483b2011-03-12 16:22:43 -0500259 dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800260 if (IS_ERR(dst)) {
261 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 goto failure;
David S. Miller14e50e52007-05-24 18:17:54 -0700263 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
265 if (saddr == NULL) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500266 saddr = &fl6.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 ipv6_addr_copy(&np->rcv_saddr, saddr);
268 }
269
270 /* set the source address */
271 ipv6_addr_copy(&np->saddr, saddr);
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000272 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700274 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700275 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
David S. Miller493f3772010-12-02 12:14:29 -0800277 rt = (struct rt6_info *) dst;
278 if (tcp_death_row.sysctl_tw_recycle &&
279 !tp->rx_opt.ts_recent_stamp &&
280 ipv6_addr_equal(&rt->rt6i_dst.addr, &np->daddr)) {
281 struct inet_peer *peer = rt6_get_peer(rt);
282 /*
283 * VJ's idea. We save last timestamp seen from
284 * the destination in peer table, when entering state
285 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
286 * when trying new connection.
287 */
288 if (peer) {
289 inet_peer_refcheck(peer);
290 if ((u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) {
291 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
292 tp->rx_opt.ts_recent = peer->tcp_ts;
293 }
294 }
295 }
296
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800297 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800299 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
300 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
303
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000304 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800307 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 if (err)
309 goto late_failure;
310
311 if (!tp->write_seq)
312 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
313 np->daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000314 inet->inet_sport,
315 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 err = tcp_connect(sk);
318 if (err)
319 goto late_failure;
320
321 return 0;
322
323late_failure:
324 tcp_set_state(sk, TCP_CLOSE);
325 __sk_dst_reset(sk);
326failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000327 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 sk->sk_route_caps = 0;
329 return err;
330}
331
332static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700333 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000335 const struct ipv6hdr *hdr = (const struct ipv6hdr*)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300336 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 struct ipv6_pinfo *np;
338 struct sock *sk;
339 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900340 struct tcp_sock *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 __u32 seq;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700342 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700344 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800345 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700348 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
349 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 return;
351 }
352
353 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700354 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return;
356 }
357
358 bh_lock_sock(sk);
359 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700360 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362 if (sk->sk_state == TCP_CLOSE)
363 goto out;
364
Stephen Hemmingere802af92010-04-22 15:24:53 -0700365 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
366 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
367 goto out;
368 }
369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900371 seq = ntohl(th->seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 if (sk->sk_state != TCP_LISTEN &&
373 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700374 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 goto out;
376 }
377
378 np = inet6_sk(sk);
379
380 if (type == ICMPV6_PKT_TOOBIG) {
David S. Miller68d0c6d2011-03-01 13:19:07 -0800381 struct dst_entry *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383 if (sock_owned_by_user(sk))
384 goto out;
385 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
386 goto out;
387
388 /* icmp should have updated the destination cache entry */
389 dst = __sk_dst_check(sk, np->dst_cookie);
390
391 if (dst == NULL) {
392 struct inet_sock *inet = inet_sk(sk);
David S. Miller4c9483b2011-03-12 16:22:43 -0500393 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 /* BUGGG_FUTURE: Again, it is not clear how
396 to handle rthdr case. Ignore this complexity
397 for now.
398 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500399 memset(&fl6, 0, sizeof(fl6));
400 fl6.flowi6_proto = IPPROTO_TCP;
401 ipv6_addr_copy(&fl6.daddr, &np->daddr);
402 ipv6_addr_copy(&fl6.saddr, &np->saddr);
403 fl6.flowi6_oif = sk->sk_bound_dev_if;
404 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500405 fl6.fl6_dport = inet->inet_dport;
406 fl6.fl6_sport = inet->inet_sport;
David S. Miller4c9483b2011-03-12 16:22:43 -0500407 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
David S. Miller4c9483b2011-03-12 16:22:43 -0500409 dst = ip6_dst_lookup_flow(sk, &fl6, NULL, false);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800410 if (IS_ERR(dst)) {
411 sk->sk_err_soft = -PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 goto out;
413 }
414
415 } else
416 dst_hold(dst);
417
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800418 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 tcp_sync_mss(sk, dst_mtu(dst));
420 tcp_simple_retransmit(sk);
421 } /* else let the usual retransmit timer handle it */
422 dst_release(dst);
423 goto out;
424 }
425
426 icmpv6_err_convert(type, code, &err);
427
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700428 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700430 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 case TCP_LISTEN:
432 if (sock_owned_by_user(sk))
433 goto out;
434
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800435 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
436 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 if (!req)
438 goto out;
439
440 /* ICMPs are not backlogged, hence we cannot get
441 * an established socket here.
442 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700443 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700445 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700446 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 goto out;
448 }
449
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700450 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 goto out;
452
453 case TCP_SYN_SENT:
454 case TCP_SYN_RECV: /* Cannot happen.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900455 It can, it SYNs are crossed. --ANK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 sk->sk_err = err;
458 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
459
460 tcp_done(sk);
461 } else
462 sk->sk_err_soft = err;
463 goto out;
464 }
465
466 if (!sock_owned_by_user(sk) && np->recverr) {
467 sk->sk_err = err;
468 sk->sk_error_report(sk);
469 } else
470 sk->sk_err_soft = err;
471
472out:
473 bh_unlock_sock(sk);
474 sock_put(sk);
475}
476
477
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000478static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
479 struct request_values *rvp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800481 struct inet6_request_sock *treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 struct ipv6_pinfo *np = inet6_sk(sk);
483 struct sk_buff * skb;
484 struct ipv6_txoptions *opt = NULL;
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000485 struct in6_addr * final_p, final;
David S. Miller4c9483b2011-03-12 16:22:43 -0500486 struct flowi6 fl6;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800487 struct dst_entry *dst;
David S. Miller68d0c6d2011-03-01 13:19:07 -0800488 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
David S. Miller4c9483b2011-03-12 16:22:43 -0500490 memset(&fl6, 0, sizeof(fl6));
491 fl6.flowi6_proto = IPPROTO_TCP;
492 ipv6_addr_copy(&fl6.daddr, &treq->rmt_addr);
493 ipv6_addr_copy(&fl6.saddr, &treq->loc_addr);
494 fl6.flowlabel = 0;
495 fl6.flowi6_oif = treq->iif;
496 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500497 fl6.fl6_dport = inet_rsk(req)->rmt_port;
498 fl6.fl6_sport = inet_rsk(req)->loc_port;
David S. Miller4c9483b2011-03-12 16:22:43 -0500499 security_req_classify_flow(req, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800501 opt = np->opt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500502 final_p = fl6_update_dst(&fl6, opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
David S. Miller4c9483b2011-03-12 16:22:43 -0500504 dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800505 if (IS_ERR(dst)) {
506 err = PTR_ERR(dst);
Boris Ostrovsky738faca2011-04-04 13:07:26 -0700507 dst = NULL;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800508 goto done;
David S. Miller68d0c6d2011-03-01 13:19:07 -0800509 }
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000510 skb = tcp_make_synack(sk, dst, req, rvp);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800511 err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 if (skb) {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000513 __tcp_v6_send_check(skb, &treq->loc_addr, &treq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
David S. Miller4c9483b2011-03-12 16:22:43 -0500515 ipv6_addr_copy(&fl6.daddr, &treq->rmt_addr);
Eric Dumazetb903d322011-10-27 00:44:35 -0400516 err = ip6_xmit(sk, skb, &fl6, opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200517 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 }
519
520done:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900521 if (opt && opt != np->opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 sock_kfree_s(sk, opt, opt->tot_len);
Eric W. Biederman78b91042006-01-31 17:51:44 -0800523 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return err;
525}
526
Octavian Purdila72659ec2010-01-17 19:09:39 -0800527static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req,
528 struct request_values *rvp)
529{
530 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
531 return tcp_v6_send_synack(sk, req, rvp);
532}
533
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700534static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
Wei Yongjun800d55f2009-02-23 21:45:33 +0000536 kfree_skb(inet6_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
538
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800539#ifdef CONFIG_TCP_MD5SIG
540static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000541 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800542{
543 struct tcp_sock *tp = tcp_sk(sk);
544 int i;
545
546 BUG_ON(tp == NULL);
547
548 if (!tp->md5sig_info || !tp->md5sig_info->entries6)
549 return NULL;
550
551 for (i = 0; i < tp->md5sig_info->entries6; i++) {
YOSHIFUJI Hideakicaad2952008-04-10 15:42:07 +0900552 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, addr))
David S. Millerf8ab18d2007-09-28 15:18:35 -0700553 return &tp->md5sig_info->keys6[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800554 }
555 return NULL;
556}
557
558static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
559 struct sock *addr_sk)
560{
561 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
562}
563
564static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
565 struct request_sock *req)
566{
567 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
568}
569
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000570static int tcp_v6_md5_do_add(struct sock *sk, const struct in6_addr *peer,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800571 char *newkey, u8 newkeylen)
572{
573 /* Add key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700574 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800575 struct tcp_sock *tp = tcp_sk(sk);
576 struct tcp6_md5sig_key *keys;
577
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700578 key = tcp_v6_md5_do_lookup(sk, peer);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800579 if (key) {
580 /* modify existing entry - just update that one */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700581 kfree(key->key);
582 key->key = newkey;
583 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800584 } else {
585 /* reallocate new list if current one is full. */
586 if (!tp->md5sig_info) {
587 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
588 if (!tp->md5sig_info) {
589 kfree(newkey);
590 return -ENOMEM;
591 }
Eric Dumazeta4654192010-05-16 00:36:33 -0700592 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800593 }
Yan, Zheng260fcbe2011-09-29 17:10:10 +0000594 if (tp->md5sig_info->entries6 == 0 &&
595 tcp_alloc_md5sig_pool(sk) == NULL) {
YOSHIFUJI Hideakiaacbe8c2007-11-20 17:30:56 -0800596 kfree(newkey);
597 return -ENOMEM;
598 }
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800599 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
600 keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
601 (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
602
603 if (!keys) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800604 kfree(newkey);
Yan, Zheng260fcbe2011-09-29 17:10:10 +0000605 if (tp->md5sig_info->entries6 == 0)
606 tcp_free_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800607 return -ENOMEM;
608 }
609
610 if (tp->md5sig_info->entries6)
611 memmove(keys, tp->md5sig_info->keys6,
612 (sizeof (tp->md5sig_info->keys6[0]) *
613 tp->md5sig_info->entries6));
614
615 kfree(tp->md5sig_info->keys6);
616 tp->md5sig_info->keys6 = keys;
617 tp->md5sig_info->alloced6++;
618 }
619
620 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
621 peer);
David S. Millerf8ab18d2007-09-28 15:18:35 -0700622 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.key = newkey;
623 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800624
625 tp->md5sig_info->entries6++;
626 }
627 return 0;
628}
629
630static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
631 u8 *newkey, __u8 newkeylen)
632{
633 return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
634 newkey, newkeylen);
635}
636
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000637static int tcp_v6_md5_do_del(struct sock *sk, const struct in6_addr *peer)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800638{
639 struct tcp_sock *tp = tcp_sk(sk);
640 int i;
641
642 for (i = 0; i < tp->md5sig_info->entries6; i++) {
YOSHIFUJI Hideakicaad2952008-04-10 15:42:07 +0900643 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, peer)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800644 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700645 kfree(tp->md5sig_info->keys6[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800646 tp->md5sig_info->entries6--;
647
648 if (tp->md5sig_info->entries6 == 0) {
649 kfree(tp->md5sig_info->keys6);
650 tp->md5sig_info->keys6 = NULL;
YOSHIFUJI Hideakica983ce2007-07-24 15:27:30 -0700651 tp->md5sig_info->alloced6 = 0;
Yan, Zheng260fcbe2011-09-29 17:10:10 +0000652 tcp_free_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800653 } else {
654 /* shrink the database */
655 if (tp->md5sig_info->entries6 != i)
656 memmove(&tp->md5sig_info->keys6[i],
657 &tp->md5sig_info->keys6[i+1],
658 (tp->md5sig_info->entries6 - i)
659 * sizeof (tp->md5sig_info->keys6[0]));
660 }
YOSHIFUJI Hideaki77adefd2007-11-20 17:31:23 -0800661 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800662 }
663 }
664 return -ENOENT;
665}
666
667static void tcp_v6_clear_md5_list (struct sock *sk)
668{
669 struct tcp_sock *tp = tcp_sk(sk);
670 int i;
671
672 if (tp->md5sig_info->entries6) {
673 for (i = 0; i < tp->md5sig_info->entries6; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700674 kfree(tp->md5sig_info->keys6[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800675 tp->md5sig_info->entries6 = 0;
676 tcp_free_md5sig_pool();
677 }
678
679 kfree(tp->md5sig_info->keys6);
680 tp->md5sig_info->keys6 = NULL;
681 tp->md5sig_info->alloced6 = 0;
682
683 if (tp->md5sig_info->entries4) {
684 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700685 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800686 tp->md5sig_info->entries4 = 0;
687 tcp_free_md5sig_pool();
688 }
689
690 kfree(tp->md5sig_info->keys4);
691 tp->md5sig_info->keys4 = NULL;
692 tp->md5sig_info->alloced4 = 0;
693}
694
695static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
696 int optlen)
697{
698 struct tcp_md5sig cmd;
699 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
700 u8 *newkey;
701
702 if (optlen < sizeof(cmd))
703 return -EINVAL;
704
705 if (copy_from_user(&cmd, optval, sizeof(cmd)))
706 return -EFAULT;
707
708 if (sin6->sin6_family != AF_INET6)
709 return -EINVAL;
710
711 if (!cmd.tcpm_keylen) {
712 if (!tcp_sk(sk)->md5sig_info)
713 return -ENOENT;
Brian Haleye773e4f2007-08-24 23:16:08 -0700714 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800715 return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
716 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
717 }
718
719 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
720 return -EINVAL;
721
722 if (!tcp_sk(sk)->md5sig_info) {
723 struct tcp_sock *tp = tcp_sk(sk);
724 struct tcp_md5sig_info *p;
725
726 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
727 if (!p)
728 return -ENOMEM;
729
730 tp->md5sig_info = p;
Eric Dumazeta4654192010-05-16 00:36:33 -0700731 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800732 }
733
Arnaldo Carvalho de Meloaf879cc2006-11-17 12:14:37 -0200734 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800735 if (!newkey)
736 return -ENOMEM;
Brian Haleye773e4f2007-08-24 23:16:08 -0700737 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800738 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
739 newkey, cmd.tcpm_keylen);
740 }
741 return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
742}
743
Adam Langley49a72df2008-07-19 00:01:42 -0700744static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000745 const struct in6_addr *daddr,
746 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800747{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800748 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700749 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900750
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800751 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800752 /* 1. TCP pseudo-header (RFC2460) */
753 ipv6_addr_copy(&bp->saddr, saddr);
754 ipv6_addr_copy(&bp->daddr, daddr);
Adam Langley49a72df2008-07-19 00:01:42 -0700755 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700756 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800757
Adam Langley49a72df2008-07-19 00:01:42 -0700758 sg_init_one(&sg, bp, sizeof(*bp));
759 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
760}
David S. Millerc7da57a2007-10-26 00:41:21 -0700761
Adam Langley49a72df2008-07-19 00:01:42 -0700762static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000763 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400764 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700765{
766 struct tcp_md5sig_pool *hp;
767 struct hash_desc *desc;
768
769 hp = tcp_get_md5sig_pool();
770 if (!hp)
771 goto clear_hash_noput;
772 desc = &hp->md5_desc;
773
774 if (crypto_hash_init(desc))
775 goto clear_hash;
776 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
777 goto clear_hash;
778 if (tcp_md5_hash_header(hp, th))
779 goto clear_hash;
780 if (tcp_md5_hash_key(hp, key))
781 goto clear_hash;
782 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800783 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800784
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800785 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800786 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700787
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800788clear_hash:
789 tcp_put_md5sig_pool();
790clear_hash_noput:
791 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700792 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800793}
794
Adam Langley49a72df2008-07-19 00:01:42 -0700795static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400796 const struct sock *sk,
797 const struct request_sock *req,
798 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800799{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000800 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700801 struct tcp_md5sig_pool *hp;
802 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400803 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800804
805 if (sk) {
806 saddr = &inet6_sk(sk)->saddr;
807 daddr = &inet6_sk(sk)->daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700808 } else if (req) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800809 saddr = &inet6_rsk(req)->loc_addr;
810 daddr = &inet6_rsk(req)->rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700811 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000812 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700813 saddr = &ip6h->saddr;
814 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800815 }
Adam Langley49a72df2008-07-19 00:01:42 -0700816
817 hp = tcp_get_md5sig_pool();
818 if (!hp)
819 goto clear_hash_noput;
820 desc = &hp->md5_desc;
821
822 if (crypto_hash_init(desc))
823 goto clear_hash;
824
825 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
826 goto clear_hash;
827 if (tcp_md5_hash_header(hp, th))
828 goto clear_hash;
829 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
830 goto clear_hash;
831 if (tcp_md5_hash_key(hp, key))
832 goto clear_hash;
833 if (crypto_hash_final(desc, md5_hash))
834 goto clear_hash;
835
836 tcp_put_md5sig_pool();
837 return 0;
838
839clear_hash:
840 tcp_put_md5sig_pool();
841clear_hash_noput:
842 memset(md5_hash, 0, 16);
843 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800844}
845
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400846static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800847{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400848 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800849 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000850 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400851 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800852 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800853 u8 newhash[16];
854
855 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900856 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800857
David S. Miller785957d2008-07-30 03:03:15 -0700858 /* We've parsed the options - do we have a hash? */
859 if (!hash_expected && !hash_location)
860 return 0;
861
862 if (hash_expected && !hash_location) {
863 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800864 return 1;
865 }
866
David S. Miller785957d2008-07-30 03:03:15 -0700867 if (!hash_expected && hash_location) {
868 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800869 return 1;
870 }
871
872 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700873 genhash = tcp_v6_md5_hash_skb(newhash,
874 hash_expected,
875 NULL, NULL, skb);
876
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800877 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
878 if (net_ratelimit()) {
Joe Perches5856b602010-01-08 00:59:52 -0800879 printk(KERN_INFO "MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800880 genhash ? "failed" : "mismatch",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700881 &ip6h->saddr, ntohs(th->source),
882 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800883 }
884 return 1;
885 }
886 return 0;
887}
888#endif
889
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800890struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700892 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -0800893 .rtx_syn_ack = tcp_v6_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700894 .send_ack = tcp_v6_reqsk_send_ack,
895 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800896 .send_reset = tcp_v6_send_reset,
897 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898};
899
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800900#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000901static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800902 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000903 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800904};
Andrew Mortonb6332e62006-11-30 19:16:28 -0800905#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800906
Herbert Xu8ad50d92010-04-11 02:15:54 +0000907static void __tcp_v6_send_check(struct sk_buff *skb,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000908 const struct in6_addr *saddr, const struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700910 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
Patrick McHardy84fa7932006-08-29 16:44:56 -0700912 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000913 th->check = ~tcp_v6_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700914 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800915 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 } else {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000917 th->check = tcp_v6_check(skb->len, saddr, daddr,
918 csum_partial(th, th->doff << 2,
919 skb->csum));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 }
921}
922
Herbert Xubb296242010-04-11 02:15:55 +0000923static void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu8ad50d92010-04-11 02:15:54 +0000924{
925 struct ipv6_pinfo *np = inet6_sk(sk);
926
927 __tcp_v6_send_check(skb, &np->saddr, &np->daddr);
928}
929
Herbert Xua430a432006-07-08 13:34:56 -0700930static int tcp_v6_gso_send_check(struct sk_buff *skb)
931{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000932 const struct ipv6hdr *ipv6h;
Herbert Xua430a432006-07-08 13:34:56 -0700933 struct tcphdr *th;
934
935 if (!pskb_may_pull(skb, sizeof(*th)))
936 return -EINVAL;
937
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700938 ipv6h = ipv6_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700939 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700940
941 th->check = 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -0700942 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xu8ad50d92010-04-11 02:15:54 +0000943 __tcp_v6_send_check(skb, &ipv6h->saddr, &ipv6h->daddr);
Herbert Xua430a432006-07-08 13:34:56 -0700944 return 0;
945}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Herbert Xu36990672009-05-22 00:45:28 -0700947static struct sk_buff **tcp6_gro_receive(struct sk_buff **head,
948 struct sk_buff *skb)
Herbert Xu684f2172009-01-08 10:41:23 -0800949{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000950 const struct ipv6hdr *iph = skb_gro_network_header(skb);
Herbert Xu684f2172009-01-08 10:41:23 -0800951
952 switch (skb->ip_summed) {
953 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +0000954 if (!tcp_v6_check(skb_gro_len(skb), &iph->saddr, &iph->daddr,
Herbert Xu684f2172009-01-08 10:41:23 -0800955 skb->csum)) {
956 skb->ip_summed = CHECKSUM_UNNECESSARY;
957 break;
958 }
959
960 /* fall through */
961 case CHECKSUM_NONE:
962 NAPI_GRO_CB(skb)->flush = 1;
963 return NULL;
964 }
965
966 return tcp_gro_receive(head, skb);
967}
Herbert Xu684f2172009-01-08 10:41:23 -0800968
Herbert Xu36990672009-05-22 00:45:28 -0700969static int tcp6_gro_complete(struct sk_buff *skb)
Herbert Xu684f2172009-01-08 10:41:23 -0800970{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000971 const struct ipv6hdr *iph = ipv6_hdr(skb);
Herbert Xu684f2172009-01-08 10:41:23 -0800972 struct tcphdr *th = tcp_hdr(skb);
973
974 th->check = ~tcp_v6_check(skb->len - skb_transport_offset(skb),
975 &iph->saddr, &iph->daddr, 0);
976 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
977
978 return tcp_gro_complete(skb);
979}
Herbert Xu684f2172009-01-08 10:41:23 -0800980
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700981static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
Eric Dumazetb903d322011-10-27 00:44:35 -0400982 u32 ts, struct tcp_md5sig_key *key, int rst, u8 tclass)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400984 const struct tcphdr *th = tcp_hdr(skb);
985 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500987 struct flowi6 fl6;
Eric Dumazetadf30902009-06-02 05:19:30 +0000988 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800989 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800990 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000991 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800992 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
994 if (ts)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700995 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800996#ifdef CONFIG_TCP_MD5SIG
997 if (key)
998 tot_len += TCPOLEN_MD5SIG_ALIGNED;
999#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1002 GFP_ATOMIC);
1003 if (buff == NULL)
1004 return;
1005
1006 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1007
Ilpo Järvinen77c676d2008-10-09 14:41:38 -07001008 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -07001009 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
1011 /* Swap the send and the receive. */
1012 memset(t1, 0, sizeof(*t1));
1013 t1->dest = th->source;
1014 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -07001015 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 t1->seq = htonl(seq);
1017 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001018 t1->ack = !rst || !th->ack;
1019 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001021
Al Viroe69a4adc2006-11-14 20:56:00 -08001022 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001025 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1026 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1027 *topt++ = htonl(tcp_time_stamp);
Ilpo Järvinen53b12572008-10-08 14:36:33 -07001028 *topt++ = htonl(ts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 }
1030
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001031#ifdef CONFIG_TCP_MD5SIG
1032 if (key) {
1033 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1034 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -07001035 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -07001036 &ipv6_hdr(skb)->saddr,
1037 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001038 }
1039#endif
1040
David S. Miller4c9483b2011-03-12 16:22:43 -05001041 memset(&fl6, 0, sizeof(fl6));
1042 ipv6_addr_copy(&fl6.daddr, &ipv6_hdr(skb)->saddr);
1043 ipv6_addr_copy(&fl6.saddr, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
David S. Millere5700af2010-04-21 14:59:20 -07001045 buff->ip_summed = CHECKSUM_PARTIAL;
1046 buff->csum = 0;
1047
David S. Miller4c9483b2011-03-12 16:22:43 -05001048 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049
David S. Miller4c9483b2011-03-12 16:22:43 -05001050 fl6.flowi6_proto = IPPROTO_TCP;
1051 fl6.flowi6_oif = inet6_iif(skb);
David S. Miller1958b852011-03-12 16:36:19 -05001052 fl6.fl6_dport = t1->dest;
1053 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -05001054 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001056 /* Pass a socket to ip6_dst_lookup either it is for RST
1057 * Underlying function will use this to retrieve the network
1058 * namespace
1059 */
David S. Miller4c9483b2011-03-12 16:22:43 -05001060 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
David S. Miller68d0c6d2011-03-01 13:19:07 -08001061 if (!IS_ERR(dst)) {
1062 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -04001063 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -08001064 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
1065 if (rst)
1066 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
1067 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 }
1069
1070 kfree_skb(buff);
1071}
1072
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001073static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
1074{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001075 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001076 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -07001077 struct tcp_md5sig_key *key = NULL;
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001078
1079 if (th->rst)
1080 return;
1081
1082 if (!ipv6_unicast_destination(skb))
1083 return;
1084
1085#ifdef CONFIG_TCP_MD5SIG
1086 if (sk)
1087 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001088#endif
1089
1090 if (th->ack)
1091 seq = ntohl(th->ack_seq);
1092 else
1093 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
1094 (th->doff << 2);
1095
Eric Dumazetb903d322011-10-27 00:44:35 -04001096 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, key, 1, 0);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001097}
1098
1099static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts,
Eric Dumazetb903d322011-10-27 00:44:35 -04001100 struct tcp_md5sig_key *key, u8 tclass)
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001101{
Eric Dumazetb903d322011-10-27 00:44:35 -04001102 tcp_v6_send_response(skb, seq, ack, win, ts, key, 0, tclass);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001103}
1104
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1106{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001107 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001108 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001110 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001111 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Eric Dumazetb903d322011-10-27 00:44:35 -04001112 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw),
1113 tw->tw_tclass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001115 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116}
1117
Gui Jianfeng6edafaa2008-08-06 23:50:04 -07001118static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
1119 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001121 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent,
Eric Dumazetb903d322011-10-27 00:44:35 -04001122 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123}
1124
1125
1126static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1127{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001128 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001129 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 struct sock *nsk;
1131
1132 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -08001133 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001134 &ipv6_hdr(skb)->saddr,
1135 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 if (req)
1137 return tcp_check_req(sk, skb, req, prev);
1138
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001139 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -08001140 &ipv6_hdr(skb)->saddr, th->source,
1141 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
1143 if (nsk) {
1144 if (nsk->sk_state != TCP_TIME_WAIT) {
1145 bh_lock_sock(nsk);
1146 return nsk;
1147 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001148 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 return NULL;
1150 }
1151
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001152#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001153 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001154 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155#endif
1156 return sk;
1157}
1158
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159/* FIXME: this is substantially similar to the ipv4 code.
1160 * Can some kind of merge be done? -- erics
1161 */
1162static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1163{
William Allen Simpson4957faade2009-12-02 18:25:27 +00001164 struct tcp_extend_values tmp_ext;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001165 struct tcp_options_received tmp_opt;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001166 const u8 *hash_location;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001167 struct request_sock *req;
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001168 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 struct ipv6_pinfo *np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001171 __u32 isn = TCP_SKB_CB(skb)->when;
David S. Miller493f3772010-12-02 12:14:29 -08001172 struct dst_entry *dst = NULL;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001173 int want_cookie = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174
1175 if (skb->protocol == htons(ETH_P_IP))
1176 return tcp_v4_conn_request(sk, skb);
1177
1178 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001179 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001181 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Eric Dumazet946cedc2011-08-30 03:21:44 +00001182 want_cookie = tcp_syn_flood_action(sk, skb, "TCPv6");
1183 if (!want_cookie)
1184 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 }
1186
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001187 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 goto drop;
1189
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001190 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 if (req == NULL)
1192 goto drop;
1193
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001194#ifdef CONFIG_TCP_MD5SIG
1195 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1196#endif
1197
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 tcp_clear_options(&tmp_opt);
1199 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1200 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001201 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
William Allen Simpson4957faade2009-12-02 18:25:27 +00001203 if (tmp_opt.cookie_plus > 0 &&
1204 tmp_opt.saw_tstamp &&
1205 !tp->rx_opt.cookie_out_never &&
1206 (sysctl_tcp_cookie_size > 0 ||
1207 (tp->cookie_values != NULL &&
1208 tp->cookie_values->cookie_desired > 0))) {
1209 u8 *c;
1210 u32 *d;
1211 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1212 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1213
1214 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1215 goto drop_and_free;
1216
1217 /* Secret recipe starts with IP addresses */
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001218 d = (__force u32 *)&ipv6_hdr(skb)->daddr.s6_addr32[0];
William Allen Simpson4957faade2009-12-02 18:25:27 +00001219 *mess++ ^= *d++;
1220 *mess++ ^= *d++;
1221 *mess++ ^= *d++;
1222 *mess++ ^= *d++;
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001223 d = (__force u32 *)&ipv6_hdr(skb)->saddr.s6_addr32[0];
William Allen Simpson4957faade2009-12-02 18:25:27 +00001224 *mess++ ^= *d++;
1225 *mess++ ^= *d++;
1226 *mess++ ^= *d++;
1227 *mess++ ^= *d++;
1228
1229 /* plus variable length Initiator Cookie */
1230 c = (u8 *)mess;
1231 while (l-- > 0)
1232 *c++ ^= *hash_location++;
1233
William Allen Simpson4957faade2009-12-02 18:25:27 +00001234 want_cookie = 0; /* not our kind of cookie */
William Allen Simpson4957faade2009-12-02 18:25:27 +00001235 tmp_ext.cookie_out_never = 0; /* false */
1236 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1237 } else if (!tp->rx_opt.cookie_in_always) {
1238 /* redundant indications, but ensure initialization. */
1239 tmp_ext.cookie_out_never = 1; /* true */
1240 tmp_ext.cookie_plus = 0;
1241 } else {
1242 goto drop_and_free;
1243 }
1244 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
Florian Westphal4dfc2812008-04-10 03:12:40 -07001246 if (want_cookie && !tmp_opt.saw_tstamp)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001247 tcp_clear_options(&tmp_opt);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001248
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1250 tcp_openreq_init(req, &tmp_opt, skb);
1251
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001252 treq = inet6_rsk(req);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001253 ipv6_addr_copy(&treq->rmt_addr, &ipv6_hdr(skb)->saddr);
1254 ipv6_addr_copy(&treq->loc_addr, &ipv6_hdr(skb)->daddr);
Florian Westphal172d69e2010-06-21 11:48:45 +00001255 if (!want_cookie || tmp_opt.tstamp_ok)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001256 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Florian Westphal2bbdf382010-06-13 11:29:39 +00001258 if (!isn) {
David S. Miller493f3772010-12-02 12:14:29 -08001259 struct inet_peer *peer = NULL;
1260
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001261 if (ipv6_opt_accepted(sk, skb) ||
1262 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1263 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1264 atomic_inc(&skb->users);
1265 treq->pktopts = skb;
1266 }
1267 treq->iif = sk->sk_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001269 /* So that link locals have meaning */
1270 if (!sk->sk_bound_dev_if &&
1271 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1272 treq->iif = inet6_iif(skb);
David S. Miller493f3772010-12-02 12:14:29 -08001273
1274 if (want_cookie) {
Florian Westphal2bbdf382010-06-13 11:29:39 +00001275 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1276 req->cookie_ts = tmp_opt.tstamp_ok;
David S. Miller493f3772010-12-02 12:14:29 -08001277 goto have_isn;
Florian Westphal2bbdf382010-06-13 11:29:39 +00001278 }
David S. Miller493f3772010-12-02 12:14:29 -08001279
1280 /* VJ's idea. We save last timestamp seen
1281 * from the destination in peer table, when entering
1282 * state TIME-WAIT, and check against it before
1283 * accepting new connection request.
1284 *
1285 * If "isn" is not zero, this request hit alive
1286 * timewait bucket, so that all the necessary checks
1287 * are made in the function processing timewait state.
1288 */
1289 if (tmp_opt.saw_tstamp &&
1290 tcp_death_row.sysctl_tw_recycle &&
1291 (dst = inet6_csk_route_req(sk, req)) != NULL &&
1292 (peer = rt6_get_peer((struct rt6_info *)dst)) != NULL &&
David S. Miller7a71ed82011-02-09 14:30:26 -08001293 ipv6_addr_equal((struct in6_addr *)peer->daddr.addr.a6,
David S. Miller493f3772010-12-02 12:14:29 -08001294 &treq->rmt_addr)) {
1295 inet_peer_refcheck(peer);
1296 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
1297 (s32)(peer->tcp_ts - req->ts_recent) >
1298 TCP_PAWS_WINDOW) {
1299 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1300 goto drop_and_release;
1301 }
1302 }
1303 /* Kill the following clause, if you dislike this way. */
1304 else if (!sysctl_tcp_syncookies &&
1305 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1306 (sysctl_max_syn_backlog >> 2)) &&
1307 (!peer || !peer->tcp_ts_stamp) &&
1308 (!dst || !dst_metric(dst, RTAX_RTT))) {
1309 /* Without syncookies last quarter of
1310 * backlog is filled with destinations,
1311 * proven to be alive.
1312 * It means that we continue to communicate
1313 * to destinations, already remembered
1314 * to the moment of synflood.
1315 */
1316 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
1317 &treq->rmt_addr, ntohs(tcp_hdr(skb)->source));
1318 goto drop_and_release;
1319 }
1320
1321 isn = tcp_v6_init_sequence(skb);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001322 }
David S. Miller493f3772010-12-02 12:14:29 -08001323have_isn:
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001324 tcp_rsk(req)->snt_isn = isn;
Jerry Chu9ad7c042011-06-08 11:08:38 +00001325 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001327 security_inet_conn_request(sk, skb, req);
1328
William Allen Simpson4957faade2009-12-02 18:25:27 +00001329 if (tcp_v6_send_synack(sk, req,
1330 (struct request_values *)&tmp_ext) ||
1331 want_cookie)
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001332 goto drop_and_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001334 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1335 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336
David S. Miller493f3772010-12-02 12:14:29 -08001337drop_and_release:
1338 dst_release(dst);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001339drop_and_free:
1340 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 return 0; /* don't send reset */
1343}
1344
1345static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001346 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 struct dst_entry *dst)
1348{
Vegard Nossum78d15e82008-09-12 16:17:43 -07001349 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1351 struct tcp6_sock *newtcp6sk;
1352 struct inet_sock *newinet;
1353 struct tcp_sock *newtp;
1354 struct sock *newsk;
1355 struct ipv6_txoptions *opt;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001356#ifdef CONFIG_TCP_MD5SIG
1357 struct tcp_md5sig_key *key;
1358#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359
1360 if (skb->protocol == htons(ETH_P_IP)) {
1361 /*
1362 * v6 mapped
1363 */
1364
1365 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1366
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001367 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 return NULL;
1369
1370 newtcp6sk = (struct tcp6_sock *)newsk;
1371 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1372
1373 newinet = inet_sk(newsk);
1374 newnp = inet6_sk(newsk);
1375 newtp = tcp_sk(newsk);
1376
1377 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1378
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001379 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001381 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382
1383 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1384
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001385 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001387#ifdef CONFIG_TCP_MD5SIG
1388 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1389#endif
1390
Yan, Zheng676a1182011-09-25 02:21:30 +00001391 newnp->ipv6_ac_list = NULL;
1392 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 newnp->pktoptions = NULL;
1394 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001395 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001396 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001398 /*
1399 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1400 * here, tcp_create_openreq_child now does this for us, see the comment in
1401 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403
1404 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001405 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 Sync it now.
1407 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001408 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
1410 return newsk;
1411 }
1412
Vegard Nossum78d15e82008-09-12 16:17:43 -07001413 treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 opt = np->opt;
1415
1416 if (sk_acceptq_is_full(sk))
1417 goto out_overflow;
1418
David S. Miller493f3772010-12-02 12:14:29 -08001419 if (!dst) {
1420 dst = inet6_csk_route_req(sk, req);
1421 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001423 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424
1425 newsk = tcp_create_openreq_child(sk, req, skb);
1426 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001427 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001429 /*
1430 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1431 * count here, tcp_create_openreq_child now does this for us, see the
1432 * comment in that function for the gory details. -acme
1433 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Stephen Hemminger59eed272006-08-25 15:55:43 -07001435 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001436 __ip6_dst_store(newsk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
1438 newtcp6sk = (struct tcp6_sock *)newsk;
1439 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1440
1441 newtp = tcp_sk(newsk);
1442 newinet = inet_sk(newsk);
1443 newnp = inet6_sk(newsk);
1444
1445 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1446
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001447 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1448 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1449 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1450 newsk->sk_bound_dev_if = treq->iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001452 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
1454 First: no IPv4 options.
1455 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001456 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001457 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001458 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
1460 /* Clone RX bits */
1461 newnp->rxopt.all = np->rxopt.all;
1462
1463 /* Clone pktoptions received with SYN */
1464 newnp->pktoptions = NULL;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001465 if (treq->pktopts != NULL) {
1466 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1467 kfree_skb(treq->pktopts);
1468 treq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 if (newnp->pktoptions)
1470 skb_set_owner_r(newnp->pktoptions, newsk);
1471 }
1472 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001473 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001474 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475
1476 /* Clone native IPv6 options from listening socket (if any)
1477
1478 Yes, keeping reference count would be much more clever,
1479 but we make one more one thing there: reattach optmem
1480 to newsk.
1481 */
1482 if (opt) {
1483 newnp->opt = ipv6_dup_options(newsk, opt);
1484 if (opt != np->opt)
1485 sock_kfree_s(sk, opt, opt->tot_len);
1486 }
1487
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001488 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001490 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1491 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492
John Heffner5d424d52006-03-20 17:53:41 -08001493 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001495 newtp->advmss = dst_metric_advmss(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 tcp_initialize_rcv_mss(newsk);
Jerry Chu9ad7c042011-06-08 11:08:38 +00001497 if (tcp_rsk(req)->snt_synack)
1498 tcp_valid_rtt_meas(newsk,
1499 tcp_time_stamp - tcp_rsk(req)->snt_synack);
1500 newtp->total_retrans = req->retrans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001502 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1503 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001505#ifdef CONFIG_TCP_MD5SIG
1506 /* Copy over the MD5 key from the original socket */
1507 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1508 /* We're using one, so create a matching key
1509 * on the newsk structure. If we fail to get
1510 * memory, then we end up not copying the key
1511 * across. Shucks.
1512 */
Arnaldo Carvalho de Meloaf879cc2006-11-17 12:14:37 -02001513 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1514 if (newkey != NULL)
John Dykstrae547bc12009-07-17 09:23:22 +00001515 tcp_v6_md5_do_add(newsk, &newnp->daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001516 newkey, key->keylen);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001517 }
1518#endif
1519
Balazs Scheidler093d2822010-10-21 13:06:43 +02001520 if (__inet_inherit_port(sk, newsk) < 0) {
1521 sock_put(newsk);
1522 goto out;
1523 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001524 __inet6_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
1526 return newsk;
1527
1528out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001529 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001530out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 if (opt && opt != np->opt)
1532 sock_kfree_s(sk, opt, opt->tot_len);
1533 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001534out:
1535 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 return NULL;
1537}
1538
Al Virob51655b2006-11-14 21:40:42 -08001539static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001541 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Herbert Xu684f2172009-01-08 10:41:23 -08001542 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001543 &ipv6_hdr(skb)->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001544 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001546 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001548
Herbert Xu684f2172009-01-08 10:41:23 -08001549 skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001550 &ipv6_hdr(skb)->saddr,
1551 &ipv6_hdr(skb)->daddr, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -08001552
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001554 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 }
1556 return 0;
1557}
1558
1559/* The socket must have it's spinlock held when we get
1560 * here.
1561 *
1562 * We have a potential double-lock case here, so even when
1563 * doing backlog processing we use the BH locking scheme.
1564 * This is because we cannot sleep with the original spinlock
1565 * held.
1566 */
1567static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1568{
1569 struct ipv6_pinfo *np = inet6_sk(sk);
1570 struct tcp_sock *tp;
1571 struct sk_buff *opt_skb = NULL;
1572
1573 /* Imagine: socket is IPv6. IPv4 packet arrives,
1574 goes to IPv4 receive handler and backlogged.
1575 From backlog it always goes here. Kerboom...
1576 Fortunately, tcp_rcv_established and rcv_established
1577 handle them correctly, but it is not case with
1578 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1579 */
1580
1581 if (skb->protocol == htons(ETH_P_IP))
1582 return tcp_v4_do_rcv(sk, skb);
1583
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001584#ifdef CONFIG_TCP_MD5SIG
1585 if (tcp_v6_inbound_md5_hash (sk, skb))
1586 goto discard;
1587#endif
1588
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001589 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 goto discard;
1591
1592 /*
1593 * socket locking is here for SMP purposes as backlog rcv
1594 * is currently called with bh processing disabled.
1595 */
1596
1597 /* Do Stevens' IPV6_PKTOPTIONS.
1598
1599 Yes, guys, it is the only place in our code, where we
1600 may make it not affecting IPv4.
1601 The rest of code is protocol independent,
1602 and I do not like idea to uglify IPv4.
1603
1604 Actually, all the idea behind IPV6_PKTOPTIONS
1605 looks not very well thought. For now we latch
1606 options, received in the last packet, enqueued
1607 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001608 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 */
1610 if (np->rxopt.all)
1611 opt_skb = skb_clone(skb, GFP_ATOMIC);
1612
1613 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Tom Herbertbdeab992011-08-14 19:45:55 +00001614 sock_rps_save_rxhash(sk, skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001615 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 if (opt_skb)
1618 goto ipv6_pktoptions;
1619 return 0;
1620 }
1621
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001622 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 goto csum_err;
1624
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001625 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1627 if (!nsk)
1628 goto discard;
1629
1630 /*
1631 * Queue it on the new socket if the new socket is active,
1632 * otherwise we just shortcircuit this and continue with
1633 * the new socket..
1634 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001635 if(nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001636 sock_rps_save_rxhash(nsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 if (tcp_child_process(sk, nsk, skb))
1638 goto reset;
1639 if (opt_skb)
1640 __kfree_skb(opt_skb);
1641 return 0;
1642 }
Neil Horman47482f12011-04-06 13:07:09 -07001643 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001644 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001646 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 if (opt_skb)
1649 goto ipv6_pktoptions;
1650 return 0;
1651
1652reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001653 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654discard:
1655 if (opt_skb)
1656 __kfree_skb(opt_skb);
1657 kfree_skb(skb);
1658 return 0;
1659csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001660 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 goto discard;
1662
1663
1664ipv6_pktoptions:
1665 /* Do you ask, what is it?
1666
1667 1. skb was enqueued by tcp.
1668 2. skb is added to tail of read queue, rather than out of order.
1669 3. socket is not in passive state.
1670 4. Finally, it really contains options, which user wants to receive.
1671 */
1672 tp = tcp_sk(sk);
1673 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1674 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001675 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001676 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001677 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001678 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 if (ipv6_opt_accepted(sk, opt_skb)) {
1680 skb_set_owner_r(opt_skb, sk);
1681 opt_skb = xchg(&np->pktoptions, opt_skb);
1682 } else {
1683 __kfree_skb(opt_skb);
1684 opt_skb = xchg(&np->pktoptions, NULL);
1685 }
1686 }
1687
Wei Yongjun800d55f2009-02-23 21:45:33 +00001688 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 return 0;
1690}
1691
Herbert Xue5bbef22007-10-15 12:50:28 -07001692static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001694 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001695 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 struct sock *sk;
1697 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001698 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699
1700 if (skb->pkt_type != PACKET_HOST)
1701 goto discard_it;
1702
1703 /*
1704 * Count it even if it's bad.
1705 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001706 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707
1708 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1709 goto discard_it;
1710
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001711 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712
1713 if (th->doff < sizeof(struct tcphdr)/4)
1714 goto bad_packet;
1715 if (!pskb_may_pull(skb, th->doff*4))
1716 goto discard_it;
1717
Herbert Xu60476372007-04-09 11:59:39 -07001718 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 goto bad_packet;
1720
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001721 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001722 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1724 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1725 skb->len - th->doff*4);
1726 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1727 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001728 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 TCP_SKB_CB(skb)->sacked = 0;
1730
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001731 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 if (!sk)
1733 goto no_tcp_socket;
1734
1735process:
1736 if (sk->sk_state == TCP_TIME_WAIT)
1737 goto do_time_wait;
1738
Stephen Hemmingere802af92010-04-22 15:24:53 -07001739 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1740 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1741 goto discard_and_relse;
1742 }
1743
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1745 goto discard_and_relse;
1746
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001747 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 goto discard_and_relse;
1749
1750 skb->dev = NULL;
1751
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001752 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 ret = 0;
1754 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001755#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001756 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001757 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001758 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001759 if (tp->ucopy.dma_chan)
1760 ret = tcp_v6_do_rcv(sk, skb);
1761 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001762#endif
1763 {
1764 if (!tcp_prequeue(sk, skb))
1765 ret = tcp_v6_do_rcv(sk, skb);
1766 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001767 } else if (unlikely(sk_add_backlog(sk, skb))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001768 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001769 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001770 goto discard_and_relse;
1771 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 bh_unlock_sock(sk);
1773
1774 sock_put(sk);
1775 return ret ? -1 : 0;
1776
1777no_tcp_socket:
1778 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1779 goto discard_it;
1780
1781 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1782bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001783 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001785 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 }
1787
1788discard_it:
1789
1790 /*
1791 * Discard frame
1792 */
1793
1794 kfree_skb(skb);
1795 return 0;
1796
1797discard_and_relse:
1798 sock_put(sk);
1799 goto discard_it;
1800
1801do_time_wait:
1802 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001803 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 goto discard_it;
1805 }
1806
1807 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001808 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001809 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 goto discard_it;
1811 }
1812
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001813 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 case TCP_TW_SYN:
1815 {
1816 struct sock *sk2;
1817
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001818 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001819 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001820 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001822 struct inet_timewait_sock *tw = inet_twsk(sk);
1823 inet_twsk_deschedule(tw, &tcp_death_row);
1824 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 sk = sk2;
1826 goto process;
1827 }
1828 /* Fall through to ACK */
1829 }
1830 case TCP_TW_ACK:
1831 tcp_v6_timewait_ack(sk, skb);
1832 break;
1833 case TCP_TW_RST:
1834 goto no_tcp_socket;
1835 case TCP_TW_SUCCESS:;
1836 }
1837 goto discard_it;
1838}
1839
David S. Millerccb7c412010-12-01 18:09:13 -08001840static struct inet_peer *tcp_v6_get_peer(struct sock *sk, bool *release_it)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841{
David S. Millerdb3949c2010-12-02 11:52:07 -08001842 struct rt6_info *rt = (struct rt6_info *) __sk_dst_get(sk);
1843 struct ipv6_pinfo *np = inet6_sk(sk);
1844 struct inet_peer *peer;
1845
1846 if (!rt ||
1847 !ipv6_addr_equal(&np->daddr, &rt->rt6i_dst.addr)) {
1848 peer = inet_getpeer_v6(&np->daddr, 1);
1849 *release_it = true;
1850 } else {
1851 if (!rt->rt6i_peer)
1852 rt6_bind_peer(rt, 1);
1853 peer = rt->rt6i_peer;
David S. Miller457de432010-12-10 13:16:09 -08001854 *release_it = false;
David S. Millerdb3949c2010-12-02 11:52:07 -08001855 }
1856
1857 return peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858}
1859
David S. Millerccb7c412010-12-01 18:09:13 -08001860static void *tcp_v6_tw_get_peer(struct sock *sk)
1861{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001862 const struct inet6_timewait_sock *tw6 = inet6_twsk(sk);
1863 const struct inet_timewait_sock *tw = inet_twsk(sk);
David S. Millerccb7c412010-12-01 18:09:13 -08001864
1865 if (tw->tw_family == AF_INET)
1866 return tcp_v4_tw_get_peer(sk);
1867
David S. Millerdb3949c2010-12-02 11:52:07 -08001868 return inet_getpeer_v6(&tw6->tw_v6_daddr, 1);
David S. Millerccb7c412010-12-01 18:09:13 -08001869}
1870
1871static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1872 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1873 .twsk_unique = tcp_twsk_unique,
1874 .twsk_destructor= tcp_twsk_destructor,
1875 .twsk_getpeer = tcp_v6_tw_get_peer,
1876};
1877
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001878static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001879 .queue_xmit = inet6_csk_xmit,
1880 .send_check = tcp_v6_send_check,
1881 .rebuild_header = inet6_sk_rebuild_header,
1882 .conn_request = tcp_v6_conn_request,
1883 .syn_recv_sock = tcp_v6_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001884 .get_peer = tcp_v6_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001885 .net_header_len = sizeof(struct ipv6hdr),
1886 .setsockopt = ipv6_setsockopt,
1887 .getsockopt = ipv6_getsockopt,
1888 .addr2sockaddr = inet6_csk_addr2sockaddr,
1889 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001890 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001891#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001892 .compat_setsockopt = compat_ipv6_setsockopt,
1893 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001894#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895};
1896
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001897#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001898static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001899 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001900 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001901 .md5_add = tcp_v6_md5_add_func,
1902 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001903};
David S. Millera9286302006-11-14 19:53:22 -08001904#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001905
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906/*
1907 * TCP over IPv4 via INET6 API
1908 */
1909
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001910static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001911 .queue_xmit = ip_queue_xmit,
1912 .send_check = tcp_v4_send_check,
1913 .rebuild_header = inet_sk_rebuild_header,
1914 .conn_request = tcp_v6_conn_request,
1915 .syn_recv_sock = tcp_v6_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001916 .get_peer = tcp_v4_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001917 .net_header_len = sizeof(struct iphdr),
1918 .setsockopt = ipv6_setsockopt,
1919 .getsockopt = ipv6_getsockopt,
1920 .addr2sockaddr = inet6_csk_addr2sockaddr,
1921 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001922 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001923#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001924 .compat_setsockopt = compat_ipv6_setsockopt,
1925 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001926#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927};
1928
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001929#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001930static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001931 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001932 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001933 .md5_add = tcp_v6_md5_add_func,
1934 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001935};
David S. Millera9286302006-11-14 19:53:22 -08001936#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001937
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938/* NOTE: A lot of things set to zero explicitly by call to
1939 * sk_alloc() so need not be done here.
1940 */
1941static int tcp_v6_init_sock(struct sock *sk)
1942{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001943 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 struct tcp_sock *tp = tcp_sk(sk);
1945
1946 skb_queue_head_init(&tp->out_of_order_queue);
1947 tcp_init_xmit_timers(sk);
1948 tcp_prequeue_init(tp);
1949
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001950 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 tp->mdev = TCP_TIMEOUT_INIT;
1952
1953 /* So many TCP implementations out there (incorrectly) count the
1954 * initial SYN frame in their delayed-ACK and congestion control
1955 * algorithms that we must have the following bandaid to talk
1956 * efficiently to them. -DaveM
1957 */
1958 tp->snd_cwnd = 2;
1959
1960 /* See draft-stevens-tcpca-spec-01 for discussion of the
1961 * initialization of these values.
1962 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001963 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001965 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966
1967 tp->reordering = sysctl_tcp_reordering;
1968
1969 sk->sk_state = TCP_CLOSE;
1970
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001971 icsk->icsk_af_ops = &ipv6_specific;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001972 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001973 icsk->icsk_sync_mss = tcp_sync_mss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 sk->sk_write_space = sk_stream_write_space;
1975 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1976
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001977#ifdef CONFIG_TCP_MD5SIG
1978 tp->af_specific = &tcp_sock_ipv6_specific;
1979#endif
1980
William Allen Simpson435cf552009-12-02 18:17:05 +00001981 /* TCP Cookie Transactions */
1982 if (sysctl_tcp_cookie_size > 0) {
1983 /* Default, cookies without s_data_payload. */
1984 tp->cookie_values =
1985 kzalloc(sizeof(*tp->cookie_values),
1986 sk->sk_allocation);
1987 if (tp->cookie_values != NULL)
1988 kref_init(&tp->cookie_values->kref);
1989 }
1990 /* Presumed zeroed, in order of appearance:
1991 * cookie_in_always, cookie_out_never,
1992 * s_data_constant, s_data_in, s_data_out
1993 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1995 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1996
Herbert Xueb4dea52008-12-29 23:04:08 -08001997 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001998 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001999 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000
2001 return 0;
2002}
2003
Brian Haley7d06b2e2008-06-14 17:04:49 -07002004static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002006#ifdef CONFIG_TCP_MD5SIG
2007 /* Clean up the MD5 key list */
2008 if (tcp_sk(sk)->md5sig_info)
2009 tcp_v6_clear_md5_list(sk);
2010#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07002012 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013}
2014
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09002015#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002017static void get_openreq6(struct seq_file *seq,
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002018 const struct sock *sk, struct request_sock *req, int i, int uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 int ttd = req->expires - jiffies;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002021 const struct in6_addr *src = &inet6_rsk(req)->loc_addr;
2022 const struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023
2024 if (ttd < 0)
2025 ttd = 0;
2026
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 seq_printf(seq,
2028 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002029 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 i,
2031 src->s6_addr32[0], src->s6_addr32[1],
2032 src->s6_addr32[2], src->s6_addr32[3],
KOVACS Krisztianfd507032008-10-19 23:35:58 -07002033 ntohs(inet_rsk(req)->loc_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 dest->s6_addr32[0], dest->s6_addr32[1],
2035 dest->s6_addr32[2], dest->s6_addr32[3],
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002036 ntohs(inet_rsk(req)->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 TCP_SYN_RECV,
2038 0,0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002039 1, /* timers active (only the expire timer) */
2040 jiffies_to_clock_t(ttd),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 req->retrans,
2042 uid,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002043 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 0, /* open_requests have no inode */
2045 0, req);
2046}
2047
2048static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
2049{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002050 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 __u16 destp, srcp;
2052 int timer_active;
2053 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002054 const struct inet_sock *inet = inet_sk(sp);
2055 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002056 const struct inet_connection_sock *icsk = inet_csk(sp);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002057 const struct ipv6_pinfo *np = inet6_sk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058
2059 dest = &np->daddr;
2060 src = &np->rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002061 destp = ntohs(inet->inet_dport);
2062 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002063
2064 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002066 timer_expires = icsk->icsk_timeout;
2067 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002069 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 } else if (timer_pending(&sp->sk_timer)) {
2071 timer_active = 2;
2072 timer_expires = sp->sk_timer.expires;
2073 } else {
2074 timer_active = 0;
2075 timer_expires = jiffies;
2076 }
2077
2078 seq_printf(seq,
2079 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002080 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 i,
2082 src->s6_addr32[0], src->s6_addr32[1],
2083 src->s6_addr32[2], src->s6_addr32[3], srcp,
2084 dest->s6_addr32[0], dest->s6_addr32[1],
2085 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002086 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002087 tp->write_seq-tp->snd_una,
2088 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 timer_active,
2090 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002091 icsk->icsk_retransmits,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 sock_i_uid(sp),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002093 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 sock_i_ino(sp),
2095 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002096 jiffies_to_clock_t(icsk->icsk_rto),
2097 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002098 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002099 tp->snd_cwnd,
2100 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 );
2102}
2103
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002104static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002105 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002107 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 __u16 destp, srcp;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002109 const struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 int ttd = tw->tw_ttd - jiffies;
2111
2112 if (ttd < 0)
2113 ttd = 0;
2114
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08002115 dest = &tw6->tw_v6_daddr;
2116 src = &tw6->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 destp = ntohs(tw->tw_dport);
2118 srcp = ntohs(tw->tw_sport);
2119
2120 seq_printf(seq,
2121 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002122 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 i,
2124 src->s6_addr32[0], src->s6_addr32[1],
2125 src->s6_addr32[2], src->s6_addr32[3], srcp,
2126 dest->s6_addr32[0], dest->s6_addr32[1],
2127 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2128 tw->tw_substate, 0, 0,
2129 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2130 atomic_read(&tw->tw_refcnt), tw);
2131}
2132
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133static int tcp6_seq_show(struct seq_file *seq, void *v)
2134{
2135 struct tcp_iter_state *st;
2136
2137 if (v == SEQ_START_TOKEN) {
2138 seq_puts(seq,
2139 " sl "
2140 "local_address "
2141 "remote_address "
2142 "st tx_queue rx_queue tr tm->when retrnsmt"
2143 " uid timeout inode\n");
2144 goto out;
2145 }
2146 st = seq->private;
2147
2148 switch (st->state) {
2149 case TCP_SEQ_STATE_LISTENING:
2150 case TCP_SEQ_STATE_ESTABLISHED:
2151 get_tcp6_sock(seq, v, st->num);
2152 break;
2153 case TCP_SEQ_STATE_OPENREQ:
2154 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2155 break;
2156 case TCP_SEQ_STATE_TIME_WAIT:
2157 get_timewait6_sock(seq, v, st->num);
2158 break;
2159 }
2160out:
2161 return 0;
2162}
2163
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002164static const struct file_operations tcp6_afinfo_seq_fops = {
2165 .owner = THIS_MODULE,
2166 .open = tcp_seq_open,
2167 .read = seq_read,
2168 .llseek = seq_lseek,
2169 .release = seq_release_net
2170};
2171
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 .name = "tcp6",
2174 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002175 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002176 .seq_ops = {
2177 .show = tcp6_seq_show,
2178 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179};
2180
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002181int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002183 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184}
2185
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002186void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002188 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189}
2190#endif
2191
2192struct proto tcpv6_prot = {
2193 .name = "TCPv6",
2194 .owner = THIS_MODULE,
2195 .close = tcp_close,
2196 .connect = tcp_v6_connect,
2197 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002198 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 .ioctl = tcp_ioctl,
2200 .init = tcp_v6_init_sock,
2201 .destroy = tcp_v6_destroy_sock,
2202 .shutdown = tcp_shutdown,
2203 .setsockopt = tcp_setsockopt,
2204 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002206 .sendmsg = tcp_sendmsg,
2207 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 .backlog_rcv = tcp_v6_do_rcv,
2209 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002210 .unhash = inet_unhash,
2211 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 .enter_memory_pressure = tcp_enter_memory_pressure,
2213 .sockets_allocated = &tcp_sockets_allocated,
2214 .memory_allocated = &tcp_memory_allocated,
2215 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002216 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 .sysctl_mem = sysctl_tcp_mem,
2218 .sysctl_wmem = sysctl_tcp_wmem,
2219 .sysctl_rmem = sysctl_tcp_rmem,
2220 .max_header = MAX_TCP_HEADER,
2221 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002222 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002223 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002224 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002225 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002226 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002227#ifdef CONFIG_COMPAT
2228 .compat_setsockopt = compat_tcp_setsockopt,
2229 .compat_getsockopt = compat_tcp_getsockopt,
2230#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231};
2232
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00002233static const struct inet6_protocol tcpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 .handler = tcp_v6_rcv,
2235 .err_handler = tcp_v6_err,
Herbert Xua430a432006-07-08 13:34:56 -07002236 .gso_send_check = tcp_v6_gso_send_check,
Herbert Xuadcfc7d2006-06-30 13:36:15 -07002237 .gso_segment = tcp_tso_segment,
Herbert Xu684f2172009-01-08 10:41:23 -08002238 .gro_receive = tcp6_gro_receive,
2239 .gro_complete = tcp6_gro_complete,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2241};
2242
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243static struct inet_protosw tcpv6_protosw = {
2244 .type = SOCK_STREAM,
2245 .protocol = IPPROTO_TCP,
2246 .prot = &tcpv6_prot,
2247 .ops = &inet6_stream_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 .no_check = 0,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08002249 .flags = INET_PROTOSW_PERMANENT |
2250 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251};
2252
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002253static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002254{
Denis V. Lunev56772422008-04-03 14:28:30 -07002255 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2256 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002257}
2258
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002259static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002260{
Denis V. Lunev56772422008-04-03 14:28:30 -07002261 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002262}
2263
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002264static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002265{
2266 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002267}
2268
2269static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002270 .init = tcpv6_net_init,
2271 .exit = tcpv6_net_exit,
2272 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002273};
2274
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002275int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002277 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08002278
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002279 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2280 if (ret)
2281 goto out;
2282
2283 /* register inet6 protocol */
2284 ret = inet6_register_protosw(&tcpv6_protosw);
2285 if (ret)
2286 goto out_tcpv6_protocol;
2287
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002288 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002289 if (ret)
2290 goto out_tcpv6_protosw;
2291out:
2292 return ret;
2293
2294out_tcpv6_protocol:
2295 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2296out_tcpv6_protosw:
2297 inet6_unregister_protosw(&tcpv6_protosw);
2298 goto out;
2299}
2300
Daniel Lezcano09f77092007-12-13 05:34:58 -08002301void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002302{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002303 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002304 inet6_unregister_protosw(&tcpv6_protosw);
2305 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306}