ircproxy  The Ultimate Cyborg

---

ServerSession.h

Go to the documentation of this file.

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

#ifndef USE_PCH
#include <libcw/sock.h>
#include "debug.h"
#endif

#include "Target.h"
#include "ServerSessionInput.h"
#include "ServerSessionOutput.h"
#include "IdentityReference.h"
#include "Matcher.h"
#include "NickPair.h"
#include "UserMode.h"
#include "AuthState.h"
#include "Queue.h"
#include "PseudoMessageEvent.h"
#include "WhoRequest.h"
#include "ISupport.h"
#include "networks_type.h"
#include "Index.h"

class Server;
class ServerConnection;

/*! @brief A server session, from connect till disconnect.
 *
 * This class represents a server session: from that we successfully
 * connect to a server until the connection is closed or lost again.
 */
class ServerSession : public Index<ServerSession>, public IdentityReference, public sock_dtct<ServerSessionInput, ServerSessionOutput>, public event_client_ct {
  public:
    typedef target_hold_map_type joined_channels_type;                                  //!< The type of M_joined_channels.
    typedef std::map<std::string, boost::shared_ptr<Channel> > join_pipeline_type;      //!< The type of M_join_pipeline.

  private:
    ServerConnection& M_server_connection;              //!< The owning object.
    MatcherEventServer M_message_event_server;          //!< Event server for incoming messages.
    NickPair M_server_session_nicks;                    //!< Server side nick pair.
    joined_channels_type M_joined_channels;             //!< Serverside lookup map for channels joined by this identity.
    UserMode M_user_mode;                               //!< My user mode.
    boost::shared_ptr<AuthState> M_auth_state;          //!< Pointer object with temporary authentication state information.
    Queue M_output_queue;                               //!< Queue for output messages.
    std::queue<WhoRequest> M_who_queue;                 //!< Queue storing WHO request messages.
    ISupport M_i_support;                               //!< Object that stores the numeric 005 information.
    std::string M_network_name;                         //!< Temporary storage of the network name as decoded from numeric 001, until numeric 005 is received.
    static int S_server_sessions;                       //!< Total number of server session objects.
    std::string M_umodes;                               //!< The user modes as received in numeric 004.
    join_pipeline_type M_join_pipeline;                 //!< Channels for which we sent a JOIN as part of a reconnect.
    std::string M_disconnect_reason;                    //!< An error message that should be sent to the client if the connection is lost, if any.

  public:
    Bool M_detected_network;                            //!< True if the network is fully detected.

  public:
    //! Construct a ServerSession instance for identity \a identity and server connection \a server_connection.
    ServerSession(Identity& identity, ServerConnection& server_connection) :
        IdentityReference(&identity), M_server_connection(server_connection),
        M_server_session_nicks(*this), M_output_queue(server_connection, 0.5, 5, 5),
        M_i_support(server_connection)
#ifdef CWDEBUG
      , M_detected_network("M_detected_network")
#endif
        {
          Dout(dc::objects, "Constructing ServerSession(" << identity << ", " << server_connection << ")");
          ++S_server_sessions;
        }
    //! Destructor.
    ~ServerSession();

    //! Called from ServerConnection::do_connect. Takes care of sending PASS/NICK/USER/PONG/MODE.
    void start_authentication(void);

    //! Called from ServerConnection::decode_ping with the argument of the first PING.
    void set_auth_ping_argument(std::string const& auth_ping_argument) { if (M_auth_state.get()) M_auth_state->set_auth_ping_argument(auth_ping_argument); }

    //! Return argument of the first PING.
    std::string const& auth_ping_argument(void) const { ASSERT(M_auth_state.get()); return M_auth_state->auth_ping_argument(); }

    //! Create a new network object with name \a network_name and domain \a domain (if any).
    void construct_network_object(std::string const& network_name, std::string const& domain);

    //! Initialize network. This function is called as soon as the network we are connected to is known.
    void detected_network(networks_type::iterator network_iter);

    //! Called when the authentication was successful (when receiving the 001 numeric).
    void authentication_successful(void);

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

    //! Called when the name of the Network is known (after numeric 005).
    void found_network_name(void);

    //! Return a reference to the event server for incoming messages.
    MatcherEventServer& message_event_server(void) { return M_message_event_server; }
    //! Return a const reference to the event server for incoming messages.
    MatcherEventServer const& message_event_server(void) const { return M_message_event_server; }

    //! Server session nick pair.
    NickPair& nicks(void) { return M_server_session_nicks; }

    //! Server session nick pair.
    NickPair const& nicks(void) const { return M_server_session_nicks; }

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

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

    //! Return my user mode.
    UserMode& user_mode(void) { return M_user_mode; }

    //! Return my user mode.
    UserMode const& user_mode(void) const { return M_user_mode; }

    //! Queue message \a msg.
    void queue_msg(MessageOut const& msg) { DoutEntering(dc::debug, "ServerSession::queue_msg(" << msg << ")"); M_output_queue.queue_msg(msg); }

    //! Queue message \a msg with default priority without changing it.
    void queue_msg_as_is(ClientMessageIn const& msg);

    //! Return the first element of M_who_queue.
    WhoRequest current_who_request(void)
        {
          ASSERT(!M_who_queue.empty());
          Dout(dc::debug, "ServerSession::current_who_request returns " << M_who_queue.front() << ". Number of items: " << M_who_queue.size());
          return M_who_queue.front();
        }

    //! Pop the first element of M_who_queue.
    void pop_who_request(void)
        {
          ASSERT(!M_who_queue.empty());
          M_who_queue.pop();
          Dout(dc::debug, "Calling ServerSession::pop_who_request. Remaining number of items: " << M_who_queue.size());
        }

    //! A write event of a pseudo NICK message happened. Actually write the NICK message.
    void send_nick_write_event(PseudoMessageEventType const&, std::string nick) { nicks().send_nick(nick); }

    //! A write event of a pseudo WHO message happened. Actually write the WHO message.
    void send_who_write_event(PseudoMessageEventType const& event_type, WhoRequest who_request);

    //! Called 1 second after sending a QUIT and the connection still wasn't terminated.
    void force_quit(timer_event_type_ct const& LIBCW_UNUSED_UNLESS_DEBUG(expired_at));

    //! Accessor for M_i_support.
    ISupport const& i_support(void) const { return M_i_support; }

    //! Accessor for M_i_support.
    ISupport& i_support(void) { return M_i_support; }

    //! Return a pointer to the channel in the pipeline, if any. Channel is removed from pipeline.
    boost::shared_ptr<Channel> join_pipeline(std::string const& channel_name);

    //! Set the disconnect reason to \a disconnect_reason.
    void set_disconnect_reason(std::string const& disconnect_reason) { ASSERT(M_disconnect_reason.empty()); M_disconnect_reason = disconnect_reason; }

    //! Accessor for underlying server connection object.
    ServerConnection& server_connection(void) const { return M_server_connection; }

    //! 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 ServerSessionInput.
    virtual void new_message_received(ServerMessageIn const&);

    //! A read(2) on the socket returned 0.
    virtual void network_connection_terminated(void);

  private:
    //! Send a JOIN to the server for every channel we are on.
    void send_rejoins(void);
};

#endif // SERVERSESSION_H

---