Identity Class Reference

#include <Identity.h>

Inheritance diagram for Identity:

List of all members.

---

Detailed Description

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).

Definition at line 58 of file Identity.h.

Public Member Functions
	Identity (void)
	Construct an Identity object for initialization from XML file.
	Identity (std::string const &key)
	Construct an Identity object with key key.
	~Identity ()
	Destruct an Identity.
	Identity (Identity const &identity)
	WARNING: This is NOT a real copy constructor. It's unfortunately needed for identities_type to work.
void	serialize (PersistXML &xml)
	Serialize the object.
std::string const &	key (void) const
	The key of this Identity.
void	new_client_message_received (ClientMessageIn const &msg)
	Called when a new message was received from the associated client.
void	new_server_message_received (ServerMessageIn const &msg)
	Called when a new message was received from the associated server.
boost::shared_ptr< Nick const >	mynick (void) const
	Returns a pointer to my Nick object.
boost::shared_ptr< Nick >	mynick (void)
	Returns a pointer to my Nick object.
std::string	server_source (void) const
	Return a reasonable servername that can be used as source for client messages.
std::string	ident (void) const
	Returns a best-guess for the users ident string.
std::string	real_hostname (void) const
	Returns a best-guess for the users host name.
std::string	hostname (void) const
	Returns a best-guess for the users host name.
std::string	real_name (void) const
	Returns a best-guess for the users real name.
std::string	network_name (void) const
	Returns the network name that this identity corresponds with.
void	set_ident (std::string const &ident)
	Set ident string as returned by ident().
void	set_real_hostname (std::string const &real_hostname)
	Set host name string as returned by real_hostname().
void	set_hostname (std::string const &hostname)
	Set host name string as returned by hostname().
void	set_real_name (std::string const &real_name)
	Set real name string as returned by real_name().
void	set_network_name (std::string const &network_name)
	Set network name string as returned by real_name().
bool	has_authentication_password (void) const
	Returns true if an authentication password is needed.
std::string const &	authentication_password (void) const
	Returns the authentication password. Should only be called if has_authentication_password returns true.
Network const &	private_network (void) const
	Return the fake network object, private to this identity.
Network &	private_network (void)
	Return the fake network object, private to this identity.
Network const &	network (void) const
	Return the network object of the connection belonging to this identity.
Network &	network (void)
	Return the network object of the connection belonging to this identity.
void	set_client_session (ClientSession *client_session)
	Set current ClientSession of this Identity, called by ClientSession::new_message_received.
void	reset_client_session (ClientSession *client_session)
	Reset the ClientSession of this Identity, provided it matches the currently set ClientSession.
bool	has_client_session (void) const
	Return true if this identity is associated with a client session.
bool	has_server_session (void) const
	Return true if this identity is associated with a server session.
ClientSession const &	client_session (void) const
	Return the current ClientSession.
ClientSession &	client_session (void)
	Return the current ClientSession.
ServerSession const &	server_session (void) const
	Return the current ClientSession.
ServerSession &	server_session (void)
	Return the current ClientSession.
boost::shared_ptr< Target >	notice_target (question_nt number)
	Return a target with prefix prefix that is not already in the private network map.
ServerConnection const &	server_connection (void) const
	Return the primary server connection object.
ServerConnection &	server_connection (void)
	Return the primary server connection object.
void	start_secondary_server_connection (boost::shared_ptr< Server > new_server)
	Start a secondary server connection, which will take over the primary once connected.
void	swap_primary_and_secondary_connection (void)
	Swap primary and secondary connection.
void	end_secondary_server_connection (void)
	Terminate the secondary connection.
bool	has_secondary_server_connection (void) const
	Return true if this identity is associated with a secondary server connection.
boost::shared_ptr < ServerConnection const >	secondary_server_connection (void) const
	Return the secondary server connection. Only valid if has_secondary_server_connection returns true.
boost::shared_ptr < ServerConnection >	secondary_server_connection (void)
	Return the secondary server connection. Only valid if has_secondary_server_connection returns true.
Authentication const &	authentication (void) const
	Return the authentication object.
Authentication &	authentication (void)
	Return the authentication object.
void	send_notice (std::string const &notice, question_nt number=no_related_question)
	Send a notice to the client.
void	received_network_domain_answer (UserAnswerEventType const &event_type, std::pair< std::string, std::string > network_domain)
	Event call back: network domain answer received. Process it.
void	pass_as_is_to_server (ClientMessageIn const &msg)
	Write ClientMessageIn msg to the server.
void	pass_as_is_to_client (ServerMessageIn const &msg)
	Write ServerMessageIn msg to the client.
Private Member Functions
void	pass_as_is_to (MessageIn const &msg, std::ostream &os)
	Write MessageIn msg to the ostream os.
Private Attributes
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.
Friends
std::ostream &	operator<< (std::ostream &os, Identity const &identity)
	For debugging purposes. Write a Identity to os.

---

Constructor & Destructor Documentation

Identity::Identity

(

void

)

[inline]

Construct an Identity object for initialization from XML file.

Definition at line 76 of file Identity.h.

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

                 :
      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"); }

Identity::Identity

(

std::string const &

key

)

[inline]

Construct an Identity object with key key.

Definition at line 89 of file Identity.h.

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

                                 :
      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 << "\")"); }

Identity::~Identity

(

)

Destruct an Identity.

Definition at line 777 of file Identity.cc.

References client_session(), has_client_session(), has_server_session(), ServerSession::joined_channels(), ClientSession::joined_channels(), debug::channels::dc::objects, and server_session().

{
  Dout(dc::objects, "Destructing Identity " << *this << ".");
  // Destruct channels before destructing private network.
  if (has_client_session())
    client_session().joined_channels().clear();
  if (has_server_session())
    server_session().joined_channels().clear();
  cancel_all_requests();
}

Identity::Identity

(

Identity const &

identity

)

[inline]

WARNING: This is NOT a real copy constructor. It's unfortunately needed for identities_type to work.

Definition at line 106 of file Identity.h.

References ASSERT, M_mynick, M_secondary_server_connection, and debug::channels::dc::objects.

                                     : 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); }

