Home | History | Annotate | Download | only in jdwp 
      1 /*
      2  * Copyright (C) 2008 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 /*
     17  * JDWP TCP socket network code.
     18  */
     19 #include "jdwp/JdwpPriv.h"
     20 #include "jdwp/JdwpHandler.h"
     21 #include "Bits.h"
     22 
     23 #include <stdlib.h>
     24 #include <unistd.h>
     25 #include <stdio.h>
     26 #include <string.h>
     27 #include <errno.h>
     28 #include <sys/types.h>
     29 #include <sys/socket.h>
     30 #include <netinet/in.h>
     31 #include <netinet/tcp.h>
     32 #include <arpa/inet.h>
     33 #include <netdb.h>
     34 
     35 #define kBasePort           8000
     36 #define kMaxPort            8040
     37 
     38 #define kInputBufferSize    8192
     39 
     40 #define kMagicHandshake     "JDWP-Handshake"
     41 #define kMagicHandshakeLen  (sizeof(kMagicHandshake)-1)
     42 
     43 // fwd
     44 static void netShutdown(JdwpNetState* state);
     45 static void netFree(JdwpNetState* state);
     46 
     47 
     48 /*
     49  * JDWP network state.
     50  *
     51  * We only talk to one debugger at a time.
     52  */
     53 struct JdwpNetState : public JdwpNetStateBase {
     54     short   listenPort;
     55     int     listenSock;         /* listen for connection from debugger */
     56     int     wakePipe[2];        /* break out of select */
     57 
     58     struct in_addr remoteAddr;
     59     unsigned short remotePort;
     60 
     61     bool    awaitingHandshake;  /* waiting for "JDWP-Handshake" */
     62 
     63     /* pending data from the network; would be more efficient as circular buf */
     64     unsigned char  inputBuffer[kInputBufferSize];
     65     int     inputCount;
     66 
     67     JdwpNetState()
     68     {
     69         listenPort  = 0;
     70         listenSock  = -1;
     71         wakePipe[0] = -1;
     72         wakePipe[1] = -1;
     73 
     74         awaitingHandshake = false;
     75 
     76         inputCount = 0;
     77     }
     78 };
     79 
     80 static JdwpNetState* netStartup(short port);
     81 
     82 /*
     83  * Set up some stuff for transport=dt_socket.
     84  */
     85 static bool prepareSocket(JdwpState* state, const JdwpStartupParams* pParams)
     86 {
     87     unsigned short port;
     88 
     89     if (pParams->server) {
     90         if (pParams->port != 0) {
     91             /* try only the specified port */
     92             port = pParams->port;
     93             state->netState = netStartup(port);
     94         } else {
     95             /* scan through a range of ports, binding to the first available */
     96             for (port = kBasePort; port <= kMaxPort; port++) {
     97                 state->netState = netStartup(port);
     98                 if (state->netState != NULL)
     99                     break;
    100             }
    101         }
    102         if (state->netState == NULL) {
    103             ALOGE("JDWP net startup failed (req port=%d)", pParams->port);
    104             return false;
    105         }
    106     } else {
    107         port = pParams->port;   // used in a debug msg later
    108         state->netState = netStartup(-1);
    109     }
    110 
    111     if (pParams->suspend)
    112         ALOGI("JDWP will wait for debugger on port %d", port);
    113     else
    114         ALOGD("JDWP will %s on port %d",
    115             pParams->server ? "listen" : "connect", port);
    116 
    117     return true;
    118 }
    119 
    120 
    121 /*
    122  * Are we still waiting for the handshake string?
    123  */
    124 static bool awaitingHandshake(JdwpState* state)
    125 {
    126     return state->netState->awaitingHandshake;
    127 }
    128 
    129 /*
    130  * Initialize JDWP stuff.
    131  *
    132  * Allocates a new state structure.  If "port" is non-negative, this also
    133  * tries to bind to a listen port.  If "port" is less than zero, we assume
    134  * we're preparing for an outbound connection, and return without binding
    135  * to anything.
    136  *
    137  * This may be called several times if we're probing for a port.
    138  *
    139  * Returns 0 on success.
    140  */
    141 static JdwpNetState* netStartup(short port)
    142 {
    143     int one = 1;
    144     JdwpNetState* netState = new JdwpNetState;
    145 
    146     if (port < 0)
    147         return netState;
    148 
    149     assert(port != 0);
    150 
    151     netState->listenSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    152     if (netState->listenSock < 0) {
    153         ALOGE("Socket create failed: %s", strerror(errno));
    154         goto fail;
    155     }
    156 
    157     /* allow immediate re-use */
    158     if (setsockopt(netState->listenSock, SOL_SOCKET, SO_REUSEADDR, &one,
    159             sizeof(one)) < 0)
    160     {
    161         ALOGE("setsockopt(SO_REUSEADDR) failed: %s", strerror(errno));
    162         goto fail;
    163     }
    164 
    165     union {
    166         struct sockaddr_in  addrInet;
    167         struct sockaddr     addrPlain;
    168     } addr;
    169     addr.addrInet.sin_family = AF_INET;
    170     addr.addrInet.sin_port = htons(port);
    171     inet_aton("127.0.0.1", &addr.addrInet.sin_addr);
    172 
    173     if (bind(netState->listenSock, &addr.addrPlain, sizeof(addr)) != 0) {
    174         ALOGV("attempt to bind to port %u failed: %s", port, strerror(errno));
    175         goto fail;
    176     }
    177 
    178     netState->listenPort = port;
    179     LOGVV("+++ bound to port %d", netState->listenPort);
    180 
    181     if (listen(netState->listenSock, 5) != 0) {
    182         ALOGE("Listen failed: %s", strerror(errno));
    183         goto fail;
    184     }
    185 
    186     return netState;
    187 
    188 fail:
    189     netShutdown(netState);
    190     netFree(netState);
    191     return NULL;
    192 }
    193 
    194 /*
    195  * Shut down JDWP listener.  Don't free state.
    196  *
    197  * Note that "netState" may be partially initialized if "startup" failed.
    198  *
    199  * This may be called from a non-JDWP thread as part of shutting the
    200  * JDWP thread down.
    201  *
    202  * (This is currently called several times during startup as we probe
    203  * for an open port.)
    204  */
    205 static void netShutdown(JdwpNetState* netState)
    206 {
    207     if (netState == NULL)
    208         return;
    209 
    210     int listenSock = netState->listenSock;
    211     int clientSock = netState->clientSock;
    212 
    213     /* clear these out so it doesn't wake up and try to reuse them */
    214     netState->listenSock = netState->clientSock = -1;
    215 
    216     /* "shutdown" dislodges blocking read() and accept() calls */
    217     if (listenSock >= 0) {
    218         shutdown(listenSock, SHUT_RDWR);
    219         close(listenSock);
    220     }
    221     if (clientSock >= 0) {
    222         shutdown(clientSock, SHUT_RDWR);
    223         close(clientSock);
    224     }
    225 
    226     /* if we might be sitting in select, kick us loose */
    227     if (netState->wakePipe[1] >= 0) {
    228         ALOGV("+++ writing to wakePipe");
    229         TEMP_FAILURE_RETRY(write(netState->wakePipe[1], "", 1));
    230     }
    231 }
    232 static void netShutdownExtern(JdwpState* state)
    233 {
    234     netShutdown(state->netState);
    235 }
    236 
    237 /*
    238  * Free JDWP state.
    239  *
    240  * Call this after shutting the network down with netShutdown().
    241  */
    242 static void netFree(JdwpNetState* netState)
    243 {
    244     if (netState == NULL)
    245         return;
    246     assert(netState->listenSock == -1);
    247     assert(netState->clientSock == -1);
    248 
    249     if (netState->wakePipe[0] >= 0) {
    250         close(netState->wakePipe[0]);
    251         netState->wakePipe[0] = -1;
    252     }
    253     if (netState->wakePipe[1] >= 0) {
    254         close(netState->wakePipe[1]);
    255         netState->wakePipe[1] = -1;
    256     }
    257 
    258     delete netState;
    259 }
    260 static void netFreeExtern(JdwpState* state)
    261 {
    262     netFree(state->netState);
    263 }
    264 
    265 /*
    266  * Returns "true" if we're connected to a debugger.
    267  */
    268 static bool isConnected(JdwpState* state)
    269 {
    270     return (state->netState != NULL &&
    271             state->netState->clientSock >= 0);
    272 }
    273 
    274 /*
    275  * Returns "true" if the fd is ready, "false" if not.
    276  */
    277 #if 0
    278 static bool isFdReadable(int sock)
    279 {
    280     fd_set readfds;
    281     struct timeval tv;
    282     int count;
    283 
    284     FD_ZERO(&readfds);
    285     FD_SET(sock, &readfds);
    286 
    287     tv.tv_sec = 0;
    288     tv.tv_usec = 0;
    289     count = select(sock+1, &readfds, NULL, NULL, &tv);
    290     if (count <= 0)
    291         return false;
    292 
    293     if (FD_ISSET(sock, &readfds))   /* make sure it's our fd */
    294         return true;
    295 
    296     ALOGE("WEIRD: odd behavior in select (count=%d)", count);
    297     return false;
    298 }
    299 #endif
    300 
    301 #if 0
    302 /*
    303  * Check to see if we have a pending connection from the debugger.
    304  *
    305  * Returns true on success (meaning a connection is available).
    306  */
    307 static bool checkConnection(JdwpState* state)
    308 {
    309     JdwpNetState* netState = state->netState;
    310 
    311     assert(netState->listenSock >= 0);
    312     /* not expecting to be called when debugger is actively connected */
    313     assert(netState->clientSock < 0);
    314 
    315     if (!isFdReadable(netState->listenSock))
    316         return false;
    317     return true;
    318 }
    319 #endif
    320 
    321 /*
    322  * Disable the TCP Nagle algorithm, which delays transmission of outbound
    323  * packets until the previous transmissions have been acked.  JDWP does a
    324  * lot of back-and-forth with small packets, so this may help.
    325  */
    326 static int setNoDelay(int fd)
    327 {
    328     int cc, on = 1;
    329 
    330     cc = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
    331     assert(cc == 0);
    332     return cc;
    333 }
    334 
    335 /*
    336  * Accept a connection.  This will block waiting for somebody to show up.
    337  * If that's not desirable, use checkConnection() to make sure something
    338  * is pending.
    339  */
    340 static bool acceptConnection(JdwpState* state)
    341 {
    342     JdwpNetState* netState = state->netState;
    343     union {
    344         struct sockaddr_in  addrInet;
    345         struct sockaddr     addrPlain;
    346     } addr;
    347     socklen_t addrlen;
    348     int sock;
    349 
    350     if (netState->listenSock < 0)
    351         return false;       /* you're not listening! */
    352 
    353     assert(netState->clientSock < 0);      /* must not already be talking */
    354 
    355     addrlen = sizeof(addr);
    356     do {
    357         sock = accept(netState->listenSock, &addr.addrPlain, &addrlen);
    358         if (sock < 0 && errno != EINTR) {
    359             // When we call shutdown() on the socket, accept() returns with
    360             // EINVAL.  Don't gripe about it.
    361             if (errno == EINVAL)
    362                 LOGVV("accept failed: %s", strerror(errno));
    363             else
    364                 ALOGE("accept failed: %s", strerror(errno));
    365             return false;
    366         }
    367     } while (sock < 0);
    368 
    369     netState->remoteAddr = addr.addrInet.sin_addr;
    370     netState->remotePort = ntohs(addr.addrInet.sin_port);
    371     ALOGV("+++ accepted connection from %s:%u",
    372         inet_ntoa(netState->remoteAddr), netState->remotePort);
    373 
    374     netState->clientSock = sock;
    375     netState->awaitingHandshake = true;
    376     netState->inputCount = 0;
    377 
    378     ALOGV("Setting TCP_NODELAY on accepted socket");
    379     setNoDelay(netState->clientSock);
    380 
    381     if (pipe(netState->wakePipe) < 0) {
    382         ALOGE("pipe failed");
    383         return false;
    384     }
    385 
    386     return true;
    387 }
    388 
    389 /*
    390  * Create a connection to a waiting debugger.
    391  */
    392 static bool establishConnection(JdwpState* state)
    393 {
    394     union {
    395         struct sockaddr_in  addrInet;
    396         struct sockaddr     addrPlain;
    397     } addr;
    398     struct hostent* pEntry;
    399     int h_errno;
    400 
    401     assert(state != NULL && state->netState != NULL);
    402     assert(!state->params.server);
    403     assert(state->params.host[0] != '\0');
    404     assert(state->params.port != 0);
    405 
    406     /*
    407      * Start by resolving the host name.
    408      */
    409 //#undef HAVE_GETHOSTBYNAME_R
    410 //#warning "forcing non-R"
    411 #ifdef HAVE_GETHOSTBYNAME_R
    412     struct hostent he;
    413     char auxBuf[128];
    414     int cc = gethostbyname_r(state->params.host, &he, auxBuf, sizeof(auxBuf),
    415             &pEntry, &h_errno);
    416     if (cc != 0) {
    417         ALOGW("gethostbyname_r('%s') failed: %s",
    418             state->params.host, strerror(errno));
    419         return false;
    420     }
    421 
    422 #else
    423     h_errno = 0;
    424     pEntry = gethostbyname(state->params.host);
    425     if (pEntry == NULL) {
    426         ALOGW("gethostbyname('%s') failed: %s",
    427             state->params.host, strerror(h_errno));
    428         return false;
    429     }
    430 #endif
    431 
    432     /* copy it out ASAP to minimize risk of multithreaded annoyances */
    433     memcpy(&addr.addrInet.sin_addr, pEntry->h_addr, pEntry->h_length);
    434     addr.addrInet.sin_family = pEntry->h_addrtype;
    435 
    436     addr.addrInet.sin_port = htons(state->params.port);
    437 
    438     ALOGI("Connecting out to '%s' %d",
    439         inet_ntoa(addr.addrInet.sin_addr), ntohs(addr.addrInet.sin_port));
    440 
    441     /*
    442      * Create a socket.
    443      */
    444     JdwpNetState* netState;
    445     netState = state->netState;
    446     netState->clientSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    447     if (netState->clientSock < 0) {
    448         ALOGE("Unable to create socket: %s", strerror(errno));
    449         return false;
    450     }
    451 
    452     /*
    453      * Try to connect.
    454      */
    455     if (connect(netState->clientSock, &addr.addrPlain, sizeof(addr)) != 0) {
    456         ALOGE("Unable to connect to %s:%d: %s",
    457             inet_ntoa(addr.addrInet.sin_addr), ntohs(addr.addrInet.sin_port),
    458             strerror(errno));
    459         close(netState->clientSock);
    460         netState->clientSock = -1;
    461         return false;
    462     }
    463 
    464     ALOGI("Connection established to %s (%s:%d)",
    465         state->params.host, inet_ntoa(addr.addrInet.sin_addr),
    466         ntohs(addr.addrInet.sin_port));
    467     netState->awaitingHandshake = true;
    468     netState->inputCount = 0;
    469 
    470     setNoDelay(netState->clientSock);
    471 
    472     if (pipe(netState->wakePipe) < 0) {
    473         ALOGE("pipe failed");
    474         return false;
    475     }
    476 
    477     return true;
    478 }
    479 
    480 /*
    481  * Close the connection to the debugger.
    482  *
    483  * Reset the state so we're ready to receive a new connection.
    484  */
    485 static void closeConnection(JdwpState* state)
    486 {
    487     JdwpNetState* netState;
    488 
    489     assert(state != NULL && state->netState != NULL);
    490 
    491     netState = state->netState;
    492     if (netState->clientSock < 0)
    493         return;
    494 
    495     ALOGV("+++ closed connection to %s:%u",
    496         inet_ntoa(netState->remoteAddr), netState->remotePort);
    497 
    498     close(netState->clientSock);
    499     netState->clientSock = -1;
    500 
    501     return;
    502 }
    503 
    504 /*
    505  * Figure out if we have a full packet in the buffer.
    506  */
    507 static bool haveFullPacket(JdwpNetState* netState)
    508 {
    509     long length;
    510 
    511     if (netState->awaitingHandshake)
    512         return (netState->inputCount >= (int) kMagicHandshakeLen);
    513 
    514     if (netState->inputCount < 4)
    515         return false;
    516 
    517     length = get4BE(netState->inputBuffer);
    518     return (netState->inputCount >= length);
    519 }
    520 
    521 /*
    522  * Consume bytes from the buffer.
    523  *
    524  * This would be more efficient with a circular buffer.  However, we're
    525  * usually only going to find one packet, which is trivial to handle.
    526  */
    527 static void consumeBytes(JdwpNetState* netState, int count)
    528 {
    529     assert(count > 0);
    530     assert(count <= netState->inputCount);
    531 
    532     if (count == netState->inputCount) {
    533         netState->inputCount = 0;
    534         return;
    535     }
    536 
    537     memmove(netState->inputBuffer, netState->inputBuffer + count,
    538         netState->inputCount - count);
    539     netState->inputCount -= count;
    540 }
    541 
    542 /*
    543  * Dump the contents of a packet to stdout.
    544  */
    545 #if 0
    546 static void dumpPacket(const unsigned char* packetBuf)
    547 {
    548     const unsigned char* buf = packetBuf;
    549     u4 length, id;
    550     u1 flags, cmdSet, cmd;
    551     u2 error;
    552     bool reply;
    553     int dataLen;
    554 
    555     cmd = cmdSet = 0xcc;
    556 
    557     length = read4BE(&buf);
    558     id = read4BE(&buf);
    559     flags = read1(&buf);
    560     if ((flags & kJDWPFlagReply) != 0) {
    561         reply = true;
    562         error = read2BE(&buf);
    563     } else {
    564         reply = false;
    565         cmdSet = read1(&buf);
    566         cmd = read1(&buf);
    567     }
    568 
    569     dataLen = length - (buf - packetBuf);
    570 
    571     ALOGV("--- %s: dataLen=%u id=0x%08x flags=0x%02x cmd=%d/%d",
    572         reply ? "reply" : "req",
    573         dataLen, id, flags, cmdSet, cmd);
    574     if (dataLen > 0)
    575         dvmPrintHexDumpDbg(buf, dataLen, LOG_TAG);
    576 }
    577 #endif
    578 
    579 /*
    580  * Handle a packet.  Returns "false" if we encounter a connection-fatal error.
    581  */
    582 static bool handlePacket(JdwpState* state)
    583 {
    584     JdwpNetState* netState = state->netState;
    585     const unsigned char* buf = netState->inputBuffer;
    586     JdwpReqHeader hdr;
    587     u4 length, id;
    588     u1 flags, cmdSet, cmd;
    589     u2 error;
    590     bool reply;
    591     int dataLen;
    592 
    593     cmd = cmdSet = 0;       // shut up gcc
    594 
    595     /*dumpPacket(netState->inputBuffer);*/
    596 
    597     length = read4BE(&buf);
    598     id = read4BE(&buf);
    599     flags = read1(&buf);
    600     if ((flags & kJDWPFlagReply) != 0) {
    601         reply = true;
    602         error = read2BE(&buf);
    603     } else {
    604         reply = false;
    605         cmdSet = read1(&buf);
    606         cmd = read1(&buf);
    607     }
    608 
    609     assert((int) length <= netState->inputCount);
    610     dataLen = length - (buf - netState->inputBuffer);
    611 
    612     if (!reply) {
    613         ExpandBuf* pReply = expandBufAlloc();
    614 
    615         hdr.length = length;
    616         hdr.id = id;
    617         hdr.cmdSet = cmdSet;
    618         hdr.cmd = cmd;
    619         dvmJdwpProcessRequest(state, &hdr, buf, dataLen, pReply);
    620         if (expandBufGetLength(pReply) > 0) {
    621             ssize_t cc = netState->writePacket(pReply);
    622 
    623             if (cc != (ssize_t) expandBufGetLength(pReply)) {
    624                 ALOGE("Failed sending reply to debugger: %s", strerror(errno));
    625                 expandBufFree(pReply);
    626                 return false;
    627             }
    628         } else {
    629             ALOGW("No reply created for set=%d cmd=%d", cmdSet, cmd);
    630         }
    631         expandBufFree(pReply);
    632     } else {
    633         ALOGV("reply?!");
    634         assert(false);
    635     }
    636 
    637     ALOGV("----------");
    638 
    639     consumeBytes(netState, length);
    640     return true;
    641 }
    642 
    643 /*
    644  * Process incoming data.  If no data is available, this will block until
    645  * some arrives.
    646  *
    647  * If we get a full packet, handle it.
    648  *
    649  * To take some of the mystery out of life, we want to reject incoming
    650  * connections if we already have a debugger attached.  If we don't, the
    651  * debugger will just mysteriously hang until it times out.  We could just
    652  * close the listen socket, but there's a good chance we won't be able to
    653  * bind to the same port again, which would confuse utilities.
    654  *
    655  * Returns "false" on error (indicating that the connection has been severed),
    656  * "true" if things are still okay.
    657  */
    658 static bool processIncoming(JdwpState* state)
    659 {
    660     JdwpNetState* netState = state->netState;
    661     int readCount;
    662 
    663     assert(netState->clientSock >= 0);
    664 
    665     if (!haveFullPacket(netState)) {
    666         /* read some more, looping until we have data */
    667         errno = 0;
    668         while (1) {
    669             int selCount;
    670             fd_set readfds;
    671             int maxfd;
    672             int fd;
    673 
    674             maxfd = netState->listenSock;
    675             if (netState->clientSock > maxfd)
    676                 maxfd = netState->clientSock;
    677             if (netState->wakePipe[0] > maxfd)
    678                 maxfd = netState->wakePipe[0];
    679 
    680             if (maxfd < 0) {
    681                 ALOGV("+++ all fds are closed");
    682                 return false;
    683             }
    684 
    685             FD_ZERO(&readfds);
    686 
    687             /* configure fds; note these may get zapped by another thread */
    688             fd = netState->listenSock;
    689             if (fd >= 0)
    690                 FD_SET(fd, &readfds);
    691             fd = netState->clientSock;
    692             if (fd >= 0)
    693                 FD_SET(fd, &readfds);
    694             fd = netState->wakePipe[0];
    695             if (fd >= 0) {
    696                 FD_SET(fd, &readfds);
    697             } else {
    698                 ALOGI("NOTE: entering select w/o wakepipe");
    699             }
    700 
    701             /*
    702              * Select blocks until it sees activity on the file descriptors.
    703              * Closing the local file descriptor does not count as activity,
    704              * so we can't rely on that to wake us up (it works for read()
    705              * and accept(), but not select()).
    706              *
    707              * We can do one of three things: (1) send a signal and catch
    708              * EINTR, (2) open an additional fd ("wakePipe") and write to
    709              * it when it's time to exit, or (3) time out periodically and
    710              * re-issue the select.  We're currently using #2, as it's more
    711              * reliable than #1 and generally better than #3.  Wastes two fds.
    712              */
    713             selCount = select(maxfd+1, &readfds, NULL, NULL, NULL);
    714             if (selCount < 0) {
    715                 if (errno == EINTR)
    716                     continue;
    717                 ALOGE("select failed: %s", strerror(errno));
    718                 goto fail;
    719             }
    720 
    721             if (netState->wakePipe[0] >= 0 &&
    722                 FD_ISSET(netState->wakePipe[0], &readfds))
    723             {
    724                 if (netState->listenSock >= 0)
    725                     ALOGE("Exit wake set, but not exiting?");
    726                 else
    727                     ALOGD("Got wake-up signal, bailing out of select");
    728                 goto fail;
    729             }
    730             if (netState->listenSock >= 0 &&
    731                 FD_ISSET(netState->listenSock, &readfds))
    732             {
    733                 ALOGI("Ignoring second debugger -- accepting and dropping");
    734                 union {
    735                     struct sockaddr_in   addrInet;
    736                     struct sockaddr      addrPlain;
    737                 } addr;
    738                 socklen_t addrlen;
    739                 int tmpSock;
    740                 tmpSock = accept(netState->listenSock, &addr.addrPlain,
    741                                 &addrlen);
    742                 if (tmpSock < 0)
    743                     ALOGI("Weird -- accept failed");
    744                 else
    745                     close(tmpSock);
    746             }
    747             if (netState->clientSock >= 0 &&
    748                 FD_ISSET(netState->clientSock, &readfds))
    749             {
    750                 readCount = read(netState->clientSock,
    751                                 netState->inputBuffer + netState->inputCount,
    752                     sizeof(netState->inputBuffer) - netState->inputCount);
    753                 if (readCount < 0) {
    754                     /* read failed */
    755                     if (errno != EINTR)
    756                         goto fail;
    757                     ALOGD("+++ EINTR hit");
    758                     return true;
    759                 } else if (readCount == 0) {
    760                     /* EOF hit -- far end went away */
    761                     ALOGD("+++ peer disconnected");
    762                     goto fail;
    763                 } else
    764                     break;
    765             }
    766         }
    767 
    768         netState->inputCount += readCount;
    769         if (!haveFullPacket(netState))
    770             return true;        /* still not there yet */
    771     }
    772 
    773     /*
    774      * Special-case the initial handshake.  For some bizarre reason we're
    775      * expected to emulate bad tty settings by echoing the request back
    776      * exactly as it was sent.  Note the handshake is always initiated by
    777      * the debugger, no matter who connects to whom.
    778      *
    779      * Other than this one case, the protocol [claims to be] stateless.
    780      */
    781     if (netState->awaitingHandshake) {
    782         int cc;
    783 
    784         if (memcmp(netState->inputBuffer,
    785                 kMagicHandshake, kMagicHandshakeLen) != 0)
    786         {
    787             ALOGE("ERROR: bad handshake '%.14s'", netState->inputBuffer);
    788             goto fail;
    789         }
    790 
    791         errno = 0;
    792         cc = TEMP_FAILURE_RETRY(write(netState->clientSock, netState->inputBuffer,
    793                                       kMagicHandshakeLen));
    794         if (cc != kMagicHandshakeLen) {
    795             ALOGE("Failed writing handshake bytes: %s (%d of %d)",
    796                 strerror(errno), cc, (int) kMagicHandshakeLen);
    797             goto fail;
    798         }
    799 
    800         consumeBytes(netState, kMagicHandshakeLen);
    801         netState->awaitingHandshake = false;
    802         ALOGV("+++ handshake complete");
    803         return true;
    804     }
    805 
    806     /*
    807      * Handle this packet.
    808      */
    809     return handlePacket(state);
    810 
    811 fail:
    812     closeConnection(state);
    813     return false;
    814 }
    815 
    816 /*
    817  * Send a request.
    818  *
    819  * The entire packet must be sent with a single write() call to avoid
    820  * threading issues.
    821  *
    822  * Returns "true" if it was sent successfully.
    823  */
    824 static bool sendRequest(JdwpState* state, ExpandBuf* pReq)
    825 {
    826     JdwpNetState* netState = state->netState;
    827 
    828     /*dumpPacket(expandBufGetBuffer(pReq));*/
    829     if (netState->clientSock < 0) {
    830         /* can happen with some DDMS events */
    831         ALOGV("NOT sending request -- no debugger is attached");
    832         return false;
    833     }
    834 
    835     errno = 0;
    836     ssize_t cc = netState->writePacket(pReq);
    837 
    838     if (cc != (ssize_t) expandBufGetLength(pReq)) {
    839         ALOGE("Failed sending req to debugger: %s (%d of %d)",
    840             strerror(errno), (int) cc, (int) expandBufGetLength(pReq));
    841         return false;
    842     }
    843 
    844     return true;
    845 }
    846 
    847 /*
    848  * Send a request that was split into multiple buffers.
    849  *
    850  * The entire packet must be sent with a single writev() call to avoid
    851  * threading issues.
    852  *
    853  * Returns "true" if it was sent successfully.
    854  */
    855 static bool sendBufferedRequest(JdwpState* state, const struct iovec* iov,
    856     int iovcnt)
    857 {
    858     JdwpNetState* netState = state->netState;
    859 
    860     if (netState->clientSock < 0) {
    861         /* can happen with some DDMS events */
    862         ALOGV("NOT sending request -- no debugger is attached");
    863         return false;
    864     }
    865 
    866     size_t expected = 0;
    867     int i;
    868     for (i = 0; i < iovcnt; i++)
    869         expected += iov[i].iov_len;
    870 
    871     ssize_t actual = netState->writeBufferedPacket(iov, iovcnt);
    872 
    873     if ((size_t)actual != expected) {
    874         ALOGE("Failed sending b-req to debugger: %s (%d of %zu)",
    875             strerror(errno), (int) actual, expected);
    876         return false;
    877     }
    878 
    879     return true;
    880 }
    881 
    882 
    883 /*
    884  * Our functions.
    885  *
    886  * We can't generally share the implementations with other transports,
    887  * even if they're also socket-based, because our JdwpNetState will be
    888  * different from theirs.
    889  */
    890 static const JdwpTransport socketTransport = {
    891     prepareSocket,
    892     acceptConnection,
    893     establishConnection,
    894     closeConnection,
    895     netShutdownExtern,
    896     netFreeExtern,
    897     isConnected,
    898     awaitingHandshake,
    899     processIncoming,
    900     sendRequest,
    901     sendBufferedRequest,
    902 };
    903 
    904 /*
    905  * Return our set.
    906  */
    907 const JdwpTransport* dvmJdwpSocketTransport()
    908 {
    909     return &socketTransport;
    910 }
    911