minimal pdcp: initial commit

traffic goes through, no security, no integrity verification
no reestablishment

cmake_targets/CMakeLists.txt

@@ -1372,13 +1372,18 @@ set(RRC_DIR ${OPENAIR2_DIR}/RRC/LTE)
 set(PDCP_DIR  ${OPENAIR2_DIR}/LAYER2/PDCP_v10.1.0)
 set(L2_SRC
   ${OPENAIR2_DIR}/LAYER2/openair2_proc.c
-  ${PDCP_DIR}/pdcp.c
-  ${PDCP_DIR}/pdcp_fifo.c
-  ${PDCP_DIR}/pdcp_sequence_manager.c
-  ${PDCP_DIR}/pdcp_primitives.c
-  ${PDCP_DIR}/pdcp_util.c
-  ${PDCP_DIR}/pdcp_security.c
-  ${PDCP_DIR}/pdcp_netlink.c
+#  ${PDCP_DIR}/pdcp.c
+#  ${PDCP_DIR}/pdcp_fifo.c
+#  ${PDCP_DIR}/pdcp_sequence_manager.c
+#  ${PDCP_DIR}/pdcp_primitives.c
+#  ${PDCP_DIR}/pdcp_util.c
+#  ${PDCP_DIR}/pdcp_security.c
+#  ${PDCP_DIR}/pdcp_netlink.c
+  ${OPENAIR2_DIR}/LAYER2/pdcp_v2/pdcp_oai_api.c
+  ${OPENAIR2_DIR}/LAYER2/pdcp_v2/pdcp_ue_manager.c
+  ${OPENAIR2_DIR}/LAYER2/pdcp_v2/pdcp_entity.c
+  ${OPENAIR2_DIR}/LAYER2/pdcp_v2/pdcp_entity_srb.c
+  ${OPENAIR2_DIR}/LAYER2/pdcp_v2/pdcp_entity_drb_am.c
   ${RLC_V2}
 #  ${RRC_DIR}/rrc_UE.c
   ${RRC_DIR}/rrc_eNB.c

openair2/LAYER2/pdcp_v2/pdcp_entity.c

+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#include "pdcp_entity.h"
+
+#include "pdcp_entity_srb.h"
+#include "pdcp_entity_drb_am.h"
+
+#include "LOG/log.h"
+
+pdcp_entity_t *new_pdcp_entity_srb(
+    int rb_id,
+    void (*deliver_sdu)(void *deliver_sdu_data, struct pdcp_entity_t *entity,
+                        char *buf, int size),
+    void *deliver_sdu_data,
+    void (*deliver_pdu)(void *deliver_pdu_data, struct pdcp_entity_t *entity,
+                        char *buf, int size, int sdu_id),
+    void *deliver_pdu_data)
+{
+  pdcp_entity_srb_t *ret;
+
+  ret = calloc(1, sizeof(pdcp_entity_srb_t));
+  if (ret == NULL) {
+    LOG_E(PDCP, "%s:%d:%s: out of memory\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  ret->common.recv_pdu          = pdcp_entity_srb_recv_pdu;
+  ret->common.recv_sdu          = pdcp_entity_srb_recv_sdu;
+  ret->common.set_integrity_key = pdcp_entity_srb_set_integrity_key;
+
+  ret->common.delete = pdcp_entity_srb_delete;
+
+  ret->common.deliver_sdu = deliver_sdu;
+  ret->common.deliver_sdu_data = deliver_sdu_data;
+
+  ret->common.deliver_pdu = deliver_pdu;
+  ret->common.deliver_pdu_data = deliver_pdu_data;
+
+  ret->rb_id = rb_id;
+
+  ret->common.maximum_pdcp_sn = 31;
+
+  return (pdcp_entity_t *)ret;
+
+#if 0
+  ret->common.recv_pdu      = rlc_entity_am_recv_pdu;
+  ret->common.buffer_status = rlc_entity_am_buffer_status;
+  ret->common.generate_pdu  = rlc_entity_am_generate_pdu;
+
+  ret->common.recv_sdu         = rlc_entity_am_recv_sdu;
+
+  ret->common.set_time = rlc_entity_am_set_time;
+
+  ret->common.discard_sdu = rlc_entity_am_discard_sdu;
+
+  ret->common.reestablishment = rlc_entity_am_reestablishment;
+
+  ret->common.delete = rlc_entity_am_delete;
+
+  ret->common.deliver_sdu      = deliver_sdu;
+  ret->common.deliver_sdu_data = deliver_sdu_data;
+
+  ret->common.sdu_successful_delivery      = sdu_successful_delivery;
+  ret->common.sdu_successful_delivery_data = sdu_successful_delivery_data;
+
+  ret->common.max_retx_reached      = max_retx_reached;
+  ret->common.max_retx_reached_data = max_retx_reached_data;
+
+  ret->rx_maxsize         = rx_maxsize;
+  ret->tx_maxsize         = tx_maxsize;
+  ret->t_reordering       = t_reordering;
+  ret->t_status_prohibit  = t_status_prohibit;
+  ret->t_poll_retransmit  = t_poll_retransmit;
+  ret->poll_pdu           = poll_pdu;
+  ret->poll_byte          = poll_byte;
+  ret->max_retx_threshold = max_retx_threshold;
+
+  return (rlc_entity_t *)ret;
+#endif
+}
+
+pdcp_entity_t *new_pdcp_entity_drb_am(
+    int rb_id,
+    void (*deliver_sdu)(void *deliver_sdu_data, struct pdcp_entity_t *entity,
+                        char *buf, int size),
+    void *deliver_sdu_data,
+    void (*deliver_pdu)(void *deliver_pdu_data, struct pdcp_entity_t *entity,
+                        char *buf, int size, int sdu_id),
+    void *deliver_pdu_data)
+{
+  pdcp_entity_drb_am_t *ret;
+
+  ret = calloc(1, sizeof(pdcp_entity_drb_am_t));
+  if (ret == NULL) {
+    LOG_E(PDCP, "%s:%d:%s: out of memory\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  ret->common.recv_pdu          = pdcp_entity_drb_am_recv_pdu;
+  ret->common.recv_sdu          = pdcp_entity_drb_am_recv_sdu;
+  ret->common.set_integrity_key = pdcp_entity_drb_am_set_integrity_key;
+
+  ret->common.delete = pdcp_entity_drb_am_delete;
+
+  ret->common.deliver_sdu = deliver_sdu;
+  ret->common.deliver_sdu_data = deliver_sdu_data;
+
+  ret->common.deliver_pdu = deliver_pdu;
+  ret->common.deliver_pdu_data = deliver_pdu_data;
+
+  ret->rb_id = rb_id;
+
+  ret->common.maximum_pdcp_sn = 4095;
+
+  return (pdcp_entity_t *)ret;
+}

openair2/LAYER2/pdcp_v2/pdcp_entity.h

+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#ifndef _PDCP_ENTITY_H_
+#define _PDCP_ENTITY_H_
+
+typedef struct pdcp_entity_t {
+  /* functions provided by the PDCP module */
+  void (*recv_pdu)(struct pdcp_entity_t *entity, char *buffer, int size);
+  void (*recv_sdu)(struct pdcp_entity_t *entity, char *buffer, int size,
+                   int sdu_id);
+  void (*delete)(struct pdcp_entity_t *entity);
+  void (*set_integrity_key)(struct pdcp_entity_t *entity, char *key);
+
+  /* callbacks provided to the PDCP module */
+  void (*deliver_sdu)(void *deliver_sdu_data, struct pdcp_entity_t *entity,
+                      char *buf, int size);
+  void *deliver_sdu_data;
+  void (*deliver_pdu)(void *deliver_pdu_data, struct pdcp_entity_t *entity,
+                      char *buf, int size, int sdu_id);
+  void *deliver_pdu_data;
+  int tx_hfn;
+  int next_pdcp_tx_sn;
+  int maximum_pdcp_sn;
+} pdcp_entity_t;
+
+pdcp_entity_t *new_pdcp_entity_srb(
+    int rb_id,
+    void (*deliver_sdu)(void *deliver_sdu_data, struct pdcp_entity_t *entity,
+                        char *buf, int size),
+    void *deliver_sdu_data,
+    void (*deliver_pdu)(void *deliver_pdu_data, struct pdcp_entity_t *entity,
+                        char *buf, int size, int sdu_id),
+    void *deliver_pdu_data);
+
+pdcp_entity_t *new_pdcp_entity_drb_am(
+    int rb_id,
+    void (*deliver_sdu)(void *deliver_sdu_data, struct pdcp_entity_t *entity,
+                        char *buf, int size),
+    void *deliver_sdu_data,
+    void (*deliver_pdu)(void *deliver_pdu_data, struct pdcp_entity_t *entity,
+                        char *buf, int size, int sdu_id),
+    void *deliver_pdu_data);
+
+#endif /* _PDCP_ENTITY_H_ */

openair2/LAYER2/pdcp_v2/pdcp_entity_drb_am.c

+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#include "pdcp_entity_drb_am.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void pdcp_entity_drb_am_recv_pdu(pdcp_entity_t *_entity, char *buffer, int size)
+{
+  pdcp_entity_drb_am_t *entity = (pdcp_entity_drb_am_t *)_entity;
+
+  if (size < 3) abort();
+  if (!(buffer[0] & 0x80)) { printf("%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__); exit(1); }
+  entity->common.deliver_sdu(entity->common.deliver_sdu_data,
+                             (pdcp_entity_t *)entity, buffer+2, size-2);
+}
+
+void pdcp_entity_drb_am_recv_sdu(pdcp_entity_t *_entity, char *buffer, int size,
+                              int sdu_id)
+{
+  pdcp_entity_drb_am_t *entity = (pdcp_entity_drb_am_t *)_entity;
+  int sn;
+  char buf[size+2];
+
+  sn = entity->common.next_pdcp_tx_sn;
+
+  entity->common.next_pdcp_tx_sn++;
+  if (entity->common.next_pdcp_tx_sn > entity->common.maximum_pdcp_sn) {
+    entity->common.next_pdcp_tx_sn = 0;
+    entity->common.tx_hfn++;
+  }
+
+  buf[0] = 0x80 | ((sn >> 8) & 0x0f);
+  buf[1] = sn & 0xff;
+  memcpy(buf+2, buffer, size);
+
+  entity->common.deliver_pdu(entity->common.deliver_pdu_data,
+                             (pdcp_entity_t *)entity, buf, size+2, sdu_id);
+}
+
+void pdcp_entity_drb_am_set_integrity_key(pdcp_entity_t *_entity, char *key)
+{
+  /* nothing to do */
+}
+
+void pdcp_entity_drb_am_delete(pdcp_entity_t *_entity)
+{
+  pdcp_entity_drb_am_t *entity = (pdcp_entity_drb_am_t *)_entity;
+  free(entity);
+}

openair2/LAYER2/pdcp_v2/pdcp_entity_drb_am.h

+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#ifndef _PDCP_ENTITY_DRB_AM_H_
+#define _PDCP_ENTITY_DRB_AM_H_
+
+#include "pdcp_entity.h"
+
+typedef struct {
+  pdcp_entity_t common;
+  int rb_id;
+} pdcp_entity_drb_am_t;
+
+void pdcp_entity_drb_am_recv_pdu(pdcp_entity_t *entity, char *buffer, int size);
+void pdcp_entity_drb_am_recv_sdu(pdcp_entity_t *entity, char *buffer, int size,
+                                 int sdu_id);
+void pdcp_entity_drb_am_set_integrity_key(pdcp_entity_t *entity, char *key);
+void pdcp_entity_drb_am_delete(pdcp_entity_t *entity);
+
+#endif /* _PDCP_ENTITY_DRB_AM_H_ */

openair2/LAYER2/pdcp_v2/pdcp_entity_srb.c

+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#include "pdcp_entity_srb.h"
+
+#include <stdlib.h>
+
+void pdcp_entity_srb_recv_pdu(pdcp_entity_t *_entity, char *buffer, int size)
+{
+  pdcp_entity_srb_t *entity = (pdcp_entity_srb_t *)_entity;
+
+  entity->common.deliver_sdu(entity->common.deliver_sdu_data,
+                             (pdcp_entity_t *)entity, buffer+1, size-5);
+}
+
+#include <string.h>
+#include <stdint.h>
+#include "UTIL/OSA/osa_defs.h"
+
+void pdcp_entity_srb_recv_sdu(pdcp_entity_t *_entity, char *buffer, int size,
+                              int sdu_id)
+{
+  pdcp_entity_srb_t *entity = (pdcp_entity_srb_t *)_entity;
+  int sn;
+  char buf[size+5];
+
+  sn = entity->common.next_pdcp_tx_sn;
+
+  entity->common.next_pdcp_tx_sn++;
+  if (entity->common.next_pdcp_tx_sn > entity->common.maximum_pdcp_sn) {
+    entity->common.next_pdcp_tx_sn = 0;
+    entity->common.tx_hfn++;
+  }
+
+  buf[0] = sn & 0x1f;
+  memcpy(buf+1, buffer, size);
+
+  if (entity->integrity_active) {
+    stream_cipher_t params;
+    params.message = (unsigned char *)buf;
+    params.blength = (size + 1) << 3;
+    params.key = (unsigned char *)entity->key_integrity + 16;
+    params.key_length = 16;
+    params.count = (entity->common.tx_hfn << 5) | sn;
+    params.bearer = entity->rb_id - 1;
+    params.direction = SECU_DIRECTION_DOWNLINK;
+printf("call stream_compute_integrity\n");
+    stream_compute_integrity(EIA2_128_ALG_ID, &params,
+                             (unsigned char *)&buf[size+1]);
+  } else {
+printf("no integrity\n");
+    buf[size+1] = 0;
+    buf[size+2] = 0;
+    buf[size+3] = 0;
+    buf[size+4] = 0;
+  }
+
+  entity->common.deliver_pdu(entity->common.deliver_pdu_data,
+                             (pdcp_entity_t *)entity, buf, size+5, sdu_id);
+}
+
+void pdcp_entity_srb_set_integrity_key(pdcp_entity_t *_entity, char *key)
+{
+printf("activate integrity\n");
+  pdcp_entity_srb_t *entity = (pdcp_entity_srb_t *)_entity;
+
+  memcpy(entity->key_integrity, key, 32);
+  entity->integrity_active = 1;
+}
+
+void pdcp_entity_srb_delete(pdcp_entity_t *_entity)
+{
+  pdcp_entity_srb_t *entity = (pdcp_entity_srb_t *)_entity;
+  free(entity);
+}

openair2/LAYER2/pdcp_v2/pdcp_entity_srb.h

+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#ifndef _PDCP_ENTITY_SRB_H_
+#define _PDCP_ENTITY_SRB_H_
+
+#include "pdcp_entity.h"
+
+typedef struct {
+  pdcp_entity_t common;
+  int rb_id;
+  char key_integrity[32];
+  int integrity_active;
+} pdcp_entity_srb_t;
+
+void pdcp_entity_srb_recv_pdu(pdcp_entity_t *entity, char *buffer, int size);
+void pdcp_entity_srb_recv_sdu(pdcp_entity_t *entity, char *buffer, int size,
+                              int sdu_id);
+void pdcp_entity_srb_set_integrity_key(pdcp_entity_t *entity, char *key);
+void pdcp_entity_srb_delete(pdcp_entity_t *entity);
+
+#endif /* _PDCP_ENTITY_SRB_H_ */

openair2/LAYER2/pdcp_v2/pdcp_ue_manager.c

+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#include "pdcp_ue_manager.h"
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "LOG/log.h"
+
+typedef struct {
+  pthread_mutex_t lock;
+  pdcp_ue_t        **ue_list;
+  int             ue_count;
+  int             enb_flag;
+} pdcp_ue_manager_internal_t;
+
+pdcp_ue_manager_t *new_pdcp_ue_manager(int enb_flag)
+{
+  pdcp_ue_manager_internal_t *ret;
+
+  ret = calloc(1, sizeof(pdcp_ue_manager_internal_t));
+  if (ret == NULL) {
+    LOG_E(PDCP, "%s:%d:%s: out of memory\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  if (pthread_mutex_init(&ret->lock, NULL)) abort();
+  ret->enb_flag = enb_flag;
+
+  return ret;
+}
+
+int pdcp_manager_get_enb_flag(pdcp_ue_manager_t *_m)
+{
+  pdcp_ue_manager_internal_t *m = _m;
+  return m->enb_flag;
+}
+
+void pdcp_manager_lock(pdcp_ue_manager_t *_m)
+{
+  pdcp_ue_manager_internal_t *m = _m;
+  if (pthread_mutex_lock(&m->lock)) {
+    LOG_E(PDCP, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+}
+
+void pdcp_manager_unlock(pdcp_ue_manager_t *_m)
+{
+  pdcp_ue_manager_internal_t *m = _m;
+  if (pthread_mutex_unlock(&m->lock)) {
+    LOG_E(PDCP, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+}
+
+/* must be called with lock acquired */
+pdcp_ue_t *pdcp_manager_get_ue(pdcp_ue_manager_t *_m, int rnti)
+{
+  /* TODO: optimze */
+  pdcp_ue_manager_internal_t *m = _m;
+  int i;
+
+  for (i = 0; i < m->ue_count; i++)
+    if (m->ue_list[i]->rnti == rnti)
+      return m->ue_list[i];
+
+  LOG_D(PDCP, "%s:%d:%s: new UE %d\n", __FILE__, __LINE__, __FUNCTION__, rnti);
+
+  m->ue_count++;
+  m->ue_list = realloc(m->ue_list, sizeof(pdcp_ue_t *) * m->ue_count);
+  if (m->ue_list == NULL) {
+    LOG_E(PDCP, "%s:%d:%s: out of memory\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+  m->ue_list[m->ue_count-1] = calloc(1, sizeof(pdcp_ue_t));
+  if (m->ue_list[m->ue_count-1] == NULL) {
+    LOG_E(PDCP, "%s:%d:%s: out of memory\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  m->ue_list[m->ue_count-1]->rnti = rnti;
+
+  return m->ue_list[m->ue_count-1];
+}
+
+/* must be called with lock acquired */
+void pdcp_manager_remove_ue(pdcp_ue_manager_t *_m, int rnti)
+{
+  pdcp_ue_manager_internal_t *m = _m;
+  pdcp_ue_t *ue;
+  int i;
+  int j;
+
+  for (i = 0; i < m->ue_count; i++)
+    if (m->ue_list[i]->rnti == rnti)
+      break;
+
+  if (i == m->ue_count) {
+    LOG_D(PDCP, "%s:%d:%s: warning: ue %d not found\n",
+          __FILE__, __LINE__, __FUNCTION__,
+          rnti);
+    return;
+  }
+
+  ue = m->ue_list[i];
+
+  for (j = 0; j < 2; j++)
+    if (ue->srb[j] != NULL)
+      ue->srb[j]->delete(ue->srb[j]);
+
+  for (j = 0; j < 5; j++)
+    if (ue->drb[j] != NULL)
+      ue->drb[j]->delete(ue->drb[j]);
+
+  free(ue);
+
+  m->ue_count--;
+  if (m->ue_count == 0) {
+    free(m->ue_list);
+    m->ue_list = NULL;
+    return;
+  }
+
+  memmove(&m->ue_list[i], &m->ue_list[i+1],
+          (m->ue_count - i) * sizeof(pdcp_ue_t *));
+  m->ue_list = realloc(m->ue_list, m->ue_count * sizeof(pdcp_ue_t *));
+  if (m->ue_list == NULL) {
+    LOG_E(PDCP, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+}
+
+/* must be called with lock acquired */
+void pdcp_ue_add_srb_pdcp_entity(pdcp_ue_t *ue, int srb_id, pdcp_entity_t *entity)
+{
+  if (srb_id < 1 || srb_id > 2) {
+    LOG_E(PDCP, "%s:%d:%s: fatal, bad srb id\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  srb_id--;
+
+  if (ue->srb[srb_id] != NULL) {
+    LOG_E(PDCP, "%s:%d:%s: fatal, srb already present\n",
+          __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  ue->srb[srb_id] = entity;
+}
+
+/* must be called with lock acquired */
+void pdcp_ue_add_drb_pdcp_entity(pdcp_ue_t *ue, int drb_id, pdcp_entity_t *entity)
+{
+  if (drb_id < 1 || drb_id > 5) {
+    LOG_E(PDCP, "%s:%d:%s: fatal, bad drb id\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  drb_id--;
+
+  if (ue->drb[drb_id] != NULL) {
+    LOG_E(PDCP, "%s:%d:%s: fatal, drb already present\n",
+          __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  ue->drb[drb_id] = entity;
+}

openair2/LAYER2/pdcp_v2/pdcp_ue_manager.h

+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#ifndef _PDCP_UE_MANAGER_H_
+#define _PDCP_UE_MANAGER_H_
+
+#include "pdcp_entity.h"
+
+typedef void pdcp_ue_manager_t;
+
+typedef struct pdcp_ue_t {
+  int rnti;
+  pdcp_entity_t *srb[2];
+  pdcp_entity_t *drb[5];
+} pdcp_ue_t;
+
+/***********************************************************************/
+/* manager functions                                                   */
+/***********************************************************************/
+
+pdcp_ue_manager_t *new_pdcp_ue_manager(int enb_flag);
+
+int pdcp_manager_get_enb_flag(pdcp_ue_manager_t *m);
+
+void pdcp_manager_lock(pdcp_ue_manager_t *m);
+void pdcp_manager_unlock(pdcp_ue_manager_t *m);
+
+pdcp_ue_t *pdcp_manager_get_ue(pdcp_ue_manager_t *m, int rnti);
+void pdcp_manager_remove_ue(pdcp_ue_manager_t *m, int rnti);
+
+/***********************************************************************/
+/* ue functions                                                        */
+/***********************************************************************/
+
+void pdcp_ue_add_srb_pdcp_entity(pdcp_ue_t *ue, int srb_id,
+                                 pdcp_entity_t *entity);
+void pdcp_ue_add_drb_pdcp_entity(pdcp_ue_t *ue, int drb_id,
+                                 pdcp_entity_t *entity);
+
+#endif /* _PDCP_UE_MANAGER_H_ */

openair2/RRC/LTE/rrc_eNB_S1AP.c

@@ -561,7 +561,7 @@ rrc_pdcp_config_security(
   key = PDCP_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, DCCH, SRB_FLAG_YES);
   h_rc = hashtable_get(pdcp_coll_p, key, (void **)&pdcp_p);
 
-  if (h_rc == HASH_TABLE_OK) {
+  if (1 || h_rc == HASH_TABLE_OK) {
     pdcp_config_set_security(
       ctxt_pP,
       pdcp_p,