PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Clang-formated PDCP NR PR.

This commit is contained in:
Pedro Alvarez 2019-07-23 15:49:34 +01:00 committed by Andre Puschmann
parent 964db869a6
commit 491695ab77
11 changed files with 127 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/include/srslte/common/interfaces_common.h
View File

@ -88,7 +88,7 @@ public:
hdr_len_bytes = ceil((float)sn_len / 8);
}
uint8_t bearer_id;
uint8_t bearer_id;
pdcp_rb_type_t rb_type;
uint8_t tx_direction;
uint8_t rx_direction;

4
lib/include/srslte/upper/pdcp.h
View File

@ -22,8 +22,8 @@
#ifndef SRSLTE_PDCP_H
#define SRSLTE_PDCP_H
#include "srslte/common/log.h"
#include "srslte/common/common.h"
#include "srslte/common/log.h"
#include "srslte/interfaces/ue_interfaces.h"
#include "srslte/upper/pdcp_entity_lte.h"
@ -76,7 +76,7 @@ private:
srsue::rrc_interface_pdcp* rrc = nullptr;
srsue::gw_interface_pdcp* gw = nullptr;
typedef std::map<uint16_t, pdcp_entity_lte*> pdcp_map_t;
typedef std::map<uint16_t, pdcp_entity_lte*> pdcp_map_t;
typedef std::pair<uint16_t, pdcp_entity_lte*> pdcp_map_pair_t;
log* pdcp_log = nullptr;

6
lib/include/srslte/upper/pdcp_entity_base.h
View File

@ -84,9 +84,9 @@ public:
uint32_t HFN(uint32_t count);
uint32_t SN(uint32_t count);
uint32_t COUNT(uint32_t hfn, uint32_t sn);
protected:
srslte::log* log = nullptr;
srslte::log* log = nullptr;
bool active = false;
uint32_t lcid = 0;
@ -119,7 +119,7 @@ inline uint32_t pdcp_entity_base::HFN(uint32_t count)
inline uint32_t pdcp_entity_base::SN(uint32_t count)
{
return count & (0xFFFFFFFF >> (32 -cfg.sn_len));
return count & (0xFFFFFFFF >> (32 - cfg.sn_len));
}
inline uint32_t pdcp_entity_base::COUNT(uint32_t hfn, uint32_t sn)

9
lib/include/srslte/upper/pdcp_entity_lte.h
View File

