ServerConnection Class Reference

#include <ServerConnection.h>

Inheritance diagram for ServerConnection:

List of all members.

---

Detailed Description

Object representing the server-side connection.

This object is owned by an Identity (and therefore has the same life time). The actual server connection is a ServerSession object that is created and managed by this object. Administrative information about the specific server itself (name, network, ports etc) is stored in a Server object.

Definition at line 54 of file ServerConnection.h.

Public Member Functions
	ServerConnection (Identity *identity)
	Constructor.
	ServerConnection (Identity *identity, boost::shared_ptr< Server > server)
	Constructor for secondary connection.
	~ServerConnection ()
	Destructor.
state_nt	state (void) const
	Return the state of the connection.
bool	secondary_connection (void) const
	Return true if this is a secondary connection.
void	set_my_serverside_nick_name (std::string const &my_serverside_nick_name)
	Set a new serverside nick name for myself. May only be called for a secondary connection.
std::string const &	my_serverside_nick_name (void) const
	Get my serverside nick name. Only valid for secondary connection.
void	change_state (state_nt, state_nt to)
	Change the state of the connection from from to to.
bool	has_server (void) const
	Return true if we have a server object.
boost::shared_ptr< Server const >	server (void) const
	Returns the server that we are connected with or connecting to.
boost::shared_ptr< Server >	server (void)
	Returns the server that we are connected with or connecting to.
bool	has_server_session (void) const
	Return true if we have a server session object.
ServerSession const &	server_session (void) const
	Return the ServerSession.
ServerSession &	server_session (void)
	Return the ServerSession.
Network const &	network (void) const
	Return the network object of the current connection.
Network &	network (void)
	Return the network object of the current connection.
void	connect (bool auto_reconnect)
	Connect to the server and stay connected.
void	disconnect (void)
	Disconnect from the server.
void	session_lost (void)
	This function is called when the ServerSession object is destroyed.
void	delayed_connect (timer_event_type_ct const &expired_at)
	Called when the timer for a delayed connect expired.
void	received_server_port_answer (UserAnswerEventType const &event_type)
	This function is called when an answer to the server/port question is received.
void	error_message_received (ServerMessageIn const &msg)
	This function is called if an ERROR message is received.
void	successful_connection (void)
	Called when the first message is received from the server.
void	decode_ping (ServerMessageIn const &pong_msg)
	This function is called when a PING message is received.
void	send_pong_and_mode (ExpressionEventType const &event_type)
	This function is called when it is safe to call it.
void	received_first_umode (MatcherEventType const &event_type)
	Called for the first MODE <mynick> received from the server.
bool	is_connected (void) const
	Return true if we are connected with a server.
bool	reconnect (void) const
	Return true if we try to (stay) connect(ed).
timeval	connect_delay (void) const
	Accessor for M_connect_delay.
bool	timed_out (void) const
	Accessor for M_timed_out.
int	timed_out_count (void) const
	Accessor for M_timed_out_count.
void	invisible_event (ExpressionEventType const &)
	Called when we first turn invisible.
void	make_primary (void)
void	make_secondary (void)
Private Member Functions
void	do_connect (void)
	Attempt an immediate connect to the server.
Private Attributes
boost::shared_ptr< Server >	M_server
	The server that we are connected to or trying to connect to, or NULL when the server is still unknown.
ServerSession *	M_server_session
	A pointer to the current server session, or NULL when there is none.
bool	M_reconnect
	True if we should try to (re)connect.
bool	M_connected
state_nt	M_state
	The state of the connection.
timeval	M_connect_delay
	The next connect delay.
bool	M_timed_out
	Set if the last connection attempted timed out.
int	M_timed_out_count
	The number of connect attempts left that will time out, until we stop trying.
bool	M_secondary_connection
	True if this connection is a secondary connection, while the primary still exists.
std::string	M_my_serverside_nick_name
	This is my serverside nick name for as long as this is a secondary connection.
Static Private Attributes
static timeval	S_connect_delay_init = { 1, 0 }
	The initial connect delay.
