Daemon.xs

//////////////////////////////////////////////////////////////////////////////
//
//  Daemon.cpp
//  Win32::Daemon Perl extension main source file
//
//  Copyright (c) 1998-2008 Dave Roth
//  Courtesy of Roth Consulting
//  http://www.roth.net/
//
//  This file may be copied or modified only under the terms of either 
//  the Artistic License or the GNU General Public License, which may 
//  be found in the Perl 5.0 source kit.
//
//  2008.03.24  :Date
//  20080324    :Version
//////////////////////////////////////////////////////////////////////////////


// Enable Win32::Daemon callback support
#define ENABLE_CALLBACKS

// Enable MS Visual Studio 2005's secure stdlib
// The _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES macro defined with a value of 1
// will swap out a secured version of stdlib functions. These perform buffer overrun
// checking and such.
//	define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES	1

//	As an alternative you can keep the depricated function calls and block out any
//	security warnings by defining the _CRT_SECURE_NO_DEPRECATE macro.
#define _CRT_SECURE_NO_DEPRECATE



#define WIN32_LEAN_AND_MEAN

#ifdef __BORLANDC__
typedef wchar_t wctype_t; /* in tchar.h, but unavailable unless _UNICODE */
#endif

#include <windows.h>
#include <tchar.h>
#include <wtypes.h>
#include <stdio.h>      //  Gurusamy's right, Borland is brain damaged!
#include <math.h>       //  Gurusamy's right, MS is brain damaged!
#include <time.h>

//  Use headers that define the security stuff
#include <lmaccess.h>
#include <lmserver.h>
#include <lmapibuf.h>
#include <LMERR.H>      //  For the NERR_Succes macro

#include "XS_Win32Perl.h"
//	#include <preWin32Perl.h>
//	#include <Win32Perl.h>

#include "constant.h"
#include "CWinStation.hpp"
#include "ServiceThread.hpp"

#ifdef ENABLE_CALLBACKS
	#include "CCallbackList.hpp"
	#include "CCallbackTimer.hpp"
#endif // ENABLE_CALLBACKS
#include "daemon.h"

#define SET_SERVICE_BITS_LIBRARY    TEXT( "AdvApi32.dll" )
#define SET_SERVICE_BITS_FUNCTION   TEXT( "SetServiceBits" )


/*----------------------- M I S C   F U N C T I O N S -------------------*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int My_SetServiceBits( SERVICE_STATUS_HANDLE hService, DWORD dwServiceBits, BOOL bSetBitsOn, BOOL bUpdateImmediately )
{
    int iResult = 0;
    HINSTANCE hInstance;
    DWORD dwMask = USER_SERVICE_BITS_MASK;      // Default mask. These bits are not reserved by MS. We can use these w/o problems w/MS products.

    hInstance = LoadLibrary( SET_SERVICE_BITS_LIBRARY );
    if( NULL != hInstance )
    {
        typedef BOOL (CALLBACK *fSetServiceBits) ( SERVICE_STATUS_HANDLE hServiceGoo, DWORD dwBits, BOOL bBitsOn, BOOL bUpdate );
        fSetServiceBits pSetServiceBits = NULL;
        pSetServiceBits= (fSetServiceBits) GetProcAddress( hInstance, SET_SERVICE_BITS_FUNCTION );
        if( NULL != pSetServiceBits )
        {
            // Note:
            // We clear all user defined bits before applying our bits. If this sucks
            // then use something like Win32::Lanman. We only want to track our bits
            // and not mess with others.

            //  First clear all user defined bits...
            // My_SetServiceBits() will mask out the user bits from the passed in DWORD.
            (*pSetServiceBits)( ghService, 0xFFFFFFFF, FALSE, FALSE );

            // Mask those lovely bits!
            dwServiceBits &= dwMask;
            iResult = (*pSetServiceBits)( hService, dwServiceBits, bSetBitsOn, bUpdateImmediately );
        }
    }

    return( iResult );
}

BOOL GetProcessSid( HANDLE hProcess, SID *pSid, DWORD dwSidBufferSize )
{
    BOOL fResult = FALSE;
    HANDLE hToken = NULL;

    if( ( NULL == pSid ) || ( sizeof( SID ) > dwSidBufferSize ) )
    {
        return( FALSE );
    }

    // Manually get the process token since we need it for more than just
    // calling into SetPrivilege()...
    if( OpenProcessToken(
            hProcess,
            TOKEN_ADJUST_PRIVILEGES
            | TOKEN_QUERY
            | TOKEN_QUERY_SOURCE,
            &hToken ) )
    {
        // Now that you have the token for this process, you want to set
        // the SE_DEBUG_NAME privilege.

// TODO:
// We may want to not do this here. Only if we show the
// service. Otherwise this may give us too many privileges that
// we may not want to have

        SetPrivilege( hToken, SE_DEBUG_NAME, TRUE );

        // Determine the SID for the current process. We need
        // to give this SID permissions to access the
        // desktop object...
        fResult =  GetSidFromToken( hToken, pSid, dwSidBufferSize );
        CloseHandle( hToken );
    }
    return( fResult );
}


////////////////////////////////////////////////////////////////////////////
//  ResetCallbackTimer()
//  Stops or changes the callback timer.
//  Passing in nothing simply stops/starts the timer (depending upon the state)
//  Passing in 0 stops the timer.
//  Passing in any positive value starts the timer and sets that value as callback timeout.
//  
//	Default pass in value is -1 (if nothing is specified).
//
/*
BOOL ResetCallbackTimer( UINT uintTimeoutValue )
{
    //
    // If the callback timer is active then kill it
    //
    if( 0 != gpuintCallbackTimerID )
    {
        KillTimer( NULL, gpuintCallbackTimerID );
        gpuintCallbackTimerID = 0;
        if( -1 == uintTimeoutValue )
        {
            return( TRUE );
        }
    }

    //
    //  Are we changing the value? A 0 means to simply stop
    //  the timer. Otherwise change the timeout value...
    //
    if( 0 == uintTimeoutValue ) return( TRUE );

    if( 0 <= (int) uintTimeoutValue )
    {
        guintCallbackTimer = uintTimeoutValue;
    }
        
    if( 0 != guintCallbackTimer )
    {
        gpuintCallbackTimerID = SetTimer( NULL, CALLBACK_RUNNING_TIMER, guintCallbackTimer, (TIMERPROC) NULL );
    }
    
    return( TRUE );
}
*/

////////////////////////////////////////////////////////////////////////////
//  Fill in a SID buffer from the specified token
BOOL GetSidFromToken( HANDLE hToken, SID *pSid, DWORD dwSidBufferSize )
{
    BOOL fResult = FALSE;

    if( NULL != hToken )
    {
        PTOKEN_USER  pTokenUserStruct = NULL;
        DWORD dwLength = 0;

        if( FALSE == GetTokenInformation(
                hToken,
                TokenUser,
                pTokenUserStruct,
                0,
                &dwLength ) )
        {
            pTokenUserStruct = (PTOKEN_USER) new BYTE [ dwLength ];
            if( NULL != pTokenUserStruct )
            {
                ZeroMemory( pTokenUserStruct, dwLength );
                if( GetTokenInformation(
                        hToken,
                        TokenUser,
                        pTokenUserStruct,
                        dwLength,
                        &dwLength ) )
                {
                    if( FALSE != IsValidSid( pTokenUserStruct->User.Sid ) )
                    {
                        DWORD dwSidLength;

                        dwSidLength = GetLengthSid( pTokenUserStruct->User.Sid );
                        if( dwSidLength <= dwSidBufferSize )
                        {
                            fResult = CopySid( dwSidLength, pSid, pTokenUserStruct->User.Sid );
                        }
                    }
                }
                delete [] pTokenUserStruct;
            }
        }
    }
    return( fResult );
}

////////////////////////////////////////////////////////////////////////////
// The SetPrivilege function will accept a handle to a token, a
// privilege, and a flag to either enable/disable that privilege. The
// function will attempt to perform the desired action upon the token
// returning TRUE if it succeeded, or FALSE if it failed.
BOOL SetPrivilege( HANDLE hToken, const char *pszPrivilege, BOOL bSetFlag )
{
    TOKEN_PRIVILEGES structPriv, structPrevPriv;
    LUID Luid;
    DWORD dwStructSize = sizeof( structPrevPriv );
    BOOL fResult = FALSE;
    BOOL fCloseToken = FALSE;

    // If no token is specified assume that the process token is desired.
    if( 0 == hToken )
    {    
        OpenProcessToken(
            GetCurrentProcess(),
            TOKEN_ADJUST_PRIVILEGES
            | TOKEN_QUERY
            | TOKEN_QUERY_SOURCE,
            &hToken );
        fCloseToken = TRUE;
    }
    if( 0 != hToken )
    {
        ZeroMemory( &structPrevPriv, sizeof( structPrevPriv ) );
        ZeroMemory( &structPriv, sizeof( structPriv ) );

        // Grab the LUID for the request privilege.
        if( LookupPrivilegeValue( "", pszPrivilege, &Luid ) )
        {
            // Set up basic information for a call.
            // You want to retrieve the current privileges
            // of the token under concern before you can modify them.
            structPriv.PrivilegeCount = 1;
            structPriv.Privileges[0].Luid = Luid;
            structPriv.Privileges[0].Attributes = ( bSetFlag )? SE_PRIVILEGE_ENABLED : 0;


            // You need to acquire the current privileges first
            fResult = ( FALSE != AdjustTokenPrivileges(
                                    hToken,
                                    0,
                                    &structPriv,
                                    sizeof( structPriv ),
                                    &structPrevPriv,
                                    &dwStructSize ) );
        }
        if( FALSE != fCloseToken )
        {
            CloseHandle( hToken );
        }
    }
    return( fResult );
}

////////////////////////////////////////////////////////////////////////////
//  Fill the specified text buffer with the text representation of the
//  specified SID.
//  NOTE: The buffer must have enough memory to represent the SID.
void TextFromSid( LPTSTR pszBuffer, SID *pSid )
{
    TCHAR szTemp[ 100 ];
    int iCount;
    PUCHAR puCount;

    SID_IDENTIFIER_AUTHORITY *pSia;

    if( FALSE == IsValidSid( pSid ) )
    {
        return;
    }

    pSia = GetSidIdentifierAuthority( pSid );

    //  Create the string version of the SID
    //  We begin by S (for SID) - the revision level - the authority
    //  identifier. Note that we are assuming that the Authority ID is in
    //  the sixth element (element #5 starting at 0) in Authority Identifier
    //  structure. Currently as of this writing SID strings do not display
    //  the other values in the pSiz strucutre. They are normally something
    //  like: {0,0,0,0,0,5} where the last byte contains a value and the others
    //  are zero.
    iCount = wsprintf( pszBuffer, TEXT( "S-%d-%d" ), pSid->Revision, (DWORD) pSia->Value[5] );
    puCount = GetSidSubAuthorityCount( pSid );
    for( DWORD dwTemp = 0; dwTemp < *puCount; dwTemp++ )
    {
        wsprintf( szTemp, TEXT( "-%d" ), (DWORD) *( GetSidSubAuthority( pSid, dwTemp ) ) );
        _tcscat( pszBuffer, szTemp );
    }
}

