maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
eefb9da69a48ce8ca85e7647fea39bf8d8dcf5dc
openairinterface5g/nfapi/open-nFAPI/pnf/tests/pnf_cunit_main.c
T
Robert Schmidt eefb9da69a Reimplement nFAPI message exchange after msgDataTx removal 
Reimplement nFAPI message exchange between L1 and L2 following the
changes in parent commit removing msgDataTx.

Avoid direct calls and use NR_IF_module fptrs to avoid linking problems.
allowing to remove some function definitions that are not needed.
2025-11-14 18:16:02 +01:00

2369 lines
68 KiB
C
Raw Blame History

/*
* Copyright 2017 Cisco Systems, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "CUnit.h"
#include "Basic.h"
#include "Automated.h"
//#include "CUnit/Console.h"
#include "nfapi_interface.h"
#include "nfapi_pnf_interface.h"
#include "nfapi.h"
#include <stdio.h> // for printf
#include <stdlib.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/sctp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include "debug.h"
/* Test Suite setup and cleanup functions: */
int init_suite(void) { return 0; }
int clean_suite(void) { return 0; }
#define MAX_PACKED_MESSAGE_SIZE 8192
typedef struct phy_info
{
uint8_t enabled;
uint16_t phy_id;
uint16_t sfn_sf;
uint16_t sfn;
uint16_t slot;
pthread_t thread;
int pnf_p7_port;
char* pnf_p7_addr;
int vnf_p7_port;
char* vnf_p7_addr;
nfapi_pnf_p7_config_t* config;
} phy_info_t;
typedef struct pnf_info
{
uint8_t num_phys;
phy_info_t phys[8];
} pnf_info_t;
phy_info_t* find_phy_info(pnf_info_t* pnf, uint16_t phy_id)
{
int i = 0;
for(i = 0; i < 8; ++i)
{
if(pnf->phys[i].enabled == 1 && pnf->phys[i].phy_id == phy_id)
{
return &(pnf->phys[i]);
}
}
return 0;
}
/************* Test case functions ****************/
void pnf_test_start_no_config(void)
{
int result = nfapi_pnf_start(0);
CU_ASSERT_EQUAL(result, -1);
}
void test_trace(nfapi_trace_level_t level, const char* message, ...)
{
printf("%s", message);
}
void* pnf_test_start_thread(void* ptr)
{
int result = nfapi_pnf_start((nfapi_pnf_config_t*)ptr);
return (void*)(intptr_t)result;
}
void* pnf_test_start_p7_thread(void* ptr)
{
int result = nfapi_pnf_p7_start((nfapi_pnf_p7_config_t*)ptr);
return (void*)(intptr_t)result;
}
void pnf_test_start_no_connection(void)
{
char* vnf_addr = "127.127.0.1";
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
sleep(1);
nfapi_pnf_stop(config);
int* result;
pthread_join(thread, (void**)&result);
CU_ASSERT_EQUAL(result, 0);
}
void pnf_test_start_no_ip(void)
{
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
sleep(2);
nfapi_pnf_stop(config);
intptr_t result;
pthread_join(thread, (void**)&result);
CU_ASSERT_EQUAL((int)result, -1);
}
void pnf_test_start_invalid_ip(void)
{
char* vnf_addr = "not.an.ip.address";
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
sleep(2);
nfapi_pnf_stop(config);
intptr_t result;
pthread_join(thread, (void**)&result);
CU_ASSERT_EQUAL((int)result, -1);
}
int create_p5_listen_socket(char* ip, int port)
{
int p5ListenSock = socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = INADDR_ANY;
// bind to the configured address and port
bind(p5ListenSock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
return p5ListenSock;
}
int create_p5_ipv6_listen_socket(char* ip, int port)
{
struct addrinfo hints, *servinfo;
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_STREAM; // For SCTP we are only interested in SOCK_STREAM
hints.ai_family= AF_INET6;
char port_str[8];
snprintf(port_str, sizeof(port_str), "%d", port);
getaddrinfo(ip, port_str, &hints, &servinfo);
int p5ListenSock = socket(AF_INET6, SOCK_STREAM, IPPROTO_SCTP);
//printf("Socket result %d\n", p5ListenSock);
// bind to the configured address and port
/*int bind_result = */
bind(p5ListenSock, servinfo->ai_addr, servinfo->ai_addrlen);
//printf("Bind result %d (errno:%d)\n", bind_result, errno);
freeaddrinfo(servinfo);
return p5ListenSock;
}
/*
int wait_for_pnf_connection(int p5ListenSock)
{
listen(p5ListenSock, 2);
socklen_t addrSize;
int p5Sock = accept(p5ListenSock, (struct sockaddr *)&addr, &addrSize);
return p5Sock;
}
*/
int test_param_request_called = 0;
int test_pnf_param_request(nfapi_pnf_config_t* config, nfapi_pnf_param_request_t* req)
{
printf("test_pnf_param_request called.... ;-)\n");
nfapi_pnf_param_response_t resp;
memset(&resp, 0, sizeof(resp));
resp.header.message_id = NFAPI_PNF_PARAM_RESPONSE;
resp.pnf_param_general.tl.tag = NFAPI_PNF_PARAM_GENERAL_TAG;
resp.pnf_param_general.nfapi_sync_mode = 2;
resp.pnf_param_general.location_mode = 1;
resp.pnf_param_general.location_coordinates[0] = 123;
resp.pnf_param_general.dl_config_timing = 12;
resp.pnf_param_general.tx_timing = 12;
resp.pnf_param_general.ul_config_timing = 12;
resp.pnf_param_general.hi_dci0_timing = 12;
resp.pnf_param_general.maximum_number_phys = 2;
resp.pnf_param_general.maximum_total_bandwidth = 100;
resp.pnf_param_general.maximum_total_number_dl_layers = 2;
resp.pnf_param_general.maximum_total_number_ul_layers = 2;
resp.pnf_param_general.shared_bands = 0;
resp.pnf_param_general.shared_pa = 0;
resp.pnf_param_general.maximum_total_power = -190;
resp.pnf_param_general.oui[0] = 88;
/*
in.pnf_phy.tl.tag = NFAPI_PNF_PHY_TAG;
in.pnf_phy.number_of_phys = 2;
in.pnf_phy.phy[0].phy_config_index = 0;
in.pnf_phy.phy[0].number_of_rfs = 2;
in.pnf_phy.phy[0].rf_config[0].rf_config_index = 0;
in.pnf_phy.phy[0].number_of_rf_exclusions = 1;
in.pnf_phy.phy[0].rf_config[0].rf_config_index = 1;
in.pnf_phy.phy[0].downlink_channel_bandwidth_supported = 20;
in.pnf_phy.phy[0].uplink_channel_bandwidth_supported = 20;
in.pnf_phy.phy[0].number_of_dl_layers_supported = 2;
in.pnf_phy.phy[0].number_of_ul_layers_supported = 1;
in.pnf_phy.phy[0].maximum_3gpp_release_supported = 3;
in.pnf_phy.phy[0].nmm_modes_supported = 2;
in.pnf_rf.tl.tag = NFAPI_PNF_RF_TAG;
in.pnf_rf.number_of_rfs = 2;
in.pnf_rf.rf[0].rf_config_index = 0;
in.pnf_rf.rf[0].band = 1;
in.pnf_rf.rf[0].maximum_transmit_power = -100;
in.pnf_rf.rf[0].minimum_transmit_power = -90;
in.pnf_rf.rf[0].number_of_antennas_suppported = 4;
in.pnf_rf.rf[0].minimum_downlink_frequency = 100;
in.pnf_rf.rf[0].maximum_downlink_frequency = 2132;
in.pnf_rf.rf[0].minimum_uplink_frequency = 1231;
in.pnf_rf.rf[0].maximum_uplink_frequency = 123;
in.pnf_phy_rel10.tl.tag = NFAPI_PNF_PHY_REL10_TAG;
in.pnf_phy_rel10.number_of_phys = 2;
in.pnf_phy_rel10.phy[0].phy_config_index = 0;
in.pnf_phy_rel10.phy[0].transmission_mode_7_supported = 1;
in.pnf_phy_rel10.phy[0].transmission_mode_8_supported = 2;
in.pnf_phy_rel10.phy[0].two_antenna_ports_for_pucch = 3;
in.pnf_phy_rel10.phy[0].transmission_mode_9_supported = 4;
in.pnf_phy_rel10.phy[0].simultaneous_pucch_pusch = 5;
in.pnf_phy_rel10.phy[0].four_layer_tx_with_tm3_and_tm4 = 6;
in.pnf_phy_rel11.tl.tag = NFAPI_PNF_PHY_REL11_TAG;
in.pnf_phy_rel11.number_of_phys = 2;
in.pnf_phy_rel11.phy[0].phy_config_index = 0;
in.pnf_phy_rel11.phy[0].edpcch_supported = 1;
in.pnf_phy_rel11.phy[0].multi_ack_csi_reporting = 2;
in.pnf_phy_rel11.phy[0].pucch_tx_diversity = 3;
in.pnf_phy_rel11.phy[0].ul_comp_supported = 4;
in.pnf_phy_rel11.phy[0].transmission_mode_5_supported = 5;
in.pnf_phy_rel12.tl.tag = NFAPI_PNF_PHY_REL12_TAG;
in.pnf_phy_rel12.number_of_phys = 2;
in.pnf_phy_rel12.phy[0].phy_config_index = 0;
in.pnf_phy_rel12.phy[0].csi_subframe_set = 1;
in.pnf_phy_rel12.phy[0].enhanced_4tx_codebook = 2;
in.pnf_phy_rel12.phy[0].drs_supported = 3;
in.pnf_phy_rel12.phy[0].ul_64qam_supported = 4;
in.pnf_phy_rel12.phy[0].transmission_mode_10_supported = 5;
in.pnf_phy_rel12.phy[0].alternative_bts_indices = 6;
in.pnf_phy_rel13.tl.tag = NFAPI_PNF_PHY_REL13_TAG;
in.pnf_phy_rel13.number_of_phys = 2;
in.pnf_phy_rel13.phy[0].phy_config_index = 0;
in.pnf_phy_rel13.phy[0].pucch_format4_supported = 1;
in.pnf_phy_rel13.phy[0].pucch_format5_supported = 2;
in.pnf_phy_rel13.phy[0].more_than_5_ca_support = 3;
in.pnf_phy_rel13.phy[0].laa_supported = 4;
in.pnf_phy_rel13.phy[0].laa_ending_in_dwpts_supported = 5;
in.pnf_phy_rel13.phy[0].laa_starting_in_second_slot_supported = 6;
in.pnf_phy_rel13.phy[0].beamforming_supported = 7;
in.pnf_phy_rel13.phy[0].csi_rs_enhancement_supported = 8;
in.pnf_phy_rel13.phy[0].drms_enhancement_supported = 9;
in.pnf_phy_rel13.phy[0].srs_enhancement_supported = 10;
*/
test_param_request_called++;
nfapi_pnf_pnf_param_resp(config, &resp);
return 0;
}
int test_config_request_called = 0;
int test_pnf_config_request(nfapi_pnf_config_t* config, nfapi_pnf_config_request_t* req)
{
printf("test_pnf_config_request called.... ;-)\n");
CU_ASSERT_EQUAL(req->pnf_phy_rf_config.tl.tag, NFAPI_PNF_PHY_RF_TAG);
if(config->user_data != 0)
{
pnf_info_t* pnf = (pnf_info_t*)(config->user_data);
int i = 0;
for(i = 0; i < req->pnf_phy_rf_config.number_phy_rf_config_info; ++i)
{
pnf->phys[i].enabled = 1;
pnf->phys[i].phy_id = req->pnf_phy_rf_config.phy_rf_config[i].phy_id;
printf("test_pnf_config_request creating phy %d\n", pnf->phys[i].phy_id);
}
}
nfapi_pnf_config_response_t resp;
memset(&resp, 0, sizeof(resp));
resp.header.message_id = NFAPI_PNF_CONFIG_RESPONSE;
resp.error_code = NFAPI_MSG_OK;
nfapi_pnf_pnf_config_resp(config, &resp);
test_config_request_called++;
return 0;
}
int test_pnf_start_request(nfapi_pnf_config_t* config, nfapi_pnf_start_request_t* req)
{
printf("test_pnf_start_request called.... ;-)\n");
nfapi_pnf_start_response_t resp;
memset(&resp, 0, sizeof(resp));
resp.header.message_id = NFAPI_PNF_START_RESPONSE;
resp.error_code = NFAPI_MSG_OK;
nfapi_pnf_pnf_start_resp(config, &resp);
return 0;
}
int test_pnf_stop_request(nfapi_pnf_config_t* config, nfapi_pnf_stop_request_t* req)
{
printf("test_pnf_stop_request called.... ;-)\n");
nfapi_pnf_stop_response_t resp;
memset(&resp, 0, sizeof(resp));
resp.header.message_id = NFAPI_PNF_STOP_RESPONSE;
resp.error_code = NFAPI_MSG_OK;
nfapi_pnf_pnf_stop_resp(config, &resp);
return 0;
}
int test_param_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_param_request_t* req)
{
printf("test_param_request called.... ;-)\n");
nfapi_param_response_t resp;
memset(&resp, 0, sizeof(resp));
resp.header.message_id = NFAPI_PARAM_RESPONSE;
resp.header.phy_id = req->header.phy_id;
resp.error_code = NFAPI_MSG_OK;
if(config->user_data != 0)
{
phy_info_t* phy_info = find_phy_info((pnf_info_t*)(config->user_data), req->header.phy_id);
resp.nfapi_config.p7_pnf_port.tl.tag = NFAPI_NFAPI_P7_PNF_PORT_TAG;
resp.nfapi_config.p7_pnf_port.value = phy_info->pnf_p7_port;
resp.num_tlv++;
resp.nfapi_config.p7_pnf_address_ipv4.tl.tag = NFAPI_NFAPI_P7_PNF_PORT_TAG;
struct sockaddr_in pnf_p7_sockaddr;
pnf_p7_sockaddr.sin_addr.s_addr = inet_addr(phy_info->pnf_p7_addr);
memcpy(&(resp.nfapi_config.p7_pnf_address_ipv4.address[0]), &pnf_p7_sockaddr.sin_addr.s_addr, 4);
resp.num_tlv++;
}
nfapi_pnf_param_resp(config, &resp);
return 0;
}
int test_config_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_config_request_t* req)
{
printf("test_config_request called.... ;-)\n");
if(config->user_data != 0)
{
phy_info_t* phy_info = find_phy_info((pnf_info_t*)(config->user_data), req->header.phy_id);
if(req->nfapi_config.p7_vnf_port.tl.tag == NFAPI_NFAPI_P7_VNF_PORT_TAG)
{
phy_info->vnf_p7_port = req->nfapi_config.p7_vnf_port.value;
printf("vnf_p7_port %d\n", phy_info->vnf_p7_port);
}
if(req->nfapi_config.p7_vnf_address_ipv4.tl.tag == NFAPI_NFAPI_P7_VNF_ADDRESS_IPV4_TAG)
{
struct sockaddr_in addr;
memcpy(&addr.sin_addr.s_addr, req->nfapi_config.p7_vnf_address_ipv4.address, 4);
char* ip = inet_ntoa(addr.sin_addr);
phy_info->vnf_p7_addr = ip;
printf("vnf_p7_addr %s\n", phy_info->vnf_p7_addr);
}
}
nfapi_config_response_t resp;
memset(&resp, 0, sizeof(resp));
resp.header.message_id = NFAPI_CONFIG_RESPONSE;
resp.header.phy_id = req->header.phy_id;
resp.error_code = NFAPI_MSG_OK;
nfapi_pnf_config_resp(config, &resp);
return 0;
}
int test_dl_config_req(nfapi_pnf_p7_config_t* config, nfapi_dl_config_request_t* req)
{
printf("test_dl_config_req called.... ;-)\n");
return 0;
}
int test_ul_config_req(nfapi_pnf_p7_config_t* config, nfapi_ul_config_request_t* req)
{
printf("test_ul_config_req called.... ;-)\n");
return 0;
}
int test_hi_dci0_req(nfapi_pnf_p7_config_t* config, nfapi_hi_dci0_request_t* req)
{
printf("test_hi_dci0_req called.... ;-)\n");
return 0;
}
int test_tx_req(nfapi_pnf_p7_config_t* config, nfapi_tx_request_t* req)
{
printf("test_tx_req called.... ;-)\n");
return 0;
}
int test_lbt_dl_config_req(nfapi_pnf_p7_config_t* config, nfapi_lbt_dl_config_request_t* req)
{
printf("test_lbt_dl_req called.... ;-)\n");
return 0;
}
int test_start_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_start_request_t* req)
{
printf("test_start_request called.... ;-)\n");
if(config->user_data != 0)
{
phy_info_t* phy_info = find_phy_info((pnf_info_t*)(config->user_data), req->header.phy_id);
phy_info->config = nfapi_pnf_p7_config_create();
phy_info->config->local_p7_port = phy_info->pnf_p7_port;
phy_info->config->remote_p7_port = phy_info->vnf_p7_port;
phy_info->config->remote_p7_addr = phy_info->vnf_p7_addr;
phy_info->config->dl_config_req = &test_dl_config_req;
phy_info->config->ul_config_req = &test_ul_config_req;
phy_info->config->hi_dci0_req = &test_hi_dci0_req;
phy_info->config->tx_req = &test_tx_req;
phy_info->config->lbt_dl_config_req = &test_lbt_dl_config_req;
//phy_info->config->subframe_buffer_size = 8;
//phy_info->config->timing_info_mode_periodic = 1;
//phy_info->config->timing_info_period = 32;
//phy_info->config->timing_info_mode_aperiodic = 1;
phy_info->config->segment_size = 1400;
phy_info->config->checksum_enabled = 0;
pthread_create(&phy_info->thread, NULL, &pnf_test_start_p7_thread, phy_info->config);
}
nfapi_start_response_t resp;
memset(&resp, 0, sizeof(resp));
resp.header.message_id = NFAPI_START_RESPONSE;
resp.header.phy_id = req->header.phy_id;
resp.error_code = NFAPI_MSG_OK;
nfapi_pnf_start_resp(config, &resp);
return 0;
}
int test_stop_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_stop_request_t* req)
{
printf("test_stop_request called.... ;-)\n");
nfapi_stop_response_t resp;
memset(&resp, 0, sizeof(resp));
resp.header.message_id = NFAPI_STOP_RESPONSE;
resp.header.phy_id = req->header.phy_id;
resp.error_code = NFAPI_MSG_OK;
nfapi_pnf_stop_resp(config, &resp);
return 0;
}
int send_p5_message(int p5Sock, nfapi_p4_p5_message_header_t* msg, unsigned msg_size, struct sockaddr* addr, socklen_t addr_size)
{
char buffer[256];
int encoded_size = nfapi_p5_message_pack(msg, msg_size, buffer, sizeof(buffer), 0);
int result = sendto(p5Sock, buffer, encoded_size, 0, addr, addr_size);
return result;
}
int send_p7_message(int p7Sock, nfapi_p7_message_header_t* msg, unsigned msg_size, struct sockaddr_in* addr, socklen_t addr_size)
{
char buffer[256];
int encoded_size = nfapi_p7_message_pack(msg, buffer, sizeof(buffer), 0);
int result = sendto(p7Sock, buffer, encoded_size, 0, (struct sockaddr*)addr, addr_size);
printf("send_p7_message result %d\n", result);
return result;
}
int send_p7_segmented_message(int p7Sock, nfapi_p7_message_header_t* msg, unsigned msg_size, struct sockaddr_in* addr, socklen_t addr_size)
{
char buffer[1024 * 10];
int encoded_size = nfapi_p7_message_pack(msg, buffer, sizeof(buffer), 0);
uint16_t segment_size = 256;
if(encoded_size < segment_size)
{
int result = sendto(p7Sock, buffer, encoded_size, 0, (struct sockaddr*)addr, addr_size);
return result;
}
else
{
// printf("Segmenting p7 message %d\n", encoded_size);
uint8_t segment_count = 0;
uint8_t buffer2[segment_size];
uint32_t offset = 0;
uint16_t msg_size;
//uint8_t m = 1;
do{
if(segment_count == 0)
{
msg_size = segment_size;
memcpy(&buffer2[0], &buffer[0], msg_size);
// M = 1
buffer2[6] = (1 << 7) | (segment_count & 0x7F);
offset = msg_size;
}
else
{
memcpy(&buffer2[0], &buffer[0], NFAPI_P7_HEADER_LENGTH);
if(encoded_size - offset > segment_size)
{
// M = 1
buffer2[6] = (1 << 7) | (segment_count & 0x7F);
msg_size = segment_size;
}
else
{
// M = 0
buffer2[6] = (0 << 7) | (segment_count & 0x7F);
msg_size = encoded_size - offset + NFAPI_P7_HEADER_LENGTH;
}
memcpy(&buffer2[NFAPI_P7_HEADER_LENGTH], &buffer[offset], msg_size - NFAPI_P7_HEADER_LENGTH);
offset += msg_size - NFAPI_P7_HEADER_LENGTH;
}
uint8_t* p = &buffer2[4];
push16(msg_size, &p, &buffer2[segment_size]);
//printf("Segmenting p7 message %d %di %d\n", segment_count, msg_size, offset);
/*int result = */sendto(p7Sock, buffer2, msg_size, 0, (struct sockaddr*)addr, addr_size);
segment_count++;
}while(offset < encoded_size);
}
return 0;
}
int send_p7_segmented_message_outoforder(int p7Sock, nfapi_p7_message_header_t* msg, unsigned msg_size, struct sockaddr_in* addr, socklen_t addr_size)
{
char buffer[1024 * 10];
int encoded_size = nfapi_p7_message_pack(msg, buffer, sizeof(buffer), 0);
uint16_t segment_size = 256;
if(encoded_size < segment_size)
{
int result = sendto(p7Sock, buffer, encoded_size, 0, (struct sockaddr*)addr, addr_size);
return result;
}
else
{
// printf("Segmenting p7 message %d\n", encoded_size);
uint8_t segment_count = 0;
uint8_t buffer2[128][segment_size];
uint32_t offset = 0;
uint16_t msg_size[128];
uint8_t i = 0;
do{
if(segment_count == 0)
{
msg_size[i] = segment_size;
memcpy(&buffer2[i][0], &buffer[0], msg_size[i]);
// M = 1
buffer2[i][6] = (1 << 7) | (segment_count & 0x7F);
offset = msg_size[i];
}
else
{
memcpy(&buffer2[i][0], &buffer[0], NFAPI_P7_HEADER_LENGTH);
if(encoded_size - offset > segment_size)
{
// M = 1
buffer2[i][6] = (1 << 7) | (segment_count & 0x7F);
msg_size[i] = segment_size;
}
else
{
// M = 0
buffer2[i][6] = (0 << 7) | (segment_count & 0x7F);
msg_size[i] = encoded_size - offset + NFAPI_P7_HEADER_LENGTH;
}
memcpy(&buffer2[i][NFAPI_P7_HEADER_LENGTH], &buffer[offset], msg_size[i] - NFAPI_P7_HEADER_LENGTH);
offset += msg_size[i] - NFAPI_P7_HEADER_LENGTH;
}
uint8_t* p = &buffer2[i][4];
push16(msg_size[i], &p, &buffer2[i][segment_size]);
segment_count++;
i++;
}while(offset < encoded_size);
// send all odd then send event
uint8_t e = 0;
uint8_t o = 1;
while(o <= i)
{
sendto(p7Sock, &buffer2[o][0], msg_size[o], 0, (struct sockaddr*)addr, addr_size);
o += 2;
}
while(e <= i)
{
sendto(p7Sock, &buffer2[e][0], msg_size[e], 0, (struct sockaddr*)addr, addr_size);
e += 2;
}
}
return 0;
}
int get_p7_segmented_message(int p7Sock, nfapi_p7_message_header_t* msg, unsigned _msg_size, struct sockaddr_in* addr, socklen_t addr_size, uint8_t (buffer2)[][256], uint16_t msg_size[256], uint8_t i)
{
char buffer[1024 * 10];
int encoded_size = nfapi_p7_message_pack(msg, buffer, sizeof(buffer), 0);
uint16_t segment_size = 256;
printf("get_p7_segmented_message size %d\n", encoded_size);
if(encoded_size < segment_size)
{
msg_size[i] = encoded_size;
memcpy(&buffer2[i][0], &buffer[0], msg_size[i]);
i++;
}
else
{
uint8_t segment_count = 0;
uint32_t offset = 0;
do{
if(segment_count == 0)
{
msg_size[i] = segment_size;
memcpy(&buffer2[i][0], &buffer[0], msg_size[i]);
// M = 1
(buffer2[i][6]) = (1 << 7) | (segment_count & 0x7F);
offset = msg_size[i];
}
else
{
memcpy(&buffer2[i][0], &buffer[0], NFAPI_P7_HEADER_LENGTH);
if(encoded_size - offset > segment_size)
{
// M = 1
(buffer2[i][6]) = (1 << 7) | (segment_count & 0x7F);
msg_size[i] = segment_size;
}
else
{
// M = 0
(buffer2[i][6]) = (0 << 7) | (segment_count & 0x7F);
msg_size[i] = encoded_size - offset + NFAPI_P7_HEADER_LENGTH;
}
memcpy(&buffer2[i][NFAPI_P7_HEADER_LENGTH], &buffer[offset], msg_size[i] - NFAPI_P7_HEADER_LENGTH);
offset += msg_size[i] - NFAPI_P7_HEADER_LENGTH;
}
uint8_t* p = &buffer2[i][4];
push16(msg_size[i], &p, &buffer2[i][segment_size]);
segment_count++;
i++;
}while(offset < encoded_size);
}
return i;
}
int recv_p5_message(int p5Sock, nfapi_p4_p5_message_header_t* msg, unsigned msg_size)
{
//struct sockaddr_in addr2;
//socklen_t addr2len;
char buffer2[1024];
int result2 = recv(p5Sock, buffer2, sizeof(buffer2), 0); //, (struct sockaddr*)&addr2, &addr2len);
if(result2 == -1)
{
printf("%s recvfrom failed errno:%d\n", __FUNCTION__, errno);
}
else
{
/*int unpack_result =*/ nfapi_p5_message_unpack(buffer2, result2, msg, msg_size, 0); //, sizeof(resp));
}
return 0;
}
int recv_p7_message(int p7Sock, nfapi_p7_message_header_t* msg, unsigned msg_size)
{
char buffer2[2560];
int result2 = recvfrom(p7Sock, buffer2, sizeof(buffer2), 0, 0, 0);
if(result2 == -1)
{
printf("%s recvfrom failed errno:%d\n", __FUNCTION__, errno);
}
else
{
/*int unpack_result =*/ nfapi_p7_message_unpack(buffer2, result2, msg, msg_size, 0); //, sizeof(resp));
}
return 0;
}
int send_pnf_param_request(int p5Sock, struct sockaddr* addr, socklen_t addr_size)
{
printf("%s\n", __FUNCTION__);
nfapi_pnf_param_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_PNF_PARAM_REQUEST;
req.header.message_length = 0;
send_p5_message(p5Sock, &(req.header), sizeof(req), addr, addr_size);
return 0;
}
int receive_pnf_param_response(int p5Sock, uint8_t error_code)
{
nfapi_pnf_param_response_t resp;
recv_p5_message(p5Sock, &(resp.header), sizeof(resp));
printf("0x%x\n", resp.header.message_id);
CU_ASSERT_EQUAL(resp.header.message_id, NFAPI_PNF_PARAM_RESPONSE);
if(resp.header.message_id == NFAPI_PNF_PARAM_RESPONSE)
{
printf("decoded nfapi_pnf_param_response\n");
CU_ASSERT_EQUAL(resp.error_code, error_code);
if(error_code == NFAPI_MSG_OK)
{
CU_ASSERT_EQUAL(resp.pnf_param_general.tl.tag, NFAPI_PNF_PARAM_GENERAL_TAG);
CU_ASSERT_EQUAL(resp.pnf_param_general.nfapi_sync_mode, 2);
CU_ASSERT_EQUAL(resp.pnf_param_general.location_mode, 1);
}
}
return 0;
}
int send_pnf_config_request(int p5Sock, struct sockaddr* addr, socklen_t addr_size)
{
nfapi_pnf_config_request_t req;
req.header.message_id = NFAPI_PNF_CONFIG_REQUEST;
req.header.message_length = 0;
req.pnf_phy_rf_config.tl.tag = NFAPI_PNF_PHY_RF_TAG;
req.pnf_phy_rf_config.number_phy_rf_config_info = 1;
req.pnf_phy_rf_config.phy_rf_config[0].phy_id = 0;
send_p5_message(p5Sock, &(req.header), sizeof(req), addr, addr_size);
return 0;
}
int receive_pnf_config_response(int p5Sock)
{
nfapi_pnf_config_response_t resp;
recv_p5_message(p5Sock, &(resp.header), sizeof(resp));
CU_ASSERT_EQUAL(resp.header.message_id, NFAPI_PNF_CONFIG_RESPONSE);
if(resp.header.message_id == NFAPI_PNF_CONFIG_RESPONSE)
{
printf("decoded nfapi_pnf_config_response\n");
}
return 0;
}
void send_pnf_start_request(int p5Sock, struct sockaddr* addr, socklen_t addr_size)
{
nfapi_pnf_start_request_t req;
req.header.message_id = NFAPI_PNF_START_REQUEST;
req.header.message_length = 0;
send_p5_message(p5Sock, &(req.header), sizeof(req), addr, addr_size);
}
void receive_pnf_start_response(int p5Sock)
{
nfapi_pnf_start_response_t resp;
recv_p5_message(p5Sock, &(resp.header), sizeof(resp));
CU_ASSERT_EQUAL(resp.header.message_id, NFAPI_PNF_START_RESPONSE);
if(resp.header.message_id == NFAPI_PNF_START_RESPONSE)
{
printf("decoded nfapi_pnf_start_response\n");
}
}
void send_pnf_stop_request(int p5Sock, struct sockaddr* addr, socklen_t addr_size)
{
nfapi_pnf_stop_request_t req;
req.header.message_id = NFAPI_PNF_STOP_REQUEST;
req.header.message_length = 0;
send_p5_message(p5Sock, &(req.header), sizeof(req), addr, addr_size);
}
void receive_pnf_stop_response(int p5Sock)
{
nfapi_pnf_stop_response_t resp;
recv_p5_message(p5Sock, &(resp.header), sizeof(resp));
CU_ASSERT_EQUAL(resp.header.message_id, NFAPI_PNF_STOP_RESPONSE);
if(resp.header.message_id == NFAPI_PNF_STOP_RESPONSE)
{
printf("decoded nfapi_pnf_stop_response\n");
}
}
void send_param_request(int p5Sock, int phy_id, struct sockaddr* addr, socklen_t addr_size)
{
nfapi_param_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_PARAM_REQUEST;
req.header.phy_id = phy_id;
send_p5_message(p5Sock, &(req.header), sizeof(req), addr, addr_size);
}
void receive_param_response(int p5Sock)
{
nfapi_pnf_stop_response_t resp;
recv_p5_message(p5Sock, &(resp.header), sizeof(resp));
CU_ASSERT_EQUAL(resp.header.message_id, NFAPI_PARAM_RESPONSE);
if(resp.header.message_id == NFAPI_PARAM_RESPONSE)
{
printf("decoded nfapi_param_response\n");
}
}
void send_config_request(int p5Sock, int phy_id, struct sockaddr* addr, socklen_t addr_size, pnf_info_t* pnf_info)
{
nfapi_config_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_CONFIG_REQUEST;
req.header.phy_id = phy_id;
phy_info_t* phy_info = find_phy_info(pnf_info, phy_id);
req.nfapi_config.p7_vnf_port.tl.tag = NFAPI_NFAPI_P7_VNF_PORT_TAG;
req.nfapi_config.p7_vnf_port.value = phy_info->vnf_p7_port;
req.num_tlv++;
//req.nfapi_config.p7_vnf_address_ipv4.tl.tag = NFAPI_NFAPI_P7_VNF_ADDRESS_IPV4_TAG;
//req.num_tlv++;
send_p5_message(p5Sock, &(req.header), sizeof(req), addr, addr_size);
}
void receive_config_response(int p5Sock)
{
nfapi_pnf_stop_response_t resp;
recv_p5_message(p5Sock, &(resp.header), sizeof(resp));
CU_ASSERT_EQUAL(resp.header.message_id, NFAPI_CONFIG_RESPONSE);
if(resp.header.message_id == NFAPI_CONFIG_RESPONSE)
{
printf("decoded nfapi_config_response\n");
}
}
void send_start_request(int p5Sock, int phy_id, struct sockaddr* addr, socklen_t addr_size)
{
nfapi_start_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_START_REQUEST;
req.header.phy_id = phy_id;
send_p5_message(p5Sock, &(req.header), sizeof(req), addr, addr_size);
}
void receive_start_response(int p5Sock)
{
nfapi_pnf_start_response_t resp;
recv_p5_message(p5Sock, &(resp.header), sizeof(resp));
CU_ASSERT_EQUAL(resp.header.message_id, NFAPI_START_RESPONSE);
if(resp.header.message_id == NFAPI_START_RESPONSE)
{
printf("decoded nfapi_start_response\n");
}
}
void send_stop_request(int p5Sock, int phy_id, struct sockaddr* addr, socklen_t addr_size)
{
nfapi_start_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_STOP_REQUEST;
req.header.phy_id = phy_id;
send_p5_message(p5Sock, &(req.header), sizeof(req), addr, addr_size);
}
void receive_stop_response(int p5Sock)
{
nfapi_pnf_stop_response_t resp;
recv_p5_message(p5Sock, &(resp.header), sizeof(resp));
CU_ASSERT_EQUAL(resp.header.message_id, NFAPI_STOP_RESPONSE);
if(resp.header.message_id == NFAPI_STOP_RESPONSE)
{
printf("decoded nfapi_stop_response\n");
}
}
void send_dl_node_sync(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_dl_node_sync_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_DL_NODE_SYNC;
req.header.phy_id = phy_id;
req.t1 = 1977;
req.delta_sfn_sf = 5000;
send_p7_message(p7Sock, &(req.header), sizeof(req), addr, addr_size);
}
void receive_ul_node_sync(int p7Sock)
{
nfapi_ul_node_sync_t sync;
recv_p7_message(p7Sock, &(sync.header), sizeof(sync));
CU_ASSERT_EQUAL(sync.header.message_id, NFAPI_UL_NODE_SYNC);
if(sync.header.message_id == NFAPI_UL_NODE_SYNC)
{
printf("decoded nfapi_ul_node_sync t1:%d t2:%d t3:%d\n",
sync.t1, sync.t2, sync.t3);
}
}
void receive_timing_info(int p7Sock)
{
nfapi_timing_info_t timing_info;
recv_p7_message(p7Sock, &(timing_info.header), sizeof(timing_info));
CU_ASSERT_EQUAL(timing_info.header.message_id, NFAPI_TIMING_INFO);
if(timing_info.header.message_id == NFAPI_TIMING_INFO)
{
printf("decoded nfapi_timing_info\n");
}
else
{
printf("decoded ?? 0x%x\n", timing_info.header.message_id);
}
}
void send_dl_config_req(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size, uint16_t sfn_sf)
{
nfapi_dl_config_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_DL_CONFIG_REQUEST;
req.header.phy_id = phy_id;
req.sfn_sf = sfn_sf;
send_p7_message(p7Sock, &(req.header), sizeof(req), addr, addr_size);
}
void send_ul_config_req(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size, uint16_t sfn_sf)
{
nfapi_ul_config_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_UL_CONFIG_REQUEST;
req.header.phy_id = phy_id;
req.sfn_sf = sfn_sf;
send_p7_message(p7Sock, &(req.header), sizeof(req), addr, addr_size);
}
void send_hi_dci0_req(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size, uint16_t sfn_sf)
{
nfapi_hi_dci0_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_HI_DCI0_REQUEST;
req.header.phy_id = phy_id;
req.sfn_sf = sfn_sf;
send_p7_message(p7Sock, &(req.header), sizeof(req), addr, addr_size);
}
void send_tx_req(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size, uint16_t sfn_sf)
{
nfapi_tx_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_TX_REQUEST;
req.header.phy_id = phy_id;
req.sfn_sf = sfn_sf;
send_p7_message(p7Sock, &(req.header), sizeof(req), addr, addr_size);
}
void send_tx_req_1(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size, uint16_t sfn_sf)
{
nfapi_tx_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_TX_REQUEST;
req.header.phy_id = phy_id;
req.sfn_sf = sfn_sf;
req.tx_request_body.tl.tag = NFAPI_TX_REQUEST_BODY_TAG;
req.tx_request_body.number_of_pdus = 8;
req.tx_request_body.tx_pdu_list = (nfapi_tx_request_pdu_t*)(malloc(sizeof(nfapi_tx_request_t) * 8));
uint8_t i = 0;
uint8_t test_pdu[1200];
for(i = 0; i < 8; i++)
{
req.tx_request_body.tx_pdu_list[i].pdu_length = sizeof(test_pdu);
req.tx_request_body.tx_pdu_list[i].pdu_index = i;
req.tx_request_body.tx_pdu_list[i].num_segments =1;
req.tx_request_body.tx_pdu_list[i].segments[0].segment_length = sizeof(test_pdu);
req.tx_request_body.tx_pdu_list[i].segments[0].segment_data = (void*)&test_pdu;
}
send_p7_segmented_message(p7Sock, &(req.header), sizeof(req), addr, addr_size);
free(req.tx_request_body.tx_pdu_list);
}
void send_tx_req_2(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size, uint16_t sfn_sf)
{
nfapi_tx_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_TX_REQUEST;
req.header.phy_id = phy_id;
req.sfn_sf = sfn_sf;
req.tx_request_body.tl.tag = NFAPI_TX_REQUEST_BODY_TAG;
req.tx_request_body.number_of_pdus = 8;
req.tx_request_body.tx_pdu_list = (nfapi_tx_request_pdu_t*)(malloc(sizeof(nfapi_tx_request_t) * 8));
uint8_t i = 0;
uint8_t test_pdu[1200];
for(i = 0; i < 8; i++)
{
req.tx_request_body.tx_pdu_list[i].pdu_length = sizeof(test_pdu);
req.tx_request_body.tx_pdu_list[i].pdu_index = i;
req.tx_request_body.tx_pdu_list[i].num_segments =1;
req.tx_request_body.tx_pdu_list[i].segments[0].segment_length = sizeof(test_pdu);
req.tx_request_body.tx_pdu_list[i].segments[0].segment_data = (void*)&test_pdu;
}
send_p7_segmented_message_outoforder(p7Sock, &(req.header), sizeof(req), addr, addr_size);
free(req.tx_request_body.tx_pdu_list);
}
void send_dl_subframe_msgs_interleaved(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size, uint16_t sfn_sf)
{
uint8_t buffer[256][256];
uint16_t msg_size[256];
uint16_t count = 0;
{
nfapi_dl_config_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_DL_CONFIG_REQUEST;
req.header.phy_id = phy_id;
req.header.m_segment_sequence = 34;
req.sfn_sf = sfn_sf;
req.dl_config_request_body.tl.tag = NFAPI_DL_CONFIG_REQUEST_BODY_TAG;
req.dl_config_request_body.number_pdu = 8;
req.dl_config_request_body.dl_config_pdu_list = (nfapi_dl_config_request_pdu_t*)malloc(sizeof(nfapi_dl_config_request_pdu_t) * 8);
uint8_t i = 0;
for(i = 0; i < 8; i++)
{
nfapi_dl_config_request_pdu_t* pdu = &(req.dl_config_request_body.dl_config_pdu_list[i]);
pdu->pdu_type = NFAPI_DL_CONFIG_DLSCH_PDU_TYPE;
pdu->dlsch_pdu.dlsch_pdu_rel8.tl.tag = NFAPI_DL_CONFIG_REQUEST_DLSCH_PDU_REL8_TAG;
}
count = get_p7_segmented_message(p7Sock, &(req.header), sizeof(req), addr, addr_size, buffer, msg_size, count);
}
{
nfapi_ul_config_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_UL_CONFIG_REQUEST;
req.header.phy_id = phy_id;
req.header.m_segment_sequence = 35;
req.sfn_sf = sfn_sf;
count = get_p7_segmented_message(p7Sock, &(req.header), sizeof(req), addr, addr_size, buffer, msg_size, count);
}
{
nfapi_hi_dci0_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_HI_DCI0_REQUEST;
req.header.phy_id = phy_id;
req.header.m_segment_sequence = 36;
req.sfn_sf = sfn_sf;
count = get_p7_segmented_message(p7Sock, &(req.header), sizeof(req), addr, addr_size, buffer, msg_size, count);
}
{
nfapi_tx_request_t req;
memset(&req, 0, sizeof(req));
req.header.message_id = NFAPI_TX_REQUEST;
req.header.phy_id = phy_id;
req.header.m_segment_sequence = 37;
req.sfn_sf = sfn_sf;
req.tx_request_body.tl.tag = NFAPI_TX_REQUEST_BODY_TAG;
req.tx_request_body.number_of_pdus = 8;
req.tx_request_body.tx_pdu_list = (nfapi_tx_request_pdu_t*)(malloc(sizeof(nfapi_tx_request_t) * 8));
uint8_t i = 0;
uint8_t test_pdu[1200];
for(i = 0; i < 8; i++)
{
req.tx_request_body.tx_pdu_list[i].pdu_length = sizeof(test_pdu);
req.tx_request_body.tx_pdu_list[i].pdu_index = i;
req.tx_request_body.tx_pdu_list[i].num_segments =1;
req.tx_request_body.tx_pdu_list[i].segments[0].segment_length = sizeof(test_pdu);
req.tx_request_body.tx_pdu_list[i].segments[0].segment_data = (void*)&test_pdu;
}
count = get_p7_segmented_message(p7Sock, &(req.header), sizeof(req), addr, addr_size, buffer, msg_size, count);
}
// send all odd then send event
uint8_t e = 0;
uint8_t o = 1;
while(o <= count)
{
if(msg_size[o] == 0)
printf("**** Sending a zero length msg %d\n", o);
sendto(p7Sock, &buffer[o][0], msg_size[o], 0, (struct sockaddr*)addr, addr_size);
o += 2;
}
while(e <= count)
{
if(msg_size[e] == 0)
printf("**** Sending a zero length msg %d\n", e);
sendto(p7Sock, &buffer[e][0], msg_size[e], 0, (struct sockaddr*)addr, addr_size);
e += 2;
}
//free(req.tx_request_body.tx_pdu_list);
}
void send_subframe_indication(phy_info_t* phy_info)
{
nfapi_pnf_p7_subframe_ind(phy_info->config, phy_info->phy_id, phy_info->sfn_sf);
}
void send_harq_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_harq_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_HARQ_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_harq_ind((phy_info->config), &ind);
}
void recieve_harq_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_harq_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_HARQ_INDICATION);
if(ind.header.message_id == NFAPI_HARQ_INDICATION)
{
printf("decoded nfapi_harq_indication\n");
}
else
{
printf("decoded ?? 0x%x\n", ind.header.message_id);
}
}
void send_crc_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_crc_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_CRC_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_crc_ind((phy_info->config), &ind);
}
void recieve_crc_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_crc_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_CRC_INDICATION);
if(ind.header.message_id == NFAPI_CRC_INDICATION)
{
printf("decoded nfapi_crc_indication\n");
}
}
void send_rx_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_rx_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_RX_ULSCH_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_rx_ind((phy_info->config), &ind);
}
void recieve_rx_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_rx_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_RX_ULSCH_INDICATION);
if(ind.header.message_id == NFAPI_RX_ULSCH_INDICATION)
{
printf("decoded nfapi_rx_indication\n");
}
}
void send_rach_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_rach_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_RACH_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_rach_ind((phy_info->config), &ind);
}
void recieve_rach_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_rach_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_RACH_INDICATION);
if(ind.header.message_id == NFAPI_RACH_INDICATION)
{
printf("decoded nfapi_rach_indication\n");
}
}
void send_srs_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_srs_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_SRS_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_srs_ind((phy_info->config), &ind);
}
void recieve_srs_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_srs_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_SRS_INDICATION);
if(ind.header.message_id == NFAPI_SRS_INDICATION)
{
printf("decoded nfapi_srs_indication\n");
}
}
void send_sr_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_sr_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_RX_SR_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_sr_ind((phy_info->config), &ind);
}
void recieve_sr_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_sr_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_RX_SR_INDICATION);
if(ind.header.message_id == NFAPI_RX_SR_INDICATION)
{
printf("decoded nfapi_sr_indication\n");
}
}
void send_cqi_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_cqi_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_RX_CQI_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_cqi_ind((phy_info->config), &ind);
}
void recieve_cqi_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_cqi_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_RX_CQI_INDICATION);
if(ind.header.message_id == NFAPI_RX_CQI_INDICATION)
{
printf("decoded nfapi_cqi_indication\n");
}
}
void send_lbt_dl_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_lbt_dl_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_LBT_DL_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_lbt_dl_ind((phy_info->config), &ind);
}
void recieve_lbt_dl_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_lbt_dl_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_LBT_DL_INDICATION);
if(ind.header.message_id == NFAPI_LBT_DL_INDICATION)
{
printf("decoded nfapi_lbt_dl_indication\n");
}
}
void send_nb_harq_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_nb_harq_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_NB_HARQ_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_nb_harq_ind((phy_info->config), &ind);
}
void recieve_nb_harq_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_nb_harq_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_NB_HARQ_INDICATION);
if(ind.header.message_id == NFAPI_NB_HARQ_INDICATION)
{
printf("decoded nfapi_nb_harq_indication\n");
}
}
void send_nrach_ind(phy_info_t* phy_info, uint16_t sfn_sf)
{
nfapi_nrach_indication_t ind;
memset(&ind, 0, sizeof(ind));
ind.header.message_id = NFAPI_NRACH_INDICATION;
ind.header.phy_id = phy_info->phy_id;
ind.sfn_sf = sfn_sf;
nfapi_pnf_p7_nrach_ind((phy_info->config), &ind);
}
void recieve_nrach_ind(int p7Sock, int phy_id, struct sockaddr_in* addr, socklen_t addr_size)
{
nfapi_nrach_indication_t ind;
recv_p7_message(p7Sock, &(ind.header), sizeof(ind));
CU_ASSERT_EQUAL(ind.header.message_id, NFAPI_NRACH_INDICATION);
if(ind.header.message_id == NFAPI_NRACH_INDICATION)
{
printf("decoded nfapi_nrach_indication\n");
}
}
void pnf_test_start_connect(void)
{
pnf_info_t pnf_info;
pnf_info.num_phys = 1;
pnf_info.phys[0].pnf_p7_port = 9345;
pnf_info.phys[0].pnf_p7_addr = "127.0.0.1";
pnf_info.phys[0].vnf_p7_port = 8875;
pnf_info.phys[0].vnf_p7_addr = "127.0.0.1";
char* vnf_addr = "127.0.0.1";
int vnf_port = 6699;
int p5ListenSock = create_p5_listen_socket(vnf_addr, vnf_port);
printf("p5ListenSock %d %d\n", p5ListenSock, errno);
listen(p5ListenSock, 2);
test_param_request_called = 0;
test_config_request_called = 0;
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
config->vnf_p5_port = vnf_port;
config->pnf_param_req = &test_pnf_param_request;
config->pnf_config_req = &test_pnf_config_request;
config->pnf_start_req = &test_pnf_start_request;
config->pnf_stop_req = &test_pnf_stop_request;
config->param_req = &test_param_request;
config->config_req = &test_config_request;
config->start_req = &test_start_request;
config->stop_req = &test_stop_request;
config->user_data = &pnf_info;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
struct sockaddr_in addr;
socklen_t addrSize = sizeof(addr);;
int p5Sock = accept(p5ListenSock, (struct sockaddr *)&addr, &addrSize);
printf("p5 connection accepted %d %d\n", p5Sock, errno);
send_pnf_param_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_param_response(p5Sock, NFAPI_MSG_OK);
send_pnf_config_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_config_response(p5Sock);
send_pnf_start_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_start_response(p5Sock);
send_param_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_param_response(p5Sock);
send_config_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize, &pnf_info);
receive_config_response(p5Sock);
send_start_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_start_response(p5Sock);
sleep(2);
int p7Sock = socket(AF_INET, SOCK_DGRAM, 0);
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(pnf_info.phys[0].vnf_p7_port);
addr.sin_addr.s_addr = INADDR_ANY;
bind(p7Sock, (struct sockaddr*)&addr, sizeof(addr));
}
printf("Sending p7 messages too %s:%d\n", pnf_info.phys[0].pnf_p7_addr, pnf_info.phys[0].pnf_p7_port);
struct sockaddr_in p7_addr;
p7_addr.sin_family = AF_INET;
p7_addr.sin_port = htons(pnf_info.phys[0].pnf_p7_port);
p7_addr.sin_addr.s_addr = inet_addr(pnf_info.phys[0].pnf_p7_addr);
socklen_t p7_addrSize = sizeof(p7_addr);
send_dl_node_sync(p7Sock, 0, &p7_addr, p7_addrSize);
receive_ul_node_sync(p7Sock);
#define SFNSF(_sfn, _sf) ((_sfn << 4) + _sf)
uint16_t sfn_sf = SFNSF(500, 3); // sfn:500 sf:3
pnf_info.phys[0].sfn_sf = sfn_sf;
send_subframe_indication(&(pnf_info.phys[0]));
// should generate dummy messages
usleep(500);
sfn_sf = SFNSF(500, 4); // sfn:500 sf:4
pnf_info.phys[0].sfn_sf = sfn_sf;
send_dl_config_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_ul_config_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_hi_dci0_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_tx_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
usleep(500);
send_subframe_indication(&(pnf_info.phys[0]));
// should send the cached messages
send_harq_ind(&pnf_info.phys[0], sfn_sf);
recieve_harq_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_crc_ind(&pnf_info.phys[0], sfn_sf);
recieve_crc_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_rx_ind(&pnf_info.phys[0], sfn_sf);
recieve_rx_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_rach_ind(&pnf_info.phys[0], sfn_sf);
recieve_rach_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_srs_ind(&pnf_info.phys[0], sfn_sf);
recieve_srs_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_sr_ind(&pnf_info.phys[0], sfn_sf);
recieve_sr_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_cqi_ind(&pnf_info.phys[0], sfn_sf);
recieve_cqi_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_lbt_dl_ind(&pnf_info.phys[0], sfn_sf);
recieve_lbt_dl_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_nb_harq_ind(&pnf_info.phys[0], sfn_sf);
recieve_nb_harq_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_nrach_ind(&pnf_info.phys[0], sfn_sf);
recieve_nrach_ind(p7Sock, 0, &p7_addr, p7_addrSize);
// send out of window dl_config, should expect the timing info
send_dl_config_req(p7Sock, 0, &p7_addr, p7_addrSize, SFNSF(600, 0));
sfn_sf = SFNSF(500, 5); // sfn:500 sf:4
pnf_info.phys[0].sfn_sf = sfn_sf;
usleep(500);
send_subframe_indication(&(pnf_info.phys[0]));
receive_timing_info(p7Sock);
send_stop_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_stop_response(p5Sock);
send_pnf_stop_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_stop_response(p5Sock);
nfapi_pnf_stop(config);
int* result;
pthread_join(thread, (void**)&result);
//CU_ASSERT_NOT_EQUAL(*result, -1);
CU_ASSERT_EQUAL(test_param_request_called, 1);
CU_ASSERT_EQUAL(test_config_request_called, 1);
close(p5Sock);
close(p5ListenSock);
}
void pnf_test_start_connect_ipv6(void)
{
pnf_info_t pnf_info;
pnf_info.num_phys = 1;
pnf_info.phys[0].pnf_p7_port = 9345;
pnf_info.phys[0].pnf_p7_addr = "::1";
pnf_info.phys[0].vnf_p7_port = 8875;
pnf_info.phys[0].vnf_p7_addr = "::1";
char* vnf_addr = "::1";
int vnf_port = 6698;
int p5ListenSock = create_p5_ipv6_listen_socket(vnf_addr, vnf_port);
printf("p5ListenSock ipv6 %d %d\n", p5ListenSock, errno);
int listen_result = listen(p5ListenSock, 2);
printf("Listen result %d\n", listen_result);
test_param_request_called = 0;
test_config_request_called = 0;
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
config->vnf_p5_port = vnf_port;
config->pnf_param_req = &test_pnf_param_request;
config->pnf_config_req = &test_pnf_config_request;
config->pnf_start_req = &test_pnf_start_request;
config->pnf_stop_req = &test_pnf_stop_request;
config->param_req = &test_param_request;
config->config_req = &test_config_request;
config->start_req = &test_start_request;
config->stop_req = &test_stop_request;
config->user_data = &pnf_info;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
struct sockaddr_in6 addr;
socklen_t addrSize = sizeof(addr);;
int p5Sock = accept(p5ListenSock, (struct sockaddr *)&addr, &addrSize);
printf("p5 connection accepted %d %d\n", p5Sock, errno);
send_pnf_param_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_param_response(p5Sock, NFAPI_MSG_OK);
send_pnf_config_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_config_response(p5Sock);
send_pnf_start_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_start_response(p5Sock);
send_param_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_param_response(p5Sock);
}
void pnf_test_state_pnf_config_invalid_state()
{
char* vnf_addr = "127.0.0.1";
int vnf_port = 4546;
int p5ListenSock = create_p5_listen_socket(vnf_addr, vnf_port);
test_param_request_called = 0;
test_config_request_called = 0;
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
config->vnf_p5_port = vnf_port;
config->pnf_param_req = &test_pnf_param_request;
config->pnf_config_req = &test_pnf_config_request;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
listen(p5ListenSock, 2);
struct sockaddr_in addr;
socklen_t addrSize = sizeof(addr);
int p5Sock = accept(p5ListenSock, (struct sockaddr *)&addr, &addrSize);
printf("%s p5Sock %d errno %d\n", __FUNCTION__, p5Sock, errno);
send_pnf_param_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_param_response(p5Sock, NFAPI_MSG_OK);
send_pnf_config_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_config_response(p5Sock);
send_pnf_param_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_param_response(p5Sock, NFAPI_MSG_INVALID_STATE);
nfapi_pnf_stop(config);
int* result;
pthread_join(thread, (void**)&result);
CU_ASSERT_EQUAL(result, 0);
CU_ASSERT_EQUAL(test_param_request_called, 1);
CU_ASSERT_EQUAL(test_config_request_called, 1);
close(p5Sock);
close(p5ListenSock);
}
void pnf_test_state_pnf_param_invalid_state()
{
pnf_info_t pnf_info;
char* vnf_addr = "127.0.0.1";
int vnf_port = 4547;
int p5ListenSock = create_p5_listen_socket(vnf_addr, vnf_port);
test_param_request_called = 0;
test_config_request_called = 0;
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
config->vnf_p5_port = vnf_port;
config->pnf_param_req = &test_pnf_param_request;
config->pnf_config_req = &test_pnf_config_request;
config->user_data = &pnf_info;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
listen(p5ListenSock, 2);
struct sockaddr_in addr;
socklen_t addrSize = sizeof(addr);
int p5Sock = accept(p5ListenSock, (struct sockaddr *)&addr, &addrSize);
send_pnf_param_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_param_response(p5Sock, NFAPI_MSG_OK);
send_pnf_config_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_config_response(p5Sock);
send_pnf_config_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_config_response(p5Sock);
nfapi_pnf_stop(config);
int* result;
pthread_join(thread, (void**)&result);
CU_ASSERT_EQUAL(result, 0);
CU_ASSERT_EQUAL(test_param_request_called, 1);
CU_ASSERT_EQUAL(test_config_request_called, 2);
close(p5Sock);
close(p5ListenSock);
}
void pnf_test_p7_segmentation_test_1(void)
{
pnf_info_t pnf_info;
pnf_info.num_phys = 1;
pnf_info.phys[0].pnf_p7_port = 9348;
pnf_info.phys[0].pnf_p7_addr = "127.0.0.1";
pnf_info.phys[0].vnf_p7_port = 8878;
pnf_info.phys[0].vnf_p7_addr = "127.0.0.1";
char* vnf_addr = "127.0.0.1";
int vnf_port = 6699;
int p5ListenSock = create_p5_listen_socket(vnf_addr, vnf_port);
printf("p5ListenSock %d %d\n", p5ListenSock, errno);
listen(p5ListenSock, 2);
test_param_request_called = 0;
test_config_request_called = 0;
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
config->vnf_p5_port = vnf_port;
config->pnf_param_req = &test_pnf_param_request;
config->pnf_config_req = &test_pnf_config_request;
config->pnf_start_req = &test_pnf_start_request;
config->pnf_stop_req = &test_pnf_stop_request;
config->param_req = &test_param_request;
config->config_req = &test_config_request;
config->start_req = &test_start_request;
config->stop_req = &test_stop_request;
config->user_data = &pnf_info;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
struct sockaddr_in addr;
socklen_t addrSize = sizeof(addr);;
int p5Sock = accept(p5ListenSock, (struct sockaddr *)&addr, &addrSize);
printf("p5 connection accepted %d %d\n", p5Sock, errno);
send_pnf_param_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_param_response(p5Sock, NFAPI_MSG_OK);
send_pnf_config_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_config_response(p5Sock);
send_pnf_start_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_start_response(p5Sock);
send_param_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_param_response(p5Sock);
send_config_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize, &pnf_info);
receive_config_response(p5Sock);
send_start_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_start_response(p5Sock);
sleep(2);
int p7Sock = socket(AF_INET, SOCK_DGRAM, 0);
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(pnf_info.phys[0].vnf_p7_port);
addr.sin_addr.s_addr = INADDR_ANY;
bind(p7Sock, (struct sockaddr*)&addr, sizeof(addr));
}
printf("Sending p7 messages too %s:%d\n", pnf_info.phys[0].pnf_p7_addr, pnf_info.phys[0].pnf_p7_port);
struct sockaddr_in p7_addr;
p7_addr.sin_family = AF_INET;
p7_addr.sin_port = htons(pnf_info.phys[0].pnf_p7_port);
p7_addr.sin_addr.s_addr = inet_addr(pnf_info.phys[0].pnf_p7_addr);
socklen_t p7_addrSize = sizeof(p7_addr);
send_dl_node_sync(p7Sock, 0, &p7_addr, p7_addrSize);
receive_ul_node_sync(p7Sock);
#define SFNSF(_sfn, _sf) ((_sfn << 4) + _sf)
uint16_t sfn_sf = SFNSF(500, 3); // sfn:500 sf:3
pnf_info.phys[0].sfn_sf = sfn_sf;
send_subframe_indication(&(pnf_info.phys[0]));
// should generate dummy messages
usleep(500);
sfn_sf = SFNSF(500, 4); // sfn:500 sf:4
pnf_info.phys[0].sfn_sf = sfn_sf;
send_dl_config_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_ul_config_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_hi_dci0_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_tx_req_1(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
usleep(500);
send_subframe_indication(&(pnf_info.phys[0]));
// should send the cached messages
send_harq_ind(&pnf_info.phys[0], sfn_sf);
recieve_harq_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_crc_ind(&pnf_info.phys[0], sfn_sf);
recieve_crc_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_rx_ind(&pnf_info.phys[0], sfn_sf);
recieve_rx_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_rach_ind(&pnf_info.phys[0], sfn_sf);
recieve_rach_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_srs_ind(&pnf_info.phys[0], sfn_sf);
recieve_srs_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_sr_ind(&pnf_info.phys[0], sfn_sf);
recieve_sr_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_cqi_ind(&pnf_info.phys[0], sfn_sf);
recieve_cqi_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_lbt_dl_ind(&pnf_info.phys[0], sfn_sf);
recieve_lbt_dl_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_nb_harq_ind(&pnf_info.phys[0], sfn_sf);
recieve_nb_harq_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_nrach_ind(&pnf_info.phys[0], sfn_sf);
recieve_nrach_ind(p7Sock, 0, &p7_addr, p7_addrSize);
// send out of window dl_config, should expect the timing info
send_dl_config_req(p7Sock, 0, &p7_addr, p7_addrSize, SFNSF(600, 0));
sfn_sf = SFNSF(500, 5); // sfn:500 sf:4
pnf_info.phys[0].sfn_sf = sfn_sf;
usleep(500);
send_subframe_indication(&(pnf_info.phys[0]));
receive_timing_info(p7Sock);
nfapi_pnf_p7_stop(pnf_info.phys[0].config);
int* result;
pthread_join(pnf_info.phys[0].thread, (void**)&result);
close(p7Sock);
send_stop_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_stop_response(p5Sock);
send_pnf_stop_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_stop_response(p5Sock);
nfapi_pnf_stop(config);
pthread_join(thread, (void**)&result);
//CU_ASSERT_NOT_EQUAL(*result, -1);
CU_ASSERT_EQUAL(test_param_request_called, 1);
CU_ASSERT_EQUAL(test_config_request_called, 1);
close(p5Sock);
close(p5ListenSock);
}
void pnf_test_p7_segmentation_test_2(void)
{
pnf_info_t pnf_info;
pnf_info.num_phys = 1;
pnf_info.phys[0].pnf_p7_port = 9348;
pnf_info.phys[0].pnf_p7_addr = "127.0.0.1";
pnf_info.phys[0].vnf_p7_port = 8878;
pnf_info.phys[0].vnf_p7_addr = "127.0.0.1";
char* vnf_addr = "127.0.0.1";
int vnf_port = 6699;
int p5ListenSock = create_p5_listen_socket(vnf_addr, vnf_port);
printf("p5ListenSock %d %d\n", p5ListenSock, errno);
listen(p5ListenSock, 2);
test_param_request_called = 0;
test_config_request_called = 0;
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
config->vnf_p5_port = vnf_port;
config->pnf_param_req = &test_pnf_param_request;
config->pnf_config_req = &test_pnf_config_request;
config->pnf_start_req = &test_pnf_start_request;
config->pnf_stop_req = &test_pnf_stop_request;
config->param_req = &test_param_request;
config->config_req = &test_config_request;
config->start_req = &test_start_request;
config->stop_req = &test_stop_request;
config->user_data = &pnf_info;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
struct sockaddr_in addr;
socklen_t addrSize = sizeof(addr);;
int p5Sock = accept(p5ListenSock, (struct sockaddr *)&addr, &addrSize);
printf("p5 connection accepted %d %d\n", p5Sock, errno);
send_pnf_param_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_param_response(p5Sock, NFAPI_MSG_OK);
send_pnf_config_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_config_response(p5Sock);
send_pnf_start_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_start_response(p5Sock);
send_param_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_param_response(p5Sock);
send_config_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize, &pnf_info);
receive_config_response(p5Sock);
send_start_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_start_response(p5Sock);
sleep(2);
int p7Sock = socket(AF_INET, SOCK_DGRAM, 0);
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(pnf_info.phys[0].vnf_p7_port);
addr.sin_addr.s_addr = INADDR_ANY;
bind(p7Sock, (struct sockaddr*)&addr, sizeof(addr));
}
printf("Sending p7 messages too %s:%d\n", pnf_info.phys[0].pnf_p7_addr, pnf_info.phys[0].pnf_p7_port);
struct sockaddr_in p7_addr;
p7_addr.sin_family = AF_INET;
p7_addr.sin_port = htons(pnf_info.phys[0].pnf_p7_port);
p7_addr.sin_addr.s_addr = inet_addr(pnf_info.phys[0].pnf_p7_addr);
socklen_t p7_addrSize = sizeof(p7_addr);
send_dl_node_sync(p7Sock, 0, &p7_addr, p7_addrSize);
receive_ul_node_sync(p7Sock);
#define SFNSF(_sfn, _sf) ((_sfn << 4) + _sf)
uint16_t sfn_sf = SFNSF(500, 3); // sfn:500 sf:3
pnf_info.phys[0].sfn_sf = sfn_sf;
send_subframe_indication(&(pnf_info.phys[0]));
// should generate dummy messages
usleep(500);
sfn_sf = SFNSF(500, 4); // sfn:500 sf:4
pnf_info.phys[0].sfn_sf = sfn_sf;
send_dl_config_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_ul_config_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_hi_dci0_req(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
send_tx_req_2(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
usleep(500);
send_subframe_indication(&(pnf_info.phys[0]));
// should send the cached messages
send_harq_ind(&pnf_info.phys[0], sfn_sf);
recieve_harq_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_crc_ind(&pnf_info.phys[0], sfn_sf);
recieve_crc_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_rx_ind(&pnf_info.phys[0], sfn_sf);
recieve_rx_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_rach_ind(&pnf_info.phys[0], sfn_sf);
recieve_rach_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_srs_ind(&pnf_info.phys[0], sfn_sf);
recieve_srs_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_sr_ind(&pnf_info.phys[0], sfn_sf);
recieve_sr_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_cqi_ind(&pnf_info.phys[0], sfn_sf);
recieve_cqi_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_lbt_dl_ind(&pnf_info.phys[0], sfn_sf);
recieve_lbt_dl_ind(p7Sock, 0, &p7_addr, p7_addrSize);
// send out of window dl_config, should expect the timing info
send_dl_config_req(p7Sock, 0, &p7_addr, p7_addrSize, SFNSF(600, 0));
sfn_sf = SFNSF(500, 5); // sfn:500 sf:4
pnf_info.phys[0].sfn_sf = sfn_sf;
usleep(500);
send_subframe_indication(&(pnf_info.phys[0]));
receive_timing_info(p7Sock);
send_stop_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_stop_response(p5Sock);
nfapi_pnf_p7_stop(pnf_info.phys[0].config);
int* result;
pthread_join(pnf_info.phys[0].thread, (void**)&result);
close(p7Sock);
send_pnf_stop_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_stop_response(p5Sock);
nfapi_pnf_stop(config);
pthread_join(thread, (void**)&result);
//CU_ASSERT_NOT_EQUAL(*result, -1);
CU_ASSERT_EQUAL(test_param_request_called, 1);
CU_ASSERT_EQUAL(test_config_request_called, 1);
close(p5Sock);
close(p5ListenSock);
}
void pnf_test_p7_segmentation_test_3(void)
{
pnf_info_t pnf_info;
pnf_info.num_phys = 1;
pnf_info.phys[0].pnf_p7_port = 9348;
pnf_info.phys[0].pnf_p7_addr = "127.0.0.1";
pnf_info.phys[0].vnf_p7_port = 8878;
pnf_info.phys[0].vnf_p7_addr = "127.0.0.1";
char* vnf_addr = "127.0.0.1";
int vnf_port = 6699;
int p5ListenSock = create_p5_listen_socket(vnf_addr, vnf_port);
printf("p5ListenSock %d %d\n", p5ListenSock, errno);
listen(p5ListenSock, 2);
test_param_request_called = 0;
test_config_request_called = 0;
nfapi_pnf_config_t* config = nfapi_pnf_config_create();
config->vnf_ip_addr = vnf_addr;
config->vnf_p5_port = vnf_port;
config->pnf_param_req = &test_pnf_param_request;
config->pnf_config_req = &test_pnf_config_request;
config->pnf_start_req = &test_pnf_start_request;
config->pnf_stop_req = &test_pnf_stop_request;
config->param_req = &test_param_request;
config->config_req = &test_config_request;
config->start_req = &test_start_request;
config->stop_req = &test_stop_request;
config->user_data = &pnf_info;
pthread_t thread;
pthread_create(&thread, NULL, &pnf_test_start_thread, config);
struct sockaddr_in addr;
socklen_t addrSize = sizeof(addr);;
int p5Sock = accept(p5ListenSock, (struct sockaddr *)&addr, &addrSize);
printf("p5 connection accepted %d %d\n", p5Sock, errno);
send_pnf_param_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_param_response(p5Sock, NFAPI_MSG_OK);
send_pnf_config_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_config_response(p5Sock);
send_pnf_start_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_start_response(p5Sock);
send_param_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_param_response(p5Sock);
send_config_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize, &pnf_info);
receive_config_response(p5Sock);
send_start_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_start_response(p5Sock);
sleep(2);
int p7Sock = socket(AF_INET, SOCK_DGRAM, 0);
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(pnf_info.phys[0].vnf_p7_port);
addr.sin_addr.s_addr = INADDR_ANY;
bind(p7Sock, (struct sockaddr*)&addr, sizeof(addr));
}
printf("Sending p7 messages too %s:%d\n", pnf_info.phys[0].pnf_p7_addr, pnf_info.phys[0].pnf_p7_port);
struct sockaddr_in p7_addr;
p7_addr.sin_family = AF_INET;
p7_addr.sin_port = htons(pnf_info.phys[0].pnf_p7_port);
p7_addr.sin_addr.s_addr = inet_addr(pnf_info.phys[0].pnf_p7_addr);
socklen_t p7_addrSize = sizeof(p7_addr);
send_dl_node_sync(p7Sock, 0, &p7_addr, p7_addrSize);
receive_ul_node_sync(p7Sock);
#define SFNSF(_sfn, _sf) ((_sfn << 4) + _sf)
uint16_t sfn_sf = SFNSF(500, 3); // sfn:500 sf:3
pnf_info.phys[0].sfn_sf = sfn_sf;
send_subframe_indication(&(pnf_info.phys[0]));
// should generate dummy messages
usleep(500);
sfn_sf = SFNSF(500, 4); // sfn:500 sf:4
pnf_info.phys[0].sfn_sf = sfn_sf;
send_dl_subframe_msgs_interleaved(p7Sock, 0, &p7_addr, p7_addrSize, sfn_sf);
usleep(500);
send_subframe_indication(&(pnf_info.phys[0]));
// should send the cached messages
send_harq_ind(&pnf_info.phys[0], sfn_sf);
recieve_harq_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_crc_ind(&pnf_info.phys[0], sfn_sf);
recieve_crc_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_rx_ind(&pnf_info.phys[0], sfn_sf);
recieve_rx_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_rach_ind(&pnf_info.phys[0], sfn_sf);
recieve_rach_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_srs_ind(&pnf_info.phys[0], sfn_sf);
recieve_srs_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_sr_ind(&pnf_info.phys[0], sfn_sf);
recieve_sr_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_cqi_ind(&pnf_info.phys[0], sfn_sf);
recieve_cqi_ind(p7Sock, 0, &p7_addr, p7_addrSize);
send_lbt_dl_ind(&pnf_info.phys[0], sfn_sf);
recieve_lbt_dl_ind(p7Sock, 0, &p7_addr, p7_addrSize);
// send out of window dl_config, should expect the timing info
printf("Sending late dl config req\n");
send_dl_config_req(p7Sock, 0, &p7_addr, p7_addrSize, SFNSF(600, 0));
sfn_sf = SFNSF(500, 5); // sfn:500 sf:4
pnf_info.phys[0].sfn_sf = sfn_sf;
sleep(2);
printf("Sending subframe indication\n");
send_subframe_indication(&(pnf_info.phys[0]));
printf("Waitning for timing info\n");
receive_timing_info(p7Sock);
printf("Sending stop request\n");
send_stop_request(p5Sock, 0, (struct sockaddr*)&addr, addrSize);
receive_stop_response(p5Sock);
printf("Waiting for P7 thread to stop\n");
nfapi_pnf_p7_stop(pnf_info.phys[0].config);
int* result;
pthread_join(pnf_info.phys[0].thread, (void**)&result);
close(p7Sock);
send_pnf_stop_request(p5Sock, (struct sockaddr*)&addr, addrSize);
receive_pnf_stop_response(p5Sock);
nfapi_pnf_stop(config);
pthread_join(thread, (void**)&result);
//CU_ASSERT_NOT_EQUAL(*result, -1);
CU_ASSERT_EQUAL(test_param_request_called, 1);
CU_ASSERT_EQUAL(test_config_request_called, 1);
close(p5Sock);
close(p5ListenSock);
}
/************* Test Runner Code goes here **************/
int main ( void )
{
CU_pSuite pSuite = NULL;
/* initialize the CUnit test registry */
if ( CUE_SUCCESS != CU_initialize_registry() )
return CU_get_error();
/* add a suite to the registry */
pSuite = CU_add_suite( "pnf_test_suite", init_suite, clean_suite );
if ( NULL == pSuite ) {
CU_cleanup_registry();
return CU_get_error();
}
/* add the tests to the suite */
if ( (NULL == CU_add_test(pSuite, "pnf_test_start_no_config", pnf_test_start_no_config)) ||
(NULL == CU_add_test(pSuite, "pnf_test_start_no_ip", pnf_test_start_no_ip)) ||
(NULL == CU_add_test(pSuite, "pnf_test_start_invalid_ip", pnf_test_start_invalid_ip)) ||
(NULL == CU_add_test(pSuite, "pnf_test_start_no_connection", pnf_test_start_no_connection)) ||
(NULL == CU_add_test(pSuite, "pnf_test_start_connect", pnf_test_start_connect)) ||
(NULL == CU_add_test(pSuite, "pnf_test_start_pnf_config_invalid_state", pnf_test_state_pnf_config_invalid_state)) ||
(NULL == CU_add_test(pSuite, "pnf_test_start_pnf_param_invalid_state", pnf_test_state_pnf_param_invalid_state)) ||
(NULL == CU_add_test(pSuite, "pnf_test_p7_segmentation_test_1", pnf_test_p7_segmentation_test_1)) ||
(NULL == CU_add_test(pSuite, "pnf_test_p7_segmentation_test_2", pnf_test_p7_segmentation_test_2)) ||
(NULL == CU_add_test(pSuite, "pnf_test_p7_segmentation_test_3", pnf_test_p7_segmentation_test_3))
)
{
CU_cleanup_registry();
return CU_get_error();
}
//(NULL == CU_add_test(pSuite, "pnf_test_start_connect_ipv6", pnf_test_start_connect_ipv6)) ||
// Run all tests using the basic interface
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_set_output_filename("pnf_unit_test_results.xml");
CU_basic_run_tests();
CU_pSuite s = CU_get_registry()->pSuite;
int count = 0;
while(s)
{
CU_pTest t = s->pTest;
while(t)
{
count++;
t = t->pNext;
}
s = s->pNext;
}
printf("%d..%d\n", 1, count);
s = CU_get_registry()->pSuite;
count = 1;
while(s)
{
CU_pTest t = s->pTest;
while(t)
{
int pass = 1;
CU_FailureRecord* failures = CU_get_failure_list();
while(failures)
{
if(strcmp(failures->pSuite->pName, s->pName) == 0 &&
strcmp(failures->pTest->pName, t->pName) == 0)
{
pass = 0;
failures = 0;
}
else
{
failures = failures->pNext;
}
}
if(pass)
printf("ok %d - %s:%s\n", count, s->pName, t->pName);
else
printf("not ok %d - %s:%s\n", count, s->pName, t->pName);
count++;
t = t->pNext;
}
s = s->pNext;
}
// Clean up registry and return
CU_cleanup_registry();
return CU_get_error();
}
Reference in New Issue View Git Blame Copy Permalink