/*
 * Service.xs
 */
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "ppport.h"
#define RETURNRESULT(x)         if ((x)){ XST_mYES(0); }\
                                else { XST_mNO(0); }\
                                XSRETURN(1)
#define SETIV(index,value) sv_setiv(ST(index), value)
#define SETPV(index,string) sv_setpv(ST(index), string)
/* constant function for exporting NT definitions. */
static long
constant(char *name)
{
    errno = 0;
    switch (*name) {
    case 'A':
        break;
    case 'B':
        break;
    case 'C':
        break;
    case 'D':
        break;
    case 'E':
        break;
    case 'F':
        break;
    case 'G':
        break;
    case 'H':
        break;
    case 'I':
        break;
    case 'J':
        break;
    case 'K':
        break;
    case 'L':
        break;
    case 'M':
        break;
    case 'N':
        break;
    case 'O':
        break;
    case 'P':
        break;
    case 'Q':
        break;
    case 'R':
        break;
    case 'S':
        if (strEQ(name, "SERVICE_WIN32_OWN_PROCESS"))
#ifdef SERVICE_WIN32_OWN_PROCESS
                return SERVICE_WIN32_OWN_PROCESS;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_WIN32_SHARE_PROCESS"))
#ifdef SERVICE_WIN32_SHARE_PROCESS
                return SERVICE_WIN32_SHARE_PROCESS;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_KERNEL_DRIVER"))
#ifdef SERVICE_KERNEL_DRIVER
                return SERVICE_KERNEL_DRIVER;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_FILE_SYSTEM_DRIVER"))
#ifdef SERVICE_FILE_SYSTEM_DRIVER
                return SERVICE_FILE_SYSTEM_DRIVER;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_INTERACTIVE_PROCESS"))
#ifdef SERVICE_INTERACTIVE_PROCESS
                return SERVICE_INTERACTIVE_PROCESS;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_STOPPED"))
#ifdef SERVICE_STOPPED
                return SERVICE_STOPPED;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_START_PENDING"))
#ifdef SERVICE_START_PENDING
                return SERVICE_START_PENDING;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_STOP_PENDING"))
#ifdef SERVICE_STOP_PENDING
                return SERVICE_STOP_PENDING;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_RUNNING"))
#ifdef SERVICE_RUNNING
                return SERVICE_RUNNING;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_CONTINUE_PENDING"))
#ifdef SERVICE_CONTINUE_PENDING
                return SERVICE_CONTINUE_PENDING;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_PAUSE_PENDING"))
#ifdef SERVICE_PAUSE_PENDING
                return SERVICE_PAUSE_PENDING;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_PAUSED"))
#ifdef SERVICE_PAUSED
                return SERVICE_PAUSED;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_ACCEPT_STOP"))
#ifdef SERVICE_ACCEPT_STOP
                return SERVICE_ACCEPT_STOP;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_ACCEPT_PAUSE_CONTINUE"))
#ifdef SERVICE_ACCEPT_PAUSE_CONTINUE
                return SERVICE_ACCEPT_PAUSE_CONTINUE;
#else
                goto not_there;
#endif  
        if (strEQ(name, "SERVICE_ACCEPT_SHUTDOWN"))
#ifdef SERVICE_ACCEPT_SHUTDOWN
                return SERVICE_ACCEPT_SHUTDOWN;
#else
                goto not_there;
#endif  
        break;
    case 'T':
        break;
    case 'U':
        break;
    case 'V':
        break;
    case 'W':
        break;
    case 'X':
        break;
    case 'Y':
        break;
    case 'Z':
        break;
    }
    errno = EINVAL;
    return 0;
not_there:
    errno = ENOENT;
    return 0;
}
MODULE = Win32::Service         PACKAGE = Win32::Service
PROTOTYPES: DISABLE
long
constant(name)
        char *name
    CODE:
        RETVAL = constant(name);
    OUTPUT:
        RETVAL
