transport.c 30 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186
  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 <string.h>
  20. #include <errno.h>
  21. #include "sysdeps.h"
  22. #define TRACE_TAG TRACE_TRANSPORT
  23. #include "adb.h"
  24. static void transport_unref(atransport *t);
  25. static atransport transport_list = {
  26. .next = &transport_list,
  27. .prev = &transport_list,
  28. };
  29. ADB_MUTEX_DEFINE( transport_lock );
  30. #if ADB_TRACE
  31. #define MAX_DUMP_HEX_LEN 16
  32. static void dump_hex( const unsigned char* ptr, size_t len )
  33. {
  34. int nn, len2 = len;
  35. // Build a string instead of logging each character.
  36. // MAX chars in 2 digit hex, one space, MAX chars, one '\0'.
  37. char buffer[MAX_DUMP_HEX_LEN *2 + 1 + MAX_DUMP_HEX_LEN + 1 ], *pb = buffer;
  38. if (len2 > MAX_DUMP_HEX_LEN) len2 = MAX_DUMP_HEX_LEN;
  39. for (nn = 0; nn < len2; nn++) {
  40. sprintf(pb, "%02x", ptr[nn]);
  41. pb += 2;
  42. }
  43. sprintf(pb++, " ");
  44. for (nn = 0; nn < len2; nn++) {
  45. int c = ptr[nn];
  46. if (c < 32 || c > 127)
  47. c = '.';
  48. *pb++ = c;
  49. }
  50. *pb++ = '\0';
  51. DR("%s\n", buffer);
  52. }
  53. #endif
  54. void
  55. kick_transport(atransport* t)
  56. {
  57. if (t && !t->kicked)
  58. {
  59. int kicked;
  60. adb_mutex_lock(&transport_lock);
  61. kicked = t->kicked;
  62. if (!kicked)
  63. t->kicked = 1;
  64. adb_mutex_unlock(&transport_lock);
  65. if (!kicked)
  66. t->kick(t);
  67. }
  68. }
  69. void
  70. run_transport_disconnects(atransport* t)
  71. {
  72. adisconnect* dis = t->disconnects.next;
  73. D("%s: run_transport_disconnects\n", t->serial);
  74. while (dis != &t->disconnects) {
  75. adisconnect* next = dis->next;
  76. dis->func( dis->opaque, t );
  77. dis = next;
  78. }
  79. }
  80. #if ADB_TRACE
  81. static void
  82. dump_packet(const char* name, const char* func, apacket* p)
  83. {
  84. unsigned command = p->msg.command;
  85. int len = p->msg.data_length;
  86. char cmd[9];
  87. char arg0[12], arg1[12];
  88. int n;
  89. for (n = 0; n < 4; n++) {
  90. int b = (command >> (n*8)) & 255;
  91. if (b < 32 || b >= 127)
  92. break;
  93. cmd[n] = (char)b;
  94. }
  95. if (n == 4) {
  96. cmd[4] = 0;
  97. } else {
  98. /* There is some non-ASCII name in the command, so dump
  99. * the hexadecimal value instead */
  100. snprintf(cmd, sizeof cmd, "%08x", command);
  101. }
  102. if (p->msg.arg0 < 256U)
  103. snprintf(arg0, sizeof arg0, "%d", p->msg.arg0);
  104. else
  105. snprintf(arg0, sizeof arg0, "0x%x", p->msg.arg0);
  106. if (p->msg.arg1 < 256U)
  107. snprintf(arg1, sizeof arg1, "%d", p->msg.arg1);
  108. else
  109. snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);
  110. D("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
  111. name, func, cmd, arg0, arg1, len);
  112. dump_hex(p->data, len);
  113. }
  114. #endif /* ADB_TRACE */
  115. static int
  116. read_packet(int fd, const char* name, apacket** ppacket)
  117. {
  118. char *p = (char*)ppacket; /* really read a packet address */
  119. int r;
  120. int len = sizeof(*ppacket);
  121. char buff[8];
  122. if (!name) {
  123. snprintf(buff, sizeof buff, "fd=%d", fd);
  124. name = buff;
  125. }
  126. while(len > 0) {
  127. r = adb_read(fd, p, len);
  128. if(r > 0) {
  129. len -= r;
  130. p += r;
  131. } else {
  132. D("%s: read_packet (fd=%d), error ret=%d errno=%d: %s\n", name, fd, r, errno, strerror(errno));
  133. if((r < 0) && (errno == EINTR)) continue;
  134. return -1;
  135. }
  136. }
  137. #if ADB_TRACE
  138. if (ADB_TRACING) {
  139. dump_packet(name, "from remote", *ppacket);
  140. }
  141. #endif
  142. return 0;
  143. }
  144. static int
  145. write_packet(int fd, const char* name, apacket** ppacket)
  146. {
  147. char *p = (char*) ppacket; /* we really write the packet address */
  148. int r, len = sizeof(ppacket);
  149. char buff[8];
  150. if (!name) {
  151. snprintf(buff, sizeof buff, "fd=%d", fd);
  152. name = buff;
  153. }
  154. #if ADB_TRACE
  155. if (ADB_TRACING) {
  156. dump_packet(name, "to remote", *ppacket);
  157. }
  158. #endif
  159. len = sizeof(ppacket);
  160. while(len > 0) {
  161. r = adb_write(fd, p, len);
  162. if(r > 0) {
  163. len -= r;
  164. p += r;
  165. } else {
  166. D("%s: write_packet (fd=%d) error ret=%d errno=%d: %s\n", name, fd, r, errno, strerror(errno));
  167. if((r < 0) && (errno == EINTR)) continue;
  168. return -1;
  169. }
  170. }
  171. return 0;
  172. }
  173. static void transport_socket_events(int fd, unsigned events, void *_t)
  174. {
  175. atransport *t = _t;
  176. D("transport_socket_events(fd=%d, events=%04x,...)\n", fd, events);
  177. if(events & FDE_READ){
  178. apacket *p = 0;
  179. if(read_packet(fd, t->serial, &p)){
  180. D("%s: failed to read packet from transport socket on fd %d\n", t->serial, fd);
  181. } else {
  182. handle_packet(p, (atransport *) _t);
  183. }
  184. }
  185. }
  186. void send_packet(apacket *p, atransport *t)
  187. {
  188. unsigned char *x;
  189. unsigned sum;
  190. unsigned count;
  191. p->msg.magic = p->msg.command ^ 0xffffffff;
  192. count = p->msg.data_length;
  193. x = (unsigned char *) p->data;
  194. sum = 0;
  195. while(count-- > 0){
  196. sum += *x++;
  197. }
  198. p->msg.data_check = sum;
  199. print_packet("send", p);
  200. if (t == NULL) {
  201. D("Transport is null \n");
  202. // Zap errno because print_packet() and other stuff have errno effect.
  203. errno = 0;
  204. fatal_errno("Transport is null");
  205. }
  206. if(write_packet(t->transport_socket, t->serial, &p)){
  207. fatal_errno("cannot enqueue packet on transport socket");
  208. }
  209. }
  210. /* The transport is opened by transport_register_func before
  211. ** the input and output threads are started.
  212. **
  213. ** The output thread issues a SYNC(1, token) message to let
  214. ** the input thread know to start things up. In the event
  215. ** of transport IO failure, the output thread will post a
  216. ** SYNC(0,0) message to ensure shutdown.
  217. **
  218. ** The transport will not actually be closed until both
  219. ** threads exit, but the input thread will kick the transport
  220. ** on its way out to disconnect the underlying device.
  221. */
  222. static void *output_thread(void *_t)
  223. {
  224. atransport *t = _t;
  225. apacket *p;
  226. D("%s: starting transport output thread on fd %d, SYNC online (%d)\n",
  227. t->serial, t->fd, t->sync_token + 1);
  228. p = get_apacket();
  229. p->msg.command = A_SYNC;
  230. p->msg.arg0 = 1;
  231. p->msg.arg1 = ++(t->sync_token);
  232. p->msg.magic = A_SYNC ^ 0xffffffff;
  233. if(write_packet(t->fd, t->serial, &p)) {
  234. put_apacket(p);
  235. D("%s: failed to write SYNC packet\n", t->serial);
  236. goto oops;
  237. }
  238. D("%s: data pump started\n", t->serial);
  239. for(;;) {
  240. p = get_apacket();
  241. if(t->read_from_remote(p, t) == 0){
  242. D("%s: received remote packet, sending to transport\n",
  243. t->serial);
  244. if(write_packet(t->fd, t->serial, &p)){
  245. put_apacket(p);
  246. D("%s: failed to write apacket to transport\n", t->serial);
  247. goto oops;
  248. }
  249. } else {
  250. D("%s: remote read failed for transport\n", t->serial);
  251. put_apacket(p);
  252. break;
  253. }
  254. }
  255. D("%s: SYNC offline for transport\n", t->serial);
  256. p = get_apacket();
  257. p->msg.command = A_SYNC;
  258. p->msg.arg0 = 0;
  259. p->msg.arg1 = 0;
  260. p->msg.magic = A_SYNC ^ 0xffffffff;
  261. if(write_packet(t->fd, t->serial, &p)) {
  262. put_apacket(p);
  263. D("%s: failed to write SYNC apacket to transport", t->serial);
  264. }
  265. oops:
  266. D("%s: transport output thread is exiting\n", t->serial);
  267. kick_transport(t);
  268. transport_unref(t);
  269. return 0;
  270. }
  271. static void *input_thread(void *_t)
  272. {
  273. atransport *t = _t;
  274. apacket *p;
  275. int active = 0;
  276. D("%s: starting transport input thread, reading from fd %d\n",
  277. t->serial, t->fd);
  278. for(;;){
  279. if(read_packet(t->fd, t->serial, &p)) {
  280. D("%s: failed to read apacket from transport on fd %d\n",
  281. t->serial, t->fd );
  282. break;
  283. }
  284. if(p->msg.command == A_SYNC){
  285. if(p->msg.arg0 == 0) {
  286. D("%s: transport SYNC offline\n", t->serial);
  287. put_apacket(p);
  288. break;
  289. } else {
  290. if(p->msg.arg1 == t->sync_token) {
  291. D("%s: transport SYNC online\n", t->serial);
  292. active = 1;
  293. } else {
  294. D("%s: transport ignoring SYNC %d != %d\n",
  295. t->serial, p->msg.arg1, t->sync_token);
  296. }
  297. }
  298. } else {
  299. if(active) {
  300. D("%s: transport got packet, sending to remote\n", t->serial);
  301. t->write_to_remote(p, t);
  302. } else {
  303. D("%s: transport ignoring packet while offline\n", t->serial);
  304. }
  305. }
  306. put_apacket(p);
  307. }
  308. // this is necessary to avoid a race condition that occured when a transport closes
  309. // while a client socket is still active.
  310. close_all_sockets(t);
  311. D("%s: transport input thread is exiting, fd %d\n", t->serial, t->fd);
  312. kick_transport(t);
  313. transport_unref(t);
  314. return 0;
  315. }
  316. static int transport_registration_send = -1;
  317. static int transport_registration_recv = -1;
  318. static fdevent transport_registration_fde;
  319. #if ADB_HOST
  320. static int list_transports_msg(char* buffer, size_t bufferlen)
  321. {
  322. char head[5];
  323. int len;
  324. len = list_transports(buffer+4, bufferlen-4, 0);
  325. snprintf(head, sizeof(head), "%04x", len);
  326. memcpy(buffer, head, 4);
  327. len += 4;
  328. return len;
  329. }
  330. /* this adds support required by the 'track-devices' service.
  331. * this is used to send the content of "list_transport" to any
  332. * number of client connections that want it through a single
  333. * live TCP connection
  334. */
  335. typedef struct device_tracker device_tracker;
  336. struct device_tracker {
  337. asocket socket;
  338. int update_needed;
  339. device_tracker* next;
  340. };
  341. /* linked list of all device trackers */
  342. static device_tracker* device_tracker_list;
  343. static void
  344. device_tracker_remove( device_tracker* tracker )
  345. {
  346. device_tracker** pnode = &device_tracker_list;
  347. device_tracker* node = *pnode;
  348. adb_mutex_lock( &transport_lock );
  349. while (node) {
  350. if (node == tracker) {
  351. *pnode = node->next;
  352. break;
  353. }
  354. pnode = &node->next;
  355. node = *pnode;
  356. }
  357. adb_mutex_unlock( &transport_lock );
  358. }
  359. static void
  360. device_tracker_close( asocket* socket )
  361. {
  362. device_tracker* tracker = (device_tracker*) socket;
  363. asocket* peer = socket->peer;
  364. D( "device tracker %p removed\n", tracker);
  365. if (peer) {
  366. peer->peer = NULL;
  367. peer->close(peer);
  368. }
  369. device_tracker_remove(tracker);
  370. free(tracker);
  371. }
  372. static int
  373. device_tracker_enqueue( asocket* socket, apacket* p )
  374. {
  375. /* you can't read from a device tracker, close immediately */
  376. put_apacket(p);
  377. device_tracker_close(socket);
  378. return -1;
  379. }
  380. static int
  381. device_tracker_send( device_tracker* tracker,
  382. const char* buffer,
  383. int len )
  384. {
  385. apacket* p = get_apacket();
  386. asocket* peer = tracker->socket.peer;
  387. memcpy(p->data, buffer, len);
  388. p->len = len;
  389. return peer->enqueue( peer, p );
  390. }
  391. static void
  392. device_tracker_ready( asocket* socket )
  393. {
  394. device_tracker* tracker = (device_tracker*) socket;
  395. /* we want to send the device list when the tracker connects
  396. * for the first time, even if no update occured */
  397. if (tracker->update_needed > 0) {
  398. char buffer[1024];
  399. int len;
  400. tracker->update_needed = 0;
  401. len = list_transports_msg(buffer, sizeof(buffer));
  402. device_tracker_send(tracker, buffer, len);
  403. }
  404. }
  405. asocket*
  406. create_device_tracker(void)
  407. {
  408. device_tracker* tracker = calloc(1,sizeof(*tracker));
  409. if(tracker == 0) fatal("cannot allocate device tracker");
  410. D( "device tracker %p created\n", tracker);
  411. tracker->socket.enqueue = device_tracker_enqueue;
  412. tracker->socket.ready = device_tracker_ready;
  413. tracker->socket.close = device_tracker_close;
  414. tracker->update_needed = 1;
  415. tracker->next = device_tracker_list;
  416. device_tracker_list = tracker;
  417. return &tracker->socket;
  418. }
  419. /* call this function each time the transport list has changed */
  420. void update_transports(void)
  421. {
  422. char buffer[1024];
  423. int len;
  424. device_tracker* tracker;
  425. len = list_transports_msg(buffer, sizeof(buffer));
  426. tracker = device_tracker_list;
  427. while (tracker != NULL) {
  428. device_tracker* next = tracker->next;
  429. /* note: this may destroy the tracker if the connection is closed */
  430. device_tracker_send(tracker, buffer, len);
  431. tracker = next;
  432. }
  433. }
  434. #else
  435. void update_transports(void)
  436. {
  437. // nothing to do on the device side
  438. }
  439. #endif // ADB_HOST
  440. typedef struct tmsg tmsg;
  441. struct tmsg
  442. {
  443. atransport *transport;
  444. int action;
  445. };
  446. static int
  447. transport_read_action(int fd, struct tmsg* m)
  448. {
  449. char *p = (char*)m;
  450. int len = sizeof(*m);
  451. int r;
  452. while(len > 0) {
  453. r = adb_read(fd, p, len);
  454. if(r > 0) {
  455. len -= r;
  456. p += r;
  457. } else {
  458. if((r < 0) && (errno == EINTR)) continue;
  459. D("transport_read_action: on fd %d, error %d: %s\n",
  460. fd, errno, strerror(errno));
  461. return -1;
  462. }
  463. }
  464. return 0;
  465. }
  466. static int
  467. transport_write_action(int fd, struct tmsg* m)
  468. {
  469. char *p = (char*)m;
  470. int len = sizeof(*m);
  471. int r;
  472. while(len > 0) {
  473. r = adb_write(fd, p, len);
  474. if(r > 0) {
  475. len -= r;
  476. p += r;
  477. } else {
  478. if((r < 0) && (errno == EINTR)) continue;
  479. D("transport_write_action: on fd %d, error %d: %s\n",
  480. fd, errno, strerror(errno));
  481. return -1;
  482. }
  483. }
  484. return 0;
  485. }
  486. static void transport_registration_func(int _fd, unsigned ev, void *data)
  487. {
  488. tmsg m;
  489. adb_thread_t output_thread_ptr;
  490. adb_thread_t input_thread_ptr;
  491. int s[2];
  492. atransport *t;
  493. if(!(ev & FDE_READ)) {
  494. return;
  495. }
  496. if(transport_read_action(_fd, &m)) {
  497. fatal_errno("cannot read transport registration socket");
  498. }
  499. t = m.transport;
  500. if(m.action == 0){
  501. D("transport: %s removing and free'ing %d\n", t->serial, t->transport_socket);
  502. /* IMPORTANT: the remove closes one half of the
  503. ** socket pair. The close closes the other half.
  504. */
  505. fdevent_remove(&(t->transport_fde));
  506. adb_close(t->fd);
  507. adb_mutex_lock(&transport_lock);
  508. t->next->prev = t->prev;
  509. t->prev->next = t->next;
  510. adb_mutex_unlock(&transport_lock);
  511. run_transport_disconnects(t);
  512. if (t->product)
  513. free(t->product);
  514. if (t->serial)
  515. free(t->serial);
  516. if (t->model)
  517. free(t->model);
  518. if (t->device)
  519. free(t->device);
  520. if (t->devpath)
  521. free(t->devpath);
  522. memset(t,0xee,sizeof(atransport));
  523. free(t);
  524. update_transports();
  525. return;
  526. }
  527. /* don't create transport threads for inaccessible devices */
  528. if (t->connection_state != CS_NOPERM) {
  529. /* initial references are the two threads */
  530. t->ref_count = 2;
  531. if(adb_socketpair(s)) {
  532. fatal_errno("cannot open transport socketpair");
  533. }
  534. D("transport: %s (%d,%d) starting\n", t->serial, s[0], s[1]);
  535. t->transport_socket = s[0];
  536. t->fd = s[1];
  537. fdevent_install(&(t->transport_fde),
  538. t->transport_socket,
  539. transport_socket_events,
  540. t);
  541. fdevent_set(&(t->transport_fde), FDE_READ);
  542. if(adb_thread_create(&input_thread_ptr, input_thread, t)){
  543. fatal_errno("cannot create input thread");
  544. }
  545. if(adb_thread_create(&output_thread_ptr, output_thread, t)){
  546. fatal_errno("cannot create output thread");
  547. }
  548. }
  549. /* put us on the master device list */
  550. adb_mutex_lock(&transport_lock);
  551. t->next = &transport_list;
  552. t->prev = transport_list.prev;
  553. t->next->prev = t;
  554. t->prev->next = t;
  555. adb_mutex_unlock(&transport_lock);
  556. t->disconnects.next = t->disconnects.prev = &t->disconnects;
  557. update_transports();
  558. }
  559. void init_transport_registration(void)
  560. {
  561. int s[2];
  562. if(adb_socketpair(s)){
  563. fatal_errno("cannot open transport registration socketpair");
  564. }
  565. transport_registration_send = s[0];
  566. transport_registration_recv = s[1];
  567. fdevent_install(&transport_registration_fde,
  568. transport_registration_recv,
  569. transport_registration_func,
  570. 0);
  571. fdevent_set(&transport_registration_fde, FDE_READ);
  572. }
  573. /* the fdevent select pump is single threaded */
  574. static void register_transport(atransport *transport)
  575. {
  576. tmsg m;
  577. m.transport = transport;
  578. m.action = 1;
  579. D("transport: %s registered\n", transport->serial);
  580. if(transport_write_action(transport_registration_send, &m)) {
  581. fatal_errno("cannot write transport registration socket\n");
  582. }
  583. }
  584. static void remove_transport(atransport *transport)
  585. {
  586. tmsg m;
  587. m.transport = transport;
  588. m.action = 0;
  589. D("transport: %s removed\n", transport->serial);
  590. if(transport_write_action(transport_registration_send, &m)) {
  591. fatal_errno("cannot write transport registration socket\n");
  592. }
  593. }
  594. static void transport_unref_locked(atransport *t)
  595. {
  596. t->ref_count--;
  597. if (t->ref_count == 0) {
  598. D("transport: %s unref (kicking and closing)\n", t->serial);
  599. if (!t->kicked) {
  600. t->kicked = 1;
  601. t->kick(t);
  602. }
  603. t->close(t);
  604. remove_transport(t);
  605. } else {
  606. D("transport: %s unref (count=%d)\n", t->serial, t->ref_count);
  607. }
  608. }
  609. static void transport_unref(atransport *t)
  610. {
  611. if (t) {
  612. adb_mutex_lock(&transport_lock);
  613. transport_unref_locked(t);
  614. adb_mutex_unlock(&transport_lock);
  615. }
  616. }
  617. void add_transport_disconnect(atransport* t, adisconnect* dis)
  618. {
  619. adb_mutex_lock(&transport_lock);
  620. dis->next = &t->disconnects;
  621. dis->prev = dis->next->prev;
  622. dis->prev->next = dis;
  623. dis->next->prev = dis;
  624. adb_mutex_unlock(&transport_lock);
  625. }
  626. void remove_transport_disconnect(atransport* t, adisconnect* dis)
  627. {
  628. dis->prev->next = dis->next;
  629. dis->next->prev = dis->prev;
  630. dis->next = dis->prev = dis;
  631. }
  632. static int qual_char_is_invalid(char ch)
  633. {
  634. if ('A' <= ch && ch <= 'Z')
  635. return 0;
  636. if ('a' <= ch && ch <= 'z')
  637. return 0;
  638. if ('0' <= ch && ch <= '9')
  639. return 0;
  640. return 1;
  641. }
  642. static int qual_match(const char *to_test,
  643. const char *prefix, const char *qual, int sanitize_qual)
  644. {
  645. if (!to_test || !*to_test)
  646. /* Return true if both the qual and to_test are null strings. */
  647. return !qual || !*qual;
  648. if (!qual)
  649. return 0;
  650. if (prefix) {
  651. while (*prefix) {
  652. if (*prefix++ != *to_test++)
  653. return 0;
  654. }
  655. }
  656. while (*qual) {
  657. char ch = *qual++;
  658. if (sanitize_qual && qual_char_is_invalid(ch))
  659. ch = '_';
  660. if (ch != *to_test++)
  661. return 0;
  662. }
  663. /* Everything matched so far. Return true if *to_test is a NUL. */
  664. return !*to_test;
  665. }
  666. atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char** error_out)
  667. {
  668. atransport *t;
  669. atransport *result = NULL;
  670. int ambiguous = 0;
  671. retry:
  672. if (error_out)
  673. *error_out = "device not found";
  674. adb_mutex_lock(&transport_lock);
  675. for (t = transport_list.next; t != &transport_list; t = t->next) {
  676. if (t->connection_state == CS_NOPERM) {
  677. if (error_out)
  678. *error_out = "insufficient permissions for device";
  679. continue;
  680. }
  681. /* check for matching serial number */
  682. if (serial) {
  683. if ((t->serial && !strcmp(serial, t->serial)) ||
  684. (t->devpath && !strcmp(serial, t->devpath)) ||
  685. qual_match(serial, "product:", t->product, 0) ||
  686. qual_match(serial, "model:", t->model, 1) ||
  687. qual_match(serial, "device:", t->device, 0)) {
  688. if (result) {
  689. if (error_out)
  690. *error_out = "more than one device";
  691. ambiguous = 1;
  692. result = NULL;
  693. break;
  694. }
  695. result = t;
  696. }
  697. } else {
  698. if (ttype == kTransportUsb && t->type == kTransportUsb) {
  699. if (result) {
  700. if (error_out)
  701. *error_out = "more than one device";
  702. ambiguous = 1;
  703. result = NULL;
  704. break;
  705. }
  706. result = t;
  707. } else if (ttype == kTransportLocal && t->type == kTransportLocal) {
  708. if (result) {
  709. if (error_out)
  710. *error_out = "more than one emulator";
  711. ambiguous = 1;
  712. result = NULL;
  713. break;
  714. }
  715. result = t;
  716. } else if (ttype == kTransportAny) {
  717. if (result) {
  718. if (error_out)
  719. *error_out = "more than one device and emulator";
  720. ambiguous = 1;
  721. result = NULL;
  722. break;
  723. }
  724. result = t;
  725. }
  726. }
  727. }
  728. adb_mutex_unlock(&transport_lock);
  729. if (result) {
  730. /* offline devices are ignored -- they are either being born or dying */
  731. if (result && result->connection_state == CS_OFFLINE) {
  732. if (error_out)
  733. *error_out = "device offline";
  734. result = NULL;
  735. }
  736. /* check for required connection state */
  737. if (result && state != CS_ANY && result->connection_state != state) {
  738. if (error_out)
  739. *error_out = "invalid device state";
  740. result = NULL;
  741. }
  742. }
  743. if (result) {
  744. /* found one that we can take */
  745. if (error_out)
  746. *error_out = NULL;
  747. } else if (state != CS_ANY && (serial || !ambiguous)) {
  748. adb_sleep_ms(1000);
  749. goto retry;
  750. }
  751. return result;
  752. }
  753. #if ADB_HOST
  754. static const char *statename(atransport *t)
  755. {
  756. switch(t->connection_state){
  757. case CS_OFFLINE: return "offline";
  758. case CS_BOOTLOADER: return "bootloader";
  759. case CS_DEVICE: return "device";
  760. case CS_HOST: return "host";
  761. case CS_RECOVERY: return "recovery";
  762. case CS_SIDELOAD: return "sideload";
  763. case CS_NOPERM: return "no permissions";
  764. default: return "unknown";
  765. }
  766. }
  767. static void add_qual(char **buf, size_t *buf_size,
  768. const char *prefix, const char *qual, int sanitize_qual)
  769. {
  770. size_t len;
  771. int prefix_len;
  772. if (!buf || !*buf || !buf_size || !*buf_size || !qual || !*qual)
  773. return;
  774. len = snprintf(*buf, *buf_size, "%s%n%s", prefix, &prefix_len, qual);
  775. if (sanitize_qual) {
  776. char *cp;
  777. for (cp = *buf + prefix_len; cp < *buf + len; cp++) {
  778. if (qual_char_is_invalid(*cp))
  779. *cp = '_';
  780. }
  781. }
  782. *buf_size -= len;
  783. *buf += len;
  784. }
  785. static size_t format_transport(atransport *t, char *buf, size_t bufsize,
  786. int long_listing)
  787. {
  788. const char* serial = t->serial;
  789. if (!serial || !serial[0])
  790. serial = "????????????";
  791. if (!long_listing) {
  792. return snprintf(buf, bufsize, "%s\t%s\n", serial, statename(t));
  793. } else {
  794. size_t len, remaining = bufsize;
  795. len = snprintf(buf, remaining, "%-22s %s", serial, statename(t));
  796. remaining -= len;
  797. buf += len;
  798. add_qual(&buf, &remaining, " ", t->devpath, 0);
  799. add_qual(&buf, &remaining, " product:", t->product, 0);
  800. add_qual(&buf, &remaining, " model:", t->model, 1);
  801. add_qual(&buf, &remaining, " device:", t->device, 0);
  802. len = snprintf(buf, remaining, "\n");
  803. remaining -= len;
  804. return bufsize - remaining;
  805. }
  806. }
  807. int list_transports(char *buf, size_t bufsize, int long_listing)
  808. {
  809. char* p = buf;
  810. char* end = buf + bufsize;
  811. int len;
  812. atransport *t;
  813. /* XXX OVERRUN PROBLEMS XXX */
  814. adb_mutex_lock(&transport_lock);
  815. for(t = transport_list.next; t != &transport_list; t = t->next) {
  816. len = format_transport(t, p, end - p, long_listing);
  817. if (p + len >= end) {
  818. /* discard last line if buffer is too short */
  819. break;
  820. }
  821. p += len;
  822. }
  823. p[0] = 0;
  824. adb_mutex_unlock(&transport_lock);
  825. return p - buf;
  826. }
  827. /* hack for osx */
  828. void close_usb_devices()
  829. {
  830. atransport *t;
  831. adb_mutex_lock(&transport_lock);
  832. for(t = transport_list.next; t != &transport_list; t = t->next) {
  833. if ( !t->kicked ) {
  834. t->kicked = 1;
  835. t->kick(t);
  836. }
  837. }
  838. adb_mutex_unlock(&transport_lock);
  839. }
  840. #endif // ADB_HOST
  841. void register_socket_transport(int s, const char *serial, int port, int local)
  842. {
  843. atransport *t = calloc(1, sizeof(atransport));
  844. char buff[32];
  845. if (!serial) {
  846. snprintf(buff, sizeof buff, "T-%p", t);
  847. serial = buff;
  848. }
  849. D("transport: %s init'ing for socket %d, on port %d\n", serial, s, port);
  850. if ( init_socket_transport(t, s, port, local) < 0 ) {
  851. adb_close(s);
  852. free(t);
  853. return;
  854. }
  855. if(serial) {
  856. t->serial = strdup(serial);
  857. }
  858. register_transport(t);
  859. }
  860. #if ADB_HOST
  861. atransport *find_transport(const char *serial)
  862. {
  863. atransport *t;
  864. adb_mutex_lock(&transport_lock);
  865. for(t = transport_list.next; t != &transport_list; t = t->next) {
  866. if (t->serial && !strcmp(serial, t->serial)) {
  867. break;
  868. }
  869. }
  870. adb_mutex_unlock(&transport_lock);
  871. if (t != &transport_list)
  872. return t;
  873. else
  874. return 0;
  875. }
  876. void unregister_transport(atransport *t)
  877. {
  878. adb_mutex_lock(&transport_lock);
  879. t->next->prev = t->prev;
  880. t->prev->next = t->next;
  881. adb_mutex_unlock(&transport_lock);
  882. kick_transport(t);
  883. transport_unref(t);
  884. }
  885. // unregisters all non-emulator TCP transports
  886. void unregister_all_tcp_transports()
  887. {
  888. atransport *t, *next;
  889. adb_mutex_lock(&transport_lock);
  890. for (t = transport_list.next; t != &transport_list; t = next) {
  891. next = t->next;
  892. if (t->type == kTransportLocal && t->adb_port == 0) {
  893. t->next->prev = t->prev;
  894. t->prev->next = next;
  895. // we cannot call kick_transport when holding transport_lock
  896. if (!t->kicked)
  897. {
  898. t->kicked = 1;
  899. t->kick(t);
  900. }
  901. transport_unref_locked(t);
  902. }
  903. }
  904. adb_mutex_unlock(&transport_lock);
  905. }
  906. #endif
  907. void register_usb_transport(usb_handle *usb, const char *serial, const char *devpath, unsigned writeable)
  908. {
  909. atransport *t = calloc(1, sizeof(atransport));
  910. D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb,
  911. serial ? serial : "");
  912. init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM));
  913. if(serial) {
  914. t->serial = strdup(serial);
  915. }
  916. if(devpath) {
  917. t->devpath = strdup(devpath);
  918. }
  919. register_transport(t);
  920. }
  921. /* this should only be used for transports with connection_state == CS_NOPERM */
  922. void unregister_usb_transport(usb_handle *usb)
  923. {
  924. atransport *t;
  925. adb_mutex_lock(&transport_lock);
  926. for(t = transport_list.next; t != &transport_list; t = t->next) {
  927. if (t->usb == usb && t->connection_state == CS_NOPERM) {
  928. t->next->prev = t->prev;
  929. t->prev->next = t->next;
  930. break;
  931. }
  932. }
  933. adb_mutex_unlock(&transport_lock);
  934. }
  935. #undef TRACE_TAG
  936. #define TRACE_TAG TRACE_RWX
  937. int readx(int fd, void *ptr, size_t len)
  938. {
  939. char *p = ptr;
  940. int r;
  941. #if ADB_TRACE
  942. int len0 = len;
  943. #endif
  944. D("readx: fd=%d wanted=%d\n", fd, (int)len);
  945. while(len > 0) {
  946. r = adb_read(fd, p, len);
  947. if(r > 0) {
  948. len -= r;
  949. p += r;
  950. } else {
  951. if (r < 0) {
  952. D("readx: fd=%d error %d: %s\n", fd, errno, strerror(errno));
  953. if (errno == EINTR)
  954. continue;
  955. } else {
  956. D("readx: fd=%d disconnected\n", fd);
  957. }
  958. return -1;
  959. }
  960. }
  961. #if ADB_TRACE
  962. D("readx: fd=%d wanted=%d got=%d\n", fd, len0, len0 - len);
  963. dump_hex( ptr, len0 );
  964. #endif
  965. return 0;
  966. }
  967. int writex(int fd, const void *ptr, size_t len)
  968. {
  969. char *p = (char*) ptr;
  970. int r;
  971. #if ADB_TRACE
  972. D("writex: fd=%d len=%d: ", fd, (int)len);
  973. dump_hex( ptr, len );
  974. #endif
  975. while(len > 0) {
  976. r = adb_write(fd, p, len);
  977. if(r > 0) {
  978. len -= r;
  979. p += r;
  980. } else {
  981. if (r < 0) {
  982. D("writex: fd=%d error %d: %s\n", fd, errno, strerror(errno));
  983. if (errno == EINTR)
  984. continue;
  985. } else {
  986. D("writex: fd=%d disconnected\n", fd);
  987. }
  988. return -1;
  989. }
  990. }
  991. return 0;
  992. }
  993. int check_header(apacket *p)
  994. {
  995. if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
  996. D("check_header(): invalid magic\n");
  997. return -1;
  998. }
  999. if(p->msg.data_length > MAX_PAYLOAD) {
  1000. D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length);
  1001. return -1;
  1002. }
  1003. return 0;
  1004. }
  1005. int check_data(apacket *p)
  1006. {
  1007. unsigned count, sum;
  1008. unsigned char *x;
  1009. count = p->msg.data_length;
  1010. x = p->data;
  1011. sum = 0;
  1012. while(count-- > 0) {
  1013. sum += *x++;
  1014. }
  1015. if(sum != p->msg.data_check) {
  1016. return -1;
  1017. } else {
  1018. return 0;
  1019. }
  1020. }