Merge remote-tracking branch 'origin/374-missing-rrc-inactivity-timer-missing-default-drx-ie-in-s1-setup-ue-s1-id-unknown-after-detach-for-switch-off' into develop_integration_w48

common/utils/T/tracer/gui/x.c

@@ -7,19 +7,17 @@
 #include <stdlib.h>
 #include <string.h>
 
-int x_connection_fd(x_connection *_x)
+int x_connection_fd(x_connection *_x) {
-{
   struct x_connection *x = _x;
   return ConnectionNumber(x->d);
 }
 
-static GC create_gc(Display *d, char *color)
+static GC create_gc(Display *d, char *color) {
-{
   GC ret = XCreateGC(d, DefaultRootWindow(d), 0, NULL);
   XGCValues gcv;
   XColor rcol, scol;
-
   XCopyGC(d, DefaultGC(d, DefaultScreen(d)), -1L, ret);
+
   if (XAllocNamedColor(d, DefaultColormap(d, DefaultScreen(d)),
                        color, &scol, &rcol)) {
     gcv.foreground = scol.pixel;
@@ -29,17 +27,18 @@ static GC create_gc(Display *d, char *color)
   return ret;
 }
 
-int x_new_color(x_connection *_x, char *color)
+int x_new_color(x_connection *_x, char *color) {
-{
   struct x_connection *x = _x;
   x->ncolors++;
-
   x->colors = realloc(x->colors, x->ncolors * sizeof(GC));
-  if (x->colors == NULL) OOM;
-  x->colors[x->ncolors-1] = create_gc(x->d, color);
 
+  if (x->colors == NULL) OOM;
+
+  x->colors[x->ncolors-1] = create_gc(x->d, color);
   x->xft_colors = realloc(x->xft_colors, x->ncolors * sizeof(XftColor));
+
   if (x->xft_colors == NULL) OOM;
+
   if (XftColorAllocName(x->d, DefaultVisual(x->d, DefaultScreen(x->d)),
                         DefaultColormap(x->d, DefaultScreen(x->d)),
                         color, &x->xft_colors[x->ncolors-1]) == False)
@@ -48,45 +47,45 @@ int x_new_color(x_connection *_x, char *color)
   return x->ncolors - 1;
 }
 
-int x_new_font(x_connection *_x, char *font)
+int x_new_font(x_connection *_x, char *font) {
-{
   struct x_connection *x = _x;
   /* TODO: allocate fonts only once */
   x->nfonts++;
   x->fonts = realloc(x->fonts, x->nfonts * sizeof(XftFont *));
+
   if (x->fonts == NULL) OOM;
+
   x->fonts[x->nfonts-1] = XftFontOpenName(x->d, DefaultScreen(x->d), font);
+
   if (x->fonts[x->nfonts-1] == NULL)
     ERR("failed allocating font '%s'\n", font);
+
   return x->nfonts - 1;
 }
 
-x_connection *x_open(void)
+x_connection *x_open(void) {
-{
   struct x_connection *ret;
-
   ret = calloc(1, sizeof(struct x_connection));
+
   if (ret == NULL) OOM;
 
   ret->d = XOpenDisplay(0);
   LOGD("XOpenDisplay display %p return x_connection %p\n", ret->d, ret);
+
   if (ret->d == NULL) ERR("error calling XOpenDisplay: no X? you root?\n");
 
   x_new_color(ret, "white");    /* background color */
   x_new_color(ret, "black");    /* foreground color */
-
   x_new_font(ret, "sans-8");
-
   return ret;
 }
 
 x_window *x_create_window(x_connection *_x, int width, int height,
-    char *title)
+                          char *title) {
-{
   struct x_connection *x = _x;
   struct x_window *ret;
-
   ret = calloc(1, sizeof(struct x_window));
+
   if (ret == NULL) OOM;
 
   ret->w = XCreateSimpleWindow(x->d, DefaultRootWindow(x->d), 0, 0,
@@ -94,17 +93,15 @@ x_window *x_create_window(x_connection *_x, int width, int height,
                                WhitePixel(x->d, DefaultScreen(x->d)));
   ret->width = width;
   ret->height = height;
-
   XStoreName(x->d, ret->w, title);
-
   ret->p = XCreatePixmap(x->d, ret->w, width, height,
                          DefaultDepth(x->d, DefaultScreen(x->d)));
   XFillRectangle(x->d, ret->p, x->colors[BACKGROUND_COLOR],
                  0, 0, width, height);
-
   ret->xft = XftDrawCreate(x->d, ret->p,
                            DefaultVisual(x->d, DefaultScreen(x->d)),
                            DefaultColormap(x->d, DefaultScreen(x->d)));
+
   if (ret->xft == NULL) ERR("XftDrawCreate failed\n");
 
   /* enable backing store */
@@ -113,7 +110,6 @@ x_window *x_create_window(x_connection *_x, int width, int height,
     att.backing_store = Always;
     XChangeWindowAttributes(x->d, ret->w, CWBackingStore, &att);
   }
-
   XSelectInput(x->d, ret->w,
                KeyPressMask      |
                ButtonPressMask   |
@@ -121,15 +117,12 @@ x_window *x_create_window(x_connection *_x, int width, int height,
                PointerMotionMask |
                ExposureMask      |
                StructureNotifyMask);
-
   XMapWindow(x->d, ret->w);
-
   return ret;
 }
 
 x_image *x_create_image(x_connection *_x, unsigned char *data,
-    int width, int height)
+                        int width, int height) {
-{
   struct x_connection *x = _x;
   struct x_image *ret;
   XImage *ximage;
@@ -137,8 +130,9 @@ x_image *x_create_image(x_connection *_x, unsigned char *data,
   XVisualInfo template;
   int nvs;
   Visual *v;
+  ret = calloc(1, sizeof(struct x_image));
 
-  ret = calloc(1, sizeof(struct x_image)); if (ret == NULL) OOM;
+  if (ret == NULL) OOM;
 
   template.class = TrueColor;
   template.depth = 24;
@@ -146,7 +140,6 @@ x_image *x_create_image(x_connection *_x, unsigned char *data,
   template.green_mask = 0x00ff00;
   template.blue_mask = 0x0000ff;
   template.bits_per_rgb = 8;
-
   vs = XGetVisualInfo(x->d, VisualDepthMask | VisualClassMask |
                       VisualRedMaskMask | VisualGreenMaskMask | VisualBlueMaskMask |
                       VisualBitsPerRGBMask, &template, &nvs);
@@ -163,51 +156,49 @@ x_image *x_create_image(x_connection *_x, unsigned char *data,
 
   v = vs[0].visual;
   XFree(vs);
-
   ximage = XCreateImage(x->d, v, 24, ZPixmap, 0,
                         (char *)data, width, height, 32, 0);
+
   if (ximage == NULL) ERR("image creation failed\n");
 
   ret->p = XCreatePixmap(x->d, DefaultRootWindow(x->d), width, height, 24);
-
   XPutImage(x->d, ret->p, DefaultGC(x->d, DefaultScreen(x->d)),
             ximage, 0, 0, 0, 0, width, height);
-
   /* TODO: be sure it's fine to set data to NULL */
   ximage->data = NULL;
   XDestroyImage(ximage);
-
   ret->width = width;
   ret->height = height;
-
   return ret;
 }
 
-static struct toplevel_window_widget *find_x_window(struct gui *g, Window id)
+static struct toplevel_window_widget *find_x_window(struct gui *g, Window id) {
-{
   struct widget_list *cur;
   struct toplevel_window_widget *w;
   struct x_window *xw;
   cur = g->toplevel;
+
   while (cur) {
     w = (struct toplevel_window_widget *)cur->item;
     xw = w->x;
+
     if (xw->w == id) return w;
+
     cur = cur->next;
   }
+
   return NULL;
 }
 
-void x_events(gui *_gui)
+void x_events(gui *_gui) {
-{
   struct gui *g = _gui;
   struct widget_list *cur;
   struct x_connection *x = g->x;
   struct toplevel_window_widget *w;
-
   LOGD("x_events START\n");
   /* preprocessing (to "compress" events) */
   cur = g->toplevel;
+
   while (cur) {
     struct x_window *xw;
     w = (struct toplevel_window_widget *)cur->item;
@@ -222,6 +213,7 @@ void x_events(gui *_gui)
     XEvent ev;
     XNextEvent(x->d, &ev);
     LOGD("XEV %d\n", ev.type);
+
     switch (ev.type) {
       case MapNotify:
       case Expose:
@@ -229,51 +221,76 @@ void x_events(gui *_gui)
           struct x_window *xw = w->x;
           xw->redraw = 1;
         }
+
         break;
+
       case ConfigureNotify:
         if ((w = find_x_window(g, ev.xconfigure.window)) != NULL) {
           struct x_window *xw = w->x;
           xw->resize = 1;
           xw->new_width = ev.xconfigure.width;
           xw->new_height = ev.xconfigure.height;
+
           if (xw->new_width < 10) xw->new_width = 10;
+
           if (xw->new_height < 10) xw->new_height = 10;
+
           LOGD("ConfigureNotify %d %d\n", ev.xconfigure.width, ev.xconfigure.height);
         }
+
         break;
+
       case ButtonPress:
         if ((w = find_x_window(g, ev.xbutton.window)) != NULL) {
           int key_modifiers = 0;
+
           if (ev.xbutton.state & ShiftMask)   key_modifiers |= KEY_SHIFT;
+
           if (ev.xbutton.state & Mod1Mask)    key_modifiers |= KEY_ALT;
+
           if (ev.xbutton.state & ControlMask) key_modifiers |= KEY_CONTROL;
+
           w->common.button(g, w, ev.xbutton.x, ev.xbutton.y, key_modifiers,
                            ev.xbutton.button, 0);
         }
+
         break;
+
       case ButtonRelease:
         if ((w = find_x_window(g, ev.xbutton.window)) != NULL) {
           int key_modifiers = 0;
+
           if (ev.xbutton.state & ShiftMask)   key_modifiers |= KEY_SHIFT;
+
           if (ev.xbutton.state & Mod1Mask)    key_modifiers |= KEY_ALT;
+
           if (ev.xbutton.state & ControlMask) key_modifiers |= KEY_CONTROL;
+
           w->common.button(g, w, ev.xbutton.x, ev.xbutton.y, key_modifiers,
                            ev.xbutton.button, 1);
         }
+
+        break;
+
+      default:
+        if (gui_logd) WARN("TODO: X event type %d\n", ev.type);
+
         break;
-    default: if (gui_logd) WARN("TODO: X event type %d\n", ev.type); break;
     }
   }
 
   /* postprocessing */
   LOGD("post processing\n");
   cur = g->toplevel;
+
   while (cur) {
     struct toplevel_window_widget *w =
       (struct toplevel_window_widget *)cur->item;
     struct x_window *xw = w->x;
+
     if (xw->resize) {
       LOGD("resize old %d %d new %d %d\n", xw->width, xw->height, xw->new_width, xw->new_height);
+
       if (xw->width != xw->new_width || xw->height != xw->new_height) {
         w->common.allocate(g, w, 0, 0, xw->new_width, xw->new_height);
         xw->width = xw->new_width;
@@ -287,40 +304,41 @@ void x_events(gui *_gui)
         xw->xft = XftDrawCreate(x->d, xw->p,
                                 DefaultVisual(x->d, DefaultScreen(x->d)),
                                 DefaultColormap(x->d, DefaultScreen(x->d)));
+
         if (xw->xft == NULL) ERR("XftDrawCreate failed\n");
 
         //xw->repaint = 1;
       }
     }
+
     if (xw->repaint) {
       w->common.paint(g, w);
       xw->redraw = 1;
     }
+
     if (xw->redraw) {
       struct x_connection *x = g->x;
       LOGD("XCopyArea w h %d %d\n", xw->width, xw->height);
       XCopyArea(x->d, xw->p, xw->w, x->colors[1],
                 0, 0, xw->width, xw->height, 0, 0);
     }
+
     cur = cur->next;
   }
+
   LOGD("x_events DONE\n");
 }
 
-void x_flush(x_connection *_x)
+void x_flush(x_connection *_x) {
-{
   struct x_connection *x = _x;
   XFlush(x->d);
 }
 
 void x_text_get_dimensions(x_connection *_c, int font, const char *t,
-    int *width, int *height, int *baseline)
+                           int *width, int *height, int *baseline) {
-{
   struct x_connection *c = _c;
   XGlyphInfo ext;
-
   XftTextExtentsUtf8(c->d, c->fonts[font], (FcChar8 *)t, strlen(t), &ext);
-
   *width = ext.width;
   *height = c->fonts[font]->height;
   *baseline = c->fonts[font]->ascent;
@@ -331,32 +349,28 @@ void x_text_get_dimensions(x_connection *_c, int font, const char *t,
 /***********************************************************************/
 
 void x_draw_line(x_connection *_c, x_window *_w, int color,
-    int x1, int y1, int x2, int y2)
+                 int x1, int y1, int x2, int y2) {
-{
   struct x_connection *c = _c;
   struct x_window *w = _w;
   XDrawLine(c->d, w->p, c->colors[color], x1, y1, x2, y2);
 }
 
 void x_draw_rectangle(x_connection *_c, x_window *_w, int color,
-    int x, int y, int width, int height)
+                      int x, int y, int width, int height) {
-{
   struct x_connection *c = _c;
   struct x_window *w = _w;
   XDrawRectangle(c->d, w->p, c->colors[color], x, y, width, height);
 }
 
 void x_fill_rectangle(x_connection *_c, x_window *_w, int color,
-    int x, int y, int width, int height)
+                      int x, int y, int width, int height) {
-{
   struct x_connection *c = _c;
   struct x_window *w = _w;
   XFillRectangle(c->d, w->p, c->colors[color], x, y, width, height);
 }
 
 void x_draw_string(x_connection *_c, x_window *_w, int font, int color,
-    int x, int y, const char *t)
+                   int x, int y, const char *t) {
-{
   struct x_connection *c = _c;
   struct x_window *w = _w;
   int tlen = strlen(t);
@@ -366,28 +380,26 @@ void x_draw_string(x_connection *_c, x_window *_w, int font, int color,
 
 void x_draw_clipped_string(x_connection *_c, x_window *_w, int font,
                            int color, int x, int y, const char *t,
-    int clipx, int clipy, int clipwidth, int clipheight)
+                           int clipx, int clipy, int clipwidth, int clipheight) {
-{
   struct x_window *w = _w;
-
   XRectangle clip = { clipx, clipy, clipwidth, clipheight };
+
   if (XftDrawSetClipRectangles(w->xft, 0, 0, &clip, 1) == False) abort();
+
   x_draw_string(_c, _w, font, color, x, y, t);
+
   if (XftDrawSetClip(w->xft, NULL) == False) abort();
 }
 
-void x_draw_image(x_connection *_c, x_window *_w, x_image *_img, int x, int y)
+void x_draw_image(x_connection *_c, x_window *_w, x_image *_img, int x, int y) {
-{
   struct x_connection *c = _c;
   struct x_window *w = _w;
   struct x_image *img = _img;
-
   XCopyArea(c->d, img->p, w->p, DefaultGC(c->d, DefaultScreen(c->d)),
             0, 0, img->width, img->height, x, y);
 }
 
-void x_draw(x_connection *_c, x_window *_w)
+void x_draw(x_connection *_c, x_window *_w) {
-{
   struct x_connection *c = _c;
   struct x_window *w = _w;
   LOGD("x_draw XCopyArea w h %d %d display %p window %d pixmap %d\n", w->width, w->height, c->d, (int)w->w, (int)w->p);
@@ -397,13 +409,13 @@ void x_draw(x_connection *_c, x_window *_w)
 /* those two special functions are to plot many points
  * first call x_add_point many times then x_plot_points once
  */
-void x_add_point(x_connection *_c, int x, int y)
+void x_add_point(x_connection *_c, int x, int y) {
-{
   struct x_connection *c = _c;
 
   if (c->pts_size == c->pts_maxsize) {
     c->pts_maxsize += 65536;
     c->pts = realloc(c->pts, c->pts_maxsize * sizeof(XPoint));
+
     if (c->pts == NULL) OOM;
   }
 
@@ -412,8 +424,7 @@ void x_add_point(x_connection *_c, int x, int y)
   c->pts_size++;
 }
 
-void x_plot_points(x_connection *_c, x_window *_w, int color)
+void x_plot_points(x_connection *_c, x_window *_w, int color) {
-{
   struct x_connection *c = _c;
   LOGD("x_plot_points %d points\n", c->pts_size);
   struct x_window *w = _w;

openair2/COMMON/rrc_messages_types.h

@@ -102,6 +102,7 @@ typedef struct RrcConfigurationReq_s {
   uint8_t             mnc_digit_length[PLMN_LIST_MAX_SIZE];
   uint8_t             num_plmn;
 
+  uint32_t            rrc_inactivity_timer_thres; // for testing, maybe change later
 
   paging_drx_t            default_drx;
   int16_t                 nb_cc;

openair2/ENB_APP/enb_config.c

@@ -60,6 +60,8 @@
 #include "RRC_config_tools.h"
 #include "enb_paramdef.h"
 
+#define RRC_INACTIVITY_THRESH 0
+
 extern uint16_t sf_ahead;
 extern void set_parallel_conf(char *parallel_conf);
 extern void set_worker_conf(char *worker_conf);
@@ -579,6 +581,7 @@ int RCconfig_RRC(MessageDef *msg_p, uint32_t i, eNB_RRC_INST *rrc) {
         for (int I = 0; I < sizeof(PLMNParams) / sizeof(paramdef_t); ++I)
           PLMNParams[I].chkPptr = &(config_check_PLMNParams[I]);
 
+        RRC_CONFIGURATION_REQ (msg_p).rrc_inactivity_timer_thres = RRC_INACTIVITY_THRESH; // set to 0 to deactivate
         RRC_CONFIGURATION_REQ (msg_p).cell_identity = enb_id;
         RRC_CONFIGURATION_REQ (msg_p).tac = *ENBParamList.paramarray[i][ENB_TRACKING_AREA_CODE_IDX].uptr;
         AssertFatal(!ENBParamList.paramarray[i][ENB_MOBILE_COUNTRY_CODE_IDX_OLD].strptr
@@ -2041,14 +2044,139 @@ int RCconfig_gtpu(void ) {
   return 0;
 }
 
-
+//-----------------------------------------------------------------------------
-int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
+/*
-  int               j,k                           = 0;
+* Configure the s1ap_register_enb_req in itti message for future
-  int enb_id;
+* communications between eNB(s) and MME.
-  int32_t     my_int;
+*/
+int RCconfig_S1(
+  MessageDef *msg_p,
+  uint32_t i)
+//-----------------------------------------------------------------------------
+{
+  int enb_id = 0;
+  int32_t my_int = 0;
   const char *active_enb[MAX_ENB];
   char *address = NULL;
   char *cidr    = NULL;
+  /*------------------------------------------------------------------------------*/
+  /*
+  * the only reason for all these variables is, that they are "hard-encoded" into
+  * the CCPARAMS_DESC macro and we need it for the default_DRX value ...
+  */
+  char       *frame_type                    = NULL;
+  int32_t     tdd_config                    = 0;
+  int32_t     tdd_config_s                  = 0;
+  char       *prefix_type                   = NULL;
+  char       *pbch_repetition               = NULL;
+  int32_t     eutra_band                    = 0;
+  long long int     downlink_frequency      = 0;
+  int32_t     uplink_frequency_offset       = 0;
+  int32_t     Nid_cell                      = 0;
+  int32_t     Nid_cell_mbsfn                = 0;
+  int32_t     N_RB_DL                       = 0;
+  int32_t     nb_antenna_ports              = 0;
+  int32_t     prach_root                    = 0;
+  int32_t     prach_config_index            = 0;
+  char            *prach_high_speed         = NULL;
+  int32_t     prach_zero_correlation        = 0;
+  int32_t     prach_freq_offset             = 0;
+  int32_t     pucch_delta_shift             = 0;
+  int32_t     pucch_nRB_CQI                 = 0;
+  int32_t     pucch_nCS_AN                  = 0;
+  int32_t     pucch_n1_AN                   = 0;
+  int32_t     pdsch_referenceSignalPower    = 0;
+  int32_t     pdsch_p_b                     = 0;
+  int32_t     pusch_n_SB                    = 0;
+  char       *pusch_hoppingMode             = NULL;
+  int32_t     pusch_hoppingOffset           = 0;
+  char          *pusch_enable64QAM          = NULL;
+  char          *pusch_groupHoppingEnabled  = NULL;
+  int32_t     pusch_groupAssignment         = 0;
+  char        *pusch_sequenceHoppingEnabled = NULL;
+  int32_t     pusch_nDMRS1                  = 0;
+  char       *phich_duration                = NULL;
+  char       *phich_resource                = NULL;
+  char       *srs_enable                    = NULL;
+  int32_t     srs_BandwidthConfig           = 0;
+  int32_t     srs_SubframeConfig            = 0;
+  char       *srs_ackNackST                 = NULL;
+  char       *srs_MaxUpPts                  = NULL;
+  int32_t     pusch_p0_Nominal              = 0;
+  char       *pusch_alpha                   = NULL;
+  int32_t     pucch_p0_Nominal              = 0;
+  int32_t     msg3_delta_Preamble           = 0;
+  char       *pucch_deltaF_Format1          = NULL;
+  char       *pucch_deltaF_Format1b         = NULL;
+  char       *pucch_deltaF_Format2          = NULL;
+  char       *pucch_deltaF_Format2a         = NULL;
+  char       *pucch_deltaF_Format2b         = NULL;
+  int32_t     rach_numberOfRA_Preambles     = 0;
+  char       *rach_preamblesGroupAConfig    = NULL;
+  int32_t     rach_sizeOfRA_PreamblesGroupA = 0;
+  int32_t     rach_messageSizeGroupA        = 0;
+  char       *rach_messagePowerOffsetGroupB = NULL;
+  int32_t     rach_powerRampingStep         = 0;
+  int32_t     rach_preambleInitialReceivedTargetPower = 0;
+  int32_t     rach_preambleTransMax         = 0;
+  int32_t     rach_raResponseWindowSize     = 10;
+  int32_t     rach_macContentionResolutionTimer = 0;
+  int32_t     rach_maxHARQ_Msg3Tx           = 0;
+  int32_t     pcch_defaultPagingCycle       = 0;
+  char       *pcch_nB                       = NULL;
+  int32_t     bcch_modificationPeriodCoeff  = 0;
+  int32_t     ue_TimersAndConstants_t300    = 0;
+  int32_t     ue_TimersAndConstants_t301    = 0;
+  int32_t     ue_TimersAndConstants_t310    = 0;
+  int32_t     ue_TimersAndConstants_t311    = 0;
+  int32_t     ue_TimersAndConstants_n310    = 0;
+  int32_t     ue_TimersAndConstants_n311    = 0;
+  int32_t     ue_TransmissionMode           = 0;
+  int32_t     ue_multiple_max               = 0;
+  //TTN - for D2D
+  //SIB18
+  const char       *rxPool_sc_CP_Len                                        = NULL;
+  const char       *rxPool_sc_Period                                        = NULL;
+  const char       *rxPool_data_CP_Len                                      = NULL;
+  libconfig_int     rxPool_ResourceConfig_prb_Num                           = 0;
+  libconfig_int     rxPool_ResourceConfig_prb_Start                         = 0;
+  libconfig_int     rxPool_ResourceConfig_prb_End                           = 0;
+  const char       *rxPool_ResourceConfig_offsetIndicator_present           = NULL;
+  libconfig_int     rxPool_ResourceConfig_offsetIndicator_choice            = 0;
+  const char       *rxPool_ResourceConfig_subframeBitmap_present            = NULL;
+  char             *rxPool_ResourceConfig_subframeBitmap_choice_bs_buf      = NULL;
+  libconfig_int     rxPool_ResourceConfig_subframeBitmap_choice_bs_size     = 0;
+  libconfig_int     rxPool_ResourceConfig_subframeBitmap_choice_bs_bits_unused     = 0;
+  //SIB19
+  //For discRxPool
+  const char       *discRxPool_cp_Len                                              = NULL;
+  const char       *discRxPool_discPeriod                                          = NULL;
+  libconfig_int     discRxPool_numRetx                                             = 0;
+  libconfig_int     discRxPool_numRepetition                                       = 0;
+  libconfig_int     discRxPool_ResourceConfig_prb_Num                              = 0;
+  libconfig_int     discRxPool_ResourceConfig_prb_Start                            = 0;
+  libconfig_int     discRxPool_ResourceConfig_prb_End                              = 0;
+  const char       *discRxPool_ResourceConfig_offsetIndicator_present              = NULL;
+  libconfig_int     discRxPool_ResourceConfig_offsetIndicator_choice               = 0;
+  const char       *discRxPool_ResourceConfig_subframeBitmap_present               = NULL;
+  char             *discRxPool_ResourceConfig_subframeBitmap_choice_bs_buf         = NULL;
+  libconfig_int     discRxPool_ResourceConfig_subframeBitmap_choice_bs_size        = 0;
+  libconfig_int     discRxPool_ResourceConfig_subframeBitmap_choice_bs_bits_unused = 0;
+  //For discRxPoolPS
+  const char       *discRxPoolPS_cp_Len                                              = NULL;
+  const char       *discRxPoolPS_discPeriod                                          = NULL;
+  libconfig_int     discRxPoolPS_numRetx                                             = 0;
+  libconfig_int     discRxPoolPS_numRepetition                                       = 0;
+  libconfig_int     discRxPoolPS_ResourceConfig_prb_Num                              = 0;
+  libconfig_int     discRxPoolPS_ResourceConfig_prb_Start                            = 0;
+  libconfig_int     discRxPoolPS_ResourceConfig_prb_End                              = 0;
+  const char       *discRxPoolPS_ResourceConfig_offsetIndicator_present              = NULL;
+  libconfig_int     discRxPoolPS_ResourceConfig_offsetIndicator_choice               = 0;
+  const char       *discRxPoolPS_ResourceConfig_subframeBitmap_present               = NULL;
+  char             *discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_buf         = NULL;
+  libconfig_int     discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_size        = 0;
+  libconfig_int     discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_bits_unused = 0;
+  /*------------------------------------------------------------------------------*/
   // for no gcc warnings
   (void)my_int;
   memset((char *)active_enb, 0, MAX_ENB * sizeof(char *));
@@ -2066,11 +2194,11 @@ int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
     config_getlist(&ENBParamList, ENBParams, sizeof(ENBParams)/sizeof(paramdef_t), NULL);
 
     if (ENBParamList.numelt > 0) {
-      for (k = 0; k < ENBParamList.numelt; k++) {
+      for (int k = 0; k < ENBParamList.numelt; k++) {
         if (ENBParamList.paramarray[k][ENB_ENB_ID_IDX].uptr == NULL) {
           // Calculate a default eNB ID
           if (EPC_MODE_ENABLED) {
-            uint32_t hash;
+            uint32_t hash = 0;
             hash = s1ap_generate_eNB_id();
             enb_id = k + (hash & 0xFFFF8);
           } else {
@@ -2081,15 +2209,24 @@ int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
         }
 
         // search if in active list
-        for (j=0; j < ENBSParams[ENB_ACTIVE_ENBS_IDX].numelt; j++) {
+        for (int j = 0; j < ENBSParams[ENB_ACTIVE_ENBS_IDX].numelt; j++) {
           if (strcmp(ENBSParams[ENB_ACTIVE_ENBS_IDX].strlistptr[j], *(ENBParamList.paramarray[k][ENB_ENB_NAME_IDX].strptr)) == 0) {
             paramdef_t PLMNParams[] = PLMNPARAMS_DESC;
             paramlist_def_t PLMNParamList = {ENB_CONFIG_STRING_PLMN_LIST, NULL, 0};
+            paramdef_t CCsParams[] = CCPARAMS_DESC;
+            /* map parameter checking array instances to parameter definition array instances */
+            checkedparam_t config_check_CCparams[] = CCPARAMS_CHECK;
+
+            for (int I = 0; I < (sizeof(CCsParams) / sizeof(paramdef_t)); I++) {
+              CCsParams[I].chkPptr = &(config_check_CCparams[I]);
+            }
+
             /* map parameter checking array instances to parameter definition array instances */
             checkedparam_t config_check_PLMNParams [] = PLMNPARAMS_CHECK;
 
-            for (int I = 0; I < sizeof(PLMNParams) / sizeof(paramdef_t); ++I)
+            for (int I = 0; I < sizeof(PLMNParams) / sizeof(paramdef_t); ++I) {
               PLMNParams[I].chkPptr = &(config_check_PLMNParams[I]);
+            }
 
             paramdef_t S1Params[] = S1PARAMS_DESC;
             paramlist_def_t S1ParamList = {ENB_CONFIG_STRING_MME_IP_ADDRESS, NULL, 0};
@@ -2106,7 +2243,9 @@ int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
             } else {
               AssertFatal(0,
                           "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for cell_type choice: CELL_MACRO_ENB or CELL_HOME_ENB !\n",
-                           RC.config_file_name, i, *(ENBParamList.paramarray[k][ENB_CELL_TYPE_IDX].strptr));
+                          RC.config_file_name,
+                          i,
+                          *(ENBParamList.paramarray[k][ENB_CELL_TYPE_IDX].strptr));
             }
 
             S1AP_REGISTER_ENB_REQ (msg_p).eNB_name = strdup(*(ENBParamList.paramarray[k][ENB_ENB_NAME_IDX].strptr));
@@ -2122,9 +2261,10 @@ int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
                         "    plmn_list = ( { mcc = 208; mnc = 93; mnc_length = 2; } )\n");
             config_getlist(&PLMNParamList, PLMNParams, sizeof(PLMNParams)/sizeof(paramdef_t), aprefix);
 
-            if (PLMNParamList.numelt < 1 || PLMNParamList.numelt > 6)
+            if (PLMNParamList.numelt < 1 || PLMNParamList.numelt > 6) {
               AssertFatal(0, "The number of PLMN IDs must be in [1,6], but is %d\n",
                           PLMNParamList.numelt);
+            }
 
             S1AP_REGISTER_ENB_REQ(msg_p).num_plmn = PLMNParamList.numelt;
 
@@ -2138,7 +2278,47 @@ int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
                           S1AP_REGISTER_ENB_REQ(msg_p).mnc[l]);
             }
 
+            /* Default DRX param */
+            /*
+            * Here we get the config of the first CC, since the s1ap_register_enb_req_t doesn't support multiple CC.
+            * There is a unique value of defaultPagingCycle per eNB (same for multiple cells).
+            * Hence, it should be stated somewhere that the value should be the same for every CC, or put the value outside the CC
+            * in the conf file.
+            */
+            sprintf(aprefix, "%s.[%i].%s.[%i]", ENB_CONFIG_STRING_ENB_LIST, k, ENB_CONFIG_STRING_COMPONENT_CARRIERS, 0);
+            config_get(CCsParams, sizeof(CCsParams)/sizeof(paramdef_t), aprefix);
+
+            switch (pcch_defaultPagingCycle) {
+              case 32: {
                 S1AP_REGISTER_ENB_REQ(msg_p).default_drx = 0;
+                break;
+              }
+
+              case 64: {
+                S1AP_REGISTER_ENB_REQ(msg_p).default_drx = 1;
+                break;
+              }
+
+              case 128: {
+                S1AP_REGISTER_ENB_REQ(msg_p).default_drx = 2;
+                break;
+              }
+
+              case 256: {
+                S1AP_REGISTER_ENB_REQ(msg_p).default_drx = 3;
+                break;
+              }
+
+              default: {
+                LOG_E(S1AP, "Default I-DRX value in conf file is invalid (%i). Should be 32, 64, 128 or 256. \
+           Default DRX set to 32 in MME configuration\n",
+                      pcch_defaultPagingCycle);
+                S1AP_REGISTER_ENB_REQ(msg_p).default_drx = 0;
+              }
+            }
+
+            /* MME connection params */
+            sprintf(aprefix, "%s.[%i]", ENB_CONFIG_STRING_ENB_LIST, k);
             config_getlist(&S1ParamList, S1Params, sizeof(S1Params)/sizeof(paramdef_t), aprefix);
             S1AP_REGISTER_ENB_REQ (msg_p).nb_mme = 0;
 
@@ -2156,10 +2336,11 @@ int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
                 S1AP_REGISTER_ENB_REQ (msg_p).mme_ip_address[l].ipv6 = 1;
               }
 
-              if (S1ParamList.paramarray[l][ENB_MME_BROADCAST_PLMN_INDEX].iptr)
+              if (S1ParamList.paramarray[l][ENB_MME_BROADCAST_PLMN_INDEX].iptr) {
                 S1AP_REGISTER_ENB_REQ(msg_p).broadcast_plmn_num[l] = S1ParamList.paramarray[l][ENB_MME_BROADCAST_PLMN_INDEX].numelt;
-              else
+              } else {
                 S1AP_REGISTER_ENB_REQ(msg_p).broadcast_plmn_num[l] = 0;
+              }
 
               AssertFatal(S1AP_REGISTER_ENB_REQ(msg_p).broadcast_plmn_num[l] <= S1AP_REGISTER_ENB_REQ(msg_p).num_plmn,
                           "List of broadcast PLMN to be sent to MME can not be longer than actual "
@@ -2181,10 +2362,11 @@ int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
               if (S1AP_REGISTER_ENB_REQ(msg_p).broadcast_plmn_num[l] == 0) {
                 S1AP_REGISTER_ENB_REQ(msg_p).broadcast_plmn_num[l] = S1AP_REGISTER_ENB_REQ(msg_p).num_plmn;
 
-                for (int el = 0; el < S1AP_REGISTER_ENB_REQ(msg_p).num_plmn; ++el)
+                for (int el = 0; el < S1AP_REGISTER_ENB_REQ(msg_p).num_plmn; ++el) {
                   S1AP_REGISTER_ENB_REQ(msg_p).broadcast_plmn_index[l][el] = el;
                 }
               }
+            }
 
             // SCTP SETTING
             S1AP_REGISTER_ENB_REQ (msg_p).sctp_out_streams = SCTP_OUT_STREAMS;
@@ -2200,7 +2382,6 @@ int RCconfig_S1(MessageDef *msg_p, uint32_t i) {
             sprintf(aprefix,"%s.[%i].%s",ENB_CONFIG_STRING_ENB_LIST,k,ENB_CONFIG_STRING_NETWORK_INTERFACES_CONFIG);
             // NETWORK_INTERFACES
             config_get( NETParams,sizeof(NETParams)/sizeof(paramdef_t),aprefix);
-            //    S1AP_REGISTER_ENB_REQ (msg_p).enb_interface_name_for_S1U = strdup(enb_interface_name_for_S1U);
             cidr = *(NETParams[ENB_IPV4_ADDRESS_FOR_S1_MME_IDX].strptr);
             address = strtok(cidr, "/");
             S1AP_REGISTER_ENB_REQ (msg_p).enb_ip_address.ipv6 = 0;
@@ -2390,10 +2571,8 @@ int RCconfig_X2(MessageDef *msg_p, uint32_t i) {
                         || X2AP_REGISTER_ENB_REQ(msg_p).mnc < 100,
                         "MNC %d cannot be encoded in two digits as requested (change mnc_digit_length to 3)\n",
                         X2AP_REGISTER_ENB_REQ(msg_p).mnc);
-
             /* CC params */
             config_getlist(&CCsParamList, NULL, 0, aprefix);
-
             X2AP_REGISTER_ENB_REQ (msg_p).num_cc = CCsParamList.numelt;
 
             if (CCsParamList.numelt > 0) {
@@ -2440,7 +2619,6 @@ int RCconfig_X2(MessageDef *msg_p, uint32_t i) {
             AssertFatal(X2ParamList.numelt <= X2AP_MAX_NB_ENB_IP_ADDRESS,
                         "value of X2ParamList.numelt %d must be lower than X2AP_MAX_NB_ENB_IP_ADDRESS %d value: reconsider to increase X2AP_MAX_NB_ENB_IP_ADDRESS\n",
                         X2ParamList.numelt,X2AP_MAX_NB_ENB_IP_ADDRESS);
-
             X2AP_REGISTER_ENB_REQ (msg_p).nb_x2 = 0;
 
             for (l = 0; l < X2ParamList.numelt; l++) {

openair2/RRC/LTE/L2_interface.c

@@ -64,7 +64,6 @@ mac_rrc_data_req(
   uint8_t Sdu_size                = 0;
   uint8_t sfn                     = (uint8_t)((frameP>>2)&0xff);
 
-
   if (LOG_DEBUGFLAG(DEBUG_RRC)) {
     LOG_D(RRC,"[eNB %d] mac_rrc_data_req to SRB ID=%d\n",Mod_idP,Srb_id);
   }
@@ -72,8 +71,6 @@ mac_rrc_data_req(
   eNB_RRC_INST *rrc;
   rrc_eNB_carrier_data_t *carrier;
   LTE_BCCH_BCH_Message_t *mib;
-
-
   rrc     = RC.rrc[Mod_idP];
   carrier = &rrc->carrier[0];
   mib     = &carrier->mib;
@@ -118,13 +115,14 @@ mac_rrc_data_req(
 
         LOG_T(RRC,"\n");
       } /* LOG_DEBUGFLAG(DEBUG_RRC) */
+
       return(RC.rrc[Mod_idP]->carrier[CC_id].sizeof_SIB23);
     } else {
       return(0);
     }
   }
-    if( (Srb_id & RAB_OFFSET ) == MIBCH) {
 
+  if( (Srb_id & RAB_OFFSET ) == MIBCH) {
     mib->message.systemFrameNumber.buf = &sfn;
     enc_rval = uper_encode_to_buffer(&asn_DEF_LTE_BCCH_BCH_Message,
                                      NULL,
@@ -153,7 +151,6 @@ mac_rrc_data_req(
     // check if data is there for MAC
     if(Srb_info->Tx_buffer.payload_size>0) { //Fill buffer
       LOG_D(RRC,"[eNB %d] CCCH (%p) has %d bytes (dest: %p, src %p)\n",Mod_idP,Srb_info,Srb_info->Tx_buffer.payload_size,buffer_pP,Srb_info->Tx_buffer.Payload);
-
       memcpy(buffer_pP,Srb_info->Tx_buffer.Payload,Srb_info->Tx_buffer.payload_size);
       Sdu_size = Srb_info->Tx_buffer.payload_size;
       Srb_info->Tx_buffer.payload_size=0;
@@ -169,7 +166,6 @@ mac_rrc_data_req(
     if(RC.rrc[Mod_idP]->carrier[CC_id].sizeof_paging[mbsfn_sync_area] > 0) { //Fill buffer
       LOG_D(RRC,"[eNB %d] PCCH (%p) has %d bytes\n",Mod_idP,&RC.rrc[Mod_idP]->carrier[CC_id].paging[mbsfn_sync_area],
             RC.rrc[Mod_idP]->carrier[CC_id].sizeof_paging[mbsfn_sync_area]);
-
       memcpy(buffer_pP, RC.rrc[Mod_idP]->carrier[CC_id].paging[mbsfn_sync_area], RC.rrc[Mod_idP]->carrier[CC_id].sizeof_paging[mbsfn_sync_area]);
       Sdu_size = RC.rrc[Mod_idP]->carrier[CC_id].sizeof_paging[mbsfn_sync_area];
       RC.rrc[Mod_idP]->carrier[CC_id].sizeof_paging[mbsfn_sync_area] = 0;
@@ -203,8 +199,8 @@ mac_rrc_data_req(
   }
 
 #endif // #if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
-
 #if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
+
   if ((Srb_id & RAB_OFFSET) == BCCH_SIB1_BR) {
     memcpy(&buffer_pP[0],
            RC.rrc[Mod_idP]->carrier[CC_id].SIB1_BR,
@@ -220,8 +216,6 @@ mac_rrc_data_req(
   }
 
 #endif
-
-
   return(0);
 }
 
@@ -243,10 +237,8 @@ mac_rrc_data_ind(
   SRB_INFO *Srb_info;
   protocol_ctxt_t ctxt;
   sdu_size_t      sdu_size = 0;
-
   /* for no gcc warnings */
   (void)sdu_size;
-
   /*
   int si_window;
    */
@@ -263,9 +255,11 @@ mac_rrc_data_ind(
       rrc_eNB_decode_ccch(&ctxt, Srb_info, CC_id);
     }
   }
+
   if((srb_idP & RAB_OFFSET) == DCCH) {
     struct rrc_eNB_ue_context_s    *ue_context_p = NULL;
     ue_context_p = rrc_eNB_get_ue_context(RC.rrc[ctxt.module_id],rntiP);
+
     if(ue_context_p) {
       rrc_eNB_generate_defaultRRCConnectionReconfiguration(&ctxt,
           ue_context_p,
@@ -275,10 +269,12 @@ mac_rrc_data_ind(
   }
 
   return(0);
-
 }
 
 //------------------------------------------------------------------------------
+/*
+* Get RRC status (Connected, Idle...) of UE from RNTI
+*/
 int
 mac_eNB_get_rrc_status(
   const module_id_t Mod_idP,
@@ -287,9 +283,7 @@ mac_eNB_get_rrc_status(
 //------------------------------------------------------------------------------
 {
   struct rrc_eNB_ue_context_s *ue_context_p = NULL;
-  ue_context_p = rrc_eNB_get_ue_context(
+  ue_context_p = rrc_eNB_get_ue_context(RC.rrc[Mod_idP], rntiP);
-                   RC.rrc[Mod_idP],
-                   rntiP);
 
   if (ue_context_p != NULL) {
     return(ue_context_p->ue_context.Status);
@@ -302,8 +296,7 @@ void mac_eNB_rrc_ul_failure(const module_id_t Mod_instP,
                             const int CC_idP,
                             const frame_t frameP,
                             const sub_frame_t subframeP,
-			    const rnti_t rntiP)
+                            const rnti_t rntiP) {
-{
   struct rrc_eNB_ue_context_s *ue_context_p = NULL;
   ue_context_p = rrc_eNB_get_ue_context(
                    RC.rrc[Mod_instP],
@@ -311,17 +304,19 @@ void mac_eNB_rrc_ul_failure(const module_id_t Mod_instP,
 
   if (ue_context_p != NULL) {
     LOG_I(RRC,"Frame %d, Subframe %d: UE %x UL failure, activating timer\n",frameP,subframeP,rntiP);
+
     if(ue_context_p->ue_context.ul_failure_timer == 0)
       ue_context_p->ue_context.ul_failure_timer=1;
-  }
+  } else {
-  else {
     LOG_W(RRC,"Frame %d, Subframe %d: UL failure: UE %x unknown \n",frameP,subframeP,rntiP);
   }
+
   if (rrc_agent_registered[Mod_instP]) {
     agent_rrc_xface[Mod_instP]->flexran_agent_notify_ue_state_change(Mod_instP,
         rntiP,
         PROTOCOL__FLEX_UE_STATE_CHANGE_TYPE__FLUESC_DEACTIVATED);
   }
+
   rrc_mac_remove_ue(Mod_instP,rntiP);
 }
 
@@ -329,19 +324,18 @@ void mac_eNB_rrc_uplane_failure(const module_id_t Mod_instP,
                                 const int CC_idP,
                                 const frame_t frameP,
                                 const sub_frame_t subframeP,
-                const rnti_t rntiP)
+                                const rnti_t rntiP) {
-{
   struct rrc_eNB_ue_context_s *ue_context_p = NULL;
   ue_context_p = rrc_eNB_get_ue_context(
                    RC.rrc[Mod_instP],
                    rntiP);
+
   if (ue_context_p != NULL) {
     LOG_I(RRC,"Frame %d, Subframe %d: UE %x U-Plane failure, activating timer\n",frameP,subframeP,rntiP);
 
     if(ue_context_p->ue_context.ul_failure_timer == 0)
       ue_context_p->ue_context.ul_failure_timer=19999;
-    }
+  } else {
-    else {
     LOG_W(RRC,"Frame %d, Subframe %d: U-Plane failure: UE %x unknown \n",frameP,subframeP,rntiP);
   }
 }
@@ -350,8 +344,7 @@ void mac_eNB_rrc_ul_in_sync(const module_id_t Mod_instP,
                             const int CC_idP,
                             const frame_t frameP,
                             const sub_frame_t subframeP,
-			    const rnti_t rntiP)
+                            const rnti_t rntiP) {
-{
   struct rrc_eNB_ue_context_s *ue_context_p = NULL;
   ue_context_p = rrc_eNB_get_ue_context(
                    RC.rrc[Mod_instP],

openair2/RRC/LTE/MESSAGES/asn1_msg.h

@@ -57,7 +57,7 @@ uint16_t get_adjacent_cell_id(uint8_t Mod_id,uint8_t index);
 uint8_t get_adjacent_cell_mod_id(uint16_t phyCellId);
 
 /**
-\brief Generate configuration for SIB1 (eNB).
+\brief Generate configuration for MIB (eNB).
 @param carrier pointer to Carrier information
 @param N_RB_DL Number of downlink PRBs
 @param phich_Resource PHICH resoure parameter

openair2/RRC/LTE/rrc_defs.h

@@ -552,7 +552,7 @@ typedef struct eNB_RRC_UE_s {
   LTE_CipheringAlgorithm_r12_t                          ciphering_algorithm;
   e_LTE_SecurityAlgorithmConfig__integrityProtAlgorithm integrity_algorithm;
 
-  uint8_t                            Status;
+  uint8_t                            Status; // RRC status, type enum UE_STATE_t
   rnti_t                             rnti;
   uint64_t                           random_ue_identity;
 
@@ -599,6 +599,8 @@ typedef struct eNB_RRC_UE_s {
   uint32_t                           ue_release_timer_thres_rrc;
   uint32_t                           ue_reestablishment_timer;
   uint32_t                           ue_reestablishment_timer_thres;
+  /* RRC inactivity timer: on timeout, should release RRC connection for inactivity on all E-RABs */
+  uint32_t                           ue_rrc_inactivity_timer;
   uint8_t                            e_rab_release_command_flag;
   int8_t                             reestablishment_xid;
 } eNB_RRC_UE_t;

openair3/S1AP/s1ap_eNB.c

@@ -74,22 +74,17 @@ void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *
 
 void s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp);
 
-uint32_t s1ap_generate_eNB_id(void)
+uint32_t s1ap_generate_eNB_id(void) {
-{
   char    *out;
   char     hostname[50];
   int      ret;
   uint32_t eNB_id;
-
   /* Retrieve the host name */
   ret = gethostname(hostname, sizeof(hostname));
   DevAssert(ret == 0);
-
   out = crypt(hostname, "eurecom");
   DevAssert(out != NULL);
-
   eNB_id = ((out[0] << 24) | (out[1] << 16) | (out[2] << 8) | out[3]);
-
   return eNB_id;
 }
 
@@ -99,55 +94,42 @@ static void s1ap_eNB_register_mme(s1ap_eNB_instance_t *instance_p,
                                   uint16_t             in_streams,
                                   uint16_t             out_streams,
                                   uint8_t              broadcast_plmn_num,
-                                  uint8_t              broadcast_plmn_index[PLMN_LIST_MAX_SIZE])
+                                  uint8_t              broadcast_plmn_index[PLMN_LIST_MAX_SIZE]) {
-{
   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);
-
   message_p = itti_alloc_new_message(TASK_S1AP, SCTP_NEW_ASSOCIATION_REQ);
-
   sctp_new_association_req_p = &message_p->ittiMsg.sctp_new_association_req;
-
   sctp_new_association_req_p->port = S1AP_PORT_NUMBER;
   sctp_new_association_req_p->ppid = S1AP_SCTP_PPID;
-
   sctp_new_association_req_p->in_streams  = in_streams;
   sctp_new_association_req_p->out_streams = out_streams;
-
   memcpy(&sctp_new_association_req_p->remote_address,
          mme_ip_address,
          sizeof(*mme_ip_address));
-
   memcpy(&sctp_new_association_req_p->local_address,
          local_ip_addr,
          sizeof(*local_ip_addr));
-
   S1AP_INFO("[eNB %d] check the mme registration state\n",instance_p->instance);
-	      
   mme = NULL;
 
   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->broadcast_plmn_num = broadcast_plmn_num;
+
     for (int i = 0; i < broadcast_plmn_num; ++i)
       s1ap_mme_data_p->broadcast_plmn_index[i] = broadcast_plmn_index[i];
+
     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.
      */
@@ -158,12 +140,10 @@ static void s1ap_eNB_register_mme(s1ap_eNB_instance_t *instance_p,
   } 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;
 
@@ -181,13 +161,10 @@ static void s1ap_eNB_register_mme(s1ap_eNB_instance_t *instance_p,
 }
 
 
-void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *s1ap_register_eNB)
+void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *s1ap_register_eNB) {
-{
   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);
 
@@ -197,38 +174,36 @@ void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *
     DevCheck(new_instance->cell_type == s1ap_register_eNB->cell_type, new_instance->cell_type, s1ap_register_eNB->cell_type, 0);
     DevCheck(new_instance->num_plmn == s1ap_register_eNB->num_plmn, new_instance->num_plmn, s1ap_register_eNB->num_plmn, 0);
     DevCheck(new_instance->tac == s1ap_register_eNB->tac, new_instance->tac, s1ap_register_eNB->tac, 0);
-    for (int i = 0; i < new_instance->num_plmn; i++)
+
-    {
+    for (int i = 0; i < new_instance->num_plmn; i++) {
       DevCheck(new_instance->mcc[i] == s1ap_register_eNB->mcc[i], new_instance->mcc[i], s1ap_register_eNB->mcc[i], 0);
       DevCheck(new_instance->mnc[i] == s1ap_register_eNB->mnc[i], new_instance->mnc[i], s1ap_register_eNB->mnc[i], 0);
       DevCheck(new_instance->mnc_digit_length[i] == s1ap_register_eNB->mnc_digit_length[i], new_instance->mnc_digit_length[i], s1ap_register_eNB->mnc_digit_length[i], 0);
     }
+
     DevCheck(new_instance->default_drx == s1ap_register_eNB->default_drx, new_instance->default_drx, s1ap_register_eNB->default_drx, 0);
   } else {
     new_instance = calloc(1, sizeof(s1ap_eNB_instance_t));
     DevAssert(new_instance != NULL);
-
     RB_INIT(&new_instance->s1ap_ue_head);
     RB_INIT(&new_instance->s1ap_mme_head);
-
     /* Copy usefull parameters */
     new_instance->instance         = instance;
     new_instance->eNB_name         = s1ap_register_eNB->eNB_name;
     new_instance->eNB_id           = s1ap_register_eNB->eNB_id;
     new_instance->cell_type        = s1ap_register_eNB->cell_type;
     new_instance->tac              = s1ap_register_eNB->tac;
-    for (int i = 0; i < s1ap_register_eNB->num_plmn; i++)
+
-    {
+    for (int i = 0; i < s1ap_register_eNB->num_plmn; i++) {
       new_instance->mcc[i]              = s1ap_register_eNB->mcc[i];
       new_instance->mnc[i]              = s1ap_register_eNB->mnc[i];
       new_instance->mnc_digit_length[i] = s1ap_register_eNB->mnc_digit_length[i];
     }
+
     new_instance->num_plmn         = s1ap_register_eNB->num_plmn;
     new_instance->default_drx      = s1ap_register_eNB->default_drx;
-
     /* Add the new instance to the list of eNB (meaningfull in virtual mode) */
     s1ap_eNB_insert_new_instance(new_instance);
-
     S1AP_INFO("Registered new eNB[%d] and %s eNB id %u\n",
               instance,
               s1ap_register_eNB->cell_type == CELL_MACRO_ENB ? "macro" : "home",
@@ -250,16 +225,12 @@ void s1ap_eNB_handle_register_eNB(instance_t instance, s1ap_register_enb_req_t *
   }
 }
 
-void s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp)
+void s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp) {
-{
   s1ap_eNB_instance_t *instance_p;
   s1ap_eNB_mme_data_t *s1ap_mme_data_p;
-
   DevAssert(sctp_new_association_resp != NULL);
-
   instance_p = s1ap_eNB_get_instance(instance);
   DevAssert(instance_p != NULL);
-
   s1ap_mme_data_p = s1ap_eNB_get_MME(instance_p, -1,
                                      sctp_new_association_resp->ulp_cnx_id);
   DevAssert(s1ap_mme_data_p != NULL);
@@ -269,9 +240,7 @@ void s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_associa
               sctp_new_association_resp->sctp_state,
               instance,
               sctp_new_association_resp->ulp_cnx_id);
-
     s1ap_handle_s1_setup_message(s1ap_mme_data_p, sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN);
-
     return;
   }
 
@@ -279,16 +248,13 @@ void s1ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_associa
   s1ap_mme_data_p->assoc_id    = sctp_new_association_resp->assoc_id;
   s1ap_mme_data_p->in_streams  = sctp_new_association_resp->in_streams;
   s1ap_mme_data_p->out_streams = sctp_new_association_resp->out_streams;
-
   /* Prepare new S1 Setup Request */
   s1ap_eNB_generate_s1_setup_request(instance_p, s1ap_mme_data_p);
 }
 
 static
-void s1ap_eNB_handle_sctp_data_ind(sctp_data_ind_t *sctp_data_ind)
+void s1ap_eNB_handle_sctp_data_ind(sctp_data_ind_t *sctp_data_ind) {
-{
   int result;
-
   DevAssert(sctp_data_ind != NULL);
 #if defined(TEST_S1C_MME)
   mme_test_s1_notify_sctp_data_ind(sctp_data_ind->assoc_id, sctp_data_ind->stream,
@@ -301,18 +267,14 @@ void s1ap_eNB_handle_sctp_data_ind(sctp_data_ind_t *sctp_data_ind)
   AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
 }
 
-void s1ap_eNB_init(void)
+void s1ap_eNB_init(void) {
-{
   S1AP_DEBUG("Starting S1AP layer\n");
-
   s1ap_eNB_prepare_internal_data();
-
   itti_mark_task_ready(TASK_S1AP);
   MSC_START_USE();
 }
 
-void *s1ap_eNB_process_itti_msg(void* notUsed)
+void *s1ap_eNB_process_itti_msg(void *notUsed) {
-{
   MessageDef *received_msg = NULL;
   int         result;
   itti_receive_msg(TASK_S1AP, &received_msg);
@@ -396,11 +358,8 @@ void *s1ap_eNB_process_itti_msg(void* notUsed)
     case S1AP_UE_CONTEXT_RELEASE_REQ: {
       s1ap_eNB_instance_t               *s1ap_eNB_instance_p           = NULL; // test
       struct s1ap_eNB_ue_context_s      *ue_context_p                  = NULL; // test
-
       s1ap_ue_context_release_req(ITTI_MESSAGE_GET_INSTANCE(received_msg),
                                   &S1AP_UE_CONTEXT_RELEASE_REQ(received_msg));
-
-
       s1ap_eNB_instance_p = s1ap_eNB_get_instance(ITTI_MESSAGE_GET_INSTANCE(received_msg)); // test
       DevAssert(s1ap_eNB_instance_p != NULL); // test
 
@@ -427,14 +386,12 @@ void *s1ap_eNB_process_itti_msg(void* notUsed)
 
   result = itti_free (ITTI_MSG_ORIGIN_ID(received_msg), received_msg);
   AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
-
   received_msg = NULL;
   return NULL;
 }
 
 
-void *s1ap_eNB_task(void *arg)
+void *s1ap_eNB_task(void *arg) {
-{
   s1ap_eNB_init();
 
   while (1) {
@@ -444,23 +401,26 @@ void *s1ap_eNB_task(void *arg)
   return NULL;
 }
 
+//-----------------------------------------------------------------------------
+/*
+* eNB generate a S1 setup request towards MME
+*/
 static int s1ap_eNB_generate_s1_setup_request(
-  s1ap_eNB_instance_t *instance_p, s1ap_eNB_mme_data_t *s1ap_mme_data_p)
+  s1ap_eNB_instance_t *instance_p,
+  s1ap_eNB_mme_data_t *s1ap_mme_data_p)
+//-----------------------------------------------------------------------------
 {
   S1AP_S1AP_PDU_t            pdu;
-  S1AP_S1SetupRequest_t              *out;
+  S1AP_S1SetupRequest_t     *out = NULL;
-  S1AP_S1SetupRequestIEs_t           *ie;
+  S1AP_S1SetupRequestIEs_t   *ie = NULL;
-  S1AP_SupportedTAs_Item_t           *ta;
+  S1AP_SupportedTAs_Item_t   *ta = NULL;
-  S1AP_PLMNidentity_t                *plmn;
+  S1AP_PLMNidentity_t      *plmn = NULL;
-  uint8_t  *buffer;
+  uint8_t  *buffer = NULL;
-  uint32_t  len;
+  uint32_t  len = 0;
   int       ret = 0;
-
   DevAssert(instance_p != NULL);
   DevAssert(s1ap_mme_data_p != NULL);
-
   s1ap_mme_data_p->state = S1AP_ENB_STATE_WAITING;
-
   /* Prepare the S1AP message to encode */
   memset(&pdu, 0, sizeof(pdu));
   pdu.present = S1AP_S1AP_PDU_PR_initiatingMessage;
@@ -468,7 +428,6 @@ static int s1ap_eNB_generate_s1_setup_request(
   pdu.choice.initiatingMessage.criticality = S1AP_Criticality_reject;
   pdu.choice.initiatingMessage.value.present = S1AP_InitiatingMessage__value_PR_S1SetupRequest;
   out = &pdu.choice.initiatingMessage.value.choice.S1SetupRequest;
-
   /* mandatory */
   ie = (S1AP_S1SetupRequestIEs_t *)calloc(1, sizeof(S1AP_S1SetupRequestIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_Global_ENB_ID;
@@ -519,7 +478,6 @@ static int s1ap_eNB_generate_s1_setup_request(
     ASN_SEQUENCE_ADD(&ie->value.choice.SupportedTAs.list, ta);
   }
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_S1SetupRequestIEs_t *)calloc(1, sizeof(S1AP_S1SetupRequestIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_DefaultPagingDRX;
@@ -540,6 +498,7 @@ static int s1ap_eNB_generate_s1_setup_request(
 
   /* optional */
 #if (S1AP_VERSION >= MAKE_VERSION(13, 0, 0))
+
   if (0) {
     ie = (S1AP_S1SetupRequestIEs_t *)calloc(1, sizeof(S1AP_S1SetupRequestIEs_t));
     ie->id = S1AP_ProtocolIE_ID_id_UE_RetentionInformation;
@@ -558,6 +517,7 @@ static int s1ap_eNB_generate_s1_setup_request(
     // ie->value.choice.NB_IoT_DefaultPagingDRX = ;
     ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
   }
+
 #endif /* #if (S1AP_VERSION >= MAKE_VERSION(14, 0, 0)) */
 
   if (s1ap_eNB_encode_pdu(&pdu, &buffer, &len) < 0) {
@@ -567,6 +527,5 @@ static int s1ap_eNB_generate_s1_setup_request(
 
   /* Non UE-Associated signalling -> stream = 0 */
   s1ap_eNB_itti_send_sctp_data_req(instance_p->instance, s1ap_mme_data_p->assoc_id, buffer, len, 0);
-
   return ret;
 }

openair3/S1AP/s1ap_eNB_handlers.c

@@ -156,8 +156,7 @@ static char *s1ap_direction_String[] = {
   };
   return(s1ap_direction_String[s1ap_dir]);
 }
-void s1ap_handle_s1_setup_message(s1ap_eNB_mme_data_t *mme_desc_p, int sctp_shutdown)
+void s1ap_handle_s1_setup_message(s1ap_eNB_mme_data_t *mme_desc_p, int sctp_shutdown) {
-{
   if (sctp_shutdown) {
     /* A previously connected MME has been shutdown */
 
@@ -173,7 +172,6 @@ void s1ap_handle_s1_setup_message(s1ap_eNB_mme_data_t *mme_desc_p, int sctp_shut
       /* If there are no more associated MME, inform eNB app */
       if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb == 0) {
         MessageDef                 *message_p;
-
         message_p = itti_alloc_new_message(TASK_S1AP, S1AP_DEREGISTERED_ENB_IND);
         S1AP_DEREGISTERED_ENB_IND(message_p).nb_mme = 0;
         itti_send_msg_to_task(TASK_ENB_APP, mme_desc_p->s1ap_eNB_instance->instance, message_p);
@@ -192,7 +190,6 @@ void s1ap_handle_s1_setup_message(s1ap_eNB_mme_data_t *mme_desc_p, int sctp_shut
     /* If there are no more pending messages, inform eNB app */
     if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb == 0) {
       MessageDef                 *message_p;
-
       message_p = itti_alloc_new_message(TASK_S1AP, S1AP_REGISTER_ENB_CNF);
       S1AP_REGISTER_ENB_CNF(message_p).nb_mme = mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb;
       itti_send_msg_to_task(TASK_ENB_APP, mme_desc_p->s1ap_eNB_instance->instance, message_p);
@@ -201,13 +198,10 @@ void s1ap_handle_s1_setup_message(s1ap_eNB_mme_data_t *mme_desc_p, int sctp_shut
 }
 
 int s1ap_eNB_handle_message(uint32_t assoc_id, int32_t stream,
-                            const uint8_t *const data, const uint32_t data_length)
+                            const uint8_t *const data, const uint32_t data_length) {
-{
   S1AP_S1AP_PDU_t pdu;
   int ret;
-
   DevAssert(data != NULL);
-
   memset(&pdu, 0, sizeof(pdu));
 
   if (s1ap_eNB_decode_pdu(&pdu, data, data_length) < 0) {
@@ -246,14 +240,11 @@ int s1ap_eNB_handle_message(uint32_t assoc_id, int32_t stream,
 static
 int s1ap_eNB_handle_s1_setup_failure(uint32_t               assoc_id,
                                      uint32_t               stream,
-                                     S1AP_S1AP_PDU_t       *pdu)
+                                     S1AP_S1AP_PDU_t       *pdu) {
-{
   S1AP_S1SetupFailure_t      *container;
   S1AP_S1SetupFailureIEs_t   *ie;
   s1ap_eNB_mme_data_t        *mme_desc_p;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.unsuccessfulOutcome.value.choice.S1SetupFailure;
 
   /* S1 Setup Failure == Non UE-related procedure -> stream 0 */
@@ -280,22 +271,18 @@ int s1ap_eNB_handle_s1_setup_failure(uint32_t               assoc_id,
 
   mme_desc_p->state = S1AP_ENB_STATE_WAITING;
   s1ap_handle_s1_setup_message(mme_desc_p, 0);
-
   return 0;
 }
 
 static
 int s1ap_eNB_handle_s1_setup_response(uint32_t               assoc_id,
                                       uint32_t               stream,
-                                      S1AP_S1AP_PDU_t       *pdu)
+                                      S1AP_S1AP_PDU_t       *pdu) {
-{
   S1AP_S1SetupResponse_t    *container;
   S1AP_S1SetupResponseIEs_t *ie;
   s1ap_eNB_mme_data_t       *mme_desc_p;
   int i;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.successfulOutcome.value.choice.S1SetupResponse;
 
   /* S1 Setup Response == Non UE-related procedure -> stream 0 */
@@ -324,20 +311,16 @@ int s1ap_eNB_handle_s1_setup_response(uint32_t               assoc_id,
     S1AP_ServedGUMMEIsItem_t *gummei_item_p;
     struct served_gummei_s   *new_gummei_p;
     int j;
-
     gummei_item_p = ie->value.choice.ServedGUMMEIs.list.array[i];
     new_gummei_p = calloc(1, sizeof(struct served_gummei_s));
-
     STAILQ_INIT(&new_gummei_p->served_plmns);
     STAILQ_INIT(&new_gummei_p->served_group_ids);
     STAILQ_INIT(&new_gummei_p->mme_codes);
-
     S1AP_DEBUG("servedPLMNs.list.count %d\n", gummei_item_p->servedPLMNs.list.count);
 
     for (j = 0; j < gummei_item_p->servedPLMNs.list.count; j++) {
       S1AP_PLMNidentity_t *plmn_identity_p;
       struct plmn_identity_s *new_plmn_identity_p;
-
       plmn_identity_p = gummei_item_p->servedPLMNs.list.array[j];
       new_plmn_identity_p = calloc(1, sizeof(struct plmn_identity_s));
       TBCD_TO_MCC_MNC(plmn_identity_p, new_plmn_identity_p->mcc,
@@ -349,7 +332,6 @@ int s1ap_eNB_handle_s1_setup_response(uint32_t               assoc_id,
     for (j = 0; j < gummei_item_p->servedGroupIDs.list.count; j++) {
       S1AP_MME_Group_ID_t           *mme_group_id_p;
       struct served_group_id_s *new_group_id_p;
-
       mme_group_id_p = gummei_item_p->servedGroupIDs.list.array[j];
       new_group_id_p = calloc(1, sizeof(struct served_group_id_s));
       OCTET_STRING_TO_INT16(mme_group_id_p, new_group_id_p->mme_group_id);
@@ -360,10 +342,8 @@ int s1ap_eNB_handle_s1_setup_response(uint32_t               assoc_id,
     for (j = 0; j < gummei_item_p->servedMMECs.list.count; j++) {
       S1AP_MME_Code_t        *mme_code_p;
       struct mme_code_s *new_mme_code_p;
-
       mme_code_p = gummei_item_p->servedMMECs.list.array[j];
       new_mme_code_p = calloc(1, sizeof(struct mme_code_s));
-
       OCTET_STRING_TO_INT8(mme_code_p, new_mme_code_p->mme_code);
       STAILQ_INSERT_TAIL(&new_gummei_p->mme_codes, new_mme_code_p, next);
       new_gummei_p->nb_mme_code++;
@@ -376,10 +356,10 @@ int s1ap_eNB_handle_s1_setup_response(uint32_t               assoc_id,
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_S1SetupResponseIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_RelativeMMECapacity, true);
   mme_desc_p->relative_mme_capacity = ie->value.choice.RelativeMMECapacity;
-
   /* Optionaly set the mme name */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_S1SetupResponseIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_MMEname, false);
+
   if (ie) {
     mme_desc_p->mme_name = calloc(ie->value.choice.MMEname.size + 1, sizeof(char));
     memcpy(mme_desc_p->mme_name, ie->value.choice.MMEname.buf,
@@ -394,7 +374,6 @@ int s1ap_eNB_handle_s1_setup_response(uint32_t               assoc_id,
   mme_desc_p->state = S1AP_ENB_STATE_CONNECTED;
   mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb ++;
   s1ap_handle_s1_setup_message(mme_desc_p, 0);
-
   return 0;
 }
 
@@ -402,14 +381,11 @@ int s1ap_eNB_handle_s1_setup_response(uint32_t               assoc_id,
 static
 int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
                                      uint32_t         stream,
-                                     S1AP_S1AP_PDU_t *pdu)
+                                     S1AP_S1AP_PDU_t *pdu) {
-{
   S1AP_ErrorIndication_t    *container;
   S1AP_ErrorIndicationIEs_t *ie;
   s1ap_eNB_mme_data_t        *mme_desc_p;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.initiatingMessage.value.choice.ErrorIndication;
 
   /* S1 Setup Failure == Non UE-related procedure -> stream 0 */
@@ -455,118 +431,156 @@ int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
           case S1AP_CauseRadioNetwork_unspecified:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_unspecified\n");
             break;
+
           case S1AP_CauseRadioNetwork_tx2relocoverall_expiry:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_tx2relocoverall_expiry\n");
             break;
+
           case S1AP_CauseRadioNetwork_successful_handover:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_successful_handover\n");
             break;
+
           case S1AP_CauseRadioNetwork_release_due_to_eutran_generated_reason:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_release_due_to_eutran_generated_reason\n");
             break;
+
           case S1AP_CauseRadioNetwork_handover_cancelled:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_handover_cancelled\n");
             break;
+
           case S1AP_CauseRadioNetwork_partial_handover:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_partial_handover\n");
             break;
+
           case S1AP_CauseRadioNetwork_ho_failure_in_target_EPC_eNB_or_target_system:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_ho_failure_in_target_EPC_eNB_or_target_system\n");
             break;
+
           case S1AP_CauseRadioNetwork_ho_target_not_allowed:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_ho_target_not_allowed\n");
             break;
+
           case S1AP_CauseRadioNetwork_tS1relocoverall_expiry:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_tS1relocoverall_expiry\n");
             break;
+
           case S1AP_CauseRadioNetwork_tS1relocprep_expiry:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_tS1relocprep_expiry\n");
             break;
+
           case S1AP_CauseRadioNetwork_cell_not_available:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_cell_not_available\n");
             break;
+
           case S1AP_CauseRadioNetwork_unknown_targetID:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_unknown_targetID\n");
             break;
+
           case S1AP_CauseRadioNetwork_no_radio_resources_available_in_target_cell:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_no_radio_resources_available_in_target_cell\n");
             break;
+
           case S1AP_CauseRadioNetwork_unknown_mme_ue_s1ap_id:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_unknown_mme_ue_s1ap_id\n");
             break;
+
           case S1AP_CauseRadioNetwork_unknown_enb_ue_s1ap_id:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_unknown_enb_ue_s1ap_id\n");
             break;
+
           case S1AP_CauseRadioNetwork_unknown_pair_ue_s1ap_id:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_unknown_pair_ue_s1ap_id\n");
             break;
+
           case S1AP_CauseRadioNetwork_handover_desirable_for_radio_reason:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_handover_desirable_for_radio_reason\n");
             break;
+
           case S1AP_CauseRadioNetwork_time_critical_handover:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_time_critical_handover\n");
             break;
+
           case S1AP_CauseRadioNetwork_resource_optimisation_handover:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_resource_optimisation_handover\n");
             break;
+
           case S1AP_CauseRadioNetwork_reduce_load_in_serving_cell:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_reduce_load_in_serving_cell\n");
             break;
+
           case S1AP_CauseRadioNetwork_user_inactivity:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_user_inactivity\n");
             break;
+
           case S1AP_CauseRadioNetwork_radio_connection_with_ue_lost:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_radio_connection_with_ue_lost\n");
             break;
+
           case S1AP_CauseRadioNetwork_load_balancing_tau_required:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_load_balancing_tau_required\n");
             break;
+
           case S1AP_CauseRadioNetwork_cs_fallback_triggered:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_cs_fallback_triggered\n");
             break;
+
           case S1AP_CauseRadioNetwork_ue_not_available_for_ps_service:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_ue_not_available_for_ps_service\n");
             break;
+
           case S1AP_CauseRadioNetwork_radio_resources_not_available:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_radio_resources_not_available\n");
             break;
+
           case S1AP_CauseRadioNetwork_failure_in_radio_interface_procedure:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_failure_in_radio_interface_procedure\n");
             break;
+
           case S1AP_CauseRadioNetwork_invalid_qos_combination:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_invals1ap_id_qos_combination\n");
             break;
+
           case S1AP_CauseRadioNetwork_interrat_redirection:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_interrat_redirection\n");
             break;
+
           case S1AP_CauseRadioNetwork_interaction_with_other_procedure:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_interaction_with_other_procedure\n");
             break;
+
           case S1AP_CauseRadioNetwork_unknown_E_RAB_ID:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_unknown_E_RAB_ID\n");
             break;
+
           case S1AP_CauseRadioNetwork_multiple_E_RAB_ID_instances:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_multiple_E_RAB_ID_instances\n");
             break;
+
           case S1AP_CauseRadioNetwork_encryption_and_or_integrity_protection_algorithms_not_supported:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_encryption_and_or_integrity_protection_algorithms_not_supported\n");
             break;
+
           case S1AP_CauseRadioNetwork_s1_intra_system_handover_triggered:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_s1_intra_system_handover_triggered\n");
             break;
+
           case S1AP_CauseRadioNetwork_s1_inter_system_handover_triggered:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_s1_inter_system_handover_triggered\n");
             break;
+
           case S1AP_CauseRadioNetwork_x2_handover_triggered:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_x2_handover_triggered\n");
             break;
+
           case S1AP_CauseRadioNetwork_redirection_towards_1xRTT:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_redirection_towards_1xRTT\n");
             break;
+
           case S1AP_CauseRadioNetwork_not_supported_QCI_value:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_not_supported_QCI_value\n");
             break;
 #if (S1AP_VERSION >= MAKE_VERSION(9, 0, 0))
+
           case S1AP_CauseRadioNetwork_invalid_CSG_Id:
             S1AP_WARN("Received S1 Error indication S1AP_CauseRadioNetwork_invals1ap_id_CSG_Id\n");
             break;
@@ -575,6 +589,7 @@ int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
           default:
             S1AP_WARN("Received S1 Error indication cause radio network case not handled\n");
         }
+
         break;
 
       case S1AP_Cause_PR_transport:
@@ -582,12 +597,15 @@ int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
           case S1AP_CauseTransport_transport_resource_unavailable:
             S1AP_WARN("Received S1 Error indication S1AP_CauseTransport_transport_resource_unavailable\n");
             break;
+
           case S1AP_CauseTransport_unspecified:
             S1AP_WARN("Received S1 Error indication S1AP_CauseTransport_unspecified\n");
             break;
+
           default:
             S1AP_WARN("Received S1 Error indication cause transport case not handled\n");
         }
+
         break;
 
       case S1AP_Cause_PR_nas:
@@ -595,20 +613,25 @@ int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
           case S1AP_CauseNas_normal_release:
             S1AP_WARN("Received S1 Error indication S1AP_CauseNas_normal_release\n");
             break;
+
           case S1AP_CauseNas_authentication_failure:
             S1AP_WARN("Received S1 Error indication S1AP_CauseNas_authentication_failure\n");
             break;
+
           case S1AP_CauseNas_detach:
             S1AP_WARN("Received S1 Error indication S1AP_CauseNas_detach\n");
             break;
+
           case S1AP_CauseNas_unspecified:
             S1AP_WARN("Received S1 Error indication S1AP_CauseNas_unspecified\n");
             break;
 #if (S1AP_VERSION >= MAKE_VERSION(9, 0, 0))
+
           case S1AP_CauseNas_csg_subscription_expiry:
             S1AP_WARN("Received S1 Error indication S1AP_CauseNas_csg_subscription_expiry\n");
             break;
 #endif /* #if (S1AP_VERSION >= MAKE_VERSION(9, 0, 0)) */
+
           default:
             S1AP_WARN("Received S1 Error indication cause nas case not handled\n");
         }
@@ -620,27 +643,35 @@ int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
           case S1AP_CauseProtocol_transfer_syntax_error:
             S1AP_WARN("Received S1 Error indication S1AP_CauseProtocol_transfer_syntax_error\n");
             break;
+
           case S1AP_CauseProtocol_abstract_syntax_error_reject:
             S1AP_WARN("Received S1 Error indication S1AP_CauseProtocol_abstract_syntax_error_reject\n");
             break;
+
           case S1AP_CauseProtocol_abstract_syntax_error_ignore_and_notify:
             S1AP_WARN("Received S1 Error indication S1AP_CauseProtocol_abstract_syntax_error_ignore_and_notify\n");
             break;
+
           case S1AP_CauseProtocol_message_not_compatible_with_receiver_state:
             S1AP_WARN("Received S1 Error indication S1AP_CauseProtocol_message_not_compatible_with_receiver_state\n");
             break;
+
           case S1AP_CauseProtocol_semantic_error:
             S1AP_WARN("Received S1 Error indication S1AP_CauseProtocol_semantic_error\n");
             break;
+
           case S1AP_CauseProtocol_abstract_syntax_error_falsely_constructed_message:
             S1AP_WARN("Received S1 Error indication S1AP_CauseProtocol_abstract_syntax_error_falsely_constructed_message\n");
             break;
+
           case S1AP_CauseProtocol_unspecified:
             S1AP_WARN("Received S1 Error indication S1AP_CauseProtocol_unspecified\n");
             break;
+
           default:
             S1AP_WARN("Received S1 Error indication cause protocol case not handled\n");
         }
+
         break;
 
       case S1AP_Cause_PR_misc:
@@ -648,24 +679,31 @@ int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
           case S1AP_CauseMisc_control_processing_overload:
             S1AP_WARN("Received S1 Error indication S1AP_CauseMisc_control_processing_overload\n");
             break;
+
           case S1AP_CauseMisc_not_enough_user_plane_processing_resources:
             S1AP_WARN("Received S1 Error indication S1AP_CauseMisc_not_enough_user_plane_processing_resources\n");
             break;
+
           case S1AP_CauseMisc_hardware_failure:
             S1AP_WARN("Received S1 Error indication S1AP_CauseMisc_hardware_failure\n");
             break;
+
           case S1AP_CauseMisc_om_intervention:
             S1AP_WARN("Received S1 Error indication S1AP_CauseMisc_om_intervention\n");
             break;
+
           case S1AP_CauseMisc_unspecified:
             S1AP_WARN("Received S1 Error indication S1AP_CauseMisc_unspecified\n");
             break;
+
           case S1AP_CauseMisc_unknown_PLMN:
             S1AP_WARN("Received S1 Error indication S1AP_CauseMisc_unknown_PLMN\n");
             break;
+
           default:
             S1AP_WARN("Received S1 Error indication cause misc case not handled\n");
         }
+
         break;
     }
   }
@@ -676,8 +714,8 @@ int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
   if (ie) {
     // TODO continue
   }
-  // TODO continue
 
+  // TODO continue
   return 0;
 }
 
@@ -685,8 +723,7 @@ int s1ap_eNB_handle_error_indication(uint32_t         assoc_id,
 static
 int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
     uint32_t               stream,
-    S1AP_S1AP_PDU_t       *pdu)
+    S1AP_S1AP_PDU_t       *pdu) {
-{
   int i;
   s1ap_eNB_mme_data_t   *mme_desc_p       = NULL;
   s1ap_eNB_ue_context_t *ue_desc_p        = NULL;
@@ -695,9 +732,7 @@ int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
   S1AP_InitialContextSetupRequestIEs_t *ie;
   S1AP_ENB_UE_S1AP_ID_t    enb_ue_s1ap_id;
   S1AP_MME_UE_S1AP_ID_t    mme_ue_s1ap_id;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.initiatingMessage.value.choice.InitialContextSetupRequest;
 
   if ((mme_desc_p = s1ap_eNB_get_MME(NULL, assoc_id, 0)) == NULL) {
@@ -710,7 +745,6 @@ int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_InitialContextSetupRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID, true);
   mme_ue_s1ap_id = ie->value.choice.MME_UE_S1AP_ID;
-
   /* id-eNB-UE-S1AP-ID */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_InitialContextSetupRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID, true);
@@ -732,16 +766,11 @@ int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
   }
 
   ue_desc_p->rx_stream = stream;
-
   ue_desc_p->mme_ue_s1ap_id = mme_ue_s1ap_id;
-
   message_p        = itti_alloc_new_message(TASK_S1AP, S1AP_INITIAL_CONTEXT_SETUP_REQ);
-
   S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).ue_initial_id  = ue_desc_p->ue_initial_id;
   ue_desc_p->ue_initial_id = 0;
-
   S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).eNB_ue_s1ap_id = ue_desc_p->eNB_ue_s1ap_id;
-
   /* id-uEaggregateMaximumBitrate */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_InitialContextSetupRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_uEaggregateMaximumBitrate, true);
@@ -749,11 +778,9 @@ int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
                     &(S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).ue_ambr.br_ul));
   asn_INTEGER2ulong(&(ie->value.choice.UEAggregateMaximumBitrate.uEaggregateMaximumBitRateDL),
                     &(S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).ue_ambr.br_dl));
-
   /* id-E-RABToBeSetupListCtxtSUReq */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_InitialContextSetupRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_E_RABToBeSetupListCtxtSUReq, true);
-
   S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).nb_of_e_rabs =
     ie->value.choice.E_RABToBeSetupListCtxtSUReq.list.count;
 
@@ -765,10 +792,8 @@ int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
     if (item_p->nAS_PDU != NULL) {
       /* Only copy NAS pdu if present */
       S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.length = item_p->nAS_PDU->size;
-
       S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.buffer =
         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);
       S1AP_DEBUG("Received NAS message with the E_RAB setup procedure\n");
@@ -782,13 +807,10 @@ int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
            item_p->transportLayerAddress.buf, item_p->transportLayerAddress.size);
     S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].sgw_addr.length =
       item_p->transportLayerAddress.size * 8 - item_p->transportLayerAddress.bits_unused;
-
     /* GTP tunnel endpoint ID */
     OCTET_STRING_TO_INT32(&item_p->gTP_TEID, S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].gtp_teid);
-
     /* Set the QOS informations */
     S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].qos.qci = item_p->e_RABlevelQoSParameters.qCI;
-
     S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].qos.allocation_retention_priority.priority_level =
       item_p->e_RABlevelQoSParameters.allocationRetentionPriority.priorityLevel;
     S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].qos.allocation_retention_priority.pre_emp_capability =
@@ -804,15 +826,12 @@ int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
     BIT_STRING_to_uint16(&ie->value.choice.UESecurityCapabilities.encryptionAlgorithms);
   S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).security_capabilities.integrity_algorithms =
     BIT_STRING_to_uint16(&ie->value.choice.UESecurityCapabilities.integrityProtectionAlgorithms);
-
   /* id-SecurityKey : Copy the security key */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_InitialContextSetupRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_SecurityKey, true);
   memcpy(&S1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).security_key,
          ie->value.choice.SecurityKey.buf, ie->value.choice.SecurityKey.size);
-
   itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p);
-
   return 0;
 }
 
@@ -820,8 +839,7 @@ int s1ap_eNB_handle_initial_context_request(uint32_t   assoc_id,
 static
 int s1ap_eNB_handle_ue_context_release_command(uint32_t   assoc_id,
     uint32_t               stream,
-    S1AP_S1AP_PDU_t       *pdu)
+    S1AP_S1AP_PDU_t       *pdu) {
-{
   s1ap_eNB_mme_data_t   *mme_desc_p       = NULL;
   s1ap_eNB_ue_context_t *ue_desc_p        = NULL;
   MessageDef            *message_p        = NULL;
@@ -829,9 +847,7 @@ int s1ap_eNB_handle_ue_context_release_command(uint32_t   assoc_id,
   S1AP_ENB_UE_S1AP_ID_t  enb_ue_s1ap_id;
   S1AP_UEContextReleaseCommand_t     *container;
   S1AP_UEContextReleaseCommand_IEs_t *ie;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.initiatingMessage.value.choice.UEContextReleaseCommand;
 
   if ((mme_desc_p = s1ap_eNB_get_MME(NULL, assoc_id, 0)) == NULL) {
@@ -847,7 +863,6 @@ int s1ap_eNB_handle_ue_context_release_command(uint32_t   assoc_id,
     case S1AP_UE_S1AP_IDs_PR_uE_S1AP_ID_pair:
       enb_ue_s1ap_id = ie->value.choice.UE_S1AP_IDs.choice.uE_S1AP_ID_pair.eNB_UE_S1AP_ID;
       mme_ue_s1ap_id = ie->value.choice.UE_S1AP_IDs.choice.uE_S1AP_ID_pair.mME_UE_S1AP_ID;
-
       MSC_LOG_RX_MESSAGE(
         MSC_S1AP_ENB,
         MSC_S1AP_MME,
@@ -863,11 +878,6 @@ int s1ap_eNB_handle_ue_context_release_command(uint32_t   assoc_id,
                    "existing UE context 0x%06lx\n",
                    assoc_id,
                    enb_ue_s1ap_id);
-        /*MessageDef *msg_complete_p;
-        msg_complete_p = itti_alloc_new_message(TASK_RRC_ENB, S1AP_UE_CONTEXT_RELEASE_COMPLETE);
-        S1AP_UE_CONTEXT_RELEASE_COMPLETE(msg_complete_p).eNB_ue_s1ap_id = enb_ue_s1ap_id;
-        itti_send_msg_to_task(TASK_S1AP, ue_desc_p->eNB_instance->instance <=> 0, msg_complete_p);
-        */
         return -1;
       } else {
         MSC_LOG_TX_MESSAGE(
@@ -877,6 +887,11 @@ int s1ap_eNB_handle_ue_context_release_command(uint32_t   assoc_id,
           "0 S1AP_UE_CONTEXT_RELEASE_COMMAND/%d eNB_ue_s1ap_id "S1AP_UE_ID_FMT" ",
           enb_ue_s1ap_id);
         message_p        = itti_alloc_new_message(TASK_S1AP, S1AP_UE_CONTEXT_RELEASE_COMMAND);
+
+        if (ue_desc_p->mme_ue_s1ap_id == 0) { // case of Detach Request and switch off from RRC_IDLE mode
+          ue_desc_p->mme_ue_s1ap_id = mme_ue_s1ap_id;
+        }
+
         S1AP_UE_CONTEXT_RELEASE_COMMAND(message_p).eNB_ue_s1ap_id = enb_ue_s1ap_id;
         itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p);
         return 0;
@@ -905,8 +920,7 @@ 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,
-                                        S1AP_S1AP_PDU_t *pdu)
+                                        S1AP_S1AP_PDU_t *pdu) {
-{
   int i;
   S1AP_MME_UE_S1AP_ID_t         mme_ue_s1ap_id;
   S1AP_ENB_UE_S1AP_ID_t         enb_ue_s1ap_id;
@@ -915,9 +929,7 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t         assoc_id,
   MessageDef                   *message_p        = NULL;
   S1AP_E_RABSetupRequest_t     *container;
   S1AP_E_RABSetupRequestIEs_t  *ie;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.initiatingMessage.value.choice.E_RABSetupRequest;
 
   if ((mme_desc_p = s1ap_eNB_get_MME(NULL, assoc_id, 0)) == NULL) {
@@ -930,7 +942,6 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t         assoc_id,
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABSetupRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID, true);
   mme_ue_s1ap_id = ie->value.choice.MME_UE_S1AP_ID;
-
   /* id-eNB-UE-S1AP-ID */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABSetupRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID, true);
@@ -959,11 +970,9 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t         assoc_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  = mme_ue_s1ap_id;
   S1AP_E_RAB_SETUP_REQ(message_p).eNB_ue_s1ap_id  = enb_ue_s1ap_id;
-
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABSetupRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_E_RABToBeSetupListBearerSUReq, true);
   S1AP_E_RAB_SETUP_REQ(message_p).nb_e_rabs_tosetup =
@@ -971,24 +980,19 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t         assoc_id,
 
   for (i = 0; i < ie->value.choice.E_RABToBeSetupListBearerSUReq.list.count; i++) {
     S1AP_E_RABToBeSetupItemBearerSUReq_t *item_p;
-
     item_p = &(((S1AP_E_RABToBeSetupItemBearerSUReqIEs_t *)ie->value.choice.E_RABToBeSetupListBearerSUReq.list.array[i])->value.choice.E_RABToBeSetupItemBearerSUReq);
-
     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;
     }
@@ -998,7 +1002,6 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t         assoc_id,
            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,
@@ -1006,10 +1009,8 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t         assoc_id,
     */
     /* 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 =
@@ -1019,25 +1020,20 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t         assoc_id,
   }
 
   itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p);
-
   return 0;
 }
 
 static
 int s1ap_eNB_handle_paging(uint32_t               assoc_id,
                            uint32_t               stream,
-                           S1AP_S1AP_PDU_t       *pdu)
+                           S1AP_S1AP_PDU_t       *pdu) {
-{
   s1ap_eNB_mme_data_t   *mme_desc_p        = NULL;
   s1ap_eNB_instance_t   *s1ap_eNB_instance = NULL;
   MessageDef            *message_p         = NULL;
   S1AP_Paging_t         *container;
   S1AP_PagingIEs_t      *ie;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.initiatingMessage.value.choice.Paging;
-
   // received Paging Message from MME
   S1AP_DEBUG("[SCTP %d] Received Paging Message From MME\n",assoc_id);
 
@@ -1055,6 +1051,7 @@ int s1ap_eNB_handle_paging(uint32_t               assoc_id,
   }
 
   s1ap_eNB_instance = mme_desc_p->s1ap_eNB_instance;
+
   if (s1ap_eNB_instance == NULL) {
     S1AP_ERROR("[SCTP %d] Received Paging for non existing MME context : s1ap_eNB_instance is NULL\n",
                assoc_id);
@@ -1062,7 +1059,6 @@ int s1ap_eNB_handle_paging(uint32_t               assoc_id,
   }
 
   message_p = itti_alloc_new_message(TASK_S1AP, S1AP_PAGING_IND);
-
   /* convert S1AP_PagingIEs_t to s1ap_paging_ind_t */
   /* id-UEIdentityIndexValue : convert UE Identity Index value */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_PagingIEs_t, ie, container,
@@ -1070,13 +1066,12 @@ int s1ap_eNB_handle_paging(uint32_t               assoc_id,
   S1AP_PAGING_IND(message_p).ue_index_value  = BIT_STRING_to_uint32(&ie->value.choice.UEIdentityIndexValue);
   S1AP_DEBUG("[SCTP %d] Received Paging ue_index_value (%d)\n",
              assoc_id,(uint32_t)S1AP_PAGING_IND(message_p).ue_index_value);
-
   S1AP_PAGING_IND(message_p).ue_paging_identity.choice.s_tmsi.mme_code = 0;
   S1AP_PAGING_IND(message_p).ue_paging_identity.choice.s_tmsi.m_tmsi = 0;
-
   /* id-UEPagingID */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_PagingIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_UEPagingID, true);
+
   /* convert UE Paging Identity */
   if (ie->value.choice.UEPagingID.present == S1AP_UEPagingID_PR_s_TMSI) {
     S1AP_PAGING_IND(message_p).ue_paging_identity.presenceMask = UE_PAGING_IDENTITY_s_tmsi;
@@ -1115,7 +1110,6 @@ int s1ap_eNB_handle_paging(uint32_t               assoc_id,
   }
 
   S1AP_PAGING_IND(message_p).paging_drx = PAGING_DRX_256;
-
   /* id-pagingDRX */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_PagingIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_pagingDRX, false);
@@ -1145,7 +1139,6 @@ int s1ap_eNB_handle_paging(uint32_t               assoc_id,
   memset (&S1AP_PAGING_IND(message_p).plmn_identity[0], 0, sizeof(plmn_identity_t)*256);
   memset (&S1AP_PAGING_IND(message_p).tac[0], 0, sizeof(int16_t)*256);
   S1AP_PAGING_IND(message_p).tai_size = 0;
-
   /* id-TAIList */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_PagingIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_TAIList, true);
@@ -1165,7 +1158,6 @@ int s1ap_eNB_handle_paging(uint32_t               assoc_id,
                S1AP_PAGING_IND(message_p).tac[i]);
   }
 
-
   //paging parameter values
   S1AP_DEBUG("[SCTP %d] Received Paging parameters: ue_index_value %d  cn_domain %d paging_drx %d paging_priority %d\n",assoc_id,
              S1AP_PAGING_IND(message_p).ue_index_value, S1AP_PAGING_IND(message_p).cn_domain,
@@ -1176,18 +1168,15 @@ int s1ap_eNB_handle_paging(uint32_t               assoc_id,
              S1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[0], S1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[1],
              S1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[2], S1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[3],
              S1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[4], S1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[5]);
-
   /* send message to RRC */
   itti_send_msg_to_task(TASK_RRC_ENB, s1ap_eNB_instance->instance, message_p);
-
   return 0;
 }
 
 static
 int s1ap_eNB_handle_e_rab_modify_request(uint32_t               assoc_id,
     uint32_t               stream,
-                                         S1AP_S1AP_PDU_t       *pdu)
+    S1AP_S1AP_PDU_t       *pdu) {
-{
   int i, nb_of_e_rabs_failed;
   s1ap_eNB_mme_data_t           *mme_desc_p       = NULL;
   s1ap_eNB_ue_context_t         *ue_desc_p        = NULL;
@@ -1196,9 +1185,7 @@ int s1ap_eNB_handle_e_rab_modify_request(uint32_t               assoc_id,
   S1AP_E_RABModifyRequestIEs_t  *ie;
   S1AP_ENB_UE_S1AP_ID_t         enb_ue_s1ap_id;
   S1AP_MME_UE_S1AP_ID_t         mme_ue_s1ap_id;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.initiatingMessage.value.choice.E_RABModifyRequest;
 
   if ((mme_desc_p = s1ap_eNB_get_MME(NULL, assoc_id, 0)) == NULL) {
@@ -1211,7 +1198,6 @@ int s1ap_eNB_handle_e_rab_modify_request(uint32_t               assoc_id,
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABModifyRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID, true);
   mme_ue_s1ap_id = ie->value.choice.MME_UE_S1AP_ID;
-
   /* id-eNB-UE-S1AP-ID */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABModifyRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID, true);
@@ -1238,9 +1224,7 @@ int s1ap_eNB_handle_e_rab_modify_request(uint32_t               assoc_id,
     S1AP_WARN("UE context mme_ue_s1ap_id is different form that of the message (%d != %ld)",
               ue_desc_p->mme_ue_s1ap_id, mme_ue_s1ap_id);
     message_p = itti_alloc_new_message (TASK_RRC_ENB, S1AP_E_RAB_MODIFY_RESP);
-
     S1AP_E_RAB_MODIFY_RESP (message_p).eNB_ue_s1ap_id = enb_ue_s1ap_id;
-
     S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABModifyRequestIEs_t, ie, container,
                                S1AP_ProtocolIE_ID_id_E_RABToBeModifiedListBearerModReq, true);
 
@@ -1252,22 +1236,18 @@ int s1ap_eNB_handle_e_rab_modify_request(uint32_t               assoc_id,
       S1AP_E_RAB_MODIFY_RESP(message_p).e_rabs_failed[nb_of_e_rabs_failed].cause = S1AP_Cause_PR_radioNetwork;
       S1AP_E_RAB_MODIFY_RESP(message_p).e_rabs_failed[nb_of_e_rabs_failed].cause_value = S1AP_CauseRadioNetwork_unknown_mme_ue_s1ap_id;
     }
-    S1AP_E_RAB_MODIFY_RESP(message_p).nb_of_e_rabs_failed = nb_of_e_rabs_failed;
 
+    S1AP_E_RAB_MODIFY_RESP(message_p).nb_of_e_rabs_failed = nb_of_e_rabs_failed;
     s1ap_eNB_e_rab_modify_resp(mme_desc_p->s1ap_eNB_instance->instance,
                                &S1AP_E_RAB_MODIFY_RESP(message_p));
-
     message_p = NULL;
     return -1;
   }
 
   message_p        = itti_alloc_new_message(TASK_S1AP, S1AP_E_RAB_MODIFY_REQ);
-
   S1AP_E_RAB_MODIFY_REQ(message_p).ue_initial_id  = ue_desc_p->ue_initial_id;
-
   S1AP_E_RAB_MODIFY_REQ(message_p).mme_ue_s1ap_id  = mme_ue_s1ap_id;
   S1AP_E_RAB_MODIFY_REQ(message_p).eNB_ue_s1ap_id  = enb_ue_s1ap_id;
-
   /* id-E-RABToBeModifiedListBearerModReq */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABModifyRequestIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_E_RABToBeModifiedListBearerModReq, true);
@@ -1282,9 +1262,7 @@ int s1ap_eNB_handle_e_rab_modify_request(uint32_t               assoc_id,
     // check for the NAS PDU
     if (item_p->nAS_PDU.size > 0 ) {
       S1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].nas_pdu.length = item_p->nAS_PDU.size;
-
       S1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].nas_pdu.buffer = malloc(sizeof(uint8_t) * item_p->nAS_PDU.size);
-
       memcpy(S1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].nas_pdu.buffer,
              item_p->nAS_PDU.buf, item_p->nAS_PDU.size);
     } else {
@@ -1295,26 +1273,22 @@ int s1ap_eNB_handle_e_rab_modify_request(uint32_t               assoc_id,
 
     /* Set the QOS informations */
     S1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].qos.qci = item_p->e_RABLevelQoSParameters.qCI;
-
     S1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].qos.allocation_retention_priority.priority_level =
       item_p->e_RABLevelQoSParameters.allocationRetentionPriority.priorityLevel;
     S1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].qos.allocation_retention_priority.pre_emp_capability =
       item_p->e_RABLevelQoSParameters.allocationRetentionPriority.pre_emptionCapability;
     S1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_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;
 }
 // handle e-rab release command and send it to rrc_end
 static
 int s1ap_eNB_handle_e_rab_release_command(uint32_t               assoc_id,
     uint32_t               stream,
-                                          S1AP_S1AP_PDU_t       *pdu)
+    S1AP_S1AP_PDU_t       *pdu) {
-{
   int i;
   s1ap_eNB_mme_data_t   *mme_desc_p       = NULL;
   s1ap_eNB_ue_context_t *ue_desc_p        = NULL;
@@ -1323,9 +1297,7 @@ int s1ap_eNB_handle_e_rab_release_command(uint32_t               assoc_id,
   S1AP_E_RABReleaseCommandIEs_t  *ie;
   S1AP_ENB_UE_S1AP_ID_t           enb_ue_s1ap_id;
   S1AP_MME_UE_S1AP_ID_t           mme_ue_s1ap_id;
-
   DevAssert(pdu != NULL);
-
   container = &pdu->choice.initiatingMessage.value.choice.E_RABReleaseCommand;
 
   if ((mme_desc_p = s1ap_eNB_get_MME(NULL, assoc_id, 0)) == NULL) {
@@ -1337,7 +1309,6 @@ int s1ap_eNB_handle_e_rab_release_command(uint32_t               assoc_id,
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABReleaseCommandIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID, true);
   mme_ue_s1ap_id = ie->value.choice.MME_UE_S1AP_ID;
-
   /* id-eNB-UE-S1AP-ID */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABReleaseCommandIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID, true);
@@ -1366,14 +1337,13 @@ int s1ap_eNB_handle_e_rab_release_command(uint32_t               assoc_id,
 
   S1AP_DEBUG("[SCTP %d] Received E-RAB release command for eNB_UE_S1AP_ID %ld mme_ue_s1ap_id %ld\n",
              assoc_id, enb_ue_s1ap_id, mme_ue_s1ap_id);
-
   message_p = itti_alloc_new_message(TASK_S1AP, S1AP_E_RAB_RELEASE_COMMAND);
   S1AP_E_RAB_RELEASE_COMMAND(message_p).eNB_ue_s1ap_id = enb_ue_s1ap_id;
   S1AP_E_RAB_RELEASE_COMMAND(message_p).mme_ue_s1ap_id = mme_ue_s1ap_id;
-
   /* id-NAS-PDU */
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_E_RABReleaseCommandIEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_NAS_PDU, false);
+
   if(ie && ie->value.choice.NAS_PDU.size > 0) {
     S1AP_E_RAB_RELEASE_COMMAND(message_p).nas_pdu.length = ie->value.choice.NAS_PDU.size;
     S1AP_E_RAB_RELEASE_COMMAND(message_p).nas_pdu.buffer =
@@ -1399,6 +1369,5 @@ int s1ap_eNB_handle_e_rab_release_command(uint32_t               assoc_id,
   }
 
   itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p);
-
   return 0;
 }

openair3/S1AP/s1ap_eNB_nas_procedures.c

@@ -61,13 +61,10 @@ int s1ap_eNB_handle_nas_first_req(
   S1AP_InitialUEMessage_IEs_t  *ie;
   uint8_t  *buffer = NULL;
   uint32_t  length = 0;
-
   DevAssert(s1ap_nas_first_req_p != NULL);
-
   /* Retrieve the S1AP eNB instance associated with Mod_id */
   instance_p = s1ap_eNB_get_instance(instance);
   DevAssert(instance_p != NULL);
-
   memset(&pdu, 0, sizeof(pdu));
   pdu.present = S1AP_S1AP_PDU_PR_initiatingMessage;
   pdu.choice.initiatingMessage.procedureCode = S1AP_ProcedureCode_id_initialUEMessage;
@@ -81,6 +78,7 @@ int s1ap_eNB_handle_nas_first_req(
                    instance_p,
                    s1ap_nas_first_req_p->establishment_cause,
                    s1ap_nas_first_req_p->ue_identity.gummei);
+
     if (mme_desc_p) {
       S1AP_INFO("[eNB %d] Chose MME '%s' (assoc_id %d) through GUMMEI MCC %d MNC %d MMEGI %d MMEC %d\n",
                 instance,
@@ -101,6 +99,7 @@ int s1ap_eNB_handle_nas_first_req(
                      s1ap_nas_first_req_p->establishment_cause,
                      s1ap_nas_first_req_p->selected_plmn_identity,
                      s1ap_nas_first_req_p->ue_identity.s_tmsi.mme_code);
+
       if (mme_desc_p) {
         S1AP_INFO("[eNB %d] Chose MME '%s' (assoc_id %d) through S-TMSI MMEC %d and selected PLMN Identity index %d MCC %d MNC %d\n",
                   instance,
@@ -121,6 +120,7 @@ int s1ap_eNB_handle_nas_first_req(
                    instance_p,
                    s1ap_nas_first_req_p->establishment_cause,
                    s1ap_nas_first_req_p->selected_plmn_identity);
+
     if (mme_desc_p) {
       S1AP_INFO("[eNB %d] Chose MME '%s' (assoc_id %d) through selected PLMN Identity index %d MCC %d MNC %d\n",
                 instance,
@@ -140,6 +140,7 @@ int s1ap_eNB_handle_nas_first_req(
     mme_desc_p = s1ap_eNB_nnsf_select_mme(
                    instance_p,
                    s1ap_nas_first_req_p->establishment_cause);
+
     if (mme_desc_p) {
       S1AP_INFO("[eNB %d] Chose MME '%s' (assoc_id %d) through highest relative capacity\n",
                 instance,
@@ -153,7 +154,6 @@ int s1ap_eNB_handle_nas_first_req(
      * In case eNB has no MME associated, the eNB should inform RRC and discard
      * this request.
      */
-
     S1AP_WARN("No MME is associated to the eNB\n");
     // TODO: Inform RRC
     return -1;
@@ -164,7 +164,6 @@ int s1ap_eNB_handle_nas_first_req(
    */
   ue_desc_p = s1ap_eNB_allocate_new_UE_context();
   DevAssert(ue_desc_p != NULL);
-
   /* Keep a reference to the selected MME */
   ue_desc_p->mme_ref       = mme_desc_p;
   ue_desc_p->ue_initial_id = s1ap_nas_first_req_p->ue_initial_id;
@@ -173,7 +172,6 @@ int s1ap_eNB_handle_nas_first_req(
 
   do {
     struct s1ap_eNB_ue_context_s *collision_p;
-
     /* Peek a random value for the eNB_ue_s1ap_id */
     ue_desc_p->eNB_ue_s1ap_id = (random() + random()) & 0x00ffffff;
 
@@ -194,7 +192,6 @@ int s1ap_eNB_handle_nas_first_req(
   ie->value.present = S1AP_InitialUEMessage_IEs__value_PR_ENB_UE_S1AP_ID;
   ie->value.choice.ENB_UE_S1AP_ID = ue_desc_p->eNB_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_NAS_PDU;
@@ -210,7 +207,6 @@ int s1ap_eNB_handle_nas_first_req(
 #endif
   ie->value.choice.NAS_PDU.size = s1ap_nas_first_req_p->nas_pdu.length;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_TAI;
@@ -223,7 +219,6 @@ int s1ap_eNB_handle_nas_first_req(
                     instance_p->mnc_digit_length[ue_desc_p->selected_plmn_identity],
                     &ie->value.choice.TAI.pLMNidentity);
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_EUTRAN_CGI;
@@ -242,11 +237,9 @@ int s1ap_eNB_handle_nas_first_req(
                   instance_p->mnc_digit_length[ue_desc_p->selected_plmn_identity],
                   &ie->value.choice.EUTRAN_CGI.pLMNidentity);
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* Set the establishment cause according to those provided by RRC */
   DevCheck(s1ap_nas_first_req_p->establishment_cause < RRC_CAUSE_LAST,
            s1ap_nas_first_req_p->establishment_cause, RRC_CAUSE_LAST, 0);
-
   /* mandatory */
   ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_RRC_Establishment_Cause;
@@ -300,6 +293,7 @@ int s1ap_eNB_handle_nas_first_req(
 
   /* optional */
 #if (S1AP_VERSION >= MAKE_VERSION(9, 0, 0))
+
   if (0) {
     ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
     ie->id = S1AP_ProtocolIE_ID_id_CellAccessMode;
@@ -311,6 +305,7 @@ int s1ap_eNB_handle_nas_first_req(
 
   /* optional */
 #if (S1AP_VERSION >= MAKE_VERSION(10, 0, 0))
+
   if (0) {
     ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
     ie->id = S1AP_ProtocolIE_ID_id_GW_TransportLayerAddress;
@@ -331,6 +326,7 @@ int s1ap_eNB_handle_nas_first_req(
   }
 
 #if (S1AP_VERSION >= MAKE_VERSION(11, 0, 0))
+
   /* optional */
   if (0) {
     ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
@@ -372,6 +368,7 @@ int s1ap_eNB_handle_nas_first_req(
   }
 
 #if (S1AP_VERSION >= MAKE_VERSION(13, 0, 0))
+
   /* optional */
   if (0) {
     ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
@@ -403,6 +400,7 @@ int s1ap_eNB_handle_nas_first_req(
   }
 
 #if (S1AP_VERSION >= MAKE_VERSION(14, 0, 0))
+
   /* optional */
   if (0) {
     ie = (S1AP_InitialUEMessage_IEs_t *)calloc(1, sizeof(S1AP_InitialUEMessage_IEs_t));
@@ -422,6 +420,7 @@ int s1ap_eNB_handle_nas_first_req(
     // ie->value.choice.Coverage_Level = ue_release_req_p->eNB_ue_s1ap_id;
     ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
   }
+
 #endif /* #if (S1AP_VERSION >= MAKE_VERSION(14, 0, 0)) */
 #endif /* #if (S1AP_VERSION >= MAKE_VERSION(13, 0, 0)) */
 #endif /* #if (S1AP_VERSION >= MAKE_VERSION(11, 0, 0)) */
@@ -435,7 +434,6 @@ int s1ap_eNB_handle_nas_first_req(
 
   /* Update the current S1AP UE state */
   ue_desc_p->ue_state = S1AP_UE_WAITING_CSR;
-
   /* Assign a stream for this UE :
    * From 3GPP 36.412 7)Transport layers:
    *  Within the SCTP association established between one MME and eNB pair:
@@ -455,7 +453,6 @@ int s1ap_eNB_handle_nas_first_req(
   }
 
   ue_desc_p->tx_stream = mme_desc_p->nextstream;
-
   MSC_LOG_TX_MESSAGE(
     MSC_S1AP_ENB,
     MSC_S1AP_MME,
@@ -464,11 +461,9 @@ int s1ap_eNB_handle_nas_first_req(
     MSC_AS_TIME_FMT" initialUEMessage initiatingMessage eNB_ue_s1ap_id %u",
     0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
     ue_desc_p->eNB_ue_s1ap_id);
-
   /* Send encoded message over sctp */
   s1ap_eNB_itti_send_sctp_data_req(instance_p->instance, mme_desc_p->assoc_id,
                                    buffer, length, ue_desc_p->tx_stream);
-
   return 0;
 }
 
@@ -502,14 +497,11 @@ int s1ap_eNB_handle_nas_downlink(uint32_t         assoc_id,
   }
 
   s1ap_eNB_instance = mme_desc_p->s1ap_eNB_instance;
-
   /* Prepare the S1AP message to encode */
   container = &pdu->choice.initiatingMessage.value.choice.DownlinkNASTransport;
-
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_DownlinkNASTransport_IEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID, true);
   mme_ue_s1ap_id = ie->value.choice.MME_UE_S1AP_ID;
-
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_DownlinkNASTransport_IEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID, true);
   enb_ue_s1ap_id = ie->value.choice.ENB_UE_S1AP_ID;
@@ -563,7 +555,6 @@ int s1ap_eNB_handle_nas_downlink(uint32_t         assoc_id,
     MSC_AS_TIME_FMT" downlinkNASTransport  eNB_ue_s1ap_id %u mme_ue_s1ap_id %u",
     assoc_id,
     mme_ue_s1ap_id);
-
   S1AP_FIND_PROTOCOLIE_BY_ID(S1AP_DownlinkNASTransport_IEs_t, ie, container,
                              S1AP_ProtocolIE_ID_id_NAS_PDU, true);
   /* Forward the NAS PDU to RRC */
@@ -572,10 +563,6 @@ int s1ap_eNB_handle_nas_downlink(uint32_t         assoc_id,
                                       ue_desc_p->eNB_ue_s1ap_id,
                                       ie->value.choice.NAS_PDU.buf,
                                       ie->value.choice.NAS_PDU.size);
-
-  // LG: Why set to 0 ??
-  //ue_desc_p->ue_initial_id = 0;
-
   return 0;
 }
 
@@ -590,9 +577,7 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
   S1AP_UplinkNASTransport_IEs_t *ie;
   uint8_t  *buffer;
   uint32_t  length;
-
   DevAssert(s1ap_uplink_nas_p != NULL);
-
   /* Retrieve the S1AP eNB instance associated with Mod_id */
   s1ap_eNB_instance_p = s1ap_eNB_get_instance(instance);
   DevAssert(s1ap_eNB_instance_p != NULL);
@@ -622,7 +607,6 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
   pdu.choice.initiatingMessage.criticality = S1AP_Criticality_ignore;
   pdu.choice.initiatingMessage.value.present = S1AP_InitiatingMessage__value_PR_UplinkNASTransport;
   out = &pdu.choice.initiatingMessage.value.choice.UplinkNASTransport;
-
   /* mandatory */
   ie = (S1AP_UplinkNASTransport_IEs_t *)calloc(1, sizeof(S1AP_UplinkNASTransport_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID;
@@ -630,7 +614,6 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
   ie->value.present = S1AP_UplinkNASTransport_IEs__value_PR_MME_UE_S1AP_ID;
   ie->value.choice.MME_UE_S1AP_ID = ue_context_p->mme_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_UplinkNASTransport_IEs_t *)calloc(1, sizeof(S1AP_UplinkNASTransport_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID;
@@ -638,7 +621,6 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
   ie->value.present = S1AP_UplinkNASTransport_IEs__value_PR_ENB_UE_S1AP_ID;
   ie->value.choice.ENB_UE_S1AP_ID = ue_context_p->eNB_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_UplinkNASTransport_IEs_t *)calloc(1, sizeof(S1AP_UplinkNASTransport_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_NAS_PDU;
@@ -647,7 +629,6 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
   ie->value.choice.NAS_PDU.buf = s1ap_uplink_nas_p->nas_pdu.buffer;
   ie->value.choice.NAS_PDU.size = s1ap_uplink_nas_p->nas_pdu.length;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_UplinkNASTransport_IEs_t *)calloc(1, sizeof(S1AP_UplinkNASTransport_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_EUTRAN_CGI;
@@ -663,7 +644,6 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
                                 0,
                                 &ie->value.choice.EUTRAN_CGI.cell_ID);
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_UplinkNASTransport_IEs_t *)calloc(1, sizeof(S1AP_UplinkNASTransport_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_TAI;
@@ -676,9 +656,9 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
     &ie->value.choice.TAI.pLMNidentity);
   TAC_TO_ASN1(s1ap_eNB_instance_p->tac, &ie->value.choice.TAI.tAC);
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* optional */
 #if (S1AP_VERSION >= MAKE_VERSION(10, 0, 0))
+
   if (0) {
     ie = (S1AP_UplinkNASTransport_IEs_t *)calloc(1, sizeof(S1AP_UplinkNASTransport_IEs_t));
     ie->id = S1AP_ProtocolIE_ID_id_GW_TransportLayerAddress;
@@ -690,6 +670,7 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
 
   /* optional */
 #if (S1AP_VERSION >= MAKE_VERSION(14, 0, 0))
+
   if (0) {
     ie = (S1AP_UplinkNASTransport_IEs_t *)calloc(1, sizeof(S1AP_UplinkNASTransport_IEs_t));
     ie->id = S1AP_ProtocolIE_ID_id_SIPTO_L_GW_TransportLayerAddress;
@@ -708,6 +689,7 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
     // ie->value.choice.LHN_ID =;
     ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
   }
+
 #endif /* #if (S1AP_VERSION >= MAKE_VERSION(14, 0, 0)) */
 #endif /* #if (S1AP_VERSION >= MAKE_VERSION(10, 0, 0)) */
 
@@ -726,12 +708,10 @@ int s1ap_eNB_nas_uplink(instance_t instance, s1ap_uplink_nas_t *s1ap_uplink_nas_
     0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
     ue_context_p->eNB_ue_s1ap_id,
     ue_context_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 0;
 }
 
@@ -748,9 +728,7 @@ int s1ap_eNB_nas_non_delivery_ind(instance_t instance,
   S1AP_NASNonDeliveryIndication_IEs_t *ie;
   uint8_t  *buffer;
   uint32_t  length;
-
   DevAssert(s1ap_nas_non_delivery_ind != NULL);
-
   /* Retrieve the S1AP eNB instance associated with Mod_id */
   s1ap_eNB_instance_p = s1ap_eNB_get_instance(instance);
   DevAssert(s1ap_eNB_instance_p != NULL);
@@ -773,7 +751,6 @@ int s1ap_eNB_nas_non_delivery_ind(instance_t instance,
   pdu.choice.initiatingMessage.criticality = S1AP_Criticality_ignore;
   pdu.choice.initiatingMessage.value.present = S1AP_InitiatingMessage__value_PR_NASNonDeliveryIndication;
   out = &pdu.choice.initiatingMessage.value.choice.NASNonDeliveryIndication;
-
   /* mandatory */
   ie = (S1AP_NASNonDeliveryIndication_IEs_t *)calloc(1, sizeof(S1AP_NASNonDeliveryIndication_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID;
@@ -781,7 +758,6 @@ int s1ap_eNB_nas_non_delivery_ind(instance_t instance,
   ie->value.present = S1AP_NASNonDeliveryIndication_IEs__value_PR_MME_UE_S1AP_ID;
   ie->value.choice.MME_UE_S1AP_ID = ue_context_p->mme_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_NASNonDeliveryIndication_IEs_t *)calloc(1, sizeof(S1AP_NASNonDeliveryIndication_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID;
@@ -789,7 +765,6 @@ int s1ap_eNB_nas_non_delivery_ind(instance_t instance,
   ie->value.present = S1AP_NASNonDeliveryIndication_IEs__value_PR_ENB_UE_S1AP_ID;
   ie->value.choice.ENB_UE_S1AP_ID = ue_context_p->eNB_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_NASNonDeliveryIndication_IEs_t *)calloc(1, sizeof(S1AP_NASNonDeliveryIndication_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_NAS_PDU;
@@ -797,9 +772,7 @@ int s1ap_eNB_nas_non_delivery_ind(instance_t instance,
   ie->value.present = S1AP_NASNonDeliveryIndication_IEs__value_PR_NAS_PDU;
   ie->value.choice.NAS_PDU.buf = s1ap_nas_non_delivery_ind->nas_pdu.buffer;
   ie->value.choice.NAS_PDU.size = s1ap_nas_non_delivery_ind->nas_pdu.length;
-
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_NASNonDeliveryIndication_IEs_t *)calloc(1, sizeof(S1AP_NASNonDeliveryIndication_IEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_Cause;
@@ -828,7 +801,6 @@ int s1ap_eNB_nas_non_delivery_ind(instance_t instance,
     0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
     ue_context_p->eNB_ue_s1ap_id,
     ue_context_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,
@@ -849,10 +821,8 @@ int s1ap_eNB_initial_ctxt_resp(
   uint8_t  *buffer = NULL;
   uint32_t length;
   int      i;
-
   /* Retrieve the S1AP eNB instance associated with Mod_id */
   s1ap_eNB_instance_p = s1ap_eNB_get_instance(instance);
-
   DevAssert(initial_ctxt_resp_p != NULL);
   DevAssert(s1ap_eNB_instance_p != NULL);
 
@@ -882,7 +852,6 @@ int s1ap_eNB_initial_ctxt_resp(
   pdu.choice.successfulOutcome.criticality = S1AP_Criticality_reject;
   pdu.choice.successfulOutcome.value.present = S1AP_SuccessfulOutcome__value_PR_InitialContextSetupResponse;
   out = &pdu.choice.successfulOutcome.value.choice.InitialContextSetupResponse;
-
   /* mandatory */
   ie = (S1AP_InitialContextSetupResponseIEs_t *)calloc(1, sizeof(S1AP_InitialContextSetupResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID;
@@ -890,7 +859,6 @@ int s1ap_eNB_initial_ctxt_resp(
   ie->value.present = S1AP_InitialContextSetupResponseIEs__value_PR_MME_UE_S1AP_ID;
   ie->value.choice.MME_UE_S1AP_ID = ue_context_p->mme_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_InitialContextSetupResponseIEs_t *)calloc(1, sizeof(S1AP_InitialContextSetupResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID;
@@ -898,7 +866,6 @@ int s1ap_eNB_initial_ctxt_resp(
   ie->value.present = S1AP_InitialContextSetupResponseIEs__value_PR_ENB_UE_S1AP_ID;
   ie->value.choice.ENB_UE_S1AP_ID = initial_ctxt_resp_p->eNB_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_InitialContextSetupResponseIEs_t *)calloc(1, sizeof(S1AP_InitialContextSetupResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_E_RABSetupListCtxtSURes;
@@ -949,23 +916,27 @@ int s1ap_eNB_initial_ctxt_resp(
       item->value.choice.E_RABItem.e_RAB_ID = initial_ctxt_resp_p->e_rabs_failed[i].e_rab_id;
       item->value.choice.E_RABItem.cause.present = initial_ctxt_resp_p->e_rabs_failed[i].cause;
 
-      switch(item->value.choice.E_RABItem.cause.present)
+      switch(item->value.choice.E_RABItem.cause.present) {
-      {
         case S1AP_Cause_PR_radioNetwork:
           item->value.choice.E_RABItem.cause.choice.radioNetwork = initial_ctxt_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_transport:
           item->value.choice.E_RABItem.cause.choice.transport = initial_ctxt_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_nas:
           item->value.choice.E_RABItem.cause.choice.nas = initial_ctxt_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_protocol:
           item->value.choice.E_RABItem.cause.choice.protocol = initial_ctxt_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_misc:
           item->value.choice.E_RABItem.cause.choice.misc = initial_ctxt_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_NOTHING:
         default:
           break;
@@ -1003,12 +974,10 @@ int s1ap_eNB_initial_ctxt_resp(
     0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
     initial_ctxt_resp_p->eNB_ue_s1ap_id,
     ue_context_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 0;
 }
 
@@ -1024,10 +993,8 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
   S1AP_UECapabilityInfoIndicationIEs_t *ie;
   uint8_t  *buffer;
   uint32_t length;
-
   /* Retrieve the S1AP eNB instance associated with Mod_id */
   s1ap_eNB_instance_p = s1ap_eNB_get_instance(instance);
-
   DevAssert(ue_cap_info_ind_p != NULL);
   DevAssert(s1ap_eNB_instance_p != NULL);
 
@@ -1057,7 +1024,6 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
   pdu.choice.initiatingMessage.criticality = S1AP_Criticality_ignore;
   pdu.choice.initiatingMessage.value.present = S1AP_InitiatingMessage__value_PR_UECapabilityInfoIndication;
   out = &pdu.choice.initiatingMessage.value.choice.UECapabilityInfoIndication;
-
   /* mandatory */
   ie = (S1AP_UECapabilityInfoIndicationIEs_t *)calloc(1, sizeof(S1AP_UECapabilityInfoIndicationIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID;
@@ -1065,7 +1031,6 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
   ie->value.present = S1AP_UECapabilityInfoIndicationIEs__value_PR_MME_UE_S1AP_ID;
   ie->value.choice.MME_UE_S1AP_ID = ue_context_p->mme_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_UECapabilityInfoIndicationIEs_t *)calloc(1, sizeof(S1AP_UECapabilityInfoIndicationIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID;
@@ -1073,7 +1038,6 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
   ie->value.present = S1AP_UECapabilityInfoIndicationIEs__value_PR_ENB_UE_S1AP_ID;
   ie->value.choice.ENB_UE_S1AP_ID = ue_cap_info_ind_p->eNB_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_UECapabilityInfoIndicationIEs_t *)calloc(1, sizeof(S1AP_UECapabilityInfoIndicationIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_UERadioCapability;
@@ -1082,9 +1046,9 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
   ie->value.choice.UERadioCapability.buf = ue_cap_info_ind_p->ue_radio_cap.buffer;
   ie->value.choice.UERadioCapability.size = ue_cap_info_ind_p->ue_radio_cap.length;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* optional */
 #if (S1AP_VERSION >= MAKE_VERSION(12, 0, 0))
+
   if (0) {
     ie = (S1AP_UECapabilityInfoIndicationIEs_t *)calloc(1, sizeof(S1AP_UECapabilityInfoIndicationIEs_t));
     ie->id = S1AP_ProtocolIE_ID_id_UERadioCapabilityForPaging;
@@ -1093,6 +1057,7 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
     // ie->value.choice.UERadioCapabilityForPaging = ;
     ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
   }
+
 #endif /* #if (S1AP_VERSION >= MAKE_VERSION(14, 0, 0)) */
 
   if (s1ap_eNB_encode_pdu(&pdu, &buffer, &length) < 0) {
@@ -1110,12 +1075,10 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
     0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
     ue_cap_info_ind_p->eNB_ue_s1ap_id,
     ue_context_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 0;
 }
 
@@ -1132,10 +1095,8 @@ int s1ap_eNB_e_rab_setup_resp(instance_t instance,
   uint8_t  *buffer  = NULL;
   uint32_t length;
   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);
 
@@ -1165,7 +1126,6 @@ int s1ap_eNB_e_rab_setup_resp(instance_t instance,
   pdu.choice.successfulOutcome.criticality = S1AP_Criticality_reject;
   pdu.choice.successfulOutcome.value.present = S1AP_SuccessfulOutcome__value_PR_E_RABSetupResponse;
   out = &pdu.choice.successfulOutcome.value.choice.E_RABSetupResponse;
-
   /* mandatory */
   ie = (S1AP_E_RABSetupResponseIEs_t *)calloc(1, sizeof(S1AP_E_RABSetupResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID;
@@ -1173,7 +1133,6 @@ int s1ap_eNB_e_rab_setup_resp(instance_t instance,
   ie->value.present = S1AP_E_RABSetupResponseIEs__value_PR_MME_UE_S1AP_ID;
   ie->value.choice.MME_UE_S1AP_ID = ue_context_p->mme_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_E_RABSetupResponseIEs_t *)calloc(1, sizeof(S1AP_E_RABSetupResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID;
@@ -1234,23 +1193,27 @@ int s1ap_eNB_e_rab_setup_resp(instance_t instance,
       item->value.choice.E_RABItem.e_RAB_ID = e_rab_setup_resp_p->e_rabs_failed[i].e_rab_id;
       item->value.choice.E_RABItem.cause.present = e_rab_setup_resp_p->e_rabs_failed[i].cause;
 
-      switch(item->value.choice.E_RABItem.cause.present)
+      switch(item->value.choice.E_RABItem.cause.present) {
-      {
         case S1AP_Cause_PR_radioNetwork:
           item->value.choice.E_RABItem.cause.choice.radioNetwork = e_rab_setup_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_transport:
           item->value.choice.E_RABItem.cause.choice.transport = e_rab_setup_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_nas:
           item->value.choice.E_RABItem.cause.choice.nas = e_rab_setup_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_protocol:
           item->value.choice.E_RABItem.cause.choice.protocol = e_rab_setup_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_misc:
           item->value.choice.E_RABItem.cause.choice.misc = e_rab_setup_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_NOTHING:
         default:
           break;
@@ -1280,6 +1243,7 @@ int s1ap_eNB_e_rab_setup_resp(instance_t instance,
   ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_S1AP_E_RABSetupListBearerSURes, &e_RABSetupListBearerSURes);
   */
   fprintf(stderr, "start encode\n");
+
   if (s1ap_eNB_encode_pdu(&pdu, &buffer, &length) < 0) {
     S1AP_ERROR("Failed to encode uplink transport\n");
     /* Encode procedure has failed... */
@@ -1295,12 +1259,10 @@ int s1ap_eNB_e_rab_setup_resp(instance_t instance,
     0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
     e_rab_setup_resp_p->eNB_ue_s1ap_id,
     ue_context_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 0;
 }
 
@@ -1314,14 +1276,11 @@ int s1ap_eNB_e_rab_modify_resp(instance_t instance,
   S1AP_S1AP_PDU_t                pdu;
   S1AP_E_RABModifyResponse_t    *out;
   S1AP_E_RABModifyResponseIEs_t *ie;
-
   uint8_t  *buffer  = NULL;
   uint32_t length;
   int      i;
-
   /* Retrieve the S1AP eNB instance associated with Mod_id */
   s1ap_eNB_instance_p = s1ap_eNB_get_instance(instance);
-
   DevAssert(e_rab_modify_resp_p != NULL);
   DevAssert(s1ap_eNB_instance_p != NULL);
 
@@ -1351,7 +1310,6 @@ int s1ap_eNB_e_rab_modify_resp(instance_t instance,
   pdu.choice.successfulOutcome.criticality = S1AP_Criticality_reject;
   pdu.choice.successfulOutcome.value.present = S1AP_SuccessfulOutcome__value_PR_E_RABModifyResponse;
   out = &pdu.choice.successfulOutcome.value.choice.E_RABModifyResponse;
-
   /* mandatory */
   ie = (S1AP_E_RABModifyResponseIEs_t *)calloc(1, sizeof(S1AP_E_RABModifyResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID;
@@ -1359,7 +1317,6 @@ int s1ap_eNB_e_rab_modify_resp(instance_t instance,
   ie->value.present = S1AP_E_RABModifyResponseIEs__value_PR_MME_UE_S1AP_ID;
   ie->value.choice.MME_UE_S1AP_ID = ue_context_p->mme_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_E_RABModifyResponseIEs_t *)calloc(1, sizeof(S1AP_E_RABModifyResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID;
@@ -1405,23 +1362,27 @@ int s1ap_eNB_e_rab_modify_resp(instance_t instance,
       item->value.choice.E_RABItem.e_RAB_ID = e_rab_modify_resp_p->e_rabs_failed[i].e_rab_id;
       item->value.choice.E_RABItem.cause.present = e_rab_modify_resp_p->e_rabs_failed[i].cause;
 
-      switch(item->value.choice.E_RABItem.cause.present)
+      switch(item->value.choice.E_RABItem.cause.present) {
-      {
         case S1AP_Cause_PR_radioNetwork:
           item->value.choice.E_RABItem.cause.choice.radioNetwork = e_rab_modify_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_transport:
           item->value.choice.E_RABItem.cause.choice.transport = e_rab_modify_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_nas:
           item->value.choice.E_RABItem.cause.choice.nas = e_rab_modify_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_protocol:
           item->value.choice.E_RABItem.cause.choice.protocol = e_rab_modify_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_misc:
           item->value.choice.E_RABItem.cause.choice.misc = e_rab_modify_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_NOTHING:
         default:
           break;
@@ -1445,6 +1406,7 @@ int s1ap_eNB_e_rab_modify_resp(instance_t instance,
   }
 
   fprintf(stderr, "start encode\n");
+
   if (s1ap_eNB_encode_pdu(&pdu, &buffer, &length) < 0) {
     S1AP_ERROR("Failed to encode uplink transport\n");
     /* Encode procedure has failed... */
@@ -1460,7 +1422,6 @@ int s1ap_eNB_e_rab_modify_resp(instance_t instance,
     0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
     e_rab_modify_resp_p->eNB_ue_s1ap_id,
     ue_context_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,
@@ -1480,7 +1441,6 @@ int s1ap_eNB_e_rab_release_resp(instance_t instance,
   uint8_t  *buffer  = NULL;
   uint32_t length;
   int      i;
-
   /* Retrieve the S1AP eNB instance associated with Mod_id */
   s1ap_eNB_instance_p = s1ap_eNB_get_instance(instance);
   DevAssert(e_rab_release_resp_p != NULL);
@@ -1501,7 +1461,6 @@ int s1ap_eNB_e_rab_release_resp(instance_t instance,
   pdu.choice.successfulOutcome.criticality = S1AP_Criticality_reject;
   pdu.choice.successfulOutcome.value.present = S1AP_SuccessfulOutcome__value_PR_E_RABReleaseResponse;
   out = &pdu.choice.successfulOutcome.value.choice.E_RABReleaseResponse;
-
   /* mandatory */
   ie = (S1AP_E_RABReleaseResponseIEs_t *)calloc(1, sizeof(S1AP_E_RABReleaseResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID;
@@ -1509,7 +1468,6 @@ int s1ap_eNB_e_rab_release_resp(instance_t instance,
   ie->value.present = S1AP_E_RABReleaseResponseIEs__value_PR_MME_UE_S1AP_ID;
   ie->value.choice.MME_UE_S1AP_ID = ue_context_p->mme_ue_s1ap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
   /* mandatory */
   ie = (S1AP_E_RABReleaseResponseIEs_t *)calloc(1, sizeof(S1AP_E_RABReleaseResponseIEs_t));
   ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID;
@@ -1555,23 +1513,27 @@ int s1ap_eNB_e_rab_release_resp(instance_t instance,
       item->value.choice.E_RABItem.e_RAB_ID = e_rab_release_resp_p->e_rabs_failed[i].e_rab_id;
       item->value.choice.E_RABItem.cause.present = e_rab_release_resp_p->e_rabs_failed[i].cause;
 
-      switch(item->value.choice.E_RABItem.cause.present)
+      switch(item->value.choice.E_RABItem.cause.present) {
-      {
         case S1AP_Cause_PR_radioNetwork:
           item->value.choice.E_RABItem.cause.choice.radioNetwork = e_rab_release_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_transport:
           item->value.choice.E_RABItem.cause.choice.transport = e_rab_release_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_nas:
           item->value.choice.E_RABItem.cause.choice.nas = e_rab_release_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_protocol:
           item->value.choice.E_RABItem.cause.choice.protocol = e_rab_release_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_misc:
           item->value.choice.E_RABItem.cause.choice.misc = e_rab_release_resp_p->e_rabs_failed[i].cause_value;
           break;
+
         case S1AP_Cause_PR_NOTHING:
         default:
           break;
@@ -1595,6 +1557,7 @@ int s1ap_eNB_e_rab_release_resp(instance_t instance,
 
   /* optional */
 #if (S1AP_VERSION >= MAKE_VERSION(12, 0, 0))
+
   if(0) {
     ie = (S1AP_E_RABReleaseResponseIEs_t *)calloc(1, sizeof(S1AP_E_RABReleaseResponseIEs_t));
     ie->id = S1AP_ProtocolIE_ID_id_UserLocationInformation;
@@ -1603,9 +1566,10 @@ int s1ap_eNB_e_rab_release_resp(instance_t instance,
     // ie->value.choice.UserLocationInformation = ;
     ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
   }
-#endif /* #if (S1AP_VERSION >= MAKE_VERSION(14, 0, 0)) */
 
+#endif /* #if (S1AP_VERSION >= MAKE_VERSION(14, 0, 0)) */
   fprintf(stderr, "start encode\n");
+
   if (s1ap_eNB_encode_pdu(&pdu, &buffer, &length) < 0) {
     S1AP_ERROR("Failed to encode release response\n");
     /* Encode procedure has failed... */
@@ -1621,14 +1585,11 @@ int s1ap_eNB_e_rab_release_resp(instance_t instance,
     0,0,//MSC_AS_TIME_ARGS(ctxt_pP),
     e_rab_release_resp_p->eNB_ue_s1ap_id,
     ue_context_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);
-
   S1AP_INFO("e_rab_release_response sended eNB_UE_S1AP_ID %d  mme_ue_s1ap_id %d nb_of_e_rabs_released %d nb_of_e_rabs_failed %d\n",
             e_rab_release_resp_p->eNB_ue_s1ap_id, ue_context_p->mme_ue_s1ap_id,e_rab_release_resp_p->nb_of_e_rabs_released,e_rab_release_resp_p->nb_of_e_rabs_failed);
-
   return 0;
 }

targets/RT/USER/lte-enb.c

@@ -166,13 +166,10 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
   // *******************************************************************
 
   if (nfapi_mode == 1) {
-
     // I am a PNF and I need to let nFAPI know that we have a (sub)frame tick
     uint16_t frame = proc->frame_rx;
     uint16_t subframe = proc->subframe_rx;
-
     //add_subframe(&frame, &subframe, 4);
-
     //oai_subframe_ind(proc->frame_tx, proc->subframe_tx);
     //LOG_D(PHY, "oai_subframe_ind(frame:%u, subframe:%d) - NOT CALLED ********\n", frame, subframe);
     start_meas(&nfapi_meas);
@@ -203,7 +200,6 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
 
   // ****************************************
   // Common RX procedures subframe n
-
   T(T_ENB_PHY_DL_TICK, T_INT(eNB->Mod_id), T_INT(proc->frame_tx), T_INT(proc->subframe_tx));
 
   // if this is IF5 or 3GPP_eNB
@@ -220,6 +216,7 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
   if (nfapi_mode == 0 || nfapi_mode == 1) {
     phy_procedures_eNB_uespec_RX(eNB, proc);
   }
+
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ULSCH_SCHEDULER, 1 );
 
   if(get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) {
@@ -227,36 +224,34 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
       LOG_E(PHY,"Frame %d, subframe %d: TX1 not ready\n",proc[1].frame_rx,proc[1].subframe_rx);
       return(-1);
     }
+
     if (release_thread(&proc[1].mutex_rxtx,&proc[1].pipe_ready,"wakeup_tx")<0)  return(-1);
   }
 
   pthread_mutex_lock(&eNB->UL_INFO_mutex);
-
   eNB->UL_INFO.frame     = proc->frame_rx;
   eNB->UL_INFO.subframe  = proc->subframe_rx;
   eNB->UL_INFO.module_id = eNB->Mod_id;
   eNB->UL_INFO.CC_id     = eNB->CC_id;
-
   eNB->if_inst->UL_indication(&eNB->UL_INFO);
-
   pthread_mutex_unlock(&eNB->UL_INFO_mutex);
   /* this conflict resolution may be totally wrong, to be tested */
   /* CONFLICT RESOLUTION: BEGIN */
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ULSCH_SCHEDULER, 0 );
+
   if(oai_exit) return(-1);
+
   if(get_thread_parallel_conf() == PARALLEL_SINGLE_THREAD) {
 #ifndef PHY_TX_THREAD
     phy_procedures_eNB_TX(eNB, proc, 1);
 #endif
   }
+
   /* CONFLICT RESOLUTION: what about this release_thread call, has it to be done? if yes, where? */
   //if (release_thread(&proc->mutex_rxtx,&proc->instance_cnt_rxtx,thread_name)<0) return(-1);
   /* CONFLICT RESOLUTION: END */
-
   stop_meas( &softmodem_stats_rxtx_sf );
-
   LOG_D(PHY,"%s() Exit proc[rx:%d%d tx:%d%d]\n", __FUNCTION__, proc->frame_rx, proc->subframe_rx, proc->frame_tx, proc->subframe_tx);
-
   LOG_D(PHY, "rxtx:%lld nfapi:%lld tx:%lld rx:%lld prach:%lld ofdm:%lld ",
         softmodem_stats_rxtx_sf.p_time, nfapi_meas.p_time,
         TICK_TO_US(eNB->phy_proc_tx),
@@ -273,14 +268,12 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
         TICK_TO_US(eNB->dlsch_turbo_encoding_stats),
         TICK_TO_US(eNB->dlsch_interleaving_stats),
         TICK_TO_US(eNB->rx_dft_stats));
-
   LOG_D(PHY," ulsch[ch:%lld freq:%lld dec:%lld demod:%lld ru:%lld ",
         TICK_TO_US(eNB->ulsch_channel_estimation_stats),
         TICK_TO_US(eNB->ulsch_freq_offset_estimation_stats),
         TICK_TO_US(eNB->ulsch_decoding_stats),
         TICK_TO_US(eNB->ulsch_demodulation_stats),
         TICK_TO_US(eNB->ulsch_rate_unmatching_stats));
-
   LOG_D(PHY, "td:%lld dei:%lld dem:%lld llr:%lld tci:%lld ",
         TICK_TO_US(eNB->ulsch_turbo_decoding_stats),
         TICK_TO_US(eNB->ulsch_deinterleaving_stats),
@@ -295,17 +288,14 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
         TICK_TO_US(eNB->ulsch_tc_intl1_stats),
         TICK_TO_US(eNB->ulsch_tc_intl2_stats)
        );
-  
   return(0);
 }
 
 
 static void *tx_thread(void *param) {
-
   eNB_proc_t *eNB_proc  = (eNB_proc_t *)param;
   eNB_rxtx_proc_t *proc = &eNB_proc->proc_rxtx[1];
   PHY_VARS_eNB *eNB = RC.eNB[0][proc->CC_id];
-  
   char thread_name[100];
   sprintf(thread_name,"TXnp4_%d\n",&eNB->proc.proc_rxtx[0] == proc ? 0 : 1);
   thread_top_init(thread_name,1,470000,500000,500000);
@@ -313,10 +303,10 @@ static void* tx_thread(void* param) {
   //wait_sync("tx_thread");
 
   while (!oai_exit) {
-    
-
     if (wait_on_condition(&proc->mutex_rxtx,&proc->cond_rxtx,&proc->instance_cnt_rxtx,thread_name)<0) break;
+
     if (oai_exit) break;
+
     // *****************************************
     // TX processing for subframe n+4
     // run PHY TX procedures the one after the other for all CCs to avoid race conditions
@@ -326,17 +316,19 @@ static void* tx_thread(void* param) {
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX1_ENB,proc->subframe_rx);
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX1_ENB,proc->frame_tx);
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX1_ENB,proc->frame_rx);
-    
     phy_procedures_eNB_TX(eNB, proc, 1);
+
     if (release_thread(&proc->mutex_rxtx,&proc->instance_cnt_rxtx,thread_name)<0) break;
 
     pthread_mutex_lock( &proc->mutex_rxtx );
     proc->pipe_ready++;
+
     // the thread can now be woken up
     if (pthread_cond_signal(&proc->cond_rxtx) != 0) {
       LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB TXnp4 thread\n");
       exit_fun( "ERROR pthread_cond_signal" );
     }
+
     pthread_mutex_unlock( &proc->mutex_rxtx );
     wakeup_txfh(proc,eNB_proc->ru_proc);
   }
@@ -351,7 +343,6 @@ static void* tx_thread(void* param) {
  */
 
 static void *eNB_thread_rxtx( void *param ) {
-
   static int eNB_thread_rxtx_status;
   //eNB_proc_t *eNB_proc  = (eNB_proc_t*)param;
   eNB_rxtx_proc_t *proc;
@@ -359,35 +350,24 @@ static void* eNB_thread_rxtx( void* param ) {
   // Working
   if(nfapi_mode ==2) {
     proc = (eNB_rxtx_proc_t *)param;
-  }
+  } else {
-  else{
     eNB_proc_t *eNB_proc  = (eNB_proc_t *)param;
     proc = &eNB_proc->proc_rxtx[0];
   }
 
-
   PHY_VARS_eNB *eNB = RC.eNB[0][proc->CC_id];
   //RU_proc_t *ru_proc = NULL;
-
   char thread_name[100];
-
   cpu_set_t cpuset;
   CPU_ZERO(&cpuset);
-
   // set default return value
   eNB_thread_rxtx_status = 0;
-
-
   sprintf(thread_name,"RXn_TXnp4_%d\n",&eNB->proc.proc_rxtx[0] == proc ? 0 : 1);
   thread_top_init(thread_name,1,470000,500000,500000);
   pthread_setname_np( pthread_self(),"rxtx processing");
   LOG_I(PHY,"thread rxtx created id=%ld\n", syscall(__NR_gettid));
 
-
-
   while (!oai_exit) {
-    
-    
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX0+(proc->subframe_rx&1), 0 );
     T(T_ENB_MASTER_TICK, T_INT(0), T_INT(proc->frame_rx), T_INT(proc->subframe_rx));
 
@@ -395,61 +375,55 @@ static void* eNB_thread_rxtx( void* param ) {
 
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_CPUID_ENB_THREAD_RXTX,sched_getcpu());
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX0+(proc->subframe_rx&1), 1 );
-   
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_ENB,proc->subframe_tx);
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_ENB,proc->subframe_rx);
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB,proc->frame_tx);
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_ENB,proc->frame_rx);
 
-
     if (oai_exit) break;
 
-    if (eNB->CC_id==0)
+    if (eNB->CC_id==0) {
-    {
       if (rxtx(eNB,proc,thread_name) < 0) break;
     }
 
     if (release_thread(&proc->mutex_rxtx,&proc->instance_cnt_rxtx,thread_name)<0) break;
+
     pthread_mutex_lock( &proc->mutex_rxtx );
     proc->pipe_ready++;
+
     // the thread can now be woken up
     if (pthread_cond_signal(&proc->cond_rxtx) != 0) {
       LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB TXnp4 thread\n");
       exit_fun( "ERROR pthread_cond_signal" );
     }
+
     pthread_mutex_unlock( &proc->mutex_rxtx );
+
     if (nfapi_mode!=2) {
       if(get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT)      wakeup_tx(eNB,eNB->proc.ru_proc);
-    	else if(get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT)
+      else if(get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT) {
-    	{
         phy_procedures_eNB_TX(eNB, proc, 1);
         wakeup_txfh(proc,eNB->proc.ru_proc);
       }
     }
-
   } // while !oai_exit
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX0+(proc->subframe_rx&1), 0 );
-
   LOG_D(PHY, " *** Exiting eNB thread RXn_TXnp4\n");
-
   eNB_thread_rxtx_status = 0;
   return &eNB_thread_rxtx_status;
 }
 
-void eNB_top(PHY_VARS_eNB *eNB, int frame_rx, int subframe_rx, char *string,RU_t *ru)
+void eNB_top(PHY_VARS_eNB *eNB, int frame_rx, int subframe_rx, char *string,RU_t *ru) {
-{
   eNB_proc_t *proc           = &eNB->proc;
   eNB_rxtx_proc_t *proc_rxtx = &proc->proc_rxtx[0];
   LTE_DL_FRAME_PARMS *fp = &ru->frame_parms;
   RU_proc_t *ru_proc=&ru->proc;
-
   proc->frame_rx    = frame_rx;
   proc->subframe_rx = subframe_rx;
 
   if (!oai_exit) {
     T(T_ENB_MASTER_TICK, T_INT(0), T_INT(proc->frame_rx), T_INT(proc->subframe_rx));
-
     proc_rxtx->timestamp_tx = ru_proc->timestamp_rx + (sf_ahead*fp->samples_per_tti);
     proc_rxtx->frame_rx     = ru_proc->frame_rx;
     proc_rxtx->subframe_rx  = ru_proc->subframe_rx;
@@ -457,6 +431,7 @@ void eNB_top(PHY_VARS_eNB *eNB, int frame_rx, int subframe_rx, char *string,RU_t
     proc_rxtx->subframe_tx  = (proc_rxtx->subframe_rx + sf_ahead)%10;
 
     if (rxtx(eNB,proc_rxtx,string) < 0) LOG_E(PHY,"eNB %d CC_id %d failed during execution\n",eNB->Mod_id,eNB->CC_id);
+
     ru_proc->timestamp_tx = proc_rxtx->timestamp_tx;
     ru_proc->subframe_tx  = proc_rxtx->subframe_tx;
     ru_proc->frame_tx     = proc_rxtx->frame_tx;
@@ -464,24 +439,25 @@ void eNB_top(PHY_VARS_eNB *eNB, int frame_rx, int subframe_rx, char *string,RU_t
 }
 
 int wakeup_txfh(eNB_rxtx_proc_t *proc,RU_proc_t *ru_proc) {
-  
   if(ru_proc == NULL)
     return(0);
+
   struct timespec wait;
   wait.tv_sec=0;
   wait.tv_nsec=5000000L;
 
-  
   if(wait_on_condition(&ru_proc->mutex_eNBs,&ru_proc->cond_eNBs,&ru_proc->ru_tx_ready,"wakeup_txfh")<0) {
     LOG_E(PHY,"Frame %d, subframe %d: TX FH not ready\n", ru_proc->frame_tx, ru_proc->subframe_tx);
     return(-1);
   }
+
   if (release_thread(&ru_proc->mutex_eNBs,&ru_proc->ru_tx_ready,"wakeup_txfh")<0) return(-1);
 
   if (ru_proc->instance_cnt_eNBs == 0) {
     LOG_E(PHY,"Frame %d, subframe %d: TX FH thread busy, dropping Frame %d, subframe %d\n", ru_proc->frame_tx, ru_proc->subframe_tx, proc->frame_rx, proc->subframe_rx);
     return(-1);
   }
+
   if (pthread_mutex_timedlock(&ru_proc->mutex_eNBs,&wait) != 0) {
     LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB TX1 thread %d (IC %d)\n", ru_proc->subframe_rx&1,ru_proc->instance_cnt_eNBs );
     exit_fun( "error locking mutex_eNB" );
@@ -501,24 +477,17 @@ int wakeup_txfh(eNB_rxtx_proc_t *proc,RU_proc_t *ru_proc) {
   }
 
   pthread_mutex_unlock( &ru_proc->mutex_eNBs );
-
   return(0);
 }
 
 int wakeup_tx(PHY_VARS_eNB *eNB,RU_proc_t *ru_proc) {
-
   eNB_proc_t *proc=&eNB->proc;
-
   eNB_rxtx_proc_t *proc_rxtx1=&proc->proc_rxtx[1];//*proc_rxtx=&proc->proc_rxtx[proc->frame_rx&1];
   eNB_rxtx_proc_t *proc_rxtx0=&proc->proc_rxtx[0];
-
-  
   struct timespec wait;
   wait.tv_sec=0;
   wait.tv_nsec=5000000L;
 
-  
-  
   if (proc_rxtx1->instance_cnt_rxtx == 0) {
     LOG_E(PHY,"Frame %d, subframe %d: TX1 thread busy, dropping\n",proc_rxtx1->frame_rx,proc_rxtx1->subframe_rx);
     return(-1);
@@ -531,8 +500,6 @@ int wakeup_tx(PHY_VARS_eNB *eNB,RU_proc_t *ru_proc) {
   }
 
   ++proc_rxtx1->instance_cnt_rxtx;
-
-  
   proc_rxtx1->subframe_rx   = proc_rxtx0->subframe_rx;
   proc_rxtx1->frame_rx      = proc_rxtx0->frame_rx;
   proc_rxtx1->subframe_tx   = proc_rxtx0->subframe_tx;
@@ -547,54 +514,46 @@ int wakeup_tx(PHY_VARS_eNB *eNB,RU_proc_t *ru_proc) {
   }
 
   pthread_mutex_unlock( &proc_rxtx1->mutex_rxtx );
-
   return(0);
 }
 
 int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) {
-
   eNB_proc_t *proc=&eNB->proc;
   RU_proc_t *ru_proc=&ru->proc;
-
   eNB_rxtx_proc_t *proc_rxtx0=&proc->proc_rxtx[0];
   //eNB_rxtx_proc_t *proc_rxtx1=&proc->proc_rxtx[1];
-  
-
   LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
-
   int i;
   struct timespec wait;
-  
   pthread_mutex_lock(&proc->mutex_RU);
+
   for (i=0; i<eNB->num_RU; i++) {
     if (ru == eNB->RU_list[i]) {
       if ((proc->RU_mask&(1<<i)) > 0)
         LOG_E(PHY,"eNB %d frame %d, subframe %d : previous information from RU %d (num_RU %d,mask %x) has not been served yet!\n",
               eNB->Mod_id,proc->frame_rx,proc->subframe_rx,ru->idx,eNB->num_RU,proc->RU_mask);
+
       proc->RU_mask |= (1<<i);
     }
   }
+
   if (proc->RU_mask != (1<<eNB->num_RU)-1) {  // not all RUs have provided their information so return
     LOG_E(PHY,"Not all RUs have provided their info\n");
     pthread_mutex_unlock(&proc->mutex_RU);
     return(0);
-  }
+  } else { // all RUs have provided their information so continue on and wakeup eNB processing
-  else { // all RUs have provided their information so continue on and wakeup eNB processing
     proc->RU_mask = 0;
     pthread_mutex_unlock(&proc->mutex_RU);
   }
 
-
-
-
   wait.tv_sec=0;
   wait.tv_nsec=5000000L;
 
-  
   if(wait_on_condition(&proc_rxtx0->mutex_rxtx,&proc_rxtx0->cond_rxtx,&proc_rxtx0->pipe_ready,"wakeup_rxtx")<0) {
     LOG_E(PHY,"Frame %d, subframe %d: RXTX0 not ready\n",proc_rxtx0->frame_rx,proc_rxtx0->subframe_rx);
     return(-1);
   }
+
   if (release_thread(&proc_rxtx0->mutex_rxtx,&proc_rxtx0->pipe_ready,"wakeup_rxtx")<0) return(-1);
 
   if (proc_rxtx0->instance_cnt_rxtx == 0) {
@@ -610,9 +569,7 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) {
     return(-1);
   }
 
-
   ++proc_rxtx0->instance_cnt_rxtx;
-  
   // We have just received and processed the common part of a subframe, say n.
   // TS_rx is the last received timestamp (start of 1st slot), TS_tx is the desired
   // transmitted timestamp of the next TX slot (first).
@@ -633,32 +590,33 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) {
   }
 
   pthread_mutex_unlock( &proc_rxtx0->mutex_rxtx );
-
   return(0);
 }
 
 void wakeup_prach_eNB(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) {
-
   eNB_proc_t *proc = &eNB->proc;
   LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
   int i;
 
   if (ru!=NULL) {
     pthread_mutex_lock(&proc->mutex_RU_PRACH);
+
     for (i=0; i<eNB->num_RU; i++) {
       if (ru == eNB->RU_list[i]) {
         LOG_D(PHY,"frame %d, subframe %d: RU %d for eNB %d signals PRACH (mask %x, num_RU %d)\n",frame,subframe,i,eNB->Mod_id,proc->RU_mask_prach,eNB->num_RU);
+
         if ((proc->RU_mask_prach&(1<<i)) > 0)
           LOG_E(PHY,"eNB %d frame %d, subframe %d : previous information (PRACH) from RU %d (num_RU %d, mask %x) has not been served yet!\n",
                 eNB->Mod_id,frame,subframe,ru->idx,eNB->num_RU,proc->RU_mask_prach);
+
         proc->RU_mask_prach |= (1<<i);
       }
     }
+
     if (proc->RU_mask_prach != (1<<eNB->num_RU)-1) {  // not all RUs have provided their information so return
       pthread_mutex_unlock(&proc->mutex_RU_PRACH);
       return;
-    }
+    } else { // all RUs have provided their information so continue on and wakeup eNB processing
-    else { // all RUs have provided their information so continue on and wakeup eNB processing
       proc->RU_mask_prach = 0;
       pthread_mutex_unlock(&proc->mutex_RU_PRACH);
     }
@@ -667,6 +625,7 @@ void wakeup_prach_eNB(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) {
   // check if we have to detect PRACH first
   if (is_prach_subframe(fp,frame,subframe)>0) {
     LOG_D(PHY,"Triggering prach processing, frame %d, subframe %d\n",frame,subframe);
+
     if (proc->instance_cnt_prach == 0) {
       LOG_W(PHY,"[eNB] Frame %d Subframe %d, dropping PRACH\n", frame,subframe);
       return;
@@ -693,32 +652,33 @@ void wakeup_prach_eNB(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) {
 
     pthread_mutex_unlock( &proc->mutex_prach );
   }
-
 }
 
 #if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
 void wakeup_prach_eNB_br(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) {
-
   eNB_proc_t *proc = &eNB->proc;
   LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
   int i;
 
   if (ru!=NULL) {
     pthread_mutex_lock(&proc->mutex_RU_PRACH_br);
+
     for (i=0; i<eNB->num_RU; i++) {
       if (ru == eNB->RU_list[i]) {
         LOG_D(PHY,"frame %d, subframe %d: RU %d for eNB %d signals PRACH BR (mask %x, num_RU %d)\n",frame,subframe,i,eNB->Mod_id,proc->RU_mask_prach_br,eNB->num_RU);
+
         if ((proc->RU_mask_prach_br&(1<<i)) > 0)
           LOG_E(PHY,"eNB %d frame %d, subframe %d : previous information (PRACH BR) from RU %d (num_RU %d, mask %x) has not been served yet!\n",
                 eNB->Mod_id,frame,subframe,ru->idx,eNB->num_RU,proc->RU_mask_prach_br);
+
         proc->RU_mask_prach_br |= (1<<i);
       }
     }
+
     if (proc->RU_mask_prach_br != (1<<eNB->num_RU)-1) {  // not all RUs have provided their information so return
       pthread_mutex_unlock(&proc->mutex_RU_PRACH_br);
       return;
-    }
+    } else { // all RUs have provided their information so continue on and wakeup eNB processing
-    else { // all RUs have provided their information so continue on and wakeup eNB processing
       proc->RU_mask_prach_br = 0;
       pthread_mutex_unlock(&proc->mutex_RU_PRACH_br);
     }
@@ -727,6 +687,7 @@ void wakeup_prach_eNB_br(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) {
   // check if we have to detect PRACH first
   if (is_prach_subframe(fp,frame,subframe)>0) {
     LOG_D(PHY,"Triggering prach br processing, frame %d, subframe %d\n",frame,subframe);
+
     if (proc->instance_cnt_prach_br == 0) {
       LOG_W(PHY,"[eNB] Frame %d Subframe %d, dropping PRACH BR\n", frame,subframe);
       return;
@@ -753,7 +714,6 @@ void wakeup_prach_eNB_br(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) {
 
     pthread_mutex_unlock( &proc->mutex_prach_br );
   }
-
 }
 #endif
 
@@ -765,23 +725,17 @@ void wakeup_prach_eNB_br(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) {
  */
 static void *eNB_thread_prach( void *param ) {
   static int eNB_thread_prach_status;
-
-
   PHY_VARS_eNB *eNB= (PHY_VARS_eNB *)param;
   eNB_proc_t *proc = &eNB->proc;
-
   // set default return value
   eNB_thread_prach_status = 0;
-
   thread_top_init("eNB_thread_prach",1,500000,1000000,20000000);
 
   //wait_sync("eNB_thread_prach");
 
   while (!oai_exit) {
-    
-
-    
     if (wait_on_condition(&proc->mutex_prach,&proc->cond_prach,&proc->instance_cnt_prach,"eNB_prach_thread") < 0) break;
+
     if (oai_exit) break;
 
     LOG_D(PHY,"Running eNB prach procedures\n");
@@ -795,7 +749,6 @@ static void* eNB_thread_prach( void* param ) {
   }
 
   LOG_I(PHY, "Exiting eNB thread PRACH\n");
-
   eNB_thread_prach_status = 0;
   return &eNB_thread_prach_status;
 }
@@ -808,21 +761,15 @@ static void* eNB_thread_prach( void* param ) {
  */
 static void *eNB_thread_prach_br( void *param ) {
   static int eNB_thread_prach_status;
-
-
   PHY_VARS_eNB *eNB= (PHY_VARS_eNB *)param;
   eNB_proc_t *proc = &eNB->proc;
-
   // set default return value
   eNB_thread_prach_status = 0;
-
   thread_top_init("eNB_thread_prach_br",1,500000,1000000,20000000);
 
   while (!oai_exit) {
-    
-    
-
     if (wait_on_condition(&proc->mutex_prach_br,&proc->cond_prach_br,&proc->instance_cnt_prach_br,"eNB_prach_thread_br") < 0) break;
+
     if (oai_exit) break;
 
     LOG_D(PHY,"Running eNB prach procedures for BL/CE UEs\n");
@@ -832,7 +779,6 @@ static void* eNB_thread_prach_br( void* param ) {
   }
 
   LOG_I(PHY, "Exiting eNB thread PRACH BR\n");
-
   eNB_thread_prach_status = 0;
   return &eNB_thread_prach_status;
 }
@@ -847,17 +793,16 @@ extern void kill_td_thread(PHY_VARS_eNB *);
 extern void kill_te_thread(PHY_VARS_eNB *);
 
 static void *process_stats_thread(void *param) {
-
   PHY_VARS_eNB     *eNB      = (PHY_VARS_eNB *)param;
-
   wait_sync("process_stats_thread");
 
   while (!oai_exit) {
     sleep(1);
+
     if (opp_enabled == 1) {
       if (eNB->td) print_meas(&eNB->ulsch_decoding_stats,"ulsch_decoding",NULL,NULL);
-        if (eNB->te)
+
-        {
+      if (eNB->te) {
         print_meas(&eNB->dlsch_turbo_encoding_preperation_stats,"dlsch_coding_crc",NULL,NULL);
         print_meas(&eNB->dlsch_turbo_encoding_segmentation_stats,"dlsch_segmentation",NULL,NULL);
         print_meas(&eNB->dlsch_encoding_stats,"dlsch_encoding",NULL,NULL);
@@ -870,15 +815,16 @@ static void* process_stats_thread(void* param) {
         print_meas(&eNB->dlsch_turbo_encoding_wakeup_stats0,"coding_worker_0",NULL,NULL);
         print_meas(&eNB->dlsch_turbo_encoding_wakeup_stats1,"coding_worker_1",NULL,NULL);
       }
+
       print_meas(&eNB->dlsch_modulation_stats,"dlsch_modulation",NULL,NULL);
     }
   }
+
   return(NULL);
 }
 
 
 void init_eNB_proc(int inst) {
-  
   /*int i=0;*/
   int CC_id;
   PHY_VARS_eNB *eNB;
@@ -888,7 +834,6 @@ void init_eNB_proc(int inst) {
 #if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
   pthread_attr_t *attr_prach_br=NULL;
 #endif
-
   LOG_I(PHY,"%s(inst:%d) RC.nb_CC[inst]:%d \n",__FUNCTION__,inst,RC.nb_CC[inst]);
 
   for (CC_id=0; CC_id<RC.nb_CC[inst]; CC_id++) {
@@ -897,7 +842,6 @@ void init_eNB_proc(int inst) {
     LOG_I(PHY,"Initializing eNB processes instance:%d CC_id %d \n",inst,CC_id);
 #endif
     proc = &eNB->proc;
-
     proc_rxtx                      = proc->proc_rxtx;
     proc_rxtx[0].instance_cnt_rxtx = -1;
     proc_rxtx[1].instance_cnt_rxtx = -1;
@@ -907,26 +851,21 @@ void init_eNB_proc(int inst) {
     proc->instance_cnt_asynch_rxtx = -1;
     proc->instance_cnt_synch       = -1;
     proc->CC_id                    = CC_id;
-
     proc->first_rx=1;
     proc->first_tx=1;
     proc->RU_mask=0;
     proc->RU_mask_prach=0;
-
     pthread_mutex_init( &eNB->UL_INFO_mutex, NULL);
     pthread_mutex_init( &proc_rxtx[0].mutex_rxtx, NULL);
     pthread_mutex_init( &proc_rxtx[1].mutex_rxtx, NULL);
     pthread_cond_init( &proc_rxtx[0].cond_rxtx, NULL);
     pthread_cond_init( &proc_rxtx[1].cond_rxtx, NULL);
-
     pthread_mutex_init( &proc->mutex_prach, NULL);
     pthread_mutex_init( &proc->mutex_asynch_rxtx, NULL);
     pthread_mutex_init( &proc->mutex_RU,NULL);
     pthread_mutex_init( &proc->mutex_RU_PRACH,NULL);
-
     pthread_cond_init( &proc->cond_prach, NULL);
     pthread_cond_init( &proc->cond_asynch_rxtx, NULL);
-
     pthread_attr_init( &proc->attr_prach);
     pthread_attr_init( &proc->attr_asynch_rxtx);
     pthread_attr_init( &proc_rxtx[0].attr_rxtx);
@@ -946,24 +885,22 @@ void init_eNB_proc(int inst) {
 #if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
     attr_prach_br  = &proc->attr_prach_br;
 #endif
-
     //    attr_td     = &proc->attr_td;
     //    attr_te     = &proc->attr_te;
 #endif
 
-    if(get_thread_worker_conf() == WORKER_ENABLE)
+    if(get_thread_worker_conf() == WORKER_ENABLE) {
-    {
       init_te_thread(eNB);
       init_td_thread(eNB);
     }
 
-
     LOG_I(PHY,"eNB->single_thread_flag:%d\n", eNB->single_thread_flag);
 
     if ((get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT || get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) && nfapi_mode!=2) {
       pthread_create( &proc_rxtx[0].pthread_rxtx, attr0, eNB_thread_rxtx, proc );
       pthread_create( &proc_rxtx[1].pthread_rxtx, attr1, tx_thread, proc);
     }
+
     pthread_create( &proc->pthread_prach, attr_prach, eNB_thread_prach, eNB );
 #if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
     pthread_create( &proc->pthread_prach_br, attr_prach_br, eNB_thread_prach_br, eNB );
@@ -975,13 +912,9 @@ void init_eNB_proc(int inst) {
       snprintf( name, sizeof(name), "RXTX1 %d", i );
       pthread_setname_np( proc_rxtx[1].pthread_rxtx, name );
     }*/
-
     AssertFatal(proc->instance_cnt_prach == -1,"instance_cnt_prach = %d\n",proc->instance_cnt_prach);
 
-
     if (opp_enabled == 1) pthread_create(&proc->process_stats_thread,NULL,process_stats_thread,(void *)eNB);
-
-    
   }
 
   //for multiple CCs: setup master and slaves
@@ -1000,13 +933,10 @@ void init_eNB_proc(int inst) {
      }
      }
   */
-
   /* setup PHY proc TX sync mechanism */
   pthread_mutex_init(&sync_phy_proc.mutex_phy_proc_tx, NULL);
   pthread_cond_init(&sync_phy_proc.cond_phy_proc_tx, NULL);
   sync_phy_proc.phy_proc_CC_id = 0;
-  
-  
 }
 
 
@@ -1015,15 +945,14 @@ void init_eNB_proc(int inst) {
  * \brief Terminate eNB TX and RX threads.
  */
 void kill_eNB_proc(int inst) {
-
   int *status;
   PHY_VARS_eNB *eNB;
   eNB_proc_t *proc;
   eNB_rxtx_proc_t *proc_rxtx;
   int i;
+
   for (int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
     eNB=RC.eNB[inst][CC_id];
-    
     proc = &eNB->proc;
     proc_rxtx = &proc->proc_rxtx[0];
 
@@ -1031,7 +960,9 @@ void kill_eNB_proc(int inst) {
       kill_td_thread(eNB);
       kill_te_thread(eNB);
     }
+
     LOG_I(PHY, "Killing TX CC_id %d inst %d\n", CC_id, inst );
+
     for (i=0; i<2; i++) {
       pthread_mutex_lock(&proc_rxtx[i].mutex_rxtx);
       proc_rxtx[i].instance_cnt_rxtx = 0;
@@ -1039,17 +970,15 @@ void kill_eNB_proc(int inst) {
       pthread_cond_signal(&proc_rxtx[i].cond_rxtx);
       pthread_mutex_unlock(&proc_rxtx[i].mutex_rxtx);
     }
+
     pthread_mutex_lock(&proc->mutex_prach);
     proc->instance_cnt_prach = 0;
     pthread_cond_signal( &proc->cond_prach );
     pthread_mutex_unlock(&proc->mutex_prach);
-
     pthread_cond_signal( &proc->cond_asynch_rxtx );
     pthread_cond_broadcast(&sync_phy_proc.cond_phy_proc_tx);
-
     LOG_D(PHY, "joining pthread_prach\n");
     pthread_join( proc->pthread_prach, (void **)&status );
-
     LOG_I(PHY, "Destroying prach mutex/cond\n");
     pthread_mutex_destroy( &proc->mutex_prach );
     pthread_cond_destroy( &proc->cond_prach );
@@ -1062,6 +991,7 @@ void kill_eNB_proc(int inst) {
 #endif
     LOG_I(PHY, "Destroying UL_INFO mutex\n");
     pthread_mutex_destroy(&eNB->UL_INFO_mutex);
+
     for (i=0; i<2; i++) {
       LOG_I(PHY, "Joining rxtx[%d] mutex/cond\n",i);
       pthread_join( proc_rxtx[i].pthread_rxtx, (void **)&status );
@@ -1078,7 +1008,6 @@ void kill_eNB_proc(int inst) {
     pthread_mutex_destroy(&proc->mutex_RU_PRACH_br);
     pthread_attr_destroy(&proc->attr_prach_br);
 #endif
-
   }
 }
 
@@ -1086,7 +1015,6 @@ void kill_eNB_proc(int inst) {
 
 
 void reset_opp_meas(void) {
-
   int sfn;
   reset_meas(&softmodem_stats_mt);
   reset_meas(&softmodem_stats_hw);
@@ -1099,7 +1027,6 @@ void reset_opp_meas(void) {
 
 
 void print_opp_meas(void) {
-
   int sfn=0;
   print_meas(&softmodem_stats_mt, "Main ENB Thread", NULL, NULL);
   print_meas(&softmodem_stats_hw, "HW Acquisation", NULL, NULL);
@@ -1110,33 +1037,34 @@ void print_opp_meas(void) {
   }
 }
 
-void free_transport(PHY_VARS_eNB *eNB)
+void free_transport(PHY_VARS_eNB *eNB) {
-{
   int i;
   int j;
 
   for (i=0; i<NUMBER_OF_UE_MAX; i++) {
     LOG_D(PHY, "Freeing Transport Channel Buffers for DLSCH, UE %d\n",i);
+
     for (j=0; j<2; j++) free_eNB_dlsch(eNB->dlsch[i][j]);
 
     LOG_D(PHY, "Freeing Transport Channel Buffer for ULSCH, UE %d\n",i);
     free_eNB_ulsch(eNB->ulsch[1+i]);
   }
+
   free_eNB_ulsch(eNB->ulsch[0]);
 }
 
 void init_transport(PHY_VARS_eNB *eNB) {
-
   int i;
   int j;
   LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
-
   LOG_I(PHY, "Initialise transport\n");
 
   for (i=0; i<NUMBER_OF_UE_MAX; i++) {
     LOG_D(PHY,"Allocating Transport Channel Buffers for DLSCH, UE %d\n",i);
+
     for (j=0; j<2; j++) {
       eNB->dlsch[i][j] = new_eNB_dlsch(1,8,NSOFT,fp->N_RB_DL,0,fp);
+
       if (!eNB->dlsch[i][j]) {
         LOG_E(PHY,"Can't get eNB dlsch structures for UE %d \n", i);
         exit(-1);
@@ -1158,6 +1086,7 @@ void init_transport(PHY_VARS_eNB *eNB) {
     // this will be overwritten with the real transmission mode by the RRC once the UE is connected
     eNB->transmission_mode[i] = fp->nb_antenna_ports_eNB==1 ? 1 : 2;
   }
+
   // ULSCH for RA
   eNB->ulsch[0] = new_eNB_ulsch(MAX_TURBO_ITERATIONS, fp->N_RB_UL, 0);
 
@@ -1165,70 +1094,60 @@ void init_transport(PHY_VARS_eNB *eNB) {
     LOG_E(PHY,"Can't get eNB ulsch structures\n");
     exit(-1);
   }
+
   eNB->dlsch_SI  = new_eNB_dlsch(1,8,NSOFT,fp->N_RB_DL, 0, fp);
   LOG_D(PHY,"eNB %d.%d : SI %p\n",eNB->Mod_id,eNB->CC_id,eNB->dlsch_SI);
   eNB->dlsch_ra  = new_eNB_dlsch(1,8,NSOFT,fp->N_RB_DL, 0, fp);
   LOG_D(PHY,"eNB %d.%d : RA %p\n",eNB->Mod_id,eNB->CC_id,eNB->dlsch_ra);
   eNB->dlsch_MCH = new_eNB_dlsch(1,8,NSOFT,fp->N_RB_DL, 0, fp);
   LOG_D(PHY,"eNB %d.%d : MCH %p\n",eNB->Mod_id,eNB->CC_id,eNB->dlsch_MCH);
-  
-  
   eNB->rx_total_gain_dB=130;
 
   for(i=0; i<NUMBER_OF_UE_MAX; i++)
     eNB->mu_mimo_mode[i].dl_pow_off = 2;
 
   eNB->check_for_total_transmissions = 0;
-  
   eNB->check_for_MUMIMO_transmissions = 0;
-  
   eNB->FULL_MUMIMO_transmissions = 0;
-  
   eNB->check_for_SUMIMO_transmissions = 0;
-  
   fp->pucch_config_common.deltaPUCCH_Shift = 1;
-    
 }
 
 void init_eNB_afterRU(void) {
-
   int inst,CC_id,ru_id,i,aa;
   PHY_VARS_eNB *eNB;
-
   LOG_I(PHY,"%s() RC.nb_inst:%d\n", __FUNCTION__, RC.nb_inst);
 
   for (inst=0; inst<RC.nb_inst; inst++) {
     LOG_I(PHY,"RC.nb_CC[inst]:%d\n", RC.nb_CC[inst]);
+
     for (CC_id=0; CC_id<RC.nb_CC[inst]; CC_id++) {
-
       LOG_I(PHY,"RC.nb_CC[inst:%d][CC_id:%d]:%p\n", inst, CC_id, RC.eNB[inst][CC_id]);
-
       eNB                                  =  RC.eNB[inst][CC_id];
       phy_init_lte_eNB(eNB,0,0);
+
       // map antennas and PRACH signals to eNB RX
       if (0) AssertFatal(eNB->num_RU>0,"Number of RU attached to eNB %d is zero\n",eNB->Mod_id);
+
       LOG_I(PHY,"Mapping RX ports from %d RUs to eNB %d\n",eNB->num_RU,eNB->Mod_id);
       eNB->frame_parms.nb_antennas_rx       = 0;
-
       LOG_I(PHY,"Overwriting eNB->prach_vars.rxsigF[0]:%p\n", eNB->prach_vars.rxsigF[0]);
-
       eNB->prach_vars.rxsigF[0] = (int16_t **)malloc16(64*sizeof(int16_t *));
 #if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+
       for (int ce_level=0; ce_level<4; ce_level++) {
         LOG_I(PHY,"Overwriting eNB->prach_vars_br.rxsigF.rxsigF[0]:%p\n", eNB->prach_vars_br.rxsigF[ce_level]);
         eNB->prach_vars_br.rxsigF[ce_level] = (int16_t **)malloc16(64*sizeof(int16_t *));
       }
-#endif
 
+#endif
       LOG_I(PHY,"eNB->num_RU:%d\n", eNB->num_RU);
 
       for (ru_id=0,aa=0; ru_id<eNB->num_RU; ru_id++) {
         eNB->frame_parms.nb_antennas_rx    += eNB->RU_list[ru_id]->nb_rx;
-
         AssertFatal(eNB->RU_list[ru_id]->common.rxdataF!=NULL,
                     "RU %d : common.rxdataF is NULL\n",
                     eNB->RU_list[ru_id]->idx);
-
         AssertFatal(eNB->RU_list[ru_id]->prach_rxsigF!=NULL,
                     "RU %d : prach_rxsigF is NULL\n",
                     eNB->RU_list[ru_id]->idx);
@@ -1237,56 +1156,45 @@ void init_eNB_afterRU(void) {
           LOG_I(PHY,"Attaching RU %d antenna %d to eNB antenna %d\n",eNB->RU_list[ru_id]->idx,i,aa);
           eNB->prach_vars.rxsigF[0][aa]    =  eNB->RU_list[ru_id]->prach_rxsigF[i];
 #if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+
           for (int ce_level=0; ce_level<4; ce_level++)
             eNB->prach_vars_br.rxsigF[ce_level][aa] = eNB->RU_list[ru_id]->prach_rxsigF_br[ce_level][i];
+
 #endif
           eNB->common_vars.rxdataF[aa]     =  eNB->RU_list[ru_id]->common.rxdataF[i];
         }
       }
 
-
-
       /* TODO: review this code, there is something wrong.
        * In monolithic mode, we come here with nb_antennas_rx == 0
        * (not tested in other modes).
        */
-      if (eNB->frame_parms.nb_antennas_rx < 1)
+      if (eNB->frame_parms.nb_antennas_rx < 1) {
-      {
         LOG_I(PHY, "%s() ************* DJP ***** eNB->frame_parms.nb_antennas_rx:%d - GOING TO HARD CODE TO 1", __FUNCTION__, eNB->frame_parms.nb_antennas_rx);
         eNB->frame_parms.nb_antennas_rx = 1;
-      }
+      } else {
-      else
-      {
         //LOG_I(PHY," Delete code\n");
       }
 
-      if (eNB->frame_parms.nb_antennas_tx < 1)
+      if (eNB->frame_parms.nb_antennas_tx < 1) {
-      {
         LOG_I(PHY, "%s() ************* DJP ***** eNB->frame_parms.nb_antennas_tx:%d - GOING TO HARD CODE TO 1", __FUNCTION__, eNB->frame_parms.nb_antennas_tx);
         eNB->frame_parms.nb_antennas_tx = 1;
-      }
+      } else {
-      else
-      {
         //LOG_I(PHY," Delete code\n");
       }
 
-
-
-
       AssertFatal(eNB->frame_parms.nb_antennas_rx >0,
                   "inst %d, CC_id %d : nb_antennas_rx %d\n",inst,CC_id,eNB->frame_parms.nb_antennas_rx);
       LOG_I(PHY,"inst %d, CC_id %d : nb_antennas_rx %d\n",inst,CC_id,eNB->frame_parms.nb_antennas_rx);
-
       init_transport(eNB);
       //init_precoding_weights(RC.eNB[inst][CC_id]);
     }
+
     init_eNB_proc(inst);
   }
 
   for (ru_id=0; ru_id<RC.nb_RU; ru_id++) {
-
     AssertFatal(RC.ru[ru_id]!=NULL,"ru_id %d is null\n",ru_id);
-    
     RC.ru[ru_id]->wakeup_rxtx         = wakeup_rxtx;
     RC.ru[ru_id]->wakeup_prach_eNB    = wakeup_prach_eNB;
 #if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
@@ -1297,34 +1205,30 @@ void init_eNB_afterRU(void) {
 }
 
 void init_eNB(int single_thread_flag,int wait_for_sync) {
-  
   int CC_id;
   int inst;
   PHY_VARS_eNB *eNB;
-
   LOG_I(PHY,"[lte-softmodem.c] eNB structure about to allocated RC.nb_L1_inst:%d RC.nb_L1_CC[0]:%d\n",RC.nb_L1_inst,RC.nb_L1_CC[0]);
 
   if (RC.eNB == NULL) RC.eNB = (PHY_VARS_eNB ***) malloc(RC.nb_L1_inst*sizeof(PHY_VARS_eNB **));
+
   LOG_I(PHY,"[lte-softmodem.c] eNB structure RC.eNB allocated\n");
+
   for (inst=0; inst<RC.nb_L1_inst; inst++) {
     if (RC.eNB[inst] == NULL) RC.eNB[inst] = (PHY_VARS_eNB **) malloc(RC.nb_CC[inst]*sizeof(PHY_VARS_eNB *));
+
     for (CC_id=0; CC_id<RC.nb_L1_CC[inst]; CC_id++) {
       if (RC.eNB[inst][CC_id] == NULL) RC.eNB[inst][CC_id] = (PHY_VARS_eNB *) malloc(sizeof(PHY_VARS_eNB));
+
       eNB                     = RC.eNB[inst][CC_id];
       eNB->abstraction_flag   = 0;
       eNB->single_thread_flag = single_thread_flag;
-
-
       LOG_I(PHY,"Initializing eNB %d CC_id %d single_thread_flag:%d\n",inst,CC_id,single_thread_flag);
 #ifndef OCP_FRAMEWORK
       LOG_I(PHY,"Initializing eNB %d CC_id %d\n",inst,CC_id);
 #endif
-
-
       eNB->td                   = ulsch_decoding_data_all;
       eNB->te                   = dlsch_encoding_all;
-
-      
       LOG_I(PHY,"Registering with MAC interface module\n");
       AssertFatal((eNB->if_inst         = IF_Module_init(inst))!=NULL,"Cannot register interface");
       eNB->if_inst->schedule_response   = schedule_response;
@@ -1340,7 +1244,6 @@ void init_eNB(int single_thread_flag,int wait_for_sync) {
       eNB->UL_INFO.cqi_ind.cqi_raw_pdu_list = eNB->cqi_raw_pdu_list;
       eNB->prach_energy_counter = 0;
     }
-
   }
 
   LOG_I(PHY,"[lte-softmodem.c] eNB structure allocated\n");
@@ -1348,7 +1251,6 @@ void init_eNB(int single_thread_flag,int wait_for_sync) {
 
 
 void stop_eNB(int nb_inst) {
-
   for (int inst=0; inst<nb_inst; inst++) {
     LOG_I(PHY,"Killing eNB %d processing threads\n",inst);
     kill_eNB_proc(inst);