blob: b7718a0562a23f482f96befe59eef2b323746319 [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
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
Yabin Cuiaed3c612015-09-22 15:52:57 -070017#define TRACE_TAG SOCKETS
Dan Albert33134262015-03-19 15:21:08 -070018
19#include "sysdeps.h"
20
Dan Albert76649012015-02-24 15:51:19 -080021#include <ctype.h>
22#include <errno.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080023#include <stdio.h>
24#include <stdlib.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080025#include <string.h>
Dan Albert76649012015-02-24 15:51:19 -080026#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080027
Spencer Low363af562015-11-07 18:51:54 -080028#include <algorithm>
David Pursell3f902aa2016-03-01 08:58:26 -080029#include <string>
30#include <vector>
Spencer Low363af562015-11-07 18:51:54 -080031
Dan Albert76649012015-02-24 15:51:19 -080032#if !ADB_HOST
33#include "cutils/properties.h"
34#endif
Dan Albert33134262015-03-19 15:21:08 -070035
36#include "adb.h"
37#include "adb_io.h"
Dan Albert76649012015-02-24 15:51:19 -080038#include "transport.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080039
Josh Gao52bd8522016-05-17 16:55:06 -070040ADB_MUTEX_DEFINE(socket_list_lock);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080041
Josh Gao52bd8522016-05-17 16:55:06 -070042static void local_socket_close_locked(asocket* s);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080043
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080044static unsigned local_socket_next_id = 1;
45
46static asocket local_socket_list = {
Josh Gao52bd8522016-05-17 16:55:06 -070047 .next = &local_socket_list, .prev = &local_socket_list,
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080048};
49
50/* the the list of currently closing local sockets.
51** these have no peer anymore, but still packets to
52** write to their fd.
53*/
54static asocket local_socket_closing_list = {
Josh Gao52bd8522016-05-17 16:55:06 -070055 .next = &local_socket_closing_list, .prev = &local_socket_closing_list,
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080056};
57
David 'Digit' Turner818d6412013-12-13 14:09:44 +010058// Parse the global list of sockets to find one with id |local_id|.
59// If |peer_id| is not 0, also check that it is connected to a peer
60// with id |peer_id|. Returns an asocket handle on success, NULL on failure.
Josh Gao52bd8522016-05-17 16:55:06 -070061asocket* find_local_socket(unsigned local_id, unsigned peer_id) {
62 asocket* s;
63 asocket* result = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080064
65 adb_mutex_lock(&socket_list_lock);
André Goddard Rosa81828292010-06-12 11:40:20 -030066 for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
Josh Gao52bd8522016-05-17 16:55:06 -070067 if (s->id != local_id) {
David 'Digit' Turner818d6412013-12-13 14:09:44 +010068 continue;
Josh Gao52bd8522016-05-17 16:55:06 -070069 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +010070 if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) {
André Goddard Rosa81828292010-06-12 11:40:20 -030071 result = s;
André Goddard Rosa81828292010-06-12 11:40:20 -030072 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +010073 break;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080074 }
75 adb_mutex_unlock(&socket_list_lock);
76
77 return result;
78}
79
Josh Gao52bd8522016-05-17 16:55:06 -070080static void insert_local_socket(asocket* s, asocket* list) {
81 s->next = list;
82 s->prev = s->next->prev;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080083 s->prev->next = s;
84 s->next->prev = s;
85}
86
Josh Gao52bd8522016-05-17 16:55:06 -070087void install_local_socket(asocket* s) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080088 adb_mutex_lock(&socket_list_lock);
89
90 s->id = local_socket_next_id++;
David 'Digit' Turner818d6412013-12-13 14:09:44 +010091
92 // Socket ids should never be 0.
Josh Gao52bd8522016-05-17 16:55:06 -070093 if (local_socket_next_id == 0) {
94 local_socket_next_id = 1;
95 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +010096
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080097 insert_local_socket(s, &local_socket_list);
98
99 adb_mutex_unlock(&socket_list_lock);
100}
101
Josh Gao52bd8522016-05-17 16:55:06 -0700102void remove_socket(asocket* s) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800103 // socket_list_lock should already be held
Josh Gao52bd8522016-05-17 16:55:06 -0700104 if (s->prev && s->next) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800105 s->prev->next = s->next;
106 s->next->prev = s->prev;
107 s->next = 0;
108 s->prev = 0;
109 s->id = 0;
110 }
111}
112
Josh Gao52bd8522016-05-17 16:55:06 -0700113void close_all_sockets(atransport* t) {
114 asocket* s;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800115
Josh Gao52bd8522016-05-17 16:55:06 -0700116 /* this is a little gross, but since s->close() *will* modify
117 ** the list out from under you, your options are limited.
118 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800119 adb_mutex_lock(&socket_list_lock);
120restart:
Josh Gao52bd8522016-05-17 16:55:06 -0700121 for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
122 if (s->transport == t || (s->peer && s->peer->transport == t)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800123 local_socket_close_locked(s);
124 goto restart;
125 }
126 }
127 adb_mutex_unlock(&socket_list_lock);
128}
129
Josh Gao52bd8522016-05-17 16:55:06 -0700130static int local_socket_enqueue(asocket* s, apacket* p) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700131 D("LS(%d): enqueue %d", s->id, p->len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800132
133 p->ptr = p->data;
134
Josh Gao52bd8522016-05-17 16:55:06 -0700135 /* if there is already data queue'd, we will receive
136 ** events when it's time to write. just add this to
137 ** the tail
138 */
139 if (s->pkt_first) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800140 goto enqueue;
141 }
142
Josh Gao52bd8522016-05-17 16:55:06 -0700143 /* write as much as we can, until we
144 ** would block or there is an error/eof
145 */
146 while (p->len > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800147 int r = adb_write(s->fd, p->ptr, p->len);
Josh Gao52bd8522016-05-17 16:55:06 -0700148 if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800149 p->len -= r;
150 p->ptr += r;
151 continue;
152 }
Josh Gao52bd8522016-05-17 16:55:06 -0700153 if ((r == 0) || (errno != EAGAIN)) {
154 D("LS(%d): not ready, errno=%d: %s", s->id, errno, strerror(errno));
Yabin Cuic1b1f6f2015-09-15 16:27:09 -0700155 put_apacket(p);
156 s->has_write_error = true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800157 s->close(s);
158 return 1; /* not ready (error) */
159 } else {
160 break;
161 }
162 }
163
Josh Gao52bd8522016-05-17 16:55:06 -0700164 if (p->len == 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800165 put_apacket(p);
166 return 0; /* ready for more data */
167 }
168
169enqueue:
170 p->next = 0;
Josh Gao52bd8522016-05-17 16:55:06 -0700171 if (s->pkt_first) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800172 s->pkt_last->next = p;
173 } else {
174 s->pkt_first = p;
175 }
176 s->pkt_last = p;
177
Josh Gao52bd8522016-05-17 16:55:06 -0700178 /* make sure we are notified when we can drain the queue */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800179 fdevent_add(&s->fde, FDE_WRITE);
180
181 return 1; /* not ready (backlog) */
182}
183
Josh Gao52bd8522016-05-17 16:55:06 -0700184static void local_socket_ready(asocket* s) {
Nanik Tolaramb627a0e2015-02-18 22:53:37 +1100185 /* far side is ready for data, pay attention to
186 readable events */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800187 fdevent_add(&s->fde, FDE_READ);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800188}
189
Josh Gao52bd8522016-05-17 16:55:06 -0700190static void local_socket_close(asocket* s) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800191 adb_mutex_lock(&socket_list_lock);
192 local_socket_close_locked(s);
193 adb_mutex_unlock(&socket_list_lock);
194}
195
196// be sure to hold the socket list lock when calling this
Josh Gao52bd8522016-05-17 16:55:06 -0700197static void local_socket_destroy(asocket* s) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800198 apacket *p, *n;
Benoit Gobyf366b362012-03-16 14:50:07 -0700199 int exit_on_close = s->exit_on_close;
200
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700201 D("LS(%d): destroying fde.fd=%d", s->id, s->fde.fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800202
Josh Gao52bd8522016-05-17 16:55:06 -0700203 /* IMPORTANT: the remove closes the fd
204 ** that belongs to this socket
205 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800206 fdevent_remove(&s->fde);
207
Josh Gao52bd8522016-05-17 16:55:06 -0700208 /* dispose of any unwritten data */
209 for (p = s->pkt_first; p; p = n) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700210 D("LS(%d): discarding %d bytes", s->id, p->len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800211 n = p->next;
212 put_apacket(p);
213 }
214 remove_socket(s);
215 free(s);
Benoit Gobyf366b362012-03-16 14:50:07 -0700216
217 if (exit_on_close) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700218 D("local_socket_destroy: exiting");
Benoit Gobyf366b362012-03-16 14:50:07 -0700219 exit(1);
220 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800221}
222
Josh Gao52bd8522016-05-17 16:55:06 -0700223static void local_socket_close_locked(asocket* s) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700224 D("entered local_socket_close_locked. LS(%d) fd=%d", s->id, s->fd);
Josh Gao52bd8522016-05-17 16:55:06 -0700225 if (s->peer) {
226 D("LS(%d): closing peer. peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100227 /* Note: it's important to call shutdown before disconnecting from
228 * the peer, this ensures that remote sockets can still get the id
229 * of the local socket they're connected to, to send a CLOSE()
230 * protocol event. */
Josh Gao52bd8522016-05-17 16:55:06 -0700231 if (s->peer->shutdown) {
232 s->peer->shutdown(s->peer);
233 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800234 s->peer->peer = 0;
235 // tweak to avoid deadlock
Tom Marlin49f18572011-05-13 13:24:55 -0500236 if (s->peer->close == local_socket_close) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800237 local_socket_close_locked(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500238 } else {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800239 s->peer->close(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500240 }
241 s->peer = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800242 }
243
Josh Gao52bd8522016-05-17 16:55:06 -0700244 /* If we are already closing, or if there are no
245 ** pending packets, destroy immediately
246 */
Yabin Cuic1b1f6f2015-09-15 16:27:09 -0700247 if (s->closing || s->has_write_error || s->pkt_first == NULL) {
Josh Gao52bd8522016-05-17 16:55:06 -0700248 int id = s->id;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800249 local_socket_destroy(s);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700250 D("LS(%d): closed", id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800251 return;
252 }
253
Josh Gao52bd8522016-05-17 16:55:06 -0700254 /* otherwise, put on the closing list
255 */
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700256 D("LS(%d): closing", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800257 s->closing = 1;
258 fdevent_del(&s->fde, FDE_READ);
259 remove_socket(s);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700260 D("LS(%d): put on socket_closing_list fd=%d", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800261 insert_local_socket(s, &local_socket_closing_list);
Yabin Cuic1b1f6f2015-09-15 16:27:09 -0700262 CHECK_EQ(FDE_WRITE, s->fde.state & FDE_WRITE);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800263}
264
Josh Gao52bd8522016-05-17 16:55:06 -0700265static void local_socket_event_func(int fd, unsigned ev, void* _s) {
Dan Albertbac34742015-02-25 17:51:28 -0800266 asocket* s = reinterpret_cast<asocket*>(_s);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700267 D("LS(%d): event_func(fd=%d(==%d), ev=%04x)", s->id, s->fd, fd, ev);
JP Abgrall408fa572011-03-16 15:57:42 -0700268
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800269 /* put the FDE_WRITE processing before the FDE_READ
270 ** in order to simplify the code.
271 */
Dan Albertbac34742015-02-25 17:51:28 -0800272 if (ev & FDE_WRITE) {
273 apacket* p;
274 while ((p = s->pkt_first) != nullptr) {
275 while (p->len > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800276 int r = adb_write(fd, p->ptr, p->len);
Dan Albertbac34742015-02-25 17:51:28 -0800277 if (r == -1) {
278 /* returning here is ok because FDE_READ will
279 ** be processed in the next iteration loop
280 */
281 if (errno == EAGAIN) {
282 return;
283 }
284 } else if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800285 p->ptr += r;
286 p->len -= r;
287 continue;
288 }
Dan Albertbac34742015-02-25 17:51:28 -0800289
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700290 D(" closing after write because r=%d and errno is %d", r, errno);
Yabin Cuic1b1f6f2015-09-15 16:27:09 -0700291 s->has_write_error = true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800292 s->close(s);
293 return;
294 }
295
Dan Albertbac34742015-02-25 17:51:28 -0800296 if (p->len == 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800297 s->pkt_first = p->next;
Dan Albertbac34742015-02-25 17:51:28 -0800298 if (s->pkt_first == 0) {
299 s->pkt_last = 0;
300 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800301 put_apacket(p);
302 }
303 }
304
Dan Albertbac34742015-02-25 17:51:28 -0800305 /* if we sent the last packet of a closing socket,
306 ** we can now destroy it.
307 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800308 if (s->closing) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700309 D(" closing because 'closing' is set after write");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800310 s->close(s);
311 return;
312 }
313
Dan Albertbac34742015-02-25 17:51:28 -0800314 /* no more packets queued, so we can ignore
315 ** writable events again and tell our peer
316 ** to resume writing
317 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800318 fdevent_del(&s->fde, FDE_WRITE);
319 s->peer->ready(s->peer);
320 }
321
Dan Albertbac34742015-02-25 17:51:28 -0800322 if (ev & FDE_READ) {
Josh Gao52bd8522016-05-17 16:55:06 -0700323 apacket* p = get_apacket();
324 unsigned char* x = p->data;
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100325 const size_t max_payload = s->get_max_payload();
326 size_t avail = max_payload;
327 int r = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800328 int is_eof = 0;
329
Dan Albertbac34742015-02-25 17:51:28 -0800330 while (avail > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800331 r = adb_read(fd, x, avail);
Josh Gao52bd8522016-05-17 16:55:06 -0700332 D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu", s->id, s->fd, r,
333 r < 0 ? errno : 0, avail);
Dan Albertbac34742015-02-25 17:51:28 -0800334 if (r == -1) {
335 if (errno == EAGAIN) {
336 break;
337 }
338 } else if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800339 avail -= r;
340 x += r;
341 continue;
342 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800343
Dan Albertbac34742015-02-25 17:51:28 -0800344 /* r = 0 or unhandled error */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800345 is_eof = 1;
346 break;
347 }
Josh Gao52bd8522016-05-17 16:55:06 -0700348 D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d", s->id, s->fd, r, is_eof,
349 s->fde.force_eof);
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100350 if ((avail == max_payload) || (s->peer == 0)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800351 put_apacket(p);
352 } else {
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100353 p->len = max_payload - avail;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800354
Yabin Cui00674122015-08-26 12:27:40 -0700355 // s->peer->enqueue() may call s->close() and free s,
356 // so save variables for debug printing below.
357 unsigned saved_id = s->id;
358 int saved_fd = s->fd;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800359 r = s->peer->enqueue(s->peer, p);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700360 D("LS(%u): fd=%d post peer->enqueue(). r=%d", saved_id, saved_fd, r);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800361
Dan Albertbac34742015-02-25 17:51:28 -0800362 if (r < 0) {
Josh Gao52bd8522016-05-17 16:55:06 -0700363 /* error return means they closed us as a side-effect
364 ** and we must return immediately.
365 **
366 ** note that if we still have buffered packets, the
367 ** socket will be placed on the closing socket list.
368 ** this handler function will be called again
369 ** to process FDE_WRITE events.
370 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800371 return;
372 }
373
Dan Albertbac34742015-02-25 17:51:28 -0800374 if (r > 0) {
Josh Gao52bd8522016-05-17 16:55:06 -0700375 /* if the remote cannot accept further events,
376 ** we disable notification of READs. They'll
377 ** be enabled again when we get a call to ready()
378 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800379 fdevent_del(&s->fde, FDE_READ);
380 }
381 }
JP Abgrall112445b2011-04-12 22:01:58 -0700382 /* Don't allow a forced eof if data is still there */
Dan Albertbac34742015-02-25 17:51:28 -0800383 if ((s->fde.force_eof && !r) || is_eof) {
Josh Gao52bd8522016-05-17 16:55:06 -0700384 D(" closing because is_eof=%d r=%d s->fde.force_eof=%d", is_eof, r, s->fde.force_eof);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800385 s->close(s);
Yabin Cuic1b1f6f2015-09-15 16:27:09 -0700386 return;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800387 }
388 }
389
Josh Gao52bd8522016-05-17 16:55:06 -0700390 if (ev & FDE_ERROR) {
391 /* this should be caught be the next read or write
392 ** catching it here means we may skip the last few
393 ** bytes of readable data.
394 */
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700395 D("LS(%d): FDE_ERROR (fd=%d)", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800396 return;
397 }
398}
399
Josh Gao52bd8522016-05-17 16:55:06 -0700400asocket* create_local_socket(int fd) {
401 asocket* s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
402 if (s == NULL) {
403 fatal("cannot allocate socket");
404 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800405 s->fd = fd;
406 s->enqueue = local_socket_enqueue;
407 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100408 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800409 s->close = local_socket_close;
JP Abgrall408fa572011-03-16 15:57:42 -0700410 install_local_socket(s);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800411
412 fdevent_install(&s->fde, fd, local_socket_event_func, s);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700413 D("LS(%d): created (fd=%d)", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800414 return s;
415}
416
Josh Gao52bd8522016-05-17 16:55:06 -0700417asocket* create_local_service_socket(const char* name, const atransport* transport) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800418#if !ADB_HOST
Josh Gao52bd8522016-05-17 16:55:06 -0700419 if (!strcmp(name, "jdwp")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800420 return create_jdwp_service_socket();
421 }
Josh Gao52bd8522016-05-17 16:55:06 -0700422 if (!strcmp(name, "track-jdwp")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800423 return create_jdwp_tracker_service_socket();
424 }
425#endif
David Pursell0955c662015-08-31 10:42:13 -0700426 int fd = service_to_fd(name, transport);
Josh Gao52bd8522016-05-17 16:55:06 -0700427 if (fd < 0) {
428 return 0;
429 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800430
Dan Pasanen98858812014-10-06 12:57:20 -0500431 asocket* s = create_local_socket(fd);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700432 D("LS(%d): bound to '%s' via %d", s->id, name, fd);
Benoit Gobyf366b362012-03-16 14:50:07 -0700433
JP Abgrallf91259a2012-03-30 13:19:11 -0700434#if !ADB_HOST
Dan Pasanen98858812014-10-06 12:57:20 -0500435 char debug[PROPERTY_VALUE_MAX];
Josh Gao52bd8522016-05-17 16:55:06 -0700436 if (!strncmp(name, "root:", 5)) {
jzhuan51297d222013-05-24 17:40:15 -0400437 property_get("ro.debuggable", debug, "");
Josh Gao52bd8522016-05-17 16:55:06 -0700438 }
jzhuan51297d222013-05-24 17:40:15 -0400439
Josh Gao52bd8522016-05-17 16:55:06 -0700440 if ((!strncmp(name, "root:", 5) && getuid() != 0 && strcmp(debug, "1") == 0) ||
441 (!strncmp(name, "unroot:", 7) && getuid() == 0) ||
442 !strncmp(name, "usb:", 4) ||
443 !strncmp(name, "tcpip:", 6)) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700444 D("LS(%d): enabling exit_on_close", s->id);
Benoit Gobyf366b362012-03-16 14:50:07 -0700445 s->exit_on_close = 1;
446 }
JP Abgrallf91259a2012-03-30 13:19:11 -0700447#endif
Benoit Gobyf366b362012-03-16 14:50:07 -0700448
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800449 return s;
450}
451
452#if ADB_HOST
Josh Gao52bd8522016-05-17 16:55:06 -0700453static asocket* create_host_service_socket(const char* name, const char* serial) {
454 asocket* s;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800455
456 s = host_service_to_socket(name, serial);
457
458 if (s != NULL) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700459 D("LS(%d) bound to '%s'", s->id, name);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800460 return s;
461 }
462
463 return s;
464}
465#endif /* ADB_HOST */
466
Josh Gao52bd8522016-05-17 16:55:06 -0700467static int remote_socket_enqueue(asocket* s, apacket* p) {
468 D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d", s->id, s->fd, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800469 p->msg.command = A_WRTE;
470 p->msg.arg0 = s->peer->id;
471 p->msg.arg1 = s->id;
472 p->msg.data_length = p->len;
473 send_packet(p, s->transport);
474 return 1;
475}
476
Josh Gao52bd8522016-05-17 16:55:06 -0700477static void remote_socket_ready(asocket* s) {
478 D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d", s->id, s->fd, s->peer->fd);
479 apacket* p = get_apacket();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800480 p->msg.command = A_OKAY;
481 p->msg.arg0 = s->peer->id;
482 p->msg.arg1 = s->id;
483 send_packet(p, s->transport);
484}
485
Josh Gao52bd8522016-05-17 16:55:06 -0700486static void remote_socket_shutdown(asocket* s) {
487 D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d", s->id, s->fd,
488 s->peer ? s->peer->fd : -1);
489 apacket* p = get_apacket();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800490 p->msg.command = A_CLSE;
Josh Gao52bd8522016-05-17 16:55:06 -0700491 if (s->peer) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800492 p->msg.arg0 = s->peer->id;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100493 }
494 p->msg.arg1 = s->id;
495 send_packet(p, s->transport);
496}
497
Josh Gao52bd8522016-05-17 16:55:06 -0700498static void remote_socket_close(asocket* s) {
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100499 if (s->peer) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800500 s->peer->peer = 0;
Josh Gao52bd8522016-05-17 16:55:06 -0700501 D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800502 s->peer->close(s->peer);
503 }
Josh Gao52bd8522016-05-17 16:55:06 -0700504 D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d", s->id, s->fd,
505 s->peer ? s->peer->fd : -1);
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700506 D("RS(%d): closed", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800507 free(s);
508}
509
Yabin Cuifd28f322015-08-27 18:50:04 -0700510// Create a remote socket to exchange packets with a remote service through transport
511// |t|. Where |id| is the socket id of the corresponding service on the other
512// side of the transport (it is allocated by the remote side and _cannot_ be 0).
513// Returns a new non-NULL asocket handle.
Josh Gao52bd8522016-05-17 16:55:06 -0700514asocket* create_remote_socket(unsigned id, atransport* t) {
515 if (id == 0) {
516 fatal("invalid remote socket id (0)");
517 }
Yabin Cuifd28f322015-08-27 18:50:04 -0700518 asocket* s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800519
Josh Gao52bd8522016-05-17 16:55:06 -0700520 if (s == NULL) {
521 fatal("cannot allocate socket");
522 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800523 s->id = id;
524 s->enqueue = remote_socket_enqueue;
525 s->ready = remote_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100526 s->shutdown = remote_socket_shutdown;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800527 s->close = remote_socket_close;
528 s->transport = t;
529
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700530 D("RS(%d): created", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800531 return s;
532}
533
Josh Gao52bd8522016-05-17 16:55:06 -0700534void connect_to_remote(asocket* s, const char* destination) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700535 D("Connect_to_remote call RS(%d) fd=%d", s->id, s->fd);
Josh Gao52bd8522016-05-17 16:55:06 -0700536 apacket* p = get_apacket();
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100537 size_t len = strlen(destination) + 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800538
Josh Gao52bd8522016-05-17 16:55:06 -0700539 if (len > (s->get_max_payload() - 1)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800540 fatal("destination oversized");
541 }
542
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700543 D("LS(%d): connect('%s')", s->id, destination);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800544 p->msg.command = A_OPEN;
545 p->msg.arg0 = s->id;
546 p->msg.data_length = len;
Josh Gao52bd8522016-05-17 16:55:06 -0700547 strcpy((char*)p->data, destination);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800548 send_packet(p, s->transport);
549}
550
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800551/* this is used by magic sockets to rig local sockets to
552 send the go-ahead message when they connect */
Josh Gao52bd8522016-05-17 16:55:06 -0700553static void local_socket_ready_notify(asocket* s) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800554 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100555 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800556 s->close = local_socket_close;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700557 SendOkay(s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800558 s->ready(s);
559}
560
561/* this is used by magic sockets to rig local sockets to
562 send the failure message if they are closed before
563 connected (to avoid closing them without a status message) */
Josh Gao52bd8522016-05-17 16:55:06 -0700564static void local_socket_close_notify(asocket* s) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800565 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100566 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800567 s->close = local_socket_close;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700568 SendFail(s->fd, "closed");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800569 s->close(s);
570}
571
Josh Gao52bd8522016-05-17 16:55:06 -0700572static unsigned unhex(unsigned char* s, int len) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800573 unsigned n = 0, c;
574
Josh Gao52bd8522016-05-17 16:55:06 -0700575 while (len-- > 0) {
576 switch ((c = *s++)) {
577 case '0':
578 case '1':
579 case '2':
580 case '3':
581 case '4':
582 case '5':
583 case '6':
584 case '7':
585 case '8':
586 case '9':
587 c -= '0';
588 break;
589 case 'a':
590 case 'b':
591 case 'c':
592 case 'd':
593 case 'e':
594 case 'f':
595 c = c - 'a' + 10;
596 break;
597 case 'A':
598 case 'B':
599 case 'C':
600 case 'D':
601 case 'E':
602 case 'F':
603 c = c - 'A' + 10;
604 break;
605 default:
606 return 0xffffffff;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800607 }
608
609 n = (n << 4) | c;
610 }
611
612 return n;
613}
614
Elliott Hughese67f1f82015-04-30 17:32:03 -0700615#if ADB_HOST
616
David Pursell3f902aa2016-03-01 08:58:26 -0800617namespace internal {
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700618
David Pursell3f902aa2016-03-01 08:58:26 -0800619// Returns the position in |service| following the target serial parameter. Serial format can be
620// any of:
621// * [tcp:|udp:]<serial>[:<port>]:<command>
622// * <prefix>:<serial>:<command>
623// Where <port> must be a base-10 number and <prefix> may be any of {usb,product,model,device}.
624//
625// The returned pointer will point to the ':' just before <command>, or nullptr if not found.
Dan Austinb4cff492016-03-28 15:32:37 -0700626char* skip_host_serial(char* service) {
David Pursell3f902aa2016-03-01 08:58:26 -0800627 static const std::vector<std::string>& prefixes =
628 *(new std::vector<std::string>{"usb:", "product:", "model:", "device:"});
Terence Haddock28e13902011-03-16 09:43:56 +0100629
David Pursell3f902aa2016-03-01 08:58:26 -0800630 for (const std::string& prefix : prefixes) {
631 if (!strncmp(service, prefix.c_str(), prefix.length())) {
632 return strchr(service + prefix.length(), ':');
633 }
Scott Anderson3608d832012-05-31 12:04:23 -0700634 }
635
David Pursell3f902aa2016-03-01 08:58:26 -0800636 // For fastboot compatibility, ignore protocol prefixes.
637 if (!strncmp(service, "tcp:", 4) || !strncmp(service, "udp:", 4)) {
638 service += 4;
639 }
640
641 char* first_colon = strchr(service, ':');
Terence Haddock28e13902011-03-16 09:43:56 +0100642 if (!first_colon) {
David Pursell3f902aa2016-03-01 08:58:26 -0800643 // No colon in service string.
644 return nullptr;
Terence Haddock28e13902011-03-16 09:43:56 +0100645 }
David Pursell3f902aa2016-03-01 08:58:26 -0800646
647 char* serial_end = first_colon;
Terence Haddock28e13902011-03-16 09:43:56 +0100648 if (isdigit(serial_end[1])) {
649 serial_end++;
David Pursell3f902aa2016-03-01 08:58:26 -0800650 while (*serial_end && isdigit(*serial_end)) {
Terence Haddock28e13902011-03-16 09:43:56 +0100651 serial_end++;
652 }
David Pursell3f902aa2016-03-01 08:58:26 -0800653 if (*serial_end != ':') {
Terence Haddock28e13902011-03-16 09:43:56 +0100654 // Something other than numbers was found, reset the end.
655 serial_end = first_colon;
656 }
657 }
658 return serial_end;
659}
660
David Pursell3f902aa2016-03-01 08:58:26 -0800661} // namespace internal
662
Josh Gao52bd8522016-05-17 16:55:06 -0700663#endif // ADB_HOST
Elliott Hughese67f1f82015-04-30 17:32:03 -0700664
Josh Gao52bd8522016-05-17 16:55:06 -0700665static int smart_socket_enqueue(asocket* s, apacket* p) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800666 unsigned len;
667#if ADB_HOST
Josh Gao52bd8522016-05-17 16:55:06 -0700668 char* service = nullptr;
Elliott Hughes8d28e192015-10-07 14:55:10 -0700669 char* serial = nullptr;
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700670 TransportType type = kTransportAny;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800671#endif
672
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700673 D("SS(%d): enqueue %d", s->id, p->len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800674
Josh Gao52bd8522016-05-17 16:55:06 -0700675 if (s->pkt_first == 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800676 s->pkt_first = p;
677 s->pkt_last = p;
678 } else {
Josh Gao52bd8522016-05-17 16:55:06 -0700679 if ((s->pkt_first->len + p->len) > s->get_max_payload()) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700680 D("SS(%d): overflow", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800681 put_apacket(p);
682 goto fail;
683 }
684
Josh Gao52bd8522016-05-17 16:55:06 -0700685 memcpy(s->pkt_first->data + s->pkt_first->len, p->data, p->len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800686 s->pkt_first->len += p->len;
687 put_apacket(p);
688
689 p = s->pkt_first;
690 }
691
Josh Gao7e6683c2016-01-15 14:35:54 -0800692 /* don't bother if we can't decode the length */
Josh Gao52bd8522016-05-17 16:55:06 -0700693 if (p->len < 4) {
694 return 0;
695 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800696
697 len = unhex(p->data, 4);
Josh Gao7e6683c2016-01-15 14:35:54 -0800698 if ((len < 1) || (len > MAX_PAYLOAD_V1)) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700699 D("SS(%d): bad size (%d)", s->id, len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800700 goto fail;
701 }
702
Josh Gao52bd8522016-05-17 16:55:06 -0700703 D("SS(%d): len is %d", s->id, len);
Josh Gao7e6683c2016-01-15 14:35:54 -0800704 /* can't do anything until we have the full header */
Josh Gao52bd8522016-05-17 16:55:06 -0700705 if ((len + 4) > p->len) {
706 D("SS(%d): waiting for %d more bytes", s->id, len + 4 - p->len);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800707 return 0;
708 }
709
710 p->data[len + 4] = 0;
711
Josh Gao52bd8522016-05-17 16:55:06 -0700712 D("SS(%d): '%s'", s->id, (char*)(p->data + 4));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800713
714#if ADB_HOST
Josh Gao52bd8522016-05-17 16:55:06 -0700715 service = (char*)p->data + 4;
716 if (!strncmp(service, "host-serial:", strlen("host-serial:"))) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800717 char* serial_end;
718 service += strlen("host-serial:");
719
Terence Haddock28e13902011-03-16 09:43:56 +0100720 // serial number should follow "host:" and could be a host:port string.
David Pursell3f902aa2016-03-01 08:58:26 -0800721 serial_end = internal::skip_host_serial(service);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800722 if (serial_end) {
Josh Gao52bd8522016-05-17 16:55:06 -0700723 *serial_end = 0; // terminate string
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800724 serial = service;
725 service = serial_end + 1;
726 }
727 } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700728 type = kTransportUsb;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800729 service += strlen("host-usb:");
730 } else if (!strncmp(service, "host-local:", strlen("host-local:"))) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700731 type = kTransportLocal;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800732 service += strlen("host-local:");
733 } else if (!strncmp(service, "host:", strlen("host:"))) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700734 type = kTransportAny;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800735 service += strlen("host:");
736 } else {
Elliott Hughes8d28e192015-10-07 14:55:10 -0700737 service = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800738 }
739
740 if (service) {
Josh Gao52bd8522016-05-17 16:55:06 -0700741 asocket* s2;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800742
Josh Gao52bd8522016-05-17 16:55:06 -0700743 /* some requests are handled immediately -- in that
744 ** case the handle_host_request() routine has sent
745 ** the OKAY or FAIL message and all we have to do
746 ** is clean up.
747 */
748 if (handle_host_request(service, type, serial, s->peer->fd, s) == 0) {
749 /* XXX fail message? */
750 D("SS(%d): handled host service '%s'", s->id, service);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800751 goto fail;
752 }
753 if (!strncmp(service, "transport", strlen("transport"))) {
Josh Gao52bd8522016-05-17 16:55:06 -0700754 D("SS(%d): okay transport", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800755 p->len = 0;
756 return 0;
757 }
758
Josh Gao52bd8522016-05-17 16:55:06 -0700759 /* try to find a local service with this name.
760 ** if no such service exists, we'll fail out
761 ** and tear down here.
762 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800763 s2 = create_host_service_socket(service, serial);
Josh Gao52bd8522016-05-17 16:55:06 -0700764 if (s2 == 0) {
765 D("SS(%d): couldn't create host service '%s'", s->id, service);
Elliott Hughese67f1f82015-04-30 17:32:03 -0700766 SendFail(s->peer->fd, "unknown host service");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800767 goto fail;
768 }
769
Josh Gao52bd8522016-05-17 16:55:06 -0700770 /* we've connected to a local host service,
771 ** so we make our peer back into a regular
772 ** local socket and bind it to the new local
773 ** service socket, acknowledge the successful
774 ** connection, and close this smart socket now
775 ** that its work is done.
776 */
Elliott Hughese67f1f82015-04-30 17:32:03 -0700777 SendOkay(s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800778
779 s->peer->ready = local_socket_ready;
Elliott Hughes8d28e192015-10-07 14:55:10 -0700780 s->peer->shutdown = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800781 s->peer->close = local_socket_close;
782 s->peer->peer = s2;
783 s2->peer = s->peer;
784 s->peer = 0;
Josh Gao52bd8522016-05-17 16:55:06 -0700785 D("SS(%d): okay", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800786 s->close(s);
787
Josh Gao52bd8522016-05-17 16:55:06 -0700788 /* initial state is "ready" */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800789 s2->ready(s2);
790 return 0;
791 }
792#else /* !ADB_HOST */
Elliott Hughes8d28e192015-10-07 14:55:10 -0700793 if (s->transport == nullptr) {
Elliott Hughes7be29c82015-04-16 22:54:44 -0700794 std::string error_msg = "unknown failure";
Elliott Hughes8d28e192015-10-07 14:55:10 -0700795 s->transport = acquire_one_transport(kTransportAny, nullptr, nullptr, &error_msg);
796 if (s->transport == nullptr) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700797 SendFail(s->peer->fd, error_msg);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800798 goto fail;
799 }
800 }
801#endif
802
Josh Gao52bd8522016-05-17 16:55:06 -0700803 if (!(s->transport) || (s->transport->connection_state == kCsOffline)) {
804 /* if there's no remote we fail the connection
805 ** right here and terminate it
806 */
Elliott Hughese67f1f82015-04-30 17:32:03 -0700807 SendFail(s->peer->fd, "device offline (x)");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800808 goto fail;
809 }
810
Josh Gao52bd8522016-05-17 16:55:06 -0700811 /* instrument our peer to pass the success or fail
812 ** message back once it connects or closes, then
813 ** detach from it, request the connection, and
814 ** tear down
815 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800816 s->peer->ready = local_socket_ready_notify;
Elliott Hughes8d28e192015-10-07 14:55:10 -0700817 s->peer->shutdown = nullptr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800818 s->peer->close = local_socket_close_notify;
819 s->peer->peer = 0;
Josh Gao52bd8522016-05-17 16:55:06 -0700820 /* give him our transport and upref it */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800821 s->peer->transport = s->transport;
822
Josh Gao52bd8522016-05-17 16:55:06 -0700823 connect_to_remote(s->peer, (char*)(p->data + 4));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800824 s->peer = 0;
825 s->close(s);
826 return 1;
827
828fail:
Josh Gao52bd8522016-05-17 16:55:06 -0700829 /* we're going to close our peer as a side-effect, so
830 ** return -1 to signal that state to the local socket
831 ** who is enqueueing against us
832 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800833 s->close(s);
834 return -1;
835}
836
Josh Gao52bd8522016-05-17 16:55:06 -0700837static void smart_socket_ready(asocket* s) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700838 D("SS(%d): ready", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800839}
840
Josh Gao52bd8522016-05-17 16:55:06 -0700841static void smart_socket_close(asocket* s) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700842 D("SS(%d): closed", s->id);
Josh Gao52bd8522016-05-17 16:55:06 -0700843 if (s->pkt_first) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800844 put_apacket(s->pkt_first);
845 }
Josh Gao52bd8522016-05-17 16:55:06 -0700846 if (s->peer) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800847 s->peer->peer = 0;
848 s->peer->close(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500849 s->peer = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800850 }
851 free(s);
852}
853
Josh Gao52bd8522016-05-17 16:55:06 -0700854static asocket* create_smart_socket(void) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700855 D("Creating smart socket");
Josh Gao52bd8522016-05-17 16:55:06 -0700856 asocket* s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300857 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800858 s->enqueue = smart_socket_enqueue;
859 s->ready = smart_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100860 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800861 s->close = smart_socket_close;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800862
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700863 D("SS(%d)", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800864 return s;
865}
866
Josh Gao52bd8522016-05-17 16:55:06 -0700867void connect_to_smartsocket(asocket* s) {
Yabin Cui7a3f8d62015-09-02 17:44:28 -0700868 D("Connecting to smart socket");
Josh Gao52bd8522016-05-17 16:55:06 -0700869 asocket* ss = create_smart_socket();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800870 s->peer = ss;
871 ss->peer = s;
872 s->ready(s);
873}
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100874
875size_t asocket::get_max_payload() const {
876 size_t max_payload = MAX_PAYLOAD;
877 if (transport) {
878 max_payload = std::min(max_payload, transport->get_max_payload());
879 }
880 if (peer && peer->transport) {
881 max_payload = std::min(max_payload, peer->transport->get_max_payload());
882 }
883 return max_payload;
884}