////////////////////////////////////////////////////////////////////////////
//  Load the user's profile hive into the HKEY_USERS Registry key.
BOOL LoadProfile( SID *pSid )
{
    BOOL fResult = FALSE;
    TCHAR szUserProfilePath[ 1024 ];
    TCHAR szSid[ 64 ];
    HKEY hKey = NULL;
#ifdef DEBUG
    TCHAR szDebugText[ 1024 ];
#endif // DEBUG

    ZeroMemory( szSid, sizeof( szSid ) );
    TextFromSid( szSid, pSid );

    _tcscpy( szUserProfilePath, REG_KEY_USER_LOCAL_PROFILE );
    _tcscat( szUserProfilePath, szSid );

#ifdef DEBUG
    wsprintf( szDebugText, TEXT( "[LoadProfile] Loading profile for %s" ), szSid );
    ALERT( szDebugText );
#endif

    // Check to see if we already have the profile loaded
    if( ERROR_SUCCESS == RegOpenKeyEx( HKEY_USERS,
                                        szSid,
                                        0,
                                        KEY_READ,
                                        &hKey ) )
    {
        RegCloseKey( hKey );
        ALERT( "[LoadProfile] Profile already loaded." );
        return( TRUE );
    }

    // If we got here then the profile is not loaded, let's load it.
    // First open the Registry key where profile info is held
    if( ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                                        szUserProfilePath,
                                        0,
                                        KEY_READ,
                                        &hKey ) )
    {
        TCHAR szCentralPath[ MAX_PATH + 1 ];
        TCHAR szLocalPath[ MAX_PATH + 1 ];
        DWORD dwLength;
        DWORD dwType;
        HANDLE hToken = NULL;

        _tcscpy( szCentralPath, TEXT( "" ) );
        _tcscpy( szLocalPath, TEXT( "" ) );

        // We need to be granted Restore Name privileges. Otherwise
        // we won't be able to load the profile
        if( OpenProcessToken(
                GetCurrentProcess(),
                TOKEN_ADJUST_PRIVILEGES
                | TOKEN_QUERY
                | TOKEN_QUERY_SOURCE,
                &hToken ) )
        {
            // Now that you have the token for this process, you want to set
            // the SE_RESTORE_NAME privilege.
            SetPrivilege( hToken, SE_RESTORE_NAME, TRUE );
        }

        dwLength = sizeof( szCentralPath );
        if( ERROR_SUCCESS == RegQueryValueEx(
                                hKey,
                                REG_VALUE_USER_CENTRAL_PROFILE_PATH,
                                0,
                                &dwType,
                                (LPBYTE) szCentralPath,
                                &dwLength
                                ) )
        {
            // Expand environment variables if needed
            if( REG_EXPAND_SZ == dwType )
            {
                TCHAR szBuffer[ MAX_PATH + 1 ];

                _tcscpy( szBuffer, szCentralPath );
                ExpandEnvironmentStrings( szBuffer, szCentralPath, sizeof( szCentralPath ) );
            }
        }

        dwLength = sizeof( szLocalPath );
        if( ERROR_SUCCESS == RegQueryValueEx(
                                hKey,
                                REG_VALUE_USER_LOCAL_PROFILE_PATH,
                                0,
                                &dwType,
                                (LPBYTE) szLocalPath,
                                &dwLength
                                ) )
        {
            // Expand environment variables if needed
            if( REG_EXPAND_SZ == dwType )
            {
                TCHAR szBuffer[ MAX_PATH + 1 ];

                _tcscpy( szBuffer, szLocalPath );
                ExpandEnvironmentStrings( szBuffer, szLocalPath, sizeof( szLocalPath ) );
            }
        }

        if( 0 != _tcscmp( szCentralPath, TEXT( "" ) ) )
        {
            TCHAR szProfilePath[ MAX_PATH ];

            _tcscpy( szProfilePath, szCentralPath );
            _tcscat( szProfilePath, TEXT( "\\" ) );
            _tcscat( szProfilePath, USER_PROFILE_HIVE_NAME );

            // Try to load the profile. This may fail if the
            // path is a UNC to another machine or for other
            // reasons. RegLoadKey() seems to only load local
            // copies of profiles--possibly to prevent corruption
            // if the net goes down.
            // If this is the case we may want to copy the file
            // over.
            if( ERROR_SUCCESS == RegLoadKey(
                                            HKEY_USERS,
                                            szSid,
                                            szProfilePath
                                            ) )
            {
                fResult = TRUE;
#ifdef DEBUG
                wsprintf( szDebugText, TEXT( "[LoadProfile] Loaded %s" ), szProfilePath );
                ALERT( szDebugText );
#endif
            }
            else if( 0 != _tcscmp( szLocalPath, TEXT( "" ) ) )
            {
                TCHAR szDestination[ MAX_PATH ];

                _tcscpy( szDestination, szLocalPath );

                // determine if it is a file or directory, WinNT 4.0 it is a
                // directory
                // WinNT 3.51 it is a file
                //
                if( FILE_ATTRIBUTE_DIRECTORY == ( GetFileAttributes( szProfilePath )
                                                  & FILE_ATTRIBUTE_DIRECTORY ) )
                {
                    _tcscat( szProfilePath, TEXT( "\\" ) );
                    _tcscat( szProfilePath, USER_PROFILE_HIVE_NAME );
                }


                // Copy the profile hive file from the origin location to the
                // local local cached profile
                CopyFile( szProfilePath, szDestination, TRUE );
#ifdef DEBUG
                wsprintf( szDebugText, TEXT( "[LoadProfile] Copied path from %s to %s" ), szProfilePath, szDestination );
                ALERT( szDebugText );
#endif

            }
        }

        // Were we successful?
        if( ( FALSE == fResult ) && ( 0 != _tcscmp( szLocalPath, TEXT( "" ) ) ) )
        {
            // No, try loading the local path.
            TCHAR szProfilePath[ MAX_PATH ];

            _tcscpy( szProfilePath, szLocalPath );


            // determine if it is a file or directory, WinNT 4.0 it is a
            // directory
            // WinNT 3.51 it is a file
            //
            if( FILE_ATTRIBUTE_DIRECTORY == ( GetFileAttributes( szProfilePath )
                                              & FILE_ATTRIBUTE_DIRECTORY ) )
            {
                _tcscat( szProfilePath, TEXT( "\\" ) );
                _tcscat( szProfilePath, USER_PROFILE_HIVE_NAME );
            }

            // Try to load the profile.
            if( ERROR_SUCCESS == RegLoadKey(
                                            HKEY_USERS,
                                            szSid,
                                            szProfilePath
                                            ) )
            {
                fResult = TRUE;
#ifdef DEBUG
                wsprintf( szDebugText, TEXT( "[LoadProfile] Loaded %s" ), szProfilePath );
                ALERT( szDebugText );
#endif
            }
        }

        RegCloseKey( hKey );
    }

    return( fResult );
}

//////////////////////////////////////////////////////////////////
//  Store the service's description in the Registry. Win2k does
//  this for you but we need to be backward compatible.
BOOL StoreServiceDescription( LPCTSTR pszMachine, LPCTSTR pszServiceName, LPCTSTR pszDescription )
{
    HKEY hRoot = HKEY_LOCAL_MACHINE;
    HKEY hKey = NULL;
    BOOL fFlag = TRUE;
    BOOL fResult = FALSE;

    if( 0 != _tcscmp( TEXT( "" ), pszMachine ) )
    {
        fFlag = ( ERROR_SUCCESS == RegConnectRegistry( pszMachine, HKEY_LOCAL_MACHINE, &hRoot ) );
    }

    if( TRUE == fFlag )
    {
        TCHAR szBuffer[ 75 ];
        _stprintf( szBuffer, REGISTRY_SERVICE_PATH TEXT( "\\%s" ), pszServiceName );
        if( ERROR_SUCCESS == RegOpenKeyEx( hRoot, szBuffer, 0, KEY_SET_VALUE, &hKey ) )
        {
            DWORD dwSize = (DWORD)_tcslen( pszDescription ) * sizeof( TCHAR );
            fResult = ( ERROR_SUCCESS == RegSetValueEx( hKey, REGISTRY_SERVICE_KEYWORD_DESCRIPTION, 0, REG_SZ, (LPBYTE) pszDescription, dwSize ) );
        }
        RegCloseKey( hKey );
    }

    if( 0 != _tcscmp( TEXT( "" ), pszMachine ) )
    {
        RegCloseKey( hRoot );
    }

    return( fResult );
}


