Merge remote-tracking branch 'origin/develop' into enhancement-16-tm_rrc_reconfig

Conflicts:
	openair2/RRC/LITE/rrc_eNB.c
	targets/PROJECTS/GENERIC-LTE-EPC/CONF/enb.band7.tm1.usrpb210.conf

cmake_targets/CMakeLists.txt

@@ -42,6 +42,7 @@ set (OPENAIR_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY})
 
 project (OpenAirInterface)
 
+#add_definitions("-DEMIT_ASN_DEBUG=1")
 add_subdirectory(${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lms7002m lms7002m)
 add_subdirectory(${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lmsSDR lmsSDR)
 add_subdirectory(${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/Si5351C Si5351C)

cmake_targets/tools/run_enb_ue_virt_s1

@@ -257,6 +257,9 @@ function main()
   ip rule add fwmark 1 table lte 
   ifconfig oip1 up
   ip route add default dev oip1 table lte
+  # the actual IP address depends on the EPC/MME config file for address pool
+  ip route add from 192.188.0.0/24 table lte
+  ip route add to 192.188.0.0/24 table lte
 
   exe_arguments="$exe_arguments -s15 -AAWGN -y1 -b1 -u1 -Q0"
     

maketags

 #!/bin/sh
 echo "building ctags for openair1 and openair2 ..."
-ctags -e -R  --exclude=openair1/DOCS/ --exclude=openair2/DOCS/ --exclude=openair2/RRC/CELLULAR/ --exclude=openair2/NAS/DRIVER/CELLULAR/ --exclude=openair2/SIMULATION/ --exclude=targets/DOCS/ --exclude=targets/PROJECTS/ openair1 openair2 targets
+ctags -e -R  --exclude=openair1/DOCS/ --exclude=openair2/DOCS/ --exclude=openair2/RRC/CELLULAR/ --exclude=openair2/NAS/DRIVER/CELLULAR/ --exclude=openair2/SIMULATION/ --exclude=targets/DOCS/ --exclude=targets/PROJECTS/ openair1 openair2 openair3 targets cmake_targets common

openair2/COMMON/platform_types.h

@@ -215,6 +215,7 @@ typedef struct protocol_ctxt_s {
   frame_t     frame;         /*!< \brief  LTE frame number.*/
   sub_frame_t subframe;      /*!< \brief  LTE sub frame number.*/
   eNB_index_t eNB_index;     /*!< \brief  valid for UE indicating the index of connected eNB(s)      */
+  boolean_t   configured;  /*!< \brief  flag indicating whether the instance is configured or not  */
 } protocol_ctxt_t;
 // warning time hardcoded
 #define PROTOCOL_CTXT_TIME_MILLI_SECONDS(CtXt_h) ((CtXt_h)->frame*10+(CtXt_h)->subframe)

openair2/COMMON/s1ap_messages_def.h

@@ -39,6 +39,8 @@ MESSAGE_DEF(S1AP_UE_CONTEXT_RELEASE_REQ_LOG, MESSAGE_PRIORITY_MED, IttiMsgText
 MESSAGE_DEF(S1AP_UE_CONTEXT_RELEASE_COMMAND_LOG, MESSAGE_PRIORITY_MED, IttiMsgText                  , s1ap_ue_context_release_command_log)
 MESSAGE_DEF(S1AP_UE_CONTEXT_RELEASE_COMPLETE_LOG, MESSAGE_PRIORITY_MED, IttiMsgText                 , s1ap_ue_context_release_complete_log)
 MESSAGE_DEF(S1AP_UE_CONTEXT_RELEASE_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , s1ap_ue_context_release_log)
+MESSAGE_DEF(S1AP_E_RAB_SETUP_REQUEST_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , s1ap_e_rab_setup_request_log)
+MESSAGE_DEF(S1AP_E_RAB_SETUP_RESPONSE_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , s1ap_e_rab_setup_response_log)
 
 /* eNB application layer -> S1AP messages */
 MESSAGE_DEF(S1AP_REGISTER_ENB_REQ          , MESSAGE_PRIORITY_MED, s1ap_register_enb_req_t          , s1ap_register_enb_req)
@@ -58,12 +60,15 @@ MESSAGE_DEF(S1AP_UE_CONTEXT_RELEASE_RESP   , MESSAGE_PRIORITY_MED, s1ap_ue_relea
 MESSAGE_DEF(S1AP_UE_CONTEXT_RELEASE_COMPLETE, MESSAGE_PRIORITY_MED, s1ap_ue_release_complete_t      , s1ap_ue_release_complete)
 MESSAGE_DEF(S1AP_UE_CTXT_MODIFICATION_RESP , MESSAGE_PRIORITY_MED, s1ap_ue_ctxt_modification_resp_t , s1ap_ue_ctxt_modification_resp)
 MESSAGE_DEF(S1AP_UE_CTXT_MODIFICATION_FAIL , MESSAGE_PRIORITY_MED, s1ap_ue_ctxt_modification_fail_t , s1ap_ue_ctxt_modification_fail)
+MESSAGE_DEF(S1AP_E_RAB_SETUP_RESP          , MESSAGE_PRIORITY_MED, s1ap_e_rab_setup_resp_t          , s1ap_e_rab_setup_resp)
+MESSAGE_DEF(S1AP_E_RAB_SETUP_REQUEST_FAIL  , MESSAGE_PRIORITY_MED, s1ap_e_rab_setup_req_fail_t      , s1ap_e_rab_setup_request_fail)
 
 /* S1AP -> RRC messages */
 MESSAGE_DEF(S1AP_DOWNLINK_NAS              , MESSAGE_PRIORITY_MED, s1ap_downlink_nas_t              , s1ap_downlink_nas )
 MESSAGE_DEF(S1AP_INITIAL_CONTEXT_SETUP_REQ , MESSAGE_PRIORITY_MED, s1ap_initial_context_setup_req_t , s1ap_initial_context_setup_req )
 MESSAGE_DEF(S1AP_UE_CTXT_MODIFICATION_REQ  , MESSAGE_PRIORITY_MED, s1ap_ue_ctxt_modification_req_t  , s1ap_ue_ctxt_modification_req)
 MESSAGE_DEF(S1AP_PAGING_IND                , MESSAGE_PRIORITY_MED, s1ap_paging_ind_t                , s1ap_paging_ind )
+MESSAGE_DEF(S1AP_E_RAB_SETUP_REQ            , MESSAGE_PRIORITY_MED, s1ap_e_rab_setup_req_t        , s1ap_e_rab_setup_req )
 MESSAGE_DEF(S1AP_UE_CONTEXT_RELEASE_COMMAND, MESSAGE_PRIORITY_MED, s1ap_ue_release_command_t        , s1ap_ue_release_command)
 
 /* S1AP <-> RRC messages (can be initiated either by MME or eNB) */

openair2/COMMON/s1ap_messages_types.h

@@ -47,12 +47,15 @@
 #define S1AP_NAS_NON_DELIVERY_IND(mSGpTR)       (mSGpTR)->ittiMsg.s1ap_nas_non_delivery_ind
 #define S1AP_UE_CTXT_MODIFICATION_RESP(mSGpTR)  (mSGpTR)->ittiMsg.s1ap_ue_ctxt_modification_resp
 #define S1AP_UE_CTXT_MODIFICATION_FAIL(mSGpTR)  (mSGpTR)->ittiMsg.s1ap_ue_ctxt_modification_fail
+#define S1AP_E_RAB_SETUP_RESP(mSGpTR)           (mSGpTR)->ittiMsg.s1ap_e_rab_setup_resp
+#define S1AP_E_RAB_SETUP_FAIL(mSGpTR)           (mSGpTR)->ittiMsg.s1ap_e_rab_setup_req_fail
 
 #define S1AP_DOWNLINK_NAS(mSGpTR)               (mSGpTR)->ittiMsg.s1ap_downlink_nas
 #define S1AP_INITIAL_CONTEXT_SETUP_REQ(mSGpTR)  (mSGpTR)->ittiMsg.s1ap_initial_context_setup_req
 #define S1AP_UE_CTXT_MODIFICATION_REQ(mSGpTR)   (mSGpTR)->ittiMsg.s1ap_ue_ctxt_modification_req
 #define S1AP_UE_CONTEXT_RELEASE_COMMAND(mSGpTR) (mSGpTR)->ittiMsg.s1ap_ue_release_command
 #define S1AP_UE_CONTEXT_RELEASE_COMPLETE(mSGpTR) (mSGpTR)->ittiMsg.s1ap_ue_release_complete
+#define S1AP_E_RAB_SETUP_REQ(mSGpTR)              (mSGpTR)->ittiMsg.s1ap_e_rab_setup_req
 #define S1AP_PAGIND_IND(mSGpTR)                 (mSGpTR)->ittiMsg.s1ap_paging_ind
 
 #define S1AP_UE_CONTEXT_RELEASE_REQ(mSGpTR)     (mSGpTR)->ittiMsg.s1ap_ue_release_req
@@ -390,7 +393,7 @@ typedef struct s1ap_initial_context_setup_fail_s {
   unsigned  eNB_ue_s1ap_id:24;
 
   /* TODO add cause */
-} s1ap_initial_context_setup_fail_t, s1ap_ue_ctxt_modification_fail_t;
+} s1ap_initial_context_setup_fail_t, s1ap_ue_ctxt_modification_fail_t, s1ap_e_rab_setup_req_fail_t;
 
 typedef struct s1ap_nas_non_delivery_ind_s {
   unsigned  eNB_ue_s1ap_id:24;
@@ -439,6 +442,7 @@ typedef struct s1ap_downlink_nas_s {
   nas_pdu_t nas_pdu;
 } s1ap_downlink_nas_t;
 
+
 typedef struct s1ap_initial_context_setup_req_s {
   /* UE id for initial connection to S1AP */
   uint16_t ue_initial_id;
@@ -479,6 +483,39 @@ typedef struct s1ap_paging_ind_s {
   paging_priority_t paging_priority;
 } s1ap_paging_ind_t;
 
+typedef struct s1ap_e_rab_setup_req_s {
+  /* UE id for initial connection to S1AP */
+  uint16_t ue_initial_id;
+
+  /* MME UE id  */
+  uint16_t mme_ue_s1ap_id;
+
+  /* eNB ue s1ap id as initialized by S1AP layer */
+  unsigned eNB_ue_s1ap_id:24;
+
+  /* Number of e_rab to be setup in the list */
+  uint8_t nb_e_rabs_tosetup;
+
+  /* E RAB setup request */
+  e_rab_t e_rab_setup_params[S1AP_MAX_E_RAB];
+
+} s1ap_e_rab_setup_req_t;
+
+typedef struct s1ap_e_rab_setup_resp_s {
+  unsigned  eNB_ue_s1ap_id:24;
+
+  /* Number of e_rab setup-ed in the list */
+  uint8_t       nb_of_e_rabs;
+  /* list of e_rab setup-ed by RRC layers */
+  e_rab_setup_t e_rabs[S1AP_MAX_E_RAB];
+
+  /* Number of e_rab failed to be setup in list */
+  uint8_t        nb_of_e_rabs_failed;
+  /* list of e_rabs that failed to be setup */
+  e_rab_failed_t e_rabs_failed[S1AP_MAX_E_RAB];
+} s1ap_e_rab_setup_resp_t;
+
+
 // S1AP --> RRC messages
 typedef struct s1ap_ue_release_command_s {
 

openair2/ENB_APP/enb_app.c

@@ -258,6 +258,8 @@ static uint32_t eNB_app_register(uint32_t enb_id_start, uint32_t enb_id_end, con
       str = inet_ntoa(addr);
       strcpy(s1ap_register_eNB->enb_ip_address.ipv4_address, str);
 
+      LOG_I(ENB_APP,"[eNB %d] eNB_app_register for instance %d\n", enb_id, ENB_MODULE_ID_TO_INSTANCE(enb_id));
+
       itti_send_msg_to_task (TASK_S1AP, ENB_MODULE_ID_TO_INSTANCE(enb_id), msg_p);
 
       register_enb_pending++;

openair2/LAYER2/MAC/defs.h

@@ -900,7 +900,7 @@ typedef struct {
   /// CCE table used to build DCI scheduling information
   int CCE_table[MAX_NUM_CCs][800];
   ///  active flag for Other lcid
-  //  uint8_t lcid_active[NB_RB_MAX];
+  uint8_t lcid_active[NB_RB_MAX];
   /// eNB stats
   eNB_STATS eNB_stats[MAX_NUM_CCs];
   // MAC function execution peformance profiler

openair2/LAYER2/MAC/eNB_scheduler_dlsch.c

@@ -434,10 +434,12 @@ schedule_ue_spec(
   int                   N_RBG[MAX_NUM_CCs];
   unsigned char         aggregation;
   mac_rlc_status_resp_t rlc_status;
-  unsigned char         header_len_dcch=0, header_len_dcch_tmp=0,header_len_dtch=0,header_len_dtch_tmp=0, ta_len=0;
-  unsigned char         sdu_lcids[11],offset,num_sdus=0;
+  unsigned char         header_len_dcch=0, header_len_dcch_tmp=0, header_len_dcch_last=0; 
+  unsigned char         header_len_dtch=0, header_len_dtch_tmp=0, header_len_dtch_last=0; 
+  unsigned char         ta_len=0;
+  unsigned char         sdu_lcids[NB_RB_MAX],lcid,offset,num_sdus=0;
   uint16_t              nb_rb,nb_rb_temp,total_nb_available_rb[MAX_NUM_CCs],nb_available_rb;
-  uint16_t              TBS,j,sdu_lengths[11],rnti,padding=0,post_padding=0;
+  uint16_t              TBS,j,sdu_lengths[NB_RB_MAX],rnti,padding=0,post_padding=0;
   unsigned char         dlsch_buffer[MAX_DLSCH_PAYLOAD_BYTES];
   unsigned char         round            = 0;
   unsigned char         harq_pid         = 0;
@@ -883,7 +885,7 @@ schedule_ue_spec(
                                        ENB_FLAG_YES,
                                        MBMS_FLAG_NO,
                                        DCCH+1,
-                                       (char *)&dlsch_buffer[sdu_lengths[0]]);
+                                       (char *)&dlsch_buffer[sdu_lengths[num_sdus]]);
 
             T(T_ENB_MAC_UE_DL_SDU, T_INT(module_idP), T_INT(CC_id), T_INT(rnti), T_INT(frameP), T_INT(subframeP),
               T_INT(harq_pid), T_INT(DCCH+1), T_INT(sdu_lengths[num_sdus]));
@@ -893,80 +895,96 @@ schedule_ue_spec(
             header_len_dcch += 2;
             UE_list->eNB_UE_stats[CC_id][UE_id].num_pdu_tx[DCCH1]+=1;
             UE_list->eNB_UE_stats[CC_id][UE_id].num_bytes_tx[DCCH1]+=sdu_lengths[num_sdus];
-            num_sdus++;
-            LOG_D(MAC,"[eNB %d] CC_id %d Got %d bytes for DCCH from RLC\n",module_idP,CC_id,sdu_lengths[0]);
-          }
-        }
-
-        // check for DTCH and update header information
-        // here we should loop over all possible DTCH
-
-        header_len_dtch = 3; // 3 bytes DTCH SDU subheader
-
-        LOG_D(MAC,"[eNB %d], Frame %d, DTCH->DLSCH, CC_id %d, Checking RLC status (rab %d, tbs %d, len %d)\n",
-              module_idP,frameP,CC_id,DTCH,TBS,
-              TBS-ta_len-header_len_dcch-sdu_length_total-header_len_dtch);
-
-        if (TBS-ta_len-header_len_dcch-sdu_length_total-header_len_dtch > 0 ) {
-          rlc_status = mac_rlc_status_ind(
-                         module_idP,
-                         rnti,
-			 module_idP,
-                         frameP,
-                         ENB_FLAG_YES,
-                         MBMS_FLAG_NO,
-                         DTCH,
-                         TBS-ta_len-header_len_dcch-sdu_length_total-header_len_dtch);
-
-          if (rlc_status.bytes_in_buffer > 0) {
-
-            LOG_D(MAC,"[eNB %d][USER-PLANE DEFAULT DRB], Frame %d, DTCH->DLSCH, CC_id %d, Requesting %d bytes from RLC (hdr len dtch %d)\n",
-                  module_idP,frameP,CC_id,TBS-header_len_dcch-sdu_length_total-header_len_dtch,header_len_dtch);
-            sdu_lengths[num_sdus] = mac_rlc_data_req(
-                                      module_idP,
-                                      rnti,
-				      module_idP,
-                                      frameP,
-                                      ENB_FLAG_YES,
-                                      MBMS_FLAG_NO,
-                                      DTCH,
-                                      (char*)&dlsch_buffer[sdu_length_total]);
-
-            T(T_ENB_MAC_UE_DL_SDU, T_INT(module_idP), T_INT(CC_id), T_INT(rnti), T_INT(frameP), T_INT(subframeP),
-              T_INT(harq_pid), T_INT(DTCH), T_INT(sdu_lengths[num_sdus]));
-
-            LOG_D(MAC,"[eNB %d][USER-PLANE DEFAULT DRB] CC_id %d Got %d bytes for DTCH %d \n",
-                  module_idP,CC_id,sdu_lengths[num_sdus],DTCH);
-            sdu_lcids[num_sdus] = DTCH;
-            sdu_length_total += sdu_lengths[num_sdus];
-            UE_list->eNB_UE_stats[CC_id][UE_id].num_pdu_tx[DTCH]+=1;
-            UE_list->eNB_UE_stats[CC_id][UE_id].num_bytes_tx[DTCH]+=sdu_lengths[num_sdus];
+	    num_sdus++;
+#ifdef DEBUG_eNB_SCHEDULER
+            LOG_T(MAC,"[eNB %d][DCCH1] CC_id %d Got %d bytes :",module_idP,CC_id,sdu_lengths[num_sdus]);
 
-            if (sdu_lengths[num_sdus] < 128) {
-              header_len_dtch=2;
+            for (j=0; j<sdu_lengths[num_sdus]; j++) {
+              LOG_T(MAC,"%x ",dlsch_buffer[j]);
             }
 
-            num_sdus++;
-          } else {
-            header_len_dtch = 0;
-          }
-        }
-
-        // there is a payload
-        if (((sdu_length_total + header_len_dcch + header_len_dtch )> 0)) {
-
-          // Now compute number of required RBs for total sdu length
-          // Assume RAH format 2
-          // adjust  header lengths
-          header_len_dcch_tmp = header_len_dcch;
-          header_len_dtch_tmp = header_len_dtch;
+            LOG_T(MAC,"\n");
+#endif
 
-          if (header_len_dtch==0) {
-            header_len_dcch = (header_len_dcch >0) ? 1 : header_len_dcch;  // remove length field
-          } else {
-            header_len_dtch = (header_len_dtch > 0) ? 1 :header_len_dtch;     // remove length field for the last SDU
-          }
+	  }
+        }
 
+	// assume the max dtch header size, and adjust it later
+	header_len_dtch=0;
+	header_len_dtch_last=0; // the header length of the last mac sdu
+	// lcid has to be sorted before the actual allocation (similar struct as ue_list).
+	for (lcid=NB_RB_MAX-1; lcid>=DTCH ; lcid--){
+	  // TBD: check if the lcid is active
+	  
+	  header_len_dtch+=3; 
+	  header_len_dtch_last=3;
+	  LOG_D(MAC,"[eNB %d], Frame %d, DTCH%d->DLSCH, Checking RLC status (tbs %d, len %d)\n",
+		module_idP,frameP,lcid,TBS,
+		TBS-ta_len-header_len_dcch-sdu_length_total-header_len_dtch);
+	  
+	  if (TBS-ta_len-header_len_dcch-sdu_length_total-header_len_dtch > 0 ) { // NN: > 2 ? 
+	    rlc_status = mac_rlc_status_ind(module_idP,
+					    rnti,
+					    module_idP,
+					    frameP,
+					    ENB_FLAG_YES,
+					    MBMS_FLAG_NO,
+					    lcid,
+					    TBS-ta_len-header_len_dcch-sdu_length_total-header_len_dtch);
+	   
+
+	    if (rlc_status.bytes_in_buffer > 0) {
+	      
+	      LOG_D(MAC,"[eNB %d][USER-PLANE DEFAULT DRB] Frame %d : DTCH->DLSCH, Requesting %d bytes from RLC (lcid %d total hdr len %d)\n",
+		    module_idP,frameP,TBS-header_len_dcch-sdu_length_total-header_len_dtch,lcid, header_len_dtch);
+	      sdu_lengths[num_sdus] = mac_rlc_data_req(module_idP,
+						       rnti,
+						       module_idP,
+						       frameP,
+						       ENB_FLAG_YES,
+						       MBMS_FLAG_NO,
+						       lcid,
+						       (char*)&dlsch_buffer[sdu_length_total]);
+	      T(T_ENB_MAC_UE_DL_SDU, T_INT(module_idP), T_INT(CC_id), T_INT(rnti), T_INT(frameP), T_INT(subframeP),
+              T_INT(harq_pid), T_INT(lcid), T_INT(sdu_lengths[num_sdus]));
+
+	      LOG_D(MAC,"[eNB %d][USER-PLANE DEFAULT DRB] Got %d bytes for DTCH %d \n",module_idP,sdu_lengths[num_sdus],lcid);
+	      sdu_lcids[num_sdus] = lcid;
+	      sdu_length_total += sdu_lengths[num_sdus];
+	      UE_list->eNB_UE_stats[CC_id][UE_id].num_pdu_tx[lcid]+=1;
+	      UE_list->eNB_UE_stats[CC_id][UE_id].num_bytes_tx[lcid]+=sdu_lengths[num_sdus];
+	      if (sdu_lengths[num_sdus] < 128) {
+		header_len_dtch--;
+		header_len_dtch_last--;
+	      }
+	      num_sdus++;
+	    } // no data for this LCID
+	    else {
+	      header_len_dtch-=3;
+	    }
+	  } // no TBS left
+	  else {
+	    header_len_dtch-=3;
+	    break; 
+	  }
+	}
+	if (header_len_dtch == 0 )
+	  header_len_dtch_last= 0;
+	// there is at least one SDU 
+	// if (num_sdus > 0 ){
+	if ((sdu_length_total + header_len_dcch + header_len_dtch )> 0) {
+	  
+	  // Now compute number of required RBs for total sdu length
+	  // Assume RAH format 2
+	  // adjust  header lengths
+	  header_len_dcch_tmp = header_len_dcch;
+	  header_len_dtch_tmp = header_len_dtch;
+	  if (header_len_dtch==0) {
+	    header_len_dcch = (header_len_dcch >0) ? 1 : 0;//header_len_dcch;  // remove length field
+	  } else {
+	    header_len_dtch_last-=1; // now use it to find how many bytes has to be removed for the last MAC SDU 
+	    header_len_dtch = (header_len_dtch > 0) ? header_len_dtch - header_len_dtch_last  :header_len_dtch;     // remove length field for the last SDU
+	  }
 
           mcs = eNB_UE_stats->dlsch_mcs1;
 
@@ -1080,8 +1098,7 @@ schedule_ue_spec(
                   "[eNB %d][DLSCH] Frame %d Generate header for UE_id %d on CC_id %d: sdu_length_total %d, num_sdus %d, sdu_lengths[0] %d, sdu_lcids[0] %d => payload offset %d,timing advance value : %d, padding %d,post_padding %d,(mcs %d, TBS %d, nb_rb %d),header_dcch %d, header_dtch %d\n",
                   module_idP,frameP, UE_id, CC_id, sdu_length_total,num_sdus,sdu_lengths[0],sdu_lcids[0],offset,
                   ue_sched_ctl->ta_update,padding,post_padding,mcs,TBS,nb_rb,header_len_dcch,header_len_dtch);
-          }
-
+	  }
           //#endif
 #ifdef DEBUG_eNB_SCHEDULER
           LOG_T(MAC,"[eNB %d] First 16 bytes of DLSCH : \n");

openair2/LAYER2/MAC/eNB_scheduler_ulsch.c

@@ -71,16 +71,15 @@
 // This table holds the allowable PRB sizes for ULSCH transmissions
 uint8_t rb_table[33] = {1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,27,30,32,36,40,45,48,50,54,60,72,75,80,81,90,96,100};
 
-void rx_sdu(
-  const module_id_t enb_mod_idP,
-  const int         CC_idP,
-  const frame_t     frameP,
-  const sub_frame_t subframeP,
-  const rnti_t      rntiP,
-  uint8_t          *sduP,
-  const uint16_t    sdu_lenP,
-  const int         harq_pidP,
-  uint8_t          *msg3_flagP)
+void rx_sdu(const module_id_t enb_mod_idP,
+	    const int         CC_idP,
+	    const frame_t     frameP,
+	    const sub_frame_t subframeP,
+	    const rnti_t      rntiP,
+	    uint8_t          *sduP,
+	    const uint16_t    sdu_lenP,
+	    const int         harq_pidP,
+	    uint8_t          *msg3_flagP)
 {
 
   unsigned char  rx_ces[MAX_NUM_CE],num_ce,num_sdu,i,*payload_ptr;
@@ -325,7 +324,6 @@ void rx_sdu(
               enb_mod_idP, CC_idP, frameP, rx_lengths[i], CCCH_PAYLOAD_SIZE_MAX);
         break;
       }
-
       LOG_I(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d, Received CCCH:  %x.%x.%x.%x.%x.%x, Terminating RA procedure for UE rnti %x\n",
             enb_mod_idP,CC_idP,frameP,
             payload_ptr[0],payload_ptr[1],payload_ptr[2],payload_ptr[3],payload_ptr[4], payload_ptr[5], rntiP);
@@ -382,21 +380,19 @@ void rx_sdu(
 
         } // if process is active
       } // loop on RA processes
+      
+      break ;
 
-      break;
-
-    case  DCCH :
+    case DCCH :
     case DCCH1 :
       //      if(eNB_mac_inst[module_idP][CC_idP].Dcch_lchan[UE_id].Active==1){
       
 
 #if defined(ENABLE_MAC_PAYLOAD_DEBUG)
       LOG_T(MAC,"offset: %d\n",(unsigned char)((unsigned char*)payload_ptr-sduP));
-      
       for (j=0; j<32; j++) {
         LOG_T(MAC,"%x ",payload_ptr[j]);
       }
-
       LOG_T(MAC,"\n");
 #endif
 
@@ -425,67 +421,69 @@ void rx_sdu(
           UE_list->eNB_UE_stats[CC_idP][UE_id].num_pdu_rx[rx_lcids[i]]+=1;
           UE_list->eNB_UE_stats[CC_idP][UE_id].num_bytes_rx[rx_lcids[i]]+=rx_lengths[i];
       } /* UE_id != -1 */
-
-      //      }
+ 
+      // } 
       break;
 
-    case DTCH: // default DRB
-      //      if(eNB_mac_inst[module_idP][CC_idP].Dcch_lchan[UE_id].Active==1){
+      // all the DRBS
+    case DTCH:
+    default :
 
 #if defined(ENABLE_MAC_PAYLOAD_DEBUG)
       LOG_T(MAC,"offset: %d\n",(unsigned char)((unsigned char*)payload_ptr-sduP));
-
       for (j=0; j<32; j++) {
         LOG_T(MAC,"%x ",payload_ptr[j]);
       }
-
       LOG_T(MAC,"\n");
 #endif
+      if (rx_lcids[i]  < NB_RB_MAX ) {
+	LOG_D(MAC,"[eNB %d] CC_id %d Frame %d : ULSCH -> UL-DTCH, received %d bytes from UE %d for lcid %d\n",
+	      enb_mod_idP,CC_idP,frameP, rx_lengths[i], UE_id, rx_lcids[i]);
+	
+	if (UE_id != -1) {
+	  // adjust buffer occupancy of the correponding logical channel group
+	  LOG_D(MAC,"[eNB %d] CC_id %d Frame %d : ULSCH -> UL-DTCH, received %d bytes from UE %d for lcid %d, removing from LCGID %d, %d\n",
+		enb_mod_idP,CC_idP,frameP, rx_lengths[i], UE_id,rx_lcids[i],
+		UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]],
+		UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]]);
+	  
+	  if (UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]] >= rx_lengths[i])
+	    UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]] -= rx_lengths[i];
+	  else
+	    UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]] = 0;
+	  if ((rx_lengths[i] <SCH_PAYLOAD_SIZE_MAX) &&  (rx_lengths[i] > 0) ) {   // MAX SIZE OF transport block
+	    mac_rlc_data_ind(
+			     enb_mod_idP,
+			     rntiP,
+			     enb_mod_idP,
+			     frameP,
+			     ENB_FLAG_YES,
+			     MBMS_FLAG_NO,
+			     rx_lcids[i],
+			     (char *)payload_ptr,
+			     rx_lengths[i],
+			     1,
+			     NULL);//(unsigned int*)crc_status);
+	    
+	    UE_list->eNB_UE_stats[CC_idP][UE_id].num_pdu_rx[rx_lcids[i]]+=1;
+	    UE_list->eNB_UE_stats[CC_idP][UE_id].num_bytes_rx[rx_lcids[i]]+=rx_lengths[i];
+	  }
+	  else { /* rx_length[i] */
+	    UE_list->eNB_UE_stats[CC_idP][UE_id].num_errors_rx+=1;
+	    LOG_E(MAC,"[eNB %d] CC_id %d Frame %d : Max size of transport block reached LCID %d from UE %d ",
+		  enb_mod_idP, CC_idP, frameP, rx_lcids[i], UE_id);
+	  }
+	}    
+	else {/*(UE_id != -1*/ 
+	  UE_list->eNB_UE_stats[CC_idP][UE_id].num_errors_rx+=1;
+	  LOG_E(MAC,"[eNB %d] CC_id %d Frame %d : received unsupported or unknown LCID %d from UE %d ",
+		enb_mod_idP, CC_idP, frameP, rx_lcids[i], UE_id);
+	}
+      }
 
