root/net/tcp/tcp.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. min
  2. print_th
  3. get_firstr
  4. diff
  5. tcp_time_wait
  6. tcp_retransmit
  7. tcp_err
  8. tcp_select
  9. tcp_ioctl
  10. tcp_check
  11. tcp_send_check
  12. tcp_send_ack
  13. tcp_build_header
  14. tcp_write
  15. tcp_read_wakeup
  16. cleanup_rbuf
  17. tcp_read_urg
  18. tcp_read
  19. tcp_reset
  20. tcp_conn_request
  21. tcp_close
  22. tcp_write_xmit
  23. tcp_ack
  24. tcp_data
  25. tcp_urg
  26. tcp_fin
  27. tcp_accept
  28. tcp_connect
  29. tcp_sequence
  30. tcp_options
  31. tcp_rcv
  32. tcp_write_wakeup

   1  /* tcp.c */
   2  /*
   3      Copyright (C) 1992  Ross Biro
   4 
   5      This program is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published by
   7      the Free Software Foundation; either version 2, or (at your option)
   8      any later version.
   9 
  10      This program is distributed in the hope that it will be useful,
  11      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13      GNU General Public License for more details.
  14 
  15      You should have received a copy of the GNU General Public License
  16      along with this program; if not, write to the Free Software
  17      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
  18 
  19      The Author may be reached as bir7@leland.stanford.edu or
  20      C/O Department of Mathematics; Stanford University; Stanford, CA 94305
  21  */
  22 
  23 #include <linux/types.h>
  24 #include <linux/sched.h>
  25 #include <linux/mm.h>
  26 #include <asm/memory.h>
  27 #include <linux/socket.h>
  28 #include <netinet/in.h>
  29 #include <linux/fcntl.h>
  30 #include "timer.h"
  31 #include "ip.h"
  32 #include "icmp.h"
  33 #include "tcp.h"
  34 #include "sock.h"
  35 #include <linux/errno.h>
  36 #include <linux/timer.h>
  37 #include <asm/system.h>
  38 #include <asm/segment.h>
  39 /* #include <signal.h>*/
  40 #include "../kern_sock.h" /* for PRINTK */
  41 
  42 #define tmax(a,b) (before ((a),(b)) ? (b) : (a))
  43 #define swap(a,b) {unsigned long c; c=a; a=b; b=c;}
  44 
  45 extern struct proto tcp_prot;
  46 
  47 static  int 
  48 min (unsigned int a, unsigned int b)
     /* [previous][next][first][last][top][bottom][index][help] */
  49 {
  50    if (a < b) return (a);
  51    return (b);
  52 }
  53 
  54 void
  55 print_th (struct tcp_header *th)
     /* [previous][next][first][last][top][bottom][index][help] */
  56 {
  57    unsigned char *ptr;
  58    ptr = (unsigned char *)(th + 1);
  59    PRINTK ("tcp header:\n");
  60    PRINTK ("  source=%d, dest=%d, seq =%d, ack_seq = %d\n",
  61            net16(th->source), net16(th->dest), net32(th->seq),
  62            net32(th->ack_seq));
  63    PRINTK ("  fin=%d, syn=%d, rst=%d, psh=%d, ack=%d, urg=%d res1=%d res2=%d\n"
  64            ,th->fin, th->syn, th->rst, th->psh, th->ack, th->urg,
  65            th->res1, th->res2);
  66    PRINTK ("  window = %d, check = %d urg_ptr = %d\n",
  67            net16(th->window), net16(th->check), net16(th->urg_ptr));
  68    PRINTK ("  doff = %d\n",th->doff);
  69    PRINTK ("options = %d %d %d %d\n", ptr[0], ptr[1], ptr[2], ptr[3]);
  70  }
  71 
  72  /* This routine grabs the first thing off of a rcv queue. */
  73 static  struct sk_buff *
  74 get_firstr(volatile struct sock *sk)
     /* [previous][next][first][last][top][bottom][index][help] */
  75 {
  76    struct sk_buff *skb;
  77    skb = sk->rqueue;
  78    if (skb == NULL) return (NULL);
  79    sk->rqueue = skb->next;
  80    if (sk->rqueue == skb)
  81      {
  82        sk->rqueue = NULL;
  83      }
  84    else
  85      {
  86        sk->rqueue->prev=skb->prev;
  87        sk->rqueue->prev->next = sk->rqueue;
  88      }
  89    return (skb);
  90 }
  91 
  92 static  long
  93 diff (unsigned long seq1, unsigned long seq2)
     /* [previous][next][first][last][top][bottom][index][help] */
  94 {
  95    long d;
  96    d=seq1-seq2;
  97    if (d > 0) return (d);
  98    /* I hope this returns what I want. */
  99    return (~d+1);
 100 }
 101 
 102  /* enter the time wait state. */
 103 static  void
 104 tcp_time_wait (volatile struct sock *sk)
     /* [previous][next][first][last][top][bottom][index][help] */
 105 {
 106    sk->state = TCP_TIME_WAIT;
 107    sk->time_wait.len = TCP_TIMEWAIT_LEN;
 108    sk->timeout = TIME_CLOSE;
 109    reset_timer ((struct timer *)&sk->time_wait);
 110 }
 111 
 112 static void
 113 tcp_retransmit (volatile struct sock *sk, int all)
     /* [previous][next][first][last][top][bottom][index][help] */
 114 {
 115    if (all) 
 116      {
 117         ip_retransmit (sk, all);
 118         return;
 119      }
 120    sk->rtt *= 2; /* exponential back off. */
 121    if (sk->cong_window > 1)
 122      sk->cong_window = sk->cong_window / 2;
 123    sk->exp_growth = 0;
 124 
 125    /* do the actuall retransmit. */
 126    ip_retransmit (sk, all);
 127    
 128 }
 129 
 130 /* this routine is called by the icmp module when it gets some
 131    sort of error condition.  If err < 0 then the socket should
 132    be closed and the error returned to the user.  If err > 0
 133    it's just the icmp type << 8 | icmp code.  
 134    header points to the first 8 bytes of the tcp header.  We need
 135    to find the appropriate port. */
 136 
 137 void
 138 tcp_err (int err, unsigned char *header, unsigned long daddr,
     /* [previous][next][first][last][top][bottom][index][help] */
 139          unsigned long saddr, struct ip_protocol *protocol)
 140 {
 141    struct tcp_header *th;
 142    volatile struct sock *sk;
 143    
 144    th = (struct tcp_header *)header;
 145    sk = get_sock (&tcp_prot, net16(th->dest), saddr, th->source, daddr);
 146 
 147    if (sk == NULL) return;
 148 
 149    if (err & 0xff00 == (ICMP_SOURCE_QUENCH << 8))
 150      {
 151         /* for now we will just trigger a linear backoff. The slow start
 152            code should cause a real backoff here. */
 153 
 154         if (sk->cong_window > 1)
 155           sk->cong_window --;
 156 
 157         return;
 158      }
 159 
 160    sk->err = icmp_err_convert[err & 0xff].errno;
 161    if (icmp_err_convert[err & 0xff].fatal)
 162      {
 163         if (sk->state != TCP_ESTABLISHED)
 164           sk->state = TCP_CLOSE;
 165         sk->prot->close(sk, 0);
 166      }
 167 
 168    return;
 169    
 170 }
 171 
 172 static int
 173 tcp_select (volatile struct sock *sk, int sel_type, select_table *wait)
     /* [previous][next][first][last][top][bottom][index][help] */
 174 {
 175   switch (sel_type)
 176     {
 177     case SEL_IN:
 178        select_wait (sk->sleep, wait);
 179        if (sk->rqueue != NULL &&
 180            (between (sk->copied_seq, sk->rqueue->next->h.th->seq - 1,
 181                      sk->rqueue->next->h.th->seq + sk->rqueue->next->len) ||
 182             sk->state == TCP_LISTEN))
 183          {
 184             return (1);
 185          }
 186 
 187       switch (sk->state)
 188         {
 189         case TCP_LISTEN:
 190         case TCP_ESTABLISHED:
 191         case TCP_SYN_SENT:
 192         case TCP_SYN_RECV:
 193            return (0);
 194         default:
 195            return (1);
 196         }
 197 
 198     case SEL_OUT:
 199        select_wait (sk->sleep, wait);
 200        if (sk->state != TCP_ESTABLISHED) return (1);
 201       /* hack so it will probably be able to write something
 202          if it says it's ok to write. */
 203       if (sk->prot->wspace(sk) >= MIN_WRITE_SPACE) return (1);
 204       return (0);
 205 
 206     case SEL_EX:
 207       select_wait(sk->sleep,wait);
 208       if (sk->err) return (1);
 209       if (sk->state == TCP_FIN_WAIT1 ||
 210           sk->state == TCP_FIN_WAIT2 ||
 211           sk->state == TCP_TIME_WAIT ||
 212           sk->state == TCP_LAST_ACK)
 213         return (1);
 214       return (0);
 215     }
 216   return (0);
 217 }
 218 
 219 static int
 220 tcp_ioctl (volatile struct sock *sk, int cmd, unsigned long arg)
     /* [previous][next][first][last][top][bottom][index][help] */
 221 {
 222    switch (cmd)
 223      {
 224        default:
 225         return (-EINVAL);
 226 #if 0
 227        case SIOCATMARK:
 228         /* try to figure out if we need to read some urgent data. */
 229         if (sk->rqueue && sk->rqueue->next->th.urg)
 230           {
 231              int offset;
 232              struct sk_buff *skb;
 233              skb = sk->rqueue->next;
 234              offset = sk->copied_seq +1 - skb->th.seq - skb->th.syn;
 235              /* now we know we are at the urgent data. */
 236              if (offset >= skb->len)
 237                {
 238                   verify_area ((void *)arg, sizeof (int));
 239                   put_fs_long(1, (unsigned long *)arg);
 240                   return (0);
 241                }
 242           }
 243         verify_area ((void *)arg, sizeof (int));
 244         put_fs_long(0, (unsigned long *)arg);
 245         return (0);
 246 #endif
 247      }
 248 }
 249 
 250 
 251 /* this routine computes a tcp checksum */
 252 static  unsigned short
 253 tcp_check (struct tcp_header *th, int len, unsigned long saddr,
     /* [previous][next][first][last][top][bottom][index][help] */
 254            unsigned long daddr)
 255 {     
 256    unsigned long sum;
 257    
 258    if (saddr == 0) saddr = MY_IP_ADDR;
 259    print_th (th);
 260    __asm__("\t addl %%ecx,%%ebx\n"
 261            "\t adcl %%edx,%%ebx\n"
 262            "\t adcl $0, %%ebx\n"
 263            : "=b" (sum)
 264            : "0" (daddr), "c" (saddr), "d" ((net16(len) << 16) + IP_TCP*256)
 265            : "cx","bx","dx" );
 266    
 267    if (len > 3)
 268      {
 269         __asm__(
 270                 "\tclc\n"
 271                 "1:\n"
 272                 "\t lodsl\n"
 273                 "\t adcl %%eax, %%ebx\n"
 274                 "\t loop 1b\n"
 275                 "\t adcl $0, %%ebx\n"
 276                 : "=b" (sum) , "=S" (th)
 277                 : "0" (sum), "c" (len/4) ,"1" (th)
 278                 : "ax", "cx", "bx", "si" );
 279      }
 280    
 281    /* convert from 32 bits to 16 bits. */
 282    __asm__(
 283            "\t movl %%ebx, %%ecx\n"
 284            "\t shrl $16,%%ecx\n"
 285            "\t addw %%cx, %%bx\n"
 286            "\t adcw $0, %%bx\n"
 287            : "=b" (sum)
 288            : "0" (sum)
 289            : "bx", "cx");
 290    
 291    /* check for an extra word. */
 292    if ((len & 2) != 0)
 293      {
 294         __asm__("\t lodsw\n"
 295                 "\t addw %%ax,%%bx\n"
 296                 "\t adcw $0, %%bx\n"
 297                 : "=b" (sum), "=S" (th)
 298                 : "0" (sum) ,"1" (th)
 299                 : "si", "ax", "bx");
 300      }
 301    
 302    /* now check for the extra byte. */
 303    if ((len & 1) != 0)
 304      {
 305         __asm__("\t lodsb\n"
 306                 "\t movb $0,%%ah\n"
 307                 "\t addw %%ax,%%bx\n"
 308                 "\t adcw $0, %%bx\n"
 309                 : "=b" (sum)
 310                 : "0" (sum) ,"S" (th)
 311                 : "si", "ax", "bx");
 312      }
 313    
 314    /* we only want the bottom 16 bits, but we never cleared
 315       the top 16. */
 316    return ((~sum) & 0xffff);
 317 }
 318 
 319 
 320 static  void
 321 tcp_send_check (struct tcp_header *th, unsigned long saddr, 
     /* [previous][next][first][last][top][bottom][index][help] */
 322                  unsigned long daddr, int len, volatile struct sock *sk)
 323  {
 324 
 325    th->check = 0;
 326    if (sk && sk->no_check) return;
 327    th->check = tcp_check (th, len, saddr, daddr);
 328    return;
 329 }
 330 
 331  /* This routine sends an ack and also updates the window. */
 332  static  void
 333  tcp_send_ack (unsigned long sequence, unsigned long ack,
     /* [previous][next][first][last][top][bottom][index][help] */
 334                volatile struct sock *sk,
 335                struct tcp_header *th, unsigned long daddr)
 336  {
 337    struct sk_buff *buff;
 338    struct tcp_header *t1;
 339    struct device *dev=NULL;
 340    int tmp;
 341 
 342    /* we need to grab some memory, and put together an ack, and then
 343       put it into the queue to be sent. */
 344 
 345    buff=sk->prot->wmalloc(sk,MAX_ACK_SIZE,1);
 346    if (buff == NULL) 
 347      {
 348         /* force it to send an ack. */
 349         sk->ack_backlog++;
 350         if (sk->timeout != TIME_WRITE && sk->state < TCP_CLOSING)
 351           {
 352              sk->timeout = TIME_WRITE;
 353              sk->time_wait.len = 10; /* got to do it quickly. */
 354              reset_timer ((struct timer *)&sk->time_wait);
 355           }
 356         return;
 357      }
 358 
 359    buff->mem_addr = buff;
 360    buff->mem_len = MAX_ACK_SIZE;
 361    buff->len=sizeof (struct tcp_header);
 362    buff->sk = sk;
 363    t1 = (struct tcp_header *)(buff + 1);
 364    /* put in the ip_header and routing stuff. */
 365    tmp = sk->prot->build_header (buff, sk->saddr, daddr, &dev,
 366                                  IP_TCP, sk->opt, MAX_ACK_SIZE);
 367    if (tmp < 0)
 368      {
 369        sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
 370        return;
 371      }
 372    buff->len += tmp;
 373    t1 = (struct tcp_header *)((char *)t1 +tmp);
 374 
 375    memcpy (t1, th, sizeof (*t1)); /* this should probably be removed. */
 376 
 377    /* swap the send and the receive. */
 378    t1->dest = th->source;
 379    t1->source = th->dest;
 380    t1->seq = net32(sequence);
 381    t1->ack = 1;
 382    sk->window = sk->prot->rspace(sk);
 383    t1->window = net16(sk->window);
 384    t1->res1=0;
 385    t1->res2=0;
 386    t1->rst = 0;
 387    t1->urg = 0;
 388    t1->syn = 0;
 389    t1->psh = 0;
 390    t1->fin = 0;
 391    if (ack == sk->acked_seq)
 392      {
 393         sk->ack_backlog = 0;
 394         sk->bytes_rcv = 0;
 395         sk->ack_timed = 0;
 396         if (sk->send_head == NULL &&
 397             sk->wfront == NULL)
 398           {
 399              delete_timer((struct timer *)&sk->time_wait);
 400              sk->timeout = 0;
 401           }
 402         
 403      }
 404    t1->ack_seq = net32(ack);
 405    t1->doff = sizeof (*t1)/4;
 406    tcp_send_check (t1, sk->saddr, daddr, sizeof (*t1), sk);
 407    sk->prot->queue_xmit(sk, dev, buff, 1);
 408 }
 409 
 410 /* this routine builds a generic tcp header. */
 411 static  int
 412 tcp_build_header(struct tcp_header *th, volatile struct sock *sk, int push)
     /* [previous][next][first][last][top][bottom][index][help] */
 413 {
 414 
 415  /* want to get rid of this. */
 416   memcpy (th,(void *) &(sk->dummy_th), sizeof (*th));
 417   th->seq = net32(sk->send_seq);
 418   th->psh = (push == 0) ? 1 : 0;
 419   th->doff = sizeof (*th)/4;
 420   th->ack = 1;
 421   th->fin = 0;
 422   sk->ack_backlog = 0;
 423   sk->bytes_rcv = 0;
 424   sk->ack_timed = 0;
 425   th->ack_seq = net32(sk->acked_seq);
 426   sk->window = sk->prot->rspace(sk);
 427   th->window = net16(sk->window);
 428 
 429   return (sizeof (*th));
 430 }
 431 
 432 /* This routine copies from a user buffer into a socket, and starts
 433    the transmit system. */
 434 
 435 static int
 436 tcp_write(volatile struct sock *sk, unsigned char *from,
     /* [previous][next][first][last][top][bottom][index][help] */
 437           int len, int nonblock, unsigned flags)
 438 {
 439   int copied=0;
 440   int copy;
 441   int tmp;
 442   struct sk_buff *skb;
 443   unsigned char *buff;
 444   struct proto *prot;
 445   struct device *dev=NULL;
 446 
 447   PRINTK ("in TCP_WRITE sk = %X:\n",sk);
 448   print_sk (sk);
 449 
 450   sk->inuse = 1; /* no one else will use this socket. */
 451   prot = sk->prot;
 452   while (len > 0)
 453     {
 454        /* first thing we do is make sure that we are established. */     
 455 
 456       while (sk->state != TCP_ESTABLISHED)
 457         {
 458           if (sk->state != TCP_SYN_SENT &&
 459               sk->state != TCP_SYN_RECV)
 460            {
 461               release_sock (sk);
 462               if (sk->keepopen)
 463                 {
 464                     send_sig (SIGPIPE, current, 0);
 465                     return (-EINTR);
 466                 }
 467               if (copied) return (copied);
 468               if (sk->err) return (-sk->err);
 469               return (-ENOTCONN);
 470             }
 471 
 472           if (nonblock)
 473             {
 474               release_sock (sk);
 475               return (-EAGAIN);
 476             }
 477 
 478           /* now here is a race condition.
 479              release_sock could cause the connection to
 480              enter the established mode, if that is the
 481              case, then we will block here for ever, because
 482              we will have gotten our wakeup call before we
 483              go to sleep. */
 484           release_sock (sk);
 485           cli();
 486           if (sk->state != TCP_ESTABLISHED)
 487             {
 488               interruptible_sleep_on (sk->sleep);
 489               if (current->signal & ~current->blocked)
 490                 {
 491                    sti();
 492                    if (copied) return (copied);
 493                    return (-ERESTARTSYS);
 494                 }
 495             }
 496           sti();
 497           sk->inuse = 1;
 498         }
 499       /* we also need to worry about the window.  The smallest we
 500          will send is about 200 bytes. */
 501 
 502       copy = min (sk->mtu, diff(sk->window_seq, sk->send_seq));
 503       if (copy < 200) copy = sk->mtu;
 504       copy = min (copy, len);
 505 
 506       skb=prot->wmalloc (sk, copy + prot->max_header+sizeof (*skb),0);
 507 
 508       /* if we didn't get any memory, we need to sleep. */
 509       if (skb == NULL)
 510         {
 511           if (nonblock ||  copied)
 512             {
 513               break;
 514             }
 515           /* here is another race condition. */
 516           tmp = sk->wmem_alloc;
 517           release_sock (sk);
 518           /* again we will try to avoid it. */
 519           cli ();
 520           if (tmp <= sk->wmem_alloc)
 521             {
 522               interruptible_sleep_on (sk->sleep);
 523               if (current->signal & ~current->blocked)
 524                 {
 525                    sti();
 526                    if (copied) return (copied);
 527                    return (-ERESTARTSYS);
 528                 }
 529             }
 530           sti();
 531           sk->inuse = 1;
 532           continue;
 533         }
 534       skb->mem_addr = skb;
 535       skb->mem_len = copy+prot->max_header+sizeof (*skb);
 536       skb->len = 0;
 537       skb->sk = sk;
 538       buff =(unsigned char *)( skb+1);
 539        /* we need to optimize this.  Perhaps some hints here
 540           would be good. */
 541 
 542       tmp = prot->build_header (skb, sk->saddr, sk->daddr, &dev,
 543                                 IP_TCP, sk->opt, skb->mem_len);
 544       if (tmp < 0 )
 545         {
 546           prot->wfree (sk, skb->mem_addr, skb->mem_len);
 547           release_sock (sk);
 548           return (tmp);
 549         }
 550       skb->len += tmp;
 551       skb->dev = dev;
 552       buff+=tmp;
 553       tmp = tcp_build_header((struct tcp_header *)buff, sk, len-copy);
 554       if (tmp < 0)
 555         {
 556           prot->wfree (sk, skb->mem_addr, skb->mem_len);
 557           release_sock (sk);
 558           return (tmp);
 559         }
 560 
 561       if (flags & MSG_OOB)
 562         {
 563                 ((struct tcp_header *)buff)->urg = 1;
 564                 ((struct tcp_header *)buff)->urg_ptr = copy;
 565         }
 566       skb->len += tmp;
 567       memcpy_fromfs (buff+tmp, from, copy);
 568 
 569       tcp_send_check ((struct tcp_header *)buff, sk->saddr, sk->daddr,
 570                        copy +sizeof (struct tcp_header), sk);
 571 
 572       from += copy;
 573       copied += copy;
 574       len -= copy;
 575       skb->len += copy;
 576       skb->free = 0;
 577       sk->send_seq += copy;
 578       skb->h.seq = sk->send_seq;
 579       if (after (sk->send_seq , sk->window_seq) ||
 580           sk->packets_out >= sk->cong_window)
 581         {
 582           PRINTK ("sk->cong_window = %d, sk->packets_out = %d\n",
 583                   sk->cong_window, sk->packets_out);
 584           PRINTK ("sk->send_seq = %d, sk->window_seq = %d\n",
 585                   sk->send_seq, sk->window_seq);
 586           skb->next = NULL;
 587           if (sk->wback == NULL)
 588             {
 589               sk->wfront=skb;
 590             }
 591           else
 592             {
 593               sk->wback->next = skb;
 594             }
 595           sk->wback = skb;
 596         }
 597       else
 598         {
 599           prot->queue_xmit (sk, dev, skb,0);
 600         }
 601     }
 602   sk->err = 0;
 603   release_sock (sk);
 604   return (copied);
 605 }
 606 
 607 
 608 static  void
 609 tcp_read_wakeup(volatile struct sock *sk)
     /* [previous][next][first][last][top][bottom][index][help] */
 610 {
 611   int tmp;
 612   struct device *dev = NULL;
 613   struct tcp_header *t1;
 614   struct sk_buff *buff;
 615 
 616   if (!sk->ack_backlog ) return;
 617   PRINTK ("in tcp read wakeup\n");
 618   /* we need to put code here to prevent this routine from being called. */
 619   /* being called once in a while is ok, so only check if this is the
 620      second time in a row. */
 621 
 622   /* we need to grab some memory, and put together an ack, and then
 623      put it into the queue to be sent. */
 624 
 625   buff=sk->prot->wmalloc(sk,MAX_ACK_SIZE,1);
 626   if (buff == NULL) 
 627     {
 628        /* try again real soon. */
 629        sk->timeout = TIME_WRITE;
 630        sk->time_wait.len = 10;
 631        reset_timer((struct timer *) &sk->time_wait);
 632        return;
 633     }
 634 
 635   buff->mem_addr = buff;
 636   buff->mem_len = MAX_ACK_SIZE;
 637   buff->len=sizeof (struct tcp_header);
 638   buff->sk = sk;
 639 
 640   /* put in the ip_header and routing stuff. */
 641   tmp = sk->prot->build_header (buff, sk->saddr, sk->daddr, &dev,
 642                                 IP_TCP, sk->opt, MAX_ACK_SIZE);
 643   if (tmp < 0)
 644     {
 645       sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
 646       return;
 647     }
 648 
 649   buff->len += tmp;
 650   t1 = (struct tcp_header *)((char *)(buff+1) +tmp);
 651 
 652   memcpy (t1,(void *) &sk->dummy_th, sizeof (*t1));
 653   t1->seq = net32(sk->send_seq);
 654   t1->ack = 1;
 655   t1->res1=0;
 656   t1->res2=0;
 657   t1->rst = 0;
 658   t1->urg = 0;
 659   t1->syn = 0;
 660   t1->psh = 0;
 661   sk->ack_backlog = 0;
 662   sk->bytes_rcv = 0;
 663   sk->window = sk->prot->rspace(sk);
 664   t1->window = net16(sk->window);
 665   t1->ack_seq = net32(sk->acked_seq);
 666   t1->doff = sizeof (*t1)/4;
 667   tcp_send_check (t1, sk->saddr, sk->daddr, sizeof (*t1), sk);
 668   sk->prot->queue_xmit(sk, dev, buff, 1);
 669 }
 670 
 671 
 672 /* This routine frees used buffers. */
 673 /* It should consider sending an ack to let the
 674    other end know we now have a bigger window. */
 675 
 676 static  void
 677 cleanup_rbuf (volatile struct sock *sk)
     /* [previous][next][first][last][top][bottom][index][help] */
 678 {
 679    PRINTK ("cleaning rbuf for sk=%X\n",sk);
 680   /* we have to loop through all the buffer headers, and 
 681      try to free up all the space we can. */
 682   while (sk->rqueue != NULL )
 683     {
 684       struct sk_buff *skb;
 685       skb=sk->rqueue->next;
 686       if (!skb->used) break;
 687       if (sk->rqueue == skb)
 688         {
 689           sk->rqueue = NULL;
 690         }
 691       else
 692         {
 693           skb->next->prev = skb->prev;
 694           skb->prev->next = skb->next;
 695         }
 696       skb->sk = sk;
 697       free_skb (skb, FREE_READ);
 698     }
 699    /* at this point we should send an ack if the difference in
 700       the window, and the amount of space is bigger than
 701       TCP_WINDOW_DIFF */
 702    PRINTK ("sk->window left = %d, sk->prot->rspace(sk)=%d\n",
 703            sk->window - sk->bytes_rcv, sk->prot->rspace(sk));
 704 
 705    if ((sk->prot->rspace(sk) >
 706         (sk->window - sk->bytes_rcv + TCP_WINDOW_DIFF)) ||
 707        (sk->window - sk->bytes_rcv < 2*sk->mtu)) 
 708      {
 709         /* force it to send an ack. */
 710         sk->ack_backlog++;
 711         if (sk->timeout != TIME_WRITE && sk->state == TCP_ESTABLISHED)
 712           {
 713              sk->time_wait.len = TCP_ACK_TIME;
 714              sk->timeout=TIME_WRITE;
 715              reset_timer ((struct timer *)&sk->time_wait);
 716           }
 717      }
 718 
 719 }
 720 
 721 /* handle reading urgent data. */
 722 static  int
 723 tcp_read_urg(volatile struct sock * sk,
     /* [previous][next][first][last][top][bottom][index][help] */
 724              unsigned char *to, int len, unsigned flags)
 725 {
 726     int copied = 0;
 727     struct sk_buff *skb;
 728     PRINTK ("tcp_read_urg(sk=%X, to=%X, len=%d, flags=%X)\n",
 729             sk, to, len, flags);
 730     print_sk(sk);
 731     while (len > 0)
 732       {
 733          sk->inuse = 1;
 734           while (sk->urg==0 || sk->rqueue == NULL)
 735             {
 736                /* now at this point, we may have gotten some data. */
 737                release_sock (sk);
 738                 if (sk->state > TCP_CLOSING)
 739                   {
 740                       if (copied) return (copied);
 741                       return (-ENOTCONN);
 742                   }
 743                cli();
 744                if (sk->urg == 0 || sk->rqueue == NULL)
 745                  {
 746                     interruptible_sleep_on (sk->sleep);
 747                     if (current->signal & ~current->blocked)
 748                       {
 749                          sti();
 750                          if (copied) return (copied);
 751                          return (-ERESTARTSYS);
 752                       }
 753                  }
 754                sti();
 755                sk->inuse = 1;
 756             }
 757           /* now we have some urgent data, we must find it.*/
 758           for (skb = sk->rqueue->next; skb->next != sk->rqueue;
 759                skb = skb->next)
 760             {
 761                 int offset;
 762                 int amt;
 763                 if (!skb->h.th->urg) continue;
 764                 offset = 0;
 765                 amt = min(skb->h.th->urg_ptr,len);
 766                 verify_area (to, amt);
 767                 memcpy_tofs (to, (unsigned char *)(skb->h.th) +
 768                              skb->h.th->doff*4
 769                              + offset, amt);
 770 
 771                 if (!(flags & MSG_PEEK))
 772                   {
 773                      skb->urg_used = 1;
 774                      sk->urg --;
 775                   }
 776                 release_sock (sk);
 777                 copied += amt;
 778                 return (copied);
 779             }
 780       }
 781     return (0);
 782 }
 783 
 784 /* This routine copies from a sock struct into the user buffer. */
 785 static  int
 786 tcp_read(volatile struct sock *sk, unsigned char *to,
     /* [previous][next][first][last][top][bottom][index][help] */
 787          int len, int nonblock, unsigned flags)
 788 {
 789     int copied=0; /* will be used to say how much has been copied. */
 790     struct sk_buff *skb;
 791     unsigned long offset;
 792     unsigned long used;
 793 
 794     if (len == 0) return (0);
 795     if (len < 0) 
 796       {
 797          return (-EINVAL);
 798       }
 799     
 800     /* this error should be checked. */
 801     if (sk->state == TCP_LISTEN) return (-ENOTCONN);
 802 
 803     /* urgent data needs to be handled specially. */
 804     if ((flags & MSG_OOB))
 805       return (tcp_read_urg (sk, to, len, flags));
 806 
 807     /* so no-one else will use this socket. */
 808     sk->inuse = 1;
 809     if (sk->rqueue != NULL)
 810       skb=sk->rqueue->next;
 811     else
 812       skb = NULL;
 813 
 814     while ( len > 0)
 815       {
 816          PRINTK("tcp_read (sk=%X, to=%X, len=%d, nonblock=%d, flags=%X)\n",
 817                 sk, to, len, nonblock, flags);
 818           while ( skb == NULL || before (sk->copied_seq+1, skb->h.th->seq) ||
 819                  skb->used) /* skb->used just checks to see if we've
 820                                gone all the way around. */
 821             {
 822 
 823                PRINTK("skb = %X:\n",skb);
 824                print_skb(skb);
 825                print_sk (sk);
 826 
 827                cleanup_rbuf(sk);
 828 
 829                 if (nonblock || ((flags & MSG_PEEK) && copied))
 830                   {
 831                      release_sock (sk);
 832                      if (copied) return (copied);
 833                      return (-EAGAIN);
 834                   }
 835 
 836                 release_sock (sk); /* now we may have some data waiting. */
 837 
 838 
 839                PRINTK ("tcp_read about to sleep. state = %d\n",sk->state);
 840                cli();
 841 
 842                if (sk->state == TCP_CLOSE || sk->state == TCP_TIME_WAIT)
 843                    {
 844                      sti();
 845                      if (copied) return (copied);
 846                      if (sk->err) return (-sk->err);
 847                      if (!sk->done)
 848                        {
 849                           sk->done = 1;
 850                           return (0);
 851                        }
 852                      return (-ENOTCONN);
 853                   }
 854                         
 855                 if ( sk->rqueue == NULL ||
 856                     before (sk->copied_seq+1, sk->rqueue->next->h.th->seq))
 857                   {
 858                      interruptible_sleep_on (sk->sleep);
 859                      if (current->signal & ~current->blocked)
 860                        {
 861                           sti ();
 862                           if (copied) return (copied);
 863                           return (-ERESTARTSYS);
 864                        }
 865                   }
 866                 sti();
 867                 PRINTK ("tcp_read woke up. \n");
 868 
 869                 sk->inuse = 1;
 870 
 871                 if (sk->rqueue != NULL)
 872                   skb=sk->rqueue->next;
 873                 else
 874                   skb = NULL;
 875 
 876             }
 877 
 878           /* Copy anything from the current block that needs to go
 879              into the user buffer. */
 880 
 881          offset = sk->copied_seq+1 - skb->h.th->seq;
 882 
 883          if (skb->h.th->syn) offset --;
 884          if (offset < skb->len )
 885            {
 886               /* if there is urgent data we must either return or skip
 887                  over it. */
 888               if (skb->h.th->urg)
 889                 {
 890                    if (skb->urg_used)
 891                      {
 892                         if (flags & MSG_PEEK) break;
 893                         sk->copied_seq += skb->h.th->urg_ptr;
 894                         offset += skb->h.th->urg_ptr;
 895                         if (offset > skb->len)
 896                           {
 897                              skb->used = 1;
 898                              skb=skb->next;
 899                              continue;
 900                           }
 901                      }
 902                    else
 903                      {
 904                         break;
 905                      }
 906                 }
 907               used = min(skb->len - offset, len);
 908 
 909               verify_area (to, used);
 910               memcpy_tofs(to, ((unsigned char *)skb->h.th) +
 911                           skb->h.th->doff*4 +
 912                           offset,
 913                           used);
 914               copied += used;
 915               len -= used;
 916               to += used;
 917               if (!(flags & MSG_PEEK))
 918                 sk->copied_seq += used;
 919               
 920               /* mark this data used if we are really reading it, and if
 921                  it doesn't contain any urgent data. And we have used all
 922                  the data. */
 923               if (!(flags & MSG_PEEK) &&
 924                   (!skb->h.th->urg || skb->urg_used) &&
 925                   (used + offset >= skb->len) )
 926                 skb->used = 1;
 927               
 928               /* see if this is the end of a message or if the remaining data
 929                  is urgent. */
 930               if ( skb->h.th->psh || skb->h.th->urg)
 931                 {
 932                    break;
 933                 }
 934            }
 935          else /* already used this data, must be a retransmit. */
 936            {
 937               skb->used = 1;
 938            }
 939          skb=skb->next;
 940       }
 941     cleanup_rbuf (sk);
 942     release_sock (sk);
 943     if (copied == 0 && nonblock) return (-EAGAIN);
 944     return (copied);
 945 }
 946 
 947 /* this routine will send a reset to the other tcp. */
 948 static  void
 949 tcp_reset(unsigned long saddr, unsigned long daddr, struct tcp_header *th,
     /* [previous][next][first][last][top][bottom][index][help] */
 950            struct proto *prot, struct options *opt, struct device *dev)
 951 {
 952   /* we need to grab some memory, and put together a reset, and then
 953      put it into the queue to be sent. */
 954   struct sk_buff *buff;
 955   struct tcp_header *t1;
 956   int tmp;
 957   buff=prot->wmalloc(NULL, MAX_RESET_SIZE,1);
 958   if (buff == NULL) return;
 959 
 960   PRINTK("tcp_reset buff = %X\n", buff);
 961   buff->mem_addr = buff;
 962   buff->mem_len = MAX_RESET_SIZE;
 963   buff->len = sizeof (*t1);
 964   buff->sk = NULL;
 965   buff->dev = dev;
 966 
 967   t1=(struct tcp_header *)(buff + 1);
 968   /* put in the ip_header and routing stuff. */
 969   tmp = prot->build_header (buff, saddr, daddr, &dev, IP_TCP, opt,
 970                             sizeof(struct tcp_header));
 971   if (tmp < 0)
 972     {
 973       prot->wfree (NULL,buff->mem_addr, buff->mem_len);
 974       return;
 975     }
 976   t1 = (struct tcp_header *)((char *)t1 +tmp);
 977   buff->len += tmp;
 978   memcpy (t1, th, sizeof (*t1));
 979   /* swap the send and the receive. */
 980   t1->dest = th->source;
 981   t1->source = th->dest;
 982   t1->seq = th->ack_seq; /* add one so it will be in
 983                             the right range.*/
 984   t1->rst = 1;
 985   t1->ack = 0;
 986   t1->syn = 0;
 987   t1->urg = 0;
 988   t1->fin = 0;
 989   t1->psh = 0;
 990   t1->doff = sizeof (*t1)/4;
 991   tcp_send_check (t1, saddr, daddr, sizeof (*t1), NULL);
 992   prot->queue_xmit(NULL, dev, buff, 1);
 993   
 994 }
 995 
 996 
 997 /* This routine handles a connection request.  This should make sure
 998    we haven't already responded. */
 999 /* Because of the way BSD works, we have to send a syn/ack now. This also
1000  means it will be harder to close a socket which is listening. */
1001 
1002 static  void
1003 tcp_conn_request(volatile struct sock *sk, struct sk_buff *skb,
     /* [previous][next][first][last][top][bottom][index][help] */
1004                  unsigned long daddr,
1005                  unsigned long saddr, struct options *opt, struct device *dev)
1006 {
1007   struct sk_buff *buff;
1008   struct tcp_header *t1;
1009   unsigned char *ptr;
1010   volatile struct sock *newsk;
1011   struct tcp_header *th;
1012   int tmp;
1013   th = skb->h.th;
1014 
1015   PRINTK ("tcp_conn_request (sk = %X, skb = %X, daddr = %X, sadd4= %X, \n"
1016           "                  opt = %X, dev = %X)\n",
1017           sk, skb, daddr, saddr, opt, dev);
1018   
1019   /* if the socket is dead, don't accept the connection. */
1020   if (!sk->dead)
1021     {
1022        wake_up(sk->sleep);
1023     }
1024   else
1025     {
1026        PRINTK ("tcp_conn_request on dead socket\n");
1027        tcp_reset (daddr, saddr, th, sk->prot, opt, dev);
1028        free_skb (skb, FREE_READ);
1029        return;
1030     }
1031 
1032 
1033   /* we need to build a new sock struct. */
1034   /* It is sort of bad to have a socket without an inode attached to
1035      it, but the wake_up's will just wake up the listening socket,
1036      and if the listening socket is destroyed before this is taken
1037      off of the queue, this will take care of it. */
1038 
1039   newsk = malloc(sizeof (struct sock));
1040   if (newsk == NULL) 
1041     {
1042        /* just ignore the syn.  It will get retransmitted. */
1043        free_skb (skb, FREE_READ);
1044        return;
1045     }
1046 
1047 
1048   PRINTK ("newsk = %X\n", newsk);
1049   memcpy ((void *)newsk, (void *)sk, sizeof (*newsk));
1050   newsk->wback = NULL;
1051   newsk->wfront = NULL;
1052   newsk->rqueue = NULL;
1053   newsk->send_head = NULL;
1054   newsk->send_tail = NULL;
1055   newsk->back_log = NULL;
1056   newsk->blog = 0;
1057   newsk->intr = 0;
1058   newsk->proc = 0;
1059   newsk->done = 0;
1060 
1061   newsk->pair = NULL;
1062   newsk->wmem_alloc = 0;
1063   newsk->rmem_alloc = 0;
1064 
1065   newsk->max_unacked = MAX_WINDOW - TCP_WINDOW_DIFF;
1066 
1067   newsk->err = 0;
1068   newsk->shutdown = 0;
1069   newsk->ack_backlog = 0;
1070   newsk->acked_seq = skb->h.th->seq+1;
1071   newsk->fin_seq = skb->h.th->seq;
1072   newsk->copied_seq = skb->h.th->seq;
1073   newsk->state = TCP_SYN_RECV;
1074   newsk->timeout = 0;
1075   newsk->send_seq = timer_seq*SEQ_TICK-seq_offset;
1076   newsk->rcv_ack_seq = newsk->send_seq;
1077   newsk->urg =0;
1078   newsk->retransmits = 0;
1079   newsk->destroy = 0;
1080   newsk->time_wait.sk = newsk;
1081   newsk->time_wait.next = NULL;
1082   newsk->dummy_th.source = skb->h.th->dest;
1083   newsk->dummy_th.dest = skb->h.th->source;
1084   /* swap these two, they are from our point of view. */
1085   newsk->daddr=saddr;
1086   newsk->saddr=daddr;
1087 
1088   put_sock (newsk->num,newsk);
1089   newsk->dummy_th.res1=0;
1090   newsk->dummy_th.doff=6;
1091   newsk->dummy_th.fin=0;
1092   newsk->dummy_th.syn=0;
1093   newsk->dummy_th.rst=0;
1094   newsk->dummy_th.psh=0;
1095   newsk->dummy_th.ack=0;
1096   newsk->dummy_th.urg=0;
1097   newsk->dummy_th.res2=0;
1098   newsk->acked_seq = skb->h.th->seq+1;
1099   newsk->copied_seq = skb->h.th->seq;
1100 
1101   if (skb->h.th->doff == 5)
1102     {
1103       newsk->mtu=dev->mtu-HEADER_SIZE;
1104     }
1105   else
1106     {
1107       ptr = (unsigned char *)(skb+1);
1108       if (ptr[0] != 2 || ptr[1] != 4)
1109         {
1110            newsk->mtu=576-HEADER_SIZE;
1111         }
1112       else
1113         {
1114           newsk->mtu = min (ptr[2]*256+ptr[3]-HEADER_SIZE,
1115                             dev->mtu-HEADER_SIZE);
1116         }
1117     }
1118 
1119   print_sk (newsk);
1120   buff=newsk->prot->wmalloc(newsk,MAX_SYN_SIZE,1);
1121   if (buff == NULL)
1122     {
1123        sk->err = -ENOMEM;
1124        newsk->dead = 1;
1125        release_sock (newsk);
1126        free_skb (skb, FREE_READ);
1127        return;
1128     }
1129   
1130   buff->mem_addr = buff;
1131   buff->mem_len = MAX_SYN_SIZE;
1132   buff->len=sizeof (struct tcp_header)+4;
1133   buff->sk = newsk;
1134   
1135   t1=(struct tcp_header *)(buff + 1);
1136   /* put in the ip_header and routing stuff. */
1137 
1138   tmp = sk->prot->build_header (buff, newsk->saddr, newsk->daddr, &dev,
1139                                 IP_TCP, NULL, MAX_SYN_SIZE);
1140 
1141   /* something went wrong. */
1142   if (tmp < 0)
1143     {
1144        sk->err = tmp;
1145        sk->prot->wfree(newsk, buff->mem_addr, buff->mem_len);
1146        newsk->dead = 1;
1147        release_sock (newsk);
1148        free_skb (skb, FREE_READ);
1149        return;
1150     }
1151 
1152   buff->len += tmp;
1153   t1 = (struct tcp_header *)((char *)t1 +tmp);
1154   
1155   memcpy (t1, skb->h.th, sizeof (*t1));
1156   buff->h.seq = newsk->send_seq;
1157   /* swap the send and the receive. */
1158   t1->dest = skb->h.th->source;
1159   t1->source = newsk->dummy_th.source;
1160   t1->seq = net32(newsk->send_seq++);
1161   t1->ack = 1;
1162   newsk->window = sk->prot->rspace(newsk);
1163   t1->window = net16(newsk->window);
1164   t1->res1=0;
1165   t1->res2=0;
1166   t1->rst = 0;
1167   t1->urg = 0;
1168   t1->psh = 0;
1169   t1->syn = 1;
1170   t1->ack_seq = net32(skb->h.th->seq+1);
1171   t1->doff = sizeof (*t1)/4+1;
1172 
1173   ptr = (unsigned char *)(t1+1);
1174   ptr[0]=2;
1175   ptr[1]=4;
1176   ptr[2]=((dev->mtu - HEADER_SIZE) >> 8) & 0xff;
1177   ptr[3]=(dev->mtu - HEADER_SIZE) & 0xff;
1178 
1179   tcp_send_check (t1, daddr, saddr, sizeof (*t1)+4, newsk);
1180   newsk->prot->queue_xmit(newsk, dev, buff, 0);
1181 
1182   newsk->time_wait.len = TCP_CONNECT_TIME;
1183   PRINTK ("newsk->time_wait.sk = %X\n", newsk->time_wait.sk);
1184   reset_timer ((struct timer *)&newsk->time_wait);
1185   skb->sk = newsk;
1186   /* charge the sock_buff to newsk. */
1187   sk->rmem_alloc -= skb->mem_len;
1188   newsk->rmem_alloc += skb->mem_len;
1189 
1190   if (sk->rqueue == NULL)
1191     {
1192       skb->next = skb;
1193       skb->prev = skb;
1194       sk->rqueue = skb;
1195     }
1196   else
1197     {
1198       skb->next = sk->rqueue;
1199       skb->prev = sk->rqueue->prev;
1200       sk->rqueue->prev = skb;
1201       skb->prev->next = skb;
1202     }
1203   release_sock (newsk);
1204 }
1205 
1206 static  void
1207 tcp_close (volatile struct sock *sk, int timeout)
     /* [previous][next][first][last][top][bottom][index][help] */
