WPILibC++  2018.4.1-20180927001728-1207-gd5d744a
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
Tcp.h
1 /*----------------------------------------------------------------------------*/
2 /* Copyright (c) 2018 FIRST. All Rights Reserved. */
3 /* Open Source Software - may be modified and shared by FRC teams. The code */
4 /* must be accompanied by the FIRST BSD license file in the root directory of */
5 /* the project. */
6 /*----------------------------------------------------------------------------*/
7 
8 #ifndef WPIUTIL_WPI_UV_TCP_H_
9 #define WPIUTIL_WPI_UV_TCP_H_
10 
11 #include <uv.h>
12 
13 #include <chrono>
14 #include <functional>
15 #include <memory>
16 
17 #include "wpi/Twine.h"
18 #include "wpi/uv/NetworkStream.h"
19 
20 namespace wpi {
21 namespace uv {
22 
23 class Loop;
24 class TcpConnectReq;
25 
30 class Tcp final : public NetworkStreamImpl<Tcp, uv_tcp_t> {
31  struct private_init {};
32 
33  public:
34  using Time = std::chrono::duration<uint64_t, std::milli>;
35 
36  explicit Tcp(const private_init&) {}
37  ~Tcp() noexcept override = default;
38 
45  static std::shared_ptr<Tcp> Create(Loop& loop,
46  unsigned int flags = AF_UNSPEC);
47 
54  static std::shared_ptr<Tcp> Create(const std::shared_ptr<Loop>& loop,
55  unsigned int flags = AF_UNSPEC) {
56  return Create(*loop, flags);
57  }
58 
69  void Reuse(std::function<void()> callback, unsigned int flags = AF_UNSPEC);
70 
86  std::shared_ptr<Tcp> Accept();
87 
104  bool Accept(const std::shared_ptr<Tcp>& client) {
105  return NetworkStream::Accept(client);
106  }
107 
116  void Open(uv_os_sock_t sock) { Invoke(&uv_tcp_open, GetRaw(), sock); }
117 
123  bool SetNoDelay(bool enable) { return uv_tcp_nodelay(GetRaw(), enable) == 0; }
124 
132  bool SetKeepAlive(bool enable, Time time = Time{0}) {
133  return uv_tcp_keepalive(GetRaw(), enable, time.count()) == 0;
134  }
135 
150  bool SetSimultaneousAccepts(bool enable) {
151  return uv_tcp_simultaneous_accepts(GetRaw(), enable) == 0;
152  }
153 
165  void Bind(const sockaddr& addr, unsigned int flags = 0) {
166  Invoke(&uv_tcp_bind, GetRaw(), &addr, flags);
167  }
168 
169  void Bind(const sockaddr_in& addr, unsigned int flags = 0) {
170  Bind(reinterpret_cast<const sockaddr&>(addr), flags);
171  }
172 
173  void Bind(const sockaddr_in6& addr, unsigned int flags = 0) {
174  Bind(reinterpret_cast<const sockaddr&>(addr), flags);
175  }
176 
191  void Bind(const Twine& ip, unsigned int port, unsigned int flags = 0);
192 
207  void Bind6(const Twine& ip, unsigned int port, unsigned int flags = 0);
208 
213  sockaddr_storage GetSock();
214 
219  sockaddr_storage GetPeer();
220 
236  void Connect(const sockaddr& addr, const std::shared_ptr<TcpConnectReq>& req);
237 
238  void Connect(const sockaddr_in& addr,
239  const std::shared_ptr<TcpConnectReq>& req) {
240  Connect(reinterpret_cast<const sockaddr&>(addr), req);
241  }
242 
243  void Connect(const sockaddr_in6& addr,
244  const std::shared_ptr<TcpConnectReq>& req) {
245  Connect(reinterpret_cast<const sockaddr&>(addr), req);
246  }
247 
261  void Connect(const sockaddr& addr, std::function<void()> callback);
262 
263  void Connect(const sockaddr_in& addr, std::function<void()> callback) {
264  Connect(reinterpret_cast<const sockaddr&>(addr), callback);
265  }
266 
267  void Connect(const sockaddr_in6& addr, std::function<void()> callback) {
268  Connect(reinterpret_cast<const sockaddr&>(addr), callback);
269  }
270 
287  void Connect(const Twine& ip, unsigned int port,
288  const std::shared_ptr<TcpConnectReq>& req);
289 
304  void Connect(const Twine& ip, unsigned int port,
305  std::function<void()> callback);
306 
323  void Connect6(const Twine& ip, unsigned int port,
324  const std::shared_ptr<TcpConnectReq>& req);
325 
340  void Connect6(const Twine& ip, unsigned int port,
341  std::function<void()> callback);
342 
343  private:
344  Tcp* DoAccept() override;
345 
346  struct ReuseData {
347  std::function<void()> callback;
348  unsigned int flags;
349  };
350  std::unique_ptr<ReuseData> m_reuseData;
351 };
352 
356 class TcpConnectReq : public ConnectReq {
357  public:
358  Tcp& GetStream() const {
359  return *static_cast<Tcp*>(&ConnectReq::GetStream());
360  }
361 };
362 
363 } // namespace uv
364 } // namespace wpi
365 
366 #endif // WPIUTIL_WPI_UV_TCP_H_
void Bind(const sockaddr &addr, unsigned int flags=0)
Bind the handle to an IPv4 or IPv6 address and port.
Definition: Tcp.h:165
void Reuse(std::function< void()> callback, unsigned int flags=AF_UNSPEC)
Reuse this handle.
std::shared_ptr< NetworkStream > Accept()
Accept incoming connection.
Definition: NetworkStream.h:94
uv_tcp_t * GetRaw() const noexcept
Get the underlying handle data structure.
Definition: NetworkStream.h:145
std::shared_ptr< Tcp > Accept()
Accept incoming connection.
WPILib C++ utilities (wpiutil) namespace.
Definition: SmallString.h:21
sockaddr_storage GetPeer()
Get the address of the peer connected to the handle.
void Connect6(const Twine &ip, unsigned int port, const std::shared_ptr< TcpConnectReq > &req)
Establish an IPv6 TCP connection.
TCP handle.
Definition: Tcp.h:30
bool SetSimultaneousAccepts(bool enable)
Enable/Disable simultaneous asynchronous accept requests.
Definition: Tcp.h:150
static std::shared_ptr< Tcp > Create(Loop &loop, unsigned int flags=AF_UNSPEC)
Create a TCP handle.
Definition: NetworkStream.h:130
void Bind6(const Twine &ip, unsigned int port, unsigned int flags=0)
Bind the handle to an IPv6 address and port.
bool SetKeepAlive(bool enable, Time time=Time{0})
Enable/Disable TCP keep-alive.
Definition: Tcp.h:132
static std::shared_ptr< Tcp > Create(const std::shared_ptr< Loop > &loop, unsigned int flags=AF_UNSPEC)
Create a TCP handle.
Definition: Tcp.h:54
Event loop.
Definition: Loop.h:37
bool Accept(const std::shared_ptr< Tcp > &client)
Accept incoming connection.
Definition: Tcp.h:104
bool SetNoDelay(bool enable)
Enable/Disable Nagle's algorithm.
Definition: Tcp.h:123
TCP connection request.
Definition: Tcp.h:356
void Connect(const sockaddr &addr, const std::shared_ptr< TcpConnectReq > &req)
Establish an IPv4 or IPv6 TCP connection.
void Open(uv_os_sock_t sock)
Open an existing file descriptor or SOCKET as a TCP handle.
Definition: Tcp.h:116
sockaddr_storage GetSock()
Get the current address to which the handle is bound.
Connection request.
Definition: NetworkStream.h:27