cpgpnetippacket.cpp

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

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

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

#include "pgpnetBase.h"

#include "pgpNetIPdef.h"
#include "pgpnetIpHelper.h"

#include "CPGPnetIPPacket.h"

extern "C"
{
#include "stdio.h"
}
/******************************************************************************
Ethernet Header
******************************************************************************/
CPGPnetEthernetHeader::CPGPnetEthernetHeader()
{
	NdisZeroMemory(&ethernet_header, sizeof(ethernet_header));
}

CPGPnetEthernetHeader::~CPGPnetEthernetHeader()
{
}

PGPBoolean CPGPnetEthernetHeader::IsIP()
{
	return (GetEthernetProtocolNet() == IPPROT_NET);
}

PGPBoolean CPGPnetEthernetHeader::IsARP()
{
	return (GetEthernetProtocolNet() == ARPPROT_NET);
}

PGPBoolean CPGPnetEthernetHeader::IsBroadcast()
{
	return BroadcastEthernetAddress(GetDstAddress());
}

unsigned char* CPGPnetEthernetHeader::GetSrcAddress()
{
	return &ethernet_header.eth_srcAddress[0];
}

unsigned char* CPGPnetEthernetHeader::GetDstAddress()
{
	return &ethernet_header.eth_dstAddress[0];
}

unsigned short CPGPnetEthernetHeader::GetEthernetProtocolNet()
{
	return *((PUSHORT)(&ethernet_header.eth_protocolType[0]));
}

unsigned short CPGPnetEthernetHeader::GetEthernetProtocol()
{
	return ntohs(GetEthernetProtocolNet());
}

void CPGPnetEthernetHeader::SetIP()
{
	SetEthernetProtocolNet(IPPROT_NET);
}
void CPGPnetEthernetHeader::SetARP()
{
	SetEthernetProtocolNet(ARPPROT_NET);
}

void CPGPnetEthernetHeader::SetBroadcast()
{
	for (int i = 0; i<6; i++)
		ethernet_header.eth_dstAddress[i] = 0xFF;
}

void CPGPnetEthernetHeader::SetSrcAddress(unsigned char* srcAddress)
{
	NdisMoveMemory(&ethernet_header.eth_srcAddress[0], srcAddress, 6);
}

void CPGPnetEthernetHeader::SetDstAddress(unsigned char* dstAddress)
{
	NdisMoveMemory(&ethernet_header.eth_dstAddress[0], dstAddress, 6);
}

void CPGPnetEthernetHeader::SetEthernetProtocol(unsigned short protocol)
{
	SetEthernetProtocolNet(ntohs(protocol));
}

void CPGPnetEthernetHeader::SetEthernetProtocolNet(unsigned short protocolNet)
{
	unsigned short* ethernet_protocol = (PUSHORT)(&ethernet_header.eth_protocolType[0]);
	*ethernet_protocol = protocolNet;
}

unsigned short CPGPnetEthernetHeader::CopyToPlainBuffer(PVOID buffer)
{
	NdisMoveMemory(buffer, &ethernet_header, sizeof(ethernet_header));

	return sizeof(ethernet_header);
}

/******************************************************************************
IP Header
******************************************************************************/

CPGPnetIPHeader::CPGPnetIPHeader()
{
	ip_header.ip_versionandheaderlength = default_versionandheaderlength;
	ip_header.ip_tos = default_tos;
	ip_header.ip_foff = default_foff;
	ip_header.ip_ttl = default_ttl;

	ip_header.ip_len = sizeof(ip_header);
	ip_header.ip_id = 0;
	ip_header.ip_prot = 0;
	ip_header.ip_chksum = 0;
	ip_header.ip_src = 0;
	ip_header.ip_dest = 0;

}

CPGPnetIPHeader::~CPGPnetIPHeader()
{
}

PGPBoolean CPGPnetIPHeader::IsTCP()
{
	return (ip_header.ip_prot == PROTOCOL_TCP);
}

