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

freedos_micro_python/port/shutil_uc386dos.c

@@ -0,0 +1,111 @@
+// uc386-dos `shutil` module — file copy/move utilities backed by
+// the libc open/read/write path (which routes through INT 21h via
+// uc386's libc). Lean stdlib match — `copy` / `copyfile` / `move`
+// are the everyday cases; rmtree / chown / chmod aren't useful on
+// DOS so we don't ship them.
+//
+// `move` tries os.rename first (atomic for same-volume moves under
+// DOS) and falls back to copy + unlink for cross-drive moves where
+// rename returns an error.
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "py/runtime.h"
+#include "py/objstr.h"
+#include "py/mperrno.h"
+
+// 4 KB buffer is a reasonable middle ground — small enough to live
+// on the stack inside `_copy_stream` without bloating frame size,
+// large enough that the per-call read/write syscall overhead doesn't
+// dominate even on slow DOS disks.
+#define SHUTIL_COPY_BUF_SIZE 4096
+
+static void copy_stream(int src_fd, int dst_fd) {
+    char buf[SHUTIL_COPY_BUF_SIZE];
+    for (;;) {
+        int n = read(src_fd, buf, sizeof(buf));
+        if (n < 0) {
+            mp_raise_OSError(MP_EIO);
+        }
+        if (n == 0) {
+            break;
+        }
+        int written = 0;
+        while (written < n) {
+            int w = write(dst_fd, buf + written, n - written);
+            if (w <= 0) {
+                mp_raise_OSError(MP_EIO);
+            }
+            written += w;
+        }
+    }
+}
+
+// `shutil.copyfile(src, dst)` — overwrites dst if it exists.
+// Returns dst (matching CPython).
+static mp_obj_t shutil_copyfile(mp_obj_t src_in, mp_obj_t dst_in) {
+    const char *src = mp_obj_str_get_str(src_in);
+    const char *dst = mp_obj_str_get_str(dst_in);
+
+    int src_fd = open(src, 0);  // O_RDONLY
+    if (src_fd < 0) {
+        mp_raise_OSError(MP_ENOENT);
+    }
+    // Open dst write+truncate. Our libc routes a writable open
+    // through INT 21h AH=0x3C (CREATE), which truncates if the
+    // file exists.
+    int dst_fd = open(dst, 1);  // O_WRONLY -> our libc handles create-or-truncate
+    if (dst_fd < 0) {
+        close(src_fd);
+        mp_raise_OSError(MP_EIO);
+    }
+    copy_stream(src_fd, dst_fd);
+    close(src_fd);
+    close(dst_fd);
+    return dst_in;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(shutil_copyfile_obj, shutil_copyfile);
+
+// `shutil.copy(src, dst)` — alias for copyfile here. CPython
+// preserves permissions through this call but DOS has none worth
+// preserving, so the simpler form suffices.
+static mp_obj_t shutil_copy(mp_obj_t src_in, mp_obj_t dst_in) {
+    return shutil_copyfile(src_in, dst_in);
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(shutil_copy_obj, shutil_copy);
+
+// `shutil.move(src, dst)` — atomic rename when both ends sit on
+// the same DOS volume; falls back to copy + unlink across volumes
+// (which DOS rejects with INT 21h AH=0x56 → CF set, error 17).
+static mp_obj_t shutil_move(mp_obj_t src_in, mp_obj_t dst_in) {
+    const char *src = mp_obj_str_get_str(src_in);
+    const char *dst = mp_obj_str_get_str(dst_in);
+
+    if (rename(src, dst) == 0) {
+        return dst_in;
+    }
+    // Cross-volume or other rename failure — fall back to
+    // copy + unlink.
+    shutil_copyfile(src_in, dst_in);
+    if (unlink(src) != 0) {
+        mp_raise_OSError(MP_EIO);
+    }
+    return dst_in;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(shutil_move_obj, shutil_move);
+
+static const mp_rom_map_elem_t mp_module_shutil_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_shutil) },
+    { MP_ROM_QSTR(MP_QSTR_copyfile), MP_ROM_PTR(&shutil_copyfile_obj) },
+    { MP_ROM_QSTR(MP_QSTR_copy),     MP_ROM_PTR(&shutil_copy_obj) },
+    { MP_ROM_QSTR(MP_QSTR_move),     MP_ROM_PTR(&shutil_move_obj) },
+};
+static MP_DEFINE_CONST_DICT(mp_module_shutil_globals, mp_module_shutil_globals_table);
+
+const mp_obj_module_t mp_module_shutil = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&mp_module_shutil_globals,
+};