1208 {
1209   /* we need to grab some memory, and put together a fin, and then
1210      put it into the queue to be sent. */
1211   struct sk_buff *buff;
1212   int need_reset = 0;
1213   struct tcp_header *t1,*th;
1214   struct proto *prot;
1215   struct device *dev=NULL;
1216   int tmp;
1217   PRINTK ("tcp_close ((struct sock *)%X, %d)\n",sk, timeout);
1218   sk->inuse = 1;
1219   sk->keepopen = 0;
1220   sk->shutdown = SHUTDOWN_MASK;
1221 
1222   if (!sk->dead)
1223     wake_up (sk->sleep);
1224 
1225 
1226   /* we need to flush the recv. buffs. */
1227   
1228   if (sk->rqueue != NULL)
1229     {
1230        struct sk_buff *skb;
1231        struct sk_buff *skb2;
1232        skb = sk->rqueue;
1233        do {
1234           skb2=skb->next;
1235           free_skb (skb, FREE_READ);
1236           skb=skb2;
1237        } while (skb != sk->rqueue);
1238        need_reset = 1;
1239     }
1240   sk->rqueue = NULL;
1241 
1242 
1243   switch (sk->state)
1244     {
1245       case TCP_FIN_WAIT1:
1246       case TCP_FIN_WAIT2:
1247       case TCP_LAST_ACK:
1248        if (timeout)
1249          tcp_time_wait(sk);
1250        release_sock (sk);
1251        if (!need_reset)
1252          return;
1253        break;
1254 
1255       case TCP_TIME_WAIT:
1256        if (timeout)
1257          sk->state = TCP_CLOSE;
1258        release_sock (sk);
1259        return;
1260 
1261       case TCP_LISTEN:
1262        sk->state = TCP_CLOSE;
1263        release_sock(sk);
1264        return;
1265 
1266       case TCP_CLOSE:
1267 
1268        release_sock(sk);
1269        return;
1270        
1271 
1272     case TCP_ESTABLISHED:
1273     case TCP_SYN_SENT:
1274     case TCP_SYN_RECV:
1275 
1276       prot = (struct proto *)sk->prot;
1277       th=(struct tcp_header *)&sk->dummy_th;
1278 
1279        buff=prot->wmalloc(sk, MAX_FIN_SIZE,1);
1280        if (buff == NULL)
1281          {
1282             /* this will force it to try again later. */
1283             sk->state = TCP_ESTABLISHED;
1284             sk->timeout = TIME_CLOSE;
1285             sk->time_wait.len = 100; /* wait a second. */
1286             reset_timer ((struct timer *)&sk->time_wait);
1287             return;
1288          }
1289 
1290       buff->mem_addr = buff;
1291       buff->mem_len = MAX_FIN_SIZE;
1292       buff->sk = sk;
1293       buff->len = sizeof (*t1);
1294       t1=(struct tcp_header *)(buff + 1);
1295       /* put in the ip_header and routing stuff. */
1296       tmp = prot->build_header (buff,sk->saddr, sk->daddr, &dev,
1297                                 IP_TCP, sk->opt,
1298                                 sizeof(struct tcp_header));
1299       if (tmp < 0)
1300         {
1301           prot->wfree (sk,buff->mem_addr, buff->mem_len);
1302           PRINTK ("Unable to build header for fin.\n");
1303           release_sock(sk);
1304           return;
1305         }
1306       t1 = (struct tcp_header *)((char *)t1 +tmp);
1307       buff ->len += tmp;
1308       buff->dev = dev;
1309       memcpy (t1, th, sizeof (*t1));
1310       t1->seq = net32(sk->send_seq);
1311       sk->send_seq++;
1312       buff->h.seq = sk->send_seq;
1313       t1->ack = 1;
1314        /* ack everything immediately from now on. */
1315       sk->delay_acks = 0;
1316       t1->ack_seq = net32(sk->acked_seq);
1317       t1->window = net16(sk->prot->rspace(sk));
1318       t1->fin = 1;
1319       t1->rst = need_reset;
1320       t1->doff = sizeof (*t1)/4;
1321       tcp_send_check (t1, sk->saddr, sk->daddr, sizeof (*t1), sk);
1322 
1323       if (sk->wfront == NULL)
1324         {
1325           prot->queue_xmit(sk, dev, buff, 0);
1326         }
1327       else
1328         {
1329            sk->time_wait.len = sk->rtt;
1330            sk->timeout = TIME_WRITE;
1331            reset_timer ((struct timer *)&sk->time_wait);
1332            buff->next = NULL;
1333            if (sk->wback == NULL)
1334              {
1335                 sk->wfront=buff;
1336              }
1337            else
1338              {
1339                 sk->wback->next = buff;
1340              }
1341            sk->wback = buff;
1342            
1343         }
1344       sk->state = TCP_FIN_WAIT1;
1345     }
1346   release_sock (sk);
1347 }
1348 
1349 
1350 /* This routine takes stuff off of the write queue, and puts it in the
1351    xmit queue. */
1352 static  void
1353 tcp_write_xmit (volatile struct sock *sk)
     /* [previous][next][first][last][top][bottom][index][help] */
