source: box/trunk/bin/bbackupd/Win32ServiceFunctions.cpp @ 2460

//***************************************************************
// From the book "Win32 System Services: The Heart of Windows 98
// and Windows 2000"
// by Marshall Brain
// Published by Prentice Hall
// Copyright 1995 Prentice Hall.
//
// This code implements the Windows API Service interface 
// for the Box Backup for Windows native port.
// Adapted for Box Backup by Nick Knight.
//***************************************************************

#ifdef WIN32

#include "Box.h"

#ifdef HAVE_UNISTD_H
        #include <unistd.h>
#endif
#ifdef HAVE_PROCESS_H
        #include <process.h>
#endif

extern void TerminateService(void);
extern unsigned int WINAPI RunService(LPVOID lpParameter);

// Global variables

TCHAR* gServiceName = TEXT("Box Backup Service");
SERVICE_STATUS gServiceStatus;
SERVICE_STATUS_HANDLE gServiceStatusHandle = 0;
HANDLE gStopServiceEvent = 0;
DWORD gServiceReturnCode = 0;

#define SERVICE_NAME "boxbackup"

void ShowMessage(char *s)
{
        MessageBox(0, s, "Box Backup Message", 
                MB_OK | MB_SETFOREGROUND | MB_DEFAULT_DESKTOP_ONLY);
}

void ErrorHandler(char *s, DWORD err)
{
        char buf[256];
        memset(buf, 0, sizeof(buf));
        _snprintf(buf, sizeof(buf)-1, "%s: %s", s,
                GetErrorMessage(err).c_str());
        BOX_ERROR(buf);
        MessageBox(0, buf, "Error", 
                MB_OK | MB_SETFOREGROUND | MB_DEFAULT_DESKTOP_ONLY);
        ExitProcess(err);
}

void WINAPI ServiceControlHandler( DWORD controlCode )
{
        switch ( controlCode )
        {
                case SERVICE_CONTROL_INTERROGATE:
                        break;

                case SERVICE_CONTROL_SHUTDOWN:
                case SERVICE_CONTROL_STOP:
                        Beep(1000,100);
                        TerminateService();
                        gServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
                        SetServiceStatus(gServiceStatusHandle, &gServiceStatus);

                        SetEvent(gStopServiceEvent);
                        return;

                case SERVICE_CONTROL_PAUSE:
                        break;

                case SERVICE_CONTROL_CONTINUE:
                        break;

                default:
                        if ( controlCode >= 128 && controlCode <= 255 )
                                // user defined control code
                                break;
                        else
                                // unrecognised control code
                                break;
        }

        SetServiceStatus( gServiceStatusHandle, &gServiceStatus );
}

// ServiceMain is called when the SCM wants to
// start the service. When it returns, the service
// has stopped. It therefore waits on an event
// just before the end of the function, and
// that event gets set when it is time to stop. 
// It also returns on any error because the
// service cannot start if there is an eror.

static char* spConfigFileName;

VOID ServiceMain(DWORD argc, LPTSTR *argv) 
{
        // initialise service status
        gServiceStatus.dwServiceType = SERVICE_WIN32;
        gServiceStatus.dwCurrentState = SERVICE_STOPPED;
        gServiceStatus.dwControlsAccepted = 0;
        gServiceStatus.dwWin32ExitCode = NO_ERROR;
        gServiceStatus.dwServiceSpecificExitCode = NO_ERROR;
        gServiceStatus.dwCheckPoint = 0;
        gServiceStatus.dwWaitHint = 0;

        gServiceStatusHandle = RegisterServiceCtrlHandler(gServiceName, 
                ServiceControlHandler);

        if (gServiceStatusHandle)
        {
                // service is starting
                gServiceStatus.dwCurrentState = SERVICE_START_PENDING;
                SetServiceStatus(gServiceStatusHandle, &gServiceStatus);

                // do initialisation here
                gStopServiceEvent = CreateEvent(0, TRUE, FALSE, 0);
                if (!gStopServiceEvent)
                {
                        gServiceStatus.dwControlsAccepted &= 
                                ~(SERVICE_ACCEPT_STOP | 
                                  SERVICE_ACCEPT_SHUTDOWN);
                        gServiceStatus.dwCurrentState = SERVICE_STOPPED;
                        SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
                        return;
                }

                HANDLE ourThread = (HANDLE)_beginthreadex(
                        NULL,
                        0,
                        RunService,
                        spConfigFileName,
                        CREATE_SUSPENDED,
                        NULL);

                SetThreadPriority(ourThread, THREAD_PRIORITY_LOWEST);
                ResumeThread(ourThread);

                // we are now running so tell the SCM
                gServiceStatus.dwControlsAccepted |= 
                        (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
                gServiceStatus.dwCurrentState = SERVICE_RUNNING;
                SetServiceStatus(gServiceStatusHandle, &gServiceStatus);

                // do cleanup here
                WaitForSingleObject(gStopServiceEvent, INFINITE);
                CloseHandle(gStopServiceEvent);
                gStopServiceEvent = 0;

                // service was stopped
                gServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
                SetServiceStatus(gServiceStatusHandle, &gServiceStatus);

                // service is now stopped
                gServiceStatus.dwControlsAccepted &= 
                        ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);

                gServiceStatus.dwCurrentState = SERVICE_STOPPED;

                if (gServiceReturnCode != 0)
                {
                        gServiceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
                        gServiceStatus.dwServiceSpecificExitCode = gServiceReturnCode;
                }

                SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
        }
}

