Merge remote-tracking branch 'origin/NR_SA_F1AP_5GRECORDS' into develop-NR_SA_F1AP_5GRECORDS

executables/nr-softmodem.c

@@ -857,13 +857,6 @@ if(!IS_SOFTMODEM_NOS1)
       printf("NFAPI mode - DO NOT call init_gNB_afterRU()\n");
     }
 
-    if (nfapi_mode != 1 && nfapi_mode != 2) {
-      printf("Not NFAPI mode - call init_eNB_afterRU()\n");
-      init_eNB_afterRU();
-    } else {
-      printf("NFAPI mode - DO NOT call init_gNB_afterRU()\n");
-    }
-
     printf("ALL RUs ready - ALL gNBs ready\n");
     // connect the TX/RX buffers
     printf("Sending sync to all threads\n");

openair2/GNB_APP/gnb_config.c

@@ -1109,6 +1109,8 @@ int RCconfig_nr_gtpu(void ) {
         IPV4_STR_ADDR_TO_INT_NWBO (address, GTPV1U_ENB_S1_REQ(message).enb_ip_address_for_S1u_S12_S4_up, "BAD IP ADDRESS FORMAT FOR eNB S1_U !\n" );
         LOG_I(GTPU,"Configuring GTPu address : %s -> %x\n",address,GTPV1U_ENB_S1_REQ(message).enb_ip_address_for_S1u_S12_S4_up);
         GTPV1U_ENB_S1_REQ(message).enb_port_for_S1u_S12_S4_up = gnb_port_for_S1U;
+        strcpy(GTPV1U_ENB_S1_REQ(message).addrStr,address);
+        sprintf(GTPV1U_ENB_S1_REQ(message).portStr,"%d", gnb_port_for_NGU);
       } else {// TODO SA
         message = itti_alloc_new_message(TASK_GNB_APP, 0, GTPV1U_GNB_NG_REQ);
         AssertFatal(message!=NULL,"");
@@ -1116,8 +1118,6 @@ int RCconfig_nr_gtpu(void ) {
         LOG_I(GTPU,"Configuring GTPu address : %s -> %x\n",address,GTPV1U_GNB_NG_REQ(message).gnb_ip_address_for_NGu_up);
         GTPV1U_GNB_NG_REQ(message).gnb_port_for_NGu_up = gnb_port_for_NGU;
       }
-    strcpy(GTPV1U_ENB_S1_REQ(message).addrStr,address);
-    sprintf(GTPV1U_ENB_S1_REQ(message).portStr,"%d", gnb_port_for_NGU);
      itti_send_msg_to_task (TASK_VARIABLE, 0, message); // data model is wrong: gtpu doesn't have enb_id (or module_id)
     } else
     LOG_E(GTPU,"invalid address for NGU\n");

openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c

@@ -101,7 +101,7 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity,
     entity->integrity(entity->integrity_context, integrity,
                       buffer, size - integrity_size,
                       entity->rb_id, rcvd_count, entity->is_gnb ? 0 : 1);
-    if (memcmp(integrity, buffer, 4) != 0) {
+    if (memcmp(integrity, buffer + size - integrity_size, 4) != 0) {
       LOG_E(PDCP, "discard NR PDU, integrity failed\n");
       return;
     }
@@ -212,6 +212,7 @@ static void nr_pdcp_entity_recv_sdu(nr_pdcp_entity_t *entity,
                       header_size + size + integrity_size, sdu_id);
 }
 
