mirrors/bun.sh
1
0
Fork 0
mirror of https://github.com/oven-sh/bun synced 2026-02-09 10:28:47 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
ff4eccc3b40cf53166c9d2c4188af0d66b021ae0
bun.sh/src/windows_c.zig
Ciro Spaciari 183c661c40 net compatibility improvements (#14933) 
Co-authored-by: Jarred Sumner <jarred@jarredsumner.com>
2024-11-07 22:03:53 -08:00

1509 lines
56 KiB
Zig
Raw Blame History

const std = @import("std");
const bun = @import("root").bun;
const builtin = @import("builtin");
const win32 = std.os.windows;
const posix = std.posix;
const mem = std.mem;
const Stat = std.fs.File.Stat;
const Kind = std.fs.File.Kind;
const StatError = std.fs.File.StatError;
pub fn getTotalMemory() usize {
return uv.uv_get_total_memory();
}
pub fn getFreeMemory() usize {
return uv.uv_get_free_memory();
}
pub fn getSystemLoadavg() [3]f32 {
// loadavg is not supported on windows even in node
return .{ 0, 0, 0 };
}
pub const Mode = i32;
const Win32Error = bun.windows.Win32Error;
// The way we do errors in Bun needs to get cleaned up.
// This is way too complicated.
// The problem is because we use libc in some cases and we use zig's std lib in other places and other times we go direct.
// So we end up with a lot of redundant code.
pub const SystemErrno = enum(u16) {
SUCCESS = 0,
EPERM = 1,
ENOENT = 2,
ESRCH = 3,
EINTR = 4,
EIO = 5,
ENXIO = 6,
E2BIG = 7,
ENOEXEC = 8,
EBADF = 9,
ECHILD = 10,
EAGAIN = 11,
ENOMEM = 12,
EACCES = 13,
EFAULT = 14,
ENOTBLK = 15,
EBUSY = 16,
EEXIST = 17,
EXDEV = 18,
ENODEV = 19,
ENOTDIR = 20,
EISDIR = 21,
EINVAL = 22,
ENFILE = 23,
EMFILE = 24,
ENOTTY = 25,
ETXTBSY = 26,
EFBIG = 27,
ENOSPC = 28,
ESPIPE = 29,
EROFS = 30,
EMLINK = 31,
EPIPE = 32,
EDOM = 33,
ERANGE = 34,
EDEADLK = 35,
ENAMETOOLONG = 36,
ENOLCK = 37,
ENOSYS = 38,
ENOTEMPTY = 39,
ELOOP = 40,
EWOULDBLOCK = 41,
ENOMSG = 42,
EIDRM = 43,
ECHRNG = 44,
EL2NSYNC = 45,
EL3HLT = 46,
EL3RST = 47,
ELNRNG = 48,
EUNATCH = 49,
ENOCSI = 50,
EL2HLT = 51,
EBADE = 52,
EBADR = 53,
EXFULL = 54,
ENOANO = 55,
EBADRQC = 56,
EBADSLT = 57,
EDEADLOCK = 58,
EBFONT = 59,
ENOSTR = 60,
ENODATA = 61,
ETIME = 62,
ENOSR = 63,
ENONET = 64,
ENOPKG = 65,
EREMOTE = 66,
ENOLINK = 67,
EADV = 68,
ESRMNT = 69,
ECOMM = 70,
EPROTO = 71,
EMULTIHOP = 72,
EDOTDOT = 73,
EBADMSG = 74,
EOVERFLOW = 75,
ENOTUNIQ = 76,
EBADFD = 77,
EREMCHG = 78,
ELIBACC = 79,
ELIBBAD = 80,
ELIBSCN = 81,
ELIBMAX = 82,
ELIBEXEC = 83,
EILSEQ = 84,
ERESTART = 85,
ESTRPIPE = 86,
EUSERS = 87,
ENOTSOCK = 88,
EDESTADDRREQ = 89,
EMSGSIZE = 90,
EPROTOTYPE = 91,
ENOPROTOOPT = 92,
EPROTONOSUPPORT = 93,
ESOCKTNOSUPPORT = 94,
/// For Linux, EOPNOTSUPP is the real value
/// but it's ~the same and is incompatible across operating systems
/// https://lists.gnu.org/archive/html/bug-glibc/2002-08/msg00017.html
ENOTSUP = 95,
EPFNOSUPPORT = 96,
EAFNOSUPPORT = 97,
EADDRINUSE = 98,
EADDRNOTAVAIL = 99,
ENETDOWN = 100,
ENETUNREACH = 101,
ENETRESET = 102,
ECONNABORTED = 103,
ECONNRESET = 104,
ENOBUFS = 105,
EISCONN = 106,
ENOTCONN = 107,
ESHUTDOWN = 108,
ETOOMANYREFS = 109,
ETIMEDOUT = 110,
ECONNREFUSED = 111,
EHOSTDOWN = 112,
EHOSTUNREACH = 113,
EALREADY = 114,
EINPROGRESS = 115,
ESTALE = 116,
EUCLEAN = 117,
ENOTNAM = 118,
ENAVAIL = 119,
EISNAM = 120,
EREMOTEIO = 121,
EDQUOT = 122,
ENOMEDIUM = 123,
EMEDIUMTYPE = 124,
ECANCELED = 125,
ENOKEY = 126,
EKEYEXPIRED = 127,
EKEYREVOKED = 128,
EKEYREJECTED = 129,
EOWNERDEAD = 130,
ENOTRECOVERABLE = 131,
ERFKILL = 132,
EHWPOISON = 133,
// made up erropr
EUNKNOWN = 134,
ECHARSET = 135,
EOF = 136,
UV_E2BIG = -uv.UV_E2BIG,
UV_EACCES = -uv.UV_EACCES,
UV_EADDRINUSE = -uv.UV_EADDRINUSE,
UV_EADDRNOTAVAIL = -uv.UV_EADDRNOTAVAIL,
UV_EAFNOSUPPORT = -uv.UV_EAFNOSUPPORT,
UV_EAGAIN = -uv.UV_EAGAIN,
UV_EAI_ADDRFAMILY = -uv.UV_EAI_ADDRFAMILY,
UV_EAI_AGAIN = -uv.UV_EAI_AGAIN,
UV_EAI_BADFLAGS = -uv.UV_EAI_BADFLAGS,
UV_EAI_BADHINTS = -uv.UV_EAI_BADHINTS,
UV_EAI_CANCELED = -uv.UV_EAI_CANCELED,
UV_EAI_FAIL = -uv.UV_EAI_FAIL,
UV_EAI_FAMILY = -uv.UV_EAI_FAMILY,
UV_EAI_MEMORY = -uv.UV_EAI_MEMORY,
UV_EAI_NODATA = -uv.UV_EAI_NODATA,
UV_EAI_NONAME = -uv.UV_EAI_NONAME,
UV_EAI_OVERFLOW = -uv.UV_EAI_OVERFLOW,
UV_EAI_PROTOCOL = -uv.UV_EAI_PROTOCOL,
UV_EAI_SERVICE = -uv.UV_EAI_SERVICE,
UV_EAI_SOCKTYPE = -uv.UV_EAI_SOCKTYPE,
UV_EALREADY = -uv.UV_EALREADY,
UV_EBADF = -uv.UV_EBADF,
UV_EBUSY = -uv.UV_EBUSY,
UV_ECANCELED = -uv.UV_ECANCELED,
UV_ECHARSET = -uv.UV_ECHARSET,
UV_ECONNABORTED = -uv.UV_ECONNABORTED,
UV_ECONNREFUSED = -uv.UV_ECONNREFUSED,
UV_ECONNRESET = -uv.UV_ECONNRESET,
UV_EDESTADDRREQ = -uv.UV_EDESTADDRREQ,
UV_EEXIST = -uv.UV_EEXIST,
UV_EFAULT = -uv.UV_EFAULT,
UV_EFBIG = -uv.UV_EFBIG,
UV_EHOSTUNREACH = -uv.UV_EHOSTUNREACH,
UV_EINVAL = -uv.UV_EINVAL,
UV_EINTR = -uv.UV_EINTR,
UV_EISCONN = -uv.UV_EISCONN,
UV_EIO = -uv.UV_EIO,
UV_ELOOP = -uv.UV_ELOOP,
UV_EISDIR = -uv.UV_EISDIR,
UV_EMSGSIZE = -uv.UV_EMSGSIZE,
UV_EMFILE = -uv.UV_EMFILE,
UV_ENETDOWN = -uv.UV_ENETDOWN,
UV_ENAMETOOLONG = -uv.UV_ENAMETOOLONG,
UV_ENFILE = -uv.UV_ENFILE,
UV_ENETUNREACH = -uv.UV_ENETUNREACH,
UV_ENODEV = -uv.UV_ENODEV,
UV_ENOBUFS = -uv.UV_ENOBUFS,
UV_ENOMEM = -uv.UV_ENOMEM,
UV_ENOENT = -uv.UV_ENOENT,
UV_ENOPROTOOPT = -uv.UV_ENOPROTOOPT,
UV_ENONET = -uv.UV_ENONET,
UV_ENOSYS = -uv.UV_ENOSYS,
UV_ENOSPC = -uv.UV_ENOSPC,
UV_ENOTDIR = -uv.UV_ENOTDIR,
UV_ENOTCONN = -uv.UV_ENOTCONN,
UV_ENOTSOCK = -uv.UV_ENOTSOCK,
UV_ENOTEMPTY = -uv.UV_ENOTEMPTY,
UV_EOVERFLOW = -uv.UV_EOVERFLOW,
UV_ENOTSUP = -uv.UV_ENOTSUP,
UV_EPIPE = -uv.UV_EPIPE,
UV_EPERM = -uv.UV_EPERM,
UV_EPROTONOSUPPORT = -uv.UV_EPROTONOSUPPORT,
UV_EPROTO = -uv.UV_EPROTO,
UV_ERANGE = -uv.UV_ERANGE,
UV_EPROTOTYPE = -uv.UV_EPROTOTYPE,
UV_ESHUTDOWN = -uv.UV_ESHUTDOWN,
UV_EROFS = -uv.UV_EROFS,
UV_ESRCH = -uv.UV_ESRCH,
UV_ESPIPE = -uv.UV_ESPIPE,
UV_ETXTBSY = -uv.UV_ETXTBSY,
UV_ETIMEDOUT = -uv.UV_ETIMEDOUT,
UV_UNKNOWN = -uv.UV_UNKNOWN,
UV_EXDEV = -uv.UV_EXDEV,
UV_ENXIO = -uv.UV_ENXIO,
UV_EOF = -uv.UV_EOF,
UV_EHOSTDOWN = -uv.UV_EHOSTDOWN,
UV_EMLINK = -uv.UV_EMLINK,
UV_ENOTTY = -uv.UV_ENOTTY,
UV_EREMOTEIO = -uv.UV_EREMOTEIO,
UV_EILSEQ = -uv.UV_EILSEQ,
UV_EFTYPE = -uv.UV_EFTYPE,
UV_ENODATA = -uv.UV_ENODATA,
UV_ESOCKTNOSUPPORT = -uv.UV_ESOCKTNOSUPPORT,
UV_ERRNO_MAX = -uv.UV_ERRNO_MAX,
UV_EUNATCH = -uv.UV_EUNATCH,
pub const max = 137;
pub const Error = error{
EPERM,
ENOENT,
ESRCH,
EINTR,
EIO,
ENXIO,
E2BIG,
ENOEXEC,
EBADF,
ECHILD,
EAGAIN,
ENOMEM,
EACCES,
EFAULT,
ENOTBLK,
EBUSY,
EEXIST,
EXDEV,
ENODEV,
ENOTDIR,
EISDIR,
EINVAL,
ENFILE,
EMFILE,
ENOTTY,
ETXTBSY,
EFBIG,
ENOSPC,
ESPIPE,
EROFS,
EMLINK,
EPIPE,
EDOM,
ERANGE,
EDEADLK,
ENAMETOOLONG,
ENOLCK,
ENOSYS,
ENOTEMPTY,
ELOOP,
EWOULDBLOCK,
ENOMSG,
EIDRM,
ECHRNG,
EL2NSYNC,
EL3HLT,
EL3RST,
ELNRNG,
EUNATCH,
ENOCSI,
EL2HLT,
EBADE,
EBADR,
EXFULL,
ENOANO,
EBADRQC,
EBADSLT,
EDEADLOCK,
EBFONT,
ENOSTR,
ENODATA,
ETIME,
ENOSR,
ENONET,
ENOPKG,
EREMOTE,
ENOLINK,
EADV,
ESRMNT,
ECOMM,
EPROTO,
EMULTIHOP,
EDOTDOT,
EBADMSG,
EOVERFLOW,
ENOTUNIQ,
EBADFD,
EREMCHG,
ELIBACC,
ELIBBAD,
ELIBSCN,
ELIBMAX,
ELIBEXEC,
EILSEQ,
ERESTART,
ESTRPIPE,
EUSERS,
ENOTSOCK,
EDESTADDRREQ,
EMSGSIZE,
EPROTOTYPE,
ENOPROTOOPT,
EPROTONOSUPPORT,
ESOCKTNOSUPPORT,
ENOTSUP,
EPFNOSUPPORT,
EAFNOSUPPORT,
EADDRINUSE,
EADDRNOTAVAIL,
ENETDOWN,
ENETUNREACH,
ENETRESET,
ECONNABORTED,
ECONNRESET,
ENOBUFS,
EISCONN,
ENOTCONN,
ESHUTDOWN,
ETOOMANYREFS,
ETIMEDOUT,
ECONNREFUSED,
EHOSTDOWN,
EHOSTUNREACH,
EALREADY,
EINPROGRESS,
ESTALE,
EUCLEAN,
ENOTNAM,
ENAVAIL,
EISNAM,
EREMOTEIO,
EDQUOT,
ENOMEDIUM,
EMEDIUMTYPE,
ECANCELED,
ENOKEY,
EKEYEXPIRED,
EKEYREVOKED,
EKEYREJECTED,
EOWNERDEAD,
ENOTRECOVERABLE,
ERFKILL,
EHWPOISON,
EUNKNOWN,
ECHARSET,
EOF,
Unexpected,
};
pub inline fn toE(this: SystemErrno) E {
return @enumFromInt(@intFromEnum(this));
}
const error_map: [SystemErrno.max]Error = brk: {
var errors: [SystemErrno.max]Error = undefined;
errors[@intFromEnum(SystemErrno.EPERM)] = error.EPERM;
errors[@intFromEnum(SystemErrno.ENOENT)] = error.ENOENT;
errors[@intFromEnum(SystemErrno.ESRCH)] = error.ESRCH;
errors[@intFromEnum(SystemErrno.EINTR)] = error.EINTR;
errors[@intFromEnum(SystemErrno.EIO)] = error.EIO;
errors[@intFromEnum(SystemErrno.ENXIO)] = error.ENXIO;
errors[@intFromEnum(SystemErrno.E2BIG)] = error.E2BIG;
errors[@intFromEnum(SystemErrno.ENOEXEC)] = error.ENOEXEC;
errors[@intFromEnum(SystemErrno.EBADF)] = error.EBADF;
errors[@intFromEnum(SystemErrno.ECHILD)] = error.ECHILD;
errors[@intFromEnum(SystemErrno.EAGAIN)] = error.EAGAIN;
errors[@intFromEnum(SystemErrno.ENOMEM)] = error.ENOMEM;
errors[@intFromEnum(SystemErrno.EACCES)] = error.EACCES;
errors[@intFromEnum(SystemErrno.EFAULT)] = error.EFAULT;
errors[@intFromEnum(SystemErrno.ENOTBLK)] = error.ENOTBLK;
errors[@intFromEnum(SystemErrno.EBUSY)] = error.EBUSY;
errors[@intFromEnum(SystemErrno.EEXIST)] = error.EEXIST;
errors[@intFromEnum(SystemErrno.EXDEV)] = error.EXDEV;
errors[@intFromEnum(SystemErrno.ENODEV)] = error.ENODEV;
errors[@intFromEnum(SystemErrno.ENOTDIR)] = error.ENOTDIR;
errors[@intFromEnum(SystemErrno.EISDIR)] = error.EISDIR;
errors[@intFromEnum(SystemErrno.EINVAL)] = error.EINVAL;
errors[@intFromEnum(SystemErrno.ENFILE)] = error.ENFILE;
errors[@intFromEnum(SystemErrno.EMFILE)] = error.EMFILE;
errors[@intFromEnum(SystemErrno.ENOTTY)] = error.ENOTTY;
errors[@intFromEnum(SystemErrno.ETXTBSY)] = error.ETXTBSY;
errors[@intFromEnum(SystemErrno.EFBIG)] = error.EFBIG;
errors[@intFromEnum(SystemErrno.ENOSPC)] = error.ENOSPC;
errors[@intFromEnum(SystemErrno.ESPIPE)] = error.ESPIPE;
errors[@intFromEnum(SystemErrno.EROFS)] = error.EROFS;
errors[@intFromEnum(SystemErrno.EMLINK)] = error.EMLINK;
errors[@intFromEnum(SystemErrno.EPIPE)] = error.EPIPE;
errors[@intFromEnum(SystemErrno.EDOM)] = error.EDOM;
errors[@intFromEnum(SystemErrno.ERANGE)] = error.ERANGE;
errors[@intFromEnum(SystemErrno.EDEADLK)] = error.EDEADLK;
errors[@intFromEnum(SystemErrno.ENAMETOOLONG)] = error.ENAMETOOLONG;
errors[@intFromEnum(SystemErrno.ENOLCK)] = error.ENOLCK;
errors[@intFromEnum(SystemErrno.ENOSYS)] = error.ENOSYS;
errors[@intFromEnum(SystemErrno.ENOTEMPTY)] = error.ENOTEMPTY;
errors[@intFromEnum(SystemErrno.ELOOP)] = error.ELOOP;
errors[@intFromEnum(SystemErrno.EWOULDBLOCK)] = error.EWOULDBLOCK;
errors[@intFromEnum(SystemErrno.ENOMSG)] = error.ENOMSG;
errors[@intFromEnum(SystemErrno.EIDRM)] = error.EIDRM;
errors[@intFromEnum(SystemErrno.ECHRNG)] = error.ECHRNG;
errors[@intFromEnum(SystemErrno.EL2NSYNC)] = error.EL2NSYNC;
errors[@intFromEnum(SystemErrno.EL3HLT)] = error.EL3HLT;
errors[@intFromEnum(SystemErrno.EL3RST)] = error.EL3RST;
errors[@intFromEnum(SystemErrno.ELNRNG)] = error.ELNRNG;
errors[@intFromEnum(SystemErrno.EUNATCH)] = error.EUNATCH;
errors[@intFromEnum(SystemErrno.ENOCSI)] = error.ENOCSI;
errors[@intFromEnum(SystemErrno.EL2HLT)] = error.EL2HLT;
errors[@intFromEnum(SystemErrno.EBADE)] = error.EBADE;
errors[@intFromEnum(SystemErrno.EBADR)] = error.EBADR;
errors[@intFromEnum(SystemErrno.EXFULL)] = error.EXFULL;
errors[@intFromEnum(SystemErrno.ENOANO)] = error.ENOANO;
errors[@intFromEnum(SystemErrno.EBADRQC)] = error.EBADRQC;
errors[@intFromEnum(SystemErrno.EBADSLT)] = error.EBADSLT;
errors[@intFromEnum(SystemErrno.EDEADLOCK)] = error.EDEADLOCK;
errors[@intFromEnum(SystemErrno.EBFONT)] = error.EBFONT;
errors[@intFromEnum(SystemErrno.ENOSTR)] = error.ENOSTR;
errors[@intFromEnum(SystemErrno.ENODATA)] = error.ENODATA;
errors[@intFromEnum(SystemErrno.ETIME)] = error.ETIME;
errors[@intFromEnum(SystemErrno.ENOSR)] = error.ENOSR;
errors[@intFromEnum(SystemErrno.ENONET)] = error.ENONET;
errors[@intFromEnum(SystemErrno.ENOPKG)] = error.ENOPKG;
errors[@intFromEnum(SystemErrno.EREMOTE)] = error.EREMOTE;
errors[@intFromEnum(SystemErrno.ENOLINK)] = error.ENOLINK;
errors[@intFromEnum(SystemErrno.EADV)] = error.EADV;
errors[@intFromEnum(SystemErrno.ESRMNT)] = error.ESRMNT;
errors[@intFromEnum(SystemErrno.ECOMM)] = error.ECOMM;
errors[@intFromEnum(SystemErrno.EPROTO)] = error.EPROTO;
errors[@intFromEnum(SystemErrno.EMULTIHOP)] = error.EMULTIHOP;
errors[@intFromEnum(SystemErrno.EDOTDOT)] = error.EDOTDOT;
errors[@intFromEnum(SystemErrno.EBADMSG)] = error.EBADMSG;
errors[@intFromEnum(SystemErrno.EOVERFLOW)] = error.EOVERFLOW;
errors[@intFromEnum(SystemErrno.ENOTUNIQ)] = error.ENOTUNIQ;
errors[@intFromEnum(SystemErrno.EBADFD)] = error.EBADFD;
errors[@intFromEnum(SystemErrno.EREMCHG)] = error.EREMCHG;
errors[@intFromEnum(SystemErrno.ELIBACC)] = error.ELIBACC;
errors[@intFromEnum(SystemErrno.ELIBBAD)] = error.ELIBBAD;
errors[@intFromEnum(SystemErrno.ELIBSCN)] = error.ELIBSCN;
errors[@intFromEnum(SystemErrno.ELIBMAX)] = error.ELIBMAX;
errors[@intFromEnum(SystemErrno.ELIBEXEC)] = error.ELIBEXEC;
errors[@intFromEnum(SystemErrno.EILSEQ)] = error.EILSEQ;
errors[@intFromEnum(SystemErrno.ERESTART)] = error.ERESTART;
errors[@intFromEnum(SystemErrno.ESTRPIPE)] = error.ESTRPIPE;
errors[@intFromEnum(SystemErrno.EUSERS)] = error.EUSERS;
errors[@intFromEnum(SystemErrno.ENOTSOCK)] = error.ENOTSOCK;
errors[@intFromEnum(SystemErrno.EDESTADDRREQ)] = error.EDESTADDRREQ;
errors[@intFromEnum(SystemErrno.EMSGSIZE)] = error.EMSGSIZE;
errors[@intFromEnum(SystemErrno.EPROTOTYPE)] = error.EPROTOTYPE;
errors[@intFromEnum(SystemErrno.ENOPROTOOPT)] = error.ENOPROTOOPT;
errors[@intFromEnum(SystemErrno.EPROTONOSUPPORT)] = error.EPROTONOSUPPORT;
errors[@intFromEnum(SystemErrno.ESOCKTNOSUPPORT)] = error.ESOCKTNOSUPPORT;
errors[@intFromEnum(SystemErrno.ENOTSUP)] = error.ENOTSUP;
errors[@intFromEnum(SystemErrno.EPFNOSUPPORT)] = error.EPFNOSUPPORT;
errors[@intFromEnum(SystemErrno.EAFNOSUPPORT)] = error.EAFNOSUPPORT;
errors[@intFromEnum(SystemErrno.EADDRINUSE)] = error.EADDRINUSE;
errors[@intFromEnum(SystemErrno.EADDRNOTAVAIL)] = error.EADDRNOTAVAIL;
errors[@intFromEnum(SystemErrno.ENETDOWN)] = error.ENETDOWN;
errors[@intFromEnum(SystemErrno.ENETUNREACH)] = error.ENETUNREACH;
errors[@intFromEnum(SystemErrno.ENETRESET)] = error.ENETRESET;
errors[@intFromEnum(SystemErrno.ECONNABORTED)] = error.ECONNABORTED;
errors[@intFromEnum(SystemErrno.ECONNRESET)] = error.ECONNRESET;
errors[@intFromEnum(SystemErrno.ENOBUFS)] = error.ENOBUFS;
errors[@intFromEnum(SystemErrno.EISCONN)] = error.EISCONN;
errors[@intFromEnum(SystemErrno.ENOTCONN)] = error.ENOTCONN;
errors[@intFromEnum(SystemErrno.ESHUTDOWN)] = error.ESHUTDOWN;
errors[@intFromEnum(SystemErrno.ETOOMANYREFS)] = error.ETOOMANYREFS;
errors[@intFromEnum(SystemErrno.ETIMEDOUT)] = error.ETIMEDOUT;
errors[@intFromEnum(SystemErrno.ECONNREFUSED)] = error.ECONNREFUSED;
errors[@intFromEnum(SystemErrno.EHOSTDOWN)] = error.EHOSTDOWN;
errors[@intFromEnum(SystemErrno.EHOSTUNREACH)] = error.EHOSTUNREACH;
errors[@intFromEnum(SystemErrno.EALREADY)] = error.EALREADY;
errors[@intFromEnum(SystemErrno.EINPROGRESS)] = error.EINPROGRESS;
errors[@intFromEnum(SystemErrno.ESTALE)] = error.ESTALE;
errors[@intFromEnum(SystemErrno.EUCLEAN)] = error.EUCLEAN;
errors[@intFromEnum(SystemErrno.ENOTNAM)] = error.ENOTNAM;
errors[@intFromEnum(SystemErrno.ENAVAIL)] = error.ENAVAIL;
errors[@intFromEnum(SystemErrno.EISNAM)] = error.EISNAM;
errors[@intFromEnum(SystemErrno.EREMOTEIO)] = error.EREMOTEIO;
errors[@intFromEnum(SystemErrno.EDQUOT)] = error.EDQUOT;
errors[@intFromEnum(SystemErrno.ENOMEDIUM)] = error.ENOMEDIUM;
errors[@intFromEnum(SystemErrno.EMEDIUMTYPE)] = error.EMEDIUMTYPE;
errors[@intFromEnum(SystemErrno.ECANCELED)] = error.ECANCELED;
errors[@intFromEnum(SystemErrno.ENOKEY)] = error.ENOKEY;
errors[@intFromEnum(SystemErrno.EKEYEXPIRED)] = error.EKEYEXPIRED;
errors[@intFromEnum(SystemErrno.EKEYREVOKED)] = error.EKEYREVOKED;
errors[@intFromEnum(SystemErrno.EKEYREJECTED)] = error.EKEYREJECTED;
errors[@intFromEnum(SystemErrno.EOWNERDEAD)] = error.EOWNERDEAD;
errors[@intFromEnum(SystemErrno.ENOTRECOVERABLE)] = error.ENOTRECOVERABLE;
errors[@intFromEnum(SystemErrno.ERFKILL)] = error.ERFKILL;
errors[@intFromEnum(SystemErrno.EHWPOISON)] = error.EHWPOISON;
errors[@intFromEnum(SystemErrno.EUNKNOWN)] = error.EUNKNOWN;
errors[@intFromEnum(SystemErrno.ECHARSET)] = error.ECHARSET;
errors[@intFromEnum(SystemErrno.EOF)] = error.EOF;
break :brk errors;
};
pub fn fromError(err: anyerror) ?SystemErrno {
return switch (err) {
error.EPERM => SystemErrno.EPERM,
error.ENOENT => SystemErrno.ENOENT,
error.ESRCH => SystemErrno.ESRCH,
error.EINTR => SystemErrno.EINTR,
error.EIO => SystemErrno.EIO,
error.ENXIO => SystemErrno.ENXIO,
error.E2BIG => SystemErrno.E2BIG,
error.ENOEXEC => SystemErrno.ENOEXEC,
error.EBADF => SystemErrno.EBADF,
error.ECHILD => SystemErrno.ECHILD,
error.EAGAIN => SystemErrno.EAGAIN,
error.ENOMEM => SystemErrno.ENOMEM,
error.EACCES => SystemErrno.EACCES,
error.EFAULT => SystemErrno.EFAULT,
error.ENOTBLK => SystemErrno.ENOTBLK,
error.EBUSY => SystemErrno.EBUSY,
error.EEXIST => SystemErrno.EEXIST,
error.EXDEV => SystemErrno.EXDEV,
error.ENODEV => SystemErrno.ENODEV,
error.ENOTDIR => SystemErrno.ENOTDIR,
error.EISDIR => SystemErrno.EISDIR,
error.EINVAL => SystemErrno.EINVAL,
error.ENFILE => SystemErrno.ENFILE,
error.EMFILE => SystemErrno.EMFILE,
error.ENOTTY => SystemErrno.ENOTTY,
error.ETXTBSY => SystemErrno.ETXTBSY,
error.EFBIG => SystemErrno.EFBIG,
error.ENOSPC => SystemErrno.ENOSPC,
error.ESPIPE => SystemErrno.ESPIPE,
error.EROFS => SystemErrno.EROFS,
error.EMLINK => SystemErrno.EMLINK,
error.EPIPE => SystemErrno.EPIPE,
error.EDOM => SystemErrno.EDOM,
error.ERANGE => SystemErrno.ERANGE,
error.EDEADLK => SystemErrno.EDEADLK,
error.ENAMETOOLONG => SystemErrno.ENAMETOOLONG,
error.ENOLCK => SystemErrno.ENOLCK,
error.ENOSYS => SystemErrno.ENOSYS,
error.ENOTEMPTY => SystemErrno.ENOTEMPTY,
error.ELOOP => SystemErrno.ELOOP,
error.EWOULDBLOCK => SystemErrno.EWOULDBLOCK,
error.ENOMSG => SystemErrno.ENOMSG,
error.EIDRM => SystemErrno.EIDRM,
error.ECHRNG => SystemErrno.ECHRNG,
error.EL2NSYNC => SystemErrno.EL2NSYNC,
error.EL3HLT => SystemErrno.EL3HLT,
error.EL3RST => SystemErrno.EL3RST,
error.ELNRNG => SystemErrno.ELNRNG,
error.EUNATCH => SystemErrno.EUNATCH,
error.ENOCSI => SystemErrno.ENOCSI,
error.EL2HLT => SystemErrno.EL2HLT,
error.EBADE => SystemErrno.EBADE,
error.EBADR => SystemErrno.EBADR,
error.EXFULL => SystemErrno.EXFULL,
error.ENOANO => SystemErrno.ENOANO,
error.EBADRQC => SystemErrno.EBADRQC,
error.EBADSLT => SystemErrno.EBADSLT,
error.EDEADLOCK => SystemErrno.EDEADLOCK,
error.EBFONT => SystemErrno.EBFONT,
error.ENOSTR => SystemErrno.ENOSTR,
error.ENODATA => SystemErrno.ENODATA,
error.ETIME => SystemErrno.ETIME,
error.ENOSR => SystemErrno.ENOSR,
error.ENONET => SystemErrno.ENONET,
error.ENOPKG => SystemErrno.ENOPKG,
error.EREMOTE => SystemErrno.EREMOTE,
error.ENOLINK => SystemErrno.ENOLINK,
error.EADV => SystemErrno.EADV,
error.ESRMNT => SystemErrno.ESRMNT,
error.ECOMM => SystemErrno.ECOMM,
error.EPROTO => SystemErrno.EPROTO,
error.EMULTIHOP => SystemErrno.EMULTIHOP,
error.EDOTDOT => SystemErrno.EDOTDOT,
error.EBADMSG => SystemErrno.EBADMSG,
error.EOVERFLOW => SystemErrno.EOVERFLOW,
error.ENOTUNIQ => SystemErrno.ENOTUNIQ,
error.EBADFD => SystemErrno.EBADFD,
error.EREMCHG => SystemErrno.EREMCHG,
error.ELIBACC => SystemErrno.ELIBACC,
error.ELIBBAD => SystemErrno.ELIBBAD,
error.ELIBSCN => SystemErrno.ELIBSCN,
error.ELIBMAX => SystemErrno.ELIBMAX,
error.ELIBEXEC => SystemErrno.ELIBEXEC,
error.EILSEQ => SystemErrno.EILSEQ,
error.ERESTART => SystemErrno.ERESTART,
error.ESTRPIPE => SystemErrno.ESTRPIPE,
error.EUSERS => SystemErrno.EUSERS,
error.ENOTSOCK => SystemErrno.ENOTSOCK,
error.EDESTADDRREQ => SystemErrno.EDESTADDRREQ,
error.EMSGSIZE => SystemErrno.EMSGSIZE,
error.EPROTOTYPE => SystemErrno.EPROTOTYPE,
error.ENOPROTOOPT => SystemErrno.ENOPROTOOPT,
error.EPROTONOSUPPORT => SystemErrno.EPROTONOSUPPORT,
error.ESOCKTNOSUPPORT => SystemErrno.ESOCKTNOSUPPORT,
error.ENOTSUP => SystemErrno.ENOTSUP,
error.EPFNOSUPPORT => SystemErrno.EPFNOSUPPORT,
error.EAFNOSUPPORT => SystemErrno.EAFNOSUPPORT,
error.EADDRINUSE => SystemErrno.EADDRINUSE,
error.EADDRNOTAVAIL => SystemErrno.EADDRNOTAVAIL,
error.ENETDOWN => SystemErrno.ENETDOWN,
error.ENETUNREACH => SystemErrno.ENETUNREACH,
error.ENETRESET => SystemErrno.ENETRESET,
error.ECONNABORTED => SystemErrno.ECONNABORTED,
error.ECONNRESET => SystemErrno.ECONNRESET,
error.ENOBUFS => SystemErrno.ENOBUFS,
error.EISCONN => SystemErrno.EISCONN,
error.ENOTCONN => SystemErrno.ENOTCONN,
error.ESHUTDOWN => SystemErrno.ESHUTDOWN,
error.ETOOMANYREFS => SystemErrno.ETOOMANYREFS,
error.ETIMEDOUT => SystemErrno.ETIMEDOUT,
error.ECONNREFUSED => SystemErrno.ECONNREFUSED,
error.EHOSTDOWN => SystemErrno.EHOSTDOWN,
error.EHOSTUNREACH => SystemErrno.EHOSTUNREACH,
error.EALREADY => SystemErrno.EALREADY,
error.EINPROGRESS => SystemErrno.EINPROGRESS,
error.ESTALE => SystemErrno.ESTALE,
error.EUCLEAN => SystemErrno.EUCLEAN,
error.ENOTNAM => SystemErrno.ENOTNAM,
error.ENAVAIL => SystemErrno.ENAVAIL,
error.EISNAM => SystemErrno.EISNAM,
error.EREMOTEIO => SystemErrno.EREMOTEIO,
error.EDQUOT => SystemErrno.EDQUOT,
error.ENOMEDIUM => SystemErrno.ENOMEDIUM,
error.EMEDIUMTYPE => SystemErrno.EMEDIUMTYPE,
error.ECANCELED => SystemErrno.ECANCELED,
error.ENOKEY => SystemErrno.ENOKEY,
error.EKEYEXPIRED => SystemErrno.EKEYEXPIRED,
error.EKEYREVOKED => SystemErrno.EKEYREVOKED,
error.EKEYREJECTED => SystemErrno.EKEYREJECTED,
error.EOWNERDEAD => SystemErrno.EOWNERDEAD,
error.ENOTRECOVERABLE => SystemErrno.ENOTRECOVERABLE,
error.ERFKILL => SystemErrno.ERFKILL,
error.EHWPOISON => SystemErrno.EHWPOISON,
error.EUNKNOWN => SystemErrno.EUNKNOWN,
error.ECHARSET => SystemErrno.ECHARSET,
error.EOF => SystemErrno.EOF,
else => return null,
};
}
pub fn toError(this: SystemErrno) Error {
return error_map[@intFromEnum(this)];
}
pub fn init(code: anytype) ?SystemErrno {
if (@TypeOf(code) == u16 or (@TypeOf(code) == c_int and code > 0)) {
// Win32Error and WSA Error codes
if (code <= @intFromEnum(Win32Error.IO_REISSUE_AS_CACHED) or (code >= @intFromEnum(Win32Error.WSAEINTR) and code <= @intFromEnum(Win32Error.WSA_QOS_RESERVED_PETYPE))) {
return init(@as(Win32Error, @enumFromInt(code)));
} else {
if (comptime bun.Environment.allow_assert)
bun.Output.debugWarn("Unknown error code: {any}\n", .{code});
return null;
}
}
if (comptime @TypeOf(code) == Win32Error or @TypeOf(code) == std.os.windows.Win32Error) {
return switch (@as(Win32Error, @enumFromInt(@intFromEnum(code)))) {
Win32Error.NOACCESS => SystemErrno.EACCES,
Win32Error.WSAEACCES => SystemErrno.EACCES,
Win32Error.ELEVATION_REQUIRED => SystemErrno.EACCES,
Win32Error.CANT_ACCESS_FILE => SystemErrno.EACCES,
Win32Error.ADDRESS_ALREADY_ASSOCIATED => SystemErrno.EADDRINUSE,
Win32Error.WSAEADDRINUSE => SystemErrno.EADDRINUSE,
Win32Error.WSAEADDRNOTAVAIL => SystemErrno.EADDRNOTAVAIL,
Win32Error.WSAEAFNOSUPPORT => SystemErrno.EAFNOSUPPORT,
Win32Error.WSAEWOULDBLOCK => SystemErrno.EAGAIN,
Win32Error.WSAEALREADY => SystemErrno.EALREADY,
Win32Error.INVALID_FLAGS => SystemErrno.EBADF,
Win32Error.INVALID_HANDLE => SystemErrno.EBADF,
Win32Error.LOCK_VIOLATION => SystemErrno.EBUSY,
Win32Error.PIPE_BUSY => SystemErrno.EBUSY,
Win32Error.SHARING_VIOLATION => SystemErrno.EBUSY,
Win32Error.OPERATION_ABORTED => SystemErrno.ECANCELED,
Win32Error.WSAEINTR => SystemErrno.ECANCELED,
Win32Error.NO_UNICODE_TRANSLATION => SystemErrno.ECHARSET,
Win32Error.CONNECTION_ABORTED => SystemErrno.ECONNABORTED,
Win32Error.WSAECONNABORTED => SystemErrno.ECONNABORTED,
Win32Error.CONNECTION_REFUSED => SystemErrno.ECONNREFUSED,
Win32Error.WSAECONNREFUSED => SystemErrno.ECONNREFUSED,
Win32Error.NETNAME_DELETED => SystemErrno.ECONNRESET,
Win32Error.WSAECONNRESET => SystemErrno.ECONNRESET,
Win32Error.ALREADY_EXISTS => SystemErrno.EEXIST,
Win32Error.FILE_EXISTS => SystemErrno.EEXIST,
Win32Error.BUFFER_OVERFLOW => SystemErrno.EFAULT,
Win32Error.WSAEFAULT => SystemErrno.EFAULT,
Win32Error.HOST_UNREACHABLE => SystemErrno.EHOSTUNREACH,
Win32Error.WSAEHOSTUNREACH => SystemErrno.EHOSTUNREACH,
Win32Error.INSUFFICIENT_BUFFER => SystemErrno.EINVAL,
Win32Error.INVALID_DATA => SystemErrno.EINVAL,
Win32Error.INVALID_PARAMETER => SystemErrno.EINVAL,
Win32Error.SYMLINK_NOT_SUPPORTED => SystemErrno.EINVAL,
Win32Error.WSAEINVAL => SystemErrno.EINVAL,
Win32Error.WSAEPFNOSUPPORT => SystemErrno.EINVAL,
Win32Error.BEGINNING_OF_MEDIA => SystemErrno.EIO,
Win32Error.BUS_RESET => SystemErrno.EIO,
Win32Error.CRC => SystemErrno.EIO,
Win32Error.DEVICE_DOOR_OPEN => SystemErrno.EIO,
Win32Error.DEVICE_REQUIRES_CLEANING => SystemErrno.EIO,
Win32Error.DISK_CORRUPT => SystemErrno.EIO,
Win32Error.EOM_OVERFLOW => SystemErrno.EIO,
Win32Error.FILEMARK_DETECTED => SystemErrno.EIO,
Win32Error.GEN_FAILURE => SystemErrno.EIO,
Win32Error.INVALID_BLOCK_LENGTH => SystemErrno.EIO,
Win32Error.IO_DEVICE => SystemErrno.EIO,
Win32Error.NO_DATA_DETECTED => SystemErrno.EIO,
Win32Error.NO_SIGNAL_SENT => SystemErrno.EIO,
Win32Error.OPEN_FAILED => SystemErrno.EIO,
Win32Error.SETMARK_DETECTED => SystemErrno.EIO,
Win32Error.SIGNAL_REFUSED => SystemErrno.EIO,
Win32Error.WSAEISCONN => SystemErrno.EISCONN,
Win32Error.CANT_RESOLVE_FILENAME => SystemErrno.ELOOP,
Win32Error.TOO_MANY_OPEN_FILES => SystemErrno.EMFILE,
Win32Error.WSAEMFILE => SystemErrno.EMFILE,
Win32Error.WSAEMSGSIZE => SystemErrno.EMSGSIZE,
Win32Error.FILENAME_EXCED_RANGE => SystemErrno.ENAMETOOLONG,
Win32Error.NETWORK_UNREACHABLE => SystemErrno.ENETUNREACH,
Win32Error.WSAENETUNREACH => SystemErrno.ENETUNREACH,
Win32Error.WSAENOBUFS => SystemErrno.ENOBUFS,
Win32Error.BAD_PATHNAME => SystemErrno.ENOENT,
Win32Error.DIRECTORY => SystemErrno.ENOTDIR,
Win32Error.ENVVAR_NOT_FOUND => SystemErrno.ENOENT,
Win32Error.FILE_NOT_FOUND => SystemErrno.ENOENT,
Win32Error.INVALID_NAME => SystemErrno.ENOENT,
Win32Error.INVALID_DRIVE => SystemErrno.ENOENT,
Win32Error.INVALID_REPARSE_DATA => SystemErrno.ENOENT,
Win32Error.MOD_NOT_FOUND => SystemErrno.ENOENT,
Win32Error.PATH_NOT_FOUND => SystemErrno.ENOENT,
Win32Error.WSAHOST_NOT_FOUND => SystemErrno.ENOENT,
Win32Error.WSANO_DATA => SystemErrno.ENOENT,
Win32Error.NOT_ENOUGH_MEMORY => SystemErrno.ENOMEM,
Win32Error.OUTOFMEMORY => SystemErrno.ENOMEM,
Win32Error.CANNOT_MAKE => SystemErrno.ENOSPC,
Win32Error.DISK_FULL => SystemErrno.ENOSPC,
Win32Error.EA_TABLE_FULL => SystemErrno.ENOSPC,
Win32Error.END_OF_MEDIA => SystemErrno.ENOSPC,
Win32Error.HANDLE_DISK_FULL => SystemErrno.ENOSPC,
Win32Error.NOT_CONNECTED => SystemErrno.ENOTCONN,
Win32Error.WSAENOTCONN => SystemErrno.ENOTCONN,
Win32Error.DIR_NOT_EMPTY => SystemErrno.ENOTEMPTY,
Win32Error.WSAENOTSOCK => SystemErrno.ENOTSOCK,
Win32Error.NOT_SUPPORTED => SystemErrno.ENOTSUP,
Win32Error.BROKEN_PIPE => SystemErrno.EPIPE,
Win32Error.ACCESS_DENIED => SystemErrno.EPERM,
Win32Error.PRIVILEGE_NOT_HELD => SystemErrno.EPERM,
Win32Error.BAD_PIPE => SystemErrno.EPIPE,
Win32Error.NO_DATA => SystemErrno.EPIPE,
Win32Error.PIPE_NOT_CONNECTED => SystemErrno.EPIPE,
Win32Error.WSAESHUTDOWN => SystemErrno.EPIPE,
Win32Error.WSAEPROTONOSUPPORT => SystemErrno.EPROTONOSUPPORT,
Win32Error.WRITE_PROTECT => SystemErrno.EROFS,
Win32Error.SEM_TIMEOUT => SystemErrno.ETIMEDOUT,
Win32Error.WSAETIMEDOUT => SystemErrno.ETIMEDOUT,
Win32Error.NOT_SAME_DEVICE => SystemErrno.EXDEV,
Win32Error.INVALID_FUNCTION => SystemErrno.EISDIR,
Win32Error.META_EXPANSION_TOO_LONG => SystemErrno.E2BIG,
Win32Error.WSAESOCKTNOSUPPORT => SystemErrno.ESOCKTNOSUPPORT,
Win32Error.DELETE_PENDING => SystemErrno.EBUSY,
else => null,
};
}
if (code < 0)
return init(-code);
if (code >= max) return null;
return @as(SystemErrno, @enumFromInt(code));
}
pub fn label(this: SystemErrno) ?[:0]const u8 {
return labels.get(this) orelse null;
}
const LabelMap = std.enums.EnumMap(SystemErrno, [:0]const u8);
pub const labels: LabelMap = brk: {
var map: LabelMap = LabelMap.initFull("");
map.put(.EPERM, "Operation not permitted");
map.put(.ENOENT, "No such file or directory");
map.put(.ESRCH, "No such process");
map.put(.EINTR, "Interrupted system call");
map.put(.EIO, "I/O error");
map.put(.ENXIO, "No such device or address");
map.put(.E2BIG, "Argument list too long");
map.put(.ENOEXEC, "Exec format error");
map.put(.EBADF, "Bad file descriptor");
map.put(.ECHILD, "No child processes");
map.put(.EAGAIN, "Try again");
map.put(.EOF, "End of file");
map.put(.ENOMEM, "Out of memory");
map.put(.EACCES, "Permission denied");
map.put(.EFAULT, "Bad address");
map.put(.ENOTBLK, "Block device required");
map.put(.EBUSY, "Device or resource busy");
map.put(.EEXIST, "File or folder exists");
map.put(.EXDEV, "Cross-device link");
map.put(.ENODEV, "No such device");
map.put(.ENOTDIR, "Not a directory");
map.put(.EISDIR, "Is a directory");
map.put(.EINVAL, "Invalid argument");
map.put(.ENFILE, "File table overflow");
map.put(.EMFILE, "Too many open files");
map.put(.ECHARSET, "Invalid or incomplete multibyte or wide character");
map.put(.ENOTTY, "Not a typewriter");
map.put(.ETXTBSY, "Text file busy");
map.put(.EFBIG, "File too large");
map.put(.ENOSPC, "No space left on device");
map.put(.ESPIPE, "Illegal seek");
map.put(.EROFS, "Read-only file system");
map.put(.EMLINK, "Too many links");
map.put(.EPIPE, "Broken pipe");
map.put(.EDOM, "Math argument out of domain of func");
map.put(.ERANGE, "Math result not representable");
map.put(.EDEADLK, "Resource deadlock would occur");
map.put(.ENAMETOOLONG, "File name too long");
map.put(.ENOLCK, "No record locks available");
map.put(.EUNKNOWN, "An unknown error occurred");
map.put(.ENOSYS, "Function not implemented");
map.put(.ENOTEMPTY, "Directory not empty");
map.put(.ELOOP, "Too many symbolic links encountered");
map.put(.ENOMSG, "No message of desired type");
map.put(.EIDRM, "Identifier removed");
map.put(.ECHRNG, "Channel number out of range");
map.put(.EL2NSYNC, "Level 2 not synchronized");
map.put(.EL3HLT, "Level 3 halted");
map.put(.EL3RST, "Level 3 reset");
map.put(.ELNRNG, "Link number out of range");
map.put(.EUNATCH, "Protocol driver not attached");
map.put(.ENOCSI, "No CSI structure available");
map.put(.EL2HLT, "Level 2 halted");
map.put(.EBADE, "Invalid exchange");
map.put(.EBADR, "Invalid request descriptor");
map.put(.EXFULL, "Exchange full");
map.put(.ENOANO, "No anode");
map.put(.EBADRQC, "Invalid request code");
map.put(.EBADSLT, "Invalid slot");
map.put(.EBFONT, "Bad font file format");
map.put(.ENOSTR, "Device not a stream");
map.put(.ENODATA, "No data available");
map.put(.ETIME, "Timer expired");
map.put(.ENOSR, "Out of streams resources");
map.put(.ENONET, "Machine is not on the network");
map.put(.ENOPKG, "Package not installed");
map.put(.EREMOTE, "Object is remote");
map.put(.ENOLINK, "Link has been severed");
map.put(.EADV, "Advertise error");
map.put(.ESRMNT, "Srmount error");
map.put(.ECOMM, "Communication error on send");
map.put(.EPROTO, "Protocol error");
map.put(.EMULTIHOP, "Multihop attempted");
map.put(.EDOTDOT, "RFS specific error");
map.put(.EBADMSG, "Not a data message");
map.put(.EOVERFLOW, "Value too large for defined data type");
map.put(.ENOTUNIQ, "Name not unique on network");
map.put(.EBADFD, "File descriptor in bad state");
map.put(.EREMCHG, "Remote address changed");
map.put(.ELIBACC, "Can not access a needed shared library");
map.put(.ELIBBAD, "Accessing a corrupted shared library");
map.put(.ELIBSCN, "lib section in a.out corrupted");
map.put(.ELIBMAX, "Attempting to link in too many shared libraries");
map.put(.ELIBEXEC, "Cannot exec a shared library directly");
map.put(.EILSEQ, "Illegal byte sequence");
map.put(.ERESTART, "Interrupted system call should be restarted");
map.put(.ESTRPIPE, "Streams pipe error");
map.put(.EUSERS, "Too many users");
map.put(.ENOTSOCK, "Socket operation on non-socket");
map.put(.EDESTADDRREQ, "Destination address required");
map.put(.EMSGSIZE, "Message too long");
map.put(.EPROTOTYPE, "Protocol wrong type for socket");
map.put(.ENOPROTOOPT, "Protocol not available");
map.put(.EPROTONOSUPPORT, "Protocol not supported");
map.put(.ESOCKTNOSUPPORT, "Socket type not supported");
map.put(.ENOTSUP, "Operation not supported on transport endpoint");
map.put(.EPFNOSUPPORT, "Protocol family not supported");
map.put(.EAFNOSUPPORT, "Address family not supported by protocol");
map.put(.EADDRINUSE, "Address already in use");
map.put(.EADDRNOTAVAIL, "Cannot assign requested address");
map.put(.ENETDOWN, "Network is down");
map.put(.ENETUNREACH, "Network is unreachable");
map.put(.ENETRESET, "Network dropped connection because of reset");
map.put(.ECONNABORTED, "Software caused connection abort");
map.put(.ECONNRESET, "Connection reset by peer");
map.put(.ENOBUFS, "No buffer space available");
map.put(.EISCONN, "Transport endpoint is already connected");
map.put(.ENOTCONN, "Transport endpoint is not connected");
map.put(.ESHUTDOWN, "Cannot send after transport endpoint shutdown");
map.put(.ETOOMANYREFS, "Too many references: cannot splice");
map.put(.ETIMEDOUT, "Connection timed out");
map.put(.ECONNREFUSED, "Connection refused");
map.put(.EHOSTDOWN, "Host is down");
map.put(.EHOSTUNREACH, "No route to host");
map.put(.EALREADY, "Operation already in progress");
map.put(.EINPROGRESS, "Operation now in progress");
map.put(.ESTALE, "Stale NFS file handle");
map.put(.EUCLEAN, "Structure needs cleaning");
map.put(.ENOTNAM, "Not a XENIX named type file");
map.put(.ENAVAIL, "No XENIX semaphores available");
map.put(.EISNAM, "Is a named type file");
map.put(.EREMOTEIO, "Remote I/O error");
map.put(.EDQUOT, "Quota exceeded");
map.put(.ENOMEDIUM, "No medium found");
map.put(.EMEDIUMTYPE, "Wrong medium type");
map.put(.ECANCELED, "Operation Canceled");
map.put(.ENOKEY, "Required key not available");
map.put(.EKEYEXPIRED, "Key has expired");
map.put(.EKEYREVOKED, "Key has been revoked");
map.put(.EKEYREJECTED, "Key was rejected by service");
map.put(.EOWNERDEAD, "Owner died");
map.put(.ENOTRECOVERABLE, "State not recoverable");
break :brk map;
};
};
pub const UV_E2BIG = -uv.UV_E2BIG;
pub const UV_EACCES = -uv.UV_EACCES;
pub const UV_EADDRINUSE = -uv.UV_EADDRINUSE;
pub const UV_EADDRNOTAVAIL = -uv.UV_EADDRNOTAVAIL;
pub const UV_EAFNOSUPPORT = -uv.UV_EAFNOSUPPORT;
pub const UV_EAGAIN = -uv.UV_EAGAIN;
pub const UV_EALREADY = -uv.UV_EALREADY;
pub const UV_EBADF = -uv.UV_EBADF;
pub const UV_EBUSY = -uv.UV_EBUSY;
pub const UV_ECANCELED = -uv.UV_ECANCELED;
pub const UV_ECHARSET = -uv.UV_ECHARSET;
pub const UV_ECONNABORTED = -uv.UV_ECONNABORTED;
pub const UV_ECONNREFUSED = -uv.UV_ECONNREFUSED;
pub const UV_ECONNRESET = -uv.UV_ECONNRESET;
pub const UV_EDESTADDRREQ = -uv.UV_EDESTADDRREQ;
pub const UV_EEXIST = -uv.UV_EEXIST;
pub const UV_EFAULT = -uv.UV_EFAULT;
pub const UV_EHOSTUNREACH = -uv.UV_EHOSTUNREACH;
pub const UV_EINTR = -uv.UV_EINTR;
pub const UV_EINVAL = -uv.UV_EINVAL;
pub const UV_EIO = -uv.UV_EIO;
pub const UV_EISCONN = -uv.UV_EISCONN;
pub const UV_EISDIR = -uv.UV_EISDIR;
pub const UV_ELOOP = -uv.UV_ELOOP;
pub const UV_EMFILE = -uv.UV_EMFILE;
pub const UV_EMSGSIZE = -uv.UV_EMSGSIZE;
pub const UV_ENAMETOOLONG = -uv.UV_ENAMETOOLONG;
pub const UV_ENETDOWN = -uv.UV_ENETDOWN;
pub const UV_ENETUNREACH = -uv.UV_ENETUNREACH;
pub const UV_ENFILE = -uv.UV_ENFILE;
pub const UV_ENOBUFS = -uv.UV_ENOBUFS;
pub const UV_ENODEV = -uv.UV_ENODEV;
pub const UV_ENOENT = -uv.UV_ENOENT;
pub const UV_ENOMEM = -uv.UV_ENOMEM;
pub const UV_ENONET = -uv.UV_ENONET;
pub const UV_ENOSPC = -uv.UV_ENOSPC;
pub const UV_ENOSYS = -uv.UV_ENOSYS;
pub const UV_ENOTCONN = -uv.UV_ENOTCONN;
pub const UV_ENOTDIR = -uv.UV_ENOTDIR;
pub const UV_ENOTEMPTY = -uv.UV_ENOTEMPTY;
pub const UV_ENOTSOCK = -uv.UV_ENOTSOCK;
pub const UV_ENOTSUP = -uv.UV_ENOTSUP;
pub const UV_EPERM = -uv.UV_EPERM;
pub const UV_EPIPE = -uv.UV_EPIPE;
pub const UV_EPROTO = -uv.UV_EPROTO;
pub const UV_EPROTONOSUPPORT = -uv.UV_EPROTONOSUPPORT;
pub const UV_EPROTOTYPE = -uv.UV_EPROTOTYPE;
pub const UV_EROFS = -uv.UV_EROFS;
pub const UV_ESHUTDOWN = -uv.UV_ESHUTDOWN;
pub const UV_ESPIPE = -uv.UV_ESPIPE;
pub const UV_ESRCH = -uv.UV_ESRCH;
pub const UV_ETIMEDOUT = -uv.UV_ETIMEDOUT;
pub const UV_ETXTBSY = -uv.UV_ETXTBSY;
pub const UV_EXDEV = -uv.UV_EXDEV;
pub const UV_EFBIG = -uv.UV_EFBIG;
pub const UV_ENOPROTOOPT = -uv.UV_ENOPROTOOPT;
pub const UV_ERANGE = -uv.UV_ERANGE;
pub const UV_ENXIO = -uv.UV_ENXIO;
pub const UV_EMLINK = -uv.UV_EMLINK;
pub const UV_EHOSTDOWN = -uv.UV_EHOSTDOWN;
pub const UV_EREMOTEIO = -uv.UV_EREMOTEIO;
pub const UV_ENOTTY = -uv.UV_ENOTTY;
pub const UV_EFTYPE = -uv.UV_EFTYPE;
pub const UV_EILSEQ = -uv.UV_EILSEQ;
pub const UV_EOVERFLOW = -uv.UV_EOVERFLOW;
pub const UV_ESOCKTNOSUPPORT = -uv.UV_ESOCKTNOSUPPORT;
pub const UV_ENODATA = -uv.UV_ENODATA;
pub const UV_EUNATCH = -uv.UV_EUNATCH;
pub const off_t = i64;
pub fn preallocate_file(_: posix.fd_t, _: off_t, _: off_t) !void {}
const uv = @import("./deps/libuv.zig");
pub const E = enum(u16) {
SUCCESS = 0,
PERM = 1,
NOENT = 2,
SRCH = 3,
INTR = 4,
IO = 5,
NXIO = 6,
@"2BIG" = 7,
NOEXEC = 8,
BADF = 9,
CHILD = 10,
AGAIN = 11,
NOMEM = 12,
ACCES = 13,
FAULT = 14,
NOTBLK = 15,
BUSY = 16,
EXIST = 17,
XDEV = 18,
NODEV = 19,
NOTDIR = 20,
ISDIR = 21,
INVAL = 22,
NFILE = 23,
MFILE = 24,
NOTTY = 25,
TXTBSY = 26,
FBIG = 27,
NOSPC = 28,
SPIPE = 29,
ROFS = 30,
MLINK = 31,
PIPE = 32,
DOM = 33,
RANGE = 34,
DEADLK = 35,
NAMETOOLONG = 36,
NOLCK = 37,
NOSYS = 38,
NOTEMPTY = 39,
LOOP = 40,
WOULDBLOCK = 41,
NOMSG = 42,
IDRM = 43,
CHRNG = 44,
L2NSYNC = 45,
L3HLT = 46,
L3RST = 47,
LNRNG = 48,
UNATCH = 49,
NOCSI = 50,
L2HLT = 51,
BADE = 52,
BADR = 53,
XFULL = 54,
NOANO = 55,
BADRQC = 56,
BADSLT = 57,
DEADLOCK = 58,
BFONT = 59,
NOSTR = 60,
NODATA = 61,
TIME = 62,
NOSR = 63,
NONET = 64,
NOPKG = 65,
REMOTE = 66,
NOLINK = 67,
ADV = 68,
SRMNT = 69,
COMM = 70,
PROTO = 71,
MULTIHOP = 72,
DOTDOT = 73,
BADMSG = 74,
OVERFLOW = 75,
NOTUNIQ = 76,
BADFD = 77,
REMCHG = 78,
LIBACC = 79,
LIBBAD = 80,
LIBSCN = 81,
LIBMAX = 82,
LIBEXEC = 83,
ILSEQ = 84,
RESTART = 85,
STRPIPE = 86,
USERS = 87,
NOTSOCK = 88,
DESTADDRREQ = 89,
MSGSIZE = 90,
PROTOTYPE = 91,
NOPROTOOPT = 92,
PROTONOSUPPORT = 93,
SOCKTNOSUPPORT = 94,
NOTSUP = 95,
PFNOSUPPORT = 96,
AFNOSUPPORT = 97,
ADDRINUSE = 98,
ADDRNOTAVAIL = 99,
NETDOWN = 100,
NETUNREACH = 101,
NETRESET = 102,
CONNABORTED = 103,
CONNRESET = 104,
NOBUFS = 105,
ISCONN = 106,
NOTCONN = 107,
SHUTDOWN = 108,
TOOMANYREFS = 109,
TIMEDOUT = 110,
CONNREFUSED = 111,
HOSTDOWN = 112,
HOSTUNREACH = 113,
ALREADY = 114,
INPROGRESS = 115,
STALE = 116,
UCLEAN = 117,
NOTNAM = 118,
NAVAIL = 119,
ISNAM = 120,
REMOTEIO = 121,
DQUOT = 122,
NOMEDIUM = 123,
MEDIUMTYPE = 124,
CANCELED = 125,
NOKEY = 126,
KEYEXPIRED = 127,
KEYREVOKED = 128,
KEYREJECTED = 129,
OWNERDEAD = 130,
NOTRECOVERABLE = 131,
RFKILL = 132,
HWPOISON = 133,
UNKNOWN = 134,
CHARSET = 135,
EOF = 136,
UV_E2BIG = -uv.UV_E2BIG,
UV_EACCES = -uv.UV_EACCES,
UV_EADDRINUSE = -uv.UV_EADDRINUSE,
UV_EADDRNOTAVAIL = -uv.UV_EADDRNOTAVAIL,
UV_EAFNOSUPPORT = -uv.UV_EAFNOSUPPORT,
UV_EAGAIN = -uv.UV_EAGAIN,
UV_EAI_ADDRFAMILY = -uv.UV_EAI_ADDRFAMILY,
UV_EAI_AGAIN = -uv.UV_EAI_AGAIN,
UV_EAI_BADFLAGS = -uv.UV_EAI_BADFLAGS,
UV_EAI_BADHINTS = -uv.UV_EAI_BADHINTS,
UV_EAI_CANCELED = -uv.UV_EAI_CANCELED,
UV_EAI_FAIL = -uv.UV_EAI_FAIL,
UV_EAI_FAMILY = -uv.UV_EAI_FAMILY,
UV_EAI_MEMORY = -uv.UV_EAI_MEMORY,
UV_EAI_NODATA = -uv.UV_EAI_NODATA,
UV_EAI_NONAME = -uv.UV_EAI_NONAME,
UV_EAI_OVERFLOW = -uv.UV_EAI_OVERFLOW,
UV_EAI_PROTOCOL = -uv.UV_EAI_PROTOCOL,
UV_EAI_SERVICE = -uv.UV_EAI_SERVICE,
UV_EAI_SOCKTYPE = -uv.UV_EAI_SOCKTYPE,
UV_EALREADY = -uv.UV_EALREADY,
UV_EBADF = -uv.UV_EBADF,
UV_EBUSY = -uv.UV_EBUSY,
UV_ECANCELED = -uv.UV_ECANCELED,
UV_ECHARSET = -uv.UV_ECHARSET,
UV_ECONNABORTED = -uv.UV_ECONNABORTED,
UV_ECONNREFUSED = -uv.UV_ECONNREFUSED,
UV_ECONNRESET = -uv.UV_ECONNRESET,
UV_EDESTADDRREQ = -uv.UV_EDESTADDRREQ,
UV_EEXIST = -uv.UV_EEXIST,
UV_EFAULT = -uv.UV_EFAULT,
UV_EFBIG = -uv.UV_EFBIG,
UV_EHOSTUNREACH = -uv.UV_EHOSTUNREACH,
UV_EINVAL = -uv.UV_EINVAL,
UV_EINTR = -uv.UV_EINTR,
UV_EISCONN = -uv.UV_EISCONN,
UV_EIO = -uv.UV_EIO,
UV_ELOOP = -uv.UV_ELOOP,
UV_EISDIR = -uv.UV_EISDIR,
UV_EMSGSIZE = -uv.UV_EMSGSIZE,
UV_EMFILE = -uv.UV_EMFILE,
UV_ENETDOWN = -uv.UV_ENETDOWN,
UV_ENAMETOOLONG = -uv.UV_ENAMETOOLONG,
UV_ENFILE = -uv.UV_ENFILE,
UV_ENETUNREACH = -uv.UV_ENETUNREACH,
UV_ENODEV = -uv.UV_ENODEV,
UV_ENOBUFS = -uv.UV_ENOBUFS,
UV_ENOMEM = -uv.UV_ENOMEM,
UV_ENOENT = -uv.UV_ENOENT,
UV_ENOPROTOOPT = -uv.UV_ENOPROTOOPT,
UV_ENONET = -uv.UV_ENONET,
UV_ENOSYS = -uv.UV_ENOSYS,
UV_ENOSPC = -uv.UV_ENOSPC,
UV_ENOTDIR = -uv.UV_ENOTDIR,
UV_ENOTCONN = -uv.UV_ENOTCONN,
UV_ENOTSOCK = -uv.UV_ENOTSOCK,
UV_ENOTEMPTY = -uv.UV_ENOTEMPTY,
UV_EOVERFLOW = -uv.UV_EOVERFLOW,
UV_ENOTSUP = -uv.UV_ENOTSUP,
UV_EPIPE = -uv.UV_EPIPE,
UV_EPERM = -uv.UV_EPERM,
UV_EPROTONOSUPPORT = -uv.UV_EPROTONOSUPPORT,
UV_EPROTO = -uv.UV_EPROTO,
UV_ERANGE = -uv.UV_ERANGE,
UV_EPROTOTYPE = -uv.UV_EPROTOTYPE,
UV_ESHUTDOWN = -uv.UV_ESHUTDOWN,
UV_EROFS = -uv.UV_EROFS,
UV_ESRCH = -uv.UV_ESRCH,
UV_ESPIPE = -uv.UV_ESPIPE,
UV_ETXTBSY = -uv.UV_ETXTBSY,
UV_ETIMEDOUT = -uv.UV_ETIMEDOUT,
UV_UNKNOWN = -uv.UV_UNKNOWN,
UV_EXDEV = -uv.UV_EXDEV,
UV_ENXIO = -uv.UV_ENXIO,
UV_EOF = -uv.UV_EOF,
UV_EHOSTDOWN = -uv.UV_EHOSTDOWN,
UV_EMLINK = -uv.UV_EMLINK,
UV_ENOTTY = -uv.UV_ENOTTY,
UV_EREMOTEIO = -uv.UV_EREMOTEIO,
UV_EILSEQ = -uv.UV_EILSEQ,
UV_EFTYPE = -uv.UV_EFTYPE,
UV_ENODATA = -uv.UV_ENODATA,
UV_ESOCKTNOSUPPORT = -uv.UV_ESOCKTNOSUPPORT,
UV_ERRNO_MAX = -uv.UV_ERRNO_MAX,
UV_EUNATCH = -uv.UV_EUNATCH,
};
pub const S = struct {
pub const IFMT = 0o170000;
pub const IFDIR = 0o040000;
pub const IFCHR = 0o020000;
pub const IFBLK = 0o060000;
pub const IFREG = 0o100000;
pub const IFIFO = 0o010000;
pub const IFLNK = 0o120000;
pub const IFSOCK = 0o140000;
pub const ISUID = 0o4000;
pub const ISGID = 0o2000;
pub const ISVTX = 0o1000;
pub const IRUSR = 0o400;
pub const IWUSR = 0o200;
pub const IXUSR = 0o100;
pub const IRWXU = 0o700;
pub const IRGRP = 0o040;
pub const IWGRP = 0o020;
pub const IXGRP = 0o010;
pub const IRWXG = 0o070;
pub const IROTH = 0o004;
pub const IWOTH = 0o002;
pub const IXOTH = 0o001;
pub const IRWXO = 0o007;
pub inline fn ISREG(m: i32) bool {
return m & IFMT == IFREG;
}
pub inline fn ISDIR(m: i32) bool {
return m & IFMT == IFDIR;
}
pub inline fn ISCHR(m: i32) bool {
return m & IFMT == IFCHR;
}
pub inline fn ISBLK(m: i32) bool {
return m & IFMT == IFBLK;
}
pub inline fn ISFIFO(m: i32) bool {
return m & IFMT == IFIFO;
}
pub inline fn ISLNK(m: i32) bool {
return m & IFMT == IFLNK;
}
pub inline fn ISSOCK(m: i32) bool {
return m & IFMT == IFSOCK;
}
};
pub fn getErrno(_: anytype) E {
if (Win32Error.get().toSystemErrno()) |sys| {
return sys.toE();
}
if (bun.windows.WSAGetLastError()) |wsa| {
return wsa.toE();
}
return .SUCCESS;
}
const Maybe = bun.JSC.Maybe;
const w = std.os.windows;
extern "c" fn _umask(Mode) Mode;
pub const umask = _umask;
/// Derived from std.os.windows.renameAtW
/// Allows more errors
pub fn renameAtW(
old_dir_fd: bun.FileDescriptor,
old_path_w: []const u16,
new_dir_fd: bun.FileDescriptor,
new_path_w: []const u16,
replace_if_exists: bool,
) Maybe(void) {
const src_fd = brk: {
switch (bun.sys.openFileAtWindows(
old_dir_fd,
old_path_w,
w.SYNCHRONIZE | w.GENERIC_WRITE | w.DELETE | w.FILE_TRAVERSE,
w.FILE_OPEN,
w.FILE_SYNCHRONOUS_IO_NONALERT | w.FILE_OPEN_REPARSE_POINT,
)) {
.err => {
// retry, wtihout FILE_TRAVERSE flag
switch (bun.sys.openFileAtWindows(
old_dir_fd,
old_path_w,
w.SYNCHRONIZE | w.GENERIC_WRITE | w.DELETE,
w.FILE_OPEN,
w.FILE_SYNCHRONOUS_IO_NONALERT | w.FILE_OPEN_REPARSE_POINT,
)) {
.err => |err2| return .{ .err = err2 },
.result => |fd| break :brk fd,
}
},
.result => |fd| break :brk fd,
}
};
defer _ = bun.sys.close(src_fd);
return moveOpenedFileAt(src_fd, new_dir_fd, new_path_w, replace_if_exists);
}
const log = bun.sys.syslog;
/// With an open file source_fd, move it into the directory new_dir_fd with the name new_path_w.
/// Does not close the file descriptor.
///
/// For this to succeed
/// - source_fd must have been opened with access_mask=w.DELETE
/// - new_path_w must be the name of a file. it cannot be a path relative to new_dir_fd. see moveOpenedFileAtLoose
pub fn moveOpenedFileAt(
src_fd: bun.FileDescriptor,
new_dir_fd: bun.FileDescriptor,
new_file_name: []const u16,
replace_if_exists: bool,
) Maybe(void) {
// FILE_RENAME_INFORMATION_EX and FILE_RENAME_POSIX_SEMANTICS require >= win10_rs1,
// but FILE_RENAME_IGNORE_READONLY_ATTRIBUTE requires >= win10_rs5. We check >= rs5 here
// so that we only use POSIX_SEMANTICS when we know IGNORE_READONLY_ATTRIBUTE will also be
// supported in order to avoid either (1) using a redundant call that we can know in advance will return
// STATUS_NOT_SUPPORTED or (2) only setting IGNORE_READONLY_ATTRIBUTE when >= rs5
// and therefore having different behavior when the Windows version is >= rs1 but < rs5.
comptime bun.assert(builtin.target.os.version_range.windows.min.isAtLeast(.win10_rs5));
if (bun.Environment.allow_assert) {
bun.assert(std.mem.indexOfScalar(u16, new_file_name, '/') == null); // Call moveOpenedFileAtLoose
}
const struct_buf_len = @sizeOf(w.FILE_RENAME_INFORMATION_EX) + (bun.MAX_PATH_BYTES - 1);
var rename_info_buf: [struct_buf_len]u8 align(@alignOf(w.FILE_RENAME_INFORMATION_EX)) = undefined;
const struct_len = @sizeOf(w.FILE_RENAME_INFORMATION_EX) - 1 + new_file_name.len * 2;
if (struct_len > struct_buf_len) return Maybe(void).errno(bun.C.E.NAMETOOLONG, .NtSetInformationFile);
const rename_info = @as(*w.FILE_RENAME_INFORMATION_EX, @ptrCast(&rename_info_buf));
var io_status_block: w.IO_STATUS_BLOCK = undefined;
var flags: w.ULONG = w.FILE_RENAME_POSIX_SEMANTICS | w.FILE_RENAME_IGNORE_READONLY_ATTRIBUTE;
if (replace_if_exists) flags |= w.FILE_RENAME_REPLACE_IF_EXISTS;
rename_info.* = .{
.Flags = flags,
.RootDirectory = if (std.fs.path.isAbsoluteWindowsWTF16(new_file_name)) null else new_dir_fd.cast(),
.FileNameLength = @intCast(new_file_name.len * 2), // already checked error.NameTooLong
.FileName = undefined,
};
@memcpy(@as([*]u16, &rename_info.FileName)[0..new_file_name.len], new_file_name);
const rc = w.ntdll.NtSetInformationFile(
src_fd.cast(),
&io_status_block,
rename_info,
@intCast(struct_len), // already checked for error.NameTooLong
.FileRenameInformationEx,
);
log("moveOpenedFileAt({} ->> {} '{}', {s}) = {s}", .{ src_fd, new_dir_fd, bun.fmt.utf16(new_file_name), if (replace_if_exists) "replace_if_exists" else "no flag", @tagName(rc) });
if (bun.Environment.isDebug) {
if (rc == .ACCESS_DENIED) {
bun.Output.debugWarn("moveOpenedFileAt was called on a file descriptor without access_mask=w.DELETE", .{});
}
}
return if (rc == .SUCCESS)
Maybe(void).success
else
Maybe(void).errno(rc, .NtSetInformationFile);
}
/// Same as moveOpenedFileAt but allows new_path to be a path relative to new_dir_fd.
///
/// Aka: moveOpenedFileAtLoose(fd, dir, ".\\a\\relative\\not-normalized-path.txt", false);
pub fn moveOpenedFileAtLoose(
src_fd: bun.FileDescriptor,
new_dir_fd: bun.FileDescriptor,
new_path: []const u16,
replace_if_exists: bool,
) Maybe(void) {
bun.assert(std.mem.indexOfScalar(u16, new_path, '/') == null); // Call bun.strings.toWPathNormalized first
const without_leading_dot_slash = if (new_path.len >= 2 and new_path[0] == '.' and new_path[1] == '\\')
new_path[2..]
else
new_path;
if (std.mem.lastIndexOfScalar(u16, new_path, '\\')) |last_slash| {
const dirname = new_path[0..last_slash];
const fd = switch (bun.sys.openDirAtWindows(new_dir_fd, dirname, .{ .can_rename_or_delete = true, .iterable = false })) {
.err => |e| return .{ .err = e },
.result => |fd| fd,
};
defer _ = bun.sys.close(fd);
const basename = new_path[last_slash + 1 ..];
return moveOpenedFileAt(src_fd, fd, basename, replace_if_exists);
}
// easy mode
return moveOpenedFileAt(src_fd, new_dir_fd, without_leading_dot_slash, replace_if_exists);
}
const FILE_DISPOSITION_DO_NOT_DELETE: w.ULONG = 0x00000000;
const FILE_DISPOSITION_DELETE: w.ULONG = 0x00000001;
const FILE_DISPOSITION_POSIX_SEMANTICS: w.ULONG = 0x00000002;
const FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK: w.ULONG = 0x00000004;
const FILE_DISPOSITION_ON_CLOSE: w.ULONG = 0x00000008;
const FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE: w.ULONG = 0x00000010;
/// Extracted from standard library except this takes an open file descriptor
///
/// NOTE: THE FILE MUST BE OPENED WITH ACCESS_MASK "DELETE" OR THIS WILL FAIL
pub fn deleteOpenedFile(fd: bun.FileDescriptor) Maybe(void) {
comptime bun.assert(builtin.target.os.version_range.windows.min.isAtLeast(.win10_rs5));
var info = w.FILE_DISPOSITION_INFORMATION_EX{
.Flags = FILE_DISPOSITION_DELETE |
FILE_DISPOSITION_POSIX_SEMANTICS |
FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE,
};
var io: w.IO_STATUS_BLOCK = undefined;
const rc = w.ntdll.NtSetInformationFile(
fd.cast(),
&io,
&info,
@sizeOf(w.FILE_DISPOSITION_INFORMATION_EX),
.FileDispositionInformationEx,
);
log("deleteOpenedFile({}) = {s}", .{ fd, @tagName(rc) });
return if (rc == .SUCCESS)
Maybe(void).success
else
Maybe(void).errno(rc, .NtSetInformationFile);
}
pub extern fn windows_enable_stdio_inheritance() void;
pub extern "c" fn quick_exit(code: c_int) noreturn;
Reference in New Issue View Git Blame Copy Permalink