minadbd/adb.c - android_bootable_recovery - Gitiles

 /*
  * 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);
 }
	/*
	* 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);
	}