PPPSockets.h

Go to the documentation of this file.

#pragma once
#include <Client.h>
#include <Server.h>
#include <Udp.h>
 
#include "IPStack.h"
#include "PPPEngine.h"
 
#ifndef TINYPPP_TIMEOUT
#define TINYPPP_TIMEOUT 5000
#endif
 
namespace tinyppp {
 
class PPPClient : public Client {
 public:
  PPPClient() = default;
  explicit PPPClient(IPStack &stack) : _stack(&stack) {}
  PPPClient(IPStack *stack, int sock)
      : _stack(stack), _sock(sock), _gen(stack->tcpGen(sock)) {}
 
  int connect(IPAddress ip, uint16_t port) override {
    if (stack() == nullptr) return 0;
    if (valid()) stop();
    _sock = stack()->tcpConnect(toIp4(ip[0], ip[1], ip[2], ip[3]),
                                port, _timeout);
    if (_sock < 0) return 0;
    _gen = stack()->tcpGen(_sock);
    return 1;
  }
 
  int connect(const char *host, uint16_t port) override {
    if (stack() == nullptr) return 0;
    IPAddress ip;
    if (!stack()->hostByName(host, ip, _timeout)) return 0;
    return connect(ip, port);
  }
 
  size_t write(uint8_t b) override { return write(&b, 1); }
  size_t write(const uint8_t *buf, size_t size) override {
    if (!valid()) return 0;
    size_t n = stack()->tcpWrite(_sock, buf, size, _timeout);
    if (n < size) setWriteError();
    return n;
  }
  using Print::write;
 
  int available() override {
    return valid() ? stack()->tcpAvailable(_sock) : 0;
  }
 
  int read() override {
    uint8_t b;
    return read(&b, 1) == 1 ? b : -1;
  }
 
  int read(uint8_t *buf, size_t size) override {
    if (!valid()) return -1;
    int n = stack()->tcpRead(_sock, buf, size);
    return n > 0 ? n : -1;
  }
 
  int peek() override { return valid() ? stack()->tcpPeek(_sock) : -1; }
 
  void flush() override {
    if (valid()) stack()->tcpFlush(_sock, _timeout);
  }
 
  void stop() override {
    if (valid()) stack()->tcpClose(_sock, 1000);
    _sock = -1;
  }
 
  uint8_t connected() override {
    if (!valid()) return 0;
    if (stack()->tcpAvailable(_sock) > 0) return 1;
    return stack()->tcpState(_sock) == TCPState::Established;
  }
 
  operator bool() override { return valid(); }
 
  bool operator==(const PPPClient &other) const {
    return _sock == other._sock && _gen == other._gen;
  }
  bool operator!=(const PPPClient &other) const { return !(*this == other); }
 
  IPAddress remoteIP() {
    return valid() ? toIPAddress(stack()->tcpRemoteIP(_sock))
                   : IPAddress(0, 0, 0, 0);
  }
  uint16_t remotePort() {
    return valid() ? stack()->tcpRemotePort(_sock) : 0;
  }
  uint16_t localPort() { return valid() ? stack()->tcpLocalPort(_sock) : 0; }
 
  void setConnectionTimeout(uint32_t ms) { _timeout = ms; }
 
 protected:
  IPStack *_stack = nullptr;
  int _sock = -1;
  uint8_t _gen = 0;
  uint32_t _timeout = TINYPPP_TIMEOUT;
 
  IPStack *stack() const {
    return _stack ? _stack : IPStack::current();
  }
  bool valid() const {
    return _sock >= 0 && stack() != nullptr && stack()->tcpValid(_sock, _gen);
  }
};
 
class PPPServer : public Server {
 public:
  explicit PPPServer(uint16_t port = 80) : _port(port) {}
  PPPServer(uint16_t port, IPStack &stack)
      : _port(port), _stack(&stack) {}
 
  void begin() override {
    if (stack()) _listening = stack()->tcpListen(_port);
  }
  void begin(uint16_t port) {
    end();
    _port = port;
    begin();
  }
 
  void end() {
    if (stack() && _listening) stack()->tcpUnlisten(_port);
    _listening = false;
  }
 
  PPPClient accept() {
    int s = stack() ? stack()->tcpAccept(_port, false) : -1;
    return s < 0 ? PPPClient() : PPPClient(stack(), s);
  }
 
