Fix8 Base Session. User sessions are derived from this class. More...

#include <session.hpp>

Inheritance diagram for FIX8::Session:

Classes
struct	RetransmissionContext
	Provides context to your retrans handler. More...

Public Types
enum	SessionControl { shutdown, print, printnohb, debug, count }

using	Control = ebitset_r< SessionControl >

using	SequencePair = std::pair< const unsigned, const f8String >

Public Member Functions
F8API	Session (const F8MetaCntx &ctx, const SessionID &sid, Persister persist=nullptr, Logger logger=nullptr, Logger *plogger=nullptr)

F8API	Session (const F8MetaCntx &ctx, const sender_comp_id &sci=sender_comp_id(), Persister persist=nullptr, Logger logger=nullptr, Logger *plogger=nullptr)

virtual F8API	~Session ()
	Dtor. More...

F8API int	start (Connection *connection, bool wait=true, const unsigned send_seqnum=0, const unsigned recv_seqnum=0, const f8String davi=f8String())

void	clear_connection (const Connection *connection)

virtual F8API bool	process (const f8String &from)

virtual F8API bool	retrans_callback (const SequencePair &with, RetransmissionContext &rctx)

virtual F8API bool	send (Message *msg, bool destroy=true, const unsigned custom_seqnum=0, const bool no_increment=false)

virtual F8API bool	send (Message &msg, const unsigned custom_seqnum=0, const bool no_increment=false)

virtual F8API size_t	send_batch (const std::vector< Message * > &msgs, bool destroy=true)

F8API bool	send_process (Message *msg)

virtual F8API int	modify_header (MessageBase *msg)

F8API void	update_persist_seqnums ()
	Force persister to sync next send/receive seqnums. More...

F8API void	stop ()
	stop the session. More...

Connection *	get_connection ()

Timer< Session > &	get_timer ()

const F8MetaCntx &	get_ctx () const

bool	is_loggable (Logger::Level level) const

bool	enqueue (const std::string &what, Logger::Level lev, const char *fl=nullptr, unsigned value=0) const

bool	log (const std::string &what, Logger::Level lev, const char *fl=nullptr, unsigned value=0) const

bool	plog (const std::string &what, Logger::Level lev, const unsigned direction=0) const

const Tickval &	get_last_received () const

const Tickval &	get_last_sent () const

void	update_sent ()
	Update the last sent time. More...

void	update_received ()
	Update the last received time. More...

F8API void	compid_check (const unsigned seqnum, const Message *msg, const SessionID &id) const

F8API bool	sequence_check (const unsigned seqnum, const Message *msg)

virtual bool	activation_check (const unsigned seqnum, const Message *msg)

F8API bool	enforce (const unsigned seqnum, const Message *msg)

const SessionID &	get_sid () const

unsigned	get_next_send_seq () const

void	set_login_parameters (const LoginParameters &loginParamaters)

void	get_login_parameters (LoginParameters &loginParamaters) const

const LoginParameters &	get_login_parameters () const

void	set_reset_sequence_numbers_flag (bool flag)

void	set_persister (Persister *pst)

Control &	control ()

bool	is_shutdown ()

void	set_session_config (struct SessionConfig *sf)

virtual F8API Message *	generate_logout (const char *msgstr=nullptr)

virtual F8API Message *	generate_heartbeat (const f8String &testReqID)

virtual F8API Message *	generate_resend_request (const unsigned begin, const unsigned end=0)

virtual F8API Message *	generate_sequence_reset (const unsigned newseqnum, const bool gapfillflag=false)

virtual F8API Message *	generate_test_request (const f8String &testReqID)

virtual F8API Message *	generate_reject (const unsigned seqnum, const char what, const char msgtype=nullptr)

virtual F8API Message *	generate_business_reject (const unsigned seqnum, const Message msg, const int reason, const char what)

void	do_state_change (const States::SessionStates new_state)

States::SessionStates	get_session_state () const

Static Public Member Functions
static const Message *	detach (const Message *&msg)

static const f8String &	get_session_state_string (const States::SessionStates state)

static F8API const f8String	copyright_string ()

Protected Member Functions
F8API bool	heartbeat_service ()
	Heartbeat generation service thread method. More...

F8API bool	activation_service ()
	Session start/stop service thread method. More...

virtual F8API bool	handle_logon (const unsigned seqnum, const Message *msg)

virtual F8API Message *	generate_logon (const unsigned heartbeat_interval, const f8String davi=f8String())

virtual F8API bool	handle_logout (const unsigned seqnum, const Message *msg)

virtual F8API bool	handle_heartbeat (const unsigned seqnum, const Message *msg)

virtual F8API bool	handle_resend_request (const unsigned seqnum, const Message *msg)

virtual F8API bool	handle_sequence_reset (const unsigned seqnum, const Message *msg)

virtual F8API bool	handle_test_request (const unsigned seqnum, const Message *msg)

virtual bool	handle_reject (const unsigned seqnum, const Message *msg)

virtual bool	handle_admin (const unsigned seqnum, const Message *msg)

virtual F8API bool	handle_outbound_reject (const unsigned seqnum, const Message msg, const char errstr)

virtual bool	handle_application (const unsigned seqnum, const Message *&msg)=0

virtual void	state_change (const States::SessionStates before, const States::SessionStates after)

virtual void	modify_outbound (Message *msg)

virtual bool	authenticate (SessionID &id, const Message *msg)

virtual F8API void	recover_seqnums ()
	Recover next expected and next to send sequence numbers from persitence layer. More...

Message *	create_msg (const f8String &msg_type) const

void	set_scheduler (int priority)

void	set_affinity (int core_id)

Protected Attributes
Control	_control

f8_atomic< unsigned >	_next_send_seq

f8_atomic< unsigned >	_next_receive_seq

f8_atomic< States::SessionStates >	_state

f8_atomic< bool >	_active

Tickval	_last_sent

Tickval	_last_received

const F8MetaCntx &	_ctx

sender_comp_id	_sci

Connection *	_connection

unsigned	_req_next_send_seq

unsigned	_req_next_receive_seq

SessionID	_sid

struct SessionConfig *	_sf

LoginParameters	_loginParameters

f8_spin_lock	_per_spl

Persister *	_persist

Logger *	_logger

Logger *	_plogger

Timer< Session >	_timer

TimerEvent< Session >	_hb_processor

TimerEvent< Session >	_session_scheduler

std::string	_batchmsgs_buffer

Session_Schedule *	_schedule

Static Protected Attributes
static F8API const std::vector< f8String >	_state_names
	string representation of Sessionstates More...

Private Member Functions
void	atomic_init (States::SessionStates st)

Detailed Description

Fix8 Base Session. User sessions are derived from this class.

Definition at line 394 of file session.hpp.

Member Typedef Documentation

using FIX8::Session::Control = ebitset_r<SessionControl>

Definition at line 403 of file session.hpp.

using FIX8::Session::SequencePair = std::pair<const unsigned, const f8String>

Definition at line 615 of file session.hpp.

Member Enumeration Documentation

enum FIX8::Session::SessionControl

Enumerator
shutdown
print
printnohb
debug
count

Definition at line 401 of file session.hpp.

401 { shutdown, print, printnohb, debug, count };

FIX8::Session::count

Definition: session.hpp:401

FIX8::Session::printnohb

Definition: session.hpp:401

FIX8::Session::print

Definition: session.hpp:401

FIX8::Session::debug

Definition: session.hpp:401

FIX8::Session::shutdown

Definition: session.hpp:401

Constructor & Destructor Documentation

Session::Session	(	const F8MetaCntx &	ctx,
		const SessionID &	sid,
		Persister *	persist = `nullptr`,
		Logger *	logger = `nullptr`,
		Logger *	plogger = `nullptr`
	)

Ctor. Initiator.

Parameters

ctx	reference to generated metadata
sid	sessionid of connecting session
persist	persister for this session
logger	logger for this session
plogger	protocol logger for this session

Definition at line 105 of file session.cpp.

References _batchmsgs_buffer, _logger, _persist, _plogger, _sid, _timer, FIX8_MAX_MSG_LENGTH, glout_warn, and FIX8::HEADER_CALC_OFFSET().

                                                                                                                  :
 _state(States::st_none),
 _ctx(ctx), _connection(), _req_next_send_seq(), _req_next_receive_seq(),
    _sid(sid), _sf(), _persist(persist), _logger(logger), _plogger(plogger),   // initiator
    _timer(*this, 10), _hb_processor(&Session::heartbeat_service, true),
    _session_scheduler(&Session::activation_service, true), _schedule()
 {
    _timer.start();
    _batchmsgs_buffer.reserve(10 * (FIX8_MAX_MSG_LENGTH + HEADER_CALC_OFFSET));
 
    if (!_logger)
    {
       glout_warn << "Warning: no session logger defined for " << _sid;
    }
 
    if (!_plogger)
    {
       glout_warn << "Warning: no protocol logger defined for " << _sid;
    }
 
    if (!_persist)
    {
       glout_warn << "Warning: no persister defined for " << _sid;
    }
 }

Session::Session	(	const F8MetaCntx &	ctx,
		const sender_comp_id &	sci = `sender_comp_id()`,
		Persister *	persist = `nullptr`,
		Logger *	logger = `nullptr`,
		Logger *	plogger = `nullptr`
	)

Ctor. Acceptor.

Parameters

ctx	reference to generated metadata
sci	sender comp id of hosting session
persist	persister for this session
logger	logger for this session
plogger	protocol logger for this session

