// Copyright 2009 Ryan Dahl <ry@tinyclouds.org>

#include <node.h>

#include <locale.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <string.h>

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

#include <assert.h>

#include <unistd.h>

#include <errno.h>

#include <dlfcn.h> /* dlopen(), dlsym() */

#include <sys/types.h>

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

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

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

#include "platform.h"

#include <node_buffer.h>

#include <node_io_watcher.h>

#include <node_net.h>

#include <node_events.h>

#include <node_cares.h>

#include <node_file.h>

#if 0

// not in use

# include <node_idle_watcher.h>

#endif

#include <node_http_parser.h>

#include <node_signal_watcher.h>

#include <node_stat_watcher.h>

#include <node_timer.h>

#include <node_child_process.h>

#include <node_constants.h>

#include <node_stdio.h>

#include <node_natives.h>

#include <node_version.h>

#ifdef HAVE_OPENSSL

#include <node_crypto.h>

#endif

#include <node_script.h>

#include <v8-debug.h>

#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))

using namespace v8;

extern char **environ;

namespace node {

static Persistent<Object> process;

static Persistent<String> errno_symbol;

static Persistent<String> syscall_symbol;

static Persistent<String> errpath_symbol;

static Persistent<String> dev_symbol;

static Persistent<String> ino_symbol;

static Persistent<String> mode_symbol;

static Persistent<String> nlink_symbol;

static Persistent<String> uid_symbol;

static Persistent<String> gid_symbol;

static Persistent<String> rdev_symbol;

static Persistent<String> size_symbol;

static Persistent<String> blksize_symbol;

static Persistent<String> blocks_symbol;

static Persistent<String> atime_symbol;

static Persistent<String> mtime_symbol;

static Persistent<String> ctime_symbol;

static Persistent<String> rss_symbol;

static Persistent<String> vsize_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 int option_end_index = 0;

static bool use_debug_agent = false;

static bool debug_wait_connect = false;

static int debug_port=5858;

static ev_prepare next_tick_watcher;

static ev_idle tick_spinner;

static bool need_tick_cb;

static Persistent<String> tick_callback_sym;

static ev_async eio_want_poll_notifier;

static ev_async eio_done_poll_notifier;

static ev_idle eio_poller;

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

// 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 ev_check gc_check;

static ev_idle gc_idle;

static ev_timer gc_timer;

bool need_gc;

#define FAST_TICK 0.7

#define GC_WAIT_TIME 5.

#define RPM_SAMPLES 100

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

static ev_tstamp tick_times[RPM_SAMPLES];

static int tick_time_head;

static void StartGCTimer () {

if (!ev_is_active(&gc_timer)) {

ev_timer_start(EV_DEFAULT_UC_ &gc_timer);

ev_unref(EV_DEFAULT_UC);

}

}

static void StopGCTimer () {

if (ev_is_active(&gc_timer)) {

ev_ref(EV_DEFAULT_UC);

ev_timer_stop(EV_DEFAULT_UC_ &gc_timer);

}

}

static void Idle(EV_P_ ev_idle *watcher, int revents) {

assert(watcher == &gc_idle);

assert(revents == EV_IDLE);

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

if (V8::IdleNotification()) {

ev_idle_stop(EV_A_ watcher);

StopGCTimer();

}

}

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

static void Check(EV_P_ ev_check *watcher, int revents) {

assert(watcher == &gc_check);

assert(revents == EV_CHECK);

tick_times[tick_time_head] = ev_now(EV_DEFAULT_UC);

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

ev_idle_start(EV_A_ &gc_idle);

}

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

HandleScope scope;

need_tick_cb = true;

ev_idle_start(EV_DEFAULT_UC_ &tick_spinner);

return Undefined();

}

static void Spin(EV_P_ ev_idle *watcher, int revents) {

assert(watcher == &tick_spinner);

assert(revents == EV_IDLE);

}

