Merge "Kill of most of the remainder of minadbd."
This commit is contained in:
Dan Albert
Gerrit Code Review
@@ -67,7 +67,6 @@ LOCAL_STATIC_LIBRARIES := \
|
|||||||
libmtdutils \
|
libmtdutils \
|
||||||
libmincrypt \
|
libmincrypt \
|
||||||
libminadbd \
|
libminadbd \
|
||||||
libadbd \
|
|
||||||
libfusesideload \
|
libfusesideload \
|
||||||
libminui \
|
libminui \
|
||||||
libpng \
|
libpng \
|
||||||
|
|||||||
+1
-2
@@ -11,15 +11,14 @@ LOCAL_PATH:= $(call my-dir)
|
|||||||
include $(CLEAR_VARS)
|
include $(CLEAR_VARS)
|
||||||
|
|
||||||
LOCAL_SRC_FILES := \
|
LOCAL_SRC_FILES := \
|
||||||
adb.c \
|
|
||||||
adb_main.c \
|
adb_main.c \
|
||||||
fuse_adb_provider.c \
|
fuse_adb_provider.c \
|
||||||
sockets.c \
|
|
||||||
services.c \
|
services.c \
|
||||||
|
|
||||||
LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter
|
LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter
|
||||||
LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE
|
LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE
|
||||||
LOCAL_C_INCLUDES := bootable/recovery system/core/adb
|
LOCAL_C_INCLUDES := bootable/recovery system/core/adb
|
||||||
|
LOCAL_WHOLE_STATIC_LIBRARIES := libadbd
|
||||||
|
|
||||||
LOCAL_MODULE := libminadbd
|
LOCAL_MODULE := libminadbd
|
||||||
|
|
||||||
|
|||||||
+3
-34
@@ -1,39 +1,8 @@
|
|||||||
The contents of this directory are copied from system/core/adb, with
|
minadbd is now mostly built from libadbd. The fuse features are unique to
|
||||||
the following changes:
|
minadbd, and services.c has been modified as follows:
|
||||||
|
|
||||||
adb.c
|
- all services removed
|
||||||
- much support for host mode and non-linux OS's stripped out; this
|
|
||||||
version only runs as adbd on the device.
|
|
||||||
- always setuid/setgid's itself to the shell user
|
|
||||||
- only uses USB transport
|
|
||||||
- references to JDWP removed
|
|
||||||
- main() removed
|
|
||||||
- all ADB_HOST and win32 code removed
|
|
||||||
- removed listeners, logging code, background server (for host)
|
|
||||||
|
|
||||||
adb.h
|
|
||||||
- minor changes to match adb.c changes
|
|
||||||
|
|
||||||
sockets.c
|
|
||||||
- references to JDWP removed
|
|
||||||
- ADB_HOST code removed
|
|
||||||
|
|
||||||
services.c
|
|
||||||
- all services except echo_service (which is commented out) removed
|
|
||||||
- all host mode support removed
|
- all host mode support removed
|
||||||
- sideload_service() added; this is the only service supported. It
|
- sideload_service() added; this is the only service supported. It
|
||||||
receives a single blob of data, writes it to a fixed filename, and
|
receives a single blob of data, writes it to a fixed filename, and
|
||||||
makes the process exit.
|
makes the process exit.
|
||||||
|
|
||||||
Android.mk
|
|
||||||
- only builds in adbd mode; builds as static library instead of a
|
|
||||||
standalone executable.
|
|
||||||
|
|
||||||
sysdeps.h
|
|
||||||
- changes adb_creat() to use O_NOFOLLOW
|
|
||||||
|
|
||||||
transport.c
|
|
||||||
- removed ADB_HOST code
|
|
||||||
|
|
||||||
transport_usb.c
|
|
||||||
- removed ADB_HOST code
|
|
||||||
|
|||||||
-372
@@ -1,372 +0,0 @@
|
|||||||
/*
|
|
||||||
* 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define TRACE_TAG TRACE_ADB
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <ctype.h>
|
|
||||||
#include <stdarg.h>
|
|
||||||
#include <errno.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include <time.h>
|
|
||||||
#include <sys/time.h>
|
|
||||||
|
|
||||||
#include "sysdeps.h"
|
|
||||||
#include "adb.h"
|
|
||||||
|
|
||||||
#include <private/android_filesystem_config.h>
|
|
||||||
|
|
||||||
#if ADB_TRACE
|
|
||||||
ADB_MUTEX_DEFINE( D_lock );
|
|
||||||
#endif
|
|
||||||
|
|
||||||
int HOST = 0;
|
|
||||||
|
|
||||||
static const char *adb_device_banner = "sideload";
|
|
||||||
|
|
||||||
void fatal(const char *fmt, ...)
|
|
||||||
{
|
|
||||||
va_list ap;
|
|
||||||
va_start(ap, fmt);
|
|
||||||
fprintf(stderr, "error: ");
|
|
||||||
vfprintf(stderr, fmt, ap);
|
|
||||||
fprintf(stderr, "\n");
|
|
||||||
va_end(ap);
|
|
||||||
exit(-1);
|
|
||||||
}
|
|
||||||
|
|
||||||
void fatal_errno(const char *fmt, ...)
|
|
||||||
{
|
|
||||||
va_list ap;
|
|
||||||
va_start(ap, fmt);
|
|
||||||
fprintf(stderr, "error: %s: ", strerror(errno));
|
|
||||||
vfprintf(stderr, fmt, ap);
|
|
||||||
fprintf(stderr, "\n");
|
|
||||||
va_end(ap);
|
|
||||||
exit(-1);
|
|
||||||
}
|
|
||||||
|
|
||||||
int adb_trace_mask;
|
|
||||||
|
|
||||||
/* read a comma/space/colum/semi-column separated list of tags
|
|
||||||
* from the ADB_TRACE environment variable and build the trace
|
|
||||||
* mask from it. note that '1' and 'all' are special cases to
|
|
||||||
* enable all tracing
|
|
||||||
*/
|
|
||||||
void adb_trace_init(void)
|
|
||||||
{
|
|
||||||
const char* p = getenv("ADB_TRACE");
|
|
||||||
const char* q;
|
|
||||||
|
|
||||||
static const struct {
|
|
||||||
const char* tag;
|
|
||||||
int flag;
|
|
||||||
} tags[] = {
|
|
||||||
{ "1", 0 },
|
|
||||||
{ "all", 0 },
|
|
||||||
{ "adb", TRACE_ADB },
|
|
||||||
{ "sockets", TRACE_SOCKETS },
|
|
||||||
{ "packets", TRACE_PACKETS },
|
|
||||||
{ "rwx", TRACE_RWX },
|
|
||||||
{ "usb", TRACE_USB },
|
|
||||||
{ "sync", TRACE_SYNC },
|
|
||||||
{ "sysdeps", TRACE_SYSDEPS },
|
|
||||||
{ "transport", TRACE_TRANSPORT },
|
|
||||||
{ "jdwp", TRACE_JDWP },
|
|
||||||
{ "services", TRACE_SERVICES },
|
|
||||||
{ NULL, 0 }
|
|
||||||
};
|
|
||||||
|
|
||||||
if (p == NULL)
|
|
||||||
return;
|
|
||||||
|
|
||||||
/* use a comma/column/semi-colum/space separated list */
|
|
||||||
while (*p) {
|
|
||||||
int len, tagn;
|
|
||||||
|
|
||||||
q = strpbrk(p, " ,:;");
|
|
||||||
if (q == NULL) {
|
|
||||||
q = p + strlen(p);
|
|
||||||
}
|
|
||||||
len = q - p;
|
|
||||||
|
|
||||||
for (tagn = 0; tags[tagn].tag != NULL; tagn++)
|
|
||||||
{
|
|
||||||
int taglen = strlen(tags[tagn].tag);
|
|
||||||
|
|
||||||
if (len == taglen && !memcmp(tags[tagn].tag, p, len) )
|
|
||||||
{
|
|
||||||
int flag = tags[tagn].flag;
|
|
||||||
if (flag == 0) {
|
|
||||||
adb_trace_mask = ~0;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
adb_trace_mask |= (1 << flag);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
p = q;
|
|
||||||
if (*p)
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
apacket *get_apacket(void)
|
|
||||||
{
|
|
||||||
apacket *p = malloc(sizeof(apacket));
|
|
||||||
if(p == 0) fatal("failed to allocate an apacket");
|
|
||||||
memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);
|
|
||||||
return p;
|
|
||||||
}
|
|
||||||
|
|
||||||
void put_apacket(apacket *p)
|
|
||||||
{
|
|
||||||
free(p);
|
|
||||||
}
|
|
||||||
|
|
||||||
void handle_online(void)
|
|
||||||
{
|
|
||||||
D("adb: online\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
void handle_offline(atransport *t)
|
|
||||||
{
|
|
||||||
D("adb: offline\n");
|
|
||||||
//Close the associated usb
|
|
||||||
run_transport_disconnects(t);
|
|
||||||
}
|
|
||||||
|
|
||||||
#if TRACE_PACKETS
|
|
||||||
#define DUMPMAX 32
|
|
||||||
void print_packet(const char *label, apacket *p)
|
|
||||||
{
|
|
||||||
char *tag;
|
|
||||||
char *x;
|
|
||||||
unsigned count;
|
|
||||||
|
|
||||||
switch(p->msg.command){
|
|
||||||
case A_SYNC: tag = "SYNC"; break;
|
|
||||||
case A_CNXN: tag = "CNXN" ; break;
|
|
||||||
case A_OPEN: tag = "OPEN"; break;
|
|
||||||
case A_OKAY: tag = "OKAY"; break;
|
|
||||||
case A_CLSE: tag = "CLSE"; break;
|
|
||||||
case A_WRTE: tag = "WRTE"; break;
|
|
||||||
default: tag = "????"; break;
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(stderr, "%s: %s %08x %08x %04x \"",
|
|
||||||
label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
|
|
||||||
count = p->msg.data_length;
|
|
||||||
x = (char*) p->data;
|
|
||||||
if(count > DUMPMAX) {
|
|
||||||
count = DUMPMAX;
|
|
||||||
tag = "\n";
|
|
||||||
} else {
|
|
||||||
tag = "\"\n";
|
|
||||||
}
|
|
||||||
while(count-- > 0){
|
|
||||||
if((*x >= ' ') && (*x < 127)) {
|
|
||||||
fputc(*x, stderr);
|
|
||||||
} else {
|
|
||||||
fputc('.', stderr);
|
|
||||||
}
|
|
||||||
x++;
|
|
||||||
}
|
|
||||||
fprintf(stderr, tag);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
static void send_ready(unsigned local, unsigned remote, atransport *t)
|
|
||||||
{
|
|
||||||
D("Calling send_ready \n");
|
|
||||||
apacket *p = get_apacket();
|
|
||||||
p->msg.command = A_OKAY;
|
|
||||||
p->msg.arg0 = local;
|
|
||||||
p->msg.arg1 = remote;
|
|
||||||
send_packet(p, t);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void send_close(unsigned local, unsigned remote, atransport *t)
|
|
||||||
{
|
|
||||||
D("Calling send_close \n");
|
|
||||||
apacket *p = get_apacket();
|
|
||||||
p->msg.command = A_CLSE;
|
|
||||||
p->msg.arg0 = local;
|
|
||||||
p->msg.arg1 = remote;
|
|
||||||
send_packet(p, t);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void send_connect(atransport *t)
|
|
||||||
{
|
|
||||||
D("Calling send_connect \n");
|
|
||||||
apacket *cp = get_apacket();
|
|
||||||
cp->msg.command = A_CNXN;
|
|
||||||
cp->msg.arg0 = A_VERSION;
|
|
||||||
cp->msg.arg1 = MAX_PAYLOAD;
|
|
||||||
snprintf((char*) cp->data, sizeof cp->data, "%s::",
|
|
||||||
HOST ? "host" : adb_device_banner);
|
|
||||||
cp->msg.data_length = strlen((char*) cp->data) + 1;
|
|
||||||
send_packet(cp, t);
|
|
||||||
}
|
|
||||||
|
|
||||||
void parse_banner(char *banner, atransport *t)
|
|
||||||
{
|
|
||||||
char *type, *product, *end;
|
|
||||||
|
|
||||||
D("parse_banner: %s\n", banner);
|
|
||||||
type = banner;
|
|
||||||
product = strchr(type, ':');
|
|
||||||
if(product) {
|
|
||||||
*product++ = 0;
|
|
||||||
} else {
|
|
||||||
product = "";
|
|
||||||
}
|
|
||||||
|
|
||||||
/* remove trailing ':' */
|
|
||||||
end = strchr(product, ':');
|
|
||||||
if(end) *end = 0;
|
|
||||||
|
|
||||||
/* save product name in device structure */
|
|
||||||
if (t->product == NULL) {
|
|
||||||
t->product = strdup(product);
|
|
||||||
} else if (strcmp(product, t->product) != 0) {
|
|
||||||
free(t->product);
|
|
||||||
t->product = strdup(product);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!strcmp(type, "bootloader")){
|
|
||||||
D("setting connection_state to CS_BOOTLOADER\n");
|
|
||||||
t->connection_state = CS_BOOTLOADER;
|
|
||||||
update_transports();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!strcmp(type, "device")) {
|
|
||||||
D("setting connection_state to CS_DEVICE\n");
|
|
||||||
t->connection_state = CS_DEVICE;
|
|
||||||
update_transports();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!strcmp(type, "recovery")) {
|
|
||||||
D("setting connection_state to CS_RECOVERY\n");
|
|
||||||
t->connection_state = CS_RECOVERY;
|
|
||||||
update_transports();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!strcmp(type, "sideload")) {
|
|
||||||
D("setting connection_state to CS_SIDELOAD\n");
|
|
||||||
t->connection_state = CS_SIDELOAD;
|
|
||||||
update_transports();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
t->connection_state = CS_HOST;
|
|
||||||
}
|
|
||||||
|
|
||||||
void handle_packet(apacket *p, atransport *t)
|
|
||||||
{
|
|
||||||
asocket *s;
|
|
||||||
|
|
||||||
D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0],
|
|
||||||
((char*) (&(p->msg.command)))[1],
|
|
||||||
((char*) (&(p->msg.command)))[2],
|
|
||||||
((char*) (&(p->msg.command)))[3]);
|
|
||||||
print_packet("recv", p);
|
|
||||||
|
|
||||||
switch(p->msg.command){
|
|
||||||
case A_SYNC:
|
|
||||||
if(p->msg.arg0){
|
|
||||||
send_packet(p, t);
|
|
||||||
if(HOST) send_connect(t);
|
|
||||||
} else {
|
|
||||||
t->connection_state = CS_OFFLINE;
|
|
||||||
handle_offline(t);
|
|
||||||
send_packet(p, t);
|
|
||||||
}
|
|
||||||
return;
|
|
||||||
|
|
||||||
case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */
|
|
||||||
/* XXX verify version, etc */
|
|
||||||
if(t->connection_state != CS_OFFLINE) {
|
|
||||||
t->connection_state = CS_OFFLINE;
|
|
||||||
handle_offline(t);
|
|
||||||
}
|
|
||||||
parse_banner((char*) p->data, t);
|
|
||||||
handle_online();
|
|
||||||
if(!HOST) send_connect(t);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case A_OPEN: /* OPEN(local-id, 0, "destination") */
|
|
||||||
if(t->connection_state != CS_OFFLINE) {
|
|
||||||
char *name = (char*) p->data;
|
|
||||||
name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;
|
|
||||||
s = create_local_service_socket(name);
|
|
||||||
if(s == 0) {
|
|
||||||
send_close(0, p->msg.arg0, t);
|
|
||||||
} else {
|
|
||||||
s->peer = create_remote_socket(p->msg.arg0, t);
|
|
||||||
s->peer->peer = s;
|
|
||||||
send_ready(s->id, s->peer->id, t);
|
|
||||||
s->ready(s);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case A_OKAY: /* READY(local-id, remote-id, "") */
|
|
||||||
if(t->connection_state != CS_OFFLINE) {
|
|
||||||
if((s = find_local_socket(p->msg.arg1))) {
|
|
||||||
if(s->peer == 0) {
|
|
||||||
s->peer = create_remote_socket(p->msg.arg0, t);
|
|
||||||
s->peer->peer = s;
|
|
||||||
}
|
|
||||||
s->ready(s);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case A_CLSE: /* CLOSE(local-id, remote-id, "") */
|
|
||||||
if(t->connection_state != CS_OFFLINE) {
|
|
||||||
if((s = find_local_socket(p->msg.arg1))) {
|
|
||||||
s->close(s);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case A_WRTE:
|
|
||||||
if(t->connection_state != CS_OFFLINE) {
|
|
||||||
if((s = find_local_socket(p->msg.arg1))) {
|
|
||||||
unsigned rid = p->msg.arg0;
|
|
||||||
p->len = p->msg.data_length;
|
|
||||||
|
|
||||||
if(s->enqueue(s, p) == 0) {
|
|
||||||
D("Enqueue the socket\n");
|
|
||||||
send_ready(s->id, rid, t);
|
|
||||||
}
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
default:
|
|
||||||
printf("handle_packet: what is %08x?!\n", p->msg.command);
|
|
||||||
}
|
|
||||||
|
|
||||||
put_apacket(p);
|
|
||||||
}
|
|
||||||
-433
@@ -1,433 +0,0 @@
|
|||||||
/*
|
|
||||||
* 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef __ADB_H
|
|
||||||
#define __ADB_H
|
|
||||||
|
|
||||||
#include <limits.h>
|
|
||||||
|
|
||||||
#include "transport.h" /* readx(), writex() */
|
|
||||||
#include "fdevent.h"
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define MAX_PAYLOAD 4096
|
|
||||||
|
|
||||||
#define A_SYNC 0x434e5953
|
|
||||||
#define A_CNXN 0x4e584e43
|
|
||||||
#define A_OPEN 0x4e45504f
|
|
||||||
#define A_OKAY 0x59414b4f
|
|
||||||
#define A_CLSE 0x45534c43
|
|
||||||
#define A_WRTE 0x45545257
|
|
||||||
|
|
||||||
#define A_VERSION 0x01000000 // ADB protocol version
|
|
||||||
|
|
||||||
#define ADB_VERSION_MAJOR 1 // Used for help/version information
|
|
||||||
#define ADB_VERSION_MINOR 0 // Used for help/version information
|
|
||||||
|
|
||||||
#define ADB_SERVER_VERSION 29 // Increment this when we want to force users to start a new adb server
|
|
||||||
|
|
||||||
typedef struct amessage amessage;
|
|
||||||
typedef struct apacket apacket;
|
|
||||||
typedef struct asocket asocket;
|
|
||||||
typedef struct aservice aservice;
|
|
||||||
typedef struct atransport atransport;
|
|
||||||
typedef struct adisconnect adisconnect;
|
|
||||||
typedef struct usb_handle usb_handle;
|
|
||||||
|
|
||||||
struct amessage {
|
|
||||||
unsigned command; /* command identifier constant */
|
|
||||||
unsigned arg0; /* first argument */
|
|
||||||
unsigned arg1; /* second argument */
|
|
||||||
unsigned data_length; /* length of payload (0 is allowed) */
|
|
||||||
unsigned data_check; /* checksum of data payload */
|
|
||||||
unsigned magic; /* command ^ 0xffffffff */
|
|
||||||
};
|
|
||||||
|
|
||||||
struct apacket
|
|
||||||
{
|
|
||||||
apacket *next;
|
|
||||||
|
|
||||||
unsigned len;
|
|
||||||
unsigned char *ptr;
|
|
||||||
|
|
||||||
amessage msg;
|
|
||||||
unsigned char data[MAX_PAYLOAD];
|
|
||||||
};
|
|
||||||
|
|
||||||
/* An asocket represents one half of a connection between a local and
|
|
||||||
** remote entity. A local asocket is bound to a file descriptor. A
|
|
||||||
** remote asocket is bound to the protocol engine.
|
|
||||||
*/
|
|
||||||
struct asocket {
|
|
||||||
/* chain pointers for the local/remote list of
|
|
||||||
** asockets that this asocket lives in
|
|
||||||
*/
|
|
||||||
asocket *next;
|
|
||||||
asocket *prev;
|
|
||||||
|
|
||||||
/* the unique identifier for this asocket
|
|
||||||
*/
|
|
||||||
unsigned id;
|
|
||||||
|
|
||||||
/* flag: set when the socket's peer has closed
|
|
||||||
** but packets are still queued for delivery
|
|
||||||
*/
|
|
||||||
int closing;
|
|
||||||
|
|
||||||
/* the asocket we are connected to
|
|
||||||
*/
|
|
||||||
|
|
||||||
asocket *peer;
|
|
||||||
|
|
||||||
/* For local asockets, the fde is used to bind
|
|
||||||
** us to our fd event system. For remote asockets
|
|
||||||
** these fields are not used.
|
|
||||||
*/
|
|
||||||
fdevent fde;
|
|
||||||
int fd;
|
|
||||||
|
|
||||||
/* queue of apackets waiting to be written
|
|
||||||
*/
|
|
||||||
apacket *pkt_first;
|
|
||||||
apacket *pkt_last;
|
|
||||||
|
|
||||||
/* enqueue is called by our peer when it has data
|
|
||||||
** for us. It should return 0 if we can accept more
|
|
||||||
** data or 1 if not. If we return 1, we must call
|
|
||||||
** peer->ready() when we once again are ready to
|
|
||||||
** receive data.
|
|
||||||
*/
|
|
||||||
int (*enqueue)(asocket *s, apacket *pkt);
|
|
||||||
|
|
||||||
/* ready is called by the peer when it is ready for
|
|
||||||
** us to send data via enqueue again
|
|
||||||
*/
|
|
||||||
void (*ready)(asocket *s);
|
|
||||||
|
|
||||||
/* close is called by the peer when it has gone away.
|
|
||||||
** we are not allowed to make any further calls on the
|
|
||||||
** peer once our close method is called.
|
|
||||||
*/
|
|
||||||
void (*close)(asocket *s);
|
|
||||||
|
|
||||||
/* socket-type-specific extradata */
|
|
||||||
void *extra;
|
|
||||||
|
|
||||||
/* A socket is bound to atransport */
|
|
||||||
atransport *transport;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/* the adisconnect structure is used to record a callback that
|
|
||||||
** will be called whenever a transport is disconnected (e.g. by the user)
|
|
||||||
** this should be used to cleanup objects that depend on the
|
|
||||||
** transport (e.g. remote sockets, etc...)
|
|
||||||
*/
|
|
||||||
struct adisconnect
|
|
||||||
{
|
|
||||||
void (*func)(void* opaque, atransport* t);
|
|
||||||
void* opaque;
|
|
||||||
adisconnect* next;
|
|
||||||
adisconnect* prev;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/* a transport object models the connection to a remote device or emulator
|
|
||||||
** there is one transport per connected device/emulator. a "local transport"
|
|
||||||
** connects through TCP (for the emulator), while a "usb transport" through
|
|
||||||
** USB (for real devices)
|
|
||||||
**
|
|
||||||
** note that kTransportHost doesn't really correspond to a real transport
|
|
||||||
** object, it's a special value used to indicate that a client wants to
|
|
||||||
** connect to a service implemented within the ADB server itself.
|
|
||||||
*/
|
|
||||||
typedef enum transport_type {
|
|
||||||
kTransportUsb,
|
|
||||||
kTransportLocal,
|
|
||||||
kTransportAny,
|
|
||||||
kTransportHost,
|
|
||||||
} transport_type;
|
|
||||||
|
|
||||||
struct atransport
|
|
||||||
{
|
|
||||||
atransport *next;
|
|
||||||
atransport *prev;
|
|
||||||
|
|
||||||
int (*read_from_remote)(apacket *p, atransport *t);
|
|
||||||
int (*write_to_remote)(apacket *p, atransport *t);
|
|
||||||
void (*close)(atransport *t);
|
|
||||||
void (*kick)(atransport *t);
|
|
||||||
|
|
||||||
int fd;
|
|
||||||
int transport_socket;
|
|
||||||
fdevent transport_fde;
|
|
||||||
int ref_count;
|
|
||||||
unsigned sync_token;
|
|
||||||
int connection_state;
|
|
||||||
transport_type type;
|
|
||||||
|
|
||||||
/* usb handle or socket fd as needed */
|
|
||||||
usb_handle *usb;
|
|
||||||
int sfd;
|
|
||||||
|
|
||||||
/* used to identify transports for clients */
|
|
||||||
char *serial;
|
|
||||||
char *product;
|
|
||||||
int adb_port; // Use for emulators (local transport)
|
|
||||||
|
|
||||||
/* a list of adisconnect callbacks called when the transport is kicked */
|
|
||||||
int kicked;
|
|
||||||
adisconnect disconnects;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
void print_packet(const char *label, apacket *p);
|
|
||||||
|
|
||||||
asocket *find_local_socket(unsigned id);
|
|
||||||
void install_local_socket(asocket *s);
|
|
||||||
void remove_socket(asocket *s);
|
|
||||||
void close_all_sockets(atransport *t);
|
|
||||||
|
|
||||||
#define LOCAL_CLIENT_PREFIX "emulator-"
|
|
||||||
|
|
||||||
asocket *create_local_socket(int fd);
|
|
||||||
asocket *create_local_service_socket(const char *destination);
|
|
||||||
|
|
||||||
asocket *create_remote_socket(unsigned id, atransport *t);
|
|
||||||
void connect_to_remote(asocket *s, const char *destination);
|
|
||||||
void connect_to_smartsocket(asocket *s);
|
|
||||||
|
|
||||||
void fatal(const char *fmt, ...);
|
|
||||||
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, size_t maxLen);
|
|
||||||
int launch_server(int server_port);
|
|
||||||
int adb_main();
|
|
||||||
|
|
||||||
|
|
||||||
/* transports are ref-counted
|
|
||||||
** get_device_transport does an acquire on your behalf before returning
|
|
||||||
*/
|
|
||||||
void init_transport_registration(void);
|
|
||||||
int list_transports(char *buf, size_t bufsize);
|
|
||||||
void update_transports(void);
|
|
||||||
|
|
||||||
asocket* create_device_tracker(void);
|
|
||||||
|
|
||||||
/* Obtain a transport from the available transports.
|
|
||||||
** If state is != CS_ANY, only transports in that state are considered.
|
|
||||||
** If serial is non-NULL then only the device with that serial will be chosen.
|
|
||||||
** If no suitable transport is found, error is set.
|
|
||||||
*/
|
|
||||||
atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char **error_out);
|
|
||||||
void add_transport_disconnect( atransport* t, adisconnect* dis );
|
|
||||||
void remove_transport_disconnect( atransport* t, adisconnect* dis );
|
|
||||||
void run_transport_disconnects( atransport* t );
|
|
||||||
void kick_transport( atransport* t );
|
|
||||||
|
|
||||||
/* initialize a transport object's func pointers and state */
|
|
||||||
#if ADB_HOST
|
|
||||||
int get_available_local_transport_index();
|
|
||||||
#endif
|
|
||||||
void init_usb_transport(atransport *t, usb_handle *usb, int state);
|
|
||||||
|
|
||||||
/* for MacOS X cleanup */
|
|
||||||
void close_usb_devices();
|
|
||||||
|
|
||||||
/* these should only be used for the "adb disconnect" command */
|
|
||||||
void unregister_transport(atransport *t);
|
|
||||||
void unregister_all_tcp_transports();
|
|
||||||
|
|
||||||
void register_usb_transport(usb_handle *h, const char *serial,
|
|
||||||
const char* dev_path, unsigned writeable);
|
|
||||||
|
|
||||||
/* this should only be used for transports with connection_state == CS_NOPERM */
|
|
||||||
void unregister_usb_transport(usb_handle *usb);
|
|
||||||
|
|
||||||
atransport *find_transport(const char *serial);
|
|
||||||
#if ADB_HOST
|
|
||||||
atransport* find_emulator_transport_by_adb_port(int adb_port);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
int service_to_fd(const char *name);
|
|
||||||
#if ADB_HOST
|
|
||||||
asocket *host_service_to_socket(const char* name, const char *serial);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !ADB_HOST
|
|
||||||
typedef enum {
|
|
||||||
BACKUP,
|
|
||||||
RESTORE
|
|
||||||
} BackupOperation;
|
|
||||||
int backup_service(BackupOperation operation, char* args);
|
|
||||||
void framebuffer_service(int fd, void *cookie);
|
|
||||||
void log_service(int fd, void *cookie);
|
|
||||||
void remount_service(int fd, void *cookie);
|
|
||||||
char * get_log_file_path(const char * log_name);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* packet allocator */
|
|
||||||
apacket *get_apacket(void);
|
|
||||||
void put_apacket(apacket *p);
|
|
||||||
|
|
||||||
int check_header(apacket *p);
|
|
||||||
int check_data(apacket *p);
|
|
||||||
|
|
||||||
/* define ADB_TRACE to 1 to enable tracing support, or 0 to disable it */
|
|
||||||
|
|
||||||
#define ADB_TRACE 1
|
|
||||||
|
|
||||||
/* IMPORTANT: if you change the following list, don't
|
|
||||||
* forget to update the corresponding 'tags' table in
|
|
||||||
* the adb_trace_init() function implemented in adb.c
|
|
||||||
*/
|
|
||||||
typedef enum {
|
|
||||||
TRACE_ADB = 0, /* 0x001 */
|
|
||||||
TRACE_SOCKETS,
|
|
||||||
TRACE_PACKETS,
|
|
||||||
TRACE_TRANSPORT,
|
|
||||||
TRACE_RWX, /* 0x010 */
|
|
||||||
TRACE_USB,
|
|
||||||
TRACE_SYNC,
|
|
||||||
TRACE_SYSDEPS,
|
|
||||||
TRACE_JDWP, /* 0x100 */
|
|
||||||
TRACE_SERVICES,
|
|
||||||
} AdbTrace;
|
|
||||||
|
|
||||||
#if ADB_TRACE
|
|
||||||
|
|
||||||
extern int adb_trace_mask;
|
|
||||||
extern unsigned char adb_trace_output_count;
|
|
||||||
void adb_trace_init(void);
|
|
||||||
|
|
||||||
# define ADB_TRACING ((adb_trace_mask & (1 << TRACE_TAG)) != 0)
|
|
||||||
|
|
||||||
/* you must define TRACE_TAG before using this macro */
|
|
||||||
# define D(...) \
|
|
||||||
do { \
|
|
||||||
if (ADB_TRACING) { \
|
|
||||||
int save_errno = errno; \
|
|
||||||
adb_mutex_lock(&D_lock); \
|
|
||||||
fprintf(stderr, "%s::%s():", \
|
|
||||||
__FILE__, __FUNCTION__); \
|
|
||||||
errno = save_errno; \
|
|
||||||
fprintf(stderr, __VA_ARGS__ ); \
|
|
||||||
fflush(stderr); \
|
|
||||||
adb_mutex_unlock(&D_lock); \
|
|
||||||
errno = save_errno; \
|
|
||||||
} \
|
|
||||||
} while (0)
|
|
||||||
# define DR(...) \
|
|
||||||
do { \
|
|
||||||
if (ADB_TRACING) { \
|
|
||||||
int save_errno = errno; \
|
|
||||||
adb_mutex_lock(&D_lock); \
|
|
||||||
errno = save_errno; \
|
|
||||||
fprintf(stderr, __VA_ARGS__ ); \
|
|
||||||
fflush(stderr); \
|
|
||||||
adb_mutex_unlock(&D_lock); \
|
|
||||||
errno = save_errno; \
|
|
||||||
} \
|
|
||||||
} while (0)
|
|
||||||
#else
|
|
||||||
# define D(...) ((void)0)
|
|
||||||
# define DR(...) ((void)0)
|
|
||||||
# define ADB_TRACING 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if !TRACE_PACKETS
|
|
||||||
#define print_packet(tag,p) do {} while (0)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if ADB_HOST_ON_TARGET
|
|
||||||
/* adb and adbd are coexisting on the target, so use 5038 for adb
|
|
||||||
* to avoid conflicting with adbd's usage of 5037
|
|
||||||
*/
|
|
||||||
# define DEFAULT_ADB_PORT 5038
|
|
||||||
#else
|
|
||||||
# define DEFAULT_ADB_PORT 5037
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define DEFAULT_ADB_LOCAL_TRANSPORT_PORT 5555
|
|
||||||
|
|
||||||
#define ADB_CLASS 0xff
|
|
||||||
#define ADB_SUBCLASS 0x42
|
|
||||||
#define ADB_PROTOCOL 0x1
|
|
||||||
|
|
||||||
|
|
||||||
void local_init(int port);
|
|
||||||
int local_connect(int port);
|
|
||||||
int local_connect_arbitrary_ports(int console_port, int adb_port);
|
|
||||||
|
|
||||||
/* usb host/client interface */
|
|
||||||
void usb_init();
|
|
||||||
void usb_cleanup();
|
|
||||||
int usb_write(usb_handle *h, const void *data, int len);
|
|
||||||
int usb_read(usb_handle *h, void *data, int len);
|
|
||||||
int usb_close(usb_handle *h);
|
|
||||||
void usb_kick(usb_handle *h);
|
|
||||||
|
|
||||||
/* used for USB device detection */
|
|
||||||
#if ADB_HOST
|
|
||||||
int is_adb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
unsigned host_to_le32(unsigned n);
|
|
||||||
int adb_commandline(int argc, char **argv);
|
|
||||||
|
|
||||||
int connection_state(atransport *t);
|
|
||||||
|
|
||||||
#define CS_ANY -1
|
|
||||||
#define CS_OFFLINE 0
|
|
||||||
#define CS_BOOTLOADER 1
|
|
||||||
#define CS_DEVICE 2
|
|
||||||
#define CS_HOST 3
|
|
||||||
#define CS_RECOVERY 4
|
|
||||||
#define CS_NOPERM 5 /* Insufficient permissions to communicate with the device */
|
|
||||||
#define CS_SIDELOAD 6
|
|
||||||
#define CS_UNAUTHORIZED 7
|
|
||||||
|
|
||||||
extern int HOST;
|
|
||||||
extern int SHELL_EXIT_NOTIFY_FD;
|
|
||||||
|
|
||||||
#define CHUNK_SIZE (64*1024)
|
|
||||||
|
|
||||||
#if !ADB_HOST
|
|
||||||
#define USB_ADB_PATH "/dev/android_adb"
|
|
||||||
|
|
||||||
#define USB_FFS_ADB_PATH "/dev/usb-ffs/adb/"
|
|
||||||
#define USB_FFS_ADB_EP(x) USB_FFS_ADB_PATH#x
|
|
||||||
|
|
||||||
#define USB_FFS_ADB_EP0 USB_FFS_ADB_EP(ep0)
|
|
||||||
#define USB_FFS_ADB_OUT USB_FFS_ADB_EP(ep1)
|
|
||||||
#define USB_FFS_ADB_IN USB_FFS_ADB_EP(ep2)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
int sendfailmsg(int fd, const char *reason);
|
|
||||||
int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
+3
-1
@@ -24,10 +24,12 @@
|
|||||||
#include "adb.h"
|
#include "adb.h"
|
||||||
#include "sysdeps.h"
|
#include "sysdeps.h"
|
||||||
|
|
||||||
int adb_main()
|
int adb_main(int is_daemon, int server_port)
|
||||||
{
|
{
|
||||||
atexit(usb_cleanup);
|
atexit(usb_cleanup);
|
||||||
|
|
||||||
|
adb_device_banner = "sideload";
|
||||||
|
|
||||||
// No SIGCHLD. Let the service subproc handle its children.
|
// No SIGCHLD. Let the service subproc handle its children.
|
||||||
signal(SIGPIPE, SIG_IGN);
|
signal(SIGPIPE, SIG_IGN);
|
||||||
|
|
||||||
|
|||||||
@@ -1,731 +0,0 @@
|
|||||||
/*
|
|
||||||
* 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 <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <unistd.h>
|
|
||||||
#include <errno.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include <ctype.h>
|
|
||||||
|
|
||||||
#include "sysdeps.h"
|
|
||||||
|
|
||||||
#define TRACE_TAG TRACE_SOCKETS
|
|
||||||
#include "adb.h"
|
|
||||||
|
|
||||||
ADB_MUTEX_DEFINE( socket_list_lock );
|
|
||||||
|
|
||||||
static void local_socket_close_locked(asocket *s);
|
|
||||||
|
|
||||||
int sendfailmsg(int fd, const char *reason)
|
|
||||||
{
|
|
||||||
char buf[9];
|
|
||||||
int len;
|
|
||||||
len = strlen(reason);
|
|
||||||
if(len > 0xffff) len = 0xffff;
|
|
||||||
snprintf(buf, sizeof buf, "FAIL%04x", len);
|
|
||||||
if(writex(fd, buf, 8)) return -1;
|
|
||||||
return writex(fd, reason, len);
|
|
||||||
}
|
|
||||||
|
|
||||||
//extern int online;
|
|
||||||
|
|
||||||
static unsigned local_socket_next_id = 1;
|
|
||||||
|
|
||||||
static asocket local_socket_list = {
|
|
||||||
.next = &local_socket_list,
|
|
||||||
.prev = &local_socket_list,
|
|
||||||
};
|
|
||||||
|
|
||||||
/* the the list of currently closing local sockets.
|
|
||||||
** these have no peer anymore, but still packets to
|
|
||||||
** write to their fd.
|
|
||||||
*/
|
|
||||||
static asocket local_socket_closing_list = {
|
|
||||||
.next = &local_socket_closing_list,
|
|
||||||
.prev = &local_socket_closing_list,
|
|
||||||
};
|
|
||||||
|
|
||||||
asocket *find_local_socket(unsigned id)
|
|
||||||
{
|
|
||||||
asocket *s;
|
|
||||||
asocket *result = NULL;
|
|
||||||
|
|
||||||
adb_mutex_lock(&socket_list_lock);
|
|
||||||
for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
|
|
||||||
if (s->id == id) {
|
|
||||||
result = s;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
adb_mutex_unlock(&socket_list_lock);
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
insert_local_socket(asocket* s, asocket* list)
|
|
||||||
{
|
|
||||||
s->next = list;
|
|
||||||
s->prev = s->next->prev;
|
|
||||||
s->prev->next = s;
|
|
||||||
s->next->prev = s;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
|
|
||||||
void remove_socket(asocket *s)
|
|
||||||
{
|
|
||||||
// socket_list_lock should already be held
|
|
||||||
if (s->prev && s->next)
|
|
||||||
{
|
|
||||||
s->prev->next = s->next;
|
|
||||||
s->next->prev = s->prev;
|
|
||||||
s->next = 0;
|
|
||||||
s->prev = 0;
|
|
||||||
s->id = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void close_all_sockets(atransport *t)
|
|
||||||
{
|
|
||||||
asocket *s;
|
|
||||||
|
|
||||||
/* this is a little gross, but since s->close() *will* modify
|
|
||||||
** the list out from under you, your options are limited.
|
|
||||||
*/
|
|
||||||
adb_mutex_lock(&socket_list_lock);
|
|
||||||
restart:
|
|
||||||
for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
|
|
||||||
if(s->transport == t || (s->peer && s->peer->transport == t)) {
|
|
||||||
local_socket_close_locked(s);
|
|
||||||
goto restart;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
adb_mutex_unlock(&socket_list_lock);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int local_socket_enqueue(asocket *s, apacket *p)
|
|
||||||
{
|
|
||||||
D("LS(%d): enqueue %d\n", s->id, p->len);
|
|
||||||
|
|
||||||
p->ptr = p->data;
|
|
||||||
|
|
||||||
/* if there is already data queue'd, we will receive
|
|
||||||
** events when it's time to write. just add this to
|
|
||||||
** the tail
|
|
||||||
*/
|
|
||||||
if(s->pkt_first) {
|
|
||||||
goto enqueue;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* write as much as we can, until we
|
|
||||||
** would block or there is an error/eof
|
|
||||||
*/
|
|
||||||
while(p->len > 0) {
|
|
||||||
int r = adb_write(s->fd, p->ptr, p->len);
|
|
||||||
if(r > 0) {
|
|
||||||
p->len -= r;
|
|
||||||
p->ptr += r;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if((r == 0) || (errno != EAGAIN)) {
|
|
||||||
D( "LS(%d): not ready, errno=%d: %s\n", s->id, errno, strerror(errno) );
|
|
||||||
s->close(s);
|
|
||||||
return 1; /* not ready (error) */
|
|
||||||
} else {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if(p->len == 0) {
|
|
||||||
put_apacket(p);
|
|
||||||
return 0; /* ready for more data */
|
|
||||||
}
|
|
||||||
|
|
||||||
enqueue:
|
|
||||||
p->next = 0;
|
|
||||||
if(s->pkt_first) {
|
|
||||||
s->pkt_last->next = p;
|
|
||||||
} else {
|
|
||||||
s->pkt_first = p;
|
|
||||||
}
|
|
||||||
s->pkt_last = p;
|
|
||||||
|
|
||||||
/* make sure we are notified when we can drain the queue */
|
|
||||||
fdevent_add(&s->fde, FDE_WRITE);
|
|
||||||
|
|
||||||
return 1; /* not ready (backlog) */
|
|
||||||
}
|
|
||||||
|
|
||||||
static void local_socket_ready(asocket *s)
|
|
||||||
{
|
|
||||||
/* far side is ready for data, pay attention to
|
|
||||||
readable events */
|
|
||||||
fdevent_add(&s->fde, FDE_READ);
|
|
||||||
// D("LS(%d): ready()\n", s->id);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void local_socket_close(asocket *s)
|
|
||||||
{
|
|
||||||
adb_mutex_lock(&socket_list_lock);
|
|
||||||
local_socket_close_locked(s);
|
|
||||||
adb_mutex_unlock(&socket_list_lock);
|
|
||||||
}
|
|
||||||
|
|
||||||
// be sure to hold the socket list lock when calling this
|
|
||||||
static void local_socket_destroy(asocket *s)
|
|
||||||
{
|
|
||||||
apacket *p, *n;
|
|
||||||
D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
|
|
||||||
|
|
||||||
/* IMPORTANT: the remove closes the fd
|
|
||||||
** that belongs to this socket
|
|
||||||
*/
|
|
||||||
fdevent_remove(&s->fde);
|
|
||||||
|
|
||||||
/* dispose of any unwritten data */
|
|
||||||
for(p = s->pkt_first; p; p = n) {
|
|
||||||
D("LS(%d): discarding %d bytes\n", s->id, p->len);
|
|
||||||
n = p->next;
|
|
||||||
put_apacket(p);
|
|
||||||
}
|
|
||||||
remove_socket(s);
|
|
||||||
free(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void local_socket_close_locked(asocket *s)
|
|
||||||
{
|
|
||||||
D("entered. LS(%d) fd=%d\n", s->id, s->fd);
|
|
||||||
if(s->peer) {
|
|
||||||
D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
|
|
||||||
s->id, s->peer->id, s->peer->fd);
|
|
||||||
s->peer->peer = 0;
|
|
||||||
// tweak to avoid deadlock
|
|
||||||
if (s->peer->close == local_socket_close) {
|
|
||||||
local_socket_close_locked(s->peer);
|
|
||||||
} else {
|
|
||||||
s->peer->close(s->peer);
|
|
||||||
}
|
|
||||||
s->peer = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* If we are already closing, or if there are no
|
|
||||||
** pending packets, destroy immediately
|
|
||||||
*/
|
|
||||||
if (s->closing || s->pkt_first == NULL) {
|
|
||||||
int id = s->id;
|
|
||||||
local_socket_destroy(s);
|
|
||||||
D("LS(%d): closed\n", id);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* otherwise, put on the closing list
|
|
||||||
*/
|
|
||||||
D("LS(%d): closing\n", s->id);
|
|
||||||
s->closing = 1;
|
|
||||||
fdevent_del(&s->fde, FDE_READ);
|
|
||||||
remove_socket(s);
|
|
||||||
D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
|
|
||||||
insert_local_socket(s, &local_socket_closing_list);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void local_socket_event_func(int fd, unsigned ev, void *_s)
|
|
||||||
{
|
|
||||||
asocket *s = _s;
|
|
||||||
|
|
||||||
D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
|
|
||||||
|
|
||||||
/* put the FDE_WRITE processing before the FDE_READ
|
|
||||||
** in order to simplify the code.
|
|
||||||
*/
|
|
||||||
if(ev & FDE_WRITE){
|
|
||||||
apacket *p;
|
|
||||||
|
|
||||||
while((p = s->pkt_first) != 0) {
|
|
||||||
while(p->len > 0) {
|
|
||||||
int r = adb_write(fd, p->ptr, p->len);
|
|
||||||
if(r > 0) {
|
|
||||||
p->ptr += r;
|
|
||||||
p->len -= r;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if(r < 0) {
|
|
||||||
/* returning here is ok because FDE_READ will
|
|
||||||
** be processed in the next iteration loop
|
|
||||||
*/
|
|
||||||
if(errno == EAGAIN) return;
|
|
||||||
if(errno == EINTR) continue;
|
|
||||||
}
|
|
||||||
D(" closing after write because r=%d and errno is %d\n", r, errno);
|
|
||||||
s->close(s);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(p->len == 0) {
|
|
||||||
s->pkt_first = p->next;
|
|
||||||
if(s->pkt_first == 0) s->pkt_last = 0;
|
|
||||||
put_apacket(p);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* if we sent the last packet of a closing socket,
|
|
||||||
** we can now destroy it.
|
|
||||||
*/
|
|
||||||
if (s->closing) {
|
|
||||||
D(" closing because 'closing' is set after write\n");
|
|
||||||
s->close(s);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* no more packets queued, so we can ignore
|
|
||||||
** writable events again and tell our peer
|
|
||||||
** to resume writing
|
|
||||||
*/
|
|
||||||
fdevent_del(&s->fde, FDE_WRITE);
|
|
||||||
s->peer->ready(s->peer);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
if(ev & FDE_READ){
|
|
||||||
apacket *p = get_apacket();
|
|
||||||
unsigned char *x = p->data;
|
|
||||||
size_t avail = MAX_PAYLOAD;
|
|
||||||
int r;
|
|
||||||
int is_eof = 0;
|
|
||||||
|
|
||||||
while(avail > 0) {
|
|
||||||
r = adb_read(fd, x, avail);
|
|
||||||
D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu\n",
|
|
||||||
s->id, s->fd, r, r<0?errno:0, avail);
|
|
||||||
if(r > 0) {
|
|
||||||
avail -= r;
|
|
||||||
x += r;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if(r < 0) {
|
|
||||||
if(errno == EAGAIN) break;
|
|
||||||
if(errno == EINTR) continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* r = 0 or unhandled error */
|
|
||||||
is_eof = 1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
|
|
||||||
s->id, s->fd, r, is_eof, s->fde.force_eof);
|
|
||||||
if((avail == MAX_PAYLOAD) || (s->peer == 0)) {
|
|
||||||
put_apacket(p);
|
|
||||||
} else {
|
|
||||||
p->len = MAX_PAYLOAD - avail;
|
|
||||||
|
|
||||||
r = s->peer->enqueue(s->peer, p);
|
|
||||||
D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r);
|
|
||||||
|
|
||||||
if(r < 0) {
|
|
||||||
/* error return means they closed us as a side-effect
|
|
||||||
** and we must return immediately.
|
|
||||||
**
|
|
||||||
** note that if we still have buffered packets, the
|
|
||||||
** socket will be placed on the closing socket list.
|
|
||||||
** this handler function will be called again
|
|
||||||
** to process FDE_WRITE events.
|
|
||||||
*/
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(r > 0) {
|
|
||||||
/* if the remote cannot accept further events,
|
|
||||||
** we disable notification of READs. They'll
|
|
||||||
** be enabled again when we get a call to ready()
|
|
||||||
*/
|
|
||||||
fdevent_del(&s->fde, FDE_READ);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/* Don't allow a forced eof if data is still there */
|
|
||||||
if((s->fde.force_eof && !r) || is_eof) {
|
|
||||||
D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof);
|
|
||||||
s->close(s);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if(ev & FDE_ERROR){
|
|
||||||
/* this should be caught be the next read or write
|
|
||||||
** catching it here means we may skip the last few
|
|
||||||
** bytes of readable data.
|
|
||||||
*/
|
|
||||||
// s->close(s);
|
|
||||||
D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
asocket *create_local_socket(int fd)
|
|
||||||
{
|
|
||||||
asocket *s = calloc(1, sizeof(asocket));
|
|
||||||
if (s == NULL) fatal("cannot allocate socket");
|
|
||||||
s->fd = fd;
|
|
||||||
s->enqueue = local_socket_enqueue;
|
|
||||||
s->ready = local_socket_ready;
|
|
||||||
s->close = local_socket_close;
|
|
||||||
install_local_socket(s);
|
|
||||||
|
|
||||||
fdevent_install(&s->fde, fd, local_socket_event_func, s);
|
|
||||||
/* fdevent_add(&s->fde, FDE_ERROR); */
|
|
||||||
//fprintf(stderr, "Created local socket in create_local_socket \n");
|
|
||||||
D("LS(%d): created (fd=%d)\n", s->id, s->fd);
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
|
|
||||||
asocket *create_local_service_socket(const char *name)
|
|
||||||
{
|
|
||||||
asocket *s;
|
|
||||||
int fd;
|
|
||||||
|
|
||||||
fd = service_to_fd(name);
|
|
||||||
if(fd < 0) return 0;
|
|
||||||
|
|
||||||
s = create_local_socket(fd);
|
|
||||||
D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* a Remote socket is used to send/receive data to/from a given transport object
|
|
||||||
** it needs to be closed when the transport is forcibly destroyed by the user
|
|
||||||
*/
|
|
||||||
typedef struct aremotesocket {
|
|
||||||
asocket socket;
|
|
||||||
adisconnect disconnect;
|
|
||||||
} aremotesocket;
|
|
||||||
|
|
||||||
static int remote_socket_enqueue(asocket *s, apacket *p)
|
|
||||||
{
|
|
||||||
D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
|
|
||||||
s->id, s->fd, s->peer->fd);
|
|
||||||
p->msg.command = A_WRTE;
|
|
||||||
p->msg.arg0 = s->peer->id;
|
|
||||||
p->msg.arg1 = s->id;
|
|
||||||
p->msg.data_length = p->len;
|
|
||||||
send_packet(p, s->transport);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void remote_socket_ready(asocket *s)
|
|
||||||
{
|
|
||||||
D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
|
|
||||||
s->id, s->fd, s->peer->fd);
|
|
||||||
apacket *p = get_apacket();
|
|
||||||
p->msg.command = A_OKAY;
|
|
||||||
p->msg.arg0 = s->peer->id;
|
|
||||||
p->msg.arg1 = s->id;
|
|
||||||
send_packet(p, s->transport);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void remote_socket_close(asocket *s)
|
|
||||||
{
|
|
||||||
D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
|
|
||||||
s->id, s->fd, s->peer?s->peer->fd:-1);
|
|
||||||
apacket *p = get_apacket();
|
|
||||||
p->msg.command = A_CLSE;
|
|
||||||
if(s->peer) {
|
|
||||||
p->msg.arg0 = s->peer->id;
|
|
||||||
s->peer->peer = 0;
|
|
||||||
D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
|
|
||||||
s->id, s->peer->id, s->peer->fd);
|
|
||||||
s->peer->close(s->peer);
|
|
||||||
}
|
|
||||||
p->msg.arg1 = s->id;
|
|
||||||
send_packet(p, s->transport);
|
|
||||||
D("RS(%d): closed\n", s->id);
|
|
||||||
remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
|
|
||||||
free(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void remote_socket_disconnect(void* _s, atransport* t)
|
|
||||||
{
|
|
||||||
asocket* s = _s;
|
|
||||||
asocket* peer = s->peer;
|
|
||||||
|
|
||||||
D("remote_socket_disconnect RS(%d)\n", s->id);
|
|
||||||
if (peer) {
|
|
||||||
peer->peer = NULL;
|
|
||||||
peer->close(peer);
|
|
||||||
}
|
|
||||||
remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
|
|
||||||
free(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
asocket *create_remote_socket(unsigned id, atransport *t)
|
|
||||||
{
|
|
||||||
asocket *s = calloc(1, sizeof(aremotesocket));
|
|
||||||
adisconnect* dis = &((aremotesocket*)s)->disconnect;
|
|
||||||
|
|
||||||
if (s == NULL) fatal("cannot allocate socket");
|
|
||||||
s->id = id;
|
|
||||||
s->enqueue = remote_socket_enqueue;
|
|
||||||
s->ready = remote_socket_ready;
|
|
||||||
s->close = remote_socket_close;
|
|
||||||
s->transport = t;
|
|
||||||
|
|
||||||
dis->func = remote_socket_disconnect;
|
|
||||||
dis->opaque = s;
|
|
||||||
add_transport_disconnect( t, dis );
|
|
||||||
D("RS(%d): created\n", s->id);
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
|
|
||||||
void connect_to_remote(asocket *s, const char *destination)
|
|
||||||
{
|
|
||||||
D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
|
|
||||||
apacket *p = get_apacket();
|
|
||||||
int len = strlen(destination) + 1;
|
|
||||||
|
|
||||||
if(len > (MAX_PAYLOAD-1)) {
|
|
||||||
fatal("destination oversized");
|
|
||||||
}
|
|
||||||
|
|
||||||
D("LS(%d): connect('%s')\n", s->id, destination);
|
|
||||||
p->msg.command = A_OPEN;
|
|
||||||
p->msg.arg0 = s->id;
|
|
||||||
p->msg.data_length = len;
|
|
||||||
strcpy((char*) p->data, destination);
|
|
||||||
send_packet(p, s->transport);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* this is used by magic sockets to rig local sockets to
|
|
||||||
send the go-ahead message when they connect */
|
|
||||||
static void local_socket_ready_notify(asocket *s)
|
|
||||||
{
|
|
||||||
s->ready = local_socket_ready;
|
|
||||||
s->close = local_socket_close;
|
|
||||||
adb_write(s->fd, "OKAY", 4);
|
|
||||||
s->ready(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* this is used by magic sockets to rig local sockets to
|
|
||||||
send the failure message if they are closed before
|
|
||||||
connected (to avoid closing them without a status message) */
|
|
||||||
static void local_socket_close_notify(asocket *s)
|
|
||||||
{
|
|
||||||
s->ready = local_socket_ready;
|
|
||||||
s->close = local_socket_close;
|
|
||||||
sendfailmsg(s->fd, "closed");
|
|
||||||
s->close(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned unhex(unsigned char *s, int len)
|
|
||||||
{
|
|
||||||
unsigned n = 0, c;
|
|
||||||
|
|
||||||
while(len-- > 0) {
|
|
||||||
switch((c = *s++)) {
|
|
||||||
case '0': case '1': case '2':
|
|
||||||
case '3': case '4': case '5':
|
|
||||||
case '6': case '7': case '8':
|
|
||||||
case '9':
|
|
||||||
c -= '0';
|
|
||||||
break;
|
|
||||||
case 'a': case 'b': case 'c':
|
|
||||||
case 'd': case 'e': case 'f':
|
|
||||||
c = c - 'a' + 10;
|
|
||||||
break;
|
|
||||||
case 'A': case 'B': case 'C':
|
|
||||||
case 'D': case 'E': case 'F':
|
|
||||||
c = c - 'A' + 10;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
return 0xffffffff;
|
|
||||||
}
|
|
||||||
|
|
||||||
n = (n << 4) | c;
|
|
||||||
}
|
|
||||||
|
|
||||||
return n;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* skip_host_serial return the position in a string
|
|
||||||
skipping over the 'serial' parameter in the ADB protocol,
|
|
||||||
where parameter string may be a host:port string containing
|
|
||||||
the protocol delimiter (colon). */
|
|
||||||
char *skip_host_serial(char *service) {
|
|
||||||
char *first_colon, *serial_end;
|
|
||||||
|
|
||||||
first_colon = strchr(service, ':');
|
|
||||||
if (!first_colon) {
|
|
||||||
/* No colon in service string. */
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
serial_end = first_colon;
|
|
||||||
if (isdigit(serial_end[1])) {
|
|
||||||
serial_end++;
|
|
||||||
while ((*serial_end) && isdigit(*serial_end)) {
|
|
||||||
serial_end++;
|
|
||||||
}
|
|
||||||
if ((*serial_end) != ':') {
|
|
||||||
// Something other than numbers was found, reset the end.
|
|
||||||
serial_end = first_colon;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return serial_end;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int smart_socket_enqueue(asocket *s, apacket *p)
|
|
||||||
{
|
|
||||||
unsigned len;
|
|
||||||
|
|
||||||
D("SS(%d): enqueue %d\n", s->id, p->len);
|
|
||||||
|
|
||||||
if(s->pkt_first == 0) {
|
|
||||||
s->pkt_first = p;
|
|
||||||
s->pkt_last = p;
|
|
||||||
} else {
|
|
||||||
if((s->pkt_first->len + p->len) > MAX_PAYLOAD) {
|
|
||||||
D("SS(%d): overflow\n", s->id);
|
|
||||||
put_apacket(p);
|
|
||||||
goto fail;
|
|
||||||
}
|
|
||||||
|
|
||||||
memcpy(s->pkt_first->data + s->pkt_first->len,
|
|
||||||
p->data, p->len);
|
|
||||||
s->pkt_first->len += p->len;
|
|
||||||
put_apacket(p);
|
|
||||||
|
|
||||||
p = s->pkt_first;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* don't bother if we can't decode the length */
|
|
||||||
if(p->len < 4) return 0;
|
|
||||||
|
|
||||||
len = unhex(p->data, 4);
|
|
||||||
if((len < 1) || (len > 1024)) {
|
|
||||||
D("SS(%d): bad size (%d)\n", s->id, len);
|
|
||||||
goto fail;
|
|
||||||
}
|
|
||||||
|
|
||||||
D("SS(%d): len is %d\n", s->id, len );
|
|
||||||
/* can't do anything until we have the full header */
|
|
||||||
if((len + 4) > p->len) {
|
|
||||||
D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
p->data[len + 4] = 0;
|
|
||||||
|
|
||||||
D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4));
|
|
||||||
|
|
||||||
if (s->transport == NULL) {
|
|
||||||
char* error_string = "unknown failure";
|
|
||||||
s->transport = acquire_one_transport (CS_ANY,
|
|
||||||
kTransportAny, NULL, &error_string);
|
|
||||||
|
|
||||||
if (s->transport == NULL) {
|
|
||||||
sendfailmsg(s->peer->fd, error_string);
|
|
||||||
goto fail;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) {
|
|
||||||
/* if there's no remote we fail the connection
|
|
||||||
** right here and terminate it
|
|
||||||
*/
|
|
||||||
sendfailmsg(s->peer->fd, "device offline (x)");
|
|
||||||
goto fail;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* instrument our peer to pass the success or fail
|
|
||||||
** message back once it connects or closes, then
|
|
||||||
** detach from it, request the connection, and
|
|
||||||
** tear down
|
|
||||||
*/
|
|
||||||
s->peer->ready = local_socket_ready_notify;
|
|
||||||
s->peer->close = local_socket_close_notify;
|
|
||||||
s->peer->peer = 0;
|
|
||||||
/* give him our transport and upref it */
|
|
||||||
s->peer->transport = s->transport;
|
|
||||||
|
|
||||||
connect_to_remote(s->peer, (char*) (p->data + 4));
|
|
||||||
s->peer = 0;
|
|
||||||
s->close(s);
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
fail:
|
|
||||||
/* we're going to close our peer as a side-effect, so
|
|
||||||
** return -1 to signal that state to the local socket
|
|
||||||
** who is enqueueing against us
|
|
||||||
*/
|
|
||||||
s->close(s);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void smart_socket_ready(asocket *s)
|
|
||||||
{
|
|
||||||
D("SS(%d): ready\n", s->id);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void smart_socket_close(asocket *s)
|
|
||||||
{
|
|
||||||
D("SS(%d): closed\n", s->id);
|
|
||||||
if(s->pkt_first){
|
|
||||||
put_apacket(s->pkt_first);
|
|
||||||
}
|
|
||||||
if(s->peer) {
|
|
||||||
s->peer->peer = 0;
|
|
||||||
s->peer->close(s->peer);
|
|
||||||
s->peer = 0;
|
|
||||||
}
|
|
||||||
free(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
asocket *create_smart_socket(void (*action_cb)(asocket *s, const char *act))
|
|
||||||
{
|
|
||||||
D("Creating smart socket \n");
|
|
||||||
asocket *s = calloc(1, sizeof(asocket));
|
|
||||||
if (s == NULL) fatal("cannot allocate socket");
|
|
||||||
s->enqueue = smart_socket_enqueue;
|
|
||||||
s->ready = smart_socket_ready;
|
|
||||||
s->close = smart_socket_close;
|
|
||||||
s->extra = action_cb;
|
|
||||||
|
|
||||||
D("SS(%d): created %p\n", s->id, action_cb);
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
|
|
||||||
void smart_socket_action(asocket *s, const char *act)
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void connect_to_smartsocket(asocket *s)
|
|
||||||
{
|
|
||||||
D("Connecting to smart socket \n");
|
|
||||||
asocket *ss = create_smart_socket(smart_socket_action);
|
|
||||||
s->peer = ss;
|
|
||||||
ss->peer = s;
|
|
||||||
s->ready(s);
|
|
||||||
}
|
|
||||||
+2
-2
@@ -43,7 +43,7 @@
|
|||||||
#include "device.h"
|
#include "device.h"
|
||||||
#include "adb_install.h"
|
#include "adb_install.h"
|
||||||
extern "C" {
|
extern "C" {
|
||||||
#include "minadbd/adb.h"
|
#include "adb.h"
|
||||||
#include "fuse_sideload.h"
|
#include "fuse_sideload.h"
|
||||||
#include "fuse_sdcard_provider.h"
|
#include "fuse_sdcard_provider.h"
|
||||||
}
|
}
|
||||||
@@ -841,7 +841,7 @@ main(int argc, char **argv) {
|
|||||||
// only way recovery should be run with this argument is when it
|
// only way recovery should be run with this argument is when it
|
||||||
// starts a copy of itself from the apply_from_adb() function.
|
// starts a copy of itself from the apply_from_adb() function.
|
||||||
if (argc == 2 && strcmp(argv[1], "--adbd") == 0) {
|
if (argc == 2 && strcmp(argv[1], "--adbd") == 0) {
|
||||||
adb_main();
|
adb_main(0, DEFAULT_ADB_PORT);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
Reference in New Issue
Block a user