/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// #undef NDEBUG
#include "guest/commands/usbforward/usb_server.h"
#include <string>
#include <vector>
#include <strings.h>
#include <cutils/log.h>
#include <libusb/libusb.h>
#include "common/libs/fs/shared_select.h"
#include "common/libs/usbforward/protocol.h"
#include "guest/commands/usbforward/transport_request.h"
namespace usb_forward {
namespace {
// USBServer exports device kExportedVendorID:kExportedProductID to the server.
// We will not support exporting multiple USB devices as there's no practical
// need for this.
constexpr uint16_t kExportedVendorID = 0x18d1;
constexpr uint16_t kExportedProductID = 0x4ee7;
// Use default BUS and DEVICE IDs so that it's easier to attach over USB/IP.
constexpr uint8_t kDefaultBusID = 1;
constexpr uint8_t kDefaultDevID = 1;
std::shared_ptr<libusb_device_handle> GetDevice() {
std::shared_ptr<libusb_device_handle> res(
libusb_open_device_with_vid_pid(nullptr, kExportedVendorID,
kExportedProductID),
[](libusb_device_handle* h) {
// Apparently, deleter is called even on an uninitialized shared_ptr.
if (h != nullptr) {
libusb_release_interface(h, 0);
libusb_close(h);
}
});
if (res) libusb_claim_interface(res.get(), 0);
return res;
}
} // anonymous namespace
bool USBServer::GetDeviceInfo(
DeviceInfo* info, std::vector<InterfaceInfo>* ifaces) {
if (!handle_) return false;
// This function does not modify the reference count of the returned device,
// so do not feel compelled to unreference it when you are done.
libusb_device* dev = libusb_get_device(handle_.get());
libusb_device_descriptor desc;
libusb_config_descriptor* conf;
memset(info, 0, sizeof(*info));
int res = libusb_get_device_descriptor(dev, &desc);
if (res < 0) {
// This shouldn't really happen.
ALOGE("libusb_get_device_descriptor failed %d", res);
return false;
}
res = libusb_get_active_config_descriptor(dev, &conf);
if (res < 0) {
// This shouldn't really happen.
ALOGE("libusb_get_active_config_descriptor failed %d", res);
libusb_free_config_descriptor(conf);
return false;
}
info->vendor_id = desc.idVendor;
info->product_id = desc.idProduct;
info->dev_version = desc.bcdDevice;
info->dev_class = desc.bDeviceClass;
info->dev_subclass = desc.bDeviceSubClass;
info->dev_protocol = desc.bDeviceProtocol;
info->speed = libusb_get_device_speed(dev);
info->num_configurations = desc.bNumConfigurations;
info->num_interfaces = conf->bNumInterfaces;
info->cur_configuration = conf->bConfigurationValue;
info->bus_id = kDefaultBusID;
info->dev_id = kDefaultDevID;
if (ifaces != nullptr) {
for (int ifidx = 0; ifidx < conf->bNumInterfaces; ++ifidx) {
const libusb_interface& iface = conf->interface[ifidx];
for (int altidx = 0; altidx < iface.num_altsetting; ++altidx) {
const libusb_interface_descriptor& alt = iface.altsetting[altidx];
ifaces->push_back(InterfaceInfo{alt.bInterfaceClass,
alt.bInterfaceSubClass,
alt.bInterfaceProtocol, 0});
}
}
}
libusb_free_config_descriptor(conf);
return true;
}
USBServer::USBServer(const cvd::SharedFD& fd)
: fd_{fd},
device_event_fd_{cvd::SharedFD::Event(0, 0)},
thread_event_fd_{cvd::SharedFD::Event(0, 0)} {}
void USBServer::HandleDeviceList(uint32_t tag) {
// Iterate all devices and send structure for every found device.
// Write header: number of devices.
DeviceInfo info;
std::vector<InterfaceInfo> ifaces;
bool found = GetDeviceInfo(&info, &ifaces);
cvd::LockGuard<cvd::Mutex> lock(write_mutex_);
ResponseHeader rsp{StatusSuccess, tag};
fd_->Write(&rsp, sizeof(rsp));
if (found) {
uint32_t cnt = 1;
fd_->Write(&cnt, sizeof(cnt));
fd_->Write(&info, sizeof(info));
fd_->Write(ifaces.data(), ifaces.size() * sizeof(InterfaceInfo));
} else {
// No devices.
uint32_t cnt = 0;
fd_->Write(&cnt, sizeof(cnt));
}
}
void USBServer::HandleAttach(uint32_t tag) {
// We read the request, but it no longer plays any significant role here.
AttachRequest req;
if (fd_->Read(&req, sizeof(req)) != sizeof(req)) return;
cvd::LockGuard<cvd::Mutex> lock(write_mutex_);
ResponseHeader rsp{handle_ ? StatusSuccess : StatusFailure, tag};
fd_->Write(&rsp, sizeof(rsp));
}
void USBServer::HandleHeartbeat(uint32_t tag) {
cvd::LockGuard<cvd::Mutex> lock(write_mutex_);
ResponseHeader rsp{handle_ ? StatusSuccess : StatusFailure, tag};
fd_->Write(&rsp, sizeof(rsp));
}
void USBServer::HandleControlTransfer(uint32_t tag) {
ControlTransfer req;
// If disconnected prematurely, don't send response.
if (fd_->Read(&req, sizeof(req)) != sizeof(req)) return;
// Technically speaking this isn't endpoint, but names, masks, values and
// meaning here is exactly same.
bool is_data_in =
((req.type & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN);
std::unique_ptr<TransportRequest> treq(new TransportRequest(
handle_,
[this, is_data_in, tag](bool is_success, const uint8_t* data,
int32_t length) {
OnTransferComplete(tag, is_data_in, is_success, data, length);
},
req));
if (!is_data_in && req.length) {
// If disconnected prematurely, don't send response.
int32_t got = 0;
while (got < req.length) {
auto read = fd_->Read(&treq->Buffer()[got], req.length - got);
if (fd_->GetErrno() != 0) {
ALOGE("Failed to read from client: %s", fd_->StrError());
return;
} else if (read == 0) {
ALOGE("Failed to read from client: short read");
return;
}
got += read;
}
}
// At this point we store transport request internally until it completes.
TransportRequest* treq_ptr = treq.get();
{
cvd::LockGuard<cvd::Mutex> lock(requests_mutex_);
requests_in_flight_[tag] = std::move(treq);
}
if (!treq_ptr->Submit()) {
OnTransferComplete(tag, is_data_in, false, nullptr, 0);
}
}
void USBServer::HandleDataTransfer(uint32_t tag) {
DataTransfer req;
// If disconnected prematurely, don't send response.
if (fd_->Read(&req, sizeof(req)) != sizeof(req)) return;
bool is_data_in = !req.is_host_to_device;
std::unique_ptr<TransportRequest> treq(new TransportRequest(
handle_,
[this, is_data_in, tag](bool is_success, const uint8_t* data,
int32_t length) {
OnTransferComplete(tag, is_data_in, is_success, data, length);
},
req));
if (!is_data_in && req.length) {
// If disconnected prematurely, don't send response.
int32_t got = 0;
while (got < req.length) {
auto read = fd_->Read(&treq->Buffer()[got], req.length - got);
if (fd_->GetErrno() != 0) {
ALOGE("Failed to read from client: %s", fd_->StrError());
return;
} else if (read == 0) {
ALOGE("Failed to read from client: short read");
return;
}
got += read;
}
}
// At this point we store transport request internally until it completes.
TransportRequest* treq_ptr = treq.get();
{
cvd::LockGuard<cvd::Mutex> lock(requests_mutex_);
requests_in_flight_[tag] = std::move(treq);
}
if (!treq_ptr->Submit()) {
OnTransferComplete(tag, is_data_in, false, nullptr, 0);
}
}
void USBServer::OnTransferComplete(uint32_t tag, bool is_data_in,
bool is_success, const uint8_t* buffer,
int32_t actual_length) {
ResponseHeader rsp{is_success ? StatusSuccess : StatusFailure, tag};
cvd::LockGuard<cvd::Mutex> lock(write_mutex_);
fd_->Write(&rsp, sizeof(rsp));
if (is_success && is_data_in) {
fd_->Write(&actual_length, sizeof(actual_length));
if (actual_length > 0) {
// NOTE: don't use buffer_ here directly, as libusb uses first few bytes
// to store control data there.
int32_t sent = 0;
while (sent < actual_length) {
int packet_size = fd_->Write(&buffer[sent], actual_length - sent);
sent += packet_size;
ALOGV("Sending response, %d / %d bytes sent", sent, actual_length);
if (fd_->GetErrno() != 0) {
ALOGE("Send failed: %s", fd_->StrError());
return;
}
}
}
}
{
cvd::LockGuard<cvd::Mutex> lock(requests_mutex_);
requests_in_flight_.erase(tag);
}
}
int USBServer::HandleDeviceEvent(libusb_context*, libusb_device*,
libusb_hotplug_event event, void* self_raw) {
auto self = reinterpret_cast<USBServer*>(self_raw);
int64_t dummy = 1;
self->device_event_fd_->Write(&dummy, sizeof(dummy));
return 0;
}
void* USBServer::ProcessLibUSBRequests(void* self_raw) {
USBServer* self = reinterpret_cast<USBServer*>(self_raw);
ALOGI("Starting hotplug thread.");
cvd::SharedFDSet rset;
while (true) {
// Do not wait if there's no event.
timeval select_timeout{0, 0};
rset.Zero();
rset.Set(self->thread_event_fd_);
int ret = cvd::Select(&rset, nullptr, nullptr, &select_timeout);
if (ret > 0) break;
timeval libusb_timeout{1, 0};
libusb_handle_events_timeout_completed(nullptr, &libusb_timeout, nullptr);
}
int64_t dummy;
self->thread_event_fd_->Read(&dummy, sizeof(dummy));
ALOGI("Shutting down hotplug thread.");
return nullptr;
}
void USBServer::InitLibUSB() {
if (libusb_init(nullptr) != 0) return;
libusb_hotplug_register_callback(
nullptr,
libusb_hotplug_event(LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
libusb_hotplug_flag(0), kExportedVendorID, kExportedProductID,
LIBUSB_HOTPLUG_MATCH_ANY, &USBServer::HandleDeviceEvent, this,
&hotplug_handle_);
handle_ = GetDevice();
libusb_thread_.reset(new cvd::ScopedThread(&ProcessLibUSBRequests, this));
}
void USBServer::ExitLibUSB() {
if (!libusb_thread_) return;
libusb_hotplug_deregister_callback(nullptr, hotplug_handle_);
int64_t dummy = 1;
thread_event_fd_->Write(&dummy, sizeof(dummy));
libusb_thread_.reset();
handle_.reset();
libusb_exit(nullptr);
}
void USBServer::Serve() {
cvd::SharedFDSet rset;
while (true) {
timeval retry_timeout{1, 0};
timeval* select_timeout = nullptr;
if (!handle_) {
select_timeout = &retry_timeout;
}
rset.Zero();
rset.Set(fd_);
rset.Set(device_event_fd_);
int ret = cvd::Select(&rset, nullptr, nullptr, select_timeout);
// device_event_fd_ is reset each time libusb notices device has re-appeared
// or is gone. In both cases, the existing handle is no longer valid.
if (rset.IsSet(device_event_fd_)) {
int64_t dummy;
device_event_fd_->Read(&dummy, sizeof(dummy));
handle_.reset();
}
if (!handle_) {
ExitLibUSB();
InitLibUSB();
if (handle_) {
ALOGI("Device present.");
}
}
if (ret < 0) continue;
if (rset.IsSet(fd_)) {
RequestHeader req;
if (fd_->Read(&req, sizeof(req)) != sizeof(req)) {
// There's nobody on the other side.
sleep(3);
continue;
}
switch (req.command) {
case CmdDeviceList:
ALOGV("Processing DeviceList command, tag=%d", req.tag);
HandleDeviceList(req.tag);
break;
case CmdAttach:
ALOGV("Processing Attach command, tag=%d", req.tag);
HandleAttach(req.tag);
break;
case CmdControlTransfer:
ALOGV("Processing ControlTransfer command, tag=%d", req.tag);
HandleControlTransfer(req.tag);
break;
case CmdDataTransfer:
ALOGV("Processing DataTransfer command, tag=%d", req.tag);
HandleDataTransfer(req.tag);
break;
case CmdHeartbeat:
ALOGV("Processing Heartbeat command, tag=%d", req.tag);
HandleHeartbeat(req.tag);
break;
default:
ALOGE("Discarding unknown command %08x, tag=%d", req.command,
req.tag);
}
}
}
}
} // namespace usb_forward