vpnsupport.c

vc环境下的pgp源码

			}
			pgpPacket = next;
		} while (pgpPacket != *packet_list);
	}
	
	NdisReleaseSpinLock(&adapter->general_lock);
	
	return;

}

PPGPNDIS_PACKET_HEAD PacketHeadListQuery(
	PVPN_ADAPTER adapter,
	PPGPNDIS_PACKET_HEAD *packet_head_list,
	USHORT		 id,
	ULONG		 ipAddress)
{
	PPGPNDIS_PACKET_HEAD packetHead;

	NdisAcquireSpinLock(&adapter->general_lock);

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

PPGPNDIS_PACKET_HEAD PGPNdisPacketHeadAlloc(
    PNDIS_STATUS status,
    PVPN_ADAPTER adapter)
{
    PPGPNDIS_PACKET_HEAD packetHead;

	DBG_FUNC("PGPNdisPacketHeadAlloc")

	packetHead = (PPGPNDIS_PACKET_HEAD) PacketHeadDequeue( adapter, &adapter->free_packet_head_list);

	if (packetHead == (PPGPNDIS_PACKET_HEAD) NULL) {
		DBG_PRINT(("!!!!! FATAL!!! PreAllocated PGPPacketHead Exhausted!!!\n"););
		ASSERT(FALSE);
		*status = NDIS_STATUS_RESOURCES;
		return NULL;
	}

	NdisZeroMemory(packetHead, sizeof(PGPNDIS_PACKET_HEAD));

	*status = NDIS_STATUS_SUCCESS;
	
    return packetHead;
}

VOID PGPNdisPacketHeadFreeList(
		PVPN_ADAPTER adapter,
		PPGPNDIS_PACKET_HEAD packetHead,
		BOOLEAN outgoing)
{

	DBG_FUNC("PGPNdisPacketHeadFreeList")

	PPGPNDIS_PACKET packet, next;

	DBG_ENTER();

	packet = packetHead->link;

	while (packet != NULL)
	{
		next = packet->link;
		if (outgoing)
			PGPNdisPacketFree(adapter, packet);
		else
			PGPNdisPacketFreeSrcPacket(adapter, packet);

		packet = next;
			
	}

	DBG_LEAVE(0);
}

VOID PGPNdisPacketFreeList(
		PVPN_ADAPTER adapter,
		PPGPNDIS_PACKET packet,
		BOOLEAN outgoing)
{

	DBG_FUNC("PGPNdisPacketFreeList")

	PPGPNDIS_PACKET next;

	DBG_ENTER();

	while (packet != NULL)
	{
		next = packet->link;
		if (outgoing)
			PGPNdisPacketFree(adapter, packet);
		else
			PGPNdisPacketFreeSrcPacket(adapter, packet);

		packet = next;
			
	}

	DBG_LEAVE(0);
}

VOID PGPNdisPacketHeadFree(
		PVPN_ADAPTER adapter,
		PPGPNDIS_PACKET_HEAD packetHead)
{

	DBG_FUNC("PGPNdisPacketHeadFree")

	DBG_ENTER();

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

	DBG_LEAVE(0);
}

VOID InsertPGPNdisPacket(
	PVPN_ADAPTER adapter,
	PPGPNDIS_PACKET_HEAD packetHead,
	PPGPNDIS_PACKET pgpPacket)
{
	PPGPNDIS_PACKET next;

	NdisAcquireSpinLock(&adapter->general_lock);

	next = packetHead->link;

	if (next == NULL)
	{
		packetHead->link = pgpPacket;
		pgpPacket->link = NULL;
		NdisReleaseSpinLock(&adapter->general_lock);
		return;
	}
	

	while (next != NULL)
	{
		if (next->link == NULL)
		{
			next->link = pgpPacket;
			pgpPacket->link = NULL;
			NdisReleaseSpinLock(&adapter->general_lock);
			return;
		}
		else if (pgpPacket->offset < next->link->offset)
		{
			pgpPacket->link = next->link;
			next->link = pgpPacket;
			NdisReleaseSpinLock(&adapter->general_lock);
			return;
		}

		next = next->link;

	}
	NdisReleaseSpinLock(&adapter->general_lock);

}

VOID AppendPGPNdisPacket(
	PVPN_ADAPTER adapter,
	PPGPNDIS_PACKET_HEAD packetHead,
	PPGPNDIS_PACKET pgpPacket)
{
	PPGPNDIS_PACKET next;

	NdisAcquireSpinLock(&adapter->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(&adapter->general_lock);
}

void PacketHeadCollect(
		PVPN_ADAPTER			adapter,
		PPGPNDIS_PACKET_HEAD	*packet_list,
		BOOLEAN					outgoing)
{
	DBG_FUNC("PacketHeadCollect")

	PPGPNDIS_PACKET_HEAD current;
	PPGPNDIS_PACKET_HEAD next;
	
	BOOLEAN done = FALSE;

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

	NdisAcquireSpinLock(&adapter->general_lock);

	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(adapter, next, outgoing);
			PGPNdisPacketHeadFree(adapter, next);
		}
		else
			current = next;
	}while ( (next != *packet_list) && !done );

	NdisReleaseSpinLock(&adapter->general_lock);
}

