Migrated to new Version of Flavio's Windows driver

virtualsmartcard/win32/BixVReader/BixVReader.ini

@@ -0,0 +1,84 @@
+[Driver]
+NumReaders=12
+
+[Reader0]
+RPC_TYPE=0
+VENDOR_NAME=VirtualCard
+VENDOR_IFD_TYPE=BixReader
+DECIVE_UNIT=0
+
+[Reader1]
+RPC_TYPE=1
+VENDOR_NAME=VirtualCard
+VENDOR_IFD_TYPE=BixReader
+DECIVE_UNIT=1
+
+[Reader2]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35963
+DECIVE_UNIT=2
+
+[Reader3]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35964
+DECIVE_UNIT=3
+
+[Reader4]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35965
+DECIVE_UNIT=4
+
+[Reader5]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35966
+DECIVE_UNIT=5
+
+[Reader6]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35967
+DECIVE_UNIT=6
+
+[Reader7]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35968
+DECIVE_UNIT=7
+
+[Reader8]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35969
+DECIVE_UNIT=8
+
+[Reader9]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35970
+DECIVE_UNIT=9
+
+[Reader10]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35971
+DECIVE_UNIT=10
+
+[Reader11]
+RPC_TYPE=2
+VENDOR_NAME=Virtual Smart Card Architecture
+VENDOR_IFD_TYPE=Virtual PCD
+TCP_PORT=35972
+DECIVE_UNIT=11

virtualsmartcard/win32/BixVReader/BixVReader.rc

@@ -43,11 +43,11 @@ BEGIN
         BLOCK "001004b0"
         BEGIN
             VALUE "CompanyName", "Windows (R) Codename Longhorn DDK provider"
-            VALUE "FileDescription", "Virtual Smart Card Driver"
+            VALUE "FileDescription", "Bix Virtual Smart Card Driver"
             VALUE "FileVersion", "6.0.6000.16384"
-            VALUE "InternalName", "vpcd"
+            VALUE "InternalName", "BixVReader"
             VALUE "LegalCopyright", "© Microsoft Corporation. All rights reserved."
-            VALUE "OriginalFilename", "vpcd.dll"
+            VALUE "OriginalFilename", "BixVReader.dll"
             VALUE "ProductName", "Windows (R) Codename Longhorn DDK driver"
             VALUE "ProductVersion", "6.0.6000.16384"
         END

virtualsmartcard/win32/BixVReader/DllMain.cpp

@@ -1,4 +1,3 @@
-
 #include "internal.h"
 
 class CVirtualSmartCardDriverModule : public CAtlDllModuleT<CVirtualSmartCardDriverModule> {} _AtlModule;
@@ -24,6 +23,7 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE    hInstance,
                                DWORD        dwReason,
                                LPVOID       lpReserved)
 {
+	inFunc
     (lpReserved);
 
     switch (dwReason)
@@ -61,6 +61,7 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE    hInstance,
 /////////////////////////////////////////////////////////////////////////
 STDAPI DllCanUnloadNow(void)
 {
+	inFunc
     return _AtlModule.DllCanUnloadNow();
 }
 
@@ -83,6 +84,7 @@ STDAPI DllCanUnloadNow(void)
 
 STDAPI DllGetClassObject(__in REFCLSID rclsid, __in REFIID riid, __deref_out LPVOID* ppv)
 {
+	inFunc
     return _AtlModule.DllGetClassObject(rclsid, riid, ppv);
 }
 
@@ -105,6 +107,7 @@ STDAPI DllGetClassObject(__in REFCLSID rclsid, __in REFIID riid, __deref_out LPV
 /////////////////////////////////////////////////////////////////////////
 STDAPI DllRegisterServer(void)
 {
+	inFunc
     return S_OK;
 }
 
@@ -129,6 +132,7 @@ STDAPI DllRegisterServer(void)
 /////////////////////////////////////////////////////////////////////////
 STDAPI DllUnregisterServer(void)
 {
+	inFunc
     return S_OK;
 }
 

virtualsmartcard/win32/BixVReader/PipeReader.cpp

@@ -0,0 +1,264 @@
+#include "internal.h"
+#include "VirtualSCReader.h"
+#include "reader.h"
+#include "device.h"
+#include <winscard.h>
+#include "memory.h"
+#include <Sddl.h>
+#include "sectionLocker.h"
+
+BOOL CreateMyDACL(SECURITY_ATTRIBUTES * pSA)
+{
+     TCHAR * szSD = TEXT("D:")       // Discretionary ACL
+        TEXT("(D;OICI;GA;;;BG)")     // Deny access to 
+                                     // built-in guests
+        TEXT("(D;OICI;GA;;;AN)")     // Deny access to 
+                                     // anonymous logon	
+        TEXT("(A;OICI;GRGWGX;;;AU)") // Allow 
+                                     // read/write/execute 
+                                     // to authenticated 
+                                     // users
+        TEXT("(A;OICI;GA;;;BA)");    // Allow full control 
+                                     // to administrators
+
+    if (NULL == pSA)
+        return FALSE;
+
+     return ConvertStringSecurityDescriptorToSecurityDescriptor(
+                szSD,
+                SDDL_REVISION_1,
+                &(pSA->lpSecurityDescriptor),
+                NULL);
+}
+
+PipeReader::PipeReader() {
+	rpcType=0;
+	state=SCARD_ABSENT;
+
+	InitializeCriticalSection(&eventSection);
+	InitializeCriticalSection(&dataSection);
+}
+
+void PipeReader::init(wchar_t *section) {
+	wchar_t temp[300];
+	swprintf(temp,L"SCardSimulatorDriver%i",instance);
+	GetPrivateProfileStringW(section,L"PIPE_NAME",temp,pipeName,300,L"BixVReader.ini");
+	swprintf(temp,L"SCardSimulatorDriverEvents%i",instance);
+	GetPrivateProfileStringW(section,L"PIPE_EVENT_NAME",temp,pipeEventName,300,L"BixVReader.ini");
+	
+}
+
+bool PipeReader::CheckATR() {
+	//SectionLocker lock(dataSection);
+
+	if (pipe==NULL)
+		return false;
+	DWORD read=0;
+	DWORD command=1;
+	if (!WriteFile(pipe,&command,sizeof(DWORD),&read,NULL)) {
+		return false;
+	}
+	FlushFileBuffers(pipe);
+	DWORD size=0;
+	if (!ReadFile(pipe,&size,sizeof(DWORD),&read,NULL)) {
+		return false;
+	}
+	if (size==0)
+		return false;
+	BYTE ATR[100];
+	if (!ReadFile(pipe,ATR,size,&read,NULL)) {
+		return false;
+	}
+	return true;
+}
+bool PipeReader::QueryTransmit(BYTE *APDU,int APDUlen,BYTE *Resp,int *Resplen) {
+	//SectionLocker lock(dataSection);
+
+	if (pipe==NULL)
+		return false;
+	DWORD command=2;
+	DWORD read=0;
+	if (!WriteFile(pipe,&command,sizeof(DWORD),&read,NULL)) {
+		pipe=NULL;
+		return false;
+	}
+	DWORD dwAPDUlen=(DWORD)APDUlen;
+	if (!WriteFile(pipe,&dwAPDUlen,sizeof(DWORD),&read,NULL)) {
+		pipe=NULL;
+		return false;
+	}
+	if (!WriteFile(pipe,APDU,APDUlen,&read,NULL)) {
+		pipe=NULL;
+		return false;
+	}
+	FlushFileBuffers(pipe);
+	DWORD dwRespLen=0;
+	if (!ReadFile(pipe,&dwRespLen,sizeof(DWORD),&read,NULL)) {
+		pipe=NULL;
+		return false;
+	}
+	if (!ReadFile(pipe,Resp,dwRespLen,&read,NULL)) {
+		pipe=NULL;
+		return false;
+	}
+	(*Resplen)=(int)dwRespLen;
+	return true;
+}
+
+bool PipeReader::QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset) {
+	//SectionLocker lock(dataSection);
+
+	if (pipe==NULL)
+		return false;
+	DWORD command=reset ? 0 : 1;
+	DWORD read=0;
+	if (!WriteFile(pipe,&command,sizeof(DWORD),&read,NULL)) {
+		pipe=NULL;
+		return false;
+	}
+	FlushFileBuffers(pipe);
+	DWORD size=0;
+	if (!ReadFile(pipe,&size,sizeof(DWORD),&read,NULL)) {
+		pipe=NULL;
+		return false;
+	}
+	if (size==0)
+		return false;
+	if (!ReadFile(pipe,ATR,size,&read,NULL)) {
+		pipe=NULL;
+		return false;
+	}
+	(*ATRsize)=size;
+	return true;
+}
+
+DWORD PipeReader::startServer() {
+	SECURITY_ATTRIBUTES sa;
+	sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+    sa.bInheritHandle = FALSE;  
+	CreateMyDACL(&sa);
+
+	wchar_t temp[300];
+	swprintf(temp,L"\\\\.\\pipe\\%s",pipeName);
+	HANDLE _pipe=CreateNamedPipe(temp,PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED,PIPE_TYPE_BYTE,PIPE_UNLIMITED_INSTANCES,0,0,0,&sa);
+	swprintf(temp,L"\\\\.\\pipe\\%s",pipeEventName);
+	HANDLE _eventpipe=CreateNamedPipe(temp,PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED,PIPE_TYPE_BYTE,PIPE_UNLIMITED_INSTANCES,0,0,0,&sa);
+	wchar_t log[300];
+	swprintf(log,L"[BixVReader]Pipe created:%s:%08x",pipeName,_pipe);
+	OutputDebugString(log);
+
+	while (true) {
+		//__try {
+			BOOL ris=ConnectNamedPipe(_pipe,NULL);
+			if (ris==0) {
+				swprintf(log,L"[BixVReader]Pipe NOT connected:%x",GetLastError());
+				OutputDebugString(log);
+			}
+			else {
+				swprintf(log,L"[BixVReader]Pipe connected");
+				OutputDebugString(log);
+				}
+			ris=ConnectNamedPipe(_eventpipe,NULL);
+			if (ris==0) {
+				swprintf(log,L"[BixVReader]Event Pipe NOT connected:%x",GetLastError());
+				OutputDebugString(log);
+			}
+			else {
+				swprintf(log,L"[BixVReader]Event Pipe connected");
+				OutputDebugString(log);
+			}
+			pipe=_pipe;
+			eventpipe=_eventpipe;
+			if (waitInsertIpr!=NULL) {
+				SectionLocker lock(device->m_RequestLock);
+				// if I'm waiting for card insertion, verify if there's a card present
+				if (initProtocols()) {
+					if (waitInsertIpr->UnmarkCancelable()==S_OK)
+						waitInsertIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+					waitInsertIpr=NULL;
+					state=SCARD_SWALLOWED;					
+				}
+			}
+			
+			while (true) {
+				// wait for a command
+				DWORD command=0;
+				DWORD read=0;
+				if (!ReadFile(eventpipe,&command,sizeof(DWORD),&read,NULL)) {
+					state=SCARD_ABSENT;
+					OutputDebugString(L"[BixVReader]Pipe error");
+					powered=0;
+					pipe=NULL;
+					eventpipe=NULL;
+					if (waitRemoveIpr!=NULL) {// card inserted
+						SectionLocker lock(device->m_RequestLock);
+						OutputDebugString(L"[BixVReader]complete Wait Remove");
+						if (waitRemoveIpr->UnmarkCancelable()==S_OK) {
+							OutputDebugString(L"[BixVReader]Wait Remove Unmarked");
+							waitRemoveIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+							OutputDebugString(L"[BixVReader]Wait Remove Completed");
+						}
+						waitRemoveIpr=NULL;
+					}
+					if (waitInsertIpr!=NULL) {// card removed
+						SectionLocker lock(device->m_RequestLock);
+						OutputDebugString(L"[BixVReader]cancel Wait Remove");
+						if (waitInsertIpr->UnmarkCancelable()==S_OK) {
+							OutputDebugString(L"[BixVReader]Wait Insert Unmarked");
+							waitInsertIpr->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_CANCELLED), 0);
+							OutputDebugString(L"[BixVReader]Wait Insert Cancelled");
+						}
+						waitInsertIpr=NULL;
+					}
+					DisconnectNamedPipe(_pipe);
+					DisconnectNamedPipe(_eventpipe);
+					break;
+				}
+				OutputDebugString(L"[BixVReader]Pipe data");
+				if (command==0)
+					powered=0;
+				if (command==0 && waitRemoveIpr!=NULL) {// card removed
+					SectionLocker lock(device->m_RequestLock);
+					state=SCARD_ABSENT;
+					if (waitRemoveIpr->UnmarkCancelable()==S_OK) {						
+						waitRemoveIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+					}
+					waitRemoveIpr=NULL;
+				}
+				else if (command==1 && waitInsertIpr!=NULL) {// card inserted
+					SectionLocker lock(device->m_RequestLock);
+					state=SCARD_SWALLOWED;
+					initProtocols();
+					if (waitInsertIpr->UnmarkCancelable()==S_OK) {
+						waitInsertIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+					}
+					waitInsertIpr=NULL;
+				}
+			}
+		//}
+		//__except(EXCEPTION_EXECUTE_HANDLER) {
+		//	wchar_t log[300];
+		//	DWORD err=GetExceptionCode();
+		//	swprintf(log,L"Exception:%08X",err);
+		//	OutputDebugString(log);
+		//}
+	}
+	OutputDebugString(L"[BixVReader]Pipe quit!!!");
+	return 0;
+}
+
+void PipeReader::shutdown() {
+	state=SCARD_ABSENT;
+	if (waitRemoveIpr!=NULL) {
+		SectionLocker lock(device->m_RequestLock);
+		if (waitRemoveIpr->UnmarkCancelable()==S_OK)
+			waitRemoveIpr->Complete(HRESULT_FROM_WIN32(ERROR_CANCELLED));
+		waitRemoveIpr=NULL;
+	}
+	if (waitInsertIpr!=NULL) {
+		SectionLocker lock(device->m_RequestLock);
+		if (waitInsertIpr->UnmarkCancelable()==S_OK)
+			waitInsertIpr->Complete(HRESULT_FROM_WIN32(ERROR_CANCELLED));
+		waitInsertIpr=NULL;
+	}
+}

virtualsmartcard/win32/BixVReader/Queue.cpp

@@ -1,8 +1,7 @@
-
-
 #include "internal.h"
 #include "Device.h"
 #include "Queue.h"
+#include "SectionLocker.h"
 
 /////////////////////////////////////////////////////////////////////////
 //
@@ -16,7 +15,6 @@
 CMyQueue::CMyQueue() :
     m_pParentDevice(NULL)
 {
-	state=0;
 }
 
 /////////////////////////////////////////////////////////////////////////
@@ -49,7 +47,8 @@ CMyQueue::~CMyQueue()
 /////////////////////////////////////////////////////////////////////////
 HRESULT CMyQueue::CreateInstance(__in IWDFDevice*  pWdfDevice, CMyDevice* pMyDevice)
 {
-	inFunc;
+	inFunc
+	SectionLogger a(__FUNCTION__);
     CComObject<CMyQueue>* pMyQueue = NULL;
 
     if(NULL == pMyDevice)
@@ -86,10 +85,10 @@ HRESULT CMyQueue::CreateInstance(__in IWDFDevice*  pWdfDevice, CMyDevice* pMyDev
                                             );
             if (FAILED(hr))
             {
-				OutputDebugString (L"IoQueue NOT Created\n");
+				OutputDebugString (L"[BixVReader]IoQueue NOT Created\n");
             }
 			else
-				OutputDebugString (L"IoQueue Created\n");
+				OutputDebugString (L"[BixVReader]IoQueue Created\n");
 
         }
 
@@ -122,5 +121,4 @@ STDMETHODIMP_ (void) CMyQueue::OnDeviceIoControl(
     )
 {
 	m_pParentDevice->ProcessIoControl(pQueue,pRequest,ControlCode,InputBufferSizeInBytes,OutputBufferSizeInBytes);    
-    
 }

virtualsmartcard/win32/BixVReader/Queue.h

@@ -21,7 +21,6 @@ protected:
 
 // COM Interface methods
 public:
