现在的位置: 首页 > 综合 > 正文

IrpCreateFile

2013年04月23日 ⁄ 综合 ⁄ 共 20931字 ⁄ 字号 小 中 大 ⁄ 评论关闭
  1. #include <ntddk.h>  
  2. #include "ioctl.h"  
  3. #include "wintypes.h"  
  4. //---------------------------------------------------------------------------   
  5.   
  6. #ifdef _DEBUG   
  7. #define DbgPrint(_string) {DbgPrint _string;}   
  8. #else  
  9. #define DbgPrint(_string)   
  10. #endif   
  11. //---------------------------------------------------------------------------   
  12.   
  13. NTSTATUS   
  14. IoCompletionRoutine(   
  15.         IN PDEVICE_OBJECT  DeviceObject,   
  16.         IN PIRP  Irp,   
  17.         IN PVOID  Context   
  18.         )   
  19. {   
  20.         DbgPrint(("IoCompletionRoutine!/n"));   
  21.         *Irp->UserIosb = Irp->IoStatus;   
  22.   
  23.         if (Irp->UserEvent)   
  24.                 KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, 0);   
  25.   
  26.         if (Irp->MdlAddress)   
  27.         {   
  28.                 IoFreeMdl(Irp->MdlAddress);   
  29.                 Irp->MdlAddress = NULL;   
  30.         }   
  31.   
  32.         IoFreeIrp(Irp);   
  33.   
  34.         return STATUS_MORE_PROCESSING_REQUIRED;   
  35. }   
  36.   
  37. NTSTATUS   
  38. IrpFileCreate(   
  39.         IN PUNICODE_STRING FileName,   
  40.         IN ACCESS_MASK DesiredAccess,   
  41.         IN ULONG FileAttributes,   
  42.         IN ULONG ShareAccess,   
  43.         IN ULONG CreateDisposition,   
  44.         IN ULONG CreateOptions,   
  45.         IN PDEVICE_OBJECT DeviceObject,   
  46.         IN PDEVICE_OBJECT RealDevice,   
  47.         OUT PVOID *Object   
  48.         )   
  49. {   
  50.         NTSTATUS status;   
  51.         KEVENT event;   
  52.         PIRP irp;   
  53.         IO_STATUS_BLOCK ioStatus;   
  54.         PIO_STACK_LOCATION irpSp;   
  55.         IO_SECURITY_CONTEXT securityContext;   
  56.         ACCESS_STATE accessState;   
  57.         OBJECT_ATTRIBUTES objectAttributes;   
  58.         PFILE_OBJECT fileObject;   
  59.         AUX_ACCESS_DATA auxData;   
  60.   
  61.         RtlZeroMemory(&auxData, sizeof(AUX_ACCESS_DATA));   
  62.         KeInitializeEvent(&event, SynchronizationEvent, FALSE);   
  63.         irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);   
  64.   
  65.         if (irp == NULL)   
  66.                 return STATUS_INSUFFICIENT_RESOURCES;   
  67.   
  68.         InitializeObjectAttributes(&objectAttributes, NULL, OBJ_CASE_INSENSITIVE, 0, NULL);   
  69.   
  70.         status = ObCreateObject(KernelMode,   
  71.                                                         *IoFileObjectType,   
  72.                                                         &objectAttributes,   
  73.                                                         KernelMode,   
  74.                                                         NULL,   
  75.                                                         sizeof(FILE_OBJECT),   
  76.                                                         0,   
  77.                                                         0,   
  78.                                                         (PVOID *)&fileObject);   
  79.   
  80.         if (!NT_SUCCESS(status))   
  81.         {   
  82.                 IoFreeIrp(irp);   
  83.                 return status;   
  84.         }   
  85.   
  86.         RtlZeroMemory(fileObject, sizeof(FILE_OBJECT));   
  87.         fileObject->Type = IO_TYPE_FILE;   
  88.         fileObject->Size = sizeof(FILE_OBJECT);   
  89.         fileObject->DeviceObject = RealDevice;   
  90. //        fileObject->RelatedFileObject = NULL;   
  91.         fileObject->Flags = FO_SYNCHRONOUS_IO;   
  92.         fileObject->FileName.MaximumLength = FileName->MaximumLength;   
  93.         fileObject->FileName.Buffer = ExAllocatePool(NonPagedPool, FileName->MaximumLength);   
  94.   
  95.         if (fileObject->FileName.Buffer == NULL)   
  96.         {   
  97.                 IoFreeIrp(irp);   
  98.                 ObDereferenceObject(fileObject);   
  99.                 return STATUS_INSUFFICIENT_RESOURCES;   
  100.         }   
  101.   
  102.         RtlCopyUnicodeString(&fileObject->FileName, FileName);   
  103.         KeInitializeEvent(&fileObject->Lock, SynchronizationEvent, FALSE);   
  104.         KeInitializeEvent(&fileObject->Event, NotificationEvent, FALSE);   
  105.   
  106.         irp->MdlAddress = NULL;   
  107.         irp->Flags |= IRP_CREATE_OPERATION | IRP_SYNCHRONOUS_API;   
  108.         irp->RequestorMode = KernelMode;   
  109.         irp->UserIosb = &ioStatus;   
  110.         irp->UserEvent = &event;   
  111.         irp->PendingReturned = FALSE;   
  112.         irp->Cancel = FALSE;   
  113.         irp->CancelRoutine = NULL;   
  114.         irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();   
  115.         irp->Tail.Overlay.AuxiliaryBuffer = NULL;   
  116.         irp->Tail.Overlay.OriginalFileObject = fileObject;   
  117.   
  118.         status = SeCreateAccessState(        &accessState,   
  119.                                                                         &auxData,   
  120.                                                                         DesiredAccess,   
  121.                                                                         IoGetFileObjectGenericMapping());   
  122.   
  123.         if (!NT_SUCCESS(status))   
  124.         {   
  125.                 IoFreeIrp(irp);   
  126.                 ExFreePool(fileObject->FileName.Buffer);   
  127.                 ObDereferenceObject(fileObject);   
  128.                 return status;   
  129.         }   
  130.   
  131.         securityContext.SecurityQos = NULL;   
  132.         securityContext.AccessState = &accessState;   
  133.         securityContext.DesiredAccess = DesiredAccess;   
  134.         securityContext.FullCreateOptions = 0;   
  135.   
  136.         irpSp = IoGetNextIrpStackLocation(irp);   
  137.         irpSp->MajorFunction = IRP_MJ_CREATE;   
  138.         irpSp->DeviceObject = DeviceObject;   
  139.         irpSp->FileObject = fileObject;   
  140.         irpSp->Parameters.Create.SecurityContext = &securityContext;   
  141.         irpSp->Parameters.Create.Options = (CreateDisposition << 24) | CreateOptions;   
  142.         irpSp->Parameters.Create.FileAttributes = (USHORT)FileAttributes;   
  143.         irpSp->Parameters.Create.ShareAccess = (USHORT)ShareAccess;   
  144.         irpSp->Parameters.Create.EaLength = 0;   
  145.   
  146.         IoSetCompletionRoutine(irp, IoCompletionRoutine, NULL, TRUE, TRUE, TRUE);   
  147.         status = IoCallDriver(DeviceObject, irp);   
  148.   
  149.         if (status == STATUS_PENDING)   
  150.                 KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);   
  151.   
  152.         status = ioStatus.Status;   
  153.   
  154.         if (!NT_SUCCESS(status))   
  155.         {   
  156.                 ExFreePool(fileObject->FileName.Buffer);   
  157.                 fileObject->FileName.Length = 0;   
  158.                 fileObject->DeviceObject = NULL;   
  159.                 ObDereferenceObject(fileObject);   
  160.         }   
  161.         else  
  162.         {   
  163.                 InterlockedIncrement(&fileObject->DeviceObject->ReferenceCount);   
  164.   
  165.                 if (fileObject->Vpb)   
  166.                 {   
  167.                         InterlockedIncrement(&fileObject->Vpb->ReferenceCount);   
  168.                 }   
  169.                 *Object = fileObject;   
  170.                 DbgPrint(("Open file success! object = %x/n", fileObject));   
  171.         }   
  172.   
  173.         return status;   
  174. }   
  175.   
  176. NTSTATUS   
  177. IrpFileClose(   
  178.         IN PDEVICE_OBJECT DeviceObject,   
  179.         IN PFILE_OBJECT FileObject   
  180.         )   
  181. {   
  182.         NTSTATUS status;   
  183.         KEVENT event;   
  184.         PIRP irp;   
  185.     PVPB vpb;   
  186.         IO_STATUS_BLOCK ioStatusBlock;   
  187.         PIO_STACK_LOCATION irpSp;   
  188.   
  189.     KeInitializeEvent(&event, SynchronizationEvent, FALSE);   
  190.         irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);   
  191.   
  192.         if (irp == NULL)   
  193.                 return STATUS_INSUFFICIENT_RESOURCES;   
  194.   
  195.         irp->Tail.Overlay.OriginalFileObject = FileObject;   
  196.     irp->Tail.Overlay.Thread = PsGetCurrentThread();   
  197.     irp->RequestorMode = KernelMode;   
  198.     irp->UserEvent = &event;   
  199.     irp->UserIosb = &irp->IoStatus;   
  200.     irp->Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)NULL;   
  201.     irp->Flags = IRP_SYNCHRONOUS_API | IRP_CLOSE_OPERATION;   
  202.   
  203.     irpSp = IoGetNextIrpStackLocation(irp);   
  204.     irpSp->MajorFunction = IRP_MJ_CLEANUP;   
  205.     irpSp->FileObject = FileObject;   
  206.   
  207.     status = IoCallDriver(DeviceObject, irp);   
  208.   
  209.     if (status == STATUS_PENDING)   
  210.         {   
  211.                 KeWaitForSingleObject(        &event,   
  212.                                                                 UserRequest,   
  213.                                                                 KernelMode,   
  214.                                                                 FALSE,   
  215.                                                                 NULL);   
  216.         }   
  217.   
  218.         IoReuseIrp(irp , STATUS_SUCCESS);   
  219.     KeClearEvent(&event);   
  220.   
  221.     irpSp = IoGetNextIrpStackLocation(irp);   
  222.     irpSp->MajorFunction = IRP_MJ_CLOSE;   
  223.     irpSp->FileObject = FileObject;   
  224.   
  225.     irp->UserIosb = &ioStatusBlock;   
  226.     irp->UserEvent = &event;   
  227.     irp->Tail.Overlay.OriginalFileObject = FileObject;   
  228.     irp->Tail.Overlay.Thread = PsGetCurrentThread();   
  229.     irp->AssociatedIrp.SystemBuffer = (PVOID)NULL;   
  230.     irp->Flags = IRP_CLOSE_OPERATION | IRP_SYNCHRONOUS_API;   
  231.   
  232.     vpb = FileObject->Vpb;   
  233.   
  234.         if (vpb && !(FileObject->Flags & FO_DIRECT_DEVICE_OPEN))   
  235.         {   
  236.                 InterlockedDecrement(&vpb->ReferenceCount);   
  237.                 FileObject->Flags |= FO_FILE_OPEN_CANCELLED;   
  238.         }   
  239.   
  240.     status = IoCallDriver(DeviceObject, irp);   
  241.   
  242.     if (status == STATUS_PENDING)   
  243.         {   
  244.                 KeWaitForSingleObject(        &event,   
  245.                                                                 Executive,   
  246.                                                                 KernelMode,   
  247.                                                                 FALSE,   
  248.                                                                 NULL);   
  249.         }   
  250.   
  251.     IoFreeIrp(irp);   
  252.   
  253.         return status;   
  254. }   
  255.   
  256. NTSTATUS   
  257. IrpFileRead(   
  258.         IN PFILE_OBJECT FileObject,   
  259.         IN PLARGE_INTEGER ByteOffset OPTIONAL,   
  260.         IN ULONG Length,   
  261.         OUT PVOID Buffer,   
  262.         OUT PIO_STATUS_BLOCK IoStatusBlock   
  263.         )   
  264. {   
  265.         NTSTATUS status;   
  266.         KEVENT event;   
  267.         PIRP irp;   
  268.         PIO_STACK_LOCATION irpSp;   
  269.         PDEVICE_OBJECT deviceObject;   
  270.   
  271.         if (ByteOffset == NULL)   
  272.         {   
  273.                 if (!(FileObject->Flags & FO_SYNCHRONOUS_IO))   
  274.                         return STATUS_INVALID_PARAMETER;   
  275.   
  276.                 ByteOffset = &FileObject->CurrentByteOffset;   
  277.         }   
  278.   
  279.         if (FileObject->Vpb == 0 || FileObject->Vpb->RealDevice == NULL)   
  280.                 return STATUS_UNSUCCESSFUL;   
  281.   
  282.         deviceObject = FileObject->Vpb->DeviceObject;   
  283.         irp = IoAllocateIrp(deviceObject->StackSize, FALSE);   
  284.   
  285.         if (irp == NULL)   
  286.                 return STATUS_INSUFFICIENT_RESOURCES;   
  287.   
  288.         irp->MdlAddress = IoAllocateMdl(Buffer, Length, FALSE, TRUE, NULL);   
  289.   
  290.         if (irp->MdlAddress == NULL)   
  291.         {   
  292.                 IoFreeIrp(irp);   
  293.                 return STATUS_INSUFFICIENT_RESOURCES;;   
  294.         }   
  295.   
  296.         MmBuildMdlForNonPagedPool(irp->MdlAddress);   
  297.   
  298.         irp->Flags = IRP_READ_OPERATION;   
  299.         irp->RequestorMode = KernelMode;   
  300.         irp->UserIosb = IoStatusBlock;   
  301.         irp->UserEvent = &event;   
  302.         irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();   
  303.         irp->Tail.Overlay.OriginalFileObject = FileObject;   
  304.   
  305.         irpSp = IoGetNextIrpStackLocation(irp);   
  306.         irpSp->MajorFunction = IRP_MJ_READ;   
  307.         irpSp->MinorFunction = IRP_MN_NORMAL;   
  308.         irpSp->DeviceObject = deviceObject;   
  309.         irpSp->FileObject = FileObject;   
  310.         irpSp->Parameters.Read.Length = Length;   
  311.         irpSp->Parameters.Read.ByteOffset = *ByteOffset;   
  312.   
  313.         KeInitializeEvent(&event, SynchronizationEvent, FALSE);   
  314.         IoSetCompletionRoutine(irp, IoCompletionRoutine, NULL, TRUE, TRUE, TRUE);   
  315.         status = IoCallDriver(deviceObject, irp);   
  316.   
  317.         if (status == STATUS_PENDING)   
  318.                 status = KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);   
  319.   
  320.         return status;   
  321. }   
  322.   
  323. NTSTATUS   
  324. IrpFileWrite(   
  325.         IN PFILE_OBJECT FileObject,   
  326.         IN PLARGE_INTEGER ByteOffset OPTIONAL,   
  327.         IN ULONG Length,   
  328.         IN PVOID Buffer,   
  329.         OUT PIO_STATUS_BLOCK IoStatusBlock   
  330.         )   
  331. {   
  332.         NTSTATUS status;   
  333.         KEVENT event;   
  334.         PIRP irp;   
  335.         PIO_STACK_LOCATION irpSp;   
  336.         PDEVICE_OBJECT deviceObject;   
  337.   
  338.         if (ByteOffset == NULL)   
  339.         {   
  340.                 if (!(FileObject->Flags & FO_SYNCHRONOUS_IO))   
  341.                         return STATUS_INVALID_PARAMETER;   
  342.   
  343.                 ByteOffset = &FileObject->CurrentByteOffset;   
  344.         }   
  345.   
  346.         if (FileObject->Vpb == 0 || FileObject->Vpb->RealDevice == NULL)   
  347.                 return STATUS_UNSUCCESSFUL;   
  348.   
  349.         deviceObject = FileObject->Vpb->DeviceObject;   
  350.         irp = IoAllocateIrp(deviceObject->StackSize, FALSE);   
  351.   
  352.         if (irp == NULL)   
  353.                 return STATUS_INSUFFICIENT_RESOURCES;   
  354.   
  355.         irp->MdlAddress = IoAllocateMdl(Buffer, Length, FALSE, TRUE, NULL);   
  356.   
  357.         if (irp->MdlAddress == NULL)   
  358.         {   
  359.                 IoFreeIrp(irp);   
  360.                 return STATUS_INSUFFICIENT_RESOURCES;;   
  361.         }   
  362.   
  363.         MmBuildMdlForNonPagedPool(irp->MdlAddress);   
  364.   
  365.         irp->Flags = IRP_WRITE_OPERATION;   
  366.         irp->RequestorMode = KernelMode;   
  367.         irp->UserIosb = IoStatusBlock;   
  368.         irp->UserEvent = &event;   
  369.         irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();   
  370.         irp->Tail.Overlay.OriginalFileObject = FileObject;   
  371.   
  372.         irpSp = IoGetNextIrpStackLocation(irp);   
  373.         irpSp->MajorFunction = IRP_MJ_WRITE;   
  374.         irpSp->MinorFunction = IRP_MN_NORMAL;   
  375.         irpSp->DeviceObject = deviceObject;   
  376.         irpSp->FileObject = FileObject;   
  377.         irpSp->Parameters.Write.Length = Length;   
  378.         irpSp->Parameters.Write.ByteOffset = *ByteOffset;   
  379.   
  380.         KeInitializeEvent(&event, SynchronizationEvent, FALSE);   
  381.         IoSetCompletionRoutine(irp, IoCompletionRoutine, NULL, TRUE, TRUE, TRUE);   
  382.         status = IoCallDriver(deviceObject, irp);   
  383.   
  384.         if (status == STATUS_PENDING)   
  385.                 status = KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);   
  386.   
  387.         return status;   
  388. }   
  389.   
  390. NTSTATUS   
  391. IrpFileQuery(   
  392.         IN PFILE_OBJECT FileObject,   
  393.         OUT PVOID FileInformation,   
  394.         IN ULONG Length,   
  395.         IN FILE_INFORMATION_CLASS FileInformationClass   
  396.         )   
  397. {   
  398.         NTSTATUS status;   
  399.         KEVENT event;   
  400.         PIRP irp;   
  401.         IO_STATUS_BLOCK ioStatus;   
  402.         PIO_STACK_LOCATION irpSp;   
  403.         PDEVICE_OBJECT deviceObject;   
  404.   
  405.         if (FileObject->Vpb == 0 || FileObject->Vpb->RealDevice == NULL)   
  406.                 return STATUS_UNSUCCESSFUL;   
  407.   
  408.         deviceObject = FileObject->Vpb->DeviceObject;   
  409.         KeInitializeEvent(&event, SynchronizationEvent, FALSE);   
  410.         irp = IoAllocateIrp(deviceObject->StackSize, FALSE);   
  411.   
  412.         if (irp == NULL)   
  413.                 return STATUS_INSUFFICIENT_RESOURCES;   
  414.   
  415.         irp->Flags = IRP_BUFFERED_IO;   
  416.         irp->AssociatedIrp.SystemBuffer = FileInformation;   
  417.         irp->RequestorMode = KernelMode;   
  418.         irp->Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)NULL;   
  419.         irp->UserEvent = &event;   
  420.         irp->UserIosb = &ioStatus;   
  421.         irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();   
  422.         irp->Tail.Overlay.OriginalFileObject = FileObject;   
  423.   
  424.         irpSp = IoGetNextIrpStackLocation(irp);   
  425.         irpSp->MajorFunction = IRP_MJ_QUERY_INFORMATION;   
  426.         irpSp->DeviceObject = deviceObject;   
  427.         irpSp->FileObject = FileObject;   
  428.         irpSp->Parameters.QueryFile.Length = Length;   
  429.         irpSp->Parameters.QueryFile.FileInformationClass = FileInformationClass;   
  430.   
  431.         IoSetCompletionRoutine(irp, IoCompletionRoutine, NULL, TRUE, TRUE, TRUE);   
  432.         status = IoCallDriver(deviceObject, irp);   
  433.   
  434.         if (status == STATUS_PENDING)   
  435.                 KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);   
  436.   
  437.         return ioStatus.Status;   
  438. }   
  439.   
  440. NTSTATUS   
  441. IrpDirectoryQuery(   
  442.         IN PFILE_OBJECT FileObject,   
  443.         IN FILE_INFORMATION_CLASS FileInformationClass,   
  444.         OUT PVOID Buffer,   
  445.         IN ULONG Length   
  446.         )   
  447. {   
  448.         NTSTATUS status;   
  449.         KEVENT event;   
  450.         PIRP irp;   
  451.         IO_STATUS_BLOCK ioStatus;   
  452.         PIO_STACK_LOCATION irpSp;   
  453.         PDEVICE_OBJECT deviceObject;   
  454.         PQUERY_DIRECTORY queryDirectory;   
  455.   
  456.         if (FileObject->Vpb == 0 || FileObject->Vpb->RealDevice == NULL)   
  457.                 return STATUS_UNSUCCESSFUL;   
  458.   
  459.         deviceObject = FileObject->Vpb->DeviceObject;   
  460.         KeInitializeEvent(&event, SynchronizationEvent, FALSE);   
  461.         irp = IoAllocateIrp(deviceObject->StackSize, FALSE);   
  462.   
  463.         if (irp == NULL)   
  464.                 return STATUS_INSUFFICIENT_RESOURCES;   
  465.   
  466.         irp->Flags = IRP_INPUT_OPERATION | IRP_BUFFERED_IO;   
  467.         irp->RequestorMode = KernelMode;   
  468.         irp->UserEvent = &event;   
  469.         irp->UserIosb = &ioStatus;   
  470.         irp->UserBuffer = Buffer;   
  471.         irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();   
  472.         irp->Tail.Overlay.OriginalFileObject = FileObject;   
  473.         irp->Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)NULL;   
  474.         //irp->Pointer = FileObject;   
  475.   
  476.         irpSp = IoGetNextIrpStackLocation(irp);   
  477.         irpSp->MajorFunction = IRP_MJ_DIRECTORY_CONTROL;   
  478.         irpSp->MinorFunction = IRP_MN_QUERY_DIRECTORY;   
  479.         irpSp->DeviceObject = deviceObject;   
  480.         irpSp->FileObject = FileObject;   
  481.   
  482.         queryDirectory = (PQUERY_DIRECTORY)&irpSp->Parameters;   
  483.         queryDirectory->Length = Length;   
  484.         queryDirectory->FileName = NULL;   
  485.         queryDirectory->FileInformationClass = FileInformationClass;   
  486.         queryDirectory->FileIndex = 0;   
  487.   
  488.         IoSetCompletionRoutine(irp, IoCompletionRoutine, NULL, TRUE, TRUE, TRUE);   
  489.         status = IoCallDriver(deviceObject, irp);   
  490.   
  491.         if (status == STATUS_PENDING)   
  492.         {   
  493.                 KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);   
  494.                 status = ioStatus.Status;   
  495.         }   
  496.   
  497.         return status;   
  498. }   
  499.   
  500. BOOLEAN GetDriveObject(   
  501.         IN ULONG DriveNumber,   
  502.         OUT PDEVICE_OBJECT *DeviceObject,   
  503.         OUT PDEVICE_OBJECT *ReadDevice   
  504.         )   
  505. {   
  506.         WCHAR driveName[] = L"//DosDevices//A://";   
  507.         UNICODE_STRING deviceName;   
  508.         HANDLE deviceHandle;   
  509.         OBJECT_ATTRIBUTES objectAttributes;   
  510.         IO_STATUS_BLOCK        ioStatus;   
  511.         PFILE_OBJECT fileObject;   
  512.         NTSTATUS status;   
  513.   
  514.         if (DriveNumber >= 'A' && DriveNumber <= 'Z')   
  515.         {   
  516.                 driveName[12] = (CHAR)DriveNumber;   
  517.         }   
  518.         else if (DriveNumber >= 'a' && DriveNumber <= 'z')   
  519.         {   
  520.                 driveName[12] = (CHAR)DriveNumber - 'a' + 'A';   
  521.         }   
  522.         else  
  523.         {   
  524.                 return FALSE;   
  525.         }   
  526.   
  527.         RtlInitUnicodeString(&deviceName, driveName);   
  528.   
  529.         InitializeObjectAttributes(        &objectAttributes,   
  530.                                                                 &deviceName,   
  531.                                                                 OBJ_CASE_INSENSITIVE,   
  532.                                                                 NULL,   
  533.                                                                 NULL);   
  534.   
  535.         status = IoCreateFile(        &deviceHandle,   
  536.                                                         SYNCHRONIZE | FILE_ANY_ACCESS,   
  537.                                                         &objectAttributes,   
  538.                                                         &ioStatus,   
  539.                                                         NULL,   
  540.                                                         0,   
  541.                                                         FILE_SHARE_READ | FILE_SHARE_WRITE,   
  542.                                                         FILE_OPEN,   
  543.                                                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE,   
  544.                                                         NULL,   
  545.                                                         0,   
  546.                                                         CreateFileTypeNone,   
  547.                                                         NULL,   
  548.                                                         0x100);   
  549.   
  550.         if (!NT_SUCCESS(status))   
  551.         {   
  552.                 DbgPrint(("Could not open drive %c: %x/n", DriveNumber, status));   
  553.                 return FALSE;   
  554.         }   
  555.   
  556.         status = ObReferenceObjectByHandle(        deviceHandle,   
  557.                                                                                 FILE_READ_DATA,   
  558.                                                                                 *IoFileObjectType,   
  559.                                                                                 KernelMode,   
  560.                                                                                 &fileObject,   
  561.                                                                                 NULL);   
  562.   
  563.         if (!NT_SUCCESS(status))   
  564.         {   
  565.                 DbgPrint(("Could not get fileobject from handle: %c/n", DriveNumber));   
  566.                 ZwClose(deviceHandle);   
  567.                 return FALSE;   
  568.         }   
  569.   
  570.         if (fileObject->Vpb == 0 || fileObject->Vpb->RealDevice == NULL)   
  571.         {   
  572.                 ObDereferenceObject(fileObject);   
  573.                 ZwClose(deviceHandle);   
  574.                 return FALSE;   
  575.         }   
  576.   
  577.         *DeviceObject = fileObject->Vpb->DeviceObject;   
  578.         *ReadDevice = fileObject->Vpb->RealDevice;   
  579.   
  580.         ObDereferenceObject(fileObject);   
  581.         ZwClose(deviceHandle);   
  582.   
  583.         return TRUE;   
  584. }  
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