stream.h

Go to the documentation of this file.

 
#ifndef MINESERVER_STREAM_H
#define MINESERVER_STREAM_H
 
#include <cstdint>
#include <cstddef>
#include <string>
#include <vector>
#include <utils/network.h>
#include <types/chatmessage.h>
#include <types/uuid.h>
#include <utils/crypto.h>
 
class IMCStream
{
public:
    virtual ~IMCStream() = default;
 
    virtual void read(std::byte *buffer, std::size_t offset, std::size_t len) = 0;
    virtual void write(const std::byte *buffer, std::size_t offset, std::size_t len) = 0;
    virtual void flush() = 0;
    virtual size_t available() = 0;
 
    virtual void finishPacketWrite(const std::byte *packetData, size_t len) = 0;
 
    bool readBoolean();
    void writeBoolean(bool b);
 
    std::int8_t readByte();
    void writeByte(std::int8_t b);
 
    std::uint8_t readUnsignedByte();
    void writeUnsignedByte(std::uint8_t b);
 
    std::int16_t readShort();
    void writeShort(std::int16_t s);
 
    std::uint16_t readUnsignedShort();
    void writeUnsignedShort(std::uint16_t s);
 
    std::int32_t readInt();
    void writeInt(std::int32_t i);
 
    std::int64_t readLong();
    void writeLong(std::int64_t l);
 
    float readFloat();
    void writeFloat(float f);
 
    double readDouble();
    void writeDouble(double d);
 
    std::string readString();
    void writeString(const std::string &s);
 
    ChatMessage readChat();
    void writeChat(const ChatMessage &c);
 
    std::int32_t readVarInt();
    void writeVarInt(std::int32_t i);
 
    std::int64_t readVarLong();
    void writeVarLong(std::int64_t l);
 
    MinecraftUUID readUUID();
    void writeUUID(const MinecraftUUID &uuid);
};
 
class MemoryStream : public IMCStream
{
private:
    std::vector<std::byte> data;
    std::uint32_t readIndex{};
 
public:
    MemoryStream() = default;
    ~MemoryStream() override = default;
 
    void read(std::byte *buffer, std::size_t offset, std::size_t len) override;
    void write(const std::byte *buffer, std::size_t offset, std::size_t len) override;
    void flush() override;
    size_t available() override;
 
    void finishPacketWrite(const std::byte *packetData, size_t len) override;
 
    void clear();
    const std::vector<std::byte> &getData() const;
};
 
class NetSocketStream : public IMCStream
{
private:
    ClientSocket socket;
 
public:
    NetSocketStream(const ClientSocket& socket);
    ~NetSocketStream();
 
    void read(std::byte *buffer, std::size_t offset, std::size_t len) override;
    void write(const std::byte *buffer, std::size_t offset, std::size_t len) override;
    size_t available() override;
 
    void finishPacketWrite(const std::byte *packetData, size_t len) override;
 
    void flush() override;
};
 
class CipherStream : public IMCStream
{
private:
    IMCStream *baseStream;
    crypto::AES128CFB8Cipher encipher;
    crypto::AES128CFB8Cipher decipher;
 
public:
    CipherStream(IMCStream *baseStream, std::byte *key, std::byte *iv);
    ~CipherStream();
 
    void read(std::byte *buffer, std::size_t offset, std::size_t len) override;
    void write(const std::byte *buffer, std::size_t offset, std::size_t len) override;
    size_t available() override;
 
    void finishPacketWrite(const std::byte *packetData, size_t len) override;
 
    void flush() override;
};
 
class ZLibStream : public IMCStream
{
private:
    IMCStream *baseStream;
    crypto::ZLibCompressor comp;
 
    std::vector<std::byte> inBuffer{};
    std::uint32_t inIndex{};
 
    std::vector<std::byte> outBuffer{};
    int threshold;
 
public:
    ZLibStream(IMCStream *baseStream, int level, int threshold);
    ~ZLibStream();
 
    void read(std::byte *buffer, std::size_t offset, std::size_t len) override;
    void write(const std::byte *buffer, std::size_t offset, std::size_t len) override;
    size_t available() override;
 
    void finishPacketWrite(const std::byte *packetData, size_t len) override;
 
    void flush() override;
};
 
#endif // MINESERVER_STREAM_H