Changeset 15074 in vbox for trunk

Timestamp:

Dec 7, 2008 10:13:12 PM (16 years ago)

Author:

vboxsync

Message:

slirp: better readability

Location:

trunk/src/VBox/Devices/Network/slirp

Files:

• debug.h (modified) (1 diff)
• tcp_output.c (modified) (2 diffs)
• tcp_subr.c (modified) (15 diffs)

trunk/src/VBox/Devices/Network/slirp/debug.h

@@ -11 +11 @@
 /* Unused anyway, using VBox Log facility. */
 #define dfd NULL
-extern int dostats;
-extern int slirp_debug;
 
 #define DBG_CALL 0x1

trunk/src/VBox/Devices/Network/slirp/tcp_output.c

@@ -49 +49 @@
  * 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",
+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] = {
-        TH_RST|TH_ACK, 0,      TH_SYN,        TH_SYN|TH_ACK,
-        TH_ACK,        TH_ACK, TH_FIN|TH_ACK, TH_FIN|TH_ACK,
-        TH_FIN|TH_ACK, TH_ACK, TH_ACK,
+static const u_char  tcp_outflags[TCP_NSTATES] =
+{
+    TH_RST|TH_ACK, 0,      TH_SYN,        TH_SYN|TH_ACK,
+    TH_ACK,        TH_ACK, TH_FIN|TH_ACK, TH_FIN|TH_ACK,
+    TH_FIN|TH_ACK, TH_ACK, TH_ACK,
 };
 
@@ -71 +73 @@
 tcp_output(PNATState pData, register struct tcpcb *tp)
 {
-        register struct socket *so = tp->t_socket;
-        register long len, win;
-        int off, flags, error;
-        register struct mbuf *m;
-        register struct tcpiphdr *ti;
-        u_char opt[MAX_TCPOPTLEN];
-        unsigned optlen, hdrlen;
-        int idle, sendalot;
-
-        DEBUG_CALL("tcp_output");
-        DEBUG_ARG("tp = %lx", (long )tp);
-
-        /*
-         * Determine length of data that should be transmitted,
-         * and flags that will be used.
-         * If there is some data or critical controls (SYN, RST)
-         * to send, then transmit; otherwise, investigate further.
-         */
-        idle = (tp->snd_max == tp->snd_una);
-        if (idle && tp->t_idle >= tp->t_rxtcur)
-                /*
-                 * We have been idle for "a while" and no acks are
-                 * expected to clock out any data we send --
-                 * slow start to get ack "clock" running again.
-                 */
-                tp->snd_cwnd = tp->t_maxseg;
+    register struct socket *so = tp->t_socket;
+    register long len, win;
+    int off, flags, error;
+    register struct mbuf *m;
+    register struct tcpiphdr *ti;
+    u_char opt[MAX_TCPOPTLEN];
+    unsigned optlen, hdrlen;
+    int idle, sendalot;
+
+    DEBUG_CALL("tcp_output");
+    DEBUG_ARG("tp = %lx", (long )tp);
+
+    /*
+     * Determine length of data that should be transmitted,
+     * and flags that will be used.
+     * If there is some data or critical controls (SYN, RST)
+     * to send, then transmit; otherwise, investigate further.
+     */
+    idle = (tp->snd_max == tp->snd_una);
+    if (idle && tp->t_idle >= tp->t_rxtcur)
+        /*
+         * We have been idle for "a while" and no acks are
+         * expected to clock out any data we send --
+         * slow start to get ack "clock" running again.
+         */
+        tp->snd_cwnd = tp->t_maxseg;
+
 again:
-        sendalot = 0;
-        off = tp->snd_nxt - tp->snd_una;
-        win = min(tp->snd_wnd, tp->snd_cwnd);
-
-        flags = tcp_outflags[tp->t_state];
-
-        DEBUG_MISC((dfd, " --- tcp_output flags = 0x%x\n",flags));
-
-        /*
-         * If in persist timeout with window of 0, send 1 byte.
-         * Otherwise, if window is small but nonzero
-         * and timer expired, we will send what we can
-         * and go to transmit state.
-         */
-        if (tp->t_force) {
-                if (win == 0) {
-                        /*
-                         * If we still have some data to send, then
-                         * clear the FIN bit.  Usually this would
-                         * happen below when it realizes that we
-                         * aren't sending all the data.  However,
-                         * if we have exactly 1 byte of unset data,
-                         * then it won't clear the FIN bit below,
-                         * and if we are in persist state, we wind
-                         * up sending the packet without recording
-                         * that we sent the FIN bit.
-                         *
-                         * We can't just blindly clear the FIN bit,
-                         * because if we don't have any more data
-                         * to send then the probe will be the FIN
-                         * itself.
-                         */
-                        if (off < so->so_snd.sb_cc)
-                                flags &= ~TH_FIN;
-                        win = 1;
-                } else {
-                        tp->t_timer[TCPT_PERSIST] = 0;
-                        tp->t_rxtshift = 0;
-                }
-        }
-
-        len = min(so->so_snd.sb_cc, win) - off;
-
-        if (len < 0) {
-                /*
-                 * If FIN has been sent but not acked,
-                 * but we haven't been called to retransmit,
-                 * len will be -1.  Otherwise, window shrank
-                 * after we sent into it.  If window shrank to 0,
-                 * cancel pending retransmit and pull snd_nxt
-                 * back to (closed) window.  We will enter persist
-                 * state below.  If the window didn't close completely,
-                 * just wait for an ACK.
-                 */
+    sendalot = 0;
+    off = tp->snd_nxt - tp->snd_una;
+    win = min(tp->snd_wnd, tp->snd_cwnd);
+
+    flags = tcp_outflags[tp->t_state];
+
+    DEBUG_MISC((dfd, " --- tcp_output flags = 0x%x\n",flags));
+
+    /*
+     * If in persist timeout with window of 0, send 1 byte.
+     * Otherwise, if window is small but nonzero
+     * and timer expired, we will send what we can
+     * and go to transmit state.
+     */
+    if (tp->t_force)
+    {
+        if (win == 0)
+        {
+            /*
+             * If we still have some data to send, then
+             * clear the FIN bit.  Usually this would
+             * happen below when it realizes that we
+             * aren't sending all the data.  However,
+             * if we have exactly 1 byte of unset data,
+             * then it won't clear the FIN bit below,
+             * and if we are in persist state, we wind
+             * up sending the packet without recording
+             * that we sent the FIN bit.
+             *
+             * We can't just blindly clear the FIN bit,
+             * because if we don't have any more data
+             * to send then the probe will be the FIN
+             * itself.
+             */
+            if (off < so->so_snd.sb_cc)
+                flags &= ~TH_FIN;
+            win = 1;
+        }
+        else
+        {
+            tp->t_timer[TCPT_PERSIST] = 0;
+            tp->t_rxtshift = 0;
+        }
+    }
+
+    len = min(so->so_snd.sb_cc, win) - off;
+    if (len < 0)
+    {
+        /*
+         * If FIN has been sent but not acked,
+         * but we haven't been called to retransmit,
+         * len will be -1.  Otherwise, window shrank
+         * after we sent into it.  If window shrank to 0,
+         * cancel pending retransmit and pull snd_nxt
+         * back to (closed) window.  We will enter persist
+         * state below.  If the window didn't close completely,
+         * just wait for an ACK.
+         */
+        len = 0;
+        if (win == 0)
+        {
+            tp->t_timer[TCPT_REXMT] = 0;
+            tp->snd_nxt = tp->snd_una;
+        }
+    }
+    if (len > tp->t_maxseg)
+    {
+        len = tp->t_maxseg;
+        sendalot = 1;
+    }
+    if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + so->so_snd.sb_cc))
+        flags &= ~TH_FIN;
+
+    win = sbspace(&so->so_rcv);
+
+    /*
+     * Sender silly window avoidance.  If connection is idle
+     * and can send all data, a maximum segment,
+     * at least a maximum default-size segment do it,
+     * or are forced, do it; otherwise don't bother.
+     * If peer's buffer is tiny, then send
+     * when window is at least half open.
+     * If retransmitting (possibly after persist timer forced us
+     * to send into a small window), then must resend.
+     */
+    if (len)
+    {
+        if (len == tp->t_maxseg)
+            goto send;
+        if ((1 || idle || tp->t_flags & TF_NODELAY) &&
+                len + off >= so->so_snd.sb_cc)
+            goto send;
+        if (tp->t_force)
+            goto send;
+        if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0)
+            goto send;
+        if (SEQ_LT(tp->snd_nxt, tp->snd_max))
+            goto send;
+    }
+
+    /*
+     * Compare available window to amount of window
+     * known to peer (as advertised window less
+     * next expected input).  If the difference is at least two
+     * max size segments, or at least 50% of the maximum possible
+     * window, then want to send a window update to peer.
+     */
+    if (win > 0)
+    {
+        /*
+         * "adv" is the amount we can increase the window,
+         * taking into account that we are limited by
+         * TCP_MAXWIN << tp->rcv_scale.
+         */
+        long adv = min(win, 
+                       (long)TCP_MAXWIN << tp->rcv_scale) - 
+                       (tp->rcv_adv - tp->rcv_nxt);
+
+        if (adv >= (long) (2 * tp->t_maxseg))
+            goto send;
+        if (2 * adv >= (long) so->so_rcv.sb_datalen)
+            goto send;
+    }
+
+    /*
+     * Send if we owe peer an ACK.
+     */
+    if (tp->t_flags & TF_ACKNOW)
+        goto send;
+    if (flags & (TH_SYN|TH_RST))
+        goto send;
+    if (SEQ_GT(tp->snd_up, tp->snd_una))
+        goto send;
+    /*
+     * If our state indicates that FIN should be sent
+     * and we have not yet done so, or we're retransmitting the FIN,
+     * then we need to send.
+     */
+    if (   flags & TH_FIN
+        && ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))
+        goto send;
+
+    /*
+     * TCP window updates are not reliable, rather a polling protocol
+     * using ``persist'' packets is used to insure receipt of window
+     * updates.  The three ``states'' for the output side are:
+     *      idle                    not doing retransmits or persists
+     *      persisting              to move a small or zero window
+     *      (re)transmitting        and thereby not persisting
+     *
+     * tp->t_timer[TCPT_PERSIST]
+     *      is set when we are in persist state.
+     * tp->t_force
+     *      is set when we are called to send a persist packet.
+     * tp->t_timer[TCPT_REXMT]
+     *      is set when we are retransmitting
+     * The output side is idle when both timers are zero.
+     *
+     * If send window is too small, there is data to transmit, and no
+     * retransmit or persist is pending, then go to persist state.
+     * If nothing happens soon, send when timer expires:
+     * if window is nonzero, transmit what we can,
+     * otherwise force out a byte.
+     */
+    if (   so->so_snd.sb_cc
+        && tp->t_timer[TCPT_REXMT] == 0
+        && tp->t_timer[TCPT_PERSIST] == 0)
+    {
+        tp->t_rxtshift = 0;
+        tcp_setpersist(tp);
+    }
+
+    /*
+     * No reason to send a segment, just return.
+     */
+    tcpstat.tcps_didnuttin++;
+
+    return (0);
+
+send:
+    /*
+     * Before ESTABLISHED, force sending of initial options
+     * unless TCP set not to do any options.
+     * NOTE: we assume that the IP/TCP header plus TCP options
+     * always fit in a single mbuf, leaving room for a maximum
+     * link header, i.e.
+     *      max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN
+     */
+    optlen = 0;
+    hdrlen = sizeof (struct tcpiphdr);
+    if (flags & TH_SYN)
+    {
+        tp->snd_nxt = tp->iss;
+        if ((tp->t_flags & TF_NOOPT) == 0)
+        {
+            u_int16_t mss;
+
+            opt[0] = TCPOPT_MAXSEG;
+            opt[1] = 4;
+            mss = htons((u_int16_t) tcp_mss(pData, tp, 0));
+            memcpy((caddr_t)(opt + 2), (caddr_t)&mss, sizeof(mss));
+            optlen = 4;
+
+#if 0
+            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;
+            }
+#endif
+        }
+    }
+
+    /*
+     * 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 0
+    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;
+    }
+#endif
+    hdrlen += optlen;
+
+    /*
+     * Adjust data length if insertion of options will
+     * bump the packet length beyond the t_maxseg length.
+     */
+    if (len > tp->t_maxseg - optlen)
+    {
+        len = tp->t_maxseg - optlen;
+        sendalot = 1;
+    }
+
+    /*
+     * Grab a header mbuf, attaching a copy of data to
+     * be transmitted, and initialize the header from
+     * the template for sends on this connection.
+     */
+    if (len)
+    {
+        if (tp->t_force && len == 1)
+            tcpstat.tcps_sndprobe++;
+        else if (SEQ_LT(tp->snd_nxt, tp->snd_max))
+        {
+            tcpstat.tcps_sndrexmitpack++;
+            tcpstat.tcps_sndrexmitbyte += len;
+        }
+        else
+        {
+            tcpstat.tcps_sndpack++;
+            tcpstat.tcps_sndbyte += len;
+        }
+
+        m = m_get(pData);
+        if (m == NULL)
+        {
+/*          error = ENOBUFS; */
+            error = 1;
+            goto out;
+        }
+        m->m_data += if_maxlinkhdr;
+        m->m_len = hdrlen;
+
+        /*
+         * This will always succeed, since we make sure our mbufs
+         * are big enough to hold one MSS packet + header + ... etc.
+         */
+#if 0
+        if (len <= MHLEN - hdrlen - max_linkhdr)
+        {
+#endif
+            sbcopy(&so->so_snd, off, (int) len, mtod(m, caddr_t) + hdrlen);
+            m->m_len += len;
+#if 0
+        }
+        else
+        {
+            m->m_next = m_copy(so->so_snd.sb_mb, off, (int) len);
+            if (m->m_next == 0)
                 len = 0;
-                if (win == 0) {
-                        tp->t_timer[TCPT_REXMT] = 0;
-                        tp->snd_nxt = tp->snd_una;
-                }
-        }
-
-        if (len > tp->t_maxseg) {
-                len = tp->t_maxseg;
-                sendalot = 1;
-        }
-        if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + so->so_snd.sb_cc))
-                flags &= ~TH_FIN;
-
-        win = sbspace(&so->so_rcv);
-
-        /*
-         * Sender silly window avoidance.  If connection is idle
-         * and can send all data, a maximum segment,
-         * at least a maximum default-size segment do it,
-         * or are forced, do it; otherwise don't bother.
-         * If peer's buffer is tiny, then send
-         * when window is at least half open.
-         * If retransmitting (possibly after persist timer forced us
-         * to send into a small window), then must resend.
-         */
-        if (len) {
-                if (len == tp->t_maxseg)
-                        goto send;
-                if ((1 || idle || tp->t_flags & TF_NODELAY) &&
-                    len + off >= so->so_snd.sb_cc)
-                        goto send;
-                if (tp->t_force)
-                        goto send;
-                if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0)
-                        goto send;
-                if (SEQ_LT(tp->snd_nxt, tp->snd_max))
-                        goto send;
-        }
-
-        /*
-         * Compare available window to amount of window
-         * known to peer (as advertised window less
-         * next expected input).  If the difference is at least two
-         * max size segments, or at least 50% of the maximum possible
-         * window, then want to send a window update to peer.
-         */
-        if (win > 0) {
-                /*
-                 * "adv" is the amount we can increase the window,
-                 * taking into account that we are limited by
-                 * TCP_MAXWIN << tp->rcv_scale.
-                 */
-                long adv = min(win, (long)TCP_MAXWIN << tp->rcv_scale) -
-                        (tp->rcv_adv - tp->rcv_nxt);
-
-                if (adv >= (long) (2 * tp->t_maxseg))
-                        goto send;
-                if (2 * adv >= (long) so->so_rcv.sb_datalen)
-                        goto send;
-        }
-
-        /*
-         * Send if we owe peer an ACK.
-         */
+        }
+#endif
+        /*
+         * If we're sending everything we've got, set PUSH.
+         * (This will keep happy those implementations which only
+         * give data to the user when a buffer fills or
+         * a PUSH comes in.)
+         */
+        if (off + len == so->so_snd.sb_cc)
+            flags |= TH_PUSH;
+    }
+    else
+    {
         if (tp->t_flags & TF_ACKNOW)
-                goto send;
-        if (flags & (TH_SYN|TH_RST))
-                goto send;
-        if (SEQ_GT(tp->snd_up, tp->snd_una))
-                goto send;
-        /*
-         * If our state indicates that FIN should be sent
-         * and we have not yet done so, or we're retransmitting the FIN,
-         * then we need to send.
-         */
-        if (flags & TH_FIN &&
-            ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))
-                goto send;
-
-        /*
-         * TCP window updates are not reliable, rather a polling protocol
-         * using ``persist'' packets is used to insure receipt of window
-         * updates.  The three ``states'' for the output side are:
-         *      idle                    not doing retransmits or persists
-         *      persisting              to move a small or zero window
-         *      (re)transmitting        and thereby not persisting
-         *
-         * tp->t_timer[TCPT_PERSIST]
-         *      is set when we are in persist state.
-         * tp->t_force
-         *      is set when we are called to send a persist packet.
-         * tp->t_timer[TCPT_REXMT]
-         *      is set when we are retransmitting
-         * The output side is idle when both timers are zero.
-         *
-         * If send window is too small, there is data to transmit, and no
-         * retransmit or persist is pending, then go to persist state.
-         * If nothing happens soon, send when timer expires:
-         * if window is nonzero, transmit what we can,
-         * otherwise force out a byte.
-         */
-        if (so->so_snd.sb_cc && tp->t_timer[TCPT_REXMT] == 0 &&
-            tp->t_timer[TCPT_PERSIST] == 0) {
+            tcpstat.tcps_sndacks++;
+        else if (flags & (TH_SYN|TH_FIN|TH_RST))
+            tcpstat.tcps_sndctrl++;
+        else if (SEQ_GT(tp->snd_up, tp->snd_una))
+            tcpstat.tcps_sndurg++;
+        else
+            tcpstat.tcps_sndwinup++;
+
+        m = m_get(pData);
+        if (m == NULL)
+        {
+/*          error = ENOBUFS; */
+            error = 1;
+            goto out;
+        }
+        m->m_data += if_maxlinkhdr;
+        m->m_len = hdrlen;
+    }
+
+    ti = mtod(m, struct tcpiphdr *);
+
+    memcpy((caddr_t)ti, &tp->t_template, sizeof (struct tcpiphdr));
+
+    /*
+     * Fill in fields, remembering maximum advertised
+     * window for use in delaying messages about window sizes.
+     * If resending a FIN, be sure not to use a new sequence number.
+     */
+    if (   flags & TH_FIN
+        && tp->t_flags & TF_SENTFIN
+        && tp->snd_nxt == tp->snd_max)
+        tp->snd_nxt--;
+    /*
+     * If we are doing retransmissions, then snd_nxt will
+     * not reflect the first unsent octet.  For ACK only
+     * packets, we do not want the sequence number of the
+     * retransmitted packet, we want the sequence number
+     * of the next unsent octet.  So, if there is no data
+     * (and no SYN or FIN), use snd_max instead of snd_nxt
+     * when filling in ti_seq.  But if we are in persist
+     * state, snd_max might reflect one byte beyond the
+     * right edge of the window, so use snd_nxt in that
+     * case, since we know we aren't doing a retransmission.
+     * (retransmit and persist are mutually exclusive...)
+     */
+    if (len || (flags & (TH_SYN|TH_FIN)) || tp->t_timer[TCPT_PERSIST])
+        ti->ti_seq = htonl(tp->snd_nxt);
+    else
+        ti->ti_seq = htonl(tp->snd_max);
+    ti->ti_ack = htonl(tp->rcv_nxt);
+    if (optlen)
+    {
+        memcpy((caddr_t)(ti + 1), (caddr_t)opt, optlen);
+        ti->ti_off = (sizeof (struct tcphdr) + optlen) >> 2;
+    }
+    ti->ti_flags = flags;
+    /*
+     * Calculate receive window.  Don't shrink window,
+     * but avoid silly window syndrome.
+     */
+    if (win < (long)(so->so_rcv.sb_datalen / 4) && win < (long)tp->t_maxseg)
+        win = 0;
+    if (win > (long)TCP_MAXWIN << tp->rcv_scale)
+        win = (long)TCP_MAXWIN << tp->rcv_scale;
+    if (win < (long)(tp->rcv_adv - tp->rcv_nxt))
+        win = (long)(tp->rcv_adv - tp->rcv_nxt);
+    ti->ti_win = htons((u_int16_t) (win>>tp->rcv_scale));
+
+#if 0
+    if (SEQ_GT(tp->snd_up, tp->snd_nxt))
+    {
+        ti->ti_urp = htons((u_int16_t)(tp->snd_up - tp->snd_nxt));
+#else
+    if (SEQ_GT(tp->snd_up, tp->snd_una))
+    {
+        ti->ti_urp = htons((u_int16_t)(tp->snd_up - ntohl(ti->ti_seq)));
+#endif
+        ti->ti_flags |= TH_URG;
+    }
+    else
+        /*
+         * If no urgent pointer to send, then we pull
+         * the urgent pointer to the left edge of the send window
+         * so that it doesn't drift into the send window on sequence
+         * number wraparound.
+         */
+        tp->snd_up = tp->snd_una;               /* drag it along */
+
+    /*
+     * Put TCP length in extended header, and then
+     * checksum extended header and data.
+     */
+    if (len + optlen)
+        ti->ti_len = htons((u_int16_t)(sizeof (struct tcphdr)
+                                       + optlen + len));
+    ti->ti_sum = cksum(m, (int)(hdrlen + len));
+
+    /*
+     * In transmit state, time the transmission and arrange for
+     * the retransmit.  In persist state, just set snd_max.
+     */
+    if (tp->t_force == 0 || tp->t_timer[TCPT_PERSIST] == 0) 
+    {
+        tcp_seq startseq = tp->snd_nxt;
+
+        /*
+         * Advance snd_nxt over sequence space of this segment.
+         */
+        if (flags & (TH_SYN|TH_FIN))
+        {
+            if (flags & TH_SYN)
+                tp->snd_nxt++;
+            if (flags & TH_FIN)
+            {
+                tp->snd_nxt++;
+                tp->t_flags |= TF_SENTFIN;
+            }
+        }
+        tp->snd_nxt += len;
+        if (SEQ_GT(tp->snd_nxt, tp->snd_max))
+        {
+            tp->snd_max = tp->snd_nxt;
+            /*
+             * Time this transmission if not a retransmission and
+             * not currently timing anything.
+             */
+            if (tp->t_rtt == 0)
+            {
+                tp->t_rtt = 1;
+                tp->t_rtseq = startseq;
+                tcpstat.tcps_segstimed++;
+            }
+        }
+
+        /*
+         * Set retransmit timer if not currently set,
+         * and not doing an ack or a keep-alive probe.
+         * Initial value for retransmit timer is smoothed
+         * round-trip time + 2 * round-trip time variance.
+         * Initialize shift counter which is used for backoff
+         * of retransmit time.
+         */
+        if (   tp->t_timer[TCPT_REXMT] == 0
+            && tp->snd_nxt != tp->snd_una)
+        {
+            tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
+            if (tp->t_timer[TCPT_PERSIST])
+            {
+                tp->t_timer[TCPT_PERSIST] = 0;
                 tp->t_rxtshift = 0;
-                tcp_setpersist(tp);
-        }
-
-        /*
-         * No reason to send a segment, just return.
-         */
-        tcpstat.tcps_didnuttin++;
-
-        return (0);
-
-send:
-        /*
-         * Before ESTABLISHED, force sending of initial options
-         * unless TCP set not to do any options.
-         * NOTE: we assume that the IP/TCP header plus TCP options
-         * always fit in a single mbuf, leaving room for a maximum
-         * link header, i.e.
-         *      max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN
-         */
-        optlen = 0;
-        hdrlen = sizeof (struct tcpiphdr);
-        if (flags & TH_SYN) {
-                tp->snd_nxt = tp->iss;
-                if ((tp->t_flags & TF_NOOPT) == 0) {
-                        u_int16_t mss;
-
-                        opt[0] = TCPOPT_MAXSEG;
-                        opt[1] = 4;
-                        mss = htons((u_int16_t) tcp_mss(pData, tp, 0));
-                        memcpy((caddr_t)(opt + 2), (caddr_t)&mss, sizeof(mss));
-                        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;
-
-        /*
-         * Adjust data length if insertion of options will
-         * bump the packet length beyond the t_maxseg length.
-         */
-         if (len > tp->t_maxseg - optlen) {
-                len = tp->t_maxseg - optlen;
-                sendalot = 1;
-         }
-
-        /*
-         * Grab a header mbuf, attaching a copy of data to
-         * be transmitted, and initialize the header from
-         * the template for sends on this connection.
-         */
-        if (len) {
-                if (tp->t_force && len == 1)
-                        tcpstat.tcps_sndprobe++;
-                else if (SEQ_LT(tp->snd_nxt, tp->snd_max)) {
-                        tcpstat.tcps_sndrexmitpack++;
-                        tcpstat.tcps_sndrexmitbyte += len;
-                } else {
-                        tcpstat.tcps_sndpack++;
-                        tcpstat.tcps_sndbyte += len;
-                }
-
-                m = m_get(pData);
-                if (m == NULL) {
-/*                      error = ENOBUFS; */
-                        error = 1;
-                        goto out;
-                }
-                m->m_data += if_maxlinkhdr;
-                m->m_len = hdrlen;
-
-                /*
-                 * This will always succeed, since we make sure our mbufs
-                 * 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.
-                 * (This will keep happy those implementations which only
-                 * give data to the user when a buffer fills or
-                 * a PUSH comes in.)
-                 */
-                if (off + len == so->so_snd.sb_cc)
-                        flags |= TH_PUSH;
-        } else {
-                if (tp->t_flags & TF_ACKNOW)
-                        tcpstat.tcps_sndacks++;
-                else if (flags & (TH_SYN|TH_FIN|TH_RST))
-                        tcpstat.tcps_sndctrl++;
-                else if (SEQ_GT(tp->snd_up, tp->snd_una))
-                        tcpstat.tcps_sndurg++;
-                else
-                        tcpstat.tcps_sndwinup++;
-
-                m = m_get(pData);
-                if (m == NULL) {
-/*                      error = ENOBUFS; */
-                        error = 1;
-                        goto out;
-                }
-                m->m_data += if_maxlinkhdr;
-                m->m_len = hdrlen;
-        }
-
-        ti = mtod(m, struct tcpiphdr *);
-
-        memcpy((caddr_t)ti, &tp->t_template, sizeof (struct tcpiphdr));
-
-        /*
-         * Fill in fields, remembering maximum advertised
-         * window for use in delaying messages about window sizes.
-         * If resending a FIN, be sure not to use a new sequence number.
-         */
-        if (flags & TH_FIN && tp->t_flags & TF_SENTFIN &&
-            tp->snd_nxt == tp->snd_max)
-                tp->snd_nxt--;
-        /*
-         * If we are doing retransmissions, then snd_nxt will
-         * not reflect the first unsent octet.  For ACK only
-         * packets, we do not want the sequence number of the
-         * retransmitted packet, we want the sequence number
-         * of the next unsent octet.  So, if there is no data
-         * (and no SYN or FIN), use snd_max instead of snd_nxt
-         * when filling in ti_seq.  But if we are in persist
-         * state, snd_max might reflect one byte beyond the
-         * right edge of the window, so use snd_nxt in that
-         * case, since we know we aren't doing a retransmission.
-         * (retransmit and persist are mutually exclusive...)
-         */
-        if (len || (flags & (TH_SYN|TH_FIN)) || tp->t_timer[TCPT_PERSIST])
-                ti->ti_seq = htonl(tp->snd_nxt);
-        else
-                ti->ti_seq = htonl(tp->snd_max);
-        ti->ti_ack = htonl(tp->rcv_nxt);
-        if (optlen) {
-                memcpy((caddr_t)(ti + 1), (caddr_t)opt, optlen);
-                ti->ti_off = (sizeof (struct tcphdr) + optlen) >> 2;
-        }
-        ti->ti_flags = flags;
-        /*
-         * Calculate receive window.  Don't shrink window,
-         * but avoid silly window syndrome.
-         */
-        if (win < (long)(so->so_rcv.sb_datalen / 4) && win < (long)tp->t_maxseg)
-                win = 0;
-        if (win > (long)TCP_MAXWIN << tp->rcv_scale)
-                win = (long)TCP_MAXWIN << tp->rcv_scale;
-        if (win < (long)(tp->rcv_adv - tp->rcv_nxt))
-                win = (long)(tp->rcv_adv - tp->rcv_nxt);
-        ti->ti_win = htons((u_int16_t) (win>>tp->rcv_scale));
-
-        if (SEQ_GT(tp->snd_up, tp->snd_una)) {
-                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;
-        } else
-                /*
-                 * If no urgent pointer to send, then we pull
-                 * the urgent pointer to the left edge of the send window
-                 * so that it doesn't drift into the send window on sequence
-                 * number wraparound.
-                 */
-                tp->snd_up = tp->snd_una;               /* drag it along */
-
-        /*
-         * Put TCP length in extended header, and then
-         * checksum extended header and data.
-         */
-        if (len + optlen)
-                ti->ti_len = htons((u_int16_t)(sizeof (struct tcphdr) +
-                    optlen + len));
-        ti->ti_sum = cksum(m, (int)(hdrlen + len));
-
-        /*
-         * In transmit state, time the transmission and arrange for
-         * the retransmit.  In persist state, just set snd_max.
-         */
-        if (tp->t_force == 0 || tp->t_timer[TCPT_PERSIST] == 0) {
-                tcp_seq startseq = tp->snd_nxt;
-
-                /*
-                 * Advance snd_nxt over sequence space of this segment.
-                 */
-                if (flags & (TH_SYN|TH_FIN)) {
-                        if (flags & TH_SYN)
-                                tp->snd_nxt++;
-                        if (flags & TH_FIN) {
-                                tp->snd_nxt++;
-                                tp->t_flags |= TF_SENTFIN;
-                        }
-                }
-                tp->snd_nxt += len;
-                if (SEQ_GT(tp->snd_nxt, tp->snd_max)) {
-                        tp->snd_max = tp->snd_nxt;
-                        /*
-                         * Time this transmission if not a retransmission and
-                         * not currently timing anything.
-                         */
-                        if (tp->t_rtt == 0) {
-                                tp->t_rtt = 1;
-                                tp->t_rtseq = startseq;
-                                tcpstat.tcps_segstimed++;
-                        }
-                }
-
-                /*
-                 * Set retransmit timer if not currently set,
-                 * and not doing an ack or a keep-alive probe.
-                 * Initial value for retransmit timer is smoothed
-                 * round-trip time + 2 * round-trip time variance.
-                 * Initialize shift counter which is used for backoff
-                 * of retransmit time.
-                 */
-                if (tp->t_timer[TCPT_REXMT] == 0 &&
-                    tp->snd_nxt != tp->snd_una) {
-                        tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
-                        if (tp->t_timer[TCPT_PERSIST]) {
-                                tp->t_timer[TCPT_PERSIST] = 0;
-                                tp->t_rxtshift = 0;
-                        }
-                }
-        } else
-                if (SEQ_GT(tp->snd_nxt + len, tp->snd_max))
-                        tp->snd_max = tp->snd_nxt + len;
-
-        /*
-         * Fill in IP length and desired time to live and
-         * send to IP level.  There should be a better way
-         * to handle ttl and tos; we could keep them in
-         * the template, but need a way to checksum without them.
-         */
-        m->m_len = hdrlen + len; /* XXX Needed? m_len should be correct */
-
-    {
-
+            }
+        }
+    }
+    else
+        if (SEQ_GT(tp->snd_nxt + len, tp->snd_max))
+            tp->snd_max = tp->snd_nxt + len;
+
+    /*
+     * Fill in IP length and desired time to live and
+     * send to IP level.  There should be a better way
+     * to handle ttl and tos; we could keep them in
+     * the template, but need a way to checksum without them.
+     */
+    m->m_len = hdrlen + len; /* XXX Needed? m_len should be correct */
+
+    {
         ((struct ip *)ti)->ip_len = m->m_len;
-
         ((struct ip *)ti)->ip_ttl = ip_defttl;
         ((struct ip *)ti)->ip_tos = so->so_iptos;
 
-/* #if BSD >= 43 */
+        /* #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);
- */
+#if 0
+        error = ip_output(m, tp->t_inpcb->inp_options, &tp->t_inpcb->inp_route,
+                         so->so_options & SO_DONTROUTE, 0);
+#endif
         error = ip_output(pData, so, m);
 
-/* #else
- *      error = ip_output(m, (struct mbuf *)0, &tp->t_inpcb->inp_route,
- *          so->so_options & SO_DONTROUTE);
- * #endif
- */
-    }
-        if (error) {
+#if 0
+/* #else */
+        error = ip_output(m, (struct mbuf *)0, &tp->t_inpcb->inp_route,
+                          so->so_options & SO_DONTROUTE);
+/* #endif */
+#endif
+    }
+    if (error)
+    {
 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);
-        }
-        tcpstat.tcps_sndtotal++;
-
-        /*
-         * Data sent (as far as we can tell).
-         * If this advertises a larger window than any other segment,
-         * then remember the size of the advertised window.
-         * Any pending ACK has now been sent.
-         */
-        if (win > 0 && SEQ_GT(tp->rcv_nxt+win, tp->rcv_adv))
-                tp->rcv_adv = tp->rcv_nxt + win;
-        tp->last_ack_sent = tp->rcv_nxt;
-        tp->t_flags &= ~(TF_ACKNOW|TF_DELACK);
-        if (sendalot)
-                goto again;
-
-        return (0);
+#if 0
+        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);
+        }
+#endif
+        return (error);
+    }
+    tcpstat.tcps_sndtotal++;
+
+    /*
+     * Data sent (as far as we can tell).
+     * If this advertises a larger window than any other segment,
+     * then remember the size of the advertised window.
+     * Any pending ACK has now been sent.
+     */
+    if (win > 0 && SEQ_GT(tp->rcv_nxt+win, tp->rcv_adv))
+        tp->rcv_adv = tp->rcv_nxt + win;
+    tp->last_ack_sent = tp->rcv_nxt;
+    tp->t_flags &= ~(TF_ACKNOW|TF_DELACK);
+    if (sendalot)
+        goto again;
+
+    return (0);
 }
 
 void
