]> bbs.cooldavid.org Git - net-next-2.6.git/blame - net/ipv6/tcp_ipv6.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SK_BUFF]: Introduce skb_network_header()
[net-next-2.6.git] / net / ipv6 / tcp_ipv6.c
CommitLineData
1da177e4
LT		 1/*
2 * TCP over IPv6
1ab1457c 3 * Linux INET6 implementation
1da177e4
LT		 4 *
5 * Authors:
1ab1457c 6 * Pedro Roque <roque@di.fc.ul.pt>
1da177e4
LT		 7 *
8 * $Id: tcp_ipv6.c,v 1.144 2002/02/01 22:01:04 davem Exp $
9 *
1ab1457c 10 * Based on:
1da177e4
LT		 11 * linux/net/ipv4/tcp.c
12 * linux/net/ipv4/tcp_input.c
13 * linux/net/ipv4/tcp_output.c
14 *
15 * Fixes:
16 * Hideaki YOSHIFUJI : sin6_scope_id support
17 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
18 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
19 * a single port at the same time.
20 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
21 *
22 * This program is free software; you can redistribute it and/or
23 * modify it under the terms of the GNU General Public License
24 * as published by the Free Software Foundation; either version
25 * 2 of the License, or (at your option) any later version.
26 */
27
28#include <linux/module.h>
1da177e4
LT		 29#include <linux/errno.h>
30#include <linux/types.h>
31#include <linux/socket.h>
32#include <linux/sockios.h>
33#include <linux/net.h>
34#include <linux/jiffies.h>
35#include <linux/in.h>
36#include <linux/in6.h>
37#include <linux/netdevice.h>
38#include <linux/init.h>
39#include <linux/jhash.h>
40#include <linux/ipsec.h>
41#include <linux/times.h>
42
43#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
5324a040 49#include <net/inet6_hashtables.h>
8129765a 50#include <net/inet6_connection_sock.h>
1da177e4
LT		 51#include <net/ipv6.h>
52#include <net/transp_v6.h>
53#include <net/addrconf.h>
54#include <net/ip6_route.h>
55#include <net/ip6_checksum.h>
56#include <net/inet_ecn.h>
57#include <net/protocol.h>
58#include <net/xfrm.h>
59#include <net/addrconf.h>
60#include <net/snmp.h>
61#include <net/dsfield.h>
6d6ee43e 62#include <net/timewait_sock.h>
1da177e4
LT		 63
64#include <asm/uaccess.h>
65
66#include <linux/proc_fs.h>
67#include <linux/seq_file.h>
68
cfb6eeb4
YH		 69#include <linux/crypto.h>
70#include <linux/scatterlist.h>
71
ae0f7d5f
DW		 72/* Socket used for sending RSTs and ACKs */
73static struct socket *tcp6_socket;
74
cfb6eeb4 75static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
60236fdd 76static void tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req);
1ab1457c 77static void tcp_v6_send_check(struct sock *sk, int len,
1da177e4
LT		 78 struct sk_buff *skb);
79
80static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
1da177e4 81
8292a17a
ACM		 82static struct inet_connection_sock_af_ops ipv6_mapped;
83static struct inet_connection_sock_af_ops ipv6_specific;
a928630a 84#ifdef CONFIG_TCP_MD5SIG
cfb6eeb4
YH		 85static struct tcp_sock_af_ops tcp_sock_ipv6_specific;
86static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
a928630a 87#endif
1da177e4 88
1da177e4
LT		 89static int tcp_v6_get_port(struct sock *sk, unsigned short snum)
90{
971af18b
ACM		 91 return inet_csk_get_port(&tcp_hashinfo, sk, snum,
92 inet6_csk_bind_conflict);
1da177e4
LT		 93}
94
1da177e4
LT		 95static void tcp_v6_hash(struct sock *sk)
96{
97 if (sk->sk_state != TCP_CLOSE) {
8292a17a 98 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
1da177e4
LT		 99 tcp_prot.hash(sk);
100 return;
101 }
102 local_bh_disable();
90b19d31 103 __inet6_hash(&tcp_hashinfo, sk);
1da177e4
LT		 104 local_bh_enable();
105 }
106}
107
868c86bc 108static __inline__ __sum16 tcp_v6_check(struct tcphdr *th, int len,
1ab1457c
YH		 109 struct in6_addr *saddr,
110 struct in6_addr *daddr,
868c86bc 111 __wsum base)
1da177e4
LT		 112{
113 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
114}
115
a94f723d 116static __u32 tcp_v6_init_sequence(struct sk_buff *skb)
1da177e4 117{
a94f723d
GR		 118 return secure_tcpv6_sequence_number(skb->nh.ipv6h->daddr.s6_addr32,
119 skb->nh.ipv6h->saddr.s6_addr32,
120 skb->h.th->dest,
121 skb->h.th->source);
1da177e4
LT		 122}
123
1ab1457c 124static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
1da177e4
LT		 125 int addr_len)
126{
127 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
1ab1457c 128 struct inet_sock *inet = inet_sk(sk);
d83d8461 129 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT		 130 struct ipv6_pinfo *np = inet6_sk(sk);
131 struct tcp_sock *tp = tcp_sk(sk);
132 struct in6_addr *saddr = NULL, *final_p = NULL, final;
133 struct flowi fl;
134 struct dst_entry *dst;
135 int addr_type;
136 int err;
137
1ab1457c 138 if (addr_len < SIN6_LEN_RFC2133)
1da177e4
LT		 139 return -EINVAL;
140
1ab1457c 141 if (usin->sin6_family != AF_INET6)
1da177e4
LT		 142 return(-EAFNOSUPPORT);
143
144 memset(&fl, 0, sizeof(fl));
145
146 if (np->sndflow) {
147 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
148 IP6_ECN_flow_init(fl.fl6_flowlabel);
149 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
150 struct ip6_flowlabel *flowlabel;
151 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
152 if (flowlabel == NULL)
153 return -EINVAL;
154 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
155 fl6_sock_release(flowlabel);
156 }
157 }
158
159 /*
1ab1457c
YH		 160 * connect() to INADDR_ANY means loopback (BSD'ism).
161 */
162
163 if(ipv6_addr_any(&usin->sin6_addr))
164 usin->sin6_addr.s6_addr[15] = 0x1;
1da177e4
LT		 165
166 addr_type = ipv6_addr_type(&usin->sin6_addr);
167
168 if(addr_type & IPV6_ADDR_MULTICAST)
169 return -ENETUNREACH;
170
171 if (addr_type&IPV6_ADDR_LINKLOCAL) {
172 if (addr_len >= sizeof(struct sockaddr_in6) &&
173 usin->sin6_scope_id) {
174 /* If interface is set while binding, indices
175 * must coincide.
176 */
177 if (sk->sk_bound_dev_if &&
178 sk->sk_bound_dev_if != usin->sin6_scope_id)
179 return -EINVAL;
180
181 sk->sk_bound_dev_if = usin->sin6_scope_id;
182 }
183
184 /* Connect to link-local address requires an interface */
185 if (!sk->sk_bound_dev_if)
186 return -EINVAL;
187 }
188
189 if (tp->rx_opt.ts_recent_stamp &&
190 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
191 tp->rx_opt.ts_recent = 0;
192 tp->rx_opt.ts_recent_stamp = 0;
193 tp->write_seq = 0;
194 }
195
196 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
197 np->flow_label = fl.fl6_flowlabel;
198
199 /*
200 * TCP over IPv4
201 */
202
203 if (addr_type == IPV6_ADDR_MAPPED) {
d83d8461 204 u32 exthdrlen = icsk->icsk_ext_hdr_len;
1da177e4
LT		 205 struct sockaddr_in sin;
206
207 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
208
209 if (__ipv6_only_sock(sk))
210 return -ENETUNREACH;
211
212 sin.sin_family = AF_INET;
213 sin.sin_port = usin->sin6_port;
214 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
215
d83d8461 216 icsk->icsk_af_ops = &ipv6_mapped;
1da177e4 217 sk->sk_backlog_rcv = tcp_v4_do_rcv;
cfb6eeb4
YH		 218#ifdef CONFIG_TCP_MD5SIG
219 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
220#endif
1da177e4
LT		 221
222 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
223
224 if (err) {
d83d8461
ACM		 225 icsk->icsk_ext_hdr_len = exthdrlen;
226 icsk->icsk_af_ops = &ipv6_specific;
1da177e4 227 sk->sk_backlog_rcv = tcp_v6_do_rcv;
cfb6eeb4
YH		 228#ifdef CONFIG_TCP_MD5SIG
229 tp->af_specific = &tcp_sock_ipv6_specific;
230#endif
1da177e4
LT		 231 goto failure;
232 } else {
233 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
234 inet->saddr);
235 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
236 inet->rcv_saddr);
237 }
238
239 return err;
240 }
241
242 if (!ipv6_addr_any(&np->rcv_saddr))
243 saddr = &np->rcv_saddr;
244
245 fl.proto = IPPROTO_TCP;
246 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
247 ipv6_addr_copy(&fl.fl6_src,
248 (saddr ? saddr : &np->saddr));
249 fl.oif = sk->sk_bound_dev_if;
250 fl.fl_ip_dport = usin->sin6_port;
251 fl.fl_ip_sport = inet->sport;
252
253 if (np->opt && np->opt->srcrt) {
254 struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
255 ipv6_addr_copy(&final, &fl.fl6_dst);
256 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
257 final_p = &final;
258 }
259
beb8d13b
VY		 260 security_sk_classify_flow(sk, &fl);
261
1da177e4
LT		 262 err = ip6_dst_lookup(sk, &dst, &fl);
263 if (err)
264 goto failure;
265 if (final_p)
266 ipv6_addr_copy(&fl.fl6_dst, final_p);
267
8eb9086f 268 if ((err = xfrm_lookup(&dst, &fl, sk, 1)) < 0)
1da177e4 269 goto failure;
1da177e4
LT		 270
271 if (saddr == NULL) {
272 saddr = &fl.fl6_src;
273 ipv6_addr_copy(&np->rcv_saddr, saddr);
274 }
275
276 /* set the source address */
277 ipv6_addr_copy(&np->saddr, saddr);
278 inet->rcv_saddr = LOOPBACK4_IPV6;
279
f83ef8c0 280 sk->sk_gso_type = SKB_GSO_TCPV6;
8e1ef0a9 281 __ip6_dst_store(sk, dst, NULL, NULL);
1da177e4 282
d83d8461 283 icsk->icsk_ext_hdr_len = 0;
1da177e4 284 if (np->opt)
d83d8461
ACM		 285 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
286 np->opt->opt_nflen);
1da177e4
LT		 287
288 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
289
290 inet->dport = usin->sin6_port;
291
292 tcp_set_state(sk, TCP_SYN_SENT);
d8313f5c 293 err = inet6_hash_connect(&tcp_death_row, sk);
1da177e4
LT		 294 if (err)
295 goto late_failure;
296
297 if (!tp->write_seq)
298 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
299 np->daddr.s6_addr32,
300 inet->sport,
301 inet->dport);
302
303 err = tcp_connect(sk);
304 if (err)
305 goto late_failure;
306
307 return 0;
308
309late_failure:
310 tcp_set_state(sk, TCP_CLOSE);
311 __sk_dst_reset(sk);
312failure:
313 inet->dport = 0;
314 sk->sk_route_caps = 0;
315 return err;
316}
317
318static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
04ce6909 319 int type, int code, int offset, __be32 info)
1da177e4
LT		 320{
321 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
505cbfc5 322 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
1da177e4
LT		 323 struct ipv6_pinfo *np;
324 struct sock *sk;
325 int err;
1ab1457c 326 struct tcp_sock *tp;
1da177e4
LT		 327 __u32 seq;
328
505cbfc5
ACM		 329 sk = inet6_lookup(&tcp_hashinfo, &hdr->daddr, th->dest, &hdr->saddr,
330 th->source, skb->dev->ifindex);
1da177e4
LT		 331
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) {
9469c7b4 338 inet_twsk_put(inet_twsk(sk));
1da177e4
LT		 339 return;
340 }
341
342 bh_lock_sock(sk);
343 if (sock_owned_by_user(sk))
344 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
345
346 if (sk->sk_state == TCP_CLOSE)
347 goto out;
348
349 tp = tcp_sk(sk);
1ab1457c 350 seq = ntohl(th->seq);
1da177e4
LT		 351 if (sk->sk_state != TCP_LISTEN &&
352 !between(seq, tp->snd_una, tp->snd_nxt)) {
353 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
354 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;
beb8d13b 385 security_skb_classify_flow(skb, &fl);
1da177e4
LT		 386
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
d83d8461 400 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
1da177e4
LT		 401 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
60236fdd 410 /* Might be for an request_sock */
1da177e4 411 switch (sk->sk_state) {
60236fdd 412 struct request_sock *req, **prev;
1da177e4
LT		 413 case TCP_LISTEN:
414 if (sock_owned_by_user(sk))
415 goto out;
416
8129765a
ACM		 417 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
418 &hdr->saddr, inet6_iif(skb));
1da177e4
LT		 419 if (!req)
420 goto out;
421
422 /* ICMPs are not backlogged, hence we cannot get
423 * an established socket here.
424 */
425 BUG_TRAP(req->sk == NULL);
426
2e6599cb 427 if (seq != tcp_rsk(req)->snt_isn) {
1da177e4
LT		 428 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
429 goto out;
430 }
431
463c84b9 432 inet_csk_reqsk_queue_drop(sk, req, prev);
1da177e4
LT		 433 goto out;
434
435 case TCP_SYN_SENT:
436 case TCP_SYN_RECV: /* Cannot happen.
1ab1457c 437 It can, it SYNs are crossed. --ANK */
1da177e4 438 if (!sock_owned_by_user(sk)) {
1da177e4
LT		 439 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
60236fdd 460static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
1da177e4
LT		 461 struct dst_entry *dst)
462{
ca304b61 463 struct inet6_request_sock *treq = inet6_rsk(req);
1da177e4
LT		 464 struct ipv6_pinfo *np = inet6_sk(sk);
465 struct sk_buff * skb;
466 struct ipv6_txoptions *opt = NULL;
467 struct in6_addr * final_p = NULL, final;
468 struct flowi fl;
469 int err = -1;
470
471 memset(&fl, 0, sizeof(fl));
472 fl.proto = IPPROTO_TCP;
2e6599cb
ACM		 473 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
474 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
1da177e4 475 fl.fl6_flowlabel = 0;
2e6599cb
ACM		 476 fl.oif = treq->iif;
477 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
1da177e4 478 fl.fl_ip_sport = inet_sk(sk)->sport;
4237c75c 479 security_req_classify_flow(req, &fl);
1da177e4
LT		 480
481 if (dst == NULL) {
482 opt = np->opt;
483 if (opt == NULL &&
333fad53 484 np->rxopt.bits.osrcrt == 2 &&
2e6599cb
ACM		 485 treq->pktopts) {
486 struct sk_buff *pktopts = treq->pktopts;
1da177e4
LT		 487 struct inet6_skb_parm *rxopt = IP6CB(pktopts);
488 if (rxopt->srcrt)
d56f90a7
ACM		 489 opt = ipv6_invert_rthdr(sk,
490 (struct ipv6_rt_hdr *)(skb_network_header(pktopts) +
491 rxopt->srcrt));
1da177e4
LT		 492 }
493
494 if (opt && opt->srcrt) {
495 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
496 ipv6_addr_copy(&final, &fl.fl6_dst);
497 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
498 final_p = &final;
499 }
500
501 err = ip6_dst_lookup(sk, &dst, &fl);
502 if (err)
503 goto done;
504 if (final_p)
505 ipv6_addr_copy(&fl.fl6_dst, final_p);
506 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
507 goto done;
508 }
509
510 skb = tcp_make_synack(sk, dst, req);
511 if (skb) {
512 struct tcphdr *th = skb->h.th;
513
514 th->check = tcp_v6_check(th, skb->len,
2e6599cb 515 &treq->loc_addr, &treq->rmt_addr,
1da177e4
LT		 516 csum_partial((char *)th, skb->len, skb->csum));
517
2e6599cb 518 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
1da177e4 519 err = ip6_xmit(sk, skb, &fl, opt, 0);
b9df3cb8 520 err = net_xmit_eval(err);
1da177e4
LT		 521 }
522
523done:
1ab1457c 524 if (opt && opt != np->opt)
1da177e4 525 sock_kfree_s(sk, opt, opt->tot_len);
78b91042 526 dst_release(dst);
1da177e4
LT		 527 return err;
528}
529
60236fdd 530static void tcp_v6_reqsk_destructor(struct request_sock *req)
1da177e4 531{
ca304b61
ACM		 532 if (inet6_rsk(req)->pktopts)
533 kfree_skb(inet6_rsk(req)->pktopts);
1da177e4
LT		 534}
535
cfb6eeb4
YH		 536#ifdef CONFIG_TCP_MD5SIG
537static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
538 struct in6_addr *addr)
539{
540 struct tcp_sock *tp = tcp_sk(sk);
541 int i;
542
543 BUG_ON(tp == NULL);
544
545 if (!tp->md5sig_info || !tp->md5sig_info->entries6)
546 return NULL;
547
548 for (i = 0; i < tp->md5sig_info->entries6; i++) {
549 if (ipv6_addr_cmp(&tp->md5sig_info->keys6[i].addr, addr) == 0)
550 return (struct tcp_md5sig_key *)&tp->md5sig_info->keys6[i];
551 }
552 return NULL;
553}
554
555static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
556 struct sock *addr_sk)
557{
558 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
559}
560
561static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
562 struct request_sock *req)
563{
564 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
565}
566
567static int tcp_v6_md5_do_add(struct sock *sk, struct in6_addr *peer,
568 char *newkey, u8 newkeylen)
569{
570 /* Add key to the list */
571 struct tcp6_md5sig_key *key;
572 struct tcp_sock *tp = tcp_sk(sk);
573 struct tcp6_md5sig_key *keys;
574
575 key = (struct tcp6_md5sig_key*) tcp_v6_md5_do_lookup(sk, peer);
576 if (key) {
577 /* modify existing entry - just update that one */
578 kfree(key->key);
579 key->key = newkey;
580 key->keylen = newkeylen;
581 } else {
582 /* reallocate new list if current one is full. */
583 if (!tp->md5sig_info) {
584 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
585 if (!tp->md5sig_info) {
586 kfree(newkey);
587 return -ENOMEM;
588 }
589 }
590 tcp_alloc_md5sig_pool();
591 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
592 keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
593 (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
594
595 if (!keys) {
596 tcp_free_md5sig_pool();
597 kfree(newkey);
598 return -ENOMEM;
599 }
600
601 if (tp->md5sig_info->entries6)
602 memmove(keys, tp->md5sig_info->keys6,
603 (sizeof (tp->md5sig_info->keys6[0]) *
604 tp->md5sig_info->entries6));
605
606 kfree(tp->md5sig_info->keys6);
607 tp->md5sig_info->keys6 = keys;
608 tp->md5sig_info->alloced6++;
609 }
610
611 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
612 peer);
613 tp->md5sig_info->keys6[tp->md5sig_info->entries6].key = newkey;
614 tp->md5sig_info->keys6[tp->md5sig_info->entries6].keylen = newkeylen;
615
616 tp->md5sig_info->entries6++;
617 }
618 return 0;
619}
620
621static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
622 u8 *newkey, __u8 newkeylen)
623{
624 return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
625 newkey, newkeylen);
626}
627
628static int tcp_v6_md5_do_del(struct sock *sk, struct in6_addr *peer)
629{
630 struct tcp_sock *tp = tcp_sk(sk);
631 int i;
632
633 for (i = 0; i < tp->md5sig_info->entries6; i++) {
634 if (ipv6_addr_cmp(&tp->md5sig_info->keys6[i].addr, peer) == 0) {
635 /* Free the key */
636 kfree(tp->md5sig_info->keys6[i].key);
637 tp->md5sig_info->entries6--;
638
639 if (tp->md5sig_info->entries6 == 0) {
640 kfree(tp->md5sig_info->keys6);
641 tp->md5sig_info->keys6 = NULL;
642
643 tcp_free_md5sig_pool();
644
645 return 0;
646 } else {
647 /* shrink the database */
648 if (tp->md5sig_info->entries6 != i)
649 memmove(&tp->md5sig_info->keys6[i],
650 &tp->md5sig_info->keys6[i+1],
651 (tp->md5sig_info->entries6 - i)
652 * sizeof (tp->md5sig_info->keys6[0]));
653 }
654 }
655 }
656 return -ENOENT;
657}
658
659static void tcp_v6_clear_md5_list (struct sock *sk)
660{
661 struct tcp_sock *tp = tcp_sk(sk);
662 int i;
663
664 if (tp->md5sig_info->entries6) {
665 for (i = 0; i < tp->md5sig_info->entries6; i++)
666 kfree(tp->md5sig_info->keys6[i].key);
667 tp->md5sig_info->entries6 = 0;
668 tcp_free_md5sig_pool();
669 }
670
671 kfree(tp->md5sig_info->keys6);
672 tp->md5sig_info->keys6 = NULL;
673 tp->md5sig_info->alloced6 = 0;
674
675 if (tp->md5sig_info->entries4) {
676 for (i = 0; i < tp->md5sig_info->entries4; i++)
677 kfree(tp->md5sig_info->keys4[i].key);
678 tp->md5sig_info->entries4 = 0;
679 tcp_free_md5sig_pool();
680 }
681
682 kfree(tp->md5sig_info->keys4);
683 tp->md5sig_info->keys4 = NULL;
684 tp->md5sig_info->alloced4 = 0;
685}
686
687static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
688 int optlen)
689{
690 struct tcp_md5sig cmd;
691 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
692 u8 *newkey;
693
694 if (optlen < sizeof(cmd))
695 return -EINVAL;
696
697 if (copy_from_user(&cmd, optval, sizeof(cmd)))
698 return -EFAULT;
699
700 if (sin6->sin6_family != AF_INET6)
701 return -EINVAL;
702
703 if (!cmd.tcpm_keylen) {
704 if (!tcp_sk(sk)->md5sig_info)
705 return -ENOENT;
706 if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_MAPPED)
707 return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
708 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
709 }
710
711 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
712 return -EINVAL;
713
714 if (!tcp_sk(sk)->md5sig_info) {
715 struct tcp_sock *tp = tcp_sk(sk);
716 struct tcp_md5sig_info *p;
717
718 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
719 if (!p)
720 return -ENOMEM;
721
722 tp->md5sig_info = p;
723 }
724
af879cc7 725 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
cfb6eeb4
YH		 726 if (!newkey)
727 return -ENOMEM;
cfb6eeb4
YH		 728 if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_MAPPED) {
729 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
730 newkey, cmd.tcpm_keylen);
731 }
732 return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
733}
734
735static int tcp_v6_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
736 struct in6_addr *saddr,
737 struct in6_addr *daddr,
738 struct tcphdr *th, int protocol,
739 int tcplen)
740{
741 struct scatterlist sg[4];
742 __u16 data_len;
743 int block = 0;
8e5200f5 744 __sum16 cksum;
cfb6eeb4
YH		 745 struct tcp_md5sig_pool *hp;
746 struct tcp6_pseudohdr *bp;
747 struct hash_desc *desc;
748 int err;
749 unsigned int nbytes = 0;
750
751 hp = tcp_get_md5sig_pool();
752 if (!hp) {
753 printk(KERN_WARNING "%s(): hash pool not found...\n", __FUNCTION__);
754 goto clear_hash_noput;
755 }
756 bp = &hp->md5_blk.ip6;
757 desc = &hp->md5_desc;
758
759 /* 1. TCP pseudo-header (RFC2460) */
760 ipv6_addr_copy(&bp->saddr, saddr);
761 ipv6_addr_copy(&bp->daddr, daddr);
762 bp->len = htonl(tcplen);
763 bp->protocol = htonl(protocol);
764
765 sg_set_buf(&sg[block++], bp, sizeof(*bp));
766 nbytes += sizeof(*bp);
767
768 /* 2. TCP header, excluding options */
769 cksum = th->check;
770 th->check = 0;
771 sg_set_buf(&sg[block++], th, sizeof(*th));
772 nbytes += sizeof(*th);
773
774 /* 3. TCP segment data (if any) */
775 data_len = tcplen - (th->doff << 2);
776 if (data_len > 0) {
777 u8 *data = (u8 *)th + (th->doff << 2);
778 sg_set_buf(&sg[block++], data, data_len);
779 nbytes += data_len;
780 }
781
782 /* 4. shared key */
783 sg_set_buf(&sg[block++], key->key, key->keylen);
784 nbytes += key->keylen;
785
786 /* Now store the hash into the packet */
787 err = crypto_hash_init(desc);
788 if (err) {
789 printk(KERN_WARNING "%s(): hash_init failed\n", __FUNCTION__);
790 goto clear_hash;
791 }
792 err = crypto_hash_update(desc, sg, nbytes);
793 if (err) {
794 printk(KERN_WARNING "%s(): hash_update failed\n", __FUNCTION__);
795 goto clear_hash;
796 }
797 err = crypto_hash_final(desc, md5_hash);
798 if (err) {
799 printk(KERN_WARNING "%s(): hash_final failed\n", __FUNCTION__);
800 goto clear_hash;
801 }
802
803 /* Reset header, and free up the crypto */
804 tcp_put_md5sig_pool();
805 th->check = cksum;
806out:
807 return 0;
808clear_hash:
809 tcp_put_md5sig_pool();
810clear_hash_noput:
811 memset(md5_hash, 0, 16);
812 goto out;
813}
814
815static int tcp_v6_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
816 struct sock *sk,
817 struct dst_entry *dst,
818 struct request_sock *req,
819 struct tcphdr *th, int protocol,
820 int tcplen)
821{
822 struct in6_addr *saddr, *daddr;
823
824 if (sk) {
825 saddr = &inet6_sk(sk)->saddr;
826 daddr = &inet6_sk(sk)->daddr;
827 } else {
828 saddr = &inet6_rsk(req)->loc_addr;
829 daddr = &inet6_rsk(req)->rmt_addr;
830 }
831 return tcp_v6_do_calc_md5_hash(md5_hash, key,
832 saddr, daddr,
833 th, protocol, tcplen);
834}
835
836static int tcp_v6_inbound_md5_hash (struct sock *sk, struct sk_buff *skb)
837{
838 __u8 *hash_location = NULL;
839 struct tcp_md5sig_key *hash_expected;
840 struct ipv6hdr *ip6h = skb->nh.ipv6h;
841 struct tcphdr *th = skb->h.th;
842 int length = (th->doff << 2) - sizeof (*th);
843 int genhash;
844 u8 *ptr;
845 u8 newhash[16];
846
847 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
848
849 /* If the TCP option is too short, we can short cut */
850 if (length < TCPOLEN_MD5SIG)
851 return hash_expected ? 1 : 0;
852
853 /* parse options */
854 ptr = (u8*)(th + 1);
855 while (length > 0) {
856 int opcode = *ptr++;
857 int opsize;
858
859 switch(opcode) {
860 case TCPOPT_EOL:
861 goto done_opts;
862 case TCPOPT_NOP:
863 length--;
864 continue;
865 default:
866 opsize = *ptr++;
867 if (opsize < 2 || opsize > length)
868 goto done_opts;
869 if (opcode == TCPOPT_MD5SIG) {
870 hash_location = ptr;
871 goto done_opts;
872 }
873 }
874 ptr += opsize - 2;
875 length -= opsize;
876 }
877
878done_opts:
879 /* do we have a hash as expected? */
880 if (!hash_expected) {
881 if (!hash_location)
882 return 0;
883 if (net_ratelimit()) {
884 printk(KERN_INFO "MD5 Hash NOT expected but found "
885 "(" NIP6_FMT ", %u)->"
886 "(" NIP6_FMT ", %u)\n",
887 NIP6(ip6h->saddr), ntohs(th->source),
888 NIP6(ip6h->daddr), ntohs(th->dest));
889 }
890 return 1;
891 }
892
893 if (!hash_location) {
894 if (net_ratelimit()) {
895 printk(KERN_INFO "MD5 Hash expected but NOT found "
896 "(" NIP6_FMT ", %u)->"
897 "(" NIP6_FMT ", %u)\n",
898 NIP6(ip6h->saddr), ntohs(th->source),
899 NIP6(ip6h->daddr), ntohs(th->dest));
900 }
901 return 1;
902 }
903
904 /* check the signature */
905 genhash = tcp_v6_do_calc_md5_hash(newhash,
906 hash_expected,
907 &ip6h->saddr, &ip6h->daddr,
908 th, sk->sk_protocol,
909 skb->len);
910 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
911 if (net_ratelimit()) {
912 printk(KERN_INFO "MD5 Hash %s for "
913 "(" NIP6_FMT ", %u)->"
914 "(" NIP6_FMT ", %u)\n",
915 genhash ? "failed" : "mismatch",
916 NIP6(ip6h->saddr), ntohs(th->source),
917 NIP6(ip6h->daddr), ntohs(th->dest));
918 }
919 return 1;
920 }
921 return 0;
922}
923#endif
924
9ec75fe8 925static struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
1da177e4 926 .family = AF_INET6,
2e6599cb 927 .obj_size = sizeof(struct tcp6_request_sock),
1da177e4 928 .rtx_syn_ack = tcp_v6_send_synack,
60236fdd
ACM		 929 .send_ack = tcp_v6_reqsk_send_ack,
930 .destructor = tcp_v6_reqsk_destructor,
1da177e4
LT		 931 .send_reset = tcp_v6_send_reset
932};
933
cfb6eeb4 934#ifdef CONFIG_TCP_MD5SIG
b6332e6c 935static struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
cfb6eeb4 936 .md5_lookup = tcp_v6_reqsk_md5_lookup,
cfb6eeb4 937};
b6332e6c 938#endif
cfb6eeb4 939
6d6ee43e
ACM		 940static struct timewait_sock_ops tcp6_timewait_sock_ops = {
941 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
942 .twsk_unique = tcp_twsk_unique,
cfb6eeb4 943 .twsk_destructor= tcp_twsk_destructor,
6d6ee43e
ACM		 944};
945
8292a17a 946static void tcp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb)
1da177e4
LT		 947{
948 struct ipv6_pinfo *np = inet6_sk(sk);
8292a17a 949 struct tcphdr *th = skb->h.th;
1da177e4 950
84fa7933 951 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1da177e4 952 th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0);
ff1dcadb 953 skb->csum_offset = offsetof(struct tcphdr, check);
1da177e4 954 } else {
1ab1457c
YH		 955 th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
956 csum_partial((char *)th, th->doff<<2,
1da177e4
LT		 957 skb->csum));
958 }
959}
960
a430a43d
HX		 961static int tcp_v6_gso_send_check(struct sk_buff *skb)
962{
963 struct ipv6hdr *ipv6h;
964 struct tcphdr *th;
965
966 if (!pskb_may_pull(skb, sizeof(*th)))
967 return -EINVAL;
968
969 ipv6h = skb->nh.ipv6h;
970 th = skb->h.th;
971
972 th->check = 0;
973 th->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr, skb->len,
974 IPPROTO_TCP, 0);
ff1dcadb 975 skb->csum_offset = offsetof(struct tcphdr, check);
84fa7933 976 skb->ip_summed = CHECKSUM_PARTIAL;
a430a43d
HX		 977 return 0;
978}
1da177e4 979
cfb6eeb4 980static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
1da177e4 981{
1ab1457c 982 struct tcphdr *th = skb->h.th, *t1;
1da177e4
LT		 983 struct sk_buff *buff;
984 struct flowi fl;
cfb6eeb4
YH		 985 int tot_len = sizeof(*th);
986#ifdef CONFIG_TCP_MD5SIG
987 struct tcp_md5sig_key *key;
988#endif
1da177e4
LT		 989
990 if (th->rst)
991 return;
992
993 if (!ipv6_unicast_destination(skb))
1ab1457c 994 return;
1da177e4 995
cfb6eeb4
YH		 996#ifdef CONFIG_TCP_MD5SIG
997 if (sk)
998 key = tcp_v6_md5_do_lookup(sk, &skb->nh.ipv6h->daddr);
999 else
1000 key = NULL;
1001
1002 if (key)
1003 tot_len += TCPOLEN_MD5SIG_ALIGNED;
1004#endif
1005
1da177e4
LT		 1006 /*
1007 * We need to grab some memory, and put together an RST,
1008 * and then put it into the queue to be sent.
1009 */
1010
cfb6eeb4 1011 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1da177e4 1012 GFP_ATOMIC);
1ab1457c
YH		 1013 if (buff == NULL)
1014 return;
1da177e4 1015
cfb6eeb4 1016 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1da177e4 1017
cfb6eeb4 1018 t1 = (struct tcphdr *) skb_push(buff, tot_len);
1da177e4
LT		 1019
1020 /* Swap the send and the receive. */
1021 memset(t1, 0, sizeof(*t1));
1022 t1->dest = th->source;
1023 t1->source = th->dest;
cfb6eeb4 1024 t1->doff = tot_len / 4;
1da177e4 1025 t1->rst = 1;
1ab1457c 1026
1da177e4 1027 if(th->ack) {
1ab1457c 1028 t1->seq = th->ack_seq;
1da177e4
LT		 1029 } else {
1030 t1->ack = 1;
1031 t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
1032 + skb->len - (th->doff<<2));
1033 }
1034
cfb6eeb4
YH		 1035#ifdef CONFIG_TCP_MD5SIG
1036 if (key) {
8e5200f5 1037 __be32 *opt = (__be32*)(t1 + 1);
cfb6eeb4
YH		 1038 opt[0] = htonl((TCPOPT_NOP << 24) |
1039 (TCPOPT_NOP << 16) |
1040 (TCPOPT_MD5SIG << 8) |
1041 TCPOLEN_MD5SIG);
1042 tcp_v6_do_calc_md5_hash((__u8*)&opt[1],
1043 key,
1044 &skb->nh.ipv6h->daddr,
1045 &skb->nh.ipv6h->saddr,
1046 t1, IPPROTO_TCP,
1047 tot_len);
1048 }
1049#endif
1050
1da177e4
LT		 1051 buff->csum = csum_partial((char *)t1, sizeof(*t1), 0);
1052
1053 memset(&fl, 0, sizeof(fl));
1054 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
1055 ipv6_addr_copy(&fl.fl6_src, &skb->nh.ipv6h->daddr);
1056
1057 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1058 sizeof(*t1), IPPROTO_TCP,
1059 buff->csum);
1060
1061 fl.proto = IPPROTO_TCP;
505cbfc5 1062 fl.oif = inet6_iif(skb);
1da177e4
LT		 1063 fl.fl_ip_dport = t1->dest;
1064 fl.fl_ip_sport = t1->source;
beb8d13b 1065 security_skb_classify_flow(skb, &fl);
1da177e4
LT		 1066
1067 /* sk = NULL, but it is safe for now. RST socket required. */
1068 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
1069
ecc51b6d 1070 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
ae0f7d5f 1071 ip6_xmit(tcp6_socket->sk, buff, &fl, NULL, 0);
ecc51b6d
ACM		 1072 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1073 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
1da177e4 1074 return;
ecc51b6d 1075 }
1da177e4
LT		 1076 }
1077
1078 kfree_skb(buff);
1079}
1080
cfb6eeb4
YH		 1081static void tcp_v6_send_ack(struct tcp_timewait_sock *tw,
1082 struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts)
1da177e4
LT		 1083{
1084 struct tcphdr *th = skb->h.th, *t1;
1085 struct sk_buff *buff;
1086 struct flowi fl;
1087 int tot_len = sizeof(struct tcphdr);
e69a4adc 1088 __be32 *topt;
cfb6eeb4
YH		 1089#ifdef CONFIG_TCP_MD5SIG
1090 struct tcp_md5sig_key *key;
1091 struct tcp_md5sig_key tw_key;
1092#endif
1093
1094#ifdef CONFIG_TCP_MD5SIG
1095 if (!tw && skb->sk) {
1096 key = tcp_v6_md5_do_lookup(skb->sk, &skb->nh.ipv6h->daddr);
1097 } else if (tw && tw->tw_md5_keylen) {
1098 tw_key.key = tw->tw_md5_key;
1099 tw_key.keylen = tw->tw_md5_keylen;
1100 key = &tw_key;
1101 } else {
1102 key = NULL;
1103 }
1104#endif
1da177e4
LT		 1105
1106 if (ts)
4244f8a9 1107 tot_len += TCPOLEN_TSTAMP_ALIGNED;
cfb6eeb4
YH		 1108#ifdef CONFIG_TCP_MD5SIG
1109 if (key)
1110 tot_len += TCPOLEN_MD5SIG_ALIGNED;
1111#endif
1da177e4
LT		 1112
1113 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1114 GFP_ATOMIC);
1115 if (buff == NULL)
1116 return;
1117
1118 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1119
1120 t1 = (struct tcphdr *) skb_push(buff,tot_len);
1121
1122 /* Swap the send and the receive. */
1123 memset(t1, 0, sizeof(*t1));
1124 t1->dest = th->source;
1125 t1->source = th->dest;
1126 t1->doff = tot_len/4;
1127 t1->seq = htonl(seq);
1128 t1->ack_seq = htonl(ack);
1129 t1->ack = 1;
1130 t1->window = htons(win);
cfb6eeb4 1131
e69a4adc 1132 topt = (__be32 *)(t1 + 1);
1ab1457c 1133
1da177e4 1134 if (ts) {
cfb6eeb4
YH		 1135 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1136 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1137 *topt++ = htonl(tcp_time_stamp);
1138 *topt = htonl(ts);
1da177e4
LT		 1139 }
1140
cfb6eeb4
YH		 1141#ifdef CONFIG_TCP_MD5SIG
1142 if (key) {
1143 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1144 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
1145 tcp_v6_do_calc_md5_hash((__u8 *)topt,
1146 key,
1147 &skb->nh.ipv6h->daddr,
1148 &skb->nh.ipv6h->saddr,
1149 t1, IPPROTO_TCP,
1150 tot_len);
1151 }
1152#endif
1153
1da177e4
LT		 1154 buff->csum = csum_partial((char *)t1, tot_len, 0);
1155
1156 memset(&fl, 0, sizeof(fl));
1157 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
1158 ipv6_addr_copy(&fl.fl6_src, &skb->nh.ipv6h->daddr);
1159
1160 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1161 tot_len, IPPROTO_TCP,
1162 buff->csum);
1163
1164 fl.proto = IPPROTO_TCP;
505cbfc5 1165 fl.oif = inet6_iif(skb);
1da177e4
LT		 1166 fl.fl_ip_dport = t1->dest;
1167 fl.fl_ip_sport = t1->source;
beb8d13b 1168 security_skb_classify_flow(skb, &fl);
1da177e4
LT		 1169
1170 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
ecc51b6d 1171 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
ae0f7d5f 1172 ip6_xmit(tcp6_socket->sk, buff, &fl, NULL, 0);
ecc51b6d 1173 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1da177e4 1174 return;
ecc51b6d 1175 }
1da177e4
LT		 1176 }
1177
1178 kfree_skb(buff);
1179}
1180
1181static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1182{
8feaf0c0 1183 struct inet_timewait_sock *tw = inet_twsk(sk);
cfb6eeb4 1184 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1da177e4 1185
cfb6eeb4 1186 tcp_v6_send_ack(tcptw, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
8feaf0c0
ACM		 1187 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
1188 tcptw->tw_ts_recent);
1da177e4 1189
8feaf0c0 1190 inet_twsk_put(tw);
1da177e4
LT		 1191}
1192
60236fdd 1193static void tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
1da177e4 1194{
cfb6eeb4 1195 tcp_v6_send_ack(NULL, skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent);
1da177e4
LT		 1196}
1197
1198
1199static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1200{
60236fdd 1201 struct request_sock *req, **prev;
505cbfc5 1202 const struct tcphdr *th = skb->h.th;
1da177e4
LT		 1203 struct sock *nsk;
1204
1205 /* Find possible connection requests. */
8129765a
ACM		 1206 req = inet6_csk_search_req(sk, &prev, th->source,
1207 &skb->nh.ipv6h->saddr,
1208 &skb->nh.ipv6h->daddr, inet6_iif(skb));
1da177e4
LT		 1209 if (req)
1210 return tcp_check_req(sk, skb, req, prev);
1211
505cbfc5
ACM		 1212 nsk = __inet6_lookup_established(&tcp_hashinfo, &skb->nh.ipv6h->saddr,
1213 th->source, &skb->nh.ipv6h->daddr,
1214 ntohs(th->dest), inet6_iif(skb));
1da177e4
LT		 1215
1216 if (nsk) {
1217 if (nsk->sk_state != TCP_TIME_WAIT) {
1218 bh_lock_sock(nsk);
1219 return nsk;
1220 }
9469c7b4 1221 inet_twsk_put(inet_twsk(nsk));
1da177e4
LT		 1222 return NULL;
1223 }
1224
1225#if 0 /*def CONFIG_SYN_COOKIES*/
1226 if (!th->rst && !th->syn && th->ack)
1227 sk = cookie_v6_check(sk, skb, &(IPCB(skb)->opt));
1228#endif
1229 return sk;
1230}
1231
1da177e4
LT		 1232/* FIXME: this is substantially similar to the ipv4 code.
1233 * Can some kind of merge be done? -- erics
1234 */
1235static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1236{
ca304b61 1237 struct inet6_request_sock *treq;
1da177e4
LT		 1238 struct ipv6_pinfo *np = inet6_sk(sk);
1239 struct tcp_options_received tmp_opt;
1240 struct tcp_sock *tp = tcp_sk(sk);
60236fdd 1241 struct request_sock *req = NULL;
1da177e4
LT		 1242 __u32 isn = TCP_SKB_CB(skb)->when;
1243
1244 if (skb->protocol == htons(ETH_P_IP))
1245 return tcp_v4_conn_request(sk, skb);
1246
1247 if (!ipv6_unicast_destination(skb))
1ab1457c 1248 goto drop;
1da177e4
LT		 1249
1250 /*
1ab1457c 1251 * There are no SYN attacks on IPv6, yet...
1da177e4 1252 */
463c84b9 1253 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1da177e4
LT		 1254 if (net_ratelimit())
1255 printk(KERN_INFO "TCPv6: dropping request, synflood is possible\n");
1ab1457c 1256 goto drop;
1da177e4
LT		 1257 }
1258
463c84b9 1259 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1da177e4
LT		 1260 goto drop;
1261
ca304b61 1262 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
1da177e4
LT		 1263 if (req == NULL)
1264 goto drop;
1265
cfb6eeb4
YH		 1266#ifdef CONFIG_TCP_MD5SIG
1267 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1268#endif
1269
1da177e4
LT		 1270 tcp_clear_options(&tmp_opt);
1271 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1272 tmp_opt.user_mss = tp->rx_opt.user_mss;
1273
1274 tcp_parse_options(skb, &tmp_opt, 0);
1275
1276 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1277 tcp_openreq_init(req, &tmp_opt, skb);
1278
ca304b61 1279 treq = inet6_rsk(req);
2e6599cb
ACM		 1280 ipv6_addr_copy(&treq->rmt_addr, &skb->nh.ipv6h->saddr);
1281 ipv6_addr_copy(&treq->loc_addr, &skb->nh.ipv6h->daddr);
1da177e4 1282 TCP_ECN_create_request(req, skb->h.th);
2e6599cb 1283 treq->pktopts = NULL;
1da177e4 1284 if (ipv6_opt_accepted(sk, skb) ||
333fad53
YH		 1285 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1286 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1da177e4 1287 atomic_inc(&skb->users);
2e6599cb 1288 treq->pktopts = skb;
1da177e4 1289 }
2e6599cb 1290 treq->iif = sk->sk_bound_dev_if;
1da177e4
LT		 1291
1292 /* So that link locals have meaning */
1293 if (!sk->sk_bound_dev_if &&
2e6599cb 1294 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
505cbfc5 1295 treq->iif = inet6_iif(skb);
1da177e4 1296
1ab1457c 1297 if (isn == 0)
a94f723d 1298 isn = tcp_v6_init_sequence(skb);
1da177e4 1299
2e6599cb 1300 tcp_rsk(req)->snt_isn = isn;
1da177e4 1301
4237c75c
VY		 1302 security_inet_conn_request(sk, skb, req);
1303
1da177e4
LT		 1304 if (tcp_v6_send_synack(sk, req, NULL))
1305 goto drop;
1306
8129765a 1307 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1da177e4
LT		 1308 return 0;
1309
1310drop:
1311 if (req)
60236fdd 1312 reqsk_free(req);
1da177e4 1313
1da177e4
LT		 1314 return 0; /* don't send reset */
1315}
1316
1317static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
60236fdd 1318 struct request_sock *req,
1da177e4
LT		 1319 struct dst_entry *dst)
1320{
ca304b61 1321 struct inet6_request_sock *treq = inet6_rsk(req);
1da177e4
LT		 1322 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1323 struct tcp6_sock *newtcp6sk;
1324 struct inet_sock *newinet;
1325 struct tcp_sock *newtp;
1326 struct sock *newsk;
1327 struct ipv6_txoptions *opt;
cfb6eeb4
YH		 1328#ifdef CONFIG_TCP_MD5SIG
1329 struct tcp_md5sig_key *key;
1330#endif
1da177e4
LT		 1331
1332 if (skb->protocol == htons(ETH_P_IP)) {
1333 /*
1334 * v6 mapped
1335 */
1336
1337 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1338
1ab1457c 1339 if (newsk == NULL)
1da177e4
LT		 1340 return NULL;
1341
1342 newtcp6sk = (struct tcp6_sock *)newsk;
1343 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1344
1345 newinet = inet_sk(newsk);
1346 newnp = inet6_sk(newsk);
1347 newtp = tcp_sk(newsk);
1348
1349 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1350
1351 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
1352 newinet->daddr);
1353
1354 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
1355 newinet->saddr);
1356
1357 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1358
8292a17a 1359 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1da177e4 1360 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
cfb6eeb4
YH		 1361#ifdef CONFIG_TCP_MD5SIG
1362 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1363#endif
1364
1da177e4
LT		 1365 newnp->pktoptions = NULL;
1366 newnp->opt = NULL;
505cbfc5 1367 newnp->mcast_oif = inet6_iif(skb);
1da177e4
LT		 1368 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
1369
e6848976
ACM		 1370 /*
1371 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1372 * here, tcp_create_openreq_child now does this for us, see the comment in
1373 * that function for the gory details. -acme
1da177e4 1374 */
1da177e4
LT		 1375
1376 /* It is tricky place. Until this moment IPv4 tcp
8292a17a 1377 worked with IPv6 icsk.icsk_af_ops.
1da177e4
LT		 1378 Sync it now.
1379 */
d83d8461 1380 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1da177e4
LT		 1381
1382 return newsk;
1383 }
1384
1385 opt = np->opt;
1386
1387 if (sk_acceptq_is_full(sk))
1388 goto out_overflow;
1389
333fad53 1390 if (np->rxopt.bits.osrcrt == 2 &&
2e6599cb
ACM		 1391 opt == NULL && treq->pktopts) {
1392 struct inet6_skb_parm *rxopt = IP6CB(treq->pktopts);
1da177e4 1393 if (rxopt->srcrt)
d56f90a7
ACM		 1394 opt = ipv6_invert_rthdr(sk,
1395 (struct ipv6_rt_hdr *)(skb_network_header(treq->pktopts) +
1396 rxopt->srcrt));
1da177e4
LT		 1397 }
1398
1399 if (dst == NULL) {
1400 struct in6_addr *final_p = NULL, final;
1401 struct flowi fl;
1402
1403 memset(&fl, 0, sizeof(fl));
1404 fl.proto = IPPROTO_TCP;
2e6599cb 1405 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
1da177e4
LT		 1406 if (opt && opt->srcrt) {
1407 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
1408 ipv6_addr_copy(&final, &fl.fl6_dst);
1409 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1410 final_p = &final;
1411 }
2e6599cb 1412 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
1da177e4 1413 fl.oif = sk->sk_bound_dev_if;
2e6599cb 1414 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
1da177e4 1415 fl.fl_ip_sport = inet_sk(sk)->sport;
4237c75c 1416 security_req_classify_flow(req, &fl);
1da177e4
LT		 1417
1418 if (ip6_dst_lookup(sk, &dst, &fl))
1419 goto out;
1420
1421 if (final_p)
1422 ipv6_addr_copy(&fl.fl6_dst, final_p);
1423
1424 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
1425 goto out;
1ab1457c 1426 }
1da177e4
LT		 1427
1428 newsk = tcp_create_openreq_child(sk, req, skb);
1429 if (newsk == NULL)
1430 goto out;
1431
e6848976
ACM		 1432 /*
1433 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1434 * count here, tcp_create_openreq_child now does this for us, see the
1435 * comment in that function for the gory details. -acme
1436 */
1da177e4 1437
59eed279 1438 newsk->sk_gso_type = SKB_GSO_TCPV6;
8e1ef0a9 1439 __ip6_dst_store(newsk, dst, NULL, NULL);
1da177e4
LT		 1440
1441 newtcp6sk = (struct tcp6_sock *)newsk;
1442 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1443
1444 newtp = tcp_sk(newsk);
1445 newinet = inet_sk(newsk);
1446 newnp = inet6_sk(newsk);
1447
1448 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1449
2e6599cb
ACM		 1450 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1451 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1452 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1453 newsk->sk_bound_dev_if = treq->iif;
1da177e4 1454
1ab1457c 1455 /* Now IPv6 options...
1da177e4
LT		 1456
1457 First: no IPv4 options.
1458 */
1459 newinet->opt = NULL;
d35690be 1460 newnp->ipv6_fl_list = NULL;
1da177e4
LT		 1461
1462 /* Clone RX bits */
1463 newnp->rxopt.all = np->rxopt.all;
1464
1465 /* Clone pktoptions received with SYN */
1466 newnp->pktoptions = NULL;
2e6599cb
ACM		 1467 if (treq->pktopts != NULL) {
1468 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1469 kfree_skb(treq->pktopts);
1470 treq->pktopts = NULL;
1da177e4
LT		 1471 if (newnp->pktoptions)
1472 skb_set_owner_r(newnp->pktoptions, newsk);
1473 }
1474 newnp->opt = NULL;
505cbfc5 1475 newnp->mcast_oif = inet6_iif(skb);
1da177e4
LT		 1476 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
1477
1478 /* Clone native IPv6 options from listening socket (if any)
1479
1480 Yes, keeping reference count would be much more clever,
1481 but we make one more one thing there: reattach optmem
1482 to newsk.
1483 */
1484 if (opt) {
1485 newnp->opt = ipv6_dup_options(newsk, opt);
1486 if (opt != np->opt)
1487 sock_kfree_s(sk, opt, opt->tot_len);
1488 }
1489
d83d8461 1490 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1da177e4 1491 if (newnp->opt)
d83d8461
ACM		 1492 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1493 newnp->opt->opt_flen);
1da177e4 1494
5d424d5a 1495 tcp_mtup_init(newsk);
1da177e4
LT		 1496 tcp_sync_mss(newsk, dst_mtu(dst));
1497 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1498 tcp_initialize_rcv_mss(newsk);
1499
1500 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
1501
cfb6eeb4
YH		 1502#ifdef CONFIG_TCP_MD5SIG
1503 /* Copy over the MD5 key from the original socket */
1504 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1505 /* We're using one, so create a matching key
1506 * on the newsk structure. If we fail to get
1507 * memory, then we end up not copying the key
1508 * across. Shucks.
1509 */
af879cc7
ACM		 1510 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1511 if (newkey != NULL)
cfb6eeb4
YH		 1512 tcp_v6_md5_do_add(newsk, &inet6_sk(sk)->daddr,
1513 newkey, key->keylen);
cfb6eeb4
YH		 1514 }
1515#endif
1516
90b19d31 1517 __inet6_hash(&tcp_hashinfo, newsk);
2d8c4ce5 1518 inet_inherit_port(&tcp_hashinfo, sk, newsk);
1da177e4
LT		 1519
1520 return newsk;
1521
1522out_overflow:
1523 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1524out:
1525 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1526 if (opt && opt != np->opt)
1527 sock_kfree_s(sk, opt, opt->tot_len);
1528 dst_release(dst);
1529 return NULL;
1530}
1531
b51655b9 1532static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
1da177e4 1533{
84fa7933 1534 if (skb->ip_summed == CHECKSUM_COMPLETE) {
1da177e4 1535 if (!tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
fb286bb2
HX		 1536 &skb->nh.ipv6h->daddr,skb->csum)) {
1537 skb->ip_summed = CHECKSUM_UNNECESSARY;
1da177e4 1538 return 0;
fb286bb2 1539 }
1da177e4 1540 }
fb286bb2 1541
868c86bc
AV		 1542 skb->csum = ~csum_unfold(tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
1543 &skb->nh.ipv6h->daddr, 0));
fb286bb2 1544
1da177e4 1545 if (skb->len <= 76) {
fb286bb2 1546 return __skb_checksum_complete(skb);
1da177e4
LT		 1547 }
1548 return 0;
1549}
1550
1551/* The socket must have it's spinlock held when we get
1552 * here.
1553 *
1554 * We have a potential double-lock case here, so even when
1555 * doing backlog processing we use the BH locking scheme.
1556 * This is because we cannot sleep with the original spinlock
1557 * held.
1558 */
1559static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1560{
1561 struct ipv6_pinfo *np = inet6_sk(sk);
1562 struct tcp_sock *tp;
1563 struct sk_buff *opt_skb = NULL;
1564
1565 /* Imagine: socket is IPv6. IPv4 packet arrives,
1566 goes to IPv4 receive handler and backlogged.
1567 From backlog it always goes here. Kerboom...
1568 Fortunately, tcp_rcv_established and rcv_established
1569 handle them correctly, but it is not case with
1570 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1571 */
1572
1573 if (skb->protocol == htons(ETH_P_IP))
1574 return tcp_v4_do_rcv(sk, skb);
1575
cfb6eeb4
YH		 1576#ifdef CONFIG_TCP_MD5SIG
1577 if (tcp_v6_inbound_md5_hash (sk, skb))
1578 goto discard;
1579#endif
1580
fda9ef5d 1581 if (sk_filter(sk, skb))
1da177e4
LT		 1582 goto discard;
1583
1584 /*
1585 * socket locking is here for SMP purposes as backlog rcv
1586 * is currently called with bh processing disabled.
1587 */
1588
1589 /* Do Stevens' IPV6_PKTOPTIONS.
1590
1591 Yes, guys, it is the only place in our code, where we
1592 may make it not affecting IPv4.
1593 The rest of code is protocol independent,
1594 and I do not like idea to uglify IPv4.
1595
1596 Actually, all the idea behind IPV6_PKTOPTIONS
1597 looks not very well thought. For now we latch
1598 options, received in the last packet, enqueued
1599 by tcp. Feel free to propose better solution.
1ab1457c 1600 --ANK (980728)
1da177e4
LT		 1601 */
1602 if (np->rxopt.all)
1603 opt_skb = skb_clone(skb, GFP_ATOMIC);
1604
1605 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1606 TCP_CHECK_TIMER(sk);
1607 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1608 goto reset;
1609 TCP_CHECK_TIMER(sk);
1610 if (opt_skb)
1611 goto ipv6_pktoptions;
1612 return 0;
1613 }
1614
1615 if (skb->len < (skb->h.th->doff<<2) || tcp_checksum_complete(skb))
1616 goto csum_err;
1617
1ab1457c 1618 if (sk->sk_state == TCP_LISTEN) {
1da177e4
LT		 1619 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1620 if (!nsk)
1621 goto discard;
1622
1623 /*
1624 * Queue it on the new socket if the new socket is active,
1625 * otherwise we just shortcircuit this and continue with
1626 * the new socket..
1627 */
1ab1457c 1628 if(nsk != sk) {
1da177e4
LT		 1629 if (tcp_child_process(sk, nsk, skb))
1630 goto reset;
1631 if (opt_skb)
1632 __kfree_skb(opt_skb);
1633 return 0;
1634 }
1635 }
1636
1637 TCP_CHECK_TIMER(sk);
1638 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1639 goto reset;
1640 TCP_CHECK_TIMER(sk);
1641 if (opt_skb)
1642 goto ipv6_pktoptions;
1643 return 0;
1644
1645reset:
cfb6eeb4 1646 tcp_v6_send_reset(sk, skb);
1da177e4
LT		 1647discard:
1648 if (opt_skb)
1649 __kfree_skb(opt_skb);
1650 kfree_skb(skb);
1651 return 0;
1652csum_err:
1653 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1654 goto discard;
1655
1656
1657ipv6_pktoptions:
1658 /* Do you ask, what is it?
1659
1660 1. skb was enqueued by tcp.
1661 2. skb is added to tail of read queue, rather than out of order.
1662 3. socket is not in passive state.
1663 4. Finally, it really contains options, which user wants to receive.
1664 */
1665 tp = tcp_sk(sk);
1666 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1667 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
333fad53 1668 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
505cbfc5 1669 np->mcast_oif = inet6_iif(opt_skb);
333fad53 1670 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1da177e4
LT		 1671 np->mcast_hops = opt_skb->nh.ipv6h->hop_limit;
1672 if (ipv6_opt_accepted(sk, opt_skb)) {
1673 skb_set_owner_r(opt_skb, sk);
1674 opt_skb = xchg(&np->pktoptions, opt_skb);
1675 } else {
1676 __kfree_skb(opt_skb);
1677 opt_skb = xchg(&np->pktoptions, NULL);
1678 }
1679 }
1680
1681 if (opt_skb)
1682 kfree_skb(opt_skb);
1683 return 0;
1684}
1685
951dbc8a 1686static int tcp_v6_rcv(struct sk_buff **pskb)
1da177e4
LT		 1687{
1688 struct sk_buff *skb = *pskb;
1ab1457c 1689 struct tcphdr *th;
1da177e4
LT		 1690 struct sock *sk;
1691 int ret;
1692
1693 if (skb->pkt_type != PACKET_HOST)
1694 goto discard_it;
1695
1696 /*
1697 * Count it even if it's bad.
1698 */
1699 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1700
1701 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1702 goto discard_it;
1703
1704 th = skb->h.th;
1705
1706 if (th->doff < sizeof(struct tcphdr)/4)
1707 goto bad_packet;
1708 if (!pskb_may_pull(skb, th->doff*4))
1709 goto discard_it;
1710
1711 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
fb286bb2 1712 tcp_v6_checksum_init(skb)))
1da177e4
LT		 1713 goto bad_packet;
1714
1715 th = skb->h.th;
1716 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1717 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1718 skb->len - th->doff*4);
1719 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1720 TCP_SKB_CB(skb)->when = 0;
1721 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(skb->nh.ipv6h);
1722 TCP_SKB_CB(skb)->sacked = 0;
1723
505cbfc5
ACM		 1724 sk = __inet6_lookup(&tcp_hashinfo, &skb->nh.ipv6h->saddr, th->source,
1725 &skb->nh.ipv6h->daddr, ntohs(th->dest),
1726 inet6_iif(skb));
1da177e4
LT		 1727
1728 if (!sk)
1729 goto no_tcp_socket;
1730
1731process:
1732 if (sk->sk_state == TCP_TIME_WAIT)
1733 goto do_time_wait;
1734
1735 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1736 goto discard_and_relse;
1737
fda9ef5d 1738 if (sk_filter(sk, skb))
1da177e4
LT		 1739 goto discard_and_relse;
1740
1741 skb->dev = NULL;
1742
293b9c42 1743 bh_lock_sock_nested(sk);
1da177e4
LT		 1744 ret = 0;
1745 if (!sock_owned_by_user(sk)) {
1a2449a8 1746#ifdef CONFIG_NET_DMA
1ab1457c
YH		 1747 struct tcp_sock *tp = tcp_sk(sk);
1748 if (tp->ucopy.dma_chan)
1749 ret = tcp_v6_do_rcv(sk, skb);
1750 else
1a2449a8
CL		 1751#endif
1752 {
1753 if (!tcp_prequeue(sk, skb))
1754 ret = tcp_v6_do_rcv(sk, skb);
1755 }
1da177e4
LT		 1756 } else
1757 sk_add_backlog(sk, skb);
1758 bh_unlock_sock(sk);
1759
1760 sock_put(sk);
1761 return ret ? -1 : 0;
1762
1763no_tcp_socket:
1764 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1765 goto discard_it;
1766
1767 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1768bad_packet:
1769 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1770 } else {
cfb6eeb4 1771 tcp_v6_send_reset(NULL, skb);
1da177e4
LT		 1772 }
1773
1774discard_it:
1775
1776 /*
1777 * Discard frame
1778 */
1779
1780 kfree_skb(skb);
1781 return 0;
1782
1783discard_and_relse:
1784 sock_put(sk);
1785 goto discard_it;
1786
1787do_time_wait:
1788 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
9469c7b4 1789 inet_twsk_put(inet_twsk(sk));
1da177e4
LT		 1790 goto discard_it;
1791 }
1792
1793 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1794 TCP_INC_STATS_BH(TCP_MIB_INERRS);
9469c7b4 1795 inet_twsk_put(inet_twsk(sk));
1da177e4
LT		 1796 goto discard_it;
1797 }
1798
9469c7b4 1799 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1da177e4
LT		 1800 case TCP_TW_SYN:
1801 {
1802 struct sock *sk2;
1803
505cbfc5
ACM		 1804 sk2 = inet6_lookup_listener(&tcp_hashinfo,
1805 &skb->nh.ipv6h->daddr,
1806 ntohs(th->dest), inet6_iif(skb));
1da177e4 1807 if (sk2 != NULL) {
295ff7ed
ACM		 1808 struct inet_timewait_sock *tw = inet_twsk(sk);
1809 inet_twsk_deschedule(tw, &tcp_death_row);
1810 inet_twsk_put(tw);
1da177e4
LT		 1811 sk = sk2;
1812 goto process;
1813 }
1814 /* Fall through to ACK */
1815 }
1816 case TCP_TW_ACK:
1817 tcp_v6_timewait_ack(sk, skb);
1818 break;
1819 case TCP_TW_RST:
1820 goto no_tcp_socket;
1821 case TCP_TW_SUCCESS:;
1822 }
1823 goto discard_it;
1824}
1825
1da177e4
LT		 1826static int tcp_v6_remember_stamp(struct sock *sk)
1827{
1828 /* Alas, not yet... */
1829 return 0;
1830}
1831
8292a17a 1832static struct inet_connection_sock_af_ops ipv6_specific = {
543d9cfe
ACM		 1833 .queue_xmit = inet6_csk_xmit,
1834 .send_check = tcp_v6_send_check,
1835 .rebuild_header = inet6_sk_rebuild_header,
1836 .conn_request = tcp_v6_conn_request,
1837 .syn_recv_sock = tcp_v6_syn_recv_sock,
1838 .remember_stamp = tcp_v6_remember_stamp,
1839 .net_header_len = sizeof(struct ipv6hdr),
1840 .setsockopt = ipv6_setsockopt,
1841 .getsockopt = ipv6_getsockopt,
1842 .addr2sockaddr = inet6_csk_addr2sockaddr,
1843 .sockaddr_len = sizeof(struct sockaddr_in6),
3fdadf7d 1844#ifdef CONFIG_COMPAT
543d9cfe
ACM		 1845 .compat_setsockopt = compat_ipv6_setsockopt,
1846 .compat_getsockopt = compat_ipv6_getsockopt,
3fdadf7d 1847#endif
1da177e4
LT		 1848};
1849
cfb6eeb4 1850#ifdef CONFIG_TCP_MD5SIG
a928630a 1851static struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
cfb6eeb4
YH		 1852 .md5_lookup = tcp_v6_md5_lookup,
1853 .calc_md5_hash = tcp_v6_calc_md5_hash,
1854 .md5_add = tcp_v6_md5_add_func,
1855 .md5_parse = tcp_v6_parse_md5_keys,
cfb6eeb4 1856};
a928630a 1857#endif
cfb6eeb4 1858
1da177e4
LT		 1859/*
1860 * TCP over IPv4 via INET6 API
1861 */
1862
8292a17a 1863static struct inet_connection_sock_af_ops ipv6_mapped = {
543d9cfe
ACM		 1864 .queue_xmit = ip_queue_xmit,
1865 .send_check = tcp_v4_send_check,
1866 .rebuild_header = inet_sk_rebuild_header,
1867 .conn_request = tcp_v6_conn_request,
1868 .syn_recv_sock = tcp_v6_syn_recv_sock,
1869 .remember_stamp = tcp_v4_remember_stamp,
1870 .net_header_len = sizeof(struct iphdr),
1871 .setsockopt = ipv6_setsockopt,
1872 .getsockopt = ipv6_getsockopt,
1873 .addr2sockaddr = inet6_csk_addr2sockaddr,
1874 .sockaddr_len = sizeof(struct sockaddr_in6),
3fdadf7d 1875#ifdef CONFIG_COMPAT
543d9cfe
ACM		 1876 .compat_setsockopt = compat_ipv6_setsockopt,
1877 .compat_getsockopt = compat_ipv6_getsockopt,
3fdadf7d 1878#endif
1da177e4
LT		 1879};
1880
cfb6eeb4 1881#ifdef CONFIG_TCP_MD5SIG
a928630a 1882static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
cfb6eeb4
YH		 1883 .md5_lookup = tcp_v4_md5_lookup,
1884 .calc_md5_hash = tcp_v4_calc_md5_hash,
1885 .md5_add = tcp_v6_md5_add_func,
1886 .md5_parse = tcp_v6_parse_md5_keys,
cfb6eeb4 1887};
a928630a 1888#endif
cfb6eeb4 1889
1da177e4
LT		 1890/* NOTE: A lot of things set to zero explicitly by call to
1891 * sk_alloc() so need not be done here.
1892 */
1893static int tcp_v6_init_sock(struct sock *sk)
1894{
6687e988 1895 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT		 1896 struct tcp_sock *tp = tcp_sk(sk);
1897
1898 skb_queue_head_init(&tp->out_of_order_queue);
1899 tcp_init_xmit_timers(sk);
1900 tcp_prequeue_init(tp);
1901
6687e988 1902 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1da177e4
LT		 1903 tp->mdev = TCP_TIMEOUT_INIT;
1904
1905 /* So many TCP implementations out there (incorrectly) count the
1906 * initial SYN frame in their delayed-ACK and congestion control
1907 * algorithms that we must have the following bandaid to talk
1908 * efficiently to them. -DaveM
1909 */
1910 tp->snd_cwnd = 2;
1911
1912 /* See draft-stevens-tcpca-spec-01 for discussion of the
1913 * initialization of these values.
1914 */
1915 tp->snd_ssthresh = 0x7fffffff;
1916 tp->snd_cwnd_clamp = ~0;
c1b4a7e6 1917 tp->mss_cache = 536;
1da177e4
LT		 1918
1919 tp->reordering = sysctl_tcp_reordering;
1920
1921 sk->sk_state = TCP_CLOSE;
1922
8292a17a 1923 icsk->icsk_af_ops = &ipv6_specific;
6687e988 1924 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
d83d8461 1925 icsk->icsk_sync_mss = tcp_sync_mss;
1da177e4
LT		 1926 sk->sk_write_space = sk_stream_write_space;
1927 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1928
cfb6eeb4
YH		 1929#ifdef CONFIG_TCP_MD5SIG
1930 tp->af_specific = &tcp_sock_ipv6_specific;
1931#endif
1932
1da177e4
LT		 1933 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1934 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1935
1936 atomic_inc(&tcp_sockets_allocated);
1937
1938 return 0;
1939}
1940
1941static int tcp_v6_destroy_sock(struct sock *sk)
1942{
cfb6eeb4
YH		 1943#ifdef CONFIG_TCP_MD5SIG
1944 /* Clean up the MD5 key list */
1945 if (tcp_sk(sk)->md5sig_info)
1946 tcp_v6_clear_md5_list(sk);
1947#endif
1da177e4
LT		 1948 tcp_v4_destroy_sock(sk);
1949 return inet6_destroy_sock(sk);
1950}
1951
1952/* Proc filesystem TCPv6 sock list dumping. */
1ab1457c 1953static void get_openreq6(struct seq_file *seq,
60236fdd 1954 struct sock *sk, struct request_sock *req, int i, int uid)
1da177e4 1955{
1da177e4 1956 int ttd = req->expires - jiffies;
ca304b61
ACM		 1957 struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1958 struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
1da177e4
LT		 1959
1960 if (ttd < 0)
1961 ttd = 0;
1962
1da177e4
LT		 1963 seq_printf(seq,
1964 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1965 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1966 i,
1967 src->s6_addr32[0], src->s6_addr32[1],
1968 src->s6_addr32[2], src->s6_addr32[3],
1969 ntohs(inet_sk(sk)->sport),
1970 dest->s6_addr32[0], dest->s6_addr32[1],
1971 dest->s6_addr32[2], dest->s6_addr32[3],
2e6599cb 1972 ntohs(inet_rsk(req)->rmt_port),
1da177e4
LT		 1973 TCP_SYN_RECV,
1974 0,0, /* could print option size, but that is af dependent. */
1ab1457c
YH		 1975 1, /* timers active (only the expire timer) */
1976 jiffies_to_clock_t(ttd),
1da177e4
LT		 1977 req->retrans,
1978 uid,
1ab1457c 1979 0, /* non standard timer */
1da177e4
LT		 1980 0, /* open_requests have no inode */
1981 0, req);
1982}
1983
1984static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1985{
1986 struct in6_addr *dest, *src;
1987 __u16 destp, srcp;
1988 int timer_active;
1989 unsigned long timer_expires;
1990 struct inet_sock *inet = inet_sk(sp);
1991 struct tcp_sock *tp = tcp_sk(sp);
463c84b9 1992 const struct inet_connection_sock *icsk = inet_csk(sp);
1da177e4
LT		 1993 struct ipv6_pinfo *np = inet6_sk(sp);
1994
1995 dest = &np->daddr;
1996 src = &np->rcv_saddr;
1997 destp = ntohs(inet->dport);
1998 srcp = ntohs(inet->sport);
463c84b9
ACM		 1999
2000 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1da177e4 2001 timer_active = 1;
463c84b9
ACM		 2002 timer_expires = icsk->icsk_timeout;
2003 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1da177e4 2004 timer_active = 4;
463c84b9 2005 timer_expires = icsk->icsk_timeout;
1da177e4
LT		 2006 } else if (timer_pending(&sp->sk_timer)) {
2007 timer_active = 2;
2008 timer_expires = sp->sk_timer.expires;
2009 } else {
2010 timer_active = 0;
2011 timer_expires = jiffies;
2012 }
2013
2014 seq_printf(seq,
2015 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2016 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %u %u %u %u %d\n",
2017 i,
2018 src->s6_addr32[0], src->s6_addr32[1],
2019 src->s6_addr32[2], src->s6_addr32[3], srcp,
2020 dest->s6_addr32[0], dest->s6_addr32[1],
2021 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1ab1457c 2022 sp->sk_state,
47da8ee6
SS		 2023 tp->write_seq-tp->snd_una,
2024 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
1da177e4
LT		 2025 timer_active,
2026 jiffies_to_clock_t(timer_expires - jiffies),
463c84b9 2027 icsk->icsk_retransmits,
1da177e4 2028 sock_i_uid(sp),
6687e988 2029 icsk->icsk_probes_out,
1da177e4
LT		 2030 sock_i_ino(sp),
2031 atomic_read(&sp->sk_refcnt), sp,
463c84b9
ACM		 2032 icsk->icsk_rto,
2033 icsk->icsk_ack.ato,
2034 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
1da177e4
LT		 2035 tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
2036 );
2037}
2038
1ab1457c 2039static void get_timewait6_sock(struct seq_file *seq,
8feaf0c0 2040 struct inet_timewait_sock *tw, int i)
1da177e4
LT		 2041{
2042 struct in6_addr *dest, *src;
2043 __u16 destp, srcp;
0fa1a53e 2044 struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
1da177e4
LT		 2045 int ttd = tw->tw_ttd - jiffies;
2046
2047 if (ttd < 0)
2048 ttd = 0;
2049
0fa1a53e
ACM		 2050 dest = &tw6->tw_v6_daddr;
2051 src = &tw6->tw_v6_rcv_saddr;
1da177e4
LT		 2052 destp = ntohs(tw->tw_dport);
2053 srcp = ntohs(tw->tw_sport);
2054
2055 seq_printf(seq,
2056 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2057 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2058 i,
2059 src->s6_addr32[0], src->s6_addr32[1],
2060 src->s6_addr32[2], src->s6_addr32[3], srcp,
2061 dest->s6_addr32[0], dest->s6_addr32[1],
2062 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2063 tw->tw_substate, 0, 0,
2064 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2065 atomic_read(&tw->tw_refcnt), tw);
2066}
2067
2068#ifdef CONFIG_PROC_FS
2069static int tcp6_seq_show(struct seq_file *seq, void *v)
2070{
2071 struct tcp_iter_state *st;
2072
2073 if (v == SEQ_START_TOKEN) {
2074 seq_puts(seq,
2075 " sl "
2076 "local_address "
2077 "remote_address "
2078 "st tx_queue rx_queue tr tm->when retrnsmt"
2079 " uid timeout inode\n");
2080 goto out;
2081 }
2082 st = seq->private;
2083
2084 switch (st->state) {
2085 case TCP_SEQ_STATE_LISTENING:
2086 case TCP_SEQ_STATE_ESTABLISHED:
2087 get_tcp6_sock(seq, v, st->num);
2088 break;
2089 case TCP_SEQ_STATE_OPENREQ:
2090 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2091 break;
2092 case TCP_SEQ_STATE_TIME_WAIT:
2093 get_timewait6_sock(seq, v, st->num);
2094 break;
2095 }
2096out:
2097 return 0;
2098}
2099
2100static struct file_operations tcp6_seq_fops;
2101static struct tcp_seq_afinfo tcp6_seq_afinfo = {
2102 .owner = THIS_MODULE,
2103 .name = "tcp6",
2104 .family = AF_INET6,
2105 .seq_show = tcp6_seq_show,
2106 .seq_fops = &tcp6_seq_fops,
2107};
2108
2109int __init tcp6_proc_init(void)
2110{
2111 return tcp_proc_register(&tcp6_seq_afinfo);
2112}
2113
2114void tcp6_proc_exit(void)
2115{
2116 tcp_proc_unregister(&tcp6_seq_afinfo);
2117}
2118#endif
2119
2120struct proto tcpv6_prot = {
2121 .name = "TCPv6",
2122 .owner = THIS_MODULE,
2123 .close = tcp_close,
2124 .connect = tcp_v6_connect,
2125 .disconnect = tcp_disconnect,
463c84b9 2126 .accept = inet_csk_accept,
1da177e4
LT		 2127 .ioctl = tcp_ioctl,
2128 .init = tcp_v6_init_sock,
2129 .destroy = tcp_v6_destroy_sock,
2130 .shutdown = tcp_shutdown,
2131 .setsockopt = tcp_setsockopt,
2132 .getsockopt = tcp_getsockopt,
2133 .sendmsg = tcp_sendmsg,
2134 .recvmsg = tcp_recvmsg,
2135 .backlog_rcv = tcp_v6_do_rcv,
2136 .hash = tcp_v6_hash,
2137 .unhash = tcp_unhash,
2138 .get_port = tcp_v6_get_port,
2139 .enter_memory_pressure = tcp_enter_memory_pressure,
2140 .sockets_allocated = &tcp_sockets_allocated,
2141 .memory_allocated = &tcp_memory_allocated,
2142 .memory_pressure = &tcp_memory_pressure,
0a5578cf 2143 .orphan_count = &tcp_orphan_count,
1da177e4
LT		 2144 .sysctl_mem = sysctl_tcp_mem,
2145 .sysctl_wmem = sysctl_tcp_wmem,
2146 .sysctl_rmem = sysctl_tcp_rmem,
2147 .max_header = MAX_TCP_HEADER,
2148 .obj_size = sizeof(struct tcp6_sock),
6d6ee43e 2149 .twsk_prot = &tcp6_timewait_sock_ops,
60236fdd 2150 .rsk_prot = &tcp6_request_sock_ops,
543d9cfe
ACM		 2151#ifdef CONFIG_COMPAT
2152 .compat_setsockopt = compat_tcp_setsockopt,
2153 .compat_getsockopt = compat_tcp_getsockopt,
2154#endif
1da177e4
LT		 2155};
2156
2157static struct inet6_protocol tcpv6_protocol = {
2158 .handler = tcp_v6_rcv,
2159 .err_handler = tcp_v6_err,
a430a43d 2160 .gso_send_check = tcp_v6_gso_send_check,
adcfc7d0 2161 .gso_segment = tcp_tso_segment,
1da177e4
LT		 2162 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2163};
2164
1da177e4
LT		 2165static struct inet_protosw tcpv6_protosw = {
2166 .type = SOCK_STREAM,
2167 .protocol = IPPROTO_TCP,
2168 .prot = &tcpv6_prot,
2169 .ops = &inet6_stream_ops,
2170 .capability = -1,
2171 .no_check = 0,
d83d8461
ACM		 2172 .flags = INET_PROTOSW_PERMANENT |
2173 INET_PROTOSW_ICSK,
1da177e4
LT		 2174};
2175
2176void __init tcpv6_init(void)
2177{
2178 /* register inet6 protocol */
2179 if (inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP) < 0)
2180 printk(KERN_ERR "tcpv6_init: Could not register protocol\n");
2181 inet6_register_protosw(&tcpv6_protosw);
ae0f7d5f 2182
c4d93909
ACM		 2183 if (inet_csk_ctl_sock_create(&tcp6_socket, PF_INET6, SOCK_RAW,
2184 IPPROTO_TCP) < 0)
ae0f7d5f 2185 panic("Failed to create the TCPv6 control socket.\n");
1da177e4 2186}
Clone of davem's net-next-2.6 tree