ircproxy  The Ultimate Cyborg

---

debug_ostream_operators.cc

Go to the documentation of this file.

// ircproxy -- an intelligent IRC proxy
//
//! @file debug_ostream_operators.cc
//! @brief This file contains the implementation of ostream inserter operators used for debugging.
//
// 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"        // Put this outside the #ifdef CWDEBUG .. #endif in order
                        // to force recompilation after the configuration changed.
#endif

#ifdef CWDEBUG

#ifndef USE_PCH
#include <iostream>
#include <libcw/support.h>
#include "debug.h"
#include <libcwd/buf2str.h>
#include <libcwd/cwprint.h>
#endif

#include "casereturnstr.h"
#include "PersistXML.h"
#include "Network.h"
#include "MessageIn.h"
#include "UserAnswer.h"
#include "Identity.h"
#include "IdentityReference.h"
#include "Authentication.h"
#include "Channel.h"
#include "Nick.h"
#include "ClientSession.h"
#include "QuestionTarget.h"
#include "NoticeTarget.h"
#include "ServerSession.h"
#include "DestructEvent.h"
#include "ServerConnection.h"
#include "Expression.h"
#include "keys.h"
#include "Matcher.h"
#include "Prefix.h"
#include "JustInTime.h"
#include "PseudoMessageEvent.h"
#include "Member.h"
#include "WhoRequest.h"

namespace debug {

/*!
 * @internal
 * @brief Return a string literal representing the name of the \c state_nt \a state.
 */
char const* state_nt_name(state_nt state)
{
  switch(state)
  {
    // See enum state_nt in ServerConnection.h
    CASERETURNSTR(disconnected);
    CASERETURNSTR(successful_connect);
    CASERETURNSTR(authentication_started);
    CASERETURNSTR(pong_sent);
    CASERETURNSTR(login_sent);
    CASERETURNSTR(real_nick_sent);
    CASERETURNSTR(real_nick_accepted);
  }
  DoutFatal(dc::fatal, "Unhandled state_nt in state_nt_name");
}

/*!
 * @internal
 * @brief Return a string literal representing the name of the \c PersistXML::openmode_type \a openmode.
 */
char const* openmode_name(PersistXML::openmode_type openmode)
{
  switch(openmode)
  {
    // See enum PersistXML::openmode_type in PersistXML.h
    CASERETURNSTR(PersistXML::not_open);
    CASERETURNSTR(PersistXML::store);
    CASERETURNSTR(PersistXML::load);
  }
  DoutFatal(dc::fatal, "Unhandled PersistXML::openmode in openmode_name");
}

/*!
 * @internal
 * @brief Return a string literal representing the name of the \c match0_type \a mt.
 */
char const* match0_type_name(match0_type mt)
{
  switch(mt)
  {
    // See enum match0_type in Matcher.h
    CASERETURNSTR(anystring_mt);
    CASERETURNSTR(nonemptystring_mt);
    CASERETURNSTR(anyserver_mt);
    CASERETURNSTR(localserver_mt);
    CASERETURNSTR(anynick_mt);
    CASERETURNSTR(mynick_mt);
    CASERETURNSTR(anychannel_mt);
    CASERETURNSTR(anyglobalchannel_mt);
    CASERETURNSTR(anylocalchannel_mt);
  }
  DoutFatal(dc::fatal, "Unhandled match0_type in match0_type_name");
}

/*!
 * @internal
 * @brief Return a string literal representing the name of the \c match1_type \a mt.
 */
char const* match1_type_name(match1_type mt)
{
  switch(mt)
  {
    // See enum match1_type in Matcher.h
    CASERETURNSTR(wildcard_mt);
    CASERETURNSTR(regexp_mt);
    CASERETURNSTR(exactmatch_mt);
  }
  DoutFatal(dc::fatal, "Unhandled match1_type in match1_type_name");
}

/*!
 * @internal
 * @brief Return a string literal representing the name of the \c int \a command.
 */
char const* command_name(int command)
{
  using namespace keys;
  switch(command)
  {
    // See irc_commands
    CASERETURNSTR(PASS);
    CASERETURNSTR(USER);
    CASERETURNSTR(NICK);
    CASERETURNSTR(PING);
    CASERETURNSTR(ERROR);
    CASERETURNSTR(QUIT);
    CASERETURNSTR(WHO);
    CASERETURNSTR(WHOIS);
    CASERETURNSTR(WHOWAS);
    CASERETURNSTR(PRIVMSG);
    CASERETURNSTR(NOTICE);
    CASERETURNSTR(CPRIVMSG);
    CASERETURNSTR(CNOTICE);
    CASERETURNSTR(LINKS);
    CASERETURNSTR(JOIN);
    CASERETURNSTR(PART);
    CASERETURNSTR(KICK);
    CASERETURNSTR(MODE);
    CASERETURNSTR(NAMES);
    CASERETURNSTR(TOPIC);
  }
  DoutFatal(dc::fatal, "Unhandled command key in command_name");
}

} // namespace debug

