基于visual c++之windows核心编程代码分析（24）IO控制、内核通信

我们在进行Windows编程的时候，经常需要进行IO控制与内核通信，我们来实现IO控制与内核通信。请见代码实现与注释讲解

 

驱动代码实现与分析

/* 头文件 */
#include <ntddk.h>// 包括了很多NT内核的类型、结构、函数定义，开发驱动时需要包括此头文件
#include <string.h>
#include "xioctl.h"
/* 常量与预定义 */
#define NT_DEVICE_NAME      L"\\Device\\XIOCTL"
#define DOS_DEVICE_NAME     L"\\DosDevices\\IoctlTest"

#if DBG
#define XIOCTL_KDPRINT(_x_) \
                DbgPrint("XIOCTL.SYS: ");\
                DbgPrint _x_;
#else
#define XIOCTL_KDPRINT(_x_)
#endif 

/* 函数声明 */
NTSTATUS DriverEntry(PDRIVER_OBJECT  DriverObject, PUNICODE_STRING RegistryPath);
NTSTATUS XioctlCreateClose(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS XioctlDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp );
VOID XioctlUnloadDriver(PDRIVER_OBJECT DriverObject );
VOID PrintIrpInfo( PIRP Irp );
VOID PrintChars( PCHAR BufferAddress, ULONG CountChars );

#ifdef ALLOC_PRAGMA
#pragma alloc_text( INIT, DriverEntry )
#pragma alloc_text( PAGE, XioctlCreateClose)
#pragma alloc_text( PAGE, XioctlDeviceControl)
#pragma alloc_text( PAGE, XioctlUnloadDriver)
#pragma alloc_text( PAGE, PrintIrpInfo)
#pragma alloc_text( PAGE, PrintChars)
#endif // ALLOC_PRAGMA


/*************************************
* DriverEntry
* 功能	驱动的入口函数，分配了相关处理例程
**************************************/
NTSTATUS
DriverEntry(
    IN OUT PDRIVER_OBJECT   DriverObject,
    IN PUNICODE_STRING      RegistryPath
    )
{
    NTSTATUS        ntStatus;
    UNICODE_STRING  ntUnicodeString;    // 设备名
    UNICODE_STRING  ntWin32NameString;    // Win32 设备名
    PDEVICE_OBJECT  deviceObject = NULL;    // 设备对象


    RtlInitUnicodeString( &ntUnicodeString, NT_DEVICE_NAME );
    // 创建设备
    ntStatus = IoCreateDevice(
        DriverObject,                   // 驱动对象 DriverEntry 的参数
        0,                              // 不使用设备扩展
        &ntUnicodeString,               // 设备名 "\Device\XIOCTL"
        FILE_DEVICE_UNKNOWN,            // 设备类型
        FILE_DEVICE_SECURE_OPEN,   		  // 
        FALSE,                          // 
        &deviceObject );                // 设备对象

    if ( !NT_SUCCESS( ntStatus ) )
    {
        XIOCTL_KDPRINT(("Couldn't create the device object\n"));
        return ntStatus;
    }
    // 初始化处理例程
    DriverObject->MajorFunction[IRP_MJ_CREATE] = XioctlCreateClose;// 创建时会调用
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = XioctlCreateClose;// 关闭时会调用
    // 处理IO控制
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = XioctlDeviceControl;
    DriverObject->DriverUnload = XioctlUnloadDriver;// 卸载时会调用
   
    // WIN32 设备名
    RtlInitUnicodeString( &ntWin32NameString, DOS_DEVICE_NAME );

    // 在设备名和WIN32设备名之间创建符号连接
    ntStatus = IoCreateSymbolicLink(
                        &ntWin32NameString, &ntUnicodeString );

    if ( !NT_SUCCESS( ntStatus ) )
    {
        XIOCTL_KDPRINT(("Couldn't create symbolic link\n"));
        IoDeleteDevice( deviceObject );
    }

    return ntStatus;
}

