ircproxy  The Ultimate Cyborg

---

Identity.h

Go to the documentation of this file.

// ircproxy -- An intelligent IRC proxy
//
//! @file Identity.h
//! @brief Header of class Identity
//
// 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 IDENTITY_H
#define IDENTITY_H

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

#include "Network.h"
#include "ServerConnection.h"
#include "question_nt.h"

class MessageIn;
class Authentication;
class ClientSession;
class PersistXML;

//! String constant used for unknown ident.
static char const* const unknown_ident = "~unknown-yet";

//! String constant used for unknown hostname.
static char const* const unknown_hostname = "unknown-yet.net";

//! String constant used for unknown real name.
static char const* const unknown_real_name = "Unknown Yet";

//! String constant used for unknown network name.
static char const* const unknown_network_name = "UnknowYet";

/*! @brief A Nick/Network identity.
 *
 * The IRC Client provides a unique key with the PASS message.
 * Each unique key corresponds to a single Identity, making it
 * possible to re-attach to an identity after losing connection.
 *
 * The uniqueness corresponds therefore to the uniqueness of
 * a nick/network combination (also in that case there can only
 * be one unique value).
 */
class Identity : public virtual event_client_ct {
private:
  std::string M_key;                                    //!< The unique identity key as used with the identity map.
  boost::shared_ptr<Authentication> M_authentication;   //!< Temporary authentication token, or NULL.
  boost::shared_ptr<Nick> M_mynick;                     //!< Pointer to the Nick object representing my own nick.
  std::string M_authpass;                               //!< Authentication password.
  Network M_private_network;                            //!< Fake network, private to this identity.
  ClientSession* M_client_session;                      //!< Pointer to the current client session.
  std::string M_ident;                                  //!< A best-guess for this users ident.
  std::string M_real_hostname;                          //!< A best-guess for this users real hostname.
  std::string M_hostname;                               //!< A best-guess for this users (cloaked) hostname.
  std::string M_real_name;                              //!< A best-guess for this users real name.
  std::string M_network_name;                           //!< The network name that corresponds to this identity.
  boost::shared_ptr<ServerConnection> M_primary_server_connection;      //!< Our link to some server.
  boost::shared_ptr<ServerConnection> M_secondary_server_connection;    //!< Link to a secondary server connection in progress, or NULL when none.

public:
  //! Construct an Identity object for initialization from XML file.
  Identity(void) :
      M_mynick(NEW(MyNick(*this))),
      M_private_network("private network", true),
      M_client_session(NULL),
      M_ident(unknown_ident),
      M_real_hostname(unknown_hostname),
      M_hostname(unknown_hostname),
      M_real_name(unknown_real_name),
      M_network_name(unknown_network_name),
      M_primary_server_connection(NEW(ServerConnection(this)))
      { Dout(dc::objects, "Constructing Identity"); }

  //! Construct an Identity object with key \a key.
  Identity(std::string const& key) :
      M_key(key),
      M_mynick(NEW(MyNick(*this))),
      M_private_network("private network of " + key, true),
      M_client_session(NULL),
      M_ident(unknown_ident),
      M_real_hostname(unknown_hostname),
      M_hostname(unknown_hostname),
      M_real_name(unknown_real_name),
      M_network_name(unknown_network_name),
      M_primary_server_connection(NEW(ServerConnection(this)))
      { Dout(dc::objects, "Constructing Identity(\"" << key << "\")"); }

  //! Destruct an Identity.
  ~Identity();

