コード例 #1
0
 /*
  * Listen on the specified address and port. Return a listener
  * that encapsulates the ServerSocket.
  */
 ListenKey startListening(String localaddress, int port) throws IOException {
   InetSocketAddress sa;
   if (localaddress == null) {
     sa = new InetSocketAddress(port);
   } else {
     sa = new InetSocketAddress(localaddress, port);
   }
   ServerSocket ss = new ServerSocket();
   ss.bind(sa);
   return new SocketListenKey(ss);
 }
コード例 #2
0
  /** Stop the listener */
  public void stopListening(ListenKey listener) throws IOException {
    if (!(listener instanceof SocketListenKey)) {
      throw new IllegalArgumentException("Invalid listener");
    }

    synchronized (listener) {
      ServerSocket ss = ((SocketListenKey) listener).socket();

      // if the ServerSocket has been closed it means
      // the listener is invalid
      if (ss.isClosed()) {
        throw new IllegalArgumentException("Invalid listener");
      }
      ss.close();
    }
  }
コード例 #3
0
    /*
     * Returns the string representation of the address that this
     * listen key represents.
     */
    public String address() {
      InetAddress address = ss.getInetAddress();

      /*
       * If bound to the wildcard address then use current local
       * hostname. In the event that we don't know our own hostname
       * then assume that host supports IPv4 and return something to
       * represent the loopback address.
       */
      if (address.isAnyLocalAddress()) {
        try {
          address = InetAddress.getLocalHost();
        } catch (UnknownHostException uhe) {
          byte[] loopback = {0x7f, 0x00, 0x00, 0x01};
          try {
            address = InetAddress.getByAddress("127.0.0.1", loopback);
          } catch (UnknownHostException x) {
            throw new InternalError("unable to get local hostname");
          }
        }
      }

      /*
       * Now decide if we return a hostname or IP address. Where possible
       * return a hostname but in the case that we are bound to an
       * address that isn't registered in the name service then we
       * return an address.
       */
      String result;
      String hostname = address.getHostName();
      String hostaddr = address.getHostAddress();
      if (hostname.equals(hostaddr)) {
        if (address instanceof Inet6Address) {
          result = "[" + hostaddr + "]";
        } else {
          result = hostaddr;
        }
      } else {
        result = hostname;
      }

      /*
       * Finally return "hostname:port", "ipv4-address:port" or
       * "[ipv6-address]:port".
       */
      return result + ":" + ss.getLocalPort();
    }
コード例 #4
0
  /** Accept a connection from a debuggee and handshake with it. */
  public Connection accept(ListenKey listener, long acceptTimeout, long handshakeTimeout)
      throws IOException {
    if (acceptTimeout < 0 || handshakeTimeout < 0) {
      throw new IllegalArgumentException("timeout is negative");
    }
    if (!(listener instanceof SocketListenKey)) {
      throw new IllegalArgumentException("Invalid listener");
    }
    ServerSocket ss;

    // obtain the ServerSocket from the listener - if the
    // socket is closed it means the listener is invalid
    synchronized (listener) {
      ss = ((SocketListenKey) listener).socket();
      if (ss.isClosed()) {
        throw new IllegalArgumentException("Invalid listener");
      }
    }

    // from here onwards it's possible that the ServerSocket
    // may be closed by a call to stopListening - that's okay
    // because the ServerSocket methods will throw an
    // IOException indicating the socket is closed.
    //
    // Additionally, it's possible that another thread calls accept
    // with a different accept timeout - that creates a same race
    // condition between setting the timeout and calling accept.
    // As it is such an unlikely scenario (requires both threads
    // to be using the same listener we've chosen to ignore the issue).

    ss.setSoTimeout((int) acceptTimeout);
    Socket s;
    try {
      s = ss.accept();
    } catch (SocketTimeoutException x) {
      throw new TransportTimeoutException("timeout waiting for connection");
    }

    // handshake here
    handshake(s, handshakeTimeout);

    return new SocketConnection(s);
  }