ircproxy  The Ultimate Cyborg

---

Nick.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Nick.h
//! @brief This file contains the declaration of class Nick.
//
// 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 NICK_H
#define NICK_H

#ifndef USE_PCH
#include "debug.h"
#endif

#include "Target.h"
#include "IdentityReference.h"
#include "IPNumber.h"
#include "Flags.h"
#include "random_nick.h"
#include "Array.h"

class ClientMessageIn;
class ServerMessageIn;

//! The type used for NickData fields.
typedef unsigned int mask_type;

mask_type const username_bit = 1;       //!< Username bit mask.
mask_type const hostname_bit = 2;       //!< Hostname bit mask.
mask_type const ip_bit = 4;             //!< IP number bit mask.
mask_type const realname_bit = 8;       //!< Realname bit mask.
mask_type const servername_bit = 16;    //!< Servername bit mask.
mask_type const idletime_bit = 32;      //!< Idle time bit mask.
mask_type const accountname_bit = 64;   //!< Account name bit mask.
mask_type const hopcount_bit = 128;     //!< Hopcount bit mask.
mask_type const flags_bit = 256;        //!< Flags bit mask.

//! @brief The data that can be associated with a nick name.
//
// The fields of this object might or might not be initialized.
// The caller is responsible for taking care to only call accessors
// for members that are initialized.
class NickData {
public:
  typedef std::map<std::string, boost::weak_ptr<Channel> > common_channels_type;        //!< The type of NickData::M_common_channels

protected:
  mask_type M_initialized;                      //!< A bit mask indicating which of the data below has been retrieved before.
  std::string M_username;                       //!< The username of this nick.
  std::string M_hostname;                       //!< The hostname of this nick.
  IPNumber M_ip;                                //!< The IP number of this nick.
  std::string M_realname;                       //!< The real name info of this nick.
  std::string M_servername;                     //!< The server name of this nick.
  int M_idletime;                               //!< The idle time of this nick.
  std::string M_accountname;                    //!< The account name of this nick.
  int M_hopcount;                               //!< The hop count of this nick.
  Flags M_flags;                                //!< The flags of this nick.
  common_channels_type M_common_channels;       //!< Map with common channels that this nick is on.

public:
  //! Construct an uninitialized NickData object.
  NickData(void) : M_initialized(0) { }

  //! Return a mask indicating which fields are initialized.
  mask_type initialized(void) const { return M_initialized; }
  //! Retrieve the username field (must be initialized first).
  std::string const& username(void) const { ASSERT(M_initialized & username_bit); return M_username; }
  //! Retrieve the hostname field (must be initialized first).
  std::string const& hostname(void) const { ASSERT(M_initialized & hostname_bit); return M_hostname; }
  //! Retrieve the IP field (must be initialized first).
  IPNumber const& ip(void) const { ASSERT(M_initialized & ip_bit); return M_ip; }
  //! Retrieve the realname field (must be initialized first).
  std::string const& realname(void) const { ASSERT(M_initialized & realname_bit); return M_realname; }
  //! Retrieve the servername field (must be initialized first).
  std::string const& servername(void) const { ASSERT(M_initialized & servername_bit); return M_servername; }
  //! Retrieve the idle time field (must be initialized first).
  int idletime(void) const { ASSERT(M_initialized & idletime_bit); return M_idletime; }
  //! Retrieve the account field (must be initialized first).
  std::string const& accountname(void) const { ASSERT(M_initialized & accountname_bit); return M_accountname; }
  //! Retrieve the hopcount field (must be initialized first).
  int hopcount(void) const { ASSERT(M_initialized & hopcount_bit); return M_hopcount; }
  //! Retrieve the flags field (must be initialized first).
  Flags const& flags(void) const { ASSERT(M_initialized & flags_bit); return M_flags; }

  //! Set the username field.
  void set_username(std::string const& username) { M_initialized |= username_bit; M_username = username; }
  //! Set the hostname field.
  void set_hostname(std::string const& hostname) { M_initialized |= hostname_bit; M_hostname = hostname; }
  //! Set the IP field.
  void set_ip(IPNumber const& ip) { M_initialized |= ip_bit; M_ip = ip; }
  //! Set the realname field.
  void set_realname(std::string const& realname) { M_initialized |= realname_bit; M_realname = realname; }
  //! Set the servername field.
  void set_servername(std::string const& servername) { M_initialized |= servername_bit; M_servername = servername; }
  //! Set the idletime field.
  void set_idletime(int idletime) { M_initialized |= idletime_bit; M_idletime = idletime; }
  //! Set the accountname field.
  void set_accountname(std::string const& accountname) { M_initialized |= accountname_bit; M_accountname = accountname; }
  //! Set the hopcount.
  void set_hopcount(int hopcount) { M_initialized |= hopcount_bit; M_hopcount = hopcount; }
  //! Set the flags.
  void set_flags(Flags const& flags) { M_initialized |= flags_bit; M_flags = flags; }

  //! Mark all data as uninitialized.
  void reset(void) { M_initialized = 0; }

  //! Accessor for NickData::M_common_channels.
  common_channels_type& common_channels(void) { return M_common_channels; }

  //! Accessor for NickData::M_common_channels.
  common_channels_type const& common_channels(void) const { return M_common_channels; }
};

//! @brief Event Type for WHO query results.
class WhoEventType : public NickData {
};

