packet.cpp

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/>.
 */
 
#include "../../stdafx.h"
#include "../../string_func.h"
 
#include "packet.h"
 
#include "../../safeguards.h"
 
Packet::Packet(NetworkSocketHandler *cs, size_t limit, size_t initial_read_size) : pos(0), limit(limit)
{
  assert(cs != nullptr);
 
  this->cs = cs;
  this->buffer.resize(initial_read_size);
}
Packet::Packet(NetworkSocketHandler *cs, size_t limit, size_t initial_read_size) : pos(0), limit(limit) {…}
 
Packet::Packet(NetworkSocketHandler *cs, PacketType type, size_t limit) : pos(0), limit(limit), cs(cs)
{
  /* Allocate space for the the size so we can write that in just before sending the packet. */
  size_t size = EncodedLengthOfPacketSize();
  if (cs != nullptr && cs->send_encryption_handler != nullptr) {
    /* Allocate some space for the message authentication code of the encryption. */
    size += cs->send_encryption_handler->MACSize();
  }
  assert(this->CanWriteToPacket(size));
  this->buffer.resize(size, 0);
 
  this->Send_uint8(type);
}
Packet::Packet(NetworkSocketHandler *cs, PacketType type, size_t limit) : pos(0), limit(limit), cs(cs) {…}
 
 
void Packet::PrepareToSend()
{
  /* Prevent this to be called twice and for packets that have been received. */
  assert(this->buffer[0] == 0 && this->buffer[1] == 0);
 
  this->buffer[0] = GB(this->Size(), 0, 8);
  this->buffer[1] = GB(this->Size(), 8, 8);
 
  if (cs != nullptr && cs->send_encryption_handler != nullptr) {
    size_t offset = EncodedLengthOfPacketSize();
    size_t mac_size = cs->send_encryption_handler->MACSize();
    size_t message_offset = offset + mac_size;
    cs->send_encryption_handler->Encrypt(std::span(&this->buffer[offset], mac_size), std::span(&this->buffer[message_offset], this->buffer.size() - message_offset));
  }
 
  this->pos  = 0; // We start reading from here
  this->buffer.shrink_to_fit();
}
void Packet::PrepareToSend() {…}
 
bool Packet::CanWriteToPacket(size_t bytes_to_write)
{
  return this->Size() + bytes_to_write <= this->limit;
}
bool Packet::CanWriteToPacket(size_t bytes_to_write) {…}
 
/*
 * The next couple of functions make sure we can send
 *  uint8_t, uint16_t, uint32_t and uint64_t endian-safe
 *  over the network. The least significant bytes are
 *  sent first.
 *
 *  So 0x01234567 would be sent as 67 45 23 01.
 *
 * A bool is sent as a uint8_t where zero means false
 *  and non-zero means true.
 */
 
void Packet::Send_bool(bool data)
{
  this->Send_uint8(data ? 1 : 0);
}
void Packet::Send_bool(bool data) {…}
 
void Packet::Send_uint8(uint8_t data)
{
  assert(this->CanWriteToPacket(sizeof(data)));
  this->buffer.emplace_back(data);
}
void Packet::Send_uint8(uint8_t data) {…}
 
void Packet::Send_uint16(uint16_t data)
{
  assert(this->CanWriteToPacket(sizeof(data)));
  this->buffer.emplace_back(GB(data, 0, 8));
  this->buffer.emplace_back(GB(data, 8, 8));
}
void Packet::Send_uint16(uint16_t data) {…}
 
void Packet::Send_uint32(uint32_t data)
{
  assert(this->CanWriteToPacket(sizeof(data)));
  this->buffer.emplace_back(GB(data,  0, 8));
  this->buffer.emplace_back(GB(data,  8, 8));
  this->buffer.emplace_back(GB(data, 16, 8));
  this->buffer.emplace_back(GB(data, 24, 8));
}
void Packet::Send_uint32(uint32_t data) {…}
 
