Diff for /qemu/slirp/tcp_timer.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2018/04/24 16:37:52 version 1.1.1.2, 2018/04/24 16:49:08
Line 36 Line 36
   
 #include <slirp.h>  #include <slirp.h>
   
 int     tcp_keepidle = TCPTV_KEEP_IDLE;  #ifdef LOG_ENABLED
 int     tcp_keepintvl = TCPTV_KEEPINTVL;  
 int     tcp_maxidle;  
 int     so_options = DO_KEEPALIVE;  
   
 struct   tcpstat tcpstat;        /* tcp statistics */  struct   tcpstat tcpstat;        /* tcp statistics */
   #endif
   
 u_int32_t        tcp_now;                /* for RFC 1323 timestamps */  u_int32_t        tcp_now;                /* for RFC 1323 timestamps */
   
   static struct tcpcb *tcp_timers(register struct tcpcb *tp, int timer);
   
 /*  /*
  * Fast timeout routine for processing delayed acks   * Fast timeout routine for processing delayed acks
  */   */
Line 54  tcp_fasttimo() Line 54  tcp_fasttimo()
         register struct tcpcb *tp;          register struct tcpcb *tp;
   
         DEBUG_CALL("tcp_fasttimo");          DEBUG_CALL("tcp_fasttimo");
           
         so = tcb.so_next;          so = tcb.so_next;
         if (so)          if (so)
         for (; so != &tcb; so = so->so_next)          for (; so != &tcb; so = so->so_next)
Line 62  tcp_fasttimo() Line 62  tcp_fasttimo()
                     (tp->t_flags & TF_DELACK)) {                      (tp->t_flags & TF_DELACK)) {
                         tp->t_flags &= ~TF_DELACK;                          tp->t_flags &= ~TF_DELACK;
                         tp->t_flags |= TF_ACKNOW;                          tp->t_flags |= TF_ACKNOW;
                         tcpstat.tcps_delack++;                          STAT(tcpstat.tcps_delack++);
                         (void) tcp_output(tp);                          (void) tcp_output(tp);
                 }                  }
 }  }
Line 80  tcp_slowtimo() Line 80  tcp_slowtimo()
         register int i;          register int i;
   
         DEBUG_CALL("tcp_slowtimo");          DEBUG_CALL("tcp_slowtimo");
           
         tcp_maxidle = TCPTV_KEEPCNT * tcp_keepintvl;  
         /*          /*
          * Search through tcb's and update active timers.           * Search through tcb's and update active timers.
          */           */
