kernel-tests/HeaderProcessingContextTests.cpp

/*
 * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of The Linux Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "HeaderProcessingContextTestFixture.h"

/*----------------------------------------------------------------------------*/
/* Test00: Header insertion scenario of [RNDIS][ETH_II][IP] ->                */
/* [WLAN][ETH_II][IP]                                                         */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest00 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest00()
	{
		m_name = "IpaHdrProcCtxTest00";
		m_description =
			"Processing Context test 00 - \
			of [RNDIS][ETH_II][IP] -> [WLAN][ETH_II][IP] \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST2. \
			Routing rule will use processing context ETH2_2_WLAN_ETH2 \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";
		m_pCurrentProducer = &m_rndisEth2Producer;
		m_currProducerClient = IPA_CLIENT_TEST_PROD;
		m_pCurrentConsumer = &m_defaultConsumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST2_CONS;
		m_procCtxHandleId = PROC_CTX_HANDLE_ID_ETH2_2_WLAN_ETH2;
		m_minIPAHwType = IPA_HW_v2_5;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		if (!RNDISAggregationHelper::LoadRNDISPacket(
			ip,
			m_sendBuffer1,
			m_sendSize1))
		{
			LOG_MSG_ERROR("Failed default Packet\n");
			return false;
		}
		printf ("Loaded %zu Bytes to Packet 1\n",m_sendSize1);

		add_buff(m_sendBuffer1+RNDIS_HDR_SIZE, ETH_HLEN, 2);
		print_buff(m_sendBuffer1, m_sendSize1);

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		m_expectedBufferSize1 = WLAN_ETH2_HDR_SIZE +
			IP4_PACKET_SIZE;

		// copy WLAN header to the beginning of the buffer
		memcpy(m_expectedBuffer1, WLAN_ETH2_HDR, WLAN_HDR_SIZE);

		// copy ETH+IP packet right after WLAN header
		memcpy(m_expectedBuffer1 + WLAN_HDR_SIZE,
			m_sendBuffer1 + RNDIS_HDR_SIZE,
			ETH_HLEN + IP4_PACKET_SIZE);

		return true;
	} // GenerateExpectedPackets()
};

/*----------------------------------------------------------------------------*/
/* Test01: Header insertion scenario of [WLAN][ETH_II][IP] ->                 */
/* [RNDIS][ETH_II][IP]                                                        */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest01 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest01()
	{
		m_name = "IpaHdrProcCtxTest01";
		m_description =
			"Processing context test 01 - \
			of [WLAN][ETH_II][IP] -> [RNDIS][ETH_II][IP] \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST3. \
			Routing rule will use processing context ETH2_2_RNDIS_ETH2 \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";
		m_pCurrentProducer = &m_wlanEth2producer;
		m_currProducerClient = IPA_CLIENT_TEST2_PROD;
		m_pCurrentConsumer = &m_rndisEth2Consumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST3_CONS;
		m_procCtxHandleId = PROC_CTX_HANDLE_ID_ETH2_2_RNDIS_ETH2;
		m_minIPAHwType = IPA_HW_v2_5;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		// load WLAN ETH2 IP4 packet of size 1kB + 1 byte
		// This size will trigger RNDIS aggregation later
		m_sendSize1 =
			RNDISAggregationHelper::RNDIS_AGGREGATION_BYTE_LIMIT + 1;

		if (!WlanHelper::LoadWlanEth2IP4PacketByLength(
			m_sendBuffer1,
			m_BUFF_MAX_SIZE,
			m_sendSize1,
			0x01))
			return false;

		printf ("Loaded %zu Bytes to Packet 1\n",m_sendSize1);

		add_buff(m_sendBuffer1+WLAN_HDR_SIZE, ETH_HLEN, 3);

		print_buff(m_sendBuffer1, m_sendSize1);

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		size_t len = 0;
		size_t eth2PacketSize = m_sendSize1 - WLAN_HDR_SIZE;

		m_expectedBufferSize1 =	eth2PacketSize + RNDIS_HDR_SIZE;

		// copy RNDIS header
		if (!RNDISAggregationHelper::LoadRNDISHeader(
			m_expectedBuffer1,
			m_BUFF_MAX_SIZE,
			m_expectedBufferSize1,
			&len))
		{
			LOG_MSG_ERROR("Failed default Packet\n");
			return false;
		}

		// copy ETH2 packet after RNDIS header
		memcpy(m_expectedBuffer1 + len,
			m_sendBuffer1 + WLAN_HDR_SIZE,
			eth2PacketSize);

		return true;
	} // GenerateExpectedPackets()
};