//! For debugging purposes. Write a state_nt to \a os.
std::ostream& operator<<(std::ostream& os, state_nt state)
{
  return os << debug::state_nt_name(state);
}

//! For debugging purposes. Write a PersistXML::openmode to \a os.
std::ostream& operator<<(std::ostream& os, PersistXML::openmode_type openmode)
{
  return os << debug::openmode_name(openmode);
}

//! For debugging purposes. Write a match0_type to \a os.
std::ostream& operator<<(std::ostream& os, match0_type mt)
{
  return os << debug::match0_type_name(mt);
}

//! For debugging purposes. Write a match1_type to \a os.
std::ostream& operator<<(std::ostream& os, match1_type mt)
{
  return os << debug::match1_type_name(mt);
}

//! For debugging purposes. Write an Application to \a os.
std::ostream& operator<<(std::ostream& os, Application const& LIBCW_UNUSED(application))
{
  return os << "(application)";
}

//! For debugging purposes. Write a Network to \a os.
std::ostream& operator<<(std::ostream& os, Network const& network)
{
  os << "{name:" << network.name();
  if (network.has_domain())
    os << ", domain:" << network.domain();
  os << ", servers:{";
  Network::servers_type::const_iterator iter = network.servers().begin();
  if (iter != network.servers().end())
  {
    os << *iter;
    while (++iter != network.servers().end())
      os << ", " << *iter;
  }
  return os << "}}";
}

//! For debugging purposes. Write a Server to \a os.
std::ostream& operator<<(std::ostream& os, Server const& server)
{
  os << "{hostname:" << server.hostname() <<
        ", irc_name:" << server.get_irc_name() <<
        ", ports:{";
  Server::ports_type::const_iterator iter = server.ports().begin();
  if (iter != server.ports().end())
  {
    os << *iter;
    while (++iter != server.ports().end())
      os << ", " << *iter;
  }
  os << "}, last_connection_event:" << server.last_connection_event();
  return os << '}';
}

//! For debugging purposes. Write a MessageIn to \a os.
std::ostream& operator<<(std::ostream& os, MessageIn const& msg)
{
  os << '{';
  if (msg.uninitialized())
    return os << "<uninitialized>}";
  if (msg.has_prefix())
    os << "prefix:\"" << libcwd::buf2str(msg.prefix_part().start(), msg.prefix_part().len()) << "\", ";
  if (msg.command_part().start())
    os << "command:\"" <<
        libcwd::buf2str(msg.command_part().start(), msg.command_part().len()) << "\" [key:" << msg.key() << "]";
  os << ", params:{";
  MessageIn::params_type::const_iterator iter = msg.params().begin();
  if (iter != msg.params().end())
  {
    os << *iter;
    while(++iter != msg.params().end())
      os << ", " << *iter;
  }
  return os << "}}";
}

//! For debugging purposes. Write a ClientMessageIn to \a os.
std::ostream& operator<<(std::ostream& os, ClientMessageIn const& msg)
{
  return os << "{client_session:" << msg.client_session() <<
     "; MessageIn:" << *static_cast<MessageIn const*>(&msg) << '}';
}