---

Member Function Documentation

void Identity::serialize

(

PersistXML &

xml

)

Serialize the object.

Serialize object to XML.

Definition at line 770 of file Identity.cc.

References M_authpass, M_key, M_network_name, and PersistXML::serialize().

{
  xml.serialize("M_key", M_key);
  xml.serialize("M_authpass", M_authpass);
  xml.serialize("M_network_name", M_network_name);
}

std::string const& Identity::key

(

void

)

const [inline]

The key of this Identity.

Definition at line 126 of file Identity.h.

References M_key.

Referenced by Target::clientside_get_channel(), Target::get_joined_nick(), ServerConnection::invisible_event(), operator<<(), and Target::serverside_get_channel().

{ return M_key; }

void Identity::new_client_message_received

(

ClientMessageIn const &

msg

)

Called when a new message was received from the associated client.

Definition at line 92 of file Identity.cc.

References ASSERT, edragon::caught(), ClientMessageIn::client_session(), client_session(), Target::clientside_get_channel(), default_priority(), DoutEntering, Authentication::get(), ClientSession::get_nick(), is_channel(), MessageIn::key(), M_authentication, M_ident, M_real_name, mynick(), ClientSession::new_client_nick_received(), MessageIn::param(), MessageIn::params(), MessageIn::params_size(), ClientSession::private_targets(), ServerSession::queue_msg(), ClientSession::queue_msg(), ServerSession::queue_msg_as_is(), safe_query, ServerSession::send_who_write_event(), server_connection(), and server_session().

Referenced by ClientSession::process_message().

{
  DoutEntering(dc::debug, "Identity::new_client_message_received(" << msg << ")");

  switch (msg.key())
  {
    using namespace keys;
    case PASS:                  // No target
      Authentication::get(this, M_authentication);
      M_authentication->decode_pass(msg);
      break;
    case USER:                  // No target
      if (M_ident == unknown_ident)     // It might be retrieved already from identd.
        M_ident = msg.param(0);
      M_real_name = msg.param(3);
      Authentication::get(this, M_authentication);
      M_authentication->decode_user(msg);
      break;
    case PING:                  // No target
    {
      std::string server_name(server_connection().has_server() ? server_connection().server()->get_irc_name() : "noserver.pong.org");
      Prefix prefix(server_name);
      MessageOut msgout(default_priority(keys::PONG));
      client_session().queue_msg(msgout << prefix << keys::PONG << server_name << msg.params(0));
      break;
    }
    case SILENCE:               // No target
    {
      // FIXME.
      // For now, just pass it on the server as-is.
      server_session().queue_msg_as_is(msg);
      break;
    }
    case OPER:                  // No target
    case MAP:
    case WALLOPS:
    case WALLUSERS:
    {
      // FIXME.
      // For now, just pass it on the server as-is.
      server_session().queue_msg_as_is(msg);
      break;
    }
    case STATS:                 // No target, or server target.
    case VERSION:
    {
      // FIXME.
      // For now, just pass it on the server as-is.
      server_session().queue_msg_as_is(msg);
      break;
    }
    case WHO:                   // Query
    {
      WhoRequest who_request(msg.client_session(), (msg.params_size() >= 3) ? msg.param(2) : msg.param(0), msg.param(1));
      if (msg.params().size() >= 1 && who_request.options().matches_against_channel() && is_channel(who_request.mask()))
      {
        // Search in the private network targets map.
        ClientSession::private_targets_type::iterator priv_iter = client_session().private_targets().find(who_request.mask());
        if (priv_iter != client_session().private_targets().end())
        {
          boost::static_pointer_cast<PrivateTarget>(priv_iter->second)->handle_who(who_request);
          break;
        }
      }
      // Not a private channel, pass it on to the server.
      PseudoMessageOut pseudo_msg(default_priority(keys::WHO), safe_query);
      pseudo_msg.writeEventRequest(server_session(), &ServerSession::send_who_write_event, who_request);
      server_session().queue_msg(pseudo_msg);
      break;
    }
    case WHOIS:                 // Query
    case WHOWAS:                // Query
    case LIST:                  // Query
    {
      // Extract the prefix of the input message.
      Prefix prefix(msg);
      // FIXME: needs caching.
      MessageOut msgout(default_priority(msg.key()));
      server_session().queue_msg(msgout << prefix << msg.key() << msg.params(0));
      break;
    }
    case LINKS:                 // Disabled
      break;
    case NICK:                  // Target: this
      // Handle NICK
      msg.client_session().new_client_nick_received(msg.param(0));
      break;
    case QUIT:                  // Target: this
      break;
    case KILL:                  // Target: nick
    {
      Prefix prefix(msg);
      MessageOut msgout(default_priority(msg.key()));
      try
      {
        // Is this a known target?
        boost::shared_ptr<Target> nick = msg.client_session().get_nick(msg.param(0));
        server_session().queue_msg(msgout << prefix << msg.key() << nick << msg.params(1));
      }
      catch(unknown_target& error)
      {
        Debug(edragon::caught(error));
        server_session().queue_msg(msgout << prefix << msg.key() << msg.params(0));
      }
      break;
    }
    case MODE:                  // Target: channel or nick (this)
    case PRIVMSG:               // Target: channel or nick
    case NOTICE:                // Target: channel or nick
    {
      if (!msg.params().empty())
      {
        char c = *msg.params().front().start();
        if (c != '#' && c != '&')
        {
          if (msg.key() == MODE)
          {
            // Handle MODE <nick>
            // FIXME: replace ASSERT with code that handles the other case.
            ASSERT(msg.param(0) == mynick()->in_name(client_session())); 
            Prefix prefix(msg);
            MessageOut msgout(default_priority(msg.key()));
            server_session().queue_msg(msgout << prefix << msg.key() << mynick() << msg.params(1));
            break;
          }
          else
          {
            try
            {
              // Is this a known target?
              msg.client_session().get_nick(msg.param(0))->new_client_message_received(msg);
            }
            catch(unknown_target& error)
            {
              Debug(edragon::caught(error));
              // Client is sending a message to an unknown target.
              // FIXME: Shouldn't we do something here?
              // Pass the message as-is to the server.
              server_session().queue_msg_as_is(msg);
            }
          }
          break;
        }
      }
      /* FALL-THROUGH */
    }
    case INVITE:                // Target: channel
    case CPRIVMSG:              // Target: channel
    case CNOTICE:               // Target: channel
    case JOIN:                  // Target: channel
    case PART:                  // Target: channel
    case KICK:                  // Target: channel
    case NAMES:                 // Target: channel
    case TOPIC:                 // Target: channel
      try
      {
        // Are we really on this channel?
        Target::clientside_get_channel(*this, msg.param(0))->new_client_message_received(msg);
      }
      catch(unknown_target& error)
      {
        Debug(edragon::caught(error));
        // FIXME: Shouldn't we do something here?
        // Client targets an unknown channel. Just pass the message on as-is to the server.
        server_session().queue_msg_as_is(msg);
      }
      break;
  }
}

