Index  Source Files  Annotated Class List  Alphabetical Class List  Class Hierarchy  Graphical Class Hierarchy 

FIX::HttpConnection Class Reference

Encapsulates a HTTP socket file descriptor. More...

#include <HttpConnection.h>

Collaboration diagram for FIX::HttpConnection:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 HttpConnection (int s)
int getSocket () const
bool read ()

Private Member Functions

bool readMessage (std::string &msg) throw ( SocketRecvFailed )
void processStream ()
void processRequest (const HttpMessage &)
void processRoot (const HttpMessage &, std::stringstream &h, std::stringstream &b)
void processResetSessions (const HttpMessage &, std::stringstream &h, std::stringstream &b)
void processRefreshSessions (const HttpMessage &, std::stringstream &h, std::stringstream &b)
void processEnableSessions (const HttpMessage &, std::stringstream &h, std::stringstream &b)
void processDisableSessions (const HttpMessage &, std::stringstream &h, std::stringstream &b)
void processSession (const HttpMessage &, std::stringstream &h, std::stringstream &b)
void processResetSession (const HttpMessage &, std::stringstream &h, std::stringstream &b)
void processRefreshSession (const HttpMessage &, std::stringstream &h, std::stringstream &b)
void showToggle (std::stringstream &s, const std::string &name, bool value, const std::string &url)
void showRow (std::stringstream &s, const std::string &name, bool value, const std::string &url="")
void showRow (std::stringstream &s, const std::string &name, const std::string &value, const std::string &url="")
void showRow (std::stringstream &s, const std::string &name, int value, const std::string &url="")
bool send (const std::string &)
void disconnect (int error=0)

Private Attributes

int m_socket
char m_buffer [BUFSIZ]
HttpParser m_parser
fd_set m_fds

Detailed Description

Encapsulates a HTTP socket file descriptor.

Definition at line 37 of file HttpConnection.h.


Constructor & Destructor Documentation

FIX::HttpConnection::HttpConnection ( int  s  ) 

Definition at line 37 of file HttpConnection.cpp.

References m_fds, and m_socket.

00038 : m_socket( s )
00039 {
00040   FD_ZERO( &m_fds );
00041   FD_SET( m_socket, &m_fds );
00042 }


Member Function Documentation

void FIX::HttpConnection::disconnect ( int  error = 0  )  [private]

Definition at line 50 of file HttpConnection.cpp.

References FIX::HttpMessage::createResponse(), m_socket, QF_STACK_POP, QF_STACK_PUSH, send(), and FIX::socket_close().

Referenced by processRequest(), processStream(), and read().

00051 { QF_STACK_PUSH(HttpConnection::disconnect)
00052   
00053   if( error > 0 )
00054     send( HttpMessage::createResponse(error) );
00055 
00056   socket_close( m_socket );
00057 
00058   QF_STACK_POP
00059 }

int FIX::HttpConnection::getSocket (  )  const [inline]

Definition at line 42 of file HttpConnection.h.

References m_socket.

00042 { return m_socket; }

void FIX::HttpConnection::processDisableSessions ( const HttpMessage request,
std::stringstream &  h,
std::stringstream &  b 
) [private]

Definition at line 404 of file HttpConnection.cpp.

References FIX::HttpMessage::getParameter(), FIX::Session::getSessions(), FIX::HttpMessage::hasParameter(), HTML::A::href(), FIX::Session::logout(), FIX::Session::lookupSession(), HTML::NBSP, QF_STACK_POP, QF_STACK_PUSH, FIX::HttpMessage::removeParameter(), HTML::TAG::text(), and FIX::HttpMessage::toString().

Referenced by processRequest().

00405 { QF_STACK_PUSH(HttpConnection::processDisableSessions)
00406 
00407   try
00408   {
00409     HttpMessage copy = request;
00410 
00411     bool confirm = false;
00412     if( copy.hasParameter("confirm") && copy.getParameter("confirm") != "0" )
00413     {
00414       confirm = true;
00415       std::set<SessionID> sessions = Session::getSessions();
00416       std::set<SessionID>::iterator session;
00417       for( session = sessions.begin(); session != sessions.end(); ++session )
00418         Session::lookupSession( *session )->logout();
00419       copy.removeParameter("confirm");
00420     }
00421 
00422     if( confirm )
00423     {
00424       h << "<META http-equiv='refresh' content=2;URL='" << "/'>";
00425       CENTER center(b); center.text();
00426       H2 h2(b); h2.text();
00427       { A a(b); a.href("/").text("Sessions"); }
00428       b << " have been disabled";
00429     }
00430     else
00431     {
00432       { CENTER center(b); center.text();
00433         H2 h2(b); h2.text();
00434         b << "Are you sure you want to disable all sessions ?";
00435       }
00436       { CENTER center(b); center.text();
00437         b << "[";
00438         { A a(b); a.href(request.toString() + "?confirm=1").text("YES, disable sessions"); }
00439         b << "]" << NBSP << "[";
00440         { A a(b); a.href("/").text("NO, do not disable sessions"); }
00441         b << "]";
00442       }
00443     }
00444   }
00445   catch( std::exception& e )
00446   {
00447     b << e.what();
00448   }
00449 
00450   QF_STACK_POP
00451 }

void FIX::HttpConnection::processEnableSessions ( const HttpMessage request,
std::stringstream &  h,
std::stringstream &  b 
) [private]

Definition at line 354 of file HttpConnection.cpp.

References FIX::HttpMessage::getParameter(), FIX::Session::getSessions(), FIX::HttpMessage::hasParameter(), HTML::A::href(), FIX::Session::logon(), FIX::Session::lookupSession(), HTML::NBSP, QF_STACK_POP, QF_STACK_PUSH, FIX::HttpMessage::removeParameter(), HTML::TAG::text(), and FIX::HttpMessage::toString().

Referenced by processRequest().

00355 { QF_STACK_PUSH(HttpConnection::processEnableSessions)
00356 
00357   try
00358   {
00359     HttpMessage copy = request;
00360 
00361     bool confirm = false;
00362     if( copy.hasParameter("confirm") && copy.getParameter("confirm") != "0" )
00363     {
00364       confirm = true;
00365       std::set<SessionID> sessions = Session::getSessions();
00366       std::set<SessionID>::iterator session;
00367       for( session = sessions.begin(); session != sessions.end(); ++session )
00368         Session::lookupSession( *session )->logon();
00369       copy.removeParameter("confirm");
00370     }
00371 
00372     if( confirm )
00373     {
00374       h << "<META http-equiv='refresh' content=2;URL='" << "/'>";
00375       CENTER center(b); center.text();
00376       H2 h2(b); h2.text();
00377       { A a(b); a.href("/").text("Sessions"); }
00378       b << " have been enabled";
00379     }
00380     else
00381     {
00382       { CENTER center(b); center.text();
00383         H2 h2(b); h2.text();
00384         b << "Are you sure you want to enable all sessions ?";
00385       }
00386       { CENTER center(b); center.text();
00387         b << "[";
00388         { A a(b); a.href(request.toString() + "?confirm=1").text("YES, enable sessions"); }
00389         b << "]" << NBSP << "[";
00390         { A a(b); a.href("/").text("NO, do not enable sessions"); }
00391         b << "]";
00392       }
00393     }
00394   }
00395   catch( std::exception& e )
00396   {
00397     b << e.what();
00398   }
00399 
00400   QF_STACK_POP
00401 }

void FIX::HttpConnection::processRefreshSession ( const HttpMessage request,
std::stringstream &  h,
std::stringstream &  b 
) [private]

Definition at line 655 of file HttpConnection.cpp.

References FIX::HttpMessage::getParameter(), FIX::HttpMessage::getParameterString(), FIX::HttpMessage::hasParameter(), HTML::A::href(), FIX::Session::lookupSession(), HTML::NBSP, QF_STACK_POP, QF_STACK_PUSH, FIX::Session::refresh(), FIX::HttpMessage::removeParameter(), HTML::TAG::text(), FIX::HttpMessage::toString(), and FIX::SessionID::toString().

Referenced by processRequest().

00656 { QF_STACK_PUSH(HttpConnection::processRefreshSession)
00657 
00658   try
00659   {
00660     HttpMessage copy = request;
00661     std::string beginString = request.getParameter( "BeginString" );
00662     std::string senderCompID = request.getParameter( "SenderCompID" );
00663     std::string targetCompID = request.getParameter( "TargetCompID" );
00664     std::string sessionQualifier;
00665     if( copy.hasParameter("SessionQualifier") )
00666     sessionQualifier = copy.getParameter( "SessionQualifier" );
00667 
00668     SessionID sessionID( beginString, senderCompID, targetCompID, sessionQualifier );
00669     Session* pSession = Session::lookupSession( sessionID );
00670     if( pSession == 0 ) throw SessionNotFound();
00671 
00672     std::string sessionUrl = "/session" + request.getParameterString();
00673 
00674     bool confirm = false;
00675     if( copy.hasParameter("confirm") && copy.getParameter("confirm") != "0" )
00676     {
00677       confirm = true;
00678       pSession->refresh();
00679       copy.removeParameter("confirm");
00680     }
00681 
00682     if( confirm )
00683     {
00684       h << "<META http-equiv='refresh' content=2;URL='" << "/session" << copy.getParameterString() << "'>";
00685       CENTER center(b); center.text();
00686       H2 h2(b); h2.text();
00687       { A a(b); a.href("/session" + copy.getParameterString()).text(sessionID.toString()); }
00688       b << " has been refreshed";
00689     }
00690     else
00691     {
00692       { CENTER center(b); center.text();
00693         H2 h2(b); h2.text();
00694         b << "Are you sure you want to refresh session ";
00695         { A a(b); a.href(sessionUrl + request.getParameterString()).text(sessionID.toString()); }
00696         b << "?";
00697       }
00698       { CENTER center(b); center.text();
00699         b << "[";
00700         { A a(b); a.href(request.toString() + "&confirm=1").text("YES, refresh session"); }
00701         b << "]" << NBSP << "[";
00702         { A a(b); a.href(sessionUrl).text("NO, do not refresh session"); }
00703         b << "]";
00704       }
00705     }
00706   }
00707   catch( std::exception& e )
00708   {
00709     b << e.what();
00710   }
00711 
00712   QF_STACK_POP
00713 }

void FIX::HttpConnection::processRefreshSessions ( const HttpMessage request,
std::stringstream &  h,
std::stringstream &  b 
) [private]

Definition at line 304 of file HttpConnection.cpp.

References FIX::HttpMessage::getParameter(), FIX::Session::getSessions(), FIX::HttpMessage::hasParameter(), HTML::A::href(), FIX::Session::lookupSession(), HTML::NBSP, QF_STACK_POP, QF_STACK_PUSH, FIX::Session::refresh(), FIX::HttpMessage::removeParameter(), HTML::TAG::text(), and FIX::HttpMessage::toString().

Referenced by processRequest().

00305 { QF_STACK_PUSH(HttpConnection::processRefreshSessions)
00306 
00307   try
00308   {
00309     HttpMessage copy = request;
00310 
00311     bool confirm = false;
00312     if( copy.hasParameter("confirm") && copy.getParameter("confirm") != "0" )
00313     {
00314       confirm = true;
00315       std::set<SessionID> sessions = Session::getSessions();
00316       std::set<SessionID>::iterator session;
00317       for( session = sessions.begin(); session != sessions.end(); ++session )
00318         Session::lookupSession( *session )->refresh();
00319       copy.removeParameter("confirm");
00320     }
00321 
00322     if( confirm )
00323     {
00324       h << "<META http-equiv='refresh' content=2;URL='" << "/'>";
00325       CENTER center(b); center.text();
00326       H2 h2(b); h2.text();
00327       { A a(b); a.href("/").text("Sessions"); }
00328       b << " have been refreshed";
00329     }
00330     else
00331     {
00332       { CENTER center(b); center.text();
00333         H2 h2(b); h2.text();
00334         b << "Are you sure you want to refresh all sessions ?";
00335       }
00336       { CENTER center(b); center.text();
00337         b << "[";
00338         { A a(b); a.href(request.toString() + "?confirm=1").text("YES, refresh sessions"); }
00339         b << "]" << NBSP << "[";
00340         { A a(b); a.href("/").text("NO, do not refresh sessions"); }
00341         b << "]";
00342       }
00343     }
00344   }
00345   catch( std::exception& e )
00346   {
00347     b << e.what();
00348   }
00349 
00350   QF_STACK_POP
00351 }

void FIX::HttpConnection::processRequest ( const HttpMessage request  )  [private]

Definition at line 140 of file HttpConnection.cpp.

References FIX::HttpMessage::createResponse(), disconnect(), FIX::HttpMessage::getRootString(), HTML::A::href(), HTML::NBSP, processDisableSessions(), processEnableSessions(), processRefreshSession(), processRefreshSessions(), processResetSession(), processResetSessions(), processRoot(), processSession(), QF_STACK_POP, QF_STACK_PUSH, send(), HTML::TAG::text(), and FIX::HttpMessage::toString().

Referenced by processStream().

00141 { QF_STACK_PUSH(HttpConnection::processRequest)
00142 
00143   int error = 200;
00144   std::stringstream h;
00145   std::stringstream b;
00146   std::string titleString = "QuickFIX Engine Web Interface";
00147 
00148   { HEAD head(h); head.text();
00149     { CENTER center(h); center.text();
00150       { TITLE title(h); title.text(titleString); }
00151       { H1 h1(h); h1.text(titleString); }
00152     }
00153     { CENTER center(h); center.text();
00154       { A a(h); a.href("/").text("HOME"); }
00155       h << NBSP;
00156       { A a(h); a.href(request.toString()).text("RELOAD"); }
00157     }
00158     HR hr(h); hr.text();
00159   }
00160 
00161   BODY body(b); body.text();
00162 
00163   try
00164   {
00165     if( request.getRootString() == "/" )
00166       processRoot( request, h, b );
00167     else if( request.getRootString() == "/resetSessions" )
00168       processResetSessions( request, h, b );
00169     else if( request.getRootString() == "/refreshSessions" )
00170       processRefreshSessions( request, h, b );
00171     else if( request.getRootString() == "/enableSessions" )
00172       processEnableSessions( request, h, b );
00173     else if( request.getRootString() == "/disableSessions" )
00174       processDisableSessions( request, h, b );
00175     else if( request.getRootString() == "/session" )
00176       processSession( request, h, b );
00177     else if( request.getRootString() == "/resetSession" )
00178       processResetSession( request, h, b );
00179     else if( request.getRootString() == "/refreshSession" )
00180       processRefreshSession( request, h, b );
00181     else
00182       error = 404;
00183   }
00184   catch( std::exception& e )
00185   {
00186     error = 400;
00187     b << e.what();
00188   }
00189 
00190   std::string response = "<HTML>" + h.str() + b.str() + "</HTML>";
00191   send( HttpMessage::createResponse(error, error == 200 ? response : "") );
00192 
00193   disconnect();
00194 
00195   QF_STACK_POP
00196 }

void FIX::HttpConnection::processResetSession ( const HttpMessage request,
std::stringstream &  h,
std::stringstream &  b 
) [private]

Definition at line 594 of file HttpConnection.cpp.

References FIX::HttpMessage::getParameter(), FIX::HttpMessage::getParameterString(), FIX::HttpMessage::hasParameter(), HTML::A::href(), FIX::Session::lookupSession(), HTML::NBSP, QF_STACK_POP, QF_STACK_PUSH, FIX::HttpMessage::removeParameter(), FIX::Session::reset(), HTML::TAG::text(), FIX::HttpMessage::toString(), and FIX::SessionID::toString().

Referenced by processRequest().

00595 { QF_STACK_PUSH(HttpConnection::processResetSession)
00596 
00597   try
00598   {
00599     HttpMessage copy = request;
00600     std::string beginString = request.getParameter( "BeginString" );
00601     std::string senderCompID = request.getParameter( "SenderCompID" );
00602     std::string targetCompID = request.getParameter( "TargetCompID" );
00603     std::string sessionQualifier;
00604     if( copy.hasParameter("SessionQualifier") )
00605       sessionQualifier = copy.getParameter( "SessionQualifier" );
00606 
00607     SessionID sessionID( beginString, senderCompID, targetCompID, sessionQualifier );
00608     Session* pSession = Session::lookupSession( sessionID );
00609     if( pSession == 0 ) throw SessionNotFound();
00610 
00611     std::string sessionUrl = "/session" + request.getParameterString();
00612 
00613     bool confirm = false;
00614     if( copy.hasParameter("confirm") && copy.getParameter("confirm") != "0" )
00615     {
00616       confirm = true;
00617       pSession->reset();
00618       copy.removeParameter("confirm");
00619     }
00620 
00621     if( confirm )
00622     {
00623       h << "<META http-equiv='refresh' content=2;URL='" << "/session" << copy.getParameterString() << "'>";
00624       CENTER center(b); center.text();
00625       H2 h2(b); h2.text();
00626       { A a(b); a.href("/session" + copy.getParameterString()).text(sessionID.toString()); }
00627       b << " has been reset";
00628     }
00629     else
00630     {
00631       { CENTER center(b); center.text();
00632         H2 h2(b); h2.text();
00633         b << "Are you sure you want to reset session ";
00634         { A a(b); a.href(sessionUrl + request.getParameterString()).text(sessionID.toString()); }
00635         b << "?";
00636       }
00637       { CENTER center(b); center.text();
00638         b << "[";
00639         { A a(b); a.href(request.toString() + "&confirm=1").text("YES, reset session"); }
00640         b << "]" << NBSP << "[";
00641         { A a(b); a.href(sessionUrl).text("NO, do not reset session"); }
00642         b << "]";
00643       }
00644     }
00645   }
00646   catch( std::exception& e )
00647   {
00648     b << e.what();
00649   }
00650 
00651   QF_STACK_POP
00652 }

void FIX::HttpConnection::processResetSessions ( const HttpMessage request,
std::stringstream &  h,
std::stringstream &  b 
) [private]

Definition at line 254 of file HttpConnection.cpp.

References FIX::HttpMessage::getParameter(), FIX::Session::getSessions(), FIX::HttpMessage::hasParameter(), HTML::A::href(), FIX::Session::lookupSession(), HTML::NBSP, QF_STACK_POP, QF_STACK_PUSH, FIX::HttpMessage::removeParameter(), FIX::Session::reset(), HTML::TAG::text(), and FIX::HttpMessage::toString().

Referenced by processRequest().

00255 { QF_STACK_PUSH(HttpConnection::processResetSessions)
00256 
00257   try
00258   {
00259     HttpMessage copy = request;
00260 
00261     bool confirm = false;
00262     if( copy.hasParameter("confirm") && copy.getParameter("confirm") != "0" )
00263     {
00264       confirm = true;
00265       std::set<SessionID> sessions = Session::getSessions();
00266       std::set<SessionID>::iterator session;
00267       for( session = sessions.begin(); session != sessions.end(); ++session )
00268         Session::lookupSession( *session )->reset();
00269       copy.removeParameter("confirm");
00270     }
00271 
00272     if( confirm )
00273     {
00274       h << "<META http-equiv='refresh' content=2;URL='" << "/'>";
00275       CENTER center(b); center.text();
00276       H2 h2(b); h2.text();
00277       { A a(b); a.href("/").text("Sessions"); }
00278       b << " have been reset";
00279     }
00280     else
00281     {
00282       { CENTER center(b); center.text();
00283         H2 h2(b); h2.text();
00284         b << "Are you sure you want to reset all sessions ?";
00285       }
00286       { CENTER center(b); center.text();
00287         b << "[";
00288         { A a(b); a.href(request.toString() + "?confirm=1").text("YES, reset sessions"); }
00289         b << "]" << NBSP << "[";
00290         { A a(b); a.href("/").text("NO, do not reset sessions"); }
00291         b << "]";
00292       }
00293     }
00294   }
00295   catch( std::exception& e )
00296   {
00297     b << e.what();
00298   }
00299 
00300   QF_STACK_POP
00301 }

void FIX::HttpConnection::processRoot ( const HttpMessage request,
std::stringstream &  h,
std::stringstream &  b 
) [private]

Definition at line 199 of file HttpConnection.cpp.

References HTML::TD::align(), HTML::TABLE::border(), HTML::TABLE::cellspacing(), FIX::Session::getExpectedSenderNum(), FIX::Session::getExpectedTargetNum(), FIX::HttpMessage::getParameterString(), FIX::Session::getSessions(), HTML::A::href(), FIX::Session::isEnabled(), FIX::Session::isInitiator(), FIX::Session::isLoggedOn(), FIX::Session::isSessionTime(), FIX::Session::lookupSession(), HTML::NBSP, FIX::Session::numSessions(), QF_STACK_POP, QF_STACK_PUSH, HTML::TAG::text(), and HTML::TABLE::width().

Referenced by processRequest().

00200 { QF_STACK_PUSH(HttpConnection::processRoot)
00201 
00202   TABLE table(b); table.border(1).cellspacing(2).width(100).text();
00203 
00204   { CAPTION caption(b); caption.text();
00205     EM em(b); em.text();
00206     b << Session::numSessions() << " Sessions managed by QuickFIX";
00207     { HR hr(b); hr.text(); }
00208     { b << NBSP; A a(b); a.href("/resetSessions" + request.getParameterString()).text("RESET"); }
00209     { b << NBSP; A a(b); a.href("/refreshSessions" + request.getParameterString()).text("REFRESH"); }
00210     { b << NBSP; A a(b); a.href("/enableSessions" + request.getParameterString()).text("ENABLE"); }
00211     { b << NBSP; A a(b); a.href("/disableSessions" + request.getParameterString()).text("DISABLE"); }
00212   }
00213 
00214   { TR tr(b); tr.text();
00215     { TD td(b); td.align("center").text("Session"); }
00216     { TD td(b); td.align("center").text("ConnectionType"); }
00217     { TD td(b); td.align("center").text("Enabled"); }
00218     { TD td(b); td.align("center").text("Session Time"); }
00219     { TD td(b); td.align("center").text("Logged On"); }
00220     { TD td(b); td.align("center").text("Next Incoming"); }
00221     { TD td(b); td.align("center").text("Next Outgoing"); }
00222   }
00223 
00224   std::set<SessionID> sessions = Session::getSessions();
00225   std::set<SessionID>::iterator i;
00226   for( i = sessions.begin(); i != sessions.end(); ++i )
00227   {
00228     Session* pSession = Session::lookupSession( *i );
00229     if( !pSession ) continue;
00230 
00231     { TR tr(b); tr.text();
00232       { TD td(b); td.text();
00233         std::string href = "/session?BeginString=" + i->getBeginString().getValue() +
00234                             "&SenderCompID=" + i->getSenderCompID().getValue() +
00235                             "&TargetCompID=" + i->getTargetCompID().getValue();
00236         if( i->getSessionQualifier().size() )
00237           href += "&SessionQualifier=" + i->getSessionQualifier();
00238 
00239         A a(b); a.href(href).text(i->toString());
00240       }
00241       { TD td(b); td.text(pSession->isInitiator() ? "initiator" : "acceptor"); }
00242       { TD td(b); td.text(pSession->isEnabled() ? "yes" : "no"); }
00243       { TD td(b); td.text(pSession->isSessionTime(UtcTimeStamp()) ? "yes" : "no"); }
00244       { TD td(b); td.text(pSession->isLoggedOn() ? "yes" : "no"); }
00245       { TD td(b); td.text(pSession->getExpectedTargetNum()); }
00246       { TD td(b); td.text(pSession->getExpectedSenderNum()); }
00247     }
00248   }
00249 
00250   QF_STACK_POP
00251 }

void FIX::HttpConnection::processSession ( const HttpMessage request,
std::stringstream &  h,
std::stringstream &  b 
) [private]

Definition at line 454 of file HttpConnection.cpp.

References HTML::TABLE::border(), HTML::TABLE::cellspacing(), FIX::CHECK_COMPID, FIX::CHECK_LATENCY, FIX::IntConvertor::convert(), FIX::Session::getCheckCompId(), FIX::Session::getCheckLatency(), FIX::Session::getExpectedSenderNum(), FIX::Session::getExpectedTargetNum(), FIX::Session::getLogonTimeout(), FIX::Session::getLogoutTimeout(), FIX::Session::getMaxLatency(), FIX::Session::getMillisecondsInTimeStamp(), FIX::HttpMessage::getParameter(), FIX::HttpMessage::getParameterString(), FIX::Session::getPersistMessages(), FIX::Session::getRefreshOnLogon(), FIX::Session::getResetOnDisconnect(), FIX::Session::getResetOnLogon(), FIX::Session::getResetOnLogout(), FIX::Session::getSendRedundantResendRequests(), FIX::HttpMessage::hasParameter(), HTML::A::href(), FIX::Session::isEnabled(), FIX::Session::isInitiator(), FIX::Session::isLoggedOn(), FIX::Session::isSessionTime(), FIX::Session::logon(), FIX::LOGON_TIMEOUT, FIX::Session::logout(), FIX::LOGOUT_TIMEOUT, FIX::Session::lookupSession(), FIX::MAX_LATENCY, FIX::MILLISECONDS_IN_TIMESTAMP, HTML::NBSP, FIX::PERSIST_MESSAGES, QF_STACK_POP, QF_STACK_PUSH, FIX::REFRESH_ON_LOGON, FIX::HttpMessage::removeParameter(), FIX::RESET_ON_DISCONNECT, FIX::RESET_ON_LOGON, FIX::RESET_ON_LOGOUT, FIX::SEND_REDUNDANT_RESENDREQUESTS, FIX::Session::setCheckCompId(), FIX::Session::setCheckLatency(), FIX::Session::setLogonTimeout(), FIX::Session::setLogoutTimeout(), FIX::Session::setMaxLatency(), FIX::Session::setMillisecondsInTimeStamp(), FIX::Session::setNextSenderMsgSeqNum(), FIX::Session::setNextTargetMsgSeqNum(), FIX::Session::setPersistMessages(), FIX::Session::setRefreshOnLogon(), FIX::Session::setResetOnDisconnect(), FIX::Session::setResetOnLogon(), FIX::Session::setResetOnLogout(), FIX::Session::setSendRedundantResendRequests(), HTML::TAG::text(), FIX::HttpMessage::toString(), and HTML::TABLE::width().

Referenced by processRequest().

00455 { QF_STACK_PUSH(HttpConnection::processSession)
00456 
00457   try
00458   {
00459     HttpMessage copy = request;
00460     std::string url = request.toString();
00461     std::string beginString = copy.getParameter( "BeginString" );
00462     std::string senderCompID = copy.getParameter( "SenderCompID" );
00463     std::string targetCompID = copy.getParameter( "TargetCompID" );
00464     std::string sessionQualifier;
00465     if( copy.hasParameter("SessionQualifier") )
00466       sessionQualifier = copy.getParameter( "SessionQualifier" );
00467 
00468     SessionID sessionID( beginString, senderCompID, targetCompID, sessionQualifier );
00469     Session* pSession = Session::lookupSession( sessionID );
00470     if( pSession == 0 ) throw SessionNotFound();
00471 
00472     if( copy.hasParameter("Enabled") )
00473     {
00474       copy.getParameter("Enabled") == "0" ? pSession->logout() : pSession->logon();
00475       copy.removeParameter("Enabled");
00476     }
00477     if( copy.hasParameter("Next%20Incoming") )
00478     {
00479       int value = IntConvertor::convert( copy.getParameter("Next%20Incoming") );
00480       pSession->setNextTargetMsgSeqNum( value <= 0 ? 1 : value );
00481       copy.removeParameter("Next%20Incoming");
00482     }
00483     if( copy.hasParameter("Next%20Outgoing") )
00484     {
00485       int value = IntConvertor::convert( copy.getParameter("Next%20Outgoing") );
00486       pSession->setNextSenderMsgSeqNum( value <= 0 ? 1 : value );
00487       copy.removeParameter("Next%20Outgoing");
00488     }
00489     if( copy.hasParameter(SEND_REDUNDANT_RESENDREQUESTS) )
00490     {
00491       pSession->setSendRedundantResendRequests( copy.getParameter(SEND_REDUNDANT_RESENDREQUESTS) != "0" );
00492       copy.removeParameter(SEND_REDUNDANT_RESENDREQUESTS);
00493     }
00494     if( copy.hasParameter(CHECK_COMPID) )
00495     {
00496       pSession->setCheckCompId( copy.getParameter(CHECK_COMPID) != "0" );
00497       copy.removeParameter(CHECK_COMPID);
00498     }
00499     if( copy.hasParameter(CHECK_LATENCY) )
00500     {
00501       pSession->setCheckLatency( copy.getParameter(CHECK_LATENCY) != "0" );
00502       copy.removeParameter(CHECK_LATENCY);
00503     }
00504     if( copy.hasParameter(MAX_LATENCY) )
00505     {
00506       int value = IntConvertor::convert( copy.getParameter(MAX_LATENCY) );
00507       pSession->setMaxLatency( value <= 0 ? 1 : value );
00508       copy.removeParameter(MAX_LATENCY);
00509     }
00510     if( copy.hasParameter(LOGON_TIMEOUT) )
00511     {
00512       int value = IntConvertor::convert( copy.getParameter(LOGON_TIMEOUT) );
00513       pSession->setLogonTimeout( value <= 0 ? 1 : value );
00514       copy.removeParameter(LOGON_TIMEOUT);
00515     }
00516     if( copy.hasParameter(LOGOUT_TIMEOUT) )
00517     {
00518       int value = IntConvertor::convert( copy.getParameter(LOGOUT_TIMEOUT) );
00519       pSession->setLogoutTimeout( value <= 0 ? 1 : value );
00520       copy.removeParameter(LOGOUT_TIMEOUT);
00521     }
00522     if( copy.hasParameter(RESET_ON_LOGON) )
00523     {
00524       pSession->setResetOnLogon( copy.getParameter(RESET_ON_LOGON) != "0" );
00525       copy.removeParameter(RESET_ON_LOGON);
00526     }
00527     if( copy.hasParameter(RESET_ON_LOGOUT) )
00528     {
00529       pSession->setResetOnLogout( copy.getParameter(RESET_ON_LOGOUT) != "0" );
00530       copy.removeParameter(RESET_ON_LOGOUT);
00531     }
00532     if( copy.hasParameter(RESET_ON_DISCONNECT) )
00533     {
00534       pSession->setResetOnDisconnect( copy.getParameter(RESET_ON_DISCONNECT) != "0" );
00535       copy.removeParameter(RESET_ON_DISCONNECT);
00536     }
00537     if( copy.hasParameter(REFRESH_ON_LOGON) )
00538     {
00539       pSession->setRefreshOnLogon( copy.getParameter(REFRESH_ON_LOGON) != "0" );
00540       copy.removeParameter(REFRESH_ON_LOGON);
00541     }
00542     if( copy.hasParameter(MILLISECONDS_IN_TIMESTAMP) )
00543     {
00544       pSession->setMillisecondsInTimeStamp( copy.getParameter(MILLISECONDS_IN_TIMESTAMP) != "0" );
00545       copy.removeParameter(MILLISECONDS_IN_TIMESTAMP);
00546     }
00547     if( copy.hasParameter(PERSIST_MESSAGES) )
00548     {
00549       pSession->setPersistMessages( copy.getParameter(PERSIST_MESSAGES) != "0" );
00550       copy.removeParameter(PERSIST_MESSAGES);
00551     }
00552 
00553     if( url != copy.toString() )
00554       h << "<META http-equiv='refresh' content=0;URL='" << copy.toString() << "'>";
00555 
00556     TABLE table(b); table.border(1).cellspacing(2).width(100).text();
00557 
00558     { CAPTION caption(b); caption.text();
00559       EM em(b); em.text();
00560       b << sessionID;
00561       { HR hr(b); hr.text(); }
00562       { b << NBSP; A a(b); a.href("/resetSession" + copy.getParameterString()).text("RESET"); }
00563       { b << NBSP; A a(b); a.href("/refreshSession" + copy.getParameterString()).text("REFRESH"); }
00564     }
00565 
00566     showRow( b, "Enabled", pSession->isEnabled(), url );
00567     showRow( b, "ConnectionType", std::string(pSession->isInitiator() ?"initiator" : "acceptor") );
00568     showRow( b, "SessionTime", pSession->isSessionTime(UtcTimeStamp()) );
00569     showRow( b, "Logged On", pSession->isLoggedOn() );
00570     showRow( b, "Next Incoming", (int)pSession->getExpectedTargetNum(), url );
00571     showRow( b, "Next Outgoing", (int)pSession->getExpectedSenderNum(), url );
00572     showRow( b, SEND_REDUNDANT_RESENDREQUESTS, pSession->getSendRedundantResendRequests(), url );
00573     showRow( b, CHECK_COMPID, pSession->getCheckCompId(), url );
00574     showRow( b, CHECK_LATENCY, pSession->getCheckLatency(), url );
00575     showRow( b, MAX_LATENCY, pSession->getMaxLatency(), url );
00576     showRow( b, LOGON_TIMEOUT, pSession->getLogonTimeout(), url );
00577     showRow( b, LOGOUT_TIMEOUT, pSession->getLogoutTimeout(), url );
00578     showRow( b, RESET_ON_LOGON, pSession->getResetOnLogon(), url );
00579     showRow( b, RESET_ON_LOGOUT, pSession->getResetOnLogout(), url );
00580     showRow( b, RESET_ON_DISCONNECT, pSession->getResetOnDisconnect(), url );
00581     showRow( b, REFRESH_ON_LOGON, pSession->getRefreshOnLogon(), url );
00582     showRow( b, MILLISECONDS_IN_TIMESTAMP, pSession->getMillisecondsInTimeStamp(), url );
00583     showRow( b, PERSIST_MESSAGES, pSession->getPersistMessages(), url );
00584   }
00585   catch( std::exception& e )
00586   {
00587     b << e.what();
00588   }
00589 
00590   QF_STACK_POP
00591 }

void FIX::HttpConnection::processStream (  )  [private]

Definition at line 118 of file HttpConnection.cpp.

References disconnect(), processRequest(), QF_STACK_POP, QF_STACK_PUSH, and readMessage().

Referenced by read().

00119 { QF_STACK_PUSH(HttpConnection::processStream)
00120 
00121   std::string msg;
00122   try
00123   {
00124     if( !readMessage(msg) )
00125       return;
00126     HttpMessage request( msg );
00127     processRequest( request );
00128   }
00129   catch( InvalidMessage& ) 
00130   {
00131     disconnect( 400 );
00132     return;
00133   }
00134 
00135   return;
00136 
00137   QF_STACK_POP
00138 }

bool FIX::HttpConnection::read (  ) 

Definition at line 61 of file HttpConnection.cpp.

References FIX::HttpParser::addToStream(), disconnect(), m_buffer, m_fds, m_parser, m_socket, processStream(), QF_STACK_POP, and QF_STACK_PUSH.

Referenced by FIX::HttpServer::onConnect().

00062 { QF_STACK_PUSH(HttpConnection::read)
00063 
00064   struct timeval timeout = { 2, 0 };
00065   fd_set readset = m_fds;
00066 
00067   try
00068   {
00069     // Wait for input (1 second timeout)
00070     int result = select( 1 + m_socket, &readset, 0, 0, &timeout );
00071 
00072     if( result > 0 ) // Something to read
00073     {
00074       // We can read without blocking
00075       int size = recv( m_socket, m_buffer, sizeof(m_buffer), 0 );
00076       if ( size <= 0 ) { throw SocketRecvFailed( size ); }
00077       m_parser.addToStream( m_buffer, size );
00078     }
00079     else if( result == 0 ) // Timeout
00080     {
00081       disconnect( 408 );
00082       return false;
00083     }
00084     else if( result < 0 ) // Error
00085     {
00086       throw SocketRecvFailed( result );
00087     }
00088 
00089     processStream();
00090     return true;
00091   }
00092   catch ( SocketRecvFailed& )
00093   {
00094     disconnect();
00095     return false;
00096   }
00097 
00098   QF_STACK_POP
00099 }