PGPBoolean CPGPnetIPHeader::IsUDP()
{
	return (ip_header.ip_prot == PROTOCOL_UDP);
}

PGPBoolean CPGPnetIPHeader::IsICMP()
{
	return (ip_header.ip_prot == PROTOCOL_ICMP);
}

unsigned char CPGPnetIPHeader::GetIPProtocol()
{
	return ip_header.ip_prot;
}

PGPBoolean CPGPnetIPHeader::IsBroadcast()
{
	return ip_header.ip_dest == 0xFFFFFFFF;
}

PGPUInt32 CPGPnetIPHeader::GetSrcAddress()
{
	return ntohl(GetSrcAddressNet());
}

PGPUInt32 CPGPnetIPHeader::GetDstAddress()
{
	return ntohl(GetDstAddressNet());
}

PGPUInt32 CPGPnetIPHeader::GetSrcAddressNet()
{
	return ip_header.ip_src;
}

PGPUInt32 CPGPnetIPHeader::GetDstAddressNet()
{
	return ip_header.ip_dest;
}

void CPGPnetIPHeader::SetTCP()
{
	ip_header.ip_prot = PROTOCOL_TCP;
}

void CPGPnetIPHeader::SetUDP()
{
	ip_header.ip_prot = PROTOCOL_UDP;
}

void CPGPnetIPHeader::SetICMP()
{
	ip_header.ip_prot = PROTOCOL_ICMP;
}

void CPGPnetIPHeader::SetIPProtocol(unsigned char ip_protocol)
{
	ip_header.ip_prot = ip_protocol;
}

void CPGPnetIPHeader::SetBroadcast()
{
	SetDstAddress(0xffffffff);
}

void CPGPnetIPHeader::SetSrcAddress(PGPUInt32 ip_address)
{
	SetSrcAddressNet(ntohl(ip_address));
}

void CPGPnetIPHeader::SetDstAddress(PGPUInt32 ip_address)
{
	SetDstAddressNet(ntohl(ip_address));
}

void CPGPnetIPHeader::SetSrcAddressNet(PGPUInt32 ip_address_net)
{
	ip_header.ip_src = ip_address_net;
}

void CPGPnetIPHeader::SetDstAddressNet(PGPUInt32 ip_address_net)
{
	ip_header.ip_dest = ip_address_net;
}

unsigned short CPGPnetIPHeader::GetId()
{
	return ntohs(GetIdNet());
}

unsigned short CPGPnetIPHeader::GetIdNet()
{
	return ip_header.ip_id;
}

void CPGPnetIPHeader::SetId(unsigned short ip_id)
{
	SetIdNet(ntohs(ip_id));
}

void CPGPnetIPHeader::SetIdNet(unsigned short ip_id_net)
{
	ip_header.ip_id = ip_id_net;
}

unsigned short CPGPnetIPHeader::GetChecksum()
{
	return ip_header.ip_chksum;
}

void CPGPnetIPHeader::SetChecksum(unsigned short checksum)
{
	ip_header.ip_chksum = checksum;
}

unsigned short CPGPnetIPHeader::GetIPLength()
{
	return ntohs(ip_header.ip_len);
}

void CPGPnetIPHeader::SetIPLength(unsigned short ip_len)
{
	ip_header.ip_len = ntohs(ip_len);
}

void CPGPnetIPHeader::UpdateChecksum()
{
	SetChecksum(HeaderChecksum((USHORT*)&ip_header, TYPE_IP));
}

unsigned short CPGPnetIPHeader::CopyToPlainBuffer(PVOID buffer)
{
	PUCHAR working_buffer = (PUCHAR)buffer;
	unsigned short offset = 0;

	offset = ethernet_header.CopyToPlainBuffer(buffer);
	working_buffer = working_buffer + offset;

	NdisMoveMemory(working_buffer, &ip_header, sizeof(ip_header));
	offset += sizeof(ip_header);

	return offset;

}
/******************************************************************************
UDP Header
******************************************************************************/
CPGPnetUDPHeader::CPGPnetUDPHeader()
{
	NdisZeroMemory(&udp_header, sizeof(udp_header));
	udp_header.msg_len = ntohs(8);
}

