buslib.cpp

InsProDisk.Partial.Src.rar 一个虚拟硬盘的源代码

#include "stdafx.h"
#include <windows.h>
#include "buslib.h"
#include <string.h>
#include <initguid.h>
#include <winioctl.h>
#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);
}