Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes
FIX::Session Class Reference

Maintains the state and implements the logic of a FIX session. More...

#include <Session.h>

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

List of all members.

Public Member Functions

 Session (Application &, MessageStoreFactory &, const SessionID &, const DataDictionaryProvider &, const TimeRange &, int heartBtInt, LogFactory *pLogFactory)
virtual ~Session ()
void logon ()
void logout (const std::string &reason="")
bool isEnabled ()
bool sentLogon ()
bool sentLogout ()
bool receivedLogon ()
bool isLoggedOn ()
void reset () throw ( IOException )
void refresh () throw ( IOException )
void setNextSenderMsgSeqNum (int num) throw ( IOException )
void setNextTargetMsgSeqNum (int num) throw ( IOException )
const SessionIDgetSessionID () const
void setDataDictionaryProvider (const DataDictionaryProvider &dataDictionaryProvider)
const DataDictionaryProvidergetDataDictionaryProvider () const
bool isSessionTime (const UtcTimeStamp &time)
bool isLogonTime (const UtcTimeStamp &time)
bool isInitiator ()
bool isAcceptor ()
const TimeRangegetLogonTime ()
void setLogonTime (const TimeRange &value)
const std::string & getSenderDefaultApplVerID ()
void setSenderDefaultApplVerID (const std::string &senderDefaultApplVerID)
const std::string & getTargetDefaultApplVerID ()
void setTargetDefaultApplVerID (const std::string &targetDefaultApplVerID)
bool getSendRedundantResendRequests ()
void setSendRedundantResendRequests (bool value)
bool getCheckCompId ()
void setCheckCompId (bool value)
bool getCheckLatency ()
void setCheckLatency (bool value)
int getMaxLatency ()
void setMaxLatency (int value)
int getLogonTimeout ()
void setLogonTimeout (int value)
int getLogoutTimeout ()
void setLogoutTimeout (int value)
bool getResetOnLogon ()
void setResetOnLogon (bool value)
bool getResetOnLogout ()
void setResetOnLogout (bool value)
bool getResetOnDisconnect ()
void setResetOnDisconnect (bool value)
bool getRefreshOnLogon ()
void setRefreshOnLogon (bool value)
bool getMillisecondsInTimeStamp ()
void setMillisecondsInTimeStamp (bool value)
bool getPersistMessages ()
void setPersistMessages (bool value)
bool getValidateLengthAndChecksum ()
void setValidateLengthAndChecksum (bool value)
void setResponder (Responder *pR)
bool send (Message &)
void next ()
void next (const UtcTimeStamp &timeStamp)
void next (const std::string &, const UtcTimeStamp &timeStamp, bool queued=false)
void next (const Message &, const UtcTimeStamp &timeStamp, bool queued=false)
void disconnect ()
int getExpectedSenderNum ()
int getExpectedTargetNum ()
LoggetLog ()
const MessageStoregetStore ()

Static Public Member Functions

static bool sendToTarget (Message &message, const std::string &qualifier="") throw ( SessionNotFound )
static bool sendToTarget (Message &message, const SessionID &sessionID) throw ( SessionNotFound )
static bool sendToTarget (Message &, const SenderCompID &senderCompID, const TargetCompID &targetCompID, const std::string &qualifier="") throw ( SessionNotFound )
static bool sendToTarget (Message &message, const std::string &senderCompID, const std::string &targetCompID, const std::string &qualifier="") throw ( SessionNotFound )
static std::set< SessionIDgetSessions ()
static bool doesSessionExist (const SessionID &)
static SessionlookupSession (const SessionID &)
static SessionlookupSession (const std::string &, bool reverse=false)
static bool isSessionRegistered (const SessionID &)
static SessionregisterSession (const SessionID &)
static void unregisterSession (const SessionID &)
static int numSessions ()

Private Types

typedef std::map< SessionID,
Session * > 
Sessions
typedef std::set< SessionIDSessionIDs

Private Member Functions

bool send (const std::string &)
bool sendRaw (Message &, int msgSeqNum=0)
bool resend (Message &message)
void persist (const Message &, const std::string &) throw ( IOException )
void insertSendingTime (Header &)
void insertOrigSendingTime (Header &, const UtcTimeStamp &when=UtcTimeStamp())
void fill (Header &)
bool isGoodTime (const SendingTime &sendingTime)
bool checkSessionTime (const UtcTimeStamp &timeStamp)
bool isTargetTooHigh (const MsgSeqNum &msgSeqNum)
bool isTargetTooLow (const MsgSeqNum &msgSeqNum)
bool isCorrectCompID (const SenderCompID &senderCompID, const TargetCompID &targetCompID)
bool shouldSendReset ()
bool validLogonState (const MsgType &msgType)
void fromCallback (const MsgType &msgType, const Message &msg, const SessionID &sessionID)
void doBadTime (const Message &msg)
void doBadCompID (const Message &msg)
bool doPossDup (const Message &msg)
bool doTargetTooLow (const Message &msg)
void doTargetTooHigh (const Message &msg)
void nextQueued (const UtcTimeStamp &timeStamp)
bool nextQueued (int num, const UtcTimeStamp &timeStamp)
void nextLogon (const Message &, const UtcTimeStamp &timeStamp)
void nextHeartbeat (const Message &, const UtcTimeStamp &timeStamp)
void nextTestRequest (const Message &, const UtcTimeStamp &timeStamp)
void nextLogout (const Message &, const UtcTimeStamp &timeStamp)
void nextReject (const Message &, const UtcTimeStamp &timeStamp)
void nextSequenceReset (const Message &, const UtcTimeStamp &timeStamp)
void nextResendRequest (const Message &, const UtcTimeStamp &timeStamp)
void generateLogon ()
void generateLogon (const Message &)
void generateResendRequest (const BeginString &, const MsgSeqNum &)
void generateSequenceReset (int, int)
void generateHeartbeat ()
void generateHeartbeat (const Message &)
void generateTestRequest (const std::string &)
void generateReject (const Message &, int err, int field=0)
void generateReject (const Message &, const std::string &)
void generateBusinessReject (const Message &, int err, int field=0)
void generateLogout (const std::string &text="")
void populateRejectReason (Message &, int field, const std::string &)
void populateRejectReason (Message &, const std::string &)
bool verify (const Message &msg, bool checkTooHigh=true, bool checkTooLow=true)
bool set (int s, const Message &m)
bool get (int s, Message &m) const

Static Private Member Functions

static bool addSession (Session &)
static void removeSession (Session &)

Private Attributes

Applicationm_application
SessionID m_sessionID
TimeRange m_sessionTime
TimeRange m_logonTime
std::string m_senderDefaultApplVerID
std::string m_targetDefaultApplVerID
bool m_sendRedundantResendRequests
bool m_checkCompId
bool m_checkLatency
int m_maxLatency
bool m_resetOnLogon
bool m_resetOnLogout
bool m_resetOnDisconnect
bool m_refreshOnLogon
bool m_millisecondsInTimeStamp
bool m_persistMessages
bool m_validateLengthAndChecksum
SessionState m_state
DataDictionaryProvider m_dataDictionaryProvider
MessageStoreFactorym_messageStoreFactory
LogFactorym_pLogFactory
Responderm_pResponder
Mutex m_mutex

Static Private Attributes

static Sessions s_sessions
static SessionIDs s_sessionIDs
static Sessions s_registered
static Mutex s_mutex

Detailed Description

Maintains the state and implements the logic of a FIX session.

Definition at line 45 of file Session.h.


Member Typedef Documentation

typedef std::set< SessionID > FIX::Session::SessionIDs [private]

Definition at line 219 of file Session.h.

typedef std::map< SessionID, Session* > FIX::Session::Sessions [private]

Definition at line 218 of file Session.h.


Constructor & Destructor Documentation

FIX::Session::Session ( Application application,
MessageStoreFactory messageStoreFactory,
const SessionID sessionID,
const DataDictionaryProvider dataDictionaryProvider,
const TimeRange sessionTime,
int  heartBtInt,
LogFactory pLogFactory 
)
FIX::Session::~Session ( ) [virtual]

Member Function Documentation

bool FIX::Session::addSession ( Session s) [static, private]

Definition at line 1466 of file Session.cpp.

References m_sessionID, s_mutex, s_sessionIDs, and s_sessions.

Referenced by Session().

{
  Locker locker( s_mutex );
  Sessions::iterator it = s_sessions.find( s.m_sessionID );
  if ( it == s_sessions.end() )
  {
    s_sessions[ s.m_sessionID ] = &s;
    s_sessionIDs.insert( s.m_sessionID );
    return true;
  }
  else
    return false;
}
bool FIX::Session::checkSessionTime ( const UtcTimeStamp timeStamp) [inline, private]

Definition at line 240 of file Session.h.

References FIX::SessionState::getCreationTime(), FIX::TimeRange::isInSameRange(), m_sessionTime, and m_state.

Referenced by next(), Session(), and setResponder().

  {
    UtcTimeStamp creationTime = m_state.getCreationTime();
    return m_sessionTime.isInSameRange( timeStamp, creationTime );
  }
void FIX::Session::doBadCompID ( const Message msg) [private]
void FIX::Session::doBadTime ( const Message msg) [private]
bool FIX::Session::doesSessionExist ( const SessionID sessionID) [static]

Definition at line 1397 of file Session.cpp.

References s_mutex, and s_sessions.

{
  Locker locker( s_mutex );
  return s_sessions.end() != s_sessions.find( sessionID );
}
bool FIX::Session::doPossDup ( const Message msg) [private]

Definition at line 1065 of file Session.cpp.

References generateLogout(), generateReject(), FIX::FieldMap::getField(), FIX::FieldMap::getFieldIfSet(), FIX::Message::getHeader(), FIX::FIELD::MsgType, FIX::MsgType_SequenceReset, FIX::FIELD::OrigSendingTime, FIX::FIELD::SendingTime, FIX::SessionRejectReason_REQUIRED_TAG_MISSING, and FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM.

Referenced by doTargetTooLow().

{
  const Header & header = msg.getHeader();
  OrigSendingTime origSendingTime;
  SendingTime sendingTime;
  MsgType msgType;

  header.getField( msgType );
  header.getField( sendingTime );

  if ( msgType != MsgType_SequenceReset )
  {
    if ( !header.getFieldIfSet( origSendingTime ) )
    {
      generateReject( msg, SessionRejectReason_REQUIRED_TAG_MISSING, origSendingTime.getField() );
      return false;
    }

    if ( origSendingTime > sendingTime )
    {
      generateReject( msg, SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM );
      generateLogout();
      return false;
    }
  }
  return true;
}
void FIX::Session::doTargetTooHigh ( const Message msg) [private]