CPGPnetUDPHeader::~CPGPnetUDPHeader()
{
}

PGPBoolean CPGPnetUDPHeader::IsBOOTP()
{
	return (IsBOOTPClient() || IsBOOTPServer());
}

PGPBoolean CPGPnetUDPHeader::IsBOOTPClient()
{
	return (udp_header.source_port == UDP_PORT_BOOTPC_NET);
}

PGPBoolean CPGPnetUDPHeader::IsBOOTPServer()
{
	return (udp_header.source_port == UDP_PORT_BOOTPS_NET);
}

unsigned short CPGPnetUDPHeader::GetUDPLen()
{
	return ntohs(udp_header.msg_len);
}

unsigned short CPGPnetUDPHeader::GetSrcPort()
{
	return ntohs(GetSrcPortNet());
}

unsigned short CPGPnetUDPHeader::GetDstPort()
{
	return ntohs(GetDstPortNet());
}

unsigned short CPGPnetUDPHeader::GetSrcPortNet()
{
	return udp_header.source_port;
}

unsigned short CPGPnetUDPHeader::GetDstPortNet()
{
	return udp_header.dest_port;
}

unsigned short CPGPnetUDPHeader::GetChecksum()
{
	return udp_header.checksum;
}

void CPGPnetUDPHeader::SetUDPLen(unsigned short udp_len)
{
	udp_header.msg_len = ntohs(udp_len);
}

void CPGPnetUDPHeader::SetSrcPort(unsigned short port)
{
	SetSrcPortNet(ntohs(port));
}

void CPGPnetUDPHeader::SetDstPort(unsigned short port)
{
	SetDstPortNet(ntohs(port));
}

void CPGPnetUDPHeader::SetSrcPortNet(unsigned short port_net)
{
	udp_header.source_port = port_net;
}

void CPGPnetUDPHeader::SetDstPortNet(unsigned short port_net)
{
	udp_header.dest_port = port_net;
}

void CPGPnetUDPHeader::SetChecksum(unsigned short checksum)
{
	udp_header.checksum = checksum;
}

void CPGPnetUDPHeader::UpdateChecksum()
{
	SetChecksum(0);
}

unsigned short CPGPnetUDPHeader::CopyToPlainBuffer(PVOID buffer)
{
	PUCHAR working_buffer = (PUCHAR)buffer;
	unsigned short offset = 0;

	offset = ip_header.CopyToPlainBuffer(buffer);
	working_buffer = working_buffer + offset;

	NdisMoveMemory(working_buffer, &udp_header, sizeof(udp_header));
	offset += sizeof(udp_header);

	return offset;

}

/******************************************************************************
DHCP Packet
******************************************************************************/

CPGPnetDHCPPacket::CPGPnetDHCPPacket()
{
	// DHCP Option
	NdisZeroMemory(&OptionField, sizeof(OptionField));
	eooPos = 0;
	OptionField[eooPos] = CODE_END_OPTION;

	// DHCP Header
	NdisZeroMemory(&dhcp_header, sizeof(dhcp_header));

	// UDP ???
}

CPGPnetDHCPPacket::~CPGPnetDHCPPacket()
{
}

CPGPnetDHCPPacket::CPGPnetDHCPPacket(PVOID block, UINT block_len)
{
	if (block_len > sizeof(dhcp_header))
	{
		NdisMoveMemory(&dhcp_header, block, sizeof(dhcp_header));

		NdisMoveMemory(&OptionField, (PCHAR)block + sizeof(DHCP_HEADER), block_len - sizeof(DHCP_HEADER));
	}
}

PGPUInt32 CPGPnetDHCPPacket::GetClientIPAddress()
{
	return htonl(dhcp_header.ciaddr);
}

PGPUInt32 CPGPnetDHCPPacket::GetYourIPAddress()
{
	return htonl(dhcp_header.yiaddr);
}