ircproxy  The Ultimate Cyborg

---

Server.h

Go to the documentation of this file.

// ircproxy -- An intelligent IRC proxy
//
//! @file Server.h
//! @brief Header of class Server
//
// Copyright (C) 2005 - 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 SERVER_H
#define SERVER_H

#ifndef USE_PCH
#include <vector>
#include <netinet/in.h>
#include "debug.h"
#include <libcw/timing.h>
#endif

#include "ServerVersion.h"

class PersistXML;

/*! @brief An IRC server.
 * 
 * This class represents an IRC server.
 */
class Server {
public:
  typedef std::vector<unsigned short> ports_type;       //!< The type of the list with ports.

private:
  //! The resolvable name of the server, or IP number if there is no hostname available.
  std::string           M_hostname;             

  //! The IRC name of the server, as received by the proxy during connect.
  std::string           M_irc_name;             

  ports_type            M_ports;                        //!< Client listen ports that we successfully connected to in the past.
  unsigned short        M_default_port;                 //!< The last port that was successfully connected to.
  unsigned short        M_next_port;                    //!< The next port that we will try to connect to.
  unsigned short        M_port;                         //!< The port that we try to connect to.

  struct in_addr        M_vhost;                        //!< Vhost to use to connect to server.

  Network*              M_network;                      //!< Reference to the corresponding network.
  timeval               M_last_connection_event;        //!< Last time we disconnected or tried to connect to this server.

  static timeval        S_last_connection_event_init;   //!< Initial value for M_last_connection_event.

  ServerVersion         M_version;                      //!< Information about the server version.

public:
  //! Construct a Server object with DNS name \a hostname and default listen port \a default_port.
  Server(Network& network, std::string const& hostname, unsigned short port, struct in_addr vhost) :
      M_hostname(hostname), M_default_port(port), M_next_port(port), M_port(0), M_vhost(vhost),
      M_network(&network), M_last_connection_event(S_last_connection_event_init)
      {
        Dout(dc::objects, "Constructing Server(" << network << ", \"" << hostname << "\", " << port << ", " << vhost << ")");
      }

  //! Construct an uninitialized object for the given network.
  Server(void) : M_next_port(0), M_network(NULL)
      {
        Dout(dc::objects, "Constructing Server()");
        std::memset(&M_vhost, 0, sizeof(struct in_addr));
      }

  //! Copy constructor.
  Server(Server const& server) :
      M_hostname(server.M_hostname),
      M_irc_name(server.M_irc_name),
      M_ports(server.M_ports),
      M_default_port(server.M_default_port),
      M_next_port(server.M_next_port),
      M_port(server.M_port),
      M_vhost(server.M_vhost),
      M_network(server.M_network),
      M_last_connection_event(server.M_last_connection_event)
      { Dout(dc::objects, "Copy-constructing Server from " << server); }

  //! The resolvable name of the server that one can connect to (as passed to the constructor).
  std::string const& hostname(void) const { return M_hostname; }

  //! Return the next port we will try to connect to.
  unsigned short next_port(void) const { return M_next_port; }

  //! Set the next port to connect to.
  void set_next_port(unsigned short next_port) { M_next_port = next_port; }

  //! Returns one of the ports of the server that one can connect to.
  unsigned short random_port(void) const;

  //! Returns the port we last tried to connect to.
  unsigned short port(void) const { return M_port; }

  //! Returns a reference to the vhost of this server.
  struct in_addr& vhost(void) { return M_vhost; }

  //! Returns the vhost that should be used for this server.
  struct in_addr vhost(void) const { return M_vhost; }

  //! A const reference to the list with known port numbers of this server.
  ports_type const& ports(void) const { return M_ports; }

  //! Return the corresponding network.
  Network const& network(void) const { return *M_network; }

  //! Return the corresponding network.
  Network& network(void) { return *M_network; }

  //! Set the final network. Called from Identity::detected_network.
  void set_network(Network* network) { M_network = network; }

  //! The server version object.
  ServerVersion const& version(void) const { return M_version; }

  //! The server version object.
  ServerVersion& version(void) { return M_version; }

  //! Return true if port \a port is known.
  bool find_port(unsigned short port) const
  {
    ports_type::const_iterator iter = std::find(M_ports.begin(), M_ports.end(), port);
    return iter != M_ports.end(); 
  }

  //! Add port \a port (duplicates are ignored). Return true when it was a new port.
  bool add_port(unsigned short port)
    {
      bool new_port = !this->find_port(port);
      if (new_port)
        M_ports.push_back(port);
      return new_port;
    }

  //! Delete port \a port. Return true when the port was found.
  bool delete_port(unsigned short port)
    {
      ports_type::iterator iter = std::find(M_ports.begin(), M_ports.end(), port);
      bool found = iter != M_ports.end();
      if (found)
        M_ports.erase(iter);
      return found;
    }

  //! Make \a port the port returned by port().
  void set_port(unsigned short port)
    {
      delete_port(port);
      M_ports.insert(M_ports.begin(), port);
    }

  //! Set the IRC name of this server. Returns true when not set before.
  bool set_irc_name(std::string const& irc_name)
    {
      bool empty = M_irc_name.empty();
      M_irc_name = irc_name;
      return empty;
    }

  //! IRC name of the server as set with set_irc_name.
  std::string const& get_irc_name(void) const { return M_irc_name; }

  //! Last we attempted to connect to this server.
  timeval const& last_connection_event(void) const { return M_last_connection_event; }

  //! Called when a connect attempt to the server is being made.
  void attempting_to_connect(void)
      {
        M_port = M_next_port;
        M_next_port = random_port();
        M_last_connection_event = timerRequest.get_now();
      }

  //! Called when we disconnected from this server.
  void connection_lost(void) { M_last_connection_event = timerRequest.get_now(); }

  void serialize(PersistXML& xml);
};

#endif // SERVER_H

---