Definition at line 132 of file session.cpp.

References _batchmsgs_buffer, _timer, FIX8_MAX_MSG_LENGTH, and FIX8::HEADER_CALC_OFFSET().

                                                                                                                       :
 _state(States::st_none),
 _ctx(ctx), _sci(sci), _connection(), _req_next_send_seq(), _req_next_receive_seq(),
    _sf(), _persist(persist), _logger(logger), _plogger(plogger),  // acceptor
    _timer(*this, 10), _hb_processor(&Session::heartbeat_service, true),
    _session_scheduler(&Session::activation_service, true), _schedule()
 {
    _timer.start();
    _batchmsgs_buffer.reserve(10 * (FIX8_MAX_MSG_LENGTH + HEADER_CALC_OFFSET));
 }

Session::~Session ( )

virtual

Dtor.

Definition at line 152 of file session.cpp.

References _connection, _logger, _per_spl, _persist, _plogger, _schedule, FIX8::Connection::cn_acceptor, FIX8::Connection::get_role(), FIX8::hypersleep< h_seconds >(), slout_info, and FIX8::Logger::stop().

 {
    slout_info << "Session terminating";
    if (_logger)
       _logger->stop();
    if (_plogger)
       _plogger->stop();
    hypersleep<h_seconds>(1); // needed for service threads to exit gracefully
 
    if (_connection && _connection->get_role() == Connection::cn_acceptor)
       { f8_scoped_spin_lock guard(_per_spl); delete _persist; _persist = 0; }
    delete _schedule;
 }

Member Function Documentation

virtual bool FIX8::Session::activation_check	(	const unsigned	seqnum,
		const Message *	msg
	)

inlinevirtual

Check that the session is active for this application message

Parameters

seqnum	message sequence number
msg	Message

Returns: true if active

Definition at line 736 of file session.hpp.

References _active.

Referenced by process().

736 { return _active; }

FIX8::Session::_active

f8_atomic< bool > _active

Definition: session.hpp:409

bool Session::activation_service ( )

protected

Session start/stop service thread method.

Definition at line 788 of file session.cpp.

References _active, _connection, FIX8::Session_Schedule::_sch, _schedule, FIX8::Connection::is_connected(), is_shutdown(), slout_info, and FIX8::Schedule::test().

 {
    //cout << "activation_service()" << endl;
    if (is_shutdown())
       return false;
 
    if (_connection && _connection->is_connected())
    {
       const bool curr(_active);
       _active = _schedule->_sch.test(curr);
       if (curr != _active)
       {
          slout_info << "Session activation transitioned to " << (_active ? "active" : "inactive");
       }
    }
 
    return true;
 }

void Session::atomic_init ( States::SessionStates st )

private

Initialise atomic members.

Parameters

st	the initial session state

Definition at line 144 of file session.cpp.

References _active, _next_receive_seq, _next_send_seq, and do_state_change().

Referenced by start().

 {
    do_state_change(st);
    _next_send_seq = _next_receive_seq = 1;
    _active = true;
 }

virtual bool FIX8::Session::authenticate	(	SessionID &	id,
		const Message *	msg
	)

inlineprotectedvirtual

Call user defined authentication with logon message.

Parameters

id	Session id of inbound connection
msg	Message

Returns: true on success

Definition at line 520 of file session.hpp.

Referenced by handle_logon().

520 { return true; }

void FIX8::Session::clear_connection ( const Connection * connection )

inline

Clear reference to connection. Called by ~Connection() to clear reference.

Parameters

connection being deleted

Definition at line 586 of file session.hpp.

Referenced by FIX8::Connection::~Connection().

    {
       if (connection == _connection)
          _connection = nullptr;
    }

void Session::compid_check	(	const unsigned	seqnum,
		const Message *	msg,
		const SessionID &	id
	)		const

Check that a message has the correct sender/target compid for this session. Throws BadCompidId on error.

Parameters

seqnum	message sequence number
msg	Message
id	Session id of inbound connection

Definition at line 415 of file session.cpp.

References FIX8::LoginParameters::_enforce_compids, _loginParameters, FIX8::MessageBase::get(), and FIX8::Message::Header().

Referenced by enforce().

 {
    if (_loginParameters._enforce_compids)
    {
       if (!id.same_sender_comp_id(msg->Header()->get<target_comp_id>()->get()))
          throw BadCompidId(msg->Header()->get<target_comp_id>()->get());
       if (!id.same_target_comp_id(msg->Header()->get<sender_comp_id>()->get()))
          throw BadCompidId(msg->Header()->get<sender_comp_id>()->get());
    }
 }

Control& FIX8::Session::control ( )

inline

Get the control object for this session.

Returns: the control object

Definition at line 774 of file session.hpp.

References _control.

774 { return _control; }

FIX8::Session::_control

Control _control

Definition: session.hpp:406

const f8String Session::copyright_string ( )

static

Return the version and copyright for this version

Returns: string

Definition at line 1207 of file session.cpp.

Referenced by start().

 {
    time_t now(time(0));
 #ifdef _MSC_VER
    struct tm *ptim(localtime (&now));
 #else
    struct tm tim;
    localtime_r(&now, &tim);
    struct tm *ptim(&tim);
 #endif
    ostringstream ostr;
    ostr << endl << package_version << ' ' << copyright_short << setw(2) << (ptim->tm_year - 100) << copyright_short2;
    return ostr.str();
 }

Message* FIX8::Session::create_msg ( const f8String & msg_type ) const

inlineprotected

Create a new Fix message from metadata layer.

Parameters

msg_type message type string

Returns: new Message

Definition at line 528 of file session.hpp.

References FIX8::F8MetaCntx::_bme, FIX8::BaseMsgEntry::_create, FIX8::Minst::_do, and FIX8::GeneratedTable< Key, Val >::find_ptr().

Referenced by generate_business_reject(), generate_heartbeat(), generate_logon(), generate_logout(), generate_reject(), generate_resend_request(), generate_sequence_reset(), and generate_test_request().

    {
       const BaseMsgEntry *bme(_ctx._bme.find_ptr(msg_type.c_str()));
       if (!bme)
          throw InvalidMetadata<f8String>(msg_type);
       return bme->_create._do(true);
    }

static const Message* FIX8::Session::detach ( const Message *& msg )

inlinestatic

Detach message passed to handle_application. Will set source to 0; Not thread safe and should never be called across threads. It should only be called from Session::handle_application().

Parameters

msg	ref to ptr containing message

Returns: detached Message *

Definition at line 843 of file session.hpp.

    {
       const Message *tmp(msg);
       msg = 0;
       return tmp;
    }

void FIX8::Session::do_state_change ( const States::SessionStates new_state )

inline

Call the virtual state_change method with before and after, then set the new state

Parameters

new_state new session state to set

Definition at line 827 of file session.hpp.

References state_change().

Referenced by atomic_init(), handle_heartbeat(), handle_logon(), handle_resend_request(), handle_sequence_reset(), heartbeat_service(), process(), retrans_callback(), sequence_check(), and start().

    {
       const States::SessionStates old_state(_state.exchange(new_state));
       if (old_state != new_state)
          state_change(old_state, new_state);
    }

bool Session::enforce	(	const unsigned	seqnum,
		const Message *	msg
	)

Enforce session semantics. Checks compids, sequence numbers.

Parameters

seqnum	message sequence number
msg	Message

Returns: true if message FAILS enforce rules

Definition at line 252 of file session.cpp.

References _sid, _state, FIX8::Common_MsgType_SEQUENCE_RESET(), compid_check(), FIX8::MessageBase::get_msgtype(), FIX8::States::is_established(), sequence_check(), and FIX8::States::st_logon_received.

Referenced by handle_heartbeat(), handle_logon(), handle_logout(), handle_resend_request(), handle_sequence_reset(), and handle_test_request().

 {
    if (States::is_established(_state))
    {
       if (_state != States::st_logon_received)
          compid_check(seqnum, msg, _sid);
       if (msg->get_msgtype() != Common_MsgType_SEQUENCE_RESET && sequence_check(seqnum, msg))
          return false;
    }
 
    return true;
 }

bool FIX8::Session::enqueue	(	const std::string &	what,
		Logger::Level	lev,
		const char *	fl = `nullptr`,
		unsigned	value = `0`
	)		const

inline

Log a message to the session logger. Do not check for level permission

Parameters

what	string to log
lev	log level
fl	pointer to fileline
value	optional value for the logger to use

Returns: true on success

Definition at line 686 of file session.hpp.

References FIX8::Logger::enqueue().

687 { return _logger ? _logger->enqueue(what, lev, fl, value) : false; }

FIX8::Session::_logger

Logger * _logger

Definition: session.hpp:422

FIX8::Logger::enqueue

bool enqueue(const std::string &what, Level lev=Logger::Info, const char *fl=nullptr, const unsigned val=0)

Definition: logger.hpp:294

Message * Session::generate_business_reject	(	const unsigned	seqnum,
		const Message *	msg,
		const int	reason,
		const char *	what
	)

virtual

Generate a business_reject message.

Parameters

seqnum	message sequence number
msg	source message
reason	rejection reason code
what	rejection text

Returns: new Message

Definition at line 901 of file session.cpp.

