Skip to content

O
OpenXG-SMF-Simple
Commit 40faab75 authored by Tien-Thinh Nguyen's avatar Tien-Thinh Nguyen
Browse files
Options

Code cleanup/format for Itti

parent 238c743b
Hide whitespace changes
Inline Side-by-side
Showing with 615 additions and 716 deletions
src/common/msg/itti_async_shell_cmd.hpp
View file @ 40faab75
......@@ -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
*
......@@ -33,28 +33,22 @@
class itti_async_shell_cmd : public itti_msg {
public:
itti_async_shell_cmd(const task_id_t origin, const task_id_t destination,
const std::string &system_cmd, bool is_abort_on_error,
const char *src_file, const int src_line)
:
itti_msg(ASYNC_SHELL_CMD, origin, destination),
system_command(system_cmd),
is_abort_on_error(is_abort_on_error),
src_file(src_file),
src_line(src_line) {
}
itti_async_shell_cmd(const itti_async_shell_cmd &i)
:
itti_msg(i),
system_command(i.system_command),
is_abort_on_error(i.is_abort_on_error),
src_file(i.src_file),
src_line(i.src_line) {
}
const char* get_msg_name() {
return typeid(itti_msg_ping).name();
}
;
itti_async_shell_cmd(
const task_id_t origin, const task_id_t destination,
const std::string& system_cmd, bool is_abort_on_error,
const char* src_file, const int src_line)
: itti_msg(ASYNC_SHELL_CMD, origin, destination),
system_command(system_cmd),
is_abort_on_error(is_abort_on_error),
src_file(src_file),
src_line(src_line) {}
itti_async_shell_cmd(const itti_async_shell_cmd& i)
: itti_msg(i),
system_command(i.system_command),
is_abort_on_error(i.is_abort_on_error),
src_file(i.src_file),
src_line(i.src_line) {}
const char* get_msg_name() { return typeid(itti_msg_ping).name(); };
std::string system_command;
bool is_abort_on_error;
// debug
......
src/common/msg/itti_msg_n11.hpp
View file @ 40faab75
......@@ -4,8 +4,8 @@
* 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
* file except in compliance with the License. You may obtain a copy of the
* License at
*
* http://www.openairinterface.org/?page_id=698
*
......
src/common/msg/itti_msg_n4.hpp
View file @ 40faab75
......@@ -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
*
......@@ -35,27 +35,24 @@
class itti_n4_msg : public itti_msg {
public:
itti_n4_msg(const itti_msg_type_t msg_type, const task_id_t origin,
const task_id_t destination)
:
itti_msg(msg_type, origin, destination) {
l_endpoint = { };
r_endpoint = { };
seid = UNASSIGNED_SEID;
trxn_id = 0;
}
itti_n4_msg(const itti_n4_msg &i)
:
itti_msg(i) {
itti_n4_msg(
const itti_msg_type_t msg_type, const task_id_t origin,
const task_id_t destination)
: itti_msg(msg_type, origin, destination) {
l_endpoint = {};
r_endpoint = {};
seid = UNASSIGNED_SEID;
trxn_id = 0;
}
itti_n4_msg(const itti_n4_msg& i) : itti_msg(i) {
l_endpoint = i.l_endpoint;
r_endpoint = i.r_endpoint;
seid = i.seid;
trxn_id = i.trxn_id;
seid = i.seid;
trxn_id = i.trxn_id;
}
itti_n4_msg(const itti_n4_msg &i, const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i) {
origin = orig;
itti_n4_msg(const itti_n4_msg& i, const task_id_t orig, const task_id_t dest)
: itti_n4_msg(i) {
origin = orig;
destination = dest;
}
......@@ -69,25 +66,21 @@ class itti_n4_msg : public itti_msg {
class itti_n4_heartbeat_request : public itti_n4_msg {
public:
itti_n4_heartbeat_request(const task_id_t origin, const task_id_t destination)
:
itti_n4_msg(N4_HEARTBEAT_REQUEST, origin, destination) {
}
itti_n4_heartbeat_request(const itti_n4_heartbeat_request &i)
:
itti_n4_msg(i) {
: itti_n4_msg(N4_HEARTBEAT_REQUEST, origin, destination) {}
itti_n4_heartbeat_request(const itti_n4_heartbeat_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_heartbeat_request(const itti_n4_heartbeat_request &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_heartbeat_request(
const itti_n4_heartbeat_request& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_heartbeat_request).name();
}
;
};
pfcp::pfcp_heartbeat_request pfcp_ies;
};
......@@ -95,26 +88,22 @@ class itti_n4_heartbeat_request : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_heartbeat_response : public itti_n4_msg {
public:
itti_n4_heartbeat_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_HEARTBEAT_RESPONSE, origin, destination) {
}
itti_n4_heartbeat_response(const itti_n4_heartbeat_response &i)
:
itti_n4_msg(i) {
itti_n4_heartbeat_response(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_HEARTBEAT_RESPONSE, origin, destination) {}
itti_n4_heartbeat_response(const itti_n4_heartbeat_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_heartbeat_response(const itti_n4_heartbeat_response &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_heartbeat_response(
const itti_n4_heartbeat_response& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_heartbeat_response).name();
}
;
};
pfcp::pfcp_heartbeat_response pfcp_ies;
};
......@@ -122,28 +111,23 @@ class itti_n4_heartbeat_response : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_pfcp_pfd_management_request : public itti_n4_msg {
public:
itti_n4_pfcp_pfd_management_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_PFCP_PFD_MANAGEMENT_REQUEST, origin, destination) {
}
itti_n4_pfcp_pfd_management_request(
const itti_n4_pfcp_pfd_management_request &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_PFCP_PFD_MANAGEMENT_REQUEST, origin, destination) {}
itti_n4_pfcp_pfd_management_request(
const itti_n4_pfcp_pfd_management_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_pfcp_pfd_management_request(
const itti_n4_pfcp_pfd_management_request &i, const task_id_t orig,
const itti_n4_pfcp_pfd_management_request& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_pfcp_pfd_management_request).name();
}
;
};
pfcp::pfcp_pfd_management_request pfcp_ies;
};
......@@ -151,28 +135,23 @@ class itti_n4_pfcp_pfd_management_request : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_pfcp_pfd_management_response : public itti_n4_msg {
public:
itti_n4_pfcp_pfd_management_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_PFCP_PFD_MANAGEMENT_RESPONSE, origin, destination) {
}
itti_n4_pfcp_pfd_management_response(
const itti_n4_pfcp_pfd_management_response &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_PFCP_PFD_MANAGEMENT_RESPONSE, origin, destination) {}
itti_n4_pfcp_pfd_management_response(
const itti_n4_pfcp_pfd_management_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_pfcp_pfd_management_response(
const itti_n4_pfcp_pfd_management_response &i, const task_id_t orig,
const itti_n4_pfcp_pfd_management_response& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_pfcp_pfd_management_response).name();
}
;
};
pfcp::pfcp_pfd_management_response pfcp_ies;
};
......@@ -180,26 +159,22 @@ class itti_n4_pfcp_pfd_management_response : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_association_setup_request : public itti_n4_msg {
public:
itti_n4_association_setup_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_ASSOCIATION_SETUP_REQUEST, origin, destination) {
}
itti_n4_association_setup_request(const itti_n4_association_setup_request &i)
:
itti_n4_msg(i) {
itti_n4_association_setup_request(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_ASSOCIATION_SETUP_REQUEST, origin, destination) {}
itti_n4_association_setup_request(const itti_n4_association_setup_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_association_setup_request(const itti_n4_association_setup_request &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_association_setup_request(
const itti_n4_association_setup_request& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_association_setup_request).name();
}
;
};
pfcp::pfcp_association_setup_request pfcp_ies;
};
......@@ -207,28 +182,23 @@ class itti_n4_association_setup_request : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_association_setup_response : public itti_n4_msg {
public:
itti_n4_association_setup_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_ASSOCIATION_SETUP_RESPONSE, origin, destination) {
}
itti_n4_association_setup_response(
const itti_n4_association_setup_response &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_ASSOCIATION_SETUP_RESPONSE, origin, destination) {}
itti_n4_association_setup_response(
const itti_n4_association_setup_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_association_setup_response(
const itti_n4_association_setup_response &i, const task_id_t orig,
const itti_n4_association_setup_response& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_association_setup_response).name();
}
;
};
pfcp::pfcp_association_setup_response pfcp_ies;
};
......@@ -236,28 +206,23 @@ class itti_n4_association_setup_response : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_association_update_request : public itti_n4_msg {
public:
itti_n4_association_update_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_ASSOCIATION_UPDATE_REQUEST, origin, destination) {
}
itti_n4_association_update_request(
const itti_n4_association_update_request &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_ASSOCIATION_UPDATE_REQUEST, origin, destination) {}
itti_n4_association_update_request(
const itti_n4_association_update_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_association_update_request(
const itti_n4_association_update_request &i, const task_id_t orig,
const itti_n4_association_update_request& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_association_update_request).name();
}
;
};
pfcp::pfcp_association_update_request pfcp_ies;
};
......@@ -265,28 +230,23 @@ class itti_n4_association_update_request : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_association_update_response : public itti_n4_msg {
public:
itti_n4_association_update_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_ASSOCIATION_UPDATE_RESPONSE, origin, destination) {
}
itti_n4_association_update_response(
const itti_n4_association_update_response &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_ASSOCIATION_UPDATE_RESPONSE, origin, destination) {}
itti_n4_association_update_response(
const itti_n4_association_update_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_association_update_response(
const itti_n4_association_update_response &i, const task_id_t orig,
const itti_n4_association_update_response& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_association_update_response).name();
}
;
};
pfcp::pfcp_association_update_response pfcp_ies;
};
......@@ -294,28 +254,23 @@ class itti_n4_association_update_response : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_association_release_request : public itti_n4_msg {
public:
itti_n4_association_release_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_ASSOCIATION_RELEASE_REQUEST, origin, destination) {
}
itti_n4_association_release_request(
const itti_n4_association_release_request &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_ASSOCIATION_RELEASE_REQUEST, origin, destination) {}
itti_n4_association_release_request(
const itti_n4_association_release_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_association_release_request(
const itti_n4_association_release_request &i, const task_id_t orig,
const itti_n4_association_release_request& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_association_release_request).name();
}
;
};
pfcp::pfcp_association_release_request pfcp_ies;
};
......@@ -323,28 +278,23 @@ class itti_n4_association_release_request : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_association_release_response : public itti_n4_msg {
public:
itti_n4_association_release_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_ASSOCIATION_RELEASE_RESPONSE, origin, destination) {
}
itti_n4_association_release_response(
const itti_n4_association_release_response &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_ASSOCIATION_RELEASE_RESPONSE, origin, destination) {}
itti_n4_association_release_response(
const itti_n4_association_release_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_association_release_response(
const itti_n4_association_release_response &i, const task_id_t orig,
const itti_n4_association_release_response& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_association_release_response).name();
}
;
};
pfcp::pfcp_association_release_response pfcp_ies;
};
......@@ -352,28 +302,23 @@ class itti_n4_association_release_response : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_version_not_supported_response : public itti_n4_msg {
public:
itti_n4_version_not_supported_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_VERSION_NOT_SUPPORTED_RESPONSE, origin, destination) {
}
itti_n4_version_not_supported_response(
const itti_n4_version_not_supported_response &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_VERSION_NOT_SUPPORTED_RESPONSE, origin, destination) {}
itti_n4_version_not_supported_response(
const itti_n4_version_not_supported_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_version_not_supported_response(
const itti_n4_version_not_supported_response &i, const task_id_t orig,
const itti_n4_version_not_supported_response& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_version_not_supported_response).name();
}
;
};
pfcp::pfcp_version_not_supported_response pfcp_ies;
};
......@@ -381,26 +326,22 @@ class itti_n4_version_not_supported_response : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_node_report_request : public itti_n4_msg {
public:
itti_n4_node_report_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_NODE_REPORT_REQUEST, origin, destination) {
}
itti_n4_node_report_request(const itti_n4_node_report_request &i)
:
itti_n4_msg(i) {
itti_n4_node_report_request(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_NODE_REPORT_REQUEST, origin, destination) {}
itti_n4_node_report_request(const itti_n4_node_report_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_node_report_request(const itti_n4_node_report_request &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_node_report_request(
const itti_n4_node_report_request& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_node_report_request).name();
}
;
};
pfcp::pfcp_node_report_request pfcp_ies;
};
......@@ -408,26 +349,22 @@ class itti_n4_node_report_request : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_node_report_response : public itti_n4_msg {
public:
itti_n4_node_report_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_NODE_REPORT_RESPONSE, origin, destination) {
}
itti_n4_node_report_response(const itti_n4_node_report_response &i)
:
itti_n4_msg(i) {
itti_n4_node_report_response(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_NODE_REPORT_RESPONSE, origin, destination) {}
itti_n4_node_report_response(const itti_n4_node_report_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_node_report_response(const itti_n4_node_report_response &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_node_report_response(
const itti_n4_node_report_response& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_node_report_response).name();
}
;
};
pfcp::pfcp_node_report_response pfcp_ies;
};
......@@ -435,303 +372,252 @@ class itti_n4_node_report_response : public itti_n4_msg {
//-----------------------------------------------------------------------------
class itti_n4_session_set_deletion_request : public itti_n4_msg {
public:
itti_n4_session_set_deletion_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_SET_DELETION_REQUEST, origin, destination) {
}
itti_n4_session_set_deletion_request(
const itti_n4_session_set_deletion_request &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_SET_DELETION_REQUEST, origin, destination) {}
itti_n4_session_set_deletion_request(
const itti_n4_session_set_deletion_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_set_deletion_request(
const itti_n4_session_set_deletion_request &i, const task_id_t orig,
const itti_n4_session_set_deletion_request& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_set_deletion_request).name();
}
;
};
pfcp::pfcp_session_set_deletion_request pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_set_deletion_response : public itti_n4_msg {
public:
itti_n4_session_set_deletion_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_SET_DELETION_RESPONSE, origin, destination) {
}
itti_n4_session_set_deletion_response(
const itti_n4_session_set_deletion_response &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_SET_DELETION_RESPONSE, origin, destination) {}
itti_n4_session_set_deletion_response(
const itti_n4_session_set_deletion_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_set_deletion_response(
const itti_n4_session_set_deletion_response &i, const task_id_t orig,
const itti_n4_session_set_deletion_response& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_set_deletion_response).name();
}
;
};
pfcp::pfcp_session_set_deletion_response pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_establishment_request : public itti_n4_msg {
public:
itti_n4_session_establishment_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_ESTABLISHMENT_REQUEST, origin, destination) {
}
itti_n4_session_establishment_request(
const itti_n4_session_establishment_request &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_ESTABLISHMENT_REQUEST, origin, destination) {}
itti_n4_session_establishment_request(
const itti_n4_session_establishment_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_establishment_request(
const itti_n4_session_establishment_request &i, const task_id_t orig,
const itti_n4_session_establishment_request& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_establishment_request).name();
}
;
};
pfcp::pfcp_session_establishment_request pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_establishment_response : public itti_n4_msg {
public:
itti_n4_session_establishment_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_ESTABLISHMENT_RESPONSE, origin, destination) {
}
itti_n4_session_establishment_response(
const itti_n4_session_establishment_response &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_ESTABLISHMENT_RESPONSE, origin, destination) {}
itti_n4_session_establishment_response(
const itti_n4_session_establishment_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_establishment_response(
const itti_n4_session_establishment_response &i, const task_id_t orig,
const itti_n4_session_establishment_response& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_establishment_response).name();
}
;
};
pfcp::pfcp_session_establishment_response pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_modification_request : public itti_n4_msg {
public:
itti_n4_session_modification_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_MODIFICATION_REQUEST, origin, destination) {
}
itti_n4_session_modification_request(
const itti_n4_session_modification_request &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_MODIFICATION_REQUEST, origin, destination) {}
itti_n4_session_modification_request(
const itti_n4_session_modification_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_modification_request(
const itti_n4_session_modification_request &i, const task_id_t orig,
const itti_n4_session_modification_request& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_modification_request).name();
}
;
};
pfcp::pfcp_session_modification_request pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_modification_response : public itti_n4_msg {
public:
itti_n4_session_modification_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_MODIFICATION_RESPONSE, origin, destination) {
}
itti_n4_session_modification_response(
const itti_n4_session_modification_response &i)
:
itti_n4_msg(i) {
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_MODIFICATION_RESPONSE, origin, destination) {}
itti_n4_session_modification_response(
const itti_n4_session_modification_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_modification_response(
const itti_n4_session_modification_response &i, const task_id_t orig,
const itti_n4_session_modification_response& i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_modification_response).name();
}
;
};
pfcp::pfcp_session_modification_response pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_deletion_request : public itti_n4_msg {
public:
itti_n4_session_deletion_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_DELETION_REQUEST, origin, destination) {
}
itti_n4_session_deletion_request(const itti_n4_session_deletion_request &i)
:
itti_n4_msg(i) {
itti_n4_session_deletion_request(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_DELETION_REQUEST, origin, destination) {}
itti_n4_session_deletion_request(const itti_n4_session_deletion_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_deletion_request(const itti_n4_session_deletion_request &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_session_deletion_request(
const itti_n4_session_deletion_request& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_deletion_request).name();
}
;
};
pfcp::pfcp_session_deletion_request pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_deletion_response : public itti_n4_msg {
public:
itti_n4_session_deletion_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_DELETION_RESPONSE, origin, destination) {
}
itti_n4_session_deletion_response(const itti_n4_session_deletion_response &i)
:
itti_n4_msg(i) {
itti_n4_session_deletion_response(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_DELETION_RESPONSE, origin, destination) {}
itti_n4_session_deletion_response(const itti_n4_session_deletion_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_deletion_response(const itti_n4_session_deletion_response &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_session_deletion_response(
const itti_n4_session_deletion_response& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_deletion_response).name();
}
;
};
pfcp::pfcp_session_deletion_response pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_report_request : public itti_n4_msg {
public:
itti_n4_session_report_request(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_REPORT_REQUEST, origin, destination) {
}
itti_n4_session_report_request(const itti_n4_session_report_request &i)
:
itti_n4_msg(i) {
itti_n4_session_report_request(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_REPORT_REQUEST, origin, destination) {}
itti_n4_session_report_request(const itti_n4_session_report_request& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_report_request(const itti_n4_session_report_request &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_session_report_request(
const itti_n4_session_report_request& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_deletion_request).name();
}
;
};
pfcp::pfcp_session_report_request pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_report_response : public itti_n4_msg {
public:
itti_n4_session_report_response(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_REPORT_RESPONSE, origin, destination) {
}
itti_n4_session_report_response(const itti_n4_session_report_response &i)
:
itti_n4_msg(i) {
itti_n4_session_report_response(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_REPORT_RESPONSE, origin, destination) {}
itti_n4_session_report_response(const itti_n4_session_report_response& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_report_response(const itti_n4_session_report_response &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_session_report_response(
const itti_n4_session_report_response& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_report_response).name();
}
;
};
pfcp::pfcp_session_report_response pfcp_ies;
};
//-----------------------------------------------------------------------------
class itti_n4_session_failure_indication : public itti_n4_msg {
public:
itti_n4_session_failure_indication(const task_id_t origin,
const task_id_t destination)
:
itti_n4_msg(N4_SESSION_REPORT_RESPONSE, origin, destination) {
}
itti_n4_session_failure_indication(const itti_n4_session_failure_indication &i)
:
itti_n4_msg(i) {
itti_n4_session_failure_indication(
const task_id_t origin, const task_id_t destination)
: itti_n4_msg(N4_SESSION_REPORT_RESPONSE, origin, destination) {}
itti_n4_session_failure_indication(
const itti_n4_session_failure_indication& i)
: itti_n4_msg(i) {
pfcp_ies = i.pfcp_ies;
}
itti_n4_session_failure_indication(const itti_n4_session_failure_indication &i,
const task_id_t orig, const task_id_t dest)
:
itti_n4_msg(i, orig, dest) {
itti_n4_session_failure_indication(
const itti_n4_session_failure_indication& i, const task_id_t orig,
const task_id_t dest)
: itti_n4_msg(i, orig, dest) {
pfcp_ies = i.pfcp_ies;
}
const char* get_msg_name() {
return typeid(itti_n4_session_failure_indication).name();
}
;
};
pfcp::pfcp_session_modification_request pfcp_ies;
};
#endif /* ITTI_MSG_N4_HPP_INCLUDED_ */
src/common/msg/itti_msg_n4_restore.hpp
View file @ 40faab75
......@@ -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
*
......@@ -36,26 +36,16 @@
class itti_n4_restore : public itti_msg {
public:
itti_n4_restore(const task_id_t origin, const task_id_t destination)
:
itti_msg(RESTORE_N4_SESSIONS, origin, destination),
sessions() {
}
itti_n4_restore(const itti_n4_restore &i)
:
itti_msg(i),
sessions(i.sessions) {
}
itti_n4_restore(const itti_n4_restore &i, const task_id_t orig,
const task_id_t dest)
:
itti_n4_restore(i) {
origin = orig;
: itti_msg(RESTORE_N4_SESSIONS, origin, destination), sessions() {}
itti_n4_restore(const itti_n4_restore& i)
: itti_msg(i), sessions(i.sessions) {}
itti_n4_restore(
const itti_n4_restore& i, const task_id_t orig, const task_id_t dest)
: itti_n4_restore(i) {
origin = orig;
destination = dest;
}
const char* get_msg_name() {
return "N4_RESTORE";
}
;
const char* get_msg_name() { return "N4_RESTORE"; };
std::set<pfcp::fseid_t> sessions;
};
......
src/common/msg/itti_msg_nx.hpp
View file @ 40faab75
......@@ -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
*
......@@ -35,54 +35,34 @@
class itti_nx_msg : public itti_msg {
public:
itti_nx_msg(const itti_msg_type_t msg_type, const task_id_t orig,
const task_id_t dest)
:
itti_msg(msg_type, orig, dest) {
}
itti_nx_msg(const itti_nx_msg &i)
:
itti_msg(i) {
}
itti_nx_msg(const itti_nx_msg &i, const task_id_t orig, const task_id_t dest)
:
itti_nx_msg(i) {
origin = orig;
itti_nx_msg(
const itti_msg_type_t msg_type, const task_id_t orig,
const task_id_t dest)
: itti_msg(msg_type, orig, dest) {}
itti_nx_msg(const itti_nx_msg& i) : itti_msg(i) {}
itti_nx_msg(const itti_nx_msg& i, const task_id_t orig, const task_id_t dest)
: itti_nx_msg(i) {
origin = orig;
destination = dest;
}
};
//-----------------------------------------------------------------------------
class itti_nx_trigger_pdu_session_modification : public itti_nx_msg {
public:
itti_nx_trigger_pdu_session_modification(const task_id_t orig,
const task_id_t dest)
:
itti_nx_msg(NX_TRIGGER_SESSION_MODIFICATION, orig, dest),
msg(),
http_version() {
}
itti_nx_trigger_pdu_session_modification(
const itti_nx_trigger_pdu_session_modification &i)
:
itti_nx_msg(i),
msg(i.msg),
http_version(i.http_version) {
}
const task_id_t orig, const task_id_t dest)
: itti_nx_msg(NX_TRIGGER_SESSION_MODIFICATION, orig, dest),
msg(),
http_version() {}
itti_nx_trigger_pdu_session_modification(
const itti_nx_trigger_pdu_session_modification& i)
: itti_nx_msg(i), msg(i.msg), http_version(i.http_version) {}
itti_nx_trigger_pdu_session_modification(
const itti_nx_trigger_pdu_session_modification &i, const task_id_t orig,
const itti_nx_trigger_pdu_session_modification& i, const task_id_t orig,
const task_id_t dest)
:
itti_nx_msg(i, orig, dest),
msg(),
http_version(i.http_version) {
}
const char* get_msg_name() {
return "NX_TRIGGER_PDU_SESSION_MODIFICATION";
}
;
: itti_nx_msg(i, orig, dest), msg(), http_version(i.http_version) {}
const char* get_msg_name() { return "NX_TRIGGER_PDU_SESSION_MODIFICATION"; };
smf::pdu_session_modification_network_requested msg;
uint8_t http_version;
};
......
src/common/nas/3gpp_24.007.h
View file @ 40faab75
......@@ -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
*
......@@ -33,30 +33,30 @@ typedef enum extended_protocol_discriminator_e {
} extended_protocol_discriminator_t;
// Procedure transaction identity
//8 bits
#define PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED (uint8_t)0
#define PROCEDURE_TRANSACTION_IDENTITY_FIRST (uint8_t)1
#define PROCEDURE_TRANSACTION_IDENTITY_LAST (uint8_t)254
#define PROCEDURE_TRANSACTION_IDENTITY_RESERVED (uint8_t)255
// 8 bits
#define PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED (uint8_t) 0
#define PROCEDURE_TRANSACTION_IDENTITY_FIRST (uint8_t) 1
#define PROCEDURE_TRANSACTION_IDENTITY_LAST (uint8_t) 254
#define PROCEDURE_TRANSACTION_IDENTITY_RESERVED (uint8_t) 255
// PDU Session Identity
typedef uint8_t pdu_session_id_t;
//8 bits
#define PDU_SESSION_IDENTITY_UNASSIGNED (uint8_t)0
#define PDU_SESSION_IDENTITY_FIRST (uint8_t)1
#define PDU_SESSION_IDENTITY_LAST (uint8_t)15
// 8 bits
#define PDU_SESSION_IDENTITY_UNASSIGNED (uint8_t) 0
#define PDU_SESSION_IDENTITY_FIRST (uint8_t) 1
#define PDU_SESSION_IDENTITY_LAST (uint8_t) 15
// QFI
// type: integer, minimum: 0, maximum: 63
#define NO_QOS_FLOW_IDENTIFIER_ASSIGNED (uint8_t)0
#define QOS_FLOW_IDENTIFIER_FIRST (uint8_t)1
#define QOS_FLOW_IDENTIFIER_LAST (uint8_t)63
#define NO_QOS_FLOW_IDENTIFIER_ASSIGNED (uint8_t) 0
#define QOS_FLOW_IDENTIFIER_FIRST (uint8_t) 1
#define QOS_FLOW_IDENTIFIER_LAST (uint8_t) 63
//QoS Rule
#define NO_QOS_RULE_IDENTIFIER_ASSIGNED (uint8_t)0
#define QOS_RULE_IDENTIFIER_FIRST (uint8_t)1
#define QOS_RULE_IDENTIFIER_LAST (uint8_t)255
// QoS Rule
#define NO_QOS_RULE_IDENTIFIER_ASSIGNED (uint8_t) 0
#define QOS_RULE_IDENTIFIER_FIRST (uint8_t) 1
#define QOS_RULE_IDENTIFIER_LAST (uint8_t) 255
// Integrity protection maximum data rate
typedef struct ipmdr_s {
......
src/common/nas/3gpp_33.401.h
View file @ 40faab75
......@@ -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
*
......@@ -33,30 +33,33 @@
//------------------------------------------------------------------------------
// 5.1.3.2 Algorithm Identifier Values
//------------------------------------------------------------------------------
#define EEA0_ALG_ID 0b000
#define EEA1_128_ALG_ID 0b001
#define EEA2_128_ALG_ID 0b010
#define EEA0_ALG_ID 0b000
#define EEA1_128_ALG_ID 0b001
#define EEA2_128_ALG_ID 0b010
//------------------------------------------------------------------------------
// 5.1.4.2 Algorithm Identifier Values
//------------------------------------------------------------------------------
#define EIA0_ALG_ID 0b000
#define EIA1_128_ALG_ID 0b001
#define EIA2_128_ALG_ID 0b010
#define EIA0_ALG_ID 0b000
#define EIA1_128_ALG_ID 0b001
#define EIA2_128_ALG_ID 0b010
//------------------------------------------------------------------------------
// 6.1.2 Distribution of authentication data from HSS to serving network
//------------------------------------------------------------------------------
/* NOTE 2: It is recommended that the MME fetch only one EPS authentication vector at a time as the need to perform
* AKA runs has been reduced in EPS through the use of a more elaborate key hierarchy. In particular,
* service requests can be authenticated using a stored K ASME without the need to perform AKA.
* Furthermore, the sequence number management schemes in TS 33.102, Annex C [4], designed to avoid
* re-synchronisation problems caused by interleaving use of batches of authentication vectors, are only
* optional. Re-synchronisation problems in EPS can be avoided, independently of the sequence number
* management scheme, by immediately using an authentication vector retrieved from the HSS in an
* authentication procedure between UE and MME.
/* NOTE 2: It is recommended that the MME fetch only one EPS authentication
* vector at a time as the need to perform AKA runs has been reduced in EPS
* through the use of a more elaborate key hierarchy. In particular, service
* requests can be authenticated using a stored K ASME without the need to
* perform AKA. Furthermore, the sequence number management schemes in
* TS 33.102, Annex C [4], designed to avoid re-synchronisation problems caused
* by interleaving use of batches of authentication vectors, are only optional.
* Re-synchronisation problems in EPS can be avoided, independently of the
* sequence number management scheme, by immediately using an authentication
* vector retrieved from the HSS in an authentication procedure between UE and
* MME.
*/
#define MAX_EPS_AUTH_VECTORS 1
#define MAX_EPS_AUTH_VECTORS 1
//----------------------------
typedef struct mm_ue_eps_authentication_quadruplet_s {
......
src/common/nas/3gpp_36.401.h
View file @ 40faab75
......@@ -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
*
......@@ -19,7 +19,6 @@
* contact@openairinterface.org
*/
/*! \file 3gpp_36.401.h
\brief
\author Lionel Gauthier
......@@ -34,14 +33,18 @@
// 6.2 E-UTRAN Identifiers
//------------------------------------------------------------------------------
typedef uint32_t enb_ue_s1ap_id_t; /*!< \brief An eNB UE S1AP ID shall be allocated so as to uniquely identify the UE over the S1 interface within an eNB.
When an MME receives an eNB UE S1AP ID it shall store it for the duration of the UE-associated logical S1-connection for this UE.
Once known to an MME this IE is included in all UE associated S1-AP signalling.
The eNB UE S1AP ID shall be unique within the eNB logical node. */
typedef uint32_t enb_ue_s1ap_id_t; /*!< \brief An eNB UE S1AP ID shall be
allocated so as to uniquely identify the UE over the S1 interface within an
eNB. When an MME receives an eNB UE S1AP ID it shall store it for the duration
of the UE-associated logical S1-connection for this UE. Once known to an MME
this IE is included in all UE associated S1-AP signalling. The eNB UE S1AP ID
shall be unique within the eNB logical node. */
typedef uint32_t mme_ue_s1ap_id_t; /*!< \brief A MME UE S1AP ID shall be allocated so as to uniquely identify the UE over the S1 interface within the MME.
When an eNB receives MME UE S1AP ID it shall store it for the duration of the UE-associated logical S1-connection for this UE.
Once known to an eNB this IE is included in all UE associated S1-AP signalling.
typedef uint32_t mme_ue_s1ap_id_t; /*!< \brief A MME UE S1AP ID shall be
allocated so as to uniquely identify the UE over the S1 interface within the
MME. When an eNB receives MME UE S1AP ID it shall store it for the duration of
the UE-associated logical S1-connection for this UE. Once known to an eNB this
IE is included in all UE associated S1-AP signalling.
The MME UE S1AP ID shall be unique within the MME logical node.*/
#endif /* FILE_3GPP_36_401_SEEN */
src/common/nas/3gpp_38.401.h 100755 → 100644
View file @ 40faab75
......@@ -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
*
......
src/common/nas/common_types.h 100755 → 100644
View file @ 40faab75
......@@ -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
*
......@@ -19,7 +19,6 @@
* contact@openairinterface.org
*/
#ifndef FILE_COMMON_TYPES_SEEN
#define FILE_COMMON_TYPES_SEEN
......@@ -31,19 +30,19 @@
typedef uint16_t sctp_stream_id_t;
typedef uint32_t sctp_assoc_id_t;
//UE NGAP IDs
// UE NGAP IDs
#define INVALID_RAN_UE_NGAP_ID_KEY 0xFFFFFFFFFFFFFFFF
#define RAN_UE_NGAP_ID_MASK 0x00FFFFFF
#define RAN_UE_NGAP_ID_FMT "0x%06" PRIX32
#define GNB_UE_NGAP_ID_FMT "0x%06" PRIX32
#define AMF_UE_NGAP_ID_FMT "0x%08" PRIX32
#define INVALID_AMF_UE_NGAP_ID 0x0
#define RAN_UE_NGAP_ID_MASK 0x00FFFFFF
#define RAN_UE_NGAP_ID_FMT "0x%06" PRIX32
#define GNB_UE_NGAP_ID_FMT "0x%06" PRIX32
#define AMF_UE_NGAP_ID_FMT "0x%08" PRIX32
#define INVALID_AMF_UE_NGAP_ID 0x0
#define AMF_UE_NGAP_ID_MASK_ 0x0000FFFFFFFFFF
#define AMF_UE_NGAP_ID_MASK_ 0x0000FFFFFFFFFF
typedef uint8_t ksi_t;
#define KSI_NO_KEY_AVAILABLE 0x07
#define KSI_NO_KEY_AVAILABLE 0x07
typedef uint32_t ipv4_nbo_t;
......
src/common/nas/security_types.h
View file @ 40faab75
......@@ -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
*
......@@ -19,7 +19,6 @@
* contact@openairinterface.org
*/
/*! \file security_types.h
\brief
\author Sebastien ROUX, Lionel Gauthier
......@@ -28,11 +27,11 @@
*/
#if HAVE_CONFIG_H
# include "config.h"
#include "config.h"
#endif
#if !defined(HAVE_UINT128_T)
# include <gmp.h>
#include <gmp.h>
#endif
#include <stdlib.h>
......@@ -42,17 +41,17 @@
#ifndef FILE_SECURITY_TYPES_SEEN
#define FILE_SECURITY_TYPES_SEEN
#define RAND_LENGTH_BITS (128)
#define RAND_LENGTH_OCTETS (RAND_LENGTH_BITS/8)
#define AUTH_KEY_LENGTH_BITS (128)
#define AUTH_KEY_LENGTH_OCTETS (AUTH_KEY_LENGTH_BITS/8)
#define KASME_LENGTH_BITS (256)
#define KASME_LENGTH_OCTETS (KASME_LENGTH_BITS/8)
#define RAND_LENGTH_BITS (128)
#define RAND_LENGTH_OCTETS (RAND_LENGTH_BITS / 8)
#define AUTH_KEY_LENGTH_BITS (128)
#define AUTH_KEY_LENGTH_OCTETS (AUTH_KEY_LENGTH_BITS / 8)
#define KASME_LENGTH_BITS (256)
#define KASME_LENGTH_OCTETS (KASME_LENGTH_BITS / 8)
/* In OCTETS */
#define XRES_LENGTH_MIN (4)
#define XRES_LENGTH_MAX (16)
#define AUTN_LENGTH_BITS (128)
#define AUTN_LENGTH_OCTETS (AUTN_LENGTH_BITS/8)
#define XRES_LENGTH_MIN (4)
#define XRES_LENGTH_MAX (16)
#define AUTN_LENGTH_BITS (128)
#define AUTN_LENGTH_OCTETS (AUTN_LENGTH_BITS / 8)
/* Some methods to convert a string to an int64_t */
/*
......@@ -63,29 +62,28 @@
*/
/* Converts a string to 128 bits gmplib integer holder */
# define STRING_TO_XBITS(sTRING, lENGTH, cONTAINER, rET) \
do { \
memcpy(cONTAINER, sTRING, lENGTH); \
rET = 0; \
} while(0)
# define STRING_TO_128BITS(sTRING, cONTAINER, rET) \
STRING_TO_XBITS(sTRING, 16, cONTAINER, rET)
# define STRING_TO_256BITS(sTRING, cONTAINER, rET) \
STRING_TO_XBITS(sTRING, 32, cONTAINER, rET)
# define STRING_TO_RAND STRING_TO_128BITS
# define STRING_TO_AUTH_KEY STRING_TO_128BITS
# define STRING_TO_AUTH_RES STRING_TO_128BITS
# define STRING_TO_AUTN STRING_TO_128BITS
# define STRING_TO_KASME STRING_TO_256BITS
# define STRING_TO_XRES(sTRING, lENGTH, cONTAINER, rET) \
do { \
STRING_TO_XBITS(sTRING, lENGTH, (cONTAINER)->data, rET); \
if (rET != -1) \
(cONTAINER)->size = lENGTH; \
} while(0)
#define STRING_TO_XBITS(sTRING, lENGTH, cONTAINER, rET) \
do { \
memcpy(cONTAINER, sTRING, lENGTH); \
rET = 0; \
} while (0)
#define STRING_TO_128BITS(sTRING, cONTAINER, rET) \
STRING_TO_XBITS(sTRING, 16, cONTAINER, rET)
#define STRING_TO_256BITS(sTRING, cONTAINER, rET) \
STRING_TO_XBITS(sTRING, 32, cONTAINER, rET)
#define STRING_TO_RAND STRING_TO_128BITS
#define STRING_TO_AUTH_KEY STRING_TO_128BITS
#define STRING_TO_AUTH_RES STRING_TO_128BITS
#define STRING_TO_AUTN STRING_TO_128BITS
#define STRING_TO_KASME STRING_TO_256BITS
#define STRING_TO_XRES(sTRING, lENGTH, cONTAINER, rET) \
do { \
STRING_TO_XBITS(sTRING, lENGTH, (cONTAINER)->data, rET); \
if (rET != -1) (cONTAINER)->size = lENGTH; \
} while (0)
/* RES amd XRES can have a variable length of 4-16 octets */
typedef struct {
......@@ -93,18 +91,22 @@ typedef struct {
uint8_t data[XRES_LENGTH_MAX];
} res_t;
#define FORMAT_128BITS "%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x"
#define XRES_FORMAT FORMAT_128BITS
#define RAND_FORMAT FORMAT_128BITS
#define AUTN_FORMAT FORMAT_128BITS
#define FORMAT_128BITS \
"%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%" \
"02x,%02x"
#define XRES_FORMAT FORMAT_128BITS
#define RAND_FORMAT FORMAT_128BITS
#define AUTN_FORMAT FORMAT_128BITS
#define KASME_FORMAT FORMAT_128BITS
#define DISPLAY_128BITS(bUFFER) \
bUFFER[0], bUFFER[1], bUFFER[2], bUFFER[3], bUFFER[4], bUFFER[5], bUFFER[6], bUFFER[7], \
bUFFER[8], bUFFER[9], bUFFER[10], bUFFER[11], bUFFER[12], bUFFER[13], bUFFER[14], bUFFER[15]
#define DISPLAY_128BITS_2(bUFFER) \
bUFFER[16], bUFFER[17], bUFFER[18], bUFFER[19], bUFFER[20], bUFFER[21], bUFFER[22], bUFFER[23], \
bUFFER[24], bUFFER[25], bUFFER[26], bUFFER[27], bUFFER[28], bUFFER[29], bUFFER[30], bUFFER[31]
#define DISPLAY_128BITS(bUFFER) \
bUFFER[0], bUFFER[1], bUFFER[2], bUFFER[3], bUFFER[4], bUFFER[5], bUFFER[6], \
bUFFER[7], bUFFER[8], bUFFER[9], bUFFER[10], bUFFER[11], bUFFER[12], \
bUFFER[13], bUFFER[14], bUFFER[15]
#define DISPLAY_128BITS_2(bUFFER) \
bUFFER[16], bUFFER[17], bUFFER[18], bUFFER[19], bUFFER[20], bUFFER[21], \
bUFFER[22], bUFFER[23], bUFFER[24], bUFFER[25], bUFFER[26], bUFFER[27], \
bUFFER[28], bUFFER[29], bUFFER[30], bUFFER[31]
#define XRES_DISPLAY(bUFFER) DISPLAY_128BITS(bUFFER)
#define RAND_DISPLAY(bUFFER) DISPLAY_128BITS(bUFFER)
......@@ -121,10 +123,10 @@ typedef struct eutran_vector_s {
uint8_t kasme[KASME_LENGTH_OCTETS];
} eutran_vector_t;
#define FC_KASME (0x10)
#define FC_KENB (0x11)
#define FC_NH (0x12)
#define FC_KENB_STAR (0x13)
#define FC_KASME (0x10)
#define FC_KENB (0x11)
#define FC_NH (0x12)
#define FC_KENB_STAR (0x13)
/* 33401 #A.7 Algorithm for key derivation function.
* This FC should be used for:
* - NAS Encryption algorithm
......@@ -133,16 +135,16 @@ typedef struct eutran_vector_s {
* - RRC Integrity algorithm
* - User Plane Encryption algorithm
*/
#define FC_ALG_KEY_DER (0x15)
#define FC_KASME_TO_CK (0x16)
#define FC_ALG_KEY_DER (0x15)
#define FC_KASME_TO_CK (0x16)
typedef enum {
NAS_ENC_ALG = 0x01,
NAS_INT_ALG = 0x02,
RRC_ENC_ALG = 0x03,
RRC_INT_ALG = 0x04,
UP_ENC_ALG = 0x05,
UP_INT_ALG = 0x06
UP_ENC_ALG = 0x05,
UP_INT_ALG = 0x06
} algorithm_type_dist_t;
#endif /* FILE_SECURITY_TYPES_SEEN */
src/itti/itti.cpp
View file @ 40faab75
......@@ -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
*
......@@ -34,13 +34,14 @@
#include <algorithm>
#include <csignal>
extern itti_mw *itti_inst;
extern itti_mw* itti_inst;
static itti_timer null_timer(ITTI_INVALID_TIMER_ID, TASK_NONE, 0xFFFFFFFF, 0xFFFFFFFF, 0, 0);
static itti_timer null_timer(
ITTI_INVALID_TIMER_ID, TASK_NONE, 0xFFFFFFFF, 0xFFFFFFFF, 0, 0);
//------------------------------------------------------------------------------
void itti_mw::timer_manager_task(const util::thread_sched_params& sched_params)
{
void itti_mw::timer_manager_task(
const util::thread_sched_params& sched_params) {
Logger::itti().info("Starting timer_manager_task");
sched_params.apply(TASK_ITTI_TIMER, Logger::itti());
while (true) {
......@@ -51,20 +52,26 @@ void itti_mw::timer_manager_task(const util::thread_sched_params& sched_params)
itti_inst->c_timers.wait(lx);
}
std::set<itti_timer>::iterator it = itti_inst->timers.begin();
itti_inst->current_timer = std::ref(*it);
itti_inst->current_timer = std::ref(*it);
itti_inst->timers.erase(it);
lx.unlock();
// check time-out
if (itti_inst->current_timer.time_out > std::chrono::system_clock::now()) {
if (itti_inst->current_timer.time_out >
std::chrono::system_clock::now()) {
std::unique_lock<std::mutex> lto(itti_inst->m_timeout);
auto diff = itti_inst->current_timer.time_out - std::chrono::system_clock::now();
auto rc = itti_inst->c_timeout.wait_for( lto, diff);
auto diff = itti_inst->current_timer.time_out -
std::chrono::system_clock::now();
auto rc = itti_inst->c_timeout.wait_for(lto, diff);
lto.unlock();
if ( std::cv_status::timeout == rc) {
if (std::cv_status::timeout == rc) {
// signal time-out
itti_msg_timeout mto(TASK_ITTI_TIMER, itti_inst->current_timer.task_id, itti_inst->current_timer.id, itti_inst->current_timer.arg1_user, itti_inst->current_timer.arg2_user);
std::shared_ptr<itti_msg_timeout> msgsh = std::make_shared<itti_msg_timeout>(mto);
itti_msg_timeout mto(
TASK_ITTI_TIMER, itti_inst->current_timer.task_id,
itti_inst->current_timer.id, itti_inst->current_timer.arg1_user,
itti_inst->current_timer.arg2_user);
std::shared_ptr<itti_msg_timeout> msgsh =
std::make_shared<itti_msg_timeout>(mto);
int ret = itti_inst->send_msg(msgsh);
} else {
// other timer required ?
......@@ -74,20 +81,33 @@ void itti_mw::timer_manager_task(const util::thread_sched_params& sched_params)
}
itti_inst->current_timer = null_timer;
itti_inst->m_timers.unlock();
//cout << "cv.wait released by other triggered timer end" << endl;
// cout << "cv.wait released by other triggered timer end" << endl;
}
} else {
// signal time-out
itti_msg_timeout mto(TASK_ITTI_TIMER, itti_inst->current_timer.task_id, itti_inst->current_timer.id, itti_inst->current_timer.arg1_user, itti_inst->current_timer.arg2_user);
std::shared_ptr<itti_msg_timeout> msgsh = std::make_shared<itti_msg_timeout>(mto);
itti_msg_timeout mto(
TASK_ITTI_TIMER, itti_inst->current_timer.task_id,
itti_inst->current_timer.id, itti_inst->current_timer.arg1_user,
itti_inst->current_timer.arg2_user);
std::shared_ptr<itti_msg_timeout> msgsh =
std::make_shared<itti_msg_timeout>(mto);
itti_inst->send_msg(msgsh);
}
}
}
}
//------------------------------------------------------------------------------
itti_mw::itti_mw() : timer_id(0), msg_number(0), created_tasks(0), ready_tasks(0), m_timers(), current_timer(null_timer), m_timeout(), m_timer_id(), terminate(false) {
std::fill(itti_task_ctxts, itti_task_ctxts+TASK_MAX, nullptr );
itti_mw::itti_mw()
: timer_id(0),
msg_number(0),
created_tasks(0),
ready_tasks(0),
m_timers(),
current_timer(null_timer),
m_timeout(),
m_timer_id(),
terminate(false) {
std::fill(itti_task_ctxts, itti_task_ctxts + TASK_MAX, nullptr);
}
//------------------------------------------------------------------------------
......@@ -108,25 +128,23 @@ itti_mw::~itti_mw() {
//------------------------------------------------------------------------------
void itti_mw::start(const util::thread_sched_params& sched_params) {
Logger::itti().startup( "Starting..." );
Logger::itti().startup("Starting...");
timer_thread = std::thread(timer_manager_task, sched_params);
Logger::itti().startup( "Started" );
Logger::itti().startup("Started");
}
//------------------------------------------------------------------------------
timer_id_t itti_mw::increment_timer_id () {
timer_id_t itti_mw::increment_timer_id() {
return ++timer_id;
}
//------------------------------------------------------------------------------
unsigned int itti_mw::increment_message_number () {
unsigned int itti_mw::increment_message_number() {
return __sync_fetch_and_add(&msg_number, 1);
}
//------------------------------------------------------------------------------
int itti_mw::create_task (const task_id_t task_id,
void (*start_routine) (void *),
void *args_p)
{
int itti_mw::create_task(
const task_id_t task_id, void (*start_routine)(void*), void* args_p) {
if (nullptr == start_routine) {
Logger::itti().error("Null start routine for task %d", task_id);
return RETURNerror;
......@@ -142,9 +160,10 @@ int itti_mw::create_task (const task_id_t task_id,
created_tasks++;
lk.unlock();
}
itti_task_ctxts[task_id]->thread = std::thread(start_routine,args_p);
while ((itti_task_ctxts[task_id]->task_state != TASK_STATE_READY) && (itti_task_ctxts[task_id]->task_state != TASK_STATE_ENDED))
usleep (1000);
itti_task_ctxts[task_id]->thread = std::thread(start_routine, args_p);
while ((itti_task_ctxts[task_id]->task_state != TASK_STATE_READY) &&
(itti_task_ctxts[task_id]->task_state != TASK_STATE_ENDED))
usleep(1000);
return 0;
} else {
Logger::itti().error("Try to start an already started task %d", task_id);
......@@ -156,8 +175,7 @@ int itti_mw::create_task (const task_id_t task_id,
}
//------------------------------------------------------------------------------
int itti_mw::notify_task_ready(const task_id_t task_id)
{
int itti_mw::notify_task_ready(const task_id_t task_id) {
if (itti_task_ctxts[task_id]) {
itti_task_ctxts[task_id]->m_state.lock();
if (itti_task_ctxts[task_id]->task_state == TASK_STATE_STARTING) {
......@@ -166,7 +184,9 @@ int itti_mw::notify_task_ready(const task_id_t task_id)
return RETURNok;
}
itti_task_ctxts[task_id]->m_state.unlock();
Logger::itti().error("Notify task ready, bad state %d", itti_task_ctxts[task_id]->task_state);
Logger::itti().error(
"Notify task ready, bad state %d",
itti_task_ctxts[task_id]->task_state);
} else {
Logger::itti().error("Notify task ready, task not starting %d", task_id);
}
......@@ -175,23 +195,30 @@ int itti_mw::notify_task_ready(const task_id_t task_id)
//------------------------------------------------------------------------------
int itti_mw::send_msg(std::shared_ptr<itti_msg> message) {
if ((TASK_FIRST <= message->destination) && (TASK_MAX > message->destination)) {
if ((TASK_FIRST <= message->destination) &&
(TASK_MAX > message->destination)) {
if (itti_task_ctxts[message->destination]) {
if (itti_task_ctxts[message->destination]->task_state == TASK_STATE_READY) {
std::unique_lock<std::mutex> l(itti_task_ctxts[message->destination]->m_queue);
//res =
if (itti_task_ctxts[message->destination]->task_state ==
TASK_STATE_READY) {
std::unique_lock<std::mutex> l(
itti_task_ctxts[message->destination]->m_queue);
// res =
itti_task_ctxts[message->destination]->msg_queue.push(message);
itti_task_ctxts[message->destination]->c_queue.notify_one();
return RETURNok;
} else if (itti_task_ctxts[message->destination]->task_state == TASK_STATE_ENDED) {
Logger::itti().warn("Unicast message number %lu can not be sent from %d to %d, ended destination task!",
} else if (
itti_task_ctxts[message->destination]->task_state ==
TASK_STATE_ENDED) {
Logger::itti().warn(
"Unicast message number %lu can not be sent from %d to %d, ended "
"destination task!",
message->msg_num, message->origin, message->destination);
return RETURNerror;
}
} else {
Logger::itti().warn("Unicast message number %lu can not be sent from %d to %d, not started destination task!",
Logger::itti().warn(
"Unicast message number %lu can not be sent from %d to %d, not "
"started destination task!",
message->msg_num, message->origin, message->destination);
}
} else if (message->destination == TASK_ALL) {
......@@ -202,7 +229,6 @@ int itti_mw::send_msg(std::shared_ptr<itti_msg> message) {
//------------------------------------------------------------------------------
int itti_mw::send_broadcast_msg(std::shared_ptr<itti_msg> message) {
if (TASK_ALL == message->destination) {
for (int t = TASK_FIRST; t < TASK_MAX; t++) {
if (itti_task_ctxts[t]) {
......@@ -211,11 +237,16 @@ int itti_mw::send_broadcast_msg(std::shared_ptr<itti_msg> message) {
itti_task_ctxts[t]->msg_queue.push(message);
itti_task_ctxts[t]->c_queue.notify_one();
} else if (itti_task_ctxts[t]->task_state == TASK_STATE_ENDED) {
Logger::itti().warn("Broadcast message number %lu can not be sent from %d to %d, ended destination task!",
Logger::itti().warn(
"Broadcast message number %lu can not be sent from %d to %d, "
"ended destination task!",
message->msg_num, message->origin, t);
} else {
Logger::itti().warn("Broadcast message number %lu can not be sent from %d to %d, unknown state %d !",
message->msg_num, message->origin, t, itti_task_ctxts[t]->task_state);
Logger::itti().warn(
"Broadcast message number %lu can not be sent from %d to %d, "
"unknown state %d !",
message->msg_num, message->origin, t,
itti_task_ctxts[t]->task_state);
}
}
}
......@@ -226,24 +257,24 @@ int itti_mw::send_broadcast_msg(std::shared_ptr<itti_msg> message) {
//------------------------------------------------------------------------------
int itti_mw::send_terminate_msg(task_id_t src_task_id) {
itti_msg_terminate msg(src_task_id, TASK_ALL);
terminate = true;
std::shared_ptr<itti_msg_terminate> smsg = std::make_shared<itti_msg_terminate>(msg);
std::shared_ptr<itti_msg_terminate> smsg =
std::make_shared<itti_msg_terminate>(msg);
int ret = itti_inst->send_broadcast_msg(smsg);
return ret;
}
//------------------------------------------------------------------------------
std::shared_ptr<itti_msg> itti_mw::receive_msg (task_id_t task_id)
{
std::shared_ptr<itti_msg> itti_mw::receive_msg(task_id_t task_id) {
if ((TASK_FIRST <= task_id) && (TASK_MAX > task_id)) {
if (itti_task_ctxts[task_id]) {
std::unique_lock<std::mutex> lk(itti_task_ctxts[task_id]->m_queue);
while (itti_task_ctxts[task_id]->msg_queue.empty()) {
itti_task_ctxts[task_id]->c_queue.wait(lk);
}
std::shared_ptr<itti_msg> msg = itti_task_ctxts[task_id]->msg_queue.front();
std::shared_ptr<itti_msg> msg =
itti_task_ctxts[task_id]->msg_queue.front();
itti_task_ctxts[task_id]->msg_queue.pop();
return msg;
}
......@@ -253,13 +284,13 @@ std::shared_ptr<itti_msg> itti_mw::receive_msg (task_id_t task_id)
}
//------------------------------------------------------------------------------
std::shared_ptr<itti_msg> itti_mw::poll_msg (task_id_t task_id)
{
std::shared_ptr<itti_msg> itti_mw::poll_msg(task_id_t task_id) {
if ((TASK_FIRST <= task_id) && (TASK_MAX > task_id)) {
if (itti_task_ctxts[task_id]) {
std::lock_guard<std::mutex> lk(itti_task_ctxts[task_id]->m_queue);
if (!itti_task_ctxts[task_id]->msg_queue.empty()) {
std::shared_ptr<itti_msg> msg = itti_task_ctxts[task_id]->msg_queue.front();
if (!itti_task_ctxts[task_id]->msg_queue.empty()) {
std::shared_ptr<itti_msg> msg =
itti_task_ctxts[task_id]->msg_queue.front();
itti_task_ctxts[task_id]->msg_queue.pop();
return msg;
}
......@@ -269,9 +300,7 @@ std::shared_ptr<itti_msg> itti_mw::poll_msg (task_id_t task_id)
}
//------------------------------------------------------------------------------
void itti_mw::wait_tasks_end (void)
{
void itti_mw::wait_tasks_end(void) {
Logger::itti().info("Waiting ITTI tasks closed");
for (int task_idx = TASK_FIRST; task_idx < TASK_MAX; task_idx++) {
if (itti_task_ctxts[task_idx]) {
......@@ -287,16 +316,14 @@ void itti_mw::wait_tasks_end (void)
}
//------------------------------------------------------------------------------
timer_id_t itti_mw::timer_setup (
uint32_t interval_sec,
uint32_t interval_us,
task_id_t task_id,
uint64_t arg1_user,
uint64_t arg2_user)
{
timer_id_t itti_mw::timer_setup(
uint32_t interval_sec, uint32_t interval_us, task_id_t task_id,
uint64_t arg1_user, uint64_t arg2_user) {
// Not sending to task timer
if ((TASK_FIRST < task_id) && (TASK_MAX > task_id)) {
itti_timer t(increment_timer_id(), task_id, interval_sec, interval_us, arg1_user, arg2_user);
itti_timer t(
increment_timer_id(), task_id, interval_sec, interval_us, arg1_user,
arg2_user);
timer_id_t id = t.id;
std::unique_lock<std::mutex> l(m_timers);
timers.insert(t);
......@@ -311,11 +338,10 @@ timer_id_t itti_mw::timer_setup (
}
//------------------------------------------------------------------------------
int itti_mw::timer_remove (timer_id_t timer_id)
{
int itti_mw::timer_remove(timer_id_t timer_id) {
std::lock_guard<std::mutex> lk(m_timers);
if (current_timer.id == timer_id) {
//cout << "timer_remove() current_timer.id == timer_id" << endl;
// cout << "timer_remove() current_timer.id == timer_id" << endl;
current_timer = null_timer;
c_timers.notify_one();
// wake up thread timer if necessary
......@@ -324,7 +350,7 @@ int itti_mw::timer_remove (timer_id_t timer_id)
return RETURNok;
} else {
std::set<itti_timer>::iterator it = itti_inst->timers.begin();
while(it != itti_inst->timers.end()) {
while (it != itti_inst->timers.end()) {
if (it->id == timer_id) {
itti_inst->timers.erase(it);
return RETURNok;
......@@ -335,4 +361,3 @@ int itti_mw::timer_remove (timer_id_t timer_id)
Logger::itti().trace("Removing timer 0x%lx: Not found", timer_id);
return RETURNerror;
}
src/itti/itti.hpp
View file @ 40faab75
......@@ -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
*
......@@ -27,7 +27,6 @@
#ifndef SRC_OAI_ITTI_ITTI_HPP_INCLUDED_
#define SRC_OAI_ITTI_ITTI_HPP_INCLUDED_
#include <chrono>
#include <condition_variable>
//#include <iomanip>
......@@ -42,104 +41,125 @@
#include "thread_sched.hpp"
typedef volatile enum task_state_s {
TASK_STATE_NOT_CONFIGURED, TASK_STATE_STARTING, TASK_STATE_READY, TASK_STATE_ENDED, TASK_STATE_MAX,
TASK_STATE_NOT_CONFIGURED,
TASK_STATE_STARTING,
TASK_STATE_READY,
TASK_STATE_ENDED,
TASK_STATE_MAX,
} task_state_t;
typedef uint32_t timer_id_t;
#define ITTI_INVALID_TIMER_ID (timer_id_t)0
#define ITTI_INVALID_TIMER_ID (timer_id_t) 0
class itti_timer {
public:
itti_timer(const timer_id_t id, const task_id_t task_id, const uint32_t interval_sec, const uint32_t interval_us, uint64_t arg1_user, uint64_t arg2_user) :
id(id), task_id(task_id), arg1_user(arg1_user), arg2_user(arg2_user) {
time_out = std::chrono::system_clock::now() + std::chrono::seconds(interval_sec) + std::chrono::microseconds(interval_us);
}
itti_timer(const timer_id_t id, const task_id_t task_id, const std::chrono::system_clock::time_point time_out, uint64_t arg1_user, uint64_t arg2_user) :
id(id), task_id(task_id), time_out(time_out), arg1_user(arg1_user), arg2_user(arg2_user) {
public:
itti_timer(
const timer_id_t id, const task_id_t task_id, const uint32_t interval_sec,
const uint32_t interval_us, uint64_t arg1_user, uint64_t arg2_user)
: id(id), task_id(task_id), arg1_user(arg1_user), arg2_user(arg2_user) {
time_out = std::chrono::system_clock::now() +
std::chrono::seconds(interval_sec) +
std::chrono::microseconds(interval_us);
}
itti_timer(const itti_timer &t) : id(t.id), task_id(t.task_id) , time_out(t.time_out), arg1_user(t.arg1_user), arg2_user(t.arg2_user) {}
//itti_timer(itti_timer&& t) noexcept : id(std::move(t.id)), task_id(std::move(t.task_id)) , time_out(std::move(t.time_out)) {}
itti_timer(
const timer_id_t id, const task_id_t task_id,
const std::chrono::system_clock::time_point time_out, uint64_t arg1_user,
uint64_t arg2_user)
: id(id),
task_id(task_id),
time_out(time_out),
arg1_user(arg1_user),
arg2_user(arg2_user) {}
itti_timer(const itti_timer& t)
: id(t.id),
task_id(t.task_id),
time_out(t.time_out),
arg1_user(t.arg1_user),
arg2_user(t.arg2_user) {}
// itti_timer(itti_timer&& t) noexcept : id(std::move(t.id)),
// task_id(std::move(t.task_id)) , time_out(std::move(t.time_out)) {}
bool operator<(const itti_timer& t) const { return time_out < t.time_out; }
~itti_timer() {}
timer_id_t id;
task_id_t task_id;
timer_id_t id;
task_id_t task_id;
std::chrono::system_clock::time_point time_out;
uint64_t arg1_user;
uint64_t arg2_user;
uint64_t arg1_user;
uint64_t arg2_user;
};
//------------------------------------------------------------------------------
struct timer_comparator {
bool operator()(const itti_timer &left, const itti_timer &right) const
{
return (left.time_out < right.time_out);
}
bool operator()(const itti_timer& left, const itti_timer& right) const {
return (left.time_out < right.time_out);
}
};
class itti_task_ctxt {
public:
explicit itti_task_ctxt(const task_id_t task_id) :
task_id(task_id), m_state(), task_state(TASK_STATE_STARTING), msg_queue() , m_queue(), c_queue() {}
public:
explicit itti_task_ctxt(const task_id_t task_id)
: task_id(task_id),
m_state(),
task_state(TASK_STATE_STARTING),
msg_queue(),
m_queue(),
c_queue() {}
~itti_task_ctxt() {}
const task_id_t task_id;
const task_id_t task_id;
/*
* pthread associated with the thread
*/
//std::thread::id thread_id;
std::thread thread;
// std::thread::id thread_id;
std::thread thread;
/*
* State of the thread
*/
std::mutex m_state;
volatile task_state_t task_state;
std::mutex m_state;
volatile task_state_t task_state;
std::queue<std::shared_ptr<itti_msg>> msg_queue;
std::mutex m_queue;
std::condition_variable c_queue;
std::queue<std::shared_ptr<itti_msg>> msg_queue;
std::mutex m_queue;
std::condition_variable c_queue;
};
class itti_mw {
private:
itti_task_ctxt *itti_task_ctxts[TASK_MAX];
private:
itti_task_ctxt* itti_task_ctxts[TASK_MAX];
/*
* Current message number. Incremented every call to send_msg_to_task
*/
unsigned long msg_number;
timer_id_t timer_id;
std::mutex m_timer_id;
std::thread timer_thread;
unsigned long msg_number;
timer_id_t timer_id;
std::mutex m_timer_id;
std::thread timer_thread;
std::atomic<int> created_tasks;
std::atomic<int> ready_tasks;
std::atomic<int> created_tasks;
std::atomic<int> ready_tasks;
std::set<itti_timer, timer_comparator> timers;
itti_timer current_timer;
std::mutex m_timers;
std::condition_variable c_timers;
std::set<itti_timer, timer_comparator> timers;
itti_timer current_timer;
std::mutex m_timers;
std::condition_variable c_timers;
std::mutex m_timeout;
std::condition_variable c_timeout;
std::mutex m_timeout;
std::condition_variable c_timeout;
bool terminate;
bool terminate;
static void timer_manager_task(const util::thread_sched_params& sched_params);
public:
public:
itti_mw();
itti_mw(itti_mw const&) = delete;
void operator=(itti_mw const&) = delete;
itti_mw(itti_mw const&) = delete;
void operator=(itti_mw const&) = delete;
~itti_mw();
void start(const util::thread_sched_params& sched_params);
timer_id_t increment_timer_id ();
unsigned int increment_message_number ();
timer_id_t increment_timer_id();
unsigned int increment_message_number();
/** \brief Send a broadcast message to every task
\param message_p Pointer to the message to send
......@@ -158,13 +178,13 @@ public:
\param task_id Task ID of the receiving task
\param received_msg Pointer to the allocated message
**/
std::shared_ptr<itti_msg> receive_msg (task_id_t task_id);
std::shared_ptr<itti_msg> receive_msg(task_id_t task_id);
/** \brief Try to retrieves a message in the queue associated to task_id.
\param task_id Task ID of the receiving task
\param received_msg Pointer to the allocated message
**/
std::shared_ptr<itti_msg> poll_msg(task_id_t task_id);
std::shared_ptr<itti_msg> poll_msg(task_id_t task_id);
/** \brief Start thread associated to the task
* \param task_id task to start
......@@ -172,9 +192,8 @@ public:
* \param args_p Optional argument to pass to the start routine
* @returns -1 on failure, 0 otherwise
**/
int create_task (const task_id_t task_id,
void (*start_routine) (void *),
void *args_p);
int create_task(
const task_id_t task_id, void (*start_routine)(void*), void* args_p);
/** \brief Notify ITTI of a started thread
* \param task_id of started task
......@@ -184,18 +203,20 @@ public:
**/
int notify_task_ready(const task_id_t task_id);
/** \brief Indicates to ITTI if newly created tasks should wait for all tasks to be ready
* \param wait_tasks non 0 to make new created tasks to wait, 0 to let created tasks to run
/** \brief Indicates to ITTI if newly created tasks should wait for all tasks
*to be ready \param wait_tasks non 0 to make new created tasks to wait, 0 to
*let created tasks to run
**/
//void wait_ready(int wait_tasks);
// void wait_ready(int wait_tasks);
/** \brief Mark the task as in ready state
* \param task_id task to mark as ready
**/
//void mark_task_ready(task_id_t task_id);
// void mark_task_ready(task_id_t task_id);
/** \brief handle signals and wait for all threads to join when the process complete.
* This function should be called from the main thread after having created all ITTI tasks.
/** \brief handle signals and wait for all threads to join when the process
*complete. This function should be called from the main thread after having
*created all ITTI tasks.
**/
void wait_tasks_end(void);
......@@ -211,22 +232,17 @@ public:
* @returns 0 on failure, timer id otherwise
**/
timer_id_t timer_setup(
uint32_t interval_sec,
uint32_t interval_us,
task_id_t task_id,
uint64_t arg1_user = 0,
uint64_t arg2_user = 0);
uint32_t interval_sec, uint32_t interval_us, task_id_t task_id,
uint64_t arg1_user = 0, uint64_t arg2_user = 0);
/** \brief Remove the timer from list
* \param timer_id unique timer id
* \param task_id task id of the task that requested the timer
* @returns -1 on failure, 0 otherwise
**/
int timer_remove (timer_id_t timer_id);
static void signal_handler( int signum );
int timer_remove(timer_id_t timer_id);
static void signal_handler(int signum);
};
#endif /* SRC_OAI_ITTI_ITTI_HPP_INCLUDED_ */
src/itti/itti_msg.cpp
View file @ 40faab75
......@@ -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
*
......@@ -28,24 +28,25 @@
#include "itti_msg.hpp"
#include "itti.hpp"
extern itti_mw *itti_inst;
extern itti_mw* itti_inst;
itti_msg::itti_msg() :
msg_type(ITTI_MSG_TYPE_NONE), origin(TASK_NONE), destination(TASK_NONE) {
itti_msg::itti_msg()
: msg_type(ITTI_MSG_TYPE_NONE), origin(TASK_NONE), destination(TASK_NONE) {
msg_num = itti_inst->increment_message_number();
};
itti_msg::itti_msg(const itti_msg_type_t msg_type, task_id_t origin, task_id_t destination) :
msg_type(msg_type), origin(origin), destination(destination) {
itti_msg::itti_msg(
const itti_msg_type_t msg_type, task_id_t origin, task_id_t destination)
: msg_type(msg_type), origin(origin), destination(destination) {
msg_num = itti_inst->increment_message_number();
};
itti_msg::itti_msg(const itti_msg& i) :
msg_type(i.msg_type),msg_num(i.msg_num), origin(i.origin), destination(i.destination) {
};
itti_msg::itti_msg(const itti_msg& i)
: msg_type(i.msg_type),
msg_num(i.msg_num),
origin(i.origin),
destination(i.destination){};
const char* itti_msg::get_msg_name()
{
const char* itti_msg::get_msg_name() {
return "UNINITIALIZED";
}
src/itti/itti_msg.hpp
View file @ 40faab75
......@@ -4,8 +4,8 @@
* 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
* file except in compliance with the License. You may obtain a copy of the
* License at
*
* http://www.openairinterface.org/?page_id=698
*
......
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