break;           }        //-----------------------------------------------------------        //   User mode thread has called open() on the tap device        //-----------------------------------------------------------        case IRP_MJ_CREATE:           {            if (l_Adapter->m_TapIsRunning)               {                DbgPrint ("[%s] [CIPE] release [%d.%d] open request\n", l_Adapter->m_Name, CIPE_DRIVER_MAJOR_VERSION, CIPE_DRIVER_MINOR_VERSION);                ++l_Adapter->m_TapOpens;               }            else               {                DbgPrint ("[%s] TAP is presently unavailable\n", l_Adapter->m_Name);                p_IRP->IoStatus.Status = l_Status = STATUS_UNSUCCESSFUL;                p_IRP->IoStatus.Information = 0;               }            IoCompleteRequest (p_IRP, IO_NO_INCREMENT);            break;           }        //-----------------------------------------------------------        //        User mode thread close() on the tap device        //-----------------------------------------------------------        case IRP_MJ_CLOSE:           {            DbgPrint ("[%s] [CIPE] release [%d.%d] close request\n", l_Adapter->m_Name, CIPE_DRIVER_MAJOR_VERSION, CIPE_DRIVER_MINOR_VERSION);            while (QueueCount (&l_Extension->m_PacketQueue)) QueuePop (&l_Extension->m_PacketQueue); // Exhaust packet queue            // If we were going to CancelIrp() all the IRPs in queue, we would do it here :-)            if (l_Adapter->m_TapOpens) --l_Adapter->m_TapOpens;            IoCompleteRequest (p_IRP, IO_NO_INCREMENT);             break;           }        //-----------------------------------------------------------        // Something screwed up if it gets here ! It won't die, though        //-----------------------------------------------------------        default:           {            IoCompleteRequest (p_IRP, IO_NO_INCREMENT);             break;           }       }     return l_Status;   }//===========================================================================================//                               IRP Management Routines//===========================================================================================NTSTATUS CompleteIRP (IN PIRP p_IRP, IN CipeTapExtensionPointer p_Extension)   {    NTSTATUS l_Status = STATUS_UNSUCCESSFUL;    CipePacketPointer l_PacketBuffer;    if ((l_PacketBuffer = QueuePeek (&p_Extension->m_PacketQueue)) == 0) // The topmost packet buffer is invalid !       {        QueuePop (&p_Extension->m_PacketQueue);       }    else if (p_IRP)       {        IoSetCancelRoutine (p_IRP, NULL); // Disable cancel routine        if (p_IRP->IoStatus.Information < l_PacketBuffer->m_Size)           {            p_IRP->IoStatus.Information = 0; // l_PacketBuffer->m_Size;            p_IRP->IoStatus.Status = STATUS_BUFFER_OVERFLOW;           }        else           {            p_IRP->IoStatus.Information = l_PacketBuffer->m_Size;            p_IRP->IoStatus.Status = l_Status = STATUS_SUCCESS;            QueuePop (&p_Extension->m_PacketQueue);            __try               {                NdisMoveMemory (p_IRP->AssociatedIrp.SystemBuffer, l_PacketBuffer->m_Data, l_PacketBuffer->m_Size);               }            __except (EXCEPTION_EXECUTE_HANDLER)               {                p_IRP->IoStatus.Status = STATUS_UNSUCCESSFUL;                p_IRP->IoStatus.Information = 0;               }            __try               {                NdisFreeMemory (l_PacketBuffer, sizeof (CipePacket) + l_PacketBuffer->m_Size, 0);               }            __except (EXCEPTION_EXECUTE_HANDLER)               {               }           }        IoCompleteRequest (p_IRP, IO_NO_INCREMENT);       }    return l_Status;   }VOID CancelIRP (IN PDEVICE_OBJECT p_DeviceObject, IN PIRP p_IRP)   {    CipeTapExtensionPointer l_Extension = (CipeTapExtensionPointer) p_DeviceObject->DeviceExtension;    if (p_IRP) if (QueueExtract (&l_Extension->m_IrpQueue, p_IRP) == p_IRP)       {        IoSetCancelRoutine (p_IRP, NULL);         IoReleaseCancelSpinLock (p_IRP->CancelIrql);         p_IRP->IoStatus.Status = STATUS_CANCELLED;        p_IRP->IoStatus.Information = 0;        IoCompleteRequest (p_IRP, IO_NO_INCREMENT);       }   }//===========================================================================================//                             Dispatch Table Managemement//===========================================================================================VOID HookDispatchFunctions()   {    unsigned long l_Index;    //==============================================================    // Save original NDIS dispatch functions and override with ours    //==============================================================    if (! g_DispatchFunctionsHooked) for (l_Index = 0, g_DispatchFunctionsHooked = 1; l_Index <= IRP_MJ_MAXIMUM_FUNCTION; ++l_Index)       {        g_DispatchHook [l_Index] = g_CipeDriverObject->MajorFunction [l_Index];        g_CipeDriverObject->MajorFunction [l_Index] = CipeTapDeviceHook;       }   }//===========================================================================================//                         Linked List Management Routines//===========================================================================================LROOT ListAlloc (ULONG p_Limit)   {    return ListActivate ((LROOT) MemAlloc (sizeof (struct LROOTSTRUCT)), p_Limit);   }VOID ListFree (LROOT p_Root)   {    if (p_Root)       {        ListDeactivate (p_Root);        MemFree ((PVOID) p_Root, sizeof (struct LROOTSTRUCT));       }   }LROOT ListActivate (LROOT p_Root, ULONG p_Limit)   {    if (p_Root)       {        p_Root->m_First = p_Root->m_Last = 0;        p_Root->m_Limit = p_Limit;        p_Root->m_Count = 0;       }    return p_Root;   }VOID ListDeactivate (LROOT p_Root)   {    if (p_Root) while (p_Root->m_Count) ListRemove (p_Root, LMODE_QUEUE);   }LITEM ListAdd (LROOT p_Root, LITEM p_Payload)   {    LITEM l_Return = 0;    LNODE l_Node;    if (p_Root)       {        if (p_Root->m_Count >= p_Root->m_Limit && p_Root->m_Limit)           ;        else if ((l_Node = (LNODE) MemAlloc (sizeof (struct LNODESTRUCT))) == 0)           ;        else if (p_Root->m_First)           {            (l_Node->m_Previous = p_Root->m_Last)->m_Next = l_Node;            l_Return = l_Node->m_Payload = p_Payload;            p_Root->m_Last = l_Node;            ++p_Root->m_Count;           }        else           {            l_Return = l_Node->m_Payload = p_Payload;            p_Root->m_First = p_Root->m_Last = l_Node;            l_Node->m_Next = l_Node->m_Previous = 0;            p_Root->m_Count = 1;           }       }    return l_Return;   }LITEM ListRemove (LROOT p_Root, LMODE p_Mode)   {    LITEM l_Return = 0;    LNODE l_Node;    if (p_Root)       {        if (p_Root->m_Count == 0)           ;        else if ((l_Node = (p_Mode == LMODE_QUEUE ? p_Root->m_First : p_Root->m_Last)) == 0)           p_Root->m_Count = 0;        else           {            if (l_Node->m_Next && p_Mode == LMODE_QUEUE)               (p_Root->m_First = l_Node->m_Next)->m_Previous = 0;            else if (l_Node->m_Previous && p_Mode == LMODE_STACK)               (p_Root->m_Last = l_Node->m_Previous)->m_Next = 0;            else               p_Root->m_First = p_Root->m_Last = 0;            l_Return = l_Node->m_Payload;            MemFree ((PVOID) l_Node, sizeof (struct LNODESTRUCT)); // DEBUG DEBUG DEBUG            --p_Root->m_Count;           }       }    return l_Return;   }LITEM ListExtract (LROOT p_Root, LITEM p_Payload)   {    LITEM l_Return = 0;    LNODE l_Node = 0;    if (p_Root)       {        if (p_Root->m_Count)           {            for (l_Node = p_Root->m_First; l_Node && l_Node->m_Payload != p_Payload; l_Node = l_Node->m_Next);           }        if (l_Node)           {            if (l_Node->m_Previous) l_Node->m_Previous->m_Next = l_Node->m_Next;            if (l_Node->m_Next) l_Node->m_Next->m_Previous = l_Node->m_Previous;            if (p_Root->m_Last == l_Node) p_Root->m_Last = l_Node->m_Previous;            if (p_Root->m_First == l_Node) p_Root->m_First = l_Node->m_Next;            l_Return = l_Node->m_Payload;            MemFree ((PVOID) l_Node, sizeof (struct LNODESTRUCT));            --p_Root->m_Count;           }       }    return l_Return;   }LITEM ListPeek (LROOT p_Root, LMODE p_Mode)   {    LITEM l_Return = 0;    if (p_Root)       {        if (p_Root->m_Count == 0)           ;        else if (p_Root->m_First && p_Mode == LMODE_QUEUE)           l_Return = p_Root->m_First->m_Payload;        else if (p_Root->m_Last && p_Mode == LMODE_STACK)           l_Return = p_Root->m_Last->m_Payload;        else           l_Return = (LITEM) (p_Root->m_Count = 0);       }    return l_Return;   }ULONG ListCount (LROOT p_Root)   {    return (p_Root ? p_Root->m_Count : 0);   }//===========================================================================================//                               Memory Management//===========================================================================================PVOID MemAlloc (ULONG p_Size)   {    PVOID l_Return = 0;    if (p_Size)       {        __try           {            static NDIS_PHYSICAL_ADDRESS l_HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST (-1,-1);            NdisAllocateMemory (&l_Return, p_Size, 0, l_HighestAcceptableMax);            NdisZeroMemory (l_Return, p_Size);           }        __except (EXCEPTION_EXECUTE_HANDLER)           {            l_Return = 0;           }       }    return l_Return;   }VOID MemFree (PVOID p_Addr, ULONG p_Size)   {    if (p_Addr && p_Size)       {        __try           {            NdisFreeMemory (p_Addr, p_Size, 0);           }        __except (EXCEPTION_EXECUTE_HANDLER)           {           }       }   }//===========================================================================================//                                    End of Source//===========================================================================================