cmd/lms/main.cpp

/*******************************************************************************
 * Copyright (C) 2004-2008 Intel Corp. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  - Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *  - Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 *  - Neither the name of Intel Corp. nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "iatshareddata.h"
#include <cstdlib>
#include <cstdio>
#include <cerrno>
#include <csignal>
#include <syslog.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/file.h>
#include "types.h"
#include "Protocol.h"
#include "version.h"
#include "ATVersion.h"
#include "glue.h"

#ifdef __sun
#include <signal.h>
#endif

#ifdef DAEMON
#include "daemonize.h"
#endif //DAEMON

#define LOCK_PATH IATSTATERUNDIR
/* Change this to whatever your daemon is called */
#define DAEMON_PID_FILE "lms.pid"

#define QUICK_CONNECT_COUNT 30
#define SLEEP_TIMEOUT 30
#define QUICK_SLEEP_TIMEOUT 5


bool isRunning(int running = -1)
{
    static int _running = 0;
    if (running >= 0)
    {
        _running = running;
    }
    if (_running == 1)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void log(void *param, LPCTSTR message, WORD eventType)
{
#ifdef DEBUGLOG
    syslog((int)eventType, "%s", message);
#endif
}

//This needs to be global for termination action
Protocol prot;
int lock_pid_file_fd = -1;
glue plugin;

void exitcleanup()
{
    prot.Deinit();
    prot.DestroySockets();
    //syslog(EVENTLOG_INFORMATION_TYPE, "Service stopped\n");
    closelog();
    if (-1 != lock_pid_file_fd) {
        close(lock_pid_file_fd);
        lock_pid_file_fd = -1;
        unlink(LOCK_PATH DAEMON_PID_FILE);
    }

    plugin.deinit();
}

//Action termination
#ifdef __sun
extern "C"
#endif
void terminationHandler(int signum, siginfo_t *sinfo, void *dummy)
{
    PRINT("LMS Service received - Signal:%d   Err:(%d) Code:(%d)\n", signum, sinfo->si_errno, sinfo->si_code);
    if (isRunning()) {
        syslog(EVENTLOG_WARNING_TYPE, "Received termination signal (%d)\n", signum);

        isRunning(0);

        exit(EXIT_SUCCESS);
    }
}

void setTerminationHandler()
{
    int sigSet = 0;
    // Termination signal handler.
    struct sigaction terminateAction;
    // Set up the structure to specify the termination action.
    terminateAction.sa_sigaction = terminationHandler;
    sigemptyset(&terminateAction.sa_mask);
    terminateAction.sa_flags = SA_SIGINFO;
    sigSet &= sigaction(SIGTERM, &terminateAction, NULL);
    sigSet &= sigaction(SIGQUIT, &terminateAction, NULL);
    sigSet &= sigaction(SIGINT,  &terminateAction, NULL);
    sigSet &= sigaction(SIGHUP,  &terminateAction, NULL);
    sigSet &= sigaction(SIGPIPE, &terminateAction, NULL);
    sigSet &= sigaction(SIGALRM, &terminateAction, NULL);
    sigSet &= sigaction(SIGUSR1, &terminateAction, NULL);
    sigSet &= sigaction(SIGUSR2, &terminateAction, NULL);

    if (sigSet != 0) {
        syslog(EVENTLOG_WARNING_TYPE, "Failed to register terminate signal handler\n");
    }
}

/*
 *  return: 1 if the lock is real, 0 if not real, -1 on error
 **/
int lock_is_real(const char *lockfile)
{
    int lfp;
    char pid_buf[32];
    ssize_t count = 0;
    int lockpid;

    lfp = open(lockfile, O_RDONLY);
    if (lfp < 0) {
        syslog(LOG_ERR,
            "unable to open lock file %s, code=%d (%s)",
            lockfile, errno, strerror(errno));
        return -1;
    }

    count = read(lfp, pid_buf, sizeof(pid_buf)-1);
    if (count < 1) {
        syslog(LOG_ERR,
            "unable to read lock file %s, code=%d (%s)",
            lockfile, errno, strerror(errno));
        close(lfp);
        return -1;
    }
    close(lfp);
    pid_buf[count] = '\0';

    lockpid = atoi(pid_buf);
    if (lockpid <= 1) {
        syslog(LOG_ERR, "bad pid in lock file %s", lockfile);
        return 0;
    }

    /* See if the process still exists */
    if (kill(lockpid, 0) == 0) {
        /* Process exists, lock is real */
        return 1;
    }
    else {
        /* Process is gone */
        return 0;
    }
}

/**
 *  lock_pid_file - creates a pid file and writes current process pid into it
 *
 *  lockfile - name of a file to be created
 *
 *  return: 0 on success, -1 on fatal error, -2 on error
 **/
int lock_pid_file(const char *lockfile)
{
    int lfp = -1;
    size_t towrite = 0;
    ssize_t written = 0;
    int error = 0;
    int haserror = 0;
    char pid_buf[32];

    /* Create the lock file as the current user */
    if (lockfile && lockfile[0]) {
#ifdef __sun
        lfp = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0644);
        if (lfp < 0) {
            if (errno == EEXIST) {
                if (lock_is_real(lockfile)) {
                    syslog(LOG_ERR,
                    "The LMS service is already running!");
                }
                else {
                    unlink(lockfile);
                }
                return -2;
            }
            else {
                syslog(LOG_ERR,
                    "unable to lock file %s, code=%d (%s)",
                    lockfile, errno, strerror(errno));
                return -1;
            }
        }
        snprintf(pid_buf, sizeof(pid_buf), "%u", getpid());
        towrite = strnlen(pid_buf, 31);
        written = write(lfp, pid_buf, towrite);
#else
        lfp = open(lockfile, O_RDWR | O_CREAT, 0644);
        if (lfp < 0) {
            syslog(LOG_ERR,
                   "unable to create lock file %s, code=%d (%s)",
                   lockfile, errno, strerror(errno));
            return -1;
        }

        if (-1 == flock(lfp, LOCK_EX | LOCK_NB)) {
            error = errno;
            if (EWOULDBLOCK == errno) {
                syslog(LOG_ERR, "The LMS service is already running!");
                close(lfp);
            } else {
                syslog(LOG_ERR,
                       "unable to lock file %s, code=%d (%s)",
                       lockfile, error, strerror(error));
                close(lfp);
                unlink(lockfile);
                return -2;
            }
            return -1;
        }
        if (-1 == ftruncate(lfp, 0)) {
            syslog(LOG_ERR,
                   "unable to fruncate lock file %s, code=%d (%s)",
                   lockfile, errno, strerror(errno));
            close(lfp);
            unlink(lockfile);
            return -2;
        }
        snprintf(pid_buf, sizeof(pid_buf), "%u", getpid());
        towrite = strnlen(pid_buf, 31);
        written = write(lfp, pid_buf, towrite);
        if (-1 == written) {
            error = errno;
            haserror = 1;
        } else if (towrite != (size_t)written) {
            haserror = 1;
        } else if (-1 == fsync(lfp)) {
            error = errno;
            haserror = 1;
        }
        if (1 == haserror) {
            syslog(LOG_ERR,
                   "unable to write pid into lock file %s, code=%d (%s)",
                   lockfile, error, strerror(error));
            close(lfp);
            unlink(lockfile);
            return -2;
        }
#endif // __sun
        lock_pid_file_fd = lfp;
    }
    return 0;
}