-tcp_setpersist(tp)
-        register struct tcpcb *tp;
+tcp_setpersist(struct tcpcb *tp)
 {
     int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
 
-/*      if (tp->t_timer[TCPT_REXMT])
- *              panic("tcp_output REXMT");
- */
-        /*
-         * Start/restart persistence timer.
-         */
-        TCPT_RANGESET(tp->t_timer[TCPT_PERSIST],
-            t * tcp_backoff[tp->t_rxtshift],
-            TCPTV_PERSMIN, TCPTV_PERSMAX);
-        if (tp->t_rxtshift < TCP_MAXRXTSHIFT)
-                tp->t_rxtshift++;
+#if 0
+    if (tp->t_timer[TCPT_REXMT])
+        panic("tcp_output REXMT");
+#endif
+    /*
+     * Start/restart persistence timer.
+     */
+    TCPT_RANGESET(tp->t_timer[TCPT_PERSIST],
+                  t * tcp_backoff[tp->t_rxtshift],
+                  TCPTV_PERSMIN, TCPTV_PERSMAX);
+    if (tp->t_rxtshift < TCP_MAXRXTSHIFT)
+        tp->t_rxtshift++;
 }

trunk/src/VBox/Devices/Network/slirp/tcp_subr.c

@@ -53 +53 @@
 tcp_init(PNATState pData)
 {
-        tcp_iss = 1;            /* wrong */
-        tcb.so_next = tcb.so_prev = &tcb;
-        tcp_last_so = &tcb;
+    tcp_iss = 1;            /* wrong */
+    tcb.so_next = tcb.so_prev = &tcb;
+    tcp_last_so = &tcb;
 #ifdef VBOX_WITH_BSD_REASS
-        tcp_reass_maxqlen = 48;
-        tcp_reass_maxseg  = 256;
+    tcp_reass_maxqlen = 48;
+    tcp_reass_maxseg  = 256;
 #endif /* VBOX_WITH_BSD_REASS */
 }
@@ -70 +70 @@
 /* struct tcpiphdr * */
 void
-tcp_template(tp)
-        struct tcpcb *tp;
-{
-        struct socket *so = tp->t_socket;
-        register struct tcpiphdr *n = &tp->t_template;
+tcp_template(struct tcpcb *tp)
+{
+    struct socket *so = tp->t_socket;
+    register struct tcpiphdr *n = &tp->t_template;
 
 #if !defined(VBOX_WITH_BSD_REASS)
-        n->ti_next = n->ti_prev = 0;
-        n->ti_x1 = 0;
+    n->ti_next = n->ti_prev = 0;
+    n->ti_x1 = 0;
 #else
-        memset(n->ti_x1, 0, 9);
+    memset(n->ti_x1, 0, 9);
 #endif
-        n->ti_pr = IPPROTO_TCP;
-        n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));
-        n->ti_src = so->so_faddr;
-        n->ti_dst = so->so_laddr;
-        n->ti_sport = so->so_fport;
-        n->ti_dport = so->so_lport;
-
-        n->ti_seq = 0;
-        n->ti_ack = 0;
-        n->ti_x2 = 0;
-        n->ti_off = 5;
-        n->ti_flags = 0;
-        n->ti_win = 0;
-        n->ti_sum = 0;
-        n->ti_urp = 0;
+    n->ti_pr = IPPROTO_TCP;
+    n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));
+    n->ti_src = so->so_faddr;
+    n->ti_dst = so->so_laddr;
+    n->ti_sport = so->so_fport;
+    n->ti_dport = so->so_lport;
+
+    n->ti_seq = 0;
+    n->ti_ack = 0;
+    n->ti_x2 = 0;
+    n->ti_off = 5;
+    n->ti_flags = 0;
+    n->ti_win = 0;
+    n->ti_sum = 0;
+    n->ti_urp = 0;
 }
 
