inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/client/clientpackethandler.cpp

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2006 by James May
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <iostream>
#include "inspectorj/client/clientpackethandler.h"

using namespace inspectorj::client;
using namespace inspectorj::jdwp;
        
ClientPacketHandler::ClientPacketHandler(QTcpSocket &socket)
    : tcpSocket(socket), packetSize(0)
{
    initIdSizesAction = new JDWPAction(this);
    connect (initIdSizesAction, SIGNAL (triggered(JDWPPacket&)), this, SLOT (initIdSizes(JDWPPacket&)));
}

void ClientPacketHandler::sendJDWPCommand(JDWPCommand* cmd, QList<JDWPAction*>& actions)
{
    // store the replyPacket callback actions
    for (int i = 0; i < actions.size(); ++i) {
        replyCallbackMap.insert(cmd->getId(), actions[i]);
    }

    // send the command
    QByteArray block; 
    QDataStream out(&block, QIODevice::WriteOnly);
    out << cmd->getLength();
    out << cmd->getId();
    out << cmd->getPacketType();
    out << cmd->getCmdSet();
    out << cmd->getCmd();
    
    if (cmd->getLength() > JDWP_HEADER_LENGTH) {
        out.writeRawData(cmd->getDataBytes(), cmd->getLength() - JDWP_HEADER_LENGTH);
    }

    tcpSocket.write(block);
    delete cmd;
    cmd = 0;
}

void ClientPacketHandler::readJDWPPacket()
{
    QDataStream in(&tcpSocket);
    in.setVersion(QDataStream::Qt_4_1);
    
    while (tcpSocket.bytesAvailable()) {
    
        // Get the size of the next packet
        if (packetSize == 0) {
            if (tcpSocket.bytesAvailable() < sizeof(jint)) {
                return;
            }
            in >> packetSize;
        }    
        
        // Wait until we have all the bytes
        if (tcpSocket.bytesAvailable() < packetSize - sizeof(jint)) {
            return;
        }
        int dataSize = packetSize - JDWP_HEADER_LENGTH;
        qint32 id;
        jbyte flags;
    
        in >> id;
        in >> flags; 

        // Check to see if this is a reply packet or a command packet
        if (flags == (jbyte) JDWPTRANSPORT_FLAGS_REPLY) {
            
            jdwpReplyPacket replyPacket;
            replyPacket.len = packetSize;
            replyPacket.id = id;
            replyPacket.flags = flags;
            in >> replyPacket.errorCode;
            // read reply data if any
            if ( dataSize > 0 ) {
                replyPacket.data = new jbyte[dataSize];
                tcpSocket.read((char *)replyPacket.data, (qint64) dataSize); 
            } else {
                replyPacket.data = NULL;
            }
    
            JDWPReply reply = JDWPReply(replyPacket);
            handleResponse(reply);
    
        } else {
            
            jdwpCmdPacket cmdPacket;
            cmdPacket.len = packetSize;
            cmdPacket.id = id;
            cmdPacket.flags = flags;
            in >> cmdPacket.cmdSet;
            in >> cmdPacket.cmd;
    
            //read cmd data if any
            if ( dataSize > 0 ) {
                cmdPacket.data = new jbyte[dataSize];
                tcpSocket.read((char*)cmdPacket.data, (qint64) dataSize);
            } else {
                cmdPacket.data = NULL;
            }
    
            JDWPCommand cmd = JDWPCommand(cmdPacket);     
            handleResponse(cmd);
        }
        packetSize = 0;
    }
}

void ClientPacketHandler::handleResponse(JDWPPacket &reply)
{
    int id = reply.getId();
    QList<JDWPAction*> actions = replyCallbackMap.values(id);
    replyCallbackMap.remove(id);
    
    for (int i = 0; i < actions.size(); ++i)
    {
        JDWPAction *action = actions[i];
        action->trigger(reply);
    }
}

void ClientPacketHandler::getHandshake(bool &attached, QString &msg)
{
    QDataStream in(&tcpSocket);
    in.setVersion(QDataStream::Qt_4_2);

    while (true) {
        if (tcpSocket.bytesAvailable() < JDWP_HANDSHAKE_LENGTH)
        {
            break;
        }

        char* resp = new char[JDWP_HANDSHAKE_LENGTH + 1];
        tcpSocket.read(resp, (qint64) JDWP_HANDSHAKE_LENGTH);
        resp[14] = 0;

            // Check to see if the handshake succeeded
        if (strcmp(resp, JDWP_HANDSHAKE) != 0)
        {
            msg = QString("Error: handshake failed.");
            delete[] resp;
            resp = 0;
            tcpSocket.close();
            break;
        } else {
            QString peerName = tcpSocket.peerName();
            QString peerPort;
            peerPort.setNum(tcpSocket.peerPort());
            msg = QString("Connected to ").append(peerName).append(":").append(peerPort);
        }

        attached = true;
        
        // initialize the ID JDWPPacket id sizes
        JDWPCommand *cmd = JDWPCommand::newCommand(VM_CMD_ID_SIZES);
        QList<JDWPAction*> actions;
        actions << initIdSizesAction;
        sendJDWPCommand(cmd, actions);
                
        delete[] resp;
        resp = 0;
        break;
    }
}

