pgpnetpackethelper.cpp

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	$Id: pgpnetPacketHelper.cpp,v 1.2 2002/08/06 20:10:27 dallen Exp $
____________________________________________________________________________*/

#include "pgpnetBase.h"

#include "pgpnetPacket.h"
//#include "pgpnetRequest.h"
#include "pgpNetPM.h"
#include "CPGPnetDriver.h"


//#include "CPGPnetFilterDriver.h"
//#include "CPGPnetFilterDriverMac.h"

#include "CPGPnetAdapter.h"
//#include "CPGPnetFilterAdapter.h"

#include "pgpnetPacketHelper.h"

#include "pgpNetIPdef.h"

#include "pgpnetdebug.h"


/*******************************************************************************
 *******************************************************************************
 PGPnetPacket Related functions
 *******************************************************************************
 *******************************************************************************/

VOID PacketEnqueue(
    PPGPnetPacket* packet_list,
    PGPnetPacket* packet)
{

	DBG_FUNC("PacketEnqueue")

	ASSERT(packet);

	if (packet->reserved[0] != 0)
		ASSERT(FALSE);

    NdisAcquireSpinLock(&PGPnetDriver->general_lock);

    if (*packet_list == (PGPnetPacket*) NULL) {
        packet->link = packet;
    } else {
        packet->link = (*packet_list)->link;
        (*packet_list)->link = packet;
    }
    *packet_list = packet;

    NdisReleaseSpinLock(&PGPnetDriver->general_lock);
}

PGPnetPacket* PacketDequeue(
    PPGPnetPacket* packet_list)
{

	DBG_FUNC("PacketDequeue")

	PGPnetPacket* packet;

    NdisAcquireSpinLock(&PGPnetDriver->general_lock);

    if (*packet_list == (PGPnetPacket*) NULL) {
        packet = (PGPnetPacket*) NULL;
    } else {
		packet = (*packet_list)->link;
        if (packet == *packet_list) {
            *packet_list = (PGPnetPacket*) NULL;
        } else {
            (*packet_list)->link = packet->link;
        }
    }

    NdisReleaseSpinLock(&PGPnetDriver->general_lock);

	if (packet != NULL) {
		ASSERT(packet->reserved[0] == 0);
		packet->link = NULL;
	}

    return packet;
}

PGPnetPacket* AllocatePGPnetPacket(VOID)
{
    PGPnetPacket* packet;

	DBG_FUNC("AllocatePGPnetPacket")

	DBG_ENTER();

	packet = (PGPnetPacket*) PacketDequeue(&PGPnetDriver->free_packet_list);

	if (packet == (PGPnetPacket*) NULL) {
		DBG_PRINT(("!!!!! FATAL!!! PreAllocated PGPPacket Exhausted!!!\n"););
		ASSERT(FALSE);
		return NULL;
	}

	packet->link = NULL;
	packet->xformBlockLen = 0;
	packet->firstSrcBlock = 0;
	packet->firstXformBlock = 0;
	packet->lastSrcBlock = 0;
	packet->lastXformBlock = 0;
	packet->bAlreadyProcessed = 0;
//XXX	packet->Carry = 0;

	packet->nextFrag = NULL;
	packet->isFragment = 0;
	packet->defaultAdapterMTU = 1500;
    packet->bNatTraversed = 0;

	packet->srcBlockLen = 0;
	packet->xformBlockLen = 0;

	packet->srcIPsecBufferPriv.allocatedSize = BLOCK_SIZE;
	packet->srcIPsecBufferPriv.dataSize = 0;
	packet->srcIPsecBufferPriv.next = NULL;
	packet->srcIPsecBufferPriv.data = packet->srcBlock + ETHER_HEADER_SIZE;
	packet->pSrcIPsecBuffer = &(packet->srcIPsecBufferPriv);
	packet->bSrcDataIsHeap = FALSE;

	packet->xformIPsecBufferPriv.allocatedSize = BLOCK_SIZE;
	packet->xformIPsecBufferPriv.dataSize = 0;
	packet->xformIPsecBufferPriv.next = NULL;
	packet->xformIPsecBufferPriv.data = packet->xformBlock + ETHER_HEADER_SIZE;
	packet->pXformIPsecBuffer = &(packet->xformIPsecBufferPriv);
	packet->bXformDataIsHeap = FALSE;

	packet->SendFlag = 0;
	packet->bIsPacketLocal = FALSE;

	DBG_LEAVE(0);

    return packet;
}

VOID FreePGPnetPacket(
		PGPnetPacket* packet)
{

	DBG_FUNC("FreePGPnetPacket")

	DBG_ENTER();

	if (packet == NULL)
	{
		DBG_LEAVE(1);
		return;
	}

    PacketEnqueue(&PGPnetDriver->free_packet_list, packet);

	DBG_LEAVE(0);
}

