cipdrvr.c

DKW Heavy Industries VPN network driver

            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
//===========================================================================================