From 52338a3f9364847b0b469e8e6d951a90cc9bb875 Mon Sep 17 00:00:00 2001 From: Josh Gao Date: Fri, 13 May 2016 15:28:34 -0700 Subject: [PATCH] adb: refactor jdwp_service.cpp. Refactor jdwp_service.cpp to be more idiomatic C++. Bug: http://b/28347842 Change-Id: I8c463069fe489819cb7c248f4aff2689877bfe45 --- adb/jdwp_service.cpp | 713 ++++++++++++++++++------------------------- 1 file changed, 297 insertions(+), 416 deletions(-) diff --git a/adb/jdwp_service.cpp b/adb/jdwp_service.cpp index 3c812cce7..7a4480168 100644 --- a/adb/jdwp_service.cpp +++ b/adb/jdwp_service.cpp @@ -14,7 +14,7 @@ * limitations under the License. */ -/* implement the "debug-ports" and "track-debug-ports" device services */ +#if !ADB_HOST #define TRACE_TAG JDWP @@ -24,22 +24,29 @@ #include #include #include +#include +#include #include +#include +#include +#include + #include "adb.h" +#include "adb_io.h" #include "adb_utils.h" /* here's how these things work. when adbd starts, it creates a unix server socket - named @vm-debug-control (@ is a shortcut for "first byte is zero" + named @jdwp-control (@ is a shortcut for "first byte is zero" to use the private namespace instead of the file system) when a new JDWP daemon thread starts in a new VM process, it creates - a connection to @vm-debug-control to announce its availability. + a connection to @jdwp-control to announce its availability. - JDWP thread @vm-debug-control + JDWP thread @jdwp-control | | |-------------------------------> | | hello I'm in process | @@ -72,7 +79,7 @@ to the JDWP process with the help of sendmsg() - JDWP thread @vm-debug-control + JDWP thread @jdwp-control | | | <----------------------| | OK, try this file descriptor | @@ -116,249 +123,191 @@ ** for each JDWP process, we record its pid and its connected socket **/ -#define MAX_OUT_FDS 4 +// PIDs are transmitted as 4 hex digits in ascii. +static constexpr size_t PID_LEN = 4; -#if !ADB_HOST +static void jdwp_process_event(int socket, unsigned events, void* _proc); +static void jdwp_process_list_updated(void); -#include -#include +struct JdwpProcess; +static std::list> _jdwp_list; struct JdwpProcess { - JdwpProcess* next; - JdwpProcess* prev; - int pid; - int socket; - fdevent* fde; + explicit JdwpProcess(int socket) { + this->socket = socket; + this->fde = fdevent_create(socket, jdwp_process_event, this); - char in_buff[4]; /* input character to read PID */ - int in_len; /* number from JDWP process */ + if (!this->fde) { + fatal("could not create fdevent for new JDWP process"); + } - int out_fds[MAX_OUT_FDS]; /* output array of file descriptors */ - int out_count; /* to send to the JDWP process */ + this->fde->state |= FDE_DONT_CLOSE; + + /* start by waiting for the PID */ + fdevent_add(this->fde, FDE_READ); + } + + ~JdwpProcess() { + if (this->socket >= 0) { + adb_shutdown(this->socket); + adb_close(this->socket); + this->socket = -1; + } + + if (this->fde) { + fdevent_destroy(this->fde); + this->fde = nullptr; + } + + out_fds.clear(); + } + + void RemoveFromList() { + if (this->pid >= 0) { + D("removing pid %d from jdwp process list", this->pid); + } else { + D("removing transient JdwpProcess from list"); + } + + auto pred = [this](const auto& proc) { return proc.get() == this; }; + _jdwp_list.remove_if(pred); + } + + int pid = -1; + int socket = -1; + fdevent* fde = nullptr; + + std::vector out_fds; + char in_buf[PID_LEN + 1]; + ssize_t in_len = 0; }; -static JdwpProcess _jdwp_list; - -static int -jdwp_process_list( char* buffer, int bufferlen ) -{ - char* end = buffer + bufferlen; - char* p = buffer; - JdwpProcess* proc = _jdwp_list.next; - - for ( ; proc != &_jdwp_list; proc = proc->next ) { - int len; +static size_t jdwp_process_list(char* buffer, size_t bufferlen) { + std::string temp; + for (auto& proc : _jdwp_list) { /* skip transient connections */ - if (proc->pid < 0) + if (proc->pid < 0) { continue; + } - len = snprintf(p, end-p, "%d\n", proc->pid); - if (p + len >= end) + std::string next = std::to_string(proc->pid) + "\n"; + if (temp.length() + next.length() > bufferlen) { + D("truncating JDWP process list (max len = %zu)", bufferlen); break; - p += len; - } - p[0] = 0; - return (p - buffer); -} - - -static int -jdwp_process_list_msg( char* buffer, int bufferlen ) -{ - char head[5]; - int len = jdwp_process_list( buffer+4, bufferlen-4 ); - snprintf(head, sizeof head, "%04x", len); - memcpy(buffer, head, 4); - return len + 4; -} - - -static void jdwp_process_list_updated(void); - -static void -jdwp_process_free( JdwpProcess* proc ) -{ - if (proc) { - int n; - - proc->prev->next = proc->next; - proc->next->prev = proc->prev; - - if (proc->socket >= 0) { - adb_shutdown(proc->socket); - adb_close(proc->socket); - proc->socket = -1; } - - if (proc->fde != NULL) { - fdevent_destroy(proc->fde); - proc->fde = NULL; - } - proc->pid = -1; - - for (n = 0; n < proc->out_count; n++) { - adb_close(proc->out_fds[n]); - } - proc->out_count = 0; - - free(proc); - - jdwp_process_list_updated(); + temp.append(next); } + + memcpy(buffer, temp.data(), temp.length()); + return temp.length(); } - -static void jdwp_process_event(int, unsigned, void*); /* forward */ - - -static JdwpProcess* -jdwp_process_alloc( int socket ) -{ - JdwpProcess* proc = reinterpret_cast( - calloc(1, sizeof(*proc))); - - if (proc == NULL) { - D("not enough memory to create new JDWP process"); - return NULL; +static size_t jdwp_process_list_msg(char* buffer, size_t bufferlen) { + // Message is length-prefixed with 4 hex digits in ASCII. + static constexpr size_t header_len = 4; + if (bufferlen < header_len) { + fatal("invalid JDWP process list buffer size: %zu", bufferlen); } - proc->socket = socket; - proc->pid = -1; - proc->next = proc; - proc->prev = proc; - - proc->fde = fdevent_create( socket, jdwp_process_event, proc ); - if (proc->fde == NULL) { - D("could not create fdevent for new JDWP process" ); - free(proc); - return NULL; - } - - proc->fde->state |= FDE_DONT_CLOSE; - proc->in_len = 0; - proc->out_count = 0; - - /* append to list */ - proc->next = &_jdwp_list; - proc->prev = proc->next->prev; - - proc->prev->next = proc; - proc->next->prev = proc; - - /* start by waiting for the PID */ - fdevent_add(proc->fde, FDE_READ); - - return proc; + char head[header_len + 1]; + size_t len = jdwp_process_list(buffer + header_len, bufferlen - header_len); + snprintf(head, sizeof head, "%04zx", len); + memcpy(buffer, head, header_len); + return len + header_len; } - -static void -jdwp_process_event( int socket, unsigned events, void* _proc ) -{ - JdwpProcess* proc = reinterpret_cast(_proc); +static void jdwp_process_event(int socket, unsigned events, void* _proc) { + JdwpProcess* proc = reinterpret_cast(_proc); if (events & FDE_READ) { if (proc->pid < 0) { /* read the PID as a 4-hexchar string */ - char* p = proc->in_buff + proc->in_len; - int size = 4 - proc->in_len; - char temp[5]; - while (size > 0) { - int len = recv( socket, p, size, 0 ); - if (len < 0) { - if (errno == EINTR) - continue; - if (errno == EAGAIN) - return; - /* this can fail here if the JDWP process crashes very fast */ - D("weird unknown JDWP process failure: %s", - strerror(errno)); - - goto CloseProcess; - } - if (len == 0) { /* end of stream ? */ - D("weird end-of-stream from unknown JDWP process"); - goto CloseProcess; - } - p += len; - proc->in_len += len; - size -= len; + if (proc->in_len < 0) { + fatal("attempting to read JDWP pid again?"); } - /* we have read 4 characters, now decode the pid */ - memcpy(temp, proc->in_buff, 4); - temp[4] = 0; - if (sscanf( temp, "%04x", &proc->pid ) != 1) { - D("could not decode JDWP %p PID number: '%s'", proc, temp); + char* p = proc->in_buf + proc->in_len; + size_t size = PID_LEN - proc->in_len; + + ssize_t rc = TEMP_FAILURE_RETRY(recv(socket, p, size, 0)); + if (rc < 0) { + if (errno == EAGAIN) { + return; + } + + D("failed to read jdwp pid: %s", strerror(errno)); + goto CloseProcess; + } + + proc->in_len += rc; + if (proc->in_len != PID_LEN) { + return; + } + + proc->in_buf[PID_LEN] = '\0'; + proc->in_len = -1; + + if (sscanf(proc->in_buf, "%04x", &proc->pid) != 1) { + D("could not decode JDWP %p PID number: '%s'", proc, p); goto CloseProcess; } /* all is well, keep reading to detect connection closure */ D("Adding pid %d to jdwp process list", proc->pid); jdwp_process_list_updated(); - } - else - { + } else { /* the pid was read, if we get there it's probably because the connection * was closed (e.g. the JDWP process exited or crashed) */ - char buf[32]; + char buf[32]; - for (;;) { - int len = recv(socket, buf, sizeof(buf), 0); + while (true) { + int len = TEMP_FAILURE_RETRY(recv(socket, buf, sizeof(buf), 0)); - if (len <= 0) { - if (len < 0 && errno == EINTR) - continue; - if (len < 0 && errno == EAGAIN) + if (len == 0) { + D("terminating JDWP %d connection: EOF", proc->pid); + break; + } else if (len < 0) { + if (len < 0 && errno == EAGAIN) { return; - else { - D("terminating JDWP %d connection: %s", proc->pid, - strerror(errno)); - break; } - } - else { - D( "ignoring unexpected JDWP %d control socket activity (%d bytes)", - proc->pid, len ); + + D("terminating JDWP %d connection: EOF", proc->pid); + break; + } else { + D("ignoring unexpected JDWP %d control socket activity (%d bytes)", proc->pid, + len); } } - CloseProcess: - if (proc->pid >= 0) { - D( "remove pid %d to jdwp process list", proc->pid ); - } - jdwp_process_free(proc); - return; + goto CloseProcess; } } if (events & FDE_WRITE) { - D("trying to write to JDWP pid controli (count=%d first=%d) %d", - proc->pid, proc->out_count, proc->out_fds[0]); - if (proc->out_count > 0) { - int fd = proc->out_fds[0]; - int n, ret; - struct cmsghdr* cmsg; - struct msghdr msg; - struct iovec iov; - char dummy = '!'; - char buffer[sizeof(struct cmsghdr) + sizeof(int)]; + D("trying to send fd to JDWP process (count = %zu)", proc->out_fds.size()); + if (!proc->out_fds.empty()) { + int fd = proc->out_fds.back().get(); + struct cmsghdr* cmsg; + struct msghdr msg; + struct iovec iov; + char dummy = '!'; + char buffer[sizeof(struct cmsghdr) + sizeof(int)]; - iov.iov_base = &dummy; - iov.iov_len = 1; - msg.msg_name = NULL; - msg.msg_namelen = 0; - msg.msg_iov = &iov; - msg.msg_iovlen = 1; - msg.msg_flags = 0; - msg.msg_control = buffer; + iov.iov_base = &dummy; + iov.iov_len = 1; + msg.msg_name = NULL; + msg.msg_namelen = 0; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_flags = 0; + msg.msg_control = buffer; msg.msg_controllen = sizeof(buffer); cmsg = CMSG_FIRSTHDR(&msg); - cmsg->cmsg_len = msg.msg_controllen; + cmsg->cmsg_len = msg.msg_controllen; cmsg->cmsg_level = SOL_SOCKET; - cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_type = SCM_RIGHTS; ((int*)CMSG_DATA(cmsg))[0] = fd; if (!set_file_block_mode(proc->socket, true)) { @@ -366,74 +315,59 @@ jdwp_process_event( int socket, unsigned events, void* _proc ) goto CloseProcess; } - for (;;) { - ret = sendmsg(proc->socket, &msg, 0); - if (ret >= 0) { - adb_close(fd); - break; - } - if (errno == EINTR) - continue; - D("sending new file descriptor to JDWP %d failed: %s", - proc->pid, strerror(errno)); + int ret = TEMP_FAILURE_RETRY(sendmsg(proc->socket, &msg, 0)); + if (ret < 0) { + D("sending new file descriptor to JDWP %d failed: %s", proc->pid, strerror(errno)); goto CloseProcess; } - D("sent file descriptor %d to JDWP process %d", - fd, proc->pid); + adb_close(fd); - for (n = 1; n < proc->out_count; n++) - proc->out_fds[n-1] = proc->out_fds[n]; + D("sent file descriptor %d to JDWP process %d", fd, proc->pid); + + proc->out_fds.pop_back(); if (!set_file_block_mode(proc->socket, false)) { VLOG(JDWP) << "failed to set non-blocking mode for fd " << proc->socket; goto CloseProcess; } - if (--proc->out_count == 0) - fdevent_del( proc->fde, FDE_WRITE ); + if (proc->out_fds.empty()) { + fdevent_del(proc->fde, FDE_WRITE); + } } } + + return; + +CloseProcess: + proc->RemoveFromList(); + jdwp_process_list_updated(); } - -int -create_jdwp_connection_fd(int pid) -{ - JdwpProcess* proc = _jdwp_list.next; - +int create_jdwp_connection_fd(int pid) { D("looking for pid %d in JDWP process list", pid); - for ( ; proc != &_jdwp_list; proc = proc->next ) { + + for (auto& proc : _jdwp_list) { if (proc->pid == pid) { - goto FoundIt; + int fds[2]; + + if (adb_socketpair(fds) < 0) { + D("%s: socket pair creation failed: %s", __FUNCTION__, strerror(errno)); + return -1; + } + D("socketpair: (%d,%d)", fds[0], fds[1]); + + proc->out_fds.emplace_back(fds[1]); + if (proc->out_fds.size() == 1) { + fdevent_add(proc->fde, FDE_WRITE); + } + + return fds[0]; } } D("search failed !!"); return -1; - -FoundIt: - { - int fds[2]; - - if (proc->out_count >= MAX_OUT_FDS) { - D("%s: too many pending JDWP connection for pid %d", - __FUNCTION__, pid); - return -1; - } - - if (adb_socketpair(fds) < 0) { - D("%s: socket pair creation failed: %s", - __FUNCTION__, strerror(errno)); - return -1; - } - D("socketpair: (%d,%d)", fds[0], fds[1]); - - proc->out_fds[ proc->out_count ] = fds[1]; - if (++proc->out_count == 1) - fdevent_add( proc->fde, FDE_WRITE ); - - return fds[0]; - } } /** VM DEBUG CONTROL SOCKET @@ -442,33 +376,27 @@ FoundIt: **/ /* name of the debug control Unix socket */ -#define JDWP_CONTROL_NAME "\0jdwp-control" -#define JDWP_CONTROL_NAME_LEN (sizeof(JDWP_CONTROL_NAME)-1) +#define JDWP_CONTROL_NAME "\0jdwp-control" +#define JDWP_CONTROL_NAME_LEN (sizeof(JDWP_CONTROL_NAME) - 1) struct JdwpControl { - int listen_socket; - fdevent* fde; + int listen_socket; + fdevent* fde; }; +static JdwpControl _jdwp_control; -static void -jdwp_control_event(int s, unsigned events, void* user); +static void jdwp_control_event(int s, unsigned events, void* user); - -static int -jdwp_control_init( JdwpControl* control, - const char* sockname, - int socknamelen ) -{ - sockaddr_un addr; - socklen_t addrlen; - int s; - int maxpath = sizeof(addr.sun_path); - int pathlen = socknamelen; +static int jdwp_control_init(JdwpControl* control, const char* sockname, int socknamelen) { + sockaddr_un addr; + socklen_t addrlen; + int s; + int maxpath = sizeof(addr.sun_path); + int pathlen = socknamelen; if (pathlen >= maxpath) { - D( "vm debug control socket name too long (%d extra chars)", - pathlen+1-maxpath ); + D("vm debug control socket name too long (%d extra chars)", pathlen + 1 - maxpath); return -1; } @@ -476,25 +404,22 @@ jdwp_control_init( JdwpControl* control, addr.sun_family = AF_UNIX; memcpy(addr.sun_path, sockname, socknamelen); - s = socket( AF_UNIX, SOCK_STREAM, 0 ); + s = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); if (s < 0) { - D( "could not create vm debug control socket. %d: %s", - errno, strerror(errno)); + D("could not create vm debug control socket. %d: %s", errno, strerror(errno)); return -1; } - addrlen = (pathlen + sizeof(addr.sun_family)); + addrlen = pathlen + sizeof(addr.sun_family); if (bind(s, reinterpret_cast(&addr), addrlen) < 0) { - D( "could not bind vm debug control socket: %d: %s", - errno, strerror(errno) ); + D("could not bind vm debug control socket: %d: %s", errno, strerror(errno)); adb_close(s); return -1; } - if ( listen(s, 4) < 0 ) { - D("listen failed in jdwp control socket: %d: %s", - errno, strerror(errno)); + if (listen(s, 4) < 0) { + D("listen failed in jdwp control socket: %d: %s", errno, strerror(errno)); adb_close(s); return -1; } @@ -503,128 +428,109 @@ jdwp_control_init( JdwpControl* control, control->fde = fdevent_create(s, jdwp_control_event, control); if (control->fde == NULL) { - D( "could not create fdevent for jdwp control socket" ); + D("could not create fdevent for jdwp control socket"); adb_close(s); return -1; } /* only wait for incoming connections */ fdevent_add(control->fde, FDE_READ); - close_on_exec(s); D("jdwp control socket started (%d)", control->listen_socket); return 0; } - -static void -jdwp_control_event( int s, unsigned events, void* _control ) -{ - JdwpControl* control = (JdwpControl*) _control; +static void jdwp_control_event(int s, unsigned events, void* _control) { + JdwpControl* control = (JdwpControl*)_control; if (events & FDE_READ) { - sockaddr_storage ss; - sockaddr* addrp = reinterpret_cast(&ss); - socklen_t addrlen = sizeof(ss); - int s = -1; - JdwpProcess* proc; - - do { - s = adb_socket_accept(control->listen_socket, addrp, &addrlen); - if (s < 0) { - if (errno == EINTR) - continue; - if (errno == ECONNABORTED) { - /* oops, the JDWP process died really quick */ - D("oops, the JDWP process died really quick"); - return; - } + sockaddr_storage ss; + sockaddr* addrp = reinterpret_cast(&ss); + socklen_t addrlen = sizeof(ss); + int s = adb_socket_accept(control->listen_socket, addrp, &addrlen); + if (s < 0) { + if (errno == ECONNABORTED) { + /* oops, the JDWP process died really quick */ + D("oops, the JDWP process died really quick"); + return; + } else { /* the socket is probably closed ? */ - D( "weird accept() failed on jdwp control socket: %s", - strerror(errno) ); + D("weird accept() failed on jdwp control socket: %s", strerror(errno)); return; } } - while (s < 0); - proc = jdwp_process_alloc( s ); - if (proc == NULL) - return; + auto proc = std::make_unique(s); + if (!proc) { + fatal("failed to allocate JdwpProcess"); + } + + _jdwp_list.emplace_back(std::move(proc)); } } - -static JdwpControl _jdwp_control; - /** "jdwp" local service implementation ** this simply returns the list of known JDWP process pids **/ -struct JdwpSocket { - asocket socket; - int pass; +struct JdwpSocket : public asocket { + bool pass; }; -static void -jdwp_socket_close( asocket* s ) -{ - asocket* peer = s->peer; +static void jdwp_socket_close(asocket* s) { + D("LS(%d): closing jdwp socket", s->id); + + if (s->peer) { + D("LS(%d) peer->close()ing peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd); + s->peer->peer = nullptr; + s->peer->close(s->peer); + s->peer = nullptr; + } remove_socket(s); - - if (peer) { - peer->peer = NULL; - peer->close(peer); - } free(s); } -static int -jdwp_socket_enqueue( asocket* s, apacket* p ) -{ +static int jdwp_socket_enqueue(asocket* s, apacket* p) { /* you can't write to this asocket */ + D("LS(%d): JDWP socket received data?", s->id); put_apacket(p); s->peer->close(s->peer); return -1; } +static void jdwp_socket_ready(asocket* s) { + JdwpSocket* jdwp = (JdwpSocket*)s; + asocket* peer = jdwp->peer; -static void -jdwp_socket_ready( asocket* s ) -{ - JdwpSocket* jdwp = (JdwpSocket*)s; - asocket* peer = jdwp->socket.peer; - - /* on the first call, send the list of pids, - * on the second one, close the connection - */ - if (jdwp->pass == 0) { - apacket* p = get_apacket(); + /* on the first call, send the list of pids, + * on the second one, close the connection + */ + if (!jdwp->pass) { + apacket* p = get_apacket(); p->len = jdwp_process_list((char*)p->data, s->get_max_payload()); peer->enqueue(peer, p); - jdwp->pass = 1; - } - else { + jdwp->pass = true; + } else { peer->close(peer); } } -asocket* -create_jdwp_service_socket( void ) -{ +asocket* create_jdwp_service_socket(void) { JdwpSocket* s = reinterpret_cast(calloc(sizeof(*s), 1)); - if (s == NULL) - return NULL; + if (!s) { + fatal("failed to allocate JdwpSocket"); + } - install_local_socket(&s->socket); + install_local_socket(s); - s->socket.ready = jdwp_socket_ready; - s->socket.enqueue = jdwp_socket_enqueue; - s->socket.close = jdwp_socket_close; - s->pass = 0; + s->ready = jdwp_socket_ready; + s->enqueue = jdwp_socket_enqueue; + s->close = jdwp_socket_close; + s->pass = false; - return &s->socket; + return s; } /** "track-jdwp" local service implementation @@ -632,113 +538,88 @@ create_jdwp_service_socket( void ) ** to the client... **/ -struct JdwpTracker { - asocket socket; - JdwpTracker* next; - JdwpTracker* prev; - int need_update; +struct JdwpTracker : public asocket { + bool need_initial; }; -static JdwpTracker _jdwp_trackers_list; +static std::vector> _jdwp_trackers; +static void jdwp_process_list_updated(void) { + char buffer[1024]; + int len = jdwp_process_list_msg(buffer, sizeof(buffer)); -static void -jdwp_process_list_updated(void) -{ - char buffer[1024]; - int len; - JdwpTracker* t = _jdwp_trackers_list.next; - - len = jdwp_process_list_msg(buffer, sizeof(buffer)); - - for ( ; t != &_jdwp_trackers_list; t = t->next ) { - apacket* p = get_apacket(); - asocket* peer = t->socket.peer; + for (auto& t : _jdwp_trackers) { + apacket* p = get_apacket(); memcpy(p->data, buffer, len); p->len = len; - peer->enqueue( peer, p ); + + if (t->peer) { + // The tracker might not have been connected yet. + t->peer->enqueue(t->peer, p); + } } } -static void -jdwp_tracker_close( asocket* s ) -{ - JdwpTracker* tracker = (JdwpTracker*) s; - asocket* peer = s->peer; +static void jdwp_tracker_close(asocket* s) { + D("LS(%d): destroying jdwp tracker service", s->id); - if (peer) { - peer->peer = NULL; - peer->close(peer); + if (s->peer) { + D("LS(%d) peer->close()ing peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd); + s->peer->peer = nullptr; + s->peer->close(s->peer); + s->peer = nullptr; } remove_socket(s); - tracker->prev->next = tracker->next; - tracker->next->prev = tracker->prev; - - free(s); + auto pred = [s](const auto& tracker) { return tracker.get() == s; }; + std::remove_if(_jdwp_trackers.begin(), _jdwp_trackers.end(), pred); } -static void -jdwp_tracker_ready( asocket* s ) -{ - JdwpTracker* t = (JdwpTracker*) s; +static void jdwp_tracker_ready(asocket* s) { + JdwpTracker* t = (JdwpTracker*)s; - if (t->need_update) { - apacket* p = get_apacket(); - t->need_update = 0; + if (t->need_initial) { + apacket* p = get_apacket(); + t->need_initial = false; p->len = jdwp_process_list_msg((char*)p->data, s->get_max_payload()); s->peer->enqueue(s->peer, p); } } -static int -jdwp_tracker_enqueue( asocket* s, apacket* p ) -{ +static int jdwp_tracker_enqueue(asocket* s, apacket* p) { /* you can't write to this socket */ + D("LS(%d): JDWP tracker received data?", s->id); put_apacket(p); s->peer->close(s->peer); return -1; } +asocket* create_jdwp_tracker_service_socket(void) { + auto t = std::make_unique(); + if (!t) { + fatal("failed to allocate JdwpTracker"); + } -asocket* -create_jdwp_tracker_service_socket( void ) -{ - JdwpTracker* t = reinterpret_cast(calloc(sizeof(*t), 1)); + memset(t.get(), 0, sizeof(asocket)); - if (t == NULL) - return NULL; + install_local_socket(t.get()); + D("LS(%d): created new jdwp tracker service", t->id); - t->next = &_jdwp_trackers_list; - t->prev = t->next->prev; + t->ready = jdwp_tracker_ready; + t->enqueue = jdwp_tracker_enqueue; + t->close = jdwp_tracker_close; + t->need_initial = true; - t->next->prev = t; - t->prev->next = t; + asocket* result = t.get(); - install_local_socket(&t->socket); + _jdwp_trackers.emplace_back(std::move(t)); - t->socket.ready = jdwp_tracker_ready; - t->socket.enqueue = jdwp_tracker_enqueue; - t->socket.close = jdwp_tracker_close; - t->need_update = 1; - - return &t->socket; + return result; } - -int -init_jdwp(void) -{ - _jdwp_list.next = &_jdwp_list; - _jdwp_list.prev = &_jdwp_list; - - _jdwp_trackers_list.next = &_jdwp_trackers_list; - _jdwp_trackers_list.prev = &_jdwp_trackers_list; - - return jdwp_control_init( &_jdwp_control, - JDWP_CONTROL_NAME, - JDWP_CONTROL_NAME_LEN ); +int init_jdwp(void) { + return jdwp_control_init(&_jdwp_control, JDWP_CONTROL_NAME, JDWP_CONTROL_NAME_LEN); } #endif /* !ADB_HOST */