pdcp_fifo.c 38.5 KB
Newer Older
1 2 3 4 5
/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
6
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
7 8 9 10 11 12 13 14 15 16 17 18 19 20
 * except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.openairinterface.org/?page_id=698
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */
21 22

/*! \file pdcp_fifo.c
23
 * \brief pdcp interface with linux IP interface, have a look at http://man7.org/linux/man-pages/man7/netlink.7.html for netlink
24 25
 * \author  Navid Nikaein and Lionel GAUTHIER
 * \date 2009 - 2016
26
 * \version 0.5
27
 * \email navid.nikaein@eurecom.fr
28 29 30
 * \warning This component can be runned only in user-space
 * @ingroup pdcp
 */
31 32 33

#define PDCP_FIFO_C
#define PDCP_DEBUG 1
34
//#define DEBUG_PDCP_FIFO_FLUSH_SDU
35 36 37 38 39 40 41 42 43

#ifndef OAI_EMU
extern int otg_enabled;
#endif

#include "pdcp.h"
#include "pdcp_primitives.h"

#ifdef USER_MODE
44
#include <pthread.h>
45 46 47 48 49 50 51 52 53 54 55 56
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define rtf_put write
#define rtf_get read
#else
#include <rtai_fifos.h>
#endif //USER_MODE

#include "../MAC/extern.h"
#include "RRC/L2_INTERFACE/openair_rrc_L2_interface.h"
57
#include "NETWORK_DRIVER/LITE/constant.h"
58 59 60 61
#include "SIMULATION/ETH_TRANSPORT/extern.h"
#include "UTIL/OCG/OCG.h"
#include "UTIL/OCG/OCG_extern.h"
#include "UTIL/LOG/log.h"
62
#include "UTIL/OTG/otg_tx.h"
63
#include "UTIL/FIFO/pad_list.h"
64
#include "UTIL/LOG/vcd_signal_dumper.h"
65
#include "platform_constants.h"
gauthier's avatar
gauthier committed
66
#include "msc.h"
67

68
#include "assertions.h"
69

70
#ifdef PDCP_USE_NETLINK
71 72
#include <sys/socket.h>
#include <linux/netlink.h>
73
#include "NETWORK_DRIVER/UE_IP/constant.h"
74

75
extern char nl_rx_buf[NL_MAX_PAYLOAD];
76
extern struct sockaddr_nl nas_src_addr, nas_dest_addr;
77 78 79 80
extern struct nlmsghdr *nas_nlh_tx;
extern struct nlmsghdr *nas_nlh_rx;
extern struct iovec nas_iov_tx;
extern struct iovec nas_iov_rx;
81
extern int nas_sock_fd;
82 83
extern struct msghdr nas_msg_tx;
extern struct msghdr nas_msg_rx;
84

85
unsigned char pdcp_read_state_g = 0;
86 87
#endif

88
extern Packet_OTG_List_t *otg_pdcp_buffer;
89

90
#if defined(LINK_ENB_PDCP_TO_GTPV1U)
gauthier's avatar
gauthier committed
91
#  include "gtpv1u_eNB_task.h"
Cedric Roux's avatar
Cedric Roux committed
92
#  include "gtpv1u_eNB_defs.h"
gauthier's avatar
gauthier committed
93 94
#endif

95 96
extern int gtpv1u_new_data_req( uint8_t  enb_module_idP, rnti_t   ue_rntiP, uint8_t  rab_idP, uint8_t *buffer_pP, uint32_t buf_lenP, uint32_t buf_offsetP);

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
/* Prevent de-queueing the same PDCP SDU from the queue twice
 * by multiple threads. This has happened in TDD when thread-odd
 * is flushing a PDCP SDU after UE_RX() processing; whereas
 * thread-even is at a special-subframe, skips the UE_RX() process
 * and goes straight to the PDCP SDU flushing. The 2nd flushing
 * dequeues the same SDU again causing unexpected behavior.
 *
 * comment out the MACRO below to disable this protection
 */
#define PDCP_SDU_FLUSH_LOCK

#ifdef PDCP_SDU_FLUSH_LOCK
static pthread_mutex_t mtex = PTHREAD_MUTEX_INITIALIZER;
#endif

112
pdcp_data_req_header_t pdcp_read_header_g;
113 114