bool
StartService(lpHostName, lpServiceName)
        char *lpHostName
        char *lpServiceName
    CODE:
        {
            SC_HANDLE hSCManager, hSCService;
            RETVAL = FALSE;
            if (lpHostName && *lpHostName == '\0')
                lpHostName = NULL;
            if (lpServiceName && *lpServiceName != '\0') {
                hSCManager = OpenSCManagerA(lpHostName, NULL, SC_MANAGER_CONNECT);
                if (hSCManager != NULL) {
                    hSCService = OpenServiceA(hSCManager, lpServiceName, SERVICE_START);
                    if (hSCService != NULL)  {
                        RETVAL = StartService(hSCService, 0, NULL);
                        CloseServiceHandle(hSCService);
                    }
                    CloseServiceHandle(hSCManager);
                }
            }
        }
    OUTPUT:
        RETVAL
bool
StopService(lpHostName, lpServiceName)
        char *lpHostName
        char *lpServiceName
    CODE:
        {
            SERVICE_STATUS serviceStatus;
            SC_HANDLE hSCManager, hSCService;
            RETVAL = FALSE;
            if (lpHostName && *lpHostName == '\0')
                lpHostName = NULL;
            if (lpServiceName && *lpServiceName != '\0') {
                hSCManager = OpenSCManagerA(lpHostName, NULL, SC_MANAGER_CONNECT);
                if (hSCManager != NULL) {
                    hSCService = OpenServiceA(hSCManager, lpServiceName, SERVICE_STOP);
                    if (hSCService != NULL) {
                        RETVAL = ControlService(hSCService, SERVICE_CONTROL_STOP,
                                                &serviceStatus);
                        CloseServiceHandle(hSCService);
                    }
                    CloseServiceHandle(hSCManager);
                }
            }
        }
    OUTPUT:
        RETVAL
bool
GetStatus(lpHostName,lpServiceName,status)
        char *lpHostName
        char *lpServiceName
        SV *status
    CODE:
        {
            SERVICE_STATUS serviceStatus;
            SC_HANDLE hSCManager, hSCService;
            RETVAL = FALSE;
            if (!(status && SvROK(status) &&
                  (status = SvRV(status)) && SvTYPE(status) == SVt_PVHV))
                croak("third arg must be a HASHREF");
             
            if (lpHostName && *lpHostName == '\0')
                lpHostName = NULL;
            if (lpServiceName && *lpServiceName != '\0') {
                hSCManager = OpenSCManagerA(lpHostName, NULL, SC_MANAGER_CONNECT);
                if (hSCManager != NULL) {
                    hSCService = OpenServiceA(hSCManager, lpServiceName, SERVICE_INTERROGATE);
                    if (hSCService != NULL) {
                        RETVAL = ControlService(hSCService, SERVICE_CONTROL_INTERROGATE,
                                                &serviceStatus);
                        if (!RETVAL && GetLastError() == ERROR_SERVICE_NOT_ACTIVE) {
                            Zero(&serviceStatus, 1, SERVICE_STATUS);
                            serviceStatus.dwCurrentState = SERVICE_STOPPED;
                            RETVAL = TRUE;
                        }
                        CloseServiceHandle(hSCService);
                    }
                    CloseServiceHandle(hSCManager);
                    if (RETVAL) {
                        SV *sv;
                        sv = newSViv(serviceStatus.dwServiceType);
                        hv_store((HV*)status, "ServiceType", (I32)strlen("ServiceType"), sv, 0);
                         
                        sv = newSViv(serviceStatus.dwCurrentState);
                        hv_store((HV*)status, "CurrentState", (I32)strlen("CurrentState"), sv, 0);
                         
                        sv = newSViv(serviceStatus.dwControlsAccepted);
                        hv_store((HV*)status, "ControlsAccepted", (I32)strlen("ControlsAccepted"), sv, 0);
                         
                        sv = newSViv(serviceStatus.dwWin32ExitCode);
                        hv_store((HV*)status, "Win32ExitCode", (I32)strlen("Win32ExitCode"), sv, 0);
                         
                        sv = newSViv(serviceStatus.dwServiceSpecificExitCode);
                        hv_store((HV*)status, "ServiceSpecificExitCode", (I32)strlen("ServiceSpecificExitCode"), sv, 0);
                         
                        sv = newSViv(serviceStatus.dwCheckPoint);
                        hv_store((HV*)status, "CheckPoint", (I32)strlen("CheckPoint"), sv, 0);
                         
                        sv = newSViv(serviceStatus.dwWaitHint);
                        hv_store((HV*)status, "WaitHint", (I32)strlen("WaitHint"), sv, 0);
                    }
                }
            }
        }
    OUTPUT:
        RETVAL