/*----------------------------------------------------------------------------*/
/* Test02: Header insertion scenario of [WLAN][ETH_II][IP] ->                 */
/* [WLAN'][ETH_II][IP]                                                        */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest02 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest02()
	{
		m_name = "IpaHdrProcCtxTest02";
		m_description =
			"Processing context test 02 - \
			of [WLAN][ETH_II][IP] -> [WLAN'][ETH_II][IP] \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST2. \
			Routing rule will use processing context ETH2_2_WLAN_ETH2 \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";
		m_pCurrentProducer = &m_wlanEth2producer;
		m_currProducerClient = IPA_CLIENT_TEST2_PROD;
		m_pCurrentConsumer = &m_defaultConsumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST2_CONS;
		m_procCtxHandleId = PROC_CTX_HANDLE_ID_ETH2_2_WLAN_ETH2;
		m_minIPAHwType = IPA_HW_v2_5;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		// load WLAN ETH2 IP4 packet of size 1kB
		// This size will trigger RNDIS aggregation later
		if (!WlanHelper::LoadWlanEth2IP4Packet(
			m_sendBuffer1,
			m_BUFF_MAX_SIZE,
			&m_sendSize1))
			return false;

		printf ("Loaded %zu Bytes to Packet 1\n",m_sendSize1);

		add_buff(m_sendBuffer1+WLAN_HDR_SIZE, ETH_HLEN, 5);

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		m_expectedBufferSize1 = m_sendSize1;
		memcpy(m_expectedBuffer1, m_sendBuffer1, m_expectedBufferSize1);
		memcpy(m_expectedBuffer1, WLAN_ETH2_HDR, WLAN_HDR_SIZE);

		return true;
	} // GenerateExpectedPackets()
};

/*----------------------------------------------------------------------------*/
/* Test03: Header insertion scenario of [WLAN][ETH_II][IP] ->                 */
/* [RNDIS][ETH_II][IP] with RNDIS aggregation                                 */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest03 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest03()
	{
		m_name = "IpaHdrProcCtxTest03";
		m_description =
			"Processing Context test 03 - \
			of [RNDIS][ETH_II][IP] -> [WLAN][ETH_II][IP] \
			with RNDIS aggregation \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST3. \
			Routing rule will use processing context ETH2_2_RNDIS_ETH2 \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";
		m_pCurrentProducer = &m_wlanEth2producer;
		m_currProducerClient = IPA_CLIENT_TEST2_PROD;
		m_pCurrentConsumer = &m_rndisEth2Consumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST3_CONS;
		m_procCtxHandleId = PROC_CTX_HANDLE_ID_ETH2_2_RNDIS_ETH2;
		m_minIPAHwType = IPA_HW_v2_5;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		// choose this size so that 2 such buffers would be aggregated
		m_sendSize1 = RNDISAggregationHelper::
			RNDIS_AGGREGATION_BYTE_LIMIT /	2 + 200;

		if (!WlanHelper::LoadWlanEth2IP4PacketByLength(
			m_sendBuffer1,
			m_BUFF_MAX_SIZE,
			m_sendSize1,
			1))
			return false;

		printf ("Loaded %zu Bytes to Packet 1\n", m_sendSize1);

		add_buff(m_sendBuffer1+WLAN_HDR_SIZE, ETH_HLEN, 7);

		// choose this size so that 2 such buffers would be aggregated
		m_sendSize2 = RNDISAggregationHelper::
			RNDIS_AGGREGATION_BYTE_LIMIT /	2 + 200;

		if (!WlanHelper::LoadWlanEth2IP4PacketByLength(
			m_sendBuffer2,
			m_BUFF_MAX_SIZE,
			m_sendSize2,
			2))
			return false;

		printf ("Loaded %zu Bytes to Packet 2\n", m_sendSize2);

		add_buff(m_sendBuffer2+WLAN_HDR_SIZE, ETH_HLEN, 11);

		return true;
	}

	virtual bool SendPackets()
	{
		bool isSuccess = false;

		// Send packet 1
		isSuccess = m_pCurrentProducer->SendData(
			m_sendBuffer1,
			m_sendSize1);
		if (false == isSuccess)
		{
			LOG_MSG_ERROR(
				"SendData Buffer 1 failed on producer %d\n", m_currProducerClient);
			return false;
		}

		// Send packet 2
		isSuccess = m_pCurrentProducer->SendData(
			m_sendBuffer2,
			m_sendSize2);
		if (false == isSuccess)
		{
			LOG_MSG_ERROR(
				"SendData Buffer 2 failed on producer %d\n", m_currProducerClient);
			return false;
		}

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		size_t len = 0;
		size_t eth2PacketSize1 = m_sendSize1 - WLAN_HDR_SIZE;
		size_t rndisPacketSize1 = eth2PacketSize1 + RNDIS_HDR_SIZE;
		size_t eth2PacketSize2 = m_sendSize2 - WLAN_HDR_SIZE;
		size_t rndisPacketSize2 = eth2PacketSize2 + RNDIS_HDR_SIZE;
		Byte *currBuffLocation = NULL;

		m_expectedBufferSize1 = rndisPacketSize1 + rndisPacketSize2;

		currBuffLocation = m_expectedBuffer1;

		// copy first RNDIS header
		if (!RNDISAggregationHelper::LoadRNDISHeader(
			currBuffLocation,
			m_BUFF_MAX_SIZE,
			rndisPacketSize1,
			&len))
			return false;

		// copy ETH2 packet 1 after RNDIS header
		currBuffLocation += len;
		memcpy(currBuffLocation,
			m_sendBuffer1 + WLAN_HDR_SIZE,
			eth2PacketSize1);

		// copy second RNDIS header
		currBuffLocation += eth2PacketSize1;
		if (!RNDISAggregationHelper::LoadRNDISHeader(
			currBuffLocation,
			m_BUFF_MAX_SIZE - rndisPacketSize1,
			rndisPacketSize2,
			&len))
			return false;

		// copy ETH2 packet 2 after RNDIS header
		currBuffLocation += len;
		memcpy(currBuffLocation,
			m_sendBuffer2 + WLAN_HDR_SIZE,
			eth2PacketSize2);

		return true;
	} // GenerateExpectedPackets()
};


