It will be necessary to handle the synchronization at this level, by employing a mutex that each thread locks before sending its message and unlocking it only after the entire message is sent. Sent to the same socket by different threads Not only there's a chance of that, it is pretty much going to be a certainty, at one point or another. 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.Īlthough the call to ::send() is done sequentially, is the any chance that the byte stream is still mixed?Īlthough the call to ::send() is done sequentially, is the any chance that The loop is mutexed so can be seen as thread safe, so each thread has to perform the sending after the other. Thus, go with the loop solution until all the bytes are sent. In some cases where messages are large multiple calls to ::send() are required as not all the bytes are sent at the initial call. 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?Ģ messages are sent to the same socket by different threads at the same time on the same tcp client via ::send(). ) where sent_bytes is only 256 bytes so this needs to be called again. 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.

Install asterisk cdr viewer