Friends
std::ostream &	operator<< (std::ostream &os, ServerConnection const &server_connection)
	For debugging purposes. Write a ServerConnection to os.

---

Constructor & Destructor Documentation

ServerConnection::ServerConnection

(

Identity *

identity

)

[inline]

Constructor.

Definition at line 90 of file ServerConnection.h.

References debug::channels::dc::objects.

                                       :
      event_client_ct(), IdentityReference(identity), M_server_session(NULL), M_reconnect(false),
      M_connected(false), M_state(disconnected),
      M_connect_delay(S_connect_delay_init), M_timed_out(false), M_timed_out_count(0),
      M_secondary_connection(false)
      {
        Dout(dc::objects, "Constructing ServerConnection(" << (void*)identity << ")");
      }

ServerConnection::ServerConnection	(	Identity *	identity,
		boost::shared_ptr< Server >	server
	)			[inline]

Constructor for secondary connection.

Definition at line 100 of file ServerConnection.h.

References debug::channels::dc::objects.

                                                                       :
      event_client_ct(), IdentityReference(identity),
      M_server(server), M_server_session(NULL),
      M_reconnect(false), M_connected(false), M_state(disconnected),
      M_connect_delay(S_connect_delay_init), M_timed_out(false), M_timed_out_count(0),
      M_secondary_connection(true), M_my_serverside_nick_name(random_nick())
      {
        Dout(dc::objects, "Constructing secondary ServerConnection(" << (void*)identity << ")");
      }

ServerConnection::~ServerConnection

(

)

[inline]

Destructor.

Definition at line 111 of file ServerConnection.h.

References disconnect(), M_server_session, and debug::channels::dc::objects.

      {
        Dout(dc::objects, "Destructing ServerConnection" << *this);
        cancel_all_requests();
        if (M_server_session)
          disconnect();
      }

---

Member Function Documentation

state_nt ServerConnection::state

(

void

)

const [inline]

Return the state of the connection.

Definition at line 120 of file ServerConnection.h.

References M_state.

Referenced by Queue::flush(), ServerSession::new_message_received(), Identity::new_server_message_received(), operator<<(), and Identity::pass_as_is_to_server().

{ return M_state; }

bool ServerConnection::secondary_connection

(

void

)

const [inline]

Return true if this is a secondary connection.

Definition at line 123 of file ServerConnection.h.

References M_secondary_connection.

Referenced by AuthState::auth_notice_looking_up_hostname(), AuthState::auth_notice_looking_up_ident(), AuthState::AuthState(), ServerSession::detected_network(), ServerSession::network_connection_terminated(), ServerSession::new_message_received(), operator<<(), and ServerSession::~ServerSession().

{ return M_secondary_connection; }

void ServerConnection::set_my_serverside_nick_name

(

std::string const &

my_serverside_nick_name

)

[inline]

Set a new serverside nick name for myself. May only be called for a secondary connection.

Definition at line 126 of file ServerConnection.h.

References ASSERT, M_my_serverside_nick_name, and M_secondary_connection.

      { ASSERT(M_secondary_connection); M_my_serverside_nick_name = my_serverside_nick_name; }

std::string const& ServerConnection::my_serverside_nick_name

(

void

)

const [inline]

Get my serverside nick name. Only valid for secondary connection.

Definition at line 130 of file ServerConnection.h.

References ASSERT, M_my_serverside_nick_name, and M_secondary_connection.

      { ASSERT(M_secondary_connection); return M_my_serverside_nick_name; }

void ServerConnection::change_state	(	state_nt	,
		state_nt	to
	)			[inline]

Change the state of the connection from from to to.

Definition at line 134 of file ServerConnection.h.

References ASSERT, and M_state.

Referenced by ServerSession::new_message_received().

      {
        Debug(ASSERT(M_state == from));
        M_state = to;
      }

bool ServerConnection::has_server

(

void

)

const [inline]

Return true if we have a server object.

Definition at line 141 of file ServerConnection.h.

References M_server.

Referenced by connect(), delayed_connect(), received_server_port_answer(), and server().

{ return M_server.get(); }