/*----------------------------------------------------------------------------*/
/* Test04: Header insertion scenario when adding total header sizes > 2048    */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest04 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest04()
	{
		m_name = "IpaHdrProcCtxTest04";
		m_description =
			"Processing context test 04 - \
			Header insertion scenario when adding \
			total header sizes > 2048 \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST2. \
			Routing rule will use header WLAN_ETH2 \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";
		m_pCurrentProducer = &m_wlanEth2producer;
		m_currProducerClient = IPA_CLIENT_TEST2_PROD;
		m_pCurrentConsumer = &m_defaultConsumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST2_CONS;
		m_minIPAHwType = IPA_HW_v2_5;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual void AddAllHeaders()
	{
		int cnt = 0;
		int allHeadersSize = 0;

		while (allHeadersSize <= m_ALL_HEADER_SIZE_LIMIT)
		{
			AddHeader(HEADER_HANDLE_ID_ETH2);
			/* header bins are power of 2 */
			allHeadersSize += ETH_HLEN + 2;
			cnt++;
		}

		AddHeader(HEADER_HANDLE_ID_WLAN_ETH2);
	}

	virtual bool AddRules()
	{
		printf("Entering %s, %s()\n",__FUNCTION__, __FILE__);

		AddAllHeaders();

		AddRtBypassRule(m_headerHandles[HEADER_HANDLE_ID_WLAN_ETH2], 0);

		AddFltBypassRule();

		printf("Leaving %s, %s()\n",__FUNCTION__, __FILE__);
		return true;

	}// AddRules()

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		// load WLAN ETH2 IP4 packet of size 1kB
		// This size will trigger RNDIS aggregation later
		if (!WlanHelper::LoadWlanEth2IP4Packet(
			m_sendBuffer1,
			m_BUFF_MAX_SIZE,
			&m_sendSize1))
			return false;

		printf ("Loaded %zu Bytes to Packet 1\n",m_sendSize1);

		add_buff(m_sendBuffer1+WLAN_HDR_SIZE, ETH_HLEN, 13);

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		m_expectedBufferSize1 = m_sendSize1;
		memcpy(m_expectedBuffer1, m_sendBuffer1, m_expectedBufferSize1);
		memcpy(m_expectedBuffer1, WLAN_ETH2_HDR, WLAN_ETH2_HDR_SIZE);

		return true;
	} // GenerateExpectedPackets()
};

