ircproxy  The Ultimate Cyborg

---

MessageIn.h

Go to the documentation of this file.

// ircproxy -- An intelligent IRC proxy
//
//! @file MessageIn.h
//! @brief Header of class MessageIn
//
// 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 IRCMESSAGE_H
#define IRCMESSAGE_H

#ifndef USE_PCH
#include <map>
#include <string>
#include <vector>
#include "debug.h"
#include <libcw/dbstreambuf.h>  // msg_block_ct
#ifdef CWDEBUG
#include <libcwd/buf2str.h>
#endif
#endif

#include "Keyword.h"
#include "Prefix.h"

class ClientSession;
class ServerSession;
class MsgPart;

/*! @brief
 *
 * An IRC message as received from client or server.
 */
class MessageIn {
public:
  //! Part of an MessageIn.
  class Part {
  private:
    char const* M_ptr;          //!< Pointer to the start of the Part.
    size_t M_len;               //!< The number of characters that belong to this Part.
  public:
    //! Construct an uninitialized Part.
    Part(void) { }
    //! Construct a Part with start \a start and end \a end.
    Part(char const* start, char const* end) : M_ptr(start), M_len(end - start) { }
    //! Initialize the Part.
    void set(char const* start, char const* end) { M_ptr = start; M_len = end - start; }
    //! Initialize an empty Part.
    void clear(void) { M_ptr = NULL; }
    //! Return the start of the Part.
    char const* start(void) const { return M_ptr; }
    //! Return the end (exclusive) of the Part.
    char const* end(void) const { return M_ptr + M_len; }
    //! The size of the Part (end minus start).
    size_t len(void) const { return M_len; }
#ifdef CWDEBUG
    //! For debugging purposes. Write \a part to \a os.
    friend std::ostream& operator<<(std::ostream& os, Part const& part)
        { return os << '"' << libcwd::buf2str(part.M_ptr, part.M_len) << '"'; }
#endif
  };

public:
  typedef std::vector<Part> params_type;        //!< Type of M_params.

private:
  msg_block_ct M_msg_block;             //!< Message block to keep message alive as long as we use it.
  char const* M_end;                    //!< Points one after the message (at '\\r' or '\\n').
  Part M_prefix;                        //!< The prefix (without colon).
  Part M_command;                       //!< The command or numeric.
  int M_key;                            //!< The command or numeric as integer.
  Keyword const* M_keyword_ptr;         //!< Pointer to Keyword struct, if the command is a known command.
  params_type M_params;                 //!< The command parameters.

protected:
  //! Construct an uninitialized MessageIn.
  MessageIn(void);

public:
  //! (re)initialize this MessageIn.
  void init(msg_block_ct msg_block);

  //! Return true if this MessageIn is still uninitialized.
  bool uninitialized(void) const { return M_msg_block.get_size() == 0; }

  //! Returns true when this message is a numeric reply.
  bool is_numeric(void) const { return M_command.start() && std::isdigit(*M_command.start()); }

  //! The numeric value of this numeric reply.
  int numeric(void) const { ASSERT(is_numeric()); return M_key; }

  //! Numeric representation of command or numeric.
  int key(void) const { return M_key; }

  //! The number of parameters.
  params_type::size_type params_size(void) const { return M_params.size(); }

  //! A const reference to the vector with parameter Parts.
  params_type const& params(void) const { return M_params; }

  //! Returns parameter \a n as a std::string. The result is empty if there no such parameter.
  std::string param(size_t n) const
  {
    std::string result;
    if (n < M_params.size())
      result.assign(M_params[n].start(), M_params[n].len());
    return result;
  }

  //! Returns parameters \a n and higher as MsgPart. The result is empty if there no such parameter.
  MsgPart params(size_t n) const;

  //! Returns true if there is a prefix.
  bool has_prefix(void) const { return M_prefix.start(); }

  //! The prefix.
  std::string prefix_str(void) const { ASSERT(has_prefix()); return std::string(M_prefix.start(), M_prefix.len()); }

  //! The prefix. The returned Part is only valid as long as the MessageIn is not destructed.
  Part prefix_part(void) const { ASSERT(has_prefix()); return M_prefix; }

  //! The prefix.
  Prefix prefix(void) const
      { return has_prefix() ? (is_server_message() ? Prefix(priv_server_session(), prefix_str()) : Prefix(priv_client_session(), prefix_str())) : Prefix(); }