static void Tick(EV_P_ ev_prepare *watcher, int revents) {

assert(watcher == &next_tick_watcher);

assert(revents == EV_PREPARE);

// Avoid entering a V8 scope.

if (!need_tick_cb) return;

need_tick_cb = false;

ev_idle_stop(EV_DEFAULT_UC_ &tick_spinner);

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 DoPoll(EV_P_ ev_idle *watcher, int revents) {

assert(watcher == &eio_poller);

assert(revents == EV_IDLE);

//printf("eio_poller\n");

if (eio_poll() != -1) {

//printf("eio_poller stop\n");

ev_idle_stop(EV_DEFAULT_UC_ watcher);

}

}

// Called from the main thread.

static void WantPollNotifier(EV_P_ ev_async *watcher, int revents) {

assert(watcher == &eio_want_poll_notifier);

assert(revents == EV_ASYNC);

//printf("want poll notifier\n");

if (eio_poll() == -1) {

//printf("eio_poller start\n");

ev_idle_start(EV_DEFAULT_UC_ &eio_poller);

}

}

static void DonePollNotifier(EV_P_ ev_async *watcher, int revents) {

assert(watcher == &eio_done_poll_notifier);

assert(revents == EV_ASYNC);

//printf("done poll notifier\n");

if (eio_poll() != -1) {

//printf("eio_poller stop\n");

ev_idle_stop(EV_DEFAULT_UC_ &eio_poller);

}

}

// EIOWantPoll() is called from the EIO thread pool each time an EIO

// request (that is, one of the node.fs.* functions) has completed.

static void EIOWantPoll(void) {

// Signal the main thread that eio_poll need to be processed.

ev_async_send(EV_DEFAULT_UC_ &eio_want_poll_notifier);

}

static void EIODonePoll(void) {

// Signal the main thread that we should stop calling eio_poll().

// from the idle watcher.

ev_async_send(EV_DEFAULT_UC_ &eio_done_poll_notifier);

}

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

SIGNO_CASE(SIGCHLD);

#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 (errno_symbol.IsEmpty()) {

syscall_symbol = NODE_PSYMBOL("syscall");

errno_symbol = NODE_PSYMBOL("errno");

errpath_symbol = NODE_PSYMBOL("path");

}

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

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

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

return e;

}

enum encoding ParseEncoding(Handle<Value> encoding_v, enum encoding _default) {

HandleScope scope;

if (!encoding_v->IsString()) return _default;

String::Utf8Value encoding(encoding_v->ToString());

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, "binary") == 0) {

return BINARY;

} else if (strcasecmp(*encoding, "raw") == 0) {

fprintf(stderr, "'raw' (array of integers) has been removed. "

"Use 'binary'.\n");

return BINARY;

} else if (strcasecmp(*encoding, "raws") == 0) {

fprintf(stderr, "'raws' encoding has been renamed to 'binary'. "

"Please update your code.\n");

return BINARY;

} else {

return _default;

}

}

Local<Value> Encode(const void *buf, size_t len, enum encoding encoding) {

HandleScope scope;

if (!len) return scope.Close(String::Empty());

if (encoding == BINARY) {

const unsigned char *cbuf = static_cast<const unsigned char*>(buf);

uint16_t * twobytebuf = new uint16_t[len];

for (size_t i = 0; i < len; i++) {

// XXX is the following line platform independent?

twobytebuf[i] = cbuf[i];

}

Local<String> chunk = String::New(twobytebuf, len);

delete [] twobytebuf; // TODO use ExternalTwoByteString?

return scope.Close(chunk);

}

// utf8 or ascii encoding

Local<String> chunk = String::New((const char*)buf, len);

return scope.Close(chunk);

}

// Returns -1 if the handle was not valid for decoding

ssize_t DecodeBytes(v8::Handle<v8::Value> val, enum encoding encoding) {

HandleScope scope;

if (val->IsArray()) {

fprintf(stderr, "'raw' encoding (array of integers) has been removed. "

"Use 'binary'.\n");

assert(0);

return -1;

}

Local<String> str = val->ToString();

if (encoding == UTF8) return str->Utf8Length();

return str->Length();

}

#ifndef MIN

# define MIN(a, b) ((a) < (b) ? (a) : (b))

#endif

// Returns number of bytes written.