void Identity::new_server_message_received

(

ServerMessageIn const &

msg

)

Called when a new message was received from the associated server.

Definition at line 278 of file Identity.cc.

References Target::add_joined_nick(), ASSERT, edragon::caught(), client_session(), default_priority(), DoutEntering, WhoOptions::fields(), Target::get_joined_nick(), Prefix::get_nick(), ServerSession::get_nick(), hostname(), NickPair::in_nick(), NickPair::inuse(), MessageIn::key(), WhoRequest::mask(), mynick(), network(), ServerSession::nicks(), WhoRequest::options(), Prefix::out_prefix(), MessageIn::param(), MessageIn::params(), pass_as_is_to_client(), pong_sent, ServerSession::pop_who_request(), MessageIn::prefix(), ClientSession::queue_msg(), server_connection(), ServerMessageIn::server_session(), server_session(), Target::serverside_get_channel(), and ServerConnection::state().

Referenced by ServerSession::new_message_received().

{
  ASSERT(!debug::secondary_connection);
  DoutEntering(dc::debug, "Identity::new_server_message_received(" << msg << ")");

  switch (msg.key())
  {
    using namespace keys;
    case 315:   // End of /WHO list.
    {
      Prefix prefix(msg);
      MessageOut msgout(default_priority(msg.key()));
      client_session().queue_msg(msgout << prefix << msg.key() << mynick() << msg.params(1));
#ifdef CWDEBUG
      WhoRequest who_request(server_session().current_who_request());
      ASSERT(who_request.mask() == msg.param(1));
#endif
      server_session().pop_who_request();
      break;
    }
    case 324:
    {
      Prefix prefix(msg);
      MessageOut msgout(default_priority(msg.key()));
      // Parameter 0 should be my own nick name.
      std::string my_nick_name(msg.param(0));
      ASSERT(my_nick_name == mynick()->in_name(msg.server_session()));
      // Write the first part of the message.
      msgout << prefix << msg.key() << mynick();
      // FIXME: decode channel modes.
      try
      {
        boost::shared_ptr<Channel> channel(Target::serverside_get_channel(*this, msg.param(1)));
        msgout << channel;
      }
      catch (unknown_target& error)
      {
        Debug(edragon::caught(error));   
        msgout << msg.param(1);
      }
      msgout << msg.params(2);
      // Write the message.
      client_session().queue_msg(msgout);
      break;
    }
    case 329:   // Channel timestamp.
    {
      Prefix prefix(msg);
      MessageOut msgout(default_priority(msg.key()));
      // Parameter 0 should be my own nick name.
      std::string my_nick_name(msg.param(0));
      ASSERT(my_nick_name == mynick()->in_name(msg.server_session()));
      // Write the first part of the message.
      msgout << prefix << msg.key() << mynick();
      time_t creation_time = atol(msg.param(2).c_str());
      try
      {
        boost::shared_ptr<Channel> channel(Target::serverside_get_channel(*this, msg.param(1)));
        channel->set_creation_time(creation_time);
        msgout << channel;
      }
      catch (unknown_target& error)
      {
        Debug(edragon::caught(error));   
        msgout << msg.param(1);
      }
      msgout << creation_time;
      // Write the message.
      client_session().queue_msg(msgout);
      break;
    }
    case 352:   // WHO, without fields, reply.
    {
      // Get the corresponding WhoRequest.
      WhoRequest who_request(server_session().current_who_request());
      Dout(dc::notice, "Decoding numeric 352 for WHO request " << who_request);
      // The format of this numeric is:
      // 0: My nick
      // 1: (first) channel
      // 2: username
      // 3: hostname
      // 4: servername
      // 5: nick
      // 6: flags
      // 7: hop realname
      Prefix prefix(msg);
      MessageOut msgout(default_priority(msg.key()));
      // Parameter 0 should be my own nick name.
      std::string my_nick_name(msg.param(0));
      ASSERT(my_nick_name == mynick()->in_name(msg.server_session()));
      // Write the first part of the message.
      msgout << prefix << msg.key() << mynick();
      try
      {
        boost::shared_ptr<Channel> channel(Target::serverside_get_channel(*this, msg.param(1)));
        msgout << channel;
      }
      catch (unknown_target& error)
      {
        Debug(edragon::caught(error));   
        msgout << msg.param(1); 
      }
      std::string username(msg.param(2));
      std::string hostname(msg.param(3));
      std::string servername(msg.param(4));
      std::string flags(msg.param(6));
      std::string realname(msg.param(7));
      int hopcount = atoi(realname.c_str());
      realname = realname.substr(realname.find(' ') + 1);
      msgout << username << hostname << servername;
      try
      {
        boost::shared_ptr<Nick> nick(msg.server_session().get_nick(msg.param(5)));
        msgout << nick;
        nick->data().set_username(username);
        nick->data().set_hostname(hostname);
        nick->data().set_realname(realname);
        nick->data().set_hopcount(hopcount);
        nick->data().set_flags(Flags(network(), flags));
      }
      catch(unknown_target& error)
      {
        Debug(edragon::caught(error));   
        msgout << msg.param(5);
      }
      msgout << flags << msg.params(7);
      // Write the message.
      client_session().queue_msg(msgout);
      break;
    }
    case 354:   // WHO, with fields, reply.
    {
      // Get the corresponding WhoRequest.
      WhoRequest who_request(server_session().current_who_request());
      Dout(dc::notice, "Decoding numeric 354 for WHO request " << who_request);
      // The format of this numeric is:
      // - t: The left-most three digits of the query type (or 0, if there was none, or non-numeric, or negative).
      // - c: The (first) channel name.
      // - u: User name with eventual ~.
      // - i: IP
      // - h: Host name.
      // - s: Server name.
      // - n: Nick name.
      // - f: Flags (all of them).
      // - d: Hop count. 3 for non-Opers.
      // - l: Idle time (0 for remote users). Also 0 for non-Opers.
      // - a: Account name.
      // - r: Real name.

      Prefix prefix(msg);
      MessageOut msgout(default_priority(msg.key()));
      // Parameter 0 should be my own nick name.
      std::string my_nick_name(msg.param(0));
      ASSERT(my_nick_name == mynick()->in_name(msg.server_session()));
      // Write the first part of the message.
      msgout << prefix << msg.key() << mynick();

      int n = 0;
      // Run over all field flags.
      for (unsigned int field = 1; field < field_percentage; field <<= 1)
      {
        if ((who_request.options().fields() & field))
        {
          // Next message parameter.
          ++n;
          // Ok, this field exists. Write it out.
          if (field == field_c)         // A channel name?
          {
            try
            {
              boost::shared_ptr<Channel> channel(Target::serverside_get_channel(*this, msg.param(n)));
              msgout << channel;
            }
            catch (unknown_target& error)
            {
              Debug(edragon::caught(error));   
              msgout << msg.param(n); 
            }
          }
          else if (field == field_n)    // A nick name?
          {
            try
            {
              boost::shared_ptr<Nick> nick(msg.server_session().get_nick(msg.param(n)));
              msgout << nick;
              int n2 = 0;
              for (unsigned int field2 = 1; field2 < field_percentage; field2 <<= 1)
                if ((who_request.options().fields() & field2))
                {
                  ++n2;
                  switch(field2)
                  {
                    case field_u:
                      nick->data().set_username(msg.param(n2));
                      break;
                    case field_h:
                      nick->data().set_hostname(msg.param(n2));
                      break;
                    case field_i:
                      nick->data().set_ip(IPNumber(msg.param(n2)));
                      break;
                    case field_r:
                      nick->data().set_realname(msg.param(n2));
                      break;
                    case field_d:
                      nick->data().set_hopcount(atoi(msg.param(n2).c_str()));
                      break;
                    case field_f:
                      nick->data().set_flags(Flags(network(), msg.param(n2)));
                      break;
                    case field_s:
                      nick->data().set_servername(msg.param(n2));
                      break;
                    case field_l:
                      nick->data().set_idletime(atoi(msg.param(n2).c_str()));
                      break;
                    case field_a:
                      nick->data().set_accountname(msg.param(n2));
                      break;
                  }
                }
            }
            catch(unknown_target& error)
            {
              Debug(edragon::caught(error));   
              msgout << msg.param(n);
            }
          }
          else
            msgout << msg.param(n);
        }
      }
      // Write the message.
      client_session().queue_msg(msgout);
      break;
    }
    case 353:   // NAMES reply
    {
      // Get prefix.
      Prefix prefix(msg);
      // Prepare message to be sent to client.
      MessageOut msgout(default_priority(msg.key()));
      // Lookup the channel.
      boost::shared_ptr<Channel> channel(Target::serverside_get_channel(*this, msg.param(2)));
      bool received_first_names = channel->received_names();
      // Parameter 0 should be my own nick name.
      std::string my_nick_name(msg.param(0));
      ASSERT(my_nick_name == mynick()->in_name(msg.server_session()));
      // Write first part of message.
      msgout << prefix << msg.key() << mynick() << msg.param(1) << channel;
      // Run over each parameter.
      MsgPart names_list(msg.params(3));
      char const* list_start = names_list.start();
      if (*list_start == ':')
        ++list_start;
      char const* const list_end = names_list.end();
      char const* word_end;
      for (char const* word_start = list_start; word_start < list_end; word_start = word_end + 1)
      {
        ASSERT(*word_start != ' ');
        for (word_end = word_start; word_end < list_end && *word_end != ' '; ++word_end);
        std::string param(word_start, word_end - word_start);
        if (!IsNickChar(*word_start))
        {
          ASSERT(*word_start == '@' || *word_start == '+');
          std::string nick_name(word_start + 1, word_end - word_start - 1);
          boost::shared_ptr<Nick> nick;
          if (received_first_names)
            nick = Target::get_joined_nick(*this, nick_name, channel);
          else if (nick_name == my_nick_name)   // Was already added by the JOIN.
            nick = mynick();
          else
            nick = Target::add_joined_nick(*this, nick_name, channel);
          msgout << *word_start << JustInTimeCatenate(nick);
        }
        else
        {
          std::string nick_name(word_start, word_end - word_start);
          boost::shared_ptr<Nick> nick;
          if (received_first_names)
            nick = Target::get_joined_nick(*this, nick_name, channel);
          else if (nick_name == my_nick_name)   // Was already added by the JOIN.
            nick = mynick();
          else
            nick = Target::add_joined_nick(*this, nick_name, channel);
          msgout << nick;
        }
      }
      client_session().queue_msg(msgout);
      break;
    }
    case 366:   // End of /NAMES list.
    {
      // Get prefix.
      Prefix prefix(msg);
      // Prepare message to be sent to client.
      MessageOut msgout(default_priority(msg.key()));
      // Lookup the channel.
      boost::shared_ptr<Channel> channel(Target::serverside_get_channel(*this, msg.param(1)));
      if (!channel->received_names())
      {
        // Tell channel we received the first 366.
        channel->set_received_names();
      }
      // Parameter 0 should be my own nick name.
      ASSERT(msg.param(0) == mynick()->in_name(msg.server_session()));
      // Pass message on the client.
      client_session().queue_msg(msgout << prefix << msg.key() << mynick() << channel << msg.params(2));
      break;
    }
    case 433:   // Nickname is already in use.
      server_session().nicks().inuse(msg.param(1));
      break;
    case 451:   // Register first
      if (server_connection().state() == pong_sent)
      {
        // This probably means that something went wrong with the registration part.
        // For example Undernet server version 2.10.12.10 has no means to set MODE +xi
        // with the USER command, but requires hostname and ident lookup to be finished
        // before it considers registration to be finished. Therefore it is not possible
        // to send the PONG and the MODE +ix in one packet (as we do) until after the
        // hostname and ident look ups actually have finished. However, because we don't
        // know if those lookups are merely delayed a lot, or that we aren't connected
        // to an undernet server, we send the PONG and MODE anyway after a certain timeout.
        // If the MODE failed, we are vulnerable. Disconnect immediately.
        server_session() << "QUIT\r\n" << std::flush;
      }
      break;
    case QUIT:
      do_quit(msg.prefix().get_nick(), msg.param(0));
      break;
    case NICK:
    {
      Prefix prefix(msg);
      Prefix old_prefix(prefix.out_prefix(client_session()));
      boost::shared_ptr<Nick> nick(prefix.get_nick());
      nick->serverside_nick_changed_to(msg.server_session(), msg.param(0));     // This updates the maps.
      // FIXME: check for collisions etc.
      nick->clientside_nick_changed_to(client_session(), msg.param(0));         // This is passed as parameter 0 to the client in the message below.
      // Pass the message as-is to the client.
      MessageOut msgout(default_priority(msg.key()));
      client_session().queue_msg(msgout << old_prefix << msg.key() << nick);
      break;
    }
    case NOTICE:                // Target: channel or nick
      if (server_connection().state() <= pong_sent)     // On the last AUTH message the state is already set to pong_sent.
        break;                  // Ignore NOTICE AUTH messages in the beginning (already handled).
      /* FALL-THROUGH */
    case PRIVMSG:               // Target: channel or nick
    {
      if (msg.params().empty())
        break;                  // Should never happen.
      char c = *msg.params().front().start();
      if (c != '#' && c != '&' && c != '@')
      {
        // We should only receive PRIVMSG, NOTICE and user MODE's for ourselves.
        // A NOTICE can be sent to $mask or * as well.
        ASSERT(c == '$' || msg.param(0) == server_session().nicks().in_nick() || (msg.key() == NOTICE && msg.param(0) == "*"));
        // Received private PRIVMSG or NOTICE.
        // Pass to client as-is.
        Prefix prefix(msg);
        MessageOut msgout(default_priority(msg.key()));
        if (c == '$' || msg.param(0) == "*")
          client_session().queue_msg(msgout << prefix << msg.key() << msg.params(0));
        else
          client_session().queue_msg(msgout << prefix << msg.key() << mynick() << msg.params(1));
        break;
      } 
      /* FALL-THROUGH */
    }
    case MODE:                  // Target: channel
    case PART:                  // Target: channel
    case KICK:                  // Target: channel
    case TOPIC:                 // Target: channel
    {
      // If we receive a message from the server targetted to a channel, we should already
      // be on the channel, so there is no need to catch the unknown_target exception here.
      // If it's JOIN we might not be on the channel, but in that case we create it here.
      Target::serverside_get_channel(*this, msg.param(0), msg.key() == JOIN)->new_server_message_received(msg);
      break;
    }
    case JOIN:                  // Target: channel
    {
      Target::serverside_get_channel(*this, msg.param(0), msg.key() == JOIN)->new_server_message_received(msg);
      break;
    }
    default:
      Dout(dc::warning, "Unhandled command " << msg << " from server");
      pass_as_is_to_client(msg);
      break;
  }
}

