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;            
 
  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(sockaddr *address, int address_length) :
    address_length(address_length),
    resolved(address_length != 0)
  {
    memset(&this->address, 0, sizeof(this->address));
    memcpy(&this->address, address, 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;
 
    memset(&this->address, 0, sizeof(this->address));
    this->address.ss_family = family;
    this->SetPort(port);
  }
 
  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;
  }
 
  uint16_t GetPort() const;
  void SetPort(uint16_t port);
 
  bool IsResolved() const
  {
    return this->resolved;
  }
 
  bool IsFamily(int family);
  bool IsInNetmask(const std::string &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;
  }
 
  bool operator == (NetworkAddress &address)
  {
    return this->CompareTo(address) == 0;
  }
 
  bool operator == (NetworkAddress &address) const
  {
    return const_cast<NetworkAddress*>(this)->CompareTo(address) == 0;
  }
  bool operator != (NetworkAddress address) const
  {
    return const_cast<NetworkAddress*>(this)->CompareTo(address) != 0;
  }
 
  bool operator < (NetworkAddress &address)
  {
    return this->CompareTo(address) < 0;
  }
 
  void Listen(int socktype, SocketList *sockets);
 
  static const char *SocketTypeAsString(int socktype);
  static const char *AddressFamilyAsString(int family);
  static NetworkAddress GetPeerAddress(SOCKET sock);
  static NetworkAddress GetSockAddress(SOCKET sock);
  static const std::string GetPeerName(SOCKET sock);
};
 
enum ServerAddressType {
  SERVER_ADDRESS_DIRECT,      
  SERVER_ADDRESS_INVITE_CODE, 
};
 
class ServerAddress {
private:
  ServerAddress(ServerAddressType type, const std::string &connection_string) : type(type), connection_string(connection_string) {}
 
public:
  ServerAddressType type;        
  std::string connection_string; 
 
  static ServerAddress Parse(const std::string &connection_string, uint16_t default_port, CompanyID *company_id = nullptr);
};
 
#endif /* NETWORK_CORE_ADDRESS_H */