ircproxy  The Ultimate Cyborg

---

ClientSession.cc

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file ClientSession.cc
//! @brief This file contains the implementation of class ClientSession.
//
// 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 USE_PCH
#include "sys.h"
#include <sstream>
#include <libcw/inet_debug_support.h>
#include "debug.h"
#endif

#include "ClientSession.h"
#include "keys.h"
#include "exceptions.h"
#include "Identity.h"
#include "identities_type.h"
#include "Application.h"
#include "Target.h"
#include "Channel.h"
#include "Nick.h"
#include "is_channel.h"
#include "Authentication.h"
#include "is_channel.h"
#include "exceptions.h"

void ClientSession::new_message_received(ClientMessageIn const& msg)
{
#ifdef CWDEBUG
  // Suppress all debug output related to PING messages.
  bool suppress_debug_output =
      (msg.key() == keys::PING && Application::instance().suppress_ping()) ||
      (msg.key() == keys::WHO && Application::instance().suppress_who());
  Debug(if (suppress_debug_output) libcw_do.off());
#endif

  DoutEntering(dc::debug, "ClientSession::new_message_received(" << msg << ")");
  if (must_be_removed())
  {
    Dout(dc::debug, "Do nothing, ClientSession is marked for removal.");
    // Turn debug output on again, if it was suppressed.
    Debug(if (suppress_debug_output) libcw_do.on());
    // Skip message.
    return;
  }
  if (!has_identity())
  {
    if (msg.key() != keys::PASS)
    {
      // Turn debug output on again, if it was suppressed.
      Debug(if (suppress_debug_output) libcw_do.on());
      Dout(dc::notice, "Received non-PASS message from client without Identity (" << msg << ')');
      // Error. The first message from a client must ALWAYS be a PASS.
      fatal_error("Send PASS first.");
      return;
    }
    Dout(dc::debug, "Received PASS: " << msg);
    std::string password(msg.param(0));
    if (password.empty())
    {
      fatal_error("Empty password.");
      return;
    }
    else
    {
      // Find or create Identity.
      identities_type::iterator iter = Application::instance().identities().find(password);
      if (iter == Application::instance().identities().end())
      {
        // Create new Identity.
        Identity identity(password);
        set_identity(&Application::instance().identities().
            insert(std::pair<std::string, Identity>(password, identity)).first->second);
        Dout(dc::debug, "Created a new Identity.");
      }
      else
      {
        set_identity(&iter->second);
        // If the identity already has another ClientSession, kill that.
        if (identity().has_client_session())
        {
          ClientSession& old_client_session(identity().client_session());
          std::ostringstream error_msg;
          error_msg << "Received new client connection from " << old_client_session.remote_ip();
          old_client_session.fatal_error(error_msg.str().c_str());
          // Wait till the old session is actually destructed before processing
          // messages from this connection.
          start_queuing_messages();
          // Request stop_queuing_messages to be called when old_client_session is destructed.
          old_client_session.destruct_event_server(*this, &ClientSession::stop_queuing_messages);
        }
      }
      identity().set_client_session(this);
      if (identity().hostname() != unknown_hostname)
      {
        std::ostringstream buf;
        buf << remote_ip();
        identity().set_hostname(buf.str());
      }
    }
  }
  if (!M_queue_messages)
    process_message(msg);
  else
    queue_message(msg);

  // Turn debug output on again, if it was suppressed.
  Debug(if (suppress_debug_output) libcw_do.on());
}

void ClientSession::process_message(ClientMessageIn const& msg)
{
  DoutEntering(dc::debug, "ClientSession::process_message(" << msg << ")");
  try
  {
    identity().new_client_message_received(msg);
  }
  catch (FatalError& error)
  {
    Debug(edragon::caught(error));
    fatal_error(error.what());
    return;
  }
}

void ClientSession::start_queuing_messages(void)
{
  M_queue_messages = true;
}

void ClientSession::stop_queuing_messages(DestructEventType const&)
{
  while (!M_msg_queue.empty())
  {
    process_message(M_msg_queue.back());
    M_msg_queue.pop_back();
  }
  M_queue_messages = false;
}

void ClientSession::queue_message(ClientMessageIn const& msg)
{
  DoutEntering(dc::debug, "ClientSession::queue_message(" << msg << ")");
  M_msg_queue.push_front(msg);
}

void ClientSession::queue_msg_as_is(ServerMessageIn const& msg)
{
  Prefix prefix(msg);
  MessageOut msgout(default_priority(msg.key()));
  queue_msg(msgout << prefix << msg.key() << msg.params(0));
}

void ClientSession::queue_msg_me_as_is(ServerMessageIn const& msg)
{
  ASSERT(msg.param(0) == identity().mynick()->in_name(msg.server_session()));
  Prefix prefix(msg);
  MessageOut msgout(default_priority(msg.key()));
  queue_msg(msgout << prefix << msg.key() << identity().mynick() << msg.params(1));
}