#ifdef ENABLE_CALLBACKS
//////////////////////////////////////////////////////////////////
//  The idea here is that when a state change occurs because the
//	SCM has submitted a command (stop, pause, start, interrogate, etc)
//	we can call this function. If callbacks have been enabled then 
//	this function will execute the Perl callback if a callback routine 
//	has been provided. Otherwise we just pass through.
//  
BOOL ProcessStateChange( pTHX_ DWORD dwCommand, HV* pHvContext )
{
	BOOL fMakeContextHash = FALSE;
	PVOID pSvSubroutine = gCallback.Get( dwCommand );
	
	//
	// The SERVICE_CONTROL_TIMER has replaced SERVICE_RUNNING. Since
	// SERVICE_RUNNING is easily confused with another constant with teh
	// same value we have renamed this SERVICE_CONTROL_RUNNING for clarity.
	// Regardless, SERVICE_CONTROL_RUNNING is being depreciated and replaced
	// with SERVICE_CONTROL_TIMER to better indicate why the callback is 
	// occuring.
	// For legacy purposes:
	//	1) Registering a "running" callback will still work
	//	2) Registering a "timer" callback is preferred instead of "running"
	//	3) Registering both will result in only a "timer" callback
	//
	// Now let's check if this is the timer command AND if the script has
	// registered only the "running" callback...
	if( SERVICE_CONTROL_TIMER == dwCommand )
	{
//
//	Code currently changes 3) to result in "running" for legacy support
//	if code called Callback() passing in only one catchall subroutine reference
//

		PVOID pSvTemp;
		pSvTemp = gCallback.Get( SERVICE_CONTROL_RUNNING );
		if( NULL != pSvTemp )
		{
			pSvSubroutine = pSvTemp;
			dwCommand = SERVICE_CONTROL_RUNNING;
		}

     }	

#ifdef aTHX
    if( NULL == aTHX )
    {
        return( FALSE );
    }
#endif // aTHX
    
	if( NULL == pSvSubroutine )
	{
		return( FALSE );
	}

	ALERT( "ProcessStateChange: checking for context hash..." );
	// If there is no context hash provided then make one...
	if( NULL == pHvContext )
	{
		ALERT( "ProcessStateChange: Creating a new context hash" );
		pHvContext = newHV();
	}
	else
	{
		// If we don't create the context HV then increase its ref count because
		// later we will decrease it. If we created the HV then the decrease will
		// auto destroy it.
		ALERT( "ProcessStateChange: Increasing ref count on existing context hash" );
		SvREFCNT_inc( (SV*) pHvContext );
	}

	 ALERT( "ProcessStateChange: Storing value into context hash" );
	HASH_STORE_IV( pHvContext, KEYWORD_CALLBACK_COMMAND_NAME, dwCommand );

	ALERT( "ProcessStateChange: Checking for a valid subroutine" );
	if( SVt_PVCV == SvTYPE( (SV*) pSvSubroutine ) )
	{
		ALERT( "About to call into a Perl routine..." );
		//	Call into the Perl subroutine
		//  Push onto the stack the hash context
		CallPerlRoutine( aTHX_ (CV*) pSvSubroutine, 
						dwCommand,
						pHvContext );
		ALERT( "Back from calling into a Perl routine..." );
		//	Callback into the subroutine.
		//	The subroutine should look like:
		//
		//	sub EventCallback
		//	{
		//	  my( $Event, $Context ) = @_;
		//		# Process the event
		//		Win32::Daemon::State( $NewState );		
		//	  return;
		//	}
		//
		//	=================== OR ====================
		//	sub EventCallback
		//	{
		//	  my( $Event, $Context ) = @_;
		//		# Process the event
		//	  return( $NewState );
		//	}

	}
	
	// Decrease the context HV reference counter. If we created the HV then it is
	// unloaded at this time. Otherwise we have previously increased the count so
	// this just decreases it back to where it started at the beginning of this
	// routine.
	SvREFCNT_dec( (SV*) pHvContext );
	return( TRUE );
}
#endif // ENABLE_CALLBACKS

#ifdef ENABLE_CALLBACKS
////////////////////////////////////////////////////////////////////////////
//  CallPerlRoutine()
//  This will callback into a specified Perl subroutine passing in any
//  SVs that are passed into the function.
//  Nothing is returned.
//
//  void CallPerlRoutine( pTHX_ CV* pPerlSubroutine, int iTotalParams, ... )
void CallPerlRoutine( pTHX_ CV* pPerlSubroutine, DWORD dwCommand, HV* pHvContext )
{
    SV *pSv = NULL;
    int iReturnedItems = 0;

	// Make sure that a routine was passed in AND that it is really a code reference
    if( ( NULL == pPerlSubroutine ) || ( SVt_PVCV != SvTYPE( (SV*) pPerlSubroutine ) ) )
    {
        return;
    }

    //  Declare necessary vars...
    dSP;

    //  Begin a new scope...
    ENTER;

    //  Start mortal stack. All mortals after this point will be put onto this stack
    //  which will be freeded up later with FREETMPS
    SAVETMPS;

    //  Remember (or push) the current position of the stack...
    ALERT( "CallPerlRoutine: Pushing parameters onto the perl stack" );
    PUSHMARK( sp );
    XPUSHs( sv_2mortal( newSViv( (IV) dwCommand ) ) );
    XPUSHs( (SV*) newRV_inc( (SV*) pHvContext ) );
    //  Mark the end of arguments on the stack...
    PUTBACK;
    ALERT( "CallPerlRoutine: Done: Pushed parameters onto the perl stack" );

	TCHAR szBuff[ 256 ];
    sprintf( szBuff, "CallPerlRoutine: Calling into Perl for command: 0x%04x.\n", dwCommand );
    ALERT( szBuff );

    ALERT( "CallPerlRoutine: Calling into the perl routine now..." );

	iReturnedItems = perl_call_sv( (SV*) pPerlSubroutine, G_SCALAR );
    
	ALERT( "CallPerlRoutine: ...Back from calling the perl routine." );
    
    //  Begin the process of unwinding the return stack...
    SPAGAIN;

	if( iReturnedItems )
	{
		SV *pSvReturn = POPs;

		//
		//	Check if the return value is an integer
		//
		if( SvIOK( pSvReturn ) )
		{
			//
			//	Any integer return value is a new state value
			//	so update the service's state. Specify waithint value of 0
			//	and error value of 0xFFFFFFFF to use defaults.
			//
                        DWORD dwNewState = (DWORD)SvIV( pSvReturn );
			UpdateServiceStatus( dwNewState, 0, 0xFFFFFFFF );
		}

		//
		//	NOTE: the while() look predecriments iReturnedItems to 
		//	accomodate the new state value taken off of the stack
		//
		while( --iReturnedItems )
		{
			//  Pop an SV off of the return stack...
			POPs;
		}
	}

    //  We are done here so put back the stack pointer...
    PUTBACK;

    //  Unwind and destroy any mortals that are on our temp stack...
    FREETMPS;

    //  Leave our little scope...
    LEAVE;
}
#endif // ENABLE_CALLBACKS


////////////////////////////////////////////////////////////////////////////
//  DispatchThreadMessage()
//  This is called for every message that the thread message queue receives.
//	This is used instead of DispatchMessage() since there is no window available.
//
void DispatchThreadMessage( MSG *pMsg )
{
	// Retrieve the Perl context...
	dTHX;

#ifdef _DEBUG
    TCHAR szBuffer[ 1024 ];
    wsprintf( szBuffer, TEXT( "Servicing Thread Message Queue: Message = 0x%04x; aTHX = 0x%04x." ), pMsg->message, aTHX );
    ALERT( szBuffer );
#endif // _DEBUG

	BOOL fCallbackState = FALSE;

	switch( pMsg->message )
	{
        case WM_DAEMON_STATE_CHANGE:
		// We have a state change!
		// Notice we are using gPerlObject here! Therefore we MUST be in 
		// callback mode!
		//
		//  First reset the timer. Don't pass in any value so that it just
		//  temporarily pauses the timer. The next time you call it without
		//  any params it will start it again. This prevents queuing up 
		//  timeout messages if the callback takes time. 
		ALERT( TEXT( "...processing WM_DAEMON_STATE_CHANGE message\n" ) )
		fCallbackState =  gCallbackTimer.QueryState();
		if( fCallbackState )
		{
			gCallbackTimer.Stop();
		}
		ProcessStateChange( aTHX_ (DWORD) pMsg->wParam, gpHvContext );
		if( fCallbackState )
		{
			gCallbackTimer.Start();
		}
		break;
        
	case WM_TIMER:
		//
		//  You get here when the callback timeout value has been exceeded. This
		//  simply means that it is time to callback into the Perl script to give
		//  the script a chance to process anything it needs to.
		//  The script sees this event as a "SERVICE_RUNNING" event.
		//
			//
		//  First reset the timer. Don't pass in any value so that it just
		//  temporarily pauses the timer. The next time you call it without
		//  any params it will start it again. This prevents queuing up 
		//  timeout messages if the callback takes time. 
		ALERT( TEXT( "...processing WM_TIMER message (heartbeat callback)\n" ) )
		fCallbackState =  gCallbackTimer.QueryState();
		if( fCallbackState )
		{
			gCallbackTimer.Stop();
		}
		ProcessStateChange( aTHX_ (DWORD) SERVICE_CONTROL_TIMER, gpHvContext );
		if( fCallbackState )
		{
			gCallbackTimer.Start();
		}
		break;
		
	default:
		ALERT( "...Default handler has been invoked." );
	
    }
}

////////////////////////////////////////////////////////////////////////////
//  TimerProc()
//  This is called by a Win32 Timer every time the timer's timeout value is
//  reached. This is used to determine when to callback into the Perl script
//  to allow it for processing. When the callback into Perl occurs it does 
//  so indicating the SERVICE_RUNNING state.
//
void CALLBACK TimerProc(
   HWND hWnd,      // handle of CWnd that called SetTimer
   UINT nMsg,      // WM_TIMER
   UINT nIDEvent,   // timer identification
   DWORD dwTime    // system time
)
{
    MSG sMsg;

    ZeroMemory( &sMsg, sizeof( sMsg ) );
    sMsg.hwnd = hWnd;
    sMsg.lParam = 0;
    sMsg.message = WM_TIMER;
//    sMsg.pt = 0;
    sMsg.time = dwTime;
    sMsg.wParam = nIDEvent;

    DispatchThreadMessage( &sMsg );
}


#ifdef _DEBUG
//////////////////////////////////////////////////////////////////
//
//
HANDLE CreateLog( LPCTSTR pszPath )
{
    HANDLE hFile = 0;

    ZeroMemory( gszDebugOutputPath, sizeof( gszDebugOutputPath ) );
    _tcsncpy( gszDebugOutputPath, pszPath, sizeof( gszDebugOutputPath ) - 1 );

    if( 0 != ghLogFile )
    {
        CloseHandle( ghLogFile );
        ghLogFile = 0;
    }

    if( _tcscmp( TEXT( "" ), gszDebugOutputPath ) != 0 )
    {
        ghLogFile = CreateFile( gszDebugOutputPath,
                                GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ,
                                NULL,
                                CREATE_ALWAYS,
                                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH,
                                NULL );
        if( 0 == ghLogFile )
        {
            _tcscpy( gszDebugOutputPath, TEXT( "" ) );
        }
    }
    return( ghLogFile );
}
#endif // _DEBUG


