platform/server/main.cpp

// ------------------------------------------------------------------
// pion-platform: a C++ framework for building lightweight HTTP interfaces
// ------------------------------------------------------------------
// Copyright (C) 2007 Atomic Labs, Inc.  (http://www.atomiclabs.com)
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file COPYING or copy at http://www.boost.org/LICENSE_1_0.txt
//

#ifndef _MSC_VER
    #include <fcntl.h>
    #include <unistd.h>
    #include <sys/stat.h>
#endif

#ifdef _MSC_VER
    #include <windows.h>
    #include <direct.h>
#endif

// mlockall support on LINUX
#ifndef _MSC_VER
    #include <sys/mman.h>
    #include <string.h>
#endif

#include <pion/PionConfig.hpp>

#ifdef PION_HAVE_SSL
    #include <openssl/ssl.h>
//#ifdef _MSC_VER
//  #include <openssl/applink.c>
//#endif
#endif

#ifndef SYSCONFDIR
    #define SYSCONFDIR "/usr/local/etc"
#endif

#include <iostream>
#include <boost/filesystem/operations.hpp>
#include "PlatformConfig.hpp"
#include "../../net/utils/ShutdownManager.hpp"

using namespace std;
using namespace pion;
using namespace pion::net;
using namespace pion::platform;
using namespace pion::server;

// some forward declarations of functions used
void daemonize_server(void);
void argument_error(void);
int run(bool run_as_daemon, bool lock_memory, const std::string& platform_config_file);

int parse_args(int argc, char *argv[], bool& run_as_daemon, bool& lock_memory, std::string& platform_config_file)
{
    // get platform config file
    run_as_daemon = false;
    lock_memory = false;

#ifdef _MSC_VER
    platform_config_file = "config\\platform.xml";
#else
    platform_config_file = "/etc/pion/platform.xml";
    if (! boost::filesystem::exists(platform_config_file) )
        platform_config_file = std::string(SYSCONFDIR) + "/pion/platform.xml";
#endif

    for (int argnum=1; argnum < argc; ++argnum) {
        if (argv[argnum][0] == '-') {
            if (argv[argnum][1] == 'D') {
                run_as_daemon = true;
            } else if (argv[argnum][1] == 'M') {
                lock_memory = true;
            } else if (argv[argnum][1] == 'c' && argv[argnum][2] == '\0' && argnum+1 < argc) {
                platform_config_file = boost::filesystem::system_complete(argv[++argnum]).normalize().file_string();
            } else if (strncmp(argv[argnum], "--version", 9) == 0) {
                std::cout << "pion version " << PION_VERSION << std::endl;
                return 1;
            } else {
                argument_error();
                return 1;
            }
        } else {
            argument_error();
            return 1;
        }
    }

    return 0;
}

#ifdef _MSC_VER
#define SVCNAME TEXT("Pion")

bool                    g_lock_memory = false;
std::string             g_platform_config_file;

SERVICE_STATUS          gSvcStatus; 
SERVICE_STATUS_HANDLE   gSvcStatusHandle;

void report_service_status( DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint );

void WINAPI service_control_handler( DWORD dwCtrl )
{
    // Handle the requested control code. 
    switch(dwCtrl) {  
    case SERVICE_CONTROL_STOP: 
    case SERVICE_CONTROL_SHUTDOWN:
        report_service_status(SERVICE_STOP_PENDING, NO_ERROR, 0);
        // Signal the Pion to shutdown.
        main_shutdown_manager.shutdown();
        return;

    case SERVICE_CONTROL_INTERROGATE: 
        // Fall through to send current status.
        break; 

    default: 
        break;
    } 

   report_service_status(gSvcStatus.dwCurrentState, NO_ERROR, 0);
}

void report_service_status( DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint )
{
    static DWORD dwCheckPoint = 1;

    // Fill in the SERVICE_STATUS structure.
    gSvcStatus.dwCurrentState = dwCurrentState;
    gSvcStatus.dwWin32ExitCode = dwWin32ExitCode;
    gSvcStatus.dwWaitHint = dwWaitHint;

    if (dwCurrentState == SERVICE_START_PENDING)
        gSvcStatus.dwControlsAccepted = 0;
    else 
        gSvcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;

    if ( (dwCurrentState == SERVICE_RUNNING) || (dwCurrentState == SERVICE_STOPPED) )
        gSvcStatus.dwCheckPoint = 0;
    else 
        gSvcStatus.dwCheckPoint = dwCheckPoint++;

    // Report the status of the service to the SCM.
    SetServiceStatus( gSvcStatusHandle, &gSvcStatus );
}

void service_report_event(LPTSTR szFunction) 
{
    //TODO
}

void WINAPI SvcMain( DWORD dwArgc, LPTSTR *lpszArgv )
{
    // Register the handler function for the service
    gSvcStatusHandle = RegisterServiceCtrlHandler( SVCNAME, service_control_handler );

    if( !gSvcStatusHandle ){ 
        PION_ASSERT( gSvcStatusHandle );
        service_report_event(TEXT("RegisterServiceCtrlHandler")); 
        return; 
    } 

    // These SERVICE_STATUS members remain as set here
    gSvcStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; 
    gSvcStatus.dwServiceSpecificExitCode = 0;    

    // Report initial status to the SCM
    report_service_status( SERVICE_START_PENDING, NO_ERROR, 3000 );

    bool run_as_daemon = false;
    bool lock_memory = false;
    
#ifdef _MSC_VER
    std::string platform_config_file("config\\platform.xml");
#else
    std::string platform_config_file("/etc/pion/platform.xml");
#endif

    run( true, g_lock_memory, g_platform_config_file );

    report_service_status( SERVICE_STOPPED, NO_ERROR, 0 );
}
#endif