boost::shared_ptr<Server const> ServerConnection::server

(

void

)

const [inline]

Returns the server that we are connected with or connecting to.

Definition at line 144 of file ServerConnection.h.

References ASSERT, has_server(), and M_server.

Referenced by ServerSession::detected_network(), ServerSession::found_network_name(), Matcher_noarg::match_impl(), network(), ServerSession::network_connection_terminated(), ServerSession::new_message_received(), and received_server_port_answer().

{ ASSERT(has_server()); return boost::const_pointer_cast<Server const>(M_server); }

boost::shared_ptr<Server> ServerConnection::server

(

void

)

[inline]

Returns the server that we are connected with or connecting to.

Definition at line 147 of file ServerConnection.h.

References ASSERT, has_server(), and M_server.

{ ASSERT(has_server()); return M_server; }

bool ServerConnection::has_server_session

(

void

)

const [inline]

Return true if we have a server session object.

Definition at line 150 of file ServerConnection.h.

References M_server_session.

Referenced by operator<<().

{ return M_server_session; }

ServerSession const& ServerConnection::server_session

(

void

)

const [inline]

Return the ServerSession.

Definition at line 153 of file ServerConnection.h.

References M_server_session.

Referenced by AuthState::auth_notice_looking_up_hostname(), AuthState::auth_notice_looking_up_ident(), AuthState::AuthState(), decode_ping(), ISupport::end(), error_message_received(), Queue::flush(), operator<<(), and Authentication::send_authentication().

{ return *M_server_session; }

ServerSession& ServerConnection::server_session

(

void

)

[inline]

Return the ServerSession.

Definition at line 156 of file ServerConnection.h.

References M_server_session.

{ return *M_server_session; }

Network const& ServerConnection::network

(

void

)

const [inline]

Return the network object of the current connection.

Definition at line 159 of file ServerConnection.h.

References server().

Referenced by Target::add_channel(), Target::add_joined_nick(), Target::get_joined_nick(), Identity::network(), and Target::serverside_add_channel().

{ return server()->network(); }

Network& ServerConnection::network

(

void

)

[inline]

Return the network object of the current connection.

Definition at line 162 of file ServerConnection.h.

References server().

{ return server()->network(); }

void ServerConnection::connect

(

bool

auto_reconnect

)

Connect to the server and stay connected.

This function should be called only after the ServerConnection was just created, or after calling ServerConnection::disconnect.

This function will start the procedure of connecting to a server, either the one already specified by ServerConnection::M_server or, if none is known, it will first ask the user for a server name and port.

It will continue to attempt to connect to a server (with appropriate connect delays if necessary) until connected. After a connection is successful then the authentication sequence is started (handled by Authentication).

If a connection is lost, at any time, then a new connection is automatically attempted.

Definition at line 73 of file ServerConnection.cc.

References ASSERT, Identity::client_session(), delayed_connect(), disconnect(), disconnected, do_connect(), DoutEntering, has_server(), IdentityReference::identity(), is_connected(), M_connect_delay, M_reconnect, M_secondary_connection, M_server, M_server_session, M_state, M_timed_out, M_timed_out_count, Identity::network_name(), received_server_port_answer(), server_port_question, and ClientSession::user_answer_event_server.

Referenced by do_connect(), Authentication::received_nick_and_user(), received_server_port_answer(), and session_lost().

