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