ircproxy  The Ultimate Cyborg

---

ServerConnection.cc

Go to the documentation of this file.

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

#include "ServerConnection.h"
#include "Identity.h"
#include "Server.h"
#include "UserAnswer.h"
#include "ClientSession.h"
#include "keys.h"
#include "Authentication.h"
#include "Expression.h"
#include "Matcher.h"
#include "Bool.inl"
#include "Application.h"

/*! @brief Ordering predicate for Server objects.
 * 
 * This struct determines the (re)connect priority of servers.
 */
struct ConnectionOrder {
  bool operator()(boost::shared_ptr<Server> const& server1, boost::shared_ptr<Server> const& server2)
  {
    timeval const now = timerRequest.get_now();
    timeval const ten_minutes = { 600, 0 };
    timeval ten_minutes_ago;
    timersub(&now, &ten_minutes, &ten_minutes_ago);
    bool server1_more_than_10_minutes_ago = (timercmp(&server1->last_connection_event(), &ten_minutes_ago, <));
    bool server2_more_than_10_minutes_ago = (timercmp(&server2->last_connection_event(), &ten_minutes_ago, <));
    bool server1_longer_ago_than_server2 = (timercmp(&server1->last_connection_event(), &server2->last_connection_event(), <));
    if (server1_more_than_10_minutes_ago != server2_more_than_10_minutes_ago)
      return server1_more_than_10_minutes_ago;
    // Always return false if the objects compare equal.
    bool different_connection_event = (timercmp(&server1->last_connection_event(), &server2->last_connection_event(), !=));
    return different_connection_event && server1_longer_ago_than_server2 != server1_more_than_10_minutes_ago;
  }
};

/*! @brief Connect to the server and stay connected.
 *
 * This function should be called only after the ServerConnection was just created,
 * or after calling ServerConnection::disconnect.
 *
 * This function will start the procedure of connecting to a server,
 * either the one already specified by ServerConnection::M_server or,
 * if none is known, it will first ask the user for a server name and port.
 *
 * It will continue to attempt to connect to a server (with appropriate
 * connect delays if necessary) until connected. After a connection is successful
 * then the authentication sequence is started (handled by Authentication).
 *
 * If a connection is lost, at any time, then a new connection is automatically
 * attempted.
 */
void ServerConnection::connect(bool auto_reconnect)
{
  DoutEntering(dc::debug, "ServerConnection::connect() for " << *this);
  ASSERT(!is_connected());
  ASSERT(M_state == disconnected);
  if (!M_server_session)        // Could already be allocated if has_server() was false
                                // and we get here a second time because the ClientSession
                                // was destroyed after requesting an answer.
  {
    M_server_session = new ServerSession(identity(), *this);
    AllocTag(M_server_session, (M_secondary_connection ? "Secondary Server session of " : "Server session of ") << identity().key());
  }
  if (auto_reconnect)
  {
    // See if we can find a network that this Identity belongs to.
    for (networks_type::iterator network_iter = Application::instance().networks().begin(); network_iter != Application::instance().networks().end(); ++network_iter)
      if (network_iter->name() == identity().network_name())
      {
        if (has_server())
        {
          if (!M_timed_out_count)
          {
            M_timed_out_count = 3 * network_iter->servers().size();
            ASSERT(M_timed_out_count != 0);     // We have at least one server because has_server() is true.
          }
          if (M_timed_out)
            --M_timed_out_count;
        }
        if (network_iter->servers().empty() || (M_timed_out && !M_timed_out_count))
          M_server.reset();     // If we don't have any servers, or when all servers timed out three times on a row.
        else
        {
          std::stable_sort(network_iter->servers().begin(), network_iter->servers().end(), ConnectionOrder());
          M_server = network_iter->servers().front();
        }
        break;
      }
  }
  M_reconnect = true;
  if (has_server())
  {
    timeval next_connect;
    timeradd(&M_server->last_connection_event(), &M_connect_delay, &next_connect);
    timeval now = timerRequest.get_now();
    if (timercmp(&now, &next_connect, >))
      do_connect();
    else
      timerRequest(M_connect_delay, *this, &ServerConnection::delayed_connect);
  }
  else if (identity().has_client_session())
  {
    ASSERT(!M_secondary_connection);    // The secondary connection should always have a server.
    identity().client_session().user_answer_event_server
        (UserAnswerRequestData(identity().client_session(), server_port_question,
        "What server should I connect to (type: <server> [<port> [<localip>]])?"),
        *this, &ServerConnection::received_server_port_answer);
  }
  else
    disconnect();
}

/*! @brief Called when the timer for a delayed connect expired.
 *
 * Never call this function directly.
 */
void ServerConnection::delayed_connect(timer_event_type_ct const& LIBCW_UNUSED_UNLESS_DEBUG(expired_at))
{
  DoutEntering(dc::debug, "ServerConnection::delayed_connect(" << expired_at.get_expire_time() << ")");
  if (!is_connected() && M_reconnect && M_server_session && has_server())
    do_connect();
}

