Session.h
Go to the documentation of this file.
1 /* -*- C++ -*- */
2 
3 /****************************************************************************
4 ** Copyright (c) 2001-2014
5 **
6 ** This file is part of the QuickFIX FIX Engine
7 **
8 ** This file may be distributed under the terms of the quickfixengine.org
9 ** license as defined by quickfixengine.org and appearing in the file
10 ** LICENSE included in the packaging of this file.
11 **
12 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
13 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
14 **
15 ** See http://www.quickfixengine.org/LICENSE for licensing information.
16 **
17 ** Contact ask@quickfixengine.org if any conditions of this licensing are
18 ** not clear to you.
19 **
20 ****************************************************************************/
21 
22 #ifndef FIX_SESSION_H
23 #define FIX_SESSION_H
24 
25 #ifdef _MSC_VER
26 #pragma warning( disable : 4503 4355 4786 4290 )
27 #endif
28 
29 #include "SessionState.h"
30 #include "TimeRange.h"
31 #include "SessionID.h"
32 #include "Responder.h"
33 #include "Fields.h"
34 #include "DataDictionaryProvider.h"
35 #include "Application.h"
36 #include "Mutex.h"
37 #include "Log.h"
38 #include <utility>
39 #include <map>
40 #include <queue>
41 
42 namespace FIX
43 {
45 class Session
46 {
47 public:
49  const SessionID&,
51  const TimeRange&,
52  int heartBtInt, LogFactory* pLogFactory );
53  virtual ~Session();
54 
55  void logon()
56  { m_state.enabled( true ); m_state.logoutReason( "" ); }
57  void logout( const std::string& reason = "" )
58  { m_state.enabled( false ); m_state.logoutReason( reason ); }
59  bool isEnabled()
60  { return m_state.enabled(); }
61 
62  bool sentLogon() { return m_state.sentLogon(); }
63  bool sentLogout() { return m_state.sentLogout(); }
64  bool receivedLogon() { return m_state.receivedLogon(); }
65  bool isLoggedOn() { return receivedLogon() && sentLogon(); }
66  void reset() throw( IOException )
68  void refresh() throw( IOException )
69  { m_state.refresh(); }
70  void setNextSenderMsgSeqNum( int num ) throw( IOException )
72  void setNextTargetMsgSeqNum( int num ) throw( IOException )
74 
75  const SessionID& getSessionID() const
76  { return m_sessionID; }
77  void setDataDictionaryProvider( const DataDictionaryProvider& dataDictionaryProvider )
78  { m_dataDictionaryProvider = dataDictionaryProvider; }
80  { return m_dataDictionaryProvider; }
81 
82  static bool sendToTarget( Message& message,
83  const std::string& qualifier = "" )
84  throw( SessionNotFound );
85  static bool sendToTarget( Message& message, const SessionID& sessionID )
86  throw( SessionNotFound );
87  static bool sendToTarget( Message&,
88  const SenderCompID& senderCompID,
89  const TargetCompID& targetCompID,
90  const std::string& qualifier = "" )
91  throw( SessionNotFound );
92  static bool sendToTarget( Message& message,
93  const std::string& senderCompID,
94  const std::string& targetCompID,
95  const std::string& qualifier = "" )
96  throw( SessionNotFound );
97 
98  static std::set<SessionID> getSessions();
99  static bool doesSessionExist( const SessionID& );
100  static Session* lookupSession( const SessionID& );
101  static Session* lookupSession( const std::string&, bool reverse = false );
102  static bool isSessionRegistered( const SessionID& );
103  static Session* registerSession( const SessionID& );
104  static void unregisterSession( const SessionID& );
105 
106  static size_t numSessions();
107 
108  bool isSessionTime(const UtcTimeStamp& time)
109  { return m_sessionTime.isInRange(time); }
110  bool isLogonTime(const UtcTimeStamp& time)
111  { return m_logonTime.isInRange(time); }
112  bool isInitiator()
113  { return m_state.initiate(); }
114  bool isAcceptor()
115  { return !m_state.initiate(); }
116 
118  { return m_logonTime; }
119  void setLogonTime( const TimeRange& value )
120  { m_logonTime = value; }
121 
122  const std::string& getSenderDefaultApplVerID()
123  { return m_senderDefaultApplVerID; }
124  void setSenderDefaultApplVerID( const std::string& senderDefaultApplVerID )
125  { m_senderDefaultApplVerID = senderDefaultApplVerID; }
126 
127  const std::string& getTargetDefaultApplVerID()
128  { return m_targetDefaultApplVerID; }
129  void setTargetDefaultApplVerID( const std::string& targetDefaultApplVerID )
130  { m_targetDefaultApplVerID = targetDefaultApplVerID; }
131 
134  void setSendRedundantResendRequests ( bool value )
135  { m_sendRedundantResendRequests = value; }
136 
138  { return m_checkCompId; }
139  void setCheckCompId ( bool value )
140  { m_checkCompId = value; }
141 
143  { return m_checkLatency; }
144  void setCheckLatency ( bool value )
145  { m_checkLatency = value; }
146 
148  { return m_maxLatency; }
149  void setMaxLatency ( int value )
150  { m_maxLatency = value; }
151 
153  { return m_state.logonTimeout(); }
154  void setLogonTimeout ( int value )
155  { m_state.logonTimeout( value ); }
156 
158  { return m_state.logoutTimeout(); }
159  void setLogoutTimeout ( int value )
160  { m_state.logoutTimeout( value ); }
161 
163  { return m_resetOnLogon; }
164  void setResetOnLogon ( bool value )
165  { m_resetOnLogon = value; }
166 
168  { return m_resetOnLogout; }
169  void setResetOnLogout ( bool value )
170  { m_resetOnLogout = value; }
171 
173  { return m_resetOnDisconnect; }
174  void setResetOnDisconnect( bool value )
175  { m_resetOnDisconnect = value; }
176 
178  { return m_refreshOnLogon; }
179  void setRefreshOnLogon( bool value )
180  { m_refreshOnLogon = value; }
181 
183  { return (m_timestampPrecision == 3); }
184  void setMillisecondsInTimeStamp ( bool value )
185  { if (value)
187  else
189  }
191  { return m_timestampPrecision; }
192  void setTimestampPrecision(int precision)
193  {
194  if (precision < 0 || precision > 9)
195  return;
196 
197  m_timestampPrecision = precision;
198  }
199 
201  { return m_persistMessages; }
202  void setPersistMessages ( bool value )
203  { m_persistMessages = value; }
204 
206  { return m_validateLengthAndChecksum; }
207  void setValidateLengthAndChecksum ( bool value )
208  { m_validateLengthAndChecksum = value; }
209 
211  {
213  reset();
214  m_pResponder = pR;
215  }
216 
217  bool send( Message& );
218  void next();
219  void next( const UtcTimeStamp& timeStamp );
220  void next( const std::string&, const UtcTimeStamp& timeStamp, bool queued = false );
221  void next( const Message&, const UtcTimeStamp& timeStamp, bool queued = false );
222  void disconnect();
223 
226 
227  Log* getLog() { return &m_state; }
228  const MessageStore* getStore() { return &m_state; }
229 
230 private:
231  typedef std::map < SessionID, Session* > Sessions;
232  typedef std::set < SessionID > SessionIDs;
233 
234  static bool addSession( Session& );
235  static void removeSession( Session& );
236 
237  bool send( const std::string& );
238  bool sendRaw( Message&, int msgSeqNum = 0 );
239  bool resend( Message& message );
240  void persist( const Message&, const std::string& ) throw ( IOException );
241 
242  void insertSendingTime( Header& );
244  const UtcTimeStamp& when = UtcTimeStamp () );
245  void fill( Header& );
246 
247  bool isGoodTime( const SendingTime& sendingTime )
248  {
249  if ( !m_checkLatency ) return true;
250  UtcTimeStamp now;
251  return labs( now - sendingTime ) <= m_maxLatency;
252  }
253  bool checkSessionTime( const UtcTimeStamp& timeStamp )
254  {
255  UtcTimeStamp creationTime = m_state.getCreationTime();
256  return m_sessionTime.isInSameRange( timeStamp, creationTime );
257  }
258  bool isTargetTooHigh( const MsgSeqNum& msgSeqNum )
259  { return msgSeqNum > ( m_state.getNextTargetMsgSeqNum() ); }
260  bool isTargetTooLow( const MsgSeqNum& msgSeqNum )
261  { return msgSeqNum < ( m_state.getNextTargetMsgSeqNum() ); }
262  bool isCorrectCompID( const SenderCompID& senderCompID,
263  const TargetCompID& targetCompID )
264  {
265  if( !m_checkCompId ) return true;
266 
267  return
268  m_sessionID.getSenderCompID().getValue() == targetCompID.getValue()
269  && m_sessionID.getTargetCompID().getValue() == senderCompID.getValue();
270  }
271  bool shouldSendReset();
272 
273  bool validLogonState( const MsgType& msgType );
274  void fromCallback( const MsgType& msgType, const Message& msg,
275  const SessionID& sessionID );
276 
277  void doBadTime( const Message& msg );
278  void doBadCompID( const Message& msg );
279  bool doPossDup( const Message& msg );
280  bool doTargetTooLow( const Message& msg );
281  void doTargetTooHigh( const Message& msg );
282  void nextQueued( const UtcTimeStamp& timeStamp );
283  bool nextQueued( int num, const UtcTimeStamp& timeStamp );
284 
285  void nextLogon( const Message&, const UtcTimeStamp& timeStamp );
286  void nextHeartbeat( const Message&, const UtcTimeStamp& timeStamp );
287  void nextTestRequest( const Message&, const UtcTimeStamp& timeStamp );
288  void nextLogout( const Message&, const UtcTimeStamp& timeStamp );
289  void nextReject( const Message&, const UtcTimeStamp& timeStamp );
290  void nextSequenceReset( const Message&, const UtcTimeStamp& timeStamp );
291  void nextResendRequest( const Message&, const UtcTimeStamp& timeStamp );
292 
293  void generateLogon();
294  void generateLogon( const Message& );
295  void generateResendRequest( const BeginString&, const MsgSeqNum& );
296  void generateSequenceReset( int, int );
297  void generateHeartbeat();
298  void generateHeartbeat( const Message& );
299  void generateTestRequest( const std::string& );
300  void generateReject( const Message&, int err, int field = 0 );
301  void generateReject( const Message&, const std::string& );
302  void generateBusinessReject( const Message&, int err, int field = 0 );
303  void generateLogout( const std::string& text = "" );
304 
305  void populateRejectReason( Message&, int field, const std::string& );
306  void populateRejectReason( Message&, const std::string& );
307 
308  bool verify( const Message& msg,
309  bool checkTooHigh = true, bool checkTooLow = true );
310 
311  bool set( int s, const Message& m );
312  bool get( int s, Message& m ) const;
313 
314  Message * newMessage(const std::string & msgType) const;
315 
320 
334 
341 
342  static Sessions s_sessions;
343  static SessionIDs s_sessionIDs;
344  static Sessions s_registered;
345  static Mutex s_mutex;
346 };
347 }
348 
349 #endif //FIX_SESSION_H
bool getCheckLatency()
Definition: Session.h:142
int getExpectedTargetNum()
Definition: Session.h:225
int logonTimeout() const
Definition: SessionState.h:71
bool isEnabled()
Definition: Session.h:59
Message * newMessage(const std::string &msgType) const
Definition: Session.cpp:492
bool getCheckCompId()
Definition: Session.h:137
static Session * lookupSession(const SessionID &)
Definition: Session.cpp:1496
virtual ~Session()
Definition: Session.cpp:83
int getNextTargetMsgSeqNum() const
Definition: SessionState.h:179
void populateRejectReason(Message &, int field, const std::string &)
Definition: Session.cpp:1009
bool isGoodTime(const SendingTime &sendingTime)
Definition: Session.h:247
bool send(Message &)
Definition: Session.cpp:523
bool getRefreshOnLogon()
Definition: Session.h:177
void setRefreshOnLogon(bool value)
Definition: Session.h:179
void setDataDictionaryProvider(const DataDictionaryProvider &dataDictionaryProvider)
Definition: Session.h:77
bool verify(const Message &msg, bool checkTooHigh=true, bool checkTooLow=true)
Definition: Session.cpp:1034
Keeps track of when session is active.
Definition: TimeRange.h:34
int getExpectedSenderNum()
Definition: Session.h:224
bool enabled() const
Definition: SessionState.h:50
DataDictionaryProvider m_dataDictionaryProvider
Definition: Session.h:336
bool getValidateLengthAndChecksum()
Definition: Session.h:205
void generateHeartbeat()
Definition: Session.cpp:764
const DataDictionaryProvider & getDataDictionaryProvider() const
Definition: Session.h:79
static void unregisterSession(const SessionID &)
Definition: Session.cpp:1547
bool isInitiator()
Definition: Session.h:112
Maintains the state and implements the logic of a FIX session.
Definition: Session.h:45
void doBadTime(const Message &msg)
Definition: Session.cpp:1146
void nextReject(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:312
MessageStoreFactory & m_messageStoreFactory
Definition: Session.h:337
bool sentLogon()
Definition: Session.h:62
static bool addSession(Session &)
Definition: Session.cpp:1559
Interface implements sending on and disconnecting a transport.
Definition: Responder.h:34
Session cannot be found for specified action.
Definition: Exceptions.h:231
void next()
Definition: Session.cpp:125
static size_t numSessions()
Definition: Session.cpp:1553
void setNextTargetMsgSeqNum(int n)
Definition: SessionState.h:183
Queries for DataDictionary based on appropriate version of FIX.
void setLogonTime(const TimeRange &value)
Definition: Session.h:119
UtcTimeStamp getCreationTime() const
Definition: SessionState.h:189
void reverse(I begin, I end)
Definition: pugixml.cpp:6009
bool receivedLogon()
Definition: Session.h:64
bool sendRaw(Message &, int msgSeqNum=0)
Definition: Session.cpp:530
bool m_checkLatency
Definition: Session.h:325
SessionID m_sessionID
Definition: Session.h:317
void nextTestRequest(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:287
void reset()
Definition: Session.h:66
void setMillisecondsInTimeStamp(bool value)
Definition: Session.h:184
bool validLogonState(const MsgType &msgType)
Definition: Session.cpp:1117
void setNextSenderMsgSeqNum(int num)
Definition: Session.h:70
void nextResendRequest(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:344
bool getPersistMessages()
Definition: Session.h:200
void generateResendRequest(const BeginString &, const MsgSeqNum &)
Definition: Session.cpp:718
bool getSendRedundantResendRequests()
Definition: Session.h:132
const TargetCompID & getTargetCompID() const
Definition: SessionID.h:57
void setResetOnLogon(bool value)
Definition: Session.h:164
void refresh()
Definition: Session.h:68
bool initiate() const
Definition: SessionState.h:68
static bool isInRange(const UtcTimeOnly &start, const UtcTimeOnly &end, const DateTime &time)
Definition: TimeRange.h:43
void setCheckCompId(bool value)
Definition: Session.h:139
static bool isSessionRegistered(const SessionID &)
Definition: Session.cpp:1531
bool m_checkCompId
Definition: Session.h:324
bool getMillisecondsInTimeStamp()
Definition: Session.h:182
void setSenderDefaultApplVerID(const std::string &senderDefaultApplVerID)
Definition: Session.h:124
int logoutTimeout() const
Definition: SessionState.h:74
bool isLogonTime(const UtcTimeStamp &time)
Definition: Session.h:110
int m_timestampPrecision
Definition: Session.h:331
int getMaxLatency()
Definition: Session.h:147
This interface must be implemented to log messages and events.
Definition: Log.h:81
bool isTargetTooLow(const MsgSeqNum &msgSeqNum)
Definition: Session.h:260
const int SendingTime
static Sessions s_sessions
Definition: Session.h:342
Definition: Acceptor.cpp:34
bool getResetOnLogon()
Definition: Session.h:162
static Session * registerSession(const SessionID &)
Definition: Session.cpp:1537
void doTargetTooHigh(const Message &msg)
Definition: Session.cpp:1206
Log * getLog()
Definition: Session.h:227
void generateLogon()
Definition: Session.cpp:673
void setLogoutTimeout(int value)
Definition: Session.h:159
Session(Application &, MessageStoreFactory &, const SessionID &, const DataDictionaryProvider &, const TimeRange &, int heartBtInt, LogFactory *pLogFactory)
Definition: Session.cpp:41
void generateSequenceReset(int, int)
Definition: Session.cpp:743
This interface must be implemented to define what your FIX application does.
Definition: Application.h:43
void setPersistMessages(bool value)
Definition: Session.h:202
int getTimestampPrecision()
Definition: Session.h:190
static std::set< SessionID > getSessions()
Definition: Session.cpp:1485
static bool sendToTarget(Message &message, const std::string &qualifier="")
Definition: Session.cpp:1444
int m_maxLatency
Definition: Session.h:326
Application & m_application
Definition: Session.h:316
bool getResetOnLogout()
Definition: Session.h:167
bool m_resetOnLogon
Definition: Session.h:327
std::string m_senderDefaultApplVerID
Definition: Session.h:321
LogFactory * m_pLogFactory
Definition: Session.h:338
void disconnect()
Definition: Session.cpp:613
void persist(const Message &, const std::string &)
Definition: Session.cpp:663
static SessionIDs s_sessionIDs
Definition: Session.h:343
bool isTargetTooHigh(const MsgSeqNum &msgSeqNum)
Definition: Session.h:258
int getLogonTimeout()
Definition: Session.h:152
const int TargetCompID
static Mutex s_mutex
Definition: Session.h:345
TimeRange m_logonTime
Definition: Session.h:319
void generateReject(const Message &, int err, int field=0)
Definition: Session.cpp:805
void setMaxLatency(int value)
Definition: Session.h:149
SessionState m_state
Definition: Session.h:335
std::string m_targetDefaultApplVerID
Definition: Session.h:322
This interface must be implemented to create a Log.
Definition: Log.h:42
void setTimestampPrecision(int precision)
Definition: Session.h:192
bool receivedLogon() const
Definition: SessionState.h:53
Base class for all FIX messages.
Definition: Message.h:117
int getLogoutTimeout()
Definition: Session.h:157
bool sentLogout()
Definition: Session.h:63
bool m_validateLengthAndChecksum
Definition: Session.h:333
This interface must be implemented to store and retrieve messages and sequence numbers.
Definition: MessageStore.h:66
const SessionID & getSessionID() const
Definition: Session.h:75
bool checkSessionTime(const UtcTimeStamp &timeStamp)
Definition: Session.h:253
void insertSendingTime(Header &)
Definition: Session.cpp:91
std::string logoutReason() const
Definition: SessionState.h:150
void fromCallback(const MsgType &msgType, const Message &msg, const SessionID &sessionID)
Definition: Session.cpp:1137
bool shouldSendReset()
Definition: Session.cpp:1106
void nextHeartbeat(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:280
This interface must be implemented to create a MessageStore.
Definition: MessageStore.h:41
Portable implementation of a mutex.
Definition: Mutex.h:30
void setResetOnLogout(bool value)
Definition: Session.h:169
void setSendRedundantResendRequests(bool value)
Definition: Session.h:134
bool sentLogon() const
Definition: SessionState.h:59
bool isCorrectCompID(const SenderCompID &senderCompID, const TargetCompID &targetCompID)
Definition: Session.h:262
const int SenderCompID
const std::string & getTargetDefaultApplVerID()
Definition: Session.h:127
void generateTestRequest(const std::string &)
Definition: Session.cpp:792
void nextLogon(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:202
const std::string & getSenderDefaultApplVerID()
Definition: Session.h:122
static void removeSession(Session &)
Definition: Session.cpp:1573
void doBadCompID(const Message &msg)
Definition: Session.cpp:1152
void generateLogout(const std::string &text="")
Definition: Session.cpp:996
const MessageStore * getStore()
Definition: Session.h:228
void generateBusinessReject(const Message &, int err, int field=0)
Definition: Session.cpp:931
void logout(const std::string &reason="")
Definition: Session.h:57
void setLogonTimeout(int value)
Definition: Session.h:154
Mutex m_mutex
Definition: Session.h:340
const TimeRange & getLogonTime()
Definition: Session.h:117
void fill(Header &)
Definition: Session.cpp:114
void setResponder(Responder *pR)
Definition: Session.h:210
Date and Time represented in UTC.
Definition: FieldTypes.h:582
Maintains all of state for the Session class.
Definition: SessionState.h:37
bool m_resetOnDisconnect
Definition: Session.h:329
TimeRange m_sessionTime
Definition: Session.h:318
bool getResetOnDisconnect()
Definition: Session.h:172
bool doTargetTooLow(const Message &msg)
Definition: Session.cpp:1186
void setValidateLengthAndChecksum(bool value)
Definition: Session.h:207
void setCheckLatency(bool value)
Definition: Session.h:144
const int BeginString
bool m_persistMessages
Definition: Session.h:332
std::set< SessionID > SessionIDs
Definition: Session.h:232
void setResetOnDisconnect(bool value)
Definition: Session.h:174
const int MsgSeqNum
void setNextTargetMsgSeqNum(int num)
Definition: Session.h:72
Unique session id consists of BeginString, SenderCompID and TargetCompID.
Definition: SessionID.h:30
bool m_sendRedundantResendRequests
Definition: Session.h:323
Responder * m_pResponder
Definition: Session.h:339
void insertOrigSendingTime(Header &, const UtcTimeStamp &when=UtcTimeStamp())
Definition: Session.cpp:103
bool m_resetOnLogout
Definition: Session.h:328
bool resend(Message &message)
Definition: Session.cpp:643
bool isSessionTime(const UtcTimeStamp &time)
Definition: Session.h:108
void nextQueued(const UtcTimeStamp &timeStamp)
Definition: Session.cpp:1238
int getNextSenderMsgSeqNum() const
Definition: SessionState.h:177
const SenderCompID & getSenderCompID() const
Definition: SessionID.h:55
bool m_refreshOnLogon
Definition: Session.h:330
void setNextSenderMsgSeqNum(int n)
Definition: SessionState.h:181
static Sessions s_registered
Definition: Session.h:344
void nextLogout(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:295
bool sentLogout() const
Definition: SessionState.h:56
static bool isInSameRange(const UtcTimeOnly &start, const UtcTimeOnly &end, const DateTime &time1, const DateTime &time2)
Definition: TimeRange.h:76
void setTargetDefaultApplVerID(const std::string &targetDefaultApplVerID)
Definition: Session.h:129
IO Error.
Definition: Exceptions.h:238
const int MsgType
void nextSequenceReset(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:319
void logon()
Definition: Session.h:55
bool isAcceptor()
Definition: Session.h:114
bool doPossDup(const Message &msg)
Definition: Session.cpp:1158
std::map< SessionID, Session *> Sessions
Definition: Session.h:231
static bool doesSessionExist(const SessionID &)
Definition: Session.cpp:1490
bool isLoggedOn()
Definition: Session.h:65

Generated on Sun Apr 15 2018 21:44:02 for QuickFIX by doxygen 1.8.13 written by Dimitri van Heesch, © 1997-2001