  //! The command as received.
  std::string command_str(void) const { return M_command.start() ? std::string(M_command.start(), M_command.len()) : ""; }

  //! The command. The returned Part is only valid as long as the MessageIn is not destructed.
  Part const& command_part(void) const { return M_command; }

  //! The command as uppercase C string.
  char const* uppercase_command(void) const { ASSERT(M_key < 0); return M_keyword_ptr->name; }

  //! Pointer to one beyond the end of the message.
  char const* end(void) const { return M_end; }

protected:
  //! Return true if this is a ServerMessageIn.
  virtual bool is_server_message(void) const = 0;

  //! The session of the derived class.
  virtual ServerSession& priv_server_session(void) const = 0;
  //! The session of the derived class.
  virtual ClientSession& priv_client_session(void) const = 0;
};

//! Like MessageIn::Part but with a copy of msg_block_ct to keep the message block alive.
//
// Unlike MessageIn::Part, a MsgPart can be used even after the corresponding MessageIn is destroyed.
class MsgPart : public MessageIn::Part {
private:
  msg_block_ct M_msg_block;     //!< The message block.
public:
  //! Construct an empty MsgPart that will reference \a msg_block.
  MsgPart(msg_block_ct const& msg_block) : M_msg_block(msg_block) { }
  //! Construct a MsgPart from Part \a part that references \a msg_block.
  MsgPart(msg_block_ct const& msg_block, Part const& part) : MessageIn::Part(part), M_msg_block(msg_block) { }
};

inline MsgPart MessageIn::params(size_t n) const
{
  MsgPart result(M_msg_block);
  if (n < M_params.size())
  {
    char const* start = M_params[n].start();
    if (n == M_params.size() - 1 && start[-1] == ':')
      --start;
    result.set(start, M_end);
  }
  else
    result.clear();
  return result;
}

/*! @brief
 *
 * An IRC message as received from a client.
 */
class ClientMessageIn : public MessageIn {
  private:
    ClientSession* M_client_session;            //!< The client session over which this message was received.
  public:
    //! Construct a ClientMessageIn that was received via client session \a client_session.
    ClientMessageIn(ClientSession* client_session) : M_client_session(client_session) { }
#ifdef CWDEBUG
    //! Copy-constructor.
    ClientMessageIn(ClientMessageIn const& msg) : MessageIn(msg), M_client_session(msg.M_client_session)
        { Dout(dc::objects, "Copy-constructing ClientMessageIn from " << msg); }
    //! Destructor.
    ~ClientMessageIn() { Dout(dc::objects, "Destructing ClientMessageIn " << *this); }
#endif

    //! Accessor for M_client_session.
    ClientSession& client_session(void) const { return *M_client_session; }

  protected:
    virtual bool is_server_message(void) const { return false; }

    virtual ClientSession& priv_client_session(void) const { return client_session(); }
    virtual ServerSession& priv_server_session(void) const { DoutFatal(dc::core, "Calling MessageIn::server_session() for ClientMessageIn"); }
};

/*! @brief
 *
 * An IRC message as received from a server.
 */
class ServerMessageIn : public MessageIn {
  private:
    ServerSession* M_server_session;            //!< The server session over which this message was received.
  public:
    //! Construct a ServerMessageIn that was received via server session \a server_session.
    ServerMessageIn(ServerSession* server_session) : M_server_session(server_session) { }
#ifdef CWDEBUG
    //! Copy-constructor.
    ServerMessageIn(ServerMessageIn const& msg) : MessageIn(msg), M_server_session(msg.M_server_session)
        { Dout(dc::objects, "Copy-constructing ServerMessageIn from " << msg); }
#endif
    //! Destructor.
    ~ServerMessageIn() { Dout(dc::objects, "Destructing ServerMessageIn " << *this); }

    //! Accessor for M_server_session.
    // This returns a non-const ServerSession, even though the method is const,
    // because the const applies to the MessageIn. The ServerSession pointer is
    // just for convenience ("this is the ServerSession that this message was
    // received over).
    ServerSession& server_session(void) const { return *M_server_session; }

  protected:
    virtual bool is_server_message(void) const { return true; }

    virtual ClientSession& priv_client_session(void) const { DoutFatal(dc::core, "Calling ServerMessageIn::priv_client_session()"); }
    virtual ServerSession& priv_server_session(void) const { return server_session(); }
};

#endif // IRCMESSAGE_H

---