boost::shared_ptr<Nick const> Identity::mynick

(

void

)

const [inline]

Returns a pointer to my Nick object.

Definition at line 135 of file Identity.h.

References ASSERT, and M_mynick.

Referenced by ServerSession::detected_network(), new_client_message_received(), ClientSession::new_client_nick_received(), ServerSession::new_message_received(), new_server_message_received(), ClientSession::queue_msg_me_as_is(), Authentication::send_authentication(), and Target::sub_channel().

{ ASSERT(!debug::secondary_connection); return M_mynick; }

boost::shared_ptr<Nick> Identity::mynick

(

void

)

[inline]

Returns a pointer to my Nick object.

Definition at line 138 of file Identity.h.

References ASSERT, and M_mynick.

{ ASSERT(!debug::secondary_connection); return M_mynick; }

std::string Identity::server_source

(

void

)

const

Return a reasonable servername that can be used as source for client messages.

Obtain associated server name.

Definition at line 759 of file Identity.cc.

References M_primary_server_connection.

Referenced by PrivateTarget::do_names_output(), and PrivateTarget::new_client_message_received().

{
  std::string result;
  if (M_primary_server_connection->has_server())
    result = M_primary_server_connection->server()->get_irc_name();
  if (result.empty())
    result = "ircproxy.net";
  return result;
}

