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 | |
| 15 | #include "pw_rpc/server.h" |
| 16 | |
Wyatt Hepler | 3e2d719 | 2020-06-11 08:28:21 -0700 | [diff] [blame] | 17 | #include <algorithm> |
| 18 | |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 19 | #include "pw_log/log.h" |
| 20 | #include "pw_rpc/internal/packet.h" |
Wyatt Hepler | 671946e | 2020-06-09 14:39:33 -0700 | [diff] [blame] | 21 | #include "pw_rpc/internal/server.h" |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 22 | #include "pw_rpc/server_context.h" |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 23 | |
| 24 | namespace pw::rpc { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 25 | namespace { |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 26 | |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 27 | using std::byte; |
| 28 | |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 29 | using internal::Packet; |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 30 | using internal::PacketType; |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 31 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 32 | bool DecodePacket(ChannelOutput& interface, |
| 33 | std::span<const byte> data, |
| 34 | Packet& packet) { |
Alexei Frolov | 3f2d008 | 2020-10-04 22:30:39 -0700 | [diff] [blame] | 35 | Result<Packet> result = Packet::FromBuffer(data); |
| 36 | if (!result.ok()) { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 37 | PW_LOG_WARN("Failed to decode packet on interface %s", interface.name()); |
| 38 | return false; |
| 39 | } |
| 40 | |
Alexei Frolov | 3f2d008 | 2020-10-04 22:30:39 -0700 | [diff] [blame] | 41 | packet = result.value(); |
| 42 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 43 | // If the packet is malformed, don't try to process it. |
| 44 | if (packet.channel_id() == Channel::kUnassignedChannelId || |
| 45 | packet.service_id() == 0 || packet.method_id() == 0) { |
| 46 | PW_LOG_WARN("Received incomplete packet on interface %s", interface.name()); |
| 47 | |
| 48 | // Only send an ERROR response if a valid channel ID was provided. |
| 49 | if (packet.channel_id() != Channel::kUnassignedChannelId) { |
| 50 | internal::Channel temp_channel(packet.channel_id(), &interface); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 51 | temp_channel.Send(Packet::ServerError(packet, Status::DataLoss())); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 52 | } |
| 53 | return false; |
| 54 | } |
| 55 | |
| 56 | return true; |
| 57 | } |
| 58 | |
| 59 | } // namespace |
| 60 | |
Wyatt Hepler | b7643d7 | 2020-07-10 10:33:14 -0700 | [diff] [blame] | 61 | Server::~Server() { |
| 62 | // Since the writers remove themselves from the server in Finish(), remove the |
| 63 | // first writer until no writers remain. |
| 64 | while (!writers_.empty()) { |
| 65 | writers_.front().Finish(); |
| 66 | } |
| 67 | } |
| 68 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 69 | Status Server::ProcessPacket(std::span<const byte> data, |
| 70 | ChannelOutput& interface) { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 71 | Packet packet; |
| 72 | if (!DecodePacket(interface, data, packet)) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 73 | return Status::DataLoss(); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 74 | } |
| 75 | |
| 76 | if (packet.destination() != Packet::kServer) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 77 | return Status::InvalidArgument(); |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 78 | } |
| 79 | |
Wyatt Hepler | 671946e | 2020-06-09 14:39:33 -0700 | [diff] [blame] | 80 | internal::Channel* channel = FindChannel(packet.channel_id()); |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 81 | if (channel == nullptr) { |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 82 | // If the requested channel doesn't exist, try to dynamically assign one. |
| 83 | channel = AssignChannel(packet.channel_id(), interface); |
| 84 | if (channel == nullptr) { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 85 | // If a channel can't be assigned, send a RESOURCE_EXHAUSTED error. |
Wyatt Hepler | 671946e | 2020-06-09 14:39:33 -0700 | [diff] [blame] | 86 | internal::Channel temp_channel(packet.channel_id(), &interface); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 87 | temp_channel.Send( |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 88 | Packet::ServerError(packet, Status::ResourceExhausted())); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 89 | return OkStatus(); // OK since the packet was handled |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 90 | } |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 91 | } |
| 92 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 93 | const auto [service, method] = FindMethod(packet); |
| 94 | |
| 95 | if (method == nullptr) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 96 | channel->Send(Packet::ServerError(packet, Status::NotFound())); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 97 | return OkStatus(); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 98 | } |
| 99 | |
| 100 | switch (packet.type()) { |
| 101 | case PacketType::REQUEST: { |
| 102 | internal::ServerCall call( |
| 103 | static_cast<internal::Server&>(*this), *channel, *service, *method); |
| 104 | method->Invoke(call, packet); |
| 105 | break; |
| 106 | } |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 107 | case PacketType::CLIENT_STREAM: |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 108 | // TODO(hepler): Support client streaming RPCs. |
| 109 | break; |
| 110 | case PacketType::CLIENT_ERROR: |
Alexei Frolov | 062ed18 | 2020-09-28 16:23:06 -0700 | [diff] [blame] | 111 | HandleClientError(packet); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 112 | break; |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 113 | case PacketType::CANCEL: |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 114 | HandleCancelPacket(packet, *channel); |
| 115 | break; |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 116 | case PacketType::CLIENT_STREAM_END: |
| 117 | // TODO(hepler): Handle client stream end packets. |
| 118 | break; |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 119 | default: |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 120 | channel->Send(Packet::ServerError(packet, Status::Unimplemented())); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 121 | PW_LOG_WARN("Unable to handle packet of type %u", |
| 122 | unsigned(packet.type())); |
| 123 | } |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 124 | return OkStatus(); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 125 | } |
| 126 | |
Wyatt Hepler | cbd09c2 | 2020-09-15 11:17:24 -0700 | [diff] [blame] | 127 | std::tuple<Service*, const internal::Method*> Server::FindMethod( |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 128 | const internal::Packet& packet) { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 129 | // Packets always include service and method IDs. |
Wyatt Hepler | 3e2d719 | 2020-06-11 08:28:21 -0700 | [diff] [blame] | 130 | auto service = std::find_if(services_.begin(), services_.end(), [&](auto& s) { |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 131 | return s.id() == packet.service_id(); |
Wyatt Hepler | 3e2d719 | 2020-06-11 08:28:21 -0700 | [diff] [blame] | 132 | }); |
| 133 | |
| 134 | if (service == services_.end()) { |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 135 | return {}; |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 136 | } |
| 137 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 138 | return {&(*service), service->FindMethod(packet.method_id())}; |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 139 | } |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 140 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 141 | void Server::HandleCancelPacket(const Packet& packet, |
| 142 | internal::Channel& channel) { |
| 143 | auto writer = std::find_if(writers_.begin(), writers_.end(), [&](auto& w) { |
| 144 | return w.channel_id() == packet.channel_id() && |
| 145 | w.service_id() == packet.service_id() && |
| 146 | w.method_id() == packet.method_id(); |
| 147 | }); |
Wyatt Hepler | 7da973a | 2020-06-09 10:04:48 -0700 | [diff] [blame] | 148 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 149 | if (writer == writers_.end()) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 150 | channel.Send(Packet::ServerError(packet, Status::FailedPrecondition())); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 151 | PW_LOG_WARN("Received CANCEL packet for method that is not pending"); |
| 152 | } else { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 153 | writer->Finish(Status::Cancelled()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 154 | } |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Alexei Frolov | 062ed18 | 2020-09-28 16:23:06 -0700 | [diff] [blame] | 157 | void Server::HandleClientError(const Packet& packet) { |
| 158 | // A client error indicates that the client received a packet that it did not |
| 159 | // expect. If the packet belongs to a streaming RPC, cancel the stream without |
| 160 | // sending a final SERVER_STREAM_END packet. |
| 161 | auto writer = std::find_if(writers_.begin(), writers_.end(), [&](auto& w) { |
| 162 | return w.channel_id() == packet.channel_id() && |
| 163 | w.service_id() == packet.service_id() && |
| 164 | w.method_id() == packet.method_id(); |
| 165 | }); |
| 166 | |
| 167 | if (writer != writers_.end()) { |
| 168 | writer->Close(); |
| 169 | } |
| 170 | } |
| 171 | |
Wyatt Hepler | 671946e | 2020-06-09 14:39:33 -0700 | [diff] [blame] | 172 | internal::Channel* Server::FindChannel(uint32_t id) const { |
| 173 | for (internal::Channel& c : channels_) { |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 174 | if (c.id() == id) { |
| 175 | return &c; |
| 176 | } |
| 177 | } |
| 178 | return nullptr; |
| 179 | } |
| 180 | |
Wyatt Hepler | 671946e | 2020-06-09 14:39:33 -0700 | [diff] [blame] | 181 | internal::Channel* Server::AssignChannel(uint32_t id, |
| 182 | ChannelOutput& interface) { |
| 183 | internal::Channel* channel = FindChannel(Channel::kUnassignedChannelId); |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 184 | if (channel == nullptr) { |
| 185 | return nullptr; |
| 186 | } |
| 187 | |
Wyatt Hepler | 671946e | 2020-06-09 14:39:33 -0700 | [diff] [blame] | 188 | *channel = internal::Channel(id, &interface); |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 189 | return channel; |
| 190 | } |
| 191 | |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 192 | } // namespace pw::rpc |