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