VOID FragmentCollection(
    PVOID SystemArg1,
    PVOID Context,
    PVOID SystemArg2,
    PVOID SystemArg3)
{
// Hard coded timeout, to be changed to an adaptive value.
#define FRAGMENTATION_TIMEOUT 15000

	DBG_FUNC("FragmentCollection")

	PVPN_ADAPTER adapter = (PVPN_ADAPTER)Context;

	DBG_ENTER();

	PacketHeadCollect(adapter, &adapter->outgoing_packet_head_list, TRUE);
	PacketHeadCollect(adapter, &adapter->incoming_packet_head_list, FALSE);
	NdisSetTimer(&adapter->collection_timer, FRAGMENTATION_TIMEOUT);

	DBG_LEAVE(0);

}

VOID IndicateReceiveClear(
		PVPN_ADAPTER adapter,
		PPGPNDIS_PACKET pgpPacket)
{
	PIP_HEADER			ip_header;
	UINT				ip_len;

	pgpPacket->HeaderBuffer = pgpPacket->xformBlock;
	pgpPacket->HeaderBufferSize = adapter->eth_hdr_len;
	pgpPacket->LookaheadBuffer = pgpPacket->xformBlock + adapter->eth_hdr_len;

	ip_header = (PIP_HEADER) ( (UCHAR*)pgpPacket->LookaheadBuffer );

    ip_len = ntohs(ip_header->ip_len);

	ProtocolIndicateReceive(adapter,
							pgpPacket->srcPacket,
							pgpPacket->HeaderBuffer,
							pgpPacket->HeaderBufferSize,
							pgpPacket->LookaheadBuffer,
							ip_len,
							ip_len);
}

NDIS_STATUS MacSendPackets(
		PVPN_ADAPTER adapter,
		PPGPNDIS_PACKET_HEAD packetHead)
{
	DBG_FUNC("MacSendPackets")

	NDIS_STATUS status = NDIS_STATUS_SUCCESS;
	NDIS_STATUS returnStatus = NDIS_STATUS_SUCCESS;

	USHORT	IPDataTotalLength;
	UCHAR	ip_prot; // Should always be 0x32?

	USHORT	offset;

	PPGPNDIS_PACKET packet, next;
	PIP_HEADER first_ip_hdr;
	PIP_HEADER ip_hdr;
	PUCHAR		first_xformBlock;
	PUCHAR		first_srcBlock;


	DBG_ENTER();

	// Get Information from the first packet.

	packet = packetHead->link;
	ASSERT(packet != NULL);

	first_srcBlock = packet->srcBlock;
	first_xformBlock = packet->xformBlock;
	first_ip_hdr = (PIP_HEADER)((UCHAR*)packet->xformBlock + ETHER_HEADER_SIZE);
	IPDataTotalLength = htons(first_ip_hdr->ip_len) - IP_HEADER_SIZE;
	ip_prot = first_ip_hdr->ip_prot;

	NdisMoveMemory(first_xformBlock, packet->srcBlock, ETHER_HEADER_SIZE);
	offset = 0;

	while (packet != NULL)
	{
		//NdisMoveMemory(packet->xformBlock, first_xformBlock, ETHER_HEADER_SIZE);
		// Wait for Damon's fix.
		// For every packet adjust the xformBlockLen, wait for Damon's fix
		packet->HeaderBuffer = packet->xformBlock;
		packet->HeaderBufferSize = adapter->eth_hdr_len;
		NdisMoveMemory(packet->xformBlock, first_xformBlock, ETHER_HEADER_SIZE);

		//packet->xformBlockLen -= ETHER_HEADER_SIZE + IP_HEADER_SIZE;
		NdisMoveMemory(packet->xformBlock, first_srcBlock, ETHER_HEADER_SIZE);

		ip_hdr = (PIP_HEADER)((UCHAR*)packet->xformBlock + ETHER_HEADER_SIZE);

		NdisMoveMemory(ip_hdr, first_ip_hdr, IP_HEADER_SIZE);

		ip_hdr->ip_len = htons(packet->xformBlockLen - ETHER_HEADER_SIZE);
		ip_hdr->ip_foff = htons(offset >> 3);
		if (packet->lastXformBlock)
			ip_hdr->ip_foff = ~(IP_MF) & ip_hdr->ip_foff;
		else
			ip_hdr->ip_foff = IP_MF | ip_hdr->ip_foff;
		ip_hdr->ip_prot = ip_prot;
		ip_hdr->ip_chksum = 0;
		ip_hdr->ip_chksum = iphdr_cksum((USHORT*)ip_hdr);

		if (packet->firstSrcBlock)
			packet->xformBlockLen += 0;//ETHER_HEADER_SIZE;
		else
			packet->xformBlockLen += 0;//ETHER_HEADER_SIZE + IP_HEADER_SIZE;

		PGPnetAdjustPacket(packet);

		offset += htons(ip_hdr->ip_len) - IP_HEADER_SIZE;

		if (packet->lastXformBlock)
		{
			PGPNdisPacketFreeList(adapter, packet->link, TRUE);
			next = NULL;
			packet->link = NULL;
		}
		else
			next = packet->link;

		PacketEnqueue(adapter, &adapter->outgoing_multiple_ipsecpacket_list, packet);

		NdisSend(&status, adapter->NdisBindingHandleToRealMac, packet->xformPacket);
		if (status == NDIS_STATUS_PENDING)
		{
			//status = NDIS_STATUS_SUCCESS;
		}
		else
		{
			packet = PacketRemoveByXformPacket(adapter, &adapter->outgoing_multiple_ipsecpacket_list, packet->xformPacket);
			PGPNdisPacketFree(adapter, packet);
		}
		if (packet->lastSrcBlock)
			returnStatus = status;


		packet = next;
		

	}

	PacketHeadListRemove(adapter, &adapter->outgoing_packet_head_list, packetHead);
	PGPNdisPacketHeadFree(adapter, packetHead);

	adapter->SendPackets++;

	DBG_LEAVE(returnStatus);
	return returnStatus;
}