  //! WARNING: This is NOT a real copy constructor. It's unfortunately needed for identities_type to work.
  Identity(Identity const& identity) : event_client_ct(identity),
      M_key(identity.M_key),
      M_authentication(identity.M_authentication),
      M_mynick(NEW(MyNick(*this))),
      M_authpass(identity.M_authpass),
      M_private_network(identity.M_private_network),
      M_client_session(identity.M_client_session),
      M_ident(identity.M_ident),
      M_real_hostname(identity.M_real_hostname),
      M_hostname(identity.M_hostname),
      M_real_name(identity.M_real_name),
      M_network_name(identity.M_network_name),
      M_primary_server_connection(NEW(ServerConnection(this))),
      M_secondary_server_connection(identity.M_secondary_server_connection)
      { ASSERT(!M_secondary_server_connection.get()); ASSERT(M_mynick.use_count() <= 1); Dout(dc::objects, "Copy-constructing Identity from " << identity); }

  //! Serialize the object.
  void serialize(PersistXML& xml);

  //! The key of this Identity.
  std::string const& key(void) const { return M_key; }

  //! Called when a new message was received from the associated client.
  void new_client_message_received(ClientMessageIn const& msg);

  //! Called when a new message was received from the associated server.
  void new_server_message_received(ServerMessageIn const& msg);

  //! Returns a pointer to my Nick object.
  boost::shared_ptr<Nick const> mynick(void) const { ASSERT(!debug::secondary_connection); return M_mynick; }

  //! Returns a pointer to my Nick object.
  boost::shared_ptr<Nick> mynick(void) { ASSERT(!debug::secondary_connection); return M_mynick; }

  //! Return a reasonable servername that can be used as source for client messages.
  std::string server_source(void) const;

  //! Returns a best-guess for the users ident string.
  std::string ident(void) const { return M_ident; }

  //! Returns a best-guess for the users host name.
  std::string real_hostname(void) const { return M_real_hostname; }

  //! Returns a best-guess for the users host name.
  std::string hostname(void) const { return M_hostname; }

  //! Returns a best-guess for the users real name.
  std::string real_name(void) const { return M_real_name; }

  //! Returns the network name that this identity corresponds with.
  std::string network_name(void) const { return M_network_name; }

  //! Set ident string as returned by ident().
  void set_ident(std::string const& ident)
      { Dout(dc::debug, "Setting ident to \"" << ident << "\"."); M_ident = ident; }

  //! Set host name string as returned by real_hostname().
  void set_real_hostname(std::string const& real_hostname)
      { Dout(dc::debug, "Setting real hostname to \"" << real_hostname << "\"."); M_real_hostname = real_hostname; }

  //! Set host name string as returned by hostname().
  void set_hostname(std::string const& hostname)
      { Dout(dc::debug, "Setting hostname to \"" << hostname << "\"."); M_hostname = hostname; }

  //! Set real name string as returned by real_name().
  void set_real_name(std::string const& real_name) { M_real_name = real_name; }

  //! Set network name string as returned by real_name().
  void set_network_name(std::string const& network_name) { M_network_name = network_name; }

  //! Returns true if an authentication password is needed.
  bool has_authentication_password(void) const { return !M_authpass.empty(); }

  //! Returns the authentication password. Should only be called if has_authentication_password returns true.
  std::string const& authentication_password(void) const { ASSERT(has_authentication_password()); return M_authpass; }

  //! Return the fake network object, private to this identity.
  Network const& private_network(void) const { return M_private_network; }

  //! Return the fake network object, private to this identity.
  Network& private_network(void) { return M_private_network; }

  //! Return the network object of the connection belonging to this identity.
  Network const& network(void) const { return server_connection().network(); }

  //! Return the network object of the connection belonging to this identity.
  Network& network(void) { return server_connection().network(); }

  //! Set current ClientSession of this Identity, called by ClientSession::new_message_received.
  void set_client_session(ClientSession* client_session) { M_client_session = client_session; }

  //! Reset the ClientSession of this Identity, provided it matches the currently set ClientSession.
  void reset_client_session(ClientSession* client_session)
      { if (M_client_session == client_session) M_client_session = NULL; }

  //! Return true if this identity is associated with a client session.
  bool has_client_session(void) const { return M_client_session; }