//! For debugging purposes. Write a ServerMessageIn to \a os.
std::ostream& operator<<(std::ostream& os, ServerMessageIn const& msg)
{
  return os << "{server_session:" << msg.server_session() <<
     "; MessageIn:" << *static_cast<MessageIn const*>(&msg) << '}';
}

//! For debugging purposes. Write a UserAnswerRequestData to \a os.
std::ostream& operator<<(std::ostream& os, UserAnswerRequestData const& request_data)
{
  return os << '{' << "question:\"" << request_data.question() << "\" [client_session:" << request_data.client_session() << "]}";
}

//! For debugging purposes. Write a UserAnswer to \a os.
std::ostream& operator<<(std::ostream& os, UserAnswer const& answer)
{
  os << '{' << "answer:\"" << answer.M_answer;
  os << "\", client_session:" << answer.M_client_session;
  os << ", target:\"" << answer.M_target_name;
  os << "\"}";
  return os;
}

//! For debugging purposes. Write a UserAnswerEventRequestBase to \a os.
std::ostream& operator<<(std::ostream& os, UserAnswerEventRequestBase const& request)
{
  os << "{request_data:" << request.M_request_data;
  if (request.M_target.get())
    os << ", target:" << *request.M_target.get();
  return os << '}';
}

//! For debugging purposes. Write a Identity to \a os.
std::ostream& operator<<(std::ostream& os, Identity const& identity)
{
  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;
}

//! For debugging purposes. Write a ServerConnection to \a os.
std::ostream& operator<<(std::ostream& os, ServerConnection const& server_connection)
{
  os << "{server:";
  if (server_connection.M_server.get())
    os << *server_connection.M_server.get();
  else
    os << "<none>";
  os << "; server_session:";
  if (server_connection.has_server_session())
    os << server_connection.server_session();
  else
    os << "<NULL>";
  os << "; reconnect:";
  if (server_connection.reconnect())
    os << "true";
  else
    os << "false";
  os << "; connected:";
  if (server_connection.is_connected())
    os << "true";
  else
    os << "false";
  os << "; state:" << server_connection.state();
  os << "; connect_delay:" << server_connection.connect_delay();
  os << "; timed_out:";
  if (server_connection.timed_out())
    os << "true";
  else
    os << "false";
  os << "; timed_out_count:" << server_connection.timed_out_count();
  os << "; secondary_connection:" << server_connection.secondary_connection();
  return os << '}';
}

//! For debugging purposes. Write a IdentityReference to \a os.
std::ostream& operator<<(std::ostream& os, IdentityReference const& identity_reference)
{
  os << "[identity:" << identity_reference.identity().key() << ']';
  return os;
}

//! For debugging purposes. Write a Authentication to \a os.
std::ostream& operator<<(std::ostream& os, Authentication const& authentication)
{
  os << "{server_pass:" <<
#ifdef PRINT_AUTHENTICATION
      authentication.M_server_pass
#else
      "***"
#endif
      ;
  os << ", service_pass:" <<
#ifdef PRINT_AUTHENTICATION
      authentication.M_service_pass
#else
      "***"
#endif
      ;
  os << ", ident:" << authentication.M_ident;
  os << ", realname:" << authentication.M_realname;
  os << ", received_nick:" << authentication.M_received_nick;
  os << ", received_user:" << authentication.M_received_user;
  return os << ' ' << static_cast<IdentityReference const&>(authentication) << '}';
}

//! For debugging purposes. Write a Channel to \a os.
std::ostream& operator<<(std::ostream& os, Channel const& channel)
{
  os << "{Channel " << static_cast<Target const&>(channel);
  return os << '}';
}

//! For debugging purposes. Write a Nick to \a os.
std::ostream& operator<<(std::ostream& os, Nick const& nick)
{
  os << "{Nick " << static_cast<Target const&>(nick);
  return os;
}

