ircproxy  The Ultimate Cyborg

---

ServerConnection.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file ServerConnection.h
//! @brief This file contains the declaration of class ServerConnection.
//
// Copyright (C) 2006, 2007 by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.

#ifndef SERVERCONNECTION_H
#define SERVERCONNECTION_H

#ifndef USE_PCH
#include <boost/shared_ptr.hpp>
#include <sys/time.h>
#include "debug.h"
#include <libcw/events.h>
#endif

#include "MessageOut.h"
#include "ServerSession.h"
#include "IdentityReference.h"
#include "Server.h"
#include "random_nick.h"

class UserAnswerEventType;
class ServerMessageIn;
class ExpressionEventType;

//! Connection states.
enum state_nt {
  disconnected,                 //!< Disconnected
  authentication_started,       //!< PASS, NICK and USER message sent.
  successful_connect,           //!< Received first server message
  pong_sent,                    //!< PONG and MODE +i sent.
  login_sent,                   //!< Login message to X sent.
  real_nick_sent,               //!< NICK with real nick name sent.
  real_nick_accepted            //!< NICK with real nick accepted.
};

/*! @brief 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.
 */
class ServerConnection : public IdentityReference, public virtual event_client_ct {
private:
  //! The server that we are connected to or trying to connect to, or NULL when the server is still unknown.
  boost::shared_ptr<Server> M_server;

  //! A pointer to the current server session, or NULL when there is none.
  ServerSession* M_server_session;

  //! True if we should try to (re)connect.
  bool M_reconnect;

  //! 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).
  bool M_connected;

  //! The state of the connection.
  state_nt M_state;

  timeval M_connect_delay;                      //!< The next connect delay.
  static timeval S_connect_delay_init;          //!< The initial connect delay.

  //! Set if the last connection attempted timed out.
  bool M_timed_out;

  //! The number of connect attempts left that will time out, until we stop trying.
  int M_timed_out_count;

  //! True if this connection is a secondary connection, while the primary still exists.
  bool M_secondary_connection;

  //! This is my serverside nick name for as long as this is a secondary connection.
  std::string M_my_serverside_nick_name;

public:
  //! Constructor.
  ServerConnection(Identity* identity) :
      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 << ")");
      }

  //! Constructor for secondary connection.
  ServerConnection(Identity* identity, boost::shared_ptr<Server> server) :
      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 << ")");
      }

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

  //! Return the state of the connection.
  state_nt state(void) const { return M_state; }

  //! Return true if this is a secondary connection.
  bool secondary_connection(void) const { return M_secondary_connection; }

  //! Set a new serverside nick name for myself. May only be called for a secondary connection.
  void set_my_serverside_nick_name(std::string const& my_serverside_nick_name)
      { ASSERT(M_secondary_connection); M_my_serverside_nick_name = my_serverside_nick_name; }

  //! Get my serverside nick name. Only valid for secondary connection.
  std::string const& my_serverside_nick_name(void) const
      { ASSERT(M_secondary_connection); return M_my_serverside_nick_name; }

  //! Change the state of the connection from \a from to \a to.
  void change_state(state_nt LIBCW_UNUSED_UNLESS_DEBUG(from), state_nt to)
      {
        Debug(ASSERT(M_state == from));
        M_state = to;
      }

  //! Return true if we have a server object.
  bool has_server(void) const { return M_server.get(); }

  //! Returns the server that we are connected with or connecting to.
  boost::shared_ptr<Server const> server(void) const { ASSERT(has_server()); return boost::const_pointer_cast<Server const>(M_server); }

  //! Returns the server that we are connected with or connecting to.
  boost::shared_ptr<Server> server(void) { ASSERT(has_server()); return M_server; }

  //! Return true if we have a server session object.
  bool has_server_session(void) const { return M_server_session; }

  //! Return the ServerSession.
  ServerSession const& server_session(void) const { return *M_server_session; }

  //! Return the ServerSession.
  ServerSession& server_session(void) { return *M_server_session; }

  //! Return the network object of the current connection.
  Network const& network(void) const { return server()->network(); }

  //! Return the network object of the current connection.
  Network& network(void) { return server()->network(); }

  // Connect to the server and stay connected.
  void connect(bool auto_reconnect);

  //! Disconnect from the server.
  void disconnect(void)
      {
        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 session_lost(void);
  void delayed_connect(timer_event_type_ct const& expired_at);
  void connect_timed_out(timer_event_type_ct const& expired_at);
  void received_server_port_answer(UserAnswerEventType const& event_type);
  void error_message_received(ServerMessageIn const& msg);
  void successful_connection(void);
  void decode_ping(ServerMessageIn const& pong_msg);
  void send_pong_and_mode(ExpressionEventType const& event_type);
  void received_first_umode(MatcherEventType const& event_type);
  void quit(std::string const& msg);

  //! Return true if we are connected with a server.
  bool is_connected(void) const { return M_connected; }

  //! Return true if we try to (stay) connect(ed).
  bool reconnect(void) const { return M_reconnect; }

  //! Accessor for M_connect_delay.
  timeval connect_delay(void) const { return M_connect_delay; }

  //! Accessor for M_timed_out.
  bool timed_out(void) const { return M_timed_out; }

  //! Accessor for M_timed_out_count.
  int timed_out_count(void) const { return M_timed_out_count; }

  //! Called when we first turn invisible.
  void invisible_event(ExpressionEventType const&);

  //! \internal
  void make_primary(void) { M_secondary_connection = false; }

  //! \internal
  void make_secondary(void) { M_secondary_connection = true; }

private:
  void do_connect(void);

  friend std::ostream& operator<<(std::ostream& os, ServerConnection const& server_connection);
};

#endif // SERVERCONNECTION_H

---