std::unique_ptr<usb_handle> do_usb_open(const wchar_t* interface_name) { // Allocate our handle std::unique_ptr<usb_handle> ret(new usb_handle); // Create interface. ret->adb_interface = AdbCreateInterfaceByName(interface_name); if (nullptr == ret->adb_interface) { errno = GetLastError(); return nullptr; } // Open read pipe (endpoint) ret->adb_read_pipe = AdbOpenDefaultBulkReadEndpoint(ret->adb_interface, AdbOpenAccessTypeReadWrite, AdbOpenSharingModeReadWrite); if (nullptr != ret->adb_read_pipe) { // Open write pipe (endpoint) ret->adb_write_pipe = AdbOpenDefaultBulkWriteEndpoint(ret->adb_interface, AdbOpenAccessTypeReadWrite, AdbOpenSharingModeReadWrite); if (nullptr != ret->adb_write_pipe) { // Save interface name unsigned long name_len = 0; // First get expected name length AdbGetInterfaceName(ret->adb_interface, nullptr, &name_len, true); if (0 != name_len) { // Now save the name ret->interface_name.resize(name_len); if (AdbGetInterfaceName(ret->adb_interface, &ret->interface_name[0], &name_len, true)) { // We're done at this point return ret; } } } } // Something went wrong. errno = GetLastError(); usb_cleanup_handle(ret.get()); SetLastError(errno); return nullptr; }
usb_handle* do_usb_open(const wchar_t* interface_name) { // Allocate our handle usb_handle* ret = (usb_handle*)malloc(sizeof(usb_handle)); if (NULL == ret) return NULL; // Create interface. ret->adb_interface = AdbCreateInterfaceByName(interface_name); if (NULL == ret->adb_interface) { free(ret); errno = GetLastError(); return NULL; } // Open read pipe (endpoint) ret->adb_read_pipe = AdbOpenDefaultBulkReadEndpoint(ret->adb_interface, AdbOpenAccessTypeReadWrite, AdbOpenSharingModeReadWrite); if (NULL != ret->adb_read_pipe) { // Open write pipe (endpoint) ret->adb_write_pipe = AdbOpenDefaultBulkWriteEndpoint(ret->adb_interface, AdbOpenAccessTypeReadWrite, AdbOpenSharingModeReadWrite); if (NULL != ret->adb_write_pipe) { // Save interface name unsigned long name_len = 0; // First get expected name length AdbGetInterfaceName(ret->adb_interface, NULL, &name_len, true); if (0 != name_len) { ret->interface_name = (char*)malloc(name_len); if (NULL != ret->interface_name) { // Now save the name if (AdbGetInterfaceName(ret->adb_interface, ret->interface_name, &name_len, true)) { // We're done at this point return ret; } } else { SetLastError(ERROR_OUTOFMEMORY); } } } } // Something went wrong. errno = GetLastError(); usb_cleanup_handle(ret); free(ret); SetLastError(errno); return NULL; }
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; }
bool TestInterfaceHandle(ADBAPIHANDLE interface_handle) { // Get interface name. char intr_name[4096]; unsigned long intr_name_size = sizeof(intr_name); if (AdbGetInterfaceName(interface_handle, intr_name, &intr_name_size, true)) { printf("\n+++ Interface name %s", intr_name); } else { printf("\n--- AdbGetInterfaceName failure %u", GetLastError()); return false; } // Get device descriptor for the interface USB_DEVICE_DESCRIPTOR dev_desc; if (AdbGetUsbDeviceDescriptor(interface_handle, &dev_desc)) { printf("\n+++ Device descriptor:"); printf("\n bLength = %u", dev_desc.bLength); printf("\n bDescriptorType = %u", dev_desc.bDescriptorType); printf("\n bcdUSB = %u", dev_desc.bcdUSB); printf("\n bDeviceClass = %u", dev_desc.bDeviceClass); printf("\n bDeviceSubClass = %u", dev_desc.bDeviceSubClass); printf("\n bDeviceProtocol = %u", dev_desc.bDeviceProtocol); printf("\n bMaxPacketSize0 = %u", dev_desc.bMaxPacketSize0); printf("\n idVendor = %X", dev_desc.idVendor); printf("\n idProduct = %X", dev_desc.idProduct); printf("\n bcdDevice = %u", dev_desc.bcdDevice); printf("\n iManufacturer = %u", dev_desc.iManufacturer); printf("\n iProduct = %u", dev_desc.iProduct); printf("\n iSerialNumber = %u", dev_desc.iSerialNumber); printf("\n bNumConfigurations = %u", dev_desc.bDescriptorType); } else { printf("\n--- AdbGetUsbDeviceDescriptor failure %u", GetLastError()); return false; } // Get configuration descriptor for the interface USB_CONFIGURATION_DESCRIPTOR config_desc; if (AdbGetUsbConfigurationDescriptor(interface_handle, &config_desc)) { printf("\n+++ Configuration descriptor:"); printf("\n bLength = %u", config_desc.bLength); printf("\n bDescriptorType = %u", config_desc.bDescriptorType); printf("\n wTotalLength = %u", config_desc.wTotalLength); printf("\n bNumInterfaces = %u", config_desc.bNumInterfaces); printf("\n bConfigurationValue = %u", config_desc.bConfigurationValue); printf("\n iConfiguration = %u", config_desc.iConfiguration); printf("\n bmAttributes = %u", config_desc.bmAttributes); printf("\n MaxPower = %u", config_desc.MaxPower); } else { printf("\n--- AdbGetUsbConfigurationDescriptor failure %u", GetLastError()); return false; } // Get device serial number char ser_num[1024]; unsigned long ser_num_size = sizeof(ser_num); if (AdbGetSerialNumber(interface_handle, ser_num, &ser_num_size, true)) { printf("\n+++ Serial number: %s", ser_num); } else { printf("\n--- AdbGetSerialNumber failure %u", GetLastError()); return false; } // Get interface descriptor USB_INTERFACE_DESCRIPTOR intr_desc; if (AdbGetUsbInterfaceDescriptor(interface_handle, &intr_desc)) { printf("\n+++ Interface descriptor:"); printf("\n bDescriptorType = %u", intr_desc.bDescriptorType); printf("\n bInterfaceNumber = %u", intr_desc.bInterfaceNumber); printf("\n bAlternateSetting = %u", intr_desc.bAlternateSetting); printf("\n bNumEndpoints = %u", intr_desc.bNumEndpoints); printf("\n bInterfaceClass = %u", intr_desc.bInterfaceClass); printf("\n bInterfaceSubClass = %u", intr_desc.bInterfaceSubClass); printf("\n bInterfaceProtocol = %u", intr_desc.bInterfaceProtocol); printf("\n iInterface = %u", intr_desc.iInterface); } else { printf("\n--- AdbGetUsbInterfaceDescriptor failure %u", GetLastError()); return false; } // Enumerate interface's endpoints AdbEndpointInformation pipe_info; for (UCHAR pipe = 0; pipe < intr_desc.bNumEndpoints; pipe++) { if (AdbGetEndpointInformation(interface_handle, pipe, &pipe_info)) { printf("\n PIPE %u info:", pipe); printf("\n max_packet_size = %u", pipe_info.max_packet_size); printf("\n max_transfer_size = %u", pipe_info.max_transfer_size); printf("\n endpoint_type = %u", pipe_info.endpoint_type); printf("\n endpoint_address = %02X", pipe_info.endpoint_address); printf("\n polling_interval = %u", pipe_info.polling_interval); printf("\n setting_index = %u", pipe_info.setting_index); } else { printf("\n--- AdbGetEndpointInformation(%u) failure %u", pipe, GetLastError()); return false; } } // Get default bulk read endpoint info if (AdbGetDefaultBulkReadEndpointInformation(interface_handle, &pipe_info)) { printf("\n Default Bulk Read Pipe info:"); printf("\n max_packet_size = %u", pipe_info.max_packet_size); printf("\n max_transfer_size = %u", pipe_info.max_transfer_size); printf("\n endpoint_type = %u", pipe_info.endpoint_type); printf("\n endpoint_address = %02X", pipe_info.endpoint_address); printf("\n polling_interval = %u", pipe_info.polling_interval); printf("\n setting_index = %u", pipe_info.setting_index); } else { printf("\n--- AdbGetDefaultBulkReadEndpointInformation failure %u", GetLastError()); return false; } // Get default bulk write endpoint info if (AdbGetDefaultBulkWriteEndpointInformation(interface_handle, &pipe_info)) { printf("\n Default Bulk Write Pipe info:"); printf("\n max_packet_size = %u", pipe_info.max_packet_size); printf("\n max_transfer_size = %u", pipe_info.max_transfer_size); printf("\n endpoint_type = %u", pipe_info.endpoint_type); printf("\n endpoint_address = %02X", pipe_info.endpoint_address); printf("\n polling_interval = %u", pipe_info.polling_interval); printf("\n setting_index = %u", pipe_info.setting_index); } else { printf("\n--- AdbGetDefaultBulkWriteEndpointInformation failure %u", GetLastError()); return false; } // Test a handshake on that interface DeviceHandShake(interface_handle); return true; }
usb_handle* do_usb_open(const wchar_t* interface_name) { unsigned long name_len = 0; // Allocate our handle usb_handle* ret = (usb_handle*)calloc(1, sizeof(usb_handle)); if (nullptr == ret) { D("Could not allocate %u bytes for usb_handle: %s", sizeof(usb_handle), strerror(errno)); goto fail; } // Create interface. ret->adb_interface = AdbCreateInterfaceByName(interface_name); if (nullptr == ret->adb_interface) { D("AdbCreateInterfaceByName failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } // Open read pipe (endpoint) ret->adb_read_pipe = AdbOpenDefaultBulkReadEndpoint( ret->adb_interface, AdbOpenAccessTypeReadWrite, AdbOpenSharingModeReadWrite); if (nullptr == ret->adb_read_pipe) { D("AdbOpenDefaultBulkReadEndpoint failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } // Open write pipe (endpoint) ret->adb_write_pipe = AdbOpenDefaultBulkWriteEndpoint( ret->adb_interface, AdbOpenAccessTypeReadWrite, AdbOpenSharingModeReadWrite); if (nullptr == ret->adb_write_pipe) { D("AdbOpenDefaultBulkWriteEndpoint failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } // Save interface name // First get expected name length AdbGetInterfaceName(ret->adb_interface, nullptr, &name_len, false); if (0 == name_len) { D("AdbGetInterfaceName returned name length of zero: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } ret->interface_name = (wchar_t*)malloc(name_len * sizeof(ret->interface_name[0])); if (nullptr == ret->interface_name) { D("Could not allocate %lu characters for interface_name: %s", name_len, strerror(errno)); goto fail; } // Now save the name if (!AdbGetInterfaceName(ret->adb_interface, ret->interface_name, &name_len, false)) { D("AdbGetInterfaceName failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } // We're done at this point return ret; fail: if (nullptr != ret) { usb_cleanup_handle(ret); free(ret); } return nullptr; }