ircproxy  The Ultimate Cyborg

---

ClientSession.h

Go to the documentation of this file.

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

#ifndef USE_PCH
#include <libcw/sock.h>
#include <boost/shared_ptr.hpp>
#include <string>
#include <deque>
#include <map>
#include "debug.h"
#include <libcw/events.h>
#endif

#include "IdentityReference.h"
#include "ClientSessionInput.h"
#include "ClientSessionOutput.h"
#include "UserAnswer.h"
#include "DestructEvent.h"
#include "Nick.h"
#include "Index.h"

class MessageIn;

/*! @brief A client session, from connect till disconnect.
 *
 * This class represents a client session: from that a client successfully
 * connects to the application's listen socket, until the connection is
 * closed or lost again.
 */
class ClientSession : public Index<ClientSession>, public IdentityReference, public sock_dtct<ClientSessionInput, ClientSessionOutput>,
    public virtual event_client_ct {
public:
  //! The type of the map with the private targets that the client has joined.
  typedef std::map<std::string, boost::shared_ptr<Target>, IRC_less> private_targets_type;
  //! The type of M_joined_channels.
  typedef target_hold_map_type joined_channels_type;

private:
  std::string M_in_nick;                        //!< The last NICK as received from the client in this session.
  bool M_queue_messages;                        //!< Set if messages need to be queued instead of processed.
  std::deque<ClientMessageIn> M_msg_queue;      //!< The message queue.
  bool M_first_nick;                            //!< Set before the first NICK message is received from the client.
  private_targets_type M_private_targets;       //!< Map with private targets that the client has joined.
  joined_channels_type M_joined_channels;       //!< Clientside lookup map for channels joined by this identity.

public:
  UserAnswerEventServer user_answer_event_server;       //!< The UserAnswer event server.
  DestructEventServer destruct_event_server;            //!< The DestructEvent event server.

public:
  //! Default constructor.
  ClientSession(void) : event_client_ct(), M_queue_messages(false), M_first_nick(true)
      { Dout(dc::objects, "Constructing ClientSession() " << *this); }
  //! Destructor.
  ~ClientSession();

public:
  //! A fatal error occured. Calling this function will terminate the ClientSession.
  void fatal_error(char const* error_msg);

  //! Called from Identity::new_client_message_received for NICK messages.
  void new_client_nick_received(std::string const& nick);

  //! Returns the last NICK as received from the client in this session.
  std::string const& client_in_nick(void) const { return M_in_nick; }

  //! FIXME
  std::string const& client_out_nick(void) const { return M_in_nick; }

  //! Decode message \a msg.
  void process_message(ClientMessageIn const& msg);

  //! Queue message \a msg.
  void queue_message(ClientMessageIn const& msg);

  //! Start queuing messages.
  void start_queuing_messages(void);

  //! Stop queuing messages.
  void stop_queuing_messages(DestructEventType const&);

  void add_private_target(boost::shared_ptr<Target> const& target);
  void del_private_target(std::string const& target_name);

  //! Return reference to map with private targets.
  private_targets_type& private_targets(void) { return M_private_targets; }

  //! Return const reference to map with private targets.
  private_targets_type const& private_targets(void) const { return M_private_targets; }

  //! Return reference to map with known channels.
  joined_channels_type& joined_channels(void) { return M_joined_channels; }

  //! Return const reference to map with known channels.
  joined_channels_type const& joined_channels(void) const { return M_joined_channels; }

  //! Check if target already exists, if not, create it and add it to our private targets map.
  void create_private_target(std::string const& target_name, Network& network);

  //! Send an output message to this session.
  void queue_msg(MessageOut const& msgout);

  //! Pass message \a msg on to the client with default priority, without changing anything.
  void queue_msg_as_is(ServerMessageIn const& msg);

  //! Pass message \a msg on to the client with default priority, changing only the target: my nick.
  void queue_msg_me_as_is(ServerMessageIn const& msg);

  //! This function is called from ServerSession::session_lost().
  void serversession_lost(void);

  //! Get or create a Nick for \a nick_name.
  boost::shared_ptr<Nick> get_nick(std::string const& nick_name, bool create = false);

protected:
  //! Incoming event from ClientSessionInput.
  virtual void new_message_received(ClientMessageIn const&);
};

#endif // CLIENTSESSION_H

---