forked from acouzens/open5gs
645 lines
21 KiB
C
645 lines
21 KiB
C
/*
|
|
* Copyright (C) 2023 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 "sbi-path.h"
|
|
#include "n32c-handler.h"
|
|
|
|
void sepp_handshake_fsm_init(sepp_node_t *sepp_node, bool try_to_establish)
|
|
{
|
|
sepp_event_t e;
|
|
|
|
ogs_assert(sepp_node);
|
|
|
|
memset(&e, 0, sizeof(e));
|
|
e.sepp_node = sepp_node;
|
|
|
|
if (try_to_establish == true) {
|
|
sepp_node->t_establish_interval = ogs_timer_add(ogs_app()->timer_mgr,
|
|
sepp_timer_peer_establish, sepp_node);
|
|
ogs_assert(sepp_node->t_establish_interval);
|
|
}
|
|
|
|
ogs_fsm_init(&sepp_node->sm,
|
|
sepp_handshake_state_initial, sepp_handshake_state_final, &e);
|
|
}
|
|
|
|
void sepp_handshake_fsm_fini(sepp_node_t *sepp_node)
|
|
{
|
|
sepp_event_t e;
|
|
|
|
ogs_assert(sepp_node);
|
|
|
|
memset(&e, 0, sizeof(e));
|
|
e.sepp_node = sepp_node;
|
|
|
|
if (OGS_FSM_CHECK(&sepp_node->sm, sepp_handshake_state_established)) {
|
|
ogs_expect(true ==
|
|
sepp_n32c_handshake_send_security_capability_request(
|
|
sepp_node, true));
|
|
}
|
|
|
|
ogs_fsm_fini(&sepp_node->sm, &e);
|
|
|
|
if (sepp_node->t_establish_interval)
|
|
ogs_timer_delete(sepp_node->t_establish_interval);
|
|
}
|
|
|
|
void sepp_handshake_state_initial(ogs_fsm_t *s, sepp_event_t *e)
|
|
{
|
|
sepp_node_t *sepp_node = NULL;
|
|
|
|
ogs_assert(s);
|
|
ogs_assert(e);
|
|
|
|
sepp_node = e->sepp_node;
|
|
ogs_assert(sepp_node);
|
|
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_will_establish);
|
|
}
|
|
|
|
void sepp_handshake_state_final(ogs_fsm_t *s, sepp_event_t *e)
|
|
{
|
|
ogs_assert(s);
|
|
ogs_assert(e);
|
|
|
|
sepp_sm_debug(e);
|
|
}
|
|
|
|
void sepp_handshake_state_will_establish(ogs_fsm_t *s, sepp_event_t *e)
|
|
{
|
|
bool handled;
|
|
sepp_node_t *sepp_node = NULL;
|
|
|
|
ogs_sbi_stream_t *stream = NULL;
|
|
ogs_sbi_message_t *message = NULL;
|
|
|
|
ogs_assert(s);
|
|
ogs_assert(e);
|
|
|
|
sepp_sm_debug(e);
|
|
|
|
sepp_node = e->sepp_node;
|
|
ogs_assert(sepp_node);
|
|
|
|
switch (e->h.id) {
|
|
case OGS_FSM_ENTRY_SIG:
|
|
if (sepp_node->t_establish_interval) {
|
|
ogs_timer_start(sepp_node->t_establish_interval,
|
|
ogs_local_conf()->time.message.sbi.reconnect_interval);
|
|
|
|
ogs_expect(true ==
|
|
sepp_n32c_handshake_send_security_capability_request(
|
|
sepp_node, false));
|
|
}
|
|
break;
|
|
|
|
case OGS_FSM_EXIT_SIG:
|
|
if (sepp_node->t_establish_interval) {
|
|
ogs_timer_stop(sepp_node->t_establish_interval);
|
|
}
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_SERVER:
|
|
message = e->h.sbi.message;
|
|
ogs_assert(message);
|
|
stream = e->h.sbi.data;
|
|
ogs_assert(stream);
|
|
|
|
SWITCH(message->h.service.name)
|
|
CASE(OGS_SBI_SERVICE_NAME_N32C_HANDSHAKE)
|
|
SWITCH(message->h.resource.component[0])
|
|
CASE(OGS_SBI_RESOURCE_NAME_EXCHANGE_CAPABILITY)
|
|
SWITCH(message->h.method)
|
|
CASE(OGS_SBI_HTTP_METHOD_POST)
|
|
handled =
|
|
sepp_n32c_handshake_handle_security_capability_request(
|
|
sepp_node, stream, message);
|
|
if (!handled) {
|
|
ogs_error("[%s] Cannot handle SBI message",
|
|
sepp_node->receiver);
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_exception);
|
|
break;
|
|
}
|
|
|
|
if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_TLS) {
|
|
|
|
/* Change to ESTABLISHED */
|
|
sepp_n32c_handshake_send_security_capability_response(
|
|
sepp_node, stream);
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_established);
|
|
|
|
} else if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_PRINS) {
|
|
|
|
ogs_error("[%s] PRINS is not supported",
|
|
sepp_node->receiver);
|
|
ogs_assert(true ==
|
|
ogs_sbi_server_send_error(stream,
|
|
OGS_SBI_HTTP_STATUS_BAD_REQUEST,
|
|
message, "PRINS is not supported",
|
|
sepp_node->receiver, NULL));
|
|
|
|
} else if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_NONE) {
|
|
|
|
/* No State Change */
|
|
sepp_n32c_handshake_send_security_capability_response(
|
|
sepp_node, stream);
|
|
ogs_warn("[%s] SEPP has not been established",
|
|
sepp_node->receiver);
|
|
}
|
|
break;
|
|
DEFAULT
|
|
ogs_error("Invalid HTTP method [%s]", message->h.method);
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid resource name [%s]",
|
|
sepp_node->receiver, message->h.resource.component[0]);
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid API name [%s]",
|
|
sepp_node->receiver, message->h.service.name);
|
|
END
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_CLIENT:
|
|
message = e->h.sbi.message;
|
|
ogs_assert(message);
|
|
|
|
SWITCH(message->h.service.name)
|
|
CASE(OGS_SBI_SERVICE_NAME_N32C_HANDSHAKE)
|
|
SWITCH(message->h.resource.component[0])
|
|
CASE(OGS_SBI_RESOURCE_NAME_EXCHANGE_CAPABILITY)
|
|
SWITCH(message->h.method)
|
|
CASE(OGS_SBI_HTTP_METHOD_POST)
|
|
|
|
if (message->res_status == OGS_SBI_HTTP_STATUS_OK) {
|
|
handled = sepp_n32c_handshake_handle_security_capability_response(
|
|
sepp_node, message);
|
|
if (!handled) {
|
|
ogs_error("[%s] Cannot handle SBI message",
|
|
sepp_node->receiver);
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_exception);
|
|
break;
|
|
}
|
|
|
|
if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_TLS) {
|
|
|
|
/* Change to ESTABLISHED */
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_established);
|
|
|
|
} else if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_PRINS) {
|
|
|
|
ogs_error("[%s] PRINS is not supported",
|
|
sepp_node->receiver);
|
|
|
|
} else if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_NONE) {
|
|
|
|
/* No State Change */
|
|
ogs_warn("[%s] SEPP has not been established",
|
|
sepp_node->receiver);
|
|
}
|
|
} else {
|
|
ogs_error("[%s] HTTP Response Status Code [%d]",
|
|
sepp_node->receiver, message->res_status);
|
|
}
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("Invalid HTTP method [%s]", message->h.method);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid resource name [%s]",
|
|
sepp_node->receiver, message->h.resource.component[0]);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid API name [%s]",
|
|
sepp_node->receiver, message->h.service.name);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_TIMER:
|
|
switch(e->h.timer_id) {
|
|
case SEPP_TIMER_PEER_ESTABLISH:
|
|
ogs_warn("[%s] Retry establishment with Peer SEPP",
|
|
sepp_node->receiver);
|
|
|
|
ogs_assert(sepp_node->t_establish_interval);
|
|
ogs_timer_start(sepp_node->t_establish_interval,
|
|
ogs_local_conf()->time.message.sbi.reconnect_interval);
|
|
|
|
ogs_expect(true ==
|
|
sepp_n32c_handshake_send_security_capability_request(
|
|
sepp_node, false));
|
|
break;
|
|
|
|
default:
|
|
ogs_error("Unknown timer[%s:%d]",
|
|
ogs_timer_get_name(e->h.timer_id), e->h.timer_id);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ogs_error("Unknown event %s", sepp_event_get_name(e));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void sepp_handshake_state_established(ogs_fsm_t *s, sepp_event_t *e)
|
|
{
|
|
bool handled;
|
|
sepp_node_t *sepp_node = NULL;
|
|
|
|
ogs_sbi_stream_t *stream = NULL;
|
|
ogs_sbi_message_t *message = NULL;
|
|
|
|
ogs_assert(s);
|
|
ogs_assert(e);
|
|
|
|
sepp_sm_debug(e);
|
|
|
|
sepp_node = e->sepp_node;
|
|
ogs_assert(sepp_node);
|
|
|
|
switch (e->h.id) {
|
|
case OGS_FSM_ENTRY_SIG:
|
|
ogs_info("[%s] SEPP established", sepp_node->receiver);
|
|
break;
|
|
|
|
case OGS_FSM_EXIT_SIG:
|
|
ogs_info("[%s] SEPP terminated", sepp_node->receiver);
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_SERVER:
|
|
message = e->h.sbi.message;
|
|
ogs_assert(message);
|
|
stream = e->h.sbi.data;
|
|
ogs_assert(stream);
|
|
|
|
SWITCH(message->h.service.name)
|
|
CASE(OGS_SBI_SERVICE_NAME_N32C_HANDSHAKE)
|
|
SWITCH(message->h.resource.component[0])
|
|
CASE(OGS_SBI_RESOURCE_NAME_EXCHANGE_CAPABILITY)
|
|
SWITCH(message->h.method)
|
|
CASE(OGS_SBI_HTTP_METHOD_POST)
|
|
handled =
|
|
sepp_n32c_handshake_handle_security_capability_request(
|
|
sepp_node, stream, message);
|
|
if (!handled) {
|
|
ogs_error("[%s] Cannot handle SBI message",
|
|
sepp_node->receiver);
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_exception);
|
|
break;
|
|
}
|
|
|
|
if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_TLS) {
|
|
|
|
/* No State Change */
|
|
sepp_n32c_handshake_send_security_capability_response(
|
|
sepp_node, stream);
|
|
ogs_warn("[%s] SEPP has already been established",
|
|
sepp_node->receiver);
|
|
|
|
} else if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_PRINS) {
|
|
|
|
ogs_error("[%s] PRINS is not supported",
|
|
sepp_node->receiver);
|
|
ogs_assert(true ==
|
|
ogs_sbi_server_send_error(stream,
|
|
OGS_SBI_HTTP_STATUS_BAD_REQUEST,
|
|
message, "PRINS is not supported",
|
|
sepp_node->receiver, NULL));
|
|
|
|
} else if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_NONE) {
|
|
|
|
/* Change to TERMINATED */
|
|
sepp_n32c_handshake_send_security_capability_response(
|
|
sepp_node, stream);
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_terminated);
|
|
}
|
|
break;
|
|
DEFAULT
|
|
ogs_error("Invalid HTTP method [%s]", message->h.method);
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid resource name [%s]",
|
|
sepp_node->receiver, message->h.resource.component[0]);
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid API name [%s]",
|
|
sepp_node->receiver, message->h.service.name);
|
|
END
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_CLIENT:
|
|
message = e->h.sbi.message;
|
|
ogs_assert(message);
|
|
|
|
SWITCH(message->h.service.name)
|
|
CASE(OGS_SBI_SERVICE_NAME_N32C_HANDSHAKE)
|
|
SWITCH(message->h.resource.component[0])
|
|
CASE(OGS_SBI_RESOURCE_NAME_EXCHANGE_CAPABILITY)
|
|
SWITCH(message->h.method)
|
|
CASE(OGS_SBI_HTTP_METHOD_POST)
|
|
if (message->res_status == OGS_SBI_HTTP_STATUS_OK) {
|
|
ogs_warn("[%s] SEPP has already been established",
|
|
sepp_node->receiver);
|
|
} else {
|
|
ogs_error("[%s] HTTP Response Status Code [%d]",
|
|
sepp_node->receiver, message->res_status);
|
|
}
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("Invalid HTTP method [%s]", message->h.method);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid resource name [%s]",
|
|
sepp_node->receiver, message->h.resource.component[0]);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid API name [%s]",
|
|
sepp_node->receiver, message->h.service.name);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
default:
|
|
ogs_error("Unknown event %s", sepp_event_get_name(e));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void sepp_handshake_state_terminated(ogs_fsm_t *s, sepp_event_t *e)
|
|
{
|
|
bool handled;
|
|
sepp_node_t *sepp_node = NULL;
|
|
|
|
ogs_sbi_stream_t *stream = NULL;
|
|
ogs_sbi_message_t *message = NULL;
|
|
|
|
ogs_assert(s);
|
|
ogs_assert(e);
|
|
|
|
sepp_sm_debug(e);
|
|
|
|
sepp_node = e->sepp_node;
|
|
ogs_assert(sepp_node);
|
|
|
|
switch (e->h.id) {
|
|
case OGS_FSM_ENTRY_SIG:
|
|
if (sepp_node->t_establish_interval) {
|
|
ogs_timer_start(sepp_node->t_establish_interval,
|
|
ogs_local_conf()->time.message.sbi.reconnect_interval);
|
|
}
|
|
break;
|
|
|
|
case OGS_FSM_EXIT_SIG:
|
|
if (sepp_node->t_establish_interval) {
|
|
ogs_timer_stop(sepp_node->t_establish_interval);
|
|
}
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_SERVER:
|
|
message = e->h.sbi.message;
|
|
ogs_assert(message);
|
|
stream = e->h.sbi.data;
|
|
ogs_assert(stream);
|
|
|
|
SWITCH(message->h.service.name)
|
|
CASE(OGS_SBI_SERVICE_NAME_N32C_HANDSHAKE)
|
|
SWITCH(message->h.resource.component[0])
|
|
CASE(OGS_SBI_RESOURCE_NAME_EXCHANGE_CAPABILITY)
|
|
SWITCH(message->h.method)
|
|
CASE(OGS_SBI_HTTP_METHOD_POST)
|
|
handled =
|
|
sepp_n32c_handshake_handle_security_capability_request(
|
|
sepp_node, stream, message);
|
|
if (!handled) {
|
|
ogs_error("[%s] Cannot handle SBI message",
|
|
sepp_node->receiver);
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_exception);
|
|
break;
|
|
}
|
|
|
|
if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_TLS) {
|
|
|
|
/* Change to ESTABLISHED */
|
|
sepp_n32c_handshake_send_security_capability_response(
|
|
sepp_node, stream);
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_established);
|
|
|
|
} else if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_PRINS) {
|
|
|
|
ogs_error("[%s] PRINS is not supported",
|
|
sepp_node->receiver);
|
|
ogs_assert(true ==
|
|
ogs_sbi_server_send_error(stream,
|
|
OGS_SBI_HTTP_STATUS_BAD_REQUEST,
|
|
message, "PRINS is not supported",
|
|
sepp_node->receiver, NULL));
|
|
|
|
} else if (sepp_node->negotiated_security_scheme ==
|
|
OpenAPI_security_capability_NONE) {
|
|
|
|
/* No State Change */
|
|
sepp_n32c_handshake_send_security_capability_response(
|
|
sepp_node, stream);
|
|
ogs_warn("[%s] SEPP has not been established",
|
|
sepp_node->receiver);
|
|
}
|
|
break;
|
|
DEFAULT
|
|
ogs_error("Invalid HTTP method [%s]", message->h.method);
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid resource name [%s]",
|
|
sepp_node->receiver, message->h.resource.component[0]);
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid API name [%s]",
|
|
sepp_node->receiver, message->h.service.name);
|
|
END
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_CLIENT:
|
|
message = e->h.sbi.message;
|
|
ogs_assert(message);
|
|
|
|
SWITCH(message->h.service.name)
|
|
CASE(OGS_SBI_SERVICE_NAME_N32C_HANDSHAKE)
|
|
SWITCH(message->h.resource.component[0])
|
|
CASE(OGS_SBI_RESOURCE_NAME_EXCHANGE_CAPABILITY)
|
|
SWITCH(message->h.method)
|
|
CASE(OGS_SBI_HTTP_METHOD_POST)
|
|
if (message->res_status == OGS_SBI_HTTP_STATUS_OK) {
|
|
ogs_warn("[%s] SEPP was terminated", sepp_node->receiver);
|
|
} else {
|
|
ogs_error("[%s] HTTP Response Status Code [%d]",
|
|
sepp_node->receiver, message->res_status);
|
|
}
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("Invalid HTTP method [%s]", message->h.method);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid resource name [%s]",
|
|
sepp_node->receiver, message->h.resource.component[0]);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
DEFAULT
|
|
ogs_error("[%s] Invalid API name [%s]",
|
|
sepp_node->receiver, message->h.service.name);
|
|
ogs_assert_if_reached();
|
|
END
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_TIMER:
|
|
switch(e->h.timer_id) {
|
|
case SEPP_TIMER_PEER_ESTABLISH:
|
|
ogs_warn("[%s] Retry establishment with Peer SEPP",
|
|
sepp_node->receiver);
|
|
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_will_establish);
|
|
break;
|
|
|
|
default:
|
|
ogs_error("Unknown timer[%s:%d]",
|
|
ogs_timer_get_name(e->h.timer_id), e->h.timer_id);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ogs_error("Unknown event %s", sepp_event_get_name(e));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void sepp_handshake_state_exception(ogs_fsm_t *s, sepp_event_t *e)
|
|
{
|
|
sepp_node_t *sepp_node = NULL;
|
|
|
|
ogs_sbi_message_t *message = NULL;
|
|
|
|
ogs_assert(s);
|
|
ogs_assert(e);
|
|
|
|
sepp_sm_debug(e);
|
|
|
|
sepp_node = e->sepp_node;
|
|
ogs_assert(sepp_node);
|
|
|
|
switch (e->h.id) {
|
|
case OGS_FSM_ENTRY_SIG:
|
|
if (sepp_node->t_establish_interval) {
|
|
ogs_timer_start(sepp_node->t_establish_interval,
|
|
ogs_local_conf()->time.message.sbi.
|
|
reconnect_interval_in_exception);
|
|
}
|
|
break;
|
|
|
|
case OGS_FSM_EXIT_SIG:
|
|
if (sepp_node->t_establish_interval) {
|
|
ogs_timer_stop(sepp_node->t_establish_interval);
|
|
}
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_TIMER:
|
|
switch(e->h.timer_id) {
|
|
case SEPP_TIMER_PEER_ESTABLISH:
|
|
ogs_warn("[%s] Retry establishment with Peer SEPP",
|
|
sepp_node->receiver);
|
|
|
|
OGS_FSM_TRAN(s, &sepp_handshake_state_will_establish);
|
|
break;
|
|
|
|
default:
|
|
ogs_error("Unknown timer[%s:%d]",
|
|
ogs_timer_get_name(e->h.timer_id), e->h.timer_id);
|
|
}
|
|
break;
|
|
|
|
case OGS_EVENT_SBI_SERVER:
|
|
case OGS_EVENT_SBI_CLIENT:
|
|
message = e->h.sbi.message;
|
|
ogs_assert(message);
|
|
|
|
SWITCH(message->h.service.name)
|
|
CASE(OGS_SBI_SERVICE_NAME_N32C_HANDSHAKE)
|
|
|
|
SWITCH(message->h.resource.component[0])
|
|
CASE(OGS_SBI_RESOURCE_NAME_EXCHANGE_CAPABILITY)
|
|
ogs_error("[%s] SEPP exception state", sepp_node->receiver);
|
|
break;
|
|
DEFAULT
|
|
ogs_error("Invalid resource name [%s]",
|
|
message->h.resource.component[0]);
|
|
END
|
|
break;
|
|
DEFAULT
|
|
ogs_error("Invalid API name [%s]", message->h.service.name);
|
|
END
|
|
break;
|
|
|
|
default:
|
|
ogs_error("Unknown event %s", sepp_event_get_name(e));
|
|
break;
|
|
}
|
|
}
|