| /* |
| * Copyright (c) 2016, The OpenThread Authors. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holder nor the |
| * names of its contributors may be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "pch.hpp" |
| #include "serial.tmh" |
| |
| PAGED |
| _No_competing_thread_ |
| _IRQL_requires_max_(PASSIVE_LEVEL) |
| NTSTATUS |
| SerialInitialize( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext |
| ) |
| /*++ |
| Routine Description: |
| |
| SerialInitialize attempts to find and open the first COM port available, with |
| the assumption that it should be for the Thread device. |
| |
| Arguments: |
| |
| AdapterContext - handle to a OTTMP Adapter |
| |
| Return Value: |
| |
| NTSTATUS - A failure here will indicate the serial COM port was not able |
| to be opened. |
| --*/ |
| { |
| NTSTATUS status = STATUS_UNSUCCESSFUL; |
| PWSTR SymbolicLinkList = NULL; |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| do |
| { |
| WDF_OBJECT_ATTRIBUTES attr = { 0 }; |
| WDF_WORKITEM_CONFIG config = { 0 }; |
| |
| // |
| // Send Queue Variables |
| // |
| |
| InitializeListHead(&AdapterContext->SendQueue); |
| AdapterContext->SendQueueRunning = false; |
| |
| WDF_OBJECT_ATTRIBUTES_INIT(&attr); |
| attr.ParentObject = AdapterContext->Device; |
| status = WdfSpinLockCreate(&attr, &AdapterContext->SendLock); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "WdfSpinLockCreate(lockSend) failed %!STATUS!", status); |
| break; |
| } |
| |
| WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attr, WDF_DEVICE_INFO); |
| attr.ParentObject = AdapterContext->Device; |
| WDF_WORKITEM_CONFIG_INIT(&config, SerialSendLoop); |
| |
| status = WdfWorkItemCreate(&config, &attr, &AdapterContext->SendWorkItem); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "WdfWorkItemCreate(SerialSendLoop) failed %!STATUS!", status); |
| break; |
| } |
| GetWdfDeviceInfo(AdapterContext->SendWorkItem)->AdapterContext = AdapterContext; |
| |
| // |
| // Receive Variables |
| // |
| |
| WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attr, WDF_DEVICE_INFO); |
| attr.ParentObject = AdapterContext->Device; |
| WDF_WORKITEM_CONFIG_INIT(&config, SerialRecvLoop); |
| |
| status = WdfWorkItemCreate(&config, &attr, &AdapterContext->RecvWorkItem); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "WdfWorkItemCreate(SerialRecvLoop) failed %!STATUS!", status); |
| break; |
| } |
| |
| GetWdfDeviceInfo(AdapterContext->RecvWorkItem)->AdapterContext = AdapterContext; |
| |
| // Query the system for device with SERIAL interface |
| status = |
| IoGetDeviceInterfaces( |
| &GUID_DEVINTERFACE_COMPORT, |
| NULL, |
| 0, |
| &SymbolicLinkList // List of symbolic names; separate by NULL, EOL with NULL+NULL. |
| ); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IoGetDeviceInterfaces failed %!STATUS!", status); |
| break; |
| } |
| |
| // Make sure there is a COM port found |
| NT_ASSERT(SymbolicLinkList); |
| if (*SymbolicLinkList == NULL) { |
| status = STATUS_DEVICE_NOT_CONNECTED; |
| LogError(DRIVER_DEFAULT, "No COM ports found!"); |
| break; |
| } |
| |
| #if DBG |
| for (PCWSTR sym = SymbolicLinkList; *sym != NULL; sym += wcslen(sym) + 1) |
| { |
| LogVerbose(DRIVER_DEFAULT, "Symbolic Name found: %ws", sym); |
| } |
| #endif |
| |
| // Try to open each serial port until we get that one works or we exhaust them all |
| for (PCWSTR sym = SymbolicLinkList; *sym != NULL; sym += wcslen(sym) + 1) |
| { |
| // Initialize the target |
| status = SerialInitializeTarget(AdapterContext, sym); |
| |
| // Break on success |
| if (NT_SUCCESS(status)) { |
| break; |
| } |
| } |
| |
| } while (false); |
| |
| // Clean up on failure |
| if (!NT_SUCCESS(status)) { |
| SerialUninitialize(AdapterContext); |
| } |
| |
| if (SymbolicLinkList) { |
| ExFreePool(SymbolicLinkList); |
| SymbolicLinkList = NULL; |
| } |
| |
| LogFuncExitNT(DRIVER_DEFAULT, status); |
| |
| return status; |
| } |
| |
| PAGED |
| _IRQL_requires_max_(PASSIVE_LEVEL) |
| VOID |
| SerialUninitialize( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext |
| ) |
| /*++ |
| Routine Description: |
| |
| SerialUninitialize cleans up any cached Wdf IoTarget created from SerialInitialize. |
| |
| Arguments: |
| |
| AdapterContext - handle to a OTTMP Adapter |
| --*/ |
| { |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| // TODO - Clean up work item |
| |
| // TODO - Clean up send queue |
| |
| SerialUninitializeTarget(AdapterContext); |
| |
| if (AdapterContext->RecvWorkItem) { |
| WdfWorkItemFlush(AdapterContext->RecvWorkItem); |
| } |
| |
| LogFuncExit(DRIVER_DEFAULT); |
| } |
| |
| PAGED |
| _No_competing_thread_ |
| _IRQL_requires_max_(PASSIVE_LEVEL) |
| NTSTATUS |
| SerialInitializeTarget( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext, |
| _In_ PCWSTR TargetName |
| ) |
| { |
| NTSTATUS status = STATUS_UNSUCCESSFUL; |
| WDFIOTARGET tempTarget = WDF_NO_HANDLE; |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| do |
| { |
| DECLARE_UNICODE_STRING_SIZE(PortName, 64); // Maximum name length of the device path to a serial port |
| WDF_IO_TARGET_OPEN_PARAMS openParams = { 0 }; |
| WDF_OBJECT_ATTRIBUTES attr = { 0 }; |
| |
| // Create the Wdf IoTarget |
| status = WdfIoTargetCreate(AdapterContext->Device, WDF_NO_OBJECT_ATTRIBUTES, &tempTarget); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "WdfIoTargetCreate failed %!STATUS!", status); |
| break; |
| } |
| |
| // Try the COM port |
| LogInfo(DRIVER_DEFAULT, "Opening device: %ws", TargetName); |
| RtlInitUnicodeString(&PortName, TargetName); |
| WDF_IO_TARGET_OPEN_PARAMS_INIT_OPEN_BY_NAME( |
| &openParams, |
| &PortName, |
| GENERIC_READ | GENERIC_WRITE); |
| |
| // Open the port on the target |
| status = WdfIoTargetOpen(tempTarget, &openParams); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "WdfIoTargetOpen(%wZ) failed %!STATUS!", &PortName, status); |
| break; |
| } |
| |
| AdapterContext->WdfIoTarget = tempTarget; |
| tempTarget = WDF_NO_HANDLE; |
| |
| WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attr, WDF_DEVICE_INFO); |
| attr.ParentObject = AdapterContext->Device; |
| |
| status = WdfRequestCreate(&attr, AdapterContext->WdfIoTarget, &AdapterContext->RecvReadRequest); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "WdfRequestCreate failed %!STATUS!", status); |
| break; |
| } |
| |
| // Try to configure the target |
| status = SerialConfigure(AdapterContext); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "SerialConfigure failed %!STATUS!", status); |
| break; |
| } |
| |
| } while (false); |
| |
| // Clean up on failure |
| if (!NT_SUCCESS(status)) { |
| SerialUninitializeTarget(AdapterContext); |
| } |
| |
| if (tempTarget) { |
| WdfIoTargetClose(tempTarget); |
| } |
| |
| LogFuncExitNT(DRIVER_DEFAULT, status); |
| |
| return status; |
| } |
| |
| PAGED |
| _IRQL_requires_max_(PASSIVE_LEVEL) |
| VOID |
| SerialUninitializeTarget( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext |
| ) |
| /*++ |
| Routine Description: |
| |
| SerialUninitializeTarget cleans up any cached Wdf IoTarget created from SerialInitializeTarget. |
| |
| Arguments: |
| |
| AdapterContext - handle to a OTTMP Adapter |
| --*/ |
| { |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| if (AdapterContext->WdfIoTarget) { |
| // |
| // WdfIoTargetStop will cancel all the outstanding I/O and wait |
| // for them to complete before returning. WdfIoTargetStop with the |
| // action type WdfIoTargetCancelSentIo can be called at IRQL PASSIVE_LEVEL only. |
| // |
| WdfIoTargetStop(AdapterContext->WdfIoTarget, WdfIoTargetCancelSentIo); |
| WdfIoTargetClose(AdapterContext->WdfIoTarget); |
| AdapterContext->WdfIoTarget = NULL; |
| } |
| |
| LogFuncExit(DRIVER_DEFAULT); |
| } |
| |
| _Must_inspect_result_ |
| _IRQL_requires_max_(PASSIVE_LEVEL) |
| NTSTATUS |
| FORCEINLINE |
| SerialSendIoctl( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext, |
| _In_ ULONG IoctlCode, |
| _In_opt_ PWDF_REQUEST_SEND_OPTIONS RequestOptions = NULL, |
| _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer = WDF_NO_HANDLE, |
| _In_opt_ PWDF_MEMORY_DESCRIPTOR OutputBuffer = WDF_NO_HANDLE, |
| _Out_opt_ PULONG_PTR BytesReturned = NULL |
| ) |
| /*++ |
| Routine Description: |
| |
| Helper/Wrapper function for WdfIoTargetSendIoctlSynchronously. |
| |
| --*/ |
| { |
| return WdfIoTargetSendIoctlSynchronously( |
| AdapterContext->WdfIoTarget, |
| WDF_NO_HANDLE, |
| IoctlCode, |
| InputBuffer, |
| OutputBuffer, |
| RequestOptions, |
| BytesReturned); |
| } |
| |
| PAGED |
| _IRQL_requires_max_(PASSIVE_LEVEL) |
| NTSTATUS |
| SerialConfigure( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext |
| ) |
| /*++ |
| Routine Description: |
| |
| SerialInitialize attempts to find and open the first COM port available, with |
| the assumption that it should be for the Thread device. |
| |
| Arguments: |
| |
| AdapterContext - handle to a OTTMP Adapter |
| |
| Return Value: |
| |
| NTSTATUS - A failure here will indicate the serial COM port was not able |
| to be configured as desired. |
| --*/ |
| { |
| NTSTATUS status = STATUS_UNSUCCESSFUL; |
| WDF_MEMORY_DESCRIPTOR inputDesc; |
| WDF_REQUEST_SEND_OPTIONS wrso = { |
| sizeof(WDF_REQUEST_SEND_OPTIONS), |
| WDF_REQUEST_SEND_OPTION_TIMEOUT | WDF_REQUEST_SEND_OPTION_SYNCHRONOUS, |
| WDF_REL_TIMEOUT_IN_SEC(1) // Nothing should take more than a second to complete |
| }; |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| do |
| { |
| // Initial reset of the device |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_RESET_DEVICE, &wrso); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_RESET_DEVICE failed %!STATUS!", status); |
| break; |
| } |
| |
| // 8 bits, no parity, 1 stop bit |
| { |
| const SERIAL_LINE_CONTROL slc = { STOP_BIT_1, NO_PARITY, 8 }; |
| WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&inputDesc, (PVOID)&slc, sizeof(slc)); |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_SET_LINE_CONTROL, &wrso, &inputDesc); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_SET_LINE_CONTROL failed %!STATUS!", status ); |
| break; |
| } |
| } |
| |
| // Xon and Xoff characters |
| { |
| const SERIAL_CHARS sc = { 0, 0, 0, 0, 0x11, 0x13 }; |
| WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&inputDesc, (PVOID)&sc, sizeof(sc)); |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_SET_CHARS, &wrso, &inputDesc); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_SET_CHARS failed %!STATUS!", status); |
| break; |
| } |
| } |
| |
| // Baud rate |
| { |
| const SERIAL_BAUD_RATE sbr = { 115200 }; |
| WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&inputDesc, (PVOID)&sbr, sizeof(sbr)); |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_SET_BAUD_RATE, &wrso, &inputDesc); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_SET_BAUD_RATE failed %!STATUS!", status); |
| break; |
| } |
| } |
| |
| /*{ |
| // Only send if CTS is set, Set RTS before sending |
| const SERIAL_HANDFLOW shf = |
| { |
| SERIAL_CTS_HANDSHAKE, SERIAL_RTS_CONTROL, |
| MAX_SPINEL_COMMAND_LENGTH, MAX_SPINEL_COMMAND_LENGTH |
| }; |
| WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&inputDesc, (PVOID)&shf, sizeof(shf)); |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_SET_HANDFLOW, &wrso, &inputDesc); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_SET_HANDFLOW failed %!STATUS!", status); |
| // break; Ignore for now |
| } |
| } |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_SET_XON, &wrso); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_SET_XON failed %!STATUS!", status); |
| break; |
| } |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_SET_RTS, &wrso); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_SET_RTS failed %!STATUS!", status); |
| break; |
| } |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_SET_DTR, &wrso); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_SET_DTR failed %!STATUS!", status); |
| break; |
| }*/ |
| |
| { |
| const SERIAL_TIMEOUTS sto = { |
| 1, 0, 0, // On read, only timeout if more than 1ms *between* bytes (wait forever for first byte) |
| 1, 10 // Write times out after (1ms * n-bytes) + (10ms) |
| }; |
| WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&inputDesc, (PVOID)&sto, sizeof(sto)); |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_SET_TIMEOUTS, &wrso, &inputDesc); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_SET_TIMEOUTS failed %!STATUS!", status); |
| break; |
| } |
| } |
| |
| status = SerialFlushAndCheckStatus(AdapterContext); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "SerialFlushAndCheckStatus failed %!STATUS!", status); |
| break; |
| } |
| |
| } while (false); |
| |
| LogFuncExitNT(DRIVER_DEFAULT, status); |
| |
| return status; |
| } |
| |
| PAGED |
| _IRQL_requires_(PASSIVE_LEVEL) |
| NTSTATUS |
| SerialCheckStatus( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext, |
| _In_ bool DataExpected |
| ) |
| /*++ |
| Routine Description: |
| |
| SerialCheckStatus validates the current status of the serial COM port. |
| |
| Arguments: |
| |
| AdapterContext - handle to a OTTMP Adapter |
| |
| Return Value: |
| |
| NTSTATUS - A failure here will indicate the serial COM port is not in an |
| expected state. |
| --*/ |
| { |
| NTSTATUS status = STATUS_UNSUCCESSFUL; |
| WDF_MEMORY_DESCRIPTOR outputDesc; |
| WDF_REQUEST_SEND_OPTIONS wrso = { |
| sizeof(WDF_REQUEST_SEND_OPTIONS), |
| WDF_REQUEST_SEND_OPTION_TIMEOUT | WDF_REQUEST_SEND_OPTION_SYNCHRONOUS, |
| WDF_REL_TIMEOUT_IN_SEC(1) // Nothing should take more than a second to complete |
| }; |
| ULONG_PTR bytesReturned = 0; |
| SERIAL_STATUS ss = { 0 }; |
| WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&outputDesc, (PVOID)&ss, sizeof(ss)); |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| // Check to ensure we are ready to send |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_GET_COMMSTATUS, &wrso, WDF_NO_HANDLE, &outputDesc, &bytesReturned); |
| |
| if (!NT_SUCCESS(status)) |
| { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_GET_COMMSTATUS failed %!STATUS!", status); |
| } |
| else if (bytesReturned >= sizeof(ss)) |
| { |
| if (ss.HoldReasons) |
| { |
| if (ss.HoldReasons != SERIAL_TX_WAITING_FOR_CTS) |
| { |
| LogError(DRIVER_DEFAULT, "HoldReasons is wrong (should only be CTS, but is %x)", ss.HoldReasons ); |
| status = STATUS_INVALID_DEVICE_STATE; |
| } |
| else if (!DataExpected) |
| { |
| LogError(DRIVER_DEFAULT, "Adapter already has data on init!?!?!"); |
| status = STATUS_INVALID_STATE_TRANSITION; |
| } |
| } |
| if (ss.Errors) |
| { |
| LogWarning(DRIVER_DEFAULT, "Unexpected Error %x", ss.Errors); |
| status = STATUS_UNSUCCESSFUL; |
| } |
| } |
| |
| LogFuncExitNT(DRIVER_DEFAULT, status); |
| |
| return status; |
| } |
| |
| PAGED |
| _IRQL_requires_(PASSIVE_LEVEL) |
| NTSTATUS |
| SerialFlushAndCheckStatus( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext |
| ) |
| /*++ |
| Routine Description: |
| |
| SerialFlushAndCheckStatus flushed and validates the current status of the serial COM port. |
| |
| Arguments: |
| |
| AdapterContext - handle to a OTTMP Adapter |
| |
| Return Value: |
| |
| NTSTATUS - A failure here will indicate the serial COM port is not in an |
| expected state. |
| --*/ |
| { |
| NTSTATUS status = STATUS_UNSUCCESSFUL; |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| do |
| { |
| WDF_MEMORY_DESCRIPTOR inputDesc; |
| WDF_REQUEST_SEND_OPTIONS wrso = { |
| sizeof(WDF_REQUEST_SEND_OPTIONS), |
| WDF_REQUEST_SEND_OPTION_TIMEOUT | WDF_REQUEST_SEND_OPTION_SYNCHRONOUS, |
| WDF_REL_TIMEOUT_IN_SEC(1) // Nothing should take more than a second to complete |
| }; |
| const ULONG flags = SERIAL_PURGE_RXABORT | SERIAL_PURGE_RXCLEAR | SERIAL_PURGE_TXABORT | SERIAL_PURGE_TXCLEAR; |
| |
| WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&inputDesc, (PVOID)&flags, sizeof(flags)); |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_PURGE, &wrso, &inputDesc); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_PURGE failed %!STATUS!", status); |
| break; |
| } |
| |
| status = SerialSendIoctl(AdapterContext, IOCTL_SERIAL_CLEAR_STATS, &wrso); |
| |
| if (!NT_SUCCESS(status)) { |
| LogError(DRIVER_DEFAULT, "IOCTL_SERIAL_CLEAR_STATS failed %!STATUS!", status); |
| break; |
| } |
| |
| status = SerialCheckStatus(AdapterContext, false); |
| for (int i = 0; !NT_SUCCESS(status) && i < 20; i++) |
| { |
| NdisMSleep(1); // just sleep enough to give up our quantum |
| status = SerialCheckStatus(AdapterContext, false); |
| } |
| |
| } while (false); |
| |
| LogFuncExitNT(DRIVER_DEFAULT, status); |
| |
| return status; |
| } |
| |
| _IRQL_requires_max_(DISPATCH_LEVEL) |
| bool |
| SerialPushSend( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext, |
| _In_ PSERIAL_SEND_ITEM SendItem |
| ) |
| { |
| WdfSpinLockAcquire(AdapterContext->SendLock); |
| |
| // Start the work item up if it's not already running |
| if (!AdapterContext->SendQueueRunning) |
| { |
| LogVerbose(DRIVER_DEFAULT, "Starting Send Work Item"); |
| AdapterContext->SendQueueRunning = true; |
| WdfWorkItemEnqueue(AdapterContext->SendWorkItem); |
| } |
| |
| // Insert the new item at the end of the list |
| InsertTailList(&AdapterContext->SendQueue, &SendItem->Link); |
| |
| WdfSpinLockRelease(AdapterContext->SendLock); |
| |
| return true; |
| } |
| |
| _IRQL_requires_max_(DISPATCH_LEVEL) |
| PSERIAL_SEND_ITEM |
| SerialPopSend( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext |
| ) |
| { |
| PLIST_ENTRY current = NULL; |
| |
| // Grab the head of the list |
| // Careful, this might have gotten aborted, leaving the list empty |
| WdfSpinLockAcquire(AdapterContext->SendLock); |
| |
| if (!IsListEmpty(&AdapterContext->SendQueue)) |
| { |
| current = RemoveHeadList(&AdapterContext->SendQueue); |
| } |
| if (current == NULL) |
| { |
| // Do this under the lock, but the state is consumed outside the lock |
| AdapterContext->SendQueueRunning = false; |
| LogVerbose(DRIVER_DEFAULT, "Send Work Item Complete"); |
| } |
| |
| WdfSpinLockRelease(AdapterContext->SendLock); |
| |
| return current ? CONTAINING_RECORD(current, SERIAL_SEND_ITEM, Link) : NULL; |
| } |
| |
| _IRQL_requires_max_(DISPATCH_LEVEL) |
| NTSTATUS |
| SerialSendData( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext, |
| _In_ PNET_BUFFER_LIST NetBufferList |
| ) |
| /*++ |
| Routine Description: |
| |
| SerialSendData encodes and queues up the data to be sent over the serial COM port. |
| |
| Arguments: |
| |
| AdapterContext - handle to a OTTMP Adapter |
| |
| NetBufferLists - a single NET_BUFFER_LIST object, containing a signle NET_BUFFER for |
| Spinel tunnel commands. |
| |
| DispatchLevel - flag indicating if we are running at dispatch or not |
| |
| Return Value: |
| |
| NTSTATUS - A failure here will indicate we either failed to encode or queue the data. |
| --*/ |
| { |
| NTSTATUS status = STATUS_SUCCESS; |
| WDF_OBJECT_ATTRIBUTES attributes; |
| WDFMEMORY WdfMemBuffer = NULL; |
| PSERIAL_SEND_ITEM SendItem = NULL; |
| PUCHAR DecodedBuffer = NULL; |
| ULONG DecodedBufferLength = NetBufferList->FirstNetBuffer->DataLength; |
| ULONG EncodedBufferLength; |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| do |
| { |
| // Get the decoded buffer from the NBL/NB. We required |
| // the use of contiguous buffers. |
| DecodedBuffer = (PUCHAR)NdisGetDataBuffer(NetBufferList->FirstNetBuffer, DecodedBufferLength, NULL, 1, 0); |
| if (DecodedBuffer == NULL) { |
| status = STATUS_INVALID_PARAMETER; |
| break; |
| } |
| |
| LogVerbose(DRIVER_DEFAULT, "Sending %u decoded bytes", DecodedBufferLength); |
| DumpBuffer(DecodedBuffer, DecodedBufferLength); |
| |
| // Calculate the buffer size required |
| EncodedBufferLength = HdlcComputeEncodedLength(DecodedBuffer, DecodedBufferLength); |
| |
| // Allocate the memory |
| WDF_OBJECT_ATTRIBUTES_INIT(&attributes); |
| attributes.ParentObject = AdapterContext->Device; |
| #pragma warning(push) |
| #pragma warning(suppress: 28160) // Param 3 could be 0 |
| status = WdfMemoryCreate( |
| &attributes, |
| NonPagedPoolNx, |
| 0, |
| SERIAL_SEND_ITEM_SIZE + EncodedBufferLength, |
| &WdfMemBuffer, |
| (PVOID*)&SendItem |
| ); |
| #pragma warning(pop) |
| |
| if (!NT_SUCCESS(status)) { |
| LogWarning(DRIVER_DEFAULT, "WdfMemoryCreate (%u bytes) failed %!STATUS!", (SERIAL_SEND_ITEM_SIZE + EncodedBufferLength), status); |
| break; |
| } |
| |
| SendItem->NetBufferList = NetBufferList; |
| SendItem->WdfMemory = WdfMemBuffer; |
| SendItem->EncodedBufferLength = EncodedBufferLength; |
| |
| // Encode data |
| if (!HdlcEncodeBuffer(DecodedBuffer, DecodedBufferLength, SendItem->EncodedBuffer, EncodedBufferLength)) { |
| NT_ASSERT(FALSE); // Should never fail, unless we have a bug in the length computation |
| status = STATUS_INSUFFICIENT_RESOURCES; |
| break; |
| } |
| |
| // Queue data to be sent out |
| if (!SerialPushSend(AdapterContext, SendItem)) { |
| status = STATUS_DEVICE_NOT_READY; |
| break; |
| } |
| |
| } while (false); |
| |
| if (!NT_SUCCESS(status)) { |
| if (WdfMemBuffer) { |
| WdfObjectDelete(WdfMemBuffer); |
| } |
| } |
| |
| LogFuncExitNT(DRIVER_DEFAULT, status); |
| |
| return status; |
| } |
| |
| PAGED |
| _Function_class_(EVT_WDF_WORKITEM) |
| _IRQL_requires_same_ |
| _IRQL_requires_max_(PASSIVE_LEVEL) |
| VOID |
| SerialSendLoop( |
| _In_ WDFWORKITEM WorkItem |
| ) |
| /*++ |
| Routine Description: |
| |
| SerialSendLoop handles the actual sending of data over the serial COM port. |
| |
| Arguments: |
| |
| WorkItem - handle to a Wdf Device Info object for the Adapter context |
| |
| --*/ |
| { |
| POTTMP_ADAPTER_CONTEXT AdapterContext = GetWdfDeviceInfo(WorkItem)->AdapterContext; |
| WDF_REQUEST_SEND_OPTIONS wrso = { |
| sizeof(WDF_REQUEST_SEND_OPTIONS), |
| WDF_REQUEST_SEND_OPTION_TIMEOUT | WDF_REQUEST_SEND_OPTION_SYNCHRONOUS, |
| WDF_REL_TIMEOUT_IN_SEC(1) // Nothing should take more than a second to complete |
| }; |
| WDFMEMORY_OFFSET offset = { 0 }; |
| PSERIAL_SEND_ITEM SendItem = NULL; |
| WDF_MEMORY_DESCRIPTOR wmd; |
| NTSTATUS status; |
| |
| WDF_OBJECT_ATTRIBUTES Attributes; |
| WDF_OBJECT_ATTRIBUTES_INIT(&Attributes); |
| Attributes.ParentObject = AdapterContext->Device; |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| #pragma warning(push) |
| #pragma warning(suppress: 6387) // Param 2 is NULL |
| WDF_MEMORY_DESCRIPTOR_INIT_HANDLE(&wmd, NULL, &offset); |
| #pragma warning(pop) |
| |
| while (NULL != (SendItem = SerialPopSend(AdapterContext))) |
| { |
| LogVerbose(DRIVER_DEFAULT, "Sending %u encoded bytes", SendItem->EncodedBufferLength); |
| DumpBuffer(SendItem->EncodedBuffer, SendItem->EncodedBufferLength); |
| |
| if (SendItem->EncodedBufferLength > 0) |
| { |
| offset.BufferLength = SendItem->EncodedBufferLength; |
| status = |
| WdfMemoryCreatePreallocated( |
| &Attributes, |
| SendItem->EncodedBuffer, |
| SendItem->EncodedBufferLength, |
| &wmd.u.HandleType.Memory); |
| |
| if (!NT_SUCCESS( status )) { |
| LogError(DRIVER_DEFAULT, "WdfIoTargetSendWriteSynchronously (%u bytes) failed %!STATUS!", SendItem->EncodedBufferLength, status); |
| } |
| else |
| { |
| // Send the buffer out |
| status = WdfIoTargetSendWriteSynchronously(AdapterContext->WdfIoTarget, NULL, &wmd, NULL, &wrso, NULL); |
| |
| if (!NT_SUCCESS( status )) { |
| LogError(DRIVER_DEFAULT, "WdfIoTargetSendWriteSynchronously (%u bytes) failed %!STATUS!", SendItem->EncodedBufferLength, status); |
| } |
| |
| WdfObjectDelete(wmd.u.HandleType.Memory); |
| } |
| } |
| else |
| { |
| status = STATUS_INVALID_PARAMETER; |
| } |
| |
| // Complete the NetBufferList |
| SendItem->NetBufferList->Status = status; |
| #ifdef OTTMP_LEGACY |
| NdisMSendNetBufferListsComplete(AdapterContext->Adapter, SendItem->NetBufferList, 0); |
| #else |
| NetBufferListsCompleteSend(SendItem->NetBufferList); |
| #endif |
| |
| // Hack to sleep 1 ms per 5 bytes sent |
| NdisMSleep(1000 * (1 + SendItem->EncodedBufferLength / 5)); |
| |
| // Cleanup |
| WdfObjectDelete(SendItem->WdfMemory); |
| }; |
| |
| LogFuncExit(DRIVER_DEFAULT); |
| } |
| |
| PAGED |
| _Function_class_(EVT_WDF_WORKITEM) |
| _IRQL_requires_same_ |
| _IRQL_requires_max_(PASSIVE_LEVEL) |
| VOID |
| SerialRecvLoop( |
| _In_ WDFWORKITEM WorkItem |
| ) |
| { |
| POTTMP_ADAPTER_CONTEXT AdapterContext = GetWdfDeviceInfo(WorkItem)->AdapterContext; |
| WDFMEMORY mem = { 0 }; |
| NTSTATUS status; |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| PAGED_CODE(); |
| |
| do |
| { |
| WDFREQUEST & request = AdapterContext->RecvReadRequest; |
| |
| WDF_OBJECT_ATTRIBUTES attributes; |
| WDF_OBJECT_ATTRIBUTES_INIT(&attributes); |
| attributes.ParentObject = AdapterContext->Device; |
| status = |
| WdfMemoryCreatePreallocated( |
| &attributes, |
| AdapterContext->RecvBuffer + AdapterContext->RecvBufferLength, |
| MAX_SPINEL_COMMAND_LENGTH, |
| &mem); |
| |
| if (!NT_SUCCESS(status)) |
| { |
| LogError(DRIVER_DEFAULT, "WdfMemoryCreateFromLookaside failed %!STATUS!", status); |
| break; |
| } |
| |
| status = WdfIoTargetFormatRequestForRead(AdapterContext->WdfIoTarget, request, mem, NULL, NULL); |
| |
| if (!NT_SUCCESS(status)) |
| { |
| LogError(DRIVER_DEFAULT, "WdfIoTargetFormatRequestForRead failed %!STATUS!", status); |
| break; |
| } |
| else |
| { |
| WdfRequestSetCompletionRoutine(request, SerialRecvComplete, AdapterContext); |
| if (WdfRequestSend(request, AdapterContext->WdfIoTarget, WDF_NO_SEND_OPTIONS)) |
| { |
| // Send succeeded, no cleanup |
| mem = NULL; |
| break; |
| } |
| |
| status = WdfRequestGetStatus(request); |
| if (!NT_SUCCESS(status)) |
| { |
| LogError(DRIVER_DEFAULT, "WdfRequestSend failed %!STATUS!", status); |
| } |
| |
| WDF_REQUEST_REUSE_PARAMS reuseParams = { 0 }; |
| WDF_REQUEST_REUSE_PARAMS_INIT(&reuseParams, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_SUCCESS); |
| |
| // refresh the request so it is ready to reuse |
| status = WdfRequestReuse(request, &reuseParams); |
| if (!NT_SUCCESS(status)) |
| { |
| NT_ASSERT(NT_SUCCESS(status)); |
| LogError(DRIVER_DEFAULT, "WdfRequestReuse failed %!STATUS!", status); |
| } |
| } |
| |
| } while (false); |
| |
| if (mem) { |
| WdfObjectDelete(mem); |
| } |
| |
| LogFuncExit(DRIVER_DEFAULT); |
| } |
| |
| _IRQL_requires_max_(DISPATCH_LEVEL) |
| _When_(return==0,_At_(*pNetBufferList, __drv_allocatesMem(mem))) |
| _When_(return==0,_At_((*pNetBufferList)->FirstNetBuffer, __drv_allocatesMem(mem))) |
| NTSTATUS |
| SerialAllocateNetBufferList( |
| _In_ POTTMP_ADAPTER_CONTEXT AdapterContext, |
| _In_ ULONG BufferLength, |
| _Out_ PNET_BUFFER_LIST *pNetBufferList |
| ) |
| { |
| NTSTATUS status = STATUS_SUCCESS; |
| PNET_BUFFER_LIST NetBufferList = NULL; |
| PNET_BUFFER NetBuffer = NULL; |
| |
| do |
| { |
| |
| #ifdef OTTMP_LEGACY |
| // Allocate the NetBufferList |
| NetBufferList = NdisAllocateNetBufferList(AdapterContext->pGlobals->hNblPool, 0, 0); |
| |
| if (NetBufferList == NULL) |
| { |
| status = STATUS_INSUFFICIENT_RESOURCES; |
| break; |
| } |
| |
| // Allocate the NetBuffer |
| NetBufferList->FirstNetBuffer = NdisAllocateNetBufferMdlAndData(AdapterContext->pGlobals->hNbPool); |
| |
| if (NetBufferList->FirstNetBuffer == NULL) |
| { |
| status = STATUS_INSUFFICIENT_RESOURCES; |
| break; |
| } |
| #else |
| // Grab a NetBufferList from the collection |
| status = NetBufferListCollectionRetrieveNbls(AdapterContext->ReceiveCollection, 1, &NetBufferList); |
| |
| if (!NT_SUCCESS(status)) |
| { |
| break; |
| } |
| #endif |
| |
| NDIS_STATUS ndisStatus = NDIS_STATUS_SUCCESS; |
| NetBuffer = NetBufferList->FirstNetBuffer; |
| |
| // If there is no buffer allocated yet, go ahead and allocate the max |
| if (NET_BUFFER_DATA_LENGTH(NetBuffer) == 0) |
| { |
| // Allocate the max buffer size |
| ndisStatus = NdisRetreatNetBufferDataStart(NetBuffer, MAX_SPINEL_COMMAND_LENGTH, 0, NULL); |
| if (ndisStatus != NDIS_STATUS_SUCCESS) |
| { |
| LogError(DRIVER_DEFAULT, "NdisRetreatNetBufferDataStart failed %!NDIS_STATUS!", ndisStatus); |
| status = STATUS_INSUFFICIENT_RESOURCES; |
| break; |
| } |
| } |
| |
| // By this point, we should have a NetBuffer with a contiguous memory block of MAX_SPINEL_COMMAND_LENGTH bytes, |
| // though it's offset could be anywhere in the buffer, from when it was previously used. |
| |
| // Adjust buffer length to fit the requested length |
| if (NET_BUFFER_DATA_LENGTH(NetBuffer) > BufferLength) |
| { |
| NdisAdvanceNetBufferDataStart(NetBuffer, NET_BUFFER_DATA_LENGTH(NetBuffer) - BufferLength, FALSE, NULL); |
| } |
| else if (NET_BUFFER_DATA_LENGTH(NetBuffer) < BufferLength) |
| { |
| ndisStatus = NdisRetreatNetBufferDataStart(NetBuffer, BufferLength - NET_BUFFER_DATA_LENGTH(NetBuffer), 0, NULL); |
| NT_ASSERT(ndisStatus == NDIS_STATUS_SUCCESS); |
| if (ndisStatus != NDIS_STATUS_SUCCESS) |
| { |
| status = STATUS_INSUFFICIENT_RESOURCES; |
| break; |
| } |
| } |
| |
| // Set the output |
| *pNetBufferList = NetBufferList; |
| |
| } while (FALSE); |
| |
| if (!NT_SUCCESS(status)) |
| { |
| #ifdef OTTMP_LEGACY |
| if (NetBuffer) NdisFreeNetBuffer(NetBuffer); |
| if (NetBufferList) NdisFreeNetBufferList(NetBufferList); |
| #else |
| if (NetBufferList) NetBufferListsDiscardReceive(NetBufferList); |
| #endif |
| } |
| |
| return status; |
| } |
| |
| _Function_class_(EVT_WDF_REQUEST_COMPLETION_ROUTINE) |
| _IRQL_requires_same_ |
| VOID |
| SerialRecvComplete( |
| _In_ WDFREQUEST Request, |
| _In_ WDFIOTARGET Target, |
| _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, |
| _In_ WDFCONTEXT Context |
| ) |
| { |
| POTTMP_ADAPTER_CONTEXT AdapterContext = (POTTMP_ADAPTER_CONTEXT)Context; |
| NTSTATUS status; |
| |
| LogFuncEntry(DRIVER_DEFAULT); |
| |
| UNREFERENCED_PARAMETER(Target); // Except for an assert |
| NT_ASSERT((Target == AdapterContext->WdfIoTarget) || (WDF_NO_HANDLE == AdapterContext->WdfIoTarget)); |
| NT_ASSERT(Request == AdapterContext->RecvReadRequest); |
| |
| WDFMEMORY mem = Params->Parameters.Read.Buffer; |
| NT_ASSERT(mem); |
| |
| status = WdfRequestGetStatus(Request); |
| if (NT_SUCCESS(status)) |
| { |
| NT_ASSERT(Params->Type == WdfRequestTypeRead); |
| NT_ASSERT(Params->Parameters.Read.Offset == 0); |
| |
| size_t MemoryLength = 0; |
| NT_ASSERT(AdapterContext->RecvBuffer + AdapterContext->RecvBufferLength == (PUCHAR)WdfMemoryGetBuffer(mem, &MemoryLength)); |
| UNREFERENCED_PARAMETER(MemoryLength); |
| |
| LogVerbose(DRIVER_DEFAULT, "Received %u encoded bytes", (ULONG)Params->IoStatus.Information); |
| DumpBuffer(AdapterContext->RecvBuffer + AdapterContext->RecvBufferLength, (ULONG)Params->IoStatus.Information); |
| |
| AdapterContext->RecvBufferLength += (ULONG)Params->IoStatus.Information; |
| |
| // Decode and receive |
| ULONG ReadOffset = 0; |
| while (AdapterContext->RecvBufferLength > ReadOffset) |
| { |
| // Parse, validate and compute the decoded buffer size requirements |
| ULONG UsedEncodedBufferLength = AdapterContext->RecvBufferLength - ReadOffset; |
| ULONG DecodedBufferLength = 0; |
| bool HasGoodBuffer = false; |
| bool HasCompleteBuffer = |
| HdlcDecodeBuffer( |
| AdapterContext->RecvBuffer + ReadOffset, |
| &UsedEncodedBufferLength, |
| &DecodedBufferLength, |
| NULL, |
| &HasGoodBuffer); |
| |
| // We should never have used more buffer than available |
| NT_ASSERT(UsedEncodedBufferLength <= AdapterContext->RecvBufferLength - ReadOffset); |
| |
| // Did we have a complete (start and end sequence chars) buffer? |
| if (!HasCompleteBuffer) |
| { |
| AdapterContext->RecvBufferLength -= ReadOffset; |
| |
| LogWarning(DRIVER_DEFAULT, "Buffering %u incomplete bytes", AdapterContext->RecvBufferLength); |
| NT_ASSERT(AdapterContext->RecvBufferLength < MAX_SPINEL_COMMAND_LENGTH); |
| |
| memmove_s(AdapterContext->RecvBuffer, sizeof(AdapterContext->RecvBuffer), |
| AdapterContext->RecvBuffer + ReadOffset, AdapterContext->RecvBufferLength); |
| break; |
| } |
| else |
| { |
| // Was the buffer too short or did it's FCS not match? |
| if (HasGoodBuffer) |
| { |
| NT_ASSERT(UsedEncodedBufferLength <= MAX_SPINEL_COMMAND_LENGTH); |
| |
| // Allocate the NetBufferList & NetBuffer to decode the data to |
| PNET_BUFFER_LIST NetBufferList = NULL; |
| status = SerialAllocateNetBufferList(AdapterContext, DecodedBufferLength, &NetBufferList); |
| |
| if (NT_SUCCESS(status)) |
| { |
| PNET_BUFFER NetBuffer = NetBufferList->FirstNetBuffer; |
| NT_ASSERT(DecodedBufferLength == NET_BUFFER_DATA_LENGTH(NetBuffer)); |
| |
| // Get pointer to contiguous buffer |
| PUCHAR DecodedBuffer = (PUCHAR)NdisGetDataBuffer(NetBuffer, DecodedBufferLength, NULL, 1, 0); |
| NT_ASSERT(DecodedBuffer); |
| if (DecodedBuffer) |
| { |
| HasCompleteBuffer = |
| HdlcDecodeBuffer( |
| AdapterContext->RecvBuffer + ReadOffset, |
| &UsedEncodedBufferLength, |
| &DecodedBufferLength, |
| DecodedBuffer, |
| &HasGoodBuffer); |
| |
| NT_ASSERT(HasCompleteBuffer); |
| NT_ASSERT(HasGoodBuffer); |
| NT_ASSERT(DecodedBufferLength == NET_BUFFER_DATA_LENGTH(NetBuffer)); |
| |
| LogVerbose(DRIVER_DEFAULT, "Received %u decoded bytes", DecodedBufferLength); |
| DumpBuffer(DecodedBuffer, DecodedBufferLength); |
| } |
| else |
| { |
| status = STATUS_INVALID_PARAMETER; |
| } |
| |
| if (NT_SUCCESS(status)) |
| { |
| // Indicate up the new NBL we just created |
| #ifdef OTTMP_LEGACY |
| NdisMIndicateReceiveNetBufferLists( |
| AdapterContext->Adapter, |
| NetBufferList, |
| NDIS_DEFAULT_PORT_NUMBER, |
| 1, |
| 0 |
| ); |
| #else |
| NetBufferListsCompleteReceive( |
| NetBufferList, |
| NDIS_DEFAULT_PORT_NUMBER, |
| 0 |
| ); |
| #endif |
| } |
| else |
| { |
| #ifdef OTTMP_LEGACY |
| NdisFreeNetBuffer(NetBuffer); |
| NdisFreeNetBufferList(NetBufferList); |
| #else |
| NetBufferListsDiscardReceive(NetBufferList); |
| #endif |
| } |
| } |
| } |
| else |
| { |
| LogWarning(DRIVER_DEFAULT, "Dropping %u bad bytes", UsedEncodedBufferLength); |
| DumpBuffer(AdapterContext->RecvBuffer + ReadOffset, UsedEncodedBufferLength); |
| } |
| |
| // Skip over used data |
| ReadOffset += UsedEncodedBufferLength; |
| } |
| } |
| |
| // We read all the buffer, so reset the length |
| if (AdapterContext->RecvBufferLength == ReadOffset) |
| { |
| AdapterContext->RecvBufferLength = 0; |
| } |
| } |
| else |
| { |
| LogError(DRIVER_DEFAULT, "Read request failed %!STATUS!", status); |
| } |
| |
| WdfObjectDelete(mem); |
| |
| if (status != STATUS_DELETE_PENDING) |
| { |
| WDF_REQUEST_REUSE_PARAMS reuseParams = { 0 }; |
| WDF_REQUEST_REUSE_PARAMS_INIT(&reuseParams, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_SUCCESS); |
| status = WdfRequestReuse(Request, &reuseParams); |
| if (!NT_SUCCESS(status)) |
| { |
| NT_ASSERT(NT_SUCCESS(status)); |
| LogError(DRIVER_DEFAULT, "WdfRequestReuse failed %!STATUS!", status); |
| } |
| |
| LogVerbose(DRIVER_DEFAULT, "Starting recv worker"); |
| WdfWorkItemEnqueue(AdapterContext->RecvWorkItem); |
| } |
| |
| LogFuncExit(DRIVER_DEFAULT); |
| } |
| |
| VOID |
| DumpLine( |
| _In_reads_bytes_(aLength) PCUCHAR aBuf, |
| _In_ size_t aLength |
| ) |
| { |
| char buf[80] = {0}; |
| char *cur = buf; |
| |
| sprintf_s(cur, sizeof(buf) - (cur - buf), "|"); |
| cur += 1; |
| |
| for (size_t i = 0; i < 16; i++) |
| { |
| if (i < aLength) |
| { |
| sprintf_s(cur, sizeof(buf) - (cur - buf), " %02X", aBuf[i]); |
| cur += 3; |
| } |
| else |
| { |
| sprintf_s(cur, sizeof(buf) - (cur - buf), " .."); |
| cur += 3; |
| } |
| |
| if (!((i + 1) % 8)) |
| { |
| sprintf_s(cur, sizeof(buf) - (cur - buf), " |"); |
| cur += 2; |
| } |
| } |
| |
| sprintf_s(cur, sizeof(buf) - (cur - buf), " "); |
| cur += 1; |
| |
| for (size_t i = 0; i < 16; i++) |
| { |
| if (i < aLength && isprint(0x7f & aBuf[i])) |
| { |
| char c = 0x7f & aBuf[i]; |
| sprintf_s(cur, sizeof(buf) - (cur - buf), "%c", c); |
| cur += 1; |
| } |
| else |
| { |
| sprintf_s(cur, sizeof(buf) - (cur - buf), "."); |
| cur += 1; |
| } |
| } |
| |
| LogVerbose(DRIVER_DEFAULT, "%s", buf); |
| } |
| |
| VOID |
| DumpBuffer( |
| _In_reads_bytes_(aLength) PCUCHAR aBuf, |
| _In_ size_t aLength |
| ) |
| { |
| for (size_t i = 0; i < aLength; i += 16) |
| { |
| DumpLine(aBuf + i, (aLength - i) < 16 ? (aLength - i) : 16); |
| } |
| } |
