Is non-blocking socket really non-blocking when used with blocking select()?

Question

This is rather theoretical question. If sockets I/O (either read or write) is set to O_NONBLOCK, but then this socket is set in fd_set to select() which blocks (waiting for an event the file descriptor become either readable or writable), then that socket is blocking anyway (due to the select())?

Why would I set the socket to be non-blocking, when even the blocking (default) version once become readable (or writable) (thanks to select()), won't block, because the select() said it has data to read (or write) and thus the socket is able to perform its operation with that data without blocking. So why to bother setting socket non-blocking when select() blocks anyway?

An example of having non-block sockets, but in conjuction with blocking select():

#include <unp.h>

void str_cli(FILE *fp, int sockfd)
{
    int flags, maxfd, stdineof;

    fd_set rset, wset;

    ssize_t nbytes, nactual;
    //struct bufpos { char *read_ptr, *write_ptr; };
    struct bufpos ipos, opos;
    char inbuf[BSIZE], outbuf[BSIZE];

    //--//

    //set nonblocking flag for these fds:
    int nblkFds[3] = {sockfd, STDIN_FILENO, STDOUT_FILENO};
    for (int i = 0; i < 3; i++)
    {
        flags = Fcntl(nblkFds[i], F_GETFL, 0);
        Fcntl(nblkFds[i], F_SETFL, flags | O_NONBLOCK);
    }

    //initialize buffer positions
    ipos.write_ptr = ipos.read_ptr = inbuf;
    opos.write_ptr = opos.read_ptr = outbuf;

    stdineof = 0; //stdin
    maxfd = max(STDOUT_FILENO, sockfd) + 1;

    while (1)
    {
        FD_ZERO(&rset);
        FD_ZERO(&wset);
        //can read from stdin and readptr is not at the end of buffer
        if (stdineof == 0 && opos.read_ptr < &outbuf[BSIZE])
        {
            FD_SET(STDIN_FILENO, &rset);
        }
        //can read from socket and the readptr is not at then end of buffer
        if (ipos.read_ptr < &inbuf[BSIZE])
        {
            FD_SET(sockfd, &rset);
        }
        //difference in outbuf == data to write to socket
        if (opos.read_ptr != opos.write_ptr)
        {
            FD_SET(sockfd, &wset);
        }
        //difference in inbuf == data to write to file
        if (ipos.read_ptr != ipos.write_ptr)
        {
            FD_SET(STDOUT_FILENO, &wset);
        }

        Select(maxfd, &rset, &wset, NULL, NULL);

        if (FD_ISSET(STDIN_FILENO, &rset))
        {
            switch ((nbytes = read(STDIN_FILENO, opos.read_ptr, &outbuf[BSIZE] - opos.read_ptr)))
            {
            case -1:
                perror("read");
                if (errno != EWOULDBLOCK)
                {
                    die("read");
                }

            case 0:
                fprintf(stderr, "%s: EOF on stdin\n", nowtime());
                stdineof = 1;
                if (opos.write_ptr == opos.read_ptr)
                {
                    //everything was written to socket -> we won't be writing enything else -> close the connection by sending FIN
                    Shutdown(sockfd, SHUT_WR);
                }
                break;

            default:
                fprintf(stderr, "%s: read %ld bytes from stdin\n", nowtime(), nbytes);
                //move the read pointer with bytes writen
                opos.read_ptr += nbytes;
                //now those bytes could be writen to socket
                FD_SET(sockfd, &wset);
            }
        }

        if (FD_ISSET(sockfd, &rset))
        {
            switch ((nbytes = read(sockfd, ipos.read_ptr, &inbuf[BSIZE] - ipos.read_ptr)))
            {
            case -1:
                perror("read");
                if (errno != EWOULDBLOCK)
                {
                    die("read");
                }

            case 0:
                fprintf(stderr, "%s: EOF on socket\n", nowtime());
                if (stdineof)
                {
                    //normal termination (client EOF)
                    return;
                }
                else
                {
                    //RST from peer
                    die("str_cli: server terminated prematurely");
                }
                break;

            default:
                fprintf(stderr, "%s: read %ld bytes from socket\n", nowtime(), nbytes);
                //move the read pointer with bytes read
                ipos.read_ptr += nbytes;
                //those bytes could be writen to file
                FD_SET(STDOUT_FILENO, &wset);
            }
        }

        if (FD_ISSET(STDOUT_FILENO, &wset) && (nbytes = ipos.read_ptr - ipos.write_ptr) > 0)
        {
            //the stdout is writeable and there are some bytes to write
            switch ((nactual = write(STDOUT_FILENO, ipos.write_ptr, nbytes)))
            {
            case -1:
                perror("write");
                if (errno != EWOULDBLOCK)
                {
                    die("write");
                }
            default:
                fprintf(stderr, "%s: wrote %ld bytes to stdout\n", nowtime(), nactual);
                ipos.write_ptr += nactual;
                if (ipos.write_ptr == ipos.read_ptr)
                {
                    //back to beginning buffer if all was writen to stdout
                    ipos.write_ptr = ipos.read_ptr = inbuf;
                }
            }
        }

        if (FD_ISSET(sockfd, &wset) && ((nbytes = opos.read_ptr - opos.write_ptr) > 0))
        {
            //the socket is writeable and there are some bytes to write
            switch ((nactual = write(sockfd, opos.write_ptr, nbytes)))
            {
            case -1:
                perror("write");
                if (errno != EWOULDBLOCK)
                {
                    die("write");
                }

            default:
                fprintf(stderr, "%s wrote %ld bytes to socket\n", nowtime(), nactual);
                opos.write_ptr += nactual;
                if (opos.write_ptr == opos.read_ptr)
                {
                    //back to beginning buffer if all was send/writen to socket
                    opos.read_ptr = opos.write_ptr = outbuf;
                    if (stdineof)
                    {
                        //EOF, could send its FIN
                        Shutdown(sockfd, SHUT_WR);
                    }
                }
            }
        }
    }
}