//-----------------------------------------------------------------------------
115
int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const  ctxt_pP)
116 117 118
{
  //-----------------------------------------------------------------------------

119
//#if defined(PDCP_USE_NETLINK) && defined(LINUX)
120
  int ret = 0;
121
//#endif
122

123 124
#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU
#define THREAD_NAME_LEN 16
125
  static char threadname[THREAD_NAME_LEN];
126 127 128 129 130 131 132 133 134
  ret = pthread_getname_np(pthread_self(), threadname, THREAD_NAME_LEN);
  if (ret != 0)
  {
   perror("pthread_getname_np : ");
   exit_fun("Error getting thread name");
  }
#undef THREAD_NAME_LEN
#endif

135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
#ifdef PDCP_SDU_FLUSH_LOCK
  ret = pthread_mutex_trylock(&mtex);
  if (ret == EBUSY) {
#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU
    LOG_W(PDCP, "[%s] at SFN/SF=%d/%d wait for PDCP FIFO to be unlocked\n",
        threadname, ctxt_pP->frame, ctxt_pP->subframe);
#endif
    if (pthread_mutex_lock(&mtex)) {
      exit_fun("PDCP_SDU_FLUSH_LOCK lock error!");
    }
#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU
    LOG_I(PDCP, "[%s] at SFN/SF=%d/%d PDCP FIFO is unlocked\n",
        threadname, ctxt_pP->frame, ctxt_pP->subframe);
#endif
  } else if (ret != 0) {
    exit_fun("PDCP_SDU_FLUSH_LOCK trylock error!");
  }

#endif

  mem_block_t     *sdu_p            = list_get_head (&pdcp_sdu_list);
  int              bytes_wrote      = 0;
  int              pdcp_nb_sdu_sent = 0;
  uint8_t          cont             = 1;
#if defined(LINK_ENB_PDCP_TO_GTPV1U)
  //MessageDef      *message_p        = NULL;
#endif

163
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH, 1 );
164
  while (sdu_p && cont) {
165

166 167 168 169 170 171
#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU
    LOG_D(PDCP, "[%s] SFN/SF=%d/%d inst=%d size=%d\n",
        threadname, ctxt_pP->frame, ctxt_pP->subframe,
        ((pdcp_data_ind_header_t*) sdu_p->data)->inst,
        ((pdcp_data_ind_header_t *) sdu_p->data)->data_size);
#else
gauthier's avatar
gauthier committed
172
#if ! defined(OAI_EMU)
Cedric Roux's avatar
Cedric Roux committed
173 174
    /* TODO: do we have to reset to 0 or not? not for a scenario with 1 UE at least */
//    ((pdcp_data_ind_header_t *)(sdu_p->data))->inst = 0;
175
#endif
176
#endif
177

178
#if defined(LINK_ENB_PDCP_TO_GTPV1U)
gauthier's avatar
gauthier committed
179

180 181 182 183
    if (ctxt_pP->enb_flag) {
      AssertFatal(0, "Now execution should not go here");
      LOG_D(PDCP,"Sending to GTPV1U %d bytes\n", ((pdcp_data_ind_header_t *)(sdu_p->data))->data_size);
      gtpv1u_new_data_req(
184 185 186 187 188 189
			  ctxt_pP->module_id, //gtpv1u_data_t *gtpv1u_data_p,
			  ctxt_pP->rnti,//rb_id/maxDRB, TO DO UE ID
			  ((pdcp_data_ind_header_t *)(sdu_p->data))->rb_id + 4,
			  &(((uint8_t *) sdu_p->data)[sizeof (pdcp_data_ind_header_t)]),
			  ((pdcp_data_ind_header_t *)(sdu_p->data))->data_size,
			  0);
190 191

      list_remove_head (&pdcp_sdu_list);
192
      free_mem_block (sdu_p, __func__);
193 194 195 196 197 198 199
      cont = 1;
      pdcp_nb_sdu_sent += 1;
      sdu_p = list_get_head (&pdcp_sdu_list);
      LOG_D(OTG,"After  GTPV1U\n");
      continue; // loop again
    }

gauthier's avatar
gauthier committed
200
#endif /* defined(ENABLE_USE_MME) */
201
#ifdef PDCP_DEBUG
202
    LOG_D(PDCP, "PDCP->IP TTI %d INST %d: Preparing %d Bytes of data from rab %d to Nas_mesh\n",
203
          ctxt_pP->frame, ((pdcp_data_ind_header_t *)(sdu_p->data))->inst,
204
          ((pdcp_data_ind_header_t *)(sdu_p->data))->data_size, ((pdcp_data_ind_header_t *)(sdu_p->data))->rb_id);
205
#endif //PDCP_DEBUG
206
    cont = 0;
207

208 209 210 211
    if (!pdcp_output_sdu_bytes_to_write) {
      if (!pdcp_output_header_bytes_to_write) {
        pdcp_output_header_bytes_to_write = sizeof (pdcp_data_ind_header_t);
      }
212

213 214
#ifdef PDCP_USE_RT_FIFO
      bytes_wrote = rtf_put (PDCP2PDCP_USE_RT_FIFO,
215 216
                             &(((uint8_t *) sdu->data)[sizeof (pdcp_data_ind_header_t) - pdcp_output_header_bytes_to_write]),
                             pdcp_output_header_bytes_to_write);
217 218

#else
219
#ifdef PDCP_USE_NETLINK
220
#ifdef LINUX
221 222 223
      memcpy(NLMSG_DATA(nas_nlh_tx), &(((uint8_t *) sdu_p->data)[sizeof (pdcp_data_ind_header_t) - pdcp_output_header_bytes_to_write]),
             pdcp_output_header_bytes_to_write);
      nas_nlh_tx->nlmsg_len = pdcp_output_header_bytes_to_write;
224
#endif //LINUX
225
#endif //PDCP_USE_NETLINK
226

227
      bytes_wrote = pdcp_output_header_bytes_to_write;
228
#endif //PDCP_USE_RT_FIFO
229 230

#ifdef PDCP_DEBUG
231
      LOG_D(PDCP, "Frame %d Sent %d Bytes of header to Nas_mesh\n",
232 233
            ctxt_pP->frame,
            bytes_wrote);
234 235
#endif //PDCP_DEBUG

236 237
      if (bytes_wrote > 0) {
        pdcp_output_header_bytes_to_write = pdcp_output_header_bytes_to_write - bytes_wrote;
238

239 240
        if (!pdcp_output_header_bytes_to_write) { // continue with sdu
          pdcp_output_sdu_bytes_to_write = ((pdcp_data_ind_header_t *) sdu_p->data)->data_size;
241
          AssertFatal(pdcp_output_sdu_bytes_to_write >= 0, "invalid data_size!");
242

243 244
#ifdef PDCP_USE_RT_FIFO
          bytes_wrote = rtf_put (PDCP2PDCP_USE_RT_FIFO, &(sdu->data[sizeof (pdcp_data_ind_header_t)]), pdcp_output_sdu_bytes_to_write);
245 246
#else

247
#ifdef PDCP_USE_NETLINK
248
#ifdef LINUX
249 250
          memcpy(NLMSG_DATA(nas_nlh_tx)+sizeof(pdcp_data_ind_header_t), &(sdu_p->data[sizeof (pdcp_data_ind_header_t)]), pdcp_output_sdu_bytes_to_write);
          nas_nlh_tx->nlmsg_len += pdcp_output_sdu_bytes_to_write;
251 252
          VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE_PDCP_FLUSH_SIZE, pdcp_output_sdu_bytes_to_write);
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH_BUFFER, 1 );
253
          ret = sendmsg(nas_sock_fd,&nas_msg_tx,0);
254 255
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH_BUFFER, 0 );
          VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE_PDCP_FLUSH_ERR, ret );