freedos_micro_python/port/tempfile_uc386dos.c

@@ -0,0 +1,129 @@
+// uc386-dos `tempfile` module — minimal CPython-compat shim.
+//
+// Surface:
+//   tempfile.gettempdir()        → str (TEMP env var, falls back to "C:\\")
+//   tempfile.mktemp(suffix='', prefix='tmp', dir=None)
+//                                → str path that doesn't exist yet
+//
+// We deliberately don't ship `mkstemp` (returns an fd) or
+// `NamedTemporaryFile` (context manager) — both want to atomically
+// create-and-open and DOS doesn't have O_EXCL semantics worth
+// relying on. The CPython gotcha "mktemp is unsafe" applies here
+// too, but the htget pattern that motivated the addition (download
+// to a temp path, validate, rename) doesn't care: only one process
+// is running at a time.
+
+#include <string.h>
+#include <stdio.h>
+
+#include "py/runtime.h"
+#include "py/objstr.h"
+#include "py/mperrno.h"
+
+// libc lookups — getenv comes from lib/i386_dos_libc.asm.
+extern const char *getenv(const char *name);
+// stat() probe to avoid handing out an existing path.
+#include <sys/stat.h>
+
+// Counter ratchets across mktemp() calls within a single REPL
+// session. Combined with the BIOS-tick seed we get from PID-less
+// DOS, this is enough collision avoidance for single-user
+// scripting.
+static unsigned tmp_counter = 0;
+
+static mp_obj_t tempfile_gettempdir(void) {
+    const char *t = getenv("TEMP");
+    if (!t) {
+        t = getenv("TMP");
+    }
+    if (!t || !*t) {
+        // Fallback: root of the boot drive. Most FreeDOS systems
+        // boot off C:; if that's wrong the user can SET TEMP=...
+        t = "C:\\";
+    }
+    return mp_obj_new_str(t, strlen(t));
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(tempfile_gettempdir_obj, tempfile_gettempdir);
+
+// `tempfile.mktemp(suffix='', prefix='tmp', dir=None)` — return
+// a string path that doesn't currently exist. Doesn't create the
+// file (intentionally — caller decides open() flags).
+static mp_obj_t tempfile_mktemp(size_t n_args, const mp_obj_t *pos_args,
+                                mp_map_t *kw_args) {
+    static const mp_arg_t allowed[] = {
+        { MP_QSTR_suffix, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_)} },
+        { MP_QSTR_prefix, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_tmp)} },
+        { MP_QSTR_dir,    MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed),
+                     allowed, args);
+    const char *suffix = mp_obj_str_get_str(args[0].u_obj);
+    const char *prefix = mp_obj_str_get_str(args[1].u_obj);
+    const char *dir;
+    if (args[2].u_obj == mp_const_none) {
+        const char *t = getenv("TEMP");
+        if (!t) t = getenv("TMP");
+        if (!t || !*t) t = "C:\\";
+        dir = t;
+    } else {
+        dir = mp_obj_str_get_str(args[2].u_obj);
+    }
+
+    // Loop probing names until we find one stat() rejects.
+    char name[80];
+    struct stat st;
+    for (int attempt = 0; attempt < 1024; attempt++) {
+        unsigned n = ++tmp_counter;
+        // Build "<dir>\\<prefix><N><suffix>". Cap dir so the result
+        // fits the DOS 8.3-ish filesystem comfortably.
+        size_t dir_len = strlen(dir);
+        if (dir_len > 60) dir_len = 60;
+        memcpy(name, dir, dir_len);
+        size_t pos = dir_len;
+        if (pos > 0 && name[pos - 1] != '\\' && name[pos - 1] != '/') {
+            name[pos++] = '\\';
+        }
+        size_t prefix_len = strlen(prefix);
+        if (prefix_len > 8) prefix_len = 8;
+        memcpy(name + pos, prefix, prefix_len);
+        pos += prefix_len;
+        // 5-digit decimal counter.
+        char digits[6];
+        int dlen = 0;
+        unsigned v = n;
+        do {
+            digits[dlen++] = '0' + (v % 10);
+            v /= 10;
+        } while (v && dlen < 5);
+        // Pad to 5.
+        while (dlen < 5) digits[dlen++] = '0';
+        for (int i = dlen - 1; i >= 0; i--) {
+            name[pos++] = digits[i];
+        }
+        size_t suffix_len = strlen(suffix);
+        if (pos + suffix_len + 1 > sizeof(name)) {
+            mp_raise_OSError(MP_E2BIG);
+        }
+        memcpy(name + pos, suffix, suffix_len);
+        pos += suffix_len;
+        name[pos] = '\0';
+        if (stat(name, &st) != 0) {
+            return mp_obj_new_str(name, pos);
+        }
+    }
+    mp_raise_OSError(MP_EEXIST);
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(tempfile_mktemp_obj, 0, tempfile_mktemp);
+
+static const mp_rom_map_elem_t mp_module_tempfile_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__),    MP_ROM_QSTR(MP_QSTR_tempfile) },
+    { MP_ROM_QSTR(MP_QSTR_gettempdir),  MP_ROM_PTR(&tempfile_gettempdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mktemp),      MP_ROM_PTR(&tempfile_mktemp_obj) },
+};
+static MP_DEFINE_CONST_DICT(mp_module_tempfile_globals, mp_module_tempfile_globals_table);
+
+const mp_obj_module_t mp_module_tempfile = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&mp_module_tempfile_globals,
+};

