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 <stdint.h> 22 #include <sys/types.h> 23 24 #include <string> 25 26 #include <android-base/macros.h> 27 28 #include "adb_trace.h" 29 #include "fdevent.h" 30 #include "socket.h" 31 #include "usb.h" 32 33 constexpr size_t MAX_PAYLOAD_V1 = 4 * 1024; 34 constexpr size_t MAX_PAYLOAD_V2 = 256 * 1024; 35 constexpr size_t MAX_PAYLOAD = MAX_PAYLOAD_V2; 36 37 constexpr size_t LINUX_MAX_SOCKET_SIZE = 4194304; 38 39 #define A_SYNC 0x434e5953 40 #define A_CNXN 0x4e584e43 41 #define A_OPEN 0x4e45504f 42 #define A_OKAY 0x59414b4f 43 #define A_CLSE 0x45534c43 44 #define A_WRTE 0x45545257 45 #define A_AUTH 0x48545541 46 47 // ADB protocol version. 48 #define A_VERSION 0x01000000 49 50 // Used for help/version information. 51 #define ADB_VERSION_MAJOR 1 52 #define ADB_VERSION_MINOR 0 53 54 std::string adb_version(); 55 56 // Increment this when we want to force users to start a new adb server. 57 #define ADB_SERVER_VERSION 39 58 59 class atransport; 60 61 struct amessage { 62 uint32_t command; /* command identifier constant */ 63 uint32_t arg0; /* first argument */ 64 uint32_t arg1; /* second argument */ 65 uint32_t data_length; /* length of payload (0 is allowed) */ 66 uint32_t data_check; /* checksum of data payload */ 67 uint32_t magic; /* command ^ 0xffffffff */ 68 }; 69 70 struct apacket 71 { 72 apacket *next; 73 74 size_t len; 75 char* ptr; 76 77 amessage msg; 78 char data[MAX_PAYLOAD]; 79 }; 80 81 uint32_t calculate_apacket_checksum(const apacket* packet); 82 83 /* the adisconnect structure is used to record a callback that 84 ** will be called whenever a transport is disconnected (e.g. by the user) 85 ** this should be used to cleanup objects that depend on the 86 ** transport (e.g. remote sockets, listeners, etc...) 87 */ 88 struct adisconnect 89 { 90 void (*func)(void* opaque, atransport* t); 91 void* opaque; 92 }; 93 94 95 // A transport object models the connection to a remote device or emulator there 96 // is one transport per connected device/emulator. A "local transport" connects 97 // through TCP (for the emulator), while a "usb transport" through USB (for real 98 // devices). 99 // 100 // Note that kTransportHost doesn't really correspond to a real transport 101 // object, it's a special value used to indicate that a client wants to connect 102 // to a service implemented within the ADB server itself. 103 enum TransportType { 104 kTransportUsb, 105 kTransportLocal, 106 kTransportAny, 107 kTransportHost, 108 }; 109 110 #define TOKEN_SIZE 20 111 112 enum ConnectionState { 113 kCsAny = -1, 114 kCsOffline = 0, 115 kCsBootloader, 116 kCsDevice, 117 kCsHost, 118 kCsRecovery, 119 kCsNoPerm, // Insufficient permissions to communicate with the device. 120 kCsSideload, 121 kCsUnauthorized, 122 }; 123 124 125 void print_packet(const char *label, apacket *p); 126 127 // These use the system (v)fprintf, not the adb prefixed ones defined in sysdeps.h, so they 128 // shouldn't be tagged with ADB_FORMAT_ARCHETYPE. 129 void fatal(const char* fmt, ...) __attribute__((noreturn, format(__printf__, 1, 2))); 130 void fatal_errno(const char* fmt, ...) __attribute__((noreturn, format(__printf__, 1, 2))); 131 132 void handle_packet(apacket *p, atransport *t); 133 134 int launch_server(const std::string& socket_spec); 135 int adb_server_main(int is_daemon, const std::string& socket_spec, int ack_reply_fd); 136 137 /* initialize a transport object's func pointers and state */ 138 #if ADB_HOST 139 int get_available_local_transport_index(); 140 #endif 141 int init_socket_transport(atransport *t, int s, int port, int local); 142 void init_usb_transport(atransport *t, usb_handle *usb, ConnectionState state); 143 144 std::string getEmulatorSerialString(int console_port); 145 #if ADB_HOST 146 atransport* find_emulator_transport_by_adb_port(int adb_port); 147 atransport* find_emulator_transport_by_console_port(int console_port); 148 #endif 149 150 int service_to_fd(const char* name, const atransport* transport); 151 #if ADB_HOST 152 asocket *host_service_to_socket(const char* name, const char *serial); 153 #endif 154 155 #if !ADB_HOST 156 int init_jdwp(void); 157 asocket* create_jdwp_service_socket(); 158 asocket* create_jdwp_tracker_service_socket(); 159 int create_jdwp_connection_fd(int jdwp_pid); 160 #endif 161 162 int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd); 163 164 #if !ADB_HOST 165 void framebuffer_service(int fd, void *cookie); 166 void set_verity_enabled_state_service(int fd, void* cookie); 167 #endif 168 169 /* packet allocator */ 170 apacket *get_apacket(void); 171 void put_apacket(apacket *p); 172 173 // Define it if you want to dump packets. 174 #define DEBUG_PACKETS 0 175 176 #if !DEBUG_PACKETS 177 #define print_packet(tag,p) do {} while (0) 178 #endif 179 180 #if ADB_HOST_ON_TARGET 181 /* adb and adbd are coexisting on the target, so use 5038 for adb 182 * to avoid conflicting with adbd's usage of 5037 183 */ 184 # define DEFAULT_ADB_PORT 5038 185 #else 186 # define DEFAULT_ADB_PORT 5037 187 #endif 188 189 #define DEFAULT_ADB_LOCAL_TRANSPORT_PORT 5555 190 191 #define ADB_CLASS 0xff 192 #define ADB_SUBCLASS 0x42 193 #define ADB_PROTOCOL 0x1 194 195 196 void local_init(int port); 197 bool local_connect(int port); 198 int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error); 199 200 ConnectionState connection_state(atransport *t); 201 202 extern const char* adb_device_banner; 203 204 #if !ADB_HOST 205 extern int SHELL_EXIT_NOTIFY_FD; 206 #endif // !ADB_HOST 207 208 #define CHUNK_SIZE (64*1024) 209 210 #if !ADB_HOST 211 #define USB_FFS_ADB_PATH "/dev/usb-ffs/adb/" 212 #define USB_FFS_ADB_EP(x) USB_FFS_ADB_PATH#x 213 214 #define USB_FFS_ADB_EP0 USB_FFS_ADB_EP(ep0) 215 #define USB_FFS_ADB_OUT USB_FFS_ADB_EP(ep1) 216 #define USB_FFS_ADB_IN USB_FFS_ADB_EP(ep2) 217 #endif 218 219 int handle_host_request(const char* service, TransportType type, const char* serial, int reply_fd, asocket *s); 220 221 void handle_online(atransport *t); 222 void handle_offline(atransport *t); 223 224 void send_connect(atransport *t); 225 226 void parse_banner(const std::string&, atransport* t); 227 228 #endif 229