Definition at line 1113 of file Session.cpp.

References FIX::FIELD::BeginString, FIX::IntConvertor::convert(), generateResendRequest(), getExpectedTargetNum(), FIX::FieldMap::getField(), FIX::Message::getHeader(), m_sendRedundantResendRequests, m_state, FIX::FIELD::MsgSeqNum, FIX::SessionState::onEvent(), FIX::SessionState::queue(), FIX::SessionState::resendRange(), and FIX::SessionState::resendRequested().

Referenced by nextLogon(), and verify().

{
  const Header & header = msg.getHeader();
  BeginString beginString;
  MsgSeqNum msgSeqNum;
  header.getField( beginString );
  header.getField( msgSeqNum );

  m_state.onEvent( "MsgSeqNum too high, expecting "
                   + IntConvertor::convert( getExpectedTargetNum() )
                   + " but received "
                   + IntConvertor::convert( msgSeqNum ) );

  m_state.queue( msgSeqNum, msg );

  if( m_state.resendRequested() )
  {
    SessionState::ResendRange range = m_state.resendRange();

    if( !m_sendRedundantResendRequests && msgSeqNum >= range.first )
    {
          m_state.onEvent ("Already sent ResendRequest FROM: " +
                           IntConvertor::convert (range.first) + " TO: " +
                           IntConvertor::convert (range.second) +
                           ".  Not sending another.");
          return;
    }
  }

  generateResendRequest( beginString, msgSeqNum );
}
bool FIX::Session::doTargetTooLow ( const Message msg) [private]

Definition at line 1093 of file Session.cpp.

References doPossDup(), generateLogout(), getExpectedTargetNum(), FIX::FieldMap::getField(), FIX::FieldMap::getFieldIfSet(), FIX::Message::getHeader(), FIX::FIELD::MsgSeqNum, and FIX::FIELD::PossDupFlag.

Referenced by verify().

{
  const Header & header = msg.getHeader();
  PossDupFlag possDupFlag(false);
  MsgSeqNum msgSeqNum;
  header.getFieldIfSet(possDupFlag);
  header.getField( msgSeqNum );

  if ( !possDupFlag )
  {
    std::stringstream stream;
    stream << "MsgSeqNum too low, expecting " << getExpectedTargetNum()
           << " but received " << msgSeqNum;
    generateLogout( stream.str() );
    throw std::logic_error( stream.str() );
  }

  return doPossDup( msg );
}
void FIX::Session::fill ( Header header) [private]
void FIX::Session::fromCallback ( const MsgType &  msgType,
const Message msg,
const SessionID sessionID 
) [private]
void FIX::Session::generateBusinessReject ( const Message message,
int  err,
int  field = 0 
) [private]

Definition at line 842 of file Session.cpp.

