/* Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/* ====================================================================

 * ApacheMonitor.c Simple program to manage and monitor Apache services.

 *

 * Contributed by Mladen Turk <mturk mappingsoft.com>

 *

 * 05 Aug 2001

 * ====================================================================

 */

#define _WIN32_WINNT 0x0500

#ifndef STRICT

#define STRICT

#endif

#ifndef OEMRESOURCE

#define OEMRESOURCE

#endif

#if defined(_MSC_VER) && _MSC_VER >= 1400

#define _CRT_SECURE_NO_DEPRECATE

#endif

#include <windows.h>

#include <windowsx.h>

#include <commctrl.h>

#include <objbase.h>

#include <shlobj.h>

#include <stdlib.h>

#include <stdio.h>

#include <WtsApi32.h>

#include <tchar.h>

#include "ApacheMonitor.h"

#ifndef AM_STRINGIFY

/** Properly quote a value as a string in the C preprocessor */

#define AM_STRINGIFY(n) AM_STRINGIFY_HELPER(n)

/** Helper macro for AM_STRINGIFY */

#define AM_STRINGIFY_HELPER(n) #n

#endif

#define OS_VERSION_WINNT    2

#define OS_VERSION_WIN2K    3

/* Should be enough */

#define MAX_APACHE_SERVICES 128

#define MAX_APACHE_COMPUTERS 32

#define WM_TRAYMESSAGE         (WM_APP+1)

#define WM_UPDATEMESSAGE       (WM_USER+1)

#define WM_MANAGEMESSAGE       (WM_USER+2)

#define WM_TIMER_REFRESH       10

#define WM_TIMER_RESCAN        11

#define SERVICE_APACHE_RESTART 128

#define XBITMAP                16

#define YBITMAP                16

#define MAX_LOADSTRING         100

#define REFRESH_TIME           2000           /* service refresh time (ms) */

#define RESCAN_TIME            20000          /* registry rescan time (ms) */

typedef struct _st_APACHE_SERVICE

{

    LPTSTR   szServiceName;

    LPTSTR   szDisplayName;

    LPTSTR   szDescription;

    LPTSTR   szImagePath;

    LPTSTR   szComputerName;

    DWORD    dwPid;

} ST_APACHE_SERVICE;

typedef struct _st_MONITORED_COMPUTERS

{

    LPTSTR  szComputerName;

    HKEY    hRegistry;

} ST_MONITORED_COMP;

/* Global variables */

HINSTANCE         g_hInstance = NULL;

TCHAR            *g_szTitle;          /* The title bar text */

TCHAR            *g_szWindowClass;    /* Window Class Name  */

HICON             g_icoStop;

HICON             g_icoRun;

UINT              g_bUiTaskbarCreated;

DWORD             g_dwOSVersion;

BOOL              g_bDlgServiceOn = FALSE;

BOOL              g_bConsoleRun = FALSE;

ST_APACHE_SERVICE g_stServices[MAX_APACHE_SERVICES];

ST_MONITORED_COMP g_stComputers[MAX_APACHE_COMPUTERS];

HBITMAP           g_hBmpStart, g_hBmpStop;

HBITMAP           g_hBmpPicture, g_hBmpOld;

BOOL              g_bRescanServices;

HWND              g_hwndServiceDlg;

HWND              g_hwndMain;

HWND              g_hwndStdoutList;

HWND              g_hwndConnectDlg;

HCURSOR           g_hCursorHourglass;

HCURSOR           g_hCursorArrow;

LANGID            g_LangID;

CRITICAL_SECTION  g_stcSection;

LPTSTR            g_szLocalHost;

/* locale language support */

static TCHAR *g_lpMsg[IDS_MSG_LAST - IDS_MSG_FIRST + 1];

void am_ClearServicesSt()

{

    int i;

    for (i = 0; i < MAX_APACHE_SERVICES; i++)

    {

        if (g_stServices[i].szServiceName) {

            free(g_stServices[i].szServiceName);

        }

        if (g_stServices[i].szDisplayName) {

            free(g_stServices[i].szDisplayName);

        }

        if (g_stServices[i].szDescription) {

            free(g_stServices[i].szDescription);

        }

        if (g_stServices[i].szImagePath) {

            free(g_stServices[i].szImagePath);

        }

        if (g_stServices[i].szComputerName) {

            free(g_stServices[i].szComputerName);

        }

    }

    memset(g_stServices, 0, sizeof(ST_APACHE_SERVICE) * MAX_APACHE_SERVICES);

}

