integrate X2 code

openair2/COMMON/x2ap_messages_def.h

@@ -46,5 +46,6 @@ MESSAGE_DEF(X2AP_REGISTER_ENB_REQ          , MESSAGE_PRIORITY_MED, x2ap_register
 MESSAGE_DEF(X2AP_REGISTER_ENB_CNF          , MESSAGE_PRIORITY_MED, x2ap_register_enb_cnf_t          , x2ap_register_enb_cnf)
 MESSAGE_DEF(X2AP_DEREGISTERED_ENB_IND      , MESSAGE_PRIORITY_MED, x2ap_deregistered_enb_ind_t      , x2ap_deregistered_enb_ind)
 
-
-
+/* handover messages X2AP <-> RRC */
+MESSAGE_DEF(X2AP_HANDOVER_REQ              , MESSAGE_PRIORITY_MED, x2ap_handover_req_t              , x2ap_handover_req)
+MESSAGE_DEF(X2AP_HANDOVER_RESP             , MESSAGE_PRIORITY_MED, x2ap_handover_resp_t             , x2ap_handover_resp)

openair2/COMMON/x2ap_messages_types.h

@@ -30,10 +30,14 @@
 #ifndef X2AP_MESSAGES_TYPES_H_
 #define X2AP_MESSAGES_TYPES_H_
 
+#include "PhysCellId.h"
+
 //-------------------------------------------------------------------------------------------//
 // Defines to access message fields.
 
 #define X2AP_REGISTER_ENB_REQ(mSGpTR)           (mSGpTR)->ittiMsg.x2ap_register_enb_req
+#define X2AP_HANDOVER_REQ(mSGpTR)               (mSGpTR)->ittiMsg.x2ap_handover_req
+#define X2AP_HANDOVER_RESP(mSGpTR)               (mSGpTR)->ittiMsg.x2ap_handover_resp
 #define X2AP_REGISTER_ENB_CNF(mSGpTR)           (mSGpTR)->ittiMsg.x2ap_register_enb_cnf
 #define X2AP_DEREGISTERED_ENB_IND(mSGpTR)       (mSGpTR)->ittiMsg.x2ap_deregistered_enb_ind
 
@@ -105,4 +109,22 @@ typedef struct x2ap_deregistered_enb_ind_s {
   uint8_t          nb_x2;
 } x2ap_deregistered_enb_ind_t;
 
+//-------------------------------------------------------------------------------------------//
+// X2AP <-> RRC
+
+typedef struct x2ap_handover_req_s {
+  int source_rnti;                       /* TODO: to be fixed/remove */
+  int source_x2id;                       /* TODO: to be fixed/remove */
+  PhysCellId_t target_physCellId;
+  /* TODO: this parameter has to be removed */
+  int target_mod_id;
+} x2ap_handover_req_t;
+
+typedef struct x2ap_handover_resp_s {
+  int source_rnti;                       /* TODO: to be fixed/remove */
+  int source_x2id;                       /* TODO: to be fixed/remove */
+  /* TODO: this parameter has to be removed */
+  int target_mod_id;
+} x2ap_handover_resp_t;
+
 #endif /* X2AP_MESSAGES_TYPES_H_ */

openair2/RRC/LITE/MESSAGES/asn1_msg.c

@@ -165,7 +165,7 @@ int xer_sprint (char *string, size_t string_size, asn_TYPE_descriptor_t *td, voi
     er.encoded = string_buffer.string_size;
   } else {
     if (er.encoded > string_buffer.string_size) {
-      LOG_E(RRC, "xer_sprint string buffer too small, got %d need %d!", string_buffer.string_size, er.encoded);
+      //LOG_E(RRC, "xer_sprint string buffer too small, got %d need %d!", string_buffer.string_size, er.encoded);
       er.encoded = string_buffer.string_size;
     }
   }

openair2/RRC/LITE/defs.h

@@ -166,7 +166,11 @@ typedef enum HO_STATE_e {
   HO_MEASURMENT,
   HO_PREPARE,
   HO_CMD, // initiated by the src eNB
-  HO_COMPLETE // initiated by the target eNB
+  HO_COMPLETE, // initiated by the target eNB
+
+  HO_REQUEST,
+  HO_ACK,
+  HO_CONFIGURED,
 } HO_STATE_t;
 
 //#define NUMBER_OF_UE_MAX MAX_MOBILES_PER_RG
@@ -235,8 +239,8 @@ typedef struct e_rab_param_s {
 
 /* Intermediate structure for Handover management. Associated per-UE in eNB_RRC_INST */
 typedef struct HANDOVER_INFO_s {
-  uint8_t ho_prepare;
-  uint8_t ho_complete;
+int ho_prepare, ho_complete;
+  HO_STATE_t state; //current state of handover
   uint8_t modid_s; //module_idP of serving cell
   uint8_t modid_t; //module_idP of target cell
   uint16_t ueid_s; //UE index in serving cell
@@ -245,6 +249,8 @@ typedef struct HANDOVER_INFO_s {
   AS_Context_t as_context; /* They are mandatory for HO */
   uint8_t buf[RRC_BUF_SIZE];  /* ASN.1 encoded handoverCommandMessage */
   int size;   /* size of above message in bytes */
+  /* TODO: to remove or not? */
+  int source_x2id;
 } HANDOVER_INFO;
 
 #define RRC_HEADER_SIZE_MAX 64

openair2/X2AP/x2ap_eNB.c

@@ -29,7 +29,7 @@
 
 /*! \file x2ap_eNB.c
  * \brief x2ap protocol for eNB
- * \author Navid Nikaein 
+ * \author Navid Nikaein
  * \date 2014 - 2015
  * \version 1.0
  * \company Eurecom
@@ -66,31 +66,39 @@ struct x2ap_eNB_data_s;
 RB_PROTOTYPE(x2ap_enb_map, x2ap_eNB_data_s, entry, x2ap_eNB_compare_assoc_id);
 
 static
-void x2ap_eNB_handle_register_eNB(instance_t instance, 
+void x2ap_eNB_handle_register_eNB(instance_t instance,
 				  x2ap_register_enb_req_t *x2ap_register_eNB);
 
-static 
+static
+void x2ap_eNB_handle_handover_req(instance_t instance,
+				  x2ap_handover_req_t *x2ap_handover_req);
+
+static
+void x2ap_eNB_handle_handover_resp(instance_t instance,
+				   x2ap_handover_resp_t *x2ap_handover_resp);
+
+static
 void x2ap_eNB_register_eNB(x2ap_eNB_instance_t *instance_p,
 			   net_ip_address_t    *target_eNB_ip_addr,
-			   net_ip_address_t    *local_ip_addr, 
+			   net_ip_address_t    *local_ip_addr,
 			   uint16_t             in_streams,
 			   uint16_t             out_streams);
 static
-void x2ap_eNB_handle_sctp_association_resp(instance_t instance, 
+void x2ap_eNB_handle_sctp_association_resp(instance_t instance,
 					   sctp_new_association_resp_t *sctp_new_association_resp);
 
 
 static
-void x2ap_eNB_handle_sctp_data_ind(instance_t instance, 
+void x2ap_eNB_handle_sctp_data_ind(instance_t instance,
 				   sctp_data_ind_t *sctp_data_ind) {
 
   int result;
 
   DevAssert(sctp_data_ind != NULL);
-  
+
   x2ap_eNB_handle_message(sctp_data_ind->assoc_id, sctp_data_ind->stream,
                           sctp_data_ind->buffer, sctp_data_ind->buffer_length);
-  
+
   result = itti_free(TASK_UNKNOWN, sctp_data_ind->buffer);
   AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
 
@@ -141,7 +149,7 @@ dump_trees();
               instance,
               sctp_new_association_resp->ulp_cnx_id);
 
-    x2ap_handle_x2_setup_message(x2ap_enb_data_p, 
+    x2ap_handle_x2_setup_message(x2ap_enb_data_p,
 				 sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN);
 
     return;
@@ -217,13 +225,13 @@ int x2ap_eNB_init_sctp (x2ap_eNB_instance_t *instance_p,
   // Create and alloc new message
   MessageDef                             *message;
   sctp_init_t                            *sctp_init  = NULL;
-  
+
   DevAssert(instance_p != NULL);
   DevAssert(local_ip_addr != NULL);
-  
+
   message = itti_alloc_new_message (TASK_X2AP, SCTP_INIT_MSG);
   sctp_init = &message->ittiMsg.sctp_init;
-  
+
   sctp_init->port = X2AP_PORT_NUMBER;
   sctp_init->ppid = X2AP_SCTP_PPID;
   sctp_init->ipv4 = 1;
@@ -243,11 +251,11 @@ int x2ap_eNB_init_sctp (x2ap_eNB_instance_t *instance_p,
    */
   sctp_init->nb_ipv6_addr = 0;
   sctp_init->ipv6_address[0] = "0:0:0:0:0:0:0:1";
-  
+
   return itti_send_msg_to_task (TASK_SCTP, instance_p->instance, message);
-  
+
 }
-  
+
 static void x2ap_eNB_register_eNB(x2ap_eNB_instance_t *instance_p,
                                   net_ip_address_t    *target_eNB_ip_address,
                                   net_ip_address_t    *local_ip_addr,
@@ -302,7 +310,7 @@ static void x2ap_eNB_register_eNB(x2ap_eNB_instance_t *instance_p,
 }
 
 static
-void x2ap_eNB_handle_register_eNB(instance_t instance, 
+void x2ap_eNB_handle_register_eNB(instance_t instance,
 				  x2ap_register_enb_req_t *x2ap_register_eNB)
 {
 
@@ -322,7 +330,7 @@ void x2ap_eNB_handle_register_eNB(instance_t instance,
     DevCheck(new_instance->mcc == x2ap_register_eNB->mcc, new_instance->mcc, x2ap_register_eNB->mcc, 0);
     DevCheck(new_instance->mnc == x2ap_register_eNB->mnc, new_instance->mnc, x2ap_register_eNB->mnc, 0);
 
-  } 
+  }
   else {
     new_instance = calloc(1, sizeof(x2ap_eNB_instance_t));
     DevAssert(new_instance != NULL);
@@ -351,11 +359,11 @@ void x2ap_eNB_handle_register_eNB(instance_t instance,
   DevCheck(x2ap_register_eNB->nb_x2 <= X2AP_MAX_NB_ENB_IP_ADDRESS,
            X2AP_MAX_NB_ENB_IP_ADDRESS, x2ap_register_eNB->nb_x2, 0);
 
-  
+
   /* Trying to connect to the provided list of eNB ip address */
- 
+
   for (index = 0; index < x2ap_register_eNB->nb_x2; index++) {
-      
+
     if (x2ap_register_eNB->target_enb_x2_ip_address[index].active == 1 ){
       X2AP_INFO("eNB[%d] eNB id %u acting as an initiator (client)\n",
 		instance, x2ap_register_eNB->eNB_id);
@@ -366,7 +374,7 @@ void x2ap_eNB_handle_register_eNB(instance_t instance,
 			    x2ap_register_eNB->sctp_out_streams);
     }
     else {
-      /* initiate the SCTP listener */ 
+      /* initiate the SCTP listener */
       if (x2ap_eNB_init_sctp(new_instance,&x2ap_register_eNB->enb_x2_ip_address) <  0 ) {
 	X2AP_ERROR ("Error while sending SCTP_INIT_MSG to SCTP \n");
 	return;
@@ -378,6 +386,64 @@ void x2ap_eNB_handle_register_eNB(instance_t instance,
 
 }
 
+/* TODO: remove this hack, it's to map rnti to X2 ID in the source eNB, only 1 UE supported */
+/* so we directly use index 0, no search no lock no nothing */
+int x2id_to_source_rnti[1];
+
+/* TODO: remove that, it's for the hack below */
+#include "enb_config.h"
+
+static
+void x2ap_eNB_handle_handover_req(instance_t instance,
+				  x2ap_handover_req_t *x2ap_handover_req)
+{
+  /* TODO: remove this hack (the goal is to find the correct
+   * eNodeB structure for the target) - we need a proper way for RRC
+   * and X2AP to identify eNodeBs
+   * RRC knows about mod_id and X2AP knows about eNB_id (eNB_ID in
+   * the configuration file)
+   * as far as I understand.. CROUX
+   */
+  x2ap_eNB_instance_t *instance_p;
+  x2ap_eNB_data_t     *target;
+  const Enb_properties_array_t *enb_properties = enb_config_get();
+  int target_enb_id = enb_properties->properties[x2ap_handover_req->target_mod_id]->eNB_id;
+
+  instance_p = x2ap_eNB_get_instance(instance);
+  DevAssert(instance_p != NULL);
+
+  target = x2ap_is_eNB_id_in_list(target_enb_id);
+  DevAssert(target != NULL);
+
+  /* store rnti at index 0 */
+  x2id_to_source_rnti[0] = x2ap_handover_req->source_rnti;
+  x2ap_eNB_generate_x2_handover_request(instance_p, target, 0);
+}
+
+static
+void x2ap_eNB_handle_handover_resp(instance_t instance,
+				   x2ap_handover_resp_t *x2ap_handover_resp)
+{
+  /* TODO: remove this hack (the goal is to find the correct
+   * eNodeB structure for the other end) - we need a proper way for RRC
+   * and X2AP to identify eNodeBs
+   * RRC knows about mod_id and X2AP knows about eNB_id (eNB_ID in
+   * the configuration file)
+   * as far as I understand.. CROUX
+   */
+  x2ap_eNB_instance_t *instance_p;
+  x2ap_eNB_data_t     *target;
+  const Enb_properties_array_t *enb_properties = enb_config_get();
+  int target_enb_id = enb_properties->properties[x2ap_handover_resp->target_mod_id]->eNB_id;
+
+  instance_p = x2ap_eNB_get_instance(instance);
+  DevAssert(instance_p != NULL);
+
+  target = x2ap_is_eNB_id_in_list(target_enb_id);
+  DevAssert(target != NULL);
+
+  x2ap_eNB_generate_x2_handover_response(instance_p, target, x2ap_handover_resp->source_x2id);
+}
 
 void *x2ap_task(void *arg)
 {
@@ -398,16 +464,26 @@ void *x2ap_task(void *arg)
       itti_exit_task();
       break;
 
-    case X2AP_REGISTER_ENB_REQ: 
+    case X2AP_REGISTER_ENB_REQ:
       x2ap_eNB_handle_register_eNB(ITTI_MESSAGE_GET_INSTANCE(received_msg),
                                    &X2AP_REGISTER_ENB_REQ(received_msg));
       break;
- 
-    case SCTP_NEW_ASSOCIATION_RESP: 
+
+    case X2AP_HANDOVER_REQ:
+      x2ap_eNB_handle_handover_req(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+                                   &X2AP_HANDOVER_REQ(received_msg));
+      break;
+
+    case X2AP_HANDOVER_RESP:
+      x2ap_eNB_handle_handover_resp(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+                                    &X2AP_HANDOVER_RESP(received_msg));
+      break;
+
+    case SCTP_NEW_ASSOCIATION_RESP:
       x2ap_eNB_handle_sctp_association_resp(ITTI_MESSAGE_GET_INSTANCE(received_msg),
 					    &received_msg->ittiMsg.sctp_new_association_resp);
       break;
-      
+
     case SCTP_NEW_ASSOCIATION_IND:
       x2ap_eNB_handle_sctp_association_ind(ITTI_MESSAGE_GET_INSTANCE(received_msg),
 					   &received_msg->ittiMsg.sctp_new_association_ind);

openair2/X2AP/x2ap_eNB_generate_messages.h

@@ -42,4 +42,13 @@ int x2ap_eNB_generate_x2_setup_failure ( uint32_t assoc_id,
 					 X2ap_Cause_PR cause_type,
 					 long cause_value,
 					 long time_to_waitx);
+
+int x2ap_eNB_generate_x2_handover_request(x2ap_eNB_instance_t *instance_p, 
+				          x2ap_eNB_data_t *x2ap_enb_data_p,
+                                          int source_x2id);
+
+int x2ap_eNB_generate_x2_handover_response(x2ap_eNB_instance_t *instance_p, 
+				           x2ap_eNB_data_t *x2ap_enb_data_p,
+                                           int source_x2id);
+
 #endif /*  X2AP_ENB_GENERATE_MESSAGES_H_ */

openair3/UTILS/conversions.h

@@ -206,8 +206,91 @@ do {						\
 	(bitstring)->buf[1] = (eci) >> 12;			\
 	(bitstring)->buf[2] = (eci) >> 4;			\
 	(bitstring)->buf[3] = (eci) << 4;		\
-}while(0)   
+}while(0)
+
+#define MMEGID_TO_OCTET_STRING(mmegid,octetstring)        \
+do {                                \
+    (octetstring)->size=2;                    \
+    (octetstring)->buf=calloc (2, sizeof (uint8_t));    \
+    (octetstring)->buf[0] = (mmegid) >> 8;             \
+    (octetstring)->buf[1] = (mmegid);            \
+}while(0)
+
+#define MMEC_TO_OCTET_STRING(mmec, octetstring)        \
+do {                            \
+    (octetstring)->size=1;                \
+    (octetstring)->buf=calloc (1, sizeof (uint8_t));\
+    (octetstring)->buf[0] = (mmec);            \
+}while(0)
+
+#define ENCRALG_TO_BIT_STRING(encralg, bitstring)    \
+    do {                        \
+    (bitstring)->size=2;                \
+    (bitstring)->bits_unused=0;            \
+    (bitstring)->buf=calloc (1, sizeof (uint8_t));    \
+    (bitstring)->buf[0] = (encralg) >> 8;         \
+    (bitstring)->buf[1] = (encralg);        \
+    }while(0)
 
+#define INTPROTALG_TO_BIT_STRING(intprotalg, bitstring)    \
+do {                                \
+    (bitstring)->size=2;                    \
+    (bitstring)->bits_unused=0;                \
+    (bitstring)->buf=calloc (2, sizeof (uint8_t));        \
+    (bitstring)->buf[0] = (intprotalg) >> 8;         \
+    (bitstring)->buf[1] = (intprotalg);            \
+}while(0)
+
+#define KENB_STAR_TO_BIT_STRING(kenbstar, bitstring)    \
+do {                            \
+    (bitstring)->size=32;                \
+    (bitstring)->bits_unused=0;            \
+    (bitstring)->buf= calloc (32, sizeof (uint8_t));\
+    memcpy((bitstring)->buf, kenbstar, 32*sizeof(uint8_t));            \
+}while(0)
+
+#define UEAGMAXBITRTD_TO_ASN_PRIMITIVES(uegmaxbitrtd, asnprimitives)        \
+do {                                         \
+    (asnprimitives)->size=5;                        \
+    (asnprimitives)->buf=calloc (5, sizeof (uint8_t));            \
+    (asnprimitives)->buf[0] = (uegmaxbitrtd) >> 32;                \
+    (asnprimitives)->buf[1] = (uegmaxbitrtd) >> 24;                \
+    (asnprimitives)->buf[2] = (uegmaxbitrtd) >> 16;                \
+    (asnprimitives)->buf[3] = (uegmaxbitrtd) >> 8;                \
+    (asnprimitives)->buf[4] = (uegmaxbitrtd);                \
+ }while(0)
+
+#define UEAGMAXBITRTU_TO_ASN_PRIMITIVES(uegmaxbitrtu, asnprimitives)        \
+do {                                         \
+    (asnprimitives)->size=5;                        \
+    (asnprimitives)->buf=calloc (5, sizeof (uint8_t));            \
+    (asnprimitives)->buf[0] = (uegmaxbitrtu) >> 32;                \
+    (asnprimitives)->buf[1] = (uegmaxbitrtu) >> 24;                \
+    (asnprimitives)->buf[2] = (uegmaxbitrtu) >> 16;                \
+    (asnprimitives)->buf[3] = (uegmaxbitrtu) >> 8;                \
+    (asnprimitives)->buf[4] = (uegmaxbitrtu);                \
+ }while(0)
+
+#define TRLA_TO_BIT_STRING(trla, bitstring)        \
+do {                            \
+    (bitstring)->size=4;                \
+    (bitstring)->bits_unused=0;            \
+    (bitstring)->buf=calloc (4, sizeof (uint8_t));  \
+    (bitstring)->buf[0] = (trla)>>24;              \
+    (bitstring)->buf[1] = (trla)>>16;           \
+    (bitstring)->buf[2] = (trla)>>8;           \
+    (bitstring)->buf[3] = (trla);           \
+}while(0)
+
+#define GTP_TEID_TO_OCTET_STRING(gtpteid, octetstring)    \
+do {                            \
+    (octetstring)->size=4;                \
+    (octetstring)->buf=calloc (4, sizeof (uint8_t));\
+    (octetstring)->buf[0] = (gtpteid)>>24;          \
+    (octetstring)->buf[1] = (gtpteid)>>16;       \
+    (octetstring)->buf[2] = (gtpteid)>>8;       \
+    (octetstring)->buf[3] = (gtpteid);           \
+}while(0)
 
 #define TAC_TO_OCTET_STRING(tac, octetstring)\
 do {						\