414 lines
9.9 KiB
C
414 lines
9.9 KiB
C
/*
|
|
* 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>
|
|
#include <linux/capability.h>
|
|
#include <linux/prctl.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);
|
|
}
|
|
|
|
static void adb_cleanup(void)
|
|
{
|
|
usb_cleanup();
|
|
}
|
|
|
|
int adb_main()
|
|
{
|
|
atexit(adb_cleanup);
|
|
#if defined(HAVE_FORKEXEC)
|
|
// No SIGCHLD. Let the service subproc handle its children.
|
|
signal(SIGPIPE, SIG_IGN);
|
|
#endif
|
|
|
|
init_transport_registration();
|
|
|
|
// The minimal version of adbd only uses USB.
|
|
if (access("/dev/android_adb", F_OK) == 0) {
|
|
// listen on USB
|
|
usb_init();
|
|
}
|
|
|
|
if (setgid(AID_SHELL) != 0) {
|
|
fprintf(stderr, "failed to setgid to shell\n");
|
|
exit(1);
|
|
}
|
|
if (setuid(AID_SHELL) != 0) {
|
|
fprintf(stderr, "failed to setuid to shell\n");
|
|
exit(1);
|
|
}
|
|
fprintf(stderr, "userid is %d\n", getuid());
|
|
|
|
D("Event loop starting\n");
|
|
|
|
fdevent_loop();
|
|
|
|
usb_cleanup();
|
|
|
|
return 0;
|
|
}
|