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 #define TRACE_TAG TRANSPORT
18
19 #include "sysdeps.h"
20 #include "transport.h"
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "adb.h"
27
28 #if ADB_HOST
29
30 #if defined(__APPLE__)
31 #define CHECK_PACKET_OVERFLOW 0
32 #else
33 #define CHECK_PACKET_OVERFLOW 1
34 #endif
35
36 // Call usb_read using a buffer having a multiple of usb_get_max_packet_size() bytes
37 // to avoid overflow. See http://libusb.sourceforge.net/api-1.0/packetoverflow.html.
UsbReadMessage(usb_handle * h,amessage * msg)38 static int UsbReadMessage(usb_handle* h, amessage* msg) {
39 D("UsbReadMessage");
40
41 #if CHECK_PACKET_OVERFLOW
42 size_t usb_packet_size = usb_get_max_packet_size(h);
43 CHECK_GE(usb_packet_size, sizeof(*msg));
44 CHECK_LT(usb_packet_size, 4096ULL);
45
46 char buffer[4096];
47 int n = usb_read(h, buffer, usb_packet_size);
48 if (n != sizeof(*msg)) {
49 D("usb_read returned unexpected length %d (expected %zu)", n, sizeof(*msg));
50 return -1;
51 }
52 memcpy(msg, buffer, sizeof(*msg));
53 return n;
54 #else
55 return usb_read(h, msg, sizeof(*msg));
56 #endif
57 }
58
59 // Call usb_read using a buffer having a multiple of usb_get_max_packet_size() bytes
60 // to avoid overflow. See http://libusb.sourceforge.net/api-1.0/packetoverflow.html.
UsbReadPayload(usb_handle * h,apacket * p)61 static int UsbReadPayload(usb_handle* h, apacket* p) {
62 D("UsbReadPayload(%d)", p->msg.data_length);
63
64 if (p->msg.data_length > MAX_PAYLOAD) {
65 return -1;
66 }
67
68 #if CHECK_PACKET_OVERFLOW
69 size_t usb_packet_size = usb_get_max_packet_size(h);
70
71 // Round the data length up to the nearest packet size boundary.
72 // The device won't send a zero packet for packet size aligned payloads,
73 // so don't read any more packets than needed.
74 size_t len = p->msg.data_length;
75 size_t rem_size = len % usb_packet_size;
76 if (rem_size) {
77 len += usb_packet_size - rem_size;
78 }
79
80 p->payload.resize(len);
81 int rc = usb_read(h, &p->payload[0], p->payload.size());
82 if (rc != static_cast<int>(p->msg.data_length)) {
83 return -1;
84 }
85
86 p->payload.resize(rc);
87 return rc;
88 #else
89 p->payload.resize(p->msg.data_length);
90 return usb_read(h, &p->payload[0], p->payload.size());
91 #endif
92 }
93
remote_read(apacket * p,usb_handle * usb)94 static int remote_read(apacket* p, usb_handle* usb) {
95 int n = UsbReadMessage(usb, &p->msg);
96 if (n < 0) {
97 D("remote usb: read terminated (message)");
98 return -1;
99 }
100 if (static_cast<size_t>(n) != sizeof(p->msg)) {
101 D("remote usb: read received unexpected header length %d", n);
102 return -1;
103 }
104 if (p->msg.data_length) {
105 n = UsbReadPayload(usb, p);
106 if (n < 0) {
107 D("remote usb: terminated (data)");
108 return -1;
109 }
110 if (static_cast<uint32_t>(n) != p->msg.data_length) {
111 D("remote usb: read payload failed (need %u bytes, give %d bytes), skip it",
112 p->msg.data_length, n);
113 return -1;
114 }
115 }
116 return 0;
117 }
118
119 #else
120
121 // On Android devices, we rely on the kernel to provide buffered read.
122 // So we can recover automatically from EOVERFLOW.
remote_read(apacket * p,usb_handle * usb)123 static int remote_read(apacket* p, usb_handle* usb) {
124 if (usb_read(usb, &p->msg, sizeof(amessage))) {
125 PLOG(ERROR) << "remote usb: read terminated (message)";
126 return -1;
127 }
128
129 if (p->msg.data_length) {
130 if (p->msg.data_length > MAX_PAYLOAD) {
131 PLOG(ERROR) << "remote usb: read overflow (data length = " << p->msg.data_length << ")";
132 return -1;
133 }
134
135 p->payload.resize(p->msg.data_length);
136 if (usb_read(usb, &p->payload[0], p->payload.size())) {
137 PLOG(ERROR) << "remote usb: terminated (data)";
138 return -1;
139 }
140 }
141
142 return 0;
143 }
144 #endif
145
~UsbConnection()146 UsbConnection::~UsbConnection() {
147 usb_close(handle_);
148 }
149
Read(apacket * packet)150 bool UsbConnection::Read(apacket* packet) {
151 int rc = remote_read(packet, handle_);
152 return rc == 0;
153 }
154
Write(apacket * packet)155 bool UsbConnection::Write(apacket* packet) {
156 unsigned size = packet->msg.data_length;
157
158 if (usb_write(handle_, &packet->msg, sizeof(packet->msg)) != 0) {
159 PLOG(ERROR) << "remote usb: 1 - write terminated";
160 return false;
161 }
162
163 if (packet->msg.data_length != 0 && usb_write(handle_, packet->payload.data(), size) != 0) {
164 PLOG(ERROR) << "remote usb: 2 - write terminated";
165 return false;
166 }
167
168 return true;
169 }
170
Close()171 void UsbConnection::Close() {
172 usb_kick(handle_);
173 }
174
init_usb_transport(atransport * t,usb_handle * h)175 void init_usb_transport(atransport* t, usb_handle* h) {
176 D("transport: usb");
177 t->connection.reset(new UsbConnection(h));
178 t->sync_token = 1;
179 t->type = kTransportUsb;
180 }
181
is_adb_interface(int usb_class,int usb_subclass,int usb_protocol)182 int is_adb_interface(int usb_class, int usb_subclass, int usb_protocol) {
183 return (usb_class == ADB_CLASS && usb_subclass == ADB_SUBCLASS && usb_protocol == ADB_PROTOCOL);
184 }
185
should_use_libusb()186 bool should_use_libusb() {
187 #if !ADB_HOST
188 return false;
189 #else
190 static bool enable = getenv("ADB_LIBUSB") && strcmp(getenv("ADB_LIBUSB"), "1") == 0;
191 return enable;
192 #endif
193 }
194