APIServerConnection Class Reference

Handles a client connection to the API server. More...

#include "APIServerConnection.h"

Inheritance diagram for APIServerConnection:

Collaboration diagram for APIServerConnection:

Public Member Functions
void	Process ()
boost::asio::ip::tcp::socket &	socket ()

Static Public Member Functions
static std::tr1::shared_ptr < APIServerConnection >	create (boost::asio::io_context &io)

Private Member Functions
	APIServerConnection (boost::asio::io_context &io)
void	ProcessHeaders ()
void	ProcessPostData ()
void	SendXML ()
void	NotFound ()
void	Close ()
void	Redirect ()
void	RedirectLocation ()
void	RedirectFinalize ()

Static Private Member Functions
static bool	starts_with (std::string &haystack, const char *const needle)

Private Attributes
std::string	_service
std::string	_service_handler
std::string	_redirectUrl
std::string	_http_cmd_str
APICommandCall	m_apiCommandCall
boost::asio::streambuf	_buffer
boost::asio::streambuf	_postBuffer
boost::asio::ip::tcp::socket	_socket
std::tr1::shared_ptr < std::vector< char > >	_xmlData

Static Private Attributes
static boost::asio::const_buffers_1	_responseOK = boost::asio::buffer("HTTP/1.0 200 OK\r\nContent-Type: text/xml\r\n\r\n", 43)
static boost::asio::const_buffers_1	_responseNotFound
static boost::asio::const_buffers_1	_responseNoContent = boost::asio::buffer("HTTP/1.0 204 No Content", 23)
static boost::asio::const_buffers_1	_responseRedirectBegin = boost::asio::buffer("HTTP/1.0 301 Moved Permanently\r\nLocation: ", 42)
static boost::asio::const_buffers_1	_responseRedirectEnd = boost::asio::buffer("\r\n\r\n", 4)

Detailed Description

Handles a client connection to the API server.

Handles exactly one client; does all the protocol related stuff. Very limited HTTP handling.

Author

Aknor Jaden

Date

July 2011

Definition at line 41 of file APIServerConnection.h.

Constructor & Destructor Documentation

APIServerConnection::APIServerConnection ( boost::asio::io_context &  io )

private

Definition at line 71 of file APIServerConnection.cpp.

Referenced by create().

    : _socket(io)
{
}

Here is the caller graph for this function:

Member Function Documentation

void APIServerConnection::Close ( )

private

Definition at line 418 of file APIServerConnection.cpp.

References _socket.

Referenced by NotFound(), ProcessPostData(), RedirectFinalize(), and SendXML().

{
    _socket.close();
}

Here is the caller graph for this function:

std::tr1::shared_ptr< APIServerConnection > APIServerConnection::create ( boost::asio::io_context &  io )

static

Definition at line 428 of file APIServerConnection.cpp.

References APIServerConnection().

Referenced by APIServerListener::StartAccept().

{
    return std::tr1::shared_ptr<APIServerConnection>(new APIServerConnection(io));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void APIServerConnection::NotFound ( )

private

Definition at line 394 of file APIServerConnection.cpp.

References _responseNotFound, _socket, and Close().

Referenced by ProcessHeaders(), and ProcessPostData().

{
    boost::asio::async_write(_socket, _responseNotFound, boost::asio::transfer_all(), std::bind(&APIServerConnection::Close, shared_from_this()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void APIServerConnection::Process

(

)

Definition at line 81 of file APIServerConnection.cpp.

References _buffer, _socket, and ProcessHeaders().

{
    // receive all HTTP headers from the client
    boost::asio::async_read_until(_socket, _buffer, "\r\n\r\n", std::bind(&APIServerConnection::ProcessHeaders, shared_from_this()));
}

Here is the call graph for this function:

void APIServerConnection::ProcessHeaders ( )

private

Definition at line 87 of file APIServerConnection.cpp.

References _buffer, _http_cmd_str, _postBuffer, _responseOK, _service, _service_handler, _socket, _xmlData, m_apiCommandCall, NotFound(), ProcessPostData(), sAPIServer, SendXML(), sLog, and starts_with().

Referenced by Process().

{
    std::istream stream(&_buffer);
    std::string query;
    std::string request;
    std::string get_chk_str;
    std::string post_chk_str;
    int pos;
    int parameterCount;
    std::string param;
    std::string value;

    // Clear API Command Call container:
    m_apiCommandCall.clear();

    // Get the first header line, every request line ends with "\r\n"
    // GET /service/ServiceHandler.xml.aspx?param1=value&param2=value&param3=value HTTP/1.0\r\n
    // POST /service/ServiceHandler.xml.aspx HTTP/1.0\r\n
    std::getline(stream, request, '\r');
    query = request;

    get_chk_str = request.substr(0,3);
    post_chk_str = request.substr(0,4);

    if (get_chk_str.compare("GET") == 0)
    {
        sLog.Debug( "APIServerConnection::ProcessHeaders()", "RECEIVED new HTTP GET request..." );

        // Format of an HTTP GET query:
        // 0    5     10          20
        // GET /service/ServiceHandler.xml.aspx?param1=value&param2=value&param3=value HTTP/1.0\r\n
        _http_cmd_str = get_chk_str;

        request = request.substr(4);    // Strip off the "GET " prefix

        // Find first space at end of header, if there is one, and strip off the rest of the line, ie the " HTTP/1.0\r\n" string
        int del = request.find_first_of(' ');
        if (del == std::string::npos)
        {
            NotFound();
            return;
        }
        request = request.substr(0,del);

        if (!starts_with(request, "/"))
        {
            NotFound();
            return;
        }
        request = request.substr(1);

        pos = request.find_first_of('/');
        _service = request.substr(0,pos);
        m_apiCommandCall.insert( std::pair<std::string, std::string>( "service", _service ) );
        request = request.substr(pos+1);
        pos = request.find_first_of('?');
        _service_handler = request.substr(0,pos);
        m_apiCommandCall.insert( std::pair<std::string, std::string>( "servicehandler", _service_handler ) );
        request = request.substr(pos+1);

        // Parse the query portion of the GET to a series of string pairs ("param", "value") from the URI
        while( (pos = request.find_first_of('=')) >= 0 )
        {
            param = request.substr(0,pos);
            std::transform(param.begin(), param.end(), param.begin(), tolower);
            request = request.substr(pos+1);
            pos = request.find_first_of('&');
            if( pos < 0 )
                value = request;
            else
            {
                value = request.substr(0,pos);
                request = request.substr(pos);
                if( request.substr(0,5) == "&amp;" )  // Strip out "&amp;" encoded for "&"
                    request = request.substr(5);
                else
                    request = request.substr(1);
            }
            m_apiCommandCall.insert( std::pair<std::string, std::string>( param, value ) );
        }

        _xmlData = sAPIServer.GetXML(&m_apiCommandCall);
        if (!_xmlData)
        {
            sLog.Error("APIServerConnection::ProcessHeaders()", "Unknown or malformed EVEmu API HTTP CMD Received:\r\n%s\r\n", query.c_str());
            NotFound();
            return;
        }

        // Print out to the Log with basic info on the API call and all parameters and their values parsed out
        sLog.Debug("APIServerConnection::ProcessHeaders()", "HTTP %s CMD Received: Service: %s, Handler: %s", _http_cmd_str.c_str(), _service.c_str(), _service_handler.c_str());
        APICommandCall::const_iterator cur, end;
        cur = m_apiCommandCall.begin();
        end = m_apiCommandCall.end();
        for (int i=1; cur != end; cur++, i++)
            sLog.Debug("        ", "%d: param = %s,  value = %s", i, cur->first.c_str(), cur->second.c_str() );

        // first we have to send the responseOK, then our actual result
        boost::asio::async_write(_socket, _responseOK, boost::asio::transfer_all(), std::bind(&APIServerConnection::SendXML, shared_from_this()));
    }
    else if (post_chk_str.compare("POST") == 0)
    {
        sLog.Debug( "APIServerConnection::ProcessHeaders()", "RECEIVED new HTTP POST request..." );

        // Format of an HTTP GET query:
        //
        // POST /service/ServiceHandler.xml.aspx HTTP/1.0\r\n
        // Content-Type: application/x-www-form-urlencoded\r\n
        // Host: api.eve-online.com\r\n
        // Content-Length: 86\r\n
        // \r\n
        // param1=value&param2=value&param3=value\r\n
        // \r\n

        _http_cmd_str = post_chk_str;

        request = request.substr(5);    // Strip off the "POST " prefix

        // Find first space at end of header, if there is one, and strip off the rest of the line, ie the " HTTP/1.0\r\n" string
        int del = request.find_first_of(' ');
        if (del == std::string::npos)
        {
            NotFound();
            return;
        }
        request = request.substr(0,del);

        if (!starts_with(request, "/"))
        {
            NotFound();
            return;
        }
        request = request.substr(1);

        pos = request.find_first_of('/');
        _service = request.substr(0,pos);
        m_apiCommandCall.insert( std::pair<std::string, std::string>( "service", _service ) );
        request = request.substr(pos+1);
        _service_handler = request;
        m_apiCommandCall.insert( std::pair<std::string, std::string>( "servicehandler", _service_handler ) );

        // Read the integer after 'Content-Length:' and use that as the # of bytes in the next step
        while( (request.substr( 0,15 ).compare( "Content-Length:" )) != 0 )
        {
            std::getline(stream, request, '\r');
            request = request.substr(1);
            query += request;
        }
        pos = request.find_first_of(' ');
        request = request.substr( pos+1 );
        uint32 postDataBytes = atoi( request.c_str() );
        std::getline(stream, request, '\n');

        sLog.Debug( "APIServerConnection::ProcessHeaders()", "    POST Content-Length = %u bytes", postDataBytes );

        // Keep reading lines until we get past the next "\r\n" line (blank line):
        while( request.compare( "\r" ) != 0 )
        {
            std::getline(stream, request, '\n');
        }

        std::getline(stream, request, '\n');
        pos = request.find_first_of('\r');
        request = request.substr( 0,pos );

        if( request.compare( "" ) != 0 )
        {
            // Decode the arguments of the POST data block here since asio did NOT stop reading past the first "\r\n\r\n"
            // Parse the query portion of the GET to a series of string pairs ("param", "value") from the URI
            sLog.Debug( "APIServerConnection::ProcessHeaders()", "POST data found in ProcessHeaders() !  Parsing..." );
            parameterCount = 0;
            while( (pos = request.find_first_of('=')) >= 0 )
            {
                parameterCount++;
                param = request.substr(0,pos);
                std::transform(param.begin(), param.end(), param.begin(), tolower);
                request = request.substr(pos+1);
                pos = request.find_first_of('&');
                if( pos < 0 )
                    value = request;
                else
                {
                    value = request.substr(0,pos);
                    request = request.substr(pos);
                    if( request.substr(0,5) == "&amp;" )  // Strip out "&amp;" encoded for "&"
                        request = request.substr(5);
                    else
                        request = request.substr(1);
                }
                m_apiCommandCall.insert( std::pair<std::string, std::string>( param, value ) );
            }

            // Did we somehow not detect a lack of POST data?  If so, and NO parameters were recovered, queue up the trigger for PostProcessHeaders():
            if( parameterCount == 0 )
            {
                // Call boost::asio::async_read() and feed it the # of bytes from step 1) to get the POST data
                // The 'CompleteCondition' for THIS boost::asio::async_read, a parameter that specifies when to stop reading,
                // is transfer_exactly(contentLength), where contentLength is the # of bytes we just recovered from the "Content-Length" header
                boost::asio::async_read(_socket, _postBuffer, boost::asio::transfer_exactly(postDataBytes), std::bind(&APIServerConnection::ProcessPostData, shared_from_this()));
            }

            _xmlData = sAPIServer.GetXML(&m_apiCommandCall);
            if (!_xmlData)
            {
                sLog.Error("APIServerConnection::ProcessHeaders()", "Unknown or malformed EVEmu API HTTP CMD Received:\r\n%s\r\n", query.c_str());
                NotFound();
                return;
            }

            // Print out to the Log with basic info on the API call and all parameters and their values parsed out
            sLog.Debug("APIServerConnection::ProcessHeaders()", "HTTP %s CMD Received: Service: %s, Handler: %s", _http_cmd_str.c_str(), _service.c_str(), _service_handler.c_str());
            APICommandCall::const_iterator cur, end;
            cur = m_apiCommandCall.begin();
            end = m_apiCommandCall.end();
            for (int i=1; cur != end; cur++, i++)
                sLog.Debug("        ", "%d: param = %s,  value = %s", i, cur->first.c_str(), cur->second.c_str() );

            // first we have to send the responseOK, then our actual result
            boost::asio::async_write(_socket, _responseOK, boost::asio::transfer_all(), std::bind(&APIServerConnection::SendXML, shared_from_this()));
        }
        else
        {
            // Call boost::asio::async_read() and feed it the # of bytes from step 1) to get the POST data
            // The 'CompleteCondition' for THIS boost::asio::async_read, a parameter that specifies when to stop reading,
            // is transfer_exactly(contentLength), where contentLength is the # of bytes we just recovered from the "Content-Length" header
            boost::asio::async_read(_socket, _postBuffer, boost::asio::transfer_exactly(postDataBytes), std::bind(&APIServerConnection::ProcessPostData, shared_from_this()));
        }
    }
    else
    {
        NotFound();
        return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void APIServerConnection::ProcessPostData ( )

private

Definition at line 326 of file APIServerConnection.cpp.

References _http_cmd_str, _postBuffer, _responseNoContent, _responseOK, _service, _service_handler, _socket, _xmlData, Close(), m_apiCommandCall, NotFound(), sAPIServer, SendXML(), and sLog.

Referenced by ProcessHeaders().

{
    std::istream stream(&_postBuffer);
    std::string query;
    std::string request;
    int pos;
    std::string param;
    std::string value;

    std::getline(stream, request, '\r');

    // Check for empty POST data block, and if empty, return without sending anything back:
    if( request.compare( "" ) == 0 )
    {
        sLog.Error("APIServerConnection::ProcessPostData()", "POST data block is COMPLETELY EMPTY!!" );
        boost::asio::async_write(_socket, _responseNoContent, boost::asio::transfer_all(), std::bind(&APIServerConnection::Close, shared_from_this()));
        //NotFound();
        return;
    }

    _http_cmd_str += request;

    // Parse the data portion of the POST to a series of string pairs ("param", "value") from the URI
    while( (pos = request.find_first_of('=')) >= 0 )
    {
        param = request.substr(0,pos);
        std::transform(param.begin(), param.end(), param.begin(), tolower);
        request = request.substr(pos+1);
        pos = request.find_first_of('&');
        if( pos < 0 )
            value = request;
        else
        {
            value = request.substr(0,pos);
            request = request.substr(pos);
            if( request.substr(0,5) == "&amp;" )  // Strip out "&amp;" encoded for "&"
                request = request.substr(5);
            else
                request = request.substr(1);
        }
        m_apiCommandCall.insert( std::pair<std::string, std::string>( param, value ) );
    }

    _xmlData = sAPIServer.GetXML(&m_apiCommandCall);
    if (!_xmlData)
    {
        sLog.Error("APIServerConnection::ProcessPostData()", "Unknown or malformed EVEmu API HTTP CMD Received:\r\n%s\r\n", query.c_str());
        NotFound();
        return;
    }

    // Print out to the Log with basic info on the API call and all parameters and their values parsed out
    sLog.Debug("APIServerConnection::ProcessPostData()", "HTTP %s CMD Received: Service: %s, Handler: %s", _http_cmd_str.c_str(), _service.c_str(), _service_handler.c_str());
    APICommandCall::const_iterator cur, end;
    cur = m_apiCommandCall.begin();
    end = m_apiCommandCall.end();
    for (int i=1; cur != end; cur++, i++)
        sLog.Debug("        ", "%d: param = %s,  value = %s", i, cur->first.c_str(), cur->second.c_str() );

    // first we have to send the responseOK, then our actual result
    boost::asio::async_write(_socket, _responseOK, boost::asio::transfer_all(), std::bind(&APIServerConnection::SendXML, shared_from_this()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void APIServerConnection::Redirect ( )

private

Definition at line 399 of file APIServerConnection.cpp.

References _responseRedirectBegin, _socket, and RedirectLocation().

{
    boost::asio::async_write(_socket, _responseRedirectBegin, boost::asio::transfer_all(), std::bind(&APIServerConnection::RedirectLocation, shared_from_this()));
}

Here is the call graph for this function:

void APIServerConnection::RedirectFinalize ( )

private

Definition at line 413 of file APIServerConnection.cpp.

References _responseRedirectEnd, _socket, and Close().

Referenced by RedirectLocation().

{
    boost::asio::async_write(_socket, _responseRedirectEnd, boost::asio::transfer_all(), std::bind(&APIServerConnection::Close, shared_from_this()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void APIServerConnection::RedirectLocation ( )

private

Definition at line 404 of file APIServerConnection.cpp.

References _redirectUrl, _service, _socket, APIServer::FallbackURL, and RedirectFinalize().

Referenced by Redirect().

{
    //std::string extension = _service == "Character" ? "jpg" : "png";
    std::stringstream url;
    url << APIServer::FallbackURL << _service;// << "/" << _id;
    _redirectUrl = url.str();
    boost::asio::async_write(_socket, boost::asio::buffer(_redirectUrl), boost::asio::transfer_all(), std::bind(&APIServerConnection::RedirectFinalize, shared_from_this()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void APIServerConnection::SendXML ( )

private

Definition at line 389 of file APIServerConnection.cpp.

References _socket, _xmlData, and Close().

Referenced by ProcessHeaders(), and ProcessPostData().

{
    boost::asio::async_write(_socket, boost::asio::buffer(*_xmlData, _xmlData->size()), boost::asio::transfer_all(), std::bind(&APIServerConnection::Close, shared_from_this()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

boost::asio::ip::tcp::socket & APIServerConnection::socket

(

)

Definition at line 76 of file APIServerConnection.cpp.

References _socket.

{
    return _socket;
}

bool APIServerConnection::starts_with ( std::string &  haystack, const char *const  needle  )

staticprivate

Definition at line 423 of file APIServerConnection.cpp.

Referenced by ProcessHeaders().

{
    return haystack.substr(0, strlen(needle)).compare(needle) == 0;
}

Here is the caller graph for this function:

Member Data Documentation

boost::asio::streambuf APIServerConnection::_buffer

private

Definition at line 68 of file APIServerConnection.h.

Referenced by Process(), and ProcessHeaders().

std::string APIServerConnection::_http_cmd_str

private

Definition at line 65 of file APIServerConnection.h.

Referenced by ProcessHeaders(), and ProcessPostData().

boost::asio::streambuf APIServerConnection::_postBuffer

private

Definition at line 69 of file APIServerConnection.h.

Referenced by ProcessHeaders(), and ProcessPostData().

std::string APIServerConnection::_redirectUrl

private

Definition at line 64 of file APIServerConnection.h.

Referenced by RedirectLocation().

boost::asio::const_buffers_1 APIServerConnection::_responseNoContent = boost::asio::buffer("HTTP/1.0 204 No Content", 23)

staticprivate

Definition at line 75 of file APIServerConnection.h.

Referenced by ProcessPostData().

boost::asio::const_buffers_1 APIServerConnection::_responseNotFound

staticprivate

Definition at line 74 of file APIServerConnection.h.

Referenced by NotFound().

boost::asio::const_buffers_1 APIServerConnection::_responseOK = boost::asio::buffer("HTTP/1.0 200 OK\r\nContent-Type: text/xml\r\n\r\n", 43)

staticprivate

Definition at line 73 of file APIServerConnection.h.

Referenced by ProcessHeaders(), and ProcessPostData().

boost::asio::const_buffers_1 APIServerConnection::_responseRedirectBegin = boost::asio::buffer("HTTP/1.0 301 Moved Permanently\r\nLocation: ", 42)

staticprivate

Definition at line 76 of file APIServerConnection.h.

Referenced by Redirect().

boost::asio::const_buffers_1 APIServerConnection::_responseRedirectEnd = boost::asio::buffer("\r\n\r\n", 4)

staticprivate

Definition at line 77 of file APIServerConnection.h.

Referenced by RedirectFinalize().

std::string APIServerConnection::_service

private

Definition at line 62 of file APIServerConnection.h.

Referenced by ProcessHeaders(), ProcessPostData(), and RedirectLocation().

std::string APIServerConnection::_service_handler

private

Definition at line 63 of file APIServerConnection.h.

Referenced by ProcessHeaders(), and ProcessPostData().

boost::asio::ip::tcp::socket APIServerConnection::_socket

private

Definition at line 70 of file APIServerConnection.h.

Referenced by Close(), NotFound(), Process(), ProcessHeaders(), ProcessPostData(), Redirect(), RedirectFinalize(), RedirectLocation(), SendXML(), and socket().

std::tr1::shared_ptr<std::vector<char> > APIServerConnection::_xmlData

private

Definition at line 71 of file APIServerConnection.h.

Referenced by ProcessHeaders(), ProcessPostData(), and SendXML().

APICommandCall APIServerConnection::m_apiCommandCall

private

Definition at line 66 of file APIServerConnection.h.

Referenced by ProcessHeaders(), and ProcessPostData().

---

The documentation for this class was generated from the following files:

• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/apiserver/APIServerConnection.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/apiserver/APIServerConnection.cpp