![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ntdriver.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / driver|
Return to ntdriver.c CVS log | Up to [truecrypt] / truecrypt / driver |
1.1.1.2 ! root 1: /* Copyright (C) 2004 TrueCrypt Foundation 1.1 root 2: This product uses components written by Paul Le Roux <[email protected]> */ 3: 4: #include "TCdefs.h" 5: #include "crypto.h" 6: #include "fat.h" 7: 8: #include "apidrvr.h" 9: #include "ntdriver.h" 10: #include "ntvol.h" 11: #include "ntrawdv.h" 12: #include "ntfiledv.h" 13: #include "cache.h" 14: 15: #include <tchar.h> 16: #include <initguid.h> 17: #include <mountmgr.h> 18: #include <mountdev.h> 19: #include <ntddvol.h> 20: 21: /* Init section, which is thrown away as soon as DriverEntry returns */ 22: #pragma alloc_text(INIT,DriverEntry) 23: #pragma alloc_text(INIT,TCCreateRootDeviceObject) 24: 25: /* Sync. mutex for above password data */ 26: KMUTEX driverMutex; 27: 28: /* DriverEntry initialize's the dispatch addresses to be passed back to NT. 29: RUNS AT IRQL = PASSIVE_LEVEL(0) */ 30: NTSTATUS 31: DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath) 32: { 33: if (RegistryPath); /* Remove warning */ 34: 35: DriverObject->MajorFunction[IRP_MJ_CREATE] = TCDispatchQueueIRP; 36: DriverObject->MajorFunction[IRP_MJ_CLOSE] = TCDispatchQueueIRP; 37: DriverObject->MajorFunction[IRP_MJ_CLEANUP] = TCDispatchQueueIRP; 38: DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = TCDispatchQueueIRP; 39: DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = TCDispatchQueueIRP; 40: DriverObject->MajorFunction[IRP_MJ_READ] = TCDispatchQueueIRP; 41: DriverObject->MajorFunction[IRP_MJ_WRITE] = TCDispatchQueueIRP; 42: DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = TCDispatchQueueIRP; 43: 44: DriverObject->DriverUnload = TCUnloadDriver; 45: 46: KeInitializeMutex (&driverMutex, 1); 47: 48: return TCCreateRootDeviceObject (DriverObject); 49: } 50: 51: #ifdef _DEBUG 52: // Dumps a memory region to debug output 53: void DumpMem(unsigned char *mem, int len) 54: { 55: unsigned char str[20]; 56: unsigned char *m = mem; 57: int i,j; 58: 59: for (j=0;j<len/8;j++) 60: { 61: memset (str,0,sizeof str); 62: for (i=0;i<8;i++) 63: { 64: if (m[i] > ' ' && m[i] < '~') 65: str[i]=m[i]; 66: else 67: str[i]='.'; 68: } 69: 70: Dump ("0x%08x %02x %02x %02x %02x %02x %02x %02x %02x %s", 71: m, m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], str); 72: 73: m+=8; 74: } 75: } 76: #endif 77: 78: /* TCDispatchQueueIRP queues any IRP's so that they can be processed later 79: by the thread -- or in some cases handles them immediately! */ 80: NTSTATUS 81: TCDispatchQueueIRP (PDEVICE_OBJECT DeviceObject, PIRP Irp) 82: { 83: PEXTENSION Extension = (PEXTENSION) DeviceObject->DeviceExtension; 84: PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (Irp); 85: NTSTATUS ntStatus; 86: 87: #ifdef USE_KERNEL_MUTEX 88: if (Extension->bRootDevice == FALSE) 89: KeWaitForMutexObject (&Extension->KernelMutex, Executive, KernelMode, 90: FALSE, NULL); 91: #endif 92: 93: #ifdef _DEBUG 94: if (irpSp->MajorFunction == IRP_MJ_DEVICE_CONTROL) 95: Dump ("TCDispatchQueueIRP BEGIN MajorFunction = %ls 0x%08x IoControlCode = %ls 0x%08x\n", 96: TCTranslateCode (irpSp->MajorFunction), (int) irpSp->MajorFunction, 97: TCTranslateCode (irpSp->Parameters.DeviceIoControl.IoControlCode), 98: (int) irpSp->Parameters.DeviceIoControl.IoControlCode); 99: //else 100: // Dump ("TCDispatchQueueIRP BEGIN MajorFunction = %ls 0x%08x\n", 101: // TCTranslateCode (irpSp->MajorFunction), (int) irpSp->MajorFunction); 102: #endif 103: 104: if (Extension->bRootDevice == FALSE) 105: { 106: if (irpSp->MajorFunction == IRP_MJ_READ || irpSp->MajorFunction == IRP_MJ_WRITE || 107: irpSp->MajorFunction == IRP_MJ_DEVICE_CONTROL) 108: { 109: if ((DeviceObject->Flags & DO_VERIFY_VOLUME)) 110: { 111: if (!(irpSp->Flags & SL_OVERRIDE_VERIFY_VOLUME)) 112: { 113: Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED; 114: Irp->IoStatus.Information = 0; 115: if (!NT_SUCCESS (Irp->IoStatus.Status) && 116: IoIsErrorUserInduced (Irp->IoStatus.Status)) 117: { 118: IoSetHardErrorOrVerifyDevice (Irp, DeviceObject); 119: } 120: ntStatus = Irp->IoStatus.Status; 121: IoCompleteRequest (Irp, IO_NO_INCREMENT); 122: //Dump ("TCDispatchQueueIRP NTSTATUS = 0x%08x END\n", ntStatus); 123: #ifdef USE_KERNEL_MUTEX 124: if (Extension->bRootDevice == FALSE) 125: KeReleaseMutex (&Extension->KernelMutex, FALSE); 126: #endif 127: return ntStatus; 128: } 129: else if (Extension->bShuttingDown == TRUE) 130: { 131: Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR; 132: Irp->IoStatus.Information = 0; 133: if (!NT_SUCCESS (Irp->IoStatus.Status) && 134: IoIsErrorUserInduced (Irp->IoStatus.Status)) 135: { 136: IoSetHardErrorOrVerifyDevice (Irp, DeviceObject); 137: } 138: ntStatus = Irp->IoStatus.Status; 139: IoCompleteRequest (Irp, IO_NO_INCREMENT); 140: //Dump ("TCDispatchQueueIRP NTSTATUS = 0x%08x END\n", ntStatus); 141: #ifdef USE_KERNEL_MUTEX 142: if (Extension->bRootDevice == FALSE) 143: KeReleaseMutex (&Extension->KernelMutex, FALSE); 144: #endif 145: return ntStatus; 146: } 147: } 148: else if (Extension->bShuttingDown == TRUE) 149: { 150: if (DeviceObject->Vpb && DeviceObject->Vpb->Flags & VPB_MOUNTED) 151: { 152: Irp->IoStatus.Status = STATUS_NO_MEDIA_IN_DEVICE; 153: Irp->IoStatus.Information = 0; 154: if (!NT_SUCCESS (Irp->IoStatus.Status) && 155: IoIsErrorUserInduced (Irp->IoStatus.Status)) 156: { 157: IoSetHardErrorOrVerifyDevice (Irp, DeviceObject); 158: } 159: DeviceObject->Flags |= DO_VERIFY_VOLUME; 160: } 161: else 162: { 163: Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR; 164: Irp->IoStatus.Information = 0; 165: } 166: 167: ntStatus = Irp->IoStatus.Status; 168: IoCompleteRequest (Irp, IO_NO_INCREMENT); 169: //Dump ("TCDispatchQueueIRP NTSTATUS = 0x%08x END\n", ntStatus); 170: #ifdef USE_KERNEL_MUTEX 171: if (Extension->bRootDevice == FALSE) 172: KeReleaseMutex (&Extension->KernelMutex, FALSE); 173: #endif 174: return ntStatus; 175: } 176: } 177: else if ((DeviceObject->Flags & DO_VERIFY_VOLUME)) 178: { /* If shutting down or media removed */ 179: if (Extension->bShuttingDown == TRUE) 180: { 181: Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED; 182: Irp->IoStatus.Information = 0; 183: if (!NT_SUCCESS (Irp->IoStatus.Status) && 184: IoIsErrorUserInduced (Irp->IoStatus.Status)) 185: { 186: IoSetHardErrorOrVerifyDevice (Irp, DeviceObject); 187: } 188: ntStatus = Irp->IoStatus.Status; 189: IoCompleteRequest (Irp, IO_NO_INCREMENT); 190: //Dump ("TCDispatchQueueIRP NTSTATUS = 0x%08x END\n", ntStatus); 191: #ifdef USE_KERNEL_MUTEX 192: if (Extension->bRootDevice == FALSE) 193: KeReleaseMutex (&Extension->KernelMutex, FALSE); 194: #endif 195: return ntStatus; 196: } 197: else 198: { 199: Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR; 200: Irp->IoStatus.Information = 0; 201: ntStatus = Irp->IoStatus.Status; 202: IoCompleteRequest (Irp, IO_NO_INCREMENT); 203: //Dump ("TCDispatchQueueIRP NTSTATUS = 0x%08x END\n", ntStatus); 204: #ifdef USE_KERNEL_MUTEX 205: if (Extension->bRootDevice == FALSE) 206: KeReleaseMutex (&Extension->KernelMutex, FALSE); 207: #endif 208: return ntStatus; 209: } 210: } 211: } 212: 213: switch (irpSp->MajorFunction) 214: { 215: case IRP_MJ_CLOSE: 216: case IRP_MJ_CREATE: 217: case IRP_MJ_CLEANUP: 218: #ifdef USE_KERNEL_MUTEX 219: if (Extension->bRootDevice == FALSE) 220: KeReleaseMutex (&Extension->KernelMutex, FALSE); 221: #endif 222: return COMPLETE_IRP (DeviceObject, Irp, STATUS_SUCCESS, 0); 223: 224: case IRP_MJ_SHUTDOWN: 225: case IRP_MJ_FLUSH_BUFFERS: 226: case IRP_MJ_READ: 227: case IRP_MJ_WRITE: 228: case IRP_MJ_DEVICE_CONTROL: 229: if (Extension->bRootDevice == FALSE) 230: { 231: ASSERT (Extension->bShuttingDown == FALSE); 232: 233: IoMarkIrpPending (Irp); 234: 235: ASSERT (KeGetCurrentIrql ()== PASSIVE_LEVEL || 236: KeGetCurrentIrql ()== APC_LEVEL); 237: 238: ExInterlockedInsertTailList ( 239: &Extension->ListEntry, 240: &Irp->Tail.Overlay.ListEntry, 241: &Extension->ListSpinLock); 242: 243: ASSERT (KeGetCurrentIrql ()== PASSIVE_LEVEL || 244: KeGetCurrentIrql ()== APC_LEVEL); 245: 246: KeReleaseSemaphore ( 247: &Extension->RequestSemaphore, 248: (KPRIORITY) 0, 249: 1, 250: FALSE); 251: 252: //Dump ("TCDispatchQueueIRP STATUS_PENDING END\n"); 253: #ifdef USE_KERNEL_MUTEX 254: if (Extension->bRootDevice == FALSE) 255: KeReleaseMutex (&Extension->KernelMutex, FALSE); 256: #endif 257: return STATUS_PENDING; 258: } 259: else 260: { 261: if (irpSp->Parameters.DeviceIoControl.IoControlCode >= TC_FIRST_PRIVATE && 262: irpSp->Parameters.DeviceIoControl.IoControlCode <= TC_LAST_PRIVATE) 263: { 264: ntStatus = TCDeviceControl (DeviceObject, Extension, Irp); 265: //Dump ("TCDispatchQueueIRP NTSTATUS = 0x%08x END\n", ntStatus); 266: #ifdef USE_KERNEL_MUTEX 267: if (Extension->bRootDevice == FALSE) 268: KeReleaseMutex (&Extension->KernelMutex, FALSE); 269: #endif 270: return ntStatus; 271: } 272: 273: if (irpSp->MajorFunction == IRP_MJ_FLUSH_BUFFERS || irpSp->MajorFunction == IRP_MJ_SHUTDOWN) 274: { 275: #ifdef USE_KERNEL_MUTEX 276: if (Extension->bRootDevice == FALSE) 277: KeReleaseMutex (&Extension->KernelMutex, FALSE); 278: #endif 279: return COMPLETE_IRP (DeviceObject, Irp, STATUS_SUCCESS, 0); 280: } 281: } 282: 283: #ifdef USE_KERNEL_MUTEX 284: if (Extension->bRootDevice == FALSE) 285: KeReleaseMutex (&Extension->KernelMutex, FALSE); 286: #endif 287: 288: return COMPLETE_IRP (DeviceObject, Irp, STATUS_DRIVER_INTERNAL_ERROR, 0); 289: } 290: 291: #ifdef _DEBUG 292: Dump ("ERROR: Unknown irpSp->MajorFunction in TCDispatchQueueIRP %ls 0x%08x END\n", 293: TCTranslateCode (irpSp->MajorFunction), (int) irpSp->MajorFunction); 294: #endif 295: 296: #ifdef USE_KERNEL_MUTEX 297: if (Extension->bRootDevice == FALSE) 298: KeReleaseMutex (&Extension->KernelMutex, FALSE); 299: #endif 300: return COMPLETE_IRP (DeviceObject, Irp, STATUS_DRIVER_INTERNAL_ERROR, 0); 301: } 302: 303: NTSTATUS 304: TCCreateRootDeviceObject (PDRIVER_OBJECT DriverObject) 305: { 306: UNICODE_STRING Win32NameString, ntUnicodeString; 307: WCHAR dosname[32], ntname[32]; 308: PDEVICE_OBJECT DeviceObject; 309: NTSTATUS ntStatus; 310: BOOL *bRootExtension; 311: 312: Dump ("TCCreateRootDeviceObject BEGIN\n"); 313: 314: wcscpy (dosname, (LPWSTR) DOS_ROOT_PREFIX); 315: wcscpy (ntname, (LPWSTR) NT_ROOT_PREFIX); 316: RtlInitUnicodeString (&ntUnicodeString, ntname); 317: RtlInitUnicodeString (&Win32NameString, dosname); 318: 319: Dump ("Creating root device nt=%ls dos=%ls\n", ntname, dosname); 320: 321: ntStatus = IoCreateDevice ( 322: DriverObject, /* Our Driver Object */ 323: sizeof (BOOL), /* Size of state information */ 324: &ntUnicodeString, /* Device name "\Device\Name" */ 325: FILE_DEVICE_DISK, /* Device type */ 326: 0, /* Device characteristics */ 327: FALSE, /* Exclusive device */ 328: &DeviceObject); /* Returned ptr to Device Object */ 329: 330: if (!NT_SUCCESS (ntStatus)) 331: { 332: Dump ("TCCreateRootDeviceObject NTSTATUS = 0x%08x END\n", ntStatus); 333: return ntStatus;/* Failed to create DeviceObject */ 334: } 335: 336: DeviceObject->Flags |= DO_DIRECT_IO; 337: DeviceObject->AlignmentRequirement = FILE_WORD_ALIGNMENT; 338: 339: /* Setup the device extension */ 340: bRootExtension = (BOOL *) DeviceObject->DeviceExtension; 341: *bRootExtension = TRUE; 342: 343: /* The symlinks for mount devices are created from user-mode */ 344: ntStatus = IoCreateSymbolicLink (&Win32NameString, &ntUnicodeString); 345: if (!NT_SUCCESS (ntStatus)) 346: { 347: Dump ("TCCreateRootDeviceObject NTSTATUS = 0x%08x END\n", ntStatus); 348: IoDeleteDevice (DeviceObject); 349: return ntStatus; 350: } 351: 352: ASSERT (KeGetCurrentIrql ()== PASSIVE_LEVEL); 353: Dump ("TCCreateRootDeviceObject STATUS_SUCCESS END\n"); 354: return STATUS_SUCCESS; 355: } 356: 357: NTSTATUS 358: TCCreateDeviceObject (PDRIVER_OBJECT DriverObject, 359: PDEVICE_OBJECT * ppDeviceObject, 360: int nDosDriveNo) 361: { 362: UNICODE_STRING Win32NameString, ntUnicodeString; 363: WCHAR dosname[32], ntname[32]; 364: PEXTENSION Extension; 365: NTSTATUS ntStatus; 366: 367: Dump ("TCCreateDeviceObject BEGIN\n"); 368: 369: TCGetDosNameFromNumber (dosname, nDosDriveNo); 370: TCGetNTNameFromNumber (ntname, nDosDriveNo); 371: RtlInitUnicodeString (&ntUnicodeString, ntname); 372: RtlInitUnicodeString (&Win32NameString, dosname); 373: 374: Dump ("Creating device nt=%ls dos=%ls\n", ntname, dosname); 375: 376: ntStatus = IoCreateDevice ( 377: DriverObject, /* Our Driver Object */ 378: sizeof (EXTENSION), /* Size of state information */ 379: &ntUnicodeString, /* Device name "\Device\Name" */ 380: FILE_DEVICE_DISK, /* Device type */ 381: 0, /* Device characteristics */ 382: FALSE, /* Exclusive device */ 383: ppDeviceObject); /* Returned ptr to Device Object */ 384: 385: if (!NT_SUCCESS (ntStatus)) 386: { 387: Dump ("TCCreateDeviceObject NTSTATUS = 0x%08x END\n", ntStatus); 388: return ntStatus;/* Failed to create DeviceObject */ 389: } 390: /* Initialize device object and extension. */ 391: 392: (*ppDeviceObject)->Flags |= DO_DIRECT_IO; 393: (*ppDeviceObject)->AlignmentRequirement = FILE_WORD_ALIGNMENT; 394: 395: /* Setup the device extension */ 396: Extension = (PEXTENSION) (*ppDeviceObject)->DeviceExtension; 397: memset (Extension, 0, sizeof (EXTENSION)); 398: 399: Extension->lMagicNumber = 0xabfeacde; 400: Extension->nDosDriveNo = nDosDriveNo; 401: 402: KeInitializeEvent (&Extension->keCreateEvent, SynchronizationEvent, FALSE); 403: KeInitializeSemaphore (&Extension->RequestSemaphore, 0L, MAXLONG); 404: #ifdef USE_KERNEL_MUTEX 405: KeInitializeMutex (&Extension->KernelMutex, 1); 406: #endif 407: KeInitializeSpinLock (&Extension->ListSpinLock); 408: InitializeListHead (&Extension->ListEntry); 409: 410: ASSERT (KeGetCurrentIrql ()== PASSIVE_LEVEL); 411: Dump ("TCCreateDeviceObject STATUS_SUCCESS END\n"); 412: 413: return STATUS_SUCCESS; 414: } 415: 416: /* TCDeviceControl handles certain requests from NT, these are needed for NT 417: to recognize the drive, also this function handles our device specific 418: function codes, such as mount/unmount */ 419: NTSTATUS 420: TCDeviceControl (PDEVICE_OBJECT DeviceObject, PEXTENSION Extension, PIRP Irp) 421: { 422: PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (Irp); 423: NTSTATUS ntStatus; 424: 425: #ifdef _DEBUG 426: Dump ("TCDeviceControl BEGIN IoControlCode = %ls 0x%08x\n", 427: TCTranslateCode (irpSp->Parameters.DeviceIoControl.IoControlCode), 428: irpSp->Parameters.DeviceIoControl.IoControlCode); 429: #endif 430: 431: Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST; /* Assume failure. */ 432: 433: /* Determine which I/O control code was specified. */ 434: switch (irpSp->Parameters.DeviceIoControl.IoControlCode) 435: { 436: 437: case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME: 438: if(irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (MOUNTDEV_NAME)) 439: { 440: Irp->IoStatus.Information = sizeof (MOUNTDEV_NAME); 441: Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW; 442: } 443: else 444: { 445: ULONG outLength; 446: UNICODE_STRING ntUnicodeString; 447: WCHAR ntName[64]; 448: PMOUNTDEV_NAME outputBuffer = (PMOUNTDEV_NAME) Irp->AssociatedIrp.SystemBuffer; 449: 450: Dump("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME:"); 451: 452: TCGetNTNameFromNumber (ntName, Extension->nDosDriveNo); 453: RtlInitUnicodeString (&ntUnicodeString, ntName); 454: 455: outputBuffer->NameLength = ntUnicodeString.Length; 456: outLength = ntUnicodeString.Length + sizeof(USHORT); 457: 458: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < outLength) 459: { 460: Irp->IoStatus.Information = sizeof (MOUNTDEV_NAME); 461: Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW; 462: 463: break; 464: } 465: 466: RtlCopyMemory ((PCHAR)outputBuffer->Name,ntUnicodeString.Buffer, ntUnicodeString.Length); 467: 468: Irp->IoStatus.Status = STATUS_SUCCESS; 469: Irp->IoStatus.Information = outLength; 470: 471: Dump ("name = %ls\n",ntName); 472: } 473: break; 474: 475: case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID: 476: if(irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (MOUNTDEV_UNIQUE_ID)) 477: { 478: Irp->IoStatus.Information = sizeof (MOUNTDEV_UNIQUE_ID); 479: Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW; 480: } 481: else 482: { 483: ULONG outLength; 484: UCHAR volId[128], tmp[] = { 0,0 }; 485: PMOUNTDEV_UNIQUE_ID outputBuffer = (PMOUNTDEV_UNIQUE_ID) Irp->AssociatedIrp.SystemBuffer; 486: 487: Dump("IOCTL_MOUNTDEV_QUERY_UNIQUE_ID:"); 488: 489: strcpy (volId, TC_UNIQUE_ID_PREFIX); 490: tmp[0] = 'A' + Extension->nDosDriveNo; 491: strcat (volId, tmp); 492: 493: outputBuffer->UniqueIdLength = (USHORT) strlen(volId); 494: outLength = strlen(volId) + sizeof(USHORT); 495: 496: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < outLength) 497: { 498: Irp->IoStatus.Information = sizeof (MOUNTDEV_UNIQUE_ID); 499: Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW; 500: break; 501: } 502: 503: RtlCopyMemory ((PCHAR)outputBuffer->UniqueId, volId, strlen(volId)); 504: 505: Irp->IoStatus.Status = STATUS_SUCCESS; 506: Irp->IoStatus.Information = outLength; 507: 508: Dump ("id = %s\n",volId); 509: } 510: break; 511: 512: case IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME: 513: { 514: ULONG outLength; 515: UNICODE_STRING ntUnicodeString; 516: WCHAR ntName[64]; 517: PMOUNTDEV_SUGGESTED_LINK_NAME outputBuffer = (PMOUNTDEV_SUGGESTED_LINK_NAME) Irp->AssociatedIrp.SystemBuffer; 518: 519: Dump("IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME:"); 520: 521: TCGetDosNameFromNumber (ntName, Extension->nDosDriveNo); 522: RtlInitUnicodeString (&ntUnicodeString, ntName); 523: 524: outLength = FIELD_OFFSET(MOUNTDEV_SUGGESTED_LINK_NAME,Name) + ntUnicodeString.Length; 525: 526: outputBuffer->UseOnlyIfThereAreNoOtherLinks = FALSE; 527: outputBuffer->NameLength = ntUnicodeString.Length; 528: 529: if(irpSp->Parameters.DeviceIoControl.OutputBufferLength < outLength) 530: { 531: Irp->IoStatus.Information = sizeof (MOUNTDEV_SUGGESTED_LINK_NAME); 532: Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW; 533: break; 534: } 535: 536: RtlCopyMemory ((PCHAR)outputBuffer->Name,ntUnicodeString.Buffer, ntUnicodeString.Length); 537: 538: Irp->IoStatus.Status = STATUS_SUCCESS; 539: Irp->IoStatus.Information = outLength; 540: 541: Dump ("link = %ls\n",ntName); 542: } 543: break; 544: 545: case IOCTL_DISK_GET_MEDIA_TYPES: 546: case IOCTL_DISK_GET_DRIVE_GEOMETRY: 547: /* Return the drive geometry for the disk. Note that we 548: return values which were made up to suit the disk size. */ 549: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < 550: sizeof (DISK_GEOMETRY)) 551: { 552: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 553: Irp->IoStatus.Information = 0; 554: } 555: else 556: { 557: PDISK_GEOMETRY outputBuffer = (PDISK_GEOMETRY) 558: Irp->AssociatedIrp.SystemBuffer; 559: 560: outputBuffer->MediaType = FixedMedia; 561: outputBuffer->Cylinders.QuadPart = Extension->NumberOfCylinders; 562: outputBuffer->TracksPerCylinder = Extension->TracksPerCylinder; 563: outputBuffer->SectorsPerTrack = Extension->SectorsPerTrack; 564: outputBuffer->BytesPerSector = Extension->BytesPerSector; 565: Irp->IoStatus.Status = STATUS_SUCCESS; 566: Irp->IoStatus.Information = sizeof (DISK_GEOMETRY); 567: } 568: break; 569: 570: case IOCTL_DISK_GET_PARTITION_INFO: 571: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < 572: sizeof (PARTITION_INFORMATION)) 573: { 574: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 575: Irp->IoStatus.Information = 0; 576: } 577: else 578: { 579: PPARTITION_INFORMATION outputBuffer = (PPARTITION_INFORMATION) 580: Irp->AssociatedIrp.SystemBuffer; 581: 582: outputBuffer->PartitionType = Extension->PartitionType; 583: outputBuffer->BootIndicator = FALSE; 584: outputBuffer->RecognizedPartition = TRUE; 585: outputBuffer->RewritePartition = FALSE; 586: outputBuffer->StartingOffset = RtlConvertUlongToLargeInteger (0); 587: outputBuffer->PartitionLength.QuadPart= Extension->DiskLength; 588: outputBuffer->HiddenSectors = 1L; 589: Irp->IoStatus.Status = STATUS_SUCCESS; 590: Irp->IoStatus.Information = sizeof (PARTITION_INFORMATION); 591: } 592: break; 593: 594: case IOCTL_DISK_GET_LENGTH_INFO: 595: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (GET_LENGTH_INFORMATION)) 596: { 597: Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW; 598: Irp->IoStatus.Information = sizeof (GET_LENGTH_INFORMATION); 599: } 600: else 601: { 602: PGET_LENGTH_INFORMATION outputBuffer = (PGET_LENGTH_INFORMATION) Irp->AssociatedIrp.SystemBuffer; 603: 604: outputBuffer->Length.QuadPart = Extension->DiskLength; 605: Irp->IoStatus.Status = STATUS_SUCCESS; 606: Irp->IoStatus.Information = sizeof (GET_LENGTH_INFORMATION); 607: } 608: break; 609: 610: case IOCTL_DISK_VERIFY: 611: { 612: PVERIFY_INFORMATION pVerifyInformation; 613: pVerifyInformation = (PVERIFY_INFORMATION) Irp->AssociatedIrp.SystemBuffer; 614: irpSp->Parameters.Read.ByteOffset.LowPart = 615: pVerifyInformation->StartingOffset.LowPart; 616: irpSp->Parameters.Read.ByteOffset.HighPart = 617: pVerifyInformation->StartingOffset.HighPart; 618: irpSp->Parameters.Read.Length = pVerifyInformation->Length; 619: Irp->IoStatus.Status = STATUS_SUCCESS; 620: Irp->IoStatus.Information = pVerifyInformation->Length; 621: } 622: break; 623: 624: case IOCTL_DISK_CHECK_VERIFY: 625: { 626: Irp->IoStatus.Status = STATUS_SUCCESS; 627: Irp->IoStatus.Information = 0; 628: } 629: break; 630: 631: case IOCTL_DISK_IS_WRITABLE: 632: { 633: if (Extension->bReadOnly == TRUE) 634: Irp->IoStatus.Status = STATUS_MEDIA_WRITE_PROTECTED; 635: else 636: Irp->IoStatus.Status = STATUS_SUCCESS; 637: Irp->IoStatus.Information = 0; 638: 639: } 640: break; 641: 642: case DRIVER_VERSION: 643: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < 4) 644: { 645: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 646: Irp->IoStatus.Information = 0; 647: } 648: else 649: { 650: LONG tmp = VERSION_NUM; 651: memcpy (Irp->AssociatedIrp.SystemBuffer, &tmp, 4); 652: Irp->IoStatus.Information = 4; 653: Irp->IoStatus.Status = STATUS_SUCCESS; 654: } 655: break; 656: 657: case OPEN_TEST: 658: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (OPEN_TEST_STRUCT)) 659: { 660: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 661: Irp->IoStatus.Information = 0; 662: } 663: else 664: { 665: OPEN_TEST_STRUCT *opentest = (OPEN_TEST_STRUCT *) Irp->AssociatedIrp.SystemBuffer; 666: OBJECT_ATTRIBUTES ObjectAttributes; 667: HANDLE NtFileHandle; 668: UNICODE_STRING FullFileName; 669: IO_STATUS_BLOCK IoStatus; 670: 671: RtlInitUnicodeString (&FullFileName, opentest->wszFileName); 672: 673: InitializeObjectAttributes (&ObjectAttributes, &FullFileName, OBJ_CASE_INSENSITIVE, 674: NULL, NULL); 675: 676: ntStatus = ZwCreateFile (&NtFileHandle, 677: SYNCHRONIZE | GENERIC_READ, &ObjectAttributes, &IoStatus, NULL /* alloc size = none */ , 678: FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT | 679: FILE_NO_INTERMEDIATE_BUFFERING | FILE_RANDOM_ACCESS, 680: NULL /* eabuffer */ , 0 /* ealength */ ); 681: 682: if (NT_SUCCESS (ntStatus)) 683: { 684: ZwClose (NtFileHandle); 685: Dump ("Open test on file %ls success.\n", opentest->wszFileName); 686: } 687: else 688: { 689: Dump ("Open test on file %ls failed NTSTATUS 0x%08x\n", opentest->wszFileName, ntStatus); 690: } 691: 692: Irp->IoStatus.Information = 0; 693: Irp->IoStatus.Status = ntStatus; 694: } 695: break; 696: 697: case WIPE_CACHE: 698: KeWaitForMutexObject (&driverMutex, Executive, KernelMode, 699: FALSE, NULL); 700: 701: WipeCache (); 702: 703: KeReleaseMutex (&driverMutex, FALSE); 704: 705: Irp->IoStatus.Status = STATUS_SUCCESS; 706: Irp->IoStatus.Information = 0; 707: break; 708: 709: case CACHE_STATUS: 710: Irp->IoStatus.Status = cacheEmpty ? STATUS_PIPE_EMPTY : STATUS_SUCCESS; 711: Irp->IoStatus.Information = 0; 712: break; 713: 714: #ifdef DEBUG 715: case HALT_SYSTEM: 716: KeBugCheck ((ULONG) 0x5050); 717: break; 718: #endif 719: 720: case MOUNT_LIST: 721: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (MOUNT_LIST_STRUCT)) 722: { 723: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 724: Irp->IoStatus.Information = 0; 725: } 726: else 727: { 728: MOUNT_LIST_STRUCT *list = (MOUNT_LIST_STRUCT *) Irp->AssociatedIrp.SystemBuffer; 729: PDEVICE_OBJECT ListDevice; 730: 731: list->ulMountedDrives = 0; 732: for (ListDevice = DeviceObject->DriverObject->DeviceObject; 733: ListDevice != (PDEVICE_OBJECT) NULL; ListDevice = ListDevice->NextDevice) 734: { 735: 736: PEXTENSION ListExtension = (PEXTENSION) ListDevice->DeviceExtension; 737: if (ListExtension->bRootDevice == FALSE) 738: { 739: list->ulMountedDrives |= (1 << ListExtension->nDosDriveNo); 740: wcscpy (list->wszVolume[ListExtension->nDosDriveNo], ListExtension->wszVolume); 741: list->diskLength[ListExtension->nDosDriveNo] = ListExtension->DiskLength; 742: list->cipher[ListExtension->nDosDriveNo] = ListExtension->cryptoInfo->cipher; 743: } 744: } 745: 746: Irp->IoStatus.Status = STATUS_SUCCESS; 747: Irp->IoStatus.Information = sizeof (MOUNT_LIST_STRUCT); 748: } 749: break; 750: 751: case VOLUME_PROPERTIES: 752: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (VOLUME_PROPERTIES_STRUCT)) 753: { 754: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 755: Irp->IoStatus.Information = 0; 756: } 757: else 758: { 759: VOLUME_PROPERTIES_STRUCT *prop = (VOLUME_PROPERTIES_STRUCT *) Irp->AssociatedIrp.SystemBuffer; 760: PDEVICE_OBJECT ListDevice; 761: 762: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 763: Irp->IoStatus.Information = 0; 764: 765: for (ListDevice = DeviceObject->DriverObject->DeviceObject; 766: ListDevice != (PDEVICE_OBJECT) NULL; ListDevice = ListDevice->NextDevice) 767: { 768: 769: PEXTENSION ListExtension = (PEXTENSION) ListDevice->DeviceExtension; 770: if (ListExtension->bRootDevice == FALSE && ListExtension->nDosDriveNo == prop->driveNo) 771: { 772: wcscpy (prop->wszVolume, ListExtension->wszVolume); 773: prop->diskLength = ListExtension->DiskLength; 774: prop->cipher = ListExtension->cryptoInfo->cipher; 775: prop->pkcs5 = ListExtension->cryptoInfo->pkcs5; 776: prop->pkcs5Iterations = ListExtension->cryptoInfo->noIterations; 777: prop->volumeCreationTime = ListExtension->cryptoInfo->volume_creation_time; 778: prop->headerCreationTime = ListExtension->cryptoInfo->header_creation_time; 779: 780: Irp->IoStatus.Status = STATUS_SUCCESS; 781: Irp->IoStatus.Information = sizeof (VOLUME_PROPERTIES_STRUCT); 782: break; 783: } 784: } 785: } 786: break; 787: 788: case UNMOUNT_PENDING: 789: Extension->bShuttingDown = TRUE; 790: Irp->IoStatus.Status = STATUS_NO_MEDIA_IN_DEVICE; 791: Irp->IoStatus.Information = 0; 792: if (DeviceObject->Vpb && DeviceObject->Vpb->Flags & VPB_MOUNTED) 793: { 794: IoSetHardErrorOrVerifyDevice (Irp, DeviceObject); 795: DeviceObject->Flags |= DO_VERIFY_VOLUME; 796: } 797: break; 798: 799: case UNMOUNT: 800: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (UNMOUNT_STRUCT)) 801: { 802: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 803: Irp->IoStatus.Information = 0; 804: } 805: else 806: { 807: UNMOUNT_STRUCT *unmount = (UNMOUNT_STRUCT *) Irp->AssociatedIrp.SystemBuffer; 808: PDEVICE_OBJECT ListDevice; 809: 810: unmount->nReturnCode = ERR_DRIVE_NOT_FOUND; 811: 812: for (ListDevice = DeviceObject->DriverObject->DeviceObject; 813: ListDevice != (PDEVICE_OBJECT) NULL; 814: ListDevice = ListDevice->NextDevice) 815: { 816: 817: PEXTENSION ListExtension = (PEXTENSION) ListDevice->DeviceExtension; 818: 819: if (ListExtension->bRootDevice == FALSE) 820: { 821: if (unmount->nDosDriveNo == ListExtension->nDosDriveNo) 822: { 823: if (ListDevice->Vpb && ListDevice->Vpb->ReferenceCount == 0 && (ListDevice->Vpb->Flags & VPB_MOUNTED) == 0) 824: { 825: Dump ("Deleting DeviceObject with ref count %ld\n", ListDevice->ReferenceCount); 826: ListDevice->ReferenceCount = 0; 827: TCDeleteDeviceObject (ListDevice, (PEXTENSION) ListDevice->DeviceExtension); 828: unmount->nReturnCode = 0; 829: break; 830: } 831: else 832: { 833: unmount->nReturnCode = ERR_FILES_OPEN; 834: break; 835: } 836: } /* if the drive numbers are 837: equal */ 838: } /* if it's not the root device */ 839: } /* for all the device objects the driver 840: knows about */ 841: 842: Irp->IoStatus.Information = sizeof (unmount->nReturnCode); 843: Irp->IoStatus.Status = STATUS_SUCCESS; 844: } 845: break; 846: 847: 848: case MOUNT: 849: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof (MOUNT_STRUCT)) 850: { 851: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; 852: Irp->IoStatus.Information = 0; 853: } 854: else 855: { 856: MOUNT_STRUCT *mount = (MOUNT_STRUCT *) Irp->AssociatedIrp.SystemBuffer; 857: ULONG *outputBuffer = (ULONG *) Irp->AssociatedIrp.SystemBuffer; 858: PDEVICE_OBJECT NewDeviceObject; 859: 860: /* Make sure the user is asking for a resonable 861: nDosDriveNo */ 862: if (mount->nDosDriveNo >= 0 && mount->nDosDriveNo <= 25) 863: { 864: Dump ("Mount request looks valid\n"); 865: } 866: else 867: { 868: Dump ("WARNING: MOUNT DRIVE LETTER INVALID\n"); 869: Irp->IoStatus.Information = sizeof (mount->nReturnCode); 870: Irp->IoStatus.Status = STATUS_SUCCESS; 871: mount->nReturnCode = ERR_BAD_DRIVE_LETTER; 872: break; 873: } 874: 875: ntStatus = TCCreateDeviceObject (DeviceObject->DriverObject, &NewDeviceObject, 876: mount->nDosDriveNo); 877: if (!NT_SUCCESS (ntStatus)) 878: { 879: Dump ("Mount CREATE DEVICE ERROR, ntStatus = 0x%08x\n", ntStatus); 880: Irp->IoStatus.Information = 0; 881: Irp->IoStatus.Status = ntStatus; 882: break; 883: } 884: else 885: { 886: PEXTENSION NewExtension = (PEXTENSION) NewDeviceObject->DeviceExtension; 887: ntStatus = TCStartThread (NewDeviceObject, NewExtension, mount); 888: if (!NT_SUCCESS (ntStatus)) 889: { 890: Dump ("Mount FAILURE NT ERROR, ntStatus = 0x%08x\n", ntStatus); 891: Irp->IoStatus.Information = 0; 892: Irp->IoStatus.Status = ntStatus; 893: TCDeleteDeviceObject (NewDeviceObject, NewExtension); 894: break; 895: } 896: else 897: { 898: if (mount->nReturnCode == 0) 899: { 900: Dump ("Mount SUCCESS TC code = 0x%08x READ-ONLY = %d\n", mount->nReturnCode, 901: NewExtension->bReadOnly); 902: if (NewExtension->bReadOnly == TRUE) 903: NewDeviceObject->Characteristics |= FILE_READ_ONLY_DEVICE; 904: NewDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING; 905: } 906: else 907: { 908: Dump ("Mount FAILURE TC code = 0x%08x\n", mount->nReturnCode); 909: TCDeleteDeviceObject (NewDeviceObject, NewExtension); 910: } 911: Irp->IoStatus.Information = sizeof (mount->nReturnCode); 912: Irp->IoStatus.Status = STATUS_SUCCESS; 913: break; 914: } 915: } 916: } 917: break; 918: } 919: 920: /* Finish the I/O operation by simply completing the packet and 921: returning the same NTSTATUS as in the packet itself. */ 922: ntStatus = COMPLETE_IRP (DeviceObject, Irp, Irp->IoStatus.Status, Irp->IoStatus.Information); 923: Dump ("TCDeviceControl NTSTATUS = 0x%08x END\n", ntStatus); 924: return ntStatus; 925: } 926: 927: NTSTATUS 928: TCStartThread (PDEVICE_OBJECT DeviceObject, PEXTENSION Extension, MOUNT_STRUCT * mount) 929: { 930: PTHREAD_BLOCK pThreadBlock = TCalloc (sizeof (THREAD_BLOCK)); 931: HANDLE hThread; 932: NTSTATUS ntStatus; 933: 934: Dump ("Starting thread...\n"); 935: 936: if (pThreadBlock == NULL) 937: { 938: return STATUS_INSUFFICIENT_RESOURCES; 939: } 940: else 941: { 942: pThreadBlock->DeviceObject = DeviceObject; 943: pThreadBlock->mount = mount; 944: } 945: 946: Extension->bThreadShouldQuit = FALSE; 947: 948: ntStatus = PsCreateSystemThread (&hThread, 949: THREAD_ALL_ACCESS, 950: NULL, 951: NULL, 952: NULL, 953: TCThreadIRP, 954: pThreadBlock); 955: 956: if (!NT_SUCCESS (ntStatus)) 957: { 958: Dump ("PsCreateSystemThread Failed END\n"); 959: TCfree (pThreadBlock); 960: return ntStatus; 961: } 962: 963: ObReferenceObjectByHandle (hThread, 964: THREAD_ALL_ACCESS, 965: NULL, 966: KernelMode, 967: &Extension->peThread, 968: NULL); 969: ZwClose (hThread); 970: 971: Dump ("Waiting for thread to initialize...\n"); 972: 973: KeWaitForSingleObject (&Extension->keCreateEvent, 974: UserRequest, 975: UserMode, 976: FALSE, 977: NULL); 978: 979: Dump ("Waiting completed! Thread returns 0x%08x\n", pThreadBlock->ntCreateStatus); 980: ntStatus = pThreadBlock->ntCreateStatus; 981: TCfree (pThreadBlock); 982: return ntStatus; 983: } 984: 985: void 986: TCStopThread (PDEVICE_OBJECT DeviceObject, PEXTENSION Extension) 987: { 988: NTSTATUS ntStatus; 989: 990: if (DeviceObject); /* Remove compiler warning */ 991: 992: Dump ("Signalling thread to quit...\n"); 993: 994: Extension->bThreadShouldQuit = TRUE; 995: 996: KeReleaseSemaphore (&Extension->RequestSemaphore, 997: 0, 998: 1, 999: TRUE); 1000: 1001: ntStatus = KeWaitForSingleObject (&Extension->peThread, 1002: UserRequest, 1003: UserMode, 1004: FALSE, 1005: NULL); 1006: if (ntStatus != STATUS_SUCCESS) 1007: Dump ("Failed waiting for crypto thread to quit: 0x%08x...\n", 1008: ntStatus); 1009: 1010: ObDereferenceObject (&Extension->peThread); 1011: Extension->peThread = NULL; 1012: 1013: Dump ("Thread exited!\n"); 1014: } 1015: 1016: /* TCThreadIRP does all the work of processing IRP's, and dispatching them 1017: to either the ReadWrite function or the DeviceControl function */ 1018: VOID 1019: TCThreadIRP (PVOID Context) 1020: { 1021: PTHREAD_BLOCK pThreadBlock = (PTHREAD_BLOCK) Context; 1022: PDEVICE_OBJECT DeviceObject = pThreadBlock->DeviceObject; 1023: PDRIVER_OBJECT DriverObject = DeviceObject->DriverObject; 1024: PEXTENSION Extension = (PEXTENSION) DeviceObject->DeviceExtension; 1025: LARGE_INTEGER queueWait; 1026: BOOL bDevice; 1027: 1028: /* Set thread priority to lowest realtime level. */ 1029: 1030: KeSetPriorityThread (KeGetCurrentThread (), LOW_REALTIME_PRIORITY); 1031: 1032: queueWait.QuadPart = -WAIT_SECONDS (1); 1033: 1034: Dump ("Mount THREAD OPENING VOLUME BEGIN\n"); 1035: 1036: #ifdef USE_KERNEL_MUTEX 1037: KeWaitForMutexObject (&Extension->KernelMutex, Executive, KernelMode, 1038: FALSE, NULL); 1039: #endif 1040: 1041: if (memcmp (pThreadBlock->mount->wszVolume, WIDE ("\\Device"), 14) != 0) 1042: { 1043: wcscpy (pThreadBlock->wszMountVolume, WIDE ("\\??\\")); 1044: wcscat (pThreadBlock->wszMountVolume, pThreadBlock->mount->wszVolume); 1045: bDevice = FALSE; 1046: } 1047: else 1048: { 1049: wcscpy (pThreadBlock->wszMountVolume, pThreadBlock->mount->wszVolume); 1050: bDevice = TRUE; 1051: } 1052: 1053: Dump ("Mount THREAD request for File %ls DriveNumber %d Device = %d\n", 1054: pThreadBlock->wszMountVolume, pThreadBlock->mount->nDosDriveNo, bDevice); 1055: 1056: pThreadBlock->ntCreateStatus = TCOpenVolume (DeviceObject, 1057: Extension, 1058: pThreadBlock->mount, 1059: pThreadBlock->wszMountVolume, 1060: bDevice); 1061: 1062: #ifdef USE_KERNEL_MUTEX 1063: KeReleaseMutex (&Extension->KernelMutex, FALSE); 1064: #endif 1065: 1066: if (!NT_SUCCESS (pThreadBlock->ntCreateStatus) || pThreadBlock->mount->nReturnCode != 0) 1067: { 1068: KeSetEvent (&Extension->keCreateEvent, 0, FALSE); 1069: PsTerminateSystemThread (STATUS_SUCCESS); 1070: } 1071: else 1072: { 1073: KeSetEvent (&Extension->keCreateEvent, 0, FALSE); 1074: /* From this point on pThreadBlock cannot be used as it will 1075: have been released! */ 1076: pThreadBlock = NULL; 1077: } 1078: 1079: 1080: for (;;) 1081: { 1082: NTSTATUS ntStatus; 1083: 1084: ASSERT (KeGetCurrentIrql ()== PASSIVE_LEVEL); 1085: 1086: /* Wait for a request from the dispatch routines. */ 1087: ntStatus = KeWaitForSingleObject ((PVOID) & Extension->RequestSemaphore, 1088: Executive, KernelMode, FALSE, &queueWait); 1089: 1090: if (ntStatus != STATUS_TIMEOUT) 1091: { 1092: 1093: #ifdef USE_KERNEL_MUTEX 1094: KeWaitForMutexObject (&Extension->KernelMutex, Executive, KernelMode, 1095: FALSE, NULL); 1096: #endif 1097: 1098: // Dump ("DRIVER THREAD PROCESSING DEVICEOBJECT 0x%08x \n", DeviceObject); 1099: 1100: for (;;) 1101: { 1102: PIO_STACK_LOCATION irpSp; 1103: PLIST_ENTRY request; 1104: PIRP Irp; 1105: 1106: request = ExInterlockedRemoveHeadList (&Extension->ListEntry, 1107: &Extension->ListSpinLock); 1108: if (request == NULL) 1109: break; 1110: 1111: ASSERT (KeGetCurrentIrql ()== PASSIVE_LEVEL); 1112: 1113: Irp = CONTAINING_RECORD (request, IRP, Tail.Overlay.ListEntry); 1114: irpSp = IoGetCurrentIrpStackLocation (Irp); 1115: 1116: switch (irpSp->MajorFunction) 1117: { 1118: case IRP_MJ_READ: 1119: case IRP_MJ_WRITE: 1120: TCReadWrite (DeviceObject, Extension, Irp); 1121: break; 1122: 1123: case IRP_MJ_FLUSH_BUFFERS: 1124: if (Extension->bRawDevice == FALSE) 1125: TCSendIRP_FileDevice (DeviceObject, Extension, NULL, Irp->Flags, IRP_MJ_FLUSH_BUFFERS, Irp); 1126: else 1127: { 1128: COMPLETE_IRP (DeviceObject, Irp, STATUS_SUCCESS, 0); 1129: } 1130: break; 1131: 1132: case IRP_MJ_SHUTDOWN: 1133: COMPLETE_IRP (DeviceObject, Irp, STATUS_SUCCESS, 0); 1134: break; 1135: 1136: case IRP_MJ_DEVICE_CONTROL: 1137: if (irpSp->Parameters.DeviceIoControl.IoControlCode != IOCTL_DISK_CHECK_VERIFY) 1138: TCDeviceControl (DeviceObject, Extension, Irp); 1139: else 1140: { 1141: if (Extension->bRawDevice == TRUE) 1142: TCSendIRP_RawDevice (DeviceObject, Extension, NULL, 0, IRP_MJ_DEVICE_CONTROL, Irp); 1143: else 1144: TCDeviceControl (DeviceObject, Extension, Irp); 1145: } 1146: break; 1147: } /* end of switch on 1148: irpSp->MajorFunction */ 1149: } /* for any remaining IRP's for this device */ 1150: 1151: #ifdef USE_KERNEL_MUTEX 1152: KeReleaseMutex (&Extension->KernelMutex, FALSE); 1153: #endif 1154: 1155: if (Extension->bThreadShouldQuit) 1156: { 1157: // Dump ("END PROCESSING DEVICEOBJECT THREAD ENDING 0x%08x Number = %d\n", 1158: // DeviceObject, Extension->nDosDriveNo); 1159: Dump ("Closing volume along with Thread!\n"); 1160: TCCloseVolume (DeviceObject, Extension); 1161: PsTerminateSystemThread (STATUS_SUCCESS); 1162: } 1163: //else 1164: //{ 1165: // Dump ("END PROCESSING DEVICEOBJECT 0x%08x Number = %d\n", 1166: // DeviceObject, Extension->nDosDriveNo); 1167: //} 1168: } 1169: 1170: } /* outermost for */ 1171: } 1172: 1173: void 1174: TCGetNTNameFromNumber (LPWSTR ntname, int nDriveNo) 1175: { 1176: WCHAR tmp[3] = 1177: {0, ':', 0}; 1178: int j = nDriveNo + (WCHAR) 'A'; 1179: 1180: tmp[0] = (short) j; 1181: wcscpy (ntname, (LPWSTR) NT_MOUNT_PREFIX); 1182: wcsncat (ntname, tmp, 1); 1183: } 1184: 1185: void 1186: TCGetDosNameFromNumber (LPWSTR dosname, int nDriveNo) 1187: { 1188: WCHAR tmp[3] = 1189: {0, ':', 0}; 1190: int j = nDriveNo + (WCHAR) 'A'; 1191: 1192: tmp[0] = (short) j; 1193: wcscpy (dosname, (LPWSTR) DOS_MOUNT_PREFIX); 1194: wcscat (dosname, tmp); 1195: } 1196: 1197: #ifdef _DEBUG 1198: LPWSTR 1199: TCTranslateCode (ULONG ulCode) 1200: { 1201: if (ulCode == IOCTL_DISK_GET_DRIVE_GEOMETRY) 1202: return (LPWSTR) _T ("IOCTL_DISK_GET_DRIVE_GEOMETRY"); 1203: else if (ulCode == IOCTL_DISK_GET_DRIVE_GEOMETRY_EX) 1204: return (LPWSTR) _T ("IOCTL_DISK_GET_DRIVE_GEOMETRY_EX"); 1205: else if (ulCode == IOCTL_MOUNTDEV_QUERY_DEVICE_NAME) 1206: return (LPWSTR) _T ("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME"); 1207: else if (ulCode == IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME) 1208: return (LPWSTR) _T ("IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME"); 1209: else if (ulCode == IOCTL_MOUNTDEV_QUERY_UNIQUE_ID) 1210: return (LPWSTR) _T ("IOCTL_MOUNTDEV_QUERY_UNIQUE_ID"); 1211: else if (ulCode == IOCTL_MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY) 1212: return (LPWSTR) _T ("IOCTL_MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY"); 1213: else if (ulCode == IOCTL_VOLUME_ONLINE) 1214: return (LPWSTR) _T ("IOCTL_VOLUME_ONLINE"); 1215: else if (ulCode == IOCTL_MOUNTDEV_LINK_CREATED) 1216: return (LPWSTR) _T ("IOCTL_MOUNTDEV_LINK_CREATED"); 1217: else if (ulCode == IOCTL_MOUNTDEV_LINK_DELETED) 1218: return (LPWSTR) _T ("IOCTL_MOUNTDEV_LINK_DELETED"); 1219: else if (ulCode == IOCTL_MOUNTMGR_QUERY_POINTS) 1220: return (LPWSTR) _T ("IOCTL_MOUNTMGR_QUERY_POINTS"); 1221: else if (ulCode == IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_CREATED) 1222: return (LPWSTR) _T ("IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_CREATED"); 1223: else if (ulCode == IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_DELETED) 1224: return (LPWSTR) _T ("IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_DELETED"); 1225: else if (ulCode == IOCTL_DISK_GET_LENGTH_INFO) 1226: return (LPWSTR) _T ("IOCTL_DISK_GET_LENGTH_INFO"); 1227: else if (ulCode == IOCTL_STORAGE_GET_DEVICE_NUMBER) 1228: return (LPWSTR) _T ("IOCTL_STORAGE_GET_DEVICE_NUMBER"); 1229: else if (ulCode == IOCTL_DISK_GET_PARTITION_INFO) 1230: return (LPWSTR) _T ("IOCTL_DISK_GET_PARTITION_INFO"); 1231: else if (ulCode == IOCTL_DISK_GET_PARTITION_INFO_EX) 1232: return (LPWSTR) _T ("IOCTL_DISK_GET_PARTITION_INFO_EX"); 1233: else if (ulCode == IOCTL_DISK_SET_PARTITION_INFO) 1234: return (LPWSTR) _T ("IOCTL_DISK_SET_PARTITION_INFO"); 1235: else if (ulCode == IOCTL_DISK_GET_DRIVE_LAYOUT) 1236: return (LPWSTR) _T ("IOCTL_DISK_GET_DRIVE_LAYOUT"); 1237: else if (ulCode == IOCTL_DISK_SET_DRIVE_LAYOUT_EX) 1238: return (LPWSTR) _T ("IOCTL_DISK_SET_DRIVE_LAYOUT_EX"); 1239: else if (ulCode == IOCTL_DISK_VERIFY) 1240: return (LPWSTR) _T ("IOCTL_DISK_VERIFY"); 1241: else if (ulCode == IOCTL_DISK_FORMAT_TRACKS) 1242: return (LPWSTR) _T ("IOCTL_DISK_FORMAT_TRACKS"); 1243: else if (ulCode == IOCTL_DISK_REASSIGN_BLOCKS) 1244: return (LPWSTR) _T ("IOCTL_DISK_REASSIGN_BLOCKS"); 1245: else if (ulCode == IOCTL_DISK_PERFORMANCE) 1246: return (LPWSTR) _T ("IOCTL_DISK_PERFORMANCE"); 1247: else if (ulCode == IOCTL_DISK_IS_WRITABLE) 1248: return (LPWSTR) _T ("IOCTL_DISK_IS_WRITABLE"); 1249: else if (ulCode == IOCTL_DISK_LOGGING) 1250: return (LPWSTR) _T ("IOCTL_DISK_LOGGING"); 1251: else if (ulCode == IOCTL_DISK_FORMAT_TRACKS_EX) 1252: return (LPWSTR) _T ("IOCTL_DISK_FORMAT_TRACKS_EX"); 1253: else if (ulCode == IOCTL_DISK_HISTOGRAM_STRUCTURE) 1254: return (LPWSTR) _T ("IOCTL_DISK_HISTOGRAM_STRUCTURE"); 1255: else if (ulCode == IOCTL_DISK_HISTOGRAM_DATA) 1256: return (LPWSTR) _T ("IOCTL_DISK_HISTOGRAM_DATA"); 1257: else if (ulCode == IOCTL_DISK_HISTOGRAM_RESET) 1258: return (LPWSTR) _T ("IOCTL_DISK_HISTOGRAM_RESET"); 1259: else if (ulCode == IOCTL_DISK_REQUEST_STRUCTURE) 1260: return (LPWSTR) _T ("IOCTL_DISK_REQUEST_STRUCTURE"); 1261: else if (ulCode == IOCTL_DISK_REQUEST_DATA) 1262: return (LPWSTR) _T ("IOCTL_DISK_REQUEST_DATA"); 1263: else if (ulCode == IOCTL_DISK_CONTROLLER_NUMBER) 1264: return (LPWSTR) _T ("IOCTL_DISK_CONTROLLER_NUMBER"); 1265: else if (ulCode == SMART_GET_VERSION) 1266: return (LPWSTR) _T ("SMART_GET_VERSION"); 1267: else if (ulCode == SMART_SEND_DRIVE_COMMAND) 1268: return (LPWSTR) _T ("SMART_SEND_DRIVE_COMMAND"); 1269: else if (ulCode == SMART_RCV_DRIVE_DATA) 1270: return (LPWSTR) _T ("SMART_RCV_DRIVE_DATA"); 1271: else if (ulCode == IOCTL_DISK_INTERNAL_SET_VERIFY) 1272: return (LPWSTR) _T ("IOCTL_DISK_INTERNAL_SET_VERIFY"); 1273: else if (ulCode == IOCTL_DISK_INTERNAL_CLEAR_VERIFY) 1274: return (LPWSTR) _T ("IOCTL_DISK_INTERNAL_CLEAR_VERIFY"); 1275: else if (ulCode == IOCTL_DISK_CHECK_VERIFY) 1276: return (LPWSTR) _T ("IOCTL_DISK_CHECK_VERIFY"); 1277: else if (ulCode == IOCTL_DISK_MEDIA_REMOVAL) 1278: return (LPWSTR) _T ("IOCTL_DISK_MEDIA_REMOVAL"); 1279: else if (ulCode == IOCTL_DISK_EJECT_MEDIA) 1280: return (LPWSTR) _T ("IOCTL_DISK_EJECT_MEDIA"); 1281: else if (ulCode == IOCTL_DISK_LOAD_MEDIA) 1282: return (LPWSTR) _T ("IOCTL_DISK_LOAD_MEDIA"); 1283: else if (ulCode == IOCTL_DISK_RESERVE) 1284: return (LPWSTR) _T ("IOCTL_DISK_RESERVE"); 1285: else if (ulCode == IOCTL_DISK_RELEASE) 1286: return (LPWSTR) _T ("IOCTL_DISK_RELEASE"); 1287: else if (ulCode == IOCTL_DISK_FIND_NEW_DEVICES) 1288: return (LPWSTR) _T ("IOCTL_DISK_FIND_NEW_DEVICES"); 1289: else if (ulCode == IOCTL_DISK_GET_MEDIA_TYPES) 1290: return (LPWSTR) _T ("IOCTL_DISK_GET_MEDIA_TYPES"); 1291: else if (ulCode == IOCTL_STORAGE_SET_HOTPLUG_INFO) 1292: return (LPWSTR) _T ("IOCTL_STORAGE_SET_HOTPLUG_INFO"); 1293: else if (ulCode == IRP_MJ_READ) 1294: return (LPWSTR) _T ("IRP_MJ_READ"); 1295: else if (ulCode == IRP_MJ_WRITE) 1296: return (LPWSTR) _T ("IRP_MJ_WRITE"); 1297: else if (ulCode == IRP_MJ_CREATE) 1298: return (LPWSTR) _T ("IRP_MJ_CREATE"); 1299: else if (ulCode == IRP_MJ_CLOSE) 1300: return (LPWSTR) _T ("IRP_MJ_CLOSE"); 1301: else if (ulCode == IRP_MJ_CLEANUP) 1302: return (LPWSTR) _T ("IRP_MJ_CLEANUP"); 1303: else if (ulCode == IRP_MJ_FLUSH_BUFFERS) 1304: return (LPWSTR) _T ("IRP_MJ_FLUSH_BUFFERS"); 1305: else if (ulCode == IRP_MJ_SHUTDOWN) 1306: return (LPWSTR) _T ("IRP_MJ_SHUTDOWN"); 1307: else if (ulCode == IRP_MJ_DEVICE_CONTROL) 1308: return (LPWSTR) _T ("IRP_MJ_DEVICE_CONTROL"); 1309: else if (ulCode == MOUNT) 1310: return (LPWSTR) _T ("MOUNT"); 1311: else if (ulCode == UNMOUNT) 1312: return (LPWSTR) _T ("UNMOUNT"); 1313: else if (ulCode == MOUNT_LIST) 1314: return (LPWSTR) _T ("MOUNT_LIST"); 1315: else if (ulCode == OPEN_TEST) 1316: return (LPWSTR) _T ("OPEN_TEST"); 1317: else if (ulCode == UNMOUNT_PENDING) 1318: return (LPWSTR) _T ("UNMOUNT_PENDING"); 1319: else 1320: { 1321: Dump("Unknown IOCTL recieved: DeviceType = 0x%x Function = 0x%x", (int)(ulCode>>16), (int)((ulCode&0x1FFF)>>2)); 1322: return (LPWSTR) _T ("UNKNOWN"); 1323: } 1324: } 1325: 1326: #endif 1327: 1328: PDEVICE_OBJECT 1329: TCDeleteDeviceObject (PDEVICE_OBJECT DeviceObject, PEXTENSION Extension) 1330: { 1331: PDEVICE_OBJECT OldDeviceObject = DeviceObject; 1332: UNICODE_STRING Win32NameString; 1333: WCHAR dosname[32]; 1334: NTSTATUS ntStatus; 1335: 1336: Dump ("TCDeleteDeviceObject BEGIN\n"); 1337: 1338: if (Extension->bRootDevice == TRUE) 1339: { 1340: RtlInitUnicodeString (&Win32NameString, (LPWSTR) DOS_ROOT_PREFIX); 1341: } 1342: else 1343: { 1344: if (Extension->peThread != NULL) 1345: TCStopThread (DeviceObject, Extension); 1346: TCGetDosNameFromNumber (dosname, Extension->nDosDriveNo); 1347: RtlInitUnicodeString (&Win32NameString, dosname); 1348: } 1349: 1350: ntStatus = IoDeleteSymbolicLink (&Win32NameString); 1351: if (!NT_SUCCESS (ntStatus)) 1352: { 1353: Dump ("IoDeleteSymbolicLink failed ntStatus = 0x%08x\n", ntStatus); 1354: } 1355: 1356: DeviceObject = DeviceObject->NextDevice; 1357: IoDeleteDevice (OldDeviceObject); 1358: 1359: Dump ("TCDeleteDeviceObject END\n"); 1360: return DeviceObject; 1361: } 1362: 1363: VOID 1364: TCUnloadDriver (PDRIVER_OBJECT DriverObject) 1365: { 1366: PDEVICE_OBJECT DeviceObject = DriverObject->DeviceObject; 1367: 1368: Dump ("TCUnloadDriver BEGIN\n"); 1369: 1370: /* Now walk the list of driver objects and get rid of them */ 1371: while (DeviceObject != (PDEVICE_OBJECT) NULL) 1372: { 1373: DeviceObject = TCDeleteDeviceObject (DeviceObject, 1374: (PEXTENSION) DeviceObject->DeviceExtension); 1375: } 1376: 1377: Dump ("TCUnloadDriver END\n"); 1378: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.