packets.hpp

Go to the documentation of this file.

#pragma once
 
#ifdef _WIN32
#include <WinSock2.h>
#else
#include <arpa/inet.h>
#endif
 
#include <cassert>
#include <cstdint>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace tftp_common::packets {
 
struct ParseResult;
 
namespace types {
 
enum Type : std::uint16_t {
    ReadRequest = 0x01,
    WriteRequest = 0x02,
    DataPacket = 0x03,
    AcknowledgmentPacket = 0x04,
    ErrorPacket = 0x05,
    OptionAcknowledgmentPacket = 0x06
};
 
} // namespace types
 
namespace errors {
 
enum Error : std::uint16_t {
    NotDefined = 0,
    FileNotFound = 1,
    AccessViolation = 2,
    DiskFull = 3,
    IllegalOperation = 4,
    UnknownTransferID = 5,
    FileAlreadyExists = 6,
    NoSuchUser = 7
};
 
} // namespace errors
 
namespace modes {
 
enum TransferMode {
    NetAscii,
    Octet
};
 
} // namespace modes
 
class Request final {
  public:
    Request() = default;
    Request(types::Type Type, std::string_view Filename, std::string_view Mode)
        : Type_(Type), Filename(Filename), Mode(Mode) {
        assert(Type == types::ReadRequest || Type == types::WriteRequest);
    }
    Request(types::Type Type, std::string &&Filename, std::string &&Mode) noexcept
        : Type_(Type), Filename(std::move(Filename)), Mode(std::move(Mode)) {
        assert(Type == types::ReadRequest || Type == types::WriteRequest);
    }
    Request(types::Type Type, std::string_view Filename, std::string_view Mode,
            const std::vector<std::string> &OptionsNames, const std::vector<std::string> &OptionsValues)
        : Request(Type, Filename, Mode) {
        this->OptionsNames = OptionsNames;
        this->OptionsValues = OptionsValues;
    }
    Request(types::Type Type, std::string &&Filename, std::string &&Mode, std::vector<std::string> &&OptionsNames,
            std::vector<std::string> &&OptionsValues) noexcept
        : Type_(Type), Filename(std::move(Filename)), Mode(std::move(Mode)), OptionsNames(std::move(OptionsNames)),
          OptionsValues(std::move(OptionsValues)) {
        assert(Type == types::ReadRequest || Type == types::WriteRequest);
    }
 
    template <class OutputIterator> std::size_t serialize(OutputIterator It) const noexcept {
        assert(OptionsNames.size() == OptionsValues.size());
 
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 0);
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 8);
 
        for (auto Byte : Filename) {
            *(It++) = static_cast<std::uint8_t>(Byte);
        }
        *(It++) = '\0';
 
        for (auto Byte : Mode) {
            *(It++) = static_cast<std::uint8_t>(Byte);
        }
        *(It++) = '\0';
 
        std::size_t OptionsSize = 0;
        for (std::size_t Idx = 0; Idx != OptionsNames.size(); ++Idx) {
            for (auto Byte : OptionsNames[Idx]) {
                *(It++) = static_cast<std::uint8_t>(Byte);
            }
            *(It++) = '\0';
            for (auto Byte : OptionsValues[Idx]) {
                *(It++) = static_cast<std::uint8_t>(Byte);
            }
            *(It++) = '\0';
            OptionsSize += OptionsNames[Idx].size() + OptionsValues[Idx].size() + 2;
        }
 
        return sizeof(Type_) + Filename.size() + Mode.size() + OptionsSize + 2;
    }
 
    std::uint16_t getType() const noexcept { return Type_; }
 
    std::string_view getFilename() const noexcept { return std::string_view(Filename.data(), Filename.size()); }
 
    std::string_view getMode() const noexcept { return std::string_view(Mode.data(), Mode.size()); }
 
    std::string_view getOptionName(std::size_t Idx) const noexcept {
        return std::string_view(OptionsNames[Idx].data(), OptionsNames[Idx].size());
    }
 
    std::string_view getOptionValue(std::size_t Idx) const noexcept {
        return std::string_view(OptionsValues[Idx].data(), OptionsValues[Idx].size());
    }
 
  private:
    friend ParseResult parse(const std::uint8_t *Buffer, std::size_t Len, Request &Packet);
 
    std::uint16_t Type_;
    std::string Filename;
    std::string Mode;
    std::vector<std::string> OptionsNames;
    std::vector<std::string> OptionsValues;
};
 
class Data final {
  public:
    Data() = default;
    Data(std::uint16_t Block, const std::vector<std::uint8_t> &Buffer)
        : Block(Block), DataBuffer(Buffer.begin(), Buffer.end()) {
        // The block numbers on data packets begin with one and increase by one for each new block of data
        assert(Block >= 1);
        // The data field is from zero to 512 bytes long
        assert(Buffer.size() >= 0 && Buffer.size() <= 512);
    }
    Data(std::uint16_t Block, std::vector<std::uint8_t> &&Buffer) noexcept : Block(Block) {
        // The block numbers on data packets begin with one and increase by one for each new block of data
        assert(Block >= 1);
        // The data field is from zero to 512 bytes long
        assert(Buffer.size() >= 0 && Buffer.size() <= 512);
        this->DataBuffer = std::move(Buffer);
    }
 
