Diff for /qemu/slirp/tcp_output.c between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2018/04/24 16:54:35 version 1.1.1.4, 2018/04/24 17:25:43
Line 40 Line 40
   
 #include <slirp.h>  #include <slirp.h>
   
 /*  
  * Since this is only used in "stats socket", we give meaning  
  * names instead of the REAL names  
  */  
 const char * const tcpstates[] = {  
 /*      "CLOSED",       "LISTEN",       "SYN_SENT",     "SYN_RCVD", */  
         "REDIRECT",     "LISTEN",       "SYN_SENT",     "SYN_RCVD",  
         "ESTABLISHED",  "CLOSE_WAIT",   "FIN_WAIT_1",   "CLOSING",  
         "LAST_ACK",     "FIN_WAIT_2",   "TIME_WAIT",  
 };  
   
 static const u_char  tcp_outflags[TCP_NSTATES] = {  static const u_char  tcp_outflags[TCP_NSTATES] = {
         TH_RST|TH_ACK, 0,      TH_SYN,        TH_SYN|TH_ACK,          TH_RST|TH_ACK, 0,      TH_SYN,        TH_SYN|TH_ACK,
         TH_ACK,        TH_ACK, TH_FIN|TH_ACK, TH_FIN|TH_ACK,          TH_ACK,        TH_ACK, TH_FIN|TH_ACK, TH_FIN|TH_ACK,
Line 64  static const u_char  tcp_outflags[TCP_NS Line 53  static const u_char  tcp_outflags[TCP_NS
  * Tcp output routine: figure out what should be sent and send it.   * Tcp output routine: figure out what should be sent and send it.
  */   */
 int  int
 tcp_output(tp)  tcp_output(struct tcpcb *tp)
         register struct tcpcb *tp;  
 {  {
         register struct socket *so = tp->t_socket;          register struct socket *so = tp->t_socket;
         register long len, win;          register long len, win;
Line 259  again: Line 247  again:
         /*          /*
          * No reason to send a segment, just return.           * No reason to send a segment, just return.
          */           */
         STAT(tcpstat.tcps_didnuttin++);  
   
         return (0);          return (0);
   
 send:  send:
Line 284  send: Line 270  send:
                         mss = htons((u_int16_t) tcp_mss(tp, 0));                          mss = htons((u_int16_t) tcp_mss(tp, 0));
                         memcpy((caddr_t)(opt + 2), (caddr_t)&mss, sizeof(mss));                          memcpy((caddr_t)(opt + 2), (caddr_t)&mss, sizeof(mss));
                         optlen = 4;                          optlen = 4;
   
 /*                      if ((tp->t_flags & TF_REQ_SCALE) &&  
  *                          ((flags & TH_ACK) == 0 ||  
  *                          (tp->t_flags & TF_RCVD_SCALE))) {  
  *                              *((u_int32_t *) (opt + optlen)) = htonl(  
  *                                      TCPOPT_NOP << 24 |  
  *                                      TCPOPT_WINDOW << 16 |  
  *                                      TCPOLEN_WINDOW << 8 |  
  *                                      tp->request_r_scale);  
  *                              optlen += 4;  
  *                      }  
  */  
                 }                  }
         }          }
   
         /*  
          * Send a timestamp and echo-reply if this is a SYN and our side  
          * wants to use timestamps (TF_REQ_TSTMP is set) or both our side  
          * and our peer have sent timestamps in our SYN's.  
          */  
 /*      if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP &&  
  *           (flags & TH_RST) == 0 &&  
  *          ((flags & (TH_SYN|TH_ACK)) == TH_SYN ||  
  *           (tp->t_flags & TF_RCVD_TSTMP))) {  
  *              u_int32_t *lp = (u_int32_t *)(opt + optlen);  
  *  
  *              / * Form timestamp option as shown in appendix A of RFC 1323. *  /  
  *              *lp++ = htonl(TCPOPT_TSTAMP_HDR);  
  *              *lp++ = htonl(tcp_now);  
  *              *lp   = htonl(tp->ts_recent);  
  *              optlen += TCPOLEN_TSTAMP_APPA;  
  *      }  
  */  
         hdrlen += optlen;          hdrlen += optlen;
   
         /*          /*
Line 334  send: Line 290  send:
          * the template for sends on this connection.           * the template for sends on this connection.
          */           */
         if (len) {          if (len) {
                 if (tp->t_force && len == 1)                  m = m_get(so->slirp);
                         STAT(tcpstat.tcps_sndprobe++);  
                 else if (SEQ_LT(tp->snd_nxt, tp->snd_max)) {  
                         STAT(tcpstat.tcps_sndrexmitpack++);  
                         STAT(tcpstat.tcps_sndrexmitbyte += len);  
                 } else {  
                         STAT(tcpstat.tcps_sndpack++);  
                         STAT(tcpstat.tcps_sndbyte += len);  
                 }  
   
                 m = m_get();  
                 if (m == NULL) {                  if (m == NULL) {
 /*                      error = ENOBUFS; */  
                         error = 1;                          error = 1;
                         goto out;                          goto out;
                 }                  }
                 m->m_data += IF_MAXLINKHDR;                  m->m_data += IF_MAXLINKHDR;
                 m->m_len = hdrlen;                  m->m_len = hdrlen;
   
                 /*                  sbcopy(&so->so_snd, off, (int) len, mtod(m, caddr_t) + hdrlen);
                  * This will always succeed, since we make sure our mbufs                  m->m_len += len;
                  * are big enough to hold one MSS packet + header + ... etc.  
                  */  
 /*              if (len <= MHLEN - hdrlen - max_linkhdr) { */  
   
                         sbcopy(&so->so_snd, off, (int) len, mtod(m, caddr_t) + hdrlen);  
                         m->m_len += len;  
   
 /*              } else {  
  *                      m->m_next = m_copy(so->so_snd.sb_mb, off, (int) len);  
  *                      if (m->m_next == 0)  
  *                              len = 0;  
  *              }  
  */  
                 /*                  /*
                  * If we're sending everything we've got, set PUSH.                   * If we're sending everything we've got, set PUSH.
                  * (This will keep happy those implementations which only                   * (This will keep happy those implementations which only
Line 377  send: Line 310  send:
                 if (off + len == so->so_snd.sb_cc)                  if (off + len == so->so_snd.sb_cc)
                         flags |= TH_PUSH;                          flags |= TH_PUSH;
         } else {          } else {
                 if (tp->t_flags & TF_ACKNOW)                  m = m_get(so->slirp);
                         STAT(tcpstat.tcps_sndacks++);  
                 else if (flags & (TH_SYN|TH_FIN|TH_RST))  
                         STAT(tcpstat.tcps_sndctrl++);  
                 else if (SEQ_GT(tp->snd_up, tp->snd_una))  
                         STAT(tcpstat.tcps_sndurg++);  
                 else  
                         STAT(tcpstat.tcps_sndwinup++);  
   
                 m = m_get();  
                 if (m == NULL) {                  if (m == NULL) {
 /*                      error = ENOBUFS; */  
                         error = 1;                          error = 1;
                         goto out;                          goto out;
                 }                  }
Line 445  send: Line 368  send:
   
         if (SEQ_GT(tp->snd_up, tp->snd_una)) {          if (SEQ_GT(tp->snd_up, tp->snd_una)) {
                 ti->ti_urp = htons((u_int16_t)(tp->snd_up - ntohl(ti->ti_seq)));                  ti->ti_urp = htons((u_int16_t)(tp->snd_up - ntohl(ti->ti_seq)));
 #ifdef notdef  
         if (SEQ_GT(tp->snd_up, tp->snd_nxt)) {  
                 ti->ti_urp = htons((u_int16_t)(tp->snd_up - tp->snd_nxt));  
 #endif  
                 ti->ti_flags |= TH_URG;                  ti->ti_flags |= TH_URG;
         } else          } else
                 /*                  /*
Line 496  send: Line 415  send:
                         if (tp->t_rtt == 0) {                          if (tp->t_rtt == 0) {
                                 tp->t_rtt = 1;                                  tp->t_rtt = 1;
                                 tp->t_rtseq = startseq;                                  tp->t_rtseq = startseq;
                                 STAT(tcpstat.tcps_segstimed++);  
                         }                          }
                 }                  }
   
Line 535  send: Line 453  send:
         ((struct ip *)ti)->ip_ttl = IPDEFTTL;          ((struct ip *)ti)->ip_ttl = IPDEFTTL;
         ((struct ip *)ti)->ip_tos = so->so_iptos;          ((struct ip *)ti)->ip_tos = so->so_iptos;
   
 /* #if BSD >= 43 */  
         /* Don't do IP options... */  
 /*      error = ip_output(m, tp->t_inpcb->inp_options, &tp->t_inpcb->inp_route,  
  *          so->so_options & SO_DONTROUTE, 0);  
  */  
         error = ip_output(so, m);          error = ip_output(so, m);
   
 /* #else  
  *      error = ip_output(m, (struct mbuf *)0, &tp->t_inpcb->inp_route,  
  *          so->so_options & SO_DONTROUTE);  
  * #endif  
  */  
     }      }
         if (error) {          if (error) {
 out:  out:
 /*              if (error == ENOBUFS) {  
  *                      tcp_quench(tp->t_inpcb, 0);  
  *                      return (0);  
  *              }  
  */  
 /*              if ((error == EHOSTUNREACH || error == ENETDOWN)  
  *                  && TCPS_HAVERCVDSYN(tp->t_state)) {  
  *                      tp->t_softerror = error;  
  *                      return (0);  
  *              }  
  */  
                 return (error);                  return (error);
         }          }
         STAT(tcpstat.tcps_sndtotal++);  
   
         /*          /*
          * Data sent (as far as we can tell).           * Data sent (as far as we can tell).
Line 582  out: Line 477  out:
 }  }
   
 void  void
 tcp_setpersist(tp)  tcp_setpersist(struct tcpcb *tp)
         register struct tcpcb *tp;  
 {  {
     int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;      int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
   
 /*      if (tp->t_timer[TCPT_REXMT])  
  *              panic("tcp_output REXMT");  
  */  
         /*          /*
          * Start/restart persistence timer.           * Start/restart persistence timer.
          */           */

Removed from v.1.1.1.3  
changed lines
  Added in v.1.1.1.4


unix.superglobalmegacorp.com