address.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_ADDRESS_H
#define NETWORK_CORE_ADDRESS_H
 
#include "os_abstraction.h"
#include "config.h"
#include "../../company_type.h"
#include "../../string_func.h"
 
 
class NetworkAddress;
typedef std::vector<NetworkAddress> NetworkAddressList; 
using SocketList = std::map<SOCKET, NetworkAddress>;    
 
class NetworkAddress {
private:
  std::string hostname{}; 
  int address_length{}; 
  sockaddr_storage address{}; 
  bool resolved = false; 
 
  typedef SOCKET (*LoopProc)(addrinfo *runp);
 
  SOCKET Resolve(int family, int socktype, int flags, SocketList *sockets, LoopProc func);
public:
  NetworkAddress(struct sockaddr_storage &address, int address_length) :
    address_length(address_length),
    address(address),
    resolved(address_length != 0)
  {
  }
  NetworkAddress(struct sockaddr_storage &address, int address_length) : {…}
 
  NetworkAddress(const sockaddr *address, int address_length) :
    address_length(address_length),
    resolved(address_length != 0)
  {
    std::copy_n(reinterpret_cast<const std::byte *>(address), address_length, reinterpret_cast<std::byte *>(&this->address));
  }
  NetworkAddress(const sockaddr *address, int address_length) : {…}
 
  NetworkAddress(std::string_view hostname = "", uint16_t port = 0, int family = AF_UNSPEC) :
    address_length(0),
    resolved(false)
  {
    if (!hostname.empty() && hostname.front() == '[' && hostname.back() == ']') {
      hostname.remove_prefix(1);
      hostname.remove_suffix(1);
    }
    this->hostname = hostname;
    this->address.ss_family = family;
    this->SetPort(port);
  }
  NetworkAddress(std::string_view hostname = "", uint16_t port = 0, int family = AF_UNSPEC) : {…}
 
  const std::string &GetHostname();
  std::string GetAddressAsString(bool with_family = true);
  const sockaddr_storage *GetAddress();
 
  int GetAddressLength()
  {
    /* Resolve it if we didn't do it already */
    if (!this->IsResolved()) this->GetAddress();
    return this->address_length;
  }
  int GetAddressLength() {…}
 
  uint16_t GetPort() const;
  void SetPort(uint16_t port);
 
  bool IsResolved() const
  {
    return this->resolved;
  }
  bool IsResolved() const {…}
 
  bool IsFamily(int family);
  bool IsInNetmask(std::string_view netmask);
 
  int CompareTo(NetworkAddress &address)
  {
    int r = this->GetAddressLength() - address.GetAddressLength();
    if (r == 0) r = this->address.ss_family - address.address.ss_family;
    if (r == 0) r = memcmp(&this->address, &address.address, this->address_length);
    if (r == 0) r = this->GetPort() - address.GetPort();
    return r;
  }
  int CompareTo(NetworkAddress &address) {…}
 
  bool operator == (NetworkAddress &address)
  {
    return this->CompareTo(address) == 0;
  }
  bool operator == (NetworkAddress &address) {…}
 
  bool operator == (NetworkAddress &address) const
  {
    return const_cast<NetworkAddress*>(this)->CompareTo(address) == 0;
  }
  bool operator == (NetworkAddress &address) const {…}
 
  auto operator <=>(NetworkAddress &address)
  {
    return this->CompareTo(address) <=> 0;
  }
  auto operator <=>(NetworkAddress &address) {…}
 
  void Listen(int socktype, SocketList *sockets);
 
  static std::string_view SocketTypeAsString(int socktype);
  static std::string_view AddressFamilyAsString(int family);
  static NetworkAddress GetPeerAddress(SOCKET sock);
  static NetworkAddress GetSockAddress(SOCKET sock);
  static const std::string GetPeerName(SOCKET sock);
};
class NetworkAddress {…};
 
enum ServerAddressType : uint8_t {
  SERVER_ADDRESS_DIRECT,      
  SERVER_ADDRESS_INVITE_CODE, 
};
enum ServerAddressType : uint8_t {…};
 
class ServerAddress {
private:
  ServerAddress(ServerAddressType type, std::string &&connection_string) : type(type), connection_string(std::move(connection_string)) {}
 
public:
  ServerAddressType type;        
  std::string connection_string; 
 
  static ServerAddress Parse(std::string_view connection_string, uint16_t default_port, CompanyID *company_id = nullptr);
};
class ServerAddress {…};
 
#endif /* NETWORK_CORE_ADDRESS_H */