Confused about the behavior of function shutdown(fd, options)

Question

I'm testing my socket code which is used to transfer a text-based file, and I'm writing this code by referring the book Unix Network Programming (Chinese Version). Briefly I will paste some code below:

My serve_client function:

void serve_client(int connfd, const char *filename, size_t filesize)
{
    char header[1024];
    int fd = open(filename, O_RDONLY, 0);
    char *file_mapped;
    if (fd == -1)
    {
        char *not_found = "HTTP/1.1 404 NOT FOUND\r\n";
        send(connfd, not_found, strlen(not_found), 0);
    }
    else
    {
        sprintf(header, "HTTP/1.1 200 OK\r\n");
        sprintf(header, "%sContent-Length: %u\r\n", header, filesize);
        sprintf(header, "%sContent-Type: text/plain; charset=utf-8\r\n\r\n", header);
        // send http response header
        send(connfd, header, strlen(header), 0);

        printf("Response headers:\n");
        printf("%s", header);

        file_mapped = (char *)mmap(0, filesize, PROT_READ, MAP_PRIVATE, fd, 0);
        close(fd);

        // send http response body
        send(connfd, file_mapped, filesize, 0);
        int unmapped = munmap(file_mapped, filesize);
        if (unmapped == -1)
        {
            perror("memory unmapped failed!");
            _exit(1);
        }
    }
}

There are several questions I would like to ask you guys:

1. After this serve_client() function successfully returns, I mean at least the data I need should be completely copied into the kernel buffer, to be sent in the near future. Am I right about this?

2. shutdown() function is called as below:

   serve_client(connfd, path, st.st_size);
   shutdown(connfd, SHUT_WR); 
   // thread or process ends
   

I check the tips mentioned in this book, it says that this function with this option SHUT_WR will cause the data remained in kernel buffer firstly to be sent and then the final FIN. Is that right?

3. I capture the data sent and received with WireShark, as the photo illustrated below: https://i.sstatic.net/7FIoo.jpg I saw that the RST arrived, before all the data showed up. which failed the client e.g. wget or just web access. Any advice would be great.

Now I worked around this issue by doing this, letting the client close the connection and server waits for the FIN arrives. It works. But still, not what I want. :(

while (1)
{
    ssize_t bytes_read = recv(connfd, buf, 1024, 0);
    if (bytes_read > 0)
    {
        continue;
    }
    else if (bytes_read == 0)
    {
        close(connfd);
        break;
    }
    else
    {
        // < 0
        // handle error
        close(connfd);
        break;
    }
} 

EDIT Sorry for the misunderstanding this question caused, the dump showed the RST sent from the server, which is like what I've been told, the process exited prematurely. That's the reason the previous code won't work. Thank you for all your explanations, really helping me better understand the progress under the hood.

Answer 1

Ending a process implicitly close()s all file/socket descriptors. And this is the problem. Closing after sending may cause data loss on the receiver side (depending on the TCP stack's implementation).

You need to implement an application level protocol having the client acknowledge reception of all data before the server may close the socket.

To summarise: Using closure of a socket as part of the application level protocol is not reliable. Do not do this.