void am_ClearComputersSt()

{

    int i;

    for (i = 0; i < MAX_APACHE_COMPUTERS; i++) {

        if (g_stComputers[i].szComputerName) {

            free(g_stComputers[i].szComputerName);

            RegCloseKey(g_stComputers[i].hRegistry);

        }

    }

    memset(g_stComputers, 0, sizeof(ST_MONITORED_COMP) * MAX_APACHE_COMPUTERS);

}

BOOL am_IsComputerConnected(LPTSTR szComputerName)

{

    int i = 0;

    while (g_stComputers[i].szComputerName != NULL) {

        if (_tcscmp(g_stComputers[i].szComputerName, szComputerName) == 0) {

            return TRUE;

        }

        ++i;

    }

    return FALSE;

}

void am_DisconnectComputer(LPTSTR szComputerName)

{

    int i = 0, j;

    while (g_stComputers[i].szComputerName != NULL) {

        if (_tcscmp(g_stComputers[i].szComputerName, szComputerName) == 0) {

            break;

        }

        ++i;

    }

    if (g_stComputers[i].szComputerName != NULL) {

        free(g_stComputers[i].szComputerName);

        RegCloseKey(g_stComputers[i].hRegistry);

        for (j = i; j < MAX_APACHE_COMPUTERS - 1; j++) {

            g_stComputers[j].szComputerName= g_stComputers[j+1].szComputerName;

            g_stComputers[j].hRegistry = g_stComputers[j+1].hRegistry;

        }

        g_stComputers[j].szComputerName = NULL;

        g_stComputers[j].hRegistry = NULL;

    }

}

void ErrorMessage(LPCTSTR szError, BOOL bFatal)

{

    LPVOID lpMsgBuf = NULL;

    if (szError) {

        MessageBox(NULL, szError, g_lpMsg[IDS_MSG_ERROR - IDS_MSG_FIRST],

                   MB_OK | (bFatal ? MB_ICONERROR : MB_ICONEXCLAMATION));

    }

    else {

        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |

                      FORMAT_MESSAGE_FROM_SYSTEM |

                      FORMAT_MESSAGE_IGNORE_INSERTS,

                      NULL, GetLastError(), g_LangID,

                      (LPTSTR) &lpMsgBuf, 0, NULL);

        MessageBox(NULL, (LPCTSTR)lpMsgBuf,

                   g_lpMsg[IDS_MSG_ERROR - IDS_MSG_FIRST],

                   MB_OK | (bFatal ? MB_ICONERROR : MB_ICONEXCLAMATION));

        LocalFree(lpMsgBuf);

    }

    if (bFatal) {

        PostQuitMessage(0);

    }

}

int am_RespawnAsUserAdmin(HWND hwnd, DWORD op, LPCTSTR szService,

                          LPCTSTR szComputerName)

{

    TCHAR args[MAX_PATH + MAX_COMPUTERNAME_LENGTH + 12];

    if (g_dwOSVersion < OS_VERSION_WIN2K) {

        ErrorMessage(g_lpMsg[IDS_MSG_SRVFAILED - IDS_MSG_FIRST], FALSE);

        return 0;

    }

    _sntprintf(args, sizeof(args) / sizeof(TCHAR),

               _T("%d \"%s\" \"%s\""), op, szService,

               szComputerName ? szComputerName : _T(""));

    if (!ShellExecute(hwnd, _T("runas"), __targv[0], args, NULL, SW_NORMAL)) {

        ErrorMessage(g_lpMsg[IDS_MSG_SRVFAILED - IDS_MSG_FIRST],

                     FALSE);

        return 0;

    }

    return 1;

}

BOOL am_ConnectComputer(LPTSTR szComputerName)

{

    int i = 0;

    HKEY hKeyRemote;

    TCHAR szTmp[MAX_PATH];

    while (g_stComputers[i].szComputerName != NULL) {

        if (_tcscmp(g_stComputers[i].szComputerName, szComputerName) == 0) {

            return FALSE;

        }

        ++i;

    }

    if (i > MAX_APACHE_COMPUTERS - 1) {

        return FALSE;

    }

    if (RegConnectRegistry(szComputerName, HKEY_LOCAL_MACHINE, &hKeyRemote)

            != ERROR_SUCCESS) {

        _sntprintf(szTmp, sizeof(szTmp) / sizeof(TCHAR),

                   g_lpMsg[IDS_MSG_ECONNECT - IDS_MSG_FIRST],

                   szComputerName);

        ErrorMessage(szTmp, FALSE);

        return FALSE;

    }

    else {

        g_stComputers[i].szComputerName = _tcsdup(szComputerName);

        g_stComputers[i].hRegistry = hKeyRemote;

        return TRUE;

    }

}

