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

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

 

驱动代码实现与分析

 /* 头文件 */
 #include // 包括了很多NT内核的类型、结构、函数定义，开发驱动时需要包括此头文件
 #include
 #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

        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
 #include
 #include
 #include
 #include
 #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
 #include
 #include
 /* 函数声明 */
 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 \n\t %s -ntfs \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
 #include
 #include
 /* 函数声明 */
 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 \n\t %s -ntfs \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;
 }