-	int state;
     // IQueueCallbackDeviceIoControl
     STDMETHOD_ (void, OnDeviceIoControl)(
         __in IWDFIoQueue*    pQueue,

virtualsmartcard/win32/BixVReader/Reader.cpp

@@ -0,0 +1,426 @@
+#include "internal.h"
+#include "VirtualSCReader.h"
+#include "reader.h"
+#include "device.h"
+#include <winscard.h>
+#include "memory.h"
+#include <Sddl.h>
+#include "SectionLocker.h"
+
+void Reader::init(wchar_t *section) {
+	section;
+	state=SCARD_ABSENT;
+}
+
+void Reader::IoSmartCardIsPresent(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
+	UNREFERENCED_PARAMETER(inBufSize);
+	UNREFERENCED_PARAMETER(outBufSize);
+	
+	OutputDebugString(L"[BixVReader][IPRE]IOCTL_SMARTCARD_IS_PRESENT");
+	if (CheckATR()) {
+		// there's a smart card present, so complete the request
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
+	}
+	else {
+		// there's no smart card present, so leave the request pending; it will be completed later
+		SectionLocker lock(device->m_RequestLock);
+		waitInsertIpr=pRequest;
+		IRequestCallbackCancel *callback;
+		device->QueryInterface(__uuidof(IRequestCallbackCancel),(void**)&callback);
+		pRequest->MarkCancelable(callback);
+		callback->Release();
+	}
+}
+
+void Reader::IoSmartCardGetState(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
+	UNREFERENCED_PARAMETER(inBufSize);
+	UNREFERENCED_PARAMETER(outBufSize);
+	OutputDebugString(L"[BixVReader][GSTA]IOCTL_SMARTCARD_GET_STATE");
+	wchar_t log[300];
+	swprintf(log,L"[BixVReader]STATE:%08X",state);
+	OutputDebugString(log);
+	setInt(device,pRequest,state);
+}
+void Reader::IoSmartCardIsAbsent(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
+	UNREFERENCED_PARAMETER(inBufSize);
+	UNREFERENCED_PARAMETER(outBufSize);
+	OutputDebugString(L"[BixVReader][IABS]IOCTL_SMARTCARD_IS_ABSENT");
+	if (!CheckATR()) {
+		// there's no smart card present, so complete the request
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
+	}
+	else {
+		SectionLocker lock(device->m_RequestLock);
+		// there's a smart card present, so leave the request pending; it will be completed later
+		waitRemoveIpr=pRequest;
+		IRequestCallbackCancel *callback;
+
+		device->QueryInterface(__uuidof(IRequestCallbackCancel),(void**)&callback);
+		pRequest->MarkCancelable(callback);
+		callback->Release();
+	}
+}
+
+void Reader::IoSmartCardPower(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
+	UNREFERENCED_PARAMETER(inBufSize);
+	UNREFERENCED_PARAMETER(outBufSize);
+	OutputDebugString(L"[BixVReader][POWR]IOCTL_SMARTCARD_POWER");
+	DWORD code=getInt(pRequest);
+	if (code==SCARD_COLD_RESET) {
+		OutputDebugString(L"[BixVReader][POWR]SCARD_COLD_RESET");
+		protocol=0;
+		powered=1;
+		state=SCARD_NEGOTIABLE;
+	}
+	else if (code==SCARD_WARM_RESET) {
+		OutputDebugString(L"[BixVReader][POWR]SCARD_WARM_RESET");
+		protocol=0;
+		powered=1;
+		state=SCARD_NEGOTIABLE;
+	}
+	else if (code==SCARD_POWER_DOWN) {
+		OutputDebugString(L"[BixVReader][POWR]SCARD_POWER_DOWN");
+		protocol=0;
+		powered=0;
+		state=SCARD_SWALLOWED;
+	}
+	if (code==SCARD_COLD_RESET || code==SCARD_WARM_RESET) {
+		BYTE ATR[100];
+		DWORD ATRsize;
+		if (!QueryATR(ATR,&ATRsize,true))
+		{
+			pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);					
+			return;
+		}
+		setBuffer(device,pRequest,ATR,ATRsize);
+	}
+	else {
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
+	}
+	
+}
+
+void Reader::IoSmartCardSetProtocol(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
+	UNREFERENCED_PARAMETER(inBufSize);
+	UNREFERENCED_PARAMETER(outBufSize);
+	UNREFERENCED_PARAMETER(instance);
+
+	DWORD requestedProtocol=getInt(pRequest);	
+	wchar_t log[300];
+	swprintf(log,L"[BixVReader][SPRT]IOCTL_SMARTCARD_SET_PROTOCOL:%08X",requestedProtocol);
+	OutputDebugString(log);
+
+	BYTE ATR[100];
+	DWORD ATRsize;
+	state=SCARD_SPECIFIC;
+	if (!QueryATR(ATR,&ATRsize,true))
+	{
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);					
+		return;
+	}
+		
+	if (((requestedProtocol & SCARD_PROTOCOL_T1) != 0) &&
+		((availableProtocol & SCARD_PROTOCOL_T1) != 0)) {
+		protocol = SCARD_PROTOCOL_T1;
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
+		OutputDebugString(L"[BixVReader]PROTOCOL SET: T1");
+		return;
+	}	
+
+	if (((requestedProtocol & SCARD_PROTOCOL_T0) != 0) &&
+		((availableProtocol & SCARD_PROTOCOL_T0) != 0)) {
+		protocol = SCARD_PROTOCOL_T0;
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
+		OutputDebugString(L"[BixVReader]PROTOCOL SET: T0");
+		return;
+	}	
+
+	if (((requestedProtocol & (SCARD_PROTOCOL_DEFAULT)) != 0) &&
+		((availableProtocol & SCARD_PROTOCOL_T1) != 0)) {
+		protocol = SCARD_PROTOCOL_T1;
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
+		OutputDebugString(L"[BixVReader]PROTOCOL SET: T1");
+		return;
+	}	
+
+	if (((requestedProtocol & (SCARD_PROTOCOL_DEFAULT)) != 0) &&
+		((availableProtocol & SCARD_PROTOCOL_T0) != 0)) {
+		protocol = SCARD_PROTOCOL_T0;
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
+		OutputDebugString(L"[BixVReader]PROTOCOL SET: T0");
+		return;
+	}	
+	{
+		state=SCARD_NEGOTIABLE;
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+	}
+}
+
+	void Reader::IoSmartCardSetAttribute(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
+	UNREFERENCED_PARAMETER(inBufSize);
+	UNREFERENCED_PARAMETER(outBufSize);
+	UNREFERENCED_PARAMETER(instance);
+	OutputDebugString(L"[BixVReader][SATT]IOCTL_SMARTCARD_SET_ATTRIBUTE");
+	
+	IWDFMemory *inmem=NULL;
+	pRequest->GetInputMemory(&inmem);
+	
+	SIZE_T size;
+	BYTE *data=(BYTE *)inmem->GetDataBuffer(&size);
+
+	DWORD minCode=*(DWORD*)(data);
+	bool handled=false;
+	if (minCode==SCARD_ATTR_DEVICE_IN_USE) {
+		SectionLocker lock(device->m_RequestLock);
+		OutputDebugString(L"[BixVReader][SATT]SCARD_ATTR_DEVICE_IN_USE");
+		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
+		handled=true;
+	}
+	inmem->Release();
+	if (!handled) {
+		SectionLocker lock(device->m_RequestLock);
+		wchar_t log[300];
+		swprintf(log,L"[BixVReader][SATT]ERROR_NOT_SUPPORTED:%08X",minCode);
+		OutputDebugString(log);
+		pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+	}
+}
+
+void Reader::IoSmartCardTransmit(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
+	UNREFERENCED_PARAMETER(inBufSize);
+	UNREFERENCED_PARAMETER(outBufSize);
+	OutputDebugString(L"[BixVReader][TRSM]IOCTL_SMARTCARD_TRANSMIT");
+	BYTE APDU[1000];
+	int APDUSize;
+	getBuffer(pRequest,APDU,&APDUSize);
+	if (((SCARD_IO_REQUEST*)APDU)->dwProtocol!=protocol) {
+		SectionLocker lock(device->m_RequestLock);
+        pRequest->CompleteWithInformation(STATUS_INVALID_DEVICE_STATE, 0);
+		return;
+	}
+	BYTE Resp[1000];
+	int RespSize;
+	if (!QueryTransmit(APDU+sizeof(SCARD_IO_REQUEST),APDUSize-sizeof(SCARD_IO_REQUEST),Resp+sizeof(SCARD_IO_REQUEST),&RespSize))
+	{
+		SectionLocker lock(device->m_RequestLock);
+		pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);					
+		return;
+	}
+	((SCARD_IO_REQUEST*)Resp)->cbPciLength=sizeof(SCARD_IO_REQUEST);
+	((SCARD_IO_REQUEST*)Resp)->dwProtocol=protocol;
+	setBuffer(device,pRequest,Resp,RespSize+sizeof(SCARD_IO_REQUEST));
+}
+
+void Reader::IoSmartCardGetAttribute(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
+	UNREFERENCED_PARAMETER(inBufSize);
+	
+	wchar_t log[300]=L"";
+	char temp[300];
+
+	DWORD code=getInt(pRequest);
+	swprintf(log,L"[BixVReader][GATT]  - code %0X",code);
+	OutputDebugString(log);
+
+	switch(code) {
+		case SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA009):
+			// custom attribute; RPC_TYPE
+			OutputDebugString(L"[BixVReader][GATT]RPC_TYPE");
+			setInt(device,pRequest,rpcType);
+			return;
+		case SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA00a):
+			// custom attribute; PipeName
+			if (rpcType==0) {	
+				PipeReader *pipe=(PipeReader *)this;
+				OutputDebugString(L"[BixVReader][GATT]PIPE_NAME");
+				sprintf(temp,"%S",pipe->pipeName);
+				setString(device,pRequest,(char*)temp,(int)outBufSize);
+			}
+			else {
+				SectionLocker lock(device->m_RequestLock);
+				pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+			}
+			return;
+		case SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA00b):
+			// custom attribute; EventPipeName
+			if (rpcType==0) {	
+				PipeReader *pipe=(PipeReader *)this;
+				OutputDebugString(L"[BixVReader][GATT]EVENT_PIPE_NAME");
+				sprintf(temp,"%S",pipe->pipeEventName);
+				setString(device,pRequest,(char*)temp,(int)outBufSize);
+			}
+			else {
+				SectionLocker lock(device->m_RequestLock);
+				pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+			}
+			return;
+		case SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA00c):
+			// custom attribute; TCP port
+			if (rpcType==1) {	
+				TcpIpReader *tcpIp=(TcpIpReader *)this;
+				OutputDebugString(L"[BixVReader][GATT]PORT");
+				setInt(device,pRequest,tcpIp->port);
+			}
+			else {
+				SectionLocker lock(device->m_RequestLock);
+				pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+			}
+			return;
+		case SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA00d):
+			// custom attribute; TCP event port
+			if (rpcType==1) {	
+				TcpIpReader *tcpIp=(TcpIpReader *)this;
+				OutputDebugString(L"[BixVReader][GATT]EVENT_PORT");
+				setInt(device,pRequest,tcpIp->eventPort);
+			}
+			else {
+				SectionLocker lock(device->m_RequestLock);
+				pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+			}
+			return;
+		case SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA00e):
+			// custom attribute; TCP base port
+			if (rpcType==1) {	
+				TcpIpReader *tcpIp=(TcpIpReader *)this;
+				OutputDebugString(L"[BixVReader][GATT]BASE_PORT");
+				setInt(device,pRequest,tcpIp->portBase);
+				tcpIp;
+			}
+			else {
+				SectionLocker lock(device->m_RequestLock);
+				pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+			}
+			return;
+		case SCARD_ATTR_CHARACTERISTICS:
+			// 0x00000000 No special characteristics
+			OutputDebugString(L"[BixVReader][GATT]SCARD_ATTR_CHARACTERISTICS");
+			setInt(device,pRequest,0);
+			return;
+		case SCARD_ATTR_VENDOR_NAME:
+			OutputDebugString(L"[BixVReader][GATT]SCARD_ATTR_VENDOR_NAME");
+			setString(device,pRequest,vendorName,(int)outBufSize);
+			return;
+		case SCARD_ATTR_VENDOR_IFD_TYPE:
+			OutputDebugString(L"[BixVReader][GATT]SCARD_ATTR_VENDOR_IFD_TYPE");
+			setString(device,pRequest,vendorIfdType,(int)outBufSize);
+			return;
+		case SCARD_ATTR_DEVICE_UNIT:
+			OutputDebugString(L"[BixVReader][GATT]SCARD_ATTR_DEVICE_UNIT");
+			setInt(device,pRequest,deviceUnit);
+			return;
+		case SCARD_ATTR_ATR_STRING:
+			OutputDebugString(L"[BixVReader][GATT]SCARD_ATTR_ATR_STRING");
+			BYTE ATR[100];
+			DWORD ATRsize;
+			if (!QueryATR(ATR,&ATRsize))
+			{
+				SectionLocker lock(device->m_RequestLock);
+				pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);					
+				return;
+			}
+			setBuffer(device,pRequest,ATR,ATRsize);
+			return;
+		case SCARD_ATTR_CURRENT_PROTOCOL_TYPE:
+			OutputDebugString(L"[BixVReader][GATT]SCARD_ATTR_CURRENT_PROTOCOL_TYPE");
+			setInt(device,pRequest,protocol); // T=0 or T=1
+			return;
+		default: {
+			swprintf(log,L"[BixVReader][GATT]ERROR_NOT_SUPPORTED:%08X",code);
+			OutputDebugString(log);
+			SectionLocker lock(device->m_RequestLock);
+	        pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+		}
+	}
+}
+
+bool Reader::CheckATR() {
+	return false;
+}
+
+bool Reader::QueryTransmit(BYTE *APDU,int APDUlen,BYTE *Resp,int *Resplen) {
+	APDU;
+	APDUlen;
+	Resp;
+	Resplen;
+	return false;
+}
+
+bool Reader::QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset) {
+	ATR;
+	ATRsize;
+	reset;
+	return false;
+}
+
+bool Reader::initProtocols() {
+	// ask ATR to determine available protocols
+	BYTE ATR[100];
+	DWORD ATRsize=100;
+	availableProtocol=0;
+	if (QueryATR(ATR,&ATRsize,true))
+	{
+		availableProtocol=0;
+		int iNumHistBytes=0;
+		int iTotHistBytes=0;
+		int y=0;
+		int block=1;
+		bool isHist=false;
+		char let='A';
+		for (unsigned int i=0;i<ATRsize && ! isHist;i++) {
+			if (i==0) {
+				// we are in TS
+			}
+			else if (i==1) {
+				// we are in T0; read number of historical bytes
+				let='A';
+				y=ATR[i] >> 4;			
+				iTotHistBytes=ATR[i] & 0xF;
+			}
+			else {
+				while ((y & 1)==0) {
+					let++;
+					y>>=1;
+					if (y==0) {
+						isHist=true;
+						iNumHistBytes=1;
+						i--;
+						goto end;
+					}
+				}
+				// we are in T(let)(block)
+				y=y & 0xE;
+				if (let=='D') {
+					// check available protocol(s)
+					int protocol=(ATR[i] & 0x0f);
+					availableProtocol|=1 << protocol;
+					// prepare for next block
+					let='A';
+					y=ATR[i] >> 4;
+					block++;
+				}
+			}
+end:
+			;
+		}
+		//support at least T=0
+		if (availableProtocol==0)
+			availableProtocol=1;
+		return true;
+	}
+	return false;
+}
+
+DWORD Reader::startServer() {
+	return 0;
+}
+
+void Reader::shutdown() {
+}

