#include "node_binding.h"

#include <atomic>

#include "env-inl.h"

#include "node_builtins.h"

#include "node_errors.h"

#include "node_external_reference.h"

#include "util.h"

#include <string>

#if HAVE_OPENSSL

#define NODE_BUILTIN_OPENSSL_MODULES(V) V(crypto) V(tls_wrap)

#else

#define NODE_BUILTIN_OPENSSL_MODULES(V)

#endif

#if NODE_HAVE_I18N_SUPPORT

#define NODE_BUILTIN_ICU_MODULES(V) V(icu)

#else

#define NODE_BUILTIN_ICU_MODULES(V)

#endif

#if HAVE_INSPECTOR

#define NODE_BUILTIN_PROFILER_MODULES(V) V(profiler)

#else

#define NODE_BUILTIN_PROFILER_MODULES(V)

#endif

// A list of built-in modules. In order to do module registration

// in node::Init(), need to add built-in modules in the following list.

// Then in binding::RegisterBuiltinModules(), it calls modules' registration

// function. This helps the built-in modules are loaded properly when

// node is built as static library. No need to depend on the

// __attribute__((constructor)) like mechanism in GCC.

#define NODE_BUILTIN_STANDARD_MODULES(V)                                       \

  V(async_wrap)                                                                \

  V(blob)                                                                      \

  V(block_list)                                                                \

  V(buffer)                                                                    \

  V(builtins)                                                                  \

  V(cares_wrap)                                                                \

  V(config)                                                                    \

  V(contextify)                                                                \

  V(credentials)                                                               \

  V(errors)                                                                    \

  V(fs)                                                                        \

  V(fs_dir)                                                                    \

  V(fs_event_wrap)                                                             \

  V(heap_utils)                                                                \

  V(http2)                                                                     \

  V(http_parser)                                                               \

  V(inspector)                                                                 \

  V(js_stream)                                                                 \

  V(js_udp_wrap)                                                               \

  V(messaging)                                                                 \

  V(module_wrap)                                                               \

  V(mksnapshot)                                                                \

  V(options)                                                                   \

  V(os)                                                                        \

  V(performance)                                                               \

  V(pipe_wrap)                                                                 \

  V(process_wrap)                                                              \

  V(process_methods)                                                           \

  V(report)                                                                    \

  V(serdes)                                                                    \

  V(signal_wrap)                                                               \

  V(spawn_sync)                                                                \

  V(stream_pipe)                                                               \

  V(stream_wrap)                                                               \

  V(string_decoder)                                                            \

  V(symbols)                                                                   \

  V(task_queue)                                                                \

  V(tcp_wrap)                                                                  \

  V(timers)                                                                    \

  V(trace_events)                                                              \

  V(tty_wrap)                                                                  \

  V(types)                                                                     \

  V(udp_wrap)                                                                  \

  V(url)                                                                       \

  V(util)                                                                      \

  V(uv)                                                                        \

  V(v8)                                                                        \

  V(wasi)                                                                      \

  V(wasm_web_api)                                                              \

  V(watchdog)                                                                  \

  V(worker)                                                                    \

  V(zlib)

#define NODE_BUILTIN_MODULES(V)                                                \

  NODE_BUILTIN_STANDARD_MODULES(V)                                             \

  NODE_BUILTIN_OPENSSL_MODULES(V)                                              \

  NODE_BUILTIN_ICU_MODULES(V)                                                  \

  NODE_BUILTIN_PROFILER_MODULES(V)

// This is used to load built-in modules. Instead of using

// __attribute__((constructor)), we call the _register_<modname>

// function for each built-in modules explicitly in

// binding::RegisterBuiltinModules(). This is only forward declaration.

// The definitions are in each module's implementation when calling

// the NODE_MODULE_CONTEXT_AWARE_INTERNAL.

#define V(modname) void _register_##modname();

NODE_BUILTIN_MODULES(V)

#undef V

#ifdef _AIX

// On AIX, dlopen() behaves differently from other operating systems, in that

// it returns unique values from each call, rather than identical values, when

// loading the same handle.

// We try to work around that by providing wrappers for the dlopen() family of

// functions, and using st_dev and st_ino for the file that is to be loaded

// as keys for a cache.

namespace node {

namespace dlwrapper {

struct dl_wrap {

  uint64_t st_dev;

  uint64_t st_ino;

  uint64_t refcount;

  void* real_handle;

  struct hash {

