// Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. #include "node.h" #include "node_buffer.h" #include "node_constants.h" #include "node_file.h" #include "node_http_parser.h" #include "node_javascript.h" #include "node_version.h" #if defined HAVE_PERFCTR #include "node_counters.h" #endif #if HAVE_OPENSSL #include "node_crypto.h" #endif #if defined(NODE_HAVE_I18N_SUPPORT) #include "node_i18n.h" #endif #if defined HAVE_DTRACE || defined HAVE_ETW #include "node_dtrace.h" #endif #include "ares.h" #include "async-wrap.h" #include "async-wrap-inl.h" #include "env.h" #include "env-inl.h" #include "handle_wrap.h" #include "req_wrap.h" #include "string_bytes.h" #include "util.h" #include "uv.h" #include "v8-debug.h" #include "v8-profiler.h" #include "zlib.h" #include #include #include // PATH_MAX #include #include #include #include #include #include #if defined(_MSC_VER) #include #include #include #define strcasecmp _stricmp #define getpid _getpid #define umask _umask typedef int mode_t; #else #include // getrlimit, setrlimit #include // setuid, getuid #endif #if defined(__POSIX__) && !defined(__ANDROID__) #include // getpwnam() #include // getgrnam() #endif #ifdef __APPLE__ #include #define environ (*_NSGetEnviron()) #elif !defined(_MSC_VER) extern char **environ; #endif namespace node { using v8::Array; using v8::ArrayBuffer; using v8::Boolean; using v8::Context; using v8::EscapableHandleScope; using v8::Exception; using v8::Function; using v8::FunctionCallbackInfo; using v8::FunctionTemplate; using v8::Handle; using v8::HandleScope; using v8::HeapStatistics; using v8::Integer; using v8::Isolate; using v8::Local; using v8::Locker; using v8::Message; using v8::Number; using v8::Object; using v8::ObjectTemplate; using v8::PropertyCallbackInfo; using v8::SealHandleScope; using v8::String; using v8::TryCatch; using v8::Uint32; using v8::V8; using v8::Value; using v8::kExternalUint32Array; static bool print_eval = false; static bool force_repl = false; static bool trace_deprecation = false; static bool throw_deprecation = false; static const char* eval_string = NULL; static bool use_debug_agent = false; static bool debug_wait_connect = false; static int debug_port = 5858; static bool v8_is_profiling = false; static bool node_is_initialized = false; static node_module* modpending; static node_module* modlist_builtin; static node_module* modlist_linked; static node_module* modlist_addon; #if defined(NODE_HAVE_I18N_SUPPORT) // Path to ICU data (for i18n / Intl) static const char* icu_data_dir = NULL; #endif // used by C++ modules as well bool no_deprecation = false; // process-relative uptime base, initialized at start-up static double prog_start_time; static bool debugger_running; static uv_async_t dispatch_debug_messages_async; static Isolate* node_isolate = NULL; int WRITE_UTF8_FLAGS = v8::String::HINT_MANY_WRITES_EXPECTED | v8::String::NO_NULL_TERMINATION; class ArrayBufferAllocator : public ArrayBuffer::Allocator { public: // Impose an upper limit to avoid out of memory errors that bring down // the process. static const size_t kMaxLength = 0x3fffffff; static ArrayBufferAllocator the_singleton; virtual ~ArrayBufferAllocator() {} virtual void* Allocate(size_t length); virtual void* AllocateUninitialized(size_t length); virtual void Free(void* data, size_t length); private: ArrayBufferAllocator() {} ArrayBufferAllocator(const ArrayBufferAllocator&); void operator=(const ArrayBufferAllocator&); }; ArrayBufferAllocator ArrayBufferAllocator::the_singleton; void* ArrayBufferAllocator::Allocate(size_t length) { if (length > kMaxLength) return NULL; char* data = new char[length]; memset(data, 0, length); return data; } void* ArrayBufferAllocator::AllocateUninitialized(size_t length) { if (length > kMaxLength) return NULL; return new char[length]; } void ArrayBufferAllocator::Free(void* data, size_t length) { delete[] static_cast(data); } static void CheckImmediate(uv_check_t* handle) { Environment* env = Environment::from_immediate_check_handle(handle); HandleScope scope(env->isolate()); Context::Scope context_scope(env->context()); MakeCallback(env, env->process_object(), env->immediate_callback_string()); } static void IdleImmediateDummy(uv_idle_t* handle) { // Do nothing. Only for maintaining event loop. // TODO(bnoordhuis) Maybe make libuv accept NULL idle callbacks. } static inline const char *errno_string(int errorno) { #define ERRNO_CASE(e) case e: return #e; switch (errorno) { #ifdef EACCES ERRNO_CASE(EACCES); #endif #ifdef EADDRINUSE ERRNO_CASE(EADDRINUSE); #endif #ifdef EADDRNOTAVAIL ERRNO_CASE(EADDRNOTAVAIL); #endif #ifdef EAFNOSUPPORT ERRNO_CASE(EAFNOSUPPORT); #endif #ifdef EAGAIN ERRNO_CASE(EAGAIN); #endif #ifdef EWOULDBLOCK # if EAGAIN != EWOULDBLOCK ERRNO_CASE(EWOULDBLOCK); # endif #endif #ifdef EALREADY ERRNO_CASE(EALREADY); #endif #ifdef EBADF ERRNO_CASE(EBADF); #endif #ifdef EBADMSG ERRNO_CASE(EBADMSG); #endif #ifdef EBUSY ERRNO_CASE(EBUSY); #endif #ifdef ECANCELED ERRNO_CASE(ECANCELED); #endif #ifdef ECHILD ERRNO_CASE(ECHILD); #endif #ifdef ECONNABORTED ERRNO_CASE(ECONNABORTED); #endif #ifdef ECONNREFUSED ERRNO_CASE(ECONNREFUSED); #endif #ifdef ECONNRESET ERRNO_CASE(ECONNRESET); #endif #ifdef EDEADLK ERRNO_CASE(EDEADLK); #endif #ifdef EDESTADDRREQ ERRNO_CASE(EDESTADDRREQ); #endif #ifdef EDOM ERRNO_CASE(EDOM); #endif #ifdef EDQUOT ERRNO_CASE(EDQUOT); #endif #ifdef EEXIST ERRNO_CASE(EEXIST); #endif #ifdef EFAULT ERRNO_CASE(EFAULT); #endif #ifdef EFBIG ERRNO_CASE(EFBIG); #endif #ifdef EHOSTUNREACH ERRNO_CASE(EHOSTUNREACH); #endif #ifdef EIDRM ERRNO_CASE(EIDRM); #endif #ifdef EILSEQ ERRNO_CASE(EILSEQ); #endif #ifdef EINPROGRESS ERRNO_CASE(EINPROGRESS); #endif #ifdef EINTR ERRNO_CASE(EINTR); #endif #ifdef EINVAL ERRNO_CASE(EINVAL); #endif #ifdef EIO ERRNO_CASE(EIO); #endif #ifdef EISCONN ERRNO_CASE(EISCONN); #endif #ifdef EISDIR ERRNO_CASE(EISDIR); #endif #ifdef ELOOP ERRNO_CASE(ELOOP); #endif #ifdef EMFILE ERRNO_CASE(EMFILE); #endif #ifdef EMLINK ERRNO_CASE(EMLINK); #endif #ifdef EMSGSIZE ERRNO_CASE(EMSGSIZE); #endif #ifdef EMULTIHOP ERRNO_CASE(EMULTIHOP); #endif #ifdef ENAMETOOLONG ERRNO_CASE(ENAMETOOLONG); #endif #ifdef ENETDOWN ERRNO_CASE(ENETDOWN); #endif #ifdef ENETRESET ERRNO_CASE(ENETRESET); #endif #ifdef ENETUNREACH ERRNO_CASE(ENETUNREACH); #endif #ifdef ENFILE ERRNO_CASE(ENFILE); #endif #ifdef ENOBUFS ERRNO_CASE(ENOBUFS); #endif #ifdef ENODATA ERRNO_CASE(ENODATA); #endif #ifdef ENODEV ERRNO_CASE(ENODEV); #endif #ifdef ENOENT ERRNO_CASE(ENOENT); #endif #ifdef ENOEXEC ERRNO_CASE(ENOEXEC); #endif #ifdef ENOLINK ERRNO_CASE(ENOLINK); #endif #ifdef ENOLCK # if ENOLINK != ENOLCK ERRNO_CASE(ENOLCK); # endif #endif #ifdef ENOMEM ERRNO_CASE(ENOMEM); #endif #ifdef ENOMSG ERRNO_CASE(ENOMSG); #endif #ifdef ENOPROTOOPT ERRNO_CASE(ENOPROTOOPT); #endif #ifdef ENOSPC ERRNO_CASE(ENOSPC); #endif #ifdef ENOSR ERRNO_CASE(ENOSR); #endif #ifdef ENOSTR ERRNO_CASE(ENOSTR); #endif #ifdef ENOSYS ERRNO_CASE(ENOSYS); #endif #ifdef ENOTCONN ERRNO_CASE(ENOTCONN); #endif #ifdef ENOTDIR ERRNO_CASE(ENOTDIR); #endif #ifdef ENOTEMPTY ERRNO_CASE(ENOTEMPTY); #endif #ifdef ENOTSOCK ERRNO_CASE(ENOTSOCK); #endif #ifdef ENOTSUP ERRNO_CASE(ENOTSUP); #else # ifdef EOPNOTSUPP ERRNO_CASE(EOPNOTSUPP); # endif #endif #ifdef ENOTTY ERRNO_CASE(ENOTTY); #endif #ifdef ENXIO ERRNO_CASE(ENXIO); #endif #ifdef EOVERFLOW ERRNO_CASE(EOVERFLOW); #endif #ifdef EPERM ERRNO_CASE(EPERM); #endif #ifdef EPIPE ERRNO_CASE(EPIPE); #endif #ifdef EPROTO ERRNO_CASE(EPROTO); #endif #ifdef EPROTONOSUPPORT ERRNO_CASE(EPROTONOSUPPORT); #endif #ifdef EPROTOTYPE ERRNO_CASE(EPROTOTYPE); #endif #ifdef ERANGE ERRNO_CASE(ERANGE); #endif #ifdef EROFS ERRNO_CASE(EROFS); #endif #ifdef ESPIPE ERRNO_CASE(ESPIPE); #endif #ifdef ESRCH ERRNO_CASE(ESRCH); #endif #ifdef ESTALE ERRNO_CASE(ESTALE); #endif #ifdef ETIME ERRNO_CASE(ETIME); #endif #ifdef ETIMEDOUT ERRNO_CASE(ETIMEDOUT); #endif #ifdef ETXTBSY ERRNO_CASE(ETXTBSY); #endif #ifdef EXDEV ERRNO_CASE(EXDEV); #endif default: return ""; } } const char *signo_string(int signo) { #define SIGNO_CASE(e) case e: return #e; switch (signo) { #ifdef SIGHUP SIGNO_CASE(SIGHUP); #endif #ifdef SIGINT SIGNO_CASE(SIGINT); #endif #ifdef SIGQUIT SIGNO_CASE(SIGQUIT); #endif #ifdef SIGILL SIGNO_CASE(SIGILL); #endif #ifdef SIGTRAP SIGNO_CASE(SIGTRAP); #endif #ifdef SIGABRT SIGNO_CASE(SIGABRT); #endif #ifdef SIGIOT # if SIGABRT != SIGIOT SIGNO_CASE(SIGIOT); # endif #endif #ifdef SIGBUS SIGNO_CASE(SIGBUS); #endif #ifdef SIGFPE SIGNO_CASE(SIGFPE); #endif #ifdef SIGKILL SIGNO_CASE(SIGKILL); #endif #ifdef SIGUSR1 SIGNO_CASE(SIGUSR1); #endif #ifdef SIGSEGV SIGNO_CASE(SIGSEGV); #endif #ifdef SIGUSR2 SIGNO_CASE(SIGUSR2); #endif #ifdef SIGPIPE SIGNO_CASE(SIGPIPE); #endif #ifdef SIGALRM SIGNO_CASE(SIGALRM); #endif SIGNO_CASE(SIGTERM); #ifdef SIGCHLD SIGNO_CASE(SIGCHLD); #endif #ifdef SIGSTKFLT SIGNO_CASE(SIGSTKFLT); #endif #ifdef SIGCONT SIGNO_CASE(SIGCONT); #endif #ifdef SIGSTOP SIGNO_CASE(SIGSTOP); #endif #ifdef SIGTSTP SIGNO_CASE(SIGTSTP); #endif #ifdef SIGBREAK SIGNO_CASE(SIGBREAK); #endif #ifdef SIGTTIN SIGNO_CASE(SIGTTIN); #endif #ifdef SIGTTOU SIGNO_CASE(SIGTTOU); #endif #ifdef SIGURG SIGNO_CASE(SIGURG); #endif #ifdef SIGXCPU SIGNO_CASE(SIGXCPU); #endif #ifdef SIGXFSZ SIGNO_CASE(SIGXFSZ); #endif #ifdef SIGVTALRM SIGNO_CASE(SIGVTALRM); #endif #ifdef SIGPROF SIGNO_CASE(SIGPROF); #endif #ifdef SIGWINCH SIGNO_CASE(SIGWINCH); #endif #ifdef SIGIO SIGNO_CASE(SIGIO); #endif #ifdef SIGPOLL # if SIGPOLL != SIGIO SIGNO_CASE(SIGPOLL); # endif #endif #ifdef SIGLOST SIGNO_CASE(SIGLOST); #endif #ifdef SIGPWR # if SIGPWR != SIGLOST SIGNO_CASE(SIGPWR); # endif #endif #ifdef SIGSYS SIGNO_CASE(SIGSYS); #endif default: return ""; } } // Convenience methods void ThrowError(v8::Isolate* isolate, const char* errmsg) { Environment::GetCurrent(isolate)->ThrowError(errmsg); } void ThrowTypeError(v8::Isolate* isolate, const char* errmsg) { Environment::GetCurrent(isolate)->ThrowTypeError(errmsg); } void ThrowRangeError(v8::Isolate* isolate, const char* errmsg) { Environment::GetCurrent(isolate)->ThrowRangeError(errmsg); } void ThrowErrnoException(v8::Isolate* isolate, int errorno, const char* syscall, const char* message, const char* path) { Environment::GetCurrent(isolate)->ThrowErrnoException(errorno, syscall, message, path); } void ThrowUVException(v8::Isolate* isolate, int errorno, const char* syscall, const char* message, const char* path) { Environment::GetCurrent(isolate)->ThrowErrnoException(errorno, syscall, message, path); } Local ErrnoException(Isolate* isolate, int errorno, const char *syscall, const char *msg, const char *path) { Environment* env = Environment::GetCurrent(isolate); Local e; Local estring = OneByteString(env->isolate(), errno_string(errorno)); if (msg == NULL || msg[0] == '\0') { msg = strerror(errorno); } Local message = OneByteString(env->isolate(), msg); Local cons1 = String::Concat(estring, FIXED_ONE_BYTE_STRING(env->isolate(), ", ")); Local cons2 = String::Concat(cons1, message); if (path) { Local cons3 = String::Concat(cons2, FIXED_ONE_BYTE_STRING(env->isolate(), " '")); Local cons4 = String::Concat(cons3, String::NewFromUtf8(env->isolate(), path)); Local cons5 = String::Concat(cons4, FIXED_ONE_BYTE_STRING(env->isolate(), "'")); e = Exception::Error(cons5); } else { e = Exception::Error(cons2); } Local obj = e->ToObject(); obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno)); obj->Set(env->code_string(), estring); if (path != NULL) { obj->Set(env->path_string(), String::NewFromUtf8(env->isolate(), path)); } if (syscall != NULL) { obj->Set(env->syscall_string(), OneByteString(env->isolate(), syscall)); } return e; } // hack alert! copy of ErrnoException, tuned for uv errors Local UVException(Isolate* isolate, int errorno, const char *syscall, const char *msg, const char *path) { Environment* env = Environment::GetCurrent(isolate); if (!msg || !msg[0]) msg = uv_strerror(errorno); Local estring = OneByteString(env->isolate(), uv_err_name(errorno)); Local message = OneByteString(env->isolate(), msg); Local cons1 = String::Concat(estring, FIXED_ONE_BYTE_STRING(env->isolate(), ", ")); Local cons2 = String::Concat(cons1, message); Local e; Local path_str; if (path) { #ifdef _WIN32 if (strncmp(path, "\\\\?\\UNC\\", 8) == 0) { path_str = String::Concat(FIXED_ONE_BYTE_STRING(env->isolate(), "\\\\"), String::NewFromUtf8(env->isolate(), path + 8)); } else if (strncmp(path, "\\\\?\\", 4) == 0) { path_str = String::NewFromUtf8(env->isolate(), path + 4); } else { path_str = String::NewFromUtf8(env->isolate(), path); } #else path_str = String::NewFromUtf8(env->isolate(), path); #endif Local cons3 = String::Concat(cons2, FIXED_ONE_BYTE_STRING(env->isolate(), " '")); Local cons4 = String::Concat(cons3, path_str); Local cons5 = String::Concat(cons4, FIXED_ONE_BYTE_STRING(env->isolate(), "'")); e = Exception::Error(cons5); } else { e = Exception::Error(cons2); } Local obj = e->ToObject(); // TODO(piscisaureus) errno should probably go obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno)); obj->Set(env->code_string(), estring); if (path != NULL) { obj->Set(env->path_string(), path_str); } if (syscall != NULL) { obj->Set(env->syscall_string(), OneByteString(env->isolate(), syscall)); } return e; } #ifdef _WIN32 // Does about the same as strerror(), // but supports all windows error messages static const char *winapi_strerror(const int errorno, bool* must_free) { char *errmsg = NULL; FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&errmsg, 0, NULL); if (errmsg) { *must_free = true; // Remove trailing newlines for (int i = strlen(errmsg) - 1; i >= 0 && (errmsg[i] == '\n' || errmsg[i] == '\r'); i--) { errmsg[i] = '\0'; } return errmsg; } else { // FormatMessage failed *must_free = false; return "Unknown error"; } } Local WinapiErrnoException(Isolate* isolate, int errorno, const char* syscall, const char* msg, const char* path) { Environment* env = Environment::GetCurrent(isolate); Local e; bool must_free = false; if (!msg || !msg[0]) { msg = winapi_strerror(errorno, &must_free); } Local message = OneByteString(env->isolate(), msg); if (path) { Local cons1 = String::Concat(message, FIXED_ONE_BYTE_STRING(isolate, " '")); Local cons2 = String::Concat(cons1, String::NewFromUtf8(isolate, path)); Local cons3 = String::Concat(cons2, FIXED_ONE_BYTE_STRING(isolate, "'")); e = Exception::Error(cons3); } else { e = Exception::Error(message); } Local obj = e->ToObject(); obj->Set(env->errno_string(), Integer::New(isolate, errorno)); if (path != NULL) { obj->Set(env->path_string(), String::NewFromUtf8(isolate, path)); } if (syscall != NULL) { obj->Set(env->syscall_string(), OneByteString(isolate, syscall)); } if (must_free) LocalFree((HLOCAL)msg); return e; } #endif static bool DomainHasErrorHandler(const Environment* env, const Local& domain) { HandleScope scope(env->isolate()); Local domain_event_listeners_v = domain->Get(env->events_string()); if (!domain_event_listeners_v->IsObject()) return false; Local domain_event_listeners_o = domain_event_listeners_v.As(); Local domain_error_listeners_v = domain_event_listeners_o->Get(env->error_string()); if (domain_error_listeners_v->IsFunction() || (domain_error_listeners_v->IsArray() && domain_error_listeners_v.As()->Length() > 0)) return true; return false; } static bool TopDomainHasErrorHandler(const Environment* env) { HandleScope scope(env->isolate()); if (!env->using_domains()) return false; Local domains_stack_array = env->domains_stack_array().As(); if (domains_stack_array->Length() == 0) return false; uint32_t domains_stack_length = domains_stack_array->Length(); if (domains_stack_length == 0) return false; Local top_domain_v = domains_stack_array->Get(domains_stack_length - 1); if (!top_domain_v->IsObject()) return false; Local top_domain = top_domain_v.As(); if (DomainHasErrorHandler(env, top_domain)) return true; return false; } bool ShouldAbortOnUncaughtException(v8::Isolate* isolate) { Environment* env = Environment::GetCurrent(isolate); Local process_object = env->process_object(); Local emitting_top_level_domain_error_key = env->emitting_top_level_domain_error_string(); bool isEmittingTopLevelDomainError = process_object->Get(emitting_top_level_domain_error_key)->BooleanValue(); return isEmittingTopLevelDomainError || !TopDomainHasErrorHandler(env); } void SetupDomainUse(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); if (env->using_domains()) return; env->set_using_domains(true); HandleScope scope(env->isolate()); Local process_object = env->process_object(); Local tick_callback_function_key = env->tick_domain_cb_string(); Local tick_callback_function = process_object->Get(tick_callback_function_key).As(); if (!tick_callback_function->IsFunction()) { fprintf(stderr, "process._tickDomainCallback assigned to non-function\n"); abort(); } process_object->Set(env->tick_callback_string(), tick_callback_function); env->set_tick_callback_function(tick_callback_function); assert(args[0]->IsArray()); assert(args[1]->IsObject()); assert(args[2]->IsArray()); env->set_domain_array(args[0].As()); env->set_domains_stack_array(args[2].As()); Local domain_flag_obj = args[1].As(); Environment::DomainFlag* domain_flag = env->domain_flag(); domain_flag_obj->SetIndexedPropertiesToExternalArrayData( domain_flag->fields(), kExternalUint32Array, domain_flag->fields_count()); // Do a little housekeeping. env->process_object()->Delete( FIXED_ONE_BYTE_STRING(args.GetIsolate(), "_setupDomainUse")); } void RunMicrotasks(const FunctionCallbackInfo& args) { args.GetIsolate()->RunMicrotasks(); } void SetupNextTick(const FunctionCallbackInfo& args) { HandleScope handle_scope(args.GetIsolate()); Environment* env = Environment::GetCurrent(args.GetIsolate()); assert(args[0]->IsObject()); assert(args[1]->IsFunction()); assert(args[2]->IsObject()); // Values use to cross communicate with processNextTick. Local tick_info_obj = args[0].As(); tick_info_obj->SetIndexedPropertiesToExternalArrayData( env->tick_info()->fields(), kExternalUint32Array, env->tick_info()->fields_count()); env->set_tick_callback_function(args[1].As()); NODE_SET_METHOD(args[2].As(), "runMicrotasks", RunMicrotasks); // Do a little housekeeping. env->process_object()->Delete( FIXED_ONE_BYTE_STRING(args.GetIsolate(), "_setupNextTick")); } Handle MakeCallback(Environment* env, Handle recv, const Handle callback, int argc, Handle argv[]) { // If you hit this assertion, you forgot to enter the v8::Context first. CHECK(env->context() == env->isolate()->GetCurrentContext()); Local process = env->process_object(); Local object, domain; bool has_async_queue = false; bool has_domain = false; if (recv->IsObject()) { object = recv.As(); Local async_queue_v = object->Get(env->async_queue_string()); if (async_queue_v->IsObject()) has_async_queue = true; } if (env->using_domains()) { CHECK(recv->IsObject()); Local domain_v = object->Get(env->domain_string()); has_domain = domain_v->IsObject(); if (has_domain) { domain = domain_v.As(); if (domain->Get(env->disposed_string())->IsTrue()) return Undefined(env->isolate()); } } TryCatch try_catch; try_catch.SetVerbose(true); if (has_domain) { Local enter_v = domain->Get(env->enter_string()); if (enter_v->IsFunction()) { enter_v.As()->Call(domain, 0, NULL); if (try_catch.HasCaught()) return Undefined(env->isolate()); } } if (has_async_queue) { try_catch.SetVerbose(false); env->async_hooks_pre_function()->Call(object, 0, NULL); if (try_catch.HasCaught()) FatalError("node:;MakeCallback", "pre hook threw"); try_catch.SetVerbose(true); } Local ret = callback->Call(recv, argc, argv); if (has_async_queue) { try_catch.SetVerbose(false); env->async_hooks_post_function()->Call(object, 0, NULL); if (try_catch.HasCaught()) FatalError("node::MakeCallback", "post hook threw"); try_catch.SetVerbose(true); } if (has_domain) { Local exit_v = domain->Get(env->exit_string()); if (exit_v->IsFunction()) { exit_v.As()->Call(domain, 0, NULL); if (try_catch.HasCaught()) return Undefined(env->isolate()); } } if (try_catch.HasCaught()) { return Undefined(env->isolate()); } Environment::TickInfo* tick_info = env->tick_info(); if (tick_info->in_tick()) { return ret; } if (tick_info->length() == 0) { env->isolate()->RunMicrotasks(); } if (tick_info->length() == 0) { tick_info->set_index(0); return ret; } tick_info->set_in_tick(true); // process nextTicks after call env->tick_callback_function()->Call(process, 0, NULL); tick_info->set_in_tick(false); if (try_catch.HasCaught()) { tick_info->set_last_threw(true); return Undefined(env->isolate()); } return ret; } // Internal only. Handle MakeCallback(Environment* env, Handle recv, uint32_t index, int argc, Handle argv[]) { Local cb_v = recv->Get(index); CHECK(cb_v->IsFunction()); return MakeCallback(env, recv.As(), cb_v.As(), argc, argv); } Handle MakeCallback(Environment* env, Handle recv, Handle symbol, int argc, Handle argv[]) { Local cb_v = recv->Get(symbol); CHECK(cb_v->IsFunction()); return MakeCallback(env, recv.As(), cb_v.As(), argc, argv); } Handle MakeCallback(Environment* env, Handle recv, const char* method, int argc, Handle argv[]) { Local method_string = OneByteString(env->isolate(), method); return MakeCallback(env, recv, method_string, argc, argv); } Handle MakeCallback(Isolate* isolate, Handle recv, const char* method, int argc, Handle argv[]) { EscapableHandleScope handle_scope(isolate); Local context = recv->CreationContext(); Environment* env = Environment::GetCurrent(context); Context::Scope context_scope(context); return handle_scope.Escape( Local::New(isolate, MakeCallback(env, recv, method, argc, argv))); } Handle MakeCallback(Isolate* isolate, Handle recv, Handle symbol, int argc, Handle argv[]) { EscapableHandleScope handle_scope(isolate); Local context = recv->CreationContext(); Environment* env = Environment::GetCurrent(context); Context::Scope context_scope(context); return handle_scope.Escape( Local::New(isolate, MakeCallback(env, recv, symbol, argc, argv))); } Handle MakeCallback(Isolate* isolate, Handle recv, Handle callback, int argc, Handle argv[]) { EscapableHandleScope handle_scope(isolate); Local context = recv->CreationContext(); Environment* env = Environment::GetCurrent(context); Context::Scope context_scope(context); return handle_scope.Escape(Local::New( isolate, MakeCallback(env, recv.As(), callback, argc, argv))); } enum encoding ParseEncoding(Isolate* isolate, Handle encoding_v, enum encoding _default) { HandleScope scope(isolate); if (!encoding_v->IsString()) return _default; node::Utf8Value encoding(encoding_v); if (strcasecmp(*encoding, "utf8") == 0) { return UTF8; } else if (strcasecmp(*encoding, "utf-8") == 0) { return UTF8; } else if (strcasecmp(*encoding, "ascii") == 0) { return ASCII; } else if (strcasecmp(*encoding, "base64") == 0) { return BASE64; } else if (strcasecmp(*encoding, "ucs2") == 0) { return UCS2; } else if (strcasecmp(*encoding, "ucs-2") == 0) { return UCS2; } else if (strcasecmp(*encoding, "utf16le") == 0) { return UCS2; } else if (strcasecmp(*encoding, "utf-16le") == 0) { return UCS2; } else if (strcasecmp(*encoding, "binary") == 0) { return BINARY; } else if (strcasecmp(*encoding, "buffer") == 0) { return BUFFER; } else if (strcasecmp(*encoding, "hex") == 0) { return HEX; } else if (strcasecmp(*encoding, "raw") == 0) { if (!no_deprecation) { fprintf(stderr, "'raw' (array of integers) has been removed. " "Use 'binary'.\n"); } return BINARY; } else if (strcasecmp(*encoding, "raws") == 0) { if (!no_deprecation) { fprintf(stderr, "'raws' encoding has been renamed to 'binary'. " "Please update your code.\n"); } return BINARY; } else { return _default; } } Local Encode(Isolate* isolate, const void* buf, size_t len, enum encoding encoding) { return StringBytes::Encode(isolate, static_cast(buf), len, encoding); } // Returns -1 if the handle was not valid for decoding ssize_t DecodeBytes(Isolate* isolate, Handle val, enum encoding encoding) { HandleScope scope(isolate); if (val->IsArray()) { fprintf(stderr, "'raw' encoding (array of integers) has been removed. " "Use 'binary'.\n"); assert(0); return -1; } return StringBytes::Size(isolate, val, encoding); } #ifndef MIN # define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif // Returns number of bytes written. ssize_t DecodeWrite(Isolate* isolate, char* buf, size_t buflen, Handle val, enum encoding encoding) { return StringBytes::Write(isolate, buf, buflen, val, encoding, NULL); } void AppendExceptionLine(Environment* env, Handle er, Handle message) { if (message.IsEmpty()) return; HandleScope scope(env->isolate()); Local err_obj; if (!er.IsEmpty() && er->IsObject()) { err_obj = er.As(); // Do it only once per message if (!err_obj->GetHiddenValue(env->processed_string()).IsEmpty()) return; err_obj->SetHiddenValue(env->processed_string(), True(env->isolate())); } static char arrow[1024]; // Print (filename):(line number): (message). node::Utf8Value filename(message->GetScriptResourceName()); const char* filename_string = *filename; int linenum = message->GetLineNumber(); // Print line of source code. node::Utf8Value sourceline(message->GetSourceLine()); const char* sourceline_string = *sourceline; // Because of how node modules work, all scripts are wrapped with a // "function (module, exports, __filename, ...) {" // to provide script local variables. // // When reporting errors on the first line of a script, this wrapper // function is leaked to the user. There used to be a hack here to // truncate off the first 62 characters, but it caused numerous other // problems when vm.runIn*Context() methods were used for non-module // code. // // If we ever decide to re-instate such a hack, the following steps // must be taken: // // 1. Pass a flag around to say "this code was wrapped" // 2. Update the stack frame output so that it is also correct. // // It would probably be simpler to add a line rather than add some // number of characters to the first line, since V8 truncates the // sourceline to 78 characters, and we end up not providing very much // useful debugging info to the user if we remove 62 characters. int start = message->GetStartColumn(); int end = message->GetEndColumn(); int off = snprintf(arrow, sizeof(arrow), "%s:%i\n%s\n", filename_string, linenum, sourceline_string); assert(off >= 0); // Print wavy underline (GetUnderline is deprecated). for (int i = 0; i < start; i++) { if (sourceline_string[i] == '\0' || static_cast(off) >= sizeof(arrow)) { break; } assert(static_cast(off) < sizeof(arrow)); arrow[off++] = (sourceline_string[i] == '\t') ? '\t' : ' '; } for (int i = start; i < end; i++) { if (sourceline_string[i] == '\0' || static_cast(off) >= sizeof(arrow)) { break; } assert(static_cast(off) < sizeof(arrow)); arrow[off++] = '^'; } assert(static_cast(off - 1) <= sizeof(arrow) - 1); arrow[off++] = '\n'; arrow[off] = '\0'; Local arrow_str = String::NewFromUtf8(env->isolate(), arrow); Local msg; Local stack; // Allocation failed, just print it out if (arrow_str.IsEmpty() || err_obj.IsEmpty() || !err_obj->IsNativeError()) goto print; msg = err_obj->Get(env->message_string()); stack = err_obj->Get(env->stack_string()); if (msg.IsEmpty() || stack.IsEmpty()) goto print; err_obj->Set(env->message_string(), String::Concat(arrow_str, msg->ToString())); err_obj->Set(env->stack_string(), String::Concat(arrow_str, stack->ToString())); return; print: if (env->printed_error()) return; env->set_printed_error(true); uv_tty_reset_mode(); fprintf(stderr, "\n%s", arrow); } static void ReportException(Environment* env, Handle er, Handle message) { HandleScope scope(env->isolate()); AppendExceptionLine(env, er, message); Local trace_value; if (er->IsUndefined() || er->IsNull()) trace_value = Undefined(env->isolate()); else trace_value = er->ToObject()->Get(env->stack_string()); node::Utf8Value trace(trace_value); // range errors have a trace member set to undefined if (trace.length() > 0 && !trace_value->IsUndefined()) { fprintf(stderr, "%s\n", *trace); } else { // this really only happens for RangeErrors, since they're the only // kind that won't have all this info in the trace, or when non-Error // objects are thrown manually. Local message; Local name; if (er->IsObject()) { Local err_obj = er.As(); message = err_obj->Get(env->message_string()); name = err_obj->Get(FIXED_ONE_BYTE_STRING(env->isolate(), "name")); } if (message.IsEmpty() || message->IsUndefined() || name.IsEmpty() || name->IsUndefined()) { // Not an error object. Just print as-is. node::Utf8Value message(er); fprintf(stderr, "%s\n", *message); } else { node::Utf8Value name_string(name); node::Utf8Value message_string(message); fprintf(stderr, "%s: %s\n", *name_string, *message_string); } } fflush(stderr); } static void ReportException(Environment* env, const TryCatch& try_catch) { ReportException(env, try_catch.Exception(), try_catch.Message()); } // Executes a str within the current v8 context. static Local ExecuteString(Environment* env, Handle source, Handle filename) { EscapableHandleScope scope(env->isolate()); TryCatch try_catch; // try_catch must be nonverbose to disable FatalException() handler, // we will handle exceptions ourself. try_catch.SetVerbose(false); Local<:script> script = v8::Script::Compile(source, filename); if (script.IsEmpty()) { ReportException(env, try_catch); exit(3); } Local result = script->Run(); if (result.IsEmpty()) { ReportException(env, try_catch); exit(4); } return scope.Escape(result); } static void GetActiveRequests(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); Local ary = Array::New(args.GetIsolate()); QUEUE* q = NULL; int i = 0; QUEUE_FOREACH(q, env->req_wrap_queue()) { ReqWrap* w = ContainerOf(&ReqWrap::req_wrap_queue_, q); if (w->persistent().IsEmpty()) continue; ary->Set(i++, w->object()); } args.GetReturnValue().Set(ary); } // Non-static, friend of HandleWrap. Could have been a HandleWrap method but // implemented here for consistency with GetActiveRequests(). void GetActiveHandles(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); Local ary = Array::New(env->isolate()); QUEUE* q = NULL; int i = 0; Local owner_sym = env->owner_string(); QUEUE_FOREACH(q, env->handle_wrap_queue()) { HandleWrap* w = ContainerOf(&HandleWrap::handle_wrap_queue_, q); if (w->persistent().IsEmpty() || (w->flags_ & HandleWrap::kUnref)) continue; Local object = w->object(); Local owner = object->Get(owner_sym); if (owner->IsUndefined()) owner = object; ary->Set(i++, owner); } args.GetReturnValue().Set(ary); } static void Abort(const FunctionCallbackInfo& args) { abort(); } static void Chdir(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); if (args.Length() != 1 || !args[0]->IsString()) { // FIXME(bnoordhuis) ThrowTypeError? return env->ThrowError("Bad argument."); } node::Utf8Value path(args[0]); int err = uv_chdir(*path); if (err) { return env->ThrowUVException(err, "uv_chdir"); } } static void Cwd(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); #ifdef _WIN32 /* MAX_PATH is in characters, not bytes. Make sure we have enough headroom. */ char buf[MAX_PATH * 4]; #else char buf[PATH_MAX]; #endif size_t cwd_len = sizeof(buf); int err = uv_cwd(buf, &cwd_len); if (err) { return env->ThrowUVException(err, "uv_cwd"); } Local cwd = String::NewFromUtf8(env->isolate(), buf, String::kNormalString, cwd_len); args.GetReturnValue().Set(cwd); } static void Umask(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); uint32_t old; if (args.Length() < 1 || args[0]->IsUndefined()) { old = umask(0); umask(static_cast(old)); } else if (!args[0]->IsInt32() && !args[0]->IsString()) { return env->ThrowTypeError("argument must be an integer or octal string."); } else { int oct; if (args[0]->IsInt32()) { oct = args[0]->Uint32Value(); } else { oct = 0; node::Utf8Value str(args[0]); // Parse the octal string. for (size_t i = 0; i < str.length(); i++) { char c = (*str)[i]; if (c > '7' || c < '0') { return env->ThrowTypeError("invalid octal string"); } oct *= 8; oct += c - '0'; } } old = umask(static_cast(oct)); } args.GetReturnValue().Set(old); } #if defined(__POSIX__) && !defined(__ANDROID__) static const uid_t uid_not_found = static_cast(-1); static const gid_t gid_not_found = static_cast(-1); static uid_t uid_by_name(const char* name) { struct passwd pwd; struct passwd* pp; char buf[8192]; errno = 0; pp = NULL; if (getpwnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != NULL) { return pp->pw_uid; } return uid_not_found; } static char* name_by_uid(uid_t uid) { struct passwd pwd; struct passwd* pp; char buf[8192]; int rc; errno = 0; pp = NULL; if ((rc = getpwuid_r(uid, &pwd, buf, sizeof(buf), &pp)) == 0 && pp != NULL) { return strdup(pp->pw_name); } if (rc == 0) { errno = ENOENT; } return NULL; } static gid_t gid_by_name(const char* name) { struct group pwd; struct group* pp; char buf[8192]; errno = 0; pp = NULL; if (getgrnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != NULL) { return pp->gr_gid; } return gid_not_found; } #if 0 // For future use. static const char* name_by_gid(gid_t gid) { struct group pwd; struct group* pp; char buf[8192]; int rc; errno = 0; pp = NULL; if ((rc = getgrgid_r(gid, &pwd, buf, sizeof(buf), &pp)) == 0 && pp != NULL) { return strdup(pp->gr_name); } if (rc == 0) { errno = ENOENT; } return NULL; } #endif static uid_t uid_by_name(Handle value) { if (value->IsUint32()) { return static_cast(value->Uint32Value()); } else { node::Utf8Value name(value); return uid_by_name(*name); } } static gid_t gid_by_name(Handle value) { if (value->IsUint32()) { return static_cast(value->Uint32Value()); } else { node::Utf8Value name(value); return gid_by_name(*name); } } static void GetUid(const FunctionCallbackInfo& args) { // uid_t is an uint32_t on all supported platforms. args.GetReturnValue().Set(static_cast(getuid())); } static void GetGid(const FunctionCallbackInfo& args) { // gid_t is an uint32_t on all supported platforms. args.GetReturnValue().Set(static_cast(getgid())); } static void SetGid(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); if (!args[0]->IsUint32() && !args[0]->IsString()) { return env->ThrowTypeError("setgid argument must be a number or a string"); } gid_t gid = gid_by_name(args[0]); if (gid == gid_not_found) { return env->ThrowError("setgid group id does not exist"); } if (setgid(gid)) { return env->ThrowErrnoException(errno, "setgid"); } } static void SetUid(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); if (!args[0]->IsUint32() && !args[0]->IsString()) { return env->ThrowTypeError("setuid argument must be a number or a string"); } uid_t uid = uid_by_name(args[0]); if (uid == uid_not_found) { return env->ThrowError("setuid user id does not exist"); } if (setuid(uid)) { return env->ThrowErrnoException(errno, "setuid"); } } static void GetGroups(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); int ngroups = getgroups(0, NULL); if (ngroups == -1) { return env->ThrowErrnoException(errno, "getgroups"); } gid_t* groups = new gid_t[ngroups]; ngroups = getgroups(ngroups, groups); if (ngroups == -1) { delete[] groups; return env->ThrowErrnoException(errno, "getgroups"); } Local groups_list = Array::New(env->isolate(), ngroups); bool seen_egid = false; gid_t egid = getegid(); for (int i = 0; i < ngroups; i++) { groups_list->Set(i, Integer::New(env->isolate(), groups[i])); if (groups[i] == egid) seen_egid = true; } delete[] groups; if (seen_egid == false) { groups_list->Set(ngroups, Integer::New(env->isolate(), egid)); } args.GetReturnValue().Set(groups_list); } static void SetGroups(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); if (!args[0]->IsArray()) { return env->ThrowTypeError("argument 1 must be an array"); } Local groups_list = args[0].As(); size_t size = groups_list->Length(); gid_t* groups = new gid_t[size]; for (size_t i = 0; i < size; i++) { gid_t gid = gid_by_name(groups_list->Get(i)); if (gid == gid_not_found) { delete[] groups; return env->ThrowError("group name not found"); } groups[i] = gid; } int rc = setgroups(size, groups); delete[] groups; if (rc == -1) { return env->ThrowErrnoException(errno, "setgroups"); } } static void InitGroups(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); if (!args[0]->IsUint32() && !args[0]->IsString()) { return env->ThrowTypeError("argument 1 must be a number or a string"); } if (!args[1]->IsUint32() && !args[1]->IsString()) { return env->ThrowTypeError("argument 2 must be a number or a string"); } node::Utf8Value arg0(args[0]); gid_t extra_group; bool must_free; char* user; if (args[0]->IsUint32()) { user = name_by_uid(args[0]->Uint32Value()); must_free = true; } else { user = *arg0; must_free = false; } if (user == NULL) { return env->ThrowError("initgroups user not found"); } extra_group = gid_by_name(args[1]); if (extra_group == gid_not_found) { if (must_free) free(user); return env->ThrowError("initgroups extra group not found"); } int rc = initgroups(user, extra_group); if (must_free) { free(user); } if (rc) { return env->ThrowErrnoException(errno, "initgroups"); } } #endif // __POSIX__ && !defined(__ANDROID__) void Exit(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); exit(args[0]->Int32Value()); } static void Uptime(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); double uptime; uv_update_time(env->event_loop()); uptime = uv_now(env->event_loop()) - prog_start_time; args.GetReturnValue().Set(Number::New(env->isolate(), uptime / 1000)); } void MemoryUsage(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); size_t rss; int err = uv_resident_set_memory(&rss); if (err) { return env->ThrowUVException(err, "uv_resident_set_memory"); } // V8 memory usage HeapStatistics v8_heap_stats; env->isolate()->GetHeapStatistics(&v8_heap_stats); Local heap_total = Integer::NewFromUnsigned(env->isolate(), v8_heap_stats.total_heap_size()); Local heap_used = Integer::NewFromUnsigned(env->isolate(), v8_heap_stats.used_heap_size()); Local info = Object::New(env->isolate()); info->Set(env->rss_string(), Number::New(env->isolate(), rss)); info->Set(env->heap_total_string(), heap_total); info->Set(env->heap_used_string(), heap_used); args.GetReturnValue().Set(info); } void Kill(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); if (args.Length() != 2) { return env->ThrowError("Bad argument."); } int pid = args[0]->Int32Value(); int sig = args[1]->Int32Value(); int err = uv_kill(pid, sig); args.GetReturnValue().Set(err); } // used in Hrtime() below #define NANOS_PER_SEC 1000000000 // Hrtime exposes libuv's uv_hrtime() high-resolution timer. // The value returned by uv_hrtime() is a 64-bit int representing nanoseconds, // so this function instead returns an Array with 2 entries representing seconds // and nanoseconds, to avoid any integer overflow possibility. // Pass in an Array from a previous hrtime() call to instead get a time diff. void Hrtime(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); HandleScope scope(env->isolate()); uint64_t t = uv_hrtime(); if (args.Length() > 0) { // return a time diff tuple if (!args[0]->IsArray()) { return env->ThrowTypeError( "process.hrtime() only accepts an Array tuple."); } Local inArray = Local::Cast(args[0]); uint64_t seconds = inArray->Get(0)->Uint32Value(); uint64_t nanos = inArray->Get(1)->Uint32Value(); t -= (seconds * NANOS_PER_SEC) + nanos; } Local tuple = Array::New(env->isolate(), 2); tuple->Set(0, Integer::NewFromUnsigned(env->isolate(), t / NANOS_PER_SEC)); tuple->Set(1, Integer::NewFromUnsigned(env->isolate(), t % NANOS_PER_SEC)); args.GetReturnValue().Set(tuple); } extern "C" void node_module_register(void* m) { struct node_module* mp = reinterpret_cast(m); if (mp->nm_flags & NM_F_BUILTIN) { mp->nm_link = modlist_builtin; modlist_builtin = mp; } else if (!node_is_initialized) { // "Linked" modules are included as part of the node project. // Like builtins they are registered *before* node::Init runs. mp->nm_flags = NM_F_LINKED; mp->nm_link = modlist_linked; modlist_linked = mp; } else { // Once node::Init was called we can only register dynamic modules. // See DLOpen. assert(modpending == NULL); modpending = mp; } } struct node_module* get_builtin_module(const char* name) { struct node_module* mp; for (mp = modlist_builtin; mp != NULL; mp = mp->nm_link) { if (strcmp(mp->nm_modname, name) == 0) break; } assert(mp == NULL || (mp->nm_flags & NM_F_BUILTIN) != 0); return (mp); } struct node_module* get_linked_module(const char* name) { struct node_module* mp; for (mp = modlist_linked; mp != NULL; mp = mp->nm_link) { if (strcmp(mp->nm_modname, name) == 0) break; } CHECK(mp == NULL || (mp->nm_flags & NM_F_LINKED) != 0); return mp; } typedef void (UV_DYNAMIC* extInit)(Handle exports); // DLOpen is process.dlopen(module, filename). // 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? void DLOpen(const FunctionCallbackInfo& args) { HandleScope handle_scope(args.GetIsolate()); Environment* env = Environment::GetCurrent(args.GetIsolate()); struct node_module* mp; uv_lib_t lib; if (args.Length() < 2) { env->ThrowError("process.dlopen takes exactly 2 arguments."); return; } Local module = args[0]->ToObject(); // Cast node::Utf8Value filename(args[1]); // Cast Local exports_string = env->exports_string(); Local exports = module->Get(exports_string)->ToObject(); if (uv_dlopen(*filename, &lib)) { Local errmsg = OneByteString(env->isolate(), uv_dlerror(&lib)); #ifdef _WIN32 // Windows needs to add the filename into the error message errmsg = String::Concat(errmsg, args[1]->ToString()); #endif // _WIN32 env->isolate()->ThrowException(Exception::Error(errmsg)); return; } /* * 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. */ mp = modpending; modpending = NULL; if (mp == NULL) { env->ThrowError("Module did not self-register."); return; } if (mp->nm_version != NODE_MODULE_VERSION) { char errmsg[1024]; snprintf(errmsg, sizeof(errmsg), "Module version mismatch. Expected %d, got %d.", NODE_MODULE_VERSION, mp->nm_version); env->ThrowError(errmsg); return; } if (mp->nm_flags & NM_F_BUILTIN) { env->ThrowError("Built-in module self-registered."); return; } mp->nm_dso_handle = lib.handle; mp->nm_link = modlist_addon; modlist_addon = mp; if (mp->nm_context_register_func != NULL) { mp->nm_context_register_func(exports, module, env->context(), mp->nm_priv); } else if (mp->nm_register_func != NULL) { mp->nm_register_func(exports, module, mp->nm_priv); } else { env->ThrowError("Module has no declared entry point."); return; } // Tell coverity that 'handle' should not be freed when we return. // coverity[leaked_storage] } static void OnFatalError(const char* location, const char* message) { if (location) { fprintf(stderr, "FATAL ERROR: %s %s\n", location, message); } else { fprintf(stderr, "FATAL ERROR: %s\n", message); } fflush(stderr); abort(); } NO_RETURN void FatalError(const char* location, const char* message) { OnFatalError(location, message); // to suppress compiler warning abort(); } void FatalException(Isolate* isolate, Handle error, Handle message) { HandleScope scope(isolate); Environment* env = Environment::GetCurrent(isolate); Local process_object = env->process_object(); Local fatal_exception_string = env->fatal_exception_string(); Local fatal_exception_function = process_object->Get(fatal_exception_string).As(); if (!fatal_exception_function->IsFunction()) { // failed before the process._fatalException function was added! // this is probably pretty bad. Nothing to do but report and exit. ReportException(env, error, message); exit(6); } TryCatch fatal_try_catch; // Do not call FatalException when _fatalException handler throws fatal_try_catch.SetVerbose(false); // this will return true if the JS layer handled it, false otherwise Local caught = fatal_exception_function->Call(process_object, 1, &error); if (fatal_try_catch.HasCaught()) { // the fatal exception function threw, so we must exit ReportException(env, fatal_try_catch); exit(7); } if (false == caught->BooleanValue()) { ReportException(env, error, message); exit(1); } } void FatalException(Isolate* isolate, const TryCatch& try_catch) { HandleScope scope(isolate); // TODO(bajtos) do not call FatalException if try_catch is verbose // (requires V8 API to expose getter for try_catch.is_verbose_) FatalException(isolate, try_catch.Exception(), try_catch.Message()); } void OnMessage(Handle message, Handle error) { // The current version of V8 sends messages for errors only // (thus `error` is always set). FatalException(Isolate::GetCurrent(), error, message); } static void Binding(const FunctionCallbackInfo& args) { HandleScope handle_scope(args.GetIsolate()); Environment* env = Environment::GetCurrent(args.GetIsolate()); Local module = args[0]->ToString(); node::Utf8Value module_v(module); Local cache = env->binding_cache_object(); Local exports; if (cache->Has(module)) { exports = cache->Get(module)->ToObject(); args.GetReturnValue().Set(exports); return; } // Append a string to process.moduleLoadList char buf[1024]; snprintf(buf, sizeof(buf), "Binding %s", *module_v); Local modules = env->module_load_list_array(); uint32_t l = modules->Length(); modules->Set(l, OneByteString(env->isolate(), buf)); node_module* mod = get_builtin_module(*module_v); if (mod != NULL) { exports = Object::New(env->isolate()); // Internal bindings don't have a "module" object, only exports. assert(mod->nm_register_func == NULL); assert(mod->nm_context_register_func != NULL); Local unused = Undefined(env->isolate()); mod->nm_context_register_func(exports, unused, env->context(), mod->nm_priv); cache->Set(module, exports); } else if (!strcmp(*module_v, "constants")) { exports = Object::New(env->isolate()); DefineConstants(exports); cache->Set(module, exports); } else if (!strcmp(*module_v, "natives")) { exports = Object::New(env->isolate()); DefineJavaScript(env, exports); cache->Set(module, exports); } else { char errmsg[1024]; snprintf(errmsg, sizeof(errmsg), "No such module: %s", *module_v); return env->ThrowError(errmsg); } args.GetReturnValue().Set(exports); } static void LinkedBinding(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args.GetIsolate()); Local module = args[0]->ToString(); Local cache = env->binding_cache_object(); Local exports_v = cache->Get(module); if (exports_v->IsObject()) return args.GetReturnValue().Set(exports_v.As()); node::Utf8Value module_v(module); node_module* mod = get_linked_module(*module_v); if (mod == NULL) { char errmsg[1024]; snprintf(errmsg, sizeof(errmsg), "No such module was linked: %s", *module_v); return env->ThrowError(errmsg); } Local exports = Object::New(env->isolate()); if (mod->nm_context_register_func != NULL) { mod->nm_context_register_func(exports, module, env->context(), mod->nm_priv); } else if (mod->nm_register_func != NULL) { mod->nm_register_func(exports, module, mod->nm_priv); } else { return env->ThrowError("Linked module has no declared entry point."); } cache->Set(module, exports); args.GetReturnValue().Set(exports); } static void ProcessTitleGetter(Local property, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info.GetIsolate()); HandleScope scope(env->isolate()); char buffer[512]; uv_get_process_title(buffer, sizeof(buffer)); info.GetReturnValue().Set(String::NewFromUtf8(env->isolate(), buffer)); } static void ProcessTitleSetter(Local property, Local value, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info.GetIsolate()); HandleScope scope(env->isolate()); node::Utf8Value title(value); // TODO(piscisaureus): protect with a lock uv_set_process_title(*title); } static void EnvGetter(Local property, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info.GetIsolate()); HandleScope scope(env->isolate()); #ifdef __POSIX__ node::Utf8Value key(property); const char* val = getenv(*key); if (val) { return info.GetReturnValue().Set(String::NewFromUtf8(env->isolate(), val)); } #else // _WIN32 String::Value key(property); WCHAR buffer[32767]; // The maximum size allowed for environment variables. DWORD result = GetEnvironmentVariableW(reinterpret_cast(*key), buffer, ARRAY_SIZE(buffer)); // If result >= sizeof buffer the buffer was too small. That should never // happen. If result == 0 and result != ERROR_SUCCESS the variable was not // not found. if ((result > 0 || GetLastError() == ERROR_SUCCESS) && result < ARRAY_SIZE(buffer)) { const uint16_t* two_byte_buffer = reinterpret_cast(buffer); Local rc = String::NewFromTwoByte(env->isolate(), two_byte_buffer); return info.GetReturnValue().Set(rc); } #endif // Not found. Fetch from prototype. info.GetReturnValue().Set( info.Data().As()->Get(property)); } static void EnvSetter(Local property, Local value, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info.GetIsolate()); HandleScope scope(env->isolate()); #ifdef __POSIX__ node::Utf8Value key(property); node::Utf8Value val(value); setenv(*key, *val, 1); #else // _WIN32 String::Value key(property); String::Value val(value); WCHAR* key_ptr = reinterpret_cast(*key); // Environment variables that start with '=' are read-only. if (key_ptr[0] != L'=') { SetEnvironmentVariableW(key_ptr, reinterpret_cast(*val)); } #endif // Whether it worked or not, always return rval. info.GetReturnValue().Set(value); } static void EnvQuery(Local property, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info.GetIsolate()); HandleScope scope(env->isolate()); int32_t rc = -1; // Not found unless proven otherwise. #ifdef __POSIX__ node::Utf8Value key(property); if (getenv(*key)) rc = 0; #else // _WIN32 String::Value key(property); WCHAR* key_ptr = reinterpret_cast(*key); if (GetEnvironmentVariableW(key_ptr, NULL, 0) > 0 || GetLastError() == ERROR_SUCCESS) { rc = 0; if (key_ptr[0] == L'=') { // Environment variables that start with '=' are hidden and read-only. rc = static_cast(v8::ReadOnly) | static_cast(v8::DontDelete) | static_cast(v8::DontEnum); } } #endif if (rc != -1) info.GetReturnValue().Set(rc); } static void EnvDeleter(Local property, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info.GetIsolate()); HandleScope scope(env->isolate()); bool rc = true; #ifdef __POSIX__ node::Utf8Value key(property); rc = getenv(*key) != NULL; if (rc) unsetenv(*key); #else String::Value key(property); WCHAR* key_ptr = reinterpret_cast(*key); if (key_ptr[0] == L'=' || !SetEnvironmentVariableW(key_ptr, NULL)) { // Deletion failed. Return true if the key wasn't there in the first place, // false if it is still there. rc = GetEnvironmentVariableW(key_ptr, NULL, NULL) == 0 && GetLastError() != ERROR_SUCCESS; } #endif info.GetReturnValue().Set(rc); } static void EnvEnumerator(const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info.GetIsolate()); HandleScope scope(env->isolate()); #ifdef __POSIX__ int size = 0; while (environ[size]) size++; Local envarr = Array::New(env->isolate(), size); for (int i = 0; i < size; ++i) { const char* var = environ[i]; const char* s = strchr(var, '='); const int length = s ? s - var : strlen(var); Local name = String::NewFromUtf8(env->isolate(), var, String::kNormalString, length); envarr->Set(i, name); } #else // _WIN32 WCHAR* environment = GetEnvironmentStringsW(); if (environment == NULL) return; // This should not happen. Local