Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 1 | // Copyright 2020 The Pigweed Authors |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| 4 | // use this file except in compliance with the License. You may obtain a copy of |
| 5 | // the License at |
| 6 | // |
| 7 | // https://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 11 | // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 12 | // License for the specific language governing permissions and limitations under |
| 13 | // the License. |
| 14 | |
Ewout van Bekkum | 7f5b305 | 2021-11-11 17:35:23 -0800 | [diff] [blame] | 15 | // clang-format off |
| 16 | #include "pw_rpc/internal/log_config.h" // PW_LOG_* macros must be first. |
| 17 | |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 18 | #include "pw_rpc/server.h" |
Ewout van Bekkum | 7f5b305 | 2021-11-11 17:35:23 -0800 | [diff] [blame] | 19 | // clang-format on |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 20 | |
Wyatt Hepler | 3e2d719 | 2020-06-11 08:28:21 -0700 | [diff] [blame] | 21 | #include <algorithm> |
| 22 | |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 23 | #include "pw_log/log.h" |
Wyatt Hepler | ddfc077 | 2021-09-03 16:46:25 -0700 | [diff] [blame] | 24 | #include "pw_rpc/internal/endpoint.h" |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 25 | #include "pw_rpc/internal/packet.h" |
| 26 | |
| 27 | namespace pw::rpc { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 28 | namespace { |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 29 | |
| 30 | using internal::Packet; |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 31 | using internal::PacketType; |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 32 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 33 | } // namespace |
| 34 | |
Alexei Frolov | ba93a43 | 2021-12-02 13:36:26 -0800 | [diff] [blame] | 35 | Status Server::ProcessPacket(ConstByteSpan packet_data, |
| 36 | ChannelOutput* interface) { |
Dennis Kormalev | e730306 | 2022-04-01 15:48:39 +0000 | [diff] [blame] | 37 | PW_TRY_ASSIGN(Packet packet, |
Ted Pudlik | 4180d4d | 2021-10-28 00:07:29 +0000 | [diff] [blame] | 38 | Endpoint::ProcessPacket(packet_data, Packet::kServer)); |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 39 | |
Wyatt Hepler | c8bdc7d | 2021-10-20 09:29:01 -0700 | [diff] [blame] | 40 | internal::rpc_lock().lock(); |
Wyatt Hepler | 1d000cc | 2021-10-20 11:05:06 -0700 | [diff] [blame] | 41 | internal::ServerCall* const call = |
| 42 | static_cast<internal::ServerCall*>(FindCall(packet)); |
| 43 | |
Wyatt Hepler | 3aab7f6 | 2021-10-05 16:14:51 -0700 | [diff] [blame] | 44 | // Verbose log for debugging. |
| 45 | // PW_LOG_DEBUG("RPC server received packet type %u for %u:%08x/%08x", |
| 46 | // static_cast<unsigned>(packet.type()), |
| 47 | // static_cast<unsigned>(packet.channel_id()), |
| 48 | // static_cast<unsigned>(packet.service_id()), |
| 49 | // static_cast<unsigned>(packet.method_id())); |
| 50 | |
Wyatt Hepler | ddfc077 | 2021-09-03 16:46:25 -0700 | [diff] [blame] | 51 | internal::Channel* channel = GetInternalChannel(packet.channel_id()); |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 52 | if (channel == nullptr) { |
Wyatt Hepler | 3d57eaa | 2022-02-01 18:31:07 -0800 | [diff] [blame] | 53 | // If an interface was provided, respond with a SERVER_ERROR to indicate |
| 54 | // that the channel is not available on this server. Don't send responses to |
| 55 | // error messages, though, to avoid potential infinite cycles. |
| 56 | if (interface != nullptr && packet.type() != PacketType::CLIENT_ERROR) { |
| 57 | internal::Channel(packet.channel_id(), interface) |
| 58 | .Send(Packet::ServerError(packet, Status::Unavailable())) |
| 59 | .IgnoreError(); |
Alexei Frolov | ba93a43 | 2021-12-02 13:36:26 -0800 | [diff] [blame] | 60 | } |
| 61 | |
Wyatt Hepler | 3d57eaa | 2022-02-01 18:31:07 -0800 | [diff] [blame] | 62 | internal::rpc_lock().unlock(); |
| 63 | PW_LOG_WARN("RPC server received packet for unknown channel %u", |
| 64 | static_cast<unsigned>(packet.channel_id())); |
| 65 | return Status::Unavailable(); |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 66 | } |
| 67 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 68 | const auto [service, method] = FindMethod(packet); |
| 69 | |
| 70 | if (method == nullptr) { |
Wyatt Hepler | 3be460d | 2021-09-09 16:28:12 -0700 | [diff] [blame] | 71 | // Don't send responses to errors to avoid infinite error cycles. |
| 72 | if (packet.type() != PacketType::CLIENT_ERROR) { |
| 73 | channel->Send(Packet::ServerError(packet, Status::NotFound())) |
| 74 | .IgnoreError(); |
| 75 | } |
Wyatt Hepler | af16dbb | 2022-01-27 20:15:15 -0800 | [diff] [blame] | 76 | internal::rpc_lock().unlock(); |
Wyatt Hepler | 3be460d | 2021-09-09 16:28:12 -0700 | [diff] [blame] | 77 | return OkStatus(); // OK since the packet was handled. |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 78 | } |
| 79 | |
| 80 | switch (packet.type()) { |
| 81 | case PacketType::REQUEST: { |
Wyatt Hepler | 960f5df | 2021-09-08 10:17:21 -0700 | [diff] [blame] | 82 | // If the REQUEST is for an ongoing RPC, the existing call will be |
| 83 | // cancelled when the new call object is created. |
Alexei Frolov | 86e05de | 2021-10-19 16:52:31 -0700 | [diff] [blame] | 84 | const internal::CallContext context( |
Wyatt Hepler | 592b5a1 | 2022-02-01 17:55:21 -0800 | [diff] [blame] | 85 | *this, channel->id(), *service, *method, packet.call_id()); |
Wyatt Hepler | ddfc077 | 2021-09-03 16:46:25 -0700 | [diff] [blame] | 86 | method->Invoke(context, packet); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 87 | break; |
| 88 | } |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame] | 89 | case PacketType::CLIENT_STREAM: |
Wyatt Hepler | ddfc077 | 2021-09-03 16:46:25 -0700 | [diff] [blame] | 90 | HandleClientStreamPacket(packet, *channel, call); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 91 | break; |
| 92 | case PacketType::CLIENT_ERROR: |
Wyatt Hepler | 1716915 | 2021-10-20 18:46:08 -0700 | [diff] [blame] | 93 | case PacketType::DEPRECATED_CANCEL: |
Alexei Frolov | 86e05de | 2021-10-19 16:52:31 -0700 | [diff] [blame] | 94 | if (call != nullptr && call->id() == packet.call_id()) { |
Wyatt Hepler | ddfc077 | 2021-09-03 16:46:25 -0700 | [diff] [blame] | 95 | call->HandleError(packet.status()); |
Wyatt Hepler | c8bdc7d | 2021-10-20 09:29:01 -0700 | [diff] [blame] | 96 | } else { |
| 97 | internal::rpc_lock().unlock(); |
Wyatt Hepler | 01fc15b | 2021-06-10 18:15:59 -0700 | [diff] [blame] | 98 | } |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 99 | break; |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame] | 100 | case PacketType::CLIENT_STREAM_END: |
Wyatt Hepler | ddfc077 | 2021-09-03 16:46:25 -0700 | [diff] [blame] | 101 | HandleClientStreamPacket(packet, *channel, call); |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame] | 102 | break; |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 103 | default: |
Wyatt Hepler | c8bdc7d | 2021-10-20 09:29:01 -0700 | [diff] [blame] | 104 | internal::rpc_lock().unlock(); |
Wyatt Hepler | 82db4b1 | 2021-09-23 09:10:12 -0700 | [diff] [blame] | 105 | PW_LOG_WARN("pw_rpc server unable to handle packet of type %u", |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 106 | unsigned(packet.type())); |
| 107 | } |
Wyatt Hepler | 1d000cc | 2021-10-20 11:05:06 -0700 | [diff] [blame] | 108 | |
| 109 | return OkStatus(); // OK since the packet was handled |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 110 | } |
| 111 | |
Wyatt Hepler | cbd09c2 | 2020-09-15 11:17:24 -0700 | [diff] [blame] | 112 | std::tuple<Service*, const internal::Method*> Server::FindMethod( |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 113 | const internal::Packet& packet) { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 114 | // Packets always include service and method IDs. |
Wyatt Hepler | 3e2d719 | 2020-06-11 08:28:21 -0700 | [diff] [blame] | 115 | auto service = std::find_if(services_.begin(), services_.end(), [&](auto& s) { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 116 | return s.id() == packet.service_id(); |
Wyatt Hepler | 3e2d719 | 2020-06-11 08:28:21 -0700 | [diff] [blame] | 117 | }); |
| 118 | |
| 119 | if (service == services_.end()) { |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 120 | return {}; |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 121 | } |
| 122 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 123 | return {&(*service), service->FindMethod(packet.method_id())}; |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 124 | } |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 125 | |
Wyatt Hepler | 01fc15b | 2021-06-10 18:15:59 -0700 | [diff] [blame] | 126 | void Server::HandleClientStreamPacket(const internal::Packet& packet, |
| 127 | internal::Channel& channel, |
Wyatt Hepler | 960f5df | 2021-09-08 10:17:21 -0700 | [diff] [blame] | 128 | internal::ServerCall* call) const { |
Alexei Frolov | 86e05de | 2021-10-19 16:52:31 -0700 | [diff] [blame] | 129 | if (call == nullptr || call->id() != packet.call_id()) { |
Wyatt Hepler | b1c4799 | 2022-01-06 11:05:50 -0800 | [diff] [blame] | 130 | channel.Send(Packet::ServerError(packet, Status::FailedPrecondition())) |
| 131 | .IgnoreError(); // Errors are logged in Channel::Send. |
Wyatt Hepler | af16dbb | 2022-01-27 20:15:15 -0800 | [diff] [blame] | 132 | internal::rpc_lock().unlock(); |
Wyatt Hepler | 01fc15b | 2021-06-10 18:15:59 -0700 | [diff] [blame] | 133 | PW_LOG_DEBUG( |
Wyatt Hepler | 3aab7f6 | 2021-10-05 16:14:51 -0700 | [diff] [blame] | 134 | "Received client stream packet for %u:%08x/%08x, which is not pending", |
| 135 | static_cast<unsigned>(packet.channel_id()), |
| 136 | static_cast<unsigned>(packet.service_id()), |
| 137 | static_cast<unsigned>(packet.method_id())); |
Wyatt Hepler | 01fc15b | 2021-06-10 18:15:59 -0700 | [diff] [blame] | 138 | return; |
| 139 | } |
| 140 | |
Wyatt Hepler | ddfc077 | 2021-09-03 16:46:25 -0700 | [diff] [blame] | 141 | if (!call->has_client_stream()) { |
Adrien Larbanet | d1ca56c | 2021-06-10 14:20:45 +0000 | [diff] [blame] | 142 | channel.Send(Packet::ServerError(packet, Status::InvalidArgument())) |
Wyatt Hepler | 82db4b1 | 2021-09-23 09:10:12 -0700 | [diff] [blame] | 143 | .IgnoreError(); // Errors are logged in Channel::Send. |
Wyatt Hepler | af16dbb | 2022-01-27 20:15:15 -0800 | [diff] [blame] | 144 | internal::rpc_lock().unlock(); |
Wyatt Hepler | 01fc15b | 2021-06-10 18:15:59 -0700 | [diff] [blame] | 145 | return; |
| 146 | } |
| 147 | |
Wyatt Hepler | ddfc077 | 2021-09-03 16:46:25 -0700 | [diff] [blame] | 148 | if (!call->client_stream_open()) { |
Adrien Larbanet | d1ca56c | 2021-06-10 14:20:45 +0000 | [diff] [blame] | 149 | channel.Send(Packet::ServerError(packet, Status::FailedPrecondition())) |
Wyatt Hepler | 82db4b1 | 2021-09-23 09:10:12 -0700 | [diff] [blame] | 150 | .IgnoreError(); // Errors are logged in Channel::Send. |
Wyatt Hepler | af16dbb | 2022-01-27 20:15:15 -0800 | [diff] [blame] | 151 | internal::rpc_lock().unlock(); |
Wyatt Hepler | 01fc15b | 2021-06-10 18:15:59 -0700 | [diff] [blame] | 152 | return; |
| 153 | } |
| 154 | |
| 155 | if (packet.type() == PacketType::CLIENT_STREAM) { |
Wyatt Hepler | 82db4b1 | 2021-09-23 09:10:12 -0700 | [diff] [blame] | 156 | call->HandlePayload(packet.payload()); |
Wyatt Hepler | 01fc15b | 2021-06-10 18:15:59 -0700 | [diff] [blame] | 157 | } else { // Handle PacketType::CLIENT_STREAM_END. |
Wyatt Hepler | c8bdc7d | 2021-10-20 09:29:01 -0700 | [diff] [blame] | 158 | call->HandleClientStreamEnd(); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 159 | } |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 160 | } |
| 161 | |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 162 | } // namespace pw::rpc |