freedos-micro-python 0.1.0__py3-none-any.whl

freedos_micro_python/port/file_uc386dos.c

@@ -0,0 +1,228 @@
+// uc386-dos MicroPython file I/O — port-supplied `open()` /
+// `mp_import_stat()` / `mp_lexer_new_from_file()` backed by uc386's
+// libc INT 21h file syscalls. Mirrors the shape of
+// `extmod/vfs_posix_file.c` but without the VFS plumbing — we
+// implement the file-object type directly and define
+// `mp_builtin_open_obj` as the user-visible entry point.
+//
+// `open()` modes:
+//   "r"  read-only          (default)
+//   "w"  write, truncate, create
+//   "a"  write, append, create
+//   "+"  read-write
+//   "b"  binary             (FileIO; default if no "t")
+//   "t"  text               (TextIOWrapper, but we do bytes ↔ str)
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <errno.h>
+
+#include "py/builtin.h"
+#include "py/lexer.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "py/objstr.h"
+
+typedef struct _mp_obj_uc386dos_file_t {
+    mp_obj_base_t base;
+    int fd;  // -1 = closed
+} mp_obj_uc386dos_file_t;
+
+extern const mp_obj_type_t mp_type_uc386dos_textio;
+extern const mp_obj_type_t mp_type_uc386dos_fileio;
+
+// `mp_lexer_new_from_file` — read entire file into a buffer and feed
+// to the str-len lexer. Used by `import xxx` to load `xxx.py`.
+mp_lexer_t *mp_lexer_new_from_file(qstr filename) {
+    const char *fname = qstr_str(filename);
+    int fd = open(fname, O_RDONLY);
+    if (fd < 0) {
+        mp_raise_OSError(MP_ENOENT);
+    }
+    // Stat to get the file size. Avoids a grow-the-buffer loop.
+    struct stat st;
+    if (fstat(fd, &st) < 0) {
+        close(fd);
+        mp_raise_OSError(MP_EIO);
+    }
+    size_t size = (size_t)st.st_size;
+    char *buf = m_new(char, size + 1);
+    size_t got = 0;
+    while (got < size) {
+        int n = read(fd, buf + got, size - got);
+        if (n <= 0) {
+            break;
+        }
+        got += (size_t)n;
+    }
+    close(fd);
+    buf[got] = '\0';
+    return mp_lexer_new_from_str_len(filename, buf, got, 0);
+}
+
+// `mp_import_stat` — does `path` resolve to a file, dir, or
+// nothing? `import xxx` walks `sys.path` calling this for each
+// candidate path.
+mp_import_stat_t mp_import_stat(const char *path) {
+    struct stat st;
+    if (stat(path, &st) != 0) {
+        return MP_IMPORT_STAT_NO_EXIST;
+    }
+    if (S_ISDIR(st.st_mode)) {
+        return MP_IMPORT_STAT_DIR;
+    }
+    return MP_IMPORT_STAT_FILE;
+}
+
+// File-object methods.
+static void uc386dos_file_print(const mp_print_t *print, mp_obj_t self_in,
+                                mp_print_kind_t kind) {
+    (void)kind;
+    mp_obj_uc386dos_file_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "<io.%s %d>", mp_obj_get_type_str(self_in), self->fd);
+}
+
+static mp_uint_t uc386dos_file_read(mp_obj_t o_in, void *buf, mp_uint_t size,
+                                    int *errcode) {
+    mp_obj_uc386dos_file_t *o = MP_OBJ_TO_PTR(o_in);
+    if (o->fd < 0) {
+        *errcode = MP_EBADF;
+        return MP_STREAM_ERROR;
+    }
+    int r = read(o->fd, buf, size);
+    if (r < 0) {
+        *errcode = MP_EIO;
+        return MP_STREAM_ERROR;
+    }
+    return (mp_uint_t)r;
+}
+
+static mp_uint_t uc386dos_file_write(mp_obj_t o_in, const void *buf,
+                                     mp_uint_t size, int *errcode) {
+    mp_obj_uc386dos_file_t *o = MP_OBJ_TO_PTR(o_in);
+    if (o->fd < 0) {
+        *errcode = MP_EBADF;
+        return MP_STREAM_ERROR;
+    }
+    int r = write(o->fd, buf, size);
+    if (r < 0) {
+        *errcode = MP_EIO;
+        return MP_STREAM_ERROR;
+    }
+    return (mp_uint_t)r;
+}
+
+static mp_uint_t uc386dos_file_ioctl(mp_obj_t o_in, mp_uint_t request,
+                                     uintptr_t arg, int *errcode) {
+    mp_obj_uc386dos_file_t *o = MP_OBJ_TO_PTR(o_in);
+    if (request == MP_STREAM_SEEK) {
+        struct mp_stream_seek_t *s = (struct mp_stream_seek_t *)(uintptr_t)arg;
+        if (o->fd < 0) {
+            *errcode = MP_EBADF;
+            return MP_STREAM_ERROR;
+        }
+        int whence = (s->whence == 0) ? SEEK_SET
+                   : (s->whence == 1) ? SEEK_CUR
+                                      : SEEK_END;
+        long pos = lseek(o->fd, (long)s->offset, whence);
+        if (pos < 0) {
+            *errcode = MP_EIO;
+            return MP_STREAM_ERROR;
+        }
+        s->offset = (mp_off_t)pos;
+        return 0;
+    }
+    if (request == MP_STREAM_FLUSH) {
+        // No-op: DOS write() is unbuffered at the libc layer.
+        return 0;
+    }
+    if (request == MP_STREAM_CLOSE) {
+        if (o->fd >= 0) {
+            close(o->fd);
+            o->fd = -1;
+        }
+        return 0;
+    }
+    *errcode = MP_EINVAL;
+    return MP_STREAM_ERROR;
+}
+
+static const mp_rom_map_elem_t uc386dos_file_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_read),     MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write),    MP_ROM_PTR(&mp_stream_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close),    MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_seek),     MP_ROM_PTR(&mp_stream_seek_obj) },
+    { MP_ROM_QSTR(MP_QSTR_tell),     MP_ROM_PTR(&mp_stream_tell_obj) },
+    { MP_ROM_QSTR(MP_QSTR_flush),    MP_ROM_PTR(&mp_stream_flush_obj) },
+    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&mp_stream___exit___obj) },
+};
+static MP_DEFINE_CONST_DICT(uc386dos_file_locals_dict, uc386dos_file_locals_dict_table);
+
+static const mp_stream_p_t uc386dos_fileio_stream_p = {
+    .read = uc386dos_file_read,
+    .write = uc386dos_file_write,
+    .ioctl = uc386dos_file_ioctl,
+};
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_uc386dos_fileio, MP_QSTR_FileIO,
+    MP_TYPE_FLAG_NONE,
+    print, uc386dos_file_print,
+    protocol, &uc386dos_fileio_stream_p,
+    locals_dict, &uc386dos_file_locals_dict
+);
+
+static const mp_stream_p_t uc386dos_textio_stream_p = {
+    .read = uc386dos_file_read,
+    .write = uc386dos_file_write,
+    .ioctl = uc386dos_file_ioctl,
+    .is_text = true,
+};
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_uc386dos_textio, MP_QSTR_TextIOWrapper,
+    MP_TYPE_FLAG_NONE,
+    print, uc386dos_file_print,
+    protocol, &uc386dos_textio_stream_p,
+    locals_dict, &uc386dos_file_locals_dict
+);
+
+// `open(filename, mode="r")` — port-supplied entry point bound to
+// the `MP_QSTR_open` builtin via `mp_builtin_open_obj` below.
+static mp_obj_t uc386dos_builtin_open(size_t n_args, const mp_obj_t *args,
+                                      mp_map_t *kwargs) {
+    (void)kwargs;
+    const char *fname = mp_obj_str_get_str(args[0]);
+    const char *mode_s = "r";
+    if (n_args >= 2) {
+        mode_s = mp_obj_str_get_str(args[1]);
+    }
+    int mode_rw = O_RDONLY;
+    int mode_x = 0;
+    const mp_obj_type_t *type = &mp_type_uc386dos_textio;
+    while (*mode_s) {
+        switch (*mode_s++) {
+            case 'r': mode_rw = O_RDONLY; break;
+            case 'w': mode_rw = O_WRONLY; mode_x = O_CREAT | O_TRUNC; break;
+            case 'a': mode_rw = O_WRONLY; mode_x = O_CREAT | O_APPEND; break;
+            case '+': mode_rw = O_RDWR; break;
+            case 'b': type = &mp_type_uc386dos_fileio; break;
+            case 't': type = &mp_type_uc386dos_textio; break;
+        }
+    }
+    int fd = open(fname, mode_rw | mode_x, 0644);
+    if (fd < 0) {
+        mp_raise_OSError(MP_ENOENT);
+    }
+    mp_obj_uc386dos_file_t *f = mp_obj_malloc(mp_obj_uc386dos_file_t, type);
+    f->fd = fd;
+    return MP_OBJ_FROM_PTR(f);
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, uc386dos_builtin_open);

