DLL for USB interaction ( Warning: Lengthy code)

See more:

C++

Hi, it's me and my problematic USB DLL again. I'm trying to create a DLL for USB interaction. This time i'm bumping into Run Time Check Error 0. This DLL exports abstract interface class for client. I hope this is the final push. Apologies for the lengthy code. I'm posting all of it since i assume you need the get whole picture:

//Bikedll.h 
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>	//Definitions for various common and not so common types like DWORD, PCHAR, HANDLE, etc.
#include <Dbt.h>		//Need this for definitions of WM_DEVICECHANGE messages
#include <setupapi.h>	
#include <string>
#include "AbstrClass.h"

using namespace std;

#define Cihaz_ID  "Vid_a0a1&Pid_4147"	 
#define __YAZI__ "Esetron USB Kart V1.0"

typedef GUID* LPGUID; 

typedef HDEVINFO ( *SetupDiGetClassDevsUMPTR)(LPGUID, PCTSTR, HWND, DWORD);
typedef WINSETUPAPI BOOL ( *SetupDiEnumDeviceInterfacesUMPTR)(HDEVINFO, PSP_DEVINFO_DATA, LPGUID, DWORD, PSP_DEVICE_INTERFACE_DATA);
typedef WINSETUPAPI BOOL ( *SetupDiDestroyDeviceInfoListUMPTR)(HDEVINFO);
typedef WINSETUPAPI BOOL ( *SetupDiEnumDeviceInfoUMPTR)(HDEVINFO, DWORD, PSP_DEVINFO_DATA);
typedef WINSETUPAPI BOOL ( *SetupDiGetDeviceRegistryPropertyUMPTR)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD);
typedef WINSETUPAPI BOOL ( *SetupDiSetDeviceRegistryPropertyUMPTR)(HDEVINFO, PSP_DEVINFO_DATA, DWORD, const BYTE*, DWORD);
typedef BOOL ( *SetupDiGetDeviceInterfaceDetailUMPTR)(HDEVINFO, PSP_DEVICE_INTERFACE_DATA, PSP_DEVICE_INTERFACE_DETAIL_DATA, DWORD, PDWORD, PSP_DEVINFO_DATA);
typedef HDEVNOTIFY ( *RegisterDeviceNotificationUMPTR)(HANDLE, LPVOID, DWORD);

//Globally Unique Identifier (GUID) for HID class devices.  Windows uses GUIDs to identify things.
GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, 0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30}; 

//USB variables
BOOL AttachedState = false;		
BOOL AttachedButBroken = false;					
PSP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure = new SP_DEVICE_INTERFACE_DETAIL_DATA;
HANDLE WriteHandleToUSBDevice = INVALID_HANDLE_VALUE;
HANDLE ReadHandleToUSBDevice = INVALID_HANDLE_VALUE;

unsigned char LED_durum = 0;
HANDLE  EP1INHandle = INVALID_HANDLE_VALUE;
HANDLE  EP1OUTHandle = INVALID_HANDLE_VALUE;
bool durum = false;
		
unsigned char gond_paket[65];	//Number of elements, including '/0'
unsigned char gelen_paket[65];	 	
DWORD Gond_say;				
DWORD Gelen_say;

class Bikedll : public AbstrClass
{
public:		
		SetupDiGetClassDevsUMPTR _SetupDiGetClassDevsUMPTR;
		SetupDiEnumDeviceInterfacesUMPTR _SetupDiEnumDeviceInterfacesUMPTR;
		SetupDiDestroyDeviceInfoListUMPTR _SetupDiDestroyDeviceInfoListUMPTR;
		SetupDiEnumDeviceInfoUMPTR _SetupDiEnumDeviceInfoUMPTR;
		SetupDiGetDeviceRegistryPropertyUMPTR _SetupDiGetDeviceRegistryPropertyUMPTR;
		SetupDiSetDeviceRegistryPropertyUMPTR _SetupDiSetDeviceRegistryPropertyUMPTR;
		SetupDiGetDeviceInterfaceDetailUMPTR _SetupDiGetDeviceInterfaceDetailUMPTR;
		RegisterDeviceNotificationUMPTR _RegisterDeviceNotificationUMPTR;

		DWORD ErrorStatusWrite;
		DWORD ErrorStatusRead;

		//Explicit Linking
		HINSTANCE hSetUpApi; 
		HINSTANCE hUser32;

		string get_POT();
		string get_RPM();

