rokousb.cpp

Also since the domain name--against which the retrieved domain name is to be matched--is currently h

// RokoUSB.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "USBControl.h"
#include <dbt.h>


/*Function Declarations*/
static VOID WINAPI service_main();
void CmdInstallService();
void CmdRemoveService();
VOID CmdDebugService(int argc, TCHAR **argv);
BOOL WINAPI ControlHandler ( DWORD dwCtrlType );
LPTSTR GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize );

//static VOID WINAPI service_main();
static VOID WINAPI service_ctrl(DWORD dwCtrlCode);
static BOOL ReportStatusToSCMgr(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint);
static BOOL ResumeService();
static BOOL PauseService();
static VOID StopService();
static BOOL RegisterForDeviceNotify(SERVICE_STATUS_HANDLE ssHandle);

/*End Function Declarations*/

/*Global Variables*/
static CUSBControl *pSrv = NULL;
static SERVICE_STATUS			ssStatus;       // current status of the service
static SERVICE_STATUS_HANDLE	sshStatusHandle;
static BOOL						bRunningService = FALSE;	// Service beginning flag
static BOOL						bPauseService = FALSE;		// Stop flag at one o'clock of service
static BOOL						bDebug = FALSE;
static TCHAR					szErr[256];
/*End Global Variables*/


/*Main Function*/
int _tmain(int argc, TCHAR* argv[] /*, TCHAR* envp[] */)
{
//    LOG_DBG(_T("Start"));
	int nRetCode = 0;
	SC_HANDLE hSCM = NULL;
	SC_HANDLE hService = NULL;
	pSrv = new CUSBControl();
	if (pSrv == NULL) 
	{
		printf( "Object Create Error : %d\n", ::GetLastError() );
		return -1;
	} else if (!pSrv->Init()) {   //This initialization will create a event..
		printf( "DtsRsrcCtrlSrv Init() Error : %d\n", ::GetLastError() );
		return -1;
	}

	SERVICE_TABLE_ENTRY dispatchTable[] =
	{
		{ pSrv->GetServiceName(), (LPSERVICE_MAIN_FUNCTION)service_main},
		{ NULL, NULL}
	};
//#ifdef _DEBUG
	if ( (argc > 1) &&
		((*argv[1] == '-') || (*argv[1] == '/')) )
	{
		if ( _tcsicmp( _T("install"), argv[1]+1 ) == 0 )
		{
//			LOG_DBG(_T("Service Installed"));
			CmdInstallService();
		}
		else if ( _tcsicmp( _T("remove"), argv[1]+1 ) == 0 )
		{
//			LOG_DBG(_T("Service Removed"));
			CmdRemoveService();
		}
		else if ( _tcsicmp( _T("debug"), argv[1]+1 ) == 0 )
		{
//			LOG_DBG(_T("Service Debug"));
			bDebug = TRUE;
			CmdDebugService(argc, argv);
		}
		else
		{
			goto dispatch;
		}
		if (pSrv != NULL) delete pSrv;
		return nRetCode;
	}
	
	// if it doesn't match any of the above parameters
	// the service control manager may be starting the service
	// so we must call StartServiceCtrlDispatcher
dispatch:
	// this is just to be friendly
	printf( "%s -install          to install the service\n", pSrv->GetModuleName() );
	printf( "%s -remove           to remove the service\n", pSrv->GetModuleName() );
	printf( "%s -debug <params>   to run as a console app for debugging\n", pSrv->GetModuleName() );
	printf( "\nStartServiceCtrlDispatcher being called.\n" );
	printf( "This may take several seconds.  Please wait.\n" );

//#endif // _DEBUG

	nRetCode = -1;
	try{	// Exception handling
		
		hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
		if(hSCM == NULL){
//			LOG_ERRC(_T("OpenSCManger Failed"),GetLastError());
			
		}

		hService = ::OpenService(hSCM, pSrv->GetServiceName(), SERVICE_CHANGE_CONFIG|SERVICE_START);
		if(hService == NULL){
//			LOG_ERRC(_T("OpenService Failed"),GetLastError());
			
		}

		SERVICE_FAILURE_ACTIONS actions = {0};
		SC_ACTION info[] = {{SC_ACTION_RESTART,1000}, {SC_ACTION_RESTART,1000}, {SC_ACTION_RESTART,1000}};
		actions.cActions = sizeof(info) / sizeof(SC_ACTION);
		actions.lpsaActions = info;
		if(!::ChangeServiceConfig2(hService, SERVICE_CONFIG_FAILURE_ACTIONS, &actions)){
//			LOG_ERRC(_T("ChangeServiceConfig Failed"),GetLastError());
			
		}

		if(hService) ::CloseServiceHandle(hService);
		if(hSCM) ::CloseServiceHandle(hSCM);


		if (!StartServiceCtrlDispatcher(dispatchTable))
		{
//			LOG_ERRC(_T("StartServiceCtrlDispatcher Error"),GetLastError());
			printf( "StartServiceCtrlDispatcher Error : %d\n", ::GetLastError() );
		} else {
			nRetCode = 0;
		}
	}catch(...){
	}

	if (pSrv != NULL) delete pSrv;
//	LOG_DBG(_T("Stop"));
	return nRetCode;

	
}

