cpgpnetfilteradapter.cpp

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

	if (psize < 60)
		psize = 60;

	PGPnetFilterDriver->cfgReceiveHandler(PGPnetFilterDriver->cfgAdapterHandle,
					this,
					pgpnetPacket->HeaderBuffer,
					pgpnetPacket->HeaderBufferSize,
					pgpnetPacket->LookaheadBuffer,
					psize,
					psize);

	DBG_LEAVE(0);

	return NDIS_STATUS_SUCCESS;
}

NDIS_STATUS CPGPnetFilterAdapter::IndicateCfgPacketComplete()
{
	DBG_FUNC("CPGPnetFilterAdapter::IndicateCfgPacketComplete")

	DBG_ENTER();

	PGPnetFilterDriver->cfgReceiveCompleteHandler(PGPnetFilterDriver->cfgAdapterHandle);

	DBG_LEAVE(0);

	return NDIS_STATUS_SUCCESS;
}

NDIS_STATUS CPGPnetFilterAdapter::ProtocolReceive(
					NDIS_HANDLE      MacReceiveContext,
					PVOID            HeaderBuffer,
					UINT             HeaderBufferSize,
				    PVOID            LookAheadBuffer,
					UINT             LookAheadBufferSize,
					UINT             PacketSize
					)
{ 
	DBG_FUNC("CPGPnetFilterAdapter::ProtocolReceive")

	NDIS_STATUS		status;
	PGPnetPacket*	pgpnetPacket;
	UINT			BytesTransferred;

	DBG_ENTER();

	do
	{
		if ( (LookAheadBufferSize > MAX_ETHER_FRAME_SIZE - ETHER_HEADER_SIZE) ||
			(PacketSize > MAX_ETHER_FRAME_SIZE - ETHER_HEADER_SIZE) )
		{
			status = NDIS_STATUS_INVALID_PACKET;
			break;
		}

		if (MaximumFrameSize == MAX_ETHER_FRAME_SIZE - ETHER_HEADER_SIZE)
			status = NDIS_STATUS_SUCCESS;
		else
			status = NDIS_STATUS_SUCCESS;

		pgpnetPacket = AllocatePGPnetPacket();
		if (pgpnetPacket == NULL)
		{
			status = NDIS_STATUS_RESOURCES;
			break;
		}

		if (HeaderBuffer != NULL)
			NdisMoveMemory(pgpnetPacket->srcBlock, HeaderBuffer, ETHER_HEADER_SIZE);

		pgpnetPacket->HeaderBuffer = pgpnetPacket->srcBlock;
		pgpnetPacket->HeaderBufferSize = ETHER_HEADER_SIZE;
		pgpnetPacket->LookaheadBuffer = pgpnetPacket->srcBlock + ETHER_HEADER_SIZE;

		if (LookAheadBufferSize >= PacketSize)
		{
			NdisMoveMemory(pgpnetPacket->LookaheadBuffer, LookAheadBuffer, PacketSize);
			pgpnetPacket->srcBlockLen = PacketSize + ETHER_HEADER_SIZE;
			status = NDIS_STATUS_SUCCESS;
			PacketEnqueue(&incoming_indicateComplete_wait_list, pgpnetPacket);
		}
		else
		{
			// Adjust xform packet to the exact size of incoming packet minus ether header
			pgpnetPacket->xformBlockLen = PacketSize;
			PGPnetAdjustXformPacket(pgpnetPacket);

			PacketEnqueue(&incoming_ipsectransferComplete_wait_list, pgpnetPacket);

			NdisTransferData(&status, NdisBindingHandleToRealAdapter, MacReceiveContext, 0,
				PacketSize, pgpnetPacket->xformPacket, &BytesTransferred);

			if (status == NDIS_STATUS_PENDING) {
				status = NDIS_STATUS_SUCCESS;
				break;
			}

			ASSERT(BytesTransferred == PacketSize);

			pgpnetPacket =  PacketRemoveByXformPacket(&incoming_ipsectransferComplete_wait_list, pgpnetPacket->xformPacket);

			if (status == NDIS_STATUS_SUCCESS) {
				PGPnetAdjustTransferCompletePacket(pgpnetPacket);
				PacketEnqueue(&incoming_indicateComplete_wait_list, pgpnetPacket);
			}
			else {
				FreePGPnetPacket(pgpnetPacket);
			}
		}

	} while (0);

	DBG_LEAVE(status);

	return status;
}

