source: nanoscale/trunk/server.c @ 6716

/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/* ======================================================================
 *  Copyright (c) 2004-2016  HUBzero Foundation, LLC
 * ----------------------------------------------------------------------
 *  See the file "license.terms" for information on usage and
 *  redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 * ======================================================================
 */
#define _GNU_SOURCE
#include <sys/socket.h>

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <syslog.h>
#include <unistd.h>
#include <fcntl.h>

#ifdef TCL_CONFIG
#include <tcl.h>
#endif

#include "config.h"
#include "server.h"

static const char *syslogLevels[] = {
    "emergency",                        /* System is unusable */
    "alert",                            /* Action must be taken immediately */
    "critical",                         /* Critical conditions */
    "error",                            /* Error conditions */
    "warning",                          /* Warning conditions */
    "notice",                           /* Normal but significant condition */
    "info",                             /* Informational */
    "debug",                            /* Debug-level messages */
};

static int numServers = 0;
/* Table of render servers representing services available to
 * clients.  A new instance is forked and executed each time a
 * new request is accepted. */
static RenderServer *serverTable[MAX_SERVERS];

static int debug = FALSE;
static pid_t serverPid;

static void
Help(const char *program)
{
    fprintf(stderr,
        "Syntax: %s [-d] [-f serversFile] [-x numVideoCards]\n", program);
    exit(1);
}

static void
InitLog()
{
    openlog("nanoscale", LOG_CONS | LOG_PID, LOG_USER);
}

void
SysLog(int priority, const char *path, int lineNum, const char* fmt, ...)
{
#define MSG_LEN (2047)
    char message[MSG_LEN+1];
    const char *s;
    int length;
    va_list lst;

    va_start(lst, fmt);
    s = strrchr(path, '/');
    if (s == NULL) {
        s = path;
    } else {
        s++;
    }
    if (serverPid != getpid()) {
        length = snprintf(message, MSG_LEN, "(%d) %s: %s:%d ",
                          serverPid, syslogLevels[priority], s, lineNum);
    } else {
        length = snprintf(message, MSG_LEN, "%s: %s:%d ",
                          syslogLevels[priority], s, lineNum);
    }
    length += vsnprintf(message + length, MSG_LEN - length, fmt, lst);
    message[MSG_LEN] = '\0';
    if (debug) {
        fprintf(stderr, "%s\n", message);
    } else {
        syslog(priority, message, length);
    }
}

RenderServer *
NewServer(const char *name)
{
    RenderServer *serverPtr;

    serverPtr = malloc(sizeof(RenderServer));
    memset(serverPtr, 0, sizeof(RenderServer));
    if (serverPtr == NULL) {
        ERROR("can't allocate structure: %s", strerror(errno));
        return NULL;
    }
    if (name != NULL) {
        serverPtr->name = strdup(name);
    }
    serverPtr->outputFd = STDOUT_FILENO;
    serverPtr->inputFd = STDIN_FILENO;
    serverPtr->combineLogs = TRUE;
    serverPtr->logStdout = TRUE;
    serverPtr->logStderr = TRUE;
    return serverPtr;
}

static void
InitServerTable()
{
    memset(serverTable, 0, sizeof(serverTable));
}

