native_ethernet_client.h

Go to the documentation of this file.

#pragma once
 
#ifdef _WIN64
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#include <unistd.h>
#endif
 
#include <Arduino.h>
#include <IPAddress.h>
#include <stdexcept>
 
#include <net/ethernet_client_hal.h>
 
namespace net {
 
class EthernetServer;
 
class NativeEthernetClientHAL : public EthernetClientHAL {
public:
  NativeEthernetClientHAL()
      :
#ifdef _WIN64
        client_fd(INVALID_SOCKET)
#else
        client_fd(-1)
#endif
  {
  }
 
  ~NativeEthernetClientHAL() override {
    if (isConnected()) {
      stop();
    }
  }
 
  int connect(IPAddress ip, uint16_t port) override { throw std::runtime_error("not impl"); }
 
  int connect(const char *host, uint16_t port) override { throw std::runtime_error("not impl"); }
 
  int connectNoWait(const IPAddress &ip, uint16_t port) override { throw std::runtime_error("not impl"); }
 
  int connectNoWait(const char *host, uint16_t port) override { throw std::runtime_error("not impl"); }
 
  uint8_t connected() override {
    if (!isConnected())
      return 0;
 
    int error = 0;
    socklen_t len = sizeof(error);
 
#ifdef _WIN64
    int retval = getsockopt(client_fd, SOL_SOCKET, SO_ERROR, reinterpret_cast<char *>(&error), &len);
#else
    int retval = getsockopt(client_fd, SOL_SOCKET, SO_ERROR, &error, &len);
#endif
 
    return retval == 0 && error == 0;
  }
 
  explicit operator bool() override {
#ifdef _WIN64
    return client_fd != INVALID_SOCKET;
#else
    return client_fd != -1;
#endif
  }
 
  void setConnectionTimeout(uint16_t timeout) override { throw std::runtime_error("not impl"); }
 
  uint16_t connectionTimeout() const override { throw std::runtime_error("not impl"); }
 
  void stop() override {
    if (isConnected()) {
#ifdef _WIN64
      closesocket(client_fd);
      client_fd = INVALID_SOCKET;
#else
      ::close(client_fd);
      client_fd = -1;
#endif
    }
  }
 
  void close() override { stop(); }
 
  void closeOutput() override { throw std::runtime_error("not impl"); }
 
  void abort() override { throw std::runtime_error("not impl"); }
 
  uint16_t localPort() override { throw std::runtime_error("not impl"); }
 
  IPAddress remoteIP() override {
    if (!isConnected())
      throw std::runtime_error("not connected");
 
    sockaddr_in addr;
    socklen_t addr_size = sizeof(struct sockaddr_in);
    int res = getpeername(client_fd, (struct sockaddr *)&addr, &addr_size);
    if (res != 0) {
      throw std::runtime_error("unable to find remote ip");
    }
    return {static_cast<unsigned int>(addr.sin_addr.s_addr)};
  }
 
  uint16_t remotePort() override {
    if (!isConnected())
      throw std::runtime_error("not connected");
 
    sockaddr_in addr;
    socklen_t addr_size = sizeof(struct sockaddr_in);
    int res = getpeername(client_fd, (struct sockaddr *)&addr, &addr_size);
    if (res != 0) {
      throw std::runtime_error("unable to find remote port");
    }
    return addr.sin_port;
  }
 
  IPAddress localIP() override { throw std::runtime_error("not impl"); }
 
  uintptr_t connectionId() override { throw std::runtime_error("not impl"); }
 
  size_t writeFully(uint8_t b) override { return writeFully(&b, 1); }
 
  size_t writeFully(const char *s) override { return writeFully(s, strlen(s)); }
 
  size_t writeFully(const char *s, size_t size) override {
    return writeFully(reinterpret_cast<const uint8_t *>(s), size * sizeof(char));
  }
 
  size_t writeFully(const uint8_t *buf, size_t size) override {
    size_t write_size = write(buf, size);
    flush();
    return write_size;
  }
 
  size_t write(uint8_t b) override {
#ifdef _WIN64
    return send(client_fd, reinterpret_cast<const char *>(&b), 1, 0);
#else
    return ::write(client_fd, &b, 1);
#endif
  }
 
  size_t write(const uint8_t *buf, size_t size) override {
#ifdef _WIN64
    return send(client_fd, reinterpret_cast<const char *>(buf), size, 0);
#else
    return ::write(client_fd, buf, size);
#endif
  }
 
  int availableForWrite() override { throw std::runtime_error("not impl"); }
 
  void flush() override {
    int flag = 1;
#ifdef _WIN64
    setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&flag), sizeof(int));
#else
    setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int));
#endif
  }
 
  int available() override {
    if (!isConnected())
      return 0;
 
    unsigned long bytes_available;
#ifdef _WIN64
    int result = ioctlsocket(client_fd, FIONREAD, &bytes_available);
#else
    int result = ::ioctl(client_fd, FIONREAD, &bytes_available);
#endif
 
    if (result != 0)
      return 0;
    return static_cast<int>(bytes_available);
  }
 
  int read() override {
    if (!isConnected())
      return -1;
 
#ifdef _WIN64
    int res = recv(client_fd, reinterpret_cast<char *>(input_buffer), 1, 0);
#else
    int res = ::read(client_fd, input_buffer, 1);
#endif
 
    if (res <= 0)
      return -1;
    return input_buffer[0];
  }
 
  int read(uint8_t *buf, size_t size) override { throw std::runtime_error("not impl"); }
 
  int peek() override { throw std::runtime_error("not impl"); }
 
  void setNoDelay(bool flag) override { throw std::runtime_error("not impl"); }
 
  bool isNoDelay() override { throw std::runtime_error("not impl"); }
 
private:
  bool isConnected() const {
#ifdef _WIN64
    return client_fd != INVALID_SOCKET;
#else
    return client_fd != -1;
#endif
  }
 
public:
#ifdef _WIN64
  explicit NativeEthernetClientHAL(SOCKET client_socket)
#else
  explicit NativeEthernetClientHAL(int client_socket)
#endif
      : client_fd(client_socket) {
  }
 
#ifdef _WIN64
  SOCKET client_fd;
#else
  int client_fd;
#endif
 
  uint8_t input_buffer[512];
 
  friend class NativeEthernetServerHAL;
};
 
} // namespace net