1354 {
1355   struct sk_buff *skb;
1356   while (sk->wfront != NULL && before (sk->wfront->h.seq, sk->window_seq) &&
1357          sk->packets_out < sk->cong_window)
1358     {
1359       skb = sk->wfront;
1360       sk->wfront = skb->next;
1361       if (sk->wfront == NULL)
1362         sk->wback = NULL;
1363       sk->prot->queue_xmit (sk, skb->dev, skb, skb->free);
1364     }
1365 }
1366 
1367 
1368 
1369 /* This routine deals with incoming acks, but not outgoing ones. */
1370 
1371 static  int
1372 tcp_ack (volatile struct sock *sk, struct tcp_header *th, unsigned long saddr)
     /* [previous][next][first][last][top][bottom][index][help] */
1373 {
1374   unsigned long ack;
1375   ack = net32(th->ack_seq);
1376 
1377   if (!between (ack , sk->rcv_ack_seq, sk->send_seq)) 
1378     {
1379       if (after (ack, sk->send_seq) || sk->state != TCP_ESTABLISHED) 
1380         {
1381           return (0);
1382         }
1383       if (sk->keepopen)
1384         reset_timer ((struct timer *)&sk->time_wait);
1385       sk->retransmits = 0;
1386       return (1);
1387     }
1388 
1389   sk->window_seq = ack + net16(th->window);
1390 
1391 
1392   /* we don't want too many packets out there. */
1393   if (sk->cong_window < 2048 && ack != sk->rcv_ack_seq)
1394     {
1395        if (sk->exp_growth)
1396          sk->cong_window *= 2;
1397        else
1398          sk->cong_window++;
1399     }
1400 
1401   sk->rcv_ack_seq = ack;
1402 
1403   /* see if we can take anything off of the retransmit queue. */
1404   while (sk->send_head != NULL)
1405     {
1406       if (before (sk->send_head->h.seq, ack+1))
1407         {
1408           struct sk_buff *oskb;
1409           /* we have one less packet out there. */
1410           sk->packets_out --;
1411           cli();
1412           oskb = sk->send_head;
1413           /* estimate the rtt. */
1414           sk->rtt += ((jiffies - oskb->when) - sk->rtt)/2;
1415           if (sk->rtt < 30) sk->rtt = 30;
1416           sk->send_head = oskb->link3;
1417           if (sk->send_head == NULL) 
1418             {
1419               sk->send_tail = NULL;
1420             }
1421           /* we may need to remove this from the dev send list. */
1422           if (oskb->next != NULL)
1423             {
1424                if (oskb->next != oskb)
1425                  {
1426                     oskb->next->prev = oskb->prev;
1427                     oskb->prev->next = oskb->next;
1428                  }
1429                else
1430                  {
1431                     int i;
1432                     for (i = 0; i < DEV_NUMBUFFS; i++)
1433                       {
1434                          if (oskb->dev->buffs[i] = oskb)
1435                            {
1436                               oskb->dev->buffs[i]= NULL;
1437                               break;
1438                            }
1439                       }
1440                  }
1441             }
1442           free_skb  (oskb, FREE_WRITE); /* write. */
1443           sti();
1444           if (!sk->dead)
1445             wake_up(sk->sleep);
1446         }
1447       else
1448         {
1449           break;
1450         }
1451 
1452     }
1453 
1454 
1455   /* at this point we need to check to see if we have anything
1456      which needs to be retransmiteed.  If we have failed to get
1457      some acks i.e. had to retransmit something, and we succeded, we
1458      should then attempt to retransmit everything right now. */
1459 
1460   if (sk->retransmits && sk->send_head != NULL)
1461     {
1462       sk->prot->retransmit (sk,1);
1463     }
1464   sk->retransmits = 0;
1465 
1466   /* maybe we can take some stuff off of the write queue, and put it onto
1467      the xmit queue. */
1468   if (sk->wfront != NULL && sk->packets_out < sk->cong_window)
1469     {
1470       if (after (sk->window_seq, sk->wfront->h.seq))
1471         {
1472           tcp_write_xmit (sk);
1473         }
1474     }
1475   else
1476     {
1477        if (sk->send_head == NULL && sk->ack_backlog == 0 &&
1478            sk->state != TCP_TIME_WAIT)
1479          {
1480             delete_timer((struct timer *)&sk->time_wait);
1481             sk->timeout = 0;
1482          }
1483        else
1484          {
1485             if (sk->state == TCP_TIME_WAIT)
1486               {
1487                  sk->time_wait.len = TCP_TIMEWAIT_LEN;
1488                  sk->timeout = TIME_CLOSE;
1489               }
1490             reset_timer ((struct timer *)&sk->time_wait);
1491          }
1492     }
1493 
1494   /* see if we are done. */
1495   if ( sk->state == TCP_TIME_WAIT)
1496     {
1497        if (sk->rcv_ack_seq == sk->send_seq &&    
1498            sk->acked_seq == sk->fin_seq);
1499        if (!sk->dead) wake_up (sk->sleep);
1500        sk->state = TCP_CLOSE;
1501     }
1502 
1503   if (sk->state == TCP_FIN_WAIT1)
1504     {
1505       if (sk->rcv_ack_seq == sk->send_seq)
1506         sk->state = TCP_FIN_WAIT2;
1507     }
1508   
1509   if (sk->state == TCP_LAST_ACK)
1510     {
1511       if (sk->rcv_ack_seq == sk->send_seq)
1512         {
1513            if (sk->acked_seq != sk->fin_seq)
1514              {
1515                 tcp_time_wait(sk);
1516              }
1517            else
1518              {
1519                 sk->state = TCP_CLOSE;
1520              }
1521         }
1522       if (!sk->dead) wake_up (sk->sleep);
1523     }
1524 
1525   return (1);
1526 }
1527 
1528 /* This routine handles the data.  If there is room in the buffer, it
1529    will be have already been moved into it.  If there is no room,
1530    then we will just have to discard the packet. */
1531 
1532 static  int
1533 tcp_data (struct sk_buff *skb, volatile struct sock *sk, 
     /* [previous][next][first][last][top][bottom][index][help] */
1534           unsigned long saddr, unsigned short len)
1535 {
1536   struct sk_buff *skb1, *skb2;
1537   struct tcp_header *th;
1538 
1539   th = skb->h.th;
1540   print_th (th);
1541   skb->len = len - (th->doff*4);
1542 
1543   PRINTK("tcp_data len = %d sk = %X:\n",skb->len, sk);
1544   print_sk(sk);
1545 
1546   sk->bytes_rcv += skb->len;
1547 
1548   if (skb->len == 0 && !th->fin && !th->urg && !th->psh)
1549     {
1550       /* don't want to keep passing ack's back and fourth. */
1551       if (!th->ack)
1552         tcp_send_ack (sk->send_seq, sk->acked_seq,sk, th, saddr);
1553       free_skb(skb, FREE_READ);
1554       return (0);
1555     }
1556 
1557   if (sk->shutdown & RCV_SHUTDOWN)
1558     {
1559        /* just ack everything. */
1560        sk->acked_seq = th->seq + skb->len + th->syn + th->fin;
1561        tcp_send_ack (sk->send_seq, sk->acked_seq, sk, skb->h.th, saddr);
1562        free_skb (skb, FREE_READ);
1563        if (sk->state == TCP_TIME_WAIT && sk->acked_seq == sk->fin_seq)
1564          {
1565             if (!sk->dead) wake_up (sk->sleep);
1566             sk->state = TCP_CLOSE;
1567          }
1568        return (0);
1569     }
1570 
1571   /* now we have to walk the chain, and figure out where this one
1572      goes into it.  This is set up so that the last packet we received
1573      will be the first one we look at, that way if everything comes
1574      in order, there will be no performance loss, and if they come
1575      out of order we will be able to fit things in nicely. */
1576   
1577   if (sk->rqueue == NULL)
1578     {
1579        PRINTK ("tcp_data: skb = %X:\n",skb);
1580        print_skb (skb);
1581 
1582        sk->rqueue = skb;
1583        skb->next = skb;
1584        skb->prev = skb;
1585        skb1= NULL;
1586     }
1587   else
1588     {
1589       PRINTK ("tcp_data adding to chain sk = %X:\n",sk);
1590       print_sk (sk);
1591 
1592       for (skb1=sk->rqueue; ; skb1=skb1->prev)
1593         {
1594           PRINTK ("skb1=%X\n",skb1);
1595           print_skb(skb1);
1596           PRINTK ("skb1->h.th->seq = %d\n", skb1->h.th->seq);
1597           if (after ( th->seq+1, skb1->h.th->seq))
1598             {
1599               skb->prev = skb1;
1600               skb->next = skb1->next;
1601               skb->next->prev = skb;
1602               skb1->next = skb;
1603               if (skb1 == sk->rqueue)
1604                 sk->rqueue = skb;
1605               break;
1606             }
1607           if  ( skb1->prev == sk->rqueue)
1608             {
1609                skb->next= skb1;
1610                skb->prev = skb1->prev;
1611                skb->prev->next = skb;
1612                skb1->prev = skb;
1613                skb1 = NULL; /* so we know we might be able to ack stuff. */
1614                break;
1615             }
1616         }
1617 
1618       PRINTK ("skb = %X:\n",skb);
1619       print_skb (skb);
1620       PRINTK ("sk now equals:\n");
1621       print_sk (sk);
1622 
1623     }
1624 
1625   th->ack_seq = th->seq + skb->len;
1626   if (th->syn) th->ack_seq ++;
1627   if (th->fin) th->ack_seq ++;
1628 
1629   if (before (sk->acked_seq, sk->copied_seq))
1630     {
1631        printk ("*** tcp.c:tcp_data bug acked < copied\n");
1632        sk->acked_seq = sk->copied_seq;
1633     }
1634 
1635   /* now figure out if we can ack anything. */
1636   if (skb1 == NULL || skb1->acked || before (th->seq, sk->acked_seq+1))
1637     {
1638       if (before (th->seq, sk->acked_seq+1))
1639         {
1640           sk->acked_seq = th->ack_seq;
1641           skb->acked = 1;
1642           
1643           for (skb2=skb->next; skb2 != sk->rqueue->next; skb2=skb2->next)
1644             {
1645                if (before(skb2->h.th->seq, sk->acked_seq+1))
1646                  {
1647                     sk->acked_seq = skb2->h.th->ack_seq;
1648                     skb2->acked = 1;
1649                     /* force an immediate ack. */
1650                     sk->ack_backlog = sk->max_ack_backlog;
1651                  }
1652                else
1653                  break;
1654             }
1655 
1656           /* this also takes care of updating the window. */
1657           /* this if statement needs to be simplified. */
1658 
1659           if (!sk->delay_acks || 
1660               sk->ack_backlog >= sk->max_ack_backlog || 
1661               sk->window < 2*sk->mtu + sk->bytes_rcv ||
1662               sk->bytes_rcv > sk->max_unacked || 
1663               th->fin)
1664             {
1665                 tcp_send_ack (sk->send_seq, sk->acked_seq,sk,th, saddr);
1666             }
1667           else
1668             {
1669                sk->ack_backlog++;
1670                sk->time_wait.len = TCP_ACK_TIME;
1671                sk->timeout = TIME_WRITE;
1672                reset_timer ((struct timer *)&sk->time_wait);
1673             }
1674        }
1675    }
1676   else
1677     {
1678        /* we missed a packet.  Send an ack to try to resync things. */
1679        tcp_send_ack (sk->send_seq, sk->acked_seq, sk, th, saddr);
1680     }
1681 
1682   /* now tell the user we may have some data. */
1683   if (!sk->dead)
1684     {
1685        wake_up (sk->sleep);
1686     }
1687   else
1688     {
1689        PRINTK ("data received on dead socket. \n");
1690     }
1691 
1692   if (sk->state > TCP_CLOSING && sk->acked_seq == sk->fin_seq)
1693     {
1694        sk->state = TCP_CLOSE;
1695     }
1696 
1697   return (0);
1698 }
1699 
1700 static  int
1701 tcp_urg (volatile struct sock *sk, struct tcp_header *th, unsigned long saddr)
     /* [previous][next][first][last][top][bottom][index][help] */
