blob: d41c8bd472dff97ab4d0870333e2ff353ae7ab7c [file] [log] [blame]
JP Abgrall408fa572011-03-16 15:57:42 -07001/*
2 * Copyright (C) 2011 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 __TRANSPORT_H
18#define __TRANSPORT_H
19
Dan Alberte9fca142015-02-18 18:03:26 -080020#include <sys/types.h>
21
Elliott Hughes0aeb5052016-06-29 17:42:01 -070022#include <deque>
Yabin Cuib3298242015-08-28 15:09:44 -070023#include <list>
Elliott Hughes7be29c82015-04-16 22:54:44 -070024#include <string>
Dan Albert1792c232015-05-18 13:06:53 -070025#include <unordered_set>
Dan Albert76649012015-02-24 15:51:19 -080026
Elliott Hughes7be29c82015-04-16 22:54:44 -070027#include "adb.h"
Dan Albert630b9af2014-11-24 23:34:35 -080028
Elliott Hughes0aeb5052016-06-29 17:42:01 -070029#include <openssl/rsa.h>
30
Dan Albert1792c232015-05-18 13:06:53 -070031typedef std::unordered_set<std::string> FeatureSet;
32
33const FeatureSet& supported_features();
34
David Pursell4e2fd362015-09-22 10:43:08 -070035// Encodes and decodes FeatureSet objects into human-readable strings.
36std::string FeatureSetToString(const FeatureSet& features);
37FeatureSet StringToFeatureSet(const std::string& features_string);
38
David Pursell70ef7b42015-09-30 13:35:42 -070039// Returns true if both local features and |feature_set| support |feature|.
40bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature);
41
David Pursell4e2fd362015-09-22 10:43:08 -070042// Do not use any of [:;=,] in feature strings, they have special meaning
43// in the connection banner.
Todd Kennedy6fa848a2015-11-03 16:53:08 -080044extern const char* const kFeatureShell2;
45// The 'cmd' command is available
46extern const char* const kFeatureCmd;
David Pursell0955c662015-08-31 10:42:13 -070047
Dan Albert1792c232015-05-18 13:06:53 -070048class atransport {
49public:
50 // TODO(danalbert): We expose waaaaaaay too much stuff because this was
51 // historically just a struct, but making the whole thing a more idiomatic
52 // class in one go is a very large change. Given how bad our testing is,
53 // it's better to do this piece by piece.
54
55 atransport() {
Dan Albert1792c232015-05-18 13:06:53 -070056 transport_fde = {};
57 protocol_version = A_VERSION;
58 max_payload = MAX_PAYLOAD;
59 }
60
61 virtual ~atransport() {}
62
63 int (*read_from_remote)(apacket* p, atransport* t) = nullptr;
64 int (*write_to_remote)(apacket* p, atransport* t) = nullptr;
65 void (*close)(atransport* t) = nullptr;
Yabin Cui7f274902016-04-18 11:22:34 -070066 void SetKickFunction(void (*kick_func)(atransport*)) {
67 kick_func_ = kick_func;
68 }
69 bool IsKicked() {
70 return kicked_;
71 }
72 void Kick();
Dan Albert1792c232015-05-18 13:06:53 -070073
74 int fd = -1;
75 int transport_socket = -1;
76 fdevent transport_fde;
Yabin Cuif4b99282015-08-27 12:03:11 -070077 size_t ref_count = 0;
Dan Albert1792c232015-05-18 13:06:53 -070078 uint32_t sync_token = 0;
79 ConnectionState connection_state = kCsOffline;
80 bool online = false;
81 TransportType type = kTransportAny;
82
83 // USB handle or socket fd as needed.
84 usb_handle* usb = nullptr;
85 int sfd = -1;
86
87 // Used to identify transports for clients.
88 char* serial = nullptr;
89 char* product = nullptr;
90 char* model = nullptr;
91 char* device = nullptr;
92 char* devpath = nullptr;
Yabin Cuib74c6492016-04-29 16:53:52 -070093 void SetLocalPortForEmulator(int port) {
94 CHECK_EQ(local_port_for_emulator_, -1);
95 local_port_for_emulator_ = port;
96 }
97
98 bool GetLocalPortForEmulator(int* port) const {
99 if (type == kTransportLocal && local_port_for_emulator_ != -1) {
100 *port = local_port_for_emulator_;
101 return true;
102 }
103 return false;
104 }
105
106 bool IsTcpDevice() const {
107 return type == kTransportLocal && local_port_for_emulator_ == -1;
108 }
Dan Albert1792c232015-05-18 13:06:53 -0700109
Elliott Hughes0aeb5052016-06-29 17:42:01 -0700110 RSA* NextKey();
111
Dan Albert1792c232015-05-18 13:06:53 -0700112 unsigned char token[TOKEN_SIZE] = {};
Dan Albert1792c232015-05-18 13:06:53 -0700113 size_t failed_auth_attempts = 0;
114
David Purselld2acbd12015-12-02 15:14:31 -0800115 const std::string connection_state_name() const;
Dan Albert1792c232015-05-18 13:06:53 -0700116
117 void update_version(int version, size_t payload);
118 int get_protocol_version() const;
119 size_t get_max_payload() const;
120
David Pursell4e2fd362015-09-22 10:43:08 -0700121 const FeatureSet& features() const {
Dan Albert1792c232015-05-18 13:06:53 -0700122 return features_;
123 }
124
125 bool has_feature(const std::string& feature) const;
David Pursell4e2fd362015-09-22 10:43:08 -0700126
127 // Loads the transport's feature set from the given string.
128 void SetFeatures(const std::string& features_string);
Dan Albert1792c232015-05-18 13:06:53 -0700129
Yabin Cuib3298242015-08-28 15:09:44 -0700130 void AddDisconnect(adisconnect* disconnect);
131 void RemoveDisconnect(adisconnect* disconnect);
132 void RunDisconnects();
133
David Pursell3f902aa2016-03-01 08:58:26 -0800134 // Returns true if |target| matches this transport. A matching |target| can be any of:
135 // * <serial>
136 // * <devpath>
137 // * product:<product>
138 // * model:<model>
139 // * device:<device>
140 //
141 // If this is a local transport, serial will also match [tcp:|udp:]<hostname>[:port] targets.
142 // For example, serial "100.100.100.100:5555" would match any of:
143 // * 100.100.100.100
144 // * tcp:100.100.100.100
145 // * udp:100.100.100.100:5555
146 // This is to make it easier to use the same network target for both fastboot and adb.
147 bool MatchesTarget(const std::string& target) const;
148
Dan Albert1792c232015-05-18 13:06:53 -0700149private:
Yabin Cuib74c6492016-04-29 16:53:52 -0700150 int local_port_for_emulator_ = -1;
Yabin Cui7f274902016-04-18 11:22:34 -0700151 bool kicked_ = false;
152 void (*kick_func_)(atransport*) = nullptr;
153
Dan Albert1792c232015-05-18 13:06:53 -0700154 // A set of features transmitted in the banner with the initial connection.
155 // This is stored in the banner as 'features=feature0,feature1,etc'.
156 FeatureSet features_;
157 int protocol_version;
158 size_t max_payload;
159
Yabin Cuib3298242015-08-28 15:09:44 -0700160 // A list of adisconnect callbacks called when the transport is kicked.
161 std::list<adisconnect*> disconnects_;
162
Elliott Hughes0aeb5052016-06-29 17:42:01 -0700163 std::deque<RSA*> keys_;
164
Dan Albert1792c232015-05-18 13:06:53 -0700165 DISALLOW_COPY_AND_ASSIGN(atransport);
166};
167
Dan Albert76649012015-02-24 15:51:19 -0800168/*
169 * Obtain a transport from the available transports.
Elliott Hughes8d28e192015-10-07 14:55:10 -0700170 * If serial is non-null then only the device with that serial will be chosen.
171 * If multiple devices/emulators would match, *is_ambiguous (if non-null)
172 * is set to true and nullptr returned.
173 * If no suitable transport is found, error is set and nullptr returned.
Dan Albert76649012015-02-24 15:51:19 -0800174 */
Elliott Hughes8d28e192015-10-07 14:55:10 -0700175atransport* acquire_one_transport(TransportType type, const char* serial,
176 bool* is_ambiguous, std::string* error_out);
Dan Albert76649012015-02-24 15:51:19 -0800177void kick_transport(atransport* t);
Dan Albert76649012015-02-24 15:51:19 -0800178void update_transports(void);
179
Dan Albert76649012015-02-24 15:51:19 -0800180void init_transport_registration(void);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700181std::string list_transports(bool long_listing);
Dan Albert76649012015-02-24 15:51:19 -0800182atransport* find_transport(const char* serial);
Yabin Cuif4b99282015-08-27 12:03:11 -0700183void kick_all_tcp_devices();
Dan Albert76649012015-02-24 15:51:19 -0800184
185void register_usb_transport(usb_handle* h, const char* serial,
186 const char* devpath, unsigned writeable);
187
188/* cause new transports to be init'd and added to the list */
189int register_socket_transport(int s, const char* serial, int port, int local);
190
Dan Albertdcd78a12015-05-18 16:43:57 -0700191// This should only be used for transports with connection_state == kCsNoPerm.
Dan Albert76649012015-02-24 15:51:19 -0800192void unregister_usb_transport(usb_handle* usb);
193
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100194int check_header(apacket* p, atransport* t);
Dan Albert76649012015-02-24 15:51:19 -0800195int check_data(apacket* p);
196
197/* for MacOS X cleanup */
198void close_usb_devices();
199
200void send_packet(apacket* p, atransport* t);
201
202asocket* create_device_tracker(void);
203
JP Abgrall408fa572011-03-16 15:57:42 -0700204#endif /* __TRANSPORT_H */