VOID CPGPnetFilterAdapter::ProtocolReceiveComplete()
{
	DBG_FUNC("CPGPnetFilterAdapter::ProtocolReceiveComplete")

	PGPnetPacket* pgpnetPacket;
	UINT			indicated = 0;

	DBG_ENTER();

	NdisAcquireSpinLock(&AdapterLock);

	if (indicate_busy == FALSE) {
		indicate_busy = TRUE;
		NdisReleaseSpinLock(&AdapterLock);

		while ( (pgpnetPacket = PacketDequeue(&incoming_indicateComplete_wait_list)) != NULL )
		{
			TransformAndIndicate(pgpnetPacket);
		}

		NdisAcquireSpinLock(&AdapterLock);
		indicate_busy = FALSE;
	}

	NdisReleaseSpinLock(&AdapterLock);

	DBG_LEAVE(0);
}

VOID CPGPnetFilterAdapter::ProtocolTransferDataComplete(
						PNDIS_PACKET     Packet,
						NDIS_STATUS      Status,
						UINT             BytesTransferred
						)
{
	DBG_FUNC("CPGPnetAdapterMiniport:ProtocolTransferDataComplete")

	PGPnetPacket*	pgpnetPacket;

	DBG_ENTER();

	if ( (pgpnetPacket = PacketRemoveByXformPacket(&incoming_ipsectransferComplete_wait_list, Packet)) != NULL)
	{
		if (Status == NDIS_STATUS_SUCCESS) {
			PGPnetAdjustTransferCompletePacket(pgpnetPacket);
			PacketEnqueue(&incoming_indicateComplete_wait_list, pgpnetPacket);
		}
		else {
			FreePGPnetPacket(pgpnetPacket);
		}
	}
	else {
		ASSERT(FALSE);
	}

	DBG_LEAVE(Status);
}

