os_abstraction.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 "os_abstraction.h"
#include "../../string_func.h"
#include "../../3rdparty/fmt/format.h"
#include <mutex>
 
#include "../../safeguards.h"
 
NetworkError::NetworkError(int error) : error(error)
{
}
 
bool NetworkError::WouldBlock() const
{
#if defined(_WIN32)
  return this->error == WSAEWOULDBLOCK;
#else
  /* Usually EWOULDBLOCK and EAGAIN are the same, but sometimes they are not
   * and the POSIX.1 specification states that either should be checked. */
  return this->error == EWOULDBLOCK || this->error == EAGAIN;
#endif
}
 
bool NetworkError::IsConnectionReset() const
{
#if defined(_WIN32)
  return this->error == WSAECONNRESET;
#else
  return this->error == ECONNRESET;
#endif
}
 
bool NetworkError::IsConnectInProgress() const
{
#if defined(_WIN32)
  return this->error == WSAEWOULDBLOCK;
#else
  return this->error == EINPROGRESS;
#endif
}
 
const std::string &NetworkError::AsString() const
{
  if (this->message.empty()) {
#if defined(_WIN32)
    wchar_t buffer[512];
    if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, this->error,
      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buffer, static_cast<DWORD>(std::size(buffer)), nullptr) == 0) {
      this->message.assign(fmt::format("Unknown error {}", this->error));
    } else {
      this->message.assign(FS2OTTD(buffer));
    }
#else
    /* Make strerror thread safe by locking access to it. There is a thread safe strerror_r, however
     * the non-POSIX variant is available due to defining _GNU_SOURCE meaning it is not portable.
     * The problem with the non-POSIX variant is that it does not necessarily fill the buffer with
     * the error message but can also return a pointer to a static bit of memory, whereas the POSIX
     * variant always fills the buffer. This makes the behaviour too erratic to work with. */
    static std::mutex mutex;
    std::lock_guard<std::mutex> guard(mutex);
    this->message.assign(strerror(this->error));
#endif
  }
  return this->message;
}
 
bool NetworkError::HasError() const
{
  return this->error != 0;
}
 
/* static */ NetworkError NetworkError::GetLast()
{
#if defined(_WIN32)
  return NetworkError(WSAGetLastError());
#else
  return NetworkError(errno);
#endif
}
 
 
bool SetNonBlocking([[maybe_unused]] SOCKET d)
{
#if defined(_WIN32)
  u_long nonblocking = 1;
  return ioctlsocket(d, FIONBIO, &nonblocking) == 0;
#elif defined __EMSCRIPTEN__
  return true;
#else
  int nonblocking = 1;
  return ioctl(d, FIONBIO, &nonblocking) == 0;
#endif
}
 
bool SetNoDelay([[maybe_unused]] SOCKET d)
{
#ifdef __EMSCRIPTEN__
  return true;
#else
  int flags = 1;
  /* The (const char*) cast is needed for windows */
  return setsockopt(d, IPPROTO_TCP, TCP_NODELAY, (const char *)&flags, sizeof(flags)) == 0;
#endif
}
 
bool SetReusePort(SOCKET d)
{
#ifdef _WIN32
  /* Windows has no SO_REUSEPORT, but for our usecases SO_REUSEADDR does the same job. */
  int reuse_port = 1;
  return setsockopt(d, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuse_port, sizeof(reuse_port)) == 0;
#else
  int reuse_port = 1;
  return setsockopt(d, SOL_SOCKET, SO_REUSEPORT, &reuse_port, sizeof(reuse_port)) == 0;
#endif
}
 
NetworkError GetSocketError(SOCKET d)
{
  int err;
  socklen_t len = sizeof(err);
  getsockopt(d, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
 
  return NetworkError(err);
}