537 lines
16 KiB
Java
537 lines
16 KiB
Java
/*
|
|
* 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.
|
|
*/
|
|
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 SocketTransportServiceCapabilities();
|
|
}
|
|
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
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();
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
|
|
}
|