1702 {
1703     extern int kill_pg (int pg, int sig, int priv);
1704     extern int kill_proc (int pid, int sig, int priv);
1705     
1706     if (!sk->dead)
1707       wake_up(sk->sleep);
1708     
1709     if (sk->urginline)
1710       {
1711           th->urg = 0;
1712           th->psh = 1;
1713           return (0);
1714       }
1715 
1716     sk->urg++;
1717 
1718     if (!sk->urg)
1719       {
1720           /* so if we get more urgent data, we don't 
1721              signal the user again. */
1722           if (sk->proc == 0) return (0);
1723           if (sk->proc > 0)
1724             {
1725                 kill_proc (sk->proc, SIGURG, 1);
1726             }
1727           else 
1728             {
1729                 kill_pg (-sk->proc, SIGURG, 1);
1730             }
1731       }
1732     return (0);
1733 }
1734 
1735 /* this deals with incoming fins. */
1736 static  int
1737 tcp_fin (volatile struct sock *sk, struct tcp_header *th, 
     /* [previous][next][first][last][top][bottom][index][help] */
1738          unsigned long saddr, struct device *dev)
1739 {
1740   struct sk_buff *buff;
1741   struct tcp_header *t1;
1742   int tmp;
1743   PRINTK ("tcp_fin (sk=%X, th=%X, saddr=%X, dev=%X)\n",
1744           sk, th, saddr, dev);
1745   
1746   if (!sk->dead)
1747     {
1748       wake_up (sk->sleep);
1749     }
1750 
1751   /* after sending the fin, we aren't allowed to write anymore. */
1752   sk->shutdown |= SEND_SHUTDOWN;
1753 
1754   sk->err = 0;
1755   switch (sk->state)
1756     {
1757     case TCP_SYN_RECV:
1758     case TCP_SYN_SENT:
1759     case TCP_ESTABLISHED:
1760       sk->state = TCP_LAST_ACK;
1761       break;
1762 
1763      default:
1764     case TCP_FIN_WAIT1:
1765     case TCP_TIME_WAIT:
1766       sk->state = TCP_LAST_ACK;
1767       /* start the timers. */
1768       sk->time_wait.len = TCP_TIMEWAIT_LEN;
1769       sk->timeout = TIME_CLOSE;
1770       reset_timer ((struct timer *)&sk->time_wait);
1771       return (0);
1772 
1773     case TCP_FIN_WAIT2:
1774       sk->state = TCP_CLOSE;
1775       return (0);
1776     }
1777 
1778   /* send an ack and our own fin. */
1779   buff=sk->prot->wmalloc(sk,MAX_ACK_SIZE,1);
1780   if (buff == NULL)
1781     {
1782        /* we will ignore the fin.  That way it will be sent again. */
1783        return (1);
1784     }
1785 
1786   buff->mem_addr = buff;
1787   buff->mem_len = MAX_ACK_SIZE;
1788   buff->len=sizeof (struct tcp_header);
1789   buff->sk = sk;
1790 
1791   t1 = (struct tcp_header *)(buff + 1);
1792   /* put in the ip_header and routing stuff. */
1793   tmp = sk->prot->build_header (buff, sk->saddr, sk->daddr, &dev,
1794                                 IP_TCP,  sk->opt, MAX_ACK_SIZE);
1795   if (tmp < 0)
1796     {
1797       sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
1798       return (0);
1799     }
1800 
1801   buff->len += tmp;
1802   t1 = (struct tcp_header *)((char *)t1 +tmp);
1803   
1804   memcpy (t1, th, sizeof (*t1));
1805 
1806   /* swap the send and the receive. */
1807   t1->dest = th->source;
1808   t1->source = th->dest;
1809 
1810 
1811   t1->seq = net32(sk->send_seq++);
1812 
1813   /* contains the one that needs to be acked. */
1814   sk->fin_seq = th->seq+1;
1815 
1816   buff->h.seq = sk->send_seq;
1817   t1->window = net16(sk->prot->rspace(sk));
1818 
1819   t1->res1=0;
1820   t1->res2=0;
1821   t1->rst = 0;
1822   t1->urg = 0;
1823   t1->syn = 0;
1824   t1->psh = 0;
1825   t1->ack = 1; 
1826   t1->fin = 1;
1827   t1->ack_seq = net32(sk->acked_seq);
1828 
1829   t1->doff = sizeof (*t1)/4;
1830   tcp_send_check (t1, sk->saddr, sk->daddr, sizeof (*t1), sk);
1831 
1832   /* can't just queue this up.  It should go at the end of
1833      the write queue. */
1834   if (sk->wback != NULL)
1835     {
1836       buff->next = NULL;
1837       sk->wback->next = buff;
1838       sk->wback = buff;
1839     }
1840   else
1841     {
1842       sk->prot->queue_xmit (sk, dev, buff,0);
1843     }
1844 
1845   return (0);
1846 }
1847 
1848 
1849 /* this will accept the next outstanding connection. */
1850 
1851 static volatile struct sock *
1852 tcp_accept (volatile struct sock *sk, int flags)
     /* [previous][next][first][last][top][bottom][index][help] */
