Any way to know how many bytes will be sent on TCP before sending?

Question

I'm aware that the ::send within a Linux TCP server can limit the sending of the payload such that ::send needs to be called multiple times until the entire payload is sent.

i.e. Payload is 1024 bytes

sent_bytes = ::send(fd, ...) where sent_bytes is only 256 bytes so this needs to be called again.

Is there any way to know exactly how many bytes can be sent before sending? If the socket will allow for the entire message, or that the message will be fragmented and by how much?

Example Case

2 messages are sent to the same socket by different threads at the same time on the same tcp client via ::send(). In some cases where messages are large multiple calls to ::send() are required as not all the bytes are sent at the initial call. Thus, go with the loop solution until all the bytes are sent. The loop is mutexed so can be seen as thread safe, so each thread has to perform the sending after the other. But, my worry is that beacuse Tcp is a stream the client will receive fragments of each message and I was thinking that adding framing to each message I could rebuild the message on the client side, if I knew how many bytes are sent at a time.

Although the call to ::send() is done sequentially, is the any chance that the byte stream is still mixed?

Effectively, could this happen:

• Server Side
  • Message 1: "CiaoCiao"
  • Message 2: "HelloThere"
• Client Side
  • Received Message: "CiaoHelloCiaoThere"