C 套接字 send() 在 Main 函数返回之前不会发送所有数据

Question

Here is the succinct code:

int main(){
    /* here ellipsis socket connect malloc etc. */

    send(socket,buffer, 1024*1024*1024,0);
    return 1;
}

Question: If send() is blocked, no matter how large the buffer is, I think it will send all data before the main function returned. But actually, if the data large enough, the other socket end only receive a part of data which the send() function send. However, if I add this code before 'return 1;'

while(1){}

the other socket end receive intact data.

Does the send() is non_blocked? or something wrong with send() function?

thanks advance.

Answer 1

When blocking socket is used, send() function blocks until last data is delivered to queue of local TCP-stack.

So send() may return when part of the data is still queued in local TCP-stack. Because your process exits right after send() call, there can be undelivered data in local TCP stack during exit.

TCP stack may continue the data transfer after exit, if linger is enabled. Or TCP stack may reset the connection without any attempt to transfer undelivered data to the peer, if linger is disabled.

If you close the TCP connection gracefully when linger is enabled, then TCP-stack should (try to) deliver queued data to the peer.

Close the connection gracefully by adding close() call. And make sure that SO_LINGER is enabled with reasonable timeout:

send(socket,buffer, 1024*1024*1024,0);

const struct linger linger_val = { 1, 600 };
setsockopt(socket, SOL_SOCKET, SO_LINGER, &linger_val, sizeof(linger_val));

close(socket);
return 1;

Usually there is no need to change SO_LINGER. More information about SO_LINGER in man page of socket(7) :

SO_LINGER
              When enabled, a close(2) or shutdown(2) will not return until
              all queued messages for the socket have been successfully sent
              or the linger timeout has been reached.  Otherwise, the call
              returns immediately and the closing is done in the background.
              When the socket is closed as part of exit(2), it always
              lingers in the background.

Answer 2

Whit 0 as flag, send() is like write() function:

• https://linux.die.net/man/2/send
• https://linux.die.net/man/2/write

and for write() :

The number of bytes written may be less than count if, for example, there is insufficient space on the underlying physical medium, or the RLIMIT_FSIZE resource limit is encountered (see setrlimit(2)), or the call was interrupted by a signal handler after having written less than count bytes. (See also pipe(7).).

Check also this answer:

Blocking sockets: when, exactly, does "send()" return?

Hope this help

Answer 3

send() is blocking call, but it is blocked till all the data is pushed to sendbuffer . You can modify the program to exit when all the data is send from the socket. This is possible by reducing the sendbuffer size. you can use setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char*)send_buffer, send_buffer_sizeof);