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_millisecondsInTimeStamp; }
184  void setMillisecondsInTimeStamp ( bool value )
185  { m_millisecondsInTimeStamp = value; }
186 
188  { return m_persistMessages; }
189  void setPersistMessages ( bool value )
190  { m_persistMessages = value; }
191 
193  { return m_validateLengthAndChecksum; }
194  void setValidateLengthAndChecksum ( bool value )
195  { m_validateLengthAndChecksum = value; }
196 
198  {
200  reset();
201  m_pResponder = pR;
202  }
203 
204  bool send( Message& );
205  void next();
206  void next( const UtcTimeStamp& timeStamp );
207  void next( const std::string&, const UtcTimeStamp& timeStamp, bool queued = false );
208  void next( const Message&, const UtcTimeStamp& timeStamp, bool queued = false );
209  void disconnect();
210 
213 
214  Log* getLog() { return &m_state; }
215  const MessageStore* getStore() { return &m_state; }
216 
217  const HeartBtInt& getHeartBtInt() const { return m_state.heartBtInt(); }
218 
219 private:
220  typedef std::map < SessionID, Session* > Sessions;
221  typedef std::set < SessionID > SessionIDs;
222 
223  static bool addSession( Session& );
224  static void removeSession( Session& );
225 
226  bool send( const std::string& );
227  bool sendRaw( Message&, int msgSeqNum = 0 );
228  bool resend( Message& message );
229  void persist( const Message&, const std::string& ) throw ( IOException );
230 
231  void insertSendingTime( Header& );
233  const UtcTimeStamp& when = UtcTimeStamp () );
234  void fill( Header& );
235 
236  bool isGoodTime( const SendingTime& sendingTime )
237  {
238  if ( !m_checkLatency ) return true;
239  UtcTimeStamp now;
240  return labs( now - sendingTime ) <= m_maxLatency;
241  }
242  bool checkSessionTime( const UtcTimeStamp& timeStamp )
243  {
244  UtcTimeStamp creationTime = m_state.getCreationTime();
245  return m_sessionTime.isInSameRange( timeStamp, creationTime );
246  }
247  bool isTargetTooHigh( const MsgSeqNum& msgSeqNum )
248  { return msgSeqNum > ( m_state.getNextTargetMsgSeqNum() ); }
249  bool isTargetTooLow( const MsgSeqNum& msgSeqNum )
250  { return msgSeqNum < ( m_state.getNextTargetMsgSeqNum() ); }
251  bool isCorrectCompID( const SenderCompID& senderCompID,
252  const TargetCompID& targetCompID )
253  {
254  if( !m_checkCompId ) return true;
255 
256  return
257  m_sessionID.getSenderCompID().getValue() == targetCompID.getValue()
258  && m_sessionID.getTargetCompID().getValue() == senderCompID.getValue();
259  }
260  bool shouldSendReset();
261 
262  bool validLogonState( const MsgType& msgType );
263  void fromCallback( const MsgType& msgType, const Message& msg,
264  const SessionID& sessionID );
265 
266  void doBadTime( const Message& msg );
267  void doBadCompID( const Message& msg );
268  bool doPossDup( const Message& msg );
269  bool doTargetTooLow( const Message& msg );
270  void doTargetTooHigh( const Message& msg );
271  void nextQueued( const UtcTimeStamp& timeStamp );
272  bool nextQueued( int num, const UtcTimeStamp& timeStamp );
273 
274  void nextLogon( const Message&, const UtcTimeStamp& timeStamp );
275  void nextHeartbeat( const Message&, const UtcTimeStamp& timeStamp );
276  void nextTestRequest( const Message&, const UtcTimeStamp& timeStamp );
277  void nextLogout( const Message&, const UtcTimeStamp& timeStamp );
278  void nextReject( const Message&, const UtcTimeStamp& timeStamp );
279  void nextSequenceReset( const Message&, const UtcTimeStamp& timeStamp );
280  void nextResendRequest( const Message&, const UtcTimeStamp& timeStamp );
281 
282  void generateLogon();
283  void generateLogon( const Message& );
284  void generateResendRequest( const BeginString&, const MsgSeqNum& );
285  void generateSequenceReset( int, int );
286  void generateHeartbeat();
287  void generateHeartbeat( const Message& );
288  void generateTestRequest( const std::string& );
289  void generateReject( const Message&, int err, int field = 0 );
290  void generateReject( const Message&, const std::string& );
291  void generateBusinessReject( const Message&, int err, int field = 0 );
292  void generateLogout( const std::string& text = "" );
293 
294  void populateRejectReason( Message&, int field, const std::string& );
295  void populateRejectReason( Message&, const std::string& );
296 
297  bool verify( const Message& msg,
298  bool checkTooHigh = true, bool checkTooLow = true );
299 
300  bool set( int s, const Message& m );
301  bool get( int s, Message& m ) const;
302 
307 
321 
328 
329  static Sessions s_sessions;
330  static SessionIDs s_sessionIDs;
331  static Sessions s_registered;
332  static Mutex s_mutex;
333 
334 };
335 }
336 
337 #endif //FIX_SESSION_H
bool getCheckLatency()
Definition: Session.h:142
int getExpectedTargetNum()
Definition: Session.h:212
int logonTimeout() const
Definition: SessionState.h:71
bool isEnabled()
Definition: Session.h:59
bool getCheckCompId()
Definition: Session.h:137
static Session * lookupSession(const SessionID &)
Definition: Session.cpp:1403
virtual ~Session()
Definition: Session.cpp:83
int getNextTargetMsgSeqNum() const
Definition: SessionState.h:179
void populateRejectReason(Message &, int field, const std::string &)
Definition: Session.cpp:916
bool isGoodTime(const SendingTime &sendingTime)
Definition: Session.h:236
bool send(Message &)
Definition: Session.cpp:452
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:941
Keeps track of when session is active.
Definition: TimeRange.h:34
const int HeartBtInt
int getExpectedSenderNum()
Definition: Session.h:211
bool enabled() const
Definition: SessionState.h:50
DataDictionaryProvider m_dataDictionaryProvider
Definition: Session.h:323
bool getValidateLengthAndChecksum()
Definition: Session.h:192
void generateHeartbeat()
Definition: Session.cpp:685
const DataDictionaryProvider & getDataDictionaryProvider() const
Definition: Session.h:79
static void unregisterSession(const SessionID &)
Definition: Session.cpp:1454
bool isInitiator()
Definition: Session.h:112
const HeartBtInt & getHeartBtInt() const
Definition: Session.h:217
Maintains the state and implements the logic of a FIX session.
Definition: Session.h:45
void doBadTime(const Message &msg)
Definition: Session.cpp:1053
void nextReject(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:312
MessageStoreFactory & m_messageStoreFactory
Definition: Session.h:324
bool sentLogon()
Definition: Session.h:62
static bool addSession(Session &)
Definition: Session.cpp:1466
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:1460
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:459
bool m_checkLatency
Definition: Session.h:312
SessionID m_sessionID
Definition: Session.h:304
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:1024
void setNextSenderMsgSeqNum(int num)
Definition: Session.h:70
void nextResendRequest(const Message &, const UtcTimeStamp &timeStamp)
Definition: Session.cpp:344
bool getPersistMessages()
Definition: Session.h:187
void generateResendRequest(const BeginString &, const MsgSeqNum &)
Definition: Session.cpp:643
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:1438
bool m_checkCompId
Definition: Session.h:311
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 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:249
const int SendingTime
static Sessions s_sessions
Definition: Session.h:329
Definition: Acceptor.cpp:34
bool getResetOnLogon()
Definition: Session.h:162
static Session * registerSession(const SessionID &)
Definition: Session.cpp:1444
void doTargetTooHigh(const Message &msg)
Definition: Session.cpp:1113
Log * getLog()
Definition: Session.h:214
void generateLogon()
Definition: Session.cpp:602
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:666
This interface must be implemented to define what your FIX application does.
Definition: Application.h:43
void setPersistMessages(bool value)
Definition: Session.h:189
static std::set< SessionID > getSessions()
Definition: Session.cpp:1392
static bool sendToTarget(Message &message, const std::string &qualifier="")
Definition: Session.cpp:1351
int m_maxLatency
Definition: Session.h:313
Application & m_application
Definition: Session.h:303
bool getResetOnLogout()
Definition: Session.h:167
bool m_resetOnLogon
Definition: Session.h:314
std::string m_senderDefaultApplVerID
Definition: Session.h:308
LogFactory * m_pLogFactory
Definition: Session.h:325
void disconnect()
Definition: Session.cpp:542
void persist(const Message &, const std::string &)
Definition: Session.cpp:592
static SessionIDs s_sessionIDs
Definition: Session.h:330
bool isTargetTooHigh(const MsgSeqNum &msgSeqNum)
Definition: Session.h:247
int getLogonTimeout()
Definition: Session.h:152
const int TargetCompID
bool m_millisecondsInTimeStamp
Definition: Session.h:318
static Mutex s_mutex
Definition: Session.h:332
TimeRange m_logonTime
Definition: Session.h:306
void generateReject(const Message &, int err, int field=0)
Definition: Session.cpp:720
void setMaxLatency(int value)
Definition: Session.h:149
SessionState m_state
Definition: Session.h:322
std::string m_targetDefaultApplVerID
Definition: Session.h:309
This interface must be implemented to create a Log.
Definition: Log.h:42
bool receivedLogon() const
Definition: SessionState.h:53
Base class for all FIX messages.
Definition: Message.h:67
int getLogoutTimeout()
Definition: Session.h:157
bool sentLogout()
Definition: Session.h:63
bool m_validateLengthAndChecksum
Definition: Session.h:320
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:242
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:1044
bool shouldSendReset()
Definition: Session.cpp:1013
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:251
const int SenderCompID
const std::string & getTargetDefaultApplVerID()
Definition: Session.h:127
void generateTestRequest(const std::string &)
Definition: Session.cpp:709
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:1480
void doBadCompID(const Message &msg)
Definition: Session.cpp:1059
void generateLogout(const std::string &text="")
Definition: Session.cpp:905
const MessageStore * getStore()
Definition: Session.h:215
void generateBusinessReject(const Message &, int err, int field=0)
Definition: Session.cpp:842
void logout(const std::string &reason="")
Definition: Session.h:57
void setLogonTimeout(int value)
Definition: Session.h:154
Mutex m_mutex
Definition: Session.h:327
const TimeRange & getLogonTime()
Definition: Session.h:117
void fill(Header &)
Definition: Session.cpp:114
void setResponder(Responder *pR)
Definition: Session.h:197
Date and Time represented in UTC.
Definition: FieldTypes.h:399
Maintains all of state for the Session class.
Definition: SessionState.h:37
bool m_resetOnDisconnect
Definition: Session.h:316
TimeRange m_sessionTime
Definition: Session.h:305
bool getResetOnDisconnect()
Definition: Session.h:172
bool doTargetTooLow(const Message &msg)
Definition: Session.cpp:1093
void setValidateLengthAndChecksum(bool value)
Definition: Session.h:194
void setCheckLatency(bool value)
Definition: Session.h:144
const int BeginString
bool m_persistMessages
Definition: Session.h:319
std::set< SessionID > SessionIDs
Definition: Session.h:221
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:310
Responder * m_pResponder
Definition: Session.h:326
void insertOrigSendingTime(Header &, const UtcTimeStamp &when=UtcTimeStamp())
Definition: Session.cpp:103
bool m_resetOnLogout
Definition: Session.h:315
bool resend(Message &message)
Definition: Session.cpp:572
bool isSessionTime(const UtcTimeStamp &time)
Definition: Session.h:108
void nextQueued(const UtcTimeStamp &timeStamp)
Definition: Session.cpp:1145
int getNextSenderMsgSeqNum() const
Definition: SessionState.h:177
const SenderCompID & getSenderCompID() const
Definition: SessionID.h:55
bool m_refreshOnLogon
Definition: Session.h:317
void setNextSenderMsgSeqNum(int n)
Definition: SessionState.h:181
static Sessions s_registered
Definition: Session.h:331
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 heartBtInt(const HeartBtInt &value)
Definition: SessionState.h:94
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:1065
std::map< SessionID, Session *> Sessions
Definition: Session.h:220
static bool doesSessionExist(const SessionID &)
Definition: Session.cpp:1397
bool isLoggedOn()
Definition: Session.h:65

Generated on Thu Sep 5 2019 11:07:58 for QuickFIX by doxygen 1.8.13 written by Dimitri van Heesch, © 1997-2001