virtualsmartcard/win32/BixVReader/Reader.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <Winsock2.h>
+
+class CMyDevice;
+
+class Reader {
+public:
+	CMyDevice *device;
+	CComPtr<IWDFIoRequest> waitRemoveIpr;
+	CComPtr<IWDFIoRequest> waitInsertIpr;
+	inbuf;
+	outbuf;
+
+	HANDLE serverThread;
+
+	char vendorName[300];
+	char vendorIfdType[300];
+	int deviceUnit;
+	int powered;
+	int instance;
+	int rpcType;
+	int state;
+	DWORD protocol; // T0 or T1 - protocol in use
+	DWORD availableProtocol; // T0, T1 or Both - protocols available
+	
+	void IoSmartCardGetAttribute(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
+	void IoSmartCardIsPresent(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
+	void IoSmartCardGetState(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
+	void IoSmartCardIsAbsent(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
+	void IoSmartCardPower(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
+	void IoSmartCardSetAttribute(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
+	void IoSmartCardSetProtocol(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
+	void IoSmartCardTransmit(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
+
+	bool initProtocols();
+	virtual bool QueryTransmit(BYTE *APDU,int APDUlen,BYTE *Resp,int *Resplen);
+	virtual bool QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset=false);
+	virtual bool CheckATR();
+	virtual DWORD startServer();
+	virtual void shutdown();
+	virtual void init(wchar_t *section);
+
+};
+
+class PipeReader : public Reader {
+public:
+	wchar_t pipeName[300];
+	wchar_t pipeEventName[300];
+	HANDLE pipe;
+	HANDLE eventpipe;
+
+	PipeReader();
+	bool QueryTransmit(BYTE *APDU,int APDUlen,BYTE *Resp,int *Resplen);
+	bool QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset=false);
+	bool CheckATR();
+	DWORD startServer();
+	void shutdown();
+	void init(wchar_t *section);
+	
+	CRITICAL_SECTION eventSection;
+	CRITICAL_SECTION dataSection;
+};
+
+class TcpIpReader : public Reader {
+public:
+	static int portBase;
+	int port;
+	int eventPort;
+	SOCKET socket;
+	SOCKET AcceptSocket;
+	SOCKET eventsocket;
+	bool breakSocket;
+
+	TcpIpReader();
+	bool QueryTransmit(BYTE *APDU,int APDUlen,BYTE *Resp,int *Resplen);
+	bool QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset=false);
+	bool CheckATR();
+	DWORD startServer();
+	void shutdown();
+	void init(wchar_t *section);
+
+	CRITICAL_SECTION eventSection;
+	CRITICAL_SECTION dataSection;
+};
+
+class VpcdReader : public Reader {
+public:
+	static int portBase;
+	short port;
+	void *ctx;
+	bool breakSocket;
+	bool cardPresent;
+
+	VpcdReader();
+	bool QueryTransmit(BYTE *APDU,int APDUlen,BYTE *Resp,int *Resplen);
+	bool QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset=false);
+	bool CheckATR();
+	DWORD startServer();
+	void shutdown();
+	void init(wchar_t *section);
+	void signalRemoval(void);
+	void signalInsertion(void);
+};

virtualsmartcard/win32/BixVReader/TcpIpReader.cpp

@@ -0,0 +1,306 @@
+#include "internal.h"
+#include "VirtualSCReader.h"
+#include "reader.h"
+#include "device.h"
+#include <winscard.h>
+#include "memory.h"
+#include <Sddl.h>
+#include "sectionLocker.h"
+
+
+int TcpIpReader::portBase;
+
+TcpIpReader::TcpIpReader() {
+	rpcType=1;
+	state=SCARD_ABSENT;
+}
+void TcpIpReader::init(wchar_t *section) {
+	portBase=GetPrivateProfileInt(L"Driver",L"RPC_PORT_BASE",29500,L"BixVReader.ini");	
+
+	port=GetPrivateProfileInt(section,L"TCP_PORT",portBase+(instance<<1),L"BixVReader.ini");
+	eventPort=GetPrivateProfileInt(section,L"TCP_EVENT_PORT",portBase+1+(instance<<1),L"BixVReader.ini");
+
+	InitializeCriticalSection(&eventSection);
+	InitializeCriticalSection(&dataSection);
+}
+
+bool TcpIpReader::CheckATR() {
+	//SectionLocker lock(dataSection);
+	if (AcceptSocket==NULL)
+		return false;
+	int read=0;
+	DWORD command=1;
+	if ((read=send(AcceptSocket,(char*)&command,sizeof(DWORD),NULL))<=0) {
+		return false;
+	}
+	DWORD size=0;
+	if ((read=recv(AcceptSocket,(char*)&size,sizeof(DWORD),MSG_WAITALL))<=0) {
+		return false;
+	}
+	if (size==0)
+		return false;
+	BYTE ATR[100];
+	if ((read=recv(AcceptSocket,(char*)ATR,size,MSG_WAITALL))<=0) {
+		return false;
+	}
+	return true;
+}
+bool TcpIpReader::QueryTransmit(BYTE *APDU,int APDUlen,BYTE *Resp,int *Resplen) {
+	//SectionLocker lock(dataSection);
+	if (AcceptSocket==NULL)
+		return false;
+	DWORD command=2;
+	DWORD read=0;
+	if ((read=send(AcceptSocket,(char*)&command,sizeof(DWORD),NULL))<=0) {
+		::shutdown(AcceptSocket,SD_BOTH);
+		AcceptSocket=NULL;
+		return false;
+	}
+	DWORD dwAPDUlen=(DWORD)APDUlen;
+	if ((read=send(AcceptSocket,(char*)&dwAPDUlen,sizeof(DWORD),NULL))<=0) {
+		::shutdown(AcceptSocket,SD_BOTH);
+		AcceptSocket=NULL;
+		return false;
+	}
+	if ((read=send(AcceptSocket,(char*)APDU,APDUlen,NULL))<=0) {
+		::shutdown(AcceptSocket,SD_BOTH);
+		AcceptSocket=NULL;
+		return false;
+	}
+	DWORD dwRespLen=0;
+	if ((read=recv(AcceptSocket,(char*)&dwRespLen,sizeof(DWORD),MSG_WAITALL))<=0) {
+		::shutdown(AcceptSocket,SD_BOTH);
+		AcceptSocket=NULL;
+		return false;
+	}
+	if ((read=recv(AcceptSocket,(char*)Resp,dwRespLen,MSG_WAITALL))<=0) {
+		::shutdown(AcceptSocket,SD_BOTH);
+		AcceptSocket=NULL;
+		return false;
+	}
+	(*Resplen)=(int)dwRespLen;
+	return true;
+}
+
+bool TcpIpReader::QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset) {
+	//SectionLocker lock(dataSection);
+	if (AcceptSocket==NULL)
+		return false;
+	int read=0;
+	DWORD command=reset ? 0 : 1;
+	if ((read=send(AcceptSocket,(char*)&command,sizeof(DWORD),NULL))<=0) {
+		::shutdown(AcceptSocket,SD_BOTH);
+		AcceptSocket=NULL;
+		return false;
+	}
+	DWORD size=0;
+	if ((read=recv(AcceptSocket,(char*)&size,sizeof(DWORD),MSG_WAITALL))<=0) {
+		::shutdown(AcceptSocket,SD_BOTH);
+		AcceptSocket=NULL;
+		return false;
+	}
+	if (size==0)
+		return false;
+	if ((read=recv(AcceptSocket,(char*)ATR,size,MSG_WAITALL))<=0) {
+		::shutdown(AcceptSocket,SD_BOTH);
+		AcceptSocket=NULL;
+		return false;
+	}
+	(*ATRsize)=size;
+	return true;
+}
+
+DWORD TcpIpReader::startServer() {
+	breakSocket=false;
+
+	wchar_t log[300];
+	while (true) {
+		//__try {
+			fd_set readfds;
+
+			FD_ZERO(&readfds);
+			// Set server socket to set
+			FD_SET(socket, &readfds);
+
+			// Timeout parameter
+			timeval tv = { 0 };
+			tv.tv_sec = 5;
+
+			while(true) {
+				if (breakSocket)
+					return 0;
+				FD_SET(socket, &readfds);
+				int ret = select(0, &readfds, NULL, NULL, &tv);
+				if (ret > 0)
+					break;
+				if (ret<0) {
+					wchar_t log[100];
+					DWORD err=WSAGetLastError();
+					swprintf(log,L"[BixVReader]wsa err:%x",err);
+					OutputDebugString(log);
+					if (err==0x2736) {
+						socket=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,NULL,0,0);
+						sockaddr_in Service;
+						Service.sin_family = AF_INET;
+						Service.sin_addr.s_addr = inet_addr("127.0.0.1");
+						Service.sin_port = htons((u_short)(port));
+						bind(socket, (SOCKADDR *) &Service, sizeof (Service));
+						listen(socket, 1);
+
+						FD_ZERO(&readfds);
+						// Set server socket to set
+						FD_SET(socket, &readfds);
+					}
+				}
+			}
+
+			SOCKET AcceptEventSocket;
+
+			AcceptSocket = accept(socket, NULL, NULL);
+			closesocket(socket);
+			socket=NULL;
+			if (AcceptSocket == INVALID_SOCKET)
+				return 0;
+
+			swprintf(log,L"[BixVReader]Socket connected:%i",AcceptSocket);
+			OutputDebugString(log);
+
+			FD_ZERO(&readfds);
+			// Set server socket to set
+			FD_SET(eventsocket, &readfds);
+
+			while(true) {
+				if (breakSocket)
+					return 0;
+				FD_SET(eventsocket, &readfds);
+				int ret = select(0, &readfds, NULL, NULL, &tv);
+				if (ret > 0)
+					break;
+				if (ret<0) {
+					DWORD err=WSAGetLastError();
+					swprintf(log,L"[BixVReader]wsa err:%x",err);
+					OutputDebugString(log);
+					if (err==0x2736) {
+						eventsocket=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,NULL,0,0);
+						sockaddr_in eventService;
+						eventService.sin_family = AF_INET;
+						eventService.sin_addr.s_addr = inet_addr("127.0.0.1");
+						eventService.sin_port = htons((u_short)(eventPort));
+						bind(eventsocket, (SOCKADDR *) &eventService, sizeof (eventService));
+						listen(eventsocket, 1);
+
+						FD_ZERO(&readfds);
+						// Set server socket to set
+						FD_SET(eventsocket, &readfds);
+					}
+				}
+			}
+
+			AcceptEventSocket = accept(eventsocket, NULL, NULL);
+			closesocket(eventsocket);
+			eventsocket=NULL;
+			if (AcceptEventSocket == INVALID_SOCKET)
+				return 0;
+
+			swprintf(log,L"[BixVReader]Event Socket connected:%i",AcceptEventSocket);
+			OutputDebugString(log);
+
+			if (waitInsertIpr!=NULL) {
+				// if I'm waiting for card insertion, verify if there's a card present
+				if (initProtocols()) {
+					SectionLocker lock(device->m_RequestLock);
+					if (waitInsertIpr->UnmarkCancelable()==S_OK)
+						waitInsertIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+					waitInsertIpr=NULL;
+					state=SCARD_SWALLOWED;
+				}
+			}
+			
+			while (true) {
+				// wait for a command
+				DWORD command=0;
+				int read=0;
+				if ((read=recv(AcceptEventSocket,(char*)&command,sizeof(DWORD),MSG_WAITALL))<=0) {
+					state=SCARD_ABSENT;
+					OutputDebugString(L"[BixVReader]Socket error");
+					powered=0;
+					::shutdown(AcceptSocket,SD_BOTH);
+					::shutdown(AcceptEventSocket,SD_BOTH);
+					if (waitRemoveIpr!=NULL) {// card inserted
+						OutputDebugString(L"[BixVReader]complete Wait Remove");
+						SectionLocker lock(device->m_RequestLock);
+						if (waitRemoveIpr->UnmarkCancelable()==S_OK) {
+							OutputDebugString(L"[BixVReader]Wait Remove Unmarked");
+							waitRemoveIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+							OutputDebugString(L"[BixVReader]Wait Remove Completed");
+						}
+						waitRemoveIpr=NULL;
+					}
+					if (waitInsertIpr!=NULL) {// card removed
+						OutputDebugString(L"[BixVReader]cancel Wait Remove");
+						SectionLocker lock(device->m_RequestLock);
+						if (waitInsertIpr->UnmarkCancelable()==S_OK) {
+							OutputDebugString(L"[BixVReader]Wait Insert Unmarked");
+							waitInsertIpr->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_CANCELLED), 0);
+							OutputDebugString(L"[BixVReader]Wait Insert Cancelled");
+						}
+						waitInsertIpr=NULL;
+					}
+					break;
+				}
+				OutputDebugString(L"[BixVReader]Socket data");
+				if (command==0)
+					powered=0;
+				if (command==0 && waitRemoveIpr!=NULL) {// card removed
+					SectionLocker lock(device->m_RequestLock);
+					state=SCARD_ABSENT;
+					if (waitRemoveIpr->UnmarkCancelable()==S_OK)						
+						waitRemoveIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+					waitRemoveIpr=NULL;
+				}
+				else if (command==1 && waitInsertIpr!=NULL) {// card inserted
+					SectionLocker lock(device->m_RequestLock);
+					state=SCARD_SWALLOWED;
+					initProtocols();					
+					if (waitInsertIpr->UnmarkCancelable()==S_OK)
+						waitInsertIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+					waitInsertIpr=NULL;
+				}
+			}
+		//}
+		//__except(EXCEPTION_EXECUTE_HANDLER) {
+		//	wchar_t log[300];
+		//	DWORD err=GetExceptionCode();
+		//	swprintf(log,L"Exception:%08X",err);
+		//	OutputDebugString(log);
+		//}
+	}
+	OutputDebugString(L"[BixVReader]Socket quit!!!");
+	return 0;
+}
+
+void TcpIpReader::shutdown() {
+	state=SCARD_ABSENT;
+	breakSocket=true;
+	{
+		//SectionLocker lock(dataSection);
+		closesocket(eventsocket);
+		closesocket(socket);
+	}
+	WaitForSingleObject(serverThread,10000);
+	serverThread=NULL;
+	eventsocket=NULL;
+	socket=NULL;
+	if (waitRemoveIpr!=NULL) {
+		SectionLocker lock(device->m_RequestLock);
+		if (waitRemoveIpr->UnmarkCancelable()==S_OK)
+			waitRemoveIpr->Complete(HRESULT_FROM_WIN32(ERROR_CANCELLED));
+		waitRemoveIpr=NULL;
+	}
+	if (waitInsertIpr!=NULL) {
+		SectionLocker lock(device->m_RequestLock);
+		if (waitInsertIpr->UnmarkCancelable()==S_OK)
+			waitInsertIpr->Complete(HRESULT_FROM_WIN32(ERROR_CANCELLED));
+		waitInsertIpr=NULL;
+	}
+}

virtualsmartcard/win32/BixVReader/VpcdReader.cpp