//! \brief Request data passed to the event server.
class WhoRequestData {
private:
  std::string M_nick;           //!< The nick that a WHO is requested for.
public:
  //! Construct a WhoRequestData instance for nick \a nick.
  WhoRequestData(std::string const& nick) : M_nick(nick) { }
  //! Return the nick that a WHO is requested for.
  std::string const& nick(void) const { return M_nick; }
};

//! \brief Base class for WHO query event request objects.
class WhoEventRequestBase : public event_request_base_tct<WhoEventType> {
public:
  typedef WhoRequestData event_request_data_ct; //!< RequestData type.
private:
  event_request_data_ct M_request_data;         //!< The request data.
public:
  //! Constructor.
  WhoEventRequestBase(event_client_tracker_ct* event_client_tracker, event_request_data_ct const& event_request_data) :
      event_request_base_tct<WhoEventType>(event_client_tracker), M_request_data(event_request_data) { }
};

//! The event server for WhoEventType.
typedef event_data_server_tct<WhoEventRequestBase> WhoEventServer;

//! @brief A nick name.
//
// This class represents a nick name.
class Nick : public Target {
private:
  NickData M_data;                              //!< All non-channel related info about a nick name (WHO output).
  int M_common_channels;                        //!< The number of channels that this nick is on that we are on as well.
  Array<std::string> M_clientside_name;         //!< The (input) nick name as function of the client session.
  Array<std::string> M_serverside_name;         //!< The (input) nick name as function of the server session.

protected:
  //! Construct my own nick.
  Nick(Identity& identity);

public:
  //! Construct a Nick object for server session \a server_session and target name \a target_name.
  Nick(ServerSession const& server_session, std::string const& target_name);

  //! Construct a private Nick for client session \a client_session, nick name \a target_name and private network \a private_network.
  Nick(ClientSession const& client_session, std::string const& target_name, Network& private_network);

#ifdef CWDEBUG
  //! Destructor (for debugging purpose: prints the destruction event).
  ~Nick() { Dout(dc::objects, "Destructing Nick " << *this); }
private:
  //! Copyconstructor (for debugging purpose: prints the copy event).
  Nick(Nick const& nick) : Target(nick),
      M_data(nick.M_data), M_common_channels(nick.M_common_channels)
      { DoutFatal(dc::core, "Copy-constructing Nick from " << nick); }
#endif

public:
  //! Returns true if the non-channel related info for this nick as specified by \a mask is known.
  bool is_initialized(mask_type mask) const { return (M_data.initialized() & mask) == mask; }
  //! Returns true if the non-channel related info for this nick as specified by \a mask is up to date.
  bool is_synced(mask_type mask) const { return M_common_channels > 0 && (M_data.initialized() & mask) == mask; }
  //! Return the exact bits for \a mask that are initialized.
  mask_type initialized(mask_type mask) const { return M_data.initialized() & mask; }
  //! Return the exact bits for \a mask that are up to date.
  mask_type synced(mask_type mask) const { return M_common_channels > 0 ? M_data.initialized() & mask : 0; }

  //! Const data accessor.
  NickData const& data(void) const { return M_data; }
  //! Non-const data accessor.
  NickData& data(void) { return M_data; }

  //! Called when a NICK message was received from the server.
  void serverside_nick_changed_to(ServerSession const& server_session, std::string const& new_nick);

  //! Called when a NICK message is send to the client.
  void clientside_nick_changed_to(ClientSession const& client_session, std::string const& new_nick);

  //! Add a channel to the common channels map.
  void add_channel(boost::shared_ptr<Channel> const& channel);

  //! Remove a channel from the common channels map.
  void sub_channel(Channel const& channel);

  //! Return true if this is my nick.
  virtual bool is_me(void) const { return false; }

  //! Update the network pointer from the temporary private network to the final real network.
  // Upon reconnection, after connection loss, we call this function again with the same network pointer.
  // Called from ServerSession::detected_network.
  void set_network(Network* network) { ASSERT(!network->is_private() && (M_network->is_private() || M_network == network)); M_network = network; }

  virtual void new_client_message_received(ClientMessageIn const& msg);
  virtual void new_server_message_received(ServerMessageIn const& msg);

  virtual std::string in_name(ClientSession const& client_session) const;
  virtual std::string in_name(ServerSession const& server_session) const;
  virtual std::string out_name(ClientSession const& client_session) const;
  virtual std::string out_name(ServerSession const& server_session) const;

  virtual void set_in_nick(ClientSession const& client_session, std::string const& in_nick);
  virtual void set_in_nick(ServerSession const& server_session, std::string const& in_nick);
  virtual void set_out_nick(ClientSession const& client_session, std::string const& out_nick);
  virtual void set_out_nick(ServerSession const& server_session, std::string const& out_nick);
};

//! @brief My own nick name.
//
// This class is used for the nicks that ircproxy connects with.
class MyNick : public Nick {
  private:
    Array<std::string> M_clientside_out_name;           //!< The output nick name as function of the client session.
    Array<std::string> M_serverside_out_name;           //!< The output nick name as function of the server session.

  public:
    //! Construct my own nick.
    MyNick(Identity& identity) : Nick(identity) { }

    //! Return true if this is my nick.
    virtual bool is_me(void) const { return true; }

    virtual std::string out_name(ClientSession const& client_session) const;
    virtual std::string out_name(ServerSession const& server_session) const;

    virtual void set_out_nick(ClientSession const& client_session, std::string const& out_nick);
    virtual void set_out_nick(ServerSession const& server_session, std::string const& out_nick);
};

#endif // NICK_H

---