teensy_ethernet_client.h

Go to the documentation of this file.

#pragma once
 
#include <IPAddress.h>
#include <QNEthernet.h>
 
#include <net/ethernet_client_hal.h>
 
namespace qn = qindesign::network;
 
namespace net {
 
class EthernetServer;
 
class TeensyEthernetClientHAL : public EthernetClientHAL {
public:
  TeensyEthernetClientHAL();
  ~TeensyEthernetClientHAL() override = default;
 
  int connect(IPAddress ip, uint16_t port) override;
  // Returns INVALID_SERVER (-2) if DNS is disabled.
  int connect(const char *host, uint16_t port) override;
 
  // These functions start the connection process but don't wait for the
  // connection to be complete. Note that DNS lookup might still take some time.
  // Neither of these will return TIMED_OUT (-1).
  int connectNoWait(const IPAddress &ip, uint16_t port) override;
 
  // Returns INVALID_SERVER (-2) if DNS is disabled.
  int connectNoWait(const char *host, uint16_t port) override;
 
  uint8_t connected() override;
  operator bool() override;
 
  void setConnectionTimeout(uint16_t timeout) override;
 
  // Returns the current timeout value.
  uint16_t connectionTimeout() const override;
 
  void stop() override;
 
  // Closes the connection. This works the same as stop(), but without waiting
  // for the connection to close.
  void close() override;
 
  // Closes the sending side of this connection.
  void closeOutput() override;
 
  // Kills the connection without going through the TCP close process.
  void abort() override;
 
  uint16_t localPort() override;
  IPAddress remoteIP() override;
  uint16_t remotePort() override;
 
  // Returns the local IP address for this connection, or INADDR_NONE if this
  // client is not connected.
  IPAddress localIP() override;
 
  // Returns an ID for the connection to which this client refers. It will
  // return non-zero if connected and zero if not connected.
  //
  // This is useful because of the way EthernetClient objects can be passed
  // around, copied, and moved, etc. Just taking an address of the object won't
  // work because more than one object could refer to the same connection.
  //
  // Note that while multiple active connections won't share the same ID, it's
  // possible for new connections to reuse IDs that aren't currently in use. In
  // other words, there is a one-to-one correspondence between the set of
  // connection IDs and currently active connections.
  uintptr_t connectionId() override;
 
  // Functions that loop until all bytes are written. If the connection is
  // closed before all bytes are sent then these break early and return the
  // actual number of bytes sent. In other words, these only return a value less
  // than the specified size if the connection was closed.
  size_t writeFully(uint8_t b) override;
  size_t writeFully(const char *s) override;
  size_t writeFully(const char *s, size_t size) override;
  size_t writeFully(const uint8_t *buf, size_t size) override;
 
  size_t write(uint8_t b) override;
  size_t write(const uint8_t *buf, size_t size) override;
  int availableForWrite() override;
  void flush() override;
 
  int available() override;
  int read() override;
 
  // A NULL buffer allows the caller to skip bytes without having to read into
  // a buffer.
  int read(uint8_t *buf, size_t size) override;
 
  int peek() override;
 
  // ----------------
  //  Socket Options
  // ----------------
 
  // Disables or enables Nagle's algorithm. This sets or clears the TCP_NODELAY
  // flag. If the flag is set then Nagle's algorithm is disabled, otherwise it
  // is enabled. Note that this option must be set for each new connection.
  void setNoDelay(bool flag) override;
 
  // Returns the value of the TCP_NODELAY flag for the current connection. This
  // returns false if not connected.
  bool isNoDelay() override;
 
public:
  TeensyEthernetClientHAL(qn::EthernetClient impl);
  qn::EthernetClient impl_;
  friend class NativeEthernetServerHAL;
};
 
} // namespace net