commit new itti code

common/utils/ocp_itti/all_msg.h

+#include "openair2/COMMON/phy_messages_def.h"
+#include "openair2/COMMON/mac_messages_def.h"
+#include "openair2/COMMON/rlc_messages_def.h"
+#include "openair2/COMMON/pdcp_messages_def.h"
+#include "openair2/COMMON/rrc_messages_def.h"
+#include "openair2/COMMON/nas_messages_def.h"
+#if ENABLE_RAL
+  #include "openair2/COMMON/ral_messages_def.h"
+#endif
+#include "openair2/COMMON/s1ap_messages_def.h"
+#include "openair2/COMMON/x2ap_messages_def.h"
+#include "openair2/COMMON/sctp_messages_def.h"
+#include "openair2/COMMON/udp_messages_def.h"
+#include "openair2/COMMON/gtpv1_u_messages_def.h"

common/utils/ocp_itti/intertask_interface.cpp

+/*
+  Author: Laurent THOMAS, Open Cells
+  copyleft: OpenAirInterface Software Alliance
+*/
+#include <vector>
+#include <map>
+#include <sys/eventfd.h>
+
+
+#include <intertask_interface.h>
+
+typedef struct timer_elm_s {
+  timer_type_t      type;     ///< Timer type
+  long              instance;
+  long duration;
+  uint64_t timeout;
+  void              *timer_arg; ///< Optional argument that will be passed when timer expires
+} timer_elm_t ;
+
+typedef struct task_list_s {
+  task_info_t admin;
+  pthread_t thread;
+  pthread_mutex_t queue_cond_lock;
+  std::vector<MessageDef *> message_queue;
+  std::map<long,timer_elm_t> timer_map;
+  uint64_t next_timer=UINT64_MAX;
+  struct epoll_event  *events =NULL;
+  int nb_fd_epoll=0;
+  int nb_events=0;
+  int epoll_fd=-1;
+  int sem_fd=-1;
+} task_list_t;
+
+int timer_expired(int fd);
+task_list_t tasks[TASK_MAX];
+
+extern "C" {
+  void *pool_buffer_init (void) {
+    return 0;
+  }
+
+  void *pool_buffer_clean (void *arg) {
+    //-----------------------------------------------------------------------------
+    return 0;
+  }
+
+  void free_mem_block (mem_block_t *leP, const char *caller) {
+    AssertFatal(leP!=NULL,"");
+    free(leP);
+  }
+
+  mem_block_t *get_free_mem_block (uint32_t sizeP, const char *caller) {
+    mem_block_t *ptr=(mem_block_t *)malloc(sizeP+sizeof(mem_block_t));
+    ptr->data=((unsigned char *)ptr)+sizeof(mem_block_t);
+    ptr->size=sizeP;
+    return ptr;
+  }
+
+  void *itti_malloc(task_id_t origin_task_id, task_id_t destination_task_id, ssize_t size) {
+    void *ptr = NULL;
+    AssertFatal ((ptr=malloc (size)) != NULL, "Memory allocation of %zu bytes failed (%d -> %d)!\n",
+                 size, origin_task_id, destination_task_id);
+    return ptr;
+  }
+
+  int itti_free(task_id_t task_id, void *ptr) {
+    AssertFatal (ptr != NULL, "Trying to free a NULL pointer (%d)!\n", task_id);
+    free (ptr);
+    return (EXIT_SUCCESS);
+  }
+
+  MessageDef *itti_alloc_new_message_sized(task_id_t origin_task_id, MessagesIds message_id, MessageHeaderSize size) {
+    MessageDef *temp = (MessageDef *)itti_malloc (origin_task_id, TASK_UNKNOWN, sizeof(MessageHeader) + size);
+    temp->ittiMsgHeader.messageId = message_id;
+    temp->ittiMsgHeader.originTaskId = origin_task_id;
+    temp->ittiMsgHeader.ittiMsgSize = size;
+    return temp;
+  }
+
+  MessageDef *itti_alloc_new_message(task_id_t origin_task_id, MessagesIds message_id) {
+    int size=sizeof(MessageHeader) + messages_info[message_id].size;
+    MessageDef *temp = (MessageDef *)itti_malloc (origin_task_id, TASK_UNKNOWN, size);
+    temp->ittiMsgHeader.messageId = message_id;
+    temp->ittiMsgHeader.originTaskId = origin_task_id;
+    temp->ittiMsgHeader.ittiMsgSize = size;
+    return temp;
+    //return itti_alloc_new_message_sized(origin_task_id, message_id, messages_info[message_id].size);
+  }
+
+  static inline int itti_send_msg_to_task_locked(task_id_t destination_task_id, instance_t instance, MessageDef *message) {
+    task_list_t *t=tasks+destination_task_id;
+    message->ittiMsgHeader.destinationTaskId = destination_task_id;
+    message->ittiMsgHeader.instance = instance;
+    message->ittiMsgHeader.lte_time.frame = 0;
+    message->ittiMsgHeader.lte_time.slot = 0;
+    int message_id = message->ittiMsgHeader.messageId;
+    size_t s=t->message_queue.size();
+
+    if ( s > t->admin.queue_size )
+      LOG_E(TMR,"Queue for %s task contains %ld messages\n", itti_get_task_name(destination_task_id), s );
+
+    if ( s > 50 )
+      LOG_I(TMR,"Queue for %s task size: %ld\n",itti_get_task_name(destination_task_id), s+1);
+
+    t->message_queue.insert(t->message_queue.begin(), message);
+    eventfd_t sem_counter = 1;
+    AssertFatal ( sizeof(sem_counter) == write(t->sem_fd, &sem_counter, sizeof(sem_counter)), "");
+    LOG_D(TMR,"sent messages id=%d to %s\n",message_id, t->admin.name);
+    return 0;
+  }
+
+  int itti_send_msg_to_task(task_id_t destination_task_id, instance_t instance, MessageDef *message) {
+    task_list_t *t=&tasks[destination_task_id];
+    pthread_mutex_lock (&t->queue_cond_lock);
+    int ret=itti_send_msg_to_task_locked(destination_task_id, instance, message);
+    pthread_mutex_unlock (&t->queue_cond_lock);
+
+    while ( t->message_queue.size()>0 && t->admin.func != NULL )
+      t->admin.func(NULL);
+
+    return ret;
+  }
+
+  void itti_subscribe_event_fd(task_id_t task_id, int fd) {
+    struct epoll_event event;
+    task_list_t *t=&tasks[task_id];
+    t->nb_fd_epoll++;
+    t->events = (struct epoll_event *)realloc((void *)t->events,
+                t->nb_fd_epoll * sizeof(struct epoll_event));
+    event.events  = EPOLLIN | EPOLLERR;
+    event.data.u64 = 0;
+    event.data.fd  = fd;
+    AssertFatal(epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD, fd, &event) == 0,
+                "epoll_ctl (EPOLL_CTL_ADD) failed for task %s, fd %d: %s!\n",
+                itti_get_task_name(task_id), fd, strerror(errno));
+  }
+
+  void itti_unsubscribe_event_fd(task_id_t task_id, int fd) {
+    task_list_t *t=&tasks[task_id];
+    AssertFatal (epoll_ctl(t->epoll_fd, EPOLL_CTL_DEL, fd, NULL) == 0,
+                 "epoll_ctl (EPOLL_CTL_DEL) failed for task %s, fd %d: %s!\n",
+                 itti_get_task_name(task_id), fd, strerror(errno));
+    t->nb_fd_epoll--;
+  }
+
+  static inline int itti_get_events_locked(task_id_t task_id, struct epoll_event **events) {
+    task_list_t *t=&tasks[task_id];
+    uint64_t current_time=0;
+
+    do {
+      if ( t->next_timer != UINT64_MAX ) {
+        struct timespec tp;
+        clock_gettime(CLOCK_MONOTONIC, &tp);
+        current_time=(uint64_t)tp.tv_sec*1000+tp.tv_nsec/(1000*1000);
+
+        if ( t->next_timer < current_time) {
+          t->next_timer=UINT64_MAX;
+
+          // Proceed expired timer
+          for ( auto it=t->timer_map.begin() ; it != t->timer_map.end() ; ++it ) {
+            if ( it->second.timeout < current_time ) {
+              MessageDef *message = itti_alloc_new_message(TASK_TIMER, TIMER_HAS_EXPIRED);
+              message->ittiMsg.timer_has_expired.timer_id=it->first;
+              message->ittiMsg.timer_has_expired.arg=it->second.timer_arg;
+
+              if (itti_send_msg_to_task_locked(task_id, it->second.instance, message) < 0) {
+                LOG_W(TMR,"Failed to send msg TIMER_HAS_EXPIRED to task %u\n", task_id);
+                free(message);
+                t->timer_map.erase(it);
+                return -1;
+              }
+
+              if ( it->second.type==TIMER_PERIODIC ) {
+                it->second.timeout+=it->second.duration;
+
+                if (it->second.timeout < t->next_timer)
+                  t->next_timer=it->second.timeout;
+              } else
+                t->timer_map.erase(it);
+            } else if (it->second.timeout < t->next_timer)
+              t->next_timer=it->second.timeout;
+          }
+        }
+      }
+
+      int epoll_timeout = -1;
+
+      if ( t->next_timer != UINT64_MAX )
+        epoll_timeout = t->next_timer-current_time;
+
+      pthread_mutex_unlock(&t->queue_cond_lock);
+      LOG_D(TMR,"enter blocking wait for %s\n", itti_get_task_name(task_id));
+      t->nb_events = epoll_wait(t->epoll_fd,t->events,t->nb_fd_epoll, epoll_timeout);
+    } while (t->nb_events  < 0 && (errno == EINTR || errno == EAGAIN ) );
+
+    AssertFatal (t->nb_events >=0,
+                 "epoll_wait failed for task %s, nb fds %d, timeout %lu: %s!\n",
+                 itti_get_task_name(task_id), t->nb_fd_epoll, t->next_timer != UINT64_MAX ? t->next_timer-current_time : -1, strerror(errno));
+    LOG_D(TMR,"receive on %d descriptors for %s\n", t->nb_events, itti_get_task_name(task_id));
+
+    if (t->nb_events == 0)
+      /* No data to read -> return */
+      return 0;
+
+    for (int i = 0; i < t->nb_events; i++) {
+      /* Check if there is an event for ITTI for the event fd */
+      if ((t->events[i].events & EPOLLIN) &&
+          (t->events[i].data.fd == t->sem_fd)) {
+        eventfd_t   sem_counter;
+        /* Read will always return 1 */
+        AssertFatal( sizeof(sem_counter) == read (t->sem_fd, &sem_counter, sizeof(sem_counter)), "");
+        /* Mark that the event has been processed */
+        t->events[i].events &= ~EPOLLIN;
+      }
+    }
+
+    *events = t->events;
+    return t->nb_events;
+  }
+
+  int itti_get_events(task_id_t task_id, struct epoll_event **events) {
+    pthread_mutex_lock(&tasks[task_id].queue_cond_lock);
+    return itti_get_events_locked(task_id, events);
+  }
+
+  void itti_receive_msg(task_id_t task_id, MessageDef **received_msg) {
+    // Reception of one message, blocking caller
+    task_list_t *t=&tasks[task_id];
+    pthread_mutex_lock(&t->queue_cond_lock);
+
+    // Weird condition to deal with crap legacy itti interface
+    if ( t->nb_fd_epoll == 1 ) {
+      while (t->message_queue.empty()) {
+        itti_get_events_locked(task_id, &t->events);
+        pthread_mutex_lock(&t->queue_cond_lock);
+      }
+    } else {
+      if (t->message_queue.empty()) {
+        itti_get_events_locked(task_id, &t->events);
+        pthread_mutex_lock(&t->queue_cond_lock);
+      }
+    }
+
+    // Legacy design: we return even if we have no message
+    // in this case, *received_msg is NULL
+    if (t->message_queue.empty()) {
+      *received_msg=NULL;
+      LOG_D(TMR,"task %s received even from other fd (total fds: %d), returning msg NULL\n",t->admin.name, t->nb_fd_epoll);
+    } else {
+      *received_msg=t->message_queue.back();
+      t->message_queue.pop_back();
+      LOG_D(TMR,"task %s received a message\n",t->admin.name);
+    }
+
+    pthread_mutex_unlock (&t->queue_cond_lock);
+  }
+
+  void itti_poll_msg(task_id_t task_id, MessageDef **received_msg) {
+    //reception of one message, non-blocking
+    task_list_t *t=&tasks[task_id];
+    pthread_mutex_lock(&t->queue_cond_lock);
+
+    if (!t->message_queue.empty()) {
+      LOG_D(TMR,"task %s received a message in polling mode\n",t->admin.name);
+      *received_msg=t->message_queue.back();
+      t->message_queue.pop_back();
+    } else
+      *received_msg=NULL;
+
+    pthread_mutex_unlock (&t->queue_cond_lock);
+  }
+
+  int itti_create_task(task_id_t task_id, void *(*start_routine)(void *), void *args_p) {
+    task_list_t *t=&tasks[task_id];
+    AssertFatal ( pthread_create (&t->thread, NULL, start_routine, args_p) ==0,
+                  "Thread creation for task %d failed!\n", task_id);
+    pthread_setname_np( t->thread, itti_get_task_name(task_id) );
+    LOG_I(TMR,"Created Posix thread %s\n",  itti_get_task_name(task_id) );
+    return 0;
+  }
+
+  void itti_exit_task(void) {
+    pthread_exit (NULL);
+  }
+
+  void itti_terminate_tasks(task_id_t task_id) {
+    // Sends Terminate signals to all tasks.
+    itti_send_terminate_message (task_id);
+    pthread_exit (NULL);
+  }
+
+  int itti_init(task_id_t task_max, thread_id_t thread_max, MessagesIds messages_id_max, const task_info_t *tasks_info,
+                const message_info_t *messages_info) {
+    AssertFatal(TASK_MAX<UINT16_MAX, "Max itti tasks");
+
+    for(int i=0; i<task_max; ++i) {
+      LOG_I(TMR,"Starting itti queue: %s as task %d\n", tasks_info[i].name, i);
+      pthread_mutex_init(&tasks[i].queue_cond_lock, NULL);
+      memcpy(&tasks[i].admin, &tasks_info[i], sizeof(task_info_t));
+      AssertFatal( ( tasks[i].epoll_fd = epoll_create1(0) ) >=0, "");
+      AssertFatal( ( tasks[i].sem_fd = eventfd(0, EFD_SEMAPHORE) ) >=0, "");
+      itti_subscribe_event_fd((task_id_t)i, tasks[i].sem_fd);
+
+      if (tasks[i].admin.threadFunc != NULL)
+        itti_create_task((task_id_t)i, tasks[i].admin.threadFunc, NULL);
+    }
+
+    return 0;
+  }
+
+  int timer_setup(
+    uint32_t      interval_sec,
+    uint32_t      interval_us,
+    task_id_t     task_id,
+    int32_t       instance,
+    timer_type_t  type,
+    void         *timer_arg,
+    long         *timer_id) {
+    task_list_t *t=&tasks[task_id];
+
+    do {
+      // set the taskid in the timer id to keep compatible with the legacy API
+      // timer_remove() takes only the timer id as parameter
+      *timer_id=(random()%UINT16_MAX) << 16 | task_id ;
+    } while ( t->timer_map.find(*timer_id) != t->timer_map.end());
+
+    /* Allocate new timer list element */
+    timer_elm_t timer;
+    struct timespec tp;
+    clock_gettime(CLOCK_MONOTONIC, &tp);
+
+    if (interval_us%1000 != 0)
+      LOG_W(TMR, "Can't set timer precision below 1ms, rounding it\n");
+
+    timer.duration  = interval_sec*1000+interval_us/1000;
+    timer.timeout= ((uint64_t)tp.tv_sec*1000+tp.tv_nsec/(1000*1000)+timer.duration);
+    timer.instance  = instance;
+    timer.type      = type;
+    timer.timer_arg = timer_arg;
+    pthread_mutex_lock (&t->queue_cond_lock);
+    t->timer_map[*timer_id]= timer;
+
+    if (timer.timeout < t->next_timer)
+      t->next_timer=timer.timeout;
+
+    eventfd_t sem_counter = 1;
+    AssertFatal ( sizeof(sem_counter) == write(t->sem_fd, &sem_counter, sizeof(sem_counter)), "");
+    pthread_mutex_unlock (&t->queue_cond_lock);
+    return 0;
+  }
+
+  int timer_remove(long timer_id) {
+    task_id_t task_id=(task_id_t)(timer_id&0xffff);
+    int ret;
+    pthread_mutex_lock (&tasks[task_id].queue_cond_lock);
+    ret=tasks[task_id].timer_map.erase(timer_id);
+    pthread_mutex_unlock (&tasks[task_id].queue_cond_lock);
+
+    if (ret==1)
+      return 0;
+    else {
+      LOG_W(TMR, "tried to remove a non existing timer\n");
+      return 1;
+    }
+  }
+
+  const char *itti_get_message_name(MessagesIds message_id) {
+    return messages_info[message_id].name;
+  }
+
+  const char *itti_get_task_name(task_id_t task_id) {
+    return tasks[task_id].admin.name;
+  }
+
+  // void for compatibility
+  void itti_send_terminate_message(task_id_t task_id) {
+  }
+
+  void itti_wait_tasks_end(void) {
+    while(1)
+      sleep(24*3600);
+  }
+
+  void itti_update_lte_time(uint32_t frame, uint8_t slot) {}
+  void itti_set_task_real_time(task_id_t task_id) {}
+  void itti_mark_task_ready(task_id_t task_id) {
+    // Function meaning is clear, but legacy implementation is wrong
+    // keep it void is fine: today implementation accepts messages in the queue before task is ready
+  }
+  void itti_wait_ready(int wait_tasks) {
+    // Stupid function, kept for compatibility (the parameter is meaningless!!!)
+  }
+  int signal_mask(void) { return 0;}
+}