void ClientPacketHandler::initIdSizes(JDWPPacket& reply)
{
    JDWPPacket::initIDSizes(reply);
}
    
void ClientPacketHandler::operator>>(QString &s)
{
    //get the JDWP string length
    int len;
    char *p = (char *)(&len);
    char b[4];
    tcpSocket.read(b,4);
    *p++ = b[3];
    *p++ = b[2];
    *p++ = b[1];
    *p   = b[0];

    char * tmp = new char[len];
    tcpSocket.read(tmp, (qint64) len);
    s = QString(tmp);
    delete [] tmp;
    tmp = 0;
}

void ClientPacketHandler::getSocketError(QAbstractSocket::SocketError error, QString &errMsg)
{
    switch (error)
    {
        case QAbstractSocket::ConnectionRefusedError : errMsg = "The connection was refused by the peer (or timed out)."; break;
        case QAbstractSocket::RemoteHostClosedError : errMsg = "The remote host closed the connection."; break;
        case QAbstractSocket::HostNotFoundError : errMsg = "The host address was not found."; break;
        case QAbstractSocket::SocketAccessError : errMsg = "The socket operation failed because the application lacked the required privileges."; break;
        case QAbstractSocket::SocketResourceError : errMsg = "The local system ran out of resources (e.g., too many sockets)."; break;
        case QAbstractSocket::SocketTimeoutError : errMsg = "The socket operation timed out."; break;
        case QAbstractSocket::DatagramTooLargeError : errMsg = "The datagram was larger than the operating system's limit (which can be as low as 8192 bytes)."; break;
        case QAbstractSocket::NetworkError : errMsg = "An error occurred with the network (e.g., the network cable was accidentally plugged out)."; break;
        case QAbstractSocket::AddressInUseError : errMsg = "The address specified to QUdpSocket::bind() is already in use and was set to be exclusive."; break;
        case QAbstractSocket::SocketAddressNotAvailableError : errMsg = "The address specified to QUdpSocket::bind() does not belong to the host."; break;
        case QAbstractSocket::UnsupportedSocketOperationError : errMsg = "The requested socket operation is not supported by the local operating system."; break;
        case QAbstractSocket::UnknownSocketError : errMsg = "An unidentified socket error has occurred.";     
    }
}