@@ -115 +114 @@
 tcp_respond(PNATState pData, struct tcpcb *tp, struct tcpiphdr *ti, struct mbuf *m, tcp_seq ack, tcp_seq seq, int flags)
 {
-        register int tlen;
-        int win = 0;
-
-        DEBUG_CALL("tcp_respond");
-        DEBUG_ARG("tp = %lx", (long)tp);
-        DEBUG_ARG("ti = %lx", (long)ti);
-        DEBUG_ARG("m = %lx", (long)m);
-        DEBUG_ARG("ack = %u", ack);
-        DEBUG_ARG("seq = %u", seq);
-        DEBUG_ARG("flags = %x", flags);
-
-        if (tp)
-                win = sbspace(&tp->t_socket->so_rcv);
-        if (m == 0) {
-                if ((m = m_get(pData)) == NULL)
-                        return;
+    register int tlen;
+    int win = 0;
+
+    DEBUG_CALL("tcp_respond");
+    DEBUG_ARG("tp = %lx", (long)tp);
+    DEBUG_ARG("ti = %lx", (long)ti);
+    DEBUG_ARG("m = %lx", (long)m);
+    DEBUG_ARG("ack = %u", ack);
+    DEBUG_ARG("seq = %u", seq);
+    DEBUG_ARG("flags = %x", flags);
+
+    if (tp)
+        win = sbspace(&tp->t_socket->so_rcv);
+    if (m == 0)
+    {
+        if ((m = m_get(pData)) == NULL)
+            return;
 #ifdef TCP_COMPAT_42
-                tlen = 1;
+        tlen = 1;
 #else
-                tlen = 0;
+        tlen = 0;
 #endif
-                m->m_data += if_maxlinkhdr;
-                *mtod(m, struct tcpiphdr *) = *ti;
-                ti = mtod(m, struct tcpiphdr *);
-                flags = TH_ACK;
-        } else {
-                /*
-                 * ti points into m so the next line is just making
-                 * the mbuf point to ti
-                 */
-                m->m_data = (caddr_t)ti;
-
-                m->m_len = sizeof (struct tcpiphdr);
-                tlen = 0;
+        m->m_data += if_maxlinkhdr;
+        *mtod(m, struct tcpiphdr *) = *ti;
+        ti = mtod(m, struct tcpiphdr *);
+        flags = TH_ACK;
+    }
+    else
+    {
+        /*
+         * ti points into m so the next line is just making
+         * the mbuf point to ti
+         */
+        m->m_data = (caddr_t)ti;
+
+        m->m_len = sizeof (struct tcpiphdr);
+        tlen = 0;
 #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
-                xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_int32_t);
-                xchg(ti->ti_dport, ti->ti_sport, u_int16_t);
+        xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_int32_t);
+        xchg(ti->ti_dport, ti->ti_sport, u_int16_t);
 #undef xchg
-        }
-        ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));
-        tlen += sizeof (struct tcpiphdr);
-        m->m_len = tlen;
+    }
+    ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));
+    tlen += sizeof (struct tcpiphdr);
+    m->m_len = tlen;
 
 #if !defined(VBOX_WITH_BSD_REASS)
-        ti->ti_next = ti->ti_prev = 0;
-        ti->ti_x1 = 0;
+    ti->ti_next = ti->ti_prev = 0;
+    ti->ti_x1 = 0;
 #else
-        memset(ti->ti_x1, 0, 9);
+    memset(ti->ti_x1, 0, 9);
 #endif
-        ti->ti_seq = htonl(seq);
-        ti->ti_ack = htonl(ack);
-        ti->ti_x2 = 0;
-        ti->ti_off = sizeof (struct tcphdr) >> 2;
-        ti->ti_flags = flags;
-        if (tp)
-                ti->ti_win = htons((u_int16_t) (win >> tp->rcv_scale));
-        else
-                ti->ti_win = htons((u_int16_t)win);
-        ti->ti_urp = 0;
-        ti->ti_sum = 0;
-        ti->ti_sum = cksum(m, tlen);
-        ((struct ip *)ti)->ip_len = tlen;
-
-        if(flags & TH_RST)
-          ((struct ip *)ti)->ip_ttl = MAXTTL;
-        else
-          ((struct ip *)ti)->ip_ttl = ip_defttl;
-
-        (void) ip_output(pData, (struct socket *)0, m);
+    ti->ti_seq = htonl(seq);
+    ti->ti_ack = htonl(ack);
+    ti->ti_x2 = 0;
+    ti->ti_off = sizeof (struct tcphdr) >> 2;
+    ti->ti_flags = flags;
+    if (tp)
+        ti->ti_win = htons((u_int16_t) (win >> tp->rcv_scale));
+    else
+        ti->ti_win = htons((u_int16_t)win);
+    ti->ti_urp = 0;
+    ti->ti_sum = 0;
+    ti->ti_sum = cksum(m, tlen);
+    ((struct ip *)ti)->ip_len = tlen;
+
+    if(flags & TH_RST)
+        ((struct ip *)ti)->ip_ttl = MAXTTL;
+    else
+        ((struct ip *)ti)->ip_ttl = ip_defttl;
+
+    (void) ip_output(pData, (struct socket *)0, m);
 }
 
