chore: update opensomeip submodule to v0.2.0

pyproject.toml

@@ -145,4 +145,4 @@ name = "Miscellaneous"
 showcontent = false
 
 [tool.opensomeip]
-opensomeip-version = "0.1.0"
+opensomeip-version = "0.2.0"

src/_opensomeip/e2e_bind.cpp

@@ -45,7 +45,10 @@ void init_e2e(py::module_& m) {
         .def_readwrite("profile_id", &E2EConfig::profile_id)
         .def_readwrite("profile_name", &E2EConfig::profile_name)
         .def_readwrite("data_id", &E2EConfig::data_id)
-        .def_readwrite("offset", &E2EConfig::offset)
+        .def_readwrite("offset_bits", &E2EConfig::offset_bits)
+        .def_property_readonly_static(
+            "DEFAULT_OFFSET_BITS",
+            [](py::object /*cls*/) { return E2EConfig::DEFAULT_OFFSET_BITS; })
         .def_readwrite("enable_crc", &E2EConfig::enable_crc)
         .def_readwrite("enable_counter", &E2EConfig::enable_counter)
         .def_readwrite("enable_freshness", &E2EConfig::enable_freshness)

src/_opensomeip/events_bind.cpp

@@ -112,9 +112,19 @@ void init_events(py::module_& m) {
              py::call_guard<py::gil_scoped_release>())
         .def("set_default_client_endpoint", &EventPublisher::set_default_client_endpoint,
              py::arg("address"), py::arg("port"))
-        .def("handle_subscription", &EventPublisher::handle_subscription,
+        .def("handle_subscription",
+             static_cast<bool (EventPublisher::*)(
+                 uint16_t, uint16_t, const someip::platform::Vector<EventFilter>&)>(
+                 &EventPublisher::handle_subscription),
              py::arg("eventgroup_id"), py::arg("client_id"),
              py::arg("filters") = std::vector<EventFilter>{})
+        .def("handle_subscription",
+             static_cast<bool (EventPublisher::*)(
+                 uint16_t, uint16_t, uint32_t, const someip::platform::Vector<EventFilter>&)>(
+                 &EventPublisher::handle_subscription),
+             py::arg("eventgroup_id"), py::arg("client_id"),
+             py::arg("ttl_seconds"),
+             py::arg("filters") = std::vector<EventFilter>{})
         .def("handle_unsubscription", &EventPublisher::handle_unsubscription,
              py::arg("eventgroup_id"), py::arg("client_id"))
         .def("get_registered_events", &EventPublisher::get_registered_events)

src/_opensomeip/message_bind.cpp

@@ -52,6 +52,11 @@ void init_message(py::module_& m) {
             std::vector<uint8_t> vec(sv.begin(), sv.end());
             return msg.deserialize(vec);
         }, py::arg("data"))
+        .def("try_deserialize", [](Message& msg, py::bytes data) {
+            auto sv = static_cast<std::string_view>(data);
+            std::vector<uint8_t> vec(sv.begin(), sv.end());
+            return msg.try_deserialize(vec);
+        }, py::arg("data"))
 
         // Validation
         .def("is_valid", &Message::is_valid)

src/_opensomeip/rpc_bind.cpp

@@ -20,8 +20,13 @@ void init_rpc(py::module_& m) {
         .value("INVALID_PARAMETERS", RpcResult::INVALID_PARAMETERS)
         .value("METHOD_NOT_FOUND", RpcResult::METHOD_NOT_FOUND)
         .value("SERVICE_NOT_AVAILABLE", RpcResult::SERVICE_NOT_AVAILABLE)
+        .value("WRONG_INTERFACE_VERSION", RpcResult::WRONG_INTERFACE_VERSION)
         .value("INTERNAL_ERROR", RpcResult::INTERNAL_ERROR);
 
+    py::enum_<MethodSemantics>(rpc, "MethodSemantics")
+        .value("REQUEST_RESPONSE", MethodSemantics::REQUEST_RESPONSE)
+        .value("FIRE_AND_FORGET", MethodSemantics::FIRE_AND_FORGET);
+
     py::class_<RpcTimeout>(rpc, "RpcTimeout")
         .def(py::init<>())
         .def_readwrite("request_timeout", &RpcTimeout::request_timeout)
@@ -65,18 +70,52 @@ void init_rpc(py::module_& m) {
         .def_readonly("timeout_calls", &RpcClient::Statistics::timeout_calls)
         .def_readonly("average_response_time", &RpcClient::Statistics::average_response_time);
     rpc_client
-        .def(py::init<uint16_t>(), py::arg("client_id"))
+        .def(py::init<uint16_t, uint8_t, const someip::transport::Endpoint&>(),
+             py::arg("client_id"),
+             py::arg("interface_version") = static_cast<uint8_t>(0x01),
+             py::arg("local_bind") = someip::transport::Endpoint("0.0.0.0", 0))
         .def("initialize", &RpcClient::initialize)
         .def("shutdown", &RpcClient::shutdown, py::call_guard<py::gil_scoped_release>())
-        .def("call_method_sync", &RpcClient::call_method_sync,
+        .def("set_remote_endpoint", &RpcClient::set_remote_endpoint, py::arg("endpoint"))
+        .def("get_local_endpoint", &RpcClient::get_local_endpoint)
+        .def("call_method_sync",
+             static_cast<RpcSyncResult (RpcClient::*)(
+                 uint16_t, MethodId, const someip::platform::ByteBuffer&, const RpcTimeout&)>(
+                 &RpcClient::call_method_sync),
              py::arg("service_id"), py::arg("method_id"),
              py::arg("parameters"), py::arg("timeout") = RpcTimeout(),
              py::call_guard<py::gil_scoped_release>())
-        .def("call_method_async", &RpcClient::call_method_async,
+        .def("call_method_sync",
+             static_cast<RpcSyncResult (RpcClient::*)(
+                 uint16_t, MethodId, const someip::platform::ByteBuffer&,
+                 const someip::transport::Endpoint&, const RpcTimeout&)>(
+                 &RpcClient::call_method_sync),
+             py::arg("service_id"), py::arg("method_id"),
+             py::arg("parameters"), py::arg("server_endpoint"),
+             py::arg("timeout") = RpcTimeout(),
+             py::call_guard<py::gil_scoped_release>())
+        .def("call_method_async",
+             static_cast<RpcCallHandle (RpcClient::*)(
+                 uint16_t, MethodId, const someip::platform::ByteBuffer&, RpcCallback,
+                 const RpcTimeout&)>(
+                 &RpcClient::call_method_async),
              py::arg("service_id"), py::arg("method_id"),
              py::arg("parameters"), py::arg("callback"),
              py::arg("timeout") = RpcTimeout(),
              py::call_guard<py::gil_scoped_release>())
+        .def("call_method_async",
+             static_cast<RpcCallHandle (RpcClient::*)(
+                 uint16_t, MethodId, const someip::platform::ByteBuffer&, RpcCallback,
+                 const someip::transport::Endpoint&, const RpcTimeout&)>(
+                 &RpcClient::call_method_async),
+             py::arg("service_id"), py::arg("method_id"),
+             py::arg("parameters"), py::arg("callback"),
+             py::arg("server_endpoint"), py::arg("timeout") = RpcTimeout(),
+             py::call_guard<py::gil_scoped_release>())
+        .def("send_request_no_return", &RpcClient::send_request_no_return,
+             py::arg("service_id"), py::arg("method_id"),
+             py::arg("parameters"), py::arg("dest"),
+             py::call_guard<py::gil_scoped_release>())
         .def("cancel_call", &RpcClient::cancel_call, py::arg("handle"))
         .def("is_ready", &RpcClient::is_ready)
         .def("get_statistics", &RpcClient::get_statistics);
@@ -90,11 +129,17 @@ void init_rpc(py::module_& m) {
         .def_readonly("method_not_found_errors", &RpcServer::Statistics::method_not_found_errors)
         .def_readonly("average_processing_time", &RpcServer::Statistics::average_processing_time);
     rpc_server
-        .def(py::init<uint16_t>(), py::arg("service_id"))
+        .def(py::init<uint16_t, uint8_t, const someip::transport::Endpoint&>(),
+             py::arg("service_id"),
+             py::arg("interface_version") = static_cast<uint8_t>(0x01),
+             py::arg("bind_endpoint") = someip::transport::Endpoint(
+                 "127.0.0.1", SOMEIP_DEFAULT_RPC_PORT))
         .def("initialize", &RpcServer::initialize)
         .def("shutdown", &RpcServer::shutdown, py::call_guard<py::gil_scoped_release>())
         .def("register_method", &RpcServer::register_method,
-             py::arg("method_id"), py::arg("handler"))
+             py::arg("method_id"), py::arg("handler"),
+             py::arg("semantics") = MethodSemantics::REQUEST_RESPONSE)
+        .def("get_local_endpoint", &RpcServer::get_local_endpoint)
         .def("unregister_method", &RpcServer::unregister_method, py::arg("method_id"))
         .def("is_method_registered", &RpcServer::is_method_registered, py::arg("method_id"))
         .def("get_registered_methods", &RpcServer::get_registered_methods)

src/_opensomeip/sd_bind.cpp

@@ -118,6 +118,9 @@ void init_sd(py::module_& m) {
              py::arg("service_id"), py::arg("instance_id"), py::arg("eventgroup_id"))
         .def("get_available_services", &SdClient::get_available_services,
              py::arg("service_id") = 0)
+        .def("get_eventgroup_subscription_state",
+             &SdClient::get_eventgroup_subscription_state,
+             py::arg("service_id"), py::arg("instance_id"), py::arg("eventgroup_id"))
         .def("is_ready", &SdClient::is_ready)
         .def("get_statistics", &SdClient::get_statistics);
 

src/_opensomeip/tp_bind.cpp

@@ -58,13 +58,32 @@ void init_tp(py::module_& m) {
         .def_readwrite("segment_offset", &TpSegmentHeader::segment_offset)
         .def_readwrite("segment_length", &TpSegmentHeader::segment_length)
         .def_readwrite("sequence_number", &TpSegmentHeader::sequence_number)
-        .def_readwrite("message_type", &TpSegmentHeader::message_type);
+        .def_readwrite("message_type", &TpSegmentHeader::message_type)
+        .def_readwrite("service_id", &TpSegmentHeader::service_id)
+        .def_readwrite("method_id", &TpSegmentHeader::method_id)
+        .def_readwrite("client_id", &TpSegmentHeader::client_id)
+        .def_readwrite("session_id", &TpSegmentHeader::session_id)
+        .def_readwrite("protocol_version", &TpSegmentHeader::protocol_version)
+        .def_readwrite("interface_version", &TpSegmentHeader::interface_version);
 
     py::class_<TpSegment>(tp, "TpSegment")
         .def(py::init<>())
         .def_readwrite("header", &TpSegment::header)
         .def_readwrite("payload", &TpSegment::payload)
-        .def_readwrite("retransmit_count", &TpSegment::retransmit_count);
+        .def_readwrite("retransmit_count", &TpSegment::retransmit_count)
+        .def_readwrite("sender_ipv4", &TpSegment::sender_ipv4)
+        .def_readwrite("sender_port", &TpSegment::sender_port);
+
+    py::class_<TpReassemblyKey>(tp, "TpReassemblyKey")
+        .def(py::init<>())
+        .def_readwrite("message_id", &TpReassemblyKey::message_id)
+        .def_readwrite("protocol_version", &TpReassemblyKey::protocol_version)
+        .def_readwrite("interface_version", &TpReassemblyKey::interface_version)
+        .def_readwrite("message_type", &TpReassemblyKey::message_type)
+        .def_readwrite("request_id", &TpReassemblyKey::request_id)
+        .def_readwrite("sender_ipv4", &TpReassemblyKey::sender_ipv4)
+        .def_readwrite("sender_port", &TpReassemblyKey::sender_port)
+        .def("__eq__", &TpReassemblyKey::operator==);
 
     py::class_<TpStatistics>(tp, "TpStatistics")
         .def(py::init<>())
@@ -84,10 +103,27 @@ void init_tp(py::module_& m) {
 
     py::class_<TpReassembler>(tp, "TpReassembler")
         .def(py::init<const TpConfig&>(), py::arg("config") = TpConfig())
-        .def("process_segment", &TpReassembler::process_segment,
+        .def("process_segment",
+             [](TpReassembler& reassembler, const TpSegment& segment,
+                someip::platform::ByteBuffer& complete_message) {
+                 return reassembler.process_segment(segment, complete_message, nullptr);
+             },
              py::arg("segment"), py::arg("complete_message"))
-        .def("is_reassembling", &TpReassembler::is_reassembling, py::arg("message_id"))
-        .def("cancel_reassembly", &TpReassembler::cancel_reassembly, py::arg("message_id"))
+        .def("is_reassembling",
+             static_cast<bool (TpReassembler::*)(uint32_t) const>(
+                 &TpReassembler::is_reassembling),
+             py::arg("message_id"))
+        .def("is_reassembling",
+             static_cast<bool (TpReassembler::*)(const TpReassemblyKey&) const>(
+                 &TpReassembler::is_reassembling),
+             py::arg("key"))
+        .def("cancel_reassembly",
+             static_cast<void (TpReassembler::*)(uint32_t)>(&TpReassembler::cancel_reassembly),
+             py::arg("message_id"))
+        .def("cancel_reassembly",
+             static_cast<void (TpReassembler::*)(const TpReassemblyKey&)>(
+                 &TpReassembler::cancel_reassembly),
+             py::arg("key"))
         .def("process_timeouts", &TpReassembler::process_timeouts)
         .def("get_active_reassemblies", &TpReassembler::get_active_reassemblies)
         .def("update_config", &TpReassembler::update_config, py::arg("config"));
@@ -118,6 +154,7 @@ void init_tp(py::module_& m) {
         .def("set_progress_callback", &TpManager::set_progress_callback, py::arg("callback"))
         .def("set_message_callback", &TpManager::set_message_callback, py::arg("callback"))
         .def("process_timeouts", &TpManager::process_timeouts)
-        .def("get_statistics", &TpManager::get_statistics)
+        .def("get_sender_statistics", &TpManager::get_sender_statistics)
+        .def("get_receiver_statistics", &TpManager::get_receiver_statistics)
         .def("update_config", &TpManager::update_config, py::arg("config"));
 }

src/_opensomeip/transport_bind.cpp

@@ -3,6 +3,7 @@
 #include <pybind11/chrono.h>
 
 #include "transport/endpoint.h"
+#include "transport/message_rejection.h"
 #include "transport/transport.h"
 #include "transport/udp_transport.h"
 #include "transport/tcp_transport.h"
@@ -33,6 +34,11 @@ struct PyTransportListener : ITransportListener {
         py::gil_scoped_acquire gil;
         PYBIND11_OVERRIDE_PURE(void, ITransportListener, on_error, error);
     }
+
+    void on_message_rejected(const MessageRejectionInfo& info) override {
+        py::gil_scoped_acquire gil;
+        PYBIND11_OVERRIDE(void, ITransportListener, on_message_rejected, info);
+    }
 };
 
 void init_transport(py::module_& m) {
@@ -65,12 +71,31 @@ void init_transport(py::module_& m) {
         .value("CONNECTED", TcpConnectionState::CONNECTED)
         .value("DISCONNECTING", TcpConnectionState::DISCONNECTING);
 
+    py::enum_<MessageRejectionStage>(m, "MessageRejectionStage")
+        .value("DESERIALIZE", MessageRejectionStage::DESERIALIZE)
+        .value("TCP_FRAMING", MessageRejectionStage::TCP_FRAMING)
+        .value("TP_REASSEMBLY", MessageRejectionStage::TP_REASSEMBLY)
+        .value("E2E_INTEGRITY", MessageRejectionStage::E2E_INTEGRITY);
+
+    py::class_<MessageRejectionInfo>(m, "MessageRejectionInfo")
+        .def(py::init<>())
+        .def_readwrite("sender", &MessageRejectionInfo::sender)
+        .def_readwrite("result", &MessageRejectionInfo::result)
+        .def_readwrite("stage", &MessageRejectionInfo::stage)
+        .def_readwrite("has_message_id", &MessageRejectionInfo::has_message_id)
+        .def_readwrite("message_id", &MessageRejectionInfo::message_id)
+        .def_readwrite("has_request_id", &MessageRejectionInfo::has_request_id)
+        .def_readwrite("request_id", &MessageRejectionInfo::request_id);
+
     py::class_<ITransportListener, PyTransportListener>(m, "ITransportListener")
         .def(py::init<>())
-        .def("on_message_received", &ITransportListener::on_message_received)
+        .def("on_message_received",
+             static_cast<void (ITransportListener::*)(MessagePtr, const Endpoint&)>(
+                 &ITransportListener::on_message_received))
         .def("on_connection_lost", &ITransportListener::on_connection_lost)
         .def("on_connection_established", &ITransportListener::on_connection_established)
-        .def("on_error", &ITransportListener::on_error);
+        .def("on_error", &ITransportListener::on_error)
+        .def("on_message_rejected", &ITransportListener::on_message_rejected);
 
     py::class_<UdpTransportConfig>(m, "UdpTransportConfig")
         .def(py::init<>())
@@ -82,7 +107,14 @@ void init_transport(py::module_& m) {
         .def_readwrite("enable_broadcast", &UdpTransportConfig::enable_broadcast)
         .def_readwrite("multicast_interface", &UdpTransportConfig::multicast_interface)
         .def_readwrite("multicast_ttl", &UdpTransportConfig::multicast_ttl)
-        .def_readwrite("max_message_size", &UdpTransportConfig::max_message_size);
+        .def_readwrite("max_message_size", &UdpTransportConfig::max_message_size)
+        .def_readwrite("enable_tp", &UdpTransportConfig::enable_tp);
+
+    py::class_<MulticastError>(m, "MulticastError")
+        .def(py::init<>())
+        .def_readwrite("group_address", &MulticastError::group_address)
+        .def_readwrite("interface_address", &MulticastError::interface_address)
+        .def_readwrite("system_error", &MulticastError::system_error);
 
     py::class_<UdpTransport>(m, "UdpTransport")
         .def(py::init<const Endpoint&, const UdpTransportConfig&>(),
@@ -94,6 +126,11 @@ void init_transport(py::module_& m) {
              py::arg("message"), py::arg("endpoint"),
              py::call_guard<py::gil_scoped_release>())
         .def("receive_message", &UdpTransport::receive_message)
+        .def("receive_message_with_sender", [](UdpTransport& transport) {
+            Endpoint sender;
+            MessagePtr message = transport.receive_message_with_sender(sender);
+            return py::make_tuple(std::move(message), sender);
+        })
         .def("is_running", &UdpTransport::is_running)
         .def("is_connected", &UdpTransport::is_connected)
         .def("get_local_endpoint", &UdpTransport::get_local_endpoint)
@@ -104,7 +141,8 @@ void init_transport(py::module_& m) {
              py::call_guard<py::gil_scoped_release>())
         .def("leave_multicast_group", &UdpTransport::leave_multicast_group,
              py::arg("multicast_address"),
-             py::call_guard<py::gil_scoped_release>());
+             py::call_guard<py::gil_scoped_release>())
+        .def("last_multicast_error", &UdpTransport::last_multicast_error);
 
     py::class_<TcpTransportConfig>(m, "TcpTransportConfig")
         .def(py::init<>())
@@ -133,6 +171,11 @@ void init_transport(py::module_& m) {
              py::arg("message"), py::arg("endpoint"),
              py::call_guard<py::gil_scoped_release>())
         .def("receive_message", &TcpTransport::receive_message)
+        .def("receive_message_with_sender", [](TcpTransport& transport) {
+            Endpoint sender;
+            MessagePtr message = transport.receive_message_with_sender(sender);
+            return py::make_tuple(std::move(message), sender);
+        })
         .def("is_running", &TcpTransport::is_running)
         .def("is_connected", &TcpTransport::is_connected)
         .def("get_local_endpoint", &TcpTransport::get_local_endpoint)
@@ -142,7 +185,10 @@ void init_transport(py::module_& m) {
         .def("enable_server_mode", &TcpTransport::enable_server_mode,
              py::arg("backlog") = 5,
              py::call_guard<py::gil_scoped_release>())
-        .def("accept_connection", &TcpTransport::accept_connection,
+        .def("connection_count", &TcpTransport::connection_count)
+        .def("max_connections", &TcpTransport::max_connections)
+        .def("is_peer_connected", &TcpTransport::is_peer_connected, py::arg("peer"))
+        .def("disconnect_peer", &TcpTransport::disconnect_peer, py::arg("peer"),
              py::call_guard<py::gil_scoped_release>())
         .def_static("is_magic_cookie", &TcpTransport::is_magic_cookie,
              py::arg("data"), py::arg("offset") = 0)

src/_opensomeip/types_bind.cpp

@@ -50,6 +50,7 @@ void init_types(py::module_& m) {
         .value("CONNECTION_REFUSED", Result::CONNECTION_REFUSED)
         .value("TIMEOUT", Result::TIMEOUT)
         .value("INVALID_ENDPOINT", Result::INVALID_ENDPOINT)
+        .value("MULTICAST_ERROR", Result::MULTICAST_ERROR)
         .value("INVALID_MESSAGE", Result::INVALID_MESSAGE)
         .value("INVALID_MESSAGE_TYPE", Result::INVALID_MESSAGE_TYPE)
         .value("INVALID_SERVICE_ID", Result::INVALID_SERVICE_ID)