/*! @brief Attempt an immediate connect to the server.
 *
 * Never call this function directly. Call ServerConnection::connect() instead.
 */
void ServerConnection::do_connect(void)
{
  DoutEntering(dc::debug, "ServerConnection::do_connect()");
  ASSERT(M_state == disconnected);

  if (identity().has_client_session())
  {
    std::ostringstream buf;
    buf << "Trying to connect to \"" << M_server->hostname().c_str() << "\" (port " << M_server->next_port() << ").";
    identity().send_notice(buf.str(), server_port_question);
  }

  // Reset the timed_out flag.
  M_timed_out = false;
  // Set new time out timer.
  timeval delay = { 4, 0 };
  timerRequest(delay, *this, &ServerConnection::connect_timed_out);

  ASSERT(M_server->next_port() != 0);
  if (M_server_session->connect(M_server->hostname().c_str(), M_server->next_port(), M_server->vhost()))
  {
    M_server->attempting_to_connect();
    M_connected = true;
    M_server_session->start_authentication();
    M_state = authentication_started;
  }
  else
  {
    ASSERT(!M_secondary_connection);    // FIXME
    // If the connect failed, then we have to ask the user for another servername.
    M_server.reset();
    if (identity().has_client_session())
      identity().client_session().del_private_target(question_target_name(server_port_question));
    // Try again.
    connect(true);
  }
}

void ServerConnection::connect_timed_out(timer_event_type_ct const& LIBCW_UNUSED_UNLESS_DEBUG(expired_at))
{
  if (M_state > authentication_started) // Connection was (already) successful?
    return;

  DoutEntering(dc::debug, "ServerConnection::connect_timed_out(" << expired_at.get_expire_time() << ")");
  M_server_session->close();
  M_timed_out = true;
}

/*! @brief This function is called when an answer to the server/port question is received.
 *
 * Never call this function directly.
 */
void ServerConnection::received_server_port_answer(UserAnswerEventType const& event_type)
{
  DoutEntering(dc::debug, "ServerConnection::received_server_port_answer(" << event_type << ")");
  std::string answer = event_type.answer();
  std::string hostname;
  unsigned int port = 6667;
  struct in_addr vhost = { INADDR_ANY };

  unsigned int count = 0;
  std::stringstream ss(answer);
  std::string buf;
  while ((ss >> buf))
  {
    if (count == 0)
      hostname = buf;
    else if (count == 1)
      port = atoi(buf.c_str());
    else if (count == 2)
      inet_aton(buf.c_str(), &vhost);
    ++count;
  }

  // See if this server was already known.
  bool found = false;
  for (networks_type::iterator network_iter = Application::instance().networks().begin(); network_iter != Application::instance().networks().end(); ++network_iter)
  {
    // Never change network.
    if (has_server() && server()->network().name() != network_iter->name())
      continue;
    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 && memcmp(&(*server_iter)->vhost(), &vhost, sizeof(vhost)) == 0)
      {
        Dout(dc::notice, "Found existing server " << *server_iter);
        found = true;
        M_server = *server_iter;
        M_server->set_port(port);
        break;
      }
    if (found)
      break;
  }
  if (!found)
    M_server.reset(NEW(Server(identity().private_network(), hostname, port, vhost)));
  M_timed_out = false;
  connect(false);
}

/*! @brief This function is called when the ServerSession object is destroyed.
 *
 * Never call this function directly.
 */
void ServerConnection::session_lost(void)
{ 
  if (M_state != disconnected)
  {
    // Inform the server object.
    M_server->connection_lost();
    // Let the client know that the connection was broken.
    if (!M_secondary_connection && identity().has_client_session())
      identity().client_session().serversession_lost();
  }
  M_connected = false;
  M_state = disconnected;
  M_server_session = NULL;
  if (M_secondary_connection)
  {
    M_reconnect = false;
    identity().destroy_secondary_server_connection();
  }
  if (M_reconnect)
    connect(true);
}

// Initial/minimal reconnect delay is 1 second.
timeval ServerConnection::S_connect_delay_init = { 1, 0 };

/*! @brief This function is called if an ERROR message is received.
 *
 * Never call this function directly.
 */
void ServerConnection::error_message_received(ServerMessageIn const& msg)
{
  DoutEntering(dc::notice, "ServerConnection::error_message_received(" << msg << ")");

  server_session().set_disconnect_reason(msg.param(0));

  if (M_state < successful_connect)
  {
    // FIXME: only do this when the connection was throttled.
    // Different actions are needed on different errors.
    M_connect_delay.tv_sec *= 2;  
    if (M_connect_delay.tv_sec > 600)
      M_connect_delay.tv_sec = 600;
    Dout(dc::notice, "Incrementing connect delay to " << M_connect_delay);
  }
}

/*! @brief Called when the first message is received from the server.
 */