freedos_micro_python/port/lib/axtls/crypto/crypto.h

@@ -0,0 +1,45 @@
+// uc386-dos shim header that mimics the subset of axtls's crypto.h
+// used by upstream/extmod/modhashlib.c (when MICROPY_SSL_AXTLS=1).
+//
+// We don't actually link axtls — instead we route the AXTLS-shaped
+// API to Brad Conte's public-domain reference implementations
+// (`upstream/lib/crypto-algorithms/{md5,sha1}.[ch]`, fetched
+// alongside the existing sha256 sources). The B-Con API is nearly
+// identical: same MD5_CTX / SHA1_CTX typedef names, same Update
+// argument order. Only `*_Final` differs — axtls takes
+// `(digest, ctx)` while B-Con takes `(ctx, digest)` — so we wrap.
+//
+// Setting MICROPY_SSL_AXTLS=1 in mpconfigport.h tells modhashlib.c
+// to take the AXTLS branch of its #if cascade. We don't enable the
+// rest of axtls (TLS, RSA, AES, ...); the single include below is
+// sufficient for hashlib.md5 and hashlib.sha1.
+#ifndef UCDOS_AXTLS_CRYPTO_SHIM_H
+#define UCDOS_AXTLS_CRYPTO_SHIM_H
+
+#include "lib/crypto-algorithms/md5.h"
+#include "lib/crypto-algorithms/sha1.h"
+
+#define MD5_SIZE  16
+#define SHA1_SIZE 20
+
+static inline void MD5_Init(MD5_CTX *ctx) {
+    md5_init(ctx);
+}
+static inline void MD5_Update(MD5_CTX *ctx, const unsigned char *msg, int len) {
+    md5_update(ctx, msg, (size_t)len);
+}
+static inline void MD5_Final(unsigned char *digest, MD5_CTX *ctx) {
+    md5_final(ctx, digest);
+}
+
+static inline void SHA1_Init(SHA1_CTX *ctx) {
+    sha1_init(ctx);
+}
+static inline void SHA1_Update(SHA1_CTX *ctx, const unsigned char *msg, int len) {
+    sha1_update(ctx, msg, (size_t)len);
+}
+static inline void SHA1_Final(unsigned char *digest, SHA1_CTX *ctx) {
+    sha1_final(ctx, digest);
+}
+
+#endif  // UCDOS_AXTLS_CRYPTO_SHIM_H

