src/jdk.jdi/share/classes/com/sun/tools/jdi/SocketTransportService.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package com.sun.tools.jdi;

 import java.io.IOException;
 import java.net.Inet6Address;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.SocketTimeoutException;
 import java.net.UnknownHostException;
 import java.util.ResourceBundle;

 import com.sun.jdi.connect.TransportTimeoutException;
 import com.sun.jdi.connect.spi.Connection;
 import com.sun.jdi.connect.spi.TransportService;

 /*
  * A transport service based on a TCP connection between the
  * debugger and debugee.
  */

 public class SocketTransportService extends TransportService {
     private ResourceBundle messages = null;

     /**
      * The listener returned by startListening encapsulates
      * the ServerSocket.
      */
     static class SocketListenKey extends ListenKey {
         ServerSocket ss;

         SocketListenKey(ServerSocket ss) {
             this.ss = ss;
         }

         ServerSocket socket() {
             return ss;
         }

         /*
          * 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();
         }

         public String toString() {
             return address();
         }
     }

     /**
      * Handshake with the debuggee
      */
     void handshake(Socket s, long timeout) throws IOException {
         s.setSoTimeout((int)timeout);

         byte[] hello = "JDWP-Handshake".getBytes("UTF-8");
         s.getOutputStream().write(hello);

         byte[] b = new byte[hello.length];
         int received = 0;
         while (received < hello.length) {
             int n;
             try {
                 n = s.getInputStream().read(b, received, hello.length-received);
             } catch (SocketTimeoutException x) {
                 throw new IOException("handshake timeout");
             }
             if (n < 0) {
                 s.close();
                 throw new IOException("handshake failed - connection prematurally closed");
             }
             received += n;
         }
         for (int i=0; i<hello.length; i++) {
             if (b[i] != hello[i]) {
                 throw new IOException("handshake failed - unrecognized message from target VM");
             }
         }

         // disable read timeout
         s.setSoTimeout(0);
     }

     /**
      * No-arg constructor
      */
     public SocketTransportService() {
     }

     /**
      * The name of this transport service
      */
     public String name() {
         return "Socket";
     }

     /**
      * Return localized description of this transport service
      */
     public String description() {
         synchronized (this) {
             if (messages == null) {
                 messages = ResourceBundle.getBundle("com.sun.tools.jdi.resources.jdi");
             }
         }
         return messages.getString("socket_transportservice.description");
     }

     /**
      * Return the capabilities of this transport service
      */
     public Capabilities capabilities() {
         return new TransportService.Capabilities() {
             public boolean supportsMultipleConnections() {
                 return true;
             }

             public boolean supportsAttachTimeout() {
                 return true;
             }

             public boolean supportsAcceptTimeout() {
                 return true;
             }

             public boolean supportsHandshakeTimeout() {
                 return true;
             }
         };
     }

     /**
      * Attach to the specified address with optional attach and handshake
      * timeout.
      */
     public Connection attach(String address, long attachTimeout, long handshakeTimeout)
         throws IOException {

         if (address == null) {
             throw new NullPointerException("address is null");
         }
         if (attachTimeout < 0 || handshakeTimeout < 0) {
             throw new IllegalArgumentException("timeout is negative");
         }

         int splitIndex = address.indexOf(':');
         String host;
         String portStr;
         if (splitIndex < 0) {
             host = "localhost";
             portStr = address;
         } else {
             host = address.substring(0, splitIndex);
             portStr = address.substring(splitIndex+1);
         }

         if (host.equals("*")) {
             host = InetAddress.getLocalHost().getHostName();
         }

         int port;
         try {
             port = Integer.decode(portStr).intValue();
         } catch (NumberFormatException e) {
             throw new IllegalArgumentException(
                 "unable to parse port number in address");
         }

         // open TCP connection to VM
         InetSocketAddress sa = new InetSocketAddress(host, port);
         Socket s = new Socket();
         try {
             s.connect(sa, (int)attachTimeout);
         } catch (SocketTimeoutException exc) {
             try {
                 s.close();
             } catch (IOException x) { }
             throw new TransportTimeoutException("timed out trying to establish connection");
         }

         // handshake with the target VM
         try {
             handshake(s, handshakeTimeout);
         } catch (IOException exc) {
             try {
                 s.close();
             } catch (IOException x) { }
             throw exc;
         }

         return new SocketConnection(s);
     }

     /*
      * 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();
         if (port == 0) {
             // Only need SO_REUSEADDR if we're using a fixed port. If we
             // start seeing EADDRINUSE due to collisions in free ports
             // then we should retry the bind() a few times.
             ss.setReuseAddress(false);
         }
         ss.bind(sa);
         return new SocketListenKey(ss);
     }

     /**
      * Listen on the specified address
      */
     public ListenKey startListening(String address) throws IOException {
         // use ephemeral port if address isn't specified.
         if (address == null || address.length() == 0) {
             address = "0";
         }

         int splitIndex = address.indexOf(':');
         String localaddr = null;
         if (splitIndex >= 0) {
             localaddr = address.substring(0, splitIndex);
             address = address.substring(splitIndex+1);
         }

         int port;
         try {
             port = Integer.decode(address).intValue();
         } catch (NumberFormatException e) {
             throw new IllegalArgumentException(
                     "unable to parse port number in address");
         }

         return startListening(localaddr, port);
     }

     /**
      * Listen on the default address
      */
     public ListenKey startListening() throws IOException {
         return startListening(null, 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();
         }
     }

     /**
      * 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);
     }

     public String toString() {
        return name();
     }
 }
	/*
	* Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.tools.jdi;

	import java.io.IOException;
	import java.net.Inet6Address;
	import java.net.InetAddress;
	import java.net.InetSocketAddress;
	import java.net.ServerSocket;
	import java.net.Socket;
	import java.net.SocketTimeoutException;
	import java.net.UnknownHostException;
	import java.util.ResourceBundle;

	import com.sun.jdi.connect.TransportTimeoutException;
	import com.sun.jdi.connect.spi.Connection;
	import com.sun.jdi.connect.spi.TransportService;

	/*
	* A transport service based on a TCP connection between the
	* debugger and debugee.
	*/

	public class SocketTransportService extends TransportService {
	private ResourceBundle messages = null;

	/**
	* The listener returned by startListening encapsulates
	* the ServerSocket.
	*/
	static class SocketListenKey extends ListenKey {
	ServerSocket ss;

	SocketListenKey(ServerSocket ss) {
	this.ss = ss;
	}

	ServerSocket socket() {
	return ss;
	}

	/*
	* 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();
	}

	public String toString() {
	return address();
	}
	}

	/**
	* Handshake with the debuggee
	*/
	void handshake(Socket s, long timeout) throws IOException {
	s.setSoTimeout((int)timeout);

	byte[] hello = "JDWP-Handshake".getBytes("UTF-8");
	s.getOutputStream().write(hello);

	byte[] b = new byte[hello.length];
	int received = 0;
	while (received < hello.length) {
	int n;
	try {
	n = s.getInputStream().read(b, received, hello.length-received);
	} catch (SocketTimeoutException x) {
	throw new IOException("handshake timeout");
	}
	if (n < 0) {
	s.close();
	throw new IOException("handshake failed - connection prematurally closed");
	}
	received += n;
	}
	for (int i=0; i<hello.length; i++) {
	if (b[i] != hello[i]) {
	throw new IOException("handshake failed - unrecognized message from target VM");
	}
	}

	// disable read timeout
	s.setSoTimeout(0);
	}

	/**
	* No-arg constructor
	*/
	public SocketTransportService() {
	}

	/**
	* The name of this transport service
	*/
	public String name() {
	return "Socket";
	}

	/**
	* Return localized description of this transport service
	*/
	public String description() {
	synchronized (this) {
	if (messages == null) {
	messages = ResourceBundle.getBundle("com.sun.tools.jdi.resources.jdi");
	}
	}
	return messages.getString("socket_transportservice.description");
	}

	/**
	* Return the capabilities of this transport service
	*/
	public Capabilities capabilities() {
	return new TransportService.Capabilities() {
	public boolean supportsMultipleConnections() {
	return true;
	}

	public boolean supportsAttachTimeout() {
	return true;
	}

	public boolean supportsAcceptTimeout() {
	return true;
	}

	public boolean supportsHandshakeTimeout() {
	return true;
	}
	};
	}

	/**
	* Attach to the specified address with optional attach and handshake
	* timeout.
	*/
	public Connection attach(String address, long attachTimeout, long handshakeTimeout)
	throws IOException {

	if (address == null) {
	throw new NullPointerException("address is null");
	}
	if (attachTimeout < 0 \|\| handshakeTimeout < 0) {
	throw new IllegalArgumentException("timeout is negative");
	}

	int splitIndex = address.indexOf(':');
	String host;
	String portStr;
	if (splitIndex < 0) {
	host = "localhost";
	portStr = address;
	} else {
	host = address.substring(0, splitIndex);
	portStr = address.substring(splitIndex+1);
	}

	if (host.equals("*")) {
	host = InetAddress.getLocalHost().getHostName();
	}

	int port;
	try {
	port = Integer.decode(portStr).intValue();
	} catch (NumberFormatException e) {
	throw new IllegalArgumentException(
	"unable to parse port number in address");
	}

	// open TCP connection to VM
	InetSocketAddress sa = new InetSocketAddress(host, port);
	Socket s = new Socket();
	try {
	s.connect(sa, (int)attachTimeout);
	} catch (SocketTimeoutException exc) {
	try {
	s.close();
	} catch (IOException x) { }
	throw new TransportTimeoutException("timed out trying to establish connection");
	}

	// handshake with the target VM
	try {
	handshake(s, handshakeTimeout);
	} catch (IOException exc) {
	try {
	s.close();
	} catch (IOException x) { }
	throw exc;
	}

	return new SocketConnection(s);
	}

	/*
	* 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();
	if (port == 0) {
	// Only need SO_REUSEADDR if we're using a fixed port. If we
	// start seeing EADDRINUSE due to collisions in free ports
	// then we should retry the bind() a few times.
	ss.setReuseAddress(false);
	}
	ss.bind(sa);
	return new SocketListenKey(ss);
	}

	/**
	* Listen on the specified address
	*/
	public ListenKey startListening(String address) throws IOException {
	// use ephemeral port if address isn't specified.
	if (address == null \|\| address.length() == 0) {
	address = "0";
	}

	int splitIndex = address.indexOf(':');
	String localaddr = null;
	if (splitIndex >= 0) {
	localaddr = address.substring(0, splitIndex);
	address = address.substring(splitIndex+1);
	}

	int port;
	try {
	port = Integer.decode(address).intValue();
	} catch (NumberFormatException e) {
	throw new IllegalArgumentException(
	"unable to parse port number in address");
	}

	return startListening(localaddr, port);
	}

	/**
	* Listen on the default address
	*/
	public ListenKey startListening() throws IOException {
	return startListening(null, 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();
	}
	}

	/**
	* 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);
	}

	public String toString() {
	return name();
	}
	}