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