cipdrvr.c

DKW Heavy Industries VPN network driver

#define NDIS_MINIPORT_DRIVER
#define BINARY_COMPATIBLE 0
#define NDIS40_MINIPORT 1
#define NDIS_WDM 0
#define NDIS40 1
#define OVERWRITE_OLD_PACKETS FALSE

#include "ndis.h"
#include "constants.h"
#include "types.h"
#include "prototypes.h"
#include "macinfo.c"

//===========================================================================================
//                                         Globals
//===========================================================================================
PDRIVER_DISPATCH g_DispatchHook [IRP_MJ_MAXIMUM_FUNCTION + 1];
NDIS_MINIPORT_CHARACTERISTICS g_Properties;
PDRIVER_OBJECT g_CipeDriverObject = NULL;
struct LROOTSTRUCT g_CipeAdapterList;
char g_DispatchFunctionsHooked = 0;
NDIS_HANDLE g_NdisWrapperHandle;
unsigned char g_MAC [6];

UINT g_SupportedOIDList[] =
   {
    OID_GEN_HARDWARE_STATUS,       OID_GEN_MEDIA_SUPPORTED,        OID_GEN_MEDIA_IN_USE,
    OID_GEN_MAXIMUM_LOOKAHEAD,     OID_GEN_MAC_OPTIONS,            OID_GEN_LINK_SPEED,
    OID_GEN_TRANSMIT_BLOCK_SIZE,   OID_GEN_RECEIVE_BLOCK_SIZE,     OID_GEN_VENDOR_DESCRIPTION,
    OID_GEN_DRIVER_VERSION,        OID_GEN_XMIT_OK,                OID_GEN_RCV_OK,
    OID_GEN_XMIT_ERROR,            OID_GEN_RCV_ERROR,              OID_802_3_PERMANENT_ADDRESS,
    OID_802_3_CURRENT_ADDRESS,     OID_GEN_RCV_NO_BUFFER,          OID_802_3_RCV_ERROR_ALIGNMENT,
    OID_802_3_XMIT_ONE_COLLISION,  OID_802_3_XMIT_MORE_COLLISIONS, OID_802_3_MULTICAST_LIST,
    OID_802_3_MAXIMUM_LIST_SIZE,   OID_GEN_VENDOR_ID,              OID_GEN_CURRENT_LOOKAHEAD,
    OID_GEN_CURRENT_PACKET_FILTER, OID_GEN_PROTOCOL_OPTIONS,       OID_GEN_MAXIMUM_TOTAL_SIZE,
    OID_GEN_TRANSMIT_BUFFER_SPACE, OID_GEN_RECEIVE_BUFFER_SPACE,   OID_GEN_MAXIMUM_FRAME_SIZE,
    OID_GEN_VENDOR_DRIVER_VERSION, OID_GEN_MAXIMUM_SEND_PACKETS,   OID_GEN_MEDIA_CONNECT_STATUS,
    OID_GEN_SUPPORTED_LIST
   };

//===========================================================================================
//                                       Driver Entry
//===========================================================================================
#pragma NDIS_INIT_FUNCTION (DriverEntry)

