path: root/support/win32/ApacheMonitor.c

/* ====================================================================
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2000 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 *
 * Portions of this software are based upon public domain software
 * originally written at the National Center for Supercomputing Applications,
 * University of Illinois, Urbana-Champaign.
 */

/* ====================================================================
 * ApacheService.c Simple program to manage and monitor Apache services.
 *
 * Contributed by Mladen Turk <mturk@mappingsoft.com>
 *
 * 05 Aug 2001
 * ==================================================================== 
 */

#define _WIN32_WINNT 0x0400
#ifndef STRICT
#define STRICT
#endif

#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <stdlib.h>
#include <stdio.h>
#include "ApacheMonitor.h"


#define OS_VERSION_WINNT    1
#define OS_VERSION_WIN9X    2
#define OS_VERSION_WIN2K    3
/* Should be enough */
#define MAX_APACHE_SERVICES 128

#define WM_TRAYMESSAGE         (WM_APP+1)
#define WM_UPDATEMESSAGE       (WM_USER+1)
#define SERVICE_APACHE_RESTART 128
#define XBITMAP                16
#define YBITMAP                16 
#define MAX_LOADSTRING         100

#ifndef SERVICE_RUNS_IN_SYSTEM_PROCESS
#define SERVICE_RUNS_IN_SYSTEM_PROCESS  0x00000001

typedef struct _SERVICE_STATUS_PROCESS {
    DWORD   dwServiceType;
    DWORD   dwCurrentState;
    DWORD   dwControlsAccepted;
    DWORD   dwWin32ExitCode;
    DWORD   dwServiceSpecificExitCode;
    DWORD   dwCheckPoint;
    DWORD   dwWaitHint;
    DWORD   dwProcessId;
    DWORD   dwServiceFlags;
} SERVICE_STATUS_PROCESS, *LPSERVICE_STATUS_PROCESS;

typedef enum _SC_STATUS_TYPE {
    SC_STATUS_PROCESS_INFO      = 0
} SC_STATUS_TYPE;

#endif

typedef BOOL (WINAPI *QUERYSERVICESTATUSEX)(SC_HANDLE, SC_STATUS_TYPE,
                                               LPBYTE, DWORD, LPDWORD);

typedef struct _st_APACHE_SERVICE
{
    LPSTR    szServiceName;
    LPSTR    szDisplayName;
    LPSTR    szDescription;
    LPSTR    szImagePath;
    DWORD    dwPid;
} ST_APACHE_SERVICE;

/* Global variables */
HINSTANCE         ap_hInstance = NULL;
HWND              ap_hwndAboutDlg = NULL;
TCHAR             szTitle[MAX_LOADSTRING];          /* The title bar text */
TCHAR             szWindowClass[MAX_LOADSTRING];    /* Window Class Name  */
HICON             ap_icoStop;
HICON             ap_icoRun;
UINT              ap_uiTaskbarCreated;
DWORD             ap_OSVersion;
BOOL              dlgAboutOn = FALSE;
BOOL              dlgServiceOn = FALSE;
ST_APACHE_SERVICE ap_stServices[MAX_APACHE_SERVICES];

HBITMAP           hbmpStart, hbmpStop; 
HBITMAP           hbmpPicture, hbmpOld; 
HWND              ap_hServiceDlg;
BOOL              ap_rescanServices;
HWND              ap_hServiceDlg;


void ap_ClearServicesSt()
{
    int i;
    for (i = 0; i < MAX_APACHE_SERVICES; i++)
    {
        if (ap_stServices[i].szServiceName)
            free(ap_stServices[i].szServiceName);
        if (ap_stServices[i].szDisplayName)
            free(ap_stServices[i].szDisplayName);
        if (ap_stServices[i].szDescription)
            free(ap_stServices[i].szDescription);
        if (ap_stServices[i].szImagePath)
            free(ap_stServices[i].szImagePath);

    }
    ZeroMemory(ap_stServices, sizeof(ST_APACHE_SERVICE) * MAX_APACHE_SERVICES);

}

void ErrorMessage(DWORD dwError)
{
    LPVOID lpMsgBuf;
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                  FORMAT_MESSAGE_FROM_SYSTEM |
                  FORMAT_MESSAGE_IGNORE_INSERTS,
                  NULL,
                  dwError == ERROR_SUCCESS ? GetLastError() : dwError,
                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                  (LPTSTR) &lpMsgBuf, 0, NULL);
    MessageBox(NULL, (LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONERROR);
    LocalFree(lpMsgBuf);

}

LPTSTR GetStringRes(int id)
{
  static TCHAR buffer[MAX_PATH];

  buffer[0] = 0;
  LoadString(GetModuleHandle (NULL), id, buffer, MAX_PATH);
  return buffer;
}

BOOL GetSystemOSVersion(LPSTR szVersion, LPDWORD dwVersion)
{
    OSVERSIONINFOEX osvi;
    BOOL bOsVersionInfoEx;
    char szBuff[256];
    HKEY hKey;
    char szProductType[80];
    DWORD dwBufLen;
    
    /* 
    Try calling GetVersionEx using the OSVERSIONINFOEX structure.
    If that fails, try using the OSVERSIONINFO structure.
    */
    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
    
    if (!(bOsVersionInfoEx = GetVersionEx((OSVERSIONINFO *) &osvi)))
    {
        /* If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO. */        
        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        if (!GetVersionEx((OSVERSIONINFO *) &osvi)) 
            return FALSE;
    }
    
    switch (osvi.dwPlatformId)
    {
    case VER_PLATFORM_WIN32_NT:        
        /* Test for the product. */        
        if (szVersion!= NULL)
        {
            if (osvi.dwMajorVersion <= 4)
                strcpy(szVersion, "MS Windows NT ");
            else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0)
                strcpy(szVersion, "MS Windows 2000 ");
            else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1)
                strcpy(szVersion, "Whistler ");
            /* Test for product type.*/            
#ifdef VER_VORKSTATION_NT
            if (bOsVersionInfoEx)
            {
                if (osvi.wProductType == VER_NT_WORKSTATION)
                {
#ifdef VER_SUITE_PERSONAL
                    if (osvi.wSuiteMask & VER_SUITE_PERSONAL)
                        strcat(szVersion, "Personal ");
                    else
#endif
                    strcat(szVersion, "Professional ");
                }                
                else if (osvi.wProductType == VER_NT_SERVER)
                {
                    if (osvi.wSuiteMask & VER_SUITE_DATACENTER)
                        strcat(szVersion, "DataCenter Server ");
                    else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
                        strcat(szVersion, "Advanced Server ");
                    else
                        strcat(szVersion, "Server ");
                }
            }
            else
            {
#endif                
                RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                    "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
                    0, KEY_QUERY_VALUE, &hKey);
                RegQueryValueEx(hKey, "ProductType", NULL, NULL,
                    (LPBYTE) szProductType, &dwBufLen);
                RegCloseKey(hKey);
                if (lstrcmpi("WINNT", szProductType) == 0)
                    strcat(szVersion, "Workstation ");
                if (lstrcmpi("SERVERNT", szProductType) == 0)
                    strcat(szVersion, "Server ");
#ifdef VER_VORKSTATION_NT
            }            
#endif
            /* Get version, service pack (if any), and build number. */
            if (osvi.dwMajorVersion <= 4)
            {
                sprintf(szBuff, "version %d.%d %s (Build-%d)\n",
                        osvi.dwMajorVersion,
                        osvi.dwMinorVersion,
                        osvi.szCSDVersion,
                        osvi.dwBuildNumber & 0xFFFF);
            }
            else
            { 
                sprintf(szBuff, "%s (Build-%d)\n",
                    osvi.szCSDVersion,
                    osvi.dwBuildNumber & 0xFFFF);
            }
            strcat(szVersion, szBuff);
        }
        else if (dwVersion != NULL)
        {
            if (osvi.dwMajorVersion <= 4)
                *dwVersion = OS_VERSION_WINNT;
            else if (osvi.dwMajorVersion == 5)
                *dwVersion = OS_VERSION_WIN2K;
            else
                return FALSE;
            
        }
        break;
        
    case VER_PLATFORM_WIN32_WINDOWS:
        if (szVersion != NULL)
        {
            if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
            {
                strcpy(szVersion, "MS Windows 95 ");
                if (osvi.szCSDVersion[1] == 'C')
                    strcat(szVersion, "OSR2 ");
            } 
            
            if(osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
            {
                strcpy(szVersion, "MS Windows 98 ");
                if (osvi.szCSDVersion[1] == 'A')
                    strcat(szVersion, "SE ");
            } 
            
            if(osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
            {
                strcpy(szVersion, "MS Windows Me ");
            }
        }
        if (dwVersion != NULL)
            *dwVersion = OS_VERSION_WIN9X;
        
        break;
        
    case VER_PLATFORM_WIN32s:
        if (szVersion != NULL)
            strcpy(szVersion, "Microsoft Win32s ");
        if (dwVersion != NULL)
            *dwVersion = OS_VERSION_WIN9X;
        break;
    default:
        return FALSE;
        break;
   }
   return TRUE; 
}

static VOID ShowNotifyIcon(HWND hWnd, DWORD dwMessage)
{
    
    NOTIFYICONDATA nid;
    int  i = 0, n = 0;

    ZeroMemory(&nid,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 (ap_stServices[i].szServiceName != NULL)
    {    
        if (ap_stServices[i].dwPid != 0)
            ++n;
        ++i;
    }
    if (dwMessage != NIM_DELETE)
    {
        if (n)
            nid.hIcon = ap_icoRun;
        else
            nid.hIcon = ap_icoStop;
    }
    else
        nid.hIcon = NULL;

    sprintf(nid.szTip, "Running: %d Services", n);    
    Shell_NotifyIcon(dwMessage, &nid);
    
}

void ShowTryPopupMenu(HWND hWnd)
{
    /* create popup menu */
    HMENU hMenu = CreatePopupMenu();
    POINT pt;

    if (hMenu)
    {
        AppendMenu(hMenu,  MF_STRING, IDM_ABOUT, "&About...");
        AppendMenu(hMenu,  MF_STRING, IDM_RESTORE, "&Show Services...");
        AppendMenu(hMenu,  MF_SEPARATOR, 0, "");
        AppendMenu(hMenu,  MF_STRING, IDM_EXIT,  "&Exit...");

        GetCursorPos(&pt);
        SetForegroundWindow(NULL);
        TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_RIGHTBUTTON, pt.x, pt.y, 0, hWnd, NULL);
    }
}

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,  /* system parameter to query or set */
      sizeof(RECT),
      &rWorkArea,
      0);
   if (!bResult) {
      rWorkArea.left = rWorkArea.top = 0;
      rWorkArea.right = GetSystemMetrics(SM_CXSCREEN);
      rWorkArea.bottom = GetSystemMetrics(SM_CYSCREEN);
   }

   /* Calculate new X position, then adjust for workarea */
   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 addItem(HWND hDlg, LPSTR lpStr, HBITMAP hBmp) 
{ 
    int nItem; 
 
    nItem = SendMessage(hDlg, LB_ADDSTRING, 0, (LPARAM)lpStr); 
    SendMessage(hDlg, LB_SETITEMDATA, nItem, (LPARAM)hBmp); 
} 


