ppoll on solaris

this code compiles in Linux but not Solaris, because apparently ppoll() is Linux specific (I get an undefined symbol error in Solaris with GCC). Any help converting it? I don't think just using poll() is a good idea, but then again, I didn't write this code. (I got it from Writing a command line shell with C; trying to use ncurses/C for the first time)

#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

/** VT100 command to clear the screen. Use puts(VT100_CLEAR_SCREEN) to clear
 *  the screen. */
#define VT100_CLEAR_SCREEN "\033[2J"

/** VT100 command to reset the cursor to the top left hand corner of the
 *  screen. */
#define VT100_CURSOR_TO_ORIGIN "\033[H"

struct frame_s
{
    int x;
    int y;
    char *data;
};

static int draw_frame(struct frame_s *frame)
{
    int row;
    char *data;
    int attrib;

    puts(VT100_CLEAR_SCREEN);
    puts(VT100_CURSOR_TO_ORIGIN);

    for (row = 0, data = frame->data; row  < frame->y; row++, data += frame->x)
    {
        /*  0 for normal, 1 for bold, 7 for reverse. */
        attrib = 0;

        /*  The VT100 commands to move the cursor, set the attribute, and the
         *  actual f开发者_如何学JAVArame line. */
        fprintf(stdout, "\033[%d;%dH\033[0m\033[%dm%.*s", row + 1, 0, attrib, frame->x, data);
        fflush(stdout);
    }

    return (0);
}

int main(void)
{
    const struct timespec timeout = { .tv_sec = 1, .tv_nsec = 0 };
    struct frame_s frame;
    struct termios tty_old;
    struct termios tty_new;
    unsigned char line[128];
    unsigned int count = 0;
    int ret;
    struct pollfd fds[1];
    sigset_t sigmask;
    struct tm *tp;
    time_t current_time;

    /*  Set up a little frame. */
    frame.x = 80;
    frame.y = 5;
    frame.data = malloc(frame.x * frame.y);

    if (frame.data == NULL)
    {
        fprintf(stderr, "No memory\n");
        exit (1);
    }

    memset(frame.data, ' ', frame.x * frame.y);

    /*  Get the terminal state. */
    tcgetattr(STDIN_FILENO, &tty_old);
    tty_new = tty_old;

    /*  Turn off "cooked" mode (line buffering) and set minimum characters
     *  to zero (i.e. non-blocking). */
    tty_new.c_lflag &= ~ICANON;
    tty_new.c_cc[VMIN] = 0;

    /*  Set the terminal attributes. */
    tcsetattr(STDIN_FILENO, TCSANOW, &tty_new);

    /*  Un-mask all signals while in ppoll() so any signal will cause
     *  ppoll() to return prematurely. */
    sigemptyset(&sigmask);

    fds[0].events = POLLIN;
    fds[0].fd = STDIN_FILENO;

    /*  Loop forever waiting for key presses. Update the output on every key
     *  press and every 1.0s (when ppoll() times out). */
    do
    {
        fds[0].revents = 0;
        ret = ppoll(fds, sizeof(fds) / sizeof(struct pollfd), &timeout, &sigmask);

        if (fds[0].revents & POLLIN)
        {
            ret = read(STDIN_FILENO, &line[count], sizeof(line) - count);

            if (ret > 0)
            {
                line[count + ret] = '\0';

                if (strcmp(&line[count], "\033[A") == 0)
                {
                    snprintf(frame.data, frame.x, "up");
                    count = 0;
                }
                else if (strcmp(&line[count], "\033[B") == 0)
                {
                    snprintf(frame.data, frame.x, "down");
                    count = 0;
                }
                else if (line[count] == '\n')
                {
                    snprintf(frame.data, frame.x, "entered: %s", line);
                    count = 0;
                }
                else
                {
                    count += ret;
                }
            }
        }

        /*  Print the current time to the output buffer. */
        current_time = time(NULL);
        tp = localtime(&current_time);
        strftime(&frame.data[1 * frame.x], frame.x, "%Y/%m/%d %H:%M:%S", tp);

        /*  Print the command line. */
        line[count] = '\0';
        snprintf(&frame.data[(frame.y - 1) * frame.x], frame.x, "$ %s", line);

        draw_frame(&frame);
    }
    while (1);

    /*  Restore terminal and free resources. */
    tcsetattr(STDIN_FILENO, TCSANOW, &tty_old);
    free(frame.data);

    return (0);
}

The reason you can replace the ppoll() with a poll() here at the moment is not because the signal mask provided to ppoll() is empty - this is actual the usual case - but because the signal mask prior to ppoll() is likely empty as well.

This is only possible because the shell currently does not try to handle any signals. As soon as you want to make the shell handle signals, you will need to use the following sequence:

/* Block all signals */
sigprocmask(SIG_SETMASK, all_signals);

/* Check and handle any signals that have occured. */
check_signals();

/* Wait for activity on a file descriptor or a signal */
ppoll(..., empty_set);

ppoll() is necessary here because otherwise there is a race condition - a signal may arrive between check_signals(); and the poll() call, which would be missed. Hence signals are blocked for this duration, then atomically unblocked in the ppoll().

Since ppoll() is a GNU extension which Solaris does not provide, you will need to change the code to use pselect(), which is a POSIX standard function.

To convert your code to use pselect(), replace the start of the loop with:

do
{
    fd_set rdset;
    int nfds = STDIN_FILENO + 1;

    FD_ZERO(&rdset);
    FD_SET(STDIN_FILENO, &rdset);
    ret = pselect(nfds, &rdset, NULL, NULL, &timeout, &sigmask);

    if (ret < 0) {
        if (errno == EINTR)
            continue;
        else
            break;
    }

    if (FD_ISSET(STDIN_FILENO, &rdset))
    {
        ret = read(STDIN_FILENO, &line[count], sizeof(line) - count);

    /* ... */

You can then remove the variable fds, since it is no longer needed.

Note that I've added code to check the return value of pselect() for error too - the old code should have been doing the same for ppoll().

You aren't using either sub-millisecond timeouts, a timeout that would overflow an (int), or a nonempty sigmask, so poll() is fine for this.