/* | |
* Copyright (C) 2009 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. | |
*/ | |
/** \file | |
This file consists of implementation of class AdbLegacyInterfaceObject | |
that encapsulates an interface on our USB device that is accessible | |
*/ | |
#include "stdafx.h" | |
#include "adb_api_legacy.h" | |
#include "adb_legacy_interface.h" | |
#include "adb_legacy_endpoint_object.h" | |
AdbLegacyInterfaceObject::AdbLegacyInterfaceObject(const wchar_t* interf_name) | |
: AdbInterfaceObject(interf_name), | |
def_read_endpoint_(0xFF), | |
read_endpoint_id_(0xFF), | |
def_write_endpoint_(0xFF), | |
write_endpoint_id_(0xFF) { | |
} | |
AdbLegacyInterfaceObject::~AdbLegacyInterfaceObject() { | |
} | |
ADBAPIHANDLE AdbLegacyInterfaceObject::CreateHandle() { | |
// Open USB device for this intefface | |
HANDLE usb_device_handle = CreateFile(interface_name().c_str(), | |
GENERIC_READ | GENERIC_WRITE, | |
FILE_SHARE_READ | FILE_SHARE_WRITE, | |
NULL, | |
OPEN_EXISTING, | |
0, | |
NULL); | |
if (INVALID_HANDLE_VALUE == usb_device_handle) { | |
return NULL; | |
} | |
// Now, we ensured that our usb device / interface is up and running. | |
// Lets collect device, interface and pipe information | |
bool ok = true; | |
if (!CacheUsbDeviceDescriptor(usb_device_handle) || | |
!CacheUsbConfigurationDescriptor(usb_device_handle) || | |
!CacheUsbInterfaceDescriptor(usb_device_handle)) { | |
ok = false; | |
} | |
// Preserve error accross handle close | |
ULONG error = ok ? NO_ERROR : GetLastError(); | |
::CloseHandle(usb_device_handle); | |
if (NO_ERROR != error) { | |
SetLastError(error); | |
} | |
if (!ok) { | |
return false; | |
} | |
// Save indexes and IDs for bulk read / write endpoints. We will use them to | |
// convert ADB_QUERY_BULK_WRITE_ENDPOINT_INDEX and | |
// ADB_QUERY_BULK_READ_ENDPOINT_INDEX into actual endpoint indexes and IDs. | |
for (UCHAR endpoint = 0; endpoint < usb_interface_descriptor_.bNumEndpoints; | |
endpoint++) { | |
// Get endpoint information | |
AdbEndpointInformation pipe_info; | |
if (!GetEndpointInformation(endpoint, &pipe_info)) { | |
return false; | |
} | |
if (AdbEndpointTypeBulk == pipe_info.endpoint_type) { | |
// This is a bulk endpoint. Cache its index and ID. | |
if (0 != (pipe_info.endpoint_address & USB_ENDPOINT_DIRECTION_MASK)) { | |
// Use this endpoint as default bulk read endpoint | |
ATLASSERT(0xFF == def_read_endpoint_); | |
def_read_endpoint_ = endpoint; | |
read_endpoint_id_ = pipe_info.endpoint_address; | |
} else { | |
// Use this endpoint as default bulk write endpoint | |
ATLASSERT(0xFF == def_write_endpoint_); | |
def_write_endpoint_ = endpoint; | |
write_endpoint_id_ = pipe_info.endpoint_address; | |
} | |
} | |
} | |
return AdbObjectHandle::CreateHandle(); | |
} | |
bool AdbLegacyInterfaceObject::GetSerialNumber(void* buffer, | |
unsigned long* buffer_char_size, | |
bool ansi) { | |
if (!IsOpened()) { | |
SetLastError(ERROR_INVALID_HANDLE); | |
return false; | |
} | |
// Open USB device for this intefface | |
HANDLE usb_device_handle = CreateFile(interface_name().c_str(), | |
GENERIC_READ, | |
FILE_SHARE_READ | FILE_SHARE_WRITE, | |
NULL, | |
OPEN_EXISTING, | |
0, | |
NULL); | |
if (INVALID_HANDLE_VALUE == usb_device_handle) { | |
return NULL; | |
} | |
WCHAR serial_number[512]; | |
// Send IOCTL | |
DWORD ret_bytes = 0; | |
BOOL ret = DeviceIoControl(usb_device_handle, | |
ADB_IOCTL_GET_SERIAL_NUMBER, | |
NULL, 0, | |
serial_number, sizeof(serial_number), | |
&ret_bytes, | |
NULL); | |
// Preserve error accross CloseHandle | |
ULONG error = ret ? NO_ERROR : GetLastError(); | |
::CloseHandle(usb_device_handle); | |
if (NO_ERROR != error) { | |
SetLastError(error); | |
return false; | |
} | |
unsigned long str_len = | |
static_cast<unsigned long>(wcslen(serial_number) + 1); | |
if ((NULL == buffer) || (*buffer_char_size < str_len)) { | |
*buffer_char_size = str_len; | |
SetLastError(ERROR_INSUFFICIENT_BUFFER); | |
return false; | |
} | |
if (!ansi) { | |
// If user asked for wide char name just return it | |
wcscpy(reinterpret_cast<wchar_t*>(buffer), serial_number); | |
return true; | |
} | |
// We need to convert name from wide char to ansi string | |
int res = WideCharToMultiByte(CP_ACP, | |
0, | |
serial_number, | |
static_cast<int>(str_len), | |
reinterpret_cast<PSTR>(buffer), | |
static_cast<int>(*buffer_char_size), | |
NULL, | |
NULL); | |
return (res != 0); | |
} | |
bool AdbLegacyInterfaceObject::GetEndpointInformation( | |
UCHAR endpoint_index, | |
AdbEndpointInformation* info) { | |
// Open USB device for this intefface | |
HANDLE usb_device_handle = CreateFile(interface_name().c_str(), | |
GENERIC_READ, | |
FILE_SHARE_READ | FILE_SHARE_WRITE, | |
NULL, | |
OPEN_EXISTING, | |
0, | |
NULL); | |
if (INVALID_HANDLE_VALUE == usb_device_handle) { | |
return NULL; | |
} | |
// Init ICTL param | |
AdbQueryEndpointInformation param; | |
param.endpoint_index = endpoint_index; | |
// Send IOCTL | |
DWORD ret_bytes = 0; | |
BOOL ret = DeviceIoControl(usb_device_handle, | |
ADB_IOCTL_GET_ENDPOINT_INFORMATION, | |
¶m, sizeof(param), | |
info, sizeof(AdbEndpointInformation), | |
&ret_bytes, | |
NULL); | |
ATLASSERT(!ret || (sizeof(AdbEndpointInformation) == ret_bytes)); | |
// Preserve error accross CloseHandle | |
ULONG error = ret ? NO_ERROR : GetLastError(); | |
::CloseHandle(usb_device_handle); | |
if (NO_ERROR != error) { | |
SetLastError(error); | |
} | |
return ret ? true : false; | |
} | |
ADBAPIHANDLE AdbLegacyInterfaceObject::OpenEndpoint( | |
UCHAR endpoint_index, | |
AdbOpenAccessType access_type, | |
AdbOpenSharingMode sharing_mode) { | |
// Convert index into name and ID. | |
std::wstring endpoint_name; | |
UCHAR endpoint_id; | |
try { | |
if ((ADB_QUERY_BULK_READ_ENDPOINT_INDEX == endpoint_index) || | |
(def_read_endpoint_ == endpoint_index)) { | |
endpoint_name = DEVICE_BULK_READ_PIPE_NAME; | |
endpoint_id = read_endpoint_id_; | |
endpoint_index = def_read_endpoint_; | |
} else if ((ADB_QUERY_BULK_WRITE_ENDPOINT_INDEX == endpoint_index) || | |
(def_write_endpoint_ == endpoint_index)) { | |
endpoint_name = DEVICE_BULK_WRITE_PIPE_NAME; | |
endpoint_id = write_endpoint_id_; | |
endpoint_index = def_write_endpoint_; | |
} else { | |
SetLastError(ERROR_INVALID_PARAMETER); | |
return false; | |
} | |
} catch (...) { | |
// We don't expect exceptions other than OOM thrown here. | |
SetLastError(ERROR_OUTOFMEMORY); | |
return NULL; | |
} | |
return OpenEndpoint(endpoint_name.c_str(), endpoint_id, endpoint_index, | |
access_type, sharing_mode); | |
} | |
ADBAPIHANDLE AdbLegacyInterfaceObject::OpenEndpoint( | |
const wchar_t* endpoint_name, | |
UCHAR endpoint_id, | |
UCHAR endpoint_index, | |
AdbOpenAccessType access_type, | |
AdbOpenSharingMode sharing_mode) { | |
if (!IsOpened()) { | |
SetLastError(ERROR_INVALID_HANDLE); | |
return false; | |
} | |
AdbLegacyEndpointObject* adb_endpoint = NULL; | |
try { | |
adb_endpoint = | |
new AdbLegacyEndpointObject(this, endpoint_id, endpoint_index); | |
} catch (...) { | |
// We don't expect exceptions other than OOM thrown here. | |
SetLastError(ERROR_OUTOFMEMORY); | |
return NULL; | |
} | |
// Build full path to the object | |
std::wstring endpoint_path = interface_name(); | |
endpoint_path += L"\\"; | |
endpoint_path += endpoint_name; | |
ADBAPIHANDLE ret = adb_endpoint->CreateHandle(endpoint_path.c_str(), | |
access_type, | |
sharing_mode); | |
adb_endpoint->Release(); | |
return ret; | |
} | |
bool AdbLegacyInterfaceObject::CacheUsbDeviceDescriptor( | |
HANDLE usb_device_handle) { | |
DWORD ret_bytes = 0; | |
BOOL ret = DeviceIoControl(usb_device_handle, | |
ADB_IOCTL_GET_USB_DEVICE_DESCRIPTOR, | |
NULL, 0, | |
&usb_device_descriptor_, | |
sizeof(usb_device_descriptor_), | |
&ret_bytes, | |
NULL); | |
ATLASSERT(!ret || (sizeof(USB_DEVICE_DESCRIPTOR) == ret_bytes)); | |
return ret ? true : false; | |
} | |
bool AdbLegacyInterfaceObject::CacheUsbConfigurationDescriptor( | |
HANDLE usb_device_handle) { | |
DWORD ret_bytes = 0; | |
BOOL ret = DeviceIoControl(usb_device_handle, | |
ADB_IOCTL_GET_USB_CONFIGURATION_DESCRIPTOR, | |
NULL, 0, | |
&usb_config_descriptor_, | |
sizeof(usb_config_descriptor_), | |
&ret_bytes, | |
NULL); | |
ATLASSERT(!ret || (sizeof(USB_CONFIGURATION_DESCRIPTOR) == ret_bytes)); | |
return ret ? true : false; | |
} | |
bool AdbLegacyInterfaceObject::CacheUsbInterfaceDescriptor( | |
HANDLE usb_device_handle) { | |
DWORD ret_bytes = 0; | |
BOOL ret = DeviceIoControl(usb_device_handle, | |
ADB_IOCTL_GET_USB_INTERFACE_DESCRIPTOR, | |
NULL, 0, | |
&usb_interface_descriptor_, | |
sizeof(usb_interface_descriptor_), | |
&ret_bytes, | |
NULL); | |
ATLASSERT(!ret || (sizeof(USB_INTERFACE_DESCRIPTOR) == ret_bytes)); | |
return ret ? true : false; | |
} |