projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[NETFILTER]: ip_ct_proto_gre_fini() cannot be __exit
[deliverable/linux.git] / net / ipv6 / tcp_ipv6.c
CommitLineData
1da177e4
LT		 1/*
2 * TCP over IPv6
3 * Linux INET6 implementation
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * $Id: tcp_ipv6.c,v 1.144 2002/02/01 22:01:04 davem Exp $
9 *
10 * Based on:
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>
29#include <linux/config.h>
30#include <linux/errno.h>
31#include <linux/types.h>
32#include <linux/socket.h>
33#include <linux/sockios.h>
34#include <linux/net.h>
35#include <linux/jiffies.h>
36#include <linux/in.h>
37#include <linux/in6.h>
38#include <linux/netdevice.h>
39#include <linux/init.h>
40#include <linux/jhash.h>
41#include <linux/ipsec.h>
42#include <linux/times.h>
43
44#include <linux/ipv6.h>
45#include <linux/icmpv6.h>
46#include <linux/random.h>
47
48#include <net/tcp.h>
49#include <net/ndisc.h>
5324a040 50#include <net/inet6_hashtables.h>
8129765a 51#include <net/inet6_connection_sock.h>
1da177e4
LT		 52#include <net/ipv6.h>
53#include <net/transp_v6.h>
54#include <net/addrconf.h>
55#include <net/ip6_route.h>
56#include <net/ip6_checksum.h>
57#include <net/inet_ecn.h>
58#include <net/protocol.h>
59#include <net/xfrm.h>
60#include <net/addrconf.h>
61#include <net/snmp.h>
62#include <net/dsfield.h>
6d6ee43e 63#include <net/timewait_sock.h>
1da177e4
LT		 64
65#include <asm/uaccess.h>
66
67#include <linux/proc_fs.h>
68#include <linux/seq_file.h>
69
70static void tcp_v6_send_reset(struct sk_buff *skb);
60236fdd 71static void tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req);
8292a17a 72static void tcp_v6_send_check(struct sock *sk, int len,
1da177e4
LT		 73 struct sk_buff *skb);
74
75static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
1da177e4 76
8292a17a
ACM		 77static struct inet_connection_sock_af_ops ipv6_mapped;
78static struct inet_connection_sock_af_ops ipv6_specific;
1da177e4 79
1da177e4
LT		 80static int tcp_v6_get_port(struct sock *sk, unsigned short snum)
81{
971af18b
ACM		 82 return inet_csk_get_port(&tcp_hashinfo, sk, snum,
83 inet6_csk_bind_conflict);
1da177e4
LT		 84}
85
1da177e4
LT		 86static void tcp_v6_hash(struct sock *sk)
87{
88 if (sk->sk_state != TCP_CLOSE) {
8292a17a 89 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
1da177e4
LT		 90 tcp_prot.hash(sk);
91 return;
92 }
93 local_bh_disable();
90b19d31 94 __inet6_hash(&tcp_hashinfo, sk);
1da177e4
LT		 95 local_bh_enable();
96 }
97}
98
1da177e4
LT		 99static __inline__ u16 tcp_v6_check(struct tcphdr *th, int len,
100 struct in6_addr *saddr,
101 struct in6_addr *daddr,
102 unsigned long base)
103{
104 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
105}
106
107static __u32 tcp_v6_init_sequence(struct sock *sk, struct sk_buff *skb)
108{
109 if (skb->protocol == htons(ETH_P_IPV6)) {
110 return secure_tcpv6_sequence_number(skb->nh.ipv6h->daddr.s6_addr32,
111 skb->nh.ipv6h->saddr.s6_addr32,
112 skb->h.th->dest,
113 skb->h.th->source);
114 } else {
115 return secure_tcp_sequence_number(skb->nh.iph->daddr,
116 skb->nh.iph->saddr,
117 skb->h.th->dest,
118 skb->h.th->source);
119 }
120}
121
1da177e4
LT		 122static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
123 int addr_len)
124{
125 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
d83d8461
ACM		 126 struct inet_sock *inet = inet_sk(sk);
127 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT		 128 struct ipv6_pinfo *np = inet6_sk(sk);
129 struct tcp_sock *tp = tcp_sk(sk);
130 struct in6_addr *saddr = NULL, *final_p = NULL, final;
131 struct flowi fl;
132 struct dst_entry *dst;
133 int addr_type;
134 int err;
135
136 if (addr_len < SIN6_LEN_RFC2133)
137 return -EINVAL;
138
139 if (usin->sin6_family != AF_INET6)
140 return(-EAFNOSUPPORT);
141
142 memset(&fl, 0, sizeof(fl));
143
144 if (np->sndflow) {
145 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
146 IP6_ECN_flow_init(fl.fl6_flowlabel);
147 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
148 struct ip6_flowlabel *flowlabel;
149 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
150 if (flowlabel == NULL)
151 return -EINVAL;
152 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
153 fl6_sock_release(flowlabel);
154 }
155 }
156
157 /*
158 * connect() to INADDR_ANY means loopback (BSD'ism).
159 */
160
161 if(ipv6_addr_any(&usin->sin6_addr))
162 usin->sin6_addr.s6_addr[15] = 0x1;
163
164 addr_type = ipv6_addr_type(&usin->sin6_addr);
165
166 if(addr_type & IPV6_ADDR_MULTICAST)
167 return -ENETUNREACH;
168
169 if (addr_type&IPV6_ADDR_LINKLOCAL) {
170 if (addr_len >= sizeof(struct sockaddr_in6) &&
171 usin->sin6_scope_id) {
172 /* If interface is set while binding, indices
173 * must coincide.
174 */
175 if (sk->sk_bound_dev_if &&
176 sk->sk_bound_dev_if != usin->sin6_scope_id)
177 return -EINVAL;
178
179 sk->sk_bound_dev_if = usin->sin6_scope_id;
180 }
181
182 /* Connect to link-local address requires an interface */
183 if (!sk->sk_bound_dev_if)
184 return -EINVAL;
185 }
186
187 if (tp->rx_opt.ts_recent_stamp &&
188 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
189 tp->rx_opt.ts_recent = 0;
190 tp->rx_opt.ts_recent_stamp = 0;
191 tp->write_seq = 0;
192 }
193
194 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
195 np->flow_label = fl.fl6_flowlabel;
196
197 /*
198 * TCP over IPv4
199 */
200
201 if (addr_type == IPV6_ADDR_MAPPED) {
d83d8461 202 u32 exthdrlen = icsk->icsk_ext_hdr_len;
1da177e4
LT		 203 struct sockaddr_in sin;
204
205 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
206
207 if (__ipv6_only_sock(sk))
208 return -ENETUNREACH;
209
210 sin.sin_family = AF_INET;
211 sin.sin_port = usin->sin6_port;
212 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
213
d83d8461 214 icsk->icsk_af_ops = &ipv6_mapped;
1da177e4
LT		 215 sk->sk_backlog_rcv = tcp_v4_do_rcv;
216
217 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
218
219 if (err) {
d83d8461
ACM		 220 icsk->icsk_ext_hdr_len = exthdrlen;
221 icsk->icsk_af_ops = &ipv6_specific;
1da177e4
LT		 222 sk->sk_backlog_rcv = tcp_v6_do_rcv;
223 goto failure;
224 } else {
225 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
226 inet->saddr);
227 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
228 inet->rcv_saddr);
229 }
230
231 return err;
232 }
233
234 if (!ipv6_addr_any(&np->rcv_saddr))
235 saddr = &np->rcv_saddr;
236
237 fl.proto = IPPROTO_TCP;
238 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
239 ipv6_addr_copy(&fl.fl6_src,
240 (saddr ? saddr : &np->saddr));
241 fl.oif = sk->sk_bound_dev_if;
242 fl.fl_ip_dport = usin->sin6_port;
243 fl.fl_ip_sport = inet->sport;
244
245 if (np->opt && np->opt->srcrt) {
246 struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
247 ipv6_addr_copy(&final, &fl.fl6_dst);
248 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
249 final_p = &final;
250 }
251
252 err = ip6_dst_lookup(sk, &dst, &fl);
253 if (err)
254 goto failure;
255 if (final_p)
256 ipv6_addr_copy(&fl.fl6_dst, final_p);
257
e104411b 258 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
1da177e4 259 goto failure;
1da177e4
LT		 260
261 if (saddr == NULL) {
262 saddr = &fl.fl6_src;
263 ipv6_addr_copy(&np->rcv_saddr, saddr);
264 }
265
266 /* set the source address */
267 ipv6_addr_copy(&np->saddr, saddr);
268 inet->rcv_saddr = LOOPBACK4_IPV6;
269
270 ip6_dst_store(sk, dst, NULL);
271 sk->sk_route_caps = dst->dev->features &
272 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
273
d83d8461 274 icsk->icsk_ext_hdr_len = 0;
1da177e4 275 if (np->opt)
d83d8461
ACM		 276 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
277 np->opt->opt_nflen);
1da177e4
LT		 278
279 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
280
281 inet->dport = usin->sin6_port;
282
283 tcp_set_state(sk, TCP_SYN_SENT);
d8313f5c 284 err = inet6_hash_connect(&tcp_death_row, sk);
1da177e4
LT		 285 if (err)
286 goto late_failure;
287
288 if (!tp->write_seq)
289 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
290 np->daddr.s6_addr32,
291 inet->sport,
292 inet->dport);
293
294 err = tcp_connect(sk);
295 if (err)
296 goto late_failure;
297
298 return 0;
299
300late_failure:
301 tcp_set_state(sk, TCP_CLOSE);
302 __sk_dst_reset(sk);
303failure:
304 inet->dport = 0;
305 sk->sk_route_caps = 0;
306 return err;
307}
308
309static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
310 int type, int code, int offset, __u32 info)
311{
312 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
505cbfc5 313 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
1da177e4
LT		 314 struct ipv6_pinfo *np;
315 struct sock *sk;
316 int err;
317 struct tcp_sock *tp;
318 __u32 seq;
319
505cbfc5
ACM		 320 sk = inet6_lookup(&tcp_hashinfo, &hdr->daddr, th->dest, &hdr->saddr,
321 th->source, skb->dev->ifindex);
1da177e4
LT		 322
323 if (sk == NULL) {
324 ICMP6_INC_STATS_BH(__in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
325 return;
326 }
327
328 if (sk->sk_state == TCP_TIME_WAIT) {
8feaf0c0 329 inet_twsk_put((struct inet_timewait_sock *)sk);
1da177e4
LT		 330 return;
331 }
332
333 bh_lock_sock(sk);
334 if (sock_owned_by_user(sk))
335 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
336
337 if (sk->sk_state == TCP_CLOSE)
338 goto out;
339
340 tp = tcp_sk(sk);
341 seq = ntohl(th->seq);
342 if (sk->sk_state != TCP_LISTEN &&
343 !between(seq, tp->snd_una, tp->snd_nxt)) {
344 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
345 goto out;
346 }
347
348 np = inet6_sk(sk);
349
350 if (type == ICMPV6_PKT_TOOBIG) {
351 struct dst_entry *dst = NULL;
352
353 if (sock_owned_by_user(sk))
354 goto out;
355 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
356 goto out;
357
358 /* icmp should have updated the destination cache entry */
359 dst = __sk_dst_check(sk, np->dst_cookie);
360
361 if (dst == NULL) {
362 struct inet_sock *inet = inet_sk(sk);
363 struct flowi fl;
364
365 /* BUGGG_FUTURE: Again, it is not clear how
366 to handle rthdr case. Ignore this complexity
367 for now.
368 */
369 memset(&fl, 0, sizeof(fl));
370 fl.proto = IPPROTO_TCP;
371 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
372 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
373 fl.oif = sk->sk_bound_dev_if;
374 fl.fl_ip_dport = inet->dport;
375 fl.fl_ip_sport = inet->sport;
376
377 if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
378 sk->sk_err_soft = -err;
379 goto out;
380 }
381
382 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
383 sk->sk_err_soft = -err;
384 goto out;
385 }
386
387 } else
388 dst_hold(dst);
389
d83d8461 390 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
1da177e4
LT		 391 tcp_sync_mss(sk, dst_mtu(dst));
392 tcp_simple_retransmit(sk);
393 } /* else let the usual retransmit timer handle it */
394 dst_release(dst);
395 goto out;
396 }
397
398 icmpv6_err_convert(type, code, &err);
399
60236fdd 400 /* Might be for an request_sock */
1da177e4 401 switch (sk->sk_state) {
60236fdd 402 struct request_sock *req, **prev;
1da177e4
LT		 403 case TCP_LISTEN:
404 if (sock_owned_by_user(sk))
405 goto out;
406
8129765a
ACM		 407 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
408 &hdr->saddr, inet6_iif(skb));
1da177e4
LT		 409 if (!req)
410 goto out;
411
412 /* ICMPs are not backlogged, hence we cannot get
413 * an established socket here.
414 */
415 BUG_TRAP(req->sk == NULL);
416
2e6599cb 417 if (seq != tcp_rsk(req)->snt_isn) {
1da177e4
LT		 418 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
419 goto out;
420 }
421
463c84b9 422 inet_csk_reqsk_queue_drop(sk, req, prev);
1da177e4
LT		 423 goto out;
424
425 case TCP_SYN_SENT:
426 case TCP_SYN_RECV: /* Cannot happen.
427 It can, it SYNs are crossed. --ANK */
428 if (!sock_owned_by_user(sk)) {
429 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
430 sk->sk_err = err;
431 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
432
433 tcp_done(sk);
434 } else
435 sk->sk_err_soft = err;
436 goto out;
437 }
438
439 if (!sock_owned_by_user(sk) && np->recverr) {
440 sk->sk_err = err;
441 sk->sk_error_report(sk);
442 } else
443 sk->sk_err_soft = err;
444
445out:
446 bh_unlock_sock(sk);
447 sock_put(sk);
448}
449
450
60236fdd 451static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
1da177e4
LT		 452 struct dst_entry *dst)
453{
ca304b61 454 struct inet6_request_sock *treq = inet6_rsk(req);
1da177e4
LT		 455 struct ipv6_pinfo *np = inet6_sk(sk);
456 struct sk_buff * skb;
457 struct ipv6_txoptions *opt = NULL;
458 struct in6_addr * final_p = NULL, final;
459 struct flowi fl;
460 int err = -1;
461
462 memset(&fl, 0, sizeof(fl));
463 fl.proto = IPPROTO_TCP;
2e6599cb
ACM		 464 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
465 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
1da177e4 466 fl.fl6_flowlabel = 0;
2e6599cb
ACM		 467 fl.oif = treq->iif;
468 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
1da177e4
LT		 469 fl.fl_ip_sport = inet_sk(sk)->sport;
470
471 if (dst == NULL) {
472 opt = np->opt;
473 if (opt == NULL &&
333fad53 474 np->rxopt.bits.osrcrt == 2 &&
2e6599cb
ACM		 475 treq->pktopts) {
476 struct sk_buff *pktopts = treq->pktopts;
1da177e4
LT		 477 struct inet6_skb_parm *rxopt = IP6CB(pktopts);
478 if (rxopt->srcrt)
479 opt = ipv6_invert_rthdr(sk, (struct ipv6_rt_hdr*)(pktopts->nh.raw + rxopt->srcrt));
480 }
481
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;
487 }
488
489 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 }
497
498 skb = tcp_make_synack(sk, dst, req);
499 if (skb) {
500 struct tcphdr *th = skb->h.th;
501
502 th->check = tcp_v6_check(th, skb->len,
2e6599cb 503 &treq->loc_addr, &treq->rmt_addr,
1da177e4
LT		 504 csum_partial((char *)th, skb->len, skb->csum));
505
2e6599cb 506 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
1da177e4
LT		 507 err = ip6_xmit(sk, skb, &fl, opt, 0);
508 if (err == NET_XMIT_CN)
509 err = 0;
510 }
511
512done:
1da177e4
LT		 513 if (opt && opt != np->opt)
514 sock_kfree_s(sk, opt, opt->tot_len);
515 return err;
516}
517
60236fdd 518static void tcp_v6_reqsk_destructor(struct request_sock *req)
1da177e4 519{
ca304b61
ACM		 520 if (inet6_rsk(req)->pktopts)
521 kfree_skb(inet6_rsk(req)->pktopts);
1da177e4
LT		 522}
523
60236fdd 524static struct request_sock_ops tcp6_request_sock_ops = {
1da177e4 525 .family = AF_INET6,
2e6599cb 526 .obj_size = sizeof(struct tcp6_request_sock),
1da177e4 527 .rtx_syn_ack = tcp_v6_send_synack,
60236fdd
ACM		 528 .send_ack = tcp_v6_reqsk_send_ack,
529 .destructor = tcp_v6_reqsk_destructor,
1da177e4
LT		 530 .send_reset = tcp_v6_send_reset
531};
532
6d6ee43e
ACM		 533static struct timewait_sock_ops tcp6_timewait_sock_ops = {
534 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
535 .twsk_unique = tcp_twsk_unique,
536};
537
8292a17a 538static void tcp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb)
1da177e4
LT		 539{
540 struct ipv6_pinfo *np = inet6_sk(sk);
8292a17a 541 struct tcphdr *th = skb->h.th;
1da177e4
LT		 542
543 if (skb->ip_summed == CHECKSUM_HW) {
544 th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0);
545 skb->csum = offsetof(struct tcphdr, check);
546 } else {
547 th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
548 csum_partial((char *)th, th->doff<<2,
549 skb->csum));
550 }
551}
552
553
554static void tcp_v6_send_reset(struct sk_buff *skb)
555{
556 struct tcphdr *th = skb->h.th, *t1;
557 struct sk_buff *buff;
558 struct flowi fl;
559
560 if (th->rst)
561 return;
562
563 if (!ipv6_unicast_destination(skb))
564 return;
565
566 /*
567 * We need to grab some memory, and put together an RST,
568 * and then put it into the queue to be sent.
569 */
570
571 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + sizeof(struct tcphdr),
572 GFP_ATOMIC);
573 if (buff == NULL)
574 return;
575
576 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + sizeof(struct tcphdr));
577
578 t1 = (struct tcphdr *) skb_push(buff,sizeof(struct tcphdr));
579
580 /* Swap the send and the receive. */
581 memset(t1, 0, sizeof(*t1));
582 t1->dest = th->source;
583 t1->source = th->dest;
584 t1->doff = sizeof(*t1)/4;
585 t1->rst = 1;
586
587 if(th->ack) {
588 t1->seq = th->ack_seq;
589 } else {
590 t1->ack = 1;
591 t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
592 + skb->len - (th->doff<<2));
593 }
594
595 buff->csum = csum_partial((char *)t1, sizeof(*t1), 0);
596
597 memset(&fl, 0, sizeof(fl));
598 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
599 ipv6_addr_copy(&fl.fl6_src, &skb->nh.ipv6h->daddr);
600
601 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
602 sizeof(*t1), IPPROTO_TCP,
603 buff->csum);
604
605 fl.proto = IPPROTO_TCP;
505cbfc5 606 fl.oif = inet6_iif(skb);
1da177e4
LT		 607 fl.fl_ip_dport = t1->dest;
608 fl.fl_ip_sport = t1->source;
609
610 /* sk = NULL, but it is safe for now. RST socket required. */
611 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
612
ecc51b6d
ACM		 613 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
614 ip6_xmit(NULL, buff, &fl, NULL, 0);
615 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
616 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
1da177e4 617 return;
ecc51b6d 618 }
1da177e4
LT		 619 }
620
621 kfree_skb(buff);
622}
623
624static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts)
625{
626 struct tcphdr *th = skb->h.th, *t1;
627 struct sk_buff *buff;
628 struct flowi fl;
629 int tot_len = sizeof(struct tcphdr);
630
631 if (ts)
632 tot_len += 3*4;
633
634 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
635 GFP_ATOMIC);
636 if (buff == NULL)
637 return;
638
639 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
640
641 t1 = (struct tcphdr *) skb_push(buff,tot_len);
642
643 /* Swap the send and the receive. */
644 memset(t1, 0, sizeof(*t1));
645 t1->dest = th->source;
646 t1->source = th->dest;
647 t1->doff = tot_len/4;
648 t1->seq = htonl(seq);
649 t1->ack_seq = htonl(ack);
650 t1->ack = 1;
651 t1->window = htons(win);
652
653 if (ts) {
654 u32 *ptr = (u32*)(t1 + 1);
655 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
656 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
657 *ptr++ = htonl(tcp_time_stamp);
658 *ptr = htonl(ts);
659 }
660
661 buff->csum = csum_partial((char *)t1, tot_len, 0);
662
663 memset(&fl, 0, sizeof(fl));
664 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
665 ipv6_addr_copy(&fl.fl6_src, &skb->nh.ipv6h->daddr);
666
667 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
668 tot_len, IPPROTO_TCP,
669 buff->csum);
670
671 fl.proto = IPPROTO_TCP;
505cbfc5 672 fl.oif = inet6_iif(skb);
1da177e4
LT		 673 fl.fl_ip_dport = t1->dest;
674 fl.fl_ip_sport = t1->source;
675
676 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
ecc51b6d
ACM		 677 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
678 ip6_xmit(NULL, buff, &fl, NULL, 0);
679 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1da177e4 680 return;
ecc51b6d 681 }
1da177e4
LT		 682 }
683
684 kfree_skb(buff);
685}
686
687static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
688{
8feaf0c0
ACM		 689 struct inet_timewait_sock *tw = inet_twsk(sk);
690 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1da177e4 691
8feaf0c0
ACM		 692 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
693 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
694 tcptw->tw_ts_recent);
1da177e4 695
8feaf0c0 696 inet_twsk_put(tw);
1da177e4
LT		 697}
698
60236fdd 699static void tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
1da177e4 700{
2e6599cb 701 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent);
1da177e4
LT		 702}
703
704
705static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
706{
60236fdd 707 struct request_sock *req, **prev;
505cbfc5 708 const struct tcphdr *th = skb->h.th;
1da177e4
LT		 709 struct sock *nsk;
710
711 /* Find possible connection requests. */
8129765a
ACM		 712 req = inet6_csk_search_req(sk, &prev, th->source,
713 &skb->nh.ipv6h->saddr,
714 &skb->nh.ipv6h->daddr, inet6_iif(skb));
1da177e4
LT		 715 if (req)
716 return tcp_check_req(sk, skb, req, prev);
717
505cbfc5
ACM		 718 nsk = __inet6_lookup_established(&tcp_hashinfo, &skb->nh.ipv6h->saddr,
719 th->source, &skb->nh.ipv6h->daddr,
720 ntohs(th->dest), inet6_iif(skb));
1da177e4
LT		 721
722 if (nsk) {
723 if (nsk->sk_state != TCP_TIME_WAIT) {
724 bh_lock_sock(nsk);
725 return nsk;
726 }
8feaf0c0 727 inet_twsk_put((struct inet_timewait_sock *)nsk);
1da177e4
LT		 728 return NULL;
729 }
730
731#if 0 /*def CONFIG_SYN_COOKIES*/
732 if (!th->rst && !th->syn && th->ack)
733 sk = cookie_v6_check(sk, skb, &(IPCB(skb)->opt));
734#endif
735 return sk;
736}
737
1da177e4
LT		 738/* FIXME: this is substantially similar to the ipv4 code.
739 * Can some kind of merge be done? -- erics
740 */
741static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
742{
ca304b61 743 struct inet6_request_sock *treq;
1da177e4
LT		 744 struct ipv6_pinfo *np = inet6_sk(sk);
745 struct tcp_options_received tmp_opt;
746 struct tcp_sock *tp = tcp_sk(sk);
60236fdd 747 struct request_sock *req = NULL;
1da177e4
LT		 748 __u32 isn = TCP_SKB_CB(skb)->when;
749
750 if (skb->protocol == htons(ETH_P_IP))
751 return tcp_v4_conn_request(sk, skb);
752
753 if (!ipv6_unicast_destination(skb))
754 goto drop;
755
756 /*
757 * There are no SYN attacks on IPv6, yet...
758 */
463c84b9 759 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1da177e4
LT		 760 if (net_ratelimit())
761 printk(KERN_INFO "TCPv6: dropping request, synflood is possible\n");
762 goto drop;
763 }
764
463c84b9 765 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1da177e4
LT		 766 goto drop;
767
ca304b61 768 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
1da177e4
LT		 769 if (req == NULL)
770 goto drop;
771
772 tcp_clear_options(&tmp_opt);
773 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
774 tmp_opt.user_mss = tp->rx_opt.user_mss;
775
776 tcp_parse_options(skb, &tmp_opt, 0);
777
778 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
779 tcp_openreq_init(req, &tmp_opt, skb);
780
ca304b61 781 treq = inet6_rsk(req);
2e6599cb
ACM		 782 ipv6_addr_copy(&treq->rmt_addr, &skb->nh.ipv6h->saddr);
783 ipv6_addr_copy(&treq->loc_addr, &skb->nh.ipv6h->daddr);
1da177e4 784 TCP_ECN_create_request(req, skb->h.th);
2e6599cb 785 treq->pktopts = NULL;
1da177e4 786 if (ipv6_opt_accepted(sk, skb) ||
333fad53
YH		 787 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
788 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1da177e4 789 atomic_inc(&skb->users);
2e6599cb 790 treq->pktopts = skb;
1da177e4 791 }
2e6599cb 792 treq->iif = sk->sk_bound_dev_if;
1da177e4
LT		 793
794 /* So that link locals have meaning */
795 if (!sk->sk_bound_dev_if &&
2e6599cb 796 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
505cbfc5 797 treq->iif = inet6_iif(skb);
1da177e4
LT		 798
799 if (isn == 0)
800 isn = tcp_v6_init_sequence(sk,skb);
801
2e6599cb 802 tcp_rsk(req)->snt_isn = isn;
1da177e4
LT		 803
804 if (tcp_v6_send_synack(sk, req, NULL))
805 goto drop;
806
8129765a 807 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1da177e4
LT		 808 return 0;
809
810drop:
811 if (req)
60236fdd 812 reqsk_free(req);
1da177e4
LT		 813
814 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
815 return 0; /* don't send reset */
816}
817
818static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
60236fdd 819 struct request_sock *req,
1da177e4
LT		 820 struct dst_entry *dst)
821{
ca304b61 822 struct inet6_request_sock *treq = inet6_rsk(req);
1da177e4
LT		 823 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
824 struct tcp6_sock *newtcp6sk;
825 struct inet_sock *newinet;
826 struct tcp_sock *newtp;
827 struct sock *newsk;
828 struct ipv6_txoptions *opt;
829
830 if (skb->protocol == htons(ETH_P_IP)) {
831 /*
832 * v6 mapped
833 */
834
835 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
836
837 if (newsk == NULL)
838 return NULL;
839
840 newtcp6sk = (struct tcp6_sock *)newsk;
841 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
842
843 newinet = inet_sk(newsk);
844 newnp = inet6_sk(newsk);
845 newtp = tcp_sk(newsk);
846
847 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
848
849 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
850 newinet->daddr);
851
852 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
853 newinet->saddr);
854
855 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
856
8292a17a 857 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1da177e4
LT		 858 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
859 newnp->pktoptions = NULL;
860 newnp->opt = NULL;
505cbfc5 861 newnp->mcast_oif = inet6_iif(skb);
1da177e4
LT		 862 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
863
e6848976
ACM		 864 /*
865 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
866 * here, tcp_create_openreq_child now does this for us, see the comment in
867 * that function for the gory details. -acme
1da177e4 868 */
1da177e4
LT		 869
870 /* It is tricky place. Until this moment IPv4 tcp
8292a17a 871 worked with IPv6 icsk.icsk_af_ops.
1da177e4
LT		 872 Sync it now.
873 */
d83d8461 874 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1da177e4
LT		 875
876 return newsk;
877 }
878
879 opt = np->opt;
880
881 if (sk_acceptq_is_full(sk))
882 goto out_overflow;
883
333fad53 884 if (np->rxopt.bits.osrcrt == 2 &&
2e6599cb
ACM		 885 opt == NULL && treq->pktopts) {
886 struct inet6_skb_parm *rxopt = IP6CB(treq->pktopts);
1da177e4 887 if (rxopt->srcrt)
2e6599cb 888 opt = ipv6_invert_rthdr(sk, (struct ipv6_rt_hdr *)(treq->pktopts->nh.raw + rxopt->srcrt));
1da177e4
LT		 889 }
890
891 if (dst == NULL) {
892 struct in6_addr *final_p = NULL, final;
893 struct flowi fl;
894
895 memset(&fl, 0, sizeof(fl));
896 fl.proto = IPPROTO_TCP;
2e6599cb 897 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
1da177e4
LT		 898 if (opt && opt->srcrt) {
899 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
900 ipv6_addr_copy(&final, &fl.fl6_dst);
901 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
902 final_p = &final;
903 }
2e6599cb 904 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
1da177e4 905 fl.oif = sk->sk_bound_dev_if;
2e6599cb 906 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
1da177e4
LT		 907 fl.fl_ip_sport = inet_sk(sk)->sport;
908
909 if (ip6_dst_lookup(sk, &dst, &fl))
910 goto out;
911
912 if (final_p)
913 ipv6_addr_copy(&fl.fl6_dst, final_p);
914
915 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
916 goto out;
917 }
918
919 newsk = tcp_create_openreq_child(sk, req, skb);
920 if (newsk == NULL)
921 goto out;
922
e6848976
ACM		 923 /*
924 * No need to charge this sock to the relevant IPv6 refcnt debug socks
925 * count here, tcp_create_openreq_child now does this for us, see the
926 * comment in that function for the gory details. -acme
927 */
1da177e4
LT		 928
929 ip6_dst_store(newsk, dst, NULL);
930 newsk->sk_route_caps = dst->dev->features &
931 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
932
933 newtcp6sk = (struct tcp6_sock *)newsk;
934 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
935
936 newtp = tcp_sk(newsk);
937 newinet = inet_sk(newsk);
938 newnp = inet6_sk(newsk);
939
940 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
941
2e6599cb
ACM		 942 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
943 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
944 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
945 newsk->sk_bound_dev_if = treq->iif;
1da177e4
LT		 946
947 /* Now IPv6 options...
948
949 First: no IPv4 options.
950 */
951 newinet->opt = NULL;
952
953 /* Clone RX bits */
954 newnp->rxopt.all = np->rxopt.all;
955
956 /* Clone pktoptions received with SYN */
957 newnp->pktoptions = NULL;
2e6599cb
ACM		 958 if (treq->pktopts != NULL) {
959 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
960 kfree_skb(treq->pktopts);
961 treq->pktopts = NULL;
1da177e4
LT		 962 if (newnp->pktoptions)
963 skb_set_owner_r(newnp->pktoptions, newsk);
964 }
965 newnp->opt = NULL;
505cbfc5 966 newnp->mcast_oif = inet6_iif(skb);
1da177e4
LT		 967 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
968
969 /* Clone native IPv6 options from listening socket (if any)
970
971 Yes, keeping reference count would be much more clever,
972 but we make one more one thing there: reattach optmem
973 to newsk.
974 */
975 if (opt) {
976 newnp->opt = ipv6_dup_options(newsk, opt);
977 if (opt != np->opt)
978 sock_kfree_s(sk, opt, opt->tot_len);
979 }
980
d83d8461 981 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1da177e4 982 if (newnp->opt)
d83d8461
ACM		 983 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
984 newnp->opt->opt_flen);
1da177e4
LT		 985
986 tcp_sync_mss(newsk, dst_mtu(dst));
987 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
988 tcp_initialize_rcv_mss(newsk);
989
990 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
991
90b19d31 992 __inet6_hash(&tcp_hashinfo, newsk);
2d8c4ce5 993 inet_inherit_port(&tcp_hashinfo, sk, newsk);
1da177e4
LT		 994
995 return newsk;
996
997out_overflow:
998 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
999out:
1000 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1001 if (opt && opt != np->opt)
1002 sock_kfree_s(sk, opt, opt->tot_len);
1003 dst_release(dst);
1004 return NULL;
1005}
1006
1007static int tcp_v6_checksum_init(struct sk_buff *skb)
1008{
1009 if (skb->ip_summed == CHECKSUM_HW) {
1da177e4 1010 if (!tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
fb286bb2
HX		 1011 &skb->nh.ipv6h->daddr,skb->csum)) {
1012 skb->ip_summed = CHECKSUM_UNNECESSARY;
1da177e4 1013 return 0;
fb286bb2 1014 }
1da177e4 1015 }
fb286bb2
HX		 1016
1017 skb->csum = ~tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
1018 &skb->nh.ipv6h->daddr, 0);
1019
1da177e4 1020 if (skb->len <= 76) {
fb286bb2 1021 return __skb_checksum_complete(skb);
1da177e4
LT		 1022 }
1023 return 0;
1024}
1025
1026/* The socket must have it's spinlock held when we get
1027 * here.
1028 *
1029 * We have a potential double-lock case here, so even when
1030 * doing backlog processing we use the BH locking scheme.
1031 * This is because we cannot sleep with the original spinlock
1032 * held.
1033 */
1034static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1035{
1036 struct ipv6_pinfo *np = inet6_sk(sk);
1037 struct tcp_sock *tp;
1038 struct sk_buff *opt_skb = NULL;
1039
1040 /* Imagine: socket is IPv6. IPv4 packet arrives,
1041 goes to IPv4 receive handler and backlogged.
1042 From backlog it always goes here. Kerboom...
1043 Fortunately, tcp_rcv_established and rcv_established
1044 handle them correctly, but it is not case with
1045 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1046 */
1047
1048 if (skb->protocol == htons(ETH_P_IP))
1049 return tcp_v4_do_rcv(sk, skb);
1050
1051 if (sk_filter(sk, skb, 0))
1052 goto discard;
1053
1054 /*
1055 * socket locking is here for SMP purposes as backlog rcv
1056 * is currently called with bh processing disabled.
1057 */
1058
1059 /* Do Stevens' IPV6_PKTOPTIONS.
1060
1061 Yes, guys, it is the only place in our code, where we
1062 may make it not affecting IPv4.
1063 The rest of code is protocol independent,
1064 and I do not like idea to uglify IPv4.
1065
1066 Actually, all the idea behind IPV6_PKTOPTIONS
1067 looks not very well thought. For now we latch
1068 options, received in the last packet, enqueued
1069 by tcp. Feel free to propose better solution.
1070 --ANK (980728)
1071 */
1072 if (np->rxopt.all)
1073 opt_skb = skb_clone(skb, GFP_ATOMIC);
1074
1075 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1076 TCP_CHECK_TIMER(sk);
1077 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1078 goto reset;
1079 TCP_CHECK_TIMER(sk);
1080 if (opt_skb)
1081 goto ipv6_pktoptions;
1082 return 0;
1083 }
1084
1085 if (skb->len < (skb->h.th->doff<<2) || tcp_checksum_complete(skb))
1086 goto csum_err;
1087
1088 if (sk->sk_state == TCP_LISTEN) {
1089 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1090 if (!nsk)
1091 goto discard;
1092
1093 /*
1094 * Queue it on the new socket if the new socket is active,
1095 * otherwise we just shortcircuit this and continue with
1096 * the new socket..
1097 */
1098 if(nsk != sk) {
1099 if (tcp_child_process(sk, nsk, skb))
1100 goto reset;
1101 if (opt_skb)
1102 __kfree_skb(opt_skb);
1103 return 0;
1104 }
1105 }
1106
1107 TCP_CHECK_TIMER(sk);
1108 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1109 goto reset;
1110 TCP_CHECK_TIMER(sk);
1111 if (opt_skb)
1112 goto ipv6_pktoptions;
1113 return 0;
1114
1115reset:
1116 tcp_v6_send_reset(skb);
1117discard:
1118 if (opt_skb)
1119 __kfree_skb(opt_skb);
1120 kfree_skb(skb);
1121 return 0;
1122csum_err:
1123 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1124 goto discard;
1125
1126
1127ipv6_pktoptions:
1128 /* Do you ask, what is it?
1129
1130 1. skb was enqueued by tcp.
1131 2. skb is added to tail of read queue, rather than out of order.
1132 3. socket is not in passive state.
1133 4. Finally, it really contains options, which user wants to receive.
1134 */
1135 tp = tcp_sk(sk);
1136 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1137 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
333fad53 1138 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
505cbfc5 1139 np->mcast_oif = inet6_iif(opt_skb);
333fad53 1140 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1da177e4
LT		 1141 np->mcast_hops = opt_skb->nh.ipv6h->hop_limit;
1142 if (ipv6_opt_accepted(sk, opt_skb)) {
1143 skb_set_owner_r(opt_skb, sk);
1144 opt_skb = xchg(&np->pktoptions, opt_skb);
1145 } else {
1146 __kfree_skb(opt_skb);
1147 opt_skb = xchg(&np->pktoptions, NULL);
1148 }
1149 }
1150
1151 if (opt_skb)
1152 kfree_skb(opt_skb);
1153 return 0;
1154}
1155
951dbc8a 1156static int tcp_v6_rcv(struct sk_buff **pskb)
1da177e4
LT		 1157{
1158 struct sk_buff *skb = *pskb;
1159 struct tcphdr *th;
1160 struct sock *sk;
1161 int ret;
1162
1163 if (skb->pkt_type != PACKET_HOST)
1164 goto discard_it;
1165
1166 /*
1167 * Count it even if it's bad.
1168 */
1169 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1170
1171 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1172 goto discard_it;
1173
1174 th = skb->h.th;
1175
1176 if (th->doff < sizeof(struct tcphdr)/4)
1177 goto bad_packet;
1178 if (!pskb_may_pull(skb, th->doff*4))
1179 goto discard_it;
1180
1181 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
fb286bb2 1182 tcp_v6_checksum_init(skb)))
1da177e4
LT		 1183 goto bad_packet;
1184
1185 th = skb->h.th;
1186 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1187 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1188 skb->len - th->doff*4);
1189 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1190 TCP_SKB_CB(skb)->when = 0;
1191 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(skb->nh.ipv6h);
1192 TCP_SKB_CB(skb)->sacked = 0;
1193
505cbfc5
ACM		 1194 sk = __inet6_lookup(&tcp_hashinfo, &skb->nh.ipv6h->saddr, th->source,
1195 &skb->nh.ipv6h->daddr, ntohs(th->dest),
1196 inet6_iif(skb));
1da177e4
LT		 1197
1198 if (!sk)
1199 goto no_tcp_socket;
1200
1201process:
1202 if (sk->sk_state == TCP_TIME_WAIT)
1203 goto do_time_wait;
1204
1205 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1206 goto discard_and_relse;
1207
1208 if (sk_filter(sk, skb, 0))
1209 goto discard_and_relse;
1210
1211 skb->dev = NULL;
1212
1213 bh_lock_sock(sk);
1214 ret = 0;
1215 if (!sock_owned_by_user(sk)) {
1216 if (!tcp_prequeue(sk, skb))
1217 ret = tcp_v6_do_rcv(sk, skb);
1218 } else
1219 sk_add_backlog(sk, skb);
1220 bh_unlock_sock(sk);
1221
1222 sock_put(sk);
1223 return ret ? -1 : 0;
1224
1225no_tcp_socket:
1226 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1227 goto discard_it;
1228
1229 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1230bad_packet:
1231 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1232 } else {
1233 tcp_v6_send_reset(skb);
1234 }
1235
1236discard_it:
1237
1238 /*
1239 * Discard frame
1240 */
1241
1242 kfree_skb(skb);
1243 return 0;
1244
1245discard_and_relse:
1246 sock_put(sk);
1247 goto discard_it;
1248
1249do_time_wait:
1250 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
8feaf0c0 1251 inet_twsk_put((struct inet_timewait_sock *)sk);
1da177e4
LT		 1252 goto discard_it;
1253 }
1254
1255 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1256 TCP_INC_STATS_BH(TCP_MIB_INERRS);
8feaf0c0 1257 inet_twsk_put((struct inet_timewait_sock *)sk);
1da177e4
LT		 1258 goto discard_it;
1259 }
1260
8feaf0c0
ACM		 1261 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1262 skb, th)) {
1da177e4
LT		 1263 case TCP_TW_SYN:
1264 {
1265 struct sock *sk2;
1266
505cbfc5
ACM		 1267 sk2 = inet6_lookup_listener(&tcp_hashinfo,
1268 &skb->nh.ipv6h->daddr,
1269 ntohs(th->dest), inet6_iif(skb));
1da177e4 1270 if (sk2 != NULL) {
295ff7ed
ACM		 1271 struct inet_timewait_sock *tw = inet_twsk(sk);
1272 inet_twsk_deschedule(tw, &tcp_death_row);
1273 inet_twsk_put(tw);
1da177e4
LT		 1274 sk = sk2;
1275 goto process;
1276 }
1277 /* Fall through to ACK */
1278 }
1279 case TCP_TW_ACK:
1280 tcp_v6_timewait_ack(sk, skb);
1281 break;
1282 case TCP_TW_RST:
1283 goto no_tcp_socket;
1284 case TCP_TW_SUCCESS:;
1285 }
1286 goto discard_it;
1287}
1288
1da177e4
LT		 1289static int tcp_v6_remember_stamp(struct sock *sk)
1290{
1291 /* Alas, not yet... */
1292 return 0;
1293}
1294
8292a17a 1295static struct inet_connection_sock_af_ops ipv6_specific = {
b9750ce1 1296 .queue_xmit = inet6_csk_xmit,
1da177e4 1297 .send_check = tcp_v6_send_check,
b9750ce1 1298 .rebuild_header = inet6_sk_rebuild_header,
1da177e4
LT		 1299 .conn_request = tcp_v6_conn_request,
1300 .syn_recv_sock = tcp_v6_syn_recv_sock,
1301 .remember_stamp = tcp_v6_remember_stamp,
1302 .net_header_len = sizeof(struct ipv6hdr),
1303
1304 .setsockopt = ipv6_setsockopt,
1305 .getsockopt = ipv6_getsockopt,
b9750ce1 1306 .addr2sockaddr = inet6_csk_addr2sockaddr,
1da177e4
LT		 1307 .sockaddr_len = sizeof(struct sockaddr_in6)
1308};
1309
1310/*
1311 * TCP over IPv4 via INET6 API
1312 */
1313
8292a17a 1314static struct inet_connection_sock_af_ops ipv6_mapped = {
1da177e4
LT		 1315 .queue_xmit = ip_queue_xmit,
1316 .send_check = tcp_v4_send_check,
32519f11 1317 .rebuild_header = inet_sk_rebuild_header,
1da177e4
LT		 1318 .conn_request = tcp_v6_conn_request,
1319 .syn_recv_sock = tcp_v6_syn_recv_sock,
1320 .remember_stamp = tcp_v4_remember_stamp,
1321 .net_header_len = sizeof(struct iphdr),
1322
1323 .setsockopt = ipv6_setsockopt,
1324 .getsockopt = ipv6_getsockopt,
b9750ce1 1325 .addr2sockaddr = inet6_csk_addr2sockaddr,
1da177e4
LT		 1326 .sockaddr_len = sizeof(struct sockaddr_in6)
1327};
1328
1329
1330
1331/* NOTE: A lot of things set to zero explicitly by call to
1332 * sk_alloc() so need not be done here.
1333 */
1334static int tcp_v6_init_sock(struct sock *sk)
1335{
6687e988 1336 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT		 1337 struct tcp_sock *tp = tcp_sk(sk);
1338
1339 skb_queue_head_init(&tp->out_of_order_queue);
1340 tcp_init_xmit_timers(sk);
1341 tcp_prequeue_init(tp);
1342
6687e988 1343 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1da177e4
LT		 1344 tp->mdev = TCP_TIMEOUT_INIT;
1345
1346 /* So many TCP implementations out there (incorrectly) count the
1347 * initial SYN frame in their delayed-ACK and congestion control
1348 * algorithms that we must have the following bandaid to talk
1349 * efficiently to them. -DaveM
1350 */
1351 tp->snd_cwnd = 2;
1352
1353 /* See draft-stevens-tcpca-spec-01 for discussion of the
1354 * initialization of these values.
1355 */
1356 tp->snd_ssthresh = 0x7fffffff;
1357 tp->snd_cwnd_clamp = ~0;
c1b4a7e6 1358 tp->mss_cache = 536;
1da177e4
LT		 1359
1360 tp->reordering = sysctl_tcp_reordering;
1361
1362 sk->sk_state = TCP_CLOSE;
1363
8292a17a 1364 icsk->icsk_af_ops = &ipv6_specific;
6687e988 1365 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
d83d8461 1366 icsk->icsk_sync_mss = tcp_sync_mss;
1da177e4
LT		 1367 sk->sk_write_space = sk_stream_write_space;
1368 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1369
1370 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1371 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1372
1373 atomic_inc(&tcp_sockets_allocated);
1374
1375 return 0;
1376}
1377
1378static int tcp_v6_destroy_sock(struct sock *sk)
1379{
1da177e4
LT		 1380 tcp_v4_destroy_sock(sk);
1381 return inet6_destroy_sock(sk);
1382}
1383
1384/* Proc filesystem TCPv6 sock list dumping. */
1385static void get_openreq6(struct seq_file *seq,
60236fdd 1386 struct sock *sk, struct request_sock *req, int i, int uid)
1da177e4 1387{
1da177e4 1388 int ttd = req->expires - jiffies;
ca304b61
ACM		 1389 struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1390 struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
1da177e4
LT		 1391
1392 if (ttd < 0)
1393 ttd = 0;
1394
1da177e4
LT		 1395 seq_printf(seq,
1396 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1397 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1398 i,
1399 src->s6_addr32[0], src->s6_addr32[1],
1400 src->s6_addr32[2], src->s6_addr32[3],
1401 ntohs(inet_sk(sk)->sport),
1402 dest->s6_addr32[0], dest->s6_addr32[1],
1403 dest->s6_addr32[2], dest->s6_addr32[3],
2e6599cb 1404 ntohs(inet_rsk(req)->rmt_port),
1da177e4
LT		 1405 TCP_SYN_RECV,
1406 0,0, /* could print option size, but that is af dependent. */
1407 1, /* timers active (only the expire timer) */
1408 jiffies_to_clock_t(ttd),
1409 req->retrans,
1410 uid,
1411 0, /* non standard timer */
1412 0, /* open_requests have no inode */
1413 0, req);
1414}
1415
1416static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1417{
1418 struct in6_addr *dest, *src;
1419 __u16 destp, srcp;
1420 int timer_active;
1421 unsigned long timer_expires;
1422 struct inet_sock *inet = inet_sk(sp);
1423 struct tcp_sock *tp = tcp_sk(sp);
463c84b9 1424 const struct inet_connection_sock *icsk = inet_csk(sp);
1da177e4
LT		 1425 struct ipv6_pinfo *np = inet6_sk(sp);
1426
1427 dest = &np->daddr;
1428 src = &np->rcv_saddr;
1429 destp = ntohs(inet->dport);
1430 srcp = ntohs(inet->sport);
463c84b9
ACM		 1431
1432 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1da177e4 1433 timer_active = 1;
463c84b9
ACM		 1434 timer_expires = icsk->icsk_timeout;
1435 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1da177e4 1436 timer_active = 4;
463c84b9 1437 timer_expires = icsk->icsk_timeout;
1da177e4
LT		 1438 } else if (timer_pending(&sp->sk_timer)) {
1439 timer_active = 2;
1440 timer_expires = sp->sk_timer.expires;
1441 } else {
1442 timer_active = 0;
1443 timer_expires = jiffies;
1444 }
1445
1446 seq_printf(seq,
1447 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1448 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %u %u %u %u %d\n",
1449 i,
1450 src->s6_addr32[0], src->s6_addr32[1],
1451 src->s6_addr32[2], src->s6_addr32[3], srcp,
1452 dest->s6_addr32[0], dest->s6_addr32[1],
1453 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1454 sp->sk_state,
1455 tp->write_seq-tp->snd_una, tp->rcv_nxt-tp->copied_seq,
1456 timer_active,
1457 jiffies_to_clock_t(timer_expires - jiffies),
463c84b9 1458 icsk->icsk_retransmits,
1da177e4 1459 sock_i_uid(sp),
6687e988 1460 icsk->icsk_probes_out,
1da177e4
LT		 1461 sock_i_ino(sp),
1462 atomic_read(&sp->sk_refcnt), sp,
463c84b9
ACM		 1463 icsk->icsk_rto,
1464 icsk->icsk_ack.ato,
1465 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
1da177e4
LT		 1466 tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
1467 );
1468}
1469
1470static void get_timewait6_sock(struct seq_file *seq,
8feaf0c0 1471 struct inet_timewait_sock *tw, int i)
1da177e4
LT		 1472{
1473 struct in6_addr *dest, *src;
1474 __u16 destp, srcp;
0fa1a53e 1475 struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
1da177e4
LT		 1476 int ttd = tw->tw_ttd - jiffies;
1477
1478 if (ttd < 0)
1479 ttd = 0;
1480
0fa1a53e
ACM		 1481 dest = &tw6->tw_v6_daddr;
1482 src = &tw6->tw_v6_rcv_saddr;
1da177e4
LT		 1483 destp = ntohs(tw->tw_dport);
1484 srcp = ntohs(tw->tw_sport);
1485
1486 seq_printf(seq,
1487 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1488 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1489 i,
1490 src->s6_addr32[0], src->s6_addr32[1],
1491 src->s6_addr32[2], src->s6_addr32[3], srcp,
1492 dest->s6_addr32[0], dest->s6_addr32[1],
1493 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1494 tw->tw_substate, 0, 0,
1495 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1496 atomic_read(&tw->tw_refcnt), tw);
1497}
1498
1499#ifdef CONFIG_PROC_FS
1500static int tcp6_seq_show(struct seq_file *seq, void *v)
1501{
1502 struct tcp_iter_state *st;
1503
1504 if (v == SEQ_START_TOKEN) {
1505 seq_puts(seq,
1506 " sl "
1507 "local_address "
1508 "remote_address "
1509 "st tx_queue rx_queue tr tm->when retrnsmt"
1510 " uid timeout inode\n");
1511 goto out;
1512 }
1513 st = seq->private;
1514
1515 switch (st->state) {
1516 case TCP_SEQ_STATE_LISTENING:
1517 case TCP_SEQ_STATE_ESTABLISHED:
1518 get_tcp6_sock(seq, v, st->num);
1519 break;
1520 case TCP_SEQ_STATE_OPENREQ:
1521 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1522 break;
1523 case TCP_SEQ_STATE_TIME_WAIT:
1524 get_timewait6_sock(seq, v, st->num);
1525 break;
1526 }
1527out:
1528 return 0;
1529}
1530
1531static struct file_operations tcp6_seq_fops;
1532static struct tcp_seq_afinfo tcp6_seq_afinfo = {
1533 .owner = THIS_MODULE,
1534 .name = "tcp6",
1535 .family = AF_INET6,
1536 .seq_show = tcp6_seq_show,
1537 .seq_fops = &tcp6_seq_fops,
1538};
1539
1540int __init tcp6_proc_init(void)
1541{
1542 return tcp_proc_register(&tcp6_seq_afinfo);
1543}
1544
1545void tcp6_proc_exit(void)
1546{
1547 tcp_proc_unregister(&tcp6_seq_afinfo);
1548}
1549#endif
1550
1551struct proto tcpv6_prot = {
1552 .name = "TCPv6",
1553 .owner = THIS_MODULE,
1554 .close = tcp_close,
1555 .connect = tcp_v6_connect,
1556 .disconnect = tcp_disconnect,
463c84b9 1557 .accept = inet_csk_accept,
1da177e4
LT		 1558 .ioctl = tcp_ioctl,
1559 .init = tcp_v6_init_sock,
1560 .destroy = tcp_v6_destroy_sock,
1561 .shutdown = tcp_shutdown,
1562 .setsockopt = tcp_setsockopt,
1563 .getsockopt = tcp_getsockopt,
1564 .sendmsg = tcp_sendmsg,
1565 .recvmsg = tcp_recvmsg,
1566 .backlog_rcv = tcp_v6_do_rcv,
1567 .hash = tcp_v6_hash,
1568 .unhash = tcp_unhash,
1569 .get_port = tcp_v6_get_port,
1570 .enter_memory_pressure = tcp_enter_memory_pressure,
1571 .sockets_allocated = &tcp_sockets_allocated,
1572 .memory_allocated = &tcp_memory_allocated,
1573 .memory_pressure = &tcp_memory_pressure,
0a5578cf 1574 .orphan_count = &tcp_orphan_count,
1da177e4
LT		 1575 .sysctl_mem = sysctl_tcp_mem,
1576 .sysctl_wmem = sysctl_tcp_wmem,
1577 .sysctl_rmem = sysctl_tcp_rmem,
1578 .max_header = MAX_TCP_HEADER,
1579 .obj_size = sizeof(struct tcp6_sock),
6d6ee43e 1580 .twsk_prot = &tcp6_timewait_sock_ops,
60236fdd 1581 .rsk_prot = &tcp6_request_sock_ops,
1da177e4
LT		 1582};
1583
1584static struct inet6_protocol tcpv6_protocol = {
1585 .handler = tcp_v6_rcv,
1586 .err_handler = tcp_v6_err,
1587 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1588};
1589
1da177e4
LT		 1590static struct inet_protosw tcpv6_protosw = {
1591 .type = SOCK_STREAM,
1592 .protocol = IPPROTO_TCP,
1593 .prot = &tcpv6_prot,
1594 .ops = &inet6_stream_ops,
1595 .capability = -1,
1596 .no_check = 0,
d83d8461
ACM		 1597 .flags = INET_PROTOSW_PERMANENT |
1598 INET_PROTOSW_ICSK,
1da177e4
LT		 1599};
1600
1601void __init tcpv6_init(void)
1602{
1603 /* register inet6 protocol */
1604 if (inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP) < 0)
1605 printk(KERN_ERR "tcpv6_init: Could not register protocol\n");
1606 inet6_register_protosw(&tcpv6_protosw);
1607}
Linux kernel - Deliverables
This page took 0.220942 seconds and 5 git commands to generate.