Answer 1

This is rather theoretical question. If sockets I/O (either read or write) is set to O_NONBLOCK, but then this socket is set in fd_set to select() which blocks (waiting for an event the file descriptor become either readable or writable), then that socket is blocking anyway (due to the select())?

The select is blocking. The socket is still non-blocking.

Why would I set the socket to be non-blocking, when even the blocking (default) version once become readable (or writable) (thanks to select()), won't block, because the select() said it has data to read (or write) and thus the socket is able to perform its operation with that data without blocking.

No, no, no! That is not a safe assumption. There is no guarantee that a subsequent read or write will not block. You must set the socket non-blocking if you need a future guarantee that a later operation will not block.

So why to bother setting socket non-blocking when select() blocks anyway?

Because you don't want operations on the socket to block. The select function does not guarantee that a future operation won't block and people have gotten burnt by making that assumption in the past.

For example, you do select on a UDP socket and it says that a receive won't block. But before you call recv, the administrator enables UDP checksums which were previously disabled. Guess what, now your recv will block if the checksum was incorrect on the only received datagram.

Unless you think you could have foreseen every way something like that could happen, and you definitely can't, you must set the socket non-blocking if you do not wish it to block.

Answer 2

select ignores the non-blocking flag on the file descriptor because it doesn't make any sense for it to pay attention to it.

• select is (potentially) checking mulitple file descriptor simultaneously, which might have different non-blocking flags. Which should it pay attention to?
• select has its own explicit timeout that determines if the call is blocking or non-blocking, or blocking for a limited time.

Arguably, having a non-blocking "state" flag you can set on a file descriptor is a bad design -- it would be better to specify on each call whether you want blocking or non-blocking. You can in fact do that if you use recv and send instead of read and write. All that setting "nonblocking" on a file descriptor really does is that it makes calls that don't otherwise specify blocking or nonblocking, nonblocking.