void usb_init()
{
if (!initialized)
{
adb_thread_t tid;
notificationIterators = (io_iterator_t*)malloc(
vendorIdCount * sizeof(io_iterator_t));
adb_mutex_init(&start_lock, NULL);
adb_cond_init(&start_cond, NULL);
if(adb_thread_create(&tid, RunLoopThread, NULL))
fatal_errno("cannot create input thread");
// Wait for initialization to finish
adb_mutex_lock(&start_lock);
adb_cond_wait(&start_cond, &start_lock);
adb_mutex_unlock(&start_lock);
adb_mutex_destroy(&start_lock);
adb_cond_destroy(&start_cond);
initialized = 1;
}
}
int list_transports(char *buf, size_t bufsize)
{
char* p = buf;
char* end = buf + bufsize;
int len;
atransport *t;
/* XXX OVERRUN PROBLEMS XXX */
adb_mutex_lock(&transport_lock);
for(t = transport_list.next; t != &transport_list; t = t->next) {
const char* serial = t->serial;
if (!serial || !serial[0])
serial = "????????????";
len = snprintf(p, end - p, "%s\t%s\n", serial, statename(t));
if (p + len >= end) {
/* discard last line if buffer is too short */
break;
}
p += len;
}
p[0] = 0;
adb_mutex_unlock(&transport_lock);
return p - buf;
}
void usb_init(int (*spawnD)())
{
if (!initialized)
{
notificationIterators = (io_iterator_t*)malloc(
vendorIdCount * sizeof(io_iterator_t));
adb_mutex_init(&start_lock, NULL);
adb_cond_init(&start_cond, NULL);
D("Before thread_create");
if(spawnD())
fatal_errno("cannot create RunLoopThread");
D("After thread_create");
// Wait for initialization to finish
adb_mutex_lock(&start_lock);
adb_cond_wait(&start_cond, &start_lock);
adb_mutex_unlock(&start_lock);
adb_mutex_destroy(&start_lock);
adb_cond_destroy(&start_cond);
initialized = 1;
}
}
void* RunLoopThread(void* args)
{
unsigned i;
InitUSB();
currentRunLoop = CFRunLoopGetCurrent();
CFRunLoopTimerContext context = {0, NULL, NULL, NULL, NULL};
CFRunLoopTimerRef timer = CFRunLoopTimerCreate(kCFAllocatorDefault, 0.1, 0.1, 0, 0, &onTimerFired, &context);
CFRunLoopAddTimer(currentRunLoop, timer, kCFRunLoopCommonModes);
// Signal the parent that we are running
adb_mutex_lock(&start_lock);
adb_cond_signal(&start_cond);
adb_mutex_unlock(&start_lock);
CFRunLoopRun();
currentRunLoop = 0;
for (i = 0; i < vendorIdCount; i++) {
IOObjectRelease(notificationIterators[i]);
}
IONotificationPortDestroy(notificationPort);
usb_cleanup();
DBG("RunLoopThread done\n");
return NULL;
}
// unregisters all non-emulator TCP transports
void unregister_all_tcp_transports()
{
#ifdef WIN32
printf("Legacy\n");
abort();
#else
atransport *t, *next;
adb_mutex_lock(&transport_lock);
for (t = transport_list.next; t != &transport_list; t = next) {
next = t->next;
if (t->type == kTransportLocal && t->adb_port == 0) {
t->next->prev = t->prev;
t->prev->next = next;
// we cannot call kick_transport when holding transport_lock
if (!t->kicked)
{
t->kicked = 1;
t->kick(t);
}
transport_unref_locked(t);
}
}
adb_mutex_unlock(&transport_lock);
#endif
}
static FH
_fh_alloc( FHClass clazz )
{
int nn;
FH f = NULL;
adb_mutex_lock( &_win32_lock );
if (_win32_fh_count < WIN32_MAX_FHS) {
f = &_win32_fhs[ _win32_fh_count++ ];
goto Exit;
}
for (nn = 0; nn < WIN32_MAX_FHS; nn++) {
if ( _win32_fhs[nn].clazz == NULL) {
f = &_win32_fhs[nn];
goto Exit;
}
}
D( "_fh_alloc: no more free file descriptors\n" );
Exit:
if (f) {
f->clazz = clazz;
f->used = 1;
f->eof = 0;
clazz->_fh_init(f);
}
adb_mutex_unlock( &_win32_lock );
return f;
}
atransport* find_emulator_transport_by_adb_port(int adb_port)
{
adb_mutex_lock( &local_transports_lock );
atransport* result = find_emulator_transport_by_adb_port_locked(adb_port);
adb_mutex_unlock( &local_transports_lock );
return result;
}
// This should only be used for transports with connection_state == kCsNoPerm.
void unregister_usb_transport(usb_handle *usb) {
adb_mutex_lock(&transport_lock);
transport_list.remove_if([usb](atransport* t) {
return t->usb == usb && t->connection_state == kCsNoPerm;
});
adb_mutex_unlock(&transport_lock);
}
int get_available_local_transport_index()
{
adb_mutex_lock( &local_transports_lock );
int result = get_available_local_transport_index_locked();
adb_mutex_unlock( &local_transports_lock );
return result;
}
int register_socket_transport(int s, const char *serial, int port, int local)
{
atransport *t = reinterpret_cast<atransport*>(calloc(1, sizeof(atransport)));
if (t == nullptr) {
return -1;
}
atransport *n;
char buff[32];
if (!serial) {
snprintf(buff, sizeof buff, "T-%p", t);
serial = buff;
}
D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port);
if (init_socket_transport(t, s, port, local) < 0) {
free(t);
return -1;
}
adb_mutex_lock(&transport_lock);
for (n = pending_list.next; n != &pending_list; n = n->next) {
if (n->serial && !strcmp(serial, n->serial)) {
adb_mutex_unlock(&transport_lock);
free(t);
return -1;
}
}
for (n = transport_list.next; n != &transport_list; n = n->next) {
if (n->serial && !strcmp(serial, n->serial)) {
adb_mutex_unlock(&transport_lock);
free(t);
return -1;
}
}
t->next = &pending_list;
t->prev = pending_list.prev;
t->next->prev = t;
t->prev->next = t;
t->serial = strdup(serial);
adb_mutex_unlock(&transport_lock);
register_transport(t);
return 0;
}
static void transport_unref(atransport *t)
{
if (t) {
adb_mutex_lock(&transport_lock);
transport_unref_locked(t);
adb_mutex_unlock(&transport_lock);
}
}
std::string list_transports(bool long_listing) {
std::string result;
adb_mutex_lock(&transport_lock);
for (const auto& t : transport_list) {
append_transport(t, &result, long_listing);
}
adb_mutex_unlock(&transport_lock);
return result;
}
static void dump_fde(fdevent *fde, const char *info) {
adb_mutex_lock(&D_lock);
fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd,
fde->state & FDE_READ ? 'R' : ' ',
fde->state & FDE_WRITE ? 'W' : ' ',
fde->state & FDE_ERROR ? 'E' : ' ',
info);
adb_mutex_unlock(&D_lock);
}
void install_local_socket(asocket *s)
{
adb_mutex_lock(&socket_list_lock);
s->id = local_socket_next_id++;
insert_local_socket(s, &local_socket_list);
adb_mutex_unlock(&socket_list_lock);
}
static void transport_unref(atransport *t)
{
D("in unref transport\n");
if (t) {
adb_mutex_lock(&transport_lock);
transport_unref_locked(t);
adb_mutex_unlock(&transport_lock);
}
}
void add_transport_disconnect(atransport* t, adisconnect* dis)
{
adb_mutex_lock(&transport_lock);
dis->next = &t->disconnects;
dis->prev = dis->next->prev;
dis->prev->next = dis;
dis->next->prev = dis;
adb_mutex_unlock(&transport_lock);
}
std::string list_transports(bool long_listing) {
std::string result;
adb_mutex_lock(&transport_lock);
for (atransport* t = transport_list.next; t != &transport_list; t = t->next) {
append_transport(t, &result, long_listing);
}
adb_mutex_unlock(&transport_lock);
return result;
}
void unregister_transport(atransport *t)
{
adb_mutex_lock(&transport_lock);
t->next->prev = t->prev;
t->prev->next = t->next;
adb_mutex_unlock(&transport_lock);
kick_transport(t);
transport_unref(t);
}
/* hack for osx */
void close_usb_devices() {
adb_mutex_lock(&transport_lock);
for (const auto& t : transport_list) {
if (!t->kicked) {
t->kicked = 1;
t->kick(t);
}
}
adb_mutex_unlock(&transport_lock);
}
int known_device(const char* dev_name) {
int ret = 0;
if (NULL != dev_name) {
adb_mutex_lock(&usb_lock);
ret = known_device_locked(dev_name);
adb_mutex_unlock(&usb_lock);
}
return ret;
}
static void clear_received_packet()
{
adb_mutex_lock(&packet_lock);
while(received != NULL) {
apacket* packet = received;
received = received->next;
put_apacket(packet);
}
received = last = NULL;
adb_mutex_unlock(&packet_lock);
}
void usb_kick(usb_handle *h)
{
D("usb_kick\n");
adb_mutex_lock(&h->lock);
adb_close(h->fd);
h->fd = -1;
// notify usb_open_thread that we are disconnected
adb_cond_signal(&h->notify);
adb_mutex_unlock(&h->lock);
}
void dump_thread_tag() {
adb_mutex_lock(&threads_active_lock);
int didDump = 0;
pthread_t currentThread = pthread_self();
int len = __adb_threads_active->length;
for (int i = 0; i < len; i++) {
if (pthread_equal(currentThread, *__adb_threads_active->base[i])) {
D("CURRENT THREAD IS %s\n", __adb_tags_active->base[i]);
didDump = 1;
adb_mutex_unlock(&threads_active_lock);
return;
}
}
if (!didDump) {
// die
__builtin_trap();
}
adb_mutex_unlock(&threads_active_lock);
}
/* hack for osx */
void close_usb_devices()
{
adb_mutex_lock(&transport_lock);
for (atransport* t = transport_list.next; t != &transport_list; t = t->next) {
if ( !t->kicked ) {
t->kicked = 1;
t->kick(t);
}
}
adb_mutex_unlock(&transport_lock);
}
// This should only be used for transports with connection_state == kCsNoPerm.
void unregister_usb_transport(usb_handle* usb) {
adb_mutex_lock(&transport_lock);
for (atransport* t = transport_list.next; t != &transport_list;
t = t->next) {
if (t->usb == usb && t->connection_state == kCsNoPerm) {
t->next->prev = t->prev;
t->prev->next = t->next;
break;
}
}
adb_mutex_unlock(&transport_lock);
}
void usb_kick(usb_handle *handle, bool (*close_handle_func)(ADBAPIHANDLE)) {
if (NULL != handle) {
adb_mutex_lock(&usb_lock);
usb_cleanup_handle(handle, close_handle_func, "usb_kick2");
adb_mutex_unlock(&usb_lock);
} else {
SetLastError(ERROR_INVALID_HANDLE);
errno = ERROR_INVALID_HANDLE;
}
}
int register_new_device(usb_handle* handle) {
if (NULL == handle)
return 0;
adb_mutex_lock(&usb_lock);
// Check if device is already in the list
if (known_device_locked(handle->interface_name)) {
adb_mutex_unlock(&usb_lock);
return 0;
}
// Not in the list. Add this handle to the list.
handle->next = &handle_list;
handle->prev = handle_list.prev;
handle->prev->next = handle;
handle->next->prev = handle;
adb_mutex_unlock(&usb_lock);
return 1;
}
static void store_received_packet(apacket *p)
{
adb_mutex_lock(&packet_lock);
if (received == NULL) {
received = p;
last = p;
} else {
last->next = p;
last = p;
}
last->next = NULL;
adb_mutex_unlock(&packet_lock);
}
int register_socket_transport(int s, const char *serial, int port, int local) {
atransport* t = new atransport();
if (!serial) {
char buf[32];
snprintf(buf, sizeof(buf), "T-%p", t);
serial = buf;
}
D("transport: %s init'ing for socket %d, on port %d", serial, s, port);
if (init_socket_transport(t, s, port, local) < 0) {
delete t;
return -1;
}
adb_mutex_lock(&transport_lock);
for (const auto& transport : pending_list) {
if (transport->serial && strcmp(serial, transport->serial) == 0) {
adb_mutex_unlock(&transport_lock);
delete t;
return -1;
}
}
for (const auto& transport : transport_list) {
if (transport->serial && strcmp(serial, transport->serial) == 0) {
adb_mutex_unlock(&transport_lock);
delete t;
return -1;
}
}
pending_list.push_front(t);
t->serial = strdup(serial);
adb_mutex_unlock(&transport_lock);
register_transport(t);
return 0;
}
void kick_all_tcp_devices() {
adb_mutex_lock(&transport_lock);
for (auto& t : transport_list) {
// TCP/IP devices have adb_port == 0.
if (t->type == kTransportLocal && t->adb_port == 0) {
// Kicking breaks the read_transport thread of this transport out of any read, then
// the read_transport thread will notify the main thread to make this transport
// offline. Then the main thread will notify the write_transport thread to exit.
// Finally, this transport will be closed and freed in the main thread.
kick_transport_locked(t);
}
}
adb_mutex_unlock(&transport_lock);
}