256 257

          if (ret<0) {
258
            LOG_E(PDCP, "[PDCP_FIFOS] sendmsg returns %d (errno: %d)\n", ret, errno);
gauthier's avatar
gauthier committed
259 260 261 262 263 264 265 266 267
      	    MSC_LOG_TX_MESSAGE_FAILED(
      	      (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE,
      	      (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_IP_ENB:MSC_IP_UE,
      	      NULL,
      	      0,
      	      MSC_AS_TIME_FMT" DATA-IND RNTI %"PRIx16" rb %u size %u",
      	      MSC_AS_TIME_ARGS(ctxt_pP),
      	      ((pdcp_data_ind_header_t *)(sdu_p->data))->rb_id,
      	      ((pdcp_data_ind_header_t *)(sdu_p->data))->data_size);
268
	    AssertFatal(1==0,"sendmsg failed for nas_sock_fd\n");
269
            break;
gauthier's avatar
gauthier committed
270 271 272 273 274 275 276 277 278 279
          } else {
        	  MSC_LOG_TX_MESSAGE(
        	    (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE,
        	    (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_IP_ENB:MSC_IP_UE,
        	    NULL,
        	    0,
        	    MSC_AS_TIME_FMT" DATA-IND RNTI %"PRIx16" rb %u size %u",
        	    MSC_AS_TIME_ARGS(ctxt_pP),
        	    ((pdcp_data_ind_header_t *)(sdu_p->data))->rb_id,
        	    ((pdcp_data_ind_header_t *)(sdu_p->data))->data_size);
280 281
          }

282
#endif // LINUX
283
#endif //PDCP_USE_NETLINK
284
          bytes_wrote= pdcp_output_sdu_bytes_to_write;
285
#endif // PDCP_USE_RT_FIFO
286 287

#ifdef PDCP_DEBUG
288 289 290 291 292
          LOG_D(PDCP, "PDCP->IP Frame %d INST %d: Sent %d Bytes of data from rab %d to higher layers\n",
                ctxt_pP->frame,
                ((pdcp_data_ind_header_t *)(sdu_p->data))->inst,
                bytes_wrote,
                ((pdcp_data_ind_header_t *)(sdu_p->data))->rb_id);
293
#endif //PDCP_DEBUG
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308

          if (bytes_wrote > 0) {
            pdcp_output_sdu_bytes_to_write -= bytes_wrote;

            if (!pdcp_output_sdu_bytes_to_write) { // OK finish with this SDU
              // LOG_D(PDCP, "rb sent a sdu qos_sap %d\n", sapiP);
              LOG_D(PDCP,
                    "[FRAME %05d][xxx][PDCP][MOD xx/xx][RB %u][--- PDCP_DATA_IND / %d Bytes --->][IP][INSTANCE %u][RB %u]\n",
                    ctxt_pP->frame,
                    ((pdcp_data_ind_header_t *)(sdu_p->data))->rb_id,
                    ((pdcp_data_ind_header_t *)(sdu_p->data))->data_size,
                    ((pdcp_data_ind_header_t *)(sdu_p->data))->inst,
                    ((pdcp_data_ind_header_t *)(sdu_p->data))->rb_id);

              list_remove_head (&pdcp_sdu_list);
309
              free_mem_block (sdu_p, __func__);
310 311 312
              cont = 1;
              pdcp_nb_sdu_sent += 1;
              sdu_p = list_get_head (&pdcp_sdu_list);
313 314 315
            } else {
              LOG_D(PDCP, "1 skip free_mem_block: pdcp_output_sdu_bytes_to_write = %d\n", pdcp_output_sdu_bytes_to_write);
              AssertFatal(pdcp_output_sdu_bytes_to_write > 0, "pdcp_output_sdu_bytes_to_write cannot be negative!");
316 317
            }
          } else {
318
            LOG_W(PDCP, "2: RADIO->IP SEND SDU CONGESTION!\n");
319
          }
320
        } else {
321
          LOG_W(PDCP, "3: RADIO->IP SEND SDU CONGESTION!\n");
322
        }
323 324
      } else {
        LOG_D(PDCP, "4 skip free_mem_block: bytes_wrote = %d\n", bytes_wrote);
325 326 327
      }
    } else {
      // continue writing sdu
328 329
#ifdef PDCP_USE_RT_FIFO
      bytes_wrote = rtf_put (PDCP2PDCP_USE_RT_FIFO,
330 331
                             (uint8_t *) (&(sdu_p->data[sizeof (pdcp_data_ind_header_t) + ((pdcp_data_ind_header_t *) sdu_p->data)->data_size - pdcp_output_sdu_bytes_to_write])),
                             pdcp_output_sdu_bytes_to_write);
332
#else  // PDCP_USE_RT_FIFO
333
      bytes_wrote = pdcp_output_sdu_bytes_to_write;
334
#endif  // PDCP_USE_RT_FIFO
335

336 337 338 339 340 341
      if (bytes_wrote > 0) {
        pdcp_output_sdu_bytes_to_write -= bytes_wrote;

        if (!pdcp_output_sdu_bytes_to_write) {     // OK finish with this SDU
          //PRINT_RB_SEND_OUTPUT_SDU ("[PDCP] RADIO->IP SEND SDU\n");
          list_remove_head (&pdcp_sdu_list);
342
          free_mem_block (sdu_p, __func__);
343 344 345 346
          cont = 1;
          pdcp_nb_sdu_sent += 1;
          sdu_p = list_get_head (&pdcp_sdu_list);
          // LOG_D(PDCP, "rb sent a sdu from rab\n");
347 348
        } else {
          LOG_D(PDCP, "5 skip free_mem_block: pdcp_output_sdu_bytes_to_write = %d\n", pdcp_output_sdu_bytes_to_write);
349
        }
350 351
      } else {
        LOG_D(PDCP, "6 skip free_mem_block: bytes_wrote = %d\n", bytes_wrote);
352
      }
353
    }
354
  }
355
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH, 0 );
356

357
#ifdef PDCP_USE_RT_FIFO
358

359
  if ((pdcp_nb_sdu_sent)) {
360
    if ((pdcp_2_nas_irq > 0)) {
361
#ifdef PDCP_DEBUG
362
      LOG_D(PDCP, "Frame %d : Trigger NAS RX interrupt\n",
363
            ctxt_pP->frame);
364
#endif //PDCP_DEBUG
365
      rt_pend_linux_srq (pdcp_2_nas_irq);
366

367 368 369 370 371
    } else {
      LOG_E(PDCP, "Frame %d: ERROR IF IP STACK WANTED : NOTIF PACKET(S) pdcp_2_nas_irq not initialized : %d\n",
            ctxt_pP->frame,
            pdcp_2_nas_irq);
    }
372
  }
373

374
#endif  //PDCP_USE_RT_FIFO
375

376 377 378 379
#ifdef PDCP_SDU_FLUSH_LOCK
  if (pthread_mutex_unlock(&mtex)) exit_fun("PDCP_SDU_FLUSH_LOCK unlock error!");
#endif

380 381 382 383
  return pdcp_nb_sdu_sent;
}