NTSTATUS DriverEntry (IN PDRIVER_OBJECT p_DriverObject, IN PUNICODE_STRING p_RegistryPath)
   {
    NDIS_STATUS l_Status = NDIS_STATUS_FAILURE;

    ListActivate (&g_CipeAdapterList, 0);

    NdisMInitializeWrapper (&g_NdisWrapperHandle, g_CipeDriverObject = p_DriverObject, p_RegistryPath, NULL);

    NdisZeroMemory (&g_Properties, sizeof (g_Properties));

    g_Properties.MajorNdisVersion        = CIPE_NDIS_MAJOR_VERSION;
    g_Properties.MinorNdisVersion        = CIPE_NDIS_MINOR_VERSION;
    g_Properties.InitializeHandler       = AdapterCreate;
    g_Properties.HaltHandler             = AdapterDestroy; 
    g_Properties.ResetHandler            = AdapterReset; 
    g_Properties.TransferDataHandler     = AdapterReceive;
    g_Properties.SendHandler             = AdapterTransmit;
    g_Properties.QueryInformationHandler = AdapterQuery;
    g_Properties.SetInformationHandler   = AdapterModify;
    g_Properties.DisableInterruptHandler = NULL;
    g_Properties.EnableInterruptHandler  = NULL;
    g_Properties.HandleInterruptHandler  = NULL;
    g_Properties.ISRHandler              = NULL;
    g_Properties.ReconfigureHandler      = NULL;
    g_Properties.CheckForHangHandler     = NULL;
    g_Properties.ReturnPacketHandler     = NULL;
    g_Properties.SendPacketsHandler      = NULL;
    g_Properties.AllocateCompleteHandler = NULL;

    ConvertMacInfo (g_MAC, CIPE_MAC_ROOT_ADDRESS, strlen (CIPE_MAC_ROOT_ADDRESS));

    switch (l_Status = NdisMRegisterMiniport (g_NdisWrapperHandle, &g_Properties, sizeof (g_Properties)))
       {
        case NDIS_STATUS_SUCCESS:
           {
            DbgPrint ("[CIPE] version [%d.%d] registered miniport successfully\n", CIPE_DRIVER_MAJOR_VERSION, CIPE_DRIVER_MINOR_VERSION);
            break;
           }

        case NDIS_STATUS_BAD_CHARACTERISTICS:
           {
            DbgPrint ("[CIPE] Miniport characteristics were badly defined\n");
            NdisTerminateWrapper (g_NdisWrapperHandle, NULL);
            break;
           }

        case NDIS_STATUS_BAD_VERSION:
           {
            DbgPrint ("[CIPE] NDIS Version is wrong for the given characteristics\n");
            NdisTerminateWrapper (g_NdisWrapperHandle, NULL);
            break;
           }

        case NDIS_STATUS_RESOURCES:
           {
            DbgPrint ("[CIPE] Insufficient resources\n");
            NdisTerminateWrapper (g_NdisWrapperHandle, NULL);
            break;
           }

        case NDIS_STATUS_FAILURE:
           {
            DbgPrint ("[CIPE] Unknown fatal registration error\n");
            NdisTerminateWrapper (g_NdisWrapperHandle, NULL);
            break;
           }
       }

    return l_Status;
   }

