#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);

	}

}