blob: b585c850a89a3737b1b6a19aab62dd7dd1cee5cb [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
26#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/errno.h>
28#include <linux/types.h>
29#include <linux/socket.h>
30#include <linux/sockios.h>
31#include <linux/net.h>
32#include <linux/jiffies.h>
33#include <linux/in.h>
34#include <linux/in6.h>
35#include <linux/netdevice.h>
36#include <linux/init.h>
37#include <linux/jhash.h>
38#include <linux/ipsec.h>
39#include <linux/times.h>
40
41#include <linux/ipv6.h>
42#include <linux/icmpv6.h>
43#include <linux/random.h>
44
45#include <net/tcp.h>
46#include <net/ndisc.h>
Arnaldo Carvalho de Melo5324a042005-08-12 09:26:18 -030047#include <net/inet6_hashtables.h>
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -080048#include <net/inet6_connection_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <net/ipv6.h>
50#include <net/transp_v6.h>
51#include <net/addrconf.h>
52#include <net/ip6_route.h>
53#include <net/ip6_checksum.h>
54#include <net/inet_ecn.h>
55#include <net/protocol.h>
56#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include <net/snmp.h>
58#include <net/dsfield.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080059#include <net/timewait_sock.h>
Jeff Garzik18134be2007-10-26 22:53:14 -070060#include <net/netdma.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070061#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63#include <asm/uaccess.h>
64
65#include <linux/proc_fs.h>
66#include <linux/seq_file.h>
67
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080068#include <linux/crypto.h>
69#include <linux/scatterlist.h>
70
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080071static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070072static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
73 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -080077static struct inet_connection_sock_af_ops ipv6_mapped;
78static struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080079#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080080static struct tcp_sock_af_ops tcp_sock_ipv6_specific;
81static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090082#else
83static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
84 struct in6_addr *addr)
85{
86 return NULL;
87}
David S. Millera9286302006-11-14 19:53:22 -080088#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Linus Torvalds1da177e2005-04-16 15:20:36 -070090static void tcp_v6_hash(struct sock *sk)
91{
92 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -080093 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 tcp_prot.hash(sk);
95 return;
96 }
97 local_bh_disable();
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -080098 __inet6_hash(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 local_bh_enable();
100 }
101}
102
Al Viro868c86b2006-11-14 21:35:48 -0800103static __inline__ __sum16 tcp_v6_check(struct tcphdr *th, int len,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900104 struct in6_addr *saddr,
105 struct in6_addr *daddr,
Al Viro868c86b2006-11-14 21:35:48 -0800106 __wsum base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
108 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
109}
110
Gerrit Renkera94f7232006-11-10 14:06:49 -0800111static __u32 tcp_v6_init_sequence(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700113 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
114 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700115 tcp_hdr(skb)->dest,
116 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117}
118
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900119static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 int addr_len)
121{
122 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900123 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800124 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 struct ipv6_pinfo *np = inet6_sk(sk);
126 struct tcp_sock *tp = tcp_sk(sk);
127 struct in6_addr *saddr = NULL, *final_p = NULL, final;
128 struct flowi fl;
129 struct dst_entry *dst;
130 int addr_type;
131 int err;
132
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900133 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 return -EINVAL;
135
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900136 if (usin->sin6_family != AF_INET6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 return(-EAFNOSUPPORT);
138
139 memset(&fl, 0, sizeof(fl));
140
141 if (np->sndflow) {
142 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
143 IP6_ECN_flow_init(fl.fl6_flowlabel);
144 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
145 struct ip6_flowlabel *flowlabel;
146 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
147 if (flowlabel == NULL)
148 return -EINVAL;
149 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
150 fl6_sock_release(flowlabel);
151 }
152 }
153
154 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900155 * connect() to INADDR_ANY means loopback (BSD'ism).
156 */
157
158 if(ipv6_addr_any(&usin->sin6_addr))
159 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161 addr_type = ipv6_addr_type(&usin->sin6_addr);
162
163 if(addr_type & IPV6_ADDR_MULTICAST)
164 return -ENETUNREACH;
165
166 if (addr_type&IPV6_ADDR_LINKLOCAL) {
167 if (addr_len >= sizeof(struct sockaddr_in6) &&
168 usin->sin6_scope_id) {
169 /* If interface is set while binding, indices
170 * must coincide.
171 */
172 if (sk->sk_bound_dev_if &&
173 sk->sk_bound_dev_if != usin->sin6_scope_id)
174 return -EINVAL;
175
176 sk->sk_bound_dev_if = usin->sin6_scope_id;
177 }
178
179 /* Connect to link-local address requires an interface */
180 if (!sk->sk_bound_dev_if)
181 return -EINVAL;
182 }
183
184 if (tp->rx_opt.ts_recent_stamp &&
185 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
186 tp->rx_opt.ts_recent = 0;
187 tp->rx_opt.ts_recent_stamp = 0;
188 tp->write_seq = 0;
189 }
190
191 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
192 np->flow_label = fl.fl6_flowlabel;
193
194 /*
195 * TCP over IPv4
196 */
197
198 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800199 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 struct sockaddr_in sin;
201
202 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
203
204 if (__ipv6_only_sock(sk))
205 return -ENETUNREACH;
206
207 sin.sin_family = AF_INET;
208 sin.sin_port = usin->sin6_port;
209 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
210
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800211 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800213#ifdef CONFIG_TCP_MD5SIG
214 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
215#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
217 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
218
219 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800220 icsk->icsk_ext_hdr_len = exthdrlen;
221 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800223#ifdef CONFIG_TCP_MD5SIG
224 tp->af_specific = &tcp_sock_ipv6_specific;
225#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 goto failure;
227 } else {
228 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
229 inet->saddr);
230 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
231 inet->rcv_saddr);
232 }
233
234 return err;
235 }
236
237 if (!ipv6_addr_any(&np->rcv_saddr))
238 saddr = &np->rcv_saddr;
239
240 fl.proto = IPPROTO_TCP;
241 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
242 ipv6_addr_copy(&fl.fl6_src,
243 (saddr ? saddr : &np->saddr));
244 fl.oif = sk->sk_bound_dev_if;
245 fl.fl_ip_dport = usin->sin6_port;
246 fl.fl_ip_sport = inet->sport;
247
248 if (np->opt && np->opt->srcrt) {
249 struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
250 ipv6_addr_copy(&final, &fl.fl6_dst);
251 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
252 final_p = &final;
253 }
254
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700255 security_sk_classify_flow(sk, &fl);
256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 err = ip6_dst_lookup(sk, &dst, &fl);
258 if (err)
259 goto failure;
260 if (final_p)
261 ipv6_addr_copy(&fl.fl6_dst, final_p);
262
Herbert Xubb728452007-12-12 18:48:58 -0800263 if ((err = __xfrm_lookup(&dst, &fl, sk, XFRM_LOOKUP_WAIT)) < 0) {
David S. Miller14e50e52007-05-24 18:17:54 -0700264 if (err == -EREMOTE)
265 err = ip6_dst_blackhole(sk, &dst, &fl);
266 if (err < 0)
267 goto failure;
268 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 if (saddr == NULL) {
271 saddr = &fl.fl6_src;
272 ipv6_addr_copy(&np->rcv_saddr, saddr);
273 }
274
275 /* set the source address */
276 ipv6_addr_copy(&np->saddr, saddr);
277 inet->rcv_saddr = LOOPBACK4_IPV6;
278
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700279 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700280 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800282 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800284 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
285 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
288
289 inet->dport = usin->sin6_port;
290
291 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800292 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 if (err)
294 goto late_failure;
295
296 if (!tp->write_seq)
297 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
298 np->daddr.s6_addr32,
299 inet->sport,
300 inet->dport);
301
302 err = tcp_connect(sk);
303 if (err)
304 goto late_failure;
305
306 return 0;
307
308late_failure:
309 tcp_set_state(sk, TCP_CLOSE);
310 __sk_dst_reset(sk);
311failure:
312 inet->dport = 0;
313 sk->sk_route_caps = 0;
314 return err;
315}
316
317static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Al Viro04ce6902006-11-08 00:21:01 -0800318 int type, int code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319{
320 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300321 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 struct ipv6_pinfo *np;
323 struct sock *sk;
324 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900325 struct tcp_sock *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 __u32 seq;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700327 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700329 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800330 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
332 if (sk == NULL) {
333 ICMP6_INC_STATS_BH(__in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
334 return;
335 }
336
337 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700338 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 return;
340 }
341
342 bh_lock_sock(sk);
343 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700344 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346 if (sk->sk_state == TCP_CLOSE)
347 goto out;
348
349 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900350 seq = ntohl(th->seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 if (sk->sk_state != TCP_LISTEN &&
352 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700353 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 goto out;
355 }
356
357 np = inet6_sk(sk);
358
359 if (type == ICMPV6_PKT_TOOBIG) {
360 struct dst_entry *dst = NULL;
361
362 if (sock_owned_by_user(sk))
363 goto out;
364 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
365 goto out;
366
367 /* icmp should have updated the destination cache entry */
368 dst = __sk_dst_check(sk, np->dst_cookie);
369
370 if (dst == NULL) {
371 struct inet_sock *inet = inet_sk(sk);
372 struct flowi fl;
373
374 /* BUGGG_FUTURE: Again, it is not clear how
375 to handle rthdr case. Ignore this complexity
376 for now.
377 */
378 memset(&fl, 0, sizeof(fl));
379 fl.proto = IPPROTO_TCP;
380 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
381 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
382 fl.oif = sk->sk_bound_dev_if;
383 fl.fl_ip_dport = inet->dport;
384 fl.fl_ip_sport = inet->sport;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700385 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
387 if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
388 sk->sk_err_soft = -err;
389 goto out;
390 }
391
392 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
393 sk->sk_err_soft = -err;
394 goto out;
395 }
396
397 } else
398 dst_hold(dst);
399
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800400 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 tcp_sync_mss(sk, dst_mtu(dst));
402 tcp_simple_retransmit(sk);
403 } /* else let the usual retransmit timer handle it */
404 dst_release(dst);
405 goto out;
406 }
407
408 icmpv6_err_convert(type, code, &err);
409
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700410 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700412 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 case TCP_LISTEN:
414 if (sock_owned_by_user(sk))
415 goto out;
416
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800417 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
418 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 if (!req)
420 goto out;
421
422 /* ICMPs are not backlogged, hence we cannot get
423 * an established socket here.
424 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700425 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700427 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700428 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 goto out;
430 }
431
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700432 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 goto out;
434
435 case TCP_SYN_SENT:
436 case TCP_SYN_RECV: /* Cannot happen.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900437 It can, it SYNs are crossed. --ANK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 sk->sk_err = err;
440 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
441
442 tcp_done(sk);
443 } else
444 sk->sk_err_soft = err;
445 goto out;
446 }
447
448 if (!sock_owned_by_user(sk) && np->recverr) {
449 sk->sk_err = err;
450 sk->sk_error_report(sk);
451 } else
452 sk->sk_err_soft = err;
453
454out:
455 bh_unlock_sock(sk);
456 sock_put(sk);
457}
458
459
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800460static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800462 struct inet6_request_sock *treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 struct ipv6_pinfo *np = inet6_sk(sk);
464 struct sk_buff * skb;
465 struct ipv6_txoptions *opt = NULL;
466 struct in6_addr * final_p = NULL, final;
467 struct flowi fl;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800468 struct dst_entry *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 int err = -1;
470
471 memset(&fl, 0, sizeof(fl));
472 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700473 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
474 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 fl.fl6_flowlabel = 0;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700476 fl.oif = treq->iif;
477 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 fl.fl_ip_sport = inet_sk(sk)->sport;
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700479 security_req_classify_flow(req, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800481 opt = np->opt;
482 if (opt && opt->srcrt) {
483 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
484 ipv6_addr_copy(&final, &fl.fl6_dst);
485 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
486 final_p = &final;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 }
488
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800489 err = ip6_dst_lookup(sk, &dst, &fl);
490 if (err)
491 goto done;
492 if (final_p)
493 ipv6_addr_copy(&fl.fl6_dst, final_p);
494 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
495 goto done;
496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 skb = tcp_make_synack(sk, dst, req);
498 if (skb) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700499 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 th->check = tcp_v6_check(th, skb->len,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700502 &treq->loc_addr, &treq->rmt_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 csum_partial((char *)th, skb->len, skb->csum));
504
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700505 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 err = ip6_xmit(sk, skb, &fl, opt, 0);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200507 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
509
510done:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900511 if (opt && opt != np->opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 sock_kfree_s(sk, opt, opt->tot_len);
Eric W. Biederman78b91042006-01-31 17:51:44 -0800513 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 return err;
515}
516
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800517static inline void syn_flood_warning(struct sk_buff *skb)
518{
519#ifdef CONFIG_SYN_COOKIES
520 if (sysctl_tcp_syncookies)
521 printk(KERN_INFO
522 "TCPv6: Possible SYN flooding on port %d. "
523 "Sending cookies.\n", ntohs(tcp_hdr(skb)->dest));
524 else
525#endif
526 printk(KERN_INFO
527 "TCPv6: Possible SYN flooding on port %d. "
528 "Dropping request.\n", ntohs(tcp_hdr(skb)->dest));
529}
530
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700531static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800533 if (inet6_rsk(req)->pktopts)
534 kfree_skb(inet6_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535}
536
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800537#ifdef CONFIG_TCP_MD5SIG
538static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
539 struct in6_addr *addr)
540{
541 struct tcp_sock *tp = tcp_sk(sk);
542 int i;
543
544 BUG_ON(tp == NULL);
545
546 if (!tp->md5sig_info || !tp->md5sig_info->entries6)
547 return NULL;
548
549 for (i = 0; i < tp->md5sig_info->entries6; i++) {
YOSHIFUJI Hideakicaad2952008-04-10 15:42:07 +0900550 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, addr))
David S. Millerf8ab18d2007-09-28 15:18:35 -0700551 return &tp->md5sig_info->keys6[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800552 }
553 return NULL;
554}
555
556static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
557 struct sock *addr_sk)
558{
559 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
560}
561
562static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
563 struct request_sock *req)
564{
565 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
566}
567
568static int tcp_v6_md5_do_add(struct sock *sk, struct in6_addr *peer,
569 char *newkey, u8 newkeylen)
570{
571 /* Add key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700572 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800573 struct tcp_sock *tp = tcp_sk(sk);
574 struct tcp6_md5sig_key *keys;
575
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700576 key = tcp_v6_md5_do_lookup(sk, peer);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800577 if (key) {
578 /* modify existing entry - just update that one */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700579 kfree(key->key);
580 key->key = newkey;
581 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800582 } else {
583 /* reallocate new list if current one is full. */
584 if (!tp->md5sig_info) {
585 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
586 if (!tp->md5sig_info) {
587 kfree(newkey);
588 return -ENOMEM;
589 }
David S. Miller3d7dbea2007-06-12 14:36:42 -0700590 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800591 }
YOSHIFUJI Hideakiaacbe8c2007-11-20 17:30:56 -0800592 if (tcp_alloc_md5sig_pool() == NULL) {
593 kfree(newkey);
594 return -ENOMEM;
595 }
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800596 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
597 keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
598 (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
599
600 if (!keys) {
601 tcp_free_md5sig_pool();
602 kfree(newkey);
603 return -ENOMEM;
604 }
605
606 if (tp->md5sig_info->entries6)
607 memmove(keys, tp->md5sig_info->keys6,
608 (sizeof (tp->md5sig_info->keys6[0]) *
609 tp->md5sig_info->entries6));
610
611 kfree(tp->md5sig_info->keys6);
612 tp->md5sig_info->keys6 = keys;
613 tp->md5sig_info->alloced6++;
614 }
615
616 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
617 peer);
David S. Millerf8ab18d2007-09-28 15:18:35 -0700618 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.key = newkey;
619 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800620
621 tp->md5sig_info->entries6++;
622 }
623 return 0;
624}
625
626static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
627 u8 *newkey, __u8 newkeylen)
628{
629 return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
630 newkey, newkeylen);
631}
632
633static int tcp_v6_md5_do_del(struct sock *sk, struct in6_addr *peer)
634{
635 struct tcp_sock *tp = tcp_sk(sk);
636 int i;
637
638 for (i = 0; i < tp->md5sig_info->entries6; i++) {
YOSHIFUJI Hideakicaad2952008-04-10 15:42:07 +0900639 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, peer)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800640 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700641 kfree(tp->md5sig_info->keys6[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800642 tp->md5sig_info->entries6--;
643
644 if (tp->md5sig_info->entries6 == 0) {
645 kfree(tp->md5sig_info->keys6);
646 tp->md5sig_info->keys6 = NULL;
YOSHIFUJI Hideakica983ce2007-07-24 15:27:30 -0700647 tp->md5sig_info->alloced6 = 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800648 } else {
649 /* shrink the database */
650 if (tp->md5sig_info->entries6 != i)
651 memmove(&tp->md5sig_info->keys6[i],
652 &tp->md5sig_info->keys6[i+1],
653 (tp->md5sig_info->entries6 - i)
654 * sizeof (tp->md5sig_info->keys6[0]));
655 }
YOSHIFUJI Hideaki77adefd2007-11-20 17:31:23 -0800656 tcp_free_md5sig_pool();
657 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800658 }
659 }
660 return -ENOENT;
661}
662
663static void tcp_v6_clear_md5_list (struct sock *sk)
664{
665 struct tcp_sock *tp = tcp_sk(sk);
666 int i;
667
668 if (tp->md5sig_info->entries6) {
669 for (i = 0; i < tp->md5sig_info->entries6; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700670 kfree(tp->md5sig_info->keys6[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800671 tp->md5sig_info->entries6 = 0;
672 tcp_free_md5sig_pool();
673 }
674
675 kfree(tp->md5sig_info->keys6);
676 tp->md5sig_info->keys6 = NULL;
677 tp->md5sig_info->alloced6 = 0;
678
679 if (tp->md5sig_info->entries4) {
680 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700681 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800682 tp->md5sig_info->entries4 = 0;
683 tcp_free_md5sig_pool();
684 }
685
686 kfree(tp->md5sig_info->keys4);
687 tp->md5sig_info->keys4 = NULL;
688 tp->md5sig_info->alloced4 = 0;
689}
690
691static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
692 int optlen)
693{
694 struct tcp_md5sig cmd;
695 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
696 u8 *newkey;
697
698 if (optlen < sizeof(cmd))
699 return -EINVAL;
700
701 if (copy_from_user(&cmd, optval, sizeof(cmd)))
702 return -EFAULT;
703
704 if (sin6->sin6_family != AF_INET6)
705 return -EINVAL;
706
707 if (!cmd.tcpm_keylen) {
708 if (!tcp_sk(sk)->md5sig_info)
709 return -ENOENT;
Brian Haleye773e4f2007-08-24 23:16:08 -0700710 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800711 return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
712 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
713 }
714
715 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
716 return -EINVAL;
717
718 if (!tcp_sk(sk)->md5sig_info) {
719 struct tcp_sock *tp = tcp_sk(sk);
720 struct tcp_md5sig_info *p;
721
722 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
723 if (!p)
724 return -ENOMEM;
725
726 tp->md5sig_info = p;
David S. Miller3d7dbea2007-06-12 14:36:42 -0700727 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800728 }
729
Arnaldo Carvalho de Meloaf879cc2006-11-17 12:14:37 -0200730 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800731 if (!newkey)
732 return -ENOMEM;
Brian Haleye773e4f2007-08-24 23:16:08 -0700733 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800734 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
735 newkey, cmd.tcpm_keylen);
736 }
737 return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
738}
739
Adam Langley49a72df2008-07-19 00:01:42 -0700740static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
741 struct in6_addr *daddr,
742 struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800743{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800744 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700745 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900746
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800747 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800748 /* 1. TCP pseudo-header (RFC2460) */
749 ipv6_addr_copy(&bp->saddr, saddr);
750 ipv6_addr_copy(&bp->daddr, daddr);
Adam Langley49a72df2008-07-19 00:01:42 -0700751 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700752 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800753
Adam Langley49a72df2008-07-19 00:01:42 -0700754 sg_init_one(&sg, bp, sizeof(*bp));
755 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
756}
David S. Millerc7da57a2007-10-26 00:41:21 -0700757
Adam Langley49a72df2008-07-19 00:01:42 -0700758static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
759 struct in6_addr *daddr, struct in6_addr *saddr,
760 struct tcphdr *th)
761{
762 struct tcp_md5sig_pool *hp;
763 struct hash_desc *desc;
764
765 hp = tcp_get_md5sig_pool();
766 if (!hp)
767 goto clear_hash_noput;
768 desc = &hp->md5_desc;
769
770 if (crypto_hash_init(desc))
771 goto clear_hash;
772 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
773 goto clear_hash;
774 if (tcp_md5_hash_header(hp, th))
775 goto clear_hash;
776 if (tcp_md5_hash_key(hp, key))
777 goto clear_hash;
778 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800779 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800780
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800781 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800782 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700783
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800784clear_hash:
785 tcp_put_md5sig_pool();
786clear_hash_noput:
787 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700788 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800789}
790
Adam Langley49a72df2008-07-19 00:01:42 -0700791static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
792 struct sock *sk, struct request_sock *req,
793 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800794{
795 struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700796 struct tcp_md5sig_pool *hp;
797 struct hash_desc *desc;
798 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800799
800 if (sk) {
801 saddr = &inet6_sk(sk)->saddr;
802 daddr = &inet6_sk(sk)->daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700803 } else if (req) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800804 saddr = &inet6_rsk(req)->loc_addr;
805 daddr = &inet6_rsk(req)->rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700806 } else {
807 struct ipv6hdr *ip6h = ipv6_hdr(skb);
808 saddr = &ip6h->saddr;
809 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800810 }
Adam Langley49a72df2008-07-19 00:01:42 -0700811
812 hp = tcp_get_md5sig_pool();
813 if (!hp)
814 goto clear_hash_noput;
815 desc = &hp->md5_desc;
816
817 if (crypto_hash_init(desc))
818 goto clear_hash;
819
820 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
821 goto clear_hash;
822 if (tcp_md5_hash_header(hp, th))
823 goto clear_hash;
824 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
825 goto clear_hash;
826 if (tcp_md5_hash_key(hp, key))
827 goto clear_hash;
828 if (crypto_hash_final(desc, md5_hash))
829 goto clear_hash;
830
831 tcp_put_md5sig_pool();
832 return 0;
833
834clear_hash:
835 tcp_put_md5sig_pool();
836clear_hash_noput:
837 memset(md5_hash, 0, 16);
838 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800839}
840
841static int tcp_v6_inbound_md5_hash (struct sock *sk, struct sk_buff *skb)
842{
843 __u8 *hash_location = NULL;
844 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700845 struct ipv6hdr *ip6h = ipv6_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700846 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800847 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800848 u8 newhash[16];
849
850 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900851 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800852
David S. Miller785957d2008-07-30 03:03:15 -0700853 /* We've parsed the options - do we have a hash? */
854 if (!hash_expected && !hash_location)
855 return 0;
856
857 if (hash_expected && !hash_location) {
858 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800859 return 1;
860 }
861
David S. Miller785957d2008-07-30 03:03:15 -0700862 if (!hash_expected && hash_location) {
863 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800864 return 1;
865 }
866
867 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700868 genhash = tcp_v6_md5_hash_skb(newhash,
869 hash_expected,
870 NULL, NULL, skb);
871
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800872 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
873 if (net_ratelimit()) {
874 printk(KERN_INFO "MD5 Hash %s for "
875 "(" NIP6_FMT ", %u)->"
876 "(" NIP6_FMT ", %u)\n",
877 genhash ? "failed" : "mismatch",
878 NIP6(ip6h->saddr), ntohs(th->source),
879 NIP6(ip6h->daddr), ntohs(th->dest));
880 }
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,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800899};
Andrew Mortonb6332e62006-11-30 19:16:28 -0800900#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800901
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800902static struct timewait_sock_ops tcp6_timewait_sock_ops = {
903 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
904 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800905 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800906};
907
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800908static void tcp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909{
910 struct ipv6_pinfo *np = inet6_sk(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700911 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Patrick McHardy84fa7932006-08-29 16:44:56 -0700913 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700915 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800916 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 } else {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900918 th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
919 csum_partial((char *)th, th->doff<<2,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 skb->csum));
921 }
922}
923
Herbert Xua430a432006-07-08 13:34:56 -0700924static int tcp_v6_gso_send_check(struct sk_buff *skb)
925{
926 struct ipv6hdr *ipv6h;
927 struct tcphdr *th;
928
929 if (!pskb_may_pull(skb, sizeof(*th)))
930 return -EINVAL;
931
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700932 ipv6h = ipv6_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700933 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700934
935 th->check = 0;
936 th->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr, skb->len,
937 IPPROTO_TCP, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700938 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800939 skb->csum_offset = offsetof(struct tcphdr, check);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700940 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xua430a432006-07-08 13:34:56 -0700941 return 0;
942}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800944static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700946 struct tcphdr *th = tcp_hdr(skb), *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 struct sk_buff *buff;
948 struct flowi fl;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900949 struct net *net = dev_net(skb->dst->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800950 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800951 unsigned int tot_len = sizeof(*th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800952#ifdef CONFIG_TCP_MD5SIG
953 struct tcp_md5sig_key *key;
954#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
956 if (th->rst)
957 return;
958
959 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900960 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800962#ifdef CONFIG_TCP_MD5SIG
963 if (sk)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700964 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800965 else
966 key = NULL;
967
968 if (key)
969 tot_len += TCPOLEN_MD5SIG_ALIGNED;
970#endif
971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 /*
973 * We need to grab some memory, and put together an RST,
974 * and then put it into the queue to be sent.
975 */
976
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800977 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 GFP_ATOMIC);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900979 if (buff == NULL)
980 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800982 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800984 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
986 /* Swap the send and the receive. */
987 memset(t1, 0, sizeof(*t1));
988 t1->dest = th->source;
989 t1->source = th->dest;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800990 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 t1->rst = 1;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 if(th->ack) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900994 t1->seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 } else {
996 t1->ack = 1;
997 t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
998 + skb->len - (th->doff<<2));
999 }
1000
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001001#ifdef CONFIG_TCP_MD5SIG
1002 if (key) {
Al Viro8e5200f2006-11-20 18:06:37 -08001003 __be32 *opt = (__be32*)(t1 + 1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001004 opt[0] = htonl((TCPOPT_NOP << 24) |
1005 (TCPOPT_NOP << 16) |
1006 (TCPOPT_MD5SIG << 8) |
1007 TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -07001008 tcp_v6_md5_hash_hdr((__u8 *)&opt[1], key,
1009 &ipv6_hdr(skb)->daddr,
1010 &ipv6_hdr(skb)->saddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001011 }
1012#endif
1013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 buff->csum = csum_partial((char *)t1, sizeof(*t1), 0);
1015
1016 memset(&fl, 0, sizeof(fl));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001017 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
1018 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
1020 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1021 sizeof(*t1), IPPROTO_TCP,
1022 buff->csum);
1023
1024 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001025 fl.oif = inet6_iif(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 fl.fl_ip_dport = t1->dest;
1027 fl.fl_ip_sport = t1->source;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001028 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
Daniel Lezcanoc20121a2008-03-05 10:48:35 -08001030 /* Pass a socket to ip6_dst_lookup either it is for RST
1031 * Underlying function will use this to retrieve the network
1032 * namespace
1033 */
Daniel Lezcanoe5047992008-03-07 11:16:26 -08001034 if (!ip6_dst_lookup(ctl_sk, &buff->dst, &fl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
Arnaldo Carvalho de Meloecc51b62005-12-12 14:38:10 -08001036 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
Daniel Lezcanoe5047992008-03-07 11:16:26 -08001037 ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001038 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
1039 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 return;
Arnaldo Carvalho de Meloecc51b62005-12-12 14:38:10 -08001041 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 }
1043
1044 kfree_skb(buff);
1045}
1046
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001047static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts,
1048 struct tcp_md5sig_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001050 struct tcphdr *th = tcp_hdr(skb), *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 struct sk_buff *buff;
1052 struct flowi fl;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001053 struct net *net = dev_net(skb->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -08001054 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -08001055 unsigned int tot_len = sizeof(struct tcphdr);
Al Viroe69a4ad2006-11-14 20:56:00 -08001056 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
1058 if (ts)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -07001059 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001060#ifdef CONFIG_TCP_MD5SIG
1061 if (key)
1062 tot_len += TCPOLEN_MD5SIG_ALIGNED;
1063#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
1065 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1066 GFP_ATOMIC);
1067 if (buff == NULL)
1068 return;
1069
1070 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1071
1072 t1 = (struct tcphdr *) skb_push(buff,tot_len);
1073
1074 /* Swap the send and the receive. */
1075 memset(t1, 0, sizeof(*t1));
1076 t1->dest = th->source;
1077 t1->source = th->dest;
1078 t1->doff = tot_len/4;
1079 t1->seq = htonl(seq);
1080 t1->ack_seq = htonl(ack);
1081 t1->ack = 1;
1082 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001083
Al Viroe69a4ad2006-11-14 20:56:00 -08001084 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001087 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1088 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1089 *topt++ = htonl(tcp_time_stamp);
1090 *topt = htonl(ts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 }
1092
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001093#ifdef CONFIG_TCP_MD5SIG
1094 if (key) {
1095 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1096 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -07001097 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -07001098 &ipv6_hdr(skb)->saddr,
1099 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001100 }
1101#endif
1102
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 buff->csum = csum_partial((char *)t1, tot_len, 0);
1104
1105 memset(&fl, 0, sizeof(fl));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001106 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
1107 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
1109 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1110 tot_len, IPPROTO_TCP,
1111 buff->csum);
1112
1113 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001114 fl.oif = inet6_iif(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 fl.fl_ip_dport = t1->dest;
1116 fl.fl_ip_sport = t1->source;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001117 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118
Daniel Lezcanoe5047992008-03-07 11:16:26 -08001119 if (!ip6_dst_lookup(ctl_sk, &buff->dst, &fl)) {
Arnaldo Carvalho de Meloecc51b62005-12-12 14:38:10 -08001120 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
Daniel Lezcanoe5047992008-03-07 11:16:26 -08001121 ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001122 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 return;
Arnaldo Carvalho de Meloecc51b62005-12-12 14:38:10 -08001124 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 }
1126
1127 kfree_skb(buff);
1128}
1129
1130static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1131{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001132 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001133 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001135 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001136 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001137 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001139 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140}
1141
Gui Jianfeng6edafaa2008-08-06 23:50:04 -07001142static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
1143 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +09001145 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 -07001146 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147}
1148
1149
1150static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1151{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001152 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001153 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 struct sock *nsk;
1155
1156 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -08001157 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001158 &ipv6_hdr(skb)->saddr,
1159 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 if (req)
1161 return tcp_check_req(sk, skb, req, prev);
1162
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001163 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -08001164 &ipv6_hdr(skb)->saddr, th->source,
1165 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
1167 if (nsk) {
1168 if (nsk->sk_state != TCP_TIME_WAIT) {
1169 bh_lock_sock(nsk);
1170 return nsk;
1171 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001172 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 return NULL;
1174 }
1175
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001176#ifdef CONFIG_SYN_COOKIES
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 if (!th->rst && !th->syn && th->ack)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001178 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179#endif
1180 return sk;
1181}
1182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183/* FIXME: this is substantially similar to the ipv4 code.
1184 * Can some kind of merge be done? -- erics
1185 */
1186static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1187{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001188 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 struct ipv6_pinfo *np = inet6_sk(sk);
1190 struct tcp_options_received tmp_opt;
1191 struct tcp_sock *tp = tcp_sk(sk);
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001192 struct request_sock *req = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 __u32 isn = TCP_SKB_CB(skb)->when;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001194#ifdef CONFIG_SYN_COOKIES
1195 int want_cookie = 0;
1196#else
1197#define want_cookie 0
1198#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
1200 if (skb->protocol == htons(ETH_P_IP))
1201 return tcp_v4_conn_request(sk, skb);
1202
1203 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001204 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001206 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 if (net_ratelimit())
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001208 syn_flood_warning(skb);
1209#ifdef CONFIG_SYN_COOKIES
1210 if (sysctl_tcp_syncookies)
1211 want_cookie = 1;
1212 else
1213#endif
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001214 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 }
1216
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001217 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 goto drop;
1219
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001220 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 if (req == NULL)
1222 goto drop;
1223
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001224#ifdef CONFIG_TCP_MD5SIG
1225 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1226#endif
1227
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 tcp_clear_options(&tmp_opt);
1229 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1230 tmp_opt.user_mss = tp->rx_opt.user_mss;
1231
1232 tcp_parse_options(skb, &tmp_opt, 0);
1233
Florian Westphal4dfc2812008-04-10 03:12:40 -07001234 if (want_cookie && !tmp_opt.saw_tstamp)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001235 tcp_clear_options(&tmp_opt);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1238 tcp_openreq_init(req, &tmp_opt, skb);
1239
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001240 treq = inet6_rsk(req);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001241 ipv6_addr_copy(&treq->rmt_addr, &ipv6_hdr(skb)->saddr);
1242 ipv6_addr_copy(&treq->loc_addr, &ipv6_hdr(skb)->daddr);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001243 if (!want_cookie)
1244 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001246 if (want_cookie) {
1247 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
Florian Westphal4dfc2812008-04-10 03:12:40 -07001248 req->cookie_ts = tmp_opt.tstamp_ok;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001249 } else if (!isn) {
1250 if (ipv6_opt_accepted(sk, skb) ||
1251 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1252 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1253 atomic_inc(&skb->users);
1254 treq->pktopts = skb;
1255 }
1256 treq->iif = sk->sk_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001258 /* So that link locals have meaning */
1259 if (!sk->sk_bound_dev_if &&
1260 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1261 treq->iif = inet6_iif(skb);
1262
Gerrit Renkera94f7232006-11-10 14:06:49 -08001263 isn = tcp_v6_init_sequence(skb);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001266 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001268 security_inet_conn_request(sk, skb, req);
1269
Denis V. Lunevfd80eb92008-02-29 11:43:03 -08001270 if (tcp_v6_send_synack(sk, req))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 goto drop;
1272
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001273 if (!want_cookie) {
1274 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1275 return 0;
1276 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
1278drop:
1279 if (req)
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001280 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 return 0; /* don't send reset */
1283}
1284
1285static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001286 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 struct dst_entry *dst)
1288{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001289 struct inet6_request_sock *treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1291 struct tcp6_sock *newtcp6sk;
1292 struct inet_sock *newinet;
1293 struct tcp_sock *newtp;
1294 struct sock *newsk;
1295 struct ipv6_txoptions *opt;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001296#ifdef CONFIG_TCP_MD5SIG
1297 struct tcp_md5sig_key *key;
1298#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
1300 if (skb->protocol == htons(ETH_P_IP)) {
1301 /*
1302 * v6 mapped
1303 */
1304
1305 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1306
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001307 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 return NULL;
1309
1310 newtcp6sk = (struct tcp6_sock *)newsk;
1311 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1312
1313 newinet = inet_sk(newsk);
1314 newnp = inet6_sk(newsk);
1315 newtp = tcp_sk(newsk);
1316
1317 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1318
1319 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
1320 newinet->daddr);
1321
1322 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
1323 newinet->saddr);
1324
1325 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1326
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001327 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001329#ifdef CONFIG_TCP_MD5SIG
1330 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1331#endif
1332
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 newnp->pktoptions = NULL;
1334 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001335 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001336 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001338 /*
1339 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1340 * here, tcp_create_openreq_child now does this for us, see the comment in
1341 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
1344 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001345 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 Sync it now.
1347 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001348 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
1350 return newsk;
1351 }
1352
1353 opt = np->opt;
1354
1355 if (sk_acceptq_is_full(sk))
1356 goto out_overflow;
1357
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 if (dst == NULL) {
1359 struct in6_addr *final_p = NULL, final;
1360 struct flowi fl;
1361
1362 memset(&fl, 0, sizeof(fl));
1363 fl.proto = IPPROTO_TCP;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001364 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 if (opt && opt->srcrt) {
1366 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
1367 ipv6_addr_copy(&final, &fl.fl6_dst);
1368 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1369 final_p = &final;
1370 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001371 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 fl.oif = sk->sk_bound_dev_if;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001373 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 fl.fl_ip_sport = inet_sk(sk)->sport;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001375 security_req_classify_flow(req, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
1377 if (ip6_dst_lookup(sk, &dst, &fl))
1378 goto out;
1379
1380 if (final_p)
1381 ipv6_addr_copy(&fl.fl6_dst, final_p);
1382
1383 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
1384 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001385 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
1387 newsk = tcp_create_openreq_child(sk, req, skb);
1388 if (newsk == NULL)
1389 goto out;
1390
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001391 /*
1392 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1393 * count here, tcp_create_openreq_child now does this for us, see the
1394 * comment in that function for the gory details. -acme
1395 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
Stephen Hemminger59eed272006-08-25 15:55:43 -07001397 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001398 __ip6_dst_store(newsk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
1400 newtcp6sk = (struct tcp6_sock *)newsk;
1401 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1402
1403 newtp = tcp_sk(newsk);
1404 newinet = inet_sk(newsk);
1405 newnp = inet6_sk(newsk);
1406
1407 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1408
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001409 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1410 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1411 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1412 newsk->sk_bound_dev_if = treq->iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001414 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415
1416 First: no IPv4 options.
1417 */
1418 newinet->opt = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001419 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
1421 /* Clone RX bits */
1422 newnp->rxopt.all = np->rxopt.all;
1423
1424 /* Clone pktoptions received with SYN */
1425 newnp->pktoptions = NULL;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001426 if (treq->pktopts != NULL) {
1427 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1428 kfree_skb(treq->pktopts);
1429 treq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 if (newnp->pktoptions)
1431 skb_set_owner_r(newnp->pktoptions, newsk);
1432 }
1433 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001434 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001435 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436
1437 /* Clone native IPv6 options from listening socket (if any)
1438
1439 Yes, keeping reference count would be much more clever,
1440 but we make one more one thing there: reattach optmem
1441 to newsk.
1442 */
1443 if (opt) {
1444 newnp->opt = ipv6_dup_options(newsk, opt);
1445 if (opt != np->opt)
1446 sock_kfree_s(sk, opt, opt->tot_len);
1447 }
1448
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001449 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001451 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1452 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
John Heffner5d424d52006-03-20 17:53:41 -08001454 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 tcp_sync_mss(newsk, dst_mtu(dst));
1456 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1457 tcp_initialize_rcv_mss(newsk);
1458
1459 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
1460
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001461#ifdef CONFIG_TCP_MD5SIG
1462 /* Copy over the MD5 key from the original socket */
1463 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1464 /* We're using one, so create a matching key
1465 * on the newsk structure. If we fail to get
1466 * memory, then we end up not copying the key
1467 * across. Shucks.
1468 */
Arnaldo Carvalho de Meloaf879cc2006-11-17 12:14:37 -02001469 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1470 if (newkey != NULL)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001471 tcp_v6_md5_do_add(newsk, &inet6_sk(sk)->daddr,
1472 newkey, key->keylen);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001473 }
1474#endif
1475
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001476 __inet6_hash(newsk);
Pavel Emelyanove56d8b82008-04-17 23:17:34 -07001477 __inet_inherit_port(sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478
1479 return newsk;
1480
1481out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001482 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483out:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001484 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 if (opt && opt != np->opt)
1486 sock_kfree_s(sk, opt, opt->tot_len);
1487 dst_release(dst);
1488 return NULL;
1489}
1490
Al Virob51655b2006-11-14 21:40:42 -08001491static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001493 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001494 if (!tcp_v6_check(tcp_hdr(skb), skb->len, &ipv6_hdr(skb)->saddr,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001495 &ipv6_hdr(skb)->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001496 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001498 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001500
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001501 skb->csum = ~csum_unfold(tcp_v6_check(tcp_hdr(skb), skb->len,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001502 &ipv6_hdr(skb)->saddr,
1503 &ipv6_hdr(skb)->daddr, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -08001504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001506 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 }
1508 return 0;
1509}
1510
1511/* The socket must have it's spinlock held when we get
1512 * here.
1513 *
1514 * We have a potential double-lock case here, so even when
1515 * doing backlog processing we use the BH locking scheme.
1516 * This is because we cannot sleep with the original spinlock
1517 * held.
1518 */
1519static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1520{
1521 struct ipv6_pinfo *np = inet6_sk(sk);
1522 struct tcp_sock *tp;
1523 struct sk_buff *opt_skb = NULL;
1524
1525 /* Imagine: socket is IPv6. IPv4 packet arrives,
1526 goes to IPv4 receive handler and backlogged.
1527 From backlog it always goes here. Kerboom...
1528 Fortunately, tcp_rcv_established and rcv_established
1529 handle them correctly, but it is not case with
1530 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1531 */
1532
1533 if (skb->protocol == htons(ETH_P_IP))
1534 return tcp_v4_do_rcv(sk, skb);
1535
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001536#ifdef CONFIG_TCP_MD5SIG
1537 if (tcp_v6_inbound_md5_hash (sk, skb))
1538 goto discard;
1539#endif
1540
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001541 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 goto discard;
1543
1544 /*
1545 * socket locking is here for SMP purposes as backlog rcv
1546 * is currently called with bh processing disabled.
1547 */
1548
1549 /* Do Stevens' IPV6_PKTOPTIONS.
1550
1551 Yes, guys, it is the only place in our code, where we
1552 may make it not affecting IPv4.
1553 The rest of code is protocol independent,
1554 and I do not like idea to uglify IPv4.
1555
1556 Actually, all the idea behind IPV6_PKTOPTIONS
1557 looks not very well thought. For now we latch
1558 options, received in the last packet, enqueued
1559 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001560 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 */
1562 if (np->rxopt.all)
1563 opt_skb = skb_clone(skb, GFP_ATOMIC);
1564
1565 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1566 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001567 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 goto reset;
1569 TCP_CHECK_TIMER(sk);
1570 if (opt_skb)
1571 goto ipv6_pktoptions;
1572 return 0;
1573 }
1574
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001575 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 goto csum_err;
1577
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001578 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1580 if (!nsk)
1581 goto discard;
1582
1583 /*
1584 * Queue it on the new socket if the new socket is active,
1585 * otherwise we just shortcircuit this and continue with
1586 * the new socket..
1587 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001588 if(nsk != sk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 if (tcp_child_process(sk, nsk, skb))
1590 goto reset;
1591 if (opt_skb)
1592 __kfree_skb(opt_skb);
1593 return 0;
1594 }
1595 }
1596
1597 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001598 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 goto reset;
1600 TCP_CHECK_TIMER(sk);
1601 if (opt_skb)
1602 goto ipv6_pktoptions;
1603 return 0;
1604
1605reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001606 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607discard:
1608 if (opt_skb)
1609 __kfree_skb(opt_skb);
1610 kfree_skb(skb);
1611 return 0;
1612csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001613 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 goto discard;
1615
1616
1617ipv6_pktoptions:
1618 /* Do you ask, what is it?
1619
1620 1. skb was enqueued by tcp.
1621 2. skb is added to tail of read queue, rather than out of order.
1622 3. socket is not in passive state.
1623 4. Finally, it really contains options, which user wants to receive.
1624 */
1625 tp = tcp_sk(sk);
1626 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1627 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001628 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001629 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001630 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001631 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 if (ipv6_opt_accepted(sk, opt_skb)) {
1633 skb_set_owner_r(opt_skb, sk);
1634 opt_skb = xchg(&np->pktoptions, opt_skb);
1635 } else {
1636 __kfree_skb(opt_skb);
1637 opt_skb = xchg(&np->pktoptions, NULL);
1638 }
1639 }
1640
1641 if (opt_skb)
1642 kfree_skb(opt_skb);
1643 return 0;
1644}
1645
Herbert Xue5bbef22007-10-15 12:50:28 -07001646static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647{
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001648 struct tcphdr *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 struct sock *sk;
1650 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001651 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
1653 if (skb->pkt_type != PACKET_HOST)
1654 goto discard_it;
1655
1656 /*
1657 * Count it even if it's bad.
1658 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001659 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1662 goto discard_it;
1663
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001664 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
1666 if (th->doff < sizeof(struct tcphdr)/4)
1667 goto bad_packet;
1668 if (!pskb_may_pull(skb, th->doff*4))
1669 goto discard_it;
1670
Herbert Xu60476372007-04-09 11:59:39 -07001671 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 goto bad_packet;
1673
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001674 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1676 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1677 skb->len - th->doff*4);
1678 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1679 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001680 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 TCP_SKB_CB(skb)->sacked = 0;
1682
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001683 sk = __inet6_lookup(net, &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -08001684 &ipv6_hdr(skb)->saddr, th->source,
1685 &ipv6_hdr(skb)->daddr, ntohs(th->dest),
1686 inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
1688 if (!sk)
1689 goto no_tcp_socket;
1690
1691process:
1692 if (sk->sk_state == TCP_TIME_WAIT)
1693 goto do_time_wait;
1694
1695 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1696 goto discard_and_relse;
1697
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001698 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 goto discard_and_relse;
1700
1701 skb->dev = NULL;
1702
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001703 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 ret = 0;
1705 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001706#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001707 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001708 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1709 tp->ucopy.dma_chan = get_softnet_dma();
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001710 if (tp->ucopy.dma_chan)
1711 ret = tcp_v6_do_rcv(sk, skb);
1712 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001713#endif
1714 {
1715 if (!tcp_prequeue(sk, skb))
1716 ret = tcp_v6_do_rcv(sk, skb);
1717 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 } else
1719 sk_add_backlog(sk, skb);
1720 bh_unlock_sock(sk);
1721
1722 sock_put(sk);
1723 return ret ? -1 : 0;
1724
1725no_tcp_socket:
1726 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1727 goto discard_it;
1728
1729 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1730bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001731 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001733 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 }
1735
1736discard_it:
1737
1738 /*
1739 * Discard frame
1740 */
1741
1742 kfree_skb(skb);
1743 return 0;
1744
1745discard_and_relse:
1746 sock_put(sk);
1747 goto discard_it;
1748
1749do_time_wait:
1750 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001751 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 goto discard_it;
1753 }
1754
1755 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001756 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001757 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 goto discard_it;
1759 }
1760
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001761 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 case TCP_TW_SYN:
1763 {
1764 struct sock *sk2;
1765
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001766 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001767 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001768 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001770 struct inet_timewait_sock *tw = inet_twsk(sk);
1771 inet_twsk_deschedule(tw, &tcp_death_row);
1772 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 sk = sk2;
1774 goto process;
1775 }
1776 /* Fall through to ACK */
1777 }
1778 case TCP_TW_ACK:
1779 tcp_v6_timewait_ack(sk, skb);
1780 break;
1781 case TCP_TW_RST:
1782 goto no_tcp_socket;
1783 case TCP_TW_SUCCESS:;
1784 }
1785 goto discard_it;
1786}
1787
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788static int tcp_v6_remember_stamp(struct sock *sk)
1789{
1790 /* Alas, not yet... */
1791 return 0;
1792}
1793
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001794static struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001795 .queue_xmit = inet6_csk_xmit,
1796 .send_check = tcp_v6_send_check,
1797 .rebuild_header = inet6_sk_rebuild_header,
1798 .conn_request = tcp_v6_conn_request,
1799 .syn_recv_sock = tcp_v6_syn_recv_sock,
1800 .remember_stamp = tcp_v6_remember_stamp,
1801 .net_header_len = sizeof(struct ipv6hdr),
1802 .setsockopt = ipv6_setsockopt,
1803 .getsockopt = ipv6_getsockopt,
1804 .addr2sockaddr = inet6_csk_addr2sockaddr,
1805 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001806 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001807#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001808 .compat_setsockopt = compat_ipv6_setsockopt,
1809 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001810#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811};
1812
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001813#ifdef CONFIG_TCP_MD5SIG
David S. Millera9286302006-11-14 19:53:22 -08001814static struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001815 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001816 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001817 .md5_add = tcp_v6_md5_add_func,
1818 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001819};
David S. Millera9286302006-11-14 19:53:22 -08001820#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001821
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822/*
1823 * TCP over IPv4 via INET6 API
1824 */
1825
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001826static struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001827 .queue_xmit = ip_queue_xmit,
1828 .send_check = tcp_v4_send_check,
1829 .rebuild_header = inet_sk_rebuild_header,
1830 .conn_request = tcp_v6_conn_request,
1831 .syn_recv_sock = tcp_v6_syn_recv_sock,
1832 .remember_stamp = tcp_v4_remember_stamp,
1833 .net_header_len = sizeof(struct iphdr),
1834 .setsockopt = ipv6_setsockopt,
1835 .getsockopt = ipv6_getsockopt,
1836 .addr2sockaddr = inet6_csk_addr2sockaddr,
1837 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001838 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001839#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001840 .compat_setsockopt = compat_ipv6_setsockopt,
1841 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001842#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843};
1844
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001845#ifdef CONFIG_TCP_MD5SIG
David S. Millera9286302006-11-14 19:53:22 -08001846static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001847 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001848 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001849 .md5_add = tcp_v6_md5_add_func,
1850 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001851};
David S. Millera9286302006-11-14 19:53:22 -08001852#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001853
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854/* NOTE: A lot of things set to zero explicitly by call to
1855 * sk_alloc() so need not be done here.
1856 */
1857static int tcp_v6_init_sock(struct sock *sk)
1858{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001859 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 struct tcp_sock *tp = tcp_sk(sk);
1861
1862 skb_queue_head_init(&tp->out_of_order_queue);
1863 tcp_init_xmit_timers(sk);
1864 tcp_prequeue_init(tp);
1865
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001866 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 tp->mdev = TCP_TIMEOUT_INIT;
1868
1869 /* So many TCP implementations out there (incorrectly) count the
1870 * initial SYN frame in their delayed-ACK and congestion control
1871 * algorithms that we must have the following bandaid to talk
1872 * efficiently to them. -DaveM
1873 */
1874 tp->snd_cwnd = 2;
1875
1876 /* See draft-stevens-tcpca-spec-01 for discussion of the
1877 * initialization of these values.
1878 */
1879 tp->snd_ssthresh = 0x7fffffff;
1880 tp->snd_cwnd_clamp = ~0;
David S. Millerc1b4a7e2005-07-05 15:24:38 -07001881 tp->mss_cache = 536;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882
1883 tp->reordering = sysctl_tcp_reordering;
1884
1885 sk->sk_state = TCP_CLOSE;
1886
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001887 icsk->icsk_af_ops = &ipv6_specific;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001888 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001889 icsk->icsk_sync_mss = tcp_sync_mss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 sk->sk_write_space = sk_stream_write_space;
1891 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1892
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001893#ifdef CONFIG_TCP_MD5SIG
1894 tp->af_specific = &tcp_sock_ipv6_specific;
1895#endif
1896
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1898 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1899
1900 atomic_inc(&tcp_sockets_allocated);
1901
1902 return 0;
1903}
1904
Brian Haley7d06b2e2008-06-14 17:04:49 -07001905static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001907#ifdef CONFIG_TCP_MD5SIG
1908 /* Clean up the MD5 key list */
1909 if (tcp_sk(sk)->md5sig_info)
1910 tcp_v6_clear_md5_list(sk);
1911#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001913 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914}
1915
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001916#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001918static void get_openreq6(struct seq_file *seq,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001919 struct sock *sk, struct request_sock *req, int i, int uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 int ttd = req->expires - jiffies;
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001922 struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1923 struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924
1925 if (ttd < 0)
1926 ttd = 0;
1927
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 seq_printf(seq,
1929 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1930 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1931 i,
1932 src->s6_addr32[0], src->s6_addr32[1],
1933 src->s6_addr32[2], src->s6_addr32[3],
1934 ntohs(inet_sk(sk)->sport),
1935 dest->s6_addr32[0], dest->s6_addr32[1],
1936 dest->s6_addr32[2], dest->s6_addr32[3],
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001937 ntohs(inet_rsk(req)->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 TCP_SYN_RECV,
1939 0,0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001940 1, /* timers active (only the expire timer) */
1941 jiffies_to_clock_t(ttd),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 req->retrans,
1943 uid,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001944 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 0, /* open_requests have no inode */
1946 0, req);
1947}
1948
1949static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1950{
1951 struct in6_addr *dest, *src;
1952 __u16 destp, srcp;
1953 int timer_active;
1954 unsigned long timer_expires;
1955 struct inet_sock *inet = inet_sk(sp);
1956 struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001957 const struct inet_connection_sock *icsk = inet_csk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 struct ipv6_pinfo *np = inet6_sk(sp);
1959
1960 dest = &np->daddr;
1961 src = &np->rcv_saddr;
1962 destp = ntohs(inet->dport);
1963 srcp = ntohs(inet->sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001964
1965 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001967 timer_expires = icsk->icsk_timeout;
1968 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001970 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 } else if (timer_pending(&sp->sk_timer)) {
1972 timer_active = 2;
1973 timer_expires = sp->sk_timer.expires;
1974 } else {
1975 timer_active = 0;
1976 timer_expires = jiffies;
1977 }
1978
1979 seq_printf(seq,
1980 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Stephen Hemminger7be87352008-06-27 20:00:19 -07001981 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 i,
1983 src->s6_addr32[0], src->s6_addr32[1],
1984 src->s6_addr32[2], src->s6_addr32[3], srcp,
1985 dest->s6_addr32[0], dest->s6_addr32[1],
1986 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001987 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001988 tp->write_seq-tp->snd_una,
1989 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 timer_active,
1991 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001992 icsk->icsk_retransmits,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 sock_i_uid(sp),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001994 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 sock_i_ino(sp),
1996 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001997 jiffies_to_clock_t(icsk->icsk_rto),
1998 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001999 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
2001 );
2002}
2003
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002004static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002005 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006{
2007 struct in6_addr *dest, *src;
2008 __u16 destp, srcp;
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08002009 struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 int ttd = tw->tw_ttd - jiffies;
2011
2012 if (ttd < 0)
2013 ttd = 0;
2014
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08002015 dest = &tw6->tw_v6_daddr;
2016 src = &tw6->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 destp = ntohs(tw->tw_dport);
2018 srcp = ntohs(tw->tw_sport);
2019
2020 seq_printf(seq,
2021 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2022 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2023 i,
2024 src->s6_addr32[0], src->s6_addr32[1],
2025 src->s6_addr32[2], src->s6_addr32[3], srcp,
2026 dest->s6_addr32[0], dest->s6_addr32[1],
2027 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2028 tw->tw_substate, 0, 0,
2029 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2030 atomic_read(&tw->tw_refcnt), tw);
2031}
2032
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033static int tcp6_seq_show(struct seq_file *seq, void *v)
2034{
2035 struct tcp_iter_state *st;
2036
2037 if (v == SEQ_START_TOKEN) {
2038 seq_puts(seq,
2039 " sl "
2040 "local_address "
2041 "remote_address "
2042 "st tx_queue rx_queue tr tm->when retrnsmt"
2043 " uid timeout inode\n");
2044 goto out;
2045 }
2046 st = seq->private;
2047
2048 switch (st->state) {
2049 case TCP_SEQ_STATE_LISTENING:
2050 case TCP_SEQ_STATE_ESTABLISHED:
2051 get_tcp6_sock(seq, v, st->num);
2052 break;
2053 case TCP_SEQ_STATE_OPENREQ:
2054 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2055 break;
2056 case TCP_SEQ_STATE_TIME_WAIT:
2057 get_timewait6_sock(seq, v, st->num);
2058 break;
2059 }
2060out:
2061 return 0;
2062}
2063
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 .name = "tcp6",
2066 .family = AF_INET6,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002067 .seq_fops = {
2068 .owner = THIS_MODULE,
2069 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002070 .seq_ops = {
2071 .show = tcp6_seq_show,
2072 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073};
2074
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002075int tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002077 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078}
2079
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002080void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002082 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083}
2084#endif
2085
2086struct proto tcpv6_prot = {
2087 .name = "TCPv6",
2088 .owner = THIS_MODULE,
2089 .close = tcp_close,
2090 .connect = tcp_v6_connect,
2091 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002092 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 .ioctl = tcp_ioctl,
2094 .init = tcp_v6_init_sock,
2095 .destroy = tcp_v6_destroy_sock,
2096 .shutdown = tcp_shutdown,
2097 .setsockopt = tcp_setsockopt,
2098 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 .recvmsg = tcp_recvmsg,
2100 .backlog_rcv = tcp_v6_do_rcv,
2101 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002102 .unhash = inet_unhash,
2103 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 .enter_memory_pressure = tcp_enter_memory_pressure,
2105 .sockets_allocated = &tcp_sockets_allocated,
2106 .memory_allocated = &tcp_memory_allocated,
2107 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002108 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 .sysctl_mem = sysctl_tcp_mem,
2110 .sysctl_wmem = sysctl_tcp_wmem,
2111 .sysctl_rmem = sysctl_tcp_rmem,
2112 .max_header = MAX_TCP_HEADER,
2113 .obj_size = sizeof(struct tcp6_sock),
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002114 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002115 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002116 .h.hashinfo = &tcp_hashinfo,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002117#ifdef CONFIG_COMPAT
2118 .compat_setsockopt = compat_tcp_setsockopt,
2119 .compat_getsockopt = compat_tcp_getsockopt,
2120#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121};
2122
2123static struct inet6_protocol tcpv6_protocol = {
2124 .handler = tcp_v6_rcv,
2125 .err_handler = tcp_v6_err,
Herbert Xua430a432006-07-08 13:34:56 -07002126 .gso_send_check = tcp_v6_gso_send_check,
Herbert Xuadcfc7d2006-06-30 13:36:15 -07002127 .gso_segment = tcp_tso_segment,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2129};
2130
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131static struct inet_protosw tcpv6_protosw = {
2132 .type = SOCK_STREAM,
2133 .protocol = IPPROTO_TCP,
2134 .prot = &tcpv6_prot,
2135 .ops = &inet6_stream_ops,
2136 .capability = -1,
2137 .no_check = 0,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08002138 .flags = INET_PROTOSW_PERMANENT |
2139 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140};
2141
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002142static int tcpv6_net_init(struct net *net)
2143{
Denis V. Lunev56772422008-04-03 14:28:30 -07002144 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2145 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002146}
2147
2148static void tcpv6_net_exit(struct net *net)
2149{
Denis V. Lunev56772422008-04-03 14:28:30 -07002150 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Daniel Lezcanod3154922008-09-08 13:17:27 -07002151 inet_twsk_purge(net, &tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002152}
2153
2154static struct pernet_operations tcpv6_net_ops = {
2155 .init = tcpv6_net_init,
2156 .exit = tcpv6_net_exit,
2157};
2158
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002159int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002161 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08002162
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002163 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2164 if (ret)
2165 goto out;
2166
2167 /* register inet6 protocol */
2168 ret = inet6_register_protosw(&tcpv6_protosw);
2169 if (ret)
2170 goto out_tcpv6_protocol;
2171
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002172 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002173 if (ret)
2174 goto out_tcpv6_protosw;
2175out:
2176 return ret;
2177
2178out_tcpv6_protocol:
2179 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2180out_tcpv6_protosw:
2181 inet6_unregister_protosw(&tcpv6_protosw);
2182 goto out;
2183}
2184
Daniel Lezcano09f77092007-12-13 05:34:58 -08002185void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002186{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002187 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002188 inet6_unregister_protosw(&tcpv6_protosw);
2189 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190}