android_kernel_samsung_sm8650-modules/kernel-tests/HeaderRemovalTestFixture.cpp

/*
 * Copyright (c) 2017 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 "HeaderRemovalTestFixture.h"

#include "Constants.h"
#include "Logger.h"
#include "IPAFilteringTable.h"

#define IPA_TEST_DMUX_HEADER_LENGTH           8
#define IPA_TEST_META_DATA_IS_VALID           1
#define IPA_TEST_DMUX_HEADER_META_DATA_OFFSET 4

extern Logger g_Logger;

/////////////////////////////////////////////////////////////////////////////////

//define the static Pipes which will be used by all derived tests.
Pipe HeaderRemovalTestFixture::m_A2NDUNToIpaPipe(IPA_CLIENT_TEST2_PROD, IPA_TEST_CONFIFURATION_3);
Pipe HeaderRemovalTestFixture::m_IpaToUsbPipe(IPA_CLIENT_TEST_CONS, IPA_TEST_CONFIFURATION_3);
Pipe HeaderRemovalTestFixture::m_IpaToA2NDUNPipe(IPA_CLIENT_TEST2_CONS, IPA_TEST_CONFIFURATION_3);
Pipe HeaderRemovalTestFixture::m_IpaToQ6LANPipe(IPA_CLIENT_TEST4_CONS, IPA_TEST_CONFIFURATION_3);
RoutingDriverWrapper   HeaderRemovalTestFixture::m_routing;
Filtering HeaderRemovalTestFixture::m_filtering;
const char HeaderRemovalTestFixture_bypass0[20] = "Bypass0";
const char HeaderRemovalTestFixture_bypassIPv60[20] = "BypassIPv60";

/////////////////////////////////////////////////////////////////////////////////

HeaderRemovalTestFixture::HeaderRemovalTestFixture()
{
	m_testSuiteName.push_back("Removal");
	Register(*this);
}

static int SetupKernelModule(void)
{
	int retval;
	struct ipa_channel_config from_ipa_channels[3];
	struct test_ipa_ep_cfg from_ipa_cfg[3];
	struct ipa_channel_config to_ipa_channels[1];
	struct test_ipa_ep_cfg to_ipa_cfg[1];

	struct ipa_test_config_header header = {0};
	struct ipa_channel_config *to_ipa_array[1];
	struct ipa_channel_config *from_ipa_array[3];

	/* From ipa configurations - 3 pipes */
	memset(&from_ipa_cfg[0], 0, sizeof(from_ipa_cfg[0]));
	prepare_channel_struct(&from_ipa_channels[0],
			header.from_ipa_channels_num++,
			IPA_CLIENT_TEST_CONS,
			(void *)&from_ipa_cfg[0],
			sizeof(from_ipa_cfg[0]));
	from_ipa_array[0] = &from_ipa_channels[0];

	memset(&from_ipa_cfg[1], 0, sizeof(from_ipa_cfg[1]));
	prepare_channel_struct(&from_ipa_channels[1],
			header.from_ipa_channels_num++,
			IPA_CLIENT_TEST2_CONS,
			(void *)&from_ipa_cfg[1],
			sizeof(from_ipa_cfg[1]));
	from_ipa_array[1] = &from_ipa_channels[1];

	memset(&from_ipa_cfg[2], 0, sizeof(from_ipa_cfg[2]));
	prepare_channel_struct(&from_ipa_channels[2],
			header.from_ipa_channels_num++,
			IPA_CLIENT_TEST4_CONS,
			(void *)&from_ipa_cfg[2],
			sizeof(from_ipa_cfg[2]));
	from_ipa_array[2] = &from_ipa_channels[2];

	/* To ipa configurations - 1 pipes */
	memset(&to_ipa_cfg[0], 0, sizeof(to_ipa_cfg[0]));
	to_ipa_cfg[0].hdr.hdr_len = IPA_TEST_DMUX_HEADER_LENGTH;
	to_ipa_cfg[0].hdr.hdr_ofst_metadata_valid = IPA_TEST_META_DATA_IS_VALID;
	to_ipa_cfg[0].hdr.hdr_ofst_metadata =
		IPA_TEST_DMUX_HEADER_META_DATA_OFFSET;
	prepare_channel_struct(&to_ipa_channels[0],
			header.to_ipa_channels_num++,
			IPA_CLIENT_TEST2_PROD,
			(void *)&to_ipa_cfg[0],
			sizeof(to_ipa_cfg[0]));
	to_ipa_array[0] = &to_ipa_channels[0];

	header.head_marker = IPA_TEST_CONFIG_MARKER;
	header.tail_marker = IPA_TEST_CONFIG_MARKER;

	prepare_header_struct(&header, from_ipa_array, to_ipa_array);

	retval = GenericConfigureScenario(&header);

	return retval;
}