References FIX8::Common_MsgType_BUSINESS_REJECT(), create_msg(), and FIX8::MessageBase::get_msgtype().

 {
    Message *msg;
    try
    {
       msg = create_msg(Common_MsgType_BUSINESS_REJECT);
    }
    catch (InvalidMetadata<f8String>&)
    {
       // since this is an application message, it may not be supported in supplied schema
       return nullptr;
    }
 
    *msg << new ref_seq_num(seqnum);
    *msg << new ref_msg_type(imsg->get_msgtype());
    *msg << new business_reject_reason(reason);
    if (what)
       *msg << new text(what);
 
    return msg;
 }

Message * Session::generate_heartbeat ( const f8String & testReqID )

virtual

Generate a heartbeat message.

Parameters

testReqID test request id

Returns: new Message

Definition at line 878 of file session.cpp.

References FIX8::Common_MsgType_HEARTBEAT(), and create_msg().

Referenced by handle_test_request(), and heartbeat_service().

 {
    Message *msg(create_msg(Common_MsgType_HEARTBEAT));
    if (!testReqID.empty())
       *msg << new test_request_id(testReqID);
 
    return msg;
 }

Message * Session::generate_logon	(	const unsigned	heartbeat_interval,
		const f8String	davi = `f8String()`
	)

protectedvirtual

Generate a logon message.

Parameters

heartbeat_interval	heartbeat interval
davi	default appl version id (FIXT)

Returns: new Message

Definition at line 933 of file session.cpp.

References _loginParameters, FIX8::LoginParameters::_reset_sequence_numbers, FIX8::Common_MsgType_LOGON(), create_msg(), and FIX8::MessageBase::is_legal().

Referenced by handle_logon(), and start().

 {
    Message *msg(create_msg(Common_MsgType_LOGON));
    *msg << new heartbeat_interval(heartbtint)
         << new encrypt_method(0); // FIXME
    if (!davi.empty() && msg->is_legal<default_appl_ver_id>())
       *msg << new default_appl_ver_id(davi);
    if (_loginParameters._reset_sequence_numbers)
       *msg << new reset_seqnum_flag(true);
 
    return msg;
 }

Message * Session::generate_logout ( const char * msgstr = nullptr )

virtual

Generate a logout message.

Returns: new Message

Definition at line 947 of file session.cpp.

References FIX8::Common_MsgType_LOGOUT(), and create_msg().

Referenced by heartbeat_service(), and process().

 {
    Message *msg(create_msg(Common_MsgType_LOGOUT));
    if (msgstr)
       *msg << new text(msgstr);
 
    return msg;
 }

Message * Session::generate_reject	(	const unsigned	seqnum,
		const char *	what,
		const char *	msgtype = `nullptr`
	)

virtual

Generate a reject message.

Parameters

seqnum	message sequence number
what	rejection text
msgtype	offending msgtype

Returns: new Message

Definition at line 888 of file session.cpp.

References FIX8::Common_MsgType_REJECT(), and create_msg().

Referenced by handle_logon(), and handle_outbound_reject().

 {
    Message *msg(create_msg(Common_MsgType_REJECT));
    *msg << new ref_seq_num(seqnum);
    if (what)
       *msg << new text(what);
    if (msgtype)
       *msg << new ref_msg_type(msgtype);
 
    return msg;
 }

Message * Session::generate_resend_request	(	const unsigned	begin,
		const unsigned	end = `0`
	)

virtual

Generate a resend request message.

Parameters

begin	begin sequence number
end	sequence number

Returns: new Message

Definition at line 957 of file session.cpp.

References FIX8::Common_MsgType_RESEND_REQUEST(), and create_msg().

Referenced by sequence_check().

 {
    Message *msg(create_msg(Common_MsgType_RESEND_REQUEST));
    *msg << new begin_seq_num(begin) << new end_seq_num(end);
 
    return msg;
 }

Message * Session::generate_sequence_reset	(	const unsigned	newseqnum,
		const bool	gapfillflag = `false`
	)

virtual

Generate a sequence reset message.

Parameters

newseqnum	new sequence number
gapfillflag	gap fill flag

Returns: new Message

Definition at line 966 of file session.cpp.

References FIX8::Common_MsgType_SEQUENCE_RESET(), and create_msg().

Referenced by handle_resend_request(), and retrans_callback().

 {
    Message *msg(create_msg(Common_MsgType_SEQUENCE_RESET));
    *msg << new new_seq_num(newseqnum);
 
    if (gapfillflag)
       *msg << new gap_fill_flag(true);
 
    return msg;
 }

Message * Session::generate_test_request ( const f8String & testReqID )

virtual

Generate a test request message.

Parameters

testReqID test request id

Returns: new Message

Definition at line 924 of file session.cpp.

References FIX8::Common_MsgType_TEST_REQUEST(), and create_msg().

Referenced by heartbeat_service().

 {
    Message *msg(create_msg(Common_MsgType_TEST_REQUEST));
    *msg << new test_request_id(testReqID);
 
    return msg;
 }

Connection* FIX8::Session::get_connection ( )

inline

Get the connection object.

Returns: the connection object

Definition at line 665 of file session.hpp.

References _connection.

Referenced by MyMenu::send_all_preloaded().

665 { return _connection; }

FIX8::Session::_connection

Connection * _connection

Definition: session.hpp:413

const F8MetaCntx& FIX8::Session::get_ctx ( ) const

inline

Get the metadata context object.

Returns: the context object

Definition at line 673 of file session.hpp.

References _ctx.

673 { return _ctx; }

FIX8::Session::_ctx

const F8MetaCntx & _ctx

Definition: session.hpp:411

const Tickval& FIX8::Session::get_last_received ( ) const

inline

Return the last received timstamp

Returns: Tickval on success

Definition at line 708 of file session.hpp.

References _last_received.

708 { return _last_received; }

FIX8::Session::_last_received

Tickval _last_received

Definition: session.hpp:410

const Tickval& FIX8::Session::get_last_sent ( ) const

inline

Return the last sent timstamp

Returns: Tickval on success

Definition at line 712 of file session.hpp.

References _last_sent.

712 { return _last_sent; }

FIX8::Session::_last_sent

Tickval _last_sent

Definition: session.hpp:410

void FIX8::Session::get_login_parameters ( LoginParameters & loginParamaters ) const

inline

Get the LoginParameters

Parameters

loginParamaters to populate

Definition at line 758 of file session.hpp.

References _loginParameters.

758 { loginParamaters = _loginParameters; }

FIX8::Session::_loginParameters

LoginParameters _loginParameters

Definition: session.hpp:418

const LoginParameters& FIX8::Session::get_login_parameters ( ) const

inline

Get the LoginParameters

Returns: loginParamaters

Definition at line 762 of file session.hpp.

References _loginParameters.

762 { return _loginParameters; }

FIX8::Session::_loginParameters

LoginParameters _loginParameters

Definition: session.hpp:418

unsigned FIX8::Session::get_next_send_seq ( ) const

inline

Get the next sender sequence number

Returns: next sender sequence number

Definition at line 750 of file session.hpp.

References _next_send_seq.

Referenced by FIX8::MemoryPersister::get(), and FIX8::FilePersister::get().

750 { return _next_send_seq; }

FIX8::Session::_next_send_seq

f8_atomic< unsigned > _next_send_seq

Definition: session.hpp:407

States::SessionStates FIX8::Session::get_session_state ( ) const

inline

Get the current session state enumeration

Returns: States::SessionStates value

Definition at line 836 of file session.hpp.

References _state.

836 { return _state; }

FIX8::Session::_state

f8_atomic< States::SessionStates > _state

Definition: session.hpp:408

static const f8String& FIX8::Session::get_session_state_string ( const States::SessionStates state )

inlinestatic

Find the string representation for the given session state

Parameters

state session state

Returns: string found or "unknown"

Definition at line 853 of file session.hpp.

    {
       static const f8String unknown("Unknown");
       return state < _state_names.size() ? _state_names[state] : unknown;
    }

const SessionID& FIX8::Session::get_sid ( ) const

inline

Get the session id for this session.

Returns: the session id

Definition at line 746 of file session.hpp.

References _sid.

746 { return _sid; }

FIX8::Session::_sid

SessionID _sid

Definition: session.hpp:415

Timer<Session>& FIX8::Session::get_timer ( )

inline

Get the timer object.

Returns: the timer object

Definition at line 669 of file session.hpp.

References _timer.

669 { return _timer; }

FIX8::Session::_timer

Timer< Session > _timer

Definition: session.hpp:424

virtual bool FIX8::Session::handle_admin	(	const unsigned	seqnum,
		const Message *	msg
	)

inlineprotectedvirtual

Administrative message callback. Called on receipt of all admin messages.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 490 of file session.hpp.

Referenced by process().

490 { return true; }

virtual bool FIX8::Session::handle_application	(	const unsigned	seqnum,
		const Message *&	msg
	)

protectedpure virtual

Application message callback. Called on receipt of all non-admin messages. You must implement this method. The message is passed as a reference to a pointer. Your application can detach and take ownership. If you want to take ownership, take a copy of the pointer and then set msg to 0. See Session::detach()

Parameters

seqnum	message sequence number
msg	reference to Message ptr

Returns: true on success

Implemented in hf_session_server, myfix_session_server, hf_session_client, and myfix_session_client.

Referenced by process().

bool Session::handle_heartbeat	(	const unsigned	seqnum,
		const Message *	msg
	)

protectedvirtual

Heartbeat callback.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 868 of file session.cpp.

References _state, do_state_change(), enforce(), FIX8::States::st_continuous, and FIX8::States::st_test_request_sent.