+/* may be called several times, take care to clean previous settings */
 static void nr_pdcp_entity_set_security(nr_pdcp_entity_t *entity,
                                         int integrity_algorithm,
                                         char *integrity_key,
@@ -226,6 +227,46 @@ static void nr_pdcp_entity_set_security(nr_pdcp_entity_t *entity,
     memcpy(entity->integrity_key, integrity_key, 16);
   if (ciphering_key != NULL)
     memcpy(entity->ciphering_key, ciphering_key, 16);
+
+  if (integrity_algorithm == 0) {
+    entity->has_integrity = 0;
+    if (entity->free_integrity != NULL)
+      entity->free_integrity(entity->integrity_context);
+    entity->free_integrity = NULL;
+  }
+
+  if (integrity_algorithm != 0 && integrity_algorithm != -1) {
+    if (integrity_algorithm != 2) {
+      LOG_E(PDCP, "FATAL: only nia2 supported for the moment\n");
+      exit(1);
+    }
+    entity->has_integrity = 1;
+    if (entity->free_integrity != NULL)
+      entity->free_integrity(entity->integrity_context);
+    entity->integrity_context = nr_pdcp_integrity_nia2_init(entity->integrity_key);
+    entity->integrity = nr_pdcp_integrity_nia2_integrity;
+    entity->free_integrity = nr_pdcp_integrity_nia2_free_integrity;
+  }
+
+  if (ciphering_algorithm == 0) {
+    entity->has_ciphering = 0;
+    if (entity->free_security != NULL)
+      entity->free_security(entity->security_context);
+    entity->free_security = NULL;
+  }
+
+  if (ciphering_algorithm != 0 && ciphering_algorithm != -1) {
+    if (ciphering_algorithm != 2) {
+      LOG_E(PDCP, "FATAL: only nea2 supported for the moment\n");
+      exit(1);
+    }
+    entity->has_ciphering = 1;
+    if (entity->free_security != NULL)
+      entity->free_security(entity->security_context);
+    entity->security_context = nr_pdcp_security_nea2_init(entity->ciphering_key);
+    entity->cipher = nr_pdcp_security_nea2_cipher;
+    entity->free_security = nr_pdcp_security_nea2_free_security;
+  }
 }
 
 static void check_t_reordering(nr_pdcp_entity_t *entity)
@@ -339,34 +380,11 @@ nr_pdcp_entity_t *new_nr_pdcp_entity(
   ret->sn_max        = (1 << sn_size) - 1;
   ret->window_size   = 1 << (sn_size - 1);
 
-  if (ciphering_key != NULL && ciphering_algorithm != 0) {
-    if (ciphering_algorithm != 2) {
-      LOG_E(PDCP, "FATAL: only nea2 supported for the moment\n");
-      exit(1);
-    }
-    ret->has_ciphering = 1;
-    ret->ciphering_algorithm = ciphering_algorithm;
-    memcpy(ret->ciphering_key, ciphering_key, 16);
-
-    ret->security_context = nr_pdcp_security_nea2_init(ciphering_key);
-    ret->cipher = nr_pdcp_security_nea2_cipher;
-    ret->free_security = nr_pdcp_security_nea2_free_security;
-  }
   ret->is_gnb = is_gnb;
 
-  if (integrity_key != NULL && integrity_algorithm != 0) {
-    if (integrity_algorithm != 2) {
-      LOG_E(PDCP, "FATAL: only nia2 supported for the moment\n");
-      exit(1);
-    }
-    ret->has_integrity = 1;
-    ret->integrity_algorithm = integrity_algorithm;
-    memcpy(ret->integrity_key, integrity_key, 16);
-
-    ret->integrity_context = nr_pdcp_integrity_nia2_init(integrity_key);
-    ret->integrity = nr_pdcp_integrity_nia2_integrity;
-    ret->free_integrity = nr_pdcp_integrity_nia2_free_integrity;
-  }
+  nr_pdcp_entity_set_security(ret,
+                              integrity_algorithm, (char *)integrity_key,
+                              ciphering_algorithm, (char *)ciphering_key);
 
   return ret;
 }

openair2/LAYER2/nr_pdcp/nr_pdcp_integrity_nia2.c

@@ -45,7 +45,7 @@ static void compute_t(unsigned char *t, uint32_t count, int bearer,
   t[1] = (count >> 16) & 255;
   t[2] = (count >>  8) & 255;
   t[3] = (count      ) & 255;
-  t[4] = (bearer << 3) | (direction << 2);
+  t[4] = ((bearer-1) << 3) | (direction << 2);
   memset(&t[5], 0, 8-5);
 }
 
@@ -63,6 +63,7 @@ void nr_pdcp_integrity_nia2_integrity(void *integrity_context,
    * (which is identical to 128-NIA2, see 33.501 D.3.1.3) */
   compute_t(t, count, bearer, direction);
 
+  CMAC_Init(ctx, NULL, 0, NULL, NULL);
   CMAC_Update(ctx, t, 8);
   CMAC_Update(ctx, buffer, length);
   CMAC_Final(ctx, mac, &maclen);

openair2/RRC/NR/MESSAGES/asn1_msg.c

@@ -70,6 +70,7 @@
 #include "NR_RRCReconfigurationComplete-IEs.h"
 #include "NR_DLInformationTransfer.h"
 #include "NR_RRCReestablishmentRequest.h"
+#include "NR_UE-CapabilityRequestFilterNR.h"
 #include "PHY/defs_nr_common.h"
 #if defined(NR_Rel16)
   #include "NR_SCS-SpecificCarrier.h"
@@ -1076,7 +1077,8 @@ void fill_initial_SpCellConfig(rnti_t rnti,
   
   ASN_SEQUENCE_ADD(&bwp_Dedicated->pdcch_Config->choice.setup->searchSpacesToAddModList->list,
                    ss2);
-
+  
+  SpCellConfig->spCellConfigDedicated->tag_Id=0;
 }
 
 void fill_initial_cellGroupConfig(rnti_t rnti,
@@ -1127,6 +1129,10 @@ void fill_initial_cellGroupConfig(rnti_t rnti,
     logicalChannelGroup                                              = CALLOC(1, sizeof(long));
     *logicalChannelGroup                                             = 0;
     logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup = logicalChannelGroup;
+    logicalChannelConfig->ul_SpecificParameters->schedulingRequestID = CALLOC(1, sizeof(*logicalChannelConfig->ul_SpecificParameters->schedulingRequestID));
+    *logicalChannelConfig->ul_SpecificParameters->schedulingRequestID = 0;
+    logicalChannelConfig->ul_SpecificParameters->logicalChannelSR_Mask = 0;
+    logicalChannelConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = 0;
   //}
   rlc_BearerConfig->mac_LogicalChannelConfig                       = logicalChannelConfig;
   
@@ -1135,11 +1141,27 @@ void fill_initial_cellGroupConfig(rnti_t rnti,
   cellGroupConfig->rlc_BearerToReleaseList = NULL;
   
   /* mac CellGroup Config */
-  if (0) {
-    mac_CellGroupConfig                                                     = calloc(1, sizeof(NR_MAC_CellGroupConfig_t));
+  if (1) {
+    mac_CellGroupConfig                                                     = calloc(1, sizeof(*mac_CellGroupConfig));
+    mac_CellGroupConfig->schedulingRequestConfig                            = calloc(1, sizeof(*mac_CellGroupConfig->schedulingRequestConfig));
+    mac_CellGroupConfig->schedulingRequestConfig->schedulingRequestToAddModList = CALLOC(1,sizeof(*mac_CellGroupConfig->schedulingRequestConfig->schedulingRequestToAddModList));
+    struct NR_SchedulingRequestToAddMod *schedulingrequestlist;
+    schedulingrequestlist = CALLOC(1,sizeof(*schedulingrequestlist));
+    schedulingrequestlist->schedulingRequestId  = 0;
+    schedulingrequestlist->sr_ProhibitTimer = CALLOC(1,sizeof(*schedulingrequestlist->sr_ProhibitTimer));
+    *(schedulingrequestlist->sr_ProhibitTimer) = 0;
+    schedulingrequestlist->sr_TransMax      = 0;
+    ASN_SEQUENCE_ADD(&(mac_CellGroupConfig->schedulingRequestConfig->schedulingRequestToAddModList->list),schedulingrequestlist);
     mac_CellGroupConfig->bsr_Config                                         = calloc(1, sizeof(*mac_CellGroupConfig->bsr_Config));
     mac_CellGroupConfig->bsr_Config->periodicBSR_Timer                      = NR_BSR_Config__periodicBSR_Timer_sf10;
     mac_CellGroupConfig->bsr_Config->retxBSR_Timer                          = NR_BSR_Config__retxBSR_Timer_sf80;
+    mac_CellGroupConfig->tag_Config                                         = calloc(1, sizeof(*mac_CellGroupConfig->tag_Config));
+    mac_CellGroupConfig->tag_Config->tag_ToReleaseList = NULL;
+    mac_CellGroupConfig->tag_Config->tag_ToAddModList  = calloc(1,sizeof(*mac_CellGroupConfig->tag_Config->tag_ToAddModList));
+    struct NR_TAG *tag=calloc(1,sizeof(*tag));
+    tag->tag_Id             = 0;
+    tag->timeAlignmentTimer = NR_TimeAlignmentTimer_infinity;
+    ASN_SEQUENCE_ADD(&mac_CellGroupConfig->tag_Config->tag_ToAddModList->list,tag);
     mac_CellGroupConfig->phr_Config                                         = calloc(1, sizeof(*mac_CellGroupConfig->phr_Config));
     mac_CellGroupConfig->phr_Config->present                                = NR_SetupRelease_PHR_Config_PR_setup;
     mac_CellGroupConfig->phr_Config->choice.setup                           = calloc(1, sizeof(*mac_CellGroupConfig->phr_Config->choice.setup));
@@ -1243,7 +1265,7 @@ uint8_t do_RRCSetup(rrc_gNB_ue_context_t         *const ue_context_pP,
 				       NULL,
 				       (void *)cellGroupConfig,
 				       masterCellGroup_buf,
-				       100);
+				       1000);
       
       if(enc_rval.encoded == -1) {
         LOG_E(NR_RRC, "ASN1 message CellGroupConfig encoding failed (%s, %lu)!\n",
@@ -1264,7 +1286,7 @@ uint8_t do_RRCSetup(rrc_gNB_ue_context_t         *const ue_context_pP,
 				     NULL,
 				     (void *)&dl_ccch_msg,
 				     buffer,
-				     100);
+				     1000);
     
     if(enc_rval.encoded == -1) {
       LOG_E(NR_RRC, "[gNB AssertFatal]ASN1 message encoding failed (%s, %lu)!\n",
@@ -1346,6 +1368,11 @@ uint8_t do_NR_SA_UECapabilityEnquiry( const protocol_ctxt_t *const ctxt_pP,
                                    const uint8_t                Transaction_id)
 //------------------------------------------------------------------------------
 {
+  NR_UE_CapabilityRequestFilterNR_t *sa_band_filter;
+  NR_FreqBandList_t *sa_band_list;
+  NR_FreqBandInformation_t *sa_band_info;
+  NR_FreqBandInformationNR_t *sa_band_infoNR;
+
   NR_DL_DCCH_Message_t dl_dcch_msg;
   NR_UE_CapabilityRAT_Request_t *ue_capabilityrat_request;
 
@@ -1362,6 +1389,35 @@ uint8_t do_NR_SA_UECapabilityEnquiry( const protocol_ctxt_t *const ctxt_pP,
   memset(ue_capabilityrat_request,0,sizeof(NR_UE_CapabilityRAT_Request_t));
   ue_capabilityrat_request->rat_Type = NR_RAT_Type_nr;
 
+  sa_band_infoNR = (NR_FreqBandInformationNR_t*)calloc(1,sizeof(NR_FreqBandInformationNR_t));
+  sa_band_infoNR->bandNR = 78;
+  sa_band_info = (NR_FreqBandInformation_t*)calloc(1,sizeof(NR_FreqBandInformation_t));
+  sa_band_info->present = NR_FreqBandInformation_PR_bandInformationNR;
+  sa_band_info->choice.bandInformationNR = sa_band_infoNR;
+  
+  sa_band_list = (NR_FreqBandList_t *)calloc(1, sizeof(NR_FreqBandList_t));
+  ASN_SEQUENCE_ADD(&sa_band_list->list, sa_band_info);
+
+  sa_band_filter = (NR_UE_CapabilityRequestFilterNR_t*)calloc(1,sizeof(NR_UE_CapabilityRequestFilterNR_t));
+  sa_band_filter->frequencyBandListFilter = sa_band_list;
+
+  OCTET_STRING_t req_freq;
+  unsigned char req_freq_buf[1024];
+  enc_rval = uper_encode_to_buffer(&asn_DEF_NR_UE_CapabilityRequestFilterNR,
+				   NULL,
+				   (void *)sa_band_filter,
+				   req_freq_buf,
+				   1024);
+
+  if ( LOG_DEBUGFLAG(DEBUG_ASN1) ) {
+    xer_fprint(stdout, &asn_DEF_NR_UE_CapabilityRequestFilterNR, (void *)sa_band_filter);
+  }
+
+  req_freq.buf = req_freq_buf;
+  req_freq.size = (enc_rval.encoded+7)/8;
+
+  ue_capabilityrat_request->capabilityRequestFilter = &req_freq;
+
   ASN_SEQUENCE_ADD(&dl_dcch_msg.message.choice.c1->choice.ueCapabilityEnquiry->criticalExtensions.choice.ueCapabilityEnquiry->ue_CapabilityRAT_RequestList.list,
                    ue_capabilityrat_request);
 
@@ -1508,7 +1564,7 @@ uint16_t do_RRCReconfiguration(
                                     NULL,
                                     (void *)&dl_dcch_msg,
                                     buffer,
-                                    100);
+                                    1000);
 
     if(enc_rval.encoded == -1) {
         LOG_I(NR_RRC, "[gNB AssertFatal]ASN1 message encoding failed (%s, %lu)!\n",

openair2/RRC/NR/nr_rrc_proto.h

@@ -193,3 +193,8 @@ rrc_gNB_generate_dedicatedRRCReconfiguration_release(
     uint8_t                  xid,
     uint32_t                 nas_length,
     uint8_t                 *nas_buffer);
+
+void 
+rrc_gNB_generate_dedicatedRRCReconfiguration(
+    const protocol_ctxt_t     *const ctxt_pP,
+    rrc_gNB_ue_context_t      *ue_context_pP);

openair2/RRC/NR/rrc_gNB_NGAP.c

@@ -1058,8 +1058,9 @@ rrc_gNB_process_NGAP_PDUSESSION_SETUP_REQ(
     ue_context_p->ue_context.setup_pdu_sessions += nb_pdusessions_tosetup;
 
     // TEST 
-    ue_context_p->ue_context.pdusession[0].status = PDU_SESSION_STATUS_DONE;
-    rrc_gNB_send_NGAP_PDUSESSION_SETUP_RESP(&ctxt, ue_context_p, 0);
+    // ue_context_p->ue_context.pdusession[0].status = PDU_SESSION_STATUS_DONE;
+    // rrc_gNB_send_NGAP_PDUSESSION_SETUP_RESP(&ctxt, ue_context_p, 0);
+    rrc_gNB_generate_dedicatedRRCReconfiguration(&ctxt, ue_context_p);
     return(0);
   }
 }