BOOL RunAndForgetConsole(LPTSTR szCmdLine,
                         LPDWORD nRetValue,
                         BOOL  showConsole)
{
    
    
    STARTUPINFO stInfo;
    PROCESS_INFORMATION prInfo;
    BOOL bResult;
    ZeroMemory(&stInfo, sizeof(stInfo));
    stInfo.cb = sizeof(stInfo);
    stInfo.dwFlags = STARTF_USESHOWWINDOW;
    stInfo.wShowWindow = showConsole ? SW_SHOWNORMAL : SW_HIDE;
    
    bResult = CreateProcess(NULL,
        szCmdLine,
        NULL,
        NULL,
        TRUE,
        CREATE_NEW_CONSOLE ,
        NULL,
        NULL ,
        &stInfo,
        &prInfo);
    if (nRetValue)
        *nRetValue = GetLastError();
    
    CloseHandle(prInfo.hThread);
    CloseHandle(prInfo.hProcess);
    if (!bResult) 
        return FALSE;
    else
        return TRUE;
}


BOOL ApacheManageService(LPCSTR szServiceName, LPCSTR szImagePath, DWORD dwCommand)
{
    
    CHAR szBuf[MAX_PATH];
    LPSTR sPos;
    DWORD retCode;
    BOOL  retValue;
    BOOL  ntService = TRUE;
    SC_HANDLE   schService;
    SC_HANDLE   schSCManager;    
    SERVICE_STATUS schSStatus;
    LPSTR *args;
    int   ticks;

    if (ap_OSVersion == OS_VERSION_WIN9X)
    {
        sPos = strstr(szImagePath, "-k start");
        if (sPos)
        {
            lstrcpyn(szBuf, szImagePath, sPos - szImagePath);
            switch (dwCommand)
            {
            case SERVICE_CONTROL_STOP:
                lstrcat(szBuf, " -k stop -n ");
                break;
            case SERVICE_CONTROL_CONTINUE:
                lstrcat(szBuf, " -k start -n ");
                break;
            case SERVICE_APACHE_RESTART:
                lstrcat(szBuf, " -k restart -n ");
                break;
            case SERVICE_CONTROL_SHUTDOWN:
                lstrcat(szBuf, " -k uninstall -n ");
                break;
            default:
                return FALSE;
            }
            lstrcat(szBuf, szServiceName);
        }
        else
            return FALSE;
        if (!RunAndForgetConsole(szBuf, &retCode, FALSE))
        {
            ErrorMessage(retCode);
            return FALSE;
        }
    }
    else
    {
        sPos = strstr(szImagePath, "--ntservice");
        if (!sPos)
        {
            sPos = strstr(szImagePath, "-k runservice");
            ntService = FALSE;
        }
        if (sPos)
        {
            lstrcpyn(szBuf, szImagePath, sPos - szImagePath);
            if (dwCommand == SERVICE_CONTROL_SHUTDOWN)
            {
                lstrcat(szBuf, " -k uninstall -n ");
                lstrcat(szBuf, szServiceName);
                if (!RunAndForgetConsole(szBuf, &retCode, FALSE))
                {
                    ErrorMessage(retCode);
                    return FALSE;
                }
                else
                    return TRUE;
            }
        }
        else
            return FALSE;
        schSCManager = OpenSCManager(
            NULL,
            NULL,
            SC_MANAGER_ALL_ACCESS
           );
        if (!schSCManager)
            return FALSE;
        
        schService = OpenService(schSCManager, szServiceName, SERVICE_ALL_ACCESS);
        if (schService != NULL)
        {
            retValue = FALSE;
            switch (dwCommand)
            {
                case SERVICE_CONTROL_STOP:
                    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;
                    }
                break;                
                case SERVICE_CONTROL_CONTINUE:
                    args = (char **)malloc(3 * sizeof(char*));
                    args[0] = szBuf;
                    if (ntService)
                        args[1] = "--ntservice";
                    else
                    {
                        args[1] = "-k";
                        args[2] = "runservice";
                    }
                    if(StartService(schService, ntService ? 2 : 3, args)) 
                    {
                        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;
                    }
                    /* is this OK to do? */
                    free(args);
                break;                
                case SERVICE_APACHE_RESTART:
                    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);
                                return FALSE;
                            }
                            if (!--ticks)
                                break;
                        }
                    }
                    if(schSStatus.dwCurrentState == SERVICE_RUNNING)
                            retValue = TRUE;
                break;                
            }
            CloseServiceHandle(schService);
            CloseServiceHandle(schSCManager);
            return retValue;
            
        }
        else
            ap_rescanServices = TRUE;
        
        CloseServiceHandle(schSCManager);
        return FALSE;
    }
    
    return FALSE;
}