Referenced by process().

 {
    enforce(seqnum, msg);
 
    if (_state == States::st_test_request_sent)
       do_state_change(States::st_continuous);
    return true;
 }

bool Session::handle_logon	(	const unsigned	seqnum,
		const Message *	msg
	)

protectedvirtual

Logon callback.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 470 of file session.cpp.

References FIX8::F8MetaCntx::_beginStr, FIX8::LoginParameters::_clients, _connection, _ctx, FIX8::LoginParameters::_enforce_compids, _hb_processor, _logger, FIX8::LoginParameters::_login_schedule, _loginParameters, _next_receive_seq, _next_send_seq, _per_spl, _persist, _plogger, _req_next_receive_seq, _req_next_send_seq, _schedule, _sci, FIX8::SessionConfig::_ses, _sf, _sid, _state, _timer, authenticate(), FIX8::Connection::cn_initiator, FIX8::Common_ResetSeqNumFlag(), FIX8::Configuration::create_logger(), FIX8::Configuration::create_persister(), do_state_change(), enforce(), generate_logon(), generate_reject(), FIX8::MessageBase::get(), FIX8::Connection::get_hb_interval(), FIX8::MessageBase::get_msgtype(), FIX8::Connection::get_peer_socket_address(), FIX8::Connection::get_pmodel(), FIX8::Connection::get_role(), FIX8::SessionID::get_senderCompID(), glout_error, glout_info, glout_warn, FIX8::MessageBase::have(), FIX8::Message::Header(), FIX8::Schedule::is_valid(), FIX8::pm_coro, FIX8::Configuration::protocol_log, recover_seqnums(), send(), FIX8::Configuration::session_log, FIX8::Connection::set_hb_interval(), slout_error, slout_info, FIX8::States::st_continuous, FIX8::States::st_logon_received, FIX8::States::st_session_terminated, stop(), and FIX8::Schedule::test().

Referenced by process().

 {
    if (_state == States::st_continuous)
    {
       send(generate_reject(seqnum, "Already logged on"), msg->get_msgtype().c_str());
       return true;
    }
    do_state_change(States::st_logon_received);
    const bool reset_given(msg->have(Common_ResetSeqNumFlag) && msg->get<reset_seqnum_flag>()->get());
    sender_comp_id sci; // so this should be our tci
    msg->Header()->get(sci);
    target_comp_id tci; // so this should be our sci
    msg->Header()->get(tci);
    SessionID id(_ctx._beginStr, tci(), sci());
 
    if (_connection->get_role() == Connection::cn_initiator)
    {
       if (id != _sid)
       {
          glout_warn << "Inbound TargetCompID not recognised (" << tci << "), expecting (" << _sid.get_senderCompID() << ')';
          if (_loginParameters._enforce_compids)
          {
             stop();
             do_state_change(States::st_session_terminated);
             return false;
          }
       }
 
       enforce(seqnum, msg);
       do_state_change(States::st_continuous);
    }
    else // acceptor
    {
       default_appl_ver_id davi;
       msg->get(davi);
 
       if (_sci() != tci())
       {
          glout_warn << "Inbound TargetCompID not recognised (" << tci << "), expecting (" << _sci << ')';
          if (_loginParameters._enforce_compids)
          {
             stop();
             do_state_change(States::st_session_terminated);
             return false;
          }
       }
 
       if (!_loginParameters._clients.empty())
       {
          auto itr(_loginParameters._clients.find(sci()));
          bool iserr(false);
          if (itr == _loginParameters._clients.cend())
          {
             glout_error << "Remote (" << sci << ") not found (" << id << "). NOT authorised to proceed.";
             iserr = true;
          }
 
          if (!iserr && get<1>(itr->second) != Poco::Net::IPAddress()
             && get<1>(itr->second) != _connection->get_peer_socket_address().host())
          {
             glout_error << "Remote (" << get<0>(itr->second) << ", " << sci << ") NOT authorised to proceed ("
                << _connection->get_peer_socket_address().toString() << ").";
             iserr = true;
          }
 
          if (iserr)
          {
             stop();
             do_state_change(States::st_session_terminated);
             return false;
          }
 
          glout_info << "Remote (" << get<0>(itr->second) << ", " << sci << ") authorised to proceed ("
             << _connection->get_peer_socket_address().toString() << ").";
       }
 
       // important - these objects can't be created until we have a valid SessionID
       if (_sf)
       {
          if (!_logger && !(_logger = _sf->create_logger(_sf->_ses, Configuration::session_log, &id)))
          {
             glout_warn << "Warning: no session logger defined for " << id;
          }
 
          if (!_plogger && !(_plogger = _sf->create_logger(_sf->_ses, Configuration::protocol_log, &id)))
          {
             glout_warn << "Warning: no protocol logger defined for " << id;
          }
 
          if (!_persist)
          {
             f8_scoped_spin_lock guard(_per_spl, _connection->get_pmodel() == pm_coro);
             if (!(_persist = _sf->create_persister(_sf->_ses, &id, reset_given)))
             {
                glout_warn << "Warning: no persister defined for " << id;
             }
          }
 
 #if 0
          if (_schedule)
             slout_info << *_schedule;
 #endif
       }
       else
       {
          glout_error << "Error: SessionConfig object missing in session";
       }
 
       slout_info << "Connection from " << _connection->get_peer_socket_address().toString();
 
       if (reset_given) // ignore version restrictions on this behaviour
       {
          slout_info << "Resetting sequence numbers";
          _next_send_seq = _next_receive_seq = 1;
       }
       else
       {
          recover_seqnums();
          if (_req_next_send_seq)
             _next_send_seq = _req_next_send_seq;
          if (_req_next_receive_seq)
             _next_receive_seq = _req_next_receive_seq;
       }
 
       if (authenticate(id, msg))
       {
          _sid = id;
          enforce(seqnum, msg);
          heartbeat_interval hbi;
          msg->get(hbi);
          _connection->set_hb_interval(hbi());
          send(generate_logon(hbi(), davi()));
          do_state_change(States::st_continuous);
          slout_info << "Client setting heartbeat interval to " << hbi();
       }
       else
       {
          slout_error << id << " failed authentication";
          stop();
          do_state_change(States::st_session_terminated);
          return false;
       }
 
       if (_loginParameters._login_schedule.is_valid() && !_loginParameters._login_schedule.test())
       {
          slout_error << id << " Session unavailable. Login not accepted.";
          stop();
          do_state_change(States::st_session_terminated);
          return false;
       }
    }
 
    slout_info << "Heartbeat interval is " << _connection->get_hb_interval();
 
    _timer.schedule(_hb_processor, 1000);  // check every second
 
    return true;
 }

bool Session::handle_logout	(	const unsigned	seqnum,
		const Message *	msg
	)

protectedvirtual

Logout callback.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 630 of file session.cpp.

References enforce(), and slout_info.

Referenced by process().

 {
    enforce(seqnum, msg);
 
    //if (_state != States::st_logoff_sent)
    // send(generate_logout());
    slout_info << "peer has logged out";
    // stop(); // FX-615
    return true;
 }

bool Session::handle_outbound_reject	(	const unsigned	seqnum,
		const Message *	msg,
		const char *	errstr
	)

protectedvirtual

Outbound Reject callback. Override to receive callback when an inbound message has caused a reject

Parameters

seqnum	message sequence number
msg	Message
errstr	reject message text

Returns: true on success

Definition at line 782 of file session.cpp.

References generate_reject(), FIX8::MessageBase::get_msgtype(), and send().

Referenced by handle_resend_request(), and process().

 {
    return send(generate_reject(seqnum, errstr, msg && !msg->get_msgtype().empty() ? msg->get_msgtype().c_str() : nullptr));
 }

virtual bool FIX8::Session::handle_reject	(	const unsigned	seqnum,
		const Message *	msg
	)

inlineprotectedvirtual

Reject callback.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 484 of file session.hpp.

Referenced by process().

484 { return false; }

bool Session::handle_resend_request	(	const unsigned	seqnum,
		const Message *	msg
	)

protectedvirtual

Resend request callback.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 663 of file session.cpp.

References _next_send_seq, _persist, _state, do_state_change(), enforce(), generate_sequence_reset(), FIX8::Persister::get(), FIX8::MessageBase::get(), handle_outbound_reject(), retrans_callback(), send(), slout_debug, slout_warn, and FIX8::States::st_resend_request_received.

Referenced by process().

 {
    enforce(seqnum, msg);
 
    if (_state != States::st_resend_request_received)
    {
       begin_seq_num begin;
       end_seq_num end;
 
       if (!msg->get(begin))
       {
          slout_warn << "handle_resend_request: can't obtain BeginSeqNo from request";
       }
       if (!msg->get(end))
       {
          slout_warn << "handle_resend_request: can't obtain EndSeqNo from request";
       }
 
       if ((begin() > end() && end()) || begin() == 0)
          handle_outbound_reject(seqnum, msg, "Invalid resend range: Begin > End or Begin = 0");
       else if (!_persist)
       {
          const int nxt(static_cast<int>(_next_send_seq)), nseq(begin() >= nxt ? begin() + 1 : nxt);
          send(generate_sequence_reset(nseq, true), true, begin());
          _next_send_seq = nseq;
          slout_debug << "handle_resend_request scenario #" << (nseq == nxt ? 7 : 8);
       }
       else
       {
          //cout << "got resend request:" << begin() << " to " << end() << endl;
          do_state_change(States::st_resend_request_received);
          //f8_scoped_spin_lock guard(_per_spl, _connection->get_pmodel() == pm_coro); // no no nanette!
          _persist->get(begin(), end(), *this, &Session::retrans_callback);
       }
    }
    else
    {
       slout_warn << "resend request received during an existing resend sequence";
    }
 
    return true;
 }