NDIS_STATUS CPGPnetFilterAdapter::TransformAndIndicate(PGPnetPacket* pgpnetPacket)
{
	DBG_FUNC("CPGPnetFilterAdapter::TransformAndIndicate")

	NDIS_STATUS status = NDIS_STATUS_SUCCESS;

	PGPnetPacketStatus	packetStatus;
	PGPnetPMStatus		pmStatus;

	PGPBoolean			newHead = FALSE;

	DBG_ENTER();

	pgpnetPacket->HeaderBuffer = pgpnetPacket->srcBlock;
	pgpnetPacket->HeaderBufferSize = ETHER_HEADER_SIZE;
	pgpnetPacket->LookaheadBuffer = pgpnetPacket->srcBlock + ETHER_HEADER_SIZE;


	// Non IP packet, indicate
	// IP packet, assemble
	// Assemble complete, check status and do transform
	do {
		packetStatus = PGPnetFilterPacketCheck(pgpnetPacket, TRUE);

		switch (packetStatus)
		{
		case PacketDrop:
			FreePGPnetPacket(pgpnetPacket);
			status = NDIS_STATUS_NOT_ACCEPTED;
			break;

		case PacketPassthrough:
			status = IndicatePacket(pgpnetPacket);
			IndicateReceiveComplete();
			FreePGPnetPacket(pgpnetPacket);
			break;

		case PacketEncrypt:
			ASSERT(0);
			break;

		case PacketFurtherCheck:
		{

			pgpnetPacket->pSrcIPsecBuffer->data = pgpnetPacket->srcBlock + ETHER_HEADER_SIZE;
			pgpnetPacket->pSrcIPsecBuffer->dataSize = pgpnetPacket->srcBlockLen - ETHER_HEADER_SIZE;
			pgpnetPacket->ethernetAddr = pgpnetPacket->srcBlock;
			pgpnetPacket->lastSrcBlock = TRUE;
			pgpnetPacket->lastXformBlock = TRUE;
			pgpnetPacket->firstSrcBlock = TRUE;
			pgpnetPacket->firstXformBlock = TRUE;

			pmStatus = PGPnetHandleIncomingPacket(PGPnetDriver->PolicyManagerHandle, &pgpnetPacket);

			switch (pmStatus) {	
			case kPGPNetPMPacketSent:

				status = IndicatePackets(pgpnetPacket, FALSE /* not cfg */);

				break;
			case kPGPNetPMPacketWaiting:
			case kPGPNetPMPacketDrop:
				// free packets here
				PGPNdisPacketFreeList(pgpnetPacket);
				status = NDIS_STATUS_SUCCESS;
				break;
			case kPGPNetPMPacketClear:
				status = IndicatePackets(pgpnetPacket, FALSE /* not cfg */);
				break;
			case kPGPNetPMPacketForget:
				status = NDIS_STATUS_SUCCESS;
				break;
			case kPGPNetPMPacketCfg:
				status = IndicatePackets(pgpnetPacket, TRUE /* cfg */);
				break;
			default:
				ASSERT(0);
			} 
			break;
		}
		default:
			ASSERT(0);
		}

	} while (0);

	DBG_LEAVE(status);

	return status;
}

NDIS_STATUS CPGPnetFilterAdapter::IndicatePackets(PGPnetPacket *pgpNetPacket, PGPBoolean bIsCfgPacket)
{
	DBG_FUNC("CPGPnetFilterAdapter::IndicatePackets")

	NDIS_STATUS status = NDIS_STATUS_SUCCESS;

	PGPnetPacket* packet;
	PGPnetPacket* next;

	DBG_ENTER();

	packet = pgpNetPacket;

	ASSERT(packet != NULL);

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

		if (bIsCfgPacket)
		{
			IndicateCfgPacket(packet);
			IndicateCfgPacketComplete();
		}
		else
		{
			IndicatePacket(packet);
			IndicateReceiveComplete();
		}

		FreePGPnetPacket(packet);

		packet = next;
	}

	DBG_LEAVE(0);

	return status;
}

VOID CPGPnetFilterAdapter::HeadFragmentCollection(PPGPnetPacketHead	*packet_list)
{
	DBG_FUNC("CPGPnetFilterAdapter::HeadFragmentCollection")

	PPGPnetPacketHead current;
	PPGPnetPacketHead next;
	
	PGPBoolean done = FALSE;

	if ((current = *packet_list) == NULL) {	
		return;
	}

	AdapterLevelLock();

	do {
		next = current->next;
		
		next->timeOut += 1;

		if (next->timeOut > 1)
		{
			DBG_PRINT(("Caught one overdue fragment\n"););
			if (next == current) {
				*packet_list = NULL;
				done = TRUE;
			}
			else
			{
				current->next = next->next;
				if (next == *packet_list) {
					*packet_list = next->next;
					done = TRUE;
					break;
				}
			}
			PGPNdisPacketHeadFreeList(next);
			PGPNdisPacketHeadFree(next);
		}
		else
			current = next;
	}while ( (next != *packet_list) && !done );

	AdapterLevelUnlock();
}

VOID CPGPnetFilterAdapter::FragmentCollection()
{
	DBG_FUNC("CPGPnetFilterAdapter::FragmentCollection")

	DBG_ENTER();

	HeadFragmentCollection(&outgoing_local_packet_head_list);
	HeadFragmentCollection(&outgoing_cfg_packet_head_list);
	HeadFragmentCollection(&incoming_packet_head_list);

	DBG_LEAVE(0);
}