References FIX::FIELD::BusinessRejectReason, FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE, FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT, FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING, FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT, FIX::BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME, FIX::BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT, FIX::BusinessRejectReason_NOT_AUTHORIZED, FIX::BusinessRejectReason_NOT_AUTHORIZED_TEXT, FIX::BusinessRejectReason_OTHER, FIX::BusinessRejectReason_OTHER_TEXT, FIX::BusinessRejectReason_UNKNOWN_ID, FIX::BusinessRejectReason_UNKNOWN_ID_TEXT, FIX::BusinessRejectReason_UNKNOWN_MESSAGE_TYPE, FIX::BusinessRejectReason_UNKNOWN_SECURITY, FIX::BusinessRejectReason_UNKNOWN_SECURITY_TEXT, FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT, FIX::IntConvertor::convert(), FIX::FIELD::DefaultApplVerID, fill(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::SessionState::incrNextTargetMsgSeqNum(), FIX::SessionID::isFIXT(), m_senderDefaultApplVerID, m_sessionID, m_state, FIX::FIELD::MsgSeqNum, FIX::FIELD::MsgType, FIX::MsgType_BusinessMessageReject, FIX::SessionState::onEvent(), populateRejectReason(), FIX::FIELD::RefMsgType, FIX::FIELD::RefSeqNum, sendRaw(), and FIX::FieldMap::setField().

Referenced by next().

{
  Message reject;
  reject.getHeader().setField( MsgType( MsgType_BusinessMessageReject ) );
  if( m_sessionID.isFIXT() )
    reject.setField( DefaultApplVerID(m_senderDefaultApplVerID) );  
  fill( reject.getHeader() );
  MsgType msgType;
  MsgSeqNum msgSeqNum;
  message.getHeader().getField( msgType );
  message.getHeader().getField( msgSeqNum );
  reject.setField( RefMsgType( msgType ) );
  reject.setField( RefSeqNum( msgSeqNum ) );
  reject.setField( BusinessRejectReason( err ) );
  m_state.incrNextTargetMsgSeqNum();

  const char* reason = 0;
  switch ( err )
  {
    case BusinessRejectReason_OTHER:
    reason = BusinessRejectReason_OTHER_TEXT;
    break;
    case BusinessRejectReason_UNKNOWN_ID:
    reason = BusinessRejectReason_UNKNOWN_ID_TEXT;
    break;
    case BusinessRejectReason_UNKNOWN_SECURITY:
    reason = BusinessRejectReason_UNKNOWN_SECURITY_TEXT;
    break;
    case BusinessRejectReason_UNKNOWN_MESSAGE_TYPE:
    reason = BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT;
    break;
    case BusinessRejectReason_APPLICATION_NOT_AVAILABLE:
    reason = BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT;
    break;
    case BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING:
    reason = BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT;
    break;
    case BusinessRejectReason_NOT_AUTHORIZED:
    reason = BusinessRejectReason_NOT_AUTHORIZED_TEXT;
    break;
    case BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME:
    reason = BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT;
    break;
  };

  if ( reason && field )
  {
    populateRejectReason( reject, field, reason );
    m_state.onEvent( "Message " + msgSeqNum.getString() + " Rejected: "
                     + reason + ":" + IntConvertor::convert( field ) );
  }
  else if ( reason )
  {
    populateRejectReason( reject, reason );
    m_state.onEvent( "Message " + msgSeqNum.getString()
         + " Rejected: " + reason );
  }
  else
    m_state.onEvent( "Message " + msgSeqNum.getString() + " Rejected" );

  sendRaw( reject );
}
void FIX::Session::generateHeartbeat ( ) [private]

Definition at line 685 of file Session.cpp.

References fill(), FIX::Message::getHeader(), FIX::FIELD::MsgType, sendRaw(), and FIX::FieldMap::setField().

Referenced by next(), and nextTestRequest().

{
  Message heartbeat;
  heartbeat.getHeader().setField( MsgType( "0" ) );
  fill( heartbeat.getHeader() );
  sendRaw( heartbeat );
}
void FIX::Session::generateHeartbeat ( const Message testRequest) [private]

Definition at line 693 of file Session.cpp.

References fill(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::FIELD::MsgType, sendRaw(), FIX::FieldMap::setField(), and FIX::FIELD::TestReqID.

{
  Message heartbeat;
  heartbeat.getHeader().setField( MsgType( "0" ) );
  fill( heartbeat.getHeader() );
  try
  {
    TestReqID testReqID;
    testRequest.getField( testReqID );
    heartbeat.setField( testReqID );
  }
  catch ( FieldNotFound& ) {}

  sendRaw( heartbeat );
}
void FIX::Session::generateLogon ( ) [private]
void FIX::Session::generateLogon ( const Message aLogon) [private]

Definition at line 625 of file Session.cpp.

References FIX::FIELD::DefaultApplVerID, FIX::FIELD::EncryptMethod, fill(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::FIELD::HeartBtInt, FIX::SessionID::isFIXT(), logon(), m_senderDefaultApplVerID, m_sessionID, m_state, FIX::FIELD::MsgType, FIX::SessionState::receivedReset(), FIX::FIELD::ResetSeqNumFlag, sendRaw(), FIX::SessionState::sentLogon(), and FIX::FieldMap::setField().

{
  Message logon;
  EncryptMethod encryptMethod;
  HeartBtInt heartBtInt;
  logon.setField( EncryptMethod( 0 ) );
  if( m_sessionID.isFIXT() )
    logon.setField( DefaultApplVerID(m_senderDefaultApplVerID) );  
  if( m_state.receivedReset() )
    logon.setField( ResetSeqNumFlag(true) );
  aLogon.getField( heartBtInt );
  logon.getHeader().setField( MsgType( "A" ) );
  logon.setField( heartBtInt );
  fill( logon.getHeader() );
  sendRaw( logon );
  m_state.sentLogon( true );
}
void FIX::Session::generateLogout ( const std::string &  text = "") [private]

Definition at line 905 of file Session.cpp.

References fill(), FIX::Message::getHeader(), logout(), m_state, FIX::FIELD::MsgType, FIX::MsgType_Logout, sendRaw(), FIX::SessionState::sentLogout(), FIX::FieldMap::setField(), and FIX::FIELD::Text.

Referenced by doBadCompID(), doBadTime(), doPossDup(), doTargetTooLow(), next(), nextLogout(), and reset().

{
  Message logout;
  logout.getHeader().setField( MsgType( MsgType_Logout ) );
  fill( logout.getHeader() );
  if ( text.length() )
    logout.setField( Text( text ) );
  sendRaw( logout );
  m_state.sentLogout( true );
}
void FIX::Session::generateReject ( const Message message,
int  err,
int  field = 0 
) [private]

Definition at line 720 of file Session.cpp.

References FIX::BeginString_FIX42, FIX::IntConvertor::convert(), fill(), FIX::SessionID::getBeginString(), getExpectedTargetNum(), FIX::FieldMap::getField(), FIX::FieldMap::getFieldIfSet(), FIX::Message::getHeader(), FIX::SessionState::incrNextTargetMsgSeqNum(), m_sessionID, m_state, FIX::FIELD::MsgSeqNum, FIX::FIELD::MsgType, FIX::MsgType_Logon, FIX::MsgType_SequenceReset, FIX::SessionState::onEvent(), populateRejectReason(), FIX::SessionState::receivedLogon(), FIX::FIELD::RefMsgType, FIX::FIELD::RefSeqNum, FIX::Message::reverseRoute(), sendRaw(), FIX::FIELD::SessionRejectReason, FIX::SessionRejectReason_COMPID_PROBLEM, FIX::SessionRejectReason_COMPID_PROBLEM_TEXT, FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE, FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT, FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP, FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT, FIX::SessionRejectReason_INVALID_MSGTYPE, FIX::SessionRejectReason_INVALID_MSGTYPE_TEXT, FIX::SessionRejectReason_INVALID_TAG_NUMBER, FIX::SessionRejectReason_INVALID_TAG_NUMBER_TEXT, FIX::SessionRejectReason_REQUIRED_TAG_MISSING, FIX::SessionRejectReason_REQUIRED_TAG_MISSING_TEXT, FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM, FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT, FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE, FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT, FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE, FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT, FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER, FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT, FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE, FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT, FIX::SessionRejectReason_VALUE_IS_INCORRECT, FIX::SessionRejectReason_VALUE_IS_INCORRECT_TEXT, and FIX::FieldMap::setField().

Referenced by doBadCompID(), doBadTime(), doPossDup(), next(), and nextSequenceReset().

{
  std::string beginString = m_sessionID.getBeginString();

  Message reject;
  reject.getHeader().setField( MsgType( "3" ) );
  reject.reverseRoute( message.getHeader() );
  fill( reject.getHeader() );

  MsgSeqNum msgSeqNum;
  MsgType msgType;

  message.getHeader().getField( msgType );
  if( message.getHeader().getFieldIfSet( msgSeqNum ) )
  {
    if( msgSeqNum.getString() != "" )
      reject.setField( RefSeqNum( msgSeqNum ) );
  }

  if ( beginString >= FIX::BeginString_FIX42 )
  {
    if( msgType.getString() != "" )
      reject.setField( RefMsgType( msgType ) );
    if ( (beginString == FIX::BeginString_FIX42
          && err <= SessionRejectReason_INVALID_MSGTYPE)
          || beginString > FIX::BeginString_FIX42 )
    {
      reject.setField( SessionRejectReason( err ) );
    }
  }
  if ( msgType != MsgType_Logon && msgType != MsgType_SequenceReset
       && msgSeqNum == getExpectedTargetNum() )
  { m_state.incrNextTargetMsgSeqNum(); }

  const char* reason = 0;
  switch ( err )
  {
    case SessionRejectReason_INVALID_TAG_NUMBER:
    reason = SessionRejectReason_INVALID_TAG_NUMBER_TEXT;
    break;
    case SessionRejectReason_REQUIRED_TAG_MISSING:
    reason = SessionRejectReason_REQUIRED_TAG_MISSING_TEXT;
    break;
    case SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE:
    reason = SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT;
    break;
    case SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE:
    reason = SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT;
    break;
    case SessionRejectReason_VALUE_IS_INCORRECT:
    reason = SessionRejectReason_VALUE_IS_INCORRECT_TEXT;
    break;
    case SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE:
    reason = SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT;
    break;
    case SessionRejectReason_COMPID_PROBLEM:
    reason = SessionRejectReason_COMPID_PROBLEM_TEXT;
    break;
    case SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM:
    reason = SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT;
    break;
    case SessionRejectReason_INVALID_MSGTYPE:
    reason = SessionRejectReason_INVALID_MSGTYPE_TEXT;
    break;
    case SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE:
    reason = SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT;
    break;
    case SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER:
    reason = SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT;
    break;
    case SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP:
    reason = SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT;
  };

  if ( reason && ( field || err == SessionRejectReason_INVALID_TAG_NUMBER ) )
  {
    populateRejectReason( reject, field, reason );
    m_state.onEvent( "Message " + msgSeqNum.getString() + " Rejected: "
                     + reason + ":" + IntConvertor::convert( field ) );
  }
  else if ( reason )
  {
    populateRejectReason( reject, reason );
    m_state.onEvent( "Message " + msgSeqNum.getString()
         + " Rejected: " + reason );
  }
  else
    m_state.onEvent( "Message " + msgSeqNum.getString() + " Rejected" );

  if ( !m_state.receivedLogon() )
    throw std::runtime_error( "Tried to send a reject while not logged on" );

  sendRaw( reject );
}
void FIX::Session::generateReject ( const Message message,
const std::string &  str 
) [private]

Definition at line 815 of file Session.cpp.

References FIX::BeginString_FIX42, fill(), FIX::SessionID::getBeginString(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::SessionState::incrNextTargetMsgSeqNum(), m_sessionID, m_state, FIX::FIELD::MsgSeqNum, FIX::FIELD::MsgType, FIX::MsgType_Logon, FIX::MsgType_SequenceReset, FIX::SessionState::onEvent(), FIX::FIELD::RefMsgType, FIX::FIELD::RefSeqNum, FIX::Message::reverseRoute(), sendRaw(), FIX::FieldMap::setField(), and FIX::FIELD::Text.

{
  std::string beginString = m_sessionID.getBeginString();

  Message reject;
  reject.getHeader().setField( MsgType( "3" ) );
  reject.reverseRoute( message.getHeader() );
  fill( reject.getHeader() );

  MsgType msgType;
  MsgSeqNum msgSeqNum;

  message.getHeader().getField( msgType );
  message.getHeader().getField( msgSeqNum );
  if ( beginString >= FIX::BeginString_FIX42 )
    reject.setField( RefMsgType( msgType ) );
  reject.setField( RefSeqNum( msgSeqNum ) );

  if ( msgType != MsgType_Logon && msgType != MsgType_SequenceReset )
    m_state.incrNextTargetMsgSeqNum();

  reject.setField( Text( str ) );
  sendRaw( reject );
  m_state.onEvent( "Message " + msgSeqNum.getString()
                   + " Rejected: " + str );
}
void FIX::Session::generateResendRequest ( const BeginString &  beginString,
const MsgSeqNum &  msgSeqNum 
) [private]

Definition at line 643 of file Session.cpp.

References FIX::FIELD::BeginSeqNo, FIX::BeginString_FIX41, FIX::BeginString_FIX42, FIX::IntConvertor::convert(), FIX::FIELD::EndSeqNo, fill(), getExpectedTargetNum(), FIX::Message::getHeader(), m_state, FIX::FIELD::MsgType, FIX::SessionState::onEvent(), FIX::SessionState::resendRange(), sendRaw(), and FIX::FieldMap::setField().

Referenced by doTargetTooHigh().

{
  Message resendRequest;
  BeginSeqNo beginSeqNo( ( int ) getExpectedTargetNum() );
  EndSeqNo endSeqNo( msgSeqNum - 1 );
  if ( beginString >= FIX::BeginString_FIX42 )
    endSeqNo = 0;
  else if( beginString <= FIX::BeginString_FIX41 )
    endSeqNo = 999999;
  resendRequest.getHeader().setField( MsgType( "2" ) );
  resendRequest.setField( beginSeqNo );
  resendRequest.setField( endSeqNo );
  fill( resendRequest.getHeader() );
  sendRaw( resendRequest );

  m_state.onEvent( "Sent ResendRequest FROM: "
                   + IntConvertor::convert( beginSeqNo ) +
                   " TO: " + IntConvertor::convert( endSeqNo ) );

  m_state.resendRange( beginSeqNo, msgSeqNum - 1 );
}
void FIX::Session::generateSequenceReset ( int  beginSeqNo,
int  endSeqNo 
) [private]

Definition at line 666 of file Session.cpp.

References FIX::IntConvertor::convert(), FIX::FIELD::GapFillFlag, FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::FIELD::MsgSeqNum, FIX::FIELD::MsgType, FIX::FIELD::NewSeqNo, FIX::FIELD::PossDupFlag, FIX::FIELD::SendingTime, and FIX::FieldMap::setField().

Referenced by nextResendRequest().

{
  Message sequenceReset;
  NewSeqNo newSeqNo( endSeqNo );
  sequenceReset.getHeader().setField( MsgType( "4" ) );
  sequenceReset.getHeader().setField( PossDupFlag( true ) );
  sequenceReset.setField( newSeqNo );
  fill( sequenceReset.getHeader() );

  SendingTime sendingTime;
  sequenceReset.getHeader().getField( sendingTime );
  insertOrigSendingTime( sequenceReset.getHeader(), sendingTime );
  sequenceReset.getHeader().setField( MsgSeqNum( beginSeqNo ) );
  sequenceReset.setField( GapFillFlag( true ) );
  sendRaw( sequenceReset, beginSeqNo );
  m_state.onEvent( "Sent SequenceReset TO: "
                   + IntConvertor::convert( newSeqNo ) );
}
void FIX::Session::generateTestRequest ( const std::string &  id) [private]

Definition at line 709 of file Session.cpp.

References fill(), FIX::Message::getHeader(), FIX::FIELD::MsgType, sendRaw(), FIX::FieldMap::setField(), and FIX::FIELD::TestReqID.

Referenced by next().

{
  Message testRequest;
  testRequest.getHeader().setField( MsgType( "1" ) );
  fill( testRequest.getHeader() );
  TestReqID testReqID( id );
  testRequest.setField( testReqID );

  sendRaw( testRequest );
}
bool FIX::Session::get ( int  s,
Message m 
) const [private]
bool FIX::Session::getCheckCompId ( ) [inline]

Definition at line 137 of file Session.h.

References m_checkCompId.

Referenced by FIX::HttpConnection::processSession().

    { return m_checkCompId; }
bool FIX::Session::getCheckLatency ( ) [inline]

Definition at line 142 of file Session.h.

References m_checkLatency.

Referenced by FIX::HttpConnection::processSession().

    { return m_checkLatency; }

Definition at line 79 of file Session.h.

References m_dataDictionaryProvider.

Log* FIX::Session::getLog ( ) [inline]

Definition at line 117 of file Session.h.

References m_logonTime.

    { return m_logonTime; }

Definition at line 152 of file Session.h.

References FIX::SessionState::logonTimeout(), and m_state.

Referenced by FIX::HttpConnection::processSession().

    { return m_state.logonTimeout(); }

Definition at line 157 of file Session.h.

References FIX::SessionState::logoutTimeout(), and m_state.

Referenced by FIX::HttpConnection::processSession().

    { return m_state.logoutTimeout(); }
int FIX::Session::getMaxLatency ( ) [inline]

Definition at line 147 of file Session.h.

References m_maxLatency.

Referenced by FIX::HttpConnection::processSession().

    { return m_maxLatency; }

Definition at line 182 of file Session.h.

References m_millisecondsInTimeStamp.

Referenced by FIX::HttpConnection::processSession().

Definition at line 187 of file Session.h.

References m_persistMessages.

Referenced by FIX::HttpConnection::processSession().

    { return m_persistMessages; }

Definition at line 177 of file Session.h.

References m_refreshOnLogon.

Referenced by FIX::HttpConnection::processSession().

    { return m_refreshOnLogon; }

Definition at line 172 of file Session.h.

References m_resetOnDisconnect.

Referenced by FIX::HttpConnection::processSession().

    { return m_resetOnDisconnect; }
bool FIX::Session::getResetOnLogon ( ) [inline]

Definition at line 162 of file Session.h.

References m_resetOnLogon.

Referenced by FIX::HttpConnection::processSession().

    { return m_resetOnLogon; }
bool FIX::Session::getResetOnLogout ( ) [inline]

Definition at line 167 of file Session.h.

References m_resetOnLogout.

Referenced by FIX::HttpConnection::processSession().

    { return m_resetOnLogout; }
const std::string& FIX::Session::getSenderDefaultApplVerID ( ) [inline]

Definition at line 122 of file Session.h.

References m_senderDefaultApplVerID.

Referenced by FIX::MessageCracker::crack().

Definition at line 132 of file Session.h.

References m_sendRedundantResendRequests.

Referenced by FIX::HttpConnection::processSession().

const SessionID& FIX::Session::getSessionID ( ) const [inline]
std::set< SessionID > FIX::Session::getSessions ( ) [static]
const MessageStore* FIX::Session::getStore ( ) [inline]

Definition at line 215 of file Session.h.

References m_state.

{ return &m_state; }
const std::string& FIX::Session::getTargetDefaultApplVerID ( ) [inline]

Definition at line 127 of file Session.h.

References m_targetDefaultApplVerID.

Definition at line 192 of file Session.h.

References m_validateLengthAndChecksum.

void FIX::Session::insertOrigSendingTime ( Header header,
const UtcTimeStamp when = UtcTimeStamp () 
) [private]

Definition at line 103 of file Session.cpp.

References FIX::BeginString_FIX42, FIX::BeginString_FIXT11, FIX::SessionID::getBeginString(), m_millisecondsInTimeStamp, m_sessionID, FIX::FIELD::OrigSendingTime, and FIX::FieldMap::setField().

Referenced by resend().

{
  bool showMilliseconds = false;
  if( m_sessionID.getBeginString() == BeginString_FIXT11 )
    showMilliseconds = true;
  else
    showMilliseconds = m_sessionID.getBeginString() >= BeginString_FIX42;

  header.setField( OrigSendingTime(when, showMilliseconds && m_millisecondsInTimeStamp) );
}
void FIX::Session::insertSendingTime ( Header header) [private]

Definition at line 91 of file Session.cpp.

References FIX::BeginString_FIX42, FIX::BeginString_FIXT11, FIX::SessionID::getBeginString(), m_millisecondsInTimeStamp, m_sessionID, FIX::FIELD::SendingTime, and FIX::FieldMap::setField().

Referenced by fill(), and resend().

{
  UtcTimeStamp now;
  bool showMilliseconds = false;
  if( m_sessionID.getBeginString() == BeginString_FIXT11 )
    showMilliseconds = true;
  else
    showMilliseconds = m_sessionID.getBeginString() >= BeginString_FIX42;

  header.setField( SendingTime(now, showMilliseconds && m_millisecondsInTimeStamp) );
}
bool FIX::Session::isAcceptor ( ) [inline]

Definition at line 114 of file Session.h.

References FIX::SessionState::initiate(), and m_state.

    { return !m_state.initiate(); }
bool FIX::Session::isCorrectCompID ( const SenderCompID &  senderCompID,
const TargetCompID &  targetCompID 
) [inline, private]

Definition at line 249 of file Session.h.

References FIX::SessionID::getSenderCompID(), FIX::SessionID::getTargetCompID(), m_checkCompId, and m_sessionID.

Referenced by verify().

  {
    if( !m_checkCompId ) return true;

    return
      m_sessionID.getSenderCompID().getValue() == targetCompID.getValue()
      && m_sessionID.getTargetCompID().getValue() == senderCompID.getValue();
  }
bool FIX::Session::isEnabled ( ) [inline]
bool FIX::Session::isGoodTime ( const SendingTime &  sendingTime) [inline, private]

Definition at line 234 of file Session.h.

References m_checkLatency, and m_maxLatency.

Referenced by verify().

  {
    if ( !m_checkLatency ) return true;
    UtcTimeStamp now;
    return labs( now - sendingTime ) <= m_maxLatency;
  }
bool FIX::Session::isInitiator ( ) [inline]
bool FIX::Session::isLoggedOn ( ) [inline]
bool FIX::Session::isLogonTime ( const UtcTimeStamp time) [inline]

Definition at line 110 of file Session.h.

References FIX::TimeRange::isInRange(), and m_logonTime.

Referenced by next(), and nextLogon().

    { return m_logonTime.isInRange(time); }
bool FIX::Session::isSessionRegistered ( const SessionID sessionID) [static]

Definition at line 1438 of file Session.cpp.

References s_mutex, and s_registered.

Referenced by FIX::SocketConnection::isValidSession(), registerSession(), and FIX::ThreadedSocketConnection::setSession().

{
  Locker locker( s_mutex );
  return s_registered.end() != s_registered.find( sessionID );
}
bool FIX::Session::isSessionTime ( const UtcTimeStamp time) [inline]
bool FIX::Session::isTargetTooHigh ( const MsgSeqNum &  msgSeqNum) [inline, private]

Definition at line 245 of file Session.h.

References FIX::SessionState::getNextTargetMsgSeqNum(), and m_state.

Referenced by nextLogon(), nextResendRequest(), and verify().

  { return msgSeqNum > ( m_state.getNextTargetMsgSeqNum() ); }
bool FIX::Session::isTargetTooLow ( const MsgSeqNum &  msgSeqNum) [inline, private]

Definition at line 247 of file Session.h.

References FIX::SessionState::getNextTargetMsgSeqNum(), and m_state.

Referenced by nextResendRequest(), and verify().

  { return msgSeqNum < ( m_state.getNextTargetMsgSeqNum() ); }
void FIX::Session::logon ( ) [inline]
void FIX::Session::logout ( const std::string &  reason = "") [inline]
Session * FIX::Session::lookupSession ( const SessionID sessionID) [static]
Session * FIX::Session::lookupSession ( const std::string &  string,
bool  reverse = false 
) [static]

Definition at line 1413 of file Session.cpp.

References FIX::FIELD::BeginString, FIELD_GET_REF, FIX::Message::getHeader(), lookupSession(), FIX::FIELD::SenderCompID, FIX::Message::setStringHeader(), and FIX::FIELD::TargetCompID.

{
  Message message;
  if ( !message.setStringHeader( string ) )
    return 0;

  try
  {
    const Header& header = message.getHeader();
    const BeginString& beginString = FIELD_GET_REF( header, BeginString );
    const SenderCompID& senderCompID = FIELD_GET_REF( header, SenderCompID );
    const TargetCompID& targetCompID = FIELD_GET_REF( header, TargetCompID );

    if ( reverse )
    {
      return lookupSession( SessionID( beginString, SenderCompID( targetCompID ),
                                     TargetCompID( senderCompID ) ) );
    }

    return lookupSession( SessionID( beginString, senderCompID,
                          targetCompID ) );
  }
  catch ( FieldNotFound& ) { return 0; }
}
void FIX::Session::next ( const UtcTimeStamp timeStamp)

Definition at line 130 of file Session.cpp.

References FIX::SessionState::alreadySentLogon(), checkSessionTime(), disconnect(), generateHeartbeat(), generateLogon(), generateLogout(), generateTestRequest(), FIX::SessionState::heartBtInt(), isEnabled(), isLoggedOn(), isLogonTime(), FIX::SessionState::logonTimedOut(), FIX::SessionState::logoutReason(), FIX::SessionState::logoutTimedOut(), m_state, FIX::SessionState::needHeartbeat(), FIX::SessionState::needTestRequest(), FIX::SessionState::onEvent(), FIX::SessionState::receivedLogon(), reset(), FIX::SessionState::sentLogout(), FIX::SessionState::shouldSendLogon(), FIX::SessionState::testRequest(), FIX::SessionState::timedOut(), and FIX::SessionState::withinHeartBeat().

{
  try
  {
    if ( !checkSessionTime(timeStamp) )
      { reset(); return; }

    if( !isEnabled() || !isLogonTime(timeStamp) )
    {
      if( isLoggedOn() )
      {
        if( !m_state.sentLogout() )
        {
          m_state.onEvent( "Initiated logout request" );
          generateLogout( m_state.logoutReason() );
        }
      }
      else
        return;
    }

    if ( !m_state.receivedLogon() )
    {
      if ( m_state.shouldSendLogon() && isLogonTime(timeStamp) )
      {
        generateLogon();
        m_state.onEvent( "Initiated logon request" );
      }
      else if ( m_state.alreadySentLogon() && m_state.logonTimedOut() )
      {
        m_state.onEvent( "Timed out waiting for logon response" );
        disconnect();
      }
      return ;
    }

    if ( m_state.heartBtInt() == 0 ) return ;

    if ( m_state.logoutTimedOut() )
    {
      m_state.onEvent( "Timed out waiting for logout response" );
      disconnect();
    }

    if ( m_state.withinHeartBeat() ) return ;

    if ( m_state.timedOut() )
    {
      m_state.onEvent( "Timed out waiting for heartbeat" );
      disconnect();
    }
    else
    {
      if ( m_state.needTestRequest() )
      {
        generateTestRequest( "TEST" );
        m_state.testRequest( m_state.testRequest() + 1 );
        m_state.onEvent( "Sent test request TEST" );
      }
      else if ( m_state.needHeartbeat() )
      {
        generateHeartbeat();
      }
    }
  }
  catch ( FIX::IOException& e )
  {
    m_state.onEvent( e.what() );
    disconnect();
  }
}
void FIX::Session::next ( const std::string &  msg,
const UtcTimeStamp timeStamp,
bool  queued = false 
)

Definition at line 1174 of file Session.cpp.

References disconnect(), FIX::DataDictionaryProvider::getApplicationDataDictionary(), FIX::SessionID::getBeginString(), FIX::DataDictionaryProvider::getSessionDataDictionary(), FIX::identifyType(), FIX::SessionID::isFIXT(), m_dataDictionaryProvider, m_senderDefaultApplVerID, m_sessionID, m_state, m_validateLengthAndChecksum, FIX::MsgType_Logon, next(), FIX::SessionState::onEvent(), and FIX::SessionState::onIncoming().

{
  try
  {
    m_state.onIncoming( msg );
    const DataDictionary& sessionDD = 
      m_dataDictionaryProvider.getSessionDataDictionary(m_sessionID.getBeginString());
    if( m_sessionID.isFIXT() )
    {
      const DataDictionary& applicationDD =
        m_dataDictionaryProvider.getApplicationDataDictionary(m_senderDefaultApplVerID);
      next( Message( msg, sessionDD, applicationDD, m_validateLengthAndChecksum ), timeStamp, queued );
    }
    else
    {
      next( Message( msg, sessionDD, m_validateLengthAndChecksum ), timeStamp, queued );
    }
  }
  catch( InvalidMessage& e )
  {
    m_state.onEvent( e.what() );

    try
    {
      if( identifyType(msg) == MsgType_Logon )
      {
        m_state.onEvent( "Logon message is not valid" );
        disconnect();
      }
    } catch( MessageParseError& ) {}
    throw e;
  }
}
void FIX::Session::next ( const Message message,
const UtcTimeStamp timeStamp,
bool  queued = false 
)

Definition at line 1208 of file Session.cpp.

References FIX::FIELD::ApplVerID, FIX::FIELD::BeginString, FIX::BeginString_FIX42, FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING, FIX::BusinessRejectReason_UNKNOWN_MESSAGE_TYPE, checkSessionTime(), FIX::FIELD::DefaultApplVerID, disconnect(), FIX::FieldNotFound::field, FIX::InvalidTagNumber::field, FIX::RequiredTagMissing::field, FIX::TagNotDefinedForMessage::field, FIX::NoTagValue::field, FIX::IncorrectTagValue::field, FIX::IncorrectDataFormat::field, FIX::TagOutOfOrder::field, FIX::RepeatedTag::field, FIX::RepeatingGroupCountMismatch::field, FIELD_GET_REF, FIELD_THROW_IF_NOT_FOUND, generateBusinessReject(), generateLogout(), generateReject(), FIX::DataDictionaryProvider::getApplicationDataDictionary(), FIX::SessionID::getBeginString(), FIX::FieldMap::getField(), FIX::FieldMap::getFieldIfSet(), FIX::Message::getHeader(), FIX::DataDictionaryProvider::getSessionDataDictionary(), FIX::SessionState::incrNextTargetMsgSeqNum(), FIX::Message::isApp(), FIX::SessionID::isFIXT(), isLoggedOn(), LOGEX, m_dataDictionaryProvider, m_sessionID, m_state, m_targetDefaultApplVerID, FIX::FIELD::MsgType, FIX::MsgType_Heartbeat, FIX::MsgType_Logon, FIX::MsgType_Logout, FIX::MsgType_Reject, FIX::MsgType_ResendRequest, FIX::MsgType_SequenceReset, FIX::MsgType_TestRequest, next(), nextHeartbeat(), nextLogon(), nextLogout(), nextQueued(), nextReject(), nextResendRequest(), nextSequenceReset(), nextTestRequest(), FIX::SessionState::onEvent(), reset(), FIX::FIELD::SenderCompID, FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE, FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP, FIX::SessionRejectReason_INVALID_MSGTYPE, FIX::SessionRejectReason_INVALID_TAG_NUMBER, FIX::SessionRejectReason_REQUIRED_TAG_MISSING, FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE, FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE, FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER, FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE, FIX::SessionRejectReason_VALUE_IS_INCORRECT, setTargetDefaultApplVerID(), FIX::FIELD::TargetCompID, FIX::Message::toApplVerID(), FIX::DataDictionary::validate(), and verify().

{
  const Header& header = message.getHeader();

  try
  {
    if ( !checkSessionTime(timeStamp) )
      { reset(); return; }

    const MsgType& msgType = FIELD_GET_REF( header, MsgType );
    const BeginString& beginString = FIELD_GET_REF( header, BeginString );
    // make sure these fields are present
    FIELD_THROW_IF_NOT_FOUND( header, SenderCompID );
    FIELD_THROW_IF_NOT_FOUND( header, TargetCompID );

    if ( beginString != m_sessionID.getBeginString() )
      throw UnsupportedVersion();

    if( msgType == MsgType_Logon )
    {
      if( m_sessionID.isFIXT() )
      {
        const DefaultApplVerID& applVerID = FIELD_GET_REF( message, DefaultApplVerID );
        setTargetDefaultApplVerID(applVerID);
      }
      else
      {
        setTargetDefaultApplVerID(Message::toApplVerID(beginString));
      }
    }

    const DataDictionary& sessionDataDictionary = 
        m_dataDictionaryProvider.getSessionDataDictionary(m_sessionID.getBeginString());

    if( m_sessionID.isFIXT() && message.isApp() )
    {
      ApplVerID applVerID = m_targetDefaultApplVerID;
      header.getFieldIfSet(applVerID);
      const DataDictionary& applicationDataDictionary = 
        m_dataDictionaryProvider.getApplicationDataDictionary(applVerID);
      DataDictionary::validate( message, &sessionDataDictionary, &applicationDataDictionary );
    }
    else
    {
      sessionDataDictionary.validate( message );
    }

    if ( msgType == MsgType_Logon )
      nextLogon( message, timeStamp );
    else if ( msgType == MsgType_Heartbeat )
      nextHeartbeat( message, timeStamp );
    else if ( msgType == MsgType_TestRequest )
      nextTestRequest( message, timeStamp );
    else if ( msgType == MsgType_SequenceReset )
      nextSequenceReset( message, timeStamp );
    else if ( msgType == MsgType_Logout )
      nextLogout( message, timeStamp );
    else if ( msgType == MsgType_ResendRequest )
      nextResendRequest( message,timeStamp );
    else if ( msgType == MsgType_Reject )
      nextReject( message, timeStamp );
    else
    {
      if ( !verify( message ) ) return ;
      m_state.incrNextTargetMsgSeqNum();
    }
  }
  catch ( MessageParseError& e )
  { m_state.onEvent( e.what() ); }
  catch ( RequiredTagMissing & e )
  { LOGEX( generateReject( message, SessionRejectReason_REQUIRED_TAG_MISSING, e.field ) ); }
  catch ( FieldNotFound & e )
  {
    if( header.getField(FIELD::BeginString) >= FIX::BeginString_FIX42 && message.isApp() )
    {
      LOGEX( generateBusinessReject( message, BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING, e.field ) );
    }
    else
    {
      LOGEX( generateReject( message, SessionRejectReason_REQUIRED_TAG_MISSING, e.field ) );
      if ( header.getField(FIELD::MsgType) == MsgType_Logon )
      {
        m_state.onEvent( "Required field missing from logon" );
        disconnect();
      }
    }
  }
  catch ( InvalidTagNumber & e )
  { LOGEX( generateReject( message, SessionRejectReason_INVALID_TAG_NUMBER, e.field ) ); }
  catch ( NoTagValue & e )
  { LOGEX( generateReject( message, SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE, e.field ) ); }
  catch ( TagNotDefinedForMessage & e )
  { LOGEX( generateReject( message, SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE, e.field ) ); }
  catch ( InvalidMessageType& )
  { LOGEX( generateReject( message, SessionRejectReason_INVALID_MSGTYPE ) ); }
  catch ( UnsupportedMessageType& )
  {
    if ( header.getField(FIELD::BeginString) >= FIX::BeginString_FIX42 )
      { LOGEX( generateBusinessReject( message, BusinessRejectReason_UNKNOWN_MESSAGE_TYPE ) ); }
    else
      { LOGEX( generateReject( message, "Unsupported message type" ) ); }
  }
  catch ( TagOutOfOrder & e )
  { LOGEX( generateReject( message, SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER, e.field ) ); }
  catch ( IncorrectDataFormat & e )
  { LOGEX( generateReject( message, SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE, e.field ) ); }
  catch ( IncorrectTagValue & e )
  { LOGEX( generateReject( message, SessionRejectReason_VALUE_IS_INCORRECT, e.field ) ); }
  catch ( RepeatedTag & e )
  { LOGEX( generateReject( message, SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE, e.field ) ); }
  catch ( RepeatingGroupCountMismatch & e )
  { LOGEX( generateReject( message, SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP, e.field ) ); }
  catch ( InvalidMessage& e )
  { m_state.onEvent( e.what() ); }
  catch ( RejectLogon& e )
  {
    m_state.onEvent( e.what() );
    generateLogout( e.what() );
    disconnect();
  }
  catch ( UnsupportedVersion& )
  {
    if ( header.getField(FIELD::MsgType) == MsgType_Logout )
      nextLogout( message, timeStamp );
    else
    {
      generateLogout( "Incorrect BeginString" );
      m_state.incrNextTargetMsgSeqNum();
    }
  }
  catch ( IOException& e )
  {
    m_state.onEvent( e.what() );
    disconnect();
  }

  if( !queued )
    nextQueued( timeStamp );

  if( isLoggedOn() )
    next();
}
void FIX::Session::nextHeartbeat ( const Message heartbeat,
const UtcTimeStamp timeStamp 
) [private]

Definition at line 280 of file Session.cpp.

References FIX::SessionState::incrNextTargetMsgSeqNum(), m_state, nextQueued(), and verify().

Referenced by next().

{
  if ( !verify( heartbeat ) ) return ;
  m_state.incrNextTargetMsgSeqNum();
  nextQueued( timeStamp );
}
void FIX::Session::nextLogon ( const Message logon,
const UtcTimeStamp timeStamp 
) [private]

Definition at line 202 of file Session.cpp.

References disconnect(), doTargetTooHigh(), generateLogon(), FIX::FieldMap::getField(), FIX::FieldMap::getFieldIfSet(), FIX::Message::getHeader(), FIX::SessionState::heartBtInt(), FIX::SessionState::incrNextTargetMsgSeqNum(), FIX::SessionState::initiate(), isEnabled(), isLoggedOn(), isLogonTime(), isTargetTooHigh(), m_application, m_refreshOnLogon, m_resetOnLogon, m_sessionID, m_state, FIX::FIELD::MsgSeqNum, nextQueued(), FIX::SessionState::onEvent(), FIX::Application::onLogon(), FIX::SessionState::receivedLogon(), FIX::SessionState::receivedReset(), refresh(), FIX::SessionState::reset(), FIX::FIELD::ResetSeqNumFlag, FIX::FIELD::SenderCompID, FIX::SessionState::sentReset(), FIX::SessionState::shouldSendLogon(), FIX::FIELD::TargetCompID, and verify().

Referenced by next().

{
  SenderCompID senderCompID;
  TargetCompID targetCompID;
  logon.getHeader().getField( senderCompID );
  logon.getHeader().getField( targetCompID );

  if( m_refreshOnLogon )
    refresh();

  if( !isEnabled() )
  {
    m_state.onEvent( "Session is not enabled for logon" );
    disconnect();
    return;
  }

  if( !isLogonTime(timeStamp) )
  {
    m_state.onEvent( "Received logon outside of valid logon time" );
    disconnect();
    return;
  }

  ResetSeqNumFlag resetSeqNumFlag(false);
  logon.getFieldIfSet(resetSeqNumFlag);
  m_state.receivedReset( resetSeqNumFlag );

  if( m_state.receivedReset() )
  {
    m_state.onEvent( "Logon contains ResetSeqNumFlag=Y, reseting sequence numbers to 1" );
    if( !m_state.sentReset() ) m_state.reset();
  }

  if( m_state.shouldSendLogon() && !m_state.receivedReset() )
  {
    m_state.onEvent( "Received logon response before sending request" );
    disconnect();
    return;
  }

  if( !m_state.initiate() && m_resetOnLogon )
    m_state.reset();

  if( !verify( logon, false, true ) )
    return;
  m_state.receivedLogon( true );

  if ( !m_state.initiate() 
       || (m_state.receivedReset() && !m_state.sentReset()) )
  {
    logon.getFieldIfSet(m_state.heartBtInt());
    m_state.onEvent( "Received logon request" );
    generateLogon( logon );
    m_state.onEvent( "Responding to logon request" );
  }
  else
    m_state.onEvent( "Received logon response" );

  m_state.sentReset( false );
  m_state.receivedReset( false );

  MsgSeqNum msgSeqNum;
  logon.getHeader().getField( msgSeqNum );
  if ( isTargetTooHigh( msgSeqNum ) && !resetSeqNumFlag )
  {
    doTargetTooHigh( logon );
  }
  else
  {
    m_state.incrNextTargetMsgSeqNum();
    nextQueued( timeStamp );
  }

  if ( isLoggedOn() )
    m_application.onLogon( m_sessionID );
}
void FIX::Session::nextLogout ( const Message logout,
const UtcTimeStamp timeStamp 
) [private]

Definition at line 295 of file Session.cpp.

References disconnect(), generateLogout(), FIX::SessionState::incrNextTargetMsgSeqNum(), m_resetOnLogout, m_state, FIX::SessionState::onEvent(), FIX::SessionState::reset(), FIX::SessionState::sentLogout(), and verify().

Referenced by next().

{
  if ( !verify( logout, false, false ) ) return ;
  if ( !m_state.sentLogout() )
  {
    m_state.onEvent( "Received logout request" );
    generateLogout();
    m_state.onEvent( "Sending logout response" );
  }
  else
    m_state.onEvent( "Received logout response" );

  m_state.incrNextTargetMsgSeqNum();
  if ( m_resetOnLogout ) m_state.reset();
  disconnect();
}
void FIX::Session::nextQueued ( const UtcTimeStamp timeStamp) [private]

Definition at line 1145 of file Session.cpp.

References getExpectedTargetNum().

Referenced by next(), nextHeartbeat(), nextLogon(), nextReject(), and nextTestRequest().

{
  while ( nextQueued( getExpectedTargetNum(), timeStamp ) ) {}
}
bool FIX::Session::nextQueued ( int  num,
const UtcTimeStamp timeStamp 
) [private]

Definition at line 1150 of file Session.cpp.

References FIX::IntConvertor::convert(), FIX::FieldMap::getField(), FIX::Message::getHeader(), FIX::SessionState::incrNextTargetMsgSeqNum(), m_state, FIX::FIELD::MsgType, FIX::MsgType_Logon, FIX::MsgType_ResendRequest, next(), FIX::SessionState::onEvent(), and FIX::SessionState::retrieve().

{
  Message msg;
  MsgType msgType;

  if( m_state.retrieve( num, msg ) )
  {
    m_state.onEvent( "Processing QUEUED message: "
                     + IntConvertor::convert( num ) );
    msg.getHeader().getField( msgType );
    if( msgType == MsgType_Logon
        || msgType == MsgType_ResendRequest )
    {
      m_state.incrNextTargetMsgSeqNum();
    }
    else
    {
      next( msg, timeStamp, true );
    }
    return true;
  }
  return false;
}
void FIX::Session::nextReject ( const Message reject,
const UtcTimeStamp timeStamp 
) [private]

Definition at line 312 of file Session.cpp.

References FIX::SessionState::incrNextTargetMsgSeqNum(), m_state, nextQueued(), and verify().

Referenced by next().

{
  if ( !verify( reject, false, true ) ) return ;
  m_state.incrNextTargetMsgSeqNum();
  nextQueued( timeStamp );
}
void FIX::Session::nextResendRequest ( const Message resendRequest,
const UtcTimeStamp timeStamp 
) [private]

Definition at line 344 of file Session.cpp.

References FIX::FIELD::ApplVerID, FIX::FIELD::BeginSeqNo, FIX::BeginString_FIX42, FIX::IntConvertor::convert(), FIX::FIELD::EndSeqNo, generateSequenceReset(), FIX::SessionState::get(), FIX::DataDictionaryProvider::getApplicationDataDictionary(), FIX::SessionID::getBeginString(), getExpectedSenderNum(), FIX::FieldMap::getField(), FIX::FieldMap::getFieldIfSet(), FIX::Message::getHeader(), FIX::SessionState::getNextSenderMsgSeqNum(), FIX::DataDictionaryProvider::getSessionDataDictionary(), FIX::SessionState::incrNextTargetMsgSeqNum(), FIX::Message::isAdminMsgType(), FIX::SessionID::isFIXT(), isTargetTooHigh(), isTargetTooLow(), m_dataDictionaryProvider, m_mutex, m_persistMessages, m_senderDefaultApplVerID, m_sessionID, m_state, m_validateLengthAndChecksum, FIX::FIELD::MsgSeqNum, FIX::FIELD::MsgType, next(), FIX::SessionState::onEvent(), resend(), send(), FIX::Message::setStringHeader(), FIX::Message::toString(), and verify().

Referenced by next().

{
  if ( !verify( resendRequest, false, false ) ) return ;

  Locker l( m_mutex );

  BeginSeqNo beginSeqNo;
  EndSeqNo endSeqNo;
  resendRequest.getField( beginSeqNo );
  resendRequest.getField( endSeqNo );

  m_state.onEvent( "Received ResendRequest FROM: "
       + IntConvertor::convert( beginSeqNo ) +
                   " TO: " + IntConvertor::convert( endSeqNo ) );

  std::string beginString = m_sessionID.getBeginString();
  if ( (beginString >= FIX::BeginString_FIX42 && endSeqNo == 0) ||
       (beginString <= FIX::BeginString_FIX42 && endSeqNo == 999999) ||
       (endSeqNo >= getExpectedSenderNum()) )
  { endSeqNo = getExpectedSenderNum() - 1; }

  if ( !m_persistMessages )
  {
    endSeqNo = EndSeqNo(endSeqNo + 1);
    int next = m_state.getNextSenderMsgSeqNum();
    if( endSeqNo > next )
      endSeqNo = EndSeqNo(next);
    generateSequenceReset( beginSeqNo, endSeqNo );
    return;
  }

  std::vector < std::string > messages;
  m_state.get( beginSeqNo, endSeqNo, messages );

  std::vector < std::string > ::iterator i;
  MsgSeqNum msgSeqNum(0);
  MsgType msgType;
  int begin = 0;
  int current = beginSeqNo;
  std::string messageString;
  Message msg;

  for ( i = messages.begin(); i != messages.end(); ++i )
  {
    const DataDictionary& sessionDD = 
      m_dataDictionaryProvider.getSessionDataDictionary(m_sessionID.getBeginString());

    if( m_sessionID.isFIXT() )
    {
      msg.setStringHeader(*i);
      ApplVerID applVerID;
      if( !msg.getHeader().getFieldIfSet(applVerID) )
        applVerID = m_senderDefaultApplVerID;

      const DataDictionary& applicationDD =
        m_dataDictionaryProvider.getApplicationDataDictionary(applVerID);
      msg = Message( *i, sessionDD, applicationDD, m_validateLengthAndChecksum );
    }
    else
    {
      msg = Message( *i, sessionDD, m_validateLengthAndChecksum );
    }


    msg.getHeader().getField( msgSeqNum );
    msg.getHeader().getField( msgType );

    if( (current != msgSeqNum) && !begin )
      begin = current;

    if ( Message::isAdminMsgType( msgType ) )
    {
      if ( !begin ) begin = msgSeqNum;
    }
    else
    {
      if ( resend( msg ) )
      {
        if ( begin ) generateSequenceReset( begin, msgSeqNum );
        send( msg.toString(messageString) );
        m_state.onEvent( "Resending Message: "
                         + IntConvertor::convert( msgSeqNum ) );
        begin = 0;
      }
      else
      { if ( !begin ) begin = msgSeqNum; }
    }
    current = msgSeqNum + 1;
  }
  if ( begin )
  {
    generateSequenceReset( begin, msgSeqNum + 1 );
  }

  if ( endSeqNo > msgSeqNum )
  {
    endSeqNo = EndSeqNo(endSeqNo + 1);
    int next = m_state.getNextSenderMsgSeqNum();
    if( endSeqNo > next )
      endSeqNo = EndSeqNo(next);
    generateSequenceReset( beginSeqNo, endSeqNo );
  }

  resendRequest.getHeader().getField( msgSeqNum );
  if( !isTargetTooHigh(msgSeqNum) && !isTargetTooLow(msgSeqNum) )
    m_state.incrNextTargetMsgSeqNum();
}
void FIX::Session::nextSequenceReset ( const Message sequenceReset,
const UtcTimeStamp timeStamp 
) [private]

Definition at line 319 of file Session.cpp.

References FIX::IntConvertor::convert(), FIX::FIELD::GapFillFlag, generateReject(), getExpectedTargetNum(), FIX::FieldMap::getFieldIfSet(), m_state, FIX::FIELD::MsgSeqNum, FIX::FIELD::NewSeqNo, FIX::SessionState::onEvent(), FIX::SessionRejectReason_VALUE_IS_INCORRECT, FIX::SessionState::setNextTargetMsgSeqNum(), and verify().

Referenced by next().

{
  bool isGapFill = false;
  GapFillFlag gapFillFlag;
  if ( sequenceReset.getFieldIfSet( gapFillFlag ) )
  {
    isGapFill = gapFillFlag;
  }

  if ( !verify( sequenceReset, isGapFill, isGapFill ) ) return ;

  NewSeqNo newSeqNo;
  if ( sequenceReset.getFieldIfSet( newSeqNo ) )
  {
    m_state.onEvent( "Received SequenceReset FROM: "
                     + IntConvertor::convert( getExpectedTargetNum() ) +
                     " TO: " + IntConvertor::convert( newSeqNo ) );

    if ( newSeqNo > getExpectedTargetNum() )
      m_state.setNextTargetMsgSeqNum( MsgSeqNum( newSeqNo ) );
    else if ( newSeqNo < getExpectedTargetNum() )
      generateReject( sequenceReset, SessionRejectReason_VALUE_IS_INCORRECT );
  }
}
void FIX::Session::nextTestRequest ( const Message testRequest,
const UtcTimeStamp timeStamp 
) [private]

Definition at line 287 of file Session.cpp.

References generateHeartbeat(), FIX::SessionState::incrNextTargetMsgSeqNum(), m_state, nextQueued(), and verify().

Referenced by next().

{
  if ( !verify( testRequest ) ) return ;
  generateHeartbeat( testRequest );
  m_state.incrNextTargetMsgSeqNum();
  nextQueued( timeStamp );
}
int FIX::Session::numSessions ( ) [static]

Definition at line 1460 of file Session.cpp.

References s_mutex, and s_sessions.

Referenced by FIX::HttpConnection::processRoot().

{
  Locker locker( s_mutex );
  return s_sessions.size();
}
void FIX::Session::persist ( const Message message,
const std::string &  messageString 
) throw ( IOException ) [private]

Definition at line 592 of file Session.cpp.

References FIX::FIELD::MsgSeqNum.

Referenced by sendRaw().

{
  MsgSeqNum msgSeqNum;
  message.getHeader().getField( msgSeqNum );
  if( m_persistMessages )
    m_state.set( msgSeqNum, messageString );
  m_state.incrNextSenderMsgSeqNum();
}
void FIX::Session::populateRejectReason ( Message reject,
int  field,
const std::string &  text 
) [private]

Definition at line 916 of file Session.cpp.

References FIX::BeginString_FIX42, FIX::SessionID::getBeginString(), FIX::FieldMap::getField(), FIX::Message::getHeader(), m_sessionID, FIX::FIELD::MsgType, FIX::MsgType_Reject, FIX::FIELD::RefTagID, FIX::FieldMap::setField(), and FIX::FIELD::Text.

Referenced by generateBusinessReject(), and generateReject().

{
  MsgType msgType;
   reject.getHeader().getField( msgType );

  if ( msgType == MsgType_Reject 
       && m_sessionID.getBeginString() >= FIX::BeginString_FIX42 )
  {
    reject.setField( RefTagID( field ) );
    reject.setField( Text( text ) );
  }
  else
  {
    std::stringstream stream;
    stream << text << " (" << field << ")";
    reject.setField( Text( stream.str() ) );
  }
}
void FIX::Session::populateRejectReason ( Message reject,
const std::string &  text 
) [private]

Definition at line 936 of file Session.cpp.

References FIX::FieldMap::setField(), and FIX::FIELD::Text.

{
  reject.setField( Text( text ) );
}
bool FIX::Session::receivedLogon ( ) [inline]

Definition at line 64 of file Session.h.

References m_state, and FIX::SessionState::receivedLogon().

Referenced by isLoggedOn().

{ return m_state.receivedLogon(); }
void FIX::Session::refresh ( ) throw ( IOException ) [inline]
Session * FIX::Session::registerSession ( const SessionID sessionID) [static]

Definition at line 1444 of file Session.cpp.

References isSessionRegistered(), lookupSession(), s_mutex, and s_registered.

Referenced by FIX::SocketConnection::read(), and FIX::ThreadedSocketConnection::setSession().

{
  Locker locker( s_mutex );
  Session* pSession = lookupSession( sessionID );
  if ( pSession == 0 ) return 0;
  if ( isSessionRegistered( sessionID ) ) return 0;
  s_registered[ sessionID ] = pSession;
  return pSession;
}
void FIX::Session::removeSession ( Session s) [static, private]

Definition at line 1480 of file Session.cpp.

References m_sessionID, s_mutex, s_registered, s_sessionIDs, and s_sessions.

Referenced by ~Session().

{
  Locker locker( s_mutex );
  s_sessions.erase( s.m_sessionID );
  s_sessionIDs.erase( s.m_sessionID );
  s_registered.erase( s.m_sessionID );
}
bool FIX::Session::resend ( Message message) [private]

Definition at line 572 of file Session.cpp.

References FIX::FieldMap::getField(), FIX::Message::getHeader(), insertOrigSendingTime(), insertSendingTime(), m_application, m_sessionID, FIX::FIELD::MsgSeqNum, FIX::FIELD::PossDupFlag, FIX::FIELD::SendingTime, FIX::FieldMap::setField(), and FIX::Application::toApp().

Referenced by nextResendRequest().

{
  SendingTime sendingTime;
  MsgSeqNum msgSeqNum;
  Header& header = message.getHeader();
  header.getField( sendingTime );
  header.getField( msgSeqNum );
  insertOrigSendingTime( header, sendingTime );
  header.setField( PossDupFlag( true ) );
  insertSendingTime( header );

  try
  {
    m_application.toApp( message, m_sessionID );
    return true;
  }
  catch ( DoNotSend& )
  { return false; }
}
void FIX::Session::reset ( ) throw ( IOException ) [inline]
bool FIX::Session::send ( Message message)

Definition at line 452 of file Session.cpp.

References FIX::Message::getHeader(), FIX::FIELD::OrigSendingTime, FIX::FIELD::PossDupFlag, FIX::FieldMap::removeField(), and sendRaw().

Referenced by nextResendRequest(), sendRaw(), and sendToTarget().

{
  message.getHeader().removeField( FIELD::PossDupFlag );
  message.getHeader().removeField( FIELD::OrigSendingTime );
  return sendRaw( message );
}
bool FIX::Session::send ( const std::string &  string) [private]

Definition at line 535 of file Session.cpp.

References m_pResponder, m_state, FIX::SessionState::onOutgoing(), and FIX::Responder::send().

{
  if ( !m_pResponder ) return false;
  m_state.onOutgoing( string );
  return m_pResponder->send( string );
}
bool FIX::Session::sendRaw ( Message message,
int  msgSeqNum = 0 
) [private]

Definition at line 459 of file Session.cpp.

References fill(), getExpectedSenderNum(), FIX::FieldMap::getFieldIfSet(), FIX::Message::getHeader(), FIX::Message::isAdminMsgType(), isLoggedOn(), m_application, m_mutex, m_sessionID, m_state, FIX::FIELD::MsgSeqNum, FIX::FIELD::MsgType, FIX::SessionState::onEvent(), persist(), FIX::SessionState::receivedReset(), FIX::SessionState::reset(), FIX::FIELD::ResetSeqNumFlag, send(), FIX::SessionState::sentReset(), FIX::FieldMap::setField(), shouldSendReset(), FIX::Application::toAdmin(), FIX::Application::toApp(), and FIX::Message::toString().

Referenced by generateBusinessReject(), generateHeartbeat(), generateLogon(), generateLogout(), generateReject(), generateResendRequest(), generateTestRequest(), and send().

{
  Locker l( m_mutex );

  try
  {
    Header& header = message.getHeader();

    MsgType msgType;
    header.getFieldIfSet(msgType);

    fill( header );
    std::string messageString;

    if ( num )
      header.setField( MsgSeqNum( num ) );

    if ( Message::isAdminMsgType( msgType ) )
    {
      m_application.toAdmin( message, m_sessionID );

      if( msgType == "A" && !m_state.receivedReset() )
      {
        ResetSeqNumFlag resetSeqNumFlag( false );
        message.getFieldIfSet(resetSeqNumFlag);

        if( resetSeqNumFlag )
        {
          m_state.reset();
          message.getHeader().setField( MsgSeqNum(getExpectedSenderNum()) );
        }
        m_state.sentReset( resetSeqNumFlag );
      }

      message.toString( messageString );

      if( !num )
        persist( message, messageString );

      if (
        msgType == "A" || msgType == "5"
        || msgType == "2" || msgType == "4"
        || isLoggedOn() )
      {
        send( messageString );
      }
    }
    else
    {
      // do not send application messages if they will just be cleared
      if( !isLoggedOn() && shouldSendReset() )
        return false;

      try
      {
        m_application.toApp( message, m_sessionID );
        message.toString( messageString );

        if( !num )
          persist( message, messageString );

        if ( isLoggedOn() )
          send( messageString );
      }
      catch ( DoNotSend& ) { return false; }
    }

    return true;
  }
  catch ( IOException& e )
  {
    m_state.onEvent( e.what() );
    return false;
  }
}
bool FIX::Session::sendToTarget ( Message message,
const std::string &  qualifier = "" 
) throw ( SessionNotFound ) [static]

Definition at line 1351 of file Session.cpp.

{
  try
  {
    SessionID sessionID = message.getSessionID( qualifier );
    return sendToTarget( message, sessionID );
  }
  catch ( FieldNotFound& ) { throw SessionNotFound(); }
}
bool FIX::Session::sendToTarget ( Message message,
const SessionID sessionID 
) throw ( SessionNotFound ) [static]

Definition at line 1362 of file Session.cpp.

References send().

{
  message.setSessionID( sessionID );
  Session* pSession = lookupSession( sessionID );
  if ( !pSession ) throw SessionNotFound();
  return pSession->send( message );
}
bool FIX::Session::sendToTarget ( Message message,
const SenderCompID &  senderCompID,
const TargetCompID &  targetCompID,
const std::string &  qualifier = "" 
) throw ( SessionNotFound ) [static]

Definition at line 1372 of file Session.cpp.

References FIX::Message::getHeader(), and FIX::FieldMap::setField().

{
  message.getHeader().setField( senderCompID );
  message.getHeader().setField( targetCompID );
  return sendToTarget( message, qualifier );
}
bool FIX::Session::sendToTarget ( Message message,
const std::string &  senderCompID,
const std::string &  targetCompID,
const std::string &  qualifier = "" 
) throw ( SessionNotFound ) [static]

Definition at line 1384 of file Session.cpp.

References FIX::FIELD::SenderCompID, and FIX::FIELD::TargetCompID.

{
  return sendToTarget( message, SenderCompID( sender ),
                       TargetCompID( target ), qualifier );
}
bool FIX::Session::sentLogon ( ) [inline]

Definition at line 62 of file Session.h.

References m_state, and FIX::SessionState::sentLogon().

Referenced by isLoggedOn().

{ return m_state.sentLogon(); }
bool FIX::Session::sentLogout ( ) [inline]

Definition at line 63 of file Session.h.

References m_state, and FIX::SessionState::sentLogout().

{ return m_state.sentLogout(); }
bool FIX::Session::set ( int  s,
const Message m 
) [private]
void FIX::Session::setCheckCompId ( bool  value) [inline]

Definition at line 139 of file Session.h.

References m_checkCompId.

Referenced by FIX::HttpConnection::processSession().

    { m_checkCompId = value; }
void FIX::Session::setCheckLatency ( bool  value) [inline]

Definition at line 144 of file Session.h.

References m_checkLatency.

Referenced by FIX::HttpConnection::processSession().

    { m_checkLatency = value; }
void FIX::Session::setDataDictionaryProvider ( const DataDictionaryProvider dataDictionaryProvider) [inline]

Definition at line 77 of file Session.h.

References m_dataDictionaryProvider.

  { m_dataDictionaryProvider = dataDictionaryProvider; }
void FIX::Session::setLogonTime ( const TimeRange value) [inline]

Definition at line 119 of file Session.h.

References m_logonTime.

    { m_logonTime = value; }
void FIX::Session::setLogonTimeout ( int  value) [inline]

Definition at line 154 of file Session.h.

References FIX::SessionState::logonTimeout(), and m_state.

Referenced by FIX::HttpConnection::processSession().

    { m_state.logonTimeout( value ); }
void FIX::Session::setLogoutTimeout ( int  value) [inline]

Definition at line 159 of file Session.h.

References FIX::SessionState::logoutTimeout(), and m_state.

Referenced by FIX::HttpConnection::processSession().

    { m_state.logoutTimeout( value ); }
void FIX::Session::setMaxLatency ( int  value) [inline]

Definition at line 149 of file Session.h.

References m_maxLatency.

Referenced by FIX::HttpConnection::processSession().

    { m_maxLatency = value; }
void FIX::Session::setMillisecondsInTimeStamp ( bool  value) [inline]

Definition at line 184 of file Session.h.

References m_millisecondsInTimeStamp.

Referenced by FIX::HttpConnection::processSession().

void FIX::Session::setNextSenderMsgSeqNum ( int  num) throw ( IOException ) [inline]
void FIX::Session::setNextTargetMsgSeqNum ( int  num) throw ( IOException ) [inline]
void FIX::Session::setPersistMessages ( bool  value) [inline]

Definition at line 189 of file Session.h.

References m_persistMessages.

Referenced by FIX::HttpConnection::processSession().

    { m_persistMessages = value; }
void FIX::Session::setRefreshOnLogon ( bool  value) [inline]

Definition at line 179 of file Session.h.

References m_refreshOnLogon.

Referenced by FIX::HttpConnection::processSession().

    { m_refreshOnLogon = value; } 
void FIX::Session::setResetOnDisconnect ( bool  value) [inline]

Definition at line 174 of file Session.h.

References m_resetOnDisconnect.

Referenced by FIX::HttpConnection::processSession().

    { m_resetOnDisconnect = value; }
void FIX::Session::setResetOnLogon ( bool  value) [inline]

Definition at line 164 of file Session.h.

References m_resetOnLogon.

Referenced by FIX::HttpConnection::processSession().

    { m_resetOnLogon = value; }
void FIX::Session::setResetOnLogout ( bool  value) [inline]

Definition at line 169 of file Session.h.

References m_resetOnLogout.

Referenced by FIX::HttpConnection::processSession().

    { m_resetOnLogout = value; }
void FIX::Session::setResponder ( Responder pR) [inline]
void FIX::Session::setSenderDefaultApplVerID ( const std::string &  senderDefaultApplVerID) [inline]

Definition at line 124 of file Session.h.

References m_senderDefaultApplVerID.

    { m_senderDefaultApplVerID = senderDefaultApplVerID; }
void FIX::Session::setSendRedundantResendRequests ( bool  value) [inline]

Definition at line 134 of file Session.h.

References m_sendRedundantResendRequests.

Referenced by FIX::HttpConnection::processSession().

void FIX::Session::setTargetDefaultApplVerID ( const std::string &  targetDefaultApplVerID) [inline]

Definition at line 129 of file Session.h.

References m_targetDefaultApplVerID.

Referenced by next().

    { m_targetDefaultApplVerID = targetDefaultApplVerID; }
void FIX::Session::setValidateLengthAndChecksum ( bool  value) [inline]

Definition at line 194 of file Session.h.

References m_validateLengthAndChecksum.

bool FIX::Session::shouldSendReset ( ) [private]
void FIX::Session::unregisterSession ( const SessionID sessionID) [static]

Definition at line 1454 of file Session.cpp.

References s_mutex, and s_registered.

Referenced by FIX::Acceptor::stop(), FIX::SocketConnection::~SocketConnection(), and FIX::ThreadedSocketConnection::~ThreadedSocketConnection().

{
  Locker locker( s_mutex );
  s_registered.erase( sessionID );
}
bool FIX::Session::validLogonState ( const MsgType &  msgType) [private]

Definition at line 1024 of file Session.cpp.

References m_state, FIX::MsgType_Logon, FIX::MsgType_Logout, FIX::MsgType_Reject, FIX::MsgType_SequenceReset, FIX::SessionState::receivedLogon(), FIX::SessionState::receivedReset(), FIX::SessionState::sentLogon(), FIX::SessionState::sentLogout(), and FIX::SessionState::sentReset().

Referenced by verify().

{
  if ( (msgType == MsgType_Logon && m_state.sentReset()) 
       || (m_state.receivedReset()) )
    return true;
  if ( (msgType == MsgType_Logon && !m_state.receivedLogon())
       || (msgType != MsgType_Logon && m_state.receivedLogon()) )
    return true;
  if ( msgType == MsgType_Logout && m_state.sentLogon() )
    return true;
  if ( msgType != MsgType_Logout && m_state.sentLogout() )
    return true;
  if ( msgType == MsgType_SequenceReset ) 
    return true;
  if ( msgType == MsgType_Reject )
    return true;

  return false;
}
bool FIX::Session::verify ( const Message msg,
bool  checkTooHigh = true,
bool  checkTooLow = true 
) [private]

Definition at line 941 of file Session.cpp.

References FIX::IntConvertor::convert(), disconnect(), doBadCompID(), doBadTime(), doTargetTooHigh(), doTargetTooLow(), FIELD_GET_PTR, FIELD_GET_REF, fromCallback(), FIX::Message::getHeader(), isCorrectCompID(), isGoodTime(), isTargetTooHigh(), isTargetTooLow(), FIX::SessionState::lastReceivedTime(), m_sessionID, m_state, FIX::FIELD::MsgSeqNum, FIX::FIELD::MsgType, FIX::SessionState::onEvent(), FIX::SessionState::resendRange(), FIX::SessionState::resendRequested(), FIX::FIELD::SenderCompID, FIX::FIELD::SendingTime, FIX::FIELD::TargetCompID, FIX::SessionState::testRequest(), and validLogonState().

Referenced by next(), nextHeartbeat(), nextLogon(), nextLogout(), nextReject(), nextResendRequest(), nextSequenceReset(), and nextTestRequest().

{
  const MsgType* pMsgType = 0;
  const MsgSeqNum* pMsgSeqNum = 0;

  try
  {
    const Header& header = msg.getHeader();

    pMsgType = FIELD_GET_PTR( header, MsgType );
    const SenderCompID& senderCompID = FIELD_GET_REF( header, SenderCompID );
    const TargetCompID& targetCompID = FIELD_GET_REF( header, TargetCompID );
    const SendingTime& sendingTime = FIELD_GET_REF( header, SendingTime );

    if( checkTooHigh || checkTooLow )
      pMsgSeqNum = FIELD_GET_PTR( header, MsgSeqNum );

    if ( !validLogonState( *pMsgType ) )
      throw std::logic_error( "Logon state is not valid for message" );

    if ( !isGoodTime( sendingTime ) )
    {
      doBadTime( msg );
      return false;
    }
    if ( !isCorrectCompID( senderCompID, targetCompID ) )
    {
      doBadCompID( msg );
      return false;
    }

    if ( checkTooHigh && isTargetTooHigh( *pMsgSeqNum ) )
    {
      doTargetTooHigh( msg );
      return false;
    }
    else if ( checkTooLow && isTargetTooLow( *pMsgSeqNum ) )
    {
      doTargetTooLow( msg );
      return false;
    }

    if ( (checkTooHigh || checkTooLow) && m_state.resendRequested() )
    {
      SessionState::ResendRange range = m_state.resendRange();
 
      if ( *pMsgSeqNum >= range.second )
      {
        m_state.onEvent ("ResendRequest for messages FROM: " +
                         IntConvertor::convert (range.first) + " TO: " +
                         IntConvertor::convert (range.second) +
                         " has been satisfied.");
        m_state.resendRange (0, 0);
      }
    }
  }
  catch ( std::exception& e )
  {
    m_state.onEvent( e.what() );
    disconnect();
    return false;
  }

  UtcTimeStamp now;
  m_state.lastReceivedTime( now );
  m_state.testRequest( 0 );

  fromCallback( pMsgType ? *pMsgType : MsgType(), msg, m_sessionID );
  return true;
}

Member Data Documentation

Definition at line 301 of file Session.h.

Referenced by disconnect(), fromCallback(), nextLogon(), resend(), sendRaw(), and Session().

Definition at line 309 of file Session.h.

Referenced by getCheckCompId(), isCorrectCompID(), and setCheckCompId().

Definition at line 310 of file Session.h.

Referenced by getCheckLatency(), isGoodTime(), and setCheckLatency().

Definition at line 304 of file Session.h.

Referenced by getLogonTime(), isLogonTime(), and setLogonTime().

Definition at line 311 of file Session.h.

Referenced by getMaxLatency(), isGoodTime(), and setMaxLatency().

Definition at line 322 of file Session.h.

Referenced by Session(), and ~Session().

Definition at line 325 of file Session.h.

Referenced by disconnect(), nextResendRequest(), and sendRaw().

Definition at line 317 of file Session.h.

Referenced by getPersistMessages(), nextResendRequest(), and setPersistMessages().

Definition at line 323 of file Session.h.

Referenced by Session(), and ~Session().

Definition at line 324 of file Session.h.

Referenced by disconnect(), send(), and setResponder().

Definition at line 315 of file Session.h.

Referenced by generateLogon(), getRefreshOnLogon(), nextLogon(), and setRefreshOnLogon().

Definition at line 314 of file Session.h.

Referenced by disconnect(), getResetOnDisconnect(), setResetOnDisconnect(), and shouldSendReset().

Definition at line 313 of file Session.h.

Referenced by getResetOnLogout(), nextLogout(), setResetOnLogout(), and shouldSendReset().

Definition at line 303 of file Session.h.

Referenced by checkSessionTime(), and isSessionTime().

Definition at line 307 of file Session.h.

Referenced by getTargetDefaultApplVerID(), next(), and setTargetDefaultApplVerID().

Mutex FIX::Session::s_mutex [static, private]

Definition at line 329 of file Session.h.

Referenced by isSessionRegistered(), registerSession(), removeSession(), and unregisterSession().

Definition at line 328 of file Session.h.

Referenced by addSession(), getSessions(), and removeSession().

Definition at line 327 of file Session.h.

Referenced by addSession(), doesSessionExist(), lookupSession(), numSessions(), and removeSession().


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

Generated on Mon Jun 23 2014 23:49:39 for QuickFIX by doxygen 1.7.6.1 written by Dimitri van Heesch, © 1997-2001