{
  DoutEntering(dc::debug, "ServerConnection::connect() for " << *this);
  ASSERT(!is_connected());
  ASSERT(M_state == disconnected);
  if (!M_server_session)        // Could already be allocated if has_server() was false
                                // and we get here a second time because the ClientSession
                                // was destroyed after requesting an answer.
  {
    M_server_session = new ServerSession(identity(), *this);
    AllocTag(M_server_session, (M_secondary_connection ? "Secondary Server session of " : "Server session of ") << identity().key());
  }
  if (auto_reconnect)
  {
    // See if we can find a network that this Identity belongs to.
    for (networks_type::iterator network_iter = Application::instance().networks().begin(); network_iter != Application::instance().networks().end(); ++network_iter)
      if (network_iter->name() == identity().network_name())
      {
        if (has_server())
        {
          if (!M_timed_out_count)
          {
            M_timed_out_count = 3 * network_iter->servers().size();
            ASSERT(M_timed_out_count != 0);     // We have at least one server because has_server() is true.
          }
          if (M_timed_out)
            --M_timed_out_count;
        }
        if (network_iter->servers().empty() || (M_timed_out && !M_timed_out_count))
          M_server.reset();     // If we don't have any servers, or when all servers timed out three times on a row.
        else
        {
          std::stable_sort(network_iter->servers().begin(), network_iter->servers().end(), ConnectionOrder());
          M_server = network_iter->servers().front();
        }
        break;
      }
  }
  M_reconnect = true;
  if (has_server())
  {
    timeval next_connect;
    timeradd(&M_server->last_connection_event(), &M_connect_delay, &next_connect);
    timeval now = timerRequest.get_now();
    if (timercmp(&now, &next_connect, >))
      do_connect();
    else
      timerRequest(M_connect_delay, *this, &ServerConnection::delayed_connect);
  }
  else if (identity().has_client_session())
  {
    ASSERT(!M_secondary_connection);    // The secondary connection should always have a server.
    identity().client_session().user_answer_event_server
        (UserAnswerRequestData(identity().client_session(), server_port_question,
        "What server should I connect to (type: <server> [<port> [<localip>]])?"),
        *this, &ServerConnection::received_server_port_answer);
  }
  else
    disconnect();
}

void ServerConnection::disconnect

(

void

)

[inline]

Disconnect from the server.

Definition at line 168 of file ServerConnection.h.

References ASSERT, DoutEntering, M_reconnect, and M_server_session.

Referenced by connect(), ServerSession::force_quit(), ServerSession::found_network_name(), ServerSession::new_message_received(), and ~ServerConnection().

      {
        DoutEntering(dc::debug, "ServerConnection::disconnect() for " << *this);
        ASSERT(M_server_session);
        M_reconnect = false;            // Before calling del(), otherwise 'session_lost' will
                                        // immediately try to reconnect.
        M_server_session->del();        // This calls session_lost (possibly with a tiny delay),
                                        // messages in the socket queue are first flushed.
      }

void ServerConnection::session_lost

(

void

)

This function is called when the ServerSession object is destroyed.

Never call this function directly.

Definition at line 252 of file ServerConnection.cc.

References Identity::client_session(), connect(), Identity::destroy_secondary_server_connection(), disconnected, IdentityReference::identity(), M_connected, M_reconnect, M_secondary_connection, M_server, M_server_session, M_state, and ClientSession::serversession_lost().

Referenced by ServerSession::~ServerSession().

{ 
  if (M_state != disconnected)
  {
    // Inform the server object.
    M_server->connection_lost();
    // Let the client know that the connection was broken.
    if (!M_secondary_connection && identity().has_client_session())
      identity().client_session().serversession_lost();
  }
  M_connected = false;
  M_state = disconnected;
  M_server_session = NULL;
  if (M_secondary_connection)
  {
    M_reconnect = false;
    identity().destroy_secondary_server_connection();
  }
  if (M_reconnect)
    connect(true);
}

void ServerConnection::delayed_connect

(

timer_event_type_ct const &

expired_at

)

Called when the timer for a delayed connect expired.

Never call this function directly.

Definition at line 138 of file ServerConnection.cc.

References do_connect(), DoutEntering, has_server(), is_connected(), M_reconnect, and M_server_session.

Referenced by connect().

{
  DoutEntering(dc::debug, "ServerConnection::delayed_connect(" << expired_at.get_expire_time() << ")");
  if (!is_connected() && M_reconnect && M_server_session && has_server())
    do_connect();
}

void ServerConnection::received_server_port_answer

(

UserAnswerEventType const &

event_type

)

This function is called when an answer to the server/port question is received.

Never call this function directly.

Definition at line 201 of file ServerConnection.cc.

