cpgpnetippacket.cpp

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

PGPUInt32 CPGPnetDHCPPacket::GetServerIPAddress()
{
	return htonl(dhcp_header.siaddr);
}

unsigned char* CPGPnetDHCPPacket::GetClientEthernetAddress()
{
	return &(dhcp_header.chaddr[0]);
}

PGPUInt32 CPGPnetDHCPPacket::GetTransactionID()
{
	return dhcp_header.xid;
}

void CPGPnetDHCPPacket::SetClientIPAddress(PGPUInt32 ip_address)
{
	dhcp_header.ciaddr = htonl(ip_address);
}

void CPGPnetDHCPPacket::SetYourIPAddress(PGPUInt32 ip_address)
{
	dhcp_header.yiaddr = htonl(ip_address);
}

void CPGPnetDHCPPacket::SetServerIPAddress(PGPUInt32 ip_address)
{
	dhcp_header.siaddr = htonl(ip_address);
}

void CPGPnetDHCPPacket::SetClientEtherenetAddress(unsigned char* ethernet_address)
{
	for (int i = 0; i < 6; i++)
		dhcp_header.chaddr[i] = ethernet_address[i];
}

void CPGPnetDHCPPacket::SetTransactionID(PGPUInt32 transactionID)
{
	dhcp_header.xid = transactionID;
}

void CPGPnetDHCPPacket::BuildGenericResponse()
{
	dhcp_header.op = 0x2;			// response
	dhcp_header.htype = 0x1;		// Ethernet
	dhcp_header.hlen = 0x6;			// 6 for ethernet

	dhcp_header.secs = 0;
	dhcp_header.flags = 0;

	dhcp_header.cookie = DHCP_MAGIC_COOKIE;

	udp_header.SetSrcPortNet(UDP_PORT_BOOTPS_NET);
	udp_header.SetDstPortNet(UDP_PORT_BOOTPC_NET);
	udp_header.SetUDPLen(sizeof(DHCP_HEADER) + sizeof(UDP_HEADER));
	udp_header.SetChecksum(0);
}

void CPGPnetDHCPPacket::DecodeOptionFields()
{
	UINT i;
	UINT curPos;

	for (i = 0; i < CODE_END_OPTION; i++)
		NdisZeroMemory(&options[i], sizeof(OptionItem));

	curPos = 0;
	while (curPos < MAXIMUM_DHCP_OPTION_TOTAL_LEN)
	{
		DHCP_CODE	code;
		UINT		len;

		code = (DHCP_CODE)OptionField[curPos++];

		if (code == CODE_END_OPTION)
		{
			options[code].len = 1;
			break;
		}

		len = (UINT)OptionField[curPos++];

		options[code].len = (UINT)len;
		NdisMoveMemory(&options[code].value,
						&OptionField[curPos],
						len > MAXIMUM_DHCP_OPTION_ITEM_LEN ? MAXIMUM_DHCP_OPTION_ITEM_LEN : len);
		curPos += len;

	}
}

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

	offset = udp_header.CopyToPlainBuffer(buffer);
	working_buffer = (PUCHAR)buffer + offset;

	NdisMoveMemory(working_buffer, &dhcp_header, sizeof(dhcp_header));

	offset += sizeof(dhcp_header);
	working_buffer = (PUCHAR)buffer + offset;

	NdisMoveMemory(working_buffer, OptionField, eooPos + 1);

	offset += eooPos + 1;

	return offset;
}

DHCP_TYPE CPGPnetDHCPPacket::GetDHCPType()
{
	// DHCP TYPE always the first option?

	unsigned short opp = 0;
	DHCP_TYPE dhcpType = TYPE_INVALID;

	if (CODE_DHCP_TYPE == OptionField[opp])
		dhcpType = (DHCP_TYPE)OptionField[opp + OptionField[opp + 1] + 1];

	if (dhcpType < TYPE_DISCOVER || dhcpType >> TYPE_INVALID)
		dhcpType = TYPE_INVALID;

	return dhcpType;
}

void CPGPnetDHCPPacket::SetDHCPType(DHCP_TYPE dhcpType)
{
	OptionField[eooPos++] = CODE_DHCP_TYPE;
	OptionField[eooPos++] = 1;
	OptionField[eooPos++] = dhcpType;

	OptionField[eooPos] = CODE_END_OPTION;
}