freedos_micro_python/port/lwip-arch-cc.h

@@ -0,0 +1,46 @@
+// uc386-dos lwIP `arch/cc.h` shim. Included via `-I` rather than
+// the conventional `arch/cc.h` path because uc386's preprocessor
+// doesn't have a per-port arch include directory convention.
+// build_port.sh adds `uc386-dos/` to the include path AND aliases
+// the conventional name via a stub at uc386-dos/arch/cc.h that
+// just `#include`s this file.
+
+#ifndef LWIP_ARCH_CC_H
+#define LWIP_ARCH_CC_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+// Endianness — i386 is little-endian.
+#define BYTE_ORDER LITTLE_ENDIAN
+#ifndef LITTLE_ENDIAN
+#define LITTLE_ENDIAN 1234
+#define BIG_ENDIAN    4321
+#endif
+
+// Packed structs — uc386 honors `__attribute__((packed))` (member
+// byte-alignment, struct alignment 1). lwIP's init.c self-tests the
+// layout via `sizeof(struct { u8; u32; } __packed) == 5` at boot;
+// without real packing this fails because u32 lands at offset 4.
+// The other PACK_STRUCT_* slots (BEGIN/END/FIELD) remain empty —
+// upstream's lwip/arch.h defines them that way for GCC/clang.
+#define PACK_STRUCT_FIELD(x) x
+#define PACK_STRUCT_STRUCT __attribute__((packed))
+#define PACK_STRUCT_BEGIN
+#define PACK_STRUCT_END
+
+// Diagnostics — route lwIP's debug printf through the regular
+// printf chain. LWIP_DEBUG=0 in lwipopts.h makes these no-ops in
+// the common case.
+#include <stdio.h>
+#define LWIP_PLATFORM_DIAG(x) do { printf x; } while (0)
+
+// sys_prot_t — a critical-section level. We're NO_SYS=1 with no
+// real interrupts to mask, so use a stub type and let lwipopts.h's
+// SYS_ARCH_* macros expand to nothing.
+typedef uint32_t sys_prot_t;
+
+// strerror — uc386's libc has it.
+
+#endif  // LWIP_ARCH_CC_H

