extmod/network_ppp_lwip: Add network.PPP via lwIP.

This commit adds a new `network.PPP` interface which works on any port that
has bare-metal lwIP, eg rp2, stm32, mimxrt.

It has been tested on stm32.  A board needs to enable
`MICROPY_PY_NETWORK_PPP_LWIP` and then it can use it as follows:

    import network

    ppp = network.PPP(uart)
    ppp.connect()

    while not ppp.isconnected():
        pass

    # use `socket` module as usual, etc

    ppp.disconnect()

Usually the application must first configure the cellular/etc UART link to
get it connected and in to PPP mode first (eg ATD*99#), before handing over
control to `network.PPP`.

The PPP interface automatically configures the UART IRQ callback to call
PPP.poll() on incoming data.
Signed-off-by: Damien George <damien@micropython.org>

extmod/extmod.cmake

@@ -49,6 +49,7 @@ set(MICROPY_SOURCE_EXTMOD
     ${MICROPY_EXTMOD_DIR}/network_cyw43.c
     ${MICROPY_EXTMOD_DIR}/network_lwip.c
     ${MICROPY_EXTMOD_DIR}/network_ninaw10.c
+    ${MICROPY_EXTMOD_DIR}/network_ppp_lwip.c
     ${MICROPY_EXTMOD_DIR}/network_wiznet5k.c
     ${MICROPY_EXTMOD_DIR}/os_dupterm.c
     ${MICROPY_EXTMOD_DIR}/vfs.c
@@ -313,6 +314,32 @@ if(MICROPY_PY_LWIP)
         ${MICROPY_LIB_LWIP_DIR}/core/timeouts.c
         ${MICROPY_LIB_LWIP_DIR}/core/udp.c
         ${MICROPY_LIB_LWIP_DIR}/netif/ethernet.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/auth.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/ccp.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/chap-md5.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/chap_ms.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/chap-new.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/demand.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/eap.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/ecp.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/eui64.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/fsm.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/ipcp.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/ipv6cp.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/lcp.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/magic.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/mppe.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/multilink.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/polarssl/md5.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/pppapi.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/ppp.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/pppcrypt.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/pppoe.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/pppol2tp.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/pppos.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/upap.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/utils.c
+        ${MICROPY_LIB_LWIP_DIR}/netif/ppp/vj.c
     )
 
     list(APPEND MICROPY_INC_CORE

extmod/extmod.mk

@@ -51,6 +51,7 @@ SRC_EXTMOD_C += \
 	extmod/network_esp_hosted.c \
 	extmod/network_lwip.c \
 	extmod/network_ninaw10.c \
+	extmod/network_ppp_lwip.c \
 	extmod/network_wiznet5k.c \
 	extmod/os_dupterm.c \
 	extmod/vfs.c \
@@ -370,6 +371,32 @@ SRC_THIRDPARTY_C += $(addprefix $(LWIP_DIR)/,\
 	core/ipv6/mld6.c \
 	core/ipv6/nd6.c \
 	netif/ethernet.c \
+	netif/ppp/auth.c \
+	netif/ppp/ccp.c \
+	netif/ppp/chap-md5.c \
+	netif/ppp/chap_ms.c \
+	netif/ppp/chap-new.c \
+	netif/ppp/demand.c \
+	netif/ppp/eap.c \
+	netif/ppp/ecp.c \
+	netif/ppp/eui64.c \
+	netif/ppp/fsm.c \
+	netif/ppp/ipcp.c \
+	netif/ppp/ipv6cp.c \
+	netif/ppp/lcp.c \
+	netif/ppp/magic.c \
+	netif/ppp/mppe.c \
+	netif/ppp/multilink.c \
+	netif/ppp/polarssl/md5.c \
+	netif/ppp/pppapi.c \
+	netif/ppp/ppp.c \
+	netif/ppp/pppcrypt.c \
+	netif/ppp/pppoe.c \
+	netif/ppp/pppol2tp.c \
+	netif/ppp/pppos.c \
+	netif/ppp/upap.c \
+	netif/ppp/utils.c \
+	netif/ppp/vj.c \
 	)
 ifeq ($(MICROPY_PY_LWIP_LOOPBACK),1)
 CFLAGS_EXTMOD += -DLWIP_NETIF_LOOPBACK=1

extmod/modnetwork.c

@@ -156,6 +156,10 @@ static const mp_rom_map_elem_t mp_module_network_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_ipconfig), MP_ROM_PTR(&mod_network_ipconfig_obj) },
     #endif
 
