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