Commit c4cb8f47 authored by Rohit Gupta's avatar Rohit Gupta

Merge branch 'Feature-6-fix_test_core_network_with_scenarios' into develop

parents debe652b 667a4987
......@@ -176,30 +176,53 @@ add_definitions(-DCMAKER)
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} -g -DMALLOC_CHECK_=3")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS} -g -DMALLOC_CHECK_=3 -O2")
Message("RF_BOARD is ${RF_BOARD}")
# Below has been put in comment because does not work with
# SVN authentication.
#
#find_package(Subversion)
#if(SUBVERSION_FOUND)
# Subversion_WC_INFO(${OPENAIR_DIR} openair)
# set (FIRMWARE_VERSION "${openair_WC_REVISION} - ${openair_WC_LAST_CHANGED_DATE}")
# Subversion_WC_LOG(${OPENAIR_DIR} Project)
#else()
# set (FIRMWARE_VERSION "No svn information")
#endif()
#add_definitions("-DFIRMWARE_VERSION=\"${FIRMWARE_VERSION}\"")
set(GIT_BRANCH "UNKNOWN")
set(GIT_COMMIT_HASH "UNKNOWN")
set(GIT_COMMIT_DATE "UNKNOWN")
find_package(Git)
if(GIT_FOUND)
message("git found: ${GIT_EXECUTABLE}")
# Get the current working branch
execute_process(
COMMAND git rev-parse --abbrev-ref HEAD
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
OUTPUT_VARIABLE GIT_BRANCH
OUTPUT_STRIP_TRAILING_WHITESPACE
)
# Get the latest abbreviated commit hash of the working branch
execute_process(
COMMAND git log -1 --format=%h
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
OUTPUT_VARIABLE GIT_COMMIT_HASH
OUTPUT_STRIP_TRAILING_WHITESPACE
)
# Get the latest commit date of the working branch
execute_process(
COMMAND git log -1 --format=%cd
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
OUTPUT_VARIABLE GIT_COMMIT_DATE
OUTPUT_STRIP_TRAILING_WHITESPACE
)
endif()
# Below is a hard-coded info
set (FIRMWARE_VERSION "No svn information")
add_definitions("-DFIRMWARE_VERSION=\"${FIRMWARE_VERSION}\"")
add_definitions("-DPACKAGE_VERSION=\"${FIRMWARE_VERSION}\"")
add_definitions("-DPACKAGE_BUGREPORT=\"OpenAirInterface web site\"")
add_definitions("-DPACKAGE_VERSION=\"Branch: ${GIT_BRANCH} Abrev. Hash: ${GIT_COMMIT_HASH} Date: ${GIT_COMMIT_DATE}\"")
add_definitions("-DPACKAGE_BUGREPORT=\"openair4g-devel@lists.eurecom.fr\"")
# Debug related options
#########################################
add_boolean_option(ASN_DEBUG False "ASN1 coder/decoder Debug")
add_boolean_option(EMIT_ASN_DEBUG False "ASN1 coder/decoder Debug")
add_boolean_option(MSG_PRINT False "print debug messages")
add_boolean_option(DISABLE_XER_PRINT False "print XER Format")
add_boolean_option(XER_PRINT False "print XER Format")
......@@ -322,6 +345,7 @@ set(S1AP_OAI_generated
${S1AP_C_DIR}/s1ap_decoder.c
${S1AP_C_DIR}/s1ap_encoder.c
${S1AP_C_DIR}/s1ap_xer_print.c
${S1AP_C_DIR}/s1ap_compare.c
${S1AP_C_DIR}/s1ap_ies_defs.h
)
file(GLOB s1ap_h ${S1AP_C_DIR}/*.h)
......@@ -1086,7 +1110,6 @@ add_library(CN_UTILS
${OPENAIR3_DIR}/UTILS/conversions.c
${OPENAIR3_DIR}/UTILS/enum_string.c
${OPENAIR3_DIR}/UTILS/log.c
${OPENAIR3_DIR}/UTILS/mme_config.c
${OPENAIR3_DIR}/UTILS/mcc_mnc_itu.c
)
......@@ -1427,6 +1450,9 @@ include(FindPkgConfig)
pkg_search_module(LIBXML2 libxml-2.0 REQUIRED)
include_directories(${LIBXML2_INCLUDE_DIRS})
pkg_search_module(LIBXSLT libxslt REQUIRED)
include_directories(${LIBXSLT_INCLUDE_DIRS})
pkg_search_module(OPENSSL openssl REQUIRED)
include_directories(${OPENSSL_INCLUDE_DIRS})
......@@ -1718,6 +1744,7 @@ endforeach(myExe)
add_executable(test_epc_generate_scenario
${OPENAIR3_DIR}/TEST/EPC_TEST/generate_scenario.c
${OPENAIR3_DIR}/TEST/EPC_TEST/generate_scenario.h
${OPENAIR2_DIR}/ENB_APP/enb_config.h
${OPENAIR2_DIR}/COMMON/commonDef.h
${OPENAIR2_DIR}/COMMON/messages_def.h
......@@ -1726,7 +1753,28 @@ add_executable(test_epc_generate_scenario
${OPENAIR_BIN_DIR}/messages_xml.h
)
target_link_libraries (test_epc_generate_scenario
-Wl,--start-group RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY LFDS ${MSC_LIB} L2 -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIBRARIES}
-Wl,--start-group RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY LFDS ${ITTI_LIB} ${MSC_LIB} L2 -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIBRARIES}
)
add_executable(test_epc_play_scenario
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario.c
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_decode.c
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_display.c
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_fsm.c
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_parse.c
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_s1ap.c
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_s1ap_compare_ie.c
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_s1ap_eNB_defs.h
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_sctp.c
${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario.h
${OPENAIR2_DIR}/COMMON/commonDef.h
${OPENAIR2_DIR}/COMMON/messages_def.h
${OPENAIR2_DIR}/COMMON/messages_types.h
${OPENAIR_BIN_DIR}/messages_xml.h
)
target_include_directories(test_epc_play_scenario PUBLIC /usr/local/share/asn1c)
target_link_libraries (test_epc_play_scenario
-Wl,--start-group RRC_LIB S1AP_LIB X2AP_LIB GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY LFDS ${ITTI_LIB} ${MSC_LIB} -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIBRARIES}
)
......
cmake_minimum_required(VERSION 2.8)
set ( CMAKE_BUILD_TYPE "RelWithDebInfo" )
set ( ASN_DEBUG False)
set ( ADDR_CONF False )
set ( DEBUG_OMG False )
set ( DISABLE_XER_PRINT False )
set ( DRIVER2013 True )
set ( EMOS False )
set ( EMIT_ASN_DEBUG False )
set ( ENABLE_FXP True )
set ( ENABLE_ITTI True )
set ( ENABLE_NAS_UE_LOGGING True )
......@@ -47,9 +49,9 @@ set ( OAI_EMU False )
set ( OAISIM False )
set ( OAI_NW_DRIVER_TYPE_ETHERNET False )
set ( OAI_NW_DRIVER_USE_NETLINK True )
set ( OPENAIR1 False )
set ( OPENAIR2 False )
set ( OPENAIR_LTE F )
set ( OPENAIR1 True )
set ( OPENAIR2 True )
set ( OPENAIR_LTE True )
set ( PACKAGE_NAME "epc_test" )
set ( PBS_SIM False )
set ( PDCP_USE_NETLINK True )
......@@ -74,4 +76,4 @@ set ( SMBV False )
set ( TEST_OMG False )
set ( USE_MME "R10" )
set ( USER_MODE True )
set ( XER_PRINT False )
set ( XER_PRINT True )
......@@ -30,7 +30,7 @@
################################################################################
# file build_helper
# brief
# author Laurent Thomas
# authors Laurent Thomas, Lionel GAUTHIER
#
#######################################
SUDO='sudo -E'
......@@ -269,7 +269,9 @@ check_install_oai_software() {
pydb \
wvdial \
python-numpy \
sshpass
sshpass \
libxslt1-dev
$SUDO update-alternatives --set liblapack.so /usr/lib/atlas-base/atlas/liblapack.so
if [ `lsb_release -rs` = '12.04' ] ; then
install_nettle_from_source
......@@ -291,10 +293,12 @@ install_asn1c_from_source(){
$SUDO rm -rf /tmp/asn1c-r1516
mkdir -p /tmp/asn1c-r1516
cd /tmp/asn1c-r1516
svn co https://github.com/vlm/asn1c/trunk /tmp/asn1c-r1516 -r 1516
patch -p0 < $OPENAIR_DIR/openair3/S1AP/MESSAGES/ASN1/asn1cpatch.p0
patch -p0 < $OPENAIR_DIR/openair3/S1AP/MESSAGES/ASN1/asn1cpatch_2.p0
patch -p0 < $OPENAIR_DIR/openair2/RRC/LITE/MESSAGES/asn1c/asn1cpatch.p0
rm -rf /tmp/asn1c-r1516/*
svn co https://github.com/vlm/asn1c/trunk /tmp/asn1c-r1516 -r 1516 > /tmp/log_compile_asn1c
patch -p0 < $OPENAIR_DIR/openair3/S1AP/MESSAGES/ASN1/asn1cpatch.p0 >> /tmp/log_compile_asn1c
patch -p0 < $OPENAIR_DIR/openair3/S1AP/MESSAGES/ASN1/asn1cpatch_2.p0 >> /tmp/log_compile_asn1c
patch -p0 < $OPENAIR_DIR/openair2/RRC/LITE/MESSAGES/asn1c/asn1cpatch.p0 >> /tmp/log_compile_asn1c
patch -p0 < $OPENAIR_DIR/openair3/S1AP/MESSAGES/ASN1/asn1cpatch_3.p0 >> /tmp/log_compile_asn1c
./configure
make -j`nproc`
$SUDO make install
......@@ -324,7 +328,6 @@ install_nas_tools() {
}
################################
# set_openair_env
###############################
......
......@@ -22,7 +22,7 @@
# Contact Information
# OpenAirInterface Admin: openair_admin@eurecom.fr
# OpenAirInterface Tech : openair_tech@eurecom.fr
# OpenAirInterface Dev : openair4g-devel@eurecom.fr
# OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
#
# Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
#
......@@ -121,6 +121,7 @@ function main()
echo "Cleaning TEST_EPC"
fi
rm -f $OPENAIR_DIR/targets/bin/test_epc_generate_scenario
rm -f $OPENAIR_DIR/targets/bin/test_epc_play_scenario
rm -Rf build 2>&1
mkdir -m 777 -p -v build
fi
......@@ -140,6 +141,13 @@ function main()
compilations \
epc_test test_epc_generate_scenario \
test_epc_generate_scenario $dbin/test_epc_generate_scenario
compilations \
epc_test test_epc_play_scenario \
test_epc_play_scenario $dbin/test_epc_play_scenario
$SUDO cp -upv test_epc_generate_scenario /usr/local/bin
$SUDO cp -upv test_epc_play_scenario /usr/local/bin
}
......
......@@ -48,7 +48,19 @@ Description Contains global common definitions
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
typedef signed char boolean_t;
#if !defined(TRUE)
#define TRUE (boolean_t)0x01
#endif
#if !defined(FALSE)
#define FALSE (boolean_t)0x00
#endif
#define BOOL_NOT(b) (b^TRUE)
#define NAS_UE_ID_FMT "0x%06x"
......@@ -59,13 +71,6 @@ Description Contains global common definitions
#define RETURNok (0)
#define RETURNerror (-1)
#ifndef FALSE
#define FALSE (0)
#endif
#ifndef TRUE
#define TRUE (1)
#endif
/*
* Name of the environment variable which defines the default directory
* where the NAS application is executed and where are located files
......
......@@ -112,7 +112,7 @@ typedef struct net_ip_address_s {
unsigned ipv4:1;
unsigned ipv6:1;
char ipv4_address[16];
char ipv6_address[40];
char ipv6_address[46];
} net_ip_address_t;
typedef uint64_t bitrate_t;
......
......@@ -265,7 +265,7 @@ static const eutra_band_t eutra_bands[] = {
Enb_properties_array_t enb_properties;
static void enb_config_display(void)
void enb_config_display(void)
{
int i,j;
......
......@@ -264,6 +264,7 @@ typedef struct Enb_properties_array_s {
Enb_properties_t *properties[MAX_ENB];
} Enb_properties_array_t;
void enb_config_display(void);
const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP);
const Enb_properties_array_t *enb_config_get(void);
......
......@@ -60,6 +60,8 @@
# include "DRB-ToAddModList.h"
# include "SRB-ToAddMod.h"
# include "SRB-ToAddModList.h"
# include "DRB-ToReleaseList.h"
#ifdef Rel10
#include "PMCH-InfoList-r9.h"
#endif
......
......@@ -51,10 +51,6 @@
#include "UTIL/OPT/opt.h"
/*----------------------------------------------------------------------------*/
#ifndef HAVE_STRNDUP
char * strndup (const char *s, size_t size);
#endif
static int oai_emulation_; /*!< \brief indicating that the parsing position is now within OAI_Emulation_*/
static int environment_system_config_; /*!< \brief indicating that the parsing position is now within Envi_Config_*/
......
--- asn1c/unber.c 2015-12-08 14:39:33.282543533 +0100
+++ asn1c/unber.c 2015-12-07 10:46:18.382647000 +0100
@@ -779,4 +779,6 @@
asn_enc_rval_t OCTET_STRING_encode_aper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *cts, void *sptr, asn_per_outp_t *po) { asn_enc_rval_t er = { 0, 0, 0 }; (void)td; (void)cts; (void)sptr; (void)po; return er; }
+asn_comp_rval_t * OCTET_STRING_compare(asn_TYPE_descriptor_t *td1, void *sptr1, asn_TYPE_descriptor_t *td2, void *sptr2) { (void)td1; (void)sptr1; (void)td2; (void)sptr2; return 0; }
+
size_t xer_whitespace_span(const void *chunk_buf, size_t chunk_size) { (void)chunk_buf; (void)chunk_size; return 0; }
--- libasn1compiler/asn1c_C.c 2015-12-08 14:39:33.366543533 +0100
+++ libasn1compiler/asn1c_C.c 2015-12-08 08:38:29.002565000 +0100
@@ -1082,6 +1082,8 @@
enum tvm_compat tv_mode;
enum etd_spec etd_spec;
char *p;
+ //char tmp_buf[512];
+ //int i = 0;
if(arg->embed) {
enum tnfmt tnfmt = TNF_CTYPE;
@@ -1243,7 +1245,8 @@
OUT("td->uper_decoder = asn_DEF_%s.uper_decoder;\n", type_name);
OUT("td->uper_encoder = asn_DEF_%s.uper_encoder;\n", type_name);
OUT("td->aper_decoder = asn_DEF_%s.aper_decoder;\n", type_name);
- OUT("td->aper_encoder = asn_DEF_%s.aper_encoder;\n", type_name);
+ OUT("td->aper_encoder = asn_DEF_%s.aper_encoder;\n", type_name);
+ OUT("td->compare = asn_DEF_%s.compare;\n", type_name);
if(!terminal && !tags_count) {
OUT("/* The next four lines are here because of -fknown-extern-type */\n");
OUT("td->tags = asn_DEF_%s.tags;\n", type_name);
@@ -1413,6 +1416,39 @@
OUT("}\n");
OUT("\n");
+
+ //i = 0;
+ //while ((p[i] != '_') && (i < sizeof(tmp_buf))) {
+ // tmp_buf[i] = p[i];
+ // i++;
+ //}
+ //tmp_buf[i] = '\0';
+ // hack, only for s1ap
+ //if ((strcmp("S1ap", tmp_buf) == 0) || (strcmp("X2ap", tmp_buf) == 0))
+ // OUT("#include \"%s-ProtocolIE-ID.h\"\n", tmp_buf);
+
+
+ p = MKID(expr);
+ if(HIDE_INNER_DEFS) OUT("static ");
+ OUT("asn_comp_rval_t * \n");
+ OUT("%s", p);
+ if(HIDE_INNER_DEFS) OUT("_%d", expr->_type_unique_index);
+ OUT("_compare(asn_TYPE_descriptor_t *td1,\n");
+ INDENTED(
+ OUT("\tvoid *structure1,\n");
+ OUT("\tasn_TYPE_descriptor_t *td2,\n");
+ OUT("\tvoid *structure2) {\n");
+ OUT("asn_comp_rval_t * res = NULL;\n");
+ OUT("%s_%d_inherit_TYPE_descriptor(td1);\n",
+ p, expr->_type_unique_index);
+ OUT("%s_%d_inherit_TYPE_descriptor(td2);\n",
+ p, expr->_type_unique_index);
+ OUT("res = td1->compare(td1, structure1, td2, structure2);\n");
+ OUT("return res;\n");
+ );
+ OUT("}\n");
+ OUT("\n");
+
p = MKID(expr);
if(HIDE_INNER_DEFS) OUT("static ");
@@ -1450,7 +1486,8 @@
OUT("per_type_decoder_f %s_decode_uper;\n", p);
OUT("per_type_encoder_f %s_encode_uper;\n", p);
OUT("per_type_decoder_f %s_decode_aper;\n", p);
- OUT("per_type_encoder_f %s_encode_aper;\n", p);
+ OUT("per_type_encoder_f %s_encode_aper;\n", p);
+ OUT("type_compare_f %s_compare;\n", p);
}
}
@@ -2501,6 +2538,7 @@
OUT("0, 0,\t/* No APER support, "
"use \"-gen-PER\" to enable */\n");
}
+ FUNCREF(compare);
if(!terminal || terminal->expr_type == ASN_CONSTR_CHOICE) {
//if(expr->expr_type == ASN_CONSTR_CHOICE) {
--- skeletons/ANY.c 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/ANY.c 2015-11-26 14:40:56.547616000 +0100
@@ -24,7 +24,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
0, 0, 0, 0,
0, /* No PER visible constraints */
--- skeletons/asn_application.h 2015-12-08 14:39:12.674543554 +0100
+++ skeletons/asn_application.h 2015-12-07 14:36:32.950633000 +0100
@@ -9,7 +9,8 @@
#define _ASN_APPLICATION_H_
#include "asn_system.h" /* for platform-dependent types */
-#include "asn_codecs.h" /* for ASN.1 codecs specifics */
+#include "asn_codecs.h" /* for ASN.1 codecs specifics */
+#include "asn_compare.h"
#ifdef __cplusplus
extern "C" {
--- skeletons/asn_compare.h 1970-01-01 01:00:00.000000000 +0100
+++ skeletons/asn_compare.h 2015-12-08 10:34:58.090558000 +0100
@@ -0,0 +1,78 @@
+#ifndef _ASN_COMPARE_H_
+#define _ASN_COMPARE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct asn_TYPE_descriptor_s; /* Forward declaration */
+
+
+typedef enum COMPARE_ERR_CODE_e {
+ COMPARE_ERR_CODE_START = 0,
+ COMPARE_ERR_CODE_NONE = COMPARE_ERR_CODE_START,
+ COMPARE_ERR_CODE_NO_MATCH,
+ COMPARE_ERR_CODE_TYPE_MISMATCH,
+ COMPARE_ERR_CODE_TYPE_ARG_NULL,
+ COMPARE_ERR_CODE_VALUE_NULL,
+ COMPARE_ERR_CODE_VALUE_ARG_NULL,
+ COMPARE_ERR_CODE_CHOICE_NUM,
+ COMPARE_ERR_CODE_CHOICE_PRESENT,
+ COMPARE_ERR_CODE_CHOICE_MALFORMED,
+ COMPARE_ERR_CODE_SET_MALFORMED,
+ COMPARE_ERR_CODE_COLLECTION_NUM_ELEMENTS,
+ COMPARE_ERR_CODE_END
+} COMPARE_ERR_CODE_t;
+
+typedef struct asn_comp_rval_s {
+ enum COMPARE_ERR_CODE_e err_code;
+ char *name; // e_S1ap_ProtocolIE_ID not available for all ASN1 use (RRC vs S1AP, X2AP)
+ void *structure1;
+ void *structure2;
+ struct asn_comp_rval_s *next;
+} asn_comp_rval_t;
+
+#define COMPARE_CHECK_ARGS(aRg_tYpE_dEf1, aRg_tYpE_dEf2, aRg_vAl1, aRg_vAl2, rEsUlT) \
+ do {\
+ if ((aRg_tYpE_dEf1) && (aRg_tYpE_dEf2)) {\
+ if ((aRg_tYpE_dEf1->name) && (aRg_tYpE_dEf2->name)) {\
+ if (strcmp(aRg_tYpE_dEf1->name, aRg_tYpE_dEf2->name)) {\
+ rEsUlT = (asn_comp_rval_t *)calloc(1, sizeof(asn_comp_rval_t));\
+ rEsUlT->err_code = COMPARE_ERR_CODE_TYPE_MISMATCH;\
+ rEsUlT->name = aRg_tYpE_dEf1->name;\
+ return rEsUlT;\
+ }\
+ } else {\
+ if ((aRg_tYpE_dEf1->xml_tag) && (aRg_tYpE_dEf2->xml_tag)) {\
+ if (strcmp(aRg_tYpE_dEf1->xml_tag, aRg_tYpE_dEf2->xml_tag)) {\
+ rEsUlT = (asn_comp_rval_t *)calloc(1, sizeof(asn_comp_rval_t));\
+ rEsUlT->err_code = COMPARE_ERR_CODE_TYPE_MISMATCH;\
+ rEsUlT->name = aRg_tYpE_dEf1->xml_tag;\
+ return rEsUlT;\
+ }\
+ }\
+ }\
+ } else {\
+ rEsUlT = (asn_comp_rval_t *)calloc(1, sizeof(asn_comp_rval_t));\
+ rEsUlT->name = aRg_tYpE_dEf1->name;\
+ rEsUlT->structure1 = aRg_vAl1;\
+ rEsUlT->structure2 = aRg_vAl2;\
+ rEsUlT->err_code = COMPARE_ERR_CODE_TYPE_ARG_NULL;\
+ return rEsUlT;\
+ }\
+ if ((NULL == aRg_vAl1) || (NULL == aRg_vAl2)){\
+ rEsUlT = (asn_comp_rval_t *)calloc(1, sizeof(asn_comp_rval_t));\
+ rEsUlT->name = aRg_tYpE_dEf1->name;\
+ rEsUlT->structure1 = aRg_vAl1;\
+ rEsUlT->structure2 = aRg_vAl2;\
+ rEsUlT->err_code = COMPARE_ERR_CODE_VALUE_ARG_NULL;\
+ return rEsUlT;\
+ }\
+ } while (0);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ASN_COMPARE_H_ */
--- skeletons/BIT_STRING.c 2015-12-08 14:39:33.346543533 +0100
+++ skeletons/BIT_STRING.c 2015-11-26 14:41:50.159616000 +0100
@@ -30,7 +30,8 @@
OCTET_STRING_decode_uper, /* Unaligned PER decoder */
OCTET_STRING_encode_uper, /* Unaligned PER encoder */
OCTET_STRING_decode_aper, /* Aligned PER decoder */
- OCTET_STRING_encode_aper, /* Aligned PER encoder */
+ OCTET_STRING_encode_aper, /* Aligned PER encoder */
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_BIT_STRING_tags,
sizeof(asn_DEF_BIT_STRING_tags)
--- skeletons/BMPString.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/BMPString.c 2015-11-26 14:42:08.487616000 +0100
@@ -36,7 +36,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper, /* Aligned PER decoder */
- OCTET_STRING_encode_aper, /* Aligned PER encoder */
+ OCTET_STRING_encode_aper, /* Aligned PER encoder */
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_BMPString_tags,
sizeof(asn_DEF_BMPString_tags)
--- skeletons/BOOLEAN.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/BOOLEAN.c 2015-12-08 10:37:11.866558000 +0100
@@ -25,7 +25,8 @@
BOOLEAN_decode_uper, /* Unaligned PER decoder */
BOOLEAN_encode_uper, /* Unaligned PER encoder */
BOOLEAN_decode_aper, /* Aligned PER decoder */
- BOOLEAN_encode_aper, /* Aligned PER encoder */
+ BOOLEAN_encode_aper, /* Aligned PER encoder */
+ BOOLEAN_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_BOOLEAN_tags,
sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
@@ -326,3 +327,22 @@
_ASN_ENCODED_OK(er);
}
+
+asn_comp_rval_t *
+BOOLEAN_compare(asn_TYPE_descriptor_t *td1,
+ void *sptr1, asn_TYPE_descriptor_t *td2, void *sptr2) {
+ const BOOLEAN_t *st1 = (const BOOLEAN_t *)sptr1;
+ const BOOLEAN_t *st2 = (const BOOLEAN_t *)sptr2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (*st1 == *st2) return NULL;
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+}
+
--- skeletons/BOOLEAN.h 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/BOOLEAN.h 2015-11-26 12:46:58.491623000 +0100
@@ -30,6 +30,7 @@
per_type_encoder_f BOOLEAN_encode_uper;
per_type_decoder_f BOOLEAN_decode_aper;
per_type_encoder_f BOOLEAN_encode_aper;
+type_compare_f BOOLEAN_compare;
#ifdef __cplusplus
}
--- skeletons/compare.h 1970-01-01 01:00:00.000000000 +0100
+++ skeletons/compare.h 2015-12-08 08:23:03.694566000 +0100
@@ -0,0 +1,28 @@
+/*-
+ * Eurecom 2015.
+ */
+#ifndef _COMPARE_H_
+#define _COMPARE_H_
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct asn_TYPE_descriptor_s; /* Forward declaration */
+
+typedef asn_comp_rval_t * (type_compare_f)(
+ struct asn_TYPE_descriptor_s *type_descriptor1,
+ void *struct_ptr1,
+ struct asn_TYPE_descriptor_s *type_descriptor2,
+ void *struct_ptr2
+);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _COMPARE_H_ */
--- skeletons/constr_CHOICE.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/constr_CHOICE.c 2015-12-08 10:39:16.670558000 +0100
@@ -1272,3 +1272,75 @@
assert(pres_size != sizeof(int));
}
}
+
+asn_comp_rval_t *
+CHOICE_compare(asn_TYPE_descriptor_t *td1, void *sptr1, asn_TYPE_descriptor_t *td2, void *sptr2)
+{
+ asn_CHOICE_specifics_t *specs1 = (asn_CHOICE_specifics_t *)td1->specifics;
+ asn_CHOICE_specifics_t *specs2 = (asn_CHOICE_specifics_t *)td2->specifics;
+ int present1;
+ int present2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ /*
+ * Figure out which CHOICE element is encoded.
+ */
+ present1 = _fetch_present_idx(sptr1, specs1->pres_offset,specs1->pres_size);
+ // same specs
+ present2 = _fetch_present_idx(sptr2, specs2->pres_offset,specs2->pres_size);
+
+ if (td1->elements_count != td2->elements_count) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_CHOICE_NUM;
+ return res;
+ }
+ if (present1 != present2) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_CHOICE_PRESENT;
+ return res;
+ }
+ if(present1 > 0 && present1 <= td1->elements_count) {
+ asn_TYPE_member_t *elm1 = &td1->elements[present1-1];
+ asn_TYPE_member_t *elm2 = &td2->elements[present2-1];
+ const void *memb_ptr1;
+ const void *memb_ptr2;
+
+ if((elm1->flags & ATF_POINTER) && (elm1->flags & ATF_POINTER)){
+ memb_ptr1 = *(const void * const *)((const char *)sptr1 + elm1->memb_offset);
+ memb_ptr2 = *(const void * const *)((const char *)sptr2 + elm2->memb_offset);
+ if((!memb_ptr1) || (!memb_ptr2)) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_VALUE_NULL;
+ return res;
+ }
+ } else if (!(elm1->flags & ATF_POINTER) && !(elm1->flags & ATF_POINTER)){
+ memb_ptr1 = (const void *)((const char *)sptr1 + elm1->memb_offset);
+ memb_ptr2 = (const void *)((const char *)sptr2 + elm2->memb_offset);
+ } else {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_CHOICE_MALFORMED;
+ return res;
+ }
+ return elm1->type->compare(elm1->type, memb_ptr1, elm2->type, memb_ptr2);
+ }
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_CHOICE_MALFORMED;
+ return res;
+}
--- skeletons/constr_CHOICE.h 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/constr_CHOICE.h 2015-11-26 14:43:57.647616000 +0100
@@ -39,7 +39,7 @@
/*
* A set specialized functions dealing with the CHOICE type.
*/
-asn_struct_free_f CHOICE_free;
+asn_struct_free_f CHOICE_free;
asn_struct_print_f CHOICE_print;
asn_constr_check_f CHOICE_constraint;
ber_type_decoder_f CHOICE_decode_ber;
@@ -50,7 +50,8 @@
per_type_encoder_f CHOICE_encode_uper;
per_type_decoder_f CHOICE_decode_aper;
per_type_encoder_f CHOICE_encode_aper;
-asn_outmost_tag_f CHOICE_outmost_tag;
+type_compare_f CHOICE_compare;
+asn_outmost_tag_f CHOICE_outmost_tag;
#ifdef __cplusplus
}
--- skeletons/constr_SEQUENCE.c 2015-12-08 14:39:33.346543533 +0100
+++ skeletons/constr_SEQUENCE.c 2015-12-08 10:39:52.442558000 +0100
@@ -1761,3 +1761,66 @@
_ASN_ENCODED_OK(er);
}
+
+asn_comp_rval_t * SEQUENCE_compare(asn_TYPE_descriptor_t *td1, void *sptr1, asn_TYPE_descriptor_t *td2, void *sptr2) {
+ int edx;
+ int ret;
+ asn_comp_rval_t *res = NULL;
+ asn_comp_rval_t *res2 = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (td1->elements_count != td2->elements_count) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_COLLECTION_NUM_ELEMENTS;
+ return res;
+ }
+
+ for(edx = 0; edx < td1->elements_count; edx++) {
+ asn_TYPE_member_t *elm1 = &td1->elements[edx];
+ asn_TYPE_member_t *elm2 = &td1->elements[edx];
+ const void *memb_ptr1;
+ const void *memb_ptr2;
+
+ if(elm1->flags & ATF_POINTER) {
+ memb_ptr1 = *(const void * const *)((const char *)sptr1 + elm1->memb_offset);
+ memb_ptr2 = *(const void * const *)((const char *)sptr2 + elm2->memb_offset);
+ if((!memb_ptr1) && (!memb_ptr2)) {
+ if(elm1->optional) continue;
+ }
+ if ((!memb_ptr1) || (!memb_ptr2)) {
+ res2 = calloc(1, sizeof(asn_comp_rval_t));
+ res2->name = elm1->name;
+ res2->structure1 = memb_ptr1;
+ res2->structure2 = memb_ptr2;
+ res->err_code = COMPARE_ERR_CODE_VALUE_NULL;
+ if (NULL == res) {
+ res = res2;
+ } else {
+ res2->next = res;
+ res = res2;
+ }
+ res2 = NULL;
+ }
+ } else {
+ memb_ptr1 = (const void *)((const char *)sptr1 + elm1->memb_offset);
+ memb_ptr2 = (const void *)((const char *)sptr2 + elm2->memb_offset);
+ }
+
+ /* Compare the member itself */
+ res2 = elm1->type->compare(elm1->type, memb_ptr1, elm2->type, memb_ptr2);
+ if(res2) {
+ if (NULL == res) {
+ res = res2;
+ } else {
+ res2->next = res;
+ res = res2;
+ }
+ res2 = NULL;
+ }
+ }
+ return res;
+}
--- skeletons/constr_SEQUENCE.h 2015-12-08 14:39:33.346543533 +0100
+++ skeletons/constr_SEQUENCE.h 2015-11-26 14:48:14.123616000 +0100
@@ -54,6 +54,7 @@
per_type_encoder_f SEQUENCE_encode_uper;
per_type_decoder_f SEQUENCE_decode_aper;
per_type_encoder_f SEQUENCE_encode_aper;
+type_compare_f SEQUENCE_compare;
#ifdef __cplusplus
}
--- skeletons/constr_SEQUENCE_OF.h 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/constr_SEQUENCE_OF.h 2015-11-26 15:05:25.399615000 +0100
@@ -22,7 +22,8 @@
#define SEQUENCE_OF_decode_ber SET_OF_decode_ber
#define SEQUENCE_OF_decode_xer SET_OF_decode_xer
#define SEQUENCE_OF_decode_uper SET_OF_decode_uper
-#define SEQUENCE_OF_decode_aper SET_OF_decode_aper
+#define SEQUENCE_OF_decode_aper SET_OF_decode_aper
+#define SEQUENCE_OF_compare SET_OF_compare
der_type_encoder_f SEQUENCE_OF_encode_der;
xer_type_encoder_f SEQUENCE_OF_encode_xer;
per_type_encoder_f SEQUENCE_OF_encode_uper;
--- skeletons/constr_SET.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/constr_SET.c 2015-12-08 10:40:35.066558000 +0100
@@ -1108,7 +1108,7 @@
}
}
-int
+long
SET_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
int edx;
@@ -1159,3 +1159,58 @@
return 0;
}
+
+asn_comp_rval_t *
+SET_compare(asn_TYPE_descriptor_t *td1, void *sptr1, asn_TYPE_descriptor_t *td2, void *sptr2)
+{
+ int edx;
+ asn_comp_rval_t *res = NULL;
+ asn_comp_rval_t *res2 = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (td1->elements_count != td2->elements_count) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_COLLECTION_NUM_ELEMENTS;
+ return res;
+ }
+
+ for(edx = 0; edx < td1->elements_count; edx++) {
+ asn_TYPE_member_t *elm1 = &td1->elements[edx];
+ asn_TYPE_member_t *elm2 = &td2->elements[edx];
+ const void *memb_ptr1;
+ const void *memb_ptr2;
+
+ if(elm1->flags & ATF_POINTER) {
+ memb_ptr1 = *(const void * const *)((const char *)sptr1 + elm1->memb_offset);
+ memb_ptr2 = *(const void * const *)((const char *)sptr2 + elm2->memb_offset);
+ if(!memb_ptr1) {
+ if(elm1->optional)
+ continue;
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_SET_MALFORMED;
+ return res;
+ }
+ } else {
+ memb_ptr1 = (const void *)((const char *)sptr1 + elm1->memb_offset);
+ memb_ptr2 = (const void *)((const char *)sptr2 + elm2->memb_offset);
+ }
+ res2 = elm1->type->compare(elm1->type, memb_ptr1, elm2->type, memb_ptr2);
+ if(res2) {
+ if (NULL == res) {
+ res = res2;
+ } else {
+ res2->next = res;
+ res = res2;
+ }
+ res2 = NULL;
+ }
+ }
+ return res;
+}
--- skeletons/constr_SET.h 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/constr_SET.h 2015-11-26 14:49:09.243616000 +0100
@@ -56,6 +56,7 @@
per_type_decoder_f SET_decode_aper;
per_type_encoder_f SET_encode_uper;
per_type_encoder_f SET_encode_aper;
+type_compare_f SET_compare;
/***********************
* Some handy helpers. *
--- skeletons/constr_SET_OF.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/constr_SET_OF.c 2015-12-08 10:45:54.466557000 +0100
@@ -1039,3 +1039,55 @@
rv.consumed = 0;
return rv;
}
+
+asn_comp_rval_t *
+SET_OF_compare(asn_TYPE_descriptor_t *td1, void *sptr1, asn_TYPE_descriptor_t *td2, void *sptr2)
+{
+ asn_TYPE_member_t *elm1 = td1->elements;
+ asn_TYPE_member_t *elm2 = td2->elements;
+ const asn_anonymous_set_ *list1 = _A_CSET_FROM_VOID(sptr1);
+ const asn_anonymous_set_ *list2 = _A_CSET_FROM_VOID(sptr2);
+ int ret;
+ int i;
+ asn_comp_rval_t *res = NULL;
+ asn_comp_rval_t *res2 = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (td1->elements_count != td2->elements_count) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_COLLECTION_NUM_ELEMENTS;
+ return res;
+ }
+
+
+ if (list1->count != list2->count ) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_COLLECTION_NUM_ELEMENTS;
+ return res;
+ }
+
+ for(i = 0; i < list1->count; i++) {
+ const void *memb_ptr1 = list1->array[i];
+ const void *memb_ptr2 = list2->array[i];
+ if ((!memb_ptr1) & (!memb_ptr2)) continue;
+
+ res2 = elm1->type->compare(elm1->type, memb_ptr1, elm2->type, memb_ptr2);
+ if(res2) {
+ if (NULL == res) {
+ res = res2;
+ } else {
+ res2->next = res;
+ res = res2;
+ }
+ res2 = NULL;
+ }
+ }
+ return res;
+}
--- skeletons/constr_SET_OF.h 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/constr_SET_OF.h 2015-11-26 14:48:45.067616000 +0100
@@ -36,6 +36,7 @@
per_type_encoder_f SET_OF_encode_uper;
per_type_decoder_f SET_OF_decode_aper;
per_type_encoder_f SET_OF_encode_aper;
+type_compare_f SET_OF_compare;
#ifdef __cplusplus
}
--- skeletons/constr_TYPE.h 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/constr_TYPE.h 2015-11-26 15:28:05.495613000 +0100
@@ -41,7 +41,8 @@
#include <xer_encoder.h> /* Encoder into XER (XML, text) */
#include <per_decoder.h> /* Packet Encoding Rules decoder */
#include <per_encoder.h> /* Packet Encoding Rules encoder */
-#include <constraints.h> /* Subtype constraints support */
+#include <constraints.h> /* Subtype constraints support */
+#include <compare.h> /* Comparison */
/*
* Free the structure according to its specification.
@@ -101,6 +102,7 @@
per_type_encoder_f *uper_encoder; /* Unaligned PER encoder */
per_type_decoder_f *aper_decoder; /* Aligned PER decoder */
per_type_encoder_f *aper_encoder; /* Aligned PER encoder */
+ type_compare_f *compare; /* Comparison between 2 instances */
/***********************************************************************
* Internally useful members. Not to be used by applications directly. *
--- skeletons/ENUMERATED.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/ENUMERATED.c 2015-12-08 10:40:55.986558000 +0100
@@ -27,7 +27,8 @@
ENUMERATED_decode_uper, /* Unaligned PER decoder */
ENUMERATED_encode_uper, /* Unaligned PER encoder */
ENUMERATED_decode_aper, /* Aligned PER decoder */
- ENUMERATED_encode_aper, /* Aligned PER encoder */
+ ENUMERATED_encode_aper, /* Aligned PER encoder */
+ ENUMERATED_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_ENUMERATED_tags,
sizeof(asn_DEF_ENUMERATED_tags) / sizeof(asn_DEF_ENUMERATED_tags[0]),
@@ -103,3 +104,22 @@
return NativeEnumerated_encode_aper(td, constraints, &value, po);
}
+
+asn_comp_rval_t *
+ENUMERATED_compare(asn_TYPE_descriptor_t *td1, void *sptr1,
+ asn_TYPE_descriptor_t *td2, void *sptr2) {
+ ENUMERATED_t *st1 = (ENUMERATED_t *)sptr1;
+ ENUMERATED_t *st2 = (ENUMERATED_t *)sptr2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (*st1 == *st2) return NULL;
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+}
+
--- skeletons/ENUMERATED.h 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/ENUMERATED.h 2015-11-26 12:46:35.523623000 +0100
@@ -19,6 +19,7 @@
per_type_encoder_f ENUMERATED_encode_uper;
per_type_decoder_f ENUMERATED_decode_aper;
per_type_encoder_f ENUMERATED_encode_aper;
+type_compare_f ENUMERATED_compare;
#ifdef __cplusplus
}
--- skeletons/file-dependencies 2015-12-08 14:39:12.678543554 +0100
+++ skeletons/file-dependencies 2015-12-07 15:34:40.454629000 +0100
@@ -39,12 +39,13 @@
constr_SEQUENCE.h constr_SEQUENCE.c
constr_SEQUENCE_OF.h constr_SEQUENCE_OF.c asn_SEQUENCE_OF.h constr_SET_OF.h
constr_SET.h constr_SET.c
-constr_SET_OF.h constr_SET_OF.c asn_SET_OF.h
+constr_SET_OF.h constr_SET_OF.c asn_SET_OF.h compare.h
COMMON-FILES: # THIS IS A SPECIAL SECTION
-asn_application.h # Applications should include this file
+asn_application.h # Applications should include this file
asn_system.h # Platform-dependent types
-asn_codecs.h # Return types of encoders and decoders
+asn_codecs.h # Return types of encoders and decoders
+asn_compare.h # Return type of compare
asn_internal.h # Internal stuff
OCTET_STRING.h OCTET_STRING.c # This one is used too widely
BIT_STRING.h BIT_STRING.c # This one is necessary for the above one
--- skeletons/GeneralizedTime.c 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/GeneralizedTime.c 2015-11-26 15:09:03.899615000 +0100
@@ -168,7 +168,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_GeneralizedTime_tags,
sizeof(asn_DEF_GeneralizedTime_tags)
--- skeletons/GeneralString.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/GeneralString.c 2015-11-26 14:50:11.843616000 +0100
@@ -25,7 +25,8 @@
OCTET_STRING_decode_uper, /* Implemented in terms of OCTET STRING */
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_GeneralString_tags,
sizeof(asn_DEF_GeneralString_tags)
--- skeletons/GraphicString.c 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/GraphicString.c 2015-11-26 15:33:33.255613000 +0100
@@ -25,7 +25,8 @@
OCTET_STRING_decode_uper, /* Implemented in terms of OCTET STRING */
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_GraphicString_tags,
sizeof(asn_DEF_GraphicString_tags)
--- skeletons/IA5String.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/IA5String.c 2015-11-26 14:50:44.219616000 +0100
@@ -31,6 +31,7 @@
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_IA5String_tags,
sizeof(asn_DEF_IA5String_tags)
--- skeletons/INTEGER.c 2015-12-08 14:39:33.346543533 +0100
+++ skeletons/INTEGER.c 2015-12-08 10:41:08.526558000 +0100
@@ -35,6 +35,7 @@
INTEGER_decode_aper,
INTEGER_encode_aper,
#endif /* ASN_DISABLE_PER_SUPPORT */
+ INTEGER_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_INTEGER_tags,
sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
@@ -1501,3 +1502,30 @@
}
+asn_comp_rval_t *
+INTEGER_compare(asn_TYPE_descriptor_t *td1, void *sptr1,
+ asn_TYPE_descriptor_t *td2, void *sptr2) {
+ INTEGER_t *st1 = (INTEGER_t *)sptr1;
+ INTEGER_t *st2 = (INTEGER_t *)sptr2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (st1->size != st2->size) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+ }
+ if (0 != memcmp(st1->buf, st2->buf, st1->size)) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+ }
+ return NULL;
+}
--- skeletons/INTEGER.h 2015-12-08 14:39:33.346543533 +0100
+++ skeletons/INTEGER.h 2015-11-26 12:50:41.551623000 +0100
@@ -43,6 +43,7 @@
per_type_encoder_f INTEGER_encode_uper;
per_type_decoder_f INTEGER_decode_aper;
per_type_encoder_f INTEGER_encode_aper;
+type_compare_f INTEGER_compare;
/***********************************
* Some handy conversion routines. *
--- skeletons/ISO646String.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/ISO646String.c 2015-11-26 12:55:48.327623000 +0100
@@ -30,7 +30,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_ISO646String_tags,
sizeof(asn_DEF_ISO646String_tags)
--- skeletons/Makefile.am 2015-12-08 14:39:12.666543554 +0100
+++ skeletons/Makefile.am 2015-12-07 15:54:00.150628000 +0100
@@ -46,11 +46,11 @@
asn_SET_OF.c asn_SET_OF.h \
asn_application.h asn_codecs.h \
asn_codecs_prim.c asn_codecs_prim.h \
- asn_internal.h asn_system.h \
+ asn_internal.h asn_system.h asn_compare.h \
ber_decoder.c ber_decoder.h \
ber_tlv_length.c ber_tlv_length.h \
- ber_tlv_tag.c ber_tlv_tag.h \
- constr_CHOICE.c constr_CHOICE.h \
+ ber_tlv_tag.c ber_tlv_tag.h compare.h \
+ comparison.h constr_CHOICE.c constr_CHOICE.h \
constr_SEQUENCE.c constr_SEQUENCE.h \
constr_SEQUENCE_OF.c constr_SEQUENCE_OF.h \
constr_SET.c constr_SET.h \
--- skeletons/NativeEnumerated.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/NativeEnumerated.c 2015-12-08 10:41:17.662558000 +0100
@@ -31,7 +31,8 @@
NativeEnumerated_decode_uper,
NativeEnumerated_encode_uper,
NativeEnumerated_decode_aper,
- NativeEnumerated_encode_aper,
+ NativeEnumerated_encode_aper,
+ NativeEnumerated_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_NativeEnumerated_tags,
sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
@@ -335,3 +336,22 @@
_ASN_ENCODED_OK(er);
}
+
+asn_comp_rval_t *
+NativeEnumerated_compare(asn_TYPE_descriptor_t *td1, void *sptr1,
+ asn_TYPE_descriptor_t *td2, void *sptr2) {
+ const asn_INTEGER_enum_map_t *a = sptr1;
+ const asn_INTEGER_enum_map_t *b = sptr2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if(a->nat_value == b->nat_value)
+ return NULL;
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+}
--- skeletons/NativeEnumerated.h 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/NativeEnumerated.h 2015-11-26 14:51:43.315616000 +0100
@@ -26,6 +26,7 @@
per_type_encoder_f NativeEnumerated_encode_uper;
per_type_decoder_f NativeEnumerated_decode_aper;
per_type_encoder_f NativeEnumerated_encode_aper;
+type_compare_f NativeEnumerated_compare;
#ifdef __cplusplus
}
--- skeletons/NativeInteger.c 2015-12-08 14:39:33.346543533 +0100
+++ skeletons/NativeInteger.c 2015-12-08 10:41:24.550558000 +0100
@@ -32,7 +32,8 @@
NativeInteger_decode_uper, /* Unaligned PER decoder */
NativeInteger_encode_uper, /* Unaligned PER encoder */
NativeInteger_decode_aper, /* Aligned PER decoder */
- NativeInteger_encode_aper, /* Aligned PER encoder */
+ NativeInteger_encode_aper, /* Aligned PER encoder */
+ NativeInteger_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_NativeInteger_tags,
sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
@@ -410,3 +411,21 @@
}
}
+
+asn_comp_rval_t *
+NativeInteger_compare(asn_TYPE_descriptor_t *td1, void *sptr1,
+ asn_TYPE_descriptor_t *td2, void *sptr2) {
+ const long *native1 = (const long *)sptr1;
+ const long *native2 = (const long *)sptr2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (*native1 == *native2) return NULL;
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+}
--- skeletons/NativeInteger.h 2015-12-08 14:39:33.346543533 +0100
+++ skeletons/NativeInteger.h 2015-11-26 14:52:13.931616000 +0100
@@ -31,6 +31,7 @@
per_type_encoder_f NativeInteger_encode_uper;
per_type_decoder_f NativeInteger_decode_aper;
per_type_encoder_f NativeInteger_encode_aper;
+type_compare_f NativeInteger_compare;
#ifdef __cplusplus
}
--- skeletons/NativeReal.c 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/NativeReal.c 2015-12-08 10:41:32.666558000 +0100
@@ -33,7 +33,8 @@
NativeReal_decode_uper,
NativeReal_encode_uper,
NativeReal_decode_aper,
- NativeReal_encode_aper,
+ NativeReal_encode_aper,
+ NativeReal_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_NativeReal_tags,
sizeof(asn_DEF_NativeReal_tags) / sizeof(asn_DEF_NativeReal_tags[0]),
@@ -405,3 +406,30 @@
}
}
+asn_comp_rval_t *
+NativeReal_compare(asn_TYPE_descriptor_t *td1, void *sptr1,
+ asn_TYPE_descriptor_t *td2, void *sptr2) {
+ REAL_t *st1 = (REAL_t *)sptr1;
+ REAL_t *st2 = (REAL_t *)sptr2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (st1->size != st2->size) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+ }
+ if (0 != memcmp(st1->buf, st2->buf, st1->size)) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+ }
+ return NULL;
+}
--- skeletons/NativeReal.h 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/NativeReal.h 2015-11-26 14:31:12.631617000 +0100
@@ -29,6 +29,7 @@
per_type_encoder_f NativeReal_encode_uper;
per_type_decoder_f NativeReal_decode_aper;
per_type_encoder_f NativeReal_encode_aper;
+type_compare_f NativeReal_compare;
#ifdef __cplusplus
}
--- skeletons/NULL.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/NULL.c 2015-12-07 10:49:05.178647000 +0100
@@ -26,7 +26,8 @@
NULL_decode_uper, /* Unaligned PER decoder */
NULL_encode_uper, /* Unaligned PER encoder */
NULL_decode_aper, /* Aligned PER decoder */
- NULL_encode_aper, /* Aligned PER encoder */
+ NULL_encode_aper, /* Aligned PER encoder */
+ NULL_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_NULL_tags,
sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
@@ -192,3 +193,10 @@
er.encoded = 0;
_ASN_ENCODED_OK(er);
}
+
+asn_comp_rval_t *
+NULL_compare(asn_TYPE_descriptor_t *td1, void *sptr1,
+ asn_TYPE_descriptor_t *td2, void *sptr2) {
+
+ return NULL;
+}
--- skeletons/NULL.h 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/NULL.h 2015-11-26 14:53:03.875616000 +0100
@@ -27,6 +27,7 @@
per_type_encoder_f NULL_encode_uper;
per_type_decoder_f NULL_decode_aper;
per_type_encoder_f NULL_encode_aper;
+type_compare_f NULL_compare;
#ifdef __cplusplus
}
--- skeletons/NumericString.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/NumericString.c 2015-11-26 14:40:39.407616000 +0100
@@ -50,7 +50,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_NumericString_tags,
sizeof(asn_DEF_NumericString_tags)
--- skeletons/ObjectDescriptor.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/ObjectDescriptor.c 2015-11-26 14:55:46.227615000 +0100
@@ -25,7 +25,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_ObjectDescriptor_tags,
sizeof(asn_DEF_ObjectDescriptor_tags)
--- skeletons/OBJECT_IDENTIFIER.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/OBJECT_IDENTIFIER.c 2015-11-26 14:55:13.311615000 +0100
@@ -28,7 +28,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_OBJECT_IDENTIFIER_tags,
sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
--- skeletons/OCTET_STRING.c 2015-12-08 14:39:44.554543521 +0100
+++ skeletons/OCTET_STRING.c 2015-12-08 10:41:42.838558000 +0100
@@ -37,7 +37,8 @@
OCTET_STRING_decode_uper, /* Unaligned PER decoder */
OCTET_STRING_encode_uper, /* Unaligned PER encoder */
OCTET_STRING_decode_aper, /* Aligned PER decoder */
- OCTET_STRING_encode_aper, /* Aligned PER encoder */
+ OCTET_STRING_encode_aper, /* Aligned PER encoder */
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_OCTET_STRING_tags,
sizeof(asn_DEF_OCTET_STRING_tags)
@@ -2160,3 +2161,30 @@
return st;
}
+asn_comp_rval_t *
+OCTET_STRING_compare(asn_TYPE_descriptor_t *td1,
+ void *sptr1, asn_TYPE_descriptor_t *td2, void *sptr2) {
+ OCTET_STRING_t *st1 = (OCTET_STRING_t *)sptr1;
+ OCTET_STRING_t *st2 = (OCTET_STRING_t *)sptr2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (st1->size != st2->size) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+ }
+ if (0 != memcmp(st1->buf, st2->buf, st1->size)) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+ }
+ return NULL;
+}
--- skeletons/OCTET_STRING.h 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/OCTET_STRING.h 2015-11-26 12:56:15.259623000 +0100
@@ -34,6 +34,7 @@
per_type_encoder_f OCTET_STRING_encode_uper;
per_type_decoder_f OCTET_STRING_decode_aper;
per_type_encoder_f OCTET_STRING_encode_aper;
+type_compare_f OCTET_STRING_compare;
/******************************
* Handy conversion routines. *
--- skeletons/PrintableString.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/PrintableString.c 2015-11-26 14:56:09.787615000 +0100
@@ -60,7 +60,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_PrintableString_tags,
sizeof(asn_DEF_PrintableString_tags)
--- skeletons/REAL.c 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/REAL.c 2015-12-08 10:41:55.178558000 +0100
@@ -46,7 +46,8 @@
REAL_decode_uper,
REAL_encode_uper,
REAL_decode_aper,
- REAL_encode_aper,
+ REAL_encode_aper,
+ REAL_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_REAL_tags,
sizeof(asn_DEF_REAL_tags) / sizeof(asn_DEF_REAL_tags[0]),
@@ -741,3 +742,32 @@
return 0;
}
+
+
+asn_comp_rval_t *
+REAL_compare(asn_TYPE_descriptor_t *td1, void *sptr1,
+ asn_TYPE_descriptor_t *td2, void *sptr2) {
+ REAL_t *st1 = (REAL_t *)sptr1;
+ REAL_t *st2 = (REAL_t *)sptr2;
+ asn_comp_rval_t *res = NULL;
+
+ COMPARE_CHECK_ARGS(td1, td2, sptr1, sptr2, res)
+
+ if (st1->size != st2->size) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+ }
+ if (0 != memcmp(st1->buf, st2->buf, st1->size)) {
+ res = calloc(1, sizeof(asn_comp_rval_t));
+ res->name = td1->name;
+ res->structure1 = sptr1;
+ res->structure2 = sptr2;
+ res->err_code = COMPARE_ERR_CODE_NO_MATCH;
+ return res;
+ }
+ return NULL;
+}
--- skeletons/REAL.h 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/REAL.h 2015-11-26 13:00:46.183623000 +0100
@@ -23,6 +23,7 @@
per_type_encoder_f REAL_encode_uper;
per_type_decoder_f REAL_decode_aper;
per_type_encoder_f REAL_encode_aper;
+type_compare_f REAL_compare;
/***********************************
* Some handy conversion routines. *
--- skeletons/RELATIVE-OID.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/RELATIVE-OID.c 2015-11-26 14:56:31.703615000 +0100
@@ -29,7 +29,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_RELATIVE_OID_tags,
sizeof(asn_DEF_RELATIVE_OID_tags)
--- skeletons/T61String.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/T61String.c 2015-11-26 14:57:07.235615000 +0100
@@ -25,7 +25,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_T61String_tags,
sizeof(asn_DEF_T61String_tags)
--- skeletons/TeletexString.c 2015-12-08 14:39:33.338543533 +0100
+++ skeletons/TeletexString.c 2015-11-26 14:57:17.643615000 +0100
@@ -25,7 +25,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_TeletexString_tags,
sizeof(asn_DEF_TeletexString_tags)
--- skeletons/UniversalString.c 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/UniversalString.c 2015-11-26 14:57:29.015615000 +0100
@@ -36,7 +36,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_UniversalString_tags,
sizeof(asn_DEF_UniversalString_tags)
--- skeletons/UTCTime.c 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/UTCTime.c 2015-11-26 14:57:44.127615000 +0100
@@ -41,7 +41,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_UTCTime_tags,
sizeof(asn_DEF_UTCTime_tags)
--- skeletons/UTF8String.c 2015-12-08 14:39:33.314543533 +0100
+++ skeletons/UTF8String.c 2015-11-26 14:06:54.563618000 +0100
@@ -27,6 +27,7 @@
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_UTF8String_tags,
sizeof(asn_DEF_UTF8String_tags)
--- skeletons/VideotexString.c 2015-12-08 14:39:33.342543533 +0100
+++ skeletons/VideotexString.c 2015-11-26 14:07:06.139618000 +0100
@@ -25,7 +25,8 @@
OCTET_STRING_decode_uper, /* Implemented in terms of OCTET STRING */
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_VideotexString_tags,
sizeof(asn_DEF_VideotexString_tags)
--- skeletons/VisibleString.c 2015-12-08 14:39:33.350543533 +0100
+++ skeletons/VisibleString.c 2015-11-26 14:07:15.283618000 +0100
@@ -30,7 +30,8 @@
OCTET_STRING_decode_uper,
OCTET_STRING_encode_uper,
OCTET_STRING_decode_aper,
- OCTET_STRING_encode_aper,
+ OCTET_STRING_encode_aper,
+ OCTET_STRING_compare,
0, /* Use generic outmost tag fetcher */
asn_DEF_VisibleString_tags,
sizeof(asn_DEF_VisibleString_tags)
......@@ -36,7 +36,7 @@ def outputHeaderToFile(f, filename):
f.write("""/*******************************************************************************
Eurecom OpenAirInterface
Copyright(c) 1999 - 2013 Eurecom
Copyright(c) 1999 - 2015 Eurecom
This program is free software; you can redistribute it and/or modify it
under the terms and conditions of the GNU General Public License,
......@@ -250,20 +250,31 @@ for key in iesDefs:
asn1cStruct = re.sub('Item', 'List', asn1cStruct)
keylowerunderscore = re.sub('-', '_', key.lower())
firstlower = re.sub('Item', 'List', re.sub('enb', 'eNB', lowerFirstCamelWord(asn1cStruct)))
f.write("/* %s in iesDefs not in ieofielist.values() */\n" % (key))
f.write("/** \\brief Decode function for %s ies.\n" % (key))
if len(iesDefs[key]["ies"]) != 0:
f.write(" * \\param %s Pointer to ASN1 structure in which data will be stored\n" % (lowerFirstCamelWord(re.sub('-', '_', key))))
f.write(" * \\param any_p Pointer to the ANY value to decode.\n")
f.write(" **/\n")
f.write("int %s_decode_%s(\n" % (fileprefix, keylowerunderscore))
if len(iesDefs[key]["ies"]) != 0:
f.write(" %s_t *%s,\n" % (re.sub('-', '_', key), lowerFirstCamelWord(re.sub('-', '_', key))))
f.write(" ANY_t *any_p);\n\n")
f.write("/* %s in iesDefs not in ieofielist.values() */\n" % (key))
f.write("/** \\brief Compare function for %s ies.\n" % (key))
f.write(" * \\param %s Pointer to the ASN1 structure.\n" % (firstlower))
f.write(" * \\param %s Pointer to the ASN1 structure.\n" % (firstlower))
f.write(" **/\n")
f.write("asn_comp_rval_t * %s_compare_%s(\n" % (fileprefix, keylowerunderscore))
f.write(" %s_t *%s1,\n" % (re.sub('-', '_', key), lowerFirstCamelWord(re.sub('-', '_', key))))
f.write(" %s_t *%s2);\n\n" % (re.sub('-', '_', key), lowerFirstCamelWord(re.sub('-', '_', key))))
if len(iesDefs[key]["ies"]) == 0:
continue
f.write("/* %s in iesDefs not in ieofielist.values() */\n" % (key))
f.write("/** \\brief Encode function for %s ies.\n" % (key))
f.write(" * \\param %s Pointer to the ASN1 structure.\n" % (firstlower))
f.write(" * \\param %s Pointer to the IES structure.\n" % (lowerFirstCamelWord(re.sub('-', '_', key))))
......@@ -272,16 +283,19 @@ for key in iesDefs:
f.write(" %s_t *%s,\n" % (asn1cStruct, firstlower))
f.write(" %s_t *%s);\n\n" % (re.sub('-', '_', key), lowerFirstCamelWord(re.sub('-', '_', key))))
for key in iesDefs:
if key not in ieofielist.values():
continue
asn1cStruct = re.sub('-', '_', re.sub('IEs', '', key))
asn1cStruct = re.sub('Item', 'List', asn1cStruct)
firstlower = re.sub('Item', 'List', re.sub('enb', 'eNB', lowerFirstCamelWord(asn1cStruct)))
f.write("/* %s in iesDefs in ieofielist.values() */\n" % (key))
f.write("/** \\brief Encode function for %s ies.\n" % (key))
f.write(" * \\param %s Pointer to the ASN1 structure.\n" % (firstlower))
f.write(" * \\param %s Pointer to the IES structure.\n" % (lowerFirstCamelWord(re.sub('-', '_', key))))
f.write(" **/\n")
f.write("/* %s in iesDefs in ieofielist.values() */\n" % (key))
f.write("int %s_encode_%s(\n" % (fileprefix, firstlower.lower()))
f.write(" %s_t *%s,\n" % (asn1cStruct, firstlower))
f.write(" %sIEs_t *%sIEs);\n\n" % (asn1cStruct, firstlower))
......@@ -289,9 +303,19 @@ for key in iesDefs:
f.write(" * \\param any_p Pointer to the ANY value to decode.\n")
f.write(" * \\param callback Callback function called when any_p is successfully decoded.\n")
f.write(" **/\n")
f.write("/* %s in iesDefs in ieofielist.values() */\n" % (key))
f.write("int %s_decode_%s(\n" % (fileprefix, firstlower.lower()))
f.write(" %sIEs_t *%sIEs,\n" % (asn1cStruct, firstlower))
f.write(" %s_t *%s);\n\n" % (asn1cStruct, lowerFirstCamelWord(asn1cStruct)))
f.write("/** \\brief Compare function for %s ies.\n" % (key))
f.write(" * \\param %s Pointer to the IES structure.\n" % (firstlower))
f.write(" * \\param %s Pointer to the IES structure.\n" % (firstlower))
f.write(" **/\n")
f.write("asn_comp_rval_t * %s_compare_%s(\n" % (fileprefix, firstlower.lower()))
f.write(" %sIEs_t *%s1,\n" % (asn1cStruct, firstlower))
f.write(" %sIEs_t *%s2);\n\n" % (asn1cStruct, firstlower))
for key in iesDefs:
asn1cStruct = re.sub('-', '_', re.sub('IEs', '', key))
......@@ -704,3 +728,170 @@ for (key, value) in iesDefs.items():
#f.write("cb_failed:\n")
#f.write(" return er;\n")
f.write("}\n\n")
#Generate xer print functions
f = open(outdir + fileprefix + '_compare.c', 'w')
outputHeaderToFile(f, filename)
f.write("#include <stdlib.h>\n")
f.write("#include <stdio.h>\n\n")
f.write("#include <asn_application.h>\n#include <asn_internal.h>\n\n")
f.write("#include \"%s_common.h\"\n#include \"%s_ies_defs.h\"\n" % (fileprefix, fileprefix))
f.write("#include \"%s-ProtocolIE-ID.h\"\n\n" % (fileprefix_first_upper))
for key in iesDefs:
if key in ieofielist.values():
continue
structName = re.sub('ies', '', key)
asn1cStruct = re.sub('-', '_', re.sub('IEs', '', key))
asn1cStruct = re.sub('Item', 'List', asn1cStruct)
if asn1cStruct.rfind('_') == len(asn1cStruct) - 1:
asn1cStruct = asn1cStruct[:-1]
asn1cStructfirstlower = asn1cStruct[:1].lower() + asn1cStruct[1:]
firstwordlower = re.sub('Item', 'List', re.sub('enb', 'eNB', lowerFirstCamelWord(asn1cStruct)))
iesaccess = ""
if key not in ieofielist.values():
iesaccess = "%s_ies." % (firstwordlower)
keyName = re.sub('-', '_', key)
keyupperunderscore = keyName.upper()
# No IE to encode...
if len(iesDefs[key]["ies"]) == 0:
continue
f.write("asn_comp_rval_t * %s_compare_%s(\n" % (fileprefix, re.sub('-', '_', structName.lower())))
f.write(" %s_t *%s1,\n" % (re.sub('-', '_', key), lowerFirstCamelWord(re.sub('-', '_', key))))
f.write(" %s_t *%s2) {\n\n" % (re.sub('-', '_', key), lowerFirstCamelWord(re.sub('-', '_', key))))
f.write(" asn_comp_rval_t *rv = NULL;\n\n")
f.write(" asn_comp_rval_t *rv2 = NULL;\n\n")
f.write(" assert(%s1 != NULL);\n" % (lowerFirstCamelWord(re.sub('-', '_', key))));
f.write(" assert(%s2 != NULL);\n" % (lowerFirstCamelWord(re.sub('-', '_', key))));
loop = 0
for ie in iesDefs[key]["ies"]:
iename = re.sub('-', '_', re.sub('id-', '', ie[0]))
ienameunderscore = re.sub('-', '_', iename)
ienamefirstwordlower = lowerFirstCamelWord(iename)
ieupperunderscore = re.sub('-', '_', re.sub('id-', '', ie[0])).upper()
ietypeunderscore = re.sub('-', '_', ie[2])
if ie[3] != "mandatory":
loop = loop + 1
if loop == 1:
#f.write(" %s_IE_t *ie1 = NULL;\n" % (fileprefix_first_upper))
#f.write(" %s_IE_t *ie2 = NULL;\n" % (fileprefix_first_upper))
f.write(" if (%s1->presenceMask != %s2->presenceMask) {rv=calloc(1,sizeof(asn_comp_rval_t));rv->name = asn_DEF_%s.name;rv->structure1 = %s1;rv->structure2 = %s2;rv->err_code = COMPARE_ERR_CODE_VALUE_NULL; return rv;}\n" % (lowerFirstCamelWord(re.sub('-', '_', key)), lowerFirstCamelWord(re.sub('-', '_', key)), ietypeunderscore, lowerFirstCamelWord(re.sub('-', '_', key)), lowerFirstCamelWord(re.sub('-', '_', key))))
if ie[3] == "optional":
f.write(" /* Optional field */\n")
elif ie[3] == "conditional":
f.write(" /* Conditional field */\n")
f.write(" if (%s1->presenceMask & %s_%s_PRESENT) {\n" % (lowerFirstCamelWord(re.sub('-', '_', key)), keyupperunderscore, ieupperunderscore))
if ie[2] in ieofielist.keys():
f.write(" /* collection field */\n")
f.write(" rv2 = %s_compare_%s(&%s1->%s, &%s2->%s);\n" % (fileprefix, ietypeunderscore.lower(), lowerFirstCamelWord(re.sub('-', '_', key)), ienamefirstwordlower, lowerFirstCamelWord(re.sub('-', '_', key)), ienamefirstwordlower ))
f.write(" if(rv2) {")
f.write(" if (NULL == rv) {")
f.write(" rv = rv2;")
f.write(" } else {")
f.write(" rv2->next = rv;")
f.write(" rv = rv2;")
f.write(" }")
f.write(" rv2 = NULL;")
f.write(" }")
else:
f.write(" /* simple field */\n")
f.write(" rv2 = asn_DEF_%s.compare(&asn_DEF_%s, &%s1->%s, &asn_DEF_%s, &%s2->%s); \n" % (ietypeunderscore, ietypeunderscore, lowerFirstCamelWord(re.sub('-', '_', key)), ienamefirstwordlower, ietypeunderscore, lowerFirstCamelWord(re.sub('-', '_', key)), ienamefirstwordlower ))
f.write(" if (rv2) {")
f.write(" if (NULL == rv) {")
f.write(" rv = rv2;")
f.write(" } else {")
f.write(" rv2->next = rv;")
f.write(" rv = rv2;")
f.write(" }")
f.write(" rv2 = NULL;")
f.write(" if (!rv->name) rv->name = asn_DEF_%s.name;" % (ietypeunderscore))
f.write(" }")
f.write(" assert(0);\n");
f.write(" }\n\n")
else:
if ie[2] in ieofielist.keys():
f.write(" /* Mandatory collection field */\n")
f.write(" rv2 = %s_compare_%s(&%s1->%s, &%s2->%s);\n" % (fileprefix, ietypeunderscore.lower(), lowerFirstCamelWord(re.sub('-', '_', key)), ienamefirstwordlower, lowerFirstCamelWord(re.sub('-', '_', key)), ienamefirstwordlower ))
f.write(" if (rv2) {\n")
f.write(" if (NULL == rv) {\n")
f.write(" rv = rv2;\n")
f.write(" } else {\n")
f.write(" rv2->next = rv;\n")
f.write(" rv = rv2;\n")
f.write(" }\n")
f.write(" rv2 = NULL;\n")
f.write(" }\n")
else:
f.write(" /* Mandatory simple field */\n")
f.write(" rv2 = asn_DEF_%s.compare(&asn_DEF_%s, &%s1->%s, &asn_DEF_%s, &%s2->%s);\n" % (ietypeunderscore, ietypeunderscore, lowerFirstCamelWord(re.sub('-', '_', key)), ienamefirstwordlower, ietypeunderscore, lowerFirstCamelWord(re.sub('-', '_', key)), ienamefirstwordlower ))
f.write(" if(rv2) {\n")
f.write(" if (NULL == rv) {\n")
f.write(" rv = rv2;\n")
f.write(" } else {\n")
f.write(" rv2->next = rv;\n")
f.write(" rv = rv2;\n")
f.write(" }\n")
f.write(" rv2 = NULL;\n")
f.write(" if (!rv->name) rv->name = asn_DEF_%s.name;\n" % (ietypeunderscore))
f.write(" }\n")
f.write(" return rv;\n")
f.write("}\n\n")
for (key, value) in iesDefs.items():
if key not in ieofielist.values():
continue
ie = value["ies"][0]
ietypeunderscore = re.sub('-', '_', ie[2])
asn1cStruct = re.sub('-', '_', re.sub('IEs', '', re.sub('-IEs', '', key)))
asn1cStruct = re.sub('Item', 'List', asn1cStruct)
firstwordlower = re.sub('Item', 'List', re.sub('enb', 'eNB', lowerFirstCamelWord(asn1cStruct)))
for (i, j) in ieofielist.items():
if j == key:
break
f.write("extern asn_TYPE_descriptor_t asn_DEF_%s;\n" % (ietypeunderscore))
f.write("asn_comp_rval_t * %s_compare_%s(\n" % (fileprefix, re.sub('-', '_', i).lower()))
f.write(" %sIEs_t *%sIEs1,\n" % (re.sub('-', '_', i), lowerFirstCamelWord(re.sub('-', '_', i))))
f.write(" %sIEs_t *%sIEs2) {\n\n" % (re.sub('-', '_', i), lowerFirstCamelWord(re.sub('-', '_', i))))
f.write(" int i;\n")
f.write(" asn_comp_rval_t *rv = NULL;\n\n")
f.write(" asn_comp_rval_t *rv2 = NULL;\n\n")
f.write(" assert(%sIEs1 != NULL);\n" % (lowerFirstCamelWord(re.sub('-', '_', i))));
f.write(" assert(%sIEs2 != NULL);\n\n" % (lowerFirstCamelWord(re.sub('-', '_', i))));
f.write(" for (i = 0; i < %sIEs1->%s.count; i++) {\n" % (lowerFirstCamelWord(re.sub('-', '_', i)), re.sub('IEs', '', lowerFirstCamelWord(re.sub('-', '_', key)))))
f.write(" rv2 = asn_DEF_%s.compare(&asn_DEF_%s, %sIEs1->%s.array[i], &asn_DEF_%s, %sIEs2->%s.array[i]);\n" % (ietypeunderscore, ietypeunderscore, lowerFirstCamelWord(re.sub('-', '_', i)), re.sub('IEs', '', lowerFirstCamelWord(re.sub('-', '_', key))), ietypeunderscore, lowerFirstCamelWord(re.sub('-', '_', i)), re.sub('IEs', '', lowerFirstCamelWord(re.sub('-', '_', key)))))
f.write(" if(rv2) {")
f.write(" if (NULL == rv) {")
f.write(" rv = rv2;")
f.write(" } else {")
f.write(" rv2->next = rv;")
f.write(" rv = rv2;")
f.write(" }")
f.write(" rv2 = NULL;")
f.write(" }")
f.write(" }\n")
f.write(" return rv;\n")
f.write("}\n\n")
......@@ -72,9 +72,9 @@ s1ap_eNB_config_t s1ap_config;
static int s1ap_eNB_generate_s1_setup_request(
s1ap_eNB_instance_t *instance_p, s1ap_eNB_mme_data_t *s1ap_mme_data_p);
static
void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *s1ap_register_eNB);
static
void s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp);
uint32_t s1ap_generate_eNB_id(void)
......@@ -150,7 +150,7 @@ static void s1ap_eNB_register_mme(s1ap_eNB_instance_t *instance_p,
itti_send_msg_to_task(TASK_SCTP, instance_p->instance, message_p);
}
static
void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *s1ap_register_eNB)
{
s1ap_eNB_instance_t *new_instance;
......@@ -210,7 +210,6 @@ void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *
}
}
static
void s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp)
{
s1ap_eNB_instance_t *instance_p;
......
......@@ -100,6 +100,7 @@ static STAILQ_HEAD(sctp_cnx_list_head, sctp_cnx_list_elm_s) sctp_cnx_list;
static uint16_t sctp_nb_cnx = 0;
//------------------------------------------------------------------------------
struct sctp_cnx_list_elm_s *sctp_get_cnx(int32_t assoc_id, int sd)
{
struct sctp_cnx_list_elm_s *elm;
......@@ -119,6 +120,7 @@ struct sctp_cnx_list_elm_s *sctp_get_cnx(int32_t assoc_id, int sd)
return NULL;
}
//------------------------------------------------------------------------------
void
sctp_handle_new_association_req(
const instance_t instance,
......@@ -388,6 +390,7 @@ sctp_handle_new_association_req(
sd, sctp_nb_cnx, assoc_id);
}
//------------------------------------------------------------------------------
void sctp_send_data(
instance_t instance,
task_id_t task_id,
......@@ -430,6 +433,7 @@ void sctp_send_data(
sctp_cnx->assoc_id);
}
//------------------------------------------------------------------------------
static int sctp_close_association(
const instance_t instance,
const task_id_t requestor,
......@@ -456,6 +460,7 @@ static int sctp_close_association(
return 0;
}
//------------------------------------------------------------------------------
static int sctp_create_new_listener(
const instance_t instance,
const task_id_t requestor,
......@@ -580,6 +585,7 @@ err:
return -1;
}
//------------------------------------------------------------------------------
static inline
void
sctp_eNB_accept_associations(
......@@ -646,6 +652,7 @@ sctp_eNB_accept_associations(
}
}
//------------------------------------------------------------------------------
static inline
void
sctp_eNB_read_from_socket(
......@@ -770,6 +777,7 @@ sctp_eNB_read_from_socket(
}
}
//------------------------------------------------------------------------------
void
sctp_eNB_flush_sockets(
struct epoll_event *events, int nb_events)
......@@ -799,6 +807,7 @@ sctp_eNB_flush_sockets(
}
//------------------------------------------------------------------------------
void *sctp_eNB_task(void *arg)
{
int nb_events;
......
This source diff could not be displayed because it is too large. You can view the blob instead.
Active_eNBs = ( "eNB_Eurecom_LTEBox");
# Asn1_verbosity, choice in: none, info, annoying
Asn1_verbosity = "none";
eNBs =
(
{
////////// Identification parameters:
eNB_ID = 0xe00;
cell_type = "CELL_MACRO_ENB";
eNB_name = "eNB_Eurecom_LTEBox";
// Tracking area code, 0x0000 and 0xfffe are reserved values
tracking_area_code = "1";
mobile_country_code = "208";
mobile_network_code = "95";
////////// Physical parameters:
component_carriers = (
{
frame_type = "FDD";
tdd_config = 3;
tdd_config_s = 0;
prefix_type = "NORMAL";
eutra_band = 7;
downlink_frequency = 2660000000L;
uplink_frequency_offset = -120000000;
Nid_cell = 0;
N_RB_DL = 25;
Nid_cell_mbsfn = 0;
nb_antennas_tx = 1;
nb_antennas_rx = 1;
tx_gain = 90;
rx_gain = 120;
prach_root = 0;
prach_config_index = 0;
prach_high_speed = "DISABLE";
prach_zero_correlation = 1;
prach_freq_offset = 2;
pucch_delta_shift = 1;
pucch_nRB_CQI = 1;
pucch_nCS_AN = 0;
pucch_n1_AN = 32;
pdsch_referenceSignalPower = -26;
pdsch_p_b = 0;
pusch_n_SB = 1;
pusch_enable64QAM = "DISABLE";
pusch_hoppingMode = "interSubFrame";
pusch_hoppingOffset = 0;
pusch_groupHoppingEnabled = "ENABLE";
pusch_groupAssignment = 0;
pusch_sequenceHoppingEnabled = "DISABLE";
pusch_nDMRS1 = 1;
phich_duration = "NORMAL";
phich_resource = "ONESIXTH";
srs_enable = "DISABLE";
/* srs_BandwidthConfig =;
srs_SubframeConfig =;
srs_ackNackST =;
srs_MaxUpPts =;*/
pusch_p0_Nominal = -90;
pusch_alpha = "AL1";
pucch_p0_Nominal = -108;
msg3_delta_Preamble = 6;
pucch_deltaF_Format1 = "deltaF2";
pucch_deltaF_Format1b = "deltaF3";
pucch_deltaF_Format2 = "deltaF0";
pucch_deltaF_Format2a = "deltaF0";
pucch_deltaF_Format2b = "deltaF0";
rach_numberOfRA_Preambles = 64;
rach_preamblesGroupAConfig = "DISABLE";
/*
rach_sizeOfRA_PreamblesGroupA = ;
rach_messageSizeGroupA = ;
rach_messagePowerOffsetGroupB = ;
*/
rach_powerRampingStep = 4;
rach_preambleInitialReceivedTargetPower = -108;
rach_preambleTransMax = 10;
rach_raResponseWindowSize = 10;
rach_macContentionResolutionTimer = 48;
rach_maxHARQ_Msg3Tx = 4;
pcch_default_PagingCycle = 128;
pcch_nB = "oneT";
bcch_modificationPeriodCoeff = 2;
ue_TimersAndConstants_t300 = 1000;
ue_TimersAndConstants_t301 = 1000;
ue_TimersAndConstants_t310 = 1000;
ue_TimersAndConstants_t311 = 10000;
ue_TimersAndConstants_n310 = 20;
ue_TimersAndConstants_n311 = 1;
}
);
srb1_parameters :
{
# timer_poll_retransmit = (ms) [5, 10, 15, 20,... 250, 300, 350, ... 500]
timer_poll_retransmit = 80;
# timer_reordering = (ms) [0,5, ... 100, 110, 120, ... ,200]
timer_reordering = 35;
# timer_reordering = (ms) [0,5, ... 250, 300, 350, ... ,500]
timer_status_prohibit = 0;
# poll_pdu = [4, 8, 16, 32 , 64, 128, 256, infinity(>10000)]
poll_pdu = 4;
# poll_byte = (kB) [25,50,75,100,125,250,375,500,750,1000,1250,1500,2000,3000,infinity(>10000)]
poll_byte = 99999;
# max_retx_threshold = [1, 2, 3, 4 , 6, 8, 16, 32]
max_retx_threshold = 4;
}
# ------- SCTP definitions
SCTP :
{
# Number of streams to use in input/output
SCTP_INSTREAMS = 2;
SCTP_OUTSTREAMS = 2;
};
////////// MME parameters:
mme_ip_address = ( { ipv4 = "192.188.2.2";
ipv6 = "192:168:30::17";
active = "yes";
preference = "ipv4";
}
);
NETWORK_INTERFACES :
{
ENB_INTERFACE_NAME_FOR_S1_MME = "tun2";
ENB_IPV4_ADDRESS_FOR_S1_MME = "192.188.2.2/24";
ENB_INTERFACE_NAME_FOR_S1U = "lo";
ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.1/24";
ENB_PORT_FOR_S1U = 2153; # Spec 2152
};
log_config :
{
global_log_level ="info";
global_log_verbosity ="medium";
hw_log_level ="info";
hw_log_verbosity ="medium";
phy_log_level ="info";
phy_log_verbosity ="medium";
mac_log_level ="info";
mac_log_verbosity ="high";
rlc_log_level ="info";
rlc_log_verbosity ="medium";
pdcp_log_level ="info";
pdcp_log_verbosity ="medium";
rrc_log_level ="info";
rrc_log_verbosity ="medium";
gtpu_log_level ="info";
gtpu_log_verbosity ="medium";
udp_log_level ="info";
udp_log_verbosity ="medium";
};
}
);
......@@ -36,18 +36,33 @@
*/
#include <string.h>
#include <limits.h>
#include <libconfig.h>
#include <inttypes.h>
#include <getopt.h>
#include <libgen.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <libxml/xmlmemory.h>
#include <libxml/debugXML.h>
#include <libxml/HTMLtree.h>
#include <libxml/xmlIO.h>
#include <libxml/DOCBparser.h>
#include <libxml/xinclude.h>
#include <libxml/catalog.h>
#include <libxslt/xslt.h>
#include <libxslt/xsltInternals.h>
#include <libxslt/transform.h>
#include <libxslt/xsltutils.h>
#include "assertions.h"
#include "enb_config.h"
#include "generate_scenario.h"
#include "s1ap_eNB.h"
#if defined(ENABLE_ITTI)
# include "intertask_interface.h"
#endif
#define EPC_TEST_SCENARIO_MAX_ENB 2
#include "intertask_interface.h"
#define ENB_CONFIG_STRING_ACTIVE_ENBS "Active_eNBs"
......@@ -79,29 +94,201 @@
#define ENB_CONFIG_STRING_ENB_PORT_FOR_S1U "ENB_PORT_FOR_S1U"
#define ENB_CONFIG_MAX_XSLT_PARAMS 32
Enb_properties_array_t g_enb_properties;
char *g_test_dir = NULL;
char *g_pdml_in_origin = NULL;
extern int xmlLoadExtDtdDefaultValue;
#define GENERATE_PDML_FILE 1
#define GENERATE_SCENARIO 2
#define GS_IS_FILE 1
#define GS_IS_DIR 2
//------------------------------------------------------------------------------
static void enb_config_display(void)
// test if file exist in current directory
int is_file_exists( const char const * file_nameP, const char const *file_roleP)
{
struct stat s;
int err = stat(file_nameP, &s);
if(-1 == err) {
if(ENOENT == errno) {
fprintf(stderr, "Please provide a valid %s, %s does not exist\n", file_roleP, file_nameP);
} else {
perror("stat");
exit(1);
}
} else {
if(S_ISREG(s.st_mode)) {
return GS_IS_FILE;
} else if(S_ISDIR(s.st_mode)) {
return GS_IS_DIR;
} else {
fprintf(stderr, "Please provide a valid test %s, %s exists but is not found valid\n", file_roleP, file_nameP);
}
}
return 0;
}
//------------------------------------------------------------------------------
int strip_extension(char *in_filename)
{
static const uint8_t name_min_len = 1;
static const uint8_t max_ext_len = 5; // .pdml !
fprintf(stdout, "strip_extension %s\n", in_filename);
if (NULL != in_filename) {
/* Check chars starting at end of string to find last '.' */
for (ssize_t i = strlen(in_filename); i >= name_min_len; i--) {
if (in_filename[i] == '.') {
in_filename[i] = '\0';
return i;
}
}
}
return -1;
}
//------------------------------------------------------------------------------
// return number of splitted items
int split_path( char * pathP, char *** resP)
{
char * saveptr1;
char * p = strtok_r (pathP, "/", &saveptr1);
int n_spaces = 0;
/// split string and append tokens to 'res'
while (p) {
*resP = realloc (*resP, sizeof (char*) * ++n_spaces);
AssertFatal (*resP, "realloc failed");
(*resP)[n_spaces-1] = p;
p = strtok_r (NULL, "/", &saveptr1);
}
return n_spaces;
}
//------------------------------------------------------------------------------
int generate_test_scenario(const char const * test_nameP, const char const * pdml_in_basenameP)
//------------------------------------------------------------------------------
{
//int fd_pdml_in;
xsltStylesheetPtr cur = NULL;
xmlDocPtr doc, res;
FILE *test_scenario_file = NULL;
const char test_scenario_filename[NAME_MAX];
const char *params[2*ENB_CONFIG_MAX_XSLT_PARAMS];
int nb_params = 0;
int i,j;
char astring[1024];
char *astring2 = NULL;
struct in_addr addr;
memset(test_scenario_filename, 0, sizeof(test_scenario_filename));
memset(astring, 0, sizeof(astring));
if (getcwd(astring, sizeof(astring)) != NULL) {
fprintf(stdout, "working in %s directory\n", astring);
} else {
perror("getcwd() error");
exit(1);
}
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
cur = xsltParseStylesheetFile("/usr/share/oai/xsl/generic_scenario.xsl");
if (NULL == cur) {
AssertFatal (0, "Could not parse stylesheet file /usr/share/oai/xsl/generic_scenario.xsl!\n");
} else {
fprintf(stdout, "XSLT style sheet: /usr/share/oai/xsl/generic_scenario.xsl\n");
}
doc = xmlParseFile(pdml_in_basenameP);
if (NULL == doc) {
AssertFatal (0, "Could not parse pdml file %s!\n", pdml_in_basenameP);
} else {
fprintf(stdout, "pdml file: %s\n", pdml_in_basenameP);
}
params[nb_params++] = "test_name";
sprintf(astring, "%s", pdml_in_basenameP);
if (strip_extension(astring) > 0) {
astring2 = strdup(astring);
sprintf(astring, "\"%s\"", astring2);
free(astring2);
astring2 = NULL;
} else {
fprintf(stderr, "Assigning test name failed: %s\n", astring);
}
params[nb_params++] = strdup(astring);
for (i = 0; i < g_enb_properties.number; i++) {
// eNB S1-C IPv4 address
sprintf(astring, "enb%d_s1c", i);
params[nb_params++] = strdup(astring);
addr.s_addr = g_enb_properties.properties[i]->enb_ipv4_address_for_S1_MME;
sprintf(astring, "\"%s\"", inet_ntoa(addr));
params[nb_params++] = strdup(astring);
// MME S1-C IPv4 address
for (j = 0; j < g_enb_properties.properties[i]->nb_mme; j++) {
sprintf(astring, "mme%d_s1c_%d", i, j);
params[nb_params++] = strdup(astring);
AssertFatal (g_enb_properties.properties[i]->mme_ip_address[j].ipv4_address,
"Only support MME IPv4 address\n");
sprintf(astring, "\"%s\"", g_enb_properties.properties[i]->mme_ip_address[j].ipv4_address);
params[nb_params++] = strdup(astring);
}
}
params[nb_params] = NULL;
res = xsltApplyStylesheet(cur, doc, params);
if (NULL != res) {
// since pdml filename is not relative (no path), just filename in current directory we can safely remove
sprintf(test_scenario_filename,"%s",pdml_in_basenameP);
if (strip_extension(test_scenario_filename) > 0) {
strcat(test_scenario_filename, ".xml");
test_scenario_file = fopen( test_scenario_filename, "w+");
if (NULL != test_scenario_file) {
xsltSaveResultToFile(test_scenario_file, res, cur);
fclose(test_scenario_file);
fprintf(stdout, "Wrote test scenario to %s\n", test_scenario_filename);
} else {
fprintf(stderr, "Error in fopen(%s)\n", test_scenario_filename);
}
} else {
fprintf(stderr, "Error in strip_extension()\n");
}
} else {
fprintf(stderr, "Error in xsltApplyStylesheet()\n");
}
xsltFreeStylesheet(cur);
xmlFreeDoc(res);
xmlFreeDoc(doc);
xsltCleanupGlobals();
xmlCleanupParser();
}
//------------------------------------------------------------------------------
static void enb_config_display(void)
//------------------------------------------------------------------------------
{
int i;
printf( "\n----------------------------------------------------------------------\n");
printf( " ENB CONFIG FILE CONTENT LOADED (TBC):\n");
printf( " ENB CONFIG FILE CONTENT LOADED:\n");
printf( "----------------------------------------------------------------------\n");
for (i = 0; i < g_enb_properties.number; i++) {
printf( "ENB CONFIG for instance %u:\n\n", i);
printf( "\teNB name: \t%s:\n",g_enb_properties.properties[i]->eNB_name);
printf( "\teNB ID: \t%"PRIu32":\n",g_enb_properties.properties[i]->eNB_id);
printf( "\tCell type: \t%s:\n",g_enb_properties.properties[i]->cell_type == CELL_MACRO_ENB ? "CELL_MACRO_ENB":"CELL_HOME_ENB");
printf( "\tTAC: \t%"PRIu16":\n",g_enb_properties.properties[i]->tac);
printf( "\tMCC: \t%"PRIu16":\n",g_enb_properties.properties[i]->mcc);
printf( "\teNB name: \t%s\n",g_enb_properties.properties[i]->eNB_name);
printf( "\teNB ID: \t%"PRIu32"\n",g_enb_properties.properties[i]->eNB_id);
printf( "\tCell type: \t%s\n",g_enb_properties.properties[i]->cell_type == CELL_MACRO_ENB ? "CELL_MACRO_ENB":"CELL_HOME_ENB");
printf( "\tTAC: \t%"PRIu16"\n",g_enb_properties.properties[i]->tac);
printf( "\tMCC: \t%"PRIu16"\n",g_enb_properties.properties[i]->mcc);
if (g_enb_properties.properties[i]->mnc_digit_length == 3) {
printf( "\tMNC: \t%03"PRIu16":\n",g_enb_properties.properties[i]->mnc);
printf( "\tMNC: \t%03"PRIu16"\n",g_enb_properties.properties[i]->mnc);
} else {
printf( "\tMNC: \t%02"PRIu16":\n",g_enb_properties.properties[i]->mnc);
printf( "\tMNC: \t%02"PRIu16"\n",g_enb_properties.properties[i]->mnc);
}
printf( "\n--------------------------------------------------------\n");
}
......@@ -114,13 +301,12 @@ static void enb_config_display(void)
#define libconfig_int int
#endif
//------------------------------------------------------------------------------
const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
void enb_config_init(const char const * lib_config_file_name_pP)
//------------------------------------------------------------------------------
{
config_t cfg;
config_setting_t *setting = NULL;
config_setting_t *subsetting = NULL;
config_setting_t *setting_srb1 = NULL;
config_setting_t *setting_mme_addresses = NULL;
config_setting_t *setting_mme_address = NULL;
config_setting_t *setting_enb = NULL;
......@@ -128,8 +314,6 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
int enb_properties_index = 0;
int num_enbs = 0;
int num_mme_address = 0;
int num_otg_elements =0;
int num_component_carriers =0;
int i = 0;
int j = 0;
int parse_errors = 0;
......@@ -139,12 +323,6 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
const char* enb_name = NULL;
const char* mcc = 0;
const char* mnc = 0;
const char* frame_type = NULL;
const char* prefix_type = NULL;
libconfig_int Nid_cell = 0;
libconfig_int my_int;
char* ipv4 = NULL;
char* ipv6 = NULL;
char* active = NULL;
......@@ -157,22 +335,21 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
char* enb_ipv4_address_for_S1_MME = NULL;
char *address = NULL;
char *cidr = NULL;
char *astring = NULL;
AssertFatal (lib_config_file_name_pP != NULL,
"Bad parameter lib_config_file_name_pP %s , must reference a valid eNB config file\n",
lib_config_file_name_pP);
memset((char*)active_enb, 0 , EPC_TEST_SCENARIO_MAX_ENB * sizeof(char*));
config_init(&cfg);
if (lib_config_file_name_pP != NULL) {
/* Read the file. If there is an error, report it and exit. */
if (! config_read_file(&cfg, lib_config_file_name_pP)) {
config_destroy(&cfg);
AssertFatal (0, "Failed to parse eNB configuration file %s!\n", lib_config_file_name_pP);
}
} else {
config_destroy(&cfg);
AssertFatal (0, "No eNB configuration file provided!\n");
}
// Get list of active eNBs, (only these will be configured)
setting = config_lookup(&cfg, ENB_CONFIG_STRING_ACTIVE_ENBS);
......@@ -195,7 +372,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
setting = config_lookup(&cfg, ENB_CONFIG_STRING_ENB_LIST);
if (setting != NULL) {
enb_properties_index = 0;
enb_properties_index = g_enb_properties.number;
parse_errors = 0;
num_enbs = config_setting_length(setting);
......@@ -332,31 +509,19 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
IPV4_STR_ADDR_TO_INT_NWBO ( address, g_enb_properties.properties[enb_properties_index]->enb_ipv4_address_for_S1_MME, "BAD IP ADDRESS FORMAT FOR eNB S1_MME !\n" );
}
}
}
}
}
}
}
} // if (subsetting != NULL) {
enb_properties_index += 1;
} // if (strcmp(active_enb[j], enb_name) == 0)
} // for (j=0; j < num_enb_properties; j++)
} // for (i = 0; i < num_enbs; i++)
} // if (setting != NULL) {
g_enb_properties.number = num_enb_properties;
g_enb_properties.number += num_enb_properties;
AssertError (enb_properties_index == num_enb_properties, parse_errors ++,
"Failed to parse eNB configuration file %s, mismatch between %u active eNBs and %u corresponding defined eNBs !\n",
lib_config_file_name_pP, num_enb_properties, enb_properties_index);
AssertFatal (parse_errors == 0,
"Failed to parse eNB configuration file %s, found %d error%s !\n",
lib_config_file_name_pP, parse_errors, parse_errors > 1 ? "s" : "");
enb_config_display();
return &g_enb_properties;
}
//------------------------------------------------------------------------------
const Enb_properties_array_t *enb_config_get(void)
//------------------------------------------------------------------------------
{
return &g_enb_properties;
}
......@@ -366,19 +531,41 @@ static void usage (
char *argv[])
//------------------------------------------------------------------------------
{
fprintf (stdout, "Please report any bug to: openair4g-devel@lists.eurecom.fr\n\n");
fprintf (stdout, "Please report any bug to: %s\n",PACKAGE_BUGREPORT);
fprintf (stdout, "Usage: %s [options]\n\n", argv[0]);
fprintf (stdout, "Available options:\n");
fprintf (stdout, "\t--help, -h Print this help and return\n");
fprintf (stdout, "\t--test-dir <path>\n");
fprintf (stdout, " Set the test directory where pdml and original enb(s) config files are located\n");
fprintf (stdout, " See README in openair3/TEST/EPC_TEST\n");
fprintf (stdout, "\t--new-enb-conf-file <file>\n");
fprintf (stdout, " Provide an updated eNB config file for generating a copy of the original test\n");
fprintf (stdout, " This option is set as many times as there are some eNB in the original test\n");
fprintf (stdout, "\n");
fprintf (stdout, "Mandatory options:\n");
fprintf (stdout, "\t-c | --enb-conf-file <file> Provide the old eNB config file for generating a copy of the original test\n");
fprintf (stdout, "\t-d | --test-dir <dir> Directory where a set of files related to a particular test are located\n");
fprintf (stdout, "\t-p | --pdml <file> File name (with no path) in 'test-dir' directory of an original scenario that has to be reworked (IP addresses) with new testbed\n");
fprintf (stdout, "\n");
fprintf (stdout, "Other options:\n");
fprintf (stdout, "\t-h | --help Print this help and return\n");
fprintf (stdout, "\t-v | --version Print informations about the version of this executable\n");
fprintf (stdout, "\n");
fprintf (stdout, "Example of generate_scenario use case: \n");
fprintf (stdout, "\n");
fprintf (stdout, " Generate a generix xml scenario from a captured pcap file: \n");
fprintf (stdout, " +---------------------+ \n");
fprintf (stdout, " |captured pcap-ng file| \n");
fprintf (stdout, " +----------+----------+ \n");
fprintf (stdout, " |\n");
fprintf (stdout, " mme_test_s1_pcap2pdml --pcap_file <`captured pcap-ng file`>\n");
fprintf (stdout, " |\n");
fprintf (stdout, " +--------V----------+ +--------------------+\n");
fprintf (stdout, " |'pdml-in-orig' file| |'enb-conf-file' file|\n");
fprintf (stdout, " +--------+----------+ +--------------------+\n");
fprintf (stdout, " | |\n");
fprintf (stdout, " +----------------------------+\n");
fprintf (stdout, " |\n");
fprintf (stdout, " generate_scenario -d <dir> -p <'pdml-in-orig' file> -c <'enb-conf-file' file> \n");
fprintf (stdout, " |\n");
fprintf (stdout, " +------------V--------------+\n");
fprintf (stdout, " +'xml-test-scenario' file |\n");
fprintf (stdout, " +---------------------------+\n");
fprintf (stdout, "\n");
}
//------------------------------------------------------------------------------
int
config_parse_opt_line (
......@@ -387,65 +574,119 @@ config_parse_opt_line (
//------------------------------------------------------------------------------
{
int option;
int rv = 0;
char *enb_config_file_name = NULL;
char *test_dir = NULL;
char *pdml_in_file_name = NULL;
char *test_dir_name = NULL;
enum long_option_e {
LONG_OPTION_START = 0x100, /* Start after regular single char options */
LONG_OPTION_ENB_CONF_FILE,
LONG_OPTION_PDML,
LONG_OPTION_TEST_DIR,
LONG_OPTION_NEW_ENB_CONF_FILE,
LONG_OPTION_HELP,
LONG_OPTION_VERSION,
};
static struct option long_options[] = {
{"enb-conf-file", required_argument, 0, LONG_OPTION_ENB_CONF_FILE},
{"pdml ", required_argument, 0, LONG_OPTION_PDML},
{"test-dir", required_argument, 0, LONG_OPTION_TEST_DIR},
{"new-enb-conf-file", required_argument, 0, LONG_OPTION_NEW_ENB_CONF_FILE},
{"help", required_argument, 0, LONG_OPTION_HELP},
{"help", no_argument, 0, LONG_OPTION_HELP},
{"version", no_argument, 0, LONG_OPTION_VERSION},
{NULL, 0, NULL, 0}
};
/*
* Parsing command line
*/
while ((option = getopt_long (argc, argv, "h", long_options, NULL)) != -1) {
while ((option = getopt_long (argc, argv, "vhp:n:c:s:d:", long_options, NULL)) != -1) {
switch (option) {
case LONG_OPTION_TEST_DIR:
case LONG_OPTION_ENB_CONF_FILE:
case 'c':
if (optarg) {
test_dir = strdup(optarg);
printf("TEST DIRECTORY IS %s\n", test_dir);
enb_config_file_name = optarg;
printf("eNB config file name is %s\n", enb_config_file_name);
rv |= GENERATE_SCENARIO;
}
break;
case LONG_OPTION_NEW_ENB_CONF_FILE:
case LONG_OPTION_PDML:
case 'p':
if (optarg) {
enb_config_file_name = strdup(optarg);
printf("eNB config file name is %s\n", enb_config_file_name);
enb_config_init(enb_config_file_name);
pdml_in_file_name = strdup(optarg);
printf("PDML input file name is %s\n", pdml_in_file_name);
rv |= GENERATE_SCENARIO;
}
break;
case LONG_OPTION_TEST_DIR:
case 'd':
if (optarg) {
test_dir = strdup(optarg);
printf("TEST DIRECTORY IS %s\n", test_dir);
test_dir_name = strdup(optarg);
if (is_file_exists(test_dir_name, "test dirname") != GS_IS_DIR) {
fprintf(stderr, "Please provide a valid test dirname, %s is not a valid directory name\n", test_dir_name);
exit(1);
}
printf("Test dir name is %s\n", test_dir_name);
}
break;
case LONG_OPTION_VERSION:
case 'v':
printf("Version %s\n", PACKAGE_VERSION);
exit (0);
break;
case LONG_OPTION_HELP:
case 'h': /* Fall through */
case 'h':
default:
usage (argc, argv);
exit (0);
}
}
return 0;
if (NULL == test_dir_name) {
fprintf(stderr, "Please provide a valid test dirname\n");
exit(1);
}
g_test_dir = test_dir_name; test_dir_name = NULL;
if (chdir(g_test_dir) != 0) {
fprintf(stderr, "Error: chdir %s returned %s\n", g_test_dir, strerror(errno));
exit(1);
}
if (rv & GENERATE_SCENARIO) {
if (NULL == enb_config_file_name) {
fprintf(stderr, "Error: please provide the original eNB config file name that should be in %s\n", g_test_dir);
}
if (is_file_exists(enb_config_file_name, "ENB config file") != GS_IS_FILE) {
fprintf(stderr, "Error: eNB config file name %s is not found in dir %s\n", enb_config_file_name, g_test_dir);
}
enb_config_init(enb_config_file_name);
//enb_config_display();
if (NULL == pdml_in_file_name) {
fprintf(stderr, "Error: please provide the PDML file name that should be in %s\n", g_test_dir);
}
if (is_file_exists(pdml_in_file_name, "PDML file") != GS_IS_FILE) {
fprintf(stderr, "Error: PDML file name %s is not found in dir %s\n", pdml_in_file_name, g_test_dir);
}
g_pdml_in_origin = pdml_in_file_name; pdml_in_file_name = NULL;
}
return rv;
}
//------------------------------------------------------------------------------
int main( int argc, char **argv )
//------------------------------------------------------------------------------
{
int actions = 0;
memset((char*) &g_enb_properties, 0 , sizeof(g_enb_properties));
config_parse_opt_line (argc, argv); //Command-line options
actions = config_parse_opt_line (argc, argv); //Command-line options
if (actions & GENERATE_SCENARIO) {
generate_test_scenario(g_test_dir, g_pdml_in_origin);
}
return 0;
}
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
generate_scenario.h
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#ifndef GENERATE_SCENARIO_H_
#define GENERATE_SCENARIO_H_
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "commonDef.h"
#include "platform_types.h"
#include "platform_constants.h"
#include "PHY/impl_defs_lte.h"
#include "s1ap_messages_types.h"
#ifdef CMAKER
#include "SystemInformationBlockType2.h"
#else
#include "RRC/LITE/MESSAGES/SystemInformationBlockType2.h"
#endif
#define IPV4_STR_ADDR_TO_INT_NWBO(AdDr_StR,NwBo,MeSsAgE ) do {\
struct in_addr inp;\
if ( inet_aton(AdDr_StR, &inp ) < 0 ) {\
AssertFatal (0, MeSsAgE);\
} else {\
NwBo = inp.s_addr;\
}\
} while (0);
/** @defgroup _enb_app ENB APP
* @ingroup _oai2
* @{
*/
// Hard to find a defined value for max enb...
#define EPC_TEST_SCENARIO_MAX_ENB 4
typedef struct mme_ip_address_s {
unsigned ipv4:1;
unsigned ipv6:1;
unsigned active:1;
char *ipv4_address;
char *ipv6_address;
} mme_ip_address_t;
typedef struct Enb_properties_s {
/* Unique eNB_id to identify the eNB within EPC.
* For macro eNB ids this field should be 20 bits long.
* For home eNB ids this field should be 28 bits long.
*/
uint32_t eNB_id;
/* The type of the cell */
enum cell_type_e cell_type;
/* Optional name for the cell
* NOTE: the name can be NULL (i.e no name) and will be cropped to 150
* characters.
*/
char *eNB_name;
/* Tracking area code */
uint16_t tac;
/* Mobile Country Code
* Mobile Network Code
*/
uint16_t mcc;
uint16_t mnc;
uint8_t mnc_digit_length;
/* Nb of MME to connect to */
uint8_t nb_mme;
/* List of MME to connect to */
mme_ip_address_t mme_ip_address[S1AP_MAX_NB_MME_IP_ADDRESS];
int sctp_in_streams;
int sctp_out_streams;
char *enb_interface_name_for_S1U;
in_addr_t enb_ipv4_address_for_S1U;
tcp_udp_port_t enb_port_for_S1U;
char *enb_interface_name_for_S1_MME;
in_addr_t enb_ipv4_address_for_S1_MME;
} Enb_properties_t;
typedef struct Enb_properties_array_s {
int number;
Enb_properties_t *properties[EPC_TEST_SCENARIO_MAX_ENB];
} Enb_properties_array_t;
void enb_config_init(const char const * lib_config_file_name_pP);
#endif /* ENB_CONFIG_H_ */
/** @} */
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import subprocess
import re
import socket
import datetime
from datetime import date
import os, errno
import argparse
import tempfile
from lxml import etree
from xml.dom.minidom import parse, parseString
#####################
# program arguments
#####################
parser = argparse.ArgumentParser()
parser.add_argument("--pcap_file", "-p", type=str,help="input pcap file to be translated")
args = parser.parse_args()
#####################
# get xml document from pcap
#####################
orig_pcap_file_name = args.pcap_file.strip()
orig_pdml_string = subprocess.check_output(["tshark", '-T', 'pdml', '-r', orig_pcap_file_name])
orig_dom = parseString(orig_pdml_string)
#####################
# filtering unwanted packets
#####################
#cases = orig_etree.findall(".//proto[@name='sctp']")
packets = orig_dom.getElementsByTagName("packet")
for packet in packets:
found_sctp = False
found_s1ap = False
protos = packet.getElementsByTagName("proto")
for proto in protos:
attrs = proto.attributes
urlnode = attrs['name']
if urlnode.nodeValue == 'sctp':
found_sctp = True
elif urlnode.nodeValue == 's1ap':
found_s1ap = True
elif urlnode.nodeValue == 'geninfo':
packet.removeChild(proto)
elif urlnode.nodeValue == 'eth':
packet.removeChild(proto)
if found_sctp == False:
# hopefully it seems to work (remove iterated packet)
packet.parentNode.removeChild(packet)
#####################
# dom to xml string
#####################
filtered_pdml_string = orig_dom.toxml()
cleaned_pdml_string = ""
#####################
# remove blank lines in xml string
#####################
lines = filtered_pdml_string.splitlines()
for line in lines:
if line[:-1]:
cleaned_pdml_string += line + '\r\n'
#print "'%s'" % cleaned_pdml_string
#####################
# write pdml string to pdml file
#####################
out_pdml_file_name = os.path.dirname(orig_pcap_file_name) + os.path.splitext(os.path.basename(orig_pcap_file_name))[0] + '.pdml'
out_file = open(out_pdml_file_name, "w")
out_file.write(cleaned_pdml_string)
out_file.close()
############################################################
# DECEIVING HTML BONUS: DO NOT SEEM TO WORK CORRECTLY IN FIREFOX
# DID NOT INVESTIGATE
#####################
# write xml string to html file
#####################
xsl_root = etree.fromstring(open('/usr/share/wireshark/pdml2html.xsl').read())
transform = etree.XSLT(xsl_root)
xml_root = etree.fromstring(cleaned_pdml_string)
trans_root = transform(xml_root)
filtered_html_string = etree.tostring(trans_root)
#####################
# write html string to html file
#####################
out_html_file_name = os.path.dirname(orig_pcap_file_name) + os.path.splitext(os.path.basename(orig_pcap_file_name))[0] + '.html'
out_file = open(out_html_file_name, "w")
out_file.write(filtered_html_string)
out_file.close()
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario.c
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#include <string.h>
#include <limits.h>
#include <libconfig.h>
#include <inttypes.h>
#include <getopt.h>
#include <libgen.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "intertask_interface_init.h"
#include "timer.h"
#include "assertions.h"
#include "s1ap_common.h"
#include "intertask_interface.h"
#include "play_scenario.h"
#include "sctp_eNB_task.h"
#include "sctp_default_values.h"
#include "log.h"
//------------------------------------------------------------------------------
#define PLAY_SCENARIO 1
#define GS_IS_FILE 1
#define GS_IS_DIR 2
//------------------------------------------------------------------------------
Enb_properties_array_t g_enb_properties;
int g_max_speed = 0;
//------------------------------------------------------------------------------
extern et_scenario_t *g_scenario;
extern int xmlLoadExtDtdDefaultValue;
extern int asn_debug;
extern int asn1_xer_print;
extern pthread_mutex_t g_fsm_lock;
//------------------------------------------------------------------------------
// MEMO:
// Scenario with several eNBs: We may have to create ethx.y interfaces
//
//------------------------------------------------------------------------------
// test if file exist in current directory
int is_file_exists( const char const * file_nameP, const char const *file_roleP)
{
struct stat s;
int err = stat(file_nameP, &s);
if(-1 == err) {
if(ENOENT == errno) {
fprintf(stderr, "Please provide a valid %s, %s does not exist\n", file_roleP, file_nameP);
} else {
perror("stat");
exit(1);
}
} else {
if(S_ISREG(s.st_mode)) {
return GS_IS_FILE;
} else if(S_ISDIR(s.st_mode)) {
return GS_IS_DIR;
} else {
fprintf(stderr, "Please provide a valid test %s, %s exists but is not found valid\n", file_roleP, file_nameP);
}
}
return 0;
}
//------------------------------------------------------------------------------
int et_strip_extension(char *in_filename)
{
static const uint8_t name_min_len = 1;
static const uint8_t max_ext_len = 5; // .pdml !
fprintf(stdout, "strip_extension %s\n", in_filename);
if (NULL != in_filename) {
/* Check chars starting at end of string to find last '.' */
for (ssize_t i = strlen(in_filename); i > name_min_len; i--) {
if (in_filename[i] == '.') {
in_filename[i] = '\0';
return i;
}
}
}
return -1;
}
//------------------------------------------------------------------------------
// return number of splitted items
void et_get_shift_arg( char * line_argument, shift_packet_t * const shift)
{
int len = strlen(line_argument);
int i = 0;
int j = 0;
int num_milli = 0;
char my_num[64];
int negative = 0;
while ((line_argument[i] != ':') && (i < len)) {
if (isdigit(line_argument[i])) { // may occur '\"'
my_num[j++] = line_argument[i];
}
i += 1;
}
AssertFatal(':' == line_argument[i], "Bad format");
i += 1; // ':'
my_num[j++] = '\0';
shift->frame_number = atoi(my_num);
AssertFatal(i<len, "Shift argument %s bad format", line_argument);
if (line_argument[i] == '-') {
negative = 1;
i += 1;
} else if (line_argument[i] == '+') {
i += 1;
}
AssertFatal(i<len, "Shift argument %s bad format", line_argument);
j = 0;
while ((line_argument[i] != '.') && (i < len)) {
my_num[j++] = line_argument[i++];
}
my_num[j] = '\0';
j = 0;
i += 1;
shift->shift_seconds = atoi(my_num);
// may omit .mmm, accept .m or .mm or .mmm or ...
while ((i < len) && (num_milli++ < 3)){
my_num[j++] = line_argument[i++];
}
while (num_milli++ < 6){
my_num[j++] = '0';
}
my_num[j] = '\0';
shift->shift_microseconds = atoi(my_num);
if (negative == 1) {
shift->shift_seconds = - shift->shift_seconds;
shift->shift_microseconds = - shift->shift_microseconds;
}
}
//------------------------------------------------------------------------------
// return number of splitted items
int split_path( char * pathP, char *** resP)
{
char * saveptr1;
char * p = strtok_r (pathP, "/", &saveptr1);
int n_spaces = 0;
/// split string and append tokens to 'res'
while (p) {
*resP = realloc (*resP, sizeof (char*) * ++n_spaces);
AssertFatal (*resP, "realloc failed");
(*resP)[n_spaces-1] = p;
p = strtok_r (NULL, "/", &saveptr1);
}
return n_spaces;
}
//------------------------------------------------------------------------------
void et_free_packet(et_packet_t* packet)
{
if (packet) {
switch (packet->sctp_hdr.chunk_type) {
case SCTP_CID_DATA:
et_free_pointer(packet->sctp_hdr.u.data_hdr.payload.binary_stream);
break;
default:
;
}
et_free_pointer(packet);
}
}
//------------------------------------------------------------------------------
void et_free_scenario(et_scenario_t* scenario)
{
et_packet_t *packet = NULL;
et_packet_t *next_packet = NULL;
if (scenario) {
packet = scenario->list_packet;
while (packet) {
next_packet = packet->next;
et_free_packet(packet);
packet = next_packet->next;
}
et_free_pointer(scenario);
pthread_mutex_destroy(&g_fsm_lock);
}
}
//------------------------------------------------------------------------------
char * et_ip2ip_str(const et_ip_t * const ip)
{
static char str[INET6_ADDRSTRLEN];
sprintf(str, "ERROR");
switch (ip->address_family) {
case AF_INET6:
inet_ntop(AF_INET6, &(ip->address.ipv6), str, INET6_ADDRSTRLEN);
break;
case AF_INET:
inet_ntop(AF_INET, &(ip->address.ipv4), str, INET_ADDRSTRLEN);
break;
default:
;
}
return str;
}
//------------------------------------------------------------------------------
//convert hexstring to len bytes of data
//returns 0 on success, negative on error
//data is a buffer of at least len bytes
//hexstring is upper or lower case hexadecimal, NOT prepended with "0x"
int et_hex2data(unsigned char * const data, const unsigned char * const hexstring, const unsigned int len)
{
unsigned const char *pos = hexstring;
char *endptr = NULL;
size_t count = 0;
fprintf(stdout, "%s(%s,%d)\n", __FUNCTION__, hexstring, len);
if ((len > 1) && (strlen((const char*)hexstring) % 2)) {
//or hexstring has an odd length
return -3;
}
if (len == 1) {
char buf[5] = {'0', 'x', 0, pos[0], '\0'};
data[0] = strtol(buf, &endptr, 16);
/* Check for various possible errors */
AssertFatal ((errno == 0) || (data[0] != 0), "ERROR %s() strtol: %s\n", __FUNCTION__, strerror(errno));
AssertFatal (endptr != buf, "ERROR %s() No digits were found\n", __FUNCTION__);
return 0;
}
for(count = 0; count < len/2; count++) {
char buf[5] = {'0', 'x', pos[0], pos[1], 0};
data[count] = strtol(buf, &endptr, 16);
pos += 2 * sizeof(char);
AssertFatal (endptr[0] == '\0', "ERROR %s() non-hexadecimal character encountered buf %p endptr %p buf %s count %zu pos %p\n", __FUNCTION__, buf, endptr, buf, count, pos);
AssertFatal (endptr != buf, "ERROR %s() No digits were found\n", __FUNCTION__);
}
return 0;
}
//------------------------------------------------------------------------------
sctp_cid_t et_chunk_type_str2cid(const xmlChar * const chunk_type_str)
{
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"DATA"))) { return SCTP_CID_DATA;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"INIT"))) { return SCTP_CID_INIT;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"INIT_ACK"))) { return SCTP_CID_INIT_ACK;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"SACK"))) { return SCTP_CID_SACK;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"HEARTBEAT"))) { return SCTP_CID_HEARTBEAT;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"HEARTBEAT_ACK"))) { return SCTP_CID_HEARTBEAT_ACK;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"ABORT"))) { return SCTP_CID_ABORT;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"SHUTDOWN"))) { return SCTP_CID_SHUTDOWN;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"SHUTDOWN_ACK"))) { return SCTP_CID_SHUTDOWN_ACK;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"ERROR"))) { return SCTP_CID_ERROR;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"COOKIE_ECHO"))) { return SCTP_CID_COOKIE_ECHO;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"COOKIE_ACK"))) { return SCTP_CID_COOKIE_ACK;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"ECN_ECNE"))) { return SCTP_CID_ECN_ECNE;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"ECN_CWR"))) { return SCTP_CID_ECN_CWR;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"SHUTDOWN_COMPLETE"))) { return SCTP_CID_SHUTDOWN_COMPLETE;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"AUTH"))) { return SCTP_CID_AUTH;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"FWD_TSN"))) { return SCTP_CID_FWD_TSN;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"ASCONF"))) { return SCTP_CID_ASCONF;}
if ((!xmlStrcmp(chunk_type_str, (const xmlChar *)"ASCONF_ACK"))) { return SCTP_CID_ASCONF_ACK;}
AssertFatal (0, "ERROR: %s() cannot convert: %s\n", __FUNCTION__, chunk_type_str);
}
//------------------------------------------------------------------------------
const char * const et_chunk_type_cid2str(const sctp_cid_t chunk_type)
{
switch (chunk_type) {
case SCTP_CID_DATA: return "DATA"; break;
case SCTP_CID_INIT: return "INIT"; break;
case SCTP_CID_INIT_ACK: return "INIT_ACK"; break;
case SCTP_CID_SACK: return "SACK"; break;
case SCTP_CID_HEARTBEAT: return "HEARTBEAT"; break;
case SCTP_CID_HEARTBEAT_ACK: return "HEARTBEAT_ACK"; break;
case SCTP_CID_ABORT: return "ABORT"; break;
case SCTP_CID_SHUTDOWN: return "SHUTDOWN"; break;
case SCTP_CID_SHUTDOWN_ACK: return "SHUTDOWN_ACK"; break;
case SCTP_CID_ERROR: return "ERROR"; break;
case SCTP_CID_COOKIE_ECHO: return "COOKIE_ECHO"; break;
case SCTP_CID_COOKIE_ACK: return "COOKIE_ACK"; break;
case SCTP_CID_ECN_ECNE: return "ECN_ECNE"; break;
case SCTP_CID_ECN_CWR: return "ECN_CWR"; break;
case SCTP_CID_SHUTDOWN_COMPLETE: return "SHUTDOWN_COMPLETE"; break;
case SCTP_CID_AUTH: return "AUTH"; break;
case SCTP_CID_FWD_TSN: return "FWD_TSN"; break;
case SCTP_CID_ASCONF: return "ASCONF"; break;
case SCTP_CID_ASCONF_ACK: return "ASCONF_ACK"; break;
default:
AssertFatal (0, "ERROR: Unknown chunk_type %d!\n", chunk_type);
}
}
//------------------------------------------------------------------------------
const char * const et_error_match2str(const int err)
{
switch (err) {
// from asn_compare.h
case COMPARE_ERR_CODE_NO_MATCH: return "CODE_NO_MATCH"; break;
case COMPARE_ERR_CODE_TYPE_MISMATCH: return "TYPE_MISMATCH"; break;
case COMPARE_ERR_CODE_TYPE_ARG_NULL: return "TYPE_ARG_NULL"; break;
case COMPARE_ERR_CODE_VALUE_NULL: return "VALUE_NULL"; break;
case COMPARE_ERR_CODE_VALUE_ARG_NULL: return "VALUE_ARG_NULL"; break;
case COMPARE_ERR_CODE_CHOICE_NUM: return "CHOICE_NUM"; break;
case COMPARE_ERR_CODE_CHOICE_PRESENT: return "CHOICE_PRESENT"; break;
case COMPARE_ERR_CODE_CHOICE_MALFORMED: return "CHOICE_MALFORMED"; break;
case COMPARE_ERR_CODE_SET_MALFORMED: return "SET_MALFORMED"; break;
case COMPARE_ERR_CODE_COLLECTION_NUM_ELEMENTS: return "COLLECTION_NUM_ELEMENTS"; break;
// from play_scenario.h
case ET_ERROR_MATCH_PACKET_SCTP_CHUNK_TYPE: return "SCTP_CHUNK_TYPE"; break;
case ET_ERROR_MATCH_PACKET_SCTP_PPID: return "SCTP_PPID"; break;
case ET_ERROR_MATCH_PACKET_SCTP_ASSOC_ID: return "SCTP_ASSOC_ID"; break;
case ET_ERROR_MATCH_PACKET_SCTP_STREAM_ID: return "SCTP_STREAM_ID"; break;
case ET_ERROR_MATCH_PACKET_SCTP_SSN: return "SCTP_SSN"; break;
case ET_ERROR_MATCH_PACKET_S1AP_PRESENT: return "S1AP_PRESENT"; break;
case ET_ERROR_MATCH_PACKET_S1AP_PROCEDURE_CODE: return "S1AP_PROCEDURE_CODE"; break;
case ET_ERROR_MATCH_PACKET_S1AP_CRITICALITY: return "S1AP_CRITICALITY"; break;
default:
AssertFatal (0, "ERROR: Unknown match error %d!(TODO handle an1c error codes)\n", err);
}
}
//------------------------------------------------------------------------------
et_packet_action_t et_action_str2et_action_t(const xmlChar * const action)
{
if ((!xmlStrcmp(action, (const xmlChar *)"SEND"))) { return ET_PACKET_ACTION_S1C_SEND;}
if ((!xmlStrcmp(action, (const xmlChar *)"RECEIVE"))) { return ET_PACKET_ACTION_S1C_RECEIVE;}
AssertFatal (0, "ERROR: cannot convert: %s\n", action);
//if (NULL == action) {return ACTION_S1C_NULL;}
}
//------------------------------------------------------------------------------
void et_ip_str2et_ip(const xmlChar * const ip_str, et_ip_t * const ip)
{
AssertFatal (NULL != ip_str, "ERROR Cannot convert null string to ip address!\n");
AssertFatal (NULL != ip, "ERROR out parameter pointer is NULL!\n");
// store this IP address in sa:
if (inet_pton(AF_INET, (const char*)ip_str, (void*)&(ip->address.ipv4)) > 0) {
ip->address_family = AF_INET;
strncpy((char *)ip->str, (const char *)ip_str, INET_ADDRSTRLEN+1);
} else if (inet_pton(AF_INET6, (const char*)ip_str, (void*)&(ip->address.ipv6)) > 0) {
ip->address_family = AF_INET6;
strncpy((char *)ip->str, (const char *)ip_str, INET6_ADDRSTRLEN+1);
} else {
ip->address_family = AF_UNSPEC;
AssertFatal (0, "ERROR %s() Could not parse ip address %s!\n", __FUNCTION__, ip_str);
}
}
//------------------------------------------------------------------------------
int et_compare_et_ip_to_net_ip_address(const et_ip_t * const ip, const net_ip_address_t * const net_ip)
{
AssertFatal (NULL != ip, "ERROR ip parameter\n");
AssertFatal (NULL != net_ip, "ERROR net_ip parameter\n");
switch (ip->address_family) {
case AF_INET:
if (net_ip->ipv4) {
//S1AP_DEBUG("%s(%s,%s)=%d\n",__FUNCTION__,ip->str, net_ip->ipv4_address, strcmp(ip->str, net_ip->ipv4_address));
return strcmp(ip->str, net_ip->ipv4_address);
}
//S1AP_DEBUG("%s(%s,%s)=-1 (IP version (4) not matching)\n",__FUNCTION__,ip->str, net_ip->ipv4_address);
return -1;
break;
case AF_INET6:
if (net_ip->ipv6) {
//S1AP_DEBUG("%s(%s,%s)=%d\n",__FUNCTION__,ip->str, net_ip->ipv4_address, strcmp(ip->str, net_ip->ipv6_address));
return strcmp(ip->str, net_ip->ipv6_address);
}
//S1AP_DEBUG("%s(%s,%s)=-1 (IP version (6) not matching)\n",__FUNCTION__,ip->str, net_ip->ipv6_address);
return -1;
break;
default:
S1AP_DEBUG("%s(%s,...)=-1 (unknown IP version)\n",__FUNCTION__,ip->str);
return -1;
}
}
#ifdef LIBCONFIG_LONG
#define libconfig_int long
#else
#define libconfig_int int
#endif
//------------------------------------------------------------------------------
void et_enb_config_init(const char const * lib_config_file_name_pP)
//------------------------------------------------------------------------------
{
config_t cfg;
config_setting_t *setting = NULL;
config_setting_t *subsetting = NULL;
config_setting_t *setting_mme_addresses = NULL;
config_setting_t *setting_mme_address = NULL;
config_setting_t *setting_enb = NULL;
libconfig_int my_int;
int num_enb_properties = 0;
int enb_properties_index = 0;
int num_enbs = 0;
int num_mme_address = 0;
int i = 0;
int j = 0;
int parse_errors = 0;
libconfig_int enb_id = 0;
const char* cell_type = NULL;
const char* tac = 0;
const char* enb_name = NULL;
const char* mcc = 0;
const char* mnc = 0;
char* ipv4 = NULL;
char* ipv6 = NULL;
char* active = NULL;
char* preference = NULL;
const char* active_enb[MAX_ENB];
char* enb_interface_name_for_S1U = NULL;
char* enb_ipv4_address_for_S1U = NULL;
libconfig_int enb_port_for_S1U = 0;
char* enb_interface_name_for_S1_MME = NULL;
char* enb_ipv4_address_for_S1_MME = NULL;
char *address = NULL;
char *cidr = NULL;
AssertFatal (lib_config_file_name_pP != NULL,
"Bad parameter lib_config_file_name_pP %s , must reference a valid eNB config file\n",
lib_config_file_name_pP);
memset((char*)active_enb, 0 , MAX_ENB * sizeof(char*));
config_init(&cfg);
/* Read the file. If there is an error, report it and exit. */
if (! config_read_file(&cfg, lib_config_file_name_pP)) {
config_destroy(&cfg);
AssertFatal (0, "Failed to parse eNB configuration file %s!\n", lib_config_file_name_pP);
}
// Get list of active eNBs, (only these will be configured)
setting = config_lookup(&cfg, ENB_CONFIG_STRING_ACTIVE_ENBS);
if (setting != NULL) {
num_enbs = config_setting_length(setting);
for (i = 0; i < num_enbs; i++) {
setting_enb = config_setting_get_elem(setting, i);
active_enb[i] = config_setting_get_string (setting_enb);
AssertFatal (active_enb[i] != NULL,
"Failed to parse config file %s, %uth attribute %s \n",
lib_config_file_name_pP, i, ENB_CONFIG_STRING_ACTIVE_ENBS);
active_enb[i] = strdup(active_enb[i]);
num_enb_properties += 1;
}
}
/* Output a list of all eNBs. */
setting = config_lookup(&cfg, ENB_CONFIG_STRING_ENB_LIST);
if (setting != NULL) {
enb_properties_index = g_enb_properties.number;
parse_errors = 0;
num_enbs = config_setting_length(setting);
for (i = 0; i < num_enbs; i++) {
setting_enb = config_setting_get_elem(setting, i);
if (! config_setting_lookup_int(setting_enb, ENB_CONFIG_STRING_ENB_ID, &enb_id)) {
/* Calculate a default eNB ID */
# if defined(ENABLE_USE_MME)
uint32_t hash;
hash = et_s1ap_generate_eNB_id ();
enb_id = i + (hash & 0xFFFF8);
# else
enb_id = i;
# endif
}
if ( !( config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_CELL_TYPE, &cell_type)
&& config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_ENB_NAME, &enb_name)
&& config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_TRACKING_AREA_CODE, &tac)
&& config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_MOBILE_COUNTRY_CODE, &mcc)
&& config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_MOBILE_NETWORK_CODE, &mnc)
)
) {
AssertError (0, parse_errors ++,
"Failed to parse eNB configuration file %s, %u th enb\n",
lib_config_file_name_pP, i);
continue; // FIXME this prevents segfaults below, not sure what happens after function exit
}
// search if in active list
for (j=0; j < num_enb_properties; j++) {
if (strcmp(active_enb[j], enb_name) == 0) {
g_enb_properties.properties[enb_properties_index] = calloc(1, sizeof(Enb_properties_t));
g_enb_properties.properties[enb_properties_index]->eNB_id = enb_id;
if (strcmp(cell_type, "CELL_MACRO_ENB") == 0) {
g_enb_properties.properties[enb_properties_index]->cell_type = CELL_MACRO_ENB;
} else if (strcmp(cell_type, "CELL_HOME_ENB") == 0) {
g_enb_properties.properties[enb_properties_index]->cell_type = CELL_HOME_ENB;
} else {
AssertError (0, parse_errors ++,
"Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for cell_type choice: CELL_MACRO_ENB or CELL_HOME_ENB !\n",
lib_config_file_name_pP, i, cell_type);
}
g_enb_properties.properties[enb_properties_index]->eNB_name = strdup(enb_name);
g_enb_properties.properties[enb_properties_index]->tac = (uint16_t)atoi(tac);
g_enb_properties.properties[enb_properties_index]->mcc = (uint16_t)atoi(mcc);
g_enb_properties.properties[enb_properties_index]->mnc = (uint16_t)atoi(mnc);
g_enb_properties.properties[enb_properties_index]->mnc_digit_length = strlen(mnc);
AssertFatal((g_enb_properties.properties[enb_properties_index]->mnc_digit_length == 2) ||
(g_enb_properties.properties[enb_properties_index]->mnc_digit_length == 3),
"BAD MNC DIGIT LENGTH %d",
g_enb_properties.properties[i]->mnc_digit_length);
setting_mme_addresses = config_setting_get_member (setting_enb, ENB_CONFIG_STRING_MME_IP_ADDRESS);
num_mme_address = config_setting_length(setting_mme_addresses);
g_enb_properties.properties[enb_properties_index]->nb_mme = 0;
for (j = 0; j < num_mme_address; j++) {
setting_mme_address = config_setting_get_elem(setting_mme_addresses, j);
if ( !(
config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IPV4_ADDRESS, (const char **)&ipv4)
&& config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IPV6_ADDRESS, (const char **)&ipv6)
&& config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IP_ADDRESS_ACTIVE, (const char **)&active)
&& config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IP_ADDRESS_PREFERENCE, (const char **)&preference)
)
) {
AssertError (0, parse_errors ++,
"Failed to parse eNB configuration file %s, %u th enb %u th mme address !\n",
lib_config_file_name_pP, i, j);
continue; // FIXME will prevent segfaults below, not sure what happens at function exit...
}
g_enb_properties.properties[enb_properties_index]->nb_mme += 1;
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4_address = strdup(ipv4);
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6_address = strdup(ipv6);
if (strcmp(active, "yes") == 0) {
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].active = 1;
} // else { (calloc)
if (strcmp(preference, "ipv4") == 0) {
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4 = 1;
} else if (strcmp(preference, "ipv6") == 0) {
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6 = 1;
} else if (strcmp(preference, "no") == 0) {
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4 = 1;
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6 = 1;
}
}
// SCTP SETTING
g_enb_properties.properties[enb_properties_index]->sctp_out_streams = SCTP_OUT_STREAMS;
g_enb_properties.properties[enb_properties_index]->sctp_in_streams = SCTP_IN_STREAMS;
subsetting = config_setting_get_member (setting_enb, ENB_CONFIG_STRING_SCTP_CONFIG);
if (subsetting != NULL) {
if ( (config_setting_lookup_int( subsetting, ENB_CONFIG_STRING_SCTP_INSTREAMS, &my_int) )) {
g_enb_properties.properties[enb_properties_index]->sctp_in_streams = (uint16_t)my_int;
}
if ( (config_setting_lookup_int( subsetting, ENB_CONFIG_STRING_SCTP_OUTSTREAMS, &my_int) )) {
g_enb_properties.properties[enb_properties_index]->sctp_out_streams = (uint16_t)my_int;
}
}
// NETWORK_INTERFACES
subsetting = config_setting_get_member (setting_enb, ENB_CONFIG_STRING_NETWORK_INTERFACES_CONFIG);
if (subsetting != NULL) {
if ( (
config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1_MME,
(const char **)&enb_interface_name_for_S1_MME)
&& config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_IPV4_ADDRESS_FOR_S1_MME,
(const char **)&enb_ipv4_address_for_S1_MME)
&& config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1U,
(const char **)&enb_interface_name_for_S1U)
&& config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_IPV4_ADDR_FOR_S1U,
(const char **)&enb_ipv4_address_for_S1U)
&& config_setting_lookup_int(subsetting, ENB_CONFIG_STRING_ENB_PORT_FOR_S1U,
&enb_port_for_S1U)
)
) {
g_enb_properties.properties[enb_properties_index]->enb_interface_name_for_S1U = strdup(enb_interface_name_for_S1U);
cidr = enb_ipv4_address_for_S1U;
address = strtok(cidr, "/");
if (address) {
IPV4_STR_ADDR_TO_INT_NWBO ( address, g_enb_properties.properties[enb_properties_index]->enb_ipv4_address_for_S1U, "BAD IP ADDRESS FORMAT FOR eNB S1_U !\n" );
}
g_enb_properties.properties[enb_properties_index]->enb_port_for_S1U = enb_port_for_S1U;
g_enb_properties.properties[enb_properties_index]->enb_interface_name_for_S1_MME = strdup(enb_interface_name_for_S1_MME);
cidr = enb_ipv4_address_for_S1_MME;
address = strtok(cidr, "/");
if (address) {
IPV4_STR_ADDR_TO_INT_NWBO ( address, g_enb_properties.properties[enb_properties_index]->enb_ipv4_address_for_S1_MME, "BAD IP ADDRESS FORMAT FOR eNB S1_MME !\n" );
}
}
} // if (subsetting != NULL) {
enb_properties_index += 1;
} // if (strcmp(active_enb[j], enb_name) == 0)
} // for (j=0; j < num_enb_properties; j++)
} // for (i = 0; i < num_enbs; i++)
} // if (setting != NULL) {
g_enb_properties.number += num_enb_properties;
AssertFatal (parse_errors == 0,
"Failed to parse eNB configuration file %s, found %d error%s !\n",
lib_config_file_name_pP, parse_errors, parse_errors > 1 ? "s" : "");
}
/*------------------------------------------------------------------------------*/
const Enb_properties_array_t *et_enb_config_get(void)
{
return &g_enb_properties;
}
/*------------------------------------------------------------------------------*/
void et_eNB_app_register(const Enb_properties_array_t *enb_properties)
{
uint32_t enb_id = 0;
uint32_t mme_id = 0;
MessageDef *msg_p = NULL;
char *str = NULL;
struct in_addr addr = {.s_addr = 0};
g_scenario->register_enb_pending = 0;
for (enb_id = 0; (enb_id < enb_properties->number) ; enb_id++) {
{
s1ap_register_enb_req_t *s1ap_register_eNB = NULL;
/* note: there is an implicit relationship between the data structure and the message name */
msg_p = itti_alloc_new_message (TASK_ENB_APP, S1AP_REGISTER_ENB_REQ);
s1ap_register_eNB = &S1AP_REGISTER_ENB_REQ(msg_p);
/* Some default/random parameters */
s1ap_register_eNB->eNB_id = enb_properties->properties[enb_id]->eNB_id;
s1ap_register_eNB->cell_type = enb_properties->properties[enb_id]->cell_type;
s1ap_register_eNB->eNB_name = enb_properties->properties[enb_id]->eNB_name;
s1ap_register_eNB->tac = enb_properties->properties[enb_id]->tac;
s1ap_register_eNB->mcc = enb_properties->properties[enb_id]->mcc;
s1ap_register_eNB->mnc = enb_properties->properties[enb_id]->mnc;
s1ap_register_eNB->mnc_digit_length = enb_properties->properties[enb_id]->mnc_digit_length;
s1ap_register_eNB->nb_mme = enb_properties->properties[enb_id]->nb_mme;
AssertFatal (s1ap_register_eNB->nb_mme <= S1AP_MAX_NB_MME_IP_ADDRESS, "Too many MME for eNB %d (%d/%d)!", enb_id, s1ap_register_eNB->nb_mme,
S1AP_MAX_NB_MME_IP_ADDRESS);
for (mme_id = 0; mme_id < s1ap_register_eNB->nb_mme; mme_id++) {
s1ap_register_eNB->mme_ip_address[mme_id].ipv4 = enb_properties->properties[enb_id]->mme_ip_address[mme_id].ipv4;
s1ap_register_eNB->mme_ip_address[mme_id].ipv6 = enb_properties->properties[enb_id]->mme_ip_address[mme_id].ipv6;
strncpy (s1ap_register_eNB->mme_ip_address[mme_id].ipv4_address,
enb_properties->properties[enb_id]->mme_ip_address[mme_id].ipv4_address,
sizeof(s1ap_register_eNB->mme_ip_address[0].ipv4_address));
strncpy (s1ap_register_eNB->mme_ip_address[mme_id].ipv6_address,
enb_properties->properties[enb_id]->mme_ip_address[mme_id].ipv6_address,
sizeof(s1ap_register_eNB->mme_ip_address[0].ipv6_address));
}
s1ap_register_eNB->sctp_in_streams = enb_properties->properties[enb_id]->sctp_in_streams;
s1ap_register_eNB->sctp_out_streams = enb_properties->properties[enb_id]->sctp_out_streams;
s1ap_register_eNB->enb_ip_address.ipv6 = 0;
s1ap_register_eNB->enb_ip_address.ipv4 = 1;
addr.s_addr = enb_properties->properties[enb_id]->enb_ipv4_address_for_S1_MME;
str = inet_ntoa(addr);
strcpy(s1ap_register_eNB->enb_ip_address.ipv4_address, str);
g_scenario->register_enb_pending++;
itti_send_msg_to_task (TASK_S1AP, ENB_MODULE_ID_TO_INSTANCE(enb_id), msg_p);
}
}
}
/*------------------------------------------------------------------------------*/
void *et_eNB_app_task(void *args_p)
{
et_scenario_t *scenario = (et_scenario_t*)args_p;
MessageDef *msg_p = NULL;
const char *msg_name = NULL;
instance_t instance = 0;
int result = 0;
itti_mark_task_ready (TASK_ENB_APP);
do {
// Wait for a message
itti_receive_msg (TASK_ENB_APP, &msg_p);
msg_name = ITTI_MSG_NAME (msg_p);
instance = ITTI_MSG_INSTANCE (msg_p);
switch (ITTI_MSG_ID(msg_p)) {
case TERMINATE_MESSAGE:
itti_exit_task ();
break;
case S1AP_REGISTER_ENB_CNF:
LOG_I(ENB_APP, "[eNB %d] Received %s: associated MME %d\n", instance, msg_name,
S1AP_REGISTER_ENB_CNF(msg_p).nb_mme);
DevAssert(scenario->register_enb_pending > 0);
scenario->register_enb_pending--;
/* Check if at least eNB is registered with one MME */
if (S1AP_REGISTER_ENB_CNF(msg_p).nb_mme > 0) {
scenario->registered_enb++;
}
/* Check if all register eNB requests have been processed */
if (scenario->register_enb_pending == 0) {
timer_remove(scenario->enb_register_retry_timer_id);
if (scenario->registered_enb == scenario->enb_properties->number) {
/* If all eNB are registered, start scenario */
LOG_D(ENB_APP, " All eNB are now associated with a MME\n");
et_event_t event;
event.code = ET_EVENT_S1C_CONNECTED;
et_scenario_fsm_notify_event(event);
} else {
uint32_t not_associated = scenario->enb_properties->number - scenario->registered_enb;
LOG_W(ENB_APP, " %d eNB %s not associated with a MME, retrying registration in %d seconds ...\n",
not_associated, not_associated > 1 ? "are" : "is", ET_ENB_REGISTER_RETRY_DELAY);
/* Restart the eNB registration process in ENB_REGISTER_RETRY_DELAY seconds */
if (timer_setup (ET_ENB_REGISTER_RETRY_DELAY, 0, TASK_ENB_APP, INSTANCE_DEFAULT, TIMER_ONE_SHOT,
NULL, &scenario->enb_register_retry_timer_id) < 0) {
LOG_E(ENB_APP, " Can not start eNB register retry timer, use \"sleep\" instead!\n");
sleep(ET_ENB_REGISTER_RETRY_DELAY);
/* Restart the registration process */
scenario->registered_enb = 0;
et_eNB_app_register (scenario->enb_properties);
}
}
}
break;
case S1AP_DEREGISTERED_ENB_IND:
LOG_W(ENB_APP, "[eNB %d] Received %s: associated MME %d\n", instance, msg_name,
S1AP_DEREGISTERED_ENB_IND(msg_p).nb_mme);
/* TODO handle recovering of registration */
break;
case TIMER_HAS_EXPIRED:
LOG_I(ENB_APP, " Received %s: timer_id %d\n", msg_name, TIMER_HAS_EXPIRED(msg_p).timer_id);
if (TIMER_HAS_EXPIRED (msg_p).timer_id == scenario->enb_register_retry_timer_id) {
/* Restart the registration process */
scenario->registered_enb = 0;
et_eNB_app_register (scenario->enb_properties);
}
break;
default:
LOG_E(ENB_APP, "Received unexpected message %s\n", msg_name);
break;
}
result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
} while (1);
return NULL;
}
//------------------------------------------------------------------------------
int et_play_scenario(et_scenario_t* const scenario, const struct shift_packet_s *shifts)
{
et_event_t event;
struct shift_packet_s *shift = shifts;
et_packet_t *packet = NULL;
et_packet_t *next_packet = NULL;
struct timeval shift_all_packets = { .tv_sec = 0, .tv_usec = 0 };
struct timeval relative_last_sent_packet = { .tv_sec = 0, .tv_usec = 0 };
struct timeval relative_last_received_packet = { .tv_sec = 0, .tv_usec = 0 };
struct timeval initial_time = { .tv_sec = 0, .tv_usec = 0 };
char first_packet = 1;
char first_sent_packet = 1;
char first_received_packet = 1;
// first apply timing shifts if requested
while (shift) {
packet = scenario->list_packet;
while (packet) {
//fprintf(stdout, "*shift: %p\n", shift);
//fprintf(stdout, "\tframe_number: %d\n", shift->frame_number);
//fprintf(stdout, "\tshift_seconds: %ld\n", shift->shift_seconds);
//fprintf(stdout, "\tshift_microseconds: %ld\n", shift->shift_microseconds);
//fprintf(stdout, "\tsingle: %d\n\n", shift->single);
//fprintf(stdout, "\tshift_all_packets_seconds: %ld\n", shift_all_packets.tv_sec);
//fprintf(stdout, "\tshift_all_packets_microseconds: %ld\n", shift_all_packets.tv_usec);
AssertFatal((packet->time_relative_to_first_packet.tv_sec >= 0) && (packet->time_relative_to_first_packet.tv_usec >= 0),
"Bad timing result time_relative_to_first_packet=%d.%d packet num %u, original frame number %u",
packet->time_relative_to_first_packet.tv_sec,
packet->time_relative_to_first_packet.tv_usec,
packet->packet_number,
packet->original_frame_number);
AssertFatal((packet->time_relative_to_last_received_packet.tv_sec >= 0) && (packet->time_relative_to_last_received_packet.tv_usec >= 0),
"Bad timing result time_relative_to_last_received_packet=%d.%d packet num %u, original frame number %u",
packet->time_relative_to_last_received_packet.tv_sec,
packet->time_relative_to_last_received_packet.tv_usec,
packet->packet_number,
packet->original_frame_number);
AssertFatal((packet->time_relative_to_last_sent_packet.tv_sec >= 0) && (packet->time_relative_to_last_sent_packet.tv_usec >= 0),
"Bad timing result time_relative_to_last_sent_packet=%d.%d packet num %u, original frame number %u",
packet->time_relative_to_last_sent_packet.tv_sec,
packet->time_relative_to_last_sent_packet.tv_usec,
packet->packet_number,
packet->original_frame_number);
// fprintf(stdout, "\tpacket num %u, original frame number %u time_relative_to_first_packet=%d.%d\n",
// packet->packet_number,
// packet->original_frame_number,
// packet->time_relative_to_first_packet.tv_sec,
// packet->time_relative_to_first_packet.tv_usec);
// fprintf(stdout, "\tpacket num %u, original frame number %u time_relative_to_last_received_packet=%d.%d\n",
// packet->packet_number,
// packet->original_frame_number,
// packet->time_relative_to_last_received_packet.tv_sec,
// packet->time_relative_to_last_received_packet.tv_usec);
// fprintf(stdout, "\tpacket num %u, original frame number %u time_relative_to_last_sent_packet=%d.%d\n",
// packet->packet_number,
// packet->original_frame_number,
// packet->time_relative_to_last_sent_packet.tv_sec,
// packet->time_relative_to_last_sent_packet.tv_usec);
if ((shift->single) && (shift->frame_number == packet->original_frame_number)) {
struct timeval t_offset = { .tv_sec = shift->shift_seconds, .tv_usec = shift->shift_microseconds };
et_packet_shift_timing(packet, &t_offset);
next_packet = packet->next;
if (next_packet) {
t_offset.tv_sec = -t_offset.tv_sec;
t_offset.tv_usec = -t_offset.tv_usec;
if (packet->action == ET_PACKET_ACTION_S1C_SEND) {
timeval_add(&next_packet->time_relative_to_last_sent_packet, &next_packet->time_relative_to_last_sent_packet, &t_offset);
} else if (packet->action == ET_PACKET_ACTION_S1C_RECEIVE) {
timeval_add(&next_packet->time_relative_to_last_received_packet, &next_packet->time_relative_to_last_received_packet, &t_offset);
}
}
}
if ((0 == shift->single) && (shift->frame_number == packet->original_frame_number)) {
shift_all_packets.tv_sec = shift->shift_seconds;
shift_all_packets.tv_usec = shift->shift_microseconds;
timeval_add(&packet->time_relative_to_first_packet, &packet->time_relative_to_first_packet, &shift_all_packets);
fprintf(stdout, "\tpacket num %u, now original frame number %u time_relative_to_first_packet=%d.%d\n",
packet->packet_number,
packet->original_frame_number,
packet->time_relative_to_first_packet.tv_sec,
packet->time_relative_to_first_packet.tv_usec);
AssertFatal((packet->time_relative_to_first_packet.tv_sec >= 0) && (packet->time_relative_to_first_packet.tv_usec >= 0),
"Bad timing result time_relative_to_first_packet=%d.%d packet num %u, original frame number %u",
packet->time_relative_to_first_packet.tv_sec,
packet->time_relative_to_first_packet.tv_usec,
packet->packet_number,
packet->original_frame_number);
} else if ((0 == shift->single) && (shift->frame_number < packet->original_frame_number)) {
timeval_add(&packet->time_relative_to_first_packet, &packet->time_relative_to_first_packet, &shift_all_packets);
fprintf(stdout, "\tpacket num %u, now original frame number %u time_relative_to_first_packet=%d.%d\n",
packet->packet_number,
packet->original_frame_number,
packet->time_relative_to_first_packet.tv_sec,
packet->time_relative_to_first_packet.tv_usec);
AssertFatal((packet->time_relative_to_first_packet.tv_sec >= 0) && (packet->time_relative_to_first_packet.tv_usec >= 0),
"Bad timing result time_relative_to_first_packet=%d.%d packet num %u, original frame number %u",
packet->time_relative_to_first_packet.tv_sec,
packet->time_relative_to_first_packet.tv_usec,
packet->packet_number,
packet->original_frame_number);
}
packet = packet->next;
}
shift = shift->next;
}
// now recompute time_relative_to_last_received_packet, time_relative_to_last_sent_packet
packet = scenario->list_packet;
while (packet) {
if (first_packet > 0) {
initial_time = packet->time_relative_to_first_packet;
packet->time_relative_to_first_packet.tv_sec = 0;
packet->time_relative_to_first_packet.tv_usec = 0;
first_packet = 0;
} else {
timersub(&packet->time_relative_to_first_packet, &initial_time,
&packet->time_relative_to_first_packet);
}
if (packet->action == ET_PACKET_ACTION_S1C_SEND) {
if (first_sent_packet > 0) {
relative_last_sent_packet = packet->time_relative_to_first_packet;
packet->time_relative_to_last_sent_packet.tv_sec = 0;
packet->time_relative_to_last_sent_packet.tv_usec = 0;
first_sent_packet = 0;
} else {
timersub(&packet->time_relative_to_first_packet, &relative_last_sent_packet,
&packet->time_relative_to_last_sent_packet);
relative_last_sent_packet = packet->time_relative_to_first_packet;
}
if (first_received_packet > 0) {
packet->time_relative_to_last_received_packet.tv_sec = 0;
packet->time_relative_to_last_received_packet.tv_usec = 0;
} else {
timersub(&packet->time_relative_to_first_packet, &relative_last_received_packet,
&packet->time_relative_to_last_received_packet);
}
} else if (packet->action == ET_PACKET_ACTION_S1C_RECEIVE) {
if (first_received_packet > 0) {
relative_last_received_packet.tv_sec = packet->time_relative_to_first_packet.tv_sec;
relative_last_received_packet.tv_usec = packet->time_relative_to_first_packet.tv_usec;
packet->time_relative_to_last_received_packet.tv_sec = 0;
packet->time_relative_to_last_received_packet.tv_usec = 0;
first_received_packet = 0;
} else {
timersub(&packet->time_relative_to_first_packet, &relative_last_received_packet,
&packet->time_relative_to_last_received_packet);
relative_last_received_packet = packet->time_relative_to_first_packet;
}
if (first_sent_packet > 0) {
packet->time_relative_to_last_sent_packet.tv_sec = 0;
packet->time_relative_to_last_sent_packet.tv_usec = 0;
} else {
timersub(&packet->time_relative_to_first_packet, &relative_last_sent_packet,
&packet->time_relative_to_last_sent_packet);
}
}
packet = packet->next;
}
//et_display_scenario(scenario);
// create SCTP ITTI task: same as eNB code
if (itti_create_task (TASK_SCTP, sctp_eNB_task, NULL) < 0) {
LOG_E(SCTP, "Create task for SCTP failed\n");
return -1;
}
// create S1AP ITTI task: not as same as eNB code
if (itti_create_task (TASK_S1AP, et_s1ap_eNB_task, NULL) < 0) {
LOG_E(S1AP, "Create task for S1AP failed\n");
return -1;
}
// create ENB_APP ITTI task: not as same as eNB code
if (itti_create_task (TASK_ENB_APP, et_eNB_app_task, scenario) < 0) {
LOG_E(ENB_APP, "Create task for ENB_APP failed\n");
return -1;
}
event.code = ET_EVENT_INIT;
event.u.init.scenario = scenario;
et_scenario_fsm_notify_event(event);
return 0;
}
//------------------------------------------------------------------------------
static void et_usage (
int argc,
char *argv[])
//------------------------------------------------------------------------------
{
fprintf (stdout, "Please report any bug to: %s\n",PACKAGE_BUGREPORT);
fprintf (stdout, "Usage: %s [options]\n\n", argv[0]);
fprintf (stdout, "\n");
fprintf (stdout, "\t-d | --test-dir <dir> Directory where a set of files related to a particular test are located\n");
fprintf (stdout, "\t-c | --enb-conf-file <file> Provide an eNB config file, valid for the testbed\n");
fprintf (stdout, "\t-D | --delay-on-exit <delay-in-sec> Wait delay-in-sec before exiting\n");
fprintf (stdout, "\t-f | --shift-packet <frame:[+|-]seconds[.usec]> Shift the timing of a packet'\n");
fprintf (stdout, "\t-F | --shift-packets <frame:[+|-]seconds[.usec]> Shift the timing of packets starting at frame 'frame' included\n");
fprintf (stdout, "\t-m | --max-speed Play scenario as fast as possible without respecting frame timings\n");
fprintf (stdout, "\t-s | --scenario <file> File name (with no path) of a test scenario that has to be replayed ()\n");
fprintf (stdout, "\n");
fprintf (stdout, "Other options:\n");
fprintf (stdout, "\t-h | --help Print this help and return\n");
fprintf (stdout, "\t-v | --version Print informations about the version of this executable\n");
fprintf (stdout, "\n");
}
//------------------------------------------------------------------------------
int
et_config_parse_opt_line (
int argc,
char *argv[],
char **et_dir_name,
char **scenario_file_name,
char **enb_config_file_name,
shift_packet_t **shifts,
int *delay_on_exit)
//------------------------------------------------------------------------------
{
int option = 0;
int rv = 0;
shift_packet_t *shift = NULL;
enum long_option_e {
LONG_OPTION_START = 0x100, /* Start after regular single char options */
LONG_OPTION_ENB_CONF_FILE,
LONG_OPTION_SCENARIO_FILE,
LONG_OPTION_MAX_SPEED,
LONG_OPTION_TEST_DIR,
LONG_OPTION_DELAY_EXIT,
LONG_OPTION_SHIFT_PACKET,
LONG_OPTION_SHIFT_PACKETS,
LONG_OPTION_HELP,
LONG_OPTION_VERSION
};
static struct option long_options[] = {
{"enb-conf-file", required_argument, 0, LONG_OPTION_ENB_CONF_FILE},
{"scenario ", required_argument, 0, LONG_OPTION_SCENARIO_FILE},
{"max-speed ", no_argument, 0, LONG_OPTION_MAX_SPEED},
{"test-dir", required_argument, 0, LONG_OPTION_TEST_DIR},
{"delay-on-exit", required_argument, 0, LONG_OPTION_DELAY_EXIT},
{"shift-packet", required_argument, 0, LONG_OPTION_SHIFT_PACKET},
{"shift-packets", required_argument, 0, LONG_OPTION_SHIFT_PACKETS},
{"help", no_argument, 0, LONG_OPTION_HELP},
{"version", no_argument, 0, LONG_OPTION_VERSION},
{NULL, 0, NULL, 0}
};
/*
* Parsing command line
*/
while ((option = getopt_long (argc, argv, "vhmc:s:d:f:F", long_options, NULL)) != -1) {
switch (option) {
case LONG_OPTION_ENB_CONF_FILE:
case 'c':
if (optarg) {
*enb_config_file_name = strdup(optarg);
printf("eNB config file name is %s\n", *enb_config_file_name);
rv |= PLAY_SCENARIO;
}
break;
case LONG_OPTION_SCENARIO_FILE:
case 's':
if (optarg) {
*scenario_file_name = strdup(optarg);
printf("Scenario file name is %s\n", *scenario_file_name);
rv |= PLAY_SCENARIO;
}
break;
case LONG_OPTION_TEST_DIR:
case 'd':
if (optarg) {
*et_dir_name = strdup(optarg);
if (is_file_exists(*et_dir_name, "test dirname") != GS_IS_DIR) {
fprintf(stderr, "Please provide a valid test dirname, %s is not a valid directory name\n", *et_dir_name);
exit(1);
}
printf("Test dir name is %s\n", *et_dir_name);
}
break;
case LONG_OPTION_DELAY_EXIT:
case 'D':
if (optarg) {
delay_on_exit = atoi(optarg);
if (0 > delay_on_exit) {
fprintf(stderr, "Please provide a valid -D/--delay-on-exit argument, %s is not a valid value\n", delay_on_exit);
exit(1);
}
printf("Delay on exit is %d\n", delay_on_exit);
}
break;
case LONG_OPTION_SHIFT_PACKET:
case 'f':
if (optarg) {
if (NULL == *shifts) {
shift = calloc(1, sizeof (*shift));
*shifts = shift;
} else {
shift->next = calloc(1, sizeof (*shift));
shift = shift->next;
}
shift->single = 1;
printf("Arg Shift packet %s\n", optarg);
et_get_shift_arg(optarg, shift);
}
break;
case LONG_OPTION_SHIFT_PACKETS:
case 'F':
if (optarg) {
if (NULL == *shifts) {
shift = calloc(1, sizeof (*shift));
*shifts = shift;
} else {
shift->next = calloc(1, sizeof (*shift));
shift = shift->next;
}
et_get_shift_arg(optarg, shift);
printf("Arg Shift packets %s\n", optarg);
}
break;
case LONG_OPTION_MAX_SPEED:
case 'm':
g_max_speed = 1;
break;
case LONG_OPTION_VERSION:
case 'v':
printf("Version %s\n", PACKAGE_VERSION);
exit (0);
break;
case LONG_OPTION_HELP:
case 'h':
default:
et_usage (argc, argv);
exit (0);
}
}
if (NULL == *et_dir_name) {
fprintf(stderr, "Please provide a valid test dirname\n");
exit(1);
}
if (chdir(*et_dir_name) != 0) {
fprintf(stderr, "ERROR: chdir %s returned %s\n", *et_dir_name, strerror(errno));
exit(1);
}
if (rv & PLAY_SCENARIO) {
if (NULL == *enb_config_file_name) {
fprintf(stderr, "ERROR: please provide the original eNB config file name that should be in %s\n", *et_dir_name);
}
if (is_file_exists(*enb_config_file_name, "eNB config file") != GS_IS_FILE) {
fprintf(stderr, "ERROR: original eNB config file name %s is not found in dir %s\n", *enb_config_file_name, *et_dir_name);
}
et_enb_config_init(*enb_config_file_name);
if (NULL == *scenario_file_name) {
fprintf(stderr, "ERROR: please provide the scenario file name that should be in %s\n", *et_dir_name);
}
if (is_file_exists(*scenario_file_name, "Scenario file") != GS_IS_FILE) {
fprintf(stderr, "ERROR: Scenario file name %s is not found in dir %s\n", *scenario_file_name, *et_dir_name);
}
}
return rv;
}
//------------------------------------------------------------------------------
int main( int argc, char **argv )
//------------------------------------------------------------------------------
{
int actions = 0;
char *et_dir_name = NULL;
char *scenario_file_name = NULL;
char *enb_config_file_name = NULL;
struct shift_packet_s *shifts = NULL;
int ret = 0;
int delay_on_exit = 0;
et_scenario_t *scenario = NULL;
char play_scenario_filename[NAME_MAX];
memset(play_scenario_filename, 0, sizeof(play_scenario_filename));
// logging
logInit();
set_glog(LOG_TRACE, LOG_MED);
itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info, messages_definition_xml, NULL);
set_comp_log(ENB_APP, LOG_TRACE, LOG_MED, 1);
set_comp_log(S1AP, LOG_TRACE, LOG_MED, 1);
set_comp_log(SCTP, LOG_TRACE, LOG_FULL, 1);
asn_debug = 0;
asn1_xer_print = 1;
//parameters
actions = et_config_parse_opt_line (argc, argv, &et_dir_name, &scenario_file_name, &enb_config_file_name, &shifts, &delay_on_exit); //Command-line options
if (actions & PLAY_SCENARIO) {
if (et_generate_xml_scenario(et_dir_name, scenario_file_name,enb_config_file_name, play_scenario_filename) == 0) {
if (NULL != (scenario = et_generate_scenario(play_scenario_filename))) {
ret = et_play_scenario(scenario, shifts);
} else {
fprintf(stderr, "ERROR: Could not generate scenario from tsml file\n");
ret = -1;
}
} else {
fprintf(stderr, "ERROR: Could not generate tsml scenario from xml file\n");
ret = -1;
}
et_free_pointer(et_dir_name);
et_free_pointer(scenario_file_name);
et_free_pointer(enb_config_file_name);
}
itti_wait_tasks_end();
if (0 < delay_on_exit) {
sleep(delay_on_exit);
}
return ret;
}
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario.h
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#ifndef PLAY_SCENARIO_H_
#define PLAY_SCENARIO_H_
# include <time.h>
# include <stdint.h>
# include <libxml/tree.h>
# include <libxml/xpath.h>
# include <netinet/in.h>
#include "S1AP-PDU.h"
#include "s1ap_ies_defs.h"
#include "play_scenario_s1ap_eNB_defs.h"
#include "hashtable.h"
#include "asn_compare.h"
#define ET_XPATH_EXPRESSION_MAX_LENGTH 400
// powers of 2
#define ET_BIT_MASK_MATCH_SCTP_STREAM 1
#define ET_BIT_MASK_MATCH_SCTP_SSN 2
//#define ET_BIT_MASK_MATCH_S1AP_ 2
#define MAX_ENB 16
#define ENB_CONFIG_STRING_ACTIVE_ENBS "Active_eNBs"
#define ENB_CONFIG_STRING_ENB_LIST "eNBs"
#define ENB_CONFIG_STRING_ENB_ID "eNB_ID"
#define ENB_CONFIG_STRING_CELL_TYPE "cell_type"
#define ENB_CONFIG_STRING_ENB_NAME "eNB_name"
#define ENB_CONFIG_STRING_TRACKING_AREA_CODE "tracking_area_code"
#define ENB_CONFIG_STRING_MOBILE_COUNTRY_CODE "mobile_country_code"
#define ENB_CONFIG_STRING_MOBILE_NETWORK_CODE "mobile_network_code"
#define ENB_CONFIG_STRING_MME_IP_ADDRESS "mme_ip_address"
#define ENB_CONFIG_STRING_MME_IPV4_ADDRESS "ipv4"
#define ENB_CONFIG_STRING_MME_IPV6_ADDRESS "ipv6"
#define ENB_CONFIG_STRING_MME_IP_ADDRESS_ACTIVE "active"
#define ENB_CONFIG_STRING_MME_IP_ADDRESS_PREFERENCE "preference"
#define ENB_CONFIG_STRING_SCTP_CONFIG "SCTP"
#define ENB_CONFIG_STRING_SCTP_INSTREAMS "SCTP_INSTREAMS"
#define ENB_CONFIG_STRING_SCTP_OUTSTREAMS "SCTP_OUTSTREAMS"
#define ENB_CONFIG_STRING_NETWORK_INTERFACES_CONFIG "NETWORK_INTERFACES"
#define ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1_MME "ENB_INTERFACE_NAME_FOR_S1_MME"
#define ENB_CONFIG_STRING_ENB_IPV4_ADDRESS_FOR_S1_MME "ENB_IPV4_ADDRESS_FOR_S1_MME"
#define ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1U "ENB_INTERFACE_NAME_FOR_S1U"
#define ENB_CONFIG_STRING_ENB_IPV4_ADDR_FOR_S1U "ENB_IPV4_ADDRESS_FOR_S1U"
#define ENB_CONFIG_STRING_ENB_PORT_FOR_S1U "ENB_PORT_FOR_S1U"
typedef struct shift_packet_s {
unsigned int frame_number; // original frame number
int shift_seconds;
int shift_microseconds;
int single; // shift timing only for this packet (not also following packets)
struct shift_packet_s *next;
} shift_packet_t;
typedef struct mme_ip_address_s {
unsigned ipv4:1;
unsigned ipv6:1;
unsigned active:1;
char *ipv4_address;
char *ipv6_address;
} mme_ip_address_t;
#define IPV4_STR_ADDR_TO_INT_NWBO(AdDr_StR,NwBo,MeSsAgE ) do {\
struct in_addr inp;\
if ( inet_aton(AdDr_StR, &inp ) < 0 ) {\
AssertFatal (0, MeSsAgE);\
} else {\
NwBo = inp.s_addr;\
}\
} while (0);
typedef struct Enb_properties_s {
/* Unique eNB_id to identify the eNB within EPC.
* For macro eNB ids this field should be 20 bits long.
* For home eNB ids this field should be 28 bits long.
*/
uint32_t eNB_id;
/* The type of the cell */
enum cell_type_e cell_type;
/* Optional name for the cell
* NOTE: the name can be NULL (i.e no name) and will be cropped to 150
* characters.
*/
char *eNB_name;
/* Tracking area code */
uint16_t tac;
/* Mobile Country Code
* Mobile Network Code
*/
uint16_t mcc;
uint16_t mnc;
uint8_t mnc_digit_length;
/* Physical parameters */
int16_t Nid_cell[1+MAX_NUM_CCs];// for testing, change later
/* Nb of MME to connect to */
uint8_t nb_mme;
/* List of MME to connect to */
mme_ip_address_t mme_ip_address[S1AP_MAX_NB_MME_IP_ADDRESS];
int sctp_in_streams;
int sctp_out_streams;
char *enb_interface_name_for_S1U;
in_addr_t enb_ipv4_address_for_S1U;
tcp_udp_port_t enb_port_for_S1U;
char *enb_interface_name_for_S1_MME;
in_addr_t enb_ipv4_address_for_S1_MME;
} Enb_properties_t;
typedef struct Enb_properties_array_s {
int number;
Enb_properties_t *properties[MAX_ENB];
} Enb_properties_array_t;
# define ET_ENB_REGISTER_RETRY_DELAY 3
# define ET_FSM_STATE_WAITING_RX_EVENT_DELAY_SEC 15
typedef enum {
ET_PACKET_STATUS_START = 0,
ET_PACKET_STATUS_NONE = ET_PACKET_STATUS_START,
ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT,
ET_PACKET_STATUS_SCHEDULED_FOR_SENDING,
ET_PACKET_STATUS_SENT,
ET_PACKET_STATUS_SCHEDULED_FOR_RECEIVING,
ET_PACKET_STATUS_RECEIVED,
ET_PACKET_STATUS_END
} et_packet_status_t;
typedef enum {
ET_FSM_STATE_START = 0,
ET_FSM_STATE_NULL = ET_FSM_STATE_START,
ET_FSM_STATE_CONNECTING_S1C,
ET_FSM_STATE_WAITING_RX_EVENT,
ET_FSM_STATE_WAITING_TX_EVENT,
ET_FSM_STATE_RUNNING,
ET_FSM_STATE_END
} et_fsm_state_t;
enum COMPARE_ERR_CODE_e;
typedef enum {
ET_ERROR_MATCH_START = COMPARE_ERR_CODE_END,
ET_ERROR_MATCH_PACKET_SCTP_CHUNK_TYPE = ET_ERROR_MATCH_START,
ET_ERROR_MATCH_PACKET_SCTP_PPID,
ET_ERROR_MATCH_PACKET_SCTP_ASSOC_ID,
ET_ERROR_MATCH_PACKET_SCTP_STREAM_ID,
ET_ERROR_MATCH_PACKET_SCTP_SSN,
ET_ERROR_MATCH_PACKET_S1AP_PRESENT,
ET_ERROR_MATCH_PACKET_S1AP_PROCEDURE_CODE,
ET_ERROR_MATCH_PACKET_S1AP_CRITICALITY,
ET_ERROR_MATCH_END
} et_error_match_code_t;
typedef enum {
ET_PACKET_ACTION_S1C_START = 0,
ET_PACKET_ACTION_S1C_NULL = ET_PACKET_ACTION_S1C_START,
ET_PACKET_ACTION_S1C_SEND,
ET_PACKET_ACTION_S1C_RECEIVE,
ET_PACKET_ACTION_S1C_END
} et_packet_action_t;
// from kernel source file 3.19/include/linux/sctp.h
typedef enum {
SCTP_CID_DATA = 0,
SCTP_CID_INIT = 1,
SCTP_CID_INIT_ACK = 2,
SCTP_CID_SACK = 3,
SCTP_CID_HEARTBEAT = 4,
SCTP_CID_HEARTBEAT_ACK = 5,
SCTP_CID_ABORT = 6,
SCTP_CID_SHUTDOWN = 7,
SCTP_CID_SHUTDOWN_ACK = 8,
SCTP_CID_ERROR = 9,
SCTP_CID_COOKIE_ECHO = 10,
SCTP_CID_COOKIE_ACK = 11,
SCTP_CID_ECN_ECNE = 12,
SCTP_CID_ECN_CWR = 13,
SCTP_CID_SHUTDOWN_COMPLETE = 14,
/* AUTH Extension Section 4.1 */
SCTP_CID_AUTH = 0x0F,
/* PR-SCTP Sec 3.2 */
SCTP_CID_FWD_TSN = 0xC0,
/* Use hex, as defined in ADDIP sec. 3.1 */
SCTP_CID_ASCONF = 0xC1,
SCTP_CID_ASCONF_ACK = 0x80,
} sctp_cid_t; /* enum */
typedef enum {
TEST_S1AP_PDU_TYPE_START = 0,
TEST_S1AP_PDU_TYPE_UNKNOWN = TEST_S1AP_PDU_TYPE_START,
TEST_S1AP_PDU_TYPE_INITIATING,
TEST_S1AP_PDU_TYPE_SUCCESSFUL_OUTCOME,
TEST_S1AP_PDU_TYPE_UNSUCCESSFUL_OUTCOME,
TEST_S1AP_PDU_TYPE_END
} et_s1ap_pdu_type_t;
typedef struct et_s1ap_s {
//et_s1ap_pdu_type_t pdu_type;
S1AP_PDU_t pdu; // decoded ASN1 C type: choice of initiatingMessage, successfulOutcome, unsuccessfulOutcome
uint16_t xml_stream_pos_offset;
uint16_t binary_stream_pos;
uint16_t binary_stream_allocated_size;
uint8_t *binary_stream;
s1ap_message message; // decoded message: information elements
xmlDocPtr doc; // XML representation of the S1AP PDU
} et_s1ap_t;
// from kernel source file 3.19/include/linux/sctp.h, Big Endians
typedef struct sctp_datahdr_s {
uint32_t tsn;
uint16_t stream;
uint16_t ssn;
uint32_t ppid;
uint32_t assoc_id; // filled when running scenario
et_s1ap_t payload;
} sctp_datahdr_t;
// from kernel source file 3.19/include/linux/sctp.h, Big Endians
typedef struct sctp_inithdr {
uint32_t init_tag;
uint32_t a_rwnd;
uint16_t num_outbound_streams;
uint16_t num_inbound_streams;
uint32_t initial_tsn;
uint8_t params[0];
} sctp_inithdr_t;
typedef sctp_inithdr_t sctp_initackhdr_t;
typedef struct et_sctp_hdr_s {
unsigned int src_port;
unsigned int dst_port;
sctp_cid_t chunk_type;
union {
sctp_datahdr_t data_hdr;
sctp_inithdr_t init_hdr;
sctp_initackhdr_t init_ack_hdr;
} u;
} et_sctp_hdr_t;
typedef struct et_ip_s {
unsigned int address_family; // AF_INET, AF_INET6
union {
struct in6_addr ipv6;
in_addr_t ipv4;
}address;
char str[INET6_ADDRSTRLEN+1];
}et_ip_t;
typedef struct et_ip_hdr_s {
et_ip_t src;
et_ip_t dst;
} et_ip_hdr_t;
typedef struct et_packet_s {
et_packet_action_t action;
struct timeval time_relative_to_first_packet;
struct timeval time_relative_to_last_sent_packet;
struct timeval time_relative_to_last_received_packet;
unsigned int original_frame_number;
unsigned int packet_number;
instance_t enb_instance;
et_ip_hdr_t ip_hdr;
et_sctp_hdr_t sctp_hdr;
struct et_packet_s *next;
//scenario running vars
et_packet_status_t status;
long timer_id; // ITTI timer id for waiting rx packets
struct timeval timestamp_packet; // timestamp when rx or tx packet
}et_packet_t;
typedef struct sctp_epoll_s {
/* Array of events monitored by the task.
* By default only one fd is monitored (the one used to received messages
* from other tasks).
* More events can be suscribed later by the task itself.
*/
struct epoll_event *events;
int epoll_nb_events;
} thread_desc_t;
typedef struct et_scenario_s {
xmlChar *name;
et_packet_t *list_packet;
//--------------------------
// playing scenario
//--------------------------
Enb_properties_array_t *enb_properties;
uint32_t register_enb_pending;
uint32_t registered_enb;
long enb_register_retry_timer_id;
hash_table_t *hash_mme2association_id;
hash_table_t *hash_old_ue_mme_id2ue_mme_id;
struct timeval time_last_tx_packet; // Time last sent packet
struct timeval time_last_rx_packet; // Time last packet received with all previous scenario RX packet received.
et_packet_t *last_rx_packet; // Last packet received with all previous scenario RX packet received.
et_packet_t *last_tx_packet; // Last sent packet
et_packet_t *next_packet; // Next packet to be handled in the scenario (RX or TX packet)
int timer_count;
} et_scenario_t;
typedef enum {
ET_EVENT_START = 0,
ET_EVENT_INIT = ET_EVENT_START,
ET_EVENT_S1C_CONNECTED,
ET_EVENT_RX_SCTP_EVENT,
ET_EVENT_RX_S1AP,
ET_EVENT_RX_PACKET_TIME_OUT,
ET_EVENT_TX_TIMED_PACKET,
ET_EVENT_TICK,
ET_EVENT_END
} et_event_code_t;
typedef struct et_event_init_s {
et_scenario_t *scenario;
} et_event_init_t;
typedef struct et_event_s1ap_data_ind_s {
sctp_datahdr_t sctp_datahdr;
} et_event_s1ap_data_ind_t;
typedef struct et_event_s1ap_data_req_s {
} et_event_s1ap_data_req_t;
typedef struct et_event_s {
et_event_code_t code;
union {
et_event_init_t init;
et_event_s1ap_data_ind_t s1ap_data_ind;
et_packet_t *tx_timed_packet;
et_packet_t *rx_packet_time_out;
} u;
} et_event_t;
inline void et_free_pointer(void *p) {if (NULL != p) {free(p); p=NULL;}};
//-------------------------
void et_free_packet(et_packet_t* packet);
void et_free_scenario(et_scenario_t* scenario);
//-------------------------
void et_display_packet_s1ap_data(const et_s1ap_t * const s1ap);
void et_display_packet_sctp_init(const sctp_inithdr_t * const sctp);
void et_display_packet_sctp_initack(const sctp_initackhdr_t * const sctp);
void et_display_packet_sctp_data(const sctp_datahdr_t * const sctp);
void et_display_packet_sctp(const et_sctp_hdr_t * const sctp);
void et_display_packet_ip(const et_ip_hdr_t * const ip);
void et_display_packet(const et_packet_t * const packet);
void et_display_scenario(const et_scenario_t * const scenario);
//-------------------------
int et_s1ap_decode_initiating_message(s1ap_message *message, S1ap_InitiatingMessage_t *initiating_p);
int et_s1ap_decode_successful_outcome(s1ap_message *message, S1ap_SuccessfulOutcome_t *successfullOutcome_p);
int et_s1ap_decode_unsuccessful_outcome(s1ap_message *message, S1ap_UnsuccessfulOutcome_t *unSuccessfullOutcome_p);
int et_s1ap_decode_pdu(S1AP_PDU_t * const pdu, s1ap_message * const message, const uint8_t * const buffer, const uint32_t length);
void et_decode_s1ap(et_s1ap_t * const s1ap);
//-------------------------
int et_s1ap_eNB_compare_assoc_id( struct s1ap_eNB_mme_data_s *p1, struct s1ap_eNB_mme_data_s *p2);
uint32_t et_s1ap_generate_eNB_id(void);
uint16_t et_s1ap_eNB_fetch_add_global_cnx_id(void);
void et_s1ap_eNB_prepare_internal_data(void);
void et_s1ap_eNB_insert_new_instance(s1ap_eNB_instance_t *new_instance_p);
struct s1ap_eNB_mme_data_s *et_s1ap_eNB_get_MME(s1ap_eNB_instance_t *instance_p,int32_t assoc_id, uint16_t cnx_id);
s1ap_eNB_instance_t *et_s1ap_eNB_get_instance(instance_t instance);
void et_s1ap_eNB_itti_send_sctp_data_req(instance_t instance, int32_t assoc_id, uint8_t *buffer,uint32_t buffer_length, uint16_t stream);
int et_handle_s1ap_mismatch_mme_ue_s1ap_id(et_packet_t * const spacket, et_packet_t * const rx_packet);
asn_comp_rval_t* et_s1ap_is_matching(et_s1ap_t * const s1ap1, et_s1ap_t * const s1ap2, const uint32_t constraints);
et_packet_t* et_build_packet_from_s1ap_data_ind(et_event_s1ap_data_ind_t * const s1ap_data_ind);
int et_scenario_set_packet_received(et_packet_t * const packet);
int et_s1ap_process_rx_packet(et_event_s1ap_data_ind_t * const sctp_data_ind);
void et_s1ap_eNB_handle_sctp_data_ind(sctp_data_ind_t * const sctp_data_ind);
void et_s1ap_eNB_register_mme(s1ap_eNB_instance_t *instance_p,
net_ip_address_t *mme_ip_address,
net_ip_address_t *local_ip_addr,
uint16_t in_streams,
uint16_t out_streams);
void et_s1ap_handle_s1_setup_message(s1ap_eNB_mme_data_t *mme_desc_p, int sctp_shutdown);
void et_s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *s1ap_register_eNB);
void et_s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp);
void * et_s1ap_eNB_task(void *arg);
//-------------------------
int et_generate_xml_scenario(
const char const * xml_in_dir_name,
const char const * xml_in_scenario_filename,
const char const * enb_config_filename,
char const * tsml_out_scenario_filename);
//-------------------------
void timeval_add (struct timeval * const result, const struct timeval * const a, const struct timeval * const b);
int timeval_subtract (struct timeval * const result, struct timeval * const a, struct timeval * const b);
void et_scenario_wait_rx_packet(et_packet_t * const packet);
void et_scenario_schedule_tx_packet(et_packet_t * packet);
et_fsm_state_t et_scenario_fsm_notify_event_state_running(et_event_t event);
et_fsm_state_t et_scenario_fsm_notify_event_state_waiting_tx(et_event_t event);
et_fsm_state_t et_scenario_fsm_notify_event_state_waiting_rx(et_event_t event);
et_fsm_state_t et_scenario_fsm_notify_event_state_connecting_s1c(et_event_t event);
et_fsm_state_t et_scenario_fsm_notify_event_state_null(et_event_t event);
et_fsm_state_t et_scenario_fsm_notify_event(et_event_t event);
//-------------------------
void et_parse_s1ap(xmlDocPtr doc, const xmlNode const *s1ap_node, et_s1ap_t * const s1ap);
void et_parse_sctp_data_chunk(xmlDocPtr doc, const xmlNode const *sctp_node, sctp_datahdr_t * const sctp_hdr);
void et_parse_sctp_init_chunk(xmlDocPtr doc, const xmlNode const *sctp_node, sctp_inithdr_t * const sctp_hdr);
void et_parse_sctp_init_ack_chunk(xmlDocPtr doc, const xmlNode const *sctp_node, sctp_initackhdr_t * const sctp_hdr);
void et_parse_sctp(xmlDocPtr doc, const xmlNode const *sctp_node, et_sctp_hdr_t * const sctp_hdr);
et_packet_t* et_parse_xml_packet(xmlDocPtr doc, xmlNodePtr node);
et_scenario_t* et_generate_scenario(const char * const et_scenario_filename);
//-------------------------
asn_comp_rval_t * et_s1ap_ies_is_matching(const S1AP_PDU_PR present, s1ap_message * const m1, s1ap_message * const m2, const uint32_t constraints);
void update_xpath_node_mme_ue_s1ap_id(et_s1ap_t * const s1ap, xmlNode *node, const S1ap_MME_UE_S1AP_ID_t new_id);
void update_xpath_nodes_mme_ue_s1ap_id(et_s1ap_t * const s1ap_payload, xmlNodeSetPtr nodes, const S1ap_MME_UE_S1AP_ID_t new_id);
int et_s1ap_update_mme_ue_s1ap_id(et_packet_t * const packet, const S1ap_MME_UE_S1AP_ID_t old_id, const S1ap_MME_UE_S1AP_ID_t new_id);
//-------------------------
asn_comp_rval_t * et_sctp_data_is_matching(sctp_datahdr_t * const sctp1, sctp_datahdr_t * const sctp2, const uint32_t constraints);
asn_comp_rval_t * et_sctp_is_matching(et_sctp_hdr_t * const sctp1, et_sctp_hdr_t * const sctp2, const uint32_t constraints);
//------------------------------------------------------------------------------
void et_print_hex_octets(const unsigned char * const byte_stream, const unsigned long int num);
int et_is_file_exists ( const char const * file_nameP, const char const *file_roleP);
int et_strip_extension( char *in_filename);
void et_get_shift_arg( char * line_argument, shift_packet_t * const shift);
int et_split_path ( char * pathP, char *** resP);
void et_display_node ( xmlNodePtr node, unsigned int indent);
void et_display_tree ( xmlNodePtr node, unsigned int indent);
char * et_ip2ip_str(const et_ip_t * const ip);
int et_compare_et_ip_to_net_ip_address(const et_ip_t * const ip, const net_ip_address_t * const net_ip);
int et_hex2data(unsigned char * const data, const unsigned char * const hexstring, const unsigned int len);
sctp_cid_t et_chunk_type_str2cid(const xmlChar * const chunk_type_str);
const char * const et_chunk_type_cid2str(const sctp_cid_t chunk_type);
const char * const et_error_match2str(const int err);
et_packet_action_t et_action_str2et_action_t(const xmlChar * const action);
void et_ip_str2et_ip(const xmlChar * const ip_str, et_ip_t * const ip);
void et_enb_config_init(const char const * lib_config_file_name_pP);
const Enb_properties_array_t *et_enb_config_get(void);
void et_eNB_app_register(const Enb_properties_array_t *enb_properties);
void *et_eNB_app_task(void *args_p);
int et_play_scenario(et_scenario_t* const scenario, const struct shift_packet_s *shifts);
#endif /* PLAY_SCENARIO_H_ */
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario_decode.c
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#include "intertask_interface.h"
#include "platform_types.h"
#include "s1ap_ies_defs.h"
#include "s1ap_eNB_decoder.h"
#include "assertions.h"
#include "play_scenario.h"
//------------------------------------------------------------------------------
int et_s1ap_decode_initiating_message(s1ap_message *message, S1ap_InitiatingMessage_t *initiating_p)
{
int ret = -1;
DevAssert(initiating_p != NULL);
message->procedureCode = initiating_p->procedureCode;
message->criticality = initiating_p->criticality;
switch(initiating_p->procedureCode) {
case S1ap_ProcedureCode_id_downlinkNASTransport:
ret = s1ap_decode_s1ap_downlinknastransporties(&message->msg.s1ap_DownlinkNASTransportIEs,&initiating_p->value);
break;
case S1ap_ProcedureCode_id_InitialContextSetup:
ret = s1ap_decode_s1ap_initialcontextsetuprequesties(&message->msg.s1ap_InitialContextSetupRequestIEs, &initiating_p->value);
break;
case S1ap_ProcedureCode_id_UEContextRelease:
ret = s1ap_decode_s1ap_uecontextreleasecommandies(&message->msg.s1ap_UEContextReleaseCommandIEs, &initiating_p->value);
break;
case S1ap_ProcedureCode_id_Paging:
ret = s1ap_decode_s1ap_pagingies(&message->msg.s1ap_PagingIEs, &initiating_p->value);
break;
case S1ap_ProcedureCode_id_uplinkNASTransport:
ret = s1ap_decode_s1ap_uplinknastransporties (&message->msg.s1ap_UplinkNASTransportIEs, &initiating_p->value);
break;
case S1ap_ProcedureCode_id_S1Setup:
ret = s1ap_decode_s1ap_s1setuprequesties (&message->msg.s1ap_S1SetupRequestIEs, &initiating_p->value);
break;
case S1ap_ProcedureCode_id_initialUEMessage:
ret = s1ap_decode_s1ap_initialuemessageies (&message->msg.s1ap_InitialUEMessageIEs, &initiating_p->value);
break;
case S1ap_ProcedureCode_id_UEContextReleaseRequest:
ret = s1ap_decode_s1ap_uecontextreleaserequesties (&message->msg.s1ap_UEContextReleaseRequestIEs, &initiating_p->value);
break;
case S1ap_ProcedureCode_id_UECapabilityInfoIndication:
ret = s1ap_decode_s1ap_uecapabilityinfoindicationies (&message->msg.s1ap_UECapabilityInfoIndicationIEs, &initiating_p->value);
break;
case S1ap_ProcedureCode_id_NASNonDeliveryIndication:
ret = s1ap_decode_s1ap_nasnondeliveryindication_ies (&message->msg.s1ap_NASNonDeliveryIndication_IEs, &initiating_p->value);
break;
default:
AssertFatal( 0 , "Unknown procedure ID (%d) for initiating message\n",
(int)initiating_p->procedureCode);
return -1;
}
return ret;
}
//------------------------------------------------------------------------------
int et_s1ap_decode_successful_outcome(s1ap_message *message, S1ap_SuccessfulOutcome_t *successfullOutcome_p)
{
int ret = -1;
DevAssert(successfullOutcome_p != NULL);
message->procedureCode = successfullOutcome_p->procedureCode;
message->criticality = successfullOutcome_p->criticality;
switch(successfullOutcome_p->procedureCode) {
case S1ap_ProcedureCode_id_S1Setup:
ret = s1ap_decode_s1ap_s1setupresponseies(
&message->msg.s1ap_S1SetupResponseIEs, &successfullOutcome_p->value);
break;
case S1ap_ProcedureCode_id_InitialContextSetup:
ret = s1ap_decode_s1ap_initialcontextsetupresponseies (&message->msg.s1ap_InitialContextSetupResponseIEs, &successfullOutcome_p->value);
break;
case S1ap_ProcedureCode_id_UEContextRelease:
ret = s1ap_decode_s1ap_uecontextreleasecompleteies (&message->msg.s1ap_UEContextReleaseCompleteIEs, &successfullOutcome_p->value);
break;
default:
AssertFatal(0, "Unknown procedure ID (%d) for successfull outcome message\n",
(int)successfullOutcome_p->procedureCode);
return -1;
}
return ret;
}
//------------------------------------------------------------------------------
int et_s1ap_decode_unsuccessful_outcome(s1ap_message *message, S1ap_UnsuccessfulOutcome_t *unSuccessfullOutcome_p)
{
int ret = -1;
DevAssert(unSuccessfullOutcome_p != NULL);
message->procedureCode = unSuccessfullOutcome_p->procedureCode;
message->criticality = unSuccessfullOutcome_p->criticality;
switch(unSuccessfullOutcome_p->procedureCode) {
case S1ap_ProcedureCode_id_S1Setup:
ret = s1ap_decode_s1ap_s1setupfailureies(&message->msg.s1ap_S1SetupFailureIEs, &unSuccessfullOutcome_p->value);
break;
case S1ap_ProcedureCode_id_InitialContextSetup:
ret = s1ap_decode_s1ap_initialcontextsetupfailureies (&message->msg.s1ap_InitialContextSetupFailureIEs, &unSuccessfullOutcome_p->value);
break;
default:
AssertFatal(0,"Unknown procedure ID (%d) for unsuccessfull outcome message\n",
(int)unSuccessfullOutcome_p->procedureCode);
break;
}
return ret;
}
//------------------------------------------------------------------------------
int et_s1ap_decode_pdu(S1AP_PDU_t * const pdu, s1ap_message * const message, const uint8_t * const buffer, const uint32_t length)
{
asn_dec_rval_t dec_ret;
DevAssert(buffer != NULL);
memset((void *)pdu, 0, sizeof(S1AP_PDU_t));
dec_ret = aper_decode(NULL,
&asn_DEF_S1AP_PDU,
(void **)&pdu,
buffer,
length,
0,
0);
if (dec_ret.code != RC_OK) {
S1AP_ERROR("Failed to decode pdu\n");
return -1;
}
message->direction = pdu->present;
switch(pdu->present) {
case S1AP_PDU_PR_initiatingMessage:
return et_s1ap_decode_initiating_message(message,
&pdu->choice.initiatingMessage);
case S1AP_PDU_PR_successfulOutcome:
return et_s1ap_decode_successful_outcome(message,
&pdu->choice.successfulOutcome);
case S1AP_PDU_PR_unsuccessfulOutcome:
return et_s1ap_decode_unsuccessful_outcome(message,
&pdu->choice.unsuccessfulOutcome);
default:
AssertFatal(0, "Unknown presence (%d) or not implemented\n", (int)pdu->present);
break;
}
return -1;
}
//------------------------------------------------------------------------------
void et_decode_s1ap(et_s1ap_t * const s1ap)
{
if (NULL != s1ap) {
if (et_s1ap_decode_pdu(&s1ap->pdu, &s1ap->message, s1ap->binary_stream, s1ap->binary_stream_allocated_size) < 0) {
AssertFatal (0, "ERROR %s() Cannot decode S1AP message!\n", __FUNCTION__);
}
}
}
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario_display.c
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#include <string.h>
#include <stdio.h>
#include "intertask_interface.h"
#include "platform_types.h"
#include "assertions.h"
#include "s1ap_ies_defs.h"
#include "s1ap_eNB_decoder.h"
#include "play_scenario.h"
//-----------------------------------------------------------------------------
void et_print_hex_octets(const unsigned char * const byte_stream, const unsigned long int num)
{
unsigned long octet_index = 0;
if (byte_stream == NULL) {
return;
}
fprintf(stdout, "+-----+-------------------------------------------------+\n");
fprintf(stdout, "| | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n");
fprintf(stdout, "+-----+-------------------------------------------------+\n");
for (octet_index = 0; octet_index < num; octet_index++) {
if ((octet_index % 16) == 0) {
if (octet_index != 0) {
fprintf(stdout, " |\n");
}
fprintf(stdout, " %04ld |", octet_index);
}
/*
* Print every single octet in hexadecimal form
*/
fprintf(stdout, " %02x", byte_stream[octet_index]);
/*
* Align newline and pipes according to the octets in groups of 2
*/
}
/*
* Append enough spaces and put final pipe
*/
unsigned char index;
for (index = octet_index; index < 16; ++index) {
fprintf(stdout, " ");
}
fprintf(stdout, " |\n");
}
//------------------------------------------------------------------------------
void et_display_node(xmlNodePtr node, unsigned int indent)
{
int i = 0;
if (node->type == XML_ELEMENT_NODE) {
xmlChar *path = xmlGetNodePath(node);
for (i=0; i<indent; i++) {
printf(" ");
}
if (node->children != NULL && node->children->type == XML_TEXT_NODE) {
xmlChar *content = xmlNodeGetContent(node);
printf("%s -> %s\n", path, content);
xmlFree(content);
} else {
printf("%s\n", path);
}
xmlFree(path);
}
}
//------------------------------------------------------------------------------
void et_display_tree(xmlNodePtr node, unsigned int indent)
{
xmlNode *cur_node = NULL;
for (cur_node = node; cur_node; cur_node = cur_node->next) {
if (cur_node->type == XML_ELEMENT_NODE) {
et_display_node(cur_node, indent);
}
et_display_tree(cur_node->children, indent++);
}
}
//------------------------------------------------------------------------------
void et_display_packet_s1ap_data(const et_s1ap_t * const s1ap)
{
char *message_string = NULL;
if (s1ap) {
message_string = calloc(20000, sizeof(char));
AssertFatal (NULL != message_string, "ERROR malloc()failed!\n");
s1ap_string_total_size = 0;
switch(s1ap->pdu.present) {
case S1AP_PDU_PR_initiatingMessage:
switch(s1ap->pdu.choice.initiatingMessage.procedureCode) {
case S1ap_ProcedureCode_id_downlinkNASTransport: s1ap_xer_print_s1ap_downlinknastransport(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_InitialContextSetup: s1ap_xer_print_s1ap_initialcontextsetuprequest(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_UEContextRelease: s1ap_xer_print_s1ap_uecontextreleasecommand(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_Paging: s1ap_xer_print_s1ap_paging(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_uplinkNASTransport: s1ap_xer_print_s1ap_uplinknastransport(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_S1Setup: s1ap_xer_print_s1ap_s1setuprequest(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_initialUEMessage: s1ap_xer_print_s1ap_initialuemessage(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_UEContextReleaseRequest: s1ap_xer_print_s1ap_uecontextreleaserequest(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_UECapabilityInfoIndication:s1ap_xer_print_s1ap_uecapabilityinfoindication(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_NASNonDeliveryIndication: s1ap_xer_print_s1ap_nasnondeliveryindication_(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
default:
AssertFatal( 0 , "Unknown procedure ID (%d) for initiating message\n",
(int)s1ap->pdu.choice.initiatingMessage.procedureCode);
}
break;
case S1AP_PDU_PR_successfulOutcome:
switch(s1ap->pdu.choice.successfulOutcome.procedureCode) {
case S1ap_ProcedureCode_id_S1Setup: s1ap_xer_print_s1ap_s1setupresponse(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_InitialContextSetup: s1ap_xer_print_s1ap_initialcontextsetupresponse(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_UEContextRelease: s1ap_xer_print_s1ap_uecontextreleasecomplete(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
default:
AssertFatal(0, "Unknown procedure ID (%d) for successfull outcome message\n",
(int)s1ap->pdu.choice.successfulOutcome.procedureCode);
}
break;
case S1AP_PDU_PR_unsuccessfulOutcome:
switch(s1ap->pdu.choice.unsuccessfulOutcome.procedureCode) {
case S1ap_ProcedureCode_id_S1Setup: s1ap_xer_print_s1ap_s1setupfailure(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
case S1ap_ProcedureCode_id_InitialContextSetup: s1ap_xer_print_s1ap_initialcontextsetupfailure(s1ap_xer__print2sp, message_string, (s1ap_message *)&s1ap->message);break;
default:
et_free_pointer(message_string);
AssertFatal(0,"Unknown procedure ID (%d) for unsuccessfull outcome message\n",
(int)s1ap->pdu.choice.unsuccessfulOutcome.procedureCode);
break;
}
break;
default:
AssertFatal(0, "Unknown presence (%d) or not implemented\n", (int)s1ap->pdu.present);
break;
}
fprintf(stdout, "\t\tSCTP.data XML dump:\n%s\n", message_string);
et_free_pointer(message_string);
}
}
//------------------------------------------------------------------------------
void et_display_packet_sctp_init(const sctp_inithdr_t * const sctp)
{
if (sctp) {
fprintf(stdout, "\t\tSCTP.init.init_tag : %u\n", sctp->init_tag);
fprintf(stdout, "\t\tSCTP.init.a_rwnd : %u\n", sctp->a_rwnd);
fprintf(stdout, "\t\tSCTP.init.num_inbound_streams : %u\n", sctp->num_inbound_streams);
fprintf(stdout, "\t\tSCTP.init.num_outbound_streams : %u\n", sctp->num_outbound_streams);
fprintf(stdout, "\t\tSCTP.init.initial_tsn : %u\n", sctp->initial_tsn);
}
}
//------------------------------------------------------------------------------
void et_display_packet_sctp_initack(const sctp_initackhdr_t * const sctp)
{
if (sctp) {
fprintf(stdout, "\t\tSCTP.initack.init_tag : %u\n", sctp->init_tag);
fprintf(stdout, "\t\tSCTP.initack.a_rwnd : %u\n", sctp->a_rwnd);
fprintf(stdout, "\t\tSCTP.initack.num_inbound_streams : %u\n", sctp->num_inbound_streams);
fprintf(stdout, "\t\tSCTP.initack.num_outbound_streams : %u\n", sctp->num_outbound_streams);
fprintf(stdout, "\t\tSCTP.initack.initial_tsn : %u\n", sctp->initial_tsn);
}
}
//------------------------------------------------------------------------------
void et_display_packet_sctp_data(const sctp_datahdr_t * const sctp)
{
if (sctp) {
fprintf(stdout, "\t\tSCTP.data.tsn : %u\n", sctp->tsn);
fprintf(stdout, "\t\tSCTP.data.stream : %u\n", sctp->stream);
fprintf(stdout, "\t\tSCTP.data.ssn : %u\n", sctp->ssn);
fprintf(stdout, "\t\tSCTP.data.ppid : %u\n", sctp->ppid);
if (sctp->ppid == 18) {
et_display_packet_s1ap_data(&sctp->payload);
}
fprintf(stdout, "\t\tSCTP.data.binary_stream_allocated_size : %u\n", sctp->payload.binary_stream_allocated_size);
if (NULL != sctp->payload.binary_stream) {
fprintf(stdout, "\t\tSCTP.data.binary_stream :\n");
et_print_hex_octets(sctp->payload.binary_stream, sctp->payload.binary_stream_allocated_size);
} else {
fprintf(stdout, "\t\tSCTP.data.binary_stream : NULL\n");
}
}
}
//------------------------------------------------------------------------------
void et_display_packet_sctp(const et_sctp_hdr_t * const sctp)
{
if (sctp) {
fprintf(stdout, "\t\tSCTP.src_port : %u\n", sctp->src_port);
fprintf(stdout, "\t\tSCTP.dst_port : %u\n", sctp->dst_port);
fprintf(stdout, "\t\tSCTP.chunk_type : %s\n", et_chunk_type_cid2str(sctp->chunk_type));
switch (sctp->chunk_type) {
case SCTP_CID_DATA:
et_display_packet_sctp_data(&sctp->u.data_hdr);
break;
case SCTP_CID_INIT:
et_display_packet_sctp_initack(&sctp->u.init_hdr);
break;
case SCTP_CID_INIT_ACK:
et_display_packet_sctp_initack(&sctp->u.init_ack_hdr);
break;
default:
;
}
}
}
//------------------------------------------------------------------------------
void et_display_packet_ip(const et_ip_hdr_t * const ip)
{
if (ip) {
fprintf(stdout, "\t\tSource address : %s\n", et_ip2ip_str(&ip->src));
fprintf(stdout, "\t\tDestination address : %s\n", et_ip2ip_str(&ip->dst));
}
}
//------------------------------------------------------------------------------
void et_display_packet(const et_packet_t * const packet)
{
if (packet) {
fprintf(stdout, "-------------------------------------------------------------------------------\n");
fprintf(stdout, "\tPacket:\tnum %u | original frame number %u \n", packet->packet_number, packet->original_frame_number);
fprintf(stdout, "\tPacket:\ttime relative to 1st packet %ld.%06lu\n",
packet->time_relative_to_first_packet.tv_sec, packet->time_relative_to_first_packet.tv_usec);
fprintf(stdout, "\tPacket:\ttime relative to last tx packet %ld.%06lu\n",
packet->time_relative_to_last_sent_packet.tv_sec, packet->time_relative_to_last_sent_packet.tv_usec);
fprintf(stdout, "\tPacket:\ttime relative to last_received packet %ld.%06lu\n",
packet->time_relative_to_last_received_packet.tv_sec, packet->time_relative_to_last_received_packet.tv_usec);
switch(packet->action) {
case ET_PACKET_ACTION_S1C_SEND:
fprintf(stdout, "\tPacket:\tAction SEND\n");
break;
case ET_PACKET_ACTION_S1C_RECEIVE:
fprintf(stdout, "\tPacket:\tAction RECEIVE\n");
break;
default:
fprintf(stdout, "\tPacket:\tAction UNKNOWN\n");
}
switch(packet->status) {
case ET_PACKET_STATUS_NONE:
fprintf(stdout, "\tPacket:\tStatus NONE\n");
break;
case ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT:
fprintf(stdout, "\tPacket:\tStatus NOT_TAKEN_IN_ACCOUNT\n");
break;
case ET_PACKET_STATUS_SCHEDULED_FOR_SENDING:
fprintf(stdout, "\tPacket:\tStatus SCHEDULED_FOR_SENDING\n");
break;
case ET_PACKET_STATUS_SENT:
fprintf(stdout, "\tPacket:\tStatus SENT\n");
break;
case ET_PACKET_STATUS_SCHEDULED_FOR_RECEIVING:
fprintf(stdout, "\tPacket:\tStatus SCHEDULED_FOR_RECEIVING\n");
break;
case ET_PACKET_STATUS_RECEIVED:
fprintf(stdout, "\tPacket:\tStatus RECEIVED\n");
break;
default:
fprintf(stdout, "\tPacket:\tStatus UNKNOWN\n");
}
et_display_packet_ip(&packet->ip_hdr);
et_display_packet_sctp(&packet->sctp_hdr);
}
}
//------------------------------------------------------------------------------
void et_display_scenario(const et_scenario_t * const scenario)
{
et_packet_t *packet = NULL;
if (scenario) {
fprintf(stdout, "Scenario: %s\n", (scenario->name != NULL) ? (char*)scenario->name:"UNKNOWN NAME");
packet = scenario->list_packet;
while (packet) {
et_display_packet(packet);
packet = packet->next;
}
}
}
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario_fsm.c
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#include <stdio.h>
#include <sys/time.h>
#include <pthread.h>
#include "intertask_interface.h"
#include "platform_types.h"
#include "assertions.h"
#include "play_scenario.h"
#include "s1ap_ies_defs.h"
#include "play_scenario_s1ap_eNB_defs.h"
#include "timer.h"
//------------------------------------------------------------------------------
extern int g_max_speed;
//------------------------------------------------------------------------------
et_scenario_t *g_scenario = NULL;
pthread_mutex_t g_fsm_lock = PTHREAD_MUTEX_INITIALIZER;
et_fsm_state_t g_fsm_state = ET_FSM_STATE_NULL;
uint32_t g_constraints = ET_BIT_MASK_MATCH_SCTP_STREAM | ET_BIT_MASK_MATCH_SCTP_SSN;
//------------------------------------------------------------------------------
// it is assumed that if a time is negative tv_sec and tv_usec are both negative
void timeval_add (struct timeval * const result, const struct timeval * const a, const struct timeval * const b)
{
AssertFatal(((a->tv_sec <= 0) && (a->tv_usec <= 0)) || ((a->tv_sec >= 0) && (a->tv_usec >= 0)), " Bad time format arg a\n");
AssertFatal(((b->tv_sec <= 0) && (b->tv_usec <= 0)) || ((b->tv_sec >= 0) && (b->tv_usec >= 0)), " Bad time format arg b\n");
// may happen overflows but were are not dealing with very large timings
long long int r = a->tv_usec + b->tv_usec + (a->tv_sec + b->tv_sec) * 1000000;
result->tv_sec = r / (long long int)1000000;
result->tv_usec = r % (long long int)1000000;
if ((result != a) && (result != b)) {
LOG_D(ENB_APP, "timeval_add(%ld.%06d, %ld.%06d)=%ld.%06d\n", a->tv_sec, a->tv_usec, b->tv_sec, b->tv_usec, result->tv_sec, result->tv_usec);
}
}
//------------------------------------------------------------------------------
// it is assumed that if a time is negative tv_sec and tv_usec are both negative
// return true if result is positive
int timeval_subtract (struct timeval * const result, struct timeval * const a, struct timeval * const b)
{
AssertFatal(((a->tv_sec <= 0) && (a->tv_usec <= 0)) || ((a->tv_sec >= 0) && (a->tv_usec >= 0)), " Bad time format arg a\n");
AssertFatal(((b->tv_sec <= 0) && (b->tv_usec <= 0)) || ((b->tv_sec >= 0) && (b->tv_usec >= 0)), " Bad time format arg b\n");
// may happen overflows but were are not dealing with very large timings
long long int r = a->tv_usec - b->tv_usec + (a->tv_sec - b->tv_sec) * 1000000;
result->tv_sec = r / (long long int)1000000;
result->tv_usec = r % (long long int)1000000;
if ((result != a) && (result != b)) {
LOG_D(ENB_APP, "timeval_subtract(%ld.%06d, %ld.%06d)=%ld.%06d\n", a->tv_sec, a->tv_usec, b->tv_sec, b->tv_usec, result->tv_sec, result->tv_usec);
}
return (result->tv_sec >= 0) && (result->tv_usec >= 0);
}
//------------------------------------------------------------------------------
void et_scenario_wait_rx_packet(et_packet_t * const packet)
{
packet->status = ET_PACKET_STATUS_SCHEDULED_FOR_RECEIVING;
g_fsm_state = ET_FSM_STATE_WAITING_RX_EVENT;
if (timer_setup (ET_FSM_STATE_WAITING_RX_EVENT_DELAY_SEC, 0, TASK_S1AP, INSTANCE_DEFAULT, TIMER_ONE_SHOT,
packet, &packet->timer_id) < 0) {
AssertFatal(0, " Can not start waiting RX event timer\n");
}
g_scenario->timer_count++;
LOG_D(ENB_APP, "Waiting RX packet num %d original frame number %u\n", packet->packet_number, packet->original_frame_number);
}
//------------------------------------------------------------------------------
void et_scenario_schedule_tx_packet(et_packet_t * packet)
{
s1ap_eNB_instance_t *s1ap_eNB_instance = NULL;
struct timeval now = { .tv_sec = 0, .tv_usec = 0 };
struct timeval offset_last_tx_packet = { .tv_sec = 0, .tv_usec = 0 };
struct timeval offset_last_rx_packet = { .tv_sec = 0, .tv_usec = 0 };
struct timeval offset_tx_rx = { .tv_sec = 0, .tv_usec = 0 };
struct timeval offset = { .tv_sec = 0, .tv_usec = 0 };
int last_packet_was_rx = 0;
int we_are_too_late = 0;
int original_frame_number = -1;
AssertFatal(NULL != packet, "packet argument is NULL");
s1ap_eNB_instance = et_s1ap_eNB_get_instance(packet->enb_instance);
AssertFatal(NULL != s1ap_eNB_instance, "Cannot get s1ap_eNB_instance_t for eNB instance %d", packet->enb_instance);
LOG_D(ENB_APP, "%s\n", __FUNCTION__);
g_fsm_state = ET_FSM_STATE_WAITING_TX_EVENT;
switch (packet->sctp_hdr.chunk_type) {
case SCTP_CID_DATA:
// check if we can send it now
// TODO: BUG we have to discard in scenario all packets that cannot be processed (SACK, COOKIEs, etc)
AssertFatal(gettimeofday(&now, NULL) == 0, "gettimeofday failed");
timeval_subtract(&offset_last_tx_packet,&now,&g_scenario->time_last_tx_packet);
timeval_subtract(&offset_last_rx_packet,&now,&g_scenario->time_last_rx_packet);
LOG_D(ENB_APP, "offset_last_tx_packet=%ld.%06d\n", offset_last_tx_packet.tv_sec, offset_last_tx_packet.tv_usec);
LOG_D(ENB_APP, "offset_last_rx_packet=%ld.%06d\n", offset_last_rx_packet.tv_sec, offset_last_rx_packet.tv_usec);
last_packet_was_rx = timeval_subtract(&offset_tx_rx,&offset_last_tx_packet,&offset_last_rx_packet);
if (last_packet_was_rx) {
LOG_D(ENB_APP, "last_packet_was_rx\n");
we_are_too_late = timeval_subtract(&offset,&offset_last_rx_packet,&packet->time_relative_to_last_received_packet);
LOG_D(ENB_APP, "we_are_too_late=%d, offset=%ld.%06d\n", we_are_too_late, offset.tv_sec, offset.tv_usec);
} else {
LOG_D(ENB_APP, "last_packet_was_tx\n");
we_are_too_late = timeval_subtract(&offset,&offset_last_tx_packet,&packet->time_relative_to_last_sent_packet);
LOG_D(ENB_APP, "we_are_too_late=%d, offset=%ld.%06d\n", we_are_too_late, offset.tv_sec, offset.tv_usec);
}
if ((0 == we_are_too_late) && (0 == g_max_speed)){
// set timer
if ((offset.tv_sec <= 0) || (offset.tv_usec <= 0)){
offset.tv_sec = -offset.tv_sec;
offset.tv_usec = -offset.tv_usec;
}
LOG_D(ENB_APP, "Send packet num %u original frame number %u in %ld.%06d sec\n",
packet->packet_number, packet->original_frame_number, offset.tv_sec, offset.tv_usec);
packet->status = ET_PACKET_STATUS_SCHEDULED_FOR_SENDING;
if (timer_setup (offset.tv_sec, offset.tv_usec, TASK_S1AP, INSTANCE_DEFAULT, TIMER_ONE_SHOT,packet, &packet->timer_id) < 0) {
AssertFatal(0, " Can not start TX event timer\n");
}
g_scenario->timer_count++;
// Done g_fsm_state = ET_FSM_STATE_WAITING_TX_EVENT;
} else {
// send immediately
AssertFatal(0 == gettimeofday(&packet->timestamp_packet, NULL), "gettimeofday() Failed");
original_frame_number = packet->original_frame_number;
do {
g_scenario->time_last_tx_packet.tv_sec = packet->timestamp_packet.tv_sec;
g_scenario->time_last_tx_packet.tv_usec = packet->timestamp_packet.tv_usec;
LOG_D(ENB_APP, "Sending packet num %d original frame number %u immediately\n",packet->packet_number, packet->original_frame_number);
et_s1ap_eNB_itti_send_sctp_data_req(
packet->enb_instance,
packet->sctp_hdr.u.data_hdr.assoc_id,
packet->sctp_hdr.u.data_hdr.payload.binary_stream,
packet->sctp_hdr.u.data_hdr.payload.binary_stream_allocated_size,
packet->sctp_hdr.u.data_hdr.stream);
packet->status = ET_PACKET_STATUS_SENT;
g_scenario->next_packet = g_scenario->next_packet->next;
packet = packet->next;
} while ((NULL != packet) && (packet->original_frame_number == original_frame_number));
g_fsm_state = ET_FSM_STATE_RUNNING;
}
break;
case SCTP_CID_INIT:
case SCTP_CID_INIT_ACK:
AssertFatal(0, "Invalid case TX packet SCTP_CID_INIT or SCTP_CID_INIT_ACK");
break;
default:
AssertFatal(0, "Invalid case TX packet SCTP_CID %d", packet->sctp_hdr.chunk_type);
}
}
//------------------------------------------------------------------------------
et_fsm_state_t et_scenario_fsm_notify_event_state_running(et_event_t event)
{
switch (event.code){
case ET_EVENT_TICK:
while (NULL != g_scenario->next_packet) {
LOG_D(ENB_APP, "EVENT_TICK: Considering packet num %d original frame number %u\n", g_scenario->next_packet->packet_number, g_scenario->next_packet->original_frame_number);
switch (g_scenario->next_packet->sctp_hdr.chunk_type) {
case SCTP_CID_DATA :
// no init in this scenario, may be sub-scenario
if (g_scenario->next_packet->action == ET_PACKET_ACTION_S1C_SEND) {
if (g_scenario->next_packet->status == ET_PACKET_STATUS_NONE) {
et_scenario_schedule_tx_packet(g_scenario->next_packet);
pthread_mutex_unlock(&g_fsm_lock);
et_event_t continue_event;
continue_event.code = ET_EVENT_TICK;
et_scenario_fsm_notify_event(continue_event);
return g_fsm_state;
} else if (g_scenario->next_packet->status != ET_PACKET_STATUS_SCHEDULED_FOR_SENDING) {
AssertFatal(0, "Invalid packet status %d", g_scenario->next_packet->status);
}
} else if (g_scenario->next_packet->action == ET_PACKET_ACTION_S1C_RECEIVE) {
if (g_scenario->next_packet->status == ET_PACKET_STATUS_RECEIVED) {
g_scenario->next_packet = g_scenario->next_packet->next;
} else if (g_scenario->next_packet->status == ET_PACKET_STATUS_NONE) {
et_scenario_wait_rx_packet(g_scenario->next_packet);
pthread_mutex_unlock(&g_fsm_lock);
return g_fsm_state;
} else {
AssertFatal(0, "Invalid packet status %d", g_scenario->next_packet->status);
}
} else {
AssertFatal(0, "Invalid packet action %d", g_scenario->next_packet->action);
}
break;
case SCTP_CID_INIT:
case SCTP_CID_INIT_ACK:
case SCTP_CID_HEARTBEAT:
case SCTP_CID_HEARTBEAT_ACK:
case SCTP_CID_COOKIE_ECHO:
case SCTP_CID_COOKIE_ACK:
case SCTP_CID_ECN_ECNE:
case SCTP_CID_ECN_CWR:
LOG_D(ENB_APP, "EVENT_TICK: Ignoring packet num %d SCTP CID %s\n",
g_scenario->next_packet->packet_number,
et_chunk_type_cid2str(g_scenario->next_packet->sctp_hdr.chunk_type));
g_scenario->next_packet->status = ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT;
g_scenario->next_packet = g_scenario->next_packet->next;
break;
case SCTP_CID_ABORT:
case SCTP_CID_SHUTDOWN:
case SCTP_CID_SHUTDOWN_ACK:
case SCTP_CID_ERROR:
case SCTP_CID_SHUTDOWN_COMPLETE:
AssertFatal(0, "The scenario should be cleaned (packet %s cannot be processed at this time)",
et_chunk_type_cid2str(g_scenario->next_packet->sctp_hdr.chunk_type));
break;
default:
LOG_D(ENB_APP, "EVENT_TICK: Ignoring packet num %d SCTP CID %s\n",
g_scenario->next_packet->packet_number,
et_chunk_type_cid2str(g_scenario->next_packet->sctp_hdr.chunk_type));
g_scenario->next_packet->status = ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT;
g_scenario->next_packet = g_scenario->next_packet->next;
}
}
fprintf(stderr, "No Packet found in this scenario: %s\n", g_scenario->name);
g_fsm_state = ET_FSM_STATE_NULL;
pthread_mutex_unlock(&g_fsm_lock);
if (0 == g_scenario->timer_count) {
fprintf(stderr, "End of scenario: %s\n", g_scenario->name);
fflush(stderr);
fflush(stdout);
return 0;
//exit(0);
}
fprintf(stderr, "Remaining timers running: %d\n", g_scenario->timer_count);
return g_fsm_state;
break;
case ET_EVENT_RX_PACKET_TIME_OUT:
AssertFatal(0, "Event ET_EVENT_RX_PACKET_TIME_OUT not handled in FSM state ET_FSM_STATE_RUNNING");
break;
case ET_EVENT_TX_TIMED_PACKET:
AssertFatal(0, "Event ET_EVENT_TX_TIMED_PACKET not handled in FSM state ET_FSM_STATE_RUNNING");
break;
case ET_EVENT_RX_S1AP:
et_s1ap_process_rx_packet(&event.u.s1ap_data_ind);
break;
default:
AssertFatal(0, "Case event %d not handled in ET_FSM_STATE_RUNNING", event.code);
}
pthread_mutex_unlock(&g_fsm_lock);
return 0;
}
//------------------------------------------------------------------------------
et_fsm_state_t et_scenario_fsm_notify_event_state_waiting_tx(et_event_t event)
{
int rv = 0;
int original_frame_number = -1;
et_packet_t *packet = NULL;
switch (event.code){
case ET_EVENT_TICK:
fprintf(stdout, "EVENT_TICK: waiting for tx event\n");
break;
case ET_EVENT_RX_S1AP:
rv = et_s1ap_process_rx_packet(&event.u.s1ap_data_ind);
break;
case ET_EVENT_TX_TIMED_PACKET:
// send immediately
packet = event.u.tx_timed_packet;
AssertFatal(0 == gettimeofday(&packet->timestamp_packet, NULL), "gettimeofday() Failed");
original_frame_number = packet->original_frame_number;
do {
g_scenario->time_last_tx_packet.tv_sec = packet->timestamp_packet.tv_sec;
g_scenario->time_last_tx_packet.tv_usec = packet->timestamp_packet.tv_usec;
LOG_D(ENB_APP, "Sending packet num %d original frame number %u immediately\n",packet->packet_number, packet->original_frame_number);
et_s1ap_eNB_itti_send_sctp_data_req(
packet->enb_instance,
packet->sctp_hdr.u.data_hdr.assoc_id,
packet->sctp_hdr.u.data_hdr.payload.binary_stream,
packet->sctp_hdr.u.data_hdr.payload.binary_stream_allocated_size,
packet->sctp_hdr.u.data_hdr.stream);
packet->status = ET_PACKET_STATUS_SENT;
packet = packet->next;
g_scenario->next_packet = packet;
} while ( (NULL != packet) && (packet->original_frame_number == original_frame_number));
g_fsm_state = ET_FSM_STATE_RUNNING;
break;
case ET_EVENT_RX_PACKET_TIME_OUT:
default:
AssertFatal(0, "Case event %d not handled in ET_FSM_STATE_WAITING_TX", event.code);
}
pthread_mutex_unlock(&g_fsm_lock);
return 0;
}
//------------------------------------------------------------------------------
et_fsm_state_t et_scenario_fsm_notify_event_state_waiting_rx(et_event_t event)
{
int rv = 0;
switch (event.code){
case ET_EVENT_TICK:
fprintf(stdout, "EVENT_TICK: waiting for rx event\n");
break;
case ET_EVENT_RX_PACKET_TIME_OUT:
fprintf(stderr, "Error The following packet is not received:\n");
//et_display_packet(event.u.rx_packet_time_out);
AssertFatal(0, "Waited packet not received");
break;
case ET_EVENT_RX_S1AP:
rv = et_s1ap_process_rx_packet(&event.u.s1ap_data_ind);
// waited packet
if (rv == 0) {
g_fsm_state = ET_FSM_STATE_RUNNING;
}
break;
case ET_EVENT_TX_TIMED_PACKET:
default:
AssertFatal(0, "Case event %d not handled in ET_FSM_STATE_WAITING_RX", event.code);
}
pthread_mutex_unlock(&g_fsm_lock);
return 0;
}
//------------------------------------------------------------------------------
et_fsm_state_t et_scenario_fsm_notify_event_state_connecting_s1c(et_event_t event)
{
switch (event.code){
case ET_EVENT_TICK:
break;
case ET_EVENT_S1C_CONNECTED:
// hack simulate we have been able to get the right timing values for STCP connect
AssertFatal(gettimeofday(&g_scenario->time_last_rx_packet, NULL) == 0, "gettimeofday failed");
while (NULL != g_scenario->next_packet) {
switch (g_scenario->next_packet->sctp_hdr.chunk_type) {
case SCTP_CID_DATA :
// no init in this scenario, may be sub-scenario
if (g_scenario->next_packet->action == ET_PACKET_ACTION_S1C_SEND) {
et_scenario_schedule_tx_packet(g_scenario->next_packet);
pthread_mutex_unlock(&g_fsm_lock);
et_event_t continue_event;
continue_event.code = ET_EVENT_TICK;
et_scenario_fsm_notify_event(continue_event);
return g_fsm_state;
} else if (g_scenario->next_packet->action == ET_PACKET_ACTION_S1C_RECEIVE) {
if (g_scenario->next_packet->status == ET_PACKET_STATUS_RECEIVED) {
g_scenario->last_rx_packet = g_scenario->next_packet;
g_scenario->time_last_rx_packet = g_scenario->last_rx_packet->timestamp_packet;
g_scenario->next_packet = g_scenario->next_packet->next;
} else if (g_scenario->next_packet->status == ET_PACKET_STATUS_NONE) {
et_scenario_wait_rx_packet(g_scenario->next_packet);
pthread_mutex_unlock(&g_fsm_lock);
return g_fsm_state;
} else {
AssertFatal(0, "Invalid packet status %d", g_scenario->next_packet->status);
}
} else {
AssertFatal(0, "Invalid packet action %d", g_scenario->next_packet->action);
}
break;
case SCTP_CID_INIT:
case SCTP_CID_INIT_ACK:
case SCTP_CID_HEARTBEAT:
case SCTP_CID_HEARTBEAT_ACK:
case SCTP_CID_COOKIE_ECHO:
case SCTP_CID_COOKIE_ACK:
case SCTP_CID_ECN_ECNE:
case SCTP_CID_ECN_CWR:
g_scenario->next_packet->status = ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT;
g_scenario->next_packet = g_scenario->next_packet->next;
break;
case SCTP_CID_ABORT:
case SCTP_CID_SHUTDOWN:
case SCTP_CID_SHUTDOWN_ACK:
case SCTP_CID_ERROR:
case SCTP_CID_SHUTDOWN_COMPLETE:
AssertFatal(0, "The scenario should be cleaned (packet %s cannot be processed at this time)",
et_chunk_type_cid2str(g_scenario->next_packet->sctp_hdr.chunk_type));
break;
default:
g_scenario->next_packet->status = ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT;
g_scenario->next_packet = g_scenario->next_packet->next;
}
}
fprintf(stderr, "No Packet found in this scenario: %s\n", g_scenario->name);
g_fsm_state = ET_FSM_STATE_NULL;
pthread_mutex_unlock(&g_fsm_lock);
if (0 == g_scenario->timer_count) {
fprintf(stderr, "End of scenario: %s\n", g_scenario->name);
fflush(stderr);
fflush(stdout);
exit(0);
}
fprintf(stderr, "Remaining timers running: %d\n", g_scenario->timer_count);
return g_fsm_state;
break;
default:
AssertFatal(0, "Case event %d not handled in ET_FSM_STATE_CONNECTING_S1C", event.code);
}
pthread_mutex_unlock(&g_fsm_lock);
return 0;
}
//------------------------------------------------------------------------------
et_fsm_state_t et_scenario_fsm_notify_event_state_null(et_event_t event)
{
switch (event.code){
case ET_EVENT_TICK:
break;
case ET_EVENT_INIT:
AssertFatal(NULL == g_scenario, "Current scenario not ended");
g_scenario = event.u.init.scenario;
g_scenario->next_packet = g_scenario->list_packet;
g_scenario->last_rx_packet = NULL;
g_scenario->last_tx_packet = NULL;
while (NULL != g_scenario->next_packet) {
switch (g_scenario->next_packet->sctp_hdr.chunk_type) {
case SCTP_CID_DATA :
// no init in this scenario, may be sub-scenario, ...
if (g_scenario->next_packet->action == ET_PACKET_ACTION_S1C_SEND) {
et_scenario_schedule_tx_packet(g_scenario->next_packet);
pthread_mutex_unlock(&g_fsm_lock);
et_event_t continue_event;
continue_event.code = ET_EVENT_TICK;
et_scenario_fsm_notify_event(continue_event);
return g_fsm_state;
} else if (g_scenario->next_packet->action == ET_PACKET_ACTION_S1C_RECEIVE) {
if (g_scenario->next_packet->status == ET_PACKET_STATUS_RECEIVED) {
g_scenario->last_rx_packet = g_scenario->next_packet;
g_scenario->time_last_rx_packet = g_scenario->last_rx_packet->timestamp_packet;
g_scenario->next_packet = g_scenario->next_packet->next;
} else if (g_scenario->next_packet->status == ET_PACKET_STATUS_NONE) {
et_scenario_wait_rx_packet(g_scenario->next_packet);
pthread_mutex_unlock(&g_fsm_lock);
return g_fsm_state;
} else {
AssertFatal(0, "Invalid packet status %d", g_scenario->next_packet->status);
}
} else {
AssertFatal(0, "Invalid packet action %d", g_scenario->next_packet->action);
}
break;
case SCTP_CID_INIT:
case SCTP_CID_INIT_ACK:
g_scenario->enb_properties = (Enb_properties_array_t *)et_enb_config_get();
g_scenario->hash_old_ue_mme_id2ue_mme_id = hashtable_create (256,NULL,NULL);
g_scenario->hash_mme2association_id = hashtable_create (256,NULL,NULL);
// Try to register each eNB
g_scenario->registered_enb = 0;
g_fsm_state = ET_FSM_STATE_CONNECTING_S1C;
AssertFatal(gettimeofday(&g_scenario->time_last_tx_packet, NULL) == 0, "gettimeofday failed");
et_eNB_app_register (g_scenario->enb_properties);
pthread_mutex_unlock(&g_fsm_lock);
return g_fsm_state;
break;
case SCTP_CID_HEARTBEAT:
case SCTP_CID_HEARTBEAT_ACK:
case SCTP_CID_COOKIE_ECHO:
case SCTP_CID_COOKIE_ACK:
case SCTP_CID_ECN_ECNE:
case SCTP_CID_ECN_CWR:
g_scenario->next_packet->status = ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT;
g_scenario->next_packet = g_scenario->next_packet->next;
break;
case SCTP_CID_ABORT:
case SCTP_CID_SHUTDOWN:
case SCTP_CID_SHUTDOWN_ACK:
case SCTP_CID_ERROR:
case SCTP_CID_SHUTDOWN_COMPLETE:
AssertFatal(0, "The scenario should be cleaned (packet %s cannot be processed at this time)",
et_chunk_type_cid2str(g_scenario->next_packet->sctp_hdr.chunk_type));
break;
default:
g_scenario->next_packet->status = ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT;
g_scenario->next_packet = g_scenario->next_packet->next;
}
}
fprintf(stderr, "No Useful packet found in this scenario: %s\n", g_scenario->name);
g_fsm_state = ET_FSM_STATE_NULL;
pthread_mutex_unlock(&g_fsm_lock);
return g_fsm_state;
break;
default:
AssertFatal(0, "Case event %d not handled in ET_FSM_STATE_NULL", event.code);
}
return 0;
}
//------------------------------------------------------------------------------
et_fsm_state_t et_scenario_fsm_notify_event(et_event_t event)
{
AssertFatal((event.code >= ET_EVENT_START) && (event.code < ET_EVENT_END), "Unknown et_event_t.code %d", event.code);
pthread_mutex_lock(&g_fsm_lock);
switch (g_fsm_state){
case ET_FSM_STATE_NULL: return et_scenario_fsm_notify_event_state_null(event); break;
case ET_FSM_STATE_CONNECTING_S1C: return et_scenario_fsm_notify_event_state_connecting_s1c(event); break;
case ET_FSM_STATE_WAITING_TX_EVENT: return et_scenario_fsm_notify_event_state_waiting_tx(event); break;
case ET_FSM_STATE_WAITING_RX_EVENT: return et_scenario_fsm_notify_event_state_waiting_rx(event); break;
case ET_FSM_STATE_RUNNING: return et_scenario_fsm_notify_event_state_running(event); break;
default:
AssertFatal(0, "Case fsm_state %d not handled", g_fsm_state);
}
pthread_mutex_unlock(&g_fsm_lock);
return g_fsm_state;
}
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario_parse.c
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#include <libxml/xmlmemory.h>
#include <libxml/debugXML.h>
#include <libxml/xmlIO.h>
#include <libxml/DOCBparser.h>
#include <libxml/xinclude.h>
#include <libxml/catalog.h>
#include <libxml/xmlreader.h>
#include <libxslt/xslt.h>
#include <libxslt/xsltInternals.h>
#include <libxslt/transform.h>
#include <libxslt/xsltutils.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "intertask_interface.h"
#include "platform_types.h"
#include "assertions.h"
#include "play_scenario.h"
//------------------------------------------------------------------------------
#define ENB_CONFIG_MAX_XSLT_PARAMS 32
//------------------------------------------------------------------------------
extern Enb_properties_array_t g_enb_properties;
//------------------------------------------------------------------------------
void et_parse_s1ap(xmlDocPtr doc, const xmlNode const *s1ap_node, et_s1ap_t * const s1ap)
{
xmlNodePtr cur_node = NULL;
xmlChar *xml_char = NULL;
xmlChar *xml_char2 = NULL;
unsigned int size = 0;
int rc = 0;
unsigned int go_deeper_in_tree = 1;
if ((NULL != s1ap_node) && (NULL != s1ap)) {
// see http://www.xmlsoft.org/html/libxml-tree.html#xmlCopyNode
if (NULL == s1ap->doc) {
xmlUnlinkNode(s1ap_node);
//cur_node = xmlCopyNodeList(s1ap_node);
// arg2: if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable)
//cur_node = xmlCopyNode(s1ap_node, 1);
//AssertFatal(NULL != cur_node, "xmlCopyNode Failed");
s1ap->doc = xmlNewDoc(BAD_CAST "1.0");
xmlDocSetRootElement(s1ap->doc, s1ap_node);
}
for (cur_node = (xmlNode *)s1ap_node; cur_node; cur_node = cur_node->next) {
go_deeper_in_tree = 1;
if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"field"))) {
// do not get hidden fields
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"hide");
if (NULL != xml_char) {
if ((!xmlStrcmp(xml_char, (const xmlChar *)"yes"))) {
go_deeper_in_tree = 0;
}
xmlFree(xml_char);
}
if (0 < go_deeper_in_tree) {
// first get size
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"size");
if (NULL != xml_char) {
size = strtoul((const char *)xml_char, NULL, 0);
xmlFree(xml_char);
// second: try to get value (always hex)
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"value");
if (NULL != xml_char) {
xml_char2 = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"name");
fprintf(stdout, "s1ap %p field name %s size %d value %s\n",s1ap, xml_char2, size, xml_char);
xmlFree(xml_char2);
// if success to get value, do not parse children
//AssertFatal ((xmlStrlen(xml_char) == size), "ERROR %s() mismatch in size %d and strlen %d\n", __FUNCTION__, size, xmlStrlen(xml_char));
//if (xmlStrlen(xml_char) == size) {
AssertFatal ((s1ap->binary_stream_pos+xmlStrlen(xml_char)/2) <= s1ap->binary_stream_allocated_size,
"ERROR in buffer size: binary_stream_pos %d xmlStrlen(xml_char)/2=%d\n", s1ap->binary_stream_pos, xmlStrlen(xml_char)/2);
rc = et_hex2data( &s1ap->binary_stream[s1ap->binary_stream_pos], xml_char, xmlStrlen(xml_char));
s1ap->binary_stream_pos += xmlStrlen(xml_char)/2;
//et_display_node(cur_node, 0);
AssertFatal (rc >= 0, "ERROR in converting hex string %s len %d size %d rc %d\n", xml_char, xmlStrlen(xml_char), size, rc);
go_deeper_in_tree = 0;
//}
xmlFree(xml_char);
}
}
}
}
if (0 < go_deeper_in_tree) {
et_parse_s1ap(doc, cur_node->children, s1ap);
}
}
}
}
//------------------------------------------------------------------------------
void et_parse_sctp_data_chunk(xmlDocPtr doc, const xmlNode const *sctp_node, sctp_datahdr_t * const sctp_hdr)
{
xmlNode *cur_node = NULL;
xmlChar *xml_char = NULL;
xmlChar *xml_char2 = NULL;
if ((NULL != sctp_node) && (NULL != sctp_hdr)) {
xml_char = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"name");
if (NULL != xml_char) {
if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.data_payload_proto_id"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"show");
if (NULL != xml_char2) {
sctp_hdr->ppid = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.data_sid"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"show");
if (NULL != xml_char2) {
sctp_hdr->stream = strtoul((const char *)xml_char2, NULL, 16);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.data_tsn"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"show");
if (NULL != xml_char2) {
sctp_hdr->tsn = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.data_ssn"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"show");
if (NULL != xml_char2) {
sctp_hdr->ssn = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
}
xmlFree(xml_char);
}
for (cur_node = sctp_node->children; cur_node; cur_node = cur_node->next) {
et_parse_sctp_data_chunk(doc, cur_node, sctp_hdr);
}
}
}
//------------------------------------------------------------------------------
void et_parse_sctp_init_chunk(xmlDocPtr doc, const xmlNode const *sctp_node, sctp_inithdr_t * const sctp_hdr)
{
xmlNode *cur_node = NULL;
xmlChar *xml_char = NULL;
xmlChar *xml_char2 = NULL;
if ((NULL != sctp_node) && (NULL != sctp_hdr)) {
xml_char = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"name");
if (NULL != xml_char) {
if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.init_nr_out_streams"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->num_outbound_streams = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.init_nr_in_streams"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->num_inbound_streams = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.init_credit"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->a_rwnd = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.init_initial_tsn"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"show");
if (NULL != xml_char2) {
sctp_hdr->initial_tsn = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.init_initiate_tag"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"show");
if (NULL != xml_char2) {
sctp_hdr->init_tag = strtoul((const char *)xml_char2, NULL, 16);
xmlFree(xml_char2);
}
}
xmlFree(xml_char);
}
for (cur_node = sctp_node->children; cur_node; cur_node = cur_node->next) {
et_parse_sctp_init_chunk(doc, cur_node, sctp_hdr);
}
}
}
//------------------------------------------------------------------------------
void et_parse_sctp_init_ack_chunk(xmlDocPtr doc, const xmlNode const *sctp_node, sctp_initackhdr_t * const sctp_hdr)
{
xmlNode *cur_node = NULL;
xmlChar *xml_char = NULL;
xmlChar *xml_char2 = NULL;
if ((NULL != sctp_node) && (NULL != sctp_hdr)) {
xml_char = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"name");
if (NULL != xml_char) {
if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.initack_nr_out_streams"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->num_outbound_streams = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.initack_nr_in_streams"))) {
xml_char2 = xmlGetProp((xmlNode *)(xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->num_inbound_streams = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.initack_credit"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->a_rwnd = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.initack_initial_tsn"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"show");
if (NULL != xml_char2) {
sctp_hdr->initial_tsn = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.initack_initiate_tag"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"show");
if (NULL != xml_char2) {
sctp_hdr->init_tag = strtoul((const char *)xml_char2, NULL, 16);
xmlFree(xml_char2);
}
}
xmlFree(xml_char);
}
for (cur_node = sctp_node->children; cur_node; cur_node = cur_node->next) {
et_parse_sctp_init_ack_chunk(doc, cur_node, sctp_hdr);
}
}
}
//------------------------------------------------------------------------------
void et_parse_sctp(xmlDocPtr doc, const xmlNode const *sctp_node, et_sctp_hdr_t * const sctp_hdr)
{
xmlNode *cur_node = NULL;
xmlChar *xml_char = NULL;
xmlChar *xml_char2 = NULL;
if ((NULL != sctp_node) && (NULL != sctp_hdr)) {
if ((!xmlStrcmp(sctp_node->name, (const xmlChar *)"proto"))) {
xml_char = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"name");
if (NULL != xml_char) {
if ((!xmlStrcmp(xml_char, (const xmlChar *)"s1ap"))) {
xmlFree(xml_char);
xml_char = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"pos");
if (NULL != xml_char) {
sctp_hdr->u.data_hdr.payload.xml_stream_pos_offset = strtoul((const char *)xml_char, NULL, 0);
xmlFree(xml_char);
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"size");
if (NULL != xml_char2) {
sctp_hdr->u.data_hdr.payload.binary_stream_allocated_size = strtoul((const char *)xml_char2, NULL, 0);
sctp_hdr->u.data_hdr.payload.binary_stream = calloc(1, sctp_hdr->u.data_hdr.payload.binary_stream_allocated_size);
sctp_hdr->u.data_hdr.payload.binary_stream_pos = 0;
fprintf(stdout, "Allocating payload of sctp_hdr %p %u bytes\n", sctp_hdr, sctp_hdr->u.data_hdr.payload.binary_stream_allocated_size);
xmlFree(xml_char2);
}
et_parse_s1ap(doc, sctp_node, &sctp_hdr->u.data_hdr.payload);
et_decode_s1ap(&sctp_hdr->u.data_hdr.payload);
return;
}
}
xmlFree(xml_char);
}
}
//if ((cur_node->type == XML_ATTRIBUTE_NODE) || (cur_node->type == XML_ELEMENT_NODE)) {
xml_char = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"name");
if (NULL != xml_char) {
if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.srcport"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->src_port = strtoul((const char *)xml_char2, NULL, 16);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.dstport"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->dst_port = strtoul((const char *)xml_char2, NULL, 16);
xmlFree(xml_char2);
}
} else if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp.chunk_type"))) {
xml_char2 = xmlGetProp((xmlNode *)sctp_node, (const xmlChar *)"value");
if (NULL != xml_char2) {
sctp_hdr->chunk_type = strtoul((const char *)xml_char2, NULL, 0);
xmlFree(xml_char2);
switch (sctp_hdr->chunk_type) {
case SCTP_CID_DATA:
et_parse_sctp_data_chunk(doc, sctp_node->parent, &sctp_hdr->u.data_hdr);
break;
case SCTP_CID_INIT:
et_parse_sctp_init_chunk(doc, sctp_node->parent, &sctp_hdr->u.init_hdr);
break;
case SCTP_CID_INIT_ACK:
et_parse_sctp_init_ack_chunk(doc, sctp_node->parent, &sctp_hdr->u.init_ack_hdr);
break;
default:
;
}
}
}
}
for (cur_node = sctp_node->children; cur_node; cur_node = cur_node->next) {
et_parse_sctp(doc, cur_node, sctp_hdr);
}
}
}
//------------------------------------------------------------------------------
void et_packet_shift_timing(et_packet_t * const packet, const struct timeval * const shift)
{
timeval_add(&packet->time_relative_to_first_packet, &packet->time_relative_to_first_packet, shift);
AssertFatal((packet->time_relative_to_first_packet.tv_sec >= 0) && (packet->time_relative_to_first_packet.tv_usec >= 0),
"Bad timing result time_relative_to_first_packet=%d.%d packet num %u, original frame number %u",
packet->time_relative_to_first_packet.tv_sec,
packet->time_relative_to_first_packet.tv_usec,
packet->packet_number,
packet->original_frame_number);
timeval_add(&packet->time_relative_to_last_received_packet, &packet->time_relative_to_last_received_packet, shift);
AssertFatal((packet->time_relative_to_last_received_packet.tv_sec >= 0) && (packet->time_relative_to_last_received_packet.tv_usec >= 0),
"Bad timing result time_relative_to_last_received_packet=%d.%d packet num %u, original frame number %u",
packet->time_relative_to_last_received_packet.tv_sec,
packet->time_relative_to_last_received_packet.tv_usec,
packet->packet_number,
packet->original_frame_number);
timeval_add(&packet->time_relative_to_last_sent_packet, &packet->time_relative_to_last_sent_packet, shift);
AssertFatal((packet->time_relative_to_last_sent_packet.tv_sec >= 0) && (packet->time_relative_to_last_sent_packet.tv_usec >= 0),
"Bad timing result time_relative_to_last_sent_packet=%d.%d packet num %u, original frame number %u",
packet->time_relative_to_last_sent_packet.tv_sec,
packet->time_relative_to_last_sent_packet.tv_usec,
packet->packet_number,
packet->original_frame_number);
}
//------------------------------------------------------------------------------
et_packet_t* et_parse_xml_packet(xmlDocPtr doc, xmlNodePtr node)
{
et_packet_t *packet = NULL;
xmlNode *cur_node = NULL;
xmlChar *xml_char = NULL;
float afloat = (float)0.0;
static struct timeval initial_time = { .tv_sec = 0, .tv_usec = 0 };
static struct timeval relative_last_sent_packet = { .tv_sec = 0, .tv_usec = 0 };
static struct timeval relative_last_received_packet = { .tv_sec = 0, .tv_usec = 0 };
static char first_packet = 1;
static char first_sent_packet = 1;
static char first_received_packet = 1;
static unsigned int packet_number = 1;
if (NULL != node) {
packet = calloc(1, sizeof(*packet));
xml_char = xmlGetProp(node, (const xmlChar *)"action");
packet->action = et_action_str2et_action_t(xml_char);
packet->status = ET_PACKET_STATUS_NONE;
xmlFree(xml_char);
packet->packet_number = packet_number++;
for (cur_node = node->children; cur_node; cur_node = cur_node->next) {
//if (cur_node->type == XML_ELEMENT_NODE) {
if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"frame.time_relative"))) {
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"value");
afloat = atof((const char*)xml_char);
xmlFree(xml_char);
fprintf(stdout, "Parsing packet frame.time_relative: %f\n", afloat);
packet->time_relative_to_first_packet.tv_sec = (int)afloat;
packet->time_relative_to_first_packet.tv_usec = (int)((afloat - packet->time_relative_to_first_packet.tv_sec)*1000000.0);
if (first_packet > 0) {
initial_time = packet->time_relative_to_first_packet;
packet->time_relative_to_first_packet.tv_sec = 0;
packet->time_relative_to_first_packet.tv_usec = 0;
first_packet = 0;
} else {
timersub(&packet->time_relative_to_first_packet, &initial_time,
&packet->time_relative_to_first_packet);
}
} else if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"frame.number"))) {
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"value");
packet->original_frame_number = strtoul((const char *)xml_char, NULL, 0);
fprintf(stdout, "Parsing packet frame.number: %u\n", packet->original_frame_number);
xmlFree(xml_char);
} else if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"ip.src"))) {
xml_char = xmlNodeListGetString(doc, cur_node->xmlChildrenNode, 1);
et_ip_str2et_ip(xml_char, &packet->ip_hdr.src);
xmlFree(xml_char);
} else if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"ip.dst"))) {
xml_char = xmlNodeListGetString(doc, cur_node->xmlChildrenNode, 1);
et_ip_str2et_ip(xml_char, &packet->ip_hdr.dst);
xmlFree(xml_char);
} else if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"proto"))) {
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"name");
if (NULL != xml_char) {
if ((!xmlStrcmp(xml_char, (const xmlChar *)"sctp"))) {
et_parse_sctp(doc, cur_node, &packet->sctp_hdr);
}
xmlFree(xml_char);
}
} else if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"eNB.instance"))) {
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"value");
packet->enb_instance = strtoul((const char *)xml_char, NULL, 0);
xmlFree(xml_char);
}
//}
}
}
return packet;
}
//------------------------------------------------------------------------------
et_scenario_t* et_generate_scenario(
const char * const tsml_out_scenario_filename)
{
xmlDocPtr doc = NULL;
xmlNodePtr root = NULL;
xmlNodePtr node = NULL;
xmlChar *xml_char = NULL;
et_scenario_t *scenario = NULL;
et_packet_t *last_packet = NULL;
et_packet_t *packet = NULL;
et_packet_t **next_packet = NULL;
doc = xmlParseFile(tsml_out_scenario_filename);
if (NULL == doc) {
AssertFatal (0, "Could not parse scenario xml file %s!\n", tsml_out_scenario_filename);
} else {
fprintf(stdout, "Test scenario file to play: %s\n", tsml_out_scenario_filename);
//xmlDebugDumpDocument(NULL, doc);
}
// Get root
root = xmlDocGetRootElement(doc);
if (NULL != root) {
if ((!xmlStrcmp(root->name, (const xmlChar *)"scenario"))) {
xml_char = xmlGetProp(root, (const xmlChar *)"name");
printf("scenario name: %s\n", xml_char);
scenario = calloc(1, sizeof(*scenario));
scenario->name = xml_char; // nodup nofree
next_packet = &scenario->list_packet;
for (node = root->children; node != NULL; node = node->next) {
if ((!xmlStrcmp(node->name, (const xmlChar *)"packet"))) {
packet = et_parse_xml_packet(doc, node);
if (NULL != packet) {
// special case: S1AP same frame for 2 packets
if (NULL != last_packet) {
if (last_packet->original_frame_number == packet->original_frame_number) {
// updating because these informations are not in 2nd sctp header (same IP packet)
packet->sctp_hdr.dst_port = last_packet->sctp_hdr.dst_port;
packet->sctp_hdr.src_port = last_packet->sctp_hdr.src_port;
}
}
*next_packet = packet;
next_packet = &packet->next;
} else {
fprintf(stdout, "WARNING omitted packet\n");
}
}
last_packet = packet;
}
}
} else {
fprintf(stderr, "Empty xml document\n");
}
xmlFreeDoc(doc);
xmlCleanupParser();
return scenario;
}
//------------------------------------------------------------------------------
int et_generate_xml_scenario(
const char const * xml_in_dir_name,
const char const * xml_in_scenario_filename,
const char const * enb_config_filename,
char const * tsml_out_scenario_filename)
//------------------------------------------------------------------------------
{
//int fd_pdml_in;
xsltStylesheetPtr cur = NULL;
xmlDocPtr doc, res;
FILE *play_scenario_file = NULL;
const char *params[2*ENB_CONFIG_MAX_XSLT_PARAMS];
int nb_params = 0;
int i,j;
char astring[1024];
struct in_addr addr;
int ret = 0;
memset(astring, 0, sizeof(astring));
if (getcwd(astring, sizeof(astring)) != NULL) {
fprintf(stdout, "working in %s directory\n", astring);
} else {
perror("getcwd() ERROR");
exit(1);
}
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
cur = xsltParseStylesheetFile((const xmlChar *)"/usr/share/oai/xsl/play_scenario.xsl");
if (NULL == cur) {
AssertFatal (0, "Could not parse stylesheet file /usr/share/oai/xsl/play_scenario.xsl!\n");
} else {
fprintf(stdout, "XSLT style sheet: /usr/share/oai/xsl/play_scenario.xsl\n");
}
doc = xmlParseFile(xml_in_scenario_filename);
if (NULL == doc) {
AssertFatal (0, "Could not parse scenario xml file %s!\n", xml_in_scenario_filename);
} else {
fprintf(stdout, "Test scenario file: %s\n", xml_in_scenario_filename);
}
for (i = 0; i < g_enb_properties.number; i++) {
// eNB S1-C IPv4 address
sprintf(astring, "enb%d_s1c", i);
params[nb_params++] = strdup(astring);
addr.s_addr = g_enb_properties.properties[i]->enb_ipv4_address_for_S1_MME;
sprintf(astring, "\"%s\"", inet_ntoa(addr));
params[nb_params++] = strdup(astring);
// MME S1-C IPv4 address
for (j = 0; j < g_enb_properties.properties[i]->nb_mme; j++) {
sprintf(astring, "mme%d_s1c_%d", i, j);
params[nb_params++] = strdup(astring);
AssertFatal (g_enb_properties.properties[i]->mme_ip_address[j].ipv4_address,
"Only support MME IPv4 address\n");
sprintf(astring, "\"%s\"", g_enb_properties.properties[i]->mme_ip_address[j].ipv4_address);
params[nb_params++] = strdup(astring);
}
}
params[nb_params] = NULL;
res = xsltApplyStylesheet(cur, doc, params);
if (NULL != res) {
sprintf((char *)tsml_out_scenario_filename,"%s",xml_in_scenario_filename);
if (et_strip_extension((char *)tsml_out_scenario_filename) > 0) {
strcat((char *)tsml_out_scenario_filename, ".tsml");
play_scenario_file = fopen( tsml_out_scenario_filename, "w+");
if (NULL != play_scenario_file) {
xsltSaveResultToFile(play_scenario_file, res, cur);
fclose(play_scenario_file);
fprintf(stdout, "Wrote test scenario to %s\n", tsml_out_scenario_filename);
} else {
fprintf(stderr, "ERROR in fopen(%s)\n", tsml_out_scenario_filename);
ret = -1;
}
} else {
fprintf(stderr, "ERROR in strip_extension()\n");
ret = -1;
}
} else {
fprintf(stderr, "ERROR in xsltApplyStylesheet()\n");
ret = -1;
}
xsltFreeStylesheet(cur);
xmlFreeDoc(doc);
xmlFreeDoc(res);
xsltCleanupGlobals();
xmlCleanupParser();
return ret;
}
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario_s1ap.c
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <crypt.h>
#include <sys/time.h>
#include "tree.h"
#include "queue.h"
#include "intertask_interface.h"
#include "timer.h"
#include "platform_types.h"
#include "assertions.h"
#include "conversions.h"
#include "s1ap_common.h"
#include "play_scenario_s1ap_eNB_defs.h"
#include "play_scenario.h"
#include "msc.h"
//------------------------------------------------------------------------------
s1ap_eNB_internal_data_t s1ap_eNB_internal_data;
RB_GENERATE(s1ap_mme_map, s1ap_eNB_mme_data_s, entry, et_s1ap_eNB_compare_assoc_id);
//------------------------------------------------------------------------------
extern et_scenario_t *g_scenario;
extern uint32_t g_constraints;
//------------------------------------------------------------------------------
int et_s1ap_eNB_compare_assoc_id(
struct s1ap_eNB_mme_data_s *p1, struct s1ap_eNB_mme_data_s *p2)
{
if (p1->assoc_id == -1) {
if (p1->cnx_id < p2->cnx_id) {
return -1;
}
if (p1->cnx_id > p2->cnx_id) {
return 1;
}
} else {
if (p1->assoc_id < p2->assoc_id) {
return -1;
}
if (p1->assoc_id > p2->assoc_id) {
return 1;
}
}
/* Matching reference */
return 0;
}
//------------------------------------------------------------------------------
uint32_t et_s1ap_generate_eNB_id(void)
{
char *out;
char hostname[50];
int ret;
uint32_t eNB_id;
/* Retrieve the host name */
ret = gethostname(hostname, sizeof(hostname));
DevAssert(ret == 0);
out = crypt(hostname, "eurecom");
DevAssert(out != NULL);
eNB_id = ((out[0] << 24) | (out[1] << 16) | (out[2] << 8) | out[3]);
return eNB_id;
}
//------------------------------------------------------------------------------
uint16_t et_s1ap_eNB_fetch_add_global_cnx_id(void)
{
return ++s1ap_eNB_internal_data.global_cnx_id;
}
//------------------------------------------------------------------------------
void et_s1ap_eNB_prepare_internal_data(void)
{
memset(&s1ap_eNB_internal_data, 0, sizeof(s1ap_eNB_internal_data));
STAILQ_INIT(&s1ap_eNB_internal_data.s1ap_eNB_instances_head);
}
//------------------------------------------------------------------------------
void et_s1ap_eNB_insert_new_instance(s1ap_eNB_instance_t *new_instance_p)
{
DevAssert(new_instance_p != NULL);
STAILQ_INSERT_TAIL(&s1ap_eNB_internal_data.s1ap_eNB_instances_head,
new_instance_p, s1ap_eNB_entries);
}
//------------------------------------------------------------------------------
struct s1ap_eNB_mme_data_s *et_s1ap_eNB_get_MME(
s1ap_eNB_instance_t *instance_p,
int32_t assoc_id, uint16_t cnx_id)
{
struct s1ap_eNB_mme_data_s temp;
struct s1ap_eNB_mme_data_s *found;
memset(&temp, 0, sizeof(struct s1ap_eNB_mme_data_s));
temp.assoc_id = assoc_id;
temp.cnx_id = cnx_id;
if (instance_p == NULL) {
STAILQ_FOREACH(instance_p, &s1ap_eNB_internal_data.s1ap_eNB_instances_head,
s1ap_eNB_entries) {
found = RB_FIND(s1ap_mme_map, &instance_p->s1ap_mme_head, &temp);
if (found != NULL) {
return found;
}
}
} else {
return RB_FIND(s1ap_mme_map, &instance_p->s1ap_mme_head, &temp);
}
return NULL;
}
//------------------------------------------------------------------------------
s1ap_eNB_instance_t *et_s1ap_eNB_get_instance(instance_t instance)
{
s1ap_eNB_instance_t *temp = NULL;
STAILQ_FOREACH(temp, &s1ap_eNB_internal_data.s1ap_eNB_instances_head,
s1ap_eNB_entries) {
if (temp->instance == instance) {
/* Matching occurence */
return temp;
}
}
return NULL;
}
//------------------------------------------------------------------------------
void et_s1ap_eNB_itti_send_sctp_data_req(instance_t instance, int32_t assoc_id, uint8_t *buffer,
uint32_t buffer_length, uint16_t stream)
{
MessageDef *message_p;
sctp_data_req_t *sctp_data_req;
message_p = itti_alloc_new_message(TASK_S1AP, SCTP_DATA_REQ);
sctp_data_req = &message_p->ittiMsg.sctp_data_req;
sctp_data_req->assoc_id = assoc_id;
sctp_data_req->buffer = buffer;
sctp_data_req->buffer_length = buffer_length;
sctp_data_req->stream = stream;
itti_send_msg_to_task(TASK_SCTP, instance, message_p);
}
//------------------------------------------------------------------------------
int et_handle_s1ap_mismatch_mme_ue_s1ap_id(et_packet_t * const spacket, et_packet_t * const rx_packet)
{
S1ap_MME_UE_S1AP_ID_t scenario_mme_ue_s1ap_id = 0;
S1ap_MME_UE_S1AP_ID_t rx_mme_ue_s1ap_id = 0;
S1AP_PDU_PR present;
present = rx_packet->sctp_hdr.u.data_hdr.payload.pdu.present;
switch (rx_packet->sctp_hdr.u.data_hdr.payload.message.procedureCode) {
case S1ap_ProcedureCode_id_HandoverPreparation:
if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverRequiredIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverRequiredIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverCommandIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverCommandIEs.mme_ue_s1ap_id;
}
break;
case S1ap_ProcedureCode_id_HandoverResourceAllocation:
if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverRequestIEs.mme_ue_s1ap_id;
} else if (present == S1AP_PDU_PR_successfulOutcome) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverRequestAcknowledgeIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverRequestAcknowledgeIEs.mme_ue_s1ap_id;
} else if (present == S1AP_PDU_PR_unsuccessfulOutcome) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverFailureIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverFailureIEs.mme_ue_s1ap_id;
}
break;
case S1ap_ProcedureCode_id_HandoverNotification:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverNotifyIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverNotifyIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_PathSwitchRequest:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_PathSwitchRequestIEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_PathSwitchRequestIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_HandoverCancel:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverCancelIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_HandoverCancelIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_E_RABSetup:
if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABSetupRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABSetupRequestIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABSetupResponseIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABSetupResponseIEs.mme_ue_s1ap_id;
}
break;
case S1ap_ProcedureCode_id_E_RABModify:
if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABModifyRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABModifyRequestIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABModifyResponseIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABModifyResponseIEs.mme_ue_s1ap_id;
}
break;
case S1ap_ProcedureCode_id_E_RABRelease:
if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABReleaseCommandIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABReleaseCommandIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABReleaseResponseIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABReleaseResponseIEs.mme_ue_s1ap_id;
}
break;
case S1ap_ProcedureCode_id_E_RABReleaseIndication:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABReleaseIndicationIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_E_RABReleaseIndicationIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_InitialContextSetup:
if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_InitialContextSetupRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_InitialContextSetupRequestIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_InitialContextSetupResponseIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_InitialContextSetupResponseIEs.mme_ue_s1ap_id;
}
break;
case S1ap_ProcedureCode_id_Paging:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_PagingIEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_PagingIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_downlinkNASTransport:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DownlinkNASTransportIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DownlinkNASTransportIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_initialUEMessage:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_InitialUEMessageIEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_InitialUEMessageIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_uplinkNASTransport:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UplinkNASTransportIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UplinkNASTransportIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_Reset:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ResetIEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ResetIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_ErrorIndication:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ErrorIndicationIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ErrorIndicationIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_NASNonDeliveryIndication:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_NASNonDeliveryIndication_IEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_NASNonDeliveryIndication_IEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_S1Setup:
/*if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_S1SetupRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_S1SetupRequestIEs.mme_ue_s1ap_id;
} else if (present == S1AP_PDU_PR_successfulOutcome) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_S1SetupResponseIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_S1SetupResponseIEs.mme_ue_s1ap_id;
} else if (present == S1AP_PDU_PR_unsuccessfulOutcome) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_S1SetupFailureIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_S1SetupFailureIEs.mme_ue_s1ap_id;
}*/
break;
case S1ap_ProcedureCode_id_UEContextReleaseRequest:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseRequestIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_DownlinkS1cdma2000tunneling:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DownlinkS1cdma2000tunnelingIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DownlinkS1cdma2000tunnelingIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_UplinkS1cdma2000tunneling:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UplinkS1cdma2000tunnelingIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UplinkS1cdma2000tunnelingIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_UEContextModification:
if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextModificationRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextModificationRequestIEs.mme_ue_s1ap_id;
} else if (present == S1AP_PDU_PR_successfulOutcome) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextModificationResponseIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextModificationResponseIEs.mme_ue_s1ap_id;
} else if (present == S1AP_PDU_PR_unsuccessfulOutcome) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextModificationFailureIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextModificationFailureIEs.mme_ue_s1ap_id;
}
break;
case S1ap_ProcedureCode_id_UECapabilityInfoIndication:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UECapabilityInfoIndicationIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UECapabilityInfoIndicationIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_UEContextRelease:
if (present == S1AP_PDU_PR_initiatingMessage) {
switch (rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseCommandIEs.uE_S1AP_IDs.present) {
case S1ap_UE_S1AP_IDs_PR_uE_S1AP_ID_pair:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseCommandIEs.uE_S1AP_IDs.choice.uE_S1AP_ID_pair.mME_UE_S1AP_ID;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseCommandIEs.uE_S1AP_IDs.choice.uE_S1AP_ID_pair.mME_UE_S1AP_ID;
break;
case S1ap_UE_S1AP_IDs_PR_mME_UE_S1AP_ID:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseCommandIEs.uE_S1AP_IDs.choice.mME_UE_S1AP_ID;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseCommandIEs.uE_S1AP_IDs.choice.mME_UE_S1AP_ID;
break;
}
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseCompleteIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UEContextReleaseCompleteIEs.mme_ue_s1ap_id;
}
break;
case S1ap_ProcedureCode_id_eNBStatusTransfer:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBStatusTransferIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBStatusTransferIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_MMEStatusTransfer:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEStatusTransferIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEStatusTransferIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_DeactivateTrace:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DeactivateTraceIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DeactivateTraceIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_TraceStart:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_TraceStartIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_TraceStartIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_TraceFailureIndication:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_TraceFailureIndicationIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_TraceFailureIndicationIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_ENBConfigurationUpdate:
/*if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBConfigurationUpdateIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBConfigurationUpdateIEs.mme_ue_s1ap_id;
} else if (present == S1AP_PDU_PR_successfulOutcome) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBConfigurationUpdateAcknowledgeIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBConfigurationUpdateAcknowledgeIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBConfigurationUpdateFailureIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBConfigurationUpdateFailureIEs.mme_ue_s1ap_id;
}*/
break;
case S1ap_ProcedureCode_id_MMEConfigurationUpdate:
/*if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEConfigurationUpdateIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEConfigurationUpdateIEs.mme_ue_s1ap_id;
} else if (present == S1AP_PDU_PR_successfulOutcome) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEConfigurationUpdateAcknowledgeIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEConfigurationUpdateAcknowledgeIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEConfigurationUpdateFailureIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEConfigurationUpdateFailureIEs.mme_ue_s1ap_id;
}*/
break;
case S1ap_ProcedureCode_id_LocationReportingControl:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_LocationReportingControlIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_LocationReportingControlIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_LocationReportingFailureIndication:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_LocationReportingFailureIndicationIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_LocationReportingFailureIndicationIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_LocationReport:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_LocationReportIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_LocationReportIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_OverloadStart:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_OverloadStartIEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_OverloadStartIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_OverloadStop:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_OverloadStopIEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_OverloadStopIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_WriteReplaceWarning:
/*if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_WriteReplaceWarningRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_WriteReplaceWarningRequestIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_WriteReplaceWarningResponseIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_WriteReplaceWarningResponseIEs.mme_ue_s1ap_id;
}*/
break;
case S1ap_ProcedureCode_id_eNBDirectInformationTransfer:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBDirectInformationTransferIEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_ENBDirectInformationTransferIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_MMEDirectInformationTransfer:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEDirectInformationTransferIEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_MMEDirectInformationTransferIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_PrivateMessage:
case S1ap_ProcedureCode_id_eNBConfigurationTransfer:
case S1ap_ProcedureCode_id_MMEConfigurationTransfer:
AssertFatal(0, "TODO");
break;
case S1ap_ProcedureCode_id_CellTrafficTrace:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_CellTrafficTraceIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_CellTrafficTraceIEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_Kill:
/*if (present == S1AP_PDU_PR_initiatingMessage) {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_KillRequestIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_KillRequestIEs.mme_ue_s1ap_id;
} else {
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_KillResponseIEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_KillResponseIEs.mme_ue_s1ap_id;
}*/
break;
case S1ap_ProcedureCode_id_downlinkUEAssociatedLPPaTransport:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DownlinkUEAssociatedLPPaTransport_IEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DownlinkUEAssociatedLPPaTransport_IEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_uplinkUEAssociatedLPPaTransport:
rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UplinkUEAssociatedLPPaTransport_IEs.mme_ue_s1ap_id;
scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UplinkUEAssociatedLPPaTransport_IEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_downlinkNonUEAssociatedLPPaTransport:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DownlinkNonUEAssociatedLPPaTransport_IEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_DownlinkNonUEAssociatedLPPaTransport_IEs.mme_ue_s1ap_id;
break;
case S1ap_ProcedureCode_id_uplinkNonUEAssociatedLPPaTransport:
//rx_mme_ue_s1ap_id = rx_packet->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UplinkNonUEAssociatedLPPaTransport_IEs.mme_ue_s1ap_id;
//scenario_mme_ue_s1ap_id = spacket->sctp_hdr.u.data_hdr.payload.message.msg.s1ap_UplinkNonUEAssociatedLPPaTransport_IEs.mme_ue_s1ap_id;
break;
default:
AssertFatal(0, "Unknown procedure code %ld", rx_packet->sctp_hdr.u.data_hdr.payload.message.procedureCode);
}
if (scenario_mme_ue_s1ap_id != rx_mme_ue_s1ap_id) {
S1AP_DEBUG("%s() Updating mme_ue_s1ap_id %u -> %u \n", __FUNCTION__, scenario_mme_ue_s1ap_id, rx_mme_ue_s1ap_id);
et_packet_t * p = spacket;
while (p) {
et_s1ap_update_mme_ue_s1ap_id(p, scenario_mme_ue_s1ap_id, rx_mme_ue_s1ap_id);
p = p->next;
}
return 0;
}
return 1;
}
//------------------------------------------------------------------------------
asn_comp_rval_t * et_s1ap_is_matching(et_s1ap_t * const s1ap1, et_s1ap_t * const s1ap2, const uint32_t constraints)
{
asn_comp_rval_t *rv = NULL;
if (s1ap1->pdu.present != s1ap2->pdu.present) {rv = calloc(1, sizeof(asn_comp_rval_t)); rv->err_code = ET_ERROR_MATCH_PACKET_S1AP_PRESENT; return rv;}
switch (s1ap1->pdu.present) {
case S1AP_PDU_PR_NOTHING:
break;
case S1AP_PDU_PR_initiatingMessage:
if (s1ap1->pdu.choice.initiatingMessage.procedureCode != s1ap2->pdu.choice.initiatingMessage.procedureCode)
{rv = calloc(1, sizeof(asn_comp_rval_t)); rv->err_code = ET_ERROR_MATCH_PACKET_S1AP_PROCEDURE_CODE; return rv;}
if (s1ap1->pdu.choice.initiatingMessage.criticality != s1ap2->pdu.choice.initiatingMessage.criticality)
{rv = calloc(1, sizeof(asn_comp_rval_t)); rv->err_code = ET_ERROR_MATCH_PACKET_S1AP_CRITICALITY; return rv;}
break;
case S1AP_PDU_PR_successfulOutcome:
if (s1ap1->pdu.choice.successfulOutcome.procedureCode != s1ap2->pdu.choice.successfulOutcome.procedureCode)
{rv = calloc(1, sizeof(asn_comp_rval_t)); rv->err_code = ET_ERROR_MATCH_PACKET_S1AP_PROCEDURE_CODE; return rv;}
if (s1ap1->pdu.choice.successfulOutcome.criticality != s1ap2->pdu.choice.successfulOutcome.criticality)
{rv = calloc(1, sizeof(asn_comp_rval_t)); rv->err_code = ET_ERROR_MATCH_PACKET_S1AP_CRITICALITY; return rv;}
break;
case S1AP_PDU_PR_unsuccessfulOutcome:
if (s1ap1->pdu.choice.unsuccessfulOutcome.procedureCode != s1ap2->pdu.choice.unsuccessfulOutcome.procedureCode)
{rv = calloc(1, sizeof(asn_comp_rval_t)); rv->err_code = ET_ERROR_MATCH_PACKET_S1AP_PROCEDURE_CODE; return rv;}
if (s1ap1->pdu.choice.unsuccessfulOutcome.criticality != s1ap2->pdu.choice.unsuccessfulOutcome.criticality)
{rv = calloc(1, sizeof(asn_comp_rval_t)); rv->err_code = ET_ERROR_MATCH_PACKET_S1AP_CRITICALITY; return rv;}
break;
default:
AssertFatal(0, "Unknown pdu.present %d", s1ap1->pdu.present);
}
if (s1ap1->binary_stream_allocated_size == s1ap2->binary_stream_allocated_size) {
if (memcmp((void*)s1ap1->binary_stream, (void*)s1ap2->binary_stream, s1ap1->binary_stream_allocated_size) == 0) return NULL;
}
// if no matching, may be the scenario need minor corrections (same enb_ue_s1ap_id but need to update mme_ue_s1ap_id)
return et_s1ap_ies_is_matching(s1ap1->pdu.present, &s1ap1->message, &s1ap2->message, constraints);
}
//------------------------------------------------------------------------------
et_packet_t* et_build_packet_from_s1ap_data_ind(et_event_s1ap_data_ind_t * const s1ap_data_ind)
{
et_packet_t * packet = NULL;
AssertFatal (NULL != s1ap_data_ind, "Bad parameter sctp_data_ind\n");
packet = calloc(1, sizeof(*packet));
packet->action = ET_PACKET_ACTION_S1C_NULL;
//packet->time_relative_to_first_packet.tv_sec = 0;
//packet->time_relative_to_first_packet.tv_usec = 0;
//packet->time_relative_to_last_sent_packet.tv_sec = 0;
//packet->time_relative_to_last_sent_packet.tv_usec = 0;
//packet->time_relative_to_last_received_packet.tv_sec = 0;
//packet->time_relative_to_last_received_packet.tv_usec = 0;
//packet->original_frame_number = 0;
//packet->packet_number = 0;
packet->enb_instance = 0; //TODO
//packet->ip_hdr;
// keep in mind: allocated buffer: sctp_datahdr.payload.binary_stream
packet->sctp_hdr.chunk_type = SCTP_CID_DATA;
memcpy((void*)&packet->sctp_hdr.u.data_hdr, (void*)&s1ap_data_ind->sctp_datahdr, sizeof(packet->sctp_hdr));
//packet->next = NULL;
packet->status = ET_PACKET_STATUS_RECEIVED;
//packet->timer_id = 0;
AssertFatal(0 == gettimeofday(&packet->timestamp_packet, NULL), "gettimeofday() Failed");
return packet;
}
//------------------------------------------------------------------------------
// return 0 if packet was waited
int et_scenario_set_packet_received(et_packet_t * const packet)
{
et_packet_t * p = NULL;
int rc = 0;
packet->status = ET_PACKET_STATUS_RECEIVED;
S1AP_DEBUG("Packet received: num %u | original frame number %u \n", packet->packet_number, packet->original_frame_number);
S1AP_DEBUG("Last Packet received: num %u | original frame number %u \n", g_scenario->last_rx_packet->packet_number, g_scenario->last_rx_packet->original_frame_number);
p = g_scenario->last_rx_packet;
while (NULL != p) {
if (ET_PACKET_ACTION_S1C_RECEIVE == p->action) {
if ((ET_PACKET_STATUS_RECEIVED == p->status) || (ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT == p->status)) {
g_scenario->last_rx_packet = p;
g_scenario->time_last_rx_packet.tv_sec = p->timestamp_packet.tv_sec;
g_scenario->time_last_rx_packet.tv_usec = p->timestamp_packet.tv_usec;
S1AP_DEBUG("Set Last Packet received: num %u | original frame number %u \n", g_scenario->last_rx_packet->packet_number, g_scenario->last_rx_packet->original_frame_number);
S1AP_DEBUG("Set time_last_rx_packet %ld.%06d\n", g_scenario->time_last_rx_packet.tv_sec, g_scenario->time_last_rx_packet.tv_usec);
} else {
break;
}
}
p = p->next;
}
if (0 != packet->timer_id) {
rc = timer_remove(packet->timer_id);
AssertFatal(rc == 0, "TODO: Debug Timer on Rx packet num %d unknown", packet->packet_number);
g_scenario->timer_count--;
return rc;
}
return 1;
}
//------------------------------------------------------------------------------
int et_s1ap_process_rx_packet(et_event_s1ap_data_ind_t * const s1ap_data_ind)
{
et_packet_t *packet = NULL;
et_packet_t *rx_packet = NULL;
unsigned long int not_found = 1;
asn_comp_rval_t *comp_results = NULL;
asn_comp_rval_t *comp_results2 = NULL;
unsigned char error_code = 0;
AssertFatal (NULL != s1ap_data_ind, "Bad parameter sctp_data_ind\n");
rx_packet = et_build_packet_from_s1ap_data_ind(s1ap_data_ind);
if (NULL == g_scenario->last_rx_packet) {
packet = g_scenario->list_packet;
while (NULL != packet) {
if (packet->action == ET_PACKET_ACTION_S1C_RECEIVE) {
if ((ET_PACKET_STATUS_RECEIVED == packet->status) || (ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT == packet->status)) {
g_scenario->last_rx_packet = packet;
if (ET_PACKET_STATUS_NOT_TAKEN_IN_ACCOUNT != packet->status) {
g_scenario->time_last_rx_packet.tv_sec = packet->timestamp_packet.tv_sec;
g_scenario->time_last_rx_packet.tv_usec = packet->timestamp_packet.tv_usec;
}
S1AP_DEBUG("Set Last Packet received: num %u | original frame number %u \n", g_scenario->last_rx_packet->packet_number, g_scenario->last_rx_packet->original_frame_number);
S1AP_DEBUG("Set time_last_rx_packet %ld.%06d\n", g_scenario->time_last_rx_packet.tv_sec, g_scenario->time_last_rx_packet.tv_usec);
} else {
break;
}
}
packet = packet->next;
}
packet = g_scenario->list_packet;
} else {
packet = g_scenario->last_rx_packet->next;
}
// not_found threshold may sure depend on number of mme, may be not sure on number of UE
while ((NULL != packet) && (not_found < 7)) {
S1AP_DEBUG("%s() Considering packet num %d original frame number %u\n", __FUNCTION__, packet->packet_number, packet->original_frame_number);
if (packet->action == ET_PACKET_ACTION_S1C_RECEIVE) {
comp_results = et_sctp_is_matching(&packet->sctp_hdr, &rx_packet->sctp_hdr, g_constraints);
if (NULL == comp_results) {
S1AP_DEBUG("Compare RX packet with packet: num %u | original frame number %u \n", packet->packet_number, packet->original_frame_number);
packet->timestamp_packet.tv_sec = rx_packet->timestamp_packet.tv_sec;
packet->timestamp_packet.tv_usec = rx_packet->timestamp_packet.tv_usec;
return et_scenario_set_packet_received(packet);
} else {
S1AP_DEBUG("Compare RX packet with packet: num %u | original frame number %u failed\n",
packet->packet_number, packet->original_frame_number);
while (comp_results) {
S1AP_DEBUG("Result err code %s(%u) ASN1 struct name %s\n",
et_error_match2str(comp_results->err_code), comp_results->err_code, comp_results->name);
// (each asn1 rc <= 166 (enum e_S1ap_ProtocolIE_ID, in generated file S1ap_ProtocolIE_ID.h))
if (comp_results->err_code == COMPARE_ERR_CODE_NO_MATCH) {
//TODO MME_UE_S1AP_ID, etc.
// get latest error code
if (strcmp(comp_results->name, "S1ap-MME-UE-S1AP-ID") == 0) {
if (0 == et_handle_s1ap_mismatch_mme_ue_s1ap_id((et_packet_t *const)packet, (et_packet_t *const)rx_packet)) {
packet->timestamp_packet.tv_sec = rx_packet->timestamp_packet.tv_sec;
packet->timestamp_packet.tv_usec = rx_packet->timestamp_packet.tv_usec;
return et_scenario_set_packet_received(packet);
}
} else if (strcmp(comp_results->name, "S1ap-TransportLayerAddress") == 0) {
S1AP_WARN("Some work needed there for %s, TODO in generic_scenario.xsl, add epc conf file in the process, anyway continuing...\n",comp_results->name);
packet->timestamp_packet.tv_sec = rx_packet->timestamp_packet.tv_sec;
packet->timestamp_packet.tv_usec = rx_packet->timestamp_packet.tv_usec;
return et_scenario_set_packet_received(packet);
} else {
S1AP_WARN("\n\nRX PACKET:\n");
et_display_packet_sctp(&rx_packet->sctp_hdr);
S1AP_WARN("\n\nWAITED PACKET:\n");
et_display_packet_sctp(&packet->sctp_hdr);
AssertFatal(0,"Some work needed there");
}
}
comp_results2 = comp_results;
comp_results = comp_results2->next;
et_free_pointer(comp_results2);
}
}
}
not_found += 1;
packet = packet->next;
}
et_display_packet_sctp(&rx_packet->sctp_hdr);
AssertFatal(0, "Rx packet not found in scenario (see dump above)");
return -1;
}
//------------------------------------------------------------------------------
void et_s1ap_eNB_handle_sctp_data_ind(sctp_data_ind_t * const sctp_data_ind)
{
int result = 0;
et_event_t event;
DevAssert(sctp_data_ind != NULL);
memset((void*)&event, 0, sizeof(event));
event.code = ET_EVENT_RX_S1AP;
event.u.s1ap_data_ind.sctp_datahdr.tsn = 0;
event.u.s1ap_data_ind.sctp_datahdr.stream = sctp_data_ind->stream;
event.u.s1ap_data_ind.sctp_datahdr.ssn = 0;
event.u.s1ap_data_ind.sctp_datahdr.ppid = S1AP_SCTP_PPID;
event.u.s1ap_data_ind.sctp_datahdr.assoc_id = sctp_data_ind->assoc_id;
event.u.s1ap_data_ind.sctp_datahdr.payload.binary_stream_pos = 0;
event.u.s1ap_data_ind.sctp_datahdr.payload.binary_stream_allocated_size = sctp_data_ind->buffer_length;
event.u.s1ap_data_ind.sctp_datahdr.payload.binary_stream = NULL;
if ((sctp_data_ind->buffer_length > 0) && (NULL != sctp_data_ind->buffer)) {
event.u.s1ap_data_ind.sctp_datahdr.payload.binary_stream = calloc(1, sctp_data_ind->buffer_length);
memcpy(event.u.s1ap_data_ind.sctp_datahdr.payload.binary_stream,
sctp_data_ind->buffer,
sctp_data_ind->buffer_length);
if (et_s1ap_decode_pdu(
&event.u.s1ap_data_ind.sctp_datahdr.payload.pdu,
&event.u.s1ap_data_ind.sctp_datahdr.payload.message,
event.u.s1ap_data_ind.sctp_datahdr.payload.binary_stream,
event.u.s1ap_data_ind.sctp_datahdr.payload.binary_stream_allocated_size) < 0) {
AssertFatal (0, "ERROR Cannot decode RX S1AP message!\n");
}
}
result = itti_free(TASK_UNKNOWN, sctp_data_ind->buffer);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
et_scenario_fsm_notify_event(event);
memset((void*)&event, 0, sizeof(event));
event.code = ET_EVENT_TICK;
et_scenario_fsm_notify_event(event);
}
//------------------------------------------------------------------------------
void et_s1ap_eNB_register_mme(s1ap_eNB_instance_t *instance_p,
net_ip_address_t *mme_ip_address,
net_ip_address_t *local_ip_addr,
uint16_t in_streams,
uint16_t out_streams)
{
MessageDef *message_p = NULL;
sctp_new_association_req_t *sctp_new_association_req_p = NULL;
s1ap_eNB_mme_data_t *s1ap_mme_data_p = NULL;
DevAssert(instance_p != NULL);
DevAssert(mme_ip_address != NULL);
message_p = itti_alloc_new_message(TASK_S1AP, SCTP_NEW_ASSOCIATION_REQ);
sctp_new_association_req_p = &message_p->ittiMsg.sctp_new_association_req;
sctp_new_association_req_p->port = S1AP_PORT_NUMBER;
sctp_new_association_req_p->ppid = S1AP_SCTP_PPID;
sctp_new_association_req_p->in_streams = in_streams;
sctp_new_association_req_p->out_streams = out_streams;
memcpy(&sctp_new_association_req_p->remote_address,
mme_ip_address,
sizeof(*mme_ip_address));
memcpy(&sctp_new_association_req_p->local_address,
local_ip_addr,
sizeof(*local_ip_addr));
/* Create new MME descriptor */
s1ap_mme_data_p = calloc(1, sizeof(*s1ap_mme_data_p));
DevAssert(s1ap_mme_data_p != NULL);
s1ap_mme_data_p->cnx_id = et_s1ap_eNB_fetch_add_global_cnx_id();
sctp_new_association_req_p->ulp_cnx_id = s1ap_mme_data_p->cnx_id;
s1ap_mme_data_p->assoc_id = -1;
s1ap_mme_data_p->s1ap_eNB_instance = instance_p;
memcpy((void*)&s1ap_mme_data_p->mme_net_ip_address, mme_ip_address, sizeof(*mme_ip_address));
STAILQ_INIT(&s1ap_mme_data_p->served_gummei);
/* Insert the new descriptor in list of known MME
* but not yet associated.
*/
RB_INSERT(s1ap_mme_map, &instance_p->s1ap_mme_head, s1ap_mme_data_p);
s1ap_mme_data_p->state = S1AP_ENB_STATE_WAITING;
instance_p->s1ap_mme_nb ++;
instance_p->s1ap_mme_pending_nb ++;
itti_send_msg_to_task(TASK_SCTP, instance_p->instance, message_p);
}
//------------------------------------------------------------------------------
void et_s1ap_update_assoc_id_of_packets(const int32_t assoc_id,
struct s1ap_eNB_instance_s * const s1ap_eNB_instance,
s1ap_eNB_mme_data_t * const mme_desc_p)
{
et_packet_t *packet = NULL;
int ret;
unsigned int old_enb_port = 0;
unsigned int old_mme_port = 0;
S1AP_DEBUG("%s for SCTP association (%u)\n",__FUNCTION__,assoc_id);
packet = g_scenario->list_packet;
while (NULL != packet) {
switch (packet->sctp_hdr.chunk_type) {
case SCTP_CID_DATA :
S1AP_DEBUG("%s for SCTP association (%u) SCTP_CID_DATA\n",__FUNCTION__,assoc_id);
if ((ET_PACKET_STATUS_NONE == packet->status) || (ET_PACKET_STATUS_SCHEDULED_FOR_RECEIVING == packet->status)) {
if (0 < old_mme_port) {
if (packet->action == ET_PACKET_ACTION_S1C_SEND) {
ret = et_compare_et_ip_to_net_ip_address(&packet->ip_hdr.dst, &mme_desc_p->mme_net_ip_address);
if (0 == ret) {
ret = et_compare_et_ip_to_net_ip_address(&packet->ip_hdr.src, &s1ap_eNB_instance->s1c_net_ip_address);
if (0 == ret) {
// same IP src, same IP dst
if ((packet->sctp_hdr.dst_port == old_mme_port) && (packet->sctp_hdr.src_port == old_enb_port)) {
packet->sctp_hdr.u.data_hdr.assoc_id = assoc_id;
S1AP_DEBUG("tPacket:\tnum %u | original frame number %u \n", packet->packet_number, packet->original_frame_number);
S1AP_DEBUG("\tUpdated assoc id: %u\n", assoc_id);
}
}
}
} else if (packet->action == ET_PACKET_ACTION_S1C_RECEIVE) {
ret = et_compare_et_ip_to_net_ip_address(&packet->ip_hdr.src, &mme_desc_p->mme_net_ip_address);
if (0 == ret) {
ret = et_compare_et_ip_to_net_ip_address(&packet->ip_hdr.dst, &s1ap_eNB_instance->s1c_net_ip_address);
if (0 == ret) {
// same IP src, same IP dst
if ((packet->sctp_hdr.src_port == old_mme_port) && (packet->sctp_hdr.dst_port == old_enb_port)) {
packet->sctp_hdr.u.data_hdr.assoc_id = assoc_id;
S1AP_DEBUG("tPacket:\tnum %u | original frame number %u \n", packet->packet_number, packet->original_frame_number);
S1AP_DEBUG("\tUpdated assoc id: %u\n", assoc_id);
}
}
}
}
}
}
break;
// Strong assumption
// in replayed scenario, the order of SCTP INIT packets is supposed to be the same as in the catched scenario
case SCTP_CID_INIT:
S1AP_DEBUG("%s for SCTP association (%u) SCTP_CID_INIT\n",__FUNCTION__,assoc_id);
ret = et_compare_et_ip_to_net_ip_address(&packet->ip_hdr.dst, &mme_desc_p->mme_net_ip_address);
if (0 == ret) {
ret = et_compare_et_ip_to_net_ip_address(&packet->ip_hdr.src, &s1ap_eNB_instance->s1c_net_ip_address);
if (0 == ret) {
if (0 == old_enb_port) {
if (ET_PACKET_STATUS_NONE == packet->status) {
packet->status = ET_PACKET_STATUS_SENT;
old_enb_port = packet->sctp_hdr.src_port;
S1AP_DEBUG("%s for SCTP association (%u) SCTP_CID_INIT SUCCESS\n",__FUNCTION__,assoc_id);
}
}
}
}
break;
case SCTP_CID_INIT_ACK:
S1AP_DEBUG("%s for SCTP association (%u) SCTP_CID_INIT_ACK\n",__FUNCTION__,assoc_id);
ret = et_compare_et_ip_to_net_ip_address(&packet->ip_hdr.src, &mme_desc_p->mme_net_ip_address);
if (0 == ret) {
ret = et_compare_et_ip_to_net_ip_address(&packet->ip_hdr.dst, &s1ap_eNB_instance->s1c_net_ip_address);
if (0 == ret) {
if (old_enb_port == packet->sctp_hdr.dst_port) {
if (ET_PACKET_STATUS_NONE == packet->status) {
packet->status = ET_PACKET_STATUS_RECEIVED;
old_mme_port = packet->sctp_hdr.dst_port;
S1AP_DEBUG("%s for SCTP association (%u) SCTP_CID_INIT_ACK SUCCESS\n",__FUNCTION__,assoc_id);
}
}
}
}
break;
case SCTP_CID_HEARTBEAT:
case SCTP_CID_HEARTBEAT_ACK:
case SCTP_CID_COOKIE_ECHO:
case SCTP_CID_COOKIE_ACK:
case SCTP_CID_ECN_ECNE:
case SCTP_CID_ECN_CWR:
break;
case SCTP_CID_ABORT:
case SCTP_CID_SHUTDOWN:
case SCTP_CID_SHUTDOWN_ACK:
case SCTP_CID_ERROR:
case SCTP_CID_SHUTDOWN_COMPLETE:
//TODO
break;
default:
AssertFatal(0, "Unknown chunk_type %d packet num %d", packet->sctp_hdr.chunk_type, packet->packet_number);
;
}
packet = packet->next;
}
}
//------------------------------------------------------------------------------
void et_s1ap_handle_s1_setup_message(s1ap_eNB_mme_data_t *mme_desc_p, int sctp_shutdown)
{
if (sctp_shutdown) {
/* A previously connected MME has been shutdown */
/* TODO check if it was used by some eNB and send a message to inform these eNB if there is no more associated MME */
if (mme_desc_p->state == S1AP_ENB_STATE_CONNECTED) {
mme_desc_p->state = S1AP_ENB_STATE_DISCONNECTED;
if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb > 0) {
/* Decrease associated MME number */
mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb --;
}
/* If there are no more associated MME, inform eNB app */
if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb == 0) {
MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_S1AP, S1AP_DEREGISTERED_ENB_IND);
S1AP_DEREGISTERED_ENB_IND(message_p).nb_mme = 0;
itti_send_msg_to_task(TASK_ENB_APP, mme_desc_p->s1ap_eNB_instance->instance, message_p);
}
}
} else {
/* Check that at least one setup message is pending */
DevCheck(mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb > 0, mme_desc_p->s1ap_eNB_instance->instance,
mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb, 0);
if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb > 0) {
/* Decrease pending messages number */
mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb --;
mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb++;
}
et_s1ap_update_assoc_id_of_packets(mme_desc_p->assoc_id,
mme_desc_p->s1ap_eNB_instance,
mme_desc_p);
/* If there are no more pending messages, inform eNB app */
if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb == 0) {
MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_S1AP, S1AP_REGISTER_ENB_CNF);
S1AP_REGISTER_ENB_CNF(message_p).nb_mme = mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb;
itti_send_msg_to_task(TASK_ENB_APP, mme_desc_p->s1ap_eNB_instance->instance, message_p);
}
}
}
//------------------------------------------------------------------------------
void et_s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *s1ap_register_eNB)
{
s1ap_eNB_instance_t *new_instance;
uint8_t index;
DevAssert(s1ap_register_eNB != NULL);
/* Look if the provided instance already exists */
new_instance = et_s1ap_eNB_get_instance(instance);
if (new_instance != NULL) {
/* Checks if it is a retry on the same eNB */
DevCheck(new_instance->eNB_id == s1ap_register_eNB->eNB_id, new_instance->eNB_id, s1ap_register_eNB->eNB_id, 0);
DevCheck(new_instance->cell_type == s1ap_register_eNB->cell_type, new_instance->cell_type, s1ap_register_eNB->cell_type, 0);
DevCheck(new_instance->tac == s1ap_register_eNB->tac, new_instance->tac, s1ap_register_eNB->tac, 0);
DevCheck(new_instance->mcc == s1ap_register_eNB->mcc, new_instance->mcc, s1ap_register_eNB->mcc, 0);
DevCheck(new_instance->mnc == s1ap_register_eNB->mnc, new_instance->mnc, s1ap_register_eNB->mnc, 0);
DevCheck(new_instance->mnc_digit_length == s1ap_register_eNB->mnc_digit_length, new_instance->mnc_digit_length, s1ap_register_eNB->mnc_digit_length, 0);
DevCheck(memcmp((void*)&new_instance->s1c_net_ip_address, (void*)&s1ap_register_eNB->enb_ip_address, sizeof(new_instance->s1c_net_ip_address)) == 0, 0,0,0);
} else {
new_instance = calloc(1, sizeof(s1ap_eNB_instance_t));
DevAssert(new_instance != NULL);
RB_INIT(&new_instance->s1ap_ue_head);
RB_INIT(&new_instance->s1ap_mme_head);
/* Copy usefull parameters */
new_instance->instance = instance;
new_instance->eNB_name = s1ap_register_eNB->eNB_name;
new_instance->eNB_id = s1ap_register_eNB->eNB_id;
new_instance->cell_type = s1ap_register_eNB->cell_type;
new_instance->tac = s1ap_register_eNB->tac;
new_instance->mcc = s1ap_register_eNB->mcc;
new_instance->mnc = s1ap_register_eNB->mnc;
new_instance->mnc_digit_length = s1ap_register_eNB->mnc_digit_length;
memcpy((void*)&new_instance->s1c_net_ip_address, (void*)&s1ap_register_eNB->enb_ip_address, sizeof(new_instance->s1c_net_ip_address));
/* Add the new instance to the list of eNB (meaningfull in virtual mode) */
et_s1ap_eNB_insert_new_instance(new_instance);
S1AP_DEBUG("Registered new eNB[%d] and %s eNB id %u\n",
instance,
s1ap_register_eNB->cell_type == CELL_MACRO_ENB ? "macro" : "home",
s1ap_register_eNB->eNB_id);
}
DevCheck(s1ap_register_eNB->nb_mme <= S1AP_MAX_NB_MME_IP_ADDRESS,
S1AP_MAX_NB_MME_IP_ADDRESS, s1ap_register_eNB->nb_mme, 0);
/* Trying to connect to provided list of MME ip address */
for (index = 0; index < s1ap_register_eNB->nb_mme; index++) {
et_s1ap_eNB_register_mme(new_instance,
&s1ap_register_eNB->mme_ip_address[index],
&s1ap_register_eNB->enb_ip_address,
s1ap_register_eNB->sctp_in_streams,
s1ap_register_eNB->sctp_out_streams);
}
}
//------------------------------------------------------------------------------
void et_s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp)
{
s1ap_eNB_instance_t *instance_p = NULL;
s1ap_eNB_mme_data_t *s1ap_mme_data_p = NULL;
DevAssert(sctp_new_association_resp != NULL);
instance_p = et_s1ap_eNB_get_instance(instance);
DevAssert(instance_p != NULL);
s1ap_mme_data_p = et_s1ap_eNB_get_MME(instance_p, -1,
sctp_new_association_resp->ulp_cnx_id);
DevAssert(s1ap_mme_data_p != NULL);
if (sctp_new_association_resp->sctp_state != SCTP_STATE_ESTABLISHED) {
S1AP_WARN("Received unsuccessful result for SCTP association (%u), instance %d, cnx_id %u\n",
sctp_new_association_resp->sctp_state,
instance,
sctp_new_association_resp->ulp_cnx_id);
et_s1ap_handle_s1_setup_message(s1ap_mme_data_p, sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN);
return;
}
S1AP_DEBUG("Received successful result for SCTP association (%u), instance %d, cnx_id %u\n",
sctp_new_association_resp->sctp_state,
instance,
sctp_new_association_resp->ulp_cnx_id);
/* Update parameters */
s1ap_mme_data_p->assoc_id = sctp_new_association_resp->assoc_id;
s1ap_mme_data_p->in_streams = sctp_new_association_resp->in_streams;
s1ap_mme_data_p->out_streams = sctp_new_association_resp->out_streams;
et_s1ap_handle_s1_setup_message(s1ap_mme_data_p, sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN);
}
//------------------------------------------------------------------------------
void *et_s1ap_eNB_task(void *arg)
{
MessageDef *received_msg = NULL;
int result;
S1AP_DEBUG("Starting S1AP layer\n");
et_s1ap_eNB_prepare_internal_data();
itti_mark_task_ready(TASK_S1AP);
MSC_START_USE();
while (1) {
itti_receive_msg(TASK_S1AP, &received_msg);
switch (ITTI_MSG_ID(received_msg)) {
case TERMINATE_MESSAGE:
itti_exit_task();
break;
case S1AP_REGISTER_ENB_REQ: {
/* Register a new eNB.
* in Virtual mode eNBs will be distinguished using the mod_id/
* Each eNB has to send an S1AP_REGISTER_ENB message with its
* own parameters.
*/
et_s1ap_eNB_handle_register_eNB(ITTI_MESSAGE_GET_INSTANCE(received_msg),
&S1AP_REGISTER_ENB_REQ(received_msg));
}
break;
case SCTP_NEW_ASSOCIATION_RESP: {
et_s1ap_eNB_handle_sctp_association_resp(ITTI_MESSAGE_GET_INSTANCE(received_msg),
&received_msg->ittiMsg.sctp_new_association_resp);
}
break;
case SCTP_DATA_IND: {
et_s1ap_eNB_handle_sctp_data_ind(&received_msg->ittiMsg.sctp_data_ind);
}
break;
case TIMER_HAS_EXPIRED:
LOG_I(S1AP, " Received TIMER_HAS_EXPIRED: timer_id %d\n", TIMER_HAS_EXPIRED(received_msg).timer_id);
{
et_packet_t * packet = (et_packet_t*)TIMER_HAS_EXPIRED (received_msg).arg;
et_event_t event;
g_scenario->timer_count--;
if (NULL != packet) {
if (packet->status == ET_PACKET_STATUS_SCHEDULED_FOR_RECEIVING) {
memset((void*)&event, 0, sizeof(event));
event.code = ET_EVENT_RX_PACKET_TIME_OUT;
event.u.rx_packet_time_out = packet;
et_scenario_fsm_notify_event(event);
} else if (packet->status == ET_PACKET_STATUS_SCHEDULED_FOR_SENDING) {
memset((void*)&event, 0, sizeof(event));
event.code = ET_EVENT_TX_TIMED_PACKET;
event.u.tx_timed_packet = packet;
et_scenario_fsm_notify_event(event);
et_event_t continue_event;
continue_event.code = ET_EVENT_TICK;
et_scenario_fsm_notify_event(continue_event);
} else if ((packet->status != ET_PACKET_STATUS_SENT) && ((packet->status != ET_PACKET_STATUS_RECEIVED))) {
AssertFatal (0, "Bad status %d of packet timed out!\n", packet->status);
}
} else {
LOG_W(S1AP, " Received TIMER_HAS_EXPIRED: timer_id %d, no packet attached to timer\n", TIMER_HAS_EXPIRED(received_msg).timer_id);
}
}
if (TIMER_HAS_EXPIRED (received_msg).timer_id == g_scenario->enb_register_retry_timer_id) {
/* Restart the registration process */
g_scenario->registered_enb = 0;
et_eNB_app_register (g_scenario->enb_properties);
}
break;
default:
S1AP_ERROR("Received unhandled message: %d:%s\n",
ITTI_MSG_ID(received_msg), ITTI_MSG_NAME(received_msg));
break;
}
result = itti_free (ITTI_MSG_ORIGIN_ID(received_msg), received_msg);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
received_msg = NULL;
}
return NULL;
}
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario_s1ap_compare_ie.c
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <unistd.h>
#include <crypt.h>
#include <errno.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include "tree.h"
#include "queue.h"
#include "intertask_interface.h"
#include "timer.h"
#include "platform_types.h"
#include "assertions.h"
#include "conversions.h"
#include "s1ap_common.h"
#include "play_scenario_s1ap_eNB_defs.h"
#include "play_scenario.h"
#include "msc.h"
//------------------------------------------------------------------------------
extern et_scenario_t *g_scenario;
extern uint32_t g_constraints;
//------------------------------------------------------------------------------
asn_comp_rval_t * et_s1ap_ies_is_matching(const S1AP_PDU_PR present, s1ap_message * const m1, s1ap_message * const m2, const uint32_t constraints)
{
asn_comp_rval_t *ret = NULL;
AssertFatal(m1 != NULL, "bad parameter m1");
AssertFatal(m2 != NULL, "bad parameter m2");
AssertFatal((present == S1AP_PDU_PR_initiatingMessage) ||
(present == S1AP_PDU_PR_successfulOutcome) ||
(present == S1AP_PDU_PR_unsuccessfulOutcome) , "Bad parameter S1AP_PDU_PR present ");
AssertFatal( m1->procedureCode == m2->procedureCode, "Bad parameters: no matching procedure codes");
// some cases can never occur since uplink only.
switch (m1->procedureCode) {
case S1ap_ProcedureCode_id_HandoverPreparation:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_handoverrequiredies(
&m1->msg.s1ap_HandoverRequiredIEs,
&m2->msg.s1ap_HandoverRequiredIEs);
} else {
ret = s1ap_compare_s1ap_handovercommandies(
&m1->msg.s1ap_HandoverCommandIEs,
&m2->msg.s1ap_HandoverCommandIEs);
}
break;
case S1ap_ProcedureCode_id_HandoverResourceAllocation:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_handoverrequesties(
&m1->msg.s1ap_HandoverRequestIEs,
&m2->msg.s1ap_HandoverRequestIEs);
} else if (present == S1AP_PDU_PR_successfulOutcome) {
ret = s1ap_compare_s1ap_handoverrequestacknowledgeies(
&m1->msg.s1ap_HandoverRequestAcknowledgeIEs,
&m2->msg.s1ap_HandoverRequestAcknowledgeIEs);
} else if (present == S1AP_PDU_PR_unsuccessfulOutcome) {
ret = s1ap_compare_s1ap_handoverfailureies(
&m1->msg.s1ap_HandoverFailureIEs,
&m2->msg.s1ap_HandoverFailureIEs);
}
break;
case S1ap_ProcedureCode_id_HandoverNotification:
ret = s1ap_compare_s1ap_handovernotifyies(
&m1->msg.s1ap_HandoverNotifyIEs,
&m2->msg.s1ap_HandoverNotifyIEs);
break;
case S1ap_ProcedureCode_id_PathSwitchRequest:
ret = s1ap_compare_s1ap_pathswitchrequesties(
&m1->msg.s1ap_PathSwitchRequestIEs,
&m2->msg.s1ap_PathSwitchRequestIEs);
break;
case S1ap_ProcedureCode_id_HandoverCancel:
ret = s1ap_compare_s1ap_handovercancelies(
&m1->msg.s1ap_HandoverCancelIEs,
&m2->msg.s1ap_HandoverCancelIEs);
break;
case S1ap_ProcedureCode_id_E_RABSetup:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_e_rabsetuprequesties(
&m1->msg.s1ap_E_RABSetupRequestIEs,
&m2->msg.s1ap_E_RABSetupRequestIEs);
} else {
ret = s1ap_compare_s1ap_e_rabsetupresponseies(
&m1->msg.s1ap_E_RABSetupResponseIEs,
&m2->msg.s1ap_E_RABSetupResponseIEs);
}
break;
case S1ap_ProcedureCode_id_E_RABModify:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_e_rabmodifyrequesties(
&m1->msg.s1ap_E_RABModifyRequestIEs,
&m2->msg.s1ap_E_RABModifyRequestIEs);
} else {
ret = s1ap_compare_s1ap_e_rabmodifyresponseies(
&m1->msg.s1ap_E_RABModifyResponseIEs,
&m2->msg.s1ap_E_RABModifyResponseIEs);
}
break;
case S1ap_ProcedureCode_id_E_RABRelease:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_e_rabreleasecommandies(
&m1->msg.s1ap_E_RABReleaseCommandIEs,
&m2->msg.s1ap_E_RABReleaseCommandIEs);
} else {
ret = s1ap_compare_s1ap_e_rabreleaseresponseies(
&m1->msg.s1ap_E_RABReleaseResponseIEs,
&m2->msg.s1ap_E_RABReleaseResponseIEs);
}
break;
case S1ap_ProcedureCode_id_E_RABReleaseIndication:
ret = s1ap_compare_s1ap_e_rabreleaseindicationies(
&m1->msg.s1ap_E_RABReleaseIndicationIEs,
&m2->msg.s1ap_E_RABReleaseIndicationIEs);
break;
case S1ap_ProcedureCode_id_InitialContextSetup:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_initialcontextsetuprequesties(
&m1->msg.s1ap_InitialContextSetupRequestIEs,
&m2->msg.s1ap_InitialContextSetupRequestIEs);
} else {
ret = s1ap_compare_s1ap_initialcontextsetupresponseies(
&m1->msg.s1ap_InitialContextSetupResponseIEs,
&m2->msg.s1ap_InitialContextSetupResponseIEs);
}
break;
case S1ap_ProcedureCode_id_Paging:
ret = s1ap_compare_s1ap_pagingies(
&m1->msg.s1ap_PagingIEs,
&m2->msg.s1ap_PagingIEs);
break;
case S1ap_ProcedureCode_id_downlinkNASTransport:
ret = s1ap_compare_s1ap_downlinknastransporties(
&m1->msg.s1ap_DownlinkNASTransportIEs,
&m2->msg.s1ap_DownlinkNASTransportIEs);
break;
case S1ap_ProcedureCode_id_initialUEMessage:
ret = s1ap_compare_s1ap_initialuemessageies(
&m1->msg.s1ap_InitialUEMessageIEs,
&m2->msg.s1ap_InitialUEMessageIEs);
break;
case S1ap_ProcedureCode_id_uplinkNASTransport:
ret = s1ap_compare_s1ap_uplinknastransporties(
&m1->msg.s1ap_UplinkNASTransportIEs,
&m2->msg.s1ap_UplinkNASTransportIEs);
break;
case S1ap_ProcedureCode_id_Reset:
ret = s1ap_compare_s1ap_reseties(
&m1->msg.s1ap_ResetIEs,
&m2->msg.s1ap_ResetIEs);
break;
case S1ap_ProcedureCode_id_ErrorIndication:
ret = s1ap_compare_s1ap_errorindicationies(
&m1->msg.s1ap_ErrorIndicationIEs,
&m2->msg.s1ap_ErrorIndicationIEs);
break;
case S1ap_ProcedureCode_id_NASNonDeliveryIndication:
ret = s1ap_compare_s1ap_nasnondeliveryindication_ies(
&m1->msg.s1ap_NASNonDeliveryIndication_IEs,
&m2->msg.s1ap_NASNonDeliveryIndication_IEs);
break;
case S1ap_ProcedureCode_id_S1Setup:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_s1setuprequesties(
&m1->msg.s1ap_S1SetupRequestIEs,
&m2->msg.s1ap_S1SetupRequestIEs);
} else if (present == S1AP_PDU_PR_successfulOutcome) {
ret = s1ap_compare_s1ap_s1setupresponseies(
&m1->msg.s1ap_S1SetupResponseIEs,
&m2->msg.s1ap_S1SetupResponseIEs);
} else if (present == S1AP_PDU_PR_unsuccessfulOutcome) {
ret = s1ap_compare_s1ap_s1setupfailureies(
&m1->msg.s1ap_S1SetupFailureIEs,
&m2->msg.s1ap_S1SetupFailureIEs);
}
break;
case S1ap_ProcedureCode_id_UEContextReleaseRequest:
ret = s1ap_compare_s1ap_uecontextreleaserequesties(
&m1->msg.s1ap_UEContextReleaseRequestIEs,
&m2->msg.s1ap_UEContextReleaseRequestIEs);
break;
case S1ap_ProcedureCode_id_DownlinkS1cdma2000tunneling:
ret = s1ap_compare_s1ap_downlinks1cdma2000tunnelingies(
&m1->msg.s1ap_DownlinkS1cdma2000tunnelingIEs,
&m2->msg.s1ap_DownlinkS1cdma2000tunnelingIEs);
break;
case S1ap_ProcedureCode_id_UplinkS1cdma2000tunneling:
ret = s1ap_compare_s1ap_uplinks1cdma2000tunnelingies(
&m1->msg.s1ap_UplinkS1cdma2000tunnelingIEs,
&m2->msg.s1ap_UplinkS1cdma2000tunnelingIEs);
break;
case S1ap_ProcedureCode_id_UEContextModification:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_uecontextmodificationrequesties(
&m1->msg.s1ap_UEContextModificationRequestIEs,
&m2->msg.s1ap_UEContextModificationRequestIEs);
} else if (present == S1AP_PDU_PR_successfulOutcome) {
ret = s1ap_compare_s1ap_uecontextmodificationresponseies(
&m1->msg.s1ap_UEContextModificationResponseIEs,
&m2->msg.s1ap_UEContextModificationResponseIEs);
} else if (present == S1AP_PDU_PR_unsuccessfulOutcome) {
ret = s1ap_compare_s1ap_uecontextmodificationfailureies(
&m1->msg.s1ap_UEContextModificationFailureIEs,
&m2->msg.s1ap_UEContextModificationFailureIEs);
}
break;
case S1ap_ProcedureCode_id_UECapabilityInfoIndication:
ret = s1ap_compare_s1ap_uecapabilityinfoindicationies(
&m1->msg.s1ap_UECapabilityInfoIndicationIEs,
&m2->msg.s1ap_UECapabilityInfoIndicationIEs);
break;
case S1ap_ProcedureCode_id_UEContextRelease:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_uecontextreleasecommandies(
&m1->msg.s1ap_UEContextReleaseCommandIEs,
&m2->msg.s1ap_UEContextReleaseCommandIEs);
} else {
ret = s1ap_compare_s1ap_uecontextreleasecompleteies(
&m1->msg.s1ap_UEContextReleaseCompleteIEs,
&m2->msg.s1ap_UEContextReleaseCompleteIEs);
}
break;
case S1ap_ProcedureCode_id_eNBStatusTransfer:
ret = s1ap_compare_s1ap_enbstatustransferies(
&m1->msg.s1ap_ENBStatusTransferIEs,
&m2->msg.s1ap_ENBStatusTransferIEs);
break;
case S1ap_ProcedureCode_id_MMEStatusTransfer:
ret = s1ap_compare_s1ap_mmestatustransferies(
&m1->msg.s1ap_MMEStatusTransferIEs,
&m2->msg.s1ap_MMEStatusTransferIEs);
break;
case S1ap_ProcedureCode_id_DeactivateTrace:
ret = s1ap_compare_s1ap_deactivatetraceies(
&m1->msg.s1ap_DeactivateTraceIEs,
&m2->msg.s1ap_DeactivateTraceIEs);
break;
case S1ap_ProcedureCode_id_TraceStart:
ret = s1ap_compare_s1ap_tracestarties(
&m1->msg.s1ap_TraceStartIEs,
&m2->msg.s1ap_TraceStartIEs);
break;
case S1ap_ProcedureCode_id_TraceFailureIndication:
ret = s1ap_compare_s1ap_tracefailureindicationies(
&m1->msg.s1ap_TraceFailureIndicationIEs,
&m2->msg.s1ap_TraceFailureIndicationIEs);
break;
case S1ap_ProcedureCode_id_ENBConfigurationUpdate:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_enbconfigurationupdateies(
&m1->msg.s1ap_ENBConfigurationUpdateIEs,
&m2->msg.s1ap_ENBConfigurationUpdateIEs);
} else if (present == S1AP_PDU_PR_successfulOutcome) {
ret = s1ap_compare_s1ap_enbconfigurationupdateacknowledgeies(
&m1->msg.s1ap_ENBConfigurationUpdateAcknowledgeIEs,
&m2->msg.s1ap_ENBConfigurationUpdateAcknowledgeIEs);
} else {
ret = s1ap_compare_s1ap_enbconfigurationupdatefailureies(
&m1->msg.s1ap_ENBConfigurationUpdateFailureIEs,
&m2->msg.s1ap_ENBConfigurationUpdateFailureIEs);
}
break;
case S1ap_ProcedureCode_id_MMEConfigurationUpdate:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_mmeconfigurationupdateies(
&m1->msg.s1ap_MMEConfigurationUpdateIEs,
&m2->msg.s1ap_MMEConfigurationUpdateIEs);
} else if (present == S1AP_PDU_PR_successfulOutcome) {
ret = s1ap_compare_s1ap_mmeconfigurationupdateacknowledgeies(
&m1->msg.s1ap_MMEConfigurationUpdateAcknowledgeIEs,
&m2->msg.s1ap_MMEConfigurationUpdateAcknowledgeIEs);
} else {
ret = s1ap_compare_s1ap_mmeconfigurationupdatefailureies(
&m1->msg.s1ap_MMEConfigurationUpdateFailureIEs,
&m2->msg.s1ap_MMEConfigurationUpdateFailureIEs);
}
break;
case S1ap_ProcedureCode_id_LocationReportingControl:
ret = s1ap_compare_s1ap_locationreportingcontrolies(
&m1->msg.s1ap_LocationReportingControlIEs,
&m2->msg.s1ap_LocationReportingControlIEs);
break;
case S1ap_ProcedureCode_id_LocationReportingFailureIndication:
ret = s1ap_compare_s1ap_locationreportingfailureindicationies(
&m1->msg.s1ap_LocationReportingFailureIndicationIEs,
&m2->msg.s1ap_LocationReportingFailureIndicationIEs);
break;
case S1ap_ProcedureCode_id_LocationReport:
ret = s1ap_compare_s1ap_locationreporties(
&m1->msg.s1ap_LocationReportIEs,
&m2->msg.s1ap_LocationReportIEs);
break;
case S1ap_ProcedureCode_id_OverloadStart:
ret = s1ap_compare_s1ap_overloadstarties(
&m1->msg.s1ap_OverloadStartIEs,
&m2->msg.s1ap_OverloadStartIEs);
break;
case S1ap_ProcedureCode_id_OverloadStop:
ret = s1ap_compare_s1ap_overloadstopies(
&m1->msg.s1ap_OverloadStopIEs,
&m2->msg.s1ap_OverloadStopIEs);
break;
case S1ap_ProcedureCode_id_WriteReplaceWarning:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_writereplacewarningrequesties(
&m1->msg.s1ap_WriteReplaceWarningRequestIEs,
&m2->msg.s1ap_WriteReplaceWarningRequestIEs);
} else {
ret = s1ap_compare_s1ap_writereplacewarningresponseies(
&m1->msg.s1ap_WriteReplaceWarningResponseIEs,
&m2->msg.s1ap_WriteReplaceWarningResponseIEs);
}
break;
case S1ap_ProcedureCode_id_eNBDirectInformationTransfer:
ret = s1ap_compare_s1ap_enbdirectinformationtransferies(
&m1->msg.s1ap_ENBDirectInformationTransferIEs,
&m2->msg.s1ap_ENBDirectInformationTransferIEs);
break;
case S1ap_ProcedureCode_id_MMEDirectInformationTransfer:
ret = s1ap_compare_s1ap_mmedirectinformationtransferies(
&m1->msg.s1ap_MMEDirectInformationTransferIEs,
&m2->msg.s1ap_MMEDirectInformationTransferIEs);
break;
case S1ap_ProcedureCode_id_PrivateMessage:
case S1ap_ProcedureCode_id_eNBConfigurationTransfer:
case S1ap_ProcedureCode_id_MMEConfigurationTransfer:
AssertFatal(0, "TODO");
break;
case S1ap_ProcedureCode_id_CellTrafficTrace:
ret = s1ap_compare_s1ap_celltraffictraceies(
&m1->msg.s1ap_CellTrafficTraceIEs,
&m2->msg.s1ap_CellTrafficTraceIEs);
break;
case S1ap_ProcedureCode_id_Kill:
if (present == S1AP_PDU_PR_initiatingMessage) {
ret = s1ap_compare_s1ap_killrequesties(
&m1->msg.s1ap_KillRequestIEs,
&m2->msg.s1ap_KillRequestIEs);
} else {
ret = s1ap_compare_s1ap_killresponseies(
&m1->msg.s1ap_KillResponseIEs,
&m2->msg.s1ap_KillResponseIEs);
}
break;
case S1ap_ProcedureCode_id_downlinkUEAssociatedLPPaTransport:
ret = s1ap_compare_s1ap_downlinkueassociatedlppatransport_ies(
&m1->msg.s1ap_DownlinkUEAssociatedLPPaTransport_IEs,
&m2->msg.s1ap_DownlinkUEAssociatedLPPaTransport_IEs);
break;
case S1ap_ProcedureCode_id_uplinkUEAssociatedLPPaTransport:
ret = s1ap_compare_s1ap_uplinkueassociatedlppatransport_ies(
&m1->msg.s1ap_UplinkUEAssociatedLPPaTransport_IEs,
&m2->msg.s1ap_UplinkUEAssociatedLPPaTransport_IEs);
break;
case S1ap_ProcedureCode_id_downlinkNonUEAssociatedLPPaTransport:
ret = s1ap_compare_s1ap_downlinknonueassociatedlppatransport_ies(
&m1->msg.s1ap_DownlinkNonUEAssociatedLPPaTransport_IEs,
&m2->msg.s1ap_DownlinkNonUEAssociatedLPPaTransport_IEs);
break;
case S1ap_ProcedureCode_id_uplinkNonUEAssociatedLPPaTransport:
ret = s1ap_compare_s1ap_uplinknonueassociatedlppatransport_ies(
&m1->msg.s1ap_UplinkNonUEAssociatedLPPaTransport_IEs,
&m2->msg.s1ap_UplinkNonUEAssociatedLPPaTransport_IEs);
break;
default:
AssertFatal(0, "Unknown procedure code %ld", m1->procedureCode);
}
return ret;
}
void update_xpath_node_mme_ue_s1ap_id(et_s1ap_t * const s1ap, xmlNode *node, const S1ap_MME_UE_S1AP_ID_t new_id)
{
xmlNode *cur_node = NULL;
xmlAttrPtr attr = NULL;
xmlChar *xml_char = NULL;
int size = 0;
int pos = 0;
int go_deeper_in_tree = 1;
//S1AP_INFO("%s() mme_ue_s1ap_id %u\n", __FUNCTION__, new_id);
// modify
for (cur_node = (xmlNode *)node; cur_node; cur_node = cur_node->next) {
go_deeper_in_tree = 1;
if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"field"))) {
// do not get hidden fields
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"hide");
if (NULL != xml_char) {
if ((!xmlStrcmp(xml_char, (const xmlChar *)"yes"))) {
go_deeper_in_tree = 0;
}
xmlFree(xml_char);
}
if (0 < go_deeper_in_tree) {
// first get size
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"pos");
if (NULL != xml_char) {
pos = strtoul((const char *)xml_char, NULL, 0);
pos -= s1ap->xml_stream_pos_offset;
AssertFatal(pos >= 0, "Bad pos %d xml_stream_pos_offset %d", pos, s1ap->xml_stream_pos_offset);
xmlFree(xml_char);
xml_char = xmlGetProp((xmlNode *)cur_node, (const xmlChar *)"size");
if (NULL != xml_char) {
const xmlChar value_d[32];
const xmlChar value_h[20];
const xmlChar showname[64];
int ret = 0;
int pos2 = 0;
unsigned long int uli = 0;
char hex[3] = {0,0,0};
char *end_ptr = NULL;
size = strtoul((const char *)xml_char, NULL, 0);
xmlFree(xml_char);
// second: try to set value (always hex)
ret = snprintf((char *)value_d, 32, "%ld", new_id);
AssertFatal((ret > 0) && (ret < 32), "Could not convert int to dec str");
ret = snprintf((char *)value_h, 20, "C0%08X", new_id);
AssertFatal((ret > 0) && (ret < 20), "Could not convert int to hex str");
ret = snprintf((char *)showname, 64, "MME-UE-S1AP-ID: %d", new_id);
AssertFatal((ret > 0) && (ret < 64), "Could not convert int to dec str");
attr = xmlSetProp((xmlNode *)cur_node, (const xmlChar *)"value", value_h);
attr = xmlSetProp((xmlNode *)cur_node, (const xmlChar *)"show", value_d);
attr = xmlSetProp((xmlNode *)cur_node, (const xmlChar *)"showname", showname);
//TODO update s1ap->binary_stream @pos with new_id_hex, size
AssertFatal((pos+size) < s1ap->binary_stream_allocated_size, "Rewrite of mme_ue_s1ap_id out of bounds of binary_stream");
//avoid endianess issues
do {
hex[0] = value_h[pos2++];
hex[1] = value_h[pos2++];
hex[2] = '\0';
end_ptr = hex;
uli = strtoul(hex, &end_ptr, 16);
AssertFatal((uli != ULONG_MAX) && (end_ptr != NULL) && (*end_ptr == '\0'), "Conversion of hexstring %s failed returned %ld errno %d", hex, uli, errno);
s1ap->binary_stream[pos++] = (unsigned char)uli;
} while (pos2 < (2*5));
// update ASN1
et_decode_s1ap(s1ap);
//S1AP_INFO("Updated ASN1 for %s\n", showname);
}
}
}
}
if (0 < go_deeper_in_tree) {
update_xpath_node_mme_ue_s1ap_id(s1ap, cur_node->children, new_id);
}
}
}
/**
* update_xpath_nodes:
* @nodes: the nodes set.
* @value: the new value for the node(s)
*
* Prints the @nodes content to @output.
* From http://www.xmlsoft.org/examples/#xpath2.c
*/
void update_xpath_nodes_mme_ue_s1ap_id(et_s1ap_t * const s1ap_payload, xmlNodeSetPtr nodes, const S1ap_MME_UE_S1AP_ID_t new_id)
{
int size = 0;
int i = 0;
xmlNode *s1ap_node = NULL;
size = (nodes) ? nodes->nodeNr : 0;
//S1AP_DEBUG("%s() num nodes %u\n", __FUNCTION__, size);
/*
* NOTE: the nodes are processed in reverse order, i.e. reverse document
* order because xmlNodeSetContent can actually free up descendant
* of the node and such nodes may have been selected too ! Handling
* in reverse order ensure that descendant are accessed first, before
* they get removed. Mixing XPath and modifications on a tree must be
* done carefully !
*/
for(i = size - 1; i >= 0; i--) {
s1ap_node = nodes->nodeTab[i];
AssertFatal(NULL != s1ap_node, "One element of resultset of XPATH expression is NULL\n");
update_xpath_node_mme_ue_s1ap_id(s1ap_payload, s1ap_node, new_id);
/*
* All the elements returned by an XPath query are pointers to
* elements from the tree *except* namespace nodes where the XPath
* semantic is different from the implementation in libxml2 tree.
* As a result when a returned node set is freed when
* xmlXPathFreeObject() is called, that routine must check the
* element type. But node from the returned set may have been removed
* by xmlNodeSetContent() resulting in access to freed data.
* This can be exercised by running valgrind
* There is 2 ways around it:
* - make a copy of the pointers to the nodes from the result set
* then call xmlXPathFreeObject() and then modify the nodes
* or
* - remove the reference to the modified nodes from the node set
* as they are processed, if they are not namespace nodes.
*/
if (nodes->nodeTab[i]->type != XML_NAMESPACE_DECL) {
nodes->nodeTab[i] = NULL;
}
}
}
//------------------------------------------------------------------------------
int et_s1ap_update_mme_ue_s1ap_id(et_packet_t * const packet, const S1ap_MME_UE_S1AP_ID_t old_id, const S1ap_MME_UE_S1AP_ID_t new_id)
{
xmlChar xpath_expression[ET_XPATH_EXPRESSION_MAX_LENGTH];
int ret = 0;
xmlDocPtr doc = NULL;
xmlXPathContextPtr xpath_ctx = NULL;
xmlXPathObjectPtr xpath_obj = NULL;
//S1AP_DEBUG("%s() packet num %u original frame number %u, mme_ue_s1ap_id %u -> %u\n", __FUNCTION__, packet->packet_number, packet->original_frame_number, old_id, new_id);
ret = snprintf(xpath_expression, ET_XPATH_EXPRESSION_MAX_LENGTH, "//field[@name=\"s1ap.MME_UE_S1AP_ID\"][@show=\"%u\"]", old_id);
AssertFatal((ret > 0) && (ret < ET_XPATH_EXPRESSION_MAX_LENGTH), "Could not build XPATH expression err=%d", ret);
doc = packet->sctp_hdr.u.data_hdr.payload.doc;
// Create xpath evaluation context
xpath_ctx = xmlXPathNewContext(doc);
if(xpath_ctx == NULL) {
fprintf(stderr,"Error: unable to create new XPath context\n");
xmlFreeDoc(doc);
return(-1);
}
// Evaluate xpath expression
xpath_obj = xmlXPathEvalExpression(xpath_expression, xpath_ctx);
xmlXPathFreeContext(xpath_ctx);
AssertFatal(xpath_obj != NULL, "Unable to evaluate XPATH expression \"%s\"\n", xpath_expression);
if(xmlXPathNodeSetIsEmpty(xpath_obj->nodesetval)){
xmlXPathFreeObject(xpath_obj);
S1AP_DEBUG("%s() No match \"%s\"packet num %u original frame number %u, mme_ue_s1ap_id %u -> %u\n",
__FUNCTION__, xpath_expression, packet->packet_number, packet->original_frame_number, old_id, new_id);
return -1;
}
// update selected nodes
update_xpath_nodes_mme_ue_s1ap_id(&packet->sctp_hdr.u.data_hdr.payload, xpath_obj->nodesetval, new_id);
// Cleanup of XPath data
xmlXPathFreeObject(xpath_obj);
return 0;
}
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Compus SophiaTech 450, route des chappes, 06451 Biot, France.
*******************************************************************************/
#include <stdint.h>
#include "queue.h"
#include "tree.h"
#include "sctp_eNB_defs.h"
#ifndef PLAY_SCENARIO_S1AP_ENB_DEFS_H_
#define PLAY_SCENARIO_S1AP_ENB_DEFS_H_
#define ENB_TAC (1)
#define ENB_MCC (208)
#define ENB_MNC (92)
#define ENB_NAME "Eurecom ENB"
#define ENB_NAME_FORMAT (ENB_NAME" %u")
#define S1AP_PORT_NUMBER (36412)
#define S1AP_SCTP_PPID (18)
#define X2AP_PORT_NUMBER (36422)
#define X2AP_SCTP_PPID (27)
#define S1AP_ENB_NAME_LENGTH_MAX (150)
typedef enum {
/* Disconnected state: initial state for any association. */
S1AP_ENB_STATE_DISCONNECTED = 0x0,
/* State waiting for S1 Setup response message if eNB is MME accepted or
* S1 Setup failure if MME rejects the eNB.
*/
S1AP_ENB_STATE_WAITING = 0x1,
/* The eNB is successfully connected to MME, UE contexts can be created. */
S1AP_ENB_STATE_CONNECTED = 0x2,
/* The MME has sent an overload start message. Once the MME disables the
* OVERLOAD marker, the state of the association will be
* S1AP_ENB_STATE_CONNECTED.
*/
S1AP_ENB_OVERLOAD = 0x3,
/* Max number of states available */
S1AP_ENB_STATE_MAX,
} s1ap_eNB_state_t;
/* If the Overload Action IE in the OVERLOAD START message is set to
* - “reject all RRC connection establishments for non-emergency mobile
* originated data transfer “ (i.e. reject traffic corresponding to RRC cause
* “mo-data “ (TS 36.331 [16])), or
* - “reject all RRC connection establishments for signalling “ (i.e. reject
* traffic corresponding to RRC cause “modata” and “mo-signalling”
* (TS 36.331 [16])),or
* - “only permit RRC connection establishments for emergency sessions and
* mobile terminated services” (i.e. only permit traffic corresponding to RRC
* cause “emergency” and “mt-Access” (TS 36.331 [16])).
*
* NOTE: When the Overload Action IE is set to “only permit RRC connection
* establishments for emergency sessions and mobile terminated services”,
* emergency calls with RRC cause “highPriorityAcess” from high priority users
* are rejected (TS 24.301 [24]).
*/
typedef enum {
S1AP_OVERLOAD_REJECT_MO_DATA = 0x0,
S1AP_OVERLOAD_REJECT_ALL_SIGNALLING = 0x1,
S1AP_OVERLOAD_ONLY_EMERGENCY_AND_MT = 0x2,
S1AP_NO_OVERLOAD = 0x3,
S1AP_OVERLOAD_MAX,
} s1ap_overload_state_t;
/* Served PLMN identity element */
struct plmn_identity_s {
uint16_t mcc;
uint16_t mnc;
uint8_t mnc_digit_length;
STAILQ_ENTRY(plmn_identity_s) next;
};
/* Served group id element */
struct served_group_id_s {
uint16_t mme_group_id;
STAILQ_ENTRY(served_group_id_s) next;
};
/* Served mme code for a particular MME */
struct mme_code_s {
uint8_t mme_code;
STAILQ_ENTRY(mme_code_s) next;
};
/* Served gummei element */
struct served_gummei_s {
/* Number of MME served PLMNs */
uint8_t nb_served_plmns;
/* List of served PLMNs by MME */
STAILQ_HEAD(served_plmns_s, plmn_identity_s) served_plmns;
/* Number of group id in list */
uint8_t nb_group_id;
/* Served group id list */
STAILQ_HEAD(served_group_ids_s, served_group_id_s) served_group_ids;
/* Number of MME code */
uint8_t nb_mme_code;
/* MME Code to uniquely identify an MME within an MME pool area */
STAILQ_HEAD(mme_codes_s, mme_code_s) mme_codes;
/* Next GUMMEI element */
STAILQ_ENTRY(served_gummei_s) next;
};
struct s1ap_eNB_instance_s;
/* This structure describes association of a eNB to a MME */
typedef struct s1ap_eNB_mme_data_s {
/* MME descriptors tree, ordered by sctp assoc id */
RB_ENTRY(s1ap_eNB_mme_data_s) entry;
/* This is the optional name provided by the MME */
char *mme_name;
net_ip_address_t mme_net_ip_address; // useful for joining assoc_id and ip address of packets
/* List of served GUMMEI per MME. There is one GUMMEI per RAT with a max
* number of 8 RATs but in our case only one is used. The LTE related pool
* configuration is included on the first place in the list.
*/
STAILQ_HEAD(served_gummeis_s, served_gummei_s) served_gummei;
/* Relative processing capacity of an MME with respect to the other MMEs
* in the pool in order to load-balance MMEs within a pool as defined
* in TS 23.401.
*/
uint8_t relative_mme_capacity;
/* Current MME overload information (if any). */
s1ap_overload_state_t overload_state;
/* Current eNB->MME S1AP association state */
s1ap_eNB_state_t state;
/* Next usable stream for UE signalling */
int32_t nextstream;
/* Number of input/ouput streams */
uint16_t in_streams;
uint16_t out_streams;
/* Connexion id used between SCTP/S1AP */
uint16_t cnx_id;
/* SCTP association id */
int32_t assoc_id;
/* Only meaningfull in virtual mode */
struct s1ap_eNB_instance_s *s1ap_eNB_instance;
} s1ap_eNB_mme_data_t;
typedef struct s1ap_eNB_instance_s {
/* Next s1ap eNB association.
* Only used for virtual mode.
*/
STAILQ_ENTRY(s1ap_eNB_instance_s) s1ap_eNB_entries;
/* Number of MME requested by eNB (tree size) */
uint32_t s1ap_mme_nb;
/* Number of MME for which association is pending */
uint32_t s1ap_mme_pending_nb;
/* Number of MME successfully associated to eNB */
uint32_t s1ap_mme_associated_nb;
/* Tree of S1AP MME associations ordered by association ID */
RB_HEAD(s1ap_mme_map, s1ap_eNB_mme_data_s) s1ap_mme_head;
/* TODO: add a map ordered by relative MME capacity */
/* Tree of UE ordered by eNB_ue_s1ap_id's */
RB_HEAD(s1ap_ue_map, s1ap_eNB_ue_context_s) s1ap_ue_head;
/* For virtual mode, mod_id as defined in the rest of the L1/L2 stack */
instance_t instance;
/* Displayable name of eNB */
char *eNB_name;
net_ip_address_t s1c_net_ip_address;
/* Unique eNB_id to identify the eNB within EPC.
* In our case the eNB is a macro eNB so the id will be 20 bits long.
* For Home eNB id, this field should be 28 bits long.
*/
uint32_t eNB_id;
/* The type of the cell */
enum cell_type_e cell_type;
/* Tracking area code */
uint16_t tac;
/* Mobile Country Code
* Mobile Network Code
*/
uint16_t mcc;
uint16_t mnc;
uint8_t mnc_digit_length;
} s1ap_eNB_instance_t;
typedef struct {
/* List of served eNBs
* Only used for virtual mode
*/
STAILQ_HEAD(s1ap_eNB_instances_head_s, s1ap_eNB_instance_s) s1ap_eNB_instances_head;
/* Nb of registered eNBs */
uint8_t nb_registered_eNBs;
/* Generate a unique connexion id used between S1AP and SCTP */
uint16_t global_cnx_id;
} s1ap_eNB_internal_data_t;
int s1ap_eNB_compare_assoc_id(
struct s1ap_eNB_mme_data_s *p1, struct s1ap_eNB_mme_data_s *p2);
/* Generate the tree management functions */
RB_PROTOTYPE(s1ap_mme_map, s1ap_eNB_mme_data_s, entry,
s1ap_eNB_compare_assoc_id);
#endif /* PLAY_SCENARIO_S1AP_ENB_DEFS_H_ */
/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr
Address : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
*******************************************************************************/
/*
play_scenario_sctp.c
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
*/
#include <errno.h>
#include "intertask_interface.h"
#include "platform_types.h"
#include "assertions.h"
#include "play_scenario.h"
//------------------------------------------------------------------------------
asn_comp_rval_t * et_sctp_data_is_matching(sctp_datahdr_t * const sctp1, sctp_datahdr_t * const sctp2, const uint32_t constraints)
{
asn_comp_rval_t *rv = NULL;
// no comparison for ports
if (sctp1->ppid != sctp2->ppid) {
S1AP_WARN("No Matching SCTP PPID %u %u\n", sctp1->ppid, sctp2->ppid);
rv = calloc(1, sizeof(asn_comp_rval_t));
rv->err_code = ET_ERROR_MATCH_PACKET_SCTP_PPID;
return rv;
}
if (sctp1->assoc_id != sctp2->assoc_id) {
S1AP_WARN("No Matching SCTP assoc id %u %u\n", sctp1->assoc_id, sctp2->assoc_id);
rv = calloc(1, sizeof(asn_comp_rval_t));
rv->err_code = ET_ERROR_MATCH_PACKET_SCTP_ASSOC_ID;
return rv;
}
if (sctp1->stream != sctp2->stream) {
if (constraints & ET_BIT_MASK_MATCH_SCTP_STREAM) {
rv = calloc(1, sizeof(asn_comp_rval_t));
rv->err_code = ET_ERROR_MATCH_PACKET_SCTP_STREAM_ID;
return rv;
} else {
S1AP_WARN("No Matching SCTP stream %u %u\n", sctp1->stream, sctp2->stream);
}
}
// We do not have SSN from lower layers
// if (sctp1->ssn != sctp2->ssn) {
// if (constraints & ET_BIT_MASK_MATCH_SCTP_SSN) {
// rv = calloc(1, sizeof(asn_comp_rval_t));
// rv->err_code = ET_ERROR_MATCH_PACKET_SCTP_SSN;
// return rv;
// } else {
// S1AP_WARN("No Matching SCTP STREAM SN %u %u\n", sctp1->ssn, sctp2->ssn);
// }
// }
return et_s1ap_is_matching(&sctp1->payload, &sctp2->payload, constraints);
}
//------------------------------------------------------------------------------
asn_comp_rval_t * et_sctp_is_matching(et_sctp_hdr_t * const sctp1, et_sctp_hdr_t * const sctp2, const uint32_t constraints)
{
// no comparison for ports
asn_comp_rval_t *rv = NULL;
if (sctp1->chunk_type != sctp2->chunk_type){
S1AP_WARN("No Matching chunk_type %u %u\n", sctp1->chunk_type, sctp2->chunk_type);
rv = calloc(1, sizeof(asn_comp_rval_t));
rv->err_code = ET_ERROR_MATCH_PACKET_SCTP_CHUNK_TYPE;
return rv;
}
switch (sctp1->chunk_type) {
case SCTP_CID_DATA:
return et_sctp_data_is_matching(&sctp1->u.data_hdr, &sctp2->u.data_hdr, constraints);
break;
case SCTP_CID_INIT:
AssertFatal(0, "Not needed now");
break;
case SCTP_CID_INIT_ACK:
AssertFatal(0, "Not needed now");
break;
default:
AssertFatal(0, "Not needed now cid %d", sctp1->chunk_type);
}
return NULL;
}
......@@ -275,7 +275,6 @@ do { \
(bITsTRING)->size = 3; \
(bITsTRING)->bits_unused = 4; \
} while(0)
/*
/* TS 36.413 v10.9.0 section 9.2.1.38:
* E-UTRAN CGI/Cell Identity
* The leftmost bits of the Cell
......
......@@ -130,10 +130,12 @@ eNBs =
};
////////// MME parameters:
mme_ip_address = ( {ipv4 = "192.170.0.1";
ipv6="192:168:30::17";
active="yes";
preference="ipv4";});
mme_ip_address = ( { ipv4 = "192.170.0.1";
ipv6 = "192:168:30::17";
active = "yes";
preference = "ipv4";
}
);
NETWORK_INTERFACES :
{
......@@ -141,6 +143,7 @@ eNBs =
ENB_IPV4_ADDRESS_FOR_S1_MME = "192.170.0.2/24";
ENB_INTERFACE_NAME_FOR_S1U = "eth0:4";
ENB_IPV4_ADDRESS_FOR_S1U = "192.170.1.2/24";
ENB_IPV4_ADDRESS_FOR_S1U = "192.170.0.2/24";
ENB_PORT_FOR_S1U = 2152; # Spec 2152
};
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment