Changeset 11959


Ignore:
Timestamp:
Feb 18, 2011, 12:43:56 AM (11 years ago)
Author:
jch
Message:

Resynchronise with libutp 2011-02-09 15:29:29.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/third-party/libutp/utp.cpp

    r11919 r11959  
    245245
    246246struct PacketFormatV1 {
    247         // protocol version
    248         byte version:4;
    249         // type (formerly flags)
    250         byte type:4;
     247        // packet_type (4 high bits)
     248        // protocol version (4 low bits)
     249        byte ver_type;
     250        byte version() const { return ver_type & 0xf; }
     251        byte type() const { return ver_type >> 4; }
     252        void set_version(byte v) { ver_type = (ver_type & 0xf0) | (v & 0xf); }
     253        void set_type(byte t) { ver_type = (ver_type & 0xf) | (t << 4); }
     254
    251255        // Type of the first extension header
    252256        byte ext;
     
    430434        {
    431435                // the offset should never be "negative"
    432                 assert(offset < 0x10000000);
     436                // assert(offset < 0x10000000);
    433437
    434438                // increase all of our base delays by this amount
     
    845849        }
    846850#if g_log_utp_verbose
    847         int flags = version == 0 ? b->flags : b1->type;
     851        int flags = version == 0 ? b->flags : b1->type();
    848852        uint16 seq_nr = version == 0 ? b->seq_nr : b1->seq_nr;
    849853        uint16 ack_nr = version == 0 ? b->ack_nr : b1->ack_nr;
     
    874878                len = sizeof(PacketFormat);
    875879        } else {
    876                 pfa1.pf.version = 1;
    877                 pfa1.pf.type = ST_STATE;
     880                pfa1.pf.set_version(1);
     881                pfa1.pf.set_type(ST_STATE);
    878882                pfa1.pf.ext = 0;
    879883                pfa1.pf.connid = conn_id_send;
     
    978982                len = sizeof(PacketFormat);
    979983        } else {
    980                 pf1.version = 1;
    981                 pf1.type= ST_RESET;
     984                pf1.set_version(1);
     985                pf1.set_type(ST_RESET);
    982986                pf1.ext = 0;
    983987                pf1.connid = conn_id_send;
     
    11721176                        p->flags = flags;
    11731177                } else {
    1174                         p1->version = 1;
    1175                         p1->type = flags;
     1178                        p1->set_version(1);
     1179                        p1->set_type(flags);
    11761180                        p1->ext = 0;
    11771181                        p1->connid = conn_id_send;
     
    17681772                pk_seq_nr = pf1->seq_nr;
    17691773                pk_ack_nr = pf1->ack_nr;
    1770                 pk_flags = pf1->type;
     1774                pk_flags = pf1->type();
    17711775        }
    17721776
     
    19661970        }
    19671971*/
     1972
     1973        // if the delay estimate exceeds the RTT, adjust the base_delay to
     1974        // compensate
     1975        if (conn->our_hist.get_value() > uint32(min_rtt)) {
     1976                conn->our_hist.shift(conn->our_hist.get_value() - min_rtt);
     1977        }
     1978
    19681979        // only apply the congestion controller on acks
    19691980        // if we don't have a delay measurement, there's
     
    20592070                if (conn->fast_timeout) {
    20602071                        LOG_UTPV("Fast timeout %u,%u,%u?", (uint)conn->cur_window, conn->seq_nr - conn->timeout_seq_nr, conn->timeout_seq_nr);
    2061                         if (((conn->fast_resend_seq_nr - conn->timeout_seq_nr) & ACK_NR_MASK) >= 0 ||
    2062                                 ((conn->seq_nr - conn->cur_window_packets) & ACK_NR_MASK) != conn->fast_resend_seq_nr) {
     2072                        // if the fast_resend_seq_nr is not pointing to the oldest outstanding packet, it suggests that we've already
     2073                        // resent the packet that timed out, and we should leave the fast-timeout mode.
     2074                        if (((conn->seq_nr - conn->cur_window_packets) & ACK_NR_MASK) != conn->fast_resend_seq_nr) {
    20632075                                conn->fast_timeout = false;
    20642076                        } else {
     2077                                // resend the oldest packet and increment fast_resend_seq_nr
     2078                                // to not allow another fast resend on it again
    20652079                                OutgoingPacket *pkt = (OutgoingPacket*)conn->outbuf.get(conn->seq_nr - conn->cur_window_packets);
    20662080                                if (pkt && pkt->transmissions > 0) {
     
    22642278inline bool UTP_IsV1(PacketFormatV1 const* pf)
    22652279{
    2266         return pf->version == 1 && pf->type < ST_NUM_STATES && pf->ext < 3;
     2280        return pf->version() == 1 && pf->type() < ST_NUM_STATES && pf->ext < 3;
    22672281}
    22682282
     
    24682482                memset(p->extensions, 0, 8);
    24692483        } else {
    2470                 p1->pf.version = 1;
    2471                 p1->pf.type = ST_SYN;
     2484                p1->pf.set_version(1);
     2485                p1->pf.set_type(ST_SYN);
    24722486                p1->pf.ext = 2;
    24732487                p1->pf.connid = conn->conn_id_recv;
     
    25322546        }
    25332547
    2534         const byte flags = version == 0 ? pf->flags : pf1->type;
     2548        const byte flags = version == 0 ? pf->flags : pf1->type();
    25352549
    25362550        for (size_t i = 0; i < g_utp_sockets.GetCount(); i++) {
Note: See TracChangeset for help on using the changeset viewer.