737 lines
29 KiB
JavaScript
737 lines
29 KiB
JavaScript
/* 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);
|
|
}
|