void CPGPnetDHCPPacket::SetDHCPSubnetMask(PGPUInt32 subnetMask)
{
	PGPUInt32 *longOption;

	OptionField[eooPos++] = CODE_SUBNET_MASK;
	OptionField[eooPos++] = 4;

	longOption = (PGPUInt32*)&OptionField[eooPos];

	*longOption = htonl(subnetMask);

	eooPos += 4;

	OptionField[eooPos] = CODE_END_OPTION;

}

void CPGPnetDHCPPacket::SetDHCPDomainName(char *domainName)
{
	OptionField[eooPos++] = CODE_DOMAIN_NAME;
	OptionField[eooPos++] = strlen(domainName) + 1;

	strcpy((char*)&OptionField[eooPos], domainName);

	eooPos += strlen(domainName);

	OptionField[eooPos++] = 0;

	OptionField[eooPos] = CODE_END_OPTION;

}

void CPGPnetDHCPPacket::SetDHCPRoute(PGPUInt32 route)
{
	PGPUInt32 *longOption;

	OptionField[eooPos++] = CODE_ROUTE;
	OptionField[eooPos++] = 4;

	longOption = (PGPUInt32*)&OptionField[eooPos];

	*longOption = htonl(route);

	eooPos += 4;

	OptionField[eooPos] = CODE_END_OPTION;
}

void CPGPnetDHCPPacket::SetDHCPWINSServer(PGPUInt32 wins1, PGPUInt32 wins2)
{
	PGPUInt32 *longOption1, *longOption2;

	if (wins1 == 0)
		return;

	OptionField[eooPos++] = CODE_WINS_SERVER;
	if (wins1 != wins2)
		OptionField[eooPos++] = 8;
	else
		OptionField[eooPos++] = 4;

	longOption1 = (PGPUInt32*)&OptionField[eooPos];

	*longOption1 = htonl(wins1);

	eooPos += 4;

	if (wins1 != wins2)
	{
		longOption2 = (PGPUInt32*)&OptionField[eooPos];

		*longOption2 = htonl(wins2);

		eooPos += 4;
	}

	OptionField[eooPos] = CODE_END_OPTION;
}

void CPGPnetDHCPPacket::SetDHCPWINSType(unsigned char winsType)
{
	OptionField[eooPos++] = CODE_WINS_TYPE;
	OptionField[eooPos++] = 1;

	OptionField[eooPos++] = winsType;

	OptionField[eooPos] = CODE_END_OPTION;
}

void CPGPnetDHCPPacket::GetDHCPDNSServer(PGPUInt32 *dns1, PGPUInt32 *dns2)
{
	if (!options[CODE_END_OPTION].len)
		DecodeOptionFields();

	if (options[CODE_DNS_SERVER].len == 4)
	{
		*dns1 = *dns2 = htonl(*(PGPUInt32*)(options[CODE_DNS_SERVER].value));
	}
	else if (options[CODE_DNS_SERVER].len == 8)
	{
		*dns1 = htonl(*(PGPUInt32*)(options[CODE_DNS_SERVER].value));
		*dns2 = htonl(*(PGPUInt32*)(&options[CODE_DNS_SERVER].value[4]));
	}
	else
		*dns1 = *dns2 = 0;

}

void CPGPnetDHCPPacket::SetDHCPDNSServer(PGPUInt32 dns1, PGPUInt32 dns2)
{
	PGPUInt32 *longOption1, *longOption2;

	if (dns1 == 0)
		return;

	OptionField[eooPos++] = CODE_DNS_SERVER;
	if (dns2 != dns1 && dns2 != 0)
		OptionField[eooPos++] = 8;
	else
		OptionField[eooPos++] = 4;

	longOption1 = (PGPUInt32*)&OptionField[eooPos];

	*longOption1 = htonl(dns1);

	eooPos += 4;

	if (dns2 != dns1 && dns2 != 0)
	{
		longOption2 = (PGPUInt32*)&OptionField[eooPos];

		*longOption2 = htonl(dns2);

		eooPos += 4;
	}

	OptionField[eooPos] = CODE_END_OPTION;

}