/* ===============  DLL Specific  Functions  ===================  */
//////////////////////////////////////////////////////////////////
#if defined(__cplusplus)
extern "C"
#endif
BOOL WINAPI DllMain( HINSTANCE  hinstDLL, DWORD fdwReason, LPVOID  lpvReserved )
{
    BOOL    fResult = TRUE;
    DWORD	dwSidBuferSize = MAX_SID_SIZE;

    // Fetch the OS version number...
    ZeroMemory( &gsOSVerInfo, sizeof( gsOSVerInfo ) );
    gsOSVerInfo.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
    GetVersionEx( &gsOSVerInfo );
    
    switch( fdwReason )
    {
        case DLL_PROCESS_ATTACH:

            ghDLL = hinstDLL;

#ifdef ENABLE_CALLBACKS            
            gfCallbackMode = FALSE;
//            gpPerlObject = NULL;
            gpHvContext = NULL;
#endif // ENABLE_CALLBACKS            
  
            gdwLastError = 0;
            gdwServiceErrorState = NO_ERROR;
            ghService = 0;
            ghServiceThread = 0;
            gServiceThreadId = 0;
			gServiceMainThreadID = 0;

#ifdef ENABLE_CALLBACKS
			//
			//	Setup the callback timer
			//
			gCallbackTimer.SetMessageID( CALLBACK_TIMER_ID );
			gCallbackTimer = DEFAULT_CALLBACK_TIMER;
#endif	// ENABLE_CALLBACKS			

			gMainThreadId = GetCurrentThreadId();
			gdwLastControlMessage = SERVICE_CONTROL_NONE;
			gdwTimeoutState = SERVICE_START_PENDING;
			
			gdwControlsAccepted = 0;
			switch( gsOSVerInfo.dwMajorVersion )
			{
				default:
					// We have Windows Vista
					//  The following constants only work on Vista and higher:
					//      SERVICE_ACCEPT_PRESHUTDOWN
					//
#ifdef SERVICE_CONTROL_PRESHUTDOWN 					
					gdwControlsAccepted |= SERVICE_ACCEPT_PRESHUTDOWN;
#endif	// SERVICE_CONTROL_PRESHUTDOWN 			

				case 5:
					// We have Windows 2000 or XP
					//  The following constants only work on Win2k and higher:
					//      SERVICE_ACCEPT_PARAMCHANGE
					//      SERVICE_ACCEPT_NETBINDCHANGE
					//
					gdwControlsAccepted |= SERVICE_ACCEPT_PARAMCHANGE  
										   | SERVICE_ACCEPT_NETBINDCHANGE;
										
            	case 4:
				case 3:
				case 2:
				case 1:
				case 0:
					// NT 4.0
					gdwControlsAccepted |= SERVICE_ACCEPT_STOP 
										  | SERVICE_ACCEPT_PAUSE_CONTINUE
										  | SERVICE_ACCEPT_SHUTDOWN;

			}
			gdwServiceType = SERVICE_WIN32_OWN_PROCESS 
                             | SERVICE_INTERACTIVE_PROCESS;
            gdwServiceBits = 0;
            gdwLastError = 0;
            gpSid = NULL;


            // Set the state to 0. This way we know when the service thread actually
            // starts because it will set the state to SERVICE_START_PENDING
            gdwState = 0;
            ZeroMemory( &gServiceStatus, sizeof( gServiceStatus ) );

            if( ! GetModuleFileName( ghDLL, gszModulePath, sizeof( gszModulePath ) ) )
            {
                _tcscpy( gszModulePath, TEXT( "" ) );
            }

#ifdef _DEBUG
            // Init a critical section for debug output. This way multiple threads
            // won't overrun the output code.
            ZeroMemory( &gcsDebugOutput, sizeof( gcsDebugOutput ) );
            InitializeCriticalSection( &gcsDebugOutput );
            
            // Clear out the log file path but DONT create the log. Leave that
            // to the Perl script.
            ZeroMemory( gszDebugOutputPath, sizeof( gszDebugOutputPath ) );

#endif // _DEBUG

            if( NULL != ( gpSid = (SID*) new BYTE [ dwSidBuferSize ] ) )
            {
                // Here we need to get the SID of the user account
                // we are running under
                ZeroMemory( gpSid, dwSidBuferSize );
                if( FALSE != GetProcessSid( GetCurrentProcess(), gpSid, dwSidBuferSize ) )
                {
                    gWindowStation.SetSid( gpSid );
                    LoadProfile( gpSid );
                }
            }
            break;

        case DLL_THREAD_ATTACH:
            giThread++;
            break;

        case DLL_THREAD_DETACH:
            giThread--;
            break;

        case DLL_PROCESS_DETACH:
#ifdef _DEBUG
            DeleteCriticalSection( &gcsDebugOutput );
            if( ghLogFile )
            {
                CloseHandle( ghLogFile );
            }
#endif // _DEBUG
            break;

        default:
            break;
    }
    return ( fResult );
}

/*----------------------- P E R L   F U N C T I O N S -------------------*/
//////////////////////////////////////////////////////////////////

MODULE = Win32::Daemon  PACKAGE = Win32::Daemon

PROTOTYPES: DISABLE

BOOT:
{
    ExportConstants(aTHX);
}


# INCLUDE: \include\XS_RothMacros.xsh

int
RegisterCallbacks( pSv )
	SV*	pSv

	CODE:
	{
		//////////////////////////////////////////////////////////////////
		//  This Perl routine must pass in either a code reference or a
		//  hash reference with callback code references for each event. 
		//
		RETVAL = TRUE;
#ifndef ENABLE_CALLBACKS
	croak( "RegisterCallbacks() is not supported in this build. Define the ENABLE_CALLBACKS macro and recompile\n" );
#else
		if( 1 != items )
		{
			croak( "Usage: " EXTENSION "::RegisterCallbacks( $SubRef | $HashRef )\n" );			
		}
		
		//
		// If we have a reference then de-ref it
		//
		if( SvROK( pSv ) )
		{
			pSv = SvRV( pSv );
		}

		// Check for a subroutine reference
		if( SVt_PVCV == SvTYPE( pSv ) )
		{
			//
			// Passed in a subroutine reference so go ahead and set this routine
			// as the *default* routine for all callbacks
			//
			SET_CALLBACK( CALLBACK_TIMER,          pSv );
			SET_CALLBACK( CALLBACK_START,          pSv );

			SET_CALLBACK( CALLBACK_STOP,           pSv );
			SET_CALLBACK( CALLBACK_PAUSE,          pSv );
			SET_CALLBACK( CALLBACK_CONTINUE,       pSv );
			SET_CALLBACK( CALLBACK_INTERROGATE,    pSv );
			SET_CALLBACK( CALLBACK_SHUTDOWN,       pSv );
			SET_CALLBACK( CALLBACK_PARAMCHANGE,    pSv );
			SET_CALLBACK( CALLBACK_NETBINDADD,     pSv );
			SET_CALLBACK( CALLBACK_NETBINDREMOVE,  pSv );
			SET_CALLBACK( CALLBACK_NETBINDENABLE,  pSv );
			SET_CALLBACK( CALLBACK_NETBINDDISABLE, pSv );
			SET_CALLBACK( CALLBACK_DEVICEEVENT,    pSv );
			SET_CALLBACK( CALLBACK_HARDWAREPROFILECHANGE,    pSv );
			SET_CALLBACK( CALLBACK_POWEREVENT,     pSv );
			SET_CALLBACK( CALLBACK_SESSIONCHANGE,  pSv );
#ifdef SERVICE_CONTROL_PRESHUTDOWN			
			SET_CALLBACK( CALLBACK_PRESHUTDOWN,    pSv );
#endif // SERVICE_CONTROL_PRESHUTDOWN			

			SET_CALLBACK( CALLBACK_USER_DEFINED,   pSv );
			
			//
			//	No longer supporting CALLBACK_RUNNING. It has been replaced by
			//	CALLBACK_TIMER. 
				SET_CALLBACK( CALLBACK_RUNNING,        pSv );
	        
		}
		else if( SVt_PVHV == SvTYPE( pSv ) )
		{
			HV* pHv = (HV*) pSv;
			//
			// We have a hash reference so set each callback routine to the appropriate
			// hash key's callback subroutine...
			//

			//
			//	CALLBACK_RUNNING has been superceeded by CALLBACK_TIMER.
			//	Scripts should only use "timer" instead of "running". However to support
			//	legacy scripts:
			//		1) If running is set then running will be supported
			//		2) If timer is set then the timer callback will occur
			//		3) if both are set then only "running" will occur (this mitigates the
			//		   problem of calling RegisterCallback() with only one callback routine.
			//
			//	*** #3 needs to be reconsidered: We should only use "timer" and encourage 
			//		authors to do the right thing.
			//
			SET_CALLBACK( CALLBACK_RUNNING,		   HASH_GET_SV( pHv, CALLBACK_NAME_RUNNING ) );
			
			SET_CALLBACK( CALLBACK_TIMER,          HASH_GET_SV( pHv, CALLBACK_NAME_TIMER ) );
			SET_CALLBACK( CALLBACK_START,          HASH_GET_SV( pHv, CALLBACK_NAME_START ) );
			SET_CALLBACK( CALLBACK_STOP,           HASH_GET_SV( pHv, CALLBACK_NAME_STOP ) );
			SET_CALLBACK( CALLBACK_PAUSE,          HASH_GET_SV( pHv, CALLBACK_NAME_PAUSE ) );
			SET_CALLBACK( CALLBACK_CONTINUE,       HASH_GET_SV( pHv, CALLBACK_NAME_CONTINUE ) );
			SET_CALLBACK( CALLBACK_INTERROGATE,    HASH_GET_SV( pHv, CALLBACK_NAME_INTERROGATE ) );
			SET_CALLBACK( CALLBACK_SHUTDOWN,       HASH_GET_SV( pHv, CALLBACK_NAME_SHUTDOWN ) );
			SET_CALLBACK( CALLBACK_PARAMCHANGE,    HASH_GET_SV( pHv, CALLBACK_NAME_PARAMCHANGE ) );
			SET_CALLBACK( CALLBACK_NETBINDADD,     HASH_GET_SV( pHv, CALLBACK_NAME_NETBINDADD ) );
			SET_CALLBACK( CALLBACK_NETBINDREMOVE,  HASH_GET_SV( pHv, CALLBACK_NAME_NETBINDREMOVE ) );
			SET_CALLBACK( CALLBACK_NETBINDENABLE,  HASH_GET_SV( pHv, CALLBACK_NAME_NETBINDENABLE ) );
			SET_CALLBACK( CALLBACK_NETBINDDISABLE, HASH_GET_SV( pHv, CALLBACK_NAME_NETBINDDISABLE ) );
			SET_CALLBACK( CALLBACK_DEVICEEVENT,    HASH_GET_SV( pHv, CALLBACK_NAME_DEVICEEVENT ) );
			SET_CALLBACK( CALLBACK_HARDWAREPROFILECHANGE,    HASH_GET_SV( pHv, CALLBACK_NAME_HARDWAREPROFILECHANGE ) );
			SET_CALLBACK( CALLBACK_POWEREVENT,     HASH_GET_SV( pHv, CALLBACK_NAME_POWEREVENT ) );
			SET_CALLBACK( CALLBACK_SESSIONCHANGE,  HASH_GET_SV( pHv, CALLBACK_NAME_SESSIONCHANGE ) );
#ifdef SERVICE_CONTROL_PRESHUTDOWN			
			SET_CALLBACK( CALLBACK_PRESHUTDOWN,    HASH_GET_SV( pHv, CALLBACK_NAME_PRESHUTDOWN ) );
#endif // SERVICE_CONTROL_PRESHUTDOWN

			SET_CALLBACK( CALLBACK_USER_DEFINED,   HASH_GET_SV( pHv, CALLBACK_NAME_USER_DEFINED ) );

			

		}
		else
		{
			// Fail
			RETVAL = FALSE;
		}
#endif // ENABLE_CALLBACKS
	}

	OUTPUT:
		RETVAL