void ClientSession::fatal_error(char const* error_msg)
{
  DoutEntering(dc::debug, "ClientSession::fatal_error(\"" << error_msg << "\")");
  if (!must_be_removed())               // Only write one error at a time.
    *this << "ERROR :" << error_msg << "\r\n";
  // The next method sets 'must_be_removed()' to true,
  // flushes the error and deletes this object (non-blocking).
  del();
}

ClientSession::~ClientSession()
{
  Dout(dc::objects, "Destructing ClientSession " << *this);
  if (has_identity())
    identity().reset_client_session(this);
  // First erase pending UserAnswer requests.
  user_answer_event_server.destroy_requests();
  // Then trigger the destruct event.
  destruct_event_server.trigger(DestructEventType());
  // Finally cancel all other event requests for this object.
  cancel_all_requests();
}

//! Add \a target to the private targets list.
void ClientSession::add_private_target(boost::shared_ptr<Target> const& target)
{
#if defined(DEBUG) || defined(CWDEBUG)
  std::pair<private_targets_type::iterator, bool> result =
#endif
      M_private_targets.insert(private_targets_type::value_type(target->in_name(*this), target));
  ASSERT(result.second);
}

//! Remove \a target_name from the private targets list.
void ClientSession::del_private_target(std::string const& target_name)
{
  private_targets_type::iterator iter = M_private_targets.find(target_name);
  ASSERT(iter != M_private_targets.end());
  M_private_targets.erase(iter);
}

//! Create a new target \a target_name and add it to the private targets map, unless it already exists.
void ClientSession::create_private_target(std::string const& target_name, Network& network)
{
  DoutEntering(dc::debug, "ClientSession::create_private_target(\"" << target_name << "\", " << network << ')');
  ASSERT(network.is_private());
  private_targets_type::iterator iter = M_private_targets.find(target_name);
  if (iter == M_private_targets.end())
  {
    Dout(dc::debug, "Not found. Creating new private target.");
    if (is_channel(target_name))
    {
      boost::shared_ptr<Target> new_target(NEW(Channel(identity(), target_name, network, 0)));
      M_private_targets.insert(private_targets_type::value_type(target_name, new_target));
    }
    else
    {
      ASSERT(is_nick(target_name));
      boost::shared_ptr<Target> new_target(NEW(Nick(*this, target_name, network)));
      M_private_targets.insert(private_targets_type::value_type(target_name, new_target));
    }
  }
#ifdef CWDEBUG
  else
    Dout(dc::debug, "Found: " << *iter);
#endif
}

void ClientSession::queue_msg(MessageOut const& msgout)
{
  DoutEntering(dc::debug, "ClientSession::queue_msg(" << msgout << ")");
  // No need to queue anything (yet?), just send it to the client.
  msgout.write_to(*this);
}

void ClientSession::new_client_nick_received(std::string const& nick)
{
  M_in_nick = nick;
  if (!M_first_nick)
  {
    // Client tries to change nick name.
    PseudoMessageOut pseudo_msg(default_priority(keys::NICK));
    pseudo_msg.writeEventRequest(identity().server_session(), &ServerSession::send_nick_write_event, M_in_nick);
    identity().server_session().queue_msg(pseudo_msg);
  }
  else
  {
    identity().mynick()->set_in_nick(*this, M_in_nick);         // Initialize out client-side nick name.
    identity().authentication().received_nick();
  }
  M_first_nick = false;
}

void ClientSession::serversession_lost(void)
{
  // Run over all channels that we're on.
  for (joined_channels_type::iterator channel_iter = joined_channels().begin(); channel_iter != joined_channels().end(); ++channel_iter)
  {
    boost::shared_ptr<Channel> const& channel(boost::static_pointer_cast<Channel>(channel_iter->second));
    // Run over all members.
    for (Channel::members_type::iterator member_iter = channel->members().begin(); member_iter != channel->members().end();)
    {
      // QUIT all members except myself.
      boost::shared_ptr<Nick> const& nick((member_iter++)->second.get_nick());
      if (!nick->is_me())
        identity().do_quit(nick, "ircproxy lost connection");
    }
  }
}

boost::shared_ptr<Nick> ClientSession::get_nick(std::string const& nick_name, bool create)
{
  ASSERT(is_nick(nick_name));

  // First search in the map with private targets.
  private_targets_type::const_iterator priv_iter = private_targets().find(nick_name);
  if (priv_iter != private_targets().end())
    return boost::static_pointer_cast<Nick>(priv_iter->second);

  // FIXME

  THROW_EXCEPTION(unknown_target(), "There is no client side nick \"" << nick_name << "\" on ClientSession " << *this);
}

---