Adding upstream version 0.37.0.upstream/0.37.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 904 insertions, 0 deletions

diff --git a/osdep/io.c b/osdep/io.c
new file mode 100644
index 0000000..bdf79f8
--- /dev/null
+++ b/osdep/io.c
@@ -0,0 +1,904 @@
+/*
+ * unicode/utf-8 I/O helpers and wrappers for Windows
+ *
+ * Contains parts based on libav code (http://libav.org).
+ *
+ * This file is part of mpv.
+ *
+ * mpv is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * mpv is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <limits.h>
+#include <unistd.h>
+
+#include "mpv_talloc.h"
+
+#include "config.h"
+#include "misc/random.h"
+#include "osdep/io.h"
+#include "osdep/terminal.h"
+
+#if HAVE_UWP
+// Missing from MinGW headers.
+#include <windows.h>
+WINBASEAPI UINT WINAPI GetTempFileNameW(LPCWSTR lpPathName, LPCWSTR lpPrefixString,
+                                        UINT uUnique, LPWSTR lpTempFileName);
+WINBASEAPI DWORD WINAPI GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer);
+WINBASEAPI DWORD WINAPI GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength,
+                                         LPWSTR lpBuffer, LPWSTR *lpFilePart);
+#endif
+
+// Set the CLOEXEC flag on the given fd.
+// On error, false is returned (and errno set).
+bool mp_set_cloexec(int fd)
+{
+#if defined(F_SETFD)
+    if (fd >= 0) {
+        int flags = fcntl(fd, F_GETFD);
+        if (flags == -1)
+            return false;
+        if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1)
+            return false;
+    }
+#endif
+    return true;
+}
+
+#ifdef __MINGW32__
+int mp_make_cloexec_pipe(int pipes[2])
+{
+    pipes[0] = pipes[1] = -1;
+    return -1;
+}
+#else
+int mp_make_cloexec_pipe(int pipes[2])
+{
+    if (pipe(pipes) != 0) {
+        pipes[0] = pipes[1] = -1;
+        return -1;
+    }
+
+    for (int i = 0; i < 2; i++)
+        mp_set_cloexec(pipes[i]);
+    return 0;
+}
+#endif
+
+#ifdef __MINGW32__
+int mp_make_wakeup_pipe(int pipes[2])
+{
+    return mp_make_cloexec_pipe(pipes);
+}
+#else
+// create a pipe, and set it to non-blocking (and also set FD_CLOEXEC)
+int mp_make_wakeup_pipe(int pipes[2])
+{
+    if (mp_make_cloexec_pipe(pipes) < 0)
+        return -1;
+
+    for (int i = 0; i < 2; i++) {
+        int val = fcntl(pipes[i], F_GETFL) | O_NONBLOCK;
+        fcntl(pipes[i], F_SETFL, val);
+    }
+    return 0;
+}
+#endif
+
+void mp_flush_wakeup_pipe(int pipe_end)
+{
+#ifndef __MINGW32__
+    char buf[100];
+    (void)read(pipe_end, buf, sizeof(buf));
+#endif
+}
+
+#ifdef _WIN32
+
+#include <windows.h>
+#include <wchar.h>
+#include <stdio.h>
+#include <stddef.h>
+
+//copied and modified from libav
+//http://git.libav.org/?p=libav.git;a=blob;f=libavformat/os_support.c;h=a0fcd6c9ba2be4b0dbcc476f6c53587345cc1152;hb=HEADl30
+
+wchar_t *mp_from_utf8(void *talloc_ctx, const char *s)
+{
+    int count = MultiByteToWideChar(CP_UTF8, 0, s, -1, NULL, 0);
+    if (count <= 0)
+        abort();
+    wchar_t *ret = talloc_array(talloc_ctx, wchar_t, count);
+    MultiByteToWideChar(CP_UTF8, 0, s, -1, ret, count);
+    return ret;
+}
+
+char *mp_to_utf8(void *talloc_ctx, const wchar_t *s)
+{
+    int count = WideCharToMultiByte(CP_UTF8, 0, s, -1, NULL, 0, NULL, NULL);
+    if (count <= 0)
+        abort();
+    char *ret = talloc_array(talloc_ctx, char, count);
+    WideCharToMultiByte(CP_UTF8, 0, s, -1, ret, count, NULL, NULL);
+    return ret;
+}
+
+#endif // _WIN32
+
+#ifdef __MINGW32__
+
+#include <io.h>
+#include <fcntl.h>
+#include "osdep/threads.h"
+
+static void set_errno_from_lasterror(void)
+{
+    // This just handles the error codes expected from CreateFile at the moment
+    switch (GetLastError()) {
+    case ERROR_FILE_NOT_FOUND:
+        errno = ENOENT;
+        break;
+    case ERROR_SHARING_VIOLATION:
+    case ERROR_ACCESS_DENIED:
+        errno = EACCES;
+        break;
+    case ERROR_FILE_EXISTS:
+    case ERROR_ALREADY_EXISTS:
+        errno = EEXIST;
+        break;
+    case ERROR_PIPE_BUSY:
+        errno = EAGAIN;
+        break;
+    default:
+        errno = EINVAL;
+        break;
+    }
+}
+
+static time_t filetime_to_unix_time(int64_t wintime)
+{
+    static const int64_t hns_per_second = 10000000ll;
+    static const int64_t win_to_unix_epoch = 11644473600ll;
+    return wintime / hns_per_second - win_to_unix_epoch;
+}
+
+static bool get_file_ids_win8(HANDLE h, dev_t *dev, ino_t *ino)
+{
+    FILE_ID_INFO ii;
+    if (!GetFileInformationByHandleEx(h, FileIdInfo, &ii, sizeof(ii)))
+        return false;
+    *dev = ii.VolumeSerialNumber;
+    // The definition of FILE_ID_128 differs between mingw-w64 and the Windows
+    // SDK, but we can ignore that by just memcpying it. This will also
+    // truncate the file ID on 32-bit Windows, which doesn't support __int128.
+    // 128-bit file IDs are only used for ReFS, so that should be okay.
+    assert(sizeof(*ino) <= sizeof(ii.FileId));
+    memcpy(ino, &ii.FileId, sizeof(*ino));
+    return true;
+}
+
+#if HAVE_UWP
+static bool get_file_ids(HANDLE h, dev_t *dev, ino_t *ino)
+{
+    return false;
+}
+#else
+static bool get_file_ids(HANDLE h, dev_t *dev, ino_t *ino)
+{
+    // GetFileInformationByHandle works on FAT partitions and Windows 7, but
+    // doesn't work in UWP and can produce non-unique IDs on ReFS
+    BY_HANDLE_FILE_INFORMATION bhfi;
+    if (!GetFileInformationByHandle(h, &bhfi))
+        return false;
+    *dev = bhfi.dwVolumeSerialNumber;
+    *ino = ((ino_t)bhfi.nFileIndexHigh << 32) | bhfi.nFileIndexLow;
+    return true;
+}
+#endif
+
+// Like fstat(), but with a Windows HANDLE
+static int hstat(HANDLE h, struct mp_stat *buf)
+{
+    // Handle special (or unknown) file types first
+    switch (GetFileType(h) & ~FILE_TYPE_REMOTE) {
+    case FILE_TYPE_PIPE:
+        *buf = (struct mp_stat){ .st_nlink = 1, .st_mode = _S_IFIFO | 0644 };
+        return 0;
+    case FILE_TYPE_CHAR: // character device
+        *buf = (struct mp_stat){ .st_nlink = 1, .st_mode = _S_IFCHR | 0644 };
+        return 0;
+    case FILE_TYPE_UNKNOWN:
+        errno = EBADF;
+        return -1;
+    }
+
+    struct mp_stat st = { 0 };
+
+    FILE_BASIC_INFO bi;
+    if (!GetFileInformationByHandleEx(h, FileBasicInfo, &bi, sizeof(bi))) {
+        errno = EBADF;
+        return -1;
+    }
+    st.st_atime = filetime_to_unix_time(bi.LastAccessTime.QuadPart);
+    st.st_mtime = filetime_to_unix_time(bi.LastWriteTime.QuadPart);
+    st.st_ctime = filetime_to_unix_time(bi.ChangeTime.QuadPart);
+
+    FILE_STANDARD_INFO si;
+    if (!GetFileInformationByHandleEx(h, FileStandardInfo, &si, sizeof(si))) {
+        errno = EBADF;
+        return -1;
+    }
+    st.st_nlink = si.NumberOfLinks;
+
+    // Here we pretend Windows has POSIX permissions by pretending all
+    // directories are 755 and regular files are 644
+    if (si.Directory) {
+        st.st_mode |= _S_IFDIR | 0755;
+    } else {
+        st.st_mode |= _S_IFREG | 0644;
+        st.st_size = si.EndOfFile.QuadPart;
+    }
+
+    if (!get_file_ids_win8(h, &st.st_dev, &st.st_ino)) {
+        // Fall back to the Windows 7 method (also used for FAT in Win8)
+        if (!get_file_ids(h, &st.st_dev, &st.st_ino)) {
+            errno = EBADF;
+            return -1;
+        }
+    }
+
+    *buf = st;
+    return 0;
+}
+
+int mp_stat(const char *path, struct mp_stat *buf)
+{
+    wchar_t *wpath = mp_from_utf8(NULL, path);
+    HANDLE h = CreateFileW(wpath, FILE_READ_ATTRIBUTES,
+        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
+        OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | SECURITY_SQOS_PRESENT |
+        SECURITY_IDENTIFICATION, NULL);
+    talloc_free(wpath);
+    if (h == INVALID_HANDLE_VALUE) {
+        set_errno_from_lasterror();
+        return -1;
+    }
+
+    int ret = hstat(h, buf);
+    CloseHandle(h);
+    return ret;
+}
+
+int mp_fstat(int fd, struct mp_stat *buf)
+{
+    HANDLE h = (HANDLE)_get_osfhandle(fd);
+    if (h == INVALID_HANDLE_VALUE) {
+        errno = EBADF;
+        return -1;
+    }
+    // Use mpv's hstat() function rather than MSVCRT's fstat() because mpv's
+    // supports directories and device/inode numbers.
+    return hstat(h, buf);
+}
+
+#if HAVE_UWP
+static int mp_vfprintf(FILE *stream, const char *format, va_list args)
+{
+    return vfprintf(stream, format, args);
+}
+#else
+static int mp_check_console(HANDLE wstream)
+{
+    if (wstream != INVALID_HANDLE_VALUE) {
+        unsigned int filetype = GetFileType(wstream);
+
+        if (!((filetype == FILE_TYPE_UNKNOWN) &&
+            (GetLastError() != ERROR_SUCCESS)))
+        {
+            filetype &= ~(FILE_TYPE_REMOTE);
+
+            if (filetype == FILE_TYPE_CHAR) {
+                DWORD ConsoleMode;
+                int ret = GetConsoleMode(wstream, &ConsoleMode);
+
+                if (!(!ret && (GetLastError() == ERROR_INVALID_HANDLE))) {
+                    // This seems to be a console
+                    return 1;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int mp_vfprintf(FILE *stream, const char *format, va_list args)
+{
+    int done = 0;
+
+    HANDLE wstream = INVALID_HANDLE_VALUE;
+
+    if (stream == stdout || stream == stderr) {
+        wstream = GetStdHandle(stream == stdout ?
+                               STD_OUTPUT_HANDLE : STD_ERROR_HANDLE);
+    }
+
+    if (mp_check_console(wstream)) {
+        size_t len = vsnprintf(NULL, 0, format, args) + 1;
+        char *buf = talloc_array(NULL, char, len);
+
+        if (buf) {
+            done = vsnprintf(buf, len, format, args);
+            mp_write_console_ansi(wstream, buf);
+        }
+        talloc_free(buf);
+    } else {
+        done = vfprintf(stream, format, args);
+    }
+
+    return done;
+}
+#endif
+
+int mp_fprintf(FILE *stream, const char *format, ...)
+{
+    int res;
+    va_list args;
+    va_start(args, format);
+    res = mp_vfprintf(stream, format, args);
+    va_end(args);
+    return res;
+}
+
+int mp_printf(const char *format, ...)
+{
+    int res;
+    va_list args;
+    va_start(args, format);
+    res = mp_vfprintf(stdout, format, args);
+    va_end(args);
+    return res;
+}
+
+int mp_open(const char *filename, int oflag, ...)
+{
+    // Always use all share modes, which is useful for opening files that are
+    // open in other processes, and also more POSIX-like
+    static const DWORD share =
+        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
+    // Setting FILE_APPEND_DATA and avoiding GENERIC_WRITE/FILE_WRITE_DATA
+    // will make the file handle use atomic append behavior
+    static const DWORD append =
+        FILE_APPEND_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA;
+
+    DWORD access = 0;
+    DWORD disposition = 0;
+    DWORD flags = 0;
+
+    switch (oflag & (_O_RDONLY | _O_RDWR | _O_WRONLY | _O_APPEND)) {
+    case _O_RDONLY:
+        access = GENERIC_READ;
+        flags |= FILE_FLAG_BACKUP_SEMANTICS; // For opening directories
+        break;
+    case _O_RDWR:
+        access = GENERIC_READ | GENERIC_WRITE;
+        break;
+    case _O_RDWR | _O_APPEND:
+    case _O_RDONLY | _O_APPEND:
+        access = GENERIC_READ | append;
+        break;
+    case _O_WRONLY:
+        access = GENERIC_WRITE;
+        break;
+    case _O_WRONLY | _O_APPEND:
+        access = append;
+        break;
+    default:
+        errno = EINVAL;
+        return -1;
+    }
+
+    switch (oflag & (_O_CREAT | _O_EXCL | _O_TRUNC)) {
+    case 0:
+    case _O_EXCL: // Like MSVCRT, ignore invalid use of _O_EXCL
+        disposition = OPEN_EXISTING;
+        break;
+    case _O_TRUNC:
+    case _O_TRUNC | _O_EXCL:
+        disposition = TRUNCATE_EXISTING;
+        break;
+    case _O_CREAT:
+        disposition = OPEN_ALWAYS;
+        flags |= FILE_ATTRIBUTE_NORMAL;
+        break;
+    case _O_CREAT | _O_TRUNC:
+        disposition = CREATE_ALWAYS;
+        break;
+    case _O_CREAT | _O_EXCL:
+    case _O_CREAT | _O_EXCL | _O_TRUNC:
+        disposition = CREATE_NEW;
+        flags |= FILE_ATTRIBUTE_NORMAL;
+        break;
+    }
+
+    // Opening a named pipe as a file can allow the pipe server to impersonate
+    // mpv's process, which could be a security issue. Set SQOS flags, so pipe
+    // servers can only identify the mpv process, not impersonate it.
+    if (disposition != CREATE_NEW)
+        flags |= SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION;
+
+    // Keep the same semantics for some MSVCRT-specific flags
+    if (oflag & _O_TEMPORARY) {
+        flags |= FILE_FLAG_DELETE_ON_CLOSE;
+        access |= DELETE;
+    }
+    if (oflag & _O_SHORT_LIVED)
+        flags |= FILE_ATTRIBUTE_TEMPORARY;
+    if (oflag & _O_SEQUENTIAL) {
+        flags |= FILE_FLAG_SEQUENTIAL_SCAN;
+    } else if (oflag & _O_RANDOM) {
+        flags |= FILE_FLAG_RANDOM_ACCESS;
+    }
+
+    // Open the Windows file handle
+    wchar_t *wpath = mp_from_utf8(NULL, filename);
+    HANDLE h = CreateFileW(wpath, access, share, NULL, disposition, flags, NULL);
+    talloc_free(wpath);
+    if (h == INVALID_HANDLE_VALUE) {
+        set_errno_from_lasterror();
+        return -1;
+    }
+
+    // Map the Windows file handle to a CRT file descriptor. Note: MSVCRT only
+    // cares about the following oflags.
+    oflag &= _O_APPEND | _O_RDONLY | _O_RDWR | _O_WRONLY;
+    oflag |= _O_NOINHERIT; // We never create inheritable handles
+    int fd = _open_osfhandle((intptr_t)h, oflag);
+    if (fd < 0) {
+        CloseHandle(h);
+        return -1;
+    }
+
+    return fd;
+}
+
+int mp_creat(const char *filename, int mode)
+{
+    return mp_open(filename, _O_CREAT | _O_WRONLY | _O_TRUNC, mode);
+}
+
+int mp_rename(const char *oldpath, const char *newpath)
+{
+    wchar_t *woldpath = mp_from_utf8(NULL, oldpath),
+        *wnewpath = mp_from_utf8(NULL, newpath);
+    BOOL ok = MoveFileExW(woldpath, wnewpath, MOVEFILE_REPLACE_EXISTING);
+    talloc_free(woldpath);
+    talloc_free(wnewpath);
+    if (!ok) {
+        set_errno_from_lasterror();
+        return -1;
+    }
+    return 0;
+}
+
+FILE *mp_fopen(const char *filename, const char *mode)
+{
+    if (!mode[0]) {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    int rwmode;
+    int oflags = 0;
+    switch (mode[0]) {
+    case 'r':
+        rwmode = _O_RDONLY;
+        break;
+    case 'w':
+        rwmode = _O_WRONLY;
+        oflags |= _O_CREAT | _O_TRUNC;
+        break;
+    case 'a':
+        rwmode = _O_WRONLY;
+        oflags |= _O_CREAT | _O_APPEND;
+        break;
+    default:
+        errno = EINVAL;
+        return NULL;
+    }
+
+    // Parse extra mode flags
+    for (const char *pos = mode + 1; *pos; pos++) {
+        switch (*pos) {
+        case '+': rwmode = _O_RDWR;  break;
+        case 'x': oflags |= _O_EXCL; break;
+        // Ignore unknown flags (glibc does too)
+        default: break;
+        }
+    }
+
+    // Open a CRT file descriptor
+    int fd = mp_open(filename, rwmode | oflags);
+    if (fd < 0)
+        return NULL;
+
+    // Add 'b' to the mode so the CRT knows the file is opened in binary mode
+    char bmode[] = { mode[0], 'b', rwmode == _O_RDWR ? '+' : '\0', '\0' };
+    FILE *fp = fdopen(fd, bmode);
+    if (!fp) {
+        close(fd);
+        return NULL;
+    }
+
+    return fp;
+}
+
+// Windows' MAX_PATH/PATH_MAX/FILENAME_MAX is fixed to 260, but this limit
+// applies to unicode paths encoded with wchar_t (2 bytes on Windows). The UTF-8
+// version could end up bigger in memory. In the worst case each wchar_t is
+// encoded to 3 bytes in UTF-8, so in the worst case we have:
+//      wcslen(wpath) * 3 <= strlen(utf8path)
+// Thus we need MP_PATH_MAX as the UTF-8/char version of PATH_MAX.
+// Also make sure there's free space for the terminating \0.
+// (For codepoints encoded as UTF-16 surrogate pairs, UTF-8 has the same length.)
+#define MP_PATH_MAX (FILENAME_MAX * 3 + 1)
+
+struct mp_dir {
+    DIR crap;   // must be first member
+    _WDIR *wdir;
+    union {
+        struct dirent dirent;
+        // dirent has space only for FILENAME_MAX bytes. _wdirent has space for
+        // FILENAME_MAX wchar_t, which might end up bigger as UTF-8 in some
+        // cases. Guarantee we can always hold _wdirent.d_name converted to
+        // UTF-8 (see MP_PATH_MAX).
+        // This works because dirent.d_name is the last member of dirent.
+        char space[MP_PATH_MAX];
+    };
+};
+
+DIR* mp_opendir(const char *path)
+{
+    wchar_t *wpath = mp_from_utf8(NULL, path);
+    _WDIR *wdir = _wopendir(wpath);
+    talloc_free(wpath);
+    if (!wdir)
+        return NULL;
+    struct mp_dir *mpdir = talloc(NULL, struct mp_dir);
+    // DIR is supposed to be opaque, but unfortunately the MinGW headers still
+    // define it. Make sure nobody tries to use it.
+    memset(&mpdir->crap, 0xCD, sizeof(mpdir->crap));
+    mpdir->wdir = wdir;
+    return (DIR*)mpdir;
+}
+
+struct dirent* mp_readdir(DIR *dir)
+{
+    struct mp_dir *mpdir = (struct mp_dir*)dir;
+    struct _wdirent *wdirent = _wreaddir(mpdir->wdir);
+    if (!wdirent)
+        return NULL;
+    size_t buffersize = sizeof(mpdir->space) - offsetof(struct dirent, d_name);
+    WideCharToMultiByte(CP_UTF8, 0, wdirent->d_name, -1, mpdir->dirent.d_name,
+                        buffersize, NULL, NULL);
+    mpdir->dirent.d_ino = 0;
+    mpdir->dirent.d_reclen = 0;
+    mpdir->dirent.d_namlen = strlen(mpdir->dirent.d_name);
+    return &mpdir->dirent;
+}
+
+int mp_closedir(DIR *dir)
+{
+    struct mp_dir *mpdir = (struct mp_dir*)dir;
+    int res = _wclosedir(mpdir->wdir);
+    talloc_free(mpdir);
+    return res;
+}
+
+int mp_mkdir(const char *path, int mode)
+{
+    wchar_t *wpath = mp_from_utf8(NULL, path);
+    int res = _wmkdir(wpath);
+    talloc_free(wpath);
+    return res;
+}
+
+char *mp_win32_getcwd(char *buf, size_t size)
+{
+    if (size >= SIZE_MAX / 3 - 1) {
+        errno = ENOMEM;
+        return NULL;
+    }
+    size_t wbuffer = size * 3 + 1;
+    wchar_t *wres = talloc_array(NULL, wchar_t, wbuffer);
+    DWORD wlen = GetFullPathNameW(L".", wbuffer, wres, NULL);
+    if (wlen >= wbuffer || wlen == 0) {
+        talloc_free(wres);
+        errno = wlen ? ERANGE : ENOENT;
+        return NULL;
+    }
+    char *t = mp_to_utf8(NULL, wres);
+    talloc_free(wres);
+    size_t st = strlen(t);
+    if (st >= size) {
+        talloc_free(t);
+        errno = ERANGE;
+        return NULL;
+    }
+    memcpy(buf, t, st + 1);
+    talloc_free(t);
+    return buf;
+}
+
+static char **utf8_environ;
+static void *utf8_environ_ctx;
+
+static void free_env(void)
+{
+    talloc_free(utf8_environ_ctx);
+    utf8_environ_ctx = NULL;
+    utf8_environ = NULL;
+}
+
+// Note: UNIX getenv() returns static strings, and we try to do the same. Since
+// using putenv() is not multithreading safe, we don't expect env vars to change
+// at runtime, and converting/allocating them in advance is ok.
+static void init_getenv(void)
+{
+#if !HAVE_UWP
+    wchar_t *wenv = GetEnvironmentStringsW();
+    if (!wenv)
+        return;
+    utf8_environ_ctx = talloc_new(NULL);
+    int num_env = 0;
+    while (1) {
+        size_t len = wcslen(wenv);
+        if (!len)
+            break;
+        char *s = mp_to_utf8(utf8_environ_ctx, wenv);
+        MP_TARRAY_APPEND(utf8_environ_ctx, utf8_environ, num_env, s);
+        wenv += len + 1;
+    }
+    MP_TARRAY_APPEND(utf8_environ_ctx, utf8_environ, num_env, NULL);
+    // Avoid showing up in leak detectors etc.
+    atexit(free_env);
+#endif
+}
+
+char *mp_getenv(const char *name)
+{
+    static mp_once once_init_getenv = MP_STATIC_ONCE_INITIALIZER;
+    mp_exec_once(&once_init_getenv, init_getenv);
+    // Copied from musl, http://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+    // Copyright © 2005-2013 Rich Felker, standard MIT license
+    int i;
+    size_t l = strlen(name);
+    if (!utf8_environ || !*name || strchr(name, '=')) return NULL;
+    for (i=0; utf8_environ[i] && (strncmp(name, utf8_environ[i], l)
+            || utf8_environ[i][l] != '='); i++) {}
+    if (utf8_environ[i]) return utf8_environ[i] + l+1;
+    return NULL;
+}
+
+char ***mp_penviron(void)
+{
+    mp_getenv("");  // ensure init
+    return &utf8_environ;  // `environ' should be an l-value
+}
+
+off_t mp_lseek(int fd, off_t offset, int whence)
+{
+    HANDLE h = (HANDLE)_get_osfhandle(fd);
+    if (h != INVALID_HANDLE_VALUE && GetFileType(h) != FILE_TYPE_DISK) {
+        errno = ESPIPE;
+        return (off_t)-1;
+    }
+    return _lseeki64(fd, offset, whence);
+}
+
+_Thread_local
+static struct {
+    DWORD errcode;
+    char *errstring;
+} mp_dl_result = {
+    .errcode = 0,
+    .errstring = NULL
+};
+
+static void mp_dl_free(void)
+{
+    if (mp_dl_result.errstring != NULL) {
+        talloc_free(mp_dl_result.errstring);
+    }
+}
+
+static void mp_dl_init(void)
+{
+    atexit(mp_dl_free);
+}
+
+void *mp_dlopen(const char *filename, int flag)
+{
+    wchar_t *wfilename = mp_from_utf8(NULL, filename);
+    HMODULE lib = LoadLibraryW(wfilename);
+    talloc_free(wfilename);
+    mp_dl_result.errcode = GetLastError();
+    return (void *)lib;
+}
+
+void *mp_dlsym(void *handle, const char *symbol)
+{
+    FARPROC addr = GetProcAddress((HMODULE)handle, symbol);
+    mp_dl_result.errcode = GetLastError();
+    return (void *)addr;
+}
+
+char *mp_dlerror(void)
+{
+    static mp_once once_init_dlerror = MP_STATIC_ONCE_INITIALIZER;
+    mp_exec_once(&once_init_dlerror, mp_dl_init);
+    mp_dl_free();
+
+    if (mp_dl_result.errcode == 0)
+        return NULL;
+
+    // convert error code to a string message
+    LPWSTR werrstring = NULL;
+    FormatMessageW(
+        FORMAT_MESSAGE_FROM_SYSTEM
+            | FORMAT_MESSAGE_IGNORE_INSERTS
+            | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+        NULL,
+        mp_dl_result.errcode,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
+        (LPWSTR) &werrstring,
+        0,
+        NULL);
+    mp_dl_result.errcode = 0;
+
+    if (werrstring) {
+        mp_dl_result.errstring = mp_to_utf8(NULL, werrstring);
+        LocalFree(werrstring);
+    }
+
+    return mp_dl_result.errstring == NULL
+        ? "unknown error"
+        : mp_dl_result.errstring;
+}
+
+#if HAVE_UWP
+void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
+{
+    errno = ENOSYS;
+    return MAP_FAILED;
+}
+
+int munmap(void *addr, size_t length)
+{
+    errno = ENOSYS;
+    return -1;
+}
+
+int msync(void *addr, size_t length, int flags)
+{
+    errno = ENOSYS;
+    return -1;
+}
+#else
+// Limited mmap() wrapper, inspired by:
+// http://code.google.com/p/mman-win32/source/browse/trunk/mman.c
+
+void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
+{
+    assert(addr == NULL); // not implemented
+    assert(flags == MAP_SHARED); // not implemented
+
+    HANDLE osf = (HANDLE)_get_osfhandle(fd);
+    if (!osf) {
+        errno = EBADF;
+        return MAP_FAILED;
+    }
+
+    DWORD protect = 0;
+    DWORD access = 0;
+    if (prot & PROT_WRITE) {
+        protect = PAGE_READWRITE;
+        access = FILE_MAP_WRITE;
+    } else if (prot & PROT_READ) {
+        protect = PAGE_READONLY;
+        access = FILE_MAP_READ;
+    }
+
+    DWORD l_low = (uint32_t)length;
+    DWORD l_high = ((uint64_t)length) >> 32;
+    HANDLE map = CreateFileMapping(osf, NULL, protect, l_high, l_low, NULL);
+
+    if (!map) {
+        errno = EACCES; // something random
+        return MAP_FAILED;
+    }
+
+    DWORD o_low = (uint32_t)offset;
+    DWORD o_high = ((uint64_t)offset) >> 32;
+    void *p = MapViewOfFile(map, access, o_high, o_low, length);
+
+    CloseHandle(map);
+
+    if (!p) {
+        errno = EINVAL;
+        return MAP_FAILED;
+    }
+    return p;
+}
+
+int munmap(void *addr, size_t length)
+{
+    UnmapViewOfFile(addr);
+    return 0;
+}
+
+int msync(void *addr, size_t length, int flags)
+{
+    FlushViewOfFile(addr, length);
+    return 0;
+}
+#endif
+
+locale_t newlocale(int category, const char *locale, locale_t base)
+{
+    return (locale_t)1;
+}
+
+locale_t uselocale(locale_t locobj)
+{
+    return (locale_t)1;
+}
+
+void freelocale(locale_t locobj)
+{
+}
+
+#endif // __MINGW32__
+
+int mp_mkostemps(char *template, int suffixlen, int flags)
+{
+    size_t len = strlen(template);
+    char *t = len >= 6 + suffixlen ? &template[len - (6 + suffixlen)] : NULL;
+    if (!t || strncmp(t, "XXXXXX", 6) != 0) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (size_t fuckshit = 0; fuckshit < UINT32_MAX; fuckshit++) {
+        // Using a random value may make it require fewer iterations (even if
+        // not truly random; just a counter would be sufficient).
+        size_t fuckmess = mp_rand_next();
+        char crap[7] = "";
+        snprintf(crap, sizeof(crap), "%06zx", fuckmess);
+        memcpy(t, crap, 6);
+
+        int res = open(template, O_RDWR | O_CREAT | O_EXCL | flags, 0600);
+        if (res >= 0 || errno != EEXIST)
+            return res;
+    }
+
+    errno = EEXIST;
+    return -1;
+}