UV
StartService( ... )

	PREINIT:
		UINT uintCallbackTimerValue = DEFAULT_CALLBACK_TIMER;

	CODE:
	{
		if( 2 < items )
		{
			croak( "Usage: " EXTENSION "::StartService( [ \\%Context [, $CallbackTimer] ] )\n" );
		}

		//    BeginServiceThread()
		ALERT( "Daemon::StartService: About to start the service thread..." );

		if( 0 == ghServiceThread )
		{
			//
			// Call a Win32 User level function to create a thread based message queue
			// This is needed since there are no other windows already created therefore
			// no message queue already exists.
			// NOTE that we are doing this BEFORE we create the service thread. This is so
			// that we can catch any message posted by the service thread even before we
			// are ready to handle them.
			//
			GetDesktopWindow();
			GetWindow( NULL, GW_HWNDFIRST );

			//
			//	Create a service thread which will result in the SCM creating yet another
			//	thread which ServiceMain() will run on.
			//
			ghServiceThread = CreateThread( NULL, 0, ServiceThread, 0, 0, &gServiceThreadId );

			ALERT( "Daemon::StartService: Thread has been created (falling back to perl)." );
#ifdef ENABLE_CALLBACKS
			//
			// If a context hash was passed in then store it for callback use
			//
			if( items )
			{
				if( 1 < items )
				{
					// Get the callback timer value...
                                        uintCallbackTimerValue = (int)SvIV( ST( 1 ) );
				}

				SV *pSv = ST( 0 );

				//
				// Do we have a reference?
				//
				if( SvROK( pSv ) )
				{
					// 
					// Yep. Let's dereference the reference....
					pSv = SvRV( pSv );
				}

				//
				// Now, do we have a hash? If so then store it.
				//
				if( SVt_PVHV == SvTYPE( pSv ) )
				{
					gpHvContext = (HV*) pSv;
				}
			}

			// If we have provided callbacks then enter a message loop calling the callbacks
			// whenever we receive a message to do so...
			if( 0 < gCallback.GetCount() )
			{
				//
				// Start the thread based message loop. Notice that we are relying on 
				// a *thread* message loop and now a window message loop. Any posting must
				// be made to the thread using PostThreadMessage() function.
				//
				MSG msg;
				BOOL fRet = FALSE;

				//
				// Store the main perl object into a global so that we can access it
				// when we need to callback...
				//
   				//	UPDATE: We no longer are using gpPerlObject. Instead reference the
				//	aTHX macro.
				//	gpPerlObject = aTHX;

	    		
				//
				// Set the global flag indicating that we are now in callback mode...
				//
				gfCallbackMode = TRUE;

				ALERT( "ENTERING the callback thread message loop." );
	            
				//
				//	Update the callback timer value.
				//
				gCallbackTimer = uintCallbackTimerValue;
				
				//
				//	If we have set the callback timer to a valid time
				//	then we need to start it. Don't worry about checking
				//	for it's current state. The CCallbackTimer class manages
				//	all of that.
				//
				gCallbackTimer.Start();
				

				while( FALSE != gfCallbackMode && ( 0 != ( fRet = GetMessage( &msg, NULL, 0, 0 ) ) ) )
				{ 
					if( -1 == fRet )
					{
						ALERT( "Callback Thread Message Loop: GetMessage() returned -1. Aborting..." );
						// handle the error and possibly exit
						break;
					}
					else
					{
						TranslateMessage( &msg ); 
						//
						// No DispatchMessage() here since we are only dealing with
						// thread messages
						//
						// DispatchMessage( &msg ); 
						DispatchThreadMessage( &msg );
					}
				}
				
				//
				//	We are leaving the callback routine so stop any of the 
				//	timer based callbacks.
				//
				gCallbackTimer.Stop(); 

			}
#endif // ENABLE_CALLBACKS
		}

		RETVAL = PTR2UV(ghServiceThread);
	}
	
	OUTPUT:
		RETVAL


int
CallbackTimer( ... )

	CODE:
	{
		if( 1 < items )
		{
			croak( "Usage: " EXTENSION "::CallbackTimer( [ $CallbackTimer ] )\n" );
		}

		if( items )
		{
			//
			//	Set the callback timer
			//
                        gCallbackTimer = (int)SvIV( ST( 0 ) );
			
			//
			//	If we were already stopped then we need to manually start
			//	the timer now that it has been reset with a new value.
			//	If the timer value has been set with 0 then it has already
			//	stopped and trying to start again will do nothing.
			//
			gCallbackTimer.Start();
		}

		//
		//	Return the callback timer value
		//
		RETVAL = (int) gCallbackTimer.GetTimerValue();
	}

	OUTPUT:
		RETVAL

int
StopService()	

	PREINIT:
		DWORD dwTermStatus;
		BOOL fResult = FALSE;
	
	CODE:
	{
		DWORD dwPostCount = 5;
		while( 0 < dwPostCount-- && PostThreadMessage( gServiceMainThreadID, WM_QUIT, 0, 0 ) )
		{
			//
			//	Oops. Do NOT use "sleep(xxx)" instead of Win32's "Sleep(xxx)". The
			//	case sensitive "S" will call the wrong sleep() function; where the
			//	time is not in milliseconds but in seconds!!!
			//
			Sleep( 100 );
		}

		if( FALSE != GetExitCodeThread( ghServiceThread, &dwTermStatus ) )
		{
			if( STILL_ACTIVE == dwTermStatus )
			{
				UpdateServiceStatus( SERVICE_STOP_PENDING );
				Sleep( 1000 );
				GetExitCodeThread( ghServiceThread, &dwTermStatus );
				if( STILL_ACTIVE == dwTermStatus )
				{
					TerminateThread( ghServiceThread, 0 );
				}
			}
			UpdateServiceStatus( SERVICE_STOPPED );
			fResult = TRUE;
		}

		//
		// If we were in callback mode then unset the mode...
		//
		gfCallbackMode = FALSE;

		RETVAL = (int) fResult;
	}

	OUTPUT:
		RETVAL


LPTSTR
GetVersion()

	CODE:
	{
		RETVAL = (LPTSTR) VERSION_STRING;
	}

	OUTPUT:
		RETVAL


int
CreateService( pSvServiceInfo )
	SV*	pSvServiceInfo

	PREINIT:
		HV	*pHv = NULL;
		BOOL fResult = FALSE;

	CODE:
	{
		//////////////////////////////////////////////////////////////////
		//  NOTE: dwServiceType does not include the SERVICE_INTERACTIVE_PROCESS 
		//        flag since this will prevent a assigning a userid other than
		//        LocalSystem.
		if( 1 != items )
		{
			croak( "Usage: " EXTENSION "::CreateService( \\%ServiceInfo )\n" );
		}

		if( NULL != ( pHv = EXTRACT_HV( pSvServiceInfo ) ) )
		{
			TCHAR szBuffer[ MAX_PATH * 2 ];
			TCHAR szBinaryPath[ MAX_PATH ];     
			TCHAR szDependencies[ MAX_SERVICE_DEPENDENCY_BUFFER_SIZE ]; 
			const char *pszDepend =      szDependencies;
			const char *pszMachine =     HASH_GET_PV( pHv, KEYWORD_SERVICE_MACHINE );
			const char *pszServiceName = HASH_GET_PV( pHv, KEYWORD_SERVICE_NAME );
			const char *pszDisplayName = HASH_GET_PV( pHv, KEYWORD_SERVICE_DISPLAY_NAME );
			const char *pszUser =        HASH_GET_PV( pHv, KEYWORD_SERVICE_ACCOUNT_UID );
			const char *pszPwd =         HASH_GET_PV( pHv, KEYWORD_SERVICE_ACCOUNT_PWD );
			const char *pszBinaryPath =  HASH_GET_PV( pHv, KEYWORD_SERVICE_BINARY_PATH );
			const char *pszParameters =  HASH_GET_PV( pHv, KEYWORD_SERVICE_PARAMETERS );
			const char *pszDescription = HASH_GET_PV( pHv, KEYWORD_SERVICE_DESCRIPTION );
			const char *pszLoadOrder = NULL;
			DWORD  dwTag = 0;
			DWORD dwAccess = SERVICE_ALL_ACCESS;
			DWORD dwServiceType = SERVICE_WIN32_OWN_PROCESS;
			DWORD dwStartType = SERVICE_AUTO_START;
			DWORD dwErrorControl = SERVICE_ERROR_IGNORE;

			ZeroMemory( szDependencies, sizeof( szDependencies ) );
			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_DEPENDENCIES ) )
			{
				AV *pAv = NULL;
				if( NULL != ( pAv = HASH_GET_AV( pHv, KEYWORD_SERVICE_DEPENDENCIES ) ) )
				{
					LPTSTR pszBuffer = szDependencies;
					// av_len() returns -1 if no entries. Otherwise it returns the 
					// largest index number in the array.
					DWORD dwCount = av_len( pAv ) + 1;
					for( DWORD dwIndex = 0; dwIndex < dwCount; dwIndex++ )
					{
						_tcscpy( pszBuffer, ARRAY_GET_PV( pAv, dwIndex ) );
						pszBuffer = &szDependencies[ _tcslen( pszBuffer ) + 1 ];
					}
					// Add the final terminating null (string must be double null terminated)
					pszBuffer[0] = '\0';
				}
			}

			//  Only pad the pszBinaryPath with double quotes IF there are none already AND
			//  there are spaces in the path
			if( ( _tcschr( pszBinaryPath, ' ' ) && ( 0 != _tcsncmp( pszBinaryPath, TEXT( "\"" ), 1 ) ) ) )
			{
				_tcscpy( szBinaryPath, TEXT( "\"" ) );
				_tcscat( szBinaryPath, pszBinaryPath );
				_tcscat( szBinaryPath, TEXT( "\"" ) );
				pszBinaryPath = szBinaryPath;
			}

			//  Parameters are attached to the end of the binary path
			if( 0 != _tcscmp( TEXT( "" ), pszParameters ) )
			{
				_tcscpy( szBuffer, pszBinaryPath );
				_tcscat( szBuffer, TEXT( " " ) );
				_tcscat( szBuffer, pszParameters );
				pszBinaryPath = szBuffer;
			}

			if( ( 0 == _tcscmp( TEXT( "" ), pszUser ) )
				|| ( 0 == _tcsicmp( TEXT( "localsystem" ), pszUser ) ) )
			{
				pszUser = NULL;
				pszPwd = NULL;
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_TYPE ) )
			{
                                dwServiceType = (DWORD)HASH_GET_IV( pHv, KEYWORD_SERVICE_TYPE );
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_START_TYPE ) )
			{
                                dwStartType = (DWORD)HASH_GET_IV( pHv, KEYWORD_SERVICE_START_TYPE );
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_ERROR_CONTROL ) )
			{
                                dwErrorControl = (DWORD)HASH_GET_IV( pHv, KEYWORD_SERVICE_ERROR_CONTROL );
			}

			OPEN_SERVICE_CONTROL_MANAGER( pszMachine )
				SC_HANDLE hService = CreateService( hSc,
													pszServiceName,
													pszDisplayName,
													dwAccess,
													dwServiceType,
													dwStartType,
													dwErrorControl,
													pszBinaryPath,
													pszLoadOrder,
													NULL,
													pszDepend,
													pszUser,
													pszPwd );
				if( NULL != hService )
				{
					fResult = TRUE;
					StoreServiceDescription( pszMachine, pszServiceName, pszDescription );
					CloseServiceHandle( hService );
				}
				else
				{
					gdwLastError = GetLastError();
				}
			CLOSE_SERVICE_CONTROL_MANAGER
		}

		RETVAL = ( 0 != fResult );
	}

	OUTPUT:
		RETVAL


