ddms/libs/ddmlib/src/com/android/ddmlib/Debugger.java - platform/sdk - Git at Google

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.ddmlib;

 import com.android.ddmlib.ClientData.DebuggerStatus;

 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.nio.BufferOverflowException;
 import java.nio.ByteBuffer;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.ServerSocketChannel;
 import java.nio.channels.SocketChannel;

 /**
  * This represents a pending or established connection with a JDWP debugger.
  */
 class Debugger {

     /*
      * Messages from the debugger should be pretty small; may not even
      * need an expanding-buffer implementation for this.
      */
     private static final int INITIAL_BUF_SIZE = 1 * 1024;
     private static final int MAX_BUF_SIZE = 32 * 1024;
     private ByteBuffer mReadBuffer;

     private static final int PRE_DATA_BUF_SIZE = 256;
     private ByteBuffer mPreDataBuffer;

     /* connection state */
     private int mConnState;
     private static final int ST_NOT_CONNECTED = 1;
     private static final int ST_AWAIT_SHAKE   = 2;
     private static final int ST_READY         = 3;

     /* peer */
     private Client mClient;         // client we're forwarding to/from
     private int mListenPort;        // listen to me
     private ServerSocketChannel mListenChannel;

     /* this goes up and down; synchronize methods that access the field */
     private SocketChannel mChannel;

     /**
      * Create a new Debugger object, configured to listen for connections
      * on a specific port.
      */
     Debugger(Client client, int listenPort) throws IOException {

         mClient = client;
         mListenPort = listenPort;

         mListenChannel = ServerSocketChannel.open();
         mListenChannel.configureBlocking(false);        // required for Selector

         InetSocketAddress addr = new InetSocketAddress(
                 InetAddress.getByName("localhost"), //$NON-NLS-1$
                 listenPort);
         mListenChannel.socket().setReuseAddress(true);  // enable SO_REUSEADDR
         mListenChannel.socket().bind(addr);

         mReadBuffer = ByteBuffer.allocate(INITIAL_BUF_SIZE);
         mPreDataBuffer = ByteBuffer.allocate(PRE_DATA_BUF_SIZE);
         mConnState = ST_NOT_CONNECTED;

         Log.d("ddms", "Created: " + this.toString());
     }

     /**
      * Returns "true" if a debugger is currently attached to us.
      */
     boolean isDebuggerAttached() {
         return mChannel != null;
     }

     /**
      * Represent the Debugger as a string.
      */
     @Override
     public String toString() {
         // mChannel != null means we have connection, ST_READY means it's going
         return "[Debugger " + mListenPort + "-->" + mClient.getClientData().getPid()
                 + ((mConnState != ST_READY) ? " inactive]" : " active]");
     }

     /**
      * Register the debugger's listen socket with the Selector.
      */
     void registerListener(Selector sel) throws IOException {
         mListenChannel.register(sel, SelectionKey.OP_ACCEPT, this);
     }

     /**
      * Return the Client being debugged.
      */
     Client getClient() {
         return mClient;
     }

     /**
      * Accept a new connection, but only if we don't already have one.
      *
      * Must be synchronized with other uses of mChannel and mPreBuffer.
      *
      * Returns "null" if we're already talking to somebody.
      */
     synchronized SocketChannel accept() throws IOException {
         return accept(mListenChannel);
     }

     /**
      * Accept a new connection from the specified listen channel.  This
      * is so we can listen on a dedicated port for the "current" client,
      * where "current" is constantly in flux.
      *
      * Must be synchronized with other uses of mChannel and mPreBuffer.
      *
      * Returns "null" if we're already talking to somebody.
      */
     synchronized SocketChannel accept(ServerSocketChannel listenChan)
         throws IOException {

         if (listenChan != null) {
             SocketChannel newChan;

             newChan = listenChan.accept();
             if (mChannel != null) {
                 Log.w("ddms", "debugger already talking to " + mClient
                     + " on " + mListenPort);
                 newChan.close();
                 return null;
             }
             mChannel = newChan;
             mChannel.configureBlocking(false);         // required for Selector
             mConnState = ST_AWAIT_SHAKE;
             return mChannel;
         }

         return null;
     }

     /**
      * Close the data connection only.
      */
     synchronized void closeData() {
         try {
             if (mChannel != null) {
                 mChannel.close();
                 mChannel = null;
                 mConnState = ST_NOT_CONNECTED;

                 ClientData cd = mClient.getClientData();
                 cd.setDebuggerConnectionStatus(DebuggerStatus.DEFAULT);
                 mClient.update(Client.CHANGE_DEBUGGER_STATUS);
             }
         } catch (IOException ioe) {
             Log.w("ddms", "Failed to close data " + this);
         }
     }

     /**
      * Close the socket that's listening for new connections and (if
      * we're connected) the debugger data socket.
      */
     synchronized void close() {
         try {
             if (mListenChannel != null) {
                 mListenChannel.close();
             }
             mListenChannel = null;
             closeData();
         } catch (IOException ioe) {
             Log.w("ddms", "Failed to close listener " + this);
         }
     }

     // TODO: ?? add a finalizer that verifies the channel was closed

     /**
      * Read data from our channel.
      *
      * This is called when data is known to be available, and we don't yet
      * have a full packet in the buffer.  If the buffer is at capacity,
      * expand it.
      */
     void read() throws IOException {
         int count;

         if (mReadBuffer.position() == mReadBuffer.capacity()) {
             if (mReadBuffer.capacity() * 2 > MAX_BUF_SIZE) {
                 throw new BufferOverflowException();
             }
             Log.d("ddms", "Expanding read buffer to "
                 + mReadBuffer.capacity() * 2);

             ByteBuffer newBuffer =
                     ByteBuffer.allocate(mReadBuffer.capacity() * 2);
             mReadBuffer.position(0);
             newBuffer.put(mReadBuffer);     // leaves "position" at end

             mReadBuffer = newBuffer;
         }

         count = mChannel.read(mReadBuffer);
         Log.v("ddms", "Read " + count + " bytes from " + this);
         if (count < 0) throw new IOException("read failed");
     }

     /**
      * Return information for the first full JDWP packet in the buffer.
      *
      * If we don't yet have a full packet, return null.
      *
      * If we haven't yet received the JDWP handshake, we watch for it here
      * and consume it without admitting to have done so.  We also send
      * the handshake response to the debugger, along with any pending
      * pre-connection data, which is why this can throw an IOException.
      */
     JdwpPacket getJdwpPacket() throws IOException {
         /*
          * On entry, the data starts at offset 0 and ends at "position".
          * "limit" is set to the buffer capacity.
          */
         if (mConnState == ST_AWAIT_SHAKE) {
             int result;

             result = JdwpPacket.findHandshake(mReadBuffer);
             //Log.v("ddms", "findHand: " + result);
             switch (result) {
                 case JdwpPacket.HANDSHAKE_GOOD:
                     Log.d("ddms", "Good handshake from debugger");
                     JdwpPacket.consumeHandshake(mReadBuffer);
                     sendHandshake();
                     mConnState = ST_READY;

                     ClientData cd = mClient.getClientData();
                     cd.setDebuggerConnectionStatus(DebuggerStatus.ATTACHED);
                     mClient.update(Client.CHANGE_DEBUGGER_STATUS);

                     // see if we have another packet in the buffer
                     return getJdwpPacket();
                 case JdwpPacket.HANDSHAKE_BAD:
                     // not a debugger, throw an exception so we drop the line
                     Log.d("ddms", "Bad handshake from debugger");
                     throw new IOException("bad handshake");
                 case JdwpPacket.HANDSHAKE_NOTYET:
                     break;
                 default:
                     Log.e("ddms", "Unknown packet while waiting for client handshake");
             }
             return null;
         } else if (mConnState == ST_READY) {
             if (mReadBuffer.position() != 0) {
                 Log.v("ddms", "Checking " + mReadBuffer.position() + " bytes");
             }
             return JdwpPacket.findPacket(mReadBuffer);
         } else {
             Log.e("ddms", "Receiving data in state = " + mConnState);
         }

         return null;
     }

     /**
      * Forward a packet to the client.
      *
      * "mClient" will never be null, though it's possible that the channel
      * in the client has closed and our send attempt will fail.
      *
      * Consumes the packet.
      */
     void forwardPacketToClient(JdwpPacket packet) throws IOException {
         mClient.sendAndConsume(packet);
     }

     /**
      * Send the handshake to the debugger.  We also send along any packets
      * we already received from the client (usually just a VM_START event,
      * if anything at all).
      */
     private synchronized void sendHandshake() throws IOException {
         ByteBuffer tempBuffer = ByteBuffer.allocate(JdwpPacket.HANDSHAKE_LEN);
         JdwpPacket.putHandshake(tempBuffer);
         int expectedLength = tempBuffer.position();
         tempBuffer.flip();
         if (mChannel.write(tempBuffer) != expectedLength) {
             throw new IOException("partial handshake write");
         }

         expectedLength = mPreDataBuffer.position();
         if (expectedLength > 0) {
             Log.d("ddms", "Sending " + mPreDataBuffer.position()
                     + " bytes of saved data");
             mPreDataBuffer.flip();
             if (mChannel.write(mPreDataBuffer) != expectedLength) {
                 throw new IOException("partial pre-data write");
             }
             mPreDataBuffer.clear();
         }
     }

     /**
      * Send a packet to the debugger.
      *
      * Ideally, we can do this with a single channel write.  If that doesn't
      * happen, we have to prevent anybody else from writing to the channel
      * until this packet completes, so we synchronize on the channel.
      *
      * Another goal is to avoid unnecessary buffer copies, so we write
      * directly out of the JdwpPacket's ByteBuffer.
      *
      * We must synchronize on "mChannel" before writing to it.  We want to
      * coordinate the buffered data with mChannel creation, so this whole
      * method is synchronized.
      */
     synchronized void sendAndConsume(JdwpPacket packet)
         throws IOException {

         if (mChannel == null) {
             /*
              * Buffer this up so we can send it to the debugger when it
              * finally does connect.  This is essential because the VM_START
              * message might be telling the debugger that the VM is
              * suspended.  The alternative approach would be for us to
              * capture and interpret VM_START and send it later if we
              * didn't choose to un-suspend the VM for our own purposes.
              */
             Log.d("ddms", "Saving packet 0x"
                     + Integer.toHexString(packet.getId()));
             packet.movePacket(mPreDataBuffer);
         } else {
             packet.writeAndConsume(mChannel);
         }
     }
 }
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.ddmlib;

	import com.android.ddmlib.ClientData.DebuggerStatus;

	import java.io.IOException;
	import java.net.InetAddress;
	import java.net.InetSocketAddress;
	import java.nio.BufferOverflowException;
	import java.nio.ByteBuffer;
	import java.nio.channels.SelectionKey;
	import java.nio.channels.Selector;
	import java.nio.channels.ServerSocketChannel;
	import java.nio.channels.SocketChannel;

	/**
	* This represents a pending or established connection with a JDWP debugger.
	*/
	class Debugger {

	/*
	* Messages from the debugger should be pretty small; may not even
	* need an expanding-buffer implementation for this.
	*/
	private static final int INITIAL_BUF_SIZE = 1 * 1024;
	private static final int MAX_BUF_SIZE = 32 * 1024;
	private ByteBuffer mReadBuffer;

	private static final int PRE_DATA_BUF_SIZE = 256;
	private ByteBuffer mPreDataBuffer;

	/* connection state */
	private int mConnState;
	private static final int ST_NOT_CONNECTED = 1;
	private static final int ST_AWAIT_SHAKE = 2;
	private static final int ST_READY = 3;

	/* peer */
	private Client mClient; // client we're forwarding to/from
	private int mListenPort; // listen to me
	private ServerSocketChannel mListenChannel;

	/* this goes up and down; synchronize methods that access the field */
	private SocketChannel mChannel;

	/**
	* Create a new Debugger object, configured to listen for connections
	* on a specific port.
	*/
	Debugger(Client client, int listenPort) throws IOException {

	mClient = client;
	mListenPort = listenPort;

	mListenChannel = ServerSocketChannel.open();
	mListenChannel.configureBlocking(false); // required for Selector

	InetSocketAddress addr = new InetSocketAddress(
	InetAddress.getByName("localhost"), //$NON-NLS-1$
	listenPort);
	mListenChannel.socket().setReuseAddress(true); // enable SO_REUSEADDR
	mListenChannel.socket().bind(addr);

	mReadBuffer = ByteBuffer.allocate(INITIAL_BUF_SIZE);
	mPreDataBuffer = ByteBuffer.allocate(PRE_DATA_BUF_SIZE);
	mConnState = ST_NOT_CONNECTED;

	Log.d("ddms", "Created: " + this.toString());
	}

	/**
	* Returns "true" if a debugger is currently attached to us.
	*/
	boolean isDebuggerAttached() {
	return mChannel != null;
	}

	/**
	* Represent the Debugger as a string.
	*/
	@Override
	public String toString() {
	// mChannel != null means we have connection, ST_READY means it's going
	return "[Debugger " + mListenPort + "-->" + mClient.getClientData().getPid()
	+ ((mConnState != ST_READY) ? " inactive]" : " active]");
	}

	/**
	* Register the debugger's listen socket with the Selector.
	*/
	void registerListener(Selector sel) throws IOException {
	mListenChannel.register(sel, SelectionKey.OP_ACCEPT, this);
	}

	/**
	* Return the Client being debugged.
	*/
	Client getClient() {
	return mClient;
	}

	/**
	* Accept a new connection, but only if we don't already have one.
	*
	* Must be synchronized with other uses of mChannel and mPreBuffer.
	*
	* Returns "null" if we're already talking to somebody.
	*/
	synchronized SocketChannel accept() throws IOException {
	return accept(mListenChannel);
	}

	/**
	* Accept a new connection from the specified listen channel. This
	* is so we can listen on a dedicated port for the "current" client,
	* where "current" is constantly in flux.
	*
	* Must be synchronized with other uses of mChannel and mPreBuffer.
	*
	* Returns "null" if we're already talking to somebody.
	*/
	synchronized SocketChannel accept(ServerSocketChannel listenChan)
	throws IOException {

	if (listenChan != null) {
	SocketChannel newChan;

	newChan = listenChan.accept();
	if (mChannel != null) {
	Log.w("ddms", "debugger already talking to " + mClient
	+ " on " + mListenPort);
	newChan.close();
	return null;
	}
	mChannel = newChan;
	mChannel.configureBlocking(false); // required for Selector
	mConnState = ST_AWAIT_SHAKE;
	return mChannel;
	}

	return null;
	}

	/**
	* Close the data connection only.
	*/
	synchronized void closeData() {
	try {
	if (mChannel != null) {
	mChannel.close();
	mChannel = null;
	mConnState = ST_NOT_CONNECTED;

	ClientData cd = mClient.getClientData();
	cd.setDebuggerConnectionStatus(DebuggerStatus.DEFAULT);
	mClient.update(Client.CHANGE_DEBUGGER_STATUS);
	}
	} catch (IOException ioe) {
	Log.w("ddms", "Failed to close data " + this);
	}
	}

	/**
	* Close the socket that's listening for new connections and (if
	* we're connected) the debugger data socket.
	*/
	synchronized void close() {
	try {
	if (mListenChannel != null) {
	mListenChannel.close();
	}
	mListenChannel = null;
	closeData();
	} catch (IOException ioe) {
	Log.w("ddms", "Failed to close listener " + this);
	}
	}

	// TODO: ?? add a finalizer that verifies the channel was closed

	/**
	* Read data from our channel.
	*
	* This is called when data is known to be available, and we don't yet
	* have a full packet in the buffer. If the buffer is at capacity,
	* expand it.
	*/
	void read() throws IOException {
	int count;

	if (mReadBuffer.position() == mReadBuffer.capacity()) {
	if (mReadBuffer.capacity() * 2 > MAX_BUF_SIZE) {
	throw new BufferOverflowException();
	}
	Log.d("ddms", "Expanding read buffer to "
	+ mReadBuffer.capacity() * 2);

	ByteBuffer newBuffer =
	ByteBuffer.allocate(mReadBuffer.capacity() * 2);
	mReadBuffer.position(0);
	newBuffer.put(mReadBuffer); // leaves "position" at end

	mReadBuffer = newBuffer;
	}

	count = mChannel.read(mReadBuffer);
	Log.v("ddms", "Read " + count + " bytes from " + this);
	if (count < 0) throw new IOException("read failed");
	}

	/**
	* Return information for the first full JDWP packet in the buffer.
	*
	* If we don't yet have a full packet, return null.
	*
	* If we haven't yet received the JDWP handshake, we watch for it here
	* and consume it without admitting to have done so. We also send
	* the handshake response to the debugger, along with any pending
	* pre-connection data, which is why this can throw an IOException.
	*/
	JdwpPacket getJdwpPacket() throws IOException {
	/*
	* On entry, the data starts at offset 0 and ends at "position".
	* "limit" is set to the buffer capacity.
	*/
	if (mConnState == ST_AWAIT_SHAKE) {
	int result;

	result = JdwpPacket.findHandshake(mReadBuffer);
	//Log.v("ddms", "findHand: " + result);
	switch (result) {
	case JdwpPacket.HANDSHAKE_GOOD:
	Log.d("ddms", "Good handshake from debugger");
	JdwpPacket.consumeHandshake(mReadBuffer);
	sendHandshake();
	mConnState = ST_READY;

	ClientData cd = mClient.getClientData();
	cd.setDebuggerConnectionStatus(DebuggerStatus.ATTACHED);
	mClient.update(Client.CHANGE_DEBUGGER_STATUS);

	// see if we have another packet in the buffer
	return getJdwpPacket();
	case JdwpPacket.HANDSHAKE_BAD:
	// not a debugger, throw an exception so we drop the line
	Log.d("ddms", "Bad handshake from debugger");
	throw new IOException("bad handshake");
	case JdwpPacket.HANDSHAKE_NOTYET:
	break;
	default:
	Log.e("ddms", "Unknown packet while waiting for client handshake");
	}
	return null;
	} else if (mConnState == ST_READY) {
	if (mReadBuffer.position() != 0) {
	Log.v("ddms", "Checking " + mReadBuffer.position() + " bytes");
	}
	return JdwpPacket.findPacket(mReadBuffer);
	} else {
	Log.e("ddms", "Receiving data in state = " + mConnState);
	}

	return null;
	}

	/**
	* Forward a packet to the client.
	*
	* "mClient" will never be null, though it's possible that the channel
	* in the client has closed and our send attempt will fail.
	*
	* Consumes the packet.
	*/
	void forwardPacketToClient(JdwpPacket packet) throws IOException {
	mClient.sendAndConsume(packet);
	}

	/**
	* Send the handshake to the debugger. We also send along any packets
	* we already received from the client (usually just a VM_START event,
	* if anything at all).
	*/
	private synchronized void sendHandshake() throws IOException {
	ByteBuffer tempBuffer = ByteBuffer.allocate(JdwpPacket.HANDSHAKE_LEN);
	JdwpPacket.putHandshake(tempBuffer);
	int expectedLength = tempBuffer.position();
	tempBuffer.flip();
	if (mChannel.write(tempBuffer) != expectedLength) {
	throw new IOException("partial handshake write");
	}

	expectedLength = mPreDataBuffer.position();
	if (expectedLength > 0) {
	Log.d("ddms", "Sending " + mPreDataBuffer.position()
	+ " bytes of saved data");
	mPreDataBuffer.flip();
	if (mChannel.write(mPreDataBuffer) != expectedLength) {
	throw new IOException("partial pre-data write");
	}
	mPreDataBuffer.clear();
	}
	}

	/**
	* Send a packet to the debugger.
	*
	* Ideally, we can do this with a single channel write. If that doesn't
	* happen, we have to prevent anybody else from writing to the channel
	* until this packet completes, so we synchronize on the channel.
	*
	* Another goal is to avoid unnecessary buffer copies, so we write
	* directly out of the JdwpPacket's ByteBuffer.
	*
	* We must synchronize on "mChannel" before writing to it. We want to
	* coordinate the buffered data with mChannel creation, so this whole
	* method is synchronized.
	*/
	synchronized void sendAndConsume(JdwpPacket packet)
	throws IOException {

	if (mChannel == null) {
	/*
	* Buffer this up so we can send it to the debugger when it
	* finally does connect. This is essential because the VM_START
	* message might be telling the debugger that the VM is
	* suspended. The alternative approach would be for us to
	* capture and interpret VM_START and send it later if we
	* didn't choose to un-suspend the VM for our own purposes.
	*/
	Log.d("ddms", "Saving packet 0x"
	+ Integer.toHexString(packet.getId()));
	packet.movePacket(mPreDataBuffer);
	} else {
	packet.writeAndConsume(mChannel);
	}
	}
	}