/*----------------------------------------------------------------------------*/
/* Test05: Header insertion scenario of [ETH_II_802_1Q][IP] ->                */
/* [ETH_II_802_1Q][IP]                                                        */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest05 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest05()
	{
		m_name = "IpaHdrProcCtxTest05";
		m_description =
			"Processing Context test 05 - \
			of [ETH_II_802_1Q][IP] -> [ETH_II_802_1Q][IP] \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST2. \
			Routing rule will use processing context 802_1Q_2_802_1Q \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";
		/*
		 * NOTE: we use the wlan + ETH header prod pipe since the header
		 * length shall be equal to 8021Q ETH_II length
		 */
		m_pCurrentProducer = &m_wlanEth2producer;
		m_currProducerClient = IPA_CLIENT_TEST2_PROD;
		m_pCurrentConsumer = &m_defaultConsumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST2_CONS;
		m_procCtxHandleId = PROC_CTX_HANDLE_ID_802_1Q_2_802_1Q;
		m_minIPAHwType = IPA_HW_v4_0;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		if (!LoadDefault802_1Q(ip,
			m_sendBuffer1,
			m_sendSize1)) {
			LOG_MSG_ERROR("Failed default Packet\n");
			return false;
		}
		printf("Loaded %zu Bytes to Packet 1\n", m_sendSize1);

		// modify the MAC addresses only
		add_buff(m_sendBuffer1, 12, 14);

		//change vlan ID to 9
		m_sendBuffer1[15] = 0x9;

		print_buff(m_sendBuffer1, m_sendSize1);

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		m_expectedBufferSize1 = m_sendSize1;

		// we actually expect the same packet to come out (but after uCP)
		memcpy(m_expectedBuffer1, m_sendBuffer1, m_expectedBufferSize1);

		return true;
	} // GenerateExpectedPackets()
};

/*----------------------------------------------------------------------------*/
/* Test06: Header insertion scenario of [ETH_II][IP] ->                       */
/* [ETH_II_802_1Q][IP]                                                        */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest06 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest06()
	{
		m_name = "IpaHdrProcCtxTest06";
		m_description =
			"Processing Context test 06 - \
			of [ETH_II][IP] -> [ETH_II_802_1Q][IP] \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST2. \
			Routing rule will use processing context ETH2_2_802_1Q \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";

		m_pCurrentProducer = &m_eth2Producer;
		m_currProducerClient = IPA_CLIENT_TEST3_PROD;
		m_pCurrentConsumer = &m_defaultConsumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST2_CONS;
		m_procCtxHandleId = PROC_CTX_HANDLE_ID_ETH2_2_802_1Q;
		m_minIPAHwType = IPA_HW_v4_0;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		if (!Eth2Helper::LoadEth2IP4Packet(
			m_sendBuffer1,
			m_BUFF_MAX_SIZE,
			&m_sendSize1)) {
			LOG_MSG_ERROR("Failed default Packet\n");
			return false;
		}

		printf("Loaded %zu Bytes to Packet 1\n", m_sendSize1);

		// modify the MAC addresses only
		add_buff(m_sendBuffer1, 12, 15);

		print_buff(m_sendBuffer1, m_sendSize1);

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		size_t len;

		m_expectedBufferSize1 = ETH8021Q_HEADER_LEN +
			IP4_PACKET_SIZE;
		// copy the VLAN header to expected buffer
		memcpy(m_expectedBuffer1, ETH2_8021Q_HDR, ETH8021Q_HEADER_LEN);

		// fill src and dst mac and ethertype
		memcpy(m_expectedBuffer1, m_sendBuffer1, 2 * ETH_ALEN);
		memcpy(m_expectedBuffer1 + ETH8021Q_ETH_TYPE_OFFSET,
			m_sendBuffer1 + ETH2_ETH_TYPE_OFFSET, ETH2_ETH_TYPE_LEN);

		len = m_BUFF_MAX_SIZE - ETH8021Q_HEADER_LEN;
		if (!LoadDefaultPacket(IPA_IP_v4,
			m_expectedBuffer1 + ETH8021Q_HEADER_LEN,
			len)) {
			LOG_MSG_ERROR("Failed default Packet\n");
			return false;
		}

		return true;
	} // GenerateExpectedPackets()
};

