Let's say that C is TCP client and S is TCP server.

C sent a TCP segment to S containing bytes 10, 11, 12 ... 20 (seq = 10). Segment reached S (it is not lost along the way). Is it possible that S send eg. ack 15, and that he drops all other bytes (15, 16, 17, 18, 19, 20), so that C must send another segment this time seq = 15.

In another words, is a "segment split" possible: that server accepts first part of bytes of one segment and drop the second part (due to eg. full buffer or something like that), and later take the second part of bytes from next segment? Or are segments always accepted completely?

I know that window size should prevent that type of situations: during the three way handshake, server will send his window size and client will not send segment that is greather than that. Server will later update his window size and client would continue to respect that.

But what about this: during three way handshake, server sends his window size eg 65000. By the time this client sends his segment, another client starts three way handshake and sends something big to server which gets server window size smaller. The second client gets notified about that, but the first don't. The first may send a segment which would fit into old window size but not the new one. So what happens then?

  • 1
    There is no such thing as a TCP client or server. TCP creates connections of peers. The client/server concept is an application concept – Ron Maupin Oct 9 '16 at 18:14
  • Also note that the receive window and buffer is per-connection or, not per-server. Receiving a packet on one connection does not use the buffer of the other one. – marctxk Oct 10 '16 at 11:54
  • Did any answer help you? if so, you should accept the answer so that the question doesn't keep popping up forever, looking for an answer. – Ron Maupin Jul 16 '17 at 3:51

I think you are mixing bytes and sequence numbers. Sequence number is per segment, regardless the size of the segment. So I am guessing your question is rather if a segment of segment number 10 is sent and contains 100 bytes, however if the server has the capacity to accept only 50 bytes. can it send accept half a segment ?

The answer is no. Intutively if as a reciever you get a segment but you cannot store all of it you have to discard the entire segment data. Because different parts of the segment have different importance.

For eg. you cannot keep the TCP header but leave behind the application layer data.

So no you cannot accept half segments

| improve this answer | |

segments may arrive to the destination in the different order due to f.e. asymmetric routing. Some segments may be lost and have to be re-transmitted. Server will NOT accept part of the segment- just whole segment or nothing. If the host loose the segment due to buffer overflow then it informs the source by sending ICMP message and TCP window will be reset back to start- they call it "slow start".

| improve this answer | |
  • Really if the sender transmits beyond the receive window, then the sender stack is broken except where the receiver has closed the window, i.e reduced it from a previously-advertised value. If the receiver suddenly has a memory allocation problem then it may close the window and this is allowed but not encouraged. If in this circumstance a packet is received I would expect that it would be held in a lower-layer buffer such as the NIC ring buffer and if that buffer filled then following packets would be discarded. I wouldn't expect any ICMP but would expect normal TCP congestion mechanisms. – marctxk Oct 10 '16 at 12:05

No, it is not possible to receive part of a segment. This is because the checksum calculation will be incorrect. As described in this blog post:

When TCP packet is received at the destination, the receiving TCP code also performs the TCP calculation and see if there’s a mismatch. If there is, it means there’s error in the packet and it will be discarded. The same validation logic used for IP header checksum validation can be used.

| improve this answer | |

I know this is a late answer, but I'm going answer this question.

I think it's actually possible in the "real-world-networks", When there're some middle-box-tcp-product between C and S.

C < - > FW < - > S

Ex, firewall or something like that.. it could act as below.

  1. Firewall received a segment.
  2. Firewall segmentize a segment it received, and Tx it as multiple segments.

For example, when FW receives "a" packet(10, 11, ... 20 (seq=10)), it could segmentize it to two packets (10, 11, ..., 14) & (15, 16, ..., 20). In this case, TCP checksum won't be a problem, because this FW would recreate the packet and recalculate the checksum.

So my conclusion is...

  1. As far as there's no middle-box-tcp-product between C and S, NO. Accepting half-sized segment of what C sent is not possible.
  2. BUT if there're some middle-box-tcp-products, YES. It's possible for S to receive half-size segment of what C sent.
| improve this answer | |

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.