  //! Return true if this identity is associated with a server session.
  bool has_server_session(void) const { return M_primary_server_connection->has_server_session(); }

  //! Return the current ClientSession.
  ClientSession const& client_session(void) const { ASSERT(M_client_session != NULL); return *M_client_session; }

  //! Return the current ClientSession.
  ClientSession& client_session(void) { ASSERT(M_client_session != NULL); return *M_client_session; }

  //! Return the current ClientSession.
  ServerSession const& server_session(void) const { return M_primary_server_connection->server_session(); }

  //! Return the current ClientSession.
  ServerSession& server_session(void) { return M_primary_server_connection->server_session(); }

  //! Return a target with prefix \a prefix that is not already in the private network map.
  //std::string unique_target(char const* prefix) const;

  //! Return a target for ircproxy notices related to question \a number.
  boost::shared_ptr<Target> notice_target(question_nt number);

  //! Return the primary server connection object.
  ServerConnection const& server_connection(void) const { return *M_primary_server_connection; }

  //! Return the primary server connection object.
  ServerConnection& server_connection(void) { return *M_primary_server_connection; }

  //! Start a secondary server connection, which will take over the primary once connected.
  void start_secondary_server_connection(boost::shared_ptr<Server> new_server)
      {
        ASSERT(!has_secondary_server_connection());
#ifdef CWDEBUG
        // Mark that we are about to start handling a secondary connection.
        debug::SecondaryConnection dummy(true);
#endif
        M_secondary_server_connection.reset(NEW(ServerConnection(this, new_server)));
        M_secondary_server_connection->connect(false);
      } 

  //! Swap primary and secondary connection.
  void swap_primary_and_secondary_connection(void)
      {
        std::swap(M_primary_server_connection, M_secondary_server_connection);
        M_primary_server_connection->make_primary();
        M_secondary_server_connection->make_secondary();
      }

  //! Terminate the secondary connection.
  void end_secondary_server_connection(void)
      {
        ASSERT(has_secondary_server_connection());
#ifdef CWDEBUG
        // Mark that we are about to start handling a secondary connection.
        debug::SecondaryConnection dummy(true);
#endif
        M_secondary_server_connection->disconnect();    // This will result in ServerConnection::session_lost being called,
                                                        // which will call destroy_secondary_server_connection().
      }

  // \internal
  // Called from ServerConnection::session_lost.
  void destroy_secondary_server_connection(void)
      {
        M_secondary_server_connection.reset();
      }

  //! Return true if this identity is associated with a secondary server connection.
  bool has_secondary_server_connection(void) const { return M_secondary_server_connection.get(); }

  //! Return the secondary server connection. Only valid if has_secondary_server_connection returns true.
  boost::shared_ptr<ServerConnection const> secondary_server_connection(void) const
      { return boost::const_pointer_cast<ServerConnection const>(M_secondary_server_connection); }

  //! Return the secondary server connection. Only valid if has_secondary_server_connection returns true.
  boost::shared_ptr<ServerConnection> secondary_server_connection(void)
      { return M_secondary_server_connection; }

  //! Return the authentication object.
  Authentication const& authentication(void) const { return *M_authentication; }

  //! Return the authentication object.
  Authentication& authentication(void) { return *M_authentication; }

  void do_quit(boost::shared_ptr<Nick> nick, std::string const& quit_message);
  void send_notice(std::string const& notice, question_nt number = no_related_question);
  void received_network_domain_answer(UserAnswerEventType const& event_type,
      std::pair<std::string, std::string> network_domain);
  void pass_as_is_to_server(ClientMessageIn const& msg);
  void pass_as_is_to_client(ServerMessageIn const& msg);

private:
  void pass_as_is_to(MessageIn const& msg, std::ostream& os);

public:
  friend std::ostream& operator<<(std::ostream& os, Identity const& identity);
};

#endif // IDENTITY_H

---