References UserAnswer::answer(), connect(), DoutEntering, has_server(), IdentityReference::identity(), M_server, M_timed_out, and server().

Referenced by connect().

{
  DoutEntering(dc::debug, "ServerConnection::received_server_port_answer(" << event_type << ")");
  std::string answer = event_type.answer();
  std::string hostname;
  unsigned int port = 6667;
  struct in_addr vhost = { INADDR_ANY };

  unsigned int count = 0;
  std::stringstream ss(answer);
  std::string buf;
  while ((ss >> buf))
  {
    if (count == 0)
      hostname = buf;
    else if (count == 1)
      port = atoi(buf.c_str());
    else if (count == 2)
      inet_aton(buf.c_str(), &vhost);
    ++count;
  }

  // See if this server was already known.
  bool found = false;
  for (networks_type::iterator network_iter = Application::instance().networks().begin(); network_iter != Application::instance().networks().end(); ++network_iter)
  {
    // Never change network.
    if (has_server() && server()->network().name() != network_iter->name())
      continue;
    for (Network::servers_type::iterator server_iter = network_iter->servers().begin(); server_iter != network_iter->servers().end(); ++server_iter)
      if (strcasecmp((*server_iter)->hostname().c_str(), hostname.c_str()) == 0 && memcmp(&(*server_iter)->vhost(), &vhost, sizeof(vhost)) == 0)
      {
        Dout(dc::notice, "Found existing server " << *server_iter);
        found = true;
        M_server = *server_iter;
        M_server->set_port(port);
        break;
      }
    if (found)
      break;
  }
  if (!found)
    M_server.reset(NEW(Server(identity().private_network(), hostname, port, vhost)));
  M_timed_out = false;
  connect(false);
}

void ServerConnection::error_message_received

(

ServerMessageIn const &

msg

)

This function is called if an ERROR message is received.

Never call this function directly.

Definition at line 281 of file ServerConnection.cc.

References DoutEntering, M_connect_delay, M_state, MessageIn::param(), server_session(), ServerSession::set_disconnect_reason(), and successful_connect.

Referenced by ServerSession::new_message_received().

{
  DoutEntering(dc::notice, "ServerConnection::error_message_received(" << msg << ")");

  server_session().set_disconnect_reason(msg.param(0));

  if (M_state < successful_connect)
  {
    // FIXME: only do this when the connection was throttled.
    // Different actions are needed on different errors.
    M_connect_delay.tv_sec *= 2;  
    if (M_connect_delay.tv_sec > 600)
      M_connect_delay.tv_sec = 600;
    Dout(dc::notice, "Incrementing connect delay to " << M_connect_delay);
  }
}

void ServerConnection::successful_connection

(

void

)

Called when the first message is received from the server.

Definition at line 300 of file ServerConnection.cc.

References ASSERT, authentication_started, M_connect_delay, M_state, M_timed_out_count, S_connect_delay_init, and successful_connect.

Referenced by AuthState::auth_notice_looking_up_hostname(), AuthState::auth_notice_looking_up_ident(), and decode_ping().

{
  ASSERT(M_state == authentication_started || M_state == successful_connect);
  M_state = successful_connect;
  M_connect_delay = S_connect_delay_init;       // We didn't get throttled.
  M_timed_out_count = 0;
}

void ServerConnection::decode_ping

(

ServerMessageIn const &

ping_msg

)

This function is called when a PING message is received.

Never call this function directly.

Definition at line 312 of file ServerConnection.cc.

References default_priority(), M_server_session, M_state, MessageIn::param(), pong_sent, ServerSession::queue_msg(), real_nick_sent, server_session(), ServerSession::set_auth_ping_argument(), and successful_connection().

Referenced by ServerSession::new_message_received().

{
  if (M_state >= real_nick_sent)
  {
    MessageOut msgout(default_priority(keys::PONG));
    server_session().queue_msg(msgout << keys::PONG << ping_msg.param(0));
  }
  else if (M_state >= pong_sent)
    *M_server_session << "PONG " << ping_msg.param(0) << "\r\n";
  else
  {
    successful_connection();
    M_server_session->set_auth_ping_argument(ping_msg.param(0));
  }
}

