ircproxy  The Ultimate Cyborg

---

Application.cc

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Application.cc
//! @brief This file contains the implementation of class Application.
//
// 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 <libxml/xmlmemory.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "debug.h"
#endif

#include "Application.h"
#include "ProxyListenSocket.h"
#include "PersistXML.h"
#include "Network.h"
#include "Identity.h"
#include "ClientSession.h"

/*! \brief Constructor
 *
 * Constructs an application object.
 * The application will understand the commandline parameter
 * --listen-port &lt;port&gt;, or -p &lt;port&gt;, next to all default
 * commandline options (see documentation of libcw).
 *
 * &lt;port&gt; is the port that the application will listen on
 * for new client connections (on localhost).
 *
 * \sa Application::finish_options
 */
Application::Application(void) :
    M_listen_port(0),
#ifdef CWDEBUG
    M_suppress_ping(false),
    M_suppress_who(false),
#endif
    M_memory_block_dummy(memory_block_st::create(0)),
    M_msg_block_dummy(M_memory_block_dummy->block_start(), 0, M_memory_block_dummy),
    M_terminating(false)
{
  add_option(&Application::command_line_option_listen_port,
             "listen-port", 'p', "<port>", "Port to listen on for new connections.");
#ifdef CWDEBUG
  add_option(&Application::command_line_option_suppress_ping,
             "suppress-ping", 0, NULL, "Suppress debug output regarding PING/PONG messages.");
  add_option(&Application::command_line_option_suppress_who,
             "suppress-who", 0, NULL, "Suppress debug output regarding WHO messages.");
#endif
}

/*! \brief Destructor
 *
 * The destructor does not throw.
 */
Application::~Application() throw()
{
  // Destroy all Identity's (and thus their target maps), before destroying the networks (and their targets map).
  M_identities.clear();

  // Release memory.
  M_memory_block_dummy->release();
}

void Application::last_server_session_destroyed(void)
{
  if (M_terminating)
    fd_dct::return_when_done(-1);
}

#ifdef CWDEBUG
/*! \brief Called immediately after we reached main.
 *
 * Initialize libcwd here, allowing the command line handling of libcw to override
 * any debug channels and/or set a debug output file.
 */
void Application::main_entered(int*, char* const**)
{
  Debug(debug::init());
}
#endif

/*! \brief Start application.
 *
 * This method is called at the start of the application.
 * It initialized libcwd and creates a new listen socket
 * that listens on Application::M_listen_port.
 * Then the mainloop is started.
 */
void Application::start(void)
{
#ifdef CWDEBUG
  // Redirect debug output to a file.
  static std::ofstream debug_file;
  debug_file.open("debug.out");
  static debug::TeeStream debug_stream(std::cout, debug_file);
  libcwd::libcw_do.set_ostream(&debug_stream);
#endif

  Dout(dc::notice, "Called Application::start()"); 
  
  // Object used to load/store persistant data.
  PersistXML xml;

  unsigned int commandline_listen_port = M_listen_port;

  // If xml file exists, load it.
  struct stat statbuf;
  if (stat("ircproxy.xml", &statbuf) != -1)
  {
    xml.open("ircproxy.xml", PersistXML::load);
    xml.serialize("Application", *this);
    xml.close();
  }

  // Divert signal handling.
  signalRequest(SignalRequestData(SIGINT, sigOneShot|sigReplace),
      Application::instance(), &Application::handle_signal);

  signalRequest(SignalRequestData(SIGHUP),
      Application::instance(), &Application::handle_signal);

  // Determine the listen port of the application.
  if (commandline_listen_port)
    M_listen_port = commandline_listen_port;
  else if (M_listen_port == 0)
    M_listen_port = 6667;                       // Default listen port.

  // Open a listen socket on M_listen_port.
  NEW(ProxyListenSocket(M_listen_port));

  mainloop();

  // Store persistent data.
  xml.open("ircproxy.xml", PersistXML::store);
  xml.serialize("Application", *this);
  xml.close();

  // Get rid of memory leaks of libxml2.
  xmlCleanupParser();
}

/*! \brief Process command line option --listen-port port.
 *
 * This method is called for every --listen-port or -p that is passed
 * on the commandline. \a argument is set to either "--listen-port"
 * or "-p" respectively. The global variable \c optarg is the
 * port that is being passed. When &lt;port&gt; is less than or equal 1024
 * then an error is printed to std:cerr and the application is
 * terminated.
 */
void Application::command_line_option_listen_port(char const* argument)
{
  M_listen_port = atoi(optarg);
  if (M_listen_port <= 1024)
  {
    std::cerr << application_name << ": " << argument << " : out of range" << std::endl;
    libcw_exit(-1);
  }
}

#ifdef CWDEBUG
void Application::command_line_option_suppress_ping(char const* LIBCW_UNUSED(argument))
{
  M_suppress_ping = true;
}

void Application::command_line_option_suppress_who(char const* LIBCW_UNUSED(argument))
{
  M_suppress_who = true;
}
#endif

/*! \brief Process remaining command line arguments.
 *
 * This method is called when all command options have been processed.
 * If \c errflg is set, the usage message is printed to std::cerr
 * and the application exists.
 * If no port was specified, then the default port is set to 6667.
 */
void Application::finish_options(void)
{
  if (errflg)
  {
    print_usage(std::cerr);
    libcw_exit(2);
  }
}

/*! \brief Print version information.
 *
 * This method is called when the application is called with
 * commandline parameter --version or -v. See documentation
 * of libcw.
 */
void Application::print_version(std::ostream& os) const
{
  os << PACKAGE_NAME << " " << VERSION << " by Carlo Wood <carlo@alinoe.com>\n";
}

void Application::handle_signal(SignalType const& signal_type)
{
  DoutEntering(dc::debug, "Application::handle_signal(" << signal_type << ")");

  switch(signal_type.get_signal())
  {
    case SIGHUP:
      Dout( dc::notice, "Received SIGHUP " << signal_type.get_count() << " times." );
      break;
    case SIGINT:
    {
      // QUIT all server connections.
      for (identities_type::iterator iter = identities().begin(); iter != identities().end(); ++iter)
      {
        if (iter->second.has_secondary_server_connection())
          iter->second.secondary_server_connection()->disconnect();
        if (iter->second.has_server_session())
          iter->second.server_connection().quit("ircproxy received SIGINT");    // This set reconnect to false and QUIT's the client.
      }
      // Terminate the application when the last ServerSession is closed.
      M_terminating = true;
      break;
    }
  }
}

//! @brief Serialize application to XML.
void Application::serialize(PersistXML& xml)
{
  xml.serialize("M_listen_port", M_listen_port);
  xml.serialize("M_networks", M_networks);
  xml.serialize("M_identities", M_identities);
}

namespace {
  // reserve static space for the application object:
  SingletonInstance<Application> app_instance __attribute__ ((unused));
}

---