int
DeleteService( ... )

	PREINIT:
		HV *pHv = NULL;
		BOOL fResult = FALSE;
		const char *pszServiceName = NULL;
		const char *pszMachine = TEXT( "" );
		DWORD dwIndex = 0;

	CODE:
	{
		if( ( 1 > items ) || ( 2 < items ) )
		{
			croak( "Usage: " EXTENSION "::DeleteService( [$Machine,] $ServiceName )\n" );
		}

		if( 2 == items )
		{
			pszMachine = SvPV_nolen( ST( dwIndex ) );
			dwIndex++;
		}

		if( NULL != ( pszServiceName = SvPV_nolen( ST( dwIndex ) ) ) )
		{
	        
			OPEN_SERVICE_CONTROL_MANAGER( pszMachine )
				SC_HANDLE hService = OpenService( hSc,
													pszServiceName,
													DELETE );
				if( NULL != hService )
				{
					if( FALSE == ( fResult = DeleteService( hService ) ) )
					{
						gdwLastError = GetLastError();    
					}
					CloseServiceHandle( hService );
				}
				else
				{
					gdwLastError = GetLastError();
				}
			CLOSE_SERVICE_CONTROL_MANAGER
		}
		RETVAL = ( 0 != fResult );
	}

	OUTPUT:
		RETVAL


int
ConfigureService( pSvServiceInfo )
	SV	*pSvServiceInfo

	PREINIT:
		HV *pHv = NULL;
		BOOL fResult = FALSE;

	CODE:
	{
		if( 1 != items )
		{
			croak( "Usage: " EXTENSION "::ConfigureService( \\%ServiceInfo )\n" );
		}

		if( NULL != ( pHv = EXTRACT_HV( pSvServiceInfo ) ) )
		{
			TCHAR szBuffer[ MAX_PATH * 2 ];
			TCHAR szBinaryPath[ MAX_PATH ];
			TCHAR szDependencies[ MAX_SERVICE_DEPENDENCY_BUFFER_SIZE ];
			const char *pszMachine = HASH_GET_PV( pHv, KEYWORD_SERVICE_MACHINE );
			const char *pszServiceName = NULL;
			const char *pszDisplayName = NULL;
			const char *pszUser =        NULL;
			const char *pszPwd =         NULL;
			const char *pszBinaryPath =  NULL;
			const char *pszParameters =  NULL;
			const char *pszLoadOrder =   NULL;
			const char *pszDepend =      NULL;
			const char *pszDescription = NULL;
			DWORD  dwTagId =        0;
			DWORD  *pdwTagId =      NULL;
			DWORD dwAccess =        SERVICE_ALL_ACCESS;
			DWORD dwServiceType =   SERVICE_NO_CHANGE;
			DWORD dwStartType =     SERVICE_NO_CHANGE;
			DWORD dwErrorControl =  SERVICE_NO_CHANGE;

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_NAME ) )
			{
				pszServiceName = HASH_GET_PV( pHv, KEYWORD_SERVICE_NAME );

			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_DISPLAY_NAME ) )
			{
				pszDisplayName = HASH_GET_PV( pHv, KEYWORD_SERVICE_DISPLAY_NAME );

			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_ACCOUNT_UID ) )
			{
				pszUser = HASH_GET_PV( pHv, KEYWORD_SERVICE_ACCOUNT_UID );

			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_ACCOUNT_PWD ) )
			{
				pszPwd = HASH_GET_PV( pHv, KEYWORD_SERVICE_ACCOUNT_PWD );

			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_DEPENDENCIES ) )
			{
				pszDepend = HASH_GET_PV( pHv, KEYWORD_SERVICE_DEPENDENCIES );
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_DESCRIPTION ) )
			{
				pszDescription = HASH_GET_PV( pHv, KEYWORD_SERVICE_DESCRIPTION );
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_BINARY_PATH ) )
			{
				pszBinaryPath = HASH_GET_PV( pHv, KEYWORD_SERVICE_BINARY_PATH );
				if( ( _tcschr( pszBinaryPath, ' ' ) && ( 0 != _tcsncmp( pszBinaryPath, TEXT( "\\" ), 1 ) ) ) )
				{
					_tcscpy( szBinaryPath, "\"" );
					_tcscat( szBinaryPath, pszBinaryPath );
					_tcscat( szBinaryPath, "\"" );
					pszBinaryPath = szBinaryPath;
				}
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_PARAMETERS ) )
			{
				//  Add 2 for double quote marks...
				//  TCHAR szPathBuffer[ MAX_PATH + 2 ];

				// TODO:
				// We should query the real path if pszBinaryPath == NULL!!!
				if( NULL != pszBinaryPath )
/*
				// If NULL == pszBinaryPath then we should go out and get the binary path
				// and strip out any padding " chars
				{
					// Go and find the binary path...
					GetBinaryPath( pszMachine, pszServiceName, szPathBuffer, sizeof( szPathBuffer ) );
					pszBinaryPath = szPathBuffer;
				}
*/
				pszParameters = HASH_GET_PV( pHv, KEYWORD_SERVICE_PARAMETERS );

				//  Parameters are attached to the end of the binary path
				if( 0 != _tcscmp( TEXT( "" ), pszParameters ) )
				{
					_tcscpy( szBuffer, pszBinaryPath );
					_tcscat( szBuffer, TEXT( " " ) );
					_tcscat( szBuffer, pszParameters );
					pszBinaryPath = szBuffer;
				}
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_DEPENDENCIES ) )
			{
				AV *pAv = NULL;
				if( NULL != ( pAv = HASH_GET_AV( pHv, KEYWORD_SERVICE_DEPENDENCIES ) ) )
				{
					LPTSTR pszBuffer = szDependencies;
					pszDepend = szDependencies;
					// av_len() returns -1 if no entries. Otherwise it returns the 
					// largest index number in the array.
					DWORD dwCount = av_len( pAv ) + 1;
					for( DWORD dwIndex = 0; dwIndex < dwCount; dwIndex++ )
					{
						_tcscpy( pszBuffer, ARRAY_GET_PV( pAv, dwIndex ) );
						pszBuffer = &szDependencies[ _tcslen( pszBuffer ) + 1 ];
					}
					// Add the final terminating null (string must be double null terminated)
					pszBuffer[0] = '\0';
				}
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_TAG_ID ) )
			{
                                dwTagId = (DWORD)HASH_GET_IV( pHv, KEYWORD_SERVICE_TAG_ID );
				pdwTagId = &dwTagId;
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_TYPE ) )
			{
                                dwServiceType = (DWORD)HASH_GET_IV( pHv, KEYWORD_SERVICE_TYPE );
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_START_TYPE ) )
			{
                                dwStartType = (DWORD)HASH_GET_IV( pHv, KEYWORD_SERVICE_START_TYPE );
			}

			if( HASH_KEY_EXISTS( pHv, KEYWORD_SERVICE_ERROR_CONTROL ) )
			{
                                dwErrorControl = (DWORD)HASH_GET_IV( pHv, KEYWORD_SERVICE_ERROR_CONTROL );
			}

			OPEN_SERVICE_CONTROL_MANAGER( pszMachine )
				SC_HANDLE hService = OpenService( hSc, pszServiceName, SERVICE_CHANGE_CONFIG );
				if( NULL != hService )
				{
					fResult = ChangeServiceConfig(  hService,
													dwServiceType,
													dwStartType,
													dwErrorControl,
													pszBinaryPath,
													pszLoadOrder,
													pdwTagId,
													pszDepend,
													pszUser,
													pszPwd,
													pszDisplayName );
					if( ( TRUE == fResult ) && ( NULL != pszDescription ) )
					{
						StoreServiceDescription( pszMachine, pszServiceName, pszDescription );
					}
	                
					if( FALSE == fResult )
					{
						gdwLastError = GetLastError();
					}
					CloseServiceHandle( hService );
				}
				else
				{
					gdwLastError = GetLastError();
				}
			CLOSE_SERVICE_CONTROL_MANAGER
		}
		RETVAL = ( 0 != fResult );
	}

	OUTPUT:
		RETVAL