/*******************************************************************************
 *******************************************************************************
 PGPNET_LAST_FRAGMENT Related functions
 *******************************************************************************
 *******************************************************************************/

PGPnetLastFragmentList* 
LastFragmentListQuery(PGPnetLastFragmentList *list,
					  PGPUInt32 ipAddress,
					  USHORT ipId)
{
	PGPnetLastFragmentList *head;
	PGPnetLastFragmentList *last;
	
	NdisAcquireSpinLock(&PGPnetDriver->general_lock);
	
	head = list;
	last = head;
	while (head != NULL)
	{
		if ((head->ipAddress == ipAddress) &&
			(head->ipId == ipId))
			break;
		
		last = head;
		head = head->next;
	}

	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
	return head;
}

PGPnetLastFragmentList* 
LastFragmentListAdd(PGPnetLastFragmentList **list,
					PGPUInt32 ipAddress,
					USHORT ipId)
{
	PGPnetLastFragmentList *head;
	PGPnetLastFragmentList *last;
	NDIS_STATUS status;
	
	NdisAcquireSpinLock(&PGPnetDriver->general_lock);
	
	head = *list;
	last = head;
	while (head != NULL)
	{
		if ((head->ipAddress == ipAddress) &&
			(head->ipId == ipId))
			break;
		
		last = head;
		head = head->next;
	}

	if (head == NULL)
	{
		status = NdisAllocateMemory((void **) &head, 
					sizeof(PGPnetLastFragmentList), 0, 
					HighestAcceptableAddress);

		if (status != NDIS_STATUS_SUCCESS)
		{
			NdisReleaseSpinLock(&PGPnetDriver->general_lock);
			return NULL;
		}

		NdisZeroMemory(head, sizeof(PGPnetLastFragmentList));
		head->ipAddress = ipAddress;
		head->ipId = ipId;

		if (last == NULL)
			*list = head;
		else
			last->next = head;
	}

	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
	return head;
}

VOID
LastFragmentListFree(PGPnetLastFragmentList **list,
					 PGPUInt32 ipAddress,
					 USHORT ipId)
{
	PGPnetLastFragmentList *head;
	PGPnetLastFragmentList *last;
	
	NdisAcquireSpinLock(&PGPnetDriver->general_lock);
	
	head = *list;
	last = head;
	while (head != NULL)
	{
		if ((head->ipAddress == ipAddress) &&
			(head->ipId == ipId))
			break;
		
		last = head;
		head = head->next;
	}

	if (head != NULL)
	{
		if (last == head)
			*list = head->next;
		else
			last->next = head->next;
		
		NdisFreeMemory(head, sizeof(PGPnetLastFragmentList), 0);
	}

	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
	return;
}

VOID
LastFragmentListFreeAll(PGPnetLastFragmentList *list)
{
	PGPnetLastFragmentList*	fragHead;
	PGPnetLastFragmentList* fragFree;

	NdisAcquireSpinLock(&PGPnetDriver->general_lock);

	fragHead = list;
	while (fragHead != NULL)
	{
		fragFree = fragHead;
		fragHead = fragHead->next;
		NdisFreeMemory(fragFree, sizeof(PGPnetLastFragmentList), 0);
	}

	NdisReleaseSpinLock(&PGPnetDriver->general_lock);
	return;
}

CPGPnetFilterAdapter* FindFilterAdapterByIpAddress(PGPUInt32 IpAddress)
{
	UINT i;

	for (i = 0; i < PGPnetFilterDriver->PGPnetAdapterInstanceCount; i++)
	{
		if ((IpAddress == PGPnetFilterDriver->PGPnetAdapterInstance[i]->mIpAddress) && 
			(!EmptyEthernetAddress(PGPnetFilterDriver->PGPnetAdapterInstance[i]->mHardwareAddress)) )
			return PGPnetFilterDriver->PGPnetAdapterInstance[i];
	}

	return NULL;

}