int OurService(const char* pConfigFileName)
{
        spConfigFileName = strdup(pConfigFileName);

        SERVICE_TABLE_ENTRY serviceTable[] = 
        { 
                { SERVICE_NAME, (LPSERVICE_MAIN_FUNCTION) ServiceMain },
                { NULL, NULL }
        };
        BOOL success;

        // Register with the SCM
        success = StartServiceCtrlDispatcher(serviceTable);

        free(spConfigFileName);
        spConfigFileName = NULL;

        if (!success)
        {
                ErrorHandler("Failed to start service. Did you start "
                        "Box Backup from the Service Control Manager? "
                        "(StartServiceCtrlDispatcher)", GetLastError());
                return 1;
        }

        return 0;
}

int InstallService(const char* pConfigFileName, const std::string& rServiceName)
{
        if (pConfigFileName != NULL)
        {
                EMU_STRUCT_STAT st;

                if (emu_stat(pConfigFileName, &st) != 0)
                {
                        BOX_LOG_SYS_ERROR("Failed to open configuration file "
                                "'" << pConfigFileName << "'");
                        return 1;
                }

                if (!(st.st_mode & S_IFREG))
                {
        
                        BOX_ERROR("Failed to open configuration file '" <<
                                pConfigFileName << "': not a file");
                        return 1;
                }
        }

        SC_HANDLE scm = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);

        if (!scm) 
        {
                BOX_ERROR("Failed to open service control manager: " <<
                        GetErrorMessage(GetLastError()));
                return 1;
        }

        char cmd[MAX_PATH];
        GetModuleFileName(NULL, cmd, sizeof(cmd)-1);
        cmd[sizeof(cmd)-1] = 0;

        std::string cmdWithArgs(cmd);
        cmdWithArgs += " -s -S \"" + rServiceName + "\"";

        if (pConfigFileName != NULL)
        {
                cmdWithArgs += " \"";
                cmdWithArgs += pConfigFileName;
                cmdWithArgs += "\"";
        }

        std::string serviceDesc = "Box Backup (" + rServiceName + ")";

        SC_HANDLE newService = CreateService(
                scm, 
                rServiceName.c_str(),
                serviceDesc.c_str(),
                SERVICE_ALL_ACCESS, 
                SERVICE_WIN32_OWN_PROCESS, 
                SERVICE_AUTO_START, 
                SERVICE_ERROR_NORMAL, 
                cmdWithArgs.c_str(),
                0,0,0,0,0);

        DWORD err = GetLastError();
        CloseServiceHandle(scm);

        if (!newService) 
        {
                switch (err)
                {
                        case ERROR_SERVICE_EXISTS:
                        {
                                BOX_ERROR("Failed to create Box Backup "
                                        "service: it already exists");
                        }
                        break;

                        case ERROR_SERVICE_MARKED_FOR_DELETE:
                        {
                                BOX_ERROR("Failed to create Box Backup "
                                        "service: it is waiting to be deleted");
                        }
                        break;

                        case ERROR_DUPLICATE_SERVICE_NAME:
                        {
                                BOX_ERROR("Failed to create Box Backup "
                                        "service: a service with this name "
                                        "already exists");
                        }
                        break;

                        default:
                        {
                                BOX_ERROR("Failed to create Box Backup "
                                        "service: error " <<
                                        GetErrorMessage(GetLastError()));
                        }
                }

                return 1;
        }

        BOX_INFO("Created Box Backup service");
        
        SERVICE_DESCRIPTION desc;
        desc.lpDescription = "Backs up your data files over the Internet";
        
        if (!ChangeServiceConfig2(newService, SERVICE_CONFIG_DESCRIPTION,
                &desc))
        {
                BOX_WARNING("Failed to set description for Box Backup "
                        "service: " << GetErrorMessage(GetLastError()));
        }

        CloseServiceHandle(newService);

        return 0;
}

int RemoveService(const std::string& rServiceName)
{
        SC_HANDLE scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);

        if (!scm) 
        {
                BOX_ERROR("Failed to open service control manager: " <<
                        GetErrorMessage(GetLastError()));
                return 1;
        }

        SC_HANDLE service = OpenService(scm, rServiceName.c_str(), 
                SERVICE_ALL_ACCESS|DELETE);
        DWORD err = GetLastError();
        CloseServiceHandle(scm);

        if (!service)
        {
                if (err == ERROR_SERVICE_DOES_NOT_EXIST ||
                        err == ERROR_IO_PENDING) 
                        // hello microsoft? anyone home?
                {
                        BOX_ERROR("Failed to open Box Backup service: "
                                "not installed or not found");
                }
                else
                {
                        BOX_ERROR("Failed to open Box Backup service: " <<
                                GetErrorMessage(err));
                }
                return 1;
        }

        SERVICE_STATUS status;
        if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
        {
                err = GetLastError();
                if (err != ERROR_SERVICE_NOT_ACTIVE)
                {
                        BOX_WARNING("Failed to stop Box Backup service: " <<
                                GetErrorMessage(err));
                }
        }

        BOOL deleted = DeleteService(service);
        err = GetLastError();
        CloseServiceHandle(service);

        if (deleted)
        {
                BOX_INFO("Box Backup service deleted");
                return 0;
        }
        else if (err == ERROR_SERVICE_MARKED_FOR_DELETE)
        {
                BOX_ERROR("Failed to remove Box Backup service: "
                        "it is already being deleted");
        }
        else
        {
                BOX_ERROR("Failed to remove Box Backup service: " <<
                        GetErrorMessage(err));
        }

        return 1;
}

#endif // WIN32