Merge remote-tracking branch...

Merge remote-tracking branch 'origin/nr-rrcreestablishment-fix-multipdu-proper-commits' into integration_2023_w14

openair2/RRC/NR/nr_rrc_defs.h

@@ -271,6 +271,40 @@ typedef struct pdu_session_param_s {
   uint8_t cause_value;
 } rrc_pdu_session_param_t;
 
+typedef struct drb_s {
+  int status;
+  int defaultDRBid;
+  int drb_id;
+  int reestablishPDCP;
+  int recoverPDCP;
+  int daps_Config_r16;
+  struct cnAssociation_s {
+    int present;
+    int eps_BearerIdentity;
+    struct sdap_config_s {
+      bool defaultDRB;
+      int pdusession_id;
+      int sdap_HeaderDL;
+      int sdap_HeaderUL;
+      int mappedQoS_FlowsToAdd[QOSFLOW_MAX_VALUE];
+    } sdap_config;
+  } cnAssociation;
+  struct pdcp_config_s {
+    int discardTimer;
+    int pdcp_SN_SizeUL;
+    int pdcp_SN_SizeDL;
+    int t_Reordering;
+    int integrityProtection;
+    struct headerCompression_s {
+      int NotUsed;
+      int present;
+    } headerCompression;
+    struct ext1_s {
+      int cipheringDisabled;
+    } ext1;
+  } pdcp_config;
+} drb_t;
+
 typedef struct gNB_RRC_UE_s {
   uint8_t                            primaryCC_id;
   NR_SRB_ToAddModList_t             *SRB_configList;
@@ -278,6 +312,7 @@ typedef struct gNB_RRC_UE_s {
   NR_DRB_ToAddModList_t             *DRB_configList;
   NR_DRB_ToAddModList_t             *DRB_configList2[NR_RRC_TRANSACTION_IDENTIFIER_NUMBER];
   NR_DRB_ToReleaseList_t            *DRB_Release_configList2[NR_RRC_TRANSACTION_IDENTIFIER_NUMBER];
+  drb_t                              established_drbs[NGAP_MAX_DRBS_PER_UE];
   uint8_t                            DRB_active[NGAP_MAX_DRBS_PER_UE];
 
   NR_SRB_INFO_TABLE_ENTRY Srb[maxSRBs]; // 3gpp max is 3 SRBs, number 1..3, we waste the entry 0 for code simplicity

openair2/RRC/NR/rrc_gNB_radio_bearers.c

@@ -36,65 +36,109 @@ rrc_pdu_session_param_t *find_pduSession(gNB_RRC_UE_t *ue, int id, bool create)
   return ue->pduSession + j;
 }
 
-NR_DRB_ToAddMod_t *generateDRB(gNB_RRC_UE_t *ue, uint8_t drb_id, rrc_pdu_session_param_t *pduSession, bool enable_sdap, int do_drb_integrity, int do_drb_ciphering)
+void generateDRB(gNB_RRC_UE_t *ue,
+                 uint8_t drb_id,
+                 rrc_pdu_session_param_t *pduSession,
+                 bool enable_sdap,
+                 int do_drb_integrity,
+                 int do_drb_ciphering)
 {
-  NR_DRB_ToAddMod_t *DRB_config = CALLOC(1, sizeof(*DRB_config));
-  DRB_config->drb_Identity = drb_id;
-  asn1cCalloc(DRB_config->cnAssociation, association);
-  association->present = NR_DRB_ToAddMod__cnAssociation_PR_sdap_Config;
-
+  int i;
+  int qos_flow_index;
+  drb_t *est_drb = &ue->established_drbs[drb_id - 1];
+  if (est_drb->status == DRB_INACTIVE) {
+    /* DRB Management */
+    est_drb->drb_id = drb_id;
+    est_drb->reestablishPDCP = -1;
+    est_drb->recoverPDCP = -1;
+    for (i = 0; i < NGAP_MAX_DRBS_PER_UE; i++) {
+      if ((est_drb->cnAssociation.sdap_config.pdusession_id == 0
+           || est_drb->cnAssociation.sdap_config.pdusession_id == pduSession->param.pdusession_id)
+          && est_drb->defaultDRBid == 0) {
+        est_drb->cnAssociation.sdap_config.defaultDRB = true;
+        est_drb->defaultDRBid = drb_id;
+      }
+    }
     /* SDAP Configuration */
-  NR_SDAP_Config_t *SDAP_config = CALLOC(1, sizeof(NR_SDAP_Config_t));
-  asn1cCalloc(SDAP_config->mappedQoS_FlowsToAdd, sdapFlows);
-
-  SDAP_config->pdu_Session = pduSession->param.pdusession_id;
-  
+    est_drb->cnAssociation.present = NR_DRB_ToAddMod__cnAssociation_PR_sdap_Config;
+    est_drb->cnAssociation.sdap_config.pdusession_id = pduSession->param.pdusession_id;
     if (enable_sdap) {
-    SDAP_config->sdap_HeaderDL = NR_SDAP_Config__sdap_HeaderDL_present;
-    SDAP_config->sdap_HeaderUL = NR_SDAP_Config__sdap_HeaderUL_present;
+      est_drb->cnAssociation.sdap_config.sdap_HeaderDL = NR_SDAP_Config__sdap_HeaderDL_present;
+      est_drb->cnAssociation.sdap_config.sdap_HeaderUL = NR_SDAP_Config__sdap_HeaderUL_present;
     } else {
-    SDAP_config->sdap_HeaderDL = NR_SDAP_Config__sdap_HeaderDL_absent;
-    SDAP_config->sdap_HeaderUL = NR_SDAP_Config__sdap_HeaderUL_absent;
+      est_drb->cnAssociation.sdap_config.sdap_HeaderDL = NR_SDAP_Config__sdap_HeaderDL_absent;
+      est_drb->cnAssociation.sdap_config.sdap_HeaderUL = NR_SDAP_Config__sdap_HeaderUL_absent;
     }
-  
-  SDAP_config->defaultDRB = true;
-  
-  for (int qos_flow_index = 0; qos_flow_index < pduSession->param.nb_qos; qos_flow_index++) 
-  {
-    asn1cSequenceAdd(sdapFlows->list, NR_QFI_t, qfi);
-    *qfi = pduSession->param.qos[qos_flow_index].qfi;
-    if(pduSession->param.qos[qos_flow_index].fiveQI > 5)
-      pduSession->param.used_drbs[drb_id - 1] = DRB_ACTIVE_NONGBR;
+    for (qos_flow_index = 0; qos_flow_index < pduSession->param.nb_qos; qos_flow_index++) {
+      est_drb->cnAssociation.sdap_config.mappedQoS_FlowsToAdd[qos_flow_index] = pduSession->param.qos[qos_flow_index].qfi;
+      if (pduSession->param.qos[qos_flow_index].fiveQI > 5)
+        est_drb->status = DRB_ACTIVE_NONGBR;
+      else
+        est_drb->status = DRB_ACTIVE;
+    }
+    /* PDCP Configuration */
+    est_drb->pdcp_config.discardTimer = NR_PDCP_Config__drb__discardTimer_infinity;
+    est_drb->pdcp_config.pdcp_SN_SizeDL = NR_PDCP_Config__drb__pdcp_SN_SizeDL_len18bits;
+    est_drb->pdcp_config.pdcp_SN_SizeUL = NR_PDCP_Config__drb__pdcp_SN_SizeUL_len18bits;
+    est_drb->pdcp_config.t_Reordering = NR_PDCP_Config__t_Reordering_ms100;
+    est_drb->pdcp_config.headerCompression.present = NR_PDCP_Config__drb__headerCompression_PR_notUsed;
+    est_drb->pdcp_config.headerCompression.NotUsed = 0;
+    if (do_drb_integrity)
+      est_drb->pdcp_config.integrityProtection = NR_PDCP_Config__drb__integrityProtection_enabled;
     else
-      pduSession->param.used_drbs[drb_id - 1] = DRB_ACTIVE;
+      est_drb->pdcp_config.integrityProtection = 1;
+    if (do_drb_ciphering)
+      est_drb->pdcp_config.ext1.cipheringDisabled = 1;
+    else
+      est_drb->pdcp_config.ext1.cipheringDisabled = NR_PDCP_Config__ext1__cipheringDisabled_true;
   }
+}
 
-  association->choice.sdap_Config = SDAP_config;
+NR_DRB_ToAddMod_t *generateDRB_ASN1(const drb_t *drb_asn1)
+{
+  NR_DRB_ToAddMod_t *DRB_config = CALLOC(1, sizeof(*DRB_config));
+  NR_SDAP_Config_t *SDAP_config = CALLOC(1, sizeof(NR_SDAP_Config_t));
 
-  /* PDCP Configuration */
+  asn1cCalloc(DRB_config->cnAssociation, association);
+  asn1cCalloc(SDAP_config->mappedQoS_FlowsToAdd, sdapFlows);
   asn1cCalloc(DRB_config->pdcp_Config, pdcpConfig);
   asn1cCalloc(pdcpConfig->drb, drb);
 
-  asn1cCallocOne(drb->discardTimer, NR_PDCP_Config__drb__discardTimer_infinity);
+  DRB_config->drb_Identity = drb_asn1->drb_id;
+  association->present = drb_asn1->cnAssociation.present;
+
+  /* SDAP Configuration */
+  SDAP_config->pdu_Session = drb_asn1->cnAssociation.sdap_config.pdusession_id;
+  SDAP_config->sdap_HeaderDL = drb_asn1->cnAssociation.sdap_config.sdap_HeaderDL;
+  SDAP_config->sdap_HeaderUL = drb_asn1->cnAssociation.sdap_config.sdap_HeaderUL;
+  SDAP_config->defaultDRB = drb_asn1->cnAssociation.sdap_config.defaultDRB;
+
+  for (int qos_flow_index = 0; qos_flow_index < QOSFLOW_MAX_VALUE; qos_flow_index++) {
+    if (drb_asn1->cnAssociation.sdap_config.mappedQoS_FlowsToAdd[qos_flow_index] != 0) {
+      asn1cSequenceAdd(sdapFlows->list, NR_QFI_t, qfi);
+      *qfi = drb_asn1->cnAssociation.sdap_config.mappedQoS_FlowsToAdd[qos_flow_index];
+    }
+  }
 
-  asn1cCallocOne(drb->pdcp_SN_SizeUL, NR_PDCP_Config__drb__pdcp_SN_SizeUL_len18bits);
-  asn1cCallocOne(drb->pdcp_SN_SizeDL, NR_PDCP_Config__drb__pdcp_SN_SizeDL_len18bits);
+  association->choice.sdap_Config = SDAP_config;
 
-  drb->headerCompression.present = NR_PDCP_Config__drb__headerCompression_PR_notUsed;
-  drb->headerCompression.choice.notUsed = 0;
+  /* PDCP Configuration */
+  asn1cCallocOne(drb->discardTimer, drb_asn1->pdcp_config.discardTimer);
+  asn1cCallocOne(drb->pdcp_SN_SizeUL, drb_asn1->pdcp_config.pdcp_SN_SizeUL);
+  asn1cCallocOne(drb->pdcp_SN_SizeDL, drb_asn1->pdcp_config.pdcp_SN_SizeDL);
+  asn1cCallocOne(pdcpConfig->t_Reordering, drb_asn1->pdcp_config.t_Reordering);
 
-  asn1cCallocOne(pdcpConfig->t_Reordering, NR_PDCP_Config__t_Reordering_ms100);
+  drb->headerCompression.present = drb_asn1->pdcp_config.headerCompression.present;
+  drb->headerCompression.choice.notUsed = drb_asn1->pdcp_config.headerCompression.NotUsed;
 
-  if (do_drb_integrity) {
-    asn1cCallocOne(drb->integrityProtection, NR_PDCP_Config__drb__integrityProtection_enabled);
+  if (!drb_asn1->pdcp_config.integrityProtection) {
+    asn1cCallocOne(drb->integrityProtection, drb_asn1->pdcp_config.integrityProtection);
   }
-  if (!do_drb_ciphering) {
+  if (!drb_asn1->pdcp_config.ext1.cipheringDisabled) {
     asn1cCalloc(pdcpConfig->ext1, ext1);
-    asn1cCallocOne(ext1->cipheringDisabled, NR_PDCP_Config__ext1__cipheringDisabled_true);
+    asn1cCallocOne(ext1->cipheringDisabled, drb_asn1->pdcp_config.ext1.cipheringDisabled);
   }
 
-  ue->DRB_active[drb_id-1] = DRB_ACTIVE;
-
   return DRB_config;
 }
 

openair2/RRC/NR/rrc_gNB_radio_bearers.h

@@ -35,7 +35,24 @@
 #define GBR_FLOW                (1)
 #define NONGBR_FLOW             (0)
 
-NR_DRB_ToAddMod_t *generateDRB(gNB_RRC_UE_t *rrc_ue, uint8_t drb_id, rrc_pdu_session_param_t *pduSession, bool enable_sdap, int do_drb_integrity, int do_drb_ciphering);
+/// @brief Generates an ASN1 DRB-ToAddMod, from the established_drbs in gNB_RRC_UE_t.
+/// @param drb_t drb_asn1
+/// @return Returns the ASN1 DRB-ToAddMod structs.
+NR_DRB_ToAddMod_t *generateDRB_ASN1(const drb_t *drb_asn1);
+/// @brief Creates and stores a DRB in the gNB_RRC_UE_t struct, it doesn't create the actual entity,
+/// to create the actual entity use the generateDRB_ASN1.
+/// @param ue The gNB_RRC_UE_t struct that holds information for the UEs
+/// @param drb_id The Data Radio Bearer Identity to be created for the established DRB.
+/// @param pduSession The PDU Session that the DRB is created for.
+/// @param enable_sdap If true the SDAP header will be added to the packet, else it will not add or search for SDAP header.
+/// @param do_drb_integrity
+/// @param do_drb_ciphering
+void generateDRB(gNB_RRC_UE_t *ue,
+                 uint8_t drb_id,
+                 rrc_pdu_session_param_t *pduSession,
+                 bool enable_sdap,
+                 int do_drb_integrity,
+                 int do_drb_ciphering);
 uint8_t next_available_drb(gNB_RRC_UE_t *ue, rrc_pdu_session_param_t *pdusession, bool is_gbr);
 bool drb_is_active(gNB_RRC_UE_t *ue, uint8_t drb_id);