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>
60 #include <net/dsfield.h>
61 #include <net/timewait_sock.h>
62 #include <net/netdma.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 void tcp_v6_hash(struct sock *sk)
91 if (sk->sk_state != TCP_CLOSE) {
92 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
102 static __inline__ __sum16 tcp_v6_check(struct tcphdr *th, int len,
103 struct in6_addr *saddr,
104 struct in6_addr *daddr,
107 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
110 static __u32 tcp_v6_init_sequence(struct sk_buff *skb)
112 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
113 ipv6_hdr(skb)->saddr.s6_addr32,
115 tcp_hdr(skb)->source);
118 static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
121 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
122 struct inet_sock *inet = inet_sk(sk);
123 struct inet_connection_sock *icsk = inet_csk(sk);
124 struct ipv6_pinfo *np = inet6_sk(sk);
125 struct tcp_sock *tp = tcp_sk(sk);
126 struct in6_addr *saddr = NULL, *final_p = NULL, final;
128 struct dst_entry *dst;
132 if (addr_len < SIN6_LEN_RFC2133)
135 if (usin->sin6_family != AF_INET6)
136 return(-EAFNOSUPPORT);
138 memset(&fl, 0, sizeof(fl));
141 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
142 IP6_ECN_flow_init(fl.fl6_flowlabel);
143 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
144 struct ip6_flowlabel *flowlabel;
145 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
146 if (flowlabel == NULL)
148 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
149 fl6_sock_release(flowlabel);
154 * connect() to INADDR_ANY means loopback (BSD'ism).
157 if(ipv6_addr_any(&usin->sin6_addr))
158 usin->sin6_addr.s6_addr[15] = 0x1;
160 addr_type = ipv6_addr_type(&usin->sin6_addr);
162 if(addr_type & IPV6_ADDR_MULTICAST)
165 if (addr_type&IPV6_ADDR_LINKLOCAL) {
166 if (addr_len >= sizeof(struct sockaddr_in6) &&
167 usin->sin6_scope_id) {
168 /* If interface is set while binding, indices
171 if (sk->sk_bound_dev_if &&
172 sk->sk_bound_dev_if != usin->sin6_scope_id)
175 sk->sk_bound_dev_if = usin->sin6_scope_id;
178 /* Connect to link-local address requires an interface */
179 if (!sk->sk_bound_dev_if)
183 if (tp->rx_opt.ts_recent_stamp &&
184 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
185 tp->rx_opt.ts_recent = 0;
186 tp->rx_opt.ts_recent_stamp = 0;
190 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
191 np->flow_label = fl.fl6_flowlabel;
197 if (addr_type == IPV6_ADDR_MAPPED) {
198 u32 exthdrlen = icsk->icsk_ext_hdr_len;
199 struct sockaddr_in sin;
201 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
203 if (__ipv6_only_sock(sk))
206 sin.sin_family = AF_INET;
207 sin.sin_port = usin->sin6_port;
208 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
210 icsk->icsk_af_ops = &ipv6_mapped;
211 sk->sk_backlog_rcv = tcp_v4_do_rcv;
212 #ifdef CONFIG_TCP_MD5SIG
213 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
216 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
219 icsk->icsk_ext_hdr_len = exthdrlen;
220 icsk->icsk_af_ops = &ipv6_specific;
221 sk->sk_backlog_rcv = tcp_v6_do_rcv;
222 #ifdef CONFIG_TCP_MD5SIG
223 tp->af_specific = &tcp_sock_ipv6_specific;
227 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
229 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
236 if (!ipv6_addr_any(&np->rcv_saddr))
237 saddr = &np->rcv_saddr;
239 fl.proto = IPPROTO_TCP;
240 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
241 ipv6_addr_copy(&fl.fl6_src,
242 (saddr ? saddr : &np->saddr));
243 fl.oif = sk->sk_bound_dev_if;
244 fl.fl_ip_dport = usin->sin6_port;
245 fl.fl_ip_sport = inet->sport;
247 if (np->opt && np->opt->srcrt) {
248 struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
249 ipv6_addr_copy(&final, &fl.fl6_dst);
250 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
254 security_sk_classify_flow(sk, &fl);
256 err = ip6_dst_lookup(sk, &dst, &fl);
260 ipv6_addr_copy(&fl.fl6_dst, final_p);
262 if ((err = __xfrm_lookup(&dst, &fl, sk, XFRM_LOOKUP_WAIT)) < 0) {
264 err = ip6_dst_blackhole(sk, &dst, &fl);
271 ipv6_addr_copy(&np->rcv_saddr, saddr);
274 /* set the source address */
275 ipv6_addr_copy(&np->saddr, saddr);
276 inet->rcv_saddr = LOOPBACK4_IPV6;
278 sk->sk_gso_type = SKB_GSO_TCPV6;
279 __ip6_dst_store(sk, dst, NULL, NULL);
281 icsk->icsk_ext_hdr_len = 0;
283 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
286 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
288 inet->dport = usin->sin6_port;
290 tcp_set_state(sk, TCP_SYN_SENT);
291 err = inet6_hash_connect(&tcp_death_row, sk);
296 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
301 err = tcp_connect(sk);
308 tcp_set_state(sk, TCP_CLOSE);
312 sk->sk_route_caps = 0;
316 static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
317 int type, int code, int offset, __be32 info)
319 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
320 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
321 struct ipv6_pinfo *np;
327 sk = inet6_lookup(skb->dev->nd_net, &tcp_hashinfo, &hdr->daddr,
328 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
331 ICMP6_INC_STATS_BH(__in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
335 if (sk->sk_state == TCP_TIME_WAIT) {
336 inet_twsk_put(inet_twsk(sk));
341 if (sock_owned_by_user(sk))
342 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
344 if (sk->sk_state == TCP_CLOSE)
348 seq = ntohl(th->seq);
349 if (sk->sk_state != TCP_LISTEN &&
350 !between(seq, tp->snd_una, tp->snd_nxt)) {
351 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
357 if (type == ICMPV6_PKT_TOOBIG) {
358 struct dst_entry *dst = NULL;
360 if (sock_owned_by_user(sk))
362 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
365 /* icmp should have updated the destination cache entry */
366 dst = __sk_dst_check(sk, np->dst_cookie);
369 struct inet_sock *inet = inet_sk(sk);
372 /* BUGGG_FUTURE: Again, it is not clear how
373 to handle rthdr case. Ignore this complexity
376 memset(&fl, 0, sizeof(fl));
377 fl.proto = IPPROTO_TCP;
378 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
379 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
380 fl.oif = sk->sk_bound_dev_if;
381 fl.fl_ip_dport = inet->dport;
382 fl.fl_ip_sport = inet->sport;
383 security_skb_classify_flow(skb, &fl);
385 if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
386 sk->sk_err_soft = -err;
390 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
391 sk->sk_err_soft = -err;
398 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
399 tcp_sync_mss(sk, dst_mtu(dst));
400 tcp_simple_retransmit(sk);
401 } /* else let the usual retransmit timer handle it */
406 icmpv6_err_convert(type, code, &err);
408 /* Might be for an request_sock */
409 switch (sk->sk_state) {
410 struct request_sock *req, **prev;
412 if (sock_owned_by_user(sk))
415 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
416 &hdr->saddr, inet6_iif(skb));
420 /* ICMPs are not backlogged, hence we cannot get
421 * an established socket here.
423 BUG_TRAP(req->sk == NULL);
425 if (seq != tcp_rsk(req)->snt_isn) {
426 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
430 inet_csk_reqsk_queue_drop(sk, req, prev);
434 case TCP_SYN_RECV: /* Cannot happen.
435 It can, it SYNs are crossed. --ANK */
436 if (!sock_owned_by_user(sk)) {
438 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
442 sk->sk_err_soft = err;
446 if (!sock_owned_by_user(sk) && np->recverr) {
448 sk->sk_error_report(sk);
450 sk->sk_err_soft = err;
458 static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req)
460 struct inet6_request_sock *treq = inet6_rsk(req);
461 struct ipv6_pinfo *np = inet6_sk(sk);
462 struct sk_buff * skb;
463 struct ipv6_txoptions *opt = NULL;
464 struct in6_addr * final_p = NULL, final;
466 struct dst_entry *dst;
469 memset(&fl, 0, sizeof(fl));
470 fl.proto = IPPROTO_TCP;
471 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
472 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
473 fl.fl6_flowlabel = 0;
475 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
476 fl.fl_ip_sport = inet_sk(sk)->sport;
477 security_req_classify_flow(req, &fl);
480 if (opt && opt->srcrt) {
481 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
482 ipv6_addr_copy(&final, &fl.fl6_dst);
483 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
487 err = ip6_dst_lookup(sk, &dst, &fl);
491 ipv6_addr_copy(&fl.fl6_dst, final_p);
492 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
495 skb = tcp_make_synack(sk, dst, req);
497 struct tcphdr *th = tcp_hdr(skb);
499 th->check = tcp_v6_check(th, skb->len,
500 &treq->loc_addr, &treq->rmt_addr,
501 csum_partial((char *)th, skb->len, skb->csum));
503 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
504 err = ip6_xmit(sk, skb, &fl, opt, 0);
505 err = net_xmit_eval(err);
509 if (opt && opt != np->opt)
510 sock_kfree_s(sk, opt, opt->tot_len);
515 static inline void syn_flood_warning(struct sk_buff *skb)
517 #ifdef CONFIG_SYN_COOKIES
518 if (sysctl_tcp_syncookies)
520 "TCPv6: Possible SYN flooding on port %d. "
521 "Sending cookies.\n", ntohs(tcp_hdr(skb)->dest));
525 "TCPv6: Possible SYN flooding on port %d. "
526 "Dropping request.\n", ntohs(tcp_hdr(skb)->dest));
529 static void tcp_v6_reqsk_destructor(struct request_sock *req)
531 if (inet6_rsk(req)->pktopts)
532 kfree_skb(inet6_rsk(req)->pktopts);
535 #ifdef CONFIG_TCP_MD5SIG
536 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
537 struct in6_addr *addr)
539 struct tcp_sock *tp = tcp_sk(sk);
544 if (!tp->md5sig_info || !tp->md5sig_info->entries6)
547 for (i = 0; i < tp->md5sig_info->entries6; i++) {
548 if (ipv6_addr_cmp(&tp->md5sig_info->keys6[i].addr, addr) == 0)
549 return &tp->md5sig_info->keys6[i].base;
554 static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
555 struct sock *addr_sk)
557 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
560 static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
561 struct request_sock *req)
563 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
566 static int tcp_v6_md5_do_add(struct sock *sk, struct in6_addr *peer,
567 char *newkey, u8 newkeylen)
569 /* Add key to the list */
570 struct tcp_md5sig_key *key;
571 struct tcp_sock *tp = tcp_sk(sk);
572 struct tcp6_md5sig_key *keys;
574 key = tcp_v6_md5_do_lookup(sk, peer);
576 /* modify existing entry - just update that one */
579 key->keylen = newkeylen;
581 /* reallocate new list if current one is full. */
582 if (!tp->md5sig_info) {
583 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
584 if (!tp->md5sig_info) {
588 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
590 if (tcp_alloc_md5sig_pool() == NULL) {
594 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
595 keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
596 (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
599 tcp_free_md5sig_pool();
604 if (tp->md5sig_info->entries6)
605 memmove(keys, tp->md5sig_info->keys6,
606 (sizeof (tp->md5sig_info->keys6[0]) *
607 tp->md5sig_info->entries6));
609 kfree(tp->md5sig_info->keys6);
610 tp->md5sig_info->keys6 = keys;
611 tp->md5sig_info->alloced6++;
614 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
616 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.key = newkey;
617 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.keylen = newkeylen;
619 tp->md5sig_info->entries6++;
624 static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
625 u8 *newkey, __u8 newkeylen)
627 return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
631 static int tcp_v6_md5_do_del(struct sock *sk, struct in6_addr *peer)
633 struct tcp_sock *tp = tcp_sk(sk);
636 for (i = 0; i < tp->md5sig_info->entries6; i++) {
637 if (ipv6_addr_cmp(&tp->md5sig_info->keys6[i].addr, peer) == 0) {
639 kfree(tp->md5sig_info->keys6[i].base.key);
640 tp->md5sig_info->entries6--;
642 if (tp->md5sig_info->entries6 == 0) {
643 kfree(tp->md5sig_info->keys6);
644 tp->md5sig_info->keys6 = NULL;
645 tp->md5sig_info->alloced6 = 0;
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]));
654 tcp_free_md5sig_pool();
661 static void tcp_v6_clear_md5_list (struct sock *sk)
663 struct tcp_sock *tp = tcp_sk(sk);
666 if (tp->md5sig_info->entries6) {
667 for (i = 0; i < tp->md5sig_info->entries6; i++)
668 kfree(tp->md5sig_info->keys6[i].base.key);
669 tp->md5sig_info->entries6 = 0;
670 tcp_free_md5sig_pool();
673 kfree(tp->md5sig_info->keys6);
674 tp->md5sig_info->keys6 = NULL;
675 tp->md5sig_info->alloced6 = 0;
677 if (tp->md5sig_info->entries4) {
678 for (i = 0; i < tp->md5sig_info->entries4; i++)
679 kfree(tp->md5sig_info->keys4[i].base.key);
680 tp->md5sig_info->entries4 = 0;
681 tcp_free_md5sig_pool();
684 kfree(tp->md5sig_info->keys4);
685 tp->md5sig_info->keys4 = NULL;
686 tp->md5sig_info->alloced4 = 0;
689 static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
692 struct tcp_md5sig cmd;
693 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
696 if (optlen < sizeof(cmd))
699 if (copy_from_user(&cmd, optval, sizeof(cmd)))
702 if (sin6->sin6_family != AF_INET6)
705 if (!cmd.tcpm_keylen) {
706 if (!tcp_sk(sk)->md5sig_info)
708 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
709 return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
710 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
713 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
716 if (!tcp_sk(sk)->md5sig_info) {
717 struct tcp_sock *tp = tcp_sk(sk);
718 struct tcp_md5sig_info *p;
720 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
725 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
728 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
731 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) {
732 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
733 newkey, cmd.tcpm_keylen);
735 return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
738 static int tcp_v6_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
739 struct in6_addr *saddr,
740 struct in6_addr *daddr,
741 struct tcphdr *th, int protocol,
744 struct scatterlist sg[4];
748 struct tcp_md5sig_pool *hp;
749 struct tcp6_pseudohdr *bp;
750 struct hash_desc *desc;
752 unsigned int nbytes = 0;
754 hp = tcp_get_md5sig_pool();
756 printk(KERN_WARNING "%s(): hash pool not found...\n", __FUNCTION__);
757 goto clear_hash_noput;
759 bp = &hp->md5_blk.ip6;
760 desc = &hp->md5_desc;
762 /* 1. TCP pseudo-header (RFC2460) */
763 ipv6_addr_copy(&bp->saddr, saddr);
764 ipv6_addr_copy(&bp->daddr, daddr);
765 bp->len = htonl(tcplen);
766 bp->protocol = htonl(protocol);
768 sg_init_table(sg, 4);
770 sg_set_buf(&sg[block++], bp, sizeof(*bp));
771 nbytes += sizeof(*bp);
773 /* 2. TCP header, excluding options */
776 sg_set_buf(&sg[block++], th, sizeof(*th));
777 nbytes += sizeof(*th);
779 /* 3. TCP segment data (if any) */
780 data_len = tcplen - (th->doff << 2);
782 u8 *data = (u8 *)th + (th->doff << 2);
783 sg_set_buf(&sg[block++], data, data_len);
788 sg_set_buf(&sg[block++], key->key, key->keylen);
789 nbytes += key->keylen;
791 sg_mark_end(&sg[block - 1]);
793 /* Now store the hash into the packet */
794 err = crypto_hash_init(desc);
796 printk(KERN_WARNING "%s(): hash_init failed\n", __FUNCTION__);
799 err = crypto_hash_update(desc, sg, nbytes);
801 printk(KERN_WARNING "%s(): hash_update failed\n", __FUNCTION__);
804 err = crypto_hash_final(desc, md5_hash);
806 printk(KERN_WARNING "%s(): hash_final failed\n", __FUNCTION__);
810 /* Reset header, and free up the crypto */
811 tcp_put_md5sig_pool();
816 tcp_put_md5sig_pool();
818 memset(md5_hash, 0, 16);
822 static int tcp_v6_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
824 struct dst_entry *dst,
825 struct request_sock *req,
826 struct tcphdr *th, int protocol,
829 struct in6_addr *saddr, *daddr;
832 saddr = &inet6_sk(sk)->saddr;
833 daddr = &inet6_sk(sk)->daddr;
835 saddr = &inet6_rsk(req)->loc_addr;
836 daddr = &inet6_rsk(req)->rmt_addr;
838 return tcp_v6_do_calc_md5_hash(md5_hash, key,
840 th, protocol, tcplen);
843 static int tcp_v6_inbound_md5_hash (struct sock *sk, struct sk_buff *skb)
845 __u8 *hash_location = NULL;
846 struct tcp_md5sig_key *hash_expected;
847 struct ipv6hdr *ip6h = ipv6_hdr(skb);
848 struct tcphdr *th = tcp_hdr(skb);
849 int length = (th->doff << 2) - sizeof (*th);
854 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
856 /* If the TCP option is too short, we can short cut */
857 if (length < TCPOLEN_MD5SIG)
858 return hash_expected ? 1 : 0;
874 if (opsize < 2 || opsize > length)
876 if (opcode == TCPOPT_MD5SIG) {
886 /* do we have a hash as expected? */
887 if (!hash_expected) {
890 if (net_ratelimit()) {
891 printk(KERN_INFO "MD5 Hash NOT expected but found "
892 "(" NIP6_FMT ", %u)->"
893 "(" NIP6_FMT ", %u)\n",
894 NIP6(ip6h->saddr), ntohs(th->source),
895 NIP6(ip6h->daddr), ntohs(th->dest));
900 if (!hash_location) {
901 if (net_ratelimit()) {
902 printk(KERN_INFO "MD5 Hash expected but NOT found "
903 "(" NIP6_FMT ", %u)->"
904 "(" NIP6_FMT ", %u)\n",
905 NIP6(ip6h->saddr), ntohs(th->source),
906 NIP6(ip6h->daddr), ntohs(th->dest));
911 /* check the signature */
912 genhash = tcp_v6_do_calc_md5_hash(newhash,
914 &ip6h->saddr, &ip6h->daddr,
917 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
918 if (net_ratelimit()) {
919 printk(KERN_INFO "MD5 Hash %s for "
920 "(" NIP6_FMT ", %u)->"
921 "(" NIP6_FMT ", %u)\n",
922 genhash ? "failed" : "mismatch",
923 NIP6(ip6h->saddr), ntohs(th->source),
924 NIP6(ip6h->daddr), ntohs(th->dest));
932 struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
934 .obj_size = sizeof(struct tcp6_request_sock),
935 .rtx_syn_ack = tcp_v6_send_synack,
936 .send_ack = tcp_v6_reqsk_send_ack,
937 .destructor = tcp_v6_reqsk_destructor,
938 .send_reset = tcp_v6_send_reset
941 #ifdef CONFIG_TCP_MD5SIG
942 static struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
943 .md5_lookup = tcp_v6_reqsk_md5_lookup,
947 static struct timewait_sock_ops tcp6_timewait_sock_ops = {
948 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
949 .twsk_unique = tcp_twsk_unique,
950 .twsk_destructor= tcp_twsk_destructor,
953 static void tcp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb)
955 struct ipv6_pinfo *np = inet6_sk(sk);
956 struct tcphdr *th = tcp_hdr(skb);
958 if (skb->ip_summed == CHECKSUM_PARTIAL) {
959 th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0);
960 skb->csum_start = skb_transport_header(skb) - skb->head;
961 skb->csum_offset = offsetof(struct tcphdr, check);
963 th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
964 csum_partial((char *)th, th->doff<<2,
969 static int tcp_v6_gso_send_check(struct sk_buff *skb)
971 struct ipv6hdr *ipv6h;
974 if (!pskb_may_pull(skb, sizeof(*th)))
977 ipv6h = ipv6_hdr(skb);
981 th->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr, skb->len,
983 skb->csum_start = skb_transport_header(skb) - skb->head;
984 skb->csum_offset = offsetof(struct tcphdr, check);
985 skb->ip_summed = CHECKSUM_PARTIAL;
989 static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
991 struct tcphdr *th = tcp_hdr(skb), *t1;
992 struct sk_buff *buff;
994 unsigned int tot_len = sizeof(*th);
995 #ifdef CONFIG_TCP_MD5SIG
996 struct tcp_md5sig_key *key;
1002 if (!ipv6_unicast_destination(skb))
1005 #ifdef CONFIG_TCP_MD5SIG
1007 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
1012 tot_len += TCPOLEN_MD5SIG_ALIGNED;
1016 * We need to grab some memory, and put together an RST,
1017 * and then put it into the queue to be sent.
1020 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1025 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1027 t1 = (struct tcphdr *) skb_push(buff, tot_len);
1029 /* Swap the send and the receive. */
1030 memset(t1, 0, sizeof(*t1));
1031 t1->dest = th->source;
1032 t1->source = th->dest;
1033 t1->doff = tot_len / 4;
1037 t1->seq = th->ack_seq;
1040 t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
1041 + skb->len - (th->doff<<2));
1044 #ifdef CONFIG_TCP_MD5SIG
1046 __be32 *opt = (__be32*)(t1 + 1);
1047 opt[0] = htonl((TCPOPT_NOP << 24) |
1048 (TCPOPT_NOP << 16) |
1049 (TCPOPT_MD5SIG << 8) |
1051 tcp_v6_do_calc_md5_hash((__u8 *)&opt[1], key,
1052 &ipv6_hdr(skb)->daddr,
1053 &ipv6_hdr(skb)->saddr,
1054 t1, IPPROTO_TCP, tot_len);
1058 buff->csum = csum_partial((char *)t1, sizeof(*t1), 0);
1060 memset(&fl, 0, sizeof(fl));
1061 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
1062 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
1064 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1065 sizeof(*t1), IPPROTO_TCP,
1068 fl.proto = IPPROTO_TCP;
1069 fl.oif = inet6_iif(skb);
1070 fl.fl_ip_dport = t1->dest;
1071 fl.fl_ip_sport = t1->source;
1072 security_skb_classify_flow(skb, &fl);
1074 /* sk = NULL, but it is safe for now. RST socket required. */
1075 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
1077 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
1078 ip6_xmit(tcp6_socket->sk, buff, &fl, NULL, 0);
1079 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1080 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
1088 static void tcp_v6_send_ack(struct tcp_timewait_sock *tw,
1089 struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts)
1091 struct tcphdr *th = tcp_hdr(skb), *t1;
1092 struct sk_buff *buff;
1094 unsigned int tot_len = sizeof(struct tcphdr);
1096 #ifdef CONFIG_TCP_MD5SIG
1097 struct tcp_md5sig_key *key;
1098 struct tcp_md5sig_key tw_key;
1101 #ifdef CONFIG_TCP_MD5SIG
1102 if (!tw && skb->sk) {
1103 key = tcp_v6_md5_do_lookup(skb->sk, &ipv6_hdr(skb)->daddr);
1104 } else if (tw && tw->tw_md5_keylen) {
1105 tw_key.key = tw->tw_md5_key;
1106 tw_key.keylen = tw->tw_md5_keylen;
1114 tot_len += TCPOLEN_TSTAMP_ALIGNED;
1115 #ifdef CONFIG_TCP_MD5SIG
1117 tot_len += TCPOLEN_MD5SIG_ALIGNED;
1120 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1125 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1127 t1 = (struct tcphdr *) skb_push(buff,tot_len);
1129 /* Swap the send and the receive. */
1130 memset(t1, 0, sizeof(*t1));
1131 t1->dest = th->source;
1132 t1->source = th->dest;
1133 t1->doff = tot_len/4;
1134 t1->seq = htonl(seq);
1135 t1->ack_seq = htonl(ack);
1137 t1->window = htons(win);
1139 topt = (__be32 *)(t1 + 1);
1142 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1143 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1144 *topt++ = htonl(tcp_time_stamp);
1148 #ifdef CONFIG_TCP_MD5SIG
1150 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1151 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
1152 tcp_v6_do_calc_md5_hash((__u8 *)topt, key,
1153 &ipv6_hdr(skb)->daddr,
1154 &ipv6_hdr(skb)->saddr,
1155 t1, IPPROTO_TCP, tot_len);
1159 buff->csum = csum_partial((char *)t1, tot_len, 0);
1161 memset(&fl, 0, sizeof(fl));
1162 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
1163 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
1165 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1166 tot_len, IPPROTO_TCP,
1169 fl.proto = IPPROTO_TCP;
1170 fl.oif = inet6_iif(skb);
1171 fl.fl_ip_dport = t1->dest;
1172 fl.fl_ip_sport = t1->source;
1173 security_skb_classify_flow(skb, &fl);
1175 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
1176 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
1177 ip6_xmit(tcp6_socket->sk, buff, &fl, NULL, 0);
1178 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1186 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1188 struct inet_timewait_sock *tw = inet_twsk(sk);
1189 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1191 tcp_v6_send_ack(tcptw, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
1192 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
1193 tcptw->tw_ts_recent);
1198 static void tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
1200 tcp_v6_send_ack(NULL, skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent);
1204 static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1206 struct request_sock *req, **prev;
1207 const struct tcphdr *th = tcp_hdr(skb);
1210 /* Find possible connection requests. */
1211 req = inet6_csk_search_req(sk, &prev, th->source,
1212 &ipv6_hdr(skb)->saddr,
1213 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
1215 return tcp_check_req(sk, skb, req, prev);
1217 nsk = __inet6_lookup_established(sk->sk_net, &tcp_hashinfo,
1218 &ipv6_hdr(skb)->saddr, th->source,
1219 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
1222 if (nsk->sk_state != TCP_TIME_WAIT) {
1226 inet_twsk_put(inet_twsk(nsk));
1230 #ifdef CONFIG_SYN_COOKIES
1231 if (!th->rst && !th->syn && th->ack)
1232 sk = cookie_v6_check(sk, skb);
1237 /* FIXME: this is substantially similar to the ipv4 code.
1238 * Can some kind of merge be done? -- erics
1240 static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1242 struct inet6_request_sock *treq;
1243 struct ipv6_pinfo *np = inet6_sk(sk);
1244 struct tcp_options_received tmp_opt;
1245 struct tcp_sock *tp = tcp_sk(sk);
1246 struct request_sock *req = NULL;
1247 __u32 isn = TCP_SKB_CB(skb)->when;
1248 #ifdef CONFIG_SYN_COOKIES
1249 int want_cookie = 0;
1251 #define want_cookie 0
1254 if (skb->protocol == htons(ETH_P_IP))
1255 return tcp_v4_conn_request(sk, skb);
1257 if (!ipv6_unicast_destination(skb))
1260 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1261 if (net_ratelimit())
1262 syn_flood_warning(skb);
1263 #ifdef CONFIG_SYN_COOKIES
1264 if (sysctl_tcp_syncookies)
1271 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1274 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
1278 #ifdef CONFIG_TCP_MD5SIG
1279 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1282 tcp_clear_options(&tmp_opt);
1283 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1284 tmp_opt.user_mss = tp->rx_opt.user_mss;
1286 tcp_parse_options(skb, &tmp_opt, 0);
1289 tcp_clear_options(&tmp_opt);
1290 tmp_opt.saw_tstamp = 0;
1293 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1294 tcp_openreq_init(req, &tmp_opt, skb);
1296 treq = inet6_rsk(req);
1297 ipv6_addr_copy(&treq->rmt_addr, &ipv6_hdr(skb)->saddr);
1298 ipv6_addr_copy(&treq->loc_addr, &ipv6_hdr(skb)->daddr);
1299 treq->pktopts = NULL;
1301 TCP_ECN_create_request(req, tcp_hdr(skb));
1304 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1306 if (ipv6_opt_accepted(sk, skb) ||
1307 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1308 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1309 atomic_inc(&skb->users);
1310 treq->pktopts = skb;
1312 treq->iif = sk->sk_bound_dev_if;
1314 /* So that link locals have meaning */
1315 if (!sk->sk_bound_dev_if &&
1316 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1317 treq->iif = inet6_iif(skb);
1319 isn = tcp_v6_init_sequence(skb);
1322 tcp_rsk(req)->snt_isn = isn;
1324 security_inet_conn_request(sk, skb, req);
1326 if (tcp_v6_send_synack(sk, req))
1330 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1338 return 0; /* don't send reset */
1341 static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1342 struct request_sock *req,
1343 struct dst_entry *dst)
1345 struct inet6_request_sock *treq = inet6_rsk(req);
1346 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1347 struct tcp6_sock *newtcp6sk;
1348 struct inet_sock *newinet;
1349 struct tcp_sock *newtp;
1351 struct ipv6_txoptions *opt;
1352 #ifdef CONFIG_TCP_MD5SIG
1353 struct tcp_md5sig_key *key;
1356 if (skb->protocol == htons(ETH_P_IP)) {
1361 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1366 newtcp6sk = (struct tcp6_sock *)newsk;
1367 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1369 newinet = inet_sk(newsk);
1370 newnp = inet6_sk(newsk);
1371 newtp = tcp_sk(newsk);
1373 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1375 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
1378 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
1381 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1383 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1384 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1385 #ifdef CONFIG_TCP_MD5SIG
1386 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1389 newnp->pktoptions = NULL;
1391 newnp->mcast_oif = inet6_iif(skb);
1392 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1395 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1396 * here, tcp_create_openreq_child now does this for us, see the comment in
1397 * that function for the gory details. -acme
1400 /* It is tricky place. Until this moment IPv4 tcp
1401 worked with IPv6 icsk.icsk_af_ops.
1404 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1411 if (sk_acceptq_is_full(sk))
1415 struct in6_addr *final_p = NULL, final;
1418 memset(&fl, 0, sizeof(fl));
1419 fl.proto = IPPROTO_TCP;
1420 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
1421 if (opt && opt->srcrt) {
1422 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
1423 ipv6_addr_copy(&final, &fl.fl6_dst);
1424 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1427 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
1428 fl.oif = sk->sk_bound_dev_if;
1429 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
1430 fl.fl_ip_sport = inet_sk(sk)->sport;
1431 security_req_classify_flow(req, &fl);
1433 if (ip6_dst_lookup(sk, &dst, &fl))
1437 ipv6_addr_copy(&fl.fl6_dst, final_p);
1439 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
1443 newsk = tcp_create_openreq_child(sk, req, skb);
1448 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1449 * count here, tcp_create_openreq_child now does this for us, see the
1450 * comment in that function for the gory details. -acme
1453 newsk->sk_gso_type = SKB_GSO_TCPV6;
1454 __ip6_dst_store(newsk, dst, NULL, NULL);
1456 newtcp6sk = (struct tcp6_sock *)newsk;
1457 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1459 newtp = tcp_sk(newsk);
1460 newinet = inet_sk(newsk);
1461 newnp = inet6_sk(newsk);
1463 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1465 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1466 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1467 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1468 newsk->sk_bound_dev_if = treq->iif;
1470 /* Now IPv6 options...
1472 First: no IPv4 options.
1474 newinet->opt = NULL;
1475 newnp->ipv6_fl_list = NULL;
1478 newnp->rxopt.all = np->rxopt.all;
1480 /* Clone pktoptions received with SYN */
1481 newnp->pktoptions = NULL;
1482 if (treq->pktopts != NULL) {
1483 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1484 kfree_skb(treq->pktopts);
1485 treq->pktopts = NULL;
1486 if (newnp->pktoptions)
1487 skb_set_owner_r(newnp->pktoptions, newsk);
1490 newnp->mcast_oif = inet6_iif(skb);
1491 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1493 /* Clone native IPv6 options from listening socket (if any)
1495 Yes, keeping reference count would be much more clever,
1496 but we make one more one thing there: reattach optmem
1500 newnp->opt = ipv6_dup_options(newsk, opt);
1502 sock_kfree_s(sk, opt, opt->tot_len);
1505 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1507 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1508 newnp->opt->opt_flen);
1510 tcp_mtup_init(newsk);
1511 tcp_sync_mss(newsk, dst_mtu(dst));
1512 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1513 tcp_initialize_rcv_mss(newsk);
1515 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
1517 #ifdef CONFIG_TCP_MD5SIG
1518 /* Copy over the MD5 key from the original socket */
1519 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1520 /* We're using one, so create a matching key
1521 * on the newsk structure. If we fail to get
1522 * memory, then we end up not copying the key
1525 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1527 tcp_v6_md5_do_add(newsk, &inet6_sk(sk)->daddr,
1528 newkey, key->keylen);
1532 __inet6_hash(newsk);
1533 inet_inherit_port(sk, newsk);
1538 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1540 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1541 if (opt && opt != np->opt)
1542 sock_kfree_s(sk, opt, opt->tot_len);
1547 static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
1549 if (skb->ip_summed == CHECKSUM_COMPLETE) {
1550 if (!tcp_v6_check(tcp_hdr(skb), skb->len, &ipv6_hdr(skb)->saddr,
1551 &ipv6_hdr(skb)->daddr, skb->csum)) {
1552 skb->ip_summed = CHECKSUM_UNNECESSARY;
1557 skb->csum = ~csum_unfold(tcp_v6_check(tcp_hdr(skb), skb->len,
1558 &ipv6_hdr(skb)->saddr,
1559 &ipv6_hdr(skb)->daddr, 0));
1561 if (skb->len <= 76) {
1562 return __skb_checksum_complete(skb);
1567 /* The socket must have it's spinlock held when we get
1570 * We have a potential double-lock case here, so even when
1571 * doing backlog processing we use the BH locking scheme.
1572 * This is because we cannot sleep with the original spinlock
1575 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1577 struct ipv6_pinfo *np = inet6_sk(sk);
1578 struct tcp_sock *tp;
1579 struct sk_buff *opt_skb = NULL;
1581 /* Imagine: socket is IPv6. IPv4 packet arrives,
1582 goes to IPv4 receive handler and backlogged.
1583 From backlog it always goes here. Kerboom...
1584 Fortunately, tcp_rcv_established and rcv_established
1585 handle them correctly, but it is not case with
1586 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1589 if (skb->protocol == htons(ETH_P_IP))
1590 return tcp_v4_do_rcv(sk, skb);
1592 #ifdef CONFIG_TCP_MD5SIG
1593 if (tcp_v6_inbound_md5_hash (sk, skb))
1597 if (sk_filter(sk, skb))
1601 * socket locking is here for SMP purposes as backlog rcv
1602 * is currently called with bh processing disabled.
1605 /* Do Stevens' IPV6_PKTOPTIONS.
1607 Yes, guys, it is the only place in our code, where we
1608 may make it not affecting IPv4.
1609 The rest of code is protocol independent,
1610 and I do not like idea to uglify IPv4.
1612 Actually, all the idea behind IPV6_PKTOPTIONS
1613 looks not very well thought. For now we latch
1614 options, received in the last packet, enqueued
1615 by tcp. Feel free to propose better solution.
1619 opt_skb = skb_clone(skb, GFP_ATOMIC);
1621 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1622 TCP_CHECK_TIMER(sk);
1623 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
1625 TCP_CHECK_TIMER(sk);
1627 goto ipv6_pktoptions;
1631 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
1634 if (sk->sk_state == TCP_LISTEN) {
1635 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1640 * Queue it on the new socket if the new socket is active,
1641 * otherwise we just shortcircuit this and continue with
1645 if (tcp_child_process(sk, nsk, skb))
1648 __kfree_skb(opt_skb);
1653 TCP_CHECK_TIMER(sk);
1654 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
1656 TCP_CHECK_TIMER(sk);
1658 goto ipv6_pktoptions;
1662 tcp_v6_send_reset(sk, skb);
1665 __kfree_skb(opt_skb);
1669 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1674 /* Do you ask, what is it?
1676 1. skb was enqueued by tcp.
1677 2. skb is added to tail of read queue, rather than out of order.
1678 3. socket is not in passive state.
1679 4. Finally, it really contains options, which user wants to receive.
1682 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1683 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1684 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
1685 np->mcast_oif = inet6_iif(opt_skb);
1686 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1687 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1688 if (ipv6_opt_accepted(sk, opt_skb)) {
1689 skb_set_owner_r(opt_skb, sk);
1690 opt_skb = xchg(&np->pktoptions, opt_skb);
1692 __kfree_skb(opt_skb);
1693 opt_skb = xchg(&np->pktoptions, NULL);
1702 static int tcp_v6_rcv(struct sk_buff *skb)
1708 if (skb->pkt_type != PACKET_HOST)
1712 * Count it even if it's bad.
1714 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1716 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1721 if (th->doff < sizeof(struct tcphdr)/4)
1723 if (!pskb_may_pull(skb, th->doff*4))
1726 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
1730 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1731 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1732 skb->len - th->doff*4);
1733 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1734 TCP_SKB_CB(skb)->when = 0;
1735 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(ipv6_hdr(skb));
1736 TCP_SKB_CB(skb)->sacked = 0;
1738 sk = __inet6_lookup(skb->dev->nd_net, &tcp_hashinfo,
1739 &ipv6_hdr(skb)->saddr, th->source,
1740 &ipv6_hdr(skb)->daddr, ntohs(th->dest),
1747 if (sk->sk_state == TCP_TIME_WAIT)
1750 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1751 goto discard_and_relse;
1753 if (sk_filter(sk, skb))
1754 goto discard_and_relse;
1758 bh_lock_sock_nested(sk);
1760 if (!sock_owned_by_user(sk)) {
1761 #ifdef CONFIG_NET_DMA
1762 struct tcp_sock *tp = tcp_sk(sk);
1763 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1764 tp->ucopy.dma_chan = get_softnet_dma();
1765 if (tp->ucopy.dma_chan)
1766 ret = tcp_v6_do_rcv(sk, skb);
1770 if (!tcp_prequeue(sk, skb))
1771 ret = tcp_v6_do_rcv(sk, skb);
1774 sk_add_backlog(sk, skb);
1778 return ret ? -1 : 0;
1781 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1784 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1786 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1788 tcp_v6_send_reset(NULL, skb);
1805 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1806 inet_twsk_put(inet_twsk(sk));
1810 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1811 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1812 inet_twsk_put(inet_twsk(sk));
1816 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1821 sk2 = inet6_lookup_listener(skb->dev->nd_net, &tcp_hashinfo,
1822 &ipv6_hdr(skb)->daddr,
1823 ntohs(th->dest), inet6_iif(skb));
1825 struct inet_timewait_sock *tw = inet_twsk(sk);
1826 inet_twsk_deschedule(tw, &tcp_death_row);
1831 /* Fall through to ACK */
1834 tcp_v6_timewait_ack(sk, skb);
1838 case TCP_TW_SUCCESS:;
1843 static int tcp_v6_remember_stamp(struct sock *sk)
1845 /* Alas, not yet... */
1849 static struct inet_connection_sock_af_ops ipv6_specific = {
1850 .queue_xmit = inet6_csk_xmit,
1851 .send_check = tcp_v6_send_check,
1852 .rebuild_header = inet6_sk_rebuild_header,
1853 .conn_request = tcp_v6_conn_request,
1854 .syn_recv_sock = tcp_v6_syn_recv_sock,
1855 .remember_stamp = tcp_v6_remember_stamp,
1856 .net_header_len = sizeof(struct ipv6hdr),
1857 .setsockopt = ipv6_setsockopt,
1858 .getsockopt = ipv6_getsockopt,
1859 .addr2sockaddr = inet6_csk_addr2sockaddr,
1860 .sockaddr_len = sizeof(struct sockaddr_in6),
1861 .bind_conflict = inet6_csk_bind_conflict,
1862 #ifdef CONFIG_COMPAT
1863 .compat_setsockopt = compat_ipv6_setsockopt,
1864 .compat_getsockopt = compat_ipv6_getsockopt,
1868 #ifdef CONFIG_TCP_MD5SIG
1869 static struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
1870 .md5_lookup = tcp_v6_md5_lookup,
1871 .calc_md5_hash = tcp_v6_calc_md5_hash,
1872 .md5_add = tcp_v6_md5_add_func,
1873 .md5_parse = tcp_v6_parse_md5_keys,
1878 * TCP over IPv4 via INET6 API
1881 static struct inet_connection_sock_af_ops ipv6_mapped = {
1882 .queue_xmit = ip_queue_xmit,
1883 .send_check = tcp_v4_send_check,
1884 .rebuild_header = inet_sk_rebuild_header,
1885 .conn_request = tcp_v6_conn_request,
1886 .syn_recv_sock = tcp_v6_syn_recv_sock,
1887 .remember_stamp = tcp_v4_remember_stamp,
1888 .net_header_len = sizeof(struct iphdr),
1889 .setsockopt = ipv6_setsockopt,
1890 .getsockopt = ipv6_getsockopt,
1891 .addr2sockaddr = inet6_csk_addr2sockaddr,
1892 .sockaddr_len = sizeof(struct sockaddr_in6),
1893 .bind_conflict = inet6_csk_bind_conflict,
1894 #ifdef CONFIG_COMPAT
1895 .compat_setsockopt = compat_ipv6_setsockopt,
1896 .compat_getsockopt = compat_ipv6_getsockopt,
1900 #ifdef CONFIG_TCP_MD5SIG
1901 static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
1902 .md5_lookup = tcp_v4_md5_lookup,
1903 .calc_md5_hash = tcp_v4_calc_md5_hash,
1904 .md5_add = tcp_v6_md5_add_func,
1905 .md5_parse = tcp_v6_parse_md5_keys,
1909 /* NOTE: A lot of things set to zero explicitly by call to
1910 * sk_alloc() so need not be done here.
1912 static int tcp_v6_init_sock(struct sock *sk)
1914 struct inet_connection_sock *icsk = inet_csk(sk);
1915 struct tcp_sock *tp = tcp_sk(sk);
1917 skb_queue_head_init(&tp->out_of_order_queue);
1918 tcp_init_xmit_timers(sk);
1919 tcp_prequeue_init(tp);
1921 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1922 tp->mdev = TCP_TIMEOUT_INIT;
1924 /* So many TCP implementations out there (incorrectly) count the
1925 * initial SYN frame in their delayed-ACK and congestion control
1926 * algorithms that we must have the following bandaid to talk
1927 * efficiently to them. -DaveM
1931 /* See draft-stevens-tcpca-spec-01 for discussion of the
1932 * initialization of these values.
1934 tp->snd_ssthresh = 0x7fffffff;
1935 tp->snd_cwnd_clamp = ~0;
1936 tp->mss_cache = 536;
1938 tp->reordering = sysctl_tcp_reordering;
1940 sk->sk_state = TCP_CLOSE;
1942 icsk->icsk_af_ops = &ipv6_specific;
1943 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1944 icsk->icsk_sync_mss = tcp_sync_mss;
1945 sk->sk_write_space = sk_stream_write_space;
1946 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1948 #ifdef CONFIG_TCP_MD5SIG
1949 tp->af_specific = &tcp_sock_ipv6_specific;
1952 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1953 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1955 atomic_inc(&tcp_sockets_allocated);
1960 static int tcp_v6_destroy_sock(struct sock *sk)
1962 #ifdef CONFIG_TCP_MD5SIG
1963 /* Clean up the MD5 key list */
1964 if (tcp_sk(sk)->md5sig_info)
1965 tcp_v6_clear_md5_list(sk);
1967 tcp_v4_destroy_sock(sk);
1968 return inet6_destroy_sock(sk);
1971 #ifdef CONFIG_PROC_FS
1972 /* Proc filesystem TCPv6 sock list dumping. */
1973 static void get_openreq6(struct seq_file *seq,
1974 struct sock *sk, struct request_sock *req, int i, int uid)
1976 int ttd = req->expires - jiffies;
1977 struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1978 struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
1984 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1985 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1987 src->s6_addr32[0], src->s6_addr32[1],
1988 src->s6_addr32[2], src->s6_addr32[3],
1989 ntohs(inet_sk(sk)->sport),
1990 dest->s6_addr32[0], dest->s6_addr32[1],
1991 dest->s6_addr32[2], dest->s6_addr32[3],
1992 ntohs(inet_rsk(req)->rmt_port),
1994 0,0, /* could print option size, but that is af dependent. */
1995 1, /* timers active (only the expire timer) */
1996 jiffies_to_clock_t(ttd),
1999 0, /* non standard timer */
2000 0, /* open_requests have no inode */
2004 static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
2006 struct in6_addr *dest, *src;
2009 unsigned long timer_expires;
2010 struct inet_sock *inet = inet_sk(sp);
2011 struct tcp_sock *tp = tcp_sk(sp);
2012 const struct inet_connection_sock *icsk = inet_csk(sp);
2013 struct ipv6_pinfo *np = inet6_sk(sp);
2016 src = &np->rcv_saddr;
2017 destp = ntohs(inet->dport);
2018 srcp = ntohs(inet->sport);
2020 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
2022 timer_expires = icsk->icsk_timeout;
2023 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2025 timer_expires = icsk->icsk_timeout;
2026 } else if (timer_pending(&sp->sk_timer)) {
2028 timer_expires = sp->sk_timer.expires;
2031 timer_expires = jiffies;
2035 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2036 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %u %u %u %u %d\n",
2038 src->s6_addr32[0], src->s6_addr32[1],
2039 src->s6_addr32[2], src->s6_addr32[3], srcp,
2040 dest->s6_addr32[0], dest->s6_addr32[1],
2041 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2043 tp->write_seq-tp->snd_una,
2044 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
2046 jiffies_to_clock_t(timer_expires - jiffies),
2047 icsk->icsk_retransmits,
2049 icsk->icsk_probes_out,
2051 atomic_read(&sp->sk_refcnt), sp,
2054 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
2055 tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
2059 static void get_timewait6_sock(struct seq_file *seq,
2060 struct inet_timewait_sock *tw, int i)
2062 struct in6_addr *dest, *src;
2064 struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
2065 int ttd = tw->tw_ttd - jiffies;
2070 dest = &tw6->tw_v6_daddr;
2071 src = &tw6->tw_v6_rcv_saddr;
2072 destp = ntohs(tw->tw_dport);
2073 srcp = ntohs(tw->tw_sport);
2076 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2077 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2079 src->s6_addr32[0], src->s6_addr32[1],
2080 src->s6_addr32[2], src->s6_addr32[3], srcp,
2081 dest->s6_addr32[0], dest->s6_addr32[1],
2082 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2083 tw->tw_substate, 0, 0,
2084 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2085 atomic_read(&tw->tw_refcnt), tw);
2088 static int tcp6_seq_show(struct seq_file *seq, void *v)
2090 struct tcp_iter_state *st;
2092 if (v == SEQ_START_TOKEN) {
2097 "st tx_queue rx_queue tr tm->when retrnsmt"
2098 " uid timeout inode\n");
2103 switch (st->state) {
2104 case TCP_SEQ_STATE_LISTENING:
2105 case TCP_SEQ_STATE_ESTABLISHED:
2106 get_tcp6_sock(seq, v, st->num);
2108 case TCP_SEQ_STATE_OPENREQ:
2109 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2111 case TCP_SEQ_STATE_TIME_WAIT:
2112 get_timewait6_sock(seq, v, st->num);
2119 static struct file_operations tcp6_seq_fops;
2120 static struct tcp_seq_afinfo tcp6_seq_afinfo = {
2121 .owner = THIS_MODULE,
2124 .seq_show = tcp6_seq_show,
2125 .seq_fops = &tcp6_seq_fops,
2128 int __init tcp6_proc_init(void)
2130 return tcp_proc_register(&tcp6_seq_afinfo);
2133 void tcp6_proc_exit(void)
2135 tcp_proc_unregister(&tcp6_seq_afinfo);
2139 DEFINE_PROTO_INUSE(tcpv6)
2141 struct proto tcpv6_prot = {
2143 .owner = THIS_MODULE,
2145 .connect = tcp_v6_connect,
2146 .disconnect = tcp_disconnect,
2147 .accept = inet_csk_accept,
2149 .init = tcp_v6_init_sock,
2150 .destroy = tcp_v6_destroy_sock,
2151 .shutdown = tcp_shutdown,
2152 .setsockopt = tcp_setsockopt,
2153 .getsockopt = tcp_getsockopt,
2154 .recvmsg = tcp_recvmsg,
2155 .backlog_rcv = tcp_v6_do_rcv,
2156 .hash = tcp_v6_hash,
2157 .unhash = inet_unhash,
2158 .get_port = inet_csk_get_port,
2159 .enter_memory_pressure = tcp_enter_memory_pressure,
2160 .sockets_allocated = &tcp_sockets_allocated,
2161 .memory_allocated = &tcp_memory_allocated,
2162 .memory_pressure = &tcp_memory_pressure,
2163 .orphan_count = &tcp_orphan_count,
2164 .sysctl_mem = sysctl_tcp_mem,
2165 .sysctl_wmem = sysctl_tcp_wmem,
2166 .sysctl_rmem = sysctl_tcp_rmem,
2167 .max_header = MAX_TCP_HEADER,
2168 .obj_size = sizeof(struct tcp6_sock),
2169 .twsk_prot = &tcp6_timewait_sock_ops,
2170 .rsk_prot = &tcp6_request_sock_ops,
2171 .hashinfo = &tcp_hashinfo,
2172 #ifdef CONFIG_COMPAT
2173 .compat_setsockopt = compat_tcp_setsockopt,
2174 .compat_getsockopt = compat_tcp_getsockopt,
2176 REF_PROTO_INUSE(tcpv6)
2179 static struct inet6_protocol tcpv6_protocol = {
2180 .handler = tcp_v6_rcv,
2181 .err_handler = tcp_v6_err,
2182 .gso_send_check = tcp_v6_gso_send_check,
2183 .gso_segment = tcp_tso_segment,
2184 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2187 static struct inet_protosw tcpv6_protosw = {
2188 .type = SOCK_STREAM,
2189 .protocol = IPPROTO_TCP,
2190 .prot = &tcpv6_prot,
2191 .ops = &inet6_stream_ops,
2194 .flags = INET_PROTOSW_PERMANENT |
2198 int __init tcpv6_init(void)
2202 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2206 /* register inet6 protocol */
2207 ret = inet6_register_protosw(&tcpv6_protosw);
2209 goto out_tcpv6_protocol;
2211 ret = inet_csk_ctl_sock_create(&tcp6_socket, PF_INET6,
2212 SOCK_RAW, IPPROTO_TCP);
2214 goto out_tcpv6_protosw;
2219 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2221 inet6_unregister_protosw(&tcpv6_protosw);
2225 void tcpv6_exit(void)
2227 sock_release(tcp6_socket);
2228 inet6_unregister_protosw(&tcpv6_protosw);
2229 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);