@@ -0,0 +1,147 @@
+#include "internal.h"
+#include "VirtualSCReader.h"
+#include "reader.h"
+#include "device.h"
+#include <winscard.h>
+#include "memory.h"
+#include <Sddl.h>
+#include "sectionLocker.h"
+#include "../../src/vpcd/vpcd.h"
+
+
+int VpcdReader::portBase;
+
+VpcdReader::VpcdReader() {
+	rpcType=2;
+	state=SCARD_ABSENT;
+	cardPresent = false;
+}
+void VpcdReader::init(wchar_t *section) {
+	portBase=GetPrivateProfileInt(L"Driver",L"RPC_PORT_BASE",VPCDPORT,L"BixVReader.ini");	
+
+	port=(short) GetPrivateProfileInt(section,L"TCP_PORT",portBase+instance,L"BixVReader.ini");
+}
+
+bool VpcdReader::CheckATR() {
+	bool r = false;
+	struct vicc_ctx *vicc_ctx = (struct vicc_ctx *) ctx;
+
+	if (vicc_present((struct vicc_ctx *) ctx) == 1) {
+		signalInsertion();
+		r = true;
+	} else {
+		signalRemoval();
+	}
+
+	return r;
+}
+bool VpcdReader::QueryTransmit(BYTE *APDU,int APDUlen,BYTE *Resp,int *Resplen) {
+	unsigned char *rapdu = NULL;
+	ssize_t rapdu_len;
+	bool r = false;
+
+	if (APDU && APDUlen && Resp && Resplen) {
+		rapdu_len = vicc_transmit((struct vicc_ctx *) ctx, APDUlen, APDU, &rapdu);
+		if (rapdu_len > 0) {
+			memcpy(Resp, rapdu, rapdu_len);
+			*Resplen = rapdu_len;
+			free(rapdu);
+			r = true;
+		} else {
+			signalRemoval();
+		}
+	}
+
+	return r;
+}
+
+bool VpcdReader::QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset) {
+	unsigned char *atr = NULL;
+	int atr_len;
+	bool r = false;
+
+	if (ATR && ATRsize) {
+		atr_len = vicc_getatr((struct vicc_ctx *) ctx, &atr);
+		if (atr_len > 0) {
+			/* TODO do length checking on length of ATR when ATRsize is
+			 * correctly initialized by Reader.cpp */
+			memcpy(ATR, atr, atr_len);
+			*ATRsize = atr_len;
+			free(atr);
+			r = true;
+			if (reset)
+				vicc_reset((struct vicc_ctx *) ctx);
+		} else {
+			signalRemoval();
+		}
+	}
+
+	return r;
+}
+
+DWORD VpcdReader::startServer() {
+	breakSocket = false;
+	ctx = vicc_init(NULL, port);
+	while (!breakSocket) {
+		CheckATR();
+		Sleep(1000);
+	}
+	return 0;
+}
+
+void VpcdReader::shutdown() {
+	breakSocket=true;
+	WaitForSingleObject(serverThread,10000);
+	serverThread=NULL;
+	vicc_exit((struct vicc_ctx *) ctx);
+	state=SCARD_ABSENT;
+	ctx = NULL;
+	if (waitRemoveIpr!=NULL) {
+		SectionLocker lock(device->m_RequestLock);
+		if (waitRemoveIpr->UnmarkCancelable()==S_OK)
+			waitRemoveIpr->Complete(HRESULT_FROM_WIN32(ERROR_CANCELLED));
+		waitRemoveIpr=NULL;
+	}
+	if (waitInsertIpr!=NULL) {
+		SectionLocker lock(device->m_RequestLock);
+		if (waitInsertIpr->UnmarkCancelable()==S_OK)
+			waitInsertIpr->Complete(HRESULT_FROM_WIN32(ERROR_CANCELLED));
+		waitInsertIpr=NULL;
+	}
+}
+
+void VpcdReader::signalRemoval(void) {
+	if (cardPresent) {
+		cardPresent = false;
+		state=SCARD_ABSENT;
+		if (waitRemoveIpr!=NULL) {
+			SectionLocker lock(device->m_RequestLock);
+			if (waitRemoveIpr->UnmarkCancelable()==S_OK) {
+				waitRemoveIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+			}
+			waitRemoveIpr=NULL;
+		}
+		if (waitInsertIpr!=NULL) {
+			SectionLocker lock(device->m_RequestLock);
+			if (waitInsertIpr->UnmarkCancelable()==S_OK) {
+				waitInsertIpr->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_CANCELLED), 0);
+			}
+			waitInsertIpr=NULL;
+		}
+	}
+}
+
+void VpcdReader::signalInsertion(void) {
+	if (!cardPresent) {
+		cardPresent = true;
+		if (waitInsertIpr!=NULL) {
+			if (initProtocols()) {
+				SectionLocker lock(device->m_RequestLock);
+				if (waitInsertIpr->UnmarkCancelable()==S_OK)
+					waitInsertIpr->CompleteWithInformation(STATUS_SUCCESS, 0);
+				waitInsertIpr=NULL;
+				state=SCARD_SWALLOWED;
+			}
+		}
+	}
+}

virtualsmartcard/win32/BixVReader/Win7/BixVReader.inx

@@ -14,7 +14,7 @@ DriverVer=11/22/2010,6.1.7600.16385
 %MSFTUMDF%=Microsoft,NT$ARCH$
 
 [Microsoft.NT$ARCH$]
-%ReaderDeviceName%=VReader_Install,root\vpcd
+%ReaderDeviceName%=VReader_Install,root\BixVirtualReader
 
 ; =================== Virtual Reader Device ==================================
 
@@ -31,15 +31,15 @@ AddReg=CoInstallers_AddReg
 CopyFiles=CoInstallers_CopyFiles
 
 [VReader_Install.NT.Wdf]
-UmdfService=vpcd,UMDFVReader_Install
+UmdfService=BixVReader,UMDFVReader_Install
-UmdfServiceOrder=vpcd
+UmdfServiceOrder=BixVReader
 UmdfKernelModeClientPolicy=AllowKernelModeClients
 
 ; =================== UMDF Service Install section ===================
 
 [UMDFVReader_Install]
 UmdfLibraryVersion=$UMDFVERSION$
-ServiceBinary=%12%\UMDF\vpcd.dll
+ServiceBinary=%12%\UMDF\BixVReader.dll
 DriverCLSID={d4112073-d09b-458f-a5aa-35ef21eef5de}
 
 [WUDFRD_ServiceInstall]
@@ -51,7 +51,7 @@ ServiceBinary = %12%\WUDFRd.sys
 LoadOrderGroup = Base
 
 [SourceDisksFiles]
-vpcd.dll=1
+BixVReader.dll=1
 WudfUpdate_01009.dll=1
 
 [SourceDisksNames]
@@ -68,13 +68,13 @@ UMDriverCopy=12,UMDF ; copy to driversMdf
 CoInstallers_CopyFiles=11
 
 [UMDriverCopy]
-vpcd.dll
+BixVReader.dll
 
 ; =================== Generic ==================================
 
 [Strings]
-MSFTUMDF="Virtual Smart Card Architecture"
+MSFTUMDF="Fabio Ottavi - developer"
-MediaDescription="Virtual PCD Media"
+MediaDescription="Bix Virtual Card Reader disk 1"
-WudfRdDisplayName="UMDF Virtual Smart Card Reader for ScardVisual"
+WudfRdDisplayName="Bix UMDF Virtual Smart Card Reader for ScardVisual"
-ReaderDeviceName="Virtual PCD"
+ReaderDeviceName="Bix Virtual Smart Card Reader"
 

virtualsmartcard/win32/BixVReader/Win7/makefile

@@ -0,0 +1,7 @@
+#
+# Build using BUILD.EXE (Do not edit this section of this file, edit SOURCES)
+#
+MINIMUM_NT_TARGET_VERSION=0x501
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+

virtualsmartcard/win32/BixVReader/Win7/sources

@@ -12,12 +12,14 @@ KMDF_VERSION_MAJOR=1
 KMDF_VERSION_MINOR=9
 
 
-TARGETNAME=vpcd
+TARGETNAME=BixVReader
 TARGETTYPE=DYNLINK
 
 USE_ATL     = 1
+USE_STL		= 1
 ATL_VER     = 71
 USE_MSVCRT  = 1
+USE_NATIVE_EH	= 1
 
 C_DEFINES = $(C_DEFINES)  /D_UNICODE /DUNICODE
 
@@ -26,16 +28,22 @@ _NT_TARGET_VERSION=$(_NT_TARGET_VERSION_WIN7)
 NTDDI_VERSION=$(LATEST_NTDDI_VERSION)
 
 DLLENTRY=_DllMainCRTStartup
-DLLDEF=exports.def
+DLLDEF=..\exports.def
 
 SOURCES=\
-    vpcd.rc                     \
+    ..\BixVReader.rc                 \
-    driver.cpp                  \
+    ..\driver.cpp                  \
-    device.cpp					\
+    ..\device.cpp					\
-    queue.cpp					\
+    ..\reader.cpp					\
-    memory.cpp					\
+    ..\pipereader.cpp					\
-    DllMain.cpp					\
+    ..\tcpipreader.cpp					\
-    VirtualSCReader.idl
+    ..\..\..\src\vpcd\vpcd.c					\
+    ..\vpcdreader.cpp					\
+    ..\queue.cpp					\
+    ..\memory.cpp					\
+	..\sectionLocker.cpp					\
+    ..\DllMain.cpp					\
+    ..\VirtualSCReader.idl
 
 INCLUDES= $(INCLUDES);                  \
           $(SDK_INC_PATH);              \
@@ -53,9 +61,9 @@ TARGETLIBS=\
         $(SDK_LIB_PATH)\user32.lib      \
         $(SDK_LIB_PATH)\advapi32.lib    \
         $(SDK_LIB_PATH)\shlwapi.lib     \
-        $(SDK_LIB_PATH)\ws2_32.lib
+        $(SDK_LIB_PATH)\Ws2_32.lib      \
 
-NTTARGETFILE1=$(OBJ_PATH)\$(O)\vpcd.inf
+NTTARGETFILE1=$(OBJ_PATH)\$(O)\BixVReader.inf
 
 
 #

virtualsmartcard/win32/BixVReader/WinXP/BixVReader.inx

@@ -0,0 +1,80 @@
+;
+; VirtualCardReader.inf
+;
+
+[Version]
+Signature="$Windows NT$"
+Class=SmartCardReader
+ClassGuid={50dd5230-ba8a-11d1-bf5d-0000f805f530}
+Provider=%MSFTUMDF%
+CatalogFile=WUDF.cat
+DriverVer=11/22/2010,6.1.7600.16385
+
+[Manufacturer]
+%MSFTUMDF%=Microsoft,NT$ARCH$
+
+[Microsoft.NT$ARCH$]
+%ReaderDeviceName%=VReader_Install,root\BixVirtualReader
+
+; =================== Virtual Reader Device ==================================
+
+[VReader_Install.NT]
+CopyFiles=UMDriverCopy
+
+[VReader_Install.NT.hw]
+
+[VReader_Install.NT.Services]
+AddService=WUDFRd,0x000001fa,WUDFRD_ServiceInstall
+
+[VReader_Install.NT.CoInstallers]
+AddReg=CoInstallers_AddReg
+CopyFiles=CoInstallers_CopyFiles
+
+[VReader_Install.NT.Wdf]
+UmdfService=BixVReader,UMDFVReader_Install
+UmdfServiceOrder=BixVReader
+UmdfKernelModeClientPolicy=AllowKernelModeClients
+
+; =================== UMDF Service Install section ===================
+
+[UMDFVReader_Install]
+UmdfLibraryVersion=$UMDFVERSION$
+ServiceBinary=%12%\UMDF\BixVReader.dll
+DriverCLSID={d4112073-d09b-458f-a5aa-35ef21eef5de}
+
+[WUDFRD_ServiceInstall]
+DisplayName = %WudfRdDisplayName%
+ServiceType = 1
+StartType = 3
+ErrorControl = 1
+ServiceBinary = %12%\WUDFRd.sys
+LoadOrderGroup = Base
+
+[SourceDisksFiles]
+BixVReader.dll=1
+WudfUpdate_01009.dll=1
+
+[SourceDisksNames]
+1 = %MediaDescription%
+
+[CoInstallers_CopyFiles]
+WudfUpdate_$UMDFCOINSTALLERVERSION$.dll
+
+[CoInstallers_AddReg]
+HKR,,CoInstallers32,0x00010000,"WUDFUpdate_$UMDFCOINSTALLERVERSION$.dll"
+
+[DestinationDirs]
+UMDriverCopy=12,UMDF ; copy to driversMdf
+CoInstallers_CopyFiles=11
+
+[UMDriverCopy]
+BixVReader.dll
+
+; =================== Generic ==================================
+
+[Strings]
+MSFTUMDF="Fabio Ottavi - developer"
+MediaDescription="Bix Virtual Card Reader disk 1"
+WudfRdDisplayName="Bix UMDF Virtual Smart Card Reader for ScardVisual"
+ReaderDeviceName="Bix Virtual Smart Card Reader"
+

virtualsmartcard/win32/BixVReader/WinXP/makefile

@@ -0,0 +1,7 @@
+#
+# Build using BUILD.EXE (Do not edit this section of this file, edit SOURCES)
+#
+MINIMUM_NT_TARGET_VERSION=0x501
+
+!INCLUDE $(NTMAKEENV)\makefile.def
+

virtualsmartcard/win32/BixVReader/WinXP/makefile.inc

@@ -0,0 +1,8 @@
+.SUFFIXES: .inx
+
+STAMP=stampinf
+
+.inx{$(OBJ_PATH)\$(O)}.inf:
+    copy $(@B).inx $@
+    $(STAMP) -f $@ -a $(_BUILDARCH) -k $(KMDF_VERSION_MAJOR).$(KMDF_VERSION_MINOR) -u $(UMDF_VERSION_MAJOR).$(UMDF_VERSION_MINOR).0
+

virtualsmartcard/win32/BixVReader/WinXP/sources

@@ -0,0 +1,79 @@
+#
+# UMDF_VERSION_MAJOR controls the headers that the driver uses.
+# UMDF_VERSION_MAJOR + UMDF_VERSION_MINOR control which version 
+# of UMDF the driver is bound to in the INF and which 
+# update coinstaller it requires (through stampinf). 
+#
+
+UMDF_VERSION_MAJOR=1
+UMDF_VERSION_MINOR=9
+
+KMDF_VERSION_MAJOR=1
+KMDF_VERSION_MINOR=9
+
+
+TARGETNAME=BixVReader
+TARGETTYPE=DYNLINK
+
+USE_ATL     = 1
+USE_STL		= 1
+ATL_VER     = 71
+USE_MSVCRT  = 1
+USE_NATIVE_EH	= 1
+
+C_DEFINES = $(C_DEFINES)  /D_UNICODE /DUNICODE
+
+WIN32_WINNT_VERSION=$(LATEST_WIN32_WINNT_VERSION)
+_NT_TARGET_VERSION=$(_NT_TARGET_VERSION_WINXP)
+NTDDI_VERSION=$(LATEST_NTDDI_VERSION)
+
+DLLENTRY=_DllMainCRTStartup
+DLLDEF=..\exports.def
+
+SOURCES=\
+    ..\BixVReader.rc                 \
+    ..\driver.cpp                  \
+    ..\device.cpp					\
+    ..\reader.cpp					\
+    ..\pipereader.cpp					\
+    ..\tcpipreader.cpp					\
+    ..\..\..\src\vpcd\vpcd.c					\
+    ..\vpcdreader.cpp					\
+    ..\queue.cpp					\
+    ..\memory.cpp					\
+	..\sectionLocker.cpp					\
+    ..\DllMain.cpp					\
+    ..\VirtualSCReader.idl
+
+INCLUDES= $(INCLUDES);                  \
+          $(SDK_INC_PATH);              \
+          $(DDK_INC_PATH);              \
+          $(UMDF_INC_PATH)\10; 
+          
+MSC_WARNING_LEVEL=/W4 /WX
+
+TARGETLIBS=\
+        $(SDK_LIB_PATH)\strsafe.lib     \
+        $(SDK_LIB_PATH)\kernel32.lib    \
+        $(SDK_LIB_PATH)\ole32.lib       \
+        $(SDK_LIB_PATH)\oleaut32.lib    \
+        $(SDK_LIB_PATH)\uuid.lib        \
+        $(SDK_LIB_PATH)\user32.lib      \
+        $(SDK_LIB_PATH)\advapi32.lib    \
+        $(SDK_LIB_PATH)\shlwapi.lib     \
+        $(SDK_LIB_PATH)\Ws2_32.lib      \
+
+NTTARGETFILE1=$(OBJ_PATH)\$(O)\BixVReader.inf
+
+
+#
+# This sets up the WPP preprocessor and tells it to scan internal.h to find
+# the trace function definition that's in there.
+#
+
+#RUN_WPP= $(SOURCES) -dll -scan:internal.h
+
+
+TARGET_DESTINATION=wudf
+
+

virtualsmartcard/win32/BixVReader/device.cpp

