Commit 281cecf0 authored by Niuhaiwen's avatar Niuhaiwen

Complete the message encapsulation function

parent 16d34637
This diff is collapsed.
This diff is collapsed.
......@@ -3,9 +3,9 @@
* 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
* 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
*
......@@ -46,13 +46,13 @@ typedef enum {
} task_id_t;
typedef enum message_priorities_e {
MESSAGE_PRIORITY_MAX = 100,
MESSAGE_PRIORITY_MAX = 100,
MESSAGE_PRIORITY_MAX_LEAST = 85,
MESSAGE_PRIORITY_MED_PLUS = 70,
MESSAGE_PRIORITY_MED = 55,
MESSAGE_PRIORITY_MED_PLUS = 70,
MESSAGE_PRIORITY_MED = 55,
MESSAGE_PRIORITY_MED_LEAST = 40,
MESSAGE_PRIORITY_MIN_PLUS = 25,
MESSAGE_PRIORITY_MIN = 10,
MESSAGE_PRIORITY_MIN_PLUS = 25,
MESSAGE_PRIORITY_MIN = 10,
} message_priorities_t;
typedef enum {
......@@ -68,15 +68,18 @@ typedef enum {
PDU_SESSION_RESOURCE_SETUP_REQUEST,
UE_CONTEXT_RELEASE_REQUEST,
UE_RADIO_CAP_IND,
UL_NAS_DATA_IND,//task amf_n1 message id
UL_NAS_DATA_IND, // task amf_n1 message id
DOWNLINK_NAS_TRANSFER,
NAS_SIG_ESTAB_REQ,//task amf_app
NAS_SIG_ESTAB_REQ, // task amf_app
N1N2_MESSAGE_TRANSFER_REQ,
SMF_SERVICES_CONSUMER,
NSMF_PDU_SESSION_UPDATE_SM_CTX,
HANDOVER_REQUIRED,
HANDOVER_REQUEST_ACK,
HANDOVER_NOTIFY,
PDU_SESS_RES_SET_RESP,
TIME_OUT,
HEALTH_PING,
HEALTH_PING,
TERMINATE,
ITTI_MSG_TYPE_MAX
} itti_msg_type_t;
......@@ -86,11 +89,11 @@ typedef unsigned long message_number_t;
class itti_msg {
public:
itti_msg();
itti_msg(const itti_msg_type_t msg_type, const task_id_t origin, const task_id_t destination);
itti_msg(const itti_msg& i);
itti_msg(const itti_msg_type_t msg_type, const task_id_t origin,
const task_id_t destination);
itti_msg(const itti_msg &i);
itti_msg& operator=(itti_msg other)
{
itti_msg &operator=(itti_msg other) {
std::swap(msg_num, other.msg_num);
std::swap(origin, other.origin);
std::swap(destination, other.destination);
......@@ -99,20 +102,24 @@ public:
}
virtual ~itti_msg() = default;
static const char* get_msg_name();
static const char *get_msg_name();
message_number_t msg_num;
task_id_t origin;
task_id_t destination;
itti_msg_type_t msg_type;
task_id_t origin;
task_id_t destination;
itti_msg_type_t msg_type;
};
class itti_msg_timeout : public itti_msg {
public:
itti_msg_timeout(const task_id_t origin, const task_id_t destination, uint32_t timer_id, uint64_t arg1_user, uint64_t arg2_user):
itti_msg(TIME_OUT, origin, destination), timer_id(timer_id), arg1_user(arg1_user), arg2_user(arg2_user) {}
itti_msg_timeout(const itti_msg_timeout& i) : itti_msg(i), timer_id(i.timer_id), arg1_user(i.arg1_user), arg2_user(i.arg2_user) {}
static const char* get_msg_name() {return "TIME_OUT";};
itti_msg_timeout(const task_id_t origin, const task_id_t destination,
uint32_t timer_id, uint64_t arg1_user, uint64_t arg2_user)
: itti_msg(TIME_OUT, origin, destination), timer_id(timer_id),
arg1_user(arg1_user), arg2_user(arg2_user) {}
itti_msg_timeout(const itti_msg_timeout &i)
: itti_msg(i), timer_id(i.timer_id), arg1_user(i.arg1_user),
arg2_user(i.arg2_user) {}
static const char *get_msg_name() { return "TIME_OUT"; };
uint32_t timer_id;
uint64_t arg1_user;
uint64_t arg2_user;
......@@ -120,18 +127,20 @@ public:
class itti_msg_ping : public itti_msg {
public:
itti_msg_ping(const task_id_t origin, const task_id_t destination, uint32_t seq): itti_msg(HEALTH_PING, origin, destination), seq(seq) {}
itti_msg_ping(const itti_msg_ping& i) : itti_msg(i), seq(i.seq) {}
static const char* get_msg_name() {return "HEALTH_PING";};
itti_msg_ping(const task_id_t origin, const task_id_t destination,
uint32_t seq)
: itti_msg(HEALTH_PING, origin, destination), seq(seq) {}
itti_msg_ping(const itti_msg_ping &i) : itti_msg(i), seq(i.seq) {}
static const char *get_msg_name() { return "HEALTH_PING"; };
uint32_t seq;
};
class itti_msg_terminate : public itti_msg {
public:
itti_msg_terminate(const task_id_t origin, const task_id_t destination):
itti_msg(TERMINATE, origin, destination) {}
itti_msg_terminate(const itti_msg_terminate& i) : itti_msg(i) {}
static const char* get_msg_name() {return "TERMINATE";};
itti_msg_terminate(const task_id_t origin, const task_id_t destination)
: itti_msg(TERMINATE, origin, destination) {}
itti_msg_terminate(const itti_msg_terminate &i) : itti_msg(i) {}
static const char *get_msg_name() { return "TERMINATE"; };
};
#endif /* SRC_ITTI_ITTI_MSG_HPP_INCLUDED_ */
#ifndef _ITTI_MSG_N2_H_
#define _ITTI_MSG_N2_H_
#include "itti_msg.hpp"
#include "NGSetupRequest.hpp"
#include "HandoverNotifyMsg.hpp"
#include "HandoverRequestAck.hpp"
#include "HandoverRequiredMsg.hpp"
#include "InitialUEMessage.hpp"
#include "UplinkNASTransport.hpp"
#include "NGSetupRequest.hpp"
#include "UEContextReleaseRequest.hpp"
#include "UERadioCapabilityInfoIndication.hpp"
#include "UplinkNASTransport.hpp"
#include "itti_msg.hpp"
#include "sctp_server.hpp"
using namespace ngap;
using namespace sctp;
class itti_msg_n2 : public itti_msg{
class itti_msg_n2 : public itti_msg {
public:
itti_msg_n2(const itti_msg_type_t msg_type, const task_id_t origin, const task_id_t destination):itti_msg(msg_type,origin,destination){
}
itti_msg_n2(const itti_msg_n2& i) : itti_msg(i){
itti_msg_n2(const itti_msg_type_t msg_type, const task_id_t origin,
const task_id_t destination)
: itti_msg(msg_type, origin, destination) {}
itti_msg_n2(const itti_msg_n2 &i) : itti_msg(i) {
assoc_id = i.assoc_id;
stream = i.stream;
}
......@@ -25,84 +27,125 @@ public:
sctp_stream_id_t stream;
};
class itti_new_sctp_association : public itti_msg_n2{
class itti_new_sctp_association : public itti_msg_n2 {
public:
itti_new_sctp_association(const task_id_t origin, const task_id_t destination) : itti_msg_n2(NEW_SCTP_ASSOCIATION, origin, destination){}
itti_new_sctp_association(const task_id_t origin, const task_id_t destination)
: itti_msg_n2(NEW_SCTP_ASSOCIATION, origin, destination) {}
};
class itti_ng_setup_request : public itti_msg_n2{
class itti_ng_setup_request : public itti_msg_n2 {
public:
itti_ng_setup_request(const task_id_t origin, const task_id_t destination):itti_msg_n2(NG_SETUP_REQ,origin,destination){}
itti_ng_setup_request(const itti_ng_setup_request &i) : itti_msg_n2(i){
}
itti_ng_setup_request(const task_id_t origin, const task_id_t destination)
: itti_msg_n2(NG_SETUP_REQ, origin, destination) {}
itti_ng_setup_request(const itti_ng_setup_request &i) : itti_msg_n2(i) {}
public:
NGSetupRequestMsg * ngSetupReq;
NGSetupRequestMsg *ngSetupReq;
};
class itti_initial_ue_message : public itti_msg_n2{
class itti_initial_ue_message : public itti_msg_n2 {
public:
itti_initial_ue_message(const task_id_t origin, const task_id_t destination):itti_msg_n2(INITIAL_UE_MSG,origin,destination){}
itti_initial_ue_message(const itti_initial_ue_message &i) : itti_msg_n2(i){}
itti_initial_ue_message(const task_id_t origin, const task_id_t destination)
: itti_msg_n2(INITIAL_UE_MSG, origin, destination) {}
itti_initial_ue_message(const itti_initial_ue_message &i) : itti_msg_n2(i) {}
InitialUEMessageMsg * initUeMsg;
InitialUEMessageMsg *initUeMsg;
};
class itti_ul_nas_transport : public itti_msg_n2{
class itti_ul_nas_transport : public itti_msg_n2 {
public:
itti_ul_nas_transport(const task_id_t origin, const task_id_t destination):itti_msg_n2(ITTI_UL_NAS_TRANSPORT,origin,destination){}
itti_ul_nas_transport(const itti_ul_nas_transport &i) : itti_msg_n2(i){}
itti_ul_nas_transport(const task_id_t origin, const task_id_t destination)
: itti_msg_n2(ITTI_UL_NAS_TRANSPORT, origin, destination) {}
itti_ul_nas_transport(const itti_ul_nas_transport &i) : itti_msg_n2(i) {}
UplinkNASTransportMsg *ulNas;
};
class itti_dl_nas_transport : public itti_msg_n2{
class itti_dl_nas_transport : public itti_msg_n2 {
public:
itti_dl_nas_transport(const task_id_t origin, const task_id_t destination):itti_msg_n2(ITTI_DL_NAS_TRANSPORT,origin,destination){}
itti_dl_nas_transport(const itti_dl_nas_transport &i) : itti_msg_n2(i){}
itti_dl_nas_transport(const task_id_t origin, const task_id_t destination)
: itti_msg_n2(ITTI_DL_NAS_TRANSPORT, origin, destination) {}
itti_dl_nas_transport(const itti_dl_nas_transport &i) : itti_msg_n2(i) {}
public:
uint32_t ran_ue_ngap_id;
long amf_ue_ngap_id;
bstring nas;
long amf_ue_ngap_id;
bstring nas;
};
class itti_initial_context_setup_request : public itti_msg_n2{
class itti_initial_context_setup_request : public itti_msg_n2 {
public:
itti_initial_context_setup_request(const task_id_t origin, const task_id_t destination):itti_msg_n2(INITIAL_CONTEXT_SETUP_REQUEST,origin,destination){}
itti_initial_context_setup_request(const itti_initial_context_setup_request &i):itti_msg_n2(i){}
itti_initial_context_setup_request(const task_id_t origin,
const task_id_t destination)
: itti_msg_n2(INITIAL_CONTEXT_SETUP_REQUEST, origin, destination) {}
itti_initial_context_setup_request(
const itti_initial_context_setup_request &i)
: itti_msg_n2(i) {}
uint32_t ran_ue_ngap_id;
long amf_ue_ngap_id;
bstring kgnb;
bstring nas;
bool is_sr;
bstring n2sm;
long amf_ue_ngap_id;
bstring kgnb;
bstring nas;
bool is_sr;
bstring n2sm;
uint8_t pdu_session_id;
};
class itti_pdu_session_resource_setup_request : public itti_msg_n2{
class itti_pdu_session_resource_setup_request : public itti_msg_n2 {
public:
itti_pdu_session_resource_setup_request(const task_id_t origin, const task_id_t destination) : itti_msg_n2(PDU_SESSION_RESOURCE_SETUP_REQUEST,origin,destination){}
itti_pdu_session_resource_setup_request(const itti_pdu_session_resource_setup_request &i) : itti_msg_n2(i){}
itti_pdu_session_resource_setup_request(const task_id_t origin,
const task_id_t destination)
: itti_msg_n2(PDU_SESSION_RESOURCE_SETUP_REQUEST, origin, destination) {}
itti_pdu_session_resource_setup_request(
const itti_pdu_session_resource_setup_request &i)
: itti_msg_n2(i) {}
bstring nas;
bstring n2sm;
uint32_t ran_ue_ngap_id;
long amf_ue_ngap_id;
long amf_ue_ngap_id;
uint8_t pdu_session_id;
};
class itti_ue_context_release_request : public itti_msg_n2{
class itti_ue_context_release_request : public itti_msg_n2 {
public:
itti_ue_context_release_request(const task_id_t origin, const task_id_t destination) : itti_msg_n2(UE_CONTEXT_RELEASE_REQUEST, origin,destination){}
itti_ue_context_release_request(const itti_ue_context_release_request &i) : itti_msg_n2(i){}
UEContextReleaseRequestMsg * ueCtxRel;
itti_ue_context_release_request(const task_id_t origin,
const task_id_t destination)
: itti_msg_n2(UE_CONTEXT_RELEASE_REQUEST, origin, destination) {}
itti_ue_context_release_request(const itti_ue_context_release_request &i)
: itti_msg_n2(i) {}
UEContextReleaseRequestMsg *ueCtxRel;
};
class itti_ue_radio_capability_indication : public itti_msg_n2{
class itti_ue_radio_capability_indication : public itti_msg_n2 {
public:
itti_ue_radio_capability_indication(const task_id_t origin, const task_id_t destination) : itti_msg_n2(UE_RADIO_CAP_IND, origin, destination){}
itti_ue_radio_capability_indication(const itti_ue_radio_capability_indication &i) : itti_msg_n2(i){}
UeRadioCapabilityInfoIndicationMsg * ueRadioCap;
itti_ue_radio_capability_indication(const task_id_t origin,
const task_id_t destination)
: itti_msg_n2(UE_RADIO_CAP_IND, origin, destination) {}
itti_ue_radio_capability_indication(
const itti_ue_radio_capability_indication &i)
: itti_msg_n2(i) {}
UeRadioCapabilityInfoIndicationMsg *ueRadioCap;
};
class itti_handover_required : public itti_msg_n2 {
public:
itti_handover_required(const task_id_t origin, const task_id_t destination)
: itti_msg_n2(HANDOVER_REQUIRED, origin, destination) {}
itti_handover_required(const itti_handover_required &i) : itti_msg_n2(i) {}
HandoverRequiredMsg *handvoerRequ;
};
class itti_handover_request_Ack : public itti_msg_n2 {
public:
itti_handover_request_Ack(const task_id_t origin, const task_id_t destination)
: itti_msg_n2(HANDOVER_REQUEST_ACK, origin, destination) {}
itti_handover_request_Ack(const itti_handover_request_Ack &i)
: itti_msg_n2(i) {}
HandoverRequestAck *handoverrequestAck;
};
class itti_handover_notify : public itti_msg_n2 {
public:
itti_handover_notify(const task_id_t origin, const task_id_t destination)
: itti_msg_n2(HANDOVER_NOTIFY, origin, destination) {}
itti_handover_notify(const itti_handover_notify &i) : itti_msg_n2(i) {}
HandoverNotifyMsg *handovernotify;
};
#endif
This diff is collapsed.
#include "PDUSessionResourceAdmittedItem.hpp"
#include <iostream>
using namespace std;
namespace ngap{
PDUSessionResourceAdmittedItem::PDUSessionResourceAdmittedItem()
{
pDUSessionID = NULL;
}
PDUSessionResourceAdmittedItem::~PDUSessionResourceAdmittedItem(){}
void PDUSessionResourceAdmittedItem::setPDUSessionResourceAdmittedItem(PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequestAcktransfer)
{
pDUSessionID = m_pDUSessionID;
handoverrequestAcktransfer = m_handoverrequestAcktransfer;
}
bool PDUSessionResourceAdmittedItem::encode2PDUSessionResourceAdmittedItem(Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem)
{
if(!pDUSessionID) return false;
if(!pDUSessionID->encode2PDUSessionID(pdUSessionResourceAdmittedItem->pDUSessionID)) return false;
pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer = handoverrequestAcktransfer;
return true;
}
bool PDUSessionResourceAdmittedItem::decodefromPDUSessionResourceAdmittedItem(Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem)
{
pDUSessionID = new PDUSessionID();
if(!pDUSessionID->decodefromPDUSessionID(pdUSessionResourceAdmittedItem->pDUSessionID)) return false;
handoverrequestAcktransfer = pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer;
return true;
}
void PDUSessionResourceAdmittedItem::getPDUSessionResourceAdmittedItem(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t &m_handoverrequestAcktransfer)
{
m_pDUSessionID = pDUSessionID;
m_handoverrequestAcktransfer = handoverrequestAcktransfer;
}
}
#include <iostream>
using namespace std;
namespace ngap {
PDUSessionResourceAdmittedItem::PDUSessionResourceAdmittedItem() {
pDUSessionID = NULL;
}
PDUSessionResourceAdmittedItem::~PDUSessionResourceAdmittedItem() {}
void PDUSessionResourceAdmittedItem::setPDUSessionResourceAdmittedItem(
PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequestAcktransfer) {
pDUSessionID = m_pDUSessionID;
handoverrequestAcktransfer = m_handoverrequestAcktransfer;
}
bool PDUSessionResourceAdmittedItem::encode2PDUSessionResourceAdmittedItem(
Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem) {
if (!pDUSessionID)
return false;
if (!pDUSessionID->encode2PDUSessionID(
pdUSessionResourceAdmittedItem->pDUSessionID))
return false;
pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer =
handoverrequestAcktransfer;
return true;
}
//......
bool PDUSessionResourceAdmittedItem::decodefromPDUSessionResourceAdmittedItem(
Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem) {
pDUSessionID = new PDUSessionID();
if (!pDUSessionID->decodefromPDUSessionID(
pdUSessionResourceAdmittedItem->pDUSessionID))
return false;
handoverrequestAcktransfer =
pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer;
return true;
}
void PDUSessionResourceAdmittedItem::getPDUSessionResourceAdmittedItem(
PDUSessionID *&m_pDUSessionID,
OCTET_STRING_t &m_handoverrequestAcktransfer) {
m_pDUSessionID = pDUSessionID;
m_handoverrequestAcktransfer = handoverrequestAcktransfer;
}
} // namespace ngap
/*
* 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
*/
/*! \file
\brief
\author niuxiansheng-niu, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceHandoverRequestAckTransfer.hpp"
extern "C" {
#include "asn_codecs.h"
#include "constr_TYPE.h"
#include "constraints.h"
#include "per_decoder.h"
#include "per_encoder.h"
}
#include <iostream>
using namespace std;
namespace ngap {
PDUSessionResourceHandoverRequestAckTransfer::
PDUSessionResourceHandoverRequestAckTransfer() {
handoverRequestAcknowledegTransferIEs =
(Ngap_HandoverRequestAcknowledgeTransfer_t *)calloc(
1, sizeof(Ngap_HandoverRequestAcknowledgeTransfer_t));
DL_NGU_UP_TNLInformation = NULL;
QosFlowSetupResponseItem = NULL;
numofitems = 0;
}
PDUSessionResourceHandoverRequestAckTransfer::
~PDUSessionResourceHandoverRequestAckTransfer() {}
bool PDUSessionResourceHandoverRequestAckTransfer::
decodefromHandoverRequestAckTransfer(uint8_t *buf, int buf_size) {
asn_dec_rval_t rc = asn_decode(
NULL, ATS_ALIGNED_CANONICAL_PER,
&asn_DEF_Ngap_HandoverRequestAcknowledgeTransfer,
(void **)&handoverRequestAcknowledegTransferIEs, buf, buf_size);
if (rc.code == RC_OK) {
cout << "Decoded handoverRequestAcknowledegTransfer successfully" << endl;
} else if (rc.code == RC_WMORE) {
cout << "More data expected, call again" << endl;
return false;
} else {
cout << "Failure to decode handoverRequestAcknowledegTransfer data" << endl;
return false;
}
cout << "rc.consumed to decode = " << rc.consumed << endl;
cout << endl;
DL_NGU_UP_TNLInformation = new UpTransportLayerInformation();
if (!DL_NGU_UP_TNLInformation->decodefromUpTransportLayerInformation(
handoverRequestAcknowledegTransferIEs->dL_NGU_UP_TNLInformation)) {
cout << "decoded ngap DL_NGU_UP_TNLInformation IE error" << endl;
return false;
}
numofitems = QosFlowSetupResponseList.list.count;
QosFlowSetupResponseItem = new QosFlowListWithDataForwarding[numofitems];
for (int i = 0; i < numofitems; i++) {
if (!QosFlowSetupResponseItem[i].decodeQosFlowListWithDataForwarding(
handoverRequestAcknowledegTransferIEs->qosFlowSetupResponseList.list
.array[i])) {
cout << "decoded ngap QosFlowSetupResponseList IE error" << endl;
return false;
}
}
return true;
}
bool PDUSessionResourceHandoverRequestAckTransfer::
getUpTransportLayerInformation(GtpTunnel_t &upTnlInfo) {
if (!DL_NGU_UP_TNLInformation)
return false;
TransportLayerAddress *m_transportLayerAddress;
GtpTeid *m_gtpTeid;
if (!DL_NGU_UP_TNLInformation->getUpTransportLayerInformation(
m_transportLayerAddress, m_gtpTeid))
return false;
if (!m_transportLayerAddress->getTransportLayerAddress(upTnlInfo.ip_address))
return false;
if (!m_gtpTeid->getGtpTeid(upTnlInfo.gtp_teid))
return false;
return true;
}
bool PDUSessionResourceHandoverRequestAckTransfer::getqosFlowSetupResponseList(
QosFlowListWithDataForwarding *&m_items, int &m_numofitems) {
m_items = QosFlowSetupResponseItem;
m_numofitems = numofitems;
if (!QosFlowSetupResponseItem)
return false;
if (!numofitems)
return false;
return true;
}
} // namespace ngap
\ No newline at end of file
/*
* 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
*/
/*! \file
\brief
\author niuxiansheng-niu, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCEHANDOVERREQUESTACKTRANSFER_H_
#define _PDUSESSIONRESOURCEHANDOVERREQUESTACKTRANSFER_H_
#include "DLQoSFlowPerTNLInformation.hpp"
#include "NgapIEsStruct.hpp"
#include "QosFlowListWithDataForwarding.hpp"
#include "SecurityResult.hpp"
#include "UPTransportLayerInformation.hpp"
extern "C" {
#include "Ngap_ProtocolIE-Field.h"
#include "Ngap_HandoverRequestAcknowledgeTransfer.h"
}
namespace ngap {
class PDUSessionResourceHandoverRequestAckTransfer {
public:
PDUSessionResourceHandoverRequestAckTransfer();
virtual ~PDUSessionResourceHandoverRequestAckTransfer();
bool decodefromHandoverRequestAckTransfer(uint8_t *buf, int buf_size);
bool getUpTransportLayerInformation(GtpTunnel_t &upTnlInfo);
bool getqosFlowSetupResponseList(QosFlowListWithDataForwarding *&m_items,
int &m_numofitems);
private:
Ngap_HandoverRequestAcknowledgeTransfer_t
*handoverRequestAcknowledegTransferIEs;
UpTransportLayerInformation *DL_NGU_UP_TNLInformation;
Ngap_QosFlowSetupResponseListHOReqAck_t QosFlowSetupResponseList;
QosFlowListWithDataForwarding *QosFlowSetupResponseItem;
int numofitems;
};
} // namespace ngap
#endif
\ No newline at end of file
/*
* 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
*/
/*! \file
\brief
\author niuxiansheng-niu, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "QosFlowListWithDataForwarding.hpp"
#include <iostream>
using namespace std;
namespace ngap {
QosFlowListWithDataForwarding::QosFlowListWithDataForwarding() {
qosFlowIdentifier = NULL;
}
QosFlowListWithDataForwarding::~QosFlowListWithDataForwarding() {}
bool QosFlowListWithDataForwarding::decodeQosFlowListWithDataForwarding(
Ngap_QosFlowSetupResponseItemHOReqAck_t *qosFlowSetupResponseList) {
qosFlowIdentifier = new QosFlowIdentifier();
if (!qosFlowIdentifier->decodefromQosFlowIdentifier(
&qosFlowSetupResponseList->qosFlowIdentifier))
return false;
return true;
}
bool QosFlowListWithDataForwarding::getQosFlowIdentifier(
QosFlowIdentifier *&m_qosFlowIdentifier) {
m_qosFlowIdentifier = qosFlowIdentifier;
return true;
}
} // namespace ngap
/*
* 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
*/
/*! \file
\brief
\author niuxiansheng-niu, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _QOSFLOWLISTWITHDATAFORWRADING_H_
#define _QOSFLOWLISTWITHDATAFORWRADING_H_
#include "QosFlowIdentifier.hpp"
#include "QosFlowLevelQosParameters.hpp"
extern "C" {
#include "Ngap_QosFlowSetupResponseItemHOReqAck.h"
#include "Ngap_QosFlowSetupResponseListHOReqAck.h"
}
namespace ngap {
class QosFlowListWithDataForwarding {
public:
QosFlowListWithDataForwarding();
virtual ~QosFlowListWithDataForwarding();
bool decodeQosFlowListWithDataForwarding(
Ngap_QosFlowSetupResponseItemHOReqAck_t *qosFlowSetupResponseList);
bool getQosFlowIdentifier(QosFlowIdentifier *&m_qosFlowIdentifier);
private:
QosFlowIdentifier *qosFlowIdentifier;
};
} // namespace ngap
#endif
\ No newline at end of file
This diff is collapsed.
......@@ -4,35 +4,35 @@
#include "NgapIEsStruct.hpp"
#include "AMF-UE-NGAP-ID.hpp"
#include "RAN-UE-NGAP-ID.hpp"
#include "MessageType.hpp"
#include "RAN-UE-NGAP-ID.hpp"
#include "UserLocationInformation.hpp"
extern "C" {
#include "Ngap_HandoverNotify.h"
#include "Ngap_NGAP-PDU.h"
#include "Ngap_ProtocolIE-Field.h"
#include "Ngap_HandoverNotify.h"
}
namespace ngap {
class HandoverNotifyMsg{
public:
HandoverNotifyMsg();
virtual ~HandoverNotifyMsg();
int encode2buffer(uint8_t* buf, int buf_size);
bool decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu);
void setUserLocationInfoNR(struct NrCgi_s cig, struct Tai_s tai);
unsigned long getAmfUeNgapId();//return -1;()
uint32_t getRanUeNgapId();//return -1;()
bool getUserLocationInfoNR(struct NrCgi_s& cig, struct Tai_s& tai);
class HandoverNotifyMsg {
public:
HandoverNotifyMsg();
virtual ~HandoverNotifyMsg();
int encode2buffer(uint8_t *buf, int buf_size);
bool decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu);
void setUserLocationInfoNR(struct NrCgi_s cig, struct Tai_s tai);
unsigned long getAmfUeNgapId(); // return -1;()
uint32_t getRanUeNgapId(); // return -1;()
bool getUserLocationInfoNR(struct NrCgi_s &cig, struct Tai_s &tai);
private:
Ngap_NGAP_PDU_t* handoverNotifyPdu;
Ngap_HandoverNotify_t* handoverNotifyIEs;
AMF_UE_NGAP_ID* amfUeNgapId;
RAN_UE_NGAP_ID* ranUeNgapId;
UserLocationInformation* userLocationInformation;
};
private:
Ngap_NGAP_PDU_t *handoverNotifyPdu;
Ngap_HandoverNotify_t *handoverNotifyIEs;
AMF_UE_NGAP_ID *amfUeNgapId;
RAN_UE_NGAP_ID *ranUeNgapId;
UserLocationInformation *userLocationInformation;
};
}
} // namespace ngap
#endif
This diff is collapsed.
#ifndef _HANDOVERREQUESTACK_H_
#define _HANDOVERREQUESTACK_H_
#include "AMF-UE-NGAP-ID.hpp"
#include "Cause.hpp"
#include "DefaultPagingDRX.hpp"
#include "GlobalRanNodeId.hpp"
#include "MessageType.hpp"
#include "NgapIEsStruct.hpp"
#include "PDUSessionResourceAdmittedItem.hpp"
#include "PDUSessionResourceAdmittedList.hpp"
#include "MessageType.hpp"
#include "GlobalRanNodeId.hpp"
#include "RAN-UE-NGAP-ID.hpp"
#include "RanNodeName.hpp"
#include "DefaultPagingDRX.hpp"
#include "SupportedTAList.hpp"
#include "AMF-UE-NGAP-ID.hpp"
#include "RAN-UE-NGAP-ID.hpp"
#include "Cause.hpp"
extern "C" {
#include "Ngap_HandoverRequestAcknowledgeTransfer.h"
#include "Ngap_NGAP-PDU.h"
#include "Ngap_ProtocolIE-Field.h"
#include "Ngap_NGSetupRequest.h"
#include "Ngap_PDUSessionResourceAdmittedItem.h"
#include "Ngap_HandoverRequestAcknowledgeTransfer.h"
#include <netinet/in.h>
#include "Ngap_ProtocolIE-Field.h"
#include <arpa/inet.h>
#include <netinet/in.h>
}
namespace ngap {
class HandoverRequestAck {
public:
HandoverRequestAck();
virtual ~HandoverRequestAck();
int encode2buffer(uint8_t* buf, int buf_size);
bool decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu);
class HandoverRequestAck {
public:
HandoverRequestAck();
virtual ~HandoverRequestAck();
unsigned long getAmfUeNgapId();//return -1;(不存在)
uint32_t getRanUeNgapId();//return -1;(不存在)
int encode2buffer(uint8_t *buf, int buf_size);
bool decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu);
void setMessageType(); //Initialize the PDU and populate the MessageType;
OCTET_STRING_t getTargetToSource_TransparentContainer();
bool getPDUSessionResourceAdmittedList(std::vector<PDUSessionResourceAdmittedItem_t>& list);
unsigned long getAmfUeNgapId(); // return -1;(不存在)
uint32_t getRanUeNgapId(); // return -1;(不存在)
// void setMessageType(); //Initialize the PDU and populate the MessageType;
// void setAmfUeNgapId(unsigned long id);//40 bits
// void setRanUeNgapId(uint32_t id);// 32 bits
void setMessageType(); // Initialize the PDU and populate the MessageType;
OCTET_STRING_t getTargetToSource_TransparentContainer();
bool getPDUSessionResourceAdmittedList(
std::vector<PDUSessionResourceAdmittedItem_t> &list);
// void setPDUSessionResourceAdmittedList(std::vector<Ngap_PDUSessionResourceAdmittedItem_t> list);
// void setTargetToSource_TransparentContainer(OCTET_STRING_t targetTosource);
private:
Ngap_NGAP_PDU_t *handoverRequestAckPdu;
Ngap_HandoverRequestAcknowledge_t *handoverRequestAckIEs;
/***************** for decoding ****************/
AMF_UE_NGAP_ID *amfUeNgapId;
RAN_UE_NGAP_ID *ranUeNgapId;
Ngap_HandoverType_t* handovertype;
private:
Ngap_NGAP_PDU_t *handoverRequestAckPdu;
Ngap_HandoverRequestAcknowledge_t *handoverRequestAckIEs;
/***************** for decoding ****************/
AMF_UE_NGAP_ID *amfUeNgapId;
RAN_UE_NGAP_ID *ranUeNgapId;
Ngap_HandoverType_t *handovertype;
PDUSessionResourceAdmittedList *pduSessionResourceAdmittedList;
Ngap_PDUSessionResourceFailedToSetupListHOAck_t *PDUSessionResourceFailedToSetupList;
Ngap_TargetToSource_TransparentContainer_t *TargetToSource_TransparentContainer;
Ngap_CriticalityDiagnostics_t *CriticalityDiagnostics;
};
PDUSessionResourceAdmittedList *pduSessionResourceAdmittedList;
Ngap_PDUSessionResourceFailedToSetupListHOAck_t
*PDUSessionResourceFailedToSetupList;
Ngap_TargetToSource_TransparentContainer_t
*TargetToSource_TransparentContainer;
Ngap_CriticalityDiagnostics_t *CriticalityDiagnostics;
};
}
} // namespace ngap
#endif
This diff is collapsed.
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment