/// <summary> /// 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). /// </summary> private /*synchronized*/ void sendHandshake() { 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(); } }
/// <summary> /// Write our packet to "chan". Consumes the packet as part of the /// write. /// /// The JDWP packet starts at offset 0 and ends at mBuffer.position(). /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: void writeAndConsume(java.nio.channels.SocketChannel chan) throws java.io.IOException internal void writeAndConsume(SocketChannel chan) { int oldLimit; //Log.i("ddms", "writeAndConsume: pos=" + mBuffer.position() // + ", limit=" + mBuffer.limit()); Debug.Assert(mLength > 0); mBuffer.flip(); // limit<-posn, posn<-0 oldLimit = mBuffer.limit; mBuffer.limit = (mLength); while (mBuffer.position != mBuffer.limit) { chan.write(mBuffer); } // position should now be at end of packet Debug.Assert(mBuffer.position == mLength); mBuffer.limit = (oldLimit); mBuffer.compact(); // shift posn...limit, posn<-pending data //Log.i("ddms", " : pos=" + mBuffer.position() // + ", limit=" + mBuffer.limit()); }
/// <summary> /// Write until all data in "data" is written, the optional length is reached, /// the timeout expires, or the connection fails. Returns "true" if all /// data was written. </summary> /// <param name="chan"> the opened socket to write to. </param> /// <param name="data"> the buffer to send. </param> /// <param name="length"> the length to write or -1 to send the whole buffer. </param> /// <param name="timeout"> The timeout value. A timeout of zero means "wait forever". </param> /// <exception cref="TimeoutException"> in case of timeout on the connection. </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: static void write(java.nio.channels.SocketChannel chan, byte[] data, int length, int timeout) throws TimeoutException, java.io.IOException internal static void write(SocketChannel chan, byte[] data, int length, int timeout) { ByteBuffer buf = ByteBuffer.wrap(data, 0, length != -1 ? length : data.Length); int numWaits = 0; while (buf.position != buf.limit) { int count; count = chan.write(buf); if (count < 0) { Log.d("ddms", "write: channel EOF"); throw new IOException("channel EOF"); } else if (count == 0) { // TODO: need more accurate timeout? if (timeout != 0 && numWaits * WAIT_TIME > timeout) { Log.d("ddms", "write: timeout"); throw new TimeoutException(); } // non-blocking spin Thread.Sleep(WAIT_TIME); numWaits++; } else { numWaits = 0; } } }
/// <summary> /// Initiate the JDWP handshake. /// /// On failure, closes the socket and returns false. /// </summary> internal virtual bool sendHandshake() { Debug.Assert(mWriteBuffer.position == 0); try { // assume write buffer can hold 14 bytes JdwpPacket.putHandshake(mWriteBuffer); int expectedLen = mWriteBuffer.position; mWriteBuffer.flip(); if (mChan.write(mWriteBuffer) != expectedLen) { throw new IOException("partial handshake write"); } } catch (IOException ioe) { Log.e("ddms-client", "IO error during handshake: " + ioe.Message); mConnState = ST_ERROR; close(true); // notify return(false); } finally { mWriteBuffer.clear(); } mConnState = ST_AWAIT_SHAKE; return(true); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void write(byte[] buffer, int offset, int Length) throws java.io.IOException public virtual void write(sbyte[] buffer, int offset, int Length) { socketChannel.write(ByteBuffer.wrap(buffer, 0, Length)); }