tcp.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_TCP_H
#define NETWORK_CORE_TCP_H
 
#include "address.h"
#include "packet.h"
 
#include <atomic>
#include <chrono>
#include <thread>
 
enum SendPacketsState : uint8_t {
  SPS_CLOSED,      
  SPS_NONE_SENT,   
  SPS_PARTLY_SENT, 
  SPS_ALL_SENT,    
};
 
class NetworkTCPSocketHandler : public NetworkSocketHandler {
private:
  std::deque<std::unique_ptr<Packet>> packet_queue; 
  std::unique_ptr<Packet> packet_recv = nullptr; 
 
  void EmptyPacketQueue();
public:
  SOCKET sock = INVALID_SOCKET; 
  bool writable = false; 
 
  bool IsConnected() const { return this->sock != INVALID_SOCKET; }
 
  virtual NetworkRecvStatus CloseConnection(bool error = true);
  void CloseSocket();
 
  virtual void SendPacket(std::unique_ptr<Packet> &&packet);
  SendPacketsState SendPackets(bool closing_down = false);
 
  virtual std::unique_ptr<Packet> ReceivePacket();
 
  bool CanSendReceive();
 
  bool HasSendQueue() { return !this->packet_queue.empty(); }
 
  NetworkTCPSocketHandler(SOCKET s = INVALID_SOCKET) : sock(s) {}
  ~NetworkTCPSocketHandler();
};
 
class TCPConnecter {
private:
  enum class Status : uint8_t {
    Init,       
    Resolving,  
    Failure,    
    Connecting, 
    Connected,  
  };
 
  std::thread resolve_thread;                         
  std::atomic<Status> status = Status::Init;          
  std::atomic<bool> killed = false;                   
 
  addrinfo *ai = nullptr;                             
  std::vector<addrinfo *> addresses;                  
  std::map<SOCKET, NetworkAddress> sock_to_address;   
  size_t current_address = 0;                         
 
  std::vector<SOCKET> sockets;                        
  std::chrono::steady_clock::time_point last_attempt; 
 
  std::string connection_string;                      
  NetworkAddress bind_address;                        
  int family = AF_UNSPEC;                             
 
  static std::vector<std::shared_ptr<TCPConnecter>> connecters; 
 
  void Resolve();
  void OnResolved(addrinfo *ai);
  bool TryNextAddress();
  void Connect(addrinfo *address);
  virtual bool CheckActivity();
 
  /* We do not want any other derived classes from this class being able to
   * access these private members, but it is okay for TCPServerConnecter. */
  friend class TCPServerConnecter;
 
  static void ResolveThunk(TCPConnecter *connecter);
 
public:
  TCPConnecter() {};
  TCPConnecter(const std::string &connection_string, uint16_t default_port, const NetworkAddress &bind_address = {}, int family = AF_UNSPEC);
  virtual ~TCPConnecter();
 
  virtual void OnConnect([[maybe_unused]] SOCKET s) {}
 
  virtual void OnFailure() {}
 
  void Kill();
 
  static void CheckCallbacks();
  static void KillAll();
 
  template <class T, typename... Args>
  static std::shared_ptr<TCPConnecter> Create(Args&& ... args)
  {
    return TCPConnecter::connecters.emplace_back(std::make_shared<T>(std::forward<Args>(args)...));
  }
};
 
class TCPServerConnecter : public TCPConnecter {
private:
  SOCKET socket = INVALID_SOCKET; 
 
  bool CheckActivity() override;
 
public:
  ServerAddress server_address; 
 
  TCPServerConnecter(const std::string &connection_string, uint16_t default_port);
 
  void SetConnected(SOCKET sock);
  void SetFailure();
};
 
#endif /* NETWORK_CORE_TCP_H */