  PPPClient available() {
    int s = stack() ? stack()->tcpAccept(_port, true) : -1;
    return s < 0 ? PPPClient() : PPPClient(stack(), s);
  }
 
  size_t write(uint8_t b) override { return write(&b, 1); }
  size_t write(const uint8_t *buf, size_t size) override {
    return stack() ? stack()->tcpWriteAll(_port, buf, size, TINYPPP_TIMEOUT)
                   : 0;
  }
  using Print::write;
 
  operator bool() { return _listening; }
  uint16_t port() const { return _port; }
 
 protected:
  uint16_t _port;
  IPStack *_stack = nullptr;
  bool _listening = false;
 
  IPStack *stack() const {
    return _stack ? _stack : IPStack::current();
  }
};
 
class PPPUDP : public UDP {
 public:
  PPPUDP() = default;
  explicit PPPUDP(IPStack &stack) : _stack(&stack) {}
  ~PPPUDP() { stop(); }
  PPPUDP(const PPPUDP &) = delete;
  PPPUDP &operator=(const PPPUDP &) = delete;
 
  uint8_t begin(uint16_t port) override {
    stop();
    if (stack() == nullptr) return 0;
    _sock = stack()->udpOpen(port);
    return _sock >= 0;
  }
 
  void stop() override {
    if (_sock >= 0 && stack()) stack()->udpClose(_sock);
    _sock = -1;
    _txLen = 0;
  }
 
  int beginPacket(IPAddress ip, uint16_t port) override {
    if (_sock < 0 && !begin(0)) return 0;
    _txIP = ip;
    _txPort = port;
    _txLen = 0;
    _txOverflow = false;
    return 1;
  }
 
  int beginPacket(const char *host, uint16_t port) override {
    if (stack() == nullptr) return 0;
    IPAddress ip;
    if (!stack()->hostByName(host, ip)) return 0;
    return beginPacket(ip, port);
  }
 
  int endPacket() override {
    if (_sock < 0 || _txOverflow) return 0;
    bool ok = stack()->udpSend(
        _sock, toIp4(_txIP[0], _txIP[1], _txIP[2], _txIP[3]), _txPort,
        _tx, _txLen);
    _txLen = 0;
    return ok;
  }
 
  size_t write(uint8_t b) override { return write(&b, 1); }
  size_t write(const uint8_t *buf, size_t size) override {
    if (_txLen + size > sizeof(_tx)) {
      _txOverflow = true;
      size = sizeof(_tx) - _txLen;
    }
    memcpy(_tx + _txLen, buf, size);
    _txLen += size;
    return size;
  }
  using Print::write;
 
  int parsePacket() override {
    if (_sock < 0) return 0;
    ip4_t ip = 0;
    int n = stack()->udpParsePacket(_sock, ip, _rxPort);
    if (n > 0 || stack()->udpAvailable(_sock) > 0) _rxIP = toIPAddress(ip);
    return n;
  }
 
  int available() override {
    return _sock < 0 ? 0 : stack()->udpAvailable(_sock);
  }
 
  int read() override {
    uint8_t b;
    return read(&b, 1) == 1 ? b : -1;
  }
  int read(unsigned char *buf, size_t len) override {
    if (_sock < 0) return -1;
    int n = stack()->udpRead(_sock, buf, len);
    return n > 0 ? n : -1;
  }
  int read(char *buf, size_t len) override {
    return read((unsigned char *)buf, len);
  }
 
  int peek() override { return _sock < 0 ? -1 : stack()->udpPeek(_sock); }
 
  void flush() override {
    if (_sock >= 0) stack()->udpDiscard(_sock);
  }
 
  IPAddress remoteIP() override { return _rxIP; }
  uint16_t remotePort() override { return _rxPort; }
  uint16_t localPort() { return _sock < 0 ? 0 : stack()->udpLocalPort(_sock); }
 
 protected:
  IPStack *_stack = nullptr;
  int _sock = -1;
  IPAddress _rxIP;
  uint16_t _rxPort = 0;
  IPAddress _txIP;
  uint16_t _txPort = 0;
  size_t _txLen = 0;
  bool _txOverflow = false;
  uint8_t _tx[TINYPPP_UDP_TX_BUFFER];
 
  IPStack *stack() const {
    return _stack ? _stack : IPStack::current();
  }
};
 
}  // namespace tinyppp