Loading Android.mk +0 −1 Original line number Diff line number Diff line Loading @@ -67,7 +67,6 @@ LOCAL_STATIC_LIBRARIES := \ libmtdutils \ libmincrypt \ libminadbd \ libadbd \ libfusesideload \ libminui \ libpng \ Loading minadbd/Android.mk +1 −2 Original line number Diff line number Diff line Loading @@ -11,15 +11,14 @@ LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES := \ adb.c \ adb_main.c \ fuse_adb_provider.c \ sockets.c \ services.c \ LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE LOCAL_C_INCLUDES := bootable/recovery system/core/adb LOCAL_WHOLE_STATIC_LIBRARIES := libadbd LOCAL_MODULE := libminadbd Loading minadbd/README.txt +3 −34 Original line number Diff line number Diff line The contents of this directory are copied from system/core/adb, with the following changes: minadbd is now mostly built from libadbd. The fuse features are unique to minadbd, and services.c has been modified as follows: adb.c - 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 services removed - all host mode support removed - sideload_service() added; this is the only service supported. It receives a single blob of data, writes it to a fixed filename, and 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 minadbd/adb.cdeleted 100644 → 0 +0 −372 Original line number Diff line number Diff line /* * 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); } minadbd/adb.hdeleted 100644 → 0 +0 −433 Original line number Diff line number Diff line /* * 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 Loading
Android.mk +0 −1 Original line number Diff line number Diff line Loading @@ -67,7 +67,6 @@ LOCAL_STATIC_LIBRARIES := \ libmtdutils \ libmincrypt \ libminadbd \ libadbd \ libfusesideload \ libminui \ libpng \ Loading
minadbd/Android.mk +1 −2 Original line number Diff line number Diff line Loading @@ -11,15 +11,14 @@ LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES := \ adb.c \ adb_main.c \ fuse_adb_provider.c \ sockets.c \ services.c \ LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE LOCAL_C_INCLUDES := bootable/recovery system/core/adb LOCAL_WHOLE_STATIC_LIBRARIES := libadbd LOCAL_MODULE := libminadbd Loading
minadbd/README.txt +3 −34 Original line number Diff line number Diff line The contents of this directory are copied from system/core/adb, with the following changes: minadbd is now mostly built from libadbd. The fuse features are unique to minadbd, and services.c has been modified as follows: adb.c - 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 services removed - all host mode support removed - sideload_service() added; this is the only service supported. It receives a single blob of data, writes it to a fixed filename, and 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
minadbd/adb.cdeleted 100644 → 0 +0 −372 Original line number Diff line number Diff line /* * 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); }
minadbd/adb.hdeleted 100644 → 0 +0 −433 Original line number Diff line number Diff line /* * 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