void ServerConnection::send_pong_and_mode

(

ExpressionEventType const &

event_type

)

This function is called when it is safe to call it.

See AuthState::AuthState. Never call this function directly.

Definition at line 333 of file ServerConnection.cc.

References ASSERT, ServerSession::auth_ping_argument(), DoutEntering, invisible_event(), ServerSession::M_detected_network, M_server, M_server_session, M_state, ServerSession::message_event_server(), MatchRequest::mynick(), ServerSession::nicks(), NickPair::out_nick(), pong_sent, received_first_umode(), successful_connect, and ServerSession::user_mode().

Referenced by AuthState::send_pong_and_mode().

{
  DoutEntering(dc::notice, "ServerConnection::send_pong_and_mode(" << event_type << ")");

  ASSERT(M_state == successful_connect);                        // We received at least the PING.
  ASSERT(!M_server_session->auth_ping_argument().empty());      // Didn't we?

  *M_server_session << "PONG " << M_server_session->auth_ping_argument() << "\r\n";
  M_state = pong_sent;

  // Send the 'invisible' user mode in the same packet as the PONG, in the hope
  // that the server will process them at the same time. That way we are not
  // (for 2 seconds) visible to the network.
  // Thus, we will have sent [PASS], NICK, USER, PONG, MODE +i -- which should
  // be processed immediately (we have 5 free messages before the flood protection
  // kicks in).
  char service_mode = 'x';      // FIXME, this isn't the same on every network.
  // If we don't know if the USER did set the user mode, ask for the user mode to see if it did.
  // Always sent the +i to assure invisibility at the same time as the PONG is
  // processed.
  if (!M_server->version().get_user_supports_umode())
  {
    // Always set invisibility.
    *M_server_session << "MODE " << M_server_session->nicks().out_nick() << " +i\r\n";
    // Test.
    *M_server_session << "MODE " << M_server_session->nicks().out_nick() << "\r\n";
    // Finish.
    *M_server_session << "MODE " << M_server_session->nicks().out_nick() << " +" << service_mode << "\r\n";
  }
  else if (!*M_server->version().get_user_supports_umode())
    *M_server_session << "MODE " << M_server_session->nicks().out_nick() << " +i" << service_mode << "\r\n";

  ConstExpression<UserModeMask> mask(UserModeMask('i') | service_mode);
  ON_TRUE((*M_server_session->user_mode() & mask) == mask && *M_server_session->M_detected_network, *this, &ServerConnection::invisible_event);

  MatchRequest match_request;
  match_request(keys::MODE).mynick(0);
  M_server_session->message_event_server()(match_request, *this, &ServerConnection::received_first_umode);
}

void ServerConnection::received_first_umode

(

MatcherEventType const &

event_type

)

Called for the first MODE <mynick> received from the server.

This call-back is used to extract the real ident and real hostname, as the IRC server sees it.

Definition at line 392 of file ServerConnection.cc.

References ASSERT, DoutEntering, IdentityReference::identity(), MatcherEventType::message(), MessageIn::prefix_part(), Identity::set_ident(), and Identity::set_real_hostname().

Referenced by send_pong_and_mode().

{
  DoutEntering(dc::debug, "ServerConnection::received_first_umode(" << event_type << ")");
  MessageIn::Part const& prefix(event_type.message().prefix_part());
  char const* p = strchr(prefix.start(), '!');
  ASSERT(p);
  char const* ident = p + 1;
  p = strchr(p, '@');
  ASSERT(p);
  size_t ident_len = p - ident;
  char const* real_hostname = p + 1;
  size_t real_hostname_len = prefix.end() - real_hostname;
  identity().set_real_hostname(std::string(real_hostname, real_hostname_len));
  identity().set_ident(std::string(ident, ident_len));
}

bool ServerConnection::is_connected

(

void

)

const [inline]

Return true if we are connected with a server.

Definition at line 190 of file ServerConnection.h.

References M_connected.

Referenced by connect(), delayed_connect(), and operator<<().