-      LOG_D(MAC,"[eNB %d] CC_id %d Frame %d : ULSCH -> UL-DTCH, received %d bytes from UE %d for lcid %d\n",
-            enb_mod_idP,CC_idP,frameP, rx_lengths[i], UE_id,rx_lcids[i]);
-
-      if (UE_id != -1) {
-	// adjust buffer occupancy of the correponding logical channel group
-	LOG_D(MAC,"[eNB %d] CC_id %d Frame %d : ULSCH -> UL-DTCH, received %d bytes from UE %d for lcid %d, removing from LCGID %d, %d\n",
-	      enb_mod_idP,CC_idP,frameP, rx_lengths[i], UE_id,rx_lcids[i],
-	      UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]],
-	      UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]]);
-
-	if (UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]] >= rx_lengths[i])
-	  UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]] -= rx_lengths[i];
-	else
-	  UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]] = 0;
-
-        if ((rx_lengths[i] <SCH_PAYLOAD_SIZE_MAX) &&  (rx_lengths[i] > 0) ) {   // MAX SIZE OF transport block
-          mac_rlc_data_ind(
-            enb_mod_idP,
-            rntiP,
-            enb_mod_idP,
-            frameP,
-            ENB_FLAG_YES,
-            MBMS_FLAG_NO,
-            DTCH,
-            (char *)payload_ptr,
-            rx_lengths[i],
-            1,
-            NULL);//(unsigned int*)crc_status);
-          UE_list->eNB_UE_stats[CC_idP][UE_id].num_pdu_rx[rx_lcids[i]]+=1;
-          UE_list->eNB_UE_stats[CC_idP][UE_id].num_bytes_rx[rx_lcids[i]]+=rx_lengths[i];
-        }
-      } /* UE_id != -1 */
-
-      //      }
-      break;
-
-    default :  //if (rx_lcids[i] >= DTCH) {
-      if (UE_id != -1)
-        UE_list->eNB_UE_stats[CC_idP][UE_id].num_errors_rx+=1;
-      LOG_E(MAC,"[eNB %d] CC_id %d Frame %d : received unsupported or unknown LCID %d from UE %d ",
-            enb_mod_idP, CC_idP, frameP, rx_lcids[i], UE_id);
       break;
     }