    size_t operator()(const dl_wrap* wrap) const {

      return std::hash<uint64_t>()(wrap->st_dev) ^

             std::hash<uint64_t>()(wrap->st_ino);

    }

  };

  struct equal {

    bool operator()(const dl_wrap* a,

                    const dl_wrap* b) const {

      return a->st_dev == b->st_dev && a->st_ino == b->st_ino;

    }

  };

};

static Mutex dlhandles_mutex;

static std::unordered_set<dl_wrap*, dl_wrap::hash, dl_wrap::equal>

    dlhandles;

static thread_local std::string dlerror_storage;

char* wrapped_dlerror() {

  return &dlerror_storage[0];

}

void* wrapped_dlopen(const char* filename, int flags) {

  CHECK_NOT_NULL(filename);  // This deviates from the 'real' dlopen().

  Mutex::ScopedLock lock(dlhandles_mutex);

  uv_fs_t req;

  auto cleanup = OnScopeLeave([&]() { uv_fs_req_cleanup(&req); });

  int rc = uv_fs_stat(nullptr, &req, filename, nullptr);

  if (rc != 0) {

    dlerror_storage = uv_strerror(rc);

    return nullptr;

  }

  dl_wrap search = {

    req.statbuf.st_dev,

    req.statbuf.st_ino,

    0, nullptr

  };

  auto it = dlhandles.find(&search);

  if (it != dlhandles.end()) {

    (*it)->refcount++;

    return *it;

  }

  void* real_handle = dlopen(filename, flags);

  if (real_handle == nullptr) {

    dlerror_storage = dlerror();

    return nullptr;

  }

  dl_wrap* wrap = new dl_wrap();

  wrap->st_dev = req.statbuf.st_dev;

  wrap->st_ino = req.statbuf.st_ino;

  wrap->refcount = 1;

  wrap->real_handle = real_handle;

  dlhandles.insert(wrap);

  return wrap;

}

int wrapped_dlclose(void* handle) {

  Mutex::ScopedLock lock(dlhandles_mutex);

  dl_wrap* wrap = static_cast<dl_wrap*>(handle);

  int ret = 0;

  CHECK_GE(wrap->refcount, 1);

  if (--wrap->refcount == 0) {

    ret = dlclose(wrap->real_handle);

    if (ret != 0) dlerror_storage = dlerror();

    dlhandles.erase(wrap);

    delete wrap;

  }

  return ret;

}

void* wrapped_dlsym(void* handle, const char* symbol) {

  if (handle == RTLD_DEFAULT || handle == RTLD_NEXT)

    return dlsym(handle, symbol);

  dl_wrap* wrap = static_cast<dl_wrap*>(handle);

  return dlsym(wrap->real_handle, symbol);

}

#define dlopen node::dlwrapper::wrapped_dlopen

#define dlerror node::dlwrapper::wrapped_dlerror

#define dlclose node::dlwrapper::wrapped_dlclose

#define dlsym node::dlwrapper::wrapped_dlsym

}  // namespace dlwrapper

}  // namespace node

#endif  // _AIX

#ifdef __linux__

  static std::atomic_bool has_cached_retval { false };

}

#else  // __linux__

static bool libc_may_be_musl() { return false; }

#endif  // __linux__

namespace node {

using v8::Context;

using v8::Exception;

using v8::Function;

using v8::FunctionCallbackInfo;

using v8::Local;

using v8::Object;

using v8::String;

using v8::Value;

// Globals per process

static node_module* modlist_internal;

static node_module* modlist_linked;

static thread_local node_module* thread_local_modpending;

// This is set by node::Init() which is used by embedders

bool node_is_initialized = false;

    // "Linked" modules are included as part of the node project.

    // Like builtins they are registered *before* node::Init runs.

  } else {

  }

namespace binding {

static struct global_handle_map_t {

 public:

    // We need to store this flag internally to avoid a chicken-and-egg problem

    // during cleanup. By the time we actually use the flag's value,

    // the shared object has been unloaded, and its memory would be gone,

    // making it impossible to access fields of `mod` --

    // unless `mod` *is* dynamically allocated, but we cannot know that

    // without checking the flag.

  }

    }

  }

 private:

  Mutex mutex_;

  struct Entry {

    unsigned int refcount;

    bool wants_delete_module;

    node_module* module;

  };

  std::unordered_map<void*, Entry> map_;

} global_handle_map;

