tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
M7350/qcom-opensource/kernel/kernel-tests/ip_accelerator/RoutingTests.cpp
T f75098198c M7350v5_en_gpl
2024-09-09 08:57:42 +00:00

4258 lines
128 KiB
C++
Raw Permalink Blame History

/*
* Copyright (c) 2014-2015, 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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include "hton.h" // for htonl
#include "InterfaceAbstraction.h"
#include "Constants.h"
#include "Logger.h"
#include "TestsUtils.h"
#include "linux/msm_ipa.h"
#include "RoutingDriverWrapper.h"
#include "Filtering.h"
#include "IPAFilteringTable.h"
#define TOS_FIELD_OFFSET (1)
#define DST_ADDR_LSB_OFFSET_IPV4 (19)
#define DST_ADDR_MSB_OFFSET_IPV6 (24)
#define DST_ADDR_LSB_OFFSET_IPV6 (39)
#define TRAFFIC_CLASS_MSB_OFFSET_IPV6 (0)
#define TRAFFIC_CLASS_LSB_OFFSET_IPV6 (1)
#define FLOW_CLASS_MSB_OFFSET_IPV6 (1)
#define FLOW_CLASS_MB_OFFSET_IPV6 (2)
#define FLOW_CLASS_LSB_OFFSET_IPV6 (3)
#define IPV4_DST_PORT_OFFSET (20+2)
#define IPV6_SRC_PORT_OFFSET (40)
#define IPV6_DST_PORT_OFFSET (40+2)
extern Logger g_Logger;
class IpaRoutingBlockTestFixture:public TestBase
{
public:
IpaRoutingBlockTestFixture():
m_sendSize (BUFF_MAX_SIZE),
m_sendSize2 (BUFF_MAX_SIZE),
m_sendSize3 (BUFF_MAX_SIZE),
m_IpaIPType(IPA_IP_v4)
{
memset(m_sendBuffer, 0, sizeof(m_sendBuffer));
memset(m_sendBuffer2, 0, sizeof(m_sendBuffer2));
memset(m_sendBuffer3, 0, sizeof(m_sendBuffer3));
m_testSuiteName.push_back("Routing");
}
static int SetupKernelModule(bool en_status = false)
{
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_TEST2_CONS,
(void *)&from_ipa_cfg[0],
sizeof(from_ipa_cfg[0]), en_status);
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_TEST3_CONS,
(void *)&from_ipa_cfg[1],
sizeof(from_ipa_cfg[1]), en_status);
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]), en_status);
from_ipa_array[2] = &from_ipa_channels[2];
/* To ipa configurations - 1 pipes */
memset(&to_ipa_cfg[0], 0, sizeof(to_ipa_cfg[0]));
prepare_channel_struct(&to_ipa_channels[0],
header.to_ipa_channels_num++,
IPA_CLIENT_TEST_PROD,
(void *)&to_ipa_cfg[0],
sizeof(to_ipa_cfg[0]));
to_ipa_array[0] = &to_ipa_channels[0];
prepare_header_struct(&header, from_ipa_array, to_ipa_array);
retval = GenericConfigureScenario(&header);
return retval;
}
bool Setup(bool en_status)
{
bool bRetVal = true;
bRetVal = SetupKernelModule(en_status);
if (bRetVal != true) {
return bRetVal;
}
m_producer.Open(INTERFACE0_TO_IPA_DATA_PATH, INTERFACE0_FROM_IPA_DATA_PATH);
m_consumer.Open(INTERFACE1_TO_IPA_DATA_PATH, INTERFACE1_FROM_IPA_DATA_PATH);
m_consumer2.Open(INTERFACE2_TO_IPA_DATA_PATH, INTERFACE2_FROM_IPA_DATA_PATH);
m_defaultConsumer.Open(INTERFACE3_TO_IPA_DATA_PATH, INTERFACE3_FROM_IPA_DATA_PATH);
if (!m_routing.DeviceNodeIsOpened()) {
printf("Routing block is not ready for immediate commands!\n");
return false;
}
if (!m_filtering.DeviceNodeIsOpened()) {
printf("Filtering block is not ready for immediate commands!\n");
return false;
}
m_routing.Reset(IPA_IP_v4);
m_routing.Reset(IPA_IP_v6);
return true;
} /* Setup()*/
bool Setup()
{
return Setup(false);
}
bool Teardown()
{
if (!m_routing.DeviceNodeIsOpened()) {
printf("Routing block is not ready for immediate commands!\n");
return false;
}
if (!m_filtering.DeviceNodeIsOpened()) {
printf("Filtering block is not ready for immediate commands!\n");
return false;
}
m_producer.Close();
m_consumer.Close();
m_consumer2.Close();
m_defaultConsumer.Close();
return true;
} /* Teardown() */
bool LoadFiles(enum ipa_ip_type ip)
{
string fileName;
if (IPA_IP_v4 == ip) {
fileName = "Input/IPv4_1";
} else {
fileName = "Input/IPv6";
}
if (!LoadDefaultPacket(ip, m_sendBuffer, m_sendSize)) {
LOG_MSG_ERROR("Failed loading default Packet");
return false;
}
if (!LoadDefaultPacket(ip, m_sendBuffer2, m_sendSize2)) {
LOG_MSG_ERROR("Failed loading default Packet");
return false;
}
if (!LoadDefaultPacket(ip, m_sendBuffer3, m_sendSize3)) {
LOG_MSG_ERROR("Failed loading default Packet");
return false;
}
return true;
}
bool ReceivePacketAndCompareFrom(InterfaceAbstraction& cons, Byte* send, size_t send_sz, InterfaceAbstraction& excp_cons)
{
size_t receivedSize = 0;
bool isSuccess = true;
/* Receive results*/
Byte *rxBuff1 = new Byte[0x400];
if (NULL == rxBuff1)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = cons.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, cons.m_fromChannelName.c_str());
// Compare results
isSuccess &= CompareResultVsGolden(send, send_sz, rxBuff1, receivedSize);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
// char * p = recievedBuffer;
size_t j;
for(j = 0; j < m_sendSize; j++)
snprintf(&SentBuffer[3*j], sizeof(SentBuffer) - (3*j + 1), " %02X", send[j]);
for(j = 0; j < receivedSize; j++)
// recievedBuffer += sprintf(recievedBuffer, "%02X", rxBuff1[i]);
snprintf(&recievedBuffer[3*j], sizeof(recievedBuffer) - (3*j + 1), " %02X", rxBuff1[j]);
printf("Expected Value (%zu)\n%s\n, Received Value1(%zu)\n%s\n",send_sz,SentBuffer,receivedSize,recievedBuffer);
delete[] rxBuff1;
receivedSize = excp_cons.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, excp_cons.m_fromChannelName.c_str());
return isSuccess;
}
bool ReceivePacketsAndCompare()
{
size_t receivedSize = 0;
size_t receivedSize2 = 0;
size_t receivedSize3 = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
Byte *rxBuff2 = new Byte[0x400];
Byte *rxBuff3 = new Byte[0x400];
if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
receivedSize2 = m_consumer2.ReceiveData(rxBuff2, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= CompareResultVsGolden(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
isSuccess &= CompareResultVsGolden(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
// char * p = recievedBuffer;
size_t j;
for(j = 0; j < m_sendSize; j++)
snprintf(&SentBuffer[3*j], sizeof(SentBuffer) - (3*j + 1), " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
// recievedBuffer += sprintf(recievedBuffer, "%02X", rxBuff1[i]);
snprintf(&recievedBuffer[3*j], sizeof(recievedBuffer) - (3*j + 1), " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
for(j = 0; j < m_sendSize2; j++)
snprintf(&SentBuffer[3*j], sizeof(SentBuffer) - (3*j + 1), " %02X", m_sendBuffer2[j]);
for(j = 0; j < receivedSize2; j++)
// recievedBuffer += sprintf(recievedBuffer, "%02X", rxBuff1[i]);
snprintf(&recievedBuffer[3*j], sizeof(recievedBuffer) - (3*j + 1), " %02X", rxBuff2[j]);
printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n",m_sendSize2,SentBuffer,receivedSize2,recievedBuffer);
for(j = 0; j < m_sendSize3; j++)
snprintf(&SentBuffer[3*j], sizeof(SentBuffer) - (3*j + 1), " %02X", m_sendBuffer3[j]);
for(j = 0; j < receivedSize3; j++)
// recievedBuffer += sprintf(recievedBuffer, "%02X", rxBuff1[i]);
snprintf(&recievedBuffer[3*j], sizeof(recievedBuffer) - (3*j + 1), " %02X", rxBuff3[j]);
printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n",m_sendSize3,SentBuffer,receivedSize3,recievedBuffer);
delete[] rxBuff1;
delete[] rxBuff2;
delete[] rxBuff3;
return isSuccess;
}
~IpaRoutingBlockTestFixture()
{
// free(m_sendBuffer);
// free(m_sendBuffer2);
// free(m_sendBuffer3);
m_sendSize = 0;
m_sendSize2 = 0;
m_sendSize3 = 0;
}
void InitFilteringBlock()
{
IPAFilteringTable fltTable;
struct ipa_ioc_get_rt_tbl st_rt_tbl;
struct ipa_flt_rule_add flt_rule_entry;
memset(&st_rt_tbl, 0, sizeof(st_rt_tbl));
memset(&flt_rule_entry, 0, sizeof(flt_rule_entry));
strlcpy(st_rt_tbl.name, "LAN", sizeof(st_rt_tbl.name));
st_rt_tbl.ip = m_IpaIPType;
fltTable.Init(m_IpaIPType, IPA_CLIENT_TEST_PROD, false, 1);
m_routing.GetRoutingTable(&st_rt_tbl);
flt_rule_entry.rule.rt_tbl_hdl = st_rt_tbl.hdl;
fltTable.AddRuleToTable(flt_rule_entry);
m_filtering.AddFilteringRule(fltTable.GetFilteringTable());
}
inline bool VerifyStatusReceived(size_t SendSize, size_t RecvSize)
{
if ((RecvSize <= SendSize) ||
((RecvSize - SendSize) != sizeof(struct ipa3_hw_pkt_status))){
printf("received buffer size does not match! sent:receive [%d]:[%d]\n",SendSize,RecvSize);
return false;
}
return true;
}
inline bool IsCacheHit(size_t SendSize, size_t RecvSize, void *Buff)
{
struct ipa3_hw_pkt_status *pStatus = (struct ipa3_hw_pkt_status *)Buff;
if (VerifyStatusReceived(SendSize,RecvSize) == false){
return false;
}
if((bool)pStatus->route_hash){
printf ("%s::cache hit!! \n",__FUNCTION__);
return true;
}
printf ("%s::cache miss!! \n",__FUNCTION__);
return false;
}
inline bool IsCacheMiss(size_t SendSize, size_t RecvSize, void *Buff)
{
struct ipa3_hw_pkt_status *pStatus = (struct ipa3_hw_pkt_status *)Buff;
if (VerifyStatusReceived(SendSize,RecvSize) == false){
return false;
}
if(!((bool)pStatus->route_hash)){
printf ("%s::cache miss!! \n",__FUNCTION__);
return true;
}
printf ("%s::cache hit!! \n",__FUNCTION__);
return false;
}
static RoutingDriverWrapper m_routing;
static Filtering m_filtering;
static const size_t BUFF_MAX_SIZE = 1024;
InterfaceAbstraction m_producer;
InterfaceAbstraction m_consumer;
InterfaceAbstraction m_consumer2;
InterfaceAbstraction m_defaultConsumer;
Byte m_sendBuffer[BUFF_MAX_SIZE]; // First input file / IP packet
Byte m_sendBuffer2[BUFF_MAX_SIZE]; // Second input file / IP packet
Byte m_sendBuffer3[BUFF_MAX_SIZE]; // Third input file (default) / IP packet
size_t m_sendSize;
size_t m_sendSize2;
size_t m_sendSize3;
enum ipa_ip_type m_IpaIPType;
private:
};
RoutingDriverWrapper IpaRoutingBlockTestFixture::m_routing;
Filtering IpaRoutingBlockTestFixture::m_filtering;
/*---------------------------------------------------------------------------*/
/* Test1: Tests routing by destination address */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest1 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest1()
{
m_name = "IpaRoutingBlockTest1";
m_description =" \
Routing block test 001 - Destination address exact match\1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.169.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.255 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// 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 = 0xC0A802FF;
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// 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 = 0xC0A802AA;
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*---------------------------------------------------------------------------*/
/* Test2: Tests routing by destination address with a subnet (mask) */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest2 : IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest2()
{
m_name = "IpaRoutingBlockTest2";
m_description =" \
Routing block test 002 - Destination address subnet match \
1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.169.170.0 & 255.255.255.0)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.255.0 & 255.255.255.0)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
printf("ENTRY: IpaRoutingBlockTest2::Run()\n");
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[18] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[18] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
printf("ENTRY: IpaRoutingBlockTest2::AddRules()\n");
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// 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 = 0xC0A8FF00;
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFF00;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// 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 = 0xC0A8AA00;
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFF00;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
printf("Before calling m_routing.AddRoutingRule()\n");
printf("m_routing = %p\n", &m_routing);
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*---------------------------------------------------------------------------*/
/* Test3: Tests routing by TOS (Type Of Service) */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest3 : IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest3()
{
m_name = "IpaRoutingBlockTest3";
m_description = " \
Routing block test 003 - TOS exact match\
1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match). \
All TOS == 0xFF traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All TOS == 0xAA traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[TOS_FIELD_OFFSET] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[TOS_FIELD_OFFSET] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if (!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// 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_TOS;
rt_rule_entry->rule.attrib.u.v4.tos = 0xFF;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// 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_TOS;
rt_rule_entry->rule.attrib.u.v4.tos = 0xAA;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*---------------------------------------------------------------------------*/
/* Test4: Destination address exact match and TOS exact match */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest4 : IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest4()
{
m_name = "IpaRoutingBlockTest4";
m_description =" \
Routing block test 004 - Destination address and TOS exact match \
1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.169.2.170 & 255.255.255.255) and TOS == 0xFF traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.255 & 255.255.255.255) and TOS == 0xAA traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[TOS_FIELD_OFFSET] = 0xFF;
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[TOS_FIELD_OFFSET] = 0xAA;
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// 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_TOS | IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.tos = 0xFF;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802FF;
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// 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_TOS | IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.tos = 0xAA;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA;
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*---------------------------------------------------------------------------*/
/* Test1: IPv6 - Tests routing by destination address */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest5 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest5()
{
m_name = "IpaRoutingBlockTest5";
m_description =" \
Routing block test 005 - IPv6 Destination address exact match \
1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF \
traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF \
traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// 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.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// 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.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000AA;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*---------------------------------------------------------------------------*/
/* Test5: IPv6 - Tests routing by destination address */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest006 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest006()
{
m_name = "IpaRoutingBlockTest006";
m_description =" \
Routing block test 006 - IPv6 Destination address Subnet match \
1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match 0xFFFFFFFF,0xFFFFFFFF,0x00000000,0x0000000). \
All DST_IP == 0X11020000 \
0x00000000 \
0x00000000 \
0X0000000C \
traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == 0X22020000 \
0x00000000 \
0x00000000 \
0X0000000C \
traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_MSB_OFFSET_IPV6] = 0x11;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_MSB_OFFSET_IPV6] = 0x22;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // TODO: Header Insertion 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.v6.dst_addr[0] = 0X11020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X0000000C;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0x00000000;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // TODO: Header Insertion 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.v6.dst_addr[0] = 0X22020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X0000000C;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0x00000000;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*---------------------------------------------------------------------------*/
/* Test1: IPv6 - Tests routing by destination address */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest007 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest007()
{
m_name = "IpaRoutingBlockTest007";
m_description = " \
Routing block test 007 - IPv6 Exact Traffic Class Match \
1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match). \
All Traffic Class == 0xAA traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All Traffic Class == 0xBB traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[TRAFFIC_CLASS_MSB_OFFSET_IPV6] &= 0xF0;
m_sendBuffer[TRAFFIC_CLASS_MSB_OFFSET_IPV6] |= 0x0A;
m_sendBuffer[TRAFFIC_CLASS_LSB_OFFSET_IPV6] &= 0x0F;
m_sendBuffer[TRAFFIC_CLASS_LSB_OFFSET_IPV6] |= 0xA0;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[TRAFFIC_CLASS_MSB_OFFSET_IPV6] &= 0xF0;
m_sendBuffer2[TRAFFIC_CLASS_MSB_OFFSET_IPV6] |= 0x0B;
m_sendBuffer2[TRAFFIC_CLASS_LSB_OFFSET_IPV6] &= 0x0F;
m_sendBuffer2[TRAFFIC_CLASS_LSB_OFFSET_IPV6] |= 0xB0;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // TODO: Header Insertion gidons, there is no support for header insertion / removal yet.
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_TC;
rt_rule_entry->rule.attrib.u.v6.tc = 0xAA;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // TODO: Header Insertion gidons, there is no support for header insertion / removal yet.
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_TC;
rt_rule_entry->rule.attrib.u.v6.tc = 0xBB;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*---------------------------------------------------------------------------*/
/* Test1: IPv6 - Tests routing by destination address */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest008 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest008()
{
m_name = "IpaRoutingBlockTest008";
m_description = " \
Routing block test 008 - IPv6 Destination address exact match and Traffic Class Match \
1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match). \
All Traffic Class == 0xAA & IPv6 DST Addr 0xFF020000...00AA traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All Traffic Class == 0xBB & IPv6 DST Addr 0xFF020000...00BB traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[TRAFFIC_CLASS_MSB_OFFSET_IPV6] &= 0xF0;
m_sendBuffer[TRAFFIC_CLASS_MSB_OFFSET_IPV6] |= 0x0A;
m_sendBuffer[TRAFFIC_CLASS_LSB_OFFSET_IPV6] &= 0x0F;
m_sendBuffer[TRAFFIC_CLASS_LSB_OFFSET_IPV6] |= 0xA0;
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[TRAFFIC_CLASS_MSB_OFFSET_IPV6] &= 0xF0;
m_sendBuffer2[TRAFFIC_CLASS_MSB_OFFSET_IPV6] |= 0x0B;
m_sendBuffer2[TRAFFIC_CLASS_LSB_OFFSET_IPV6] &= 0x0F;
m_sendBuffer2[TRAFFIC_CLASS_LSB_OFFSET_IPV6] |= 0xB0;
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// 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 | IPA_FLT_TC;
rt_rule_entry->rule.attrib.u.v6.tc = 0xAA;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// 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 | IPA_FLT_TC;
rt_rule_entry->rule.attrib.u.v6.tc = 0xBB;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000AA;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*---------------------------------------------------------------------------*/
/* Test1: IPv6 - Tests routing by destination address */
/*---------------------------------------------------------------------------*/
class IpaRoutingBlockTest009 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest009()
{
m_name = "IpaRoutingBlockTest009";
m_description = " \
Routing block test 009 - IPv6 Exact Flow Label Match \
1. Generate and commit a single routing tables. \
2. Generate and commit Three routing rules: (DST & Mask Match). \
All Flow Label == 0xABCDE traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All Flow Label == 0x12345 traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
Register(*this);
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[FLOW_CLASS_MSB_OFFSET_IPV6] &= 0xF0;
m_sendBuffer[FLOW_CLASS_MSB_OFFSET_IPV6] |= 0x0A;
m_sendBuffer[FLOW_CLASS_MB_OFFSET_IPV6] = 0xBC;
m_sendBuffer[FLOW_CLASS_LSB_OFFSET_IPV6] = 0xDE;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[FLOW_CLASS_MSB_OFFSET_IPV6] &= 0xF0;
m_sendBuffer2[FLOW_CLASS_MSB_OFFSET_IPV6] |= 0x01;
m_sendBuffer2[FLOW_CLASS_MB_OFFSET_IPV6] = 0x23;
m_sendBuffer2[FLOW_CLASS_LSB_OFFSET_IPV6] = 0x45;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
// 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_FLOW_LABEL;
rt_rule_entry->rule.attrib.u.v6.flow_label = 0xABCDE;
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
// 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_FLOW_LABEL;
rt_rule_entry->rule.attrib.u.v6.flow_label = 0x12345;
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
};
/*--------------------------------------------------------------------------*/
/* Test10: IPv4 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest010 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest010()
{
m_name = "IpaRoutingBlockTest10";
m_description =" \
Routing block test 010 - Destination address exact match non hashable priority higher than hashable \
both match the packet but only non hashable should hit\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
m_minIPAHwType = IPA_HW_v3_0;
Register(*this);
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool ReceivePacketsAndCompare()
{
size_t receivedSize = 0;
size_t receivedSize2 = 0;
size_t receivedSize3 = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
Byte *rxBuff2 = new Byte[0x400];
Byte *rxBuff3 = new Byte[0x400];
if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
receivedSize2 = m_consumer.ReceiveData(rxBuff2, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= CompareResultVsGolden(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
isSuccess &= CompareResultVsGolden(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
size_t j;
for(j = 0; j < m_sendSize; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
for(j = 0; j < m_sendSize2; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer2[j]);
for(j = 0; j < receivedSize2; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff2[j]);
printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n",m_sendSize2,SentBuffer,receivedSize2,recievedBuffer);
for(j = 0; j < m_sendSize3; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer3[j]);
for(j = 0; j < receivedSize3; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff3[j]);
printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n",m_sendSize3,SentBuffer,receivedSize3,recievedBuffer);
delete[] rxBuff1;
delete[] rxBuff2;
delete[] rxBuff3;
return isSuccess;
}
};
/*--------------------------------------------------------------------------*/
/* Test11: IPv4 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest011 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest011()
{
m_name = "IpaRoutingBlockTest011";
m_description =" \
Routing block test 011 - Destination address exact match hashable priority higher than non hashable \
both match the packet but only hashable should hit, second packet should get cache hit\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
m_minIPAHwType = IPA_HW_v3_0;
Register(*this);
}
bool Setup()
{
return IpaRoutingBlockTestFixture:: Setup(true);
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool ReceivePacketsAndCompare()
{
size_t receivedSize = 0;
size_t receivedSize2 = 0;
size_t receivedSize3 = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
Byte *rxBuff2 = new Byte[0x400];
Byte *rxBuff3 = new Byte[0x400];
if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
receivedSize2 = m_consumer.ReceiveData(rxBuff2, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
isSuccess &= IsCacheMiss(m_sendSize,receivedSize,rxBuff1);
isSuccess &= IsCacheHit(m_sendSize2,receivedSize2,rxBuff2);
isSuccess &= IsCacheMiss(m_sendSize3,receivedSize3,rxBuff3);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
size_t j;
for(j = 0; j < m_sendSize; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
for(j = 0; j < m_sendSize2; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer2[j]);
for(j = 0; j < receivedSize2; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff2[j]);
printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n",m_sendSize2,SentBuffer,receivedSize2,recievedBuffer);
for(j = 0; j < m_sendSize3; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer3[j]);
for(j = 0; j < receivedSize3; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff3[j]);
printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n",m_sendSize3,SentBuffer,receivedSize3,recievedBuffer);
delete[] rxBuff1;
delete[] rxBuff2;
delete[] rxBuff3;
return isSuccess;
}
};
/*--------------------------------------------------------------------------*/
/* Test12: IPv4 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest012 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest012()
{
m_name = "IpaRoutingBlockTest012";
m_description =" \
Routing block test 012 - Destination address exact match hashable priority lower than non hashable \
no match on non hashable rule (with higher priority), match on hashable rule. two packets with\
different tuple are sent (but match the rule) cache miss expected\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.171 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
m_minIPAHwType = IPA_HW_v3_0;
Register(*this);
}
bool Setup()
{
return IpaRoutingBlockTestFixture:: Setup(true);
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AB; //192.168.02.171
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
unsigned short port;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
port = ntohs(547);//DHCP Client Port
memcpy (&m_sendBuffer[IPV4_DST_PORT_OFFSET], &port, sizeof(port));
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
port = ntohs(546);//DHCP Client Port
memcpy (&m_sendBuffer2[IPV4_DST_PORT_OFFSET], &port, sizeof(port));
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool ReceivePacketsAndCompare()
{
size_t receivedSize = 0;
size_t receivedSize2 = 0;
size_t receivedSize3 = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
Byte *rxBuff2 = new Byte[0x400];
Byte *rxBuff3 = new Byte[0x400];
if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer2.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer2.m_fromChannelName.c_str());
receivedSize2 = m_consumer2.ReceiveData(rxBuff2, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
isSuccess &= IsCacheMiss(m_sendSize,receivedSize,rxBuff1);
isSuccess &= IsCacheMiss(m_sendSize2,receivedSize2,rxBuff2);
isSuccess &= IsCacheMiss(m_sendSize3,receivedSize3,rxBuff3);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
size_t j;
for(j = 0; j < m_sendSize; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
for(j = 0; j < m_sendSize2; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer2[j]);
for(j = 0; j < receivedSize2; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff2[j]);
printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n",m_sendSize2,SentBuffer,receivedSize2,recievedBuffer);
for(j = 0; j < m_sendSize3; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer3[j]);
for(j = 0; j < receivedSize3; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff3[j]);
printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n",m_sendSize3,SentBuffer,receivedSize3,recievedBuffer);
delete[] rxBuff1;
delete[] rxBuff2;
delete[] rxBuff3;
return isSuccess;
}
};
/*--------------------------------------------------------------------------*/
/* Test13: IPv4 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest013 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest013()
{
m_name = "IpaRoutingBlockTest013";
m_description =" \
Routing block test 013 - Destination address exact match \
no match on non hashable rule (with lower priority), match on hashable rule. two packets with\
different tuple are sent (but match the rule) cache miss expected\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.171 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
m_minIPAHwType = IPA_HW_v3_0;
Register(*this);
}
bool Setup()
{
return IpaRoutingBlockTestFixture:: Setup(true);
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("fail\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AB; //192.168.02.171
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
unsigned short port;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
port = ntohs(547);//DHCP Client Port
memcpy (&m_sendBuffer[IPV4_DST_PORT_OFFSET], &port, sizeof(port));
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
port = ntohs(546);//DHCP Client Port
memcpy (&m_sendBuffer2[IPV4_DST_PORT_OFFSET], &port, sizeof(port));
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool ReceivePacketsAndCompare()
{
size_t receivedSize = 0;
size_t receivedSize2 = 0;
size_t receivedSize3 = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
Byte *rxBuff2 = new Byte[0x400];
Byte *rxBuff3 = new Byte[0x400];
if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
receivedSize2 = m_consumer.ReceiveData(rxBuff2, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer.m_fromChannelName.c_str());
receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
isSuccess &= IsCacheMiss(m_sendSize,receivedSize,rxBuff1);
isSuccess &= IsCacheMiss(m_sendSize2,receivedSize2,rxBuff2);
isSuccess &= IsCacheMiss(m_sendSize3,receivedSize3,rxBuff3);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
size_t j;
for(j = 0; j < m_sendSize; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
for(j = 0; j < m_sendSize2; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer2[j]);
for(j = 0; j < receivedSize2; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff2[j]);
printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n",m_sendSize2,SentBuffer,receivedSize2,recievedBuffer);
for(j = 0; j < m_sendSize3; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer3[j]);
for(j = 0; j < receivedSize3; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff3[j]);
printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n",m_sendSize3,SentBuffer,receivedSize3,recievedBuffer);
delete[] rxBuff1;
delete[] rxBuff2;
delete[] rxBuff3;
return isSuccess;
}
};
/*--------------------------------------------------------------------------*/
/* Test14: IPv4 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest014 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest014()
{
m_name = "IpaRoutingBlockTest014";
m_description =" \
Routing block test 014 - Destination address exact match \
no match on non hashable rule(with higher priority) , match on hashable rule. two identical\
packets are sent cache hit expected on the second one\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.168.2.171 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
m_minIPAHwType = IPA_HW_v3_0;
Register(*this);
}
bool Setup()
{
return IpaRoutingBlockTestFixture:: Setup(true);
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AB; //192.168.02.171
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
free(rt_rule);
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool ReceivePacketsAndCompare()
{
size_t receivedSize = 0;
size_t receivedSize2 = 0;
size_t receivedSize3 = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
Byte *rxBuff2 = new Byte[0x400];
Byte *rxBuff3 = new Byte[0x400];
if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer2.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer2.m_fromChannelName.c_str());
receivedSize2 = m_consumer2.ReceiveData(rxBuff2, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
isSuccess &= IsCacheMiss(m_sendSize,receivedSize,rxBuff1);
isSuccess &= IsCacheHit(m_sendSize2,receivedSize2,rxBuff2);
isSuccess &= IsCacheMiss(m_sendSize3,receivedSize3,rxBuff3);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
size_t j;
for(j = 0; j < m_sendSize; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
for(j = 0; j < m_sendSize2; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer2[j]);
for(j = 0; j < receivedSize2; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff2[j]);
printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n",m_sendSize2,SentBuffer,receivedSize2,recievedBuffer);
for(j = 0; j < m_sendSize3; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer3[j]);
for(j = 0; j < receivedSize3; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff3[j]);
printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n",m_sendSize3,SentBuffer,receivedSize3,recievedBuffer);
delete[] rxBuff1;
delete[] rxBuff2;
delete[] rxBuff3;
return isSuccess;
}
};
/*--------------------------------------------------------------------------*/
/* Test15: IPv4 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest015 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest015()
{
m_name = "IpaRoutingBlockTest015";
m_description =" \
Routing block test 015 - Destination address exact match \
no match on non hashable rule(with lower priority) , match on hashable rule. two identical\
packets are sent cache hit expected on the second one\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.171 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
m_minIPAHwType = IPA_HW_v3_0;
Register(*this);
}
bool Setup()
{
return IpaRoutingBlockTestFixture:: Setup(true);
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AB; //192.168.02.171
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool ReceivePacketsAndCompare()
{
size_t receivedSize = 0;
size_t receivedSize2 = 0;
size_t receivedSize3 = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
Byte *rxBuff2 = new Byte[0x400];
Byte *rxBuff3 = new Byte[0x400];
if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
receivedSize2 = m_consumer.ReceiveData(rxBuff2, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer.m_fromChannelName.c_str());
receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
isSuccess &= IsCacheMiss(m_sendSize,receivedSize,rxBuff1);
isSuccess &= IsCacheHit(m_sendSize2,receivedSize2,rxBuff2);
isSuccess &= IsCacheMiss(m_sendSize3,receivedSize3,rxBuff3);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
size_t j;
for(j = 0; j < m_sendSize; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
for(j = 0; j < m_sendSize2; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer2[j]);
for(j = 0; j < receivedSize2; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff2[j]);
printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n",m_sendSize2,SentBuffer,receivedSize2,recievedBuffer);
for(j = 0; j < m_sendSize3; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer3[j]);
for(j = 0; j < receivedSize3; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff3[j]);
printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n",m_sendSize3,SentBuffer,receivedSize3,recievedBuffer);
delete[] rxBuff1;
delete[] rxBuff2;
delete[] rxBuff3;
return isSuccess;
}
};
/*--------------------------------------------------------------------------*/
/* Test16: IPv4 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest016 : public IpaRoutingBlockTestFixture
{
public:
IpaRoutingBlockTest016()
{
m_name = "IpaRoutingBlockTest016";
m_description =" \
Routing block test 016 - Destination address exact match max priority for non hashable \
match on both rule, non hashable rule should win because max priority\
packets are sent. No cache hit is expected\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v4;
m_minIPAHwType = IPA_HW_v3_0;
Register(*this);
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v4;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xC0A802AA; //192.168.02.170
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry->rule.max_prio = 1; // max priority
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
bool ReceivePacketsAndCompare()
{
size_t receivedSize = 0;
size_t receivedSize2 = 0;
size_t receivedSize3 = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
Byte *rxBuff2 = new Byte[0x400];
Byte *rxBuff3 = new Byte[0x400];
if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer2.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
receivedSize2 = m_consumer2.ReceiveData(rxBuff2, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer.m_fromChannelName.c_str());
receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= CompareResultVsGolden(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
isSuccess &= CompareResultVsGolden(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
size_t j;
for(j = 0; j < m_sendSize; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
for(j = 0; j < m_sendSize2; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer2[j]);
for(j = 0; j < receivedSize2; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff2[j]);
printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n",m_sendSize2,SentBuffer,receivedSize2,recievedBuffer);
for(j = 0; j < m_sendSize3; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer3[j]);
for(j = 0; j < receivedSize3; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff3[j]);
printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n",m_sendSize3,SentBuffer,receivedSize3,recievedBuffer);
delete[] rxBuff1;
delete[] rxBuff2;
delete[] rxBuff3;
return isSuccess;
}
};
/*--------------------------------------------------------------------------*/
/* Test17: IPv4 - Tests routing hashable, non hashable, hash invalidation test*/
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest017 : public IpaRoutingBlockTest015
{
public:
IpaRoutingBlockTest017()
{
m_name = "IpaRoutingBlockTest017";
m_description =" \
Routing block test 017 - this test perform test 015 and then commits another rule\
another identical packet is sent: DST_IP == 192.168.02.170 and expected to get cache miss";
}
bool ReceivePacketsAndCompareSpecial()
{
size_t receivedSize = 0;
bool isSuccess = true;
// Receive results
Byte *rxBuff1 = new Byte[0x400];
if (NULL == rxBuff1)
{
printf("Memory allocation error.\n");
return false;
}
receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
/* Compare results */
isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer, m_sendSize, rxBuff1, receivedSize);
isSuccess &= IsCacheMiss(m_sendSize,receivedSize,rxBuff1);
char recievedBuffer[256] = {0};
char SentBuffer[256] = {0};
size_t j;
for(j = 0; j < m_sendSize; j++)
sprintf(&SentBuffer[3*j], " %02X", m_sendBuffer[j]);
for(j = 0; j < receivedSize; j++)
sprintf(&recievedBuffer[3*j], " %02X", rxBuff1[j]);
printf("Expected Value1 (%zu)\n%s\n, Received Value1(%zu)\n%s\n",m_sendSize,SentBuffer,receivedSize,recievedBuffer);
delete[] rxBuff1;
return isSuccess;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v4);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
if (false == isSuccess)
{
printf("ReceivePacketsAndCompare failure.\n");
return false;
}
// until here test 15 was run, now we test hash invalidation
// commit the rules again to clear the cache
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// send the packet again
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// validate we got cache miss
isSuccess = ReceivePacketsAndCompareSpecial();
if (false == isSuccess)
{
printf("ReceivePacketsAndCompareSpecial failure.\n");
}
return isSuccess;
} // Run()
};
/*--------------------------------------------------------------------------*/
/* Test20: IPv6 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest020 : public IpaRoutingBlockTest010
{
public:
IpaRoutingBlockTest020()
{
m_name = "IpaRoutingBlockTest20";
m_description =" \
Routing block test 020 - Destination address exact match non hashable priority higher than hashable \
both match the packet but only non hashable should hit\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF \
traffic goes to pipe IPA_CLIENT_TEST2_CONS \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF \
traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
m_minIPAHwType = IPA_HW_v3_0;
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
rt_rule_entry->rule.hashable = 0; // non hashable
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
free(rt_rule);
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
};
/*--------------------------------------------------------------------------*/
/* Test21: IPv6 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest021 : public IpaRoutingBlockTest011
{
public:
IpaRoutingBlockTest021()
{
m_name = "IpaRoutingBlockTest021";
m_description =" \
Routing block test 021 - Destination address exact match hashable priority higher than non hashable \
both match the packet but only hashable should hit, second packet should get cache hit\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF - hashable\
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF - non hahsable \
traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
m_minIPAHwType = IPA_HW_v3_0;
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
rt_rule_entry->rule.hashable = 0; // non hashable
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
free(rt_rule);
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
};
/*--------------------------------------------------------------------------*/
/* Test22: IPv6 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest022 : public IpaRoutingBlockTest012
{
public:
IpaRoutingBlockTest022()
{
m_name = "IpaRoutingBlockTest022";
m_description =" \
Routing block test 022 - Destination address exact match hashable priority higher than non hashable \
no match on non hashable rule (with higher priority), match on hashable rule. two packets with\
different tuple are sent (but match the rule) cache miss expected\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000AA - non hashable\
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF - hahsable \
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
m_minIPAHwType = IPA_HW_v3_0;
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000AA;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
rt_rule_entry->rule.hashable = 0; // non hashable
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
free(rt_rule);
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
unsigned short port;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
port = ntohs(546);//DHCP Client Port
memcpy (&m_sendBuffer[IPV6_DST_PORT_OFFSET], &port, sizeof(port));
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
port = ntohs(547);//DHCP Client Port
memcpy (&m_sendBuffer2[IPV6_DST_PORT_OFFSET], &port, sizeof(port));
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
};
/*--------------------------------------------------------------------------*/
/* Test23: IPv6 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest023 : public IpaRoutingBlockTest013
{
public:
IpaRoutingBlockTest023()
{
m_name = "IpaRoutingBlockTest023";
m_description =" \
Routing block test 023 - Destination address exact match \
no match on non hashable rule (with lower priority), match on hashable rule. two packets with\
different tuple are sent (but match the rule) cache miss expected\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF - hashable\
traffic goes to pipe IPA_CLIENT_TEST2_CONS\
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000AA - non hahsable \
traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
m_minIPAHwType = IPA_HW_v3_0;
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000AA;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
rt_rule_entry->rule.hashable = 0; // non hashable
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
free(rt_rule);
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
unsigned short port;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
port = ntohs(546);//DHCP Client Port
memcpy (&m_sendBuffer[IPV6_DST_PORT_OFFSET], &port, sizeof(port));
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
port = ntohs(547);//DHCP Client Port
memcpy (&m_sendBuffer2[IPV6_DST_PORT_OFFSET], &port, sizeof(port));
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
};
/*--------------------------------------------------------------------------*/
/* Test24: IPv6 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest024 : public IpaRoutingBlockTest014
{
public:
IpaRoutingBlockTest024()
{
m_name = "IpaRoutingBlockTest024";
m_description =" \
Routing block test 024 - Destination address exact match \
no match on non hashable rule(with higher priority) , match on hashable rule. two identical\
packets are sent cache hit expected on the second one\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000AA - non hashable\
traffic goes to pipe IPA_CLIENT_TEST2_CONS\
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF - hahsable \
traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
m_minIPAHwType = IPA_HW_v3_0;
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000AA;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
rt_rule_entry->rule.hashable = 0; // non hashable
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
free(rt_rule);
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
};
/*--------------------------------------------------------------------------*/
/* Test25: IPv6 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest025 : public IpaRoutingBlockTest015
{
public:
IpaRoutingBlockTest025()
{
m_name = "IpaRoutingBlockTest025";
m_description =" \
Routing block test 025 - Destination address exact match \
no match on non hashable rule(with lower priority) , match on hashable rule. two identical\
packets are sent cache hit expected on the second one\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF - hashable\
traffic goes to pipe IPA_CLIENT_TEST2_CONS\
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000AA - non hahsable \
traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
m_minIPAHwType = IPA_HW_v3_0;
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000AA;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
rt_rule_entry->rule.hashable = 0; // non hashable
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
free(rt_rule);
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
};
/*--------------------------------------------------------------------------*/
/* Test26: IPv6 - Tests routing hashable vs non hashable priorities */
/*--------------------------------------------------------------------------*/
class IpaRoutingBlockTest026 : public IpaRoutingBlockTest016
{
public:
IpaRoutingBlockTest026()
{
m_name = "IpaRoutingBlockTest026";
m_description =" \
Routing block test 026 - Destination address exact match max priority for non hashable \
match on both rule, non hashable rule should win because max priority\
packets are sent cache hit expected on the second one\
2. Generate and commit Three routing rules: (DST & Mask Match). \
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF - hashable\
traffic goes to pipe IPA_CLIENT_TEST2_CONS\
All DST_IP == 0XFF020000 \
0x00000000 \
0x00000000 \
0X000000FF - non hahsable max prio \
traffic goes to pipe IPA_CLIENT_TEST3_CONS\
All other traffic goes to pipe IPA_CLIENT_TEST4_CONS";
m_IpaIPType = IPA_IP_v6;
m_minIPAHwType = IPA_HW_v3_0;
}
bool AddRules()
{
struct ipa_ioc_add_rt_rule *rt_rule;
struct ipa_rt_rule_add *rt_rule_entry;
const int NUM_RULES = 3;
rt_rule = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
NUM_RULES*sizeof(struct ipa_rt_rule_add));
if(!rt_rule) {
printf("Failed memory allocation for rt_rule\n");
return false;
}
rt_rule->commit = 1;
rt_rule->num_rules = NUM_RULES;
rt_rule->ip = IPA_IP_v6;
strcpy(rt_rule->rt_tbl_name, "LAN");
rt_rule_entry = &rt_rule->rules[0];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 1; // hashable
rt_rule_entry = &rt_rule->rules[1];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = 0XFF020000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = 0x00000000;
rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = 0X000000FF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
rt_rule_entry->rule.hashable = 0; // non hashable
rt_rule_entry->rule.max_prio = 1; // max prio
rt_rule_entry = &rt_rule->rules[2];
rt_rule_entry->at_rear = 1;
rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
rt_rule_entry->rule.hashable = 0; // non hashable
if (false == m_routing.AddRoutingRule(rt_rule))
{
printf("Routing rule addition failed!\n");
free(rt_rule);
return false;
}
printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
free(rt_rule);
InitFilteringBlock();
return true;
}
bool Run()
{
bool res = false;
bool isSuccess = false;
// Add the relevant routing rules
res = AddRules();
if (false == res) {
printf("Failed adding routing rules.\n");
return false;
}
// Load input data (IP packet) from file
res = LoadFiles(IPA_IP_v6);
if (false == res) {
printf("Failed loading files.\n");
return false;
}
// Send first packet
m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send second packet
m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Send third packet
isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
if (false == isSuccess)
{
printf("SendData failure.\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
return isSuccess;
} // Run()
};
static class IpaRoutingBlockTest1 ipaRoutingBlockTest1;
static class IpaRoutingBlockTest2 ipaRoutingBlockTest2;
static class IpaRoutingBlockTest3 ipaRoutingBlockTest3;
static class IpaRoutingBlockTest4 ipaRoutingBlockTest4;
static class IpaRoutingBlockTest5 ipaRoutingBlockTest5;
static class IpaRoutingBlockTest006 ipaRoutingBlockTest006;
static class IpaRoutingBlockTest007 ipaRoutingBlockTest007;
static class IpaRoutingBlockTest008 ipaRoutingBlockTest008;
static class IpaRoutingBlockTest009 ipaRoutingBlockTest009;
static class IpaRoutingBlockTest010 ipaRoutingBlockTest010;
static class IpaRoutingBlockTest011 ipaRoutingBlockTest011;
static class IpaRoutingBlockTest012 ipaRoutingBlockTest012;
static class IpaRoutingBlockTest013 ipaRoutingBlockTest013;
static class IpaRoutingBlockTest014 ipaRoutingBlockTest014;
static class IpaRoutingBlockTest015 ipaRoutingBlockTest015;
static class IpaRoutingBlockTest016 ipaRoutingBlockTest016;
static class IpaRoutingBlockTest020 ipaRoutingBlockTest020;
static class IpaRoutingBlockTest021 ipaRoutingBlockTest021;
static class IpaRoutingBlockTest022 ipaRoutingBlockTest022;
static class IpaRoutingBlockTest023 ipaRoutingBlockTest023;
static class IpaRoutingBlockTest024 ipaRoutingBlockTest024;
static class IpaRoutingBlockTest025 ipaRoutingBlockTest025;
static class IpaRoutingBlockTest026 ipaRoutingBlockTest026;
Reference in New Issue View Git Blame Copy Permalink