+    #if MICROPY_PY_NETWORK_PPP_LWIP
+    { MP_ROM_QSTR(MP_QSTR_PPP), MP_ROM_PTR(&mp_network_ppp_lwip_type) },
+    #endif
+
     // Defined per port in mpconfigport.h
     #ifdef MICROPY_PORT_NETWORK_INTERFACES
     { MP_ROM_QSTR(MP_QSTR_route), MP_ROM_PTR(&network_route_obj) },

extmod/modnetwork.h

@@ -72,6 +72,10 @@ mp_obj_t mod_network_hostname(size_t n_args, const mp_obj_t *args);
 
 #include "lwip/init.h"
 
+#if MICROPY_PY_NETWORK_PPP_LWIP
+extern const struct _mp_obj_type_t mp_network_ppp_lwip_type;
+#endif
+
 struct netif;
 void mod_network_lwip_init(void);
 void mod_network_lwip_poll_wrapper(uint32_t ticks_ms);

extmod/network_ppp_lwip.c

+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "py/stream.h"
+#include "extmod/modnetwork.h"
+
+#if MICROPY_PY_NETWORK_PPP_LWIP
+
+#include "lwip/dns.h"
+#include "netif/ppp/ppp.h"
+#include "netif/ppp/pppapi.h"
+#include "netif/ppp/pppos.h"
+
+// Enable this to see the serial data going between the PPP layer.
+#define PPP_TRACE_IN_OUT (0)
+
+typedef enum {
+    STATE_INACTIVE,
+    STATE_ACTIVE,
+    STATE_ERROR,
+    STATE_CONNECTING,
+    STATE_CONNECTED,
+} network_ppp_state_t;
+
+typedef struct _network_ppp_obj_t {
+    mp_obj_base_t base;
+    network_ppp_state_t state;
+    int error_code;
+    mp_obj_t stream;
+    ppp_pcb *pcb;
+    struct netif netif;
+} network_ppp_obj_t;
+
+const mp_obj_type_t mp_network_ppp_lwip_type;
+
+static mp_obj_t network_ppp___del__(mp_obj_t self_in);
+
+static void network_ppp_status_cb(ppp_pcb *pcb, int err_code, void *ctx) {
+    network_ppp_obj_t *self = ctx;
+    switch (err_code) {
+        case PPPERR_NONE:
+            self->state = STATE_CONNECTED;
+            break;
+        case PPPERR_USER:
+            if (self->state >= STATE_ERROR) {
+                // Disable UART IRQ.
+                mp_obj_t dest[3];
+                mp_load_method(self->stream, MP_QSTR_irq, dest);
+                dest[2] = mp_const_none;
+                mp_call_method_n_kw(1, 0, dest);
+                // Indicate that the IRQ is disabled.
+                self->state = STATE_ACTIVE;
+            }
+            // Clean up the PPP PCB.
+            network_ppp___del__(MP_OBJ_FROM_PTR(self));
+            break;
+        default:
+            self->state = STATE_ERROR;
+            self->error_code = err_code;
+            break;
+    }
+}
+
+static mp_obj_t network_ppp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+
+    mp_obj_t stream = all_args[0];
+
+    mp_get_stream_raise(stream, MP_STREAM_OP_READ | MP_STREAM_OP_WRITE);
+
+    network_ppp_obj_t *self = mp_obj_malloc_with_finaliser(network_ppp_obj_t, type);
+    self->state = STATE_INACTIVE;
+    self->stream = stream;
+    self->pcb = NULL;
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+static mp_obj_t network_ppp___del__(mp_obj_t self_in) {
+    network_ppp_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->state >= STATE_ACTIVE) {
+        if (self->state >= STATE_ERROR) {
+            // Still connected over the UART stream.
+            // Force the connection to close, with nocarrier=1.
+            self->state = STATE_INACTIVE;
+            ppp_close(self->pcb, 1);
+        }
+        // Free PPP PCB and reset state.
+        self->state = STATE_INACTIVE;
+        ppp_free(self->pcb);
+        self->pcb = NULL;
+    }
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(network_ppp___del___obj, network_ppp___del__);
+
+static mp_obj_t network_ppp_poll(size_t n_args, const mp_obj_t *args) {
+    network_ppp_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    if (self->state <= STATE_ERROR) {
+        return MP_OBJ_NEW_SMALL_INT(-MP_EPERM);
+    }
+
+    mp_int_t total_len = 0;
+    for (;;) {
+        uint8_t buf[256];
+        int err;
+        mp_uint_t len = mp_stream_rw(self->stream, buf, sizeof(buf), &err, 0);
+        if (len == 0) {
+            break;
+        }
+        #if PPP_TRACE_IN_OUT
+        mp_printf(&mp_plat_print, "ppp_in(n=%u,data=", len);
+        for (size_t i = 0; i < len; ++i) {
+            mp_printf(&mp_plat_print, "%02x:", buf[i]);
+        }
+        mp_printf(&mp_plat_print, ")\n");
+        #endif
+        pppos_input(self->pcb, (u8_t *)buf, len);
+        total_len += len;
+    }
+
+    return MP_OBJ_NEW_SMALL_INT(total_len);
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_ppp_poll_obj, 1, 2, network_ppp_poll);
+
+static mp_obj_t network_ppp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    if (n_args != 1 && kwargs->used != 0) {
+        mp_raise_TypeError(MP_ERROR_TEXT("either pos or kw args are allowed"));
+    }
+    // network_ppp_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    if (kwargs->used != 0) {
+        for (size_t i = 0; i < kwargs->alloc; i++) {
+            if (mp_map_slot_is_filled(kwargs, i)) {
+                switch (mp_obj_str_get_qstr(kwargs->table[i].key)) {
+                    default:
+                        break;
+                }
+            }
+        }
+        return mp_const_none;
+    }
+
+    if (n_args != 2) {
+        mp_raise_TypeError(MP_ERROR_TEXT("can query only one param"));
+    }
+
+    mp_obj_t val = mp_const_none;
+
+    switch (mp_obj_str_get_qstr(args[1])) {
+        default:
+            mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+    }
+
+    return val;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(network_ppp_config_obj, 1, network_ppp_config);
+
+static mp_obj_t network_ppp_status(mp_obj_t self_in) {
+    network_ppp_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->state == STATE_ERROR) {
+        return MP_OBJ_NEW_SMALL_INT(-self->error_code);
+    } else {
+        return MP_OBJ_NEW_SMALL_INT(self->state);
+    }
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(network_ppp_status_obj, network_ppp_status);
+
+static u32_t network_ppp_output_callback(ppp_pcb *pcb, const void *data, u32_t len, void *ctx) {
+    network_ppp_obj_t *self = ctx;
+    #if PPP_TRACE_IN_OUT
+    mp_printf(&mp_plat_print, "ppp_out(n=%u,data=", len);
+    for (size_t i = 0; i < len; ++i) {
+        mp_printf(&mp_plat_print, "%02x:", ((const uint8_t *)data)[i]);
+    }
+    mp_printf(&mp_plat_print, ")\n");
+    #endif
+    int err;
+    // The return value from this output callback is the number of bytes written out.
+    // If it's less than the requested number of bytes then lwIP will propagate out an error.
+    return mp_stream_rw(self->stream, (void *)data, len, &err, MP_STREAM_RW_WRITE);
+}
+
+static mp_obj_t network_ppp_connect(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    enum { ARG_security, ARG_user, ARG_key };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_security, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PPPAUTHTYPE_NONE} },
+        { MP_QSTR_user, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+    };
+
+    mp_arg_val_t parsed_args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, parsed_args);
+
+    network_ppp_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    if (self->state == STATE_INACTIVE) {
+        self->pcb = pppos_create(&self->netif, network_ppp_output_callback, network_ppp_status_cb, self);
+        if (self->pcb == NULL) {
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("pppos_create failed"));
+        }
+        self->state = STATE_ACTIVE;
+
+        // Enable UART IRQ to call PPP.poll() when incoming data is ready.
+        mp_obj_t dest[4];
+        mp_load_method(self->stream, MP_QSTR_irq, dest);
+        dest[2] = mp_obj_new_bound_meth(MP_OBJ_FROM_PTR(&network_ppp_poll_obj), MP_OBJ_FROM_PTR(self));
+        dest[3] = mp_load_attr(self->stream, MP_QSTR_IRQ_RXIDLE);
+        mp_call_method_n_kw(2, 0, dest);
+    }
+
+    if (self->state == STATE_CONNECTING || self->state == STATE_CONNECTED) {
+        mp_raise_OSError(MP_EALREADY);
+    }
+
+    switch (parsed_args[ARG_security].u_int) {
+        case PPPAUTHTYPE_NONE:
+        case PPPAUTHTYPE_PAP:
+        case PPPAUTHTYPE_CHAP:
+            break;
+        default:
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid auth"));
+    }
+
+    if (parsed_args[ARG_security].u_int != PPPAUTHTYPE_NONE) {
+        const char *user_str = mp_obj_str_get_str(parsed_args[ARG_user].u_obj);
+        const char *key_str = mp_obj_str_get_str(parsed_args[ARG_key].u_obj);
+        ppp_set_auth(self->pcb, parsed_args[ARG_security].u_int, user_str, key_str);
+    }
+
+    netif_set_default(self->pcb->netif);
+    ppp_set_usepeerdns(self->pcb, true);
+
+    if (ppp_connect(self->pcb, 0) != ERR_OK) {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("ppp_connect failed"));
+    }
+
+    self->state = STATE_CONNECTING;
+
+    // Do a poll in case there is data waiting on the input stream.
+    network_ppp_poll(1, args);
+
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(network_ppp_connect_obj, 1, network_ppp_connect);
+
+static mp_obj_t network_ppp_disconnect(mp_obj_t self_in) {
+    network_ppp_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->state == STATE_CONNECTING || self->state == STATE_CONNECTED) {
+        // Initiate close and wait for PPPERR_USER callback.
+        ppp_close(self->pcb, 0);
+    }
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(network_ppp_disconnect_obj, network_ppp_disconnect);
+
+static mp_obj_t network_ppp_isconnected(mp_obj_t self_in) {
+    network_ppp_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_bool(self->state == STATE_CONNECTED);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(network_ppp_isconnected_obj, network_ppp_isconnected);
+
+static mp_obj_t network_ppp_ifconfig(size_t n_args, const mp_obj_t *args) {
+    network_ppp_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    return mod_network_nic_ifconfig(&self->netif, n_args - 1, args + 1);
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_ppp_ifconfig_obj, 1, 2, network_ppp_ifconfig);
+
+static mp_obj_t network_ppp_ipconfig(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    network_ppp_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    return mod_network_nic_ipconfig(&self->netif, n_args - 1, args + 1, kwargs);
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(network_ppp_ipconfig_obj, 1, network_ppp_ipconfig);
+
+static const mp_rom_map_elem_t network_ppp_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&network_ppp___del___obj) },
+    { MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&network_ppp_config_obj) },
+    { MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&network_ppp_status_obj) },
+    { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&network_ppp_connect_obj) },
+    { MP_ROM_QSTR(MP_QSTR_disconnect), MP_ROM_PTR(&network_ppp_disconnect_obj) },
+    { MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&network_ppp_isconnected_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&network_ppp_ifconfig_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ipconfig), MP_ROM_PTR(&network_ppp_ipconfig_obj) },
+    { MP_ROM_QSTR(MP_QSTR_poll), MP_ROM_PTR(&network_ppp_poll_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_SEC_NONE), MP_ROM_INT(PPPAUTHTYPE_NONE) },
+    { MP_ROM_QSTR(MP_QSTR_SEC_PAP), MP_ROM_INT(PPPAUTHTYPE_PAP) },
+    { MP_ROM_QSTR(MP_QSTR_SEC_CHAP), MP_ROM_INT(PPPAUTHTYPE_CHAP) },
+};
+static MP_DEFINE_CONST_DICT(network_ppp_locals_dict, network_ppp_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_network_ppp_lwip_type,
+    MP_QSTR_PPP,
+    MP_TYPE_FLAG_NONE,
+    make_new, network_ppp_make_new,
+    locals_dict, &network_ppp_locals_dict
+    );
+
+#endif