TinyPPP_Generic.h

Go to the documentation of this file.

#pragma once
#include "IPStack.h"
#include "PPPEngine.h"
#include "PPPSockets.h"
 
namespace tinyppp {
 
class TinyPPP_Generic : public PPPEngine, public IPStack {
 public:
  using PacketCallback = void (*)(const uint8_t *data, size_t len, void *ref);
  using StateCallback = void (*)(bool up, void *ref);
 
  bool begin(Stream &io) {
    IPStack::current() = this;
    start(io);
    return true;
  }
 
  void end() { stop(); }
 
  void loop() { poll(); }
 
  bool config(IPAddress local, IPAddress peer = IPAddress(0, 0, 0, 0),
              IPAddress dns1 = IPAddress(0, 0, 0, 0),
              IPAddress dns2 = IPAddress(0, 0, 0, 0)) {
    setLocalIP(fromIPAddress(local));
    setPeerIP(fromIPAddress(peer));
    setOfferedDNS(fromIPAddress(dns1), fromIPAddress(dns2));
    return true;
  }
 
  bool waitConnected(uint32_t timeoutMs = 30000) {
    uint32_t start = millis();
    while (!connected()) {
      if (millis() - start >= timeoutMs) return false;
      loop();
      delay(1);
    }
    return true;
  }
 
  bool connected() const { return isUp(); }
  IPAddress localIP() const { return toIPAddress(PPPEngine::localIP()); }
  IPAddress gatewayIP() const { return toIPAddress(peerIP()); }
  IPAddress subnetMask() const { return IPAddress(255, 255, 255, 255); }
  IPAddress dnsIP(int n = 0) const {
    return toIPAddress(n == 0 ? dns1() : dns2());
  }
 
  void onReceive(PacketCallback cb, void *ref = nullptr) {
    _rxCallback = cb;
    _rxRef = ref;
  }
  void onStateChange(StateCallback cb, void *ref = nullptr) {
    _stateCallback = cb;
    _stateRef = ref;
  }
 
  bool send(const uint8_t *data, size_t len) { return sendIPv4(data, len); }
 
  using PPPEngine::setLogger;
  void setLogger(Print &out) { PPPEngine::setLogger(&out); }
 
 protected:
  PacketCallback _rxCallback = nullptr;
  void *_rxRef = nullptr;
  StateCallback _stateCallback = nullptr;
  void *_stateRef = nullptr;
 
  void onIPv4Packet(const uint8_t *data, size_t len) override {
    // with a raw callback, unknown connections are not answered with resets
    if (ipInput(data, len, _rxCallback == nullptr)) return;
    if (_rxCallback) _rxCallback(data, len, _rxRef);
  }
 
  void onLinkUp() override {
    if (_stateCallback) _stateCallback(true, _stateRef);
  }
 
  void onLinkDown() override {
    ipLinkDown();
    if (_stateCallback) _stateCallback(false, _stateRef);
  }
 
  // IPStack link layer
  bool ipBegin() override { return beginIPv4(); }
  void ipWrite(const uint8_t *data, size_t len) override { writeIPv4(data, len); }
  bool ipEnd() override { return endIPv4(); }
  void ipPoll() override { process(); }
  bool ipIsUp() const override { return isUp(); }
  ip4_t ipLocal() const override { return PPPEngine::localIP(); }
  ip4_t ipDns(int n) const override { return n == 0 ? dns1() : dns2(); }
  uint16_t ipMtu() const override {
    uint16_t m = mtu();
    return m > TINYPPP_MRU ? TINYPPP_MRU : m;
  }
};
 
using TinyPPP = TinyPPP_Generic;
 
}  // namespace tinyppp