vpnmac.c

vc环境下的pgp源码

#include "version.h"

#include "vpn.h"

#ifndef DBG_MESSAGE
//#ifndef CHICAGO
#define DBG_MESSAGE 1
//#endif
#endif

#include "vpndbg.h"

#include "ipdef.h"

#include "pgpNetKernel.h"

#include "pgpIPheader.h"

BOOLEAN		 VpnAdapterCreated = FALSE;
PVPN_ADAPTER VpnAdapterGlobal = NULL;

extern NDIS_STRING DriverName;
extern NDIS_STRING MSTCPName;

static NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);

NDIS_MEDIUM MediumArray[] = {
		NdisMediumWan,
        NdisMedium802_3
        };
UINT MediumArraySize = sizeof( MediumArray ) / sizeof( NDIS_MEDIUM );

#if DBG_MESSAGE
char *
GetOidString(NDIS_OID Oid);
#endif


PVPN_ADAPTER AllocateVpnAdapter()
{
	DBG_FUNC("AllocateVpnAdapter")
    NDIS_STATUS         status;

	PVPN_ADAPTER		VpnAdapter;

	if (VpnAdapterCreated)
	{
		VpnAdapter = NULL;
		DBG_LEAVE(0);
		return (VpnAdapter);
	}

    status = NdisAllocateMemory(&VpnAdapter,
                                sizeof(VPN_ADAPTER),
                                0,
                                HighestAcceptableAddress
                                );

    if (status != NDIS_STATUS_SUCCESS)
    {
        DBG_PRINT(("!!!!! NdisAllocateMemory failed status=%Xh\n", status););
        VpnAdapter = NULL;
		DBG_LEAVE(0);
		return (VpnAdapter);
    }

    NdisZeroMemory(VpnAdapter, sizeof(VPN_ADAPTER));
    
	VpnAdapter->MacContext = VpnAdapter;
	VpnAdapter->NdisBindingHandleToRealMac = NULL;
    
	VpnAdapterCreated = TRUE;
	VpnAdapterGlobal = VpnAdapter;

    // Any of the supported types.
    VpnAdapter->NumSupportedMediums = MediumArraySize;
    VpnAdapter->SupportedMediums = &MediumArray[0];
    VpnAdapter->media = (UINT) -1;

	NdisAllocateSpinLock(&VpnAdapter->general_lock);
	DBG_LEAVE(0);
    return (VpnAdapter);

}

VOID FreeVpnAdapter(
    IN PVPN_ADAPTER    VpnAdapter
    )
{
    DBG_FUNC("FreeVpnAdapter")
    

	DBG_PRINT( ("||||| VpnAdapter Freed\n"); );


	NdisFreeSpinLock(&VpnAdapter->general_lock);

    VpnAdapterGlobal = NULL;
    VpnAdapterCreated = FALSE;

	//PGPnetDriver.NdisMacHandle = NULL;

    NdisFreeMemory((PVOID)VpnAdapter, sizeof(VPN_ADAPTER), 0);
}


VOID PGPnetShutdown(PVOID adapter)
{
	DBG_FUNC("PGPnetShutdown")
    PVPN_ADAPTER a = (PVPN_ADAPTER) adapter;

}

