runtime/jdwp/jdwp_socket.cc - platform/art - Gitiles

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <arpa/inet.h>
 #include <errno.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include "android-base/stringprintf.h"

 #include "base/logging.h"
 #include "jdwp/jdwp_priv.h"

 namespace art {

 namespace JDWP {

 static constexpr uint16_t kBasePort = 8000;
 static constexpr uint16_t kMaxPort = 8040;

 /*
  * JDWP network state.
  *
  * We only talk to one debugger at a time.
  */
 struct JdwpSocketState : public JdwpNetStateBase {
   uint16_t listenPort;
   int     listenSock;         /* listen for connection from debugger */

   explicit JdwpSocketState(JdwpState* state)
       : JdwpNetStateBase(state),
         listenPort(0U),
         listenSock(-1),
         remote_port_(0U) {
   }

   virtual bool Accept();
   virtual bool Establish(const JdwpOptions*);
   virtual void Shutdown();
   virtual bool ProcessIncoming();

  private:
   in_addr remote_addr_;
   uint16_t remote_port_;
 };

 static JdwpSocketState* SocketStartup(JdwpState* state, uint16_t port, bool probe);

 /*
  * Set up some stuff for transport=dt_socket.
  */
 bool InitSocketTransport(JdwpState* state, const JdwpOptions* options) {
   uint16_t port = options->port;

   if (options->server) {
     if (options->port != 0) {
       /* try only the specified port */
       state->netState = SocketStartup(state, port, false);
     } else {
       /* scan through a range of ports, binding to the first available */
       for (port = kBasePort; port <= kMaxPort; port++) {
         state->netState = SocketStartup(state, port, true);
         if (state->netState != nullptr) {
           break;
         }
       }
     }
     if (state->netState == nullptr) {
       LOG(ERROR) << "JDWP net startup failed (req port=" << options->port << ")";
       return false;
     }
   } else {
     state->netState = SocketStartup(state, 0, false);
   }

   if (options->suspend) {
     LOG(INFO) << "JDWP will wait for debugger on port " << port;
   } else {
     LOG(INFO) << "JDWP will " << (options->server ? "listen" : "connect") << " on port " << port;
   }

   return true;
 }

 /*
  * Initialize JDWP stuff.
  *
  * Allocates a new state structure.  If "port" is non-zero, this also
  * tries to bind to a listen port.  If "port" is zero, we assume
  * we're preparing for an outbound connection, and return without binding
  * to anything.
  *
  * This may be called several times if we're probing for a port.
  *
  * Returns 0 on success.
  */
 static JdwpSocketState* SocketStartup(JdwpState* state, uint16_t port, bool probe) {
   JdwpSocketState* netState = new JdwpSocketState(state);
   if (port == 0) {
     return netState;
   }

   netState->listenSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (netState->listenSock < 0) {
     PLOG(probe ? ::android::base::ERROR : ::android::base::FATAL) << "Socket create failed";
     goto fail;
   }

   /* allow immediate re-use */
   {
     int one = 1;
     if (setsockopt(netState->listenSock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
       PLOG(probe ? ::android::base::ERROR : ::android::base::FATAL)
           << "setsockopt(SO_REUSEADDR) failed";
       goto fail;
     }
   }

   union {
     sockaddr_in  addrInet;
     sockaddr     addrPlain;
   } addr;
   addr.addrInet.sin_family = AF_INET;
   addr.addrInet.sin_port = htons(port);
   inet_aton("127.0.0.1", &addr.addrInet.sin_addr);

   if (bind(netState->listenSock, &addr.addrPlain, sizeof(addr)) != 0) {
     PLOG(probe ? ::android::base::ERROR : ::android::base::FATAL)
         << "Attempt to bind to port " << port << " failed";
     goto fail;
   }

   netState->listenPort = port;

   if (listen(netState->listenSock, 5) != 0) {
     PLOG(probe ? ::android::base::ERROR : ::android::base::FATAL) << "Listen failed";
     goto fail;
   }

   return netState;

  fail:
   netState->Shutdown();
   delete netState;
   return nullptr;
 }

 /*
  * Shut down JDWP listener.  Don't free state.
  *
  * This may be called from a non-JDWP thread as part of shutting the
  * JDWP thread down.
  *
  * (This is currently called several times during startup as we probe
  * for an open port.)
  */
 void JdwpSocketState::Shutdown() {
   int local_listenSock = this->listenSock;
   int local_clientSock = this->clientSock;

   /* clear these out so it doesn't wake up and try to reuse them */
   this->listenSock = this->clientSock = -1;

   /* "shutdown" dislodges blocking read() and accept() calls */
   if (local_listenSock != -1) {
     shutdown(local_listenSock, SHUT_RDWR);
     close(local_listenSock);
   }
   if (local_clientSock != -1) {
     shutdown(local_clientSock, SHUT_RDWR);
     close(local_clientSock);
   }

   WakePipe();
 }

 /*
  * Disable the TCP Nagle algorithm, which delays transmission of outbound
  * packets until the previous transmissions have been acked.  JDWP does a
  * lot of back-and-forth with small packets, so this may help.
  */
 static int SetNoDelay(int fd) {
   int on = 1;
   int cc = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
   CHECK_EQ(cc, 0);
   return cc;
 }

 /*
  * Accept a connection.  This will block waiting for somebody to show up.
  * If that's not desirable, use checkConnection() to make sure something
  * is pending.
  */
 bool JdwpSocketState::Accept() {
   union {
     sockaddr_in  addrInet;
     sockaddr     addrPlain;
   } addr;
   socklen_t addrlen;
   int sock;

   if (listenSock < 0) {
     return false;       /* you're not listening! */
   }

   CHECK_EQ(clientSock, -1);      /* must not already be talking */

   addrlen = sizeof(addr);
   do {
     sock = accept(listenSock, &addr.addrPlain, &addrlen);
     if (sock < 0 && errno != EINTR) {
       // When we call shutdown() on the socket, accept() returns with
       // EINVAL.  Don't gripe about it.
       if (errno == EINVAL) {
         if (VLOG_IS_ON(jdwp)) {
           PLOG(ERROR) << "accept failed";
         }
       } else {
         PLOG(ERROR) << "accept failed";
         return false;
       }
     }
   } while (sock < 0);

   remote_addr_ = addr.addrInet.sin_addr;
   remote_port_ = ntohs(addr.addrInet.sin_port);
   VLOG(jdwp) << "+++ accepted connection from " << inet_ntoa(remote_addr_) << ":" << remote_port_;

   clientSock = sock;
   SetAwaitingHandshake(true);
   input_count_ = 0;

   VLOG(jdwp) << "Setting TCP_NODELAY on accepted socket";
   SetNoDelay(clientSock);

   if (!MakePipe()) {
     return false;
   }

   return true;
 }

 /*
  * Create a connection to a waiting debugger.
  */
 bool JdwpSocketState::Establish(const JdwpOptions* options) {
   union {
     sockaddr_in  addrInet;
     sockaddr     addrPlain;
   } addr;
   hostent* pEntry;

   CHECK(!options->server);
   CHECK(!options->host.empty());
   CHECK_NE(options->port, 0);

   /*
    * Start by resolving the host name.
    */
 #if defined(__linux__)
   // Initial size of the work buffer used in gethostbyname_r.
   //
   // The call to gethostbyname_r below requires a user-allocated buffer,
   // the size of which depends on the system. The initial implementation
   // used to use a 128-byte buffer, but that was not enough on some
   // systems (maybe because of IPv6), causing failures in JDWP host
   // testing; thus it was increased to 256.
   //
   // However, we should not use a fixed size: gethostbyname_r's
   // documentation states that if the work buffer is too small (i.e. if
   // gethostbyname_r returns `ERANGE`), then the function should be
   // called again with a bigger buffer. Which we do now, starting with
   // an initial 256-byte buffer, and doubling it until gethostbyname_r
   // accepts this size.
   static constexpr size_t kInitialAuxBufSize = 256;

   std::vector<char> auxBuf(kInitialAuxBufSize);
   hostent he;
   int error;
   int cc;
   while ((cc = gethostbyname_r(
              options->host.c_str(), &he, auxBuf.data(), auxBuf.size(), &pEntry, &error))
          == ERANGE) {
     // The work buffer `auxBuf` is too small; enlarge it.
     auxBuf.resize(auxBuf.size() * 2);
   }
   if (cc != 0 || pEntry == nullptr) {
     LOG(WARNING) << "gethostbyname_r('" << options->host << "') failed: " << hstrerror(error);
     return false;
   }
 #else
   h_errno = 0;
   pEntry = gethostbyname(options->host.c_str());
   if (pEntry == nullptr) {
     PLOG(WARNING) << "gethostbyname('" << options->host << "') failed";
     return false;
   }
 #endif

   /* copy it out ASAP to minimize risk of multithreaded annoyances */
   memcpy(&addr.addrInet.sin_addr, pEntry->h_addr, pEntry->h_length);
   addr.addrInet.sin_family = pEntry->h_addrtype;

   addr.addrInet.sin_port = htons(options->port);

   LOG(INFO) << "Connecting out to " << inet_ntoa(addr.addrInet.sin_addr) << ":"
             << ntohs(addr.addrInet.sin_port);

   /*
    * Create a socket.
    */
   clientSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (clientSock < 0) {
     PLOG(ERROR) << "Unable to create socket";
     return false;
   }

   /*
    * Try to connect.
    */
   if (connect(clientSock, &addr.addrPlain, sizeof(addr)) != 0) {
     PLOG(ERROR) << "Unable to connect to " << inet_ntoa(addr.addrInet.sin_addr) << ":"
                 << ntohs(addr.addrInet.sin_port);
     close(clientSock);
     clientSock = -1;
     return false;
   }

   LOG(INFO) << "Connection established to " << options->host << " ("
             << inet_ntoa(addr.addrInet.sin_addr) << ":" << ntohs(addr.addrInet.sin_port) << ")";
   SetAwaitingHandshake(true);
   input_count_ = 0;

   SetNoDelay(clientSock);

   if (!MakePipe()) {
     return false;
   }

   return true;
 }

 /*
  * Process incoming data.  If no data is available, this will block until
  * some arrives.
  *
  * If we get a full packet, handle it.
  *
  * To take some of the mystery out of life, we want to reject incoming
  * connections if we already have a debugger attached.  If we don't, the
  * debugger will just mysteriously hang until it times out.  We could just
  * close the listen socket, but there's a good chance we won't be able to
  * bind to the same port again, which would confuse utilities.
  *
  * Returns "false" on error (indicating that the connection has been severed),
  * "true" if things are still okay.
  */
 bool JdwpSocketState::ProcessIncoming() {
   int readCount;

   CHECK_NE(clientSock, -1);

   if (!HaveFullPacket()) {
     /* read some more, looping until we have data */
     errno = 0;
     while (1) {
       int selCount;
       fd_set readfds;
       int maxfd = -1;
       int fd;

       FD_ZERO(&readfds);

       /* configure fds; note these may get zapped by another thread */
       fd = listenSock;
       if (fd >= 0) {
         FD_SET(fd, &readfds);
         if (maxfd < fd) {
           maxfd = fd;
         }
       }
       fd = clientSock;
       if (fd >= 0) {
         FD_SET(fd, &readfds);
         if (maxfd < fd) {
           maxfd = fd;
         }
       }
       fd = wake_pipe_[0];
       if (fd >= 0) {
         FD_SET(fd, &readfds);
         if (maxfd < fd) {
           maxfd = fd;
         }
       } else {
         LOG(INFO) << "NOTE: entering select w/o wakepipe";
       }

       if (maxfd < 0) {
         VLOG(jdwp) << "+++ all fds are closed";
         return false;
       }

       /*
        * Select blocks until it sees activity on the file descriptors.
        * Closing the local file descriptor does not count as activity,
        * so we can't rely on that to wake us up (it works for read()
        * and accept(), but not select()).
        *
        * We can do one of three things: (1) send a signal and catch
        * EINTR, (2) open an additional fd ("wake pipe") and write to
        * it when it's time to exit, or (3) time out periodically and
        * re-issue the select.  We're currently using #2, as it's more
        * reliable than #1 and generally better than #3.  Wastes two fds.
        */
       selCount = select(maxfd + 1, &readfds, nullptr, nullptr, nullptr);
       if (selCount < 0) {
         if (errno == EINTR) {
           continue;
         }
         PLOG(ERROR) << "select failed";
         goto fail;
       }

       if (wake_pipe_[0] >= 0 && FD_ISSET(wake_pipe_[0], &readfds)) {
         if (listenSock >= 0) {
           LOG(ERROR) << "Exit wake set, but not exiting?";
         } else {
           VLOG(jdwp) << "Got wake-up signal, bailing out of select";
         }
         goto fail;
       }
       if (listenSock >= 0 && FD_ISSET(listenSock, &readfds)) {
         LOG(INFO) << "Ignoring second debugger -- accepting and dropping";
         union {
           sockaddr_in   addrInet;
           sockaddr      addrPlain;
         } addr;
         socklen_t addrlen;
         int tmpSock;
         tmpSock = accept(listenSock, &addr.addrPlain, &addrlen);
         if (tmpSock < 0) {
           LOG(INFO) << "Weird -- accept failed";
         } else {
           close(tmpSock);
         }
       }
       if (clientSock >= 0 && FD_ISSET(clientSock, &readfds)) {
         readCount =
             read(clientSock, input_buffer_ + input_count_, sizeof(input_buffer_) - input_count_);
         if (readCount < 0) {
           /* read failed */
           if (errno != EINTR) {
             goto fail;
           }
           VLOG(jdwp) << "+++ EINTR hit";
           return true;
         } else if (readCount == 0) {
           /* EOF hit -- far end went away */
           VLOG(jdwp) << "+++ peer disconnected";
           goto fail;
         } else {
           break;
         }
       }
     }

     input_count_ += readCount;
     if (!HaveFullPacket()) {
       return true;        /* still not there yet */
     }
   }

   /*
    * Special-case the initial handshake.  For some bizarre reason we're
    * expected to emulate bad tty settings by echoing the request back
    * exactly as it was sent.  Note the handshake is always initiated by
    * the debugger, no matter who connects to whom.
    *
    * Other than this one case, the protocol [claims to be] stateless.
    */
   if (IsAwaitingHandshake()) {
     if (memcmp(input_buffer_, kMagicHandshake, kMagicHandshakeLen) != 0) {
       LOG(ERROR) << android::base::StringPrintf("ERROR: bad handshake '%.14s'", input_buffer_);
       goto fail;
     }

     errno = 0;
     int cc = TEMP_FAILURE_RETRY(write(clientSock, input_buffer_, kMagicHandshakeLen));
     if (cc != kMagicHandshakeLen) {
       PLOG(ERROR) << "Failed writing handshake bytes ("
                   << cc << " of " << kMagicHandshakeLen << ")";
       goto fail;
     }

     ConsumeBytes(kMagicHandshakeLen);
     SetAwaitingHandshake(false);
     VLOG(jdwp) << "+++ handshake complete";
     return true;
   }

   /*
    * Handle this packet.
    */
   return state_->HandlePacket();

  fail:
   Close();
   return false;
 }

 }  // namespace JDWP

 }  // namespace art
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <arpa/inet.h>
	#include <errno.h>
	#include <netdb.h>
	#include <netinet/in.h>
	#include <netinet/tcp.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/socket.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include "android-base/stringprintf.h"

	#include "base/logging.h"
	#include "jdwp/jdwp_priv.h"

	namespace art {

	namespace JDWP {

	static constexpr uint16_t kBasePort = 8000;
	static constexpr uint16_t kMaxPort = 8040;

	/*
	* JDWP network state.
	*
	* We only talk to one debugger at a time.
	*/
	struct JdwpSocketState : public JdwpNetStateBase {
	uint16_t listenPort;
	int listenSock; /* listen for connection from debugger */

	explicit JdwpSocketState(JdwpState* state)
	: JdwpNetStateBase(state),
	listenPort(0U),
	listenSock(-1),
	remote_port_(0U) {
	}

	virtual bool Accept();
	virtual bool Establish(const JdwpOptions*);
	virtual void Shutdown();
	virtual bool ProcessIncoming();

	private:
	in_addr remote_addr_;
	uint16_t remote_port_;
	};

	static JdwpSocketState* SocketStartup(JdwpState* state, uint16_t port, bool probe);

	/*
	* Set up some stuff for transport=dt_socket.
	*/
	bool InitSocketTransport(JdwpState* state, const JdwpOptions* options) {
	uint16_t port = options->port;

	if (options->server) {
	if (options->port != 0) {
	/* try only the specified port */
	state->netState = SocketStartup(state, port, false);
	} else {
	/* scan through a range of ports, binding to the first available */
	for (port = kBasePort; port <= kMaxPort; port++) {
	state->netState = SocketStartup(state, port, true);
	if (state->netState != nullptr) {
	break;
	}
	}
	}
	if (state->netState == nullptr) {
	LOG(ERROR) << "JDWP net startup failed (req port=" << options->port << ")";
	return false;
	}
	} else {
	state->netState = SocketStartup(state, 0, false);
	}

	if (options->suspend) {
	LOG(INFO) << "JDWP will wait for debugger on port " << port;
	} else {
	LOG(INFO) << "JDWP will " << (options->server ? "listen" : "connect") << " on port " << port;
	}

	return true;
	}

	/*
	* Initialize JDWP stuff.
	*
	* Allocates a new state structure. If "port" is non-zero, this also
	* tries to bind to a listen port. If "port" is zero, we assume
	* we're preparing for an outbound connection, and return without binding
	* to anything.
	*
	* This may be called several times if we're probing for a port.
	*
	* Returns 0 on success.
	*/
	static JdwpSocketState* SocketStartup(JdwpState* state, uint16_t port, bool probe) {
	JdwpSocketState* netState = new JdwpSocketState(state);
	if (port == 0) {
	return netState;
	}

	netState->listenSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (netState->listenSock < 0) {
	PLOG(probe ? ::android::base::ERROR : ::android::base::FATAL) << "Socket create failed";
	goto fail;
	}

	/* allow immediate re-use */
	{
	int one = 1;
	if (setsockopt(netState->listenSock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
	PLOG(probe ? ::android::base::ERROR : ::android::base::FATAL)
	<< "setsockopt(SO_REUSEADDR) failed";
	goto fail;
	}
	}

	union {
	sockaddr_in addrInet;
	sockaddr addrPlain;
	} addr;
	addr.addrInet.sin_family = AF_INET;
	addr.addrInet.sin_port = htons(port);
	inet_aton("127.0.0.1", &addr.addrInet.sin_addr);

	if (bind(netState->listenSock, &addr.addrPlain, sizeof(addr)) != 0) {
	PLOG(probe ? ::android::base::ERROR : ::android::base::FATAL)
	<< "Attempt to bind to port " << port << " failed";
	goto fail;
	}

	netState->listenPort = port;

	if (listen(netState->listenSock, 5) != 0) {
	PLOG(probe ? ::android::base::ERROR : ::android::base::FATAL) << "Listen failed";
	goto fail;
	}

	return netState;

	fail:
	netState->Shutdown();
	delete netState;
	return nullptr;
	}

	/*
	* Shut down JDWP listener. Don't free state.
	*
	* This may be called from a non-JDWP thread as part of shutting the
	* JDWP thread down.
	*
	* (This is currently called several times during startup as we probe
	* for an open port.)
	*/
	void JdwpSocketState::Shutdown() {
	int local_listenSock = this->listenSock;
	int local_clientSock = this->clientSock;

	/* clear these out so it doesn't wake up and try to reuse them */
	this->listenSock = this->clientSock = -1;

	/* "shutdown" dislodges blocking read() and accept() calls */
	if (local_listenSock != -1) {
	shutdown(local_listenSock, SHUT_RDWR);
	close(local_listenSock);
	}
	if (local_clientSock != -1) {
	shutdown(local_clientSock, SHUT_RDWR);
	close(local_clientSock);
	}

	WakePipe();
	}

	/*
	* Disable the TCP Nagle algorithm, which delays transmission of outbound
	* packets until the previous transmissions have been acked. JDWP does a
	* lot of back-and-forth with small packets, so this may help.
	*/
	static int SetNoDelay(int fd) {
	int on = 1;
	int cc = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
	CHECK_EQ(cc, 0);
	return cc;
	}

	/*
	* Accept a connection. This will block waiting for somebody to show up.
	* If that's not desirable, use checkConnection() to make sure something
	* is pending.
	*/
	bool JdwpSocketState::Accept() {
	union {
	sockaddr_in addrInet;
	sockaddr addrPlain;
	} addr;
	socklen_t addrlen;
	int sock;

	if (listenSock < 0) {
	return false; /* you're not listening! */
	}

	CHECK_EQ(clientSock, -1); /* must not already be talking */

	addrlen = sizeof(addr);
	do {
	sock = accept(listenSock, &addr.addrPlain, &addrlen);
	if (sock < 0 && errno != EINTR) {
	// When we call shutdown() on the socket, accept() returns with
	// EINVAL. Don't gripe about it.
	if (errno == EINVAL) {
	if (VLOG_IS_ON(jdwp)) {
	PLOG(ERROR) << "accept failed";
	}
	} else {
	PLOG(ERROR) << "accept failed";
	return false;
	}
	}
	} while (sock < 0);

	remote_addr_ = addr.addrInet.sin_addr;
	remote_port_ = ntohs(addr.addrInet.sin_port);
	VLOG(jdwp) << "+++ accepted connection from " << inet_ntoa(remote_addr_) << ":" << remote_port_;

	clientSock = sock;
	SetAwaitingHandshake(true);
	input_count_ = 0;

	VLOG(jdwp) << "Setting TCP_NODELAY on accepted socket";
	SetNoDelay(clientSock);

	if (!MakePipe()) {
	return false;
	}

	return true;
	}

	/*
	* Create a connection to a waiting debugger.
	*/
	bool JdwpSocketState::Establish(const JdwpOptions* options) {
	union {
	sockaddr_in addrInet;
	sockaddr addrPlain;
	} addr;
	hostent* pEntry;

	CHECK(!options->server);
	CHECK(!options->host.empty());
	CHECK_NE(options->port, 0);

	/*
	* Start by resolving the host name.
	*/
	#if defined(__linux__)
	// Initial size of the work buffer used in gethostbyname_r.
	//
	// The call to gethostbyname_r below requires a user-allocated buffer,
	// the size of which depends on the system. The initial implementation
	// used to use a 128-byte buffer, but that was not enough on some
	// systems (maybe because of IPv6), causing failures in JDWP host
	// testing; thus it was increased to 256.
	//
	// However, we should not use a fixed size: gethostbyname_r's
	// documentation states that if the work buffer is too small (i.e. if
	// gethostbyname_r returns `ERANGE`), then the function should be
	// called again with a bigger buffer. Which we do now, starting with
	// an initial 256-byte buffer, and doubling it until gethostbyname_r
	// accepts this size.
	static constexpr size_t kInitialAuxBufSize = 256;

	std::vector<char> auxBuf(kInitialAuxBufSize);
	hostent he;
	int error;
	int cc;
	while ((cc = gethostbyname_r(
	options->host.c_str(), &he, auxBuf.data(), auxBuf.size(), &pEntry, &error))
	== ERANGE) {
	// The work buffer `auxBuf` is too small; enlarge it.
	auxBuf.resize(auxBuf.size() * 2);
	}
	if (cc != 0 \|\| pEntry == nullptr) {
	LOG(WARNING) << "gethostbyname_r('" << options->host << "') failed: " << hstrerror(error);
	return false;
	}
	#else
	h_errno = 0;
	pEntry = gethostbyname(options->host.c_str());
	if (pEntry == nullptr) {
	PLOG(WARNING) << "gethostbyname('" << options->host << "') failed";
	return false;
	}
	#endif

	/* copy it out ASAP to minimize risk of multithreaded annoyances */
	memcpy(&addr.addrInet.sin_addr, pEntry->h_addr, pEntry->h_length);
	addr.addrInet.sin_family = pEntry->h_addrtype;

	addr.addrInet.sin_port = htons(options->port);

	LOG(INFO) << "Connecting out to " << inet_ntoa(addr.addrInet.sin_addr) << ":"
	<< ntohs(addr.addrInet.sin_port);

	/*
	* Create a socket.
	*/
	clientSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (clientSock < 0) {
	PLOG(ERROR) << "Unable to create socket";
	return false;
	}

	/*
	* Try to connect.
	*/
	if (connect(clientSock, &addr.addrPlain, sizeof(addr)) != 0) {
	PLOG(ERROR) << "Unable to connect to " << inet_ntoa(addr.addrInet.sin_addr) << ":"
	<< ntohs(addr.addrInet.sin_port);
	close(clientSock);
	clientSock = -1;
	return false;
	}

	LOG(INFO) << "Connection established to " << options->host << " ("
	<< inet_ntoa(addr.addrInet.sin_addr) << ":" << ntohs(addr.addrInet.sin_port) << ")";
	SetAwaitingHandshake(true);
	input_count_ = 0;

	SetNoDelay(clientSock);

	if (!MakePipe()) {
	return false;
	}

	return true;
	}

	/*
	* Process incoming data. If no data is available, this will block until
	* some arrives.
	*
	* If we get a full packet, handle it.
	*
	* To take some of the mystery out of life, we want to reject incoming
	* connections if we already have a debugger attached. If we don't, the
	* debugger will just mysteriously hang until it times out. We could just
	* close the listen socket, but there's a good chance we won't be able to
	* bind to the same port again, which would confuse utilities.
	*
	* Returns "false" on error (indicating that the connection has been severed),
	* "true" if things are still okay.
	*/
	bool JdwpSocketState::ProcessIncoming() {
	int readCount;

	CHECK_NE(clientSock, -1);

	if (!HaveFullPacket()) {
	/* read some more, looping until we have data */
	errno = 0;
	while (1) {
	int selCount;
	fd_set readfds;
	int maxfd = -1;
	int fd;

	FD_ZERO(&readfds);

	/* configure fds; note these may get zapped by another thread */
	fd = listenSock;
	if (fd >= 0) {
	FD_SET(fd, &readfds);
	if (maxfd < fd) {
	maxfd = fd;
	}
	}
	fd = clientSock;
	if (fd >= 0) {
	FD_SET(fd, &readfds);
	if (maxfd < fd) {
	maxfd = fd;
	}
	}
	fd = wake_pipe_[0];
	if (fd >= 0) {
	FD_SET(fd, &readfds);
	if (maxfd < fd) {
	maxfd = fd;
	}
	} else {
	LOG(INFO) << "NOTE: entering select w/o wakepipe";
	}

	if (maxfd < 0) {
	VLOG(jdwp) << "+++ all fds are closed";
	return false;
	}

	/*
	* Select blocks until it sees activity on the file descriptors.
	* Closing the local file descriptor does not count as activity,
	* so we can't rely on that to wake us up (it works for read()
	* and accept(), but not select()).
	*
	* We can do one of three things: (1) send a signal and catch
	* EINTR, (2) open an additional fd ("wake pipe") and write to
	* it when it's time to exit, or (3) time out periodically and
	* re-issue the select. We're currently using #2, as it's more
	* reliable than #1 and generally better than #3. Wastes two fds.
	*/
	selCount = select(maxfd + 1, &readfds, nullptr, nullptr, nullptr);
	if (selCount < 0) {
	if (errno == EINTR) {
	continue;
	}
	PLOG(ERROR) << "select failed";
	goto fail;
	}

	if (wake_pipe_[0] >= 0 && FD_ISSET(wake_pipe_[0], &readfds)) {
	if (listenSock >= 0) {
	LOG(ERROR) << "Exit wake set, but not exiting?";
	} else {
	VLOG(jdwp) << "Got wake-up signal, bailing out of select";
	}
	goto fail;
	}
	if (listenSock >= 0 && FD_ISSET(listenSock, &readfds)) {
	LOG(INFO) << "Ignoring second debugger -- accepting and dropping";
	union {
	sockaddr_in addrInet;
	sockaddr addrPlain;
	} addr;
	socklen_t addrlen;
	int tmpSock;
	tmpSock = accept(listenSock, &addr.addrPlain, &addrlen);
	if (tmpSock < 0) {
	LOG(INFO) << "Weird -- accept failed";
	} else {
	close(tmpSock);
	}
	}
	if (clientSock >= 0 && FD_ISSET(clientSock, &readfds)) {
	readCount =
	read(clientSock, input_buffer_ + input_count_, sizeof(input_buffer_) - input_count_);
	if (readCount < 0) {
	/* read failed */
	if (errno != EINTR) {
	goto fail;
	}
	VLOG(jdwp) << "+++ EINTR hit";
	return true;
	} else if (readCount == 0) {
	/* EOF hit -- far end went away */
	VLOG(jdwp) << "+++ peer disconnected";
	goto fail;
	} else {
	break;
	}
	}
	}

	input_count_ += readCount;
	if (!HaveFullPacket()) {
	return true; /* still not there yet */
	}
	}

	/*
	* Special-case the initial handshake. For some bizarre reason we're
	* expected to emulate bad tty settings by echoing the request back
	* exactly as it was sent. Note the handshake is always initiated by
	* the debugger, no matter who connects to whom.
	*
	* Other than this one case, the protocol [claims to be] stateless.
	*/
	if (IsAwaitingHandshake()) {
	if (memcmp(input_buffer_, kMagicHandshake, kMagicHandshakeLen) != 0) {
	LOG(ERROR) << android::base::StringPrintf("ERROR: bad handshake '%.14s'", input_buffer_);
	goto fail;
	}

	errno = 0;
	int cc = TEMP_FAILURE_RETRY(write(clientSock, input_buffer_, kMagicHandshakeLen));
	if (cc != kMagicHandshakeLen) {
	PLOG(ERROR) << "Failed writing handshake bytes ("
	<< cc << " of " << kMagicHandshakeLen << ")";
	goto fail;
	}

	ConsumeBytes(kMagicHandshakeLen);
	SetAwaitingHandshake(false);
	VLOG(jdwp) << "+++ handshake complete";
	return true;
	}

	/*
	* Handle this packet.
	*/
	return state_->HandlePacket();

	fail:
	Close();
	return false;
	}

	} // namespace JDWP

	} // namespace art