blob: d849dd53b78810623e62555a85eff50af60d84d1 [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>
41
42#include <linux/ipv6.h>
43#include <linux/icmpv6.h>
44#include <linux/random.h>
45
46#include <net/tcp.h>
47#include <net/ndisc.h>
Arnaldo Carvalho de Melo5324a042005-08-12 09:26:18 -030048#include <net/inet6_hashtables.h>
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -080049#include <net/inet6_connection_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <net/ipv6.h>
51#include <net/transp_v6.h>
52#include <net/addrconf.h>
53#include <net/ip6_route.h>
54#include <net/ip6_checksum.h>
55#include <net/inet_ecn.h>
56#include <net/protocol.h>
57#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <net/snmp.h>
59#include <net/dsfield.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080060#include <net/timewait_sock.h>
Jeff Garzik18134be2007-10-26 22:53:14 -070061#include <net/netdma.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070062#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64#include <asm/uaccess.h>
65
66#include <linux/proc_fs.h>
67#include <linux/seq_file.h>
68
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080069#include <linux/crypto.h>
70#include <linux/scatterlist.h>
71
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080072static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070073static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
74 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -080078static struct inet_connection_sock_af_ops ipv6_mapped;
79static struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080080#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080081static struct tcp_sock_af_ops tcp_sock_ipv6_specific;
82static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090083#else
84static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
85 struct in6_addr *addr)
86{
87 return NULL;
88}
David S. Millera9286302006-11-14 19:53:22 -080089#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Linus Torvalds1da177e2005-04-16 15:20:36 -070091static void tcp_v6_hash(struct sock *sk)
92{
93 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -080094 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 tcp_prot.hash(sk);
96 return;
97 }
98 local_bh_disable();
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -080099 __inet6_hash(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 local_bh_enable();
101 }
102}
103
Herbert Xu684f2172009-01-08 10:41:23 -0800104static __inline__ __sum16 tcp_v6_check(int len,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900105 struct in6_addr *saddr,
106 struct in6_addr *daddr,
Al Viro868c86b2006-11-14 21:35:48 -0800107 __wsum base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108{
109 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
110}
111
Gerrit Renkera94f7232006-11-10 14:06:49 -0800112static __u32 tcp_v6_init_sequence(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700114 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
115 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700116 tcp_hdr(skb)->dest,
117 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
119
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900120static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 int addr_len)
122{
123 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900124 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800125 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 struct ipv6_pinfo *np = inet6_sk(sk);
127 struct tcp_sock *tp = tcp_sk(sk);
128 struct in6_addr *saddr = NULL, *final_p = NULL, final;
129 struct flowi fl;
130 struct dst_entry *dst;
131 int addr_type;
132 int err;
133
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900134 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 return -EINVAL;
136
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900137 if (usin->sin6_family != AF_INET6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 return(-EAFNOSUPPORT);
139
140 memset(&fl, 0, sizeof(fl));
141
142 if (np->sndflow) {
143 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
144 IP6_ECN_flow_init(fl.fl6_flowlabel);
145 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
146 struct ip6_flowlabel *flowlabel;
147 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
148 if (flowlabel == NULL)
149 return -EINVAL;
150 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
151 fl6_sock_release(flowlabel);
152 }
153 }
154
155 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900156 * connect() to INADDR_ANY means loopback (BSD'ism).
157 */
158
159 if(ipv6_addr_any(&usin->sin6_addr))
160 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 addr_type = ipv6_addr_type(&usin->sin6_addr);
163
164 if(addr_type & IPV6_ADDR_MULTICAST)
165 return -ENETUNREACH;
166
167 if (addr_type&IPV6_ADDR_LINKLOCAL) {
168 if (addr_len >= sizeof(struct sockaddr_in6) &&
169 usin->sin6_scope_id) {
170 /* If interface is set while binding, indices
171 * must coincide.
172 */
173 if (sk->sk_bound_dev_if &&
174 sk->sk_bound_dev_if != usin->sin6_scope_id)
175 return -EINVAL;
176
177 sk->sk_bound_dev_if = usin->sin6_scope_id;
178 }
179
180 /* Connect to link-local address requires an interface */
181 if (!sk->sk_bound_dev_if)
182 return -EINVAL;
183 }
184
185 if (tp->rx_opt.ts_recent_stamp &&
186 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
187 tp->rx_opt.ts_recent = 0;
188 tp->rx_opt.ts_recent_stamp = 0;
189 tp->write_seq = 0;
190 }
191
192 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
193 np->flow_label = fl.fl6_flowlabel;
194
195 /*
196 * TCP over IPv4
197 */
198
199 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800200 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 struct sockaddr_in sin;
202
203 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
204
205 if (__ipv6_only_sock(sk))
206 return -ENETUNREACH;
207
208 sin.sin_family = AF_INET;
209 sin.sin_port = usin->sin6_port;
210 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
211
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800212 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800214#ifdef CONFIG_TCP_MD5SIG
215 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
216#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
218 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
219
220 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800221 icsk->icsk_ext_hdr_len = exthdrlen;
222 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800224#ifdef CONFIG_TCP_MD5SIG
225 tp->af_specific = &tcp_sock_ipv6_specific;
226#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 goto failure;
228 } else {
229 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
230 inet->saddr);
231 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
232 inet->rcv_saddr);
233 }
234
235 return err;
236 }
237
238 if (!ipv6_addr_any(&np->rcv_saddr))
239 saddr = &np->rcv_saddr;
240
241 fl.proto = IPPROTO_TCP;
242 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
243 ipv6_addr_copy(&fl.fl6_src,
244 (saddr ? saddr : &np->saddr));
245 fl.oif = sk->sk_bound_dev_if;
246 fl.fl_ip_dport = usin->sin6_port;
247 fl.fl_ip_sport = inet->sport;
248
249 if (np->opt && np->opt->srcrt) {
250 struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
251 ipv6_addr_copy(&final, &fl.fl6_dst);
252 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
253 final_p = &final;
254 }
255
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700256 security_sk_classify_flow(sk, &fl);
257
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 err = ip6_dst_lookup(sk, &dst, &fl);
259 if (err)
260 goto failure;
261 if (final_p)
262 ipv6_addr_copy(&fl.fl6_dst, final_p);
263
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800264 err = __xfrm_lookup(sock_net(sk), &dst, &fl, sk, XFRM_LOOKUP_WAIT);
265 if (err < 0) {
David S. Miller14e50e52007-05-24 18:17:54 -0700266 if (err == -EREMOTE)
267 err = ip6_dst_blackhole(sk, &dst, &fl);
268 if (err < 0)
269 goto failure;
270 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
272 if (saddr == NULL) {
273 saddr = &fl.fl6_src;
274 ipv6_addr_copy(&np->rcv_saddr, saddr);
275 }
276
277 /* set the source address */
278 ipv6_addr_copy(&np->saddr, saddr);
279 inet->rcv_saddr = LOOPBACK4_IPV6;
280
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700281 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700282 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800284 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800286 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
287 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
290
291 inet->dport = usin->sin6_port;
292
293 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800294 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 if (err)
296 goto late_failure;
297
298 if (!tp->write_seq)
299 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
300 np->daddr.s6_addr32,
301 inet->sport,
302 inet->dport);
303
304 err = tcp_connect(sk);
305 if (err)
306 goto late_failure;
307
308 return 0;
309
310late_failure:
311 tcp_set_state(sk, TCP_CLOSE);
312 __sk_dst_reset(sk);
313failure:
314 inet->dport = 0;
315 sk->sk_route_caps = 0;
316 return err;
317}
318
319static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700320 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321{
322 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300323 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 struct ipv6_pinfo *np;
325 struct sock *sk;
326 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900327 struct tcp_sock *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 __u32 seq;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700329 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700331 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800332 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700335 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
336 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 return;
338 }
339
340 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700341 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 return;
343 }
344
345 bh_lock_sock(sk);
346 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700347 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349 if (sk->sk_state == TCP_CLOSE)
350 goto out;
351
352 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900353 seq = ntohl(th->seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 if (sk->sk_state != TCP_LISTEN &&
355 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700356 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 goto out;
358 }
359
360 np = inet6_sk(sk);
361
362 if (type == ICMPV6_PKT_TOOBIG) {
363 struct dst_entry *dst = NULL;
364
365 if (sock_owned_by_user(sk))
366 goto out;
367 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
368 goto out;
369
370 /* icmp should have updated the destination cache entry */
371 dst = __sk_dst_check(sk, np->dst_cookie);
372
373 if (dst == NULL) {
374 struct inet_sock *inet = inet_sk(sk);
375 struct flowi fl;
376
377 /* BUGGG_FUTURE: Again, it is not clear how
378 to handle rthdr case. Ignore this complexity
379 for now.
380 */
381 memset(&fl, 0, sizeof(fl));
382 fl.proto = IPPROTO_TCP;
383 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
384 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
385 fl.oif = sk->sk_bound_dev_if;
386 fl.fl_ip_dport = inet->dport;
387 fl.fl_ip_sport = inet->sport;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700388 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
390 if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
391 sk->sk_err_soft = -err;
392 goto out;
393 }
394
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800395 if ((err = xfrm_lookup(net, &dst, &fl, sk, 0)) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 sk->sk_err_soft = -err;
397 goto out;
398 }
399
400 } else
401 dst_hold(dst);
402
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800403 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 tcp_sync_mss(sk, dst_mtu(dst));
405 tcp_simple_retransmit(sk);
406 } /* else let the usual retransmit timer handle it */
407 dst_release(dst);
408 goto out;
409 }
410
411 icmpv6_err_convert(type, code, &err);
412
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700413 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700415 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 case TCP_LISTEN:
417 if (sock_owned_by_user(sk))
418 goto out;
419
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800420 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
421 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 if (!req)
423 goto out;
424
425 /* ICMPs are not backlogged, hence we cannot get
426 * an established socket here.
427 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700428 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700430 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700431 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 goto out;
433 }
434
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700435 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 goto out;
437
438 case TCP_SYN_SENT:
439 case TCP_SYN_RECV: /* Cannot happen.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900440 It can, it SYNs are crossed. --ANK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 sk->sk_err = err;
443 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
444
445 tcp_done(sk);
446 } else
447 sk->sk_err_soft = err;
448 goto out;
449 }
450
451 if (!sock_owned_by_user(sk) && np->recverr) {
452 sk->sk_err = err;
453 sk->sk_error_report(sk);
454 } else
455 sk->sk_err_soft = err;
456
457out:
458 bh_unlock_sock(sk);
459 sock_put(sk);
460}
461
462
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800463static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800465 struct inet6_request_sock *treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 struct ipv6_pinfo *np = inet6_sk(sk);
467 struct sk_buff * skb;
468 struct ipv6_txoptions *opt = NULL;
469 struct in6_addr * final_p = NULL, final;
470 struct flowi fl;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800471 struct dst_entry *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 int err = -1;
473
474 memset(&fl, 0, sizeof(fl));
475 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700476 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
477 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 fl.fl6_flowlabel = 0;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700479 fl.oif = treq->iif;
480 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
KOVACS Krisztianfd507032008-10-19 23:35:58 -0700481 fl.fl_ip_sport = inet_rsk(req)->loc_port;
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700482 security_req_classify_flow(req, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800484 opt = np->opt;
485 if (opt && opt->srcrt) {
486 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
487 ipv6_addr_copy(&final, &fl.fl6_dst);
488 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
489 final_p = &final;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 }
491
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800492 err = ip6_dst_lookup(sk, &dst, &fl);
493 if (err)
494 goto done;
495 if (final_p)
496 ipv6_addr_copy(&fl.fl6_dst, final_p);
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800497 if ((err = xfrm_lookup(sock_net(sk), &dst, &fl, sk, 0)) < 0)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800498 goto done;
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 skb = tcp_make_synack(sk, dst, req);
501 if (skb) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700502 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Herbert Xu684f2172009-01-08 10:41:23 -0800504 th->check = tcp_v6_check(skb->len,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700505 &treq->loc_addr, &treq->rmt_addr,
Joe Perches07f07572008-11-19 15:44:53 -0800506 csum_partial(th, skb->len, skb->csum));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700508 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 err = ip6_xmit(sk, skb, &fl, opt, 0);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200510 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
512
513done:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900514 if (opt && opt != np->opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 sock_kfree_s(sk, opt, opt->tot_len);
Eric W. Biederman78b91042006-01-31 17:51:44 -0800516 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 return err;
518}
519
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800520static inline void syn_flood_warning(struct sk_buff *skb)
521{
522#ifdef CONFIG_SYN_COOKIES
523 if (sysctl_tcp_syncookies)
524 printk(KERN_INFO
525 "TCPv6: Possible SYN flooding on port %d. "
526 "Sending cookies.\n", ntohs(tcp_hdr(skb)->dest));
527 else
528#endif
529 printk(KERN_INFO
530 "TCPv6: Possible SYN flooding on port %d. "
531 "Dropping request.\n", ntohs(tcp_hdr(skb)->dest));
532}
533
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700534static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
Wei Yongjun800d55f2009-02-23 21:45:33 +0000536 kfree_skb(inet6_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
538
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800539#ifdef CONFIG_TCP_MD5SIG
540static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
541 struct in6_addr *addr)
542{
543 struct tcp_sock *tp = tcp_sk(sk);
544 int i;
545
546 BUG_ON(tp == NULL);
547
548 if (!tp->md5sig_info || !tp->md5sig_info->entries6)
549 return NULL;
550
551 for (i = 0; i < tp->md5sig_info->entries6; i++) {
YOSHIFUJI Hideakicaad2952008-04-10 15:42:07 +0900552 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, addr))
David S. Millerf8ab18d2007-09-28 15:18:35 -0700553 return &tp->md5sig_info->keys6[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800554 }
555 return NULL;
556}
557
558static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
559 struct sock *addr_sk)
560{
561 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
562}
563
564static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
565 struct request_sock *req)
566{
567 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
568}
569
570static int tcp_v6_md5_do_add(struct sock *sk, struct in6_addr *peer,
571 char *newkey, u8 newkeylen)
572{
573 /* Add key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700574 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800575 struct tcp_sock *tp = tcp_sk(sk);
576 struct tcp6_md5sig_key *keys;
577
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700578 key = tcp_v6_md5_do_lookup(sk, peer);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800579 if (key) {
580 /* modify existing entry - just update that one */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700581 kfree(key->key);
582 key->key = newkey;
583 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800584 } else {
585 /* reallocate new list if current one is full. */
586 if (!tp->md5sig_info) {
587 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
588 if (!tp->md5sig_info) {
589 kfree(newkey);
590 return -ENOMEM;
591 }
David S. Miller3d7dbea2007-06-12 14:36:42 -0700592 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800593 }
YOSHIFUJI Hideakiaacbe8c2007-11-20 17:30:56 -0800594 if (tcp_alloc_md5sig_pool() == NULL) {
595 kfree(newkey);
596 return -ENOMEM;
597 }
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800598 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
599 keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
600 (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
601
602 if (!keys) {
603 tcp_free_md5sig_pool();
604 kfree(newkey);
605 return -ENOMEM;
606 }
607
608 if (tp->md5sig_info->entries6)
609 memmove(keys, tp->md5sig_info->keys6,
610 (sizeof (tp->md5sig_info->keys6[0]) *
611 tp->md5sig_info->entries6));
612
613 kfree(tp->md5sig_info->keys6);
614 tp->md5sig_info->keys6 = keys;
615 tp->md5sig_info->alloced6++;
616 }
617
618 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
619 peer);
David S. Millerf8ab18d2007-09-28 15:18:35 -0700620 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.key = newkey;
621 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800622
623 tp->md5sig_info->entries6++;
624 }
625 return 0;
626}
627
628static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
629 u8 *newkey, __u8 newkeylen)
630{
631 return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
632 newkey, newkeylen);
633}
634
635static int tcp_v6_md5_do_del(struct sock *sk, struct in6_addr *peer)
636{
637 struct tcp_sock *tp = tcp_sk(sk);
638 int i;
639
640 for (i = 0; i < tp->md5sig_info->entries6; i++) {
YOSHIFUJI Hideakicaad2952008-04-10 15:42:07 +0900641 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, peer)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800642 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700643 kfree(tp->md5sig_info->keys6[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800644 tp->md5sig_info->entries6--;
645
646 if (tp->md5sig_info->entries6 == 0) {
647 kfree(tp->md5sig_info->keys6);
648 tp->md5sig_info->keys6 = NULL;
YOSHIFUJI Hideakica983ce2007-07-24 15:27:30 -0700649 tp->md5sig_info->alloced6 = 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800650 } else {
651 /* shrink the database */
652 if (tp->md5sig_info->entries6 != i)
653 memmove(&tp->md5sig_info->keys6[i],
654 &tp->md5sig_info->keys6[i+1],
655 (tp->md5sig_info->entries6 - i)
656 * sizeof (tp->md5sig_info->keys6[0]));
657 }
YOSHIFUJI Hideaki77adefd2007-11-20 17:31:23 -0800658 tcp_free_md5sig_pool();
659 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800660 }
661 }
662 return -ENOENT;
663}
664
665static void tcp_v6_clear_md5_list (struct sock *sk)
666{
667 struct tcp_sock *tp = tcp_sk(sk);
668 int i;
669
670 if (tp->md5sig_info->entries6) {
671 for (i = 0; i < tp->md5sig_info->entries6; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700672 kfree(tp->md5sig_info->keys6[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800673 tp->md5sig_info->entries6 = 0;
674 tcp_free_md5sig_pool();
675 }
676
677 kfree(tp->md5sig_info->keys6);
678 tp->md5sig_info->keys6 = NULL;
679 tp->md5sig_info->alloced6 = 0;
680
681 if (tp->md5sig_info->entries4) {
682 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700683 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800684 tp->md5sig_info->entries4 = 0;
685 tcp_free_md5sig_pool();
686 }
687
688 kfree(tp->md5sig_info->keys4);
689 tp->md5sig_info->keys4 = NULL;
690 tp->md5sig_info->alloced4 = 0;
691}
692
693static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
694 int optlen)
695{
696 struct tcp_md5sig cmd;
697 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
698 u8 *newkey;
699
700 if (optlen < sizeof(cmd))
701 return -EINVAL;
702
703 if (copy_from_user(&cmd, optval, sizeof(cmd)))
704 return -EFAULT;
705
706 if (sin6->sin6_family != AF_INET6)
707 return -EINVAL;
708
709 if (!cmd.tcpm_keylen) {
710 if (!tcp_sk(sk)->md5sig_info)
711 return -ENOENT;
Brian Haleye773e4f2007-08-24 23:16:08 -0700712 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800713 return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
714 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
715 }
716
717 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
718 return -EINVAL;
719
720 if (!tcp_sk(sk)->md5sig_info) {
721 struct tcp_sock *tp = tcp_sk(sk);
722 struct tcp_md5sig_info *p;
723
724 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
725 if (!p)
726 return -ENOMEM;
727
728 tp->md5sig_info = p;
David S. Miller3d7dbea2007-06-12 14:36:42 -0700729 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800730 }
731
Arnaldo Carvalho de Meloaf879cc2006-11-17 12:14:37 -0200732 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800733 if (!newkey)
734 return -ENOMEM;
Brian Haleye773e4f2007-08-24 23:16:08 -0700735 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800736 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
737 newkey, cmd.tcpm_keylen);
738 }
739 return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
740}
741
Adam Langley49a72df2008-07-19 00:01:42 -0700742static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
743 struct in6_addr *daddr,
744 struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800745{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800746 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700747 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900748
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800749 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800750 /* 1. TCP pseudo-header (RFC2460) */
751 ipv6_addr_copy(&bp->saddr, saddr);
752 ipv6_addr_copy(&bp->daddr, daddr);
Adam Langley49a72df2008-07-19 00:01:42 -0700753 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700754 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800755
Adam Langley49a72df2008-07-19 00:01:42 -0700756 sg_init_one(&sg, bp, sizeof(*bp));
757 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
758}
David S. Millerc7da57a2007-10-26 00:41:21 -0700759
Adam Langley49a72df2008-07-19 00:01:42 -0700760static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
761 struct in6_addr *daddr, struct in6_addr *saddr,
762 struct tcphdr *th)
763{
764 struct tcp_md5sig_pool *hp;
765 struct hash_desc *desc;
766
767 hp = tcp_get_md5sig_pool();
768 if (!hp)
769 goto clear_hash_noput;
770 desc = &hp->md5_desc;
771
772 if (crypto_hash_init(desc))
773 goto clear_hash;
774 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
775 goto clear_hash;
776 if (tcp_md5_hash_header(hp, th))
777 goto clear_hash;
778 if (tcp_md5_hash_key(hp, key))
779 goto clear_hash;
780 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800781 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800782
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800783 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800784 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700785
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800786clear_hash:
787 tcp_put_md5sig_pool();
788clear_hash_noput:
789 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700790 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800791}
792
Adam Langley49a72df2008-07-19 00:01:42 -0700793static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
794 struct sock *sk, struct request_sock *req,
795 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800796{
797 struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700798 struct tcp_md5sig_pool *hp;
799 struct hash_desc *desc;
800 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800801
802 if (sk) {
803 saddr = &inet6_sk(sk)->saddr;
804 daddr = &inet6_sk(sk)->daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700805 } else if (req) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800806 saddr = &inet6_rsk(req)->loc_addr;
807 daddr = &inet6_rsk(req)->rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700808 } else {
809 struct ipv6hdr *ip6h = ipv6_hdr(skb);
810 saddr = &ip6h->saddr;
811 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800812 }
Adam Langley49a72df2008-07-19 00:01:42 -0700813
814 hp = tcp_get_md5sig_pool();
815 if (!hp)
816 goto clear_hash_noput;
817 desc = &hp->md5_desc;
818
819 if (crypto_hash_init(desc))
820 goto clear_hash;
821
822 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
823 goto clear_hash;
824 if (tcp_md5_hash_header(hp, th))
825 goto clear_hash;
826 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
827 goto clear_hash;
828 if (tcp_md5_hash_key(hp, key))
829 goto clear_hash;
830 if (crypto_hash_final(desc, md5_hash))
831 goto clear_hash;
832
833 tcp_put_md5sig_pool();
834 return 0;
835
836clear_hash:
837 tcp_put_md5sig_pool();
838clear_hash_noput:
839 memset(md5_hash, 0, 16);
840 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800841}
842
843static int tcp_v6_inbound_md5_hash (struct sock *sk, struct sk_buff *skb)
844{
845 __u8 *hash_location = NULL;
846 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700847 struct ipv6hdr *ip6h = ipv6_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700848 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800849 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800850 u8 newhash[16];
851
852 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900853 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800854
David S. Miller785957d2008-07-30 03:03:15 -0700855 /* We've parsed the options - do we have a hash? */
856 if (!hash_expected && !hash_location)
857 return 0;
858
859 if (hash_expected && !hash_location) {
860 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800861 return 1;
862 }
863
David S. Miller785957d2008-07-30 03:03:15 -0700864 if (!hash_expected && hash_location) {
865 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800866 return 1;
867 }
868
869 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700870 genhash = tcp_v6_md5_hash_skb(newhash,
871 hash_expected,
872 NULL, NULL, skb);
873
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800874 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
875 if (net_ratelimit()) {
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700876 printk(KERN_INFO "MD5 Hash %s for (%pI6, %u)->(%pI6, %u)\n",
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800877 genhash ? "failed" : "mismatch",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700878 &ip6h->saddr, ntohs(th->source),
879 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800880 }
881 return 1;
882 }
883 return 0;
884}
885#endif
886
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800887struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700889 .obj_size = sizeof(struct tcp6_request_sock),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 .rtx_syn_ack = tcp_v6_send_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700891 .send_ack = tcp_v6_reqsk_send_ack,
892 .destructor = tcp_v6_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 .send_reset = tcp_v6_send_reset
894};
895
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800896#ifdef CONFIG_TCP_MD5SIG
Andrew Mortonb6332e62006-11-30 19:16:28 -0800897static struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800898 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000899 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800900};
Andrew Mortonb6332e62006-11-30 19:16:28 -0800901#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800902
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800903static struct timewait_sock_ops tcp6_timewait_sock_ops = {
904 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
905 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800906 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800907};
908
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800909static void tcp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910{
911 struct ipv6_pinfo *np = inet6_sk(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700912 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Patrick McHardy84fa7932006-08-29 16:44:56 -0700914 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700916 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800917 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 } else {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900919 th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
Joe Perches07f07572008-11-19 15:44:53 -0800920 csum_partial(th, th->doff<<2,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 skb->csum));
922 }
923}
924
Herbert Xua430a432006-07-08 13:34:56 -0700925static int tcp_v6_gso_send_check(struct sk_buff *skb)
926{
927 struct ipv6hdr *ipv6h;
928 struct tcphdr *th;
929
930 if (!pskb_may_pull(skb, sizeof(*th)))
931 return -EINVAL;
932
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700933 ipv6h = ipv6_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700934 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700935
936 th->check = 0;
937 th->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr, skb->len,
938 IPPROTO_TCP, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700939 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800940 skb->csum_offset = offsetof(struct tcphdr, check);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700941 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xua430a432006-07-08 13:34:56 -0700942 return 0;
943}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
Herbert Xu36990672009-05-22 00:45:28 -0700945static struct sk_buff **tcp6_gro_receive(struct sk_buff **head,
946 struct sk_buff *skb)
Herbert Xu684f2172009-01-08 10:41:23 -0800947{
Herbert Xu36e7b1b2009-04-27 05:44:45 -0700948 struct ipv6hdr *iph = skb_gro_network_header(skb);
Herbert Xu684f2172009-01-08 10:41:23 -0800949
950 switch (skb->ip_summed) {
951 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +0000952 if (!tcp_v6_check(skb_gro_len(skb), &iph->saddr, &iph->daddr,
Herbert Xu684f2172009-01-08 10:41:23 -0800953 skb->csum)) {
954 skb->ip_summed = CHECKSUM_UNNECESSARY;
955 break;
956 }
957
958 /* fall through */
959 case CHECKSUM_NONE:
960 NAPI_GRO_CB(skb)->flush = 1;
961 return NULL;
962 }
963
964 return tcp_gro_receive(head, skb);
965}
Herbert Xu684f2172009-01-08 10:41:23 -0800966
Herbert Xu36990672009-05-22 00:45:28 -0700967static int tcp6_gro_complete(struct sk_buff *skb)
Herbert Xu684f2172009-01-08 10:41:23 -0800968{
969 struct ipv6hdr *iph = ipv6_hdr(skb);
970 struct tcphdr *th = tcp_hdr(skb);
971
972 th->check = ~tcp_v6_check(skb->len - skb_transport_offset(skb),
973 &iph->saddr, &iph->daddr, 0);
974 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
975
976 return tcp_gro_complete(skb);
977}
Herbert Xu684f2172009-01-08 10:41:23 -0800978
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700979static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
980 u32 ts, struct tcp_md5sig_key *key, int rst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700982 struct tcphdr *th = tcp_hdr(skb), *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 struct sk_buff *buff;
984 struct flowi fl;
Eric Dumazetadf30902009-06-02 05:19:30 +0000985 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800986 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800987 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000988 struct dst_entry *dst;
Al Viroe69a4ad2006-11-14 20:56:00 -0800989 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991 if (ts)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700992 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800993#ifdef CONFIG_TCP_MD5SIG
994 if (key)
995 tot_len += TCPOLEN_MD5SIG_ALIGNED;
996#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
998 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
999 GFP_ATOMIC);
1000 if (buff == NULL)
1001 return;
1002
1003 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1004
Ilpo Järvinen77c676d2008-10-09 14:41:38 -07001005 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006
1007 /* Swap the send and the receive. */
1008 memset(t1, 0, sizeof(*t1));
1009 t1->dest = th->source;
1010 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -07001011 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 t1->seq = htonl(seq);
1013 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001014 t1->ack = !rst || !th->ack;
1015 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001017
Al Viroe69a4ad2006-11-14 20:56:00 -08001018 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001019
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001021 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1022 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1023 *topt++ = htonl(tcp_time_stamp);
Ilpo Järvinen53b12572008-10-08 14:36:33 -07001024 *topt++ = htonl(ts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 }
1026
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001027#ifdef CONFIG_TCP_MD5SIG
1028 if (key) {
1029 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1030 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -07001031 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -07001032 &ipv6_hdr(skb)->saddr,
1033 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001034 }
1035#endif
1036
Joe Perches07f07572008-11-19 15:44:53 -08001037 buff->csum = csum_partial(t1, tot_len, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
1039 memset(&fl, 0, sizeof(fl));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001040 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
1041 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042
1043 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1044 tot_len, IPPROTO_TCP,
1045 buff->csum);
1046
1047 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001048 fl.oif = inet6_iif(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 fl.fl_ip_dport = t1->dest;
1050 fl.fl_ip_sport = t1->source;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001051 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001053 /* Pass a socket to ip6_dst_lookup either it is for RST
1054 * Underlying function will use this to retrieve the network
1055 * namespace
1056 */
Eric Dumazetadf30902009-06-02 05:19:30 +00001057 if (!ip6_dst_lookup(ctl_sk, &dst, &fl)) {
1058 if (xfrm_lookup(net, &dst, &fl, NULL, 0) >= 0) {
1059 skb_dst_set(buff, dst);
Daniel Lezcanoe5047992008-03-07 11:16:26 -08001060 ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001061 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001062 if (rst)
1063 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 return;
Arnaldo Carvalho de Meloecc51b62005-12-12 14:38:10 -08001065 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 }
1067
1068 kfree_skb(buff);
1069}
1070
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001071static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
1072{
1073 struct tcphdr *th = tcp_hdr(skb);
1074 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -07001075 struct tcp_md5sig_key *key = NULL;
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001076
1077 if (th->rst)
1078 return;
1079
1080 if (!ipv6_unicast_destination(skb))
1081 return;
1082
1083#ifdef CONFIG_TCP_MD5SIG
1084 if (sk)
1085 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
Ilpo Järvinen626e2642008-10-09 14:42:40 -07001086#endif
1087
1088 if (th->ack)
1089 seq = ntohl(th->ack_seq);
1090 else
1091 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
1092 (th->doff << 2);
1093
1094 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, key, 1);
1095}
1096
1097static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts,
1098 struct tcp_md5sig_key *key)
1099{
1100 tcp_v6_send_response(skb, seq, ack, win, ts, key, 0);
1101}
1102
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1104{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001105 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001106 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001108 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001109 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001110 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001112 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113}
1114
Gui Jianfeng6edafaa2008-08-06 23:50:04 -07001115static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
1116 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001118 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 -07001119 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120}
1121
1122
1123static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1124{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001125 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001126 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 struct sock *nsk;
1128
1129 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -08001130 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001131 &ipv6_hdr(skb)->saddr,
1132 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 if (req)
1134 return tcp_check_req(sk, skb, req, prev);
1135
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001136 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -08001137 &ipv6_hdr(skb)->saddr, th->source,
1138 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
1140 if (nsk) {
1141 if (nsk->sk_state != TCP_TIME_WAIT) {
1142 bh_lock_sock(nsk);
1143 return nsk;
1144 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001145 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 return NULL;
1147 }
1148
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001149#ifdef CONFIG_SYN_COOKIES
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 if (!th->rst && !th->syn && th->ack)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001151 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152#endif
1153 return sk;
1154}
1155
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156/* FIXME: this is substantially similar to the ipv4 code.
1157 * Can some kind of merge be done? -- erics
1158 */
1159static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1160{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001161 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 struct ipv6_pinfo *np = inet6_sk(sk);
1163 struct tcp_options_received tmp_opt;
1164 struct tcp_sock *tp = tcp_sk(sk);
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001165 struct request_sock *req = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 __u32 isn = TCP_SKB_CB(skb)->when;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001167#ifdef CONFIG_SYN_COOKIES
1168 int want_cookie = 0;
1169#else
1170#define want_cookie 0
1171#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
1173 if (skb->protocol == htons(ETH_P_IP))
1174 return tcp_v4_conn_request(sk, skb);
1175
1176 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001177 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001179 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 if (net_ratelimit())
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001181 syn_flood_warning(skb);
1182#ifdef CONFIG_SYN_COOKIES
1183 if (sysctl_tcp_syncookies)
1184 want_cookie = 1;
1185 else
1186#endif
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001187 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 }
1189
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001190 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 goto drop;
1192
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001193 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 if (req == NULL)
1195 goto drop;
1196
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001197#ifdef CONFIG_TCP_MD5SIG
1198 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1199#endif
1200
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 tcp_clear_options(&tmp_opt);
1202 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1203 tmp_opt.user_mss = tp->rx_opt.user_mss;
1204
1205 tcp_parse_options(skb, &tmp_opt, 0);
1206
Florian Westphal4dfc2812008-04-10 03:12:40 -07001207 if (want_cookie && !tmp_opt.saw_tstamp)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001208 tcp_clear_options(&tmp_opt);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001209
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1211 tcp_openreq_init(req, &tmp_opt, skb);
1212
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001213 treq = inet6_rsk(req);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001214 ipv6_addr_copy(&treq->rmt_addr, &ipv6_hdr(skb)->saddr);
1215 ipv6_addr_copy(&treq->loc_addr, &ipv6_hdr(skb)->daddr);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001216 if (!want_cookie)
1217 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001219 if (want_cookie) {
1220 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
Florian Westphal4dfc2812008-04-10 03:12:40 -07001221 req->cookie_ts = tmp_opt.tstamp_ok;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001222 } else if (!isn) {
1223 if (ipv6_opt_accepted(sk, skb) ||
1224 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1225 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1226 atomic_inc(&skb->users);
1227 treq->pktopts = skb;
1228 }
1229 treq->iif = sk->sk_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001231 /* So that link locals have meaning */
1232 if (!sk->sk_bound_dev_if &&
1233 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1234 treq->iif = inet6_iif(skb);
1235
Gerrit Renkera94f7232006-11-10 14:06:49 -08001236 isn = tcp_v6_init_sequence(skb);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001237 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001239 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001241 security_inet_conn_request(sk, skb, req);
1242
Denis V. Lunevfd80eb92008-02-29 11:43:03 -08001243 if (tcp_v6_send_synack(sk, req))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 goto drop;
1245
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001246 if (!want_cookie) {
1247 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1248 return 0;
1249 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250
1251drop:
1252 if (req)
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001253 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 return 0; /* don't send reset */
1256}
1257
1258static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001259 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 struct dst_entry *dst)
1261{
Vegard Nossum78d15e82008-09-12 16:17:43 -07001262 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1264 struct tcp6_sock *newtcp6sk;
1265 struct inet_sock *newinet;
1266 struct tcp_sock *newtp;
1267 struct sock *newsk;
1268 struct ipv6_txoptions *opt;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001269#ifdef CONFIG_TCP_MD5SIG
1270 struct tcp_md5sig_key *key;
1271#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
1273 if (skb->protocol == htons(ETH_P_IP)) {
1274 /*
1275 * v6 mapped
1276 */
1277
1278 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1279
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001280 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 return NULL;
1282
1283 newtcp6sk = (struct tcp6_sock *)newsk;
1284 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1285
1286 newinet = inet_sk(newsk);
1287 newnp = inet6_sk(newsk);
1288 newtp = tcp_sk(newsk);
1289
1290 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1291
1292 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
1293 newinet->daddr);
1294
1295 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
1296 newinet->saddr);
1297
1298 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1299
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001300 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001302#ifdef CONFIG_TCP_MD5SIG
1303 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1304#endif
1305
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 newnp->pktoptions = NULL;
1307 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001308 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001309 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001311 /*
1312 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1313 * here, tcp_create_openreq_child now does this for us, see the comment in
1314 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
1317 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001318 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 Sync it now.
1320 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001321 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322
1323 return newsk;
1324 }
1325
Vegard Nossum78d15e82008-09-12 16:17:43 -07001326 treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 opt = np->opt;
1328
1329 if (sk_acceptq_is_full(sk))
1330 goto out_overflow;
1331
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 if (dst == NULL) {
1333 struct in6_addr *final_p = NULL, final;
1334 struct flowi fl;
1335
1336 memset(&fl, 0, sizeof(fl));
1337 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001338 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 if (opt && opt->srcrt) {
1340 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
1341 ipv6_addr_copy(&final, &fl.fl6_dst);
1342 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1343 final_p = &final;
1344 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001345 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 fl.oif = sk->sk_bound_dev_if;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001347 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
KOVACS Krisztianfd507032008-10-19 23:35:58 -07001348 fl.fl_ip_sport = inet_rsk(req)->loc_port;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001349 security_req_classify_flow(req, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
1351 if (ip6_dst_lookup(sk, &dst, &fl))
1352 goto out;
1353
1354 if (final_p)
1355 ipv6_addr_copy(&fl.fl6_dst, final_p);
1356
Alexey Dobriyan52479b62008-11-25 17:35:18 -08001357 if ((xfrm_lookup(sock_net(sk), &dst, &fl, sk, 0)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001359 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
1361 newsk = tcp_create_openreq_child(sk, req, skb);
1362 if (newsk == NULL)
1363 goto out;
1364
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001365 /*
1366 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1367 * count here, tcp_create_openreq_child now does this for us, see the
1368 * comment in that function for the gory details. -acme
1369 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Stephen Hemminger59eed272006-08-25 15:55:43 -07001371 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001372 __ip6_dst_store(newsk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373
1374 newtcp6sk = (struct tcp6_sock *)newsk;
1375 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1376
1377 newtp = tcp_sk(newsk);
1378 newinet = inet_sk(newsk);
1379 newnp = inet6_sk(newsk);
1380
1381 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1382
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001383 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1384 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1385 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1386 newsk->sk_bound_dev_if = treq->iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001388 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
1390 First: no IPv4 options.
1391 */
1392 newinet->opt = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001393 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
1395 /* Clone RX bits */
1396 newnp->rxopt.all = np->rxopt.all;
1397
1398 /* Clone pktoptions received with SYN */
1399 newnp->pktoptions = NULL;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001400 if (treq->pktopts != NULL) {
1401 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1402 kfree_skb(treq->pktopts);
1403 treq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 if (newnp->pktoptions)
1405 skb_set_owner_r(newnp->pktoptions, newsk);
1406 }
1407 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001408 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001409 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
1411 /* Clone native IPv6 options from listening socket (if any)
1412
1413 Yes, keeping reference count would be much more clever,
1414 but we make one more one thing there: reattach optmem
1415 to newsk.
1416 */
1417 if (opt) {
1418 newnp->opt = ipv6_dup_options(newsk, opt);
1419 if (opt != np->opt)
1420 sock_kfree_s(sk, opt, opt->tot_len);
1421 }
1422
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001423 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001425 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1426 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427
John Heffner5d424d52006-03-20 17:53:41 -08001428 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 tcp_sync_mss(newsk, dst_mtu(dst));
1430 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1431 tcp_initialize_rcv_mss(newsk);
1432
1433 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
1434
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001435#ifdef CONFIG_TCP_MD5SIG
1436 /* Copy over the MD5 key from the original socket */
1437 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1438 /* We're using one, so create a matching key
1439 * on the newsk structure. If we fail to get
1440 * memory, then we end up not copying the key
1441 * across. Shucks.
1442 */
Arnaldo Carvalho de Meloaf879cc2006-11-17 12:14:37 -02001443 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1444 if (newkey != NULL)
John Dykstrae547bc12009-07-17 09:23:22 +00001445 tcp_v6_md5_do_add(newsk, &newnp->daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001446 newkey, key->keylen);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001447 }
1448#endif
1449
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001450 __inet6_hash(newsk);
Pavel Emelyanove56d8b82008-04-17 23:17:34 -07001451 __inet_inherit_port(sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452
1453 return newsk;
1454
1455out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001456 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457out:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001458 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 if (opt && opt != np->opt)
1460 sock_kfree_s(sk, opt, opt->tot_len);
1461 dst_release(dst);
1462 return NULL;
1463}
1464
Al Virob51655b2006-11-14 21:40:42 -08001465static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001467 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Herbert Xu684f2172009-01-08 10:41:23 -08001468 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001469 &ipv6_hdr(skb)->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001470 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001472 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001474
Herbert Xu684f2172009-01-08 10:41:23 -08001475 skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001476 &ipv6_hdr(skb)->saddr,
1477 &ipv6_hdr(skb)->daddr, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -08001478
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001480 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 }
1482 return 0;
1483}
1484
1485/* The socket must have it's spinlock held when we get
1486 * here.
1487 *
1488 * We have a potential double-lock case here, so even when
1489 * doing backlog processing we use the BH locking scheme.
1490 * This is because we cannot sleep with the original spinlock
1491 * held.
1492 */
1493static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1494{
1495 struct ipv6_pinfo *np = inet6_sk(sk);
1496 struct tcp_sock *tp;
1497 struct sk_buff *opt_skb = NULL;
1498
1499 /* Imagine: socket is IPv6. IPv4 packet arrives,
1500 goes to IPv4 receive handler and backlogged.
1501 From backlog it always goes here. Kerboom...
1502 Fortunately, tcp_rcv_established and rcv_established
1503 handle them correctly, but it is not case with
1504 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1505 */
1506
1507 if (skb->protocol == htons(ETH_P_IP))
1508 return tcp_v4_do_rcv(sk, skb);
1509
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001510#ifdef CONFIG_TCP_MD5SIG
1511 if (tcp_v6_inbound_md5_hash (sk, skb))
1512 goto discard;
1513#endif
1514
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001515 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 goto discard;
1517
1518 /*
1519 * socket locking is here for SMP purposes as backlog rcv
1520 * is currently called with bh processing disabled.
1521 */
1522
1523 /* Do Stevens' IPV6_PKTOPTIONS.
1524
1525 Yes, guys, it is the only place in our code, where we
1526 may make it not affecting IPv4.
1527 The rest of code is protocol independent,
1528 and I do not like idea to uglify IPv4.
1529
1530 Actually, all the idea behind IPV6_PKTOPTIONS
1531 looks not very well thought. For now we latch
1532 options, received in the last packet, enqueued
1533 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001534 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 */
1536 if (np->rxopt.all)
1537 opt_skb = skb_clone(skb, GFP_ATOMIC);
1538
1539 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1540 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001541 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 goto reset;
1543 TCP_CHECK_TIMER(sk);
1544 if (opt_skb)
1545 goto ipv6_pktoptions;
1546 return 0;
1547 }
1548
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001549 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 goto csum_err;
1551
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001552 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1554 if (!nsk)
1555 goto discard;
1556
1557 /*
1558 * Queue it on the new socket if the new socket is active,
1559 * otherwise we just shortcircuit this and continue with
1560 * the new socket..
1561 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001562 if(nsk != sk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 if (tcp_child_process(sk, nsk, skb))
1564 goto reset;
1565 if (opt_skb)
1566 __kfree_skb(opt_skb);
1567 return 0;
1568 }
1569 }
1570
1571 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001572 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 goto reset;
1574 TCP_CHECK_TIMER(sk);
1575 if (opt_skb)
1576 goto ipv6_pktoptions;
1577 return 0;
1578
1579reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001580 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581discard:
1582 if (opt_skb)
1583 __kfree_skb(opt_skb);
1584 kfree_skb(skb);
1585 return 0;
1586csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001587 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 goto discard;
1589
1590
1591ipv6_pktoptions:
1592 /* Do you ask, what is it?
1593
1594 1. skb was enqueued by tcp.
1595 2. skb is added to tail of read queue, rather than out of order.
1596 3. socket is not in passive state.
1597 4. Finally, it really contains options, which user wants to receive.
1598 */
1599 tp = tcp_sk(sk);
1600 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1601 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001602 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001603 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001604 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001605 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 if (ipv6_opt_accepted(sk, opt_skb)) {
1607 skb_set_owner_r(opt_skb, sk);
1608 opt_skb = xchg(&np->pktoptions, opt_skb);
1609 } else {
1610 __kfree_skb(opt_skb);
1611 opt_skb = xchg(&np->pktoptions, NULL);
1612 }
1613 }
1614
Wei Yongjun800d55f2009-02-23 21:45:33 +00001615 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 return 0;
1617}
1618
Herbert Xue5bbef22007-10-15 12:50:28 -07001619static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620{
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001621 struct tcphdr *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 struct sock *sk;
1623 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001624 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
1626 if (skb->pkt_type != PACKET_HOST)
1627 goto discard_it;
1628
1629 /*
1630 * Count it even if it's bad.
1631 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001632 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
1634 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1635 goto discard_it;
1636
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001637 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
1639 if (th->doff < sizeof(struct tcphdr)/4)
1640 goto bad_packet;
1641 if (!pskb_may_pull(skb, th->doff*4))
1642 goto discard_it;
1643
Herbert Xu60476372007-04-09 11:59:39 -07001644 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 goto bad_packet;
1646
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001647 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1649 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1650 skb->len - th->doff*4);
1651 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1652 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001653 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 TCP_SKB_CB(skb)->sacked = 0;
1655
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001656 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 if (!sk)
1658 goto no_tcp_socket;
1659
1660process:
1661 if (sk->sk_state == TCP_TIME_WAIT)
1662 goto do_time_wait;
1663
1664 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1665 goto discard_and_relse;
1666
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001667 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 goto discard_and_relse;
1669
1670 skb->dev = NULL;
1671
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001672 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 ret = 0;
1674 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001675#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001676 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001677 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001678 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001679 if (tp->ucopy.dma_chan)
1680 ret = tcp_v6_do_rcv(sk, skb);
1681 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001682#endif
1683 {
1684 if (!tcp_prequeue(sk, skb))
1685 ret = tcp_v6_do_rcv(sk, skb);
1686 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 } else
1688 sk_add_backlog(sk, skb);
1689 bh_unlock_sock(sk);
1690
1691 sock_put(sk);
1692 return ret ? -1 : 0;
1693
1694no_tcp_socket:
1695 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1696 goto discard_it;
1697
1698 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1699bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001700 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001702 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 }
1704
1705discard_it:
1706
1707 /*
1708 * Discard frame
1709 */
1710
1711 kfree_skb(skb);
1712 return 0;
1713
1714discard_and_relse:
1715 sock_put(sk);
1716 goto discard_it;
1717
1718do_time_wait:
1719 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001720 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 goto discard_it;
1722 }
1723
1724 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001725 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001726 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 goto discard_it;
1728 }
1729
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001730 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 case TCP_TW_SYN:
1732 {
1733 struct sock *sk2;
1734
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001735 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001736 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001737 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001739 struct inet_timewait_sock *tw = inet_twsk(sk);
1740 inet_twsk_deschedule(tw, &tcp_death_row);
1741 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 sk = sk2;
1743 goto process;
1744 }
1745 /* Fall through to ACK */
1746 }
1747 case TCP_TW_ACK:
1748 tcp_v6_timewait_ack(sk, skb);
1749 break;
1750 case TCP_TW_RST:
1751 goto no_tcp_socket;
1752 case TCP_TW_SUCCESS:;
1753 }
1754 goto discard_it;
1755}
1756
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757static int tcp_v6_remember_stamp(struct sock *sk)
1758{
1759 /* Alas, not yet... */
1760 return 0;
1761}
1762
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001763static struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001764 .queue_xmit = inet6_csk_xmit,
1765 .send_check = tcp_v6_send_check,
1766 .rebuild_header = inet6_sk_rebuild_header,
1767 .conn_request = tcp_v6_conn_request,
1768 .syn_recv_sock = tcp_v6_syn_recv_sock,
1769 .remember_stamp = tcp_v6_remember_stamp,
1770 .net_header_len = sizeof(struct ipv6hdr),
1771 .setsockopt = ipv6_setsockopt,
1772 .getsockopt = ipv6_getsockopt,
1773 .addr2sockaddr = inet6_csk_addr2sockaddr,
1774 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001775 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001776#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001777 .compat_setsockopt = compat_ipv6_setsockopt,
1778 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001779#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780};
1781
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001782#ifdef CONFIG_TCP_MD5SIG
David S. Millera9286302006-11-14 19:53:22 -08001783static struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001784 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001785 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001786 .md5_add = tcp_v6_md5_add_func,
1787 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001788};
David S. Millera9286302006-11-14 19:53:22 -08001789#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001790
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791/*
1792 * TCP over IPv4 via INET6 API
1793 */
1794
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001795static struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001796 .queue_xmit = ip_queue_xmit,
1797 .send_check = tcp_v4_send_check,
1798 .rebuild_header = inet_sk_rebuild_header,
1799 .conn_request = tcp_v6_conn_request,
1800 .syn_recv_sock = tcp_v6_syn_recv_sock,
1801 .remember_stamp = tcp_v4_remember_stamp,
1802 .net_header_len = sizeof(struct iphdr),
1803 .setsockopt = ipv6_setsockopt,
1804 .getsockopt = ipv6_getsockopt,
1805 .addr2sockaddr = inet6_csk_addr2sockaddr,
1806 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001807 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001808#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001809 .compat_setsockopt = compat_ipv6_setsockopt,
1810 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001811#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812};
1813
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001814#ifdef CONFIG_TCP_MD5SIG
David S. Millera9286302006-11-14 19:53:22 -08001815static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001816 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001817 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001818 .md5_add = tcp_v6_md5_add_func,
1819 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001820};
David S. Millera9286302006-11-14 19:53:22 -08001821#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001822
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823/* NOTE: A lot of things set to zero explicitly by call to
1824 * sk_alloc() so need not be done here.
1825 */
1826static int tcp_v6_init_sock(struct sock *sk)
1827{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001828 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 struct tcp_sock *tp = tcp_sk(sk);
1830
1831 skb_queue_head_init(&tp->out_of_order_queue);
1832 tcp_init_xmit_timers(sk);
1833 tcp_prequeue_init(tp);
1834
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001835 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 tp->mdev = TCP_TIMEOUT_INIT;
1837
1838 /* So many TCP implementations out there (incorrectly) count the
1839 * initial SYN frame in their delayed-ACK and congestion control
1840 * algorithms that we must have the following bandaid to talk
1841 * efficiently to them. -DaveM
1842 */
1843 tp->snd_cwnd = 2;
1844
1845 /* See draft-stevens-tcpca-spec-01 for discussion of the
1846 * initialization of these values.
1847 */
1848 tp->snd_ssthresh = 0x7fffffff;
1849 tp->snd_cwnd_clamp = ~0;
David S. Millerc1b4a7e2005-07-05 15:24:38 -07001850 tp->mss_cache = 536;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851
1852 tp->reordering = sysctl_tcp_reordering;
1853
1854 sk->sk_state = TCP_CLOSE;
1855
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001856 icsk->icsk_af_ops = &ipv6_specific;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001857 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001858 icsk->icsk_sync_mss = tcp_sync_mss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 sk->sk_write_space = sk_stream_write_space;
1860 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1861
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001862#ifdef CONFIG_TCP_MD5SIG
1863 tp->af_specific = &tcp_sock_ipv6_specific;
1864#endif
1865
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1867 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1868
Herbert Xueb4dea52008-12-29 23:04:08 -08001869 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001870 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001871 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872
1873 return 0;
1874}
1875
Brian Haley7d06b2e2008-06-14 17:04:49 -07001876static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001878#ifdef CONFIG_TCP_MD5SIG
1879 /* Clean up the MD5 key list */
1880 if (tcp_sk(sk)->md5sig_info)
1881 tcp_v6_clear_md5_list(sk);
1882#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001884 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885}
1886
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001887#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001889static void get_openreq6(struct seq_file *seq,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001890 struct sock *sk, struct request_sock *req, int i, int uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 int ttd = req->expires - jiffies;
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001893 struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1894 struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
1896 if (ttd < 0)
1897 ttd = 0;
1898
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 seq_printf(seq,
1900 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1901 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1902 i,
1903 src->s6_addr32[0], src->s6_addr32[1],
1904 src->s6_addr32[2], src->s6_addr32[3],
KOVACS Krisztianfd507032008-10-19 23:35:58 -07001905 ntohs(inet_rsk(req)->loc_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 dest->s6_addr32[0], dest->s6_addr32[1],
1907 dest->s6_addr32[2], dest->s6_addr32[3],
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001908 ntohs(inet_rsk(req)->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 TCP_SYN_RECV,
1910 0,0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001911 1, /* timers active (only the expire timer) */
1912 jiffies_to_clock_t(ttd),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 req->retrans,
1914 uid,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001915 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 0, /* open_requests have no inode */
1917 0, req);
1918}
1919
1920static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1921{
1922 struct in6_addr *dest, *src;
1923 __u16 destp, srcp;
1924 int timer_active;
1925 unsigned long timer_expires;
1926 struct inet_sock *inet = inet_sk(sp);
1927 struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001928 const struct inet_connection_sock *icsk = inet_csk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 struct ipv6_pinfo *np = inet6_sk(sp);
1930
1931 dest = &np->daddr;
1932 src = &np->rcv_saddr;
1933 destp = ntohs(inet->dport);
1934 srcp = ntohs(inet->sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001935
1936 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001938 timer_expires = icsk->icsk_timeout;
1939 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001941 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 } else if (timer_pending(&sp->sk_timer)) {
1943 timer_active = 2;
1944 timer_expires = sp->sk_timer.expires;
1945 } else {
1946 timer_active = 0;
1947 timer_expires = jiffies;
1948 }
1949
1950 seq_printf(seq,
1951 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Stephen Hemminger7be87352008-06-27 20:00:19 -07001952 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 i,
1954 src->s6_addr32[0], src->s6_addr32[1],
1955 src->s6_addr32[2], src->s6_addr32[3], srcp,
1956 dest->s6_addr32[0], dest->s6_addr32[1],
1957 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001958 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001959 tp->write_seq-tp->snd_una,
1960 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 timer_active,
1962 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001963 icsk->icsk_retransmits,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 sock_i_uid(sp),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001965 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 sock_i_ino(sp),
1967 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001968 jiffies_to_clock_t(icsk->icsk_rto),
1969 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001970 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
1972 );
1973}
1974
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001975static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001976 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977{
1978 struct in6_addr *dest, *src;
1979 __u16 destp, srcp;
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08001980 struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 int ttd = tw->tw_ttd - jiffies;
1982
1983 if (ttd < 0)
1984 ttd = 0;
1985
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08001986 dest = &tw6->tw_v6_daddr;
1987 src = &tw6->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 destp = ntohs(tw->tw_dport);
1989 srcp = ntohs(tw->tw_sport);
1990
1991 seq_printf(seq,
1992 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1993 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1994 i,
1995 src->s6_addr32[0], src->s6_addr32[1],
1996 src->s6_addr32[2], src->s6_addr32[3], srcp,
1997 dest->s6_addr32[0], dest->s6_addr32[1],
1998 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1999 tw->tw_substate, 0, 0,
2000 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2001 atomic_read(&tw->tw_refcnt), tw);
2002}
2003
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004static int tcp6_seq_show(struct seq_file *seq, void *v)
2005{
2006 struct tcp_iter_state *st;
2007
2008 if (v == SEQ_START_TOKEN) {
2009 seq_puts(seq,
2010 " sl "
2011 "local_address "
2012 "remote_address "
2013 "st tx_queue rx_queue tr tm->when retrnsmt"
2014 " uid timeout inode\n");
2015 goto out;
2016 }
2017 st = seq->private;
2018
2019 switch (st->state) {
2020 case TCP_SEQ_STATE_LISTENING:
2021 case TCP_SEQ_STATE_ESTABLISHED:
2022 get_tcp6_sock(seq, v, st->num);
2023 break;
2024 case TCP_SEQ_STATE_OPENREQ:
2025 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2026 break;
2027 case TCP_SEQ_STATE_TIME_WAIT:
2028 get_timewait6_sock(seq, v, st->num);
2029 break;
2030 }
2031out:
2032 return 0;
2033}
2034
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 .name = "tcp6",
2037 .family = AF_INET6,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002038 .seq_fops = {
2039 .owner = THIS_MODULE,
2040 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002041 .seq_ops = {
2042 .show = tcp6_seq_show,
2043 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044};
2045
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002046int tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002048 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049}
2050
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002051void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002053 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054}
2055#endif
2056
2057struct proto tcpv6_prot = {
2058 .name = "TCPv6",
2059 .owner = THIS_MODULE,
2060 .close = tcp_close,
2061 .connect = tcp_v6_connect,
2062 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002063 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 .ioctl = tcp_ioctl,
2065 .init = tcp_v6_init_sock,
2066 .destroy = tcp_v6_destroy_sock,
2067 .shutdown = tcp_shutdown,
2068 .setsockopt = tcp_setsockopt,
2069 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 .recvmsg = tcp_recvmsg,
2071 .backlog_rcv = tcp_v6_do_rcv,
2072 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002073 .unhash = inet_unhash,
2074 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 .enter_memory_pressure = tcp_enter_memory_pressure,
2076 .sockets_allocated = &tcp_sockets_allocated,
2077 .memory_allocated = &tcp_memory_allocated,
2078 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002079 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 .sysctl_mem = sysctl_tcp_mem,
2081 .sysctl_wmem = sysctl_tcp_wmem,
2082 .sysctl_rmem = sysctl_tcp_rmem,
2083 .max_header = MAX_TCP_HEADER,
2084 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002085 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002086 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002087 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002088 .h.hashinfo = &tcp_hashinfo,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002089#ifdef CONFIG_COMPAT
2090 .compat_setsockopt = compat_tcp_setsockopt,
2091 .compat_getsockopt = compat_tcp_getsockopt,
2092#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093};
2094
2095static struct inet6_protocol tcpv6_protocol = {
2096 .handler = tcp_v6_rcv,
2097 .err_handler = tcp_v6_err,
Herbert Xua430a432006-07-08 13:34:56 -07002098 .gso_send_check = tcp_v6_gso_send_check,
Herbert Xuadcfc7d2006-06-30 13:36:15 -07002099 .gso_segment = tcp_tso_segment,
Herbert Xu684f2172009-01-08 10:41:23 -08002100 .gro_receive = tcp6_gro_receive,
2101 .gro_complete = tcp6_gro_complete,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2103};
2104
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105static struct inet_protosw tcpv6_protosw = {
2106 .type = SOCK_STREAM,
2107 .protocol = IPPROTO_TCP,
2108 .prot = &tcpv6_prot,
2109 .ops = &inet6_stream_ops,
2110 .capability = -1,
2111 .no_check = 0,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08002112 .flags = INET_PROTOSW_PERMANENT |
2113 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114};
2115
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002116static int tcpv6_net_init(struct net *net)
2117{
Denis V. Lunev56772422008-04-03 14:28:30 -07002118 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2119 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002120}
2121
2122static void tcpv6_net_exit(struct net *net)
2123{
Denis V. Lunev56772422008-04-03 14:28:30 -07002124 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Daniel Lezcanod3154922008-09-08 13:17:27 -07002125 inet_twsk_purge(net, &tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002126}
2127
2128static struct pernet_operations tcpv6_net_ops = {
2129 .init = tcpv6_net_init,
2130 .exit = tcpv6_net_exit,
2131};
2132
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002133int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002135 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08002136
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002137 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2138 if (ret)
2139 goto out;
2140
2141 /* register inet6 protocol */
2142 ret = inet6_register_protosw(&tcpv6_protosw);
2143 if (ret)
2144 goto out_tcpv6_protocol;
2145
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002146 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002147 if (ret)
2148 goto out_tcpv6_protosw;
2149out:
2150 return ret;
2151
2152out_tcpv6_protocol:
2153 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2154out_tcpv6_protosw:
2155 inet6_unregister_protosw(&tcpv6_protosw);
2156 goto out;
2157}
2158
Daniel Lezcano09f77092007-12-13 05:34:58 -08002159void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002160{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002161 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002162 inet6_unregister_protosw(&tcpv6_protosw);
2163 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164}