NR pdcp: Rebase initial implementation

Initially targeting ENDC setup with commercial UE
- Missing nr_rrc_pdcp and nr_rrc_rlc configuration wrt the established DRB
- Remaining to test with user plane data traffic (Downlink and Uplink)

cmake_targets/CMakeLists.txt

@@ -1668,6 +1668,16 @@ set(LTE_RLC_SRC
   ${RLC_DIR}/rlc_mpls.c
   )
 
+set(LTE_PDCP_SRC
+  ${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
+  )
+
 set(NR_RLC_SRC
   ${OPENAIR2_DIR}/LAYER2/nr_rlc/asn1_utils.c
   ${OPENAIR2_DIR}/LAYER2/nr_rlc/nr_rlc_entity.c
@@ -1679,16 +1689,16 @@ set(NR_RLC_SRC
   ${OPENAIR2_DIR}/LAYER2/nr_rlc/nr_rlc_sdu.c
   ${OPENAIR2_DIR}/LAYER2/nr_rlc/nr_rlc_ue_manager.c
   )
+  
+set(NR_PDCP_SRC
+  ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_oai_api.c
+  ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_ue_manager.c
+  ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_entity.c
+  ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_entity_drb_am.c
+  )
 
 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
 #  ${RRC_DIR}/rrc_UE.c
   ${RRC_DIR}/rrc_eNB.c
   ${RRC_DIR}/rrc_eNB_endc.c
@@ -1703,10 +1713,12 @@ set(L2_SRC
 
 set(L2_LTE_SRC
   ${LTE_RLC_SRC}
+  ${LTE_PDCP_SRC}
   )
 
 set(L2_NR_SRC
   ${NR_RLC_SRC}
+  ${NR_PDCP_SRC}
   ${NR_RRC_DIR}/rrc_gNB.c
   ${NR_RRC_DIR}/nr_rrc_common.c
   ${NR_RRC_DIR}/L2_nr_interface.c
@@ -1718,13 +1730,6 @@ set(L2_NR_SRC
   )
 
 set(L2_SRC_UE
-  ${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
   ${RRC_DIR}/rrc_UE.c
   ${RRC_DIR}/rrc_common.c
   ${RRC_DIR}/L2_interface_common.c
@@ -1740,10 +1745,12 @@ set(LTE_NR_L2_SRC_UE
   ${PDCP_DIR}/pdcp_security.c
   ${PDCP_DIR}/pdcp_netlink.c
   ${LTE_RLC_SRC}
+  ${LTE_PDCP_SRC}
   )
 
 set(NR_L2_SRC_UE
   ${NR_RLC_SRC}
+  ${NR_PDCP_SRC}
   ${NR_UE_RRC_DIR}/L2_interface_ue.c
   ${NR_UE_RRC_DIR}/main_ue.c
   ${NR_UE_RRC_DIR}/rrc_UE.c

openair2/LAYER2/nr_pdcp/nr_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 "nr_pdcp_entity.h"
+
+#include "nr_pdcp_entity_drb_am.h"
+
+#include "LOG/log.h"
+
+nr_pdcp_entity_t *new_nr_pdcp_entity_srb(
+    int rb_id,
+    void (*deliver_sdu)(void *deliver_sdu_data, struct nr_pdcp_entity_t *entity,
+                        char *buf, int size),
+    void *deliver_sdu_data,
+    void (*deliver_pdu)(void *deliver_pdu_data, struct nr_pdcp_entity_t *entity,
+                        char *buf, int size, int sdu_id),
+    void *deliver_pdu_data)
+{
+  abort();
+}
+
+nr_pdcp_entity_t *new_nr_pdcp_entity_drb_am(
+    int rb_id,
+    void (*deliver_sdu)(void *deliver_sdu_data, struct nr_pdcp_entity_t *entity,
+                        char *buf, int size),
+    void *deliver_sdu_data,
+    void (*deliver_pdu)(void *deliver_pdu_data, struct nr_pdcp_entity_t *entity,
+                        char *buf, int size, int sdu_id),
+    void *deliver_pdu_data)
+{
+  nr_pdcp_entity_drb_am_t *ret;
+
+  ret = calloc(1, sizeof(nr_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          = nr_pdcp_entity_drb_am_recv_pdu;
+  ret->common.recv_sdu          = nr_pdcp_entity_drb_am_recv_sdu;
+  ret->common.set_integrity_key = nr_pdcp_entity_drb_am_set_integrity_key;
+
+  ret->common.delete = nr_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_nr_pdcp_sn = 4095;
+
+  return (nr_pdcp_entity_t *)ret;
+}

openair2/LAYER2/nr_pdcp/nr_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 _NR_PDCP_ENTITY_H_
+#define _NR_PDCP_ENTITY_H_
+
+typedef struct nr_pdcp_entity_t {
+  /* functions provided by the PDCP module */
+  void (*recv_pdu)(struct nr_pdcp_entity_t *entity, char *buffer, int size);
+  void (*recv_sdu)(struct nr_pdcp_entity_t *entity, char *buffer, int size,
+                   int sdu_id);
+  void (*delete)(struct nr_pdcp_entity_t *entity);
+  void (*set_integrity_key)(struct nr_pdcp_entity_t *entity, char *key);
+
+  /* callbacks provided to the PDCP module */
+  void (*deliver_sdu)(void *deliver_sdu_data, struct nr_pdcp_entity_t *entity,
+                      char *buf, int size);
+  void *deliver_sdu_data;
+  void (*deliver_pdu)(void *deliver_pdu_data, struct nr_pdcp_entity_t *entity,
+                      char *buf, int size, int sdu_id);
+  void *deliver_pdu_data;
+  int tx_hfn;
+  int next_nr_pdcp_tx_sn;
+  int maximum_nr_pdcp_sn;
+} nr_pdcp_entity_t;
+
+nr_pdcp_entity_t *new_nr_pdcp_entity_srb(
+    int rb_id,
+    void (*deliver_sdu)(void *deliver_sdu_data, struct nr_pdcp_entity_t *entity,
+                        char *buf, int size),
+    void *deliver_sdu_data,
+    void (*deliver_pdu)(void *deliver_pdu_data, struct nr_pdcp_entity_t *entity,
+                        char *buf, int size, int sdu_id),
+    void *deliver_pdu_data);
+
+nr_pdcp_entity_t *new_nr_pdcp_entity_drb_am(
+    int rb_id,
+    void (*deliver_sdu)(void *deliver_sdu_data, struct nr_pdcp_entity_t *entity,
+                        char *buf, int size),
+    void *deliver_sdu_data,
+    void (*deliver_pdu)(void *deliver_pdu_data, struct nr_pdcp_entity_t *entity,
+                        char *buf, int size, int sdu_id),
+    void *deliver_pdu_data);
+
+#endif /* _NR_PDCP_ENTITY_H_ */

openair2/LAYER2/nr_pdcp/nr_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 "nr_pdcp_entity_drb_am.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void nr_pdcp_entity_drb_am_recv_pdu(nr_pdcp_entity_t *_entity, char *buffer, int size)
+{
+  nr_pdcp_entity_drb_am_t *entity = (nr_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,
+                             (nr_pdcp_entity_t *)entity, buffer+2, size-2);
+}
+
+void nr_pdcp_entity_drb_am_recv_sdu(nr_pdcp_entity_t *_entity, char *buffer, int size,
+                              int sdu_id)
+{
+  nr_pdcp_entity_drb_am_t *entity = (nr_pdcp_entity_drb_am_t *)_entity;
+  int sn;
+  char buf[size+2];
+
+  sn = entity->common.next_nr_pdcp_tx_sn;
+
+  entity->common.next_nr_pdcp_tx_sn++;
+  if (entity->common.next_nr_pdcp_tx_sn > entity->common.maximum_nr_pdcp_sn) {
+    entity->common.next_nr_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,
+                             (nr_pdcp_entity_t *)entity, buf, size+2, sdu_id);
+}
+
+void nr_pdcp_entity_drb_am_set_integrity_key(nr_pdcp_entity_t *_entity, char *key)
+{
+  /* nothing to do */
+}
+
+void nr_pdcp_entity_drb_am_delete(nr_pdcp_entity_t *_entity)
+{
+  nr_pdcp_entity_drb_am_t *entity = (nr_pdcp_entity_drb_am_t *)_entity;
+  free(entity);
+}

openair2/LAYER2/nr_pdcp/nr_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 _NR_PDCP_ENTITY_DRB_AM_H_
+#define _NR_PDCP_ENTITY_DRB_AM_H_
+
+#include "nr_pdcp_entity.h"
+
+typedef struct {
+  nr_pdcp_entity_t common;
+  int rb_id;
+} nr_pdcp_entity_drb_am_t;
+
+void nr_pdcp_entity_drb_am_recv_pdu(nr_pdcp_entity_t *entity, char *buffer, int size);
+void nr_pdcp_entity_drb_am_recv_sdu(nr_pdcp_entity_t *entity, char *buffer, int size,
+                                    int sdu_id);
+void nr_pdcp_entity_drb_am_set_integrity_key(nr_pdcp_entity_t *entity, char *key);
+void nr_pdcp_entity_drb_am_delete(nr_pdcp_entity_t *entity);
+
+#endif /* _NR_PDCP_ENTITY_DRB_AM_H_ */

openair2/LAYER2/nr_pdcp/nr_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 "nr_pdcp_ue_manager.h"
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "LOG/log.h"
+
+typedef struct {
+  pthread_mutex_t lock;
+  nr_pdcp_ue_t    **ue_list;
+  int             ue_count;
+  int             enb_flag;
+} nr_pdcp_ue_manager_internal_t;
+
+nr_pdcp_ue_manager_t *new_nr_pdcp_ue_manager(int enb_flag)
+{
+  nr_pdcp_ue_manager_internal_t *ret;
+
+  ret = calloc(1, sizeof(nr_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 nr_pdcp_manager_get_enb_flag(nr_pdcp_ue_manager_t *_m)
+{
+  nr_pdcp_ue_manager_internal_t *m = _m;
+  return m->enb_flag;
+}
+
+void nr_pdcp_manager_lock(nr_pdcp_ue_manager_t *_m)
+{
+  nr_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 nr_pdcp_manager_unlock(nr_pdcp_ue_manager_t *_m)
+{
+  nr_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 */
+nr_pdcp_ue_t *nr_pdcp_manager_get_ue(nr_pdcp_ue_manager_t *_m, int rnti)
+{
+  /* TODO: optimze */
+  nr_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(nr_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(nr_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 nr_pdcp_manager_remove_ue(nr_pdcp_ue_manager_t *_m, int rnti)
+{
+  nr_pdcp_ue_manager_internal_t *m = _m;
+  nr_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(nr_pdcp_ue_t *));
+  m->ue_list = realloc(m->ue_list, m->ue_count * sizeof(nr_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 nr_pdcp_ue_add_srb_pdcp_entity(nr_pdcp_ue_t *ue, int srb_id, nr_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 nr_pdcp_ue_add_drb_pdcp_entity(nr_pdcp_ue_t *ue, int drb_id, nr_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;
+}
+
+int nr_pdcp_get_first_rnti(nr_pdcp_ue_manager_t *_m)
+{
+  nr_pdcp_ue_manager_internal_t *m = _m;
+  if (m->ue_count == 0)
+    return -1;
+  return m->ue_list[0]->rnti;
+}

openair2/LAYER2/nr_pdcp/nr_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 _NR_PDCP_UE_MANAGER_H_
+#define _NR_PDCP_UE_MANAGER_H_
+
+#include "nr_pdcp_entity.h"
+
+typedef void nr_pdcp_ue_manager_t;
+
+typedef struct nr_pdcp_ue_t {
+  int rnti;
+  nr_pdcp_entity_t *srb[2];
+  nr_pdcp_entity_t *drb[5];
+} nr_pdcp_ue_t;
+
+/***********************************************************************/
+/* manager functions                                                   */
+/***********************************************************************/
+
+nr_pdcp_ue_manager_t *new_nr_pdcp_ue_manager(int enb_flag);
+
+int nr_pdcp_manager_get_enb_flag(nr_pdcp_ue_manager_t *m);
+
+void nr_pdcp_manager_lock(nr_pdcp_ue_manager_t *m);
+void nr_pdcp_manager_unlock(nr_pdcp_ue_manager_t *m);
+
+nr_pdcp_ue_t *nr_pdcp_manager_get_ue(nr_pdcp_ue_manager_t *m, int rnti);
+void nr_pdcp_manager_remove_ue(nr_pdcp_ue_manager_t *m, int rnti);
+
+/***********************************************************************/
+/* ue functions                                                        */
+/***********************************************************************/
+
+void nr_pdcp_ue_add_srb_pdcp_entity(nr_pdcp_ue_t *ue, int srb_id,
+                                    nr_pdcp_entity_t *entity);
+void nr_pdcp_ue_add_drb_pdcp_entity(nr_pdcp_ue_t *ue, int drb_id,
+                                    nr_pdcp_entity_t *entity);
+
+/***********************************************************************/
+/* hacks                                                               */
+/***********************************************************************/
+
+/* returns -1 if no UE */
+int nr_pdcp_get_first_rnti(nr_pdcp_ue_manager_t *m);
+
+#endif /* _NR_PDCP_UE_MANAGER_H_ */