3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * $Id: tcp_ipv6.c,v 1.144 2002/02/01 22:01:04 davem Exp $
11 * linux/net/ipv4/tcp.c
12 * linux/net/ipv4/tcp_input.c
13 * linux/net/ipv4/tcp_output.c
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.
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.
28 #include <linux/module.h>
29 #include <linux/errno.h>
30 #include <linux/types.h>
31 #include <linux/socket.h>
32 #include <linux/sockios.h>
33 #include <linux/net.h>
34 #include <linux/jiffies.h>
36 #include <linux/in6.h>
37 #include <linux/netdevice.h>
38 #include <linux/init.h>
39 #include <linux/jhash.h>
40 #include <linux/ipsec.h>
41 #include <linux/times.h>
43 #include <linux/ipv6.h>
44 #include <linux/icmpv6.h>
45 #include <linux/random.h>
48 #include <net/ndisc.h>
49 #include <net/inet6_hashtables.h>
50 #include <net/inet6_connection_sock.h>
52 #include <net/transp_v6.h>
53 #include <net/addrconf.h>
54 #include <net/ip6_route.h>
55 #include <net/ip6_checksum.h>
56 #include <net/inet_ecn.h>
57 #include <net/protocol.h>
59 #include <net/addrconf.h>
61 #include <net/dsfield.h>
62 #include <net/timewait_sock.h>
64 #include <asm/uaccess.h>
66 #include <linux/proc_fs.h>
67 #include <linux/seq_file.h>
69 #include <linux/crypto.h>
70 #include <linux/scatterlist.h>
72 /* Socket used for sending RSTs and ACKs */
73 static struct socket
*tcp6_socket
;
75 static void tcp_v6_send_reset(struct sock
*sk
, struct sk_buff
*skb
);
76 static void tcp_v6_reqsk_send_ack(struct sk_buff
*skb
, struct request_sock
*req
);
77 static void tcp_v6_send_check(struct sock
*sk
, int len
,
80 static int tcp_v6_do_rcv(struct sock
*sk
, struct sk_buff
*skb
);
82 static struct inet_connection_sock_af_ops ipv6_mapped
;
83 static struct inet_connection_sock_af_ops ipv6_specific
;
84 #ifdef CONFIG_TCP_MD5SIG
85 static struct tcp_sock_af_ops tcp_sock_ipv6_specific
;
86 static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific
;
89 static int tcp_v6_get_port(struct sock
*sk
, unsigned short snum
)
91 return inet_csk_get_port(&tcp_hashinfo
, sk
, snum
,
92 inet6_csk_bind_conflict
);
95 static void tcp_v6_hash(struct sock
*sk
)
97 if (sk
->sk_state
!= TCP_CLOSE
) {
98 if (inet_csk(sk
)->icsk_af_ops
== &ipv6_mapped
) {
103 __inet6_hash(&tcp_hashinfo
, sk
);
108 static __inline__ __sum16
tcp_v6_check(struct tcphdr
*th
, int len
,
109 struct in6_addr
*saddr
,
110 struct in6_addr
*daddr
,
113 return csum_ipv6_magic(saddr
, daddr
, len
, IPPROTO_TCP
, base
);
116 static __u32
tcp_v6_init_sequence(struct sk_buff
*skb
)
118 return secure_tcpv6_sequence_number(skb
->nh
.ipv6h
->daddr
.s6_addr32
,
119 skb
->nh
.ipv6h
->saddr
.s6_addr32
,
124 static int tcp_v6_connect(struct sock
*sk
, struct sockaddr
*uaddr
,
127 struct sockaddr_in6
*usin
= (struct sockaddr_in6
*) uaddr
;
128 struct inet_sock
*inet
= inet_sk(sk
);
129 struct inet_connection_sock
*icsk
= inet_csk(sk
);
130 struct ipv6_pinfo
*np
= inet6_sk(sk
);
131 struct tcp_sock
*tp
= tcp_sk(sk
);
132 struct in6_addr
*saddr
= NULL
, *final_p
= NULL
, final
;
134 struct dst_entry
*dst
;
138 if (addr_len
< SIN6_LEN_RFC2133
)
141 if (usin
->sin6_family
!= AF_INET6
)
142 return(-EAFNOSUPPORT
);
144 memset(&fl
, 0, sizeof(fl
));
147 fl
.fl6_flowlabel
= usin
->sin6_flowinfo
&IPV6_FLOWINFO_MASK
;
148 IP6_ECN_flow_init(fl
.fl6_flowlabel
);
149 if (fl
.fl6_flowlabel
&IPV6_FLOWLABEL_MASK
) {
150 struct ip6_flowlabel
*flowlabel
;
151 flowlabel
= fl6_sock_lookup(sk
, fl
.fl6_flowlabel
);
152 if (flowlabel
== NULL
)
154 ipv6_addr_copy(&usin
->sin6_addr
, &flowlabel
->dst
);
155 fl6_sock_release(flowlabel
);
160 * connect() to INADDR_ANY means loopback (BSD'ism).
163 if(ipv6_addr_any(&usin
->sin6_addr
))
164 usin
->sin6_addr
.s6_addr
[15] = 0x1;
166 addr_type
= ipv6_addr_type(&usin
->sin6_addr
);
168 if(addr_type
& IPV6_ADDR_MULTICAST
)
171 if (addr_type
&IPV6_ADDR_LINKLOCAL
) {
172 if (addr_len
>= sizeof(struct sockaddr_in6
) &&
173 usin
->sin6_scope_id
) {
174 /* If interface is set while binding, indices
177 if (sk
->sk_bound_dev_if
&&
178 sk
->sk_bound_dev_if
!= usin
->sin6_scope_id
)
181 sk
->sk_bound_dev_if
= usin
->sin6_scope_id
;
184 /* Connect to link-local address requires an interface */
185 if (!sk
->sk_bound_dev_if
)
189 if (tp
->rx_opt
.ts_recent_stamp
&&
190 !ipv6_addr_equal(&np
->daddr
, &usin
->sin6_addr
)) {
191 tp
->rx_opt
.ts_recent
= 0;
192 tp
->rx_opt
.ts_recent_stamp
= 0;
196 ipv6_addr_copy(&np
->daddr
, &usin
->sin6_addr
);
197 np
->flow_label
= fl
.fl6_flowlabel
;
203 if (addr_type
== IPV6_ADDR_MAPPED
) {
204 u32 exthdrlen
= icsk
->icsk_ext_hdr_len
;
205 struct sockaddr_in sin
;
207 SOCK_DEBUG(sk
, "connect: ipv4 mapped\n");
209 if (__ipv6_only_sock(sk
))
212 sin
.sin_family
= AF_INET
;
213 sin
.sin_port
= usin
->sin6_port
;
214 sin
.sin_addr
.s_addr
= usin
->sin6_addr
.s6_addr32
[3];
216 icsk
->icsk_af_ops
= &ipv6_mapped
;
217 sk
->sk_backlog_rcv
= tcp_v4_do_rcv
;
218 #ifdef CONFIG_TCP_MD5SIG
219 tp
->af_specific
= &tcp_sock_ipv6_mapped_specific
;
222 err
= tcp_v4_connect(sk
, (struct sockaddr
*)&sin
, sizeof(sin
));
225 icsk
->icsk_ext_hdr_len
= exthdrlen
;
226 icsk
->icsk_af_ops
= &ipv6_specific
;
227 sk
->sk_backlog_rcv
= tcp_v6_do_rcv
;
228 #ifdef CONFIG_TCP_MD5SIG
229 tp
->af_specific
= &tcp_sock_ipv6_specific
;
233 ipv6_addr_set(&np
->saddr
, 0, 0, htonl(0x0000FFFF),
235 ipv6_addr_set(&np
->rcv_saddr
, 0, 0, htonl(0x0000FFFF),
242 if (!ipv6_addr_any(&np
->rcv_saddr
))
243 saddr
= &np
->rcv_saddr
;
245 fl
.proto
= IPPROTO_TCP
;
246 ipv6_addr_copy(&fl
.fl6_dst
, &np
->daddr
);
247 ipv6_addr_copy(&fl
.fl6_src
,
248 (saddr
? saddr
: &np
->saddr
));
249 fl
.oif
= sk
->sk_bound_dev_if
;
250 fl
.fl_ip_dport
= usin
->sin6_port
;
251 fl
.fl_ip_sport
= inet
->sport
;
253 if (np
->opt
&& np
->opt
->srcrt
) {
254 struct rt0_hdr
*rt0
= (struct rt0_hdr
*)np
->opt
->srcrt
;
255 ipv6_addr_copy(&final
, &fl
.fl6_dst
);
256 ipv6_addr_copy(&fl
.fl6_dst
, rt0
->addr
);
260 security_sk_classify_flow(sk
, &fl
);
262 err
= ip6_dst_lookup(sk
, &dst
, &fl
);
266 ipv6_addr_copy(&fl
.fl6_dst
, final_p
);
268 if ((err
= xfrm_lookup(&dst
, &fl
, sk
, 1)) < 0)
273 ipv6_addr_copy(&np
->rcv_saddr
, saddr
);
276 /* set the source address */
277 ipv6_addr_copy(&np
->saddr
, saddr
);
278 inet
->rcv_saddr
= LOOPBACK4_IPV6
;
280 sk
->sk_gso_type
= SKB_GSO_TCPV6
;
281 __ip6_dst_store(sk
, dst
, NULL
, NULL
);
283 icsk
->icsk_ext_hdr_len
= 0;
285 icsk
->icsk_ext_hdr_len
= (np
->opt
->opt_flen
+
288 tp
->rx_opt
.mss_clamp
= IPV6_MIN_MTU
- sizeof(struct tcphdr
) - sizeof(struct ipv6hdr
);
290 inet
->dport
= usin
->sin6_port
;
292 tcp_set_state(sk
, TCP_SYN_SENT
);
293 err
= inet6_hash_connect(&tcp_death_row
, sk
);
298 tp
->write_seq
= secure_tcpv6_sequence_number(np
->saddr
.s6_addr32
,
303 err
= tcp_connect(sk
);
310 tcp_set_state(sk
, TCP_CLOSE
);
314 sk
->sk_route_caps
= 0;
318 static void tcp_v6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
319 int type
, int code
, int offset
, __be32 info
)
321 struct ipv6hdr
*hdr
= (struct ipv6hdr
*)skb
->data
;
322 const struct tcphdr
*th
= (struct tcphdr
*)(skb
->data
+offset
);
323 struct ipv6_pinfo
*np
;
329 sk
= inet6_lookup(&tcp_hashinfo
, &hdr
->daddr
, th
->dest
, &hdr
->saddr
,
330 th
->source
, skb
->dev
->ifindex
);
333 ICMP6_INC_STATS_BH(__in6_dev_get(skb
->dev
), ICMP6_MIB_INERRORS
);
337 if (sk
->sk_state
== TCP_TIME_WAIT
) {
338 inet_twsk_put(inet_twsk(sk
));
343 if (sock_owned_by_user(sk
))
344 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS
);
346 if (sk
->sk_state
== TCP_CLOSE
)
350 seq
= ntohl(th
->seq
);
351 if (sk
->sk_state
!= TCP_LISTEN
&&
352 !between(seq
, tp
->snd_una
, tp
->snd_nxt
)) {
353 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS
);
359 if (type
== ICMPV6_PKT_TOOBIG
) {
360 struct dst_entry
*dst
= NULL
;
362 if (sock_owned_by_user(sk
))
364 if ((1 << sk
->sk_state
) & (TCPF_LISTEN
| TCPF_CLOSE
))
367 /* icmp should have updated the destination cache entry */
368 dst
= __sk_dst_check(sk
, np
->dst_cookie
);
371 struct inet_sock
*inet
= inet_sk(sk
);
374 /* BUGGG_FUTURE: Again, it is not clear how
375 to handle rthdr case. Ignore this complexity
378 memset(&fl
, 0, sizeof(fl
));
379 fl
.proto
= IPPROTO_TCP
;
380 ipv6_addr_copy(&fl
.fl6_dst
, &np
->daddr
);
381 ipv6_addr_copy(&fl
.fl6_src
, &np
->saddr
);
382 fl
.oif
= sk
->sk_bound_dev_if
;
383 fl
.fl_ip_dport
= inet
->dport
;
384 fl
.fl_ip_sport
= inet
->sport
;
385 security_skb_classify_flow(skb
, &fl
);
387 if ((err
= ip6_dst_lookup(sk
, &dst
, &fl
))) {
388 sk
->sk_err_soft
= -err
;
392 if ((err
= xfrm_lookup(&dst
, &fl
, sk
, 0)) < 0) {
393 sk
->sk_err_soft
= -err
;
400 if (inet_csk(sk
)->icsk_pmtu_cookie
> dst_mtu(dst
)) {
401 tcp_sync_mss(sk
, dst_mtu(dst
));
402 tcp_simple_retransmit(sk
);
403 } /* else let the usual retransmit timer handle it */
408 icmpv6_err_convert(type
, code
, &err
);
410 /* Might be for an request_sock */
411 switch (sk
->sk_state
) {
412 struct request_sock
*req
, **prev
;
414 if (sock_owned_by_user(sk
))
417 req
= inet6_csk_search_req(sk
, &prev
, th
->dest
, &hdr
->daddr
,
418 &hdr
->saddr
, inet6_iif(skb
));
422 /* ICMPs are not backlogged, hence we cannot get
423 * an established socket here.
425 BUG_TRAP(req
->sk
== NULL
);
427 if (seq
!= tcp_rsk(req
)->snt_isn
) {
428 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS
);
432 inet_csk_reqsk_queue_drop(sk
, req
, prev
);
436 case TCP_SYN_RECV
: /* Cannot happen.
437 It can, it SYNs are crossed. --ANK */
438 if (!sock_owned_by_user(sk
)) {
440 sk
->sk_error_report(sk
); /* Wake people up to see the error (see connect in sock.c) */
444 sk
->sk_err_soft
= err
;
448 if (!sock_owned_by_user(sk
) && np
->recverr
) {
450 sk
->sk_error_report(sk
);
452 sk
->sk_err_soft
= err
;
460 static int tcp_v6_send_synack(struct sock
*sk
, struct request_sock
*req
,
461 struct dst_entry
*dst
)
463 struct inet6_request_sock
*treq
= inet6_rsk(req
);
464 struct ipv6_pinfo
*np
= inet6_sk(sk
);
465 struct sk_buff
* skb
;
466 struct ipv6_txoptions
*opt
= NULL
;
467 struct in6_addr
* final_p
= NULL
, final
;
471 memset(&fl
, 0, sizeof(fl
));
472 fl
.proto
= IPPROTO_TCP
;
473 ipv6_addr_copy(&fl
.fl6_dst
, &treq
->rmt_addr
);
474 ipv6_addr_copy(&fl
.fl6_src
, &treq
->loc_addr
);
475 fl
.fl6_flowlabel
= 0;
477 fl
.fl_ip_dport
= inet_rsk(req
)->rmt_port
;
478 fl
.fl_ip_sport
= inet_sk(sk
)->sport
;
479 security_req_classify_flow(req
, &fl
);
484 np
->rxopt
.bits
.osrcrt
== 2 &&
486 struct sk_buff
*pktopts
= treq
->pktopts
;
487 struct inet6_skb_parm
*rxopt
= IP6CB(pktopts
);
489 opt
= ipv6_invert_rthdr(sk
,
490 (struct ipv6_rt_hdr
*)(skb_network_header(pktopts
) +
494 if (opt
&& opt
->srcrt
) {
495 struct rt0_hdr
*rt0
= (struct rt0_hdr
*) opt
->srcrt
;
496 ipv6_addr_copy(&final
, &fl
.fl6_dst
);
497 ipv6_addr_copy(&fl
.fl6_dst
, rt0
->addr
);
501 err
= ip6_dst_lookup(sk
, &dst
, &fl
);
505 ipv6_addr_copy(&fl
.fl6_dst
, final_p
);
506 if ((err
= xfrm_lookup(&dst
, &fl
, sk
, 0)) < 0)
510 skb
= tcp_make_synack(sk
, dst
, req
);
512 struct tcphdr
*th
= skb
->h
.th
;
514 th
->check
= tcp_v6_check(th
, skb
->len
,
515 &treq
->loc_addr
, &treq
->rmt_addr
,
516 csum_partial((char *)th
, skb
->len
, skb
->csum
));
518 ipv6_addr_copy(&fl
.fl6_dst
, &treq
->rmt_addr
);
519 err
= ip6_xmit(sk
, skb
, &fl
, opt
, 0);
520 err
= net_xmit_eval(err
);
524 if (opt
&& opt
!= np
->opt
)
525 sock_kfree_s(sk
, opt
, opt
->tot_len
);
530 static void tcp_v6_reqsk_destructor(struct request_sock
*req
)
532 if (inet6_rsk(req
)->pktopts
)
533 kfree_skb(inet6_rsk(req
)->pktopts
);
536 #ifdef CONFIG_TCP_MD5SIG
537 static struct tcp_md5sig_key
*tcp_v6_md5_do_lookup(struct sock
*sk
,
538 struct in6_addr
*addr
)
540 struct tcp_sock
*tp
= tcp_sk(sk
);
545 if (!tp
->md5sig_info
|| !tp
->md5sig_info
->entries6
)
548 for (i
= 0; i
< tp
->md5sig_info
->entries6
; i
++) {
549 if (ipv6_addr_cmp(&tp
->md5sig_info
->keys6
[i
].addr
, addr
) == 0)
550 return (struct tcp_md5sig_key
*)&tp
->md5sig_info
->keys6
[i
];
555 static struct tcp_md5sig_key
*tcp_v6_md5_lookup(struct sock
*sk
,
556 struct sock
*addr_sk
)
558 return tcp_v6_md5_do_lookup(sk
, &inet6_sk(addr_sk
)->daddr
);
561 static struct tcp_md5sig_key
*tcp_v6_reqsk_md5_lookup(struct sock
*sk
,
562 struct request_sock
*req
)
564 return tcp_v6_md5_do_lookup(sk
, &inet6_rsk(req
)->rmt_addr
);
567 static int tcp_v6_md5_do_add(struct sock
*sk
, struct in6_addr
*peer
,
568 char *newkey
, u8 newkeylen
)
570 /* Add key to the list */
571 struct tcp6_md5sig_key
*key
;
572 struct tcp_sock
*tp
= tcp_sk(sk
);
573 struct tcp6_md5sig_key
*keys
;
575 key
= (struct tcp6_md5sig_key
*) tcp_v6_md5_do_lookup(sk
, peer
);
577 /* modify existing entry - just update that one */
580 key
->keylen
= newkeylen
;
582 /* reallocate new list if current one is full. */
583 if (!tp
->md5sig_info
) {
584 tp
->md5sig_info
= kzalloc(sizeof(*tp
->md5sig_info
), GFP_ATOMIC
);
585 if (!tp
->md5sig_info
) {
590 tcp_alloc_md5sig_pool();
591 if (tp
->md5sig_info
->alloced6
== tp
->md5sig_info
->entries6
) {
592 keys
= kmalloc((sizeof (tp
->md5sig_info
->keys6
[0]) *
593 (tp
->md5sig_info
->entries6
+ 1)), GFP_ATOMIC
);
596 tcp_free_md5sig_pool();
601 if (tp
->md5sig_info
->entries6
)
602 memmove(keys
, tp
->md5sig_info
->keys6
,
603 (sizeof (tp
->md5sig_info
->keys6
[0]) *
604 tp
->md5sig_info
->entries6
));
606 kfree(tp
->md5sig_info
->keys6
);
607 tp
->md5sig_info
->keys6
= keys
;
608 tp
->md5sig_info
->alloced6
++;
611 ipv6_addr_copy(&tp
->md5sig_info
->keys6
[tp
->md5sig_info
->entries6
].addr
,
613 tp
->md5sig_info
->keys6
[tp
->md5sig_info
->entries6
].key
= newkey
;
614 tp
->md5sig_info
->keys6
[tp
->md5sig_info
->entries6
].keylen
= newkeylen
;
616 tp
->md5sig_info
->entries6
++;
621 static int tcp_v6_md5_add_func(struct sock
*sk
, struct sock
*addr_sk
,
622 u8
*newkey
, __u8 newkeylen
)
624 return tcp_v6_md5_do_add(sk
, &inet6_sk(addr_sk
)->daddr
,
628 static int tcp_v6_md5_do_del(struct sock
*sk
, struct in6_addr
*peer
)
630 struct tcp_sock
*tp
= tcp_sk(sk
);
633 for (i
= 0; i
< tp
->md5sig_info
->entries6
; i
++) {
634 if (ipv6_addr_cmp(&tp
->md5sig_info
->keys6
[i
].addr
, peer
) == 0) {
636 kfree(tp
->md5sig_info
->keys6
[i
].key
);
637 tp
->md5sig_info
->entries6
--;
639 if (tp
->md5sig_info
->entries6
== 0) {
640 kfree(tp
->md5sig_info
->keys6
);
641 tp
->md5sig_info
->keys6
= NULL
;
643 tcp_free_md5sig_pool();
647 /* shrink the database */
648 if (tp
->md5sig_info
->entries6
!= i
)
649 memmove(&tp
->md5sig_info
->keys6
[i
],
650 &tp
->md5sig_info
->keys6
[i
+1],
651 (tp
->md5sig_info
->entries6
- i
)
652 * sizeof (tp
->md5sig_info
->keys6
[0]));
659 static void tcp_v6_clear_md5_list (struct sock
*sk
)
661 struct tcp_sock
*tp
= tcp_sk(sk
);
664 if (tp
->md5sig_info
->entries6
) {
665 for (i
= 0; i
< tp
->md5sig_info
->entries6
; i
++)
666 kfree(tp
->md5sig_info
->keys6
[i
].key
);
667 tp
->md5sig_info
->entries6
= 0;
668 tcp_free_md5sig_pool();
671 kfree(tp
->md5sig_info
->keys6
);
672 tp
->md5sig_info
->keys6
= NULL
;
673 tp
->md5sig_info
->alloced6
= 0;
675 if (tp
->md5sig_info
->entries4
) {
676 for (i
= 0; i
< tp
->md5sig_info
->entries4
; i
++)
677 kfree(tp
->md5sig_info
->keys4
[i
].key
);
678 tp
->md5sig_info
->entries4
= 0;
679 tcp_free_md5sig_pool();
682 kfree(tp
->md5sig_info
->keys4
);
683 tp
->md5sig_info
->keys4
= NULL
;
684 tp
->md5sig_info
->alloced4
= 0;
687 static int tcp_v6_parse_md5_keys (struct sock
*sk
, char __user
*optval
,
690 struct tcp_md5sig cmd
;
691 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)&cmd
.tcpm_addr
;
694 if (optlen
< sizeof(cmd
))
697 if (copy_from_user(&cmd
, optval
, sizeof(cmd
)))
700 if (sin6
->sin6_family
!= AF_INET6
)
703 if (!cmd
.tcpm_keylen
) {
704 if (!tcp_sk(sk
)->md5sig_info
)
706 if (ipv6_addr_type(&sin6
->sin6_addr
) & IPV6_ADDR_MAPPED
)
707 return tcp_v4_md5_do_del(sk
, sin6
->sin6_addr
.s6_addr32
[3]);
708 return tcp_v6_md5_do_del(sk
, &sin6
->sin6_addr
);
711 if (cmd
.tcpm_keylen
> TCP_MD5SIG_MAXKEYLEN
)
714 if (!tcp_sk(sk
)->md5sig_info
) {
715 struct tcp_sock
*tp
= tcp_sk(sk
);
716 struct tcp_md5sig_info
*p
;
718 p
= kzalloc(sizeof(struct tcp_md5sig_info
), GFP_KERNEL
);
725 newkey
= kmemdup(cmd
.tcpm_key
, cmd
.tcpm_keylen
, GFP_KERNEL
);
728 if (ipv6_addr_type(&sin6
->sin6_addr
) & IPV6_ADDR_MAPPED
) {
729 return tcp_v4_md5_do_add(sk
, sin6
->sin6_addr
.s6_addr32
[3],
730 newkey
, cmd
.tcpm_keylen
);
732 return tcp_v6_md5_do_add(sk
, &sin6
->sin6_addr
, newkey
, cmd
.tcpm_keylen
);
735 static int tcp_v6_do_calc_md5_hash(char *md5_hash
, struct tcp_md5sig_key
*key
,
736 struct in6_addr
*saddr
,
737 struct in6_addr
*daddr
,
738 struct tcphdr
*th
, int protocol
,
741 struct scatterlist sg
[4];
745 struct tcp_md5sig_pool
*hp
;
746 struct tcp6_pseudohdr
*bp
;
747 struct hash_desc
*desc
;
749 unsigned int nbytes
= 0;
751 hp
= tcp_get_md5sig_pool();
753 printk(KERN_WARNING
"%s(): hash pool not found...\n", __FUNCTION__
);
754 goto clear_hash_noput
;
756 bp
= &hp
->md5_blk
.ip6
;
757 desc
= &hp
->md5_desc
;
759 /* 1. TCP pseudo-header (RFC2460) */
760 ipv6_addr_copy(&bp
->saddr
, saddr
);
761 ipv6_addr_copy(&bp
->daddr
, daddr
);
762 bp
->len
= htonl(tcplen
);
763 bp
->protocol
= htonl(protocol
);
765 sg_set_buf(&sg
[block
++], bp
, sizeof(*bp
));
766 nbytes
+= sizeof(*bp
);
768 /* 2. TCP header, excluding options */
771 sg_set_buf(&sg
[block
++], th
, sizeof(*th
));
772 nbytes
+= sizeof(*th
);
774 /* 3. TCP segment data (if any) */
775 data_len
= tcplen
- (th
->doff
<< 2);
777 u8
*data
= (u8
*)th
+ (th
->doff
<< 2);
778 sg_set_buf(&sg
[block
++], data
, data_len
);
783 sg_set_buf(&sg
[block
++], key
->key
, key
->keylen
);
784 nbytes
+= key
->keylen
;
786 /* Now store the hash into the packet */
787 err
= crypto_hash_init(desc
);
789 printk(KERN_WARNING
"%s(): hash_init failed\n", __FUNCTION__
);
792 err
= crypto_hash_update(desc
, sg
, nbytes
);
794 printk(KERN_WARNING
"%s(): hash_update failed\n", __FUNCTION__
);
797 err
= crypto_hash_final(desc
, md5_hash
);
799 printk(KERN_WARNING
"%s(): hash_final failed\n", __FUNCTION__
);
803 /* Reset header, and free up the crypto */
804 tcp_put_md5sig_pool();
809 tcp_put_md5sig_pool();
811 memset(md5_hash
, 0, 16);
815 static int tcp_v6_calc_md5_hash(char *md5_hash
, struct tcp_md5sig_key
*key
,
817 struct dst_entry
*dst
,
818 struct request_sock
*req
,
819 struct tcphdr
*th
, int protocol
,
822 struct in6_addr
*saddr
, *daddr
;
825 saddr
= &inet6_sk(sk
)->saddr
;
826 daddr
= &inet6_sk(sk
)->daddr
;
828 saddr
= &inet6_rsk(req
)->loc_addr
;
829 daddr
= &inet6_rsk(req
)->rmt_addr
;
831 return tcp_v6_do_calc_md5_hash(md5_hash
, key
,
833 th
, protocol
, tcplen
);
836 static int tcp_v6_inbound_md5_hash (struct sock
*sk
, struct sk_buff
*skb
)
838 __u8
*hash_location
= NULL
;
839 struct tcp_md5sig_key
*hash_expected
;
840 struct ipv6hdr
*ip6h
= skb
->nh
.ipv6h
;
841 struct tcphdr
*th
= skb
->h
.th
;
842 int length
= (th
->doff
<< 2) - sizeof (*th
);
847 hash_expected
= tcp_v6_md5_do_lookup(sk
, &ip6h
->saddr
);
849 /* If the TCP option is too short, we can short cut */
850 if (length
< TCPOLEN_MD5SIG
)
851 return hash_expected
? 1 : 0;
867 if (opsize
< 2 || opsize
> length
)
869 if (opcode
== TCPOPT_MD5SIG
) {
879 /* do we have a hash as expected? */
880 if (!hash_expected
) {
883 if (net_ratelimit()) {
884 printk(KERN_INFO
"MD5 Hash NOT expected but found "
885 "(" NIP6_FMT
", %u)->"
886 "(" NIP6_FMT
", %u)\n",
887 NIP6(ip6h
->saddr
), ntohs(th
->source
),
888 NIP6(ip6h
->daddr
), ntohs(th
->dest
));
893 if (!hash_location
) {
894 if (net_ratelimit()) {
895 printk(KERN_INFO
"MD5 Hash expected but NOT found "
896 "(" NIP6_FMT
", %u)->"
897 "(" NIP6_FMT
", %u)\n",
898 NIP6(ip6h
->saddr
), ntohs(th
->source
),
899 NIP6(ip6h
->daddr
), ntohs(th
->dest
));
904 /* check the signature */
905 genhash
= tcp_v6_do_calc_md5_hash(newhash
,
907 &ip6h
->saddr
, &ip6h
->daddr
,
910 if (genhash
|| memcmp(hash_location
, newhash
, 16) != 0) {
911 if (net_ratelimit()) {
912 printk(KERN_INFO
"MD5 Hash %s for "
913 "(" NIP6_FMT
", %u)->"
914 "(" NIP6_FMT
", %u)\n",
915 genhash
? "failed" : "mismatch",
916 NIP6(ip6h
->saddr
), ntohs(th
->source
),
917 NIP6(ip6h
->daddr
), ntohs(th
->dest
));
925 static struct request_sock_ops tcp6_request_sock_ops __read_mostly
= {
927 .obj_size
= sizeof(struct tcp6_request_sock
),
928 .rtx_syn_ack
= tcp_v6_send_synack
,
929 .send_ack
= tcp_v6_reqsk_send_ack
,
930 .destructor
= tcp_v6_reqsk_destructor
,
931 .send_reset
= tcp_v6_send_reset
934 #ifdef CONFIG_TCP_MD5SIG
935 static struct tcp_request_sock_ops tcp_request_sock_ipv6_ops
= {
936 .md5_lookup
= tcp_v6_reqsk_md5_lookup
,
940 static struct timewait_sock_ops tcp6_timewait_sock_ops
= {
941 .twsk_obj_size
= sizeof(struct tcp6_timewait_sock
),
942 .twsk_unique
= tcp_twsk_unique
,
943 .twsk_destructor
= tcp_twsk_destructor
,
946 static void tcp_v6_send_check(struct sock
*sk
, int len
, struct sk_buff
*skb
)
948 struct ipv6_pinfo
*np
= inet6_sk(sk
);
949 struct tcphdr
*th
= skb
->h
.th
;
951 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
952 th
->check
= ~csum_ipv6_magic(&np
->saddr
, &np
->daddr
, len
, IPPROTO_TCP
, 0);
953 skb
->csum_offset
= offsetof(struct tcphdr
, check
);
955 th
->check
= csum_ipv6_magic(&np
->saddr
, &np
->daddr
, len
, IPPROTO_TCP
,
956 csum_partial((char *)th
, th
->doff
<<2,
961 static int tcp_v6_gso_send_check(struct sk_buff
*skb
)
963 struct ipv6hdr
*ipv6h
;
966 if (!pskb_may_pull(skb
, sizeof(*th
)))
969 ipv6h
= skb
->nh
.ipv6h
;
973 th
->check
= ~csum_ipv6_magic(&ipv6h
->saddr
, &ipv6h
->daddr
, skb
->len
,
975 skb
->csum_offset
= offsetof(struct tcphdr
, check
);
976 skb
->ip_summed
= CHECKSUM_PARTIAL
;
980 static void tcp_v6_send_reset(struct sock
*sk
, struct sk_buff
*skb
)
982 struct tcphdr
*th
= skb
->h
.th
, *t1
;
983 struct sk_buff
*buff
;
985 int tot_len
= sizeof(*th
);
986 #ifdef CONFIG_TCP_MD5SIG
987 struct tcp_md5sig_key
*key
;
993 if (!ipv6_unicast_destination(skb
))
996 #ifdef CONFIG_TCP_MD5SIG
998 key
= tcp_v6_md5_do_lookup(sk
, &skb
->nh
.ipv6h
->daddr
);
1003 tot_len
+= TCPOLEN_MD5SIG_ALIGNED
;
1007 * We need to grab some memory, and put together an RST,
1008 * and then put it into the queue to be sent.
1011 buff
= alloc_skb(MAX_HEADER
+ sizeof(struct ipv6hdr
) + tot_len
,
1016 skb_reserve(buff
, MAX_HEADER
+ sizeof(struct ipv6hdr
) + tot_len
);
1018 t1
= (struct tcphdr
*) skb_push(buff
, tot_len
);
1020 /* Swap the send and the receive. */
1021 memset(t1
, 0, sizeof(*t1
));
1022 t1
->dest
= th
->source
;
1023 t1
->source
= th
->dest
;
1024 t1
->doff
= tot_len
/ 4;
1028 t1
->seq
= th
->ack_seq
;
1031 t1
->ack_seq
= htonl(ntohl(th
->seq
) + th
->syn
+ th
->fin
1032 + skb
->len
- (th
->doff
<<2));
1035 #ifdef CONFIG_TCP_MD5SIG
1037 __be32
*opt
= (__be32
*)(t1
+ 1);
1038 opt
[0] = htonl((TCPOPT_NOP
<< 24) |
1039 (TCPOPT_NOP
<< 16) |
1040 (TCPOPT_MD5SIG
<< 8) |
1042 tcp_v6_do_calc_md5_hash((__u8
*)&opt
[1],
1044 &skb
->nh
.ipv6h
->daddr
,
1045 &skb
->nh
.ipv6h
->saddr
,
1051 buff
->csum
= csum_partial((char *)t1
, sizeof(*t1
), 0);
1053 memset(&fl
, 0, sizeof(fl
));
1054 ipv6_addr_copy(&fl
.fl6_dst
, &skb
->nh
.ipv6h
->saddr
);
1055 ipv6_addr_copy(&fl
.fl6_src
, &skb
->nh
.ipv6h
->daddr
);
1057 t1
->check
= csum_ipv6_magic(&fl
.fl6_src
, &fl
.fl6_dst
,
1058 sizeof(*t1
), IPPROTO_TCP
,
1061 fl
.proto
= IPPROTO_TCP
;
1062 fl
.oif
= inet6_iif(skb
);
1063 fl
.fl_ip_dport
= t1
->dest
;
1064 fl
.fl_ip_sport
= t1
->source
;
1065 security_skb_classify_flow(skb
, &fl
);
1067 /* sk = NULL, but it is safe for now. RST socket required. */
1068 if (!ip6_dst_lookup(NULL
, &buff
->dst
, &fl
)) {
1070 if (xfrm_lookup(&buff
->dst
, &fl
, NULL
, 0) >= 0) {
1071 ip6_xmit(tcp6_socket
->sk
, buff
, &fl
, NULL
, 0);
1072 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS
);
1073 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS
);
1081 static void tcp_v6_send_ack(struct tcp_timewait_sock
*tw
,
1082 struct sk_buff
*skb
, u32 seq
, u32 ack
, u32 win
, u32 ts
)
1084 struct tcphdr
*th
= skb
->h
.th
, *t1
;
1085 struct sk_buff
*buff
;
1087 int tot_len
= sizeof(struct tcphdr
);
1089 #ifdef CONFIG_TCP_MD5SIG
1090 struct tcp_md5sig_key
*key
;
1091 struct tcp_md5sig_key tw_key
;
1094 #ifdef CONFIG_TCP_MD5SIG
1095 if (!tw
&& skb
->sk
) {
1096 key
= tcp_v6_md5_do_lookup(skb
->sk
, &skb
->nh
.ipv6h
->daddr
);
1097 } else if (tw
&& tw
->tw_md5_keylen
) {
1098 tw_key
.key
= tw
->tw_md5_key
;
1099 tw_key
.keylen
= tw
->tw_md5_keylen
;
1107 tot_len
+= TCPOLEN_TSTAMP_ALIGNED
;
1108 #ifdef CONFIG_TCP_MD5SIG
1110 tot_len
+= TCPOLEN_MD5SIG_ALIGNED
;
1113 buff
= alloc_skb(MAX_HEADER
+ sizeof(struct ipv6hdr
) + tot_len
,
1118 skb_reserve(buff
, MAX_HEADER
+ sizeof(struct ipv6hdr
) + tot_len
);
1120 t1
= (struct tcphdr
*) skb_push(buff
,tot_len
);
1122 /* Swap the send and the receive. */
1123 memset(t1
, 0, sizeof(*t1
));
1124 t1
->dest
= th
->source
;
1125 t1
->source
= th
->dest
;
1126 t1
->doff
= tot_len
/4;
1127 t1
->seq
= htonl(seq
);
1128 t1
->ack_seq
= htonl(ack
);
1130 t1
->window
= htons(win
);
1132 topt
= (__be32
*)(t1
+ 1);
1135 *topt
++ = htonl((TCPOPT_NOP
<< 24) | (TCPOPT_NOP
<< 16) |
1136 (TCPOPT_TIMESTAMP
<< 8) | TCPOLEN_TIMESTAMP
);
1137 *topt
++ = htonl(tcp_time_stamp
);
1141 #ifdef CONFIG_TCP_MD5SIG
1143 *topt
++ = htonl((TCPOPT_NOP
<< 24) | (TCPOPT_NOP
<< 16) |
1144 (TCPOPT_MD5SIG
<< 8) | TCPOLEN_MD5SIG
);
1145 tcp_v6_do_calc_md5_hash((__u8
*)topt
,
1147 &skb
->nh
.ipv6h
->daddr
,
1148 &skb
->nh
.ipv6h
->saddr
,
1154 buff
->csum
= csum_partial((char *)t1
, tot_len
, 0);
1156 memset(&fl
, 0, sizeof(fl
));
1157 ipv6_addr_copy(&fl
.fl6_dst
, &skb
->nh
.ipv6h
->saddr
);
1158 ipv6_addr_copy(&fl
.fl6_src
, &skb
->nh
.ipv6h
->daddr
);
1160 t1
->check
= csum_ipv6_magic(&fl
.fl6_src
, &fl
.fl6_dst
,
1161 tot_len
, IPPROTO_TCP
,
1164 fl
.proto
= IPPROTO_TCP
;
1165 fl
.oif
= inet6_iif(skb
);
1166 fl
.fl_ip_dport
= t1
->dest
;
1167 fl
.fl_ip_sport
= t1
->source
;
1168 security_skb_classify_flow(skb
, &fl
);
1170 if (!ip6_dst_lookup(NULL
, &buff
->dst
, &fl
)) {
1171 if (xfrm_lookup(&buff
->dst
, &fl
, NULL
, 0) >= 0) {
1172 ip6_xmit(tcp6_socket
->sk
, buff
, &fl
, NULL
, 0);
1173 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS
);
1181 static void tcp_v6_timewait_ack(struct sock
*sk
, struct sk_buff
*skb
)
1183 struct inet_timewait_sock
*tw
= inet_twsk(sk
);
1184 struct tcp_timewait_sock
*tcptw
= tcp_twsk(sk
);
1186 tcp_v6_send_ack(tcptw
, skb
, tcptw
->tw_snd_nxt
, tcptw
->tw_rcv_nxt
,
1187 tcptw
->tw_rcv_wnd
>> tw
->tw_rcv_wscale
,
1188 tcptw
->tw_ts_recent
);
1193 static void tcp_v6_reqsk_send_ack(struct sk_buff
*skb
, struct request_sock
*req
)
1195 tcp_v6_send_ack(NULL
, skb
, tcp_rsk(req
)->snt_isn
+ 1, tcp_rsk(req
)->rcv_isn
+ 1, req
->rcv_wnd
, req
->ts_recent
);
1199 static struct sock
*tcp_v6_hnd_req(struct sock
*sk
,struct sk_buff
*skb
)
1201 struct request_sock
*req
, **prev
;
1202 const struct tcphdr
*th
= skb
->h
.th
;
1205 /* Find possible connection requests. */
1206 req
= inet6_csk_search_req(sk
, &prev
, th
->source
,
1207 &skb
->nh
.ipv6h
->saddr
,
1208 &skb
->nh
.ipv6h
->daddr
, inet6_iif(skb
));
1210 return tcp_check_req(sk
, skb
, req
, prev
);
1212 nsk
= __inet6_lookup_established(&tcp_hashinfo
, &skb
->nh
.ipv6h
->saddr
,
1213 th
->source
, &skb
->nh
.ipv6h
->daddr
,
1214 ntohs(th
->dest
), inet6_iif(skb
));
1217 if (nsk
->sk_state
!= TCP_TIME_WAIT
) {
1221 inet_twsk_put(inet_twsk(nsk
));
1225 #if 0 /*def CONFIG_SYN_COOKIES*/
1226 if (!th
->rst
&& !th
->syn
&& th
->ack
)
1227 sk
= cookie_v6_check(sk
, skb
, &(IPCB(skb
)->opt
));
1232 /* FIXME: this is substantially similar to the ipv4 code.
1233 * Can some kind of merge be done? -- erics
1235 static int tcp_v6_conn_request(struct sock
*sk
, struct sk_buff
*skb
)
1237 struct inet6_request_sock
*treq
;
1238 struct ipv6_pinfo
*np
= inet6_sk(sk
);
1239 struct tcp_options_received tmp_opt
;
1240 struct tcp_sock
*tp
= tcp_sk(sk
);
1241 struct request_sock
*req
= NULL
;
1242 __u32 isn
= TCP_SKB_CB(skb
)->when
;
1244 if (skb
->protocol
== htons(ETH_P_IP
))
1245 return tcp_v4_conn_request(sk
, skb
);
1247 if (!ipv6_unicast_destination(skb
))
1251 * There are no SYN attacks on IPv6, yet...
1253 if (inet_csk_reqsk_queue_is_full(sk
) && !isn
) {
1254 if (net_ratelimit())
1255 printk(KERN_INFO
"TCPv6: dropping request, synflood is possible\n");
1259 if (sk_acceptq_is_full(sk
) && inet_csk_reqsk_queue_young(sk
) > 1)
1262 req
= inet6_reqsk_alloc(&tcp6_request_sock_ops
);
1266 #ifdef CONFIG_TCP_MD5SIG
1267 tcp_rsk(req
)->af_specific
= &tcp_request_sock_ipv6_ops
;
1270 tcp_clear_options(&tmp_opt
);
1271 tmp_opt
.mss_clamp
= IPV6_MIN_MTU
- sizeof(struct tcphdr
) - sizeof(struct ipv6hdr
);
1272 tmp_opt
.user_mss
= tp
->rx_opt
.user_mss
;
1274 tcp_parse_options(skb
, &tmp_opt
, 0);
1276 tmp_opt
.tstamp_ok
= tmp_opt
.saw_tstamp
;
1277 tcp_openreq_init(req
, &tmp_opt
, skb
);
1279 treq
= inet6_rsk(req
);
1280 ipv6_addr_copy(&treq
->rmt_addr
, &skb
->nh
.ipv6h
->saddr
);
1281 ipv6_addr_copy(&treq
->loc_addr
, &skb
->nh
.ipv6h
->daddr
);
1282 TCP_ECN_create_request(req
, skb
->h
.th
);
1283 treq
->pktopts
= NULL
;
1284 if (ipv6_opt_accepted(sk
, skb
) ||
1285 np
->rxopt
.bits
.rxinfo
|| np
->rxopt
.bits
.rxoinfo
||
1286 np
->rxopt
.bits
.rxhlim
|| np
->rxopt
.bits
.rxohlim
) {
1287 atomic_inc(&skb
->users
);
1288 treq
->pktopts
= skb
;
1290 treq
->iif
= sk
->sk_bound_dev_if
;
1292 /* So that link locals have meaning */
1293 if (!sk
->sk_bound_dev_if
&&
1294 ipv6_addr_type(&treq
->rmt_addr
) & IPV6_ADDR_LINKLOCAL
)
1295 treq
->iif
= inet6_iif(skb
);
1298 isn
= tcp_v6_init_sequence(skb
);
1300 tcp_rsk(req
)->snt_isn
= isn
;
1302 security_inet_conn_request(sk
, skb
, req
);
1304 if (tcp_v6_send_synack(sk
, req
, NULL
))
1307 inet6_csk_reqsk_queue_hash_add(sk
, req
, TCP_TIMEOUT_INIT
);
1314 return 0; /* don't send reset */
1317 static struct sock
* tcp_v6_syn_recv_sock(struct sock
*sk
, struct sk_buff
*skb
,
1318 struct request_sock
*req
,
1319 struct dst_entry
*dst
)
1321 struct inet6_request_sock
*treq
= inet6_rsk(req
);
1322 struct ipv6_pinfo
*newnp
, *np
= inet6_sk(sk
);
1323 struct tcp6_sock
*newtcp6sk
;
1324 struct inet_sock
*newinet
;
1325 struct tcp_sock
*newtp
;
1327 struct ipv6_txoptions
*opt
;
1328 #ifdef CONFIG_TCP_MD5SIG
1329 struct tcp_md5sig_key
*key
;
1332 if (skb
->protocol
== htons(ETH_P_IP
)) {
1337 newsk
= tcp_v4_syn_recv_sock(sk
, skb
, req
, dst
);
1342 newtcp6sk
= (struct tcp6_sock
*)newsk
;
1343 inet_sk(newsk
)->pinet6
= &newtcp6sk
->inet6
;
1345 newinet
= inet_sk(newsk
);
1346 newnp
= inet6_sk(newsk
);
1347 newtp
= tcp_sk(newsk
);
1349 memcpy(newnp
, np
, sizeof(struct ipv6_pinfo
));
1351 ipv6_addr_set(&newnp
->daddr
, 0, 0, htonl(0x0000FFFF),
1354 ipv6_addr_set(&newnp
->saddr
, 0, 0, htonl(0x0000FFFF),
1357 ipv6_addr_copy(&newnp
->rcv_saddr
, &newnp
->saddr
);
1359 inet_csk(newsk
)->icsk_af_ops
= &ipv6_mapped
;
1360 newsk
->sk_backlog_rcv
= tcp_v4_do_rcv
;
1361 #ifdef CONFIG_TCP_MD5SIG
1362 newtp
->af_specific
= &tcp_sock_ipv6_mapped_specific
;
1365 newnp
->pktoptions
= NULL
;
1367 newnp
->mcast_oif
= inet6_iif(skb
);
1368 newnp
->mcast_hops
= skb
->nh
.ipv6h
->hop_limit
;
1371 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1372 * here, tcp_create_openreq_child now does this for us, see the comment in
1373 * that function for the gory details. -acme
1376 /* It is tricky place. Until this moment IPv4 tcp
1377 worked with IPv6 icsk.icsk_af_ops.
1380 tcp_sync_mss(newsk
, inet_csk(newsk
)->icsk_pmtu_cookie
);
1387 if (sk_acceptq_is_full(sk
))
1390 if (np
->rxopt
.bits
.osrcrt
== 2 &&
1391 opt
== NULL
&& treq
->pktopts
) {
1392 struct inet6_skb_parm
*rxopt
= IP6CB(treq
->pktopts
);
1394 opt
= ipv6_invert_rthdr(sk
,
1395 (struct ipv6_rt_hdr
*)(skb_network_header(treq
->pktopts
) +
1400 struct in6_addr
*final_p
= NULL
, final
;
1403 memset(&fl
, 0, sizeof(fl
));
1404 fl
.proto
= IPPROTO_TCP
;
1405 ipv6_addr_copy(&fl
.fl6_dst
, &treq
->rmt_addr
);
1406 if (opt
&& opt
->srcrt
) {
1407 struct rt0_hdr
*rt0
= (struct rt0_hdr
*) opt
->srcrt
;
1408 ipv6_addr_copy(&final
, &fl
.fl6_dst
);
1409 ipv6_addr_copy(&fl
.fl6_dst
, rt0
->addr
);
1412 ipv6_addr_copy(&fl
.fl6_src
, &treq
->loc_addr
);
1413 fl
.oif
= sk
->sk_bound_dev_if
;
1414 fl
.fl_ip_dport
= inet_rsk(req
)->rmt_port
;
1415 fl
.fl_ip_sport
= inet_sk(sk
)->sport
;
1416 security_req_classify_flow(req
, &fl
);
1418 if (ip6_dst_lookup(sk
, &dst
, &fl
))
1422 ipv6_addr_copy(&fl
.fl6_dst
, final_p
);
1424 if ((xfrm_lookup(&dst
, &fl
, sk
, 0)) < 0)
1428 newsk
= tcp_create_openreq_child(sk
, req
, skb
);
1433 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1434 * count here, tcp_create_openreq_child now does this for us, see the
1435 * comment in that function for the gory details. -acme
1438 newsk
->sk_gso_type
= SKB_GSO_TCPV6
;
1439 __ip6_dst_store(newsk
, dst
, NULL
, NULL
);
1441 newtcp6sk
= (struct tcp6_sock
*)newsk
;
1442 inet_sk(newsk
)->pinet6
= &newtcp6sk
->inet6
;
1444 newtp
= tcp_sk(newsk
);
1445 newinet
= inet_sk(newsk
);
1446 newnp
= inet6_sk(newsk
);
1448 memcpy(newnp
, np
, sizeof(struct ipv6_pinfo
));
1450 ipv6_addr_copy(&newnp
->daddr
, &treq
->rmt_addr
);
1451 ipv6_addr_copy(&newnp
->saddr
, &treq
->loc_addr
);
1452 ipv6_addr_copy(&newnp
->rcv_saddr
, &treq
->loc_addr
);
1453 newsk
->sk_bound_dev_if
= treq
->iif
;
1455 /* Now IPv6 options...
1457 First: no IPv4 options.
1459 newinet
->opt
= NULL
;
1460 newnp
->ipv6_fl_list
= NULL
;
1463 newnp
->rxopt
.all
= np
->rxopt
.all
;
1465 /* Clone pktoptions received with SYN */
1466 newnp
->pktoptions
= NULL
;
1467 if (treq
->pktopts
!= NULL
) {
1468 newnp
->pktoptions
= skb_clone(treq
->pktopts
, GFP_ATOMIC
);
1469 kfree_skb(treq
->pktopts
);
1470 treq
->pktopts
= NULL
;
1471 if (newnp
->pktoptions
)
1472 skb_set_owner_r(newnp
->pktoptions
, newsk
);
1475 newnp
->mcast_oif
= inet6_iif(skb
);
1476 newnp
->mcast_hops
= skb
->nh
.ipv6h
->hop_limit
;
1478 /* Clone native IPv6 options from listening socket (if any)
1480 Yes, keeping reference count would be much more clever,
1481 but we make one more one thing there: reattach optmem
1485 newnp
->opt
= ipv6_dup_options(newsk
, opt
);
1487 sock_kfree_s(sk
, opt
, opt
->tot_len
);
1490 inet_csk(newsk
)->icsk_ext_hdr_len
= 0;
1492 inet_csk(newsk
)->icsk_ext_hdr_len
= (newnp
->opt
->opt_nflen
+
1493 newnp
->opt
->opt_flen
);
1495 tcp_mtup_init(newsk
);
1496 tcp_sync_mss(newsk
, dst_mtu(dst
));
1497 newtp
->advmss
= dst_metric(dst
, RTAX_ADVMSS
);
1498 tcp_initialize_rcv_mss(newsk
);
1500 newinet
->daddr
= newinet
->saddr
= newinet
->rcv_saddr
= LOOPBACK4_IPV6
;
1502 #ifdef CONFIG_TCP_MD5SIG
1503 /* Copy over the MD5 key from the original socket */
1504 if ((key
= tcp_v6_md5_do_lookup(sk
, &newnp
->daddr
)) != NULL
) {
1505 /* We're using one, so create a matching key
1506 * on the newsk structure. If we fail to get
1507 * memory, then we end up not copying the key
1510 char *newkey
= kmemdup(key
->key
, key
->keylen
, GFP_ATOMIC
);
1512 tcp_v6_md5_do_add(newsk
, &inet6_sk(sk
)->daddr
,
1513 newkey
, key
->keylen
);
1517 __inet6_hash(&tcp_hashinfo
, newsk
);
1518 inet_inherit_port(&tcp_hashinfo
, sk
, newsk
);
1523 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS
);
1525 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS
);
1526 if (opt
&& opt
!= np
->opt
)
1527 sock_kfree_s(sk
, opt
, opt
->tot_len
);
1532 static __sum16
tcp_v6_checksum_init(struct sk_buff
*skb
)
1534 if (skb
->ip_summed
== CHECKSUM_COMPLETE
) {
1535 if (!tcp_v6_check(skb
->h
.th
,skb
->len
,&skb
->nh
.ipv6h
->saddr
,
1536 &skb
->nh
.ipv6h
->daddr
,skb
->csum
)) {
1537 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1542 skb
->csum
= ~csum_unfold(tcp_v6_check(skb
->h
.th
,skb
->len
,&skb
->nh
.ipv6h
->saddr
,
1543 &skb
->nh
.ipv6h
->daddr
, 0));
1545 if (skb
->len
<= 76) {
1546 return __skb_checksum_complete(skb
);
1551 /* The socket must have it's spinlock held when we get
1554 * We have a potential double-lock case here, so even when
1555 * doing backlog processing we use the BH locking scheme.
1556 * This is because we cannot sleep with the original spinlock
1559 static int tcp_v6_do_rcv(struct sock
*sk
, struct sk_buff
*skb
)
1561 struct ipv6_pinfo
*np
= inet6_sk(sk
);
1562 struct tcp_sock
*tp
;
1563 struct sk_buff
*opt_skb
= NULL
;
1565 /* Imagine: socket is IPv6. IPv4 packet arrives,
1566 goes to IPv4 receive handler and backlogged.
1567 From backlog it always goes here. Kerboom...
1568 Fortunately, tcp_rcv_established and rcv_established
1569 handle them correctly, but it is not case with
1570 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1573 if (skb
->protocol
== htons(ETH_P_IP
))
1574 return tcp_v4_do_rcv(sk
, skb
);
1576 #ifdef CONFIG_TCP_MD5SIG
1577 if (tcp_v6_inbound_md5_hash (sk
, skb
))
1581 if (sk_filter(sk
, skb
))
1585 * socket locking is here for SMP purposes as backlog rcv
1586 * is currently called with bh processing disabled.
1589 /* Do Stevens' IPV6_PKTOPTIONS.
1591 Yes, guys, it is the only place in our code, where we
1592 may make it not affecting IPv4.
1593 The rest of code is protocol independent,
1594 and I do not like idea to uglify IPv4.
1596 Actually, all the idea behind IPV6_PKTOPTIONS
1597 looks not very well thought. For now we latch
1598 options, received in the last packet, enqueued
1599 by tcp. Feel free to propose better solution.
1603 opt_skb
= skb_clone(skb
, GFP_ATOMIC
);
1605 if (sk
->sk_state
== TCP_ESTABLISHED
) { /* Fast path */
1606 TCP_CHECK_TIMER(sk
);
1607 if (tcp_rcv_established(sk
, skb
, skb
->h
.th
, skb
->len
))
1609 TCP_CHECK_TIMER(sk
);
1611 goto ipv6_pktoptions
;
1615 if (skb
->len
< (skb
->h
.th
->doff
<<2) || tcp_checksum_complete(skb
))
1618 if (sk
->sk_state
== TCP_LISTEN
) {
1619 struct sock
*nsk
= tcp_v6_hnd_req(sk
, skb
);
1624 * Queue it on the new socket if the new socket is active,
1625 * otherwise we just shortcircuit this and continue with
1629 if (tcp_child_process(sk
, nsk
, skb
))
1632 __kfree_skb(opt_skb
);
1637 TCP_CHECK_TIMER(sk
);
1638 if (tcp_rcv_state_process(sk
, skb
, skb
->h
.th
, skb
->len
))
1640 TCP_CHECK_TIMER(sk
);
1642 goto ipv6_pktoptions
;
1646 tcp_v6_send_reset(sk
, skb
);
1649 __kfree_skb(opt_skb
);
1653 TCP_INC_STATS_BH(TCP_MIB_INERRS
);
1658 /* Do you ask, what is it?
1660 1. skb was enqueued by tcp.
1661 2. skb is added to tail of read queue, rather than out of order.
1662 3. socket is not in passive state.
1663 4. Finally, it really contains options, which user wants to receive.
1666 if (TCP_SKB_CB(opt_skb
)->end_seq
== tp
->rcv_nxt
&&
1667 !((1 << sk
->sk_state
) & (TCPF_CLOSE
| TCPF_LISTEN
))) {
1668 if (np
->rxopt
.bits
.rxinfo
|| np
->rxopt
.bits
.rxoinfo
)
1669 np
->mcast_oif
= inet6_iif(opt_skb
);
1670 if (np
->rxopt
.bits
.rxhlim
|| np
->rxopt
.bits
.rxohlim
)
1671 np
->mcast_hops
= opt_skb
->nh
.ipv6h
->hop_limit
;
1672 if (ipv6_opt_accepted(sk
, opt_skb
)) {
1673 skb_set_owner_r(opt_skb
, sk
);
1674 opt_skb
= xchg(&np
->pktoptions
, opt_skb
);
1676 __kfree_skb(opt_skb
);
1677 opt_skb
= xchg(&np
->pktoptions
, NULL
);
1686 static int tcp_v6_rcv(struct sk_buff
**pskb
)
1688 struct sk_buff
*skb
= *pskb
;
1693 if (skb
->pkt_type
!= PACKET_HOST
)
1697 * Count it even if it's bad.
1699 TCP_INC_STATS_BH(TCP_MIB_INSEGS
);
1701 if (!pskb_may_pull(skb
, sizeof(struct tcphdr
)))
1706 if (th
->doff
< sizeof(struct tcphdr
)/4)
1708 if (!pskb_may_pull(skb
, th
->doff
*4))
1711 if ((skb
->ip_summed
!= CHECKSUM_UNNECESSARY
&&
1712 tcp_v6_checksum_init(skb
)))
1716 TCP_SKB_CB(skb
)->seq
= ntohl(th
->seq
);
1717 TCP_SKB_CB(skb
)->end_seq
= (TCP_SKB_CB(skb
)->seq
+ th
->syn
+ th
->fin
+
1718 skb
->len
- th
->doff
*4);
1719 TCP_SKB_CB(skb
)->ack_seq
= ntohl(th
->ack_seq
);
1720 TCP_SKB_CB(skb
)->when
= 0;
1721 TCP_SKB_CB(skb
)->flags
= ipv6_get_dsfield(skb
->nh
.ipv6h
);
1722 TCP_SKB_CB(skb
)->sacked
= 0;
1724 sk
= __inet6_lookup(&tcp_hashinfo
, &skb
->nh
.ipv6h
->saddr
, th
->source
,
1725 &skb
->nh
.ipv6h
->daddr
, ntohs(th
->dest
),
1732 if (sk
->sk_state
== TCP_TIME_WAIT
)
1735 if (!xfrm6_policy_check(sk
, XFRM_POLICY_IN
, skb
))
1736 goto discard_and_relse
;
1738 if (sk_filter(sk
, skb
))
1739 goto discard_and_relse
;
1743 bh_lock_sock_nested(sk
);
1745 if (!sock_owned_by_user(sk
)) {
1746 #ifdef CONFIG_NET_DMA
1747 struct tcp_sock
*tp
= tcp_sk(sk
);
1748 if (tp
->ucopy
.dma_chan
)
1749 ret
= tcp_v6_do_rcv(sk
, skb
);
1753 if (!tcp_prequeue(sk
, skb
))
1754 ret
= tcp_v6_do_rcv(sk
, skb
);
1757 sk_add_backlog(sk
, skb
);
1761 return ret
? -1 : 0;
1764 if (!xfrm6_policy_check(NULL
, XFRM_POLICY_IN
, skb
))
1767 if (skb
->len
< (th
->doff
<<2) || tcp_checksum_complete(skb
)) {
1769 TCP_INC_STATS_BH(TCP_MIB_INERRS
);
1771 tcp_v6_send_reset(NULL
, skb
);
1788 if (!xfrm6_policy_check(NULL
, XFRM_POLICY_IN
, skb
)) {
1789 inet_twsk_put(inet_twsk(sk
));
1793 if (skb
->len
< (th
->doff
<<2) || tcp_checksum_complete(skb
)) {
1794 TCP_INC_STATS_BH(TCP_MIB_INERRS
);
1795 inet_twsk_put(inet_twsk(sk
));
1799 switch (tcp_timewait_state_process(inet_twsk(sk
), skb
, th
)) {
1804 sk2
= inet6_lookup_listener(&tcp_hashinfo
,
1805 &skb
->nh
.ipv6h
->daddr
,
1806 ntohs(th
->dest
), inet6_iif(skb
));
1808 struct inet_timewait_sock
*tw
= inet_twsk(sk
);
1809 inet_twsk_deschedule(tw
, &tcp_death_row
);
1814 /* Fall through to ACK */
1817 tcp_v6_timewait_ack(sk
, skb
);
1821 case TCP_TW_SUCCESS
:;
1826 static int tcp_v6_remember_stamp(struct sock
*sk
)
1828 /* Alas, not yet... */
1832 static struct inet_connection_sock_af_ops ipv6_specific
= {
1833 .queue_xmit
= inet6_csk_xmit
,
1834 .send_check
= tcp_v6_send_check
,
1835 .rebuild_header
= inet6_sk_rebuild_header
,
1836 .conn_request
= tcp_v6_conn_request
,
1837 .syn_recv_sock
= tcp_v6_syn_recv_sock
,
1838 .remember_stamp
= tcp_v6_remember_stamp
,
1839 .net_header_len
= sizeof(struct ipv6hdr
),
1840 .setsockopt
= ipv6_setsockopt
,
1841 .getsockopt
= ipv6_getsockopt
,
1842 .addr2sockaddr
= inet6_csk_addr2sockaddr
,
1843 .sockaddr_len
= sizeof(struct sockaddr_in6
),
1844 #ifdef CONFIG_COMPAT
1845 .compat_setsockopt
= compat_ipv6_setsockopt
,
1846 .compat_getsockopt
= compat_ipv6_getsockopt
,
1850 #ifdef CONFIG_TCP_MD5SIG
1851 static struct tcp_sock_af_ops tcp_sock_ipv6_specific
= {
1852 .md5_lookup
= tcp_v6_md5_lookup
,
1853 .calc_md5_hash
= tcp_v6_calc_md5_hash
,
1854 .md5_add
= tcp_v6_md5_add_func
,
1855 .md5_parse
= tcp_v6_parse_md5_keys
,
1860 * TCP over IPv4 via INET6 API
1863 static struct inet_connection_sock_af_ops ipv6_mapped
= {
1864 .queue_xmit
= ip_queue_xmit
,
1865 .send_check
= tcp_v4_send_check
,
1866 .rebuild_header
= inet_sk_rebuild_header
,
1867 .conn_request
= tcp_v6_conn_request
,
1868 .syn_recv_sock
= tcp_v6_syn_recv_sock
,
1869 .remember_stamp
= tcp_v4_remember_stamp
,
1870 .net_header_len
= sizeof(struct iphdr
),
1871 .setsockopt
= ipv6_setsockopt
,
1872 .getsockopt
= ipv6_getsockopt
,
1873 .addr2sockaddr
= inet6_csk_addr2sockaddr
,
1874 .sockaddr_len
= sizeof(struct sockaddr_in6
),
1875 #ifdef CONFIG_COMPAT
1876 .compat_setsockopt
= compat_ipv6_setsockopt
,
1877 .compat_getsockopt
= compat_ipv6_getsockopt
,
1881 #ifdef CONFIG_TCP_MD5SIG
1882 static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific
= {
1883 .md5_lookup
= tcp_v4_md5_lookup
,
1884 .calc_md5_hash
= tcp_v4_calc_md5_hash
,
1885 .md5_add
= tcp_v6_md5_add_func
,
1886 .md5_parse
= tcp_v6_parse_md5_keys
,
1890 /* NOTE: A lot of things set to zero explicitly by call to
1891 * sk_alloc() so need not be done here.
1893 static int tcp_v6_init_sock(struct sock
*sk
)
1895 struct inet_connection_sock
*icsk
= inet_csk(sk
);
1896 struct tcp_sock
*tp
= tcp_sk(sk
);
1898 skb_queue_head_init(&tp
->out_of_order_queue
);
1899 tcp_init_xmit_timers(sk
);
1900 tcp_prequeue_init(tp
);
1902 icsk
->icsk_rto
= TCP_TIMEOUT_INIT
;
1903 tp
->mdev
= TCP_TIMEOUT_INIT
;
1905 /* So many TCP implementations out there (incorrectly) count the
1906 * initial SYN frame in their delayed-ACK and congestion control
1907 * algorithms that we must have the following bandaid to talk
1908 * efficiently to them. -DaveM
1912 /* See draft-stevens-tcpca-spec-01 for discussion of the
1913 * initialization of these values.
1915 tp
->snd_ssthresh
= 0x7fffffff;
1916 tp
->snd_cwnd_clamp
= ~0;
1917 tp
->mss_cache
= 536;
1919 tp
->reordering
= sysctl_tcp_reordering
;
1921 sk
->sk_state
= TCP_CLOSE
;
1923 icsk
->icsk_af_ops
= &ipv6_specific
;
1924 icsk
->icsk_ca_ops
= &tcp_init_congestion_ops
;
1925 icsk
->icsk_sync_mss
= tcp_sync_mss
;
1926 sk
->sk_write_space
= sk_stream_write_space
;
1927 sock_set_flag(sk
, SOCK_USE_WRITE_QUEUE
);
1929 #ifdef CONFIG_TCP_MD5SIG
1930 tp
->af_specific
= &tcp_sock_ipv6_specific
;
1933 sk
->sk_sndbuf
= sysctl_tcp_wmem
[1];
1934 sk
->sk_rcvbuf
= sysctl_tcp_rmem
[1];
1936 atomic_inc(&tcp_sockets_allocated
);
1941 static int tcp_v6_destroy_sock(struct sock
*sk
)
1943 #ifdef CONFIG_TCP_MD5SIG
1944 /* Clean up the MD5 key list */
1945 if (tcp_sk(sk
)->md5sig_info
)
1946 tcp_v6_clear_md5_list(sk
);
1948 tcp_v4_destroy_sock(sk
);
1949 return inet6_destroy_sock(sk
);
1952 /* Proc filesystem TCPv6 sock list dumping. */
1953 static void get_openreq6(struct seq_file
*seq
,
1954 struct sock
*sk
, struct request_sock
*req
, int i
, int uid
)
1956 int ttd
= req
->expires
- jiffies
;
1957 struct in6_addr
*src
= &inet6_rsk(req
)->loc_addr
;
1958 struct in6_addr
*dest
= &inet6_rsk(req
)->rmt_addr
;
1964 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1965 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1967 src
->s6_addr32
[0], src
->s6_addr32
[1],
1968 src
->s6_addr32
[2], src
->s6_addr32
[3],
1969 ntohs(inet_sk(sk
)->sport
),
1970 dest
->s6_addr32
[0], dest
->s6_addr32
[1],
1971 dest
->s6_addr32
[2], dest
->s6_addr32
[3],
1972 ntohs(inet_rsk(req
)->rmt_port
),
1974 0,0, /* could print option size, but that is af dependent. */
1975 1, /* timers active (only the expire timer) */
1976 jiffies_to_clock_t(ttd
),
1979 0, /* non standard timer */
1980 0, /* open_requests have no inode */
1984 static void get_tcp6_sock(struct seq_file
*seq
, struct sock
*sp
, int i
)
1986 struct in6_addr
*dest
, *src
;
1989 unsigned long timer_expires
;
1990 struct inet_sock
*inet
= inet_sk(sp
);
1991 struct tcp_sock
*tp
= tcp_sk(sp
);
1992 const struct inet_connection_sock
*icsk
= inet_csk(sp
);
1993 struct ipv6_pinfo
*np
= inet6_sk(sp
);
1996 src
= &np
->rcv_saddr
;
1997 destp
= ntohs(inet
->dport
);
1998 srcp
= ntohs(inet
->sport
);
2000 if (icsk
->icsk_pending
== ICSK_TIME_RETRANS
) {
2002 timer_expires
= icsk
->icsk_timeout
;
2003 } else if (icsk
->icsk_pending
== ICSK_TIME_PROBE0
) {
2005 timer_expires
= icsk
->icsk_timeout
;
2006 } else if (timer_pending(&sp
->sk_timer
)) {
2008 timer_expires
= sp
->sk_timer
.expires
;
2011 timer_expires
= jiffies
;
2015 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2016 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %u %u %u %u %d\n",
2018 src
->s6_addr32
[0], src
->s6_addr32
[1],
2019 src
->s6_addr32
[2], src
->s6_addr32
[3], srcp
,
2020 dest
->s6_addr32
[0], dest
->s6_addr32
[1],
2021 dest
->s6_addr32
[2], dest
->s6_addr32
[3], destp
,
2023 tp
->write_seq
-tp
->snd_una
,
2024 (sp
->sk_state
== TCP_LISTEN
) ? sp
->sk_ack_backlog
: (tp
->rcv_nxt
- tp
->copied_seq
),
2026 jiffies_to_clock_t(timer_expires
- jiffies
),
2027 icsk
->icsk_retransmits
,
2029 icsk
->icsk_probes_out
,
2031 atomic_read(&sp
->sk_refcnt
), sp
,
2034 (icsk
->icsk_ack
.quick
<< 1 ) | icsk
->icsk_ack
.pingpong
,
2035 tp
->snd_cwnd
, tp
->snd_ssthresh
>=0xFFFF?-1:tp
->snd_ssthresh
2039 static void get_timewait6_sock(struct seq_file
*seq
,
2040 struct inet_timewait_sock
*tw
, int i
)
2042 struct in6_addr
*dest
, *src
;
2044 struct inet6_timewait_sock
*tw6
= inet6_twsk((struct sock
*)tw
);
2045 int ttd
= tw
->tw_ttd
- jiffies
;
2050 dest
= &tw6
->tw_v6_daddr
;
2051 src
= &tw6
->tw_v6_rcv_saddr
;
2052 destp
= ntohs(tw
->tw_dport
);
2053 srcp
= ntohs(tw
->tw_sport
);
2056 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2057 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2059 src
->s6_addr32
[0], src
->s6_addr32
[1],
2060 src
->s6_addr32
[2], src
->s6_addr32
[3], srcp
,
2061 dest
->s6_addr32
[0], dest
->s6_addr32
[1],
2062 dest
->s6_addr32
[2], dest
->s6_addr32
[3], destp
,
2063 tw
->tw_substate
, 0, 0,
2064 3, jiffies_to_clock_t(ttd
), 0, 0, 0, 0,
2065 atomic_read(&tw
->tw_refcnt
), tw
);
2068 #ifdef CONFIG_PROC_FS
2069 static int tcp6_seq_show(struct seq_file
*seq
, void *v
)
2071 struct tcp_iter_state
*st
;
2073 if (v
== SEQ_START_TOKEN
) {
2078 "st tx_queue rx_queue tr tm->when retrnsmt"
2079 " uid timeout inode\n");
2084 switch (st
->state
) {
2085 case TCP_SEQ_STATE_LISTENING
:
2086 case TCP_SEQ_STATE_ESTABLISHED
:
2087 get_tcp6_sock(seq
, v
, st
->num
);
2089 case TCP_SEQ_STATE_OPENREQ
:
2090 get_openreq6(seq
, st
->syn_wait_sk
, v
, st
->num
, st
->uid
);
2092 case TCP_SEQ_STATE_TIME_WAIT
:
2093 get_timewait6_sock(seq
, v
, st
->num
);
2100 static struct file_operations tcp6_seq_fops
;
2101 static struct tcp_seq_afinfo tcp6_seq_afinfo
= {
2102 .owner
= THIS_MODULE
,
2105 .seq_show
= tcp6_seq_show
,
2106 .seq_fops
= &tcp6_seq_fops
,
2109 int __init
tcp6_proc_init(void)
2111 return tcp_proc_register(&tcp6_seq_afinfo
);
2114 void tcp6_proc_exit(void)
2116 tcp_proc_unregister(&tcp6_seq_afinfo
);
2120 struct proto tcpv6_prot
= {
2122 .owner
= THIS_MODULE
,
2124 .connect
= tcp_v6_connect
,
2125 .disconnect
= tcp_disconnect
,
2126 .accept
= inet_csk_accept
,
2128 .init
= tcp_v6_init_sock
,
2129 .destroy
= tcp_v6_destroy_sock
,
2130 .shutdown
= tcp_shutdown
,
2131 .setsockopt
= tcp_setsockopt
,
2132 .getsockopt
= tcp_getsockopt
,
2133 .sendmsg
= tcp_sendmsg
,
2134 .recvmsg
= tcp_recvmsg
,
2135 .backlog_rcv
= tcp_v6_do_rcv
,
2136 .hash
= tcp_v6_hash
,
2137 .unhash
= tcp_unhash
,
2138 .get_port
= tcp_v6_get_port
,
2139 .enter_memory_pressure
= tcp_enter_memory_pressure
,
2140 .sockets_allocated
= &tcp_sockets_allocated
,
2141 .memory_allocated
= &tcp_memory_allocated
,
2142 .memory_pressure
= &tcp_memory_pressure
,
2143 .orphan_count
= &tcp_orphan_count
,
2144 .sysctl_mem
= sysctl_tcp_mem
,
2145 .sysctl_wmem
= sysctl_tcp_wmem
,
2146 .sysctl_rmem
= sysctl_tcp_rmem
,
2147 .max_header
= MAX_TCP_HEADER
,
2148 .obj_size
= sizeof(struct tcp6_sock
),
2149 .twsk_prot
= &tcp6_timewait_sock_ops
,
2150 .rsk_prot
= &tcp6_request_sock_ops
,
2151 #ifdef CONFIG_COMPAT
2152 .compat_setsockopt
= compat_tcp_setsockopt
,
2153 .compat_getsockopt
= compat_tcp_getsockopt
,
2157 static struct inet6_protocol tcpv6_protocol
= {
2158 .handler
= tcp_v6_rcv
,
2159 .err_handler
= tcp_v6_err
,
2160 .gso_send_check
= tcp_v6_gso_send_check
,
2161 .gso_segment
= tcp_tso_segment
,
2162 .flags
= INET6_PROTO_NOPOLICY
|INET6_PROTO_FINAL
,
2165 static struct inet_protosw tcpv6_protosw
= {
2166 .type
= SOCK_STREAM
,
2167 .protocol
= IPPROTO_TCP
,
2168 .prot
= &tcpv6_prot
,
2169 .ops
= &inet6_stream_ops
,
2172 .flags
= INET_PROTOSW_PERMANENT
|
2176 void __init
tcpv6_init(void)
2178 /* register inet6 protocol */
2179 if (inet6_add_protocol(&tcpv6_protocol
, IPPROTO_TCP
) < 0)
2180 printk(KERN_ERR
"tcpv6_init: Could not register protocol\n");
2181 inet6_register_protosw(&tcpv6_protosw
);
2183 if (inet_csk_ctl_sock_create(&tcp6_socket
, PF_INET6
, SOCK_RAW
,
2185 panic("Failed to create the TCPv6 control socket.\n");