bool Session::handle_sequence_reset	(	const unsigned	seqnum,
		const Message *	msg
	)

protectedvirtual

Sequence reset callback.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 642 of file session.cpp.

References _next_receive_seq, _state, do_state_change(), enforce(), FIX8::MessageBase::get(), slout_debug, FIX8::States::st_continuous, and FIX8::States::st_resend_request_sent.

Referenced by process().

 {
    enforce(seqnum, msg);
 
    new_seq_num nsn;
    if (msg->get(nsn))
    {
       slout_debug << "newseqnum = " << nsn() << ", _next_receive_seq = " << _next_receive_seq << " seqnum:" << seqnum;
       if (nsn() >= static_cast<int>(_next_receive_seq))
          _next_receive_seq = nsn() - 1;
       else if (nsn() < static_cast<int>(_next_receive_seq))
          throw MsgSequenceTooLow(nsn(), _next_receive_seq);
    }
 
    if (_state == States::st_resend_request_sent)
       do_state_change(States::st_continuous);
 
    return true;
 }

bool Session::handle_test_request	(	const unsigned	seqnum,
		const Message *	msg
	)

protectedvirtual

Test request callback.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 771 of file session.cpp.

References enforce(), generate_heartbeat(), FIX8::MessageBase::get(), and send().

Referenced by process().

 {
    enforce(seqnum, msg);
 
    test_request_id testReqID;
    msg->get(testReqID);
    send(generate_heartbeat(testReqID()));
    return true;
 }

bool Session::heartbeat_service ( )

protected

Heartbeat generation service thread method.

Definition at line 808 of file session.cpp.

References _connection, _last_received, _last_sent, _loginParameters, FIX8::LoginParameters::_silent_disconnect, _state, do_state_change(), FIX8::Logger::Error, generate_heartbeat(), generate_logout(), generate_test_request(), FIX8::Connection::get_hb_interval(), FIX8::Connection::get_hb_interval20pc(), FIX8::Connection::is_connected(), is_shutdown(), log(), FIX8::Tickval::now(), FIX8::Tickval::secs(), send(), slout_error, FIX8::States::st_logoff_sent, FIX8::States::st_session_terminated, FIX8::States::st_test_request_sent, stop(), and FIX8::Logger::Warn.

 {
    //cout << "heartbeat_service()" << endl;
    if (is_shutdown())
       return false;
 
    if (_connection && _connection->is_connected())
    {
       Tickval now(true);
       if ((now - _last_sent).secs() >= static_cast<time_t>(_connection->get_hb_interval()))
       {
          const f8String testReqID;
          send(generate_heartbeat(testReqID));
       }
 
       now.now();
       if ((now - _last_received).secs() > static_cast<time_t>(_connection->get_hb_interval20pc()))
       {
          if (_state == States::st_test_request_sent)  // already sent
          {
             ostringstream ostr;
             ostr << "Remote has ignored my test request. Aborting session...";
             send(generate_logout(_loginParameters._silent_disconnect ? 0 : ostr.str().c_str()), true, 0, true); // so it won't increment
             do_state_change(States::st_logoff_sent);
             log(ostr.str(), Logger::Error);
             try
             {
                stop();
             }
             catch (Poco::Net::NetException& e)
             {
                slout_error << e.what();
             }
             catch (exception& e)
             {
                slout_error << e.what();
             }
             return true;
          }
          else if (_state != States::st_session_terminated)
          {
             ostringstream ostr;
             ostr << "Have not received anything from remote for ";
             if (_last_received.secs())
                ostr << (now - _last_received).secs();
             else
                ostr << "more than " << _connection->get_hb_interval20pc();
             ostr << " secs. Sending test request";
             log(ostr.str(), Logger::Warn);
             const f8String testReqID("TEST");
             send(generate_test_request(testReqID));
             do_state_change(States::st_test_request_sent);
          }
       }
    }
 
    return true;
 }

bool FIX8::Session::is_loggable ( Logger::Level level ) const

inline

Check if the given log level is set for the session logger

Parameters

level level to test

Returns: true if available

Definition at line 678 of file session.hpp.

References FIX8::Logger::is_loggable().

678 { return _logger ? _logger->is_loggable(level) : false; }

FIX8::Session::_logger

Logger * _logger

Definition: session.hpp:422

FIX8::Logger::is_loggable

bool is_loggable(Level level) const

Definition: logger.hpp:262

bool FIX8::Session::is_shutdown ( )

inline

See if this session is being shutdown.

Returns: true if shutdown is underway

Definition at line 778 of file session.hpp.

References FIX8::ebitset_r< T, B >::has(), shutdown, and FIX8::States::st_session_terminated.

Referenced by activation_service(), client_process(), and heartbeat_service().

778 { return _control.has(shutdown) || _state == States::st_session_terminated; }

FIX8::States::st_session_terminated

Definition: session.hpp:160

FIX8::Session::_state

f8_atomic< States::SessionStates > _state

Definition: session.hpp:408

FIX8::Session::_control

Control _control

Definition: session.hpp:406

FIX8::ebitset_r::has

integral_type has(const T sbit) const

Definition: f8utils.hpp:975

FIX8::Session::shutdown

Definition: session.hpp:401

bool FIX8::Session::log	(	const std::string &	what,
		Logger::Level	lev,
		const char *	fl = `nullptr`,
		unsigned	value = `0`
	)		const

inline

Log a message to the session logger.

Parameters

what	string to log
lev	log level
fl	pointer to fileline
value	optional value for the logger to use

Returns: true on success

Definition at line 695 of file session.hpp.

References FIX8::Logger::send().

Referenced by heartbeat_service().

696 { return _logger ? _logger->send(what, lev, fl, value) : false; }

FIX8::Session::_logger

Logger * _logger

Definition: session.hpp:422

FIX8::Logger::send

bool send(const std::string &what, Level lev=Logger::Info, const char *fl=nullptr, const unsigned val=0)

Definition: logger.hpp:306

int Session::modify_header ( MessageBase * msg )

virtual

Modify the header if desired. Called when message is sent.

Parameters

msg Message

Returns: number of fields added/modifed

Definition at line 1003 of file session.cpp.

Referenced by send_process().

 {
    return 0;
 }

virtual void FIX8::Session::modify_outbound ( Message * msg )

inlineprotectedvirtual

Permit modification of message just prior to sending.

Parameters

msg Message

Definition at line 514 of file session.hpp.

Referenced by send_process().

514 {}

bool FIX8::Session::plog	(	const std::string &	what,
		Logger::Level	lev,
		const unsigned	direction = `0`
	)		const

inline

Log a message to the protocol logger.

Parameters

what	Fix message (string) to log
lev	log level
direction	0=out, 1=in

Returns: true on success

Definition at line 703 of file session.hpp.

References FIX8::Logger::send().

Referenced by process(), and send_process().

704 { return _plogger ? _plogger->send(what, lev, nullptr, direction) : false; }

FIX8::Session::_plogger

Logger * _plogger

Definition: session.hpp:422

FIX8::Logger::send

bool send(const std::string &what, Level lev=Logger::Info, const char *fl=nullptr, const unsigned val=0)

Definition: logger.hpp:306

bool Session::process ( const f8String & from )

virtual

Process inbound messages. Called by connection object.

Parameters

from	raw fix message

Returns: true on success

