session.hpp

Go to the documentation of this file.

#pragma once
 
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
 
#include <iostream>
#include <boost/asio.hpp>
#include <memory>
#include <array>
#include <queue>
#include <vector>
#include <mutex>
#include <thread>
#include <string>
#include <optional>
 
#include "shared/network/packet.hpp"
#include "shared/utilities/typedefs.hpp"
 
using namespace boost::asio::ip;
 
enum SocketError {
    NONE,
    FATAL,
    RETRY,
};
 
 
struct SessionInfo {
    SessionInfo(std::optional<std::string> client_name,
        std::optional<EntityID> client_eid, std::optional<bool> is_dungeon_master)
        : client_name(client_name), client_eid(client_eid), is_dungeon_master(is_dungeon_master) {}
 
    std::optional<std::string> client_name;
    std::optional<EntityID> client_eid;
    std::optional<bool> is_dungeon_master;
};
 
 
class Session : public std::enable_shared_from_this<Session> {
public:
    Session(tcp::socket socket, SessionInfo info);
    ~Session();
 
    bool isOkay() const;
 
    std::vector<Event> handleAllReceivedPackets();
 
    [[nodiscard("You should check if the connection was successful")]]
        bool connectTo(basic_resolver_results<class boost::asio::ip::tcp> endpoints);
 
    void sendPacket(std::shared_ptr<PackagedPacket> packet);
 
    void sendEvent(Event evt);
 
    const SessionInfo& getInfo() const;
 
    void setDM(bool is_dm);
 
private:
    bool okay;
 
    std::optional<PacketHeader> prev_hdr;
 
    tcp::socket socket;
 
    std::vector<std::shared_ptr<PackagedPacket>> packets_to_send;
 
    std::array<char, NETWORK_BUFFER_SIZE> buffer;
 
    SessionInfo info;
 
    std::optional<Event> _handleReceivedPacket(PacketType type, const std::string& data);
 
    SocketError _classifySocketError(boost::system::error_code ec, const char* where);
 
    bool socketHasEnoughBytes(std::size_t bytes);
};
 
struct SessionEntry {
    SessionEntry(EntityID id, 
        bool is_dungeon_master,
        boost::asio::ip::address ip, 
        std::shared_ptr<Session> session)
        : id(id), is_dungeon_master(is_dungeon_master), ip(ip), session(session) {}
 
    EntityID id;
    bool is_dungeon_master;
    boost::asio::ip::address ip;
    std::shared_ptr<Session> session;
};
 
struct ip_address_hash {
    size_t operator()(const boost::asio::ip::address& v) const { 
        if (v.is_v4())
            return v.to_v4().to_ulong();
        if (v.is_v6()) {
            auto const& range = v.to_v6().to_bytes();
            return boost::hash_range(range.begin(), range.end());
        }
        if (v.is_unspecified()) {
            // guaranteed to be random: chosen by fair dice roll
            return static_cast<size_t>(0x4751301174351161ul); 
        }
        return boost::hash_value(v.to_string());
    }
};
 
// Tag structs to let you index into a Sessions Multi_index map by a name
struct IndexByID {};
// Tag structs to let you index into a Sessions Multi_index map by a name
struct IndexByIP {};
 
using Sessions = boost::multi_index_container<
    SessionEntry,
    boost::multi_index::indexed_by<
        boost::multi_index::hashed_unique<
            boost::multi_index::tag<IndexByID>,
            boost::multi_index::member<SessionEntry, EntityID, &SessionEntry::id>
        >,
        boost::multi_index::hashed_unique<
            boost::multi_index::tag<IndexByIP>,
            boost::multi_index::member<SessionEntry, boost::asio::ip::address, &SessionEntry::ip>,
            ip_address_hash
        >
    >
>;