1 /* implement the "debug-ports" and "track-debug-ports" device services */
2 #include "sysdeps.h"
3 #define TRACE_TAG TRACE_JDWP
4 #include "adb.h"
5 #include <errno.h>
6 #include <stdio.h>
7 #include <string.h>
8 #include <unistd.h>
9
10 /* here's how these things work.
11
12 when adbd starts, it creates a unix server socket
13 named @vm-debug-control (@ is a shortcut for "first byte is zero"
14 to use the private namespace instead of the file system)
15
16 when a new JDWP daemon thread starts in a new VM process, it creates
17 a connection to @vm-debug-control to announce its availability.
18
19
20 JDWP thread @vm-debug-control
21 | |
22 |-------------------------------> |
23 | hello I'm in process <pid> |
24 | |
25 | |
26
27 the connection is kept alive. it will be closed automatically if
28 the JDWP process terminates (this allows adbd to detect dead
29 processes).
30
31 adbd thus maintains a list of "active" JDWP processes. it can send
32 its content to clients through the "device:debug-ports" service,
33 or even updates through the "device:track-debug-ports" service.
34
35 when a debugger wants to connect, it simply runs the command
36 equivalent to "adb forward tcp:<hostport> jdwp:<pid>"
37
38 "jdwp:<pid>" is a new forward destination format used to target
39 a given JDWP process on the device. when sutch a request arrives,
40 adbd does the following:
41
42 - first, it calls socketpair() to create a pair of equivalent
43 sockets.
44
45 - it attaches the first socket in the pair to a local socket
46 which is itself attached to the transport's remote socket:
47
48
49 - it sends the file descriptor of the second socket directly
50 to the JDWP process with the help of sendmsg()
51
52
53 JDWP thread @vm-debug-control
54 | |
55 | <----------------------|
56 | OK, try this file descriptor |
57 | |
58 | |
59
60 then, the JDWP thread uses this new socket descriptor as its
61 pass-through connection to the debugger (and receives the
62 JDWP-Handshake message, answers to it, etc...)
63
64 this gives the following graphics:
65 ____________________________________
66 | |
67 | ADB Server (host) |
68 | |
69 Debugger <---> LocalSocket <----> RemoteSocket |
70 | ^^ |
71 |___________________________||_______|
72 ||
73 Transport ||
74 (TCP for emulator - USB for device) ||
75 ||
76 ___________________________||_______
77 | || |
78 | ADBD (device) || |
79 | VV |
80 JDWP <======> LocalSocket <----> RemoteSocket |
81 | |
82 |____________________________________|
83
84 due to the way adb works, this doesn't need a special socket
85 type or fancy handling of socket termination if either the debugger
86 or the JDWP process closes the connection.
87
88 THIS IS THE SIMPLEST IMPLEMENTATION I COULD FIND, IF YOU HAPPEN
89 TO HAVE A BETTER IDEA, LET ME KNOW - Digit
90
91 **********************************************************************/
92
93 /** JDWP PID List Support Code
94 ** for each JDWP process, we record its pid and its connected socket
95 **/
96
97 #define MAX_OUT_FDS 4
98
99 #if !ADB_HOST
100
101 #include <sys/socket.h>
102 #include <sys/un.h>
103
104 typedef struct JdwpProcess JdwpProcess;
105 struct JdwpProcess {
106 JdwpProcess* next;
107 JdwpProcess* prev;
108 int pid;
109 int socket;
110 fdevent* fde;
111
112 char in_buff[4]; /* input character to read PID */
113 int in_len; /* number from JDWP process */
114
115 int out_fds[MAX_OUT_FDS]; /* output array of file descriptors */
116 int out_count; /* to send to the JDWP process */
117 };
118
119 static JdwpProcess _jdwp_list;
120
121 static int
jdwp_process_list(char * buffer,int bufferlen)122 jdwp_process_list( char* buffer, int bufferlen )
123 {
124 char* end = buffer + bufferlen;
125 char* p = buffer;
126 JdwpProcess* proc = _jdwp_list.next;
127
128 for ( ; proc != &_jdwp_list; proc = proc->next ) {
129 int len;
130
131 /* skip transient connections */
132 if (proc->pid < 0)
133 continue;
134
135 len = snprintf(p, end-p, "%d\n", proc->pid);
136 if (p + len >= end)
137 break;
138 p += len;
139 }
140 p[0] = 0;
141 return (p - buffer);
142 }
143
144
145 static int
jdwp_process_list_msg(char * buffer,int bufferlen)146 jdwp_process_list_msg( char* buffer, int bufferlen )
147 {
148 char head[5];
149 int len = jdwp_process_list( buffer+4, bufferlen-4 );
150 snprintf(head, sizeof head, "%04x", len);
151 memcpy(buffer, head, 4);
152 return len + 4;
153 }
154
155
156 static void jdwp_process_list_updated(void);
157
158 static void
jdwp_process_free(JdwpProcess * proc)159 jdwp_process_free( JdwpProcess* proc )
160 {
161 if (proc) {
162 int n;
163
164 proc->prev->next = proc->next;
165 proc->next->prev = proc->prev;
166
167 if (proc->socket >= 0) {
168 adb_shutdown(proc->socket);
169 adb_close(proc->socket);
170 proc->socket = -1;
171 }
172
173 if (proc->fde != NULL) {
174 fdevent_destroy(proc->fde);
175 proc->fde = NULL;
176 }
177 proc->pid = -1;
178
179 for (n = 0; n < proc->out_count; n++) {
180 adb_close(proc->out_fds[n]);
181 }
182 proc->out_count = 0;
183
184 free(proc);
185
186 jdwp_process_list_updated();
187 }
188 }
189
190
191 static void jdwp_process_event(int, unsigned, void*); /* forward */
192
193
194 static JdwpProcess*
jdwp_process_alloc(int socket)195 jdwp_process_alloc( int socket )
196 {
197 JdwpProcess* proc = calloc(1,sizeof(*proc));
198
199 if (proc == NULL) {
200 D("not enough memory to create new JDWP process\n");
201 return NULL;
202 }
203
204 proc->socket = socket;
205 proc->pid = -1;
206 proc->next = proc;
207 proc->prev = proc;
208
209 proc->fde = fdevent_create( socket, jdwp_process_event, proc );
210 if (proc->fde == NULL) {
211 D("could not create fdevent for new JDWP process\n" );
212 free(proc);
213 return NULL;
214 }
215
216 proc->fde->state |= FDE_DONT_CLOSE;
217 proc->in_len = 0;
218 proc->out_count = 0;
219
220 /* append to list */
221 proc->next = &_jdwp_list;
222 proc->prev = proc->next->prev;
223
224 proc->prev->next = proc;
225 proc->next->prev = proc;
226
227 /* start by waiting for the PID */
228 fdevent_add(proc->fde, FDE_READ);
229
230 return proc;
231 }
232
233
234 static void
jdwp_process_event(int socket,unsigned events,void * _proc)235 jdwp_process_event( int socket, unsigned events, void* _proc )
236 {
237 JdwpProcess* proc = _proc;
238
239 if (events & FDE_READ) {
240 if (proc->pid < 0) {
241 /* read the PID as a 4-hexchar string */
242 char* p = proc->in_buff + proc->in_len;
243 int size = 4 - proc->in_len;
244 char temp[5];
245 while (size > 0) {
246 int len = recv( socket, p, size, 0 );
247 if (len < 0) {
248 if (errno == EINTR)
249 continue;
250 if (errno == EAGAIN)
251 return;
252 /* this can fail here if the JDWP process crashes very fast */
253 D("weird unknown JDWP process failure: %s\n",
254 strerror(errno));
255
256 goto CloseProcess;
257 }
258 if (len == 0) { /* end of stream ? */
259 D("weird end-of-stream from unknown JDWP process\n");
260 goto CloseProcess;
261 }
262 p += len;
263 proc->in_len += len;
264 size -= len;
265 }
266 /* we have read 4 characters, now decode the pid */
267 memcpy(temp, proc->in_buff, 4);
268 temp[4] = 0;
269
270 if (sscanf( temp, "%04x", &proc->pid ) != 1) {
271 D("could not decode JDWP %p PID number: '%s'\n", proc, temp);
272 goto CloseProcess;
273 }
274
275 /* all is well, keep reading to detect connection closure */
276 D("Adding pid %d to jdwp process list\n", proc->pid);
277 jdwp_process_list_updated();
278 }
279 else
280 {
281 /* the pid was read, if we get there it's probably because the connection
282 * was closed (e.g. the JDWP process exited or crashed) */
283 char buf[32];
284
285 for (;;) {
286 int len = recv(socket, buf, sizeof(buf), 0);
287
288 if (len <= 0) {
289 if (len < 0 && errno == EINTR)
290 continue;
291 if (len < 0 && errno == EAGAIN)
292 return;
293 else {
294 D("terminating JDWP %d connection: %s\n", proc->pid,
295 strerror(errno));
296 break;
297 }
298 }
299 else {
300 D( "ignoring unexpected JDWP %d control socket activity (%d bytes)\n",
301 proc->pid, len );
302 }
303 }
304
305 CloseProcess:
306 if (proc->pid >= 0)
307 D( "remove pid %d to jdwp process list\n", proc->pid );
308 jdwp_process_free(proc);
309 return;
310 }
311 }
312
313 if (events & FDE_WRITE) {
314 D("trying to write to JDWP pid controli (count=%d first=%d) %d\n",
315 proc->pid, proc->out_count, proc->out_fds[0]);
316 if (proc->out_count > 0) {
317 int fd = proc->out_fds[0];
318 int n, ret;
319 struct cmsghdr* cmsg;
320 struct msghdr msg;
321 struct iovec iov;
322 char dummy = '!';
323 char buffer[sizeof(struct cmsghdr) + sizeof(int)];
324 int flags;
325
326 iov.iov_base = &dummy;
327 iov.iov_len = 1;
328 msg.msg_name = NULL;
329 msg.msg_namelen = 0;
330 msg.msg_iov = &iov;
331 msg.msg_iovlen = 1;
332 msg.msg_flags = 0;
333 msg.msg_control = buffer;
334 msg.msg_controllen = sizeof(buffer);
335
336 cmsg = CMSG_FIRSTHDR(&msg);
337 cmsg->cmsg_len = msg.msg_controllen;
338 cmsg->cmsg_level = SOL_SOCKET;
339 cmsg->cmsg_type = SCM_RIGHTS;
340 ((int*)CMSG_DATA(cmsg))[0] = fd;
341
342 flags = fcntl(proc->socket,F_GETFL,0);
343
344 if (flags == -1) {
345 D("failed to get cntl flags for socket %d: %s\n",
346 proc->pid, strerror(errno));
347 goto CloseProcess;
348
349 }
350
351 if (fcntl(proc->socket, F_SETFL, flags & ~O_NONBLOCK) == -1) {
352 D("failed to remove O_NONBLOCK flag for socket %d: %s\n",
353 proc->pid, strerror(errno));
354 goto CloseProcess;
355 }
356
357 for (;;) {
358 ret = sendmsg(proc->socket, &msg, 0);
359 if (ret >= 0) {
360 adb_close(fd);
361 break;
362 }
363 if (errno == EINTR)
364 continue;
365 D("sending new file descriptor to JDWP %d failed: %s\n",
366 proc->pid, strerror(errno));
367 goto CloseProcess;
368 }
369
370 D("sent file descriptor %d to JDWP process %d\n",
371 fd, proc->pid);
372
373 for (n = 1; n < proc->out_count; n++)
374 proc->out_fds[n-1] = proc->out_fds[n];
375
376 if (fcntl(proc->socket, F_SETFL, flags) == -1) {
377 D("failed to set O_NONBLOCK flag for socket %d: %s\n",
378 proc->pid, strerror(errno));
379 goto CloseProcess;
380 }
381
382 if (--proc->out_count == 0)
383 fdevent_del( proc->fde, FDE_WRITE );
384 }
385 }
386 }
387
388
389 int
create_jdwp_connection_fd(int pid)390 create_jdwp_connection_fd(int pid)
391 {
392 JdwpProcess* proc = _jdwp_list.next;
393
394 D("looking for pid %d in JDWP process list\n", pid);
395 for ( ; proc != &_jdwp_list; proc = proc->next ) {
396 if (proc->pid == pid) {
397 goto FoundIt;
398 }
399 }
400 D("search failed !!\n");
401 return -1;
402
403 FoundIt:
404 {
405 int fds[2];
406
407 if (proc->out_count >= MAX_OUT_FDS) {
408 D("%s: too many pending JDWP connection for pid %d\n",
409 __FUNCTION__, pid);
410 return -1;
411 }
412
413 if (adb_socketpair(fds) < 0) {
414 D("%s: socket pair creation failed: %s\n",
415 __FUNCTION__, strerror(errno));
416 return -1;
417 }
418
419 proc->out_fds[ proc->out_count ] = fds[1];
420 if (++proc->out_count == 1)
421 fdevent_add( proc->fde, FDE_WRITE );
422
423 return fds[0];
424 }
425 }
426
427 /** VM DEBUG CONTROL SOCKET
428 **
429 ** we do implement a custom asocket to receive the data
430 **/
431
432 /* name of the debug control Unix socket */
433 #define JDWP_CONTROL_NAME "\0jdwp-control"
434 #define JDWP_CONTROL_NAME_LEN (sizeof(JDWP_CONTROL_NAME)-1)
435
436 typedef struct {
437 int listen_socket;
438 fdevent* fde;
439
440 } JdwpControl;
441
442
443 static void
444 jdwp_control_event(int s, unsigned events, void* user);
445
446
447 static int
jdwp_control_init(JdwpControl * control,const char * sockname,int socknamelen)448 jdwp_control_init( JdwpControl* control,
449 const char* sockname,
450 int socknamelen )
451 {
452 struct sockaddr_un addr;
453 socklen_t addrlen;
454 int s;
455 int maxpath = sizeof(addr.sun_path);
456 int pathlen = socknamelen;
457
458 if (pathlen >= maxpath) {
459 D( "vm debug control socket name too long (%d extra chars)\n",
460 pathlen+1-maxpath );
461 return -1;
462 }
463
464 memset(&addr, 0, sizeof(addr));
465 addr.sun_family = AF_UNIX;
466 memcpy(addr.sun_path, sockname, socknamelen);
467
468 s = socket( AF_UNIX, SOCK_STREAM, 0 );
469 if (s < 0) {
470 D( "could not create vm debug control socket. %d: %s\n",
471 errno, strerror(errno));
472 return -1;
473 }
474
475 addrlen = (pathlen + sizeof(addr.sun_family));
476
477 if (bind(s, (struct sockaddr*)&addr, addrlen) < 0) {
478 D( "could not bind vm debug control socket: %d: %s\n",
479 errno, strerror(errno) );
480 adb_close(s);
481 return -1;
482 }
483
484 if ( listen(s, 4) < 0 ) {
485 D("listen failed in jdwp control socket: %d: %s\n",
486 errno, strerror(errno));
487 adb_close(s);
488 return -1;
489 }
490
491 control->listen_socket = s;
492
493 control->fde = fdevent_create(s, jdwp_control_event, control);
494 if (control->fde == NULL) {
495 D( "could not create fdevent for jdwp control socket\n" );
496 adb_close(s);
497 return -1;
498 }
499
500 /* only wait for incoming connections */
501 fdevent_add(control->fde, FDE_READ);
502 close_on_exec(s);
503
504 D("jdwp control socket started (%d)\n", control->listen_socket);
505 return 0;
506 }
507
508
509 static void
jdwp_control_event(int s,unsigned events,void * _control)510 jdwp_control_event( int s, unsigned events, void* _control )
511 {
512 JdwpControl* control = (JdwpControl*) _control;
513
514 if (events & FDE_READ) {
515 struct sockaddr addr;
516 socklen_t addrlen = sizeof(addr);
517 int s = -1;
518 JdwpProcess* proc;
519
520 do {
521 s = adb_socket_accept( control->listen_socket, &addr, &addrlen );
522 if (s < 0) {
523 if (errno == EINTR)
524 continue;
525 if (errno == ECONNABORTED) {
526 /* oops, the JDWP process died really quick */
527 D("oops, the JDWP process died really quick\n");
528 return;
529 }
530 /* the socket is probably closed ? */
531 D( "weird accept() failed on jdwp control socket: %s\n",
532 strerror(errno) );
533 return;
534 }
535 }
536 while (s < 0);
537
538 proc = jdwp_process_alloc( s );
539 if (proc == NULL)
540 return;
541 }
542 }
543
544
545 static JdwpControl _jdwp_control;
546
547 /** "jdwp" local service implementation
548 ** this simply returns the list of known JDWP process pids
549 **/
550
551 typedef struct {
552 asocket socket;
553 int pass;
554 } JdwpSocket;
555
556 static void
jdwp_socket_close(asocket * s)557 jdwp_socket_close( asocket* s )
558 {
559 asocket* peer = s->peer;
560
561 remove_socket(s);
562
563 if (peer) {
564 peer->peer = NULL;
565 peer->close(peer);
566 }
567 free(s);
568 }
569
570 static int
jdwp_socket_enqueue(asocket * s,apacket * p)571 jdwp_socket_enqueue( asocket* s, apacket* p )
572 {
573 /* you can't write to this asocket */
574 put_apacket(p);
575 s->peer->close(s->peer);
576 return -1;
577 }
578
579
580 static void
jdwp_socket_ready(asocket * s)581 jdwp_socket_ready( asocket* s )
582 {
583 JdwpSocket* jdwp = (JdwpSocket*)s;
584 asocket* peer = jdwp->socket.peer;
585
586 /* on the first call, send the list of pids,
587 * on the second one, close the connection
588 */
589 if (jdwp->pass == 0) {
590 apacket* p = get_apacket();
591 p->len = jdwp_process_list((char*)p->data, MAX_PAYLOAD);
592 peer->enqueue(peer, p);
593 jdwp->pass = 1;
594 }
595 else {
596 peer->close(peer);
597 }
598 }
599
600 asocket*
create_jdwp_service_socket(void)601 create_jdwp_service_socket( void )
602 {
603 JdwpSocket* s = calloc(sizeof(*s),1);
604
605 if (s == NULL)
606 return NULL;
607
608 install_local_socket(&s->socket);
609
610 s->socket.ready = jdwp_socket_ready;
611 s->socket.enqueue = jdwp_socket_enqueue;
612 s->socket.close = jdwp_socket_close;
613 s->pass = 0;
614
615 return &s->socket;
616 }
617
618 /** "track-jdwp" local service implementation
619 ** this periodically sends the list of known JDWP process pids
620 ** to the client...
621 **/
622
623 typedef struct JdwpTracker JdwpTracker;
624
625 struct JdwpTracker {
626 asocket socket;
627 JdwpTracker* next;
628 JdwpTracker* prev;
629 int need_update;
630 };
631
632 static JdwpTracker _jdwp_trackers_list;
633
634
635 static void
jdwp_process_list_updated(void)636 jdwp_process_list_updated(void)
637 {
638 char buffer[1024];
639 int len;
640 JdwpTracker* t = _jdwp_trackers_list.next;
641
642 len = jdwp_process_list_msg(buffer, sizeof(buffer));
643
644 for ( ; t != &_jdwp_trackers_list; t = t->next ) {
645 apacket* p = get_apacket();
646 asocket* peer = t->socket.peer;
647 memcpy(p->data, buffer, len);
648 p->len = len;
649 peer->enqueue( peer, p );
650 }
651 }
652
653 static void
jdwp_tracker_close(asocket * s)654 jdwp_tracker_close( asocket* s )
655 {
656 JdwpTracker* tracker = (JdwpTracker*) s;
657 asocket* peer = s->peer;
658
659 if (peer) {
660 peer->peer = NULL;
661 peer->close(peer);
662 }
663
664 remove_socket(s);
665
666 tracker->prev->next = tracker->next;
667 tracker->next->prev = tracker->prev;
668
669 free(s);
670 }
671
672 static void
jdwp_tracker_ready(asocket * s)673 jdwp_tracker_ready( asocket* s )
674 {
675 JdwpTracker* t = (JdwpTracker*) s;
676
677 if (t->need_update) {
678 apacket* p = get_apacket();
679 t->need_update = 0;
680 p->len = jdwp_process_list_msg((char*)p->data, sizeof(p->data));
681 s->peer->enqueue(s->peer, p);
682 }
683 }
684
685 static int
jdwp_tracker_enqueue(asocket * s,apacket * p)686 jdwp_tracker_enqueue( asocket* s, apacket* p )
687 {
688 /* you can't write to this socket */
689 put_apacket(p);
690 s->peer->close(s->peer);
691 return -1;
692 }
693
694
695 asocket*
create_jdwp_tracker_service_socket(void)696 create_jdwp_tracker_service_socket( void )
697 {
698 JdwpTracker* t = calloc(sizeof(*t),1);
699
700 if (t == NULL)
701 return NULL;
702
703 t->next = &_jdwp_trackers_list;
704 t->prev = t->next->prev;
705
706 t->next->prev = t;
707 t->prev->next = t;
708
709 install_local_socket(&t->socket);
710
711 t->socket.ready = jdwp_tracker_ready;
712 t->socket.enqueue = jdwp_tracker_enqueue;
713 t->socket.close = jdwp_tracker_close;
714 t->need_update = 1;
715
716 return &t->socket;
717 }
718
719
720 int
init_jdwp(void)721 init_jdwp(void)
722 {
723 _jdwp_list.next = &_jdwp_list;
724 _jdwp_list.prev = &_jdwp_list;
725
726 _jdwp_trackers_list.next = &_jdwp_trackers_list;
727 _jdwp_trackers_list.prev = &_jdwp_trackers_list;
728
729 return jdwp_control_init( &_jdwp_control,
730 JDWP_CONTROL_NAME,
731 JDWP_CONTROL_NAME_LEN );
732 }
733
734 #endif /* !ADB_HOST */
735
736