/////////////////////////////////////////////////////////////////////////////////

bool HeaderRemovalTestFixture::Setup()
{
	bool bRetVal = true;

	//Set the configuration to support USB->IPA and IPA->USB pipes.
	//ConfigureScenario(PHASE_THREE_TEST_CONFIGURATION);

	bRetVal = SetupKernelModule();
	if (bRetVal != true) {
		return bRetVal;
	}

	//Initialize the pipe for all the tests - this will open the inode which represents the pipe.
	bRetVal &= m_A2NDUNToIpaPipe.Init();
	bRetVal &= m_IpaToUsbPipe.Init();
	bRetVal &= m_IpaToA2NDUNPipe.Init();
	bRetVal &= m_IpaToQ6LANPipe.Init();

	// remove default "LAN" routing table (as we want to pass to USB pipe)
	m_routing.Reset(IPA_IP_v4);
	m_routing.Reset(IPA_IP_v6);

	return bRetVal;
}

/////////////////////////////////////////////////////////////////////////////////

bool HeaderRemovalTestFixture::Teardown()
{
	//The Destroy method will close the inode.
	m_A2NDUNToIpaPipe.Destroy();
	m_IpaToUsbPipe.Destroy();
	m_IpaToA2NDUNPipe.Destroy();
	m_IpaToQ6LANPipe.Destroy();
	return true;
}

/////////////////////////////////////////////////////////////////////////////////

Byte* HeaderRemovalTestFixture::CreateA2NDUNPacket(
		unsigned int magicNumber,
		unsigned int nID,
		string sPayloadFileName,
		unsigned int *nTotalLength)
{
	size_t nIpv4ByteSize = 1024;
	bool bRetVal = false;
	Byte *pA2NDUNPacket = 0;
	unsigned int nA2NDUNPacketByteSize = 0;
	Byte *pIpv4Packet = (Byte*) malloc(1024);

	if(0 == pIpv4Packet)
	{
		LOG_MSG_ERROR("Cannot allocate the memory for IPv4 packet");
		return 0;
	}

	bRetVal = LoadDefaultPacket(IPA_IP_v4, pIpv4Packet, nIpv4ByteSize);
	if(false == bRetVal)
	{
		LOG_MSG_ERROR("Cannot load the packet");
		pA2NDUNPacket = 0;
		goto bail;
	}
	//Magic Number(4 Bytes) Logical Channel ID(2 Bytes)  Length(2 Bytes)
	nA2NDUNPacketByteSize = m_A2NDUNToIpaPipe.GetHeaderLengthAdd() +  nIpv4ByteSize;

	pA2NDUNPacket = new Byte[ nA2NDUNPacketByteSize ];

	//htobe32 for the magic number:
	pA2NDUNPacket[0] = (magicNumber & 0xFF000000) >> 24;//MSB
	pA2NDUNPacket[1] = (magicNumber & 0x00FF0000) >> 16;
	pA2NDUNPacket[2] = (magicNumber & 0x0000FF00) >>  8;
	pA2NDUNPacket[3] = (magicNumber & 0x000000FF) >>  0;//LSB

	//htobe16 for the Logical Channel ID:
	pA2NDUNPacket[4] = (nID & 0xFF00) >>  8;//MSB
	pA2NDUNPacket[5] = (nID & 0x00FF) >>  0;//LSB

	//htobe16 for the Length of the packet:
	pA2NDUNPacket[6] = (nA2NDUNPacketByteSize & 0xFF00) >> 8;//MSB
	pA2NDUNPacket[7] = (nA2NDUNPacketByteSize & 0x00FF) >> 0;//LSB

	//add the payload to the A2NDUN packet
	memcpy(&pA2NDUNPacket[8], pIpv4Packet, nIpv4ByteSize);

	*nTotalLength = nA2NDUNPacketByteSize;

/* fall through */

bail:

	Free(pIpv4Packet);

	return pA2NDUNPacket;
}