		Bikedll();
		BOOL CheckIfPresentAndGetUSBDevicePath(void)
		{
			HDEVINFO DeviceInfoTable = INVALID_HANDLE_VALUE;
			PSP_DEVICE_INTERFACE_DATA InterfaceDataStructure = new SP_DEVICE_INTERFACE_DATA;
			SP_DEVINFO_DATA DevInfoData;

			DWORD InterfaceIndex = 0;
			DWORD StatusLastError = 0;
			DWORD dwRegType;
			DWORD dwRegSize;
			DWORD StructureSize = 0;
			PBYTE PropertyValueBuffer;
			bool MatchFound = false;
			DWORD ErrorStatus;
			BOOL BoolStatus = FALSE;
			DWORD LoopCounter = 0;

			string DeviceIDToFind = Cihaz_ID;   
			//First populate a list of plugged in devices (by specifying "DIGCF_PRESENT"), which are of the specified class GUID. 
			DeviceInfoTable = _SetupDiGetClassDevsUMPTR(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE); // Run Time Check Error 0 (AKA RTCE 0) type of errors start here
			
			//Now look through the list we just populated.  We are trying to see if any of them match our device. 
			while(true)
			{																			
				InterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
				if(_SetupDiEnumDeviceInterfacesUMPTR(DeviceInfoTable, NULL, &InterfaceClassGuid, InterfaceIndex, InterfaceDataStructure)) //RTCE 0
				{
					ErrorStatus = GetLastError();
					if(ERROR_NO_MORE_ITEMS == GetLastError())	//Did we reach the end of the list of matching devices in the DeviceInfoTable?
					{	//Cound not find the device.  Must not have been attached.
						_SetupDiDestroyDeviceInfoListUMPTR(DeviceInfoTable);	//Clean up the old structure we no longer need. Still RTCE 0
						return FALSE;		
					}
				}
			else	//Else some other kind of unknown error ocurred...
			{
				ErrorStatus = GetLastError();
				_SetupDiDestroyDeviceInfoListUMPTR(DeviceInfoTable);	//Clean up the old structure we no longer need. RTCE 0
				return FALSE;	
			}
			//Now retrieve the hardware ID from the registry.  The hardware ID contains the VID and PID, which we will then 
			//check to see if it is the correct device or not.

			//Initialize an appropriate SP_DEVINFO_DATA structure.  We need this structure for SetupDiGetDeviceRegistryProperty().
			DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
			_SetupDiEnumDeviceInfoUMPTR(DeviceInfoTable, InterfaceIndex, &DevInfoData); //RTCE 0

			//First query for the size of the hardware ID, so we can know how big a buffer to allocate for the data.
			_SetupDiGetDeviceRegistryPropertyUMPTR(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID, &dwRegType, NULL, 0, &dwRegSize); //RTCE 0

			//Allocate a buffer for the hardware ID.
			PropertyValueBuffer = (BYTE *) malloc (dwRegSize);
			if(PropertyValueBuffer == NULL)	//if null, error, couldn't allocate enough memory
			{	//Can't really recover from this situation, just exit instead.
				_SetupDiDestroyDeviceInfoListUMPTR(DeviceInfoTable);	//Clean up the old structure we no longer need. RTCE 0
				return FALSE;		
			}

			//Retrieve the hardware IDs for the current device we are looking at.  PropertyValueBuffer gets filled with a 
			//REG_MULTI_SZ (array of null terminated strings).  To find a device, we only care about the very first string in the
			//buffer, which will be the "device ID".  The device ID is a string which contains the VID and PID, in the example 
			//format "Vid_04d8&Pid_003f".
			_SetupDiGetDeviceRegistryPropertyUMPTR(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID, &dwRegType, PropertyValueBuffer, dwRegSize, NULL); // RTCE 0

			//Now check if the first string in the hardware ID matches the device ID of my USB device.
			string* DeviceIDFromRegistry = new string((char *)PropertyValueBuffer);
			free(PropertyValueBuffer);		//No longer need the PropertyValueBuffer, free the memory to prevent potential memory leaks

			//Now check if the hardware ID we are looking at contains the correct VID/PID
			if (std::string::npos != DeviceIDFromRegistry->find(DeviceIDToFind))
			{
				MatchFound = true;
			}
			if(MatchFound == true)
			{
				//Device must have been found.  Open WinUSB interface handle now.  In order to do this, we will need the actual device path first.
				//We can get the path by calling SetupDiGetDeviceInterfaceDetail(), however, we have to call this function twice:  The first
				//time to get the size of the required structure/buffer to hold the detailed interface data, then a second time to actually 
				//get the structure (after we have allocated enough memory for the structure.)
				DetailedInterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
				//First call populates "StructureSize" with the correct value
				_SetupDiGetDeviceInterfaceDetailUMPTR(DeviceInfoTable, InterfaceDataStructure, NULL, NULL, &StructureSize, NULL);	
				DetailedInterfaceDataStructure = (PSP_DEVICE_INTERFACE_DETAIL_DATA)(malloc(StructureSize));		//Allocate enough memory
				if(DetailedInterfaceDataStructure == NULL)	//if null, error, couldn't allocate enough memory
				{	//Can't really recover from this situation, just exit instead.
					_SetupDiDestroyDeviceInfoListUMPTR(DeviceInfoTable);	//Clean up the old structure we no longer need.
					return FALSE;		
				}
				DetailedInterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
				//Now call SetupDiGetDeviceInterfaceDetail() a second time to receive the goods.  
				_SetupDiGetDeviceInterfaceDetailUMPTR(DeviceInfoTable, InterfaceDataStructure, DetailedInterfaceDataStructure, StructureSize, NULL, NULL); 
				// Set Device Name
				BYTE *pbuf = new BYTE[sizeof(TEXT(__YAZI__))];
				pbuf = (BYTE*)TEXT(__YAZI__);
				_SetupDiSetDeviceRegistryPropertyUMPTR(DeviceInfoTable, &DevInfoData, SPDRP_FRIENDLYNAME , pbuf, sizeof(TEXT(__YAZI__)));
				
				//We now have the proper device path, and we can finally open a device handle to the device.
				//WinUSB requires the device handle to be opened with the FILE_FLAG_OVERLAPPED attribute.
				_SetupDiDestroyDeviceInfoListUMPTR(DeviceInfoTable);	//Clean up the old structure we no longer need.
				return TRUE;
			}

				InterfaceIndex++;	
				//Keep looping until we either find a device with matching VID and PID, or until we run out of devices to check.
				//However, just in case some unexpected error occurs, keep track of the number of loops executed.
				//If the number of loops exceeds a very large number, exit anyway, to prevent inadvertent infinite looping.				
				LoopCounter++;
				if(LoopCounter == 10000000)	//Surely there aren't more than 10 million devices attached to any forseeable PC...
				{
					return FALSE;
				}
			}
			
		}
	
protected:
	/// <summary>
	/// Clean up any resources being used.
	/// </summary>
	~Bikedll()
	{
		//Close the read/write handles, if they are currently open.
		if(AttachedState == TRUE)
		{
			CloseHandle(WriteHandleToUSBDevice);
			CloseHandle(ReadHandleToUSBDevice);
		}
	}

};


