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; }