| Methods Summary |
|---|
| public void | attachToServer()Establishes TCP/IP connection to the VM being debugged.
NOTE: It's one of few methods in KJDB that produces non-debug
output directly. It's not good. For non-debug output classes
must use kdb.Log class. So may be it's a good idea
to remove the message this method prints.
socket = new Socket(serverName, portNumber);
Tools.wait(100);
System.out.println("Socket Created.");
socket.setTcpNoDelay(true);
inputStream = new DataInputStream(socket.getInputStream());
outputStream = new DataOutputStream(socket.getOutputStream());
|
| public int | availableInPrivateBuffer()Returns the number of bytes that are available in the buffer
that that contains received handshake string.
synchronized(sync){
if(finished){
throw new SocketException("Connection closed");
}
}
//System.out.println("available");
synchronized(sync2){
if(expectedSize == -1){
return handShakeSize;
}else{
return 0;
}
}
|
| public void | done()This method sets the finished field that
indicates that the background thread is to be finished.
After this it closes JDWP connection.
synchronized(sync){
finished = true;
}
doneInternal();
|
| private synchronized void | doneInternal()Internal method that terminates JDWP connection in fact.
try{
if(socket == null){
return;
}
socket.close();
}catch(IOException e){
}
|
| public void | initAsClient(java.lang.String serverName, int portNumber, java.util.Vector replies)Intializes some internal fields of the object. Need to be invoked
immediately after constructor.
this.serverName = serverName;
this.portNumber = portNumber;
this.replies = replies;
|
| public boolean | isStarted()Checks if the background thread is initialized and is not received
request for terminating yet.
synchronized(sync){
return !finished;
}
|
| public int | readNextFromPrivateBuffer()Reads next byte from the buffer that contains received
handshake string.
synchronized(sync){
if(finished){
throw new SocketException("Connection closed");
}
}
//System.out.println("read");
synchronized(sync2){
return privateBuffer[currentInPrivateBuffer++];
}
|
| public void | receive()Stores a portion of received replies in the outer buffer. If no replies
are received since the previous call of this method it does nothing.
//System.out.println("receive");
synchronized(sync){
if(finished){
throw new SocketException("Connection closed");
}
}
synchronized(sync1){
sync1.notifyAll();
}
synchronized(repliesInternal){
replies.addAll(repliesInternal);
repliesInternal.clear();
}
|
| public void | run()It's an entry point of background thread. This method processes
reading of handshake and normal JDWP packets and stores the received
values in repliesInternal vector.
Also this method establishes JDWP connection.
The method works in a
loop until finished field becomes true.
After this the JDWP connections terminates.
//setPriority(MIN_PRIORITY);
synchronized(sync){
finished = false;
}
byte[] buf = new byte[100000];
try{
attachToServer();
boolean timeToQuit = false;
synchronized(sync){
timeToQuit = finished;
}
synchronized(this){
notifyAll();
}
while(!timeToQuit){
synchronized(sync1){
sync1.wait();
}
synchronized(sync2){
cycleStarted = true;
}
if(expectedSize != -1){
//read handshake
int bytesRead = 0;
while(bytesRead != expectedSize){
bytesRead += inputStream.read(buf, bytesRead, expectedSize - bytesRead);
}
synchronized(sync2){
for(int i=0 ; i<expectedSize ; i++){
privateBuffer[i] = buf[i];
}
expectedSize = -1;
}
continue;
}
//System.out.println("read packet");
//Read header
int bytesRead = 0;
while(bytesRead != Packet.PacketHeaderSize){
int bytesReadDuringLastRead = inputStream.read(buf,
bytesRead, Packet.PacketHeaderSize - bytesRead);
bytesRead += bytesReadDuringLastRead;
if(bytesReadDuringLastRead == -1){
throw new IOException("Connection closed");
}
}
//System.out.println("read data");
//Read data
int size = (((((int)buf[0]) & 0xFF) << 24) |
((((int)buf[1]) & 0xFF ) << 16) |
((((int)buf[2]) & 0xFF ) << 8) |
(((int)buf[3]) & 0xFF));
bytesRead = 0;
while(bytesRead != size - Packet.PacketHeaderSize){
int bytesReadDuringLastRead =
inputStream.read(buf, bytesRead + Packet.PacketHeaderSize,
size - Packet.PacketHeaderSize - bytesRead);
bytesRead += bytesReadDuringLastRead;
if(bytesReadDuringLastRead == -1){
throw new IOException("Connection closed");
}
}
//System.out.println("data read");
Reply r = new Reply();
r.resetBuffer();
r.addBytes(buf,0,size);
synchronized(repliesInternal){
repliesInternal.add(r);
}
synchronized(sync){
timeToQuit = finished;
}
}
}catch(IOException e){
synchronized(sync){
finished = true;
}
synchronized(this){
notifyAll();
}
}catch(InterruptedException e){
synchronized(sync){
finished = true;
}
synchronized(this){
notifyAll();
}
}
synchronized(sync){
finished = true;
}
doneInternal();
|
| public void | startHandShake(int len)Initiates handshake procedure that is physically performed
by run() method and waits for run()
method's sterting the waiting for reply. After this it exits.
This procedure is performed immediately after establishing TCP/IP
connection and consist on sending and receiving "JDWP-Handshake" string.
currentInPrivateBuffer = 0;
expectedSize = len;
handShakeSize = len;
boolean b = true;
do{
synchronized(sync1){
sync1.notifyAll();
}
synchronized(sync2){
b = !cycleStarted;
}
}while(b);
synchronized(sync2){
cycleStarted = false;
}
|
| public void | write(int b)Writes a specified byte into the socket.
outputStream.write(b);
//System.out.println("Written byte " + b);
|