/////////////////////////////////////////////////////////////////////////////////

bool HeaderRemovalTestFixture::SetIPATablesToPassAllToSpecificClient(
		enum ipa_client_type  nClientTypeSrc,
		enum ipa_client_type nClientTypeDst)
{
	bool bRetVal = true;

	bRetVal = SetRoutingTableToPassAllToSpecificClient(nClientTypeDst);
	if(false == bRetVal)
		goto bail;
	bRetVal = SetFilterTableToPassAllToSpecificClient(nClientTypeSrc);
	if(false == bRetVal)
		goto bail;
	bRetVal = SetHeaderInsertionTableAddEmptyHeaderForTheClient(nClientTypeSrc);
	if(false == bRetVal)
		goto bail;
/* fall through */

bail:
	return bRetVal;
}

/////////////////////////////////////////////////////////////////////////////////

bool  HeaderRemovalTestFixture::SetFilterTableToPassAllToSpecificClient(
		enum ipa_client_type  nClientType)
{
	IPAFilteringTable         FilterTable;
	struct ipa_flt_rule_add   flt_rule_entry;
	struct ipa_ioc_get_rt_tbl sRoutingTable;

	sRoutingTable.ip = IPA_IP_v4;
	strlcpy(sRoutingTable.name, "Bypass0", sizeof(sRoutingTable.name));

	if (false == m_routing.GetRoutingTable(&sRoutingTable)) {
	  LOG_MSG_ERROR("Configure the routing block first");
	  return false;
	}

	FilterTable.Init(IPA_IP_v4, nClientType, false, 1);
	FilterTable.GeneratePresetRule(0, flt_rule_entry);
	flt_rule_entry.at_rear                        = true;
	flt_rule_entry.flt_rule_hdl                   = -1;
	flt_rule_entry.status                         = -1;
	flt_rule_entry.rule.action                    = IPA_PASS_TO_ROUTING;
	flt_rule_entry.rule.rt_tbl_hdl                = sRoutingTable.hdl;
	flt_rule_entry.rule.attrib.attrib_mask        = IPA_FLT_DST_ADDR;
	flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0x00000000;
	flt_rule_entry.rule.attrib.u.v4.dst_addr      = 0x00000000;
	if ((-1 == FilterTable.AddRuleToTable(flt_rule_entry)) ||
			!m_filtering.AddFilteringRule(FilterTable.GetFilteringTable())) {
		LOG_MSG_INFO ("%s::Error Adding RuleTable(0) to Filtering, aborting...");
		return false;
	} else {
		LOG_MSG_INFO( "flt rule hdl0=0x%x, status=0x%x",
				FilterTable.ReadRuleFromTable(0)->flt_rule_hdl,
					FilterTable.ReadRuleFromTable(0)->status);
	}
	LOG_MSG_INFO("Leaving ");

	return true;
}
/////////////////////////////////////////////////////////////////////////////////

bool  HeaderRemovalTestFixture::SetRoutingTableToPassAllToSpecificClient(
		enum ipa_client_type  nClientType)
{
	if (!CreateBypassRoutingTablesIPv4(
			HeaderRemovalTestFixture_bypass0,
			nClientType)) {
		LOG_MSG_INFO("CreateThreeBypassRoutingTables Failed");
		return false;
	}
	return true;
}

/////////////////////////////////////////////////////////////////////////////////

bool  HeaderRemovalTestFixture::SetHeaderInsertionTableAddEmptyHeaderForTheClient(
		enum ipa_client_type  nClientType)
{
	//TODO Header Removal: add header insertion data
	return true;
}

/////////////////////////////////////////////////////////////////////////////////
// This function creates IPv4 bypass routing entry and commits it.
bool HeaderRemovalTestFixture::CreateBypassRoutingTablesIPv4(
		const char * bypass0,
		enum ipa_client_type  nClientType)
{
	struct ipa_ioc_add_rt_rule *rt_rule0 = 0;
	struct ipa_rt_rule_add *rt_rule_entry;

