summaryrefslogtreecommitdiffstats
path: root/dom/system/OSFileConstants.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/system/OSFileConstants.cpp')
-rw-r--r--dom/system/OSFileConstants.cpp1119
1 files changed, 1119 insertions, 0 deletions
diff --git a/dom/system/OSFileConstants.cpp b/dom/system/OSFileConstants.cpp
new file mode 100644
index 000000000..945233f4c
--- /dev/null
+++ b/dom/system/OSFileConstants.cpp
@@ -0,0 +1,1119 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "mozilla/DebugOnly.h"
+
+#include "fcntl.h"
+#include "errno.h"
+
+#include "prsystem.h"
+
+#if defined(XP_UNIX)
+#include "unistd.h"
+#include "dirent.h"
+#include "poll.h"
+#include "sys/stat.h"
+#if defined(ANDROID)
+#include <sys/vfs.h>
+#define statvfs statfs
+#else
+#include "sys/statvfs.h"
+#include "sys/wait.h"
+#include <spawn.h>
+#endif // defined(ANDROID)
+#endif // defined(XP_UNIX)
+
+#if defined(XP_LINUX)
+#include <linux/fadvise.h>
+#endif // defined(XP_LINUX)
+
+#if defined(XP_MACOSX)
+#include "copyfile.h"
+#endif // defined(XP_MACOSX)
+
+#if defined(XP_WIN)
+#include <windows.h>
+#include <accctrl.h>
+
+#define PATH_MAX MAX_PATH
+
+#endif // defined(XP_WIN)
+
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "BindingUtils.h"
+
+// Used to provide information on the OS
+
+#include "nsThreadUtils.h"
+#include "nsIObserverService.h"
+#include "nsIObserver.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsIXULRuntime.h"
+#include "nsIPropertyBag2.h"
+#include "nsXPCOMCIDInternal.h"
+#include "nsServiceManagerUtils.h"
+#include "nsString.h"
+#include "nsAutoPtr.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsXULAppAPI.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "mozJSComponentLoader.h"
+
+#include "OSFileConstants.h"
+#include "nsIOSFileConstantsService.h"
+#include "nsZipArchive.h"
+
+#if defined(__DragonFly__) || defined(__FreeBSD__) \
+ || defined(__NetBSD__) || defined(__OpenBSD__)
+#define __dd_fd dd_fd
+#endif
+
+/**
+ * This module defines the basic libc constants (error numbers, open modes,
+ * etc.) used by OS.File and possibly other OS-bound JavaScript libraries.
+ */
+
+
+namespace mozilla {
+
+// Use an anonymous namespace to hide the symbols and avoid any collision
+// with, for instance, |extern bool gInitialized;|
+namespace {
+/**
+ * |true| if this module has been initialized, |false| otherwise
+ */
+bool gInitialized = false;
+
+struct Paths {
+ /**
+ * The name of the directory holding all the libraries (libxpcom, libnss, etc.)
+ */
+ nsString libDir;
+ nsString tmpDir;
+ nsString profileDir;
+ nsString localProfileDir;
+ /**
+ * The user's home directory
+ */
+ nsString homeDir;
+ /**
+ * The user's desktop directory, if there is one. Otherwise this is
+ * the same as homeDir.
+ */
+ nsString desktopDir;
+ /**
+ * The user's 'application data' directory.
+ * Windows:
+ * HOME = Documents and Settings\$USER\Application Data
+ * UAppData = $HOME[\$vendor]\$name
+ *
+ * Unix:
+ * HOME = ~
+ * UAppData = $HOME/.[$vendor/]$name
+ *
+ * Mac:
+ * HOME = ~
+ * UAppData = $HOME/Library/Application Support/$name
+ */
+ nsString userApplicationDataDir;
+
+#if defined(XP_WIN)
+ /**
+ * The user's application data directory.
+ */
+ nsString winAppDataDir;
+ /**
+ * The programs subdirectory in the user's start menu directory.
+ */
+ nsString winStartMenuProgsDir;
+#endif // defined(XP_WIN)
+
+#if defined(XP_MACOSX)
+ /**
+ * The user's Library directory.
+ */
+ nsString macUserLibDir;
+ /**
+ * The Application directory, that stores applications installed in the
+ * system.
+ */
+ nsString macLocalApplicationsDir;
+ /**
+ * The user's trash directory.
+ */
+ nsString macTrashDir;
+#endif // defined(XP_MACOSX)
+
+ Paths()
+ {
+ libDir.SetIsVoid(true);
+ tmpDir.SetIsVoid(true);
+ profileDir.SetIsVoid(true);
+ localProfileDir.SetIsVoid(true);
+ homeDir.SetIsVoid(true);
+ desktopDir.SetIsVoid(true);
+ userApplicationDataDir.SetIsVoid(true);
+
+#if defined(XP_WIN)
+ winAppDataDir.SetIsVoid(true);
+ winStartMenuProgsDir.SetIsVoid(true);
+#endif // defined(XP_WIN)
+
+#if defined(XP_MACOSX)
+ macUserLibDir.SetIsVoid(true);
+ macLocalApplicationsDir.SetIsVoid(true);
+ macTrashDir.SetIsVoid(true);
+#endif // defined(XP_MACOSX)
+ }
+};
+
+/**
+ * System directories.
+ */
+Paths* gPaths = nullptr;
+
+/**
+ * (Unix) the umask, which goes in OS.Constants.Sys but
+ * can only be looked up (via the system-info service)
+ * on the main thread.
+ */
+uint32_t gUserUmask = 0;
+} // namespace
+
+/**
+ * Return the path to one of the special directories.
+ *
+ * @param aKey The key to the special directory (e.g. "TmpD", "ProfD", ...)
+ * @param aOutPath The path to the special directory. In case of error,
+ * the string is set to void.
+ */
+nsresult GetPathToSpecialDir(const char *aKey, nsString& aOutPath)
+{
+ nsCOMPtr<nsIFile> file;
+ nsresult rv = NS_GetSpecialDirectory(aKey, getter_AddRefs(file));
+ if (NS_FAILED(rv) || !file) {
+ return rv;
+ }
+
+ return file->GetPath(aOutPath);
+}
+
+/**
+ * In some cases, OSFileConstants may be instantiated before the
+ * profile is setup. In such cases, |OS.Constants.Path.profileDir| and
+ * |OS.Constants.Path.localProfileDir| are undefined. However, we want
+ * to ensure that this does not break existing code, so that future
+ * workers spawned after the profile is setup have these constants.
+ *
+ * For this purpose, we register an observer to set |gPaths->profileDir|
+ * and |gPaths->localProfileDir| once the profile is setup.
+ */
+class DelayedPathSetter final: public nsIObserver
+{
+ ~DelayedPathSetter() {}
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVER
+
+ DelayedPathSetter() {}
+};
+
+NS_IMPL_ISUPPORTS(DelayedPathSetter, nsIObserver)
+
+NS_IMETHODIMP
+DelayedPathSetter::Observe(nsISupports*, const char * aTopic, const char16_t*)
+{
+ if (gPaths == nullptr) {
+ // Initialization of gPaths has not taken place, something is wrong,
+ // don't make things worse.
+ return NS_OK;
+ }
+ nsresult rv = GetPathToSpecialDir(NS_APP_USER_PROFILE_50_DIR, gPaths->profileDir);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ rv = GetPathToSpecialDir(NS_APP_USER_PROFILE_LOCAL_50_DIR, gPaths->localProfileDir);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+/**
+ * Perform the part of initialization that can only be
+ * executed on the main thread.
+ */
+nsresult InitOSFileConstants()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (gInitialized) {
+ return NS_OK;
+ }
+
+ gInitialized = true;
+
+ nsAutoPtr<Paths> paths(new Paths);
+
+ // Initialize paths->libDir
+ nsCOMPtr<nsIFile> file;
+ nsresult rv = NS_GetSpecialDirectory(NS_XPCOM_LIBRARY_FILE, getter_AddRefs(file));
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ nsCOMPtr<nsIFile> libDir;
+ rv = file->GetParent(getter_AddRefs(libDir));
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ rv = libDir->GetPath(paths->libDir);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ // Setup profileDir and localProfileDir immediately if possible (we
+ // assume that NS_APP_USER_PROFILE_50_DIR and
+ // NS_APP_USER_PROFILE_LOCAL_50_DIR are set simultaneously)
+ rv = GetPathToSpecialDir(NS_APP_USER_PROFILE_50_DIR, paths->profileDir);
+ if (NS_SUCCEEDED(rv)) {
+ rv = GetPathToSpecialDir(NS_APP_USER_PROFILE_LOCAL_50_DIR, paths->localProfileDir);
+ }
+
+ // Otherwise, delay setup of profileDir/localProfileDir until they
+ // become available.
+ if (NS_FAILED(rv)) {
+ nsCOMPtr<nsIObserverService> obsService = do_GetService(NS_OBSERVERSERVICE_CONTRACTID, &rv);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ RefPtr<DelayedPathSetter> pathSetter = new DelayedPathSetter();
+ rv = obsService->AddObserver(pathSetter, "profile-do-change", false);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ }
+
+ // For other directories, ignore errors (they may be undefined on
+ // some platforms or in non-Firefox embeddings of Gecko).
+
+ GetPathToSpecialDir(NS_OS_TEMP_DIR, paths->tmpDir);
+ GetPathToSpecialDir(NS_OS_HOME_DIR, paths->homeDir);
+ GetPathToSpecialDir(NS_OS_DESKTOP_DIR, paths->desktopDir);
+ GetPathToSpecialDir(XRE_USER_APP_DATA_DIR, paths->userApplicationDataDir);
+
+#if defined(XP_WIN)
+ GetPathToSpecialDir(NS_WIN_APPDATA_DIR, paths->winAppDataDir);
+ GetPathToSpecialDir(NS_WIN_PROGRAMS_DIR, paths->winStartMenuProgsDir);
+#endif // defined(XP_WIN)
+
+#if defined(XP_MACOSX)
+ GetPathToSpecialDir(NS_MAC_USER_LIB_DIR, paths->macUserLibDir);
+ GetPathToSpecialDir(NS_OSX_LOCAL_APPLICATIONS_DIR, paths->macLocalApplicationsDir);
+ GetPathToSpecialDir(NS_MAC_TRASH_DIR, paths->macTrashDir);
+#endif // defined(XP_MACOSX)
+
+ gPaths = paths.forget();
+
+ // Get the umask from the system-info service.
+ // The property will always be present, but it will be zero on
+ // non-Unix systems.
+ nsCOMPtr<nsIPropertyBag2> infoService =
+ do_GetService("@mozilla.org/system-info;1");
+ MOZ_ASSERT(infoService, "Could not access the system information service");
+ rv = infoService->GetPropertyAsUint32(NS_LITERAL_STRING("umask"),
+ &gUserUmask);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+/**
+ * Perform the cleaning up that can only be executed on the main thread.
+ */
+void CleanupOSFileConstants()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (!gInitialized) {
+ return;
+ }
+
+ gInitialized = false;
+ delete gPaths;
+ gPaths = nullptr;
+}
+
+
+/**
+ * Define a simple read-only property holding an integer.
+ *
+ * @param name The name of the constant. Used both as the JS name for the
+ * constant and to access its value. Must be defined.
+ *
+ * Produces a |ConstantSpec|.
+ */
+#define INT_CONSTANT(name) \
+ { #name, JS::Int32Value(name) }
+
+/**
+ * Define a simple read-only property holding an unsigned integer.
+ *
+ * @param name The name of the constant. Used both as the JS name for the
+ * constant and to access its value. Must be defined.
+ *
+ * Produces a |ConstantSpec|.
+ */
+#define UINT_CONSTANT(name) \
+ { #name, JS::NumberValue(name) }
+
+/**
+ * End marker for ConstantSpec
+ */
+#define PROP_END { nullptr, JS::UndefinedValue() }
+
+
+// Define missing constants for Android
+#if !defined(S_IRGRP)
+#define S_IXOTH 0001
+#define S_IWOTH 0002
+#define S_IROTH 0004
+#define S_IRWXO 0007
+#define S_IXGRP 0010
+#define S_IWGRP 0020
+#define S_IRGRP 0040
+#define S_IRWXG 0070
+#define S_IXUSR 0100
+#define S_IWUSR 0200
+#define S_IRUSR 0400
+#define S_IRWXU 0700
+#endif // !defined(S_IRGRP)
+
+/**
+ * The properties defined in libc.
+ *
+ * If you extend this list of properties, please
+ * separate categories ("errors", "open", etc.),
+ * keep properties organized by alphabetical order
+ * and #ifdef-away properties that are not portable.
+ */
+static const dom::ConstantSpec gLibcProperties[] =
+{
+ // Arguments for open
+ INT_CONSTANT(O_APPEND),
+#if defined(O_CLOEXEC)
+ INT_CONSTANT(O_CLOEXEC),
+#endif // defined(O_CLOEXEC)
+ INT_CONSTANT(O_CREAT),
+#if defined(O_DIRECTORY)
+ INT_CONSTANT(O_DIRECTORY),
+#endif // defined(O_DIRECTORY)
+#if defined(O_EVTONLY)
+ INT_CONSTANT(O_EVTONLY),
+#endif // defined(O_EVTONLY)
+ INT_CONSTANT(O_EXCL),
+#if defined(O_EXLOCK)
+ INT_CONSTANT(O_EXLOCK),
+#endif // defined(O_EXLOCK)
+#if defined(O_LARGEFILE)
+ INT_CONSTANT(O_LARGEFILE),
+#endif // defined(O_LARGEFILE)
+#if defined(O_NOFOLLOW)
+ INT_CONSTANT(O_NOFOLLOW),
+#endif // defined(O_NOFOLLOW)
+#if defined(O_NONBLOCK)
+ INT_CONSTANT(O_NONBLOCK),
+#endif // defined(O_NONBLOCK)
+ INT_CONSTANT(O_RDONLY),
+ INT_CONSTANT(O_RDWR),
+#if defined(O_RSYNC)
+ INT_CONSTANT(O_RSYNC),
+#endif // defined(O_RSYNC)
+#if defined(O_SHLOCK)
+ INT_CONSTANT(O_SHLOCK),
+#endif // defined(O_SHLOCK)
+#if defined(O_SYMLINK)
+ INT_CONSTANT(O_SYMLINK),
+#endif // defined(O_SYMLINK)
+#if defined(O_SYNC)
+ INT_CONSTANT(O_SYNC),
+#endif // defined(O_SYNC)
+ INT_CONSTANT(O_TRUNC),
+ INT_CONSTANT(O_WRONLY),
+
+#if defined(FD_CLOEXEC)
+ INT_CONSTANT(FD_CLOEXEC),
+#endif // defined(FD_CLOEXEC)
+
+#if defined(AT_EACCESS)
+ INT_CONSTANT(AT_EACCESS),
+#endif //defined(AT_EACCESS)
+#if defined(AT_FDCWD)
+ INT_CONSTANT(AT_FDCWD),
+#endif //defined(AT_FDCWD)
+#if defined(AT_SYMLINK_NOFOLLOW)
+ INT_CONSTANT(AT_SYMLINK_NOFOLLOW),
+#endif //defined(AT_SYMLINK_NOFOLLOW)
+
+#if defined(POSIX_FADV_SEQUENTIAL)
+ INT_CONSTANT(POSIX_FADV_SEQUENTIAL),
+#endif //defined(POSIX_FADV_SEQUENTIAL)
+
+ // access
+#if defined(F_OK)
+ INT_CONSTANT(F_OK),
+ INT_CONSTANT(R_OK),
+ INT_CONSTANT(W_OK),
+ INT_CONSTANT(X_OK),
+#endif // defined(F_OK)
+
+ // modes
+ INT_CONSTANT(S_IRGRP),
+ INT_CONSTANT(S_IROTH),
+ INT_CONSTANT(S_IRUSR),
+ INT_CONSTANT(S_IRWXG),
+ INT_CONSTANT(S_IRWXO),
+ INT_CONSTANT(S_IRWXU),
+ INT_CONSTANT(S_IWGRP),
+ INT_CONSTANT(S_IWOTH),
+ INT_CONSTANT(S_IWUSR),
+ INT_CONSTANT(S_IXOTH),
+ INT_CONSTANT(S_IXGRP),
+ INT_CONSTANT(S_IXUSR),
+
+ // seek
+ INT_CONSTANT(SEEK_CUR),
+ INT_CONSTANT(SEEK_END),
+ INT_CONSTANT(SEEK_SET),
+
+#if defined(XP_UNIX)
+ // poll
+ INT_CONSTANT(POLLERR),
+ INT_CONSTANT(POLLHUP),
+ INT_CONSTANT(POLLIN),
+ INT_CONSTANT(POLLNVAL),
+ INT_CONSTANT(POLLOUT),
+
+ // wait
+#if defined(WNOHANG)
+ INT_CONSTANT(WNOHANG),
+#endif // defined(WNOHANG)
+
+ // fcntl command values
+ INT_CONSTANT(F_GETLK),
+ INT_CONSTANT(F_SETFD),
+ INT_CONSTANT(F_SETFL),
+ INT_CONSTANT(F_SETLK),
+ INT_CONSTANT(F_SETLKW),
+
+ // flock type values
+ INT_CONSTANT(F_RDLCK),
+ INT_CONSTANT(F_WRLCK),
+ INT_CONSTANT(F_UNLCK),
+
+ // splice
+#if defined(SPLICE_F_MOVE)
+ INT_CONSTANT(SPLICE_F_MOVE),
+#endif // defined(SPLICE_F_MOVE)
+#if defined(SPLICE_F_NONBLOCK)
+ INT_CONSTANT(SPLICE_F_NONBLOCK),
+#endif // defined(SPLICE_F_NONBLOCK)
+#if defined(SPLICE_F_MORE)
+ INT_CONSTANT(SPLICE_F_MORE),
+#endif // defined(SPLICE_F_MORE)
+#if defined(SPLICE_F_GIFT)
+ INT_CONSTANT(SPLICE_F_GIFT),
+#endif // defined(SPLICE_F_GIFT)
+#endif // defined(XP_UNIX)
+ // copyfile
+#if defined(COPYFILE_DATA)
+ INT_CONSTANT(COPYFILE_DATA),
+ INT_CONSTANT(COPYFILE_EXCL),
+ INT_CONSTANT(COPYFILE_XATTR),
+ INT_CONSTANT(COPYFILE_STAT),
+ INT_CONSTANT(COPYFILE_ACL),
+ INT_CONSTANT(COPYFILE_MOVE),
+#endif // defined(COPYFILE_DATA)
+
+ // error values
+ INT_CONSTANT(EACCES),
+ INT_CONSTANT(EAGAIN),
+ INT_CONSTANT(EBADF),
+ INT_CONSTANT(EEXIST),
+ INT_CONSTANT(EFAULT),
+ INT_CONSTANT(EFBIG),
+ INT_CONSTANT(EINVAL),
+ INT_CONSTANT(EIO),
+ INT_CONSTANT(EISDIR),
+#if defined(ELOOP) // not defined with VC9
+ INT_CONSTANT(ELOOP),
+#endif // defined(ELOOP)
+ INT_CONSTANT(EMFILE),
+ INT_CONSTANT(ENAMETOOLONG),
+ INT_CONSTANT(ENFILE),
+ INT_CONSTANT(ENOENT),
+ INT_CONSTANT(ENOMEM),
+ INT_CONSTANT(ENOSPC),
+ INT_CONSTANT(ENOTDIR),
+ INT_CONSTANT(ENXIO),
+#if defined(EOPNOTSUPP) // not defined with VC 9
+ INT_CONSTANT(EOPNOTSUPP),
+#endif // defined(EOPNOTSUPP)
+#if defined(EOVERFLOW) // not defined with VC 9
+ INT_CONSTANT(EOVERFLOW),
+#endif // defined(EOVERFLOW)
+ INT_CONSTANT(EPERM),
+ INT_CONSTANT(ERANGE),
+#if defined(ETIMEDOUT) // not defined with VC 9
+ INT_CONSTANT(ETIMEDOUT),
+#endif // defined(ETIMEDOUT)
+#if defined(EWOULDBLOCK) // not defined with VC 9
+ INT_CONSTANT(EWOULDBLOCK),
+#endif // defined(EWOULDBLOCK)
+ INT_CONSTANT(EXDEV),
+
+#if defined(DT_UNKNOWN)
+ // Constants for |readdir|
+ INT_CONSTANT(DT_UNKNOWN),
+ INT_CONSTANT(DT_FIFO),
+ INT_CONSTANT(DT_CHR),
+ INT_CONSTANT(DT_DIR),
+ INT_CONSTANT(DT_BLK),
+ INT_CONSTANT(DT_REG),
+ INT_CONSTANT(DT_LNK),
+ INT_CONSTANT(DT_SOCK),
+#endif // defined(DT_UNKNOWN)
+
+#if defined(S_IFIFO)
+ // Constants for |stat|
+ INT_CONSTANT(S_IFMT),
+ INT_CONSTANT(S_IFIFO),
+ INT_CONSTANT(S_IFCHR),
+ INT_CONSTANT(S_IFDIR),
+ INT_CONSTANT(S_IFBLK),
+ INT_CONSTANT(S_IFREG),
+ INT_CONSTANT(S_IFLNK),
+ INT_CONSTANT(S_IFSOCK),
+#endif // defined(S_IFIFO)
+
+ INT_CONSTANT(PATH_MAX),
+
+ // Constants used to define data structures
+ //
+ // Many data structures have different fields/sizes/etc. on
+ // various OSes / versions of the same OS / platforms. For these
+ // data structures, we need to compute and export from C the size
+ // and, if necessary, the offset of fields, so as to be able to
+ // define the structure in JS.
+
+#if defined(XP_UNIX)
+ // The size of |mode_t|.
+ { "OSFILE_SIZEOF_MODE_T", JS::Int32Value(sizeof (mode_t)) },
+
+ // The size of |gid_t|.
+ { "OSFILE_SIZEOF_GID_T", JS::Int32Value(sizeof (gid_t)) },
+
+ // The size of |uid_t|.
+ { "OSFILE_SIZEOF_UID_T", JS::Int32Value(sizeof (uid_t)) },
+
+ // The size of |time_t|.
+ { "OSFILE_SIZEOF_TIME_T", JS::Int32Value(sizeof (time_t)) },
+
+ // The size of |fsblkcnt_t|.
+ { "OSFILE_SIZEOF_FSBLKCNT_T", JS::Int32Value(sizeof (fsblkcnt_t)) },
+
+#if !defined(ANDROID)
+ // The size of |posix_spawn_file_actions_t|.
+ { "OSFILE_SIZEOF_POSIX_SPAWN_FILE_ACTIONS_T", JS::Int32Value(sizeof (posix_spawn_file_actions_t)) },
+#endif // !defined(ANDROID)
+
+ // Defining |dirent|.
+ // Size
+ { "OSFILE_SIZEOF_DIRENT", JS::Int32Value(sizeof (dirent)) },
+
+ // Defining |flock|.
+#if defined(XP_UNIX)
+ { "OSFILE_SIZEOF_FLOCK", JS::Int32Value(sizeof (struct flock)) },
+ { "OSFILE_OFFSETOF_FLOCK_L_START", JS::Int32Value(offsetof (struct flock, l_start)) },
+ { "OSFILE_OFFSETOF_FLOCK_L_LEN", JS::Int32Value(offsetof (struct flock, l_len)) },
+ { "OSFILE_OFFSETOF_FLOCK_L_PID", JS::Int32Value(offsetof (struct flock, l_pid)) },
+ { "OSFILE_OFFSETOF_FLOCK_L_TYPE", JS::Int32Value(offsetof (struct flock, l_type)) },
+ { "OSFILE_OFFSETOF_FLOCK_L_WHENCE", JS::Int32Value(offsetof (struct flock, l_whence)) },
+#endif // defined(XP_UNIX)
+ // Offset of field |d_name|.
+ { "OSFILE_OFFSETOF_DIRENT_D_NAME", JS::Int32Value(offsetof (struct dirent, d_name)) },
+ // An upper bound to the length of field |d_name| of struct |dirent|.
+ // (may not be exact, depending on padding).
+ { "OSFILE_SIZEOF_DIRENT_D_NAME", JS::Int32Value(sizeof (struct dirent) - offsetof (struct dirent, d_name)) },
+
+ // Defining |timeval|.
+ { "OSFILE_SIZEOF_TIMEVAL", JS::Int32Value(sizeof (struct timeval)) },
+ { "OSFILE_OFFSETOF_TIMEVAL_TV_SEC", JS::Int32Value(offsetof (struct timeval, tv_sec)) },
+ { "OSFILE_OFFSETOF_TIMEVAL_TV_USEC", JS::Int32Value(offsetof (struct timeval, tv_usec)) },
+
+#if defined(DT_UNKNOWN)
+ // Position of field |d_type| in |dirent|
+ // Not strictly posix, but seems defined on all platforms
+ // except mingw32.
+ { "OSFILE_OFFSETOF_DIRENT_D_TYPE", JS::Int32Value(offsetof (struct dirent, d_type)) },
+#endif // defined(DT_UNKNOWN)
+
+ // Under MacOS X and BSDs, |dirfd| is a macro rather than a
+ // function, so we need a little help to get it to work
+#if defined(dirfd)
+ { "OSFILE_SIZEOF_DIR", JS::Int32Value(sizeof (DIR)) },
+
+ { "OSFILE_OFFSETOF_DIR_DD_FD", JS::Int32Value(offsetof (DIR, __dd_fd)) },
+#endif
+
+ // Defining |stat|
+
+ { "OSFILE_SIZEOF_STAT", JS::Int32Value(sizeof (struct stat)) },
+
+ { "OSFILE_OFFSETOF_STAT_ST_MODE", JS::Int32Value(offsetof (struct stat, st_mode)) },
+ { "OSFILE_OFFSETOF_STAT_ST_UID", JS::Int32Value(offsetof (struct stat, st_uid)) },
+ { "OSFILE_OFFSETOF_STAT_ST_GID", JS::Int32Value(offsetof (struct stat, st_gid)) },
+ { "OSFILE_OFFSETOF_STAT_ST_SIZE", JS::Int32Value(offsetof (struct stat, st_size)) },
+
+#if defined(HAVE_ST_ATIMESPEC)
+ { "OSFILE_OFFSETOF_STAT_ST_ATIME", JS::Int32Value(offsetof (struct stat, st_atimespec)) },
+ { "OSFILE_OFFSETOF_STAT_ST_MTIME", JS::Int32Value(offsetof (struct stat, st_mtimespec)) },
+ { "OSFILE_OFFSETOF_STAT_ST_CTIME", JS::Int32Value(offsetof (struct stat, st_ctimespec)) },
+#else
+ { "OSFILE_OFFSETOF_STAT_ST_ATIME", JS::Int32Value(offsetof (struct stat, st_atime)) },
+ { "OSFILE_OFFSETOF_STAT_ST_MTIME", JS::Int32Value(offsetof (struct stat, st_mtime)) },
+ { "OSFILE_OFFSETOF_STAT_ST_CTIME", JS::Int32Value(offsetof (struct stat, st_ctime)) },
+#endif // defined(HAVE_ST_ATIME)
+
+ // Several OSes have a birthtime field. For the moment, supporting only Darwin.
+#if defined(_DARWIN_FEATURE_64_BIT_INODE)
+ { "OSFILE_OFFSETOF_STAT_ST_BIRTHTIME", JS::Int32Value(offsetof (struct stat, st_birthtime)) },
+#endif // defined(_DARWIN_FEATURE_64_BIT_INODE)
+
+ // Defining |statvfs|
+
+ { "OSFILE_SIZEOF_STATVFS", JS::Int32Value(sizeof (struct statvfs)) },
+
+ { "OSFILE_OFFSETOF_STATVFS_F_BSIZE", JS::Int32Value(offsetof (struct statvfs, f_bsize)) },
+ { "OSFILE_OFFSETOF_STATVFS_F_BAVAIL", JS::Int32Value(offsetof (struct statvfs, f_bavail)) },
+
+#endif // defined(XP_UNIX)
+
+
+
+ // System configuration
+
+ // Under MacOSX, to avoid using deprecated functions that do not
+ // match the constants we define in this object (including
+ // |sizeof|/|offsetof| stuff, but not only), for a number of
+ // functions, we need to adapt the name of the symbols we are using,
+ // whenever macro _DARWIN_FEATURE_64_BIT_INODE is set. We export
+ // this value to be able to do so from JavaScript.
+#if defined(_DARWIN_FEATURE_64_BIT_INODE)
+ { "_DARWIN_FEATURE_64_BIT_INODE", JS::Int32Value(1) },
+#endif // defined(_DARWIN_FEATURE_64_BIT_INODE)
+
+ // Similar feature for Linux
+#if defined(_STAT_VER)
+ INT_CONSTANT(_STAT_VER),
+#endif // defined(_STAT_VER)
+
+ PROP_END
+};
+
+
+#if defined(XP_WIN)
+/**
+ * The properties defined in windows.h.
+ *
+ * If you extend this list of properties, please
+ * separate categories ("errors", "open", etc.),
+ * keep properties organized by alphabetical order
+ * and #ifdef-away properties that are not portable.
+ */
+static const dom::ConstantSpec gWinProperties[] =
+{
+ // FormatMessage flags
+ INT_CONSTANT(FORMAT_MESSAGE_FROM_SYSTEM),
+ INT_CONSTANT(FORMAT_MESSAGE_IGNORE_INSERTS),
+
+ // The max length of paths
+ INT_CONSTANT(MAX_PATH),
+
+ // CreateFile desired access
+ INT_CONSTANT(GENERIC_ALL),
+ INT_CONSTANT(GENERIC_EXECUTE),
+ INT_CONSTANT(GENERIC_READ),
+ INT_CONSTANT(GENERIC_WRITE),
+
+ // CreateFile share mode
+ INT_CONSTANT(FILE_SHARE_DELETE),
+ INT_CONSTANT(FILE_SHARE_READ),
+ INT_CONSTANT(FILE_SHARE_WRITE),
+
+ // CreateFile creation disposition
+ INT_CONSTANT(CREATE_ALWAYS),
+ INT_CONSTANT(CREATE_NEW),
+ INT_CONSTANT(OPEN_ALWAYS),
+ INT_CONSTANT(OPEN_EXISTING),
+ INT_CONSTANT(TRUNCATE_EXISTING),
+
+ // CreateFile attributes
+ INT_CONSTANT(FILE_ATTRIBUTE_ARCHIVE),
+ INT_CONSTANT(FILE_ATTRIBUTE_DIRECTORY),
+ INT_CONSTANT(FILE_ATTRIBUTE_HIDDEN),
+ INT_CONSTANT(FILE_ATTRIBUTE_NORMAL),
+ INT_CONSTANT(FILE_ATTRIBUTE_READONLY),
+ INT_CONSTANT(FILE_ATTRIBUTE_REPARSE_POINT),
+ INT_CONSTANT(FILE_ATTRIBUTE_SYSTEM),
+ INT_CONSTANT(FILE_ATTRIBUTE_TEMPORARY),
+ INT_CONSTANT(FILE_FLAG_BACKUP_SEMANTICS),
+
+ // CreateFile error constant
+ { "INVALID_HANDLE_VALUE", JS::Int32Value(INT_PTR(INVALID_HANDLE_VALUE)) },
+
+
+ // CreateFile flags
+ INT_CONSTANT(FILE_FLAG_DELETE_ON_CLOSE),
+
+ // SetFilePointer methods
+ INT_CONSTANT(FILE_BEGIN),
+ INT_CONSTANT(FILE_CURRENT),
+ INT_CONSTANT(FILE_END),
+
+ // SetFilePointer error constant
+ UINT_CONSTANT(INVALID_SET_FILE_POINTER),
+
+ // File attributes
+ INT_CONSTANT(FILE_ATTRIBUTE_DIRECTORY),
+
+
+ // MoveFile flags
+ INT_CONSTANT(MOVEFILE_COPY_ALLOWED),
+ INT_CONSTANT(MOVEFILE_REPLACE_EXISTING),
+
+ // GetFileAttributes error constant
+ INT_CONSTANT(INVALID_FILE_ATTRIBUTES),
+
+ // GetNamedSecurityInfo and SetNamedSecurityInfo constants
+ INT_CONSTANT(UNPROTECTED_DACL_SECURITY_INFORMATION),
+ INT_CONSTANT(SE_FILE_OBJECT),
+ INT_CONSTANT(DACL_SECURITY_INFORMATION),
+
+ // Errors
+ INT_CONSTANT(ERROR_INVALID_HANDLE),
+ INT_CONSTANT(ERROR_ACCESS_DENIED),
+ INT_CONSTANT(ERROR_DIR_NOT_EMPTY),
+ INT_CONSTANT(ERROR_FILE_EXISTS),
+ INT_CONSTANT(ERROR_ALREADY_EXISTS),
+ INT_CONSTANT(ERROR_FILE_NOT_FOUND),
+ INT_CONSTANT(ERROR_NO_MORE_FILES),
+ INT_CONSTANT(ERROR_PATH_NOT_FOUND),
+ INT_CONSTANT(ERROR_BAD_ARGUMENTS),
+ INT_CONSTANT(ERROR_SHARING_VIOLATION),
+ INT_CONSTANT(ERROR_NOT_SUPPORTED),
+
+ PROP_END
+};
+#endif // defined(XP_WIN)
+
+
+/**
+ * Get a field of an object as an object.
+ *
+ * If the field does not exist, create it. If it exists but is not an
+ * object, throw a JS error.
+ */
+JSObject *GetOrCreateObjectProperty(JSContext *cx, JS::Handle<JSObject*> aObject,
+ const char *aProperty)
+{
+ JS::Rooted<JS::Value> val(cx);
+ if (!JS_GetProperty(cx, aObject, aProperty, &val)) {
+ return nullptr;
+ }
+ if (!val.isUndefined()) {
+ if (val.isObject()) {
+ return &val.toObject();
+ }
+
+ JS_ReportErrorNumberASCII(cx, js::GetErrorMessage, nullptr,
+ JSMSG_UNEXPECTED_TYPE,
+ aProperty, "not an object");
+ return nullptr;
+ }
+ return JS_DefineObject(cx, aObject, aProperty, nullptr, JSPROP_ENUMERATE);
+}
+
+/**
+ * Set a property of an object from a nsString.
+ *
+ * If the nsString is void (i.e. IsVoid is true), do nothing.
+ */
+bool SetStringProperty(JSContext *cx, JS::Handle<JSObject*> aObject, const char *aProperty,
+ const nsString aValue)
+{
+ if (aValue.IsVoid()) {
+ return true;
+ }
+ JSString* strValue = JS_NewUCStringCopyZ(cx, aValue.get());
+ NS_ENSURE_TRUE(strValue, false);
+ JS::Rooted<JS::Value> valValue(cx, JS::StringValue(strValue));
+ return JS_SetProperty(cx, aObject, aProperty, valValue);
+}
+
+/**
+ * Define OS-specific constants.
+ *
+ * This function creates or uses JS object |OS.Constants| to store
+ * all its constants.
+ */
+bool DefineOSFileConstants(JSContext *cx, JS::Handle<JSObject*> global)
+{
+ if (!gInitialized || gPaths == nullptr) {
+ // If an initialization error was ignored, we may end up with
+ // |gInitialized == true| but |gPaths == nullptr|. We cannot
+ // |MOZ_ASSERT| this, as this would kill precompile_cache.js,
+ // so we simply return an error.
+ JS_ReportErrorNumberASCII(cx, js::GetErrorMessage, nullptr,
+ JSMSG_CANT_OPEN,
+ "OSFileConstants", "initialization has failed");
+ return false;
+ }
+
+ JS::Rooted<JSObject*> objOS(cx);
+ if (!(objOS = GetOrCreateObjectProperty(cx, global, "OS"))) {
+ return false;
+ }
+ JS::Rooted<JSObject*> objConstants(cx);
+ if (!(objConstants = GetOrCreateObjectProperty(cx, objOS, "Constants"))) {
+ return false;
+ }
+
+ // Build OS.Constants.libc
+
+ JS::Rooted<JSObject*> objLibc(cx);
+ if (!(objLibc = GetOrCreateObjectProperty(cx, objConstants, "libc"))) {
+ return false;
+ }
+ if (!dom::DefineConstants(cx, objLibc, gLibcProperties)) {
+ return false;
+ }
+
+#if defined(XP_WIN)
+ // Build OS.Constants.Win
+
+ JS::Rooted<JSObject*> objWin(cx);
+ if (!(objWin = GetOrCreateObjectProperty(cx, objConstants, "Win"))) {
+ return false;
+ }
+ if (!dom::DefineConstants(cx, objWin, gWinProperties)) {
+ return false;
+ }
+#endif // defined(XP_WIN)
+
+ // Build OS.Constants.Sys
+
+ JS::Rooted<JSObject*> objSys(cx);
+ if (!(objSys = GetOrCreateObjectProperty(cx, objConstants, "Sys"))) {
+ return false;
+ }
+
+#if defined(MOZ_WIDGET_GONK)
+ JSString* strVersion = JS_NewStringCopyZ(cx, "Gonk");
+ if (!strVersion){
+ return false;
+ }
+ JS::Rooted<JS::Value> valVersion(cx, JS::StringValue(strVersion));
+ if (!JS_SetProperty(cx, objSys, "Name", valVersion)) {
+ return false;
+ }
+#else
+ nsCOMPtr<nsIXULRuntime> runtime = do_GetService(XULRUNTIME_SERVICE_CONTRACTID);
+ if (runtime) {
+ nsAutoCString os;
+ DebugOnly<nsresult> rv = runtime->GetOS(os);
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+
+ JSString* strVersion = JS_NewStringCopyZ(cx, os.get());
+ if (!strVersion) {
+ return false;
+ }
+
+ JS::Rooted<JS::Value> valVersion(cx, JS::StringValue(strVersion));
+ if (!JS_SetProperty(cx, objSys, "Name", valVersion)) {
+ return false;
+ }
+ }
+#endif // defined(MOZ_WIDGET_GONK)
+
+#if defined(DEBUG)
+ JS::Rooted<JS::Value> valDebug(cx, JS::TrueValue());
+ if (!JS_SetProperty(cx, objSys, "DEBUG", valDebug)) {
+ return false;
+ }
+#endif
+
+#if defined(HAVE_64BIT_BUILD)
+ JS::Rooted<JS::Value> valBits(cx, JS::Int32Value(64));
+#else
+ JS::Rooted<JS::Value> valBits(cx, JS::Int32Value(32));
+#endif //defined (HAVE_64BIT_BUILD)
+ if (!JS_SetProperty(cx, objSys, "bits", valBits)) {
+ return false;
+ }
+
+ if (!JS_DefineProperty(cx, objSys, "umask", gUserUmask,
+ JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT)) {
+ return false;
+ }
+
+ // Build OS.Constants.Path
+
+ JS::Rooted<JSObject*> objPath(cx);
+ if (!(objPath = GetOrCreateObjectProperty(cx, objConstants, "Path"))) {
+ return false;
+ }
+
+ // Locate libxul
+ // Note that we don't actually provide the full path, only the name of the
+ // library, which is sufficient to link to the library using js-ctypes.
+
+#if defined(XP_MACOSX)
+ // Under MacOS X, for some reason, libxul is called simply "XUL",
+ // and we need to provide the full path.
+ nsAutoString libxul;
+ libxul.Append(gPaths->libDir);
+ libxul.AppendLiteral("/XUL");
+#else
+ // On other platforms, libxul is a library "xul" with regular
+ // library prefix/suffix.
+ nsAutoString libxul;
+ libxul.AppendLiteral(DLL_PREFIX);
+ libxul.AppendLiteral("xul");
+ libxul.AppendLiteral(DLL_SUFFIX);
+#endif // defined(XP_MACOSX)
+
+ if (!SetStringProperty(cx, objPath, "libxul", libxul)) {
+ return false;
+ }
+
+ if (!SetStringProperty(cx, objPath, "libDir", gPaths->libDir)) {
+ return false;
+ }
+
+ if (!SetStringProperty(cx, objPath, "tmpDir", gPaths->tmpDir)) {
+ return false;
+ }
+
+ // Configure profileDir only if it is available at this stage
+ if (!gPaths->profileDir.IsVoid()
+ && !SetStringProperty(cx, objPath, "profileDir", gPaths->profileDir)) {
+ return false;
+ }
+
+ // Configure localProfileDir only if it is available at this stage
+ if (!gPaths->localProfileDir.IsVoid()
+ && !SetStringProperty(cx, objPath, "localProfileDir", gPaths->localProfileDir)) {
+ return false;
+ }
+
+ if (!SetStringProperty(cx, objPath, "homeDir", gPaths->homeDir)) {
+ return false;
+ }
+
+ if (!SetStringProperty(cx, objPath, "desktopDir", gPaths->desktopDir)) {
+ return false;
+ }
+
+ if (!SetStringProperty(cx, objPath, "userApplicationDataDir", gPaths->userApplicationDataDir)) {
+ return false;
+ }
+
+#if defined(XP_WIN)
+ if (!SetStringProperty(cx, objPath, "winAppDataDir", gPaths->winAppDataDir)) {
+ return false;
+ }
+
+ if (!SetStringProperty(cx, objPath, "winStartMenuProgsDir", gPaths->winStartMenuProgsDir)) {
+ return false;
+ }
+#endif // defined(XP_WIN)
+
+#if defined(XP_MACOSX)
+ if (!SetStringProperty(cx, objPath, "macUserLibDir", gPaths->macUserLibDir)) {
+ return false;
+ }
+
+ if (!SetStringProperty(cx, objPath, "macLocalApplicationsDir", gPaths->macLocalApplicationsDir)) {
+ return false;
+ }
+
+ if (!SetStringProperty(cx, objPath, "macTrashDir", gPaths->macTrashDir)) {
+ return false;
+ }
+#endif // defined(XP_MACOSX)
+
+ // sqlite3 is linked from different places depending on the platform
+ nsAutoString libsqlite3;
+#if defined(ANDROID)
+ // On Android, we use the system's libsqlite3
+ libsqlite3.AppendLiteral(DLL_PREFIX);
+ libsqlite3.AppendLiteral("sqlite3");
+ libsqlite3.AppendLiteral(DLL_SUFFIX);
+#elif defined(XP_WIN)
+ // On Windows, for some reason, this is part of nss3.dll
+ libsqlite3.AppendLiteral(DLL_PREFIX);
+ libsqlite3.AppendLiteral("nss3");
+ libsqlite3.AppendLiteral(DLL_SUFFIX);
+#else
+ // On other platforms, we link sqlite3 into libxul
+ libsqlite3 = libxul;
+#endif // defined(ANDROID) || defined(XP_WIN)
+
+ if (!SetStringProperty(cx, objPath, "libsqlite3", libsqlite3)) {
+ return false;
+ }
+
+ return true;
+}
+
+NS_IMPL_ISUPPORTS(OSFileConstantsService, nsIOSFileConstantsService)
+
+OSFileConstantsService::OSFileConstantsService()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+}
+
+OSFileConstantsService::~OSFileConstantsService()
+{
+ mozilla::CleanupOSFileConstants();
+}
+
+
+NS_IMETHODIMP
+OSFileConstantsService::Init(JSContext *aCx)
+{
+ nsresult rv = mozilla::InitOSFileConstants();
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ mozJSComponentLoader* loader = mozJSComponentLoader::Get();
+ JS::Rooted<JSObject*> targetObj(aCx);
+ rv = loader->FindTargetObject(aCx, &targetObj);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!mozilla::DefineOSFileConstants(aCx, targetObj)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+} // namespace mozilla