PrivateTarget Class Reference

#include <PrivateTarget.h>

Inheritance diagram for PrivateTarget:

List of all members.

---

Detailed Description

A fake channel that is used for communication between user and ircproxy.

Base class for NoticeTarget and QuestionTarget.

Definition at line 32 of file PrivateTarget.h.

Public Member Functions
	PrivateTarget (ClientSession &client_session, std::string const &target_name, Network &network)
	Construct PrivateTarget instance for client session client_session with target name target_name on network network.
void	do_names_output (void)
	Generate the NAMES reply for the associated channel.
void	handle_command (ClientMessageIn const &msg)
	Decode and handle a command sent to a private target.
virtual void	new_client_message_received (ClientMessageIn const &msg)
	Called when a new (client) message is received for this target.
Protected Member Functions
virtual char const *	channel_modes (void)
	The channel modes for this target, as sent to the client.
Private Member Functions
virtual void	new_server_message_received (ServerMessageIn const &)
	This is called when a new message targetted at this target is received.

---

Constructor & Destructor Documentation

PrivateTarget::PrivateTarget	(	ClientSession &	client_session,
		std::string const &	target_name,
		Network &	network
	)			[inline]

Construct PrivateTarget instance for client session client_session with target name target_name on network network.

Definition at line 39 of file PrivateTarget.h.

                                                                                                 :
        Target(&network), M_client_session(client_session), M_name(target_name) { }

---

Member Function Documentation

void PrivateTarget::do_names_output

(

void

)

Generate the NAMES reply for the associated channel.

Definition at line 218 of file PrivateTarget.cc.

References ClientSession::client_out_nick(), IdentityReference::identity(), and Identity::server_source().

Referenced by QuestionTarget::create_channel_and_ask_question(), new_client_message_received(), and Identity::notice_target().

{
  client_session() << ':' << client_session().identity().server_source() << " 353 " <<
      client_session().client_out_nick() << " @ " << out_name(client_session()) <<
      " :@Leandro " << client_session().client_out_nick() << "\r\n";
  client_session() << ':' << client_session().identity().server_source() << " 366 " <<
    client_session().client_out_nick() << ' ' << out_name(client_session()) << " :End of /NAMES list.\r\n";
}

void PrivateTarget::handle_command

(

ClientMessageIn const &

msg

)

Decode and handle a command sent to a private target.

Definition at line 61 of file PrivateTarget.cc.

References ASSERT, ClientSession::client_out_nick(), IdentityReference::identity(), is_channel(), MessageIn::param(), and real_nick_accepted.

Referenced by new_client_message_received().