PGPnetPacket* PacketRemoveByXformPacket(
		PPGPnetPacket*		packet_list,
		PNDIS_PACKET		packet)
{
	DBG_FUNC("PacketRemoveByXformPacket")

	PGPnetPacket* pgpPacket;

	NdisAcquireSpinLock(&PGPnetDriver->general_lock);

	if ( (pgpPacket = *packet_list) != NULL ) 
	{
		do 
		{
			PGPnetPacket* next = pgpPacket->link;
			if (next->xformPacket == packet) 
			{
				if (next == pgpPacket)
					*packet_list = NULL;
				else
				{
					pgpPacket->link = next->link;
					if (*packet_list == next)
						*packet_list = pgpPacket;
				}
				NdisReleaseSpinLock(&PGPnetDriver->general_lock);
				return next;
			}
			pgpPacket = next;
		} while (pgpPacket != *packet_list);
	};
	
	NdisReleaseSpinLock(&PGPnetDriver->general_lock);

	return NULL;

}

PGPnetPacket* PacketRemoveBySrcPacket(
		PPGPnetPacket		*packet_list,
		PNDIS_PACKET		packet)
{
	PGPnetPacket* pgpPacket;

	NdisAcquireSpinLock(&PGPnetDriver->general_lock);

	if ( (pgpPacket = *packet_list) != NULL ) 
	{
		do 
		{
			PGPnetPacket* next = pgpPacket->link;
			if (next->srcPacket == packet) 
			{
				if (next == pgpPacket)
					*packet_list = NULL;
				else
				{
					pgpPacket->link = next->link;
					if (*packet_list == next)
						*packet_list = pgpPacket;
				}
				NdisReleaseSpinLock(&PGPnetDriver->general_lock);
				return next;
			}
			pgpPacket = next;
		} while (pgpPacket != *packet_list);
	};
	
	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
	
	return NULL;

}

PGPnetPacket* PacketListRemove(
		PPGPnetPacket	*packet_list,
		PPGPnetPacket	packet)
{
	PPGPnetPacket pgpPacket;

	NdisAcquireSpinLock(&PGPnetDriver->general_lock);

	if ( (pgpPacket = *packet_list) != NULL ) 
	{
		do 
		{
			PPGPnetPacket next = pgpPacket->link;
			if (next == packet) 
			{
				if (next == pgpPacket)
					*packet_list = NULL;
				else
				{
					pgpPacket->link = next->link;
					if (*packet_list == next)
						*packet_list = pgpPacket;
				}
				NdisReleaseSpinLock(&PGPnetDriver->general_lock);
				return packet;
			}
			pgpPacket = next;
		} while (pgpPacket != *packet_list);
	}
	
	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
	
	return NULL;

}


VOID PGPCopyPacketToBlock(
		PNDIS_PACKET	packet,
		PUCHAR			block,
		PUINT			BytesCopied)
{

	UINT			numNdisBuffer;
	PNDIS_BUFFER	CurrentBuffer;
	PVOID			CurrentBlock;
	UINT			CurrentLength;

	DBG_FUNC("PGPCopyPacketToBlock")

	*BytesCopied = 0;
	NdisQueryPacket(packet, NULL, &numNdisBuffer, &CurrentBuffer, NULL);

	if (numNdisBuffer == 0)
		return;

	NdisQueryBuffer(CurrentBuffer, &CurrentBlock, &CurrentLength);

	while(CurrentBuffer != NULL)
	{
		NdisMoveMemory(block, CurrentBlock, CurrentLength);
		block = (PUCHAR)block + CurrentLength;
		*BytesCopied = *BytesCopied + CurrentLength;


		NdisGetNextBuffer(CurrentBuffer, &CurrentBuffer);
		if (CurrentBuffer == NULL)
			break;
		NdisQueryBuffer(CurrentBuffer, &CurrentBlock, &CurrentLength);
	}
}

VOID PGPnetAdjustTransferCompletePacket(PGPnetPacket* pgpPacket)
{
	PGPCopyPacketToBlock(pgpPacket->xformPacket, pgpPacket->xformBlock, &pgpPacket->xformBlockLen);
	NdisMoveMemory(pgpPacket->srcBlock + ETHER_HEADER_SIZE, pgpPacket->xformBlock, pgpPacket->xformBlockLen);
	pgpPacket->srcBlockLen = pgpPacket->xformBlockLen + ETHER_HEADER_SIZE;
	pgpPacket->xformBlockLen = 0;
}