bool FIX::HttpConnection::readMessage ( std::string &  msg  )  throw ( SocketRecvFailed ) [private]

Definition at line 101 of file HttpConnection.cpp.

References QF_STACK_POP, and QF_STACK_PUSH.

Referenced by processStream().

00103 { QF_STACK_PUSH(HttpConnection::readMessage)
00104 
00105   try
00106   {
00107     return m_parser.readHttpMessage( msg );
00108   }
00109   catch ( MessageParseError& ) 
00110   { 
00111     disconnect( 400 );
00112   }
00113   return true;
00114 
00115   QF_STACK_POP
00116 }

bool FIX::HttpConnection::send ( const std::string &  msg  )  [private]

Definition at line 44 of file HttpConnection.cpp.

References m_socket, QF_STACK_POP, QF_STACK_PUSH, and FIX::socket_send().

Referenced by disconnect(), and processRequest().

00045 { QF_STACK_PUSH(HttpConnection::send)
00046   return socket_send( m_socket, msg.c_str(), msg.length() ) >= 0;
00047   QF_STACK_POP
00048 }

void FIX::HttpConnection::showRow ( std::stringstream &  s,
const std::string &  name,
int  value,
const std::string &  url = "" 
) [private]

Definition at line 752 of file HttpConnection.cpp.

References HTML::A::href(), HTML::NBSP, QF_STACK_POP, QF_STACK_PUSH, showRow(), and HTML::TAG::text().

00753 { QF_STACK_PUSH(HttpConnection::showRow)
00754 
00755     { TR tr(s); tr.text();
00756       { TD td(s); td.text(name); }
00757       { TD td(s); td.text(value); }
00758       { TD td(s); td.text();
00759         CENTER center(s); center.text();
00760         {
00761           std::stringstream href;
00762           href << url << "&" << name << "=" << value - 10;
00763           A a(s); a.href(href.str()).text("<<");
00764         }
00765         s << NBSP;
00766         {
00767           std::stringstream href;
00768           href << url << "&" << name << "=" << value - 1;
00769           A a(s); a.href(href.str()).text("<");
00770         }
00771         s << NBSP << "|" << NBSP;
00772         {
00773           std::stringstream href;
00774           href << url << "&" << name << "=" << value + 1;
00775           A a(s); a.href(href.str()).text(">");
00776         }
00777         s << NBSP;
00778         {
00779           std::stringstream href;
00780           href << url << "&" << name << "=" << value + 10;
00781           A a(s); a.href(href.str()).text(">>");
00782         }
00783       }
00784     }
00785 
00786   QF_STACK_POP
00787 }

void FIX::HttpConnection::showRow ( std::stringstream &  s,
const std::string &  name,
const std::string &  value,
const std::string &  url = "" 
) [private]

Definition at line 737 of file HttpConnection.cpp.

References QF_STACK_POP, QF_STACK_PUSH, showRow(), and HTML::TAG::text().

00738 { QF_STACK_PUSH(HttpConnection::showRow)
00739 
00740     { TR tr(s); tr.text();
00741       { TD td(s); td.text(name); }
00742       { TD td(s); td.text(value); }
00743       { TD td(s); td.text();
00744         CENTER center(s); center.text();
00745       }
00746     }
00747 
00748   QF_STACK_POP
00749 }

void FIX::HttpConnection::showRow ( std::stringstream &  s,
const std::string &  name,
bool  value,
const std::string &  url = "" 
) [private]

Definition at line 716 of file HttpConnection.cpp.

References HTML::A::href(), QF_STACK_POP, QF_STACK_PUSH, and HTML::TAG::text().

Referenced by showRow().

00717 { QF_STACK_PUSH(HttpConnection::showRow)
00718 
00719     { TR tr(s); tr.text();
00720       { TD td(s); td.text(name); }
00721       { TD td(s); td.text(value ? "yes" : "no"); }
00722       { TD td(s); td.text();
00723         CENTER center(s); center.text();
00724         if( url.size() )
00725         {
00726           std::stringstream href;
00727           href << url << "&" << name << "=" << !value;
00728           A a(s); a.href(href.str()).text("toggle");
00729         }
00730       }
00731     }
00732 
00733   QF_STACK_POP
00734 }

void FIX::HttpConnection::showToggle ( std::stringstream &  s,
const std::string &  name,
bool  value,
const std::string &  url 
) [private]

Member Data Documentation

char FIX::HttpConnection::m_buffer[BUFSIZ] [private]

Definition at line 71 of file HttpConnection.h.

Referenced by read().

fd_set FIX::HttpConnection::m_fds [private]

Definition at line 74 of file HttpConnection.h.

Referenced by HttpConnection(), and read().

Definition at line 73 of file HttpConnection.h.

Referenced by read().

Definition at line 70 of file HttpConnection.h.

Referenced by disconnect(), getSocket(), HttpConnection(), read(), and send().


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

Generated on Mon Apr 5 21:00:06 2010 for QuickFIX by doxygen 1.6.1 written by Dimitri van Heesch, © 1997-2001