void CPGPnetDHCPPacket::SetT1(PGPUInt32 t1)
{
	PGPUInt32 *longOption;

	OptionField[eooPos++] = CODE_T1;
	OptionField[eooPos++] = 4;

	longOption = (PGPUInt32*)&OptionField[eooPos];

	*longOption = htonl(t1);

	eooPos += 4;

	OptionField[eooPos] = CODE_END_OPTION;
}

void CPGPnetDHCPPacket::SetT2(PGPUInt32 t2)
{
	PGPUInt32 *longOption;

	OptionField[eooPos++] = CODE_T2;
	OptionField[eooPos++] = 4;

	longOption = (PGPUInt32*)&OptionField[eooPos];

	*longOption = htonl(t2);

	eooPos += 4;

	OptionField[eooPos] = CODE_END_OPTION;
}

void CPGPnetDHCPPacket::SetLeaseTime(PGPUInt32 leaseTime)
{
	PGPUInt32 *longOption;

	OptionField[eooPos++] = CODE_LEASE_TIME;
	OptionField[eooPos++] = 4;

	longOption = (PGPUInt32*)&OptionField[eooPos];

	*longOption = htonl(leaseTime);

	eooPos += 4;

	OptionField[eooPos] = CODE_END_OPTION;
}

void CPGPnetDHCPPacket::SetServerId(PGPUInt32 serverId)
{
	PGPUInt32 *longOption;

	OptionField[eooPos++] = CODE_SERVER_ID;
	OptionField[eooPos++] = 4;

	longOption = (PGPUInt32*)&OptionField[eooPos];

	*longOption = htonl(serverId);

	eooPos += 4;

	OptionField[eooPos] = CODE_END_OPTION;
}

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

CPGPnetARPPacket::CPGPnetARPPacket()
{
}

CPGPnetARPPacket::~CPGPnetARPPacket()
{
}

CPGPnetARPPacket::CPGPnetARPPacket(PVOID block, UINT block_len)
{
	if (block_len >= sizeof(arp_header))
		NdisMoveMemory(&arp_header, block, sizeof(arp_header));
}

ARP_CODE CPGPnetARPPacket::GetARPCode()
{
	return (ARP_CODE)ntohs(arp_header.arp_op);
}

unsigned char* CPGPnetARPPacket::GetSrcEthernetAddress()
{
	return arp_header.arp_src_hrd_addr;
}

unsigned char* CPGPnetARPPacket::GetDstEthernetAddress()
{
	return arp_header.arp_dst_hrd_addr;
}

PGPUInt32 CPGPnetARPPacket::GetSrcIPAddress()
{
	return htonl(arp_header.arp_src_ip_addr);
}
PGPUInt32 CPGPnetARPPacket::GetDstIPAddress()
{
	return htonl(arp_header.arp_dst_ip_addr);
}

void CPGPnetARPPacket::SetARPCode(ARP_CODE arpCode)
{
	arp_header.arp_op = htons(arpCode);
}

void CPGPnetARPPacket::SetSrcEthernetAddress(unsigned char* ethernetAddress)
{
	if (ethernetAddress == NULL)
		NdisZeroMemory(arp_header.arp_src_hrd_addr, 6);
	else
		NdisMoveMemory(arp_header.arp_src_hrd_addr, ethernetAddress, 6);
}

void CPGPnetARPPacket::SetDstEthernetAddress(unsigned char* ethernetAddress)
{
	if (ethernetAddress == NULL)
		NdisZeroMemory(arp_header.arp_dst_hrd_addr, 6);
	else
		NdisMoveMemory(arp_header.arp_dst_hrd_addr, ethernetAddress, 6);

}

void CPGPnetARPPacket::SetSrcIPAddress(PGPUInt32 ipAddress)
{
	arp_header.arp_src_ip_addr = htonl(ipAddress);
}

void CPGPnetARPPacket::SetDstIPAddress(PGPUInt32 ipAddress)
{
	arp_header.arp_dst_ip_addr = htonl(ipAddress);
}

unsigned short CPGPnetARPPacket::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, &arp_header, sizeof(arp_header));
	offset += sizeof(arp_header);

	offset += ARP_PAD_LEN;

	return offset;
}