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