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 #if ADB_HOST 164 atransport* find_emulator_transport_by_adb_port(int adb_port); 165 #endif 166 167 int service_to_fd(const char* name, const atransport* transport); 168 #if ADB_HOST 169 asocket *host_service_to_socket(const char* name, const char *serial); 170 #endif 171 172 #if !ADB_HOST 173 int init_jdwp(void); 174 asocket* create_jdwp_service_socket(); 175 asocket* create_jdwp_tracker_service_socket(); 176 int create_jdwp_connection_fd(int jdwp_pid); 177 #endif 178 179 int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd); 180 181 #if !ADB_HOST 182 void framebuffer_service(int fd, void *cookie); 183 void set_verity_enabled_state_service(int fd, void* cookie); 184 #endif 185 186 /* packet allocator */ 187 apacket *get_apacket(void); 188 void put_apacket(apacket *p); 189 190 // Define it if you want to dump packets. 191 #define DEBUG_PACKETS 0 192 193 #if !DEBUG_PACKETS 194 #define print_packet(tag,p) do {} while (0) 195 #endif 196 197 #if ADB_HOST_ON_TARGET 198 /* adb and adbd are coexisting on the target, so use 5038 for adb 199 * to avoid conflicting with adbd's usage of 5037 200 */ 201 # define DEFAULT_ADB_PORT 5038 202 #else 203 # define DEFAULT_ADB_PORT 5037 204 #endif 205 206 #define DEFAULT_ADB_LOCAL_TRANSPORT_PORT 5555 207 208 #define ADB_CLASS 0xff 209 #define ADB_SUBCLASS 0x42 210 #define ADB_PROTOCOL 0x1 211 212 213 void local_init(int port); 214 void local_connect(int port); 215 int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error); 216 217 // USB host/client interface. 218 void usb_init(); 219 int usb_write(usb_handle *h, const void *data, int len); 220 int usb_read(usb_handle *h, void *data, int len); 221 int usb_close(usb_handle *h); 222 void usb_kick(usb_handle *h); 223 224 // USB device detection. 225 #if ADB_HOST 226 int is_adb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol); 227 #endif 228 229 ConnectionState connection_state(atransport *t); 230 231 extern const char* adb_device_banner; 232 233 #if !ADB_HOST 234 extern int SHELL_EXIT_NOTIFY_FD; 235 #endif // !ADB_HOST 236 237 #define CHUNK_SIZE (64*1024) 238 239 #if !ADB_HOST 240 #define USB_ADB_PATH "/dev/android_adb" 241 242 #define USB_FFS_ADB_PATH "/dev/usb-ffs/adb/" 243 #define USB_FFS_ADB_EP(x) USB_FFS_ADB_PATH#x 244 245 #define USB_FFS_ADB_EP0 USB_FFS_ADB_EP(ep0) 246 #define USB_FFS_ADB_OUT USB_FFS_ADB_EP(ep1) 247 #define USB_FFS_ADB_IN USB_FFS_ADB_EP(ep2) 248 #endif 249 250 int handle_host_request(const char* service, TransportType type, const char* serial, int reply_fd, asocket *s); 251 252 void handle_online(atransport *t); 253 void handle_offline(atransport *t); 254 255 void send_connect(atransport *t); 256 257 void parse_banner(const std::string&, atransport* t); 258 259 #endif 260