    template <class OutputIterator> std::size_t serialize(OutputIterator It) const noexcept {
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 0);
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 8);
        *(It++) = static_cast<std::uint8_t>(htons(Block) >> 0);
        *(It++) = static_cast<std::uint8_t>(htons(Block) >> 8);
        for (auto Byte : DataBuffer) {
            *(It++) = Byte;
        }
 
        return sizeof(Type_) + sizeof(Block) + DataBuffer.size();
    }
 
    std::uint16_t getType() const noexcept { return Type_; }
 
    std::uint16_t getBlock() const noexcept { return Block; }
 
    const std::vector<std::uint8_t> &getData() const noexcept { return DataBuffer; }
 
  private:
    friend ParseResult parse(const std::uint8_t *Buffer, std::size_t Len, Data &Packet);
 
    std::uint16_t Type_ = types::DataPacket;
    std::uint16_t Block;
    std::vector<std::uint8_t> DataBuffer;
};
 
class Acknowledgment final {
  public:
    Acknowledgment() = default;
    explicit Acknowledgment(std::uint16_t Block) noexcept : Block(Block) {
        // The block numbers on data packets begin with one and increase by one for each new block of data
        assert(Block >= 1);
    }
 
    std::uint16_t getType() const noexcept { return Type_; }
 
    std::uint16_t getBlock() const noexcept { return Block; }
 
    template <class OutputIterator> std::size_t serialize(OutputIterator It) const noexcept {
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 0);
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 8);
        *(It++) = static_cast<std::uint8_t>(htons(Block) >> 0);
        *(It++) = static_cast<std::uint8_t>(htons(Block) >> 8);
 
        return sizeof(Type_) + sizeof(Block);
    }
 
  private:
    friend ParseResult parse(const std::uint8_t *Buffer, std::size_t Len, Acknowledgment &Packet);
 
    std::uint16_t Type_ = types::AcknowledgmentPacket;
    std::uint16_t Block;
};
 
class Error final {
  public:
    Error() = default;
    Error(std::uint16_t ErrorCode, std::string_view ErrorMessage) : ErrorCode(ErrorCode), ErrorMessage(ErrorMessage) {
        assert(ErrorCode >= 0 && ErrorCode <= 8);
    }
    Error(std::uint16_t ErrorCode, std::string &&ErrorMessage)
        : ErrorCode(ErrorCode), ErrorMessage(std::move(ErrorMessage)) {
        assert(ErrorCode >= 0 && ErrorCode <= 8);
    }
 
    std::uint16_t getType() const noexcept { return Type_; }
 
    std::uint16_t getErrorCode() const noexcept { return ErrorCode; }
 
    std::string_view getErrorMessage() const noexcept {
        return std::string_view(ErrorMessage.data(), ErrorMessage.size());
    }
 
    template <class OutputIterator> std::size_t serialize(OutputIterator It) const noexcept {
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 0);
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 8);
        *(It++) = static_cast<std::uint8_t>(htons(ErrorCode) >> 0);
        *(It++) = static_cast<std::uint8_t>(htons(ErrorCode) >> 8);
 
        for (auto Byte : ErrorMessage) {
            *(It++) = Byte;
        }
        *(It++) = '\0';
 
        return sizeof(Type_) + sizeof(ErrorCode) + ErrorMessage.size() + 1;
    }
 
  private:
    friend ParseResult parse(const std::uint8_t *Buffer, std::size_t Len, Error &Packet);
 
    std::uint16_t Type_ = types::ErrorPacket;
    std::uint16_t ErrorCode;
    std::string ErrorMessage;
};
 
class OptionAcknowledgment final {
  public:
    OptionAcknowledgment() = default;
    OptionAcknowledgment(std::unordered_map<std::string, std::string> Options) : Options(std::move(Options)) {}
 
    template <class OutputIterator> std::size_t serialize(OutputIterator It) const noexcept {
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 0);
        *(It++) = static_cast<std::uint8_t>(htons(Type_) >> 8);
 
        std::size_t OptionsSize = 0;
        for (const auto &[Key, Value] : Options) {
            for (auto Byte : Key) {
                *(It++) = static_cast<std::uint8_t>(Byte);
            }
            *(It++) = '\0';
            for (auto Byte : Value) {
                *(It++) = static_cast<std::uint8_t>(Byte);
            }
            *(It++) = '\0';
            OptionsSize += Key.size() + Value.size() + 2;
        }
 
        return sizeof(Type_) + OptionsSize;
    }
 
    std::uint16_t getType() const noexcept { return Type_; }
 
    auto begin() noexcept { return Options.begin(); }
 
    auto begin() const noexcept { return Options.begin(); }
 
    auto cbegin() const noexcept { return Options.cbegin(); }
 
    auto end() noexcept { return Options.end(); }
 
    auto end() const noexcept { return Options.end(); }
 
    auto cend() const noexcept { return Options.cend(); }
 
    std::string_view getOptionValue(const std::string &OptionName) const noexcept { return Options.at(OptionName); }
 
  private:
    friend ParseResult parse(const std::uint8_t *Buffer, std::size_t Len, OptionAcknowledgment &Packet);
 
    std::uint16_t Type_ = types::OptionAcknowledgmentPacket;
    // According to the RFC, the order in which options are specified is not significant, so it's fine
    std::unordered_map<std::string, std::string> Options;
};
 
} // namespace tftp_common::packets