int
QueryServiceConfig( pSvServiceInfo )
	SV *pSvServiceInfo

	PREINIT:
		HV *pHv = NULL;
		BOOL fResult = FALSE;

	CODE:
	{
		//////////////////////////////////////////////////////////////////
		//  Note:  This returns the service configuration for the *next*
		//         time that the service will run. lIf you modify the
		//         configuration while the service is still running then
		//         a call to this function will not return the current
		//         configuration but the configuration that will be
		//         used next time the service is run.    
		if( 1 != items )
		{
			croak( "Usage: " EXTENSION "::QueryServiceConfig( \\%ServiceInfo )\n" );
		}

		if( NULL != ( pHv = EXTRACT_HV( pSvServiceInfo) ) )
		{
			TCHAR szServiceName[ 256 ];
			TCHAR szMachineName[ 256 ];
			const char *pszServiceName = HASH_GET_PV( pHv, KEYWORD_SERVICE_NAME );
			const char *pszMachineName = HASH_GET_PV( pHv, KEYWORD_SERVICE_MACHINE );

			// Copy the service name to a local buffer so we can clear out the
			// hash...
			// The HASH_GET_PV() macro never returns NULL, instead it returns ""
			_tcscpy( szServiceName, pszServiceName );
			pszServiceName = szServiceName;

			// Copy the machine name to a local buffer so we can clear out the
			// hash...
			// ...if no machine key was specified HASH_GET_PV() will return "" 
			// (not a NULL). Later we will call OpenSCManager() passing in this value
			// which is interpretted as the local machine.
			_tcscpy( szMachineName, pszMachineName );
			pszMachineName = szMachineName;

			hv_clear( pHv );

			OPEN_SERVICE_CONTROL_MANAGER_READ( pszMachineName )
				SC_HANDLE hService = OpenService( hSc, pszServiceName, SERVICE_QUERY_CONFIG );
				if( NULL != hService )
				{
					DWORD dwBufferSize = 0;
					fResult = QueryServiceConfig( hService, NULL, 0, &dwBufferSize );
					if( ERROR_INSUFFICIENT_BUFFER == GetLastError() )
					{
						LPQUERY_SERVICE_CONFIG pServiceConfig = NULL;
						pServiceConfig = (LPQUERY_SERVICE_CONFIG) new BYTE [ dwBufferSize ];
						if( NULL != pServiceConfig )
						{
							ZeroMemory( pServiceConfig, dwBufferSize );
							fResult = QueryServiceConfig( hService, pServiceConfig, dwBufferSize, &dwBufferSize );
							if( FALSE != fResult )
							{
								AV *pAv = newAV();

								HASH_STORE_IV( pHv, KEYWORD_SERVICE_TYPE, pServiceConfig->dwServiceType );
								HASH_STORE_IV( pHv, KEYWORD_SERVICE_START_TYPE, pServiceConfig->dwStartType );
								HASH_STORE_IV( pHv, KEYWORD_SERVICE_ERROR_CONTROL, pServiceConfig->dwErrorControl );
								HASH_STORE_PV( pHv, KEYWORD_SERVICE_BINARY_PATH, pServiceConfig->lpBinaryPathName );
								HASH_STORE_PV( pHv, KEYWORD_SERVICE_LOAD_ORDER, pServiceConfig->lpLoadOrderGroup );
								HASH_STORE_PV( pHv, KEYWORD_SERVICE_DISPLAY_NAME, pServiceConfig->lpDisplayName );
								HASH_STORE_PV( pHv, KEYWORD_SERVICE_ACCOUNT_UID, pServiceConfig->lpServiceStartName );
								HASH_STORE_PV( pHv, KEYWORD_SERVICE_NAME, pszServiceName );
								HASH_STORE_PV( pHv, KEYWORD_SERVICE_MACHINE, pszMachineName );

								if( NULL != pAv )
								{
									LPTSTR pszBuffer = pServiceConfig->lpDependencies;

									while( '\0' != pszBuffer[0] )
									{
										ARRAY_PUSH_PV( pAv, pszBuffer );
										pszBuffer = &pszBuffer[ _tcslen( pszBuffer ) + 1 ];
									}
									HASH_STORE_AV( pHv, KEYWORD_SERVICE_DEPENDENCIES, pAv );
								}

								// Get the service Description...
								{
									HKEY hRoot = HKEY_LOCAL_MACHINE;
									HKEY hKey = NULL;
									BOOL fFlag = TRUE;
	            
									if( 0 != _tcscmp( TEXT( "" ), pszMachineName ) )
									{
										fFlag = ( ERROR_SUCCESS == RegConnectRegistry( pszMachineName, HKEY_LOCAL_MACHINE, &hRoot ) );
									}

									if( TRUE == fFlag )
									{
										TCHAR szBuffer[ 75 ];
										_stprintf( szBuffer, REGISTRY_SERVICE_PATH TEXT( "\\%s" ), pszServiceName );
										if( ERROR_SUCCESS == RegOpenKeyEx( hRoot, szBuffer, 0, KEY_QUERY_VALUE, &hKey ) )
										{
											TCHAR szDescription[ 1024 ];
											DWORD dwType, dwSize;
											if( ( ERROR_SUCCESS == RegQueryValueEx( hKey, REGISTRY_SERVICE_KEYWORD_DESCRIPTION, 0, &dwType, (LPBYTE) szDescription, &dwSize )
												&& ( REG_SZ == dwType ) ) )
											{
												HASH_STORE_PV( pHv, KEYWORD_SERVICE_DESCRIPTION, szDescription );                    
											}
										}
										RegCloseKey( hKey );
									}
	                
									if( 0 != _tcscmp( TEXT( "" ), pszMachineName ) )
									{
										RegCloseKey( hRoot );
									}
	                    
								}

							}
							else
							{
								gdwLastError = GetLastError();
							}
							delete [] (BYTE*) pServiceConfig;
						}
					}
					else
					{
						gdwLastError = GetLastError();
					}
					CloseServiceHandle( hService );
				}
				else
				{
					gdwLastError = GetLastError();
				}
			CLOSE_SERVICE_CONTROL_MANAGER
		}
		RETVAL = ( 0 != fResult );
	}

	OUTPUT:
		RETVAL


int
SetServiceBits( dwBits = 0, ... )
	DWORD dwBits	

	PREINIT:
		BOOL fResult = FALSE;
		SERVICE_STATUS_HANDLE hService = ghService;

	CODE:
	{
		if( ( 1 > items ) || ( 2 < items ) )
		{
			croak( "Usage: SetServiceBits( $Value, [$hServiceHandle] )\n" );
		}

		if( 2 == items )
		{
			hService = (SERVICE_STATUS_HANDLE) SvIV( ST( 1 ) );
		}

		if( 0 != hService )
		{

			// SetServiceBits() for some reason will not link. The link lib
			// is AdvApi32.dll which is in the link list but alas it errors out.
			// So we need to fix this later. For now we hack...load the dll, get the
			// proc then call it.

			//  Now set our bits...
			fResult = My_SetServiceBits( (SERVICE_STATUS_HANDLE) ghService, (DWORD) dwBits,(BOOL) TRUE, (BOOL) TRUE );
		}
		else
		{
			// Set the gdwServiceBits so that when the service is formally running
			// it will set the bits.
			gdwServiceBits = dwBits;
			fResult = 1;
		}
		RETVAL = (int) fResult;
	}

	OUTPUT:
		RETVAL


DWORD
GetLastError()

	CODE:
	{
		RETVAL = gdwLastError;
	}

	OUTPUT:
		RETVAL



DWORD
State( ... )

	PREINIT:
	
	CODE:
	{
		if( 2 < items )
		{
			croak( "Usage: State( [$State [, $WaitHint ] || \\%Hash ] )\n" );
		}

		if( 0 != gdwState )
		{

			if( items )
			{
				SV *pSv = ST( 0 );
				HV *pHv = NULL;
				DWORD dwState = gdwState;
				DWORD dwWaitHint = DEFAULT_WAIT_HINT;
				DWORD dwError = NO_ERROR;

				if( NULL != ( pHv = EXTRACT_HV( pSv ) ) )
				{
					if( HASH_KEY_EXISTS( pHv, KEYWORD_STATE_STATE ) )
					{
                                                dwState     = (DWORD)HASH_GET_IV( pHv, KEYWORD_STATE_STATE );
					}
					if( HASH_KEY_EXISTS( pHv, KEYWORD_STATE_WAIT_HINT ) )
					{
                                                dwWaitHint  = (DWORD)HASH_GET_IV( pHv, KEYWORD_STATE_WAIT_HINT );
					}
					if( HASH_KEY_EXISTS( pHv, KEYWORD_STATE_ERROR ) )
					{
                                                dwError     = (DWORD)HASH_GET_IV( pHv, KEYWORD_STATE_ERROR );
					}
				}
				else
				{
                                        dwState = (DWORD)SvIV( pSv );
					if( 2 == items )
					{
						// Assume that the hint was in milliseconds
                                                dwWaitHint = (DWORD)SvIV( ST( 1 ) );
					}
				}
				
				UpdateServiceStatus( dwState, dwWaitHint, dwError );
			}
		}
		RETVAL = gdwState;
	}
	
	OUTPUT:
		RETVAL



DWORD
QueryLastMessage( ... )

	CODE:
	{
		if( 1 < items )
		{
			croak( "Usage: QueryLastMessage( [$fResetMessage] )\n" );
		}

		if( ( 1 == items ) && ( 0 != SvIV( ST( 0 ) ) ) )
		{
			gdwLastControlMessage = SERVICE_CONTROL_NONE;
		}

		RETVAL = gdwLastControlMessage;
	}

	OUTPUT:
		RETVAL



BOOL
ShowService( pszWindowStation = TEXT( "Winsta0" ), ... )
	const char *pszWindowStation

	PREINIT:
		BOOL fResult;
		const char *pszDesktop = TEXT( "Default" );

	CODE:
	{
		if( 3 < items )
		{
			croak( "Usage: ShowService( $WindowStationName, [$DesktopName] )\n" );
		}

		if( 1 < items )
		{
			pszDesktop = (LPTSTR) SvPV_nolen( ST( 0 ) );
		}

		// Free your mind...and the current console. :)
		// Do it before the winstation/desktop switch otherwise if you free it later you will
		// see a brief flash of a console.
		FreeConsole();

		ALERT( "ShowService: About to call gWindowStation.Set()\n" );
		fResult = gWindowStation.Set( pszWindowStation, pszDesktop );
#ifdef _DEBUG
		TCHAR szBuffer[256];
		wsprintf( szBuffer,
				  TEXT( "ShowService: Setting window station %s\\%s resulted in %d" ),
				  pszWindowStation,
				  pszDesktop,
				  fResult );
		ALERT( szBuffer );
#endif

		// Allocate a new console for output.
		AllocConsole();

		RETVAL = (BOOL) fResult;
	}

	OUTPUT:
		RETVAL


BOOL
HideService()

	CODE:
	{
		RETVAL = (BOOL) gWindowStation.Set( TEXT( "Service-x0-3e7$" ), TEXT( "Default" ) );
	}

	OUTPUT:
		RETVAL


BOOL
RestoreService()

	CODE:	
	{
		RETVAL = (BOOL) gWindowStation.Restore();
	}

	OUTPUT:
		RETVAL



DWORD
Timeout( ... )

	CODE:
	{
		if( 1 < items )
		{
			croak( TEXT( "Usage: " EXTENSION "::Timeout( [$Timeout] )\n" ) );
		}

		if( items )
		{
                        gdwHandlerTimeout = (DWORD)SvIV( ST( 0 ) );
		}
		RETVAL = gdwHandlerTimeout;
	}

	OUTPUT:
		RETVAL



UV
GetServiceHandle()

	CODE:	
	{
		if( items )
		{
			croak( TEXT( "Usage: " EXTENSION "::GetServiceHandle()\n" ) );
		}

		RETVAL = PTR2UV(ghService);
	}

	OUTPUT:
		RETVAL



DWORD
AcceptedControls( ... )

	CODE:	
	{
		if( 1 < items )
		{
			croak( TEXT( "Usage: " EXTENSION "::AcceptedControls( [$NewControls] )\n" ) );
		}

		if( 0 < items )
		{
                        gdwControlsAccepted = (DWORD)SvIV( ST( 0 ) );
		}
		RETVAL = gdwControlsAccepted;
	}

	OUTPUT:
		RETVAL


