// 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_unicode.h>

#include <uv.h>

#include <v8-debug.h>

#ifdef HAVE_DTRACE

# include <node_dtrace.h>

#endif

#include <locale.h>

#include <signal.h>

#include <stdio.h>

#if defined(_MSC_VER)

#define snprintf _snprintf

#endif

#include <stdlib.h>

#include <string.h>

#if !defined(_MSC_VER)

#include <strings.h>

#else

#define strcasecmp _stricmp

#endif

#include <limits.h> /* PATH_MAX */

#include <assert.h>

#if !defined(_MSC_VER)

#include <unistd.h> /* setuid, getuid */

#else

#include <direct.h>

#include <process.h>

#define getpid _getpid

#include <io.h>

#define umask _umask

typedef int mode_t;

#endif

#include <errno.h>

#include <sys/types.h>

#ifdef __POSIX__

# include <pwd.h> /* getpwnam() */

# include <grp.h> /* getgrnam() */

#endif

#include <node_buffer.h>

#ifdef __POSIX__

# include <node_io_watcher.h>

#endif

#include <node_file.h>

#include <node_http_parser.h>

#ifdef __POSIX__

# include <node_signal_watcher.h>

# include <node_stat_watcher.h>

#endif

#include <node_constants.h>

#include <node_javascript.h>

#include <node_version.h>

#include <node_string.h>

#if HAVE_OPENSSL

# include <node_crypto.h>

#endif

#include <node_script.h>

#include <v8_typed_array.h>

using namespace v8;

# ifdef __APPLE__

# include <crt_externs.h>

# define environ (*_NSGetEnviron())

# elif !defined(_MSC_VER)

extern char **environ;

# endif

namespace node {

static Persistent<Object> process;

static Persistent<String> errno_symbol;

static Persistent<String> syscall_symbol;

static Persistent<String> errpath_symbol;

static Persistent<String> code_symbol;

static Persistent<String> rss_symbol;

static Persistent<String> heap_total_symbol;

static Persistent<String> heap_used_symbol;

static Persistent<String> listeners_symbol;

static Persistent<String> uncaught_exception_symbol;

static Persistent<String> emit_symbol;

static bool print_eval = false;

static char *eval_string = NULL;

static int option_end_index = 0;

static bool use_debug_agent = false;

static bool debug_wait_connect = false;

static int debug_port=5858;

static int max_stack_size = 0;

static uv_check_t check_tick_watcher;

static uv_prepare_t prepare_tick_watcher;

static uv_idle_t tick_spinner;

static bool need_tick_cb;

static Persistent<String> tick_callback_sym;

#ifdef OPENSSL_NPN_NEGOTIATED

static bool use_npn = true;

#else

static bool use_npn = false;

#endif

#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB

static bool use_sni = true;

#else

static bool use_sni = false;

#endif

#ifdef __POSIX__

// Buffer for getpwnam_r(), getgrpam_r() and other misc callers; keep this

// scoped at file-level rather than method-level to avoid excess stack usage.

static char getbuf[PATH_MAX + 1];

#endif

// We need to notify V8 when we're idle so that it can run the garbage

// collector. The interface to this is V8::IdleNotification(). It returns

// true if the heap hasn't be fully compacted, and needs to be run again.

// Returning false means that it doesn't have anymore work to do.

//

// A rather convoluted algorithm has been devised to determine when Node is

// idle. You'll have to figure it out for yourself.

static uv_check_t gc_check;

static uv_idle_t gc_idle;

static uv_timer_t gc_timer;

bool need_gc;

// process-relative uptime base, initialized at start-up

static double prog_start_time;

#define FAST_TICK 700.

#define GC_WAIT_TIME 5000.

#define RPM_SAMPLES 100

#define TICK_TIME(n) tick_times[(tick_time_head - (n)) % RPM_SAMPLES]

static int64_t tick_times[RPM_SAMPLES];

static int tick_time_head;

static void CheckStatus(uv_timer_t* watcher, int status);

static void StartGCTimer () {

if (!uv_is_active((uv_handle_t*) &gc_timer)) {

uv_timer_start(&gc_timer, node::CheckStatus, 5000, 5000);

}

}

static void StopGCTimer () {

if (uv_is_active((uv_handle_t*) &gc_timer)) {

uv_timer_stop(&gc_timer);

}

}

static void Idle(uv_idle_t* watcher, int status) {

assert((uv_idle_t*) watcher == &gc_idle);

if (V8::IdleNotification()) {

uv_idle_stop(&gc_idle);

StopGCTimer();

}

}

// Called directly after every call to select() (or epoll, or whatever)

static void Check(uv_check_t* watcher, int status) {

assert(watcher == &gc_check);

tick_times[tick_time_head] = uv_now(uv_default_loop());

tick_time_head = (tick_time_head + 1) % RPM_SAMPLES;

StartGCTimer();

for (int i = 0; i < (int)(GC_WAIT_TIME/FAST_TICK); i++) {

double d = TICK_TIME(i+1) - TICK_TIME(i+2);

//printf("d = %f\n", d);

// If in the last 5 ticks the difference between

// ticks was less than 0.7 seconds, then continue.

if (d < FAST_TICK) {

//printf("---\n");

return;

}

}

// Otherwise start the gc!

//fprintf(stderr, "start idle 2\n");

uv_idle_start(&gc_idle, node::Idle);

}

static void Tick(void) {

// Avoid entering a V8 scope.

if (!need_tick_cb) return;

need_tick_cb = false;

if (uv_is_active((uv_handle_t*) &tick_spinner)) {

uv_idle_stop(&tick_spinner);

uv_unref(uv_default_loop());

}

HandleScope scope;

if (tick_callback_sym.IsEmpty()) {

// Lazily set the symbol

tick_callback_sym =

Persistent<String>::New(String::NewSymbol("_tickCallback"));

}

Local<Value> cb_v = process->Get(tick_callback_sym);

if (!cb_v->IsFunction()) return;

Local<Function> cb = Local<Function>::Cast(cb_v);

TryCatch try_catch;

cb->Call(process, 0, NULL);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

}

static void Spin(uv_idle_t* handle, int status) {

assert((uv_idle_t*) handle == &tick_spinner);

assert(status == 0);

Tick();

}

static Handle<Value> NeedTickCallback(const Arguments& args) {

HandleScope scope;

need_tick_cb = true;

// TODO: this tick_spinner shouldn't be necessary. An ev_prepare should be

// sufficent, the problem is only in the case of the very last "tick" -

// there is nothing left to do in the event loop and libev will exit. The

// ev_prepare callback isn't called before exiting. Thus we start this

// tick_spinner to keep the event loop alive long enough to handle it.

if (!uv_is_active((uv_handle_t*) &tick_spinner)) {

uv_idle_start(&tick_spinner, Spin);

uv_ref(uv_default_loop());

}

return Undefined();

}

static void PrepareTick(uv_prepare_t* handle, int status) {

assert(handle == &prepare_tick_watcher);

assert(status == 0);

Tick();

}

static void CheckTick(uv_check_t* handle, int status) {

assert(handle == &check_tick_watcher);

assert(status == 0);

Tick();

}

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 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 "";

}

}