{
  // Some convenience variables.
  ClientSession& client_session(this->client_session());
  Identity& identity(client_session.identity());
  ServerConnection& server_connection(identity.server_connection());
  // Construct a prefix for possible messages to be sent to the client.
  std::string prefix(msg.param(0));
  if (!is_channel(prefix))
    prefix = client_session.client_out_nick();
  prefix = ":Leandro PRIVMSG " + prefix + " :";
  // Tokenize the command line.
  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  boost::char_separator<char> sep(" ");
  tokenizer tokens(msg.param(1), sep);
  tokenizer::iterator tok_iter = tokens.begin();
  if (tok_iter == tokens.end())         // No command at all?
    return;
  std::string command = *tok_iter;
  ++tok_iter;
  if (command == "!help")
  {
    client_session << prefix << "!help                  : This help text." << "\r\n";
    client_session << prefix << "!server <host> [<port>]: Connect to server <host> at port <port> (default 6667)." << "\r\n";
#ifdef CWDEBUG
    client_session << prefix << "!quit                  : Send 'QUIT :Received command !quit' to the server socket (debugging)." << "\r\n";
#endif
  }
  else if (command == "!server")
  {
    if (tok_iter == tokens.end())
    {
      client_session << prefix << "Usage: !server <host> [<port>] [<vhost>]\r\n";
      return;
    }
    std::string hostname(*tok_iter);
    std::string::size_type pos = hostname.rfind('.');
    std::string domain;
    if (pos != std::string::npos)
      domain = hostname.substr(hostname.rfind('.', pos - 1) + 1);
    ++tok_iter;
    unsigned short port = 0;
    bool no_vhost_argument_given = true;
    struct in_addr vhost = { INADDR_ANY };
    if (tok_iter != tokens.end())
    {
      std::string argument(*tok_iter);
      ++tok_iter;
      if (tok_iter != tokens.end() || argument.find_first_not_of("0123456789") == std::string::npos)
        port = atoi(argument.c_str());
      else
      {
        inet_aton(argument.c_str(), &vhost);
        no_vhost_argument_given = false;
      }
      if (tok_iter != tokens.end())
      {
        inet_aton(tok_iter->c_str(), &vhost);
        no_vhost_argument_given = false;
      }
    }
    // Do we already know this server?
    bool found = false;
    networks_type::iterator network_iter;
    Network::servers_type::iterator server_found;
    for (network_iter = Application::instance().networks().begin(); network_iter != Application::instance().networks().end(); ++network_iter)
    {
      for (Network::servers_type::iterator server_iter = network_iter->servers().begin(); server_iter != network_iter->servers().end(); ++server_iter)
        if (strcasecmp((*server_iter)->hostname().c_str(), hostname.c_str()) == 0)
        {
          Dout(dc::notice, "Found existing server " << *server_iter);
          found = true;
          server_found = server_iter;
          break;
        }
      if (found)
        break;
    }
    bool trying_to_switch_network = false;
    if (found)
    {
      // Are we (successfully) connected to a server?
      if (server_connection.has_server() && server_connection.state() >= real_nick_accepted)
      {
        // Is the found server the same server that we are already connected to?
        if (server_connection.server() == *server_found)
        {
          // Are we trying to change port?
          if (!port || port == server_connection.server()->port())
          {
            // Are we trying to change vhost?
            if (no_vhost_argument_given || std::memcmp(&server_connection.server()->vhost(), &vhost, sizeof(vhost)) == 0)
            {
              // Nothing changed. Refused to reconnect.
              static struct in_addr const any = { INADDR_ANY };
              bool print_vhost = !no_vhost_argument_given || std::memcmp(&server_connection.server()->vhost(), &any, sizeof(vhost)) != 0;
              client_session << prefix << "You are already connected to " << server_connection.server()->get_irc_name();
              if (port)
                client_session << ' ';
              else
                client_session << " (";
              client_session << "port " << server_connection.server()->port();
              if (print_vhost)
              {
                if (port && no_vhost_argument_given)
                  client_session << " (";
                else if (!port && !no_vhost_argument_given)
                  client_session << ") ";
                else
                  client_session << ' ';
                client_session << "using vhost " << server_connection.server()->vhost();
              }
              if ((print_vhost && no_vhost_argument_given) || (!print_vhost && !port))
                client_session << ')';
              client_session << "\r\n";
              return;
            }
          }
          if (no_vhost_argument_given)
            std::memcpy(&vhost, &server_connection.server()->vhost(), sizeof(vhost));
        }
        else if (network_iter->name() != identity.network().name())     // Is the user trying to switch network?
          trying_to_switch_network = true;
      }
    }
    else
      trying_to_switch_network = identity.network().has_domain() && strcasecmp(identity.network().domain().c_str(), domain.c_str()) != 0;
    if (trying_to_switch_network)
    {
      client_session << prefix << "The identity \"" << identity.key() <<
          "\" belongs to network \"" << identity.network_name() << "\". You can not switch IRC network.\r\n";
      return;
    }
    if (!port)
      port = 6667;
    boost::shared_ptr<Server> new_server;
    if (!found)
      new_server.reset(NEW(Server(identity.network(), hostname, port, vhost)));
    else
    {
      ASSERT(&(*server_found)->network() == NULL || &identity.network() == &(*server_found)->network());
      ASSERT(!strcasecmp((*server_found)->hostname().c_str(), hostname.c_str()));
      new_server = *server_found;
      std::memcpy(&new_server->vhost(), &vhost, sizeof(vhost));
      new_server->set_next_port(port);
    }
    identity.start_secondary_server_connection(new_server);
  }
#ifdef CWDEBUG
  else if (command == "!quit")
  {
    client_session << "QUIT :Received command !quit\r\n";
  }
#endif
}

void PrivateTarget::new_client_message_received

(

ClientMessageIn const &

msg

)

[virtual]

Called when a new (client) message is received for this target.

This function handles incoming messages for this target.

Implements Target.

Reimplemented in NoticeTarget, and QuestionTarget.

Definition at line 34 of file PrivateTarget.cc.

References ASSERT, channel_modes(), ClientSession::client_out_nick(), ClientMessageIn::client_session(), ClientSession::del_private_target(), do_names_output(), DoutEntering, handle_command(), IdentityReference::identity(), is_channel(), MessageIn::key(), MessageIn::param(), and Identity::server_source().

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

{
  DoutEntering(dc::debug, "PrivateTarget::new_client_message_received(" << msg << ") for target \"" << in_name(client_session()) << "\".");
  ASSERT(&client_session() == &msg.client_session());
  switch(msg.key())
  {
    using namespace keys;
    case MODE:
      if (is_channel(in_name(client_session())))
        client_session() << ':' << client_session().identity().server_source() << " 324 " <<
            client_session().client_out_nick() << ' ' << out_name(client_session()) << " +" << channel_modes() << "\r\n";
      break;
    case NAMES:
      do_names_output();
      break;
    case PART:
      client_session().del_private_target(msg.param(0));
      client_session() << ':' << client_session().client_out_nick() <<
          " PART " << msg.param(0) << "\r\n";
      break;
    case PRIVMSG:
      handle_command(msg);
      break;
  }
}

virtual void PrivateTarget::new_server_message_received

(

ServerMessageIn const &

)

[inline, private, virtual]

This is called when a new message targetted at this target is received.

Implements Target.

Definition at line 56 of file PrivateTarget.h.

{ }

virtual char const* PrivateTarget::channel_modes

(

void

)

[inline, protected, virtual]

The channel modes for this target, as sent to the client.

Reimplemented in NoticeTarget.

Definition at line 60 of file PrivateTarget.h.

Referenced by new_client_message_received().

{ return "nt"; }

---

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

• PrivateTarget.h
• PrivateTarget.cc