2020-04-26 19:36:05 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2019 by Sukchan Lee <acetcom@gmail.com>
|
|
|
|
*
|
|
|
|
* This file is part of Open5GS.
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "context.h"
|
|
|
|
#include "n4-build.h"
|
|
|
|
|
|
|
|
ogs_pkbuf_t *smf_n4_build_association_setup_request(uint8_t type)
|
|
|
|
{
|
|
|
|
ogs_pfcp_message_t pfcp_message;
|
|
|
|
ogs_pfcp_association_setup_request_t *req = NULL;
|
|
|
|
|
|
|
|
ogs_pfcp_node_id_t node_id;
|
|
|
|
int node_id_len = 0;
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
ogs_debug("Association Setup Request");
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
req = &pfcp_message.pfcp_association_setup_request;
|
|
|
|
memset(&pfcp_message, 0, sizeof(ogs_pfcp_message_t));
|
|
|
|
|
|
|
|
ogs_pfcp_sockaddr_to_node_id(
|
|
|
|
ogs_pfcp_self()->pfcp_addr, ogs_pfcp_self()->pfcp_addr6,
|
|
|
|
ogs_config()->parameter.prefer_ipv4,
|
|
|
|
&node_id, &node_id_len);
|
|
|
|
req->node_id.presence = 1;
|
|
|
|
req->node_id.data = &node_id;
|
|
|
|
req->node_id.len = node_id_len;
|
|
|
|
|
|
|
|
req->recovery_time_stamp.presence = 1;
|
|
|
|
req->recovery_time_stamp.u32 = ogs_pfcp_self()->pfcp_started;
|
|
|
|
|
|
|
|
req->cp_function_features.presence = 1;
|
|
|
|
req->cp_function_features.u8 = smf_self()->function_features;
|
|
|
|
|
|
|
|
pfcp_message.h.type = type;
|
|
|
|
return ogs_pfcp_build_msg(&pfcp_message);
|
|
|
|
}
|
|
|
|
|
|
|
|
ogs_pkbuf_t *smf_n4_build_association_setup_response(uint8_t type,
|
|
|
|
uint8_t cause)
|
|
|
|
{
|
|
|
|
ogs_pfcp_message_t pfcp_message;
|
|
|
|
ogs_pfcp_association_setup_response_t *rsp = NULL;
|
|
|
|
|
|
|
|
ogs_pfcp_node_id_t node_id;
|
|
|
|
int node_id_len = 0;
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
ogs_debug("Association Setup Response");
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
rsp = &pfcp_message.pfcp_association_setup_response;
|
|
|
|
memset(&pfcp_message, 0, sizeof(ogs_pfcp_message_t));
|
|
|
|
|
|
|
|
ogs_pfcp_sockaddr_to_node_id(
|
|
|
|
ogs_pfcp_self()->pfcp_addr, ogs_pfcp_self()->pfcp_addr6,
|
|
|
|
ogs_config()->parameter.prefer_ipv4,
|
|
|
|
&node_id, &node_id_len);
|
|
|
|
rsp->node_id.presence = 1;
|
|
|
|
rsp->node_id.data = &node_id;
|
|
|
|
rsp->node_id.len = node_id_len;
|
|
|
|
|
|
|
|
rsp->cause.presence = 1;
|
|
|
|
rsp->cause.u8 = cause;
|
|
|
|
|
|
|
|
rsp->recovery_time_stamp.presence = 1;
|
|
|
|
rsp->recovery_time_stamp.u32 = ogs_pfcp_self()->pfcp_started;
|
|
|
|
|
|
|
|
rsp->cp_function_features.presence = 1;
|
|
|
|
rsp->cp_function_features.u8 = smf_self()->function_features;
|
|
|
|
|
|
|
|
pfcp_message.h.type = type;
|
|
|
|
return ogs_pfcp_build_msg(&pfcp_message);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
ogs_pfcp_ue_ip_addr_t addr;
|
|
|
|
ogs_pfcp_outer_header_removal_t outer_header_removal;
|
|
|
|
ogs_pfcp_f_teid_t f_teid;
|
2020-06-18 01:43:16 +00:00
|
|
|
char dnn[OGS_MAX_DNN_LEN];
|
2020-04-26 19:36:05 +00:00
|
|
|
char *sdf_filter[OGS_MAX_NUM_OF_RULE];
|
2020-06-17 05:22:28 +00:00
|
|
|
} pdrbuf[OGS_MAX_NUM_OF_PDR];
|
2020-04-26 19:36:05 +00:00
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
static void pdrbuf_init(void)
|
2020-04-26 19:36:05 +00:00
|
|
|
{
|
2020-06-17 05:22:28 +00:00
|
|
|
memset(pdrbuf, 0, sizeof(pdrbuf));
|
2020-04-26 19:36:05 +00:00
|
|
|
}
|
2020-06-17 05:22:28 +00:00
|
|
|
static void pdrbuf_clear(void)
|
2020-04-26 19:36:05 +00:00
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
for (i = 0; i < OGS_MAX_NUM_OF_PDR; i++) {
|
|
|
|
for (j = 0; j < OGS_MAX_NUM_OF_RULE; j++) {
|
2020-06-17 05:22:28 +00:00
|
|
|
if (pdrbuf[i].sdf_filter[j])
|
|
|
|
ogs_free(pdrbuf[i].sdf_filter[j]);
|
2020-04-26 19:36:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void build_create_pdr(
|
|
|
|
ogs_pfcp_tlv_create_pdr_t *message, int i, ogs_pfcp_pdr_t *pdr)
|
|
|
|
{
|
|
|
|
ogs_pfcp_far_t *far = NULL;
|
|
|
|
ogs_pfcp_sess_t *pfcp_sess = NULL;
|
|
|
|
smf_sess_t *sess = NULL;
|
|
|
|
smf_bearer_t *bearer = NULL;
|
|
|
|
int j = 0;
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
ogs_assert(message);
|
|
|
|
|
|
|
|
ogs_assert(pdr);
|
|
|
|
pfcp_sess = pdr->sess;
|
|
|
|
ogs_assert(pfcp_sess);
|
|
|
|
bearer = SMF_BEARER(pfcp_sess);
|
|
|
|
ogs_assert(bearer);
|
|
|
|
sess = bearer->sess;
|
|
|
|
ogs_assert(sess);
|
|
|
|
|
|
|
|
far = pdr->far;
|
|
|
|
ogs_assert(far);
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->pdr_id.presence = 1;
|
|
|
|
message->pdr_id.u16 = pdr->id;
|
|
|
|
|
|
|
|
message->precedence.presence = 1;
|
|
|
|
message->precedence.u32 = pdr->precedence;
|
|
|
|
|
|
|
|
message->pdi.presence = 1;
|
|
|
|
message->pdi.source_interface.presence = 1;
|
|
|
|
message->pdi.source_interface.u8 = pdr->src_if;
|
|
|
|
|
|
|
|
message->pdi.network_instance.presence = 1;
|
|
|
|
message->pdi.network_instance.len = ogs_fqdn_build(
|
2020-06-18 01:43:16 +00:00
|
|
|
pdrbuf[i].dnn, sess->pdn.dnn, strlen(sess->pdn.dnn));
|
|
|
|
message->pdi.network_instance.data = pdrbuf[i].dnn;
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
for (j = 0; j < pdr->num_of_flow; j++) {
|
|
|
|
ogs_pfcp_sdf_filter_t pfcp_sdf_filter[OGS_MAX_NUM_OF_RULE];
|
|
|
|
pfcp_sdf_filter[j].fd = 1;
|
|
|
|
pfcp_sdf_filter[j].flow_description_len =
|
|
|
|
strlen(pdr->flow_description[j]);
|
|
|
|
pfcp_sdf_filter[j].flow_description = pdr->flow_description[j];
|
|
|
|
len = sizeof(ogs_pfcp_sdf_filter_t) +
|
|
|
|
pfcp_sdf_filter[j].flow_description_len;
|
|
|
|
|
|
|
|
message->pdi.sdf_filter[j].presence = 1;
|
2020-06-17 05:22:28 +00:00
|
|
|
pdrbuf[i].sdf_filter[j] = ogs_calloc(1, len);
|
2020-04-26 19:36:05 +00:00
|
|
|
ogs_pfcp_build_sdf_filter(&message->pdi.sdf_filter[j],
|
2020-06-17 05:22:28 +00:00
|
|
|
&pfcp_sdf_filter[j], pdrbuf[i].sdf_filter[j], len);
|
2020-04-26 19:36:05 +00:00
|
|
|
}
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
if (pdr->src_if == OGS_PFCP_INTERFACE_CORE) { /* Downlink */
|
2020-04-26 19:36:05 +00:00
|
|
|
if (smf_bearer_is_default(bearer)) { /* Default Bearer */
|
|
|
|
ogs_pfcp_paa_to_ue_ip_addr(&sess->pdn.paa,
|
2020-06-17 05:22:28 +00:00
|
|
|
&pdrbuf[i].addr, &len);
|
|
|
|
pdrbuf[i].addr.sd = OGS_PFCP_UE_IP_DST;
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
message->pdi.ue_ip_address.presence = 1;
|
2020-06-17 05:22:28 +00:00
|
|
|
message->pdi.ue_ip_address.data = &pdrbuf[i].addr;
|
2020-04-26 19:36:05 +00:00
|
|
|
message->pdi.ue_ip_address.len = len;
|
|
|
|
}
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
} else if (pdr->src_if == OGS_PFCP_INTERFACE_ACCESS) { /* Uplink */
|
2020-04-26 19:36:05 +00:00
|
|
|
ogs_pfcp_sockaddr_to_f_teid(
|
|
|
|
bearer->upf_addr, bearer->upf_addr6,
|
2020-06-17 05:22:28 +00:00
|
|
|
&pdrbuf[i].f_teid, &len);
|
|
|
|
pdrbuf[i].f_teid.teid = htobe32(bearer->upf_n3_teid);
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
message->pdi.local_f_teid.presence = 1;
|
2020-06-17 05:22:28 +00:00
|
|
|
message->pdi.local_f_teid.data = &pdrbuf[i].f_teid;
|
2020-04-26 19:36:05 +00:00
|
|
|
message->pdi.local_f_teid.len = len;
|
|
|
|
|
|
|
|
if (sess->pdn.paa.pdn_type == OGS_GTP_PDN_TYPE_IPV4) {
|
2020-06-17 05:22:28 +00:00
|
|
|
pdrbuf[i].outer_header_removal.description =
|
2020-04-26 19:36:05 +00:00
|
|
|
OGS_PFCP_OUTER_HEADER_REMOVAL_GTPU_UDP_IPV4;
|
|
|
|
} else if (sess->pdn.paa.pdn_type == OGS_GTP_PDN_TYPE_IPV6) {
|
2020-06-17 05:22:28 +00:00
|
|
|
pdrbuf[i].outer_header_removal.description =
|
2020-04-26 19:36:05 +00:00
|
|
|
OGS_PFCP_OUTER_HEADER_REMOVAL_GTPU_UDP_IPV6;
|
|
|
|
} else if (sess->pdn.paa.pdn_type == OGS_GTP_PDN_TYPE_IPV4V6) {
|
2020-06-17 05:22:28 +00:00
|
|
|
pdrbuf[i].outer_header_removal.description =
|
2020-04-26 19:36:05 +00:00
|
|
|
OGS_PFCP_OUTER_HEADER_REMOVAL_GTPU_UDP_IP;
|
|
|
|
} else
|
|
|
|
ogs_assert_if_reached();
|
|
|
|
|
|
|
|
message->outer_header_removal.presence = 1;
|
|
|
|
message->outer_header_removal.data =
|
2020-06-17 05:22:28 +00:00
|
|
|
&pdrbuf[i].outer_header_removal.description;
|
2020-04-26 19:36:05 +00:00
|
|
|
message->outer_header_removal.len = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdr->far) {
|
|
|
|
message->far_id.presence = 1;
|
|
|
|
message->far_id.u32 = pdr->far->id;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdr->urr) {
|
|
|
|
message->urr_id.presence = 1;
|
|
|
|
message->urr_id.u32 = pdr->urr->id;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdr->qer) {
|
|
|
|
message->qer_id.presence = 1;
|
|
|
|
message->qer_id.u32 = pdr->qer->id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
ogs_pfcp_outer_header_creation_t outer_header_creation;
|
2020-06-17 05:22:28 +00:00
|
|
|
} farbuf[OGS_MAX_NUM_OF_FAR];
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
static void build_create_far(
|
|
|
|
ogs_pfcp_tlv_create_far_t *message, int i, ogs_pfcp_far_t *far)
|
|
|
|
{
|
|
|
|
ogs_pfcp_sess_t *pfcp_sess = NULL;
|
|
|
|
smf_bearer_t *bearer = NULL;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
ogs_assert(message);
|
|
|
|
ogs_assert(far);
|
|
|
|
pfcp_sess = far->sess;
|
|
|
|
ogs_assert(pfcp_sess);
|
|
|
|
bearer = SMF_BEARER(pfcp_sess);
|
|
|
|
ogs_assert(bearer);
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->far_id.presence = 1;
|
|
|
|
message->far_id.u32 = far->id;
|
|
|
|
|
|
|
|
message->apply_action.presence = 1;
|
|
|
|
message->apply_action.u8 = far->apply_action;
|
|
|
|
|
|
|
|
message->forwarding_parameters.presence = 1;
|
|
|
|
message->forwarding_parameters.destination_interface.presence = 1;
|
2020-06-17 05:22:28 +00:00
|
|
|
message->forwarding_parameters.destination_interface.u8 =
|
|
|
|
far->dst_if;
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
if (far->dst_if == OGS_PFCP_INTERFACE_ACCESS) { /* Downlink */
|
2020-06-17 05:22:28 +00:00
|
|
|
if (bearer->gnb_ip.ipv4 || bearer->gnb_ip.ipv6) {
|
|
|
|
ogs_pfcp_ip_to_outer_header_creation(&bearer->gnb_ip,
|
|
|
|
&farbuf[i].outer_header_creation, &len);
|
|
|
|
farbuf[i].outer_header_creation.teid =
|
|
|
|
htobe32(bearer->gnb_n3_teid);
|
|
|
|
|
|
|
|
message->forwarding_parameters.outer_header_creation.presence = 1;
|
|
|
|
message->forwarding_parameters.outer_header_creation.data =
|
|
|
|
&farbuf[i].outer_header_creation;
|
|
|
|
message->forwarding_parameters.outer_header_creation.len = len;
|
|
|
|
}
|
2020-04-26 19:36:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void build_create_urr(
|
|
|
|
ogs_pfcp_tlv_create_urr_t *message, int i, ogs_pfcp_urr_t *urr)
|
|
|
|
{
|
|
|
|
ogs_assert(message);
|
|
|
|
ogs_assert(urr);
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->urr_id.presence = 1;
|
|
|
|
message->urr_id.u32 = urr->id;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
char mbr[OGS_PFCP_BITRATE_LEN];
|
|
|
|
char gbr[OGS_PFCP_BITRATE_LEN];
|
|
|
|
} create_qer_buf[OGS_MAX_NUM_OF_QER], update_qer_buf[OGS_MAX_NUM_OF_QER];
|
|
|
|
|
|
|
|
static void build_create_qer(
|
|
|
|
ogs_pfcp_tlv_create_qer_t *message, int i, ogs_pfcp_qer_t *qer)
|
|
|
|
{
|
|
|
|
ogs_assert(message);
|
|
|
|
ogs_assert(qer);
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->qer_id.presence = 1;
|
|
|
|
message->qer_id.u32 = qer->id;
|
|
|
|
|
|
|
|
message->gate_status.presence = 1;
|
|
|
|
message->gate_status.u8 = qer->gate_status.value;
|
|
|
|
|
|
|
|
if (qer->mbr.uplink || qer->mbr.downlink) {
|
|
|
|
message->maximum_bitrate.presence = 1;
|
|
|
|
ogs_pfcp_build_bitrate(
|
|
|
|
&message->maximum_bitrate,
|
|
|
|
&qer->mbr, create_qer_buf[i].mbr, OGS_PFCP_BITRATE_LEN);
|
|
|
|
}
|
|
|
|
if (qer->gbr.uplink || qer->gbr.downlink) {
|
|
|
|
message->guaranteed_bitrate.presence = 1;
|
|
|
|
ogs_pfcp_build_bitrate(
|
|
|
|
&message->guaranteed_bitrate,
|
|
|
|
&qer->gbr, create_qer_buf[i].gbr, OGS_PFCP_BITRATE_LEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void build_update_qer(
|
|
|
|
ogs_pfcp_tlv_update_qer_t *message, int i, ogs_pfcp_qer_t *qer)
|
|
|
|
{
|
|
|
|
ogs_assert(message);
|
|
|
|
ogs_assert(qer);
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->qer_id.presence = 1;
|
|
|
|
message->qer_id.u32 = qer->id;
|
|
|
|
|
|
|
|
if (qer->mbr.uplink || qer->mbr.downlink) {
|
|
|
|
message->maximum_bitrate.presence = 1;
|
|
|
|
ogs_pfcp_build_bitrate(
|
|
|
|
&message->maximum_bitrate,
|
|
|
|
&qer->mbr, update_qer_buf[i].mbr, OGS_PFCP_BITRATE_LEN);
|
|
|
|
}
|
|
|
|
if (qer->gbr.uplink || qer->gbr.downlink) {
|
|
|
|
message->guaranteed_bitrate.presence = 1;
|
|
|
|
ogs_pfcp_build_bitrate(
|
|
|
|
&message->guaranteed_bitrate,
|
|
|
|
&qer->gbr, update_qer_buf[i].gbr, OGS_PFCP_BITRATE_LEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
static void build_update_outer_header_creation(
|
|
|
|
ogs_pfcp_tlv_update_far_t *message, int i, ogs_pfcp_far_t *far)
|
|
|
|
{
|
|
|
|
ogs_pfcp_sess_t *pfcp_sess = NULL;
|
|
|
|
smf_bearer_t *bearer = NULL;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
ogs_assert(message);
|
|
|
|
ogs_assert(far);
|
|
|
|
pfcp_sess = far->sess;
|
|
|
|
ogs_assert(pfcp_sess);
|
|
|
|
bearer = SMF_BEARER(pfcp_sess);
|
|
|
|
ogs_assert(bearer);
|
|
|
|
|
|
|
|
ogs_assert(far->dst_if == OGS_PFCP_INTERFACE_ACCESS);
|
|
|
|
ogs_assert(bearer->gnb_ip.ipv4 || bearer->gnb_ip.ipv6);
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->far_id.presence = 1;
|
|
|
|
message->far_id.u32 = far->id;
|
|
|
|
|
|
|
|
ogs_pfcp_ip_to_outer_header_creation(&bearer->gnb_ip,
|
|
|
|
&farbuf[i].outer_header_creation, &len);
|
|
|
|
farbuf[i].outer_header_creation.teid =
|
|
|
|
htobe32(bearer->gnb_n3_teid);
|
|
|
|
|
|
|
|
message->update_forwarding_parameters.presence = 1;
|
|
|
|
message->update_forwarding_parameters.outer_header_creation.presence = 1;
|
|
|
|
message->update_forwarding_parameters.outer_header_creation.data =
|
|
|
|
&farbuf[i].outer_header_creation;
|
|
|
|
message->update_forwarding_parameters.outer_header_creation.len = len;
|
|
|
|
}
|
|
|
|
|
2020-04-26 19:36:05 +00:00
|
|
|
ogs_pkbuf_t *smf_n4_build_session_establishment_request(
|
|
|
|
uint8_t type, smf_sess_t *sess)
|
|
|
|
{
|
|
|
|
ogs_pfcp_message_t pfcp_message;
|
|
|
|
ogs_pfcp_session_establishment_request_t *req = NULL;
|
|
|
|
ogs_pkbuf_t *pkbuf = NULL;
|
|
|
|
|
|
|
|
smf_bearer_t *bearer = NULL;
|
|
|
|
|
|
|
|
ogs_pfcp_pdr_t *pdr = NULL;
|
|
|
|
ogs_pfcp_far_t *far = NULL;
|
|
|
|
ogs_pfcp_urr_t *urr = NULL;
|
|
|
|
ogs_pfcp_qer_t *qer = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ogs_pfcp_node_id_t node_id;
|
|
|
|
ogs_pfcp_f_seid_t f_seid;
|
|
|
|
int len;
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
ogs_debug("Session Establishment Request");
|
2020-04-26 19:36:05 +00:00
|
|
|
ogs_assert(sess);
|
|
|
|
|
|
|
|
req = &pfcp_message.pfcp_session_establishment_request;
|
|
|
|
memset(&pfcp_message, 0, sizeof(ogs_pfcp_message_t));
|
|
|
|
|
|
|
|
/* Node ID */
|
|
|
|
ogs_pfcp_sockaddr_to_node_id(
|
|
|
|
ogs_pfcp_self()->pfcp_addr, ogs_pfcp_self()->pfcp_addr6,
|
|
|
|
ogs_config()->parameter.prefer_ipv4,
|
|
|
|
&node_id, &len);
|
|
|
|
req->node_id.presence = 1;
|
|
|
|
req->node_id.data = &node_id;
|
|
|
|
req->node_id.len = len;
|
|
|
|
|
|
|
|
/* F-SEID */
|
|
|
|
ogs_pfcp_sockaddr_to_f_seid(
|
|
|
|
ogs_pfcp_self()->pfcp_addr, ogs_pfcp_self()->pfcp_addr6,
|
|
|
|
&f_seid, &len);
|
|
|
|
f_seid.seid = htobe64(sess->smf_n4_seid);
|
|
|
|
req->cp_f_seid.presence = 1;
|
|
|
|
req->cp_f_seid.data = &f_seid;
|
|
|
|
req->cp_f_seid.len = len;
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
pdrbuf_init();
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
/* Create PDR */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&sess->bearer_list, bearer) {
|
|
|
|
ogs_list_for_each(&bearer->pfcp.pdr_list, pdr) {
|
|
|
|
build_create_pdr(&req->create_pdr[i], i, pdr);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create FAR */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&sess->bearer_list, bearer) {
|
|
|
|
ogs_list_for_each(&bearer->pfcp.far_list, far) {
|
|
|
|
build_create_far(&req->create_far[i], i, far);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create URR */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&sess->bearer_list, bearer) {
|
|
|
|
ogs_list_for_each(&bearer->pfcp.urr_list, urr) {
|
|
|
|
build_create_urr(&req->create_urr[i], i, urr);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create QER */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&sess->bearer_list, bearer) {
|
|
|
|
ogs_list_for_each(&bearer->pfcp.qer_list, qer) {
|
|
|
|
build_create_qer(&req->create_qer[i], i, qer);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PDN Type */
|
|
|
|
req->pdn_type.presence = 1;
|
|
|
|
req->pdn_type.u8 = sess->pdn.paa.pdn_type;
|
|
|
|
|
|
|
|
pfcp_message.h.type = type;
|
|
|
|
pkbuf = ogs_pfcp_build_msg(&pfcp_message);
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
pdrbuf_clear();
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
return pkbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
ogs_pkbuf_t *smf_n4_build_session_modification_request(
|
|
|
|
uint8_t type, smf_bearer_t *bearer)
|
|
|
|
{
|
|
|
|
ogs_pfcp_message_t pfcp_message;
|
|
|
|
ogs_pfcp_session_modification_request_t *req = NULL;
|
|
|
|
ogs_pfcp_pdr_t *pdr = NULL;
|
|
|
|
ogs_pfcp_far_t *far = NULL;
|
|
|
|
ogs_pfcp_qer_t *qer = NULL;
|
|
|
|
ogs_pkbuf_t *pkbuf = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
smf_sess_t *sess = NULL;
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
ogs_debug("Session Modification Request");
|
2020-04-26 19:36:05 +00:00
|
|
|
ogs_assert(bearer);
|
|
|
|
sess = bearer->sess;
|
|
|
|
ogs_assert(sess);
|
|
|
|
|
|
|
|
req = &pfcp_message.pfcp_session_modification_request;
|
|
|
|
memset(&pfcp_message, 0, sizeof(ogs_pfcp_message_t));
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
if (!bearer->state.created &&
|
|
|
|
!bearer->state.tft_updated &&
|
|
|
|
!bearer->state.qos_updated &&
|
|
|
|
!bearer->state.outer_header_creation_updated &&
|
|
|
|
!bearer->state.removed) {
|
|
|
|
ogs_error("No Session Modification");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-04-26 19:36:05 +00:00
|
|
|
if (bearer->state.removed) {
|
|
|
|
/* Remove PDR */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&bearer->pfcp.pdr_list, pdr) {
|
|
|
|
ogs_pfcp_tlv_remove_pdr_t *message = &req->remove_pdr[i];
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->pdr_id.presence = 1;
|
|
|
|
message->pdr_id.u16 = pdr->id;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove FAR */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&bearer->pfcp.far_list, far) {
|
|
|
|
ogs_pfcp_tlv_remove_far_t *message = &req->remove_far[i];
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->far_id.presence = 1;
|
|
|
|
message->far_id.u32 = far->id;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove QER */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&bearer->pfcp.qer_list, qer) {
|
|
|
|
ogs_pfcp_tlv_remove_qer_t *message = &req->remove_qer[i];
|
|
|
|
|
|
|
|
message->presence = 1;
|
|
|
|
message->qer_id.presence = 1;
|
|
|
|
message->qer_id.u32 = qer->id;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (bearer->state.created) {
|
2020-06-17 05:22:28 +00:00
|
|
|
pdrbuf_init();
|
2020-04-26 19:36:05 +00:00
|
|
|
|
|
|
|
/* Create PDR */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&bearer->pfcp.pdr_list, pdr) {
|
|
|
|
build_create_pdr(&req->create_pdr[i], i, pdr);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create FAR */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&bearer->pfcp.far_list, far) {
|
|
|
|
build_create_far(&req->create_far[i], i, far);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create QER */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&bearer->pfcp.qer_list, qer) {
|
|
|
|
build_create_qer(&req->create_qer[i], i, qer);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bearer->state.qos_updated) {
|
|
|
|
/* Update QER */
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&bearer->pfcp.qer_list, qer) {
|
|
|
|
build_update_qer(&req->update_qer[i], i, qer);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
2020-06-17 05:22:28 +00:00
|
|
|
if (bearer->state.outer_header_creation_updated) {
|
|
|
|
i = 0;
|
|
|
|
ogs_list_for_each(&bearer->pfcp.far_list, far) {
|
|
|
|
if (far->dst_if == OGS_PFCP_INTERFACE_ACCESS)
|
|
|
|
build_update_outer_header_creation(
|
|
|
|
&req->update_far[i], i, far);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
2020-04-26 19:36:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pfcp_message.h.type = type;
|
|
|
|
pkbuf = ogs_pfcp_build_msg(&pfcp_message);
|
|
|
|
|
|
|
|
if (bearer->state.created) {
|
2020-06-17 05:22:28 +00:00
|
|
|
pdrbuf_clear();
|
2020-04-26 19:36:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return pkbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
ogs_pkbuf_t *smf_n4_build_session_deletion_request(
|
|
|
|
uint8_t type, smf_sess_t *sess)
|
|
|
|
{
|
|
|
|
ogs_pfcp_message_t pfcp_message;
|
|
|
|
|
2020-06-17 05:22:28 +00:00
|
|
|
ogs_debug("Session Deletion Request");
|
2020-04-26 19:36:05 +00:00
|
|
|
ogs_assert(sess);
|
|
|
|
|
|
|
|
pfcp_message.h.type = type;
|
|
|
|
return ogs_pfcp_build_msg(&pfcp_message);
|
|
|
|
}
|