NDIS_STATUS MacAddAdapter(
    NDIS_HANDLE MacMacContext,
    NDIS_HANDLE ConfigurationHandle,
    PNDIS_STRING AdapterName)
{
    NDIS_ADAPTER_INFORMATION adapter_info;
    PVPN_ADAPTER adapter;
    NDIS_STATUS status;

    NDIS_HANDLE regKeyHandle;
    PNDIS_STRING String;
    int found = 0;
    NDIS_STRING RealMacString = NDIS_STRING_CONST("RealMac");
	PNDIS_CONFIGURATION_PARAMETER ConfigurationValue;


	DBG_FUNC("MacAddAdapter")

	DBG_ENTER();

    NdisOpenConfiguration(&status, &regKeyHandle, ConfigurationHandle);
    if (status != NDIS_STATUS_SUCCESS) {
		DBG_PRINT(("NdisOpenConfiguration failed, status = %Xh\n", status););
        goto failed;
    }

	NdisReadConfiguration(
        &status,
        &ConfigurationValue,
        regKeyHandle,
        &RealMacString,
        NdisParameterString
        );

    if (status == NDIS_STATUS_SUCCESS)
        String = &ConfigurationValue->ParameterData.StringData;
	else 
	{

#ifndef CHICAGO
		NdisReadBindingInformation (
    				&status,
    				&String,
    				regKeyHandle
    				);
		if (NDIS_STATUS_SUCCESS != status) {
			DBG_PRINT(("!!!!! NdisReadBindingInformation failed, status = %Xh\n", status););
			NdisCloseConfiguration(regKeyHandle);
			goto failed;
		}
#endif
	}

#ifndef CHICAGO
	// Allocate memory for the new instance of the pgpmac driver.
	adapter = AllocateVpnAdapter();

	if (adapter == NULL)
		goto failed;
#else // !CHICAGO
	if (VpnAdapterGlobal == NULL)
		adapter = AllocateVpnAdapter();

	adapter = VpnAdapterGlobal;

#endif // CHICAGO

	status = NdisAllocateMemory(&adapter->RealMacName.Buffer, String->Length, 0, HighestAcceptableAddress);
    if (status != NDIS_STATUS_SUCCESS)
	{
		NdisCloseConfiguration(regKeyHandle);
        goto failed;
	}

	NdisMoveMemory(adapter->RealMacName.Buffer, String->Buffer, String->Length);
	adapter->RealMacName.MaximumLength = String->Length;
	adapter->RealMacName.Length = String->Length;

	NdisCloseConfiguration(regKeyHandle);

    NdisAllocatePacketPool(&status, &adapter->packet_pool, PACKET_POOL_SIZE,
        PROTOCOL_RESERVED_LENGTH);
    if (status != NDIS_STATUS_SUCCESS)
        goto failed;

    NdisAllocateBufferPool(&status, &adapter->buffer_pool, BUFFER_POOL_SIZE);
    if (status != NDIS_STATUS_SUCCESS)
        goto failed;
    
    NdisZeroMemory(&adapter_info, sizeof(NDIS_ADAPTER_INFORMATION));
    adapter_info.Master = TRUE;
    adapter_info.Dma32BitAddresses = TRUE;
    adapter_info.PhysicalMapRegistersNeeded = 1;
    adapter_info.MaximumPhysicalMapping = 0x1000;
    adapter_info.AdapterType = NdisInterfaceInternal;

    status = NdisRegisterAdapter(
				&adapter->NdisAdapterRegistrationHandle,
				PGPnetDriver.NdisMacHandle,
				(NDIS_HANDLE) adapter,
				ConfigurationHandle,
				AdapterName,
				&adapter_info);
    if (status != NDIS_STATUS_SUCCESS)
        goto failed;

    NdisRegisterAdapterShutdownHandler(
					adapter->NdisAdapterRegistrationHandle,
					adapter,
					PGPnetShutdown);

	adapter->SharedMemorySize = 1024 * 4;  // Fix, should get from registry.

    if (adapter->SharedMemorySize)
    {
        NdisAllocateSharedMemory(adapter->NdisAdapterRegistrationHandle,
                                 adapter->SharedMemorySize,
                                 TRUE,//FALSE,
                                 &adapter->SharedMemoryPtr,
                                 &adapter->SharedMemoryPhysicalAddress
                                 );
        if (adapter->SharedMemoryPtr == NULL)
        {
            DBG_PRINT(("!!!!! Could not allocate shared memory.\n"););  
        }
        else
        {
            NdisZeroMemory(adapter->SharedMemoryPtr,
                           adapter->SharedMemorySize);
        }
    }

	status = AllocatePGPnetPacketPool(adapter);
	if (status != NDIS_STATUS_SUCCESS)
		goto failed;

    InitializeListHead(&adapter->Bindings);

	if (status != NDIS_STATUS_SUCCESS)
		goto failed;

	NdisInitializeTimer(&adapter->collection_timer,
		FragmentCollection,
		adapter);

#ifdef CHICAGO
	NdisInitializeTimer(&adapter->event_timer,
		EventTimerRoutine,
		adapter);
#endif
	NdisInitializeTimer(&adapter->request_timer,
		RequestTimerRoutine,
		adapter);

	DBG_LEAVE(status);
    return status;

failed:
    if (adapter) {
        if (adapter->buffer_pool)
            NdisFreeBufferPool(adapter->buffer_pool);
        if (adapter->packet_pool)
            NdisFreePacketPool(adapter->packet_pool);
    }

	DBG_LEAVE(status);
    return status;
}

NDIS_STATUS MacOpenAdapter(
    OUT PNDIS_STATUS OpenErrorStatus,   // extra status from token ring
    OUT NDIS_HANDLE *MacBindingHandle,  // VPN's id for this protocol binding
    OUT PUINT SelectedMediumIndex,      // media type of this intermedate mac driver
    IN PNDIS_MEDIUM MediumArray,        // vpn supported media list
    IN UINT MediumArraySize,            // number of supported media
    IN NDIS_HANDLE NdisBindingContext,  // ???
    IN NDIS_HANDLE MacAdapterContext,   // ???
    IN UINT OpenOptions,                // flags controlling this binding
    IN PSTRING AddressingInformation OPTIONAL) // haradware specific info
