text: /*
   * 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
  