#ifdef __POSIX__

}

    // musl libc implements dlclose() as a no-op which returns 0.

    // As a consequence, trying to re-load a previously closed addon at a later

    // point will not call its static constructors, which Node.js uses.

    // Therefore, when we may be using musl libc, we assume that the shared

    // object exists indefinitely and keep it in our handle map.

  }

  }

}

}

#else   // !__POSIX__

bool DLib::Open() {

  int ret = uv_dlopen(filename_.c_str(), &lib_);

  if (ret == 0) {

    handle_ = static_cast<void*>(lib_.handle);

    return true;

  }

  errmsg_ = uv_dlerror(&lib_);

  uv_dlclose(&lib_);

  return false;

}

void DLib::Close() {

  if (handle_ == nullptr) return;

  if (has_entry_in_global_handle_map_)

    global_handle_map.erase(handle_);

  uv_dlclose(&lib_);

  handle_ = nullptr;

}

void* DLib::GetSymbolAddress(const char* name) {

  void* address;

  if (0 == uv_dlsym(&lib_, name, &address)) return address;

  return nullptr;

}

#endif  // !__POSIX__

}

using InitializerCallback = void (*)(Local<Object> exports,

                                     Local<Value> module,

                                     Local<Context> context);

}

      STRINGIFY(NAPI_MODULE_INITIALIZER_BASE) STRINGIFY(NAPI_MODULE_VERSION);

  return reinterpret_cast<napi_addon_register_func>(

}

// DLOpen is process.dlopen(module, filename, flags).

// Used to load 'module.node' dynamically shared objects.

//

// FIXME(bnoordhuis) Not multi-context ready. TBD how to resolve the conflict

// when two contexts try to load the same shared object. Maybe have a shadow

// cache that's a plain C list or hash table that's shared across contexts?

  }

  }

  }

  Local<Object> module;

  Local<Object> exports;

  Local<Value> exports_v;

  }

    // Objects containing v14 or later modules will have registered themselves

    // on the pending list.  Activate all of them now.  At present, only one

    // module per object is supported.

#ifdef _WIN32

      // Windows needs to add the filename into the error message

      errmsg += *filename;

#endif  // _WIN32

    }

        }

      }

    } else {

      } else {

          char errmsg[1024];

                   sizeof(errmsg),

                   "Module did not self-register: '%s'.",

        }

      }

    }

    // -1 is used for N-API modules

      // Even if the module did self-register, it may have done so with the

      // wrong version. We must only give up after having checked to see if it

      // has an appropriate initializer callback.

      }

      char errmsg[1024];

               sizeof(errmsg),

               "The module '%s'"

               "\nwas compiled against a different Node.js version using"

               "\nNODE_MODULE_VERSION %d. This version of Node.js requires"

               "\nNODE_MODULE_VERSION %d. Please try re-compiling or "

               "re-installing\nthe module (for instance, using `npm rebuild` "

               "or `npm install`).",

               *filename,

               mp->nm_version,

               NODE_MODULE_VERSION);

      // NOTE: `mp` is allocated inside of the shared library's memory, calling

      // `dlclose` will deallocate it

    }

    // Do not keep the lock while running userland addon loading code.

    } else {

    }

  });

  // Tell coverity that 'handle' should not be freed when we return.

  // coverity[leaked_storage]

}

                                      const char* name,

                                      int flag) {

  struct node_module* mp;

  }

}

                                node_module* mod,

                                Local<String> module) {

  // Internal bindings don't have a "module" object, only exports.

}

  Local<Object> exports;

        exports->SetPrototype(env->context(), Null(env->isolate())).FromJust());

    // Legacy feature: process.binding('natives').config contains stringified

    // config.gypi

              ->Set(env->context(),

                    env->config_string(),

                    builtins::BuiltinLoader::GetConfigString(env->isolate()))

              .FromJust());

  } else {

    char errmsg[1024];

  }

}

  // Iterate from here to the nearest non-Worker Environment to see if there's

  // a linked binding defined locally rather than through the global list.

  }

    char errmsg[1024];

             sizeof(errmsg),

             "No such module was linked: %s",

             *module_name_v);

  }

  Local<String> exports_prop =

        exports, module, env->context(), mod->nm_priv);

  } else {

        env,

  }

  auto effective_exports =

}

// Call built-in modules' _register_<module name> function to

// do module registration explicitly.

#define V(modname) _register_##modname();

#undef V

}  // namespace binding

}  // namespace node

                               node::binding::RegisterExternalReferences)