int
main(int argc, char **argv)
{
    int si;
#ifdef SA_NOCLDWAIT
    struct sigaction action;
#endif
    fd_set serverFds;
    int maxFd;                          /* Highest file descriptor in use. */
    char display[200];                  /* String used to manage the X
                                         * DISPLAY variable for each render
                                         * server instance. */
    int maxCards;                       /* Maximum number of video cards, each
                                         * represented by a different X
                                         * screen.  */
    int screenNum;                      /* Current X screen number. */
    const char *fileName;               /* Path to servers file. */

    serverPid = getpid();
    screenNum = 0;
    maxCards = 1;
    fileName = SERVERSFILE;
    debug = FALSE;

    strcpy(display, ":0.0");
    InitLog();
    InitServerTable();

    /* Process command line switches. */
    for (;;) {
        int c;
        int option_index = 0;
        struct option long_options[] = {
            // name, has_arg, flag, val
            { 0,0,0,0 },
        };

        c = getopt_long(argc, argv, "x:f:d", long_options, &option_index);
        if (c == -1) {
            break;
        }

        switch(c) {
        case 'x':                       /* Number of video cards */
            maxCards = strtoul(optarg, 0, 0);
            if ((maxCards < 1) || (maxCards > 10)) {
                fprintf(stderr, "Bad number of max videocards specified\n");
                return 1;
            }
            break;
        case 'd':                       /* Debug  */
            debug = TRUE;
            break;

        case 'f':                       /* Server file path. */
            fileName = strdup(optarg);
            break;

        default:
            fprintf(stderr,"Don't know what option '%c'.\n", c);
            Help(argv[0]);
            exit(1);
        }
    }

    if (!debug) {
        /* Detach this process from the controlling terminal process. The
         * current directory becomes /tmp and redirect stdin/stdout/stderr to
         * /dev/null. */
        if (daemon(0,0) < 0) {
            ERROR("Can't daemonize nanoscale: %s", strerror(errno));
            exit(1);
        }
    }
    serverPid = getpid();
    if (!ParseServersFile(fileName, &numServers, serverTable)) {
        ERROR("Exiting on invalid configuration");
        exit(1);
    }

    /* Create listening sockets */
    for (si = 0; si < numServers; si++) {
        int fd, bool;
        struct sockaddr_in addr;
        RenderServer *serverPtr;

        serverPtr = serverTable[si];

        /* Create a socket for listening. */
        fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (fd < 0) {
            ERROR("can't create listener socket for \"%s\": %s",
                  serverPtr->name, strerror(errno));
            exit(1);
        }
        /* If the render server instance should be killed, drop the socket
           address reservation immediately, don't linger. */
        bool = TRUE;
        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &bool, sizeof(bool)) < 0) {
            ERROR("can't create set socket option for \"%s\": %s",
                  serverPtr->name, strerror(errno));
            exit(1);
        }
        /* Bind this address to the socket. */
        addr.sin_family = AF_INET;
        addr.sin_port = htons(serverPtr->port);
        addr.sin_addr.s_addr = htonl(INADDR_ANY);
        if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
            ERROR("can't bind to socket for \"%s\": %s",
                  serverPtr->name, strerror(errno));
            exit(1);
        }
        /* Listen on the specified port. */
        if (listen(fd, 5) < 0) {
            ERROR("can't listen to socket for \"%s\": %s",
                  serverPtr->name, strerror(errno));
            exit(1);
        }
        serverPtr->listenerFd = fd;
        INFO("%s listening on %d", serverPtr->name, serverPtr->port);
    }

    if (numServers == 0) {
        ERROR("No servers designated.");
        exit(1);
    }
    signal(SIGPIPE, SIG_IGN);
#ifdef SA_NOCLDWAIT
    memset(&action, 0, sizeof(action));
    action.sa_flags = SA_NOCLDWAIT;
    sigaction(SIGCHLD, &action, 0);
#else
    signal(SIGCHLD, SIG_IGN);