/*----------------------------------------------------------------------------*/
/* Test07: Header insertion scenario of [ETH_II_802_1Q][IP] ->                */
/* [ETH_II][IP]                                                               */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest07 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest07()
	{
		m_name = "IpaHdrProcCtxTest07";
		m_description =
			"Processing Context test 07 - \
			of [ETH_II_802_1Q][IP] -> [ETH_II][IP] \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST2. \
			Routing rule will use processing context 802_1Q_2_ETH2 \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";

		m_pCurrentProducer = &m_wlanEth2producer;
		m_currProducerClient = IPA_CLIENT_TEST2_PROD;
		m_pCurrentConsumer = &m_defaultConsumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST2_CONS;
		m_procCtxHandleId = PROC_CTX_HANDLE_ID_802_1Q_2_ETH2;
		m_minIPAHwType = IPA_HW_v4_0;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		if (!LoadDefault802_1Q(ip,
			m_sendBuffer1,
			m_sendSize1)) {
			LOG_MSG_ERROR("Failed default Packet\n");
			return false;
		}

		printf("Loaded %zu Bytes to Packet 1\n", m_sendSize1);

		// modify the MAC addresses only
		add_buff(m_sendBuffer1, ETH8021Q_METADATA_OFFSET, 16);

		print_buff(m_sendBuffer1, m_sendSize1);

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		size_t len;

		m_expectedBufferSize1 = m_sendSize1 - ETH8021Q_8021Q_TAG_LEN;

		// copy the ETH2 header to expected buffer
		memcpy(m_expectedBuffer1, ETH2_HDR, ETH_HLEN);

		// fill src and dst mac and ethertype
		memcpy(m_expectedBuffer1, m_sendBuffer1, 2 * ETH_ALEN);
		memcpy(m_expectedBuffer1 + ETH2_ETH_TYPE_OFFSET,
			m_sendBuffer1 + ETH8021Q_ETH_TYPE_OFFSET,
			ETH2_ETH_TYPE_LEN);

		len = m_BUFF_MAX_SIZE - ETH_HLEN;
		if (!LoadDefaultPacket(IPA_IP_v4,
			m_expectedBuffer1 + ETH_HLEN,
			len)) {
			LOG_MSG_ERROR("Failed default Packet\n");
			return false;
		}

		return true;
	} // GenerateExpectedPackets()
};

/*----------------------------------------------------------------------------*/
/* Test08: Header insertion scenario of [ETH_II][IP] ->                       */
/* [ETH_II][IP] with generic ucp command                                      */
/*----------------------------------------------------------------------------*/
class IpaHdrProcCtxTest08 : public IpaHdrProcCtxTestFixture
{
public:
	IpaHdrProcCtxTest08()
	{
		m_name = "IpaHdrProcCtxTest08";
		m_description =
			"Processing Context test 08 - \
			of [ETH_II][IP] -> [ETH_II][IP] with generic ucp \
			1. Generate and commit all headers for all tests. \
			2. Generate and commit all processing context rules \
			for all tests.\
			3. Generate and commit routing table 0. \
			The table contains 1 \"bypass\" rule. \
			All data goes to output pipe TEST2. \
			Routing rule will use processing context ETH2_2_ETH2_EX \
			4. Generate and commit 1 filtering rule. \
			All traffic goes to routing table 0";

		m_pCurrentProducer = &m_eth2Producer;
		m_currProducerClient = IPA_CLIENT_TEST3_PROD;
		m_pCurrentConsumer = &m_defaultConsumer;
		m_currConsumerPipeNum = IPA_CLIENT_TEST2_CONS;
		m_procCtxHandleId = PROC_CTX_HANDLE_ID_ETH2_ETH2_2_ETH2_EX;
		m_minIPAHwType = IPA_HW_v4_0;
		m_maxIPAHwType = IPA_HW_MAX;
		m_runInRegression = false;
		Register(*this);
	}

	virtual bool LoadPackets(enum ipa_ip_type ip)
	{
		if (!Eth2Helper::LoadEth2IP4Packet(
			m_sendBuffer1,
			m_BUFF_MAX_SIZE,
			&m_sendSize1)) {
			LOG_MSG_ERROR("Failed default Packet\n");
			return false;
		}

		printf("Loaded %zu Bytes to Packet 1\n", m_sendSize1);

		// modify the MAC addresses only
		add_buff(m_sendBuffer1, 12, 17);

		print_buff(m_sendBuffer1, m_sendSize1);

		return true;
	}

	virtual bool GenerateExpectedPackets()
	{
		m_expectedBufferSize1 = m_sendSize1;

		// we actually expect the same packet to come out (but after uCP)
		memcpy(m_expectedBuffer1, m_sendBuffer1, m_expectedBufferSize1);

		return true;
	} // GenerateExpectedPackets()
};

static IpaHdrProcCtxTest00 ipaHdrProcCtxTest00;
static IpaHdrProcCtxTest01 ipaHdrProcCtxTest01;
static IpaHdrProcCtxTest02 ipaHdrProcCtxTest02;
static IpaHdrProcCtxTest03 ipaHdrProcCtxTest03;
static IpaHdrProcCtxTest04 ipaHdrProcCtxTest04;
static IpaHdrProcCtxTest05 ipaHdrProcCtxTest05;
static IpaHdrProcCtxTest06 ipaHdrProcCtxTest06;
static IpaHdrProcCtxTest07 ipaHdrProcCtxTest07;
static IpaHdrProcCtxTest08 ipaHdrProcCtxTest08;