QuickFIX: /home/omiller/Development/autobuild/quickfix/src/C++/HttpConnection.cpp Source File

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

# HttpConnection.cpp

Go to the documentation of this file.

    00001 /****************************************************************************
    00002 ** Copyright (c) quickfixengine.org  All rights reserved.
    00003 **
    00004 ** This file is part of the QuickFIX FIX Engine
    00005 **
    00006 ** This file may be distributed under the terms of the quickfixengine.org
    00007 ** license as defined by quickfixengine.org and appearing in the file
    00008 ** LICENSE included in the packaging of this file.
    00009 **
    00010 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
    00011 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
    00012 **
    00013 ** See http://www.quickfixengine.org/LICENSE for licensing information.
    00014 **
    00015 ** Contact ask@quickfixengine.org if any conditions of this licensing are
    00016 ** not clear to you.
    00017 **
    00018 ****************************************************************************/
    00019
    00020 #ifdef _MSC_VER
    00021 #include "stdafx.h"
    00022 #else
    00023 #include "config.h"
    00024 #endif
    00025 #include "CallStack.h"
    00026
    00027 #include "HttpConnection.h"
    00028 #include "HttpMessage.h"
    00029 #include "HtmlBuilder.h"
    00030 #include "Session.h"
    00031 #include "Utility.h"
    00032
    00033 using namespace HTML;
    00034
    00035 namespace FIX
    00036 {
    00037 HttpConnection::HttpConnection( int s )
    00038 : m_socket( s )
    00039 {
    00040   FD_ZERO( &m_fds );
    00041   FD_SET( m_socket, &m_fds );
    00042 }
    00043
    00044 bool HttpConnection::send( const std::string& msg )
    00045 { QF_STACK_PUSH(HttpConnection::send)
    00046   return socket_send( m_socket, msg.c_str(), msg.length() ) >= 0;
    00047   QF_STACK_POP
    00048 }
    00049
    00050 void HttpConnection::disconnect( int error )
    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 }
    00060
    00061 bool HttpConnection::read()
    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 }
    00100
    00101 bool HttpConnection::readMessage( std::string& msg )
    00102 throw( SocketRecvFailed )
    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 }
    00117
    00118 void HttpConnection::processStream()
    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 }
    00139
    00140 void HttpConnection::processRequest( const HttpMessage& request )
    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 }
    00197
    00198 void HttpConnection::processRoot
    00199 ( const HttpMessage& request, std::stringstream& h, std::stringstream& b )
    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 }
    00252
    00253 void HttpConnection::processResetSessions
    00254 ( const HttpMessage& request, std::stringstream& h, std::stringstream& b )
    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 }
    00302
    00303 void HttpConnection::processRefreshSessions
    00304 ( const HttpMessage& request, std::stringstream& h, std::stringstream& b )
    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 }
    00352
    00353 void HttpConnection::processEnableSessions
    00354 ( const HttpMessage& request, std::stringstream& h, std::stringstream& b )
    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 }
    00402
    00403 void HttpConnection::processDisableSessions
    00404 ( const HttpMessage& request, std::stringstream& h, std::stringstream& b )
    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 }
    00452
    00453 void HttpConnection::processSession
    00454 ( const HttpMessage& request, std::stringstream& h, std::stringstream& b )
    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 }
    00592
    00593 void HttpConnection::processResetSession
    00594 ( const HttpMessage& request, std::stringstream& h, std::stringstream& b )
    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 }
    00653
    00654 void HttpConnection::processRefreshSession
    00655 ( const HttpMessage& request, std::stringstream& h, std::stringstream& b )
    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 }
    00714
    00715 void HttpConnection::showRow
    00716 ( std::stringstream& s, const std::string& name, bool value, const std::string& url )
    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 }
    00735
    00736 void HttpConnection::showRow
    00737 ( std::stringstream& s, const std::string& name, const std::string& value, const std::string& url )
    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 }
    00750
    00751 void HttpConnection::showRow
    00752 ( std::stringstream& s, const std::string& name, int value, const std::string& url )
    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 }
    00788
    00789 } // namespace FIX