maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hacks for NR

Browse Source 
- send RRC Connection Reconfiguration with dummy ENDC data by doing:
  telnet localhost 9001
  and press enter when the ENDC UE is connected to the eNB to send it
This commit is contained in:
Cedric Roux
2019-10-03 15:14:26 +02:00
parent ff379fe08c
commit dd760540ea
3 changed files with 363 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmake_targets/CMakeLists.txt
+1
View File
@@ -1568,6 +1568,7 @@ set(L2_SRC
${RLC_DIR}/rlc_mpls.c
# ${RRC_DIR}/rrc_UE.c
${RRC_DIR}/rrc_eNB.c
${RRC_DIR}/rrc_eNB_endc.c
${RRC_DIR}/rrc_eNB_S1AP.c
${RRC_DIR}/rrc_eNB_UE_context.c
${RRC_DIR}/rrc_common.c
openair2/RRC/LTE/rrc_eNB.c
+9
View File
@@ -9121,11 +9121,20 @@ rrc_enb_task(
//-----------------------------------------------------------------------------
{
rrc_enb_init();
void rrc_endc_hack_init(void);
rrc_endc_hack_init();
itti_mark_task_ready(TASK_RRC_ENB);
LOG_I(RRC,"Entering main loop of RRC message task\n");
while (1) {
(void) rrc_enb_process_itti_msg(NULL);
{
extern volatile int go_nr;
void rrc_go_nr(void);
if (go_nr) rrc_go_nr();
}
}
}
openair2/RRC/LTE/rrc_eNB_endc.c
+353
View File
@@ -0,0 +1,353 @@
/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
#include "rrc_defs.h"
#include "rrc_extern.h"
#include "rrc_eNB_UE_context.h"
#include "common/ran_context.h"
#include "LTE_DL-DCCH-Message.h"
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
extern RAN_CONTEXT_t RC;
extern mui_t rrc_eNB_mui;
int rrc_eNB_generate_RRCConnectionReconfiguration_endc(protocol_ctxt_t *ctxt,
rrc_eNB_ue_context_t *ue_context,
unsigned char *buffer,
int buffer_size)
{
asn_enc_rval_t enc_rval;
LTE_DL_DCCH_Message_t dl_dcch_msg;
LTE_RRCConnectionReconfiguration_t *r;
int trans_id;
LTE_RadioResourceConfigDedicated_t rrcd;
LTE_DRB_ToAddModList_t drb_list;
struct LTE_DRB_ToAddMod drb;
long eps_bearer_id;
struct LTE_RLC_Config rlc;
long lcid;
struct LTE_LogicalChannelConfig lc;
struct LTE_LogicalChannelConfig__ul_SpecificParameters ul_params;
long lcg;
struct LTE_RadioResourceConfigDedicated__mac_MainConfig mac;
struct LTE_MAC_MainConfig__ext4 mac_ext4;
struct LTE_MAC_MainConfig__ext4__dualConnectivityPHR dc_phr;
memset(&rrcd, 0, sizeof(rrcd));
memset(&drb_list, 0, sizeof(drb_list));
memset(&drb, 0, sizeof(drb));
memset(&rlc, 0, sizeof(rlc));
memset(&lc, 0, sizeof(lc));
memset(&ul_params, 0, sizeof(ul_params));
memset(&mac, 0, sizeof(mac));
memset(&mac_ext4, 0, sizeof(mac_ext4));
memset(&dc_phr, 0, sizeof(dc_phr));
trans_id = rrc_eNB_get_next_transaction_identifier(ctxt->module_id);
memset(&dl_dcch_msg,0,sizeof(LTE_DL_DCCH_Message_t));
dl_dcch_msg.message.present = LTE_DL_DCCH_MessageType_PR_c1;
dl_dcch_msg.message.choice.c1.present = LTE_DL_DCCH_MessageType__c1_PR_rrcConnectionReconfiguration;
r = &dl_dcch_msg.message.choice.c1.choice.rrcConnectionReconfiguration;
r->rrc_TransactionIdentifier = trans_id;
r->criticalExtensions.present = LTE_RRCConnectionReconfiguration__criticalExtensions_PR_c1;
r->criticalExtensions.choice.c1.present = LTE_RRCConnectionReconfiguration__criticalExtensions__c1_PR_rrcConnectionReconfiguration_r8;
r->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated = &rrcd;
rrcd.drb_ToAddModList = &drb_list;
eps_bearer_id = 5;
drb.eps_BearerIdentity = &eps_bearer_id;
drb.drb_Identity = 5;
drb.rlc_Config = &rlc;
lcid = 4;
drb.logicalChannelIdentity = &lcid;
drb.logicalChannelConfig = &lc;
rlc.present = LTE_RLC_Config_PR_am;
rlc.choice.am.ul_AM_RLC.t_PollRetransmit = LTE_T_PollRetransmit_ms50;
rlc.choice.am.ul_AM_RLC.pollPDU = LTE_PollPDU_p16;
rlc.choice.am.ul_AM_RLC.pollByte = LTE_PollByte_kBinfinity;
rlc.choice.am.ul_AM_RLC.maxRetxThreshold = LTE_UL_AM_RLC__maxRetxThreshold_t8;
rlc.choice.am.dl_AM_RLC.t_Reordering = LTE_T_Reordering_ms35;
rlc.choice.am.dl_AM_RLC.t_StatusProhibit = LTE_T_StatusProhibit_ms25;
lc.ul_SpecificParameters = &ul_params;
ul_params.priority = 12;
ul_params.prioritisedBitRate = LTE_LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_kBps8;
ul_params.bucketSizeDuration = LTE_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms300;
lcg = 3;
ul_params.logicalChannelGroup = &lcg;
rrcd.mac_MainConfig = &mac;
mac.present = LTE_RadioResourceConfigDedicated__mac_MainConfig_PR_explicitValue;
mac.choice.explicitValue.timeAlignmentTimerDedicated = LTE_TimeAlignmentTimer_sf10240;
mac.choice.explicitValue.ext4 = &mac_ext4;
mac_ext4.dualConnectivityPHR = &dc_phr;
dc_phr.present = LTE_MAC_MainConfig__ext4__dualConnectivityPHR_PR_setup;
dc_phr.choice.setup.phr_ModeOtherCG_r12 = LTE_MAC_MainConfig__ext4__dualConnectivityPHR__setup__phr_ModeOtherCG_r12_virtual;
/* NR config */
struct LTE_RRCConnectionReconfiguration_v890_IEs cr_890;
struct LTE_RRCConnectionReconfiguration_v920_IEs cr_920;
struct LTE_RRCConnectionReconfiguration_v1020_IEs cr_1020;
struct LTE_RRCConnectionReconfiguration_v1130_IEs cr_1130;
struct LTE_RRCConnectionReconfiguration_v1250_IEs cr_1250;
struct LTE_RRCConnectionReconfiguration_v1310_IEs cr_1310;
struct LTE_RRCConnectionReconfiguration_v1430_IEs cr_1430;
struct LTE_RRCConnectionReconfiguration_v1510_IEs cr_1510;
struct LTE_RRCConnectionReconfiguration_v1510_IEs__nr_Config_r15 nr;
memset(&cr_890, 0, sizeof(cr_890));
memset(&cr_920, 0, sizeof(cr_920));
memset(&cr_1020, 0, sizeof(cr_1020));
memset(&cr_1130, 0, sizeof(cr_1130));
memset(&cr_1250, 0, sizeof(cr_1250));
memset(&cr_1310, 0, sizeof(cr_1310));
memset(&cr_1430, 0, sizeof(cr_1430));
memset(&cr_1510, 0, sizeof(cr_1510));
memset(&nr, 0, sizeof(nr));
r->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.nonCriticalExtension = &cr_890;
cr_890.nonCriticalExtension = &cr_920;
cr_920.nonCriticalExtension = &cr_1020;
cr_1020.nonCriticalExtension = &cr_1130;
cr_1130.nonCriticalExtension = &cr_1250;
cr_1250.nonCriticalExtension = &cr_1310;
cr_1310.nonCriticalExtension = &cr_1430;
cr_1430.nonCriticalExtension = &cr_1510;
cr_1510.nr_Config_r15 = &nr;
nr.present = LTE_RRCConnectionReconfiguration_v1510_IEs__nr_Config_r15_PR_setup;
nr.choice.setup.endc_ReleaseAndAdd_r15 = 0; /* FALSE */
OCTET_STRING_t scg_conf;
unsigned char scg_conf_buf[4] = { 0, 0, 0, 0 };
nr.choice.setup.nr_SecondaryCellGroupConfig_r15 = &scg_conf;
scg_conf.buf = scg_conf_buf;
scg_conf.size = 4;
long sk_counter = 0;
cr_1510.sk_Counter_r15 = &sk_counter;
OCTET_STRING_t nr1_conf;
unsigned char nr1_buf[4] = { 0, 0, 0, 0 };
cr_1510.nr_RadioBearerConfig1_r15 = &nr1_conf;
nr1_conf.buf = nr1_buf;
nr1_conf.size = 4;
OCTET_STRING_t nr2_conf;
unsigned char nr2_buf[4] = { 0, 0, 0, 0 };
cr_1510.nr_RadioBearerConfig2_r15 = &nr2_conf;
nr2_conf.buf = nr2_buf;
nr2_conf.size = 4;
ASN_SEQUENCE_ADD(&drb_list.list, &drb);
enc_rval = uper_encode_to_buffer(&asn_DEF_LTE_DL_DCCH_Message,
NULL,
(void *)&dl_dcch_msg,
buffer,
buffer_size);
{
int len = (enc_rval.encoded + 7) / 8;
int i;
printf("len = %d\n", len);
for (i = 0; i < len; i++) printf(" %2.2x", buffer[i]);
printf("\n");
}
return (enc_rval.encoded + 7) / 8;
}
volatile int go_nr;
struct rrc_eNB_ue_context_s *
get_first_ue_context(eNB_RRC_INST *rrc_instance_pP)
{
struct rrc_eNB_ue_context_s *ue_context_p = NULL;
RB_FOREACH(ue_context_p, rrc_ue_tree_s, &(rrc_instance_pP->rrc_ue_head)) {
return ue_context_p;
}
return NULL;
}
void rrc_go_nr(void)
{
protocol_ctxt_t ctxt;
rrc_eNB_ue_context_t *ue_context;
unsigned char buffer[8192];
int size;
go_nr = 0;
ue_context = get_first_ue_context(RC.rrc[0]);
PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt,
0,
ENB_FLAG_YES,
ue_context->ue_context.rnti,
0, 0);
size = rrc_eNB_generate_RRCConnectionReconfiguration_endc(&ctxt, ue_context, buffer, 8192);
rrc_data_req(&ctxt,
DCCH,
rrc_eNB_mui++,
SDU_CONFIRM_NO,
size,
buffer,
PDCP_TRANSMISSION_MODE_CONTROL);
}
static void new_thread(void *(*f)(void *), void *data) {
pthread_t t;
pthread_attr_t att;
if (pthread_attr_init(&att)) {
fprintf(stderr, "pthread_attr_init err\n");
exit(1);
}
if (pthread_attr_setdetachstate(&att, PTHREAD_CREATE_DETACHED)) {
fprintf(stderr, "pthread_attr_setdetachstate err\n");
exit(1);
}
if (pthread_attr_setstacksize(&att, 10000000)) {
fprintf(stderr, "pthread_attr_setstacksize err\n");
exit(1);
}
if (pthread_create(&t, &att, f, data)) {
fprintf(stderr, "pthread_create err\n");
exit(1);
}
if (pthread_attr_destroy(&att)) {
fprintf(stderr, "pthread_attr_destroy err\n");
exit(1);
}
}
static int create_listen_socket(char *addr, int port) {
struct sockaddr_in a;
int s;
int v;
s = socket(AF_INET, SOCK_STREAM, 0);
if (s == -1) {
perror("socket");
exit(1);
}
v = 1;
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(int))) {
perror("setsockopt");
exit(1);
}
a.sin_family = AF_INET;
a.sin_port = htons(port);
a.sin_addr.s_addr = inet_addr(addr);
if (bind(s, (struct sockaddr *)&a, sizeof(a))) {
perror("bind");
exit(1);
}
if (listen(s, 5)) {
perror("listen");
exit(1);
}
return s;
}
static int socket_accept(int s) {
struct sockaddr_in a;
socklen_t alen;
alen = sizeof(a);
return accept(s, (struct sockaddr *)&a, &alen);
}
static int fullread(int fd, void *_buf, int count) {
char *buf = _buf;
int ret = 0;
int l;
while (count) {
l = read(fd, buf, count);
if (l <= 0) return -1;
count -= l;
buf += l;
ret += l;
}
return ret;
}
void *nr_hack(void *_)
{
int s = create_listen_socket("0.0.0.0", 9001);
int t;
over:
t = socket_accept(s);
while (1) {
char c;
if (fullread(t, &c, 1) != 1) {
close(t);
goto over;
}
if (c != '\n') continue;
printf("setting go_nr to 1\n");
go_nr = 1;
}
return 0;
}
void rrc_endc_hack_init(void)
{
new_thread(nr_hack, NULL);
}