service.cpp

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2005 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#include "precomp.h"
#include "service.h"
#include "file.h"
#include "string_help.h"
#include "exception.h"
#include "thread.h"
#include <iostream>
#ifndef WIN32
#include <signal.h>
#endif

// CL_Service Construction:

CL_Service::CL_Service(const CL_String &service_name)
: service_name(service_name)
{
        if (instance != 0)
                throw CL_Exception(TEXT("More than one instance of CL_Service not allowed"));
        instance = this;
}

CL_Service::~CL_Service()
{
        instance = 0;
}

// CL_Service Attributes:

// CL_Service Operations:

int CL_Service::main(int argc, char **argv)
{
        std::vector<CL_String> args;
        for (int i=0; i<argc; i++)
                args.push_back(argv[i]);

#ifdef WIN32
        if (argc == 2 && args[1] == TEXT("-debug"))
        {
                SetConsoleCtrlHandler(&CL_Service::control_handler, TRUE);
                service_run(args);
                return 0;
        }
        else
        {
                std::cout << "Service parameters:" << std::endl;
//              std::cout << "  -install            - Install service" << std::endl;
//              std::cout << "  -uninstall          - Remove the service" << std::endl;
                std::cout << "  -debug              - Debug service" << std::endl;
                std::cout << std::endl;
                std::cout << "StartServiceCtrlDispatcher being called." << std::endl;
                std::cout << "This may take several seconds. Please wait." << std::endl;

                SERVICE_TABLE_ENTRY dispatch_table[] =
                {
                        { (LPTSTR) service_name.c_str(), (LPSERVICE_MAIN_FUNCTION) &CL_Service::service_thread_main },
                        { 0, 0 }
                };

                BOOL start_service = StartServiceCtrlDispatcher(dispatch_table);
                if (start_service == FALSE)
                        return 0;

                service_run(args);
                return 0;
        }
#else
        if (argc >= 3 && args[1] == TEXT("-daemon"))
        {
                try
                {
                        CL_File file(args[2], CL_File::create_always);

                        struct sigaction action;
                        memset(&action, 0, sizeof(struct sigaction));
                        action.sa_handler = &CL_Service::sig_term;
                        sigaction(SIGTERM, &action, 0);
                        memset(&action, 0, sizeof(struct sigaction));
                        action.sa_handler = &CL_Service::sig_hup;
                        sigaction(SIGHUP, &action, 0);

                        int pid = fork();
                        if (pid)
                        {
                                CL_StringA str_pid = CL_StringHelp::int_to_local8(pid);
                                file.write(str_pid.c_str(), str_pid.length());
                                file.write("\n", 1);
                                return pid;
                        }
                        else
                        {
                                file.close();
                                close(0);
                                close(1);
                                close(2);

                                // Starting service in seperate thread to avoid
                                // signals sent to this pid causing EINTR errors
                                // randomly in the service itself.
                                CL_Thread thread;
                                thread.start(this, &CL_Service::service_thread_main, args);
                                while (true)
                                {
                                        try
                                        {
                                                if (stop_event.wait())
                                                        break;
                                        }
                                        catch (CL_Exception e)
                                        {
                                        }
                                }
                                thread.join();
                                return 0;
                        }
                }
                catch (CL_Exception e)
                {
                        std::cout << "Unhandled exception: " << e.message.c_str() << std::endl;
                }
        }
        else if (argc == 2 && args[1] == TEXT("-debug"))
        {
                struct sigaction action;
                memset(&action, 0, sizeof(struct sigaction));
                action.sa_handler = &CL_Service::sig_term;
                sigaction(SIGTERM, &action, 0);
                memset(&action, 0, sizeof(struct sigaction));
                action.sa_handler = &CL_Service::sig_hup;
                sigaction(SIGHUP, &action, 0);
                memset(&action, 0, sizeof(struct sigaction));
                action.sa_handler = &CL_Service::sig_term;
                sigaction(SIGINT, &action, 0);
                
                // Starting service in seperate thread to avoid
                // signals sent to this pid causing EINTR errors
                // randomly in the service itself.
                CL_Thread thread;
                thread.start(this, &CL_Service::service_thread_main, args);
                while (true)
                {
                        try
                        {
                                if (stop_event.wait())
                                        break;
                        }
                        catch (CL_Exception e)
                        {
                        }
                }
                thread.join();
                return 0;
        }
        else
        {
                std::cout << "Service parameters:" << std::endl;
                std::cout << "  -daemon <pidfile>   - Start service as a unix daemon" << std::endl;
                std::cout << "  -debug              - Debug service" << std::endl;
                return 0;
        }
#endif
}

// CL_Service Implementation:

#ifdef WIN32
void CL_Service::service_thread_main(DWORD argc, LPTSTR *argv)
{
        if (instance == 0)
                return;

        std::vector<CL_String> args;
        for (int i=0; i<argc; i++)
                args.push_back(argv[i]);

        instance->service_run(args);
}

BOOL CL_Service::control_handler(DWORD ctrl_type)
{
        if (instance == 0)
                return FALSE;

        switch(ctrl_type)
        {
        case CTRL_BREAK_EVENT:  // use Ctrl+C or Ctrl+Break to simulate
        case CTRL_C_EVENT:      // SERVICE_CONTROL_STOP in debug mode
                std::cout << "Stopping service" << std::endl;
                instance->stop_event.set();
                return TRUE;

        default:
                std::cout << "Service::ControlHandler got unknown control type" << std::endl;
        }
        return FALSE;
}
#else
void CL_Service::service_thread_main(std::vector<CL_String> args)
{
        service_run(args);
}

void CL_Service::sig_term(int signal)
{
        if (instance)
                instance->stop_event.set();
}

void CL_Service::sig_hup(int signal)
{
        if (instance)
                instance->reload_event.set();
}
#endif

CL_Service *CL_Service::instance = 0;

---