From dbf234926deb45b7c7e2bf455e0c252ca8dfb414 Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Sat, 29 Jun 2019 11:34:15 +0000 Subject: Use NDIS variable style for locals Signed-off-by: Jason A. Donenfeld --- wintun.c | 936 ++++++++++++++++++++++++++++++++------------------------------- 1 file changed, 471 insertions(+), 465 deletions(-) diff --git a/wintun.c b/wintun.c index 39be8a0..06e52c7 100644 --- a/wintun.c +++ b/wintun.c @@ -145,7 +145,7 @@ _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_same_ static void TunIndicateStatus(_In_ NDIS_HANDLE MiniportAdapterHandle, _In_ NDIS_MEDIA_CONNECT_STATE MediaConnectState) { - NDIS_LINK_STATE state = { .Header = { .Type = NDIS_OBJECT_TYPE_DEFAULT, + NDIS_LINK_STATE State = { .Header = { .Type = NDIS_OBJECT_TYPE_DEFAULT, .Revision = NDIS_LINK_STATE_REVISION_1, .Size = NDIS_SIZEOF_LINK_STATE_REVISION_1 }, .MediaConnectState = MediaConnectState, @@ -154,15 +154,15 @@ TunIndicateStatus(_In_ NDIS_HANDLE MiniportAdapterHandle, _In_ NDIS_MEDIA_CONNEC .RcvLinkSpeed = TUN_LINK_SPEED, .PauseFunctions = NdisPauseFunctionsUnsupported }; - NDIS_STATUS_INDICATION t = { .Header = { .Type = NDIS_OBJECT_TYPE_STATUS_INDICATION, - .Revision = NDIS_STATUS_INDICATION_REVISION_1, - .Size = NDIS_SIZEOF_STATUS_INDICATION_REVISION_1 }, - .SourceHandle = MiniportAdapterHandle, - .StatusCode = NDIS_STATUS_LINK_STATE, - .StatusBuffer = &state, - .StatusBufferSize = sizeof(state) }; + NDIS_STATUS_INDICATION Indication = { .Header = { .Type = NDIS_OBJECT_TYPE_STATUS_INDICATION, + .Revision = NDIS_STATUS_INDICATION_REVISION_1, + .Size = NDIS_SIZEOF_STATUS_INDICATION_REVISION_1 }, + .SourceHandle = MiniportAdapterHandle, + .StatusCode = NDIS_STATUS_LINK_STATE, + .StatusBuffer = &State, + .StatusBufferSize = sizeof(State) }; - NdisMIndicateStatusEx(MiniportAdapterHandle, &t); + NdisMIndicateStatusEx(MiniportAdapterHandle, &Indication); } _IRQL_requires_max_(DISPATCH_LEVEL) @@ -194,9 +194,11 @@ _Use_decl_annotations_ static NTSTATUS TunCsqInsertIrpEx(IO_CSQ *Csq, IRP *Irp, PVOID InsertContext) { - TUN_CTX *ctx = CONTAINING_RECORD(Csq, TUN_CTX, Device.ReadQueue.Csq); - (InsertContext == TUN_CSQ_INSERT_HEAD ? InsertHeadList - : InsertTailList)(&ctx->Device.ReadQueue.List, &Irp->Tail.Overlay.ListEntry); + TUN_CTX *Ctx = CONTAINING_RECORD(Csq, TUN_CTX, Device.ReadQueue.Csq); + if (InsertContext == TUN_CSQ_INSERT_HEAD) + InsertHeadList(&Ctx->Device.ReadQueue.List, &Irp->Tail.Overlay.ListEntry); + else + InsertTailList(&Ctx->Device.ReadQueue.List, &Irp->Tail.Overlay.ListEntry); return STATUS_SUCCESS; } @@ -213,22 +215,22 @@ _Use_decl_annotations_ static IRP * TunCsqPeekNextIrp(IO_CSQ *Csq, IRP *Irp, _In_ PVOID PeekContext) { - TUN_CTX *ctx = CONTAINING_RECORD(Csq, TUN_CTX, Device.ReadQueue.Csq); + TUN_CTX *Ctx = CONTAINING_RECORD(Csq, TUN_CTX, Device.ReadQueue.Csq); /* If the IRP is non-NULL, we will start peeking from that IRP onwards, else * we will start from the listhead. This is done under the assumption that * new IRPs are always inserted at the tail. */ - for (LIST_ENTRY *head = &ctx->Device.ReadQueue.List, *next = Irp ? Irp->Tail.Overlay.ListEntry.Flink : head->Flink; - next != head; - next = next->Flink) + for (LIST_ENTRY *Head = &Ctx->Device.ReadQueue.List, *Next = Irp ? Irp->Tail.Overlay.ListEntry.Flink : Head->Flink; + Next != Head; + Next = Next->Flink) { - IRP *irp_next = CONTAINING_RECORD(next, IRP, Tail.Overlay.ListEntry); + IRP *NextIrp = CONTAINING_RECORD(Next, IRP, Tail.Overlay.ListEntry); if (!PeekContext) - return irp_next; + return NextIrp; - IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(irp_next); - if (stack->FileObject == (FILE_OBJECT *)PeekContext) - return irp_next; + IO_STACK_LOCATION *Stack = IoGetCurrentIrpStackLocation(NextIrp); + if (Stack->FileObject == (FILE_OBJECT *)PeekContext) + return NextIrp; } return NULL; @@ -258,8 +260,8 @@ _Use_decl_annotations_ static VOID TunCsqCompleteCanceledIrp(IO_CSQ *Csq, IRP *Irp) { - TUN_CTX *ctx = CONTAINING_RECORD(Csq, TUN_CTX, Device.ReadQueue.Csq); - TunCompleteRequest(ctx, Irp, STATUS_CANCELLED, IO_NO_INCREMENT); + TUN_CTX *Ctx = CONTAINING_RECORD(Csq, TUN_CTX, Device.ReadQueue.Csq); + TunCompleteRequest(Ctx, Irp, STATUS_CANCELLED, IO_NO_INCREMENT); } _IRQL_requires_max_(APC_LEVEL) @@ -267,32 +269,32 @@ _Must_inspect_result_ static NTSTATUS TunMapUbuffer(_Inout_ TUN_MAPPED_UBUFFER *MappedBuffer, _In_ VOID *UserAddress, _In_ ULONG Size) { - VOID *current_uaddr = InterlockedGetPointer(&MappedBuffer->UserAddress); - if (current_uaddr) + VOID *CurrentUserAddress = InterlockedGetPointer(&MappedBuffer->UserAddress); + if (CurrentUserAddress) { - if (UserAddress != current_uaddr || Size > MappedBuffer->Size) /* TODO: Check ThreadID */ + if (UserAddress != CurrentUserAddress || Size > MappedBuffer->Size) /* TODO: Check ThreadID */ return STATUS_ALREADY_INITIALIZED; return STATUS_SUCCESS; } - NTSTATUS status = STATUS_SUCCESS; + NTSTATUS Status = STATUS_SUCCESS; ExAcquireFastMutex(&MappedBuffer->InitializationComplete); /* Recheck the same thing as above, but locked this time. */ - current_uaddr = InterlockedGetPointer(&MappedBuffer->UserAddress); - if (current_uaddr) + CurrentUserAddress = InterlockedGetPointer(&MappedBuffer->UserAddress); + if (CurrentUserAddress) { - if (UserAddress != current_uaddr || Size > MappedBuffer->Size) /* TODO: Check ThreadID */ - status = STATUS_ALREADY_INITIALIZED; + if (UserAddress != CurrentUserAddress || Size > MappedBuffer->Size) /* TODO: Check ThreadID */ + Status = STATUS_ALREADY_INITIALIZED; goto err_releasemutex; } MappedBuffer->Mdl = IoAllocateMdl(UserAddress, Size, FALSE, FALSE, NULL); - status = STATUS_INSUFFICIENT_RESOURCES; + Status = STATUS_INSUFFICIENT_RESOURCES; if (!MappedBuffer->Mdl) goto err_releasemutex; - status = STATUS_INVALID_USER_BUFFER; + Status = STATUS_INVALID_USER_BUFFER; try { MmProbeAndLockPages(MappedBuffer->Mdl, UserMode, IoWriteAccess); @@ -301,7 +303,7 @@ TunMapUbuffer(_Inout_ TUN_MAPPED_UBUFFER *MappedBuffer, _In_ VOID *UserAddress, MappedBuffer->KernelAddress = MmGetSystemAddressForMdlSafe(MappedBuffer->Mdl, NormalPagePriority | MdlMappingNoExecute); - status = STATUS_INSUFFICIENT_RESOURCES; + Status = STATUS_INSUFFICIENT_RESOURCES; if (!MappedBuffer->KernelAddress) goto err_unlockmdl; MappedBuffer->Size = Size; @@ -316,7 +318,7 @@ err_freemdl: MappedBuffer->Mdl = NULL; err_releasemutex: ExReleaseFastMutex(&MappedBuffer->InitializationComplete); - return status; + return Status; } _IRQL_requires_max_(DISPATCH_LEVEL) @@ -336,31 +338,31 @@ _Must_inspect_result_ static NTSTATUS TunMapIrp(_In_ IRP *Irp) { - ULONG size; - TUN_MAPPED_UBUFFER *ubuffer; - IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(Irp); - TUN_FILE_CTX *file_ctx = (TUN_FILE_CTX *)stack->FileObject->FsContext; + ULONG Size; + TUN_MAPPED_UBUFFER *UserBuffer; + IO_STACK_LOCATION *Stack = IoGetCurrentIrpStackLocation(Irp); + TUN_FILE_CTX *FileCtx = (TUN_FILE_CTX *)Stack->FileObject->FsContext; - switch (stack->MajorFunction) + switch (Stack->MajorFunction) { case IRP_MJ_READ: - size = stack->Parameters.Read.Length; - if (size < TUN_EXCH_MIN_BUFFER_SIZE_READ) + Size = Stack->Parameters.Read.Length; + if (Size < TUN_EXCH_MIN_BUFFER_SIZE_READ) return STATUS_INVALID_USER_BUFFER; - ubuffer = &file_ctx->ReadBuffer; + UserBuffer = &FileCtx->ReadBuffer; break; case IRP_MJ_WRITE: - size = stack->Parameters.Write.Length; - if (size < TUN_EXCH_MIN_BUFFER_SIZE_WRITE) + Size = Stack->Parameters.Write.Length; + if (Size < TUN_EXCH_MIN_BUFFER_SIZE_WRITE) return STATUS_INVALID_USER_BUFFER; - ubuffer = &file_ctx->WriteBuffer; + UserBuffer = &FileCtx->WriteBuffer; break; default: return STATUS_INVALID_PARAMETER; } - if (size > TUN_EXCH_MAX_BUFFER_SIZE) + if (Size > TUN_EXCH_MAX_BUFFER_SIZE) return STATUS_INVALID_USER_BUFFER; - return TunMapUbuffer(ubuffer, Irp->UserBuffer, size); + return TunMapUbuffer(UserBuffer, Irp->UserBuffer, Size); } _IRQL_requires_max_(DISPATCH_LEVEL) @@ -368,14 +370,14 @@ _Must_inspect_result_ static _Return_type_success_( return != NULL) IRP *TunRemoveNextIrp(_Inout_ TUN_CTX *Ctx, _Out_ UCHAR **Buffer, _Out_ ULONG *Size) { - IRP *irp = IoCsqRemoveNextIrp(&Ctx->Device.ReadQueue.Csq, NULL); - if (!irp) + IRP *Irp = IoCsqRemoveNextIrp(&Ctx->Device.ReadQueue.Csq, NULL); + if (!Irp) return NULL; - IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(irp); - *Size = stack->Parameters.Read.Length; - ASSERT(irp->IoStatus.Information <= (ULONG_PTR)*Size); - *Buffer = ((TUN_FILE_CTX *)stack->FileObject->FsContext)->ReadBuffer.KernelAddress; - return irp; + IO_STACK_LOCATION *Stack = IoGetCurrentIrpStackLocation(Irp); + *Size = Stack->Parameters.Read.Length; + ASSERT(Irp->IoStatus.Information <= (ULONG_PTR)*Size); + *Buffer = ((TUN_FILE_CTX *)Stack->FileObject->FsContext)->ReadBuffer.KernelAddress; + return Irp; } _IRQL_requires_same_ static BOOLEAN @@ -390,24 +392,24 @@ _Must_inspect_result_ static NTSTATUS TunWriteIntoIrp(_Inout_ IRP *Irp, _Inout_ UCHAR *Buffer, _In_ NET_BUFFER *Nb, _Inout_ NDIS_STATISTICS_INFO *Statistics) { - ULONG p_size = NET_BUFFER_DATA_LENGTH(Nb); - TUN_PACKET *p = (TUN_PACKET *)(Buffer + Irp->IoStatus.Information); + ULONG PacketSize = NET_BUFFER_DATA_LENGTH(Nb); + TUN_PACKET *Packet = (TUN_PACKET *)(Buffer + Irp->IoStatus.Information); - p->Size = p_size; - void *ptr = NdisGetDataBuffer(Nb, p_size, p->Data, 1, 0); - if (!ptr) + Packet->Size = PacketSize; /* We shouldn't trust Packet->Size directly for reading, because the usre controls it. */ + void *NbData = NdisGetDataBuffer(Nb, PacketSize, Packet->Data, 1, 0); + if (!NbData) { if (Statistics) InterlockedIncrement64((LONG64 *)&Statistics->ifOutErrors); return NDIS_STATUS_RESOURCES; } - if (ptr != p->Data) - NdisMoveMemory(p->Data, ptr, p_size); + if (NbData != Packet->Data) + NdisMoveMemory(Packet->Data, NbData, PacketSize); - Irp->IoStatus.Information += TunPacketAlign(sizeof(TUN_PACKET) + p_size); + Irp->IoStatus.Information += TunPacketAlign(sizeof(TUN_PACKET) + PacketSize); - InterlockedAdd64((LONG64 *)&Statistics->ifHCOutOctets, p_size); - InterlockedAdd64((LONG64 *)&Statistics->ifHCOutUcastOctets, p_size); + InterlockedAdd64((LONG64 *)&Statistics->ifHCOutOctets, PacketSize); + InterlockedAdd64((LONG64 *)&Statistics->ifHCOutUcastOctets, PacketSize); InterlockedIncrement64((LONG64 *)&Statistics->ifHCOutUcastPkts); return STATUS_SUCCESS; } @@ -460,9 +462,9 @@ _IRQL_requires_max_(DISPATCH_LEVEL) static void TunQueueAppend(_Inout_ TUN_CTX *Ctx, _In_ NET_BUFFER_LIST *Nbl, _In_ UINT MaxNbls) { - for (NET_BUFFER_LIST *nbl_next; Nbl; Nbl = nbl_next) + for (NET_BUFFER_LIST *NextNbl; Nbl; Nbl = NextNbl) { - nbl_next = NET_BUFFER_LIST_NEXT_NBL(Nbl); + NextNbl = NET_BUFFER_LIST_NEXT_NBL(Nbl); if (!NET_BUFFER_LIST_FIRST_NB(Nbl)) { NET_BUFFER_LIST_NEXT_NBL(Nbl) = NULL; @@ -470,25 +472,25 @@ TunQueueAppend(_Inout_ TUN_CTX *Ctx, _In_ NET_BUFFER_LIST *Nbl, _In_ UINT MaxNbl continue; } - KLOCK_QUEUE_HANDLE lqh; - KeAcquireInStackQueuedSpinLock(&Ctx->PacketQueue.Lock, &lqh); + KLOCK_QUEUE_HANDLE LockHandle; + KeAcquireInStackQueuedSpinLock(&Ctx->PacketQueue.Lock, &LockHandle); TunNBLRefInit(Ctx, Nbl); TunAppendNBL(&Ctx->PacketQueue.FirstNbl, &Ctx->PacketQueue.LastNbl, Nbl); while ((UINT)InterlockedGet(&Ctx->PacketQueue.NumNbl) > MaxNbls && Ctx->PacketQueue.FirstNbl) { - NET_BUFFER_LIST *nbl_second = NET_BUFFER_LIST_NEXT_NBL(Ctx->PacketQueue.FirstNbl); + NET_BUFFER_LIST *SecondNbl = NET_BUFFER_LIST_NEXT_NBL(Ctx->PacketQueue.FirstNbl); NET_BUFFER_LIST_STATUS(Ctx->PacketQueue.FirstNbl) = NDIS_STATUS_SEND_ABORTED; TunNBLRefDec(Ctx, Ctx->PacketQueue.FirstNbl, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); Ctx->PacketQueue.NextNb = NULL; - Ctx->PacketQueue.FirstNbl = nbl_second; + Ctx->PacketQueue.FirstNbl = SecondNbl; if (!Ctx->PacketQueue.FirstNbl) Ctx->PacketQueue.LastNbl = NULL; } - KeReleaseInStackQueuedSpinLock(&lqh); + KeReleaseInStackQueuedSpinLock(&LockHandle); } } @@ -498,37 +500,37 @@ _Must_inspect_result_ static _Return_type_success_(return != NULL) NET_BUFFER *TunQueueRemove(_Inout_ TUN_CTX *Ctx, _Out_ NET_BUFFER_LIST **Nbl) { - NET_BUFFER_LIST *nbl_top; - NET_BUFFER *ret; + NET_BUFFER_LIST *TopNbl; + NET_BUFFER *RetNbl; retry: - nbl_top = Ctx->PacketQueue.FirstNbl; - *Nbl = nbl_top; - if (!nbl_top) + TopNbl = Ctx->PacketQueue.FirstNbl; + *Nbl = TopNbl; + if (!TopNbl) return NULL; if (!Ctx->PacketQueue.NextNb) - Ctx->PacketQueue.NextNb = NET_BUFFER_LIST_FIRST_NB(nbl_top); - ret = Ctx->PacketQueue.NextNb; - Ctx->PacketQueue.NextNb = NET_BUFFER_NEXT_NB(ret); + Ctx->PacketQueue.NextNb = NET_BUFFER_LIST_FIRST_NB(TopNbl); + RetNbl = Ctx->PacketQueue.NextNb; + Ctx->PacketQueue.NextNb = NET_BUFFER_NEXT_NB(RetNbl); if (!Ctx->PacketQueue.NextNb) { - Ctx->PacketQueue.FirstNbl = NET_BUFFER_LIST_NEXT_NBL(nbl_top); + Ctx->PacketQueue.FirstNbl = NET_BUFFER_LIST_NEXT_NBL(TopNbl); if (!Ctx->PacketQueue.FirstNbl) Ctx->PacketQueue.LastNbl = NULL; - NET_BUFFER_LIST_NEXT_NBL(nbl_top) = NULL; + NET_BUFFER_LIST_NEXT_NBL(TopNbl) = NULL; } else - TunNBLRefInc(nbl_top); + TunNBLRefInc(TopNbl); - if (ret && NET_BUFFER_DATA_LENGTH(ret) > TUN_EXCH_MAX_IP_PACKET_SIZE) + if (RetNbl && NET_BUFFER_DATA_LENGTH(RetNbl) > TUN_EXCH_MAX_IP_PACKET_SIZE) { - NET_BUFFER_LIST_STATUS(nbl_top) = NDIS_STATUS_INVALID_LENGTH; - TunNBLRefDec(Ctx, nbl_top, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); + NET_BUFFER_LIST_STATUS(TopNbl) = NDIS_STATUS_INVALID_LENGTH; + TunNBLRefDec(Ctx, TopNbl, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); InterlockedIncrement64((LONG64 *)&Ctx->Statistics.ifOutDiscards); goto retry; } - return ret; + return RetNbl; } /* Note: Must be called immediately after TunQueueRemove without dropping ctx->PacketQueue.Lock. */ @@ -557,19 +559,19 @@ _IRQL_requires_max_(DISPATCH_LEVEL) static void TunQueueClear(_Inout_ TUN_CTX *Ctx, _In_ NDIS_STATUS Status) { - KLOCK_QUEUE_HANDLE lqh; - KeAcquireInStackQueuedSpinLock(&Ctx->PacketQueue.Lock, &lqh); - for (NET_BUFFER_LIST *nbl = Ctx->PacketQueue.FirstNbl, *nbl_next; nbl; nbl = nbl_next) + KLOCK_QUEUE_HANDLE LockHandle; + KeAcquireInStackQueuedSpinLock(&Ctx->PacketQueue.Lock, &LockHandle); + for (NET_BUFFER_LIST *Nbl = Ctx->PacketQueue.FirstNbl, *NextNbl; Nbl; Nbl = NextNbl) { - nbl_next = NET_BUFFER_LIST_NEXT_NBL(nbl); - NET_BUFFER_LIST_STATUS(nbl) = Status; - TunNBLRefDec(Ctx, nbl, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); + NextNbl = NET_BUFFER_LIST_NEXT_NBL(Nbl); + NET_BUFFER_LIST_STATUS(Nbl) = Status; + TunNBLRefDec(Ctx, Nbl, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); } Ctx->PacketQueue.FirstNbl = NULL; Ctx->PacketQueue.LastNbl = NULL; Ctx->PacketQueue.NextNb = NULL; InterlockedExchange(&Ctx->PacketQueue.NumNbl, 0); - KeReleaseInStackQueuedSpinLock(&lqh); + KeReleaseInStackQueuedSpinLock(&LockHandle); } _Requires_lock_not_held_(Ctx->PacketQueue.Lock) @@ -577,75 +579,75 @@ _IRQL_requires_max_(DISPATCH_LEVEL) static void TunQueueProcess(_Inout_ TUN_CTX *Ctx) { - IRP *irp = NULL; - UCHAR *buffer = NULL; - ULONG size = 0; - NET_BUFFER *nb; - KLOCK_QUEUE_HANDLE lqh; + IRP *Irp = NULL; + UCHAR *Buffer = NULL; + ULONG Size = 0; + NET_BUFFER *Nb; + KLOCK_QUEUE_HANDLE LockHandle; for (;;) { - NET_BUFFER_LIST *nbl; + NET_BUFFER_LIST *Nbl; - KeAcquireInStackQueuedSpinLock(&Ctx->PacketQueue.Lock, &lqh); + KeAcquireInStackQueuedSpinLock(&Ctx->PacketQueue.Lock, &LockHandle); /* Get head NB (and IRP). */ - if (!irp) + if (!Irp) { - nb = TunQueueRemove(Ctx, &nbl); - if (!nb) + Nb = TunQueueRemove(Ctx, &Nbl); + if (!Nb) { - KeReleaseInStackQueuedSpinLock(&lqh); + KeReleaseInStackQueuedSpinLock(&LockHandle); return; } - irp = TunRemoveNextIrp(Ctx, &buffer, &size); - if (!irp) + Irp = TunRemoveNextIrp(Ctx, &Buffer, &Size); + if (!Irp) { - TunQueuePrepend(Ctx, nb, nbl); - KeReleaseInStackQueuedSpinLock(&lqh); - if (nbl) - TunNBLRefDec(Ctx, nbl, 0); + TunQueuePrepend(Ctx, Nb, Nbl); + KeReleaseInStackQueuedSpinLock(&LockHandle); + if (Nbl) + TunNBLRefDec(Ctx, Nbl, 0); return; } - _Analysis_assume_(buffer); - _Analysis_assume_(irp->IoStatus.Information <= size); + _Analysis_assume_(Buffer); + _Analysis_assume_(Irp->IoStatus.Information <= Size); } else - nb = TunQueueRemove(Ctx, &nbl); + Nb = TunQueueRemove(Ctx, &Nbl); /* If the NB won't fit in the IRP, return it. */ - if (nb && TunWontFitIntoIrp(irp, size, nb)) + if (Nb && TunWontFitIntoIrp(Irp, Size, Nb)) { - TunQueuePrepend(Ctx, nb, nbl); - if (nbl) - TunNBLRefDec(Ctx, nbl, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); - nbl = NULL; - nb = NULL; + TunQueuePrepend(Ctx, Nb, Nbl); + if (Nbl) + TunNBLRefDec(Ctx, Nbl, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); + Nbl = NULL; + Nb = NULL; } - KeReleaseInStackQueuedSpinLock(&lqh); + KeReleaseInStackQueuedSpinLock(&LockHandle); /* Process NB and IRP. */ - if (nb) + if (Nb) { - NTSTATUS status = TunWriteIntoIrp(irp, buffer, nb, &Ctx->Statistics); + NTSTATUS status = TunWriteIntoIrp(Irp, Buffer, Nb, &Ctx->Statistics); if (!NT_SUCCESS(status)) { - if (nbl) - NET_BUFFER_LIST_STATUS(nbl) = status; - IoCsqInsertIrpEx(&Ctx->Device.ReadQueue.Csq, irp, NULL, TUN_CSQ_INSERT_HEAD); - irp = NULL; + if (Nbl) + NET_BUFFER_LIST_STATUS(Nbl) = status; + IoCsqInsertIrpEx(&Ctx->Device.ReadQueue.Csq, Irp, NULL, TUN_CSQ_INSERT_HEAD); + Irp = NULL; } } else { - TunCompleteRequest(Ctx, irp, STATUS_SUCCESS, IO_NETWORK_INCREMENT); - irp = NULL; + TunCompleteRequest(Ctx, Irp, STATUS_SUCCESS, IO_NETWORK_INCREMENT); + Irp = NULL; } - if (nbl) - TunNBLRefDec(Ctx, nbl, 0); + if (Nbl) + TunNBLRefDec(Ctx, Nbl, 0); } } @@ -665,30 +667,30 @@ TunSendNetBufferLists( NDIS_PORT_NUMBER PortNumber, ULONG SendFlags) { - TUN_CTX *ctx = (TUN_CTX *)MiniportAdapterContext; + TUN_CTX *Ctx = (TUN_CTX *)MiniportAdapterContext; - InterlockedIncrement64(&ctx->ActiveNBLCount); + InterlockedIncrement64(&Ctx->ActiveNBLCount); - KIRQL irql = ExAcquireSpinLockShared(&ctx->TransitionLock); - LONG flags = InterlockedGet(&ctx->Flags); - NDIS_STATUS status; - if ((status = NDIS_STATUS_ADAPTER_REMOVED, !(flags & TUN_FLAGS_PRESENT)) || - (status = NDIS_STATUS_PAUSED, !(flags & TUN_FLAGS_RUNNING)) || - (status = NDIS_STATUS_MEDIA_DISCONNECTED, InterlockedGet64(&ctx->Device.RefCount) <= 0)) + KIRQL Irql = ExAcquireSpinLockShared(&Ctx->TransitionLock); + LONG Flags = InterlockedGet(&Ctx->Flags); + NDIS_STATUS Status; + if ((Status = NDIS_STATUS_ADAPTER_REMOVED, !(Flags & TUN_FLAGS_PRESENT)) || + (Status = NDIS_STATUS_PAUSED, !(Flags & TUN_FLAGS_RUNNING)) || + (Status = NDIS_STATUS_MEDIA_DISCONNECTED, InterlockedGet64(&Ctx->Device.RefCount) <= 0)) { - TunSetNBLStatus(NetBufferLists, status); + TunSetNBLStatus(NetBufferLists, Status); NdisMSendNetBufferListsComplete( - ctx->MiniportAdapterHandle, NetBufferLists, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); + Ctx->MiniportAdapterHandle, NetBufferLists, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); goto cleanup_ExReleaseSpinLockShared; } - TunQueueAppend(ctx, NetBufferLists, TUN_QUEUE_MAX_NBLS); + TunQueueAppend(Ctx, NetBufferLists, TUN_QUEUE_MAX_NBLS); - TunQueueProcess(ctx); + TunQueueProcess(Ctx); cleanup_ExReleaseSpinLockShared: - ExReleaseSpinLockShared(&ctx->TransitionLock, irql); - TunCompletePause(ctx, TRUE); + ExReleaseSpinLockShared(&Ctx->TransitionLock, Irql); + TunCompletePause(Ctx, TRUE); } static MINIPORT_CANCEL_SEND TunCancelSend; @@ -696,30 +698,30 @@ _Use_decl_annotations_ static void TunCancelSend(NDIS_HANDLE MiniportAdapterContext, PVOID CancelId) { - TUN_CTX *ctx = (TUN_CTX *)MiniportAdapterContext; - KLOCK_QUEUE_HANDLE lqh; + TUN_CTX *Ctx = (TUN_CTX *)MiniportAdapterContext; + KLOCK_QUEUE_HANDLE LockHandle; - KeAcquireInStackQueuedSpinLock(&ctx->PacketQueue.Lock, &lqh); + KeAcquireInStackQueuedSpinLock(&Ctx->PacketQueue.Lock, &LockHandle); - NET_BUFFER_LIST *nbl_last = NULL, **nbl_last_link = &ctx->PacketQueue.FirstNbl; - for (NET_BUFFER_LIST *nbl = ctx->PacketQueue.FirstNbl, *nbl_next; nbl; nbl = nbl_next) + NET_BUFFER_LIST *LastNbl = NULL, **LastNblLink = &Ctx->PacketQueue.FirstNbl; + for (NET_BUFFER_LIST *Nbl = Ctx->PacketQueue.FirstNbl, *NextNbl; Nbl; Nbl = NextNbl) { - nbl_next = NET_BUFFER_LIST_NEXT_NBL(nbl); - if (NDIS_GET_NET_BUFFER_LIST_CANCEL_ID(nbl) == CancelId) + NextNbl = NET_BUFFER_LIST_NEXT_NBL(Nbl); + if (NDIS_GET_NET_BUFFER_LIST_CANCEL_ID(Nbl) == CancelId) { - NET_BUFFER_LIST_STATUS(nbl) = NDIS_STATUS_SEND_ABORTED; - *nbl_last_link = nbl_next; - TunNBLRefDec(ctx, nbl, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); + NET_BUFFER_LIST_STATUS(Nbl) = NDIS_STATUS_SEND_ABORTED; + *LastNblLink = NextNbl; + TunNBLRefDec(Ctx, Nbl, NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL); } else { - nbl_last = nbl; - nbl_last_link = &NET_BUFFER_LIST_NEXT_NBL(nbl); + LastNbl = Nbl; + LastNblLink = &NET_BUFFER_LIST_NEXT_NBL(Nbl); } } - ctx->PacketQueue.LastNbl = nbl_last; + Ctx->PacketQueue.LastNbl = LastNbl; - KeReleaseInStackQueuedSpinLock(&lqh); + KeReleaseInStackQueuedSpinLock(&LockHandle); } _IRQL_requires_max_(APC_LEVEL) @@ -727,25 +729,25 @@ _Must_inspect_result_ static NTSTATUS TunDispatchRead(_Inout_ TUN_CTX *Ctx, _Inout_ IRP *Irp) { - NTSTATUS status = TunMapIrp(Irp); - if (!NT_SUCCESS(status)) + NTSTATUS Status = TunMapIrp(Irp); + if (!NT_SUCCESS(Status)) goto cleanup_CompleteRequest; - KIRQL irql = ExAcquireSpinLockShared(&Ctx->TransitionLock); - LONG flags = InterlockedGet(&Ctx->Flags); - if ((status = STATUS_FILE_FORCED_CLOSED, !(flags & TUN_FLAGS_PRESENT)) || - !NT_SUCCESS(status = IoCsqInsertIrpEx(&Ctx->Device.ReadQueue.Csq, Irp, NULL, TUN_CSQ_INSERT_TAIL))) + KIRQL Irql = ExAcquireSpinLockShared(&Ctx->TransitionLock); + LONG Flags = InterlockedGet(&Ctx->Flags); + if ((Status = STATUS_FILE_FORCED_CLOSED, !(Flags & TUN_FLAGS_PRESENT)) || + !NT_SUCCESS(Status = IoCsqInsertIrpEx(&Ctx->Device.ReadQueue.Csq, Irp, NULL, TUN_CSQ_INSERT_TAIL))) goto cleanup_ExReleaseSpinLockShared; TunQueueProcess(Ctx); - ExReleaseSpinLockShared(&Ctx->TransitionLock, irql); + ExReleaseSpinLockShared(&Ctx->TransitionLock, Irql); return STATUS_PENDING; cleanup_ExReleaseSpinLockShared: - ExReleaseSpinLockShared(&Ctx->TransitionLock, irql); + ExReleaseSpinLockShared(&Ctx->TransitionLock, Irql); cleanup_CompleteRequest: - TunCompleteRequest(Ctx, Irp, status, IO_NO_INCREMENT); - return status; + TunCompleteRequest(Ctx, Irp, Status, IO_NO_INCREMENT); + return Status; } #define IRP_REFCOUNT(irp) ((volatile LONG *)&(irp)->Tail.Overlay.DriverContext[0]) @@ -756,155 +758,155 @@ _Must_inspect_result_ static NTSTATUS TunDispatchWrite(_Inout_ TUN_CTX *Ctx, _Inout_ IRP *Irp) { - NTSTATUS status; + NTSTATUS Status; InterlockedIncrement64(&Ctx->ActiveNBLCount); - if (!NT_SUCCESS(status = TunMapIrp(Irp))) + if (!NT_SUCCESS(Status = TunMapIrp(Irp))) goto cleanup_CompleteRequest; - KIRQL irql = ExAcquireSpinLockShared(&Ctx->TransitionLock); - LONG flags = InterlockedGet(&Ctx->Flags); - if (status = STATUS_FILE_FORCED_CLOSED, !(flags & TUN_FLAGS_PRESENT)) + KIRQL Irql = ExAcquireSpinLockShared(&Ctx->TransitionLock); + LONG Flags = InterlockedGet(&Ctx->Flags); + if (Status = STATUS_FILE_FORCED_CLOSED, !(Flags & TUN_FLAGS_PRESENT)) goto cleanup_ExReleaseSpinLockShared; - IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(Irp); - TUN_MAPPED_UBUFFER *ubuffer = &((TUN_FILE_CTX *)stack->FileObject->FsContext)->WriteBuffer; - UCHAR *buffer = ubuffer->KernelAddress; - ULONG size = stack->Parameters.Write.Length; + IO_STACK_LOCATION *Stack = IoGetCurrentIrpStackLocation(Irp); + TUN_MAPPED_UBUFFER *UserBuffer = &((TUN_FILE_CTX *)Stack->FileObject->FsContext)->WriteBuffer; + UCHAR *BufferStart = UserBuffer->KernelAddress; + ULONG Size = Stack->Parameters.Write.Length; - const UCHAR *b = buffer, *b_end = buffer + size; - typedef enum _ethtypeidx_t + const UCHAR *BufferPos = BufferStart, *BufferEnd = BufferStart + Size; + typedef enum { - ethtypeidx_ipv4 = 0, - ethtypeidx_start = 0, - ethtypeidx_ipv6, - ethtypeidx_end - } ethtypeidx_t; + EtherTypeIndexIPv4 = 0, + EtherTypeIndexStart = 0, + EtherTypeIndexIPv6, + EtherTypeIndexEnd + } EtherTypeIndex; static const struct { - ULONG nbl_flags; - USHORT nbl_proto; - } ether_const[ethtypeidx_end] = { + ULONG NblFlags; + USHORT NblProto; + } EtherTypeConstants[EtherTypeIndexEnd] = { { NDIS_NBL_FLAGS_IS_IPV4, TUN_HTONS(NDIS_ETH_TYPE_IPV4) }, { NDIS_NBL_FLAGS_IS_IPV6, TUN_HTONS(NDIS_ETH_TYPE_IPV6) }, }; struct { - NET_BUFFER_LIST *head, *tail; - LONG count; - } nbl_queue[ethtypeidx_end] = { { NULL, NULL, 0 }, { NULL, NULL, 0 } }; - LONG nbl_count = 0; - while (b_end - b >= sizeof(TUN_PACKET)) + NET_BUFFER_LIST *Head, *Tail; + LONG Count; + } NblQueue[EtherTypeIndexEnd] = { { NULL, NULL, 0 }, { NULL, NULL, 0 } }; + LONG NblCount = 0; + while (BufferEnd - BufferPos >= sizeof(TUN_PACKET)) { - if (nbl_count >= MAXLONG) + if (NblCount >= MAXLONG) { - status = STATUS_INVALID_USER_BUFFER; + Status = STATUS_INVALID_USER_BUFFER; goto cleanup_nbl_queues; } - TUN_PACKET *p = (TUN_PACKET *)b; - if (p->Size > TUN_EXCH_MAX_IP_PACKET_SIZE) + TUN_PACKET *Packet = (TUN_PACKET *)BufferPos; + if (Packet->Size > TUN_EXCH_MAX_IP_PACKET_SIZE) { - status = STATUS_INVALID_USER_BUFFER; + Status = STATUS_INVALID_USER_BUFFER; goto cleanup_nbl_queues; } - ULONG p_size = TunPacketAlign(sizeof(TUN_PACKET) + p->Size); - if (b_end - b < (ptrdiff_t)p_size) + ULONG PacketSize = TunPacketAlign(sizeof(TUN_PACKET) + Packet->Size); + if (BufferEnd - BufferPos < (ptrdiff_t)PacketSize) { - status = STATUS_INVALID_USER_BUFFER; + Status = STATUS_INVALID_USER_BUFFER; goto cleanup_nbl_queues; } - ethtypeidx_t idx; - if (p->Size >= 20 && p->Data[0] >> 4 == 4) - idx = ethtypeidx_ipv4; - else if (p->Size >= 40 && p->Data[0] >> 4 == 6) - idx = ethtypeidx_ipv6; + EtherTypeIndex Index; + if (Packet->Size >= 20 && Packet->Data[0] >> 4 == 4) + Index = EtherTypeIndexIPv4; + else if (Packet->Size >= 40 && Packet->Data[0] >> 4 == 6) + Index = EtherTypeIndexIPv6; else { - status = STATUS_INVALID_USER_BUFFER; + Status = STATUS_INVALID_USER_BUFFER; goto cleanup_nbl_queues; } - NET_BUFFER_LIST *nbl = - NdisAllocateNetBufferAndNetBufferList(Ctx->NBLPool, 0, 0, ubuffer->Mdl, (ULONG)(p->Data - buffer), p->Size); - if (!nbl) + NET_BUFFER_LIST *Nbl = NdisAllocateNetBufferAndNetBufferList( + Ctx->NBLPool, 0, 0, UserBuffer->Mdl, (ULONG)(Packet->Data - BufferStart), Packet->Size); + if (!Nbl) { - status = STATUS_INSUFFICIENT_RESOURCES; + Status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup_nbl_queues; } - nbl->SourceHandle = Ctx->MiniportAdapterHandle; - NdisSetNblFlag(nbl, ether_const[idx].nbl_flags); - NET_BUFFER_LIST_INFO(nbl, NetBufferListFrameType) = (PVOID)ether_const[idx].nbl_proto; - NET_BUFFER_LIST_STATUS(nbl) = NDIS_STATUS_SUCCESS; - NET_BUFFER_LIST_IRP(nbl) = Irp; - TunAppendNBL(&nbl_queue[idx].head, &nbl_queue[idx].tail, nbl); - nbl_queue[idx].count++; - nbl_count++; - b += p_size; + Nbl->SourceHandle = Ctx->MiniportAdapterHandle; + NdisSetNblFlag(Nbl, EtherTypeConstants[Index].NblFlags); + NET_BUFFER_LIST_INFO(Nbl, NetBufferListFrameType) = (PVOID)EtherTypeConstants[Index].NblProto; + NET_BUFFER_LIST_STATUS(Nbl) = NDIS_STATUS_SUCCESS; + NET_BUFFER_LIST_IRP(Nbl) = Irp; + TunAppendNBL(&NblQueue[Index].Head, &NblQueue[Index].Tail, Nbl); + NblQueue[Index].Count++; + NblCount++; + BufferPos += PacketSize; } - if ((ULONG)(b - buffer) != size) + if ((ULONG)(BufferPos - BufferStart) != Size) { - status = STATUS_INVALID_USER_BUFFER; + Status = STATUS_INVALID_USER_BUFFER; goto cleanup_nbl_queues; } - Irp->IoStatus.Information = size; + Irp->IoStatus.Information = Size; - if (!nbl_count) + if (!NblCount) { - status = STATUS_SUCCESS; + Status = STATUS_SUCCESS; goto cleanup_ExReleaseSpinLockShared; } - if (!(flags & TUN_FLAGS_RUNNING)) + if (!(Flags & TUN_FLAGS_RUNNING)) { - InterlockedAdd64((LONG64 *)&Ctx->Statistics.ifInDiscards, nbl_count); - InterlockedAdd64((LONG64 *)&Ctx->Statistics.ifInErrors, nbl_count); - status = STATUS_SUCCESS; + InterlockedAdd64((LONG64 *)&Ctx->Statistics.ifInDiscards, NblCount); + InterlockedAdd64((LONG64 *)&Ctx->Statistics.ifInErrors, NblCount); + Status = STATUS_SUCCESS; goto cleanup_nbl_queues; } - InterlockedAdd64(&Ctx->ActiveNBLCount, nbl_count); - InterlockedExchange(IRP_REFCOUNT(Irp), nbl_count); + InterlockedAdd64(&Ctx->ActiveNBLCount, NblCount); + InterlockedExchange(IRP_REFCOUNT(Irp), NblCount); IoMarkIrpPending(Irp); - if (nbl_queue[ethtypeidx_ipv4].head) + if (NblQueue[EtherTypeIndexIPv4].Head) NdisMIndicateReceiveNetBufferLists( Ctx->MiniportAdapterHandle, - nbl_queue[ethtypeidx_ipv4].head, + NblQueue[EtherTypeIndexIPv4].Head, NDIS_DEFAULT_PORT_NUMBER, - nbl_queue[ethtypeidx_ipv4].count, + NblQueue[EtherTypeIndexIPv4].Count, NDIS_RECEIVE_FLAGS_SINGLE_ETHER_TYPE); - if (nbl_queue[ethtypeidx_ipv6].head) + if (NblQueue[EtherTypeIndexIPv6].Head) NdisMIndicateReceiveNetBufferLists( Ctx->MiniportAdapterHandle, - nbl_queue[ethtypeidx_ipv6].head, + NblQueue[EtherTypeIndexIPv6].Head, NDIS_DEFAULT_PORT_NUMBER, - nbl_queue[ethtypeidx_ipv6].count, + NblQueue[EtherTypeIndexIPv6].Count, NDIS_RECEIVE_FLAGS_SINGLE_ETHER_TYPE); - ExReleaseSpinLockShared(&Ctx->TransitionLock, irql); + ExReleaseSpinLockShared(&Ctx->TransitionLock, Irql); TunCompletePause(Ctx, TRUE); return STATUS_PENDING; cleanup_nbl_queues: - for (ethtypeidx_t idx = ethtypeidx_start; idx < ethtypeidx_end; idx++) + for (EtherTypeIndex Index = EtherTypeIndexStart; Index < EtherTypeIndexEnd; Index++) { - for (NET_BUFFER_LIST *nbl = nbl_queue[idx].head, *nbl_next; nbl; nbl = nbl_next) + for (NET_BUFFER_LIST *Nbl = NblQueue[Index].Head, *NextNbl; Nbl; Nbl = NextNbl) { - nbl_next = NET_BUFFER_LIST_NEXT_NBL(nbl); - NET_BUFFER_LIST_NEXT_NBL(nbl) = NULL; - NdisFreeNetBufferList(nbl); + NextNbl = NET_BUFFER_LIST_NEXT_NBL(Nbl); + NET_BUFFER_LIST_NEXT_NBL(Nbl) = NULL; + NdisFreeNetBufferList(Nbl); } } cleanup_ExReleaseSpinLockShared: - ExReleaseSpinLockShared(&Ctx->TransitionLock, irql); + ExReleaseSpinLockShared(&Ctx->TransitionLock, Irql); cleanup_CompleteRequest: - TunCompleteRequest(Ctx, Irp, status, IO_NO_INCREMENT); + TunCompleteRequest(Ctx, Irp, Status, IO_NO_INCREMENT); TunCompletePause(Ctx, TRUE); - return status; + return Status; } static MINIPORT_RETURN_NET_BUFFER_LISTS TunReturnNetBufferLists; @@ -912,36 +914,35 @@ _Use_decl_annotations_ static void TunReturnNetBufferLists(NDIS_HANDLE MiniportAdapterContext, PNET_BUFFER_LIST NetBufferLists, ULONG ReturnFlags) { - TUN_CTX *ctx = (TUN_CTX *)MiniportAdapterContext; + TUN_CTX *Ctx = (TUN_CTX *)MiniportAdapterContext; - LONG64 stat_size = 0, stat_p_ok = 0, stat_p_err = 0; - for (NET_BUFFER_LIST *nbl = NetBufferLists, *nbl_next; nbl; nbl = nbl_next) + LONG64 StatSize = 0, StatPacketsOk = 0, StatPacketsError = 0; + for (NET_BUFFER_LIST *Nbl = NetBufferLists, *NextNbl; Nbl; Nbl = NextNbl) { - nbl_next = NET_BUFFER_LIST_NEXT_NBL(nbl); - NET_BUFFER_LIST_NEXT_NBL(nbl) = NULL; + NextNbl = NET_BUFFER_LIST_NEXT_NBL(Nbl); + NET_BUFFER_LIST_NEXT_NBL(Nbl) = NULL; - IRP *irp = NET_BUFFER_LIST_IRP(nbl); - if (NT_SUCCESS(NET_BUFFER_LIST_STATUS(nbl))) + IRP *Irp = NET_BUFFER_LIST_IRP(Nbl); + if (NT_SUCCESS(NET_BUFFER_LIST_STATUS(Nbl))) { - ULONG p_size = NET_BUFFER_LIST_FIRST_NB(nbl)->DataLength; - stat_size += p_size; - stat_p_ok++; + StatSize += NET_BUFFER_LIST_FIRST_NB(Nbl)->DataLength; + StatPacketsOk++; } else - stat_p_err++; + StatPacketsError++; - NdisFreeNetBufferList(nbl); - TunCompletePause(ctx, TRUE); + NdisFreeNetBufferList(Nbl); + TunCompletePause(Ctx, TRUE); - ASSERT(InterlockedGet(IRP_REFCOUNT(irp)) > 0); - if (InterlockedDecrement(IRP_REFCOUNT(irp)) <= 0) - TunCompleteRequest(ctx, irp, STATUS_SUCCESS, IO_NETWORK_INCREMENT); + ASSERT(InterlockedGet(IRP_REFCOUNT(Irp)) > 0); + if (InterlockedDecrement(IRP_REFCOUNT(Irp)) <= 0) + TunCompleteRequest(Ctx, Irp, STATUS_SUCCESS, IO_NETWORK_INCREMENT); } - InterlockedAdd64((LONG64 *)&ctx->Statistics.ifHCInOctets, stat_size); - InterlockedAdd64((LONG64 *)&ctx->Statistics.ifHCInUcastOctets, stat_size); - InterlockedAdd64((LONG64 *)&ctx->Statistics.ifHCInUcastPkts, stat_p_ok); - InterlockedAdd64((LONG64 *)&ctx->Statistics.ifInErrors, stat_p_err); + InterlockedAdd64((LONG64 *)&Ctx->Statistics.ifHCInOctets, StatSize); + InterlockedAdd64((LONG64 *)&Ctx->Statistics.ifHCInUcastOctets, StatSize); + InterlockedAdd64((LONG64 *)&Ctx->Statistics.ifHCInUcastPkts, StatPacketsOk); + InterlockedAdd64((LONG64 *)&Ctx->Statistics.ifInErrors, StatPacketsError); } _IRQL_requires_max_(APC_LEVEL) @@ -949,59 +950,59 @@ _Must_inspect_result_ static NTSTATUS TunDispatchCreate(_Inout_ TUN_CTX *Ctx, _Inout_ IRP *Irp) { - NTSTATUS status; - TUN_FILE_CTX *file_ctx = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(*file_ctx), TUN_HTONL(TUN_MEMORY_TAG)); - if (!file_ctx) + NTSTATUS Status; + TUN_FILE_CTX *FileCtx = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(*FileCtx), TUN_HTONL(TUN_MEMORY_TAG)); + if (!FileCtx) return STATUS_INSUFFICIENT_RESOURCES; - RtlZeroMemory(file_ctx, sizeof(*file_ctx)); - ExInitializeFastMutex(&file_ctx->ReadBuffer.InitializationComplete); - ExInitializeFastMutex(&file_ctx->WriteBuffer.InitializationComplete); + RtlZeroMemory(FileCtx, sizeof(*FileCtx)); + ExInitializeFastMutex(&FileCtx->ReadBuffer.InitializationComplete); + ExInitializeFastMutex(&FileCtx->WriteBuffer.InitializationComplete); - KIRQL irql = ExAcquireSpinLockShared(&Ctx->TransitionLock); - LONG flags = InterlockedGet(&Ctx->Flags); - if ((status = STATUS_DELETE_PENDING, !(flags & TUN_FLAGS_PRESENT))) + KIRQL Irql = ExAcquireSpinLockShared(&Ctx->TransitionLock); + LONG Flags = InterlockedGet(&Ctx->Flags); + if ((Status = STATUS_DELETE_PENDING, !(Flags & TUN_FLAGS_PRESENT))) goto cleanup_ExReleaseSpinLockShared; - IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(Irp); - if (!NT_SUCCESS(status = IoAcquireRemoveLock(&Ctx->Device.RemoveLock, stack->FileObject))) + IO_STACK_LOCATION *Stack = IoGetCurrentIrpStackLocation(Irp); + if (!NT_SUCCESS(Status = IoAcquireRemoveLock(&Ctx->Device.RemoveLock, Stack->FileObject))) goto cleanup_ExReleaseSpinLockShared; - stack->FileObject->FsContext = file_ctx; + Stack->FileObject->FsContext = FileCtx; if (InterlockedIncrement64(&Ctx->Device.RefCount) == 1) TunIndicateStatus(Ctx->MiniportAdapterHandle, MediaConnectStateConnected); - status = STATUS_SUCCESS; + Status = STATUS_SUCCESS; cleanup_ExReleaseSpinLockShared: - ExReleaseSpinLockShared(&Ctx->TransitionLock, irql); - TunCompleteRequest(Ctx, Irp, status, IO_NO_INCREMENT); - if (!NT_SUCCESS(status)) - ExFreePoolWithTag(file_ctx, TUN_HTONL(TUN_MEMORY_TAG)); - return status; + ExReleaseSpinLockShared(&Ctx->TransitionLock, Irql); + TunCompleteRequest(Ctx, Irp, Status, IO_NO_INCREMENT); + if (!NT_SUCCESS(Status)) + ExFreePoolWithTag(FileCtx, TUN_HTONL(TUN_MEMORY_TAG)); + return Status; } _IRQL_requires_max_(DISPATCH_LEVEL) static void TunDispatchClose(_Inout_ TUN_CTX *Ctx, _Inout_ IRP *Irp) { - IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(Irp); + IO_STACK_LOCATION *Stack = IoGetCurrentIrpStackLocation(Irp); ASSERT(InterlockedGet64(&Ctx->Device.RefCount) > 0); - BOOLEAN last_handle = InterlockedDecrement64(&Ctx->Device.RefCount) <= 0; + BOOLEAN IsLastFileHandle = InterlockedDecrement64(&Ctx->Device.RefCount) <= 0; ExReleaseSpinLockExclusive( &Ctx->TransitionLock, ExAcquireSpinLockExclusive(&Ctx->TransitionLock)); /* Ensure above change is visible to all readers. */ - if (last_handle) + if (IsLastFileHandle) { - NDIS_HANDLE handle = InterlockedGetPointer(&Ctx->MiniportAdapterHandle); - if (handle) - TunIndicateStatus(handle, MediaConnectStateDisconnected); + NDIS_HANDLE AdapterHandle = InterlockedGetPointer(&Ctx->MiniportAdapterHandle); + if (AdapterHandle) + TunIndicateStatus(AdapterHandle, MediaConnectStateDisconnected); TunQueueClear(Ctx, NDIS_STATUS_MEDIA_DISCONNECTED); } - TUN_FILE_CTX *file_ctx = (TUN_FILE_CTX *)stack->FileObject->FsContext; - TunUnmapUbuffer(&file_ctx->ReadBuffer); - TunUnmapUbuffer(&file_ctx->WriteBuffer); - ExFreePoolWithTag(file_ctx, TUN_HTONL(TUN_MEMORY_TAG)); - IoReleaseRemoveLock(&Ctx->Device.RemoveLock, stack->FileObject); + TUN_FILE_CTX *FileCtx = (TUN_FILE_CTX *)Stack->FileObject->FsContext; + TunUnmapUbuffer(&FileCtx->ReadBuffer); + TunUnmapUbuffer(&FileCtx->WriteBuffer); + ExFreePoolWithTag(FileCtx, TUN_HTONL(TUN_MEMORY_TAG)); + IoReleaseRemoveLock(&Ctx->Device.RemoveLock, Stack->FileObject); } static DRIVER_DISPATCH TunDispatch; @@ -1009,53 +1010,52 @@ _Use_decl_annotations_ static NTSTATUS TunDispatch(DEVICE_OBJECT *DeviceObject, IRP *Irp) { - NTSTATUS status = STATUS_SUCCESS; + NTSTATUS Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; - TUN_CTX *ctx = NdisGetDeviceReservedExtension(DeviceObject); - if (!ctx) + TUN_CTX *Ctx = NdisGetDeviceReservedExtension(DeviceObject); + if (!Ctx) { - status = STATUS_INVALID_HANDLE; + Status = STATUS_INVALID_HANDLE; goto cleanup_complete_req; } - IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(Irp); - switch (stack->MajorFunction) + IO_STACK_LOCATION *Stack = IoGetCurrentIrpStackLocation(Irp); + switch (Stack->MajorFunction) { case IRP_MJ_READ: - if (!NT_SUCCESS(status = IoAcquireRemoveLock(&ctx->Device.RemoveLock, Irp))) + if (!NT_SUCCESS(Status = IoAcquireRemoveLock(&Ctx->Device.RemoveLock, Irp))) goto cleanup_complete_req; - return TunDispatchRead(ctx, Irp); + return TunDispatchRead(Ctx, Irp); case IRP_MJ_WRITE: - if (!NT_SUCCESS(status = IoAcquireRemoveLock(&ctx->Device.RemoveLock, Irp))) + if (!NT_SUCCESS(Status = IoAcquireRemoveLock(&Ctx->Device.RemoveLock, Irp))) goto cleanup_complete_req; - return TunDispatchWrite(ctx, Irp); + return TunDispatchWrite(Ctx, Irp); case IRP_MJ_CREATE: - if (!NT_SUCCESS(status = IoAcquireRemoveLock(&ctx->Device.RemoveLock, Irp))) + if (!NT_SUCCESS(Status = IoAcquireRemoveLock(&Ctx->Device.RemoveLock, Irp))) goto cleanup_complete_req; - return TunDispatchCreate(ctx, Irp); + return TunDispatchCreate(Ctx, Irp); case IRP_MJ_CLOSE: - TunDispatchClose(ctx, Irp); + TunDispatchClose(Ctx, Irp); break; case IRP_MJ_CLEANUP: - for (IRP *pending_irp; - (pending_irp = IoCsqRemoveNextIrp(&ctx->Device.ReadQueue.Csq, stack->FileObject)) != NULL;) - TunCompleteRequest(ctx, pending_irp, STATUS_CANCELLED, IO_NO_INCREMENT); + for (IRP *PendingIrp; (PendingIrp = IoCsqRemoveNextIrp(&Ctx->Device.ReadQueue.Csq, Stack->FileObject)) != NULL;) + TunCompleteRequest(Ctx, PendingIrp, STATUS_CANCELLED, IO_NO_INCREMENT); break; default: - status = STATUS_INVALID_PARAMETER; + Status = STATUS_INVALID_PARAMETER; break; } cleanup_complete_req: - Irp->IoStatus.Status = status; + Irp->IoStatus.Status = Status; IoCompleteRequest(Irp, IO_NO_INCREMENT); - return status; + return Status; } _Dispatch_type_(IRP_MJ_PNP) static DRIVER_DISPATCH TunDispatchPnP; @@ -1063,28 +1063,28 @@ _Use_decl_annotations_ static NTSTATUS TunDispatchPnP(DEVICE_OBJECT *DeviceObject, IRP *Irp) { - IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(Irp); - if (stack->MajorFunction == IRP_MJ_PNP) + IO_STACK_LOCATION *Stack = IoGetCurrentIrpStackLocation(Irp); + if (Stack->MajorFunction == IRP_MJ_PNP) { #pragma warning(suppress : 28175) - TUN_CTX *ctx = DeviceObject->Reserved; - if (!ctx) + TUN_CTX *Ctx = DeviceObject->Reserved; + if (!Ctx) return NdisDispatchPnP(DeviceObject, Irp); - switch (stack->MinorFunction) + switch (Stack->MinorFunction) { case IRP_MN_QUERY_REMOVE_DEVICE: case IRP_MN_SURPRISE_REMOVAL: { - InterlockedAnd(&ctx->Flags, ~TUN_FLAGS_PRESENT); + InterlockedAnd(&Ctx->Flags, ~TUN_FLAGS_PRESENT); ExReleaseSpinLockExclusive( - &ctx->TransitionLock, - ExAcquireSpinLockExclusive(&ctx->TransitionLock)); /* Ensure above change is visible to all readers. */ - TunQueueClear(ctx, NDIS_STATUS_ADAPTER_REMOVED); + &Ctx->TransitionLock, + ExAcquireSpinLockExclusive(&Ctx->TransitionLock)); /* Ensure above change is visible to all readers. */ + TunQueueClear(Ctx, NDIS_STATUS_ADAPTER_REMOVED); break; } case IRP_MN_CANCEL_REMOVE_DEVICE: - InterlockedOr(&ctx->Flags, TUN_FLAGS_PRESENT); + InterlockedOr(&Ctx->Flags, TUN_FLAGS_PRESENT); break; } } @@ -1097,10 +1097,10 @@ _Use_decl_annotations_ static NDIS_STATUS TunRestart(NDIS_HANDLE MiniportAdapterContext, PNDIS_MINIPORT_RESTART_PARAMETERS MiniportRestartParameters) { - TUN_CTX *ctx = (TUN_CTX *)MiniportAdapterContext; + TUN_CTX *Ctx = (TUN_CTX *)MiniportAdapterContext; - InterlockedExchange64(&ctx->ActiveNBLCount, 1); - InterlockedOr(&ctx->Flags, TUN_FLAGS_RUNNING); + InterlockedExchange64(&Ctx->ActiveNBLCount, 1); + InterlockedOr(&Ctx->Flags, TUN_FLAGS_RUNNING); return NDIS_STATUS_SUCCESS; } @@ -1110,15 +1110,15 @@ _Use_decl_annotations_ static NDIS_STATUS TunPause(NDIS_HANDLE MiniportAdapterContext, PNDIS_MINIPORT_PAUSE_PARAMETERS MiniportPauseParameters) { - TUN_CTX *ctx = (TUN_CTX *)MiniportAdapterContext; + TUN_CTX *Ctx = (TUN_CTX *)MiniportAdapterContext; - InterlockedAnd(&ctx->Flags, ~TUN_FLAGS_RUNNING); + InterlockedAnd(&Ctx->Flags, ~TUN_FLAGS_RUNNING); ExReleaseSpinLockExclusive( - &ctx->TransitionLock, - ExAcquireSpinLockExclusive(&ctx->TransitionLock)); /* Ensure above change is visible to all readers. */ - TunQueueClear(ctx, NDIS_STATUS_PAUSED); + &Ctx->TransitionLock, + ExAcquireSpinLockExclusive(&Ctx->TransitionLock)); /* Ensure above change is visible to all readers. */ + TunQueueClear(Ctx, NDIS_STATUS_PAUSED); - return TunCompletePause(ctx, FALSE); + return TunCompletePause(Ctx, FALSE); } static MINIPORT_DEVICE_PNP_EVENT_NOTIFY TunDevicePnPEventNotify; @@ -1136,28 +1136,28 @@ TunInitializeEx( NDIS_HANDLE MiniportDriverContext, PNDIS_MINIPORT_INIT_PARAMETERS MiniportInitParameters) { - NDIS_STATUS status; + NDIS_STATUS Status; if (!MiniportAdapterHandle) return NDIS_STATUS_FAILURE; /* Register device first. Having only one device per adapter allows us to store * adapter context inside device extension. */ - WCHAR device_name[sizeof(L"\\Device\\" TUN_DEVICE_NAME "4294967295") / sizeof(WCHAR) + 1] = { 0 }; - UNICODE_STRING unicode_device_name; - TunInitUnicodeString(&unicode_device_name, device_name); + WCHAR DeviceName[sizeof(L"\\Device\\" TUN_DEVICE_NAME "4294967295") / sizeof(WCHAR) + 1] = { 0 }; + UNICODE_STRING UnicodeDeviceName; + TunInitUnicodeString(&UnicodeDeviceName, DeviceName); RtlUnicodeStringPrintf( - &unicode_device_name, L"\\Device\\" TUN_DEVICE_NAME, (ULONG)MiniportInitParameters->NetLuid.Info.NetLuidIndex); + &UnicodeDeviceName, L"\\Device\\" TUN_DEVICE_NAME, (ULONG)MiniportInitParameters->NetLuid.Info.NetLuidIndex); - WCHAR symbolic_name[sizeof(L"\\DosDevices\\" TUN_DEVICE_NAME "4294967295") / sizeof(WCHAR) + 1] = { 0 }; - UNICODE_STRING unicode_symbolic_name; - TunInitUnicodeString(&unicode_symbolic_name, symbolic_name); + WCHAR SymbolicName[sizeof(L"\\DosDevices\\" TUN_DEVICE_NAME "4294967295") / sizeof(WCHAR) + 1] = { 0 }; + UNICODE_STRING UnicodeSymbolicName; + TunInitUnicodeString(&UnicodeSymbolicName, SymbolicName); RtlUnicodeStringPrintf( - &unicode_symbolic_name, + &UnicodeSymbolicName, L"\\DosDevices\\" TUN_DEVICE_NAME, (ULONG)MiniportInitParameters->NetLuid.Info.NetLuidIndex); - static PDRIVER_DISPATCH dispatch_table[IRP_MJ_MAXIMUM_FUNCTION + 1] = { + static PDRIVER_DISPATCH DispatchTable[IRP_MJ_MAXIMUM_FUNCTION + 1] = { TunDispatch, /* IRP_MJ_CREATE */ NULL, /* IRP_MJ_CREATE_NAMED_PIPE */ TunDispatch, /* IRP_MJ_CLOSE */ @@ -1178,31 +1178,33 @@ TunInitializeEx( NULL, /* IRP_MJ_LOCK_CONTROL */ TunDispatch, /* IRP_MJ_CLEANUP */ }; - NDIS_DEVICE_OBJECT_ATTRIBUTES t = { + NDIS_DEVICE_OBJECT_ATTRIBUTES DeviceObjectAttributes = { .Header = { .Type = NDIS_OBJECT_TYPE_DEVICE_OBJECT_ATTRIBUTES, .Revision = NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1, .Size = NDIS_SIZEOF_DEVICE_OBJECT_ATTRIBUTES_REVISION_1 }, - .DeviceName = &unicode_device_name, - .SymbolicName = &unicode_symbolic_name, - .MajorFunctions = dispatch_table, + .DeviceName = &UnicodeDeviceName, + .SymbolicName = &UnicodeSymbolicName, + .MajorFunctions = DispatchTable, .ExtensionSize = sizeof(TUN_CTX), .DefaultSDDLString = &SDDL_DEVOBJ_SYS_ALL /* Kernel, and SYSTEM: full control. Others: none */ }; - NDIS_HANDLE handle; - DEVICE_OBJECT *object; - if (!NT_SUCCESS(status = NdisRegisterDeviceEx(NdisMiniportDriverHandle, &t, &object, &handle))) + NDIS_HANDLE DeviceObjectHandle; + DEVICE_OBJECT *DeviceObject; + if (!NT_SUCCESS( + Status = NdisRegisterDeviceEx( + NdisMiniportDriverHandle, &DeviceObjectAttributes, &DeviceObject, &DeviceObjectHandle))) return NDIS_STATUS_FAILURE; - object->Flags &= ~(DO_BUFFERED_IO | DO_DIRECT_IO); + DeviceObject->Flags &= ~(DO_BUFFERED_IO | DO_DIRECT_IO); - TUN_CTX *ctx = NdisGetDeviceReservedExtension(object); - if (!ctx) + TUN_CTX *Ctx = NdisGetDeviceReservedExtension(DeviceObject); + if (!Ctx) { - status = NDIS_STATUS_FAILURE; + Status = NDIS_STATUS_FAILURE; goto cleanup_NdisDeregisterDeviceEx; } - DEVICE_OBJECT *functional_device; - NdisMGetDeviceProperty(MiniportAdapterHandle, NULL, &functional_device, NULL, NULL, NULL); + DEVICE_OBJECT *FunctionalDeviceObject; + NdisMGetDeviceProperty(MiniportAdapterHandle, NULL, &FunctionalDeviceObject, NULL, NULL, NULL); /* Reverse engineering indicates that we'd be better off calling * NdisWdfGetAdapterContextFromAdapterHandle(functional_device), @@ -1211,17 +1213,17 @@ TunInitializeEx( * this reserved field. Revisit this when we drop support for old * Windows versions. */ #pragma warning(suppress : 28175) - ASSERT(!functional_device->Reserved); + ASSERT(!FunctionalDeviceObject->Reserved); #pragma warning(suppress : 28175) - functional_device->Reserved = ctx; + FunctionalDeviceObject->Reserved = Ctx; - NdisZeroMemory(ctx, sizeof(*ctx)); - ctx->MiniportAdapterHandle = MiniportAdapterHandle; + NdisZeroMemory(Ctx, sizeof(*Ctx)); + Ctx->MiniportAdapterHandle = MiniportAdapterHandle; - ctx->Statistics.Header.Type = NDIS_OBJECT_TYPE_DEFAULT; - ctx->Statistics.Header.Revision = NDIS_STATISTICS_INFO_REVISION_1; - ctx->Statistics.Header.Size = NDIS_SIZEOF_STATISTICS_INFO_REVISION_1; - ctx->Statistics.SupportedStatistics = + Ctx->Statistics.Header.Type = NDIS_OBJECT_TYPE_DEFAULT; + Ctx->Statistics.Header.Revision = NDIS_STATISTICS_INFO_REVISION_1; + Ctx->Statistics.Header.Size = NDIS_SIZEOF_STATISTICS_INFO_REVISION_1; + Ctx->Statistics.SupportedStatistics = NDIS_STATISTICS_FLAGS_VALID_DIRECTED_FRAMES_RCV | NDIS_STATISTICS_FLAGS_VALID_MULTICAST_FRAMES_RCV | NDIS_STATISTICS_FLAGS_VALID_BROADCAST_FRAMES_RCV | NDIS_STATISTICS_FLAGS_VALID_BYTES_RCV | NDIS_STATISTICS_FLAGS_VALID_RCV_DISCARDS | NDIS_STATISTICS_FLAGS_VALID_RCV_ERROR | @@ -1232,23 +1234,23 @@ TunInitializeEx( NDIS_STATISTICS_FLAGS_VALID_BROADCAST_BYTES_RCV | NDIS_STATISTICS_FLAGS_VALID_DIRECTED_BYTES_XMIT | NDIS_STATISTICS_FLAGS_VALID_MULTICAST_BYTES_XMIT | NDIS_STATISTICS_FLAGS_VALID_BROADCAST_BYTES_XMIT; - ctx->Device.Handle = handle; - ctx->Device.Object = object; - IoInitializeRemoveLock(&ctx->Device.RemoveLock, TUN_HTONL(TUN_MEMORY_TAG), 0, 0); - KeInitializeSpinLock(&ctx->Device.ReadQueue.Lock); + Ctx->Device.Handle = DeviceObjectHandle; + Ctx->Device.Object = DeviceObject; + IoInitializeRemoveLock(&Ctx->Device.RemoveLock, TUN_HTONL(TUN_MEMORY_TAG), 0, 0); + KeInitializeSpinLock(&Ctx->Device.ReadQueue.Lock); IoCsqInitializeEx( - &ctx->Device.ReadQueue.Csq, + &Ctx->Device.ReadQueue.Csq, TunCsqInsertIrpEx, TunCsqRemoveIrp, TunCsqPeekNextIrp, TunCsqAcquireLock, TunCsqReleaseLock, TunCsqCompleteCanceledIrp); - InitializeListHead(&ctx->Device.ReadQueue.List); + InitializeListHead(&Ctx->Device.ReadQueue.List); - KeInitializeSpinLock(&ctx->PacketQueue.Lock); + KeInitializeSpinLock(&Ctx->PacketQueue.Lock); - NET_BUFFER_LIST_POOL_PARAMETERS nbl_pool_param = { + NET_BUFFER_LIST_POOL_PARAMETERS NblPoolParameters = { .Header = { .Type = NDIS_OBJECT_TYPE_DEFAULT, .Revision = NET_BUFFER_LIST_POOL_PARAMETERS_REVISION_1, .Size = NDIS_SIZEOF_NET_BUFFER_LIST_POOL_PARAMETERS_REVISION_1 }, @@ -1258,14 +1260,14 @@ TunInitializeEx( }; #pragma warning( \ suppress : 6014) /* Leaking memory 'ctx->NBLPool'. Note: 'ctx->NBLPool' is freed in TunHaltEx; or on failure. */ - ctx->NBLPool = NdisAllocateNetBufferListPool(MiniportAdapterHandle, &nbl_pool_param); - if (!ctx->NBLPool) + Ctx->NBLPool = NdisAllocateNetBufferListPool(MiniportAdapterHandle, &NblPoolParameters); + if (!Ctx->NBLPool) { - status = NDIS_STATUS_FAILURE; + Status = NDIS_STATUS_FAILURE; goto cleanup_NdisDeregisterDeviceEx; } - NDIS_MINIPORT_ADAPTER_REGISTRATION_ATTRIBUTES attr = { + NDIS_MINIPORT_ADAPTER_REGISTRATION_ATTRIBUTES AdapterRegistrationAttributes = { .Header = { .Type = NDIS_OBJECT_TYPE_MINIPORT_ADAPTER_REGISTRATION_ATTRIBUTES, .Revision = NdisVersion < NDIS_RUNTIME_VERSION_630 ? NDIS_MINIPORT_ADAPTER_REGISTRATION_ATTRIBUTES_REVISION_1 @@ -1275,16 +1277,17 @@ TunInitializeEx( : NDIS_SIZEOF_MINIPORT_ADAPTER_REGISTRATION_ATTRIBUTES_REVISION_2 }, .AttributeFlags = NDIS_MINIPORT_ATTRIBUTES_NO_HALT_ON_SUSPEND | NDIS_MINIPORT_ATTRIBUTES_SURPRISE_REMOVE_OK, .InterfaceType = NdisInterfaceInternal, - .MiniportAdapterContext = ctx + .MiniportAdapterContext = Ctx }; if (!NT_SUCCESS( - status = NdisMSetMiniportAttributes(MiniportAdapterHandle, (PNDIS_MINIPORT_ADAPTER_ATTRIBUTES)&attr))) + Status = NdisMSetMiniportAttributes( + MiniportAdapterHandle, (PNDIS_MINIPORT_ADAPTER_ATTRIBUTES)&AdapterRegistrationAttributes))) { - status = NDIS_STATUS_FAILURE; + Status = NDIS_STATUS_FAILURE; goto cleanup_NdisFreeNetBufferListPool; } - NDIS_PM_CAPABILITIES pmcap = { + NDIS_PM_CAPABILITIES PmCapabilities = { .Header = { .Type = NDIS_OBJECT_TYPE_DEFAULT, .Revision = NdisVersion < NDIS_RUNTIME_VERSION_630 ? NDIS_PM_CAPABILITIES_REVISION_1 : NDIS_PM_CAPABILITIES_REVISION_2, @@ -1294,7 +1297,7 @@ TunInitializeEx( .MinPatternWakeUp = NdisDeviceStateUnspecified, .MinLinkChangeWakeUp = NdisDeviceStateUnspecified }; - static NDIS_OID suported_oids[] = { OID_GEN_MAXIMUM_TOTAL_SIZE, + static NDIS_OID SupportedOids[] = { OID_GEN_MAXIMUM_TOTAL_SIZE, OID_GEN_CURRENT_LOOKAHEAD, OID_GEN_TRANSMIT_BUFFER_SPACE, OID_GEN_RECEIVE_BUFFER_SPACE, @@ -1311,7 +1314,7 @@ TunInitializeEx( OID_GEN_LINK_PARAMETERS, OID_PNP_SET_POWER, OID_PNP_QUERY_POWER }; - NDIS_MINIPORT_ADAPTER_GENERAL_ATTRIBUTES gen = { + NDIS_MINIPORT_ADAPTER_GENERAL_ATTRIBUTES AdapterGeneralAttributes = { .Header = { .Type = NDIS_OBJECT_TYPE_MINIPORT_ADAPTER_GENERAL_ATTRIBUTES, .Revision = NDIS_MINIPORT_ADAPTER_GENERAL_ATTRIBUTES_REVISION_2, .Size = NDIS_SIZEOF_MINIPORT_ADAPTER_GENERAL_ATTRIBUTES_REVISION_2 }, @@ -1334,19 +1337,20 @@ TunInitializeEx( .ConnectionType = NET_IF_CONNECTION_DEDICATED, .IfType = IF_TYPE_PROP_VIRTUAL, .IfConnectorPresent = FALSE, - .SupportedStatistics = ctx->Statistics.SupportedStatistics, + .SupportedStatistics = Ctx->Statistics.SupportedStatistics, .SupportedPauseFunctions = NdisPauseFunctionsUnsupported, .AutoNegotiationFlags = NDIS_LINK_STATE_XMIT_LINK_SPEED_AUTO_NEGOTIATED | NDIS_LINK_STATE_RCV_LINK_SPEED_AUTO_NEGOTIATED | NDIS_LINK_STATE_DUPLEX_AUTO_NEGOTIATED | NDIS_LINK_STATE_PAUSE_FUNCTIONS_AUTO_NEGOTIATED, - .SupportedOidList = suported_oids, - .SupportedOidListLength = sizeof(suported_oids), - .PowerManagementCapabilitiesEx = &pmcap + .SupportedOidList = SupportedOids, + .SupportedOidListLength = sizeof(SupportedOids), + .PowerManagementCapabilitiesEx = &PmCapabilities }; if (!NT_SUCCESS( - status = NdisMSetMiniportAttributes(MiniportAdapterHandle, (PNDIS_MINIPORT_ADAPTER_ATTRIBUTES)&gen))) + Status = NdisMSetMiniportAttributes( + MiniportAdapterHandle, (PNDIS_MINIPORT_ADAPTER_ATTRIBUTES)&AdapterGeneralAttributes))) { - status = NDIS_STATUS_FAILURE; + Status = NDIS_STATUS_FAILURE; goto cleanup_NdisFreeNetBufferListPool; } @@ -1355,100 +1359,102 @@ TunInitializeEx( * of the MiniportInitializeEx function. */ TunIndicateStatus(MiniportAdapterHandle, MediaConnectStateDisconnected); InterlockedIncrement64(&TunAdapterCount); - InterlockedOr(&ctx->Flags, TUN_FLAGS_PRESENT); + InterlockedOr(&Ctx->Flags, TUN_FLAGS_PRESENT); return NDIS_STATUS_SUCCESS; cleanup_NdisFreeNetBufferListPool: - NdisFreeNetBufferListPool(ctx->NBLPool); + NdisFreeNetBufferListPool(Ctx->NBLPool); cleanup_NdisDeregisterDeviceEx: - NdisDeregisterDeviceEx(handle); - return status; + NdisDeregisterDeviceEx(DeviceObjectHandle); + return Status; } _IRQL_requires_max_(PASSIVE_LEVEL) static NTSTATUS TunDeviceSetDenyAllDacl(_In_ DEVICE_OBJECT *DeviceObject) { - NTSTATUS status; - SECURITY_DESCRIPTOR sd; - ACL acl; - HANDLE handle; - - if (!NT_SUCCESS(status = RtlCreateSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION))) - return status; - if (!NT_SUCCESS(status = RtlCreateAcl(&acl, sizeof(ACL), ACL_REVISION))) - return status; - if (!NT_SUCCESS(status = RtlSetDaclSecurityDescriptor(&sd, TRUE, &acl, FALSE))) - return status; - status = ObOpenObjectByPointer( - DeviceObject, OBJ_KERNEL_HANDLE, NULL, WRITE_DAC, *IoDeviceObjectType, KernelMode, &handle); - if (!NT_SUCCESS(status)) - return status; - - status = ZwSetSecurityObject(handle, DACL_SECURITY_INFORMATION, &sd); - - ZwClose(handle); - return status; + NTSTATUS Status; + SECURITY_DESCRIPTOR Sd; + ACL Acl; + HANDLE DeviceObjectHandle; + + if (!NT_SUCCESS(Status = RtlCreateSecurityDescriptor(&Sd, SECURITY_DESCRIPTOR_REVISION))) + return Status; + if (!NT_SUCCESS(Status = RtlCreateAcl(&Acl, sizeof(ACL), ACL_REVISION))) + return Status; + if (!NT_SUCCESS(Status = RtlSetDaclSecurityDescriptor(&Sd, TRUE, &Acl, FALSE))) + return Status; + Status = ObOpenObjectByPointer( + DeviceObject, OBJ_KERNEL_HANDLE, NULL, WRITE_DAC, *IoDeviceObjectType, KernelMode, &DeviceObjectHandle); + if (!NT_SUCCESS(Status)) + return Status; + + Status = ZwSetSecurityObject(DeviceObjectHandle, DACL_SECURITY_INFORMATION, &Sd); + + ZwClose(DeviceObjectHandle); + return Status; } _IRQL_requires_max_(PASSIVE_LEVEL) static void TunForceHandlesClosed(_Inout_ TUN_CTX *Ctx) { - NTSTATUS status; - PEPROCESS process; - KAPC_STATE apc_state; - PVOID object = NULL; - ULONG verifier_flags = 0; - OBJECT_HANDLE_INFORMATION handle_info; - SYSTEM_HANDLE_INFORMATION_EX *table = NULL; - - MmIsVerifierEnabled(&verifier_flags); - - for (ULONG size = 0, req; (status = ZwQuerySystemInformation(SystemExtendedHandleInformation, table, size, &req)) == - STATUS_INFO_LENGTH_MISMATCH; - size = req) + NTSTATUS Status; + PEPROCESS Process; + KAPC_STATE ApcState; + PVOID Object = NULL; + ULONG VerifierFlags = 0; + OBJECT_HANDLE_INFORMATION HandleInfo; + SYSTEM_HANDLE_INFORMATION_EX *HandleTable = NULL; + + MmIsVerifierEnabled(&VerifierFlags); + + for (ULONG Size = 0, RequestedSize; + (Status = ZwQuerySystemInformation(SystemExtendedHandleInformation, HandleTable, Size, &RequestedSize)) == + STATUS_INFO_LENGTH_MISMATCH; + Size = RequestedSize) { - if (table) - ExFreePoolWithTag(table, TUN_HTONL(TUN_MEMORY_TAG)); - table = ExAllocatePoolWithTag(PagedPool, req, TUN_HTONL(TUN_MEMORY_TAG)); - if (!table) + if (HandleTable) + ExFreePoolWithTag(HandleTable, TUN_HTONL(TUN_MEMORY_TAG)); + HandleTable = ExAllocatePoolWithTag(PagedPool, RequestedSize, TUN_HTONL(TUN_MEMORY_TAG)); + if (!HandleTable) return; } - if (!NT_SUCCESS(status) || !table) + if (!NT_SUCCESS(Status) || !HandleTable) goto out; - for (ULONG_PTR i = 0; i < table->NumberOfHandles; ++i) + for (ULONG_PTR Index = 0; Index < HandleTable->NumberOfHandles; ++Index) { /* XXX: We should perhaps first look at table->Handles[i].ObjectTypeIndex, but * the value changes lots between NT versions, and it should be implicit anyway. */ - FILE_OBJECT *file = table->Handles[i].Object; - if (!file || file->Type != 5 || file->DeviceObject != Ctx->Device.Object) + FILE_OBJECT *FileObject = HandleTable->Handles[Index].Object; + if (!FileObject || FileObject->Type != 5 || FileObject->DeviceObject != Ctx->Device.Object) continue; - status = PsLookupProcessByProcessId(table->Handles[i].UniqueProcessId, &process); - if (!NT_SUCCESS(status)) + Status = PsLookupProcessByProcessId(HandleTable->Handles[Index].UniqueProcessId, &Process); + if (!NT_SUCCESS(Status)) continue; - KeStackAttachProcess(process, &apc_state); - if (!verifier_flags) - status = ObReferenceObjectByHandle(table->Handles[i].HandleValue, 0, NULL, UserMode, &object, &handle_info); - if (NT_SUCCESS(status)) + KeStackAttachProcess(Process, &ApcState); + if (!VerifierFlags) + Status = ObReferenceObjectByHandle( + HandleTable->Handles[Index].HandleValue, 0, NULL, UserMode, &Object, &HandleInfo); + if (NT_SUCCESS(Status)) { - if (verifier_flags || object == file) - ObCloseHandle(table->Handles[i].HandleValue, UserMode); - if (!verifier_flags) - ObfDereferenceObject(object); + if (VerifierFlags || Object == FileObject) + ObCloseHandle(HandleTable->Handles[Index].HandleValue, UserMode); + if (!VerifierFlags) + ObfDereferenceObject(Object); } - KeUnstackDetachProcess(&apc_state); - ObfDereferenceObject(process); + KeUnstackDetachProcess(&ApcState); + ObfDereferenceObject(Process); } out: - if (table) - ExFreePoolWithTag(table, TUN_HTONL(TUN_MEMORY_TAG)); + if (HandleTable) + ExFreePoolWithTag(HandleTable, TUN_HTONL(TUN_MEMORY_TAG)); } _IRQL_requires_max_(APC_LEVEL) static void -TunWaitForReferencesToDropToZero(_In_ DEVICE_OBJECT *device_object) +TunWaitForReferencesToDropToZero(_In_ DEVICE_OBJECT *DeviceObject) { /* The sleep loop isn't pretty, but we don't have a choice. This is an NDIS bug we're working around. */ enum @@ -1458,7 +1464,7 @@ TunWaitForReferencesToDropToZero(_In_ DEVICE_OBJECT *device_object) MaxTries = TotalTime / SleepTime }; #pragma warning(suppress : 28175) - for (int i = 0; i < MaxTries && device_object->ReferenceCount; ++i) + for (int Try = 0; Try < MaxTries && DeviceObject->ReferenceCount; ++Try) NdisMSleep(SleepTime); } @@ -1467,39 +1473,39 @@ _Use_decl_annotations_ static void TunHaltEx(NDIS_HANDLE MiniportAdapterContext, NDIS_HALT_ACTION HaltAction) { - TUN_CTX *ctx = (TUN_CTX *)MiniportAdapterContext; + TUN_CTX *Ctx = (TUN_CTX *)MiniportAdapterContext; - ASSERT(!InterlockedGet64(&ctx->ActiveNBLCount)); /* Adapter should not be halted if there are (potential) + ASSERT(!InterlockedGet64(&Ctx->ActiveNBLCount)); /* Adapter should not be halted if there are (potential) * active NBLs present. */ - InterlockedAnd(&ctx->Flags, ~TUN_FLAGS_PRESENT); + InterlockedAnd(&Ctx->Flags, ~TUN_FLAGS_PRESENT); ExReleaseSpinLockExclusive( - &ctx->TransitionLock, - ExAcquireSpinLockExclusive(&ctx->TransitionLock)); /* Ensure above change is visible to all readers. */ + &Ctx->TransitionLock, + ExAcquireSpinLockExclusive(&Ctx->TransitionLock)); /* Ensure above change is visible to all readers. */ - for (IRP *pending_irp; (pending_irp = IoCsqRemoveNextIrp(&ctx->Device.ReadQueue.Csq, NULL)) != NULL;) - TunCompleteRequest(ctx, pending_irp, STATUS_FILE_FORCED_CLOSED, IO_NO_INCREMENT); + for (IRP *PendingIrp; (PendingIrp = IoCsqRemoveNextIrp(&Ctx->Device.ReadQueue.Csq, NULL)) != NULL;) + TunCompleteRequest(Ctx, PendingIrp, STATUS_FILE_FORCED_CLOSED, IO_NO_INCREMENT); /* Setting a deny-all DACL we prevent userspace to open the device by symlink after TunForceHandlesClosed(). */ - TunDeviceSetDenyAllDacl(ctx->Device.Object); + TunDeviceSetDenyAllDacl(Ctx->Device.Object); - if (InterlockedGet64(&ctx->Device.RefCount)) - TunForceHandlesClosed(ctx); + if (InterlockedGet64(&Ctx->Device.RefCount)) + TunForceHandlesClosed(Ctx); /* Wait for processing IRP(s) to complete. */ - IoAcquireRemoveLock(&ctx->Device.RemoveLock, NULL); - IoReleaseRemoveLockAndWait(&ctx->Device.RemoveLock, NULL); - NdisFreeNetBufferListPool(ctx->NBLPool); + IoAcquireRemoveLock(&Ctx->Device.RemoveLock, NULL); + IoReleaseRemoveLockAndWait(&Ctx->Device.RemoveLock, NULL); + NdisFreeNetBufferListPool(Ctx->NBLPool); /* MiniportAdapterHandle must not be used in TunDispatch(). After TunHaltEx() returns it is invalidated. */ - InterlockedExchangePointer(&ctx->MiniportAdapterHandle, NULL); + InterlockedExchangePointer(&Ctx->MiniportAdapterHandle, NULL); ASSERT(InterlockedGet64(&TunAdapterCount) > 0); if (InterlockedDecrement64(&TunAdapterCount) <= 0) - TunWaitForReferencesToDropToZero(ctx->Device.Object); + TunWaitForReferencesToDropToZero(Ctx->Device.Object); /* Deregister device _after_ we are done using ctx not to risk an UaF. The ctx is hosted by device extension. */ - NdisDeregisterDeviceEx(ctx->Device.Handle); + NdisDeregisterDeviceEx(Ctx->Device.Handle); } static MINIPORT_SHUTDOWN TunShutdownEx; -- cgit v1.2.3-59-g8ed1b