/*
 * Copyright (c) 1998, 2003, 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 com.sun.jdi.*;
import com.sun.jdi.connect.*;
import com.sun.jdi.connect.spi.*;
import java.net.*;
import java.io.*;
import java.util.Map;
import java.util.ResourceBundle;

/*
 * 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.
/** * 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
/** * 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
/** * No-arg constructor */
public SocketTransportService() { }
The name of this transport service
/** * The name of this transport service */
public String name() { return "Socket"; }
Return localized description of this transport service
/** * 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
/** * Return the capabilities of this transport service */
public Capabilities capabilities() { return new SocketTransportServiceCapabilities(); }
Attach to the specified address with optional attach and handshake timeout.
/** * 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 = InetAddress.getLocalHost().getHostName(); portStr = address; } else { host = address.substring(0, splitIndex); portStr = address.substring(splitIndex+1); } 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(); ss.bind(sa); return new SocketListenKey(ss); }
Listen on the specified address
/** * 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
/** * Listen on the default address */
public ListenKey startListening() throws IOException { return startListening(null, 0); }
Stop the listener
/** * 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.
/** * 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(); } } /* * The Connection returned by attach and accept is one of these */ class SocketConnection extends Connection { private Socket socket; private boolean closed = false; private OutputStream socketOutput; private InputStream socketInput; private Object receiveLock = new Object(); private Object sendLock = new Object(); private Object closeLock = new Object(); SocketConnection(Socket socket) throws IOException { this.socket = socket; socket.setTcpNoDelay(true); socketInput = socket.getInputStream(); socketOutput = socket.getOutputStream(); } public void close() throws IOException { synchronized (closeLock) { if (closed) { return; } socketOutput.close(); socketInput.close(); socket.close(); closed = true; } } public boolean isOpen() { synchronized (closeLock) { return !closed; } } public byte[] readPacket() throws IOException { if (!isOpen()) { throw new ClosedConnectionException("connection is closed"); } synchronized (receiveLock) { int b1,b2,b3,b4; // length try { b1 = socketInput.read(); b2 = socketInput.read(); b3 = socketInput.read(); b4 = socketInput.read(); } catch (IOException ioe) { if (!isOpen()) { throw new ClosedConnectionException("connection is closed"); } else { throw ioe; } } // EOF if (b1<0) { return new byte[0]; } if (b2<0 || b3<0 || b4<0) { throw new IOException("protocol error - premature EOF"); } int len = ((b1 << 24) | (b2 << 16) | (b3 << 8) | (b4 << 0)); if (len < 0) { throw new IOException("protocol error - invalid length"); } byte b[] = new byte[len]; b[0] = (byte)b1; b[1] = (byte)b2; b[2] = (byte)b3; b[3] = (byte)b4; int off = 4; len -= off; while (len > 0) { int count; try { count = socketInput.read(b, off, len); } catch (IOException ioe) { if (!isOpen()) { throw new ClosedConnectionException("connection is closed"); } else { throw ioe; } } if (count < 0) { throw new IOException("protocol error - premature EOF"); } len -= count; off += count; } return b; } } public void writePacket(byte b[]) throws IOException { if (!isOpen()) { throw new ClosedConnectionException("connection is closed"); } /* * Check the packet size */ if (b.length < 11) { throw new IllegalArgumentException("packet is insufficient size"); } int b0 = b[0] & 0xff; int b1 = b[1] & 0xff; int b2 = b[2] & 0xff; int b3 = b[3] & 0xff; int len = ((b0 << 24) | (b1 << 16) | (b2 << 8) | (b3 << 0)); if (len < 11) { throw new IllegalArgumentException("packet is insufficient size"); } /* * Check that the byte array contains the complete packet */ if (len > b.length) { throw new IllegalArgumentException("length mis-match"); } synchronized (sendLock) { try { /* * Send the packet (ignoring any bytes that follow * the packet in the byte array). */ socketOutput.write(b, 0, len); } catch (IOException ioe) { if (!isOpen()) { throw new ClosedConnectionException("connection is closed"); } else { throw ioe; } } } } } /* * The capabilities of the socket transport service */ class SocketTransportServiceCapabilities extends TransportService.Capabilities { public boolean supportsMultipleConnections() { return true; } public boolean supportsAttachTimeout() { return true; } public boolean supportsAcceptTimeout() { return true; } public boolean supportsHandshakeTimeout() { return true; } }