#ifdef CHICAGO
#define NdisAdjustBufferLength(NdisBuffer, NewLength) ((NdisBuffer)->Length = NewLength)
#endif

VOID PGPnetAdjustXformPackets(PGPnetPacket* packet)
{
	PGPnetPacket *pIter = packet;

	while (pIter) {
		PGPnetAdjustXformPacket(pIter);
		pIter = pIter->link;
	}
}

VOID PGPnetAdjustXformPacket(PGPnetPacket* packet)
{
	PNDIS_BUFFER ndisBuffer;

	NdisUnchainBufferAtFront(packet->xformPacket, &ndisBuffer);
	NdisAdjustBufferLength(ndisBuffer, packet->xformBlockLen);
	NdisChainBufferAtFront(packet->xformPacket, ndisBuffer);
}

VOID PGPnetAdjustSrcPacket(PGPnetPacket* packet, USHORT len)
{
	PNDIS_BUFFER ndisBuffer;

	NdisUnchainBufferAtFront(packet->srcPacket, &ndisBuffer);
	NdisAdjustBufferLength(ndisBuffer, len);
	NdisChainBufferAtFront(packet->srcPacket, ndisBuffer);
}

VOID CopySrcBlockToXformBlock(PGPnetPacket *packet)
{
	if (packet->srcBlockLen)
		NdisMoveMemory(packet->xformBlock, packet->srcBlock, packet->srcBlockLen);

	packet->xformBlockLen = packet->srcBlockLen;
}

/*******************************************************************************
 *******************************************************************************
 PGPnetPacketHead Related functions
 *******************************************************************************
 *******************************************************************************/

VOID PacketHeadEnqueue(
    PPGPnetPacketHead *packet_head_list,
    PPGPnetPacketHead packetHead)
{
    NdisAcquireSpinLock(&PGPnetDriver->general_lock);

    if (*packet_head_list == (PPGPnetPacketHead) NULL) {
        packetHead->next = packetHead;
    } else {
        packetHead->next = (*packet_head_list)->next;
        (*packet_head_list)->next = packetHead;
    }
    *packet_head_list = packetHead;

    NdisReleaseSpinLock(&PGPnetDriver->general_lock);
}

PPGPnetPacketHead PacketHeadDequeue(
    PPGPnetPacketHead *packet_head_list)
{
	PPGPnetPacketHead packetHead;

    NdisAcquireSpinLock(&PGPnetDriver->general_lock);

    if (*packet_head_list == (PPGPnetPacketHead) NULL) {
        packetHead = (PPGPnetPacketHead) NULL;
    } else {
		packetHead = (*packet_head_list)->next;
        if (packetHead == *packet_head_list) {
            *packet_head_list = (PPGPnetPacketHead) NULL;
        } else {
            (*packet_head_list)->next = packetHead->next;
        }
    }

    NdisReleaseSpinLock(&PGPnetDriver->general_lock);

    return packetHead;
}

VOID PacketHeadListRemove(
		PPGPnetPacketHead	*packet_list,
		PPGPnetPacketHead	packetHead)
{
	PPGPnetPacketHead pgpPacket;

	NdisAcquireSpinLock(&PGPnetDriver->general_lock);

	if ( (pgpPacket = *packet_list) != NULL ) 
	{
		do 
		{
			PPGPnetPacketHead next = pgpPacket->next;
			if (next == packetHead) 
			{
				if (next == pgpPacket)
					*packet_list = NULL;
				else
				{
					pgpPacket->next = next->next;
					if (*packet_list == next)
						*packet_list = pgpPacket;
				}
				NdisReleaseSpinLock(&PGPnetDriver->general_lock);
				return;
			}
			pgpPacket = next;
		} while (pgpPacket != *packet_list);
	}
	
	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
	
	return;

}

PPGPnetPacketHead PacketHeadListQuery(
	PPGPnetPacketHead *packet_head_list,
	USHORT		 id,
	PGPUInt32		 ipAddress)
{
	PPGPnetPacketHead packetHead;

	NdisAcquireSpinLock(&PGPnetDriver->general_lock);

	if ( (packetHead = *packet_head_list) != NULL )
	{
		do
		{
			PPGPnetPacketHead next = packetHead->next;
			if ( (next->ipId == id) && (next->ipAddress == ipAddress) )
			{
				//if (next == packetHead)
				//{
					NdisReleaseSpinLock(&PGPnetDriver->general_lock);
					return next;
				//}
			}
			packetHead = next;
		} while (packetHead != *packet_head_list);
	}
	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
	return NULL;
}