@@ -194 +196 @@
 tcp_newtcpcb(PNATState pData, struct socket *so)
 {
-        register struct tcpcb *tp;
-
-        tp = (struct tcpcb *)malloc(sizeof(*tp));
-        if (tp == NULL)
-                return ((struct tcpcb *)0);
-
-        memset((char *) tp, 0, sizeof(struct tcpcb));
+    register struct tcpcb *tp;
+
+    tp = (struct tcpcb *)malloc(sizeof(*tp));
+    if (tp == NULL)
+        return ((struct tcpcb *)0);
+
+    memset((char *) tp, 0, sizeof(struct tcpcb));
 #ifndef VBOX_WITH_BSD_REASS
-        tp->seg_next = tp->seg_prev = ptr_to_u32(pData, (struct tcpiphdr *)tp);
+    tp->seg_next = tp->seg_prev = ptr_to_u32(pData, (struct tcpiphdr *)tp);
 #endif /* !VBOX_WITH_BSD_REASS */
-        tp->t_maxseg = tcp_mssdflt;
-
-        tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
-        tp->t_socket = so;
-
-        /*
-         * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
-         * rtt estimate.  Set rttvar so that srtt + 2 * rttvar gives
-         * reasonable initial retransmit time.
-         */
-        tp->t_srtt = TCPTV_SRTTBASE;
-        tp->t_rttvar = tcp_rttdflt * PR_SLOWHZ << 2;
-        tp->t_rttmin = TCPTV_MIN;
-
-        TCPT_RANGESET(tp->t_rxtcur,
-            ((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1,
-            TCPTV_MIN, TCPTV_REXMTMAX);
-
-        tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
-        tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
-        tp->t_state = TCPS_CLOSED;
-
-        so->so_tcpcb = tp;
-
-        return (tp);
+    tp->t_maxseg = tcp_mssdflt;
+
+    tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
+    tp->t_socket = so;
+
+    /*
+     * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
+     * rtt estimate.  Set rttvar so that srtt + 2 * rttvar gives
+     * reasonable initial retransmit time.
+     */
+    tp->t_srtt = TCPTV_SRTTBASE;
+    tp->t_rttvar = tcp_rttdflt * PR_SLOWHZ << 2;
+    tp->t_rttmin = TCPTV_MIN;
+
+    TCPT_RANGESET(tp->t_rxtcur,
+                  ((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1,
+                  TCPTV_MIN, TCPTV_REXMTMAX);
+
+    tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
+    tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
+    tp->t_state = TCPS_CLOSED;
+
+    so->so_tcpcb = tp;
+
+    return (tp);
 }
 
@@ -243 +245 @@
 {
 */
-
-        DEBUG_CALL("tcp_drop");
-        DEBUG_ARG("tp = %lx", (long)tp);
-        DEBUG_ARG("errno = %d", errno);
-
-        if (TCPS_HAVERCVDSYN(tp->t_state)) {
-                tp->t_state = TCPS_CLOSED;
-                (void) tcp_output(pData, tp);
-                tcpstat.tcps_drops++;
-        } else
-                tcpstat.tcps_conndrops++;
-/*      if (errno == ETIMEDOUT && tp->t_softerror)
- *              errno = tp->t_softerror;
- */
-/*      so->so_error = errno; */
-        return (tcp_close(pData, tp));
+    DEBUG_CALL("tcp_drop");
+    DEBUG_ARG("tp = %lx", (long)tp);
+    DEBUG_ARG("errno = %d", errno);
+
+    if (TCPS_HAVERCVDSYN(tp->t_state))
+    {
+        tp->t_state = TCPS_CLOSED;
+        (void) tcp_output(pData, tp);
+        tcpstat.tcps_drops++;
+    }
+    else
+        tcpstat.tcps_conndrops++;
+#if 0
+      if (errno == ETIMEDOUT && tp->t_softerror)
+              errno = tp->t_softerror;
+
+      so->so_error = errno;
+#endif
+      return (tcp_close(pData, tp));
 }
 
@@ -270 +275 @@
 tcp_close(PNATState pData, register struct tcpcb *tp)
 {
-        register struct tcpiphdr *t;
-        struct socket *so = tp->t_socket;
-        register struct mbuf *m;
+    register struct tcpiphdr *t;
+    struct socket *so = tp->t_socket;
+    register struct mbuf *m;
 
 #ifndef VBOX_WITH_BSD_REASS
-        DEBUG_CALL("tcp_close");
-        DEBUG_ARG("tp = %lx", (long )tp);
-
-        /* free the reassembly queue, if any */
-        t = u32_to_ptr(pData, tp->seg_next, struct tcpiphdr *);
-        while (t != (struct tcpiphdr *)tp) {
-                t = u32_to_ptr(pData, t->ti_next, struct tcpiphdr *);
-                m = REASS_MBUF_GET(u32_to_ptr(pData, t->ti_prev, struct tcpiphdr *));
-                remque_32(pData, u32_to_ptr(pData, t->ti_prev, struct tcpiphdr *));
-                m_freem(pData, m);
-        }
-        /* It's static */
-/*      if (tp->t_template)
- *              (void) m_free(dtom(tp->t_template));
- */
-/*      free(tp, M_PCB);  */
-        u32ptr_done(pData, ptr_to_u32(pData, tp), tp);
+    DEBUG_CALL("tcp_close");
+    DEBUG_ARG("tp = %lx", (long )tp);
+
+    /* free the reassembly queue, if any */
+    t = u32_to_ptr(pData, tp->seg_next, struct tcpiphdr *);
+    while (t != (struct tcpiphdr *)tp)
+    {
+        t = u32_to_ptr(pData, t->ti_next, struct tcpiphdr *);
+        m = REASS_MBUF_GET(u32_to_ptr(pData, t->ti_prev, struct tcpiphdr *));
+        remque_32(pData, u32_to_ptr(pData, t->ti_prev, struct tcpiphdr *));
+        m_freem(pData, m);
+    }
+    /* It's static */
+#if 0
+    if (tp->t_template)
+        (void) m_free(dtom(tp->t_template));
+
+    free(tp, M_PCB);  
+#endif
+    u32ptr_done(pData, ptr_to_u32(pData, tp), tp);
 #else  /* VBOX_WITH_BSD_REASS */
-        struct tseg_qent *te;
-        DEBUG_CALL("tcp_close");
-        DEBUG_ARG("tp = %lx", (long )tp);
-        /*XXX: freeing the reassembly queue */
-        LIST_FOREACH(te, &tp->t_segq, tqe_q) {
-            LIST_REMOVE(te, tqe_q);
-            m_freem(pData, te->tqe_m);
-            free(te);
-            tcp_reass_qsize--;
-        }
+    struct tseg_qent *te;
+    DEBUG_CALL("tcp_close");
+    DEBUG_ARG("tp = %lx", (long )tp);
+    /*XXX: freeing the reassembly queue */
+    LIST_FOREACH(te, &tp->t_segq, tqe_q)
+    {
+        LIST_REMOVE(te, tqe_q);
+        m_freem(pData, te->tqe_m);
+        free(te);
+        tcp_reass_qsize--;
+    }
 #endif /* VBOX_WITH_BSD_REASS */
-        free(tp);
-        so->so_tcpcb = 0;
-        soisfdisconnected(so);
-        /* clobber input socket cache if we're closing the cached connection */
-        if (so == tcp_last_so)
-                tcp_last_so = &tcb;
-        closesocket(so->s);
-        sbfree(&so->so_rcv);
-        sbfree(&so->so_snd);
-        sofree(pData, so);
-        tcpstat.tcps_closed++;
-        return ((struct tcpcb *)0);
+    free(tp);
+    so->so_tcpcb = 0;
+    soisfdisconnected(so);
+    /* clobber input socket cache if we're closing the cached connection */
+    if (so == tcp_last_so)
+        tcp_last_so = &tcb;
+    closesocket(so->s);
+    sbfree(&so->so_rcv);
+    sbfree(&so->so_snd);
+    sofree(pData, so);
+    tcpstat.tcps_closed++;
+    return ((struct tcpcb *)0);
 }
 
@@ -321 +330 @@
 tcp_drain()
 {
-        /* XXX */
+    /* XXX */
 }
 
@@ -329 +338 @@
  */
 
-#ifdef notdef
+#if 0
 
 void
-tcp_quench(i, errno)
-
-        int errno;
-{
-        struct tcpcb *tp = intotcpcb(inp);
-
-        if (tp)
-                tp->snd_cwnd = tp->t_maxseg;
-}
-
-#endif /* notdef */
+tcp_quench(i, int errno)
+{
+    struct tcpcb *tp = intotcpcb(inp);
+
+    if (tp)
+        tp->snd_cwnd = tp->t_maxseg;
+}
+
+#endif
 
 /*
@@ -361 +368 @@
 tcp_sockclosed(PNATState pData, struct tcpcb *tp)
 {
-
-        DEBUG_CALL("tcp_sockclosed");
-        DEBUG_ARG("tp = %lx", (long)tp);
-
-        switch (tp->t_state) {
-
+    DEBUG_CALL("tcp_sockclosed");
+    DEBUG_ARG("tp = %lx", (long)tp);
+
+    switch (tp->t_state)
+    {
         case TCPS_CLOSED:
         case TCPS_LISTEN:
         case TCPS_SYN_SENT:
-                tp->t_state = TCPS_CLOSED;
-                tp = tcp_close(pData, tp);
-                break;
+            tp->t_state = TCPS_CLOSED;
+            tp = tcp_close(pData, tp);
+            break;
 
         case TCPS_SYN_RECEIVED:
         case TCPS_ESTABLISHED:
-                tp->t_state = TCPS_FIN_WAIT_1;
-                break;
+            tp->t_state = TCPS_FIN_WAIT_1;
+            break;
 
         case TCPS_CLOSE_WAIT:
-                tp->t_state = TCPS_LAST_ACK;
-                break;
-        }
-/*      soisfdisconnecting(tp->t_socket); */
-        if (tp && tp->t_state >= TCPS_FIN_WAIT_2)
-                soisfdisconnected(tp->t_socket);
-        if (tp)
-                tcp_output(pData, tp);
+            tp->t_state = TCPS_LAST_ACK;
+            break;
+    }
+/*  soisfdisconnecting(tp->t_socket); */
+    if (   tp 
+        && tp->t_state >= TCPS_FIN_WAIT_2)
+        soisfdisconnected(tp->t_socket);
+    if (tp)
+        tcp_output(pData, tp);
 }
 
@@ -402 +409 @@
 int tcp_fconnect(PNATState pData, struct socket *so)
 {
-  int ret=0;
-
-  DEBUG_CALL("tcp_fconnect");
-  DEBUG_ARG("so = %lx", (long )so);
-
-  if( (ret=so->s=socket(AF_INET,SOCK_STREAM,0)) >= 0) {
-    int opt, s=so->s;
-    struct sockaddr_in addr;
-
-    fd_nonblock(s);
-    opt = 1;
-    setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(opt ));
-    opt = 1;
-    setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(opt ));
-
-    addr.sin_family = AF_INET;
-    if ((so->so_faddr.s_addr & htonl(pData->netmask)) == special_addr.s_addr) {
-      /* It's an alias */
-      switch(ntohl(so->so_faddr.s_addr) & ~pData->netmask) {
-      case CTL_DNS:
-        if (!get_dns_addr(pData, &dns_addr))
-            addr.sin_addr = dns_addr;
+    int ret=0;
+
+    DEBUG_CALL("tcp_fconnect");
+    DEBUG_ARG("so = %lx", (long )so);
+
+    if ((ret = so->s=socket(AF_INET,SOCK_STREAM,0)) >= 0)
+    {
+        int opt, s=so->s;
+        struct sockaddr_in addr;
+
+        fd_nonblock(s);
+        opt = 1;
+        setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt, sizeof(opt));
+        opt = 1;
+        setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt, sizeof(opt));
+
+        addr.sin_family = AF_INET;
+        if ((so->so_faddr.s_addr & htonl(pData->netmask)) == special_addr.s_addr)
+        {
+            /* It's an alias */
+            switch(ntohl(so->so_faddr.s_addr) & ~pData->netmask)
+            {
+                case CTL_DNS:
+                    if (!get_dns_addr(pData, &dns_addr))
+                        addr.sin_addr = dns_addr;
+                    else
+                        addr.sin_addr = loopback_addr;
+                    break;
+                case CTL_ALIAS:
+                default:
+                    addr.sin_addr = loopback_addr;
+                    break;
+            }
+        }
         else
-            addr.sin_addr = loopback_addr;
-        break;
-      case CTL_ALIAS:
-      default:
-        addr.sin_addr = loopback_addr;
-        break;
-      }
-    } else
-      addr.sin_addr = so->so_faddr;
-    addr.sin_port = so->so_fport;
-
-    DEBUG_MISC((dfd, " connect()ing, addr.sin_port=%d, "
-                "addr.sin_addr.s_addr=%.16s\n",
-                ntohs(addr.sin_port), inet_ntoa(addr.sin_addr)));
-    /* We don't care what port we get */
-    ret = connect(s,(struct sockaddr *)&addr,sizeof (addr));
-
-    /*
-     * If it's not in progress, it failed, so we just return 0,
-     * without clearing SS_NOFDREF
-     */
-    soisfconnecting(so);
-  }
-
-  return(ret);
+            addr.sin_addr = so->so_faddr;
+        addr.sin_port = so->so_fport;
+
+        DEBUG_MISC((dfd, " connect()ing, addr.sin_port=%d, "
+                         "addr.sin_addr.s_addr=%.16s\n",
+                         ntohs(addr.sin_port), inet_ntoa(addr.sin_addr)));
+        /* We don't care what port we get */
+        ret = connect(s,(struct sockaddr *)&addr,sizeof (addr));
+
+        /*
+         * If it's not in progress, it failed, so we just return 0,
+         * without clearing SS_NOFDREF
+         */
+        soisfconnecting(so);
+    }
+
+    return(ret);
 }
 