LPTSTR GetStringRes(int id)

{

    static TCHAR buffer[MAX_PATH];

    buffer[0] = 0;

    LoadString(GetModuleHandle(NULL), id, buffer, MAX_PATH);

    return buffer;

}

BOOL GetSystemOSVersion(LPDWORD dwVersion)

{

    OSVERSIONINFO osvi;

    /*

    Try calling GetVersionEx using the OSVERSIONINFOEX structure.

    If that fails, try using the OSVERSIONINFO structure.

    */

    memset(&osvi, 0, sizeof(OSVERSIONINFO));

    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

    if (!GetVersionEx(&osvi)) {

        return FALSE;

    }

    switch (osvi.dwPlatformId)

    {

    case VER_PLATFORM_WIN32_NT:

        if (osvi.dwMajorVersion >= 5)

            *dwVersion = OS_VERSION_WIN2K;

        else

            *dwVersion = OS_VERSION_WINNT;

        break;

    case VER_PLATFORM_WIN32_WINDOWS:

    case VER_PLATFORM_WIN32s:

    default:

        *dwVersion = 0;

        return FALSE;

    }

    return TRUE;

}

static VOID ShowNotifyIcon(HWND hWnd, DWORD dwMessage)

{

    NOTIFYICONDATA nid;

    int i = 0, n = 0;

    memset(&nid, 0, sizeof(nid));

    nid.cbSize = sizeof(NOTIFYICONDATA);

    nid.hWnd = hWnd;

    nid.uID = 0xFF;

    nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;

    nid.uCallbackMessage = WM_TRAYMESSAGE;

    while (g_stServices[i].szServiceName != NULL)

    {

        if (g_stServices[i].dwPid != 0) {

            ++n;

        }

        ++i;

    }

    if (dwMessage != NIM_DELETE)

    {

        if (n) {

            nid.hIcon = g_icoRun;

        }

        else {

            nid.hIcon = g_icoStop;

        }

    }

    else {

        nid.hIcon = NULL;

    }

    if (n == i && n > 0) {

        _tcscpy(nid.szTip, g_lpMsg[IDS_MSG_RUNNINGALL - IDS_MSG_FIRST]);

    }

    else if (n) {

        _sntprintf(nid.szTip, sizeof(nid.szTip) / sizeof(TCHAR),

                  g_lpMsg[IDS_MSG_RUNNING - IDS_MSG_FIRST], n, i);

    }

    else if (i) {

        _sntprintf(nid.szTip, sizeof(nid.szTip) / sizeof(TCHAR),

                  g_lpMsg[IDS_MSG_RUNNINGNONE - IDS_MSG_FIRST], i);

    }

    else {

        _tcscpy(nid.szTip, g_lpMsg[IDS_MSG_NOSERVICES - IDS_MSG_FIRST]);

    }

    Shell_NotifyIcon(dwMessage, &nid;;

}

void appendMenuItem(HMENU hMenu, UINT uMenuId, LPTSTR szName,

                    BOOL fDefault, BOOL fEnabled)

{

    MENUITEMINFO mii;

    memset(&mii, 0, sizeof(MENUITEMINFO));

    mii.cbSize = sizeof(MENUITEMINFO);

    mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE;

    if (_tcslen(szName))

    {

        mii.fType = MFT_STRING;

        mii.wID = uMenuId;

        if (fDefault) {

            mii.fState = MFS_DEFAULT;

        }

        if (!fEnabled) {

            mii.fState |= MFS_DISABLED;

        }

        mii.dwTypeData = szName;

    }

    else {

        mii.fType = MFT_SEPARATOR;

    }

    InsertMenuItem(hMenu, uMenuId, FALSE, &mii;;

}

void appendServiceMenu(HMENU hMenu, UINT uMenuId,

                       LPTSTR szServiceName, BOOL fRunning)

{

    MENUITEMINFO mii;

    HMENU smh;

    smh = CreatePopupMenu();

    appendMenuItem(smh, IDM_SM_START + uMenuId,

                   g_lpMsg[IDS_MSG_SSTART - IDS_MSG_FIRST], FALSE, !fRunning);

    appendMenuItem(smh, IDM_SM_STOP + uMenuId,

                   g_lpMsg[IDS_MSG_SSTOP - IDS_MSG_FIRST], FALSE, fRunning);

    appendMenuItem(smh, IDM_SM_RESTART + uMenuId,

                   g_lpMsg[IDS_MSG_SRESTART - IDS_MSG_FIRST], FALSE, fRunning);

    memset(&mii, 0, sizeof(MENUITEMINFO));

    mii.cbSize = sizeof(MENUITEMINFO);

    mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_SUBMENU

              | MIIM_CHECKMARKS;

    mii.fType = MFT_STRING;

    mii.wID = uMenuId;

    mii.hbmpChecked = g_hBmpStart;

    mii.hbmpUnchecked = g_hBmpStop;

    mii.dwTypeData = szServiceName;

    mii.hSubMenu = smh;

    mii.fState = fRunning ? MFS_CHECKED : MFS_UNCHECKED;

    InsertMenuItem(hMenu, IDM_SM_SERVICE + uMenuId, FALSE, &mii;;

}

void ShowTryPopupMenu(HWND hWnd)

{

    /* create popup menu */

    HMENU hMenu = CreatePopupMenu();

    POINT pt;

    if (hMenu)

    {

        appendMenuItem(hMenu, IDM_RESTORE,

                       g_lpMsg[IDS_MSG_MNUSHOW - IDS_MSG_FIRST],

                       TRUE, TRUE);

        appendMenuItem(hMenu, IDC_SMANAGER,

                       g_lpMsg[IDS_MSG_MNUSERVICES - IDS_MSG_FIRST],

                       FALSE, TRUE);

        appendMenuItem(hMenu, 0, _T(""), FALSE, TRUE);

        appendMenuItem(hMenu, IDM_EXIT,

                       g_lpMsg[IDS_MSG_MNUEXIT - IDS_MSG_FIRST],

                       FALSE, TRUE);

        if (!SetForegroundWindow(hWnd)) {

            SetForegroundWindow(NULL);

        }

        GetCursorPos(&pt;;

        TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_RIGHTBUTTON,

                       pt.x, pt.y, 0, hWnd, NULL);

        DestroyMenu(hMenu);

    }

}

void ShowTryServicesMenu(HWND hWnd)

{

    /* create services list popup menu and submenus */

    HMENU hMenu = CreatePopupMenu();

    POINT pt;

    int i = 0;

    if (hMenu)

    {

        while (g_stServices[i].szServiceName != NULL)

        {

            appendServiceMenu(hMenu, i, g_stServices[i].szDisplayName,

                              g_stServices[i].dwPid != 0);

            ++i;

        }

        if (i)

        {

            if (!SetForegroundWindow(hWnd)) {

                SetForegroundWindow(NULL);

            }

            GetCursorPos(&pt;;

            TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_RIGHTBUTTON,

                           pt.x, pt.y, 0, hWnd, NULL);

            DestroyMenu(hMenu);

        }

    }

}

BOOL CenterWindow(HWND hwndChild)

{

   RECT rChild, rWorkArea;

   int wChild, hChild;

   int xNew, yNew;

   BOOL bResult;

   /* Get the Height and Width of the child window */

   GetWindowRect(hwndChild, &rChild);

   wChild = rChild.right - rChild.left;

   hChild = rChild.bottom - rChild.top;

   /* Get the limits of the 'workarea' */

   bResult = SystemParametersInfo(SPI_GETWORKAREA, sizeof(RECT),

                                  &rWorkArea, 0);

   if (!bResult) {

      rWorkArea.left = rWorkArea.top = 0;

      rWorkArea.right = GetSystemMetrics(SM_CXSCREEN);

      rWorkArea.bottom = GetSystemMetrics(SM_CYSCREEN);

   }

   /* Calculate new X and Y position*/

   xNew = (rWorkArea.right - wChild) / 2;

   yNew = (rWorkArea.bottom - hChild) / 2;

   return SetWindowPos(hwndChild, HWND_TOP, xNew, yNew, 0, 0,

                       SWP_NOSIZE | SWP_SHOWWINDOW);

}

static void addListBoxItem(HWND hDlg, LPTSTR lpStr, HBITMAP hBmp)

{

    LRESULT nItem;

    nItem = SendMessage(hDlg, LB_ADDSTRING, 0, (LPARAM)lpStr);

    SendMessage(hDlg, LB_SETITEMDATA, nItem, (LPARAM)hBmp);

}

static void addListBoxString(HWND hListBox, LPTSTR lpStr)

{

    static int nItems = 0;

    if (!g_bDlgServiceOn) {

        return;

    }

    ++nItems;

    if (nItems > MAX_LOADSTRING)

    {

        SendMessage(hListBox, LB_RESETCONTENT, 0, 0);

        nItems = 1;

    }

    ListBox_SetCurSel(hListBox,

                      ListBox_AddString(hListBox, lpStr));

}

BOOL ApacheManageService(LPCTSTR szServiceName, LPCTSTR szImagePath,

                         LPTSTR szComputerName, DWORD dwCommand)

{

    TCHAR szMsg[MAX_PATH];

    BOOL retValue;

    SC_HANDLE schService;

    SC_HANDLE schSCManager;

    SERVICE_STATUS schSStatus;

    int ticks;

    schSCManager = OpenSCManager(szComputerName, NULL,

                                 SC_MANAGER_CONNECT);

    if (!schSCManager) {

        ErrorMessage(g_lpMsg[IDS_MSG_SRVFAILED - IDS_MSG_FIRST],

                     FALSE);

        return FALSE;

    }

    schService = OpenService(schSCManager, szServiceName,

                             SERVICE_QUERY_STATUS | SERVICE_START |

                             SERVICE_STOP | SERVICE_USER_DEFINED_CONTROL);

    if (schService == NULL)

    {

        /* Avoid recursion of ImagePath NULL (from this Respawn) */

        if (szImagePath) {

            am_RespawnAsUserAdmin(g_hwndMain, dwCommand,

                                  szServiceName, szComputerName);

        }

        else {

            ErrorMessage(g_lpMsg[IDS_MSG_SRVFAILED - IDS_MSG_FIRST],

                         FALSE);

        }

        CloseServiceHandle(schSCManager);

        return FALSE;

    }

    else

    {

        retValue = FALSE;

        g_bConsoleRun = TRUE;

        SetCursor(g_hCursorHourglass);

        switch (dwCommand)

        {

          case SERVICE_CONTROL_STOP:

            _sntprintf(szMsg, sizeof(szMsg) / sizeof(TCHAR),

                       g_lpMsg[IDS_MSG_SRVSTOP - IDS_MSG_FIRST],

                       szServiceName);

            addListBoxString(g_hwndStdoutList, szMsg);

            if (ControlService(schService, SERVICE_CONTROL_STOP,

                               &schSStatus)) {

                Sleep(1000);

                while (QueryServiceStatus(schService, &schSStatus))

                {

                    if (schSStatus.dwCurrentState == SERVICE_STOP_PENDING)

                    {

                        Sleep(1000);

                    }

                    else {

                        break;

                    }

                }

            }

            if (QueryServiceStatus(schService, &schSStatus))

            {

                if (schSStatus.dwCurrentState == SERVICE_STOPPED)

                {

                    retValue = TRUE;

                    _sntprintf(szMsg, sizeof(szMsg) / sizeof(TCHAR),

                               g_lpMsg[IDS_MSG_SRVSTOPPED - IDS_MSG_FIRST],

                               szServiceName);

                    addListBoxString(g_hwndStdoutList, szMsg);

                }

            }

            break;

          case SERVICE_CONTROL_CONTINUE:

            _sntprintf(szMsg, sizeof(szMsg) / sizeof(TCHAR),

                       g_lpMsg[IDS_MSG_SRVSTART - IDS_MSG_FIRST],

                       szServiceName);

            addListBoxString(g_hwndStdoutList, szMsg);

            if (StartService(schService, 0, NULL))

            {

                Sleep(1000);

                while (QueryServiceStatus(schService, &schSStatus))

                {

                    if (schSStatus.dwCurrentState == SERVICE_START_PENDING)

                    {

                        Sleep(1000);

                    }

                    else {

                        break;

                    }

                }

            }

            if (QueryServiceStatus(schService, &schSStatus))

            {

                if (schSStatus.dwCurrentState == SERVICE_RUNNING)

                {

                    retValue = TRUE;

                    _sntprintf(szMsg, sizeof(szMsg) / sizeof(TCHAR),

                               g_lpMsg[IDS_MSG_SRVSTARTED - IDS_MSG_FIRST],

                               szServiceName);

                    addListBoxString(g_hwndStdoutList, szMsg);

                }

            }

            break;

          case SERVICE_APACHE_RESTART:

            _sntprintf(szMsg, sizeof(szMsg) / sizeof(TCHAR),

                       g_lpMsg[IDS_MSG_SRVRESTART - IDS_MSG_FIRST],

                       szServiceName);

            addListBoxString(g_hwndStdoutList, szMsg);

            if (ControlService(schService, SERVICE_APACHE_RESTART,

                               &schSStatus))

            {

                ticks = 60;

                while (schSStatus.dwCurrentState == SERVICE_START_PENDING)

                {

                    Sleep(1000);

                    if (!QueryServiceStatus(schService, &schSStatus))

                    {

                        CloseServiceHandle(schService);

                        CloseServiceHandle(schSCManager);

                        g_bConsoleRun = FALSE;

                        SetCursor(g_hCursorArrow);

                        return FALSE;

                    }

                    if (!--ticks) {

                        break;

                    }

                }

            }

            if (schSStatus.dwCurrentState == SERVICE_RUNNING)

            {

                retValue = TRUE;

                _sntprintf(szMsg, sizeof(szMsg) / sizeof(TCHAR),

                           g_lpMsg[IDS_MSG_SRVRESTARTED - IDS_MSG_FIRST],

                           szServiceName);

                addListBoxString(g_hwndStdoutList, szMsg);

            }

            break;

        }

        CloseServiceHandle(schService);

        CloseServiceHandle(schSCManager);

        if (!retValue) {

            ErrorMessage(g_lpMsg[IDS_MSG_SRVFAILED - IDS_MSG_FIRST],

                         FALSE);

        }

        g_bConsoleRun = FALSE;

        SetCursor(g_hCursorArrow);

        return retValue;

    }

    return FALSE;

}

BOOL IsServiceRunning(LPCTSTR szServiceName, LPCTSTR szComputerName,

                      LPDWORD lpdwPid)

{

    DWORD dwPid;

    SC_HANDLE schService;

    SC_HANDLE schSCManager;

    SERVICE_STATUS schSStatus;

    dwPid = 0;

    schSCManager = OpenSCManager(szComputerName, NULL,

                                SC_MANAGER_CONNECT);

    if (!schSCManager) {

        return FALSE;

    }

    schService = OpenService(schSCManager, szServiceName,

                             SERVICE_QUERY_STATUS);

    if (schService != NULL)

    {

        if (QueryServiceStatus(schService, &schSStatus))

        {

            dwPid = schSStatus.dwCurrentState;

            if (lpdwPid) {

                *lpdwPid = 1;

            }

        }

        CloseServiceHandle(schService);

        CloseServiceHandle(schSCManager);

        return dwPid == SERVICE_RUNNING ? TRUE : FALSE;

    }

    else {

        g_bRescanServices = TRUE;

    }

    CloseServiceHandle(schSCManager);

    return FALSE;

}

BOOL FindRunningServices(void)

{

    int i = 0;

    DWORD dwPid;

    BOOL rv = FALSE;

    while (g_stServices[i].szServiceName != NULL)

    {

        if (!IsServiceRunning(g_stServices[i].szServiceName,

                              g_stServices[i].szComputerName, &dwPid)) {

            dwPid = 0;

        }

        if (g_stServices[i].dwPid != dwPid) {

            rv = TRUE;

        }

        g_stServices[i].dwPid = dwPid;

        ++i;

    }

    return rv;

}

BOOL GetApacheServicesStatus()

{

    TCHAR szKey[MAX_PATH];

    TCHAR achKey[MAX_PATH];

    TCHAR szImagePath[MAX_PATH];

    TCHAR szBuf[MAX_PATH];

    TCHAR szTmp[MAX_PATH];

    HKEY hKey, hSubKey, hKeyRemote;

    DWORD retCode, rv, dwKeyType;

    DWORD dwBufLen = MAX_PATH;

    int i, stPos = 0;

    int computers = 0;

    g_bRescanServices = FALSE;

    am_ClearServicesSt();

    while (g_stComputers[computers].szComputerName != NULL) {

        hKeyRemote = g_stComputers[computers].hRegistry;

        retCode = RegOpenKeyEx(hKeyRemote,

                               _T("System\\CurrentControlSet\\Services\\"),

                               0, KEY_READ, &hKey);

        if (retCode != ERROR_SUCCESS)

        {

            ErrorMessage(NULL, FALSE);

            return FALSE;

        }

        for (i = 0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++)

        {

            retCode = RegEnumKey(hKey, i, achKey, MAX_PATH);

            if (retCode == ERROR_SUCCESS)

            {

                _tcscpy(szKey, _T("System\\CurrentControlSet\\Services\\"));

                _tcscat(szKey, achKey);

                if (RegOpenKeyEx(hKeyRemote, szKey, 0,

                                 KEY_QUERY_VALUE, &hSubKey) == ERROR_SUCCESS)

                {

                    dwBufLen = MAX_PATH;

                    rv = RegQueryValueEx(hSubKey, _T("ImagePath"), NULL,

                                         &dwKeyType, (LPBYTE)szImagePath, &dwBufLen);

                    if (rv == ERROR_SUCCESS

                            && (dwKeyType == REG_SZ

                             || dwKeyType == REG_EXPAND_SZ)

                            && dwBufLen)

                    {

                        _tcscpy(szBuf, szImagePath);

                        CharLower(szBuf);

                        /* the service name could be httpd*.exe or Apache*.exe */

                        if (((_tcsstr(szBuf, _T("\\apache")) != NULL)

                             || (_tcsstr(szBuf, _T("\\httpd")) != NULL))

                                && _tcsstr(szBuf, _T(".exe"))

                                && (_tcsstr(szBuf, _T("--ntservice")) != NULL

                                       || _tcsstr(szBuf, _T("-k ")) != NULL))

                        {

                            g_stServices[stPos].szServiceName = _tcsdup(achKey);

                            g_stServices[stPos].szImagePath = _tcsdup(szImagePath);

                            g_stServices[stPos].szComputerName =

                                _tcsdup(g_stComputers[computers].szComputerName);

                            dwBufLen = MAX_PATH;

                            if (RegQueryValueEx(hSubKey, _T("Description"), NULL,

                                                &dwKeyType, (LPBYTE)szBuf, &dwBufLen)

                                    == ERROR_SUCCESS) {

                                g_stServices[stPos].szDescription = _tcsdup(szBuf);

                            }

                            dwBufLen = MAX_PATH;

                            if (RegQueryValueEx(hSubKey, _T("DisplayName"), NULL,

                                                &dwKeyType, (LPBYTE)szBuf, &dwBufLen)

                                    == ERROR_SUCCESS)

                            {

                                if (_tcscmp(g_stComputers[computers]

                                        .szComputerName, g_szLocalHost) != 0)

                                {

                                    _tcscpy(szTmp, g_stComputers[computers]

                                                      .szComputerName + 2);

                                    _tcscat(szTmp, _T("@"));

                                    _tcscat(szTmp, szBuf);

                                }

                                else {

                                    _tcscpy(szTmp, szBuf);

                                }

                                g_stServices[stPos].szDisplayName = _tcsdup(szTmp);

                            }

                            ++stPos;

                            if (stPos >= MAX_APACHE_SERVICES) {

                                retCode = !ERROR_SUCCESS;

                            }

                        }

                    }

                    RegCloseKey(hSubKey);

                }

            }

        }

        ++computers;

        RegCloseKey(hKey);

    }

    FindRunningServices();

    return TRUE;

}

LRESULT CALLBACK ConnectDlgProc(HWND hDlg, UINT message,

                                WPARAM wParam, LPARAM lParam)

{

    TCHAR szCmp[MAX_COMPUTERNAME_LENGTH+4];

    switch (message)

    {

    case WM_INITDIALOG:

        ShowWindow(hDlg, SW_HIDE);

        g_hwndConnectDlg = hDlg;

        CenterWindow(hDlg);

        ShowWindow(hDlg, SW_SHOW);

        SetFocus(GetDlgItem(hDlg, IDC_COMPUTER));

        return TRUE;

    case WM_COMMAND:

        switch (LOWORD(wParam))

        {

        case IDOK:

            memset(szCmp, 0, sizeof(szCmp));

            _tcscpy(szCmp, _T("\\\\"));

            SendMessage(GetDlgItem(hDlg, IDC_COMPUTER), WM_GETTEXT,

                        (WPARAM) MAX_COMPUTERNAME_LENGTH,

                        (LPARAM) szCmp+2);