merge from open-source master
This commit is contained in:
Jean-Baptiste Queru
commit
436db2e382
10 changed files with 720 additions and 17 deletions
|
|
@ -25,6 +25,12 @@ ifeq ($(HOST_OS),darwin)
|
|||
LOCAL_LDLIBS += -lpthread -framework CoreFoundation -framework IOKit -framework Carbon
|
||||
endif
|
||||
|
||||
ifeq ($(HOST_OS),freebsd)
|
||||
USB_SRCS := usb_libusb.c
|
||||
EXTRA_SRCS := get_my_path_freebsd.c
|
||||
LOCAL_LDLIBS += -lpthread -lusb
|
||||
endif
|
||||
|
||||
ifeq ($(HOST_OS),windows)
|
||||
USB_SRCS := usb_windows.c
|
||||
EXTRA_SRCS := get_my_path_windows.c
|
||||
|
|
|
|||
|
|
@ -783,7 +783,7 @@ int launch_server()
|
|||
fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
|
||||
return -1;
|
||||
}
|
||||
get_my_path(path);
|
||||
get_my_path(path, PATH_MAX);
|
||||
pid_t pid = fork();
|
||||
if(pid < 0) return -1;
|
||||
|
||||
|
|
|
|||
|
|
@ -236,7 +236,7 @@ void fatal_errno(const char *fmt, ...);
|
|||
void handle_packet(apacket *p, atransport *t);
|
||||
void send_packet(apacket *p, atransport *t);
|
||||
|
||||
void get_my_path(char s[PATH_MAX]);
|
||||
void get_my_path(char *s, size_t maxLen);
|
||||
int launch_server();
|
||||
int adb_main(int is_daemon);
|
||||
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ enum {
|
|||
|
||||
static int do_cmd(transport_type ttype, char* serial, char *cmd, ...);
|
||||
|
||||
void get_my_path(char s[PATH_MAX]);
|
||||
void get_my_path(char *s, size_t maxLen);
|
||||
int find_sync_dirs(const char *srcarg,
|
||||
char **android_srcdir_out, char **data_srcdir_out);
|
||||
int install_app(transport_type transport, char* serial, int argc, char** argv);
|
||||
|
|
@ -673,7 +673,7 @@ static char *find_top(char path_buf[PATH_MAX])
|
|||
/* If the CWD isn't under a good-looking top, see if the
|
||||
* executable is.
|
||||
*/
|
||||
get_my_path(dir);
|
||||
get_my_path(dir, PATH_MAX);
|
||||
top = find_top_from(dir, path_buf);
|
||||
}
|
||||
return top;
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
#import <Carbon/Carbon.h>
|
||||
#include <unistd.h>
|
||||
|
||||
void get_my_path(char s[PATH_MAX])
|
||||
void get_my_path(char *s, size_t maxLen)
|
||||
{
|
||||
ProcessSerialNumber psn;
|
||||
GetCurrentProcess(&psn);
|
||||
|
|
@ -25,6 +25,6 @@ void get_my_path(char s[PATH_MAX])
|
|||
dict = ProcessInformationCopyDictionary(&psn, 0xffffffff);
|
||||
CFStringRef value = (CFStringRef)CFDictionaryGetValue(dict,
|
||||
CFSTR("CFBundleExecutable"));
|
||||
CFStringGetCString(value, s, PATH_MAX - 1, kCFStringEncodingUTF8);
|
||||
CFStringGetCString(value, s, maxLen, kCFStringEncodingUTF8);
|
||||
}
|
||||
|
||||
|
|
|
|||
36
adb/get_my_path_freebsd.c
Normal file
36
adb/get_my_path_freebsd.c
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
/*
|
||||
* Copyright (C) 2009 bsdroid project
|
||||
* Alexey Tarasov <tarasov@dodologics.com>
|
||||
*
|
||||
* Copyright (C) 2007 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.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
#include <limits.h>
|
||||
#include <stdio.h>
|
||||
|
||||
void
|
||||
get_my_path(char *exe, size_t maxLen)
|
||||
{
|
||||
char proc[64];
|
||||
|
||||
snprintf(proc, sizeof(proc), "/proc/%d/file", getpid());
|
||||
|
||||
int err = readlink(proc, exe, maxLen - 1);
|
||||
|
||||
exe[err > 0 ? err : 0] = '\0';
|
||||
}
|
||||
|
||||
|
|
@ -19,15 +19,15 @@
|
|||
#include <limits.h>
|
||||
#include <stdio.h>
|
||||
|
||||
void get_my_path(char exe[PATH_MAX])
|
||||
void get_my_path(char *exe, size_t maxLen)
|
||||
{
|
||||
char proc[64];
|
||||
snprintf(proc, sizeof proc, "/proc/%d/exe", getpid());
|
||||
int err = readlink(proc, exe, PATH_MAX - 1);
|
||||
int err = readlink(proc, exe, maxLen - 1);
|
||||
if(err > 0) {
|
||||
exe[err] = 0;
|
||||
exe[err] = '\0';
|
||||
} else {
|
||||
exe[0] = 0;
|
||||
exe[0] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -18,14 +18,17 @@
|
|||
#include <assert.h>
|
||||
#include <windows.h>
|
||||
|
||||
void get_my_path(char exe[PATH_MAX])
|
||||
void get_my_path(char *exe, size_t maxLen)
|
||||
{
|
||||
char* r;
|
||||
char *r;
|
||||
|
||||
GetModuleFileName( NULL, exe, PATH_MAX-1 );
|
||||
exe[PATH_MAX-1] = 0;
|
||||
r = strrchr( exe, '\\' );
|
||||
if (r)
|
||||
*r = 0;
|
||||
/* XXX: should be GetModuleFileNameA */
|
||||
if (GetModuleFileName(NULL, exe, maxLen) > 0) {
|
||||
r = strrchr(exe, '\\');
|
||||
if (r != NULL)
|
||||
*r = '\0';
|
||||
} else {
|
||||
exe[0] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
657
adb/usb_libusb.c
Normal file
657
adb/usb_libusb.c
Normal file
|
|
@ -0,0 +1,657 @@
|
|||
/*
|
||||
* Copyright (C) 2009 bsdroid project
|
||||
* Alexey Tarasov <tarasov@dodologics.com>
|
||||
*
|
||||
* Copyright (C) 2007 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.
|
||||
*/
|
||||
|
||||
#include <sys/endian.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/uio.h>
|
||||
|
||||
#include <err.h>
|
||||
#include <errno.h>
|
||||
#include <poll.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <strings.h>
|
||||
#include <string.h>
|
||||
#include <sysexits.h>
|
||||
#include <unistd.h>
|
||||
#include <libusb.h>
|
||||
#include "sysdeps.h"
|
||||
|
||||
#define TRACE_TAG TRACE_USB
|
||||
#include "adb.h"
|
||||
|
||||
static adb_mutex_t usb_lock = ADB_MUTEX_INITIALIZER;
|
||||
static libusb_context *ctx = NULL;
|
||||
|
||||
struct usb_handle
|
||||
{
|
||||
usb_handle *prev;
|
||||
usb_handle *next;
|
||||
|
||||
libusb_device *dev;
|
||||
libusb_device_handle *devh;
|
||||
int interface;
|
||||
uint8_t dev_bus;
|
||||
uint8_t dev_addr;
|
||||
|
||||
int zero_mask;
|
||||
unsigned char end_point_address[2];
|
||||
char serial[128];
|
||||
|
||||
adb_cond_t notify;
|
||||
adb_mutex_t lock;
|
||||
};
|
||||
|
||||
static struct usb_handle handle_list = {
|
||||
.prev = &handle_list,
|
||||
.next = &handle_list,
|
||||
};
|
||||
|
||||
void
|
||||
usb_cleanup()
|
||||
{
|
||||
libusb_exit(ctx);
|
||||
}
|
||||
|
||||
void
|
||||
report_bulk_libusb_error(int r)
|
||||
{
|
||||
switch (r) {
|
||||
case LIBUSB_ERROR_TIMEOUT:
|
||||
D("Transfer timeout\n");
|
||||
break;
|
||||
|
||||
case LIBUSB_ERROR_PIPE:
|
||||
D("Control request is not supported\n");
|
||||
break;
|
||||
|
||||
case LIBUSB_ERROR_OVERFLOW:
|
||||
D("Device offered more data\n");
|
||||
break;
|
||||
|
||||
case LIBUSB_ERROR_NO_DEVICE :
|
||||
D("Device was disconnected\n");
|
||||
break;
|
||||
|
||||
default:
|
||||
D("Error %d during transfer\n", r);
|
||||
break;
|
||||
};
|
||||
}
|
||||
|
||||
static int
|
||||
usb_bulk_write(usb_handle *uh, const void *data, int len)
|
||||
{
|
||||
int r = 0;
|
||||
int transferred = 0;
|
||||
|
||||
r = libusb_bulk_transfer(uh->devh, uh->end_point_address[1], (void *)data, len,
|
||||
&transferred, 0);
|
||||
|
||||
if (r != 0) {
|
||||
D("usb_bulk_write(): ");
|
||||
report_bulk_libusb_error(r);
|
||||
return r;
|
||||
}
|
||||
|
||||
return (transferred);
|
||||
}
|
||||
|
||||
static int
|
||||
usb_bulk_read(usb_handle *uh, void *data, int len)
|
||||
{
|
||||
int r = 0;
|
||||
int transferred = 0;
|
||||
|
||||
r = libusb_bulk_transfer(uh->devh, uh->end_point_address[0], data, len,
|
||||
&transferred, 0);
|
||||
|
||||
if (r != 0) {
|
||||
D("usb_bulk_read(): ");
|
||||
report_bulk_libusb_error(r);
|
||||
return r;
|
||||
}
|
||||
|
||||
return (transferred);
|
||||
}
|
||||
|
||||
int
|
||||
usb_write(struct usb_handle *uh, const void *_data, int len)
|
||||
{
|
||||
unsigned char *data = (unsigned char*) _data;
|
||||
int n;
|
||||
int need_zero = 0;
|
||||
|
||||
if (uh->zero_mask == 1) {
|
||||
if (!(len & uh->zero_mask)) {
|
||||
need_zero = 1;
|
||||
}
|
||||
}
|
||||
|
||||
D("usb_write(): %p:%d -> transport %p\n", _data, len, uh);
|
||||
|
||||
while (len > 0) {
|
||||
int xfer = (len > 4096) ? 4096 : len;
|
||||
|
||||
n = usb_bulk_write(uh, data, xfer);
|
||||
|
||||
if (n != xfer) {
|
||||
D("usb_write(): failed for transport %p (%d bytes left)\n", uh, len);
|
||||
return -1;
|
||||
}
|
||||
|
||||
len -= xfer;
|
||||
data += xfer;
|
||||
}
|
||||
|
||||
if (need_zero){
|
||||
n = usb_bulk_write(uh, _data, 0);
|
||||
|
||||
if (n < 0) {
|
||||
D("usb_write(): failed to finish operation for transport %p\n", uh);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
usb_read(struct usb_handle *uh, void *_data, int len)
|
||||
{
|
||||
unsigned char *data = (unsigned char*) _data;
|
||||
int n;
|
||||
|
||||
D("usb_read(): %p:%d <- transport %p\n", _data, len, uh);
|
||||
|
||||
while (len > 0) {
|
||||
int xfer = (len > 4096) ? 4096 : len;
|
||||
|
||||
n = usb_bulk_read(uh, data, xfer);
|
||||
|
||||
if (n != xfer) {
|
||||
if (n > 0) {
|
||||
data += n;
|
||||
len -= n;
|
||||
continue;
|
||||
}
|
||||
|
||||
D("usb_read(): failed for transport %p (%d bytes left)\n", uh, len);
|
||||
return -1;
|
||||
}
|
||||
|
||||
len -= xfer;
|
||||
data += xfer;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
usb_close(struct usb_handle *h)
|
||||
{
|
||||
D("usb_close(): closing transport %p\n", h);
|
||||
adb_mutex_lock(&usb_lock);
|
||||
|
||||
h->next->prev = h->prev;
|
||||
h->prev->next = h->next;
|
||||
h->prev = NULL;
|
||||
h->next = NULL;
|
||||
|
||||
libusb_release_interface(h->devh, h->interface);
|
||||
libusb_close(h->devh);
|
||||
libusb_unref_device(h->dev);
|
||||
|
||||
adb_mutex_unlock(&usb_lock);
|
||||
|
||||
free(h);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
void usb_kick(struct usb_handle *h)
|
||||
{
|
||||
D("usb_cick(): kicking transport %p\n", h);
|
||||
|
||||
adb_mutex_lock(&h->lock);
|
||||
unregister_usb_transport(h);
|
||||
adb_mutex_unlock(&h->lock);
|
||||
|
||||
h->next->prev = h->prev;
|
||||
h->prev->next = h->next;
|
||||
h->prev = NULL;
|
||||
h->next = NULL;
|
||||
|
||||
libusb_release_interface(h->devh, h->interface);
|
||||
libusb_close(h->devh);
|
||||
libusb_unref_device(h->dev);
|
||||
free(h);
|
||||
}
|
||||
|
||||
int
|
||||
check_usb_interface(libusb_interface *interface,
|
||||
libusb_device_descriptor *desc,
|
||||
struct usb_handle *uh)
|
||||
{
|
||||
int e;
|
||||
|
||||
if (interface->num_altsetting == 0) {
|
||||
D("check_usb_interface(): No interface settings\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
libusb_interface_descriptor *idesc = &interface->altsetting[0];
|
||||
|
||||
if (idesc->bNumEndpoints != 2) {
|
||||
D("check_usb_interface(): Interface have not 2 endpoints, ignoring\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (e = 0; e < idesc->bNumEndpoints; e++) {
|
||||
libusb_endpoint_descriptor *edesc = &idesc->endpoint[e];
|
||||
|
||||
if (edesc->bmAttributes != LIBUSB_TRANSFER_TYPE_BULK) {
|
||||
D("check_usb_interface(): Endpoint (%u) is not bulk (%u), ignoring\n",
|
||||
edesc->bmAttributes, LIBUSB_TRANSFER_TYPE_BULK);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (edesc->bEndpointAddress & LIBUSB_ENDPOINT_IN)
|
||||
uh->end_point_address[0] = edesc->bEndpointAddress;
|
||||
else
|
||||
uh->end_point_address[1] = edesc->bEndpointAddress;
|
||||
|
||||
/* aproto 01 needs 0 termination */
|
||||
if (idesc->bInterfaceProtocol == 0x01) {
|
||||
uh->zero_mask = edesc->wMaxPacketSize - 1;
|
||||
D("check_usb_interface(): Forced Android interface protocol v.1\n");
|
||||
}
|
||||
}
|
||||
|
||||
D("check_usb_interface(): Device: %04x:%04x "
|
||||
"iclass: %x, isclass: %x, iproto: %x ep: %x/%x-> ",
|
||||
desc->idVendor, desc->idProduct, idesc->bInterfaceClass,
|
||||
idesc->bInterfaceSubClass, idesc->bInterfaceProtocol,
|
||||
uh->end_point_address[0], uh->end_point_address[1]);
|
||||
|
||||
if (!is_adb_interface(desc->idVendor, desc->idProduct,
|
||||
idesc->bInterfaceClass, idesc->bInterfaceSubClass,
|
||||
idesc->bInterfaceProtocol))
|
||||
{
|
||||
D("not matches\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
D("matches\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
check_usb_interfaces(libusb_config_descriptor *config,
|
||||
libusb_device_descriptor *desc, struct usb_handle *uh)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < config->bNumInterfaces; ++i) {
|
||||
if (check_usb_interface(&config->interface[i], desc, uh) != -1) {
|
||||
/* found some interface and saved information about it */
|
||||
D("check_usb_interfaces(): Interface %d of %04x:%04x "
|
||||
"matches Android device\n", i, desc->idVendor,
|
||||
desc->idProduct);
|
||||
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
register_device(struct usb_handle *uh, const char *serial)
|
||||
{
|
||||
D("register_device(): Registering %p [%s] as USB transport\n",
|
||||
uh, serial);
|
||||
|
||||
struct usb_handle *usb= NULL;
|
||||
|
||||
usb = calloc(1, sizeof(struct usb_handle));
|
||||
memcpy(usb, uh, sizeof(struct usb_handle));
|
||||
strcpy(usb->serial, uh->serial);
|
||||
|
||||
adb_cond_init(&usb->notify, 0);
|
||||
adb_mutex_init(&usb->lock, 0);
|
||||
|
||||
adb_mutex_lock(&usb_lock);
|
||||
|
||||
usb->next = &handle_list;
|
||||
usb->prev = handle_list.prev;
|
||||
usb->prev->next = usb;
|
||||
usb->next->prev = usb;
|
||||
|
||||
adb_mutex_unlock(&usb_lock);
|
||||
|
||||
register_usb_transport(usb, serial, 1);
|
||||
|
||||
return (1);
|
||||
}
|
||||
|
||||
int
|
||||
already_registered(usb_handle *uh)
|
||||
{
|
||||
struct usb_handle *usb= NULL;
|
||||
int exists = 0;
|
||||
|
||||
adb_mutex_lock(&usb_lock);
|
||||
|
||||
for (usb = handle_list.next; usb != &handle_list; usb = usb->next) {
|
||||
if ((usb->dev_bus == uh->dev_bus) &&
|
||||
(usb->dev_addr == uh->dev_addr))
|
||||
{
|
||||
exists = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
adb_mutex_unlock(&usb_lock);
|
||||
|
||||
return exists;
|
||||
}
|
||||
|
||||
void
|
||||
check_device(libusb_device *dev)
|
||||
{
|
||||
struct usb_handle uh;
|
||||
int i = 0;
|
||||
int found = -1;
|
||||
char serial[256] = {0};
|
||||
|
||||
libusb_device_descriptor desc;
|
||||
libusb_config_descriptor *config = NULL;
|
||||
|
||||
int r = libusb_get_device_descriptor(dev, &desc);
|
||||
|
||||
if (r != LIBUSB_SUCCESS) {
|
||||
D("check_device(): Failed to get device descriptor\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if ((desc.idVendor == 0) && (desc.idProduct == 0))
|
||||
return;
|
||||
|
||||
D("check_device(): Probing usb device %04x:%04x\n",
|
||||
desc.idVendor, desc.idProduct);
|
||||
|
||||
if (!is_adb_interface (desc.idVendor, desc.idProduct,
|
||||
ADB_CLASS, ADB_SUBCLASS, ADB_PROTOCOL))
|
||||
{
|
||||
D("check_device(): Ignored due unknown vendor id\n");
|
||||
return;
|
||||
}
|
||||
|
||||
uh.dev_bus = libusb_get_bus_number(dev);
|
||||
uh.dev_addr = libusb_get_device_address(dev);
|
||||
|
||||
if (already_registered(&uh)) {
|
||||
D("check_device(): Device (bus: %d, address: %d) "
|
||||
"is already registered\n", uh.dev_bus, uh.dev_addr);
|
||||
return;
|
||||
}
|
||||
|
||||
D("check_device(): Device bus: %d, address: %d\n",
|
||||
uh.dev_bus, uh.dev_addr);
|
||||
|
||||
r = libusb_get_active_config_descriptor(dev, &config);
|
||||
|
||||
if (r != 0) {
|
||||
if (r == LIBUSB_ERROR_NOT_FOUND) {
|
||||
D("check_device(): Device %4x:%4x is unconfigured\n",
|
||||
desc.idVendor, desc.idProduct);
|
||||
return;
|
||||
}
|
||||
|
||||
D("check_device(): Failed to get configuration for %4x:%4x\n",
|
||||
desc.idVendor, desc.idProduct);
|
||||
return;
|
||||
}
|
||||
|
||||
if (config == NULL) {
|
||||
D("check_device(): Sanity check failed after "
|
||||
"getting active config\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (config->interface != NULL) {
|
||||
found = check_usb_interfaces(config, &desc, &uh);
|
||||
}
|
||||
|
||||
/* not needed anymore */
|
||||
libusb_free_config_descriptor(config);
|
||||
|
||||
r = libusb_open(dev, &uh.devh);
|
||||
uh.dev = dev;
|
||||
|
||||
if (r != 0) {
|
||||
switch (r) {
|
||||
case LIBUSB_ERROR_NO_MEM:
|
||||
D("check_device(): Memory allocation problem\n");
|
||||
break;
|
||||
|
||||
case LIBUSB_ERROR_ACCESS:
|
||||
D("check_device(): Permissions problem, "
|
||||
"current user priveleges are messed up?\n");
|
||||
break;
|
||||
|
||||
case LIBUSB_ERROR_NO_DEVICE:
|
||||
D("check_device(): Device disconected, bad cable?\n");
|
||||
break;
|
||||
|
||||
default:
|
||||
D("check_device(): libusb triggered error %d\n", r);
|
||||
}
|
||||
// skip rest
|
||||
found = -1;
|
||||
}
|
||||
|
||||
if (found >= 0) {
|
||||
D("check_device(): Device matches Android interface\n");
|
||||
// read the device's serial number
|
||||
memset(serial, 0, sizeof(serial));
|
||||
uh.interface = found;
|
||||
|
||||
r = libusb_claim_interface(uh.devh, uh.interface);
|
||||
|
||||
if (r < 0) {
|
||||
D("check_device(): Failed to claim interface %d\n",
|
||||
uh.interface);
|
||||
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (desc.iSerialNumber) {
|
||||
// reading serial
|
||||
uint16_t buffer[128] = {0};
|
||||
uint16_t languages[128] = {0};
|
||||
int languageCount = 0;
|
||||
|
||||
memset(languages, 0, sizeof(languages));
|
||||
r = libusb_control_transfer(uh.devh,
|
||||
LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
|
||||
LIBUSB_REQUEST_GET_DESCRIPTOR, LIBUSB_DT_STRING << 8,
|
||||
0, (uint8_t *)languages, sizeof(languages), 0);
|
||||
|
||||
if (r <= 0) {
|
||||
D("check_device(): Failed to get languages count\n");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
languageCount = (r - 2) / 2;
|
||||
|
||||
for (i = 1; i <= languageCount; ++i) {
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
|
||||
r = libusb_control_transfer(uh.devh,
|
||||
LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
|
||||
LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc.iSerialNumber,
|
||||
languages[i], (uint8_t *)buffer, sizeof(buffer), 0);
|
||||
|
||||
if (r > 0) { /* converting serial */
|
||||
int j = 0;
|
||||
r /= 2;
|
||||
|
||||
for (j = 1; j < r; ++j)
|
||||
serial[j - 1] = buffer[j];
|
||||
|
||||
serial[j - 1] = '\0';
|
||||
break; /* languagesCount cycle */
|
||||
}
|
||||
}
|
||||
|
||||
if (register_device(&uh, serial) == 0) {
|
||||
D("check_device(): Failed to register device\n");
|
||||
goto fail_interface;
|
||||
}
|
||||
|
||||
libusb_ref_device(dev);
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
fail_interface:
|
||||
libusb_release_interface(uh.devh, uh.interface);
|
||||
|
||||
fail:
|
||||
libusb_close(uh.devh);
|
||||
uh.devh = NULL;
|
||||
}
|
||||
|
||||
int
|
||||
check_device_connected(struct usb_handle *uh)
|
||||
{
|
||||
int r = libusb_kernel_driver_active(uh->devh, uh->interface);
|
||||
|
||||
if (r == LIBUSB_ERROR_NO_DEVICE)
|
||||
return 0;
|
||||
|
||||
if (r < 0)
|
||||
return -1;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
kick_disconnected()
|
||||
{
|
||||
struct usb_handle *usb= NULL;
|
||||
|
||||
adb_mutex_lock(&usb_lock);
|
||||
|
||||
for (usb = handle_list.next; usb != &handle_list; usb = usb->next) {
|
||||
|
||||
if (check_device_connected(usb) == 0) {
|
||||
D("kick_disconnected(): Transport %p is not online anymore\n",
|
||||
usb);
|
||||
|
||||
usb_kick(usb);
|
||||
}
|
||||
}
|
||||
|
||||
adb_mutex_unlock(&usb_lock);
|
||||
}
|
||||
|
||||
void
|
||||
scan_usb_devices()
|
||||
{
|
||||
D("scan_usb_devices(): started\n");
|
||||
|
||||
libusb_device **devs= NULL;
|
||||
libusb_device *dev= NULL;
|
||||
ssize_t cnt = libusb_get_device_list(ctx, &devs);
|
||||
|
||||
if (cnt < 0) {
|
||||
D("scan_usb_devices(): Failed to get device list (error: %d)\n",
|
||||
cnt);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int i = 0;
|
||||
|
||||
while ((dev = devs[i++]) != NULL) {
|
||||
check_device(dev);
|
||||
}
|
||||
|
||||
libusb_free_device_list(devs, 1);
|
||||
}
|
||||
|
||||
void *
|
||||
device_poll_thread(void* unused)
|
||||
{
|
||||
D("device_poll_thread(): Created USB scan thread\n");
|
||||
|
||||
for (;;) {
|
||||
sleep(5);
|
||||
kick_disconnected();
|
||||
scan_usb_devices();
|
||||
}
|
||||
|
||||
/* never reaching this point */
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
sigalrm_handler(int signo)
|
||||
{
|
||||
/* nothing */
|
||||
}
|
||||
|
||||
void
|
||||
usb_init()
|
||||
{
|
||||
D("usb_init(): started\n");
|
||||
adb_thread_t tid;
|
||||
struct sigaction actions;
|
||||
|
||||
int r = libusb_init(&ctx);
|
||||
|
||||
if (r != LIBUSB_SUCCESS) {
|
||||
err(EX_IOERR, "Failed to init libusb\n");
|
||||
}
|
||||
|
||||
memset(&actions, 0, sizeof(actions));
|
||||
|
||||
sigemptyset(&actions.sa_mask);
|
||||
|
||||
actions.sa_flags = 0;
|
||||
actions.sa_handler = sigalrm_handler;
|
||||
|
||||
sigaction(SIGALRM, &actions, NULL);
|
||||
|
||||
/* initial device scan */
|
||||
scan_usb_devices();
|
||||
|
||||
/* starting USB event polling thread */
|
||||
if (adb_thread_create(&tid, device_poll_thread, NULL)) {
|
||||
err(EX_IOERR, "cannot create USB scan thread\n");
|
||||
}
|
||||
|
||||
D("usb_init(): finished\n");
|
||||
}
|
||||
|
||||
|
|
@ -150,6 +150,7 @@ int match_fastboot(usb_ifc_info *info)
|
|||
(info->dev_vendor != 0x18d1) && // Google
|
||||
(info->dev_vendor != 0x0451) &&
|
||||
(info->dev_vendor != 0x22b8) && // Motorola
|
||||
(info->dev_vendor != 0x0502) &&
|
||||
(info->dev_vendor != 0x0bb4)) // HTC
|
||||
return -1;
|
||||
if(info->ifc_class != 0xff) return -1;
|
||||
|
|
|
|||
Loading…
Reference in a new issue