int main(int argc, char **argv)
{
    bool alreadyFailed = false;
    bool firstLoop = true;
    bool init = false;
    int connectCount = 0;
    int lockresult = -1;

    if (ATVersion::ShowVersionIfArg(argc, const_cast<const char **>(argv), VER_PRODUCTVERSION_STR)) {
        return 0;
    }

    umask(022);

    openlog("LMS", LOG_CONS, LOG_DAEMON);

#ifdef DAEMON
    daemonize();
#else
    setTerminationHandler();
#endif

    lockresult = lock_pid_file(LOCK_PATH DAEMON_PID_FILE);
    if (-2 == lockresult) {
        lockresult = lock_pid_file(LOCK_PATH DAEMON_PID_FILE);
    }
    if (0 != lockresult) {
        exit(EXIT_FAILURE);
    }

    isRunning(1);
    //syslog(EVENTLOG_INFORMATION_TYPE, "Service started\n");

    atexit(exitcleanup);

    plugin.init();

    while (isRunning()) {
        if (!prot.IsInitialized()) {
            if (init) {
#ifdef DEBUGLOG
                log(NULL, "LMS Service lost connection to AMT via HECI driver", EVENTLOG_ERROR_TYPE);
#endif
                init = false;
            }

            if (!prot.Init(log, NULL)) {
                if (firstLoop) {
                    syslog(EVENTLOG_ERROR_TYPE, "Cannot connect to AMT via HECI driver");
                    firstLoop = false;
                }
                // Failed to connect to the HECI driver.
                // Sleep for a second and try again.
                connectCount++;
                if (connectCount >= QUICK_CONNECT_COUNT) {
                    sleep(SLEEP_TIMEOUT);
                } else {
                    sleep(QUICK_SLEEP_TIMEOUT);
                }
                continue;
            }
            init = true;
            firstLoop = false;
            connectCount = 0;
#ifdef DEBUGLOG
            log(NULL, "Connected to AMT via HECI driver\n", EVENTLOG_INFORMATION_TYPE);
#endif
        }

        if (!prot.SocketsCreated()) {
            if (!prot.CreateSockets()) {
                if (!alreadyFailed) {
#ifdef DEBUGLOG
                    log(NULL, "LMS Service has a problem in achieving network resources.", EVENTLOG_ERROR_TYPE);
#endif
                    alreadyFailed = true;
                }
                continue;
            } else {
                alreadyFailed = false;
            }
        }
        // Select on active sockets (IANA ports and open connections).
        prot.Select();
    }

    return 0;
}