@@ -467 +478 @@
 tcp_connect(PNATState pData, struct socket *inso)
 {
-        struct socket *so;
-        struct sockaddr_in addr;
-        socklen_t addrlen = sizeof(struct sockaddr_in);
-        struct tcpcb *tp;
-        int s, opt;
-
-        DEBUG_CALL("tcp_connect");
-        DEBUG_ARG("inso = %lx", (long)inso);
-
-        /*
-         * If it's an SS_ACCEPTONCE socket, no need to socreate()
-         * another socket, just use the accept() socket.
-         */
-        if (inso->so_state & SS_FACCEPTONCE) {
-                /* FACCEPTONCE already have a tcpcb */
-                so = inso;
-        } else {
-                if ((so = socreate()) == NULL) {
-                        /* If it failed, get rid of the pending connection */
-                        closesocket(accept(inso->s,(struct sockaddr *)&addr,&addrlen));
-                        return;
-                }
-                if (tcp_attach(pData, so) < 0) {
-                        free(so); /* NOT sofree */
-                        return;
-                }
-                so->so_laddr = inso->so_laddr;
-                so->so_lport = inso->so_lport;
+    struct socket *so;
+    struct sockaddr_in addr;
+    socklen_t addrlen = sizeof(struct sockaddr_in);
+    struct tcpcb *tp;
+    int s, opt;
+
+    DEBUG_CALL("tcp_connect");
+    DEBUG_ARG("inso = %lx", (long)inso);
+
+    /*
+     * If it's an SS_ACCEPTONCE socket, no need to socreate()
+     * another socket, just use the accept() socket.
+     */
+    if (inso->so_state & SS_FACCEPTONCE)
+    {
+        /* FACCEPTONCE already have a tcpcb */
+        so = inso;
+    }
+    else
+    {
+        if ((so = socreate()) == NULL)
+        {
+            /* If it failed, get rid of the pending connection */
+            closesocket(accept(inso->s,(struct sockaddr *)&addr,&addrlen));
+            return;
         }
-
-        (void) tcp_mss(pData, sototcpcb(so), 0);
-
-        if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0) {
-                tcp_close(pData, sototcpcb(so)); /* This will sofree() as well */
-                return;
+        if (tcp_attach(pData, so) < 0)
+        {
+            free(so); /* NOT sofree */
+            return;
         }
-        fd_nonblock(s);
-        opt = 1;
-        setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
-        opt = 1;
-        setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
-        opt = 1;
-        setsockopt(s,IPPROTO_TCP,TCP_NODELAY,(char *)&opt,sizeof(int));
-
-        so->so_fport = addr.sin_port;
-        so->so_faddr = addr.sin_addr;
-        /* Translate connections from localhost to the real hostname */
-        if (so->so_faddr.s_addr == 0 || so->so_faddr.s_addr == loopback_addr.s_addr)
-           so->so_faddr = alias_addr;
-
-        /* Close the accept() socket, set right state */
-        if (inso->so_state & SS_FACCEPTONCE) {
-                closesocket(so->s); /* If we only accept once, close the accept() socket */
-                so->so_state = SS_NOFDREF; /* Don't select it yet, even though we have an FD */
-                                           /* if it's not FACCEPTONCE, it's already NOFDREF */
-        }
-        so->s = s;
-
-        so->so_iptos = tcp_tos(so);
-        tp = sototcpcb(so);
-
-        tcp_template(tp);
-
-        /* Compute window scaling to request.  */
-/*      while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
- *              (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
- *              tp->request_r_scale++;
- */
-
-/*      soisconnecting(so); */ /* NOFDREF used instead */
-        tcpstat.tcps_connattempt++;
-
-        tp->t_state = TCPS_SYN_SENT;
-        tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
-        tp->iss = tcp_iss;
-        tcp_iss += TCP_ISSINCR/2;
-        tcp_sendseqinit(tp);
-        tcp_output(pData, tp);
+        so->so_laddr = inso->so_laddr;
+        so->so_lport = inso->so_lport;
+    }
+
+    (void) tcp_mss(pData, sototcpcb(so), 0);
+
+    if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0)
+    {
+        tcp_close(pData, sototcpcb(so)); /* This will sofree() as well */
+        return;
+    }
+    fd_nonblock(s);
+    opt = 1;
+    setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
+    opt = 1;
+    setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
+    opt = 1;
+    setsockopt(s,IPPROTO_TCP,TCP_NODELAY,(char *)&opt,sizeof(int));
+
+    so->so_fport = addr.sin_port;
+    so->so_faddr = addr.sin_addr;
+    /* Translate connections from localhost to the real hostname */
+    if (so->so_faddr.s_addr == 0 || so->so_faddr.s_addr == loopback_addr.s_addr)
+        so->so_faddr = alias_addr;
+
+    /* Close the accept() socket, set right state */
+    if (inso->so_state & SS_FACCEPTONCE)
+    {
+        closesocket(so->s);        /* If we only accept once, close the accept() socket */
+        so->so_state = SS_NOFDREF; /* Don't select it yet, even though we have an FD */
+                                   /* if it's not FACCEPTONCE, it's already NOFDREF */
+    }
+    so->s = s;
+
+    so->so_iptos = tcp_tos(so);
+    tp = sototcpcb(so);
+
+    tcp_template(tp);
+
+    /* Compute window scaling to request.  */
+/*  while (tp->request_r_scale < TCP_MAX_WINSHIFT
+ *         && (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
+ *      tp->request_r_scale++;
+ */
+
+/*  soisconnecting(so); */ /* NOFDREF used instead */
+    tcpstat.tcps_connattempt++;
+
+    tp->t_state = TCPS_SYN_SENT;
+    tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
+    tp->iss = tcp_iss;
+    tcp_iss += TCP_ISSINCR/2;
+    tcp_sendseqinit(tp);
+    tcp_output(pData, tp);
 }
 
@@ -553 +571 @@
 tcp_attach(PNATState pData, struct socket *so)
 {
-        if ((so->so_tcpcb = tcp_newtcpcb(pData, so)) == NULL)
-           return -1;
-
-        insque(pData, so, &tcb);
-
-        return 0;
+    if ((so->so_tcpcb = tcp_newtcpcb(pData, so)) == NULL)
+        return -1;
+
+    insque(pData, so, &tcb);
+    return 0;
 }
 
@@ -564 +581 @@
  * Set the socket's type of service field
  */