{ return M_connected; }

bool ServerConnection::reconnect

(

void

)

const [inline]

Return true if we try to (stay) connect(ed).

Definition at line 193 of file ServerConnection.h.

References M_reconnect.

Referenced by operator<<(), and ServerSession::~ServerSession().

{ return M_reconnect; }

timeval ServerConnection::connect_delay

(

void

)

const [inline]

Accessor for M_connect_delay.

Definition at line 196 of file ServerConnection.h.

References M_connect_delay.

Referenced by operator<<().

{ return M_connect_delay; }

bool ServerConnection::timed_out

(

void

)

const [inline]

Accessor for M_timed_out.

Definition at line 199 of file ServerConnection.h.

References M_timed_out.

Referenced by operator<<().

{ return M_timed_out; }

int ServerConnection::timed_out_count

(

void

)

const [inline]

Accessor for M_timed_out_count.

Definition at line 202 of file ServerConnection.h.

References M_timed_out_count.

Referenced by operator<<().

{ return M_timed_out_count; }

void ServerConnection::invisible_event

(

ExpressionEventType const &

)

Called when we first turn invisible.

This function is called when MODE +i is received.

Never call this function directly.

Definition at line 377 of file ServerConnection.cc.

References ASSERT, Identity::authentication(), DoutEntering, IdentityReference::identity(), Identity::key(), login_sent, M_server_session, M_state, pong_sent, and Authentication::service_pass().

Referenced by send_pong_and_mode().

{
  DoutEntering(dc::notice, "ServerConnection::invisible_event(" << event_type << ')');
  ASSERT(event_type);   // It should be true, of course.
  
  ASSERT(M_state == pong_sent);
  M_state = login_sent;
  *M_server_session << "PRIVMSG X@channels.undernet.org :login " <<
      identity().key() << ' ' << identity().authentication().service_pass() << "\r\n";
}

void ServerConnection::make_primary

(

void

)

[inline]

For internal use only.

Definition at line 208 of file ServerConnection.h.

References M_secondary_connection.

{ M_secondary_connection = false; }

void ServerConnection::make_secondary

(

void

)

[inline]

For internal use only.

Definition at line 211 of file ServerConnection.h.

References M_secondary_connection.

{ M_secondary_connection = true; }

void ServerConnection::do_connect

(

void

)

[private]

Attempt an immediate connect to the server.

Never call this function directly. Call ServerConnection::connect() instead.

Definition at line 149 of file ServerConnection.cc.

References ASSERT, authentication_started, Identity::client_session(), connect(), ClientSession::del_private_target(), disconnected, DoutEntering, IdentityReference::identity(), M_connected, M_secondary_connection, M_server, M_server_session, M_state, M_timed_out, question_target_name(), Identity::send_notice(), server_port_question, and ServerSession::start_authentication().

Referenced by connect(), and delayed_connect().

{
  DoutEntering(dc::debug, "ServerConnection::do_connect()");
  ASSERT(M_state == disconnected);

  if (identity().has_client_session())
  {
    std::ostringstream buf;
    buf << "Trying to connect to \"" << M_server->hostname().c_str() << "\" (port " << M_server->next_port() << ").";
    identity().send_notice(buf.str(), server_port_question);
  }

  // Reset the timed_out flag.
  M_timed_out = false;
  // Set new time out timer.
  timeval delay = { 4, 0 };
  timerRequest(delay, *this, &ServerConnection::connect_timed_out);

  ASSERT(M_server->next_port() != 0);
  if (M_server_session->connect(M_server->hostname().c_str(), M_server->next_port(), M_server->vhost()))
  {
    M_server->attempting_to_connect();
    M_connected = true;
    M_server_session->start_authentication();
    M_state = authentication_started;
  }
  else
  {
    ASSERT(!M_secondary_connection);    // FIXME
    // If the connect failed, then we have to ask the user for another servername.
    M_server.reset();
    if (identity().has_client_session())
      identity().client_session().del_private_target(question_target_name(server_port_question));
    // Try again.
    connect(true);
  }
}

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		ServerConnection const &	server_connection
	)			[friend]