void ServerConnection::successful_connection(void)
{
  ASSERT(M_state == authentication_started || M_state == successful_connect);
  M_state = successful_connect;
  M_connect_delay = S_connect_delay_init;       // We didn't get throttled.
  M_timed_out_count = 0;
}

/*! @brief This function is called when a PING message is received.
 *
 * Never call this function directly.
 */
void ServerConnection::decode_ping(ServerMessageIn const& ping_msg)
{
  if (M_state >= real_nick_sent)
  {
    MessageOut msgout(default_priority(keys::PONG));
    server_session().queue_msg(msgout << keys::PONG << ping_msg.param(0));
  }
  else if (M_state >= pong_sent)
    *M_server_session << "PONG " << ping_msg.param(0) << "\r\n";
  else
  {
    successful_connection();
    M_server_session->set_auth_ping_argument(ping_msg.param(0));
  }
}

/*! @brief This function is called when it is safe to call it.
 *
 * See AuthState::AuthState.
 * Never call this function directly.
 */
void ServerConnection::send_pong_and_mode(ExpressionEventType const& LIBCW_UNUSED_UNLESS_DEBUG(event_type))
{
  DoutEntering(dc::notice, "ServerConnection::send_pong_and_mode(" << event_type << ")");

  ASSERT(M_state == successful_connect);                        // We received at least the PING.
  ASSERT(!M_server_session->auth_ping_argument().empty());      // Didn't we?

  *M_server_session << "PONG " << M_server_session->auth_ping_argument() << "\r\n";
  M_state = pong_sent;

  // Send the 'invisible' user mode in the same packet as the PONG, in the hope
  // that the server will process them at the same time. That way we are not
  // (for 2 seconds) visible to the network.
  // Thus, we will have sent [PASS], NICK, USER, PONG, MODE +i -- which should
  // be processed immediately (we have 5 free messages before the flood protection
  // kicks in).
  char service_mode = 'x';      // FIXME, this isn't the same on every network.
  // If we don't know if the USER did set the user mode, ask for the user mode to see if it did.
  // Always sent the +i to assure invisibility at the same time as the PONG is
  // processed.
  if (!M_server->version().get_user_supports_umode())
  {
    // Always set invisibility.
    *M_server_session << "MODE " << M_server_session->nicks().out_nick() << " +i\r\n";
    // Test.
    *M_server_session << "MODE " << M_server_session->nicks().out_nick() << "\r\n";
    // Finish.
    *M_server_session << "MODE " << M_server_session->nicks().out_nick() << " +" << service_mode << "\r\n";
  }
  else if (!*M_server->version().get_user_supports_umode())
    *M_server_session << "MODE " << M_server_session->nicks().out_nick() << " +i" << service_mode << "\r\n";

  ConstExpression<UserModeMask> mask(UserModeMask('i') | service_mode);
  ON_TRUE((*M_server_session->user_mode() & mask) == mask && *M_server_session->M_detected_network, *this, &ServerConnection::invisible_event);

  MatchRequest match_request;
  match_request(keys::MODE).mynick(0);
  M_server_session->message_event_server()(match_request, *this, &ServerConnection::received_first_umode);
}

/*! @brief This function is called when MODE +i is received.
 *
 * Never call this function directly.
 */
void ServerConnection::invisible_event(ExpressionEventType const& LIBCW_UNUSED_UNLESS_DEBUG(event_type))
{
  DoutEntering(dc::notice, "ServerConnection::invisible_event(" << event_type << ')');
  ASSERT(event_type);   // It should be true, of course.
  
  ASSERT(M_state == pong_sent);
  M_state = login_sent;
  *M_server_session << "PRIVMSG X@channels.undernet.org :login " <<
      identity().key() << ' ' << identity().authentication().service_pass() << "\r\n";
}

/*! @brief Called for the first MODE &lt;mynick&gt; received from the server.
 *
 * This call-back is used to extract the real ident and real hostname, as the IRC server sees it.
 */
void ServerConnection::received_first_umode(MatcherEventType const& event_type)
{
  DoutEntering(dc::debug, "ServerConnection::received_first_umode(" << event_type << ")");
  MessageIn::Part const& prefix(event_type.message().prefix_part());
  char const* p = strchr(prefix.start(), '!');
  ASSERT(p);
  char const* ident = p + 1;
  p = strchr(p, '@');
  ASSERT(p);
  size_t ident_len = p - ident;
  char const* real_hostname = p + 1;
  size_t real_hostname_len = prefix.end() - real_hostname;
  identity().set_real_hostname(std::string(real_hostname, real_hostname_len));
  identity().set_ident(std::string(ident, ident_len));
}

void ServerConnection::quit(std::string const& msg)
{
  M_reconnect = false;
  if (M_server_session)
  {
    *M_server_session << "QUIT :" << msg << "\r\n";
    // Force a disconnect if the server reacts too slow.
    timeval delay = { 1, 0 };
    timerRequest(delay, *M_server_session, &ServerSession::force_quit);
  }
}

---