std::string Identity::ident

(

void

)

const [inline]

Returns a best-guess for the users ident string.

Definition at line 144 of file Identity.h.

References M_ident.

Referenced by QuestionTarget::new_client_message_received().

{ return M_ident; }

std::string Identity::real_hostname

(

void

)

const [inline]

Returns a best-guess for the users host name.

Definition at line 147 of file Identity.h.

References M_real_hostname.

{ return M_real_hostname; }

std::string Identity::hostname

(

void

)

const [inline]

Returns a best-guess for the users host name.

Definition at line 150 of file Identity.h.

References M_hostname.

Referenced by QuestionTarget::new_client_message_received(), and new_server_message_received().

{ return M_hostname; }

std::string Identity::real_name

(

void

)

const [inline]

Returns a best-guess for the users real name.

Definition at line 153 of file Identity.h.

References M_real_name.

{ return M_real_name; }

std::string Identity::network_name

(

void

)

const [inline]

Returns the network name that this identity corresponds with.

Definition at line 156 of file Identity.h.

References M_network_name.

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

{ return M_network_name; }

void Identity::set_ident

(

std::string const &

ident

)

[inline]

Set ident string as returned by ident().

Definition at line 159 of file Identity.h.

References M_ident.

Referenced by ServerConnection::received_first_umode().

      { Dout(dc::debug, "Setting ident to \"" << ident << "\"."); M_ident = ident; }

