ircproxy  The Ultimate Cyborg

---

MessageOut.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file MessageOut.h
//! @brief This file contains the declaration of class MessageOut and MessageOutData.
//
// 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 MESSAGEOUT_H
#define MESSAGEOUT_H

#ifndef USE_PCH
#include <sstream>
#include <string>
#include <boost/shared_ptr.hpp>
#include "debug.h"
#endif

#include "Priority.h"
#include "Prefix.h"
#include "MessageIn.h"
#include "JustInTime.h"
#include "PseudoMessageEvent.h"

//! The type of message.
enum msg_type {
  unsafe_msg,   //!< Message may only be sent to the server after the IP is hidden.
  safe_query    //!< The message can be sent to the server regardless.
};

//! A structure containing the data associated with a MessageOut object.
struct MessageOutData {
  Priority M_priority;                  //!< Message priority.
  msg_type M_type;                      //!< Whether or not it's safe to send this message before authentication.
  std::vector<boost::shared_ptr<JustInTimeToken> > M_tokens;
  uint32_t M_sequence_number;           //!< A sequence number. Larger if this message was created later.
  static uint32_t S_sequence_number;    //!< The next sequence number.

  //! Construct a MessageOutData object with prefix.
  MessageOutData(Priority const& priority, msg_type type) : M_priority(priority), M_type(type), M_sequence_number(S_sequence_number++)
      { Dout(dc::objects, "Constructing MessageOutData(" << priority << ")"); }
  //! Destructor.
  virtual ~MessageOutData() { Dout(dc::objects, "Destructing MessageOutData " << *this << ", sequence number " << M_sequence_number); }

  //! Return true if this is a pseudo message.
  virtual bool is_pseudo_message(void) const { return false; }

  //! Returns the true if the message can be sent to the server without first logging into X.
  bool is_safe(void) const { return M_type == safe_query; }
};

//! \internal
// The actual data of a PseudoMessageOut object.
struct PseudoMessageOutData : public MessageOutData {
  PseudoMessageEventServer M_pseudo_message_event_server;       //!< The pseudo-message event server.
  PseudoMessageEventType M_request_data;                        //!< The request data of the event.

  //! Construct a PseudoMessageOutData object with priority \a priority and message type \a type.
  PseudoMessageOutData(Priority const& priority, msg_type type) : MessageOutData(priority, type) { }

  //! Return true if this is a pseudo message.
  virtual bool is_pseudo_message(void) const { return true; }

  //! Accessor for the request data.
  PseudoMessageEventType const& request_data(void) const { return M_request_data; }
};

//! @brief A pseudo output message.
//
// This class is used to create a MessageOut that isn't a real message
// but that will cause a call back when the MessageOut would be written.
class PseudoMessageOut {
private:
  boost::shared_ptr<PseudoMessageOutData> M_data;       //!< Shared pointer to the actual message data.
public:
  //! Construct a PseudoMessageOut with priority \a priority.
  PseudoMessageOut(Priority const& priority, msg_type type = unsafe_msg) : M_data(NEW(PseudoMessageOutData(priority, type))) { }
  boost::shared_ptr<MessageOutData> data(void) const { return boost::static_pointer_cast<MessageOutData>(M_data); }
  PseudoMessageEventServer& pseudo_message_event_server(void) { return M_data->M_pseudo_message_event_server; }
};

#define writeEventRequest pseudo_message_event_server()

//! @brief An output message.
//
// This size of this class exists of a single boost::shared_ptr.
// A MessageOut object can therefore copied around. It is intended,
// for example, to be put in a priority (output) queue.
class MessageOut {
private:
  boost::shared_ptr<MessageOutData> M_data;     //!< Shared pointer to the actual message data.

public:
  //! Construct a MessageOut object with Priority and Prefix.
  MessageOut(Priority const& priority, msg_type type = unsafe_msg) : M_data(NEW(MessageOutData(priority, type))) { }
  //! Construct a MessageOut object that represents a pseudo message.
  MessageOut(PseudoMessageOut const& pseudo_message_out) : M_data(pseudo_message_out.data()) { }
  //! Copy-constructor.
  MessageOut(MessageOut const& message) : M_data(message.M_data) { }

  //! Write the message to an ostream.
  template<class SESSION>
  void write_to(std::ostream& os, SESSION const& session) const;

  void write_to(ClientSession& session) const;
  void write_to(ServerSession& session) const;

  //! Returns the priority of this message.
  Priority const& priority(void) const { return M_data->M_priority; }

  //! Returns true if this is a pseudo message.
  bool is_pseudo_message(void) const { return M_data->is_pseudo_message(); }

  //! Returns the true if the message can be sent to the server without first logging into X.
  bool is_safe(void) const { return M_data->is_safe(); }

  //! Returns true if the priority of message \a msg1 is less than the priority of message \a msg2.
  friend bool operator<(MessageOut const& msg1, MessageOut const& msg2)
  {
    return msg1.M_data->M_priority < msg2.M_data->M_priority ||
           (msg1.M_data->M_priority == msg2.M_data->M_priority &&
            msg1.M_data->M_sequence_number > msg2.M_data->M_sequence_number);
  }

  friend MessageOut& operator<<(MessageOut& message_out, Prefix const& prefix);
  friend MessageOut& operator<<(MessageOut& message_out, int command);
  friend MessageOut& operator<<(MessageOut& message_out, long number);
  friend MessageOut& operator<<(MessageOut& message_out, std::string const& str);
  friend MessageOut& operator<<(MessageOut& message_out, char c);
  friend MessageOut& operator<<(MessageOut& message_out, boost::shared_ptr<Target> const& target);
  friend MessageOut& operator<<(MessageOut& message_out, MsgPart const& part);
  friend MessageOut& operator<<(MessageOut& message_out, JustInTimeCatenate const& to_be_catenated_token);
  friend MessageOut& operator<<(MessageOut& message_out, JustInTimeLast const& to_be_appended_token);

  // For debugging purposes.
  friend std::ostream& operator<<(std::ostream& os, MessageOut const& message);
};

#endif // MESSAGEOUT_H

---