freedos_micro_python/port/time_real_uc386dos.c

@@ -0,0 +1,77 @@
+// Real time() / mktime() / gettimeofday() backed by the DOS RTC
+// (INT 21h AH=0x2A + 0x2C via libc's _dos_get_datetime). axtls's
+// cert verification path needs both:
+//   - mktime() to convert each cert's parsed notBefore/notAfter
+//     calendar fields into a Unix epoch second count
+//   - gettimeofday() to get the current epoch second to compare
+//     against those bounds (x509.c:506,513)
+//
+// The libc stubs we shipped at SSL bringup (returning 0 / a fake
+// counter) made every cert look "currently valid forever," which
+// is fine for CONFIG_SSL_CERT_VERIFICATION=undef but obviously
+// wrong once the flag is on.
+//
+// Calendar→epoch uses Howard Hinnant's "days from civil"
+// algorithm (no table lookups, no leap-year branches; works for
+// any Gregorian year). For DOS dates (1980–2099) the year is
+// always positive so we skip the negative-y branch.
+//
+// We replace libc.asm's `_time`, `_mktime`, `_gettimeofday`
+// (those stubs are removed). The libc wrappers compiled into
+// every TU's bundle now `extern` to these symbols.
+
+#include <time.h>
+#include <sys/time.h>
+
+extern void dos_get_datetime(unsigned char out[7]);
+
+// Returns days since 1970-01-01 for the given (year, month, day).
+// Month is 1-12, day is 1-31. Assumes year >= 0 (DOS minimum is 1980).
+static long days_from_civil(int y, unsigned m, unsigned d) {
+    y -= (m <= 2);
+    long era = y / 400;
+    unsigned yoe = (unsigned)(y - era * 400);              // [0, 399]
+    unsigned m_adj = (m > 2) ? (m - 3) : (m + 9);          // [0, 11], March=0
+    unsigned doy = (153u * m_adj + 2u) / 5u + d - 1u;      // [0, 365]
+    unsigned doe = yoe * 365u + yoe / 4u - yoe / 100u + doy;
+    return era * 146097L + (long)doe - 719468L;
+}
+
+static time_t epoch_now(void) {
+    unsigned char raw[7];
+    dos_get_datetime(raw);
+    int year = (int)(raw[0] | (raw[1] << 8));
+    long days = days_from_civil(year, raw[2], raw[3]);
+    long secs_today = (long)raw[4] * 3600L + (long)raw[5] * 60L + (long)raw[6];
+    return (time_t)(days * 86400L + secs_today);
+}
+
+time_t time(time_t *t) {
+    time_t now = epoch_now();
+    if (t) {
+        *t = now;
+    }
+    return now;
+}
+
+time_t mktime(struct tm *tm) {
+    if (tm == 0) {
+        return (time_t)-1;
+    }
+    long days = days_from_civil(tm->tm_year + 1900,
+                                (unsigned)(tm->tm_mon + 1),
+                                (unsigned)tm->tm_mday);
+    long secs_today = (long)tm->tm_hour * 3600L
+                    + (long)tm->tm_min * 60L
+                    + (long)tm->tm_sec;
+    return (time_t)(days * 86400L + secs_today);
+}
+
+int gettimeofday(struct timeval *tv, void *tz) {
+    (void)tz;
+    if (tv) {
+        tv->tv_sec = epoch_now();
+        tv->tv_usec = 0;  // DOS clock is second-precision
+    }
+    return 0;
+}

