The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 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 | |
Josh Gao | bea8f3c | 2020-04-06 12:07:56 -0700 | [diff] [blame] | 17 | #pragma once |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 18 | |
| 19 | #include <limits.h> |
Josh Gao | 67ac379 | 2016-10-06 13:31:44 -0700 | [diff] [blame] | 20 | #include <stdint.h> |
Dan Albert | b302d12 | 2015-02-24 15:51:19 -0800 | [diff] [blame] | 21 | #include <sys/types.h> |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 22 | |
Elliott Hughes | 43df109 | 2015-07-23 17:12:58 -0700 | [diff] [blame] | 23 | #include <string> |
| 24 | |
Elliott Hughes | f55ead9 | 2015-12-04 22:00:26 -0800 | [diff] [blame] | 25 | #include <android-base/macros.h> |
Dan Albert | be8e54b | 2015-05-18 13:06:53 -0700 | [diff] [blame] | 26 | |
leozwang | f25a6a4 | 2014-07-29 12:50:02 -0700 | [diff] [blame] | 27 | #include "adb_trace.h" |
Josh Gao | b51193a | 2019-06-28 13:50:37 -0700 | [diff] [blame] | 28 | #include "fdevent/fdevent.h" |
Yabin Cui | 2ce9d56 | 2015-09-15 16:27:09 -0700 | [diff] [blame] | 29 | #include "socket.h" |
Josh Gao | cd2a529 | 2018-03-07 16:52:28 -0800 | [diff] [blame] | 30 | #include "types.h" |
JP Abgrall | 2e5dd6e | 2011-03-16 15:57:42 -0700 | [diff] [blame] | 31 | |
Tamas Berghammer | a1c60c0 | 2015-07-13 19:12:28 +0100 | [diff] [blame] | 32 | constexpr size_t MAX_PAYLOAD_V1 = 4 * 1024; |
Jerry Zhang | a2cb8de | 2017-07-18 14:07:57 -0700 | [diff] [blame] | 33 | constexpr size_t MAX_PAYLOAD = 1024 * 1024; |
Michael Groover | 02b7427 | 2019-04-25 18:33:35 -0700 | [diff] [blame] | 34 | constexpr size_t MAX_FRAMEWORK_PAYLOAD = 64 * 1024; |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 35 | |
Jerry Zhang | f0e239c | 2017-02-10 17:45:27 -0800 | [diff] [blame] | 36 | constexpr size_t LINUX_MAX_SOCKET_SIZE = 4194304; |
| 37 | |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 38 | #define A_SYNC 0x434e5953 |
| 39 | #define A_CNXN 0x4e584e43 |
| 40 | #define A_OPEN 0x4e45504f |
| 41 | #define A_OKAY 0x59414b4f |
| 42 | #define A_CLSE 0x45534c43 |
| 43 | #define A_WRTE 0x45545257 |
Benoit Goby | 2cc19e4 | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 44 | #define A_AUTH 0x48545541 |
Joshua Duong | 64fab75 | 2020-01-21 13:19:42 -0800 | [diff] [blame] | 45 | #define A_STLS 0x534C5453 |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 46 | |
Dan Albert | b302d12 | 2015-02-24 15:51:19 -0800 | [diff] [blame] | 47 | // ADB protocol version. |
Tim Murray | ee7b44d | 2017-12-07 11:40:00 -0800 | [diff] [blame] | 48 | // Version revision: |
| 49 | // 0x01000000: original |
| 50 | // 0x01000001: skip checksum (Dec 2017) |
| 51 | #define A_VERSION_MIN 0x01000000 |
| 52 | #define A_VERSION_SKIP_CHECKSUM 0x01000001 |
| 53 | #define A_VERSION 0x01000001 |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 54 | |
Joshua Duong | 64fab75 | 2020-01-21 13:19:42 -0800 | [diff] [blame] | 55 | // Stream-based TLS protocol version |
| 56 | #define A_STLS_VERSION_MIN 0x01000000 |
| 57 | #define A_STLS_VERSION 0x01000000 |
| 58 | |
Dan Albert | b302d12 | 2015-02-24 15:51:19 -0800 | [diff] [blame] | 59 | // Used for help/version information. |
| 60 | #define ADB_VERSION_MAJOR 1 |
| 61 | #define ADB_VERSION_MINOR 0 |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 62 | |
Elliott Hughes | b9f0164 | 2015-08-12 08:32:10 -0700 | [diff] [blame] | 63 | std::string adb_version(); |
| 64 | |
Dan Albert | b302d12 | 2015-02-24 15:51:19 -0800 | [diff] [blame] | 65 | // Increment this when we want to force users to start a new adb server. |
Josh Gao | 070e8ba | 2019-02-22 15:26:15 -0800 | [diff] [blame] | 66 | #define ADB_SERVER_VERSION 41 |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 67 | |
Josh Gao | b39e415 | 2017-08-16 16:57:01 -0700 | [diff] [blame] | 68 | using TransportId = uint64_t; |
Dan Albert | ecce503 | 2015-05-18 16:46:31 -0700 | [diff] [blame] | 69 | class atransport; |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 70 | |
Josh Gao | 67ac379 | 2016-10-06 13:31:44 -0700 | [diff] [blame] | 71 | uint32_t calculate_apacket_checksum(const apacket* packet); |
| 72 | |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 73 | /* the adisconnect structure is used to record a callback that |
| 74 | ** will be called whenever a transport is disconnected (e.g. by the user) |
| 75 | ** this should be used to cleanup objects that depend on the |
| 76 | ** transport (e.g. remote sockets, listeners, etc...) |
| 77 | */ |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 78 | struct adisconnect { |
| 79 | void (*func)(void* opaque, atransport* t); |
| 80 | void* opaque; |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 81 | }; |
| 82 | |
Dan Albert | ecce503 | 2015-05-18 16:46:31 -0700 | [diff] [blame] | 83 | // A transport object models the connection to a remote device or emulator there |
| 84 | // is one transport per connected device/emulator. A "local transport" connects |
| 85 | // through TCP (for the emulator), while a "usb transport" through USB (for real |
| 86 | // devices). |
| 87 | // |
| 88 | // Note that kTransportHost doesn't really correspond to a real transport |
| 89 | // object, it's a special value used to indicate that a client wants to connect |
| 90 | // to a service implemented within the ADB server itself. |
Elliott Hughes | 3aec2ba | 2015-05-05 13:10:43 -0700 | [diff] [blame] | 91 | enum TransportType { |
Dan Albert | ecce503 | 2015-05-18 16:46:31 -0700 | [diff] [blame] | 92 | kTransportUsb, |
| 93 | kTransportLocal, |
| 94 | kTransportAny, |
| 95 | kTransportHost, |
Elliott Hughes | fe7ff81 | 2015-04-17 09:47:42 -0700 | [diff] [blame] | 96 | }; |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 97 | |
Benoit Goby | 2cc19e4 | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 98 | #define TOKEN_SIZE 20 |
| 99 | |
Dan Albert | 9a50f4c | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 100 | enum ConnectionState { |
| 101 | kCsAny = -1, |
Josh Gao | 7a7c5cb | 2018-05-04 16:04:49 -0700 | [diff] [blame] | 102 | |
| 103 | kCsConnecting = 0, // Haven't received a response from the device yet. |
| 104 | kCsAuthorizing, // Authorizing with keys from ADB_VENDOR_KEYS. |
| 105 | kCsUnauthorized, // ADB_VENDOR_KEYS exhausted, fell back to user prompt. |
| 106 | kCsNoPerm, // Insufficient permissions to communicate with the device. |
Josh Gao | 8e7c972 | 2021-06-17 04:19:45 -0700 | [diff] [blame] | 107 | kCsDetached, // USB device that's detached from the adb server. |
Josh Gao | 7a7c5cb | 2018-05-04 16:04:49 -0700 | [diff] [blame] | 108 | kCsOffline, |
| 109 | |
Dan Albert | 9a50f4c | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 110 | kCsBootloader, |
| 111 | kCsDevice, |
| 112 | kCsHost, |
| 113 | kCsRecovery, |
Dan Albert | 9a50f4c | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 114 | kCsSideload, |
Tao Bao | 81e9c42 | 2019-04-07 23:24:03 -0700 | [diff] [blame] | 115 | kCsRescue, |
Dan Albert | 9a50f4c | 2015-05-18 16:43:57 -0700 | [diff] [blame] | 116 | }; |
| 117 | |
Josh Gao | 6256d99 | 2021-05-20 18:28:13 -0700 | [diff] [blame] | 118 | std::string to_string(ConnectionState state); |
| 119 | |
Josh Gao | 7a7c5cb | 2018-05-04 16:04:49 -0700 | [diff] [blame] | 120 | inline bool ConnectionStateIsOnline(ConnectionState state) { |
| 121 | switch (state) { |
| 122 | case kCsBootloader: |
| 123 | case kCsDevice: |
| 124 | case kCsHost: |
| 125 | case kCsRecovery: |
| 126 | case kCsSideload: |
Tao Bao | 81e9c42 | 2019-04-07 23:24:03 -0700 | [diff] [blame] | 127 | case kCsRescue: |
Josh Gao | 7a7c5cb | 2018-05-04 16:04:49 -0700 | [diff] [blame] | 128 | return true; |
| 129 | default: |
| 130 | return false; |
| 131 | } |
| 132 | } |
| 133 | |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 134 | void print_packet(const char* label, apacket* p); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 135 | |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 136 | void handle_packet(apacket* p, atransport* t); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 137 | |
Vince Harron | 5703eb3 | 2021-11-12 12:40:58 -0800 | [diff] [blame] | 138 | int launch_server(const std::string& socket_spec, const char* one_device); |
| 139 | int adb_server_main(int is_daemon, const std::string& socket_spec, const char* one_device, |
| 140 | int ack_reply_fd); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 141 | |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 142 | /* initialize a transport object's func pointers and state */ |
Josh Gao | fa3107e | 2018-07-25 17:21:49 -0700 | [diff] [blame] | 143 | int init_socket_transport(atransport* t, unique_fd s, int port, int local); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 144 | |
Lingfeng Yang | 5edb12b | 2016-10-06 12:22:55 -0700 | [diff] [blame] | 145 | std::string getEmulatorSerialString(int console_port); |
Stefan Hilzinger | 1ec0342 | 2010-04-26 10:17:43 +0100 | [diff] [blame] | 146 | #if ADB_HOST |
| 147 | atransport* find_emulator_transport_by_adb_port(int adb_port); |
Lingfeng Yang | 5edb12b | 2016-10-06 12:22:55 -0700 | [diff] [blame] | 148 | atransport* find_emulator_transport_by_console_port(int console_port); |
Stefan Hilzinger | 1ec0342 | 2010-04-26 10:17:43 +0100 | [diff] [blame] | 149 | #endif |
Mike Lockwood | 5f2c4a1 | 2009-10-11 23:04:18 -0400 | [diff] [blame] | 150 | |
Josh Gao | c270596 | 2019-01-23 15:36:42 -0800 | [diff] [blame] | 151 | unique_fd service_to_fd(std::string_view name, atransport* transport); |
Josh Gao | 5607e92 | 2018-07-25 18:15:52 -0700 | [diff] [blame] | 152 | #if !ADB_HOST |
Josh Gao | f0fa1e4 | 2018-12-13 13:06:03 -0800 | [diff] [blame] | 153 | unique_fd daemon_service_to_fd(std::string_view name, atransport* transport); |
Josh Gao | 5607e92 | 2018-07-25 18:15:52 -0700 | [diff] [blame] | 154 | #endif |
| 155 | |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 156 | #if ADB_HOST |
Josh Gao | 0565ae0 | 2019-02-22 13:41:55 -0800 | [diff] [blame] | 157 | asocket* host_service_to_socket(std::string_view name, std::string_view serial, |
| 158 | TransportId transport_id); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 159 | #endif |
| 160 | |
| 161 | #if !ADB_HOST |
Josh Gao | 3edf807 | 2018-11-16 15:40:16 -0800 | [diff] [blame] | 162 | asocket* daemon_service_to_socket(std::string_view name); |
| 163 | #endif |
| 164 | |
| 165 | #if !ADB_HOST |
Alex Buynytskyy | 4f3fa05 | 2019-02-21 14:22:51 -0800 | [diff] [blame] | 166 | unique_fd execute_abb_command(std::string_view command); |
Alex Buynytskyy | ef34f01 | 2018-12-12 10:48:50 -0800 | [diff] [blame] | 167 | #endif |
| 168 | |
| 169 | #if !ADB_HOST |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 170 | int init_jdwp(void); |
| 171 | asocket* create_jdwp_service_socket(); |
| 172 | asocket* create_jdwp_tracker_service_socket(); |
Shukang Zhou | 420ad55 | 2020-02-13 17:01:39 -0800 | [diff] [blame] | 173 | asocket* create_app_tracker_service_socket(); |
Josh Gao | 5607e92 | 2018-07-25 18:15:52 -0700 | [diff] [blame] | 174 | unique_fd create_jdwp_connection_fd(int jdwp_pid); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 175 | #endif |
| 176 | |
Josh Gao | dd655ec | 2018-07-30 18:49:03 -0700 | [diff] [blame] | 177 | bool handle_forward_request(const char* service, atransport* transport, int reply_fd); |
| 178 | bool handle_forward_request(const char* service, |
| 179 | std::function<atransport*(std::string* error)> transport_acquirer, |
| 180 | int reply_fd); |
David 'Digit' Turner | 963a449 | 2013-03-21 21:07:42 +0100 | [diff] [blame] | 181 | |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 182 | /* packet allocator */ |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 183 | apacket* get_apacket(void); |
| 184 | void put_apacket(apacket* p); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 185 | |
leozwang | 1be5462 | 2014-08-15 09:51:27 -0700 | [diff] [blame] | 186 | // Define it if you want to dump packets. |
| 187 | #define DEBUG_PACKETS 0 |
| 188 | |
Benoit Goby | 2cc19e4 | 2012-04-12 12:23:49 -0700 | [diff] [blame] | 189 | #if !DEBUG_PACKETS |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 190 | #define print_packet(tag, p) \ |
| 191 | do { \ |
| 192 | } while (0) |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 193 | #endif |
| 194 | |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 195 | #define DEFAULT_ADB_PORT 5037 |
John Michelau | 8733752 | 2010-09-23 17:08:34 -0500 | [diff] [blame] | 196 | |
Stefan Hilzinger | 92ca4fa | 2010-04-19 12:21:12 +0100 | [diff] [blame] | 197 | #define DEFAULT_ADB_LOCAL_TRANSPORT_PORT 5555 |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 198 | |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 199 | #define ADB_CLASS 0xff |
| 200 | #define ADB_SUBCLASS 0x42 |
| 201 | #define ADB_PROTOCOL 0x1 |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 202 | |
Jason Jeremy Iman | 8461387 | 2019-07-19 12:44:39 +0900 | [diff] [blame] | 203 | void local_init(const std::string& addr); |
Yabin Cui | f401ead | 2016-04-29 16:53:52 -0700 | [diff] [blame] | 204 | bool local_connect(int port); |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 205 | int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 206 | |
Dan Albert | be8e54b | 2015-05-18 13:06:53 -0700 | [diff] [blame] | 207 | extern const char* adb_device_banner; |
| 208 | |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 209 | #define CHUNK_SIZE (64 * 1024) |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 210 | |
Alex Buynytskyy | ef34f01 | 2018-12-12 10:48:50 -0800 | [diff] [blame] | 211 | // Argument delimeter for adb abb command. |
| 212 | #define ABB_ARG_DELIMETER ('\0') |
| 213 | |
Andrzej Pietrasiewicz | d7270f2 | 2012-01-13 15:13:46 +0100 | [diff] [blame] | 214 | #if !ADB_HOST |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 215 | #define USB_FFS_ADB_PATH "/dev/usb-ffs/adb/" |
| 216 | #define USB_FFS_ADB_EP(x) USB_FFS_ADB_PATH #x |
Andrzej Pietrasiewicz | d7270f2 | 2012-01-13 15:13:46 +0100 | [diff] [blame] | 217 | |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 218 | #define USB_FFS_ADB_EP0 USB_FFS_ADB_EP(ep0) |
| 219 | #define USB_FFS_ADB_OUT USB_FFS_ADB_EP(ep1) |
| 220 | #define USB_FFS_ADB_IN USB_FFS_ADB_EP(ep2) |
Andrzej Pietrasiewicz | d7270f2 | 2012-01-13 15:13:46 +0100 | [diff] [blame] | 221 | #endif |
| 222 | |
Josh Gao | b13f3cd | 2019-02-20 20:37:26 -0800 | [diff] [blame] | 223 | enum class HostRequestResult { |
| 224 | Handled, |
| 225 | SwitchedTransport, |
| 226 | Unhandled, |
| 227 | }; |
| 228 | |
| 229 | HostRequestResult handle_host_request(std::string_view service, TransportType type, |
| 230 | const char* serial, TransportId transport_id, int reply_fd, |
| 231 | asocket* s); |
The Android Open Source Project | 9ca14dc | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 232 | |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 233 | void handle_online(atransport* t); |
| 234 | void handle_offline(atransport* t); |
Dan Albert | 056ad0e | 2015-02-18 17:47:33 -0800 | [diff] [blame] | 235 | |
Mark Salyzyn | d4bf94d | 2017-10-04 15:05:40 -0700 | [diff] [blame] | 236 | void send_connect(atransport* t); |
Joshua Duong | 64fab75 | 2020-01-21 13:19:42 -0800 | [diff] [blame] | 237 | void send_tls_request(atransport* t); |
Dan Albert | 056ad0e | 2015-02-18 17:47:33 -0800 | [diff] [blame] | 238 | |
Dan Albert | be8e54b | 2015-05-18 13:06:53 -0700 | [diff] [blame] | 239 | void parse_banner(const std::string&, atransport* t); |
| 240 | |
Josh Gao | bea8f3c | 2020-04-06 12:07:56 -0700 | [diff] [blame] | 241 | #if ADB_HOST |
Josh Gao | 1e3bf73 | 2017-05-03 22:37:10 -0700 | [diff] [blame] | 242 | // On startup, the adb server needs to wait until all of the connected devices are ready. |
| 243 | // To do this, we need to know when the scan has identified all of the potential new transports, and |
| 244 | // when each transport becomes ready. |
| 245 | // TODO: Do this for mDNS as well, instead of just USB? |
| 246 | |
| 247 | // We've found all of the transports we potentially care about. |
| 248 | void adb_notify_device_scan_complete(); |
| 249 | |
| 250 | // One or more transports have changed status, check to see if we're ready. |
| 251 | void update_transport_status(); |
| 252 | |
| 253 | // Wait until device scan has completed and every transport is ready, or a timeout elapses. |
| 254 | void adb_wait_for_device_initialization(); |
Josh Gao | bea8f3c | 2020-04-06 12:07:56 -0700 | [diff] [blame] | 255 | #endif // ADB_HOST |
| 256 | |
| 257 | #if ADB_HOST |
| 258 | // When ssh-forwarding to a remote adb server, kill-server is almost never what you actually want, |
| 259 | // and unfortunately, many other tools issue it. This adds a knob to reject kill-servers. |
| 260 | void adb_set_reject_kill_server(bool reject); |
| 261 | #endif |
Josh Gao | 1e3bf73 | 2017-05-03 22:37:10 -0700 | [diff] [blame] | 262 | |
Josh Gao | 6b55e75 | 2020-03-27 18:09:56 -0700 | [diff] [blame] | 263 | void usb_init(); |