PPGPnetPacketHead
PGPNdisPacketHeadAlloc(VOID)
{
    PPGPnetPacketHead packetHead;

	DBG_FUNC("PGPNdisPacketHeadAlloc")

	packetHead = (PPGPnetPacketHead) PacketHeadDequeue( &PGPnetDriver->free_packet_head_list);

	if (packetHead == (PPGPnetPacketHead) NULL) {
		DBG_PRINT(("Problem: PreAllocated PGPPacketHead Exhausted: Collecting Fragments\n"););

/*
#ifndef CFG_ADAPTER
		// Start to collect overdue fragments
		for (PGPUInt32 i = 0; i < PGPnetFilterDriver->PGPnetAdapterInstanceCount; i ++)
		{
			PGPnetFilterDriver->PGPnetAdapterInstance[i]->FragmentCollection();
		}

		packetHead = (PPGPnetPacketHead) PacketHeadDequeue( &PGPnetDriver->free_packet_head_list);
		if (packetHead == (PPGPnetPacketHead) NULL) {
			DBG_PRINT(("Problem: PreAllocated PGPPacketHead Exhausted\n"););
			return NULL;
		}
#else
*/
		return NULL;
/*
#endif
*/

	}

	NdisZeroMemory(packetHead, sizeof(PGPnetPacketHead));

    return packetHead;
}

VOID PGPNdisPacketHeadFreeList(
		PPGPnetPacketHead packetHead)
{

	DBG_FUNC("PGPNdisPacketHeadFreeList")

	PGPnetPacket* packet;

	DBG_ENTER();

	packet = packetHead->link;

	PGPNdisPacketFreeList(packet);

	DBG_LEAVE(0);
}

VOID PGPNdisPacketFreeList(
		PGPnetPacket* packet)
{

	DBG_FUNC("PGPNdisPacketFreeList")

	PGPnetPacket* next;

	DBG_ENTER();

	while (packet != NULL)
	{
		next = packet->link;
		FreePGPnetPacket(packet);
		packet = next;
			
	}

	DBG_LEAVE(0);
}

VOID PGPNdisPacketHeadFree(
		PPGPnetPacketHead packetHead)
{

	DBG_FUNC("PGPNdisPacketHeadFree")

	DBG_ENTER();

	packetHead->timeOut = 0;
    PacketHeadEnqueue(&PGPnetDriver->free_packet_head_list, packetHead);

	DBG_LEAVE(0);
}

VOID AppendPGPNdisPacket(
	PPGPnetPacketHead packetHead,
	PGPnetPacket* pgpPacket)
{
	PGPnetPacket* next;

	NdisAcquireSpinLock(&PGPnetDriver->general_lock);

	next = packetHead->link;

	if (next == NULL)
		packetHead->link = pgpPacket;

	while (next != NULL)
	{
		if (next->link == NULL)
		{
			next->link = pgpPacket;
			break;
		}

		next = next->link;
	}

	pgpPacket->link = NULL;

	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
}

VOID AdjustPGPIPsecBuffer(
	PPGPnetPacketHead packetHead
	)
{
	PGPnetPacket* firstPacket;
	PGPnetPacket* nextPacket;

	NdisAcquireSpinLock(&PGPnetDriver->general_lock);

	firstPacket = packetHead->link;

	nextPacket = NULL;
	if (firstPacket != NULL)
	{
		firstPacket->pSrcIPsecBuffer->data = firstPacket->srcBlock + ETHER_HEADER_SIZE;
		firstPacket->pXformIPsecBuffer->data = firstPacket->xformBlock + ETHER_HEADER_SIZE;
		nextPacket = firstPacket->link;
		if (nextPacket != NULL) {
			firstPacket->pSrcIPsecBuffer->next = nextPacket->pSrcIPsecBuffer;
			firstPacket->pXformIPsecBuffer->next = nextPacket->pXformIPsecBuffer;
		} else {
			firstPacket->pSrcIPsecBuffer->next = NULL;
			firstPacket->pXformIPsecBuffer->next = NULL;
		}
	}

	while (nextPacket != NULL)
	{
		nextPacket->pSrcIPsecBuffer->data = nextPacket->srcBlock + ETHER_HEADER_SIZE;
		firstPacket->pXformIPsecBuffer->data = nextPacket->xformBlock + ETHER_HEADER_SIZE;
		if (nextPacket->link != NULL) {
			nextPacket->pSrcIPsecBuffer->next = nextPacket->link->pSrcIPsecBuffer;
			nextPacket->pXformIPsecBuffer->next = nextPacket->link->pXformIPsecBuffer;
		} else {
			nextPacket->pSrcIPsecBuffer->next = NULL;
			nextPacket->pXformIPsecBuffer->next = NULL;
		}
		nextPacket = nextPacket->link;
	}

	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
}