1853 {
1854   volatile struct sock *newsk;
1855   struct sk_buff *skb;
1856   
1857   PRINTK ("tcp_accept(sk=%X, flags=%X)\n", sk, flags);
1858   print_sk(sk);
1859   /* we need to make sure that this socket is listening, and that
1860      it has something pending. */
1861   
1862   if (sk->state != TCP_LISTEN)
1863     {
1864       sk->err = EINVAL;
1865       return (NULL); 
1866     }
1867   /* avoid the race. */
1868 
1869   sk->inuse = 1;
1870   cli();
1871   while ( (skb = get_firstr(sk)) == NULL )
1872     {
1873       if (flags & O_NONBLOCK)
1874         {
1875           sti();
1876           release_sock (sk);
1877           sk->err = EAGAIN;
1878           return (NULL);
1879         }
1880 
1881       release_sock (sk);
1882       interruptible_sleep_on (sk->sleep);
1883       if (current->signal & ~current->blocked)
1884         {
1885            sti();
1886            sk->err = ERESTARTSYS;
1887            return (NULL);
1888         }
1889 
1890       sk->inuse = 1;
1891     }
1892   sti();
1893 
1894   /* now all we need to do is return skb->sk. */
1895   newsk = skb->sk;
1896   free_skb (skb, FREE_READ);
1897   release_sock (sk);
1898   return (newsk);
1899 }
1900 
1901 
1902 
1903 /* this will initiate an outgoing connection. */
1904 static int
1905 tcp_connect (volatile struct sock *sk, struct sockaddr_in *usin, int addr_len)
     /* [previous][next][first][last][top][bottom][index][help] */
