SVIncCompil/Testcases/AmiqEth/sc/amiq_eth_packet_ipv4.cpp - third_party/Surelog - Git at Google

 /******************************************************************************
  * (C) Copyright 2014 AMIQ Consulting
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  * NAME:        amiq_eth_packet_ipv4.cpp
  * PROJECT:     amiq_eth
  * Description: This file declare the IPV4 Ethernet packet.
  * 				Implementation is done based on: http://en.wikipedia.org/wiki/Internet_Protocol_version_4
  *******************************************************************************/

 #ifndef __AMIQ_ETH_PACKET_IPV4
 //protection against multiple includes
 #define __AMIQ_ETH_PACKET_IPV4

 using namespace std;

 //Ethernet IPV4 packet header
 class amiq_eth_packet_ipv4_header {
 public:

 	//Version
 	amiq_eth_ipv4_header_version version;

 	//Internet Header Length (IHL)
 	amiq_eth_ipv4_header_ihl ihl;

 	//Differentiated Services Code Point (DSCP)
 	amiq_eth_ipv4_header_dscp dscp;

 	//Explicit Congestion Notification (ECN)
 	amiq_eth_ipv4_header_ecn ecn;

 	//Total Length
 	amiq_eth_ipv4_header_total_length total_length;

 	//Identification
 	amiq_eth_ipv4_header_identification identification;

 	//Flags
 	amiq_eth_ipv4_header_flags flags;

 	//Fragment Offset
 	amiq_eth_ipv4_header_fragment_offset fragment_offset;

 	//Time To Live (TTL)
 	amiq_eth_ipv4_header_ttl ttl;

 	//Protocol
 	amiq_eth_ipv4_header_protocol protocol;

 	//Header Checksum
 	amiq_eth_ipv4_header_checksum checksum;

 	//Source address
 	amiq_eth_ipv4_header_source_ip_address source_ip_address;

 	//Destination address
 	amiq_eth_ipv4_header_destination_ip_address destination_ip_address;

 	//Options
 	amiq_eth_ipv4_header_option *options;

 	//constructor
 	amiq_eth_packet_ipv4_header() {
 		options = NULL;
 	}

 	//destructor
 	~amiq_eth_packet_ipv4_header() {
 		options = NULL;
 	}

 	//get the minimum length of the header, in bits
 	//@return the minimum length of the header, in bits
 	virtual unsigned int get_minimum_header_length_in_bits() const {
 		return (AMIQ_ETH_IPV4_HEADER_VERSION_WIDTH + AMIQ_ETH_IPV4_HEADER_IHL_WIDTH + AMIQ_ETH_IPV4_HEADER_DSCP_WIDTH + AMIQ_ETH_IPV4_HEADER_ECN_WIDTH + AMIQ_ETH_IPV4_HEADER_TOTAL_LENGTH_WIDTH
 				+ AMIQ_ETH_IPV4_HEADER_IDENTIFICATION_WIDTH + AMIQ_ETH_IPV4_HEADER_FLAGS_WIDTH + AMIQ_ETH_IPV4_HEADER_FRAGMENT_OFFSET_WIDTH + AMIQ_ETH_IPV4_HEADER_TTL_WIDTH
 				+ AMIQ_ETH_IPV4_HEADER_PROTOCOL_WIDTH + AMIQ_ETH_IPV4_HEADER_CHECKSUM_WIDTH + AMIQ_ETH_IPV4_HEADER_SOURCE_IP_ADDRESS_WIDTH + AMIQ_ETH_IPV4_HEADER_DESTINATION_IP_ADDRESS_WIDTH);
 	}

 	//get the minimum length of the header, in bytes
 	//@return the minimum length of the header, in bytes
 	virtual unsigned int get_minimum_header_length_in_bytes() {
 		return (get_minimum_header_length_in_bits() / 8);
 	}

 	//get the minimum length of the header, in words
 	//@return the minimum length of the header, in words
 	virtual unsigned int get_minimum_header_length_in_words() const {
 		return (get_minimum_header_length_in_bits() / 32);
 	}

 	//get the options size in words
 	//@param local_ihl - Internet Header Length (IHL)
 	//@return the options size in words
 	virtual unsigned int get_options_size_in_words() const {
 		if (ihl.to_uint() < get_minimum_header_length_in_words()) {
 			stringstream ss;
 			ss << "Internet Header Length (" << std::dec << ihl << ") should be bigger or equal then Minimum Header Length in words (" << std::dec << get_minimum_header_length_in_words() << ")";
 			string str = ss.str();
 			SC_REPORT_FATAL("AMIQ_ETH", str.c_str());
 		};

 		return (ihl.to_uint() - get_minimum_header_length_in_words());
 	}

 	//get the header length in bytes
 	//@return the header length in bytes
 	virtual unsigned int get_header_length_in_bytes() const {
 		return (ihl.to_uint() * 4);
 	}

 	//get the data length in bytes
 	//@return the data length in bytes
 	virtual unsigned int get_data_length_in_bytes() const {
 		if (total_length.to_uint() < get_header_length_in_bytes()) {
 			stringstream ss;
 			ss << "Total Length (" << std::dec << total_length.to_uint() << ") should be bigger or equal to IHL in bytes (" << std::dec << get_header_length_in_bytes() << ")";
 			string str = ss.str();
 			SC_REPORT_FATAL("AMIQ_ETH", str.c_str());
 		};

 		return (total_length.to_uint() - get_header_length_in_bytes());
 	}

 	//pack the entire Ethernet packet
 	//@param packer - the packer used by this function
 	virtual void do_pack(amiq_eth_packer& packer) const {
 		amiq_eth_do_pack(packer, version);
 		amiq_eth_do_pack(packer, ihl);
 		amiq_eth_do_pack(packer, dscp);
 		amiq_eth_do_pack(packer, ecn);
 		amiq_eth_do_pack(packer, total_length);
 		amiq_eth_do_pack(packer, identification);
 		amiq_eth_do_pack(packer, flags);
 		amiq_eth_do_pack(packer, fragment_offset);
 		amiq_eth_do_pack(packer, ttl);
 		amiq_eth_do_pack(packer, protocol);
 		amiq_eth_do_pack(packer, checksum);
 		amiq_eth_do_pack(packer, source_ip_address);
 		amiq_eth_do_pack(packer, destination_ip_address);

 		unsigned int options_size_in_words = get_options_size_in_words();
 		for (unsigned int index = 0; index < options_size_in_words; index++) {
 			amiq_eth_do_pack(packer, options[index]);
 		}
 	}

 	//unpack the entire Ethernet packet
 	//@param packer - the packer used by this function
 	virtual void do_unpack(amiq_eth_packer& packer) {
 		amiq_eth_do_unpack(packer, version);
 		amiq_eth_do_unpack(packer, ihl);
 		amiq_eth_do_unpack(packer, dscp);
 		amiq_eth_do_unpack(packer, ecn);
 		amiq_eth_do_unpack(packer, total_length);
 		amiq_eth_do_unpack(packer, identification);
 		amiq_eth_do_unpack(packer, flags);
 		amiq_eth_do_unpack(packer, fragment_offset);
 		amiq_eth_do_unpack(packer, ttl);
 		amiq_eth_do_unpack(packer, protocol);
 		amiq_eth_do_unpack(packer, checksum);
 		amiq_eth_do_unpack(packer, source_ip_address);
 		amiq_eth_do_unpack(packer, destination_ip_address);

 		unsigned int options_size_in_words = get_options_size_in_words();
 		options = new amiq_eth_ipv4_header_option[options_size_in_words];

 		for (int unsigned i = 0; i < options_size_in_words; i++) {
 			amiq_eth_ipv4_header_option option;
 			amiq_eth_do_unpack(packer, option);
 			options[i] = option;
 		}
 	}

 	//prints the current class to a given output stream
 	//@param out - output stream
 	virtual void do_print(ostream& out) const {
 		out << "Version: " << std::hex << version.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "IHL: " << std::dec << ihl.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "DSCP: " << std::hex << dscp.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "ECN: " << std::hex << ecn.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Total Length: " << std::dec << total_length.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Identification: " << std::hex << identification.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Flags: " << std::hex << flags.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Fragment Offset: " << std::hex << fragment_offset.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "TTL: " << std::dec << ttl.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Protocol: " << std::hex << protocol.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Checksum: " << std::hex << checksum.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Source IP: " << std::hex << source_ip_address.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Destination IP: " << std::hex << destination_ip_address.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "Options size: " << std::dec << get_options_size_in_words();
 	}

 };


 //Ethernet IPV4 packet
 class amiq_eth_packet_ipv4: public amiq_eth_packet_ether_type {

 public:

 	//header
 	amiq_eth_packet_ipv4_header header;

 	//data
 	amiq_eth_data *data;

 	//pad
 	amiq_eth_data *pad;

 	//fcs
 	amiq_eth_fcs fcs;

 	//constructor
 	amiq_eth_packet_ipv4() {
 		data = NULL;
 		pad = NULL;
 		header = *(new amiq_eth_packet_ipv4_header());
 	}

 	//destrucor
 	virtual ~amiq_eth_packet_ipv4() {
 		data = NULL;
 		pad = NULL;
 		delete &header;
 	}

 	//get the pad size based on the value of the input parameters
 	//@param min_frame_size - minimum frame size
 	//@param - header - Ethernet IPV4 packet header
 	//@return the pad size
 	virtual unsigned int get_pad_size_by_fields(int unsigned min_frame_size, amiq_eth_packet_ipv4_header header) const {
 		unsigned int value = ((header.total_length.to_uint64() + (2 * (AMIQ_ETH_ADDRESS_WIDTH / 8)) + 6));

 		if (min_frame_size >= value) {
 			return (min_frame_size - value);
 		} else {
 			return 0;
 		}
 	}

 	//get the pad size
 	//@return the pad size
 	virtual unsigned int get_pad_size() const {
 		return get_pad_size_by_fields(min_frame_size, header);
 	}

 	//pack data field
 	//@param packer - the packer used by this function
 	virtual void pack_data(amiq_eth_packer& packer) const {
 		for (unsigned int index = 0; index < header.get_data_length_in_bytes(); index++) {
 			amiq_eth_do_pack(packer, data[index]);
 		}
 	}

 	//pack pad field
 	//@param packer - the packer used by this function
 	virtual void pack_pad(amiq_eth_packer& packer) const {
 		unsigned int pad_size = get_pad_size();
 		for (unsigned int index = 0; index < pad_size; index++) {
 			amiq_eth_do_pack(packer, pad[index]);
 		}
 	}

 	//pack FCS field
 	//@param packer - the packer used by this function
 	virtual void pack_fcs(amiq_eth_packer& packer) const {
 		amiq_eth_do_pack(packer, fcs);
 	}

 	//pack the entire Ethernet packet
 	//@param packer - the packer used by this function
 	virtual void do_pack(amiq_eth_packer& packer) const {
 		amiq_eth_packet_ether_type::do_pack(packer);
 		header.do_pack(packer);
 		pack_data(packer);
 		pack_pad(packer);
 		pack_fcs(packer);
 	}

 	//unpack the entire Ethernet packet
 	//@param packer - the packer used by this function
 	virtual void do_unpack(amiq_eth_packer& packer) {
 		amiq_eth_packet_ether_type::do_unpack(packer);
 		header.do_unpack(packer);

 		int unsigned data_length = header.get_data_length_in_bytes();
 		data = new amiq_eth_data[data_length];
 		for (unsigned int index = 0; index < data_length; index++) {
 			amiq_eth_data local_data;
 			amiq_eth_do_unpack(packer, local_data);
 			data[index] = local_data;
 		}

 		unsigned int pad_size = get_pad_size();
 		pad = new amiq_eth_data[pad_size];
 		for (unsigned int index = 0; index < pad_size; index++) {
 			amiq_eth_data local_pad;
 			amiq_eth_do_unpack(packer, local_pad);
 			pad[index] = local_pad;
 		}

 		amiq_eth_do_unpack(packer, fcs);
 	}

 	//function for packing the Ethernet packet using only the required information for computing the FCS
 	//@param bitstream - the packed bit stream is placed in "bitstream" parameter
 	virtual void do_pack_for_fcs(amiq_eth_packer& packer) const {
 		amiq_eth_packet_ether_type::do_pack_for_fcs(packer);
 		header.do_pack(packer);
 		pack_data(packer);
 	}

 	//prints the current class to a given output stream
 	//@param out - output stream
 	virtual void do_print(ostream& out) const {
 		string fcs_info;
 		amiq_eth_fcs correct_fcs = get_correct_fcs();

 		if (correct_fcs == fcs) {
 			fcs_info = "FCS is correct";
 		} else {
 			stringstream ss;
 			ss << "FCS is wrong - expecting " << std::hex << correct_fcs << endl;
 			fcs_info = ss.str();
 		};

 		amiq_eth_packet_ether_type::do_print(out);
 		out << AMIQ_ETH_FIELD_SEPARATOR;
 		header.do_print(out);
 		out << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "data size: " << std::dec << header.get_data_length_in_bytes() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "pad size: " << std::dec << get_pad_size() << AMIQ_ETH_FIELD_SEPARATOR;
 		out << "FCS: " << std::hex << fcs.to_uint() << ", " << fcs_info << endl;
 	}

 	//function for packing the Ethernet packet into an UVM generic payload class
 	//@return an instance of the UVM generic payload containing the packed Ethernet packet
 	virtual tlm_generic_payload * to_generic_payload() const {
 		tlm_generic_payload * result = (amiq_eth_packet_ether_type::to_generic_payload());
 		result->set_address(AMIQ_ETH_PACKET_IPV4_CODE);

 		return result;
 	}
 };


 #endif
	/******************************************************************************
	* (C) Copyright 2014 AMIQ Consulting
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	* NAME: amiq_eth_packet_ipv4.cpp
	* PROJECT: amiq_eth
	* Description: This file declare the IPV4 Ethernet packet.
	* Implementation is done based on: http://en.wikipedia.org/wiki/Internet_Protocol_version_4
	*******************************************************************************/

	#ifndef __AMIQ_ETH_PACKET_IPV4
	//protection against multiple includes
	#define __AMIQ_ETH_PACKET_IPV4

	using namespace std;

	//Ethernet IPV4 packet header
	class amiq_eth_packet_ipv4_header {
	public:

	//Version
	amiq_eth_ipv4_header_version version;

	//Internet Header Length (IHL)
	amiq_eth_ipv4_header_ihl ihl;

	//Differentiated Services Code Point (DSCP)
	amiq_eth_ipv4_header_dscp dscp;

	//Explicit Congestion Notification (ECN)
	amiq_eth_ipv4_header_ecn ecn;

	//Total Length
	amiq_eth_ipv4_header_total_length total_length;

	//Identification
	amiq_eth_ipv4_header_identification identification;

	//Flags
	amiq_eth_ipv4_header_flags flags;

	//Fragment Offset
	amiq_eth_ipv4_header_fragment_offset fragment_offset;

	//Time To Live (TTL)
	amiq_eth_ipv4_header_ttl ttl;

	//Protocol
	amiq_eth_ipv4_header_protocol protocol;

	//Header Checksum
	amiq_eth_ipv4_header_checksum checksum;

	//Source address
	amiq_eth_ipv4_header_source_ip_address source_ip_address;

	//Destination address
	amiq_eth_ipv4_header_destination_ip_address destination_ip_address;

	//Options
	amiq_eth_ipv4_header_option *options;

	//constructor
	amiq_eth_packet_ipv4_header() {
	options = NULL;
	}

	//destructor
	~amiq_eth_packet_ipv4_header() {
	options = NULL;
	}

	//get the minimum length of the header, in bits
	//@return the minimum length of the header, in bits
	virtual unsigned int get_minimum_header_length_in_bits() const {
	return (AMIQ_ETH_IPV4_HEADER_VERSION_WIDTH + AMIQ_ETH_IPV4_HEADER_IHL_WIDTH + AMIQ_ETH_IPV4_HEADER_DSCP_WIDTH + AMIQ_ETH_IPV4_HEADER_ECN_WIDTH + AMIQ_ETH_IPV4_HEADER_TOTAL_LENGTH_WIDTH
	+ AMIQ_ETH_IPV4_HEADER_IDENTIFICATION_WIDTH + AMIQ_ETH_IPV4_HEADER_FLAGS_WIDTH + AMIQ_ETH_IPV4_HEADER_FRAGMENT_OFFSET_WIDTH + AMIQ_ETH_IPV4_HEADER_TTL_WIDTH
	+ AMIQ_ETH_IPV4_HEADER_PROTOCOL_WIDTH + AMIQ_ETH_IPV4_HEADER_CHECKSUM_WIDTH + AMIQ_ETH_IPV4_HEADER_SOURCE_IP_ADDRESS_WIDTH + AMIQ_ETH_IPV4_HEADER_DESTINATION_IP_ADDRESS_WIDTH);
	}

	//get the minimum length of the header, in bytes
	//@return the minimum length of the header, in bytes
	virtual unsigned int get_minimum_header_length_in_bytes() {
	return (get_minimum_header_length_in_bits() / 8);
	}

	//get the minimum length of the header, in words
	//@return the minimum length of the header, in words
	virtual unsigned int get_minimum_header_length_in_words() const {
	return (get_minimum_header_length_in_bits() / 32);
	}

	//get the options size in words
	//@param local_ihl - Internet Header Length (IHL)
	//@return the options size in words
	virtual unsigned int get_options_size_in_words() const {
	if (ihl.to_uint() < get_minimum_header_length_in_words()) {
	stringstream ss;
	ss << "Internet Header Length (" << std::dec << ihl << ") should be bigger or equal then Minimum Header Length in words (" << std::dec << get_minimum_header_length_in_words() << ")";
	string str = ss.str();
	SC_REPORT_FATAL("AMIQ_ETH", str.c_str());
	};

	return (ihl.to_uint() - get_minimum_header_length_in_words());
	}

	//get the header length in bytes
	//@return the header length in bytes
	virtual unsigned int get_header_length_in_bytes() const {
	return (ihl.to_uint() * 4);
	}

	//get the data length in bytes
	//@return the data length in bytes
	virtual unsigned int get_data_length_in_bytes() const {
	if (total_length.to_uint() < get_header_length_in_bytes()) {
	stringstream ss;
	ss << "Total Length (" << std::dec << total_length.to_uint() << ") should be bigger or equal to IHL in bytes (" << std::dec << get_header_length_in_bytes() << ")";
	string str = ss.str();
	SC_REPORT_FATAL("AMIQ_ETH", str.c_str());
	};

	return (total_length.to_uint() - get_header_length_in_bytes());
	}

	//pack the entire Ethernet packet
	//@param packer - the packer used by this function
	virtual void do_pack(amiq_eth_packer& packer) const {
	amiq_eth_do_pack(packer, version);
	amiq_eth_do_pack(packer, ihl);
	amiq_eth_do_pack(packer, dscp);
	amiq_eth_do_pack(packer, ecn);
	amiq_eth_do_pack(packer, total_length);
	amiq_eth_do_pack(packer, identification);
	amiq_eth_do_pack(packer, flags);
	amiq_eth_do_pack(packer, fragment_offset);
	amiq_eth_do_pack(packer, ttl);
	amiq_eth_do_pack(packer, protocol);
	amiq_eth_do_pack(packer, checksum);
	amiq_eth_do_pack(packer, source_ip_address);
	amiq_eth_do_pack(packer, destination_ip_address);

	unsigned int options_size_in_words = get_options_size_in_words();
	for (unsigned int index = 0; index < options_size_in_words; index++) {
	amiq_eth_do_pack(packer, options[index]);
	}
	}

	//unpack the entire Ethernet packet
	//@param packer - the packer used by this function
	virtual void do_unpack(amiq_eth_packer& packer) {
	amiq_eth_do_unpack(packer, version);
	amiq_eth_do_unpack(packer, ihl);
	amiq_eth_do_unpack(packer, dscp);
	amiq_eth_do_unpack(packer, ecn);
	amiq_eth_do_unpack(packer, total_length);
	amiq_eth_do_unpack(packer, identification);
	amiq_eth_do_unpack(packer, flags);
	amiq_eth_do_unpack(packer, fragment_offset);
	amiq_eth_do_unpack(packer, ttl);
	amiq_eth_do_unpack(packer, protocol);
	amiq_eth_do_unpack(packer, checksum);
	amiq_eth_do_unpack(packer, source_ip_address);
	amiq_eth_do_unpack(packer, destination_ip_address);

	unsigned int options_size_in_words = get_options_size_in_words();
	options = new amiq_eth_ipv4_header_option[options_size_in_words];

	for (int unsigned i = 0; i < options_size_in_words; i++) {
	amiq_eth_ipv4_header_option option;
	amiq_eth_do_unpack(packer, option);
	options[i] = option;
	}
	}

	//prints the current class to a given output stream
	//@param out - output stream
	virtual void do_print(ostream& out) const {
	out << "Version: " << std::hex << version.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "IHL: " << std::dec << ihl.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "DSCP: " << std::hex << dscp.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "ECN: " << std::hex << ecn.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Total Length: " << std::dec << total_length.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Identification: " << std::hex << identification.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Flags: " << std::hex << flags.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Fragment Offset: " << std::hex << fragment_offset.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "TTL: " << std::dec << ttl.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Protocol: " << std::hex << protocol.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Checksum: " << std::hex << checksum.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Source IP: " << std::hex << source_ip_address.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Destination IP: " << std::hex << destination_ip_address.to_uint() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "Options size: " << std::dec << get_options_size_in_words();
	}

	};


	//Ethernet IPV4 packet
	class amiq_eth_packet_ipv4: public amiq_eth_packet_ether_type {

	public:

	//header
	amiq_eth_packet_ipv4_header header;

	//data
	amiq_eth_data *data;

	//pad
	amiq_eth_data *pad;

	//fcs
	amiq_eth_fcs fcs;

	//constructor
	amiq_eth_packet_ipv4() {
	data = NULL;
	pad = NULL;
	header = *(new amiq_eth_packet_ipv4_header());
	}

	//destrucor
	virtual ~amiq_eth_packet_ipv4() {
	data = NULL;
	pad = NULL;
	delete &header;
	}

	//get the pad size based on the value of the input parameters
	//@param min_frame_size - minimum frame size
	//@param - header - Ethernet IPV4 packet header
	//@return the pad size
	virtual unsigned int get_pad_size_by_fields(int unsigned min_frame_size, amiq_eth_packet_ipv4_header header) const {
	unsigned int value = ((header.total_length.to_uint64() + (2 * (AMIQ_ETH_ADDRESS_WIDTH / 8)) + 6));

	if (min_frame_size >= value) {
	return (min_frame_size - value);
	} else {
	return 0;
	}
	}

	//get the pad size
	//@return the pad size
	virtual unsigned int get_pad_size() const {
	return get_pad_size_by_fields(min_frame_size, header);
	}

	//pack data field
	//@param packer - the packer used by this function
	virtual void pack_data(amiq_eth_packer& packer) const {
	for (unsigned int index = 0; index < header.get_data_length_in_bytes(); index++) {
	amiq_eth_do_pack(packer, data[index]);
	}
	}

	//pack pad field
	//@param packer - the packer used by this function
	virtual void pack_pad(amiq_eth_packer& packer) const {
	unsigned int pad_size = get_pad_size();
	for (unsigned int index = 0; index < pad_size; index++) {
	amiq_eth_do_pack(packer, pad[index]);
	}
	}

	//pack FCS field
	//@param packer - the packer used by this function
	virtual void pack_fcs(amiq_eth_packer& packer) const {
	amiq_eth_do_pack(packer, fcs);
	}

	//pack the entire Ethernet packet
	//@param packer - the packer used by this function
	virtual void do_pack(amiq_eth_packer& packer) const {
	amiq_eth_packet_ether_type::do_pack(packer);
	header.do_pack(packer);
	pack_data(packer);
	pack_pad(packer);
	pack_fcs(packer);
	}

	//unpack the entire Ethernet packet
	//@param packer - the packer used by this function
	virtual void do_unpack(amiq_eth_packer& packer) {
	amiq_eth_packet_ether_type::do_unpack(packer);
	header.do_unpack(packer);

	int unsigned data_length = header.get_data_length_in_bytes();
	data = new amiq_eth_data[data_length];
	for (unsigned int index = 0; index < data_length; index++) {
	amiq_eth_data local_data;
	amiq_eth_do_unpack(packer, local_data);
	data[index] = local_data;
	}

	unsigned int pad_size = get_pad_size();
	pad = new amiq_eth_data[pad_size];
	for (unsigned int index = 0; index < pad_size; index++) {
	amiq_eth_data local_pad;
	amiq_eth_do_unpack(packer, local_pad);
	pad[index] = local_pad;
	}

	amiq_eth_do_unpack(packer, fcs);
	}

	//function for packing the Ethernet packet using only the required information for computing the FCS
	//@param bitstream - the packed bit stream is placed in "bitstream" parameter
	virtual void do_pack_for_fcs(amiq_eth_packer& packer) const {
	amiq_eth_packet_ether_type::do_pack_for_fcs(packer);
	header.do_pack(packer);
	pack_data(packer);
	}

	//prints the current class to a given output stream
	//@param out - output stream
	virtual void do_print(ostream& out) const {
	string fcs_info;
	amiq_eth_fcs correct_fcs = get_correct_fcs();

	if (correct_fcs == fcs) {
	fcs_info = "FCS is correct";
	} else {
	stringstream ss;
	ss << "FCS is wrong - expecting " << std::hex << correct_fcs << endl;
	fcs_info = ss.str();
	};

	amiq_eth_packet_ether_type::do_print(out);
	out << AMIQ_ETH_FIELD_SEPARATOR;
	header.do_print(out);
	out << AMIQ_ETH_FIELD_SEPARATOR;
	out << "data size: " << std::dec << header.get_data_length_in_bytes() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "pad size: " << std::dec << get_pad_size() << AMIQ_ETH_FIELD_SEPARATOR;
	out << "FCS: " << std::hex << fcs.to_uint() << ", " << fcs_info << endl;
	}

	//function for packing the Ethernet packet into an UVM generic payload class
	//@return an instance of the UVM generic payload containing the packed Ethernet packet
	virtual tlm_generic_payload * to_generic_payload() const {
	tlm_generic_payload * result = (amiq_eth_packet_ether_type::to_generic_payload());
	result->set_address(AMIQ_ETH_PACKET_IPV4_CODE);

	return result;
	}
	};


	#endif