www.pudn.com > InsProDisk.Partial.Src.rar > BusLIb.cpp

#include "stdafx.h" 
#include  
#include "buslib.h" 
#include  
#include  
#include  
#include "../SDBUSGUID.H" 
#include "../SDBUSCMD.H" 
 
static void Err(char *s) 
{ 
	MessageBox(0,s,"Error!",MB_OK|MB_ICONERROR); 
} 
 
HANDLE 
__stdcall 
SDBusOpen() 
{ 
	LPBUSHANDLE BusHandle= new BUSHANDLE; 
 
	// 
	//Allocate the handle buffer 
	// 
	if (!BusHandle) 
	{ 
		return INVALID_HANDLE_VALUE; 
	} 
 
	// 
	//Get all device that support GUID_SDBUS_BUS_INTERFACE 
	// 
    BusHandle->hardwareDeviceInfo = SetupDiGetClassDevs( 
		(LPGUID)&GUID_SDBUS_BUS_INTERFACE, 
		NULL, // Define no enumerator (global) 
		NULL, // Define no 
		(DIGCF_PRESENT |DIGCF_INTERFACEDEVICE) 
		); 
	if(INVALID_HANDLE_VALUE == BusHandle->hardwareDeviceInfo) 
	{ 
		Err("SetupDiGetClassDevs failed\n"); 
		return INVALID_HANDLE_VALUE; 
	} 
 
	// 
	//pick out the first device support interface for SDBUS 
	// 
	BusHandle->deviceInterfaceData.cbSize = sizeof (SP_INTERFACE_DEVICE_DATA); 
	if (!SetupDiEnumDeviceInterfaces(BusHandle->hardwareDeviceInfo, 
		0, // No care about specific PDOs 
		(LPGUID)&GUID_SDBUS_BUS_INTERFACE, 
		0, // 
		&BusHandle->deviceInterfaceData)) 
	{ 
		SetupDiDestroyDeviceInfoList(BusHandle->hardwareDeviceInfo); 
		delete BusHandle; 
		return INVALID_HANDLE_VALUE; 
	} 
 
	PSP_INTERFACE_DEVICE_DETAIL_DATA deviceInterfaceDetailData; 
	ULONG predictedLength = 100000; 
	ULONG requiredLength; 
 
	// 
	//Get the WIN32 link name for BUS interface 
	// 
	SetupDiGetInterfaceDeviceDetail ( 
		BusHandle->hardwareDeviceInfo, 
		&BusHandle->deviceInterfaceData, 
		NULL, // probing so no output buffer yet 
		0, // probing so output buffer length of zero 
		&requiredLength, 
		NULL); 
	predictedLength = requiredLength; 
	deviceInterfaceDetailData = (PSP_INTERFACE_DEVICE_DETAIL_DATA)new char[predictedLength]; 
	deviceInterfaceDetailData->cbSize = sizeof (SP_INTERFACE_DEVICE_DETAIL_DATA); 
	if (! SetupDiGetInterfaceDeviceDetail ( 
		BusHandle->hardwareDeviceInfo, 
		&BusHandle->deviceInterfaceData, 
		deviceInterfaceDetailData, 
		predictedLength, 
		&requiredLength, 
		NULL)) 
	{ 
		Err("Error in SetupDiGetInterfaceDeviceDetail\n"); 
		delete deviceInterfaceDetailData; 
		SetupDiDestroyDeviceInfoList(BusHandle->hardwareDeviceInfo); 
		delete BusHandle; 
		return INVALID_HANDLE_VALUE; 
	} 
 
	// 
	//Open the handle to device 
	// 
	BusHandle->hBusInterface = CreateFile ( deviceInterfaceDetailData->DevicePath, 
		GENERIC_READ | GENERIC_WRITE, 
		0, // FILE_SHARE_READ | FILE_SHARE_WRITE 
		NULL, // no SECURITY_ATTRIBUTES structure 
		OPEN_EXISTING, // No special create flags 
		0, // No special attributes 
		NULL); // No template file 
 
	if (INVALID_HANDLE_VALUE == BusHandle->hBusInterface) 
	{ 
		Err("Device not ready!"); 
		delete deviceInterfaceDetailData; 
		SetupDiDestroyDeviceInfoList(BusHandle->hardwareDeviceInfo); 
		delete BusHandle; 
		return INVALID_HANDLE_VALUE; 
	} 
	 
	delete deviceInterfaceDetailData; 
	 
	return (HANDLE)BusHandle; 
} 
 
VOID 
__stdcall 
SDBusClose(HANDLE handle) 
{ 
	LPBUSHANDLE BusHandle= (LPBUSHANDLE)handle; 
	CloseHandle(BusHandle->hBusInterface); 
	SetupDiDestroyDeviceInfoList(BusHandle->hardwareDeviceInfo); 
	delete BusHandle; 
} 
 