//-----------------------------------------------------------------------------
384
int pdcp_fifo_read_input_sdus (const protocol_ctxt_t* const  ctxt_pP)
385
{
386
#ifdef PDCP_USE_NETLINK
387
  protocol_ctxt_t                ctxt_cpy = *ctxt_pP;
388 389 390 391
  protocol_ctxt_t                ctxt;
  hash_key_t                     key       = HASHTABLE_NOT_A_KEY_VALUE;
  hashtable_rc_t                 h_rc;
  struct pdcp_netlink_element_s* data_p    = NULL;
Cedric Roux's avatar
Cedric Roux committed
392 393
  /* avoid gcc warnings */
  (void)data_p;
394
  module_id_t                    ue_id     = 0;
395
  pdcp_t*                        pdcp_p    = NULL;
396
# if defined(PDCP_USE_NETLINK_QUEUES)
397
  rb_id_t                        rab_id    = 0;
398

399
  pdcp_transmission_mode_t       pdcp_mode = PDCP_TRANSMISSION_MODE_UNKNOWN;
400

gauthier's avatar
gauthier committed
401

402
  while (pdcp_netlink_dequeue_element(ctxt_pP, &data_p) != 0) {
knopp's avatar
knopp committed
403
    DevAssert(data_p != NULL);
404 405 406 407 408 409 410 411 412 413 414 415 416
    rab_id = data_p->pdcp_read_header.rb_id % maxDRB;
    // ctxt_pP->rnti is NOT_A_RNTI
    ctxt_cpy.rnti = pdcp_module_id_to_rnti[ctxt_cpy.module_id][data_p->pdcp_read_header.inst];
    key = PDCP_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_cpy.rnti, ctxt_pP->enb_flag, rab_id, SRB_FLAG_NO);
    h_rc = hashtable_get(pdcp_coll_p, key, (void**)&pdcp_p);

    if (h_rc != HASH_TABLE_OK) {
      LOG_W(PDCP, PROTOCOL_CTXT_FMT" Dropped IP PACKET cause no PDCP instanciated\n",
            PROTOCOL_CTXT_ARGS(ctxt_pP));
      free(data_p->data);
      free(data_p);
      data_p = NULL;
      continue;
417 418
    }

419
    CHECK_CTXT_ARGS(&ctxt_cpy);
420 421 422 423

    AssertFatal (rab_id    < maxDRB,                       "RB id is too high (%u/%d)!\n", rab_id, maxDRB);

    if (rab_id != 0) {
424
        LOG_I(PDCP, "[FRAME %05d][%s][IP][INSTANCE %u][RB %u][--- PDCP_DATA_REQ "
425
            "/ %d Bytes --->][PDCP][MOD %u][RB %u]\n",
426 427
              ctxt_cpy.frame,
              (ctxt_cpy.enb_flag) ? "eNB" : "UE",
428 429 430 431
            data_p->pdcp_read_header.inst,
            data_p->pdcp_read_header.rb_id,
            data_p->pdcp_read_header.data_size,
            ctxt_cpy.module_id,
432 433 434
              rab_id);
#ifdef  OAI_NW_DRIVER_TYPE_ETHERNET

435 436 437
      if ((data_p->pdcp_read_header.traffic_type == TRAFFIC_IPV6_TYPE_MULTICAST) /*TRAFFIC_IPV6_TYPE_MULTICAST */ ||
          (data_p->pdcp_read_header.traffic_type == TRAFFIC_IPV4_TYPE_MULTICAST) /*TRAFFIC_IPV4_TYPE_MULTICAST */ ||
          (data_p->pdcp_read_header.traffic_type == TRAFFIC_IPV4_TYPE_BROADCAST) /*TRAFFIC_IPV4_TYPE_BROADCAST */ ) {
Cedric Roux's avatar
Cedric Roux committed
438
#if defined(Rel10) || defined(Rel14)
439
          PDCP_TRANSMISSION_MODE_TRANSPARENT;
440
#else
441
          pdcp_mode= PDCP_TRANSMISSION_MODE_DATA;
442
#endif
443 444
      } else if ((data_p->pdcp_read_header.traffic_type == TRAFFIC_IPV6_TYPE_UNICAST) /* TRAFFIC_IPV6_TYPE_UNICAST */ ||
                 (data_p->pdcp_read_header.traffic_type == TRAFFIC_IPV4_TYPE_UNICAST) /*TRAFFIC_IPV4_TYPE_UNICAST*/ ) {
445 446 447 448 449 450
          pdcp_mode=  PDCP_TRANSMISSION_MODE_DATA;
        } else {
          pdcp_mode= PDCP_TRANSMISSION_MODE_DATA;
          LOG_W(PDCP,"unknown IP traffic type \n");
        }

451
#else // OAI_NW_DRIVER_TYPE_ETHERNET NASMESH driver does not curreenlty support multicast traffic
452
        pdcp_mode = PDCP_TRANSMISSION_MODE_DATA;
453
#endif
454
      pdcp_data_req(&ctxt_cpy,
455
                      SRB_FLAG_NO,
456
                      rab_id % maxDRB,
457 458
                      RLC_MUI_UNDEFINED,
                      RLC_SDU_CONFIRM_NO,
459 460
                    data_p->pdcp_read_header.data_size,
                    data_p->data,
461 462 463 464 465 466 467 468 469
                      pdcp_mode);
    } else if (ctxt_cpy.enb_flag) {
      /* rb_id = 0, thus interpreated as broadcast and transported as
       * multiple unicast is a broadcast packet, we have to send this
       * packet on all default RABS of all connected UEs
       */
      LOG_D(PDCP, "eNB Try Forcing send on DEFAULT_RAB_ID first_ue_local %u nb_ue_local %u\n", oai_emulation.info.first_ue_local, oai_emulation.info.nb_ue_local);

      for (ue_id = 0; ue_id < NB_UE_INST; ue_id++) {
470
        if (pdcp_module_id_to_rnti[ctxt_cpy.module_id][ue_id] != NOT_A_RNTI) {
471
          LOG_D(PDCP, "eNB Try Forcing send on DEFAULT_RAB_ID UE %d\n", ue_id);
472 473
          ctxt.module_id     = ctxt_cpy.module_id;
          ctxt.rnti          = ctxt_cpy.pdcp_module_id_to_rnti[ctxt_cpy.module_id][ue_id];
474 475 476
          ctxt.frame         = ctxt_cpy.frame;
          ctxt.enb_flag      = ctxt_cpy.enb_flag;

477
          pdcp_data_req(
478 479 480 481 482
            &ctxt,
            SRB_FLAG_NO,
            DEFAULT_RAB_ID,
            RLC_MUI_UNDEFINED,
            RLC_SDU_CONFIRM_NO,
483 484
            data_p->pdcp_read_header.data_size,
            data_p->data,
485 486
            PDCP_TRANSMISSION_MODE_DATA);
        }
487
      }
488 489 490 491 492 493 494 495
    } else {
      LOG_D(PDCP, "Forcing send on DEFAULT_RAB_ID\n");
      pdcp_data_req(
        &ctxt_cpy,
        SRB_FLAG_NO,
        DEFAULT_RAB_ID,
        RLC_MUI_UNDEFINED,
        RLC_SDU_CONFIRM_NO,
496 497
        data_p->pdcp_read_header.data_size,
        data_p->data,
498 499 500
        PDCP_TRANSMISSION_MODE_DATA);
    }

501 502 503
    free(data_p->data);
    free(data_p);
    data_p = NULL;
504
  }
505

506
  return 0;
507
# else /* PDCP_USE_NETLINK_QUEUES*/
508
  int              len = 1;