BOOL
SetSecurity( pszMachine, pszServiceName, pSvSecurityObject )
	LPTSTR pszMachine
	LPTSTR pszServiceName
	SV	*pSvSecurityObject

	PREINIT:
		SECURITY_DESCRIPTOR *pSD = NULL;
		BOOL fResult = FALSE;

	CODE:
	{
		if( 3 < items )
		{
			croak( TEXT( "Usage: " EXTENSION "::AcceptedControls( $Machine, $ServiceName, $Win32::Perms_Object | $BinarySD )\n" ) );
		}

		if( sv_isobject( (SV*) pSvSecurityObject ) )
		{
			// Is pSD an object (blessed object)?
			LPTSTR pszObjectType = NULL;
			SV *pSvTemp = NULL;

			//  Yep, it's a reference to a blessed object...
			//  This means that pSv is actually a blessed HV*
			pSvTemp = SvRV( (SV*) pSvSecurityObject );
			pszObjectType = HvNAME( SvSTASH( pSvTemp ) );

			if( 0 == _stricmp( pszObjectType, PERL_WIN32_PERMS_EXTENSION  ) )
			{
				dSP;
				int iCount;

				//  We have a Win32::Perms object. So let's call into its GetSD() method
				//  to get a pointer to the absolute Security Descriptor...
	        
				// Save our current position on the stack
				PUSHMARK( SP );
	        
				// Push the Win32::Perms object onto the stack
				XPUSHs( (SV*) pSvSecurityObject );

				//  Go back to the previously stored stack position
				PUTBACK;
	            
				//  Remember the position on the stack so when we free temp vars only up to this point
				//  will be freed
				ENTER;
				SAVETMPS;
	        
				//  Call the method...
				iCount = perl_call_method( (char*) "GetSD", G_SCALAR );

				if( 0 < iCount )
				{
					//  Yahooo! The method returned a value; assume it is a Security Descriptor pointer
					//  so pop it off as a long
					pSD = (SECURITY_DESCRIPTOR*) POPl;
				}

				//  Free all scalars created since the ENTER/SAVETMPS combo
				FREETMPS;
				LEAVE;
			}
		}
		else
		{
			// Okay, first check if we have an absolute security descriptor...
			pSD = (SECURITY_DESCRIPTOR*) SvIV( pSvSecurityObject );
			if( ! IsValidSecurityDescriptor( pSD ) )
			{
				// Hmmm. Okay, let's try a relative security descriptor...
				pSD = (SECURITY_DESCRIPTOR*) SvPV_nolen( pSvSecurityObject );
				if( ! IsValidSecurityDescriptor( pSD ) )
				{
					// Sigh. No, we don't seem to have any security descriptor
					pSD = NULL;
				}
			}
		}
	    
		// If we have a valid Security Descriptor that use it!
		if( NULL != pSD )
		{
			BOOL fACLExists = FALSE;
			BOOL fTempBool = FALSE;
			PACL pTempACL = NULL;
			PSID pSid = NULL;
			DWORD dwFlags = 0;
			DWORD dwOpenFlags = READ_CONTROL | WRITE_DAC;

			if( NULL != pszServiceName )
			{
	        
				if( FALSE != GetSecurityDescriptorSacl( pSD, &fACLExists, &pTempACL, &fTempBool ) )
				{
					dwFlags |= SACL_SECURITY_INFORMATION;
					SetPrivilege( 0, SE_SECURITY_NAME, TRUE);
					dwOpenFlags |= ACCESS_SYSTEM_SECURITY;
				}

				fTempBool = fACLExists = FALSE;
				if( FALSE != GetSecurityDescriptorDacl( pSD, &fACLExists, &pTempACL, &fTempBool ) )
				{
					dwFlags |= DACL_SECURITY_INFORMATION;
					dwOpenFlags |= WRITE_DAC;
				}

	/*  
		//
		//  Don't try to set the owner...this only causes problems such as
		//  permission issues preventing the set from happening...
		//
				fTempBool = fACLExists = FALSE;
				if( FALSE != GetSecurityDescriptorOwner( pSD, &pSid, &fTempBool ) )
				{
					dwFlags |= OWNER_SECURITY_INFORMATION;
					dwOpenFlags |= WRITE_OWNER;
				}
	*/

				OPEN_SERVICE_CONTROL_MANAGER( pszMachine )
				SC_HANDLE hService = OpenService( hSc,
													pszServiceName,
													dwOpenFlags );
				if( NULL != hService )
				{

					// From MSDN...
					// Sets the object's system access control list (SACL). The hService handle must 
					// have ACCESS_SYSTEM_SECURITY access. The proper way to obtain this access is to 
					// enable the SE_SECURITY_NAME privilege in the caller's current access token, open 
					// the handle for ACCESS_SYSTEM_SECURITY access, and then disable the privilege.
					//
					// ...it does not mention if the owner of the service (the process itself) must
					// still do all this. But then again, there is no way to pass in such flags
					// when opening the SCM since we only register for the SCM callback. How odd.
					//

					if( FALSE != SetServiceObjectSecurity( hService, dwFlags, pSD ) )
					{
						fResult = TRUE;
					}
					else
					{
						gdwLastError = GetLastError();
					}

					if( SACL_SECURITY_INFORMATION & dwFlags )
					{
						// Try to disable the privilege since it is no longer needed.
						SetPrivilege( 0, SE_SECURITY_NAME, FALSE );
					}

					CloseServiceHandle( hService );
				}
				else
				{
					gdwLastError = GetLastError();
				}
				CLOSE_SERVICE_CONTROL_MANAGER
			}
		}

		RETVAL = fResult;
	}

	OUTPUT:
		RETVAL


void
GetSecurity( pszMachine, pszServiceName )
    LPTSTR pszMachine
	LPTSTR pszServiceName

	PREINIT:
		SV *pSv = NULL;
		SECURITY_DESCRIPTOR *pSD = NULL;
		BOOL fResult = FALSE;

	CODE:
	{
		//////////////////////////////////////////////////////////////////
		//
		//
		// TEST: p Win32::Daemon::GetSecurity( '', 'TlntSvr' )
		//
		if( 2 != items )
		{
			croak( TEXT( "Usage: " EXTENSION "::GetSecurity( $Machine, $ServiceName )\n" ) );
		}

		if( NULL != pszServiceName )
		{
	        
			// TODO:
			// We should remove this privilege at the end of this function...
			SetPrivilege( 0, SE_SECURITY_NAME, TRUE);

			OPEN_SERVICE_CONTROL_MANAGER( pszMachine )
			SC_HANDLE hService = OpenService( hSc,
												pszServiceName,
												ACCESS_SYSTEM_SECURITY | READ_CONTROL );
			if( NULL != hService )
			{
				DWORD dwBufferSize = 0;
				DWORD dwBytesNeeded = 1024;
				BOOL fContinue = TRUE;
	            
				SetPrivilege( 0, SE_SECURITY_NAME, TRUE);
	            
				do
				{
					fContinue = FALSE;
					if( NULL != pSD )
					{
						delete [] (BYTE*) pSD;
						pSD = NULL;
					}
					pSD = (SECURITY_DESCRIPTOR *) new BYTE[ dwBytesNeeded ];
					if( NULL != pSD )
					{
						dwBufferSize = dwBytesNeeded;
						ZeroMemory( pSD, dwBufferSize );
						if( FALSE == QueryServiceObjectSecurity( 
												hService, 
												DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION, 
												pSD, 
												dwBufferSize, 
												&dwBytesNeeded ) )
						{
							DWORD dwError = GetLastError();
							if( ERROR_INSUFFICIENT_BUFFER == dwError || 0x000001e7 == dwError )
							{
								fContinue = TRUE;
							}
						}
					}
				} while( TRUE == fContinue );

				if( NULL != pSD )
				{
					pSv = newSVpv( (LPTSTR) pSD, dwBytesNeeded );
					delete [] (BYTE*) pSD;
					pSD = NULL;
				}

				CloseServiceHandle( hService );
			}
			else
			{
				gdwLastError = GetLastError();
			}
			CLOSE_SERVICE_CONTROL_MANAGER
		}

		if( NULL != pSv )
		{
			// Return the scalar...
			//		Original code was: PUSH_NOREF( pSv );
			//		...assuming that no need to make pSv mortal?
			ST(0) = pSv;
		}
		else
		{
			// Return undef
			ST(0) = &PL_sv_undef;
		}
	}

	OUTPUT:



const char *
DebugOutputPath( ... )

	CODE:
	{		
		if( 1 < items )
		{
			croak( TEXT( "Usage: " EXTENSION "::DebugOutputPath( [$Path] )\n" ) );
		}
#ifdef _DEBUG
		if( items )
		{
			LPCTSTR pszDebugOutputPath = SvPV_nolen( ST( 0 ) );
			if( NULL != pszDebugOutputPath )
			{
				CreateLog( pszDebugOutputPath );
			}
		}
		
		RETVAL = (LPTSTR) gszDebugOutputPath;
#else	/* ! def _DEBUG */
		RETVAL = TEXT( "" );
#endif	/*	_DEBUG	*/
	}
	OUTPUT:
		RETVAL




DWORD
IsDebugBuild()
	
	CODE:
#ifdef _DEBUG
		RETVAL =  1;
#else
		RETVAL = 0;
#endif
 
	OUTPUT:
		RETVAL	


#	/*
#	HISTORY:
#
#		-20000618
#			-Added:
#				-ConfigureService
#				-QueryServiceConfig
#
#		-20011230 rothd@roth.net
#			- Fixed bug where service doesn't work properly with Windows NT 4. We were 
#			  defaulting by acccepting the SERVICE_ACCEPT_PARAMCHANGE and 
#			  SERVICE_ACCEPT_NETBINDCHANGE controls. However, they were introduced in 
#			  Win2k so NT 4 coughed up blood with them.
#
#		-20010224
#			-Added:
#				-RegisterCallbacks() (and callback support)
#
#		-20011205
#			-Added:
#				-AcceptedControls()
#
#		- 20020605 rothd@roth.net
#			- Added support for reporting service errors. You can now pass in a
#			  hash reference into State(). More details in the POD docs.
#
#		- 20030615 rothd@roth.net
#			- Added callback support (actually finished it!).
#			- Added security support (Set and Get SD).
#				-GetSecurity()
#				-SetSecurity()
#				-IsDebugBuild()
#				-CallbackTimer()			
#		
#		- 20061222 rothd@roth.net
#			- Converted to XS file.
#			- Fixed callback heartbeat: now properly calls back with SERVICE_RUNNING (not SERVICE_CONTROL_RUNNING)
#			- StopService() will post WM_QUIT message to the ServiceMain() thread to shut down the service thread.
#			- Calling into StopService() will auto change the state to STOPPING/STOPPED so you do not need to 
#				explicitly do so (calling State() or a callback returning STOPPING/STOPPED).
#			- Fixed bug where messages were posted to wrong thread.
#
#	*/