Local<Value> ErrnoException(int errorno,

const char *syscall,

const char *msg,

const char *path) {

Local<Value> e;

Local<String> estring = String::NewSymbol(errno_string(errorno));

if (!msg[0]) {

msg = strerror(errorno);

}

Local<String> message = String::NewSymbol(msg);

Local<String> cons1 = String::Concat(estring, String::NewSymbol(", "));

Local<String> cons2 = String::Concat(cons1, message);

if (syscall_symbol.IsEmpty()) {

syscall_symbol = NODE_PSYMBOL("syscall");

errno_symbol = NODE_PSYMBOL("errno");

errpath_symbol = NODE_PSYMBOL("path");

code_symbol = NODE_PSYMBOL("code");

}

if (path) {

Local<String> cons3 = String::Concat(cons2, String::NewSymbol(" '"));

Local<String> cons4 = String::Concat(cons3, String::New(path));

Local<String> cons5 = String::Concat(cons4, String::NewSymbol("'"));

e = Exception::Error(cons5);

} else {

e = Exception::Error(cons2);

}

Local<Object> obj = e->ToObject();

obj->Set(errno_symbol, Integer::New(errorno));

obj->Set(code_symbol, estring);

if (path) obj->Set(errpath_symbol, String::New(path));

if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));

return e;

}

static const char* get_uv_errno_string(int errorno) {

uv_err_t err;

memset(&err, 0, sizeof err);

err.code = (uv_err_code)errorno;

return uv_err_name(err);

}

static const char* get_uv_errno_message(int errorno) {

uv_err_t err;

memset(&err, 0, sizeof err);

err.code = (uv_err_code)errorno;

return uv_strerror(err);

}

// hack alert! copy of ErrnoException, tuned for uv errors

