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