ssize_t DecodeWrite(char *buf,

size_t buflen,

v8::Handle<v8::Value> val,

enum encoding encoding) {

HandleScope scope;

// XXX

// A lot of improvement can be made here. See:

// http://code.google.com/p/v8/issues/detail?id=270

// http://groups.google.com/group/v8-dev/browse_thread/thread/dba28a81d9215291/ece2b50a3b4022c

// http://groups.google.com/group/v8-users/browse_thread/thread/1f83b0ba1f0a611

if (val->IsArray()) {

fprintf(stderr, "'raw' encoding (array of integers) has been removed. "

"Use 'binary'.\n");

assert(0);

return -1;

}

Local<String> str = val->ToString();

if (encoding == UTF8) {

str->WriteUtf8(buf, buflen, NULL, String::HINT_MANY_WRITES_EXPECTED);

return buflen;

}

if (encoding == ASCII) {

str->WriteAscii(buf, 0, buflen, String::HINT_MANY_WRITES_EXPECTED);

return buflen;

}

// THIS IS AWFUL!!! FIXME

assert(encoding == BINARY);

uint16_t * twobytebuf = new uint16_t[buflen];

str->Write(twobytebuf, 0, buflen, String::HINT_MANY_WRITES_EXPECTED);

for (size_t i = 0; i < buflen; i++) {

unsigned char *b = reinterpret_cast<unsigned char*>(&twobytebuf[i]);

assert(b[1] == 0);

buf[i] = b[0];

}

delete [] twobytebuf;

return buflen;

}

static Persistent<FunctionTemplate> stats_constructor_template;

Local<Object> BuildStatsObject(struct stat * s) {

HandleScope scope;

if (dev_symbol.IsEmpty()) {

dev_symbol = NODE_PSYMBOL("dev");

ino_symbol = NODE_PSYMBOL("ino");

mode_symbol = NODE_PSYMBOL("mode");

nlink_symbol = NODE_PSYMBOL("nlink");

uid_symbol = NODE_PSYMBOL("uid");

gid_symbol = NODE_PSYMBOL("gid");

rdev_symbol = NODE_PSYMBOL("rdev");

size_symbol = NODE_PSYMBOL("size");

blksize_symbol = NODE_PSYMBOL("blksize");

blocks_symbol = NODE_PSYMBOL("blocks");

atime_symbol = NODE_PSYMBOL("atime");

mtime_symbol = NODE_PSYMBOL("mtime");

ctime_symbol = NODE_PSYMBOL("ctime");

}

Local<Object> stats =

stats_constructor_template->GetFunction()->NewInstance();

/* ID of device containing file */

stats->Set(dev_symbol, Integer::New(s->st_dev));

/* inode number */

stats->Set(ino_symbol, Integer::New(s->st_ino));

/* protection */

stats->Set(mode_symbol, Integer::New(s->st_mode));

/* number of hard links */

stats->Set(nlink_symbol, Integer::New(s->st_nlink));

/* user ID of owner */

stats->Set(uid_symbol, Integer::New(s->st_uid));

/* group ID of owner */

stats->Set(gid_symbol, Integer::New(s->st_gid));

/* device ID (if special file) */

stats->Set(rdev_symbol, Integer::New(s->st_rdev));

/* total size, in bytes */

stats->Set(size_symbol, Number::New(s->st_size));

/* blocksize for filesystem I/O */

stats->Set(blksize_symbol, Integer::New(s->st_blksize));

/* number of blocks allocated */

stats->Set(blocks_symbol, Integer::New(s->st_blocks));

/* time of last access */

stats->Set(atime_symbol, NODE_UNIXTIME_V8(s->st_atime));

/* time of last modification */

stats->Set(mtime_symbol, NODE_UNIXTIME_V8(s->st_mtime));

/* time of last status change */

stats->Set(ctime_symbol, NODE_UNIXTIME_V8(s->st_ctime));

return scope.Close(stats);

}

// Extracts a C str from a V8 Utf8Value.

const char* ToCString(const v8::String::Utf8Value& value) {

return *value ? *value : "<str conversion failed>";

}

static void ReportException(TryCatch &try_catch, bool show_line) {

Handle<Message> message = try_catch.Message();

node::Stdio::DisableRawMode(STDIN_FILENO);

fprintf(stderr, "\n\n");

if (show_line && !message.IsEmpty()) {

// Print (filename):(line number): (message).

String::Utf8Value filename(message->GetScriptResourceName());

const char* filename_string = ToCString(filename);

int linenum = message->GetLineNumber();

fprintf(stderr, "%s:%i\n", filename_string, linenum);

// Print line of source code.

String::Utf8Value sourceline(message->GetSourceLine());

const char* sourceline_string = ToCString(sourceline);

// HACK HACK HACK

//

// FIXME