Definition at line 277 of file session.cpp.

 {
    unsigned seqnum(0);
    bool remote_logged_out {};
    const Message *msg = nullptr;
 
    try
    {
       const f8String::size_type fpos(from.find("34="));
       if (fpos == f8String::npos)
       {
          slout_debug << "Session::process throwing for " << from;
          throw InvalidMessage(from, FILE_LINE);
       }
 
       seqnum = fast_atoi<unsigned>(from.data() + fpos + 3, default_field_separator);
 
       bool retry_plog(false);
       if (_plogger && _plogger->has_flag(Logger::inbound))
       {
          if (_state != States::st_wait_for_logon)
             plog(from, Logger::Info, 1);
          else
             retry_plog = true;
       }
 
       if (!(msg = Message::factory(_ctx, from, _loginParameters._no_chksum_flag, _loginParameters._permissive_mode_flag)))
       {
          glout_fatal << "Fatal: factory failed to generate a valid message";
          return false;
       }
 
       if ((_control & printnohb) && msg->get_msgtype() != Common_MsgType_HEARTBEAT)
          cout << *msg << endl;
       else if (_control & print)
          cout << *msg << endl;
 
       bool result(false), admin_result(msg->is_admin() ? handle_admin(seqnum, msg) : true);
       if (msg->get_msgtype().size() > 1)
          goto application_call;
       else switch(msg->get_msgtype()[0])
       {
       default:
 application_call:
          if (activation_check(seqnum, msg))
             result = handle_application(seqnum, msg);
          break;
       case Common_MsgByte_HEARTBEAT:
          result = handle_heartbeat(seqnum, msg);
          break;
       case Common_MsgByte_TEST_REQUEST:
          result = handle_test_request(seqnum, msg);
          break;
       case Common_MsgByte_RESEND_REQUEST:
          result = handle_resend_request(seqnum, msg);
          break;
       case Common_MsgByte_REJECT:
          result = handle_reject(seqnum, msg);
          break;
       case Common_MsgByte_SEQUENCE_RESET:
          result = handle_sequence_reset(seqnum, msg);
          break;
       case Common_MsgByte_LOGOUT:
          result = handle_logout(seqnum, msg);
          remote_logged_out = true;
          break;
       case Common_MsgByte_LOGON:
          result = handle_logon(seqnum, msg);
          break;
       }
 
       ++_next_receive_seq;
       if (retry_plog)
          plog(from, Logger::Info, 1);
 
       update_persist_seqnums();
 
       if (remote_logged_out) // FX-615; permit logout seqnum to be persisted
       {
          slout_debug << "logout received from remote";
          stop();
       }
 
       delete msg;
       return result && admin_result;
    }
    catch (LogfileException& e)
    {
       cerr << e.what() << endl;
    }
    catch (f8Exception& e)
    {
       slout_debug << "process: f8exception" << ' ' << seqnum << ' ' << e.what();
 
       if (e.force_logoff())
       {
          if (_plogger && _plogger->has_flag(Logger::inbound))
             plog(from, Logger::Info, 1);
          slout_fatal << e.what() << " - will logoff";
          if (_state == States::st_logon_received && !_loginParameters._silent_disconnect)
          {
             do_state_change(States::st_session_terminated);
             send(generate_logout(e.what()), true, 0, true); // so it won't increment
             do_state_change(States::st_logoff_sent);
          }
          if (_loginParameters._reliable)
          {
             slout_debug << "rethrowing ...";
             throw;
          }
          stop();
       }
       else
       {
          slout_error << e.what() << " - inbound message rejected";
          handle_outbound_reject(seqnum, msg, e.what());
          ++_next_receive_seq;
          if (_plogger && _plogger->has_flag(Logger::inbound))
             plog(from, Logger::Info, 1);
          delete msg;
          return true; // message is handled but has errors
       }
    }
    catch (Poco::Net::NetException& e)
    {
       slout_debug << "process:: Poco::Net::NetException";
       slout_error << e.what();
    }
    catch (exception& e)
    {
       slout_debug << "process:: std::exception";
       slout_error << e.what();
    }
 
    return false;
 }

void Session::recover_seqnums ( )

protectedvirtual

Recover next expected and next to send sequence numbers from persitence layer.

Definition at line 1124 of file session.cpp.

References _connection, _next_receive_seq, _next_send_seq, _per_spl, _persist, FIX8::Persister::get(), FIX8::Connection::get_pmodel(), FIX8::pm_coro, and slout_info.

Referenced by handle_logon(), and start().

 {
    f8_scoped_spin_lock guard(_per_spl, _connection->get_pmodel() == pm_coro);
    if (_persist)
    {
       unsigned send_seqnum, receive_seqnum;
       if (_persist->get(send_seqnum, receive_seqnum))
       {
          slout_info << "Last sent: " << send_seqnum << ", last received: " << receive_seqnum;
          _next_send_seq = send_seqnum; // + 1;
          _next_receive_seq = receive_seqnum; // + 1;
       }
    }
 }

bool Session::retrans_callback	(	const SequencePair &	with,
		RetransmissionContext &	rctx
	)

virtual

Retransmission callback. Called by framework with each message to be resent.

Parameters

with	pair of sequence number and raw fix message
rctx	retransmission context

Returns: true on success

Definition at line 707 of file session.cpp.

References FIX8::Session::RetransmissionContext::_begin, _ctx, FIX8::Session::RetransmissionContext::_interrupted_seqnum, FIX8::Session::RetransmissionContext::_last, _next_send_seq, FIX8::Session::RetransmissionContext::_no_more_records, do_state_change(), FIX8::Message::factory(), generate_sequence_reset(), send(), slout_debug, and FIX8::States::st_continuous.

Referenced by handle_resend_request().

 {
    //cout << "first:" << with.first << ' ' << rctx << endl;
 
    if (rctx._no_more_records)
    {
       /*
       if (rctx._end)
       {
          _next_send_seq = rctx._interrupted_seqnum - 1;
          send(generate_sequence_reset(rctx._interrupted_seqnum, true), true, rctx._last + 1);
          //cout << "#1" << endl;
       }
       else if (!rctx._last)
       {
          _next_send_seq = rctx._interrupted_seqnum;
          send(generate_sequence_reset(rctx._interrupted_seqnum, true), true, rctx._begin);
          //cout << "#4" << endl;
       }
       */
       if (!rctx._last) // start to infinity requested
       {
          // handle case where requested seq is greater than current last sent seq (interrupted)
          const unsigned nseq(rctx._begin >= rctx._interrupted_seqnum ? rctx._begin + 1 : rctx._interrupted_seqnum);
          send(generate_sequence_reset(nseq, true), true, rctx._begin);
          _next_send_seq = nseq;
          slout_debug << "retrans_callback scenario #" << (nseq == rctx._interrupted_seqnum ? 4 : 5) << ' ' << rctx;
       }
       else // range requested // was: if (rctx._end)
       {
          // handle case where requested seq is greater than current last sent seq (interrupted)
          const unsigned nseq(rctx._last + 1 >= rctx._interrupted_seqnum ? rctx._last + 2 : rctx._interrupted_seqnum);
          send(generate_sequence_reset(nseq, true), true, rctx._last + 1);
          _next_send_seq = nseq;
          slout_debug << "retrans_callback scenario #" << (nseq == rctx._interrupted_seqnum ? 1 : 6) << ' ' << rctx;
       }
       do_state_change(States::st_continuous);
       return true;
    }
 
    if (rctx._last)
    {
       if (rctx._last + 1 < with.first)
       {
          send(generate_sequence_reset(with.first, true), true, _next_send_seq);
          slout_debug << "retrans_callback scenario #2, " << rctx;
       }
    }
    else
    {
       if (with.first > rctx._begin)
       {
          send(generate_sequence_reset(with.first, true));
          slout_debug << "retrans_callback scenario #3, " << rctx;
       }
    }
 
    rctx._last = with.first;
 
    Message *msg(Message::factory(_ctx, with.second));
    return send(msg);
 }

bool Session::send	(	Message *	msg,
		bool	destroy = `true`,
		const unsigned	custom_seqnum = `0`,
		const bool	no_increment = `false`
	)

virtual

Send message.

Parameters

msg	Message
destroy	if true, destroy message after send
custom_seqnum	override sequence number with this value
no_increment	if true, don't increment the seqnum after sending

Returns: true on success

Definition at line 978 of file session.cpp.

References _connection, FIX8::Message::set_custom_seqnum(), FIX8::Message::set_no_increment(), and FIX8::Connection::write().

Referenced by handle_logon(), handle_outbound_reject(), handle_resend_request(), handle_test_request(), heartbeat_service(), process(), retrans_callback(), sequence_check(), and start().

 {
    if (custom_seqnum)
       tosend->set_custom_seqnum(custom_seqnum);
    if (no_increment)
       tosend->set_no_increment(no_increment);
    return _connection && _connection->write(tosend, destroy);
 }

bool Session::send	(	Message &	msg,
		const unsigned	custom_seqnum = `0`,
		const bool	no_increment = `false`
	)

virtual

Send message - non-pipelined version. WARNING: be sure you don't inadvertently use this method. Symptoms will be out of sequence messages (seqnum==1) and core dumping.

Parameters

msg	Message
custom_seqnum	override sequence number with this value
no_increment	if true, don't increment the seqnum after sending

Returns: true on success

Definition at line 987 of file session.cpp.

References _connection, FIX8::Message::set_custom_seqnum(), FIX8::Message::set_no_increment(), and FIX8::Connection::write().

 {
    if (custom_seqnum)
       tosend.set_custom_seqnum(custom_seqnum);
    if (no_increment)
       tosend.set_no_increment(no_increment);
    return _connection && _connection->write(tosend);
 }

size_t Session::send_batch	(	const std::vector< Message * > &	msgs,
		bool	destroy = `true`
	)

virtual

Send a batch of messages. During this call HB and test requests are suspended.

Parameters

msgs	vector of Message ptrs
destroy	if true, destroy message after send

Returns: size_t number of messages sent - if destroy was true those sent messages will have been destroyed with the reamining messages in the vector still allocated

Definition at line 997 of file session.cpp.

References _connection, and FIX8::Connection::write_batch().

 {
    return _connection->write_batch(msgs, destroy);
 }

bool Session::send_process ( Message * msg )

Process message (encode) and send.

Parameters

msg Message

Returns: true on success

Definition at line 1009 of file session.cpp.

References FIX8::LoginParameters::_always_seqnum_assign, _batchmsgs_buffer, _connection, _last_sent, _loginParameters, _next_receive_seq, _next_send_seq, _per_spl, _persist, _plogger, _sid, FIX8::Common_MsgSeqNum(), FIX8::Common_MsgType_SEQUENCE_RESET(), FIX8::Common_PossDupFlag(), FIX8::Common_SenderCompID(), FIX8::Common_TargetCompID(), FIX8_MAX_MSG_LENGTH, FIX8::MessageBase::get(), FIX8::Message::get_custom_seqnum(), FIX8::Connection::get_pmodel(), FIX8::SessionID::get_senderCompID(), FIX8::SessionID::get_targetCompID(), FIX8::Logger::has_flag(), FIX8::MessageBase::have(), FIX8::Message::Header(), FIX8::HEADER_CALC_OFFSET(), FIX8::Logger::Info, modify_header(), modify_outbound(), FIX8::Tickval::now(), FIX8::Logger::outbound, plog(), FIX8::pm_coro, FIX8::Persister::put(), FIX8::MessageBase::remove(), FIX8::Connection::send(), slout_debug, slout_error, and FIX8::f8Exception::what().

