libs/vr/libpdx_uds/client_channel.cpp

   1 #include "uds/client_channel.h"
   2
   3 #include <errno.h>
   4 #include <log/log.h>
   5 #include <sys/epoll.h>
   6 #include <sys/socket.h>
   7
   8 #include <pdx/client.h>
   9 #include <pdx/service_endpoint.h>
  10 #include <uds/ipc_helper.h>
  11
  12 namespace android {
  13 namespace pdx {
  14 namespace uds {
  15
  16 namespace {
  17
  18 struct TransactionState {
  19   bool GetLocalFileHandle(int index, LocalHandle* handle) {
  20     if (index < 0) {
  21       handle->Reset(index);
  22     } else if (static_cast<size_t>(index) < response.file_descriptors.size()) {
  23       *handle = std::move(response.file_descriptors[index]);
  24     } else {
  25       return false;
  26     }
  27     return true;
  28   }
  29
  30   bool GetLocalChannelHandle(int index, LocalChannelHandle* handle) {
  31     if (index < 0) {
  32       *handle = LocalChannelHandle{nullptr, index};
  33     } else if (static_cast<size_t>(index) < response.channels.size()) {
  34       auto& channel_info = response.channels[index];
  35       *handle = ChannelManager::Get().CreateHandle(
  36           std::move(channel_info.data_fd), std::move(channel_info.event_fd));
  37     } else {
  38       return false;
  39     }
  40     return true;
  41   }
  42
  43   FileReference PushFileHandle(BorrowedHandle handle) {
  44     if (!handle)
  45       return handle.Get();
  46     request.file_descriptors.push_back(std::move(handle));
  47     return request.file_descriptors.size() - 1;
  48   }
  49
  50   ChannelReference PushChannelHandle(BorrowedChannelHandle handle) {
  51     if (!handle)
  52       return handle.value();
  53
  54     if (auto* channel_data =
  55             ChannelManager::Get().GetChannelData(handle.value())) {
  56       ChannelInfo<BorrowedHandle> channel_info;
  57       channel_info.data_fd.Reset(handle.value());
  58       channel_info.event_fd = channel_data->event_receiver.event_fd();
  59       request.channels.push_back(std::move(channel_info));
  60       return request.channels.size() - 1;
  61     } else {
  62       return -1;
  63     }
  64   }
  65
  66   RequestHeader<BorrowedHandle> request;
  67   ResponseHeader<LocalHandle> response;
  68 };
  69
  70 Status<void> ReadAndDiscardData(const BorrowedHandle& socket_fd, size_t size) {
  71   while (size > 0) {
  72     // If there is more data to read in the message than the buffers provided
  73     // by the caller, read and discard the extra data from the socket.
  74     char buffer[1024];
  75     size_t size_to_read = std::min(sizeof(buffer), size);
  76     auto status = ReceiveData(socket_fd, buffer, size_to_read);
  77     if (!status)
  78       return status;
  79     size -= size_to_read;
  80   }
  81   // We still want to return EIO error to the caller in case we had unexpected
  82   // data in the socket stream.
  83   return ErrorStatus(EIO);
  84 }
  85
  86 Status<void> SendRequest(const BorrowedHandle& socket_fd,
  87                          TransactionState* transaction_state, int opcode,
  88                          const iovec* send_vector, size_t send_count,
  89                          size_t max_recv_len) {
  90   size_t send_len = CountVectorSize(send_vector, send_count);
  91   InitRequest(&transaction_state->request, opcode, send_len, max_recv_len,
  92               false);
  93   auto status = SendData(socket_fd, transaction_state->request);
  94   if (status && send_len > 0)
  95     status = SendDataVector(socket_fd, send_vector, send_count);
  96   return status;
  97 }
  98
  99 Status<void> ReceiveResponse(const BorrowedHandle& socket_fd,
 100                              TransactionState* transaction_state,
 101                              const iovec* receive_vector, size_t receive_count,
 102                              size_t max_recv_len) {
 103   auto status = ReceiveData(socket_fd, &transaction_state->response);
 104   if (!status)
 105     return status;
 106
 107   if (transaction_state->response.recv_len > 0) {
 108     std::vector<iovec> read_buffers;
 109     size_t size_remaining = 0;
 110     if (transaction_state->response.recv_len != max_recv_len) {
 111       // If the receive buffer not exactly the size of data available, recreate
 112       // the vector list to consume the data exactly since ReceiveDataVector()
 113       // validates that the number of bytes received equals the number of bytes
 114       // requested.
 115       size_remaining = transaction_state->response.recv_len;
 116       for (size_t i = 0; i < receive_count && size_remaining > 0; i++) {
 117         read_buffers.push_back(receive_vector[i]);
 118         iovec& last_vec = read_buffers.back();
 119         if (last_vec.iov_len > size_remaining)
 120           last_vec.iov_len = size_remaining;
 121         size_remaining -= last_vec.iov_len;
 122       }
 123       receive_vector = read_buffers.data();
 124       receive_count = read_buffers.size();
 125     }
 126     status = ReceiveDataVector(socket_fd, receive_vector, receive_count);
 127     if (status && size_remaining > 0)
 128       status = ReadAndDiscardData(socket_fd, size_remaining);
 129   }
 130   return status;
 131 }
 132
 133 }  // anonymous namespace
 134
 135 ClientChannel::ClientChannel(LocalChannelHandle channel_handle)
 136     : channel_handle_{std::move(channel_handle)} {
 137   channel_data_ = ChannelManager::Get().GetChannelData(channel_handle_.value());
 138 }
 139
 140 std::unique_ptr<pdx::ClientChannel> ClientChannel::Create(
 141     LocalChannelHandle channel_handle) {
 142   return std::unique_ptr<pdx::ClientChannel>{
 143       new ClientChannel{std::move(channel_handle)}};
 144 }
 145
 146 ClientChannel::~ClientChannel() {
 147   if (channel_handle_)
 148     shutdown(channel_handle_.value(), SHUT_WR);
 149 }
 150
 151 void* ClientChannel::AllocateTransactionState() { return new TransactionState; }
 152
 153 void ClientChannel::FreeTransactionState(void* state) {
 154   delete static_cast<TransactionState*>(state);
 155 }
 156
 157 Status<void> ClientChannel::SendImpulse(int opcode, const void* buffer,
 158                                         size_t length) {
 159   Status<void> status;
 160   android::pdx::uds::RequestHeader<BorrowedHandle> request;
 161   if (length > request.impulse_payload.size() ||
 162       (buffer == nullptr && length != 0)) {
 163     status.SetError(EINVAL);
 164     return status;
 165   }
 166
 167   InitRequest(&request, opcode, length, 0, true);
 168   memcpy(request.impulse_payload.data(), buffer, length);
 169   return SendData(BorrowedHandle{channel_handle_.value()}, request);
 170 }
 171
 172 Status<int> ClientChannel::SendAndReceive(void* transaction_state, int opcode,
 173                                           const iovec* send_vector,
 174                                           size_t send_count,
 175                                           const iovec* receive_vector,
 176                                           size_t receive_count) {
 177   Status<int> result;
 178   if ((send_vector == nullptr && send_count != 0) ||
 179       (receive_vector == nullptr && receive_count != 0)) {
 180     result.SetError(EINVAL);
 181     return result;
 182   }
 183
 184   auto* state = static_cast<TransactionState*>(transaction_state);
 185   size_t max_recv_len = CountVectorSize(receive_vector, receive_count);
 186
 187   auto status = SendRequest(BorrowedHandle{channel_handle_.value()}, state,
 188                             opcode, send_vector, send_count, max_recv_len);
 189   if (status) {
 190     status = ReceiveResponse(BorrowedHandle{channel_handle_.value()}, state,
 191                              receive_vector, receive_count, max_recv_len);
 192   }
 193   if (!result.PropagateError(status)) {
 194     const int return_code = state->response.ret_code;
 195     if (return_code >= 0)
 196       result.SetValue(return_code);
 197     else
 198       result.SetError(-return_code);
 199   }
 200   return result;
 201 }
 202
 203 Status<int> ClientChannel::SendWithInt(void* transaction_state, int opcode,
 204                                        const iovec* send_vector,
 205                                        size_t send_count,
 206                                        const iovec* receive_vector,
 207                                        size_t receive_count) {
 208   return SendAndReceive(transaction_state, opcode, send_vector, send_count,
 209                         receive_vector, receive_count);
 210 }
 211
 212 Status<LocalHandle> ClientChannel::SendWithFileHandle(
 213     void* transaction_state, int opcode, const iovec* send_vector,
 214     size_t send_count, const iovec* receive_vector, size_t receive_count) {
 215   Status<int> int_status =
 216       SendAndReceive(transaction_state, opcode, send_vector, send_count,
 217                      receive_vector, receive_count);
 218   Status<LocalHandle> status;
 219   if (status.PropagateError(int_status))
 220     return status;
 221
 222   auto* state = static_cast<TransactionState*>(transaction_state);
 223   LocalHandle handle;
 224   if (state->GetLocalFileHandle(int_status.get(), &handle)) {
 225     status.SetValue(std::move(handle));
 226   } else {
 227     status.SetError(EINVAL);
 228   }
 229   return status;
 230 }
 231
 232 Status<LocalChannelHandle> ClientChannel::SendWithChannelHandle(
 233     void* transaction_state, int opcode, const iovec* send_vector,
 234     size_t send_count, const iovec* receive_vector, size_t receive_count) {
 235   Status<int> int_status =
 236       SendAndReceive(transaction_state, opcode, send_vector, send_count,
 237                      receive_vector, receive_count);
 238   Status<LocalChannelHandle> status;
 239   if (status.PropagateError(int_status))
 240     return status;
 241
 242   auto* state = static_cast<TransactionState*>(transaction_state);
 243   LocalChannelHandle handle;
 244   if (state->GetLocalChannelHandle(int_status.get(), &handle)) {
 245     status.SetValue(std::move(handle));
 246   } else {
 247     status.SetError(EINVAL);
 248   }
 249   return status;
 250 }
 251
 252 FileReference ClientChannel::PushFileHandle(void* transaction_state,
 253                                             const LocalHandle& handle) {
 254   auto* state = static_cast<TransactionState*>(transaction_state);
 255   return state->PushFileHandle(handle.Borrow());
 256 }
 257
 258 FileReference ClientChannel::PushFileHandle(void* transaction_state,
 259                                             const BorrowedHandle& handle) {
 260   auto* state = static_cast<TransactionState*>(transaction_state);
 261   return state->PushFileHandle(handle.Duplicate());
 262 }
 263
 264 ChannelReference ClientChannel::PushChannelHandle(
 265     void* transaction_state, const LocalChannelHandle& handle) {
 266   auto* state = static_cast<TransactionState*>(transaction_state);
 267   return state->PushChannelHandle(handle.Borrow());
 268 }
 269
 270 ChannelReference ClientChannel::PushChannelHandle(
 271     void* transaction_state, const BorrowedChannelHandle& handle) {
 272   auto* state = static_cast<TransactionState*>(transaction_state);
 273   return state->PushChannelHandle(handle.Duplicate());
 274 }
 275
 276 bool ClientChannel::GetFileHandle(void* transaction_state, FileReference ref,
 277                                   LocalHandle* handle) const {
 278   auto* state = static_cast<TransactionState*>(transaction_state);
 279   return state->GetLocalFileHandle(ref, handle);
 280 }
 281
 282 bool ClientChannel::GetChannelHandle(void* transaction_state,
 283                                      ChannelReference ref,
 284                                      LocalChannelHandle* handle) const {
 285   auto* state = static_cast<TransactionState*>(transaction_state);
 286   return state->GetLocalChannelHandle(ref, handle);
 287 }
 288
 289 }  // namespace uds
 290 }  // namespace pdx
 291 }  // namespace android