sockets.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873
  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. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <unistd.h>
  19. #include <errno.h>
  20. #include <string.h>
  21. #include <ctype.h>
  22. #include "sysdeps.h"
  23. #define TRACE_TAG TRACE_SOCKETS
  24. #include "adb.h"
  25. ADB_MUTEX_DEFINE( socket_list_lock );
  26. static void local_socket_close_locked(asocket *s);
  27. int sendfailmsg(int fd, const char *reason)
  28. {
  29. char buf[9];
  30. int len;
  31. len = strlen(reason);
  32. if(len > 0xffff) len = 0xffff;
  33. snprintf(buf, sizeof buf, "FAIL%04x", len);
  34. if(writex(fd, buf, 8)) return -1;
  35. return writex(fd, reason, len);
  36. }
  37. //extern int online;
  38. static unsigned local_socket_next_id = 1;
  39. static asocket local_socket_list = {
  40. .next = &local_socket_list,
  41. .prev = &local_socket_list,
  42. };
  43. /* the the list of currently closing local sockets.
  44. ** these have no peer anymore, but still packets to
  45. ** write to their fd.
  46. */
  47. static asocket local_socket_closing_list = {
  48. .next = &local_socket_closing_list,
  49. .prev = &local_socket_closing_list,
  50. };
  51. asocket *find_local_socket(unsigned id)
  52. {
  53. asocket *s;
  54. asocket *result = NULL;
  55. adb_mutex_lock(&socket_list_lock);
  56. for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
  57. if (s->id == id) {
  58. result = s;
  59. break;
  60. }
  61. }
  62. adb_mutex_unlock(&socket_list_lock);
  63. return result;
  64. }
  65. static void
  66. insert_local_socket(asocket* s, asocket* list)
  67. {
  68. s->next = list;
  69. s->prev = s->next->prev;
  70. s->prev->next = s;
  71. s->next->prev = s;
  72. }
  73. void install_local_socket(asocket *s)
  74. {
  75. adb_mutex_lock(&socket_list_lock);
  76. s->id = local_socket_next_id++;
  77. insert_local_socket(s, &local_socket_list);
  78. adb_mutex_unlock(&socket_list_lock);
  79. }
  80. void remove_socket(asocket *s)
  81. {
  82. // socket_list_lock should already be held
  83. if (s->prev && s->next)
  84. {
  85. s->prev->next = s->next;
  86. s->next->prev = s->prev;
  87. s->next = 0;
  88. s->prev = 0;
  89. s->id = 0;
  90. }
  91. }
  92. void close_all_sockets(atransport *t)
  93. {
  94. asocket *s;
  95. /* this is a little gross, but since s->close() *will* modify
  96. ** the list out from under you, your options are limited.
  97. */
  98. adb_mutex_lock(&socket_list_lock);
  99. restart:
  100. for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
  101. if(s->transport == t || (s->peer && s->peer->transport == t)) {
  102. local_socket_close_locked(s);
  103. goto restart;
  104. }
  105. }
  106. adb_mutex_unlock(&socket_list_lock);
  107. }
  108. static int local_socket_enqueue(asocket *s, apacket *p)
  109. {
  110. D("LS(%d): enqueue %d\n", s->id, p->len);
  111. p->ptr = p->data;
  112. /* if there is already data queue'd, we will receive
  113. ** events when it's time to write. just add this to
  114. ** the tail
  115. */
  116. if(s->pkt_first) {
  117. goto enqueue;
  118. }
  119. /* write as much as we can, until we
  120. ** would block or there is an error/eof
  121. */
  122. while(p->len > 0) {
  123. int r = adb_write(s->fd, p->ptr, p->len);
  124. if(r > 0) {
  125. p->len -= r;
  126. p->ptr += r;
  127. continue;
  128. }
  129. if((r == 0) || (errno != EAGAIN)) {
  130. D( "LS(%d): not ready, errno=%d: %s\n", s->id, errno, strerror(errno) );
  131. s->close(s);
  132. return 1; /* not ready (error) */
  133. } else {
  134. break;
  135. }
  136. }
  137. if(p->len == 0) {
  138. put_apacket(p);
  139. return 0; /* ready for more data */
  140. }
  141. enqueue:
  142. p->next = 0;
  143. if(s->pkt_first) {
  144. s->pkt_last->next = p;
  145. } else {
  146. s->pkt_first = p;
  147. }
  148. s->pkt_last = p;
  149. /* make sure we are notified when we can drain the queue */
  150. fdevent_add(&s->fde, FDE_WRITE);
  151. return 1; /* not ready (backlog) */
  152. }
  153. static void local_socket_ready(asocket *s)
  154. {
  155. /* far side is ready for data, pay attention to
  156. readable events */
  157. fdevent_add(&s->fde, FDE_READ);
  158. // D("LS(%d): ready()\n", s->id);
  159. }
  160. static void local_socket_close(asocket *s)
  161. {
  162. adb_mutex_lock(&socket_list_lock);
  163. local_socket_close_locked(s);
  164. adb_mutex_unlock(&socket_list_lock);
  165. }
  166. // be sure to hold the socket list lock when calling this
  167. static void local_socket_destroy(asocket *s)
  168. {
  169. apacket *p, *n;
  170. int exit_on_close = s->exit_on_close;
  171. D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
  172. /* IMPORTANT: the remove closes the fd
  173. ** that belongs to this socket
  174. */
  175. fdevent_remove(&s->fde);
  176. /* dispose of any unwritten data */
  177. for(p = s->pkt_first; p; p = n) {
  178. D("LS(%d): discarding %d bytes\n", s->id, p->len);
  179. n = p->next;
  180. put_apacket(p);
  181. }
  182. remove_socket(s);
  183. free(s);
  184. if (exit_on_close) {
  185. D("local_socket_destroy: exiting\n");
  186. exit(1);
  187. }
  188. }
  189. static void local_socket_close_locked(asocket *s)
  190. {
  191. D("entered. LS(%d) fd=%d\n", s->id, s->fd);
  192. if(s->peer) {
  193. D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
  194. s->id, s->peer->id, s->peer->fd);
  195. s->peer->peer = 0;
  196. // tweak to avoid deadlock
  197. if (s->peer->close == local_socket_close) {
  198. local_socket_close_locked(s->peer);
  199. } else {
  200. s->peer->close(s->peer);
  201. }
  202. s->peer = 0;
  203. }
  204. /* If we are already closing, or if there are no
  205. ** pending packets, destroy immediately
  206. */
  207. if (s->closing || s->pkt_first == NULL) {
  208. int id = s->id;
  209. local_socket_destroy(s);
  210. D("LS(%d): closed\n", id);
  211. return;
  212. }
  213. /* otherwise, put on the closing list
  214. */
  215. D("LS(%d): closing\n", s->id);
  216. s->closing = 1;
  217. fdevent_del(&s->fde, FDE_READ);
  218. remove_socket(s);
  219. D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
  220. insert_local_socket(s, &local_socket_closing_list);
  221. }
  222. static void local_socket_event_func(int fd, unsigned ev, void *_s)
  223. {
  224. asocket *s = _s;
  225. D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
  226. /* put the FDE_WRITE processing before the FDE_READ
  227. ** in order to simplify the code.
  228. */
  229. if(ev & FDE_WRITE){
  230. apacket *p;
  231. while((p = s->pkt_first) != 0) {
  232. while(p->len > 0) {
  233. int r = adb_write(fd, p->ptr, p->len);
  234. if(r > 0) {
  235. p->ptr += r;
  236. p->len -= r;
  237. continue;
  238. }
  239. if(r < 0) {
  240. /* returning here is ok because FDE_READ will
  241. ** be processed in the next iteration loop
  242. */
  243. if(errno == EAGAIN) return;
  244. if(errno == EINTR) continue;
  245. }
  246. D(" closing after write because r=%d and errno is %d\n", r, errno);
  247. s->close(s);
  248. return;
  249. }
  250. if(p->len == 0) {
  251. s->pkt_first = p->next;
  252. if(s->pkt_first == 0) s->pkt_last = 0;
  253. put_apacket(p);
  254. }
  255. }
  256. /* if we sent the last packet of a closing socket,
  257. ** we can now destroy it.
  258. */
  259. if (s->closing) {
  260. D(" closing because 'closing' is set after write\n");
  261. s->close(s);
  262. return;
  263. }
  264. /* no more packets queued, so we can ignore
  265. ** writable events again and tell our peer
  266. ** to resume writing
  267. */
  268. fdevent_del(&s->fde, FDE_WRITE);
  269. s->peer->ready(s->peer);
  270. }
  271. if(ev & FDE_READ){
  272. apacket *p = get_apacket();
  273. unsigned char *x = p->data;
  274. size_t avail = MAX_PAYLOAD;
  275. int r;
  276. int is_eof = 0;
  277. while(avail > 0) {
  278. r = adb_read(fd, x, avail);
  279. D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%d\n", s->id, s->fd, r, r<0?errno:0, avail);
  280. if(r > 0) {
  281. avail -= r;
  282. x += r;
  283. continue;
  284. }
  285. if(r < 0) {
  286. if(errno == EAGAIN) break;
  287. if(errno == EINTR) continue;
  288. }
  289. /* r = 0 or unhandled error */
  290. is_eof = 1;
  291. break;
  292. }
  293. D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
  294. s->id, s->fd, r, is_eof, s->fde.force_eof);
  295. if((avail == MAX_PAYLOAD) || (s->peer == 0)) {
  296. put_apacket(p);
  297. } else {
  298. p->len = MAX_PAYLOAD - avail;
  299. r = s->peer->enqueue(s->peer, p);
  300. D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r);
  301. if(r < 0) {
  302. /* error return means they closed us as a side-effect
  303. ** and we must return immediately.
  304. **
  305. ** note that if we still have buffered packets, the
  306. ** socket will be placed on the closing socket list.
  307. ** this handler function will be called again
  308. ** to process FDE_WRITE events.
  309. */
  310. return;
  311. }
  312. if(r > 0) {
  313. /* if the remote cannot accept further events,
  314. ** we disable notification of READs. They'll
  315. ** be enabled again when we get a call to ready()
  316. */
  317. fdevent_del(&s->fde, FDE_READ);
  318. }
  319. }
  320. /* Don't allow a forced eof if data is still there */
  321. if((s->fde.force_eof && !r) || is_eof) {
  322. D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof);
  323. s->close(s);
  324. }
  325. }
  326. if(ev & FDE_ERROR){
  327. /* this should be caught be the next read or write
  328. ** catching it here means we may skip the last few
  329. ** bytes of readable data.
  330. */
  331. // s->close(s);
  332. D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
  333. return;
  334. }
  335. }
  336. asocket *create_local_socket(int fd)
  337. {
  338. asocket *s = calloc(1, sizeof(asocket));
  339. if (s == NULL) fatal("cannot allocate socket");
  340. s->fd = fd;
  341. s->enqueue = local_socket_enqueue;
  342. s->ready = local_socket_ready;
  343. s->close = local_socket_close;
  344. install_local_socket(s);
  345. fdevent_install(&s->fde, fd, local_socket_event_func, s);
  346. /* fdevent_add(&s->fde, FDE_ERROR); */
  347. //fprintf(stderr, "Created local socket in create_local_socket \n");
  348. D("LS(%d): created (fd=%d)\n", s->id, s->fd);
  349. return s;
  350. }
  351. asocket *create_local_service_socket(const char *name)
  352. {
  353. asocket *s;
  354. int fd;
  355. #if !ADB_HOST
  356. if (!strcmp(name,"jdwp")) {
  357. return create_jdwp_service_socket();
  358. }
  359. if (!strcmp(name,"track-jdwp")) {
  360. return create_jdwp_tracker_service_socket();
  361. }
  362. #endif
  363. fd = service_to_fd(name);
  364. if(fd < 0) return 0;
  365. s = create_local_socket(fd);
  366. D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
  367. #if !ADB_HOST
  368. if ((!strncmp(name, "root:", 5) && getuid() != 0)
  369. || !strncmp(name, "usb:", 4)
  370. || !strncmp(name, "tcpip:", 6)) {
  371. D("LS(%d): enabling exit_on_close\n", s->id);
  372. s->exit_on_close = 1;
  373. }
  374. #endif
  375. return s;
  376. }
  377. #if ADB_HOST
  378. static asocket *create_host_service_socket(const char *name, const char* serial)
  379. {
  380. asocket *s;
  381. s = host_service_to_socket(name, serial);
  382. if (s != NULL) {
  383. D("LS(%d) bound to '%s'\n", s->id, name);
  384. return s;
  385. }
  386. return s;
  387. }
  388. #endif /* ADB_HOST */
  389. /* a Remote socket is used to send/receive data to/from a given transport object
  390. ** it needs to be closed when the transport is forcibly destroyed by the user
  391. */
  392. typedef struct aremotesocket {
  393. asocket socket;
  394. adisconnect disconnect;
  395. } aremotesocket;
  396. static int remote_socket_enqueue(asocket *s, apacket *p)
  397. {
  398. D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
  399. s->id, s->fd, s->peer->fd);
  400. p->msg.command = A_WRTE;
  401. p->msg.arg0 = s->peer->id;
  402. p->msg.arg1 = s->id;
  403. p->msg.data_length = p->len;
  404. send_packet(p, s->transport);
  405. return 1;
  406. }
  407. static void remote_socket_ready(asocket *s)
  408. {
  409. D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
  410. s->id, s->fd, s->peer->fd);
  411. apacket *p = get_apacket();
  412. p->msg.command = A_OKAY;
  413. p->msg.arg0 = s->peer->id;
  414. p->msg.arg1 = s->id;
  415. send_packet(p, s->transport);
  416. }
  417. static void remote_socket_close(asocket *s)
  418. {
  419. D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
  420. s->id, s->fd, s->peer?s->peer->fd:-1);
  421. apacket *p = get_apacket();
  422. p->msg.command = A_CLSE;
  423. if(s->peer) {
  424. p->msg.arg0 = s->peer->id;
  425. s->peer->peer = 0;
  426. D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
  427. s->id, s->peer->id, s->peer->fd);
  428. s->peer->close(s->peer);
  429. }
  430. p->msg.arg1 = s->id;
  431. send_packet(p, s->transport);
  432. D("RS(%d): closed\n", s->id);
  433. remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
  434. free(s);
  435. }
  436. static void remote_socket_disconnect(void* _s, atransport* t)
  437. {
  438. asocket* s = _s;
  439. asocket* peer = s->peer;
  440. D("remote_socket_disconnect RS(%d)\n", s->id);
  441. if (peer) {
  442. peer->peer = NULL;
  443. peer->close(peer);
  444. }
  445. remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
  446. free(s);
  447. }
  448. asocket *create_remote_socket(unsigned id, atransport *t)
  449. {
  450. asocket *s = calloc(1, sizeof(aremotesocket));
  451. adisconnect* dis = &((aremotesocket*)s)->disconnect;
  452. if (s == NULL) fatal("cannot allocate socket");
  453. s->id = id;
  454. s->enqueue = remote_socket_enqueue;
  455. s->ready = remote_socket_ready;
  456. s->close = remote_socket_close;
  457. s->transport = t;
  458. dis->func = remote_socket_disconnect;
  459. dis->opaque = s;
  460. add_transport_disconnect( t, dis );
  461. D("RS(%d): created\n", s->id);
  462. return s;
  463. }
  464. void connect_to_remote(asocket *s, const char *destination)
  465. {
  466. D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
  467. apacket *p = get_apacket();
  468. int len = strlen(destination) + 1;
  469. if(len > (MAX_PAYLOAD-1)) {
  470. fatal("destination oversized");
  471. }
  472. D("LS(%d): connect('%s')\n", s->id, destination);
  473. p->msg.command = A_OPEN;
  474. p->msg.arg0 = s->id;
  475. p->msg.data_length = len;
  476. strcpy((char*) p->data, destination);
  477. send_packet(p, s->transport);
  478. }
  479. /* this is used by magic sockets to rig local sockets to
  480. send the go-ahead message when they connect */
  481. static void local_socket_ready_notify(asocket *s)
  482. {
  483. s->ready = local_socket_ready;
  484. s->close = local_socket_close;
  485. adb_write(s->fd, "OKAY", 4);
  486. s->ready(s);
  487. }
  488. /* this is used by magic sockets to rig local sockets to
  489. send the failure message if they are closed before
  490. connected (to avoid closing them without a status message) */
  491. static void local_socket_close_notify(asocket *s)
  492. {
  493. s->ready = local_socket_ready;
  494. s->close = local_socket_close;
  495. sendfailmsg(s->fd, "closed");
  496. s->close(s);
  497. }
  498. unsigned unhex(unsigned char *s, int len)
  499. {
  500. unsigned n = 0, c;
  501. while(len-- > 0) {
  502. switch((c = *s++)) {
  503. case '0': case '1': case '2':
  504. case '3': case '4': case '5':
  505. case '6': case '7': case '8':
  506. case '9':
  507. c -= '0';
  508. break;
  509. case 'a': case 'b': case 'c':
  510. case 'd': case 'e': case 'f':
  511. c = c - 'a' + 10;
  512. break;
  513. case 'A': case 'B': case 'C':
  514. case 'D': case 'E': case 'F':
  515. c = c - 'A' + 10;
  516. break;
  517. default:
  518. return 0xffffffff;
  519. }
  520. n = (n << 4) | c;
  521. }
  522. return n;
  523. }
  524. #define PREFIX(str) { str, sizeof(str) - 1 }
  525. static const struct prefix_struct {
  526. const char *str;
  527. const size_t len;
  528. } prefixes[] = {
  529. PREFIX("usb:"),
  530. PREFIX("product:"),
  531. PREFIX("model:"),
  532. PREFIX("device:"),
  533. };
  534. static const int num_prefixes = (sizeof(prefixes) / sizeof(prefixes[0]));
  535. /* skip_host_serial return the position in a string
  536. skipping over the 'serial' parameter in the ADB protocol,
  537. where parameter string may be a host:port string containing
  538. the protocol delimiter (colon). */
  539. char *skip_host_serial(char *service) {
  540. char *first_colon, *serial_end;
  541. int i;
  542. for (i = 0; i < num_prefixes; i++) {
  543. if (!strncmp(service, prefixes[i].str, prefixes[i].len))
  544. return strchr(service + prefixes[i].len, ':');
  545. }
  546. first_colon = strchr(service, ':');
  547. if (!first_colon) {
  548. /* No colon in service string. */
  549. return NULL;
  550. }
  551. serial_end = first_colon;
  552. if (isdigit(serial_end[1])) {
  553. serial_end++;
  554. while ((*serial_end) && isdigit(*serial_end)) {
  555. serial_end++;
  556. }
  557. if ((*serial_end) != ':') {
  558. // Something other than numbers was found, reset the end.
  559. serial_end = first_colon;
  560. }
  561. }
  562. return serial_end;
  563. }
  564. static int smart_socket_enqueue(asocket *s, apacket *p)
  565. {
  566. unsigned len;
  567. #if ADB_HOST
  568. char *service = NULL;
  569. char* serial = NULL;
  570. transport_type ttype = kTransportAny;
  571. #endif
  572. D("SS(%d): enqueue %d\n", s->id, p->len);
  573. if(s->pkt_first == 0) {
  574. s->pkt_first = p;
  575. s->pkt_last = p;
  576. } else {
  577. if((s->pkt_first->len + p->len) > MAX_PAYLOAD) {
  578. D("SS(%d): overflow\n", s->id);
  579. put_apacket(p);
  580. goto fail;
  581. }
  582. memcpy(s->pkt_first->data + s->pkt_first->len,
  583. p->data, p->len);
  584. s->pkt_first->len += p->len;
  585. put_apacket(p);
  586. p = s->pkt_first;
  587. }
  588. /* don't bother if we can't decode the length */
  589. if(p->len < 4) return 0;
  590. len = unhex(p->data, 4);
  591. if((len < 1) || (len > 1024)) {
  592. D("SS(%d): bad size (%d)\n", s->id, len);
  593. goto fail;
  594. }
  595. D("SS(%d): len is %d\n", s->id, len );
  596. /* can't do anything until we have the full header */
  597. if((len + 4) > p->len) {
  598. D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len);
  599. return 0;
  600. }
  601. p->data[len + 4] = 0;
  602. D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4));
  603. #if ADB_HOST
  604. service = (char *)p->data + 4;
  605. if(!strncmp(service, "host-serial:", strlen("host-serial:"))) {
  606. char* serial_end;
  607. service += strlen("host-serial:");
  608. // serial number should follow "host:" and could be a host:port string.
  609. serial_end = skip_host_serial(service);
  610. if (serial_end) {
  611. *serial_end = 0; // terminate string
  612. serial = service;
  613. service = serial_end + 1;
  614. }
  615. } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) {
  616. ttype = kTransportUsb;
  617. service += strlen("host-usb:");
  618. } else if (!strncmp(service, "host-local:", strlen("host-local:"))) {
  619. ttype = kTransportLocal;
  620. service += strlen("host-local:");
  621. } else if (!strncmp(service, "host:", strlen("host:"))) {
  622. ttype = kTransportAny;
  623. service += strlen("host:");
  624. } else {
  625. service = NULL;
  626. }
  627. if (service) {
  628. asocket *s2;
  629. /* some requests are handled immediately -- in that
  630. ** case the handle_host_request() routine has sent
  631. ** the OKAY or FAIL message and all we have to do
  632. ** is clean up.
  633. */
  634. if(handle_host_request(service, ttype, serial, s->peer->fd, s) == 0) {
  635. /* XXX fail message? */
  636. D( "SS(%d): handled host service '%s'\n", s->id, service );
  637. goto fail;
  638. }
  639. if (!strncmp(service, "transport", strlen("transport"))) {
  640. D( "SS(%d): okay transport\n", s->id );
  641. p->len = 0;
  642. return 0;
  643. }
  644. /* try to find a local service with this name.
  645. ** if no such service exists, we'll fail out
  646. ** and tear down here.
  647. */
  648. s2 = create_host_service_socket(service, serial);
  649. if(s2 == 0) {
  650. D( "SS(%d): couldn't create host service '%s'\n", s->id, service );
  651. sendfailmsg(s->peer->fd, "unknown host service");
  652. goto fail;
  653. }
  654. /* we've connected to a local host service,
  655. ** so we make our peer back into a regular
  656. ** local socket and bind it to the new local
  657. ** service socket, acknowledge the successful
  658. ** connection, and close this smart socket now
  659. ** that its work is done.
  660. */
  661. adb_write(s->peer->fd, "OKAY", 4);
  662. s->peer->ready = local_socket_ready;
  663. s->peer->close = local_socket_close;
  664. s->peer->peer = s2;
  665. s2->peer = s->peer;
  666. s->peer = 0;
  667. D( "SS(%d): okay\n", s->id );
  668. s->close(s);
  669. /* initial state is "ready" */
  670. s2->ready(s2);
  671. return 0;
  672. }
  673. #else /* !ADB_HOST */
  674. if (s->transport == NULL) {
  675. char* error_string = "unknown failure";
  676. s->transport = acquire_one_transport (CS_ANY,
  677. kTransportAny, NULL, &error_string);
  678. if (s->transport == NULL) {
  679. sendfailmsg(s->peer->fd, error_string);
  680. goto fail;
  681. }
  682. }
  683. #endif
  684. if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) {
  685. /* if there's no remote we fail the connection
  686. ** right here and terminate it
  687. */
  688. sendfailmsg(s->peer->fd, "device offline (x)");
  689. goto fail;
  690. }
  691. /* instrument our peer to pass the success or fail
  692. ** message back once it connects or closes, then
  693. ** detach from it, request the connection, and
  694. ** tear down
  695. */
  696. s->peer->ready = local_socket_ready_notify;
  697. s->peer->close = local_socket_close_notify;
  698. s->peer->peer = 0;
  699. /* give him our transport and upref it */
  700. s->peer->transport = s->transport;
  701. connect_to_remote(s->peer, (char*) (p->data + 4));
  702. s->peer = 0;
  703. s->close(s);
  704. return 1;
  705. fail:
  706. /* we're going to close our peer as a side-effect, so
  707. ** return -1 to signal that state to the local socket
  708. ** who is enqueueing against us
  709. */
  710. s->close(s);
  711. return -1;
  712. }
  713. static void smart_socket_ready(asocket *s)
  714. {
  715. D("SS(%d): ready\n", s->id);
  716. }
  717. static void smart_socket_close(asocket *s)
  718. {
  719. D("SS(%d): closed\n", s->id);
  720. if(s->pkt_first){
  721. put_apacket(s->pkt_first);
  722. }
  723. if(s->peer) {
  724. s->peer->peer = 0;
  725. s->peer->close(s->peer);
  726. s->peer = 0;
  727. }
  728. free(s);
  729. }
  730. asocket *create_smart_socket(void (*action_cb)(asocket *s, const char *act))
  731. {
  732. D("Creating smart socket \n");
  733. asocket *s = calloc(1, sizeof(asocket));
  734. if (s == NULL) fatal("cannot allocate socket");
  735. s->enqueue = smart_socket_enqueue;
  736. s->ready = smart_socket_ready;
  737. s->close = smart_socket_close;
  738. s->extra = action_cb;
  739. D("SS(%d): created %p\n", s->id, action_cb);
  740. return s;
  741. }
  742. void smart_socket_action(asocket *s, const char *act)
  743. {
  744. }
  745. void connect_to_smartsocket(asocket *s)
  746. {
  747. D("Connecting to smart socket \n");
  748. asocket *ss = create_smart_socket(smart_socket_action);
  749. s->peer = ss;
  750. ss->peer = s;
  751. s->ready(s);
  752. }