common/utils/ocp_itti/intertask_interface.h

+/*
+  Author: Laurent THOMAS, Open Cells
+  Copyleft: OpenAirInterface software alliance
+*/
+#ifndef INTERTASK_INTERFACE_H_
+#define INTERTASK_INTERFACE_H_
+#include <stdint.h>
+#include <sys/epoll.h>
+
+#include <mem_block.h>
+#include <assertions.h>
+
+
+typedef enum timer_type_s {
+  TIMER_PERIODIC,
+  TIMER_ONE_SHOT,
+  TIMER_TYPE_MAX,
+} timer_type_t;
+
+typedef struct {
+  void *arg;
+  long  timer_id;
+} timer_has_expired_t;
+
+typedef struct {
+  uint32_t      interval_sec;
+  uint32_t      interval_us;
+  long     task_id;
+  int32_t       instance;
+  timer_type_t  type;
+  void         *timer_arg;
+  long          timer_id;
+} timer_create_t;
+
+typedef struct {
+  long     task_id;
+  long          timer_id;
+} timer_delete_t;
+
+
+typedef struct itti_lte_time_s {
+  uint32_t frame;
+  uint8_t slot;
+} itti_lte_time_t;
+
+
+typedef struct IttiMsgEmpty_s {
+} IttiMsgEmpty;
+
+typedef struct IttiMsgText_s {
+  uint32_t  size;
+  char      text[];
+} IttiMsgText;
+
+#include <openair2/COMMON/phy_messages_types.h>
+#include <openair2/COMMON/mac_messages_types.h>
+#include <openair2/COMMON/rlc_messages_types.h>
+#include <openair2/COMMON/pdcp_messages_types.h>
+#include <openair2/COMMON/networkDef.h>
+#include <openair2/COMMON/as_message.h>
+#include <openair2/RRC/LTE/rrc_types.h>
+#include <openair2/COMMON/rrc_messages_types.h>
+
+#include <openair3/NAS/COMMON/UTIL/OctetString.h>
+#include <openair3/NAS/COMMON/IES/AccessPointName.h>
+#include <openair3/NAS/COMMON/IES/AdditionalUpdateResult.h>
+#include <openair3/NAS/COMMON/IES/AdditionalUpdateType.h>
+#include <openair3/NAS/COMMON/IES/ApnAggregateMaximumBitRate.h>
+#include <openair3/NAS/COMMON/IES/AuthenticationFailureParameter.h>
+#include <openair3/NAS/COMMON/IES/AuthenticationParameterAutn.h>
+#include <openair3/NAS/COMMON/IES/AuthenticationParameterRand.h>
+#include <openair3/NAS/COMMON/IES/AuthenticationResponseParameter.h>
+#include <openair3/NAS/COMMON/IES/CipheringKeySequenceNumber.h>
+#include <openair3/NAS/COMMON/IES/Cli.h>
+#include <openair3/NAS/COMMON/IES/CsfbResponse.h>
+#include <openair3/NAS/COMMON/IES/DaylightSavingTime.h>
+#include <openair3/NAS/COMMON/IES/DetachType.h>
+#include <openair3/NAS/COMMON/IES/DrxParameter.h>
+#include <openair3/NAS/COMMON/IES/EmergencyNumberList.h>
+#include <openair3/NAS/COMMON/IES/EmmCause.h>
+#include <openair3/NAS/COMMON/IES/EpsAttachResult.h>
+#include <openair3/NAS/COMMON/IES/EpsAttachType.h>
+#include <openair3/NAS/COMMON/IES/EpsBearerContextStatus.h>
+#include <openair3/NAS/COMMON/IES/EpsBearerIdentity.h>
+#include <openair3/NAS/COMMON/IES/EpsMobileIdentity.h>
+#include <openair3/NAS/COMMON/IES/EpsNetworkFeatureSupport.h>
+#include <openair3/NAS/COMMON/IES/EpsQualityOfService.h>
+#include <openair3/NAS/COMMON/IES/EpsUpdateResult.h>
+#include <openair3/NAS/COMMON/IES/EpsUpdateType.h>
+#include <openair3/NAS/COMMON/IES/EsmCause.h>
+#include <openair3/NAS/COMMON/IES/EsmInformationTransferFlag.h>
+#include <openair3/NAS/COMMON/IES/EsmMessageContainer.h>
+#include <openair3/NAS/COMMON/IES/GprsTimer.h>
+#include <openair3/NAS/COMMON/IES/GutiType.h>
+#include <openair3/NAS/COMMON/IES/IdentityType2.h>
+#include <openair3/NAS/COMMON/IES/ImeisvRequest.h>
+#include <openair3/NAS/COMMON/IES/KsiAndSequenceNumber.h>
+#include <openair3/NAS/COMMON/IES/LcsClientIdentity.h>
+#include <openair3/NAS/COMMON/IES/LcsIndicator.h>
+#include <openair3/NAS/COMMON/IES/LinkedEpsBearerIdentity.h>
+#include <openair3/NAS/COMMON/IES/LlcServiceAccessPointIdentifier.h>
+#include <openair3/NAS/COMMON/IES/LocationAreaIdentification.h>
+#include <openair3/NAS/COMMON/IES/MessageType.h>
+#include <openair3/NAS/COMMON/IES/MobileIdentity.h>
+#include <openair3/NAS/COMMON/IES/MobileStationClassmark2.h>
+#include <openair3/NAS/COMMON/IES/MobileStationClassmark3.h>
+#include <openair3/NAS/COMMON/IES/MsNetworkCapability.h>
+#include <openair3/NAS/COMMON/IES/MsNetworkFeatureSupport.h>
+#include <openair3/NAS/COMMON/IES/NasKeySetIdentifier.h>
+#include <openair3/NAS/COMMON/IES/NasMessageContainer.h>
+#include <openair3/NAS/COMMON/IES/NasRequestType.h>
+#include <openair3/NAS/COMMON/IES/NasSecurityAlgorithms.h>
+#include <openair3/NAS/COMMON/IES/NetworkName.h>
+#include <openair3/NAS/COMMON/IES/Nonce.h>
+#include <openair3/NAS/COMMON/IES/PacketFlowIdentifier.h>
+#include <openair3/NAS/COMMON/IES/PagingIdentity.h>
+#include <openair3/NAS/COMMON/IES/PdnAddress.h>
+#include <openair3/NAS/COMMON/IES/PdnType.h>
+#include <openair3/NAS/COMMON/IES/PlmnList.h>
+#include <openair3/NAS/COMMON/IES/ProcedureTransactionIdentity.h>
+#include <openair3/NAS/COMMON/IES/ProtocolConfigurationOptions.h>
+#include <openair3/NAS/COMMON/IES/ProtocolDiscriminator.h>
+#include <openair3/NAS/COMMON/IES/PTmsiSignature.h>
+#include <openair3/NAS/COMMON/IES/QualityOfService.h>
+#include <openair3/NAS/COMMON/IES/RadioPriority.h>
+#include <openair3/NAS/COMMON/IES/SecurityHeaderType.h>
+#include <openair3/NAS/COMMON/IES/ServiceType.h>
+#include <openair3/NAS/COMMON/IES/ShortMac.h>
+#include <openair3/NAS/COMMON/IES/SsCode.h>
+#include <openair3/NAS/COMMON/IES/SupportedCodecList.h>
+#include <openair3/NAS/COMMON/IES/TimeZoneAndTime.h>
+#include <openair3/NAS/COMMON/IES/TimeZone.h>
+#include <openair3/NAS/COMMON/IES/TmsiStatus.h>
+#include <openair3/NAS/COMMON/IES/TrackingAreaIdentity.h>
+#include <openair3/NAS/COMMON/IES/TrackingAreaIdentityList.h>
+#include <openair3/NAS/COMMON/IES/TrafficFlowAggregateDescription.h>
+#include <openair3/NAS/COMMON/IES/TrafficFlowTemplate.h>
+#include <openair3/NAS/COMMON/IES/TransactionIdentifier.h>
+#include <openair3/NAS/COMMON/IES/UeNetworkCapability.h>
+#include <openair3/NAS/COMMON/IES/UeRadioCapabilityInformationUpdateNeeded.h>
+#include <openair3/NAS/COMMON/IES/UeSecurityCapability.h>
+#include <openair3/NAS/COMMON/IES/VoiceDomainPreferenceAndUeUsageSetting.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ActivateDedicatedEpsBearerContextAccept.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ActivateDedicatedEpsBearerContextReject.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ActivateDedicatedEpsBearerContextRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ActivateDefaultEpsBearerContextAccept.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ActivateDefaultEpsBearerContextReject.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ActivateDefaultEpsBearerContextRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/BearerResourceAllocationReject.h>
+#include <openair3/NAS/COMMON/ESM/MSG/BearerResourceAllocationRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/BearerResourceModificationReject.h>
+#include <openair3/NAS/COMMON/ESM/MSG/BearerResourceModificationRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/DeactivateEpsBearerContextAccept.h>
+#include <openair3/NAS/COMMON/ESM/MSG/DeactivateEpsBearerContextRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/esm_cause.h>
+#include <openair3/NAS/COMMON/ESM/MSG/EsmInformationRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/EsmInformationResponse.h>
+#include <openair3/NAS/COMMON/ESM/MSG/EsmStatus.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ModifyEpsBearerContextAccept.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ModifyEpsBearerContextReject.h>
+#include <openair3/NAS/COMMON/ESM/MSG/ModifyEpsBearerContextRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/PdnConnectivityReject.h>
+#include <openair3/NAS/COMMON/ESM/MSG/PdnConnectivityRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/PdnDisconnectReject.h>
+#include <openair3/NAS/COMMON/ESM/MSG/PdnDisconnectRequest.h>
+#include <openair3/NAS/COMMON/ESM/MSG/esm_msgDef.h>
+#include <openair3/NAS/COMMON/ESM/MSG/esm_msg.h>
+
+#include <openair3/NAS/COMMON/EMM/MSG/AttachAccept.h>
+#include <openair3/NAS/COMMON/EMM/MSG/AttachComplete.h>
+#include <openair3/NAS/COMMON/EMM/MSG/AttachReject.h>
+#include <openair3/NAS/COMMON/EMM/MSG/AttachRequest.h>
+#include <openair3/NAS/COMMON/EMM/MSG/AuthenticationFailure.h>
+#include <openair3/NAS/COMMON/EMM/MSG/AuthenticationReject.h>
+#include <openair3/NAS/COMMON/EMM/MSG/AuthenticationRequest.h>
+#include <openair3/NAS/COMMON/EMM/MSG/AuthenticationResponse.h>
+#include <openair3/NAS/COMMON/EMM/MSG/CsServiceNotification.h>
+#include <openair3/NAS/COMMON/EMM/MSG/DetachAccept.h>
+#include <openair3/NAS/COMMON/EMM/MSG/DetachRequest.h>
+#include <openair3/NAS/COMMON/EMM/MSG/DownlinkNasTransport.h>
+#include <openair3/NAS/COMMON/EMM/MSG/emm_cause.h>
+#include <openair3/NAS/COMMON/EMM/MSG/EmmInformation.h>
+#include <openair3/NAS/COMMON/EMM/MSG/EmmStatus.h>
+#include <openair3/NAS/COMMON/EMM/MSG/ExtendedServiceRequest.h>
+#include <openair3/NAS/COMMON/EMM/MSG/GutiReallocationCommand.h>
+#include <openair3/NAS/COMMON/EMM/MSG/GutiReallocationComplete.h>
+#include <openair3/NAS/COMMON/EMM/MSG/IdentityRequest.h>
+#include <openair3/NAS/COMMON/EMM/MSG/IdentityResponse.h>
+#include <openair3/NAS/COMMON/EMM/MSG/NASSecurityModeCommand.h>
+#include <openair3/NAS/COMMON/EMM/MSG/NASSecurityModeComplete.h>
+#include <openair3/NAS/COMMON/EMM/MSG/SecurityModeReject.h>
+#include <openair3/NAS/COMMON/EMM/MSG/ServiceReject.h>
+#include <openair3/NAS/COMMON/EMM/MSG/ServiceRequest.h>
+#include <openair3/NAS/COMMON/EMM/MSG/TrackingAreaUpdateAccept.h>
+#include <openair3/NAS/COMMON/EMM/MSG/TrackingAreaUpdateComplete.h>
+#include <openair3/NAS/COMMON/EMM/MSG/TrackingAreaUpdateReject.h>
+#include <openair3/NAS/COMMON/EMM/MSG/TrackingAreaUpdateRequest.h>
+#include <openair3/NAS/COMMON/EMM/MSG/UplinkNasTransport.h>
+#include <openair3/NAS/COMMON/EMM/MSG/emm_msgDef.h>
+#include <openair3/NAS/COMMON/EMM/MSG/emm_msg.h>
+
+#include <openair3/NAS/COMMON/API/NETWORK/nas_message.h>
+#include <openair2/COMMON/nas_messages_types.h>
+#if ENABLE_RAL
+  #include <ral_messages_types.h>
+#endif
+#include <openair2/COMMON/s1ap_messages_types.h>
+#include <openair2/COMMON/x2ap_messages_types.h>
+#include <openair2/COMMON/sctp_messages_types.h>
+#include <openair2/COMMON/udp_messages_types.h>
+#include <openair2/COMMON/gtpv1_u_messages_types.h>
+#include <openair3/SCTP/sctp_eNB_task.h>
+#include <openair3/NAS/UE/nas_proc_defs.h>
+#include <openair3/NAS/UE/ESM/esmData.h>
+#include <openair3/NAS/COMMON/UTIL/nas_timer.h>
+#include <openair3/NAS/UE/ESM/esm_pt_defs.h>
+#include <openair3/NAS/UE/EMM/emm_proc_defs.h>
+#include <openair3/NAS/UE/EMM/emmData.h>
+#include <openair3/NAS/UE/EMM/IdleMode_defs.h>
+#include <openair3/NAS/UE/EMM/emm_fsm_defs.h>
+#include <openair3/NAS/UE/EMM/emmData.h>
+#include <openair3/NAS/COMMON/securityDef.h>
+#include <openair3/NAS/UE/EMM/Authentication.h>
+#include <openair3/NAS/UE/EMM/SecurityModeControl.h>
+#include <openair3/NAS/UE/API/USIM/usim_api.h>
+#include <openair3/NAS/COMMON/userDef.h>
+#include <openair3/NAS/UE/API/USER/at_command.h>
+#include <openair3/NAS/UE/API/USER/at_response.h>
+#include <openair3/NAS/UE/API/USER/user_api_defs.h>
+#include <openair3/NAS/UE/EMM/LowerLayer_defs.h>
+#include <openair3/NAS/UE/user_defs.h>
+#include <openair3/NAS/UE/nas_ue_task.h>
+#include <openair3/S1AP/s1ap_eNB.h>
+//#include <proto.h>
+
+/*
+  static const char *const messages_definition_xml = {
+  #include <messages_xml.h>
+  };
+*/
+
+typedef uint32_t MessageHeaderSize;
+typedef uint32_t itti_message_types_t;
+typedef unsigned long message_number_t;
+#define MESSAGE_NUMBER_SIZE (sizeof(unsigned long))
+
+typedef enum task_priorities_e {
+  TASK_PRIORITY_MAX       = 100,
+  TASK_PRIORITY_MAX_LEAST = 85,
+  TASK_PRIORITY_MED_PLUS  = 70,
+  TASK_PRIORITY_MED       = 55,
+  TASK_PRIORITY_MED_LEAST = 40,
+  TASK_PRIORITY_MIN_PLUS  = 25,
+  TASK_PRIORITY_MIN       = 10,
+} task_priorities_t;
+
+typedef struct {
+  task_priorities_t priority;
+  unsigned int queue_size;
+  /* Printable name */
+  char name[256];
+  void *(*func)(void *) ;
+  void *(*threadFunc)(void *) ;
+} task_info_t;
+//
+//TASK_DEF(TASK_RRC_ENB,  TASK_PRIORITY_MED,  200, NULL,NULL)
+//TASK_DEF(TASK_RRC_ENB,  TASK_PRIORITY_MED,  200, NULL, NULL)
+//TASK_DEF(TASK_GTPV1_U,  TASK_PRIORITY_MED,  1000,NULL, NULL)
+//TASK_DEF(TASK_UDP,      TASK_PRIORITY_MED,  1000, NULL, NULL)
+
+#define FOREACH_TASK(TASK_DEF) \
+  TASK_DEF(TASK_UNKNOWN,  TASK_PRIORITY_MED, 50, NULL, NULL)  \
+  TASK_DEF(TASK_TIMER,    TASK_PRIORITY_MED, 10, NULL, NULL)   \
+  TASK_DEF(TASK_L2L1,     TASK_PRIORITY_MAX, 200, NULL, NULL)   \
+  TASK_DEF(TASK_BM,       TASK_PRIORITY_MED, 200, NULL, NULL)   \
+  TASK_DEF(TASK_PHY_ENB,  TASK_PRIORITY_MED, 200, NULL, NULL)   \
+  TASK_DEF(TASK_MAC_ENB,  TASK_PRIORITY_MED, 200, NULL, NULL)   \
+  TASK_DEF(TASK_RLC_ENB,  TASK_PRIORITY_MED, 200, NULL, NULL)   \
+  TASK_DEF(TASK_RRC_ENB_NB_IoT,  TASK_PRIORITY_MED, 200, NULL, NULL) \
+  TASK_DEF(TASK_PDCP_ENB, TASK_PRIORITY_MED, 200, NULL, NULL)   \
+  TASK_DEF(TASK_RRC_ENB,  TASK_PRIORITY_MED,  200, NULL,NULL)\
+  TASK_DEF(TASK_RAL_ENB,  TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_S1AP,     TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_X2AP,     TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_SCTP,     TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_ENB_APP,  TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_FLEXRAN_AGENT,TASK_PRIORITY_MED, 200, NULL, NULL) \
+  TASK_DEF(TASK_PHY_UE,   TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_MAC_UE,   TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_RLC_UE,   TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_PDCP_UE,  TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_RRC_UE,   TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_NAS_UE,   TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_RAL_UE,   TASK_PRIORITY_MED,  200, NULL, NULL)  \
+  TASK_DEF(TASK_MSC,      TASK_PRIORITY_MED,  200, NULL, NULL)\
+  TASK_DEF(TASK_GTPV1_U,  TASK_PRIORITY_MED,  1000,NULL, NULL)\
+  TASK_DEF(TASK_UDP,      TASK_PRIORITY_MED,  1000, NULL, NULL)\
+  TASK_DEF(TASK_MAX,      TASK_PRIORITY_MED,  200, NULL, NULL)
+
+#define TASK_DEF(TaskID, pRIO, qUEUEsIZE, FuNc, ThreadFunc)          { pRIO, qUEUEsIZE, #TaskID, FuNc, ThreadFunc },
+
+/* Map task id to printable name. */
+static const task_info_t tasks_info[] = {
+  FOREACH_TASK(TASK_DEF)
+};
+
+#define TASK_ENUM(TaskID, pRIO, qUEUEsIZE, FuNc,ThreadFunc ) TaskID,
+//! Tasks id of each task
+typedef enum {
+  FOREACH_TASK(TASK_ENUM)
+} task_id_t;
+
+
+typedef task_id_t thread_id_t;
+
+typedef enum message_priorities_e {
+  MESSAGE_PRIORITY_MAX       = 100,
+  MESSAGE_PRIORITY_MAX_LEAST = 85,
+  MESSAGE_PRIORITY_MED_PLUS  = 70,
+  MESSAGE_PRIORITY_MED       = 55,
+  MESSAGE_PRIORITY_MED_LEAST = 40,
+  MESSAGE_PRIORITY_MIN_PLUS  = 25,
+  MESSAGE_PRIORITY_MIN       = 10,
+} message_priorities_t;
+
+
+#define FOREACH_MSG(INTERNAL_MSG)         \
+  INTERNAL_MSG(TIMER_HAS_EXPIRED,  MESSAGE_PRIORITY_MED, timer_has_expired_t, timer_has_expired) \
+  INTERNAL_MSG(INITIALIZE_MESSAGE, MESSAGE_PRIORITY_MED, IttiMsgEmpty, initialize_message)  \
+  INTERNAL_MSG(ACTIVATE_MESSAGE,   MESSAGE_PRIORITY_MED, IttiMsgEmpty, activate_message) \
+  INTERNAL_MSG(DEACTIVATE_MESSAGE, MESSAGE_PRIORITY_MED, IttiMsgEmpty, deactivate_message)  \
+  INTERNAL_MSG(TERMINATE_MESSAGE,  MESSAGE_PRIORITY_MAX, IttiMsgEmpty, terminate_message) \
+  INTERNAL_MSG(MESSAGE_TEST,       MESSAGE_PRIORITY_MED, IttiMsgEmpty, message_test)
+
+/* This enum defines messages ids. Each one is unique. */
+typedef enum {
+#define MESSAGE_DEF(iD, pRIO, sTRUCT, fIELDnAME) iD,
+  FOREACH_MSG(MESSAGE_DEF)
+#include <all_msg.h>
+#undef MESSAGE_DEF
+  MESSAGES_ID_MAX,
+} MessagesIds;
+
+typedef union msg_s {
+#define MESSAGE_DEF(iD, pRIO, sTRUCT, fIELDnAME) sTRUCT fIELDnAME;
+  FOREACH_MSG(MESSAGE_DEF)
+#include <all_msg.h>
+#undef MESSAGE_DEF
+} msg_t;
+
+typedef struct MessageHeader_s {
+  MessagesIds messageId;          /**< Unique message id as referenced in enum MessagesIds */
+  task_id_t  originTaskId;        /**< ID of the sender task */
+  task_id_t  destinationTaskId;   /**< ID of the destination task */
+  instance_t instance;            /**< Task instance for virtualization */
+  itti_lte_time_t lte_time;
+  MessageHeaderSize ittiMsgSize;         /**< Message size (not including header size) */
+} MessageHeader;
+
+typedef struct message_info_s {
+  int id;
+  message_priorities_t priority;
+  /* Message payload size */
+  MessageHeaderSize size;
+  /* Printable name */
+  const char name[256];
+} message_info_t;
+
+/* Map message id to message information */
+static const message_info_t messages_info[] = {
+#define MESSAGE_DEF(iD, pRIO, sTRUCT, fIELDnAME) { iD, pRIO, sizeof(sTRUCT), #iD },
+  FOREACH_MSG(MESSAGE_DEF)
+#include <all_msg.h>
+#undef MESSAGE_DEF
+};
+
+typedef struct __attribute__ ((__packed__)) MessageDef_s {
+  MessageHeader ittiMsgHeader; /**< Message header */
+  msg_t         ittiMsg;
+} MessageDef;
+
+
+
+/* Extract the instance from a message */
+#define ITTI_MESSAGE_GET_INSTANCE(mESSAGE)  ((mESSAGE)->ittiMsgHeader.instance)
+#define ITTI_MSG_ID(mSGpTR)                 ((mSGpTR)->ittiMsgHeader.messageId)
+#define ITTI_MSG_ORIGIN_ID(mSGpTR)          ((mSGpTR)->ittiMsgHeader.originTaskId)
+#define ITTI_MSG_DESTINATION_ID(mSGpTR)     ((mSGpTR)->ittiMsgHeader.destinationTaskId)
+#define ITTI_MSG_INSTANCE(mSGpTR)           ((mSGpTR)->ittiMsgHeader.instance)
+#define ITTI_MSG_NAME(mSGpTR)               itti_get_message_name(ITTI_MSG_ID(mSGpTR))
+#define ITTI_MSG_ORIGIN_NAME(mSGpTR)        itti_get_task_name(ITTI_MSG_ORIGIN_ID(mSGpTR))
+#define ITTI_MSG_DESTINATION_NAME(mSGpTR)   itti_get_task_name(ITTI_MSG_DESTINATION_ID(mSGpTR))
+#define TIMER_HAS_EXPIRED(mSGpTR)           (mSGpTR)->ittiMsg.timer_has_expired
+
+#define INSTANCE_DEFAULT    (UINT16_MAX - 1)
+
+static inline int64_t clock_difftime_ns(struct timespec start, struct timespec end) {
+  return (int64_t)( end.tv_sec-start.tv_sec) * (int64_t)(1000*1000*1000) + end.tv_nsec-start.tv_nsec;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \brief Send a message to a task (could be itself)
+  \param task_id Task ID
+  \param instance Instance of the task used for virtualization
+  \param message Pointer to the message to send
+  @returns -1 on failure, 0 otherwise
+ **/
+int itti_send_msg_to_task(task_id_t task_id, instance_t instance, MessageDef *message);
+
+/** \brief Add a new fd to monitor.
+   NOTE: it is up to the user to read data associated with the fd
+    \param task_id Task ID of the receiving task
+    \param fd The file descriptor to monitor
+ **/
+void itti_subscribe_event_fd(task_id_t task_id, int fd);
+
+/** \brief Remove a fd from the list of fd to monitor
+    \param task_id Task ID of the task
+    \param fd The file descriptor to remove
+ **/
+void itti_unsubscribe_event_fd(task_id_t task_id, int fd);
+
+/** \brief Return the list of events excluding the fd associated with itti
+    \param task_id Task ID of the task
+    \param events events list
+    @returns number of events to handle
+ **/
+int itti_get_events(task_id_t task_id, struct epoll_event **events);
+
+/** \brief Retrieves a message in the queue associated to task_id.
+   If the queue is empty, the thread is blocked till a new message arrives.
+  \param task_id Task ID of the receiving task
+  \param received_msg Pointer to the allocated message
+ **/
+void itti_receive_msg(task_id_t task_id, MessageDef **received_msg);
+
+/** \brief Try to retrieves a message in the queue associated to task_id.
+  \param task_id Task ID of the receiving task
+  \param received_msg Pointer to the allocated message
+ **/
+void itti_poll_msg(task_id_t task_id, MessageDef **received_msg);
+
+/** \brief Start thread associated to the task
+   \param task_id task to start
+   \param start_routine entry point for the task
+   \param args_p Optional argument to pass to the start routine
+   @returns -1 on failure, 0 otherwise
+ **/
+int itti_create_task(task_id_t task_id,
+                     void *(*start_routine) (void *),
+                     void *args_p);
+
+/** \brief Exit the current task.
+ **/
+void itti_exit_task(void);
+
+/** \brief Initiate termination of all tasks.
+   \param task_id task that is completed
+ **/
+void itti_terminate_tasks(task_id_t task_id);
+
+// Void for legacy compatibility
+void itti_wait_ready(int wait_tasks);
+void itti_mark_task_ready(task_id_t task_id);
+
+/** \brief Return the printable string associated with the message
+   \param message_id Id of the message
+ **/
+const char *itti_get_message_name(MessagesIds message_id);
+
+/** \brief Return the printable string associated with a task id
+   \param thread_id Id of the task
+ **/
+const char *itti_get_task_name(task_id_t task_id);
+
+/** \brief Alloc and memset(0) a new itti message.
+   \param origin_task_id Task ID of the sending task
+   \param message_id Message ID
+   @returns NULL in case of failure or newly allocated mesage ref
+ **/
+MessageDef *itti_alloc_new_message(
+  task_id_t         origin_task_id,
+  MessagesIds       message_id);
+
+/** \brief Alloc and memset(0) a new itti message.
+   \param origin_task_id Task ID of the sending task
+   \param message_id Message ID
+   \param size size of the payload to send
+   @returns NULL in case of failure or newly allocated mesage ref
+ **/
+MessageDef *itti_alloc_new_message_sized(
+  task_id_t         origin_task_id,
+  MessagesIds       message_id,
+  MessageHeaderSize size);
+
+/** \brief handle signals and wait for all threads to join when the process complete.
+   This function should be called from the main thread after having created all ITTI tasks.
+ **/
+void itti_wait_tasks_end(void);
+#define  THREAD_MAX 0 //for compatibility
+void itti_set_task_real_time(task_id_t task_id);
+
+/** \brief Send a termination message to all tasks.
+   \param task_id task that is broadcasting the message.
+ **/
+void itti_send_terminate_message(task_id_t task_id);
+
+void *itti_malloc(task_id_t origin_task_id, task_id_t destination_task_id, ssize_t size);
+void *calloc_or_fail(size_t size);
+void *malloc_or_fail(size_t size);
+int memory_read(const char *datafile, void *data, size_t size);
+int itti_free(task_id_t task_id, void *ptr);
+
+int itti_init(task_id_t task_max, thread_id_t thread_max, MessagesIds messages_id_max, const task_info_t *tasks_info,
+              const message_info_t *messages_info);
+int timer_setup(
+  uint32_t      interval_sec,
+  uint32_t      interval_us,
+  task_id_t     task_id,
+  int32_t       instance,
+  timer_type_t  type,
+  void         *timer_arg,
+  long         *timer_id);
+
+
+int timer_remove(long timer_id);
+#define timer_stop timer_remove
+int signal_handle(int *end);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* INTERTASK_INTERFACE_H_ */