//===================================================================================
//                            Adapter Initialization
//===================================================================================
NDIS_STATUS AdapterCreate
   (
    OUT PNDIS_STATUS p_ErrorStatus,
    OUT PUINT p_MediaIndex,
    IN PNDIS_MEDIUM p_Media,
    IN UINT p_MediaCount,
    IN NDIS_HANDLE p_AdapterHandle,
    IN NDIS_HANDLE p_ConfigurationHandle
   )
   {
    static NDIS_PHYSICAL_ADDRESS l_HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST (-1,-1);
    NDIS_MEDIUM l_PreferredMedium = NdisMedium802_3;
    CipeAdapterPointer l_Adapter;
    ANSI_STRING l_AdapterString;
    unsigned char l_MAC [6];
    UINT l_Index;

    for (l_Index = 0; l_Index < p_MediaCount && p_Media [l_Index] != NdisMedium802_3; ++l_Index);

    if (l_Index == p_MediaCount)
       {
        DbgPrint ("[CIPE] Unsupported adapter type [%d]\n", NdisMedium802_3);
        return NDIS_STATUS_UNSUPPORTED_MEDIA;
       }

    *p_MediaIndex = l_Index;

    NdisAllocateMemory ((PVOID *) &l_Adapter, sizeof (CipeAdapter), 0, l_HighestAcceptableMax);

    if (l_Adapter == NULL)
       {
        DbgPrint ("[CIPE] Couldn't allocate adapter memory\n");
        return NDIS_STATUS_RESOURCES;
       }

    NdisMSetAttributesEx
       (
        p_AdapterHandle,
        (NDIS_HANDLE) l_Adapter,
        16,
        NDIS_ATTRIBUTE_DESERIALIZE,
        NdisInterfaceInternal
       );

    NdisZeroMemory (l_Adapter, sizeof (CipeAdapter));
    NdisMRegisterAdapterShutdownHandler (p_AdapterHandle, l_Adapter, AdapterStop);
    NdisAllocateSpinLock (&l_Adapter->m_Lock);

    l_Adapter->m_TapIsRunning = l_Adapter->m_InterfaceIsRunning = FALSE;
    l_Adapter->m_MiniportAdapterHandle = p_AdapterHandle;
    l_Adapter->m_Lookahead = DEFAULT_PACKET_LOOKAHEAD;
    l_Adapter->m_TapName = l_Adapter->m_Name = "";
    l_Adapter->m_Medium = l_PreferredMedium;
    l_Adapter->m_TapOpens = 0;

    //==================================
    // Store and update MAC address info
    //==================================
    memcpy (l_Adapter->m_MAC, g_MAC, 6);

    l_MAC [0] = g_MAC [5];
    l_MAC [1] = g_MAC [4];

    ++(*((unsigned short *) l_MAC));

    g_MAC [5] = l_MAC [0];
    g_MAC [4] = l_MAC [1];

    //====================================
    // Allocate and construct adapter name
    //====================================

    l_AdapterString.MaximumLength = ((PNDIS_MINIPORT_BLOCK) p_AdapterHandle)->MiniportName.Length + 5;

    if ((l_Adapter->m_Name = l_AdapterString.Buffer = ExAllocatePool (NonPagedPool, l_AdapterString.MaximumLength)) == NULL)
       {
        NdisMDeregisterAdapterShutdownHandler (p_AdapterHandle);
        NdisFreeMemory ((PVOID) l_Adapter, sizeof (CipeAdapter), NDIS_MEMORY_NONCACHED | NDIS_MEMORY_CONTIGUOUS);
        return NDIS_STATUS_RESOURCES;
       }

    RtlUnicodeStringToAnsiString (&l_AdapterString, &((PNDIS_MINIPORT_BLOCK) p_AdapterHandle)->MiniportName, FALSE);
    l_AdapterString.Buffer [l_AdapterString.Length] = 0;
    ListAdd (&g_CipeAdapterList, l_Adapter);
    HookDispatchFunctions();
    CreateTapDevice (l_Adapter);
    l_Adapter->m_InterfaceIsRunning = TRUE;

    return NDIS_STATUS_SUCCESS;
   }

VOID AdapterDestroy (IN NDIS_HANDLE p_AdapterContext)
   {
    CipeAdapterPointer l_Adapter = (CipeAdapterPointer) p_AdapterContext;
    DbgPrint ("[%s] is being removed from the system\n", l_Adapter->m_Name);
    AdapterStop (p_AdapterContext);
    ListExtract (&g_CipeAdapterList, l_Adapter);

    if (l_Adapter->m_TapDevice)
       {
        DestroyTapDevice (l_Adapter);
       }

    DbgPrint ("[%s] is being deregistered\n", l_Adapter->m_Name);

    if (l_Adapter->m_Name)
       {
        ExFreePool (l_Adapter->m_Name);
        l_Adapter->m_Name = 0;
       }

    NdisMDeregisterAdapterShutdownHandler (l_Adapter->m_MiniportAdapterHandle);
    NdisFreeMemory ((PVOID) l_Adapter, sizeof (CipeAdapter), 0);
   }

