blob: e394d0029d8d7561830552107fe03ef30ffb7d81 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65#include <asm/uaccess.h>
66
67#include <linux/proc_fs.h>
68#include <linux/seq_file.h>
69
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080070#include <linux/crypto.h>
71#include <linux/scatterlist.h>
72
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080073static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070074static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
75 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Herbert Xu8ad50d92010-04-11 02:15:54 +000078static void __tcp_v6_send_check(struct sk_buff *skb,
79 struct in6_addr *saddr,
80 struct in6_addr *daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Stephen Hemminger3b401a82009-09-01 19:25:04 +000082static const struct inet_connection_sock_af_ops ipv6_mapped;
83static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080084#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000085static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
86static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090087#else
88static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
89 struct in6_addr *addr)
90{
91 return NULL;
92}
David S. Millera9286302006-11-14 19:53:22 -080093#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Linus Torvalds1da177e2005-04-16 15:20:36 -070095static void tcp_v6_hash(struct sock *sk)
96{
97 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -080098 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 tcp_prot.hash(sk);
100 return;
101 }
102 local_bh_disable();
Eric Dumazet9327f702009-12-04 03:46:54 +0000103 __inet6_hash(sk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 local_bh_enable();
105 }
106}
107
Herbert Xu684f2172009-01-08 10:41:23 -0800108static __inline__ __sum16 tcp_v6_check(int len,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900109 struct in6_addr *saddr,
110 struct in6_addr *daddr,
Al Viro868c86b2006-11-14 21:35:48 -0800111 __wsum base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{
113 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
114}
115
Gerrit Renkera94f7232006-11-10 14:06:49 -0800116static __u32 tcp_v6_init_sequence(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700118 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
119 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700120 tcp_hdr(skb)->dest,
121 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122}
123
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900124static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 int addr_len)
126{
127 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900128 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800129 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 struct ipv6_pinfo *np = inet6_sk(sk);
131 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000132 struct in6_addr *saddr = NULL, *final_p, final;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 struct flowi fl;
134 struct dst_entry *dst;
135 int addr_type;
136 int err;
137
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900138 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 return -EINVAL;
140
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900141 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000142 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
144 memset(&fl, 0, sizeof(fl));
145
146 if (np->sndflow) {
147 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
148 IP6_ECN_flow_init(fl.fl6_flowlabel);
149 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
150 struct ip6_flowlabel *flowlabel;
151 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
152 if (flowlabel == NULL)
153 return -EINVAL;
154 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
155 fl6_sock_release(flowlabel);
156 }
157 }
158
159 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900160 * connect() to INADDR_ANY means loopback (BSD'ism).
161 */
162
163 if(ipv6_addr_any(&usin->sin6_addr))
164 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166 addr_type = ipv6_addr_type(&usin->sin6_addr);
167
168 if(addr_type & IPV6_ADDR_MULTICAST)
169 return -ENETUNREACH;
170
171 if (addr_type&IPV6_ADDR_LINKLOCAL) {
172 if (addr_len >= sizeof(struct sockaddr_in6) &&
173 usin->sin6_scope_id) {
174 /* If interface is set while binding, indices
175 * must coincide.
176 */
177 if (sk->sk_bound_dev_if &&
178 sk->sk_bound_dev_if != usin->sin6_scope_id)
179 return -EINVAL;
180
181 sk->sk_bound_dev_if = usin->sin6_scope_id;
182 }
183
184 /* Connect to link-local address requires an interface */
185 if (!sk->sk_bound_dev_if)
186 return -EINVAL;
187 }
188
189 if (tp->rx_opt.ts_recent_stamp &&
190 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
191 tp->rx_opt.ts_recent = 0;
192 tp->rx_opt.ts_recent_stamp = 0;
193 tp->write_seq = 0;
194 }
195
196 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
197 np->flow_label = fl.fl6_flowlabel;
198
199 /*
200 * TCP over IPv4
201 */
202
203 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800204 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 struct sockaddr_in sin;
206
207 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
208
209 if (__ipv6_only_sock(sk))
210 return -ENETUNREACH;
211
212 sin.sin_family = AF_INET;
213 sin.sin_port = usin->sin6_port;
214 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
215
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800216 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800218#ifdef CONFIG_TCP_MD5SIG
219 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
220#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
223
224 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800225 icsk->icsk_ext_hdr_len = exthdrlen;
226 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800228#ifdef CONFIG_TCP_MD5SIG
229 tp->af_specific = &tcp_sock_ipv6_specific;
230#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 goto failure;
232 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000233 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
234 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
235 &np->rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 }
237
238 return err;
239 }
240
241 if (!ipv6_addr_any(&np->rcv_saddr))
242 saddr = &np->rcv_saddr;
243
244 fl.proto = IPPROTO_TCP;
245 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
246 ipv6_addr_copy(&fl.fl6_src,
247 (saddr ? saddr : &np->saddr));
248 fl.oif = sk->sk_bound_dev_if;
Brian Haley51953d52009-10-05 08:24:16 +0000249 fl.mark = sk->sk_mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 fl.fl_ip_dport = usin->sin6_port;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000251 fl.fl_ip_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000253 final_p = fl6_update_dst(&fl, np->opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700255 security_sk_classify_flow(sk, &fl);
256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 err = ip6_dst_lookup(sk, &dst, &fl);
258 if (err)
259 goto failure;
260 if (final_p)
261 ipv6_addr_copy(&fl.fl6_dst, final_p);
262
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800263 err = __xfrm_lookup(sock_net(sk), &dst, &fl, sk, XFRM_LOOKUP_WAIT);
264 if (err < 0) {
David S. Miller14e50e52007-05-24 18:17:54 -0700265 if (err == -EREMOTE)
266 err = ip6_dst_blackhole(sk, &dst, &fl);
267 if (err < 0)
268 goto failure;
269 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
271 if (saddr == NULL) {
272 saddr = &fl.fl6_src;
273 ipv6_addr_copy(&np->rcv_saddr, saddr);
274 }
275
276 /* set the source address */
277 ipv6_addr_copy(&np->saddr, saddr);
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000278 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700280 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700281 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800283 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800285 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
286 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
289
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000290 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800293 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 if (err)
295 goto late_failure;
296
297 if (!tp->write_seq)
298 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
299 np->daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000300 inet->inet_sport,
301 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303 err = tcp_connect(sk);
304 if (err)
305 goto late_failure;
306
307 return 0;
308
309late_failure:
310 tcp_set_state(sk, TCP_CLOSE);
311 __sk_dst_reset(sk);
312failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000313 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 sk->sk_route_caps = 0;
315 return err;
316}
317
318static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700319 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{
321 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300322 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 struct ipv6_pinfo *np;
324 struct sock *sk;
325 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900326 struct tcp_sock *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 __u32 seq;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700328 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700330 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800331 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
333 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700334 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
335 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 return;
337 }
338
339 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700340 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return;
342 }
343
344 bh_lock_sock(sk);
345 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700346 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 if (sk->sk_state == TCP_CLOSE)
349 goto out;
350
Stephen Hemmingere802af92010-04-22 15:24:53 -0700351 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
352 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
353 goto out;
354 }
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900357 seq = ntohl(th->seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if (sk->sk_state != TCP_LISTEN &&
359 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700360 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 goto out;
362 }
363
364 np = inet6_sk(sk);
365
366 if (type == ICMPV6_PKT_TOOBIG) {
367 struct dst_entry *dst = NULL;
368
369 if (sock_owned_by_user(sk))
370 goto out;
371 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
372 goto out;
373
374 /* icmp should have updated the destination cache entry */
375 dst = __sk_dst_check(sk, np->dst_cookie);
376
377 if (dst == NULL) {
378 struct inet_sock *inet = inet_sk(sk);
379 struct flowi fl;
380
381 /* BUGGG_FUTURE: Again, it is not clear how
382 to handle rthdr case. Ignore this complexity
383 for now.
384 */
385 memset(&fl, 0, sizeof(fl));
386 fl.proto = IPPROTO_TCP;
387 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
388 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
389 fl.oif = sk->sk_bound_dev_if;
Brian Haley51953d52009-10-05 08:24:16 +0000390 fl.mark = sk->sk_mark;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000391 fl.fl_ip_dport = inet->inet_dport;
392 fl.fl_ip_sport = inet->inet_sport;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700393 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
396 sk->sk_err_soft = -err;
397 goto out;
398 }
399
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800400 if ((err = xfrm_lookup(net, &dst, &fl, sk, 0)) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 sk->sk_err_soft = -err;
402 goto out;
403 }
404
405 } else
406 dst_hold(dst);
407
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800408 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 tcp_sync_mss(sk, dst_mtu(dst));
410 tcp_simple_retransmit(sk);
411 } /* else let the usual retransmit timer handle it */
412 dst_release(dst);
413 goto out;
414 }
415
416 icmpv6_err_convert(type, code, &err);
417
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700418 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700420 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 case TCP_LISTEN:
422 if (sock_owned_by_user(sk))
423 goto out;
424
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800425 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
426 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 if (!req)
428 goto out;
429
430 /* ICMPs are not backlogged, hence we cannot get
431 * an established socket here.
432 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700433 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700435 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700436 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 goto out;
438 }
439
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700440 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 goto out;
442
443 case TCP_SYN_SENT:
444 case TCP_SYN_RECV: /* Cannot happen.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900445 It can, it SYNs are crossed. --ANK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 sk->sk_err = err;
448 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
449
450 tcp_done(sk);
451 } else
452 sk->sk_err_soft = err;
453 goto out;
454 }
455
456 if (!sock_owned_by_user(sk) && np->recverr) {
457 sk->sk_err = err;
458 sk->sk_error_report(sk);
459 } else
460 sk->sk_err_soft = err;
461
462out:
463 bh_unlock_sock(sk);
464 sock_put(sk);
465}
466
467
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000468static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
469 struct request_values *rvp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800471 struct inet6_request_sock *treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 struct ipv6_pinfo *np = inet6_sk(sk);
473 struct sk_buff * skb;
474 struct ipv6_txoptions *opt = NULL;
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000475 struct in6_addr * final_p, final;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 struct flowi fl;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800477 struct dst_entry *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 int err = -1;
479
480 memset(&fl, 0, sizeof(fl));
481 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700482 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
483 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 fl.fl6_flowlabel = 0;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700485 fl.oif = treq->iif;
Brian Haley51953d52009-10-05 08:24:16 +0000486 fl.mark = sk->sk_mark;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700487 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
KOVACS Krisztianfd507032008-10-19 23:35:58 -0700488 fl.fl_ip_sport = inet_rsk(req)->loc_port;
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700489 security_req_classify_flow(req, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800491 opt = np->opt;
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000492 final_p = fl6_update_dst(&fl, opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800494 err = ip6_dst_lookup(sk, &dst, &fl);
495 if (err)
496 goto done;
497 if (final_p)
498 ipv6_addr_copy(&fl.fl6_dst, final_p);
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800499 if ((err = xfrm_lookup(sock_net(sk), &dst, &fl, sk, 0)) < 0)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800500 goto done;
501
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000502 skb = tcp_make_synack(sk, dst, req, rvp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 if (skb) {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000504 __tcp_v6_send_check(skb, &treq->loc_addr, &treq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700506 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
Shan Wei4e15ed42010-04-15 16:43:08 +0000507 err = ip6_xmit(sk, skb, &fl, opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200508 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
510
511done:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900512 if (opt && opt != np->opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 sock_kfree_s(sk, opt, opt->tot_len);
Eric W. Biederman78b91042006-01-31 17:51:44 -0800514 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 return err;
516}
517
Octavian Purdila72659ec2010-01-17 19:09:39 -0800518static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req,
519 struct request_values *rvp)
520{
521 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
522 return tcp_v6_send_synack(sk, req, rvp);
523}
524
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800525static inline void syn_flood_warning(struct sk_buff *skb)
526{
527#ifdef CONFIG_SYN_COOKIES
528 if (sysctl_tcp_syncookies)
529 printk(KERN_INFO
530 "TCPv6: Possible SYN flooding on port %d. "
531 "Sending cookies.\n", ntohs(tcp_hdr(skb)->dest));
532 else
533#endif
534 printk(KERN_INFO
535 "TCPv6: Possible SYN flooding on port %d. "
536 "Dropping request.\n", ntohs(tcp_hdr(skb)->dest));
537}
538
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700539static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
Wei Yongjun800d55f2009-02-23 21:45:33 +0000541 kfree_skb(inet6_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
543
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800544#ifdef CONFIG_TCP_MD5SIG
545static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
546 struct in6_addr *addr)
547{
548 struct tcp_sock *tp = tcp_sk(sk);
549 int i;
550
551 BUG_ON(tp == NULL);
552
553 if (!tp->md5sig_info || !tp->md5sig_info->entries6)
554 return NULL;
555
556 for (i = 0; i < tp->md5sig_info->entries6; i++) {
YOSHIFUJI Hideakicaad2952008-04-10 15:42:07 +0900557 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, addr))
David S. Millerf8ab18d2007-09-28 15:18:35 -0700558 return &tp->md5sig_info->keys6[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800559 }
560 return NULL;
561}
562
563static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
564 struct sock *addr_sk)
565{
566 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
567}
568
569static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
570 struct request_sock *req)
571{
572 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
573}
574
575static int tcp_v6_md5_do_add(struct sock *sk, struct in6_addr *peer,
576 char *newkey, u8 newkeylen)
577{
578 /* Add key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700579 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800580 struct tcp_sock *tp = tcp_sk(sk);
581 struct tcp6_md5sig_key *keys;
582
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700583 key = tcp_v6_md5_do_lookup(sk, peer);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800584 if (key) {
585 /* modify existing entry - just update that one */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700586 kfree(key->key);
587 key->key = newkey;
588 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800589 } else {
590 /* reallocate new list if current one is full. */
591 if (!tp->md5sig_info) {
592 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
593 if (!tp->md5sig_info) {
594 kfree(newkey);
595 return -ENOMEM;
596 }
Eric Dumazeta4654192010-05-16 00:36:33 -0700597 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800598 }
Wu Fengguangaa133072009-09-02 23:45:45 -0700599 if (tcp_alloc_md5sig_pool(sk) == NULL) {
YOSHIFUJI Hideakiaacbe8c2007-11-20 17:30:56 -0800600 kfree(newkey);
601 return -ENOMEM;
602 }
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800603 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
604 keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
605 (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
606
607 if (!keys) {
608 tcp_free_md5sig_pool();
609 kfree(newkey);
610 return -ENOMEM;
611 }
612
613 if (tp->md5sig_info->entries6)
614 memmove(keys, tp->md5sig_info->keys6,
615 (sizeof (tp->md5sig_info->keys6[0]) *
616 tp->md5sig_info->entries6));
617
618 kfree(tp->md5sig_info->keys6);
619 tp->md5sig_info->keys6 = keys;
620 tp->md5sig_info->alloced6++;
621 }
622
623 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
624 peer);
David S. Millerf8ab18d2007-09-28 15:18:35 -0700625 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.key = newkey;
626 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800627
628 tp->md5sig_info->entries6++;
629 }
630 return 0;
631}
632
633static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
634 u8 *newkey, __u8 newkeylen)
635{
636 return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
637 newkey, newkeylen);
638}
639
640static int tcp_v6_md5_do_del(struct sock *sk, struct in6_addr *peer)
641{
642 struct tcp_sock *tp = tcp_sk(sk);
643 int i;
644
645 for (i = 0; i < tp->md5sig_info->entries6; i++) {
YOSHIFUJI Hideakicaad2952008-04-10 15:42:07 +0900646 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, peer)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800647 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700648 kfree(tp->md5sig_info->keys6[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800649 tp->md5sig_info->entries6--;
650
651 if (tp->md5sig_info->entries6 == 0) {
652 kfree(tp->md5sig_info->keys6);
653 tp->md5sig_info->keys6 = NULL;
YOSHIFUJI Hideakica983ce2007-07-24 15:27:30 -0700654 tp->md5sig_info->alloced6 = 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800655 } else {
656 /* shrink the database */
657 if (tp->md5sig_info->entries6 != i)
658 memmove(&tp->md5sig_info->keys6[i],
659 &tp->md5sig_info->keys6[i+1],
660 (tp->md5sig_info->entries6 - i)
661 * sizeof (tp->md5sig_info->keys6[0]));
662 }
YOSHIFUJI Hideaki77adefd2007-11-20 17:31:23 -0800663 tcp_free_md5sig_pool();
664 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800665 }
666 }
667 return -ENOENT;
668}
669
670static void tcp_v6_clear_md5_list (struct sock *sk)
671{
672 struct tcp_sock *tp = tcp_sk(sk);
673 int i;
674
675 if (tp->md5sig_info->entries6) {
676 for (i = 0; i < tp->md5sig_info->entries6; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700677 kfree(tp->md5sig_info->keys6[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800678 tp->md5sig_info->entries6 = 0;
679 tcp_free_md5sig_pool();
680 }
681
682 kfree(tp->md5sig_info->keys6);
683 tp->md5sig_info->keys6 = NULL;
684 tp->md5sig_info->alloced6 = 0;
685
686 if (tp->md5sig_info->entries4) {
687 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700688 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800689 tp->md5sig_info->entries4 = 0;
690 tcp_free_md5sig_pool();
691 }
692
693 kfree(tp->md5sig_info->keys4);
694 tp->md5sig_info->keys4 = NULL;
695 tp->md5sig_info->alloced4 = 0;
696}
697
698static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
699 int optlen)
700{
701 struct tcp_md5sig cmd;
702 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
703 u8 *newkey;
704
705 if (optlen < sizeof(cmd))
706 return -EINVAL;
707
708 if (copy_from_user(&cmd, optval, sizeof(cmd)))
709 return -EFAULT;
710
711 if (sin6->sin6_family != AF_INET6)
712 return -EINVAL;
713
714 if (!cmd.tcpm_keylen) {
715 if (!tcp_sk(sk)->md5sig_info)
716 return -ENOENT;
Brian Haleye773e4f2007-08-24 23:16:08 -0700717 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800718 return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
719 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
720 }
721
722 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
723 return -EINVAL;
724
725 if (!tcp_sk(sk)->md5sig_info) {
726 struct tcp_sock *tp = tcp_sk(sk);
727 struct tcp_md5sig_info *p;
728
729 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
730 if (!p)
731 return -ENOMEM;
732
733 tp->md5sig_info = p;
Eric Dumazeta4654192010-05-16 00:36:33 -0700734 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800735 }
736
Arnaldo Carvalho de Meloaf879cc2006-11-17 12:14:37 -0200737 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800738 if (!newkey)
739 return -ENOMEM;
Brian Haleye773e4f2007-08-24 23:16:08 -0700740 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800741 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
742 newkey, cmd.tcpm_keylen);
743 }
744 return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
745}
746
Adam Langley49a72df2008-07-19 00:01:42 -0700747static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
748 struct in6_addr *daddr,
749 struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800750{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800751 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700752 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900753
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800754 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800755 /* 1. TCP pseudo-header (RFC2460) */
756 ipv6_addr_copy(&bp->saddr, saddr);
757 ipv6_addr_copy(&bp->daddr, daddr);
Adam Langley49a72df2008-07-19 00:01:42 -0700758 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700759 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800760
Adam Langley49a72df2008-07-19 00:01:42 -0700761 sg_init_one(&sg, bp, sizeof(*bp));
762 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
763}
David S. Millerc7da57a2007-10-26 00:41:21 -0700764
Adam Langley49a72df2008-07-19 00:01:42 -0700765static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
766 struct in6_addr *daddr, struct in6_addr *saddr,
767 struct tcphdr *th)
768{
769 struct tcp_md5sig_pool *hp;
770 struct hash_desc *desc;
771
772 hp = tcp_get_md5sig_pool();
773 if (!hp)
774 goto clear_hash_noput;
775 desc = &hp->md5_desc;
776
777 if (crypto_hash_init(desc))
778 goto clear_hash;
779 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
780 goto clear_hash;
781 if (tcp_md5_hash_header(hp, th))
782 goto clear_hash;
783 if (tcp_md5_hash_key(hp, key))
784 goto clear_hash;
785 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800786 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800787
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800788 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800789 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700790
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800791clear_hash:
792 tcp_put_md5sig_pool();
793clear_hash_noput:
794 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700795 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800796}
797
Adam Langley49a72df2008-07-19 00:01:42 -0700798static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
799 struct sock *sk, struct request_sock *req,
800 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800801{
802 struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700803 struct tcp_md5sig_pool *hp;
804 struct hash_desc *desc;
805 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800806
807 if (sk) {
808 saddr = &inet6_sk(sk)->saddr;
809 daddr = &inet6_sk(sk)->daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700810 } else if (req) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800811 saddr = &inet6_rsk(req)->loc_addr;
812 daddr = &inet6_rsk(req)->rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700813 } else {
814 struct ipv6hdr *ip6h = ipv6_hdr(skb);
815 saddr = &ip6h->saddr;
816 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800817 }
Adam Langley49a72df2008-07-19 00:01:42 -0700818
819 hp = tcp_get_md5sig_pool();
820 if (!hp)
821 goto clear_hash_noput;
822 desc = &hp->md5_desc;
823
824 if (crypto_hash_init(desc))
825 goto clear_hash;
826
827 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
828 goto clear_hash;
829 if (tcp_md5_hash_header(hp, th))
830 goto clear_hash;
831 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
832 goto clear_hash;
833 if (tcp_md5_hash_key(hp, key))
834 goto clear_hash;
835 if (crypto_hash_final(desc, md5_hash))
836 goto clear_hash;
837
838 tcp_put_md5sig_pool();
839 return 0;
840
841clear_hash:
842 tcp_put_md5sig_pool();
843clear_hash_noput:
844 memset(md5_hash, 0, 16);
845 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800846}
847
848static int tcp_v6_inbound_md5_hash (struct sock *sk, struct sk_buff *skb)
849{
850 __u8 *hash_location = NULL;
851 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700852 struct ipv6hdr *ip6h = ipv6_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700853 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800854 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800855 u8 newhash[16];
856
857 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900858 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800859
David S. Miller785957d2008-07-30 03:03:15 -0700860 /* We've parsed the options - do we have a hash? */
861 if (!hash_expected && !hash_location)
862 return 0;
863
864 if (hash_expected && !hash_location) {
865 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800866 return 1;
867 }
868
David S. Miller785957d2008-07-30 03:03:15 -0700869 if (!hash_expected && hash_location) {
870 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800871 return 1;
872 }
873
874 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700875 genhash = tcp_v6_md5_hash_skb(newhash,
876 hash_expected,
877 NULL, NULL, skb);
878
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800879 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
880 if (net_ratelimit()) {
Joe Perches5856b602010-01-08 00:59:52 -0800881 printk(KERN_INFO "MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800882 genhash ? "failed" : "mismatch",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700883 &ip6h->saddr, ntohs(th->source),
884 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800885 }
886 return 1;
887 }
888 return 0;
889}
890#endif
891
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800892struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700894 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -0800895 .rtx_syn_ack = tcp_v6_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700896 .send_ack = tcp_v6_reqsk_send_ack,
897 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800898 .send_reset = tcp_v6_send_reset,
899 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900};
901
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800902#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000903static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800904 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000905 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800906};
Andrew Mortonb6332e62006-11-30 19:16:28 -0800907#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800908
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800909static struct timewait_sock_ops tcp6_timewait_sock_ops = {
910 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
911 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800912 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800913};
914
Herbert Xu8ad50d92010-04-11 02:15:54 +0000915static void __tcp_v6_send_check(struct sk_buff *skb,
916 struct in6_addr *saddr, struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700918 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
Patrick McHardy84fa7932006-08-29 16:44:56 -0700920 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000921 th->check = ~tcp_v6_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700922 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800923 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 } else {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000925 th->check = tcp_v6_check(skb->len, saddr, daddr,
926 csum_partial(th, th->doff << 2,
927 skb->csum));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 }
929}
930
Herbert Xubb296242010-04-11 02:15:55 +0000931static void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu8ad50d92010-04-11 02:15:54 +0000932{
933 struct ipv6_pinfo *np = inet6_sk(sk);
934
935 __tcp_v6_send_check(skb, &np->saddr, &np->daddr);
936}
937
Herbert Xua430a432006-07-08 13:34:56 -0700938static int tcp_v6_gso_send_check(struct sk_buff *skb)
939{
940 struct ipv6hdr *ipv6h;
941 struct tcphdr *th;
942
943 if (!pskb_may_pull(skb, sizeof(*th)))
944 return -EINVAL;
945
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700946 ipv6h = ipv6_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700947 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700948
949 th->check = 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -0700950 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xu8ad50d92010-04-11 02:15:54 +0000951 __tcp_v6_send_check(skb, &ipv6h->saddr, &ipv6h->daddr);
Herbert Xua430a432006-07-08 13:34:56 -0700952 return 0;
953}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
Herbert Xu36990672009-05-22 00:45:28 -0700955static struct sk_buff **tcp6_gro_receive(struct sk_buff **head,
956 struct sk_buff *skb)
Herbert Xu684f2172009-01-08 10:41:23 -0800957{
Herbert Xu36e7b1b2009-04-27 05:44:45 -0700958 struct ipv6hdr *iph = skb_gro_network_header(skb);
Herbert Xu684f2172009-01-08 10:41:23 -0800959
960 switch (skb->ip_summed) {
961 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +0000962 if (!tcp_v6_check(skb_gro_len(skb), &iph->saddr, &iph->daddr,
Herbert Xu684f2172009-01-08 10:41:23 -0800963 skb->csum)) {
964 skb->ip_summed = CHECKSUM_UNNECESSARY;
965 break;
966 }
967
968 /* fall through */
969 case CHECKSUM_NONE:
970 NAPI_GRO_CB(skb)->flush = 1;
971 return NULL;
972 }
973
974 return tcp_gro_receive(head, skb);
975}
Herbert Xu684f2172009-01-08 10:41:23 -0800976
Herbert Xu36990672009-05-22 00:45:28 -0700977static int tcp6_gro_complete(struct sk_buff *skb)
Herbert Xu684f2172009-01-08 10:41:23 -0800978{
979 struct ipv6hdr *iph = ipv6_hdr(skb);
980 struct tcphdr *th = tcp_hdr(skb);
981
982 th->check = ~tcp_v6_check(skb->len - skb_transport_offset(skb),
983 &iph->saddr, &iph->daddr, 0);
984 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
985
986 return tcp_gro_complete(skb);
987}
Herbert Xu684f2172009-01-08 10:41:23 -0800988
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700989static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
990 u32 ts, struct tcp_md5sig_key *key, int rst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700992 struct tcphdr *th = tcp_hdr(skb), *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 struct sk_buff *buff;
994 struct flowi fl;
Eric Dumazetadf30902009-06-02 05:19:30 +0000995 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800996 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800997 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000998 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800999 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 if (ts)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -07001002 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001003#ifdef CONFIG_TCP_MD5SIG
1004 if (key)
1005 tot_len += TCPOLEN_MD5SIG_ALIGNED;
1006#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
1008 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1009 GFP_ATOMIC);
1010 if (buff == NULL)
1011 return;
1012
1013 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1014
Ilpo Järvinen77c676d2008-10-09 14:41:38 -07001015 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -07001016 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017
1018 /* Swap the send and the receive. */
1019 memset(t1, 0, sizeof(*t1));
1020 t1->dest = th->source;
1021 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -07001022 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 t1->seq = htonl(seq);
1024 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001025 t1->ack = !rst || !th->ack;
1026 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001028
Al Viroe69a4adc2006-11-14 20:56:00 -08001029 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001032 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1033 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1034 *topt++ = htonl(tcp_time_stamp);
Ilpo Järvinen53b12572008-10-08 14:36:33 -07001035 *topt++ = htonl(ts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 }
1037
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001038#ifdef CONFIG_TCP_MD5SIG
1039 if (key) {
1040 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1041 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -07001042 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -07001043 &ipv6_hdr(skb)->saddr,
1044 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001045 }
1046#endif
1047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 memset(&fl, 0, sizeof(fl));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001049 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
1050 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
David S. Millere5700af2010-04-21 14:59:20 -07001052 buff->ip_summed = CHECKSUM_PARTIAL;
1053 buff->csum = 0;
1054
Herbert Xu8ad50d92010-04-11 02:15:54 +00001055 __tcp_v6_send_check(buff, &fl.fl6_src, &fl.fl6_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
1057 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001058 fl.oif = inet6_iif(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 fl.fl_ip_dport = t1->dest;
1060 fl.fl_ip_sport = t1->source;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001061 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001063 /* Pass a socket to ip6_dst_lookup either it is for RST
1064 * Underlying function will use this to retrieve the network
1065 * namespace
1066 */
Eric Dumazetadf30902009-06-02 05:19:30 +00001067 if (!ip6_dst_lookup(ctl_sk, &dst, &fl)) {
1068 if (xfrm_lookup(net, &dst, &fl, NULL, 0) >= 0) {
1069 skb_dst_set(buff, dst);
Shan Wei4e15ed42010-04-15 16:43:08 +00001070 ip6_xmit(ctl_sk, buff, &fl, NULL);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001071 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001072 if (rst)
1073 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 return;
Arnaldo Carvalho de Meloecc51b62005-12-12 14:38:10 -08001075 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 }
1077
1078 kfree_skb(buff);
1079}
1080
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001081static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
1082{
1083 struct tcphdr *th = tcp_hdr(skb);
1084 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -07001085 struct tcp_md5sig_key *key = NULL;
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001086
1087 if (th->rst)
1088 return;
1089
1090 if (!ipv6_unicast_destination(skb))
1091 return;
1092
1093#ifdef CONFIG_TCP_MD5SIG
1094 if (sk)
1095 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001096#endif
1097
1098 if (th->ack)
1099 seq = ntohl(th->ack_seq);
1100 else
1101 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
1102 (th->doff << 2);
1103
1104 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, key, 1);
1105}
1106
1107static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts,
1108 struct tcp_md5sig_key *key)
1109{
1110 tcp_v6_send_response(skb, seq, ack, win, ts, key, 0);
1111}
1112
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1114{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001115 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001116 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001118 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001119 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001120 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001122 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123}
1124
Gui Jianfeng6edafaa2008-08-06 23:50:04 -07001125static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
1126 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001128 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent,
Gui Jianfeng6edafaa2008-08-06 23:50:04 -07001129 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130}
1131
1132
1133static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1134{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001135 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001136 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 struct sock *nsk;
1138
1139 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -08001140 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001141 &ipv6_hdr(skb)->saddr,
1142 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 if (req)
1144 return tcp_check_req(sk, skb, req, prev);
1145
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001146 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -08001147 &ipv6_hdr(skb)->saddr, th->source,
1148 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
1150 if (nsk) {
1151 if (nsk->sk_state != TCP_TIME_WAIT) {
1152 bh_lock_sock(nsk);
1153 return nsk;
1154 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001155 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 return NULL;
1157 }
1158
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001159#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001160 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001161 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162#endif
1163 return sk;
1164}
1165
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166/* FIXME: this is substantially similar to the ipv4 code.
1167 * Can some kind of merge be done? -- erics
1168 */
1169static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1170{
William Allen Simpson4957faade2009-12-02 18:25:27 +00001171 struct tcp_extend_values tmp_ext;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001172 struct tcp_options_received tmp_opt;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001173 u8 *hash_location;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001174 struct request_sock *req;
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001175 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 struct ipv6_pinfo *np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001178 __u32 isn = TCP_SKB_CB(skb)->when;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001179#ifdef CONFIG_SYN_COOKIES
1180 int want_cookie = 0;
1181#else
1182#define want_cookie 0
1183#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185 if (skb->protocol == htons(ETH_P_IP))
1186 return tcp_v4_conn_request(sk, skb);
1187
1188 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001189 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001191 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 if (net_ratelimit())
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001193 syn_flood_warning(skb);
1194#ifdef CONFIG_SYN_COOKIES
1195 if (sysctl_tcp_syncookies)
1196 want_cookie = 1;
1197 else
1198#endif
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001199 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 }
1201
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001202 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 goto drop;
1204
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001205 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 if (req == NULL)
1207 goto drop;
1208
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001209#ifdef CONFIG_TCP_MD5SIG
1210 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1211#endif
1212
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 tcp_clear_options(&tmp_opt);
1214 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1215 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001216 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
William Allen Simpson4957faade2009-12-02 18:25:27 +00001218 if (tmp_opt.cookie_plus > 0 &&
1219 tmp_opt.saw_tstamp &&
1220 !tp->rx_opt.cookie_out_never &&
1221 (sysctl_tcp_cookie_size > 0 ||
1222 (tp->cookie_values != NULL &&
1223 tp->cookie_values->cookie_desired > 0))) {
1224 u8 *c;
1225 u32 *d;
1226 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1227 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1228
1229 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1230 goto drop_and_free;
1231
1232 /* Secret recipe starts with IP addresses */
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001233 d = (__force u32 *)&ipv6_hdr(skb)->daddr.s6_addr32[0];
William Allen Simpson4957faade2009-12-02 18:25:27 +00001234 *mess++ ^= *d++;
1235 *mess++ ^= *d++;
1236 *mess++ ^= *d++;
1237 *mess++ ^= *d++;
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001238 d = (__force u32 *)&ipv6_hdr(skb)->saddr.s6_addr32[0];
William Allen Simpson4957faade2009-12-02 18:25:27 +00001239 *mess++ ^= *d++;
1240 *mess++ ^= *d++;
1241 *mess++ ^= *d++;
1242 *mess++ ^= *d++;
1243
1244 /* plus variable length Initiator Cookie */
1245 c = (u8 *)mess;
1246 while (l-- > 0)
1247 *c++ ^= *hash_location++;
1248
1249#ifdef CONFIG_SYN_COOKIES
1250 want_cookie = 0; /* not our kind of cookie */
1251#endif
1252 tmp_ext.cookie_out_never = 0; /* false */
1253 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1254 } else if (!tp->rx_opt.cookie_in_always) {
1255 /* redundant indications, but ensure initialization. */
1256 tmp_ext.cookie_out_never = 1; /* true */
1257 tmp_ext.cookie_plus = 0;
1258 } else {
1259 goto drop_and_free;
1260 }
1261 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
Florian Westphal4dfc2812008-04-10 03:12:40 -07001263 if (want_cookie && !tmp_opt.saw_tstamp)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001264 tcp_clear_options(&tmp_opt);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001265
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1267 tcp_openreq_init(req, &tmp_opt, skb);
1268
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001269 treq = inet6_rsk(req);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001270 ipv6_addr_copy(&treq->rmt_addr, &ipv6_hdr(skb)->saddr);
1271 ipv6_addr_copy(&treq->loc_addr, &ipv6_hdr(skb)->daddr);
Florian Westphal172d69e2010-06-21 11:48:45 +00001272 if (!want_cookie || tmp_opt.tstamp_ok)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001273 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
Florian Westphal2bbdf382010-06-13 11:29:39 +00001275 if (!isn) {
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001276 if (ipv6_opt_accepted(sk, skb) ||
1277 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1278 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1279 atomic_inc(&skb->users);
1280 treq->pktopts = skb;
1281 }
1282 treq->iif = sk->sk_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001284 /* So that link locals have meaning */
1285 if (!sk->sk_bound_dev_if &&
1286 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1287 treq->iif = inet6_iif(skb);
Florian Westphal2bbdf382010-06-13 11:29:39 +00001288 if (!want_cookie) {
1289 isn = tcp_v6_init_sequence(skb);
1290 } else {
1291 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1292 req->cookie_ts = tmp_opt.tstamp_ok;
1293 }
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001294 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001295 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001297 security_inet_conn_request(sk, skb, req);
1298
William Allen Simpson4957faade2009-12-02 18:25:27 +00001299 if (tcp_v6_send_synack(sk, req,
1300 (struct request_values *)&tmp_ext) ||
1301 want_cookie)
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001302 goto drop_and_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001304 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1305 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001307drop_and_free:
1308 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 return 0; /* don't send reset */
1311}
1312
1313static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001314 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 struct dst_entry *dst)
1316{
Vegard Nossum78d15e82008-09-12 16:17:43 -07001317 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1319 struct tcp6_sock *newtcp6sk;
1320 struct inet_sock *newinet;
1321 struct tcp_sock *newtp;
1322 struct sock *newsk;
1323 struct ipv6_txoptions *opt;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001324#ifdef CONFIG_TCP_MD5SIG
1325 struct tcp_md5sig_key *key;
1326#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
1328 if (skb->protocol == htons(ETH_P_IP)) {
1329 /*
1330 * v6 mapped
1331 */
1332
1333 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1334
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001335 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 return NULL;
1337
1338 newtcp6sk = (struct tcp6_sock *)newsk;
1339 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1340
1341 newinet = inet_sk(newsk);
1342 newnp = inet6_sk(newsk);
1343 newtp = tcp_sk(newsk);
1344
1345 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1346
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001347 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001349 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
1351 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1352
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001353 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001355#ifdef CONFIG_TCP_MD5SIG
1356 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1357#endif
1358
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 newnp->pktoptions = NULL;
1360 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001361 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001362 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001364 /*
1365 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1366 * here, tcp_create_openreq_child now does this for us, see the comment in
1367 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
1370 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001371 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 Sync it now.
1373 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001374 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
1376 return newsk;
1377 }
1378
Vegard Nossum78d15e82008-09-12 16:17:43 -07001379 treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 opt = np->opt;
1381
1382 if (sk_acceptq_is_full(sk))
1383 goto out_overflow;
1384
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 if (dst == NULL) {
Arnaud Ebalard20c59de2010-06-01 21:35:01 +00001386 struct in6_addr *final_p, final;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 struct flowi fl;
1388
1389 memset(&fl, 0, sizeof(fl));
1390 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001391 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +00001392 final_p = fl6_update_dst(&fl, opt, &final);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001393 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 fl.oif = sk->sk_bound_dev_if;
Brian Haley51953d52009-10-05 08:24:16 +00001395 fl.mark = sk->sk_mark;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001396 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
KOVACS Krisztianfd507032008-10-19 23:35:58 -07001397 fl.fl_ip_sport = inet_rsk(req)->loc_port;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001398 security_req_classify_flow(req, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
1400 if (ip6_dst_lookup(sk, &dst, &fl))
1401 goto out;
1402
1403 if (final_p)
1404 ipv6_addr_copy(&fl.fl6_dst, final_p);
1405
Alexey Dobriyan52479b62008-11-25 17:35:18 -08001406 if ((xfrm_lookup(sock_net(sk), &dst, &fl, sk, 0)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001408 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
1410 newsk = tcp_create_openreq_child(sk, req, skb);
1411 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001412 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001414 /*
1415 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1416 * count here, tcp_create_openreq_child now does this for us, see the
1417 * comment in that function for the gory details. -acme
1418 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
Stephen Hemminger59eed272006-08-25 15:55:43 -07001420 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001421 __ip6_dst_store(newsk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
1423 newtcp6sk = (struct tcp6_sock *)newsk;
1424 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1425
1426 newtp = tcp_sk(newsk);
1427 newinet = inet_sk(newsk);
1428 newnp = inet6_sk(newsk);
1429
1430 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1431
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001432 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1433 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1434 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1435 newsk->sk_bound_dev_if = treq->iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001437 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
1439 First: no IPv4 options.
1440 */
1441 newinet->opt = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001442 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
1444 /* Clone RX bits */
1445 newnp->rxopt.all = np->rxopt.all;
1446
1447 /* Clone pktoptions received with SYN */
1448 newnp->pktoptions = NULL;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001449 if (treq->pktopts != NULL) {
1450 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1451 kfree_skb(treq->pktopts);
1452 treq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 if (newnp->pktoptions)
1454 skb_set_owner_r(newnp->pktoptions, newsk);
1455 }
1456 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001457 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001458 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
1460 /* Clone native IPv6 options from listening socket (if any)
1461
1462 Yes, keeping reference count would be much more clever,
1463 but we make one more one thing there: reattach optmem
1464 to newsk.
1465 */
1466 if (opt) {
1467 newnp->opt = ipv6_dup_options(newsk, opt);
1468 if (opt != np->opt)
1469 sock_kfree_s(sk, opt, opt->tot_len);
1470 }
1471
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001472 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001474 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1475 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476
John Heffner5d424d52006-03-20 17:53:41 -08001477 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 tcp_sync_mss(newsk, dst_mtu(dst));
1479 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1480 tcp_initialize_rcv_mss(newsk);
1481
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001482 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1483 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001485#ifdef CONFIG_TCP_MD5SIG
1486 /* Copy over the MD5 key from the original socket */
1487 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1488 /* We're using one, so create a matching key
1489 * on the newsk structure. If we fail to get
1490 * memory, then we end up not copying the key
1491 * across. Shucks.
1492 */
Arnaldo Carvalho de Meloaf879cc2006-11-17 12:14:37 -02001493 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1494 if (newkey != NULL)
John Dykstrae547bc12009-07-17 09:23:22 +00001495 tcp_v6_md5_do_add(newsk, &newnp->daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001496 newkey, key->keylen);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001497 }
1498#endif
1499
Balazs Scheidler093d2822010-10-21 13:06:43 +02001500 if (__inet_inherit_port(sk, newsk) < 0) {
1501 sock_put(newsk);
1502 goto out;
1503 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001504 __inet6_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505
1506 return newsk;
1507
1508out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001509 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001510out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 if (opt && opt != np->opt)
1512 sock_kfree_s(sk, opt, opt->tot_len);
1513 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001514out:
1515 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 return NULL;
1517}
1518
Al Virob51655b2006-11-14 21:40:42 -08001519static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001521 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Herbert Xu684f2172009-01-08 10:41:23 -08001522 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001523 &ipv6_hdr(skb)->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001524 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001526 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001528
Herbert Xu684f2172009-01-08 10:41:23 -08001529 skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001530 &ipv6_hdr(skb)->saddr,
1531 &ipv6_hdr(skb)->daddr, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -08001532
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001534 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 }
1536 return 0;
1537}
1538
1539/* The socket must have it's spinlock held when we get
1540 * here.
1541 *
1542 * We have a potential double-lock case here, so even when
1543 * doing backlog processing we use the BH locking scheme.
1544 * This is because we cannot sleep with the original spinlock
1545 * held.
1546 */
1547static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1548{
1549 struct ipv6_pinfo *np = inet6_sk(sk);
1550 struct tcp_sock *tp;
1551 struct sk_buff *opt_skb = NULL;
1552
1553 /* Imagine: socket is IPv6. IPv4 packet arrives,
1554 goes to IPv4 receive handler and backlogged.
1555 From backlog it always goes here. Kerboom...
1556 Fortunately, tcp_rcv_established and rcv_established
1557 handle them correctly, but it is not case with
1558 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1559 */
1560
1561 if (skb->protocol == htons(ETH_P_IP))
1562 return tcp_v4_do_rcv(sk, skb);
1563
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001564#ifdef CONFIG_TCP_MD5SIG
1565 if (tcp_v6_inbound_md5_hash (sk, skb))
1566 goto discard;
1567#endif
1568
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001569 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 goto discard;
1571
1572 /*
1573 * socket locking is here for SMP purposes as backlog rcv
1574 * is currently called with bh processing disabled.
1575 */
1576
1577 /* Do Stevens' IPV6_PKTOPTIONS.
1578
1579 Yes, guys, it is the only place in our code, where we
1580 may make it not affecting IPv4.
1581 The rest of code is protocol independent,
1582 and I do not like idea to uglify IPv4.
1583
1584 Actually, all the idea behind IPV6_PKTOPTIONS
1585 looks not very well thought. For now we latch
1586 options, received in the last packet, enqueued
1587 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001588 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 */
1590 if (np->rxopt.all)
1591 opt_skb = skb_clone(skb, GFP_ATOMIC);
1592
1593 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1594 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001595 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 goto reset;
1597 TCP_CHECK_TIMER(sk);
1598 if (opt_skb)
1599 goto ipv6_pktoptions;
1600 return 0;
1601 }
1602
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001603 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 goto csum_err;
1605
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001606 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1608 if (!nsk)
1609 goto discard;
1610
1611 /*
1612 * Queue it on the new socket if the new socket is active,
1613 * otherwise we just shortcircuit this and continue with
1614 * the new socket..
1615 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001616 if(nsk != sk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 if (tcp_child_process(sk, nsk, skb))
1618 goto reset;
1619 if (opt_skb)
1620 __kfree_skb(opt_skb);
1621 return 0;
1622 }
1623 }
1624
1625 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001626 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 goto reset;
1628 TCP_CHECK_TIMER(sk);
1629 if (opt_skb)
1630 goto ipv6_pktoptions;
1631 return 0;
1632
1633reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001634 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635discard:
1636 if (opt_skb)
1637 __kfree_skb(opt_skb);
1638 kfree_skb(skb);
1639 return 0;
1640csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001641 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 goto discard;
1643
1644
1645ipv6_pktoptions:
1646 /* Do you ask, what is it?
1647
1648 1. skb was enqueued by tcp.
1649 2. skb is added to tail of read queue, rather than out of order.
1650 3. socket is not in passive state.
1651 4. Finally, it really contains options, which user wants to receive.
1652 */
1653 tp = tcp_sk(sk);
1654 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1655 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001656 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001657 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001658 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001659 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 if (ipv6_opt_accepted(sk, opt_skb)) {
1661 skb_set_owner_r(opt_skb, sk);
1662 opt_skb = xchg(&np->pktoptions, opt_skb);
1663 } else {
1664 __kfree_skb(opt_skb);
1665 opt_skb = xchg(&np->pktoptions, NULL);
1666 }
1667 }
1668
Wei Yongjun800d55f2009-02-23 21:45:33 +00001669 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 return 0;
1671}
1672
Herbert Xue5bbef22007-10-15 12:50:28 -07001673static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674{
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001675 struct tcphdr *th;
Stephen Hemmingere802af92010-04-22 15:24:53 -07001676 struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 struct sock *sk;
1678 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001679 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680
1681 if (skb->pkt_type != PACKET_HOST)
1682 goto discard_it;
1683
1684 /*
1685 * Count it even if it's bad.
1686 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001687 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
1689 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1690 goto discard_it;
1691
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001692 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693
1694 if (th->doff < sizeof(struct tcphdr)/4)
1695 goto bad_packet;
1696 if (!pskb_may_pull(skb, th->doff*4))
1697 goto discard_it;
1698
Herbert Xu60476372007-04-09 11:59:39 -07001699 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 goto bad_packet;
1701
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001702 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001703 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1705 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1706 skb->len - th->doff*4);
1707 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1708 TCP_SKB_CB(skb)->when = 0;
Stephen Hemmingere802af92010-04-22 15:24:53 -07001709 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 TCP_SKB_CB(skb)->sacked = 0;
1711
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001712 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 if (!sk)
1714 goto no_tcp_socket;
1715
1716process:
1717 if (sk->sk_state == TCP_TIME_WAIT)
1718 goto do_time_wait;
1719
Stephen Hemmingere802af92010-04-22 15:24:53 -07001720 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1721 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1722 goto discard_and_relse;
1723 }
1724
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1726 goto discard_and_relse;
1727
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001728 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 goto discard_and_relse;
1730
1731 skb->dev = NULL;
1732
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001733 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 ret = 0;
1735 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001736#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001737 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001738 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001739 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001740 if (tp->ucopy.dma_chan)
1741 ret = tcp_v6_do_rcv(sk, skb);
1742 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001743#endif
1744 {
1745 if (!tcp_prequeue(sk, skb))
1746 ret = tcp_v6_do_rcv(sk, skb);
1747 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001748 } else if (unlikely(sk_add_backlog(sk, skb))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001749 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001750 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001751 goto discard_and_relse;
1752 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 bh_unlock_sock(sk);
1754
1755 sock_put(sk);
1756 return ret ? -1 : 0;
1757
1758no_tcp_socket:
1759 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1760 goto discard_it;
1761
1762 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1763bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001764 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001766 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 }
1768
1769discard_it:
1770
1771 /*
1772 * Discard frame
1773 */
1774
1775 kfree_skb(skb);
1776 return 0;
1777
1778discard_and_relse:
1779 sock_put(sk);
1780 goto discard_it;
1781
1782do_time_wait:
1783 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001784 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 goto discard_it;
1786 }
1787
1788 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001789 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001790 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 goto discard_it;
1792 }
1793
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001794 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 case TCP_TW_SYN:
1796 {
1797 struct sock *sk2;
1798
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001799 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001800 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001801 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001803 struct inet_timewait_sock *tw = inet_twsk(sk);
1804 inet_twsk_deschedule(tw, &tcp_death_row);
1805 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 sk = sk2;
1807 goto process;
1808 }
1809 /* Fall through to ACK */
1810 }
1811 case TCP_TW_ACK:
1812 tcp_v6_timewait_ack(sk, skb);
1813 break;
1814 case TCP_TW_RST:
1815 goto no_tcp_socket;
1816 case TCP_TW_SUCCESS:;
1817 }
1818 goto discard_it;
1819}
1820
David S. Miller3f419d22010-11-29 13:37:14 -08001821struct inet_peer *tcp_v6_get_peer(struct sock *sk, bool *release_it)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822{
1823 /* Alas, not yet... */
David S. Miller3f419d22010-11-29 13:37:14 -08001824 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825}
1826
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001827static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001828 .queue_xmit = inet6_csk_xmit,
1829 .send_check = tcp_v6_send_check,
1830 .rebuild_header = inet6_sk_rebuild_header,
1831 .conn_request = tcp_v6_conn_request,
1832 .syn_recv_sock = tcp_v6_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001833 .get_peer = tcp_v6_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001834 .net_header_len = sizeof(struct ipv6hdr),
1835 .setsockopt = ipv6_setsockopt,
1836 .getsockopt = ipv6_getsockopt,
1837 .addr2sockaddr = inet6_csk_addr2sockaddr,
1838 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001839 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001840#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001841 .compat_setsockopt = compat_ipv6_setsockopt,
1842 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001843#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844};
1845
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001846#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001847static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001848 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001849 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001850 .md5_add = tcp_v6_md5_add_func,
1851 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001852};
David S. Millera9286302006-11-14 19:53:22 -08001853#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001854
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855/*
1856 * TCP over IPv4 via INET6 API
1857 */
1858
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001859static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001860 .queue_xmit = ip_queue_xmit,
1861 .send_check = tcp_v4_send_check,
1862 .rebuild_header = inet_sk_rebuild_header,
1863 .conn_request = tcp_v6_conn_request,
1864 .syn_recv_sock = tcp_v6_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001865 .get_peer = tcp_v4_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001866 .net_header_len = sizeof(struct iphdr),
1867 .setsockopt = ipv6_setsockopt,
1868 .getsockopt = ipv6_getsockopt,
1869 .addr2sockaddr = inet6_csk_addr2sockaddr,
1870 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001871 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001872#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001873 .compat_setsockopt = compat_ipv6_setsockopt,
1874 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001875#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876};
1877
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001878#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001879static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001880 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001881 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001882 .md5_add = tcp_v6_md5_add_func,
1883 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001884};
David S. Millera9286302006-11-14 19:53:22 -08001885#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001886
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887/* NOTE: A lot of things set to zero explicitly by call to
1888 * sk_alloc() so need not be done here.
1889 */
1890static int tcp_v6_init_sock(struct sock *sk)
1891{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001892 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 struct tcp_sock *tp = tcp_sk(sk);
1894
1895 skb_queue_head_init(&tp->out_of_order_queue);
1896 tcp_init_xmit_timers(sk);
1897 tcp_prequeue_init(tp);
1898
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001899 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 tp->mdev = TCP_TIMEOUT_INIT;
1901
1902 /* So many TCP implementations out there (incorrectly) count the
1903 * initial SYN frame in their delayed-ACK and congestion control
1904 * algorithms that we must have the following bandaid to talk
1905 * efficiently to them. -DaveM
1906 */
1907 tp->snd_cwnd = 2;
1908
1909 /* See draft-stevens-tcpca-spec-01 for discussion of the
1910 * initialization of these values.
1911 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001912 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001914 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
1916 tp->reordering = sysctl_tcp_reordering;
1917
1918 sk->sk_state = TCP_CLOSE;
1919
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001920 icsk->icsk_af_ops = &ipv6_specific;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001921 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001922 icsk->icsk_sync_mss = tcp_sync_mss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 sk->sk_write_space = sk_stream_write_space;
1924 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1925
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001926#ifdef CONFIG_TCP_MD5SIG
1927 tp->af_specific = &tcp_sock_ipv6_specific;
1928#endif
1929
William Allen Simpson435cf552009-12-02 18:17:05 +00001930 /* TCP Cookie Transactions */
1931 if (sysctl_tcp_cookie_size > 0) {
1932 /* Default, cookies without s_data_payload. */
1933 tp->cookie_values =
1934 kzalloc(sizeof(*tp->cookie_values),
1935 sk->sk_allocation);
1936 if (tp->cookie_values != NULL)
1937 kref_init(&tp->cookie_values->kref);
1938 }
1939 /* Presumed zeroed, in order of appearance:
1940 * cookie_in_always, cookie_out_never,
1941 * s_data_constant, s_data_in, s_data_out
1942 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1944 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1945
Herbert Xueb4dea52008-12-29 23:04:08 -08001946 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001947 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001948 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949
1950 return 0;
1951}
1952
Brian Haley7d06b2e2008-06-14 17:04:49 -07001953static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001955#ifdef CONFIG_TCP_MD5SIG
1956 /* Clean up the MD5 key list */
1957 if (tcp_sk(sk)->md5sig_info)
1958 tcp_v6_clear_md5_list(sk);
1959#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001961 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962}
1963
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001964#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001966static void get_openreq6(struct seq_file *seq,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001967 struct sock *sk, struct request_sock *req, int i, int uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 int ttd = req->expires - jiffies;
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001970 struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1971 struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
1973 if (ttd < 0)
1974 ttd = 0;
1975
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 seq_printf(seq,
1977 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1978 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1979 i,
1980 src->s6_addr32[0], src->s6_addr32[1],
1981 src->s6_addr32[2], src->s6_addr32[3],
KOVACS Krisztianfd507032008-10-19 23:35:58 -07001982 ntohs(inet_rsk(req)->loc_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 dest->s6_addr32[0], dest->s6_addr32[1],
1984 dest->s6_addr32[2], dest->s6_addr32[3],
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001985 ntohs(inet_rsk(req)->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 TCP_SYN_RECV,
1987 0,0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001988 1, /* timers active (only the expire timer) */
1989 jiffies_to_clock_t(ttd),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 req->retrans,
1991 uid,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001992 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 0, /* open_requests have no inode */
1994 0, req);
1995}
1996
1997static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1998{
1999 struct in6_addr *dest, *src;
2000 __u16 destp, srcp;
2001 int timer_active;
2002 unsigned long timer_expires;
2003 struct inet_sock *inet = inet_sk(sp);
2004 struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002005 const struct inet_connection_sock *icsk = inet_csk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 struct ipv6_pinfo *np = inet6_sk(sp);
2007
2008 dest = &np->daddr;
2009 src = &np->rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002010 destp = ntohs(inet->inet_dport);
2011 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002012
2013 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002015 timer_expires = icsk->icsk_timeout;
2016 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002018 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 } else if (timer_pending(&sp->sk_timer)) {
2020 timer_active = 2;
2021 timer_expires = sp->sk_timer.expires;
2022 } else {
2023 timer_active = 0;
2024 timer_expires = jiffies;
2025 }
2026
2027 seq_printf(seq,
2028 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Stephen Hemminger7be87352008-06-27 20:00:19 -07002029 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %lu %lu %u %u %d\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], srcp,
2033 dest->s6_addr32[0], dest->s6_addr32[1],
2034 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002035 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002036 tp->write_seq-tp->snd_una,
2037 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 timer_active,
2039 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002040 icsk->icsk_retransmits,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 sock_i_uid(sp),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002042 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 sock_i_ino(sp),
2044 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002045 jiffies_to_clock_t(icsk->icsk_rto),
2046 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002047 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002048 tp->snd_cwnd,
2049 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 );
2051}
2052
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002053static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002054 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055{
2056 struct in6_addr *dest, *src;
2057 __u16 destp, srcp;
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08002058 struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 int ttd = tw->tw_ttd - jiffies;
2060
2061 if (ttd < 0)
2062 ttd = 0;
2063
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08002064 dest = &tw6->tw_v6_daddr;
2065 src = &tw6->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 destp = ntohs(tw->tw_dport);
2067 srcp = ntohs(tw->tw_sport);
2068
2069 seq_printf(seq,
2070 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2071 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2072 i,
2073 src->s6_addr32[0], src->s6_addr32[1],
2074 src->s6_addr32[2], src->s6_addr32[3], srcp,
2075 dest->s6_addr32[0], dest->s6_addr32[1],
2076 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2077 tw->tw_substate, 0, 0,
2078 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2079 atomic_read(&tw->tw_refcnt), tw);
2080}
2081
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082static int tcp6_seq_show(struct seq_file *seq, void *v)
2083{
2084 struct tcp_iter_state *st;
2085
2086 if (v == SEQ_START_TOKEN) {
2087 seq_puts(seq,
2088 " sl "
2089 "local_address "
2090 "remote_address "
2091 "st tx_queue rx_queue tr tm->when retrnsmt"
2092 " uid timeout inode\n");
2093 goto out;
2094 }
2095 st = seq->private;
2096
2097 switch (st->state) {
2098 case TCP_SEQ_STATE_LISTENING:
2099 case TCP_SEQ_STATE_ESTABLISHED:
2100 get_tcp6_sock(seq, v, st->num);
2101 break;
2102 case TCP_SEQ_STATE_OPENREQ:
2103 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2104 break;
2105 case TCP_SEQ_STATE_TIME_WAIT:
2106 get_timewait6_sock(seq, v, st->num);
2107 break;
2108 }
2109out:
2110 return 0;
2111}
2112
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 .name = "tcp6",
2115 .family = AF_INET6,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002116 .seq_fops = {
2117 .owner = THIS_MODULE,
2118 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002119 .seq_ops = {
2120 .show = tcp6_seq_show,
2121 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122};
2123
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002124int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002126 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127}
2128
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002129void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002131 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132}
2133#endif
2134
2135struct proto tcpv6_prot = {
2136 .name = "TCPv6",
2137 .owner = THIS_MODULE,
2138 .close = tcp_close,
2139 .connect = tcp_v6_connect,
2140 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002141 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 .ioctl = tcp_ioctl,
2143 .init = tcp_v6_init_sock,
2144 .destroy = tcp_v6_destroy_sock,
2145 .shutdown = tcp_shutdown,
2146 .setsockopt = tcp_setsockopt,
2147 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002149 .sendmsg = tcp_sendmsg,
2150 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 .backlog_rcv = tcp_v6_do_rcv,
2152 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002153 .unhash = inet_unhash,
2154 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 .enter_memory_pressure = tcp_enter_memory_pressure,
2156 .sockets_allocated = &tcp_sockets_allocated,
2157 .memory_allocated = &tcp_memory_allocated,
2158 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002159 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 .sysctl_mem = sysctl_tcp_mem,
2161 .sysctl_wmem = sysctl_tcp_wmem,
2162 .sysctl_rmem = sysctl_tcp_rmem,
2163 .max_header = MAX_TCP_HEADER,
2164 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002165 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002166 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002167 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002168 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002169 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002170#ifdef CONFIG_COMPAT
2171 .compat_setsockopt = compat_tcp_setsockopt,
2172 .compat_getsockopt = compat_tcp_getsockopt,
2173#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174};
2175
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00002176static const struct inet6_protocol tcpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 .handler = tcp_v6_rcv,
2178 .err_handler = tcp_v6_err,
Herbert Xua430a432006-07-08 13:34:56 -07002179 .gso_send_check = tcp_v6_gso_send_check,
Herbert Xuadcfc7d2006-06-30 13:36:15 -07002180 .gso_segment = tcp_tso_segment,
Herbert Xu684f2172009-01-08 10:41:23 -08002181 .gro_receive = tcp6_gro_receive,
2182 .gro_complete = tcp6_gro_complete,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2184};
2185
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186static struct inet_protosw tcpv6_protosw = {
2187 .type = SOCK_STREAM,
2188 .protocol = IPPROTO_TCP,
2189 .prot = &tcpv6_prot,
2190 .ops = &inet6_stream_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 .no_check = 0,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08002192 .flags = INET_PROTOSW_PERMANENT |
2193 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194};
2195
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002196static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002197{
Denis V. Lunev56772422008-04-03 14:28:30 -07002198 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2199 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002200}
2201
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002202static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002203{
Denis V. Lunev56772422008-04-03 14:28:30 -07002204 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002205}
2206
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002207static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002208{
2209 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002210}
2211
2212static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002213 .init = tcpv6_net_init,
2214 .exit = tcpv6_net_exit,
2215 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002216};
2217
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002218int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002220 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08002221
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002222 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2223 if (ret)
2224 goto out;
2225
2226 /* register inet6 protocol */
2227 ret = inet6_register_protosw(&tcpv6_protosw);
2228 if (ret)
2229 goto out_tcpv6_protocol;
2230
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002231 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002232 if (ret)
2233 goto out_tcpv6_protosw;
2234out:
2235 return ret;
2236
2237out_tcpv6_protocol:
2238 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2239out_tcpv6_protosw:
2240 inet6_unregister_protosw(&tcpv6_protosw);
2241 goto out;
2242}
2243
Daniel Lezcano09f77092007-12-13 05:34:58 -08002244void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002245{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002246 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002247 inet6_unregister_protosw(&tcpv6_protosw);
2248 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249}