//! For debugging purposes. Write a ClientSession to \a os.
std::ostream& operator<<(std::ostream& os, ClientSession const& client_session)
{
  os << "{ClientSession ";
  if (client_session.has_identity())
    os << static_cast<IdentityReference const&>(client_session);
  else
    os << "with no Identity";
  return os << '}';
}

//! For debugging purposes. Write a QuestionTarget to \a os.
std::ostream& operator<<(std::ostream& os, QuestionTarget const& question_target)
{
  os << "{QuestionTarget " << static_cast<Target const&>(question_target) << '}'; 
  return os;
}

std::ostream& operator<<(std::ostream& os, NoticeTarget const& notice_target)
{
  os << "{NoticeTarget " << static_cast<Target const&>(notice_target) << '}'; 
  return os;
}

//! For debugging purposes. Write a ServerSession to \a os.
std::ostream& operator<<(std::ostream& os, ServerSession const& server_session)
{
  os << "{ServerSession ";
  os << static_cast<IdentityReference const&>(server_session);
  return os << '}';
}

//! For debugging purposes. Write a Target to \a os.
std::ostream& operator<<(std::ostream& os, Target const& target)
{
  //os << "{serverside_name:\"" << target.serverside_name() << "\", clientside_name:\"" << target.clientside_name() << "\", network:" << target.network().name();
  os << "{FIXME";
  return os << '}';
}

//! For debugging purposes. Write a PseudoMessageEventRequestData to \a os.
std::ostream& operator<<(std::ostream& os, PseudoMessageEventRequestData const& request_data)
{
  os << "{PseudoMessageEventRequestData FIXME";
  return os << '}';
}

//! For debugging purposes. Write a MessageOutData to \a os.
std::ostream& operator<<(std::ostream& os, MessageOutData const& data)
{
  os << "{message:";
#if 0
  for (std::vector<boost::shared_ptr<JustInTimeToken> >::const_iterator iter = data.M_tokens.begin(); iter != data.M_tokens.end(); ++iter)
  {
    std::string str1((*iter)->value(serverside));
    std::string str2((*iter)->value(clientside));
    if (str1 == str2)
      os << '{' << libcwd::buf2str(str1.data(), str1.length()) << '}';     
    else
      os << "{serverside:" << libcwd::buf2str(str1.data(), str1.length()) << ", clientside:" << libcwd::buf2str(str2.data(), str2.length()) << '}';
  }
#else
  os << "FIXME";
#endif
  os << "}, priority:" << data.M_priority;
  return os << '}';
}

//! For debugging purposes. Write a MessageOut to \a os.
std::ostream& operator<<(std::ostream& os, MessageOut const& message)
{
  os << "{data:" << *message.M_data;
  return os << '}';
}

//! For debugging purposes. Write a Priority to \a os.
std::ostream& operator<<(std::ostream& os, Priority const& priority)
{
  // FIXME
  os << "{<priority>";
  return os << '}';
}

//! For debugging purposes. Write a timeval to \a os.
std::ostream& operator<<(std::ostream& os, timeval const& time)
{
  return os << "{tv_sec:" << time.tv_sec << ", tv_usec:" << time.tv_usec << '}';
}

//! For debugging purposes. Write a regex_t to \a os.
std::ostream& operator<<(std::ostream& os, regex_t const&)
{
  os << "{<compiled>";
  return os << '}';
}

//! For debugging purposes. Write a ExpressionEventType to \a os.
std::ostream& operator<<(std::ostream& os, ExpressionEventType const& event_type)
{
  os << "{expression_value:" << (event_type.M_expression_value ? "true" : "false");
  os << ", expression:\"";
  event_type.M_expression->print_on(os);
  return os << "\"}";
}

//! For debugging purposes. Write a ExpressionEventServer to \a os.
std::ostream& operator<<(std::ostream& os, ExpressionEventServer const& expression_event_server)
{
  os << "{expression:\"";
  expression_event_server.M_expression->print_on(os);
  os << "\", ok:" << (expression_event_server.M_ok ? "true" : "false");
  os << ", evaluation:" << (expression_event_server.M_evaluation ? "true" : "false");
  return os << '}';
}