509
  int  msg_len;
510
  rb_id_t          rab_id  = 0;
511 512 513
  int rlc_data_req_flag = 3;
 
  while ((len > 0) && (rlc_data_req_flag !=0))  {
514 515
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ, 1 );
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ_BUFFER, 1 );
516
    len = recvmsg(nas_sock_fd, &nas_msg_rx, 0);
517
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ_BUFFER, 0 );
518 519 520

    if (len<=0) {
      // nothing in pdcp NAS socket
521
      //LOG_D(PDCP, "[PDCP][NETLINK] Nothing in socket, length %d \n", len);
522
    } else {
523 524
    
      msg_len = len;
525
      for (nas_nlh_rx = (struct nlmsghdr *) nl_rx_buf;
526 527
           NLMSG_OK (nas_nlh_rx, msg_len);
           nas_nlh_rx = NLMSG_NEXT (nas_nlh_rx, msg_len)) {
528 529

        if (nas_nlh_rx->nlmsg_type == NLMSG_DONE) {
530
          LOG_D(PDCP, "[PDCP][NETLINK] RX NLMSG_DONE\n");
531 532 533 534
          //return;
        }

        if (nas_nlh_rx->nlmsg_type == NLMSG_ERROR) {
535
          LOG_D(PDCP, "[PDCP][NETLINK] RX NLMSG_ERROR\n");
536 537 538 539 540 541
        }

        if (pdcp_read_state_g == 0) {
          if (nas_nlh_rx->nlmsg_len == sizeof (pdcp_data_req_header_t) + sizeof(struct nlmsghdr)) {
            pdcp_read_state_g = 1;  //get
            memcpy((void *)&pdcp_read_header_g, (void *)NLMSG_DATA(nas_nlh_rx), sizeof(pdcp_data_req_header_t));
542
            LOG_D(PDCP, "[PDCP][NETLINK] RX pdcp_data_req_header_t inst %u, rb_id %u data_size %d\n",
543 544
                  pdcp_read_header_g.inst, pdcp_read_header_g.rb_id, pdcp_read_header_g.data_size);
          } else {
545
            LOG_E(PDCP, "[PDCP][NETLINK] WRONG size %d should be sizeof (pdcp_data_req_header_t) + sizeof(struct nlmsghdr)\n",
546 547 548 549 550
                  nas_nlh_rx->nlmsg_len);
          }
        } else {
          pdcp_read_state_g = 0;
          // print_active_requests()
551
#ifdef PDCP_DEBUG
552
          LOG_D(PDCP, "[PDCP][NETLINK] Something in socket, length %zu\n",
553
                nas_nlh_rx->nlmsg_len - sizeof(struct nlmsghdr));
554
#endif
555

556
#ifdef OAI_EMU
557 558 559 560 561

          // overwrite function input parameters, because only one netlink socket for all instances
          if (pdcp_read_header_g.inst < oai_emulation.info.nb_enb_local) {
            ctxt.frame         = ctxt_cpy.frame;
            ctxt.enb_flag      = ENB_FLAG_YES;
562 563
            ctxt.module_id     = pdcp_read_header_g.inst  +  oai_emulation.info.first_enb_local;
            ctxt.rnti          = oai_emulation.info.eNB_ue_module_id_to_rnti[ctxt.module_id ][pdcp_read_header_g.rb_id / maxDRB + oai_emulation.info.first_ue_local];
564 565 566 567
            rab_id    = pdcp_read_header_g.rb_id % maxDRB;
          } else {
            ctxt.frame         = ctxt_cpy.frame;
            ctxt.enb_flag      = ENB_FLAG_NO;
568 569
            ctxt.module_id     = pdcp_read_header_g.inst - oai_emulation.info.nb_enb_local + oai_emulation.info.first_ue_local;
            ctxt.rnti          = pdcp_UE_UE_module_id_to_rnti[ctxt.module_id];
nikaeinn's avatar
nikaeinn committed
570
            rab_id    = pdcp_read_header_g.rb_id % maxDRB;
571 572
          }

573
          CHECK_CTXT_ARGS(&ctxt);
574 575 576 577
          AssertFatal (rab_id    < maxDRB,                       "RB id is too high (%u/%d)!\n", rab_id, maxDRB);
          /*LGpdcp_read_header.inst = (pdcp_read_header_g.inst >= oai_emulation.info.nb_enb_local) ? \
                  pdcp_read_header_g.inst - oai_emulation.info.nb_enb_local+ NB_eNB_INST + oai_emulation.info.first_ue_local :
                  pdcp_read_header_g.inst +  oai_emulation.info.first_enb_local;*/
578
#else // OAI_EMU
Cedric Roux's avatar
Cedric Roux committed
579 580
          /* TODO: do we have to reset to 0 or not? not for a scenario with 1 UE at least */
//          pdcp_read_header_g.inst = 0;
Cedric Roux's avatar
Cedric Roux committed
581
//#warning "TO DO CORRCT VALUES FOR ue mod id, enb mod id"
582
          ctxt.frame         = ctxt_cpy.frame;
583
          ctxt.enb_flag      = ctxt_cpy.enb_flag;
584

585
#ifdef PDCP_DEBUG
586
          LOG_I(PDCP, "[PDCP][NETLINK] pdcp_read_header_g.rb_id = %d\n", pdcp_read_header_g.rb_id);
587 588
#endif

589
          if (ctxt_cpy.enb_flag) {
590
            ctxt.module_id = 0;
591
            rab_id      = pdcp_read_header_g.rb_id % maxDRB;
Florian Kaltenberger's avatar
Florian Kaltenberger committed
592
            ctxt.rnti          = pdcp_eNB_UE_instance_to_rnti[pdcp_eNB_UE_instance_to_rnti_index];
593
          } else {
594
            ctxt.module_id = 0;
595
            rab_id      = pdcp_read_header_g.rb_id % maxDRB;
596
            ctxt.rnti          = pdcp_UE_UE_module_id_to_rnti[ctxt.module_id];
597
          }
598

599

600 601
#endif

602 603 604
          if (ctxt.enb_flag) {
            if (rab_id != 0) {
              rab_id = rab_id % maxDRB;
605 606
              key = PDCP_COLL_KEY_VALUE(ctxt.module_id, ctxt.rnti, ctxt.enb_flag, rab_id, SRB_FLAG_NO);
              h_rc = hashtable_get(pdcp_coll_p, key, (void**)&pdcp_p);
607

608
              if (h_rc == HASH_TABLE_OK) {
609
#ifdef PDCP_DEBUG
610
                LOG_D(PDCP, "[FRAME %5u][eNB][NETLINK][IP->PDCP] INST %d: Received socket with length %d (nlmsg_len = %zu) on Rab %d \n",
611 612 613 614 615
                      ctxt.frame,
                      pdcp_read_header_g.inst,
                      len,
                      nas_nlh_rx->nlmsg_len-sizeof(struct nlmsghdr),
                      pdcp_read_header_g.rb_id);
616 617
#endif

gauthier's avatar
gauthier committed
618 619 620 621 622
          	    MSC_LOG_RX_MESSAGE(
          	      (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE,
                  (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_IP_ENB:MSC_IP_UE,
          	      NULL,
          	      0,
gauthier's avatar
gauthier committed
623
          	      MSC_AS_TIME_FMT" DATA-REQ inst %u rb %u rab %u size %u",
gauthier's avatar
gauthier committed
624 625 626 627 628
          	      MSC_AS_TIME_ARGS(ctxt_pP),
                  pdcp_read_header_g.inst,
          	      pdcp_read_header_g.rb_id,
          	      rab_id,
          	      pdcp_read_header_g.data_size);
629
                LOG_D(PDCP, "[FRAME %5u][eNB][IP][INSTANCE %u][RB %u][--- PDCP_DATA_REQ / %d Bytes --->][PDCP][MOD %u]UE %u][RB %u]\n",
630 631 632 633
                      ctxt_cpy.frame,
                      pdcp_read_header_g.inst,
                      pdcp_read_header_g.rb_id,
                      pdcp_read_header_g.data_size,
634 635
                      ctxt.module_id,
                      ctxt.rnti,
636 637 638 639 640 641 642 643 644 645 646
                      rab_id);

                pdcp_data_req(&ctxt,
                              SRB_FLAG_NO,
                              rab_id,
                              RLC_MUI_UNDEFINED,
                              RLC_SDU_CONFIRM_NO,
                              pdcp_read_header_g.data_size,
                              (unsigned char *)NLMSG_DATA(nas_nlh_rx),
                              PDCP_TRANSMISSION_MODE_DATA);
              } else {
647
                LOG_D(PDCP, "[FRAME %5u][eNB][IP][INSTANCE %u][RB %u][--- PDCP_DATA_REQ / %d Bytes ---X][PDCP][MOD %u][UE %u][RB %u] NON INSTANCIATED INSTANCE, DROPPED\n",
648 649 650 651
                      ctxt.frame,
                      pdcp_read_header_g.inst,
                      pdcp_read_header_g.rb_id,
                      pdcp_read_header_g.data_size,
652 653
                      ctxt.module_id,
                      ctxt.rnti,
654 655 656 657
                      rab_id);
              }
            } else  { // rb_id =0, thus interpreated as broadcast and transported as multiple unicast
              // is a broadcast packet, we have to send this packet on all default RABS of all connected UEs
Cedric Roux's avatar
Cedric Roux committed
658
//#warning CODE TO BE REVIEWED, ONLY WORK FOR SIMPLE TOPOLOGY CASES
659 660 661 662
              for (ue_id = 0; ue_id < NB_UE_INST; ue_id++) {
                if (oai_emulation.info.eNB_ue_module_id_to_rnti[ctxt_cpy.module_id][ue_id] != NOT_A_RNTI) {
                  ctxt.rnti = oai_emulation.info.eNB_ue_module_id_to_rnti[ctxt_cpy.module_id][ue_id];
                  LOG_D(PDCP, "[FRAME %5u][eNB][IP][INSTANCE %u][RB %u][--- PDCP_DATA_REQ / %d Bytes --->][PDCP][MOD %u][UE %u][RB DEFAULT_RAB_ID %u]\n",
663 664 665 666
                        ctxt.frame,
                        pdcp_read_header_g.inst,
                        pdcp_read_header_g.rb_id,
                        pdcp_read_header_g.data_size,
667 668
                        ctxt.module_id,
                        ctxt.rnti,
669 670 671 672 673 674 675 676 677 678 679 680 681
                        DEFAULT_RAB_ID);
                  pdcp_data_req (
                    &ctxt,
                    SRB_FLAG_NO,
                    DEFAULT_RAB_ID,
                    RLC_MUI_UNDEFINED,
                    RLC_SDU_CONFIRM_NO,
                    pdcp_read_header_g.data_size,
                    (unsigned char *)NLMSG_DATA(nas_nlh_rx),
                    PDCP_TRANSMISSION_MODE_DATA);
                }
              }
            }
682
          } else { // enb_flag
683
            if (rab_id != 0) {
684
              if (rab_id == UE_IP_DEFAULT_RAB_ID) {
685
                LOG_I(PDCP, "PDCP_COLL_KEY_DEFAULT_DRB_VALUE(module_id=%d, rnti=%x, enb_flag=%d)\n",
686 687 688
                    ctxt.module_id, ctxt.rnti, ctxt.enb_flag);
                key = PDCP_COLL_KEY_DEFAULT_DRB_VALUE(ctxt.module_id, ctxt.rnti, ctxt.enb_flag);
                h_rc = hashtable_get(pdcp_coll_p, key, (void**)&pdcp_p);
689
              } else {
690
                rab_id = rab_id % maxDRB;
691
                LOG_I(PDCP, "PDCP_COLL_KEY_VALUE(module_id=%d, rnti=%x, enb_flag=%d, rab_id=%d, SRB_FLAG=%d)\n",
692 693 694 695
                    ctxt.module_id, ctxt.rnti, ctxt.enb_flag, rab_id, SRB_FLAG_NO);
                key = PDCP_COLL_KEY_VALUE(ctxt.module_id, ctxt.rnti, ctxt.enb_flag, rab_id, SRB_FLAG_NO);
                h_rc = hashtable_get(pdcp_coll_p, key, (void**)&pdcp_p);
              }
696 697

              if (h_rc == HASH_TABLE_OK) {
698
                rab_id = pdcp_p->rb_id;
699
#ifdef PDCP_DEBUG
700
                LOG_I(PDCP, "[FRAME %5u][UE][NETLINK][IP->PDCP] INST %d: Received socket with length %d (nlmsg_len = %zu) on Rab %d \n",
701 702 703 704 705
                      ctxt.frame,
                      pdcp_read_header_g.inst,
                      len,
                      nas_nlh_rx->nlmsg_len-sizeof(struct nlmsghdr),
                      pdcp_read_header_g.rb_id);
706

707
                LOG_I(PDCP, "[FRAME %5u][UE][IP][INSTANCE %u][RB %u][--- PDCP_DATA_REQ / %d Bytes --->][PDCP][MOD %u][UE %u][RB %u]\n",
708 709 710 711
                      ctxt.frame,
                      pdcp_read_header_g.inst,
                      pdcp_read_header_g.rb_id,
                      pdcp_read_header_g.data_size,
712 713
                      ctxt.module_id,
                      ctxt.rnti,
714 715
                      rab_id);
#endif
gauthier's avatar
gauthier committed
716 717 718 719 720
          	    MSC_LOG_RX_MESSAGE(
          	      (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE,
                  (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_IP_ENB:MSC_IP_UE,
          	      NULL,
          	      0,
gauthier's avatar
gauthier committed
721
          	      MSC_AS_TIME_FMT" DATA-REQ inst %u rb %u rab %u size %u",
gauthier's avatar
gauthier committed
722 723 724 725 726
          	      MSC_AS_TIME_ARGS(ctxt_pP),
                  pdcp_read_header_g.inst,
          	      pdcp_read_header_g.rb_id,
          	      rab_id,
          	      pdcp_read_header_g.data_size);
727

728 729 730 731 732 733 734 735 736 737
                pdcp_data_req(
                  &ctxt,
                  SRB_FLAG_NO,
                  rab_id,
                  RLC_MUI_UNDEFINED,
                  RLC_SDU_CONFIRM_NO,
                  pdcp_read_header_g.data_size,
                  (unsigned char *)NLMSG_DATA(nas_nlh_rx),
                  PDCP_TRANSMISSION_MODE_DATA);
              } else {
gauthier's avatar
gauthier committed
738 739 740 741 742
            	MSC_LOG_RX_DISCARDED_MESSAGE(
                  (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE,
                  (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_IP_ENB:MSC_IP_UE,
                  NULL,
                  0,
gauthier's avatar
gauthier committed
743
                  MSC_AS_TIME_FMT" DATA-REQ inst %u rb %u rab %u size %u",
gauthier's avatar
gauthier committed
744 745 746 747 748
                  MSC_AS_TIME_ARGS(ctxt_pP),
                  pdcp_read_header_g.inst,
                  pdcp_read_header_g.rb_id,
                  rab_id,
                  pdcp_read_header_g.data_size);
749 750
                LOG_D(PDCP,
                      "[FRAME %5u][UE][IP][INSTANCE %u][RB %u][--- PDCP_DATA_REQ / %d Bytes ---X][PDCP][MOD %u][UE %u][RB %u] NON INSTANCIATED INSTANCE key 0x%"PRIx64", DROPPED\n",
751 752 753 754
                      ctxt.frame,
                      pdcp_read_header_g.inst,
                      pdcp_read_header_g.rb_id,
                      pdcp_read_header_g.data_size,
755 756 757 758
                      ctxt.module_id,
                      ctxt.rnti,
                      rab_id,
                      key);
759
              }
760 761
            }  else {
              LOG_D(PDCP, "Forcing send on DEFAULT_RAB_ID\n");
762
              LOG_D(PDCP, "[FRAME %5u][eNB][IP][INSTANCE %u][RB %u][--- PDCP_DATA_REQ / %d Bytes --->][PDCP][MOD %u][UE %u][RB DEFAULT_RAB_ID %u]\n",
763 764 765 766
                    ctxt.frame,
                    pdcp_read_header_g.inst,
                    pdcp_read_header_g.rb_id,
                    pdcp_read_header_g.data_size,
767 768
                    ctxt.module_id,
                    ctxt.rnti,
769
                    DEFAULT_RAB_ID);
gauthier's avatar
gauthier committed
770 771 772 773
          	  MSC_LOG_RX_MESSAGE(
                (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE,
                (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_IP_ENB:MSC_IP_UE,
                NULL,0,
gauthier's avatar
gauthier committed
774
                MSC_AS_TIME_FMT" DATA-REQ inst %u rb %u default rab %u size %u",
gauthier's avatar
gauthier committed
775 776 777 778 779 780
                MSC_AS_TIME_ARGS(ctxt_pP),
                pdcp_read_header_g.inst,
                pdcp_read_header_g.rb_id,
                DEFAULT_RAB_ID,
                pdcp_read_header_g.data_size);

781 782 783 784 785 786 787 788 789 790
              pdcp_data_req (
                &ctxt,
                SRB_FLAG_NO,
                DEFAULT_RAB_ID,
                RLC_MUI_UNDEFINED,
                RLC_SDU_CONFIRM_NO,
                pdcp_read_header_g.data_size,
                (unsigned char *)NLMSG_DATA(nas_nlh_rx),
                PDCP_TRANSMISSION_MODE_DATA);
            }
791
          }
792 793

        }
794
      }
795
    }
796
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ, 0 );
797
  }
798

799
  return len;
800
# endif
801
#else // neither PDCP_USE_NETLINK nor PDCP_USE_RT_FIFO
802
  return 0;
803
#endif // PDCP_USE_NETLINK
804 805 806
}


807 808
void pdcp_fifo_read_input_sdus_from_otg (const protocol_ctxt_t* const  ctxt_pP) {

809 810 811
  unsigned char       *otg_pkt=NULL;
  module_id_t          dst_id; // dst for otg
  rb_id_t              rb_id;
812
  unsigned int         pkt_size=0;
813
#if defined(USER_MODE) && defined(OAI_EMU)
814
  module_id_t          src_id;
815
  static unsigned int  pkt_cnt_enb=0, pkt_cnt_ue=0;
816

817 818
  Packet_otg_elt_t    *otg_pkt_info=NULL;
  int                  result;
819 820 821 822 823
  uint8_t              pdcp_mode, is_ue=0;
#endif
  protocol_ctxt_t      ctxt;
  // we need to add conditions to avoid transmitting data when the UE is not RRC connected.
#if defined(USER_MODE) && defined(OAI_EMU)
824

825
  if (oai_emulation.info.otg_enabled ==1 ) {
826 827 828 829 830 831 832 833 834
    // module_id is source id
    while ((otg_pkt_info = pkt_list_remove_head(&(otg_pdcp_buffer[ctxt_pP->instance]))) != NULL) {
      LOG_I(OTG,"Mod_id %d Frame %d Got a packet (%p), HEAD of otg_pdcp_buffer[%d] is %p and Nb elements is %d\n",
            ctxt_pP->module_id,
            ctxt_pP->frame,
            otg_pkt_info,
            ctxt_pP->instance,
            pkt_list_get_head(&(otg_pdcp_buffer[ctxt_pP->instance])),
            otg_pdcp_buffer[ctxt_pP->instance].nb_elements);
835
      //otg_pkt_info = pkt_list_remove_head(&(otg_pdcp_buffer[module_id]));
836 837
      dst_id    = (otg_pkt_info->otg_pkt).dst_id; // type is module_id_t
      src_id    = (otg_pkt_info->otg_pkt).module_id; // type is module_id_t
838 839 840 841 842 843 844 845 846 847 848 849
      rb_id     = (otg_pkt_info->otg_pkt).rb_id;
      is_ue     = (otg_pkt_info->otg_pkt).is_ue;
      pdcp_mode = (otg_pkt_info->otg_pkt).mode;
      //    LOG_I(PDCP,"pdcp_fifo, pdcp mode is= %d\n",pdcp_mode);

      // generate traffic if the ue is rrc reconfigured state
      // if (mac_get_rrc_status(module_id, ctxt_pP->enb_flag, dst_id ) > 2 /*RRC_CONNECTED*/) { // not needed: this test is already done in update_otg_enb
      otg_pkt = (unsigned char*) (otg_pkt_info->otg_pkt).sdu_buffer;
      pkt_size = (otg_pkt_info->otg_pkt).sdu_buffer_size;

      if (otg_pkt != NULL) {
        if (is_ue == 0 ) {
850 851 852 853 854 855
          PROTOCOL_CTXT_SET_BY_MODULE_ID(
            &ctxt,
            src_id,
            ENB_FLAG_YES,
            oai_emulation.info.eNB_ue_module_id_to_rnti[ctxt.module_id][dst_id],
            ctxt_pP->frame,
856 857
            ctxt_pP->subframe,
	    src_id);
858

859
          LOG_D(OTG,"[eNB %d] Frame %d sending packet %d from module %d on rab id %d (src %d, dst %d/%x) pkt size %d for pdcp mode %d\n",
860 861 862 863 864 865 866
                ctxt.module_id,
                ctxt.frame,
                pkt_cnt_enb++,
                src_id,
                rb_id,
                src_id,
                dst_id,
867
		oai_emulation.info.eNB_ue_module_id_to_rnti[ctxt.module_id][dst_id],
868 869
                pkt_size,
                pdcp_mode);
870 871 872 873 874 875 876 877
          result = pdcp_data_req(&ctxt,
                                 SRB_FLAG_NO,
                                 rb_id,
                                 RLC_MUI_UNDEFINED,
                                 RLC_SDU_CONFIRM_NO,
                                 pkt_size,
                                 otg_pkt,
                                 pdcp_mode);
878 879 880
          if (result != TRUE) {
            LOG_W(OTG,"PDCP data request failed!\n");
          }
881 882 883 884
        } else {
          //rb_id= eNB_index * MAX_NUM_RB + DTCH;


885
          LOG_D(OTG,"[UE %d] Frame %d: sending packet %d from module %d on rab id %d (src %d/%x, dst %d) pkt size %d\n",
886 887 888 889 890
                ctxt_pP->module_id,
                ctxt_pP->frame,
                pkt_cnt_ue++,
                ctxt_pP->module_id,
                rb_id,
891 892
                src_id,
		pdcp_UE_UE_module_id_to_rnti[ctxt_pP->module_id], // [src_id]
893 894 895 896
                dst_id,
                pkt_size);
          PROTOCOL_CTXT_SET_BY_MODULE_ID(
            &ctxt,
897
            ctxt_pP->module_id, //src_id,
898
            ENB_FLAG_NO,
899
            pdcp_UE_UE_module_id_to_rnti[ctxt_pP->module_id],// [src_id]
900
            ctxt_pP->frame,
901 902
            ctxt_pP->subframe,
	    dst_id);
903 904 905 906 907 908 909 910 911

          result = pdcp_data_req( &ctxt,
                                  SRB_FLAG_NO,
                                  rb_id,
                                  RLC_MUI_UNDEFINED,
                                  RLC_SDU_CONFIRM_NO,
                                  pkt_size,
                                  otg_pkt,
                                  PDCP_TRANSMISSION_MODE_DATA);
912 913 914
          if (result != TRUE) {
            LOG_W(OTG,"PDCP data request failed!\n");
          }
915 916 917 918
        }

        free(otg_pkt);
        otg_pkt = NULL;
919
      }
920 921 922 923

      // } //else LOG_D(OTG,"ctxt_pP->frame %d enb %d-> ue %d link not yet established state %d  \n", ctxt_pP->frame, eNB_index,dst_id - NB_eNB_INST, mac_get_rrc_status(module_id, ctxt_pP->enb_flag, dst_id - NB_eNB_INST));

    }
924
  }
925

926
#else
927

928
  if ((otg_enabled==1) && (ctxt_pP->enb_flag == ENB_FLAG_YES)) { // generate DL traffic
929 930 931 932 933
    unsigned int ctime=0;
    ctime = ctxt_pP->frame * 100;

    /*if  ((mac_get_rrc_status(eNB_index, ctxt_pP->enb_flag, 0 ) > 2) &&
    (mac_get_rrc_status(eNB_index, ctxt_pP->enb_flag, 1 ) > 2)) { */
934 935 936 937 938 939
    PROTOCOL_CTXT_SET_BY_MODULE_ID(
      &ctxt,
      ctxt_pP->module_id,
      ctxt_pP->enb_flag,
      NOT_A_RNTI,
      ctxt_pP->frame,
940 941
      ctxt_pP->subframe,
      ctxt_pP->module_id);
942 943

    for (dst_id = 0; dst_id<NUMBER_OF_UE_MAX; dst_id++) {
944 945 946 947
      ctxt.rnti = oai_emulation.info.eNB_ue_module_id_to_rnti[ctxt.module_id][dst_id];

      if (ctxt.rnti != NOT_A_RNTI) {
        if (mac_eNB_get_rrc_status(ctxt.module_id, ctxt.rnti ) > 2 /*RRC_SI_RECEIVED*/) {
948
        unsigned int temp = 0;
949 950 951 952 953 954
          otg_pkt=packet_gen(
                    ENB_MODULE_ID_TO_INSTANCE(ctxt.module_id),
                    UE_MODULE_ID_TO_INSTANCE(dst_id),
                    0,
                    ctime,
                    &temp);
955 956 957 958 959 960 961 962 963 964 965 966
        pkt_size = temp;

        if (otg_pkt != NULL) {
          rb_id = dst_id * maxDRB + DTCH;
          pdcp_data_req(&ctxt,
                        SRB_FLAG_NO,
                        rb_id,
                        RLC_MUI_UNDEFINED,
                        RLC_SDU_CONFIRM_NO,
                        pkt_size,
                        otg_pkt,
                        PDCP_TRANSMISSION_MODE_DATA);
967 968 969 970 971
            LOG_I(OTG,
                  "send packet from module %d on rab id %d (src %d, dst %d) pkt size %d\n",
                  ctxt_pP->module_id, rb_id, ctxt_pP->module_id, dst_id, pkt_size);
            free(otg_pkt);
          }
972
        }
973
      }
974
    }
975
  }
976

977 978
#endif
}