static void WINAPI service_main(
)
{
	DWORD	dwExitCode = 0;
	
//Sleep(20000);
	try{	// Exception handling
//		LOG_DBG(_T("Service Started"));
		
		//Setting of service control
		if( bDebug == FALSE ){
			// register our service control handler:
			//
			sshStatusHandle = RegisterServiceCtrlHandler(pSrv->GetServiceName(), service_ctrl);
			if (!sshStatusHandle)
			{
//				LOG_FTLC(_T("RegisterServiceCtrlHandler Failed"),GetLastError());
				goto cleanup;
			}
		}

			// SERVICE_STATUS members that don't change in example
		ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
		ssStatus.dwServiceSpecificExitCode = 0;

		// report the status to the service control manager.
		// PENDING !!
		if (!ReportStatusToSCMgr(
								SERVICE_START_PENDING, // service state
								NO_ERROR,              // exit code
								3000))                 // wait hint
		{
//			LOG_ERR(_T("ReportStatusToSCMgr"));
			goto cleanup;
		}

		MessageBox(NULL,L"Inside ServiceMain",L"Information",MB_OK);
		// report the status to the service control manager.
		// RUNNING !!
		if (!ReportStatusToSCMgr(
								SERVICE_RUNNING, // service state
								NO_ERROR,        // exit code
								0))              // wait hint
		{
//			LOG_ERR(_T("ReportStatusToSCMgr"));
			goto cleanup;
		}

		// Service beginning flag ON
		bRunningService = TRUE;

		//Sleep(10000);
		// Service main processing
		pSrv->Run();

	}
	catch(...){	// Exception obtaining
	}

cleanup:

//	try{	// 椺奜張棟
//
//
//	}catch(...){
//	}

	// try to report the stopped status to the service control manager.
	//
	(VOID)ReportStatusToSCMgr(
								SERVICE_STOPPED,
								dwExitCode,
								0);
	return;
	


}
/****************************************************************************
* FUNCTION : service_ctrl
* ABSTRACT : Control handler function of service
*****************************************************************************/
static VOID WINAPI service_ctrl(
	DWORD dwCtrlCode		/* (I)   Control code   */
)
{
//	LOG_DBG(_T("Start"));
	// Handle the requested control code.
	//
	switch (dwCtrlCode)
	{
	// Stop the service.
	//
	// SERVICE_STOP_PENDING should be reported before
	// setting the Stop Event - hServerStopEvent - in
	// ServiceStop().  This avoids a race condition
	// which may result in a 1053 - The Service did not respond...
	// error.
	case SERVICE_CONTROL_STOP:
//		LOG_DBG(_T("SERVICE_CONTROL_STOP Event"));
		ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0);
		//The service stop event is set. 
		StopService();
		return;

#ifdef _DEBUG

	// The temporary suspension of service and the restart are deleted from the processing object in this application because it doesn't support it. 

	// Pause the service
	case SERVICE_CONTROL_PAUSE:
//		LOG_DBG(_T("SERVICE_CONTROL_PAUSE Event"));
		if (bRunningService == TRUE && bPauseService == FALSE){
			// Tell the SCM what's happening
			ReportStatusToSCMgr(SERVICE_PAUSE_PENDING, NO_ERROR, 1000);
			if(PauseService() == TRUE){
				ssStatus.dwCurrentState = SERVICE_PAUSED;
			}else{
				// To the service stop
				ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0);
				StopService();
				return;
			}
		}
		break;

	// Resume from a pause
	case SERVICE_CONTROL_CONTINUE:
//		LOG_DBG(_T("SERVICE_CONTROL_CONTINUE"));
		if (bRunningService == TRUE && bPauseService == TRUE){
			// Tell the SCM what's happening
			ReportStatusToSCMgr(SERVICE_CONTINUE_PENDING, NO_ERROR, 1000);
			if(ResumeService() == TRUE){
				ssStatus.dwCurrentState = SERVICE_RUNNING;
			}else{
				// To the service stop
				ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0);
				StopService();
				return;
			}
		}
		break;
#endif

      // Update the service status.
      //
	case SERVICE_CONTROL_INTERROGATE:
		break;

		// device event
		//
	case SERVICE_CONTROL_DEVICEEVENT:
		MessageBox(NULL,L"Inside ServiceControl",L"Information",MB_OK);
		break;

	default:
		break;

	}
	ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0);
//	LOG_DBG(_T("Stop"));
}

/****************************************************************************
* FUNCTION : ReportStatusToSCMgr
* ABSTRACT : Service control manager's status information is updated. 
*****************************************************************************/
static BOOL ReportStatusToSCMgr(
	DWORD dwCurrentState,	/* (I)   Status of service */
	DWORD dwWin32ExitCode,	/* (I)   Error code       */
	DWORD dwWaitHint)		/* (I)   Notification of status      */
{
	static	DWORD dwCheckPoint = 1;
	BOOL	fResult = TRUE;

	//Nothing is done for debug mode. 
	if ( bDebug == TRUE ){
		return fResult;
	}

	if (dwCurrentState == SERVICE_START_PENDING){
		ssStatus.dwControlsAccepted = 0; 
	}
	else
	{
		//ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;