net/ipv6/tcp_ipv6.c

   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
  43 #include <linux/ipv6.h>
  44 #include <linux/icmpv6.h>
  45 #include <linux/random.h>
  46
  47 #include <net/tcp.h>
  48 #include <net/ndisc.h>
  49 #include <net/inet6_hashtables.h>
  50 #include <net/inet6_connection_sock.h>
  51 #include <net/ipv6.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>
  58 #include <net/xfrm.h>
  59 #include <net/snmp.h>
  60 #include <net/dsfield.h>
  61 #include <net/timewait_sock.h>
  62 #include <net/netdma.h>
  63 #include <net/inet_common.h>
  64 #include <net/secure_seq.h>
  65
  66 #include <asm/uaccess.h>
  67
  68 #include <linux/proc_fs.h>
  69 #include <linux/seq_file.h>
  70
  71 #include <linux/crypto.h>
  72 #include <linux/scatterlist.h>
  73
  74 static void     tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
  75 static void     tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
  76                                       struct request_sock *req);
  77
  78 static int      tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
  79 static void     __tcp_v6_send_check(struct sk_buff *skb,
  80                                     const struct in6_addr *saddr,
  81                                     const struct in6_addr *daddr);
  82
  83 static const struct inet_connection_sock_af_ops ipv6_mapped;
  84 static const struct inet_connection_sock_af_ops ipv6_specific;
  85 #ifdef CONFIG_TCP_MD5SIG
  86 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
  87 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
  88 #else
  89 static 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
  96 static void tcp_v6_hash(struct sock *sk)
  97 {
  98         if (sk->sk_state != TCP_CLOSE) {
  99                 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
 100                         tcp_prot.hash(sk);
 101                         return;
 102                 }
 103                 local_bh_disable();
 104                 __inet6_hash(sk, NULL);
 105                 local_bh_enable();
 106         }
 107 }
 108
 109 static __inline__ __sum16 tcp_v6_check(int len,
 110                                    const struct in6_addr *saddr,
 111                                    const struct in6_addr *daddr,
 112                                    __wsum base)
 113 {
 114         return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
 115 }
 116
 117 static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
 118 {
 119         return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
 120                                             ipv6_hdr(skb)->saddr.s6_addr32,
 121                                             tcp_hdr(skb)->dest,
 122                                             tcp_hdr(skb)->source);
 123 }
 124
 125 static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
 126                           int addr_len)
 127 {
 128         struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
 129         struct inet_sock *inet = inet_sk(sk);
 130         struct inet_connection_sock *icsk = inet_csk(sk);
 131         struct ipv6_pinfo *np = inet6_sk(sk);
 132         struct tcp_sock *tp = tcp_sk(sk);
 133         struct in6_addr *saddr = NULL, *final_p, final;
 134         struct rt6_info *rt;
 135         struct flowi6 fl6;
 136         struct dst_entry *dst;
 137         int addr_type;
 138         int err;
 139
 140         if (addr_len < SIN6_LEN_RFC2133)
 141                 return -EINVAL;
 142
 143         if (usin->sin6_family != AF_INET6)
 144                 return -EAFNOSUPPORT;
 145
 146         memset(&fl6, 0, sizeof(fl6));
 147
 148         if (np->sndflow) {
 149                 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
 150                 IP6_ECN_flow_init(fl6.flowlabel);
 151                 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
 152                         struct ip6_flowlabel *flowlabel;
 153                         flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
 154                         if (flowlabel == NULL)
 155                                 return -EINVAL;
 156                         ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
 157                         fl6_sock_release(flowlabel);
 158                 }
 159         }
 160
 161         /*
 162          *      connect() to INADDR_ANY means loopback (BSD'ism).
 163          */
 164
 165         if(ipv6_addr_any(&usin->sin6_addr))
 166                 usin->sin6_addr.s6_addr[15] = 0x1;
 167
 168         addr_type = ipv6_addr_type(&usin->sin6_addr);
 169
 170         if(addr_type & IPV6_ADDR_MULTICAST)
 171                 return -ENETUNREACH;
 172
 173         if (addr_type&IPV6_ADDR_LINKLOCAL) {
 174                 if (addr_len >= sizeof(struct sockaddr_in6) &&
 175                     usin->sin6_scope_id) {
 176                         /* If interface is set while binding, indices
 177                          * must coincide.
 178                          */
 179                         if (sk->sk_bound_dev_if &&
 180                             sk->sk_bound_dev_if != usin->sin6_scope_id)
 181                                 return -EINVAL;
 182
 183                         sk->sk_bound_dev_if = usin->sin6_scope_id;
 184                 }
 185
 186                 /* Connect to link-local address requires an interface */
 187                 if (!sk->sk_bound_dev_if)
 188                         return -EINVAL;
 189         }
 190
 191         if (tp->rx_opt.ts_recent_stamp &&
 192             !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
 193                 tp->rx_opt.ts_recent = 0;
 194                 tp->rx_opt.ts_recent_stamp = 0;
 195                 tp->write_seq = 0;
 196         }
 197
 198         ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
 199         np->flow_label = fl6.flowlabel;
 200
 201         /*
 202          *      TCP over IPv4
 203          */
 204
 205         if (addr_type == IPV6_ADDR_MAPPED) {
 206                 u32 exthdrlen = icsk->icsk_ext_hdr_len;
 207                 struct sockaddr_in sin;
 208
 209                 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
 210
 211                 if (__ipv6_only_sock(sk))
 212                         return -ENETUNREACH;
 213
 214                 sin.sin_family = AF_INET;
 215                 sin.sin_port = usin->sin6_port;
 216                 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
 217
 218                 icsk->icsk_af_ops = &ipv6_mapped;
 219                 sk->sk_backlog_rcv = tcp_v4_do_rcv;
 220 #ifdef CONFIG_TCP_MD5SIG
 221                 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
 222 #endif
 223
 224                 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
 225
 226                 if (err) {
 227                         icsk->icsk_ext_hdr_len = exthdrlen;
 228                         icsk->icsk_af_ops = &ipv6_specific;
 229                         sk->sk_backlog_rcv = tcp_v6_do_rcv;
 230 #ifdef CONFIG_TCP_MD5SIG
 231                         tp->af_specific = &tcp_sock_ipv6_specific;
 232 #endif
 233                         goto failure;
 234                 } else {
 235                         ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
 236                         ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
 237                                                &np->rcv_saddr);
 238                 }
 239
 240                 return err;
 241         }
 242
 243         if (!ipv6_addr_any(&np->rcv_saddr))
 244                 saddr = &np->rcv_saddr;
 245
 246         fl6.flowi6_proto = IPPROTO_TCP;
 247         ipv6_addr_copy(&fl6.daddr, &np->daddr);
 248         ipv6_addr_copy(&fl6.saddr,
 249                        (saddr ? saddr : &np->saddr));
 250         fl6.flowi6_oif = sk->sk_bound_dev_if;
 251         fl6.flowi6_mark = sk->sk_mark;
 252         fl6.fl6_dport = usin->sin6_port;
 253         fl6.fl6_sport = inet->inet_sport;
 254
 255         final_p = fl6_update_dst(&fl6, np->opt, &final);
 256
 257         security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
 258
 259         dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
 260         if (IS_ERR(dst)) {
 261                 err = PTR_ERR(dst);
 262                 goto failure;
 263         }
 264
 265         if (saddr == NULL) {
 266                 saddr = &fl6.saddr;
 267                 ipv6_addr_copy(&np->rcv_saddr, saddr);
 268         }
 269
 270         /* set the source address */
 271         ipv6_addr_copy(&np->saddr, saddr);
 272         inet->inet_rcv_saddr = LOOPBACK4_IPV6;
 273
 274         sk->sk_gso_type = SKB_GSO_TCPV6;
 275         __ip6_dst_store(sk, dst, NULL, NULL);
 276
 277         rt = (struct rt6_info *) dst;
 278         if (tcp_death_row.sysctl_tw_recycle &&
 279             !tp->rx_opt.ts_recent_stamp &&
 280             ipv6_addr_equal(&rt->rt6i_dst.addr, &np->daddr)) {
 281                 struct inet_peer *peer = rt6_get_peer(rt);
 282                 /*
 283                  * VJ's idea. We save last timestamp seen from
 284                  * the destination in peer table, when entering state
 285                  * TIME-WAIT * and initialize rx_opt.ts_recent from it,
 286                  * when trying new connection.
 287                  */
 288                 if (peer) {
 289                         inet_peer_refcheck(peer);
 290                         if ((u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) {
 291                                 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
 292                                 tp->rx_opt.ts_recent = peer->tcp_ts;
 293                         }
 294                 }
 295         }
 296
 297         icsk->icsk_ext_hdr_len = 0;
 298         if (np->opt)
 299                 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
 300                                           np->opt->opt_nflen);
 301
 302         tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
 303
 304         inet->inet_dport = usin->sin6_port;
 305
 306         tcp_set_state(sk, TCP_SYN_SENT);
 307         err = inet6_hash_connect(&tcp_death_row, sk);
 308         if (err)
 309                 goto late_failure;
 310
 311         if (!tp->write_seq)
 312                 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
 313                                                              np->daddr.s6_addr32,
 314                                                              inet->inet_sport,
 315                                                              inet->inet_dport);
 316
 317         err = tcp_connect(sk);
 318         if (err)
 319                 goto late_failure;
 320
 321         return 0;
 322
 323 late_failure:
 324         tcp_set_state(sk, TCP_CLOSE);
 325         __sk_dst_reset(sk);
 326 failure:
 327         inet->inet_dport = 0;
 328         sk->sk_route_caps = 0;
 329         return err;
 330 }
 331
 332 static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 333                 u8 type, u8 code, int offset, __be32 info)
 334 {
 335         const struct ipv6hdr *hdr = (const struct ipv6hdr*)skb->data;
 336         const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
 337         struct ipv6_pinfo *np;
 338         struct sock *sk;
 339         int err;
 340         struct tcp_sock *tp;
 341         __u32 seq;
 342         struct net *net = dev_net(skb->dev);
 343
 344         sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
 345                         th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
 346
 347         if (sk == NULL) {
 348                 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
 349                                    ICMP6_MIB_INERRORS);
 350                 return;
 351         }
 352
 353         if (sk->sk_state == TCP_TIME_WAIT) {
 354                 inet_twsk_put(inet_twsk(sk));
 355                 return;
 356         }
 357
 358         bh_lock_sock(sk);
 359         if (sock_owned_by_user(sk))
 360                 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
 361
 362         if (sk->sk_state == TCP_CLOSE)
 363                 goto out;
 364
 365         if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
 366                 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
 367                 goto out;
 368         }
 369
 370         tp = tcp_sk(sk);
 371         seq = ntohl(th->seq);
 372         if (sk->sk_state != TCP_LISTEN &&
 373             !between(seq, tp->snd_una, tp->snd_nxt)) {
 374                 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
 375                 goto out;
 376         }
 377
 378         np = inet6_sk(sk);
 379
 380         if (type == ICMPV6_PKT_TOOBIG) {
 381                 struct dst_entry *dst;
 382
 383                 if (sock_owned_by_user(sk))
 384                         goto out;
 385                 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
 386                         goto out;
 387
 388                 /* icmp should have updated the destination cache entry */
 389                 dst = __sk_dst_check(sk, np->dst_cookie);
 390
 391                 if (dst == NULL) {
 392                         struct inet_sock *inet = inet_sk(sk);
 393                         struct flowi6 fl6;
 394
 395                         /* BUGGG_FUTURE: Again, it is not clear how
 396                            to handle rthdr case. Ignore this complexity
 397                            for now.
 398                          */
 399                         memset(&fl6, 0, sizeof(fl6));
 400                         fl6.flowi6_proto = IPPROTO_TCP;
 401                         ipv6_addr_copy(&fl6.daddr, &np->daddr);
 402                         ipv6_addr_copy(&fl6.saddr, &np->saddr);
 403                         fl6.flowi6_oif = sk->sk_bound_dev_if;
 404                         fl6.flowi6_mark = sk->sk_mark;
 405                         fl6.fl6_dport = inet->inet_dport;
 406                         fl6.fl6_sport = inet->inet_sport;
 407                         security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
 408
 409                         dst = ip6_dst_lookup_flow(sk, &fl6, NULL, false);
 410                         if (IS_ERR(dst)) {
 411                                 sk->sk_err_soft = -PTR_ERR(dst);
 412                                 goto out;
 413                         }
 414
 415                 } else
 416                         dst_hold(dst);
 417
 418                 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
 419                         tcp_sync_mss(sk, dst_mtu(dst));
 420                         tcp_simple_retransmit(sk);
 421                 } /* else let the usual retransmit timer handle it */
 422                 dst_release(dst);
 423                 goto out;
 424         }
 425
 426         icmpv6_err_convert(type, code, &err);
 427
 428         /* Might be for an request_sock */
 429         switch (sk->sk_state) {
 430                 struct request_sock *req, **prev;
 431         case TCP_LISTEN:
 432                 if (sock_owned_by_user(sk))
 433                         goto out;
 434
 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                 goto out;
 452
 453         case TCP_SYN_SENT:
 454         case TCP_SYN_RECV:  /* Cannot happen.
 455                                It can, it SYNs are crossed. --ANK */
 456                 if (!sock_owned_by_user(sk)) {
 457                         sk->sk_err = err;
 458                         sk->sk_error_report(sk);                /* Wake people up to see the error (see connect in sock.c) */
 459
 460                         tcp_done(sk);
 461                 } else
 462                         sk->sk_err_soft = err;
 463                 goto out;
 464         }
 465
 466         if (!sock_owned_by_user(sk) && np->recverr) {
 467                 sk->sk_err = err;
 468                 sk->sk_error_report(sk);
 469         } else
 470                 sk->sk_err_soft = err;
 471
 472 out:
 473         bh_unlock_sock(sk);
 474         sock_put(sk);
 475 }
 476
 477
 478 static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
 479                               struct request_values *rvp)
 480 {
 481         struct inet6_request_sock *treq = inet6_rsk(req);
 482         struct ipv6_pinfo *np = inet6_sk(sk);
 483         struct sk_buff * skb;
 484         struct ipv6_txoptions *opt = NULL;
 485         struct in6_addr * final_p, final;
 486         struct flowi6 fl6;
 487         struct dst_entry *dst;
 488         int err;
 489
 490         memset(&fl6, 0, sizeof(fl6));
 491         fl6.flowi6_proto = IPPROTO_TCP;
 492         ipv6_addr_copy(&fl6.daddr, &treq->rmt_addr);
 493         ipv6_addr_copy(&fl6.saddr, &treq->loc_addr);
 494         fl6.flowlabel = 0;
 495         fl6.flowi6_oif = treq->iif;
 496         fl6.flowi6_mark = sk->sk_mark;
 497         fl6.fl6_dport = inet_rsk(req)->rmt_port;
 498         fl6.fl6_sport = inet_rsk(req)->loc_port;
 499         security_req_classify_flow(req, flowi6_to_flowi(&fl6));
 500
 501         opt = np->opt;
 502         final_p = fl6_update_dst(&fl6, opt, &final);
 503
 504         dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);
 505         if (IS_ERR(dst)) {
 506                 err = PTR_ERR(dst);
 507                 dst = NULL;
 508                 goto done;
 509         }
 510         skb = tcp_make_synack(sk, dst, req, rvp);
 511         err = -ENOMEM;
 512         if (skb) {
 513                 __tcp_v6_send_check(skb, &treq->loc_addr, &treq->rmt_addr);
 514
 515                 ipv6_addr_copy(&fl6.daddr, &treq->rmt_addr);
 516                 err = ip6_xmit(sk, skb, &fl6, opt, np->tclass);
 517                 err = net_xmit_eval(err);
 518         }
 519
 520 done:
 521         if (opt && opt != np->opt)
 522                 sock_kfree_s(sk, opt, opt->tot_len);
 523         dst_release(dst);
 524         return err;
 525 }
 526
 527 static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req,
 528                              struct request_values *rvp)
 529 {
 530         TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
 531         return tcp_v6_send_synack(sk, req, rvp);
 532 }
 533
 534 static void tcp_v6_reqsk_destructor(struct request_sock *req)
 535 {
 536         kfree_skb(inet6_rsk(req)->pktopts);
 537 }
 538
 539 #ifdef CONFIG_TCP_MD5SIG
 540 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
 541                                                    const struct in6_addr *addr)
 542 {
 543         struct tcp_sock *tp = tcp_sk(sk);
 544         int i;
 545
 546         BUG_ON(tp == NULL);
 547
 548         if (!tp->md5sig_info || !tp->md5sig_info->entries6)
 549                 return NULL;
 550
 551         for (i = 0; i < tp->md5sig_info->entries6; i++) {
 552                 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, addr))
 553                         return &tp->md5sig_info->keys6[i].base;
 554         }
 555         return NULL;
 556 }
 557
 558 static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
 559                                                 struct sock *addr_sk)
 560 {
 561         return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
 562 }
 563
 564 static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
 565                                                       struct request_sock *req)
 566 {
 567         return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
 568 }
 569
 570 static int tcp_v6_md5_do_add(struct sock *sk, const struct in6_addr *peer,
 571                              char *newkey, u8 newkeylen)
 572 {
 573         /* Add key to the list */
 574         struct tcp_md5sig_key *key;
 575         struct tcp_sock *tp = tcp_sk(sk);
 576         struct tcp6_md5sig_key *keys;
 577
 578         key = tcp_v6_md5_do_lookup(sk, peer);
 579         if (key) {
 580                 /* modify existing entry - just update that one */
 581                 kfree(key->key);
 582                 key->key = newkey;
 583                 key->keylen = newkeylen;
 584         } else {
 585                 /* reallocate new list if current one is full. */
 586                 if (!tp->md5sig_info) {
 587                         tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
 588                         if (!tp->md5sig_info) {
 589                                 kfree(newkey);
 590                                 return -ENOMEM;
 591                         }
 592                         sk_nocaps_add(sk, NETIF_F_GSO_MASK);
 593                 }
 594                 if (tp->md5sig_info->entries6 == 0 &&
 595                     !tcp_alloc_md5sig_pool()) {
 596                         kfree(newkey);
 597                         return -ENOMEM;
 598                 }
 599                 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
 600                         keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
 601                                        (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
 602
 603                         if (!keys) {
 604                                 kfree(newkey);
 605                                 return -ENOMEM;
 606                         }
 607
 608                         if (tp->md5sig_info->entries6)
 609                                 memmove(keys, tp->md5sig_info->keys6,
 610                                         (sizeof (tp->md5sig_info->keys6[0]) *
 611                                          tp->md5sig_info->entries6));
 612
 613                         kfree(tp->md5sig_info->keys6);
 614                         tp->md5sig_info->keys6 = keys;
 615                         tp->md5sig_info->alloced6++;
 616                 }
 617
 618                 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
 619                                peer);
 620                 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.key = newkey;
 621                 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.keylen = newkeylen;
 622
 623                 tp->md5sig_info->entries6++;
 624         }
 625         return 0;
 626 }
 627
 628 static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
 629                                u8 *newkey, __u8 newkeylen)
 630 {
 631         return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
 632                                  newkey, newkeylen);
 633 }
 634
 635 static int tcp_v6_md5_do_del(struct sock *sk, const struct in6_addr *peer)
 636 {
 637         struct tcp_sock *tp = tcp_sk(sk);
 638         int i;
 639
 640         for (i = 0; i < tp->md5sig_info->entries6; i++) {
 641                 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, peer)) {
 642                         /* Free the key */
 643                         kfree(tp->md5sig_info->keys6[i].base.key);
 644                         tp->md5sig_info->entries6--;
 645
 646                         if (tp->md5sig_info->entries6 == 0) {
 647                                 kfree(tp->md5sig_info->keys6);
 648                                 tp->md5sig_info->keys6 = NULL;
 649                                 tp->md5sig_info->alloced6 = 0;
 650                         } else {
 651                                 /* shrink the database */
 652                                 if (tp->md5sig_info->entries6 != i)
 653                                         memmove(&tp->md5sig_info->keys6[i],
 654                                                 &tp->md5sig_info->keys6[i+1],
 655                                                 (tp->md5sig_info->entries6 - i)
 656                                                 * sizeof (tp->md5sig_info->keys6[0]));
 657                         }
 658                         return 0;
 659                 }
 660         }
 661         return -ENOENT;
 662 }
 663
 664 static void tcp_v6_clear_md5_list (struct sock *sk)
 665 {
 666         struct tcp_sock *tp = tcp_sk(sk);
 667         int i;
 668
 669         if (tp->md5sig_info->entries6) {
 670                 for (i = 0; i < tp->md5sig_info->entries6; i++)
 671                         kfree(tp->md5sig_info->keys6[i].base.key);
 672                 tp->md5sig_info->entries6 = 0;
 673         }
 674
 675         kfree(tp->md5sig_info->keys6);
 676         tp->md5sig_info->keys6 = NULL;
 677         tp->md5sig_info->alloced6 = 0;
 678
 679         if (tp->md5sig_info->entries4) {
 680                 for (i = 0; i < tp->md5sig_info->entries4; i++)
 681                         kfree(tp->md5sig_info->keys4[i].base.key);
 682                 tp->md5sig_info->entries4 = 0;
 683         }
 684
 685         kfree(tp->md5sig_info->keys4);
 686         tp->md5sig_info->keys4 = NULL;
 687         tp->md5sig_info->alloced4 = 0;
 688 }
 689
 690 static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
 691                                   int optlen)
 692 {
 693         struct tcp_md5sig cmd;
 694         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
 695         u8 *newkey;
 696
 697         if (optlen < sizeof(cmd))
 698                 return -EINVAL;
 699
 700         if (copy_from_user(&cmd, optval, sizeof(cmd)))
 701                 return -EFAULT;
 702
 703         if (sin6->sin6_family != AF_INET6)
 704                 return -EINVAL;
 705
 706         if (!cmd.tcpm_keylen) {
 707                 if (!tcp_sk(sk)->md5sig_info)
 708                         return -ENOENT;
 709                 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
 710                         return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
 711                 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
 712         }
 713
 714         if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
 715                 return -EINVAL;
 716
 717         if (!tcp_sk(sk)->md5sig_info) {
 718                 struct tcp_sock *tp = tcp_sk(sk);
 719                 struct tcp_md5sig_info *p;
 720
 721                 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
 722                 if (!p)
 723                         return -ENOMEM;
 724
 725                 tp->md5sig_info = p;
 726                 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
 727         }
 728
 729         newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
 730         if (!newkey)
 731                 return -ENOMEM;
 732         if (ipv6_addr_v4mapped(&sin6->sin6_addr)) {
 733                 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
 734                                          newkey, cmd.tcpm_keylen);
 735         }
 736         return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
 737 }
 738
 739 static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
 740                                         const struct in6_addr *daddr,
 741                                         const struct in6_addr *saddr, int nbytes)
 742 {
 743         struct tcp6_pseudohdr *bp;
 744         struct scatterlist sg;
 745
 746         bp = &hp->md5_blk.ip6;
 747         /* 1. TCP pseudo-header (RFC2460) */
 748         ipv6_addr_copy(&bp->saddr, saddr);
 749         ipv6_addr_copy(&bp->daddr, daddr);
 750         bp->protocol = cpu_to_be32(IPPROTO_TCP);
 751         bp->len = cpu_to_be32(nbytes);
 752
 753         sg_init_one(&sg, bp, sizeof(*bp));
 754         return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
 755 }
 756
 757 static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
 758                                const struct in6_addr *daddr, struct in6_addr *saddr,
 759                                const struct tcphdr *th)
 760 {
 761         struct tcp_md5sig_pool *hp;
 762         struct hash_desc *desc;
 763
 764         hp = tcp_get_md5sig_pool();
 765         if (!hp)
 766                 goto clear_hash_noput;
 767         desc = &hp->md5_desc;
 768
 769         if (crypto_hash_init(desc))
 770                 goto clear_hash;
 771         if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
 772                 goto clear_hash;
 773         if (tcp_md5_hash_header(hp, th))
 774                 goto clear_hash;
 775         if (tcp_md5_hash_key(hp, key))
 776                 goto clear_hash;
 777         if (crypto_hash_final(desc, md5_hash))
 778                 goto clear_hash;
 779
 780         tcp_put_md5sig_pool();
 781         return 0;
 782
 783 clear_hash:
 784         tcp_put_md5sig_pool();
 785 clear_hash_noput:
 786         memset(md5_hash, 0, 16);
 787         return 1;
 788 }
 789
 790 static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
 791                                const struct sock *sk,
 792                                const struct request_sock *req,
 793                                const struct sk_buff *skb)
 794 {
 795         const struct in6_addr *saddr, *daddr;
 796         struct tcp_md5sig_pool *hp;
 797         struct hash_desc *desc;
 798         const struct tcphdr *th = tcp_hdr(skb);
 799
 800         if (sk) {
 801                 saddr = &inet6_sk(sk)->saddr;
 802                 daddr = &inet6_sk(sk)->daddr;
 803         } else if (req) {
 804                 saddr = &inet6_rsk(req)->loc_addr;
 805                 daddr = &inet6_rsk(req)->rmt_addr;
 806         } else {
 807                 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
 808                 saddr = &ip6h->saddr;
 809                 daddr = &ip6h->daddr;
 810         }
 811
 812         hp = tcp_get_md5sig_pool();
 813         if (!hp)
 814                 goto clear_hash_noput;
 815         desc = &hp->md5_desc;
 816
 817         if (crypto_hash_init(desc))
 818                 goto clear_hash;
 819
 820         if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
 821                 goto clear_hash;
 822         if (tcp_md5_hash_header(hp, th))
 823                 goto clear_hash;
 824         if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
 825                 goto clear_hash;
 826         if (tcp_md5_hash_key(hp, key))
 827                 goto clear_hash;
 828         if (crypto_hash_final(desc, md5_hash))
 829                 goto clear_hash;
 830
 831         tcp_put_md5sig_pool();
 832         return 0;
 833
 834 clear_hash:
 835         tcp_put_md5sig_pool();
 836 clear_hash_noput:
 837         memset(md5_hash, 0, 16);
 838         return 1;
 839 }
 840
 841 static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
 842 {
 843         const __u8 *hash_location = NULL;
 844         struct tcp_md5sig_key *hash_expected;
 845         const struct ipv6hdr *ip6h = ipv6_hdr(skb);
 846         const struct tcphdr *th = tcp_hdr(skb);
 847         int genhash;
 848         u8 newhash[16];
 849
 850         hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
 851         hash_location = tcp_parse_md5sig_option(th);
 852
 853         /* We've parsed the options - do we have a hash? */
 854         if (!hash_expected && !hash_location)
 855                 return 0;
 856
 857         if (hash_expected && !hash_location) {
 858                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
 859                 return 1;
 860         }
 861
 862         if (!hash_expected && hash_location) {
 863                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
 864                 return 1;
 865         }
 866
 867         /* check the signature */
 868         genhash = tcp_v6_md5_hash_skb(newhash,
 869                                       hash_expected,
 870                                       NULL, NULL, skb);
 871
 872         if (genhash || memcmp(hash_location, newhash, 16) != 0) {
 873                 if (net_ratelimit()) {
 874                         printk(KERN_INFO "MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
 875                                genhash ? "failed" : "mismatch",
 876                                &ip6h->saddr, ntohs(th->source),
 877                                &ip6h->daddr, ntohs(th->dest));
 878                 }
 879                 return 1;
 880         }
 881         return 0;
 882 }
 883 #endif
 884
 885 struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
 886         .family         =       AF_INET6,
 887         .obj_size       =       sizeof(struct tcp6_request_sock),
 888         .rtx_syn_ack    =       tcp_v6_rtx_synack,
 889         .send_ack       =       tcp_v6_reqsk_send_ack,
 890         .destructor     =       tcp_v6_reqsk_destructor,
 891         .send_reset     =       tcp_v6_send_reset,
 892         .syn_ack_timeout =      tcp_syn_ack_timeout,
 893 };
 894
 895 #ifdef CONFIG_TCP_MD5SIG
 896 static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
 897         .md5_lookup     =       tcp_v6_reqsk_md5_lookup,
 898         .calc_md5_hash  =       tcp_v6_md5_hash_skb,
 899 };
 900 #endif
 901
 902 static void __tcp_v6_send_check(struct sk_buff *skb,
 903                                 const struct in6_addr *saddr, const struct in6_addr *daddr)
 904 {
 905         struct tcphdr *th = tcp_hdr(skb);
 906
 907         if (skb->ip_summed == CHECKSUM_PARTIAL) {
 908                 th->check = ~tcp_v6_check(skb->len, saddr, daddr, 0);
 909                 skb->csum_start = skb_transport_header(skb) - skb->head;
 910                 skb->csum_offset = offsetof(struct tcphdr, check);
 911         } else {
 912                 th->check = tcp_v6_check(skb->len, saddr, daddr,
 913                                          csum_partial(th, th->doff << 2,
 914                                                       skb->csum));
 915         }
 916 }
 917
 918 static void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
 919 {
 920         struct ipv6_pinfo *np = inet6_sk(sk);
 921
 922         __tcp_v6_send_check(skb, &np->saddr, &np->daddr);
 923 }
 924
 925 static int tcp_v6_gso_send_check(struct sk_buff *skb)
 926 {
 927         const struct ipv6hdr *ipv6h;
 928         struct tcphdr *th;
 929
 930         if (!pskb_may_pull(skb, sizeof(*th)))
 931                 return -EINVAL;
 932
 933         ipv6h = ipv6_hdr(skb);
 934         th = tcp_hdr(skb);
 935
 936         th->check = 0;
 937         skb->ip_summed = CHECKSUM_PARTIAL;
 938         __tcp_v6_send_check(skb, &ipv6h->saddr, &ipv6h->daddr);
 939         return 0;
 940 }
 941
 942 static struct sk_buff **tcp6_gro_receive(struct sk_buff **head,
 943                                          struct sk_buff *skb)
 944 {
 945         const struct ipv6hdr *iph = skb_gro_network_header(skb);
 946
 947         switch (skb->ip_summed) {
 948         case CHECKSUM_COMPLETE:
 949                 if (!tcp_v6_check(skb_gro_len(skb), &iph->saddr, &iph->daddr,
 950                                   skb->csum)) {
 951                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 952                         break;
 953                 }
 954
 955                 /* fall through */
 956         case CHECKSUM_NONE:
 957                 NAPI_GRO_CB(skb)->flush = 1;
 958                 return NULL;
 959         }
 960
 961         return tcp_gro_receive(head, skb);
 962 }
 963
 964 static int tcp6_gro_complete(struct sk_buff *skb)
 965 {
 966         const struct ipv6hdr *iph = ipv6_hdr(skb);
 967         struct tcphdr *th = tcp_hdr(skb);
 968
 969         th->check = ~tcp_v6_check(skb->len - skb_transport_offset(skb),
 970                                   &iph->saddr, &iph->daddr, 0);
 971         skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
 972
 973         return tcp_gro_complete(skb);
 974 }
 975
 976 static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
 977                                  u32 ts, struct tcp_md5sig_key *key, int rst, u8 tclass)
 978 {
 979         const struct tcphdr *th = tcp_hdr(skb);
 980         struct tcphdr *t1;
 981         struct sk_buff *buff;
 982         struct flowi6 fl6;
 983         struct net *net = dev_net(skb_dst(skb)->dev);
 984         struct sock *ctl_sk = net->ipv6.tcp_sk;
 985         unsigned int tot_len = sizeof(struct tcphdr);
 986         struct dst_entry *dst;
 987         __be32 *topt;
 988
 989         if (ts)
 990                 tot_len += TCPOLEN_TSTAMP_ALIGNED;
 991 #ifdef CONFIG_TCP_MD5SIG
 992         if (key)
 993                 tot_len += TCPOLEN_MD5SIG_ALIGNED;
 994 #endif
 995
 996         buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
 997                          GFP_ATOMIC);
 998         if (buff == NULL)
 999                 return;