freedos_micro_python/port/uc386_net_uc386dos.c

@@ -0,0 +1,126 @@
+// uc386-dos `uc386_net` module — control surface for the lwIP eth
+// netif sitting on top of the INT 0x83 packet-driver shim.
+//
+// Surface (Python):
+//   uc386_net.eth_init(use_dhcp=True) -> rc:int
+//     Bring up the virtual eth netif. If use_dhcp, kicks off DHCP
+//     discovery; the address won't be ready until enough
+//     `lwip.callback()` ticks have run for the DHCP server to
+//     respond. Returns 0 on success, negative on error.
+//   uc386_net.eth_status() -> (ip, netmask, gateway, up:bool)
+//     IP/netmask/gateway as dotted-quad strings (zero-string when
+//     unset). `up` reflects netif_is_up() AND init has run.
+
+#include <stdio.h>
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/obj.h"
+
+extern int uc386dos_eth_start(int dhcp_start_now);
+extern void uc386dos_eth_set_addr(unsigned int ip, unsigned int mask, unsigned int gw);
+extern unsigned int uc386dos_eth_ip(void);
+extern unsigned int uc386dos_eth_netmask(void);
+extern unsigned int uc386dos_eth_gateway(void);
+extern int uc386dos_eth_is_up(void);
+extern int uc386dos_eth_driver(void);
+extern volatile unsigned int pktdrv_thunk_invocations;
+extern volatile unsigned int pktdrv_thunk_phase0_count;
+extern volatile unsigned int pktdrv_thunk_phase1_count;
+extern unsigned int pktdrv_last_handle;
+extern unsigned int pktdrv_dpmi_seg;
+extern unsigned int pktdrv_dpmi_off;
+
+static unsigned int parse_ip4(const char *s) {
+    unsigned int parts[4] = {0};
+    int idx = 0;
+    while (*s && idx < 4) {
+        unsigned int v = 0;
+        while (*s >= '0' && *s <= '9') {
+            v = v * 10 + (*s - '0');
+            s++;
+        }
+        parts[idx++] = v & 0xff;
+        if (*s == '.') s++;
+    }
+    return parts[0] | (parts[1] << 8) | (parts[2] << 16) | (parts[3] << 24);
+}
+
+static mp_obj_t mod_uc386_net_ip4_to_str(unsigned int addr) {
+    char buf[16];
+    int n = snprintf(buf, sizeof(buf), "%u.%u.%u.%u",
+                     (unsigned)(addr & 0xff),
+                     (unsigned)((addr >> 8) & 0xff),
+                     (unsigned)((addr >> 16) & 0xff),
+                     (unsigned)((addr >> 24) & 0xff));
+    if (n < 0 || (size_t)n >= sizeof(buf)) {
+        n = 0;
+    }
+    return mp_obj_new_str(buf, (size_t)n);
+}
+
+static mp_obj_t mod_uc386_net_eth_init(size_t n_args, const mp_obj_t *args) {
+    int use_dhcp = 1;
+    if (n_args > 0) {
+        use_dhcp = mp_obj_is_true(args[0]) ? 1 : 0;
+    }
+    int rc = uc386dos_eth_start(use_dhcp);
+    return MP_OBJ_NEW_SMALL_INT(rc);
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(
+    mod_uc386_net_eth_init_obj, 0, 1, mod_uc386_net_eth_init);
+
+static mp_obj_t mod_uc386_net_eth_status(void) {
+    mp_obj_t items[5];
+    items[0] = mod_uc386_net_ip4_to_str(uc386dos_eth_ip());
+    items[1] = mod_uc386_net_ip4_to_str(uc386dos_eth_netmask());
+    items[2] = mod_uc386_net_ip4_to_str(uc386dos_eth_gateway());
+    items[3] = uc386dos_eth_is_up() ? mp_const_true : mp_const_false;
+    // 0=none, 1="int83-sim", 2="pktdrv"
+    int drv = uc386dos_eth_driver();
+    const char *drv_name =
+        (drv == 2) ? "pktdrv" :
+        (drv == 1) ? "int83-sim" : "none";
+    items[4] = mp_obj_new_str(drv_name, strlen(drv_name));
+    return mp_obj_new_tuple(5, items);
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(
+    mod_uc386_net_eth_status_obj, mod_uc386_net_eth_status);
+
+static mp_obj_t mod_uc386_net_eth_set_static(mp_obj_t ip_obj, mp_obj_t mask_obj, mp_obj_t gw_obj) {
+    const char *ip_s   = mp_obj_str_get_str(ip_obj);
+    const char *mask_s = mp_obj_str_get_str(mask_obj);
+    const char *gw_s   = mp_obj_str_get_str(gw_obj);
+    uc386dos_eth_set_addr(parse_ip4(ip_s), parse_ip4(mask_s), parse_ip4(gw_s));
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_3(
+    mod_uc386_net_eth_set_static_obj, mod_uc386_net_eth_set_static);
+
+static mp_obj_t mod_uc386_net_pktdrv_diag(void) {
+    mp_obj_t items[6];
+    items[0] = MP_OBJ_NEW_SMALL_INT(pktdrv_thunk_invocations);
+    items[1] = MP_OBJ_NEW_SMALL_INT(pktdrv_thunk_phase0_count);
+    items[2] = MP_OBJ_NEW_SMALL_INT(pktdrv_thunk_phase1_count);
+    items[3] = MP_OBJ_NEW_SMALL_INT(pktdrv_last_handle);
+    items[4] = MP_OBJ_NEW_SMALL_INT(pktdrv_dpmi_seg);
+    items[5] = MP_OBJ_NEW_SMALL_INT(pktdrv_dpmi_off);
+    return mp_obj_new_tuple(6, items);
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(
+    mod_uc386_net_pktdrv_diag_obj, mod_uc386_net_pktdrv_diag);
+
+static const mp_rom_map_elem_t mp_module_uc386_net_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__),   MP_ROM_QSTR(MP_QSTR_uc386_net) },
+    { MP_ROM_QSTR(MP_QSTR_eth_init),   MP_ROM_PTR(&mod_uc386_net_eth_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_eth_status), MP_ROM_PTR(&mod_uc386_net_eth_status_obj) },
+    { MP_ROM_QSTR(MP_QSTR_eth_set_static), MP_ROM_PTR(&mod_uc386_net_eth_set_static_obj) },
+    { MP_ROM_QSTR(MP_QSTR_pktdrv_diag), MP_ROM_PTR(&mod_uc386_net_pktdrv_diag_obj) },
+};
+static MP_DEFINE_CONST_DICT(
+    mp_module_uc386_net_globals, mp_module_uc386_net_globals_table);
+
+const mp_obj_module_t mp_module_uc386_net = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&mp_module_uc386_net_globals,
+};