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   if (send_len == 0) {
  94     send_vector = nullptr;
  95     send_count = 0;
  96   }
  97   return SendData(socket_fd, transaction_state->request, send_vector,
  98                   send_count);
  99 }
 100
 101 Status<void> ReceiveResponse(const BorrowedHandle& socket_fd,
 102                              TransactionState* transaction_state,
 103                              const iovec* receive_vector, size_t receive_count,
 104                              size_t max_recv_len) {
 105   auto status = ReceiveData(socket_fd, &transaction_state->response);
 106   if (!status)
 107     return status;
 108
 109   if (transaction_state->response.recv_len > 0) {
 110     std::vector<iovec> read_buffers;
 111     size_t size_remaining = 0;
 112     if (transaction_state->response.recv_len != max_recv_len) {
 113       // If the receive buffer not exactly the size of data available, recreate
 114       // the vector list to consume the data exactly since ReceiveDataVector()
 115       // validates that the number of bytes received equals the number of bytes
 116       // requested.
 117       size_remaining = transaction_state->response.recv_len;
 118       for (size_t i = 0; i < receive_count && size_remaining > 0; i++) {
 119         read_buffers.push_back(receive_vector[i]);
 120         iovec& last_vec = read_buffers.back();
 121         if (last_vec.iov_len > size_remaining)
 122           last_vec.iov_len = size_remaining;
 123         size_remaining -= last_vec.iov_len;
 124       }
 125       receive_vector = read_buffers.data();
 126       receive_count = read_buffers.size();
 127     }
 128     status = ReceiveDataVector(socket_fd, receive_vector, receive_count);
 129     if (status && size_remaining > 0)
 130       status = ReadAndDiscardData(socket_fd, size_remaining);
 131   }
 132   return status;
 133 }
 134
 135 }  // anonymous namespace
 136
 137 ClientChannel::ClientChannel(LocalChannelHandle channel_handle)
 138     : channel_handle_{std::move(channel_handle)} {
 139   channel_data_ = ChannelManager::Get().GetChannelData(channel_handle_.value());
 140 }
 141
 142 std::unique_ptr<pdx::ClientChannel> ClientChannel::Create(
 143     LocalChannelHandle channel_handle) {
 144   return std::unique_ptr<pdx::ClientChannel>{
 145       new ClientChannel{std::move(channel_handle)}};
 146 }
 147
 148 ClientChannel::~ClientChannel() {
 149   if (channel_handle_)
 150     shutdown(channel_handle_.value(), SHUT_WR);
 151 }
 152
 153 void* ClientChannel::AllocateTransactionState() { return new TransactionState; }
 154
 155 void ClientChannel::FreeTransactionState(void* state) {
 156   delete static_cast<TransactionState*>(state);
 157 }
 158
 159 Status<void> ClientChannel::SendImpulse(int opcode, const void* buffer,
 160                                         size_t length) {
 161   std::unique_lock<std::mutex> lock(socket_mutex_);
 162   Status<void> status;
 163   android::pdx::uds::RequestHeader<BorrowedHandle> request;
 164   if (length > request.impulse_payload.size() ||
 165       (buffer == nullptr && length != 0)) {
 166     status.SetError(EINVAL);
 167     return status;
 168   }
 169
 170   InitRequest(&request, opcode, length, 0, true);
 171   memcpy(request.impulse_payload.data(), buffer, length);
 172   return SendData(BorrowedHandle{channel_handle_.value()}, request);
 173 }
 174
 175 Status<int> ClientChannel::SendAndReceive(void* transaction_state, int opcode,
 176                                           const iovec* send_vector,
 177                                           size_t send_count,
 178                                           const iovec* receive_vector,
 179                                           size_t receive_count) {
 180   std::unique_lock<std::mutex> lock(socket_mutex_);
 181   Status<int> result;
 182   if ((send_vector == nullptr && send_count != 0) ||
 183       (receive_vector == nullptr && receive_count != 0)) {
 184     result.SetError(EINVAL);
 185     return result;
 186   }
 187
 188   auto* state = static_cast<TransactionState*>(transaction_state);
 189   size_t max_recv_len = CountVectorSize(receive_vector, receive_count);
 190
 191   auto status = SendRequest(BorrowedHandle{channel_handle_.value()}, state,
 192                             opcode, send_vector, send_count, max_recv_len);
 193   if (status) {
 194     status = ReceiveResponse(BorrowedHandle{channel_handle_.value()}, state,
 195                              receive_vector, receive_count, max_recv_len);
 196   }
 197   if (!result.PropagateError(status)) {
 198     const int return_code = state->response.ret_code;
 199     if (return_code >= 0)
 200       result.SetValue(return_code);
 201     else
 202       result.SetError(-return_code);
 203   }
 204   return result;
 205 }
 206
 207 Status<int> ClientChannel::SendWithInt(void* transaction_state, int opcode,
 208                                        const iovec* send_vector,
 209                                        size_t send_count,
 210                                        const iovec* receive_vector,
 211                                        size_t receive_count) {
 212   return SendAndReceive(transaction_state, opcode, send_vector, send_count,
 213                         receive_vector, receive_count);
 214 }
 215
 216 Status<LocalHandle> ClientChannel::SendWithFileHandle(
 217     void* transaction_state, int opcode, const iovec* send_vector,
 218     size_t send_count, const iovec* receive_vector, size_t receive_count) {
 219   Status<int> int_status =
 220       SendAndReceive(transaction_state, opcode, send_vector, send_count,
 221                      receive_vector, receive_count);
 222   Status<LocalHandle> status;
 223   if (status.PropagateError(int_status))
 224     return status;
 225
 226   auto* state = static_cast<TransactionState*>(transaction_state);
 227   LocalHandle handle;
 228   if (state->GetLocalFileHandle(int_status.get(), &handle)) {
 229     status.SetValue(std::move(handle));
 230   } else {
 231     status.SetError(EINVAL);
 232   }
 233   return status;
 234 }
 235
 236 Status<LocalChannelHandle> ClientChannel::SendWithChannelHandle(
 237     void* transaction_state, int opcode, const iovec* send_vector,
 238     size_t send_count, const iovec* receive_vector, size_t receive_count) {
 239   Status<int> int_status =
 240       SendAndReceive(transaction_state, opcode, send_vector, send_count,
 241                      receive_vector, receive_count);
 242   Status<LocalChannelHandle> status;
 243   if (status.PropagateError(int_status))
 244     return status;
 245
 246   auto* state = static_cast<TransactionState*>(transaction_state);
 247   LocalChannelHandle handle;
 248   if (state->GetLocalChannelHandle(int_status.get(), &handle)) {
 249     status.SetValue(std::move(handle));
 250   } else {
 251     status.SetError(EINVAL);
 252   }
 253   return status;
 254 }
 255
 256 FileReference ClientChannel::PushFileHandle(void* transaction_state,
 257                                             const LocalHandle& handle) {
 258   auto* state = static_cast<TransactionState*>(transaction_state);
 259   return state->PushFileHandle(handle.Borrow());
 260 }
 261
 262 FileReference ClientChannel::PushFileHandle(void* transaction_state,
 263                                             const BorrowedHandle& handle) {
 264   auto* state = static_cast<TransactionState*>(transaction_state);
 265   return state->PushFileHandle(handle.Duplicate());
 266 }
 267
 268 ChannelReference ClientChannel::PushChannelHandle(
 269     void* transaction_state, const LocalChannelHandle& handle) {
 270   auto* state = static_cast<TransactionState*>(transaction_state);
 271   return state->PushChannelHandle(handle.Borrow());
 272 }
 273
 274 ChannelReference ClientChannel::PushChannelHandle(
 275     void* transaction_state, const BorrowedChannelHandle& handle) {
 276   auto* state = static_cast<TransactionState*>(transaction_state);
 277   return state->PushChannelHandle(handle.Duplicate());
 278 }
 279
 280 bool ClientChannel::GetFileHandle(void* transaction_state, FileReference ref,
 281                                   LocalHandle* handle) const {
 282   auto* state = static_cast<TransactionState*>(transaction_state);
 283   return state->GetLocalFileHandle(ref, handle);
 284 }
 285
 286 bool ClientChannel::GetChannelHandle(void* transaction_state,
 287                                      ChannelReference ref,
 288                                      LocalChannelHandle* handle) const {
 289   auto* state = static_cast<TransactionState*>(transaction_state);
 290   return state->GetLocalChannelHandle(ref, handle);
 291 }
 292
 293 }  // namespace uds
 294 }  // namespace pdx
 295 }  // namespace android