Local<Value> UVException(int errorno,

const char *syscall,

const char *msg,

const char *path) {

if (syscall_symbol.IsEmpty()) {

syscall_symbol = NODE_PSYMBOL("syscall");

errno_symbol = NODE_PSYMBOL("errno");

errpath_symbol = NODE_PSYMBOL("path");

code_symbol = NODE_PSYMBOL("code");

}

if (!msg || !msg[0])

msg = get_uv_errno_message(errorno);

Local<String> estring = String::NewSymbol(get_uv_errno_string(errorno));

Local<String> message = String::NewSymbol(msg);

Local<String> cons1 = String::Concat(estring, String::NewSymbol(", "));

Local<String> cons2 = String::Concat(cons1, message);

Local<Value> e;

Local<String> path_str;

if (path) {

#ifdef _WIN32

if (strncmp(path, "\\\\?\\UNC\\", 8) == 0) {

path_str = String::Concat(String::New("\\\\"), String::New(path + 8));

} else if (strncmp(path, "\\\\?\\", 4) == 0) {

path_str = String::New(path + 4);

} else {

path_str = String::New(path);

}

#else

path_str = String::New(path);

#endif

Local<String> cons3 = String::Concat(cons2, String::NewSymbol(" '"));

Local<String> cons4 = String::Concat(cons3, path_str);

Local<String> cons5 = String::Concat(cons4, String::NewSymbol("'"));

e = Exception::Error(cons5);

} else {

e = Exception::Error(cons2);

}

Local<Object> obj = e->ToObject();

// TODO errno should probably go

obj->Set(errno_symbol, Integer::New(errorno));

obj->Set(code_symbol, estring);

if (path) obj->Set(errpath_symbol, path_str);

if (syscall) obj->Set(syscall_symbol, String::NewSymbol(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) {

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) {

// 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

return "Unknown error";

}

}

Local<Value> WinapiErrnoException(int errorno,

const char* syscall,

const char* msg,

const char* path) {

Local<Value> e;

if (!msg || !msg[0]) {

msg = winapi_strerror(errorno);

}

Local<String> message = String::NewSymbol(msg);

if (syscall_symbol.IsEmpty()) {

syscall_symbol = NODE_PSYMBOL("syscall");

errno_symbol = NODE_PSYMBOL("errno");

errpath_symbol = NODE_PSYMBOL("path");

code_symbol = NODE_PSYMBOL("code");

}

if (path) {

Local<String> cons1 = String::Concat(message, String::NewSymbol(" '"));

Local<String> cons2 = String::Concat(cons1, String::New(path));

Local<String> cons3 = String::Concat(cons2, String::NewSymbol("'"));

e = Exception::Error(cons3);

} else {

e = Exception::Error(message);

}

Local<Object> obj = e->ToObject();

obj->Set(errno_symbol, Integer::New(errorno));

if (path) obj->Set(errpath_symbol, String::New(path));

if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));

return e;

}

#endif

Handle<Value> FromConstructorTemplate(Persistent<FunctionTemplate>& t,

const Arguments& args) {

HandleScope scope;

const int argc = args.Length();

Local<Value>* argv = new Local<Value>[argc];

for (int i = 0; i < argc; ++i) {

argv[i] = args[i];

}

Local<Object> instance = t->GetFunction()->NewInstance(argc, argv);

delete[] argv;

return scope.Close(instance);

}

// MakeCallback may only be made directly off the event loop.

// That is there can be no JavaScript stack frames underneath it.

// (Is there any way to assert that?)

//

// Maybe make this a method of a node::Handle super class

//

void MakeCallback(Handle<Object> object,

const char* method,

int argc,

Handle<Value> argv[]) {

HandleScope scope;

Local<Value> callback_v = object->Get(String::New(method));

if (!callback_v->IsFunction()) {

fprintf(stderr, "method = %s", method);

}

assert(callback_v->IsFunction());

Local<Function> callback = Local<Function>::Cast(callback_v);

// TODO Hook for long stack traces to be made here.

TryCatch try_catch;

callback->Call(object, argc, argv);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

}

void SetErrno(uv_err_t err) {

HandleScope scope;

if (errno_symbol.IsEmpty()) {

errno_symbol = NODE_PSYMBOL("errno");

}

if (err.code == UV_UNKNOWN) {

char errno_buf[100];

snprintf(errno_buf, 100, "Unknown system errno %d", err.sys_errno_);

Context::GetCurrent()->Global()->Set(errno_symbol, String::New(errno_buf));

} else {

Context::GetCurrent()->Global()->Set(errno_symbol,

String::NewSymbol(uv_err_name(err)));

}

}