-static const struct tos_t tcptos[] = {
-          {0, 20, IPTOS_THROUGHPUT, 0}, /* ftp data */
-          {21, 21, IPTOS_LOWDELAY,  EMU_FTP},   /* ftp control */
-          {0, 23, IPTOS_LOWDELAY, 0},   /* telnet */
-          {0, 80, IPTOS_THROUGHPUT, 0}, /* WWW */
-          {0, 513, IPTOS_LOWDELAY, EMU_RLOGIN|EMU_NOCONNECT},   /* rlogin */
-          {0, 514, IPTOS_LOWDELAY, EMU_RSH|EMU_NOCONNECT},      /* shell */
-          {0, 544, IPTOS_LOWDELAY, EMU_KSH},            /* kshell */
-          {0, 543, IPTOS_LOWDELAY, 0},  /* klogin */
-          {0, 6667, IPTOS_THROUGHPUT, EMU_IRC}, /* IRC */
-          {0, 6668, IPTOS_THROUGHPUT, EMU_IRC}, /* IRC undernet */
-          {0, 7070, IPTOS_LOWDELAY, EMU_REALAUDIO }, /* RealAudio control */
-          {0, 113, IPTOS_LOWDELAY, EMU_IDENT }, /* identd protocol */
-          {0, 0, 0, 0}
+static const struct tos_t tcptos[] =
+{
+    {0, 20, IPTOS_THROUGHPUT, 0},                       /* ftp data */
+    {21, 21, IPTOS_LOWDELAY,  EMU_FTP},                 /* ftp control */
+    {0, 23, IPTOS_LOWDELAY, 0},                         /* telnet */
+    {0, 80, IPTOS_THROUGHPUT, 0},                       /* WWW */
+    {0, 513, IPTOS_LOWDELAY, EMU_RLOGIN|EMU_NOCONNECT}, /* rlogin */
+    {0, 514, IPTOS_LOWDELAY, EMU_RSH|EMU_NOCONNECT},    /* shell */
+    {0, 544, IPTOS_LOWDELAY, EMU_KSH},                  /* kshell */
+    {0, 543, IPTOS_LOWDELAY, 0},                        /* klogin */
+    {0, 6667, IPTOS_THROUGHPUT, EMU_IRC},               /* IRC */
+    {0, 6668, IPTOS_THROUGHPUT, EMU_IRC},               /* IRC undernet */
+    {0, 7070, IPTOS_LOWDELAY, EMU_REALAUDIO },          /* RealAudio control */
+    {0, 113, IPTOS_LOWDELAY, EMU_IDENT },               /* identd protocol */
+    {0, 0, 0, 0}
 };
 
@@ -584 +602 @@
  */
 u_int8_t
-tcp_tos(so)
-        struct socket *so;
-{
-        int i = 0;
-
-        while(tcptos[i].tos) {
-                if ((tcptos[i].fport && (ntohs(so->so_fport) == tcptos[i].fport)) ||
-                    (tcptos[i].lport && (ntohs(so->so_lport) == tcptos[i].lport))) {
-                        so->so_emu = tcptos[i].emu;
-                        return tcptos[i].tos;
-                }
-                i++;
+tcp_tos(struct socket *so)
+{
+    int i = 0;
+
+    while(tcptos[i].tos)
+    {
+        if (   (tcptos[i].fport && (ntohs(so->so_fport) == tcptos[i].fport))
+            || (tcptos[i].lport && (ntohs(so->so_lport) == tcptos[i].lport)))
+        {
+            so->so_emu = tcptos[i].emu;
+            return tcptos[i].tos;
         }
-
-        return 0;
-}
-
-/*
- * Emulate programs that try and connect to us
- * This includes ftp (the data connection is
- * initiated by the server) and IRC (DCC CHAT and
- * DCC SEND) for now
+        i++;
+    }
+
+    return 0;
+}
+
+/*
+ * Emulate programs that try and connect to us. This includes ftp (the data
+ * connection is initiated by the server) and IRC (DCC CHAT and DCC SEND)
+ * for now
  *
- * NOTE: It's possible to crash SLiRP by sending it
- * unstandard strings to emulate... if this is a problem,
- * more checks are needed here
+ * NOTE: It's possible to crash SLiRP by sending it unstandard strings to
+ * emulate... if this is a problem, more checks are needed here.
  *
- * XXX Assumes the whole command came in one packet
+ * XXX Assumes the whole command cames in one packet
  *
- * XXX Some ftp clients will have their TOS set to
- * LOWDELAY and so Nagel will kick in.  Because of this,
- * we'll get the first letter, followed by the rest, so
- * we simply scan for ORT instead of PORT...
- * DCC doesn't have this problem because there's other stuff
- * in the packet before the DCC command.
+ * XXX Some ftp clients will have their TOS set to LOWDELAY and so Nagel will
+ * kick in.  Because of this, we'll get the first letter, followed by the
+ * rest, so we simply scan for ORT instead of PORT... DCC doesn't have this
+ * problem because there's other stuff in the packet before the DCC command.
  *
- * Return 1 if the mbuf m is still valid and should be
- * sbappend()ed
+ * Return 1 if the mbuf m is still valid and should be sbappend()ed
  *
  * NOTE: if you return 0 you MUST m_free() the mbuf!
@@ -628 +642 @@
 tcp_emu(PNATState pData, struct socket *so, struct mbuf *m)
 {
-        u_int n1, n2, n3, n4, n5, n6;
-        char buff[256];
-        u_int32_t laddr;
-        u_int lport;
-        char *bptr;
-
-        DEBUG_CALL("tcp_emu");
-        DEBUG_ARG("so = %lx", (long)so);
-        DEBUG_ARG("m = %lx", (long)m);
-
-        switch(so->so_emu) {
-                int x, i;
-
-         case EMU_IDENT:
+    u_int n1, n2, n3, n4, n5, n6;
+    char buff[256];
+    u_int32_t laddr;
+    u_int lport;
+    char *bptr;
+
+    DEBUG_CALL("tcp_emu");
+    DEBUG_ARG("so = %lx", (long)so);
+    DEBUG_ARG("m = %lx", (long)m);
+
+    switch(so->so_emu)
+    {
+        int x, i;
+
+        case EMU_IDENT:
+        /*
+         * Identification protocol as per rfc-1413
+         */
+        {
+            struct socket *tmpso;
+            struct sockaddr_in addr;
+            socklen_t addrlen = sizeof(struct sockaddr_in);
+            struct sbuf *so_rcv = &so->so_rcv;
+
+            memcpy(so_rcv->sb_wptr, m->m_data, m->m_len);
+            so_rcv->sb_wptr += m->m_len;
+            so_rcv->sb_rptr += m->m_len;
+            m->m_data[m->m_len] = 0; /* NULL terminate */
+            if (strchr(m->m_data, '\r') || strchr(m->m_data, '\n'))
+            {
+                if (sscanf(so_rcv->sb_data, "%u%*[ ,]%u", &n1, &n2) == 2)
+                {
+                    HTONS(n1);
+                    HTONS(n2);
+                    /* n2 is the one on our host */
+                    for (tmpso = tcb.so_next; tmpso != &tcb; tmpso = tmpso->so_next)
+                    {
+                        if (   tmpso->so_laddr.s_addr == so->so_laddr.s_addr
+                            && tmpso->so_lport == n2
+                            && tmpso->so_faddr.s_addr == so->so_faddr.s_addr
+                            && tmpso->so_fport == n1)
+                        {
+                            if (getsockname(tmpso->s,
+                                            (struct sockaddr *)&addr, &addrlen) == 0)
+                                n2 = ntohs(addr.sin_port);
+                            break;
+                        }
+                    }
+                }
+                so_rcv->sb_cc = sprintf(so_rcv->sb_data, "%d,%d\r\n", n1, n2);
+                so_rcv->sb_rptr = so_rcv->sb_data;
+                so_rcv->sb_wptr = so_rcv->sb_data + so_rcv->sb_cc;
+            }
+            m_free(pData, m);
+            return 0;
+        }
+
+        case EMU_FTP:
+            *(m->m_data+m->m_len) = 0; /* NULL terminate for strstr */
+            if ((bptr = (char *)strstr(m->m_data, "ORT")) != NULL)
+            {
                 /*
-                 * Identification protocol as per rfc-1413
+                 * Need to emulate the PORT command
                  */
-
+                x = sscanf(bptr, "ORT %u,%u,%u,%u,%u,%u\r\n%256[^\177]",
+                           &n1, &n2, &n3, &n4, &n5, &n6, buff);
+                if (x < 6)
+                    return 1;
+
+                laddr = htonl((n1 << 24) | (n2 << 16) | (n3 << 8) | (n4));
+                lport = htons((n5 << 8) | (n6));
+
+                if ((so = solisten(pData, 0, laddr, lport, SS_FACCEPTONCE)) == NULL)
+                    return 1;
+
+                n6 = ntohs(so->so_fport);
+
+                n5 = (n6 >> 8) & 0xff;
+                n6 &= 0xff;
+
+                laddr = ntohl(so->so_faddr.s_addr);
+
+                n1 = ((laddr >> 24) & 0xff);
+                n2 = ((laddr >> 16) & 0xff);
+                n3 = ((laddr >> 8)  & 0xff);
+                n4 = ( laddr        & 0xff);
+
+                m->m_len = bptr - m->m_data; /* Adjust length */
+                m->m_len += sprintf(bptr, "ORT %d,%d,%d,%d,%d,%d\r\n%s",
+                                    n1, n2, n3, n4, n5, n6, x==7?buff:"");
+                return 1;
+            }
+            else if ((bptr = (char *)strstr(m->m_data, "27 Entering")) != NULL)
+            {
+                /*
+                 * Need to emulate the PASV response
+                 */
+                x = sscanf(bptr, "27 Entering Passive Mode (%u,%u,%u,%u,%u,%u)\r\n%256[^\177]",
+                           &n1, &n2, &n3, &n4, &n5, &n6, buff);
+                if (x < 6)
+                    return 1;
+
+                laddr = htonl((n1 << 24) | (n2 << 16) | (n3 << 8) | (n4));
+                lport = htons((n5 << 8) | (n6));
+
+                if ((so = solisten(pData, 0, laddr, lport, SS_FACCEPTONCE)) == NULL)
+                    return 1;
+
+                n6 = ntohs(so->so_fport);
+
+                n5 = (n6 >> 8) & 0xff;
+                n6 &= 0xff;
+
+                laddr = ntohl(so->so_faddr.s_addr);
+
+                n1 = ((laddr >> 24) & 0xff);
+                n2 = ((laddr >> 16) & 0xff);
+                n3 = ((laddr >> 8)  & 0xff);
+                n4 =  (laddr & 0xff);
+
+                m->m_len = bptr - m->m_data; /* Adjust length */
+                m->m_len += sprintf(bptr, "27 Entering Passive Mode (%d,%d,%d,%d,%d,%d)\r\n%s",
+                                    n1, n2, n3, n4, n5, n6, x==7?buff:"");
+
+                return 1;
+            }
+            return 1;
+
+        case EMU_KSH:
+            /*
+             * The kshell (Kerberos rsh) and shell services both pass
+             * a local port port number to carry signals to the server
+             * and stderr to the client.  It is passed at the beginning
+             * of the connection as a NUL-terminated decimal ASCII string.
+             */
+            so->so_emu = 0;
+            for (lport = 0, i = 0; i < m->m_len-1; ++i)
+            {
+                if (m->m_data[i] < '0' || m->m_data[i] > '9')
+                    return 1;       /* invalid number */
+                lport *= 10;
+                lport += m->m_data[i] - '0';
+            }
+            if (   m->m_data[m->m_len-1] == '\0'
+                && lport != 0
+                && (so = solisten(pData, 0, so->so_laddr.s_addr, 
+                                  htons(lport), SS_FACCEPTONCE)) != NULL)
+                m->m_len = sprintf(m->m_data, "%d", ntohs(so->so_fport))+1;
+            return 1;
+
+        case EMU_IRC:
+            /*
+             * Need to emulate DCC CHAT, DCC SEND and DCC MOVE
+             */
+            *(m->m_data+m->m_len) = 0; /* NULL terminate the string for strstr */
+            if ((bptr = (char *)strstr(m->m_data, "DCC")) == NULL)
+                return 1;
+
+            /* The %256s is for the broken mIRC */
+            if (sscanf(bptr, "DCC CHAT %256s %u %u", buff, &laddr, &lport) == 3)
+            {
+                if ((so = solisten(pData, 0, htonl(laddr), 
+                                   htons(lport), SS_FACCEPTONCE)) == NULL)
+                    return 1;
+
+                m->m_len = bptr - m->m_data; /* Adjust length */
+                m->m_len += sprintf(bptr, "DCC CHAT chat %lu %u%c\n",
+                                    (unsigned long)ntohl(so->so_faddr.s_addr),
+                                    ntohs(so->so_fport), 1);
+            }
+            else if (sscanf(bptr, "DCC SEND %256s %u %u %u", buff, &laddr, &lport, &n1) == 4)
+            {
+                if ((so = solisten(pData, 0, htonl(laddr), htons(lport), SS_FACCEPTONCE)) == NULL)
+                    return 1;
+
+                m->m_len = bptr - m->m_data; /* Adjust length */
+                m->m_len += sprintf(bptr, "DCC SEND %s %lu %u %u%c\n",
+                                    buff, (unsigned long)ntohl(so->so_faddr.s_addr),
+                                    ntohs(so->so_fport), n1, 1);
+            }
+            else if (sscanf(bptr, "DCC MOVE %256s %u %u %u", buff, &laddr, &lport, &n1) == 4)
+            {
+                if ((so = solisten(pData, 0, htonl(laddr), htons(lport), SS_FACCEPTONCE)) == NULL)
+                    return 1;
+
+                m->m_len = bptr - m->m_data; /* Adjust length */
+                m->m_len += sprintf(bptr, "DCC MOVE %s %lu %u %u%c\n",
+                                    buff, (unsigned long)ntohl(so->so_faddr.s_addr),
+                                    ntohs(so->so_fport), n1, 1);
+            }
+            return 1;
+
+#ifdef VBOX
+            /** @todo Disabled EMU_REALAUDIO, because it uses a static variable.
+             * This is not legal when more than one slirp instance is active. */
+#else /* !VBOX */
+        case EMU_REALAUDIO:
+            /*
+             * RealAudio emulation - JP. We must try to parse the incoming
+             * data and try to find the two characters that contain the
+             * port number. Then we redirect an udp port and replace the
+             * number with the real port we got.
+             *
+             * The 1.0 beta versions of the player are not supported
+             * any more.
+             *
+             * A typical packet for player version 1.0 (release version):
+             *
+             * 0000:50 4E 41 00 05
+             * 0000:00 01 00 02 1B D7 00 00 67 E6 6C DC 63 00 12 50 .....×..gælÜc..P
+             * 0010:4E 43 4C 49 45 4E 54 20 31 30 31 20 41 4C 50 48 NCLIENT 101 ALPH
+             * 0020:41 6C 00 00 52 00 17 72 61 66 69 6C 65 73 2F 76 Al..R..rafiles/v
+             * 0030:6F 61 2F 65 6E 67 6C 69 73 68 5F 2E 72 61 79 42 oa/english_.rayB
+             *
+             * Now the port number 0x1BD7 is found at offset 0x04 of the
+             * Now the port number 0x1BD7 is found at offset 0x04 of the
+             * second packet. This time we received five bytes first and
+             * then the rest. You never know how many bytes you get.
+             *
+             * A typical packet for player version 2.0 (beta):
+             *
+             * 0000:50 4E 41 00 06 00 02 00 00 00 01 00 02 1B C1 00 PNA...........Á.
+             * 0010:00 67 75 78 F5 63 00 0A 57 69 6E 32 2E 30 2E 30 .guxõc..Win2.0.0
+             * 0020:2E 35 6C 00 00 52 00 1C 72 61 66 69 6C 65 73 2F .5l..R..rafiles/
+             * 0030:77 65 62 73 69 74 65 2F 32 30 72 65 6C 65 61 73 website/20releas
+             * 0040:65 2E 72 61 79 53 00 00 06 36 42                e.rayS...6B
+             *
+             * Port number 0x1BC1 is found at offset 0x0d.
+             *
+             * This is just a horrible switch statement. Variable ra tells
+             * us where we're going.
+             */
+
+            bptr = m->m_data;
+            while (bptr < m->m_data + m->m_len)
+            {
+                u_short p;
+                static int ra = 0;
+                char ra_tbl[4];
+
+                ra_tbl[0] = 0x50;
+                ra_tbl[1] = 0x4e;
+                ra_tbl[2] = 0x41;
+                ra_tbl[3] = 0;
+
+                switch (ra)
                 {
-                        struct socket *tmpso;
-                        struct sockaddr_in addr;
-                        socklen_t addrlen = sizeof(struct sockaddr_in);
-                        struct sbuf *so_rcv = &so->so_rcv;
-
-                        memcpy(so_rcv->sb_wptr, m->m_data, m->m_len);
-                        so_rcv->sb_wptr += m->m_len;
-                        so_rcv->sb_rptr += m->m_len;
-                        m->m_data[m->m_len] = 0; /* NULL terminate */
-                        if (strchr(m->m_data, '\r') || strchr(m->m_data, '\n')) {
-                                if (sscanf(so_rcv->sb_data, "%u%*[ ,]%u", &n1, &n2) == 2) {
-                                        HTONS(n1);
-                                        HTONS(n2);
-                                        /* n2 is the one on our host */
-                                        for (tmpso = tcb.so_next; tmpso != &tcb; tmpso = tmpso->so_next) {
-                                                if (tmpso->so_laddr.s_addr == so->so_laddr.s_addr &&
-                                                    tmpso->so_lport == n2 &&
-                                                    tmpso->so_faddr.s_addr == so->so_faddr.s_addr &&
-                                                    tmpso->so_fport == n1) {
-                                                        if (getsockname(tmpso->s,
-                                                                (struct sockaddr *)&addr, &addrlen) == 0)
-                                                           n2 = ntohs(addr.sin_port);
-                                                        break;
-                                                }
-                                        }
-                                }
-                                so_rcv->sb_cc = sprintf(so_rcv->sb_data, "%d,%d\r\n", n1, n2);
-                                so_rcv->sb_rptr = so_rcv->sb_data;
-                                so_rcv->sb_wptr = so_rcv->sb_data + so_rcv->sb_cc;
+                    case 0:
+                    case 2:
+                    case 3:
+                        if (*bptr++ != ra_tbl[ra])
+                        {
+                            ra = 0;
+                            continue;
                         }
-                        m_free(pData, m);
-                        return 0;
+                        break;
+
+                    case 1:
+                        /*
+                         * We may get 0x50 several times, ignore them
+                         */
+                        if (*bptr == 0x50)
+                        {
+                            ra = 1;
+                            bptr++;
+                            continue;
+                        }
+                        else if (*bptr++ != ra_tbl[ra])
+                        {
+                            ra = 0;
+                            continue;
+                        }
+                        break;
+
+                    case 4:
+                        /*
+                         * skip version number
+                         */
+                        bptr++;
+                        break;
+
+                    case 5:
+                        /*
+                         * The difference between versions 1.0 and
+                         * 2.0 is here. For future versions of
+                         * the player this may need to be modified.
+                         */
+                        if (*(bptr + 1) == 0x02)
+                            bptr += 8;
+                        else
+                            bptr += 4;
+                        break;
+
+                    case 6:
+                        /* This is the field containing the port
+                         * number that RA-player is listening to.
+                         */
+                        lport = (((u_char*)bptr)[0] << 8)
+                              + ((u_char *)bptr)[1];
+                        if (lport < 6970)
+                            lport += 256;   /* don't know why */
+                        if (lport < 6970 || lport > 7170)
+                            return 1;       /* failed */
+
+                        /* try to get udp port between 6970 - 7170 */
+                        for (p = 6970; p < 7071; p++)
+                        {
+                            if (udp_listen(htons(p),
+                                           so->so_laddr.s_addr,
+                                           htons(lport),
+                                           SS_FACCEPTONCE))
+                            {
+                                break;
+                            }
+                        }
+                        if (p == 7071)
+                            p = 0;
+                        *(u_char *)bptr++ = (p >> 8) & 0xff;
+                        *(u_char *)bptr++ = p & 0xff;
+                        ra = 0;
+                        return 1;   /* port redirected, we're done */
+                        break;
+
+                    default:
+                        ra = 0;
                 }
-
-        case EMU_FTP: /* ftp */
-                *(m->m_data+m->m_len) = 0; /* NULL terminate for strstr */
-                if ((bptr = (char *)strstr(m->m_data, "ORT")) != NULL) {
-                        /*
-                         * Need to emulate the PORT command
-                         */
-                        x = sscanf(bptr, "ORT %u,%u,%u,%u,%u,%u\r\n%256[^\177]",
-                                   &n1, &n2, &n3, &n4, &n5, &n6, buff);
-                        if (x < 6)
-                           return 1;
-
-                        laddr = htonl((n1 << 24) | (n2 << 16) | (n3 << 8) | (n4));
-                        lport = htons((n5 << 8) | (n6));
-
-                        if ((so = solisten(pData, 0, laddr, lport, SS_FACCEPTONCE)) == NULL)
-                           return 1;
-
-                        n6 = ntohs(so->so_fport);
-
-                        n5 = (n6 >> 8) & 0xff;
-                        n6 &= 0xff;
-
-                        laddr = ntohl(so->so_faddr.s_addr);
-
-                        n1 = ((laddr >> 24) & 0xff);
-                        n2 = ((laddr >> 16) & 0xff);
-                        n3 = ((laddr >> 8)  & 0xff);
-                        n4 =  (laddr & 0xff);
-
-                        m->m_len = bptr - m->m_data; /* Adjust length */
-                        m->m_len += sprintf(bptr,"ORT %d,%d,%d,%d,%d,%d\r\n%s",
-                                            n1, n2, n3, n4, n5, n6, x==7?buff:"");
-                        return 1;
-                } else if ((bptr = (char *)strstr(m->m_data, "27 Entering")) != NULL) {
-                        /*
-                         * Need to emulate the PASV response
-                         */
-                        x = sscanf(bptr, "27 Entering Passive Mode (%u,%u,%u,%u,%u,%u)\r\n%256[^\177]",
-                                   &n1, &n2, &n3, &n4, &n5, &n6, buff);
-                        if (x < 6)
-                           return 1;
-
-                        laddr = htonl((n1 << 24) | (n2 << 16) | (n3 << 8) | (n4));
-                        lport = htons((n5 << 8) | (n6));
-
-                        if ((so = solisten(pData, 0, laddr, lport, SS_FACCEPTONCE)) == NULL)
-                           return 1;
-
-                        n6 = ntohs(so->so_fport);
-
-                        n5 = (n6 >> 8) & 0xff;
-                        n6 &= 0xff;
-
-                        laddr = ntohl(so->so_faddr.s_addr);
-
-                        n1 = ((laddr >> 24) & 0xff);
-                        n2 = ((laddr >> 16) & 0xff);
-                        n3 = ((laddr >> 8)  & 0xff);
-                        n4 =  (laddr & 0xff);
-
-                        m->m_len = bptr - m->m_data; /* Adjust length */
-                        m->m_len += sprintf(bptr,"27 Entering Passive Mode (%d,%d,%d,%d,%d,%d)\r\n%s",
-                                            n1, n2, n3, n4, n5, n6, x==7?buff:"");
-
-                        return 1;
-                }
-
-                return 1;
-
-         case EMU_KSH:
-                /*
-                 * The kshell (Kerberos rsh) and shell services both pass
-                 * a local port port number to carry signals to the server
-                 * and stderr to the client.  It is passed at the beginning
-                 * of the connection as a NUL-terminated decimal ASCII string.
-                 */
-                so->so_emu = 0;
-                for (lport = 0, i = 0; i < m->m_len-1; ++i) {
-                        if (m->m_data[i] < '0' || m->m_data[i] > '9')
-                                return 1;       /* invalid number */
-                        lport *= 10;
-                        lport += m->m_data[i] - '0';
-                }
-                if (m->m_data[m->m_len-1] == '\0' && lport != 0 &&
-                    (so = solisten(pData, 0, so->so_laddr.s_addr, htons(lport), SS_FACCEPTONCE)) != NULL)
-                        m->m_len = sprintf(m->m_data, "%d", ntohs(so->so_fport))+1;
-                return 1;
-
-         case EMU_IRC:
-                /*
-                 * Need to emulate DCC CHAT, DCC SEND and DCC MOVE
-                 */
-                *(m->m_data+m->m_len) = 0; /* NULL terminate the string for strstr */
-                if ((bptr = (char *)strstr(m->m_data, "DCC")) == NULL)
-                         return 1;
-
-                /* The %256s is for the broken mIRC */
-                if (sscanf(bptr, "DCC CHAT %256s %u %u", buff, &laddr, &lport) == 3) {
-                        if ((so = solisten(pData, 0, htonl(laddr), htons(lport), SS_FACCEPTONCE)) == NULL)
-                                return 1;
-
-                        m->m_len = bptr - m->m_data; /* Adjust length */
-                        m->m_len += sprintf(bptr, "DCC CHAT chat %lu %u%c\n",
-                             (unsigned long)ntohl(so->so_faddr.s_addr),
-                             ntohs(so->so_fport), 1);
-                } else if (sscanf(bptr, "DCC SEND %256s %u %u %u", buff, &laddr, &lport, &n1) == 4) {
-                        if ((so = solisten(pData, 0, htonl(laddr), htons(lport), SS_FACCEPTONCE)) == NULL)
-                                return 1;
-
-                        m->m_len = bptr - m->m_data; /* Adjust length */
-                        m->m_len += sprintf(bptr, "DCC SEND %s %lu %u %u%c\n",
-                              buff, (unsigned long)ntohl(so->so_faddr.s_addr),
-                              ntohs(so->so_fport), n1, 1);
-                } else if (sscanf(bptr, "DCC MOVE %256s %u %u %u", buff, &laddr, &lport, &n1) == 4) {
-                        if ((so = solisten(pData, 0, htonl(laddr), htons(lport), SS_FACCEPTONCE)) == NULL)
-                                return 1;
-
-                        m->m_len = bptr - m->m_data; /* Adjust length */
-                        m->m_len += sprintf(bptr, "DCC MOVE %s %lu %u %u%c\n",
-                              buff, (unsigned long)ntohl(so->so_faddr.s_addr),
-                              ntohs(so->so_fport), n1, 1);
-                }
-                return 1;
-
-#ifdef VBOX
-         /** @todo Disabled EMU_REALAUDIO, because it uses a static variable.
-          * This is not legal when more than one slirp instance is active. */
-#else /* !VBOX */
-         case EMU_REALAUDIO:
-                /*
-                 * RealAudio emulation - JP. We must try to parse the incoming
-                 * data and try to find the two characters that contain the
-                 * port number. Then we redirect an udp port and replace the
-                 * number with the real port we got.
-                 *
-                 * The 1.0 beta versions of the player are not supported
-                 * any more.
-                 *
-                 * A typical packet for player version 1.0 (release version):
-                 *
-                 * 0000:50 4E 41 00 05
-                 * 0000:00 01 00 02 1B D7 00 00 67 E6 6C DC 63 00 12 50 .....×..gælÜc..P
-                 * 0010:4E 43 4C 49 45 4E 54 20 31 30 31 20 41 4C 50 48 NCLIENT 101 ALPH
-                 * 0020:41 6C 00 00 52 00 17 72 61 66 69 6C 65 73 2F 76 Al..R..rafiles/v
-                 * 0030:6F 61 2F 65 6E 67 6C 69 73 68 5F 2E 72 61 79 42 oa/english_.rayB
-                 *
-                 * Now the port number 0x1BD7 is found at offset 0x04 of the
-                 * Now the port number 0x1BD7 is found at offset 0x04 of the
-                 * second packet. This time we received five bytes first and
-                 * then the rest. You never know how many bytes you get.
-                 *
-                 * A typical packet for player version 2.0 (beta):
-                 *
-                 * 0000:50 4E 41 00 06 00 02 00 00 00 01 00 02 1B C1 00 PNA...........Á.
-                 * 0010:00 67 75 78 F5 63 00 0A 57 69 6E 32 2E 30 2E 30 .guxõc..Win2.0.0
-                 * 0020:2E 35 6C 00 00 52 00 1C 72 61 66 69 6C 65 73 2F .5l..R..rafiles/
-                 * 0030:77 65 62 73 69 74 65 2F 32 30 72 65 6C 65 61 73 website/20releas
-                 * 0040:65 2E 72 61 79 53 00 00 06 36 42                e.rayS...6B
-                 *
-                 * Port number 0x1BC1 is found at offset 0x0d.
-                 *
-                 * This is just a horrible switch statement. Variable ra tells
-                 * us where we're going.
-                 */
-
-                bptr = m->m_data;
-                while (bptr < m->m_data + m->m_len) {
-                        u_short p;
-                        static int ra = 0;
-                        char ra_tbl[4];
-
-                        ra_tbl[0] = 0x50;
-                        ra_tbl[1] = 0x4e;
-                        ra_tbl[2] = 0x41;
-                        ra_tbl[3] = 0;
-
-                        switch (ra) {
-                         case 0:
-                         case 2:
-                         case 3:
-                                if (*bptr++ != ra_tbl[ra]) {
-                                        ra = 0;
-                                        continue;
-                                }
-                                break;
-
-                         case 1:
-                                /*
-                                 * We may get 0x50 several times, ignore them
-                                 */
-                                if (*bptr == 0x50) {
-                                        ra = 1;
-                                        bptr++;
-                                        continue;
-                                } else if (*bptr++ != ra_tbl[ra]) {
-                                        ra = 0;
-                                        continue;
-                                }
-                                break;
-
-                         case 4:
-                                /*
-                                 * skip version number
-                                 */
-                                bptr++;
-                                break;
-
-                         case 5:
-                                /*
-                                 * The difference between versions 1.0 and
-                                 * 2.0 is here. For future versions of
-                                 * the player this may need to be modified.
-                                 */
-                                if (*(bptr + 1) == 0x02)
-                                   bptr += 8;
-                                else
-                                   bptr += 4;
-                                break;
-
-                         case 6:
-                                /* This is the field containing the port
-                                 * number that RA-player is listening to.
-                                 */
-                                lport = (((u_char*)bptr)[0] << 8)
-                                + ((u_char *)bptr)[1];
-                                if (lport < 6970)
-                                   lport += 256;   /* don't know why */
-                                if (lport < 6970 || lport > 7170)
-                                   return 1;       /* failed */
-
-                                /* try to get udp port between 6970 - 7170 */
-                                for (p = 6970; p < 7071; p++) {
-                                        if (udp_listen( htons(p),
-                                                       so->so_laddr.s_addr,
-                                                       htons(lport),
-                                                       SS_FACCEPTONCE)) {
-                                                break;
-                                        }
-                                }
-                                if (p == 7071)
-                                   p = 0;
-                                *(u_char *)bptr++ = (p >> 8) & 0xff;
-                                *(u_char *)bptr++ = p & 0xff;
-                                ra = 0;
-                                return 1;   /* port redirected, we're done */
-                                break;
-
-                         default:
-                                ra = 0;
-                        }
-                        ra++;
-                }
-                return 1;
+                ra++;
+            }
+            return 1;
 #endif /* !VBOX */
 
-         default:
-                /* Ooops, not emulated, won't call tcp_emu again */
-                so->so_emu = 0;
-                return 1;
-        }
+        default:
+            /* Ooops, not emulated, won't call tcp_emu again */
+            so->so_emu = 0;
+            return 1;
+    }
 }