Gitiles
Code Review Sign In
LeafOS / LeafOS-Project / android_vendor_qcom_opensource_dataipa / 4dec59e8864a7d33f99bd714174f08b842c6ec5b / . / kernel-tests / MBIMAggregationTests.cpp
blob: bd21434e0b7a5fefdcc302fdd1160078a03f9223 [file] [log] [blame]
/*
* Copyright (c) 2017,2020 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 "MBIMAggregationTestFixtureConf11.h"
#include "Constants.h"
#include "TestsUtils.h"
#include "linux/msm_ipa.h"
#define AGGREGATION_LOOP 4
#define IPV4_DST_ADDR_OFFSET (16)
/////////////////////////////////////////////////////////////////////////////////
// MBIM Aggregation scenarios //
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationScenarios {
public:
//MBIM Aggregation test - sends 5 packets and receives 1 aggregated packet
static bool MBIMAggregationTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Deaggregation test - sends an aggregated packet made from 5 packets
//and receives 5 packets
static bool MBIMDeaggregationTest(Pipe* input,
Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Deaggregation one packet test - sends an aggregated packet made from
//1 packet and receives 1 packet
static bool MBIMDeaggregationOnePacketTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Deaggregation and Aggregation test - sends an aggregated packet made
//from 5 packets and receives the same aggregated packet
static bool MBIMDeaggregationAndAggregationTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM multiple Deaggregation and Aggregation test - sends 5 aggregated
//packets each one made of 1 packet and receives an aggregated packet made
//of the 5 packets
static bool MBIMMultipleDeaggregationAndAggregationTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP);
//MBIM Aggregation Loop test - sends 5 packets and expects to receive 1
//aggregated packet a few times
static bool MBIMAggregationLoopTest(Pipe* input,
Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Aggregation time limit test - sends 1 small packet smaller than the
//byte limit and receives 1 aggregated packet
static bool MBIMAggregationTimeLimitTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Aggregation byte limit test - sends 2 packets that together are
//larger than the byte limit
static bool MBIMAggregationByteLimitTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
static bool MBIMAggregationByteLimitTestFC(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
static bool MBIMAggregationDualDpTestFC(Pipe* input, Pipe* output1, Pipe* output2, enum ipa_ip_type m_eIP);
//MBIM Deaggregation multiple NDP test - sends an aggregated packet made
//from 5 packets and 2 NDPs and receives 5 packets
static bool MBIMDeaggregationMultipleNDPTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Aggregation 2 pipes test - sends 3 packets from one pipe and an
//aggregated packet made of 2 packets from another pipe and receives 1
//aggregated packet made of all 5 packets
static bool MBIMAggregation2PipesTest(Pipe* input1, Pipe* input2, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Aggregation time limit loop test - sends 5 small packet smaller than
//the byte limit and receives 5 aggregated packet
static bool MBIMAggregationTimeLimitLoopTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Aggregation 0 limits test - sends 5 packets and expects to get each
//packet back aggregated (both size and time limits are 0)
static bool MBIMAggregation0LimitsTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Aggregation multiple packets test - sends 9 packets with same stream
//ID and receives 1 aggregated packet with 2 NDPs
static bool MBIMAggregationMultiplePacketsTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Aggregation different stream IDs test - sends 5 packets with
//different stream IDs and receives 1 aggregated packet made of 5 NDPs
static bool MBIMAggregationDifferentStreamIdsTest(Pipe* input, Pipe* output, enum ipa_ip_type m_eIP);
//MBIM Aggregation no interleaving stream IDs test - sends 5 packets with
//interleaving stream IDs (0, 1, 0, 1, 0) and receives 1 aggregated packet
//made of 5 NDPs
static bool MBIMAggregationNoInterleavingStreamIdsTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP);
private:
//This method will deaggregate an aggregated packet and compare the packets
//to the expected packets
static bool DeaggragateAndComparePackets(
Byte pAggregatedPacket[MAX_PACKET_SIZE],
Byte pExpectedPackets[MAX_PACKETS_IN_MBIM_TESTS][MAX_PACKET_SIZE],
int pPacketsSizes[MAX_PACKETS_IN_MBIM_TESTS], int nNumPackets,
int nAggregatedPacketSize);
//This method will aggregate packets
static void AggregatePackets(
Byte pAggregatedPacket[MAX_PACKET_SIZE]/*ouput*/,
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE],
int pPacketsSizes[NUM_PACKETS], int nNumPackets,
int nAggregatedPacketSize);
//This method will aggregate packets and take into consideration their
//stream id to seperate them into different NDPs
static void AggregatePacketsWithStreamId(
Byte pAggregatedPacket[MAX_PACKET_SIZE]/*ouput*/,
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE],
int pPacketsSizes[NUM_PACKETS], int nNumPackets,
int nAggregatedPacketSize, Byte pPacketsStreamId[NUM_PACKETS]);
//This method will deaggregate an aggregated packet made of one packet and
//compare the packet to the expected packet
static bool DeaggragateAndCompareOnePacket(
Byte pAggregatedPacket[MAX_PACKET_SIZE],
Byte pExpectedPacket[MAX_PACKET_SIZE], int nPacketsSize,
int nAggregatedPacketSize);
//This method will deaggregate an aggregated packet and compare the packets
//to the expected packets
static bool DeaggragateAndComparePacketsWithStreamId(
Byte pAggregatedPacket[MAX_PACKET_SIZE],
Byte pExpectedPackets[][MAX_PACKET_SIZE], int pPacketsSizes[],
int nNumPackets, int nAggregatedPacketSize,
Byte pPacketsStreamId[NUM_PACKETS]);
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationTest(
Pipe* input, Pipe* output, enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[NUM_PACKETS];
//Buffer for the packet that will be received
Byte pReceivedPacket[2*MAX_PACKET_SIZE];
//Total size of all sent packets (this is the max size of the aggregated
//packet minus the size of the header and the NDP)
int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize;
else
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
while (0 != pPacketsSizes[i] % 4)
{
pPacketsSizes[i]++;
}
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
//send the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be there)"
"\n", MAX_PACKET_SIZE);
int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
if (MAX_PACKET_SIZE != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", MAX_PACKET_SIZE);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
//deaggregating the aggregated packet
return DeaggragateAndComparePackets(pReceivedPacket, pPackets,
pPacketsSizes, NUM_PACKETS, nBytesReceived);
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMDeaggregationTest(
Pipe* input, Pipe* output, enum ipa_ip_type m_eIP)
{
bool bTestResult = true;
//The packets that the aggregated packet will be made of
Byte pExpectedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that the aggregated packet will be made of
int pPacketsSizes[NUM_PACKETS];
//Buffers for the packets that will be received
Byte pReceivedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//Total size of all the packets that the aggregated packet will be made of
//(this is the max size of the aggregated packet
//minus the size of the header and the NDP)
int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
//The aggregated packet that will be sent
Byte pAggregatedPacket[MAX_PACKET_SIZE] = {0};
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize;
else
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
while (0 != pPacketsSizes[i] % 4)
{
pPacketsSizes[i]++;
}
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pExpectedPackets[i],
pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pExpectedPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pExpectedPackets[i][size] = i;
size++;
}
}
//initializing the aggregated packet
AggregatePackets(pAggregatedPacket, pExpectedPackets, pPacketsSizes,
NUM_PACKETS, MAX_PACKET_SIZE);
//send the aggregated packet
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes)\n",
sizeof(pAggregatedPacket));
int nBytesSent = input->Send(pAggregatedPacket, sizeof(pAggregatedPacket));
if (sizeof(pAggregatedPacket) != nBytesSent)
{
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
"failed!\n", sizeof(pAggregatedPacket));
return false;
}
//receive the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Reading packet %d from the USB pipe(%d bytes should be "
"there)\n", i, pPacketsSizes[i]);
int nBytesReceived = output->Receive(pReceivedPackets[i],
pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving packet %d from the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
print_buff(pReceivedPackets[i], nBytesReceived);
return false;
}
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
for (int i = 0; i < NUM_PACKETS; i++)
bTestResult &= !memcmp(pExpectedPackets[i], pReceivedPackets[i],
pPacketsSizes[i]);
return bTestResult;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMDeaggregationOnePacketTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
bool bTestResult = true;
//The packets that the aggregated packet will be made of
Byte pExpectedPackets[1][MAX_PACKET_SIZE];
//The real sizes of the packets that the aggregated packet will be made of
int pPacketsSizes[1] = {100};
//Buffers for the packets that will be received
Byte pReceivedPackets[1][MAX_PACKET_SIZE];
//Total size of the aggregated packet
//(this is the max size of the aggregated packet
//minus the size of the header and the NDP)
int nTotalAggregatedPacketSize = 100 + 12 + 16;
//The aggregated packet that will be sent
Byte pAggregatedPacket[MAX_PACKET_SIZE] = {0};
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[1];
// Load input data (IP packet) from file
pIpPacketsSizes[0] = 100;
if (!LoadDefaultPacket(m_eIP, pExpectedPackets[0], pIpPacketsSizes[0]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pExpectedPackets[0][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[0];
while (size < pPacketsSizes[0])
{
pExpectedPackets[0][size] = 0;
size++;
}
//initializing the aggregated packet
AggregatePackets(pAggregatedPacket, pExpectedPackets, pPacketsSizes, 1,
nTotalAggregatedPacketSize);
//send the aggregated packet
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes)\n",
nTotalAggregatedPacketSize);
int nBytesSent = input->Send(pAggregatedPacket, nTotalAggregatedPacketSize);
if (nTotalAggregatedPacketSize != nBytesSent)
{
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
"failed!\n", nTotalAggregatedPacketSize);
return false;
}
//receive the packet
for (int i = 0; i < 1; i++)
{
LOG_MSG_DEBUG("Reading packet %d from the USB pipe(%d bytes should be "
"there)\n", i, pPacketsSizes[i]);
int nBytesReceived = output->Receive(pReceivedPackets[i],
pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving packet %d from the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
print_buff(pReceivedPackets[i], nBytesReceived);
return false;
}
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
for (int i = 0; i < 1; i++)
bTestResult &= !memcmp(pExpectedPackets[i], pReceivedPackets[i],
pPacketsSizes[i]);
return bTestResult;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMDeaggregationAndAggregationTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that the aggregated packet will be made of
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that the aggregated packet will be made of
int pPacketsSizes[NUM_PACKETS];
//Buffers for the packets that will be received
Byte pReceivedPacket[MAX_PACKET_SIZE];
//Total size of all the packets that the aggregated packet will be made of
//(this is the max size of the aggregated packet
//minus the size of the header and the NDP)
int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
//The aggregated packet that will be sent
Byte pAggregatedPacket[MAX_PACKET_SIZE] = {0};
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize;
else
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
while (0 != pPacketsSizes[i] % 4)
pPacketsSizes[i]++;
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
//initializing the aggregated packet
AggregatePackets(pAggregatedPacket, pPackets, pPacketsSizes, NUM_PACKETS,
MAX_PACKET_SIZE);
//send the aggregated packet
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes)\n",
MAX_PACKET_SIZE);
int nBytesSent = input->Send(pAggregatedPacket, MAX_PACKET_SIZE);
if (MAX_PACKET_SIZE != nBytesSent)
{
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
"failed!\n", MAX_PACKET_SIZE);
return false;
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading aggregated packet from the USB pipe(%d bytes should "
"be there)\n", MAX_PACKET_SIZE);
int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
if (MAX_PACKET_SIZE != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", MAX_PACKET_SIZE);
LOG_MSG_DEBUG("Received %d bytes\n", nBytesReceived);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
return DeaggragateAndComparePackets(pReceivedPacket, pPackets, pPacketsSizes,
NUM_PACKETS, nBytesReceived);
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMMultipleDeaggregationAndAggregationTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that the aggregated packets will be made of
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that the aggregated packet will be made of
int pPacketsSizes[NUM_PACKETS];
//Buffers for the packets that will be received
Byte pReceivedPacket[MAX_PACKET_SIZE];
//Total size of all the packets that the aggregated packet will be made of
//(this is the max size of the aggregated packet
//minus the size of the header and the NDP)
int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
//The aggregated packet that will be sent
Byte pAggregatedPacket[NUM_PACKETS][MAX_PACKET_SIZE];
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize;
else
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
while (0 != pPacketsSizes[i] % 4)
pPacketsSizes[i]++;
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
//initializing the aggregated packets
for (int i = 0; i < NUM_PACKETS; i++)
AggregatePackets(pAggregatedPacket[i], &pPackets[i], &pPacketsSizes[i],
1, pPacketsSizes[i] + 12 + 16);
//send the aggregated packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Sending aggregated packet %d into the USB pipe(%d "
"bytes)\n", i, pPacketsSizes[i] + 12 + 16);
int nBytesSent = input->Send(pAggregatedPacket[i],
pPacketsSizes[i] + 12 + 16);
if (pPacketsSizes[i] + 12 + 16 != nBytesSent)
{
LOG_MSG_DEBUG("Sending aggregated packet %d into the USB pipe(%d "
"bytes) failed!\n", i, pPacketsSizes[i] + 12 + 16);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading aggregated packet from the USB pipe(%d bytes should "
"be there)\n", MAX_PACKET_SIZE);
int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
if (MAX_PACKET_SIZE != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", MAX_PACKET_SIZE);
LOG_MSG_DEBUG("Received %d bytes\n", nBytesReceived);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
return DeaggragateAndComparePackets(pReceivedPacket, pPackets,
pPacketsSizes, NUM_PACKETS, nBytesReceived);
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationLoopTest(
Pipe* input, Pipe* output, enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[NUM_PACKETS];
//Buffer for the packet that will be received
Byte pReceivedPacket[MAX_PACKET_SIZE];
//Total size of all sent packets (this is the max size of the aggregated
//packet minus the size of the header and the NDP)
int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize;
else
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
while (0 != pPacketsSizes[i] % 4)
pPacketsSizes[i]++;
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
int num_iters = AGGREGATION_LOOP - 1;
for (int j = 0; j < num_iters; j++)
{
//send the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
memset(pReceivedPacket, 0, sizeof(pReceivedPacket));
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
"there)\n", MAX_PACKET_SIZE);
int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
if (MAX_PACKET_SIZE != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d "
"bytes) failed!\n", MAX_PACKET_SIZE);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
if (false == DeaggragateAndComparePackets(pReceivedPacket, pPackets,
pPacketsSizes, NUM_PACKETS, nBytesReceived))
{
LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
return false;
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationTimeLimitTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[1][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[1] = {0};
//Buffer for the packet that will be received
Byte pReceivedPacket[MAX_PACKET_SIZE] = {0};
//Size of aggregated packet
int nTotalPacketsSize = 24;
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[1];
//initialize the packets
for (int i = 0; i < 1 ; i++)
{
pPacketsSizes[i] = 52 + 4*i;
nTotalPacketsSize += pPacketsSizes[i] + 4; //size of the packet + 4 bytes for index and length
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
int nAllPacketsSizes = 0;
for (int i = 0; i < 1; i++)
nAllPacketsSizes += pPacketsSizes[i];
while (0 != nAllPacketsSizes % 4)
{
nAllPacketsSizes++;
nTotalPacketsSize++; //zero padding for NDP offset to be 4x
}
//send the packets
for (int i = 0; i < 1; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
"there)\n", nTotalPacketsSize);
int nBytesReceived = output->Receive(pReceivedPacket, nTotalPacketsSize);
// IPA HW may add padding to the packets to align to 4B
if (nTotalPacketsSize > nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", nTotalPacketsSize);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
if (false == DeaggragateAndComparePackets(pReceivedPacket, pPackets,
pPacketsSizes, 1, nBytesReceived))
{
LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationByteLimitTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[2][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[2];
//Buffer for the packet that will be received
Byte pReceivedPacket[2*MAX_PACKET_SIZE] = {0};
//Size of aggregated packet
int nTotalPacketsSize = 24;
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[2];
//initialize the packets
for (int i = 0; i < 2; i++)
{
pPacketsSizes[i] = (MAX_PACKET_SIZE / 2) + 10;
nTotalPacketsSize += pPacketsSizes[i] + 4;
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
//send the packets
for (int i = 0; i < 2; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
"there)\n", nTotalPacketsSize);
int nBytesReceived = output->Receive(pReceivedPacket, nTotalPacketsSize);
// IPA HW may add padding to the packets to align to 4B
if (nTotalPacketsSize > nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", nTotalPacketsSize);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
if (false == DeaggragateAndComparePackets(pReceivedPacket, pPackets,
pPacketsSizes, 2, nBytesReceived))
{
LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
return false;
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationByteLimitTestFC(
Pipe *input, Pipe *output,
enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[2][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[2];
//Buffer for the packet that will be received
Byte pReceivedPacket[2][MAX_PACKET_SIZE] = {0};
//Size of aggregated packet
int nTotalPacketsSize = 24 + (MAX_PACKET_SIZE / 2) + 8 + 4;
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[2];
int nBytesReceived;
for (int i = 0; i < 2; i++)
{
pPacketsSizes[i] = (MAX_PACKET_SIZE / 2) + 8;
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
//send the packets
for (int i = 0; i < 2; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
/* receive the packet */
LOG_MSG_DEBUG(
"Reading packets from the USB pipe(%d bytes for each)"
"\n", nTotalPacketsSize);
for (int i = 0; i < 2; i++)
{
nBytesReceived = output->Receive(pReceivedPacket[i], MAX_PACKET_SIZE);
if (nTotalPacketsSize != nBytesReceived)
{
LOG_MSG_ERROR(
"Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", nBytesReceived);
print_buff(pReceivedPacket[i], nBytesReceived);
return false;
}
}
//comparing the received packets to the aggregated packets
LOG_MSG_DEBUG("Checking sent.vs.received packets\n");
for (int i = 0; i < 2; i++)
{
if (false == DeaggragateAndComparePackets(pReceivedPacket[i],
&pPackets[i],
(int *)&pPacketsSizes[i],
1,
nBytesReceived))
{
LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
return false;
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
#define DUAL_FC_IP_PACKET_L ((MAX_PACKET_SIZE / 2) + 8)
#define DUAL_FC_1_AGG_PACKET_L (12 + DUAL_FC_IP_PACKET_L + 12 + 4)
#define DUAL_FC_2_AGG_PACKET_L (12 + DUAL_FC_IP_PACKET_L + DUAL_FC_IP_PACKET_L + 12 + 4 + 4)
bool MBIMAggregationScenarios::MBIMAggregationDualDpTestFC(
Pipe *input, Pipe *output1, Pipe *output2,
enum ipa_ip_type m_eIP)
{
int i;
//The packets that will be sent
Byte pPackets[4][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[4];
//Buffer for the packet that will be received
Byte pReceivedPacket[2 * MAX_PACKET_SIZE] = {0};
Byte pReceivedPacketFC[2][MAX_PACKET_SIZE] = {0};
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[4];
int nBytesReceived;
for (i = 0; i < 4; i++)
{
pPacketsSizes[i] = DUAL_FC_IP_PACKET_L;
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001 + (i & 0x1));
memcpy(&pPackets[i][IPV4_DST_ADDR_OFFSET], &nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = 0xAA;
size++;
}
}
//send the packets
for (int i = 0; i < 4; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
/* receive the packets from FC pipe */
LOG_MSG_DEBUG(
"Reading packets from the FC pipe (%d bytes for each)"
"\n", DUAL_FC_1_AGG_PACKET_L);
for (i = 0; i < 2; i++)
{
nBytesReceived = output1->Receive(pReceivedPacketFC[i], MAX_PACKET_SIZE);
if (DUAL_FC_1_AGG_PACKET_L != nBytesReceived)
{
LOG_MSG_ERROR(
"Receiving aggregated packet from the USB pipe (%d bytes) "
"failed!\n", nBytesReceived);
print_buff(pReceivedPacketFC[i], nBytesReceived);
return false;
}
}
for (i = 0; i < 2; i++)
{
if (false == DeaggragateAndComparePackets(pReceivedPacketFC[i],
&pPackets[i * 2],
(int *)&pPacketsSizes[i * 2],
1,
nBytesReceived))
{
LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
return false;
}
}
/* receive the packet from non-FC pipe */
LOG_MSG_DEBUG(
"Reading packet from the non-FC pipe (%d bytes)"
"\n", DUAL_FC_2_AGG_PACKET_L);
nBytesReceived = output2->Receive(pReceivedPacket, MAX_PACKET_SIZE);
if (DUAL_FC_2_AGG_PACKET_L != nBytesReceived)
{
LOG_MSG_ERROR(
"Receiving aggregated packet from the USB pipe (%d bytes) "
"failed!\n", nBytesReceived);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
// Setting all source packets IP to 127.0.0.2 for comparison
nIPv4DSTAddr = ntohl(0x7F000002);
memcpy(&pPackets[0][IPV4_DST_ADDR_OFFSET], &nIPv4DSTAddr, sizeof(nIPv4DSTAddr));
memcpy(&pPackets[2][IPV4_DST_ADDR_OFFSET], &nIPv4DSTAddr, sizeof(nIPv4DSTAddr));
if (false == DeaggragateAndComparePackets(&pReceivedPacket[0], pPackets,
(int *)&pPacketsSizes, 2, nBytesReceived))
{
LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMDeaggregationMultipleNDPTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
bool bTestResult = true;
//The packets that the aggregated packet will be made of
Byte pExpectedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that the aggregated packet will be made of
int pPacketsSizes[NUM_PACKETS];
//Buffers for the packets that will be received
Byte pReceivedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//Total size of all the packets that the aggregated packet will be made of
//(this is the max size of the aggregated packet
//minus the size of the header and the 2 NDPs)
int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 36;
//The aggregated packet that will be sent
Byte pAggregatedPacket[MAX_PACKET_SIZE] = {0};
//The stream Id byte for every packet - this will determine on which NDP the
//packet will appear
Byte pPacketsStreamId[NUM_PACKETS] = {0};
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize;
else {
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
pPacketsSizes[i] += (pPacketsSizes[i] % 4 == 0 ? 0 :
4 - pPacketsSizes[i] % 4);
}
nTotalPacketsSize -= pPacketsSizes[i];
pPacketsStreamId[i] = i < 3 ? 0 : 1;
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pExpectedPackets[i],
pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pExpectedPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pExpectedPackets[i][size] = i;
size++;
}
}
//initializing the aggregated packet
AggregatePacketsWithStreamId(pAggregatedPacket, pExpectedPackets,
pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE, pPacketsStreamId);
//send the aggregated packet
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes)\n",
sizeof(pAggregatedPacket));
int nBytesSent = input->Send(pAggregatedPacket, sizeof(pAggregatedPacket));
if (sizeof(pAggregatedPacket) != nBytesSent)
{
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
"failed!\n", sizeof(pAggregatedPacket));
return false;
}
//receive the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Reading packet %d from the USB pipe(%d bytes should be "
"there)\n", i, pPacketsSizes[i]);
int nBytesReceived = output->Receive(pReceivedPackets[i],
pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving packet %d from the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
print_buff(pReceivedPackets[i], nBytesReceived);
return false;
}
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
for (int i = 0; i < NUM_PACKETS; i++)
bTestResult &= !memcmp(pExpectedPackets[i], pReceivedPackets[i],
pPacketsSizes[i]);
return bTestResult;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregation2PipesTest(
Pipe* input1, Pipe* input2, Pipe* output, enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[NUM_PACKETS];
//Buffer for the packet that will be received
Byte pReceivedPacket[2*MAX_PACKET_SIZE];
//Total size of all sent packets (this is the max size of the aggregated
//packet minus the size of the header and the NDP)
int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
//The aggregated packet that will be sent
Byte pAggregatedPacket[2][MAX_PACKET_SIZE];
//The size of the sent aggregated packet
int nAggregatedPacketSize[2] = {0};
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize;
else
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
while (0 != pPacketsSizes[i] % 4)
pPacketsSizes[i]++;
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
nAggregatedPacketSize[0] += pPacketsSizes[0] + pPacketsSizes[1]; //adding the packets
nAggregatedPacketSize[0] += 12; //adding the header
nAggregatedPacketSize[0] += 12 + 4*2; //adding the NDP
//initializing the aggregated packet
AggregatePackets(pAggregatedPacket[0], pPackets, pPacketsSizes, 2,
nAggregatedPacketSize[0]);
//send the aggregated packet
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d "
"bytes)\n", nAggregatedPacketSize[0]);
int nBytesSent = input1->Send(pAggregatedPacket[0],
nAggregatedPacketSize[0]);
if (nAggregatedPacketSize[0] != nBytesSent)
{
LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
"failed!\n", nAggregatedPacketSize[0]);
return false;
}
//send the packets
for (int i = 2; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input2->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
"there)\n", MAX_PACKET_SIZE);
int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
if (MAX_PACKET_SIZE != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", MAX_PACKET_SIZE);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
//deaggregating the aggregated packet
return DeaggragateAndComparePackets(pReceivedPacket, pPackets, pPacketsSizes, NUM_PACKETS, nBytesReceived);
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationTimeLimitLoopTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[1][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[1] = {0};
//Buffer for the packet that will be received
Byte pReceivedPacket[MAX_PACKET_SIZE] = {0};
//Size of aggregated packet
int nTotalPacketsSize = 24;
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < 1 ; i++)
{
pPacketsSizes[i] = 52 + 4*i;
nTotalPacketsSize += pPacketsSizes[i] + 4; //size of the packet + 4 bytes for index and length
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
int nAllPacketsSizes = 0;
for (int i = 0; i < 1; i++)
nAllPacketsSizes += pPacketsSizes[i];
while (0 != nAllPacketsSizes % 4)
{
nAllPacketsSizes++;
nTotalPacketsSize++; //zero padding for NDP offset to be 4x
}
for (int k = 0; k < AGGREGATION_LOOP; k++)
{
//send the packets
for (int i = 0; i < 1; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
"there)\n", nTotalPacketsSize);
int nBytesReceived = output->Receive(pReceivedPacket,
nTotalPacketsSize);
// IPA HW may add padding to the packets to align to 4B
if (nTotalPacketsSize > nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d "
"bytes) failed!\n", nTotalPacketsSize);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
if (false == DeaggragateAndComparePackets(pReceivedPacket, pPackets,
pPacketsSizes, 1, nBytesReceived))
{
LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
return false;
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregation0LimitsTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[NUM_PACKETS];
//Buffer for the packet that will be received
Byte pReceivedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The expected aggregated packets sizes
int pAggragatedPacketsSizes[NUM_PACKETS] = {0};
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS ; i++)
{
pPacketsSizes[i] = 52 + 4*i;
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
//calculate aggregated packets sizes
for (int i = 0; i < NUM_PACKETS; i++)
{
pAggragatedPacketsSizes[i] += pPacketsSizes[i];
while (0 != pAggragatedPacketsSizes[i] % 4)
pAggragatedPacketsSizes[i]++; //zero padding for NDP offset to be 4x
pAggragatedPacketsSizes[i] += 28; //header + NDP
}
//send the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Reading packet %d from the USB pipe(%d bytes should be "
"there)\n", i, pAggragatedPacketsSizes[i]);
int nBytesReceived = output->Receive(pReceivedPackets[i],
pAggragatedPacketsSizes[i]);
// IPA HW may add padding to the packets to align to 4B
if (pAggragatedPacketsSizes[i] > nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet %d from the USB pipe(%d "
"bytes) failed!\n", i, pAggragatedPacketsSizes[i]);
print_buff(pReceivedPackets[i], nBytesReceived);
return false;
}
pAggragatedPacketsSizes[i] = nBytesReceived;
}
//comparing the received packet to the aggregated packet
LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
for (int i = 0; i < NUM_PACKETS; i++)
{
if (false == DeaggragateAndCompareOnePacket(pReceivedPackets[i],
pPackets[i], pPacketsSizes[i], pAggragatedPacketsSizes[i]))
{
LOG_MSG_DEBUG("Comparing aggregated packet %d failed!\n", i);
return false;
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationMultiplePacketsTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[MAX_PACKETS_IN_NDP + 1][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[MAX_PACKETS_IN_NDP + 1];
//Buffer for the packet that will be received
Byte pReceivedPacket[2*MAX_PACKET_SIZE];
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[MAX_PACKETS_IN_NDP + 1];
//Total size of all sent packets (this is the max size of the aggregated packet
//minus the size of the header and the 2 NDPs)
int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * (MAX_PACKETS_IN_NDP + 1)) - 24;
//initialize the packets
for (int i = 0; i < MAX_PACKETS_IN_NDP + 1; i++)
{
if (MAX_PACKETS_IN_NDP == i)
pPacketsSizes[i] = nTotalPacketsSize;
else
{
pPacketsSizes[i] = nTotalPacketsSize / (MAX_PACKETS_IN_NDP + 1);
pPacketsSizes[i] += (pPacketsSizes[i] % 4 == 0 ? 0 :
4 - pPacketsSizes[i] % 4);
}
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
//send the packets
for (int i = 0; i < MAX_PACKETS_IN_NDP + 1; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
"there)\n", MAX_PACKET_SIZE);
int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
if (MAX_PACKET_SIZE != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", MAX_PACKET_SIZE);
print_buff(pReceivedPacket, nBytesReceived);
return false;
}
//deaggregating the aggregated packet
return DeaggragateAndComparePackets(pReceivedPacket, pPackets,
pPacketsSizes, MAX_PACKETS_IN_NDP+1, nBytesReceived);
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationDifferentStreamIdsTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[NUM_PACKETS];
//Buffer for the packet that will be received
Byte pReceivedPacket[2*MAX_PACKET_SIZE];
//Total size of all sent packets (this is the max size of the aggregated
//packet minus the size of the header and the NDPs)
int nTotalPacketsSize = MAX_PACKET_SIZE - (16 * NUM_PACKETS) - 12;
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
Byte pPacketsStreamId[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
pPacketsStreamId[i] = i;
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize + 12;
else
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
while (0 != pPacketsSizes[i] % 4)
pPacketsSizes[i]++;
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[0][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
nIPv4DSTAddr = ntohl(0xC0A80101);
memcpy (&pPackets[1][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
nIPv4DSTAddr = ntohl(0xC0A80102);
memcpy (&pPackets[2][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
nIPv4DSTAddr = ntohl(0xC0A80103);
memcpy (&pPackets[3][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
nIPv4DSTAddr = ntohl(0xC0A80104);
memcpy (&pPackets[4][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
//send the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
"there)\n", MAX_PACKET_SIZE + 12);
int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE + 12);
if (MAX_PACKET_SIZE + 12 != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
"failed!\n", MAX_PACKET_SIZE + 12);
print_buff(pReceivedPacket, nBytesReceived + 12);
return false;
}
//deaggregating the aggregated packet
return DeaggragateAndComparePacketsWithStreamId(pReceivedPacket, pPackets,
pPacketsSizes, NUM_PACKETS, nBytesReceived, pPacketsStreamId);
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::MBIMAggregationNoInterleavingStreamIdsTest(
Pipe* input, Pipe* output,
enum ipa_ip_type m_eIP)
{
//The packets that will be sent
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
//The real sizes of the packets that will be sent
int pPacketsSizes[NUM_PACKETS];
//Buffer for the packet that will be received
Byte pReceivedPacket[2*MAX_PACKET_SIZE];
//Total size of all sent packets (this is the max size of the aggregated packet
//minus the size of the header and the NDPs)
int nTotalPacketsSize = MAX_PACKET_SIZE - (16 * NUM_PACKETS) - 12;
uint32_t nIPv4DSTAddr;
size_t pIpPacketsSizes[NUM_PACKETS];
Byte pPacketsStreamId[NUM_PACKETS];
//initialize the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
pPacketsStreamId[i] = i % 2;
if (NUM_PACKETS - 1 == i)
pPacketsSizes[i] = nTotalPacketsSize + 12;
else
pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
while (0 != pPacketsSizes[i] % 4)
pPacketsSizes[i]++;
nTotalPacketsSize -= pPacketsSizes[i];
// Load input data (IP packet) from file
pIpPacketsSizes[i] = MAX_PACKET_SIZE;
if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
{
LOG_MSG_ERROR("Failed default Packet");
return false;
}
int size = pIpPacketsSizes[i];
while (size < pPacketsSizes[i])
{
pPackets[i][size] = i;
size++;
}
}
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[0][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
nIPv4DSTAddr = ntohl(0xC0A80101);
memcpy (&pPackets[1][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[2][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
nIPv4DSTAddr = ntohl(0xC0A80101);
memcpy (&pPackets[3][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
nIPv4DSTAddr = ntohl(0x7F000001);
memcpy (&pPackets[4][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
sizeof(nIPv4DSTAddr));
//send the packets
for (int i = 0; i < NUM_PACKETS; i++)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
pPacketsSizes[i]);
int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
if (pPacketsSizes[i] != nBytesSent)
{
LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
"failed!\n", i, pPacketsSizes[i]);
return false;
}
}
//receive the aggregated packet
LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
"there)\n", MAX_PACKET_SIZE + 12);
int nBytesReceived = output->Receive(pReceivedPacket,
MAX_PACKET_SIZE + 12);
if (MAX_PACKET_SIZE + 12 != nBytesReceived)
{
LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes)"
" failed!\n", MAX_PACKET_SIZE + 12);
print_buff(pReceivedPacket, nBytesReceived + 12);
return false;
}
//deaggregating the aggregated packet
return DeaggragateAndComparePacketsWithStreamId(pReceivedPacket, pPackets,
pPacketsSizes, NUM_PACKETS, nBytesReceived, pPacketsStreamId);
}
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::DeaggragateAndComparePackets(
Byte pAggregatedPacket[MAX_PACKET_SIZE],
Byte pExpectedPackets[MAX_PACKETS_IN_MBIM_TESTS][MAX_PACKET_SIZE],
int pPacketsSizes[MAX_PACKETS_IN_MBIM_TESTS], int nNumPackets, int nAggregatedPacketSize)
{
int nPacketNum = 0;
int i = 0;
int nNdpStart = 0;
Byte pNdpIndex[2] = {0};
Byte pNdpLen[2] = {0};
if (0x4e != pAggregatedPacket[i] || 0x43 != pAggregatedPacket[i+1] ||
0x4d != pAggregatedPacket[i+2]|| 0x48 != pAggregatedPacket[i+3])
{
LOG_MSG_DEBUG("Error: Wrong NTH16 signature: 0x%02x 0x%02x 0x%02x "
"0x%02x(should be 0x4e, 0x43, 0x4d, 0x48)\n",
pAggregatedPacket[i], pAggregatedPacket[i+1],
pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
return false;
}
i += 4;
if (0x0c != pAggregatedPacket[i] || 0x00 != pAggregatedPacket[i+1])
{
LOG_MSG_DEBUG("Error: Wrong header length: 0x%02x 0x%02x(should be 0x0c, "
"0x00)\n",
pAggregatedPacket[i], pAggregatedPacket[i+1]);
return false;
}
i += 4; //ignoring sequence number
if ((nAggregatedPacketSize & 0x00FF) != pAggregatedPacket[i] ||
(nAggregatedPacketSize >> 8) != pAggregatedPacket[i+1])
{
LOG_MSG_DEBUG("Error: Wrong aggregated packet length: 0x%02x 0x%02x"
"(should be 0x%02x, 0x%02x)\n",
pAggregatedPacket[i], pAggregatedPacket[i+1],
nAggregatedPacketSize & 0x00FF, nAggregatedPacketSize >> 8);
return false;
}
i += 2;
pNdpIndex[0] = pAggregatedPacket[i]; //least significant byte
pNdpIndex[1] = pAggregatedPacket[i+1]; //most significant byte
//reading the NDP
while (0x00 != pNdpIndex[0] || 0x00 != pNdpIndex[1])
{
i = pNdpIndex[0] + 256*pNdpIndex[1]; //NDP should begin here
nNdpStart = i;
if (0x49 != pAggregatedPacket[i] || 0x50 != pAggregatedPacket[i + 1] ||
0x53 != pAggregatedPacket[i + 2] || 0x00 != pAggregatedPacket[i + 3])
{
LOG_MSG_DEBUG("Error: Wrong NDP16 signature: 0x%02x 0x%02x "
"0x%02x 0x%02x(should be 0x49, 0x50, 0x53, 0x00)\n",
pAggregatedPacket[i], pAggregatedPacket[i + 1],
pAggregatedPacket[i + 2], pAggregatedPacket[i + 3]);
return false;
}
i += 4;
pNdpLen[0] = pAggregatedPacket[i]; //least significant byte
pNdpLen[1] = pAggregatedPacket[i+1]; //most significant byte
if (0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2] ||
0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] -1])
{
LOG_MSG_DEBUG("Error: Wrong end of NDP: 0x%02x 0x%02x(should be 0x00,"
" 0x00)\n",
pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2],
pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 1]);
return false;
}
i += 2;
pNdpIndex[0] = pAggregatedPacket[i]; //least significant byte
pNdpIndex[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
while (i <= nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2)
{ //going over all the datagrams in this NDP
Byte pDatagramIndex[2] = {0};
Byte pDatagramLen[2] = {0};
int packetIndex = 0;
pDatagramIndex[0] = pAggregatedPacket[i]; //least significant byte
pDatagramIndex[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
if (0x00 == pDatagramIndex[0] && 0x00 == pDatagramIndex[1])
break; //zero padding after all datagrams
if (nPacketNum >= nNumPackets)
{
LOG_MSG_DEBUG("Error: wrong number of packets: %d(should be %d)\n",
nPacketNum, nNumPackets);
return false;
}
pDatagramLen[0] = pAggregatedPacket[i]; //least significant byte
pDatagramLen[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
packetIndex = pDatagramIndex[0] + 256*pDatagramIndex[1];
if (pDatagramLen[0] + 256*pDatagramLen[1] != pPacketsSizes[nPacketNum])
{
LOG_MSG_DEBUG("Error: Wrong packet %d length: 0x%02x 0x%02x"
"(should be %d)\n", nPacketNum, pDatagramLen[0],
pDatagramLen[1], pPacketsSizes[nPacketNum]);
return false;
}
if (0 != memcmp(pExpectedPackets[nPacketNum],
&pAggregatedPacket[packetIndex], pPacketsSizes[nPacketNum]))
{
LOG_MSG_DEBUG("Error: Comparison of packet %d failed!\n",
nPacketNum);
return false;
}
nPacketNum++;
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
void MBIMAggregationScenarios::AggregatePackets(
Byte pAggregatedPacket[MAX_PACKET_SIZE]/*ouput*/,
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE],
int pPacketsSizes[NUM_PACKETS], int nNumPackets,
int nAggregatedPacketSize)
{
int i = 0;
int pDatagramIndexes[NUM_PACKETS] = {0};
int nNdpIndex = 0;
int nNdpLen = 0;
//NTH16 signature
pAggregatedPacket[i] = 0x4e;
pAggregatedPacket[i+1] = 0x43;
pAggregatedPacket[i+2] = 0x4d;
pAggregatedPacket[i+3] = 0x48;
i += 4;
//header length
pAggregatedPacket[i] = 0x0c;
pAggregatedPacket[i+1] = 0x00;
i += 2;
//sequence number
pAggregatedPacket[i] = 0x00;
pAggregatedPacket[i+1] = 0x00;
i += 2;
//aggregated packet length
pAggregatedPacket[i] = nAggregatedPacketSize & 0x00FF;
pAggregatedPacket[i+1] = nAggregatedPacketSize >> 8;
i += 2;
//NDP index
for (int j = 0; j < nNumPackets; j++)
nNdpIndex += pPacketsSizes[j];
nNdpIndex += i + 2;
while (0 != nNdpIndex % 4)
nNdpIndex++;
pAggregatedPacket[i] = nNdpIndex & 0x00FF;
pAggregatedPacket[i+1] = nNdpIndex >> 8;
i += 2;
//packets
for (int j = 0; j < nNumPackets; j++)
{
pDatagramIndexes[j] = i;
for (int k = 0; k < pPacketsSizes[j]; k++)
{
pAggregatedPacket[i] = pPackets[j][k];
i++;
}
}
while (i < nNdpIndex)
{
pAggregatedPacket[i] = 0x00;
i++;
}
//NDP16 signature
pAggregatedPacket[i] = 0x49;
pAggregatedPacket[i+1] = 0x50;
pAggregatedPacket[i+2] = 0x53;
pAggregatedPacket[i+3] = 0x00;
i += 4;
//NDP length
nNdpLen = 4*nNumPackets + 8 + 2;
while (nNdpLen % 4 != 0)
nNdpLen += 2;
pAggregatedPacket[i] = nNdpLen & 0x00FF;
pAggregatedPacket[i+1] = nNdpLen >> 8;
i += 2;
//next NDP
pAggregatedPacket[i] = 0x00;
pAggregatedPacket[i+1] = 0x00;
i += 2;
for (int j = 0; j < nNumPackets; j++)
{
//datagram index
pAggregatedPacket[i] = pDatagramIndexes[j] & 0x00FF;
pAggregatedPacket[i+1] = pDatagramIndexes[j] >> 8;
i += 2;
//datagram length
pAggregatedPacket[i] = pPacketsSizes[j] & 0x00FF;
pAggregatedPacket[i+1] = pPacketsSizes[j] >> 8;
i += 2;
}
//zeros in the end of NDP
while (i < nAggregatedPacketSize)
{
pAggregatedPacket[i] = 0x00;
i++;
}
}
/////////////////////////////////////////////////////////////////////////////////
void MBIMAggregationScenarios::AggregatePacketsWithStreamId(
Byte pAggregatedPacket[MAX_PACKET_SIZE]/*ouput*/,
Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE],
int pPacketsSizes[NUM_PACKETS], int nNumPackets, int nAggregatedPacketSize,
Byte pPacketsStreamId[NUM_PACKETS])
{
int i = 0;
int n = 0;
int pDatagramIndexes[NUM_PACKETS] = {0};
int nNdpIndex[NUM_PACKETS] = {0};
int nNdpLen = 0;
Byte currStreamId = pPacketsStreamId[0];
int nNdpFirstPacket[NUM_PACKETS] = {0};
int nNdpAfterLastPacket[NUM_PACKETS] = {0};
int nNumNDPs = 0;
for (n = 0; n < nNumPackets; n++)
{
if (currStreamId != pPacketsStreamId[n])
{
nNdpAfterLastPacket[nNumNDPs] = n;
nNumNDPs++;
nNdpFirstPacket[nNumNDPs] = n;
currStreamId = pPacketsStreamId[n];
}
}
nNdpAfterLastPacket[nNumNDPs] = n;
nNumNDPs++;
//calculate NDP indexes
nNdpIndex[0] += 12; //adding the header
for (int j = 0; j < nNumNDPs; j++)
{
for (n = nNdpFirstPacket[j]; n < nNdpAfterLastPacket[j]; n++)
nNdpIndex[j] += pPacketsSizes[n]; //adding the packets
while (0 != nNdpIndex[j] % 4)
nNdpIndex[j]++;
if (j < nNumNDPs - 1)
nNdpIndex[j+1] += nNdpIndex[j] + 12 + 4*(nNdpAfterLastPacket[j] -
nNdpFirstPacket[j]); //adding the location after the current NDP to the next NDP
}
//start building the aggregated packet
//NTH16 signature
pAggregatedPacket[i] = 0x4e;
pAggregatedPacket[i+1] = 0x43;
pAggregatedPacket[i+2] = 0x4d;
pAggregatedPacket[i+3] = 0x48;
i += 4;
//header length
pAggregatedPacket[i] = 0x0c;
pAggregatedPacket[i+1] = 0x00;
i += 2;
//sequence number
pAggregatedPacket[i] = 0x00;
pAggregatedPacket[i+1] = 0x00;
i += 2;
//aggregated packet length
pAggregatedPacket[i] = nAggregatedPacketSize & 0x00FF;
pAggregatedPacket[i+1] = nAggregatedPacketSize >> 8;;
i += 2;
//first NDP index
pAggregatedPacket[i] = nNdpIndex[0] & 0x00FF;
pAggregatedPacket[i+1] = nNdpIndex[0] >> 8;
i += 2;
for (n = 0; n < nNumNDPs; n++)
{
//packets
for (int j = nNdpFirstPacket[n]; j < nNdpAfterLastPacket[n]; j++)
{
pDatagramIndexes[j] = i;
for (int k = 0; k < pPacketsSizes[j]; k++)
{
pAggregatedPacket[i] = pPackets[j][k];
i++;
}
}
while (i < nNdpIndex[n])
{
pAggregatedPacket[i] = 0x00;
i++;
}
//NDP signature
pAggregatedPacket[i] = 0x49;
pAggregatedPacket[i+1] = 0x50;
pAggregatedPacket[i+2] = 0x53;
pAggregatedPacket[i+3] = pPacketsStreamId[nNdpFirstPacket[n]];
i += 4;
//NDP length
nNdpLen = 4*(nNdpAfterLastPacket[n] - nNdpFirstPacket[n]) + 8 + 2;
while (nNdpLen % 4 != 0)
nNdpLen += 2;
pAggregatedPacket[i] = nNdpLen & 0x00FF;
pAggregatedPacket[i+1] = nNdpLen >> 8;
i += 2;
//next NDP
pAggregatedPacket[i] = nNdpIndex[n+1] & 0x00FF;
pAggregatedPacket[i+1] = nNdpIndex[n+1] >> 8;
i += 2;
for (int j = nNdpFirstPacket[n]; j < nNdpAfterLastPacket[n]; j++)
{
//datagram index
pAggregatedPacket[i] = pDatagramIndexes[j] & 0x00FF;
pAggregatedPacket[i+1] = pDatagramIndexes[j] >> 8;
i += 2;
//datagram length
pAggregatedPacket[i] = pPacketsSizes[j] & 0x00FF;
pAggregatedPacket[i+1] = pPacketsSizes[j] >> 8;
i += 2;
}
//zeros in the end of NDP
while (i < nNdpIndex[n] + nNdpLen)
{
pAggregatedPacket[i] = 0x00;
i++;
}
}
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::DeaggragateAndCompareOnePacket(
Byte pAggregatedPacket[MAX_PACKET_SIZE],
Byte pExpectedPacket[MAX_PACKET_SIZE], int nPacketsSize,
int nAggregatedPacketSize)
{
int nPacketNum = 0;
int i = 0;
int nNdpStart = 0;
Byte pNdpIndex[2] = {0};
Byte pNdpLen[2] = {0};
if (0x4e != pAggregatedPacket[i] || 0x43 != pAggregatedPacket[i+1] ||
0x4d != pAggregatedPacket[i+2]|| 0x48 != pAggregatedPacket[i+3])
{
LOG_MSG_DEBUG("Error: Wrong NTH16 signature: 0x%02x 0x%02x 0x%02x "
"0x%02x(should be 0x4e, 0x43, 0x4d, 0x48)\n",
pAggregatedPacket[i], pAggregatedPacket[i+1],
pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
return false;
}
i += 4;
if (0x0c != pAggregatedPacket[i] || 0x00 != pAggregatedPacket[i+1])
{
LOG_MSG_DEBUG("Error: Wrong header length: 0x%02x 0x%02x(should be 0x0c,"
" 0x00)\n", pAggregatedPacket[i], pAggregatedPacket[i+1]);
return false;
}
i += 4; //ignoring sequence number
if ((nAggregatedPacketSize & 0x00FF) != pAggregatedPacket[i] ||
(nAggregatedPacketSize >> 8) != pAggregatedPacket[i+1])
{
LOG_MSG_DEBUG("Error: Wrong aggregated packet length: 0x%02x 0x%02x"
"(should be 0x%02x, 0x%02x)\n",
pAggregatedPacket[i], pAggregatedPacket[i+1],
nAggregatedPacketSize & 0x00FF, nAggregatedPacketSize >> 8);
return false;
}
i += 2;
pNdpIndex[0] = pAggregatedPacket[i]; //least significant byte
pNdpIndex[1] = pAggregatedPacket[i+1]; //most significant byte
//reading the NDP
while (0x00 != pNdpIndex[0] || 0x00 != pNdpIndex[1])
{
i = pNdpIndex[0] + 256*pNdpIndex[1]; //NDP should begin here
nNdpStart = i;
if (0x49 != pAggregatedPacket[i] || 0x50 != pAggregatedPacket[i+1] ||
0x53 != pAggregatedPacket[i+2] || 0x00 != pAggregatedPacket[i+3])
{
LOG_MSG_DEBUG("Error: Wrong NDP16 signature: 0x%02x 0x%02x "
"0x%02x 0x%02x(should be 0x49, 0x50, 0x53, 0x00)\n",
pAggregatedPacket[i], pAggregatedPacket[i+1],
pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
return false;
}
i += 4;
pNdpLen[0] = pAggregatedPacket[i]; //least significant byte
pNdpLen[1] = pAggregatedPacket[i+1]; //most significant byte
if (0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2] ||
0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] -1])
{
LOG_MSG_DEBUG("Error: Wrong end of NDP: 0x%02x 0x%02x(should be "
"0x00, 0x00)\n",
pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2],
pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 1]);
return false;
}
i += 2;
pNdpIndex[0] = pAggregatedPacket[i]; //least significant byte
pNdpIndex[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
while (i <= nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2)
{ //going over all the datagrams in this NDP
Byte pDatagramIndex[2] = {0};
Byte pDatagramLen[2] = {0};
int packetIndex = 0;
pDatagramIndex[0] = pAggregatedPacket[i]; //least significant byte
pDatagramIndex[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
if (0x00 == pDatagramIndex[0] && 0x00 == pDatagramIndex[1])
break; //zero padding after all datagrams
if (nPacketNum > 1)
{
LOG_MSG_DEBUG("Error: wrong number of packets: %d(should be %d)\n",
nPacketNum, 1);
return false;
}
pDatagramLen[0] = pAggregatedPacket[i]; //least significant byte
pDatagramLen[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
packetIndex = pDatagramIndex[0] + 256*pDatagramIndex[1];
if (pDatagramLen[0] + 256*pDatagramLen[1] != nPacketsSize)
{
LOG_MSG_DEBUG("Error: Wrong packet %d length: 0x%02x 0x%02x"
"(should be %d)\n", nPacketNum, pDatagramLen[0],
pDatagramLen[1], nPacketsSize);
return false;
}
if (0 != memcmp(pExpectedPacket, &pAggregatedPacket[packetIndex],
nPacketsSize))
{
LOG_MSG_DEBUG("Error: Comparison of packet %d failed!\n",
nPacketNum);
return false;
}
nPacketNum++;
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
bool MBIMAggregationScenarios::DeaggragateAndComparePacketsWithStreamId(
Byte pAggregatedPacket[MAX_PACKET_SIZE],
Byte pExpectedPackets[][MAX_PACKET_SIZE], int pPacketsSizes[],
int nNumPackets, int nAggregatedPacketSize,
Byte pPacketsStreamId[NUM_PACKETS])
{
int nPacketNum = 0;
int i = 0;
int nNdpStart = 0;
Byte pNdpIndex[2] = {0};
Byte pNdpLen[2] = {0};
if (0x4e != pAggregatedPacket[i] || 0x43 != pAggregatedPacket[i+1] ||
0x4d != pAggregatedPacket[i+2]|| 0x48 != pAggregatedPacket[i+3])
{
LOG_MSG_DEBUG("Error: Wrong NTH16 signature: 0x%02x 0x%02x 0x%02x "
"0x%02x(should be 0x4e, 0x43, 0x4d, 0x48)\n",
pAggregatedPacket[i], pAggregatedPacket[i+1],
pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
return false;
}
i += 4;
if (0x0c != pAggregatedPacket[i] || 0x00 != pAggregatedPacket[i+1])
{
LOG_MSG_DEBUG("Error: Wrong header length: 0x%02x 0x%02x(should be "
"0x0c, 0x00)\n",pAggregatedPacket[i], pAggregatedPacket[i+1]);
return false;
}
i += 4; //ignoring sequence number
if ((nAggregatedPacketSize & 0x00FF) != pAggregatedPacket[i] ||
(nAggregatedPacketSize >> 8) != pAggregatedPacket[i+1])
{
LOG_MSG_DEBUG("Error: Wrong aggregated packet length: 0x%02x 0x%02x"
"(should be 0x%02x, 0x%02x)\n", pAggregatedPacket[i],
pAggregatedPacket[i+1], nAggregatedPacketSize & 0x00FF,
nAggregatedPacketSize >> 8);
return false;
}
i += 2;
pNdpIndex[0] = pAggregatedPacket[i]; //least significant byte
pNdpIndex[1] = pAggregatedPacket[i+1]; //most significant byte
//reading the NDP
while (0x00 != pNdpIndex[0] || 0x00 != pNdpIndex[1])
{
i = pNdpIndex[0] + 256*pNdpIndex[1]; //NDP should begin here
nNdpStart = i;
if (0x49 != pAggregatedPacket[i] || 0x50 != pAggregatedPacket[i+1] ||
0x53 != pAggregatedPacket[i+2])
{
LOG_MSG_DEBUG("Error: Wrong NDP16 signature: 0x%02x 0x%02x 0x%02x"
"(should be 0x49, 0x50, 0x53)\n", pAggregatedPacket[i],
pAggregatedPacket[i+1], pAggregatedPacket[i+2]);
return false;
}
if (pPacketsStreamId[nPacketNum] != pAggregatedPacket[i+3])
{
LOG_MSG_DEBUG("Error: Wrong NDP stream id: 0x%02x(should be 0x%02x)\n",
pAggregatedPacket[i+3], pPacketsStreamId[nPacketNum]);
return false;
}
i += 4;
pNdpLen[0] = pAggregatedPacket[i]; //least significant byte
pNdpLen[1] = pAggregatedPacket[i+1]; //most significant byte
if (0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2] ||
0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] -1])
{
LOG_MSG_DEBUG("Error: Wrong end of NDP: 0x%02x 0x%02x(should be 0x00, "
"0x00)\n",
pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2],
pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 1]);
return false;
}
i += 2;
pNdpIndex[0] = pAggregatedPacket[i]; //least significant byte
pNdpIndex[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
while (i <= nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2)
{ //going over all the datagrams in this NDP
Byte pDatagramIndex[2] = {0};
Byte pDatagramLen[2] = {0};
int packetIndex = 0;
pDatagramIndex[0] = pAggregatedPacket[i]; //least significant byte
pDatagramIndex[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
if (0x00 == pDatagramIndex[0] && 0x00 == pDatagramIndex[1])
break; //zero padding after all datagrams
if (nPacketNum >= nNumPackets)
{
LOG_MSG_DEBUG("Error: wrong number of packets: %d(should be %d)\n",
nPacketNum, nNumPackets);
return false;
}
pDatagramLen[0] = pAggregatedPacket[i]; //least significant byte
pDatagramLen[1] = pAggregatedPacket[i+1]; //most significant byte
i += 2;
packetIndex = pDatagramIndex[0] + 256*pDatagramIndex[1];
if (pDatagramLen[0] + 256*pDatagramLen[1] != (int)pPacketsSizes[nPacketNum])
{
LOG_MSG_DEBUG("Error: Wrong packet %d length: 0x%02x 0x%02x"
"(should be %d)\n", nPacketNum, pDatagramLen[0],
pDatagramLen[1], pPacketsSizes[nPacketNum]);
return false;
}
if (0 != memcmp(pExpectedPackets[nPacketNum],
&pAggregatedPacket[packetIndex], pPacketsSizes[nPacketNum]))
{
LOG_MSG_DEBUG("Error: Comparison of packet %d failed!\n",
nPacketNum);
return false;
}
nPacketNum++;
}
}
return true;
}
class MBIMAggregationTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationTest(bool generic_agg) :
MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregationTest";
else
m_name = "MBIMAggregationTest";
m_description = "MBIM Aggregation test - sends 5 packets and receives 1 "
"aggregated packet";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationTest(&m_UsbToIpaPipe,
&m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMDeaggregationTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMDeaggregationTest(bool generic_agg) :
MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMDeaggregationTest";
else
m_name = "MBIMDeaggregationTest";
m_description = "MBIM Deaggregation test - sends an aggregated packet made from"
"5 packets and receives 5 packets";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRulesDeaggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMDeaggregationTest(&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
class MBIMDeaggregationOnePacketTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMDeaggregationOnePacketTest(bool generic_agg) :
MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMDeaggregationOnePacketTest";
else
m_name = "MBIMDeaggregationOnePacketTest";
m_description = "MBIM Deaggregation one packet test - sends an aggregated packet made"
"of 1 packet and receives 1 packet";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRulesDeaggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMDeaggregationOnePacketTest(&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMDeaggregationAndAggregationTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMDeaggregationAndAggregationTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMDeaggregationAndAggregationTest";
else
m_name = "MBIMDeaggregationAndAggregationTest";
m_description = "MBIM Deaggregation and Aggregation test - sends an aggregated "
"packet made from 5 packets and receives the same aggregated packet";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMDeaggregationAndAggregationTest(
&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMMultipleDeaggregationAndAggregationTest:
public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMMultipleDeaggregationAndAggregationTest(bool generic_agg) :
MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMMultipleDeaggregationAndAggregationTest";
else
m_name = "MBIMMultipleDeaggregationAndAggregationTest";
m_description = "MBIM Multiple Deaggregation and Aggregation test - sends 5 aggregated "
"packets each one made of 1 packet and receives an aggregated packet made of the"
"5 packets";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMMultipleDeaggregationAndAggregationTest(
&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationLoopTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationLoopTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMggregationLoopTest";
else
m_name = "MBIMggregationLoopTest";
m_description = "MBIM Aggregation Loop test - sends 5 packets and expects to"
"receives 1 aggregated packet a few times";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationLoopTest(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationTimeLimitTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationTimeLimitTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregationTimeLimitTest";
else
m_name = "MBIMAggregationTimeLimitTest";
m_description = "MBIM Aggregation time limit test - sends 1 small packet "
"smaller than the byte limit and receives 1 aggregated packet";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregationTime();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationTimeLimitTest(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAggTime, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationByteLimitTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationByteLimitTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregationByteLimitTest";
else
m_name = "MBIMAggregationByteLimitTest";
m_description = "MBIM Aggregation byte limit test - sends 2 packets that together "
"are larger than the byte limit ";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationByteLimitTest(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationByteLimitTestFC: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationByteLimitTestFC(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg) {
if (generic_agg)
m_name = "GenMBIMAggregationByteLimitTestFC";
else
m_name = "MBIMAggregationByteLimitTestFC";
m_description = "MBIMAggregationByteLimitTestFC - Send 4 IP packet with FC"
"and expect 4 aggregated MBIM packets.";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules() {
return AddRules1HeaderAggregation(true);
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationByteLimitTestFC(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP);
}
};
class MBIMAggregationDualDpTestFC : public MBIMAggregationTestFixtureConf11
{
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationDualDpTestFC(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg) m_name = "GenMBIMAggregationDualDpTestFC";
else m_name = "MBIMAggregationDualDpTestFC";
m_description = "MBIMAggregationDualDpTestFC - Send IP packets "
"on two datapathes: one with FC and one without. "
"Expect 2 aggregated MBIM packets on pipe with FC. "
"Expect one aggregated MBIM packet on pipe without FC. ";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRulesAggDualFC(&m_UsbToIpaPipe,
&m_IpaToUsbPipeAggTime,
&m_IpaToUsbPipeAgg);
}
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationDualDpTestFC(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAggTime, &m_IpaToUsbPipeAgg, m_eIP);
}
};
class MBIMAggregationDualDpTestFcRoutingBased : public MBIMAggregationTestFixtureConf11
{
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationDualDpTestFcRoutingBased(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg) m_name = "GenMBIMAggregationDualDpTestFcRoutingBased";
else m_name = "MBIMAggregationDualDpTestFcRoutingBased";
m_description = "MBIMAggregationDualDpTestFcRoutingBased - Send IP packets "
"on two datapathes: one with RT based FC and one without. "
"Expect 2 aggregated MBIM packets on pipe with RT based FC. "
"Expect one aggregated MBIM packet on pipe without RT based FC. ";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRulesAggDualFcRoutingBased(&m_UsbToIpaPipe,
&m_IpaToUsbPipeAggTime,
&m_IpaToUsbPipeAgg);
}
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationDualDpTestFC(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAggTime, &m_IpaToUsbPipeAgg, m_eIP);
}
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMDeaggregationMultipleNDPTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMDeaggregationMultipleNDPTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMDeaggregationMultipleNDPTest";
else
m_name = "MBIMDeaggregationMultipleNDPTest";
m_description = "MBIM Deaggregation multiple NDP test - sends an aggregated"
"packet made from 5 packets and 2 NDPs and receives 5 packets";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRulesDeaggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMDeaggregationMultipleNDPTest(
&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregation2PipesTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregation2PipesTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregation2PipesTest";
else
m_name = "MBIMAggregation2PipesTest";
m_description = "MBIM Aggregation 2 pipes test - sends 3 packets from one pipe"
"and an aggregated packet made of 2 packets from another pipe and "
"receives 1 aggregated packet made of all 5 packets";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregation2PipesTest(
&m_UsbToIpaPipeDeagg, &m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationTimeLimitLoopTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationTimeLimitLoopTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregationTimeLimitLoopTest";
else
m_name = "MBIMAggregationTimeLimitLoopTest";
m_description = "MBIM Aggregation time limit loop test - sends 5 small packet "
"smaller than the byte limit and receives 5 aggregated packet";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregationTime();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationTimeLimitLoopTest(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAggTime, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationMultiplePacketsTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationMultiplePacketsTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregationMultiplePacketsTest";
else
m_name = "MBIMAggregationMultiplePacketsTest";
m_description = "MBIM Aggregation multiple packets test - sends 9 packets "
"with same stream ID and receives 1 aggregated packet with 2 NDPs";
this->m_runInRegression = false;
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregation();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationMultiplePacketsTest(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregation0LimitsTest: public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregation0LimitsTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregation0LimitsTest";
else
m_name = "MBIMAggregation0LimitsTest";
m_description = "MBIM Aggregation 0 limits test - sends 5 packets and expects"
"to get each packet back aggregated (both size and time limits are 0)";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
return AddRules1HeaderAggregation0Limits();
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregation0LimitsTest(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg0Limits, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationDifferentStreamIdsTest:
public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationDifferentStreamIdsTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregationDifferentStreamIdsTest";
else
m_name = "MBIMAggregationDifferentStreamIdsTest";
m_description = "MBIM Aggregation different stream IDs test - sends 5 packets"
"with different stream IDs and receives 1 aggregated packet made of 5"
"NDPs";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
m_eIP = IPA_IP_v4;
const char aBypass[NUM_PACKETS][20] = {{"Bypass1"}, {"Bypass2"}, {"Bypass3"},
{"Bypass4"}, {"Bypass5"}};
uint32_t nTableHdl[NUM_PACKETS];
bool bRetVal = true;
IPAFilteringTable cFilterTable0;
struct ipa_flt_rule_add sFilterRuleEntry;
struct ipa_ioc_get_hdr sGetHeader[NUM_PACKETS];
uint8_t aHeadertoAdd[NUM_PACKETS][4];
int hdrSize;
for (int i = 0; i < NUM_PACKETS; i++) {
if (mGenericAgg) {
hdrSize = 4;
aHeadertoAdd[i][0] = 0x49;
aHeadertoAdd[i][1] = 0x50;
aHeadertoAdd[i][2] = 0x53;
aHeadertoAdd[i][3] = (uint8_t)i;
} else {
hdrSize = 1;
aHeadertoAdd[i][0] = (uint8_t)i;
}
}
LOG_MSG_STACK("Entering Function");
memset(&sFilterRuleEntry, 0, sizeof(sFilterRuleEntry));
for (int i = 0; i < NUM_PACKETS; i++)
memset(&sGetHeader[i], 0, sizeof(sGetHeader[i]));
// Create Header:
// Allocate Memory, populate it, and add in to the Header Insertion.
struct ipa_ioc_add_hdr * pHeaderDescriptor = NULL;
pHeaderDescriptor = (struct ipa_ioc_add_hdr *) calloc(1,
sizeof(struct ipa_ioc_add_hdr)
+ NUM_PACKETS * sizeof(struct ipa_hdr_add));
if (!pHeaderDescriptor)
{
LOG_MSG_ERROR("calloc failed to allocate pHeaderDescriptor");
bRetVal = false;
goto bail;
}
pHeaderDescriptor->commit = true;
pHeaderDescriptor->num_hdrs = NUM_PACKETS;
// Adding Header No1.
strlcpy(pHeaderDescriptor->hdr[0].name, "StreamId0", sizeof(pHeaderDescriptor->hdr[0].name)); // Header's Name
memcpy(pHeaderDescriptor->hdr[0].hdr, (void*)&aHeadertoAdd[0],
hdrSize); //Header's Data
pHeaderDescriptor->hdr[0].hdr_len = hdrSize;
pHeaderDescriptor->hdr[0].hdr_hdl = -1; //Return Value
pHeaderDescriptor->hdr[0].is_partial = false;
pHeaderDescriptor->hdr[0].status = -1; // Return Parameter
// Adding Header No2.
strlcpy(pHeaderDescriptor->hdr[1].name, "StreamId1", sizeof(pHeaderDescriptor->hdr[1].name)); // Header's Name
memcpy(pHeaderDescriptor->hdr[1].hdr, (void*)&aHeadertoAdd[1],
hdrSize); //Header's Data
pHeaderDescriptor->hdr[1].hdr_len = hdrSize;
pHeaderDescriptor->hdr[1].hdr_hdl = -1; //Return Value
pHeaderDescriptor->hdr[1].is_partial = false;
pHeaderDescriptor->hdr[1].status = -1; // Return Parameter
// Adding Header No3.
strlcpy(pHeaderDescriptor->hdr[2].name, "StreamId2", sizeof(pHeaderDescriptor->hdr[2].name)); // Header's Name
memcpy(pHeaderDescriptor->hdr[2].hdr, (void*)&aHeadertoAdd[2],
hdrSize); //Header's Data
pHeaderDescriptor->hdr[2].hdr_len = hdrSize;
pHeaderDescriptor->hdr[2].hdr_hdl = -1; //Return Value
pHeaderDescriptor->hdr[2].is_partial = false;
pHeaderDescriptor->hdr[2].status = -1; // Return Parameter
// Adding Header No4.
strlcpy(pHeaderDescriptor->hdr[3].name, "StreamId3", sizeof(pHeaderDescriptor->hdr[3].name)); // Header's Name
memcpy(pHeaderDescriptor->hdr[3].hdr, (void*)&aHeadertoAdd[3],
hdrSize); //Header's Data
pHeaderDescriptor->hdr[3].hdr_len = hdrSize;
pHeaderDescriptor->hdr[3].hdr_hdl = -1; //Return Value
pHeaderDescriptor->hdr[3].is_partial = false;
pHeaderDescriptor->hdr[3].status = -1; // Return Parameter
// Adding Header No5.
strlcpy(pHeaderDescriptor->hdr[4].name, "StreamId4", sizeof(pHeaderDescriptor->hdr[4].name)); // Header's Name
memcpy(pHeaderDescriptor->hdr[4].hdr, (void*)&aHeadertoAdd[4],
hdrSize); //Header's Data
pHeaderDescriptor->hdr[4].hdr_len = hdrSize;
pHeaderDescriptor->hdr[4].hdr_hdl = -1; //Return Value
pHeaderDescriptor->hdr[4].is_partial = false;
pHeaderDescriptor->hdr[4].status = -1; // Return Parameter
for (int i = 0; i < NUM_PACKETS; i++)
strlcpy(sGetHeader[i].name, pHeaderDescriptor->hdr[i].name, sizeof(sGetHeader[i].name));
if (!m_HeaderInsertion.AddHeader(pHeaderDescriptor))
{
LOG_MSG_ERROR("m_HeaderInsertion.AddHeader(pHeaderDescriptor) Failed.");
bRetVal = false;
goto bail;
}
for (int i = 0; i < NUM_PACKETS; i++)
{
if (!m_HeaderInsertion.GetHeaderHandle(&sGetHeader[i]))
{
LOG_MSG_ERROR(" Failed");
bRetVal = false;
goto bail;
}
LOG_MSG_DEBUG("Received Header %d Handle = 0x%x", i, sGetHeader[i].hdl);
}
for (int i = 0; i < NUM_PACKETS; i++)
{
if (!CreateBypassRoutingTable(&m_Routing, m_eIP, aBypass[i],
IPA_CLIENT_TEST2_CONS, sGetHeader[i].hdl,&nTableHdl[i]))
{
LOG_MSG_ERROR("CreateBypassRoutingTable Failed\n");
bRetVal = false;
goto bail;
}
}
LOG_MSG_INFO("Creation of 5 bypass routing tables completed successfully");
// Creating Filtering Rules
cFilterTable0.Init(m_eIP,IPA_CLIENT_TEST_PROD, false, NUM_PACKETS);
LOG_MSG_INFO("Creation of filtering table completed successfully");
// Configuring Filtering Rule No.1
cFilterTable0.GeneratePresetRule(1,sFilterRuleEntry);
sFilterRuleEntry.at_rear = true;
sFilterRuleEntry.flt_rule_hdl=-1; // return Value
sFilterRuleEntry.status = -1; // return value
sFilterRuleEntry.rule.action=IPA_PASS_TO_ROUTING;
sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[0]; //put here the handle corresponding to Routing Rule 1
sFilterRuleEntry.rule.attrib.attrib_mask = IPA_FLT_DST_ADDR; // Destination IP Based Filtering
sFilterRuleEntry.rule.attrib.u.v4.dst_addr_mask = 0xFF0000FF; // Mask
sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0x7F000001; // Filter DST_IP == 127.0.0.1.
if (
((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
)
{
LOG_MSG_ERROR ("Adding Rule (0) to Filtering block Failed.");
bRetVal = false;
goto bail;
}
else
{
LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
cFilterTable0.ReadRuleFromTable(0)->flt_rule_hdl,
cFilterTable0.ReadRuleFromTable(0)->status);
}
// Configuring Filtering Rule No.2
sFilterRuleEntry.flt_rule_hdl=-1; // return Value
sFilterRuleEntry.status = -1; // return Value
sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[1]; //put here the handle corresponding to Routing Rule 2
sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80101; // Filter DST_IP == 192.168.1.1.
if (
((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
)
{
LOG_MSG_ERROR ("Adding Rule(1) to Filtering block Failed.");
bRetVal = false;
goto bail;
}
else
{
LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
cFilterTable0.ReadRuleFromTable(1)->flt_rule_hdl,
cFilterTable0.ReadRuleFromTable(1)->status);
}
// Configuring Filtering Rule No.3
sFilterRuleEntry.flt_rule_hdl=-1; // return Value
sFilterRuleEntry.status = -1; // return value
sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[2]; //put here the handle corresponding to Routing Rule 2
sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80102; // Filter DST_IP == 192.168.1.2.
if (
((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
)
{
LOG_MSG_ERROR ("Adding Rule(2) to Filtering block Failed.");
bRetVal = false;
goto bail;
}
else
{
LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
cFilterTable0.ReadRuleFromTable(2)->flt_rule_hdl,
cFilterTable0.ReadRuleFromTable(2)->status);
}
// Configuring Filtering Rule No.4
sFilterRuleEntry.flt_rule_hdl=-1; // return Value
sFilterRuleEntry.status = -1; // return value
sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[3]; //put here the handle corresponding to Routing Rule 2
sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80103; // Filter DST_IP == 192.168.1.3.
if (
((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
)
{
LOG_MSG_ERROR ("Adding Rule(3) to Filtering block Failed.");
bRetVal = false;
goto bail;
}
else
{
LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
cFilterTable0.ReadRuleFromTable(2)->flt_rule_hdl,
cFilterTable0.ReadRuleFromTable(2)->status);
}
// Configuring Filtering Rule No.5
sFilterRuleEntry.flt_rule_hdl=-1; // return Value
sFilterRuleEntry.status = -1; // return value
sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[4]; //put here the handle corresponding to Routing Rule 2
sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80104; // Filter DST_IP == 192.168.1.4.
if (
((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
)
{
LOG_MSG_ERROR ("Adding Rule(4) to Filtering block Failed.");
bRetVal = false;
goto bail;
}
else
{
LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
cFilterTable0.ReadRuleFromTable(2)->flt_rule_hdl,
cFilterTable0.ReadRuleFromTable(2)->status);
}
bail:
Free(pHeaderDescriptor);
LOG_MSG_STACK(
"Leaving Function (Returning %s)", bRetVal?"True":"False");
return bRetVal;
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationDifferentStreamIdsTest(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
class MBIMAggregationNoInterleavingStreamIdsTest:
public MBIMAggregationTestFixtureConf11 {
public:
/////////////////////////////////////////////////////////////////////////////////
MBIMAggregationNoInterleavingStreamIdsTest(bool generic_agg)
: MBIMAggregationTestFixtureConf11(generic_agg)
{
if (generic_agg)
m_name = "GenMBIMAggregationNoInterleavingStreamIdsTest";
else
m_name = "MBIMAggregationNoInterleavingStreamIdsTest";
m_description = "MBIM Aggregation no interleaving stream IDs test - sends 5 packets"
"with interleaving stream IDs (0, 1, 0, 1, 0) and receives 1 aggregated "
"packet made of 5 NDPs";
}
/////////////////////////////////////////////////////////////////////////////////
virtual bool AddRules()
{
m_eIP = IPA_IP_v4;
const char aBypass[2][20] = {{"Bypass1"}, {"Bypass2"}};
uint32_t nTableHdl[2];
bool bRetVal = true;
IPAFilteringTable cFilterTable0;
struct ipa_flt_rule_add sFilterRuleEntry;
struct ipa_ioc_get_hdr sGetHeader[2];
uint8_t aHeadertoAdd[2][4];
int hdrSize;
for (int i = 0; i < 2; i++) {
if (mGenericAgg) {
hdrSize = 4;
aHeadertoAdd[i][0] = 0x49;
aHeadertoAdd[i][1] = 0x50;
aHeadertoAdd[i][2] = 0x53;
aHeadertoAdd[i][3] = (uint8_t)i;
}
else {
hdrSize = 1;
aHeadertoAdd[i][0] = (uint8_t)i;
}
}
LOG_MSG_STACK("Entering Function");
memset(&sFilterRuleEntry, 0, sizeof(sFilterRuleEntry));
for (int i = 0; i < 2; i++)
memset(&sGetHeader[i], 0, sizeof(sGetHeader[i]));
// Create Header:
// Allocate Memory, populate it, and add in to the Header Insertion.
struct ipa_ioc_add_hdr * pHeaderDescriptor = NULL;
pHeaderDescriptor = (struct ipa_ioc_add_hdr *) calloc(1,
sizeof(struct ipa_ioc_add_hdr)
+ 2 * sizeof(struct ipa_hdr_add));
if (!pHeaderDescriptor)
{
LOG_MSG_ERROR("calloc failed to allocate pHeaderDescriptor");
bRetVal = false;
goto bail;
}
pHeaderDescriptor->commit = true;
pHeaderDescriptor->num_hdrs = 2;
// Adding Header No1.
strlcpy(pHeaderDescriptor->hdr[0].name, "StreamId0", sizeof(pHeaderDescriptor->hdr[0].name)); // Header's Name
memcpy(pHeaderDescriptor->hdr[0].hdr, (void*)&aHeadertoAdd[0],
hdrSize); //Header's Data
pHeaderDescriptor->hdr[0].hdr_len = hdrSize;
pHeaderDescriptor->hdr[0].hdr_hdl = -1; //Return Value
pHeaderDescriptor->hdr[0].is_partial = false;
pHeaderDescriptor->hdr[0].status = -1; // Return Parameter
// Adding Header No2.
strlcpy(pHeaderDescriptor->hdr[1].name, "StreamId1", sizeof(pHeaderDescriptor->hdr[1].name)); // Header's Name
memcpy(pHeaderDescriptor->hdr[1].hdr, (void*)&aHeadertoAdd[1],
hdrSize); //Header's Data
pHeaderDescriptor->hdr[1].hdr_len = hdrSize;
pHeaderDescriptor->hdr[1].hdr_hdl = -1; //Return Value
pHeaderDescriptor->hdr[1].is_partial = false;
pHeaderDescriptor->hdr[1].status = -1; // Return Parameter
for (int i = 0; i < 2; i++)
strlcpy(sGetHeader[i].name, pHeaderDescriptor->hdr[i].name, sizeof(sGetHeader[i].name));
if (!m_HeaderInsertion.AddHeader(pHeaderDescriptor))
{
LOG_MSG_ERROR("m_HeaderInsertion.AddHeader(pHeaderDescriptor) Failed.");
bRetVal = false;
goto bail;
}
for (int i = 0; i < 2; i++)
{
if (!m_HeaderInsertion.GetHeaderHandle(&sGetHeader[i]))
{
LOG_MSG_ERROR(" Failed");
bRetVal = false;
goto bail;
}
LOG_MSG_DEBUG("Received Header %d Handle = 0x%x", i, sGetHeader[i].hdl);
}
for (int i = 0; i < 2; i++)
{
if (!CreateBypassRoutingTable(&m_Routing, m_eIP, aBypass[i],
IPA_CLIENT_TEST2_CONS, sGetHeader[i].hdl,&nTableHdl[i]))
{
LOG_MSG_ERROR("CreateBypassRoutingTable Failed\n");
bRetVal = false;
goto bail;
}
}
LOG_MSG_INFO("Creation of 2 bypass routing tables completed successfully");
// Creating Filtering Rules
cFilterTable0.Init(m_eIP,IPA_CLIENT_TEST_PROD, false, 2);
LOG_MSG_INFO("Creation of filtering table completed successfully");
// Configuring Filtering Rule No.1
cFilterTable0.GeneratePresetRule(1,sFilterRuleEntry);
sFilterRuleEntry.at_rear = true;
sFilterRuleEntry.flt_rule_hdl=-1; // return Value
sFilterRuleEntry.status = -1; // return value
sFilterRuleEntry.rule.action=IPA_PASS_TO_ROUTING;
sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[0]; //put here the handle corresponding to Routing Rule 1
sFilterRuleEntry.rule.attrib.attrib_mask = IPA_FLT_DST_ADDR; // Destination IP Based Filtering
sFilterRuleEntry.rule.attrib.u.v4.dst_addr_mask = 0xFF0000FF; // Mask
sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0x7F000001; // Filter DST_IP == 127.0.0.1.
if (
((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
)
{
LOG_MSG_ERROR ("Adding Rule (0) to Filtering block Failed.");
bRetVal = false;
goto bail;
}
else
{
LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
cFilterTable0.ReadRuleFromTable(0)->flt_rule_hdl,
cFilterTable0.ReadRuleFromTable(0)->status);
}
// Configuring Filtering Rule No.2
sFilterRuleEntry.flt_rule_hdl=-1; // return Value
sFilterRuleEntry.status = -1; // return Value
sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[1]; //put here the handle corresponding to Routing Rule 2
sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80101; // Filter DST_IP == 192.168.1.1.
if (
((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
)
{
LOG_MSG_ERROR ("Adding Rule(1) to Filtering block Failed.");
bRetVal = false;
goto bail;
}
else
{
LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
cFilterTable0.ReadRuleFromTable(1)->flt_rule_hdl,
cFilterTable0.ReadRuleFromTable(1)->status);
}
bail:
Free(pHeaderDescriptor);
LOG_MSG_STACK(
"Leaving Function (Returning %s)", bRetVal?"True":"False");
return bRetVal;
} // AddRules()
/////////////////////////////////////////////////////////////////////////////////
bool TestLogic()
{
return MBIMAggregationScenarios::MBIMAggregationNoInterleavingStreamIdsTest(
&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP);
}
/////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/* Legacy MBIM tests */
static MBIMAggregationTest mbimAggregationTest(false);
static MBIMDeaggregationTest mbimDeaggregationTest(false);
static MBIMDeaggregationOnePacketTest mbimDeaggregationOnePacketTest(false);
static MBIMDeaggregationAndAggregationTest mbimDeaggregationAndAggregationTest(false);
static MBIMMultipleDeaggregationAndAggregationTest
mbimMultipleDeaggregationAndAggregationTest(false);
static MBIMAggregationLoopTest mbimAggregationLoopTest(false);
static MBIMDeaggregationMultipleNDPTest mbimDeaggregationMultipleNDPTest(false);
static MBIMAggregationMultiplePacketsTest mbimAggregationMultiplePacketsTest(false);
static MBIMAggregation2PipesTest mbimAggregation2PipesTest(false);
static MBIMAggregationNoInterleavingStreamIdsTest
mbimAggregationNoInterleavingStreamIdsTest(false);
static MBIMAggregationDifferentStreamIdsTest mbimAggregationDifferentStreamIdsTest(false);
static MBIMAggregationTimeLimitTest mbimAggregationTimeLimitTest(false);
static MBIMAggregationByteLimitTest mbimAggregationByteLimitTest(false);
static MBIMAggregationTimeLimitLoopTest mbimAggregationTimeLimitLoopTest(false);
static MBIMAggregation0LimitsTest mbimAggregation0LimitsTest(false);
/* Generic Aggregation MBIM tests */
static MBIMAggregationTest genMbimAggregationTest(true);
static MBIMDeaggregationTest genMbimDeaggregationTest(true);
static MBIMDeaggregationOnePacketTest genMbimDeaggregationOnePacketTest(true);
static MBIMDeaggregationAndAggregationTest genMbimDeaggregationAndAggregationTest(true);
static MBIMMultipleDeaggregationAndAggregationTest genMbimMultipleDeaggregationAndAggregationTest(true);
static MBIMAggregationLoopTest genMbimAggregationLoopTest(true);
static MBIMDeaggregationMultipleNDPTest genMbimDeaggregationMultipleNDPTest(true);
static MBIMAggregationMultiplePacketsTest genMbimAggregationMultiplePacketsTest(true);
static MBIMAggregation2PipesTest genMbimAggregation2PipesTest(true);
static MBIMAggregationNoInterleavingStreamIdsTest genMbimAggregationNoInterleavingStreamIdsTest(true);
static MBIMAggregationDifferentStreamIdsTest genMbimAggregationDifferentStreamIdsTest(true);
static MBIMAggregationTimeLimitTest genMbimAggregationTimeLimitTest(true);
static MBIMAggregationByteLimitTest genMbimAggregationByteLimitTest(true);
static MBIMAggregationByteLimitTestFC genMbimAggregationByteLimitTestFC(true);
static MBIMAggregationDualDpTestFC genMBIMAggregationDualDpTestFC(true);
static MBIMAggregationDualDpTestFcRoutingBased genMBIMAggregationDualDpTestFcRoutingBased(true);
static MBIMAggregationTimeLimitLoopTest genMbimAggregationTimeLimitLoopTest(true);
static MBIMAggregation0LimitsTest genMbimAggregation0LimitsTest(true);
/////////////////////////////////////////////////////////////////////////////////
// EOF ////
/////////////////////////////////////////////////////////////////////////////////