?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / net / ipv6 / tcp_ipv6.c
blob0f69e800a0ad695868f1efc89d645c32a0445e19
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>
50 #include <net/ipv6.h>
51 #include <net/transp_v6.h>
52 #include <net/addrconf.h>
53 #include <net/ip6_route.h>
54 #include <net/ip6_checksum.h>
55 #include <net/inet_ecn.h>
56 #include <net/protocol.h>
57 #include <net/xfrm.h>
58 #include <net/addrconf.h>
59 #include <net/snmp.h>
60 #include <net/dsfield.h>
61
62 #include <asm/uaccess.h>
63
64 #include <linux/proc_fs.h>
65 #include <linux/seq_file.h>
66
67 static void tcp_v6_send_reset(struct sk_buff *skb);
68 static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req);
69 static void tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len,
70 struct sk_buff *skb);
71
72 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
73 static int tcp_v6_xmit(struct sk_buff *skb, int ipfragok);
74
75 static struct tcp_func ipv6_mapped;
76 static struct tcp_func ipv6_specific;
77
78 /* I have no idea if this is a good hash for v6 or not. -DaveM */
79 static __inline__ int tcp_v6_hashfn(struct in6_addr *laddr, u16 lport,
80 struct in6_addr *faddr, u16 fport)
81 {
82 int hashent = (lport ^ fport);
83
84 hashent ^= (laddr->s6_addr32[3] ^ faddr->s6_addr32[3]);
85 hashent ^= hashent>>16;
86 hashent ^= hashent>>8;
87 return (hashent & (tcp_ehash_size - 1));
88 }
89
90 static __inline__ int tcp_v6_sk_hashfn(struct sock *sk)
91 {
92 struct inet_sock *inet = inet_sk(sk);
93 struct ipv6_pinfo *np = inet6_sk(sk);
94 struct in6_addr *laddr = &np->rcv_saddr;
95 struct in6_addr *faddr = &np->daddr;
96 __u16 lport = inet->num;
97 __u16 fport = inet->dport;
98 return tcp_v6_hashfn(laddr, lport, faddr, fport);
99 }
100
101 static inline int tcp_v6_bind_conflict(struct sock *sk,
102 struct tcp_bind_bucket *tb)
103 {
104 struct sock *sk2;
105 struct hlist_node *node;
106
107 /* We must walk the whole port owner list in this case. -DaveM */
108 sk_for_each_bound(sk2, node, &tb->owners) {
109 if (sk != sk2 &&
110 (!sk->sk_bound_dev_if ||
111 !sk2->sk_bound_dev_if ||
112 sk->sk_bound_dev_if == sk2->sk_bound_dev_if) &&
113 (!sk->sk_reuse || !sk2->sk_reuse ||
114 sk2->sk_state == TCP_LISTEN) &&
115 ipv6_rcv_saddr_equal(sk, sk2))
116 break;
117 }
118
119 return node != NULL;
120 }
121
122 /* Grrr, addr_type already calculated by caller, but I don't want
123 * to add some silly "cookie" argument to this method just for that.
124 * But it doesn't matter, the recalculation is in the rarest path
125 * this function ever takes.
126 */
127 static int tcp_v6_get_port(struct sock *sk, unsigned short snum)
128 {
129 struct tcp_bind_hashbucket *head;
130 struct tcp_bind_bucket *tb;
131 struct hlist_node *node;
132 int ret;
133
134 local_bh_disable();
135 if (snum == 0) {
136 int low = sysctl_local_port_range[0];
137 int high = sysctl_local_port_range[1];
138 int remaining = (high - low) + 1;
139 int rover;
140
141 spin_lock(&tcp_portalloc_lock);
142 if (tcp_port_rover < low)
143 rover = low;
144 else
145 rover = tcp_port_rover;
146 do { rover++;
147 if (rover > high)
148 rover = low;
149 head = &tcp_bhash[tcp_bhashfn(rover)];
150 spin_lock(&head->lock);
151 tb_for_each(tb, node, &head->chain)
152 if (tb->port == rover)
153 goto next;
154 break;
155 next:
156 spin_unlock(&head->lock);
157 } while (--remaining > 0);
158 tcp_port_rover = rover;
159 spin_unlock(&tcp_portalloc_lock);
160
161 /* Exhausted local port range during search? */
162 ret = 1;
163 if (remaining <= 0)
164 goto fail;
165
166 /* OK, here is the one we will use. */
167 snum = rover;
168 } else {
169 head = &tcp_bhash[tcp_bhashfn(snum)];
170 spin_lock(&head->lock);
171 tb_for_each(tb, node, &head->chain)
172 if (tb->port == snum)
173 goto tb_found;
174 }
175 tb = NULL;
176 goto tb_not_found;
177 tb_found:
178 if (tb && !hlist_empty(&tb->owners)) {
179 if (tb->fastreuse > 0 && sk->sk_reuse &&
180 sk->sk_state != TCP_LISTEN) {
181 goto success;
182 } else {
183 ret = 1;
184 if (tcp_v6_bind_conflict(sk, tb))
185 goto fail_unlock;
186 }
187 }
188 tb_not_found:
189 ret = 1;
190 if (!tb && (tb = tcp_bucket_create(head, snum)) == NULL)
191 goto fail_unlock;
192 if (hlist_empty(&tb->owners)) {
193 if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
194 tb->fastreuse = 1;
195 else
196 tb->fastreuse = 0;
197 } else if (tb->fastreuse &&
198 (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
199 tb->fastreuse = 0;
200
201 success:
202 if (!tcp_sk(sk)->bind_hash)
203 tcp_bind_hash(sk, tb, snum);
204 BUG_TRAP(tcp_sk(sk)->bind_hash == tb);
205 ret = 0;
206
207 fail_unlock:
208 spin_unlock(&head->lock);
209 fail:
210 local_bh_enable();
211 return ret;
212 }
213
214 static __inline__ void __tcp_v6_hash(struct sock *sk)
215 {
216 struct hlist_head *list;
217 rwlock_t *lock;
218
219 BUG_TRAP(sk_unhashed(sk));
220
221 if (sk->sk_state == TCP_LISTEN) {
222 list = &tcp_listening_hash[tcp_sk_listen_hashfn(sk)];
223 lock = &tcp_lhash_lock;
224 tcp_listen_wlock();
225 } else {
226 sk->sk_hashent = tcp_v6_sk_hashfn(sk);
227 list = &tcp_ehash[sk->sk_hashent].chain;
228 lock = &tcp_ehash[sk->sk_hashent].lock;
229 write_lock(lock);
230 }
231
232 __sk_add_node(sk, list);
233 sock_prot_inc_use(sk->sk_prot);
234 write_unlock(lock);
235 }
236
237
238 static void tcp_v6_hash(struct sock *sk)
239 {
240 if (sk->sk_state != TCP_CLOSE) {
241 struct tcp_sock *tp = tcp_sk(sk);
242
243 if (tp->af_specific == &ipv6_mapped) {
244 tcp_prot.hash(sk);
245 return;
246 }
247 local_bh_disable();
248 __tcp_v6_hash(sk);
249 local_bh_enable();
250 }
251 }
252
253 static struct sock *tcp_v6_lookup_listener(struct in6_addr *daddr, unsigned short hnum, int dif)
254 {
255 struct sock *sk;
256 struct hlist_node *node;
257 struct sock *result = NULL;
258 int score, hiscore;
259
260 hiscore=0;
261 read_lock(&tcp_lhash_lock);
262 sk_for_each(sk, node, &tcp_listening_hash[tcp_lhashfn(hnum)]) {
263 if (inet_sk(sk)->num == hnum && sk->sk_family == PF_INET6) {
264 struct ipv6_pinfo *np = inet6_sk(sk);
265
266 score = 1;
267 if (!ipv6_addr_any(&np->rcv_saddr)) {
268 if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
269 continue;
270 score++;
271 }
272 if (sk->sk_bound_dev_if) {
273 if (sk->sk_bound_dev_if != dif)
274 continue;
275 score++;
276 }
277 if (score == 3) {
278 result = sk;
279 break;
280 }
281 if (score > hiscore) {
282 hiscore = score;
283 result = sk;
284 }
285 }
286 }
287 if (result)
288 sock_hold(result);
289 read_unlock(&tcp_lhash_lock);
290 return result;
291 }
292
293 /* Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
294 * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
295 *
296 * The sockhash lock must be held as a reader here.
297 */
298
299 static inline struct sock *__tcp_v6_lookup_established(struct in6_addr *saddr, u16 sport,
300 struct in6_addr *daddr, u16 hnum,
301 int dif)
302 {
303 struct tcp_ehash_bucket *head;
304 struct sock *sk;
305 struct hlist_node *node;
306 __u32 ports = TCP_COMBINED_PORTS(sport, hnum);
307 int hash;
308
309 /* Optimize here for direct hit, only listening connections can
310 * have wildcards anyways.
311 */
312 hash = tcp_v6_hashfn(daddr, hnum, saddr, sport);
313 head = &tcp_ehash[hash];
314 read_lock(&head->lock);
315 sk_for_each(sk, node, &head->chain) {
316 /* For IPV6 do the cheaper port and family tests first. */
317 if(TCP_IPV6_MATCH(sk, saddr, daddr, ports, dif))
318 goto hit; /* You sunk my battleship! */
319 }
320 /* Must check for a TIME_WAIT'er before going to listener hash. */
321 sk_for_each(sk, node, &(head + tcp_ehash_size)->chain) {
322 /* FIXME: acme: check this... */
323 struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
324
325 if(*((__u32 *)&(tw->tw_dport)) == ports &&
326 sk->sk_family == PF_INET6) {
327 if(ipv6_addr_equal(&tw->tw_v6_daddr, saddr) &&
328 ipv6_addr_equal(&tw->tw_v6_rcv_saddr, daddr) &&
329 (!sk->sk_bound_dev_if || sk->sk_bound_dev_if == dif))
330 goto hit;
331 }
332 }
333 read_unlock(&head->lock);
334 return NULL;
335
336 hit:
337 sock_hold(sk);
338 read_unlock(&head->lock);
339 return sk;
340 }
341
342
343 static inline struct sock *__tcp_v6_lookup(struct in6_addr *saddr, u16 sport,
344 struct in6_addr *daddr, u16 hnum,
345 int dif)
346 {
347 struct sock *sk;
348
349 sk = __tcp_v6_lookup_established(saddr, sport, daddr, hnum, dif);
350
351 if (sk)
352 return sk;
353
354 return tcp_v6_lookup_listener(daddr, hnum, dif);
355 }
356
357 inline struct sock *tcp_v6_lookup(struct in6_addr *saddr, u16 sport,
358 struct in6_addr *daddr, u16 dport,
359 int dif)
360 {
361 struct sock *sk;
362
363 local_bh_disable();
364 sk = __tcp_v6_lookup(saddr, sport, daddr, ntohs(dport), dif);
365 local_bh_enable();
366
367 return sk;
368 }
369
370 EXPORT_SYMBOL_GPL(tcp_v6_lookup);
371
372
373 /*
374 * Open request hash tables.
375 */
376
377 static u32 tcp_v6_synq_hash(struct in6_addr *raddr, u16 rport, u32 rnd)
378 {
379 u32 a, b, c;
380
381 a = raddr->s6_addr32[0];
382 b = raddr->s6_addr32[1];
383 c = raddr->s6_addr32[2];
384
385 a += JHASH_GOLDEN_RATIO;
386 b += JHASH_GOLDEN_RATIO;
387 c += rnd;
388 __jhash_mix(a, b, c);
389
390 a += raddr->s6_addr32[3];
391 b += (u32) rport;
392 __jhash_mix(a, b, c);
393
394 return c & (TCP_SYNQ_HSIZE - 1);
395 }
396
397 static struct open_request *tcp_v6_search_req(struct tcp_sock *tp,
398 struct open_request ***prevp,
399 __u16 rport,
400 struct in6_addr *raddr,
401 struct in6_addr *laddr,
402 int iif)
403 {
404 struct tcp_listen_opt *lopt = tp->listen_opt;
405 struct open_request *req, **prev;
406
407 for (prev = &lopt->syn_table[tcp_v6_synq_hash(raddr, rport, lopt->hash_rnd)];
408 (req = *prev) != NULL;
409 prev = &req->dl_next) {
410 if (req->rmt_port == rport &&
411 req->class->family == AF_INET6 &&
412 ipv6_addr_equal(&req->af.v6_req.rmt_addr, raddr) &&
413 ipv6_addr_equal(&req->af.v6_req.loc_addr, laddr) &&
414 (!req->af.v6_req.iif || req->af.v6_req.iif == iif)) {
415 BUG_TRAP(req->sk == NULL);
416 *prevp = prev;
417 return req;
418 }
419 }
420
421 return NULL;
422 }
423
424 static __inline__ u16 tcp_v6_check(struct tcphdr *th, int len,
425 struct in6_addr *saddr,
426 struct in6_addr *daddr,
427 unsigned long base)
428 {
429 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
430 }
431
432 static __u32 tcp_v6_init_sequence(struct sock *sk, struct sk_buff *skb)
433 {
434 if (skb->protocol == htons(ETH_P_IPV6)) {
435 return secure_tcpv6_sequence_number(skb->nh.ipv6h->daddr.s6_addr32,
436 skb->nh.ipv6h->saddr.s6_addr32,
437 skb->h.th->dest,
438 skb->h.th->source);
439 } else {
440 return secure_tcp_sequence_number(skb->nh.iph->daddr,
441 skb->nh.iph->saddr,
442 skb->h.th->dest,
443 skb->h.th->source);
444 }
445 }
446
447 static int __tcp_v6_check_established(struct sock *sk, __u16 lport,
448 struct tcp_tw_bucket **twp)
449 {
450 struct inet_sock *inet = inet_sk(sk);
451 struct ipv6_pinfo *np = inet6_sk(sk);
452 struct in6_addr *daddr = &np->rcv_saddr;
453 struct in6_addr *saddr = &np->daddr;
454 int dif = sk->sk_bound_dev_if;
455 u32 ports = TCP_COMBINED_PORTS(inet->dport, lport);
456 int hash = tcp_v6_hashfn(daddr, inet->num, saddr, inet->dport);
457 struct tcp_ehash_bucket *head = &tcp_ehash[hash];
458 struct sock *sk2;
459 struct hlist_node *node;
460 struct tcp_tw_bucket *tw;
461
462 write_lock(&head->lock);
463
464 /* Check TIME-WAIT sockets first. */
465 sk_for_each(sk2, node, &(head + tcp_ehash_size)->chain) {
466 tw = (struct tcp_tw_bucket*)sk2;
467
468 if(*((__u32 *)&(tw->tw_dport)) == ports &&
469 sk2->sk_family == PF_INET6 &&
470 ipv6_addr_equal(&tw->tw_v6_daddr, saddr) &&
471 ipv6_addr_equal(&tw->tw_v6_rcv_saddr, daddr) &&
472 sk2->sk_bound_dev_if == sk->sk_bound_dev_if) {
473 struct tcp_sock *tp = tcp_sk(sk);
474
475 if (tw->tw_ts_recent_stamp &&
476 (!twp || (sysctl_tcp_tw_reuse &&
477 xtime.tv_sec -
478 tw->tw_ts_recent_stamp > 1))) {
479 /* See comment in tcp_ipv4.c */
480 tp->write_seq = tw->tw_snd_nxt + 65535 + 2;
481 if (!tp->write_seq)
482 tp->write_seq = 1;
483 tp->rx_opt.ts_recent = tw->tw_ts_recent;
484 tp->rx_opt.ts_recent_stamp = tw->tw_ts_recent_stamp;
485 sock_hold(sk2);
486 goto unique;
487 } else
488 goto not_unique;
489 }
490 }
491 tw = NULL;
492
493 /* And established part... */
494 sk_for_each(sk2, node, &head->chain) {
495 if(TCP_IPV6_MATCH(sk2, saddr, daddr, ports, dif))
496 goto not_unique;
497 }
498
499 unique:
500 BUG_TRAP(sk_unhashed(sk));
501 __sk_add_node(sk, &head->chain);
502 sk->sk_hashent = hash;
503 sock_prot_inc_use(sk->sk_prot);
504 write_unlock(&head->lock);
505
506 if (twp) {
507 *twp = tw;
508 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
509 } else if (tw) {
510 /* Silly. Should hash-dance instead... */
511 tcp_tw_deschedule(tw);
512 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
513
514 tcp_tw_put(tw);
515 }
516 return 0;
517
518 not_unique:
519 write_unlock(&head->lock);
520 return -EADDRNOTAVAIL;
521 }
522
523 static inline u32 tcpv6_port_offset(const struct sock *sk)
524 {
525 const struct inet_sock *inet = inet_sk(sk);
526 const struct ipv6_pinfo *np = inet6_sk(sk);
527
528 return secure_tcpv6_port_ephemeral(np->rcv_saddr.s6_addr32,
529 np->daddr.s6_addr32,
530 inet->dport);
531 }
532
533 static int tcp_v6_hash_connect(struct sock *sk)
534 {
535 unsigned short snum = inet_sk(sk)->num;
536 struct tcp_bind_hashbucket *head;
537 struct tcp_bind_bucket *tb;
538 int ret;
539
540 if (!snum) {
541 int low = sysctl_local_port_range[0];
542 int high = sysctl_local_port_range[1];
543 int range = high - low;
544 int i;
545 int port;
546 static u32 hint;
547 u32 offset = hint + tcpv6_port_offset(sk);
548 struct hlist_node *node;
549 struct tcp_tw_bucket *tw = NULL;
550
551 local_bh_disable();
552 for (i = 1; i <= range; i++) {
553 port = low + (i + offset) % range;
554 head = &tcp_bhash[tcp_bhashfn(port)];
555 spin_lock(&head->lock);
556
557 /* Does not bother with rcv_saddr checks,
558 * because the established check is already
559 * unique enough.
560 */
561 tb_for_each(tb, node, &head->chain) {
562 if (tb->port == port) {
563 BUG_TRAP(!hlist_empty(&tb->owners));
564 if (tb->fastreuse >= 0)
565 goto next_port;
566 if (!__tcp_v6_check_established(sk,
567 port,
568 &tw))
569 goto ok;
570 goto next_port;
571 }
572 }
573
574 tb = tcp_bucket_create(head, port);
575 if (!tb) {
576 spin_unlock(&head->lock);
577 break;
578 }
579 tb->fastreuse = -1;
580 goto ok;
581
582 next_port:
583 spin_unlock(&head->lock);
584 }
585 local_bh_enable();
586
587 return -EADDRNOTAVAIL;
588
589 ok:
590 hint += i;
591
592 /* Head lock still held and bh's disabled */
593 tcp_bind_hash(sk, tb, port);
594 if (sk_unhashed(sk)) {
595 inet_sk(sk)->sport = htons(port);
596 __tcp_v6_hash(sk);
597 }
598 spin_unlock(&head->lock);
599
600 if (tw) {
601 tcp_tw_deschedule(tw);
602 tcp_tw_put(tw);
603 }
604
605 ret = 0;
606 goto out;
607 }
608
609 head = &tcp_bhash[tcp_bhashfn(snum)];
610 tb = tcp_sk(sk)->bind_hash;
611 spin_lock_bh(&head->lock);
612
613 if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) {
614 __tcp_v6_hash(sk);
615 spin_unlock_bh(&head->lock);
616 return 0;
617 } else {
618 spin_unlock(&head->lock);
619 /* No definite answer... Walk to established hash table */
620 ret = __tcp_v6_check_established(sk, snum, NULL);
621 out:
622 local_bh_enable();
623 return ret;
624 }
625 }
626
627 static __inline__ int tcp_v6_iif(struct sk_buff *skb)
628 {
629 return IP6CB(skb)->iif;
630 }
631
632 static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
633 int addr_len)
634 {
635 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
636 struct inet_sock *inet = inet_sk(sk);
637 struct ipv6_pinfo *np = inet6_sk(sk);
638 struct tcp_sock *tp = tcp_sk(sk);
639 struct in6_addr *saddr = NULL, *final_p = NULL, final;
640 struct flowi fl;
641 struct dst_entry *dst;
642 int addr_type;
643 int err;
644
645 if (addr_len < SIN6_LEN_RFC2133)
646 return -EINVAL;
647
648 if (usin->sin6_family != AF_INET6)
649 return(-EAFNOSUPPORT);
650
651 memset(&fl, 0, sizeof(fl));
652
653 if (np->sndflow) {
654 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
655 IP6_ECN_flow_init(fl.fl6_flowlabel);
656 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
657 struct ip6_flowlabel *flowlabel;
658 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
659 if (flowlabel == NULL)
660 return -EINVAL;
661 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
662 fl6_sock_release(flowlabel);
663 }
664 }
665
666 /*
667 * connect() to INADDR_ANY means loopback (BSD'ism).
668 */
669
670 if(ipv6_addr_any(&usin->sin6_addr))
671 usin->sin6_addr.s6_addr[15] = 0x1;
672
673 addr_type = ipv6_addr_type(&usin->sin6_addr);
674
675 if(addr_type & IPV6_ADDR_MULTICAST)
676 return -ENETUNREACH;
677
678 if (addr_type&IPV6_ADDR_LINKLOCAL) {
679 if (addr_len >= sizeof(struct sockaddr_in6) &&
680 usin->sin6_scope_id) {
681 /* If interface is set while binding, indices
682 * must coincide.
683 */
684 if (sk->sk_bound_dev_if &&
685 sk->sk_bound_dev_if != usin->sin6_scope_id)
686 return -EINVAL;
687
688 sk->sk_bound_dev_if = usin->sin6_scope_id;
689 }
690
691 /* Connect to link-local address requires an interface */
692 if (!sk->sk_bound_dev_if)
693 return -EINVAL;
694 }
695
696 if (tp->rx_opt.ts_recent_stamp &&
697 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
698 tp->rx_opt.ts_recent = 0;
699 tp->rx_opt.ts_recent_stamp = 0;
700 tp->write_seq = 0;
701 }
702
703 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
704 np->flow_label = fl.fl6_flowlabel;
705
706 /*
707 * TCP over IPv4
708 */
709
710 if (addr_type == IPV6_ADDR_MAPPED) {
711 u32 exthdrlen = tp->ext_header_len;
712 struct sockaddr_in sin;
713
714 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
715
716 if (__ipv6_only_sock(sk))
717 return -ENETUNREACH;
718
719 sin.sin_family = AF_INET;
720 sin.sin_port = usin->sin6_port;
721 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
722
723 tp->af_specific = &ipv6_mapped;
724 sk->sk_backlog_rcv = tcp_v4_do_rcv;
725
726 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
727
728 if (err) {
729 tp->ext_header_len = exthdrlen;
730 tp->af_specific = &ipv6_specific;
731 sk->sk_backlog_rcv = tcp_v6_do_rcv;
732 goto failure;
733 } else {
734 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
735 inet->saddr);
736 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
737 inet->rcv_saddr);
738 }
739
740 return err;
741 }
742
743 if (!ipv6_addr_any(&np->rcv_saddr))
744 saddr = &np->rcv_saddr;
745
746 fl.proto = IPPROTO_TCP;
747 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
748 ipv6_addr_copy(&fl.fl6_src,
749 (saddr ? saddr : &np->saddr));
750 fl.oif = sk->sk_bound_dev_if;
751 fl.fl_ip_dport = usin->sin6_port;
752 fl.fl_ip_sport = inet->sport;
753
754 if (np->opt && np->opt->srcrt) {
755 struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
756 ipv6_addr_copy(&final, &fl.fl6_dst);
757 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
758 final_p = &final;
759 }
760
761 err = ip6_dst_lookup(sk, &dst, &fl);
762 if (err)
763 goto failure;
764 if (final_p)
765 ipv6_addr_copy(&fl.fl6_dst, final_p);
766
767 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
768 dst_release(dst);
769 goto failure;
770 }
771
772 if (saddr == NULL) {
773 saddr = &fl.fl6_src;
774 ipv6_addr_copy(&np->rcv_saddr, saddr);
775 }
776
777 /* set the source address */
778 ipv6_addr_copy(&np->saddr, saddr);
779 inet->rcv_saddr = LOOPBACK4_IPV6;
780
781 ip6_dst_store(sk, dst, NULL);
782 sk->sk_route_caps = dst->dev->features &
783 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
784
785 tp->ext_header_len = 0;
786 if (np->opt)
787 tp->ext_header_len = np->opt->opt_flen + np->opt->opt_nflen;
788
789 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
790
791 inet->dport = usin->sin6_port;
792
793 tcp_set_state(sk, TCP_SYN_SENT);
794 err = tcp_v6_hash_connect(sk);
795 if (err)
796 goto late_failure;
797
798 if (!tp->write_seq)
799 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
800 np->daddr.s6_addr32,
801 inet->sport,
802 inet->dport);
803
804 err = tcp_connect(sk);
805 if (err)
806 goto late_failure;
807
808 return 0;
809
810 late_failure:
811 tcp_set_state(sk, TCP_CLOSE);
812 __sk_dst_reset(sk);
813 failure:
814 inet->dport = 0;
815 sk->sk_route_caps = 0;
816 return err;
817 }
818
819 static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
820 int type, int code, int offset, __u32 info)
821 {
822 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
823 struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
824 struct ipv6_pinfo *np;
825 struct sock *sk;
826 int err;
827 struct tcp_sock *tp;
828 __u32 seq;
829
830 sk = tcp_v6_lookup(&hdr->daddr, th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
831
832 if (sk == NULL) {
833 ICMP6_INC_STATS_BH(__in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
834 return;
835 }
836
837 if (sk->sk_state == TCP_TIME_WAIT) {
838 tcp_tw_put((struct tcp_tw_bucket*)sk);
839 return;
840 }
841
842 bh_lock_sock(sk);
843 if (sock_owned_by_user(sk))
844 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
845
846 if (sk->sk_state == TCP_CLOSE)
847 goto out;
848
849 tp = tcp_sk(sk);
850 seq = ntohl(th->seq);
851 if (sk->sk_state != TCP_LISTEN &&
852 !between(seq, tp->snd_una, tp->snd_nxt)) {
853 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
854 goto out;
855 }
856
857 np = inet6_sk(sk);
858
859 if (type == ICMPV6_PKT_TOOBIG) {
860 struct dst_entry *dst = NULL;
861
862 if (sock_owned_by_user(sk))
863 goto out;
864 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
865 goto out;
866
867 /* icmp should have updated the destination cache entry */
868 dst = __sk_dst_check(sk, np->dst_cookie);
869
870 if (dst == NULL) {
871 struct inet_sock *inet = inet_sk(sk);
872 struct flowi fl;
873
874 /* BUGGG_FUTURE: Again, it is not clear how
875 to handle rthdr case. Ignore this complexity
876 for now.
877 */
878 memset(&fl, 0, sizeof(fl));
879 fl.proto = IPPROTO_TCP;
880 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
881 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
882 fl.oif = sk->sk_bound_dev_if;
883 fl.fl_ip_dport = inet->dport;
884 fl.fl_ip_sport = inet->sport;
885
886 if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
887 sk->sk_err_soft = -err;
888 goto out;
889 }
890
891 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
892 sk->sk_err_soft = -err;
893 goto out;
894 }
895
896 } else
897 dst_hold(dst);
898
899 if (tp->pmtu_cookie > dst_mtu(dst)) {
900 tcp_sync_mss(sk, dst_mtu(dst));
901 tcp_simple_retransmit(sk);
902 } /* else let the usual retransmit timer handle it */
903 dst_release(dst);
904 goto out;
905 }
906
907 icmpv6_err_convert(type, code, &err);
908
909 /* Might be for an open_request */
910 switch (sk->sk_state) {
911 struct open_request *req, **prev;
912 case TCP_LISTEN:
913 if (sock_owned_by_user(sk))
914 goto out;
915
916 req = tcp_v6_search_req(tp, &prev, th->dest, &hdr->daddr,
917 &hdr->saddr, tcp_v6_iif(skb));
918 if (!req)
919 goto out;
920
921 /* ICMPs are not backlogged, hence we cannot get
922 * an established socket here.
923 */
924 BUG_TRAP(req->sk == NULL);
925
926 if (seq != req->snt_isn) {
927 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
928 goto out;
929 }
930
931 tcp_synq_drop(sk, req, prev);
932 goto out;
933
934 case TCP_SYN_SENT:
935 case TCP_SYN_RECV: /* Cannot happen.
936 It can, it SYNs are crossed. --ANK */
937 if (!sock_owned_by_user(sk)) {
938 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
939 sk->sk_err = err;
940 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
941
942 tcp_done(sk);
943 } else
944 sk->sk_err_soft = err;
945 goto out;
946 }
947
948 if (!sock_owned_by_user(sk) && np->recverr) {
949 sk->sk_err = err;
950 sk->sk_error_report(sk);
951 } else
952 sk->sk_err_soft = err;
953
954 out:
955 bh_unlock_sock(sk);
956 sock_put(sk);
957 }
958
959
960 static int tcp_v6_send_synack(struct sock *sk, struct open_request *req,
961 struct dst_entry *dst)
962 {
963 struct ipv6_pinfo *np = inet6_sk(sk);
964 struct sk_buff * skb;
965 struct ipv6_txoptions *opt = NULL;
966 struct in6_addr * final_p = NULL, final;
967 struct flowi fl;
968 int err = -1;
969
970 memset(&fl, 0, sizeof(fl));
971 fl.proto = IPPROTO_TCP;
972 ipv6_addr_copy(&fl.fl6_dst, &req->af.v6_req.rmt_addr);
973 ipv6_addr_copy(&fl.fl6_src, &req->af.v6_req.loc_addr);
974 fl.fl6_flowlabel = 0;
975 fl.oif = req->af.v6_req.iif;
976 fl.fl_ip_dport = req->rmt_port;
977 fl.fl_ip_sport = inet_sk(sk)->sport;
978
979 if (dst == NULL) {
980 opt = np->opt;
981 if (opt == NULL &&
982 np->rxopt.bits.srcrt == 2 &&
983 req->af.v6_req.pktopts) {
984 struct sk_buff *pktopts = req->af.v6_req.pktopts;
985 struct inet6_skb_parm *rxopt = IP6CB(pktopts);
986 if (rxopt->srcrt)
987 opt = ipv6_invert_rthdr(sk, (struct ipv6_rt_hdr*)(pktopts->nh.raw + rxopt->srcrt));
988 }
989
990 if (opt && opt->srcrt) {
991 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
992 ipv6_addr_copy(&final, &fl.fl6_dst);
993 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
994 final_p = &final;
995 }
996
997 err = ip6_dst_lookup(sk, &dst, &fl);
998 if (err)
999 goto done;
1000 if (final_p)
1001 ipv6_addr_copy(&fl.fl6_dst, final_p);
1002 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
1003 goto done;
1004 }
1005
1006 skb = tcp_make_synack(sk, dst, req);
1007 if (skb) {
1008 struct tcphdr *th = skb->h.th;
1009
1010 th->check = tcp_v6_check(th, skb->len,
1011 &req->af.v6_req.loc_addr, &req->af.v6_req.rmt_addr,
1012 csum_partial((char *)th, skb->len, skb->csum));
1013
1014 ipv6_addr_copy(&fl.fl6_dst, &req->af.v6_req.rmt_addr);
1015 err = ip6_xmit(sk, skb, &fl, opt, 0);
1016 if (err == NET_XMIT_CN)
1017 err = 0;
1018 }
1019
1020 done:
1021 dst_release(dst);
1022 if (opt && opt != np->opt)
1023 sock_kfree_s(sk, opt, opt->tot_len);
1024 return err;
1025 }
1026
1027 static void tcp_v6_or_free(struct open_request *req)
1028 {
1029 if (req->af.v6_req.pktopts)
1030 kfree_skb(req->af.v6_req.pktopts);
1031 }
1032
1033 static struct or_calltable or_ipv6 = {
1034 .family = AF_INET6,
1035 .rtx_syn_ack = tcp_v6_send_synack,
1036 .send_ack = tcp_v6_or_send_ack,
1037 .destructor = tcp_v6_or_free,
1038 .send_reset = tcp_v6_send_reset
1039 };
1040
1041 static int ipv6_opt_accepted(struct sock *sk, struct sk_buff *skb)
1042 {
1043 struct ipv6_pinfo *np = inet6_sk(sk);
1044 struct inet6_skb_parm *opt = IP6CB(skb);
1045
1046 if (np->rxopt.all) {
1047 if ((opt->hop && np->rxopt.bits.hopopts) ||
1048 ((IPV6_FLOWINFO_MASK&*(u32*)skb->nh.raw) &&
1049 np->rxopt.bits.rxflow) ||
1050 (opt->srcrt && np->rxopt.bits.srcrt) ||
1051 ((opt->dst1 || opt->dst0) && np->rxopt.bits.dstopts))
1052 return 1;
1053 }
1054 return 0;
1055 }
1056
1057
1058 static void tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len,
1059 struct sk_buff *skb)
1060 {
1061 struct ipv6_pinfo *np = inet6_sk(sk);
1062
1063 if (skb->ip_summed == CHECKSUM_HW) {
1064 th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0);
1065 skb->csum = offsetof(struct tcphdr, check);
1066 } else {
1067 th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
1068 csum_partial((char *)th, th->doff<<2,
1069 skb->csum));
1070 }
1071 }
1072
1073
1074 static void tcp_v6_send_reset(struct sk_buff *skb)
1075 {
1076 struct tcphdr *th = skb->h.th, *t1;
1077 struct sk_buff *buff;
1078 struct flowi fl;
1079
1080 if (th->rst)
1081 return;
1082
1083 if (!ipv6_unicast_destination(skb))
1084 return;
1085
1086 /*
1087 * We need to grab some memory, and put together an RST,
1088 * and then put it into the queue to be sent.
1089 */
1090
1091 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + sizeof(struct tcphdr),
1092 GFP_ATOMIC);
1093 if (buff == NULL)
1094 return;
1095
1096 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + sizeof(struct tcphdr));
1097
1098 t1 = (struct tcphdr *) skb_push(buff,sizeof(struct tcphdr));
1099
1100 /* Swap the send and the receive. */
1101 memset(t1, 0, sizeof(*t1));
1102 t1->dest = th->source;
1103 t1->source = th->dest;
1104 t1->doff = sizeof(*t1)/4;
1105 t1->rst = 1;
1106
1107 if(th->ack) {
1108 t1->seq = th->ack_seq;
1109 } else {
1110 t1->ack = 1;
1111 t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
1112 + skb->len - (th->doff<<2));
1113 }
1114
1115 buff->csum = csum_partial((char *)t1, sizeof(*t1), 0);
1116
1117 memset(&fl, 0, sizeof(fl));
1118 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
1119 ipv6_addr_copy(&fl.fl6_src, &skb->nh.ipv6h->daddr);
1120
1121 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1122 sizeof(*t1), IPPROTO_TCP,
1123 buff->csum);
1124
1125 fl.proto = IPPROTO_TCP;
1126 fl.oif = tcp_v6_iif(skb);
1127 fl.fl_ip_dport = t1->dest;
1128 fl.fl_ip_sport = t1->source;
1129
1130 /* sk = NULL, but it is safe for now. RST socket required. */
1131 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
1132
1133 if ((xfrm_lookup(&buff->dst, &fl, NULL, 0)) < 0) {
1134 dst_release(buff->dst);
1135 return;
1136 }
1137
1138 ip6_xmit(NULL, buff, &fl, NULL, 0);
1139 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1140 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
1141 return;
1142 }
1143
1144 kfree_skb(buff);
1145 }
1146
1147 static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts)
1148 {
1149 struct tcphdr *th = skb->h.th, *t1;
1150 struct sk_buff *buff;
1151 struct flowi fl;
1152 int tot_len = sizeof(struct tcphdr);
1153
1154 if (ts)
1155 tot_len += 3*4;
1156
1157 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1158 GFP_ATOMIC);
1159 if (buff == NULL)
1160 return;
1161
1162 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1163
1164 t1 = (struct tcphdr *) skb_push(buff,tot_len);
1165
1166 /* Swap the send and the receive. */
1167 memset(t1, 0, sizeof(*t1));
1168 t1->dest = th->source;
1169 t1->source = th->dest;
1170 t1->doff = tot_len/4;
1171 t1->seq = htonl(seq);
1172 t1->ack_seq = htonl(ack);
1173 t1->ack = 1;
1174 t1->window = htons(win);
1175
1176 if (ts) {
1177 u32 *ptr = (u32*)(t1 + 1);
1178 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1179 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1180 *ptr++ = htonl(tcp_time_stamp);
1181 *ptr = htonl(ts);
1182 }
1183
1184 buff->csum = csum_partial((char *)t1, tot_len, 0);
1185
1186 memset(&fl, 0, sizeof(fl));
1187 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
1188 ipv6_addr_copy(&fl.fl6_src, &skb->nh.ipv6h->daddr);
1189
1190 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1191 tot_len, IPPROTO_TCP,
1192 buff->csum);
1193
1194 fl.proto = IPPROTO_TCP;
1195 fl.oif = tcp_v6_iif(skb);
1196 fl.fl_ip_dport = t1->dest;
1197 fl.fl_ip_sport = t1->source;
1198
1199 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
1200 if ((xfrm_lookup(&buff->dst, &fl, NULL, 0)) < 0) {
1201 dst_release(buff->dst);
1202 return;
1203 }
1204 ip6_xmit(NULL, buff, &fl, NULL, 0);
1205 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1206 return;
1207 }
1208
1209 kfree_skb(buff);
1210 }
1211
1212 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1213 {
1214 struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
1215
1216 tcp_v6_send_ack(skb, tw->tw_snd_nxt, tw->tw_rcv_nxt,
1217 tw->tw_rcv_wnd >> tw->tw_rcv_wscale, tw->tw_ts_recent);
1218
1219 tcp_tw_put(tw);
1220 }
1221
1222 static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req)
1223 {
1224 tcp_v6_send_ack(skb, req->snt_isn+1, req->rcv_isn+1, req->rcv_wnd, req->ts_recent);
1225 }
1226
1227
1228 static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1229 {
1230 struct open_request *req, **prev;
1231 struct tcphdr *th = skb->h.th;
1232 struct tcp_sock *tp = tcp_sk(sk);
1233 struct sock *nsk;
1234
1235 /* Find possible connection requests. */
1236 req = tcp_v6_search_req(tp, &prev, th->source, &skb->nh.ipv6h->saddr,
1237 &skb->nh.ipv6h->daddr, tcp_v6_iif(skb));
1238 if (req)
1239 return tcp_check_req(sk, skb, req, prev);
1240
1241 nsk = __tcp_v6_lookup_established(&skb->nh.ipv6h->saddr,
1242 th->source,
1243 &skb->nh.ipv6h->daddr,
1244 ntohs(th->dest),
1245 tcp_v6_iif(skb));
1246
1247 if (nsk) {
1248 if (nsk->sk_state != TCP_TIME_WAIT) {
1249 bh_lock_sock(nsk);
1250 return nsk;
1251 }
1252 tcp_tw_put((struct tcp_tw_bucket*)nsk);
1253 return NULL;
1254 }
1255
1256 #if 0 /*def CONFIG_SYN_COOKIES*/
1257 if (!th->rst && !th->syn && th->ack)
1258 sk = cookie_v6_check(sk, skb, &(IPCB(skb)->opt));
1259 #endif
1260 return sk;
1261 }
1262
1263 static void tcp_v6_synq_add(struct sock *sk, struct open_request *req)
1264 {
1265 struct tcp_sock *tp = tcp_sk(sk);
1266 struct tcp_listen_opt *lopt = tp->listen_opt;
1267 u32 h = tcp_v6_synq_hash(&req->af.v6_req.rmt_addr, req->rmt_port, lopt->hash_rnd);
1268
1269 req->sk = NULL;
1270 req->expires = jiffies + TCP_TIMEOUT_INIT;
1271 req->retrans = 0;
1272 req->dl_next = lopt->syn_table[h];
1273
1274 write_lock(&tp->syn_wait_lock);
1275 lopt->syn_table[h] = req;
1276 write_unlock(&tp->syn_wait_lock);
1277
1278 tcp_synq_added(sk);
1279 }
1280
1281
1282 /* FIXME: this is substantially similar to the ipv4 code.
1283 * Can some kind of merge be done? -- erics
1284 */
1285 static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1286 {
1287 struct ipv6_pinfo *np = inet6_sk(sk);
1288 struct tcp_options_received tmp_opt;
1289 struct tcp_sock *tp = tcp_sk(sk);
1290 struct open_request *req = NULL;
1291 __u32 isn = TCP_SKB_CB(skb)->when;
1292
1293 if (skb->protocol == htons(ETH_P_IP))
1294 return tcp_v4_conn_request(sk, skb);
1295
1296 if (!ipv6_unicast_destination(skb))
1297 goto drop;
1298
1299 /*
1300 * There are no SYN attacks on IPv6, yet...
1301 */
1302 if (tcp_synq_is_full(sk) && !isn) {
1303 if (net_ratelimit())
1304 printk(KERN_INFO "TCPv6: dropping request, synflood is possible\n");
1305 goto drop;
1306 }
1307
1308 if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
1309 goto drop;
1310
1311 req = tcp_openreq_alloc();
1312 if (req == NULL)
1313 goto drop;
1314
1315 tcp_clear_options(&tmp_opt);
1316 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1317 tmp_opt.user_mss = tp->rx_opt.user_mss;
1318
1319 tcp_parse_options(skb, &tmp_opt, 0);
1320
1321 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1322 tcp_openreq_init(req, &tmp_opt, skb);
1323
1324 req->class = &or_ipv6;
1325 ipv6_addr_copy(&req->af.v6_req.rmt_addr, &skb->nh.ipv6h->saddr);
1326 ipv6_addr_copy(&req->af.v6_req.loc_addr, &skb->nh.ipv6h->daddr);
1327 TCP_ECN_create_request(req, skb->h.th);
1328 req->af.v6_req.pktopts = NULL;
1329 if (ipv6_opt_accepted(sk, skb) ||
1330 np->rxopt.bits.rxinfo ||
1331 np->rxopt.bits.rxhlim) {
1332 atomic_inc(&skb->users);
1333 req->af.v6_req.pktopts = skb;
1334 }
1335 req->af.v6_req.iif = sk->sk_bound_dev_if;
1336
1337 /* So that link locals have meaning */
1338 if (!sk->sk_bound_dev_if &&
1339 ipv6_addr_type(&req->af.v6_req.rmt_addr) & IPV6_ADDR_LINKLOCAL)
1340 req->af.v6_req.iif = tcp_v6_iif(skb);
1341
1342 if (isn == 0)
1343 isn = tcp_v6_init_sequence(sk,skb);
1344
1345 req->snt_isn = isn;
1346
1347 if (tcp_v6_send_synack(sk, req, NULL))
1348 goto drop;
1349
1350 tcp_v6_synq_add(sk, req);
1351
1352 return 0;
1353
1354 drop:
1355 if (req)
1356 tcp_openreq_free(req);
1357
1358 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1359 return 0; /* don't send reset */
1360 }
1361
1362 static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1363 struct open_request *req,
1364 struct dst_entry *dst)
1365 {
1366 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1367 struct tcp6_sock *newtcp6sk;
1368 struct inet_sock *newinet;
1369 struct tcp_sock *newtp;
1370 struct sock *newsk;
1371 struct ipv6_txoptions *opt;
1372
1373 if (skb->protocol == htons(ETH_P_IP)) {
1374 /*
1375 * v6 mapped
1376 */
1377
1378 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1379
1380 if (newsk == NULL)
1381 return NULL;
1382
1383 newtcp6sk = (struct tcp6_sock *)newsk;
1384 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1385
1386 newinet = inet_sk(newsk);
1387 newnp = inet6_sk(newsk);
1388 newtp = tcp_sk(newsk);
1389
1390 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1391
1392 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
1393 newinet->daddr);
1394
1395 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
1396 newinet->saddr);
1397
1398 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1399
1400 newtp->af_specific = &ipv6_mapped;
1401 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1402 newnp->pktoptions = NULL;
1403 newnp->opt = NULL;
1404 newnp->mcast_oif = tcp_v6_iif(skb);
1405 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
1406
1407 /* Charge newly allocated IPv6 socket. Though it is mapped,
1408 * it is IPv6 yet.
1409 */
1410 #ifdef INET_REFCNT_DEBUG
1411 atomic_inc(&inet6_sock_nr);
1412 #endif
1413
1414 /* It is tricky place. Until this moment IPv4 tcp
1415 worked with IPv6 af_tcp.af_specific.
1416 Sync it now.
1417 */
1418 tcp_sync_mss(newsk, newtp->pmtu_cookie);
1419
1420 return newsk;
1421 }
1422
1423 opt = np->opt;
1424
1425 if (sk_acceptq_is_full(sk))
1426 goto out_overflow;
1427
1428 if (np->rxopt.bits.srcrt == 2 &&
1429 opt == NULL && req->af.v6_req.pktopts) {
1430 struct inet6_skb_parm *rxopt = IP6CB(req->af.v6_req.pktopts);
1431 if (rxopt->srcrt)
1432 opt = ipv6_invert_rthdr(sk, (struct ipv6_rt_hdr*)(req->af.v6_req.pktopts->nh.raw+rxopt->srcrt));
1433 }
1434
1435 if (dst == NULL) {
1436 struct in6_addr *final_p = NULL, final;
1437 struct flowi fl;
1438
1439 memset(&fl, 0, sizeof(fl));
1440 fl.proto = IPPROTO_TCP;
1441 ipv6_addr_copy(&fl.fl6_dst, &req->af.v6_req.rmt_addr);
1442 if (opt && opt->srcrt) {
1443 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
1444 ipv6_addr_copy(&final, &fl.fl6_dst);
1445 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1446 final_p = &final;
1447 }
1448 ipv6_addr_copy(&fl.fl6_src, &req->af.v6_req.loc_addr);
1449 fl.oif = sk->sk_bound_dev_if;
1450 fl.fl_ip_dport = req->rmt_port;
1451 fl.fl_ip_sport = inet_sk(sk)->sport;
1452
1453 if (ip6_dst_lookup(sk, &dst, &fl))
1454 goto out;
1455
1456 if (final_p)
1457 ipv6_addr_copy(&fl.fl6_dst, final_p);
1458
1459 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
1460 goto out;
1461 }
1462
1463 newsk = tcp_create_openreq_child(sk, req, skb);
1464 if (newsk == NULL)
1465 goto out;
1466
1467 /* Charge newly allocated IPv6 socket */
1468 #ifdef INET_REFCNT_DEBUG
1469 atomic_inc(&inet6_sock_nr);
1470 #endif
1471
1472 ip6_dst_store(newsk, dst, NULL);
1473 newsk->sk_route_caps = dst->dev->features &
1474 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
1475
1476 newtcp6sk = (struct tcp6_sock *)newsk;
1477 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1478
1479 newtp = tcp_sk(newsk);
1480 newinet = inet_sk(newsk);
1481 newnp = inet6_sk(newsk);
1482
1483 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1484
1485 ipv6_addr_copy(&newnp->daddr, &req->af.v6_req.rmt_addr);
1486 ipv6_addr_copy(&newnp->saddr, &req->af.v6_req.loc_addr);
1487 ipv6_addr_copy(&newnp->rcv_saddr, &req->af.v6_req.loc_addr);
1488 newsk->sk_bound_dev_if = req->af.v6_req.iif;
1489
1490 /* Now IPv6 options...
1491
1492 First: no IPv4 options.
1493 */
1494 newinet->opt = NULL;
1495
1496 /* Clone RX bits */
1497 newnp->rxopt.all = np->rxopt.all;
1498
1499 /* Clone pktoptions received with SYN */
1500 newnp->pktoptions = NULL;
1501 if (req->af.v6_req.pktopts) {
1502 newnp->pktoptions = skb_clone(req->af.v6_req.pktopts,
1503 GFP_ATOMIC);
1504 kfree_skb(req->af.v6_req.pktopts);
1505 req->af.v6_req.pktopts = NULL;
1506 if (newnp->pktoptions)
1507 skb_set_owner_r(newnp->pktoptions, newsk);
1508 }
1509 newnp->opt = NULL;
1510 newnp->mcast_oif = tcp_v6_iif(skb);
1511 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
1512
1513 /* Clone native IPv6 options from listening socket (if any)
1514
1515 Yes, keeping reference count would be much more clever,
1516 but we make one more one thing there: reattach optmem
1517 to newsk.
1518 */
1519 if (opt) {
1520 newnp->opt = ipv6_dup_options(newsk, opt);
1521 if (opt != np->opt)
1522 sock_kfree_s(sk, opt, opt->tot_len);
1523 }
1524
1525 newtp->ext_header_len = 0;
1526 if (newnp->opt)
1527 newtp->ext_header_len = newnp->opt->opt_nflen +
1528 newnp->opt->opt_flen;
1529
1530 tcp_sync_mss(newsk, dst_mtu(dst));
1531 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1532 tcp_initialize_rcv_mss(newsk);
1533
1534 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
1535
1536 __tcp_v6_hash(newsk);
1537 tcp_inherit_port(sk, newsk);
1538
1539 return newsk;
1540
1541 out_overflow:
1542 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1543 out:
1544 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1545 if (opt && opt != np->opt)
1546 sock_kfree_s(sk, opt, opt->tot_len);
1547 dst_release(dst);
1548 return NULL;
1549 }
1550
1551 static int tcp_v6_checksum_init(struct sk_buff *skb)
1552 {
1553 if (skb->ip_summed == CHECKSUM_HW) {
1554 skb->ip_summed = CHECKSUM_UNNECESSARY;
1555 if (!tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
1556 &skb->nh.ipv6h->daddr,skb->csum))
1557 return 0;
1558 LIMIT_NETDEBUG(printk(KERN_DEBUG "hw tcp v6 csum failed\n"));
1559 }
1560 if (skb->len <= 76) {
1561 if (tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
1562 &skb->nh.ipv6h->daddr,skb_checksum(skb, 0, skb->len, 0)))
1563 return -1;
1564 skb->ip_summed = CHECKSUM_UNNECESSARY;
1565 } else {
1566 skb->csum = ~tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
1567 &skb->nh.ipv6h->daddr,0);
1568 }
1569 return 0;
1570 }
1571
1572 /* The socket must have it's spinlock held when we get
1573 * here.
1574 *
1575 * We have a potential double-lock case here, so even when
1576 * doing backlog processing we use the BH locking scheme.
1577 * This is because we cannot sleep with the original spinlock
1578 * held.
1579 */
1580 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1581 {
1582 struct ipv6_pinfo *np = inet6_sk(sk);
1583 struct tcp_sock *tp;
1584 struct sk_buff *opt_skb = NULL;
1585
1586 /* Imagine: socket is IPv6. IPv4 packet arrives,
1587 goes to IPv4 receive handler and backlogged.
1588 From backlog it always goes here. Kerboom...
1589 Fortunately, tcp_rcv_established and rcv_established
1590 handle them correctly, but it is not case with
1591 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1592 */
1593
1594 if (skb->protocol == htons(ETH_P_IP))
1595 return tcp_v4_do_rcv(sk, skb);
1596
1597 if (sk_filter(sk, skb, 0))
1598 goto discard;
1599
1600 /*
1601 * socket locking is here for SMP purposes as backlog rcv
1602 * is currently called with bh processing disabled.
1603 */
1604
1605 /* Do Stevens' IPV6_PKTOPTIONS.
1606
1607 Yes, guys, it is the only place in our code, where we
1608 may make it not affecting IPv4.
1609 The rest of code is protocol independent,
1610 and I do not like idea to uglify IPv4.
1611
1612 Actually, all the idea behind IPV6_PKTOPTIONS
1613 looks not very well thought. For now we latch
1614 options, received in the last packet, enqueued
1615 by tcp. Feel free to propose better solution.
1616 --ANK (980728)
1617 */
1618 if (np->rxopt.all)
1619 opt_skb = skb_clone(skb, GFP_ATOMIC);
1620
1621 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1622 TCP_CHECK_TIMER(sk);
1623 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1624 goto reset;
1625 TCP_CHECK_TIMER(sk);
1626 if (opt_skb)
1627 goto ipv6_pktoptions;
1628 return 0;
1629 }
1630
1631 if (skb->len < (skb->h.th->doff<<2) || tcp_checksum_complete(skb))
1632 goto csum_err;
1633
1634 if (sk->sk_state == TCP_LISTEN) {
1635 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1636 if (!nsk)
1637 goto discard;
1638
1639 /*
1640 * Queue it on the new socket if the new socket is active,
1641 * otherwise we just shortcircuit this and continue with
1642 * the new socket..
1643 */
1644 if(nsk != sk) {
1645 if (tcp_child_process(sk, nsk, skb))
1646 goto reset;
1647 if (opt_skb)
1648 __kfree_skb(opt_skb);
1649 return 0;
1650 }
1651 }
1652
1653 TCP_CHECK_TIMER(sk);
1654 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1655 goto reset;
1656 TCP_CHECK_TIMER(sk);
1657 if (opt_skb)
1658 goto ipv6_pktoptions;
1659 return 0;
1660
1661 reset:
1662 tcp_v6_send_reset(skb);
1663 discard:
1664 if (opt_skb)
1665 __kfree_skb(opt_skb);
1666 kfree_skb(skb);
1667 return 0;
1668 csum_err:
1669 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1670 goto discard;
1671
1672
1673 ipv6_pktoptions:
1674 /* Do you ask, what is it?
1675
1676 1. skb was enqueued by tcp.
1677 2. skb is added to tail of read queue, rather than out of order.
1678 3. socket is not in passive state.
1679 4. Finally, it really contains options, which user wants to receive.
1680 */
1681 tp = tcp_sk(sk);
1682 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1683 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1684 if (np->rxopt.bits.rxinfo)
1685 np->mcast_oif = tcp_v6_iif(opt_skb);
1686 if (np->rxopt.bits.rxhlim)
1687 np->mcast_hops = opt_skb->nh.ipv6h->hop_limit;
1688 if (ipv6_opt_accepted(sk, opt_skb)) {
1689 skb_set_owner_r(opt_skb, sk);
1690 opt_skb = xchg(&np->pktoptions, opt_skb);
1691 } else {
1692 __kfree_skb(opt_skb);
1693 opt_skb = xchg(&np->pktoptions, NULL);
1694 }
1695 }
1696
1697 if (opt_skb)
1698 kfree_skb(opt_skb);
1699 return 0;
1700 }
1701
1702 static int tcp_v6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
1703 {
1704 struct sk_buff *skb = *pskb;
1705 struct tcphdr *th;
1706 struct sock *sk;
1707 int ret;
1708
1709 if (skb->pkt_type != PACKET_HOST)
1710 goto discard_it;
1711
1712 /*
1713 * Count it even if it's bad.
1714 */
1715 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1716
1717 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1718 goto discard_it;
1719
1720 th = skb->h.th;
1721
1722 if (th->doff < sizeof(struct tcphdr)/4)
1723 goto bad_packet;
1724 if (!pskb_may_pull(skb, th->doff*4))
1725 goto discard_it;
1726
1727 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
1728 tcp_v6_checksum_init(skb) < 0))
1729 goto bad_packet;
1730
1731 th = skb->h.th;
1732 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1733 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1734 skb->len - th->doff*4);
1735 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1736 TCP_SKB_CB(skb)->when = 0;
1737 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(skb->nh.ipv6h);
1738 TCP_SKB_CB(skb)->sacked = 0;
1739
1740 sk = __tcp_v6_lookup(&skb->nh.ipv6h->saddr, th->source,
1741 &skb->nh.ipv6h->daddr, ntohs(th->dest), tcp_v6_iif(skb));
1742
1743 if (!sk)
1744 goto no_tcp_socket;
1745
1746 process:
1747 if (sk->sk_state == TCP_TIME_WAIT)
1748 goto do_time_wait;
1749
1750 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1751 goto discard_and_relse;
1752
1753 if (sk_filter(sk, skb, 0))
1754 goto discard_and_relse;
1755
1756 skb->dev = NULL;
1757
1758 bh_lock_sock(sk);
1759 ret = 0;
1760 if (!sock_owned_by_user(sk)) {
1761 if (!tcp_prequeue(sk, skb))
1762 ret = tcp_v6_do_rcv(sk, skb);
1763 } else
1764 sk_add_backlog(sk, skb);
1765 bh_unlock_sock(sk);
1766
1767 sock_put(sk);
1768 return ret ? -1 : 0;
1769
1770 no_tcp_socket:
1771 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1772 goto discard_it;
1773
1774 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1775 bad_packet:
1776 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1777 } else {
1778 tcp_v6_send_reset(skb);
1779 }
1780
1781 discard_it:
1782
1783 /*
1784 * Discard frame
1785 */
1786
1787 kfree_skb(skb);
1788 return 0;
1789
1790 discard_and_relse:
1791 sock_put(sk);
1792 goto discard_it;
1793
1794 do_time_wait:
1795 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1796 tcp_tw_put((struct tcp_tw_bucket *) sk);
1797 goto discard_it;
1798 }
1799
1800 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1801 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1802 tcp_tw_put((struct tcp_tw_bucket *) sk);
1803 goto discard_it;
1804 }
1805
1806 switch(tcp_timewait_state_process((struct tcp_tw_bucket *)sk,
1807 skb, th, skb->len)) {
1808 case TCP_TW_SYN:
1809 {
1810 struct sock *sk2;
1811
1812 sk2 = tcp_v6_lookup_listener(&skb->nh.ipv6h->daddr, ntohs(th->dest), tcp_v6_iif(skb));
1813 if (sk2 != NULL) {
1814 tcp_tw_deschedule((struct tcp_tw_bucket *)sk);
1815 tcp_tw_put((struct tcp_tw_bucket *)sk);
1816 sk = sk2;
1817 goto process;
1818 }
1819 /* Fall through to ACK */
1820 }
1821 case TCP_TW_ACK:
1822 tcp_v6_timewait_ack(sk, skb);
1823 break;
1824 case TCP_TW_RST:
1825 goto no_tcp_socket;
1826 case TCP_TW_SUCCESS:;
1827 }
1828 goto discard_it;
1829 }
1830
1831 static int tcp_v6_rebuild_header(struct sock *sk)
1832 {
1833 int err;
1834 struct dst_entry *dst;
1835 struct ipv6_pinfo *np = inet6_sk(sk);
1836
1837 dst = __sk_dst_check(sk, np->dst_cookie);
1838
1839 if (dst == NULL) {
1840 struct inet_sock *inet = inet_sk(sk);
1841 struct in6_addr *final_p = NULL, final;
1842 struct flowi fl;
1843
1844 memset(&fl, 0, sizeof(fl));
1845 fl.proto = IPPROTO_TCP;
1846 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
1847 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
1848 fl.fl6_flowlabel = np->flow_label;
1849 fl.oif = sk->sk_bound_dev_if;
1850 fl.fl_ip_dport = inet->dport;
1851 fl.fl_ip_sport = inet->sport;
1852
1853 if (np->opt && np->opt->srcrt) {
1854 struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
1855 ipv6_addr_copy(&final, &fl.fl6_dst);
1856 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1857 final_p = &final;
1858 }
1859
1860 err = ip6_dst_lookup(sk, &dst, &fl);
1861 if (err) {
1862 sk->sk_route_caps = 0;
1863 return err;
1864 }
1865 if (final_p)
1866 ipv6_addr_copy(&fl.fl6_dst, final_p);
1867
1868 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
1869 sk->sk_err_soft = -err;
1870 dst_release(dst);
1871 return err;
1872 }
1873
1874 ip6_dst_store(sk, dst, NULL);
1875 sk->sk_route_caps = dst->dev->features &
1876 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
1877 }
1878
1879 return 0;
1880 }
1881
1882 static int tcp_v6_xmit(struct sk_buff *skb, int ipfragok)
1883 {
1884 struct sock *sk = skb->sk;
1885 struct inet_sock *inet = inet_sk(sk);
1886 struct ipv6_pinfo *np = inet6_sk(sk);
1887 struct flowi fl;
1888 struct dst_entry *dst;
1889 struct in6_addr *final_p = NULL, final;
1890
1891 memset(&fl, 0, sizeof(fl));
1892 fl.proto = IPPROTO_TCP;
1893 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
1894 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
1895 fl.fl6_flowlabel = np->flow_label;
1896 IP6_ECN_flow_xmit(sk, fl.fl6_flowlabel);
1897 fl.oif = sk->sk_bound_dev_if;
1898 fl.fl_ip_sport = inet->sport;
1899 fl.fl_ip_dport = inet->dport;
1900
1901 if (np->opt && np->opt->srcrt) {
1902 struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
1903 ipv6_addr_copy(&final, &fl.fl6_dst);
1904 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1905 final_p = &final;
1906 }
1907
1908 dst = __sk_dst_check(sk, np->dst_cookie);
1909
1910 if (dst == NULL) {
1911 int err = ip6_dst_lookup(sk, &dst, &fl);
1912
1913 if (err) {
1914 sk->sk_err_soft = -err;
1915 return err;
1916 }
1917
1918 if (final_p)
1919 ipv6_addr_copy(&fl.fl6_dst, final_p);
1920
1921 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
1922 sk->sk_route_caps = 0;
1923 dst_release(dst);
1924 return err;
1925 }
1926
1927 ip6_dst_store(sk, dst, NULL);
1928 sk->sk_route_caps = dst->dev->features &
1929 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
1930 }
1931
1932 skb->dst = dst_clone(dst);
1933
1934 /* Restore final destination back after routing done */
1935 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
1936
1937 return ip6_xmit(sk, skb, &fl, np->opt, 0);
1938 }
1939
1940 static void v6_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr)
1941 {
1942 struct ipv6_pinfo *np = inet6_sk(sk);
1943 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) uaddr;
1944
1945 sin6->sin6_family = AF_INET6;
1946 ipv6_addr_copy(&sin6->sin6_addr, &np->daddr);
1947 sin6->sin6_port = inet_sk(sk)->dport;
1948 /* We do not store received flowlabel for TCP */
1949 sin6->sin6_flowinfo = 0;
1950 sin6->sin6_scope_id = 0;
1951 if (sk->sk_bound_dev_if &&
1952 ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
1953 sin6->sin6_scope_id = sk->sk_bound_dev_if;
1954 }
1955
1956 static int tcp_v6_remember_stamp(struct sock *sk)
1957 {
1958 /* Alas, not yet... */
1959 return 0;
1960 }
1961
1962 static struct tcp_func ipv6_specific = {
1963 .queue_xmit = tcp_v6_xmit,
1964 .send_check = tcp_v6_send_check,
1965 .rebuild_header = tcp_v6_rebuild_header,
1966 .conn_request = tcp_v6_conn_request,
1967 .syn_recv_sock = tcp_v6_syn_recv_sock,
1968 .remember_stamp = tcp_v6_remember_stamp,
1969 .net_header_len = sizeof(struct ipv6hdr),
1970
1971 .setsockopt = ipv6_setsockopt,
1972 .getsockopt = ipv6_getsockopt,
1973 .addr2sockaddr = v6_addr2sockaddr,
1974 .sockaddr_len = sizeof(struct sockaddr_in6)
1975 };
1976
1977 /*
1978 * TCP over IPv4 via INET6 API
1979 */
1980
1981 static struct tcp_func ipv6_mapped = {
1982 .queue_xmit = ip_queue_xmit,
1983 .send_check = tcp_v4_send_check,
1984 .rebuild_header = tcp_v4_rebuild_header,
1985 .conn_request = tcp_v6_conn_request,
1986 .syn_recv_sock = tcp_v6_syn_recv_sock,
1987 .remember_stamp = tcp_v4_remember_stamp,
1988 .net_header_len = sizeof(struct iphdr),
1989
1990 .setsockopt = ipv6_setsockopt,
1991 .getsockopt = ipv6_getsockopt,
1992 .addr2sockaddr = v6_addr2sockaddr,
1993 .sockaddr_len = sizeof(struct sockaddr_in6)
1994 };
1995
1996
1997
1998 /* NOTE: A lot of things set to zero explicitly by call to
1999 * sk_alloc() so need not be done here.
2000 */
2001 static int tcp_v6_init_sock(struct sock *sk)
2002 {
2003 struct tcp_sock *tp = tcp_sk(sk);
2004
2005 skb_queue_head_init(&tp->out_of_order_queue);
2006 tcp_init_xmit_timers(sk);
2007 tcp_prequeue_init(tp);
2008
2009 tp->rto = TCP_TIMEOUT_INIT;
2010 tp->mdev = TCP_TIMEOUT_INIT;
2011
2012 /* So many TCP implementations out there (incorrectly) count the
2013 * initial SYN frame in their delayed-ACK and congestion control
2014 * algorithms that we must have the following bandaid to talk
2015 * efficiently to them. -DaveM
2016 */
2017 tp->snd_cwnd = 2;
2018
2019 /* See draft-stevens-tcpca-spec-01 for discussion of the
2020 * initialization of these values.
2021 */
2022 tp->snd_ssthresh = 0x7fffffff;
2023 tp->snd_cwnd_clamp = ~0;
2024 tp->mss_cache_std = tp->mss_cache = 536;
2025
2026 tp->reordering = sysctl_tcp_reordering;
2027
2028 sk->sk_state = TCP_CLOSE;
2029
2030 tp->af_specific = &ipv6_specific;
2031
2032 sk->sk_write_space = sk_stream_write_space;
2033 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
2034
2035 sk->sk_sndbuf = sysctl_tcp_wmem[1];
2036 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
2037
2038 atomic_inc(&tcp_sockets_allocated);
2039
2040 return 0;
2041 }
2042
2043 static int tcp_v6_destroy_sock(struct sock *sk)
2044 {
2045 extern int tcp_v4_destroy_sock(struct sock *sk);
2046
2047 tcp_v4_destroy_sock(sk);
2048 return inet6_destroy_sock(sk);
2049 }
2050
2051 /* Proc filesystem TCPv6 sock list dumping. */
2052 static void get_openreq6(struct seq_file *seq,
2053 struct sock *sk, struct open_request *req, int i, int uid)
2054 {
2055 struct in6_addr *dest, *src;
2056 int ttd = req->expires - jiffies;
2057
2058 if (ttd < 0)
2059 ttd = 0;
2060
2061 src = &req->af.v6_req.loc_addr;
2062 dest = &req->af.v6_req.rmt_addr;
2063 seq_printf(seq,
2064 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2065 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2066 i,
2067 src->s6_addr32[0], src->s6_addr32[1],
2068 src->s6_addr32[2], src->s6_addr32[3],
2069 ntohs(inet_sk(sk)->sport),
2070 dest->s6_addr32[0], dest->s6_addr32[1],
2071 dest->s6_addr32[2], dest->s6_addr32[3],
2072 ntohs(req->rmt_port),
2073 TCP_SYN_RECV,
2074 0,0, /* could print option size, but that is af dependent. */
2075 1, /* timers active (only the expire timer) */
2076 jiffies_to_clock_t(ttd),
2077 req->retrans,
2078 uid,
2079 0, /* non standard timer */
2080 0, /* open_requests have no inode */
2081 0, req);
2082 }
2083
2084 static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
2085 {
2086 struct in6_addr *dest, *src;
2087 __u16 destp, srcp;
2088 int timer_active;
2089 unsigned long timer_expires;
2090 struct inet_sock *inet = inet_sk(sp);
2091 struct tcp_sock *tp = tcp_sk(sp);
2092 struct ipv6_pinfo *np = inet6_sk(sp);
2093
2094 dest = &np->daddr;
2095 src = &np->rcv_saddr;
2096 destp = ntohs(inet->dport);
2097 srcp = ntohs(inet->sport);
2098 if (tp->pending == TCP_TIME_RETRANS) {
2099 timer_active = 1;
2100 timer_expires = tp->timeout;
2101 } else if (tp->pending == TCP_TIME_PROBE0) {
2102 timer_active = 4;
2103 timer_expires = tp->timeout;
2104 } else if (timer_pending(&sp->sk_timer)) {
2105 timer_active = 2;
2106 timer_expires = sp->sk_timer.expires;
2107 } else {
2108 timer_active = 0;
2109 timer_expires = jiffies;
2110 }
2111
2112 seq_printf(seq,
2113 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2114 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %u %u %u %u %d\n",
2115 i,
2116 src->s6_addr32[0], src->s6_addr32[1],
2117 src->s6_addr32[2], src->s6_addr32[3], srcp,
2118 dest->s6_addr32[0], dest->s6_addr32[1],
2119 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2120 sp->sk_state,
2121 tp->write_seq-tp->snd_una, tp->rcv_nxt-tp->copied_seq,
2122 timer_active,
2123 jiffies_to_clock_t(timer_expires - jiffies),
2124 tp->retransmits,
2125 sock_i_uid(sp),
2126 tp->probes_out,
2127 sock_i_ino(sp),
2128 atomic_read(&sp->sk_refcnt), sp,
2129 tp->rto, tp->ack.ato, (tp->ack.quick<<1)|tp->ack.pingpong,
2130 tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
2131 );
2132 }
2133
2134 static void get_timewait6_sock(struct seq_file *seq,
2135 struct tcp_tw_bucket *tw, int i)
2136 {
2137 struct in6_addr *dest, *src;
2138 __u16 destp, srcp;
2139 int ttd = tw->tw_ttd - jiffies;
2140
2141 if (ttd < 0)
2142 ttd = 0;
2143
2144 dest = &tw->tw_v6_daddr;
2145 src = &tw->tw_v6_rcv_saddr;
2146 destp = ntohs(tw->tw_dport);
2147 srcp = ntohs(tw->tw_sport);
2148
2149 seq_printf(seq,
2150 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2151 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2152 i,
2153 src->s6_addr32[0], src->s6_addr32[1],
2154 src->s6_addr32[2], src->s6_addr32[3], srcp,
2155 dest->s6_addr32[0], dest->s6_addr32[1],
2156 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2157 tw->tw_substate, 0, 0,
2158 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2159 atomic_read(&tw->tw_refcnt), tw);
2160 }
2161
2162 #ifdef CONFIG_PROC_FS
2163 static int tcp6_seq_show(struct seq_file *seq, void *v)
2164 {
2165 struct tcp_iter_state *st;
2166
2167 if (v == SEQ_START_TOKEN) {
2168 seq_puts(seq,
2169 " sl "
2170 "local_address "
2171 "remote_address "
2172 "st tx_queue rx_queue tr tm->when retrnsmt"
2173 " uid timeout inode\n");
2174 goto out;
2175 }
2176 st = seq->private;
2177
2178 switch (st->state) {
2179 case TCP_SEQ_STATE_LISTENING:
2180 case TCP_SEQ_STATE_ESTABLISHED:
2181 get_tcp6_sock(seq, v, st->num);
2182 break;
2183 case TCP_SEQ_STATE_OPENREQ:
2184 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2185 break;
2186 case TCP_SEQ_STATE_TIME_WAIT:
2187 get_timewait6_sock(seq, v, st->num);
2188 break;
2189 }
2190 out:
2191 return 0;
2192 }
2193
2194 static struct file_operations tcp6_seq_fops;
2195 static struct tcp_seq_afinfo tcp6_seq_afinfo = {
2196 .owner = THIS_MODULE,
2197 .name = "tcp6",
2198 .family = AF_INET6,
2199 .seq_show = tcp6_seq_show,
2200 .seq_fops = &tcp6_seq_fops,
2201 };
2202
2203 int __init tcp6_proc_init(void)
2204 {
2205 return tcp_proc_register(&tcp6_seq_afinfo);
2206 }
2207
2208 void tcp6_proc_exit(void)
2209 {
2210 tcp_proc_unregister(&tcp6_seq_afinfo);
2211 }
2212 #endif
2213
2214 struct proto tcpv6_prot = {
2215 .name = "TCPv6",
2216 .owner = THIS_MODULE,
2217 .close = tcp_close,
2218 .connect = tcp_v6_connect,
2219 .disconnect = tcp_disconnect,
2220 .accept = tcp_accept,
2221 .ioctl = tcp_ioctl,
2222 .init = tcp_v6_init_sock,
2223 .destroy = tcp_v6_destroy_sock,
2224 .shutdown = tcp_shutdown,
2225 .setsockopt = tcp_setsockopt,
2226 .getsockopt = tcp_getsockopt,
2227 .sendmsg = tcp_sendmsg,
2228 .recvmsg = tcp_recvmsg,
2229 .backlog_rcv = tcp_v6_do_rcv,
2230 .hash = tcp_v6_hash,
2231 .unhash = tcp_unhash,
2232 .get_port = tcp_v6_get_port,
2233 .enter_memory_pressure = tcp_enter_memory_pressure,
2234 .sockets_allocated = &tcp_sockets_allocated,
2235 .memory_allocated = &tcp_memory_allocated,
2236 .memory_pressure = &tcp_memory_pressure,
2237 .sysctl_mem = sysctl_tcp_mem,
2238 .sysctl_wmem = sysctl_tcp_wmem,
2239 .sysctl_rmem = sysctl_tcp_rmem,
2240 .max_header = MAX_TCP_HEADER,
2241 .obj_size = sizeof(struct tcp6_sock),
2242 };
2243
2244 static struct inet6_protocol tcpv6_protocol = {
2245 .handler = tcp_v6_rcv,
2246 .err_handler = tcp_v6_err,
2247 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2248 };
2249
2250 extern struct proto_ops inet6_stream_ops;
2251
2252 static struct inet_protosw tcpv6_protosw = {
2253 .type = SOCK_STREAM,
2254 .protocol = IPPROTO_TCP,
2255 .prot = &tcpv6_prot,
2256 .ops = &inet6_stream_ops,
2257 .capability = -1,
2258 .no_check = 0,
2259 .flags = INET_PROTOSW_PERMANENT,
2260 };
2261
2262 void __init tcpv6_init(void)
2263 {
2264 /* register inet6 protocol */
2265 if (inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP) < 0)
2266 printk(KERN_ERR "tcpv6_init: Could not register protocol\n");
2267 inet6_register_protosw(&tcpv6_protosw);
2268 }
Verdex Pro support