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(PacketType type, size_t limit) : pos(0), limit(limit), cs(nullptr)
{
  /* Allocate space for the the size so we can write that in just before sending the packet. */
  this->Send_uint16(0);
  this->Send_uint8(type);
}
 
 
void Packet::PrepareToSend()
{
  assert(this->cs == nullptr);
 
  this->buffer[0] = GB(this->Size(), 0, 8);
  this->buffer[1] = GB(this->Size(), 8, 8);
 
  this->pos  = 0; // We start reading from here
  this->buffer.shrink_to_fit();
}
 
bool Packet::CanWriteToPacket(size_t bytes_to_write)
{
  return this->Size() + bytes_to_write <= this->limit;
}
 
/*
 * 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_uint8(uint8_t data)
{
  assert(this->CanWriteToPacket(sizeof(data)));
  this->buffer.emplace_back(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_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_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_string(const 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_buffer(const std::vector<byte> &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());
}
 
size_t Packet::Send_bytes(const byte *begin, const byte *end)
{
  size_t amount = std::min<size_t>(end - begin, this->limit - this->Size());
  this->buffer.insert(this->buffer.end(), begin, begin + amount);
  return amount;
}
 
/*
 * 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::HasPacketSizeData() const
{
  return this->pos >= sizeof(PacketSize);
}
 
size_t Packet::Size() const
{
  return this->buffer.size();
}
 
bool Packet::ParsePacketSize()
{
  assert(this->cs != nullptr);
  size_t size = (size_t)this->buffer[0];
  size       += (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 < sizeof(PacketSize) + sizeof(PacketType) || size > this->limit) return false;
 
  this->buffer.resize(size);
  this->pos = sizeof(PacketSize);
  return true;
}
 
void Packet::PrepareToRead()
{
  /* Put the position on the right place */
  this->pos = sizeof(PacketSize);
}
 
PacketType Packet::GetPacketType() const
{
  assert(this->Size() >= sizeof(PacketSize) + sizeof(PacketType));
  return static_cast<PacketType>(buffer[sizeof(PacketSize)]);
}
 
bool Packet::Recv_bool()
{
  return this->Recv_uint8() != 0;
}
 
uint8_t Packet::Recv_uint8()
{
  uint8_t n;
 
  if (!this->CanReadFromPacket(sizeof(n), true)) return 0;
 
  n = this->buffer[this->pos++];
  return n;
}
 
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;
}
 
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;
}
 
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;
}
 
std::vector<byte> Packet::Recv_buffer()
{
  uint16_t size = this->Recv_uint16();
  if (size == 0 || !this->CanReadFromPacket(size, true)) return {};
 
  std::vector<byte> data;
  while (size-- > 0) {
    data.push_back(this->buffer[this->pos++]);
  }
 
  return data;
}
 
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);
}
 
size_t Packet::RemainingBytesToTransfer() const
{
  return this->Size() - this->pos;
}