void Identity::set_real_hostname

(

std::string const &

real_hostname

)

[inline]

Set host name string as returned by real_hostname().

Definition at line 163 of file Identity.h.

References M_real_hostname.

Referenced by ServerConnection::received_first_umode().

      { Dout(dc::debug, "Setting real hostname to \"" << real_hostname << "\"."); M_real_hostname = real_hostname; }

void Identity::set_hostname

(

std::string const &

hostname

)

[inline]

Set host name string as returned by hostname().

Definition at line 167 of file Identity.h.

References M_hostname.

Referenced by ServerSession::new_message_received(), and ClientSession::new_message_received().

      { Dout(dc::debug, "Setting hostname to \"" << hostname << "\"."); M_hostname = hostname; }

void Identity::set_real_name

(

std::string const &

real_name

)

[inline]

Set real name string as returned by real_name().

Definition at line 171 of file Identity.h.

References M_real_name.

{ M_real_name = real_name; }

void Identity::set_network_name

(

std::string const &

network_name

)

[inline]

Set network name string as returned by real_name().

Definition at line 174 of file Identity.h.

References M_network_name.

Referenced by ServerSession::found_network_name().

{ M_network_name = network_name; }

bool Identity::has_authentication_password

(

void

)

const [inline]

Returns true if an authentication password is needed.

Definition at line 177 of file Identity.h.

References M_authpass.

Referenced by authentication_password(), and Authentication::decode_pass().

{ return !M_authpass.empty(); }

std::string const& Identity::authentication_password

(

void

)

const [inline]

Returns the authentication password. Should only be called if has_authentication_password returns true.

Definition at line 180 of file Identity.h.

References ASSERT, has_authentication_password(), and M_authpass.

Referenced by Authentication::decode_pass().

{ ASSERT(has_authentication_password()); return M_authpass; }

Network const& Identity::private_network

(

void

)

const [inline]

Return the fake network object, private to this identity.

Definition at line 183 of file Identity.h.

References M_private_network.

{ return M_private_network; }

Network& Identity::private_network

(

void

)

[inline]

Return the fake network object, private to this identity.

Definition at line 186 of file Identity.h.

References M_private_network.

{ return M_private_network; }

Network const& Identity::network

(

void

)

const [inline]

Return the network object of the connection belonging to this identity.

Definition at line 189 of file Identity.h.

References ServerConnection::network(), and server_connection().

Referenced by UserAnswer::is_match(), and new_server_message_received().

{ return server_connection().network(); }

Network& Identity::network

(

void

)

[inline]

Return the network object of the connection belonging to this identity.

Definition at line 192 of file Identity.h.

References ServerConnection::network(), and server_connection().

{ return server_connection().network(); }

void Identity::set_client_session

(

ClientSession *

client_session

)

[inline]

Set current ClientSession of this Identity, called by ClientSession::new_message_received.

Definition at line 195 of file Identity.h.

References M_client_session.

Referenced by ClientSession::new_message_received().

{ M_client_session = client_session; }

void Identity::reset_client_session

(

ClientSession *

client_session

)

[inline]

Reset the ClientSession of this Identity, provided it matches the currently set ClientSession.

Definition at line 198 of file Identity.h.

References M_client_session.

Referenced by ClientSession::~ClientSession().

      { if (M_client_session == client_session) M_client_session = NULL; }

bool Identity::has_client_session

(

void

)

const [inline]

Return true if this identity is associated with a client session.

Definition at line 202 of file Identity.h.

References M_client_session.

Referenced by ~Identity().

{ return M_client_session; }

bool Identity::has_server_session

(

void

)

const [inline]

Return true if this identity is associated with a server session.

Definition at line 205 of file Identity.h.

References M_primary_server_connection.

Referenced by ~Identity().

{ return M_primary_server_connection->has_server_session(); }

ClientSession const& Identity::client_session

(

void

)

const [inline]

Return the current ClientSession.

Definition at line 208 of file Identity.h.

References ASSERT, and M_client_session.

Referenced by Target::add_channel(), Target::clientside_get_channel(), ServerConnection::connect(), ServerConnection::do_connect(), ServerSession::found_network_name(), new_client_message_received(), Channel::new_client_message_received(), ServerSession::new_message_received(), new_server_message_received(), Channel::new_server_message_received(), notice_target(), pass_as_is_to_client(), received_network_domain_answer(), ServerSession::send_rejoins(), ServerConnection::session_lost(), Target::sub_channel(), and ~Identity().

{ ASSERT(M_client_session != NULL); return *M_client_session; }

ClientSession& Identity::client_session

(

void

)

[inline]

Return the current ClientSession.

Definition at line 211 of file Identity.h.

References ASSERT, and M_client_session.

{ ASSERT(M_client_session != NULL); return *M_client_session; }

ServerSession const& Identity::server_session

(

void

)

const [inline]

Return the current ClientSession.

Definition at line 214 of file Identity.h.

References M_primary_server_connection.

Referenced by Target::add_channel(), new_client_message_received(), Channel::new_client_message_received(), ClientSession::new_client_nick_received(), new_server_message_received(), Channel::new_server_message_received(), pass_as_is_to_server(), received_network_domain_answer(), Target::serverside_get_channel(), Target::sub_channel(), and ~Identity().

{ return M_primary_server_connection->server_session(); }

ServerSession& Identity::server_session

(

void

)

[inline]

Return the current ClientSession.

Definition at line 217 of file Identity.h.

References M_primary_server_connection.

{ return M_primary_server_connection->server_session(); }

boost::shared_ptr< Target > Identity::notice_target

(

question_nt

number

)

Return a target with prefix prefix that is not already in the private network map.

Return a target for ircproxy notices related to question number.

