inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/agent/agentserver.cpp

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2007 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 "inspectorj/agent/agentserver.h"

using inspectorj::agent::AgentServer;
using namespace inspectorj::jdwp;
        
namespace inspectorj {
namespace agent {

AgentServer::AgentServer(int portNum, AgentPacketHandler *handler)
    : portNum(portNum),
      pktHandler(handler), 
      quit(false),
      started(false),
      error(0), 
      socket(0),
      acceptor(0),
      agentSocket(0)
{
    
}

AgentServer::~AgentServer()
{
    if (socket) {
        delete socket;
        socket = 0;
    }
    if (agentSocket) {
        delete agentSocket;
        agentSocket = 0;
    }
    if (error) {
        delete error;
        error = 0;
    }
}

void AgentServer::stop()
{
    this->quit = true;
    if (socket && socket->is_open()) {
        socket->close();
    }

    // The server may be waiting to accept a connection at the time
    // the jvm is shutting down. Close the acceptor so the server's 
    // start function can return and the server thread can die.
    if (acceptor) {
        acceptor->close();
    }
}

void AgentServer::shutDown()
{    
    if (socket) {
        if ( socket->is_open() && !quit) {
            socket->close();
        }        
        socket->io_service().stop();
    }
    this->started = false;
    this->quit = false;
}

bool AgentServer::isStarted()
{
    return this->started;
}

void AgentServer::start()
{    
    this->quit = false;
    boost::asio::io_service io_service;
    
    try
    {
        char handshake[JDWP_HANDSHAKE_LENGTH + 1];
        while (!quit) {
            this->started = false;
            error = new boost::system::error_code();
            size_t bytesRead = 0;              
            
            if (socket) {
                delete socket;
                socket = 0;
            }
            socket = new tcp::socket(io_service);
            
            if (agentSocket) {
                delete agentSocket;
                agentSocket = 0;
            }
            agentSocket = new AgentSocket(socket, error);
            pktHandler->setAgentSocket(agentSocket);
            pktHandler->attachCurrentThreadToVM();
            
            if (acceptor) {
                delete acceptor;
                acceptor = 0;
            }            
            acceptor = new tcp::acceptor(io_service, tcp::endpoint(tcp::v4(), portNum));
            acceptor->accept(*socket, *error);
            delete acceptor;
            acceptor = 0;


            // Since acceptor->accept(...) blocks while waiting for a connection,
            // it's possible that the jvm may be shutdown before a connection is made.
            // In this event, acceptor->accept(...) will return as a result of calling 
            // acceptor->close() from the main thread. Check this->quit to see if the
            // jvm is shutting down.
            // @see inspectorj::agent::AgentServer::stop();
            if (quit) {
                shutDown();
                return;
            }

            this->started = true;
            
            AgentLogger::info("Accepted client connection");

            // Check for handshake
            if (socket->available() < JDWP_HANDSHAKE_LENGTH ) {
                // no handshake yet... wait 1 second
                boost::asio::io_service timer_io_service;            
                boost::asio::deadline_timer t(timer_io_service, boost::posix_time::seconds(1));
                t.wait();  
                          
                if (socket->available() < JDWP_HANDSHAKE_LENGTH) {
                    // still no handshake... giving up
                    AgentLogger::warn("No handshake received from client... disconnecting");
                    continue;
                }
            }        
            
            // read handshake from client
            if (! agentSocket->read(handshake, JDWP_HANDSHAKE_LENGTH)) continue;           
            handshake[JDWP_HANDSHAKE_LENGTH] = '\0';

            // check handshake string
            if (strcmp(handshake, JDWP_HANDSHAKE) != 0) {
                // handshake string is not correct... abort
                AgentLogger::warn("Incorrect handshake received from client: [%s]... disconnecting",handshake);
                continue;
            }

            boost::asio::write(*socket, boost::asio::buffer(JDWP_HANDSHAKE),
                            boost::asio::transfer_all(), *error); 
    
            // Connection established... Start processing commands
            while (!checkError(*error) && !quit)
            {               
                // read command packets from the client
                jdwpCmdPacket cmdPacket;
        
                if (! agentSocket->read(cmdPacket.len)) continue;
                if (! agentSocket->read(cmdPacket.id)) continue;
                if (! agentSocket->read(cmdPacket.flags)) continue;
                if (! agentSocket->read(cmdPacket.cmdSet)) continue; 
                if (! agentSocket->read(cmdPacket.cmd)) continue;

                if (cmdPacket.cmdSet == INSPECTORJ_COMMAND_SET)
                {
                    if (cmdPacket.cmd == IJ_DISCONNECT)
                    {
                        break;
                    }
                    else if (cmdPacket.cmd == IJ_EXIT)
                    {
                        quit = true;
                        break;
                    }
                }

                int dataSize = cmdPacket.len - JDWP_HEADER_LENGTH;
                
                //read cmd data if any
                if ( dataSize > 0 ) {
                    cmdPacket.data = new jbyte[dataSize];
                    if (! agentSocket->read((char *)cmdPacket.data, dataSize)) continue;
                } else {
                    cmdPacket.data = NULL;
                }

                // Dispatch the JDWPCommand to the AgentPacketHandler.
                // This may be handled synchronously or asynchronously
                // depending on how the command is processed by the
                // command set. 
                // @see inspectorj::agent::commandset::JDWPCommandSet
                pktHandler->processCommand(new JDWPCommand(cmdPacket));
            }
        }
    }
    catch (std::exception& e)
    {   
        // If the server is being shutdown while the it is waiting to read/write
        // a command or reply, then a connection aborted exception will be thrown.
        // Therefore ignore exceptions that thrown during shutdown.
        if (! this->quit ) {
            AgentLogger::error("inspectorj server stopping becasue of exception:");
            AgentLogger::error(e.what());
        }
    }

    this->shutDown();
}

bool AgentServer::checkError(boost::system::error_code& error)
{
    if (error) {
        if (error != boost::asio::error::eof)
            throw boost::system::system_error(error);
        }
    return error;
}
    
} // end namespace agent
} // end namespace inspectorj

---