-
+  
     payload_ptr+=rx_lengths[i];
   }
 

openair2/LAYER2/PDCP_v10.1.0/pdcp.c

@@ -29,8 +29,9 @@
 
 /*! \file pdcp.c
  * \brief pdcp interface with RLC
- * \author  Lionel GAUTHIER and Navid Nikaein
+ * \author Navid Nikaein and Lionel GAUTHIER
  * \date 2009-2012
+ * \email navid.nikaein@eurecom.fr
  * \version 1.0
  */
 
@@ -83,7 +84,7 @@ extern int otg_enabled;
  * code at targets/TEST/PDCP/test_pdcp.c:test_pdcp_data_req()
  */
 boolean_t pdcp_data_req(
-  const protocol_ctxt_t* const  ctxt_pP,
+  protocol_ctxt_t*  ctxt_pP,
   const srb_flag_t     srb_flagP,
   const rb_id_t        rb_idP,
   const mui_t          muiP,
@@ -105,7 +106,6 @@ boolean_t pdcp_data_req(
   rlc_op_status_t    rlc_status;
   boolean_t          ret             = TRUE;
 
-
   hash_key_t         key             = HASHTABLE_NOT_A_KEY_VALUE;
   hashtable_rc_t     h_rc;
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_REQ,VCD_FUNCTION_IN);
@@ -116,28 +116,6 @@ boolean_t pdcp_data_req(
     T(T_ENB_PDCP_DL, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->rnti), T_INT(rb_idP), T_INT(sdu_buffer_sizeP));
 #endif
 
-  if (modeP == PDCP_TRANSMISSION_MODE_TRANSPARENT) {
-    AssertError (rb_idP < NB_RB_MBMS_MAX, return FALSE, "RB id is too high (%u/%d) %u %u!\n", rb_idP, NB_RB_MBMS_MAX, ctxt_pP->module_id, ctxt_pP->rnti);
-  } else {
-    if (srb_flagP) {
-      AssertError (rb_idP < 2, return FALSE, "RB id is too high (%u/%d) %u %u!\n", rb_idP, 2, ctxt_pP->module_id, ctxt_pP->rnti);
-    } else {
-      AssertError (rb_idP < maxDRB, return FALSE, "RB id is too high (%u/%d) %u %u!\n", rb_idP, maxDRB, ctxt_pP->module_id, ctxt_pP->rnti);
-    }
-  }
-
-  key = PDCP_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
-  h_rc = hashtable_get(pdcp_coll_p, key, (void**)&pdcp_p);
-
-  if (h_rc != HASH_TABLE_OK) {
-    if (modeP != PDCP_TRANSMISSION_MODE_TRANSPARENT) {
-      LOG_W(PDCP, PROTOCOL_CTXT_FMT" Instance is not configured for rb_id %d Ignoring SDU...\n",
-            PROTOCOL_CTXT_ARGS(ctxt_pP),
-            rb_idP);
-    return FALSE;
-  }
-  }
-
   if (sdu_buffer_sizeP == 0) {
     LOG_W(PDCP, "Handed SDU is of size 0! Ignoring...\n");
     return FALSE;
@@ -153,14 +131,39 @@ boolean_t pdcp_data_req(
     // XXX What does following call do?
     mac_xface->macphy_exit("PDCP sdu buffer size > MAX_IP_PACKET_SIZE");
   }
+  
+  if (modeP == PDCP_TRANSMISSION_MODE_TRANSPARENT) {
+    AssertError (rb_idP < NB_RB_MBMS_MAX, return FALSE, "RB id is too high (%u/%d) %u %u!\n", rb_idP, NB_RB_MBMS_MAX, ctxt_pP->module_id, ctxt_pP->rnti);
+  } else {
+    if (srb_flagP) {
+      AssertError (rb_idP < 3, return FALSE, "RB id is too high (%u/%d) %u %u!\n", rb_idP, 3, ctxt_pP->module_id, ctxt_pP->rnti);
+    } else {
+      AssertError (rb_idP < maxDRB, return FALSE, "RB id is too high (%u/%d) %u %u!\n", rb_idP, maxDRB, ctxt_pP->module_id, ctxt_pP->rnti);
+    }
+  }
 
+  key = PDCP_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
+  h_rc = hashtable_get(pdcp_coll_p, key, (void**)&pdcp_p);
+
+  if (h_rc != HASH_TABLE_OK) {
+    if (modeP != PDCP_TRANSMISSION_MODE_TRANSPARENT) {
+      LOG_W(PDCP, PROTOCOL_CTXT_FMT" Instance is not configured for rb_id %d Ignoring SDU...\n",
+	    PROTOCOL_CTXT_ARGS(ctxt_pP),
+	    rb_idP);
+      ctxt_pP->configured=FALSE;
+      return FALSE;
+    }
+  }else{
+    // instance for a given RB is configured
+    ctxt_pP->configured=TRUE;
+  }
+    
   if (ctxt_pP->enb_flag == ENB_FLAG_NO) {
     start_meas(&eNB_pdcp_stats[ctxt_pP->module_id].data_req);
   } else {
     start_meas(&UE_pdcp_stats[ctxt_pP->module_id].data_req);
   }
 
-
   // PDCP transparent mode for MBMS traffic
 
   if (modeP == PDCP_TRANSMISSION_MODE_TRANSPARENT) {
@@ -916,7 +919,7 @@ pdcp_run (
           RRC_DCCH_DATA_REQ (msg_p).frame, 
 	  0,
 	  RRC_DCCH_DATA_REQ (msg_p).eNB_index);
-        LOG_D(PDCP, PROTOCOL_CTXT_FMT"Received %s from %s: instance %d, rb_id %d, muiP %d, confirmP %d, mode %d\n",
+        LOG_I(PDCP, PROTOCOL_CTXT_FMT"Received %s from %s: instance %d, rb_id %d, muiP %d, confirmP %d, mode %d\n",
               PROTOCOL_CTXT_ARGS(&ctxt),
               msg_name,
               ITTI_MSG_ORIGIN_NAME(msg_p),
@@ -1103,7 +1106,7 @@ rrc_pdcp_config_asn1_req (
       srb_id = srb2add_list_pP->list.array[cnt]->srb_Identity;
       srb_toaddmod_p = srb2add_list_pP->list.array[cnt];
       rlc_type = RLC_MODE_AM;
-      lc_id = srb_id + 2;
+      lc_id = srb_id;// + 2;
       key = PDCP_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, srb_id, SRB_FLAG_YES);
       h_rc = hashtable_get(pdcp_coll_p, key, (void**)&pdcp_p);
 
@@ -1439,13 +1442,14 @@ pdcp_config_req_asn1 (
     pdcp_pP->first_missing_pdu                = -1;
     pdcp_pP->rx_hfn_offset                    = 0;
 
-    LOG_D(PDCP, PROTOCOL_PDCP_CTXT_FMT" Action ADD  LCID %d (rb id %d) "
+    LOG_N(PDCP, PROTOCOL_PDCP_CTXT_FMT" Action ADD  LCID %d (%s id %d) "
             "configured with SN size %d bits and RLC %s\n",
           PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP,pdcp_pP),
           lc_idP,
+	  (srb_flagP == SRB_FLAG_YES) ? "SRB" : "DRB",
           rb_idP,
           pdcp_pP->seq_num_size,
-            (rlc_modeP == RLC_MODE_AM ) ? "AM" : (rlc_modeP == RLC_MODE_TM) ? "TM" : "UM");
+	  (rlc_modeP == RLC_MODE_AM ) ? "AM" : (rlc_modeP == RLC_MODE_TM) ? "TM" : "UM");
     /* Setup security */
     if (security_modeP != 0xff) {
       pdcp_config_set_security(
@@ -1487,8 +1491,8 @@ pdcp_config_req_asn1 (
       pdcp_pP->seq_num_size=5;
     }
 
-    LOG_D(PDCP,PROTOCOL_PDCP_CTXT_FMT" Action MODIFY LCID %d "
-            "RB id %d configured with SN size %d and RLC %s \n",
+    LOG_N(PDCP,PROTOCOL_PDCP_CTXT_FMT" Action MODIFY LCID %d "
+            "RB id %d reconfigured with SN size %d and RLC %s \n",
           PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP,pdcp_pP),
           lc_idP,
           rb_idP,

openair2/LAYER2/PDCP_v10.1.0/pdcp.h

@@ -221,7 +221,7 @@ typedef struct pdcp_mbms_s {
 * @ingroup _pdcp
 */
 public_pdcp(boolean_t pdcp_data_req(
-              const protocol_ctxt_t* const  ctxt_pP,
+              protocol_ctxt_t*  ctxt_pP,
               const srb_flag_t srb_flagP,
               const rb_id_t rb_id,
               const mui_t muiP,

openair2/LAYER2/PDCP_v10.1.0/pdcp_fifo.c

@@ -29,9 +29,10 @@
 
 /*! \file pdcp_fifo.c
  * \brief pdcp interface with linux IP interface, have a look at http://man7.org/linux/man-pages/man7/netlink.7.html for netlink
- * \author  Lionel GAUTHIER and Navid Nikaein
- * \date 2009
+ * \author  Navid Nikaein and Lionel GAUTHIER
+ * \date 2009 - 2016
  * \version 0.5
+ * \email navid.nikaein@eurecom.fr
  * \warning This component can be runned only in user-space
  * @ingroup pdcp
  */
@@ -484,7 +485,7 @@ int pdcp_fifo_read_input_sdus (const protocol_ctxt_t* const  ctxt_pP)
             ctxt.enb_flag      = ENB_FLAG_NO;
             ctxt.module_id     = pdcp_read_header_g.inst - oai_emulation.info.nb_enb_local + oai_emulation.info.first_ue_local;
             ctxt.rnti          = pdcp_UE_UE_module_id_to_rnti[ctxt.module_id];
-            rab_id    = pdcp_read_header_g.rb_id  % maxDRB;
+            rab_id    = pdcp_read_header_g.rb_id % maxDRB;
           }
 
           CHECK_CTXT_ARGS(&ctxt);

openair2/LAYER2/RLC/rlc_rrc.c

@@ -234,7 +234,7 @@ rlc_op_status_t rrc_rlc_config_asn1_req (const protocol_ctxt_t   * const ctxt_pP
       drb_id = drb_toaddmod_p->drb_Identity;
       lc_id  = drb_id + 2;
 
-      LOG_D(RLC, "Adding DRB %d, lc_id %d\n",drb_id,lc_id);
+      LOG_I(RLC, "Adding DRB %d, lc_id %d\n",drb_id,lc_id);
 
 
       if (drb_toaddmod_p->rlc_Config) {

openair2/RRC/LITE/L2_interface.c

@@ -597,14 +597,14 @@ rrc_data_ind(
   rb_id_t    DCCH_index = Srb_id;
 
   if (ctxt_pP->enb_flag == ENB_FLAG_NO) {
-    LOG_N(RRC, "[UE %x] Frame %d: received a DCCH %d message on SRB %d with Size %d from eNB ???\n",
-          ctxt_pP->module_id, ctxt_pP->frame, DCCH_index,Srb_id-1,sdu_sizeP);
+    LOG_N(RRC, "[UE %x] Frame %d: received a DCCH %d message on SRB %d with Size %d from eNB %d\n",
+          ctxt_pP->module_id, ctxt_pP->frame, DCCH_index,Srb_id,sdu_sizeP,  ctxt_pP->eNB_index);
   } else {
     LOG_N(RRC, "[eNB %d] Frame %d: received a DCCH %d message on SRB %d with Size %d from UE %x\n",
           ctxt_pP->module_id,
           ctxt_pP->frame,
           DCCH_index,
-          Srb_id-1,
+          Srb_id,
           sdu_sizeP,
           ctxt_pP->rnti);
   }
@@ -656,7 +656,7 @@ void rrc_in_sync_ind(module_id_t Mod_idP, frame_t frameP, uint16_t eNB_index)
 #if defined(ENABLE_ITTI)
   {
     MessageDef *message_p;
-
+    //LOG_I(RRC,"sending a message to task_mac_ue\n");
     message_p = itti_alloc_new_message (TASK_MAC_UE, RRC_MAC_IN_SYNC_IND);
     RRC_MAC_IN_SYNC_IND (message_p).frame = frameP;
     RRC_MAC_IN_SYNC_IND (message_p).enb_index = eNB_index;

openair2/RRC/LITE/MESSAGES/asn1_msg.c

@@ -2024,7 +2024,7 @@ do_RRCConnectionReconfiguration(
                                    (void*)&dl_dcch_msg,
                                    buffer,
                                    RRC_BUF_SIZE);
-  AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
+  AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %l)!\n",
                enc_rval.failed_type->name, enc_rval.encoded);
 
 #ifdef XER_PRINT

openair2/RRC/LITE/defs.h

@@ -187,6 +187,9 @@ typedef enum HO_STATE_e {
 #define CBA_OFFSET        0xfff4
 // #define NUM_MAX_CBA_GROUP 4 // in the platform_constants
 
+/* TS 36.331: RRC-TransactionIdentifier ::= INTEGER (0..3) */
+#define RRC_TRANSACTION_IDENTIFIER_NUMBER  3
+
 typedef struct UE_RRC_INFO_s {
   UE_STATE_t State;
   uint8_t SIB1systemInfoValueTag;
@@ -220,19 +223,20 @@ typedef struct UE_S_TMSI_s {
 #if defined(ENABLE_ITTI)
 typedef enum e_rab_satus_e {
   E_RAB_STATUS_NEW,
-  E_RAB_STATUS_DONE,
+  E_RAB_STATUS_DONE, // from the eNB perspective
+  E_RAB_STATUS_ESTABLISHED, // get the reconfigurationcomplete form UE
   E_RAB_STATUS_FAILED,
 } e_rab_status_t;
 
 typedef struct e_rab_param_s {
   e_rab_t param;
   uint8_t status;
+  uint8_t xid; // transaction_id
 } __attribute__ ((__packed__)) e_rab_param_t;
 #endif
 
 
 
-
 /* Intermediate structure for Handover management. Associated per-UE in eNB_RRC_INST */
 typedef struct HANDOVER_INFO_s {
   uint8_t ho_prepare;
@@ -282,7 +286,7 @@ typedef struct SRB_INFO_TABLE_ENTRY_s {
   SRB_INFO Srb_info;
   uint8_t Active;
   uint8_t Status;
-  uint32_t Next_check_frame;
+  uint32_t Next_check_frame; 
 } SRB_INFO_TABLE_ENTRY;
 
 typedef struct MEAS_REPORT_LIST_s {
@@ -302,7 +306,9 @@ typedef struct eNB_RRC_UE_s {
   SCellToAddMod_r10_t                sCell_config[2];
 #endif
   SRB_ToAddModList_t*                SRB_configList;
+  SRB_ToAddModList_t*                SRB_configList2[RRC_TRANSACTION_IDENTIFIER_NUMBER];
   DRB_ToAddModList_t*                DRB_configList;
+  DRB_ToAddModList_t*                DRB_configList2[RRC_TRANSACTION_IDENTIFIER_NUMBER];
   uint8_t                            DRB_active[8];
   struct PhysicalConfigDedicated*    physicalConfigDedicated;
   struct SPS_Config*                 sps_Config;
@@ -347,10 +353,12 @@ typedef struct eNB_RRC_UE_s {
 
   security_capabilities_t            security_capabilities;
 
+  /* Total number of e_rab already setup in the list */
+  uint8_t                           setup_e_rabs;
   /* Number of e_rab to be setup in the list */
   uint8_t                            nb_of_e_rabs;
   /* list of e_rab to be setup by RRC layers */
-  e_rab_param_t                      e_rab[S1AP_MAX_E_RAB];
+  e_rab_param_t                      e_rab[NB_RB_MAX];//[S1AP_MAX_E_RAB];
 
   // LG: For GTPV1 TUNNELS
   uint32_t                           enb_gtp_teid[S1AP_MAX_E_RAB];
@@ -408,10 +416,10 @@ typedef struct {
 #endif
   SRB_INFO                          SI;
   SRB_INFO                          Srb0;
-} rcc_eNB_carrier_data_t;
+} rrc_eNB_carrier_data_t;
 
 typedef struct eNB_RRC_INST_s {
-  rcc_eNB_carrier_data_t          carrier[MAX_NUM_CCs];
+  rrc_eNB_carrier_data_t          carrier[MAX_NUM_CCs];
   uid_allocator_t                    uid_allocator; // for rrc_ue_head
   RB_HEAD(rrc_ue_tree_s, rrc_eNB_ue_context_s)     rrc_ue_head; // ue_context tree key search by rnti
   uint8_t                           HO_flag;

openair2/RRC/LITE/proto.h

@@ -228,19 +228,21 @@ rrc_eNB_generate_RRCConnectionReestablishmentReject(
 void
 rrc_eNB_process_RRCConnectionSetupComplete(
   const protocol_ctxt_t* const ctxt_pP,
-  rrc_eNB_ue_context_t*          const ue_context_pP,
+  rrc_eNB_ue_context_t*        ue_context_pP,
   RRCConnectionSetupComplete_r8_IEs_t* rrcConnectionSetupComplete
 );
 
 /**\brief Process the RRCConnectionReconfigurationComplete based on information coming from UE
    \param ctxt_pP       Running context
    \param ue_context_pP RRC UE context
-   \param rrcConnectionReconfigurationComplete Pointer to RRCConnectionReconfigurationComplete message*/
+   \param rrcConnectionReconfigurationComplete Pointer to RRCConnectionReconfigurationComplete message
+   \param xid         the transaction id for the rrcconnectionreconfiguration procedure
+*/
 void
 rrc_eNB_process_RRCConnectionReconfigurationComplete(
   const protocol_ctxt_t* const ctxt_pP,
-  rrc_eNB_ue_context_t*          const ue_context_pP,
-  RRCConnectionReconfigurationComplete_r8_IEs_t* rrcConnectionReconfigurationComplete
+  rrc_eNB_ue_context_t*        ue_context_pP,
+  const uint8_t xid
 );
 
 /**\brief Generate the RRCConnectionRelease
@@ -259,6 +261,17 @@ rrc_eNB_generate_defaultRRCConnectionReconfiguration(
   const uint8_t                ho_state
 );
 
+void
+rrc_eNB_generate_dedeicatedRRCConnectionReconfiguration(
+  const protocol_ctxt_t* const ctxt_pP,
+  rrc_eNB_ue_context_t*          const ue_context_pP,
+  const uint8_t                ho_state
+);
+
+void 
+rrc_eNB_reconfigure_DRBs (const protocol_ctxt_t* const ctxt_pP,
+			  rrc_eNB_ue_context_t*  ue_context_pP);
+
 #if defined(ENABLE_ITTI)
 /**\brief RRC eNB task.
    \param void *args_p Pointer on arguments to start the task. */

openair2/RRC/LITE/rrc_eNB_GTPV1U.c

@@ -68,14 +68,19 @@ rrc_eNB_process_GTPV1U_CREATE_TUNNEL_RESP(
                      ctxt_pP->rnti);
 
     for (i = 0; i < create_tunnel_resp_pP->num_tunnels; i++) {
-      LOG_D(RRC, PROTOCOL_RRC_CTXT_UE_FMT" rrc_eNB_process_GTPV1U_CREATE_TUNNEL_RESP tunnel %u bearer index %u id %u\n",
+      
+      ue_context_p->ue_context.enb_gtp_teid[i+ue_context_p->ue_context.setup_e_rabs]  = create_tunnel_resp_pP->enb_S1u_teid[i];
+      ue_context_p->ue_context.enb_gtp_addrs[i+ue_context_p->ue_context.setup_e_rabs] = create_tunnel_resp_pP->enb_addr;
+      ue_context_p->ue_context.enb_gtp_ebi[i+ue_context_p->ue_context.setup_e_rabs]   = create_tunnel_resp_pP->eps_bearer_id[i];
+      
+      LOG_I(RRC, PROTOCOL_RRC_CTXT_UE_FMT" rrc_eNB_process_GTPV1U_CREATE_TUNNEL_RESP tunnel (%u, %u) bearer UE context index %u, msg index %u, id %u, gtp addr len %d \n",
             PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),
             create_tunnel_resp_pP->enb_S1u_teid[i],
-            i,
-            create_tunnel_resp_pP->eps_bearer_id[i]);
-      ue_context_p->ue_context.enb_gtp_teid[i]  = create_tunnel_resp_pP->enb_S1u_teid[i];
-      ue_context_p->ue_context.enb_gtp_addrs[i] = create_tunnel_resp_pP->enb_addr;
-      ue_context_p->ue_context.enb_gtp_ebi[i]   = create_tunnel_resp_pP->eps_bearer_id[i];
+	    ue_context_p->ue_context.enb_gtp_teid[i+ue_context_p->ue_context.setup_e_rabs],
+            i+ue_context_p->ue_context.setup_e_rabs, 
+	    i,
+            create_tunnel_resp_pP->eps_bearer_id[i],
+	    create_tunnel_resp_pP->enb_addr.length);
     }
 	MSC_LOG_RX_MESSAGE(
 			  MSC_RRC_ENB,

openair2/RRC/LITE/rrc_eNB_S1AP.h

@@ -166,6 +166,25 @@ int rrc_eNB_process_S1AP_DOWNLINK_NAS(MessageDef *msg_p, const char *msg_name, i
  */
 int rrc_eNB_process_S1AP_INITIAL_CONTEXT_SETUP_REQ(MessageDef *msg_p, const char *msg_name, instance_t instance);
 
+
+/*! \fn rrc_eNB_process_S1AP_E_RAB_SETUP_REQ(MessageDef *msg_p, const char *msg_name, instance_t instance);
+ *\brief process a S1AP dedicated E_RAB setup request message received from S1AP.
+ *\param msg_p Message received by RRC.
+ *\param msg_name Message name.
+ *\param instance Message instance.
+ *\return 0 when successful, -1 if the UE index can not be retrieved.
+ */
+int rrc_eNB_process_S1AP_E_RAB_SETUP_REQ(MessageDef *msg_p, const char *msg_name, instance_t instance);
+
+/*! \fn rrc_eNB_send_S1AP_E_RAB_SETUP_RESP(const protocol_ctxt_t* const ctxt_pP, rrc_eNB_ue_context_t*  const ue_context_pP, uint8_t xid )
+ *\brief send a S1AP dedicated E_RAB setup response
+ *\param ctxt_pP contxt infirmation
+ *\param e_contxt_pP ue specific context at the eNB
+ *\param xid transaction identifier 
+ *\return 0 when successful, -1 if the UE index can not be retrieved.
+ */
+int rrc_eNB_send_S1AP_E_RAB_SETUP_RESP(const protocol_ctxt_t* const ctxt_pP, rrc_eNB_ue_context_t*  const ue_context_pP, uint8_t xid );  
+
 /*! \fn rrc_eNB_process_S1AP_UE_CTXT_MODIFICATION_REQ(MessageDef *msg_p, const char *msg_name, instance_t instance)
  *\brief process a S1AP_UE_CTXT_MODIFICATION_REQ message received from S1AP.
  *\param msg_p Message received by RRC.

openair2/UTIL/MEM/mem_block.h

@@ -75,7 +75,8 @@ public_mem_block(void         check_mem_area (void);)
 private_mem_block(void        check_free_mem_block (mem_block_t * leP);)
 #    endif
 #ifdef USER_MODE
-#    define MEM_SCALE /*MAX_RG */ MAX_MOBILES_PER_ENB
+//#    define MEM_SCALE MAX_MOBILES_PER_ENB*NB_RB_MAX
+#    define MEM_SCALE MAX_MOBILES_PER_ENB
 #else
 #    ifdef NODE_RG
 #        define MEM_SCALE 2

openair3/GTPV1-U/gtpv1u_eNB.c

@@ -28,7 +28,7 @@
  *******************************************************************************/
 /*! \file gtpv1u_eNB.c
  * \brief
- * \author Sebastien ROUX, Lionel GAUTHIER
+ * \author Sebastien ROUX, Lionel GAUTHIER, Navid Nikaein
  * \version 1.0
  * \company Eurecom
  * \email: lionel.gauthier@eurecom.fr
@@ -289,7 +289,7 @@ NwGtpv1uRcT gtpv1u_eNB_process_stack_req(
   NwGtpv1uUlpHandleT hUlp,
   NwGtpv1uUlpApiT   *pUlpApi)
 {
-  int                 result             = 0;
+  boolean_t           result             = FALSE;
   teid_t              teid               = 0;
   hashtable_rc_t      hash_rc            = HASH_TABLE_KEY_NOT_EXISTS;
   gtpv1u_teid_data_t *gtpv1u_teid_data_p = NULL;
@@ -335,38 +335,49 @@ NwGtpv1uRcT gtpv1u_eNB_process_stack_req(
 
 //#warning "LG eps bearer mapping to DRB id to do (offset -4)"
       PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, gtpv1u_teid_data_p->enb_id, ENB_FLAG_YES,  gtpv1u_teid_data_p->ue_id, 0, 0,gtpv1u_teid_data_p->enb_id);
-
       MSC_LOG_TX_MESSAGE(
-    		  MSC_GTPU_ENB,
-    		  MSC_PDCP_ENB,
-    		  NULL,0,
-    		  MSC_AS_TIME_FMT" DATA-REQ rb %u size %u",
-    		  0,0,
-    		  (gtpv1u_teid_data_p->eps_bearer_id) ? gtpv1u_teid_data_p->eps_bearer_id - 4: 5-4,
-    		  buffer_len);
-
+			 MSC_GTPU_ENB,
+			 MSC_PDCP_ENB,
+			 NULL,0,
+			 MSC_AS_TIME_FMT" DATA-REQ rb %u size %u",
+			 0,0,
+			 (gtpv1u_teid_data_p->eps_bearer_id) ? gtpv1u_teid_data_p->eps_bearer_id - 4: 5-4,
+			 buffer_len);
+      
       result = pdcp_data_req(
-                 &ctxt,
-                 SRB_FLAG_NO,
-                 (gtpv1u_teid_data_p->eps_bearer_id) ? gtpv1u_teid_data_p->eps_bearer_id - 4: 5-4,
-                 0, // mui
-                 SDU_CONFIRM_NO, // confirm
-                 buffer_len,
-                 buffer,
-                 PDCP_TRANSMISSION_MODE_DATA);
-      AssertError (result == TRUE, return NW_GTPV1U_FAILURE ,"PDCP data request failed!\n");
+			     &ctxt,
+			     SRB_FLAG_NO,
+			     (gtpv1u_teid_data_p->eps_bearer_id) ? gtpv1u_teid_data_p->eps_bearer_id - 4: 5-4,
+			     0, // mui
+			     SDU_CONFIRM_NO, // confirm
+			     buffer_len,
+			     buffer,
+			     PDCP_TRANSMISSION_MODE_DATA);
+      
+      
+      if ( result == FALSE ) {
+	
+	if (ctxt.configured == FALSE )
+	  LOG_W(GTPU, "PDCP data request failed, cause: RB is not configured!\n") ;
+	else  
+	  LOG_W(GTPU, "PDCP data request failed\n");
+	
+	return NW_GTPV1U_FAILURE;
+      }
+      
     } else {
-      LOG_E(GTPU, "Received T-PDU from gtpv1u stack teid %u unknown size %u", teid, buffer_len);
+      LOG_W(GTPU, "Received T-PDU from gtpv1u stack teid %u unknown size %u", teid, buffer_len);
     }
   }
-  break;
-
+    break;
+    
   default: {
     LOG_E(GTPU, "Received undefined UlpApi (%02x) from gtpv1u stack!\n",
           pUlpApi->apiType);
   }
-  }
-
+  
+  } // end of switch 
+  
   return NW_GTPV1U_OK;
 }
 

openair3/NAS/UE/API/USIM/aka_functions.c

@@ -306,6 +306,11 @@ void ComputeOPc( u8 op_c_pP[16] )
 
   for (i=0; i<16; i++)
     op_c_pP[i] ^= OP[i];
+  LOG_TRACE(DEBUG,
+            "USIM-API  - OPc[0..15]=%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
+            op_c_pP[0],op_c_pP[1],op_c_pP[2], op_c_pP[3], op_c_pP[4], op_c_pP[5], op_c_pP[6], op_c_pP[7],
+            op_c_pP[8],op_c_pP[9],op_c_pP[10],op_c_pP[11],op_c_pP[12],op_c_pP[13],op_c_pP[14],op_c_pP[15]);
+
 
   return;
 } /* end of function ComputeOPc */

openair3/S1AP/s1ap_common.c

@@ -29,8 +29,9 @@
 
 /*! \file s1ap_common.c
  * \brief s1ap procedures for both eNB and MME
- * \author Sebastien ROUX <sebastien.roux@eurecom.fr>
- * \date 2012
+ * \author Sebastien ROUX and Navid Nikaein
+ * \email navid.nikaein@eurecom.fr 
+ * \date 2012-2015
  * \version 0.1
  */
 

openair3/S1AP/s1ap_eNB.c

@@ -26,6 +26,14 @@
   Address      : Eurecom, Compus SophiaTech 450, route des chappes, 06451 Biot, France.
 
  *******************************************************************************/
+/*! \file s1ap_eNB.c
+ * \brief S1AP eNB task 
+ * \author  S. Roux and Navid Nikaein 
+ * \date 2010 - 2015
+ * \email: navid.nikaein@eurecom.fr
+ * \version 1.0
+ * @ingroup _s1ap
+ */
 
 #include <pthread.h>
 #include <stdio.h>
@@ -105,7 +113,8 @@ static void s1ap_eNB_register_mme(s1ap_eNB_instance_t *instance_p,
   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;
-
+  struct s1ap_eNB_mme_data_s *mme                         = NULL;
+ 
   DevAssert(instance_p != NULL);
   DevAssert(mme_ip_address != NULL);
 
@@ -126,27 +135,56 @@ static void s1ap_eNB_register_mme(s1ap_eNB_instance_t *instance_p,
   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                = 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;
-
-  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 ++;
-
+ 
+  S1AP_INFO("[eNB %d] check the mme registration state\n",instance_p->instance);
+	      
+  mme = s1ap_eNB_get_MME_from_instance(instance_p);
+
+  if ( mme == NULL ) {
+    
+    /* 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                = 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;
+    
+    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 ++;
+  } else if (mme->state == S1AP_ENB_STATE_WAITING) {
+    instance_p->s1ap_mme_pending_nb ++;
+    sctp_new_association_req_p->ulp_cnx_id = mme->cnx_id;
+
+    S1AP_INFO("[eNB %d] MME already registered, retrive the data (state %d, cnx %d, mme_nb %d, mme_pending_nb %d)\n",
+	      instance_p->instance, 
+	      mme->state, mme->cnx_id,
+	      instance_p->s1ap_mme_nb, instance_p->s1ap_mme_pending_nb);
+
+    /*s1ap_mme_data_p->cnx_id                = mme->cnx_id;
+    sctp_new_association_req_p->ulp_cnx_id = mme->cnx_id;
+    
+    s1ap_mme_data_p->assoc_id          = -1;
+    s1ap_mme_data_p->s1ap_eNB_instance = instance_p;
+    */ 
+  } else {
+    
+    S1AP_WARN("[eNB %d] MME already registered but not in the waiting state, retrive the data (state %d, cnx %d, mme_nb %d, mme_pending_nb %d)\n",
+	      instance_p->instance, 
+	      mme->state, mme->cnx_id, 
+	      instance_p->s1ap_mme_nb, instance_p->s1ap_mme_pending_nb);
+    
+  }
+    
   itti_send_msg_to_task(TASK_SCTP, instance_p->instance, message_p);
 }
 
@@ -155,13 +193,14 @@ void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *
 {
   s1ap_eNB_instance_t *new_instance;
   uint8_t index;
-
+  
   DevAssert(s1ap_register_eNB != NULL);
 
   /* Look if the provided instance already exists */
   new_instance = s1ap_eNB_get_instance(instance);
-
-  if (new_instance != NULL) {
+  
+ 
+  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);
@@ -191,7 +230,7 @@ void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *
     /* Add the new instance to the list of eNB (meaningfull in virtual mode) */
     s1ap_eNB_insert_new_instance(new_instance);
 
-    S1AP_DEBUG("Registered new eNB[%d] and %s eNB id %u\n",
+    S1AP_INFO("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);
@@ -203,7 +242,7 @@ void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *
   /* Trying to connect to provided list of MME ip address */
   for (index = 0; index < s1ap_register_eNB->nb_mme; index++) {
     s1ap_eNB_register_mme(new_instance,
-    		              &s1ap_register_eNB->mme_ip_address[index],
+    		          &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);
@@ -327,6 +366,12 @@ void *s1ap_eNB_task(void *arg)
     }
     break;
 
+    case S1AP_E_RAB_SETUP_RESP: {
+      s1ap_eNB_e_rab_setup_resp(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+				&S1AP_E_RAB_SETUP_RESP(received_msg));
+    }
+    break;
+      
     case S1AP_NAS_NON_DELIVERY_IND: {
       s1ap_eNB_nas_non_delivery_ind(ITTI_MESSAGE_GET_INSTANCE(received_msg),
                                     &S1AP_NAS_NON_DELIVERY_IND(received_msg));

openair3/S1AP/s1ap_eNB_context_management_procedures.c

@@ -26,7 +26,14 @@
   Address      : Eurecom, Compus SophiaTech 450, route des chappes, 06451 Biot, France.
 
  *******************************************************************************/
-
+/*! \file s1ap_eNB_context_management_procedures.c
+ * \brief S1AP context management procedures 
+ * \author  S. Roux and Navid Nikaein 
+ * \date 2010 - 2015
+ * \email: navid.nikaein@eurecom.fr
+ * \version 1.0
+ * @ingroup _s1ap
+ */
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>

openair3/S1AP/s1ap_eNB_decoder.c

@@ -29,8 +29,9 @@
 
 /*! \file s1ap_eNB_decoder.c
  * \brief s1ap pdu decode procedures for eNB
- * \author Sebastien ROUX <sebastien.roux@eurecom.fr>
- * \date 2013
+ * \author Sebastien ROUX and Navid Nikaein
+ * \email navid.nikaein@eurecom.fr
+ * \date 2013 - 2015
  * \version 0.1
  */
 
@@ -120,6 +121,29 @@ static int s1ap_eNB_decode_initiating_message(s1ap_message *message,
     break;
 
 
+  case S1ap_ProcedureCode_id_E_RABSetup:
+    ret = s1ap_decode_s1ap_e_rabsetuprequesties(
+						&message->msg.s1ap_E_RABSetupRequestIEs, &initiating_p->value);
+    //s1ap_xer_print_s1ap_e_rabsetuprequest(s1ap_xer__print2sp, message_string, message);
+    message_id = S1AP_E_RAB_SETUP_REQUEST_LOG;
+    message_string_size = strlen(message_string);
+    message_p           = itti_alloc_new_message_sized(TASK_S1AP,
+                          message_id,
+                          message_string_size + sizeof (IttiMsgText));
+    message_p->ittiMsg.s1ap_e_rab_setup_request_log.size = message_string_size;
+    memcpy(&message_p->ittiMsg.s1ap_e_rab_setup_request_log.text, message_string, message_string_size);
+    itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
+    free(message_string);
+    S1AP_INFO("E_RABSetup initiating message\n");
+    break;
+  case S1ap_ProcedureCode_id_E_RABRelease:
+    ret = s1ap_decode_s1ap_e_rabreleasecommandies(&message->msg.s1ap_E_RABReleaseCommandIEs, 
+						 &initiating_p->value);
+    //s1ap_xer_print_s1ap_e_rabsetuprequest(s1ap_xer__print2sp, message_string, message);
+    S1AP_INFO("TODO  E_RABRelease nitiating message\n");
+    free(message_string);
+    break;
+
   default:
     S1AP_ERROR("Unknown procedure ID (%d) for initiating message\n",
                (int)initiating_p->procedureCode);

openair3/S1AP/s1ap_eNB_encoder.c

@@ -29,8 +29,9 @@
 
 /*! \file s1ap_eNB_encoder.c
  * \brief s1ap pdu encode procedures for eNB
- * \author Sebastien ROUX <sebastien.roux@eurecom.fr>
- * \date 2013
+ * \author Sebastien ROUX and Navid Nikaein
+ * \email navid.nikaein@eurecom.fr
+ * \date 2013 - 2015
  * \version 0.1
  */
 
@@ -38,6 +39,8 @@
 #include <string.h>
 #include <stdint.h>
 
+#include "assertions.h"
+
 #include "conversions.h"
 
 #include "intertask_interface.h"
@@ -100,6 +103,11 @@ int s1ap_eNB_encode_ue_context_release_request(
   uint8_t                              **buffer,
   uint32_t                              *length);
 
+static inline
+int s1ap_eNB_encode_e_rab_setup_response(S1ap_E_RABSetupResponseIEs_t  *E_RABSetupResponseIEs,
+					 uint8_t                              **buffer,
+					 uint32_t                              *length);
+
 int s1ap_eNB_encode_pdu(s1ap_message *message, uint8_t **buffer, uint32_t *len)
 {
   DevAssert(message != NULL);
@@ -251,8 +259,21 @@ int s1ap_eNB_encode_successfull_outcome(s1ap_message *s1ap_message_p,
     free(message_string);
     break;
 
+  case S1ap_ProcedureCode_id_E_RABSetup:
+
+    ret = s1ap_eNB_encode_e_rab_setup_response (
+           &s1ap_message_p->msg.s1ap_E_RABSetupResponseIEs, buffer, len);
+    //s1ap_xer_print_s1ap_e_rabsetupresponse (s1ap_xer__print2sp, message_string, s1ap_message_p);
+    message_id =  S1AP_E_RAB_SETUP_RESPONSE_LOG ;
+    message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText));
+    message_p->ittiMsg.s1ap_e_rab_setup_response_log.size = message_string_size;
+    memcpy(&message_p->ittiMsg.s1ap_e_rab_setup_response_log.text, message_string, message_string_size);
+    itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
+    free(message_string);
+    S1AP_INFO("E_RABSetup successful message\n");
+    break;
   default:
-    S1AP_DEBUG("Unknown procedure ID (%d) for successfull outcome message\n",
+    S1AP_WARN("Unknown procedure ID (%d) for successfull outcome message\n",
                (int)s1ap_message_p->procedureCode);
     return ret;
     break;
@@ -528,3 +549,25 @@ int s1ap_eNB_encode_ue_context_release_request(
                                           ue_context_release_request_p);
 }
 
+static inline
+int s1ap_eNB_encode_e_rab_setup_response(S1ap_E_RABSetupResponseIEs_t  *s1ap_E_RABSetupResponseIEs,
+					 uint8_t                              **buffer,
+					 uint32_t                              *length)
+{
+  S1ap_E_RABSetupResponse_t  e_rab_setup_response;
+  S1ap_E_RABSetupResponse_t  *e_rab_setup_response_p = &e_rab_setup_response;
+  
+  memset((void *)e_rab_setup_response_p, 0,
+         sizeof(e_rab_setup_response));
+
+  if (s1ap_encode_s1ap_e_rabsetupresponseies (e_rab_setup_response_p, s1ap_E_RABSetupResponseIEs) < 0) {
+    return -1;
+  }
+  
+  return s1ap_generate_successfull_outcome(buffer,
+         length,
+         S1ap_ProcedureCode_id_E_RABSetup,
+         S1ap_Criticality_reject,
+         &asn_DEF_S1ap_E_RABSetupResponse,
+         e_rab_setup_response_p);
+}

openair3/S1AP/s1ap_eNB_handlers.c

@@ -29,8 +29,9 @@
 
 /*! \file s1ap_eNB_handlers.c
  * \brief s1ap messages handlers for eNB part
- * \author Sebastien ROUX <sebastien.roux@eurecom.fr>
- * \date 2013
+ * \author Sebastien ROUX and Navid Nikaein
+ * \email navid.nikaein@eurecom.fr
+ * \date 2013 - 2015
  * \version 0.1
  */
 
@@ -82,6 +83,13 @@ int s1ap_eNB_handle_ue_context_release_command(uint32_t               assoc_id,
     uint32_t               stream,
     struct s1ap_message_s *s1ap_message_p);
 
+
+static
+int s1ap_eNB_handle_e_rab_setup_request(uint32_t               assoc_id,
+					uint32_t               stream,
+					struct s1ap_message_s *s1ap_message_p);
+
+
 /* Handlers matrix. Only eNB related procedure present here */
 s1ap_message_decoded_callback messages_callback[][3] = {
   { 0, 0, 0 }, /* HandoverPreparation */
@@ -89,7 +97,7 @@ s1ap_message_decoded_callback messages_callback[][3] = {
   { 0, 0, 0 }, /* HandoverNotification */
   { 0, 0, 0 }, /* PathSwitchRequest */
   { 0, 0, 0 }, /* HandoverCancel */
-  { 0, 0, 0 }, /* E_RABSetup */
+  { s1ap_eNB_handle_e_rab_setup_request, 0, 0 }, /* E_RABSetup */
   { 0, 0, 0 }, /* E_RABModify */
   { 0, 0, 0 }, /* E_RABRelease */
   { 0, 0, 0 }, /* E_RABReleaseIndication */
@@ -762,7 +770,8 @@ int s1ap_eNB_handle_initial_context_request(uint32_t               assoc_id,
         malloc(sizeof(uint8_t) * item_p->nAS_PDU->size);
 
       memcpy(S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.buffer,
-             item_p->nAS_PDU->buf, item_p->nAS_PDU->size);
+             item_p->nAS_PDU->buf, item_p->nAS_PDU->size); 
+      S1AP_DEBUG("Received NAS message with the E_RAB setup procedure\n");
     } else {
       S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.length = 0;
       S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.buffer = NULL;
@@ -873,3 +882,113 @@ int s1ap_eNB_handle_ue_context_release_command(uint32_t               assoc_id,
   }
 }
 
+static
+int s1ap_eNB_handle_e_rab_setup_request(uint32_t               assoc_id,
+					uint32_t               stream,
+					struct s1ap_message_s *s1ap_message_p) {
+
+  int i;
+
+  s1ap_eNB_mme_data_t   *mme_desc_p       = NULL;
+  s1ap_eNB_ue_context_t *ue_desc_p        = NULL;
+  MessageDef            *message_p        = NULL;
+
+  S1ap_E_RABSetupRequestIEs_t         *s1ap_E_RABSetupRequest;
+  DevAssert(s1ap_message_p != NULL);
+
+  s1ap_E_RABSetupRequest = &s1ap_message_p->msg.s1ap_E_RABSetupRequestIEs;
+
+  if ((mme_desc_p = s1ap_eNB_get_MME(NULL, assoc_id, 0)) == NULL) {
+    S1AP_ERROR("[SCTP %d] Received initial context setup request for non "
+               "existing MME context\n", assoc_id);
+    return -1;
+  }
+
+    
+  if ((ue_desc_p = s1ap_eNB_get_ue_context(mme_desc_p->s1ap_eNB_instance,
+                   s1ap_E_RABSetupRequest->eNB_UE_S1AP_ID)) == NULL) {
+    S1AP_ERROR("[SCTP %d] Received initial context setup request for non "
+               "existing UE context 0x%06x\n", assoc_id,
+               s1ap_E_RABSetupRequest->eNB_UE_S1AP_ID);
+    return -1;
+  }
+
+  /* Initial context request = UE-related procedure -> stream != 0 */
+  if (stream == 0) {
+    S1AP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n",
+               assoc_id, stream);
+    return -1;
+  }
+
+  ue_desc_p->rx_stream = stream;
+
+  if ( ue_desc_p->mme_ue_s1ap_id != s1ap_E_RABSetupRequest->mme_ue_s1ap_id){
+    S1AP_WARN("UE context mme_ue_s1ap_id is different form that of the message (%d != %d)", 
+	      ue_desc_p->mme_ue_s1ap_id, s1ap_E_RABSetupRequest->mme_ue_s1ap_id);
+
+  }
+  message_p        = itti_alloc_new_message(TASK_S1AP, S1AP_E_RAB_SETUP_REQ);
+ 
+  S1AP_E_RAB_SETUP_REQ(message_p).ue_initial_id  = ue_desc_p->ue_initial_id;
+  
+  S1AP_E_RAB_SETUP_REQ(message_p).mme_ue_s1ap_id  = s1ap_E_RABSetupRequest->mme_ue_s1ap_id;
+  S1AP_E_RAB_SETUP_REQ(message_p).eNB_ue_s1ap_id  = s1ap_E_RABSetupRequest->eNB_UE_S1AP_ID;
+   
+   S1AP_E_RAB_SETUP_REQ(message_p).nb_e_rabs_tosetup =
+    s1ap_E_RABSetupRequest->e_RABToBeSetupListBearerSUReq.s1ap_E_RABToBeSetupItemBearerSUReq.count;
+ 
+  for (i = 0; i < s1ap_E_RABSetupRequest->e_RABToBeSetupListBearerSUReq.s1ap_E_RABToBeSetupItemBearerSUReq.count; i++) {
+    S1ap_E_RABToBeSetupItemBearerSUReq_t *item_p;
+   
+    item_p = (S1ap_E_RABToBeSetupItemBearerSUReq_t *)s1ap_E_RABSetupRequest->e_RABToBeSetupListBearerSUReq.s1ap_E_RABToBeSetupItemBearerSUReq.array[i];
+
+    S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].e_rab_id = item_p->e_RAB_ID;
+
+    // check for the NAS PDU
+    if (item_p->nAS_PDU.size > 0 ) {
+      S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.length = item_p->nAS_PDU.size;
+
+      S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.buffer = malloc(sizeof(uint8_t) * item_p->nAS_PDU.size);
+
+      memcpy(S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.buffer,
+             item_p->nAS_PDU.buf, item_p->nAS_PDU.size); 
+      // S1AP_INFO("received a NAS PDU with size %d (%02x.%02x)\n",S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.length, item_p->nAS_PDU.buf[0], item_p->nAS_PDU.buf[1]);
+    } else {
+      S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.length = 0;
+      S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.buffer = NULL;
+      
+      S1AP_WARN("NAS PDU is not provided, generate a E_RAB_SETUP Failure (TBD) back to MME \n");
+      return -1;
+    }
+
+    /* Set the transport layer address */
+    memcpy(S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].sgw_addr.buffer,
+           item_p->transportLayerAddress.buf, item_p->transportLayerAddress.size);
+    S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].sgw_addr.length =
+      item_p->transportLayerAddress.size * 8 - item_p->transportLayerAddress.bits_unused;
+
+    /* S1AP_INFO("sgw addr %s  len: %d (size %d, index %d)\n", 
+	      S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].sgw_addr.buffer,
+	      S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].sgw_addr.length,
+	      item_p->transportLayerAddress.size, i);
+    */
+    /* GTP tunnel endpoint ID */
+    OCTET_STRING_TO_INT32(&item_p->gTP_TEID, S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].gtp_teid);
+
+    /* Set the QOS informations */
+    S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].qos.qci = item_p->e_RABlevelQoSParameters.qCI;
+
+    S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].qos.allocation_retention_priority.priority_level =
+      item_p->e_RABlevelQoSParameters.allocationRetentionPriority.priorityLevel;
+    S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].qos.allocation_retention_priority.pre_emp_capability =
+      item_p->e_RABlevelQoSParameters.allocationRetentionPriority.pre_emptionCapability;
+    S1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].qos.allocation_retention_priority.pre_emp_vulnerability =
+      item_p->e_RABlevelQoSParameters.allocationRetentionPriority.pre_emptionVulnerability;
+  }
+
+  itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p);
+
+  return 0;
+}
+
+

openair3/S1AP/s1ap_eNB_management_procedures.c

@@ -27,6 +27,15 @@
 
  *******************************************************************************/
 
+/*! \file s1ap_eNB_management_procedures.c
+ * \brief S1AP eNB task 
+ * \author  S. Roux and Navid Nikaein 
+ * \date 2010 - 2016
+ * \email: navid.nikaein@eurecom.fr
+ * \version 1.0
+ * @ingroup _s1ap
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
@@ -116,6 +125,23 @@ struct s1ap_eNB_mme_data_s *s1ap_eNB_get_MME(
   return NULL;
 }
 
+struct s1ap_eNB_mme_data_s *s1ap_eNB_get_MME_from_instance(
+  s1ap_eNB_instance_t *instance_p)
+{
+ 
+  struct s1ap_eNB_mme_data_s *mme = NULL;
+  struct s1ap_eNB_mme_data_s *mme_next = NULL;
+
+  for (mme = RB_MIN(s1ap_mme_map, &instance_p->s1ap_mme_head); mme!=NULL ; mme = mme_next) {
+    mme_next = RB_NEXT(s1ap_mme_map, &instance_p->s1ap_mme_head, mme);
+    if (mme->s1ap_eNB_instance == instance_p) {
+      return mme;
+    }
+  }
+
+  return NULL;
+}
+
 s1ap_eNB_instance_t *s1ap_eNB_get_instance(instance_t instance)
 {
   s1ap_eNB_instance_t *temp = NULL;
@@ -130,3 +156,41 @@ s1ap_eNB_instance_t *s1ap_eNB_get_instance(instance_t instance)
 
   return NULL;
 }
+
+void s1ap_eNB_remove_mme_desc(s1ap_eNB_instance_t * instance) 
+{
+
+    struct s1ap_eNB_mme_data_s *mme = NULL;
+    struct s1ap_eNB_mme_data_s *mmeNext = NULL;
+    struct plmn_identity_s* plmnInfo;
+    struct served_group_id_s* groupInfo;
+    struct served_gummei_s* gummeiInfo;
+    struct mme_code_s* mmeCode;
+
+    for (mme = RB_MIN(s1ap_mme_map, &instance->s1ap_mme_head); mme; mme = mmeNext) {
+      mmeNext = RB_NEXT(s1ap_mme_map, &instance->s1ap_mme_head, mme);
+      RB_REMOVE(s1ap_mme_map, &instance->s1ap_mme_head, mme);
+      while (!STAILQ_EMPTY(&mme->served_gummei)) {
+        gummeiInfo = STAILQ_FIRST(&mme->served_gummei);
+        STAILQ_REMOVE_HEAD(&mme->served_gummei, next);
+	
+        while (!STAILQ_EMPTY(&gummeiInfo->served_plmns)) {
+	  plmnInfo = STAILQ_FIRST(&gummeiInfo->served_plmns);
+	  STAILQ_REMOVE_HEAD(&gummeiInfo->served_plmns, next);
+	  free(plmnInfo);
+        }
+        while (!STAILQ_EMPTY(&gummeiInfo->served_group_ids)) {
+	  groupInfo = STAILQ_FIRST(&gummeiInfo->served_group_ids);
+	  STAILQ_REMOVE_HEAD(&gummeiInfo->served_group_ids, next);
+	  free(groupInfo);
+        }
+        while (!STAILQ_EMPTY(&gummeiInfo->mme_codes)) {
+	  mmeCode = STAILQ_FIRST(&gummeiInfo->mme_codes);
+	  STAILQ_REMOVE_HEAD(&gummeiInfo->mme_codes, next);
+	  free(mmeCode);
+        }
+        free(gummeiInfo);
+      }
+      free(mme);
+    }
+}

openair3/S1AP/s1ap_eNB_management_procedures.h

@@ -34,6 +34,10 @@ struct s1ap_eNB_mme_data_s *s1ap_eNB_get_MME(
   s1ap_eNB_instance_t *instance_p,
   int32_t assoc_id, uint16_t cnx_id);
 
+struct s1ap_eNB_mme_data_s *s1ap_eNB_get_MME_from_instance(s1ap_eNB_instance_t *instance_p);
+
+void s1ap_eNB_remove_mme_desc(s1ap_eNB_instance_t * instance);
+
 void s1ap_eNB_insert_new_instance(s1ap_eNB_instance_t *new_instance_p);
 
 s1ap_eNB_instance_t *s1ap_eNB_get_instance(uint8_t mod_id);

openair3/S1AP/s1ap_eNB_nas_procedures.c

@@ -26,7 +26,14 @@
   Address      : Eurecom, Compus SophiaTech 450, route des chappes, 06451 Biot, France.
 
  *******************************************************************************/
-
+/*! \file s1ap_eNB_nas_procedures.c
+ * \brief S1AP eNb NAS procedure handler
+ * \author  S. Roux and Navid Nikaein 
+ * \date 2010 - 2015
+ * \email: navid.nikaein@eurecom.fr
+ * \version 1.0
+ * @ingroup _s1ap
+ */
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
@@ -579,6 +586,14 @@ int s1ap_eNB_initial_ctxt_resp(
     new_item->transportLayerAddress.size = initial_ctxt_resp_p->e_rabs[i].eNB_addr.length;
     new_item->transportLayerAddress.bits_unused = 0;
 
+    S1AP_DEBUG("initial_ctxt_resp_p: e_rab ID %d, enb_addr %d.%d.%d.%d, SIZE %d \n", 
+	      new_item->e_RAB_ID,
+	      new_item->transportLayerAddress.buf[0],
+	      new_item->transportLayerAddress.buf[1],
+	      new_item->transportLayerAddress.buf[2],
+	      new_item->transportLayerAddress.buf[3],
+	      new_item->transportLayerAddress.size);
+
     ASN_SEQUENCE_ADD(&initial_ies_p->e_RABSetupListCtxtSURes.s1ap_E_RABSetupItemCtxtSURes,
                      new_item);
   }
@@ -688,3 +703,140 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
   return ret;
 }
 
+//------------------------------------------------------------------------------
+int s1ap_eNB_e_rab_setup_resp(instance_t instance, 
+			      s1ap_e_rab_setup_resp_t *e_rab_setup_resp_p)
+//------------------------------------------------------------------------------
+{
+  s1ap_eNB_instance_t          *s1ap_eNB_instance_p = NULL;
+  struct s1ap_eNB_ue_context_s *ue_context_p        = NULL;
+
+  S1ap_E_RABSetupResponseIEs_t  *initial_ies_p  = NULL;
+ 
+  s1ap_message  message;
+
+  uint8_t  *buffer  = NULL;
+  uint32_t length;
+  int      ret = -1;
+  int      i;
+
+  /* Retrieve the S1AP eNB instance associated with Mod_id */
+  s1ap_eNB_instance_p = s1ap_eNB_get_instance(instance);
+
+  DevAssert(e_rab_setup_resp_p != NULL);
+  DevAssert(s1ap_eNB_instance_p != NULL);
+
+  if ((ue_context_p = s1ap_eNB_get_ue_context(s1ap_eNB_instance_p,
+					      e_rab_setup_resp_p->eNB_ue_s1ap_id)) == NULL) {
+    /* The context for this eNB ue s1ap id doesn't exist in the map of eNB UEs */
+    S1AP_WARN("Failed to find ue context associated with eNB ue s1ap id: 0x%06x\n",
+              e_rab_setup_resp_p->eNB_ue_s1ap_id);
+    return -1;
+  }
+
+  /* Uplink NAS transport can occur either during an s1ap connected state
+   * or during initial attach (for example: NAS authentication).
+   */
+  if (!(ue_context_p->ue_state == S1AP_UE_CONNECTED ||
+        ue_context_p->ue_state == S1AP_UE_WAITING_CSR)) {
+    S1AP_WARN("You are attempting to send NAS data over non-connected "
+              "eNB ue s1ap id: %06x, current state: %d\n",
+              e_rab_setup_resp_p->eNB_ue_s1ap_id, ue_context_p->ue_state);
+    return -1;
+  }
+ 
+  /* Prepare the S1AP message to encode */
+  memset(&message, 0, sizeof(s1ap_message));
+
+  message.direction     = S1AP_PDU_PR_successfulOutcome;
+  message.procedureCode = S1ap_ProcedureCode_id_E_RABSetup;
+  message.criticality   = S1ap_Criticality_reject;
+
+  initial_ies_p = &message.msg.s1ap_E_RABSetupResponseIEs;
+  
+  initial_ies_p->eNB_UE_S1AP_ID = e_rab_setup_resp_p->eNB_ue_s1ap_id;
+  initial_ies_p->mme_ue_s1ap_id = ue_context_p->mme_ue_s1ap_id;
+  
+  if ( e_rab_setup_resp_p->nb_of_e_rabs >= 1 )
+    initial_ies_p->presenceMask |= S1AP_E_RABSETUPRESPONSEIES_E_RABSETUPLISTBEARERSURES_PRESENT; 
+  
+  for (i = 0; i < e_rab_setup_resp_p->nb_of_e_rabs; i++) { 
+    S1ap_E_RABSetupItemBearerSURes_t *new_item;
+
+    new_item = calloc(1, sizeof(S1ap_E_RABSetupItemBearerSURes_t));
+
+    new_item->e_RAB_ID = e_rab_setup_resp_p->e_rabs[i].e_rab_id;
+    GTP_TEID_TO_ASN1(e_rab_setup_resp_p->e_rabs[i].gtp_teid, &new_item->gTP_TEID);
+        
+    /*
+    new_item->transportLayerAddress.buf = MALLOC(e_rab_setup_resp_p->e_rabs[i].eNB_addr.length);  
+    memcpy (new_item->transportLayerAddress.buf, 
+	    e_rab_setup_resp_p->e_rabs[i].eNB_addr.buffer,
+	    e_rab_setup_resp_p->e_rabs[i].eNB_addr.length);
+    
+    */
+    /*
+      new_item->transportLayerAddress.buf[0] = e_rab_setup_resp_p->e_rabs[i].eNB_addr.buffer[0];
+    new_item->transportLayerAddress.buf[1] = e_rab_setup_resp_p->e_rabs[i].eNB_addr.buffer[1];
+    new_item->transportLayerAddress.buf[2] = e_rab_setup_resp_p->e_rabs[i].eNB_addr.buffer[2];
+    new_item->transportLayerAddress.buf[3] = e_rab_setup_resp_p->e_rabs[i].eNB_addr.buffer[3];
+    */
+    new_item->transportLayerAddress.buf = e_rab_setup_resp_p->e_rabs[i].eNB_addr.buffer; 
+    new_item->transportLayerAddress.size = e_rab_setup_resp_p->e_rabs[i].eNB_addr.length;
+    new_item->transportLayerAddress.bits_unused = 0;
+    
+    S1AP_DEBUG("e_rab_setup_resp: e_rab ID %d, teid %u, enb_addr %d.%d.%d.%d, SIZE %d\n", 
+	       new_item->e_RAB_ID,
+	       e_rab_setup_resp_p->e_rabs[i].gtp_teid,
+	       new_item->transportLayerAddress.buf[0],
+	       new_item->transportLayerAddress.buf[1],
+	       new_item->transportLayerAddress.buf[2],
+	       new_item->transportLayerAddress.buf[3],
+	       new_item->transportLayerAddress.size);
+    
+    S1ap_IE_t *ie = s1ap_new_ie(S1ap_ProtocolIE_ID_id_E_RABSetupItemBearerSURes,
+				S1ap_Criticality_ignore,
+				&asn_DEF_S1ap_E_RABSetupItemBearerSURes,
+				new_item);
+    /*
+    S1ap_IE_t *ie = s1ap_new_ie(S1ap_ProtocolIE_ID_id_E_RABSetupListBearerSURes,
+				S1ap_Criticality_ignore,
+				&asn_DEF_S1ap_E_RABSetupListBearerSURes,
+				new_item);
+    */
+    ASN_SEQUENCE_ADD(&initial_ies_p->e_RABSetupListBearerSURes.s1ap_E_RABSetupItemBearerSURes,
+                     ie);
+  }
+ 
+  /* S1ap_E_RABSetupListBearerSURes_t  e_RABSetupListBearerSURes;
+  memset(&e_RABSetupListBearerSURes, 0, sizeof(S1ap_E_RABSetupListBearerSURes_t));
+  if (s1ap_encode_s1ap_e_rabsetuplistbearersures(&e_RABSetupListBearerSURes, &initial_ies_p->e_RABSetupListBearerSURes.s1ap_E_RABSetupItemBearerSURes) < 0 )
+    return -1;
+ ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_S1ap_E_RABSetupListBearerSURes, &e_RABSetupListBearerSURes);
+  */
+  fprintf(stderr, "start encode\n");
+  if (s1ap_eNB_encode_pdu(&message, &buffer, &length) < 0) {
+    S1AP_ERROR("Failed to encode uplink transport\n");
+    /* Encode procedure has failed... */
+    return -1;
+  }
+
+ 
+  
+  MSC_LOG_TX_MESSAGE(
+    MSC_S1AP_ENB,
+    MSC_S1AP_MME,
+    (const char *)buffer,
+    length,
+    MSC_AS_TIME_FMT" E_RAN Setup successfulOutcome eNB_ue_s1ap_id %u mme_ue_s1ap_id %u",
+    0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
+    initial_ies_p->eNB_UE_S1AP_ID,
+    initial_ies_p->mme_ue_s1ap_id);
+
+  /* UE associated signalling -> use the allocated stream */
+  s1ap_eNB_itti_send_sctp_data_req(s1ap_eNB_instance_p->instance,
+                                   ue_context_p->mme_ref->assoc_id, buffer,
+                                   length, ue_context_p->tx_stream);
+
+  return ret;
+}

targets/COMMON/create_tasks.c

@@ -51,6 +51,20 @@
 int create_tasks(uint32_t enb_nb, uint32_t ue_nb)
 {
   itti_wait_ready(1);
+  if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) {
+    LOG_E(PDCP, "Create task for L2L1 failed\n");
+    return -1;
+  }
+
+  if (enb_nb > 0) {
+    /* Last task to create, others task must be ready before its start */
+    if (itti_create_task (TASK_ENB_APP, eNB_app_task, NULL) < 0) {
+      LOG_E(ENB_APP, "Create task for eNB APP failed\n");
+      return -1;
+    }
+  }
+
+
 # ifdef OPENAIR2
   {
 #   if defined(ENABLE_USE_MME)
@@ -120,20 +134,8 @@ int create_tasks(uint32_t enb_nb, uint32_t ue_nb)
 #   endif
     }
   }
-# endif
+# endif // openair2: NN: should be openair3
 
-  if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) {
-    LOG_E(PDCP, "Create task for L2L1 failed\n");
-    return -1;
-  }
-
-  if (enb_nb > 0) {
-    /* Last task to create, others task must be ready before its start */
-    if (itti_create_task (TASK_ENB_APP, eNB_app_task, NULL) < 0) {
-      LOG_E(ENB_APP, "Create task for eNB APP failed\n");
-      return -1;
-    }
-  }
 
   itti_wait_ready(0);
 

targets/PROJECTS/GENERIC-LTE-EPC/CONF/enb.band13.tm1.usrpb210.conf

@@ -133,7 +133,7 @@ eNBs =
 
 
     ////////// MME parameters:
-    mme_ip_address      = ( { ipv4       = "172.27.8.52";
+    mme_ip_address      = ( { ipv4       = "192.168.12.170";
                               ipv6       = "192:168:30::17";
                               active     = "yes";
                               preference = "ipv4";
@@ -143,10 +143,10 @@ eNBs =
     NETWORK_INTERFACES :
     {
         ENB_INTERFACE_NAME_FOR_S1_MME            = "eth0";
-        ENB_IPV4_ADDRESS_FOR_S1_MME              = "172.27.8.51/23";
+        ENB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.12.241/24";
 
         ENB_INTERFACE_NAME_FOR_S1U               = "eth0";
-        ENB_IPV4_ADDRESS_FOR_S1U                 = "172.27.8.51/23";
+        ENB_IPV4_ADDRESS_FOR_S1U                 = "192.168.12.241/24";
         ENB_PORT_FOR_S1U                         = 2152; # Spec 2152
     };
 

targets/PROJECTS/GENERIC-LTE-EPC/CONF/enb.band7.tm1.50PRB.bladerfx40.conf

@@ -17,7 +17,7 @@ eNBs =
     
     mobile_country_code =  "208";
     
-    mobile_network_code =  "93";
+    mobile_network_code =  "95";
     
        ////////// Physical parameters:
   
@@ -132,7 +132,7 @@ eNBs =
     };
         
     ////////// MME parameters:
-    mme_ip_address      = ( { ipv4       = "192.168.12.11";
+    mme_ip_address      = ( { ipv4       = "192.168.12.170";
                               ipv6       = "192:168:30::17";
                               active     = "yes";
                               preference = "ipv4";
@@ -142,10 +142,10 @@ eNBs =
     NETWORK_INTERFACES : 
     {
         ENB_INTERFACE_NAME_FOR_S1_MME            = "eth0";
-        ENB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.12.215/24";
+        ENB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.12.241/24";
 
         ENB_INTERFACE_NAME_FOR_S1U               = "eth0";
-        ENB_IPV4_ADDRESS_FOR_S1U                 = "192.168.12.215/24";
+        ENB_IPV4_ADDRESS_FOR_S1U                 = "192.168.12.241/24";
         ENB_PORT_FOR_S1U                         = 2152; # Spec 2152
     };
     

targets/SIMU/USER/oaisim.c

@@ -615,10 +615,20 @@ l2l1_task (void *args_p)
   }
 
 #endif
+  module_id_t enb_id;
+  module_id_t UE_id;
+  for (enb_id = 0; enb_id < NB_eNB_INST; enb_id++)
+    mac_xface->mrbch_phy_sync_failure (enb_id, 0, enb_id);
+  
+  if (abstraction_flag == 1) {
+    for (UE_id = 0; UE_id < NB_UE_INST; UE_id++)
+      mac_xface->dl_phy_sync_success (UE_id, 0, 0,1);   //UE_id%NB_eNB_INST);
+  }
+  
   start_meas (&oaisim_stats);
 
   for (frame = 0;
-       (l2l1_state != L2L1_TERMINATED) &&
+       (l2l1_state != L2L1_TERMINATED) && 
 	 ((oai_emulation.info.n_frames_flag == 0) ||
 	  (frame < oai_emulation.info.n_frames));
        frame++) {
@@ -682,8 +692,7 @@ l2l1_task (void *args_p)
     //oai_emulation.info.time_ms += 1;
     oai_emulation.info.time_s += 0.01; // emu time in s, each frame lasts for 10 ms // JNote: TODO check the coherency of the time and frame (I corrected it to 10 (instead of 0.01)
 
-    update_omg (frame); // frequency is defined in the omg_global params configurable by the user
-
+     update_omg (frame); // frequency is defined in the omg_global params configurable by the user
     update_omg_ocm ();
 
 #ifdef OPENAIR2
@@ -754,7 +763,7 @@ l2l1_task (void *args_p)
               LOG_D(EMU,
                     "PHY procedures eNB %d for frame %d, slot %d (subframe TX %d, RX %d) TDD %d/%d Nid_cell %d\n",
                     eNB_inst,
-                    frame % MAX_FRAME_NUMBER,
+                    frame%MAX_FRAME_NUMBER,
                     slot,
                     PHY_vars_eNB_g[eNB_inst][0]->proc[slot >> 1].subframe_tx,
                     PHY_vars_eNB_g[eNB_inst][0]->proc[slot >> 1].subframe_rx,
@@ -844,7 +853,6 @@ l2l1_task (void *args_p)
                     PHY_vars_UE_g[UE_inst][0]->frame_tx = frame % MAX_FRAME_NUMBER;
                   else
                     PHY_vars_UE_g[UE_inst][0]->frame_tx = (frame + 1) % MAX_FRAME_NUMBER;
-
 #ifdef OPENAIR2
                   //Application
                   update_otg_UE (UE_inst, oai_emulation.info.time_ms);
@@ -902,7 +910,7 @@ l2l1_task (void *args_p)
 
               if(last_slot==2 && frame%10==0) {
                 if (UE_stats_th[UE_inst]) {
-                  fprintf(UE_stats_th[UE_inst],"%d %d\n",frame % MAX_FRAME_NUMBER, PHY_vars_UE_g[UE_inst][0]->bitrate[0]/1000);
+                  fprintf(UE_stats_th[UE_inst],"%d %d\n",frame%MAX_FRAME_NUMBER, PHY_vars_UE_g[UE_inst][0]->bitrate[0]/1000);
                 }
               }
 

targets/SIMU/USER/oaisim_functions.c

@@ -1107,14 +1107,6 @@ void init_openair2(void)
              oai_emulation.info.cba_group_active,
              oai_emulation.info.handover_active);
 
-  for (enb_id = 0; enb_id < NB_eNB_INST; enb_id++)
-    mac_xface->mrbch_phy_sync_failure (enb_id, 0, enb_id);
-
-  if (abstraction_flag == 1) {
-    for (UE_id = 0; UE_id < NB_UE_INST; UE_id++)
-      mac_xface->dl_phy_sync_success (UE_id, 0, 0,1);   //UE_id%NB_eNB_INST);
-  }
-
   mac_xface->macphy_exit = exit_fun;
 
 #endif