#include <InitGuid.h>

 #include <Windows.h>

 #include <SetupApi.h>

 #include <tchar.h>

 #include <strsafe.h>

 #include <dbt.h>

 #include <usbiodef.h>

 #include <Winhttp.h>

 #include "OpenSecUSBEventSvcLog.h"

 #pragma comment(lib, "advapi32.lib")

 #define SVCNAME TEXT("OpenSecUSBEventSvc")

 //sc create "USBEventSvc" binPath= "C:\Users\BarthaM\Documents\Visual Studio 2010\Projects\USBEventSvc\Debug\USBEventSvc.exe"

 //sc delete "USBEventSvc"

 // USB Raw Device Interface Class GUID

 //{ 0xa5dcbf10, 0x6530, 0x11d2, { 0x90, 0x1f, 0x00, 0xc0, 0x4f, 0xb9, 0x51,0xed } }

 // Disk Device Interface Class GUID

 //{ 0x53f56307, 0xb6bf, 0x11d0, { 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b } }

 // This GUID is for all USB serial host PnP drivers

 //GUID WceusbshGUID = { 0x25dbce51, 0x6c8f, 0x4a72, 0x8a, 0x6d, 0xb5, 0x4c, 0x2b, 0x4f, 0xc8, 0x35 };

 GUID WceusbshGUID = { 0x88bae032, 0x5a81, 0x49f0, 0xbc, 0x3d, 0xa4, 0xff, 0x13, 0x82, 0x16, 0xd6 };

 //DEFINE_GUID(GUID_CLASS_STORAGE_VOLUME, 0x53F5630DL, 0xB6BF, 0x11D0, 0x94, 0xF2, 0x00, 0xA0, 0xC9, 0x1E, 0xFB, 0x8B);

 SERVICE_STATUS          gSvcStatus;

 SERVICE_STATUS_HANDLE   gSvcStatusHandle = NULL;

 HANDLE                  ghSvcStopEvent = NULL;

 HDEVNOTIFY				ghDeviceNotify;

 DWORD WINAPI ServiceWorkerThread(LPVOID lpParam);

 VOID SvcInstall(void);

 VOID WINAPI SvcCtrlHandler(DWORD);

 VOID WINAPI SvcMain(DWORD, LPTSTR *);

 VOID ReportSvcStatus(DWORD, DWORD, DWORD);

 VOID SvcInit(DWORD, LPTSTR *);

 VOID SvcReportEvent(WORD, LPTSTR);

 // DoRegisterDeviceInterfaceToHwnd

 //     Registers an HWND for notification of changes in the device interfaces

 //     for the specified interface class GUID. 

 // Parameters:

 //     InterfaceClassGuid - The interface class GUID for the device 

 //         interfaces. 

 //     hWnd - Window handle to receive notifications.

 //     hDeviceNotify - Receives the device notification handle. On failure, 

 //         this value is NULL.

 // Return Value:

 //     If the function succeeds, the return value is TRUE.

 //     If the function fails, the return value is FALSE.

 // Note:

 //     RegisterDeviceNotification also allows a service handle be used,

 //     so a similar wrapper function to this one supporting that scenario

 //     could be made from this template.

 BOOL DoRegisterDeviceInterfaceToHwnd(void) {

 	DEV_BROADCAST_DEVICEINTERFACE NotificationFilter;

 	ZeroMemory(&NotificationFilter, sizeof (NotificationFilter));

 	NotificationFilter.dbcc_size = sizeof (DEV_BROADCAST_DEVICEINTERFACE);

 	NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;

 	NotificationFilter.dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;

 	memcpy(&(NotificationFilter.dbcc_classguid), &(GUID_DEVINTERFACE_USB_DEVICE), sizeof(struct _GUID));

 	ghDeviceNotify = RegisterDeviceNotification(gSvcStatusHandle,

 		&NotificationFilter,

 		DEVICE_NOTIFY_SERVICE_HANDLE);// | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);

 	if (NULL == ghDeviceNotify) {

 		SvcReportEvent(EVENTLOG_ERROR_TYPE, _T("RegisterDeviceNotification failed!"));

 		return FALSE;

 	}

 	return TRUE;

 }

 //

 // Purpose: 

 //   Entry point for the process

 //

 // Parameters:

 //   None

 // 

 // Return value:

 //   None

 //

 void __cdecl _tmain(int argc, TCHAR *argv[]) {

 	// If command-line parameter is "install", install the service. 

 	// Otherwise, the service is probably being started by the SCM.

 	if (lstrcmpi(argv[1], TEXT("install")) == 0){

 		SvcInstall();

 		return;

 	}

 	// TO_DO: Add any additional services for the process to this table.

 	SERVICE_TABLE_ENTRY DispatchTable[] = {

 		{ SVCNAME, (LPSERVICE_MAIN_FUNCTION)SvcMain },

 		{ NULL, NULL }

 	};

 	// This call returns when the service has stopped. 

 	// The process should simply terminate when the call returns.

 	if (!StartServiceCtrlDispatcher(DispatchTable)) {

 		SvcReportEvent(EVENTLOG_ERROR_TYPE, TEXT("StartServiceCtrlDispatcher"));

 	}

 }

 // Purpose: 

 //   Installs a service in the SCM database

 //

 // Parameters:

 //   None

 // 

 // Return value:

 //   None

 //

 VOID SvcInstall() {

 	SC_HANDLE schSCManager;

 	SC_HANDLE schService;

 	TCHAR szPath[MAX_PATH];

 	if (!GetModuleFileName(NULL, szPath, MAX_PATH)) {

 		printf("Cannot install service (%d)\n", GetLastError());

 		return;

 	}

 	// Get a handle to the SCM database. local computer, ServicesActive database, full access rights 

 	schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);

 	if (NULL == schSCManager) {

 		printf("Open SCManager failed (%d)\n", GetLastError());

 		return;

 	}

 	// Create the service

 	schService = CreateService(

 		schSCManager,              // SCM database 

 		SVCNAME,                   // name of service 

 		SVCNAME,                   // service name to display 

 		SERVICE_ALL_ACCESS,        // desired access 

 		SERVICE_WIN32_OWN_PROCESS, // service type 

 		SERVICE_DEMAND_START,      // start type 

 		SERVICE_ERROR_NORMAL,      // error control type 

 		szPath,                    // path to service's binary 

 		NULL,                      // no load ordering group 

 		NULL,                      // no tag identifier 

 		NULL,                      // no dependencies 

 		NULL,                      // LocalSystem account 

 		NULL);                     // no password 

 	if (schService == NULL) {

 		printf("CreateService failed (%d)\n", GetLastError());

 		CloseServiceHandle(schSCManager);

 		return;

 	}

 	else printf("Service installed successfully\n");

 	CloseServiceHandle(schService);

 	CloseServiceHandle(schSCManager);

 }

 //

 // Purpose: 

 //   Entry point for the service

 //

 // Parameters:

 //   dwArgc - Number of arguments in the lpszArgv array

 //   lpszArgv - Array of strings. The first string is the name of

 //     the service and subsequent strings are passed by the process

 //     that called the StartService function to start the service.

 // 

 // Return value:

 //   None.

 //

 VOID WINAPI SvcMain(DWORD dwArgc, LPTSTR *lpszArgv) {

 	// Register the handler function for the service

 	gSvcStatusHandle = RegisterServiceCtrlHandlerEx(SVCNAME, (LPHANDLER_FUNCTION_EX)SvcCtrlHandler, 0);

 	if (!gSvcStatusHandle) {

 		SvcReportEvent(EVENTLOG_ERROR_TYPE, TEXT("RegisterServiceCtrlHandler"));

 		return;

 	}

 	// These SERVICE_STATUS members remain as set here

 	gSvcStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;

 	gSvcStatus.dwServiceSpecificExitCode = 0;

 	// Report initial status to the SCM

 	ReportSvcStatus(SERVICE_START_PENDING, NO_ERROR, 3000);

 	if (!DoRegisterDeviceInterfaceToHwnd()) {

 		// Terminate on failure.

 		SvcReportEvent(EVENTLOG_ERROR_TYPE, TEXT("DoRegisterDeviceInterfaceToHwnd"));

 		ExitProcess(1);

 	}

 	// default security attributes, manual reset, not signaled, no name

 	ghSvcStopEvent = CreateEvent(NULL, TRUE, FALSE,	NULL);

 	if (ghSvcStopEvent == NULL) {

 		ReportSvcStatus(SERVICE_STOPPED, NO_ERROR, 0);

 		return;

 	}

 	// Report running status when initialization is complete.

 	ReportSvcStatus(SERVICE_RUNNING, NO_ERROR, 0);

 	SvcReportEvent(EVENTLOG_INFORMATION_TYPE, TEXT("OpenSecUSBEventSvc is running"));

 	// Wait until our worker thread exits signaling that the service needs to stop

 	WaitForSingleObject(ghSvcStopEvent, INFINITE);

 	SvcReportEvent(EVENTLOG_INFORMATION_TYPE, TEXT("OpenSecUSBEventSvc is exiting"));

 	// Perform any cleanup tasks

 	CloseHandle(ghSvcStopEvent);

 	// Report running status when initialization is complete.

 	ReportSvcStatus(SERVICE_STOPPED, NO_ERROR, 0);

 }

 void NotifyOpenSecManager (void) {

 	HINTERNET	hSession = NULL,

 				hConnect = NULL,

 				hRequest = NULL;

 	BOOL		bResults = FALSE;

 	//devices_json = url_encode(devices_json);

 	// Use WinHttpOpen to obtain a session handle.

 	hSession = WinHttpOpen(L"OpenSecUSBEventSvc", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);

 	if (!hSession) {

 		SvcReportEvent(EVENTLOG_ERROR_TYPE, TEXT("Error notifying the OpenSec manager. WinHttpOpen failed! "));

 		return;

 	}

 	// Specify an HTTP server.

 	hConnect = WinHttpConnect(hSession, L"localhost", 8080, 0);

 	if (!hConnect) {

 		SvcReportEvent(EVENTLOG_ERROR_TYPE, TEXT("Error notifying the OpenSec manager. WinHttpConnect failed! "));

 		return;

 	}

 	// Create an HTTP request handle.

 	hRequest = WinHttpOpenRequest(hConnect, L"GET", L"/device_change", NULL, WINHTTP_NO_REFERER, NULL, NULL);

 	if(!hRequest) {

 		SvcReportEvent(EVENTLOG_ERROR_TYPE, TEXT("Error notifying the OpenSec manager. WinHttpOpenRequest failed! "));

 		return;

 	}

 	// Send a request.

 	bResults = WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);

 	if (!bResults) {

 		SvcReportEvent(EVENTLOG_ERROR_TYPE, TEXT("Error notifying the OpenSec manager. WinHttpSendRequest failed! "));

 		return;

 	}

 	// End the request.

 	//if (bResults)

 	//	bResults = WinHttpReceiveResponse(hRequest, NULL);

 	//DWORD dwSize = 0;

 	//LPVOID lpOutBuffer = NULL;

 	//if (bResults) {

 	//	WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_RAW_HEADERS_CRLF, WINHTTP_HEADER_NAME_BY_INDEX, NULL, &dwSize, WINHTTP_NO_HEADER_INDEX);

 	//	// Allocate memory for the buffer.

 	//	if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {

 	//		lpOutBuffer = new WCHAR[dwSize / sizeof(WCHAR)];

 	//		// Now, use WinHttpQueryHeaders to retrieve the header.

 	//		bResults = WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_RAW_HEADERS_CRLF, WINHTTP_HEADER_NAME_BY_INDEX, lpOutBuffer, &dwSize, WINHTTP_NO_HEADER_INDEX);

 	//	}

 	//}

 	//// Print the header contents.

 	//if (bResults)

 	//	printf("Header contents: \n%S", lpOutBuffer);

 	//// Free the allocated memory.

 	//delete [] lpOutBuffer;

 }

 //

 // Purpose: 

 //   Sets the current service status and reports it to the SCM.

 //

 // Parameters:

 //   dwCurrentState - The current state (see SERVICE_STATUS)

 //   dwWin32ExitCode - The system error code

 //   dwWaitHint - Estimated time for pending operation, 

 //     in milliseconds

 // 

 // Return value:

 //   None

 //

 VOID ReportSvcStatus(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint) {

 	static DWORD dwCheckPoint = 1;

 	// Fill in the SERVICE_STATUS structure.

 	gSvcStatus.dwCurrentState = dwCurrentState;

 	gSvcStatus.dwWin32ExitCode = dwWin32ExitCode;

 	gSvcStatus.dwWaitHint = dwWaitHint;

 	if (dwCurrentState == SERVICE_START_PENDING)

 		gSvcStatus.dwControlsAccepted = 0;

 	else gSvcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;

 	if ((dwCurrentState == SERVICE_RUNNING) ||

 		(dwCurrentState == SERVICE_STOPPED))

 		gSvcStatus.dwCheckPoint = 0;

 	else gSvcStatus.dwCheckPoint = dwCheckPoint++;

 	// Report the status of the service to the SCM.

 	SetServiceStatus(gSvcStatusHandle, &gSvcStatus);

 }

 // Purpose: 

 //   Called by SCM whenever a control code is sent to the service

 //   using the ControlService function.

 //

 // Parameters:

 //   dwCtrl - control code

 // 

 // Return value:

 //   None

 //

 VOID WINAPI SvcCtrlHandler(DWORD dwCtrl) {

 	// Handle the requested control code. 

 	switch (dwCtrl) {

 		case SERVICE_CONTROL_STOP:

 			UnregisterDeviceNotification(ghDeviceNotify);

 			ReportSvcStatus(SERVICE_STOP_PENDING, NO_ERROR, 0);

 			// Signal the service to stop.

 			SetEvent(ghSvcStopEvent);

 			ReportSvcStatus(gSvcStatus.dwCurrentState, NO_ERROR, 0);

 			return;

 		case SERVICE_CONTROL_INTERROGATE:

 			break;

 		case SERVICE_CONTROL_DEVICEEVENT:

 			SvcReportEvent(EVENTLOG_INFORMATION_TYPE, _T("Received SERVICE_CONTROL_DEVICEEVENT"));

 			//NotifyOpenSecManager();

 			break;

 		default:

 			break;

 	}

 }

 //

 // Purpose: 

 //   Logs messages to the event log

 //

 // Parameters:

 //   szFunction - name of function that failed

 // 

 // Return value:

 //   None

 //

 // Remarks:

 //   The service must have an entry in the Application event log.

 //

 VOID SvcReportEvent(WORD type, LPTSTR szFunction) {

 	HANDLE hEventSource;

 	LPCTSTR lpszStrings[2];

 	TCHAR Buffer[80];

 	hEventSource = RegisterEventSource(NULL, SVCNAME);

 	if (NULL != hEventSource) {

 		if (type == EVENTLOG_ERROR_TYPE)

 			StringCchPrintf(Buffer, 80, TEXT("Error has occured. %s failed with %d"), szFunction, GetLastError());

 		else

 			StringCchPrintf(Buffer, 80, TEXT("%s"), szFunction);

 		lpszStrings[0] = SVCNAME;

 		lpszStrings[1] = Buffer;

 		if (type == EVENTLOG_ERROR_TYPE)

 			ReportEvent(hEventSource,       

 				type, // event type

 				0,                   // event category

 				SVC_ERROR,           // event identifier

 				NULL,                // no security identifier

 				2,                   // size of lpszStrings array

 				0,                   // no binary data

 				lpszStrings,         // array of strings

 				NULL);               // no binary data

 		else

 			ReportEvent(hEventSource,

 				type, // event type

 				0,                   // event category

 				SVC_ERROR,		     // event identifier

 				NULL,                // no security identifier

 				2,                   // size of lpszStrings array

 				0,                   // no binary data

 				lpszStrings,         // array of strings

 				NULL);               // no binary data

 		DeregisterEventSource(hEventSource);

 	}

 }