TinyPPP_RP2040.h

Go to the documentation of this file.

#pragma once
#include <Arduino.h>
#include <LwipEthernet.h>
#include <LwipIntf.h>
#include <WiFi.h>
#include <lwip/dns.h>
#include <lwip/ip4.h>
#include <lwip/netif.h>
#include <lwip/pbuf.h>
 
#include <functional>
 
#include "PPPEngine.h"
 
extern std::function<void(struct netif *)> _addNetifCB;
extern std::function<void(struct netif *)> _removeNetifCB;
 
namespace tinyppp {
 
using PPPClient = WiFiClient;
using PPPServer = WiFiServer;
using PPPUDP = WiFiUDP;
 
class TinyPPP_RP2040 : public LwipIntf, protected PPPEngine {
 public:
  TinyPPP_RP2040() = default;
  TinyPPP_RP2040(const TinyPPP_RP2040 &) = delete;
  TinyPPP_RP2040 &operator=(const TinyPPP_RP2040 &) = delete;
  ~TinyPPP_RP2040() { end(); }
 
  bool begin(Stream &io) {
    if (_netifAdded) end();
    _io = &io;
 
    ip4_addr_t any;
    ip4_addr_set_zero(&any);
    memset(&_netif, 0, sizeof(_netif));
    if (!netif_add(&_netif, &any, &any, &any, this, netifInit, ip4_input)) {
      return false;
    }
    _netifAdded = true;
    if (_addNetifCB) _addNetifCB(&_netif);
 
    // the engine is started from the lwIP context in the packet handler
    _cmd = Cmd::Start;
    _phID = __addEthernetPacketHandler([this] { this->poll(); });
    return true;
  }
 
  void end() {
    if (!_netifAdded) return;
    if (_phID >= 0) {
      _cmd = Cmd::Stop;
      // wait for the handler to send the LCP Terminate-Request
      uint32_t start = millis();
      while (_cmd != Cmd::None && millis() - start < 1000) delay(1);
      __removeEthernetPacketHandler(_phID);
      _phID = -1;
    }
    if (_removeNetifCB) _removeNetifCB(&_netif);
    netif_remove(&_netif);
    _netifAdded = false;
  }
 
  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;
  }
 
  using PPPEngine::fcsErrors;
  using PPPEngine::phase;
  using PPPEngine::setCredentials;
  using PPPEngine::setEchoInterval;
  using PPPEngine::setPassive;
  using PPPEngine::setRequestDNS;
  using PPPEngine::stats;
 
  void setLogger(Print &out) { PPPEngine::setLogger(&out); }
 
  void setDefault(bool flag = true) {
    _default = flag;
    if (flag && connected()) netif_set_default(&_netif);
  }
 
  void setPollingPeriod(int ms) { lwipPollingPeriod(ms); }
 
  bool waitConnected(uint32_t timeoutMs = 30000) {
    uint32_t start = millis();
    while (!connected()) {
      if (millis() - start >= timeoutMs) return false;
      delay(10);
    }
    return true;
  }
 
  bool connected() const { return _up; }
  wl_status_t status() const {
    if (!_netifAdded) return WL_NO_SHIELD;
    return _up ? WL_CONNECTED : WL_DISCONNECTED;
  }
  IPAddress localIP() const { return IPAddress(ip4_addr_get_u32(netif_ip4_addr(&_netif))); }
  IPAddress gatewayIP() const { return IPAddress(ip4_addr_get_u32(netif_ip4_gw(&_netif))); }
  IPAddress subnetMask() const { return IPAddress(ip4_addr_get_u32(netif_ip4_netmask(&_netif))); }
  IPAddress dnsIP(int n = 0) const {
    return toIPAddress(n == 0 ? dns1() : dns2());
  }
 
  using StateCallback = void (*)(bool up, void *ref);
 
  void onStateChange(StateCallback cb, void *ref = nullptr) {
    _stateCallback = cb;
    _stateRef = ref;
  }
 
  struct netif *getNetIf() { return &_netif; }
 
 protected:
  enum class Cmd : uint8_t { None, Start, Stop };
 
  struct netif _netif;
  Stream *_io = nullptr;
  int _phID = -1;
  volatile Cmd _cmd = Cmd::None;
  volatile bool _up = false;
  bool _netifAdded = false;
  bool _default = true;
  StateCallback _stateCallback = nullptr;
  void *_stateRef = nullptr;
 
  // called by the lwIP background task (lwIP lock held)
  void poll() {
    if (_cmd == Cmd::Start) {
      start(*_io);
      _cmd = Cmd::None;
    } else if (_cmd == Cmd::Stop) {
      stop();
      _cmd = Cmd::None;
      return;
    }
    process();
  }
 
  static err_t netifInit(struct netif *netif) {
    netif->name[0] = 'p';
    netif->name[1] = 'p';
    netif->mtu = 1500;
    netif->flags = 0;  // point-to-point: no ARP, no broadcast
    netif->output = output4;
#if LWIP_IPV6
    netif->output_ip6 = output6;
#endif
    return ERR_OK;
  }
 
  static err_t output4(struct netif *netif, struct pbuf *p,
                       const ip4_addr_t *addr) {
    (void)addr;
    TinyPPP_RP2040 *self = (TinyPPP_RP2040 *)netif->state;
    if (!self->beginIPv4()) return ERR_CONN;
    for (struct pbuf *q = p; q != nullptr; q = q->next) {
      self->writeIPv4((const uint8_t *)q->payload, q->len);
      if (q->len == q->tot_len) break;
    }
    return self->endIPv4() ? ERR_OK : ERR_IF;
  }
 
#if LWIP_IPV6
  static err_t output6(struct netif *, struct pbuf *, const ip6_addr_t *) {
    return ERR_IF;  // IPV6CP is not supported
  }
#endif
 
  void onIPv4Packet(const uint8_t *data, size_t len) override {
    struct pbuf *p = pbuf_alloc(PBUF_RAW, (u16_t)len, PBUF_POOL);
    if (p == nullptr) return;
    pbuf_take(p, data, (u16_t)len);
    if (_netif.input(p, &_netif) != ERR_OK) pbuf_free(p);
  }
 
  void onLinkUp() override {
    ip4_addr_t ip, mask, gw;
    ip4_addr_set_u32(&ip, PPPEngine::localIP());
    ip4_addr_set_u32(&gw, peerIP());
    ip4_addr_set_u32(&mask, 0xFFFFFFFF);
    netif_set_addr(&_netif, &ip, &mask, &gw);
    _netif.mtu = mtu();
    netif_set_link_up(&_netif);
    netif_set_up(&_netif);
    if (dns1() != 0) {
      ip_addr_t dns;
      ip_addr_set_ip4_u32(&dns, dns1());
      dns_setserver(0, &dns);
    }
    if (dns2() != 0) {
      ip_addr_t dns;
      ip_addr_set_ip4_u32(&dns, dns2());
      dns_setserver(1, &dns);
    }
    if (_default) netif_set_default(&_netif);
    _up = true;
    if (_stateCallback) _stateCallback(true, _stateRef);
  }
 
  void onLinkDown() override {
    _up = false;
    netif_set_down(&_netif);
    netif_set_link_down(&_netif);
    ip4_addr_t any;
    ip4_addr_set_zero(&any);
    netif_set_addr(&_netif, &any, &any, &any);
    if (_stateCallback) _stateCallback(false, _stateRef);
  }
};
 
using TinyPPP = TinyPPP_RP2040;
 
}  // namespace tinyppp