1000
1001         skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1002
1003         t1 = (struct tcphdr *) skb_push(buff, tot_len);
1004         skb_reset_transport_header(buff);
1005
1006         /* Swap the send and the receive. */
1007         memset(t1, 0, sizeof(*t1));
1008         t1->dest = th->source;
1009         t1->source = th->dest;
1010         t1->doff = tot_len / 4;
1011         t1->seq = htonl(seq);
1012         t1->ack_seq = htonl(ack);
1013         t1->ack = !rst || !th->ack;
1014         t1->rst = rst;
1015         t1->window = htons(win);
1016
1017         topt = (__be32 *)(t1 + 1);
1018
1019         if (ts) {
1020                 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1021                                 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1022                 *topt++ = htonl(tcp_time_stamp);
1023                 *topt++ = htonl(ts);
1024         }
1025
1026 #ifdef CONFIG_TCP_MD5SIG
1027         if (key) {
1028                 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1029                                 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
1030                 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
1031                                     &ipv6_hdr(skb)->saddr,
1032                                     &ipv6_hdr(skb)->daddr, t1);
1033         }
1034 #endif
1035
1036         memset(&fl6, 0, sizeof(fl6));
1037         ipv6_addr_copy(&fl6.daddr, &ipv6_hdr(skb)->saddr);
1038         ipv6_addr_copy(&fl6.saddr, &ipv6_hdr(skb)->daddr);
1039
1040         buff->ip_summed = CHECKSUM_PARTIAL;
1041         buff->csum = 0;
1042
1043         __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
1044
1045         fl6.flowi6_proto = IPPROTO_TCP;
1046         if (ipv6_addr_type(&fl6.daddr) & IPV6_ADDR_LINKLOCAL)
1047                 fl6.flowi6_oif = inet6_iif(skb);
1048         fl6.fl6_dport = t1->dest;
1049         fl6.fl6_sport = t1->source;
1050         security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
1051
1052         /* Pass a socket to ip6_dst_lookup either it is for RST
1053          * Underlying function will use this to retrieve the network
1054          * namespace
1055          */
1056         dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
1057         if (!IS_ERR(dst)) {
1058                 skb_dst_set(buff, dst);
1059                 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
1060                 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
1061                 if (rst)
1062                         TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
1063                 return;
1064         }
1065
1066         kfree_skb(buff);
1067 }
1068
1069 static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
1070 {
1071         const struct tcphdr *th = tcp_hdr(skb);
1072         u32 seq = 0, ack_seq = 0;
1073         struct tcp_md5sig_key *key = NULL;
1074
1075         if (th->rst)
1076                 return;
1077
1078         if (!ipv6_unicast_destination(skb))
1079                 return;
1080
1081 #ifdef CONFIG_TCP_MD5SIG
1082         if (sk)
1083                 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->saddr);
1084 #endif
1085
1086         if (th->ack)
1087                 seq = ntohl(th->ack_seq);
1088         else
1089                 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
1090                           (th->doff << 2);
1091
1092         tcp_v6_send_response(skb, seq, ack_seq, 0, 0, key, 1, 0);
1093 }
1094
1095 static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts,
1096                             struct tcp_md5sig_key *key, u8 tclass)
1097 {
1098         tcp_v6_send_response(skb, seq, ack, win, ts, key, 0, tclass);
1099 }
1100
1101 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1102 {
1103         struct inet_timewait_sock *tw = inet_twsk(sk);
1104         struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1105
1106         tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
1107                         tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
1108                         tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw),
1109                         tw->tw_tclass);
1110
1111         inet_twsk_put(tw);
1112 }
1113
1114 static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
1115                                   struct request_sock *req)
1116 {
1117         tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent,
1118                         tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), 0);
1119 }
1120
1121
1122 static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1123 {
1124         struct request_sock *req, **prev;
1125         const struct tcphdr *th = tcp_hdr(skb);
1126         struct sock *nsk;
1127
1128         /* Find possible connection requests. */
1129         req = inet6_csk_search_req(sk, &prev, th->source,
1130                                    &ipv6_hdr(skb)->saddr,
1131                                    &ipv6_hdr(skb)->daddr, inet6_iif(skb));
1132         if (req)
1133                 return tcp_check_req(sk, skb, req, prev);
1134
1135         nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
1136                         &ipv6_hdr(skb)->saddr, th->source,
1137                         &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
1138
1139         if (nsk) {
1140                 if (nsk->sk_state != TCP_TIME_WAIT) {
1141                         bh_lock_sock(nsk);
1142                         return nsk;
1143                 }
1144                 inet_twsk_put(inet_twsk(nsk));
1145                 return NULL;
1146         }
1147
1148 #ifdef CONFIG_SYN_COOKIES
1149         if (!th->syn)
1150                 sk = cookie_v6_check(sk, skb);
1151 #endif
1152         return sk;
1153 }
1154
1155 /* FIXME: this is substantially similar to the ipv4 code.
1156  * Can some kind of merge be done? -- erics
1157  */
1158 static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1159 {
1160         struct tcp_extend_values tmp_ext;
1161         struct tcp_options_received tmp_opt;
1162         const u8 *hash_location;
1163         struct request_sock *req;
1164         struct inet6_request_sock *treq;
1165         struct ipv6_pinfo *np = inet6_sk(sk);
1166         struct tcp_sock *tp = tcp_sk(sk);
1167         __u32 isn = TCP_SKB_CB(skb)->when;
1168         struct dst_entry *dst = NULL;
1169         int want_cookie = 0;
1170
1171         if (skb->protocol == htons(ETH_P_IP))
1172                 return tcp_v4_conn_request(sk, skb);
1173
1174         if (!ipv6_unicast_destination(skb))
1175                 goto drop;
1176
1177         if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1178                 want_cookie = tcp_syn_flood_action(sk, skb, "TCPv6");
1179                 if (!want_cookie)
1180                         goto drop;
1181         }
1182
1183         if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1184                 goto drop;
1185
1186         req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
1187         if (req == NULL)
1188                 goto drop;
1189
1190 #ifdef CONFIG_TCP_MD5SIG
1191         tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1192 #endif
1193
1194         tcp_clear_options(&tmp_opt);
1195         tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1196         tmp_opt.user_mss = tp->rx_opt.user_mss;
1197         tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
1198
1199         if (tmp_opt.cookie_plus > 0 &&
1200             tmp_opt.saw_tstamp &&
1201             !tp->rx_opt.cookie_out_never &&
1202             (sysctl_tcp_cookie_size > 0 ||
1203              (tp->cookie_values != NULL &&
1204               tp->cookie_values->cookie_desired > 0))) {
1205                 u8 *c;
1206                 u32 *d;
1207                 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1208                 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1209
1210                 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1211                         goto drop_and_free;
1212
1213                 /* Secret recipe starts with IP addresses */
1214                 d = (__force u32 *)&ipv6_hdr(skb)->daddr.s6_addr32[0];
1215                 *mess++ ^= *d++;
1216                 *mess++ ^= *d++;
1217                 *mess++ ^= *d++;
1218                 *mess++ ^= *d++;
1219                 d = (__force u32 *)&ipv6_hdr(skb)->saddr.s6_addr32[0];
1220                 *mess++ ^= *d++;
1221                 *mess++ ^= *d++;
1222                 *mess++ ^= *d++;
1223                 *mess++ ^= *d++;
1224
1225                 /* plus variable length Initiator Cookie */
1226                 c = (u8 *)mess;
1227                 while (l-- > 0)
1228                         *c++ ^= *hash_location++;
1229
1230                 want_cookie = 0;        /* not our kind of cookie */
1231                 tmp_ext.cookie_out_never = 0; /* false */
1232                 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1233         } else if (!tp->rx_opt.cookie_in_always) {
1234                 /* redundant indications, but ensure initialization. */
1235                 tmp_ext.cookie_out_never = 1; /* true */
1236                 tmp_ext.cookie_plus = 0;
1237         } else {
1238                 goto drop_and_free;
1239         }
1240         tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
1241
1242         if (want_cookie && !tmp_opt.saw_tstamp)
1243                 tcp_clear_options(&tmp_opt);
1244
1245         tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1246         tcp_openreq_init(req, &tmp_opt, skb);
1247
1248         treq = inet6_rsk(req);
1249         ipv6_addr_copy(&treq->rmt_addr, &ipv6_hdr(skb)->saddr);
1250         ipv6_addr_copy(&treq->loc_addr, &ipv6_hdr(skb)->daddr);
1251         if (!want_cookie || tmp_opt.tstamp_ok)
1252                 TCP_ECN_create_request(req, skb);
1253
1254         treq->iif = sk->sk_bound_dev_if;
1255
1256         /* So that link locals have meaning */
1257         if (!sk->sk_bound_dev_if &&
1258             ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1259                 treq->iif = inet6_iif(skb);
1260
1261         if (!isn) {
1262                 struct inet_peer *peer = NULL;
1263
1264                 if (ipv6_opt_accepted(sk, skb) ||
1265                     np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1266                     np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1267                         atomic_inc(&skb->users);
1268                         treq->pktopts = skb;
1269                 }
1270
1271                 if (want_cookie) {
1272                         isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1273                         req->cookie_ts = tmp_opt.tstamp_ok;
1274                         goto have_isn;
1275                 }
1276
1277                 /* VJ's idea. We save last timestamp seen
1278                  * from the destination in peer table, when entering
1279                  * state TIME-WAIT, and check against it before
1280                  * accepting new connection request.
1281                  *
1282                  * If "isn" is not zero, this request hit alive
1283                  * timewait bucket, so that all the necessary checks
1284                  * are made in the function processing timewait state.
1285                  */
1286                 if (tmp_opt.saw_tstamp &&
1287                     tcp_death_row.sysctl_tw_recycle &&
1288                     (dst = inet6_csk_route_req(sk, req)) != NULL &&
1289                     (peer = rt6_get_peer((struct rt6_info *)dst)) != NULL &&
1290                     ipv6_addr_equal((struct in6_addr *)peer->daddr.addr.a6,
1291                                     &treq->rmt_addr)) {
1292                         inet_peer_refcheck(peer);
1293                         if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
1294                             (s32)(peer->tcp_ts - req->ts_recent) >
1295                                                         TCP_PAWS_WINDOW) {
1296                                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1297                                 goto drop_and_release;
1298                         }
1299                 }
1300                 /* Kill the following clause, if you dislike this way. */
1301                 else if (!sysctl_tcp_syncookies &&
1302                          (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1303                           (sysctl_max_syn_backlog >> 2)) &&
1304                          (!peer || !peer->tcp_ts_stamp) &&
1305                          (!dst || !dst_metric(dst, RTAX_RTT))) {
1306                         /* Without syncookies last quarter of
1307                          * backlog is filled with destinations,
1308                          * proven to be alive.
1309                          * It means that we continue to communicate
1310                          * to destinations, already remembered
1311                          * to the moment of synflood.
1312                          */
1313                         LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
1314                                        &treq->rmt_addr, ntohs(tcp_hdr(skb)->source));
1315                         goto drop_and_release;
1316                 }
1317
1318                 isn = tcp_v6_init_sequence(skb);
1319         }
1320 have_isn:
1321         tcp_rsk(req)->snt_isn = isn;
1322         tcp_rsk(req)->snt_synack = tcp_time_stamp;
1323
1324         security_inet_conn_request(sk, skb, req);
1325
1326         if (tcp_v6_send_synack(sk, req,
1327                                (struct request_values *)&tmp_ext) ||
1328             want_cookie)
1329                 goto drop_and_free;
1330
1331         inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1332         return 0;
1333
1334 drop_and_release:
1335         dst_release(dst);
1336 drop_and_free:
1337         reqsk_free(req);
1338 drop:
1339         return 0; /* don't send reset */
1340 }
1341
1342 static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1343                                           struct request_sock *req,
1344                                           struct dst_entry *dst)
1345 {
1346         struct inet6_request_sock *treq;
1347         struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1348         struct tcp6_sock *newtcp6sk;
1349         struct inet_sock *newinet;
1350         struct tcp_sock *newtp;
1351         struct sock *newsk;
1352         struct ipv6_txoptions *opt;
1353 #ifdef CONFIG_TCP_MD5SIG
1354         struct tcp_md5sig_key *key;
1355 #endif
1356
1357         if (skb->protocol == htons(ETH_P_IP)) {
1358                 /*
1359                  *      v6 mapped
1360                  */
1361
1362                 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1363
1364                 if (newsk == NULL)
1365                         return NULL;
1366
1367                 newtcp6sk = (struct tcp6_sock *)newsk;
1368                 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1369
1370                 newinet = inet_sk(newsk);
1371                 newnp = inet6_sk(newsk);
1372                 newtp = tcp_sk(newsk);
1373
1374                 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1375
1376                 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
1377
1378                 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
1379
1380                 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1381
1382                 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1383                 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1384 #ifdef CONFIG_TCP_MD5SIG
1385                 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1386 #endif
1387
1388                 newnp->ipv6_ac_list = NULL;
1389                 newnp->ipv6_fl_list = NULL;
1390                 newnp->pktoptions  = NULL;
1391                 newnp->opt         = NULL;
1392                 newnp->mcast_oif   = inet6_iif(skb);
1393                 newnp->mcast_hops  = ipv6_hdr(skb)->hop_limit;
1394
1395                 /*
1396                  * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1397                  * here, tcp_create_openreq_child now does this for us, see the comment in
1398                  * that function for the gory details. -acme
1399                  */
1400
1401                 /* It is tricky place. Until this moment IPv4 tcp
1402                    worked with IPv6 icsk.icsk_af_ops.
1403                    Sync it now.
1404                  */
1405                 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1406
1407                 return newsk;
1408         }
1409
1410         treq = inet6_rsk(req);
1411         opt = np->opt;
1412
1413         if (sk_acceptq_is_full(sk))
1414                 goto out_overflow;
1415
1416         if (!dst) {
1417                 dst = inet6_csk_route_req(sk, req);
1418                 if (!dst)
1419                         goto out;
1420         }
1421
1422         newsk = tcp_create_openreq_child(sk, req, skb);
1423         if (newsk == NULL)
1424                 goto out_nonewsk;
1425
1426         /*
1427          * No need to charge this sock to the relevant IPv6 refcnt debug socks
1428          * count here, tcp_create_openreq_child now does this for us, see the
1429          * comment in that function for the gory details. -acme
1430          */
1431
1432         newsk->sk_gso_type = SKB_GSO_TCPV6;
1433         __ip6_dst_store(newsk, dst, NULL, NULL);
1434
1435         newtcp6sk = (struct tcp6_sock *)newsk;
1436         inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1437
1438         newtp = tcp_sk(newsk);
1439         newinet = inet_sk(newsk);
1440         newnp = inet6_sk(newsk);
1441
1442         memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1443
1444         ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1445         ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1446         ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1447         newsk->sk_bound_dev_if = treq->iif;
1448
1449         /* Now IPv6 options...
1450
1451            First: no IPv4 options.
1452          */
1453         newinet->inet_opt = NULL;
1454         newnp->ipv6_ac_list = NULL;
1455         newnp->ipv6_fl_list = NULL;
1456
1457         /* Clone RX bits */
1458         newnp->rxopt.all = np->rxopt.all;
1459
1460         /* Clone pktoptions received with SYN */
1461         newnp->pktoptions = NULL;
1462         if (treq->pktopts != NULL) {
1463                 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1464                 kfree_skb(treq->pktopts);
1465                 treq->pktopts = NULL;
1466                 if (newnp->pktoptions)
1467                         skb_set_owner_r(newnp->pktoptions, newsk);
1468         }
1469         newnp->opt        = NULL;
1470         newnp->mcast_oif  = inet6_iif(skb);
1471         newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1472
1473         /* Clone native IPv6 options from listening socket (if any)
1474
1475            Yes, keeping reference count would be much more clever,
1476            but we make one more one thing there: reattach optmem
1477            to newsk.
1478          */
1479         if (opt) {
1480                 newnp->opt = ipv6_dup_options(newsk, opt);
1481                 if (opt != np->opt)
1482                         sock_kfree_s(sk, opt, opt->tot_len);
1483         }
1484
1485         inet_csk(newsk)->icsk_ext_hdr_len = 0;
1486         if (newnp->opt)
1487                 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1488                                                      newnp->opt->opt_flen);
1489
1490         tcp_mtup_init(newsk);
1491         tcp_sync_mss(newsk, dst_mtu(dst));
1492         newtp->advmss = dst_metric_advmss(dst);
1493         if (tcp_sk(sk)->rx_opt.user_mss &&
1494             tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1495                 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1496
1497         tcp_initialize_rcv_mss(newsk);
1498         if (tcp_rsk(req)->snt_synack)
1499                 tcp_valid_rtt_meas(newsk,
1500                     tcp_time_stamp - tcp_rsk(req)->snt_synack);
1501         newtp->total_retrans = req->retrans;
1502
1503         newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1504         newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
1505
1506 #ifdef CONFIG_TCP_MD5SIG
1507         /* Copy over the MD5 key from the original socket */
1508         if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1509                 /* We're using one, so create a matching key
1510                  * on the newsk structure. If we fail to get
1511                  * memory, then we end up not copying the key
1512                  * across. Shucks.
1513                  */
1514                 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1515                 if (newkey != NULL)
1516                         tcp_v6_md5_do_add(newsk, &newnp->daddr,
1517                                           newkey, key->keylen);
1518         }
1519 #endif
1520
1521         if (__inet_inherit_port(sk, newsk) < 0) {
1522                 inet_csk_prepare_forced_close(newsk);
1523                 tcp_done(newsk);
1524                 goto out;
1525         }
1526         __inet6_hash(newsk, NULL);
1527
1528         return newsk;
1529
1530 out_overflow:
1531         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1532 out_nonewsk:
1533         if (opt && opt != np->opt)
1534                 sock_kfree_s(sk, opt, opt->tot_len);
1535         dst_release(dst);
1536 out:
1537         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1538         return NULL;
1539 }
1540
1541 static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
1542 {
1543         if (skb->ip_summed == CHECKSUM_COMPLETE) {
1544                 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
1545                                   &ipv6_hdr(skb)->daddr, skb->csum)) {
1546                         skb->ip_summed = CHECKSUM_UNNECESSARY;
1547                         return 0;
1548                 }
1549         }
1550
1551         skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
1552                                               &ipv6_hdr(skb)->saddr,
1553                                               &ipv6_hdr(skb)->daddr, 0));
1554
1555         if (skb->len <= 76) {
1556                 return __skb_checksum_complete(skb);
1557         }
1558         return 0;
1559 }
1560
1561 /* The socket must have it's spinlock held when we get
1562  * here.
1563  *
1564  * We have a potential double-lock case here, so even when
1565  * doing backlog processing we use the BH locking scheme.
1566  * This is because we cannot sleep with the original spinlock
1567  * held.
1568  */
1569 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1570 {
1571         struct ipv6_pinfo *np = inet6_sk(sk);
1572         struct tcp_sock *tp;
1573         struct sk_buff *opt_skb = NULL;
1574
1575         /* Imagine: socket is IPv6. IPv4 packet arrives,
1576            goes to IPv4 receive handler and backlogged.
1577            From backlog it always goes here. Kerboom...
1578            Fortunately, tcp_rcv_established and rcv_established
1579            handle them correctly, but it is not case with
1580            tcp_v6_hnd_req and tcp_v6_send_reset().   --ANK
1581          */
1582
1583         if (skb->protocol == htons(ETH_P_IP))
1584                 return tcp_v4_do_rcv(sk, skb);
1585
1586 #ifdef CONFIG_TCP_MD5SIG
1587         if (tcp_v6_inbound_md5_hash (sk, skb))
1588                 goto discard;
1589 #endif
1590
1591         if (sk_filter(sk, skb))
1592                 goto discard;
1593
1594         /*
1595          *      socket locking is here for SMP purposes as backlog rcv
1596          *      is currently called with bh processing disabled.
1597          */
1598
1599         /* Do Stevens' IPV6_PKTOPTIONS.
1600
1601            Yes, guys, it is the only place in our code, where we
1602            may make it not affecting IPv4.
1603            The rest of code is protocol independent,
1604            and I do not like idea to uglify IPv4.
1605
1606            Actually, all the idea behind IPV6_PKTOPTIONS
1607            looks not very well thought. For now we latch
1608            options, received in the last packet, enqueued
1609            by tcp. Feel free to propose better solution.
1610                                                --ANK (980728)
1611          */
1612         if (np->rxopt.all)
1613                 opt_skb = skb_clone(skb, GFP_ATOMIC);
1614
1615         if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1616                 sock_rps_save_rxhash(sk, skb);
1617                 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
1618                         goto reset;
1619                 if (opt_skb)
1620                         goto ipv6_pktoptions;
1621                 return 0;
1622         }
1623
1624         if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
1625                 goto csum_err;
1626
1627         if (sk->sk_state == TCP_LISTEN) {
1628                 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1629                 if (!nsk)
1630                         goto discard;
1631
1632                 /*
1633                  * Queue it on the new socket if the new socket is active,
1634                  * otherwise we just shortcircuit this and continue with
1635                  * the new socket..
1636                  */
1637                 if(nsk != sk) {
1638                         sock_rps_save_rxhash(nsk, skb);
1639                         if (tcp_child_process(sk, nsk, skb))
1640                                 goto reset;
1641                         if (opt_skb)
1642                                 __kfree_skb(opt_skb);
1643                         return 0;
1644                 }
1645         } else
1646                 sock_rps_save_rxhash(sk, skb);
1647
1648         if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
1649                 goto reset;
1650         if (opt_skb)
1651                 goto ipv6_pktoptions;
1652         return 0;
1653
1654 reset:
1655         tcp_v6_send_reset(sk, skb);
1656 discard:
1657         if (opt_skb)
1658                 __kfree_skb(opt_skb);
1659         kfree_skb(skb);
1660         return 0;
1661 csum_err:
1662         TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
1663         goto discard;
1664
1665
1666 ipv6_pktoptions:
1667         /* Do you ask, what is it?
1668
1669            1. skb was enqueued by tcp.
1670            2. skb is added to tail of read queue, rather than out of order.
1671            3. socket is not in passive state.
1672            4. Finally, it really contains options, which user wants to receive.
1673          */
1674         tp = tcp_sk(sk);
1675         if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1676             !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1677                 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
1678                         np->mcast_oif = inet6_iif(opt_skb);
1679                 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1680                         np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1681                 if (ipv6_opt_accepted(sk, opt_skb)) {
1682                         skb_set_owner_r(opt_skb, sk);
1683                         opt_skb = xchg(&np->pktoptions, opt_skb);
1684                 } else {
1685                         __kfree_skb(opt_skb);
1686                         opt_skb = xchg(&np->pktoptions, NULL);
1687                 }
1688         }
1689
1690         kfree_skb(opt_skb);
1691         return 0;
1692 }
1693
1694 static int tcp_v6_rcv(struct sk_buff *skb)
1695 {
1696         const struct tcphdr *th;
1697         const struct ipv6hdr *hdr;
1698         struct sock *sk;
1699         int ret;
1700         struct net *net = dev_net(skb->dev);
1701
1702         if (skb->pkt_type != PACKET_HOST)
1703                 goto discard_it;
1704
1705         /*
1706          *      Count it even if it's bad.
1707          */
1708         TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
1709
1710         if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1711                 goto discard_it;
1712
1713         th = tcp_hdr(skb);
1714
1715         if (th->doff < sizeof(struct tcphdr)/4)
1716                 goto bad_packet;
1717         if (!pskb_may_pull(skb, th->doff*4))
1718                 goto discard_it;
1719
1720         if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
1721                 goto bad_packet;
1722
1723         th = tcp_hdr(skb);
1724         hdr = ipv6_hdr(skb);
1725         TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1726         TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1727                                     skb->len - th->doff*4);
1728         TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1729         TCP_SKB_CB(skb)->when = 0;
1730         TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
1731         TCP_SKB_CB(skb)->sacked = 0;
1732
1733         sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
1734         if (!sk)
1735                 goto no_tcp_socket;
1736
1737 process:
1738         if (sk->sk_state == TCP_TIME_WAIT)
1739                 goto do_time_wait;
1740
1741         if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1742                 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1743                 goto discard_and_relse;
1744         }
1745
1746         if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1747                 goto discard_and_relse;
1748
1749         if (sk_filter(sk, skb))
1750                 goto discard_and_relse;
1751
1752         skb->dev = NULL;
1753
1754         bh_lock_sock_nested(sk);
1755         ret = 0;
1756         if (!sock_owned_by_user(sk)) {
1757 #ifdef CONFIG_NET_DMA
1758                 struct tcp_sock *tp = tcp_sk(sk);
1759                 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1760                         tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
1761                 if (tp->ucopy.dma_chan)
1762                         ret = tcp_v6_do_rcv(sk, skb);
1763                 else
1764 #endif
1765                 {
1766                         if (!tcp_prequeue(sk, skb))
1767                                 ret = tcp_v6_do_rcv(sk, skb);
1768                 }
1769         } else if (unlikely(sk_add_backlog(sk, skb))) {
1770                 bh_unlock_sock(sk);
1771                 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
1772                 goto discard_and_relse;
1773         }
1774         bh_unlock_sock(sk);
1775
1776         sock_put(sk);
1777         return ret ? -1 : 0;
1778
1779 no_tcp_socket:
1780         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1781                 goto discard_it;
1782
1783         if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1784 bad_packet:
1785                 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1786         } else {
1787                 tcp_v6_send_reset(NULL, skb);
1788         }
1789
1790 discard_it:
1791
1792         /*
1793          *      Discard frame
1794          */
1795
1796         kfree_skb(skb);
1797         return 0;
1798
1799 discard_and_relse:
1800         sock_put(sk);
1801         goto discard_it;
1802
1803 do_time_wait:
1804         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1805                 inet_twsk_put(inet_twsk(sk));
1806                 goto discard_it;
1807         }
1808
1809         if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1810                 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1811                 inet_twsk_put(inet_twsk(sk));
1812                 goto discard_it;
1813         }
1814
1815         switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1816         case TCP_TW_SYN:
1817         {
1818                 struct sock *sk2;
1819
1820                 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
1821                                             &ipv6_hdr(skb)->daddr,
1822                                             ntohs(th->dest), inet6_iif(skb));
1823                 if (sk2 != NULL) {
1824                         struct inet_timewait_sock *tw = inet_twsk(sk);
1825                         inet_twsk_deschedule(tw, &tcp_death_row);
1826                         inet_twsk_put(tw);
1827                         sk = sk2;
1828                         goto process;
1829                 }
1830                 /* Fall through to ACK */
1831         }
1832         case TCP_TW_ACK:
1833                 tcp_v6_timewait_ack(sk, skb);
1834                 break;
1835         case TCP_TW_RST:
1836                 goto no_tcp_socket;
1837         case TCP_TW_SUCCESS:;
1838         }
1839         goto discard_it;
1840 }
1841
1842 static struct inet_peer *tcp_v6_get_peer(struct sock *sk, bool *release_it)
1843 {
1844         struct rt6_info *rt = (struct rt6_info *) __sk_dst_get(sk);
1845         struct ipv6_pinfo *np = inet6_sk(sk);
1846         struct inet_peer *peer;
1847
1848         if (!rt ||
1849             !ipv6_addr_equal(&np->daddr, &rt->rt6i_dst.addr)) {
1850                 peer = inet_getpeer_v6(&np->daddr, 1);
1851                 *release_it = true;
1852         } else {
1853                 if (!rt->rt6i_peer)
1854                         rt6_bind_peer(rt, 1);
1855                 peer = rt->rt6i_peer;
1856                 *release_it = false;
1857         }
1858
1859         return peer;
1860 }
1861
1862 static void *tcp_v6_tw_get_peer(struct sock *sk)
1863 {
1864         const struct inet6_timewait_sock *tw6 = inet6_twsk(sk);
1865         const struct inet_timewait_sock *tw = inet_twsk(sk);
1866
1867         if (tw->tw_family == AF_INET)
1868                 return tcp_v4_tw_get_peer(sk);
1869
1870         return inet_getpeer_v6(&tw6->tw_v6_daddr, 1);
1871 }
1872
1873 static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1874         .twsk_obj_size  = sizeof(struct tcp6_timewait_sock),
1875         .twsk_unique    = tcp_twsk_unique,
1876         .twsk_destructor= tcp_twsk_destructor,
1877         .twsk_getpeer   = tcp_v6_tw_get_peer,
1878 };
1879
1880 static const struct inet_connection_sock_af_ops ipv6_specific = {
1881         .queue_xmit        = inet6_csk_xmit,
1882         .send_check        = tcp_v6_send_check,
1883         .rebuild_header    = inet6_sk_rebuild_header,
1884         .conn_request      = tcp_v6_conn_request,
1885         .syn_recv_sock     = tcp_v6_syn_recv_sock,
1886         .get_peer          = tcp_v6_get_peer,
1887         .net_header_len    = sizeof(struct ipv6hdr),
1888         .setsockopt        = ipv6_setsockopt,
1889         .getsockopt        = ipv6_getsockopt,
1890         .addr2sockaddr     = inet6_csk_addr2sockaddr,
1891         .sockaddr_len      = sizeof(struct sockaddr_in6),
1892         .bind_conflict     = inet6_csk_bind_conflict,
1893 #ifdef CONFIG_COMPAT
1894         .compat_setsockopt = compat_ipv6_setsockopt,
1895         .compat_getsockopt = compat_ipv6_getsockopt,
1896 #endif
1897 };
1898
1899 #ifdef CONFIG_TCP_MD5SIG
1900 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
1901         .md5_lookup     =       tcp_v6_md5_lookup,
1902         .calc_md5_hash  =       tcp_v6_md5_hash_skb,
1903         .md5_add        =       tcp_v6_md5_add_func,
1904         .md5_parse      =       tcp_v6_parse_md5_keys,
1905 };
1906 #endif
1907
1908 /*
1909  *      TCP over IPv4 via INET6 API
1910  */
1911
1912 static const struct inet_connection_sock_af_ops ipv6_mapped = {
1913         .queue_xmit        = ip_queue_xmit,
1914         .send_check        = tcp_v4_send_check,
1915         .rebuild_header    = inet_sk_rebuild_header,
1916         .conn_request      = tcp_v6_conn_request,
1917         .syn_recv_sock     = tcp_v6_syn_recv_sock,
1918         .get_peer          = tcp_v4_get_peer,
1919         .net_header_len    = sizeof(struct iphdr),
1920         .setsockopt        = ipv6_setsockopt,
1921         .getsockopt        = ipv6_getsockopt,
1922         .addr2sockaddr     = inet6_csk_addr2sockaddr,
1923         .sockaddr_len      = sizeof(struct sockaddr_in6),
1924         .bind_conflict     = inet6_csk_bind_conflict,
1925 #ifdef CONFIG_COMPAT
1926         .compat_setsockopt = compat_ipv6_setsockopt,
1927         .compat_getsockopt = compat_ipv6_getsockopt,
1928 #endif
1929 };
1930
1931 #ifdef CONFIG_TCP_MD5SIG
1932 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
1933         .md5_lookup     =       tcp_v4_md5_lookup,
1934         .calc_md5_hash  =       tcp_v4_md5_hash_skb,
1935         .md5_add        =       tcp_v6_md5_add_func,
1936         .md5_parse      =       tcp_v6_parse_md5_keys,
1937 };
1938 #endif
1939
1940 /* NOTE: A lot of things set to zero explicitly by call to
1941  *       sk_alloc() so need not be done here.
1942  */
1943 static int tcp_v6_init_sock(struct sock *sk)
1944 {
1945         struct inet_connection_sock *icsk = inet_csk(sk);
1946         struct tcp_sock *tp = tcp_sk(sk);
1947
1948         skb_queue_head_init(&tp->out_of_order_queue);
1949         tcp_init_xmit_timers(sk);
1950         tcp_prequeue_init(tp);
1951
1952         icsk->icsk_rto = TCP_TIMEOUT_INIT;
1953         tp->mdev = TCP_TIMEOUT_INIT;
1954
1955         /* So many TCP implementations out there (incorrectly) count the
1956          * initial SYN frame in their delayed-ACK and congestion control
1957          * algorithms that we must have the following bandaid to talk
1958          * efficiently to them.  -DaveM
1959          */
1960         tp->snd_cwnd = 2;
1961
1962         /* See draft-stevens-tcpca-spec-01 for discussion of the
1963          * initialization of these values.
1964          */
1965         tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
1966         tp->snd_cwnd_clamp = ~0;
1967         tp->mss_cache = TCP_MSS_DEFAULT;
1968
1969         tp->reordering = sysctl_tcp_reordering;
1970
1971         sk->sk_state = TCP_CLOSE;
1972
1973         icsk->icsk_af_ops = &ipv6_specific;
1974         icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1975         icsk->icsk_sync_mss = tcp_sync_mss;
1976         sk->sk_write_space = sk_stream_write_space;
1977         sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1978
1979 #ifdef CONFIG_TCP_MD5SIG
1980         tp->af_specific = &tcp_sock_ipv6_specific;
1981 #endif
1982
1983         /* TCP Cookie Transactions */
1984         if (sysctl_tcp_cookie_size > 0) {
1985                 /* Default, cookies without s_data_payload. */
1986                 tp->cookie_values =
1987                         kzalloc(sizeof(*tp->cookie_values),
1988                                 sk->sk_allocation);
1989                 if (tp->cookie_values != NULL)
1990                         kref_init(&tp->cookie_values->kref);
1991         }
1992         /* Presumed zeroed, in order of appearance:
1993          *      cookie_in_always, cookie_out_never,
1994          *      s_data_constant, s_data_in, s_data_out
1995          */
1996         sk->sk_sndbuf = sysctl_tcp_wmem[1];
1997         sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1998
1999         local_bh_disable();
2000         percpu_counter_inc(&tcp_sockets_allocated);
2001         local_bh_enable();
2002
2003         return 0;
2004 }
2005
2006 static void tcp_v6_destroy_sock(struct sock *sk)
2007 {
2008 #ifdef CONFIG_TCP_MD5SIG
2009         /* Clean up the MD5 key list */
2010         if (tcp_sk(sk)->md5sig_info)
2011                 tcp_v6_clear_md5_list(sk);
2012 #endif
2013         tcp_v4_destroy_sock(sk);
2014         inet6_destroy_sock(sk);
2015 }
2016
2017 #ifdef CONFIG_PROC_FS
2018 /* Proc filesystem TCPv6 sock list dumping. */
2019 static void get_openreq6(struct seq_file *seq,
2020                          const struct sock *sk, struct request_sock *req, int i, int uid)
2021 {
2022         int ttd = req->expires - jiffies;
2023         const struct in6_addr *src = &inet6_rsk(req)->loc_addr;
2024         const struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
2025
2026         if (ttd < 0)
2027                 ttd = 0;
2028
2029         seq_printf(seq,
2030                    "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2031                    "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
2032                    i,
2033                    src->s6_addr32[0], src->s6_addr32[1],
2034                    src->s6_addr32[2], src->s6_addr32[3],
2035                    ntohs(inet_rsk(req)->loc_port),
2036                    dest->s6_addr32[0], dest->s6_addr32[1],
2037                    dest->s6_addr32[2], dest->s6_addr32[3],
2038                    ntohs(inet_rsk(req)->rmt_port),
2039                    TCP_SYN_RECV,
2040                    0,0, /* could print option size, but that is af dependent. */
2041                    1,   /* timers active (only the expire timer) */
2042                    jiffies_to_clock_t(ttd),
2043                    req->retrans,
2044                    uid,
2045                    0,  /* non standard timer */
2046                    0, /* open_requests have no inode */
2047                    0, req);
2048 }
2049
2050 static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
2051 {
2052         const struct in6_addr *dest, *src;
2053         __u16 destp, srcp;
2054         int timer_active;
2055         unsigned long timer_expires;
2056         const struct inet_sock *inet = inet_sk(sp);
2057         const struct tcp_sock *tp = tcp_sk(sp);
2058         const struct inet_connection_sock *icsk = inet_csk(sp);
2059         const struct ipv6_pinfo *np = inet6_sk(sp);
2060
2061         dest  = &np->daddr;
2062         src   = &np->rcv_saddr;
2063         destp = ntohs(inet->inet_dport);
2064         srcp  = ntohs(inet->inet_sport);
2065
2066         if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
2067                 timer_active    = 1;
2068                 timer_expires   = icsk->icsk_timeout;
2069         } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2070                 timer_active    = 4;
2071                 timer_expires   = icsk->icsk_timeout;
2072         } else if (timer_pending(&sp->sk_timer)) {
2073                 timer_active    = 2;
2074                 timer_expires   = sp->sk_timer.expires;
2075         } else {
2076                 timer_active    = 0;
2077                 timer_expires = jiffies;
2078         }
2079
2080         seq_printf(seq,
2081                    "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2082                    "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %pK %lu %lu %u %u %d\n",
2083                    i,
2084                    src->s6_addr32[0], src->s6_addr32[1],
2085                    src->s6_addr32[2], src->s6_addr32[3], srcp,
2086                    dest->s6_addr32[0], dest->s6_addr32[1],
2087                    dest->s6_addr32[2], dest->s6_addr32[3], destp,
2088                    sp->sk_state,
2089                    tp->write_seq-tp->snd_una,
2090                    (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
2091                    timer_active,
2092                    jiffies_to_clock_t(timer_expires - jiffies),
2093                    icsk->icsk_retransmits,
2094                    sock_i_uid(sp),
2095                    icsk->icsk_probes_out,
2096                    sock_i_ino(sp),
2097                    atomic_read(&sp->sk_refcnt), sp,
2098                    jiffies_to_clock_t(icsk->icsk_rto),
2099                    jiffies_to_clock_t(icsk->icsk_ack.ato),
2100                    (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
2101                    tp->snd_cwnd,
2102                    tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
2103                    );
2104 }
2105
2106 static void get_timewait6_sock(struct seq_file *seq,
2107                                struct inet_timewait_sock *tw, int i)
2108 {
2109         const struct in6_addr *dest, *src;
2110         __u16 destp, srcp;
2111         const struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
2112         int ttd = tw->tw_ttd - jiffies;
2113
2114         if (ttd < 0)
2115                 ttd = 0;
2116
2117         dest = &tw6->tw_v6_daddr;
2118         src  = &tw6->tw_v6_rcv_saddr;
2119         destp = ntohs(tw->tw_dport);
2120         srcp  = ntohs(tw->tw_sport);
2121
2122         seq_printf(seq,
2123                    "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2124                    "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
2125                    i,
2126                    src->s6_addr32[0], src->s6_addr32[1],
2127                    src->s6_addr32[2], src->s6_addr32[3], srcp,
2128                    dest->s6_addr32[0], dest->s6_addr32[1],
2129                    dest->s6_addr32[2], dest->s6_addr32[3], destp,
2130                    tw->tw_substate, 0, 0,
2131                    3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2132                    atomic_read(&tw->tw_refcnt), tw);
2133 }
2134
2135 static int tcp6_seq_show(struct seq_file *seq, void *v)
2136 {
2137         struct tcp_iter_state *st;
2138
2139         if (v == SEQ_START_TOKEN) {
2140                 seq_puts(seq,
2141                          "  sl  "
2142                          "local_address                         "
2143                          "remote_address                        "
2144                          "st tx_queue rx_queue tr tm->when retrnsmt"
2145                          "   uid  timeout inode\n");
2146                 goto out;
2147         }
2148         st = seq->private;
2149
2150         switch (st->state) {
2151         case TCP_SEQ_STATE_LISTENING:
2152         case TCP_SEQ_STATE_ESTABLISHED:
2153                 get_tcp6_sock(seq, v, st->num);
2154                 break;
2155         case TCP_SEQ_STATE_OPENREQ:
2156                 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2157                 break;
2158         case TCP_SEQ_STATE_TIME_WAIT:
2159                 get_timewait6_sock(seq, v, st->num);
2160                 break;
2161         }
2162 out:
2163         return 0;
2164 }
2165
2166 static const struct file_operations tcp6_afinfo_seq_fops = {
2167         .owner   = THIS_MODULE,
2168         .open    = tcp_seq_open,
2169         .read    = seq_read,
2170         .llseek  = seq_lseek,
2171         .release = seq_release_net
2172 };
2173
2174 static struct tcp_seq_afinfo tcp6_seq_afinfo = {
2175         .name           = "tcp6",
2176         .family         = AF_INET6,
2177         .seq_fops       = &tcp6_afinfo_seq_fops,
2178         .seq_ops        = {
2179                 .show           = tcp6_seq_show,
2180         },
2181 };
2182
2183 int __net_init tcp6_proc_init(struct net *net)
2184 {
2185         return tcp_proc_register(net, &tcp6_seq_afinfo);
2186 }
2187
2188 void tcp6_proc_exit(struct net *net)
2189 {
2190         tcp_proc_unregister(net, &tcp6_seq_afinfo);
2191 }
2192 #endif
2193
2194 static void tcp_v6_clear_sk(struct sock *sk, int size)
2195 {
2196         struct inet_sock *inet = inet_sk(sk);
2197
2198         /* we do not want to clear pinet6 field, because of RCU lookups */
2199         sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
2200
2201         size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
2202         memset(&inet->pinet6 + 1, 0, size);
2203 }
2204
2205 struct proto tcpv6_prot = {
2206         .name                   = "TCPv6",
2207         .owner                  = THIS_MODULE,
2208         .close                  = tcp_close,
2209         .connect                = tcp_v6_connect,
2210         .disconnect             = tcp_disconnect,
2211         .accept                 = inet_csk_accept,
2212         .ioctl                  = tcp_ioctl,
2213         .init                   = tcp_v6_init_sock,
2214         .destroy                = tcp_v6_destroy_sock,
2215         .shutdown               = tcp_shutdown,
2216         .setsockopt             = tcp_setsockopt,
2217         .getsockopt             = tcp_getsockopt,
2218         .recvmsg                = tcp_recvmsg,
2219         .sendmsg                = tcp_sendmsg,
2220         .sendpage               = tcp_sendpage,
2221         .backlog_rcv            = tcp_v6_do_rcv,
2222         .hash                   = tcp_v6_hash,
2223         .unhash                 = inet_unhash,
2224         .get_port               = inet_csk_get_port,
2225         .enter_memory_pressure  = tcp_enter_memory_pressure,
2226         .sockets_allocated      = &tcp_sockets_allocated,
2227         .memory_allocated       = &tcp_memory_allocated,
2228         .memory_pressure        = &tcp_memory_pressure,
2229         .orphan_count           = &tcp_orphan_count,
2230         .sysctl_mem             = sysctl_tcp_mem,
2231         .sysctl_wmem            = sysctl_tcp_wmem,
2232         .sysctl_rmem            = sysctl_tcp_rmem,
2233         .max_header             = MAX_TCP_HEADER,
2234         .obj_size               = sizeof(struct tcp6_sock),
2235         .slab_flags             = SLAB_DESTROY_BY_RCU,
2236         .twsk_prot              = &tcp6_timewait_sock_ops,
2237         .rsk_prot               = &tcp6_request_sock_ops,
2238         .h.hashinfo             = &tcp_hashinfo,
2239         .no_autobind            = true,
2240 #ifdef CONFIG_COMPAT
2241         .compat_setsockopt      = compat_tcp_setsockopt,
2242         .compat_getsockopt      = compat_tcp_getsockopt,
2243 #endif
2244         .clear_sk               = tcp_v6_clear_sk,
2245 };
2246
2247 static const struct inet6_protocol tcpv6_protocol = {
2248         .handler        =       tcp_v6_rcv,
2249         .err_handler    =       tcp_v6_err,
2250         .gso_send_check =       tcp_v6_gso_send_check,
2251         .gso_segment    =       tcp_tso_segment,
2252         .gro_receive    =       tcp6_gro_receive,
2253         .gro_complete   =       tcp6_gro_complete,
2254         .flags          =       INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2255 };
2256
2257 static struct inet_protosw tcpv6_protosw = {
2258         .type           =       SOCK_STREAM,
2259         .protocol       =       IPPROTO_TCP,
2260         .prot           =       &tcpv6_prot,
2261         .ops            =       &inet6_stream_ops,
2262         .no_check       =       0,
2263         .flags          =       INET_PROTOSW_PERMANENT |
2264                                 INET_PROTOSW_ICSK,
2265 };
2266
2267 static int __net_init tcpv6_net_init(struct net *net)
2268 {
2269         return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2270                                     SOCK_RAW, IPPROTO_TCP, net);
2271 }
2272
2273 static void __net_exit tcpv6_net_exit(struct net *net)
2274 {
2275         inet_ctl_sock_destroy(net->ipv6.tcp_sk);
2276 }
2277
2278 static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
2279 {
2280         inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
2281 }
2282
2283 static struct pernet_operations tcpv6_net_ops = {
2284         .init       = tcpv6_net_init,
2285         .exit       = tcpv6_net_exit,
2286         .exit_batch = tcpv6_net_exit_batch,
2287 };
2288
2289 int __init tcpv6_init(void)
2290 {
2291         int ret;
2292
2293         ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2294         if (ret)
2295                 goto out;
2296
2297         /* register inet6 protocol */
2298         ret = inet6_register_protosw(&tcpv6_protosw);
2299         if (ret)
2300                 goto out_tcpv6_protocol;
2301
2302         ret = register_pernet_subsys(&tcpv6_net_ops);
2303         if (ret)
2304                 goto out_tcpv6_protosw;
2305 out:
2306         return ret;
2307
2308 out_tcpv6_protocol:
2309         inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2310 out_tcpv6_protosw:
2311         inet6_unregister_protosw(&tcpv6_protosw);
2312         goto out;
2313 }
2314
2315 void tcpv6_exit(void)
2316 {
2317         unregister_pernet_subsys(&tcpv6_net_ops);
2318         inet6_unregister_protosw(&tcpv6_protosw);
2319         inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2320 }