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