int usb_write(usb_handle* handle, const void* data, int len) {
unsigned long time_out = 5000;
unsigned long written = 0;
int err = 0;
D("usb_write %d", len);
if (nullptr == handle) {
D("usb_write was passed NULL handle");
err = EINVAL;
goto fail;
}
// Perform write
if (!AdbWriteEndpointSync(handle->adb_write_pipe, (void*)data, (unsigned long)len, &written,
time_out)) {
D("AdbWriteEndpointSync failed: %s",
android::base::SystemErrorCodeToString(GetLastError()).c_str());
err = EIO;
goto fail;
}
// Make sure that we've written what we were asked to write
D("usb_write got: %ld, expected: %d", written, len);
if (written != (unsigned long)len) {
// If this occurs, this code should be changed to repeatedly call
// AdbWriteEndpointSync() until all bytes are written.
D("AdbWriteEndpointSync was supposed to write %d, but only wrote %ld", len, written);
err = EIO;
goto fail;
}
if (handle->zero_mask && (len & handle->zero_mask) == 0) {
// Send a zero length packet
unsigned long dummy;
if (!AdbWriteEndpointSync(handle->adb_write_pipe, (void*)data, 0, &dummy, time_out)) {
D("AdbWriteEndpointSync of zero length packet failed: %s",
android::base::SystemErrorCodeToString(GetLastError()).c_str());
err = EIO;
goto fail;
}
}
return written;
fail:
// Any failure should cause us to kick the device instead of leaving it a
// zombie state with potential to hang.
if (nullptr != handle) {
D("Kicking device due to error in usb_write");
usb_kick(handle);
}
D("usb_write failed");
errno = err;
return -1;
}
int usb_write(usb_handle* handle, const void* data, int len) {
unsigned long time_out = 500 + len * 8;
unsigned long written = 0;
unsigned count = 0;
int ret;
DBG("usb_write %d\n", len);
if (NULL != handle) {
// Perform write
while(len > 0) {
int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
ret = AdbWriteEndpointSync(handle->adb_write_pipe,
(void*)data,
(unsigned long)xfer,
&written,
time_out);
errno = GetLastError();
DBG("AdbWriteEndpointSync returned %d, errno: %d\n", ret, errno);
if (ret == 0) {
// assume ERROR_INVALID_HANDLE indicates we are disconnected
if (errno == ERROR_INVALID_HANDLE)
usb_kick(handle);
return -1;
}
count += written;
len -= written;
data += written;
if (len == 0)
return count;
}
} else {
DBG("usb_write NULL handle\n");
SetLastError(ERROR_INVALID_HANDLE);
}
DBG("usb_write failed: %d\n", errno);
return -1;
}
ssize_t WindowsUsbTransport::Write(const void* data, size_t len) {
unsigned long time_out = 5000;
unsigned long written = 0;
unsigned count = 0;
int ret;
DBG("usb_write %d\n", len);
if (nullptr != handle_) {
// Perform write
while(len > 0) {
int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
ret = AdbWriteEndpointSync(handle_->adb_write_pipe, const_cast<void*>(data), xfer,
&written, time_out);
errno = GetLastError();
DBG("AdbWriteEndpointSync returned %d, errno: %d\n", ret, errno);
if (ret == 0) {
// assume ERROR_INVALID_HANDLE indicates we are disconnected
if (errno == ERROR_INVALID_HANDLE)
usb_kick(handle_.get());
return -1;
}
count += written;
len -= written;
data = (const char *)data + written;
if (len == 0)
return count;
}
} else {
DBG("usb_write NULL handle\n");
SetLastError(ERROR_INVALID_HANDLE);
}
DBG("usb_write failed: %d\n", errno);
return -1;
}
bool DeviceHandShake(ADBAPIHANDLE adb_interface) {
// Get interface name
char interf_name[512];
unsigned long name_size = sizeof(interf_name);
if (!AdbGetInterfaceName(adb_interface, interf_name, &name_size, true)) {
printf("\nDeviceHandShake: AdbGetInterfaceName returned error %u",
GetLastError());
return false;
}
printf("\n\nDeviceHandShake on %s", interf_name);
char* ser_num = NULL;
name_size = 0;
if (!AdbGetSerialNumber(adb_interface, ser_num, &name_size, true)) {
ser_num = reinterpret_cast<char*>(malloc(name_size));
if (NULL != ser_num) {
if (!AdbGetSerialNumber(adb_interface, ser_num, &name_size, true)) {
printf("\n AdbGetSerialNumber returned error %u", GetLastError());
AdbCloseHandle(adb_interface);
return false;
}
printf("\nInterface serial number is %s", ser_num);
free(ser_num);
}
}
// Get default read endpoint
ADBAPIHANDLE adb_read = AdbOpenDefaultBulkReadEndpoint(adb_interface,
AdbOpenAccessTypeReadWrite,
AdbOpenSharingModeReadWrite);
if (NULL == adb_read) {
printf("\n AdbOpenDefaultBulkReadEndpoint returned error %u", GetLastError());
return false;
}
// Get default write endpoint
ADBAPIHANDLE adb_write = AdbOpenDefaultBulkWriteEndpoint(adb_interface,
AdbOpenAccessTypeReadWrite,
AdbOpenSharingModeReadWrite);
if (NULL == adb_write) {
printf("\n AdbOpenDefaultBulkWriteEndpoint returned error %u", GetLastError());
AdbCloseHandle(adb_read);
return false;
}
// Send connect message
message msg_send;
msg_send.command = A_CNXN;
msg_send.arg0 = A_VERSION;
msg_send.arg1 = MAX_PAYLOAD;
msg_send.data_length = 0;
msg_send.data_crc32 = 0;
msg_send.magic = msg_send.command ^ 0xffffffff;
ULONG written_bytes = 0;
bool write_res = AdbWriteEndpointSync(adb_write, &msg_send, sizeof(msg_send), &written_bytes, 500);
if (!write_res) {
printf("\n AdbWriteEndpointSync returned error %u", GetLastError());
AdbCloseHandle(adb_write);
AdbCloseHandle(adb_read);
return false;
}
// Receive handshake
message msg_rcv;
ULONG read_bytes = 0;
bool read_res = AdbReadEndpointSync(adb_read, &msg_rcv, sizeof(msg_rcv), &read_bytes, 512);
if (!read_res) {
printf("\n AdbReadEndpointSync returned error %u", GetLastError());
AdbCloseHandle(adb_write);
AdbCloseHandle(adb_read);
return false;
}
printf("\n Read handshake: %u bytes received", read_bytes);
char* cmd_ansi = reinterpret_cast<char*>(&msg_rcv.command);
printf("\n command = %08X (%c%c%c%c)", msg_rcv.command,
cmd_ansi[0], cmd_ansi[1], cmd_ansi[2], cmd_ansi[3]);
printf("\n arg0 = %08X", msg_rcv.arg0);
printf("\n arg1 = %08X", msg_rcv.arg1);
printf("\n data_length = %u", msg_rcv.data_length);
printf("\n data_crc32 = %08X", msg_rcv.data_crc32);
printf("\n magic = %08X", msg_rcv.magic);
if (0 != msg_rcv.data_length) {
char* buf = reinterpret_cast<char*>(malloc(msg_rcv.data_length));
read_res = AdbReadEndpointSync(adb_read, buf, msg_rcv.data_length, &read_bytes, 512);
if (!read_res) {
printf("\n AdbReadEndpointSync (data) returned error %u", GetLastError());
free(buf);
AdbCloseHandle(adb_write);
AdbCloseHandle(adb_read);
return false;
}
for (ULONG n = 0; n < read_bytes; n++) {
if (0 == (n % 16))
printf("\n ");
printf("%02X ", buf[n]);
}
printf("\n %s", buf);
delete buf;
}
AdbCloseHandle(adb_write);
AdbCloseHandle(adb_read);
return true;
}