node/src/node_binding.h

#ifndef SRC_NODE_BINDING_H_
#define SRC_NODE_BINDING_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#if defined(__POSIX__)
#include <dlfcn.h>
#endif

#include <string>

#include "node.h"
#include "node_api.h"
#include "quic/guard.h"
#include "uv.h"

enum {
  NM_F_BUILTIN = 1 << 0,  // Unused.
  NM_F_LINKED = 1 << 1,
  NM_F_INTERNAL = 1 << 2,
  NM_F_DELETEME = 1 << 3,
};

// Make sure our internal values match the public API's values.
static_assert(static_cast<int>(NM_F_LINKED) ==
                  static_cast<int>(node::ModuleFlags::kLinked),
              "NM_F_LINKED != node::ModuleFlags::kLinked");

#if NODE_HAVE_I18N_SUPPORT
#define NODE_BUILTIN_ICU_BINDINGS(V) V(icu)
#else
#define NODE_BUILTIN_ICU_BINDINGS(V)
#endif

#if HAVE_OPENSSL && OPENSSL_NO_QUIC != 1
#define NODE_BUILTIN_QUIC_BINDINGS(V) V(quic)
#else
#define NODE_BUILTIN_QUIC_BINDINGS(V)
#endif

#if HAVE_OPENSSL && HAVE_DTLS
#define NODE_BUILTIN_DTLS_BINDINGS(V) V(dtls)
#else
#define NODE_BUILTIN_DTLS_BINDINGS(V)
#endif

#if HAVE_SQLITE
#define NODE_BUILTIN_SQLITE_BINDINGS(V)                                        \
  V(sqlite)                                                                    \
  V(webstorage)
#else
#define NODE_BUILTIN_SQLITE_BINDINGS(V)
#endif

#if HAVE_FFI
#define NODE_BUILTIN_FFI_BINDINGS(V) V(ffi)
#else
#define NODE_BUILTIN_FFI_BINDINGS(V)
#endif

#define NODE_BINDINGS_WITH_PER_ISOLATE_INIT(V)                                 \
  V(async_wrap)                                                                \
  V(blob)                                                                      \
  V(builtins)                                                                  \
  V(contextify)                                                                \
  V(diagnostics_channel)                                                       \
  V(encoding_binding)                                                          \
  V(fs)                                                                        \
  V(fs_dir)                                                                    \
  V(glob)                                                                      \
  V(http_parser)                                                               \
  V(locks)                                                                     \
  V(messaging)                                                                 \
  V(mksnapshot)                                                                \
  V(modules)                                                                   \
  V(module_wrap)                                                               \
  V(performance)                                                               \
  V(process_methods)                                                           \
  V(timers)                                                                    \
  V(url)                                                                       \
  V(worker)                                                                    \
  NODE_BUILTIN_ICU_BINDINGS(V)                                                 \
  NODE_BUILTIN_QUIC_BINDINGS(V)                                                \
  NODE_BUILTIN_DTLS_BINDINGS(V)

#define NODE_BINDING_CONTEXT_AWARE_CPP(modname, regfunc, priv, flags)          \
  static node::node_module _module = {                                         \
      NODE_MODULE_VERSION,                                                     \
      flags,                                                                   \
      nullptr,                                                                 \
      __FILE__,                                                                \
      nullptr,                                                                 \
      (node::addon_context_register_func)(regfunc),                            \
      NODE_STRINGIFY(modname),                                                 \
      priv,                                                                    \
      nullptr};                                                                \
  void _register_##modname() { node_module_register(&_module); }

void napi_module_register_by_symbol(
    v8::Local<v8::Object> exports,
    v8::Local<v8::Value> module,
    v8::Local<v8::Context> context,
    napi_addon_register_func init,
    int32_t module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION);

node::addon_context_register_func get_node_api_context_register_func(
    node::Environment* node_env,
    const char* module_name,
    int32_t module_api_version);

namespace node {

// Define a node internal binding that may be loaded in a context of
// a node::Environment.
// If an internal binding needs initializing per-isolate templates, define
// with NODE_BINDING_PER_ISOLATE_INIT too.
#define NODE_BINDING_CONTEXT_AWARE_INTERNAL(modname, regfunc)                  \
  NODE_BINDING_CONTEXT_AWARE_CPP(modname, regfunc, nullptr, NM_F_INTERNAL)

// Define a per-isolate initialization function for a node internal binding.
// The modname should be registered in the NODE_BINDINGS_WITH_PER_ISOLATE_INIT
// list.
#define NODE_BINDING_PER_ISOLATE_INIT(modname, per_isolate_func)               \
  void _register_isolate_##modname(node::IsolateData* isolate_data,            \
                                   v8::Local<v8::ObjectTemplate> target) {     \
    per_isolate_func(isolate_data, target);                                    \
  }