#endif

    /* Build the array of servers listener file descriptors. */
    FD_ZERO(&serverFds);
    maxFd = -1;
    for (si = 0; si < numServers; si++) {
        RenderServer *serverPtr;

        serverPtr = serverTable[si];

        FD_SET(serverPtr->listenerFd, &serverFds);
        if (serverPtr->listenerFd > maxFd) {
            maxFd = serverPtr->listenerFd;
        }
    }

    for (;;) {
        fd_set readFds;

        /* Reset using the array of server file descriptors. */
        memcpy(&readFds, &serverFds, sizeof(serverFds));
        if (select(maxFd+1, &readFds, NULL, NULL, 0) <= 0) {
            ERROR("Select failed: %s", strerror(errno));
            break;                      /* Error on select. */
        }
        for (si = 0; si < numServers; si++) {
            RenderServer *serverPtr;
            pid_t child;
            int sock;
            socklen_t length;
            struct sockaddr_in newaddr;

            serverPtr = serverTable[si];
            if (!FD_ISSET(serverPtr->listenerFd, &readFds)) {
                continue;
            }
            /* Rotate the display's screen number.  If we have multiple video
             * cards, try to spread the jobs out among them.  */
            screenNum++;
            if (screenNum >= maxCards) {
                screenNum = 0;
            }
            /* Accept the new connection. */
            length = sizeof(newaddr);
#ifdef HAVE_ACCEPT4
            sock = accept4(serverPtr->listenerFd, (struct sockaddr *)&newaddr,
                           &length, SOCK_CLOEXEC);
#else
            sock = accept(serverPtr->listenerFd, (struct sockaddr *)&newaddr,
                          &length);
#endif
            if (sock < 0) {
                ERROR("Can't accept server \"%s\": %s", serverPtr->name,
                      strerror(errno));
                exit(1);
            }
#ifndef HAVE_ACCEPT4
            int flags = fcntl(sock, F_GETFD);
            flags |= FD_CLOEXEC;
            if (fcntl(sock, F_SETFD, flags) < 0) {
                ERROR("Can't set FD_CLOEXEC on socket \"%s\": %s",
                        serverPtr->name, strerror(errno));
                exit(1);
            }
#endif
            INFO("Connecting \"%s\" to %s\n", serverPtr->name,
                 inet_ntoa(newaddr.sin_addr));

            /* Fork the new process.  Connect I/O to the new socket. */
            child = fork();
            if (child < 0) {
                ERROR("Can't fork \"%s\": %s", serverPtr->name,
                      strerror(errno));
                continue;
            }
            if (child == 0) {           /* Child process. */
                int i;

                if ((!debug) && (setsid() < 0)) {
                    ERROR("Can't setsid \"%s\": %s", serverPtr->name,
                          strerror(errno));
                    exit(1);
                }
                if ((!debug) && ((chdir("/")) < 0)) {
                    ERROR("Can't change to root directory for \"%s\": %s",
                          serverPtr->name, strerror(errno));
                    exit(1);
                }
                if (serverPtr->combineLogs) {
                    char path[BUFSIZ];
                    int newFd;

                    sprintf(path, "%s/%s-%d.log", LOGDIR,
                        serverPtr->name, getpid());
                    if (serverPtr->logStdout) {
                        newFd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
                    } else {
                        newFd = open("/dev/null", O_WRONLY, 0600);
                    }
                    if (newFd < 0) {
                        ERROR("%s: can't open \"%s\": %s", serverPtr->name,
                              path, strerror(errno));
                        exit(1);
                    }
                    if (dup2(newFd, 1) < 0) {
                        ERROR("%s: can't dup stdout to \"%s\": %s",
                              serverPtr->name, path, strerror(errno));
                        exit(1);
                    }
                    if (dup2(newFd, 2) < 0) {
                        ERROR("%s: can't dup stderr to \"%s\": %s",
                              serverPtr->name, path, strerror(errno));
                        exit(1);
                    }
                } else {
                    char path[BUFSIZ];
                    int newFd;

                    sprintf(path, "%s/%s-%d.stdout", LOGDIR,
                        serverPtr->name, getpid());
                    if (serverPtr->logStdout) {
                        newFd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
                    } else {
                        newFd = open("/dev/null", O_WRONLY, 0600);
                    }
                    if (newFd < 0) {
                        ERROR("%s: can't open \"%s\": %s", serverPtr->name,
                              path, strerror(errno));
                        exit(1);
                    }
                    if (dup2(newFd, 1) < 0) {
                        ERROR("%s: can't dup stdout to \"%s\": %s",
                              serverPtr->name, path, strerror(errno));
                        exit(1);
                    }
                    sprintf(path, "%s/%s-%d.stderr", LOGDIR,
                        serverPtr->name, getpid());
                    if (serverPtr->logStderr) {
                        newFd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
                    } else {
                        newFd = open("/dev/null", O_WRONLY, 0600);
                    }
                    if (newFd < 0) {
                        ERROR("%s: can't open \"%s\": %s", serverPtr->name,
                              path, strerror(errno));
                        exit(1);
                    }
                    if (dup2(newFd, 2) < 0) {
                        ERROR("%s: can't dup stderr to \"%s\": %s",
                              serverPtr->name, path, strerror(errno));
                        exit(1);
                    }
                }
                /* Make sure to close syslog in case it is using one of
                 * the file descriptors we are about to close
                 */
                closelog();
                /* Dup the socket to descriptors, e.g. 3 and 4 */
                if (dup2(sock, serverPtr->inputFd) < 0)  { /* input */
                    ERROR("%s: can't dup socket to fd %d: %s",
                          serverPtr->name, serverPtr->inputFd,
                          strerror(errno));
                    exit(1);
                }
                /* If using a single descriptor for input and output, we don't
                 * need to call dup2 again
                 */
                if (serverPtr->outputFd != serverPtr->inputFd) {
                    if (dup2(sock, serverPtr->outputFd) < 0) { /* output */
                        ERROR("%s: can't dup socket to fd %d: %s",
                              serverPtr->name, serverPtr->outputFd,
                              strerror(errno));
                        exit(1);
                    }
                }
                /* Close all the other descriptors. */
                for (i = 3; i <= FD_SETSIZE; i++) {
                    if (i != serverPtr->inputFd &&
                        i != serverPtr->outputFd) {
                        close(i);
                    }
                }

                /* Set the screen number in the DISPLAY variable. */
                display[3] = screenNum + '0';
                setenv("DISPLAY", display, 1);
                /* Don't pollute child's environment with our library path.
                 * Library path should be explicitly set in config if needed.
                 */ 
                unsetenv("LD_LIBRARY_PATH");
                /* Set the configured environment */
                for (i = 0; i < serverPtr->numEnvArgs; i += 2) {
                    INFO("Env: %s=%s", serverPtr->envArgs[i],
                         serverPtr->envArgs[i+1]);
                    setenv(serverPtr->envArgs[i], serverPtr->envArgs[i+1], 1);
                }
                {
                    char *cmd;

                    cmd = MergeArgs(serverPtr->numCmdArgs, serverPtr->cmdArgs);
                    INFO("Executing %s: client=%s, \"%s\" in=%d out=%d on DISPLAY=%s",
                         serverPtr->name, inet_ntoa(newaddr.sin_addr),
                         cmd, serverPtr->inputFd, serverPtr->outputFd, display);
                    FreeArgs(cmd);
                    //closelog();
                    /* Replace the current process with the render server. */
                    execvp(serverPtr->cmdArgs[0], serverPtr->cmdArgs);
                    ERROR("Can't execute \"%s\": %s", serverPtr->cmdArgs[0],
                          strerror(errno));
                    exit(1);
                }
            } else {
                close(sock);
            }
        }
    }
    exit(1);
}