void Packet::Send_uint64(uint64_t data)
{
  assert(this->CanWriteToPacket(sizeof(data)));
  this->buffer.emplace_back(GB(data,  0, 8));
  this->buffer.emplace_back(GB(data,  8, 8));
  this->buffer.emplace_back(GB(data, 16, 8));
  this->buffer.emplace_back(GB(data, 24, 8));
  this->buffer.emplace_back(GB(data, 32, 8));
  this->buffer.emplace_back(GB(data, 40, 8));
  this->buffer.emplace_back(GB(data, 48, 8));
  this->buffer.emplace_back(GB(data, 56, 8));
}
void Packet::Send_uint64(uint64_t data) {…}
 
void Packet::Send_string(std::string_view data)
{
  assert(this->CanWriteToPacket(data.size() + 1));
  this->buffer.insert(this->buffer.end(), data.begin(), data.end());
  this->buffer.emplace_back('\0');
}
void Packet::Send_string(std::string_view data) {…}
 
void Packet::Send_buffer(const std::vector<uint8_t> &data)
{
  assert(this->CanWriteToPacket(sizeof(uint16_t) + data.size()));
  this->Send_uint16((uint16_t)data.size());
  this->buffer.insert(this->buffer.end(), data.begin(), data.end());
}
void Packet::Send_buffer(const std::vector<uint8_t> &data) {…}
 
std::span<const uint8_t> Packet::Send_bytes(const std::span<const uint8_t> span)
{
  size_t amount = std::min<size_t>(span.size(), this->limit - this->Size());
  this->buffer.insert(this->buffer.end(), span.data(), span.data() + amount);
  return span.subspan(amount);
}
std::span<const uint8_t> Packet::Send_bytes(const std::span<const uint8_t> span) {…}
 
/*
 * Receiving commands
 * Again, the next couple of functions are endian-safe
 *  see the comment before Send_bool for more info.
 */
 
 
bool Packet::CanReadFromPacket(size_t bytes_to_read, bool close_connection)
{
  /* Don't allow reading from a quit client/client who send bad data */
  if (this->cs->HasClientQuit()) return false;
 
  /* Check if variable is within packet-size */
  if (this->pos + bytes_to_read > this->Size()) {
    if (close_connection) this->cs->NetworkSocketHandler::MarkClosed();
    return false;
  }
 
  return true;
}
bool Packet::CanReadFromPacket(size_t bytes_to_read, bool close_connection) {…}
 
bool Packet::HasPacketSizeData() const
{
  return this->pos >= EncodedLengthOfPacketSize();
}
bool Packet::HasPacketSizeData() const {…}
 
size_t Packet::Size() const
{
  return this->buffer.size();
}
size_t Packet::Size() const {…}
 
bool Packet::ParsePacketSize()
{
  size_t size = static_cast<size_t>(this->buffer[0]);
  size       += static_cast<size_t>(this->buffer[1]) << 8;
 
  /* If the size of the packet is less than the bytes required for the size and type of
   * the packet, or more than the allowed limit, then something is wrong with the packet.
   * In those cases the packet can generally be regarded as containing garbage data. */
  if (size < EncodedLengthOfPacketSize() + EncodedLengthOfPacketType() || size > this->limit) return false;
 
  this->buffer.resize(size);
  this->pos = static_cast<PacketSize>(EncodedLengthOfPacketSize());
  return true;
}
bool Packet::ParsePacketSize() {…}
 
bool Packet::PrepareToRead()
{
  /* Put the position on the right place */
  this->pos = static_cast<PacketSize>(EncodedLengthOfPacketSize());
 
  if (cs == nullptr || cs->receive_encryption_handler == nullptr) return true;
 
  size_t mac_size = cs->receive_encryption_handler->MACSize();
  if (this->buffer.size() <= pos + mac_size) return false;
 
  bool valid = cs->receive_encryption_handler->Decrypt(std::span(&this->buffer[pos], mac_size), std::span(&this->buffer[pos + mac_size], this->buffer.size() - pos - mac_size));
  this->pos += static_cast<PacketSize>(mac_size);
  return valid;
}
bool Packet::PrepareToRead() {…}
 