BOOL IsServiceRunning(LPCSTR szServiceName, LPDWORD lpdwPid)
{

    DWORD dwPid, dwBytes;
    HWND  hWnd;
    SC_HANDLE   schService;
    SC_HANDLE   schSCManager;    
    SERVICE_STATUS schSStatus;
    SERVICE_STATUS_PROCESS schSProcess;
    HANDLE hAdvapi;
    QUERYSERVICESTATUSEX pQueryServiceStatusEx = NULL;

    if (ap_OSVersion == OS_VERSION_WIN9X)
    {
        hWnd = FindWindow("ApacheWin95ServiceMonitor", szServiceName);
        if (hWnd && GetWindowThreadProcessId(hWnd, &dwPid))
        {
            *lpdwPid = dwPid;
            return TRUE;
        }
        else
            return FALSE;
    }
    else
    {

        dwPid = 0;
        schSCManager = OpenSCManager(
                            NULL,
                            NULL,
                            SC_MANAGER_ALL_ACCESS
                           );
        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;
            }
            if (ap_OSVersion == OS_VERSION_WIN2K)
            {
                hAdvapi = LoadLibrary("ADVAPI32.DLL");
                if (hAdvapi != NULL)
                    pQueryServiceStatusEx = (QUERYSERVICESTATUSEX)GetProcAddress(hAdvapi,
                                                                    "QueryServiceStatusEx");
                if (hAdvapi != NULL && pQueryServiceStatusEx != NULL)
                {
                    if (pQueryServiceStatusEx(schService, SC_STATUS_PROCESS_INFO,
                                               (LPBYTE)&schSProcess, sizeof(SERVICE_STATUS_PROCESS), &dwBytes))
                    {
                        dwPid = schSProcess.dwCurrentState;
                        if (lpdwPid)
                            *lpdwPid = schSProcess.dwProcessId;
                    }
                }
                if (hAdvapi != NULL)
                    FreeLibrary(hAdvapi);
            }
            CloseServiceHandle(schService);
            CloseServiceHandle(schSCManager);
            return dwPid == SERVICE_RUNNING ? TRUE : FALSE;
        }
        else
            ap_rescanServices = TRUE;

        CloseServiceHandle(schSCManager);
        return FALSE;

    }

    return FALSE;
}

BOOL FindRunningServices()
{
    int i = 0;
    DWORD dwPid;
    BOOL rv = FALSE;
    while (ap_stServices[i].szServiceName != NULL)
    {    
        if (!IsServiceRunning(ap_stServices[i].szServiceName, &dwPid))
            dwPid = 0;
        if (ap_stServices[i].dwPid != dwPid)
            rv = TRUE;
        ap_stServices[i].dwPid = dwPid;
        ++i;
    }                        
    return rv;
}

BOOL GetApacheServicesStatus()
{

    CHAR szKey[MAX_PATH];
    CHAR achKey[MAX_PATH];
    CHAR szImagePath[MAX_PATH];
    CHAR szBuf[MAX_PATH];

    HKEY hKey, hSubKey;
    DWORD retCode, rv, dwKeyType;
    DWORD dwBufLen = MAX_PATH;

    int  i, stPos = 0;
    ap_rescanServices = FALSE;

    retCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                            "System\\CurrentControlSet\\Services\\",
                            0, KEY_READ, &hKey);
    if (retCode != ERROR_SUCCESS)
    {
        ErrorMessage(retCode);
        return FALSE;
    }
    ap_ClearServicesSt();
    for (i = 0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++)
    {

        retCode = RegEnumKey(hKey, i, achKey, MAX_PATH);
        if (retCode == ERROR_SUCCESS)
        {
            lstrcpy(szKey, "System\\CurrentControlSet\\Services\\");
            lstrcat(szKey, achKey);

            if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKey, 0, 
                KEY_QUERY_VALUE, &hSubKey) == ERROR_SUCCESS)
            {
                dwBufLen = MAX_PATH;
                rv = RegQueryValueEx(hSubKey, "ImagePath", NULL,
                                      &dwKeyType, szImagePath, &dwBufLen);

                if (rv == ERROR_SUCCESS && (dwKeyType == REG_SZ  || dwKeyType == REG_EXPAND_SZ) && dwBufLen)
                {
                    lstrcpy(szBuf, szImagePath);
                    CharLower(szBuf);
                    if (strstr(szBuf, "\\apache.exe") != NULL)
                    {
                        ap_stServices[stPos].szServiceName = strdup(achKey);
                        ap_stServices[stPos].szImagePath = strdup(szImagePath);
                        dwBufLen = MAX_PATH;
                        if (RegQueryValueEx(hSubKey, "Description", NULL,
                                      &dwKeyType, szBuf, &dwBufLen) == ERROR_SUCCESS)
                            ap_stServices[stPos].szDescription = strdup(szBuf);

                        dwBufLen = MAX_PATH;
                        if (RegQueryValueEx(hSubKey, "DisplayName", NULL,
                                      &dwKeyType, szBuf, &dwBufLen) == ERROR_SUCCESS)
                            ap_stServices[stPos].szDisplayName= strdup(szBuf);
                        ++stPos;
                        if (stPos >= MAX_APACHE_SERVICES)
                            retCode = !ERROR_SUCCESS;
                    }
                }
                RegCloseKey(hSubKey);
            }
        }
    }
    RegCloseKey(hKey);
    FindRunningServices();
    return TRUE;
}