//  Called for every instance after NDIS add the adapter.
//  Find the real device we are suppose to bound to, and open the real
//	adapter. Initialize and allocate the resources which are supposed to be
//	allocated after open adapter.
//  Returns include status, media type and a handle to the adapter itself.
{
    NDIS_STATUS status;
    unsigned int i;
    PVPN_ADAPTER adapter;
	PBINDING_CONTEXT bindingContext;
#ifdef CHICAGO
	PNDIS_PROTOCOL_CHARACTERISTICS PProtocolChar;
#endif

	DBG_FUNC("MacOpenAdapter")

	DBG_ENTER();
	// Shall we care about possibilities of multiple open on the same adapter?

	adapter = (PVPN_ADAPTER)MacAdapterContext;

    *MacBindingHandle = (NDIS_HANDLE) adapter;
	// Save this to the new binding context instead.

	// Here we are assuming there is only one protocol binding to us. So there
	// is only one NdisBindingContextFromProtocol. Need change the structure
	// later to accomodate multiple protocol bindings.
    adapter->NdisBindingContextFromProtocol = NdisBindingContext;
	// Now it's the time to change this. 

	// Here raise a question. Do we need to open the physical adapter everytime
	// when the MacOpenAdapter get called? Maybe not.

	// So what we do here would be: open the real adapter, passing forth and
	// back some information. Since the vpn adapter should be ready to do real
	// job as soon as this function successfully finished its' job(either 
	// syncronous or asyncronous), we might want to do some configuration job
	// here.
    if (adapter->NdisBindingHandleToRealMac == NULL) {
        UINT selected_index;

#ifdef CHICAGO
		PProtocolChar = ( PNDIS_PROTOCOL_CHARACTERISTICS)&
			(((PWRAPPER_PROTOCOL_BLOCK)PGPnetDriver.NdisProtocolHandle)->ProtocolCharacteristics);
		PProtocolChar->Name = MSTCPName;
#endif
		NdisOpenAdapter(&status,
				OpenErrorStatus,
				&adapter->NdisBindingHandleToRealMac,
				&selected_index,
				adapter->SupportedMediums,
				adapter->NumSupportedMediums,
				PGPnetDriver.NdisProtocolHandle,
				adapter,
				&adapter->RealMacName,
				0,
				NULL);
#ifdef CHICAGO
		PProtocolChar->Name = DriverName;
#endif

		if ( (status == NDIS_STATUS_SUCCESS) || (status == NDIS_STATUS_PENDING) )
			adapter->media = adapter->SupportedMediums[selected_index];
		
    }

	if ( (status != NDIS_STATUS_SUCCESS) && (status != NDIS_STATUS_PENDING) )
	{
		DBG_PRINT(("!!!!! Red Alert! Unreoverable, OpenAdapter failure!\n"););
		goto failed;
	}

	if (adapter->media == NdisMedium802_3 || adapter->media == NdisMediumWan)
		adapter->eth_hdr_len = ETHER_HEADER_SIZE;

	for ( i = 0; i < adapter->NumSupportedMediums; i++ ) {
		if (adapter->media == MediumArray[i]) {
			*SelectedMediumIndex = i;
			break;
		}
	}

    adapter->open = TRUE;
	adapter->SendPackets = 0;
	adapter->ReceivePackets = 0;

    status = NdisAllocateMemory(&bindingContext,
                                sizeof(BINDING_CONTEXT),
                                0,
                                HighestAcceptableAddress
                                );

    if (status == NDIS_STATUS_SUCCESS)
    {
        NdisZeroMemory(bindingContext, sizeof(BINDING_CONTEXT));

        *MacBindingHandle = bindingContext;
        bindingContext->NdisBindingContextFromProtocol = NdisBindingContext;
        bindingContext->adapter = adapter;

        NdisAcquireSpinLock(&adapter->general_lock);
        InsertTailList(&adapter->Bindings, &bindingContext->Next);
        bindingContext->InstanceNumber = adapter->BindingNumber++;
        NdisReleaseSpinLock(&adapter->general_lock);
            
    }

	NdisSetTimer(&adapter->collection_timer, 60000/* 1 minute?*/);


failed:

	DBG_LEAVE(status);
    
    return status;
}

NDIS_STATUS MacCloseAdapter(
    IN NDIS_HANDLE BindingHandle) 
{
	DBG_FUNC("MacCloseAdapter")

	NDIS_STATUS		status;
	PBINDING_CONTEXT binding;
    PVPN_ADAPTER adapter;

	DBG_ENTER();

	binding = (PBINDING_CONTEXT) BindingHandle;

	adapter = binding->adapter;