VOID ProtocolIndicatePackets(
		PVPN_ADAPTER adapter,
		PPGPNDIS_PACKET_HEAD packetHead)
{
	DBG_FUNC("ProtocolIndicatePackets")

	NDIS_STATUS status = NDIS_STATUS_SUCCESS;

	USHORT	IPDataTotalLength;
	UCHAR	ip_prot; // Should always be 0x32?

	USHORT	offset;

	USHORT ip_len;

	PPGPNDIS_PACKET packet, next;
	PIP_HEADER first_ip_hdr;
	PIP_HEADER ip_hdr;
	PUCHAR		first_xformBlock;
	PUCHAR		first_srcBlock;


	DBG_ENTER();

	packet = packetHead->link;
	ASSERT(packet != NULL);

	first_srcBlock = packet->srcBlock;
	first_xformBlock = packet->xformBlock;
	first_ip_hdr = (PIP_HEADER)((UCHAR*)packet->xformBlock + ETHER_HEADER_SIZE);
	IPDataTotalLength = htons(first_ip_hdr->ip_len) - IP_HEADER_SIZE;
	ip_prot = first_ip_hdr->ip_prot;

	offset = 0;

	while (packet != NULL)
	{
		//packet->xformBlockLen -= ETHER_HEADER_SIZE + IP_HEADER_SIZE;

		packet->HeaderBuffer = packet->xformBlock;
		packet->HeaderBufferSize = adapter->eth_hdr_len;
		NdisMoveMemory(packet->xformBlock, first_srcBlock, packet->HeaderBufferSize);

		packet->LookaheadBuffer = packet->xformBlock + adapter->eth_hdr_len;

		ip_hdr = (PIP_HEADER)((UCHAR*)packet->xformBlock + ETHER_HEADER_SIZE);

		NdisMoveMemory(ip_hdr, first_ip_hdr, IP_HEADER_SIZE);

		ip_hdr->ip_len = htons(packet->xformBlockLen - ETHER_HEADER_SIZE);
		ip_hdr->ip_foff = htons(offset >> 3);
		if (packet->lastXformBlock)
			ip_hdr->ip_foff = ~(IP_MF) & ip_hdr->ip_foff;
		else
			ip_hdr->ip_foff = IP_MF | ip_hdr->ip_foff;
		ip_hdr->ip_prot = ip_prot;
		ip_hdr->ip_chksum = 0;
		ip_hdr->ip_chksum = iphdr_cksum((USHORT*)ip_hdr);

		if (packet->firstSrcBlock)
			packet->xformBlockLen += 0;//ETHER_HEADER_SIZE;
		else
			packet->xformBlockLen += 0; //ETHER_HEADER_SIZE + IP_HEADER_SIZE;

	    ip_len = ntohs(ip_hdr->ip_len);

		offset += ip_len - IP_HEADER_SIZE;
		if (packet->lastXformBlock)
		{
			PGPNdisPacketFreeList(adapter, packet->link, FALSE);
			next = NULL;
			packet->link = NULL;
		}
		else
			next = packet->link;

	
		ProtocolIndicateReceive(adapter,
							packet->srcPacket,
							packet->HeaderBuffer,
							packet->HeaderBufferSize,
							packet->LookaheadBuffer,
							ip_len,
							ip_len);

		ProtocolIndicateReceiveComplete(adapter);

		packet = next;


	}

	PGPNdisPacketHeadFreeList(adapter, packetHead, FALSE);
	PacketHeadListRemove(adapter, &adapter->incoming_packet_head_list, packetHead);
	PGPNdisPacketHeadFree(adapter, packetHead);

	DBG_LEAVE(0);
}

BOOLEAN BroadcastEthernetAddress(UCHAR* eth_dstAddress)
{
	int i;
	for (i = 0; i < 6; i ++)
	{
		if (eth_dstAddress[i] != 0xFF)
			return FALSE;
	}

	return TRUE;
}