static usb_handle *find_usb_device(ifc_match_func callback) { usb_handle* handle = NULL; char entry_buffer[2048]; char interf_name[2048]; AdbInterfaceInfo* next_interface = (AdbInterfaceInfo*)(&entry_buffer[0]); unsigned long entry_buffer_size = sizeof(entry_buffer); char* copy_name; // Enumerate all present and active interfaces. ADBAPIHANDLE enum_handle = AdbEnumInterfaces(usb_class_id, true, true, true); if (NULL == enum_handle) return NULL; while (AdbNextInterface(enum_handle, next_interface, &entry_buffer_size)) { // TODO(vchtchetkine): FIXME - temp hack converting wchar_t into char. // It would be better to change AdbNextInterface so it will return // interface name as single char string. const wchar_t* wchar_name = next_interface->device_name; for(copy_name = interf_name; L'\0' != *wchar_name; wchar_name++, copy_name++) { *copy_name = (char)(*wchar_name); } *copy_name = '\0'; handle = do_usb_open(next_interface->device_name); if (NULL != handle) { // Lets see if this interface (device) belongs to us if (recognized_device(handle, callback)) { // found it! break; } else { usb_cleanup_handle(handle); free(handle); handle = NULL; } } entry_buffer_size = sizeof(entry_buffer); } AdbCloseHandle(enum_handle); return handle; }
bool TestInterfaces() { // Enumerate interfaces ADBAPIHANDLE enum_handle = AdbEnumInterfaces(kAdbInterfaceId, true, true, true); if (NULL == enum_handle) { printf("\nTest interfaces failure:"); printf("\nUnable to enumerate ADB interfaces: %u", GetLastError()); return false; } // Unite interface info structure and buffer big enough to contain the // largest structure. union { AdbInterfaceInfo interface_info; char buf[4096]; }; unsigned long buf_size = sizeof(buf); // Test each found interface while (AdbNextInterface(enum_handle, &interface_info, &buf_size)) { TestInterface(interface_info.device_name); buf_size = sizeof(buf); }; AdbCloseHandle(enum_handle); // Create interface by VID/PID/MI ADBAPIHANDLE interface_handle = AdbCreateInterface(kAdbInterfaceId, DEVICE_VENDOR_ID, DEVICE_COMPOSITE_PRODUCT_ID, DEVICE_INTERFACE_ID); if (NULL == interface_handle) { printf("\nUnable to create interface by VID/PID: %u", GetLastError()); return false; } // Test it TestInterfaceHandle(interface_handle); AdbCloseHandle(interface_handle); return true; }
bool TestEnumInterfaces() { // Enumerate interfaces ADBAPIHANDLE enum_handle = AdbEnumInterfaces(kAdbInterfaceId, true, true, true); if (NULL == enum_handle) { printf("\nEnum interfaces failure:"); printf("\nUnable to enumerate ADB interfaces: %u", GetLastError()); return false; } // Unite interface info structure and buffer big enough to contain the // largest structure. union { AdbInterfaceInfo interface_info; char buf[4096]; }; unsigned long buf_size = sizeof(buf); // Enumerate (and count) interfaces, printing information for each found // interface. interface_count = 0; while (AdbNextInterface(enum_handle, &interface_info, &buf_size)) { interface_count++; printf("\nFound interface %ws:", interface_info.device_name); if (interface_info.flags & SPINT_ACTIVE) printf(" ACTIVE"); if (interface_info.flags & SPINT_DEFAULT) printf(" DEFAULT"); if (interface_info.flags & SPINT_REMOVED) printf(" REMOVED"); buf_size = sizeof(buf);; }; AdbCloseHandle(enum_handle); return true; }
void find_devices() { usb_handle* handle = nullptr; char entry_buffer[2048]; AdbInterfaceInfo* next_interface = (AdbInterfaceInfo*)(&entry_buffer[0]); unsigned long entry_buffer_size = sizeof(entry_buffer); // Enumerate all present and active interfaces. ADBAPIHANDLE enum_handle = AdbEnumInterfaces(usb_class_id, true, true, true); if (nullptr == enum_handle) { D("AdbEnumInterfaces failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); return; } while (AdbNextInterface(enum_handle, next_interface, &entry_buffer_size)) { // Lets see if we already have this device in the list if (!known_device(next_interface->device_name)) { // This seems to be a new device. Open it! handle = do_usb_open(next_interface->device_name); if (nullptr != handle) { // Lets see if this interface (device) belongs to us if (recognized_device(handle)) { D("adding a new device %ls", next_interface->device_name); // We don't request a wchar_t string from AdbGetSerialNumber() because of a bug // in adb_winusb_interface.cpp:CopyMemory(buffer, ser_num->bString, // bytes_written) where the last parameter should be (str_len * // sizeof(wchar_t)). The bug reads 2 bytes past the end of a stack buffer in the // best case, and in the unlikely case of a long serial number, it will read 2 // bytes past the end of a heap allocation. This doesn't affect the resulting // string, but we should avoid the bad reads in the first place. char serial_number[512]; unsigned long serial_number_len = sizeof(serial_number); if (AdbGetSerialNumber(handle->adb_interface, serial_number, &serial_number_len, true)) { // Lets make sure that we don't duplicate this device if (register_new_device(handle)) { register_usb_transport(handle, serial_number, nullptr, 1); } else { D("register_new_device failed for %ls", next_interface->device_name); usb_cleanup_handle(handle); free(handle); } } else { D("cannot get serial number: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); usb_cleanup_handle(handle); free(handle); } } else { usb_cleanup_handle(handle); free(handle); } } } entry_buffer_size = sizeof(entry_buffer); } if (GetLastError() != ERROR_NO_MORE_ITEMS) { // Only ERROR_NO_MORE_ITEMS is expected at the end of enumeration. D("AdbNextInterface failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } _adb_close_handle(enum_handle); }