Referenced by FIX8::FIXWriter::write(), and FIX8::FIXWriter::write_batch().

 {
    //cout << "send_process()" << endl;
    bool is_dup(msg->Header()->have(Common_PossDupFlag));
    if (!msg->Header()->have(Common_SenderCompID))
       *msg->Header() << new sender_comp_id(_sid.get_senderCompID());
    if (!msg->Header()->have(Common_TargetCompID))
       *msg->Header() << new target_comp_id(_sid.get_targetCompID());
 
    if (msg->Header()->have(Common_MsgSeqNum))
    {
       if (is_dup)
       {
          if (_loginParameters._always_seqnum_assign)
             delete msg->Header()->remove(Common_PossDupFlag);
       }
       else
       {
          if (!_loginParameters._always_seqnum_assign)
          {
             *msg->Header() << new poss_dup_flag(true);
             is_dup = true;
          }
       }
 
       sending_time sendtime;
       msg->Header()->get(sendtime);
       *msg->Header() << new orig_sending_time(sendtime());
 
       if (_loginParameters._always_seqnum_assign)
       {
          slout_debug << "send_process: _next_send_seq = " << _next_send_seq;
          *msg->Header() << new msg_seq_num(msg->get_custom_seqnum() ? msg->get_custom_seqnum() : static_cast<unsigned int>(_next_send_seq));
       }
    }
    else
    {
       slout_debug << "send_process: _next_send_seq = " << _next_send_seq;
       *msg->Header() << new msg_seq_num(msg->get_custom_seqnum() ? msg->get_custom_seqnum() : static_cast<unsigned int>(_next_send_seq));
    }
    *msg->Header() << new sending_time;
 
    // allow session to modify the header of this message before sending
    const int fields_modified(modify_header(msg->Header()));
    if (fields_modified)
    {
       slout_debug << "send_process: " << fields_modified << " header fields added/modified";
    }
 
    try
    {
       slout_debug << "Sending:" << *msg;
       modify_outbound(msg);
       char output[FIX8_MAX_MSG_LENGTH + HEADER_CALC_OFFSET], *ptr(output);
       size_t enclen(msg->encode(&ptr));
       const char *optr(ptr);
       if (msg->get_end_of_batch())
       {
          if (!_batchmsgs_buffer.empty())
          {
             _batchmsgs_buffer.append(ptr);
             ptr = &_batchmsgs_buffer[0];
             enclen = _batchmsgs_buffer.size();
          }
          if (!_connection->send(ptr, enclen))
          {
             slout_error << "Message write failed: " << enclen << " bytes";
             _batchmsgs_buffer.clear();
             return false;
          }
          _last_sent.now();
          _batchmsgs_buffer.clear();
       }
       else
       {
          _batchmsgs_buffer.append(ptr);
       }
 
       if (_plogger && _plogger->has_flag(Logger::outbound))
          plog(optr, Logger::Info);
 
       //cout << "send_process" << endl;
 
       if (!is_dup)
       {
          if (_persist)
          {
             f8_scoped_spin_lock guard(_per_spl, _connection->get_pmodel() == pm_coro); // not needed for coroutine mode
             if (!msg->is_admin())
                _persist->put(_next_send_seq, ptr);
             _persist->put(_next_send_seq + 1, _next_receive_seq);
             //cout << "Persisted (send):" << (_next_send_seq + 1) << " and " << _next_receive_seq << endl;
          }
          if (!msg->get_custom_seqnum() && !msg->get_no_increment() && msg->get_msgtype() != Common_MsgType_SEQUENCE_RESET)
          {
             ++_next_send_seq;
             //cout << "Seqnum now:" << _next_send_seq << " and " << _next_receive_seq << endl;
          }
       }
    }
    catch (f8Exception& e)
    {
       slout_error << e.what();
       return false;
    }
    catch (Poco::Exception& e)
    {
       slout_error << e.displayText();
       return false;
    }
 
    return true;
 }

bool Session::sequence_check	(	const unsigned	seqnum,
		const Message *	msg
	)

Check that a message is in the correct sequence for this session. Will generated resend request if required. Throws InvalidMsgSequence, MissingMandatoryField, BadSendingTime.

Parameters

seqnum	message sequence number
msg	Message

Returns: true on success

Definition at line 427 of file session.cpp.

References _next_receive_seq, FIX8::SessionConfig::_ses, _sf, _state, do_state_change(), generate_resend_request(), FIX8::MessageBase::get(), FIX8::Configuration::get_ignore_logon_sequence_check_flag(), FIX8::Message::Header(), FIX8::BaseField::print(), send(), slout_warn, FIX8::States::st_continuous, and FIX8::States::st_resend_request_sent.

Referenced by enforce().

 {
    //cout << "seqnum:" << seqnum << " next_target_seq:" << _next_receive_seq
       //<< " next_sender_seq:" << _next_send_seq << " state:" << _state << " next_receive_seq:" <<  _next_receive_seq << endl;
 
    if (seqnum > _next_receive_seq)
    {
       if (_state == States::st_resend_request_sent)
       {
          slout_warn << "Resend request already sent";
       }
       if (_state == States::st_continuous)
       {
          send(generate_resend_request(_next_receive_seq));
          do_state_change(States::st_resend_request_sent);
       }
       // If SessionConfig has *not* been set, assume wrong logon sequence is checked.
       else if (!_sf || !_sf->get_ignore_logon_sequence_check_flag(_sf->_ses))
          throw InvalidMsgSequence(seqnum, _next_receive_seq);
       return false;
    }
 
    if (seqnum < _next_receive_seq)
    {
       poss_dup_flag pdf(false);
       msg->Header()->get(pdf);
       if (!pdf()) // poss dup not set so bad
          throw MsgSequenceTooLow(seqnum, _next_receive_seq);
       sending_time st;
       msg->Header()->get(st);
       orig_sending_time ost;
       if (msg->Header()->get(ost) && ost() > st())
       {
          ostringstream ostr;
          ost.print(ostr);
          throw BadSendingTime(ostr.str());
       }
    }
 
    return true;
 }

void Session::set_affinity ( int core_id )

protected

Set the CPU affinity mask for the given thread

Parameters

core_id core to mask on

Definition at line 1200 of file session.cpp.

References slout_error.

 {
    slout_error << "set_affinity: not implemented";
 }

void FIX8::Session::set_login_parameters ( const LoginParameters & loginParamaters )

inline

Set the LoginParameters

Parameters

loginParamaters to populate from

Definition at line 754 of file session.hpp.

754 { _loginParameters = loginParamaters; }

FIX8::Session::_loginParameters

LoginParameters _loginParameters

Definition: session.hpp:418

void FIX8::Session::set_persister ( Persister * pst )

inline

Set the persister.

Parameters

pst	pointer to persister object

Definition at line 770 of file session.hpp.

770 { _persist = pst; }

FIX8::Session::_persist

Persister * _persist

Definition: session.hpp:421

void FIX8::Session::set_reset_sequence_numbers_flag ( bool flag )

inline

Set the reset_sequence_numbers flag, defaults to value set in config file (default false)

Parameters

flag	true or false

Definition at line 766 of file session.hpp.

References FIX8::LoginParameters::_reset_sequence_numbers.

766 { _loginParameters._reset_sequence_numbers = flag; }

FIX8::Session::_loginParameters

LoginParameters _loginParameters

Definition: session.hpp:418

FIX8::LoginParameters::_reset_sequence_numbers

bool _reset_sequence_numbers

Definition: session.hpp:355

void Session::set_scheduler ( int priority )

protected

Set the scheduling policy for the current thread

Parameters

priority scheduler priority

Definition at line 1194 of file session.cpp.

References slout_error.

 {
    slout_error << "set_scheduler: not implemented";
 }

void FIX8::Session::set_session_config ( struct SessionConfig * sf )

inline

Definition at line 782 of file session.hpp.

782 { _sf = sf; }

FIX8::Session::_sf

struct SessionConfig * _sf

Definition: session.hpp:416

int Session::start	(	Connection *	connection,
		bool	wait = `true`,
		const unsigned	send_seqnum = `0`,
		const unsigned	recv_seqnum = `0`,
		const f8String	davi = `f8String()`
	)

Start the session.

Parameters

connection	established connection
wait	if true, thread will wait till session ends before returning
send_seqnum	if supplied, override the send login sequence number, set next send to seqnum+1
recv_seqnum	if supplied, override the receive login sequence number, set next recv to seqnum+1
davi	default appl version id (FIXT)

Returns: -1 on error, 0 on success

Definition at line 167 of file session.cpp.

