/*******************************************************************************
*
*  Copyright 1999 American Power Conversion, All Rights Reserved
*
*  TITLE:       UPSCOMMON.C
*
*  VERSION:     1.0
*
*  AUTHOR:      SteveT
*
*  DATE:        07 June, 1999
*
*  DESCRIPTION: This file contains functions that are used by various different module,
*				or are generic enough to be used by varoius different modules even if 
*				they are only being used in one place at present.
********************************************************************************/

#include "upstab.h"
#include "prsht.h"
#pragma hdrstop

// static data
///////////////////////////////////////////////////////////////////////////////

static HWND g_hUPSPage = 0;                //Used in
                                           //InitializeApplyButton and
                                           //EnableApplyButton

static DWORD g_CurrentActiveDataState = 0; //Used in
                                           //AddActiveDataState
                                           //GetActiveDataState and
                                           //SetActiveDataState

extern HINSTANCE g_hInstance;			   //Global instance handle of this DLL

// functions
///////////////////////////////////////////////////////////////////////////////

DWORD GetServiceStatus_Control (LPCTSTR aServiceName, LPDWORD lpStatus);
DWORD GetServiceStatus_Query   (LPCTSTR aServiceName, LPDWORD lpStatus);
DWORD GetServiceStatus_Enum    (LPCTSTR aServiceName, LPDWORD lpStatus);

DWORD ManageService       (LPCTSTR aServiceName,
                           DWORD aDesiredSCAccess,
                           DWORD aDesiredServiceAccess,
                           DWORD aAction,
                           BOOL bWait,
                           DWORD aWaitStatus,
						   LPDWORD lpStatus);

BOOL WaitForServiceStatus (SC_HANDLE aHandle, DWORD aStatus);
DWORD LoadUPSString       (DWORD aMsgID,
                           LPTSTR aMessageBuffer,
                           DWORD * aBufferSizePtr);

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// HMODULE GetUPSModuleHandle (void);
//
// Description: This function gets the HMODULE of the module that created
//              the UPS tab dialog.
//
// Additional Information: 
//
// Parameters: None
//
// Return Value: Returns the HMODULE of the module that created the dialog.
//
HMODULE GetUPSModuleHandle (void) {
  static HMODULE hModule = NULL;
  
  if (hModule == NULL) {
#ifdef _APC_
    hModule = GetModuleHandle(UPS_EXE_FILE);
#else
    hModule = g_hInstance;
#endif
    }

  return(hModule);
  }


//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// void InitializeApplyButton (HWND aDlgHWND);
//
// Description: This function sets the data needed to allow the
//              EnableApplyButton to 
//
// Additional Information: 
//
// Parameters:
//
//   HWND aDlgHWND :- 
//
// Return Value: None
//
void InitializeApplyButton (HWND aDlgHWND) {
  _ASSERT(g_hUPSPage == 0);
  _ASSERT(aDlgHWND != 0);

  g_hUPSPage = aDlgHWND;
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// void EnableApplyButton (void);
//
// Description: This function enables the "Apply" button on the main UPS page
//
// Additional Information: 
//
// Parameters: None
//
// Return Value: None
//
void EnableApplyButton (void) {
  HWND hParent = 0;

  _ASSERT(g_hUPSPage != 0); //Should call InitializeApplyButton
                            //to initialize.

  hParent = GetParent(g_hUPSPage);
  PropSheet_Changed(hParent, g_hUPSPage);
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// BOOL RestartService (LPCTSTR aServiceName, BOOL bWait);
//
// Description: This function restarts the specified service
//
// Additional Information: 
//
// Parameters:
//
//   LPCTSTR aServiceName :- The name of the service to restart
//
//   BOOL bWait :- A BOOL that specifies if the process should wait for the
//                 the service to fully restart. If TRUE then this process
//                 returns when the service has fully restarted. If FALSE
//                 then this process tells the service to start but does
//                 not wait around for it to be fully started before returning.
//
// Return Value: If the given service restarts successfully then this function
//               returns TRUE, otherwise it returns FALSE.
//
BOOL RestartService (LPCTSTR aServiceName, BOOL bWait) {
  StopService(aServiceName);

  return(StartOffService(aServiceName, bWait));
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// BOOL StartOffService (LPCTSTR aServiceName, BOOL bWaitForService);
//
// Description: This function starts the specified service
//
// Additional Information: 
//
// Parameters:
//
//   LPCTSTR aServiceName :- The name of the service to start
//
//   BOOL bWaitForService :- A BOOL that specifies if the process should wait
//                           for the the service to fully start. If TRUE then
//                           this process returns when the service has fully
//                           started. If FALSE then this process tells the
//                           service to start but does not wait around for it
//                           to be fully started before returning.
//
// Return Value: If the given service starts successfully then this function
//               returns TRUE, otherwise it returns FALSE.
//
BOOL StartOffService (LPCTSTR aServiceName, BOOL bWaitForService) {
  BOOL bStartedOK = FALSE;
  SC_HANDLE hManager = NULL;

  if ((hManager = OpenSCManager(NULL, NULL, GENERIC_READ)) != NULL) {
    SC_HANDLE service_handle = NULL;
    
    if ((service_handle = OpenService(hManager,
                                      aServiceName,
                                      SERVICE_START | SERVICE_INTERROGATE | SERVICE_QUERY_STATUS)) != NULL) {
      SERVICE_STATUS service_status;

      SetLastError(0);

      ZeroMemory(&service_status, sizeof(service_status));

      if ((bStartedOK = StartService(service_handle,
                                     0,
                                     NULL)) == TRUE) {
        SetLastError(0);
        if (bWaitForService == TRUE) {
          bStartedOK = WaitForServiceStatus(service_handle, SERVICE_RUNNING);
          }
        }
      else {
        _ASSERT(FALSE);
        }

      if (CloseServiceHandle(service_handle) == FALSE) {
        _ASSERT(FALSE);
        //error closing service configuration manager
        }
      }

    if (CloseServiceHandle(hManager) == FALSE) {
      //error closing service configuration manager
      _ASSERT(FALSE);
      }
    }

  return(bStartedOK);
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// BOOL WaitForServiceStatus (SC_HANDLE aHandle, DWORD aStatus);
//
// Description: This function waits for the service identified by the given
//              service handle to enter the given state.
//
// Additional Information: 
//
// Parameters:
//
//   SC_HANDLE aHandle :- A handle to an open service.
//
//   DWORD aStatus :- The status to wait for. The allows value for this
//                    parameter are defined by the dwCurrentState member of the
//                    structure.
//
// Return Value: 
//
BOOL WaitForServiceStatus (SC_HANDLE aHandle, DWORD aStatus) {
  SERVICE_STATUS service_status;
  DWORD dwOldCheck = 0;
  BOOL bStatusSet = FALSE;
  
  ZeroMemory(&service_status, sizeof(service_status));

  bStatusSet = QueryServiceStatus(aHandle, &service_status);

  if (bStatusSet == FALSE) {
    return(bStatusSet);
    }

  while (service_status.dwCurrentState != aStatus) {
    dwOldCheck = service_status.dwCheckPoint;

    Sleep(service_status.dwWaitHint);

    if ((bStatusSet = QueryServiceStatus(aHandle, &service_status)) == FALSE) {
      break;
      }

    if (dwOldCheck >= service_status.dwCheckPoint) {
      break;
      }
    }//end while

  if (service_status.dwCurrentState == aStatus) {
    bStatusSet = TRUE;
    }
  else {
    TCHAR errMessageBuffer[MAX_PATH] = TEXT("");
    DWORD errMessageBufferSize = MAX_PATH;
    bStatusSet = FALSE;

    //Must load the error message from "netmsg.dll"

    if ((LoadUPSString(service_status.dwWin32ExitCode,
                       errMessageBuffer,
                       &errMessageBufferSize) == ERROR_SUCCESS) &&
        (*errMessageBuffer != TEXT('\0'))) {
      MessageBox(NULL, errMessageBuffer, NULL, MB_OK | MB_ICONEXCLAMATION);
      }
    }

  return(bStatusSet);
  }


//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// DWORD LoadUPSString (DWORD aMsgID, 
//                      LPTSTR aMessageBuffer, 
//                      DWORD * aBufferSizePtr);
//
// Description: This function load the string resource identified by aMsgID
//              into the buffer identified by aMessageBuffer
//
// Additional Information: 
//
// Parameters:
//
//   DWORD aMsgID :- ID of string resource to load
//
//   LPTSTR aMessageBuffer :- Pointer to a buffer where the string is to be
//                            copied.
//
//   DWORD * aBufferSizePtr :- The size of the buffer. 
//
// Return Value: Returns a Win32 error code. ERROR_SUCCESS on success.
//
DWORD LoadUPSString (DWORD aMsgID,
                     LPTSTR aMessageBuffer,
                     DWORD * aBufferSizePtr) {
  LPTSTR lpBuf = NULL; // Will Hold text of the message (allocated by FormatMessage
  DWORD errStatus = ERROR_SUCCESS;
  DWORD numChars = 0;
  HMODULE hNetMsg = LoadLibrary(TEXT("netmsg.dll"));

  if (hNetMsg != NULL) {
    if (numChars = FormatMessage(FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ALLOCATE_BUFFER,
                                  (LPCVOID) hNetMsg,
                                  aMsgID,
                                  0,
                                  (LPTSTR) &lpBuf,
                                  *aBufferSizePtr,
                                  (va_list *)0) == 0) {

      *aBufferSizePtr = 0;
      *aMessageBuffer = TEXT('\0');
      }
    else {
      if (aBufferSizePtr != NULL) {
        if (numChars < *aBufferSizePtr) {
          //the given buffer is big enough to hold the string

          if (aMessageBuffer != NULL) {
            _tcscpy(aMessageBuffer, lpBuf);
            }
          }
        *aBufferSizePtr = numChars;
        }

      LocalFree(lpBuf);
      }

    FreeLibrary(hNetMsg);
    }

  return(errStatus);
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// void StopService (LPCTSTR aServiceName);
//
// Description: This function stops the service named.
//
// Additional Information: 
//
// Parameters:
//
//   LPCTSTR aServiceName :- The name of the service
//
// Return Value: None
//
void StopService (LPCTSTR aServiceName) {
	DWORD dwStatus = SERVICE_STOPPED;
	DWORD dwError = ERROR_SUCCESS;

	dwError = ManageService(aServiceName,
                GENERIC_READ,
                SERVICE_STOP | SERVICE_INTERROGATE | SERVICE_QUERY_STATUS,
                SERVICE_CONTROL_STOP,
                TRUE,
                SERVICE_STOPPED,
				&dwStatus);
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// BOOL IsServiceRunning (LPCTSTR aServiceName);
//
// Description: This function checks if the service named is running.
//
// Additional Information: 
//
// Parameters:
//
//   LPCTSTR aServiceName :- The name of the service
//
// Return Value: TRUE if the service is running, FALSE otherwise.
//
BOOL IsServiceRunning (LPCTSTR aServiceName)
{
	DWORD dwStatus = SERVICE_STOPPED;

	// There are three methods of retrieving the service status
	// 1. Interrogate the service using ControlService()	- most accurate
	// 2. Query the service using QueryServiceStatus()		- most efficient
	// 3. Query the service using EnumServicesStatus()		- most accessible

	if (GetServiceStatus_Control(aServiceName, &dwStatus) != ERROR_SUCCESS)
	{
		if (GetServiceStatus_Query(aServiceName, &dwStatus) != ERROR_SUCCESS)
		{
			GetServiceStatus_Enum(aServiceName, &dwStatus);
		}
    }

  return(SERVICE_RUNNING == dwStatus);
}

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// DWORD GetServiceStatus_Control (LPCTSTR aServiceName, LPDWORD lpStatus);
//
// Description: This function returns the status of the service named
//              using the Win32 API call ControlService().  This is the
//              most accurate way to retrieve the service staus.
//
// Parameters:
//
//   IN
//   LPCTSTR aServiceName :- The name of the service
//
//   OUT
//   LPDWORD  lpStatus     :- The service status  
//
// Return Value: Returns a Win32 error code. ERROR_SUCCESS on success.
//
DWORD GetServiceStatus_Control (LPCTSTR aServiceName, LPDWORD lpStatus)
{
	DWORD dwError = ERROR_SUCCESS;
	*lpStatus = SERVICE_STOPPED;

	dwError = ManageService(aServiceName,
							SC_MANAGER_ENUMERATE_SERVICE,
							SERVICE_INTERROGATE | SERVICE_QUERY_STATUS,
							SERVICE_CONTROL_INTERROGATE,
							FALSE,
							0,
							lpStatus);

	return dwError;
}

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// DWORD GetServiceStatus_Query (LPCTSTR aServiceName, LPDWORD lpStatus);
//
// Description: This function returns the status of the service named.
//              using the Win32 API call QueryServiceStatus().  This is the
//              most efficient way to retrieve the service staus.
//
// Parameters:
//
//   IN
//   LPCTSTR aServiceName :- The name of the service
//
//   OUT
//   LPDWORD  lpStatus     :- The service status  
//
// Return Value: Returns a Win32 error code. ERROR_SUCCESS on success.
//
DWORD GetServiceStatus_Query (LPCTSTR aServiceName, LPDWORD lpStatus)
{
	DWORD dwError = ERROR_SUCCESS;
	SC_HANDLE hManager = NULL;

	*lpStatus = SERVICE_STOPPED;

	if (NULL != (hManager = OpenSCManager(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE)))
	{
		SC_HANDLE service_handle = NULL;
		if (NULL != (service_handle = OpenService(hManager,
										  aServiceName,
										  SERVICE_QUERY_STATUS)))
		{
		  SERVICE_STATUS service_status;
		  ZeroMemory(&service_status, sizeof(service_status));

		  if( QueryServiceStatus(service_handle, &service_status) != 0 )
		  {
			  *lpStatus = service_status.dwCurrentState;
		  }
		  else
		  {
			  dwError = GetLastError();
		  }

          if (CloseServiceHandle(service_handle) == FALSE)
          {
            _ASSERT(FALSE);
            //error closing service configuration manager
          }
		}
		else
		{
			dwError = GetLastError();
		}

	    if (CloseServiceHandle(hManager) == FALSE)
        {
	      //error closing service configuration manager
	      _ASSERT(FALSE);
        }
	}
	else
	{
		dwError = GetLastError();
	}

	return dwError;
}

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// DWORD GetServiceStatus_Enum (LPCTSTR aServiceName, LPDWORD lpStatus);
//
// Description: This function returns the status of the service named.
//              using the Win32 API call EnumServicesStatus().  This call
//              requires the mimimum access privileges but is the most
//              inefficient accurate way to retrieve the service staus.
//
// Parameters:
//
//   IN
//   LPCTSTR aServiceName :- The name of the service
//
//   OUT
//   LPDWORD  lpStatus     :- The service status  
//
// Return Value: Returns a Win32 error code. ERROR_SUCCESS on success.
//
DWORD GetServiceStatus_Enum (LPCTSTR aServiceName, LPDWORD lpStatus)
{
    DWORD dwError = ERROR_SUCCESS;
    SC_HANDLE hManager;

    _ASSERT( NULL != lpStatus );
    *lpStatus = SERVICE_STOPPED;

    hManager = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT );
    if ( NULL != hManager )
    {
        SC_HANDLE hService = OpenService( hManager, aServiceName, SERVICE_QUERY_STATUS );
        if ( NULL != hService )
        {
            SERVICE_STATUS ss;

            BOOL bRet = QueryServiceStatus( hService, &ss );
            if ( bRet )
            {
                *lpStatus = ss.dwCurrentState;
            }
            else
            {
                dwError = GetLastError( );
            }

            CloseServiceHandle( hService );
            // what do you do if this fails?
        }
        else
        {
            dwError = GetLastError( );
        }

        CloseServiceHandle( hManager );
        // what do you do if this fails?
    }
    else
    {
        dwError = GetLastError( );
    }

    return dwError;
}

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// DWORD ManageService (LPCTSTR aServiceName, 
//                      DWORD aDesiredSCAccess, 
//                      DWORD aDesiredServiceAccess, 
//                      DWORD aAction, 
//                      BOOL bWait, 
//                      DWORD aWaitStatus
//						LPDWORD lpStatus);
//
// Description: This function opens the service named and performs the
//              specified control request on the given service. The
//              function optionally waits on the service to enter the
//              specified status.
//
// Additional Information: 
//
// Parameters:
//
//   LPCTSTR aServiceName :- The name of the service
//
//   DWORD aDesiredSCAccess :- The access to use to open the service control
//                             manager.
//
//   DWORD aDesiredServiceAccess :- The access to use to open the service.
//
//   DWORD aAction :- Specifies the requested control code.
//
//   BOOL bWait :- TRUE specifies that this process should wait for the service
//                 to reach the state identified by aWaitStatus.
//
//   DWORD aWaitStatus :- The service state to wait for.
//
//   OUT
//   LPDWORD lpStatus :- The service status
//
// Return Value: Returns a Win32 error code. ERROR_SUCCESS on success.
//
DWORD ManageService (LPCTSTR aServiceName,
                     DWORD aDesiredSCAccess,
                     DWORD aDesiredServiceAccess,
                     DWORD aAction,
                     BOOL bWait,
                     DWORD aWaitStatus,
					 LPDWORD lpStatus)
{
  DWORD dwError = ERROR_SUCCESS;
  SC_HANDLE hManager = NULL;

  *lpStatus = SERVICE_STOPPED;
  
  if ((hManager = OpenSCManager(NULL, NULL, aDesiredSCAccess)) != NULL) {
    SC_HANDLE service_handle = NULL;
    
    if ((service_handle = OpenService(hManager,
                                      aServiceName,
                                      aDesiredServiceAccess)) != NULL) {
      SERVICE_STATUS service_status;

      ZeroMemory(&service_status, sizeof(service_status));

      if (ControlService(service_handle,
                          aAction,
                          &service_status) == TRUE) {
        //OK we should now know the current state

        if (bWait == TRUE) {
          if (WaitForServiceStatus(service_handle, aWaitStatus) == TRUE) {
            *lpStatus = aWaitStatus;
            }
          else {
            dwError = GetServiceStatus_Enum(aServiceName,lpStatus);
            }
          }
        else {
          *lpStatus = service_status.dwCurrentState;
          }
        }
	  else {
		  dwError = GetLastError();
	  }

      if (CloseServiceHandle(service_handle) == FALSE) {
        _ASSERT(FALSE);
        //error closing service configuration manager
        }
      }
	else {
		dwError = GetLastError();
	}

    if (CloseServiceHandle(hManager) == FALSE) {
      //error closing service configuration manager
      _ASSERT(FALSE);
      }
    }
  else
  {
	  dwError = GetLastError();
  }

  return(dwError);
}

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// void ConfigureService (BOOL aSetToAutoStartBool);
//
// Description: This function sets the UPS service configuration to either
//              automatic or manual.
//
// Additional Information: 
//
// Parameters:
//
//   BOOL aSetToAutoStartBool :- TRUE for automatic. FALSE for manual.
//
// Return Value: None
//
void ConfigureService (BOOL aSetToAutoStartBool) {
  SC_HANDLE hSCM = 0;

  if ((hSCM = OpenSCManager(NULL, NULL, GENERIC_READ | GENERIC_EXECUTE)) != NULL) {
    SC_LOCK hLock = 0;

    if ((hLock = LockServiceDatabase(hSCM)) != NULL) {
      SC_HANDLE hService = 0;

      if ((hService = OpenService(hSCM, UPS_SERVICE_NAME, SERVICE_CHANGE_CONFIG)) != NULL) {
        DWORD dwStartType = 0;

        dwStartType = (aSetToAutoStartBool == TRUE) ? SERVICE_AUTO_START : SERVICE_DEMAND_START;

        ChangeServiceConfig(hService,
                            SERVICE_NO_CHANGE,
                            dwStartType,
                            SERVICE_NO_CHANGE,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL);

        CloseServiceHandle(hService);
        }//end Open
      UnlockServiceDatabase(hLock);
      }//end Lock
    CloseServiceHandle(hSCM);
    }//end OpenSCM
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// void AddActiveDataState (DWORD aBitToSet);
//
// Description: This function adds the given bit to current active data state.
//              The active data state is the state of the current UPS data set.
//              The UPS data set can include SERVICE_DATA_CHANGE and
//              CONFIG_DATA_CHANGE which signify that the service data like UPS
//              vendor, model name, etc, has changed. SERVICE_DATA_CHANGE is
//              for data the require the service to be restarted when changed.
//              CONFIG_DATA_CHANGE is for data that has changed but that does
//              not require a service restart.
//
// Additional Information: 
//
// Parameters:
//
//   DWORD aBitToSet :- The bit to set. Can be either SERVICE_DATA_CHANGE or
//                      CONFIG_DATA_CHANGE.
//
// Return Value: None
//
void AddActiveDataState (DWORD aBitToSet) {
  g_CurrentActiveDataState |= aBitToSet;
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// DWORD GetActiveDataState (void);
//
// Description: This function returns the current value of the active data
//              set. This value should be & with SERVICE_DATA_CHANGE and
//              CONFIG_DATA_CHANGE to determine the current active data state.
//
// Additional Information: 
//
// Parameters: None
//
// Return Value: Returns the current active data state.
//
DWORD GetActiveDataState (void) {
  return(g_CurrentActiveDataState);
  }

//////////////////////////////////////////////////////////////////////////_/_//
//////////////////////////////////////////////////////////////////////////_/_//
// void SetActiveDataState (DWORD aNewValue);
//
// Description: This function replaces the current value of the active data
//              state.
//
// Additional Information: 
//
// Parameters:
//
//   DWORD aNewValue :- The new value for the active data state.
//
// Return Value: None
//
void SetActiveDataState (DWORD aNewValue) {
  g_CurrentActiveDataState = aNewValue;
  }