packet.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef NETWORK_CORE_PACKET_H
#define NETWORK_CORE_PACKET_H
 
#include "os_abstraction.h"
#include "config.h"
#include "core.h"
#include "../../core/convertible_through_base.hpp"
#include "../../string_type.h"
 
typedef uint16_t PacketSize; 
typedef uint8_t  PacketType; 
 
struct Packet {
  static constexpr size_t EncodedLengthOfPacketSize() { return sizeof(PacketSize); }
  static constexpr size_t EncodedLengthOfPacketType() { return sizeof(PacketType); }
private:
  PacketSize pos;
  std::vector<uint8_t> buffer;
  size_t limit;
 
  NetworkSocketHandler *cs;
 
public:
  Packet(NetworkSocketHandler *cs, size_t limit, size_t initial_read_size = EncodedLengthOfPacketSize());
  Packet(NetworkSocketHandler *cs, PacketType type, size_t limit = COMPAT_MTU);
 
  /* Sending/writing of packets */
  void PrepareToSend();
 
  bool   CanWriteToPacket(size_t bytes_to_write);
  void   Send_bool  (bool   data);
  void   Send_uint8 (uint8_t  data);
  void   Send_uint8 (const ConvertibleThroughBase auto &data) { this->Send_uint8(data.base()); }
  void   Send_uint16(uint16_t data);
  void   Send_uint32(uint32_t data);
  void   Send_uint64(uint64_t data);
  void   Send_string(std::string_view data);
  void   Send_buffer(const std::vector<uint8_t> &data);
  std::span<const uint8_t> Send_bytes(const std::span<const uint8_t> span);
 
  /* Reading/receiving of packets */
  bool HasPacketSizeData() const;
  bool ParsePacketSize();
  size_t Size() const;
  [[nodiscard]] bool PrepareToRead();
  PacketType GetPacketType() const;
 
  bool   CanReadFromPacket(size_t bytes_to_read, bool close_connection = false);
  bool   Recv_bool  ();
  uint8_t  Recv_uint8 ();
  uint16_t Recv_uint16();
  uint32_t Recv_uint32();
  uint64_t Recv_uint64();
  std::vector<uint8_t> Recv_buffer();
  size_t Recv_bytes(std::span<uint8_t> span);
  std::string Recv_string(size_t length, StringValidationSettings settings = StringValidationSetting::ReplaceWithQuestionMark);
 
  size_t RemainingBytesToTransfer() const;
 
  template <typename F>
  ssize_t TransferOutWithLimit(F transfer_function, size_t limit)
  {
    size_t amount = std::min(this->RemainingBytesToTransfer(), limit);
    if (amount == 0) return 0;
 
    assert(this->pos < this->buffer.size());
    assert(this->pos + amount <= this->buffer.size());
    auto output_buffer = std::span<const uint8_t>(this->buffer.data() + this->pos, amount);
    ssize_t bytes = transfer_function(output_buffer);
    if (bytes > 0) this->pos += bytes;
    return bytes;
  }
  ssize_t TransferOutWithLimit(F transfer_function, size_t limit) {…}
 
  template <typename F>
  ssize_t TransferOut(F transfer_function)
  {
    return TransferOutWithLimit(transfer_function, std::numeric_limits<size_t>::max());
  }
  ssize_t TransferOut(F transfer_function) {…}
 
  template <typename F>
  ssize_t TransferIn(F transfer_function)
  {
    size_t amount = this->RemainingBytesToTransfer();
    if (amount == 0) return 0;
 
    assert(this->pos < this->buffer.size());
    assert(this->pos + amount <= this->buffer.size());
    auto input_buffer = std::span<uint8_t>(this->buffer.data() + this->pos, amount);
    ssize_t bytes = transfer_function(input_buffer);
    if (bytes > 0) this->pos += bytes;
    return bytes;
  }
  ssize_t TransferIn(F transfer_function) {…}
};
struct Packet {…};
 
#endif /* NETWORK_CORE_PACKET_H */