message.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <memory>
#include <optional>
#include <vector>
 
#include "download/bitfield.hpp"
#include "torrent.hpp"
#include "util/result.hpp"
 
using namespace fur::util;
using namespace fur::download::bitfield;
 
namespace fur::download::message {
enum class MessageKind {
  KeepAlive,
  Choke,
  Unchoke,
  Interested,
  NotInterested,
  Have,
  Bitfield,
  Request,
  Piece,
};
 
enum class DecodeError {
  UnexpectedPayload,
  InvalidHeader,
  UnknownMessageID,
  InvalidPayloadLength,
};
 
std::string display_decode_error(const DecodeError& err);
 
class Message {
 public:
  virtual ~Message() = default;
  [[nodiscard]] virtual std::vector<uint8_t> encode() const;
 
  [[nodiscard]] static Result<std::unique_ptr<Message>, DecodeError> decode(
      const TorrentFile& torrent, const std::vector<uint8_t>& buf);
 
  [[nodiscard]] virtual MessageKind kind() const = 0;
 
 private:
  [[nodiscard]] virtual uint8_t message_id() const = 0;
  [[nodiscard]] virtual std::vector<uint8_t> encode_payload() const = 0;
};
 
class KeepAliveMessage final : public Message {
 public:
  [[nodiscard]] std::vector<uint8_t> encode() const override {
    return {0, 0, 0, 0};
  }
 
  [[nodiscard]] MessageKind kind() const override {
    return MessageKind::KeepAlive;
  }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 0; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override {
    return {};
  }
};
 
class ChokeMessage final : public Message {
 public:
  [[nodiscard]] MessageKind kind() const override { return MessageKind::Choke; }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 0; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override {
    return {};
  }
};
 
class UnchokeMessage final : public Message {
 public:
  [[nodiscard]] MessageKind kind() const override {
    return MessageKind::Unchoke;
  }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 1; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override {
    return {};
  }
};
 
class InterestedMessage final : public Message {
 public:
  [[nodiscard]] MessageKind kind() const override {
    return MessageKind::Interested;
  }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 2; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override {
    return {};
  }
};
 
class NotInterestedMessage final : public Message {
 public:
  [[nodiscard]] MessageKind kind() const override {
    return MessageKind::NotInterested;
  }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 3; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override {
    return {};
  }
};
 
class HaveMessage final : public Message {
 public:
  const int64_t index;
 
  explicit HaveMessage(int64_t index) : index{index} {}
 
  [[nodiscard]] static Result<std::unique_ptr<HaveMessage>, DecodeError> decode(
      const std::vector<uint8_t>& buf);
 
  [[nodiscard]] MessageKind kind() const override { return MessageKind::Have; }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 4; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override;
};
 
class BitfieldMessage final : public Message {
 public:
  const Bitfield bitfield;
 
  explicit BitfieldMessage(Bitfield bitfield) : bitfield{std::move(bitfield)} {}
 
  [[nodiscard]] static std::unique_ptr<BitfieldMessage> decode(
      const TorrentFile& torrent, const std::vector<uint8_t>& buf);
 
  [[nodiscard]] MessageKind kind() const override {
    return MessageKind::Bitfield;
  }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 5; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override;
};
 
class RequestMessage final : public Message {
 public:
  const int64_t index;
  const int64_t begin;
  const int64_t length;
 
  RequestMessage(int64_t index, int64_t begin, int64_t length)
      : index{index}, begin{begin}, length{length} {}
 
  [[nodiscard]] static Result<std::unique_ptr<RequestMessage>, DecodeError>
  decode(const std::vector<uint8_t>& buf);
 
  [[nodiscard]] MessageKind kind() const override {
    return MessageKind::Request;
  }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 6; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override;
};
 
class PieceMessage final : public Message {
 public:
  const int64_t index;
  const int64_t begin;
  const std::vector<uint8_t> block;
 
  PieceMessage(int64_t index, int64_t begin, std::vector<uint8_t> block)
      : index{index}, begin{begin}, block{std::move(block)} {}
 
  [[nodiscard]] static Result<std::unique_ptr<PieceMessage>, DecodeError>
  decode(const std::vector<uint8_t>& buf);
 
  [[nodiscard]] MessageKind kind() const override { return MessageKind::Piece; }
 
 private:
  [[nodiscard]] uint8_t message_id() const override { return 7; }
  [[nodiscard]] std::vector<uint8_t> encode_payload() const override;
};
 
// WARN: BitTorrent specifies a CancelMessage with ID 8, but we don't expect to
//  ever send or receive it
 
// WARN: BitTorrent specifies a PortMessage with ID 9, but we don't expect to
//  ever send or receive it
}  // namespace fur::download::message