source: src/linux/universal/linux-3.18/net/ipv6/tcp_ipv6.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 4 months ago

update

File size: 51.5 KB
Line 
1/*
2 *      TCP over IPv6
3 *      Linux INET6 implementation
4 *
5 *      Authors:
6 *      Pedro Roque             <roque@di.fc.ul.pt>
7 *
8 *      Based on:
9 *      linux/net/ipv4/tcp.c
10 *      linux/net/ipv4/tcp_input.c
11 *      linux/net/ipv4/tcp_output.c
12 *
13 *      Fixes:
14 *      Hideaki YOSHIFUJI       :       sin6_scope_id support
15 *      YOSHIFUJI Hideaki @USAGI and:   Support IPV6_V6ONLY socket option, which
16 *      Alexey Kuznetsov                allow both IPv4 and IPv6 sockets to bind
17 *                                      a single port at the same time.
18 *      YOSHIFUJI Hideaki @USAGI:       convert /proc/net/tcp6 to seq_file.
19 *
20 *      This program is free software; you can redistribute it and/or
21 *      modify it under the terms of the GNU General Public License
22 *      as published by the Free Software Foundation; either version
23 *      2 of the License, or (at your option) any later version.
24 */
25
26#include <linux/bottom_half.h>
27#include <linux/module.h>
28#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/socket.h>
31#include <linux/sockios.h>
32#include <linux/net.h>
33#include <linux/jiffies.h>
34#include <linux/in.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/init.h>
38#include <linux/jhash.h>
39#include <linux/ipsec.h>
40#include <linux/times.h>
41#include <linux/slab.h>
42#include <asm/unaligned.h>
43#include <linux/uaccess.h>
44#include <linux/ipv6.h>
45#include <linux/icmpv6.h>
46#include <linux/random.h>
47
48#include <net/tcp.h>
49#include <net/ndisc.h>
50#include <net/inet6_hashtables.h>
51#include <net/inet6_connection_sock.h>
52#include <net/ipv6.h>
53#include <net/transp_v6.h>
54#include <net/addrconf.h>
55#include <net/ip6_route.h>
56#include <net/ip6_checksum.h>
57#include <net/inet_ecn.h>
58#include <net/protocol.h>
59#include <net/xfrm.h>
60#include <net/snmp.h>
61#include <net/dsfield.h>
62#include <net/timewait_sock.h>
63#include <net/inet_common.h>
64#include <net/secure_seq.h>
65#include <net/tcp_memcontrol.h>
66#include <net/busy_poll.h>
67
68#include <asm/unaligned.h>
69#include <asm/uaccess.h>
70
71#include <linux/proc_fs.h>
72#include <linux/seq_file.h>
73
74#include <linux/crypto.h>
75#include <linux/scatterlist.h>
76
77static void     tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
78static void     tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
79                                      struct request_sock *req);
80
81static int      tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
82
83static const struct inet_connection_sock_af_ops ipv6_mapped;
84static const struct inet_connection_sock_af_ops ipv6_specific;
85#ifdef CONFIG_TCP_MD5SIG
86static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
87static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
88#else
89static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
90                                                   const struct in6_addr *addr)
91{
92        return NULL;
93}
94#endif
95
96static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
97{
98        struct dst_entry *dst = skb_dst(skb);
99
100        if (dst && dst_hold_safe(dst)) {
101                const struct rt6_info *rt = (const struct rt6_info *)dst;
102
103                sk->sk_rx_dst = dst;
104                inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
105                if (rt->rt6i_node)
106                        inet6_sk(sk)->rx_dst_cookie = rt->rt6i_node->fn_sernum;
107        }
108}
109
110static void tcp_v6_hash(struct sock *sk)
111{
112        if (sk->sk_state != TCP_CLOSE) {
113                if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
114                        tcp_prot.hash(sk);
115                        return;
116                }
117                local_bh_disable();
118                __inet6_hash(sk, NULL);
119                local_bh_enable();
120        }
121}
122
123static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
124{
125        return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
126                                            ipv6_hdr(skb)->saddr.s6_addr32,
127                                            tcp_hdr(skb)->dest,
128                                            tcp_hdr(skb)->source);
129}
130
131static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
132                          int addr_len)
133{
134        struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
135        struct inet_sock *inet = inet_sk(sk);
136        struct inet_connection_sock *icsk = inet_csk(sk);
137        struct ipv6_pinfo *np = inet6_sk(sk);
138        struct tcp_sock *tp = tcp_sk(sk);
139        struct in6_addr *saddr = NULL, *final_p, final;
140        struct ipv6_txoptions *opt;
141        struct rt6_info *rt;
142        struct flowi6 fl6;
143        struct dst_entry *dst;
144        int addr_type;
145        int err;
146
147        if (addr_len < SIN6_LEN_RFC2133)
148                return -EINVAL;
149
150        if (usin->sin6_family != AF_INET6)
151                return -EAFNOSUPPORT;
152
153        memset(&fl6, 0, sizeof(fl6));
154
155        if (np->sndflow) {
156                fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
157                IP6_ECN_flow_init(fl6.flowlabel);
158                if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
159                        struct ip6_flowlabel *flowlabel;
160                        flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
161                        if (flowlabel == NULL)
162                                return -EINVAL;
163                        fl6_sock_release(flowlabel);
164                }
165        }
166
167        /*
168         *      connect() to INADDR_ANY means loopback (BSD'ism).
169         */
170
171        if (ipv6_addr_any(&usin->sin6_addr))
172                usin->sin6_addr.s6_addr[15] = 0x1;
173
174        addr_type = ipv6_addr_type(&usin->sin6_addr);
175
176        if (addr_type & IPV6_ADDR_MULTICAST)
177                return -ENETUNREACH;
178
179        if (addr_type&IPV6_ADDR_LINKLOCAL) {
180                if (addr_len >= sizeof(struct sockaddr_in6) &&
181                    usin->sin6_scope_id) {
182                        /* If interface is set while binding, indices
183                         * must coincide.
184                         */
185                        if (sk->sk_bound_dev_if &&
186                            sk->sk_bound_dev_if != usin->sin6_scope_id)
187                                return -EINVAL;
188
189                        sk->sk_bound_dev_if = usin->sin6_scope_id;
190                }
191
192                /* Connect to link-local address requires an interface */
193                if (!sk->sk_bound_dev_if)
194                        return -EINVAL;
195        }
196
197        if (tp->rx_opt.ts_recent_stamp &&
198            !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
199                tp->rx_opt.ts_recent = 0;
200                tp->rx_opt.ts_recent_stamp = 0;
201                tp->write_seq = 0;
202        }
203
204        sk->sk_v6_daddr = usin->sin6_addr;
205        np->flow_label = fl6.flowlabel;
206
207        /*
208         *      TCP over IPv4
209         */
210
211        if (addr_type == IPV6_ADDR_MAPPED) {
212                u32 exthdrlen = icsk->icsk_ext_hdr_len;
213                struct sockaddr_in sin;
214
215                SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
216
217                if (__ipv6_only_sock(sk))
218                        return -ENETUNREACH;
219
220                sin.sin_family = AF_INET;
221                sin.sin_port = usin->sin6_port;
222                sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
223
224                icsk->icsk_af_ops = &ipv6_mapped;
225                sk->sk_backlog_rcv = tcp_v4_do_rcv;
226#ifdef CONFIG_TCP_MD5SIG
227                tp->af_specific = &tcp_sock_ipv6_mapped_specific;
228#endif
229
230                err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
231
232                if (err) {
233                        icsk->icsk_ext_hdr_len = exthdrlen;
234                        icsk->icsk_af_ops = &ipv6_specific;
235                        sk->sk_backlog_rcv = tcp_v6_do_rcv;
236#ifdef CONFIG_TCP_MD5SIG
237                        tp->af_specific = &tcp_sock_ipv6_specific;
238#endif
239                        goto failure;
240                } else {
241                        ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
242                        ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
243                                               &sk->sk_v6_rcv_saddr);
244                }
245
246                return err;
247        }
248
249        if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
250                saddr = &sk->sk_v6_rcv_saddr;
251
252        fl6.flowi6_proto = IPPROTO_TCP;
253        fl6.daddr = sk->sk_v6_daddr;
254        fl6.saddr = saddr ? *saddr : np->saddr;
255        fl6.flowi6_oif = sk->sk_bound_dev_if;
256        fl6.flowi6_mark = sk->sk_mark;
257        fl6.fl6_dport = usin->sin6_port;
258        fl6.fl6_sport = inet->inet_sport;
259
260        opt = rcu_dereference_protected(np->opt, sock_owned_by_user(sk));
261        final_p = fl6_update_dst(&fl6, opt, &final);
262
263        security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
264
265        dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
266        if (IS_ERR(dst)) {
267                err = PTR_ERR(dst);
268                goto failure;
269        }
270
271        if (saddr == NULL) {
272                saddr = &fl6.saddr;
273                sk->sk_v6_rcv_saddr = *saddr;
274        }
275
276        /* set the source address */
277        np->saddr = *saddr;
278        inet->inet_rcv_saddr = LOOPBACK4_IPV6;
279
280        sk->sk_gso_type = SKB_GSO_TCPV6;
281        __ip6_dst_store(sk, dst, NULL, NULL);
282
283        rt = (struct rt6_info *) dst;
284        if (tcp_death_row.sysctl_tw_recycle &&
285            !tp->rx_opt.ts_recent_stamp &&
286            ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
287                tcp_fetch_timewait_stamp(sk, dst);
288
289        icsk->icsk_ext_hdr_len = 0;
290        if (opt)
291                icsk->icsk_ext_hdr_len = opt->opt_flen +
292                                         opt->opt_nflen;
293
294        tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
295
296        inet->inet_dport = usin->sin6_port;
297
298        tcp_set_state(sk, TCP_SYN_SENT);
299        err = inet6_hash_connect(&tcp_death_row, sk);
300        if (err)
301                goto late_failure;
302
303        ip6_set_txhash(sk);
304
305        if (!tp->write_seq && likely(!tp->repair))
306                tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
307                                                             sk->sk_v6_daddr.s6_addr32,
308                                                             inet->inet_sport,
309                                                             inet->inet_dport);
310
311        err = tcp_connect(sk);
312        if (err)
313                goto late_failure;
314
315        return 0;
316
317late_failure:
318        tcp_set_state(sk, TCP_CLOSE);
319        __sk_dst_reset(sk);
320failure:
321        inet->inet_dport = 0;
322        sk->sk_route_caps = 0;
323        return err;
324}
325
326static void tcp_v6_mtu_reduced(struct sock *sk)
327{
328        struct dst_entry *dst;
329
330        if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
331                return;
332
333        dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
334        if (!dst)
335                return;
336
337        if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
338                tcp_sync_mss(sk, dst_mtu(dst));
339                tcp_simple_retransmit(sk);
340        }
341}
342
343static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
344                u8 type, u8 code, int offset, __be32 info)
345{
346        const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
347        const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
348        struct ipv6_pinfo *np;
349        struct sock *sk;
350        int err;
351        struct tcp_sock *tp;
352        struct request_sock *fastopen;
353        __u32 seq, snd_una;
354        struct net *net = dev_net(skb->dev);
355
356        sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
357                        th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
358
359        if (sk == NULL) {
360                ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
361                                   ICMP6_MIB_INERRORS);
362                return;
363        }
364
365        if (sk->sk_state == TCP_TIME_WAIT) {
366                inet_twsk_put(inet_twsk(sk));
367                return;
368        }
369
370        bh_lock_sock(sk);
371        if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
372                NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
373
374        if (sk->sk_state == TCP_CLOSE)
375                goto out;
376
377        if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
378                NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
379                goto out;
380        }
381
382        tp = tcp_sk(sk);
383        seq = ntohl(th->seq);
384        /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
385        fastopen = tp->fastopen_rsk;
386        snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
387        if (sk->sk_state != TCP_LISTEN &&
388            !between(seq, snd_una, tp->snd_nxt)) {
389                NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
390                goto out;
391        }
392
393        np = inet6_sk(sk);
394
395        if (type == NDISC_REDIRECT) {
396                if (!sock_owned_by_user(sk)) {
397                        struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
398
399                        if (dst)
400                                dst->ops->redirect(dst, sk, skb);
401                }
402                goto out;
403        }
404
405        if (type == ICMPV6_PKT_TOOBIG) {
406                /* We are not interested in TCP_LISTEN and open_requests
407                 * (SYN-ACKs send out by Linux are always <576bytes so
408                 * they should go through unfragmented).
409                 */
410                if (sk->sk_state == TCP_LISTEN)
411                        goto out;
412
413                if (!ip6_sk_accept_pmtu(sk))
414                        goto out;
415
416                tp->mtu_info = ntohl(info);
417                if (!sock_owned_by_user(sk))
418                        tcp_v6_mtu_reduced(sk);
419                else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
420                                           &tp->tsq_flags))
421                        sock_hold(sk);
422                goto out;
423        }
424
425        icmpv6_err_convert(type, code, &err);
426
427        /* Might be for an request_sock */
428        switch (sk->sk_state) {
429                struct request_sock *req, **prev;
430        case TCP_LISTEN:
431                if (sock_owned_by_user(sk))
432                        goto out;
433
434                /* Note : We use inet6_iif() here, not tcp_v6_iif() */
435                req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
436                                           &hdr->saddr, inet6_iif(skb));
437                if (!req)
438                        goto out;
439
440                /* ICMPs are not backlogged, hence we cannot get
441                 * an established socket here.
442                 */
443                WARN_ON(req->sk != NULL);
444
445                if (seq != tcp_rsk(req)->snt_isn) {
446                        NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
447                        goto out;
448                }
449
450                inet_csk_reqsk_queue_drop(sk, req, prev);
451                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
452                goto out;
453
454        case TCP_SYN_SENT:
455        case TCP_SYN_RECV:
456                /* Only in fast or simultaneous open. If a fast open socket is
457                 * is already accepted it is treated as a connected one below.
458                 */
459                if (fastopen && fastopen->sk == NULL)
460                        break;
461
462                if (!sock_owned_by_user(sk)) {
463                        sk->sk_err = err;
464                        sk->sk_error_report(sk);                /* Wake people up to see the error (see connect in sock.c) */
465
466                        tcp_done(sk);
467                } else
468                        sk->sk_err_soft = err;
469                goto out;
470        }
471
472        if (!sock_owned_by_user(sk) && np->recverr) {
473                sk->sk_err = err;
474                sk->sk_error_report(sk);
475        } else
476                sk->sk_err_soft = err;
477
478out:
479        bh_unlock_sock(sk);
480        sock_put(sk);
481}
482
483
484static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
485                              struct flowi *fl,
486                              struct request_sock *req,
487                              u16 queue_mapping,
488                              struct tcp_fastopen_cookie *foc)
489{
490        struct inet_request_sock *ireq = inet_rsk(req);
491        struct ipv6_pinfo *np = inet6_sk(sk);
492        struct flowi6 *fl6 = &fl->u.ip6;
493        struct sk_buff *skb;
494        int err = -ENOMEM;
495
496        /* First, grab a route. */
497        if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
498                goto done;
499
500        skb = tcp_make_synack(sk, dst, req, foc);
501
502        if (skb) {
503                __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
504                                    &ireq->ir_v6_rmt_addr);
505
506                fl6->daddr = ireq->ir_v6_rmt_addr;
507                if (np->repflow && (ireq->pktopts != NULL))
508                        fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
509
510                skb_set_queue_mapping(skb, queue_mapping);
511                rcu_read_lock();
512                err = ip6_xmit(sk, skb, fl6, rcu_dereference(np->opt),
513                               np->tclass);
514                rcu_read_unlock();
515                err = net_xmit_eval(err);
516        }
517
518done:
519        return err;
520}
521
522
523static void tcp_v6_reqsk_destructor(struct request_sock *req)
524{
525        kfree_skb(inet_rsk(req)->pktopts);
526}
527
528#ifdef CONFIG_TCP_MD5SIG
529static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
530                                                   const struct in6_addr *addr)
531{
532        return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
533}
534
535static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
536                                                struct sock *addr_sk)
537{
538        return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
539}
540
541static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
542                                                      struct request_sock *req)
543{
544        return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
545}
546
547static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
548                                 int optlen)
549{
550        struct tcp_md5sig cmd;
551        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
552
553        if (optlen < sizeof(cmd))
554                return -EINVAL;
555
556        if (copy_from_user(&cmd, optval, sizeof(cmd)))
557                return -EFAULT;
558
559        if (sin6->sin6_family != AF_INET6)
560                return -EINVAL;
561
562        if (!cmd.tcpm_keylen) {
563                if (ipv6_addr_v4mapped(&sin6->sin6_addr))
564                        return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
565                                              AF_INET);
566                return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
567                                      AF_INET6);
568        }
569
570        if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
571                return -EINVAL;
572
573        if (ipv6_addr_v4mapped(&sin6->sin6_addr))
574                return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
575                                      AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
576
577        return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
578                              AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
579}
580
581static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
582                                        const struct in6_addr *daddr,
583                                        const struct in6_addr *saddr, int nbytes)
584{
585        struct tcp6_pseudohdr *bp;
586        struct scatterlist sg;
587
588        bp = &hp->md5_blk.ip6;
589        /* 1. TCP pseudo-header (RFC2460) */
590        bp->saddr = *saddr;
591        bp->daddr = *daddr;
592        bp->protocol = cpu_to_be32(IPPROTO_TCP);
593        bp->len = cpu_to_be32(nbytes);
594
595        sg_init_one(&sg, bp, sizeof(*bp));
596        return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
597}
598
599static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
600                               const struct in6_addr *daddr, struct in6_addr *saddr,
601                               const struct tcphdr *th)
602{
603        struct tcp_md5sig_pool *hp;
604        struct hash_desc *desc;
605
606        hp = tcp_get_md5sig_pool();
607        if (!hp)
608                goto clear_hash_noput;
609        desc = &hp->md5_desc;
610
611        if (crypto_hash_init(desc))
612                goto clear_hash;
613        if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
614                goto clear_hash;
615        if (tcp_md5_hash_header(hp, th))
616                goto clear_hash;
617        if (tcp_md5_hash_key(hp, key))
618                goto clear_hash;
619        if (crypto_hash_final(desc, md5_hash))
620                goto clear_hash;
621
622        tcp_put_md5sig_pool();
623        return 0;
624
625clear_hash:
626        tcp_put_md5sig_pool();
627clear_hash_noput:
628        memset(md5_hash, 0, 16);
629        return 1;
630}
631
632static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
633                               const struct sock *sk,
634                               const struct request_sock *req,
635                               const struct sk_buff *skb)
636{
637        const struct in6_addr *saddr, *daddr;
638        struct tcp_md5sig_pool *hp;
639        struct hash_desc *desc;
640        const struct tcphdr *th = tcp_hdr(skb);
641
642        if (sk) {
643                saddr = &inet6_sk(sk)->saddr;
644                daddr = &sk->sk_v6_daddr;
645        } else if (req) {
646                saddr = &inet_rsk(req)->ir_v6_loc_addr;
647                daddr = &inet_rsk(req)->ir_v6_rmt_addr;
648        } else {
649                const struct ipv6hdr *ip6h = ipv6_hdr(skb);
650                saddr = &ip6h->saddr;
651                daddr = &ip6h->daddr;
652        }
653
654        hp = tcp_get_md5sig_pool();
655        if (!hp)
656                goto clear_hash_noput;
657        desc = &hp->md5_desc;
658
659        if (crypto_hash_init(desc))
660                goto clear_hash;
661
662        if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
663                goto clear_hash;
664        if (tcp_md5_hash_header(hp, th))
665                goto clear_hash;
666        if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
667                goto clear_hash;
668        if (tcp_md5_hash_key(hp, key))
669                goto clear_hash;
670        if (crypto_hash_final(desc, md5_hash))
671                goto clear_hash;
672
673        tcp_put_md5sig_pool();
674        return 0;
675
676clear_hash:
677        tcp_put_md5sig_pool();
678clear_hash_noput:
679        memset(md5_hash, 0, 16);
680        return 1;
681}
682
683static int __tcp_v6_inbound_md5_hash(struct sock *sk,
684                                     const struct sk_buff *skb)
685{
686        const __u8 *hash_location = NULL;
687        struct tcp_md5sig_key *hash_expected;
688        const struct ipv6hdr *ip6h = ipv6_hdr(skb);
689        const struct tcphdr *th = tcp_hdr(skb);
690        int genhash;
691        u8 newhash[16];
692
693        hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
694        hash_location = tcp_parse_md5sig_option(th);
695
696        /* We've parsed the options - do we have a hash? */
697        if (!hash_expected && !hash_location)
698                return 0;
699
700        if (hash_expected && !hash_location) {
701                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
702                return 1;
703        }
704
705        if (!hash_expected && hash_location) {
706                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
707                return 1;
708        }
709
710        /* check the signature */
711        genhash = tcp_v6_md5_hash_skb(newhash,
712                                      hash_expected,
713                                      NULL, NULL, skb);
714
715        if (genhash || memcmp(hash_location, newhash, 16) != 0) {
716                net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
717                                     genhash ? "failed" : "mismatch",
718                                     &ip6h->saddr, ntohs(th->source),
719                                     &ip6h->daddr, ntohs(th->dest));
720                return 1;
721        }
722        return 0;
723}
724
725static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
726{
727        int ret;
728
729        rcu_read_lock();
730        ret = __tcp_v6_inbound_md5_hash(sk, skb);
731        rcu_read_unlock();
732
733        return ret;
734}
735
736#endif
737
738static void tcp_v6_init_req(struct request_sock *req, struct sock *sk,
739                            struct sk_buff *skb)
740{
741        struct inet_request_sock *ireq = inet_rsk(req);
742        struct ipv6_pinfo *np = inet6_sk(sk);
743
744        ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
745        ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
746
747        ireq->ir_iif = sk->sk_bound_dev_if;
748
749        /* So that link locals have meaning */
750        if (!sk->sk_bound_dev_if &&
751            ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
752                ireq->ir_iif = tcp_v6_iif(skb);
753
754        if (!TCP_SKB_CB(skb)->tcp_tw_isn &&
755            (ipv6_opt_accepted(sk, skb, &TCP_SKB_CB(skb)->header.h6) ||
756             np->rxopt.bits.rxinfo ||
757             np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
758             np->rxopt.bits.rxohlim || np->repflow)) {
759                atomic_inc(&skb->users);
760                ireq->pktopts = skb;
761        }
762}
763
764static struct dst_entry *tcp_v6_route_req(struct sock *sk, struct flowi *fl,
765                                          const struct request_sock *req,
766                                          bool *strict)
767{
768        if (strict)
769                *strict = true;
770        return inet6_csk_route_req(sk, &fl->u.ip6, req);
771}
772
773struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
774        .family         =       AF_INET6,
775        .obj_size       =       sizeof(struct tcp6_request_sock),
776        .rtx_syn_ack    =       tcp_rtx_synack,
777        .send_ack       =       tcp_v6_reqsk_send_ack,
778        .destructor     =       tcp_v6_reqsk_destructor,
779        .send_reset     =       tcp_v6_send_reset,
780        .syn_ack_timeout =      tcp_syn_ack_timeout,
781};
782
783static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
784        .mss_clamp      =       IPV6_MIN_MTU - sizeof(struct tcphdr) -
785                                sizeof(struct ipv6hdr),
786#ifdef CONFIG_TCP_MD5SIG
787        .md5_lookup     =       tcp_v6_reqsk_md5_lookup,
788        .calc_md5_hash  =       tcp_v6_md5_hash_skb,
789#endif
790        .init_req       =       tcp_v6_init_req,
791#ifdef CONFIG_SYN_COOKIES
792        .cookie_init_seq =      cookie_v6_init_sequence,
793#endif
794        .route_req      =       tcp_v6_route_req,
795        .init_seq       =       tcp_v6_init_sequence,
796        .send_synack    =       tcp_v6_send_synack,
797        .queue_hash_add =       inet6_csk_reqsk_queue_hash_add,
798};
799
800static void tcp_v6_send_response(struct sock *sk, struct sk_buff *skb, u32 seq,
801                                 u32 ack, u32 win, u32 tsval, u32 tsecr,
802                                 int oif, struct tcp_md5sig_key *key, int rst,
803                                 u8 tclass, u32 label)
804{
805        const struct tcphdr *th = tcp_hdr(skb);
806        struct tcphdr *t1;
807        struct sk_buff *buff;
808        struct flowi6 fl6;
809        struct net *net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
810        struct sock *ctl_sk = net->ipv6.tcp_sk;
811        unsigned int tot_len = sizeof(struct tcphdr);
812        struct dst_entry *dst;
813        __be32 *topt;
814
815        if (tsecr)
816                tot_len += TCPOLEN_TSTAMP_ALIGNED;
817#ifdef CONFIG_TCP_MD5SIG
818        if (key)
819                tot_len += TCPOLEN_MD5SIG_ALIGNED;
820#endif
821
822        buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
823                         GFP_ATOMIC);
824        if (buff == NULL)
825                return;
826
827        skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
828
829        t1 = (struct tcphdr *) skb_push(buff, tot_len);
830        skb_reset_transport_header(buff);
831
832        /* Swap the send and the receive. */
833        memset(t1, 0, sizeof(*t1));
834        t1->dest = th->source;
835        t1->source = th->dest;
836        t1->doff = tot_len / 4;
837        t1->seq = htonl(seq);
838        t1->ack_seq = htonl(ack);
839        t1->ack = !rst || !th->ack;
840        t1->rst = rst;
841        t1->window = htons(win);
842
843        topt = (__be32 *)(t1 + 1);
844
845        if (tsecr) {
846                put_unaligned_be32((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
847                                (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP, topt++);
848                put_unaligned_be32(tsval, topt++);
849                put_unaligned_be32(tsecr, topt++);
850        }
851
852#ifdef CONFIG_TCP_MD5SIG
853        if (key) {
854                *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
855                                (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
856                tcp_v6_md5_hash_hdr((__u8 *)topt, key,
857                                    &ipv6_hdr(skb)->saddr,
858                                    &ipv6_hdr(skb)->daddr, t1);
859        }
860#endif
861
862        memset(&fl6, 0, sizeof(fl6));
863        fl6.daddr = ipv6_hdr(skb)->saddr;
864        fl6.saddr = ipv6_hdr(skb)->daddr;
865        fl6.flowlabel = label;
866
867        buff->ip_summed = CHECKSUM_PARTIAL;
868        buff->csum = 0;
869
870        __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
871
872        fl6.flowi6_proto = IPPROTO_TCP;
873        if (rt6_need_strict(&fl6.daddr) && !oif)
874                fl6.flowi6_oif = tcp_v6_iif(skb);
875        else
876                fl6.flowi6_oif = oif;
877        fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
878        fl6.fl6_dport = t1->dest;
879        fl6.fl6_sport = t1->source;
880        security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
881
882        /* Pass a socket to ip6_dst_lookup either it is for RST
883         * Underlying function will use this to retrieve the network
884         * namespace
885         */
886        dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
887        if (!IS_ERR(dst)) {
888                skb_dst_set(buff, dst);
889                ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
890                TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
891                if (rst)
892                        TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
893                return;
894        }
895
896        kfree_skb(buff);
897}
898
899static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
900{
901        const struct tcphdr *th = tcp_hdr(skb);
902        u32 seq = 0, ack_seq = 0;
903        struct tcp_md5sig_key *key = NULL;
904#ifdef CONFIG_TCP_MD5SIG
905        const __u8 *hash_location = NULL;
906        struct ipv6hdr *ipv6h = ipv6_hdr(skb);
907        unsigned char newhash[16];
908        int genhash;
909        struct sock *sk1 = NULL;
910#endif
911        int oif;
912
913        if (th->rst)
914                return;
915
916        /* If sk not NULL, it means we did a successful lookup and incoming
917         * route had to be correct. prequeue might have dropped our dst.
918         */
919        if (!sk && !ipv6_unicast_destination(skb))
920                return;
921
922#ifdef CONFIG_TCP_MD5SIG
923        hash_location = tcp_parse_md5sig_option(th);
924        if (!sk && hash_location) {
925                /*
926                 * active side is lost. Try to find listening socket through
927                 * source port, and then find md5 key through listening socket.
928                 * we are not loose security here:
929                 * Incoming packet is checked with md5 hash with finding key,
930                 * no RST generated if md5 hash doesn't match.
931                 */
932                sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
933                                           &tcp_hashinfo, &ipv6h->saddr,
934                                           th->source, &ipv6h->daddr,
935                                           ntohs(th->source), tcp_v6_iif(skb));
936                if (!sk1)
937                        return;
938
939                rcu_read_lock();
940                key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
941                if (!key)
942                        goto release_sk1;
943
944                genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
945                if (genhash || memcmp(hash_location, newhash, 16) != 0)
946                        goto release_sk1;
947        } else {
948                key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
949        }
950#endif
951
952        if (th->ack)
953                seq = ntohl(th->ack_seq);
954        else
955                ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
956                          (th->doff << 2);
957
958        oif = sk ? sk->sk_bound_dev_if : 0;
959        tcp_v6_send_response(sk, skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
960
961#ifdef CONFIG_TCP_MD5SIG
962release_sk1:
963        if (sk1) {
964                rcu_read_unlock();
965                sock_put(sk1);
966        }
967#endif
968}
969
970static void tcp_v6_send_ack(struct sock *sk, struct sk_buff *skb, u32 seq,
971                            u32 ack, u32 win, u32 tsval, u32 tsecr, int oif,
972                            struct tcp_md5sig_key *key, u8 tclass,
973                            u32 label)
974{
975        tcp_v6_send_response(sk, skb, seq, ack, win, tsval, tsecr, oif, key, 0,
976                             tclass, label);
977}
978
979static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
980{
981        struct inet_timewait_sock *tw = inet_twsk(sk);
982        struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
983
984        tcp_v6_send_ack(sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
985                        tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
986                        tcp_time_stamp + tcptw->tw_ts_offset,
987                        tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
988                        tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel));
989
990        inet_twsk_put(tw);
991}
992
993static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
994                                  struct request_sock *req)
995{
996        /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
997         * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
998         */
999        tcp_v6_send_ack(sk, skb, (sk->sk_state == TCP_LISTEN) ?
1000                        tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
1001                        tcp_rsk(req)->rcv_nxt, req->rcv_wnd,
1002                        tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
1003                        tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
1004                        0, 0);
1005}
1006
1007
1008static struct sock *tcp_v6_hnd_req(struct sock *sk, struct sk_buff *skb)
1009{
1010        struct request_sock *req, **prev;
1011        const struct tcphdr *th = tcp_hdr(skb);
1012        struct sock *nsk;
1013
1014        /* Find possible connection requests. */
1015        req = inet6_csk_search_req(sk, &prev, th->source,
1016                                   &ipv6_hdr(skb)->saddr,
1017                                   &ipv6_hdr(skb)->daddr, tcp_v6_iif(skb));
1018        if (req)
1019                return tcp_check_req(sk, skb, req, prev, false);
1020
1021        nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
1022                                         &ipv6_hdr(skb)->saddr, th->source,
1023                                         &ipv6_hdr(skb)->daddr, ntohs(th->dest),
1024                                         tcp_v6_iif(skb));
1025
1026        if (nsk) {
1027                if (nsk->sk_state != TCP_TIME_WAIT) {
1028                        bh_lock_sock(nsk);
1029                        return nsk;
1030                }
1031                inet_twsk_put(inet_twsk(nsk));
1032                return NULL;
1033        }
1034
1035#ifdef CONFIG_SYN_COOKIES
1036        if (!th->syn)
1037                sk = cookie_v6_check(sk, skb);
1038#endif
1039        return sk;
1040}
1041
1042static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1043{
1044        if (skb->protocol == htons(ETH_P_IP))
1045                return tcp_v4_conn_request(sk, skb);
1046
1047        if (!ipv6_unicast_destination(skb))
1048                goto drop;
1049
1050        return tcp_conn_request(&tcp6_request_sock_ops,
1051                                &tcp_request_sock_ipv6_ops, sk, skb);
1052
1053drop:
1054        NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1055        return 0; /* don't send reset */
1056}
1057
1058static void tcp_v6_restore_cb(struct sk_buff *skb)
1059{
1060        /* We need to move header back to the beginning if xfrm6_policy_check()
1061         * and tcp_v6_fill_cb() are going to be called again.
1062         * ip6_datagram_recv_specific_ctl() also expects IP6CB to be there.
1063         */
1064        memmove(IP6CB(skb), &TCP_SKB_CB(skb)->header.h6,
1065                sizeof(struct inet6_skb_parm));
1066}
1067
1068static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1069                                         struct request_sock *req,
1070                                         struct dst_entry *dst)
1071{
1072        struct inet_request_sock *ireq;
1073        struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1074        struct tcp6_sock *newtcp6sk;
1075        struct ipv6_txoptions *opt;
1076        struct inet_sock *newinet;
1077        struct tcp_sock *newtp;
1078        struct sock *newsk;
1079#ifdef CONFIG_TCP_MD5SIG
1080        struct tcp_md5sig_key *key;
1081#endif
1082        struct flowi6 fl6;
1083
1084        if (skb->protocol == htons(ETH_P_IP)) {
1085                /*
1086                 *      v6 mapped
1087                 */
1088
1089                newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1090
1091                if (newsk == NULL)
1092                        return NULL;
1093
1094                newtcp6sk = (struct tcp6_sock *)newsk;
1095                inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1096
1097                newinet = inet_sk(newsk);
1098                newnp = inet6_sk(newsk);
1099                newtp = tcp_sk(newsk);
1100
1101                memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1102
1103                ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
1104
1105                ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
1106
1107                newsk->sk_v6_rcv_saddr = newnp->saddr;
1108
1109                inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1110                newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1111#ifdef CONFIG_TCP_MD5SIG
1112                newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1113#endif
1114
1115                newnp->ipv6_ac_list = NULL;
1116                newnp->ipv6_fl_list = NULL;
1117                newnp->pktoptions  = NULL;
1118                newnp->opt         = NULL;
1119                newnp->mcast_oif   = tcp_v6_iif(skb);
1120                newnp->mcast_hops  = ipv6_hdr(skb)->hop_limit;
1121                newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
1122                if (np->repflow)
1123                        newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
1124
1125                /*
1126                 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1127                 * here, tcp_create_openreq_child now does this for us, see the comment in
1128                 * that function for the gory details. -acme
1129                 */
1130
1131                /* It is tricky place. Until this moment IPv4 tcp
1132                   worked with IPv6 icsk.icsk_af_ops.
1133                   Sync it now.
1134                 */
1135                tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1136
1137                return newsk;
1138        }
1139
1140        ireq = inet_rsk(req);
1141
1142        if (sk_acceptq_is_full(sk))
1143                goto out_overflow;
1144
1145        if (!dst) {
1146                dst = inet6_csk_route_req(sk, &fl6, req);
1147                if (!dst)
1148                        goto out;
1149        }
1150
1151        newsk = tcp_create_openreq_child(sk, req, skb);
1152        if (newsk == NULL)
1153                goto out_nonewsk;
1154
1155        /*
1156         * No need to charge this sock to the relevant IPv6 refcnt debug socks
1157         * count here, tcp_create_openreq_child now does this for us, see the
1158         * comment in that function for the gory details. -acme
1159         */
1160
1161        newsk->sk_gso_type = SKB_GSO_TCPV6;
1162        __ip6_dst_store(newsk, dst, NULL, NULL);
1163        inet6_sk_rx_dst_set(newsk, skb);
1164
1165        newtcp6sk = (struct tcp6_sock *)newsk;
1166        inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1167
1168        newtp = tcp_sk(newsk);
1169        newinet = inet_sk(newsk);
1170        newnp = inet6_sk(newsk);
1171
1172        memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1173
1174        newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1175        newnp->saddr = ireq->ir_v6_loc_addr;
1176        newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1177        newsk->sk_bound_dev_if = ireq->ir_iif;
1178
1179        ip6_set_txhash(newsk);
1180
1181        /* Now IPv6 options...
1182
1183           First: no IPv4 options.
1184         */
1185        newinet->inet_opt = NULL;
1186        newnp->ipv6_ac_list = NULL;
1187        newnp->ipv6_fl_list = NULL;
1188
1189        /* Clone RX bits */
1190        newnp->rxopt.all = np->rxopt.all;
1191
1192        /* Clone pktoptions received with SYN */
1193        newnp->pktoptions = NULL;
1194        if (ireq->pktopts != NULL) {
1195                newnp->pktoptions = skb_clone(ireq->pktopts,
1196                                              sk_gfp_atomic(sk, GFP_ATOMIC));
1197                consume_skb(ireq->pktopts);
1198                ireq->pktopts = NULL;
1199                if (newnp->pktoptions) {
1200                        tcp_v6_restore_cb(newnp->pktoptions);
1201                        skb_set_owner_r(newnp->pktoptions, newsk);
1202                }
1203        }
1204        newnp->opt        = NULL;
1205        newnp->mcast_oif  = tcp_v6_iif(skb);
1206        newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1207        newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
1208        if (np->repflow)
1209                newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
1210
1211        /* Clone native IPv6 options from listening socket (if any)
1212
1213           Yes, keeping reference count would be much more clever,
1214           but we make one more one thing there: reattach optmem
1215           to newsk.
1216         */
1217        opt = rcu_dereference(np->opt);
1218        if (opt) {
1219                opt = ipv6_dup_options(newsk, opt);
1220                RCU_INIT_POINTER(newnp->opt, opt);
1221        }
1222        inet_csk(newsk)->icsk_ext_hdr_len = 0;
1223        if (opt)
1224                inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +
1225                                                    opt->opt_flen;
1226
1227        tcp_sync_mss(newsk, dst_mtu(dst));
1228        newtp->advmss = dst_metric_advmss(dst);
1229        if (tcp_sk(sk)->rx_opt.user_mss &&
1230            tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1231                newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1232
1233        tcp_initialize_rcv_mss(newsk);
1234
1235        newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1236        newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
1237
1238#ifdef CONFIG_TCP_MD5SIG
1239        /* Copy over the MD5 key from the original socket */
1240        key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
1241        if (key != NULL) {
1242                /* We're using one, so create a matching key
1243                 * on the newsk structure. If we fail to get
1244                 * memory, then we end up not copying the key
1245                 * across. Shucks.
1246                 */
1247                tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
1248                               AF_INET6, key->key, key->keylen,
1249                               sk_gfp_atomic(sk, GFP_ATOMIC));
1250        }
1251#endif
1252
1253        if (__inet_inherit_port(sk, newsk) < 0) {
1254                inet_csk_prepare_forced_close(newsk);
1255                tcp_done(newsk);
1256                goto out;
1257        }
1258        __inet6_hash(newsk, NULL);
1259
1260        return newsk;
1261
1262out_overflow:
1263        NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1264out_nonewsk:
1265        dst_release(dst);
1266out:
1267        NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1268        return NULL;
1269}
1270
1271/* The socket must have it's spinlock held when we get
1272 * here.
1273 *
1274 * We have a potential double-lock case here, so even when
1275 * doing backlog processing we use the BH locking scheme.
1276 * This is because we cannot sleep with the original spinlock
1277 * held.
1278 */
1279static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1280{
1281        struct ipv6_pinfo *np = inet6_sk(sk);
1282        struct tcp_sock *tp;
1283        struct sk_buff *opt_skb = NULL;
1284
1285        /* Imagine: socket is IPv6. IPv4 packet arrives,
1286           goes to IPv4 receive handler and backlogged.
1287           From backlog it always goes here. Kerboom...
1288           Fortunately, tcp_rcv_established and rcv_established
1289           handle them correctly, but it is not case with
1290           tcp_v6_hnd_req and tcp_v6_send_reset().   --ANK
1291         */
1292
1293        if (skb->protocol == htons(ETH_P_IP))
1294                return tcp_v4_do_rcv(sk, skb);
1295
1296        if (sk_filter(sk, skb))
1297                goto discard;
1298
1299        /*
1300         *      socket locking is here for SMP purposes as backlog rcv
1301         *      is currently called with bh processing disabled.
1302         */
1303
1304        /* Do Stevens' IPV6_PKTOPTIONS.
1305
1306           Yes, guys, it is the only place in our code, where we
1307           may make it not affecting IPv4.
1308           The rest of code is protocol independent,
1309           and I do not like idea to uglify IPv4.
1310
1311           Actually, all the idea behind IPV6_PKTOPTIONS
1312           looks not very well thought. For now we latch
1313           options, received in the last packet, enqueued
1314           by tcp. Feel free to propose better solution.
1315                                               --ANK (980728)
1316         */
1317        if (np->rxopt.all)
1318                opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
1319
1320        if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1321                struct dst_entry *dst = sk->sk_rx_dst;
1322
1323                sock_rps_save_rxhash(sk, skb);
1324                if (dst) {
1325                        if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1326                            dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1327                                dst_release(dst);
1328                                sk->sk_rx_dst = NULL;
1329                        }
1330                }
1331
1332                tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
1333                if (opt_skb)
1334                        goto ipv6_pktoptions;
1335                return 0;
1336        }
1337
1338        if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
1339                goto csum_err;
1340
1341        if (sk->sk_state == TCP_LISTEN) {
1342                struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1343                if (!nsk)
1344                        goto discard;
1345
1346                /*
1347                 * Queue it on the new socket if the new socket is active,
1348                 * otherwise we just shortcircuit this and continue with
1349                 * the new socket..
1350                 */
1351                if (nsk != sk) {
1352                        sock_rps_save_rxhash(nsk, skb);
1353                        if (tcp_child_process(sk, nsk, skb))
1354                                goto reset;
1355                        if (opt_skb)
1356                                __kfree_skb(opt_skb);
1357                        return 0;
1358                }
1359        } else
1360                sock_rps_save_rxhash(sk, skb);
1361
1362        if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
1363                goto reset;
1364        if (opt_skb)
1365                goto ipv6_pktoptions;
1366        return 0;
1367
1368reset:
1369        tcp_v6_send_reset(sk, skb);
1370discard:
1371        if (opt_skb)
1372                __kfree_skb(opt_skb);
1373        kfree_skb(skb);
1374        return 0;
1375csum_err:
1376        TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
1377        TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
1378        goto discard;
1379
1380
1381ipv6_pktoptions:
1382        /* Do you ask, what is it?
1383
1384           1. skb was enqueued by tcp.
1385           2. skb is added to tail of read queue, rather than out of order.
1386           3. socket is not in passive state.
1387           4. Finally, it really contains options, which user wants to receive.
1388         */
1389        tp = tcp_sk(sk);
1390        if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1391            !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1392                if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
1393                        np->mcast_oif = tcp_v6_iif(opt_skb);
1394                if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1395                        np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1396                if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
1397                        np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
1398                if (np->repflow)
1399                        np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
1400                if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) {
1401                        skb_set_owner_r(opt_skb, sk);
1402                        tcp_v6_restore_cb(opt_skb);
1403                        opt_skb = xchg(&np->pktoptions, opt_skb);
1404                } else {
1405                        __kfree_skb(opt_skb);
1406                        opt_skb = xchg(&np->pktoptions, NULL);
1407                }
1408        }
1409
1410        kfree_skb(opt_skb);
1411        return 0;
1412}
1413
1414static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr,
1415                           const struct tcphdr *th)
1416{
1417        /* This is tricky: we move IP6CB at its correct location into
1418         * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because
1419         * _decode_session6() uses IP6CB().
1420         * barrier() makes sure compiler won't play aliasing games.
1421         */
1422        memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
1423                sizeof(struct inet6_skb_parm));
1424        barrier();
1425
1426        TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1427        TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1428                                    skb->len - th->doff*4);
1429        TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1430        TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
1431        TCP_SKB_CB(skb)->tcp_tw_isn = 0;
1432        TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
1433        TCP_SKB_CB(skb)->sacked = 0;
1434}
1435
1436static int tcp_v6_rcv(struct sk_buff *skb)
1437{
1438        const struct tcphdr *th;
1439        const struct ipv6hdr *hdr;
1440        struct sock *sk;
1441        int ret;
1442        struct net *net = dev_net(skb->dev);
1443
1444        if (skb->pkt_type != PACKET_HOST)
1445                goto discard_it;
1446
1447        /*
1448         *      Count it even if it's bad.
1449         */
1450        TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
1451
1452        if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1453                goto discard_it;
1454
1455        th = tcp_hdr(skb);
1456
1457        if (th->doff < sizeof(struct tcphdr)/4)
1458                goto bad_packet;
1459        if (!pskb_may_pull(skb, th->doff*4))
1460                goto discard_it;
1461
1462        if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
1463                goto csum_error;
1464
1465        th = tcp_hdr(skb);
1466        hdr = ipv6_hdr(skb);
1467
1468        sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest,
1469                                inet6_iif(skb));
1470        if (!sk)
1471                goto no_tcp_socket;
1472
1473process:
1474        if (sk->sk_state == TCP_TIME_WAIT)
1475                goto do_time_wait;
1476
1477        if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1478                NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1479                goto discard_and_relse;
1480        }
1481
1482        if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1483                goto discard_and_relse;
1484
1485        tcp_v6_fill_cb(skb, hdr, th);
1486
1487#ifdef CONFIG_TCP_MD5SIG
1488        if (tcp_v6_inbound_md5_hash(sk, skb))
1489                goto discard_and_relse;
1490#endif
1491
1492        if (sk_filter(sk, skb))
1493                goto discard_and_relse;
1494
1495        sk_mark_napi_id(sk, skb);
1496        skb->dev = NULL;
1497
1498        bh_lock_sock_nested(sk);
1499        ret = 0;
1500        if (!sock_owned_by_user(sk)) {
1501                if (!tcp_prequeue(sk, skb))
1502                        ret = tcp_v6_do_rcv(sk, skb);
1503        } else if (unlikely(sk_add_backlog(sk, skb,
1504                                           sk->sk_rcvbuf + sk->sk_sndbuf))) {
1505                bh_unlock_sock(sk);
1506                NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
1507                goto discard_and_relse;
1508        }
1509        bh_unlock_sock(sk);
1510
1511        sock_put(sk);
1512        return ret ? -1 : 0;
1513
1514no_tcp_socket:
1515        if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1516                goto discard_it;
1517
1518        tcp_v6_fill_cb(skb, hdr, th);
1519
1520        if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1521csum_error:
1522                TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
1523bad_packet:
1524                TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1525        } else {
1526                tcp_v6_send_reset(NULL, skb);
1527        }
1528
1529discard_it:
1530        kfree_skb(skb);
1531        return 0;
1532
1533discard_and_relse:
1534        sock_put(sk);
1535        goto discard_it;
1536
1537do_time_wait:
1538        if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1539                inet_twsk_put(inet_twsk(sk));
1540                goto discard_it;
1541        }
1542
1543        tcp_v6_fill_cb(skb, hdr, th);
1544
1545        if (skb->len < (th->doff<<2)) {
1546                inet_twsk_put(inet_twsk(sk));
1547                goto bad_packet;
1548        }
1549        if (tcp_checksum_complete(skb)) {
1550                inet_twsk_put(inet_twsk(sk));
1551                goto csum_error;
1552        }
1553
1554        switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1555        case TCP_TW_SYN:
1556        {
1557                struct sock *sk2;
1558
1559                sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
1560                                            &ipv6_hdr(skb)->saddr, th->source,
1561                                            &ipv6_hdr(skb)->daddr,
1562                                            ntohs(th->dest), tcp_v6_iif(skb));
1563                if (sk2 != NULL) {
1564                        struct inet_timewait_sock *tw = inet_twsk(sk);
1565                        inet_twsk_deschedule(tw, &tcp_death_row);
1566                        inet_twsk_put(tw);
1567                        sk = sk2;
1568                        tcp_v6_restore_cb(skb);
1569                        goto process;
1570                }
1571                /* Fall through to ACK */
1572        }
1573        case TCP_TW_ACK:
1574                tcp_v6_timewait_ack(sk, skb);
1575                break;
1576        case TCP_TW_RST:
1577                tcp_v6_restore_cb(skb);
1578                goto no_tcp_socket;
1579        case TCP_TW_SUCCESS:
1580                ;
1581        }
1582        goto discard_it;
1583}
1584
1585static void tcp_v6_early_demux(struct sk_buff *skb)
1586{
1587        const struct ipv6hdr *hdr;
1588        const struct tcphdr *th;
1589        struct sock *sk;
1590
1591        if (skb->pkt_type != PACKET_HOST)
1592                return;
1593
1594        if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1595                return;
1596
1597        hdr = ipv6_hdr(skb);
1598        th = tcp_hdr(skb);
1599
1600        if (th->doff < sizeof(struct tcphdr) / 4)
1601                return;
1602
1603        /* Note : We use inet6_iif() here, not tcp_v6_iif() */
1604        sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1605                                        &hdr->saddr, th->source,
1606                                        &hdr->daddr, ntohs(th->dest),
1607                                        inet6_iif(skb));
1608        if (sk) {
1609                skb->sk = sk;
1610                skb->destructor = sock_edemux;
1611                if (sk->sk_state != TCP_TIME_WAIT) {
1612                        struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst);
1613
1614                        if (dst)
1615                                dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
1616                        if (dst &&
1617                            inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
1618                                skb_dst_set_noref(skb, dst);
1619                }
1620        }
1621}
1622
1623static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1624        .twsk_obj_size  = sizeof(struct tcp6_timewait_sock),
1625        .twsk_unique    = tcp_twsk_unique,
1626        .twsk_destructor = tcp_twsk_destructor,
1627};
1628
1629static const struct inet_connection_sock_af_ops ipv6_specific = {
1630        .queue_xmit        = inet6_csk_xmit,
1631        .send_check        = tcp_v6_send_check,
1632        .rebuild_header    = inet6_sk_rebuild_header,
1633        .sk_rx_dst_set     = inet6_sk_rx_dst_set,
1634        .conn_request      = tcp_v6_conn_request,
1635        .syn_recv_sock     = tcp_v6_syn_recv_sock,
1636        .net_header_len    = sizeof(struct ipv6hdr),
1637        .net_frag_header_len = sizeof(struct frag_hdr),
1638        .setsockopt        = ipv6_setsockopt,
1639        .getsockopt        = ipv6_getsockopt,
1640        .addr2sockaddr     = inet6_csk_addr2sockaddr,
1641        .sockaddr_len      = sizeof(struct sockaddr_in6),
1642        .bind_conflict     = inet6_csk_bind_conflict,
1643#ifdef CONFIG_COMPAT
1644        .compat_setsockopt = compat_ipv6_setsockopt,
1645        .compat_getsockopt = compat_ipv6_getsockopt,
1646#endif
1647        .mtu_reduced       = tcp_v6_mtu_reduced,
1648};
1649
1650#ifdef CONFIG_TCP_MD5SIG
1651static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
1652        .md5_lookup     =       tcp_v6_md5_lookup,
1653        .calc_md5_hash  =       tcp_v6_md5_hash_skb,
1654        .md5_parse      =       tcp_v6_parse_md5_keys,
1655};
1656#endif
1657
1658/*
1659 *      TCP over IPv4 via INET6 API
1660 */
1661static const struct inet_connection_sock_af_ops ipv6_mapped = {
1662        .queue_xmit        = ip_queue_xmit,
1663        .send_check        = tcp_v4_send_check,
1664        .rebuild_header    = inet_sk_rebuild_header,
1665        .sk_rx_dst_set     = inet_sk_rx_dst_set,
1666        .conn_request      = tcp_v6_conn_request,
1667        .syn_recv_sock     = tcp_v6_syn_recv_sock,
1668        .net_header_len    = sizeof(struct iphdr),
1669        .setsockopt        = ipv6_setsockopt,
1670        .getsockopt        = ipv6_getsockopt,
1671        .addr2sockaddr     = inet6_csk_addr2sockaddr,
1672        .sockaddr_len      = sizeof(struct sockaddr_in6),
1673        .bind_conflict     = inet6_csk_bind_conflict,
1674#ifdef CONFIG_COMPAT
1675        .compat_setsockopt = compat_ipv6_setsockopt,
1676        .compat_getsockopt = compat_ipv6_getsockopt,
1677#endif
1678        .mtu_reduced       = tcp_v4_mtu_reduced,
1679};
1680
1681#ifdef CONFIG_TCP_MD5SIG
1682static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
1683        .md5_lookup     =       tcp_v4_md5_lookup,
1684        .calc_md5_hash  =       tcp_v4_md5_hash_skb,
1685        .md5_parse      =       tcp_v6_parse_md5_keys,
1686};
1687#endif
1688
1689/* NOTE: A lot of things set to zero explicitly by call to
1690 *       sk_alloc() so need not be done here.
1691 */
1692static int tcp_v6_init_sock(struct sock *sk)
1693{
1694        struct inet_connection_sock *icsk = inet_csk(sk);
1695
1696        tcp_init_sock(sk);
1697
1698        icsk->icsk_af_ops = &ipv6_specific;
1699
1700#ifdef CONFIG_TCP_MD5SIG
1701        tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
1702#endif
1703
1704        return 0;
1705}
1706
1707static void tcp_v6_destroy_sock(struct sock *sk)
1708{
1709        tcp_v4_destroy_sock(sk);
1710        inet6_destroy_sock(sk);
1711}
1712
1713#ifdef CONFIG_PROC_FS
1714/* Proc filesystem TCPv6 sock list dumping. */
1715static void get_openreq6(struct seq_file *seq,
1716                         const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
1717{
1718        int ttd = req->expires - jiffies;
1719        const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1720        const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
1721
1722        if (ttd < 0)
1723                ttd = 0;
1724
1725        seq_printf(seq,
1726                   "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1727                   "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
1728                   i,
1729                   src->s6_addr32[0], src->s6_addr32[1],
1730                   src->s6_addr32[2], src->s6_addr32[3],
1731                   inet_rsk(req)->ir_num,
1732                   dest->s6_addr32[0], dest->s6_addr32[1],
1733                   dest->s6_addr32[2], dest->s6_addr32[3],
1734                   ntohs(inet_rsk(req)->ir_rmt_port),
1735                   TCP_SYN_RECV,
1736                   0, 0, /* could print option size, but that is af dependent. */
1737                   1,   /* timers active (only the expire timer) */
1738                   jiffies_to_clock_t(ttd),
1739                   req->num_timeout,
1740                   from_kuid_munged(seq_user_ns(seq), uid),
1741                   0,  /* non standard timer */
1742                   0, /* open_requests have no inode */
1743                   0, req);
1744}
1745
1746static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1747{
1748        const struct in6_addr *dest, *src;
1749        __u16 destp, srcp;
1750        int timer_active;
1751        unsigned long timer_expires;
1752        const struct inet_sock *inet = inet_sk(sp);
1753        const struct tcp_sock *tp = tcp_sk(sp);
1754        const struct inet_connection_sock *icsk = inet_csk(sp);
1755        struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
1756
1757        dest  = &sp->sk_v6_daddr;
1758        src   = &sp->sk_v6_rcv_saddr;
1759        destp = ntohs(inet->inet_dport);
1760        srcp  = ntohs(inet->inet_sport);
1761
1762        if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
1763            icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
1764            icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
1765                timer_active    = 1;
1766                timer_expires   = icsk->icsk_timeout;
1767        } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1768                timer_active    = 4;
1769                timer_expires   = icsk->icsk_timeout;
1770        } else if (timer_pending(&sp->sk_timer)) {
1771                timer_active    = 2;
1772                timer_expires   = sp->sk_timer.expires;
1773        } else {
1774                timer_active    = 0;
1775                timer_expires = jiffies;
1776        }
1777
1778        seq_printf(seq,
1779                   "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1780                   "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
1781                   i,
1782                   src->s6_addr32[0], src->s6_addr32[1],
1783                   src->s6_addr32[2], src->s6_addr32[3], srcp,
1784                   dest->s6_addr32[0], dest->s6_addr32[1],
1785                   dest->s6_addr32[2], dest->s6_addr32[3], destp,
1786                   sp->sk_state,
1787                   tp->write_seq-tp->snd_una,
1788                   (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
1789                   timer_active,
1790                   jiffies_delta_to_clock_t(timer_expires - jiffies),
1791                   icsk->icsk_retransmits,
1792                   from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
1793                   icsk->icsk_probes_out,
1794                   sock_i_ino(sp),
1795                   atomic_read(&sp->sk_refcnt), sp,
1796                   jiffies_to_clock_t(icsk->icsk_rto),
1797                   jiffies_to_clock_t(icsk->icsk_ack.ato),
1798                   (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1799                   tp->snd_cwnd,
1800                   sp->sk_state == TCP_LISTEN ?
1801                        (fastopenq ? fastopenq->max_qlen : 0) :
1802                        (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
1803                   );
1804}
1805
1806static void get_timewait6_sock(struct seq_file *seq,
1807                               struct inet_timewait_sock *tw, int i)
1808{
1809        const struct in6_addr *dest, *src;
1810        __u16 destp, srcp;
1811        s32 delta = tw->tw_ttd - inet_tw_time_stamp();
1812
1813        dest = &tw->tw_v6_daddr;
1814        src  = &tw->tw_v6_rcv_saddr;
1815        destp = ntohs(tw->tw_dport);
1816        srcp  = ntohs(tw->tw_sport);
1817
1818        seq_printf(seq,
1819                   "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1820                   "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
1821                   i,
1822                   src->s6_addr32[0], src->s6_addr32[1],
1823                   src->s6_addr32[2], src->s6_addr32[3], srcp,
1824                   dest->s6_addr32[0], dest->s6_addr32[1],
1825                   dest->s6_addr32[2], dest->s6_addr32[3], destp,
1826                   tw->tw_substate, 0, 0,
1827                   3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
1828                   atomic_read(&tw->tw_refcnt), tw);
1829}
1830
1831static int tcp6_seq_show(struct seq_file *seq, void *v)
1832{
1833        struct tcp_iter_state *st;
1834        struct sock *sk = v;
1835
1836        if (v == SEQ_START_TOKEN) {
1837                seq_puts(seq,
1838                         "  sl  "
1839                         "local_address                         "
1840                         "remote_address                        "
1841                         "st tx_queue rx_queue tr tm->when retrnsmt"
1842                         "   uid  timeout inode\n");
1843                goto out;
1844        }
1845        st = seq->private;
1846
1847        switch (st->state) {
1848        case TCP_SEQ_STATE_LISTENING:
1849        case TCP_SEQ_STATE_ESTABLISHED:
1850                if (sk->sk_state == TCP_TIME_WAIT)
1851                        get_timewait6_sock(seq, v, st->num);
1852                else
1853                        get_tcp6_sock(seq, v, st->num);
1854                break;
1855        case TCP_SEQ_STATE_OPENREQ:
1856                get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1857                break;
1858        }
1859out:
1860        return 0;
1861}
1862
1863static const struct file_operations tcp6_afinfo_seq_fops = {
1864        .owner   = THIS_MODULE,
1865        .open    = tcp_seq_open,
1866        .read    = seq_read,
1867        .llseek  = seq_lseek,
1868        .release = seq_release_net
1869};
1870
1871static struct tcp_seq_afinfo tcp6_seq_afinfo = {
1872        .name           = "tcp6",
1873        .family         = AF_INET6,
1874        .seq_fops       = &tcp6_afinfo_seq_fops,
1875        .seq_ops        = {
1876                .show           = tcp6_seq_show,
1877        },
1878};
1879
1880int __net_init tcp6_proc_init(struct net *net)
1881{
1882        return tcp_proc_register(net, &tcp6_seq_afinfo);
1883}
1884
1885void tcp6_proc_exit(struct net *net)
1886{
1887        tcp_proc_unregister(net, &tcp6_seq_afinfo);
1888}
1889#endif
1890
1891static void tcp_v6_clear_sk(struct sock *sk, int size)
1892{
1893        struct inet_sock *inet = inet_sk(sk);
1894
1895        /* we do not want to clear pinet6 field, because of RCU lookups */
1896        sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1897
1898        size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1899        memset(&inet->pinet6 + 1, 0, size);
1900}
1901
1902struct proto tcpv6_prot = {
1903        .name                   = "TCPv6",
1904        .owner                  = THIS_MODULE,
1905        .close                  = tcp_close,
1906        .connect                = tcp_v6_connect,
1907        .disconnect             = tcp_disconnect,
1908        .accept                 = inet_csk_accept,
1909        .ioctl                  = tcp_ioctl,
1910        .init                   = tcp_v6_init_sock,
1911        .destroy                = tcp_v6_destroy_sock,
1912        .shutdown               = tcp_shutdown,
1913        .setsockopt             = tcp_setsockopt,
1914        .getsockopt             = tcp_getsockopt,
1915        .recvmsg                = tcp_recvmsg,
1916        .sendmsg                = tcp_sendmsg,
1917        .sendpage               = tcp_sendpage,
1918        .backlog_rcv            = tcp_v6_do_rcv,
1919        .release_cb             = tcp_release_cb,
1920        .hash                   = tcp_v6_hash,
1921        .unhash                 = inet_unhash,
1922        .get_port               = inet_csk_get_port,
1923        .enter_memory_pressure  = tcp_enter_memory_pressure,
1924        .stream_memory_free     = tcp_stream_memory_free,
1925        .sockets_allocated      = &tcp_sockets_allocated,
1926        .memory_allocated       = &tcp_memory_allocated,
1927        .memory_pressure        = &tcp_memory_pressure,
1928        .orphan_count           = &tcp_orphan_count,
1929        .sysctl_mem             = sysctl_tcp_mem,
1930        .sysctl_wmem            = sysctl_tcp_wmem,
1931        .sysctl_rmem            = sysctl_tcp_rmem,
1932        .max_header             = MAX_TCP_HEADER,
1933        .obj_size               = sizeof(struct tcp6_sock),
1934        .slab_flags             = SLAB_DESTROY_BY_RCU,
1935        .twsk_prot              = &tcp6_timewait_sock_ops,
1936        .rsk_prot               = &tcp6_request_sock_ops,
1937        .h.hashinfo             = &tcp_hashinfo,
1938        .no_autobind            = true,
1939#ifdef CONFIG_COMPAT
1940        .compat_setsockopt      = compat_tcp_setsockopt,
1941        .compat_getsockopt      = compat_tcp_getsockopt,
1942#endif
1943#ifdef CONFIG_MEMCG_KMEM
1944        .proto_cgroup           = tcp_proto_cgroup,
1945#endif
1946        .clear_sk               = tcp_v6_clear_sk,
1947};
1948
1949static const struct inet6_protocol tcpv6_protocol = {
1950        .early_demux    =       tcp_v6_early_demux,
1951        .handler        =       tcp_v6_rcv,
1952        .err_handler    =       tcp_v6_err,
1953        .flags          =       INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1954};
1955
1956static struct inet_protosw tcpv6_protosw = {
1957        .type           =       SOCK_STREAM,
1958        .protocol       =       IPPROTO_TCP,
1959        .prot           =       &tcpv6_prot,
1960        .ops            =       &inet6_stream_ops,
1961        .flags          =       INET_PROTOSW_PERMANENT |
1962                                INET_PROTOSW_ICSK,
1963};
1964
1965static int __net_init tcpv6_net_init(struct net *net)
1966{
1967        return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1968                                    SOCK_RAW, IPPROTO_TCP, net);
1969}
1970
1971static void __net_exit tcpv6_net_exit(struct net *net)
1972{
1973        inet_ctl_sock_destroy(net->ipv6.tcp_sk);
1974}
1975
1976static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
1977{
1978        inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
1979}
1980
1981static struct pernet_operations tcpv6_net_ops = {
1982        .init       = tcpv6_net_init,
1983        .exit       = tcpv6_net_exit,
1984        .exit_batch = tcpv6_net_exit_batch,
1985};
1986
1987int __init tcpv6_init(void)
1988{
1989        int ret;
1990
1991        ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1992        if (ret)
1993                goto out;
1994
1995        /* register inet6 protocol */
1996        ret = inet6_register_protosw(&tcpv6_protosw);
1997        if (ret)
1998                goto out_tcpv6_protocol;
1999
2000        ret = register_pernet_subsys(&tcpv6_net_ops);
2001        if (ret)
2002                goto out_tcpv6_protosw;
2003out:
2004        return ret;
2005
2006out_tcpv6_protosw:
2007        inet6_unregister_protosw(&tcpv6_protosw);
2008out_tcpv6_protocol:
2009        inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2010        goto out;
2011}
2012
2013void tcpv6_exit(void)
2014{
2015        unregister_pernet_subsys(&tcpv6_net_ops);
2016        inet6_unregister_protosw(&tcpv6_protosw);
2017        inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2018}
Note: See TracBrowser for help on using the repository browser.