tcp.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 "../../debug.h"
 
#include "tcp.h"
 
#include "../../safeguards.h"
 
NetworkTCPSocketHandler::NetworkTCPSocketHandler(SOCKET s) :
    NetworkSocketHandler(),
    sock(s), writable(false)
{
}
 
NetworkTCPSocketHandler::~NetworkTCPSocketHandler()
{
  this->CloseSocket();
}
 
void NetworkTCPSocketHandler::CloseSocket()
{
  if (this->sock != INVALID_SOCKET) closesocket(this->sock);
  this->sock = INVALID_SOCKET;
}
 
NetworkRecvStatus NetworkTCPSocketHandler::CloseConnection([[maybe_unused]] bool error)
{
  this->MarkClosed();
  this->writable = false;
 
  this->packet_queue.clear();
  this->packet_recv = nullptr;
 
  return NETWORK_RECV_STATUS_OKAY;
}
 
void NetworkTCPSocketHandler::SendPacket(std::unique_ptr<Packet> &&packet)
{
  assert(packet != nullptr);
 
  packet->PrepareToSend();
  this->packet_queue.push_back(std::move(packet));
}
 
SendPacketsState NetworkTCPSocketHandler::SendPackets(bool closing_down)
{
  /* We can not write to this socket!! */
  if (!this->writable) return SPS_NONE_SENT;
  if (!this->IsConnected()) return SPS_CLOSED;
 
  while (!this->packet_queue.empty()) {
    Packet &p = *this->packet_queue.front();
    ssize_t res = p.TransferOut<int>(send, this->sock, 0);
    if (res == -1) {
      NetworkError err = NetworkError::GetLast();
      if (!err.WouldBlock()) {
        /* Something went wrong.. close client! */
        if (!closing_down) {
          Debug(net, 0, "Send failed: {}", err.AsString());
          this->CloseConnection();
        }
        return SPS_CLOSED;
      }
      return SPS_PARTLY_SENT;
    }
    if (res == 0) {
      /* Client/server has left us :( */
      if (!closing_down) this->CloseConnection();
      return SPS_CLOSED;
    }
 
    /* Is this packet sent? */
    if (p.RemainingBytesToTransfer() == 0) {
      /* Go to the next packet */
      this->packet_queue.pop_front();
    } else {
      return SPS_PARTLY_SENT;
    }
  }
 
  return SPS_ALL_SENT;
}
 
std::unique_ptr<Packet> NetworkTCPSocketHandler::ReceivePacket()
{
  ssize_t res;
 
  if (!this->IsConnected()) return nullptr;
 
  if (this->packet_recv == nullptr) {
    this->packet_recv = std::make_unique<Packet>(this, TCP_MTU);
  }
 
  Packet &p = *this->packet_recv.get();
 
  /* Read packet size */
  if (!p.HasPacketSizeData()) {
    while (p.RemainingBytesToTransfer() != 0) {
      res = p.TransferIn<int>(recv, this->sock, 0);
      if (res == -1) {
        NetworkError err = NetworkError::GetLast();
        if (!err.WouldBlock()) {
          /* Something went wrong... */
          if (!err.IsConnectionReset()) Debug(net, 0, "Recv failed: {}", err.AsString());
          this->CloseConnection();
          return nullptr;
        }
        /* Connection would block, so stop for now */
        return nullptr;
      }
      if (res == 0) {
        /* Client/server has left */
        this->CloseConnection();
        return nullptr;
      }
    }
 
    /* Parse the size in the received packet and if not valid, close the connection. */
    if (!p.ParsePacketSize()) {
      this->CloseConnection();
      return nullptr;
    }
  }
 
  /* Read rest of packet */
  while (p.RemainingBytesToTransfer() != 0) {
    res = p.TransferIn<int>(recv, this->sock, 0);
    if (res == -1) {
      NetworkError err = NetworkError::GetLast();
      if (!err.WouldBlock()) {
        /* Something went wrong... */
        if (!err.IsConnectionReset()) Debug(net, 0, "Recv failed: {}", err.AsString());
        this->CloseConnection();
        return nullptr;
      }
      /* Connection would block */
      return nullptr;
    }
    if (res == 0) {
      /* Client/server has left */
      this->CloseConnection();
      return nullptr;
    }
  }
 
  if (!p.PrepareToRead()) {
    Debug(net, 0, "Invalid packet received (too small / decryption error)");
    this->CloseConnection();
    return nullptr;
  }
  return std::move(this->packet_recv);
}
 
bool NetworkTCPSocketHandler::CanSendReceive()
{
  assert(this->sock != INVALID_SOCKET);
 
  fd_set read_fd, write_fd;
  struct timeval tv;
 
  FD_ZERO(&read_fd);
  FD_ZERO(&write_fd);
 
  FD_SET(this->sock, &read_fd);
  FD_SET(this->sock, &write_fd);
 
  tv.tv_sec = tv.tv_usec = 0; // don't block at all.
  if (select(FD_SETSIZE, &read_fd, &write_fd, nullptr, &tv) < 0) return false;
 
  this->writable = !!FD_ISSET(this->sock, &write_fd);
  return FD_ISSET(this->sock, &read_fd) != 0;
}