For debugging purposes. Write a ServerConnection to os.

Definition at line 318 of file debug_ostream_operators.cc.

{
  os << "{server:";
  if (server_connection.M_server.get())
    os << *server_connection.M_server.get();
  else
    os << "<none>";
  os << "; server_session:";
  if (server_connection.has_server_session())
    os << server_connection.server_session();
  else
    os << "<NULL>";
  os << "; reconnect:";
  if (server_connection.reconnect())
    os << "true";
  else
    os << "false";
  os << "; connected:";
  if (server_connection.is_connected())
    os << "true";
  else
    os << "false";
  os << "; state:" << server_connection.state();
  os << "; connect_delay:" << server_connection.connect_delay();
  os << "; timed_out:";
  if (server_connection.timed_out())
    os << "true";
  else
    os << "false";
  os << "; timed_out_count:" << server_connection.timed_out_count();
  os << "; secondary_connection:" << server_connection.secondary_connection();
  return os << '}';
}

---

Member Data Documentation

boost::shared_ptr<Server> ServerConnection::M_server [private]

The server that we are connected to or trying to connect to, or NULL when the server is still unknown.

Definition at line 57 of file ServerConnection.h.

Referenced by connect(), do_connect(), has_server(), operator<<(), received_server_port_answer(), send_pong_and_mode(), server(), and session_lost().

ServerSession* ServerConnection::M_server_session [private]

A pointer to the current server session, or NULL when there is none.

Definition at line 60 of file ServerConnection.h.

Referenced by connect(), decode_ping(), delayed_connect(), disconnect(), do_connect(), has_server_session(), invisible_event(), send_pong_and_mode(), server_session(), session_lost(), and ~ServerConnection().

bool ServerConnection::M_reconnect [private]

True if we should try to (re)connect.

Definition at line 63 of file ServerConnection.h.

Referenced by connect(), delayed_connect(), disconnect(), reconnect(), and session_lost().

bool ServerConnection::M_connected [private]

TCP/IP connect in progress, or connected. True if we actually attempted to connect to the server (after calling ServerConnection::do_connect). Reset when the session was lost (or destructed).

Definition at line 68 of file ServerConnection.h.

Referenced by do_connect(), is_connected(), and session_lost().

state_nt ServerConnection::M_state [private]

The state of the connection.

Definition at line 71 of file ServerConnection.h.

Referenced by change_state(), connect(), decode_ping(), do_connect(), error_message_received(), invisible_event(), send_pong_and_mode(), session_lost(), state(), and successful_connection().

timeval ServerConnection::M_connect_delay [private]

The next connect delay.

Definition at line 73 of file ServerConnection.h.

Referenced by connect(), connect_delay(), error_message_received(), and successful_connection().

timeval ServerConnection::S_connect_delay_init = { 1, 0 } [static, private]

The initial connect delay.

Definition at line 74 of file ServerConnection.h.

Referenced by successful_connection().

bool ServerConnection::M_timed_out [private]

Set if the last connection attempted timed out.

Definition at line 77 of file ServerConnection.h.

Referenced by connect(), do_connect(), received_server_port_answer(), and timed_out().

int ServerConnection::M_timed_out_count [private]

The number of connect attempts left that will time out, until we stop trying.

Definition at line 80 of file ServerConnection.h.

Referenced by connect(), successful_connection(), and timed_out_count().

bool ServerConnection::M_secondary_connection [private]

True if this connection is a secondary connection, while the primary still exists.

Definition at line 83 of file ServerConnection.h.

Referenced by connect(), do_connect(), make_primary(), make_secondary(), my_serverside_nick_name(), secondary_connection(), session_lost(), and set_my_serverside_nick_name().

std::string ServerConnection::M_my_serverside_nick_name [private]

This is my serverside nick name for as long as this is a secondary connection.

Definition at line 86 of file ServerConnection.h.

Referenced by my_serverside_nick_name(), and set_my_serverside_nick_name().

---

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

• ServerConnection.h
• ServerConnection.cc