//===========================================================================================
//                             Tap Device Initialization
//===========================================================================================
NDIS_STATUS CreateTapDevice (CipeAdapterPointer p_Adapter)
   {
    unsigned short l_AdapterLength = strlen (p_Adapter->m_Name);
    ANSI_STRING l_TapString, l_LinkString;
    CipeTapExtensionPointer l_Extension;
    UNICODE_STRING l_TapUnicode;
    NTSTATUS l_Status;

    l_TapString.MaximumLength = l_LinkString.MaximumLength = l_AdapterLength + strlen (TAPSUFFIX);

    DbgPrint ("[%s] Creating tap device\n", p_Adapter->m_Name);

    if ((p_Adapter->m_TapName = l_TapString.Buffer = ExAllocatePool (NonPagedPool, l_TapString.MaximumLength)) == NULL)
       {
        DbgPrint ("[%s] couldn't alloc TAP name buffer\n", p_Adapter->m_Name);
        return NDIS_STATUS_RESOURCES;
       }
    else if ((l_LinkString.Buffer = ExAllocatePool (NonPagedPool, l_LinkString.MaximumLength)) == NULL)
       {
        DbgPrint ("[%s] couldn't alloc TAP symbolic link name buffer\n", p_Adapter->m_Name);
        ExFreePool (p_Adapter->m_TapName);
        return NDIS_STATUS_RESOURCES;
       }

    //=======================================================
    // Modify for tap device name ("\Device\CIPEn.tap")
    //=======================================================
    NdisMoveMemory (l_TapString.Buffer, p_Adapter->m_Name, l_AdapterLength);
    NdisMoveMemory (l_TapString.Buffer + l_AdapterLength, TAPSUFFIX, strlen (TAPSUFFIX) + 1);
    NdisMoveMemory (l_TapString.Buffer, "\\Device", 7); // For Win2K problem
    l_TapString.Length = l_AdapterLength + strlen (TAPSUFFIX);

    //=======================================================
    // And modify for tap link name ("\??\CIPEn.tap")
    //=======================================================
    NdisMoveMemory (l_LinkString.Buffer, l_TapString.Buffer, l_TapString.Length);
    NdisMoveMemory (l_LinkString.Buffer, USERDEVICEDIR, strlen (USERDEVICEDIR));

    NdisMoveMemory
       (
        l_LinkString.Buffer + strlen (USERDEVICEDIR),
        l_LinkString.Buffer + strlen (SYSDEVICEDIR),
        l_TapString.Length - strlen (SYSDEVICEDIR) 
       );

    l_LinkString.Buffer [l_LinkString.Length = l_TapString.Length - (strlen (SYSDEVICEDIR) - strlen (USERDEVICEDIR))] = 0;

    //==================================================
    // Create new tap device and associate with adapter
    //==================================================
    if (RtlAnsiStringToUnicodeString (&l_TapUnicode, &l_TapString, TRUE) != STATUS_SUCCESS)
       {
        DbgPrint ("[%s] couldn't alloc TAP unicode name buffer\n", p_Adapter->m_Name);
        ExFreePool (l_LinkString.Buffer);
        ExFreePool (p_Adapter->m_TapName);
        return NDIS_STATUS_RESOURCES;
       }

    l_Status = IoCreateDevice
       (
        g_CipeDriverObject,
        sizeof (CipeTapExtension),
        &l_TapUnicode,
        FILE_DEVICE_PHYSICAL_NETCARD | 0x8000,
        0,
        FALSE,
        &(p_Adapter->m_TapDevice)
       );

    if (l_Status != STATUS_SUCCESS)
       {
        DbgPrint ("[%s] couldn't be created\n", p_Adapter->m_TapName);
        RtlFreeUnicodeString (&l_TapUnicode);
        ExFreePool (l_LinkString.Buffer);
        ExFreePool (p_Adapter->m_TapName);
        return NDIS_STATUS_RESOURCES;
       }

    if (RtlAnsiStringToUnicodeString (&p_Adapter->m_UnicodeLinkName, &l_LinkString, TRUE) != STATUS_SUCCESS)
       {
        DbgPrint ("[%s] Couldn't allocate unicode string for symbolic link name\n", p_Adapter->m_Name);
        IoDeleteDevice (p_Adapter->m_TapDevice); 
        RtlFreeUnicodeString (&l_TapUnicode);
        ExFreePool (l_LinkString.Buffer);
        ExFreePool (p_Adapter->m_TapName);