Note: We no longer publish the latest version of our code here. We primarily use a kumc-bmi github organization. The heron ETL repository, in particular, is not public. Peers in the informatics community should see MultiSiteDev for details on requesting access.

source: webrtc/talk/p2p/base/pseudotcp.cc @ 0:4bda6873e34c

pub_scrub_3792 tip
Last change on this file since 0:4bda6873e34c was 0:4bda6873e34c, checked in by Michael Prittie <mprittie@…>, 6 years ago

Scrubbed password for publication.

File size: 37.3 KB
Line 
1/*
2 * libjingle
3 * Copyright 2004--2005, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 *  1. Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 *  2. Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 *  3. The name of the author may not be used to endorse or promote products
14 *     derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include "talk/p2p/base/pseudotcp.h"
29
30#include <cstdio>
31#include <cstdlib>
32#include <set>
33
34#include "talk/base/basictypes.h"
35#include "talk/base/bytebuffer.h"
36#include "talk/base/byteorder.h"
37#include "talk/base/common.h"
38#include "talk/base/logging.h"
39#include "talk/base/scoped_ptr.h"
40#include "talk/base/socket.h"
41#include "talk/base/stringutils.h"
42#include "talk/base/timeutils.h"
43
44// The following logging is for detailed (packet-level) analysis only.
45#define _DBG_NONE     0
46#define _DBG_NORMAL   1
47#define _DBG_VERBOSE  2
48#define _DEBUGMSG _DBG_NONE
49
50namespace cricket {
51
52//////////////////////////////////////////////////////////////////////
53// Network Constants
54//////////////////////////////////////////////////////////////////////
55
56// Standard MTUs
57const uint16 PACKET_MAXIMUMS[] = {
58  65535,    // Theoretical maximum, Hyperchannel
59  32000,    // Nothing
60  17914,    // 16Mb IBM Token Ring
61  8166,   // IEEE 802.4
62  //4464,   // IEEE 802.5 (4Mb max)
63  4352,   // FDDI
64  //2048,   // Wideband Network
65  2002,   // IEEE 802.5 (4Mb recommended)
66  //1536,   // Expermental Ethernet Networks
67  //1500,   // Ethernet, Point-to-Point (default)
68  1492,   // IEEE 802.3
69  1006,   // SLIP, ARPANET
70  //576,    // X.25 Networks
71  //544,    // DEC IP Portal
72  //512,    // NETBIOS
73  508,    // IEEE 802/Source-Rt Bridge, ARCNET
74  296,    // Point-to-Point (low delay)
75  //68,     // Official minimum
76  0,      // End of list marker
77};
78
79const uint32 MAX_PACKET = 65535;
80// Note: we removed lowest level because packet overhead was larger!
81const uint32 MIN_PACKET = 296;
82
83const uint32 IP_HEADER_SIZE = 20; // (+ up to 40 bytes of options?)
84const uint32 ICMP_HEADER_SIZE = 8;
85const uint32 UDP_HEADER_SIZE = 8;
86// TODO: Make JINGLE_HEADER_SIZE transparent to this code?
87const uint32 JINGLE_HEADER_SIZE = 64; // when relay framing is in use
88
89// Default size for receive and send buffer.
90const uint32 DEFAULT_RCV_BUF_SIZE = 60 * 1024;
91const uint32 DEFAULT_SND_BUF_SIZE = 90 * 1024;
92
93//////////////////////////////////////////////////////////////////////
94// Global Constants and Functions
95//////////////////////////////////////////////////////////////////////
96//
97//    0                   1                   2                   3
98//    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
99//    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
100//  0 |                      Conversation Number                      |
101//    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
102//  4 |                        Sequence Number                        |
103//    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
104//  8 |                     Acknowledgment Number                     |
105//    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
106//    |               |   |U|A|P|R|S|F|                               |
107// 12 |    Control    |   |R|C|S|S|Y|I|            Window             |
108//    |               |   |G|K|H|T|N|N|                               |
109//    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
110// 16 |                       Timestamp sending                       |
111//    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
112// 20 |                      Timestamp receiving                      |
113//    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
114// 24 |                             data                              |
115//    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
116//
117//////////////////////////////////////////////////////////////////////
118
119#define PSEUDO_KEEPALIVE 0
120
121const uint32 MAX_SEQ = 0xFFFFFFFF;
122const uint32 HEADER_SIZE = 24;
123const uint32 PACKET_OVERHEAD = HEADER_SIZE + UDP_HEADER_SIZE + IP_HEADER_SIZE + JINGLE_HEADER_SIZE;
124
125const uint32 MIN_RTO   =   250; // 250 ms (RFC1122, Sec 4.2.3.1 "fractions of a second")
126const uint32 DEF_RTO   =  3000; // 3 seconds (RFC1122, Sec 4.2.3.1)
127const uint32 MAX_RTO   = 60000; // 60 seconds
128const uint32 DEF_ACK_DELAY = 100; // 100 milliseconds
129
130const uint8 FLAG_CTL = 0x02;
131const uint8 FLAG_RST = 0x04;
132
133const uint8 CTL_CONNECT = 0;
134//const uint8 CTL_REDIRECT = 1;
135const uint8 CTL_EXTRA = 255;
136
137// TCP options.
138const uint8 TCP_OPT_EOL = 0;  // End of list.
139const uint8 TCP_OPT_NOOP = 1;  // No-op.
140const uint8 TCP_OPT_MSS = 2;  // Maximum segment size.
141const uint8 TCP_OPT_WND_SCALE = 3;  // Window scale factor.
142
143/*
144const uint8 FLAG_FIN = 0x01;
145const uint8 FLAG_SYN = 0x02;
146const uint8 FLAG_ACK = 0x10;
147*/
148
149const uint32 CTRL_BOUND = 0x80000000;
150
151const long DEFAULT_TIMEOUT = 4000; // If there are no pending clocks, wake up every 4 seconds
152const long CLOSED_TIMEOUT = 60 * 1000; // If the connection is closed, once per minute
153
154#if PSEUDO_KEEPALIVE
155// !?! Rethink these times
156const uint32 IDLE_PING = 20 * 1000; // 20 seconds (note: WinXP SP2 firewall udp timeout is 90 seconds)
157const uint32 IDLE_TIMEOUT = 90 * 1000; // 90 seconds;
158#endif // PSEUDO_KEEPALIVE
159
160//////////////////////////////////////////////////////////////////////
161// Helper Functions
162//////////////////////////////////////////////////////////////////////
163
164inline void long_to_bytes(uint32 val, void* buf) {
165  *static_cast<uint32*>(buf) = talk_base::HostToNetwork32(val);
166}
167
168inline void short_to_bytes(uint16 val, void* buf) {
169  *static_cast<uint16*>(buf) = talk_base::HostToNetwork16(val);
170}
171
172inline uint32 bytes_to_long(const void* buf) {
173  return talk_base::NetworkToHost32(*static_cast<const uint32*>(buf));
174}
175
176inline uint16 bytes_to_short(const void* buf) {
177  return talk_base::NetworkToHost16(*static_cast<const uint16*>(buf));
178}
179
180uint32 bound(uint32 lower, uint32 middle, uint32 upper) {
181  return talk_base::_min(talk_base::_max(lower, middle), upper);
182}
183
184//////////////////////////////////////////////////////////////////////
185// Debugging Statistics
186//////////////////////////////////////////////////////////////////////
187
188#if 0  // Not used yet
189
190enum Stat {
191  S_SENT_PACKET,   // All packet sends
192  S_RESENT_PACKET, // All packet sends that are retransmits
193  S_RECV_PACKET,   // All packet receives
194  S_RECV_NEW,      // All packet receives that are too new
195  S_RECV_OLD,      // All packet receives that are too old
196  S_NUM_STATS
197};
198
199const char* const STAT_NAMES[S_NUM_STATS] = {
200  "snt",
201  "snt-r",
202  "rcv"
203  "rcv-n",
204  "rcv-o"
205};
206
207int g_stats[S_NUM_STATS];
208inline void Incr(Stat s) { ++g_stats[s]; }
209void ReportStats() {
210  char buffer[256];
211  size_t len = 0;
212  for (int i = 0; i < S_NUM_STATS; ++i) {
213    len += talk_base::sprintfn(buffer, ARRAY_SIZE(buffer), "%s%s:%d",
214                               (i == 0) ? "" : ",", STAT_NAMES[i], g_stats[i]);
215    g_stats[i] = 0;
216  }
217  LOG(LS_INFO) << "Stats[" << buffer << "]";
218}
219
220#endif
221
222//////////////////////////////////////////////////////////////////////
223// PseudoTcp
224//////////////////////////////////////////////////////////////////////
225
226uint32 PseudoTcp::Now() {
227#if 0  // Use this to synchronize timers with logging timestamps (easier debug)
228  return talk_base::TimeSince(StartTime());
229#else
230  return talk_base::Time();
231#endif
232}
233
234PseudoTcp::PseudoTcp(IPseudoTcpNotify* notify, uint32 conv)
235    : m_notify(notify),
236      m_shutdown(SD_NONE),
237      m_error(0),
238      m_rbuf_len(DEFAULT_RCV_BUF_SIZE),
239      m_rbuf(m_rbuf_len),
240      m_sbuf_len(DEFAULT_SND_BUF_SIZE),
241      m_sbuf(m_sbuf_len) {
242
243  // Sanity check on buffer sizes (needed for OnTcpWriteable notification logic)
244  ASSERT(m_rbuf_len + MIN_PACKET < m_sbuf_len);
245
246  uint32 now = Now();
247
248  m_state = TCP_LISTEN;
249  m_conv = conv;
250  m_rcv_wnd = m_rbuf_len;
251  m_rwnd_scale = m_swnd_scale = 0;
252  m_snd_nxt = 0;
253  m_snd_wnd = 1;
254  m_snd_una = m_rcv_nxt = 0;
255  m_bReadEnable = true;
256  m_bWriteEnable = false;
257  m_t_ack = 0;
258
259  m_msslevel = 0;
260  m_largest = 0;
261  ASSERT(MIN_PACKET > PACKET_OVERHEAD);
262  m_mss = MIN_PACKET - PACKET_OVERHEAD;
263  m_mtu_advise = MAX_PACKET;
264
265  m_rto_base = 0;
266
267  m_cwnd = 2 * m_mss;
268  m_ssthresh = m_rbuf_len;
269  m_lastrecv = m_lastsend = m_lasttraffic = now;
270  m_bOutgoing = false;
271
272  m_dup_acks = 0;
273  m_recover = 0;
274
275  m_ts_recent = m_ts_lastack = 0;
276
277  m_rx_rto = DEF_RTO;
278  m_rx_srtt = m_rx_rttvar = 0;
279
280  m_use_nagling = true;
281  m_ack_delay = DEF_ACK_DELAY;
282  m_support_wnd_scale = true;
283}
284
285PseudoTcp::~PseudoTcp() {
286}
287
288int PseudoTcp::Connect() {
289  if (m_state != TCP_LISTEN) {
290    m_error = EINVAL;
291    return -1;
292  }
293
294  m_state = TCP_SYN_SENT;
295  LOG(LS_INFO) << "State: TCP_SYN_SENT";
296
297  queueConnectMessage();
298  attemptSend();
299
300  return 0;
301}
302
303void PseudoTcp::NotifyMTU(uint16 mtu) {
304  m_mtu_advise = mtu;
305  if (m_state == TCP_ESTABLISHED) {
306    adjustMTU();
307  }
308}
309
310void PseudoTcp::NotifyClock(uint32 now) {
311  if (m_state == TCP_CLOSED)
312    return;
313
314    // Check if it's time to retransmit a segment
315  if (m_rto_base && (talk_base::TimeDiff(m_rto_base + m_rx_rto, now) <= 0)) {
316    if (m_slist.empty()) {
317      ASSERT(false);
318    } else {
319      // Note: (m_slist.front().xmit == 0)) {
320      // retransmit segments
321#if _DEBUGMSG >= _DBG_NORMAL
322      LOG(LS_INFO) << "timeout retransmit (rto: " << m_rx_rto
323                   << ") (rto_base: " << m_rto_base
324                   << ") (now: " << now
325                   << ") (dup_acks: " << static_cast<unsigned>(m_dup_acks)
326                   << ")";
327#endif // _DEBUGMSG
328      if (!transmit(m_slist.begin(), now)) {
329        closedown(ECONNABORTED);
330        return;
331      }
332
333      uint32 nInFlight = m_snd_nxt - m_snd_una;
334      m_ssthresh = talk_base::_max(nInFlight / 2, 2 * m_mss);
335      //LOG(LS_INFO) << "m_ssthresh: " << m_ssthresh << "  nInFlight: " << nInFlight << "  m_mss: " << m_mss;
336      m_cwnd = m_mss;
337
338      // Back off retransmit timer.  Note: the limit is lower when connecting.
339      uint32 rto_limit = (m_state < TCP_ESTABLISHED) ? DEF_RTO : MAX_RTO;
340      m_rx_rto = talk_base::_min(rto_limit, m_rx_rto * 2);
341      m_rto_base = now;
342    }
343  }
344
345  // Check if it's time to probe closed windows
346  if ((m_snd_wnd == 0)
347        && (talk_base::TimeDiff(m_lastsend + m_rx_rto, now) <= 0)) {
348    if (talk_base::TimeDiff(now, m_lastrecv) >= 15000) {
349      closedown(ECONNABORTED);
350      return;
351    }
352
353    // probe the window
354    packet(m_snd_nxt - 1, 0, 0, 0);
355    m_lastsend = now;
356
357    // back off retransmit timer
358    m_rx_rto = talk_base::_min(MAX_RTO, m_rx_rto * 2);
359  }
360
361  // Check if it's time to send delayed acks
362  if (m_t_ack && (talk_base::TimeDiff(m_t_ack + m_ack_delay, now) <= 0)) {
363    packet(m_snd_nxt, 0, 0, 0);
364  }
365
366#if PSEUDO_KEEPALIVE
367  // Check for idle timeout
368  if ((m_state == TCP_ESTABLISHED) && (TimeDiff(m_lastrecv + IDLE_TIMEOUT, now) <= 0)) {
369    closedown(ECONNABORTED);
370    return;
371  }
372
373  // Check for ping timeout (to keep udp mapping open)
374  if ((m_state == TCP_ESTABLISHED) && (TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3/2 : IDLE_PING), now) <= 0)) {
375    packet(m_snd_nxt, 0, 0, 0);
376  }
377#endif // PSEUDO_KEEPALIVE
378}
379
380bool PseudoTcp::NotifyPacket(const char* buffer, size_t len) {
381  if (len > MAX_PACKET) {
382    LOG_F(WARNING) << "packet too large";
383    return false;
384  }
385  return parse(reinterpret_cast<const uint8 *>(buffer), uint32(len));
386}
387
388bool PseudoTcp::GetNextClock(uint32 now, long& timeout) {
389  return clock_check(now, timeout);
390}
391
392void PseudoTcp::GetOption(Option opt, int* value) {
393  if (opt == OPT_NODELAY) {
394    *value = m_use_nagling ? 0 : 1;
395  } else if (opt == OPT_ACKDELAY) {
396    *value = m_ack_delay;
397  } else if (opt == OPT_SNDBUF) {
398    *value = m_sbuf_len;
399  } else if (opt == OPT_RCVBUF) {
400    *value = m_rbuf_len;
401  } else {
402    ASSERT(false);
403  }
404}
405void PseudoTcp::SetOption(Option opt, int value) {
406  if (opt == OPT_NODELAY) {
407    m_use_nagling = value == 0;
408  } else if (opt == OPT_ACKDELAY) {
409    m_ack_delay = value;
410  } else if (opt == OPT_SNDBUF) {
411    ASSERT(m_state == TCP_LISTEN);
412    resizeSendBuffer(value);
413  } else if (opt == OPT_RCVBUF) {
414    ASSERT(m_state == TCP_LISTEN);
415    resizeReceiveBuffer(value);
416  } else {
417    ASSERT(false);
418  }
419}
420
421uint32 PseudoTcp::GetCongestionWindow() const {
422  return m_cwnd;
423}
424
425uint32 PseudoTcp::GetBytesInFlight() const {
426  return m_snd_nxt - m_snd_una;
427}
428
429uint32 PseudoTcp::GetBytesBufferedNotSent() const {
430  size_t buffered_bytes = 0;
431  m_sbuf.GetBuffered(&buffered_bytes);
432  return static_cast<uint32>(m_snd_una + buffered_bytes - m_snd_nxt);
433}
434
435uint32 PseudoTcp::GetRoundTripTimeEstimateMs() const {
436  return m_rx_srtt;
437}
438
439//
440// IPStream Implementation
441//
442
443int PseudoTcp::Recv(char* buffer, size_t len) {
444  if (m_state != TCP_ESTABLISHED) {
445    m_error = ENOTCONN;
446    return SOCKET_ERROR;
447  }
448
449  size_t read = 0;
450  talk_base::StreamResult result = m_rbuf.Read(buffer, len, &read, NULL);
451
452  // If there's no data in |m_rbuf|.
453  if (result == talk_base::SR_BLOCK) {
454    m_bReadEnable = true;
455    m_error = EWOULDBLOCK;
456    return SOCKET_ERROR;
457  }
458  ASSERT(result == talk_base::SR_SUCCESS);
459
460  size_t available_space = 0;
461  m_rbuf.GetWriteRemaining(&available_space);
462
463  if (uint32(available_space) - m_rcv_wnd >=
464      talk_base::_min<uint32>(m_rbuf_len / 2, m_mss)) {
465    // TODO(jbeda): !?! Not sure about this was closed business
466    bool bWasClosed = (m_rcv_wnd == 0);
467    m_rcv_wnd = static_cast<uint32>(available_space);
468
469    if (bWasClosed) {
470      attemptSend(sfImmediateAck);
471    }
472  }
473
474  return static_cast<int>(read);
475}
476
477int PseudoTcp::Send(const char* buffer, size_t len) {
478  if (m_state != TCP_ESTABLISHED) {
479    m_error = ENOTCONN;
480    return SOCKET_ERROR;
481  }
482
483  size_t available_space = 0;
484  m_sbuf.GetWriteRemaining(&available_space);
485
486  if (!available_space) {
487    m_bWriteEnable = true;
488    m_error = EWOULDBLOCK;
489    return SOCKET_ERROR;
490  }
491
492  int written = queue(buffer, uint32(len), false);
493  attemptSend();
494  return written;
495}
496
497void PseudoTcp::Close(bool force) {
498  LOG_F(LS_VERBOSE) << "(" << (force ? "true" : "false") << ")";
499  m_shutdown = force ? SD_FORCEFUL : SD_GRACEFUL;
500}
501
502int PseudoTcp::GetError() {
503  return m_error;
504}
505
506//
507// Internal Implementation
508//
509
510uint32 PseudoTcp::queue(const char* data, uint32 len, bool bCtrl) {
511  size_t available_space = 0;
512  m_sbuf.GetWriteRemaining(&available_space);
513
514  if (len > static_cast<uint32>(available_space)) {
515    ASSERT(!bCtrl);
516    len = static_cast<uint32>(available_space);
517  }
518
519  // We can concatenate data if the last segment is the same type
520  // (control v. regular data), and has not been transmitted yet
521  if (!m_slist.empty() && (m_slist.back().bCtrl == bCtrl) &&
522      (m_slist.back().xmit == 0)) {
523    m_slist.back().len += len;
524  } else {
525    size_t snd_buffered = 0;
526    m_sbuf.GetBuffered(&snd_buffered);
527    SSegment sseg(static_cast<uint32>(m_snd_una + snd_buffered), len, bCtrl);
528    m_slist.push_back(sseg);
529  }
530
531  size_t written = 0;
532  m_sbuf.Write(data, len, &written, NULL);
533  return static_cast<uint32>(written);
534}
535
536IPseudoTcpNotify::WriteResult PseudoTcp::packet(uint32 seq, uint8 flags,
537                                                uint32 offset, uint32 len) {
538  ASSERT(HEADER_SIZE + len <= MAX_PACKET);
539
540  uint32 now = Now();
541
542  talk_base::scoped_ptr<uint8[]> buffer(new uint8[MAX_PACKET]);
543  long_to_bytes(m_conv, buffer.get());
544  long_to_bytes(seq, buffer.get() + 4);
545  long_to_bytes(m_rcv_nxt, buffer.get() + 8);
546  buffer[12] = 0;
547  buffer[13] = flags;
548  short_to_bytes(
549      static_cast<uint16>(m_rcv_wnd >> m_rwnd_scale), buffer.get() + 14);
550
551  // Timestamp computations
552  long_to_bytes(now, buffer.get() + 16);
553  long_to_bytes(m_ts_recent, buffer.get() + 20);
554  m_ts_lastack = m_rcv_nxt;
555
556  if (len) {
557    size_t bytes_read = 0;
558    talk_base::StreamResult result = m_sbuf.ReadOffset(
559        buffer.get() + HEADER_SIZE, len, offset, &bytes_read);
560    UNUSED(result);
561    ASSERT(result == talk_base::SR_SUCCESS);
562    ASSERT(static_cast<uint32>(bytes_read) == len);
563  }
564
565#if _DEBUGMSG >= _DBG_VERBOSE
566  LOG(LS_INFO) << "<-- <CONV=" << m_conv
567               << "><FLG=" << static_cast<unsigned>(flags)
568               << "><SEQ=" << seq << ":" << seq + len
569               << "><ACK=" << m_rcv_nxt
570               << "><WND=" << m_rcv_wnd
571               << "><TS="  << (now % 10000)
572               << "><TSR=" << (m_ts_recent % 10000)
573               << "><LEN=" << len << ">";
574#endif // _DEBUGMSG
575
576  IPseudoTcpNotify::WriteResult wres = m_notify->TcpWritePacket(
577      this, reinterpret_cast<char *>(buffer.get()), len + HEADER_SIZE);
578  // Note: When len is 0, this is an ACK packet.  We don't read the return value for those,
579  // and thus we won't retry.  So go ahead and treat the packet as a success (basically simulate
580  // as if it were dropped), which will prevent our timers from being messed up.
581  if ((wres != IPseudoTcpNotify::WR_SUCCESS) && (0 != len))
582    return wres;
583
584  m_t_ack = 0;
585  if (len > 0) {
586    m_lastsend = now;
587  }
588  m_lasttraffic = now;
589  m_bOutgoing = true;
590
591  return IPseudoTcpNotify::WR_SUCCESS;
592}
593
594bool PseudoTcp::parse(const uint8* buffer, uint32 size) {
595  if (size < 12)
596    return false;
597
598  Segment seg;
599  seg.conv = bytes_to_long(buffer);
600  seg.seq = bytes_to_long(buffer + 4);
601  seg.ack = bytes_to_long(buffer + 8);
602  seg.flags = buffer[13];
603  seg.wnd = bytes_to_short(buffer + 14);
604
605  seg.tsval = bytes_to_long(buffer + 16);
606  seg.tsecr = bytes_to_long(buffer + 20);
607
608  seg.data = reinterpret_cast<const char *>(buffer) + HEADER_SIZE;
609  seg.len = size - HEADER_SIZE;
610
611#if _DEBUGMSG >= _DBG_VERBOSE
612  LOG(LS_INFO) << "--> <CONV=" << seg.conv
613               << "><FLG=" << static_cast<unsigned>(seg.flags)
614               << "><SEQ=" << seg.seq << ":" << seg.seq + seg.len
615               << "><ACK=" << seg.ack
616               << "><WND=" << seg.wnd
617               << "><TS="  << (seg.tsval % 10000)
618               << "><TSR=" << (seg.tsecr % 10000)
619               << "><LEN=" << seg.len << ">";
620#endif // _DEBUGMSG
621
622  return process(seg);
623}
624
625bool PseudoTcp::clock_check(uint32 now, long& nTimeout) {
626  if (m_shutdown == SD_FORCEFUL)
627    return false;
628
629  size_t snd_buffered = 0;
630  m_sbuf.GetBuffered(&snd_buffered);
631  if ((m_shutdown == SD_GRACEFUL)
632      && ((m_state != TCP_ESTABLISHED)
633          || ((snd_buffered == 0) && (m_t_ack == 0)))) {
634    return false;
635  }
636
637  if (m_state == TCP_CLOSED) {
638    nTimeout = CLOSED_TIMEOUT;
639    return true;
640  }
641
642  nTimeout = DEFAULT_TIMEOUT;
643
644  if (m_t_ack) {
645    nTimeout = talk_base::_min<int32>(nTimeout,
646      talk_base::TimeDiff(m_t_ack + m_ack_delay, now));
647  }
648  if (m_rto_base) {
649    nTimeout = talk_base::_min<int32>(nTimeout,
650      talk_base::TimeDiff(m_rto_base + m_rx_rto, now));
651  }
652  if (m_snd_wnd == 0) {
653    nTimeout = talk_base::_min<int32>(nTimeout, talk_base::TimeDiff(m_lastsend + m_rx_rto, now));
654  }
655#if PSEUDO_KEEPALIVE
656  if (m_state == TCP_ESTABLISHED) {
657    nTimeout = talk_base::_min<int32>(nTimeout,
658      talk_base::TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3/2 : IDLE_PING), now));
659  }
660#endif // PSEUDO_KEEPALIVE
661  return true;
662}
663
664bool PseudoTcp::process(Segment& seg) {
665  // If this is the wrong conversation, send a reset!?! (with the correct conversation?)
666  if (seg.conv != m_conv) {
667    //if ((seg.flags & FLAG_RST) == 0) {
668    //  packet(tcb, seg.ack, 0, FLAG_RST, 0, 0);
669    //}
670    LOG_F(LS_ERROR) << "wrong conversation";
671    return false;
672  }
673
674  uint32 now = Now();
675  m_lasttraffic = m_lastrecv = now;
676  m_bOutgoing = false;
677
678  if (m_state == TCP_CLOSED) {
679    // !?! send reset?
680    LOG_F(LS_ERROR) << "closed";
681    return false;
682  }
683
684  // Check if this is a reset segment
685  if (seg.flags & FLAG_RST) {
686    closedown(ECONNRESET);
687    return false;
688  }
689
690  // Check for control data
691  bool bConnect = false;
692  if (seg.flags & FLAG_CTL) {
693    if (seg.len == 0) {
694      LOG_F(LS_ERROR) << "Missing control code";
695      return false;
696    } else if (seg.data[0] == CTL_CONNECT) {
697      bConnect = true;
698
699      // TCP options are in the remainder of the payload after CTL_CONNECT.
700      parseOptions(&seg.data[1], seg.len - 1);
701
702      if (m_state == TCP_LISTEN) {
703        m_state = TCP_SYN_RECEIVED;
704        LOG(LS_INFO) << "State: TCP_SYN_RECEIVED";
705        //m_notify->associate(addr);
706        queueConnectMessage();
707      } else if (m_state == TCP_SYN_SENT) {
708        m_state = TCP_ESTABLISHED;
709        LOG(LS_INFO) << "State: TCP_ESTABLISHED";
710        adjustMTU();
711        if (m_notify) {
712          m_notify->OnTcpOpen(this);
713        }
714        //notify(evOpen);
715      }
716    } else {
717      LOG_F(LS_WARNING) << "Unknown control code: " << seg.data[0];
718      return false;
719    }
720  }
721
722  // Update timestamp
723  if ((seg.seq <= m_ts_lastack) && (m_ts_lastack < seg.seq + seg.len)) {
724    m_ts_recent = seg.tsval;
725  }
726
727  // Check if this is a valuable ack
728  if ((seg.ack > m_snd_una) && (seg.ack <= m_snd_nxt)) {
729    // Calculate round-trip time
730    if (seg.tsecr) {
731      long rtt = talk_base::TimeDiff(now, seg.tsecr);
732      if (rtt >= 0) {
733        if (m_rx_srtt == 0) {
734          m_rx_srtt = rtt;
735          m_rx_rttvar = rtt / 2;
736        } else {
737          m_rx_rttvar = (3 * m_rx_rttvar + abs(long(rtt - m_rx_srtt))) / 4;
738          m_rx_srtt = (7 * m_rx_srtt + rtt) / 8;
739        }
740        m_rx_rto = bound(MIN_RTO, m_rx_srtt +
741            talk_base::_max<uint32>(1, 4 * m_rx_rttvar), MAX_RTO);
742#if _DEBUGMSG >= _DBG_VERBOSE
743        LOG(LS_INFO) << "rtt: " << rtt
744                     << "  srtt: " << m_rx_srtt
745                     << "  rto: " << m_rx_rto;
746#endif // _DEBUGMSG
747      } else {
748        ASSERT(false);
749      }
750    }
751
752    m_snd_wnd = static_cast<uint32>(seg.wnd) << m_swnd_scale;
753
754    uint32 nAcked = seg.ack - m_snd_una;
755    m_snd_una = seg.ack;
756
757    m_rto_base = (m_snd_una == m_snd_nxt) ? 0 : now;
758
759    m_sbuf.ConsumeReadData(nAcked);
760
761    for (uint32 nFree = nAcked; nFree > 0; ) {
762      ASSERT(!m_slist.empty());
763      if (nFree < m_slist.front().len) {
764        m_slist.front().len -= nFree;
765        nFree = 0;
766      } else {
767        if (m_slist.front().len > m_largest) {
768          m_largest = m_slist.front().len;
769        }
770        nFree -= m_slist.front().len;
771        m_slist.pop_front();
772      }
773    }
774
775    if (m_dup_acks >= 3) {
776      if (m_snd_una >= m_recover) { // NewReno
777        uint32 nInFlight = m_snd_nxt - m_snd_una;
778        m_cwnd = talk_base::_min(m_ssthresh, nInFlight + m_mss); // (Fast Retransmit)
779#if _DEBUGMSG >= _DBG_NORMAL
780        LOG(LS_INFO) << "exit recovery";
781#endif // _DEBUGMSG
782        m_dup_acks = 0;
783      } else {
784#if _DEBUGMSG >= _DBG_NORMAL
785        LOG(LS_INFO) << "recovery retransmit";
786#endif // _DEBUGMSG
787        if (!transmit(m_slist.begin(), now)) {
788          closedown(ECONNABORTED);
789          return false;
790        }
791        m_cwnd += m_mss - talk_base::_min(nAcked, m_cwnd);
792      }
793    } else {
794      m_dup_acks = 0;
795      // Slow start, congestion avoidance
796      if (m_cwnd < m_ssthresh) {
797        m_cwnd += m_mss;
798      } else {
799        m_cwnd += talk_base::_max<uint32>(1, m_mss * m_mss / m_cwnd);
800      }
801    }
802  } else if (seg.ack == m_snd_una) {
803    // !?! Note, tcp says don't do this... but otherwise how does a closed window become open?
804    m_snd_wnd = static_cast<uint32>(seg.wnd) << m_swnd_scale;
805
806    // Check duplicate acks
807    if (seg.len > 0) {
808      // it's a dup ack, but with a data payload, so don't modify m_dup_acks
809    } else if (m_snd_una != m_snd_nxt) {
810      m_dup_acks += 1;
811      if (m_dup_acks == 3) { // (Fast Retransmit)
812#if _DEBUGMSG >= _DBG_NORMAL
813        LOG(LS_INFO) << "enter recovery";
814        LOG(LS_INFO) << "recovery retransmit";
815#endif // _DEBUGMSG
816        if (!transmit(m_slist.begin(), now)) {
817          closedown(ECONNABORTED);
818          return false;
819        }
820        m_recover = m_snd_nxt;
821        uint32 nInFlight = m_snd_nxt - m_snd_una;
822        m_ssthresh = talk_base::_max(nInFlight / 2, 2 * m_mss);
823        //LOG(LS_INFO) << "m_ssthresh: " << m_ssthresh << "  nInFlight: " << nInFlight << "  m_mss: " << m_mss;
824        m_cwnd = m_ssthresh + 3 * m_mss;
825      } else if (m_dup_acks > 3) {
826        m_cwnd += m_mss;
827      }
828    } else {
829      m_dup_acks = 0;
830    }
831  }
832
833  // !?! A bit hacky
834  if ((m_state == TCP_SYN_RECEIVED) && !bConnect) {
835    m_state = TCP_ESTABLISHED;
836    LOG(LS_INFO) << "State: TCP_ESTABLISHED";
837    adjustMTU();
838    if (m_notify) {
839      m_notify->OnTcpOpen(this);
840    }
841    //notify(evOpen);
842  }
843
844  // If we make room in the send queue, notify the user
845  // The goal it to make sure we always have at least enough data to fill the
846  // window.  We'd like to notify the app when we are halfway to that point.
847  const uint32 kIdealRefillSize = (m_sbuf_len + m_rbuf_len) / 2;
848  size_t snd_buffered = 0;
849  m_sbuf.GetBuffered(&snd_buffered);
850  if (m_bWriteEnable && static_cast<uint32>(snd_buffered) < kIdealRefillSize) {
851    m_bWriteEnable = false;
852    if (m_notify) {
853      m_notify->OnTcpWriteable(this);
854    }
855    //notify(evWrite);
856  }
857
858  // Conditions were acks must be sent:
859  // 1) Segment is too old (they missed an ACK) (immediately)
860  // 2) Segment is too new (we missed a segment) (immediately)
861  // 3) Segment has data (so we need to ACK!) (delayed)
862  // ... so the only time we don't need to ACK, is an empty segment that points to rcv_nxt!
863
864  SendFlags sflags = sfNone;
865  if (seg.seq != m_rcv_nxt) {
866    sflags = sfImmediateAck; // (Fast Recovery)
867  } else if (seg.len != 0) {
868    if (m_ack_delay == 0) {
869      sflags = sfImmediateAck;
870    } else {
871      sflags = sfDelayedAck;
872    }
873  }
874#if _DEBUGMSG >= _DBG_NORMAL
875  if (sflags == sfImmediateAck) {
876    if (seg.seq > m_rcv_nxt) {
877      LOG_F(LS_INFO) << "too new";
878    } else if (seg.seq + seg.len <= m_rcv_nxt) {
879      LOG_F(LS_INFO) << "too old";
880    }
881  }
882#endif // _DEBUGMSG
883
884  // Adjust the incoming segment to fit our receive buffer
885  if (seg.seq < m_rcv_nxt) {
886    uint32 nAdjust = m_rcv_nxt - seg.seq;
887    if (nAdjust < seg.len) {
888      seg.seq += nAdjust;
889      seg.data += nAdjust;
890      seg.len -= nAdjust;
891    } else {
892      seg.len = 0;
893    }
894  }
895
896  size_t available_space = 0;
897  m_rbuf.GetWriteRemaining(&available_space);
898
899  if ((seg.seq + seg.len - m_rcv_nxt) > static_cast<uint32>(available_space)) {
900    uint32 nAdjust = seg.seq + seg.len - m_rcv_nxt - static_cast<uint32>(available_space);
901    if (nAdjust < seg.len) {
902      seg.len -= nAdjust;
903    } else {
904      seg.len = 0;
905    }
906  }
907
908  bool bIgnoreData = (seg.flags & FLAG_CTL) || (m_shutdown != SD_NONE);
909  bool bNewData = false;
910
911  if (seg.len > 0) {
912    if (bIgnoreData) {
913      if (seg.seq == m_rcv_nxt) {
914        m_rcv_nxt += seg.len;
915      }
916    } else {
917      uint32 nOffset = seg.seq - m_rcv_nxt;
918
919      talk_base::StreamResult result = m_rbuf.WriteOffset(seg.data, seg.len,
920                                                          nOffset, NULL);
921      ASSERT(result == talk_base::SR_SUCCESS);
922      UNUSED(result);
923
924      if (seg.seq == m_rcv_nxt) {
925        m_rbuf.ConsumeWriteBuffer(seg.len);
926        m_rcv_nxt += seg.len;
927        m_rcv_wnd -= seg.len;
928        bNewData = true;
929
930        RList::iterator it = m_rlist.begin();
931        while ((it != m_rlist.end()) && (it->seq <= m_rcv_nxt)) {
932          if (it->seq + it->len > m_rcv_nxt) {
933            sflags = sfImmediateAck; // (Fast Recovery)
934            uint32 nAdjust = (it->seq + it->len) - m_rcv_nxt;
935#if _DEBUGMSG >= _DBG_NORMAL
936            LOG(LS_INFO) << "Recovered " << nAdjust << " bytes (" << m_rcv_nxt << " -> " << m_rcv_nxt + nAdjust << ")";
937#endif // _DEBUGMSG
938            m_rbuf.ConsumeWriteBuffer(nAdjust);
939            m_rcv_nxt += nAdjust;
940            m_rcv_wnd -= nAdjust;
941          }
942          it = m_rlist.erase(it);
943        }
944      } else {
945#if _DEBUGMSG >= _DBG_NORMAL
946        LOG(LS_INFO) << "Saving " << seg.len << " bytes (" << seg.seq << " -> " << seg.seq + seg.len << ")";
947#endif // _DEBUGMSG
948        RSegment rseg;
949        rseg.seq = seg.seq;
950        rseg.len = seg.len;
951        RList::iterator it = m_rlist.begin();
952        while ((it != m_rlist.end()) && (it->seq < rseg.seq)) {
953          ++it;
954        }
955        m_rlist.insert(it, rseg);
956      }
957    }
958  }
959
960  attemptSend(sflags);
961
962  // If we have new data, notify the user
963  if (bNewData && m_bReadEnable) {
964    m_bReadEnable = false;
965    if (m_notify) {
966      m_notify->OnTcpReadable(this);
967    }
968    //notify(evRead);
969  }
970
971  return true;
972}
973
974bool PseudoTcp::transmit(const SList::iterator& seg, uint32 now) {
975  if (seg->xmit >= ((m_state == TCP_ESTABLISHED) ? 15 : 30)) {
976    LOG_F(LS_VERBOSE) << "too many retransmits";
977    return false;
978  }
979
980  uint32 nTransmit = talk_base::_min(seg->len, m_mss);
981
982  while (true) {
983    uint32 seq = seg->seq;
984    uint8 flags = (seg->bCtrl ? FLAG_CTL : 0);
985    IPseudoTcpNotify::WriteResult wres = packet(seq,
986                                                flags,
987                                                seg->seq - m_snd_una,
988                                                nTransmit);
989
990    if (wres == IPseudoTcpNotify::WR_SUCCESS)
991      break;
992
993    if (wres == IPseudoTcpNotify::WR_FAIL) {
994      LOG_F(LS_VERBOSE) << "packet failed";
995      return false;
996    }
997
998    ASSERT(wres == IPseudoTcpNotify::WR_TOO_LARGE);
999
1000    while (true) {
1001      if (PACKET_MAXIMUMS[m_msslevel + 1] == 0) {
1002        LOG_F(LS_VERBOSE) << "MTU too small";
1003        return false;
1004      }
1005      // !?! We need to break up all outstanding and pending packets and then retransmit!?!
1006
1007      m_mss = PACKET_MAXIMUMS[++m_msslevel] - PACKET_OVERHEAD;
1008      m_cwnd = 2 * m_mss; // I added this... haven't researched actual formula
1009      if (m_mss < nTransmit) {
1010        nTransmit = m_mss;
1011        break;
1012      }
1013    }
1014#if _DEBUGMSG >= _DBG_NORMAL
1015    LOG(LS_INFO) << "Adjusting mss to " << m_mss << " bytes";
1016#endif // _DEBUGMSG
1017  }
1018
1019  if (nTransmit < seg->len) {
1020    LOG_F(LS_VERBOSE) << "mss reduced to " << m_mss;
1021
1022    SSegment subseg(seg->seq + nTransmit, seg->len - nTransmit, seg->bCtrl);
1023    //subseg.tstamp = seg->tstamp;
1024    subseg.xmit = seg->xmit;
1025    seg->len = nTransmit;
1026
1027    SList::iterator next = seg;
1028    m_slist.insert(++next, subseg);
1029  }
1030
1031  if (seg->xmit == 0) {
1032    m_snd_nxt += seg->len;
1033  }
1034  seg->xmit += 1;
1035  //seg->tstamp = now;
1036  if (m_rto_base == 0) {
1037    m_rto_base = now;
1038  }
1039
1040  return true;
1041}
1042
1043void PseudoTcp::attemptSend(SendFlags sflags) {
1044  uint32 now = Now();
1045
1046  if (talk_base::TimeDiff(now, m_lastsend) > static_cast<long>(m_rx_rto)) {
1047    m_cwnd = m_mss;
1048  }
1049
1050#if _DEBUGMSG
1051  bool bFirst = true;
1052  UNUSED(bFirst);
1053#endif // _DEBUGMSG
1054
1055  while (true) {
1056    uint32 cwnd = m_cwnd;
1057    if ((m_dup_acks == 1) || (m_dup_acks == 2)) { // Limited Transmit
1058      cwnd += m_dup_acks * m_mss;
1059    }
1060    uint32 nWindow = talk_base::_min(m_snd_wnd, cwnd);
1061    uint32 nInFlight = m_snd_nxt - m_snd_una;
1062    uint32 nUseable = (nInFlight < nWindow) ? (nWindow - nInFlight) : 0;
1063
1064    size_t snd_buffered = 0;
1065    m_sbuf.GetBuffered(&snd_buffered);
1066    uint32 nAvailable =
1067        talk_base::_min(static_cast<uint32>(snd_buffered) - nInFlight, m_mss);
1068
1069    if (nAvailable > nUseable) {
1070      if (nUseable * 4 < nWindow) {
1071        // RFC 813 - avoid SWS
1072        nAvailable = 0;
1073      } else {
1074        nAvailable = nUseable;
1075      }
1076    }
1077
1078#if _DEBUGMSG >= _DBG_VERBOSE
1079    if (bFirst) {
1080      size_t available_space = 0;
1081      m_sbuf.GetWriteRemaining(&available_space);
1082
1083      bFirst = false;
1084      LOG(LS_INFO) << "[cwnd: " << m_cwnd
1085                   << "  nWindow: " << nWindow
1086                   << "  nInFlight: " << nInFlight
1087                   << "  nAvailable: " << nAvailable
1088                   << "  nQueued: " << snd_buffered
1089                   << "  nEmpty: " << available_space
1090                   << "  ssthresh: " << m_ssthresh << "]";
1091    }
1092#endif // _DEBUGMSG
1093
1094    if (nAvailable == 0) {
1095      if (sflags == sfNone)
1096        return;
1097
1098      // If this is an immediate ack, or the second delayed ack
1099      if ((sflags == sfImmediateAck) || m_t_ack) {
1100        packet(m_snd_nxt, 0, 0, 0);
1101      } else {
1102        m_t_ack = Now();
1103      }
1104      return;
1105    }
1106
1107    // Nagle's algorithm.
1108    // If there is data already in-flight, and we haven't a full segment of
1109    // data ready to send then hold off until we get more to send, or the
1110    // in-flight data is acknowledged.
1111    if (m_use_nagling && (m_snd_nxt > m_snd_una) && (nAvailable < m_mss))  {
1112      return;
1113    }
1114
1115    // Find the next segment to transmit
1116    SList::iterator it = m_slist.begin();
1117    while (it->xmit > 0) {
1118      ++it;
1119      ASSERT(it != m_slist.end());
1120    }
1121    SList::iterator seg = it;
1122
1123    // If the segment is too large, break it into two
1124    if (seg->len > nAvailable) {
1125      SSegment subseg(seg->seq + nAvailable, seg->len - nAvailable, seg->bCtrl);
1126      seg->len = nAvailable;
1127      m_slist.insert(++it, subseg);
1128    }
1129
1130    if (!transmit(seg, now)) {
1131      LOG_F(LS_VERBOSE) << "transmit failed";
1132      // TODO: consider closing socket
1133      return;
1134    }
1135
1136    sflags = sfNone;
1137  }
1138}
1139
1140void
1141PseudoTcp::closedown(uint32 err) {
1142  LOG(LS_INFO) << "State: TCP_CLOSED";
1143  m_state = TCP_CLOSED;
1144  if (m_notify) {
1145    m_notify->OnTcpClosed(this, err);
1146  }
1147  //notify(evClose, err);
1148}
1149
1150void
1151PseudoTcp::adjustMTU() {
1152  // Determine our current mss level, so that we can adjust appropriately later
1153  for (m_msslevel = 0; PACKET_MAXIMUMS[m_msslevel + 1] > 0; ++m_msslevel) {
1154    if (static_cast<uint16>(PACKET_MAXIMUMS[m_msslevel]) <= m_mtu_advise) {
1155      break;
1156    }
1157  }
1158  m_mss = m_mtu_advise - PACKET_OVERHEAD;
1159  // !?! Should we reset m_largest here?
1160#if _DEBUGMSG >= _DBG_NORMAL
1161  LOG(LS_INFO) << "Adjusting mss to " << m_mss << " bytes";
1162#endif // _DEBUGMSG
1163  // Enforce minimums on ssthresh and cwnd
1164  m_ssthresh = talk_base::_max(m_ssthresh, 2 * m_mss);
1165  m_cwnd = talk_base::_max(m_cwnd, m_mss);
1166}
1167
1168bool
1169PseudoTcp::isReceiveBufferFull() const {
1170  size_t available_space = 0;
1171  m_rbuf.GetWriteRemaining(&available_space);
1172  return !available_space;
1173}
1174
1175void
1176PseudoTcp::disableWindowScale() {
1177  m_support_wnd_scale = false;
1178}
1179
1180void
1181PseudoTcp::queueConnectMessage() {
1182  talk_base::ByteBuffer buf(talk_base::ByteBuffer::ORDER_NETWORK);
1183
1184  buf.WriteUInt8(CTL_CONNECT);
1185  if (m_support_wnd_scale) {
1186    buf.WriteUInt8(TCP_OPT_WND_SCALE);
1187    buf.WriteUInt8(1);
1188    buf.WriteUInt8(m_rwnd_scale);
1189  }
1190  m_snd_wnd = static_cast<uint32>(buf.Length());
1191  queue(buf.Data(), static_cast<uint32>(buf.Length()), true);
1192}
1193
1194void
1195PseudoTcp::parseOptions(const char* data, uint32 len) {
1196  std::set<uint8> options_specified;
1197
1198  // See http://www.freesoft.org/CIE/Course/Section4/8.htm for
1199  // parsing the options list.
1200  talk_base::ByteBuffer buf(data, len);
1201  while (buf.Length()) {
1202    uint8 kind = TCP_OPT_EOL;
1203    buf.ReadUInt8(&kind);
1204
1205    if (kind == TCP_OPT_EOL) {
1206      // End of option list.
1207      break;
1208    } else if (kind == TCP_OPT_NOOP) {
1209      // No op.
1210      continue;
1211    }
1212
1213    // Length of this option.
1214    ASSERT(len != 0);
1215    UNUSED(len);
1216    uint8 opt_len = 0;
1217    buf.ReadUInt8(&opt_len);
1218
1219    // Content of this option.
1220    if (opt_len <= buf.Length()) {
1221      applyOption(kind, buf.Data(), opt_len);
1222      buf.Consume(opt_len);
1223    } else {
1224      LOG(LS_ERROR) << "Invalid option length received.";
1225      return;
1226    }
1227    options_specified.insert(kind);
1228  }
1229
1230  if (options_specified.find(TCP_OPT_WND_SCALE) == options_specified.end()) {
1231    LOG(LS_WARNING) << "Peer doesn't support window scaling";
1232
1233    if (m_rwnd_scale > 0) {
1234      // Peer doesn't support TCP options and window scaling.
1235      // Revert receive buffer size to default value.
1236      resizeReceiveBuffer(DEFAULT_RCV_BUF_SIZE);
1237      m_swnd_scale = 0;
1238    }
1239  }
1240}
1241
1242void
1243PseudoTcp::applyOption(char kind, const char* data, uint32 len) {
1244  if (kind == TCP_OPT_MSS) {
1245    LOG(LS_WARNING) << "Peer specified MSS option which is not supported.";
1246    // TODO: Implement.
1247  } else if (kind == TCP_OPT_WND_SCALE) {
1248    // Window scale factor.
1249    // http://www.ietf.org/rfc/rfc1323.txt
1250    if (len != 1) {
1251      LOG_F(WARNING) << "Invalid window scale option received.";
1252      return;
1253    }
1254    applyWindowScaleOption(data[0]);
1255  }
1256}
1257
1258void
1259PseudoTcp::applyWindowScaleOption(uint8 scale_factor) {
1260  m_swnd_scale = scale_factor;
1261}
1262
1263void
1264PseudoTcp::resizeSendBuffer(uint32 new_size) {
1265  m_sbuf_len = new_size;
1266  m_sbuf.SetCapacity(new_size);
1267}
1268
1269void
1270PseudoTcp::resizeReceiveBuffer(uint32 new_size) {
1271  uint8 scale_factor = 0;
1272
1273  // Determine the scale factor such that the scaled window size can fit
1274  // in a 16-bit unsigned integer.
1275  while (new_size > 0xFFFF) {
1276    ++scale_factor;
1277    new_size >>= 1;
1278  }
1279
1280  // Determine the proper size of the buffer.
1281  new_size <<= scale_factor;
1282  bool result = m_rbuf.SetCapacity(new_size);
1283
1284  // Make sure the new buffer is large enough to contain data in the old
1285  // buffer. This should always be true because this method is called either
1286  // before connection is established or when peers are exchanging connect
1287  // messages.
1288  ASSERT(result);
1289  UNUSED(result);
1290  m_rbuf_len = new_size;
1291  m_rwnd_scale = scale_factor;
1292  m_ssthresh = new_size;
1293
1294  size_t available_space = 0;
1295  m_rbuf.GetWriteRemaining(&available_space);
1296  m_rcv_wnd = static_cast<uint32>(available_space);
1297}
1298
1299}  // namespace cricket
Note: See TracBrowser for help on using the repository browser.