freedos_micro_python/port/lwip_uc386dos.c

@@ -0,0 +1,248 @@
+// uc386-dos lwIP port glue. Provides:
+//   - sys_now() — millisecond tick from BIOS (INT 1Ah AH=0).
+//   - lwip_uc386dos_init() — calls lwip_init() once + adds the
+//     loopback netif. Called from main.c at boot.
+//   - mp_module_socket — re-export of lwIP's mp_module_lwip under
+//     `MP_QSTR_socket` so `import socket` lights up the BSD-style
+//     surface modlwip.c provides.
+//
+// We don't ship modnetwork.c — that's the higher-level network
+// configuration interface used by ports with WLAN/Ethernet drivers.
+// For loopback-only Phase 1 testing, the raw socket surface
+// (modlwip.c → MP_QSTR_socket) is sufficient.
+
+#include <string.h>
+
+#include "py/runtime.h"
+#include "lwip/init.h"
+#include "lwip/timeouts.h"
+#include "lwip/netif.h"
+#include "lwip/dhcp.h"
+#include "lwip/etharp.h"
+#include "lwip/pbuf.h"
+#include "netif/ethernet.h"
+#if LWIP_HAVE_LOOPIF
+#include "lwip/sys.h"
+#endif
+
+// INT 0x83 packet-driver shim — see lib/i386_dos_libc.asm. dos_emu
+// intercepts and routes to a NetworkSimulator (sim mode).
+extern int ethdrv_init(unsigned char mac[6]);
+extern int ethdrv_send(const unsigned char *buf, unsigned int len);
+extern unsigned int ethdrv_recv(unsigned char *buf, unsigned int maxlen);
+
+// Crynwr packet-driver bindings (real-DOS path) — pktdrv_uc386dos.c.
+// Returns 0 on success when a "PKT DRVR" signature is found in the
+// IVT 0x60–0x7F range; otherwise we fall back to the INT 0x83 sim.
+extern int pktdrv_init(unsigned char mac[6]);
+extern int pktdrv_send(const unsigned char *buf, unsigned int len);
+extern unsigned int pktdrv_recv(unsigned char *buf, unsigned int maxlen);
+extern int pktdrv_is_active(void);
+
+// `bios_ticks()` from lib/i386_dos_libc.asm — INT 1Ah AH=0 read of
+// the BIOS tick counter (~18.2 Hz). Multiply by 55 for an
+// approximate millisecond clock; lwIP's timeouts only need
+// monotonic ms, not absolute wall time, so the small drift is fine.
+extern unsigned bios_ticks(void);
+
+uint32_t sys_now(void) {
+    return bios_ticks() * 55u;
+}
+
+#if LWIP_HAVE_LOOPIF
+// One-shot lwIP init. Call from `main()` after mp_init.
+// Loopback netif is auto-added by lwip_init() when LWIP_HAVE_LOOPIF
+// is on, so we just call lwip_init() and we're done.
+void lwip_uc386dos_init(void) {
+    lwip_init();
+}
+#endif
+
+// Drive periodic timer checks. Call from the REPL idle loop or a
+// dedicated tick. modlwip.c expects sys_check_timeouts() to be
+// pumped regularly so TCP retransmits / DNS timeouts fire.
+void lwip_uc386dos_poll(void) {
+    sys_check_timeouts();
+}
+
+// Stub for `mp_mod_network_prefer_dns_use_ip_version` — modlwip.c
+// reads it inside getaddrinfo() to pick AF_INET vs AF_INET6 ordering.
+// modnetwork.c (which we don't compile) defines it as a real global;
+// we ship the stub here defaulting to IPv4 preferred. If we ever
+// turn LWIP_IPV6 on, switch this to 6 or wire modnetwork properly.
+int mp_mod_network_prefer_dns_use_ip_version = 4;
+
+// modlwip.c also references the hostname buffer that modnetwork.c
+// otherwise owns. Provide a stub matching the symbol shape.
+char mod_network_hostname_data[16 + 1] = "uc386-dos";
+
+// ---- Virtual ethernet netif (uc386dos_eth) ---------------------
+//
+// A second netif on top of the INT 0x83 packet-driver shim. Used
+// for DHCP discovery and any non-loopback IPv4 traffic the program
+// wants. Stays separate from the loopback netif so 127.0.0.1 traffic
+// doesn't bounce off the wire.
+//
+// Frame path:
+//   TX: lwIP → etharp_output → ethdrv_send → INT 0x83 AH=1
+//                                          → dos_emu hook
+//                                          → NetworkSimulator
+//   RX: ethdrv_recv (INT 0x83 AH=2) → pbuf_alloc + take
+//                                   → ethernet_input → ip_input
+// Pumped from `uc386dos_loopback_poll` (which is wired in as
+// modlwip's poll-list hook), so `lwip.callback()` drives both
+// loopback delivery and eth RX in one shot.
+
+static struct netif uc386dos_eth_netif;
+static int uc386dos_eth_active = 0;
+
+// Static TX scratch — one outgoing frame at a time, no concurrency
+// since NO_SYS=1 + single-threaded REPL. Sized to lwIP MTU + eth hdr.
+static unsigned char uc386dos_eth_tx_buf[1500 + 14];
+static unsigned char uc386dos_eth_rx_buf[1500 + 14];
+
+static err_t uc386dos_eth_linkoutput(struct netif *netif, struct pbuf *p) {
+    (void)netif;
+    if (p->tot_len > sizeof(uc386dos_eth_tx_buf)) {
+        return ERR_IF;
+    }
+    pbuf_copy_partial(p, uc386dos_eth_tx_buf, p->tot_len, 0);
+    int rc;
+    if (pktdrv_is_active()) {
+        rc = pktdrv_send(uc386dos_eth_tx_buf, p->tot_len);
+    } else {
+        rc = ethdrv_send(uc386dos_eth_tx_buf, p->tot_len);
+    }
+    return (rc != 0) ? ERR_IF : ERR_OK;
+}
+
+static err_t uc386dos_eth_netif_init_cb(struct netif *netif) {
+    netif->name[0] = 'e';
+    netif->name[1] = 'n';
+    netif->output = etharp_output;
+    netif->linkoutput = uc386dos_eth_linkoutput;
+    netif->mtu = 1500;
+    netif->hwaddr_len = 6;
+    netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP
+                 | NETIF_FLAG_ETHERNET;
+    // hwaddr is filled in by uc386dos_eth_start() before netif_add.
+    return ERR_OK;
+}
+
+// Pull queued frames from the RX path and feed them into lwIP.
+// When Crynwr is the active driver, drain `pktdrv_recv` — under
+// dos_emu the harness fills the buffer through AH=0x99 polling
+// registration; on real DOS this requires a DPMI INT 31h fn 0x0303
+// trampoline (see pktdrv_uc386dos.c) that's still TODO. With INT
+// 0x83 sim active, drain `ethdrv_recv` instead. The two never
+// coexist in a single boot.
+static void uc386dos_eth_pump_rx(void) {
+    if (!uc386dos_eth_active) {
+        return;
+    }
+    for (;;) {
+        unsigned int len = pktdrv_is_active()
+            ? pktdrv_recv(uc386dos_eth_rx_buf,
+                          sizeof(uc386dos_eth_rx_buf))
+            : ethdrv_recv(uc386dos_eth_rx_buf,
+                          sizeof(uc386dos_eth_rx_buf));
+        if (len == 0) {
+            break;
+        }
+        struct pbuf *p = pbuf_alloc(PBUF_RAW, (u16_t)len, PBUF_POOL);
+        if (p == NULL) {
+            // Drop the frame; lwIP will time out and retransmit.
+            continue;
+        }
+        pbuf_take(p, uc386dos_eth_rx_buf, (u16_t)len);
+        if (uc386dos_eth_netif.input(p, &uc386dos_eth_netif) != ERR_OK) {
+            pbuf_free(p);
+        }
+    }
+}
+
+// Bring the eth netif up. Calls INT 0x83 to fetch the host-assigned
+// MAC, registers the netif, and (if dhcp_start_now) kicks off DHCP
+// discovery. Idempotent — second call is a no-op.
+int uc386dos_eth_start(int dhcp_start_now) {
+    if (uc386dos_eth_active) {
+        return 0;
+    }
+    unsigned char mac[6];
+    // Try a real Crynwr packet driver first (so the same binary
+    // lights up on hardware when one's loaded). Fall back to the
+    // INT 0x83 sim — what dos_emu provides without a fake Crynwr.
+    if (pktdrv_init(mac) != 0 && ethdrv_init(mac) != 0) {
+        return -1;
+    }
+    ip4_addr_t ip0, nm0, gw0;
+    ip0.addr = 0;
+    nm0.addr = 0;
+    gw0.addr = 0;
+    if (netif_add(&uc386dos_eth_netif, &ip0, &nm0, &gw0, NULL,
+                  uc386dos_eth_netif_init_cb, ethernet_input) == NULL) {
+        return -2;
+    }
+    memcpy(uc386dos_eth_netif.hwaddr, mac, 6);
+    netif_set_default(&uc386dos_eth_netif);
+    netif_set_up(&uc386dos_eth_netif);
+    netif_set_link_up(&uc386dos_eth_netif);
+    uc386dos_eth_active = 1;
+    if (dhcp_start_now) {
+        if (dhcp_start(&uc386dos_eth_netif) != ERR_OK) {
+            return -3;
+        }
+    }
+    return 0;
+}
+
+// Static-IP override path for tests / environments where DHCP isn't
+// available. Caller has already run uc386dos_eth_start(False) so the
+// netif exists; this just clears any DHCP state and writes the
+// addresses directly.
+void uc386dos_eth_set_addr(unsigned int ip, unsigned int mask, unsigned int gw) {
+    if (!uc386dos_eth_active) return;
+    dhcp_release_and_stop(&uc386dos_eth_netif);
+    ip4_addr_t a, n, g;
+    a.addr = ip; n.addr = mask; g.addr = gw;
+    netif_set_addr(&uc386dos_eth_netif, &a, &n, &g);
+    netif_set_up(&uc386dos_eth_netif);
+}
+
+// Read-back helpers for the Python-facing module to inspect state.
+unsigned int uc386dos_eth_ip(void)      { return uc386dos_eth_netif.ip_addr.addr; }
+unsigned int uc386dos_eth_netmask(void) { return uc386dos_eth_netif.netmask.addr; }
+unsigned int uc386dos_eth_gateway(void) { return uc386dos_eth_netif.gw.addr; }
+int uc386dos_eth_is_up(void)            { return uc386dos_eth_active && netif_is_up(&uc386dos_eth_netif); }
+
+// 0 = no eth init yet, 1 = INT 0x83 sim, 2 = Crynwr packet driver.
+int uc386dos_eth_driver(void) {
+    if (!uc386dos_eth_active) return 0;
+    return pktdrv_is_active() ? 2 : 1;
+}
+
+// Loopback packet pump. With LWIP_NETIF_LOOPBACK=1 + NO_SYS=1, lwIP
+// queues outgoing-to-127.0.0.1 packets in netif->loop_first/last and
+// only delivers them when netif_poll(netif) is called. The loopback
+// netif (`loop_netif`) is created by netif_init() but isn't promoted
+// to `netif_default`, so use netif_poll_all() — it walks every netif
+// on `netif_list` and is provided when LWIP_NETIF_LOOPBACK_MULTITHREADING
+// is 0 (our case). Registered from mod_lwip_reset (patched in
+// fetch.sh) so each `lwip.reset()` re-arms the loopback pump
+// alongside the usual sys_check_timeouts() cadence. Also drains the
+// virtual-eth RX queue so DHCP responses + ARP replies land.
+void uc386dos_loopback_poll(void *arg) {
+    (void)arg;
+    extern int write(int fd, const void *buf, unsigned int n);
+    write(1, "[lp:np]", 7);
+    netif_poll_all();
+    write(1, "[lp:rx]", 7);
+    uc386dos_eth_pump_rx();
+    write(1, "[lp:done]", 9);
+}
+
+// Expose `mp_module_lwip` as `socket` too. modlwip.c registers
+// itself under MP_QSTR_lwip and MP_QSTR_socket via `MP_REGISTER_*`
+// markers — but our hand-rolled moduledefs.h doesn't process those.
+// The `socket` registration goes through UCDOS_MOD_ENTRY_SOCKET in
+// build.sh's heredoc; we don't need any C-side glue for that.