LRESULT CALLBACK ServiceDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{

    CHAR tchBuffer[MAX_PATH]; 
    CHAR tsbBuffer[MAX_PATH];
    CHAR szBuf[64];
    HWND hListBox;
    static HWND hStatusBar; 
    TEXTMETRIC tm; 
    int i, y; 
    HDC hdcMem; 
    LPMEASUREITEMSTRUCT lpmis; 
    LPDRAWITEMSTRUCT lpdis; 
    RECT rcBitmap; 
    UINT nItem;

    switch (message) 
    { 
 
        case WM_INITDIALOG: 
            ShowWindow(hDlg, SW_HIDE);
            ap_hServiceDlg = hDlg;
            hbmpStart = LoadBitmap(ap_hInstance, MAKEINTRESOURCE(IDB_BMPRUN)); 
            hbmpStop  = LoadBitmap(ap_hInstance, MAKEINTRESOURCE(IDB_BMPSTOP)); 

            Button_Enable(GetDlgItem(hDlg, IDC_SSTART), FALSE);
            Button_Enable(GetDlgItem(hDlg, IDC_SSTOP), FALSE);
            Button_Enable(GetDlgItem(hDlg, IDC_SRESTART), FALSE);
            Button_Enable(GetDlgItem(hDlg, IDC_SUNINSTALL), FALSE);
            hListBox = GetDlgItem(hDlg, IDL_SERVICES); 
            hStatusBar = CreateStatusWindow(SBT_TOOLTIPS | WS_CHILD | WS_VISIBLE,
                                            "", hDlg, IDC_STATBAR);            
            if (GetApacheServicesStatus())
            {
                i = 0;
                while (ap_stServices[i].szServiceName != NULL)
                {    
                    addItem(hListBox, ap_stServices[i].szDisplayName, 
                        ap_stServices[i].dwPid == 0 ? hbmpStop : hbmpStart);
                    ++i;
                }
            }
            CenterWindow(hDlg);
            ShowWindow(hDlg, SW_SHOW);
            SetFocus(hListBox); 
            SendMessage(hListBox, LB_SETCURSEL, 0, 0); 
            return TRUE;
        break;
        case WM_UPDATEMESSAGE:
            hListBox = GetDlgItem(hDlg, IDL_SERVICES); 
            SendMessage(hListBox, LB_RESETCONTENT, 0, 0); 
            Button_Enable(GetDlgItem(hDlg, IDC_SSTART), FALSE);
            Button_Enable(GetDlgItem(hDlg, IDC_SSTOP), FALSE);
            Button_Enable(GetDlgItem(hDlg, IDC_SRESTART), FALSE);
            Button_Enable(GetDlgItem(hDlg, IDC_SUNINSTALL), FALSE);
            i = 0;
            while (ap_stServices[i].szServiceName != NULL)
            {    
                addItem(hListBox, ap_stServices[i].szDisplayName, 
                    ap_stServices[i].dwPid == 0 ? hbmpStop : hbmpStart);
                ++i;
            }
            SendMessage(hListBox, LB_SETCURSEL, 0, 0); 
            /* Dirty hack to bring the window to the foreground */
             SetWindowPos(hDlg, HWND_TOPMOST, 0, 0, 0, 0,
                                    SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW);
            SetWindowPos(hDlg, HWND_NOTOPMOST, 0, 0, 0, 0,
                                    SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW);
            SetFocus(hListBox); 
            return TRUE;
        break;
        case WM_MEASUREITEM: 
 
            lpmis = (LPMEASUREITEMSTRUCT) lParam; 
            lpmis->itemHeight = 16; 
            return TRUE; 
 
        case WM_DRAWITEM: 
 
            lpdis = (LPDRAWITEMSTRUCT) lParam; 
            if (lpdis->itemID == -1) 
            { 
                break; 
            } 
            switch (lpdis->itemAction) 
            { 
                case ODA_SELECT: 
                case ODA_DRAWENTIRE: 
                    hbmpPicture = (HBITMAP)SendMessage(lpdis->hwndItem, 
                        LB_GETITEMDATA, lpdis->itemID, (LPARAM) 0); 
 
                    hdcMem = CreateCompatibleDC(lpdis->hDC); 
                    hbmpOld = SelectObject(hdcMem, hbmpPicture); 
 
                    BitBlt(lpdis->hDC, 
                        lpdis->rcItem.left, lpdis->rcItem.top, 
                        lpdis->rcItem.right - lpdis->rcItem.left, 
                        lpdis->rcItem.bottom - lpdis->rcItem.top, 
                        hdcMem, 0, 0, SRCCOPY); 
                    SendMessage(lpdis->hwndItem, LB_GETTEXT, 
                        lpdis->itemID, (LPARAM) tchBuffer); 
 
                    GetTextMetrics(lpdis->hDC, &tm);  
                    y = (lpdis->rcItem.bottom + lpdis->rcItem.top - 
                        tm.tmHeight) / 2; 
  
                    SelectObject(hdcMem, hbmpOld); 
                    DeleteDC(hdcMem); 
 
                    rcBitmap.left = lpdis->rcItem.left + XBITMAP; 
                    rcBitmap.top = lpdis->rcItem.top; 
                    rcBitmap.right = lpdis->rcItem.right; 
                    rcBitmap.bottom = lpdis->rcItem.top + YBITMAP; 

                    if (lpdis->itemState & ODS_SELECTED) 
                    { 
                        if (hbmpPicture == hbmpStop)
                        {
                            Button_Enable(GetDlgItem(hDlg, IDC_SSTART), TRUE);
                            Button_Enable(GetDlgItem(hDlg, IDC_SSTOP), FALSE);
                            Button_Enable(GetDlgItem(hDlg, IDC_SRESTART), FALSE);
                            Button_Enable(GetDlgItem(hDlg, IDC_SUNINSTALL), TRUE);
                            
                        }
                        else if (hbmpPicture == hbmpStart) 
                        {
                            Button_Enable(GetDlgItem(hDlg, IDC_SSTART), FALSE);
                            Button_Enable(GetDlgItem(hDlg, IDC_SSTOP), TRUE);
                            Button_Enable(GetDlgItem(hDlg, IDC_SRESTART), TRUE);
                            Button_Enable(GetDlgItem(hDlg, IDC_SUNINSTALL), FALSE);
                            
                        }
                        i = 0;
                        while (ap_stServices[i].szServiceName != NULL)
                        {    
                            if (lstrcmp(ap_stServices[i].szDisplayName, tchBuffer) == 0)
                            {
                                if (ap_stServices[i].szDescription)
                                    lstrcpy(tsbBuffer, ap_stServices[i].szDescription); 
                                else
                                    lstrcpy(tsbBuffer, ap_stServices[i].szImagePath); 
                                if (ap_stServices[i].dwPid != 0)
                                {                
                                    if (ap_stServices[i].dwPid & 0xFF000000)
                                        sprintf(szBuf, "  PID : 0x%08X", ap_stServices[i].dwPid);
                                    else
                                        sprintf(szBuf, "  PID : %d", ap_stServices[i].dwPid);
                                    lstrcat(tsbBuffer, szBuf);
                                }
                                SendMessage(hStatusBar, SB_SETTEXT, 0, (LPARAM)tsbBuffer);
                                break;
                            }
                            ++i;
                        }
                        
                        SetTextColor(lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT)); 
                        SetBkColor(lpdis->hDC, GetSysColor(COLOR_HIGHLIGHT)); 
                        FillRect(lpdis->hDC, &rcBitmap, (HBRUSH)(COLOR_HIGHLIGHTTEXT)); 
                    } 
                    else
                    {
                       SetTextColor(lpdis->hDC, GetSysColor(COLOR_MENUTEXT)); 
                       SetBkColor(lpdis->hDC, GetSysColor(COLOR_WINDOW)); 
                       FillRect(lpdis->hDC, &rcBitmap, (HBRUSH)(COLOR_WINDOW+1)); 
                    }
                    TextOut(lpdis->hDC, 
                        XBITMAP + 6, 
                        y, 
                        tchBuffer, 
                        strlen(tchBuffer)); 
                    break; 
 
                case ODA_FOCUS: 
                    break; 
            } 
            return TRUE;  
        case WM_COMMAND: 
            switch (LOWORD(wParam)) 
            { 
                case IDL_SERVICES:
                    switch (HIWORD(wParam))
                    {
                        case LBN_DBLCLK:
                            GetApacheServicesStatus();
                            SendMessage(hDlg, WM_UPDATEMESSAGE, 0, 0);
                            return TRUE;
                    }
                break;
                case IDOK: 
                    EndDialog(hDlg, TRUE); 
                    return TRUE; 
                break;
                case IDC_SSTART: 
                    Button_Enable(GetDlgItem(hDlg, IDC_SSTART), FALSE);
                    hListBox = GetDlgItem(hDlg, IDL_SERVICES); 
                    nItem = SendMessage(hListBox, LB_GETCURSEL, 0, 0); 
                    if (nItem != LB_ERR)
                    {
                        ApacheManageService(ap_stServices[nItem].szServiceName,
                                             ap_stServices[nItem].szImagePath,
                                             SERVICE_CONTROL_CONTINUE);
                    }
                    Button_Enable(GetDlgItem(hDlg, IDC_SSTART), TRUE);
                    return TRUE;
                break;
                case IDC_SSTOP: 
                    Button_Enable(GetDlgItem(hDlg, IDC_SSTOP), FALSE);
                    hListBox = GetDlgItem(hDlg, IDL_SERVICES); 
                    nItem = SendMessage(hListBox, LB_GETCURSEL, 0, 0); 
                    if (nItem != LB_ERR)
                    {
                        ApacheManageService(ap_stServices[nItem].szServiceName,
                                             ap_stServices[nItem].szImagePath,
                                             SERVICE_CONTROL_STOP);
                    }
                    Button_Enable(GetDlgItem(hDlg, IDC_SSTOP), TRUE);
                    return TRUE;
                break;
                case IDC_SRESTART: 
                    Button_Enable(GetDlgItem(hDlg, IDC_SRESTART), FALSE);
                    hListBox = GetDlgItem(hDlg, IDL_SERVICES); 
                    nItem = SendMessage(hListBox, LB_GETCURSEL, 0, 0); 
                    if (nItem != LB_ERR)
                    {
                        ApacheManageService(ap_stServices[nItem].szServiceName,
                                             ap_stServices[nItem].szImagePath,
                                             SERVICE_APACHE_RESTART);
                    }
                    Button_Enable(GetDlgItem(hDlg, IDC_SRESTART), TRUE);
                    return TRUE;
                break;
                case IDC_SUNINSTALL: 
                    Button_Enable(GetDlgItem(hDlg, IDC_SUNINSTALL), FALSE);
                    hListBox = GetDlgItem(hDlg, IDL_SERVICES); 
                    nItem = SendMessage(hListBox, LB_GETCURSEL, 0, 0); 
                    if (nItem != LB_ERR)
                    {
                        ApacheManageService(ap_stServices[nItem].szServiceName,
                                             ap_stServices[nItem].szImagePath,
                                             SERVICE_CONTROL_SHUTDOWN);
                    }
                    ap_rescanServices = TRUE;
                    Button_Enable(GetDlgItem(hDlg, IDC_SUNINSTALL), TRUE);
                    return TRUE;
                break;
             }
        break;
        case WM_SIZE:
            switch (LOWORD(wParam)) 
            { 
                case SIZE_MINIMIZED:
                    EndDialog(hDlg, TRUE); 
                    return TRUE; 
                break;
            }
        break;
        case WM_ERASEBKGND:
            
            break;
        case WM_CLOSE: 
            EndDialog(hDlg, TRUE);
            return TRUE;
        case WM_DESTROY: 
            DeleteObject(hbmpStart); 
            DeleteObject(hbmpStop); 
            return TRUE; 

        default:
            return FALSE;
    }
    return FALSE;
}