PacketType Packet::GetPacketType() const
{
  assert(this->Size() >= EncodedLengthOfPacketSize() + EncodedLengthOfPacketType());
  size_t offset = EncodedLengthOfPacketSize();
  if (cs != nullptr && cs->send_encryption_handler != nullptr) offset += cs->send_encryption_handler->MACSize();
  return static_cast<PacketType>(buffer[offset]);
}
PacketType Packet::GetPacketType() const {…}
 
bool Packet::Recv_bool()
{
  return this->Recv_uint8() != 0;
}
bool Packet::Recv_bool() {…}
 
uint8_t Packet::Recv_uint8()
{
  uint8_t n;
 
  if (!this->CanReadFromPacket(sizeof(n), true)) return 0;
 
  n = this->buffer[this->pos++];
  return n;
}
uint8_t Packet::Recv_uint8() {…}
 
uint16_t Packet::Recv_uint16()
{
  uint16_t n;
 
  if (!this->CanReadFromPacket(sizeof(n), true)) return 0;
 
  n  = (uint16_t)this->buffer[this->pos++];
  n += (uint16_t)this->buffer[this->pos++] << 8;
  return n;
}
uint16_t Packet::Recv_uint16() {…}
 
uint32_t Packet::Recv_uint32()
{
  uint32_t n;
 
  if (!this->CanReadFromPacket(sizeof(n), true)) return 0;
 
  n  = (uint32_t)this->buffer[this->pos++];
  n += (uint32_t)this->buffer[this->pos++] << 8;
  n += (uint32_t)this->buffer[this->pos++] << 16;
  n += (uint32_t)this->buffer[this->pos++] << 24;
  return n;
}
uint32_t Packet::Recv_uint32() {…}
 
uint64_t Packet::Recv_uint64()
{
  uint64_t n;
 
  if (!this->CanReadFromPacket(sizeof(n), true)) return 0;
 
  n  = (uint64_t)this->buffer[this->pos++];
  n += (uint64_t)this->buffer[this->pos++] << 8;
  n += (uint64_t)this->buffer[this->pos++] << 16;
  n += (uint64_t)this->buffer[this->pos++] << 24;
  n += (uint64_t)this->buffer[this->pos++] << 32;
  n += (uint64_t)this->buffer[this->pos++] << 40;
  n += (uint64_t)this->buffer[this->pos++] << 48;
  n += (uint64_t)this->buffer[this->pos++] << 56;
  return n;
}
uint64_t Packet::Recv_uint64() {…}
 
std::vector<uint8_t> Packet::Recv_buffer()
{
  uint16_t size = this->Recv_uint16();
  if (size == 0 || !this->CanReadFromPacket(size, true)) return {};
 
  std::vector<uint8_t> data;
  while (size-- > 0) {
    data.push_back(this->buffer[this->pos++]);
  }
 
  return data;
}
std::vector<uint8_t> Packet::Recv_buffer() {…}
 
size_t Packet::Recv_bytes(std::span<uint8_t> destination)
{
  auto transfer_to_span = [&destination](std::span<const uint8_t> source) {
    auto to_copy = source.subspan(0, destination.size());
    std::ranges::copy(to_copy, destination.begin());
    return to_copy.size();
  };
 
  return this->TransferOut(transfer_to_span);
}
size_t Packet::Recv_bytes(std::span<uint8_t> destination) {…}
 
std::string Packet::Recv_string(size_t length, StringValidationSettings settings)
{
  assert(length > 1);
 
  /* Both loops with Recv_uint8 terminate when reading past the end of the
   * packet as Recv_uint8 then closes the connection and returns 0. */
  std::string str;
  char character;
  while (--length > 0 && (character = this->Recv_uint8()) != '\0') str.push_back(character);
 
  if (length == 0) {
    /* The string in the packet was longer. Read until the termination. */
    while (this->Recv_uint8() != '\0') {}
  }
 
  return StrMakeValid(str, settings);
}
std::string Packet::Recv_string(size_t length, StringValidationSettings settings) {…}
 
size_t Packet::RemainingBytesToTransfer() const
{
  return this->Size() - this->pos;
}
size_t Packet::RemainingBytesToTransfer() const {…}