Lines Matching defs:segment
93 Receive(TCPEndpoint* endpoint, tcp_segment_header& segment, uint32 window,
99 fSequence(segment.sequence),
100 fAcknowledge(segment.acknowledge),
103 fFlags(segment.flags)
129 Send(TCPEndpoint* endpoint, tcp_segment_header& segment, net_buffer* buffer,
135 fSequence(segment.sequence),
136 fAcknowledge(segment.acknowledge),
140 fFlags(segment.flags)
360 segment_in_sequence(const tcp_segment_header& segment, int size,
363 tcp_sequence sequence(segment.sequence);
1140 // "SHOULD" be for at least every second full-size segment. (RFC 5681 �� 4.2)
1295 TCPEndpoint::_DuplicateAcknowledge(tcp_segment_header &segment)
1311 if ((segment.acknowledge - 1) > fRecover || (fCongestionWindow > fSendMaxSegmentSize &&
1317 fSendNext = segment.acknowledge;
1334 TCPEndpoint::_UpdateTimestamps(tcp_segment_header& segment,
1338 tcp_sequence sequence(segment.sequence);
1342 fReceivedTimestamp = segment.timestamp_value;
1377 TCPEndpoint::_AddData(tcp_segment_header& segment, net_buffer* buffer)
1379 if ((segment.flags & TCP_FLAG_FINISH) != 0) {
1382 fFinishReceivedAt = segment.sequence + buffer->size;
1385 fReceiveQueue.Add(buffer, segment.sequence);
1389 // Set or reset the finish flag on the current segment
1391 segment.flags &= ~TCP_FLAG_FINISH;
1393 segment.flags |= TCP_FLAG_FINISH;
1399 if ((segment.flags & TCP_FLAG_PUSH) != 0)
1407 TCPEndpoint::_PrepareReceivePath(tcp_segment_header& segment)
1409 fInitialReceiveSequence = segment.sequence;
1413 segment.sequence++;
1415 fReceiveNext = segment.sequence;
1416 fReceiveQueue.SetInitialSequence(segment.sequence);
1419 if (segment.max_segment_size > 0) {
1420 // The maximum size of a segment that a TCP endpoint really sends,
1423 fSendMaxSegmentSize = min_c(segment.max_segment_size,
1427 if (segment.options & TCP_HAS_WINDOW_SCALE) {
1429 fSendWindowShift = segment.window_shift;
1435 if (segment.options & TCP_HAS_TIMESTAMPS) {
1437 fReceivedTimestamp = segment.timestamp_value;
1441 if ((segment.options & TCP_SACK_PERMITTED) == 0)
1453 fSlowStartThreshold = (uint32)segment.advertised_window << fSendWindowShift;
1469 TCPEndpoint::_Spawn(TCPEndpoint* parent, tcp_segment_header& segment,
1499 _PrepareReceivePath(segment);
1507 segment.flags &= ~TCP_FLAG_SYNCHRONIZE;
1510 return _Receive(segment, buffer);
1515 TCPEndpoint::_ListenReceive(tcp_segment_header& segment, net_buffer* buffer)
1521 if (segment.flags & TCP_FLAG_RESET)
1523 if (segment.flags & TCP_FLAG_ACKNOWLEDGE)
1525 if ((segment.flags & TCP_FLAG_SYNCHRONIZE) == 0)
1538 segment, buffer);
1543 TCPEndpoint::_SynchronizeSentReceive(tcp_segment_header &segment,
1548 if ((segment.flags & TCP_FLAG_ACKNOWLEDGE) != 0
1549 && (fInitialSendSequence >= segment.acknowledge
1550 || fSendMax < segment.acknowledge))
1553 if (segment.flags & TCP_FLAG_RESET) {
1558 if ((segment.flags & TCP_FLAG_SYNCHRONIZE) == 0)
1561 fSendUnacknowledged = segment.acknowledge;
1562 _PrepareReceivePath(segment);
1564 if (segment.flags & TCP_FLAG_ACKNOWLEDGE) {
1572 segment.flags &= ~TCP_FLAG_SYNCHRONIZE;
1575 return _Receive(segment, buffer) | IMMEDIATE_ACKNOWLEDGE;
1580 TCPEndpoint::_Receive(tcp_segment_header& segment, net_buffer* buffer)
1583 if ((fFlags & FLAG_OPTION_TIMESTAMP) != 0 && (segment.flags & TCP_FLAG_RESET) == 0) {
1584 if ((segment.options & TCP_HAS_TIMESTAMPS) == 0)
1586 if ((int32)(fReceivedTimestamp - segment.timestamp_value) > 0
1587 && (fReceivedTimestamp - segment.timestamp_value) <= INT32_MAX)
1591 uint32 advertisedWindow = segment.AdvertisedWindow(fSendWindowShift);
1595 // (known as header prediction - the segment must not change the window,
1599 && segment.AcknowledgeOnly()
1600 && fReceiveNext == segment.sequence
1603 _UpdateTimestamps(segment, segmentLength);
1606 // this is a pure acknowledge segment - we're on the sending end
1607 if (fSendUnacknowledged < segment.acknowledge
1608 && fSendMax >= segment.acknowledge) {
1609 _Acknowledged(segment);
1612 } else if (segment.acknowledge == fSendUnacknowledged
1616 if (_AddData(segment, buffer))
1619 return KEEP | ((segment.flags & TCP_FLAG_PUSH) != 0
1625 // processing of the incoming segment
1631 if (!segment_in_sequence(segment, segmentLength, fReceiveNext,
1633 TRACE(" Receive(): segment out of window, next: %" B_PRIu32
1635 if ((segment.flags & TCP_FLAG_RESET) != 0) {
1643 if ((segment.flags & TCP_FLAG_RESET) != 0) {
1646 if (fLastAcknowledgeSent <= segment.sequence
1647 && tcp_sequence(segment.sequence) < (fLastAcknowledgeSent
1664 if ((segment.flags & TCP_FLAG_SYNCHRONIZE) != 0
1666 && (fInitialReceiveSequence > segment.sequence
1667 || ((segment.flags & TCP_FLAG_ACKNOWLEDGE) != 0
1668 && (fSendUnacknowledged > segment.acknowledge
1669 || fSendMax < segment.acknowledge))))) {
1681 int32 drop = (int32)(fReceiveNext - segment.sequence).Number();
1685 && (segment.flags & TCP_FLAG_FINISH) == 0)) {
1687 segment.flags &= ~TCP_FLAG_FINISH;
1694 segment.sequence += drop;
1699 // immediately acknowledge out-of-order segment to trigger fast-retransmit at the sender
1703 drop = (int32)(segment.sequence + buffer->size
1708 // if we can accept data, or the segment is not what we'd expect,
1709 // drop the segment (an immediate acknowledge is always triggered)
1710 if (fReceiveWindow != 0 || segment.sequence != fReceiveNext)
1716 if ((segment.flags & TCP_FLAG_FINISH) != 0) {
1721 segment.flags &= ~(TCP_FLAG_FINISH | TCP_FLAG_PUSH);
1735 // Our current send window is less than a segment wide, and the new one
1746 if ((segment.flags & TCP_FLAG_ACKNOWLEDGE) != 0) {
1751 if (fSendMax < segment.acknowledge)
1754 if (segment.acknowledge == fSendUnacknowledged) {
1756 && (segment.flags & TCP_FLAG_FINISH) == 0 && fSendUnacknowledged != fSendMax) {
1758 _DuplicateAcknowledge(segment);
1760 } else if (segment.acknowledge < fSendUnacknowledged) {
1763 // this segment acknowledges in flight data
1767 if (segment.acknowledge > fRecover) {
1775 if (fSendMax == segment.acknowledge)
1778 if (segment.acknowledge > fSendQueue.LastSequence()
1803 _Acknowledged(segment);
1811 if (segment.flags & TCP_FLAG_URGENT) {
1826 if ((bufferSize > 0 || (segment.flags & TCP_FLAG_FINISH) != 0)
1828 notify = _AddData(segment, buffer);
1836 if ((segment.flags & TCP_FLAG_FINISH) != 0) {
1880 if (bufferSize > 0 || (segment.flags & TCP_FLAG_SYNCHRONIZE) != 0)
1883 _UpdateTimestamps(segment, segmentLength);
1892 TCPEndpoint::SegmentReceived(tcp_segment_header& segment, net_buffer* buffer)
1899 PrintAddress(buffer->destination), segment.flags, segment.sequence,
1900 segment.acknowledge,
1901 (uint32)segment.advertised_window << fSendWindowShift);
1902 T(Receive(this, segment,
1903 (uint32)segment.advertised_window << fSendWindowShift, buffer));
1908 segmentAction = _ListenReceive(segment, buffer);
1912 segmentAction = _SynchronizeSentReceive(segment, buffer);
1924 segmentAction = _Receive(segment, buffer);
1986 tcp_segment_header segment(flags);
1990 segment.options |= TCP_HAS_TIMESTAMPS;
1991 segment.timestamp_reply = fReceivedTimestamp;
1992 segment.timestamp_value = tcp_now();
1995 if ((segment.flags & TCP_FLAG_SYNCHRONIZE) != 0
1998 segment.max_segment_size = fReceiveMaxSegmentSize;
2000 segment.options |= TCP_HAS_WINDOW_SCALE;
2001 segment.window_shift = fReceiveWindowShift;
2004 segment.options |= TCP_SACK_PERMITTED;
2009 segment.options |= TCP_HAS_SACK;
2012 memset(segment.sacks, 0, sizeof(segment.sacks));
2013 segment.sackCount = fReceiveQueue.PopulateSackInfo(fReceiveNext,
2014 maxSackCount, segment.sacks);
2022 segment.SetAdvertisedWindow(availableBytes, fReceiveWindowShift);
2024 segment.acknowledge = fReceiveNext.Number();
2028 segment.flags |= TCP_FLAG_URGENT;
2029 segment.urgent_offset = (fSendUrgentOffset - fSendNext).Number();
2034 segment.urgent_offset = 0;
2037 return segment;
2042 TCPEndpoint::_PrepareAndSend(tcp_segment_header& segment, net_buffer* buffer,
2049 segment.sequence = fSendNext.Number();
2056 PrintAddress(buffer->destination), segment.flags, segment.sequence,
2057 segment.acknowledge, segment.advertised_window,
2061 T(Send(this, segment, buffer, fSendQueue.FirstSequence(),
2066 status_t status = add_tcp_header(AddressModule(), segment, buffer);
2072 if (segment.flags & TCP_FLAG_SYNCHRONIZE) {
2073 segment.options &= ~TCP_HAS_WINDOW_SCALE;
2074 segment.max_segment_size = 0;
2078 if (segment.flags & TCP_FLAG_FINISH)
2091 fReceiveMaxAdvertised = fReceiveNext + segment.AdvertisedWindow(fReceiveWindowShift);
2097 && (segmentLength != 0 || (segment.flags & TCP_FLAG_SYNCHRONIZE) != 0)) {
2099 fRoundTripStartSequence = segment.sequence;
2102 if (segment.flags & TCP_FLAG_ACKNOWLEDGE) {
2103 fLastAcknowledgeSent = segment.acknowledge;
2112 TCPEndpoint::_ShouldSendSegment(tcp_segment_header& segment, uint32 length,
2119 // Avoid the silly window syndrome - we only send a segment in case:
2120 // - we have a full segment to send, or
2133 if (segment.advertised_window > 0) {
2135 uint32 window = segment.AdvertisedWindow(fReceiveWindowShift)
2138 // if we can advertise a window larger than twice the maximum segment
2145 if ((segment.flags & (TCP_FLAG_SYNCHRONIZE | TCP_FLAG_FINISH
2153 // there is no reason to send a segment just now
2164 tcp_segment_header segment = _PrepareSendSegment();
2170 && !_ShouldSendSegment(segment, 0, 0, 0))
2177 return _PrepareAndSend(segment, buffer, false);
2188 tcp_segment_header segment = _PrepareSendSegment();
2233 - tcp_options_length(segment);
2238 segment.flags |= TCP_FLAG_FINISH;
2240 segment.flags |= TCP_FLAG_PUSH;
2243 // Determine if we should really send this segment
2244 if (!force && !retransmit && !_ShouldSendSegment(segment, segmentLength,
2267 status = _PrepareAndSend(segment, buffer, retransmit);
2280 segment.flags &= ~(TCP_FLAG_SYNCHRONIZE | TCP_FLAG_RESET
2342 TCPEndpoint::_Acknowledged(tcp_segment_header& segment)
2345 B_PRIu32 "; max %" B_PRIu32, segment.acknowledge,
2348 ASSERT(fSendUnacknowledged <= segment.acknowledge);
2350 if (fSendUnacknowledged < segment.acknowledge) {
2351 fSendQueue.RemoveUntil(segment.acknowledge);
2353 uint32 bytesAcknowledged = segment.acknowledge - fSendUnacknowledged.Number();
2355 fSendUnacknowledged = segment.acknowledge;
2361 fRecover = segment.acknowledge - 1;
2398 _UpdateRoundTripTime(tcp_diff_timestamp(segment.timestamp_reply),
2400 } else if (fSendTime != 0 && fRoundTripStartSequence < segment.acknowledge) {
2605 kprintf(" max segment size: %" B_PRIu32 "\n", fSendMaxSegmentSize);
2621 kprintf(" max segment size: %" B_PRIu32 "\n", fReceiveMaxSegmentSize);