Linux equivalent of WaitForSingleObject when reading a from console?

In my Windows application, I use WaitForSingleObject() when reading from a console:

HANDLE h = (void*)GetStdHandle(STD_INPUT_HANDLE);
char buf[512] = { 0 };
DWORD r = 0;

if (WaitForSingleObject(h, 3000) == WAIT_OBJECT_0)
{
	ReadConsole(h, buf, 512, &r, 0);
}

It looks like, in order to port the above code to Linux, I have to implement a conditional wait. How would I implement that? How can I check if some characters have been written to the console before reading them?

A close equivalent to the Windows code is as follows:

    int h = STDIN_FILENO;
    char buf[512] = { 0 };
    ssize_t r = 0;
    struct pollfd fds[1];
    int ret;

    fds[0].fd = h;
    fds[0].events = POLLIN;
    ret = poll(fds, 1, 3000);
    if (ret > 0 && (fds[0].revents & POLLIN) != 0)
    {
        r = read(h, buf, 512);
    }

This uses declarations from #include <unistd.h> and #include <poll.h>.

The poll() function waits for various specified events on specified file descriptors and has a timeout specified in milliseconds. A timeout value of -1 allows poll() to wait indefinitely (like a timeout value of INFINITE in calls to WaitForSingleObject() on Windows). On successful completion it returns a positive value indicating the number of pollfd structures that have events pending (i.e. have a non-zero .revents member). (It is also possible for some special events to be reported in the .revents member that were not asked for in the .events member.) On timeout it returns 0. On error it returns -1 and errno (defined by #include <errno.h>) contains the error number.

Special events in the .revents member include POLLERR (indicating an error has occurred on the file descriptor), POLLHUP (indicating a "hang-up" state on the file descriptor), and POLLNVAL (indicating the specified file descriptor is invalid).

The read() function call could block indefinitely, but if the file descriptor is something other than a regular file it typically does not block if the file descriptor is ready to be read (which has already been tested for in the results of the poll() call). (It is also possible to put the underlying file into non-blocking mode using the fcntl() function, in which case read() would return -1 and set errno to EAGAIN if it is not ready. poll() does not care about the non-blocking mode.) On success read() returns the number of bytes read which may be less than the requested amount. (For special files if there is some data available but less that the requested count, it typically returns what is available rather than blocking indefinitely to try and read the requested amount.) A return value of 0 should be treated as an "end-of-file" condition. (For some devices such as a terminal the "end-of-file" condition is merely a suggestion and is the result of some special input sequence on the terminal.) On failure read() returns -1 and sets errno to the error number.

For interactive input from a terminal, there are other things to consider such as the "termios" settings for the terminal. Amongst other things, these control the conditions when input from the terminal is ready to be read. In the default "canonical" mode, input becomes ready on a line-by-line basis. In "noncanonical" mode, input becomes ready depending on other parameters that control the minimum number of characters and/or the time elapsed since the previous read() or the previous received character. The "termios" settings can be queried and changed with the tcgetattr() and tcsetattr() functions declared by #include <termios.h> and only work on terminal devices. (The isatty() function declared by #include <unistd.h> can be used to test whether a file descriptor refers to a terminal.)

Note: Instead of poll() you may also encounter the more ancient select() or pselect() used for the same purpose of waiting for events on file descriptors. These pass the timeout parameter as a pointer to a struct timeval (for select()) or a pointer to a struct timespec (for pselect()). select() may update the struct timeval to indicate how much time was left when it returned (but pselect() does not modify its struct timespec).