4258 lines
128 KiB
C++
4258 lines
128 KiB
C++
/*
|
|
* 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;
|
|
|
|
|