bool ClientPacketHandler::handleJDWPError(JDWPPacket &packet)
{
    
    jint errCode = packet.getErrorCode();
    bool hasError = (errCode != (jint)ERR_NONE);
    if (hasError) {
        QString msg;
        ClientPacketHandler::getJDWPError(errCode, msg);
        QMessageBox::warning( 0, "inspectorJ Error", msg,
                              QMessageBox::Ok | QMessageBox::Default);
    }
    return hasError;
}
void ClientPacketHandler::getJDWPError(int errCode, QString &s)
{
    switch (errCode)
    {
        case ERR_NONE : s = "No error has occurred.";  break;
        case ERR_INVALID_THREAD : s = "Passed thread is null, is not a valid thread or has exited.";  break;
        case ERR_INVALID_THREAD_GROUP : s = "Thread group invalid.";  break;
        case ERR_INVALID_PRIORITY : s = "Invalid priority.";  break;
        case ERR_THREAD_NOT_SUSPENDED : s = "If the specified thread has not been suspended by an event.";  break;
        case ERR_THREAD_SUSPENDED : s = "Thread already suspended.";  break;
        case ERR_INVALID_OBJECT : s = "If this reference type has been unloaded and garbage collected.";  break;
        case ERR_INVALID_CLASS : s = "Invalid class.";  break;
        case ERR_CLASS_NOT_PREPARED : s = "Class has been loaded but not yet prepared.";  break;
        case ERR_INVALID_METHODID : s = "Invalid method.";  break;
        case ERR_INVALID_LOCATION : s = "Invalid location.";  break;
        case ERR_INVALID_FIELDID : s = "Invalid field.";  break;
        case ERR_INVALID_FRAMEID : s = "Invalid jframeID.";  break;
        case ERR_NO_MORE_FRAMES : s = "There are no more Java or JNI frames on the call stack.";  break;
        case ERR_OPAQUE_FRAME : s = "Information about the frame is not available.";  break;
        case ERR_NOT_CURRENT_FRAME : s = "Operation can only be performed on current frame.";  break;
        case ERR_TYPE_MISMATCH : s = "The variable is not an appropriate type for the function used.";  break;
        case ERR_INVALID_SLOT : s = "Invalid slot.";  break;
        case ERR_DUPLICATE : s = "Item already set.";  break;
        case ERR_NOT_FOUND : s = "Desired element not found.";  break;
        case ERR_INVALID_MONITOR : s = "Invalid monitor.";  break;
        case ERR_NOT_MONITOR_OWNER : s = "This thread doesn't own the monitor.";  break;
        case ERR_INTERRUPT : s = "The call has been interrupted before completion.";  break;
        case ERR_INVALID_CLASS_FORMAT : s = "The virtual machine attempted to read a class file and determined that the file is malformed or otherwise cannot be interpreted as a class file.";  break;
        case ERR_CIRCULAR_CLASS_DEFINITION : s = "A circularity has been detected while initializing a class.";  break;
        case ERR_FAILS_VERIFICATION : s = "The verifier detected that a class file, though well formed, contained some sort of internal inconsistency or security problem.";  break;
        case ERR_ADD_METHOD_NOT_IMPLEMENTED : s = "Adding methods has not been implemented.";  break;
        case ERR_SCHEMA_CHANGE_NOT_IMPLEMENTED : s = "Schema change has not been implemented.";  break;
        case ERR_INVALID_TYPESTATE : s = "The state of the thread has been modified, and is now inconsistent.";  break;
        case ERR_HIERARCHY_CHANGE_NOT_IMPLEMENTED : s = "A direct superclass is different for the new class version, or the set of directly implemented interfaces is different and canUnrestrictedlyRedefineClasses is false.";  break;
        case ERR_DELETE_METHOD_NOT_IMPLEMENTED : s = "The new class version does not declare a method declared in the old class version and canUnrestrictedlyRedefineClasses is false.";  break;
        case ERR_UNSUPPORTED_VERSION : s = "A class file has a version number not supported by this VM.";  break;
        case ERR_NAMES_DONT_MATCH : s = "The class name defined in the new class file is different from the name in the old class object.";  break;
        case ERR_CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED : s = "The new class version has different modifiers and and canUnrestrictedlyRedefineClasses is false.";  break;
        case ERR_METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED : s = "A method in the new class version has different modifiers than its counterpart in the old class version and and canUnrestrictedlyRedefineClasses is false.";  break;
        case ERR_NOT_IMPLEMENTED : s = "The functionality requested is not implemented by this agent.";  break;
        case ERR_NULL_POINTER : s = "Invalid pointer.";  break;
        case ERR_ABSENT_INFORMATION : s = "Desired information is not available.";  break;
        case ERR_INVALID_EVENT_TYPE : s = "The specified event type id is not recognized.";  break;
        case ERR_ILLEGAL_ARGUMENT : s = "Illegal argument.";  break;
        case ERR_OUT_OF_MEMORY : s = "The function needed to allocate memory and no more memory was available for allocation.";  break;
        case ERR_ACCESS_DENIED : s = "Debugging has not been enabled in this virtual machine. JVMDI cannot be used.";  break;
        case ERR_VM_DEAD : s = "The virtual machine is not running.";  break;
        case ERR_INTERNAL : s = "An unexpected internal error has occurred.";  break;
        case ERR_UNATTACHED_THREAD : s = "The thread being used to call this function is not attached to the virtual machine. Calls must be made from attached threads.";  break;
        case ERR_INVALID_TAG : s = "object type id or class tag.";  break;
        case ERR_ALREADY_INVOKING : s = "Previous invoke not complete.";  break;
        case ERR_INVALID_INDEX : s = "Index is invalid.";  break;
        case ERR_INVALID_LENGTH : s = "The length is invalid.";  break;
        case ERR_INVALID_STRING : s = "The string is invalid.";  break;
        case ERR_INVALID_CLASS_LOADER : s = "The class loader is invalid.";  break;
        case ERR_INVALID_ARRAY : s = "The array is invalid.";  break;
        case ERR_TRANSPORT_LOAD : s = "Unable to load the transport.";  break;
        case ERR_TRANSPORT_INIT : s = "Unable to initialize the transport.";  break;
        case ERR_NATIVE_METHOD : s = " Native method error.";  break;
        case ERR_INVALID_COUNT : s = "The count is invalid.";
    }
}

---