1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef __ADB_H 18 #define __ADB_H 19 20 #include <limits.h> 21 #include <sys/types.h> 22 23 #include <string> 24 25 #include <android-base/macros.h> 26 27 #include "adb_trace.h" 28 #include "fdevent.h" 29 #include "socket.h" 30 31 constexpr size_t MAX_PAYLOAD_V1 = 4 * 1024; 32 constexpr size_t MAX_PAYLOAD_V2 = 256 * 1024; 33 constexpr size_t MAX_PAYLOAD = MAX_PAYLOAD_V2; 34 35 #define A_SYNC 0x434e5953 36 #define A_CNXN 0x4e584e43 37 #define A_OPEN 0x4e45504f 38 #define A_OKAY 0x59414b4f 39 #define A_CLSE 0x45534c43 40 #define A_WRTE 0x45545257 41 #define A_AUTH 0x48545541 42 43 // ADB protocol version. 44 #define A_VERSION 0x01000000 45 46 // Used for help/version information. 47 #define ADB_VERSION_MAJOR 1 48 #define ADB_VERSION_MINOR 0 49 50 std::string adb_version(); 51 52 // Increment this when we want to force users to start a new adb server. 53 #define ADB_SERVER_VERSION 36 54 55 class atransport; 56 struct usb_handle; 57 58 struct amessage { 59 unsigned command; /* command identifier constant */ 60 unsigned arg0; /* first argument */ 61 unsigned arg1; /* second argument */ 62 unsigned data_length; /* length of payload (0 is allowed) */ 63 unsigned data_check; /* checksum of data payload */ 64 unsigned magic; /* command ^ 0xffffffff */ 65 }; 66 67 struct apacket 68 { 69 apacket *next; 70 71 unsigned len; 72 unsigned char *ptr; 73 74 amessage msg; 75 unsigned char data[MAX_PAYLOAD]; 76 }; 77 78 /* the adisconnect structure is used to record a callback that 79 ** will be called whenever a transport is disconnected (e.g. by the user) 80 ** this should be used to cleanup objects that depend on the 81 ** transport (e.g. remote sockets, listeners, etc...) 82 */ 83 struct adisconnect 84 { 85 void (*func)(void* opaque, atransport* t); 86 void* opaque; 87 }; 88 89 90 // A transport object models the connection to a remote device or emulator there 91 // is one transport per connected device/emulator. A "local transport" connects 92 // through TCP (for the emulator), while a "usb transport" through USB (for real 93 // devices). 94 // 95 // Note that kTransportHost doesn't really correspond to a real transport 96 // object, it's a special value used to indicate that a client wants to connect 97 // to a service implemented within the ADB server itself. 98 enum TransportType { 99 kTransportUsb, 100 kTransportLocal, 101 kTransportAny, 102 kTransportHost, 103 }; 104 105 #define TOKEN_SIZE 20 106 107 enum ConnectionState { 108 kCsAny = -1, 109 kCsOffline = 0, 110 kCsBootloader, 111 kCsDevice, 112 kCsHost, 113 kCsRecovery, 114 kCsNoPerm, // Insufficient permissions to communicate with the device. 115 kCsSideload, 116 kCsUnauthorized, 117 }; 118 119 /* A listener is an entity which binds to a local port 120 ** and, upon receiving a connection on that port, creates 121 ** an asocket to connect the new local connection to a 122 ** specific remote service. 123 ** 124 ** TODO: some listeners read from the new connection to 125 ** determine what exact service to connect to on the far 126 ** side. 127 */ 128 struct alistener 129 { 130 alistener *next; 131 alistener *prev; 132 133 fdevent fde; 134 int fd; 135 136 char *local_name; 137 char *connect_to; 138 atransport *transport; 139 adisconnect disconnect; 140 }; 141 142 143 void print_packet(const char *label, apacket *p); 144 145 // These use the system (v)fprintf, not the adb prefixed ones defined in sysdeps.h, so they 146 // shouldn't be tagged with ADB_FORMAT_ARCHETYPE. 147 void fatal(const char* fmt, ...) __attribute__((noreturn, format(__printf__, 1, 2))); 148 void fatal_errno(const char* fmt, ...) __attribute__((noreturn, format(__printf__, 1, 2))); 149 150 void handle_packet(apacket *p, atransport *t); 151 152 void get_my_path(char *s, size_t maxLen); 153 int launch_server(int server_port); 154 int adb_server_main(int is_daemon, int server_port, int ack_reply_fd); 155 156 /* initialize a transport object's func pointers and state */ 157 #if ADB_HOST 158 int get_available_local_transport_index(); 159 #endif 160 int init_socket_transport(atransport *t, int s, int port, int local); 161 void init_usb_transport(atransport *t, usb_handle *usb, ConnectionState state); 162 163 std::string getEmulatorSerialString(int console_port); 164 #if ADB_HOST 165 atransport* find_emulator_transport_by_adb_port(int adb_port); 166 atransport* find_emulator_transport_by_console_port(int console_port); 167 #endif 168 169 int service_to_fd(const char* name, const atransport* transport); 170 #if ADB_HOST 171 asocket *host_service_to_socket(const char* name, const char *serial); 172 #endif 173 174 #if !ADB_HOST 175 int init_jdwp(void); 176 asocket* create_jdwp_service_socket(); 177 asocket* create_jdwp_tracker_service_socket(); 178 int create_jdwp_connection_fd(int jdwp_pid); 179 #endif 180 181 int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd); 182 183 #if !ADB_HOST 184 void framebuffer_service(int fd, void *cookie); 185 void set_verity_enabled_state_service(int fd, void* cookie); 186 #endif 187 188 /* packet allocator */ 189 apacket *get_apacket(void); 190 void put_apacket(apacket *p); 191 192 // Define it if you want to dump packets. 193 #define DEBUG_PACKETS 0 194 195 #if !DEBUG_PACKETS 196 #define print_packet(tag,p) do {} while (0) 197 #endif 198 199 #if ADB_HOST_ON_TARGET 200 /* adb and adbd are coexisting on the target, so use 5038 for adb 201 * to avoid conflicting with adbd's usage of 5037 202 */ 203 # define DEFAULT_ADB_PORT 5038 204 #else 205 # define DEFAULT_ADB_PORT 5037 206 #endif 207 208 #define DEFAULT_ADB_LOCAL_TRANSPORT_PORT 5555 209 210 #define ADB_CLASS 0xff 211 #define ADB_SUBCLASS 0x42 212 #define ADB_PROTOCOL 0x1 213 214 215 void local_init(int port); 216 void local_connect(int port); 217 int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error); 218 219 // USB host/client interface. 220 void usb_init(); 221 int usb_write(usb_handle *h, const void *data, int len); 222 int usb_read(usb_handle *h, void *data, int len); 223 int usb_close(usb_handle *h); 224 void usb_kick(usb_handle *h); 225 226 // USB device detection. 227 #if ADB_HOST 228 int is_adb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol); 229 #endif 230 231 ConnectionState connection_state(atransport *t); 232 233 extern const char* adb_device_banner; 234 235 #if !ADB_HOST 236 extern int SHELL_EXIT_NOTIFY_FD; 237 #endif // !ADB_HOST 238 239 #define CHUNK_SIZE (64*1024) 240 241 #if !ADB_HOST 242 #define USB_ADB_PATH "/dev/android_adb" 243 244 #define USB_FFS_ADB_PATH "/dev/usb-ffs/adb/" 245 #define USB_FFS_ADB_EP(x) USB_FFS_ADB_PATH#x 246 247 #define USB_FFS_ADB_EP0 USB_FFS_ADB_EP(ep0) 248 #define USB_FFS_ADB_OUT USB_FFS_ADB_EP(ep1) 249 #define USB_FFS_ADB_IN USB_FFS_ADB_EP(ep2) 250 #endif 251 252 int handle_host_request(const char* service, TransportType type, const char* serial, int reply_fd, asocket *s); 253 254 void handle_online(atransport *t); 255 void handle_offline(atransport *t); 256 257 void send_connect(atransport *t); 258 259 void parse_banner(const std::string&, atransport* t); 260 261 #endif 262