/* About Box from MS Generic Sample */
LRESULT CALLBACK AboutDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    static  HFONT hfontDlg;    /* Font for dialog text */
    static  HFONT hFinePrint;  /* Font for 'fine print' in dialog */
    DWORD   dwVerInfoSize;     /* Size of version information block */
    LPSTR   lpVersion;         /* String pointer to 'version' text */
    DWORD   dwVerHnd=0;        /* An 'ignored' parameter, always '0' */
    UINT    uVersionLen;
    WORD    wRootLen;
    BOOL    bRetCode;
    int     i;
    char    szFullPath[256];
    char    szResult[256];
    char    szGetName[256];
    char    szVersion[256];
    DWORD dwResult;
    
    switch (message) {
    case WM_INITDIALOG:
        ShowWindow(hDlg, SW_HIDE);
        ap_hwndAboutDlg = hDlg;
        
        hfontDlg = CreateFont(14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            VARIABLE_PITCH | FF_SWISS, "");
        hFinePrint = CreateFont(11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            VARIABLE_PITCH | FF_SWISS, "");

        CenterWindow(hDlg);
        GetModuleFileName(ap_hInstance, szFullPath, sizeof(szFullPath));
        
        /* Now lets dive in and pull out the version information: */
        dwVerInfoSize = GetFileVersionInfoSize(szFullPath, &dwVerHnd);
        if (dwVerInfoSize) {
            LPSTR   lpstrVffInfo;
            HANDLE  hMem;
            hMem = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
            lpstrVffInfo  = GlobalLock(hMem);
            GetFileVersionInfo(szFullPath, dwVerHnd, dwVerInfoSize, lpstrVffInfo);
            lstrcpy(szGetName, GetStringRes(IDS_VER_INFO_LANG));
            
            wRootLen = lstrlen(szGetName); /* Save this position */
            
            /* Set the title of the dialog: */
            lstrcat(szGetName, "ProductName");
            bRetCode = VerQueryValue((LPVOID)lpstrVffInfo,
                (LPSTR)szGetName,
                (LPVOID)&lpVersion,
                (UINT *)&uVersionLen);
            
            /* Notice order of version and string... */
            lstrcpy(szResult, "About ");
            lstrcat(szResult, lpVersion);
            
            SetWindowText(hDlg, szResult);
            
            /* Walk through the dialog items that we want to replace: */
            for (i = DLG_VERFIRST; i <= DLG_VERLAST; i++) {
                GetDlgItemText(hDlg, i, szResult, sizeof(szResult));
                szGetName[wRootLen] = (char)0;
                lstrcat(szGetName, szResult);
                uVersionLen   = 0;
                lpVersion     = NULL;
                bRetCode      =  VerQueryValue((LPVOID)lpstrVffInfo,
                    (LPSTR)szGetName,
                    (LPVOID)&lpVersion,
                    (UINT *)&uVersionLen);
                
                if (bRetCode && uVersionLen && lpVersion) {
                    /* Replace dialog item text with version info */
                    lstrcpy(szResult, lpVersion);
                    SetDlgItemText(hDlg, i, szResult);
                }
                else
                {
                    dwResult = GetLastError();
                    
                    wsprintf(szResult, GetStringRes(IDS_VERSION_ERROR), dwResult);
                    SetDlgItemText(hDlg, i, szResult);
                }
                SendMessage(GetDlgItem(hDlg, i), WM_SETFONT,
                    (UINT)((i==DLG_VERLAST)?hFinePrint:hfontDlg),
                    TRUE);
            }
            
            
            GlobalUnlock(hMem);
            GlobalFree(hMem);
            
        } 
        
        SendMessage(GetDlgItem(hDlg, IDC_LABEL), WM_SETFONT,
            (WPARAM)hfontDlg,(LPARAM)TRUE);
        if (!GetSystemOSVersion(szVersion, NULL))
            strcpy(szVersion, "Unknown Version");
        SetWindowText(GetDlgItem(hDlg, IDC_OSVERSION), szVersion);
        ShowWindow(hDlg, SW_SHOW);
        return (TRUE);
        
      case WM_COMMAND:
          if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
              EndDialog(hDlg, TRUE);
              DeleteObject(hfontDlg);
              DeleteObject(hFinePrint);
              return (TRUE);
          }
          break;
   }
   
   return FALSE;
}