//! For debugging purposes. Write a Bool to \a os.
std::ostream& operator<<(std::ostream& os, Bool const& b)
{
  return os << "{value:" << b.M_value << "; name:\"" << b.M_name << "\"}";
}

//! For debugging purposes. Write a Matcher to \a os.
std::ostream& operator<<(std::ostream& os, Matcher const& matcher)
{
  os << '{';
  matcher.print_type_on(os);
  os << ' ';
  matcher.Matcher::print_on(os);
  os << ", ";
  matcher.print_on(os);
  return os << '}';
}

//! For debugging purposes. Write a MatchRequestList to \a os.
std::ostream& operator<<(std::ostream& os, MatchRequestList const& match_request_list)
{
  os << "{command: ";
  if (match_request_list.M_command < 0)
    os << debug::command_name(match_request_list.M_command);
  else
    os << match_request_list.M_command;
  os << ", conditions:{";
  std::multiset<boost::shared_ptr<Matcher> >::const_iterator iter = match_request_list.M_conditions.begin();
  if (iter != match_request_list.M_conditions.end())
  {
    os << **iter;
    while(++iter != match_request_list.M_conditions.end())
      os << ", " << **iter;
  }
  return os << "}}";
}

//! For debugging purposes. Write a MatchRequest to \a os.
std::ostream& operator<<(std::ostream& os, MatchRequest const& match_request)
{
  os << "{match_request_list:" << match_request.match_request_list();
  return os << '}';
}

//! For debugging purposes. Write a MatcherEventType to \a os.
std::ostream& operator<<(std::ostream& os, MatcherEventType const& event_type)
{
  os << "{message:" << event_type.message();
  return os << '}';
}

//! For debugging purposes. Write a MatcherEventRequestBase to \a os.
std::ostream& operator<<(std::ostream& os, MatcherEventRequestBase const& request)
{
  os << "{request_data:" << request.M_request_data;
  return os << '}';
}

//! For debugging purposes. Write a Prefix to \a os.
std::ostream& operator<<(std::ostream& os, Prefix const& prefix)
{
  os << '{';
  if (prefix.empty())
    os << "Empty Prefix";
  else if (!prefix.server_name().empty())
    os << prefix.server_name();
  else
  {
#if 0
    if (prefix.nick()->serverside_name() == prefix.nick()->clientside_name())
      os << prefix.nick()->serverside_name();
    else
      os << "{serverside:" << prefix.nick()->serverside_name() << "; clientside:" << prefix.nick()->clientside_name() << '}';
#else
    os << "FIXME";
#endif
    os << '!';
    if ((prefix.nick()->data().initialized() & username_bit))
      os << prefix.nick()->data().username();
    else
      os << "<uninitialized>";
    os << '@';
    if ((prefix.nick()->data().initialized() & hostname_bit))
      os << prefix.nick()->data().hostname();
    else
      os << "<uninitialized>";
  }
  return os << '}';
}

std::ostream& operator<<(std::ostream& os, Member const& member)
{
  os << '{';
  os << "nick:" << member.get_nick();
  return os << '}';
}

std::ostream& operator<<(std::ostream& os, WhoOptions const& options)
{
  return os << options.str();
}

std::ostream& operator<<(std::ostream& os, WhoRequest const& who_request)
{
  return os << "{mask:" << who_request.mask() << "; options:" << who_request.options() << '}';
}

std::ostream& operator<<(std::ostream& os, SignalType const& signal)
{
  return os << "{sig:" << signal.get_signal() << "; count:" << signal.get_count() << '}';
}

std::ostream& operator<<(std::ostream& os, ServerVersion const& server_version)
{
  return os << libcwd::cwprint(server_version);
}

std::ostream& operator<<(std::ostream& os, AuthState const& auth_state)
{
  return os << libcwd::cwprint(auth_state);
}

#endif // CWDEBUG

---