// Globals per process
// This is set by node::Init() which is used by embedders
extern bool node_is_initialized;

namespace binding {

class DLib {
 public:
#ifdef __POSIX__
  static const int kDefaultFlags = RTLD_LAZY;
#else
  static const int kDefaultFlags = 0;
#endif

  DLib(const char* filename, int flags);

  bool Open();
  void Close();
  void* GetSymbolAddress(const char* name);
  void SaveInGlobalHandleMap(node_module* mp);
  node_module* GetSavedModuleFromGlobalHandleMap();

  const std::string filename_;
  const int flags_;
  std::string errmsg_;
  void* handle_;
#ifndef __POSIX__
  uv_lib_t lib_;
#endif
  bool has_entry_in_global_handle_map_ = false;

  DLib(const DLib&) = delete;
  DLib& operator=(const DLib&) = delete;
};

// Call _register<module_name> functions for all of
// the built-in bindings. Because built-in bindings don't
// use the __attribute__((constructor)). Need to
// explicitly call the _register* functions.
void RegisterBuiltinBindings();
// Create per-isolate templates for the internal bindings.
void CreateInternalBindingTemplates(IsolateData* isolate_data);
void GetInternalBinding(const v8::FunctionCallbackInfo<v8::Value>& args);
void GetLinkedBinding(const v8::FunctionCallbackInfo<v8::Value>& args);
void DLOpen(const v8::FunctionCallbackInfo<v8::Value>& args);
void DLOpenBinary(const v8::FunctionCallbackInfo<v8::Value>& args);

// Materializes the bytes of a dynamically shared object into a form
// dlopen()/LoadLibrary() can load, with the smallest, most private on-disk
// footprint each platform allows:
//   Linux:        an anonymous in-memory memfd, loaded via /proc/self/fd/N -
//                 the bytes never touch the filesystem.
//   other POSIX:  a 0700 mkdtemp() directory plus an O_EXCL|O_NOFOLLOW file,
//                 unlink()ed right after the load (the mapping keeps it alive).
//   Windows:      a temp file, written and closed before the load because the
//                 loader shares read alone. It cannot be unlinked while its
//                 image is mapped, so it is kept with the module it loaded as
//                 and both are released at process exit.
// Used for a native addon or an FFI library that lives somewhere the dynamic
// loader cannot open by path, such as a virtual file system. Call exactly one
// of Materialize()+AfterOpen() around the load; a destroyed image that never
// reached AfterOpen() cleans up after itself.
class AddonImage {
 public:
  AddonImage() = default;
  ~AddonImage();
  AddonImage(const AddonImage&) = delete;
  AddonImage& operator=(const AddonImage&) = delete;

  // The directory a temporary image would be written to, with a trailing
  // separator; empty when it cannot be determined. Names the resource for the
  // file-system permission check.
  static std::string TempDir();

  // On success sets path() to a real, loadable path for `data`.
  bool Materialize(const char* data, size_t len);
  const std::string& path() const { return path_; }
  const std::string& errmsg() const { return errmsg_; }

  // Call exactly once, right after the load; `opened` says whether the load
  // succeeded and `module` is the module handle it produced. Releases what is
  // no longer needed: on POSIX closes the memfd or unlinks the temp file, which
  // a successful load keeps alive through its own mapping. Windows cannot
  // unlink a mapped image, so there the file is removed at once only when the
  // load failed; otherwise it is kept, with `module`, until process exit, where
  // the module is unloaded and the file finally deleted.
  void AfterOpen(bool opened, void* module);

 private:
  std::string path_;
  std::string errmsg_;
  bool consumed_ = false;
#ifdef _WIN32
  std::wstring wpath_;  // the path of the image, to delete it again at exit
#else
  bool MaterializeTempFile(const char* data, size_t len);
  int fd_ = -1;
  std::string temp_dir_;
#endif
};

}  // namespace binding

}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#endif  // SRC_NODE_BINDING_H_