1906 {
1907   struct sk_buff *buff;
1908   struct sockaddr_in sin;
1909   struct device *dev=NULL;
1910   unsigned char *ptr;
1911   int tmp;
1912   struct tcp_header *t1;
1913   if (sk->state != TCP_CLOSE) return (-EISCONN);
1914   if (addr_len < 8) return (-EINVAL);
1915 
1916   verify_area (usin, addr_len);
1917   memcpy_fromfs (&sin,usin, min(sizeof (sin), addr_len));
1918 
1919   if (sin.sin_family && sin.sin_family != AF_INET) return (-EAFNOSUPPORT);
1920 
1921   sk->daddr = sin.sin_addr.s_addr;
1922   sk->send_seq = timer_seq*SEQ_TICK-seq_offset;
1923   sk->rcv_ack_seq = sk->send_seq -1;
1924   sk->err = 0;
1925   sk->dummy_th.dest = sin.sin_port;
1926 
1927   buff=sk->prot->wmalloc(sk,MAX_SYN_SIZE,0);
1928   if (buff == NULL) 
1929     {
1930       return (-ENOMEM);
1931     }
1932   sk->inuse = 1;
1933   buff->mem_addr = buff;
1934   buff->mem_len = MAX_SYN_SIZE;
1935   buff->len=24;
1936   buff->sk = sk;
1937   t1=(struct tcp_header *)(buff + 1);
1938   /* put in the ip_header and routing stuff. */
1939   /* We need to build the routing stuff fromt the things saved
1940      in skb. */
1941   tmp = sk->prot->build_header (buff, sk->saddr, sk->daddr, &dev,
1942                                 IP_TCP, NULL, MAX_SYN_SIZE);
1943   if (tmp < 0)
1944     {
1945       sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
1946       release_sock (sk);
1947       return (-ENETUNREACH);
1948     }
1949   buff->len += tmp;
1950   t1 = (struct tcp_header *)((char *)t1 +tmp);
1951 
1952   memcpy (t1, (void *)&(sk->dummy_th), sizeof (*t1));
1953   t1->seq = net32(sk->send_seq++);
1954   buff->h.seq = sk->send_seq;
1955   t1->ack = 0;
1956   t1->window = 2;
1957   t1->res1=0;
1958   t1->res2=0;
1959   t1->rst = 0;
1960   t1->urg = 0;
1961   t1->psh = 0;
1962   t1->syn = 1;
1963   t1->urg_ptr = 0;
1964   t1->doff =6;
1965   /* put in the tcp options to say mtu. */
1966   ptr=(unsigned char *)(t1+1);
1967   ptr[0]=2;
1968   ptr[1]=4;
1969   ptr[2]=(dev->mtu- HEADER_SIZE) >> 8;
1970   ptr[3]=(dev->mtu- HEADER_SIZE) & 0xff;
1971   sk->mtu = dev->mtu - HEADER_SIZE;
1972   tcp_send_check (t1, sk->saddr, sk->daddr,
1973                   sizeof (struct tcp_header) + 4, sk);
1974   /* this must go first otherwise a really quick response will
1975      get reset. */
1976   sk->state = TCP_SYN_SENT;
1977 
1978   sk->prot->queue_xmit(sk, dev, buff, 0);
1979   
1980   sk->time_wait.len = TCP_CONNECT_TIME;
1981   reset_timer ((struct timer *)&sk->time_wait);
1982   sk->retransmits = TCP_RETR1 - TCP_SYN_RETRIES;
1983   release_sock (sk);
1984   return (0);
1985 }
1986 
1987 
1988 /* this functions checks to see if the tcp header is actually
1989    acceptible. */
1990 
1991 static  int
1992 tcp_sequence (volatile struct sock *sk, struct tcp_header *th, short len,
     /* [previous][next][first][last][top][bottom][index][help] */
1993               struct options *opt, unsigned long saddr)
1994 {
1995    /* this isn't quite right.  sk->acked_seq could be more recent
1996       than sk->window.  This is however close enough.  We will accept
1997       slightly more packets than we should, but it should not cause
1998       problems unless someone is trying to forge packets. */
1999 
2000   if (between(th->seq, sk->acked_seq, sk->acked_seq + sk->window)||
2001       between(th->seq + len-sizeof (*th), sk->acked_seq+1, 
2002               sk->acked_seq + sk->window))
2003     {
2004        return (1);
2005     }
2006 
2007   /* if it's too far ahead, send an ack to let the other end
2008      know what we expect. */
2009   if (after (th->seq, sk->acked_seq + sk->window))
2010     {
2011        tcp_send_ack (sk->send_seq, sk->acked_seq, sk, th, saddr);
2012        return (0);
2013     }
2014 
2015   if (!th->rst)
2016     {
2017        if (len != th->doff*4 || th->fin || th->syn)
2018          {
2019             sk->delay_acks = 0;
2020          }
2021 
2022        /* try to resync things. */
2023        tcp_send_ack (net32(th->ack_seq), sk->acked_seq, sk, th, saddr);
2024     }
2025 
2026   /* in case it's just a late ack, let it through */
2027   if (th->ack && len == th->doff*4 && after (th->seq, sk->acked_seq - 4096) &&
2028       !th->fin && !th->syn) return (1);
2029 
2030   return (0);
2031 }
2032 
2033 /* This deals with the tcp option.  It isn't very general yet. */
2034 static void
2035 tcp_options (volatile struct sock *sk, struct tcp_header *th)
     /* [previous][next][first][last][top][bottom][index][help] */