@@ -0,0 +1,331 @@
+#include "internal.h"
+#include "VirtualSCReader.h"
+#include "queue.h"
+#include "device.h"
+#include "driver.h"
+#include <stdio.h>
+#include <winscard.h>
+#include "memory.h"
+#include "SectionLocker.h"
+
+HRESULT
+CMyDevice::CreateInstance(
+                          __in IWDFDriver *FxDriver,
+                          __in IWDFDeviceInitialize * FxDeviceInit
+                          )
+
+                          /*++
+
+                          Routine Description:
+
+                          This method creates and initializs an instance of the virtual smart card reader driver's 
+                          device callback object.
+
+                          Arguments:
+
+                          FxDeviceInit - the settings for the device.
+
+                          Device - a location to store the referenced pointer to the device object.
+
+                          Return Value:
+
+                          Status
+
+                          --*/
+{
+    inFunc
+        SectionLogger a(__FUNCTION__);
+    CComObject<CMyDevice>* device = NULL;
+    HRESULT hr;
+
+    OutputDebugString(L"[BixVReader]CreateInstance");    //
+    // Allocate a new instance of the device class.
+    //
+    hr = CComObject<CMyDevice>::CreateInstance(&device);
+
+    if (device==NULL)
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    //
+    // Initialize the instance.
+    //
+    device->AddRef();
+
+    OutputDebugString(L"[BixVReader]SetLockingConstraint");    //
+    FxDeviceInit->SetLockingConstraint(WdfDeviceLevel);
+
+    CComPtr<IUnknown> spCallback;
+    OutputDebugString(L"[BixVReader]QueryInterface");    //
+    hr = device->QueryInterface(IID_IUnknown, (void**)&spCallback);
+
+    CComPtr<IWDFDevice> spIWDFDevice;
+    if (SUCCEEDED(hr))
+    {
+        OutputDebugString(L"[BixVReader]CreateDevice");    //
+        hr = FxDriver->CreateDevice(FxDeviceInit, spCallback, &spIWDFDevice);
+    }
+
+    device->numInstances=GetPrivateProfileInt(L"Driver",L"NumReaders",1,L"BixVReader.ini");	
+
+    WSADATA wsaData;
+    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
+    if (iResult != NO_ERROR) {
+        OutputDebugString(L"[BixVReader]Error at WSAStartup()\n");
+    }
+
+    for (int i=0;i<device->numInstances;i++) {
+        OutputDebugString(L"[BixVReader]CreateDeviceInterface");    //
+        wchar_t name[10];
+        swprintf(name,L"DEV%i",i);
+
+        if (spIWDFDevice->CreateDeviceInterface(&SmartCardReaderGuid,name)!=0)	
+            OutputDebugString(L"[BixVReader]CreateDeviceInterface Failed");
+    }
+
+    SAFE_RELEASE(device);	
+    return hr;
+}
+
+void CMyDevice::ProcessIoControl(__in IWDFIoQueue*     pQueue,
+                                 __in IWDFIoRequest*   pRequest,
+                                 __in ULONG            ControlCode,
+                                 SIZE_T           inBufSize,
+                                 SIZE_T           outBufSize)
+{
+    inFunc
+        SectionLogger a(__FUNCTION__);
+    UNREFERENCED_PARAMETER(pQueue);
+    wchar_t log[300];
+    swprintf(log,L"[BixVReader][IOCT]IOCTL %08X - In %i Out %i",ControlCode,inBufSize,outBufSize);
+    OutputDebugString(log);
+
+    //SectionLocker lock(m_RequestLock);
+    int instance=0;
+    {	
+        CComPtr<IWDFFile>   pFileObject;
+        pRequest->GetFileObject(&pFileObject);
+
+        if (pFileObject != NULL)
+        {
+            DWORD logLen=300;
+            pFileObject->RetrieveFileName(log,&logLen);
+            instance=_wtoi(log+(logLen-2));
+        }
+    }
+    Reader &reader=*readers[instance];
+
+    if (ControlCode==IOCTL_SMARTCARD_GET_ATTRIBUTE) {
+        reader.IoSmartCardGetAttribute(pRequest,inBufSize,outBufSize);
+        return;
+    }
+    else if (ControlCode==IOCTL_SMARTCARD_IS_PRESENT) {
+        reader.IoSmartCardIsPresent(pRequest,inBufSize,outBufSize);
+        return;
+    }
+    else if (ControlCode==IOCTL_SMARTCARD_GET_STATE) {
+        reader.IoSmartCardGetState(pRequest,inBufSize,outBufSize);
+        return;
+    }
+    else if (ControlCode==IOCTL_SMARTCARD_IS_ABSENT) {
+        reader.IoSmartCardIsAbsent(pRequest,inBufSize,outBufSize);
+        return;
+    }
+    else if (ControlCode==IOCTL_SMARTCARD_POWER) {
+        reader.IoSmartCardPower(pRequest,inBufSize,outBufSize);
+        return;
+    }	
+    else if (ControlCode==IOCTL_SMARTCARD_SET_ATTRIBUTE) {
+        reader.IoSmartCardSetAttribute(pRequest,inBufSize,outBufSize);
+        return;
+    }
+    else if (ControlCode==IOCTL_SMARTCARD_SET_PROTOCOL) {
+        reader.IoSmartCardSetProtocol(pRequest,inBufSize,outBufSize);
+        return;
+    }
+    else if (ControlCode==IOCTL_SMARTCARD_TRANSMIT) {
+        reader.IoSmartCardTransmit(pRequest,inBufSize,outBufSize);
+        return;
+    }
+    swprintf(log,L"[BixVReader][IOCT]ERROR_NOT_SUPPORTED:%08X",ControlCode);
+    OutputDebugString(log);
+    pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
+
+    return;
+}
+
+
+DWORD WINAPI ServerFunc(Reader *reader) {
+    return reader->startServer();
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// CMyDevice::OnPrepareHardware
+//
+//  Called by UMDF to prepare the hardware for use. 
+//
+// Parameters:
+//      pWdfDevice - pointer to an IWDFDevice object representing the
+//      device
+//
+// Return Values:
+//      S_OK: success
+//
+/////////////////////////////////////////////////////////////////////////
+
+HRESULT CMyDevice::OnPrepareHardware(
+                                     __in IWDFDevice* pWdfDevice
+                                     )
+{
+    inFunc
+        SectionLogger a(__FUNCTION__);
+    // Store the IWDFDevice pointer
+    m_pWdfDevice = pWdfDevice;
+
+    // Configure the default IO Queue
+    HRESULT hr = CMyQueue::CreateInstance(m_pWdfDevice, this);
+
+    return hr;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// CMyDevice::OnReleaseHardware
+//
+// Called by WUDF to uninitialize the hardware.
+//
+// Parameters:
+//      pWdfDevice - pointer to an IWDFDevice object for the device
+//
+// Return Values:
+//      S_OK:
+//
+/////////////////////////////////////////////////////////////////////////
+HRESULT CMyDevice::OnReleaseHardware(
+                                     __in IWDFDevice* pWdfDevice
+                                     )
+{
+    inFunc
+        SectionLogger a(__FUNCTION__);
+    UNREFERENCED_PARAMETER(pWdfDevice);
+
+    // Release the IWDFDevice handle, if it matches
+    if (pWdfDevice == m_pWdfDevice.p)
+    {
+        m_pWdfDevice.Release();
+    }
+
+    return S_OK;
+}
+
+
+HRESULT CMyDevice::OnD0Entry(IN IWDFDevice*  pWdfDevice,IN WDF_POWER_DEVICE_STATE  previousState) {
+    SectionLogger a(__FUNCTION__);
+    UNREFERENCED_PARAMETER(pWdfDevice);
+    UNREFERENCED_PARAMETER(previousState);
+
+    numInstances=GetPrivateProfileInt(L"Driver",L"NumReaders",1,L"BixVReader.ini");	
+    readers.resize(numInstances);
+
+    for (int i=0;i<numInstances;i++) {
+        wchar_t section[300];
+        char sectionA[300];
+        swprintf(section,L"Reader%i",i);
+        sprintf(sectionA,"Reader%i",i);
+
+        int rpcType=GetPrivateProfileInt(section,L"RPC_TYPE",0,L"BixVReader.ini");
+        if (rpcType==0)
+            readers[i]=new PipeReader();
+        else if (rpcType==1)
+            readers[i]=new TcpIpReader();
+        else if (rpcType==2)
+            readers[i]=new VpcdReader();
+
+        readers[i]->instance=i;
+        readers[i]->device=this;
+        GetPrivateProfileStringA(sectionA,"VENDOR_NAME","Bix",readers[i]->vendorName,sizeof readers[i]->vendorName,"BixVReader.ini");
+        GetPrivateProfileStringA(sectionA,"VENDOR_IFD_TYPE","VIRTUAL_CARD_READER",readers[i]->vendorIfdType,sizeof readers[i]->vendorIfdType,"BixVReader.ini");
+        readers[i]->deviceUnit=GetPrivateProfileInt(section,L"DEVICE_UNIT",i,L"BixVReader.ini");
+        readers[i]->protocol=0;
+
+        readers[i]->init(section);
+
+        DWORD pipeThreadID;
+        readers[i]->serverThread=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)ServerFunc,readers[i],0,&pipeThreadID);
+    }
+
+    return S_OK;
+}
+HRESULT CMyDevice::OnD0Exit(IN IWDFDevice*  pWdfDevice,IN WDF_POWER_DEVICE_STATE  newState) {
+    SectionLogger a(__FUNCTION__);
+    UNREFERENCED_PARAMETER(pWdfDevice);
+    UNREFERENCED_PARAMETER(newState);
+    // dovrei fermare tutti i thread in ascolto dei lettori
+    shutDown();
+    return S_OK;
+}
+
+void CMyDevice::shutDown() {
+    SectionLogger a(__FUNCTION__);
+    for (int i=0;i<numInstances;i++) {
+        readers[i]->shutdown();
+        delete readers[i];
+    }
+    numInstances=0;
+}
+HRESULT CMyDevice::OnQueryRemove(IN IWDFDevice*  pWdfDevice) {
+    SectionLogger a(__FUNCTION__);
+    UNREFERENCED_PARAMETER(pWdfDevice);
+    OutputDebugString(L"[BixVReader]OnQueryRemove");
+    shutDown();
+    return S_OK;
+}
+HRESULT CMyDevice::OnQueryStop(IN IWDFDevice*  pWdfDevice) {
+    SectionLogger a(__FUNCTION__);
+    UNREFERENCED_PARAMETER(pWdfDevice);
+    OutputDebugString(L"[BixVReader]OnQueryStop");
+    shutDown();
+    return S_OK;
+}
+void CMyDevice::OnSurpriseRemoval(IN IWDFDevice*  pWdfDevice) {
+    SectionLogger a(__FUNCTION__);
+    UNREFERENCED_PARAMETER(pWdfDevice);
+    OutputDebugString(L"[BixVReader]OnSurpriseRemoval");
+    shutDown();
+}
+
+STDMETHODIMP_ (void) CMyDevice::OnCancel(IN IWDFIoRequest*  pWdfRequest) {
+    SectionLogger a(__FUNCTION__);
+
+    wchar_t log[300];
+    SectionLocker lock(m_RequestLock);
+
+    int instance=0;
+    {	
+        CComPtr<IWDFFile>   pFileObject;
+        pWdfRequest->GetFileObject(&pFileObject);
+
+        if (pFileObject != NULL)
+        {
+            DWORD logLen=300;
+            pFileObject->RetrieveFileName(log,&logLen);
+            instance=_wtoi(log+(logLen-2));
+        }
+    }
+    Reader &reader=*readers[instance];
+
+    if (pWdfRequest==reader.waitRemoveIpr) {
+        OutputDebugString(L"[BixVReader]Cancel Remove");
+        reader.waitRemoveIpr=NULL;
+    }
+    else if (pWdfRequest==reader.waitInsertIpr) {
+        OutputDebugString(L"[BixVReader]Cancel Insert");
+        reader.waitInsertIpr=NULL;
+    }
+    pWdfRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_CANCELLED), 0);
+}
+

virtualsmartcard/win32/BixVReader/device.h

@@ -1,10 +1,13 @@
-
-
 #pragma once
 
+#include <vector>
+#include "reader.h"
+
 //
 // Class for the iotrace driver.
 //
+class CMyDevice;
+
 
 class ATL_NO_VTABLE CMyDevice :
     public CComObjectRootEx<CComMultiThreadModel>,