VOID CALLBACK MainTimerProc(HWND hWnd, UINT uMsg, UINT idEvent, DWORD dwTime)
{
    if (ap_rescanServices)
    {
        GetApacheServicesStatus();
        ShowNotifyIcon(hWnd, NIM_MODIFY);
        if (ap_hServiceDlg)
        {
            SendMessage(ap_hServiceDlg, WM_UPDATEMESSAGE, 0, 0);

        }
    }
    else if (FindRunningServices())
    {
        ShowNotifyIcon(hWnd, NIM_MODIFY);
        if (ap_hServiceDlg)
        {
            SendMessage(ap_hServiceDlg, WM_UPDATEMESSAGE, 0, 0);

        }
    }
}


LRESULT CALLBACK WndProc(HWND hWnd, UINT message,
                          WPARAM wParam, LPARAM lParam)
{
    if (message == ap_uiTaskbarCreated)
    {
        /* reinstall tray icon */
        ShowNotifyIcon(hWnd, NIM_ADD);
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    switch (message) 
    {
        case WM_CREATE:
            GetSystemOSVersion(NULL, &ap_OSVersion);
            GetApacheServicesStatus();
            ShowNotifyIcon(hWnd, NIM_ADD);
            SetTimer(hWnd, 10, 1000, (TIMERPROC)MainTimerProc);
              ap_hServiceDlg = NULL;                      
        break;
        case WM_QUIT:
            ShowNotifyIcon(hWnd, NIM_DELETE);
        break;
        case WM_TRAYMESSAGE:
            switch(lParam)
            {
                case WM_LBUTTONDBLCLK:
                   if (!dlgServiceOn)
                   {
                       dlgServiceOn = TRUE;
                       DialogBox(ap_hInstance, MAKEINTRESOURCE(IDD_APSRVMON_DIALOG),
                             hWnd, (DLGPROC)ServiceDlgProc);
                       dlgServiceOn = FALSE;
                       ap_hServiceDlg = NULL;
                   }
                   else if (ap_hServiceDlg)
                   {
                       /* Dirty hack to bring the window to the foreground */
                       SetWindowPos(ap_hServiceDlg, HWND_TOPMOST, 0, 0, 0, 0,
                                    SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW);
                       SetWindowPos(ap_hServiceDlg, HWND_NOTOPMOST, 0, 0, 0, 0,
                                    SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW);
                       SetFocus(ap_hServiceDlg);
                   }
                break;
                case WM_RBUTTONUP:
                    ShowTryPopupMenu(hWnd);
                break;    
            }
            break;
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
               case IDM_RESTORE:
                   if (!dlgServiceOn)
                   {
                       dlgServiceOn = TRUE;
                       DialogBox(ap_hInstance, MAKEINTRESOURCE(IDD_APSRVMON_DIALOG),
                             hWnd, (DLGPROC)ServiceDlgProc);
                       dlgServiceOn = FALSE;
                       ap_hServiceDlg = NULL;
                   }
                   else if (ap_hServiceDlg)
                       SetFocus(ap_hServiceDlg);
               break;
               case IDM_ABOUT:
                   if (!dlgAboutOn)
                   {
                      dlgAboutOn = TRUE;
                      DialogBox(ap_hInstance, MAKEINTRESOURCE(IDD_ABOUTBOX),
                             hWnd, (DLGPROC)AboutDlgProc);
                      dlgAboutOn = FALSE;
                      ap_hwndAboutDlg = NULL;                      
                   }
                   else if (ap_hwndAboutDlg)
                       SetFocus(ap_hwndAboutDlg);

                break;
                case IDM_EXIT:
                    PostQuitMessage(0);
                    return TRUE;
                break;
            }
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
    }

    return FALSE;
}