2036 {
2037   unsigned char *ptr;
2038   ptr = (unsigned char *)(th + 1);
2039   if (ptr[0] != 2 || ptr[1] != 4)
2040     {
2041        sk->mtu = min (sk->mtu, 576-HEADER_SIZE);
2042        return;
2043     }
2044   sk->mtu = min (sk->mtu, ptr[2]*256 + ptr[3] - HEADER_SIZE);
2045 }
2046 
2047 int
2048 tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
     /* [previous][next][first][last][top][bottom][index][help] */
2049         unsigned long daddr, unsigned short len,
2050         unsigned long saddr, int redo, struct ip_protocol * protocol)
2051 {
2052   struct tcp_header *th;
2053   volatile struct sock *sk;
2054 
2055   th = skb->h.th;
2056   /* find the socket. */
2057   sk=get_sock(&tcp_prot, net16(th->dest), saddr, th->source, daddr);
2058   PRINTK("<<\n");
2059   PRINTK("len = %d, redo = %d, skb=%X\n", len, redo, skb);
2060 
2061   if (sk)
2062     {
2063       PRINTK ("sk = %X:\n",sk);
2064       print_sk (sk);
2065     }
2066 
2067   if (!redo)
2068     {
2069        if (th->check && tcp_check (th, len, saddr, daddr ))
2070          {
2071             skb->sk = NULL;
2072             free_skb (skb, 0);
2073             /* we don't release the socket because it was never
2074                marked in use. */
2075             return (0);
2076          }
2077 
2078        /*See if we know about the socket. */
2079        if (sk == NULL)
2080         {
2081           if (!th->rst)
2082             tcp_reset (daddr, saddr, th, &tcp_prot, opt,dev);
2083           skb->sk = NULL;
2084           free_skb (skb, 0);
2085           return (0);
2086         }
2087 
2088        skb->len = len;
2089        skb->sk = sk;
2090        skb->acked = 0;
2091        skb->used = 0;
2092        skb->free = 0;
2093        skb->urg_used = 0;
2094        skb->saddr = daddr;
2095        skb->daddr = saddr;
2096 
2097        th->seq = net32(th->seq);
2098 
2099        cli();
2100 
2101        /* we may need to add it to the backlog here. */
2102        if (sk->inuse)
2103          {
2104             if (sk->back_log == NULL)
2105               {
2106                  sk->back_log = skb;
2107                  skb->next = skb;
2108                  skb->prev = skb;
2109               }
2110             else
2111               {
2112                  skb->next = sk->back_log;
2113                  skb->prev = sk->back_log->prev;
2114                  skb->prev->next = skb;
2115                  skb->next->prev = skb;
2116               }
2117             sti();
2118             return (0);
2119          }
2120        sk->inuse = 1;
2121        sti();
2122     }
2123 
2124   /* charge the memory to the socket. */
2125   if (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
2126     {
2127        skb->sk = NULL;
2128        free_skb (skb, 0);
2129        release_sock (sk);
2130        return (0);
2131     }
2132        
2133   sk->rmem_alloc += skb->mem_len;
2134 
2135   PRINTK ("About to do switch. \n");
2136 
2137   /* now deal with it. */
2138 
2139   switch (sk->state)
2140     {
2141        /* this should close the system down if it's waiting for an
2142           ack that is never going to be sent. */
2143     case TCP_LAST_ACK:
2144       if (th->rst)
2145         {
2146           sk->err = ECONNRESET;
2147           sk->state = TCP_CLOSE;
2148           if (!sk->dead)
2149             {
2150               wake_up (sk->sleep);
2151             }
2152           free_skb (skb, FREE_READ);
2153           release_sock(sk);
2154           return (0);
2155         }
2156 
2157     case TCP_ESTABLISHED:
2158     case TCP_FIN_WAIT1:
2159     case TCP_FIN_WAIT2:
2160     case TCP_TIME_WAIT:
2161    
2162       if (!tcp_sequence (sk, th, len, opt, saddr))
2163         {
2164            free_skb (skb, FREE_READ);
2165            release_sock(sk);
2166            return (0);
2167         }
2168       if (th->rst)
2169         {
2170           sk->err = ECONNRESET;
2171           sk->state = TCP_CLOSE;
2172           if (!sk->dead)
2173             {
2174               wake_up (sk->sleep);
2175             }
2176           free_skb (skb, FREE_READ);
2177           release_sock(sk);
2178           return (0);
2179         }
2180 
2181       if (opt->security != 0 || opt->compartment != 0 || th->syn)
2182         {
2183            sk->err = ECONNRESET;
2184            sk->state = TCP_CLOSE;
2185            tcp_reset (daddr, saddr,  th, sk->prot, opt,dev);
2186            if (!sk->dead)
2187              {
2188                 wake_up (sk->sleep);
2189              }
2190            free_skb (skb, FREE_READ);
2191            release_sock(sk);
2192            return (0);
2193         }
2194 
2195       if (th->ack)
2196         {
2197            if(!tcp_ack (sk, th, saddr))
2198             {
2199                free_skb (skb, FREE_READ);
2200                release_sock(sk);
2201                return (0);
2202            }
2203         }
2204       if (th->urg)
2205         {
2206           if (tcp_urg (sk, th, saddr))
2207             {
2208                free_skb (skb, FREE_READ);
2209                release_sock(sk);
2210                return (0);
2211             }
2212         }
2213 
2214       if ( tcp_data (skb, sk, saddr, len))
2215         {
2216            free_skb (skb, FREE_READ);
2217            release_sock(sk);
2218            return (0);
2219         }
2220 
2221       if (!th->fin)
2222         {
2223           release_sock(sk);
2224           return (0);
2225         }
2226 
2227       tcp_fin (sk, th, saddr, dev);
2228       release_sock(sk);
2229       return (0);
2230 
2231     case TCP_CLOSE:
2232 
2233       if (sk->dead || sk->daddr)
2234         {
2235            PRINTK ("packet received for closed,dead socket\n");
2236            free_skb (skb, FREE_READ);
2237            release_sock (sk);
2238            return (0);
2239         }
2240 
2241       if (!th->rst)
2242         {
2243           if (!th->ack)
2244             th->ack_seq=0;
2245           tcp_reset (daddr, saddr, th, sk->prot, opt,dev);
2246         }
2247       free_skb (skb, FREE_READ);
2248       release_sock(sk);
2249       return (0);
2250 
2251     case TCP_LISTEN:
2252       if (th->rst)
2253         {
2254            free_skb (skb, FREE_READ);
2255            release_sock(sk);
2256            return (0);
2257         }
2258       if (th->ack)
2259         {
2260           tcp_reset (daddr, saddr, th, sk->prot, opt,dev );
2261           free_skb (skb, FREE_READ);
2262           release_sock(sk);
2263           return (0);
2264         }
2265 
2266       if (th->syn)
2267         {
2268 /*        if (opt->security != 0 || opt->compartment != 0)
2269             {
2270               tcp_reset (daddr, saddr, th, prot, opt,dev);
2271               release_sock(sk);
2272               return (0);
2273             } */
2274 
2275           /* now we just put the whole thing including the header
2276              and saddr, and protocol pointer into the buffer.
2277              We can't respond until the user tells us to accept
2278              the connection. */
2279 
2280           tcp_conn_request (sk, skb, daddr, saddr, opt, dev);
2281 
2282           release_sock(sk);
2283           return (0);
2284         }
2285 
2286       free_skb (skb, FREE_READ);
2287       release_sock(sk);
2288       return (0);
2289 
2290     default:
2291       if (!tcp_sequence (sk, th, len, opt, saddr)) 
2292         {
2293            free_skb (skb, FREE_READ);
2294            release_sock(sk);
2295            return (0);
2296         }
2297 
2298     case TCP_SYN_SENT:
2299       if (th->rst)
2300         {
2301           sk->err = ECONNREFUSED;
2302           sk->state = TCP_CLOSE;
2303           if (!sk->dead)
2304             {
2305               wake_up (sk->sleep);
2306             }
2307           free_skb (skb, FREE_READ);
2308           release_sock(sk);
2309           return (0);
2310         }
2311 /*      if (opt->security != 0 || opt->compartment != 0 )
2312         {
2313           sk->err = ECONNRESET;
2314           sk->state = TCP_CLOSE;
2315           tcp_reset (daddr, saddr,  th, sk->prot, opt, dev);
2316           if (!sk->dead)
2317           {
2318           wake_up (sk->sleep);
2319           }
2320           free_skb (skb, FREE_READ);
2321           release_sock(sk);
2322           return (0);
2323         } */
2324 
2325       if (!th->ack) 
2326         {
2327           if (th->syn)
2328             {
2329               sk->state = TCP_SYN_RECV;
2330             }
2331 
2332           free_skb (skb, FREE_READ);
2333           release_sock(sk);
2334           return (0);
2335         }
2336 
2337       switch (sk->state)
2338         {
2339         case TCP_SYN_SENT:
2340           if (!tcp_ack(sk, th, saddr))
2341             {
2342               tcp_reset(daddr, saddr, th, sk->prot, opt,dev);
2343               free_skb (skb, FREE_READ);
2344               release_sock(sk);
2345               return (0);
2346             }
2347 
2348           /* if the syn bit is also set, switch to tcp_syn_recv,
2349              and then to established. */
2350               
2351           if (!th->syn) 
2352             {
2353               free_skb (skb, FREE_READ);
2354               release_sock (sk);
2355               return (0);
2356             }
2357 
2358           /* ack the syn and fall through. */
2359           sk->acked_seq = th->seq+1;
2360           sk->fin_seq = th->seq;
2361           tcp_send_ack (sk->send_seq, th->seq+1, sk, 
2362                              th, sk->daddr);
2363         
2364         case TCP_SYN_RECV:
2365           if (!tcp_ack(sk, th, saddr))
2366             {
2367               tcp_reset(daddr, saddr, th, sk->prot, opt, dev);
2368               free_skb (skb, FREE_READ);
2369               release_sock(sk);
2370               return (0);
2371             }
2372 
2373           sk->state = TCP_ESTABLISHED;
2374           /* now we need to finish filling out some of the tcp
2375              header. */
2376 
2377           /* we need to check for mtu info. */
2378           tcp_options(sk, th);
2379           sk->dummy_th.dest = th->source;
2380           sk->copied_seq = sk->acked_seq-1;
2381           if (!sk->dead)
2382             {
2383               wake_up (sk->sleep);
2384             }
2385 
2386           /* now process the rest like we were already in the established
2387              state. */
2388           if (th->urg)
2389             if (tcp_urg (sk, th, saddr))
2390               {
2391                  free_skb (skb, FREE_READ);
2392                  release_sock(sk);
2393                  return (0);
2394               }
2395           if (tcp_data (skb, sk, saddr, len))
2396             free_skb (skb, FREE_READ);
2397           
2398           if (th->fin)
2399             tcp_fin(sk, th, saddr, dev);
2400 
2401           release_sock(sk);
2402           return (0);
2403         }
2404 
2405       if (th->urg)
2406         {
2407           if (tcp_urg (sk, th, saddr))
2408             {
2409                free_skb (skb, FREE_READ);
2410                release_sock (sk);
2411                return (0);
2412             }
2413         }
2414 
2415       if (tcp_data (skb, sk, saddr, len))
2416         {
2417            free_skb (skb, FREE_READ);
2418            release_sock (sk);
2419            return (0);
2420         }
2421 
2422       if (!th->fin)
2423         {
2424           release_sock(sk);
2425           return (0);
2426         }
2427       tcp_fin (sk, th, saddr, dev);
2428       release_sock(sk);
2429       return (0);
2430     }
2431 }
2432 
2433 
2434 /* this routine sends a packet with an out of date sequence number. It
2435    assumes the other end will try to ack it. */
2436 
2437 static  void
2438 tcp_write_wakeup(volatile struct sock *sk)
     /* [previous][next][first][last][top][bottom][index][help] */
2439 {
2440   struct sk_buff *buff;
2441   struct tcp_header *t1;
2442   struct device *dev=NULL;
2443   int tmp;
2444   if (sk -> state != TCP_ESTABLISHED) return;
2445 
2446   buff=sk->prot->wmalloc(sk,MAX_ACK_SIZE,1);
2447   /* no big loss. */
2448   if (buff == NULL) return;
2449 
2450   buff->mem_addr = buff;
2451   buff->mem_len = MAX_ACK_SIZE;
2452   buff->len=sizeof (struct tcp_header);
2453   buff->free = 1;
2454   buff->sk = sk;
2455   PRINTK ("in tcp_write_wakeup\n");
2456   t1=(struct tcp_header *)(buff + 1);
2457 
2458   /* put in the ip_header and routing stuff. */
2459   tmp = sk->prot->build_header (buff, sk->saddr, sk->daddr, &dev,
2460                                 IP_TCP, sk->opt, MAX_ACK_SIZE);
2461   if (tmp < 0)
2462     {
2463       sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
2464       return;
2465     }
2466 
2467   buff->len += tmp;
2468   t1 = (struct tcp_header *)((char *)t1 +tmp);
2469 
2470   memcpy (t1,(void *) &sk->dummy_th, sizeof (*t1));
2471 
2472   /* use a previous sequence.  This should cause the other end
2473      to send an ack. */
2474   t1->seq = net32(sk->send_seq-1);
2475   t1->ack = 1; 
2476   t1->res1= 0;
2477   t1->res2= 0;
2478   t1->rst = 0;
2479   t1->urg = 0;
2480   t1->psh = 0;
2481   t1->fin = 0;
2482   t1->syn = 0;
2483   t1->ack_seq = net32(sk->acked_seq);
2484   t1->window = net16(sk->prot->rspace(sk));
2485   t1->doff = sizeof (*t1)/4;
2486   tcp_send_check (t1, sk->saddr, sk->daddr, sizeof (*t1), sk);
2487   /* send it and free it.  This will prevent the timer from 
2488      automatically being restarted. */
2489   sk->prot->queue_xmit(sk, dev, buff, 1);
2490 
2491 }
2492 
2493 struct proto tcp_prot =
2494 {
2495   sock_wmalloc,
2496   sock_rmalloc,
2497   sock_wfree,
2498   sock_rfree,
2499   sock_rspace,
2500   sock_wspace,
2501   tcp_close,
2502   tcp_read,
2503   tcp_write,
2504   NULL,
2505   NULL,
2506   ip_build_header,
2507   tcp_connect,
2508   tcp_accept,
2509   ip_queue_xmit,
2510   tcp_retransmit,
2511   tcp_write_wakeup,
2512   tcp_read_wakeup,
2513   tcp_rcv,
2514   tcp_select,
2515   tcp_ioctl,
2516   NULL,
2517   128,
2518   0,
2519   {NULL,}
2520 };
2521 
2522 
2523 
2524 

/* [previous][next][first][last][top][bottom][index][help] */