Definition at line 713 of file Identity.cc.

References ClientSession::add_private_target(), ASSERT, ClientSession::client_out_nick(), client_session(), PrivateTarget::do_names_output(), is_channel(), M_private_network, no_related_question, ClientSession::private_targets(), and question_target_name().

Referenced by send_notice().

{
  char const* channel_name;

  if (number != no_related_question)
  {
    channel_name = question_target_name(number);
    ASSERT(is_channel(channel_name));
  }

  while(1)
  {
    if (number == no_related_question)
      channel_name = "&notices";
    // Is the client already joined?
    ClientSession::private_targets_type::iterator iter = client_session().private_targets().find(channel_name);
    if (iter != client_session().private_targets().end())
      return iter->second;
    if (number == no_related_question)
      break;
    number = no_related_question;
  }

  // Create the new NoticeTarget.
  NoticeTarget* new_notice_target = new NoticeTarget(client_session(), channel_name, M_private_network);
  AllocTag(new_notice_target, channel_name);
  // Add it to the private targets map.
  boost::shared_ptr<Target> private_target(new_notice_target);
  client_session().add_private_target(private_target);
  // Have the client join it.
  client_session() << ":" << client_session().client_out_nick() << " JOIN " << channel_name << "\r\n";
  new_notice_target->do_names_output();

  return private_target;
}

ServerConnection const& Identity::server_connection

(

void

)

const [inline]

Return the primary server connection object.

Definition at line 226 of file Identity.h.

References M_primary_server_connection.

Referenced by Target::add_channel(), Target::add_joined_nick(), Target::get_joined_nick(), network(), new_client_message_received(), new_server_message_received(), pass_as_is_to_server(), and Authentication::received_nick_and_user().

{ return *M_primary_server_connection; }

ServerConnection& Identity::server_connection

(

void

)

[inline]

Return the primary server connection object.

Definition at line 229 of file Identity.h.

References M_primary_server_connection.

{ return *M_primary_server_connection; }

void Identity::start_secondary_server_connection

(

boost::shared_ptr< Server >

new_server

)

[inline]

Start a secondary server connection, which will take over the primary once connected.

Definition at line 232 of file Identity.h.

References ASSERT, has_secondary_server_connection(), and M_secondary_server_connection.

      {
        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);
      } 

void Identity::swap_primary_and_secondary_connection

(

void

)

[inline]

Swap primary and secondary connection.

Definition at line 244 of file Identity.h.

References M_primary_server_connection, and M_secondary_server_connection.

Referenced by ServerSession::new_message_received().

      {
        std::swap(M_primary_server_connection, M_secondary_server_connection);
        M_primary_server_connection->make_primary();
        M_secondary_server_connection->make_secondary();
      }

void Identity::end_secondary_server_connection

(

void

)

[inline]

Terminate the secondary connection.

Definition at line 252 of file Identity.h.

References ASSERT, has_secondary_server_connection(), and M_secondary_server_connection.

      {
        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().
      }

bool Identity::has_secondary_server_connection

(

void

)

const [inline]

Return true if this identity is associated with a secondary server connection.

Definition at line 271 of file Identity.h.

References M_secondary_server_connection.

Referenced by end_secondary_server_connection(), and start_secondary_server_connection().

{ return M_secondary_server_connection.get(); }

boost::shared_ptr<ServerConnection const> Identity::secondary_server_connection

(

void

)

const [inline]

Return the secondary server connection. Only valid if has_secondary_server_connection returns true.

Definition at line 274 of file Identity.h.

References M_secondary_server_connection.

Referenced by ServerSession::new_message_received().

      { return boost::const_pointer_cast<ServerConnection const>(M_secondary_server_connection); }

boost::shared_ptr<ServerConnection> Identity::secondary_server_connection

(

void

)

[inline]

Return the secondary server connection. Only valid if has_secondary_server_connection returns true.

Definition at line 278 of file Identity.h.

References M_secondary_server_connection.

      { return M_secondary_server_connection; }

Authentication const& Identity::authentication

(

void

)

const [inline]

Return the authentication object.

Definition at line 282 of file Identity.h.

References M_authentication.

Referenced by AuthState::AuthState(), ServerConnection::invisible_event(), and ClientSession::new_client_nick_received().

{ return *M_authentication; }

Authentication& Identity::authentication

(

void

)

[inline]

Return the authentication object.

Definition at line 285 of file Identity.h.

References M_authentication.

{ return *M_authentication; }

void Identity::send_notice	(	std::string const &	notice,
		question_nt	number = no_related_question
	)

Send a notice to the client.

Definition at line 753 of file Identity.cc.

References M_client_session, and notice_target().

Referenced by ServerSession::construct_network_object(), ServerConnection::do_connect(), ServerSession::found_network_name(), ServerSession::network_connection_terminated(), and ServerSession::new_message_received().

{
  *M_client_session << ":Leandro PRIVMSG " << notice_target(number)->out_name(*M_client_session)  << " :" << notice << "\r\n";
}

void Identity::received_network_domain_answer	(	UserAnswerEventType const &	event_type,
		std::pair< std::string, std::string >	network_domain
	)

Event call back: network domain answer received. Process it.

Definition at line 672 of file Identity.cc.

References UserAnswer::answer(), client_session(), ServerSession::construct_network_object(), DoutEntering, IRCStringCompare(), network_domain_question, server_session(), and ClientSession::user_answer_event_server.

Referenced by ServerSession::found_network_name().

{
  DoutEntering(dc::debug, "Identity::received_network_domain_answer(" << event_type);
  std::string answer = event_type.answer();
  bool yes = IRCStringCompare(answer, "Yes") == 0;
  bool no = IRCStringCompare(answer, "No") == 0;
  if (!yes && !no)
  {
    std::ostringstream the_question;
    the_question << "Does the " << network_domain.first << " IRC network use \"" <<
        network_domain.second << "\" as common domain for all servers (type: Yes|No)?";
    client_session().user_answer_event_server
        (UserAnswerRequestData(client_session(), network_domain_question, the_question.str()),
        *this, &Identity::received_network_domain_answer, network_domain);
  }
  else if (no)
    server_session().construct_network_object(network_domain.first, "");
  else
    server_session().construct_network_object(network_domain.first, network_domain.second);
}

