/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this file, * You can obtain one at http://mozilla.org/MPL/2.0/. */ { if (typeof Components != "undefined") { // We do not wish osfile_unix_back.jsm to be used directly as a main thread // module yet. When time comes, it will be loaded by a combination of // a main thread front-end/worker thread implementation that makes sure // that we are not executing synchronous IO code in the main thread. throw new Error("osfile_unix_back.jsm cannot be used from the main thread yet"); } (function(exports) { "use strict"; if (exports.OS && exports.OS.Unix && exports.OS.Unix.File) { return; // Avoid double initialization } let SharedAll = require("resource://gre/modules/osfile/osfile_shared_allthreads.jsm"); let SysAll = require("resource://gre/modules/osfile/osfile_unix_allthreads.jsm"); let LOG = SharedAll.LOG.bind(SharedAll, "Unix", "back"); let libc = SysAll.libc; let Const = SharedAll.Constants.libc; /** * Initialize the Unix module. * * @param {function=} declareFFI */ // FIXME: Both |init| and |aDeclareFFI| are deprecated, we should remove them let init = function init(aDeclareFFI) { let declareFFI; if (aDeclareFFI) { declareFFI = aDeclareFFI.bind(null, libc); } else { declareFFI = SysAll.declareFFI; } let declareLazyFFI = SharedAll.declareLazyFFI; // Initialize types that require additional OS-specific // support - either finalization or matching against // OS-specific constants. let Type = Object.create(SysAll.Type); let SysFile = exports.OS.Unix.File = { Type: Type }; /** * A file descriptor. */ Type.fd = Type.int.withName("fd"); Type.fd.importFromC = function importFromC(fd_int) { return ctypes.CDataFinalizer(fd_int, SysFile._close); }; /** * A C integer holding -1 in case of error or a file descriptor * in case of success. */ Type.negativeone_or_fd = Type.fd.withName("negativeone_or_fd"); Type.negativeone_or_fd.importFromC = function importFromC(fd_int) { if (fd_int == -1) { return -1; } return ctypes.CDataFinalizer(fd_int, SysFile._close); }; /** * A C integer holding -1 in case of error or a meaningless value * in case of success. */ Type.negativeone_or_nothing = Type.int.withName("negativeone_or_nothing"); /** * A C integer holding -1 in case of error or a positive integer * in case of success. */ Type.negativeone_or_ssize_t = Type.ssize_t.withName("negativeone_or_ssize_t"); /** * Various libc integer types */ Type.mode_t = Type.intn_t(Const.OSFILE_SIZEOF_MODE_T).withName("mode_t"); Type.uid_t = Type.intn_t(Const.OSFILE_SIZEOF_UID_T).withName("uid_t"); Type.gid_t = Type.intn_t(Const.OSFILE_SIZEOF_GID_T).withName("gid_t"); /** * Type |time_t| */ Type.time_t = Type.intn_t(Const.OSFILE_SIZEOF_TIME_T).withName("time_t"); // Structure |dirent| // Building this type is rather complicated, as its layout varies between // variants of Unix. For this reason, we rely on a number of constants // (computed in C from the C data structures) that give us the layout. // The structure we compute looks like // { int8_t[...] before_d_type; // ignored content // int8_t d_type ; // int8_t[...] before_d_name; // ignored content // char[...] d_name; // }; { let d_name_extra_size = 0; if (Const.OSFILE_SIZEOF_DIRENT_D_NAME < 8) { // d_name is defined like "char d_name[1];" on some platforms // (e.g. Solaris), we need to give it more size for our structure. d_name_extra_size = 256; } let dirent = new SharedAll.HollowStructure("dirent", Const.OSFILE_SIZEOF_DIRENT + d_name_extra_size); if (Const.OSFILE_OFFSETOF_DIRENT_D_TYPE != undefined) { // |dirent| doesn't have d_type on some platforms (e.g. Solaris). dirent.add_field_at(Const.OSFILE_OFFSETOF_DIRENT_D_TYPE, "d_type", ctypes.uint8_t); } dirent.add_field_at(Const.OSFILE_OFFSETOF_DIRENT_D_NAME, "d_name", ctypes.ArrayType(ctypes.char, Const.OSFILE_SIZEOF_DIRENT_D_NAME + d_name_extra_size)); // We now have built |dirent|. Type.dirent = dirent.getType(); } Type.null_or_dirent_ptr = new SharedAll.Type("null_of_dirent", Type.dirent.out_ptr.implementation); // Structure |stat| // Same technique { let stat = new SharedAll.HollowStructure("stat", Const.OSFILE_SIZEOF_STAT); stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_MODE, "st_mode", Type.mode_t.implementation); stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_UID, "st_uid", Type.uid_t.implementation); stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_GID, "st_gid", Type.gid_t.implementation); // Here, things get complicated with different data structures. // Some platforms have |time_t st_atime| and some platforms have // |timespec st_atimespec|. However, since |timespec| starts with // a |time_t|, followed by nanoseconds, we just cheat and pretend // that everybody has |time_t st_atime|, possibly followed by padding stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_ATIME, "st_atime", Type.time_t.implementation); stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_MTIME, "st_mtime", Type.time_t.implementation); stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_CTIME, "st_ctime", Type.time_t.implementation); // To complicate further, MacOS and some BSDs have a field |birthtime| if ("OSFILE_OFFSETOF_STAT_ST_BIRTHTIME" in Const) { stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_BIRTHTIME, "st_birthtime", Type.time_t.implementation); } stat.add_field_at(Const.OSFILE_OFFSETOF_STAT_ST_SIZE, "st_size", Type.off_t.implementation); Type.stat = stat.getType(); } // Structure |DIR| if ("OSFILE_SIZEOF_DIR" in Const) { // On platforms for which we need to access the fields of DIR // directly (e.g. because certain functions are implemented // as macros), we need to define DIR as a hollow structure. let DIR = new SharedAll.HollowStructure( "DIR", Const.OSFILE_SIZEOF_DIR); DIR.add_field_at( Const.OSFILE_OFFSETOF_DIR_DD_FD, "dd_fd", Type.fd.implementation); Type.DIR = DIR.getType(); } else { // On other platforms, we keep DIR as a blackbox Type.DIR = new SharedAll.Type("DIR", ctypes.StructType("DIR")); } Type.null_or_DIR_ptr = Type.DIR.out_ptr.withName("null_or_DIR*"); Type.null_or_DIR_ptr.importFromC = function importFromC(dir) { if (dir == null || dir.isNull()) { return null; } return ctypes.CDataFinalizer(dir, SysFile._close_dir); }; // Structure |timeval| { let timeval = new SharedAll.HollowStructure( "timeval", Const.OSFILE_SIZEOF_TIMEVAL); timeval.add_field_at( Const.OSFILE_OFFSETOF_TIMEVAL_TV_SEC, "tv_sec", Type.long.implementation); timeval.add_field_at( Const.OSFILE_OFFSETOF_TIMEVAL_TV_USEC, "tv_usec", Type.long.implementation); Type.timeval = timeval.getType(); Type.timevals = new SharedAll.Type("two timevals", ctypes.ArrayType(Type.timeval.implementation, 2)); } // Types fsblkcnt_t and fsfilcnt_t, used by structure |statvfs| Type.fsblkcnt_t = Type.uintn_t(Const.OSFILE_SIZEOF_FSBLKCNT_T).withName("fsblkcnt_t"); // Structure |statvfs| // Use an hollow structure { let statvfs = new SharedAll.HollowStructure("statvfs", Const.OSFILE_SIZEOF_STATVFS); statvfs.add_field_at(Const.OSFILE_OFFSETOF_STATVFS_F_BSIZE, "f_bsize", Type.unsigned_long.implementation); statvfs.add_field_at(Const.OSFILE_OFFSETOF_STATVFS_F_BAVAIL, "f_bavail", Type.fsblkcnt_t.implementation); Type.statvfs = statvfs.getType(); } // Declare libc functions as functions of |OS.Unix.File| // Finalizer-related functions libc.declareLazy(SysFile, "_close", "close", ctypes.default_abi, /*return */ctypes.int, /*fd*/ ctypes.int); SysFile.close = function close(fd) { // Detach the finalizer and call |_close|. return fd.dispose(); }; libc.declareLazy(SysFile, "_close_dir", "closedir", ctypes.default_abi, /*return */ctypes.int, /*dirp*/ Type.DIR.in_ptr.implementation); SysFile.closedir = function closedir(fd) { // Detach the finalizer and call |_close_dir|. return fd.dispose(); }; { // Symbol free() is special. // We override the definition of free() on several platforms. let default_lib = new SharedAll.Library("default_lib", "a.out"); // On platforms for which we override free(), nspr defines // a special library name "a.out" that will resolve to the // correct implementation free(). // If it turns out we don't have an a.out library or a.out // doesn't contain free, use the ordinary libc free. default_lib.declareLazyWithFallback(libc, SysFile, "free", "free", ctypes.default_abi, /*return*/ ctypes.void_t, /*ptr*/ ctypes.voidptr_t); } // Other functions libc.declareLazyFFI(SysFile, "access", "access", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*mode*/ Type.int); libc.declareLazyFFI(SysFile, "chdir", "chdir", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path); libc.declareLazyFFI(SysFile, "chmod", "chmod", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*mode*/ Type.mode_t); libc.declareLazyFFI(SysFile, "chown", "chown", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*uid*/ Type.uid_t, /*gid*/ Type.gid_t); libc.declareLazyFFI(SysFile, "copyfile", "copyfile", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*source*/ Type.path, /*dest*/ Type.path, /*state*/ Type.void_t.in_ptr, // Ignored atm /*flags*/ Type.uint32_t); libc.declareLazyFFI(SysFile, "dup", "dup", ctypes.default_abi, /*return*/ Type.negativeone_or_fd, /*fd*/ Type.fd); if ("OSFILE_SIZEOF_DIR" in Const) { // On platforms for which |dirfd| is a macro SysFile.dirfd = function dirfd(DIRp) { return Type.DIR.in_ptr.implementation(DIRp).contents.dd_fd; }; } else { // On platforms for which |dirfd| is a function libc.declareLazyFFI(SysFile, "dirfd", "dirfd", ctypes.default_abi, /*return*/ Type.negativeone_or_fd, /*dir*/ Type.DIR.in_ptr); } libc.declareLazyFFI(SysFile, "chdir", "chdir", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path); libc.declareLazyFFI(SysFile, "fchdir", "fchdir", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd); libc.declareLazyFFI(SysFile, "fchmod", "fchmod", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd, /*mode*/ Type.mode_t); libc.declareLazyFFI(SysFile, "fchown", "fchown", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd, /*uid_t*/ Type.uid_t, /*gid_t*/ Type.gid_t); libc.declareLazyFFI(SysFile, "fsync", "fsync", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd); libc.declareLazyFFI(SysFile, "getcwd", "getcwd", ctypes.default_abi, /*return*/ Type.out_path, /*buf*/ Type.out_path, /*size*/ Type.size_t); libc.declareLazyFFI(SysFile, "getwd", "getwd", ctypes.default_abi, /*return*/ Type.out_path, /*buf*/ Type.out_path); // Two variants of |getwd| which allocate the memory // dynamically. // Linux/Android version libc.declareLazyFFI(SysFile, "get_current_dir_name", "get_current_dir_name", ctypes.default_abi, /*return*/ Type.out_path.releaseWithLazy(() => SysFile.free )); // MacOS/BSD version (will return NULL on Linux/Android) libc.declareLazyFFI(SysFile, "getwd_auto", "getwd", ctypes.default_abi, /*return*/ Type.out_path.releaseWithLazy(() => SysFile.free ), /*buf*/ Type.void_t.out_ptr); libc.declareLazyFFI(SysFile, "fdatasync", "fdatasync", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd); // Note: MacOS/BSD-specific libc.declareLazyFFI(SysFile, "ftruncate", "ftruncate", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd, /*length*/ Type.off_t); libc.declareLazyFFI(SysFile, "lchown", "lchown", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*uid_t*/ Type.uid_t, /*gid_t*/ Type.gid_t); libc.declareLazyFFI(SysFile, "link", "link", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*source*/ Type.path, /*dest*/ Type.path); libc.declareLazyFFI(SysFile, "lseek", "lseek", ctypes.default_abi, /*return*/ Type.off_t, /*fd*/ Type.fd, /*offset*/ Type.off_t, /*whence*/ Type.int); libc.declareLazyFFI(SysFile, "mkdir", "mkdir", ctypes.default_abi, /*return*/ Type.int, /*path*/ Type.path, /*mode*/ Type.int); libc.declareLazyFFI(SysFile, "mkstemp", "mkstemp", ctypes.default_abi, /*return*/ Type.fd, /*template*/ Type.out_path); libc.declareLazyFFI(SysFile, "open", "open", ctypes.default_abi, /*return*/ Type.negativeone_or_fd, /*path*/ Type.path, /*oflags*/ Type.int, /*mode*/ Type.int); if (OS.Constants.Sys.Name == "NetBSD") { libc.declareLazyFFI(SysFile, "opendir", "__opendir30", ctypes.default_abi, /*return*/ Type.null_or_DIR_ptr, /*path*/ Type.path); } else { libc.declareLazyFFI(SysFile, "opendir", "opendir", ctypes.default_abi, /*return*/ Type.null_or_DIR_ptr, /*path*/ Type.path); } libc.declareLazyFFI(SysFile, "pread", "pread", ctypes.default_abi, /*return*/ Type.negativeone_or_ssize_t, /*fd*/ Type.fd, /*buf*/ Type.void_t.out_ptr, /*nbytes*/ Type.size_t, /*offset*/ Type.off_t); libc.declareLazyFFI(SysFile, "pwrite", "pwrite", ctypes.default_abi, /*return*/ Type.negativeone_or_ssize_t, /*fd*/ Type.fd, /*buf*/ Type.void_t.in_ptr, /*nbytes*/ Type.size_t, /*offset*/ Type.off_t); libc.declareLazyFFI(SysFile, "read", "read", ctypes.default_abi, /*return*/Type.negativeone_or_ssize_t, /*fd*/ Type.fd, /*buf*/ Type.void_t.out_ptr, /*nbytes*/Type.size_t); libc.declareLazyFFI(SysFile, "posix_fadvise", "posix_fadvise", ctypes.default_abi, /*return*/ Type.int, /*fd*/ Type.fd, /*offset*/ Type.off_t, /*len*/ Type.off_t, /*advise*/ Type.int); if (Const._DARWIN_FEATURE_64_BIT_INODE) { // Special case for MacOS X 10.5+ // Symbol name "readdir" still exists but is used for a // deprecated function that does not match the // constants of |Const|. libc.declareLazyFFI(SysFile, "readdir", "readdir$INODE64", ctypes.default_abi, /*return*/ Type.null_or_dirent_ptr, /*dir*/ Type.DIR.in_ptr); // For MacOS X } else if (OS.Constants.Sys.Name == "NetBSD") { libc.declareLazyFFI(SysFile, "readdir", "__readdir30", ctypes.default_abi, /*return*/Type.null_or_dirent_ptr, /*dir*/ Type.DIR.in_ptr); // Other Unices } else { libc.declareLazyFFI(SysFile, "readdir", "readdir", ctypes.default_abi, /*return*/Type.null_or_dirent_ptr, /*dir*/ Type.DIR.in_ptr); // Other Unices } libc.declareLazyFFI(SysFile, "rename", "rename", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*old*/ Type.path, /*new*/ Type.path); libc.declareLazyFFI(SysFile, "rmdir", "rmdir", ctypes.default_abi, /*return*/ Type.int, /*path*/ Type.path); libc.declareLazyFFI(SysFile, "splice", "splice", ctypes.default_abi, /*return*/ Type.long, /*fd_in*/ Type.fd, /*off_in*/ Type.off_t.in_ptr, /*fd_out*/ Type.fd, /*off_out*/Type.off_t.in_ptr, /*len*/ Type.size_t, /*flags*/ Type.unsigned_int); // Linux/Android-specific libc.declareLazyFFI(SysFile, "statfs", "statfs", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*buf*/ Type.statvfs.out_ptr); // Android,B2G libc.declareLazyFFI(SysFile, "statvfs", "statvfs", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*buf*/ Type.statvfs.out_ptr); // Other platforms libc.declareLazyFFI(SysFile, "symlink", "symlink", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*source*/ Type.path, /*dest*/ Type.path); libc.declareLazyFFI(SysFile, "truncate", "truncate", ctypes.default_abi, /*return*/Type.negativeone_or_nothing, /*path*/ Type.path, /*length*/ Type.off_t); libc.declareLazyFFI(SysFile, "unlink", "unlink", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path); libc.declareLazyFFI(SysFile, "write", "write", ctypes.default_abi, /*return*/ Type.negativeone_or_ssize_t, /*fd*/ Type.fd, /*buf*/ Type.void_t.in_ptr, /*nbytes*/ Type.size_t); // Weird cases that require special treatment // OSes use a variety of hacks to differentiate between // 32-bits and 64-bits versions of |stat|, |lstat|, |fstat|. if (Const._DARWIN_FEATURE_64_BIT_INODE) { // MacOS X 64-bits libc.declareLazyFFI(SysFile, "stat", "stat$INODE64", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*buf*/ Type.stat.out_ptr ); libc.declareLazyFFI(SysFile, "lstat", "lstat$INODE64", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*buf*/ Type.stat.out_ptr ); libc.declareLazyFFI(SysFile, "fstat", "fstat$INODE64", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.fd, /*buf*/ Type.stat.out_ptr ); } else if (Const._STAT_VER != undefined) { const ver = Const._STAT_VER; let xstat_name, lxstat_name, fxstat_name; if (OS.Constants.Sys.Name == "SunOS") { // Solaris xstat_name = "_xstat"; lxstat_name = "_lxstat"; fxstat_name = "_fxstat"; } else { // Linux, all widths xstat_name = "__xstat"; lxstat_name = "__lxstat"; fxstat_name = "__fxstat"; } let Stat = {}; libc.declareLazyFFI(Stat, "xstat", xstat_name, ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*_stat_ver*/ Type.int, /*path*/ Type.path, /*buf*/ Type.stat.out_ptr); libc.declareLazyFFI(Stat, "lxstat", lxstat_name, ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*_stat_ver*/ Type.int, /*path*/ Type.path, /*buf*/ Type.stat.out_ptr); libc.declareLazyFFI(Stat, "fxstat", fxstat_name, ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*_stat_ver*/ Type.int, /*fd*/ Type.fd, /*buf*/ Type.stat.out_ptr); SysFile.stat = function stat(path, buf) { return Stat.xstat(ver, path, buf); }; SysFile.lstat = function lstat(path, buf) { return Stat.lxstat(ver, path, buf); }; SysFile.fstat = function fstat(fd, buf) { return Stat.fxstat(ver, fd, buf); }; } else if (OS.Constants.Sys.Name == "NetBSD") { // NetBSD 5.0 and newer libc.declareLazyFFI(SysFile, "stat", "__stat50", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*buf*/ Type.stat.out_ptr ); libc.declareLazyFFI(SysFile, "lstat", "__lstat50", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*buf*/ Type.stat.out_ptr ); libc.declareLazyFFI(SysFile, "fstat", "__fstat50", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd, /*buf*/ Type.stat.out_ptr ); } else { // Mac OS X 32-bits, other Unix libc.declareLazyFFI(SysFile, "stat", "stat", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*buf*/ Type.stat.out_ptr ); libc.declareLazyFFI(SysFile, "lstat", "lstat", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*buf*/ Type.stat.out_ptr ); libc.declareLazyFFI(SysFile, "fstat", "fstat", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd, /*buf*/ Type.stat.out_ptr ); } // We cannot make a C array of CDataFinalizer, so // pipe cannot be directly defined as a C function. let Pipe = {}; libc.declareLazyFFI(Pipe, "_pipe", "pipe", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fds*/ new SharedAll.Type("two file descriptors", ctypes.ArrayType(ctypes.int, 2))); // A shared per-thread buffer used to communicate with |pipe| let _pipebuf = new (ctypes.ArrayType(ctypes.int, 2))(); SysFile.pipe = function pipe(array) { let result = Pipe._pipe(_pipebuf); if (result == -1) { return result; } array[0] = ctypes.CDataFinalizer(_pipebuf[0], SysFile._close); array[1] = ctypes.CDataFinalizer(_pipebuf[1], SysFile._close); return result; }; if (OS.Constants.Sys.Name == "NetBSD") { libc.declareLazyFFI(SysFile, "utimes", "__utimes50", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*timeval[2]*/ Type.timevals.out_ptr ); } else { libc.declareLazyFFI(SysFile, "utimes", "utimes", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*path*/ Type.path, /*timeval[2]*/ Type.timevals.out_ptr ); } if (OS.Constants.Sys.Name == "NetBSD") { libc.declareLazyFFI(SysFile, "futimes", "__futimes50", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd, /*timeval[2]*/ Type.timevals.out_ptr ); } else { libc.declareLazyFFI(SysFile, "futimes", "futimes", ctypes.default_abi, /*return*/ Type.negativeone_or_nothing, /*fd*/ Type.fd, /*timeval[2]*/ Type.timevals.out_ptr ); } }; exports.OS.Unix = { File: { _init: init } }; })(this); }