LONG 
__stdcall 
SDBusCreateDisk(HANDLE handle,char *FileName,ULONG BlockCount) 
{ 
	HANDLE hvdisk; 
	DWORD attr; 
 
	LARGE_INTEGER li; 
 
	// 
	//Create the file 
	// 
	hvdisk = CreateFile(FileName,GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,0); 
	if (hvdisk == INVALID_HANDLE_VALUE) 
	{ 
		return -1; 
	} 
	//WriteFile(hvdisk,"1",1,&attr,0); 
	CloseHandle(hvdisk); 
 
	attr = GetFileAttributes(FileName); 
 
	hvdisk = CreateFile(FileName,GENERIC_WRITE|GENERIC_READ,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,0); 
	if (hvdisk == INVALID_HANDLE_VALUE) 
	{ 
		return -1; 
	} 
 
	if (attr & FILE_ATTRIBUTE_COMPRESSED) 
	{ 
		USHORT cmpr = COMPRESSION_FORMAT_NONE; 
		if (!DeviceIoControl(hvdisk,FSCTL_SET_COMPRESSION,&cmpr,sizeof(cmpr),NULL,0,&attr,0)) 
		{ 
			Err("Can't change file attributes\n"); 
			CloseHandle(hvdisk); 
			return -1; 
		} 
	} 
 
	li.QuadPart = ((__int64)BlockCount/0x3f/0xff + 2)*0x3f*0xff*512; 
 
	if ( INVALID_SET_FILE_POINTER == SetFilePointer(hvdisk,li.LowPart,&li.HighPart,FILE_BEGIN)) 
	{ 
		Err("Create disk image error\n"); 
		CloseHandle(hvdisk); 
		return -1; 
	} 
	if (!SetEndOfFile(hvdisk)) 
	{ 
		Err("Create disk image error when enlarge the image file\n"); 
		CloseHandle(hvdisk); 
		return -1; 
	} 
	CloseHandle(hvdisk); 
 
	return 0; 
} 
 
LONG __stdcall SDBusPlugInDisk(HANDLE handle,char *FileName) 
{ 
	LPBUSHANDLE BusHandle= (LPBUSHANDLE)handle; 
	HANDLE hvdisk; 
	I_PLUGIN plugindev = {0}; 
	ULARGE_INTEGER li; 
	ULONG SlotNum; 
	DWORD dw; 
	DWORD attr; 
 
	hvdisk = CreateFile(FileName,GENERIC_WRITE|GENERIC_READ,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0); 
	if (hvdisk == INVALID_HANDLE_VALUE) 
	{ 
		return -1; 
	} 
	li.LowPart = GetFileSize(hvdisk,&li.HighPart); 
 
	attr = GetFileAttributes(FileName); 
 
	CloseHandle(hvdisk); 
 
	if (attr & FILE_ATTRIBUTE_COMPRESSED) 
	{ 
		Err("Don't use file compress to Vitrual Disk Image\n"); 
		return -1; 
	} 
 
	wcscpy(plugindev.DEVICE_ID,L"SDBUS\\DISK"); 
	wcscpy(plugindev.DeviceDesc,L"Secu-X bus Disk"); 
	plugindev.VirtualDiskInfo.VitualHDDBlockCount = li.QuadPart/512; 
	swprintf(plugindev.VirtualDiskInfo.VitualHDDFileName,L"%S",FileName); 
	if (!DeviceIoControl(BusHandle->hBusInterface, 
		IOCTL_SECUXBUS_PLUGIN_HARDWARE, 
		&plugindev,sizeof(plugindev), 
		&SlotNum,sizeof(SlotNum),&dw,0)) 
	{ 
		Err("IOCTL_SECUXBUS_PLUGIN_HARDWARE failed\n"); 
		return -1; 
	} 
	return SlotNum; 
} 
 
LONG __stdcall SDBusUnPlugDisk(HANDLE handle,LONG SlotNum) 
{ 
	LPBUSHANDLE BusHandle= (LPBUSHANDLE)handle; 
	DWORD dw; 
 
	if (!DeviceIoControl(BusHandle->hBusInterface,IOCTL_SECUXBUS_EJECT_HARDWARE,&SlotNum,sizeof(SlotNum),0,0,&dw,0)) 
	{ 
		Err("IOCTL_SECUXBUS_EJECT_HARDWARE failed\n"); 
		return -1; 
	} 
	return 0; 
} 
 
LONG __stdcall SDBusGetList(HANDLE handle,void *Buffer,ULONG cbBuffer) 
{ 
	LPBUSHANDLE BusHandle= (LPBUSHANDLE)handle; 
	DWORD dw; 
	if (!DeviceIoControl(BusHandle->hBusInterface,IOCTL_SECUBUS_GET_HARDWARE_LIST,0,0,Buffer,cbBuffer,&dw,0)) 
	{ 
		return 0; 
	} 
	return dw/sizeof(I_GET_LIST); 
}