Line 127  tcp_canceltimers(tp) Line 126  tcp_canceltimers(tp)
                 tp->t_timer[i] = 0;                  tp->t_timer[i] = 0;
 }  }
   
 int     tcp_backoff[TCP_MAXRXTSHIFT + 1] =  const int tcp_backoff[TCP_MAXRXTSHIFT + 1] =
    { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };     { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
   
 /*  /*
  * TCP timer processing.   * TCP timer processing.
  */   */
 struct tcpcb *  static struct tcpcb *
 tcp_timers(tp, timer)  tcp_timers(register struct tcpcb *tp, int timer)
         register struct tcpcb *tp;  
         int timer;  
 {  {
         register int rexmt;          register int rexmt;
           
         DEBUG_CALL("tcp_timers");          DEBUG_CALL("tcp_timers");
           
         switch (timer) {          switch (timer) {
   
         /*          /*
Line 152  tcp_timers(tp, timer) Line 149  tcp_timers(tp, timer)
          */           */
         case TCPT_2MSL:          case TCPT_2MSL:
                 if (tp->t_state != TCPS_TIME_WAIT &&                  if (tp->t_state != TCPS_TIME_WAIT &&
                     tp->t_idle <= tcp_maxidle)                      tp->t_idle <= TCP_MAXIDLE)
                         tp->t_timer[TCPT_2MSL] = tcp_keepintvl;                          tp->t_timer[TCPT_2MSL] = TCPTV_KEEPINTVL;
                 else                  else
                         tp = tcp_close(tp);                          tp = tcp_close(tp);
                 break;                  break;
Line 164  tcp_timers(tp, timer) Line 161  tcp_timers(tp, timer)
          * to a longer retransmit interval and retransmit one segment.           * to a longer retransmit interval and retransmit one segment.
          */           */
         case TCPT_REXMT:          case TCPT_REXMT:
                   
                 /*                  /*
                  * XXXXX If a packet has timed out, then remove all the queued                   * XXXXX If a packet has timed out, then remove all the queued
                  * packets for that session.                   * packets for that session.
                  */                   */
                   
                 if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {                  if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
                         /*                          /*
                          * This is a hack to suit our terminal server here at the uni of canberra                           * This is a hack to suit our terminal server here at the uni of canberra
Line 178  tcp_timers(tp, timer) Line 175  tcp_timers(tp, timer)
                          * keep retransmitting it, it'll keep eating the zeroes, so we keep                           * keep retransmitting it, it'll keep eating the zeroes, so we keep
                          * retransmitting, and eventually the connection dies...                           * retransmitting, and eventually the connection dies...
                          * (this only happens on incoming data)                           * (this only happens on incoming data)
                          *                            *
                          * So, if we were gonna drop the connection from too many retransmits,                           * So, if we were gonna drop the connection from too many retransmits,
                          * don't... instead halve the t_maxseg, which might break up the NULLs and                           * don't... instead halve the t_maxseg, which might break up the NULLs and
                          * let them through                           * let them through
                          *                            *
                          * *sigh*                           * *sigh*
                          */                           */
                           
                         tp->t_maxseg >>= 1;                          tp->t_maxseg >>= 1;
                         if (tp->t_maxseg < 32) {                          if (tp->t_maxseg < 32) {
                                 /*                                  /*
                                  * We tried our best, now the connection must die!                                   * We tried our best, now the connection must die!
                                  */                                   */
                                 tp->t_rxtshift = TCP_MAXRXTSHIFT;                                  tp->t_rxtshift = TCP_MAXRXTSHIFT;
                                 tcpstat.tcps_timeoutdrop++;                                  STAT(tcpstat.tcps_timeoutdrop++);
                                 tp = tcp_drop(tp, tp->t_softerror);                                  tp = tcp_drop(tp, tp->t_softerror);
                                 /* tp->t_softerror : ETIMEDOUT); */ /* XXX */                                  /* tp->t_softerror : ETIMEDOUT); */ /* XXX */
                                 return (tp); /* XXX */                                  return (tp); /* XXX */
                         }                          }
                           
                         /*                          /*
                          * Set rxtshift to 6, which is still at the maximum                           * Set rxtshift to 6, which is still at the maximum
                          * backoff time                           * backoff time
                          */                           */
                         tp->t_rxtshift = 6;                          tp->t_rxtshift = 6;
                 }                  }
                 tcpstat.tcps_rexmttimeo++;                  STAT(tcpstat.tcps_rexmttimeo++);
                 rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];                  rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];
                 TCPT_RANGESET(tp->t_rxtcur, rexmt,                  TCPT_RANGESET(tp->t_rxtcur, rexmt,
                     (short)tp->t_rttmin, TCPTV_REXMTMAX); /* XXX */                      (short)tp->t_rttmin, TCPTV_REXMTMAX); /* XXX */
Line 240  tcp_timers(tp, timer) Line 237  tcp_timers(tp, timer)
                  * size increase exponentially with time.  If the                   * size increase exponentially with time.  If the
                  * window is larger than the path can handle, this                   * window is larger than the path can handle, this
                  * exponential growth results in dropped packet(s)                   * exponential growth results in dropped packet(s)
                  * almost immediately.  To get more time between                    * almost immediately.  To get more time between
                  * drops but still "push" the network to take advantage                   * drops but still "push" the network to take advantage
                  * of improving conditions, we switch from exponential                   * of improving conditions, we switch from exponential
                  * to linear window opening at some threshold size.                   * to linear window opening at some threshold size.
Line 267  tcp_timers(tp, timer) Line 264  tcp_timers(tp, timer)
          * Force a byte to be output, if possible.           * Force a byte to be output, if possible.
          */           */
         case TCPT_PERSIST:          case TCPT_PERSIST:
                 tcpstat.tcps_persisttimeo++;                  STAT(tcpstat.tcps_persisttimeo++);
                 tcp_setpersist(tp);                  tcp_setpersist(tp);
                 tp->t_force = 1;                  tp->t_force = 1;
                 (void) tcp_output(tp);                  (void) tcp_output(tp);
Line 279  tcp_timers(tp, timer) Line 276  tcp_timers(tp, timer)
          * or drop connection if idle for too long.           * or drop connection if idle for too long.
          */           */
         case TCPT_KEEP:          case TCPT_KEEP:
                 tcpstat.tcps_keeptimeo++;                  STAT(tcpstat.tcps_keeptimeo++);
                 if (tp->t_state < TCPS_ESTABLISHED)                  if (tp->t_state < TCPS_ESTABLISHED)
                         goto dropit;                          goto dropit;
   
 /*              if (tp->t_socket->so_options & SO_KEEPALIVE && */  /*              if (tp->t_socket->so_options & SO_KEEPALIVE && */
                 if ((so_options) && tp->t_state <= TCPS_CLOSE_WAIT) {                  if ((SO_OPTIONS) && tp->t_state <= TCPS_CLOSE_WAIT) {
                         if (tp->t_idle >= tcp_keepidle + tcp_maxidle)                          if (tp->t_idle >= TCPTV_KEEP_IDLE + TCP_MAXIDLE)
                                 goto dropit;                                  goto dropit;
                         /*                          /*
                          * Send a packet designed to force a response                           * Send a packet designed to force a response
Line 299  tcp_timers(tp, timer) Line 296  tcp_timers(tp, timer)
                          * by the protocol spec, this requires the                           * by the protocol spec, this requires the
                          * correspondent TCP to respond.                           * correspondent TCP to respond.
                          */                           */
                         tcpstat.tcps_keepprobe++;                          STAT(tcpstat.tcps_keepprobe++);
 #ifdef TCP_COMPAT_42  #ifdef TCP_COMPAT_42
                         /*                          /*
                          * The keepalive packet must have nonzero length                           * The keepalive packet must have nonzero length
Line 311  tcp_timers(tp, timer) Line 308  tcp_timers(tp, timer)
                         tcp_respond(tp, &tp->t_template, (struct mbuf *)NULL,                          tcp_respond(tp, &tp->t_template, (struct mbuf *)NULL,
                             tp->rcv_nxt, tp->snd_una - 1, 0);                              tp->rcv_nxt, tp->snd_una - 1, 0);
 #endif  #endif
                         tp->t_timer[TCPT_KEEP] = tcp_keepintvl;                          tp->t_timer[TCPT_KEEP] = TCPTV_KEEPINTVL;
                 } else                  } else
                         tp->t_timer[TCPT_KEEP] = tcp_keepidle;                          tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_IDLE;
                 break;                  break;
   
         dropit:          dropit:
                 tcpstat.tcps_keepdrops++;                  STAT(tcpstat.tcps_keepdrops++);
                 tp = tcp_drop(tp, 0); /* ETIMEDOUT); */                  tp = tcp_drop(tp, 0); /* ETIMEDOUT); */
                 break;                  break;
         }          }

Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2


unix.superglobalmegacorp.com