@@ -13,7 +16,9 @@ class ATL_NO_VTABLE CMyDevice :
 	public IRequestCallbackCancel
 {
 public:
-	~CMyDevice() {}
+	~CMyDevice() {
+        DeleteCriticalSection(&m_RequestLock);
+	}
 
     DECLARE_NOT_AGGREGATABLE(CMyDevice)
 
@@ -25,16 +30,8 @@ public:
 
     CMyDevice(VOID)
     {
+        InitializeCriticalSection(&m_RequestLock);
         m_pWdfDevice = NULL;
-		waitRemoveIpr=NULL;
-		waitInsertIpr=NULL;
-		ctx = NULL;
-		pipe=NULL;
-		eventpipe=NULL;
-		outdata = NULL;
-		outlength = 0;
-		indata = NULL;
-		inlength = 0;
     }
 
 	//
@@ -43,14 +40,8 @@ public:
 private:
 
     CComPtr<IWDFDevice>     m_pWdfDevice;
-	CComPtr<IWDFIoRequest> waitRemoveIpr,waitInsertIpr;
+	std::vector<Reader*> readers;
-	struct vicc_ctx *ctx;
+	int numInstances;
-	BYTE *outdata;
-	SIZE_T outlength;
-	BYTE *indata;
-	SIZE_T inlength;
-	HANDLE pipe;
-	HANDLE eventpipe;
 
 //
 // Private methods.
@@ -66,6 +57,8 @@ private:
 //
 public:
 
+    CRITICAL_SECTION        m_RequestLock;
+
     //
     // The factory method used to create an instance of this driver.
     //
@@ -100,13 +93,6 @@ public:
     STDMETHOD_ (void, OnSurpriseRemoval)(IN IWDFDevice*  pWdfDevice);
     STDMETHOD_ (void, OnCancel)(IN IWDFIoRequest*  pWdfRequest);
 
-	void IoSmartCardGetAttribute(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
-	void IoSmartCardIsPresent(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
-	void IoSmartCardGetState(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
-	void IoSmartCardIsAbsent(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
-	void IoSmartCardPower(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
-	void IoSmartCardSetAttribute(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
-	void IoSmartCardTransmit(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize);
 	void shutDown();
 };
 

virtualsmartcard/win32/BixVReader/driver.cpp

@@ -1,12 +1,13 @@
-
 #include "internal.h"
 #include "VirtualSCReader.h"
 #include "driver.h"
 #include "device.h"
 #include <stdio.h>
+#include "SectionLocker.h"
 
 CMyDriver::CMyDriver()
 {
+	inFunc
 }
 
 /////////////////////////////////////////////////////////////////////////
@@ -29,7 +30,8 @@ HRESULT CMyDriver::OnDeviceAdd(
     __in IWDFDeviceInitialize* pDeviceInit
     )
 {
-	inFunc;
+	inFunc
+	SectionLogger a(__FUNCTION__);
     HRESULT hr = CMyDevice::CreateInstance(pDriver, pDeviceInit);
 
     return hr;
@@ -46,6 +48,8 @@ HRESULT CMyDriver::OnInitialize(
     __in IWDFDriver* pDriver
     )
 {
+	inFunc
+	SectionLogger a(__FUNCTION__);
     UNREFERENCED_PARAMETER(pDriver);
     return S_OK;
 }
@@ -63,7 +67,9 @@ void CMyDriver::OnDeinitialize(
     __in IWDFDriver* pDriver
     )
 {
-    UNREFERENCED_PARAMETER(pDriver);
+	inFunc
+ 	SectionLogger a(__FUNCTION__);
+   UNREFERENCED_PARAMETER(pDriver);
     return;
 }
 

virtualsmartcard/win32/BixVReader/internal.h

@@ -6,7 +6,7 @@
 #include <atlcom.h>
 #include <atlstr.h>
 
-__user_driver;  // Macro letting the compiler know this is not a kernel driver (this will help surpress needless warnings)
+//__user_driver;  // Macro letting the compiler know this is not a kernel driver (this will help surpress needless warnings)
 
 // Common WPD and WUDF headers
 
@@ -61,14 +61,15 @@ public:
 	funcTrace (char *func) {
 		wchar_t funcName[500];
 		wsprintf(funcN,L"%S",func);
-		wsprintf(funcName,L"IN  -> %s\n",funcN);
+		wsprintf(funcName,L"[BixVReader]IN -> %s",funcN);
 		OutputDebugString(funcName);
 	}
 	~funcTrace () {
 		wchar_t funcName[500];
-		wsprintf(funcName,L"OUT -> %s\n",funcN);
+		wsprintf(funcName,L"[BixVReader]OUT -> %s",funcN);
 		OutputDebugString(funcName);
 	}
 };
 
-#define inFunc funcTrace _ftrace(__FUNCTION__);
+//#define inFunc funcTrace _ftrace(__FUNCTION__);
+#define inFunc

virtualsmartcard/win32/BixVReader/memory.cpp

@@ -1,103 +1,83 @@
 #include "memory.h"
+#include "SectionLocker.h"
+
+bool getBuffer(IWDFIoRequest* pRequest,BYTE *buffer,int *bufferLen) {
 
-bool getBuffer(IWDFIoRequest *pRequest, BYTE **buffer, SIZE_T *bufferLen)
-{
 	IWDFMemory *inmem=NULL;
-
-	if (!pRequest || !buffer || !bufferLen) {
-		OutputDebugString(L"wrong arguments");
-		return false;
-	}
-
 	pRequest->GetInputMemory(&inmem);
 	if (inmem==NULL) {
 		OutputDebugString(L"GetInputMemory failed");
 		return false;
-	} else {
+	}
+	else {
 		SIZE_T size;
 		void *data=inmem->GetDataBuffer(&size);
-		if (*bufferLen < size) {
+		memcpy(buffer,data,size);
-			BYTE *p = (BYTE *) realloc(*buffer, size);
+		(*bufferLen)=(int)size;
-			if (!p) {
-				OutputDebugString(L"realloc failed");
-				inmem->Release();
-				return false;
-			}
-			*buffer = p;
-		}
-
-		memcpy(*buffer, data, size);
-		(*bufferLen) = size;
-
 		inmem->Release();
 		return true;
 	}
 }
-
+void setBuffer(CMyDevice *device,IWDFIoRequest* pRequest,BYTE *result,int inSize) {
-void completeWithBuffer(IWDFIoRequest* pRequest,BYTE *result,int inSize) {
 	IWDFMemory *outmem=NULL;
 	pRequest->GetOutputMemory (&outmem);
 	if (outmem==NULL) {
+		SectionLocker lock(device->m_RequestLock);
 		OutputDebugString(L"GetOutputMemory failed");
         pRequest->Complete(HRESULT_FROM_WIN32(ERROR_GEN_FAILURE));
 	}
 	else {
+		SectionLocker lock(device->m_RequestLock);
 		outmem->CopyFromBuffer(0,result,inSize);
 		outmem->Release();
         pRequest->CompleteWithInformation(0,(SIZE_T)inSize);
 	}
 }
 
-void completeWithString(IWDFIoRequest* pRequest,char *result,int outSize) {
+void setString(CMyDevice *device,IWDFIoRequest* pRequest,char *result,int outSize) {
 	IWDFMemory *outmem=NULL;
 	pRequest->GetOutputMemory (&outmem);
 	if (outmem==NULL) {
+		SectionLocker lock(device->m_RequestLock);
 		OutputDebugString(L"GetOutputMemory failed");
         pRequest->Complete(HRESULT_FROM_WIN32(ERROR_GEN_FAILURE));
 	}
 	else {
+		SectionLocker lock(device->m_RequestLock);
 		int size=min(outSize,(int)strlen(result)+1);
 		outmem->CopyFromBuffer(0,result,size);
 		outmem->Release();
         pRequest->CompleteWithInformation(0,(SIZE_T)size);
 	}
 }
-void completeWithInteger(IWDFIoRequest* pRequest,DWORD result) {
+void setInt(CMyDevice *device,IWDFIoRequest* pRequest,DWORD result) {
 	IWDFMemory *outmem=NULL;
 	pRequest->GetOutputMemory (&outmem);
 	if (outmem==NULL) {
+		SectionLocker lock(device->m_RequestLock);
 		OutputDebugString(L"GetOutputMemory failed");
         pRequest->Complete(HRESULT_FROM_WIN32(ERROR_GEN_FAILURE));
 	}
 	else {
+		SectionLocker lock(device->m_RequestLock);
 		outmem->CopyFromBuffer(0,&result,sizeof(result));
 		outmem->Release();
         pRequest->CompleteWithInformation(0,sizeof(result));
 	}
 }
+DWORD getInt(IWDFIoRequest* pRequest) {
 
-bool getInteger(IWDFIoRequest *pRequest, DWORD *integer)
-{
 	IWDFMemory *inmem=NULL;
-
-	if (!pRequest || !integer) {
-		OutputDebugString(L"wrong arguments");
-		return false;
-	}
-
 	pRequest->GetInputMemory(&inmem);
 	if (inmem==NULL) {
 		OutputDebugString(L"GetInputMemory failed");
-		return false;
+		return 0xffffffff;
-	} else {
+	}
+	else {
 		SIZE_T size;
 		void *data=inmem->GetDataBuffer(&size);
-		if (size != sizeof(*integer)) {
+		DWORD d=*(DWORD *)data;
-			OutputDebugString(L"not enough memory failed");
-			return false;
-		}
-		*integer=*(DWORD *)data;
 		inmem->Release();
-		return true;
+		return d;
 	}
 }

virtualsmartcard/win32/BixVReader/memory.h

@@ -0,0 +1,10 @@
+#pragma once
+#include "internal.h"
+#include "device.h"
+
+
+bool getBuffer(IWDFIoRequest* pRequest,BYTE *buffer,int *bufferLen);
+void setString(CMyDevice *device,IWDFIoRequest* pRequest,char *result,int outSize);
+void setBuffer(CMyDevice *device,IWDFIoRequest* pRequest,BYTE *result,int inSize);
+void setInt(CMyDevice *device,IWDFIoRequest* pRequest,DWORD result);
+DWORD getInt(IWDFIoRequest* pRequest);

virtualsmartcard/win32/BixVReader/resource.h

@@ -1319,7 +1319,7 @@
 #define _WIN32_IE_IE55                  0x0550
 #define _WIN32_WINNT_LONGHORN           0x0600
 #define _WIN32_IE_IE60                  0x0600
-//#define _WIN32_WINNT                    0x0600
+#define _WIN32_WINNT                    0x0600
 #define FILEOPENORD                     1536
 #define VER_PRODUCTVERSION_W            0x0600
 #define _WIN32_IE_IE60SP1               0x0601

virtualsmartcard/win32/BixVReader/sectionLocker.cpp

@@ -0,0 +1,47 @@
+#include "sectionLocker.h"
+void *ShowMe=NULL;
+SectionLocker::SectionLocker(CRITICAL_SECTION &critsection,char *function,int line,void* object) {
+	critsection;
+	this->section=&critsection;
+	Function=function;
+	Line=line;
+	Object=object;
+	DWORD start=GetTickCount();
+	if (TryEnterCriticalSection(section)==0) {
+		OutputDebugStringA("[BixVReader]RACE!");
+		char logBuffer[500];
+		sprintf(logBuffer,"[BixVReader]Richiesto da:Function:%s,Line:%i,Object:%x,Lock:%x",Function,Line,Object,section);
+		OutputDebugStringA(logBuffer);
+		ShowMe=section;
+		EnterCriticalSection(section);
+		DWORD end=GetTickCount();	
+		sprintf(logBuffer,"[BixVReader]Elapsed:%i ms",end-start);
+		OutputDebugStringA(logBuffer);
+	}
+}
+
+SectionLocker::~SectionLocker() {
+	if (section==ShowMe) {
+		char logBuffer[500];
+		sprintf(logBuffer,"[BixVReader]Posseduto da:Function:%s,Line:%i,Object:%x,Lock:%x",Function,Line,Object,section);
+		OutputDebugStringA(logBuffer);
+		ShowMe=NULL;
+	}
+	LeaveCriticalSection(section);
+}
+
+SectionLogger::SectionLogger(char *section) {
+	section;
+	start=GetTickCount();
+	char logBuffer[500];
+	SectionName=section;
+	sprintf(logBuffer,"[BixVReader]Start section:%s",SectionName);
+	OutputDebugStringA(logBuffer);
+}
+SectionLogger::~SectionLogger() {
+	DWORD end=GetTickCount();	
+	char logBuffer[500];
+	sprintf(logBuffer,"[BixVReader]End section:%s elapsed:%i",SectionName,end-start);
+	OutputDebugStringA(logBuffer);
+}
+

virtualsmartcard/win32/BixVReader/sectionLocker.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "internal.h"
+
+class SectionLocker {
+	char *Function;
+	int Line;
+	void *Object;
+public:
+	CRITICAL_SECTION *section;
+	
+	SectionLocker(CRITICAL_SECTION &critsection,char *function,int line,void* object);
+	//SectionLocker(CRITICAL_SECTION &section);
+	~SectionLocker();
+};
+
+class SectionLogger {
+	DWORD start;
+	char *SectionName;
+	public:
+	SectionLogger(char *section);
+	~SectionLogger();
+};
+
+#define lock(x) lockObj(x,__FUNCTION__,__LINE__,NULL)

virtualsmartcard/win32/vpcd/device.cpp

@@ -1,432 +0,0 @@
-#include "vpcd.h"
-#include "internal.h"
-#include "VirtualSCReader.h"
-#include "queue.h"
-#include "device.h"
-#include "driver.h"
-#include <stdio.h>
-#include <winscard.h>
-#include "memory.h"
-#include <Sddl.h>
-
-HRESULT
-CMyDevice::CreateInstance(
-    __in IWDFDriver *FxDriver,
-    __in IWDFDeviceInitialize * FxDeviceInit
-    )
-/*++
- 
-  Routine Description:
-
-    This method creates and initializs an instance of the virtual smart card reader driver's 
-    device callback object.
-
-  Arguments:
-
-    FxDeviceInit - the settings for the device.
-
-    Device - a location to store the referenced pointer to the device object.
-
-  Return Value:
-
-    Status
-
---*/
-{
-	inFunc;
-    CComObject<CMyDevice>* device = NULL;
-    HRESULT hr;
-
-    //
-    // Allocate a new instance of the device class.
-    //
-	hr = CComObject<CMyDevice>::CreateInstance(&device);
-
-    if (device==NULL)
-    {
-        return E_OUTOFMEMORY;
-    }
-
-    //
-    // Initialize the instance.
-    //
-	device->AddRef();
-    FxDeviceInit->SetLockingConstraint(WdfDeviceLevel);
-
-    CComPtr<IUnknown> spCallback;
-    hr = device->QueryInterface(IID_IUnknown, (void**)&spCallback);
-
-    CComPtr<IWDFDevice> spIWDFDevice;
-    if (SUCCEEDED(hr))
-    {
-        hr = FxDriver->CreateDevice(FxDeviceInit, spCallback, &spIWDFDevice);
-    }
-
-	if (spIWDFDevice->CreateDeviceInterface(&SmartCardReaderGuid,NULL)!=0)
-		OutputDebugString(L"CreateDeviceInterface Failed\n");
-
-	SAFE_RELEASE(device);
-
-    return hr;
-}
-
-void CMyDevice::IoSmartCardIsPresent(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
-	UNREFERENCED_PARAMETER(inBufSize);
-	UNREFERENCED_PARAMETER(outBufSize);
-	inFunc;
-	if (vicc_present(ctx) == 1)
-		// there's a smart card present, so complete the request
-		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
-	else {
-		// there's no smart card present, so leave the request pending; it will be completed later
-		waitInsertIpr=pRequest;
-		IRequestCallbackCancel *callback;
-		QueryInterface(__uuidof(IRequestCallbackCancel),(void**)&callback);
-		pRequest->MarkCancelable(callback);
-		callback->Release();
-	}
-}
-
-void CMyDevice::IoSmartCardGetState(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
-	UNREFERENCED_PARAMETER(inBufSize);
-	UNREFERENCED_PARAMETER(outBufSize);
-	inFunc;
-	if (vicc_present(ctx) == 1) {
-		OutputDebugString(L"[GSTA]SCARD_SPECIFIC\n");
-		completeWithInteger(pRequest, SCARD_SPECIFIC);
-	} else {
-		OutputDebugString(L"SCARD_ABSENT\n");
-		completeWithInteger(pRequest, SCARD_ABSENT);
-	}
-}
-void CMyDevice::IoSmartCardIsAbsent(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
-	UNREFERENCED_PARAMETER(inBufSize);
-	UNREFERENCED_PARAMETER(outBufSize);
-	inFunc;
-	if (vicc_present(ctx) == 0)
-		// there's no smart card present, so complete the request
-		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
-	else {
-		// there's a smart card present, so leave the request pending; it will be completed later
-		waitRemoveIpr=pRequest;
-		IRequestCallbackCancel *callback;
-
-		QueryInterface(__uuidof(IRequestCallbackCancel),(void**)&callback);
-		pRequest->MarkCancelable(callback);
-		callback->Release();
-	}
-}
-
-void CMyDevice::IoSmartCardPower(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
-	UNREFERENCED_PARAMETER(inBufSize);
-	UNREFERENCED_PARAMETER(outBufSize);
-	inFunc;
-	DWORD code;
-	if (!getInteger(pRequest, &code)) {
-		OutputDebugString(L"error getting code\n");
-		pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);
-		return;
-	}
-	switch (code) {
-		case SCARD_COLD_RESET:
-			OutputDebugString(L"[POWR]SCARD_COLD_RESET\n");
-			vicc_poweroff(ctx);
-			vicc_poweron(ctx);
-			break;
-		case SCARD_WARM_RESET:
-			OutputDebugString(L"[POWR]SCARD_WARM_RESET\n");
-			vicc_reset(ctx);
-			break;
-		case SCARD_POWER_DOWN:
-			OutputDebugString(L"[POWR]SCARD_POWER_DOWN\n");
-			vicc_poweroff(ctx);
-	}
-
-	if (code==SCARD_COLD_RESET || code==SCARD_WARM_RESET) {
-		int ATRsize = vicc_getatr(ctx, &outdata);
-		if (ATRsize <= 0) {
-			pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);					
-			return;
-		}
-		outlength = ATRsize;
-		completeWithBuffer(pRequest,outdata,outlength);
-	} else {
-		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
-	}
-}
-
-void CMyDevice::IoSmartCardSetAttribute(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
-	UNREFERENCED_PARAMETER(inBufSize);
-	UNREFERENCED_PARAMETER(outBufSize);
-	inFunc;
-	
-	IWDFMemory *inmem=NULL;
-	pRequest->GetInputMemory(&inmem);
-	
-	SIZE_T size;
-	BYTE *data=(BYTE *)inmem->GetDataBuffer(&size);
-
-	DWORD minCode=*(DWORD*)(data);
-	bool handled=false;
-	if (minCode==SCARD_ATTR_DEVICE_IN_USE) {
-		OutputDebugString(L"[SATT]SCARD_ATTR_DEVICE_IN_USE\n");
-		pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
-		handled=true;
-	}
-	inmem->Release();
-
-	if (!handled) {
-		OutputDebugString(L"[SATT]ERROR_NOT_SUPPORTED\n");
-		pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
-	}
-}
-
-void CMyDevice::IoSmartCardTransmit(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
-	UNREFERENCED_PARAMETER(inBufSize);
-	UNREFERENCED_PARAMETER(outBufSize);
-	inFunc;
-	if (!getBuffer(pRequest,&indata,&inlength)) {
-        pRequest->CompleteWithInformation(STATUS_INVALID_DEVICE_STATE, 0);
-		return;
-	}
-	if (((SCARD_IO_REQUEST*)indata)->dwProtocol!=SCARD_PROTOCOL_T1) {
-        pRequest->CompleteWithInformation(STATUS_INVALID_DEVICE_STATE, 0);
-		return;
-	}
-	int RespSize = vicc_transmit(ctx, inlength - sizeof(SCARD_IO_REQUEST), indata + sizeof(SCARD_IO_REQUEST), &outdata);
-	if (RespSize < 0)
-	{
-		pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);					
-		return;
-	}
-	outlength = RespSize;
-	BYTE *Resp = (BYTE *) malloc(outlength+sizeof(SCARD_IO_REQUEST));
-	if (!Resp) {
-        pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);
-		return;
-	}
-	((SCARD_IO_REQUEST*)Resp)->cbPciLength=sizeof(SCARD_IO_REQUEST);
-	((SCARD_IO_REQUEST*)Resp)->dwProtocol=SCARD_PROTOCOL_T1;
-	memcpy(Resp + sizeof(SCARD_IO_REQUEST), outdata, outlength);
-	completeWithBuffer(pRequest,Resp,RespSize+sizeof(SCARD_IO_REQUEST));
-}
-
-void CMyDevice::IoSmartCardGetAttribute(IWDFIoRequest* pRequest,SIZE_T inBufSize,SIZE_T outBufSize) {
-	UNREFERENCED_PARAMETER(inBufSize);
-	DWORD code;
-	int ATRsize;
-
-	if (!getInteger(pRequest, &code)) {
-		OutputDebugString(L"error getting code\n");
-		pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);
-		return;
-	}
-
-	switch(code) {
-		case SCARD_ATTR_CHARACTERISTICS:
-			// 0x00000000 No special characteristics
-			OutputDebugString(L"[GATT]SCARD_ATTR_CHARACTERISTICS\n");
-			completeWithInteger(pRequest,0);
-			return;
-		case SCARD_ATTR_VENDOR_NAME:
-			OutputDebugString(L"[GATT]SCARD_ATTR_VENDOR_NAME\n");
-			completeWithString(pRequest,"Virtual Smart Card Architecture",(int)outBufSize);
-			return;
-		case SCARD_ATTR_VENDOR_IFD_TYPE:
-			OutputDebugString(L"[GATT]SCARD_ATTR_VENDOR_IFD_TYPE\n");
-			completeWithString(pRequest,"Virtual PCD",(int)outBufSize);
-			return;
-		case SCARD_ATTR_DEVICE_UNIT:
-			OutputDebugString(L"[GATT]SCARD_ATTR_DEVICE_UNIT\n");
-			completeWithInteger(pRequest,0);
-			return;
-		case SCARD_ATTR_ATR_STRING:
-			OutputDebugString(L"[GATT]SCARD_ATTR_ATR_STRING\n");
-			ATRsize = vicc_getatr(ctx, &outdata);
-			if (ATRsize <= 0)
-			{
-				pRequest->CompleteWithInformation(STATUS_NO_MEDIA, 0);					
-				return;
-			}
-			outlength = ATRsize;
-			completeWithBuffer(pRequest,outdata,outlength);
-			return;
-		case SCARD_ATTR_CURRENT_PROTOCOL_TYPE:
-			OutputDebugString(L"[GATT]SCARD_ATTR_CURRENT_PROTOCOL_TYPE\n");
-			completeWithInteger(pRequest,SCARD_PROTOCOL_T1); // T=1
-			return;
-		default:
-			OutputDebugString(L"[GATT]ERROR_NOT_SUPPORTED\n");
-	        pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
-	}
-}
-
-void CMyDevice::ProcessIoControl(__in IWDFIoQueue*     pQueue,
-                                    __in IWDFIoRequest*   pRequest,
-                                    __in ULONG            ControlCode,
-                                         SIZE_T           inBufSize,
-                                         SIZE_T           outBufSize)
-{
-	inFunc;
-	UNREFERENCED_PARAMETER(pQueue);
-
-	if (ControlCode==IOCTL_SMARTCARD_GET_ATTRIBUTE) {
-		IoSmartCardGetAttribute(pRequest,inBufSize,outBufSize);
-		return;
-	}
-	else if (ControlCode==IOCTL_SMARTCARD_IS_PRESENT) {
-		IoSmartCardIsPresent(pRequest,inBufSize,outBufSize);
-		return;
-	}
-	else if (ControlCode==IOCTL_SMARTCARD_GET_STATE) {
-		IoSmartCardGetState(pRequest,inBufSize,outBufSize);
-		return;
-	}
-	else if (ControlCode==IOCTL_SMARTCARD_IS_ABSENT) {
-		IoSmartCardIsAbsent(pRequest,inBufSize,outBufSize);
-		return;
-	}
-	else if (ControlCode==IOCTL_SMARTCARD_POWER) {
-		IoSmartCardPower(pRequest,inBufSize,outBufSize);
-		return;
-	}	
-	else if (ControlCode==IOCTL_SMARTCARD_SET_ATTRIBUTE) {
-		IoSmartCardSetAttribute(pRequest,inBufSize,outBufSize);
-		return;
-	}
-	else if (ControlCode==IOCTL_SMARTCARD_TRANSMIT) {
-		IoSmartCardTransmit(pRequest,inBufSize,outBufSize);
-		return;
-	}
-	OutputDebugString(L"[IOCT]ERROR_NOT_SUPPORTED\n");
-    pRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED), 0);
-
-    return;
-}
-
-/////////////////////////////////////////////////////////////////////////
-//
-// CMyDevice::OnPrepareHardware
-//
-//  Called by UMDF to prepare the hardware for use. 
-//
-// Parameters:
-//      pWdfDevice - pointer to an IWDFDevice object representing the
-//      device
-//
-// Return Values:
-//      S_OK: success
-//
-/////////////////////////////////////////////////////////////////////////
-HRESULT CMyDevice::OnPrepareHardware(
-        __in IWDFDevice* pWdfDevice
-        )
-{
-	inFunc;
-    // Store the IWDFDevice pointer
-    m_pWdfDevice = pWdfDevice;
-
-    // Configure the default IO Queue
-    HRESULT hr = CMyQueue::CreateInstance(m_pWdfDevice, this);
-
-	ctx = vicc_init(NULL, VPCDPORT);
-
-    return hr;
-}
-
-
-/////////////////////////////////////////////////////////////////////////
-//
-// CMyDevice::OnReleaseHardware
-//
-// Called by WUDF to uninitialize the hardware.
-//
-// Parameters:
-//      pWdfDevice - pointer to an IWDFDevice object for the device
-//
-// Return Values:
-//      S_OK:
-//
-/////////////////////////////////////////////////////////////////////////
-HRESULT CMyDevice::OnReleaseHardware(
-        __in IWDFDevice* pWdfDevice
-        )
-{
-	inFunc;
-    UNREFERENCED_PARAMETER(pWdfDevice);
-    
-    // Release the IWDFDevice handle, if it matches
-    if (pWdfDevice == m_pWdfDevice.p)
-    {
-		vicc_eject(ctx);
-		vicc_exit(ctx);
-		ctx = NULL;
-        m_pWdfDevice.Release();
-    }
-
-    return S_OK;
-}
-
-
-HRESULT CMyDevice::OnD0Entry(IN IWDFDevice*  pWdfDevice,IN WDF_POWER_DEVICE_STATE  previousState) {
-	UNREFERENCED_PARAMETER(pWdfDevice);
-	UNREFERENCED_PARAMETER(previousState);
-	inFunc;
-	vicc_poweroff(ctx);
-	return S_OK;
-}
-HRESULT CMyDevice::OnD0Exit(IN IWDFDevice*  pWdfDevice,IN WDF_POWER_DEVICE_STATE  newState) {
-	UNREFERENCED_PARAMETER(pWdfDevice);
-	UNREFERENCED_PARAMETER(newState);
-	inFunc;
-	vicc_poweron(ctx);
-	return S_OK;
-}
-
-void CMyDevice::shutDown(){
-	if (waitRemoveIpr!=NULL) {
-		if (waitRemoveIpr->UnmarkCancelable()==S_OK)
-			waitRemoveIpr->Complete(HRESULT_FROM_WIN32(ERROR_CANCELLED));
-		waitRemoveIpr=NULL;
-	}
-	if (waitInsertIpr!=NULL) {
-		if (waitInsertIpr->UnmarkCancelable()==S_OK)
-			waitInsertIpr->Complete(HRESULT_FROM_WIN32(ERROR_CANCELLED));
-		waitInsertIpr=NULL;
-	}
-	free(outdata);
-	outdata = NULL;
-	outlength = 0;
-	free(indata);
-	indata = NULL;
-	inlength = 0;
-}
-HRESULT CMyDevice::OnQueryRemove(IN IWDFDevice*  pWdfDevice) {
-	UNREFERENCED_PARAMETER(pWdfDevice);
-	inFunc;
-	shutDown();
-	return S_OK;
-}
-HRESULT CMyDevice::OnQueryStop(IN IWDFDevice*  pWdfDevice) {
-	UNREFERENCED_PARAMETER(pWdfDevice);
-	inFunc;
-	shutDown();
-	return S_OK;
-}
-void CMyDevice::OnSurpriseRemoval(IN IWDFDevice*  pWdfDevice) {
-	UNREFERENCED_PARAMETER(pWdfDevice);
-	inFunc;
-	shutDown();
-}
-
-STDMETHODIMP_ (void) CMyDevice::OnCancel(IN IWDFIoRequest*  pWdfRequest) {
-	inFunc;
-	if (pWdfRequest==waitRemoveIpr) {
-		OutputDebugString(L"Cancel Remove\n");
-		waitRemoveIpr=NULL;
-	} else if (pWdfRequest==waitInsertIpr) {
-		OutputDebugString(L"Cancel Insert\n");
-		waitInsertIpr=NULL;
-	}
-	pWdfRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_CANCELLED), 0);
-}

virtualsmartcard/win32/vpcd/makefile.inc.props

@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <STAMP Condition="'$(OVERRIDE_STAMP)'!='true'">stampinf</STAMP>
-  </PropertyGroup>
-  <ItemGroup>
-    <NmakeTarget Include="vpcd.inx">
-      <TargetKillSwitch>ConvertedTarget0_Disabled</TargetKillSwitch>
-      <TargetName>Converted Target 0</TargetName>
-      <Outputs>$(OBJ_PATH)\$(O)\vpcd.inf</Outputs>
-      <Condition>
-      </Condition>
-      <Cmd0>copy %24%28%40B%29.inx %24%40</Cmd0>
-      <Cmd1>$(STAMP) -f %24%40 -a $(_BUILDARCH) -k $(KMDF_VERSION_MAJOR).$(KMDF_VERSION_MINOR) -u $(UMDF_VERSION_MAJOR).$(UMDF_VERSION_MINOR).0</Cmd1>
-    </NmakeTarget>
-  </ItemGroup>
-  <Target Name="Converted Target 0" BeforeTargets="$(BuildLinkTargets)" AfterTargets="$(AfterBuildCompileTargets)" Condition="'$(ConvertedTarget0_Disabled)'!='true'">
-    <ItemGroup>
-      <AllEvaluatedTargetInputs Remove="@(AllEvaluatedTargetInputs)" />
-      <t_TargetInput_0 Remove="@(t_TargetInput_0)" />
-      <t_TargetInput_0 Include="vpcd.inx" Condition="Exists('vpcd.inx') And ('@(t_TargetInput_0)'=='')" />
-      <t_TargetInput_0 Include="vpcd.inx" Condition="'@(t_TargetInput_0)'==''" />
-      <AllEvaluatedTargetInputs Include="@(t_TargetInput_0);" />
-    </ItemGroup>
-    <ReplaceNmakeCommandTokens Command="copy %24%28%40B%29.inx %24%40" TaskInputFiles="@(AllEvaluatedTargetInputs)" TaskOutputFile="$(OBJ_PATH)\$(O)\vpcd.inf">
-      <Output TaskParameter="ShouldExecute" PropertyName="TargetOutDated" />
-      <Output TaskParameter="ProcessedCommand" PropertyName="ResolvedCommand_1" />
-    </ReplaceNmakeCommandTokens>
-    <Exec Condition="'$(TargetOutDated)'=='true'" Command="$(ResolvedCommand_1)" WorkingDirectory="$(MSBuildProjectDirectory)" />
-    <ReplaceNmakeCommandTokens Command="$(STAMP) -f %24%40 -a $(_BUILDARCH) -k $(KMDF_VERSION_MAJOR).$(KMDF_VERSION_MINOR) -u $(UMDF_VERSION_MAJOR).$(UMDF_VERSION_MINOR).0" TaskInputFiles="@(AllEvaluatedTargetInputs)" TaskOutputFile="$(OBJ_PATH)\$(O)\vpcd.inf">
-      <Output TaskParameter="ShouldExecute" PropertyName="Junk_Property" />
-      <Output TaskParameter="ProcessedCommand" PropertyName="ResolvedCommand_2" />
-    </ReplaceNmakeCommandTokens>
-    <Exec Condition="'$(TargetOutDated)'=='true'" Command="$(ResolvedCommand_2)" WorkingDirectory="$(MSBuildProjectDirectory)" />
-    <Message Condition="'$(TargetOutDated)'!='true'" Text="File $(OBJ_PATH)\$(O)\vpcd.inf is up-to-date" />
-  </Target>
-</Project>

virtualsmartcard/win32/vpcd/memory.h

@@ -1,9 +0,0 @@
-#pragma once
-#include "internal.h"
-
-
-bool getBuffer(IWDFIoRequest *pRequest, BYTE **buffer, SIZE_T *bufferLen);
-void completeWithString(IWDFIoRequest* pRequest,char *result,int outSize);
-void completeWithBuffer(IWDFIoRequest* pRequest,BYTE *result,int inSize);
-void completeWithInteger(IWDFIoRequest* pRequest,DWORD result);
-bool getInteger(IWDFIoRequest *pRequest, DWORD *integer);

virtualsmartcard/win32/vpcd/sources.props

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <UMDF_VERSION_MAJOR Condition="'$(OVERRIDE_UMDF_VERSION_MAJOR)'!='true'">1</UMDF_VERSION_MAJOR>
-    <UMDF_VERSION_MINOR Condition="'$(OVERRIDE_UMDF_VERSION_MINOR)'!='true'">9</UMDF_VERSION_MINOR>
-    <KMDF_VERSION_MAJOR Condition="'$(OVERRIDE_KMDF_VERSION_MAJOR)'!='true'">1</KMDF_VERSION_MAJOR>
-    <KMDF_VERSION_MINOR Condition="'$(OVERRIDE_KMDF_VERSION_MINOR)'!='true'">9</KMDF_VERSION_MINOR>
-    <TARGETNAME Condition="'$(OVERRIDE_TARGETNAME)'!='true'">vpcd</TARGETNAME>
-    <TARGETTYPE Condition="'$(OVERRIDE_TARGETTYPE)'!='true'">DYNLINK</TARGETTYPE>
-    <USE_ATL Condition="'$(OVERRIDE_USE_ATL)'!='true'">1</USE_ATL>
-    <ATL_VER Condition="'$(OVERRIDE_ATL_VER)'!='true'">71</ATL_VER>
-    <USE_MSVCRT Condition="'$(OVERRIDE_USE_MSVCRT)'!='true'">1</USE_MSVCRT>
-    <C_DEFINES Condition="'$(OVERRIDE_C_DEFINES)'!='true'">$(C_DEFINES)  /D_UNICODE /DUNICODE</C_DEFINES>
-    <WIN32_WINNT_VERSION Condition="'$(OVERRIDE_WIN32_WINNT_VERSION)'!='true'">$(LATEST_WIN32_WINNT_VERSION)</WIN32_WINNT_VERSION>
-    <_NT_TARGET_VERSION Condition="'$(OVERRIDE__NT_TARGET_VERSION)'!='true'">$(_NT_TARGET_VERSION_WIN7)</_NT_TARGET_VERSION>
-    <NTDDI_VERSION Condition="'$(OVERRIDE_NTDDI_VERSION)'!='true'">$(LATEST_NTDDI_VERSION)</NTDDI_VERSION>
-    <DLLENTRY Condition="'$(OVERRIDE_DLLENTRY)'!='true'">_DllMainCRTStartup</DLLENTRY>
-    <DLLDEF Condition="'$(OVERRIDE_DLLDEF)'!='true'">exports.def</DLLDEF>
-    <SOURCES Condition="'$(OVERRIDE_SOURCES)'!='true'">vpcd.rc                          driver.cpp                       device.cpp					     queue.cpp					     memory.cpp					     DllMain.cpp					     VirtualSCReader.idl</SOURCES>
-    <INCLUDES Condition="'$(OVERRIDE_INCLUDES)'!='true'">$(INCLUDES);                             $(SDK_INC_PATH);                         $(DDK_INC_PATH);                         $(UMDF_INC_PATH)\10;</INCLUDES>
-    <MSC_WARNING_LEVEL Condition="'$(OVERRIDE_MSC_WARNING_LEVEL)'!='true'">/W4 /WX</MSC_WARNING_LEVEL>
-    <TARGETLIBS Condition="'$(OVERRIDE_TARGETLIBS)'!='true'">$(SDK_LIB_PATH)\strsafe.lib              $(SDK_LIB_PATH)\kernel32.lib             $(SDK_LIB_PATH)\ole32.lib                $(SDK_LIB_PATH)\oleaut32.lib             $(SDK_LIB_PATH)\uuid.lib                 $(SDK_LIB_PATH)\user32.lib               $(SDK_LIB_PATH)\advapi32.lib             $(SDK_LIB_PATH)\shlwapi.lib              $(SDK_LIB_PATH)\ws2_32.lib</TARGETLIBS>
-    <NTTARGETFILE1 Condition="'$(OVERRIDE_NTTARGETFILE1)'!='true'">$(OBJ_PATH)\$(O)\vpcd.inf</NTTARGETFILE1>
-    <TARGET_DESTINATION Condition="'$(OVERRIDE_TARGET_DESTINATION)'!='true'">wudf</TARGET_DESTINATION>
-  </PropertyGroup>
-  <ItemGroup>
-    <InvokedTargetsList Include="$(OBJ_PATH)\$(O)\vpcd.inf">
-      <Pass>1</Pass>
-      <Condition>
-      </Condition>
-    </InvokedTargetsList>
-  </ItemGroup>
-</Project>

virtualsmartcard/win32/vpcd/vpcd-Package/vpcd-Package.vcxproj

@@ -1,152 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Win8.1 Debug|Win32">
-      <Configuration>Win8.1 Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8.1 Release|Win32">
-      <Configuration>Win8.1 Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8 Debug|Win32">
-      <Configuration>Win8 Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8 Release|Win32">
-      <Configuration>Win8 Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win7 Debug|Win32">
-      <Configuration>Win7 Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win7 Release|Win32">
-      <Configuration>Win7 Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8.1 Debug|x64">
-      <Configuration>Win8.1 Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8.1 Release|x64">
-      <Configuration>Win8.1 Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8 Debug|x64">
-      <Configuration>Win8 Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8 Release|x64">
-      <Configuration>Win8 Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win7 Debug|x64">
-      <Configuration>Win7 Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win7 Release|x64">
-      <Configuration>Win7 Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="PropertySheets">
-    <PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
-    <ConfigurationType>Utility</ConfigurationType>
-    <DriverType>Package</DriverType>
-    <DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
-    <Configuration>Win8.1 Debug</Configuration>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}</ProjectGuid>
-    <RootNamespace>$(MSBuildProjectName)</RootNamespace>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|Win32'" Label="Configuration">
-    <TargetVersion>WindowsV6.3</TargetVersion>
-    <UseDebugLibraries>true</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|Win32'" Label="Configuration">
-    <TargetVersion>WindowsV6.3</TargetVersion>
-    <UseDebugLibraries>false</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'" Label="Configuration">
-    <TargetVersion>Windows8</TargetVersion>
-    <UseDebugLibraries>true</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'" Label="Configuration">
-    <TargetVersion>Windows8</TargetVersion>
-    <UseDebugLibraries>false</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'" Label="Configuration">
-    <TargetVersion>Windows7</TargetVersion>
-    <UseDebugLibraries>true</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'" Label="Configuration">
-    <TargetVersion>Windows7</TargetVersion>
-    <UseDebugLibraries>false</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|x64'" Label="Configuration">
-    <TargetVersion>WindowsV6.3</TargetVersion>
-    <UseDebugLibraries>true</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|x64'" Label="Configuration">
-    <TargetVersion>WindowsV6.3</TargetVersion>
-    <UseDebugLibraries>false</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'" Label="Configuration">
-    <TargetVersion>Windows8</TargetVersion>
-    <UseDebugLibraries>true</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'" Label="Configuration">
-    <TargetVersion>Windows8</TargetVersion>
-    <UseDebugLibraries>false</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'" Label="Configuration">
-    <TargetVersion>Windows7</TargetVersion>
-    <UseDebugLibraries>true</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'" Label="Configuration">
-    <TargetVersion>Windows7</TargetVersion>
-    <UseDebugLibraries>false</UseDebugLibraries>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup />
-  <PropertyGroup>
-    <DebuggerFlavor>DbgengRemoteDebugger</DebuggerFlavor>
-    <EnableDeployment>False</EnableDeployment>
-    <ImportToStore>False</ImportToStore>
-    <InstallMode>None</InstallMode>
-    <HardwareIdString />
-    <CommandLine />
-    <ScriptPath />
-    <DeployFiles />
-    <ScriptName />
-    <ScriptDeviceQuery>%PathToInf%</ScriptDeviceQuery>
-    <EnableVerifier>False</EnableVerifier>
-    <AllDrivers>False</AllDrivers>
-    <VerifyProjectOutput>True</VerifyProjectOutput>
-    <VerifyDrivers />
-    <VerifyFlags>133563</VerifyFlags>
-  </PropertyGroup>
-  <ItemDefinitionGroup>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <!--Inf Include="DriverInf.inv" /-->
-    <FilesToPackage Include="@(Inf->'%(CopyOutput)')" Condition="'@(Inf)'!=''" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\vpcd.vcxproj">
-      <Project>{B019D202-420C-484D-9303-45B552A05B95}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

virtualsmartcard/win32/vpcd/vpcd.sln

@@ -1,83 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0
-MinimumVisualStudioVersion = 12.0
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Vpcd-Package", "Vpcd-Package", "{B4A2C5E7-24D0-4EBB-A564-5F52DD858932}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vpcd-Package", "vpcd-Package\vpcd-Package.vcxproj", "{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vpcd", "vpcd.vcxproj", "{B019D202-420C-484D-9303-45B552A05B95}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Win8.1 Debug|Win32 = Win8.1 Debug|Win32
-		Win8.1 Debug|x64 = Win8.1 Debug|x64
-		Win8.1 Release|Win32 = Win8.1 Release|Win32
-		Win8.1 Release|x64 = Win8.1 Release|x64
-		Win8 Debug|Win32 = Win8 Debug|Win32
-		Win8 Debug|x64 = Win8 Debug|x64
-		Win8 Release|Win32 = Win8 Release|Win32
-		Win8 Release|x64 = Win8 Release|x64
-		Win7 Debug|Win32 = Win7 Debug|Win32
-		Win7 Debug|x64 = Win7 Debug|x64
-		Win7 Release|Win32 = Win7 Release|Win32
-		Win7 Release|x64 = Win7 Release|x64
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8.1 Debug|Win32.ActiveCfg = Win8.1 Debug|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8.1 Debug|Win32.Build.0 = Win8.1 Debug|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8.1 Debug|x64.ActiveCfg = Win8.1 Debug|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8.1 Debug|x64.Build.0 = Win8.1 Debug|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8.1 Release|Win32.ActiveCfg = Win8.1 Release|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8.1 Release|Win32.Build.0 = Win8.1 Release|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8.1 Release|x64.ActiveCfg = Win8.1 Release|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8.1 Release|x64.Build.0 = Win8.1 Release|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8 Debug|Win32.ActiveCfg = Win8 Debug|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8 Debug|Win32.Build.0 = Win8 Debug|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8 Debug|x64.ActiveCfg = Win8 Debug|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8 Debug|x64.Build.0 = Win8 Debug|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8 Release|Win32.ActiveCfg = Win8 Release|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8 Release|Win32.Build.0 = Win8 Release|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8 Release|x64.ActiveCfg = Win8 Release|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win8 Release|x64.Build.0 = Win8 Release|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win7 Debug|Win32.ActiveCfg = Win7 Debug|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win7 Debug|Win32.Build.0 = Win7 Debug|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win7 Debug|x64.ActiveCfg = Win7 Debug|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win7 Debug|x64.Build.0 = Win7 Debug|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win7 Release|Win32.ActiveCfg = Win7 Release|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win7 Release|Win32.Build.0 = Win7 Release|Win32
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win7 Release|x64.ActiveCfg = Win7 Release|x64
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5}.Win7 Release|x64.Build.0 = Win7 Release|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8.1 Debug|Win32.ActiveCfg = Win8.1 Debug|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8.1 Debug|Win32.Build.0 = Win8.1 Debug|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8.1 Debug|x64.ActiveCfg = Win8.1 Debug|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8.1 Debug|x64.Build.0 = Win8.1 Debug|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8.1 Release|Win32.ActiveCfg = Win8.1 Release|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8.1 Release|Win32.Build.0 = Win8.1 Release|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8.1 Release|x64.ActiveCfg = Win8.1 Release|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8.1 Release|x64.Build.0 = Win8.1 Release|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8 Debug|Win32.ActiveCfg = Win8 Debug|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8 Debug|Win32.Build.0 = Win8 Debug|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8 Debug|x64.ActiveCfg = Win8 Debug|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8 Debug|x64.Build.0 = Win8 Debug|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8 Release|Win32.ActiveCfg = Win8 Release|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8 Release|Win32.Build.0 = Win8 Release|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8 Release|x64.ActiveCfg = Win8 Release|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win8 Release|x64.Build.0 = Win8 Release|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win7 Debug|Win32.ActiveCfg = Win7 Debug|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win7 Debug|Win32.Build.0 = Win7 Debug|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win7 Debug|x64.ActiveCfg = Win7 Debug|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win7 Debug|x64.Build.0 = Win7 Debug|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win7 Release|Win32.ActiveCfg = Win7 Release|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win7 Release|Win32.Build.0 = Win7 Release|Win32
-		{B019D202-420C-484D-9303-45B552A05B95}.Win7 Release|x64.ActiveCfg = Win7 Release|x64
-		{B019D202-420C-484D-9303-45B552A05B95}.Win7 Release|x64.Build.0 = Win7 Release|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{7D06C4DD-96FC-4421-96F1-C90A6093A6F5} = {B4A2C5E7-24D0-4EBB-A564-5F52DD858932}
-	EndGlobalSection
-EndGlobal

virtualsmartcard/win32/vpcd/vpcd.vcxproj

@@ -1,217 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Win8.1 Debug|Win32">
-      <Configuration>Win8.1 Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8 Debug|Win32">
-      <Configuration>Win8 Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win7 Debug|Win32">
-      <Configuration>Win7 Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8.1 Release|Win32">
-      <Configuration>Win8.1 Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8 Release|Win32">
-      <Configuration>Win8 Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win7 Release|Win32">
-      <Configuration>Win7 Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8.1 Debug|x64">
-      <Configuration>Win8.1 Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8 Debug|x64">
-      <Configuration>Win8 Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win7 Debug|x64">
-      <Configuration>Win7 Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8.1 Release|x64">
-      <Configuration>Win8.1 Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win8 Release|x64">
-      <Configuration>Win8 Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Win7 Release|x64">
-      <Configuration>Win7 Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="PropertySheets">
-    <PlatformToolset>WindowsUserModeDriver8.1</PlatformToolset>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <DriverType>UMDF</DriverType>
-    <TARGETNAME>vpcd</TARGETNAME>
-    <Configuration Condition="'$(Configuration)' == ''">Win8.1 Debug</Configuration>
-    <Platform Condition="'$(Platform)' == ''">Win32</Platform>
-    <ConvertedTarget0_Disabled>True</ConvertedTarget0_Disabled>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Label="PropertySheets">
-    <ConversionToolVersion>1.0</ConversionToolVersion>
-    <BUILD_ALT_DIR>$(Configuration.Replace(' ',''))</BUILD_ALT_DIR>
-    <IntDir Condition="'$(Platform)'!='Win32'">$(BUILD_ALT_DIR)\$(Platform)\</IntDir>
-    <IntDir Condition="'$(Platform)'=='Win32'">$(BUILD_ALT_DIR)\x86\</IntDir>
-    <OutDir>$(IntDir)</OutDir>
-  </PropertyGroup>
-  <ImportGroup Label="PreConfiguration">
-    <Import Project="$(VCTargetsPath)\WDKConversion\PreConfiguration.props" />
-  </ImportGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{B019D202-420C-484D-9303-45B552A05B95}</ProjectGuid>
-    <RootNamespace>$(MSBuildProjectName)</RootNamespace>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|Win32'">
-    <TargetVersion>WindowsV6.3</TargetVersion>
-    <UseDebugLibraries>True</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'">
-    <TargetVersion>Win8</TargetVersion>
-    <UseDebugLibraries>True</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'">
-    <TargetVersion>Win7</TargetVersion>
-    <UseDebugLibraries>True</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|Win32'">
-    <TargetVersion>WindowsV6.3</TargetVersion>
-    <UseDebugLibraries>False</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'">
-    <TargetVersion>Win8</TargetVersion>
-    <UseDebugLibraries>False</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'">
-    <TargetVersion>Win7</TargetVersion>
-    <UseDebugLibraries>False</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|x64'">
-    <TargetVersion>WindowsV6.3</TargetVersion>
-    <UseDebugLibraries>True</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'">
-    <TargetVersion>Win8</TargetVersion>
-    <UseDebugLibraries>True</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'">
-    <TargetVersion>Win7</TargetVersion>
-    <UseDebugLibraries>True</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|x64'">
-    <TargetVersion>WindowsV6.3</TargetVersion>
-    <UseDebugLibraries>False</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'">
-    <TargetVersion>Win8</TargetVersion>
-    <UseDebugLibraries>False</UseDebugLibraries>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'">
-    <TargetVersion>Win7</TargetVersion>
-    <UseDebugLibraries>False</UseDebugLibraries>
-  </PropertyGroup>
-  <!-- Needed by any VcxProj -->
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <!-- The WrappedTaskItems label is used by the conversion tool to identify the location where items 
-        associated with wrapped tasks will reside.-->
-  <ItemGroup Label="WrappedTaskItems">
-    <Inf Include="vpcd.inx">
-      <Architecture>$(_BUILDARCH)</Architecture>
-      <SpecifyArchitecture>true</SpecifyArchitecture>
-      <KmdfVersionNumber>1.9</KmdfVersionNumber>
-      <UmdfVersionNumber>1.9.0</UmdfVersionNumber>
-      <CopyOutput>$(OBJ_PATH)\$(O)\vpcd.inf</CopyOutput>
-    </Inf>
-  </ItemGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\src\vpcd;%(AdditionalIncludeDirectories);$(Includes);$(User_Includes)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <!-- We only add items (e.g. form ClSourceFiles) that do not already exist (e.g in the ClCompile list), this avoids duplication -->
-    <ClCompile Include="..\..\src\vpcd\vpcd.c" />
-    <ClCompile Include="@(ClSourceFiles)" Exclude="@(ClCompile)" />
-    <ResourceCompile Include="@(RcSourceFiles)" Exclude="@(ResourceCompile)" />
-    <Midl Include="@(IdlSourceFiles)" Exclude="@(Midl)" />
-    <MessageCompile Include="@(McSourceFiles)" Exclude="@(MessageCompile)" />
-    <MASM Include="@(AsmSourceFiles)" Exclude="@(MASM)" />
-    <GenerateBmf Include="@(MofSourceFiles)" Exclude="@(GenerateBmf)" />
-  </ItemGroup>
-  <!-- Set default environment variables, e.g. for stampinf -->
-  <ItemGroup>
-    <BuildMacro Include="SDK_INC_PATH">
-      <Value>$(KIT_SHARED_INC_PATH)</Value>
-      <EnvironmentVariable>true</EnvironmentVariable>
-    </BuildMacro>
-  </ItemGroup>
-  <ItemGroup>
-    <Inf Exclude="@(Inf)" Include="$(DDK_INF_FILES)" />
-    <Inf Exclude="@(Inf)" Include="*.inf" />
-    <FilesToPackage Include="$(TargetPath)" Condition="'$(ConfigurationType)'=='Driver' or '$(ConfigurationType)'=='DynamicLibrary'" />
-    <FilesToPackage Include="$(DDK_PACKAGE_FILES)" />
-  </ItemGroup>
-  <!-- Necessary to pick up propper files from local directory when in the IDE-->
-  <ItemGroup>
-    <None Exclude="@(None)" Include="*.txt;*.htm;*.html" />
-    <None Exclude="@(None)" Include="*.ico;*.cur;*.bmp;*.dlg;*.rct;*.gif;*.jpg;*.jpeg;*.wav;*.jpe;*.tiff;*.tif;*.png;*.rc2" />
-    <None Exclude="@(None)" Include="*.def;*.bat;*.hpj;*.asmx" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Exclude="@(ClInclude)" Include="*.h;*.hpp;*.hxx;*.hm;*.inl;*.xsd" />
-    <ClInclude Include="..\..\src\vpcd\vpcd.h" />
-  </ItemGroup>
-  <!-- /Necessary to pick up propper files from local directory when in the IDE-->
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-</Project>