void Identity::pass_as_is_to_server

(

ClientMessageIn const &

msg

)

Write ClientMessageIn msg to the server.

Definition at line 63 of file Identity.cc.

References MessageIn::key(), pass_as_is_to(), real_nick_sent, server_connection(), server_session(), ServerConnection::state(), and THROW_EXCEPTION.

{
  bool blocked = true;
  switch (msg.key())
  {
    using namespace keys;
    case WHO:                   // Query
    case WHOIS:                 // Query
    case WHOWAS:                // Query
      blocked = false;
      break;
    default:
      break;
  }
  if (blocked && server_connection().state() < real_nick_sent)
    THROW_EXCEPTION(FatalError("Message to be passed as-is is blocked!"),
        "Identity::pass_as_is_to_server(" << msg << ") called while server connection in state " << server_connection().state() << '!');
  pass_as_is_to(msg, server_session());
}

void Identity::pass_as_is_to_client

(

ServerMessageIn const &

msg

)

Write ServerMessageIn msg to the client.

Definition at line 87 of file Identity.cc.

References client_session(), and pass_as_is_to().

Referenced by new_server_message_received().

{
  pass_as_is_to(msg, client_session());
}

void Identity::pass_as_is_to	(	MessageIn const &	msg,
		std::ostream &	os
	)			[private]

Write MessageIn msg to the ostream os.

Definition at line 40 of file Identity.cc.

References MessageIn::has_prefix(), MessageIn::is_numeric(), MessageIn::numeric(), MessageIn::param(), MessageIn::params_size(), MessageIn::prefix_str(), and MessageIn::uppercase_command().

Referenced by pass_as_is_to_client(), and pass_as_is_to_server().

{
  if (msg.has_prefix())
    os << ':' << msg.prefix_str() << ' ';
  if (msg.is_numeric())
    os << msg.numeric();
  else
    os << msg.uppercase_command();
  int number_of_parameters = msg.params_size();
  for (int param = 0; param < number_of_parameters; ++param)
  {
    os << ' ';
    if (param == number_of_parameters - 1)
      os << ':';
    os << msg.param(param);
  }
  os << "\r\n";
}

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		Identity const &	identity
	)			[friend]

For debugging purposes. Write a Identity to os.

Definition at line 294 of file debug_ostream_operators.cc.

{
  os << "{key:" << identity.M_key;
#ifdef VERBOSE_IDENTITY
#ifdef PRINT_AUTHENTICATION
  if (identity.M_authentication.get())
    os << ", authentication:" << *identity.M_authentication.get();
  os << ", server_connection:" << identity.M_server_connection;
  if (!identity.M_authpass.empty())
    os << ", authpass:" << identity.M_authpass;
#endif
  os << ", private_network:" << identity.M_private_network;
  if (identity.M_client_session)
    os << ", client_session:" << *identity.M_client_session;
  os << ", ident:\"" << identity.M_ident <<
        "\", hostname:\"" << identity.M_hostname <<
        "\", real_name:\"" << identity.M_real_name <<
        "\", network_name:\"" << identity.M_network_name << '"';
#endif
  os << '}';
  return os;
}

---

Member Data Documentation

std::string Identity::M_key [private]

The unique identity key as used with the identity map.

Definition at line 60 of file Identity.h.

Referenced by key(), operator<<(), and serialize().

boost::shared_ptr<Authentication> Identity::M_authentication [private]

Temporary authentication token, or NULL.

Definition at line 61 of file Identity.h.

Referenced by authentication(), new_client_message_received(), and operator<<().

boost::shared_ptr<Nick> Identity::M_mynick [private]

Pointer to the Nick object representing my own nick.

Definition at line 62 of file Identity.h.

Referenced by Identity(), and mynick().

std::string Identity::M_authpass [private]

Authentication password.

Definition at line 63 of file Identity.h.

Referenced by authentication_password(), has_authentication_password(), operator<<(), and serialize().

Network Identity::M_private_network [private]

Fake network, private to this identity.

Definition at line 64 of file Identity.h.

Referenced by notice_target(), operator<<(), and private_network().

ClientSession* Identity::M_client_session [private]

Pointer to the current client session.

Definition at line 65 of file Identity.h.

Referenced by client_session(), has_client_session(), operator<<(), reset_client_session(), send_notice(), and set_client_session().

std::string Identity::M_ident [private]

A best-guess for this users ident.

Definition at line 66 of file Identity.h.

Referenced by ident(), new_client_message_received(), operator<<(), and set_ident().

std::string Identity::M_real_hostname [private]

A best-guess for this users real hostname.

Definition at line 67 of file Identity.h.

Referenced by real_hostname(), and set_real_hostname().

std::string Identity::M_hostname [private]

A best-guess for this users (cloaked) hostname.

Definition at line 68 of file Identity.h.

Referenced by hostname(), operator<<(), and set_hostname().

std::string Identity::M_real_name [private]

A best-guess for this users real name.

Definition at line 69 of file Identity.h.

Referenced by new_client_message_received(), operator<<(), real_name(), and set_real_name().

std::string Identity::M_network_name [private]

The network name that corresponds to this identity.

Definition at line 70 of file Identity.h.

Referenced by network_name(), operator<<(), serialize(), and set_network_name().

boost::shared_ptr<ServerConnection> Identity::M_primary_server_connection [private]

Our link to some server.

Definition at line 71 of file Identity.h.

Referenced by has_server_session(), server_connection(), server_session(), server_source(), and swap_primary_and_secondary_connection().

boost::shared_ptr<ServerConnection> Identity::M_secondary_server_connection [private]

Link to a secondary server connection in progress, or NULL when none.

Definition at line 72 of file Identity.h.

Referenced by end_secondary_server_connection(), has_secondary_server_connection(), Identity(), secondary_server_connection(), start_secondary_server_connection(), and swap_primary_and_secondary_connection().

---

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

• Identity.h
• Identity.cc