freedos_micro_python/port/lwipopts.h

@@ -0,0 +1,117 @@
+// uc386-dos lwipopts.h — minimum-viable config for IPv4-only TCP/UDP
+// with loopback testing. No threading (NO_SYS=1), no DHCP for now,
+// no IPv6, no stats. Just enough surface so MICROPY_PY_LWIP=1 can
+// expose `socket` and a Python program can `socket.socket()`,
+// `bind`, `listen`, `connect`, `send`, `recv` over 127.0.0.1.
+//
+// Tuning will follow once we have real packet I/O wired up — DHCP
+// + DNS + a real netif driver are deferred until the dos-emu fake
+// packet driver (or real-DOS testing) lands.
+
+#ifndef MICROPY_INCLUDED_LWIPOPTS_H
+#define MICROPY_INCLUDED_LWIPOPTS_H
+
+// MicroPython's modlwip.c uses the raw API (tcp_new etc.) on a
+// single-threaded foreground loop. NO_SYS=1 disables the
+// thread-aware netconn/socket API and the rtos abstractions —
+// matches the rp2 / esp32-port shape for raw-mode lwip.
+#define NO_SYS                          1
+#define LWIP_RAW                        1
+#define LWIP_NETCONN                    0
+#define LWIP_SOCKET                     0
+#define LWIP_NETIF_API                  0
+
+// Core protocols. ARP+IP for the link layer, ICMP+IGMP for control,
+// TCP+UDP for transport, DNS for name resolution, AUTOIP for fallback
+// addressing when DHCP isn't running.
+#define LWIP_ARP                        1
+#define LWIP_ETHERNET                   1
+#define LWIP_IPV4                       1
+#define LWIP_IPV6                       0
+#define LWIP_ICMP                       1
+#define LWIP_IGMP                       1
+#define LWIP_TCP                        1
+#define LWIP_UDP                        1
+#define LWIP_DNS                        1
+#define LWIP_DHCP                       1
+#define LWIP_AUTOIP                     0
+#define LWIP_ACD                        0
+#define LWIP_DHCP_DOES_ACD_CHECK        0  // ACD off → don't probe
+#define LWIP_DHCP_BOOTP_FILE            0
+#define LWIP_DHCP_GET_NTP_SRV           0
+#define LWIP_DHCP_PROVIDE_DNS_SERVERS   1  // accept DNS from option 6
+// dhcp.c includes <stddef.h> via lwIP's def.h, then time.h via
+// timeouts.h's chain — both typedef size_t under _SIZE_T_DEFINED.
+// stddef.h's separate _PTRDIFF_T_DEFINED guard (fixed in lib/include)
+// keeps ptrdiff_t reachable.
+
+// Loopback — lets unit tests bind/connect 127.0.0.1 to itself
+// without any real netif driver. Phase 1 testing relies entirely
+// on this; phase 2 will add a packet-driver netif alongside.
+#define LWIP_HAVE_LOOPIF                1
+#define LWIP_NETIF_LOOPBACK             1
+#define LWIP_LOOPBACK_MAX_PBUFS         8
+
+// Memory. uc386's GC heap is 256 KB total — keep lwIP's footprint
+// modest. These knobs roughly mirror the minimal-port config from
+// upstream lwIP examples.
+#define MEM_ALIGNMENT                   4
+#define MEM_SIZE                        4096
+#define MEMP_NUM_PBUF                   16
+#define MEMP_NUM_RAW_PCB                4
+#define MEMP_NUM_UDP_PCB                4
+#define MEMP_NUM_TCP_PCB                4
+#define MEMP_NUM_TCP_PCB_LISTEN         4
+#define MEMP_NUM_TCP_SEG                16
+#define MEMP_NUM_REASSDATA              4
+#define MEMP_NUM_FRAG_PBUF              4
+#define MEMP_NUM_ARP_QUEUE              2
+#define MEMP_NUM_IGMP_GROUP             2
+#define MEMP_NUM_SYS_TIMEOUT            8
+#define PBUF_POOL_SIZE                  16
+#define PBUF_POOL_BUFSIZE               256
+#define TCP_MSS                         536
+#define TCP_WND                         (4 * TCP_MSS)
+#define TCP_SND_BUF                     (4 * TCP_MSS)
+#define TCP_SND_QUEUELEN                (4 * (TCP_SND_BUF / TCP_MSS))
+
+// Statistics off — saves a few KB.
+#define LWIP_STATS                      0
+
+// LWIP_DEBUG is INTENTIONALLY left undefined here. err.h gates
+// `extern const char *lwip_strerr(err_t)` on `#ifdef LWIP_DEBUG`,
+// so even `#define LWIP_DEBUG 0` is enough to pull in the extern
+// reference (which isn't satisfied because lwip_strerr's
+// definition lives behind LWIP_DEBUG too). Leaving it undefined
+// makes err.h fall through to `#define lwip_strerr(x) ""`.
+
+// Critical-section primitives. NO_SYS=1 with no real interrupts
+// to mask, so make these all no-ops. modlwip.c's tcpip thread
+// abstraction uses both macro and function forms — provide both.
+#define SYS_ARCH_DECL_PROTECT(lev)   do { } while (0)
+#define SYS_ARCH_PROTECT(lev)        do { } while (0)
+#define SYS_ARCH_UNPROTECT(lev)      do { } while (0)
+#define sys_arch_protect()           ((sys_prot_t)0)
+#define sys_arch_unprotect(lev)      do { (void)(lev); } while (0)
+
+// We don't have an OS to call. Print the assert message + abort()
+// so the dos_emu test path surfaces which assertion tripped (the
+// message + filename + line make it down to stdout before exit).
+#include <stdio.h>
+#define LWIP_PLATFORM_ASSERT(x) \
+    do { printf("lwIP assert: %s at %s:%d\n", (x), __FILE__, __LINE__); \
+         abort(); } while (0)
+
+// Use the standard lwip_htons/lwip_htonl from def.c — uc386 doesn't
+// ship a system byteorder.h.
+// (Don't define LWIP_DONT_PROVIDE_BYTEORDER_FUNCTIONS — that path
+// expects htons/htonl etc. to come from elsewhere.)
+
+// Random — lwIP's DNS uses LWIP_RAND() for transaction IDs / port
+// allocation. Route through libc's `random()` (LCG, seeded by
+// MICROPY_PY_RANDOM_SEED_INIT_FUNC's bios_ticks() at boot). Not
+// crypto-strength, but transaction-ID strength is fine.
+extern long random(void);
+#define LWIP_RAND() ((unsigned long)random())
+
+#endif  // MICROPY_INCLUDED_LWIPOPTS_H