string Bikedll::get_RPM(){
		gond_paket[0] = 0;		
		gond_paket[1] = 160;
		gond_paket[2] = 0;
		gond_paket[3] = 0;
		
		string str;

		for(unsigned char i = 4; i <65; i++)
			gond_paket[i] = 0xFF;

		WriteFile(WriteHandleToUSBDevice, &gond_paket, 65, &Gond_say, 0);

		if (ReadFile(ReadHandleToUSBDevice,&gelen_paket,65,&Gelen_say,0))
		{
			if (gelen_paket[1] == 0xBA)
			{
				return str = gelen_paket[3];
			}
		}
}
string	Bikedll::get_POT(){
		gond_paket[0] = 0;		
		gond_paket[1] = 160;
		gond_paket[2] = 0;
		gond_paket[3] = 0;
							 
		string str;

		for(unsigned char i = 4; i <65; i++)
			gond_paket[i] = 0xFF;

		WriteFile(WriteHandleToUSBDevice, &gond_paket, 65, &Gond_say, 0);
		
		if (ReadFile(ReadHandleToUSBDevice,&gelen_paket,65,&Gelen_say,0))
		{
			if (gelen_paket[1] == 0xBA)
			{
				return str = gelen_paket[5];
			}
		}
}


Bikedll::Bikedll(){
	hSetUpApi = LoadLibrary("setupapi.dll");
	hUser32 = LoadLibrary("user32.dll");

	_SetupDiGetClassDevsUMPTR = (SetupDiGetClassDevsUMPTR)GetProcAddress(hSetUpApi, "SetupDiGetClassDevsA");
	_SetupDiEnumDeviceInterfacesUMPTR = (SetupDiEnumDeviceInterfacesUMPTR)GetProcAddress(hSetUpApi, "SetupDiEnumDeviceInterfaces");
	_SetupDiDestroyDeviceInfoListUMPTR = (SetupDiDestroyDeviceInfoListUMPTR)GetProcAddress(hSetUpApi, "SetupDiDestroyDeviceInfoList");
	_SetupDiEnumDeviceInfoUMPTR = (SetupDiEnumDeviceInfoUMPTR)GetProcAddress(hSetUpApi, "SetupDiEnumDeviceInfo");
	_SetupDiGetDeviceRegistryPropertyUMPTR = (SetupDiGetDeviceRegistryPropertyUMPTR)GetProcAddress(hSetUpApi, "SetupDiGetDeviceRegistryPropertyA");
	_SetupDiSetDeviceRegistryPropertyUMPTR = (SetupDiSetDeviceRegistryPropertyUMPTR)GetProcAddress(hSetUpApi, "SetupDiSetDeviceRegistryPropertyA");
	_SetupDiGetDeviceInterfaceDetailUMPTR = (SetupDiGetDeviceInterfaceDetailUMPTR)GetProcAddress(hSetUpApi, "SetupDiGetDeviceInterfaceDetailA");

	DEV_BROADCAST_DEVICEINTERFACE MyDeviceBroadcastHeader;// = new DEV_BROADCAST_HDR;
	MyDeviceBroadcastHeader.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
	MyDeviceBroadcastHeader.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
	MyDeviceBroadcastHeader.dbcc_reserved = 0;	//Reserved says not to use...
	MyDeviceBroadcastHeader.dbcc_classguid = InterfaceClassGuid;

	if(CheckIfPresentAndGetUSBDevicePath())	//Look for the device
	{
		DWORD ErrorStatusWrite;
		DWORD ErrorStatusRead;

		WriteHandleToUSBDevice = CreateFile(DetailedInterfaceDataStructure->DevicePath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
		ErrorStatusWrite = GetLastError();
		ReadHandleToUSBDevice = CreateFile(DetailedInterfaceDataStructure->DevicePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
		ErrorStatusRead = GetLastError();

		if((ErrorStatusWrite == ERROR_SUCCESS) && (ErrorStatusRead == ERROR_SUCCESS))
		{
			AttachedState = TRUE;		
			AttachedButBroken = FALSE;
			//okay
		}

		else //reading or writing operations failed
		{
			AttachedState = FALSE;		
			AttachedButBroken = TRUE;	
			if(ErrorStatusWrite == ERROR_SUCCESS)//Açık bağlantıları kapat
				CloseHandle(WriteHandleToUSBDevice);
			if(ErrorStatusRead == ERROR_SUCCESS)
				CloseHandle(ReadHandleToUSBDevice);
		    //err1();					 
		}
	}
	else	
	{
		AttachedState = FALSE;
		AttachedButBroken = FALSE;
		//err2();
	}
}

//Interface to be exported with usable virtual functions
//#include <string>

class AbstrClass{
public:
	virtual std::string get_POT() = 0;
	virtual std::string get_RPM() = 0;
};

// Bikedll.cpp : Defines the exported functions for the DLL application.
//

#include "stdafx.h"
#include "Bikedll.h"

extern "C" __declspec(dllexport) AbstrClass* __cdecl create_AbstrClass()
{
    return new Bikedll;
}

// TestdllBike.cpp : Program to test Bikedll
//
#include "stdafx.h"
#include "AbstrClass.h"

#include <Windows.h>
#include <iostream>

using namespace std;

typedef AbstrClass* (__cdecl *abstrClass_factory)();

int main()
{
	HINSTANCE dll_handle = ::LoadLibrary(TEXT("Bikedll.dll"));
	if(!dll_handle){
		cerr << "Installation failed!";
		return 1;
	}
	
	abstrClass_factory factory_func = reinterpret_cast<abstrClass_factory>(::GetProcAddress(dll_handle, "create_AbstrClass"));

	if (!factory_func) {
        cerr << "function was not imported from dll!\n";
        ::FreeLibrary(dll_handle);
        return 1;
    }

	AbstrClass* instance = factory_func();

	string t = instance->get_POT();
	cout <<	"POT : " << t << endl;
	string v = instance->get_RPM();
	cout << "RPM : " << v << endl;

	return 0;
}