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