/*************************************
* XioctlCreateClose
* 功能	驱动对象的处理例程，由DriverEntry指定
*				本函数中驱动对象在创建和关闭时调用的例程。
*				没有实际的功能，只是将状态设置为 成功
**************************************/
NTSTATUS
XioctlCreateClose(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

{
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    
    IoCompleteRequest( Irp, IO_NO_INCREMENT );
    
    return STATUS_SUCCESS;
}

/*************************************
* XioctlUnloadDriver
* 功能	卸载驱动时调用的例程，
*       删除符号连接，删除设备
**************************************/
VOID
XioctlUnloadDriver(
    IN PDRIVER_OBJECT DriverObject
    )

{
    PDEVICE_OBJECT deviceObject = DriverObject->DeviceObject;
    UNICODE_STRING uniWin32NameString;

    RtlInitUnicodeString( &uniWin32NameString, DOS_DEVICE_NAME );


    // 删除符号连接    
    IoDeleteSymbolicLink( &uniWin32NameString );
    // 删除设备
    if ( deviceObject != NULL )
    {
        IoDeleteDevice( deviceObject );
    }
}

/*************************************
* XioctlDeviceControl
* 功能	处理IO控制的例程
**************************************/
NTSTATUS
XioctlDeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
{
    PIO_STACK_LOCATION  irpSp;// 当前栈的位置
    NTSTATUS            ntStatus = STATUS_SUCCESS;// 执行状态，成功\失败
    ULONG               inBufLength; // 输入缓存大小
    ULONG               outBufLength; // 输出缓存大小
    PCHAR               inBuf, outBuf; // 输入输出缓存
    PCHAR               data = "This String is from Device Driver !!!";
    ULONG               datalen = strlen(data)+1;//输出数据的长度
    PMDL                mdl = NULL;
    PCHAR               buffer = NULL;  

		// 处理IRP
    irpSp = IoGetCurrentIrpStackLocation( Irp );
    inBufLength = irpSp->Parameters.DeviceIoControl.InputBufferLength;
    outBufLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength;

    if(!inBufLength || !outBufLength)
    {
        ntStatus = STATUS_INVALID_PARAMETER;
        goto End;
    }

    // 判断IOCTL
    switch ( irpSp->Parameters.DeviceIoControl.IoControlCode )
    {
    case IOCTL_XIOCTL_BUFFER: 
    		// 显示收到的IRP
        XIOCTL_KDPRINT(("Called IOCTL_SIOCTL_METHOD_BUFFERED\n")); 
        PrintIrpInfo(Irp);

        // 设备IN OUT 缓存
        inBuf = Irp->AssociatedIrp.SystemBuffer;
        outBuf = Irp->AssociatedIrp.SystemBuffer;

        // 从输入缓存中获得信息
        XIOCTL_KDPRINT(("\tData from User : %s", inBuf));
        // 复制数据到输出缓存
        strncpy(outBuf, data, outBufLength);
				// 打印输出输出缓存的内容
        XIOCTL_KDPRINT(("\tData to User : %s", outBuf));
        // 设置IRP 
        Irp->IoStatus.Information = (outBufLength<datalen?outBufLength:datalen);

       break;
		// 还可以定义其他IO 控制码
		
    default:

        // 处理其他示知的IO code
        ntStatus = STATUS_INVALID_DEVICE_REQUEST;
        XIOCTL_KDPRINT(("ERROR: unrecognized IOCTL %x\n",
            irpSp->Parameters.DeviceIoControl.IoControlCode));
        break;
    }

End:
    // 设备状态，完成IPR处理
    Irp->IoStatus.Status = ntStatus;
    IoCompleteRequest( Irp, IO_NO_INCREMENT );
    return ntStatus;
}

/*************************************
* PrintIrpInfo
* 功能	打印IPR信息
**************************************/
VOID
PrintIrpInfo(
    PIRP Irp)
{
    PIO_STACK_LOCATION  irpSp;
    irpSp = IoGetCurrentIrpStackLocation( Irp );

    XIOCTL_KDPRINT(("\tIrp->AssociatedIrp.SystemBuffer = 0x%p\n",
        Irp->AssociatedIrp.SystemBuffer)); 
    XIOCTL_KDPRINT(("\tIrp->UserBuffer = 0x%p\n", Irp->UserBuffer)); 
    XIOCTL_KDPRINT(("\tirpSp->Parameters.DeviceIoControl.Type3InputBuffer = 0x%p\n",
        irpSp->Parameters.DeviceIoControl.Type3InputBuffer)); 
    XIOCTL_KDPRINT(("\tirpSp->Parameters.DeviceIoControl.InputBufferLength = %d\n",
        irpSp->Parameters.DeviceIoControl.InputBufferLength)); 
    XIOCTL_KDPRINT(("\tirpSp->Parameters.DeviceIoControl.OutputBufferLength = %d\n",
        irpSp->Parameters.DeviceIoControl.OutputBufferLength )); 
    return;
}

实现加载与卸载驱动，

/* 头文件 */
#include <windows.h>
#include <winioctl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "..\sys\xioctl.h"
/* 全局变量 */
char OutputBuffer[100];
char InputBuffer[100];
/* 函数声明 */
BOOL InstallDriver( SC_HANDLE, LPCTSTR, LPCTSTR );
BOOL RemoveDriver( SC_HANDLE, LPCTSTR );
BOOL StartDriver( SC_HANDLE , LPCTSTR );
BOOL StopDriver( SC_HANDLE , LPCTSTR );

/*************************************
* InstallDriver
* 功能 创建服务、安装驱动
* 参数 SchSCManager，服务控制器句柄
*         DriverName，服务名
*         ServiceExe，驱动的可执行程序路径
**************************************/
BOOL InstallDriver(
				   SC_HANDLE SchSCManager,
				   LPCTSTR DriverName,
				   LPCTSTR ServiceExe
				   )
{
	SC_HANDLE schService;
	DWORD err;

	// 调用CreateService创建服务
	schService = CreateService(SchSCManager, // 服务控制器，SCM句柄
		DriverName, // 服务名
		DriverName, // 服务的显示名
		SERVICE_ALL_ACCESS, // 存取权限
		SERVICE_KERNEL_DRIVER, // 服务类型
		SERVICE_DEMAND_START, // 启动类型
		SERVICE_ERROR_NORMAL, // 启动错误的处理
		ServiceExe, // 可执行程序
		NULL, NULL, NULL, NULL, NULL
		);

	if (schService == NULL)
	{
		// 创建服务失败
		err = GetLastError();
		// 服务已经存在
		if (err == ERROR_SERVICE_EXISTS)
		{
			return TRUE;// 返回成功
		}
		else
		{
			// 输出错误信息，返回失败
			printf("CreateService failed! Error = %d \n", err );
			return FALSE;
		}
	}
	// 创建成功，关闭服务
	if (schService)
	{
		CloseServiceHandle(schService);
	}
	// 返回成功
	return TRUE;
}

/*************************************
* RemoveDriver
* 功能 删除驱动服务
* 参数 SchSCManager，服务控制器句柄
*         DriverName，服务名
**************************************/
BOOL RemoveDriver(
			 SC_HANDLE SchSCManager,
			 LPCTSTR DriverName
			 )
{
	SC_HANDLE schService;
	BOOLEAN rCode;

	// 打开服务
	schService = OpenService(SchSCManager,
		DriverName,
		SERVICE_ALL_ACCESS
		);

	if (schService == NULL)
	{
		// 服务打开失败
		printf("OpenService failed! Error = %d \n", GetLastError());
		return FALSE;
	}

	// 删除服务
	if (DeleteService(schService))
	{
		rCode = TRUE;
	} 
	else
	{
		//失败
		printf("DeleteService failed! Error = %d \n", GetLastError());
		rCode = FALSE;
	}

	// 关闭服务句柄
	if (schService)
	{
		CloseServiceHandle(schService);
	}
	return rCode;
}

/*************************************
* StartDriver
* 功能 起动服务，加载执行驱动
* 参数 SchSCManager，服务控制器句柄
*         DriverName，服务名
**************************************/
BOOL StartDriver(
			SC_HANDLE SchSCManager,
			LPCTSTR DriverName
			)
{
	SC_HANDLE schService;
	DWORD err;

	// 打开服务
	schService = OpenService(SchSCManager,
		DriverName,
		SERVICE_ALL_ACCESS
		);
	if (schService == NULL)
	{
		// 失败
		printf("OpenService failed! Error = %d \n", GetLastError());
		return FALSE;
	}

	// 启动服务
	if (!StartService(schService, // 服务句柄
		0, // 参数个数，无
		NULL // 参数指针，无
		))
	{
		// 启动失败
		err = GetLastError();
		// 已经开始运行
		if (err == ERROR_SERVICE_ALREADY_RUNNING)
		{
			// 返回成功
			return TRUE;
		}
		else
		{
			// 失败，打印错误
			printf("StartService failure! Error = %d \n", err );
			return FALSE;
		}
	}

	// 关闭服务句柄
	if (schService)
	{
		CloseServiceHandle(schService);
	}

	return TRUE;

}

/*************************************
* StopDriver
* 功能 停止服务，停止驱动运行
* 参数 SchSCManager，服务控制器句柄
*         DriverName，服务名
**************************************/
BOOL StopDriver(
		   SC_HANDLE SchSCManager,
		   LPCTSTR DriverName
		   )
{
	BOOLEAN rCode = TRUE;
	SC_HANDLE schService;
	SERVICE_STATUS serviceStatus;

	// 打开服务
	schService = OpenService(SchSCManager,
		DriverName,
		SERVICE_ALL_ACCESS
		);

	if (schService == NULL)
	{
		// 失败
		printf("OpenService failed! Error = %d \n", GetLastError());
		return FALSE;
	}

	// 停止运行
	if (ControlService(schService,
		SERVICE_CONTROL_STOP,
		&serviceStatus
		))
	{
		rCode = TRUE;
	}
	else 
	{
		// 失败
		printf("ControlService failed! Error = %d \n", GetLastError() );
		rCode = FALSE;
	}

	// 关闭服务句柄
	if (schService)
	{
		CloseServiceHandle (schService);
	}
	return rCode;

} 

/*************************************
* GetDriverPath
* 功能 获得服务驱动的路径
* 参数 DriverLocation，返回驱动的路径
**************************************/
BOOL GetDriverPath(
				LPSTR DriverLocation
				)
{

	DWORD driverLocLen = 0;

	// 驱动.sys文件在本程序同一目标下
	driverLocLen = GetCurrentDirectory(MAX_PATH,
		DriverLocation
		);

	if (!driverLocLen)
	{
		printf("GetCurrentDirectory failed! Error = %d \n", GetLastError());
		return FALSE;
	}

	// 构造路径，加上驱动名
	lstrcat(DriverLocation, "\\");
	lstrcat(DriverLocation, DRIVER_NAME);
	lstrcat(DriverLocation, ".sys");

	return TRUE;
}

/*************************************
* int _cdecl main( )
* 功能 加载驱动，进行控制
**************************************/
int _cdecl main()
{
	HANDLE hDevice;
	BOOL bRc;
	ULONG bytesReturned;
	DWORD errNum = 0;
	UCHAR driverLocation[MAX_PATH];

	SC_HANDLE schSCManager;// 服务控制器句柄
	// 打开服务控制器，后续安装、启动都会使用到。
	schSCManager = OpenSCManager(NULL, // 本机
		NULL, // 本机数据库
		SC_MANAGER_ALL_ACCESS // 存取权限
		);
	if (!schSCManager)
	{
		// 打开失败
		printf("Open SC Manager failed! Error = %d \n", GetLastError());
		return 1;
	}
	// 获得驱动文件的路径
	if (!GetDriverPath(driverLocation))
	{
		return 1;
	}
	// 安装驱动服务
	if (InstallDriver(schSCManager,
		DRIVER_NAME,
		driverLocation
		))
	{
		// 安装成功，启动服务，运行驱动
		if(!StartDriver(schSCManager, DRIVER_NAME ))
		{
			printf("Unable to start driver. \n");
			return 1;
		}
	}
	else
	{
		// 安装失败，删除驱动。
		RemoveDriver(schSCManager, DRIVER_NAME );
		printf("Unable to install driver. \n");
		return 1;
	}
	// 打开驱动，获得控制所用的句柄
	// 由驱动创建的符号链接
	hDevice = CreateFile( "\\\\.\\IoctlTest",
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		CREATE_ALWAYS,
		FILE_ATTRIBUTE_NORMAL,
		NULL);
	if ( hDevice == INVALID_HANDLE_VALUE )
	{
		printf ( "Error: CreatFile Failed : %d\n", GetLastError());
		return 1;
	}

	// 打印，输入输出。
	printf("InputBuffer Pointer = %p, BufLength = %d\n", InputBuffer,
		sizeof(InputBuffer));
	printf("OutputBuffer Pointer = %p BufLength = %d\n", OutputBuffer,
		sizeof(OutputBuffer));
	
	// 输入到内核的数据，
	lstrcpy(InputBuffer,
		"This String is from User Application; using IOCTL_XIOCTL_BUFFER");
	printf("\nCalling DeviceIoControl IOCTL_XIOCTL_BUFFER:\n");
	
	// 清空输出缓存
	memset(OutputBuffer, 0, sizeof(OutputBuffer));
	// 进行IO控制，
	bRc = DeviceIoControl ( hDevice,// 句柄
		(DWORD) IOCTL_XIOCTL_BUFFER,// IOCTL
		&InputBuffer,// 输入数据
		strlen ( InputBuffer )+1,// 输入数据的长度
		&OutputBuffer,// 输出数据
		sizeof( OutputBuffer),// 输出数据长度
		&bytesReturned,// 实际输出的数据长度
		NULL
		);
	// 判断是否成功
	if ( !bRc )
	{
		printf ( "Error in DeviceIoControl : %d", GetLastError());
		return 1;
	}
	// 打印从内核输出的内容
	printf(" OutBuffer (%d): %s\n", bytesReturned, OutputBuffer);
	// 关闭句柄
	CloseHandle ( hDevice );
	// 停止运行
	StopDriver(schSCManager,
		DRIVER_NAME
		);
	// 删除服务
	RemoveDriver(schSCManager,
		DRIVER_NAME
		);
	// 关闭服务控制器
	CloseServiceHandle (schSCManager);
	return 0;
}

实现ring3下面的调用

/* 头文件 */
#include <Windows.h>
#include <Winioctl.h>
#include <stdio.h>
/* 函数声明 */
DWORD EnjectCdrom(LPSTR szCdRomName);
DWORD PrintNTFSInfo(LPSTR szVolumeName);

/*************************************
* main
* 功能	-cdrom <盘符> 弹出光盘
*			-ntfs <盘符> 显示nfts分区的信息
**************************************/
int main(int argc, char* argv[])
{
	CHAR szName[64];
	if(argc == 3)
	{
		// 构造设备名
		wsprintf(szName, "\\\\.\\%s.", argv[2]);
		// 弹出光盘
		if(lstrcmp(argv[1],"-cdrom") == 0)
		{
			EnjectCdrom( szName );
			return 0;
		}
		// 获取NTFS分区详细信息
		if(lstrcmp(argv[1],"-ntfs") == 0)
		{
			PrintNTFSInfo( szName );
			return 0;
		}
	}
	// 使用方法
	printf("usage:  \n\t %s -cdrom <volume>\n\t %s -ntfs <volume>\nlike this: \n\t -cdrom G:", 
		argv[0], argv[0]);

	return 0;
}

/*************************************
* DWORD EnjectCdrom(LPSTR szCdRomName)
* 功能	弹出指定的光盘
* 参数	szCdRomName，设备名
**************************************/
DWORD EnjectCdrom(LPSTR szCdRomName)
{
	HANDLE hDevice;
	DWORD dwBytesReturned;

	hDevice = CreateFile(szCdRomName, // 设备名
		GENERIC_ALL, // 存取权限
		FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, // 共享方式
		NULL, // 默认安全属性
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL, 
		NULL); 
	if (hDevice == INVALID_HANDLE_VALUE)
	{
		printf("Could not open file (error %d)\n", GetLastError());
		return 0;
	}
	// 发送IOCTL
	if(!DeviceIoControl(
		(HANDLE) hDevice, // 设备句柄
		IOCTL_STORAGE_EJECT_MEDIA, // 控制码
		NULL, // 输入缓存
		0, // 输入缓存大小
		NULL, // 输出缓存
		0, // 输出缓存大小
		&dwBytesReturned, // 实际需要的输输入缓存大小
		NULL // 非OVERLAPPED
		))
	{
		printf("DeviceIoControl error (%d)",GetLastError());
		return 0;
	}
	return 1;

}

/*************************************
* DWORD PrintNTFSInfo(LPSTR szVolumeName)
* 功能	获取显示指定的NTFS驱动器信息
* 参数	szVolumeName，设备名
**************************************/
DWORD PrintNTFSInfo(LPSTR szVolumeName)
{
	// FSCTL_GET_NTFS_VOLUME_DATA IO控制的返回值保存在
	// NTFS_VOLUME_DATA_BUFFER结构中
	NTFS_VOLUME_DATA_BUFFER nvdb;
	DWORD dwBufferSize;
	HANDLE hDevice;
	// 清空参数
	ZeroMemory(&nvdb,sizeof(nvdb));

	hDevice = CreateFile(szVolumeName, 
		GENERIC_ALL, 
		FILE_SHARE_READ|FILE_SHARE_WRITE, 
		NULL, 
		OPEN_EXISTING, 
		FILE_ATTRIBUTE_NORMAL, 
		NULL); 
	if (hDevice == INVALID_HANDLE_VALUE)
	{
		printf("Could not open file (error %d)\n", GetLastError());
		return 0;
	}

	if(DeviceIoControl(
		hDevice, // 设备句柄
		FSCTL_GET_NTFS_VOLUME_DATA, // 控制码
		NULL, // 输入缓存
		0, // 输入缓存大小
		&nvdb, // 输出缓存
		sizeof( NTFS_VOLUME_DATA_BUFFER ), // 输出缓存大小
		&dwBufferSize, // 返回的实际数据大小
		NULL // 非OVERLAPPED
		))
	{
		// 打印获取的信息
		printf("SerialNumber %lu\n",nvdb.VolumeSerialNumber);
		printf("Starting logical cluster number of the master file table: %lu\n",nvdb.MftStartLcn);
		printf("Length of the master file table: %lu\n",nvdb.MftValidDataLength);
		printf("... ...\n");
	}
	else
	{
		printf("DeviceIoControl error: (%d)\n",GetLastError());
		return 0;
	}
	return 1;
}

 

/* 头文件 */
#include <Windows.h>
#include <Winioctl.h>
#include <stdio.h>
/* 函数声明 */
DWORD EnjectCdrom(LPSTR szCdRomName);
DWORD PrintNTFSInfo(LPSTR szVolumeName);

/*************************************
* main
* 功能	-cdrom <盘符> 弹出光盘
*			-ntfs <盘符> 显示nfts分区的信息
**************************************/
int main(int argc, char* argv[])
{
	CHAR szName[64];
	if(argc == 3)
	{
		// 构造设备名
		wsprintf(szName, "\\\\.\\%s.", argv[2]);
		// 弹出光盘
		if(lstrcmp(argv[1],"-cdrom") == 0)
		{
			EnjectCdrom( szName );
			return 0;
		}
		// 获取NTFS分区详细信息
		if(lstrcmp(argv[1],"-ntfs") == 0)
		{
			PrintNTFSInfo( szName );
			return 0;
		}
	}
	// 使用方法
	printf("usage:  \n\t %s -cdrom <volume>\n\t %s -ntfs <volume>\nlike this: \n\t -cdrom G:", 
		argv[0], argv[0]);

	return 0;
}

/*************************************
* DWORD EnjectCdrom(LPSTR szCdRomName)
* 功能	弹出指定的光盘
* 参数	szCdRomName，设备名
**************************************/
DWORD EnjectCdrom(LPSTR szCdRomName)
{
	HANDLE hDevice;
	DWORD dwBytesReturned;

	hDevice = CreateFile(szCdRomName, // 设备名
		GENERIC_ALL, // 存取权限
		FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, // 共享方式
		NULL, // 默认安全属性
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL, 
		NULL); 
	if (hDevice == INVALID_HANDLE_VALUE)
	{
		printf("Could not open file (error %d)\n", GetLastError());
		return 0;
	}
	// 发送IOCTL
	if(!DeviceIoControl(
		(HANDLE) hDevice, // 设备句柄
		IOCTL_STORAGE_EJECT_MEDIA, // 控制码
		NULL, // 输入缓存
		0, // 输入缓存大小
		NULL, // 输出缓存
		0, // 输出缓存大小
		&dwBytesReturned, // 实际需要的输输入缓存大小
		NULL // 非OVERLAPPED
		))
	{
		printf("DeviceIoControl error (%d)",GetLastError());
		return 0;
	}
	return 1;

}

/*************************************
* DWORD PrintNTFSInfo(LPSTR szVolumeName)
* 功能	获取显示指定的NTFS驱动器信息
* 参数	szVolumeName，设备名
**************************************/
DWORD PrintNTFSInfo(LPSTR szVolumeName)
{
	// FSCTL_GET_NTFS_VOLUME_DATA IO控制的返回值保存在
	// NTFS_VOLUME_DATA_BUFFER结构中
	NTFS_VOLUME_DATA_BUFFER nvdb;
	DWORD dwBufferSize;
	HANDLE hDevice;
	// 清空参数
	ZeroMemory(&nvdb,sizeof(nvdb));

	hDevice = CreateFile(szVolumeName, 
		GENERIC_ALL, 
		FILE_SHARE_READ|FILE_SHARE_WRITE, 
		NULL, 
		OPEN_EXISTING, 
		FILE_ATTRIBUTE_NORMAL, 
		NULL); 
	if (hDevice == INVALID_HANDLE_VALUE)
	{
		printf("Could not open file (error %d)\n", GetLastError());
		return 0;
	}

	if(DeviceIoControl(
		hDevice, // 设备句柄
		FSCTL_GET_NTFS_VOLUME_DATA, // 控制码
		NULL, // 输入缓存
		0, // 输入缓存大小
		&nvdb, // 输出缓存
		sizeof( NTFS_VOLUME_DATA_BUFFER ), // 输出缓存大小
		&dwBufferSize, // 返回的实际数据大小
		NULL // 非OVERLAPPED
		))
	{
		// 打印获取的信息
		printf("SerialNumber %lu\n",nvdb.VolumeSerialNumber);
		printf("Starting logical cluster number of the master file table: %lu\n",nvdb.MftStartLcn);
		printf("Length of the master file table: %lu\n",nvdb.MftValidDataLength);
		printf("... ...\n");
	}
	else
	{
		printf("DeviceIoControl error: (%d)\n",GetLastError());
		return 0;
	}
	return 1;
}