/* Create main invisible window */
HWND CreateMainWindow(HINSTANCE hInstance)
{
    HWND       hWnd = NULL;
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX); 

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = (WNDPROC)WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, (LPCTSTR)IDI_APSRVMON);
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = (LPCSTR)IDC_APSRVMON;
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_APSMALL);

    if (RegisterClassEx(&wcex))
    {
        hWnd = CreateWindow(szWindowClass, szTitle,
                             0, 0, 0, 0, 0,
                             NULL, NULL, hInstance, NULL);
    }

    return hWnd;

}


int WINAPI WinMain(HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPTSTR lpCmdLine,
                    int nCmdShow)
{
    HWND    hwnd;
    MSG     msg;
    /* single instance mutex */
    HANDLE hMutex = CreateMutex(NULL, FALSE, "APSRVMON_MUTEX");
    if((hMutex == NULL) || (GetLastError() == ERROR_ALREADY_EXISTS))
    {
        if (hMutex)
            CloseHandle(hMutex);

        return 0;
    }

    InitCommonControls();
    ap_hInstance = hInstance;

    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_APSRVMON,  szWindowClass, MAX_LOADSTRING);
    ap_icoStop  = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICOSTOP));
    ap_icoRun   = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICORUN));
    ap_uiTaskbarCreated = RegisterWindowMessage("TaskbarCreated");

    ZeroMemory(ap_stServices, sizeof(ST_APACHE_SERVICE) * MAX_APACHE_SERVICES);
    hwnd = CreateMainWindow(hInstance);
    if (hwnd != NULL)
    {
        while (GetMessage(&msg, NULL, 0, 0) == TRUE) 
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }    
        ap_ClearServicesSt();
    }
    CloseHandle(hMutex);
    return 0;
}