References _connection, _control, _logger, _loginParameters, _next_receive_seq, _next_send_seq, _plogger, _req_next_receive_seq, _req_next_send_seq, FIX8::LoginParameters::_reset_sequence_numbers, _schedule, FIX8::SessionConfig::_ses, _session_scheduler, _sf, _timer, atomic_init(), FIX8::ebitset_r< T, B >::clear(), FIX8::Connection::cn_acceptor, FIX8::Connection::cn_initiator, FIX8::Connection::connect(), copyright_string(), FIX8::Configuration::create_session_schedule(), do_state_change(), generate_logon(), FIX8::Connection::get_hb_interval(), FIX8::Connection::get_role(), glout_info, FIX8::Connection::join(), FIX8::Logger::purge_thread_codes(), recover_seqnums(), send(), shutdown, slout_info, FIX8::States::st_logon_sent, FIX8::States::st_not_logged_in, FIX8::States::st_wait_for_logon, and FIX8::Connection::start().

 {
    glout_info << copyright_string();
    if (_logger)
       _logger->purge_thread_codes();
 
    if (_plogger)
       _plogger->purge_thread_codes();
 
    _control.clear(shutdown);
    slout_info << "Starting session";
    _connection = connection; // takes owership
    if (!_connection->connect()) // if already connected returns true
       return -1;
    if (_connection->get_role() == Connection::cn_acceptor)
       atomic_init(States::st_wait_for_logon); // important for server that this is done before connect
    _connection->start();
    slout_info << "Session connected";
 
    if (_connection->get_role() == Connection::cn_initiator)
    {
       atomic_init(States::st_not_logged_in);
       if (_loginParameters._reset_sequence_numbers)
          _next_send_seq = _next_receive_seq = 1;
       else
       {
          recover_seqnums();
          if (send_seqnum)
             _next_send_seq = send_seqnum;
          if (recv_seqnum)
             _next_receive_seq = recv_seqnum;
       }
 
       send(generate_logon(_connection->get_hb_interval(), davi));
       do_state_change(States::st_logon_sent);
    }
    else
    {
       if (send_seqnum)
          _req_next_send_seq = send_seqnum;
       if (recv_seqnum)
          _req_next_receive_seq = recv_seqnum;
    }
 
    if (_sf && (_schedule = _sf->create_session_schedule(_sf->_ses)))
    {
       if (_connection->get_role() == Connection::cn_initiator)
       {
          slout_info << *_schedule;
       }
       _timer.schedule(_session_scheduler, 1000);   // check every second
    }
 
    if (wait)   // wait for
    {
       _connection->join();
    }
 
    return 0;
 }

virtual void FIX8::Session::state_change	(	const States::SessionStates	before,
		const States::SessionStates	after
	)

inlineprotectedvirtual

This method id called whenever a session state change occurs

Parameters

before	previous session state
after	new session state

Reimplemented in myfix_session_server, and myfix_session_client.

Definition at line 510 of file session.hpp.

Referenced by do_state_change().

510 {}

void Session::stop ( )

stop the session.

Definition at line 230 of file session.cpp.

References _connection, _control, _per_spl, _persist, _timer, FIX8::Connection::cn_initiator, FIX8::Connection::get_pmodel(), FIX8::Connection::get_role(), FIX8::hypersleep< h_milliseconds >(), FIX8::pm_coro, shutdown, FIX8::Persister::stop(), and FIX8::Connection::stop().

Referenced by client_process(), handle_logon(), heartbeat_service(), and process().

 {
    if (_control & shutdown)
       return;
    _control |= shutdown;
 
    if (_connection)
    {
       if (_connection->get_role() == Connection::cn_initiator)
          _timer.clear();
       else
       {
          f8_scoped_spin_lock guard(_per_spl, _connection->get_pmodel() == pm_coro);
          if (_persist)
             _persist->stop();
       }
       _connection->stop();
    }
    hypersleep<h_milliseconds>(250);
 }

void Session::update_persist_seqnums ( )

Force persister to sync next send/receive seqnums.

Definition at line 266 of file session.cpp.

References _connection, _next_receive_seq, _next_send_seq, _per_spl, _persist, FIX8::Connection::get_pmodel(), FIX8::pm_coro, and FIX8::Persister::put().

Referenced by process().

 {
    if (_persist)
    {
       f8_scoped_spin_lock guard(_per_spl, _connection && _connection->get_pmodel() == pm_coro);
       _persist->put(_next_send_seq, _next_receive_seq);
       //cout << "Persisted:" << _next_send_seq << " and " << _next_receive_seq << endl;
    }
 }

void FIX8::Session::update_received ( )

inline

Update the last received time.

Definition at line 718 of file session.hpp.

References FIX8::Tickval::now().

718 { _last_received.now(); }

FIX8::Session::_last_received

Tickval _last_received

Definition: session.hpp:410

FIX8::Tickval::now

Tickval & now()

Definition: tickval.hpp:133

void FIX8::Session::update_sent ( )

inline

Update the last sent time.

Definition at line 715 of file session.hpp.

References FIX8::Tickval::now().

715 { _last_sent.now(); }

FIX8::Session::_last_sent

Tickval _last_sent

Definition: session.hpp:410

FIX8::Tickval::now

Tickval & now()

Definition: tickval.hpp:133

Member Data Documentation

f8_atomic<bool> FIX8::Session::_active

protected

Definition at line 409 of file session.hpp.

Referenced by activation_check(), activation_service(), and atomic_init().

std::string FIX8::Session::_batchmsgs_buffer

protected

Definition at line 426 of file session.hpp.

Referenced by send_process(), and Session().

Connection* FIX8::Session::_connection

protected

Definition at line 413 of file session.hpp.

Referenced by activation_service(), get_connection(), handle_logon(), heartbeat_service(), recover_seqnums(), send(), send_batch(), send_process(), start(), stop(), update_persist_seqnums(), and ~Session().

Control FIX8::Session::_control

protected

Definition at line 406 of file session.hpp.

Referenced by control(), process(), start(), and stop().

const F8MetaCntx& FIX8::Session::_ctx

protected

Definition at line 411 of file session.hpp.

Referenced by get_ctx(), handle_logon(), process(), and retrans_callback().

TimerEvent<Session> FIX8::Session::_hb_processor

protected

Definition at line 425 of file session.hpp.

Referenced by handle_logon().

Tickval FIX8::Session::_last_received

protected

Definition at line 410 of file session.hpp.

Referenced by get_last_received(), and heartbeat_service().

Tickval FIX8::Session::_last_sent

protected

Definition at line 410 of file session.hpp.

Referenced by get_last_sent(), heartbeat_service(), and send_process().

Logger* FIX8::Session::_logger

protected

Definition at line 422 of file session.hpp.

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

LoginParameters FIX8::Session::_loginParameters

protected

Definition at line 418 of file session.hpp.

Referenced by compid_check(), generate_logon(), get_login_parameters(), handle_logon(), heartbeat_service(), process(), send_process(), and start().

f8_atomic<unsigned> FIX8::Session::_next_receive_seq

protected

Definition at line 407 of file session.hpp.

Referenced by atomic_init(), handle_logon(), handle_sequence_reset(), process(), recover_seqnums(), send_process(), sequence_check(), start(), and update_persist_seqnums().

f8_atomic<unsigned> FIX8::Session::_next_send_seq

protected

Definition at line 407 of file session.hpp.

Referenced by atomic_init(), get_next_send_seq(), handle_logon(), handle_resend_request(), recover_seqnums(), retrans_callback(), send_process(), start(), and update_persist_seqnums().

f8_spin_lock FIX8::Session::_per_spl

protected

Definition at line 420 of file session.hpp.

Referenced by handle_logon(), recover_seqnums(), send_process(), stop(), update_persist_seqnums(), and ~Session().

Persister* FIX8::Session::_persist

protected

Definition at line 421 of file session.hpp.

Referenced by handle_logon(), handle_resend_request(), recover_seqnums(), send_process(), Session(), stop(), update_persist_seqnums(), and ~Session().

Logger * FIX8::Session::_plogger

protected

Definition at line 422 of file session.hpp.

Referenced by handle_logon(), process(), send_process(), Session(), start(), and ~Session().

unsigned FIX8::Session::_req_next_receive_seq

protected

Definition at line 414 of file session.hpp.

Referenced by handle_logon(), and start().

unsigned FIX8::Session::_req_next_send_seq

protected

Definition at line 414 of file session.hpp.

Referenced by handle_logon(), and start().

Session_Schedule* FIX8::Session::_schedule

protected

Definition at line 427 of file session.hpp.

Referenced by activation_service(), handle_logon(), start(), and ~Session().

sender_comp_id FIX8::Session::_sci

protected

Definition at line 412 of file session.hpp.

Referenced by handle_logon().

TimerEvent<Session> FIX8::Session::_session_scheduler

protected

Definition at line 425 of file session.hpp.

Referenced by start().

struct SessionConfig* FIX8::Session::_sf

protected

Definition at line 416 of file session.hpp.

Referenced by handle_logon(), sequence_check(), and start().

SessionID FIX8::Session::_sid

protected

Definition at line 415 of file session.hpp.

Referenced by enforce(), get_sid(), handle_logon(), send_process(), and Session().

f8_atomic<States::SessionStates> FIX8::Session::_state

protected

Definition at line 408 of file session.hpp.

Referenced by enforce(), get_session_state(), handle_heartbeat(), handle_logon(), handle_resend_request(), handle_sequence_reset(), heartbeat_service(), process(), and sequence_check().

const vector< f8String > Session::_state_names

staticprotected

Initial value:

{
   "none", "continuous", "session_terminated",
   "wait_for_logon", "not_logged_in", "logon_sent", "logon_received", "logoff_sent",
   "logoff_received", "test_request_sent", "sequence_reset_sent",
   "sequence_reset_received", "resend_request_sent", "resend_request_received"
}

string representation of Sessionstates

Definition at line 430 of file session.hpp.

Timer<Session> FIX8::Session::_timer

protected

Definition at line 424 of file session.hpp.

Referenced by get_timer(), handle_logon(), Session(), start(), and stop().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation