protocols/tcp/TCPEndpoint.cpp

88 	Receive(TCPEndpoint* endpoint, tcp_segment_header& segment, uint32 window,
94 		fSequence(segment.sequence),
95 		fAcknowledge(segment.acknowledge),
98 		fFlags(segment.flags)
123 	Send(TCPEndpoint* endpoint, tcp_segment_header& segment, net_buffer* buffer,
129 		fSequence(segment.sequence),
130 		fAcknowledge(segment.acknowledge),
134 		fFlags(segment.flags)
304 segment_in_sequence(const tcp_segment_header& segment, int size,
307 	tcp_sequence sequence(segment.sequence);
1241 TCPEndpoint::_DuplicateAcknowledge(tcp_segment_header &segment)
1250 		fSendNext = segment.acknowledge;
1259 TCPEndpoint::_UpdateTimestamps(tcp_segment_header& segment,
1263 		tcp_sequence sequence(segment.sequence);
1267 			fReceivedTimestamp = segment.timestamp_value;
1301 TCPEndpoint::_AddData(tcp_segment_header& segment, net_buffer* buffer)
1303 	if ((segment.flags & TCP_FLAG_FINISH) != 0) {
1306 		fFinishReceivedAt = segment.sequence + buffer->size;
1309 	fReceiveQueue.Add(buffer, segment.sequence);
1313 		// Set or reset the finish flag on the current segment
1315 			segment.flags &= ~TCP_FLAG_FINISH;
1317 			segment.flags |= TCP_FLAG_FINISH;
1323 	if ((segment.flags & TCP_FLAG_PUSH) != 0)
1331 TCPEndpoint::_PrepareReceivePath(tcp_segment_header& segment)
1333 	fInitialReceiveSequence = segment.sequence;
1337 	segment.sequence++;
1339 	fReceiveNext = segment.sequence;
1340 	fReceiveQueue.SetInitialSequence(segment.sequence);
1343 		if (segment.max_segment_size > 0)
1344 			fSendMaxSegmentSize = segment.max_segment_size;
1346 		if (segment.options & TCP_HAS_WINDOW_SCALE) {
1348 			fSendWindowShift = segment.window_shift;
1354 		if (segment.options & TCP_HAS_TIMESTAMPS) {
1356 			fReceivedTimestamp = segment.timestamp_value;
1362 	fSlowStartThreshold = (uint32)segment.advertised_window << fSendWindowShift;
1378 TCPEndpoint::_Spawn(TCPEndpoint* parent, tcp_segment_header& segment,
1409 	_PrepareReceivePath(segment);
1417 	segment.flags &= ~TCP_FLAG_SYNCHRONIZE;
1420 	return _Receive(segment, buffer);
1425 TCPEndpoint::_ListenReceive(tcp_segment_header& segment, net_buffer* buffer)
1431 	if (segment.flags & TCP_FLAG_RESET)
1433 	if (segment.flags & TCP_FLAG_ACKNOWLEDGE)
1435 	if ((segment.flags & TCP_FLAG_SYNCHRONIZE) == 0)
1448 		segment, buffer);
1453 TCPEndpoint::_SynchronizeSentReceive(tcp_segment_header &segment,
1458 	if ((segment.flags & TCP_FLAG_ACKNOWLEDGE) != 0
1459 		&& (fInitialSendSequence >= segment.acknowledge
1460 			|| fSendMax < segment.acknowledge))
1463 	if (segment.flags & TCP_FLAG_RESET) {
1468 	if ((segment.flags & TCP_FLAG_SYNCHRONIZE) == 0)
1471 	fSendUnacknowledged = segment.acknowledge;
1472 	_PrepareReceivePath(segment);
1474 	if (segment.flags & TCP_FLAG_ACKNOWLEDGE) {
1482 	segment.flags &= ~TCP_FLAG_SYNCHRONIZE;
1485 	return _Receive(segment, buffer) | IMMEDIATE_ACKNOWLEDGE;
1490 TCPEndpoint::_Receive(tcp_segment_header& segment, net_buffer* buffer)
1492 	uint32 advertisedWindow = (uint32)segment.advertised_window
1497 	// (known as header prediction - the segment must not change the window,
1501 		&& segment.AcknowledgeOnly()
1502 		&& fReceiveNext == segment.sequence
1505 		_UpdateTimestamps(segment, segmentLength);
1508 			// this is a pure acknowledge segment - we're on the sending end
1509 			if (fSendUnacknowledged < segment.acknowledge
1510 				&& fSendMax >= segment.acknowledge) {
1511 				_Acknowledged(segment);
1514 		} else if (segment.acknowledge == fSendUnacknowledged
1518 			if (_AddData(segment, buffer))
1521 			return KEEP | ((segment.flags & TCP_FLAG_PUSH) != 0
1527 	// processing of the incoming segment
1533 		if (!segment_in_sequence(segment, segmentLength, fReceiveNext,
1535 			TRACE("  Receive(): segment out of window, next: %lu wnd: %lu",
1537 			if ((segment.flags & TCP_FLAG_RESET) != 0) {
1545 	if ((segment.flags & TCP_FLAG_RESET) != 0) {
1548 		if (fLastAcknowledgeSent <= segment.sequence
1549 			&& tcp_sequence(segment.sequence) < (fLastAcknowledgeSent
1566 	if ((segment.flags & TCP_FLAG_SYNCHRONIZE) != 0
1568 			&& (fInitialReceiveSequence > segment.sequence
1569 				|| ((segment.flags & TCP_FLAG_ACKNOWLEDGE) != 0
1570 					&& (fSendUnacknowledged > segment.acknowledge
1571 						|| fSendMax < segment.acknowledge))))) {
1583 	int32 drop = (int32)(fReceiveNext - segment.sequence).Number();
1587 				&& (segment.flags & TCP_FLAG_FINISH) == 0)) {
1589 			segment.flags &= ~TCP_FLAG_FINISH;
1596 		segment.sequence += drop;
1601 	drop = (int32)(segment.sequence + buffer->size
1606 			// if we can accept data, or the segment is not what we'd expect,
1607 			// drop the segment (an immediate acknowledge is always triggered)
1608 			if (fReceiveWindow != 0 || segment.sequence != fReceiveNext)
1614 		if ((segment.flags & TCP_FLAG_FINISH) != 0) {
1619 		segment.flags &= ~(TCP_FLAG_FINISH | TCP_FLAG_PUSH);
1637 	if ((segment.flags & TCP_FLAG_ACKNOWLEDGE) != 0) {
1642 		if (fSendMax < segment.acknowledge)
1645 		if (segment.acknowledge < fSendUnacknowledged) {
1647 				&& (segment.flags & TCP_FLAG_FINISH) == 0) {
1650 				_DuplicateAcknowledge(segment);
1655 			// this segment acknowledges in flight data
1664 			if (fSendMax == segment.acknowledge)
1667 			if (segment.acknowledge > fSendQueue.LastSequence()
1691 				_Acknowledged(segment);
1695 	if (segment.flags & TCP_FLAG_URGENT) {
1710 	if ((bufferSize > 0 || (segment.flags & TCP_FLAG_FINISH) != 0)
1712 		notify = _AddData(segment, buffer);
1720 	if ((segment.flags & TCP_FLAG_FINISH) != 0) {
1764 	if (bufferSize > 0 || (segment.flags & TCP_FLAG_SYNCHRONIZE) != 0)
1767 	_UpdateTimestamps(segment, segmentLength);
1776 TCPEndpoint::SegmentReceived(tcp_segment_header& segment, net_buffer* buffer)
1783 		PrintAddress(buffer->destination), segment.flags, segment.sequence,
1784 		segment.acknowledge,
1785 		(uint32)segment.advertised_window << fSendWindowShift);
1786 	T(Receive(this, segment,
1787 		(uint32)segment.advertised_window << fSendWindowShift, buffer));
1792 			segmentAction = _ListenReceive(segment, buffer);
1796 			segmentAction = _SynchronizeSentReceive(segment, buffer);
1808 			segmentAction = _Receive(segment, buffer);
1863 TCPEndpoint::_ShouldSendSegment(tcp_segment_header& segment, uint32 length,
1867 		// Avoid the silly window syndrome - we only send a segment in case:
1868 		// - we have a full segment to send, or
1881 	if (segment.advertised_window > 0) {
1883 		uint32 window = (segment.advertised_window << fReceiveWindowShift)
1886 		// if we can advertise a window larger than twice the maximum segment
1893 	if ((segment.flags & (TCP_FLAG_SYNCHRONIZE | TCP_FLAG_FINISH
1901 	// there is no reason to send a segment just now
1926 	tcp_segment_header segment(_CurrentFlags());
1930 			segment.options |= TCP_HAS_TIMESTAMPS;
1931 			segment.timestamp_reply = fReceivedTimestamp;
1932 			segment.timestamp_value = tcp_now();
1935 		if ((segment.flags & TCP_FLAG_SYNCHRONIZE) != 0
1938 			segment.max_segment_size = fReceiveMaxSegmentSize;
1940 				segment.options |= TCP_HAS_WINDOW_SCALE;
1941 				segment.window_shift = fReceiveWindowShift;
1948 		segment.advertised_window = availableBytes >> fReceiveWindowShift;
1950 		segment.advertised_window = min_c(TCP_MAX_WINDOW, availableBytes);
1952 	segment.acknowledge = fReceiveNext.Number();
1956 		segment.flags |= TCP_FLAG_URGENT;
1957 		segment.urgent_offset = (fSendUrgentOffset - fSendNext).Number();
1962 		segment.urgent_offset = 0;
2002 			- tcp_options_length(segment);
2007 				segment.flags |= TCP_FLAG_FINISH;
2009 				segment.flags |= TCP_FLAG_PUSH;
2012 		// Determine if we should really send this segment
2013 		if (!force && !_ShouldSendSegment(segment, segmentLength,
2038 		segment.sequence = fSendNext.Number();
2044 			PrintAddress(buffer->destination), segment.flags, segment.sequence,
2045 			segment.acknowledge, segment.advertised_window,
2049 		T(Send(this, segment, buffer, fSendQueue.FirstSequence(),
2055 		status = add_tcp_header(AddressModule(), segment, buffer);
2064 		if (segment.flags & TCP_FLAG_SYNCHRONIZE) {
2065 			segment.options &= ~TCP_HAS_WINDOW_SCALE;
2066 			segment.max_segment_size = 0;
2070 		if (segment.flags & TCP_FLAG_FINISH)
2079 			+ ((uint32)segment.advertised_window << fReceiveWindowShift);
2085 			fSendNext = segment.sequence;
2091 		if (segment.flags & TCP_FLAG_ACKNOWLEDGE)
2092 			fLastAcknowledgeSent = segment.acknowledge;
2095 		segment.flags &= ~(TCP_FLAG_SYNCHRONIZE | TCP_FLAG_RESET
2162 TCPEndpoint::_Acknowledged(tcp_segment_header& segment)
2166 	fSendQueue.RemoveUntil(segment.acknowledge);
2167 	fSendUnacknowledged = segment.acknowledge;
2178 		if (segment.options & TCP_HAS_TIMESTAMPS)
2179 			_UpdateRoundTripTime(tcp_diff_timestamp(segment.timestamp_reply));
2348 	kprintf("    max segment size: %" B_PRIu32 "\n", fSendMaxSegmentSize);
2363 	kprintf("    max segment size: %" B_PRIu32 "\n", fReceiveMaxSegmentSize);