	LOG_MSG_INFO("Entering");

	rt_rule0 = (struct ipa_ioc_add_rt_rule *)
		calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
				1*sizeof(struct ipa_rt_rule_add));
	if (!rt_rule0) {
		LOG_MSG_INFO("calloc failed to allocate rt_rule0");
		return false;
	}

	rt_rule0->num_rules = 1;
	rt_rule0->ip = IPA_IP_v4;
	rt_rule0->commit = true;
	strlcpy(rt_rule0->rt_tbl_name, bypass0, sizeof(rt_rule0->rt_tbl_name));

	rt_rule_entry = &rt_rule0->rules[0];
	rt_rule_entry->at_rear = 0;
	rt_rule_entry->rule.dst = nClientType;
//    rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // gidons, there is no support for header insertion / removal yet.
	rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
	rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xaabbccdd;
	rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0x00000000;// All Packets will get a "Hit"
	if (false == m_routing.AddRoutingRule(rt_rule0)) {
		LOG_MSG_INFO("Routing rule addition(rt_rule0) failed!");
		Free (rt_rule0);
		return false;
	}

	Free (rt_rule0);
	LOG_MSG_INFO("Leaving ");
	return true;
}

bool HeaderRemovalTestFixture::ConfigureFilteringBlockWithMetaDataEq(
		enum ipa_client_type  nClientType,
		unsigned int nMetaData,
		unsigned int nMetaDataMask)
{
	const char bypass0[20] = "Bypass0";
	struct ipa_ioc_get_rt_tbl routing_table0;
	IPAFilteringTable FilterTable0;
	struct ipa_flt_rule_add flt_rule_entry;

	LOG_MSG_INFO("Entering ");

	if (!CreateBypassRoutingTablesIPv4(
			HeaderRemovalTestFixture_bypass0,
				nClientType)) {
		LOG_MSG_INFO("CreateBypassRoutingTablesIPv4 Failed");
		return false;
	}

	LOG_MSG_INFO("CreateBypassRoutingTablesIPv4 completed successfully");
	routing_table0.ip = IPA_IP_v4;
	strlcpy(routing_table0.name, bypass0, sizeof(routing_table0.name));
	if (!m_routing.GetRoutingTable(&routing_table0)) {
		LOG_MSG_INFO(
				"m_routing.GetRoutingTable(&routing_table0=0x%p) Failed."
					,&routing_table0);
		return false;
	}

	FilterTable0.Init(IPA_IP_v4, IPA_CLIENT_TEST2_PROD, false, 1);

	LOG_MSG_INFO("FilterTable*.Init Completed Successfully..");

	// Configuring Filtering Rule No.0
	FilterTable0.GeneratePresetRule(1,flt_rule_entry);
	flt_rule_entry.at_rear                        = true;
	flt_rule_entry.flt_rule_hdl                   = -1; // return Value
	flt_rule_entry.status                         = -1; // return value
	flt_rule_entry.rule.action                    = IPA_PASS_TO_ROUTING;
	flt_rule_entry.rule.rt_tbl_hdl                = routing_table0.hdl; //put here the handle corresponding to Routing Rule 1
	flt_rule_entry.rule.attrib.attrib_mask        = IPA_FLT_META_DATA;
	flt_rule_entry.rule.attrib.meta_data          = nMetaData;
	flt_rule_entry.rule.attrib.meta_data_mask     = nMetaDataMask;
	if ( (-1 == FilterTable0.AddRuleToTable(flt_rule_entry)) ||
			!m_filtering.AddFilteringRule(FilterTable0.GetFilteringTable()))
	{
		LOG_MSG_INFO ("%s::Error Adding RuleTable(0) to Filtering, aborting...");
		return false;
	} else {
		LOG_MSG_INFO("flt rule hdl0=0x%x, status=0x%x", FilterTable0.ReadRuleFromTable(0)->flt_rule_hdl,FilterTable0.ReadRuleFromTable(0)->status);
	}

	LOG_MSG_INFO("Leaving ");

	return true;
}