1 /*
2 * Copyright 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "common/libs/security/channel_sharedfd.h"
18
19 #include "common/libs/fs/shared_buf.h"
20
21 namespace cuttlefish {
22 namespace secure_env {
23 namespace {
24
25 /**
26 * Allocates memory for a RawMessage carrying a message of size
27 * `payload_size`.
28 */
CreateMessage(uint32_t command,bool is_response,size_t payload_size)29 Result<ManagedMessage> CreateMessage(uint32_t command, bool is_response, size_t payload_size) {
30 const auto bytes_to_allocate = sizeof(RawMessage) + payload_size;
31 auto memory = std::malloc(bytes_to_allocate);
32 CF_EXPECT(memory != nullptr,
33 "Cannot allocate " << bytes_to_allocate << " bytes for secure_env RPC message");
34 auto message = reinterpret_cast<RawMessage*>(memory);
35 message->command = command;
36 message->is_response = is_response;
37 message->payload_size = payload_size;
38 return ManagedMessage(message);
39 }
40
41 }
42
SharedFdChannel(SharedFD input,SharedFD output)43 SharedFdChannel::SharedFdChannel(SharedFD input, SharedFD output)
44 : input_(std::move(input)), output_(std::move(output)) {}
45
SendRequest(uint32_t command,void * message,size_t message_size)46 Result<void> SharedFdChannel::SendRequest(uint32_t command, void* message, size_t message_size) {
47 return SendMessage(command, false, message, message_size);
48 }
49
SendResponse(uint32_t command,void * message,size_t message_size)50 Result<void> SharedFdChannel::SendResponse(uint32_t command, void* message, size_t message_size) {
51 return SendMessage(command, true, message, message_size);
52 }
53
ReceiveMessage()54 Result<ManagedMessage> SharedFdChannel::ReceiveMessage() {
55 struct RawMessage message_header;
56 auto read = ReadExactBinary(input_, &message_header);
57 CF_EXPECT(read == sizeof(RawMessage),
58 "Expected " << sizeof(RawMessage) << ", received " << read << "\n" <<
59 "Could not read message: " << input_->StrError());
60 LOG(DEBUG) << "Received message with id: " << message_header.command;
61
62 auto message = CF_EXPECT(CreateMessage(message_header.command, message_header.is_response,
63 message_header.payload_size));
64 auto message_bytes = reinterpret_cast<char*>(message->payload);
65 read = ReadExact(input_, message_bytes, message->payload_size);
66 CF_EXPECT(read == message->payload_size,
67 "Could not read message: " << input_->StrError());
68
69 return message;
70 }
71
SendMessage(uint32_t command,bool response,void * message,size_t message_size)72 Result<void> SharedFdChannel::SendMessage(uint32_t command, bool response,
73 void* message, size_t message_size) {
74 auto to_send = CF_EXPECT(CreateMessage(command, response, message_size));
75 memcpy(to_send->payload, message, message_size);
76 auto write_size = sizeof(RawMessage) + message_size;
77 auto to_send_bytes = reinterpret_cast<const char*>(to_send.get());
78 auto written = WriteAll(output_, to_send_bytes, write_size);
79 CF_EXPECT(written != -1,
80 "Could not write message: " << output_->StrError());
81 return {};
82 }
83
84 } // namespace secure_env
85 } // namespace cuttlefish