bool    
PauseService(lpHostName,lpServiceName)
        char *lpHostName
        char *lpServiceName
    CODE:
        {
            SERVICE_STATUS serviceStatus;
            SC_HANDLE hSCManager, hSCService;
            RETVAL = FALSE;
            if (lpHostName && *lpHostName == '\0')
                lpHostName = NULL;
            if (lpServiceName && *lpServiceName != '\0') {
                hSCManager = OpenSCManagerA(lpHostName, NULL, SC_MANAGER_CONNECT);
                if (hSCManager != NULL) {
                    hSCService = OpenServiceA(hSCManager, lpServiceName, SERVICE_PAUSE_CONTINUE);
                    if (hSCService != NULL) {
                        RETVAL = ControlService(hSCService, SERVICE_CONTROL_PAUSE, &serviceStatus);
                        CloseServiceHandle(hSCService);
                    }
                    CloseServiceHandle(hSCManager);
                }
            }
        }
    OUTPUT:
        RETVAL
bool
ResumeService(lpHostName,lpServiceName)
        char *lpHostName
        char *lpServiceName
    CODE:
        {
            SERVICE_STATUS serviceStatus;
            SC_HANDLE hSCManager, hSCService;
            RETVAL = FALSE;
            if (lpHostName && *lpHostName == '\0')
                lpHostName = NULL;
            if (lpServiceName && *lpServiceName != '\0') {
                hSCManager = OpenSCManagerA(lpHostName, NULL, SC_MANAGER_CONNECT);
                if (hSCManager != NULL) {
                    hSCService = OpenServiceA(hSCManager, lpServiceName, SERVICE_PAUSE_CONTINUE);
                    if (hSCService != NULL) {
                        RETVAL = ControlService(hSCService, SERVICE_CONTROL_CONTINUE,
                                                &serviceStatus);
                        CloseServiceHandle(hSCService);
                    }
                    CloseServiceHandle(hSCManager);
                }
            }
        }
    OUTPUT:
        RETVAL
bool
GetServices(lpHostName, hv)
        char *lpHostName
        SV *hv
    CODE:
        {
            DWORD dwBytesNeeded, dwServicesReturned, dwResumeHandle, dwIndex;
            ENUM_SERVICE_STATUSA essA[1000];
            char szService[MAX_PATH+1];
            char szDisplay[MAX_PATH+1];
            LPSTR lpDisplayName, lpServiceName;
            SC_HANDLE hSCManager;
            SV *sv;
            RETVAL = FALSE;
            if (!(hv && SvROK(hv) &&
                  (hv = SvRV(hv)) && SvTYPE(hv) == SVt_PVHV))
                croak("second argument must be a HASHREF");
            if (lpHostName && *lpHostName == '\0')
                lpHostName = NULL;
            hSCManager = OpenSCManagerA(lpHostName, NULL, SC_MANAGER_CONNECT|SC_MANAGER_ENUMERATE_SERVICE);
            if (hSCManager != NULL) {
                dwResumeHandle = 0;
                dwBytesNeeded = 0;
                dwServicesReturned = 0;
                while (EnumServicesStatusA(hSCManager, SERVICE_WIN32,
                                           SERVICE_ACTIVE | SERVICE_INACTIVE,
                                           essA, sizeof(essA), &dwBytesNeeded,
                                           &dwServicesReturned,
                                           &dwResumeHandle) == TRUE
                       || GetLastError() == ERROR_MORE_DATA)
                {
                    lpServiceName = szService;
                    lpDisplayName = szDisplay;
                    for (dwIndex = 0; dwIndex < dwServicesReturned; ++dwIndex) {
                        lpServiceName = essA[dwIndex].lpServiceName;
                        lpDisplayName = essA[dwIndex].lpDisplayName;
                        sv = newSVpv(lpServiceName, 0);
                        hv_store((HV*)hv, lpDisplayName,
                                 (I32)strlen(lpDisplayName), sv, 0);
                    }
                    if (dwResumeHandle == 0) {
                        RETVAL = TRUE;
                        break;
                    }
                }
                CloseServiceHandle(hSCManager);
            }
        }
    OUTPUT:
        RETVAL