@ -23,14 +23,13 @@
#define SRSLTE_PDCP_ENTITY_LTE_H
#include "srslte/common/buffer_pool.h"
#include "srslte/common/log.h"
#include "srslte/common/common.h"
#include "srslte/interfaces/ue_interfaces.h"
#include "srslte/common/log.h"
#include "srslte/common/security.h"
#include "srslte/common/threads.h"
#include "srslte/interfaces/ue_interfaces.h"
#include "srslte/upper/pdcp_entity_base.h"
namespace srslte {
/****************************************************************************
@ -41,10 +40,10 @@ namespace srslte {
#define PDCP_CONTROL_MAC_I 0x00000000
/****************************************************************************
* LTE PDCP Entity
* LTE PDCP Entity
* Class for LTE PDCP entities
***************************************************************************/
class pdcp_entity_lte final: public pdcp_entity_base
class pdcp_entity_lte final : public pdcp_entity_base
{
public:
pdcp_entity_lte();

6
lib/include/srslte/upper/pdcp_entity_nr.h
View File

@ -22,13 +22,13 @@
#ifndef SRSLTE_PDCP_ENTITY_NR_H
#define SRSLTE_PDCP_ENTITY_NR_H
#include "pdcp_entity_base.h"
#include "srslte/common/buffer_pool.h"
#include "srslte/common/log.h"
#include "srslte/common/common.h"
#include "srslte/common/interfaces_common.h"
#include "srslte/common/log.h"
#include "srslte/common/security.h"
#include "srslte/common/threads.h"
#include "pdcp_entity_base.h"
namespace srslte {
@ -76,7 +76,7 @@ private:
// Packing/Unpacking Helper functions
void read_data_header(const unique_byte_buffer_t& sdu, uint32_t* rcvd_sn);
void write_data_header(const unique_byte_buffer_t& sdu, uint32_t sn);
void extract_mac(const unique_byte_buffer_t &sdu, uint8_t* mac);
void extract_mac(const unique_byte_buffer_t& sdu, uint8_t* mac);
void append_mac(const unique_byte_buffer_t& sdu, uint8_t* mac);
};

10
lib/src/upper/pdcp.cc
View File

@ -183,8 +183,8 @@ void pdcp::change_lcid(uint32_t old_lcid, uint32_t new_lcid)
// make sure old LCID exists and new LCID is still free
if (valid_lcid(old_lcid) && not valid_lcid(new_lcid)) {
// insert old PDCP entity into new LCID
pdcp_map_t::iterator it = pdcp_array.find(old_lcid);
pdcp_entity_lte *pdcp_entity = it->second;
pdcp_map_t::iterator it = pdcp_array.find(old_lcid);
pdcp_entity_lte* pdcp_entity = it->second;
if (not pdcp_array.insert(pdcp_map_pair_t(new_lcid, pdcp_entity)).second) {
pdcp_log->error("Error inserting PDCP entity into array\n.");
goto exit;
@ -193,7 +193,11 @@ void pdcp::change_lcid(uint32_t old_lcid, uint32_t new_lcid)
pdcp_array.erase(it);
pdcp_log->warning("Changed LCID of PDCP bearer from %d to %d\n", old_lcid, new_lcid);
} else {
pdcp_log->error("Can't change PDCP of bearer %s from %d to %d. Bearer doesn't exist or new LCID already occupied.\n", rrc->get_rb_name(old_lcid).c_str(), old_lcid, new_lcid);
pdcp_log->error(
"Can't change PDCP of bearer %s from %d to %d. Bearer doesn't exist or new LCID already occupied.\n",
rrc->get_rb_name(old_lcid).c_str(),
old_lcid,
new_lcid);
}
exit:
pthread_rwlock_unlock(&rwlock);

88
lib/src/upper/pdcp_entity_base.cc
View File

@ -50,19 +50,18 @@ void pdcp_entity_base::config_security(uint8_t* k_rrc_enc_,
integrity_algorithm_id_text[integ_algo],
ciphering_algorithm_id_text[cipher_algo]);
log->debug_hex(k_rrc_enc, 32,"K_rrc_enc");
log->debug_hex(k_up_enc, 32,"K_up_enc");
log->debug_hex(k_rrc_int, 32,"K_rrc_int");
log->debug_hex(k_up_int, 32,"K_up_int");
log->debug_hex(k_rrc_enc, 32, "K_rrc_enc");
log->debug_hex(k_up_enc, 32, "K_up_enc");
log->debug_hex(k_rrc_int, 32, "K_rrc_int");
log->debug_hex(k_up_int, 32, "K_up_int");
}
/****************************************************************************
* Security functions
***************************************************************************/
void pdcp_entity_base::integrity_generate(uint8_t* msg, uint32_t msg_len, uint32_t count, uint8_t* mac)
{
uint8_t *k_int;
uint8_t* k_int;
// If control plane use RRC integrity key. If data use user plane key
if (is_srb()) {
@ -71,30 +70,17 @@ void pdcp_entity_base::integrity_generate(uint8_t* msg, uint32_t msg_len, uint32
k_int = k_up_int;
}
switch(integ_algo)
{
case INTEGRITY_ALGORITHM_ID_EIA0:
break;
case INTEGRITY_ALGORITHM_ID_128_EIA1:
security_128_eia1(&k_int[16],
count,
cfg.bearer_id - 1,
cfg.tx_direction,
msg,
msg_len,
mac);
break;
case INTEGRITY_ALGORITHM_ID_128_EIA2:
security_128_eia2(&k_int[16],
count,
cfg.bearer_id - 1,
cfg.tx_direction,
msg,
msg_len,
mac);
break;
default:
break;
switch (integ_algo) {
case INTEGRITY_ALGORITHM_ID_EIA0:
break;
case INTEGRITY_ALGORITHM_ID_128_EIA1:
security_128_eia1(&k_int[16], count, cfg.bearer_id - 1, cfg.tx_direction, msg, msg_len, mac);
break;
case INTEGRITY_ALGORITHM_ID_128_EIA2:
security_128_eia2(&k_int[16], count, cfg.bearer_id - 1, cfg.tx_direction, msg, msg_len, mac);
break;
default:
break;
}
log->debug("Integrity gen input: COUNT %d, Bearer ID %d, Direction %s\n",
@ -107,9 +93,9 @@ void pdcp_entity_base::integrity_generate(uint8_t* msg, uint32_t msg_len, uint32
bool pdcp_entity_base::integrity_verify(uint8_t* msg, uint32_t msg_len, uint32_t count, uint8_t* mac)
{
uint8_t mac_exp[4] = {};
bool is_valid = true;
uint8_t *k_int;
uint8_t mac_exp[4] = {};
bool is_valid = true;
uint8_t* k_int;
// If control plane use RRC integrity key. If data use user plane key
if (is_srb()) {
@ -157,7 +143,7 @@ bool pdcp_entity_base::integrity_verify(uint8_t* msg, uint32_t msg_len, uint32_t
void pdcp_entity_base::cipher_encrypt(uint8_t* msg, uint32_t msg_len, uint32_t count, uint8_t* ct)
{
byte_buffer_t ct_tmp;
uint8_t *k_enc;
uint8_t* k_enc;
// If control plane use RRC encrytion key. If data use user plane key
if (is_srb()) {
@ -192,7 +178,7 @@ void pdcp_entity_base::cipher_encrypt(uint8_t* msg, uint32_t msg_len, uint32_t c
void pdcp_entity_base::cipher_decrypt(uint8_t* ct, uint32_t ct_len, uint32_t count, uint8_t* msg)
{
byte_buffer_t msg_tmp;
uint8_t *k_enc;
uint8_t* k_enc;
// If control plane use RRC encrytion key. If data use user plane key
if (is_srb()) {
@ -207,22 +193,20 @@ void pdcp_entity_base::cipher_decrypt(uint8_t* ct, uint32_t ct_len, uint32_t cou
(cfg.rx_direction == SECURITY_DIRECTION_DOWNLINK) ? "Downlink" : "Uplink");
log->debug_hex(ct, ct_len, "Cipher decrypt input msg");
switch(cipher_algo)
{
case CIPHERING_ALGORITHM_ID_EEA0:
break;
case CIPHERING_ALGORITHM_ID_128_EEA1:
security_128_eea1(&k_enc[16], count, cfg.bearer_id - 1, cfg.rx_direction, ct, ct_len, msg_tmp.msg);
memcpy(msg, msg_tmp.msg, ct_len);
break;
case CIPHERING_ALGORITHM_ID_128_EEA2:
security_128_eea2(&k_enc[16], count, cfg.bearer_id - 1, cfg.rx_direction, ct, ct_len, msg_tmp.msg);
memcpy(msg, msg_tmp.msg, ct_len);
break;
default:
break;
switch (cipher_algo) {
case CIPHERING_ALGORITHM_ID_EEA0:
break;
case CIPHERING_ALGORITHM_ID_128_EEA1:
security_128_eea1(&k_enc[16], count, cfg.bearer_id - 1, cfg.rx_direction, ct, ct_len, msg_tmp.msg);
memcpy(msg, msg_tmp.msg, ct_len);
break;
case CIPHERING_ALGORITHM_ID_128_EEA2:
security_128_eea2(&k_enc[16], count, cfg.bearer_id - 1, cfg.rx_direction, ct, ct_len, msg_tmp.msg);
memcpy(msg, msg_tmp.msg, ct_len);
break;
default:
break;
}
log->debug_hex(msg, ct_len,"Cipher decrypt output msg");
}
log->debug_hex(msg, ct_len, "Cipher decrypt output msg");
}
} // namespace srslte

65
lib/src/upper/pdcp_entity_lte.cc
View File

@ -33,7 +33,7 @@ void pdcp_entity_lte::init(srsue::rlc_interface_pdcp* rlc_,
srsue::gw_interface_pdcp* gw_,
srslte::log* log_,
uint32_t lcid_,
srslte_pdcp_config_t cfg_)
srslte_pdcp_config_t cfg_)
{
rlc = rlc_;
rrc = rrc_;
@ -83,10 +83,10 @@ void pdcp_entity_lte::reestablish()
rx_hfn = 0;
next_pdcp_rx_sn = 0;
} else {
tx_count = 0;
rx_count = 0;
rx_hfn = 0;
next_pdcp_rx_sn = 0;
tx_count = 0;
rx_count = 0;
rx_hfn = 0;
next_pdcp_rx_sn = 0;
last_submitted_pdcp_rx_sn = maximum_pdcp_sn;
}
}
@ -104,18 +104,20 @@ void pdcp_entity_lte::reset()
// GW/RRC interface
void pdcp_entity_lte::write_sdu(unique_byte_buffer_t sdu, bool blocking)
{
log->info_hex(sdu->msg, sdu->N_bytes,
"TX %s SDU, SN: %d, do_integrity = %s, do_encryption = %s",
rrc->get_rb_name(lcid).c_str(), tx_count,
(do_integrity) ? "true" : "false", (do_encryption) ? "true" : "false");
log->info_hex(sdu->msg,
sdu->N_bytes,
"TX %s SDU, SN: %d, do_integrity = %s, do_encryption = %s",
rrc->get_rb_name(lcid).c_str(),
tx_count,
(do_integrity) ? "true" : "false",
(do_encryption) ? "true" : "false");
mutex.lock();
if (is_srb()) {
pdcp_pack_control_pdu(tx_count, sdu.get());
if (do_integrity) {
integrity_generate(
sdu->msg, sdu->N_bytes - 4, tx_count, &sdu->msg[sdu->N_bytes - 4]);
integrity_generate(sdu->msg, sdu->N_bytes - 4, tx_count, &sdu->msg[sdu->N_bytes - 4]);
}
}
@ -176,8 +178,7 @@ void pdcp_entity_lte::write_pdu(unique_byte_buffer_t pdu)
}
if (do_integrity) {
if (not integrity_verify(
pdu->msg, pdu->N_bytes - 4, sn, &(pdu->msg[pdu->N_bytes - 4]))) {
if (not integrity_verify(pdu->msg, pdu->N_bytes - 4, sn, &(pdu->msg[pdu->N_bytes - 4]))) {
log->error_hex(pdu->msg, pdu->N_bytes, "%s Dropping PDU", rrc->get_rb_name(lcid).c_str());
goto exit;
}
@ -199,7 +200,7 @@ exit:
* Ref: 3GPP TS 36.323 v10.1.0 Section 5.1.2
***************************************************************************/
// DRBs mapped on RLC UM (5.1.2.1.3)
void pdcp_entity_lte::handle_um_drb_pdu(const srslte::unique_byte_buffer_t &pdu)
void pdcp_entity_lte::handle_um_drb_pdu(const srslte::unique_byte_buffer_t& pdu)
{
uint32_t sn;
if (12 == cfg.sn_len) {
@ -229,7 +230,7 @@ void pdcp_entity_lte::handle_um_drb_pdu(const srslte::unique_byte_buffer_t &pdu)
}
// DRBs mapped on RLC AM, without re-ordering (5.1.2.1.2)
void pdcp_entity_lte::handle_am_drb_pdu(const srslte::unique_byte_buffer_t &pdu)
void pdcp_entity_lte::handle_am_drb_pdu(const srslte::unique_byte_buffer_t& pdu)
{
uint32_t sn, count;
pdcp_unpack_data_pdu_long_sn(pdu.get(), &sn);
@ -257,14 +258,14 @@ void pdcp_entity_lte::handle_am_drb_pdu(const srslte::unique_byte_buffer_t &pdu)
} else if ((int32_t)(next_pdcp_rx_sn - sn) > (int32_t)reordering_window) {
log->debug("(Next_PDCP_RX_SN - SN) is larger than re-ordering window.\n");
rx_hfn++;
count = (rx_hfn << cfg.sn_len) | sn;
count = (rx_hfn << cfg.sn_len) | sn;
next_pdcp_rx_sn = sn + 1;
} else if (sn_diff_next_pdcp_rx_sn >= (int32_t)reordering_window) {
log->debug("(SN - Next_PDCP_RX_SN) is larger or equal than re-ordering window.\n");
count = ((rx_hfn - 1) << cfg.sn_len) | sn;
} else if (sn >= next_pdcp_rx_sn) {
log->debug("SN is larger or equal than Next_PDCP_RX_SN.\n");
count = (rx_hfn << cfg.sn_len) | sn;
count = (rx_hfn << cfg.sn_len) | sn;
next_pdcp_rx_sn = sn + 1;
if (next_pdcp_rx_sn > maximum_pdcp_sn) {
next_pdcp_rx_sn = 0;
@ -293,7 +294,6 @@ uint32_t pdcp_entity_lte::get_dl_count()
return rx_count;
}
uint32_t pdcp_entity_lte::get_ul_count()
{
return tx_count;
@ -303,8 +303,7 @@ uint32_t pdcp_entity_lte::get_ul_count()
* Pack/Unpack helper functions
* Ref: 3GPP TS 36.323 v10.1.0
***************************************************************************/
void pdcp_pack_control_pdu(uint32_t sn, byte_buffer_t *sdu)
void pdcp_pack_control_pdu(uint32_t sn, byte_buffer_t* sdu)
{
// Make room and add header
sdu->msg--;
@ -314,12 +313,11 @@ void pdcp_pack_control_pdu(uint32_t sn, byte_buffer_t *sdu)
// Add MAC
sdu->msg[sdu->N_bytes++] = (PDCP_CONTROL_MAC_I >> 24) & 0xFF;
sdu->msg[sdu->N_bytes++] = (PDCP_CONTROL_MAC_I >> 16) & 0xFF;
sdu->msg[sdu->N_bytes++] = (PDCP_CONTROL_MAC_I >> 8) & 0xFF;
sdu->msg[sdu->N_bytes++] = PDCP_CONTROL_MAC_I & 0xFF;
sdu->msg[sdu->N_bytes++] = (PDCP_CONTROL_MAC_I >> 8) & 0xFF;
sdu->msg[sdu->N_bytes++] = PDCP_CONTROL_MAC_I & 0xFF;
}
void pdcp_unpack_control_pdu(byte_buffer_t *pdu, uint32_t *sn)
void pdcp_unpack_control_pdu(byte_buffer_t* pdu, uint32_t* sn)
{
// Strip header
*sn = *pdu->msg & 0x1F;
@ -332,7 +330,7 @@ void pdcp_unpack_control_pdu(byte_buffer_t *pdu, uint32_t *sn)
// TODO: integrity check MAC
}
void pdcp_pack_data_pdu_short_sn(uint32_t sn, byte_buffer_t *sdu)
void pdcp_pack_data_pdu_short_sn(uint32_t sn, byte_buffer_t* sdu)
{
// Make room and add header
sdu->msg--;
@ -340,30 +338,29 @@ void pdcp_pack_data_pdu_short_sn(uint32_t sn, byte_buffer_t *sdu)
sdu->msg[0] = (PDCP_D_C_DATA_PDU << 7) | (sn & 0x7F);
}
void pdcp_unpack_data_pdu_short_sn(byte_buffer_t *sdu, uint32_t *sn)
void pdcp_unpack_data_pdu_short_sn(byte_buffer_t* sdu, uint32_t* sn)
{
// Strip header
*sn = sdu->msg[0] & 0x7F;
*sn = sdu->msg[0] & 0x7F;
sdu->msg++;
sdu->N_bytes--;
}
void pdcp_pack_data_pdu_long_sn(uint32_t sn, byte_buffer_t *sdu)
void pdcp_pack_data_pdu_long_sn(uint32_t sn, byte_buffer_t* sdu)
{
// Make room and add header
sdu->msg -= 2;
sdu->msg -= 2;
sdu->N_bytes += 2;
sdu->msg[0] = (PDCP_D_C_DATA_PDU << 7) | ((sn >> 8) & 0x0F);
sdu->msg[1] = sn & 0xFF;
}
void pdcp_unpack_data_pdu_long_sn(byte_buffer_t *sdu, uint32_t *sn)
void pdcp_unpack_data_pdu_long_sn(byte_buffer_t* sdu, uint32_t* sn)
{
// Strip header
*sn = (sdu->msg[0] & 0x0F) << 8;
*sn = (sdu->msg[0] & 0x0F) << 8;
*sn |= sdu->msg[1];
sdu->msg += 2;
sdu->msg += 2;
sdu->N_bytes -= 2;
}
}
} // namespace srslte

33
lib/src/upper/pdcp_entity_nr.cc
View File

@ -20,8 +20,8 @@
*/
#include "srslte/upper/pdcp_entity_nr.h"
#include "srslte/common/security.h"
#include "srslte/common/int_helpers.h"
#include "srslte/common/security.h"
namespace srslte {
@ -68,16 +68,18 @@ void pdcp_entity_nr::reset()
// SDAP/RRC interface
void pdcp_entity_nr::write_sdu(unique_byte_buffer_t sdu, bool blocking)
{
log->info_hex(sdu->msg, sdu->N_bytes,
"TX %s SDU, do_integrity = %s, do_encryption = %s",
rrc->get_rb_name(lcid).c_str(),
(do_integrity) ? "true" : "false", (do_encryption) ? "true" : "false");
log->info_hex(sdu->msg,
sdu->N_bytes,
"TX %s SDU, do_integrity = %s, do_encryption = %s",
rrc->get_rb_name(lcid).c_str(),
(do_integrity) ? "true" : "false",
(do_encryption) ? "true" : "false");
// Start discard timer TODO
// Perform header compression TODO
// Integrity protection
uint8_t mac[4];
uint8_t mac[4];
integrity_generate(sdu->msg, sdu->N_bytes, tx_next, mac);
// Ciphering
@ -88,7 +90,7 @@ void pdcp_entity_nr::write_sdu(unique_byte_buffer_t sdu, bool blocking)
// Append MAC-I
append_mac(sdu, mac);
// Increment TX_NEXT
tx_next++;
@ -150,10 +152,10 @@ void pdcp_entity_nr::write_pdu(unique_byte_buffer_t pdu)
// TODO Store PDU in reception buffer
// Update RX_NEXT
if(rcvd_count >= rx_next){
if (rcvd_count >= rx_next) {
rx_next = rcvd_count + 1;
}
// TODO if out-of-order configured, submit to upper layer
if (rcvd_count == rx_deliv) {
@ -163,21 +165,21 @@ void pdcp_entity_nr::write_pdu(unique_byte_buffer_t pdu)
} else {
gw->write_pdu(lcid, std::move(pdu));
}
// Update RX_DELIV
rx_deliv = rcvd_count + 1; // TODO needs to be corrected when queueing is implemented
printf("New RX_deliv %d, rcvd_count %d\n", rx_deliv, rcvd_count);
}
// Not clear how to update RX_DELIV without reception buffer (TODO)
// Not clear how to update RX_DELIV without reception buffer (TODO)
// TODO handle reordering timers
}
void pdcp_entity_nr::read_data_header(const unique_byte_buffer_t& pdu, uint32_t *rcvd_sn)
void pdcp_entity_nr::read_data_header(const unique_byte_buffer_t& pdu, uint32_t* rcvd_sn)
{
// Check PDU is long enough to extract header
if(pdu->N_bytes <= cfg.hdr_len_bytes){
if (pdu->N_bytes <= cfg.hdr_len_bytes) {
log->error("PDU too small to extract header\n");
return;
}
@ -230,7 +232,7 @@ void pdcp_entity_nr::write_data_header(const srslte::unique_byte_buffer_t& sdu,
}
}
void pdcp_entity_nr::extract_mac(const unique_byte_buffer_t &pdu, uint8_t* mac)
void pdcp_entity_nr::extract_mac(const unique_byte_buffer_t& pdu, uint8_t* mac)
{
// Check enough space for MAC
if (pdu->N_bytes < 4) {
@ -243,7 +245,7 @@ void pdcp_entity_nr::extract_mac(const unique_byte_buffer_t &pdu, uint8_t* mac)
pdu->N_bytes -= 4;
}
void pdcp_entity_nr::append_mac(const unique_byte_buffer_t &sdu, uint8_t* mac)
void pdcp_entity_nr::append_mac(const unique_byte_buffer_t& sdu, uint8_t* mac)
{
// Check enough space for MAC
if (sdu->N_bytes + 4 > sdu->get_tailroom()) {
@ -255,5 +257,4 @@ void pdcp_entity_nr::append_mac(const unique_byte_buffer_t &sdu, uint8_t* mac)
memcpy(&sdu->msg[sdu->N_bytes], mac, 4);
sdu->N_bytes += 4;
}
} // namespace srslte

29
lib/test/upper/pdcp_nr_test.cc
View File

@ -81,7 +81,7 @@ public:
}
private:
srslte::log* log;
srslte::log* log;
srslte::unique_byte_buffer_t last_pdcp_pdu;
bool rb_is_um(uint32_t lcid) { return false; }
@ -109,7 +109,7 @@ class gw_dummy : public srsue::gw_interface_pdcp
public:
gw_dummy(srslte::log* log_) : log(log_) {}
void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu) {}
void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu) {}
uint32_t rx_count = 0;
void get_last_pdu(const srslte::unique_byte_buffer_t& pdu)
@ -126,24 +126,30 @@ public:
}
private:
srslte::log* log;
srslte::log* log;
srslte::unique_byte_buffer_t last_pdu;
};
/*
* Genric function to test transmission of in-sequence packets
*/
int test_tx(uint32_t n_packets, uint8_t pdcp_sn_len, srslte::unique_byte_buffer_t pdu_exp, srslte::byte_buffer_pool* pool, srslte::log* log)
int test_tx(uint32_t n_packets,
uint8_t pdcp_sn_len,
srslte::unique_byte_buffer_t pdu_exp,
srslte::byte_buffer_pool* pool,
srslte::log* log)
{
srslte::pdcp_entity_nr pdcp;
srslte::srslte_pdcp_config_t cfg = {1, srslte::PDCP_RB_IS_DRB, SECURITY_DIRECTION_UPLINK, SECURITY_DIRECTION_DOWNLINK, pdcp_sn_len};
srslte::pdcp_entity_nr pdcp;
srslte::srslte_pdcp_config_t cfg = {
1, srslte::PDCP_RB_IS_DRB, SECURITY_DIRECTION_UPLINK, SECURITY_DIRECTION_DOWNLINK, pdcp_sn_len};
rlc_dummy rlc(log);
rrc_dummy rrc(log);
gw_dummy gw(log);
gw_dummy gw(log);
pdcp.init(&rlc, &rrc, &gw, log, 0, cfg);
pdcp.config_security(k_enc, k_int, k_enc, k_int, srslte::CIPHERING_ALGORITHM_ID_128_EEA2, srslte::INTEGRITY_ALGORITHM_ID_128_EIA2);
pdcp.config_security(
k_enc, k_int, k_enc, k_int, srslte::CIPHERING_ALGORITHM_ID_128_EEA2, srslte::INTEGRITY_ALGORITHM_ID_128_EIA2);
pdcp.enable_integrity();
pdcp.enable_encryption();
@ -186,7 +192,7 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log* log)
srslte::unique_byte_buffer_t pdu_exp_sn0_len12 = allocate_unique_buffer(*pool);
memcpy(pdu_exp_sn0_len12->msg, pdu1, PDU1_LEN);
pdu_exp_sn0_len12->N_bytes = PDU1_LEN;
//TESTASSERT(test_tx(1, srslte::PDCP_SN_LEN_12, std::move(pdu_exp_sn0_len12), pool, log) == 0);
TESTASSERT(test_tx(1, srslte::PDCP_SN_LEN_12, std::move(pdu_exp_sn0_len12), pool, log) == 0);
/*
* TX Test 2: PDCP Entity with SN LEN = 12
@ -198,7 +204,7 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log* log)
srslte::unique_byte_buffer_t pdu_exp_sn2048_len12 = allocate_unique_buffer(*pool);
memcpy(pdu_exp_sn2048_len12->msg, pdu2, PDU2_LEN);
pdu_exp_sn2048_len12->N_bytes = PDU2_LEN;
//TESTASSERT(test_tx(2049, srslte::PDCP_SN_LEN_12, std::move(pdu_exp_sn2048_len12), pool, log) == 0);
TESTASSERT(test_tx(2049, srslte::PDCP_SN_LEN_12, std::move(pdu_exp_sn2048_len12), pool, log) == 0);
/*
* TX Test 3: PDCP Entity with SN LEN = 12
@ -210,7 +216,7 @@ int test_tx_all(srslte::byte_buffer_pool* pool, srslte::log* log)
srslte::unique_byte_buffer_t pdu_exp_sn4096_len12 = allocate_unique_buffer(*pool);
memcpy(pdu_exp_sn4096_len12->msg, pdu3, PDU3_LEN);
pdu_exp_sn4096_len12->N_bytes = PDU3_LEN;
//TESTASSERT(test_tx(4097, srslte::PDCP_SN_LEN_12, std::move(pdu_exp_sn4096_len12), pool, log) == 0);
TESTASSERT(test_tx(4097, srslte::PDCP_SN_LEN_12, std::move(pdu_exp_sn4096_len12), pool, log) == 0);
/*
* TX Test 4: PDCP Entity with SN LEN = 18
@ -324,7 +330,6 @@ int run_all_tests(srslte::byte_buffer_pool* pool)
return 0;
}
int main(int argc, char** argv)
{
run_all_tests(srslte::byte_buffer_pool::get_instance());

12
srsue/src/stack/rrc/rrc.cc
View File

@ -3145,11 +3145,11 @@ void rrc::handle_con_reest(rrc_conn_reest_s* setup)
void rrc::add_srb(srb_to_add_mod_s* srb_cnfg)
{
// Setup PDCP
srslte_pdcp_config_t pdcp_cfg = {.bearer_id = srb_cnfg->srb_id,
.rb_type = PDCP_RB_IS_SRB,
srslte_pdcp_config_t pdcp_cfg = {.bearer_id = srb_cnfg->srb_id,
.rb_type = PDCP_RB_IS_SRB,
.tx_direction = SECURITY_DIRECTION_UPLINK,
.rx_direction = SECURITY_DIRECTION_DOWNLINK,
.sn_len = PDCP_SN_LEN_5};
.sn_len = PDCP_SN_LEN_5};
pdcp->add_bearer(srb_cnfg->srb_id, pdcp_cfg);
if (RB_ID_SRB2 == srb_cnfg->srb_id) {
pdcp->config_security(srb_cnfg->srb_id, k_rrc_enc, k_rrc_int, k_up_enc, cipher_algo, integ_algo);
@ -3222,11 +3222,11 @@ void rrc::add_drb(drb_to_add_mod_s* drb_cnfg)
}
// Setup PDCP
srslte_pdcp_config_t pdcp_cfg = {.bearer_id = drb_cnfg->drb_id,
.rb_type = PDCP_RB_IS_DRB,
srslte_pdcp_config_t pdcp_cfg = {.bearer_id = drb_cnfg->drb_id,
.rb_type = PDCP_RB_IS_DRB,
.tx_direction = SECURITY_DIRECTION_UPLINK,
.rx_direction = SECURITY_DIRECTION_DOWNLINK,
.sn_len = PDCP_SN_LEN_12};
.sn_len = PDCP_SN_LEN_12};
if (drb_cnfg->pdcp_cfg.rlc_um_present) {
if (drb_cnfg->pdcp_cfg.rlc_um.pdcp_sn_size == pdcp_cfg_s::rlc_um_s_::pdcp_sn_size_e_::len7bits) {
pdcp_cfg.sn_len = 7;