//--------------------
// Функция обработки запроса информации о файле
//
NTSTATUS DispatchQueryInformation(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) {

	NTSTATUS status = STATUS_SUCCESS;
	PIO_STACK_LOCATION pIrpStack;
	ULONG info = 0;
	FILE_BASIC_INFORMATION *fbi;
	FILE_STANDARD_INFORMATION *fsi;

	pIrpStack = IoGetCurrentIrpStackLocation(pIrp);

	switch (pIrpStack->Parameters.QueryFile.FileInformationClass) {

	case FileStandardInformation:
		info = sizeof(FILE_STANDARD_INFORMATION);
		if (info > pIrpStack->Parameters.QueryFile.Length) {
			info = 0;
			break;
		}

		fsi = (FILE_STANDARD_INFORMATION*)pIrp->AssociatedIrp.SystemBuffer;
		fsi->AllocationSize.QuadPart = 0;
		fsi->EndOfFile.QuadPart = 1000;  // размер файла
		fsi->NumberOfLinks = 1;             // количество жёстких ссылок
		fsi->Directory = FALSE;
		fsi->DeletePending = FALSE;
		break;
	}

	return CompleteIrp(pIrp, status, info);
}
//
// Функция обработки запроса на чтение.
//
NTSTATUS DispatchRead(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) {

	NTSTATUS status = STATUS_SUCCESS;
	PIO_STACK_LOCATION pIrpStack;
	ULONG info = 0;
	char *inputBuffer;
	PLIST_ENTRY link;

	pIrpStack = IoGetCurrentIrpStackLocation(pIrp);

	if (pDeviceObject->Flags & DO_BUFFERED_IO) {
		inputBuffer = (char*)pIrp->AssociatedIrp.SystemBuffer;
	}
	else {
		inputBuffer = (char*)pIrp->UserBuffer;
	}

	for (link = glOpenFiles.Flink; link != &glOpenFiles; link = link->Flink) {
		OpenFileEntry *entry = CONTAINING_RECORD(link, OpenFileEntry, link);
		if (info + entry->fileName.Length + 1 <= pIrpStack->Parameters.Read.Length) {
			RtlCopyMemory(inputBuffer + info, entry->fileName.Buffer, entry->fileName.Length);
			info += entry->fileName.Length;
			inputBuffer[info++] = '\n';
		}
		else {
			break;
		}
	}
	return CompleteIrp(pIrp, status, info); // Завершение IRP
}
NTSTATUS SecLabReceivePacket(PADAPT	pAdapt,IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)
{	
	// 某一时刻只有一个读IRP被允许存放在队列中

	NdisAcquireSpinLock(&ReadIrpLock);
	if(ReadIrp!=NULL /*&& ReadCount!=0*/)
	{
		NdisReleaseSpinLock(&ReadIrpLock);
		return CompleteIrp(Irp,STATUS_UNSUCCESSFUL,0);
	}

	// 看是否成功取出封包数据
	if( PickPacketFromList(pAdapt,Irp))
	{
        ReadCount=0;
		ReadIrp=NULL;
		NdisReleaseSpinLock(&ReadIrpLock);
		return STATUS_SUCCESS;
	}

	// 如果队列中没有封包数据,就将此IRP排队
	ReadIrp = Irp;
	ReadCount=1;

	// Mark Irp as pending and set Cancel routine
	Irp->IoStatus.Information = 0;
	Irp->IoStatus.Status = STATUS_PENDING;
	IoMarkIrpPending(Irp);
	IoSetCancelRoutine(Irp,SecLabCancelIrp);

	NdisReleaseSpinLock(&ReadIrpLock);

	return STATUS_PENDING;
}
示例#4
0
NTSTATUS PnpQueryCapabilitiesHandler( IN PDEVICE_EXTENSION pdx, IN PIRP Irp)
{
	NTSTATUS status = ForwardAndWait( pdx, Irp);
	if( NT_SUCCESS(status))
	{
		PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
		PDEVICE_CAPABILITIES deviceCapabilities;
		deviceCapabilities = IrpStack->Parameters.DeviceCapabilities.Capabilities;

		for(int ds=PowerSystemWorking;ds<PowerSystemMaximum;ds++)
			KdPrint(("Capabilities from bus: DeviceState[%d]=%d", ds, deviceCapabilities->DeviceState[ds]));
		DEVICE_POWER_STATE dps;

		SetMostPoweredState( PowerSystemWorking, PowerDeviceD0);
		SetMostPoweredState( PowerSystemSleeping1, PowerDeviceD3);
		SetMostPoweredState( PowerSystemSleeping2, PowerDeviceD3);
		SetMostPoweredState( PowerSystemSleeping3, PowerDeviceD3);
		SetMostPoweredState( PowerSystemHibernate, PowerDeviceD3);
		SetMostPoweredState( PowerSystemShutdown, PowerDeviceD3);

		//重点就是这句话了
		deviceCapabilities->Removable=TRUE;
		for(ds=PowerSystemWorking;ds<PowerSystemMaximum;ds++)
			KdPrint(("Capabilities now: DeviceState[%d]=%d", ds, deviceCapabilities->DeviceState[ds]));
	}

	return CompleteIrp( Irp, status, Irp->IoStatus.Information);
}
示例#5
0
NTSTATUS Wdm1Close(IN PDEVICE_OBJECT fdo,
	IN PIRP Irp)
{
	DebugPrintMsg("Close");

	// Complete successfully
	return CompleteIrp(Irp, STATUS_SUCCESS, 0);
}
示例#6
0
NTSTATUS Wdm1Write(IN PDEVICE_OBJECT fdo,
	IN PIRP Irp)
{
	PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
	NTSTATUS status = STATUS_SUCCESS;
	LONG BytesTxd = 0;

	// Get call parameters
	LONGLONG FilePointer = IrpStack->Parameters.Write.ByteOffset.QuadPart;
	ULONG WriteLen = IrpStack->Parameters.Write.Length;
	DebugPrint("Write %d bytes from file pointer %d", (int)WriteLen, (int)FilePointer);

	if (FilePointer < 0)
		status = STATUS_INVALID_PARAMETER;
	else
	{
		// Get access to the shared buffer
		KIRQL irql;
		KeAcquireSpinLock(&BufferLock, &irql);

		BytesTxd = WriteLen;

		// (Re)allocate buffer if necessary
		if (((ULONG)FilePointer) + WriteLen > BufferSize)
		{
			ULONG NewBufferSize = ((ULONG)FilePointer) + WriteLen;
			PVOID NewBuffer = ExAllocatePool(NonPagedPool, NewBufferSize);
			if (NewBuffer == NULL)
			{
				BytesTxd = BufferSize - (ULONG)FilePointer;
				if (BytesTxd < 0) BytesTxd = 0;
			}
			else
			{
				RtlZeroMemory(NewBuffer, NewBufferSize);
				if (Buffer != NULL)
				{
					RtlCopyMemory(NewBuffer, Buffer, BufferSize);
					ExFreePool(Buffer);
				}
				Buffer = (PUCHAR)NewBuffer;
				BufferSize = NewBufferSize;
			}
		}

		// Write to shared memory
		if (BytesTxd>0 && Buffer != NULL)
			RtlCopyMemory(Buffer + FilePointer, Irp->AssociatedIrp.SystemBuffer, BytesTxd);

		// Release shared buffer
		KeReleaseSpinLock(&BufferLock, irql);
	}

	DebugPrint("Write: %d bytes written", (int)BytesTxd);

	// Complete IRP
	return CompleteIrp(Irp, status, BytesTxd);
}
示例#7
0
NTSTATUS Wdm1Create(IN PDEVICE_OBJECT fdo,
	IN PIRP Irp)
{
	PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
	DebugPrint("Create File is %T", &(IrpStack->FileObject->FileName));

	Stack_Init(&s);

	// Complete successfully
	return CompleteIrp(Irp, STATUS_SUCCESS, 0);
}
示例#8
0
VOID CancelQueue(PC0C_IRP_QUEUE pQueue, PLIST_ENTRY pQueueToComplete)
{
  while (pQueue->pCurrent) {
    PIRP pIrp;

    pIrp = pQueue->pCurrent;
    ShiftQueue(pQueue);

    CompleteIrp(pIrp, STATUS_CANCELLED, pQueueToComplete);
  }
}
//
// Функция обработки запроса на открытие устройства драйвера.
//
NTSTATUS DispatchCreate(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) {

	NTSTATUS status = STATUS_SUCCESS;   // статус завершения операции ввода/вывода
	PIO_STACK_LOCATION pIrpStack;       // указатель на текущий элемент стека IRP-пакета
	ULONG info = 0;                     // количество возвращённых байт


	pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
	KdPrint(("Open file %wZ\n", &pIrpStack->FileObject->FileName));

	return CompleteIrp(pIrp, status, info); // Завершение IRP
}
//
// Функция обработки запроса на закрытие устройства драйвера.
//
NTSTATUS DispatchClose(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) {

	NTSTATUS status = STATUS_SUCCESS;
	PIO_STACK_LOCATION pIrpStack;
	ULONG info = 0;


	pIrpStack = IoGetCurrentIrpStackLocation(pIrp);


	return CompleteIrp(pIrp, status, info);
}
VOID SecLabCancelIrp(IN PDEVICE_OBJECT DeviceObject,
					 IN PIRP Irp)
{
	IoReleaseCancelSpinLock(Irp->CancelIrql);

	// If this is our queued read, then unqueue it
	NdisAcquireSpinLock(&ReadIrpLock);
	if( Irp==ReadIrp)
	{
		ReadIrp = NULL;
		ReadCount=0;
	}
	NdisReleaseSpinLock(&ReadIrpLock);

	// Whatever Irp it is, just cancel it
	CompleteIrp(Irp,STATUS_CANCELLED,0);
}
示例#12
0
NTSTATUS Wdm1Read(IN PDEVICE_OBJECT fdo,
	IN PIRP Irp)
{
	PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
	NTSTATUS status = STATUS_SUCCESS;
	LONG BytesTxd = 0;

	// Get call parameters
	LONGLONG FilePointer = IrpStack->Parameters.Read.ByteOffset.QuadPart;
	ULONG ReadLen = IrpStack->Parameters.Read.Length;
	DebugPrint("Read %d bytes from file pointer %d", (int)ReadLen, (int)FilePointer);

	// Get access to the shared buffer
	KIRQL irql;
	KeAcquireSpinLock(&BufferLock, &irql);

	// Check file pointer
	if (FilePointer < 0)
		status = STATUS_INVALID_PARAMETER;
	if (FilePointer >= (LONGLONG)BufferSize)
		status = STATUS_END_OF_FILE;

	if (status == STATUS_SUCCESS)
	{
		// Get transfer count
		if (((ULONG)FilePointer) + ReadLen > BufferSize)
		{
			BytesTxd = BufferSize - (ULONG)FilePointer;
			if (BytesTxd < 0) BytesTxd = 0;
		}
		else
			BytesTxd = ReadLen;

		// Read from shared buffer
		if (BytesTxd>0 && Buffer != NULL)
			RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Buffer + FilePointer, BytesTxd);
	}

	// Release shared buffer
	KeReleaseSpinLock(&BufferLock, irql);

	DebugPrint("Read: %d bytes returned", (int)BytesTxd);

	// Complete IRP
	return CompleteIrp(Irp, status, BytesTxd);
}
示例#13
0
NTSTATUS
    DriverIrpHandler(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    NTSTATUS Status;
    BOOLEAN bHandled = FALSE;
    PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
    
    KLOG(LInfo, "DevObj %p Major %x Minor %x", DeviceObject, currentIrpStack->MajorFunction, currentIrpStack->MinorFunction);
	Status = KbdDispatchGeneral(&MonitorGetInstance()->Kbd, DeviceObject, Irp, &bHandled);
    if (bHandled)
        return Status;

    if (currentIrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL) {
        return DriverDeviceControlHandler(DeviceObject, Irp);
    } else {
        return CompleteIrp(Irp, STATUS_SUCCESS, 0); 
    }
}
示例#14
0
NTSTATUS UsbKbdCreate(	IN PDEVICE_OBJECT fdo,
					IN PIRP Irp)
{
	PUSBKBD_DEVICE_EXTENSION dx = (PUSBKBD_DEVICE_EXTENSION)fdo->DeviceExtension;
	PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
	DebugPrint( "Create File is %T", &(IrpStack->FileObject->FileName));

	if( dx->IODisabled)
		return CompleteIrp( Irp, STATUS_DEVICE_NOT_CONNECTED, 0);

	InterlockedIncrement(&dx->OpenHandleCount);

	// Display USB host controller driver info
	USBD_VERSION_INFORMATION vi;
	USBD_GetUSBDIVersion(&vi);
	DebugPrint("USBDI version %x Supported version %x", vi.USBDI_Version, vi.Supported_USB_Version);

	// Reset device and select HID keyboard configuration
	UsbResetDevice(dx);
	UsbSelectConfiguration(dx);

	// DebugPrint USB info
	UsbGetUsbInfo(dx);

	// DebugPrint string lang ids
	ULONG StringsLen = 50;
	PVOID pvstrings;
	NTSTATUS status = UsbGetSpecifiedDescriptor( dx, pvstrings, USB_STRING_DESCRIPTOR_TYPE, StringsLen);
	if( NT_SUCCESS(status))
	if( StringsLen>0)
	{
		PUSB_STRING_DESCRIPTOR strings = (PUSB_STRING_DESCRIPTOR)pvstrings;
		ULONG LangIds = (strings->bLength - FIELD_OFFSET( USB_STRING_DESCRIPTOR, bString[0]))>>1;
		DebugPrint("StringsLen %d LangIds %d",StringsLen,LangIds);
		if( LangIds>0)
			for( ULONG LangIdNo=0; LangIdNo<LangIds; LangIdNo++)
				DebugPrint("LangId[%d]=%4x",LangIdNo,strings->bString[LangIdNo]);
	}
示例#15
0
NTSTATUS DriverDeviceControlHandler( IN PDEVICE_OBJECT fdo, IN PIRP Irp )
{
    NTSTATUS Status = STATUS_SUCCESS;
    PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG ControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
    ULONG method = ControlCode & 0x3;
    ULONG ResultLength = 0;
    ULONG InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
    ULONG OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
    PVOID Buffer = Irp->AssociatedIrp.SystemBuffer;

	KeEnterGuardedRegion();

    KLOG(LInfo, "IoControl fdo %p, ioctl %x", fdo, ControlCode);
	if (OutputLength < InputLength) {
		KLog(LError, "invalid outputlen=%x vs inputlen=%x", OutputLength, InputLength);
		Status = STATUS_INVALID_PARAMETER;
		goto complete;
	}
	
	ResultLength = InputLength;

    switch( ControlCode) {
        case IOCTL_KMON_INIT:
            {   
				PKMON_INIT initData = (PKMON_INIT)Buffer;
				if (InputLength < sizeof(KMON_INIT)) {
					Status = STATUS_BUFFER_TOO_SMALL;
					goto complete;
				}

                KLog(LInfo, "IOCTL_KMON_INIT");
				Status = MonitorStart(initData);
                break;
            }
        case IOCTL_KMON_RELEASE:
            {
				PKMON_RELEASE releaseData = (PKMON_RELEASE)Buffer;
				if (InputLength < sizeof(KMON_RELEASE)) {
					Status = STATUS_BUFFER_TOO_SMALL;
					goto complete;
				}
                KLog(LInfo, "IOCTL_KMON_RELEASE");
				Status = MonitorStop(releaseData);
                break;
            }
		case IOCTL_KMON_OPEN_WINSTA:
			{
				POPEN_WINSTA openWinsta = (POPEN_WINSTA)Buffer;
				if (InputLength < sizeof(OPEN_WINSTA)) {
					Status = STATUS_BUFFER_TOO_SMALL;
					goto complete;
				}
				Status = MonitorOpenWinsta(openWinsta);
				break;
			}
		case IOCTL_KMON_OPEN_DESKTOP:
		{
				POPEN_DESKTOP openDeskop = (POPEN_DESKTOP)Buffer;
				if (InputLength < sizeof(OPEN_DESKTOP)) {
					Status = STATUS_BUFFER_TOO_SMALL;
					goto complete;
				}
				Status = MonitorOpenDesktop(openDeskop);
				break;
		}
		case IOCTL_KMON_SCREENSHOT:
		{
				PKMON_SCREENSHOT screenShot = (PKMON_SCREENSHOT)Buffer;
				if (InputLength < sizeof(KMON_SCREENSHOT)) {
					Status = STATUS_BUFFER_TOO_SMALL;
					goto complete;
				}
				Status = MonitorScreenshot(screenShot);
				break;
		}
        default: Status = STATUS_INVALID_DEVICE_REQUEST;
    }


complete:
	KeLeaveGuardedRegion();
	KLog(LInfo, "dev=%p IoControl: %x bytes: %x, Status=%x", fdo, ControlCode, ResultLength, Status);

    return CompleteIrp(Irp, Status, ResultLength);
}
示例#16
0
NTSTATUS FdoPortStartIrp(
    IN PC0C_IO_PORT pIoPort,
    IN PIRP pIrp,
    IN UCHAR iQueue,
    IN PC0C_FDOPORT_START_ROUTINE pStartRoutine)
{
  NTSTATUS status;
  LIST_ENTRY queueToComplete;
  KIRQL oldIrql;
  PC0C_IRP_QUEUE pQueue;
  PC0C_IRP_STATE pState;

  InitializeListHead(&queueToComplete);
  pState = GetIrpState(pIrp);

  HALT_UNLESS(pState);

  pState->flags = 0;
  pState->iQueue = iQueue;

  pQueue = &pIoPort->irpQueues[iQueue];

  KeAcquireSpinLock(pIoPort->pIoLock, &oldIrql);

  #pragma warning(push, 3)
  IoSetCancelRoutine(pIrp, CancelRoutine);
  #pragma warning(pop)

  if (pIrp->Cancel) {
    status = NoPending(pIrp, STATUS_CANCELLED);
  } else {
    if (!pQueue->pCurrent) {
      status = StartIrp(pIoPort, pIrp, pState, pQueue, &queueToComplete, pStartRoutine);
    } else {
      PIO_STACK_LOCATION pIrpStack;
      PIO_STACK_LOCATION pCurrentStack;

      pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
      pCurrentStack = IoGetCurrentIrpStackLocation(pQueue->pCurrent);

      if (pIrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
          pIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_WAIT_ON_MASK)
      {
        status = NoPending(pIrp, STATUS_INVALID_PARAMETER);
      }
      else
      if (pIrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
          pIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_IMMEDIATE_CHAR)
      {
        if (pCurrentStack->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
            pCurrentStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_IMMEDIATE_CHAR)
        {
          status = NoPending(pIrp, STATUS_INVALID_PARAMETER);
        } else {
          PC0C_IRP_STATE pCurrentState;

          pCurrentState = GetIrpState(pQueue->pCurrent);

          HALT_UNLESS(pCurrentState);

          pCurrentState->flags &= ~C0C_IRP_FLAG_IS_CURRENT;
          InsertHeadList(&pQueue->queue, &pQueue->pCurrent->Tail.Overlay.ListEntry);
          pCurrentState->flags |= C0C_IRP_FLAG_IN_QUEUE;

          status = StartIrp(pIoPort, pIrp, pState, pQueue, &queueToComplete, pStartRoutine);
        }
      }
      else {
        InsertTailList(&pQueue->queue, &pIrp->Tail.Overlay.ListEntry);
        pState->flags |= C0C_IRP_FLAG_IN_QUEUE;

        if (pState->iQueue == C0C_QUEUE_WRITE) {
          pIoPort->amountInWriteQueue += GetWriteLength(pIrp);
        }

        if (pCurrentStack->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
            pCurrentStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_XOFF_COUNTER &&
            pQueue->pCurrent->IoStatus.Information)
        {
          if (pIrpStack->MajorFunction == IRP_MJ_FLUSH_BUFFERS) {
            RemoveEntryList(&pIrp->Tail.Overlay.ListEntry);
            pState->flags &= ~C0C_IRP_FLAG_IN_QUEUE;
            status = NoPending(pIrp, STATUS_SUCCESS);
          } else {
            PIRP pIrpXoffCounter = pQueue->pCurrent;

            ShiftQueue(pQueue);
            CompleteIrp(pIrpXoffCounter, STATUS_SERIAL_MORE_WRITES, &queueToComplete);

            status = StartIrp(pIoPort, pIrp, pState, pQueue, &queueToComplete, pStartRoutine);
          }
        } else {
          pIrp->IoStatus.Status = STATUS_PENDING;
          IoMarkIrpPending(pIrp);
          status = STATUS_PENDING;
        }
      }
    }
  }

  KeReleaseSpinLock(pIoPort->pIoLock, oldIrql);

  FdoPortCompleteQueue(&queueToComplete);

  return status;
}
示例#17
0
NTSTATUS Wdm1DeviceControl(IN PDEVICE_OBJECT fdo,
	IN PIRP Irp)
{
	PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
	NTSTATUS status = STATUS_SUCCESS;
	ULONG BytesTxd = 0;

	ULONG ControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
	ULONG InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
	ULONG OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;

	DebugPrint("DeviceIoControl: Control code %x InputLength %d OutputLength %d",
		ControlCode, InputLength, OutputLength);

	// Get access to the shared buffer
	KIRQL irql;
	KeAcquireSpinLock(&BufferLock, &irql);
	switch (ControlCode)
	{
		///////	Zero Buffer
	case IOCTL_WDM1_ZERO_BUFFER:
		// Zero the buffer
		if (Buffer != NULL && BufferSize > 0)
			RtlZeroMemory(Buffer, BufferSize);
		break;

		///////	Remove Buffer
	case IOCTL_WDM1_REMOVE_BUFFER:
		if (Buffer != NULL)
		{
			ExFreePool(Buffer);
			Buffer = NULL;
			BufferSize = 0;
		}
		break;

		///////	Get Buffer Size as ULONG
	case IOCTL_WDM1_GET_BUFFER_SIZE:
		if (OutputLength < sizeof(ULONG))
			status = STATUS_INVALID_PARAMETER;
		else
		{
			BytesTxd = sizeof(ULONG);
			RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, &BufferSize, sizeof(ULONG));
		}
		break;

		///////	Get Buffer
	case IOCTL_WDM1_GET_BUFFER:
		if (OutputLength > BufferSize)
			status = STATUS_INVALID_PARAMETER;
		else
		{
			BytesTxd = OutputLength;
			RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Buffer, BytesTxd);
		}
		break;

		///////	Get DateTime
	case IOCTL_WDM1_GET_BUILDTIME:
	{
		if (OutputLength < dateTimeSize){
			status = STATUS_INVALID_PARAMETER;
		}
		else {
			memset(dateTimeBuffer, 0, dateTimeSize);
			strcpy(dateTimeBuffer, __DATE__);
			strcat(dateTimeBuffer, " ");
			strcat(dateTimeBuffer, __TIME__);
			DebugPrint("DateTime: %s", dateTimeBuffer);
			BytesTxd = dateTimeSize;
			RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, dateTimeBuffer, dateTimeSize);
		}
	}
		break;

		/////// ------------- RPN STACK --------------------
	case IOCTL_WDM1_RPN_PUSH:
	{
		int value = 0;
		RtlCopyMemory(&value, Irp->AssociatedIrp.SystemBuffer, 4); // 4 byte = 32bit
		BytesTxd = 4;
		if (!Stack_Push(&s, value)){
			status = STATUS_UNSUCCESSFUL;
			BytesTxd = 0;
		}
		DebugPrintStack();
	}
		break;

	case IOCTL_WDM1_RPN_POP:
	{
		if (OutputLength < 4) {
			status = STATUS_INVALID_PARAMETER;
		}
		else {
			int value = 0;
			if (Stack_Pop(&s, value)){
				BytesTxd = 4;
				RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, &value, BytesTxd);
			}
			else {
				BytesTxd = 0;
				status = STATUS_UNSUCCESSFUL;
			}
		}
	}
		break;

	case IOCTL_WDM1_RPN_ADD:
		if (!RpnCalculator_Add(&s)){
			BytesTxd = 0;
			status = STATUS_UNSUCCESSFUL;
		}
		break;

	case IOCTL_WDM1_RPN_SUB:
		if (!RpnCalculator_Substract(&s)){
			BytesTxd = 0;
			status = STATUS_UNSUCCESSFUL;
		}
		break;

	case IOCTL_WDM1_RPN_MULT:
		if (!RpnCalculator_Multiply(&s)){
			BytesTxd = 0;
			status = STATUS_UNSUCCESSFUL;
		}
		break;

	case IOCTL_WDM1_RPN_DIV:
		if (!RpnCalculator_Divide(&s)){
			BytesTxd = 0;
			status = STATUS_UNSUCCESSFUL;
		}
		break;

	case IOCTL_WDM1_RPN_GETDIVREST:
		if (!RpnCalculator_Modulo(&s)){
			BytesTxd = 0;
			status = STATUS_UNSUCCESSFUL;
		}
		break;

	case IOCTL_WDM1_RPN_DUPLI:
		if (!Stack_Dup(&s)){
			BytesTxd = 0;
			status = STATUS_UNSUCCESSFUL;
		}
		DebugPrintStack();
		break;

		///////	Invalid request
	default:
		status = STATUS_INVALID_DEVICE_REQUEST;
	}
	// Release shared buffer
	KeReleaseSpinLock(&BufferLock, irql);

	DebugPrint("DeviceIoControl: %d bytes written", (int)BytesTxd);

	// Complete IRP
	return CompleteIrp(Irp, status, BytesTxd);
}
//
// Функция обработки запроса на запись.
//
NTSTATUS DispatchWrite(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) {

	NTSTATUS status = STATUS_SUCCESS;
	PIO_STACK_LOCATION pIrpStack;
	ULONG info = 0;
	OpenFileEntry *entry;
	char* str;
	char* str1;
	PLIST_ENTRY link;
	int len;
	ANSI_STRING f;
	BOOLEAN FileNonExist = TRUE;
	int l;
	char *inputBuffer;
	int i;

	pIrpStack = IoGetCurrentIrpStackLocation(pIrp);

	if (pDeviceObject->Flags & DO_BUFFERED_IO) {
		// если для устройства определён буферизованный ввод/вывод,
		// то записываем данные в системный буфер
		inputBuffer = (char*)pIrp->AssociatedIrp.SystemBuffer;
	}
	else {
		// иначе непосредственно в пользовательский буфер
		inputBuffer = (char*)pIrp->UserBuffer;
	}

	// выделяем память для нового элемента и вставляем его в конец списка
	entry = (OpenFileEntry*)ExAllocateFromPagedLookasideList(&glPagedList);
	InsertTailList(&glOpenFiles, &entry->link);


	// копируем имя файла в созданный элемент
	RtlUnicodeStringToAnsiString(&entry->fileName, &pIrpStack->FileObject->FileName, TRUE);
	len = strlen(entry->fileName.Buffer) + 1;
	do
		str = ExAllocatePool(NonPagedPool, len);
	while (str == NULL);
	strcpy(str, entry->fileName.Buffer);
	if (strstr(str, "??") != NULL){
		do
			str1 = ExAllocatePool(NonPagedPool, len - 4);
		while (str1 == NULL);
		strcpy(str1, &str[4]);
		do
			entry->fullName.Buffer = AnsiToUnicode(str1);
		while (entry->fullName.Buffer == NULL);

		ExFreePool(str1);
	}
	else
		entry->fullName.Buffer = AnsiToUnicode(str);

	//если ввели "ddd" отчищаем весь список хукнутых файлов
	if (strstr(str, "ddd") != NULL){
		while (!IsListEmpty(&glOpenFiles)) {
			PLIST_ENTRY pLink = RemoveHeadList(&glOpenFiles);
			entry = CONTAINING_RECORD(pLink, OpenFileEntry, link);
			RtlFreeAnsiString(&entry->fileName);
			RtlFreeUnicodeString(&entry->fullName);
			ExFreeToPagedLookasideList(&glPagedList, entry);
		}

	}
	ExFreePool(str);

	return CompleteIrp(pIrp, status, info);
}
示例#19
0
NTSTATUS DriverPassthroughHandler (__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp)
{
	UNREFERENCED_PARAMETER(DeviceObject);
	return CompleteIrp (Irp, 0, STATUS_NOT_SUPPORTED);
}
BOOLEAN PickPacketFromList(PADAPT pAdapt,PIRP Irp)
{
	PIO_STACK_LOCATION IrpStack;
	ULONG PacketLenTotal=0;

    PNDIS_PACKET        pRcvPacket;
    PLIST_ENTRY         pRcvPacketEntry;
    PUCHAR              pSrc, pDst;
	PUCHAR              pDstFormer;
    ULONG               BytesRemaining; // at pDst
    PNDIS_BUFFER        pNdisBuffer;
    ULONG               BytesAvailable;
	ULONG               BytesToCopy;


    NdisAcquireSpinLock(&PacketListLock);

    if(!IsListEmpty(&PacketList))
    {
        //
        //  Get the first queued receive packet
        //
        pRcvPacketEntry = PacketList.Flink;
        RemoveEntryList(pRcvPacketEntry);

        PacketCount--;

        NdisReleaseSpinLock(&PacketListLock);


        pRcvPacket = SECLAB_LIST_ENTRY_TO_RCV_PKT(pRcvPacketEntry);

        //
        //  Copy as much data as possible from the receive packet to
        //  the IRP MDL.
        //
        pDst = (PUCHAR)ExAllocatePool(NonPagedPool,MY_MTU);
        
		if(pDst==NULL)
		{
			DbgPrint("Can not allocate enough pool");
			DbgBreakPoint();
		}
        pDstFormer=pDst;

		IrpStack = IoGetCurrentIrpStackLocation(Irp);
	    BytesRemaining = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;

        pNdisBuffer = pRcvPacket->Private.Head;

        while (BytesRemaining && (pNdisBuffer != NULL))
        {

            NdisQueryBufferSafe(pNdisBuffer, &pSrc, &BytesAvailable, NormalPagePriority);

            if (pSrc == NULL) 
            {
                DbgPrint("PickPacketFromList: QueryBuffer failed for buffer");
                break;
            }

            if (BytesAvailable)
            {
                BytesToCopy = MIN(BytesAvailable, BytesRemaining);

                NdisMoveMemory(pDstFormer, pSrc, BytesToCopy);
                BytesRemaining -= BytesToCopy;
                pDstFormer += BytesToCopy;
				PacketLenTotal += BytesToCopy;
            }

            NdisGetNextBuffer(pNdisBuffer, &pNdisBuffer);
        }

        //
        //  Complete the IRP.
        //
		RtlCopyMemory( Irp->AssociatedIrp.SystemBuffer, pDst, PacketLenTotal);
	    IoSetCancelRoutine(Irp,NULL);
	    CompleteIrp(Irp,STATUS_SUCCESS,PacketLenTotal);

		ExFreePool(pDst);
        //
        //  Free up the receive packet - back to the miniport if it
        //  belongs to it, else reclaim it (local copy).
        //
        if (NdisGetPoolFromPacket(pRcvPacket) != pAdapt->RecvPacketPoolHandle)
        {
            NdisReturnPackets(&pRcvPacket, 1);
        }
        else
        {
            SecLabFreeReceivePacket(pAdapt, pRcvPacket);
        }

    }
	else
	{
		NdisReleaseSpinLock(&PacketListLock);
		return FALSE;
	}
   
	return TRUE;
}