int main (int argc, char *argv[])
{
    bool run_as_daemon = false;
    bool lock_memory = false;

#ifdef _MSC_VER
    std::string platform_config_file("config\\platform.xml");
#else
    std::string platform_config_file("/etc/pion/platform.xml");
#endif

    if(parse_args(argc, argv, run_as_daemon, lock_memory, platform_config_file) != 0)
        return 1;

#ifdef _MSC_VER
    if(run_as_daemon) {
        // running as Windows Service
        // initialize the global variables to be used by SrvMain
        g_platform_config_file = platform_config_file;
        g_lock_memory = lock_memory;

        SERVICE_TABLE_ENTRY DispatchTable[] = 
        { 
            { SVCNAME, (LPSERVICE_MAIN_FUNCTION) SvcMain }, 
            { NULL, NULL } 
        }; 
        // this call returns when the service has stopped. 
        // the process should simply terminate when the call returns.
        if (!StartServiceCtrlDispatcher( DispatchTable )) { 
            service_report_event(("StartServiceCtrlDispatcher")); 
        }
        return 0;
    }
#endif
    return run(run_as_daemon, lock_memory, platform_config_file);
}

int run (bool run_as_daemon, bool lock_memory, const std::string& platform_config_file)
{
    // initialize log system (use simple configuration)
    PionLogger pion_log(PION_GET_LOGGER("pion"));

    // This level might be overridden if there is a LogConfig file specified in the platform 
    // configuration (and if using a logging library that supports logging configuration.)
    PION_LOG_SETLEVEL_INFO(pion_log);
    PION_LOG_CONFIG_BASIC;

    // get logger for main() process
    PionLogger pion_main_log(PION_GET_LOGGER("pion.main"));

    if (run_as_daemon)
        daemonize_server();
    
    // setup signal handler
#ifdef _MSC_VER
    SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
#else
    signal(SIGPIPE, SIG_IGN);
    signal(SIGCHLD, SIG_IGN);
    signal(SIGTSTP, SIG_IGN);
    signal(SIGTTOU, SIG_IGN);
    signal(SIGTTIN, SIG_IGN);
    signal(SIGHUP, SIG_IGN);
    signal(SIGINT, handle_signal);
    signal(SIGTERM, handle_signal);
#endif
        
#ifdef PION_HAVE_SSL
    // initialize the OpenSSL library
    CRYPTO_malloc_init();
    SSL_library_init();
#endif

#ifndef _MSC_VER
    if (lock_memory)
        if (mlockall(MCL_CURRENT | MCL_FUTURE))
            PION_LOG_FATAL(pion_main_log, "Failed to lock memory: " << strerror(errno));
#endif

    // PlatformConfig destructor can throw exceptions, make sure we handle them
    try {
        PlatformConfig platform_cfg;
        try {
            // load the platform configuration
            platform_cfg.setConfigFile(platform_config_file);
            platform_cfg.openConfigFile();
            
            PION_LOG_INFO(pion_main_log, "Pion has started successfully (v" << PION_VERSION << ')');
#ifdef _MSC_VER
            if(run_as_daemon)
                report_service_status( SERVICE_RUNNING, NO_ERROR, 0 );
#endif
            // wait for shutdown
            main_shutdown_manager.wait();
        } catch (std::exception& e) {
            PION_LOG_FATAL(pion_main_log, e.what());
        }

        PION_LOG_INFO(pion_main_log, "Pion is shutting down");
    } catch (std::exception& e) {
        PION_LOG_FATAL(pion_main_log, e.what());
    }
    return 0;
}

#ifdef _MSC_VER
void daemonize_server(void)
{
    gSvcStatusHandle = RegisterServiceCtrlHandler( SVCNAME, service_control_handler );
    if( !gSvcStatusHandle )
    { 
        service_report_event(TEXT("RegisterServiceCtrlHandler")); 
        return; 
    }

    // These SERVICE_STATUS members remain as set here
    gSvcStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; 
    gSvcStatus.dwServiceSpecificExitCode = 0;    

    // Report initial status to the SCM
    report_service_status( SERVICE_START_PENDING, NO_ERROR, 20000 );

    // Windows tends to start the service in C:\windows\system32 folder
    // We need to change it to Pion's installation dir for Pion to work
    char exe_path[MAX_PATH];
    exe_path[0]=0;
    if( GetModuleFileName(NULL, exe_path, sizeof(exe_path)/sizeof(exe_path[0])) ) {
        char exe_dir[MAX_PATH], drive[MAX_PATH], filename[MAX_PATH];
        exe_dir[0]=0; drive[0] = 0; filename[0]=0;
        _splitpath( exe_path, drive, exe_dir, filename, NULL);
        SetCurrentDirectory( exe_dir );
    }
}
#else
void daemonize_server(void)
{
    // adopted from "Unix Daemon Server Programming"
    // http://www.enderunix.org/docs/eng/daemon.php
    
    // return early if already running as a daemon
    if(getppid()==1) return;
    
    // for out the process 
    int i = fork();
    if (i<0) exit(1);   // error forking
    if (i>0) exit(0);   // exit if parent
    
    // child (daemon process) continues here after the fork...
    
    // obtain a new process group
    setsid();
    
    // close all descriptors
    for (i=getdtablesize();i>=0;--i) close(i);
    
    // bind stdio to /dev/null
    i=open("/dev/null",O_RDWR); dup(i); dup(i);
    
    // restrict file creation mode to 0750
    umask(027);
}
#endif


void argument_error(void)
{
    std::cerr << "usage:   pion [-c PLATFORM_XML_FILE] [-D] [-M]" << std::endl;
}

---