src/node.cc

   1 // Copyright 2009 Ryan Dahl <ry@tinyclouds.org>
   2 #include <node.h>
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <limits.h> /* PATH_MAX */
   8 #include <assert.h>
   9 #include <unistd.h>
  10 #include <errno.h>
  11 #include <dlfcn.h> /* dlopen(), dlsym() */
  12 #include <sys/types.h>
  13 #include <unistd.h> /* setuid, getuid */
  14
  15 #include <node_buffer.h>
  16 #include <node_io_watcher.h>
  17 #include <node_net2.h>
  18 #include <node_events.h>
  19 #include <node_dns.h>
  20 #include <node_net.h>
  21 #include <node_file.h>
  22 #include <node_idle_watcher.h>
  23 #include <node_http.h>
  24 #include <node_http_parser.h>
  25 #include <node_signal_handler.h>
  26 #include <node_stat.h>
  27 #include <node_timer.h>
  28 #include <node_child_process.h>
  29 #include <node_constants.h>
  30 #include <node_stdio.h>
  31 #include <node_natives.h>
  32 #include <node_version.h>
  33
  34 #include <v8-debug.h>
  35
  36 using namespace v8;
  37
  38 extern char **environ;
  39
  40 namespace node {
  41
  42 static Persistent<Object> process;
  43
  44 static Persistent<String> dev_symbol;
  45 static Persistent<String> ino_symbol;
  46 static Persistent<String> mode_symbol;
  47 static Persistent<String> nlink_symbol;
  48 static Persistent<String> uid_symbol;
  49 static Persistent<String> gid_symbol;
  50 static Persistent<String> rdev_symbol;
  51 static Persistent<String> size_symbol;
  52 static Persistent<String> blksize_symbol;
  53 static Persistent<String> blocks_symbol;
  54 static Persistent<String> atime_symbol;
  55 static Persistent<String> mtime_symbol;
  56 static Persistent<String> ctime_symbol;
  57
  58 static Persistent<String> rss_symbol;
  59 static Persistent<String> vsize_symbol;
  60 static Persistent<String> heap_total_symbol;
  61 static Persistent<String> heap_used_symbol;
  62
  63 static Persistent<String> listeners_symbol;
  64 static Persistent<String> uncaught_exception_symbol;
  65 static Persistent<String> emit_symbol;
  66
  67 static int option_end_index = 0;
  68 static bool use_debug_agent = false;
  69 static bool debug_wait_connect = false;
  70 static int debug_port=5858;
  71
  72
  73 static ev_async eio_want_poll_notifier;
  74 static ev_async eio_done_poll_notifier;
  75 static ev_idle  eio_poller;
  76
  77 static ev_timer  gc_timer;
  78 #define GC_INTERVAL 2.0
  79
  80
  81 // Node calls this every GC_INTERVAL seconds in order to try and call the
  82 // GC. This watcher is run with maximum priority, so ev_pending_count() == 0
  83 // is an effective measure of idleness.
  84 static void GCTimeout(EV_P_ ev_timer *watcher, int revents) {
  85   assert(watcher == &gc_timer);
  86   assert(revents == EV_TIMER);
  87   if (ev_pending_count(EV_DEFAULT_UC) == 0) V8::IdleNotification();
  88 }
  89
  90
  91 static void DoPoll(EV_P_ ev_idle *watcher, int revents) {
  92   assert(watcher == &eio_poller);
  93   assert(revents == EV_IDLE);
  94
  95   //printf("eio_poller\n");
  96
  97   if (eio_poll() != -1) {
  98     //printf("eio_poller stop\n");
  99     ev_idle_stop(EV_DEFAULT_UC_ watcher);
 100   }
 101 }
 102
 103
 104 // Called from the main thread.
 105 static void WantPollNotifier(EV_P_ ev_async *watcher, int revents) {
 106   assert(watcher == &eio_want_poll_notifier);
 107   assert(revents == EV_ASYNC);
 108
 109   //printf("want poll notifier\n");
 110
 111   if (eio_poll() == -1) {
 112     //printf("eio_poller start\n");
 113     ev_idle_start(EV_DEFAULT_UC_ &eio_poller);
 114   }
 115 }
 116
 117
 118 static void DonePollNotifier(EV_P_ ev_async *watcher, int revents) {
 119   assert(watcher == &eio_done_poll_notifier);
 120   assert(revents == EV_ASYNC);
 121
 122   //printf("done poll notifier\n");
 123
 124   if (eio_poll() != -1) {
 125     //printf("eio_poller stop\n");
 126     ev_idle_stop(EV_DEFAULT_UC_ &eio_poller);
 127   }
 128 }
 129
 130
 131 // EIOWantPoll() is called from the EIO thread pool each time an EIO
 132 // request (that is, one of the node.fs.* functions) has completed.
 133 static void EIOWantPoll(void) {
 134   // Signal the main thread that eio_poll need to be processed.
 135   ev_async_send(EV_DEFAULT_UC_ &eio_want_poll_notifier);
 136 }
 137
 138
 139 static void EIODonePoll(void) {
 140   // Signal the main thread that we should stop calling eio_poll().
 141   // from the idle watcher.
 142   ev_async_send(EV_DEFAULT_UC_ &eio_done_poll_notifier);
 143 }
 144
 145
 146 enum encoding ParseEncoding(Handle<Value> encoding_v, enum encoding _default) {
 147   HandleScope scope;
 148
 149   if (!encoding_v->IsString()) return _default;
 150
 151   String::Utf8Value encoding(encoding_v->ToString());
 152
 153   if (strcasecmp(*encoding, "utf8") == 0) {
 154     return UTF8;
 155   } else if (strcasecmp(*encoding, "utf-8") == 0) {
 156     return UTF8;
 157   } else if (strcasecmp(*encoding, "ascii") == 0) {
 158     return ASCII;
 159   } else if (strcasecmp(*encoding, "binary") == 0) {
 160     return BINARY;
 161   } else if (strcasecmp(*encoding, "raw") == 0) {
 162     fprintf(stderr, "'raw' (array of integers) has been removed. "
 163                     "Use 'binary'.\n");
 164     return BINARY;
 165   } else if (strcasecmp(*encoding, "raws") == 0) {
 166     fprintf(stderr, "'raws' encoding has been renamed to 'binary'. "
 167                     "Please update your code.\n");
 168     return BINARY;
 169   } else {
 170     return _default;
 171   }
 172 }
 173
 174 Local<Value> Encode(const void *buf, size_t len, enum encoding encoding) {
 175   HandleScope scope;
 176
 177   if (!len) return scope.Close(String::Empty());
 178
 179   if (encoding == BINARY) {
 180     const unsigned char *cbuf = static_cast<const unsigned char*>(buf);
 181     uint16_t * twobytebuf = new uint16_t[len];
 182     for (size_t i = 0; i < len; i++) {
 183       // XXX is the following line platform independent?
 184       twobytebuf[i] = cbuf[i];
 185     }
 186     Local<String> chunk = String::New(twobytebuf, len);
 187     delete [] twobytebuf; // TODO use ExternalTwoByteString?
 188     return scope.Close(chunk);
 189   }
 190
 191   // utf8 or ascii encoding
 192   Local<String> chunk = String::New((const char*)buf, len);
 193   return scope.Close(chunk);
 194 }
 195
 196 // Returns -1 if the handle was not valid for decoding
 197 ssize_t DecodeBytes(v8::Handle<v8::Value> val, enum encoding encoding) {
 198   HandleScope scope;
 199
 200   if (val->IsArray()) {
 201     fprintf(stderr, "'raw' encoding (array of integers) has been removed. "
 202                     "Use 'binary'.\n");
 203     assert(0);
 204     return -1;
 205   }
 206
 207   Local<String> str = val->ToString();
 208
 209   if (encoding == UTF8) return str->Utf8Length();
 210
 211   return str->Length();
 212 }
 213
 214 #ifndef MIN
 215 # define MIN(a, b) ((a) < (b) ? (a) : (b))
 216 #endif
 217
 218 // Returns number of bytes written.
 219 ssize_t DecodeWrite(char *buf, size_t buflen,
 220                     v8::Handle<v8::Value> val,
 221                     enum encoding encoding) {
 222   HandleScope scope;
 223
 224   // XXX
 225   // A lot of improvement can be made here. See:
 226   // http://code.google.com/p/v8/issues/detail?id=270
 227   // http://groups.google.com/group/v8-dev/browse_thread/thread/dba28a81d9215291/ece2b50a3b4022c
 228   // http://groups.google.com/group/v8-users/browse_thread/thread/1f83b0ba1f0a611
 229
 230   if (val->IsArray()) {
 231     fprintf(stderr, "'raw' encoding (array of integers) has been removed. "
 232                     "Use 'binary'.\n");
 233     assert(0);
 234     return -1;
 235   }
 236
 237   Local<String> str = val->ToString();
 238
 239   if (encoding == UTF8) {
 240     str->WriteUtf8(buf, buflen);
 241     return buflen;
 242   }
 243
 244   if (encoding == ASCII) {
 245     str->WriteAscii(buf, 0, buflen);
 246     return buflen;
 247   }
 248
 249   // THIS IS AWFUL!!! FIXME
 250
 251   assert(encoding == BINARY);
 252
 253   uint16_t * twobytebuf = new uint16_t[buflen];
 254
 255   str->Write(twobytebuf, 0, buflen);
 256
 257   for (size_t i = 0; i < buflen; i++) {
 258     unsigned char *b = reinterpret_cast<unsigned char*>(&twobytebuf[i]);
 259     assert(b[1] == 0);
 260     buf[i] = b[0];
 261   }
 262
 263   delete [] twobytebuf;
 264
 265   return buflen;
 266 }
 267
 268 static Persistent<FunctionTemplate> stats_constructor_template;
 269
 270 Local<Object> BuildStatsObject(struct stat * s) {
 271   HandleScope scope;
 272
 273   if (dev_symbol.IsEmpty()) {
 274     dev_symbol = NODE_PSYMBOL("dev");
 275     ino_symbol = NODE_PSYMBOL("ino");
 276     mode_symbol = NODE_PSYMBOL("mode");
 277     nlink_symbol = NODE_PSYMBOL("nlink");
 278     uid_symbol = NODE_PSYMBOL("uid");
 279     gid_symbol = NODE_PSYMBOL("gid");
 280     rdev_symbol = NODE_PSYMBOL("rdev");
 281     size_symbol = NODE_PSYMBOL("size");
 282     blksize_symbol = NODE_PSYMBOL("blksize");
 283     blocks_symbol = NODE_PSYMBOL("blocks");
 284     atime_symbol = NODE_PSYMBOL("atime");
 285     mtime_symbol = NODE_PSYMBOL("mtime");
 286     ctime_symbol = NODE_PSYMBOL("ctime");
 287   }
 288
 289   Local<Object> stats =
 290     stats_constructor_template->GetFunction()->NewInstance();
 291
 292   /* ID of device containing file */
 293   stats->Set(dev_symbol, Integer::New(s->st_dev));
 294
 295   /* inode number */
 296   stats->Set(ino_symbol, Integer::New(s->st_ino));
 297
 298   /* protection */
 299   stats->Set(mode_symbol, Integer::New(s->st_mode));
 300
 301   /* number of hard links */
 302   stats->Set(nlink_symbol, Integer::New(s->st_nlink));
 303
 304   /* user ID of owner */
 305   stats->Set(uid_symbol, Integer::New(s->st_uid));
 306
 307   /* group ID of owner */
 308   stats->Set(gid_symbol, Integer::New(s->st_gid));
 309
 310   /* device ID (if special file) */
 311   stats->Set(rdev_symbol, Integer::New(s->st_rdev));
 312
 313   /* total size, in bytes */
 314   stats->Set(size_symbol, Integer::New(s->st_size));
 315
 316   /* blocksize for filesystem I/O */
 317   stats->Set(blksize_symbol, Integer::New(s->st_blksize));
 318
 319   /* number of blocks allocated */
 320   stats->Set(blocks_symbol, Integer::New(s->st_blocks));
 321
 322   /* time of last access */
 323   stats->Set(atime_symbol, NODE_UNIXTIME_V8(s->st_atime));
 324
 325   /* time of last modification */
 326   stats->Set(mtime_symbol, NODE_UNIXTIME_V8(s->st_mtime));
 327
 328   /* time of last status change */
 329   stats->Set(ctime_symbol, NODE_UNIXTIME_V8(s->st_ctime));
 330
 331   return scope.Close(stats);
 332 }
 333
 334
 335 // Extracts a C str from a V8 Utf8Value.
 336 const char* ToCString(const v8::String::Utf8Value& value) {
 337   return *value ? *value : "<str conversion failed>";
 338 }
 339
 340 static void ReportException(TryCatch &try_catch, bool show_line = false) {
 341   Handle<Message> message = try_catch.Message();
 342   if (message.IsEmpty()) {
 343     fprintf(stderr, "Error: (no message)\n");
 344     fflush(stderr);
 345     return;
 346   }
 347
 348   Handle<Value> error = try_catch.Exception();
 349   Handle<String> stack;
 350
 351   if (error->IsObject()) {
 352     Handle<Object> obj = Handle<Object>::Cast(error);
 353     Handle<Value> raw_stack = obj->Get(String::New("stack"));
 354     if (raw_stack->IsString()) stack = Handle<String>::Cast(raw_stack);
 355   }
 356
 357   if (show_line) {
 358     // Print (filename):(line number): (message).
 359     String::Utf8Value filename(message->GetScriptResourceName());
 360     const char* filename_string = ToCString(filename);
 361     int linenum = message->GetLineNumber();
 362     fprintf(stderr, "%s:%i\n", filename_string, linenum);
 363     // Print line of source code.
 364     String::Utf8Value sourceline(message->GetSourceLine());
 365     const char* sourceline_string = ToCString(sourceline);
 366     fprintf(stderr, "%s\n", sourceline_string);
 367     // Print wavy underline (GetUnderline is deprecated).
 368     int start = message->GetStartColumn();
 369     for (int i = 0; i < start; i++) {
 370       fprintf(stderr, " ");
 371     }
 372     int end = message->GetEndColumn();
 373     for (int i = start; i < end; i++) {
 374       fprintf(stderr, "^");
 375     }
 376     fprintf(stderr, "\n");
 377   }
 378
 379   if (stack.IsEmpty()) {
 380     message->PrintCurrentStackTrace(stderr);
 381   } else {
 382     String::Utf8Value trace(stack);
 383     fprintf(stderr, "%s\n", *trace);
 384   }
 385   fflush(stderr);
 386 }
 387
 388 // Executes a str within the current v8 context.
 389 Local<Value> ExecuteString(Local<String> source, Local<Value> filename) {
 390   HandleScope scope;
 391   TryCatch try_catch;
 392
 393   Local<Script> script = Script::Compile(source, filename);
 394   if (script.IsEmpty()) {
 395     ReportException(try_catch);
 396     exit(1);
 397   }
 398
 399   Local<Value> result = script->Run();
 400   if (result.IsEmpty()) {
 401     ReportException(try_catch);
 402     exit(1);
 403   }
 404
 405   return scope.Close(result);
 406 }
 407
 408 static Handle<Value> ByteLength(const Arguments& args) {
 409   HandleScope scope;
 410
 411   if (args.Length() < 1 || !args[0]->IsString()) {
 412     return ThrowException(Exception::Error(String::New("Bad argument.")));
 413   }
 414
 415   Local<Integer> length = Integer::New(DecodeBytes(args[0], ParseEncoding(args[1], UTF8)));
 416
 417   return scope.Close(length);
 418 }
 419
 420 static Handle<Value> Loop(const Arguments& args) {
 421   HandleScope scope;
 422
 423   // TODO Probably don't need to start this each time.
 424   // Avoids failing on test/mjsunit/test-eio-race3.js though
 425   ev_idle_start(EV_DEFAULT_UC_ &eio_poller);
 426
 427   ev_loop(EV_DEFAULT_UC_ 0);
 428   return Undefined();
 429 }
 430
 431 static Handle<Value> Unloop(const Arguments& args) {
 432   HandleScope scope;
 433   int how = EVUNLOOP_ONE;
 434   if (args[0]->IsString()) {
 435     String::Utf8Value how_s(args[0]->ToString());
 436     if (0 == strcmp(*how_s, "all")) {
 437       how = EVUNLOOP_ALL;
 438     }
 439   }
 440   ev_unloop(EV_DEFAULT_ how);
 441   return Undefined();
 442 }
 443
 444 static Handle<Value> Chdir(const Arguments& args) {
 445   HandleScope scope;
 446
 447   if (args.Length() != 1 || !args[0]->IsString()) {
 448     return ThrowException(Exception::Error(String::New("Bad argument.")));
 449   }
 450
 451   String::Utf8Value path(args[0]->ToString());
 452
 453   int r = chdir(*path);
 454
 455   if (r != 0) {
 456     return ThrowException(Exception::Error(String::New(strerror(errno))));
 457   }
 458
 459   return Undefined();
 460 }
 461
 462 static Handle<Value> Cwd(const Arguments& args) {
 463   HandleScope scope;
 464
 465   char output[PATH_MAX];
 466   char *r = getcwd(output, PATH_MAX);
 467   if (r == NULL) {
 468     return ThrowException(Exception::Error(String::New(strerror(errno))));
 469   }
 470   Local<String> cwd = String::New(output);
 471
 472   return scope.Close(cwd);
 473 }
 474
 475 static Handle<Value> Umask(const Arguments& args){
 476   HandleScope scope;
 477
 478   if(args.Length() < 1 || !args[0]->IsInt32()) {
 479     return ThrowException(Exception::TypeError(
 480           String::New("argument must be an integer.")));
 481   }
 482   unsigned int mask = args[0]->Uint32Value();
 483   unsigned int old = umask((mode_t)mask);
 484
 485   return scope.Close(Uint32::New(old));
 486 }
 487
 488
 489 static Handle<Value> GetUid(const Arguments& args) {
 490   HandleScope scope;
 491   int uid = getuid();
 492   return scope.Close(Integer::New(uid));
 493 }
 494
 495 static Handle<Value> GetGid(const Arguments& args) {
 496   HandleScope scope;
 497   int gid = getgid();
 498   return scope.Close(Integer::New(gid));
 499 }
 500
 501
 502 static Handle<Value> SetGid(const Arguments& args) {
 503   HandleScope scope;
 504
 505   if (args.Length() < 1) {
 506     return ThrowException(Exception::Error(
 507           String::New("setgid requires 1 argument")));
 508   }
 509
 510   Local<Integer> given_gid = args[0]->ToInteger();
 511   int gid = given_gid->Int32Value();
 512   int result;
 513   if ((result == setgid(gid)) != 0) {
 514     return ThrowException(Exception::Error(String::New(strerror(errno))));
 515   }
 516   return Undefined();
 517 }
 518
 519 static Handle<Value> SetUid(const Arguments& args) {
 520   HandleScope scope;
 521
 522   if (args.Length() < 1) {
 523     return ThrowException(Exception::Error(
 524           String::New("setuid requires 1 argument")));
 525   }
 526
 527   Local<Integer> given_uid = args[0]->ToInteger();
 528   int uid = given_uid->Int32Value();
 529   int result;
 530   if ((result = setuid(uid)) != 0) {
 531     return ThrowException(Exception::Error(String::New(strerror(errno))));
 532   }
 533   return Undefined();
 534 }
 535
 536
 537 v8::Handle<v8::Value> Exit(const v8::Arguments& args) {
 538   HandleScope scope;
 539   fflush(stderr);
 540   Stdio::Flush();
 541   exit(args[0]->IntegerValue());
 542   return Undefined();
 543 }
 544
 545 #ifdef __sun
 546 #define HAVE_GETMEM 1
 547 #include <unistd.h> /* getpagesize() */
 548
 549 #if (!defined(_LP64)) && (_FILE_OFFSET_BITS - 0 == 64)
 550 #define PROCFS_FILE_OFFSET_BITS_HACK 1
 551 #undef _FILE_OFFSET_BITS
 552 #else
 553 #define PROCFS_FILE_OFFSET_BITS_HACK 0
 554 #endif
 555
 556 #include <procfs.h>
 557
 558 #if (PROCFS_FILE_OFFSET_BITS_HACK - 0 == 1)
 559 #define _FILE_OFFSET_BITS 64
 560 #endif
 561
 562 int getmem(size_t *rss, size_t *vsize) {
 563   pid_t pid = getpid();
 564
 565   size_t page_size = getpagesize();
 566   char pidpath[1024];
 567   sprintf(pidpath, "/proc/%d/psinfo", pid);
 568
 569   psinfo_t psinfo;
 570   FILE *f = fopen(pidpath, "r");
 571   if (!f) return -1;
 572
 573   if (fread(&psinfo, sizeof(psinfo_t), 1, f) != 1) {
 574     fclose (f);
 575     return -1;
 576   }
 577
 578   /* XXX correct? */
 579
 580   *vsize = (size_t) psinfo.pr_size * page_size;
 581   *rss = (size_t) psinfo.pr_rssize * 1024;
 582
 583   fclose (f);
 584
 585   return 0;
 586 }
 587 #endif
 588
 589
 590 #ifdef __FreeBSD__
 591 #define HAVE_GETMEM 1
 592 #include <kvm.h>
 593 #include <sys/param.h>
 594 #include <sys/sysctl.h>
 595 #include <sys/user.h>
 596 #include <fcntl.h>
 597 #include <unistd.h>
 598
 599 int getmem(size_t *rss, size_t *vsize) {
 600   kvm_t *kd = NULL;
 601   struct kinfo_proc *kinfo = NULL;
 602   pid_t pid;
 603   int nprocs;
 604
 605   pid = getpid();
 606
 607   kd = kvm_open(NULL, NULL, NULL, O_RDONLY, "kvm_open");
 608   if (kd == NULL) goto error;
 609
 610   kinfo = kvm_getprocs(kd, KERN_PROC_PID, pid, &nprocs);
 611   if (kinfo == NULL) goto error;
 612
 613   *rss = kinfo->ki_rssize * PAGE_SIZE;
 614   *vsize = kinfo->ki_size;
 615
 616   kvm_close(kd);
 617
 618   return 0;
 619
 620 error:
 621   if (kd) kvm_close(kd);
 622   return -1;
 623 }
 624 #endif  // __FreeBSD__
 625
 626
 627 #ifdef __APPLE__
 628 #define HAVE_GETMEM 1
 629 /* Researched by Tim Becker and Michael Knight
 630  * http://blog.kuriositaet.de/?p=257
 631  */
 632
 633 #include <mach/task.h>
 634 #include <mach/mach_init.h>
 635
 636 int getmem(size_t *rss, size_t *vsize) {
 637   struct task_basic_info t_info;
 638   mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
 639
 640   int r = task_info(mach_task_self(),
 641                     TASK_BASIC_INFO,
 642                     (task_info_t)&t_info,
 643                     &t_info_count);
 644
 645   if (r != KERN_SUCCESS) return -1;
 646
 647   *rss = t_info.resident_size;
 648   *vsize  = t_info.virtual_size;
 649
 650   return 0;
 651 }
 652 #endif  // __APPLE__
 653
 654 #ifdef __linux__
 655 # define HAVE_GETMEM 1
 656 # include <sys/param.h> /* for MAXPATHLEN */
 657
 658 int getmem(size_t *rss, size_t *vsize) {
 659   FILE *f = fopen("/proc/self/stat", "r");
 660   if (!f) return -1;
 661
 662   int itmp;
 663   char ctmp;
 664   char buffer[MAXPATHLEN];
 665   size_t page_size = getpagesize();
 666
 667   /* PID */
 668   if (fscanf(f, "%d ", &itmp) == 0) goto error;
 669   /* Exec file */
 670   if (fscanf (f, "%s ", &buffer[0]) == 0) goto error;
 671   /* State */
 672   if (fscanf (f, "%c ", &ctmp) == 0) goto error;
 673   /* Parent process */
 674   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 675   /* Process group */
 676   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 677   /* Session id */
 678   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 679   /* TTY */
 680   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 681   /* TTY owner process group */
 682   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 683   /* Flags */
 684   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 685   /* Minor faults (no memory page) */
 686   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 687   /* Minor faults, children */
 688   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 689   /* Major faults (memory page faults) */
 690   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 691   /* Major faults, children */
 692   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 693   /* utime */
 694   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 695   /* stime */
 696   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 697   /* utime, children */
 698   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 699   /* stime, children */
 700   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 701   /* jiffies remaining in current time slice */
 702   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 703   /* 'nice' value */
 704   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 705   /* jiffies until next timeout */
 706   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 707   /* jiffies until next SIGALRM */
 708   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 709   /* start time (jiffies since system boot) */
 710   if (fscanf (f, "%d ", &itmp) == 0) goto error;
 711
 712   /* Virtual memory size */
 713   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 714   *vsize = (size_t) itmp;
 715
 716   /* Resident set size */
 717   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 718   *rss = (size_t) itmp * page_size;
 719
 720   /* rlim */
 721   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 722   /* Start of text */
 723   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 724   /* End of text */
 725   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 726   /* Start of stack */
 727   if (fscanf (f, "%u ", &itmp) == 0) goto error;
 728
 729   fclose (f);
 730
 731   return 0;
 732
 733 error:
 734   fclose (f);
 735   return -1;
 736 }
 737 #endif  // __linux__
 738
 739 v8::Handle<v8::Value> MemoryUsage(const v8::Arguments& args) {
 740   HandleScope scope;
 741
 742 #ifndef HAVE_GETMEM
 743   return ThrowException(Exception::Error(String::New("Not support on your platform. (Talk to Ryan.)")));
 744 #else
 745   size_t rss, vsize;
 746
 747   int r = getmem(&rss, &vsize);
 748
 749   if (r != 0) {
 750     return ThrowException(Exception::Error(String::New(strerror(errno))));
 751   }
 752
 753   Local<Object> info = Object::New();
 754
 755   if (rss_symbol.IsEmpty()) {
 756     rss_symbol = NODE_PSYMBOL("rss");
 757     vsize_symbol = NODE_PSYMBOL("vsize");
 758     heap_total_symbol = NODE_PSYMBOL("heapTotal");
 759     heap_used_symbol = NODE_PSYMBOL("heapUsed");
 760   }
 761
 762   info->Set(rss_symbol, Integer::NewFromUnsigned(rss));
 763   info->Set(vsize_symbol, Integer::NewFromUnsigned(vsize));
 764
 765   // V8 memory usage
 766   HeapStatistics v8_heap_stats;
 767   V8::GetHeapStatistics(&v8_heap_stats);
 768   info->Set(heap_total_symbol,
 769             Integer::NewFromUnsigned(v8_heap_stats.total_heap_size()));
 770   info->Set(heap_used_symbol,
 771             Integer::NewFromUnsigned(v8_heap_stats.used_heap_size()));
 772
 773   return scope.Close(info);
 774 #endif
 775 }
 776
 777
 778 v8::Handle<v8::Value> Kill(const v8::Arguments& args) {
 779   HandleScope scope;
 780
 781   if (args.Length() < 1 || !args[0]->IsNumber()) {
 782     return ThrowException(Exception::Error(String::New("Bad argument.")));
 783   }
 784
 785   pid_t pid = args[0]->IntegerValue();
 786
 787   int sig = SIGTERM;
 788
 789   if (args.Length() >= 2) {
 790     if (args[1]->IsNumber()) {
 791       sig = args[1]->Int32Value();
 792     } else if (args[1]->IsString()) {
 793       Local<String> signame = args[1]->ToString();
 794
 795       Local<Value> sig_v = process->Get(signame);
 796       if (!sig_v->IsNumber()) {
 797         return ThrowException(Exception::Error(String::New("Unknown signal")));
 798       }
 799       sig = sig_v->Int32Value();
 800     }
 801   }
 802
 803   int r = kill(pid, sig);
 804
 805   if (r != 0) {
 806     return ThrowException(Exception::Error(String::New(strerror(errno))));
 807   }
 808
 809   return Undefined();
 810 }
 811
 812 typedef void (*extInit)(Handle<Object> exports);
 813
 814 // DLOpen is node.dlopen(). Used to load 'module.node' dynamically shared
 815 // objects.
 816 Handle<Value> DLOpen(const v8::Arguments& args) {
 817   HandleScope scope;
 818
 819   if (args.Length() < 2) return Undefined();
 820
 821   String::Utf8Value filename(args[0]->ToString()); // Cast
 822   Local<Object> target = args[1]->ToObject(); // Cast
 823
 824   // Actually call dlopen().
 825   // FIXME: This is a blocking function and should be called asynchronously!
 826   // This function should be moved to file.cc and use libeio to make this
 827   // system call.
 828   void *handle = dlopen(*filename, RTLD_LAZY);
 829
 830   // Handle errors.
 831   if (handle == NULL) {
 832     Local<Value> exception = Exception::Error(String::New(dlerror()));
 833     return ThrowException(exception);
 834   }
 835
 836   // Get the init() function from the dynamically shared object.
 837   void *init_handle = dlsym(handle, "init");
 838   // Error out if not found.
 839   if (init_handle == NULL) {
 840     Local<Value> exception =
 841       Exception::Error(String::New("No 'init' symbol found in module."));
 842     return ThrowException(exception);
 843   }
 844   extInit init = (extInit)(init_handle); // Cast
 845
 846   // Execute the C++ module
 847   init(target);
 848
 849   return Undefined();
 850 }
 851
 852 Handle<Value> Compile(const Arguments& args) {
 853   HandleScope scope;
 854
 855   if (args.Length() < 2) {
 856     return ThrowException(Exception::TypeError(
 857           String::New("needs two arguments.")));
 858   }
 859
 860   Local<String> source = args[0]->ToString();
 861   Local<String> filename = args[1]->ToString();
 862
 863   TryCatch try_catch;
 864
 865   Local<Script> script = Script::Compile(source, filename);
 866   if (try_catch.HasCaught()) {
 867     // Hack because I can't get a proper stacktrace on SyntaxError
 868     ReportException(try_catch, true);
 869     exit(1);
 870   }
 871
 872   Local<Value> result = script->Run();
 873   if (try_catch.HasCaught()) return try_catch.ReThrow();
 874
 875   return scope.Close(result);
 876 }
 877
 878 static void OnFatalError(const char* location, const char* message) {
 879   if (location) {
 880     fprintf(stderr, "FATAL ERROR: %s %s\n", location, message);
 881   } else {
 882     fprintf(stderr, "FATAL ERROR: %s\n", message);
 883   }
 884   exit(1);
 885 }
 886
 887 static int uncaught_exception_counter = 0;
 888
 889 void FatalException(TryCatch &try_catch) {
 890   HandleScope scope;
 891
 892   // Check if uncaught_exception_counter indicates a recursion
 893   if (uncaught_exception_counter > 0) {
 894     ReportException(try_catch);
 895     exit(1);
 896   }
 897
 898   if (listeners_symbol.IsEmpty()) {
 899     listeners_symbol = NODE_PSYMBOL("listeners");
 900     uncaught_exception_symbol = NODE_PSYMBOL("uncaughtException");
 901     emit_symbol = NODE_PSYMBOL("emit");
 902   }
 903
 904   Local<Value> listeners_v = process->Get(listeners_symbol);
 905   assert(listeners_v->IsFunction());
 906
 907   Local<Function> listeners = Local<Function>::Cast(listeners_v);
 908
 909   Local<String> uncaught_exception_symbol_l = Local<String>::New(uncaught_exception_symbol);
 910   Local<Value> argv[1] = { uncaught_exception_symbol_l  };
 911   Local<Value> ret = listeners->Call(process, 1, argv);
 912
 913   assert(ret->IsArray());
 914
 915   Local<Array> listener_array = Local<Array>::Cast(ret);
 916
 917   uint32_t length = listener_array->Length();
 918   // Report and exit if process has no "uncaughtException" listener
 919   if (length == 0) {
 920     ReportException(try_catch);
 921     exit(1);
 922   }
 923
 924   // Otherwise fire the process "uncaughtException" event
 925   Local<Value> emit_v = process->Get(emit_symbol);
 926   assert(emit_v->IsFunction());
 927
 928   Local<Function> emit = Local<Function>::Cast(emit_v);
 929
 930   Local<Value> error = try_catch.Exception();
 931   Local<Value> event_argv[2] = { uncaught_exception_symbol_l, error };
 932
 933   uncaught_exception_counter++;
 934   emit->Call(process, 2, event_argv);
 935   // Decrement so we know if the next exception is a recursion or not
 936   uncaught_exception_counter--;
 937 }
 938
 939
 940 static ev_async debug_watcher;
 941 volatile static bool debugger_msg_pending = false;
 942
 943 static void DebugMessageCallback(EV_P_ ev_async *watcher, int revents) {
 944   HandleScope scope;
 945   assert(watcher == &debug_watcher);
 946   assert(revents == EV_ASYNC);
 947   Debug::ProcessDebugMessages();
 948 }
 949
 950 static void DebugMessageDispatch(void) {
 951   // This function is called from V8's debug thread when a debug TCP client
 952   // has sent a message.
 953
 954   // Send a signal to our main thread saying that it should enter V8 to
 955   // handle the message.
 956   debugger_msg_pending = true;
 957   ev_async_send(EV_DEFAULT_UC_ &debug_watcher);
 958 }
 959
 960 static Handle<Value> CheckBreak(const Arguments& args) {
 961   HandleScope scope;
 962
 963   // TODO FIXME This function is a hack to wait until V8 is ready to accept
 964   // commands. There seems to be a bug in EnableAgent( _ , _ , true) which
 965   // makes it unusable here. Ideally we'd be able to bind EnableAgent and
 966   // get it to halt until Eclipse connects.
 967
 968   if (!debug_wait_connect)
 969     return Undefined();
 970
 971   printf("Waiting for remote debugger connection...\n");
 972
 973   const int halfSecond = 50;
 974   const int tenMs=10000;
 975   debugger_msg_pending = false;
 976   for (;;) {
 977     if (debugger_msg_pending) {
 978       Debug::DebugBreak();
 979       Debug::ProcessDebugMessages();
 980       debugger_msg_pending = false;
 981
 982       // wait for 500 msec of silence from remote debugger
 983       int cnt = halfSecond;
 984         while (cnt --) {
 985         debugger_msg_pending = false;
 986         usleep(tenMs);
 987         if (debugger_msg_pending) {
 988           debugger_msg_pending = false;
 989           cnt = halfSecond;
 990         }
 991       }
 992       break;
 993     }
 994     usleep(tenMs);
 995   }
 996   return Undefined();
 997 }
 998
 999
1000 static void Load(int argc, char *argv[]) {
1001   HandleScope scope;
1002
1003   Local<FunctionTemplate> process_template = FunctionTemplate::New();
1004   node::EventEmitter::Initialize(process_template);
1005
1006   process = Persistent<Object>::New(process_template->GetFunction()->NewInstance());
1007
1008   // Add a reference to the global object
1009   Local<Object> global = Context::GetCurrent()->Global();
1010   process->Set(String::NewSymbol("global"), global);
1011
1012   // process.version
1013   process->Set(String::NewSymbol("version"), String::New(NODE_VERSION));
1014   // process.installPrefix
1015   process->Set(String::NewSymbol("installPrefix"), String::New(NODE_PREFIX));
1016
1017   // process.platform
1018 #define xstr(s) str(s)
1019 #define str(s) #s
1020   process->Set(String::NewSymbol("platform"), String::New(xstr(PLATFORM)));
1021
1022   // process.argv
1023   int i, j;
1024   Local<Array> arguments = Array::New(argc - option_end_index + 1);
1025   arguments->Set(Integer::New(0), String::New(argv[0]));
1026   for (j = 1, i = option_end_index + 1; i < argc; j++, i++) {
1027     Local<String> arg = String::New(argv[i]);
1028     arguments->Set(Integer::New(j), arg);
1029   }
1030   // assign it
1031   process->Set(String::NewSymbol("ARGV"), arguments);
1032   process->Set(String::NewSymbol("argv"), arguments);
1033
1034   // create process.env
1035   Local<Object> env = Object::New();
1036   for (i = 0; environ[i]; i++) {
1037     // skip entries without a '=' character
1038     for (j = 0; environ[i][j] && environ[i][j] != '='; j++) { ; }
1039     // create the v8 objects
1040     Local<String> field = String::New(environ[i], j);
1041     Local<String> value = Local<String>();
1042     if (environ[i][j] == '=') {
1043       value = String::New(environ[i]+j+1);
1044     }
1045     // assign them
1046     env->Set(field, value);
1047   }
1048   // assign process.ENV
1049   process->Set(String::NewSymbol("ENV"), env);
1050   process->Set(String::NewSymbol("env"), env);
1051
1052   process->Set(String::NewSymbol("pid"), Integer::New(getpid()));
1053
1054   // define various internal methods
1055   NODE_SET_METHOD(process, "loop", Loop);
1056   NODE_SET_METHOD(process, "unloop", Unloop);
1057   NODE_SET_METHOD(process, "compile", Compile);
1058   NODE_SET_METHOD(process, "_byteLength", ByteLength);
1059   NODE_SET_METHOD(process, "reallyExit", Exit);
1060   NODE_SET_METHOD(process, "chdir", Chdir);
1061   NODE_SET_METHOD(process, "cwd", Cwd);
1062   NODE_SET_METHOD(process, "getuid", GetUid);
1063   NODE_SET_METHOD(process, "setuid", SetUid);
1064
1065   NODE_SET_METHOD(process, "setgid", SetGid);
1066   NODE_SET_METHOD(process, "getgid", GetGid);
1067
1068   NODE_SET_METHOD(process, "umask", Umask);
1069   NODE_SET_METHOD(process, "dlopen", DLOpen);
1070   NODE_SET_METHOD(process, "kill", Kill);
1071   NODE_SET_METHOD(process, "memoryUsage", MemoryUsage);
1072   NODE_SET_METHOD(process, "checkBreak", CheckBreak);
1073
1074   // Assign the EventEmitter. It was created in main().
1075   process->Set(String::NewSymbol("EventEmitter"),
1076                EventEmitter::constructor_template->GetFunction());
1077
1078   // Initialize the stats object
1079   Local<FunctionTemplate> stat_templ = FunctionTemplate::New();
1080   stats_constructor_template = Persistent<FunctionTemplate>::New(stat_templ);
1081   process->Set(String::NewSymbol("Stats"),
1082       stats_constructor_template->GetFunction());
1083
1084
1085   // Initialize the C++ modules..................filename of module
1086   Buffer::Initialize(process);                 // buffer.cc
1087   IOWatcher::Initialize(process);              // io_watcher.cc
1088   IdleWatcher::Initialize(process);            // idle_watcher.cc
1089   Timer::Initialize(process);                  // timer.cc
1090   Stat::Initialize(process);                   // stat.cc
1091   SignalHandler::Initialize(process);          // signal_handler.cc
1092
1093   InitNet2(process);                           // net2.cc
1094   InitHttpParser(process);                     // http_parser.cc
1095
1096   Stdio::Initialize(process);                  // stdio.cc
1097   ChildProcess::Initialize(process);           // child_process.cc
1098   DefineConstants(process);                    // constants.cc
1099   // Create node.dns
1100   Local<Object> dns = Object::New();
1101   process->Set(String::NewSymbol("dns"), dns);
1102   DNS::Initialize(dns);                         // dns.cc
1103   Local<Object> fs = Object::New();
1104   process->Set(String::NewSymbol("fs"), fs);
1105   File::Initialize(fs);                         // file.cc
1106   // Create node.tcp. Note this separate from lib/tcp.js which is the public
1107   // frontend.
1108   Local<Object> tcp = Object::New();
1109   process->Set(String::New("tcp"), tcp);
1110   Server::Initialize(tcp);                      // tcp.cc
1111   Connection::Initialize(tcp);                  // tcp.cc
1112   // Create node.http.  Note this separate from lib/http.js which is the
1113   // public frontend.
1114   Local<Object> http = Object::New();
1115   process->Set(String::New("http"), http);
1116   HTTPServer::Initialize(http);                 // http.cc
1117   HTTPConnection::Initialize(http);             // http.cc
1118
1119
1120
1121   // Compile, execute the src/node.js file. (Which was included as static C
1122   // string in node_natives.h. 'natve_node' is the string containing that
1123   // source code.)
1124
1125   // The node.js file returns a function 'f'
1126
1127 #ifndef NDEBUG
1128   TryCatch try_catch;
1129 #endif
1130
1131   Local<Value> f_value = ExecuteString(String::New(native_node),
1132                                        String::New("node.js"));
1133 #ifndef NDEBUG
1134   if (try_catch.HasCaught())  {
1135     ReportException(try_catch);
1136     exit(10);
1137   }
1138 #endif
1139   assert(f_value->IsFunction());
1140   Local<Function> f = Local<Function>::Cast(f_value);
1141
1142   // Now we call 'f' with the 'process' variable that we've built up with
1143   // all our bindings. Inside node.js we'll take care of assigning things to
1144   // their places.
1145
1146   // We start the process this way in order to be more modular. Developers
1147   // who do not like how 'src/node.js' setups the module system but do like
1148   // Node's I/O bindings may want to replace 'f' with their own function.
1149
1150   Local<Value> args[1] = { Local<Value>::New(process) };
1151
1152   f->Call(global, 1, args);
1153
1154 #ifndef NDEBUG
1155   if (try_catch.HasCaught())  {
1156     ReportException(try_catch);
1157     exit(11);
1158   }
1159 #endif
1160 }
1161
1162 static void PrintHelp();
1163
1164 static void ParseDebugOpt(const char* arg) {
1165   const char *p = 0;
1166
1167   use_debug_agent = true;
1168   if (!strcmp (arg, "--debug-brk")) {
1169     debug_wait_connect = true;
1170     return;
1171   } else if (!strcmp(arg, "--debug")) {
1172     return;
1173   } else if (strstr(arg, "--debug-brk=") == arg) {
1174     debug_wait_connect = true;
1175     p = 1 + strchr(arg, '=');
1176     debug_port = atoi(p);
1177   } else if (strstr(arg, "--debug=") == arg) {
1178     p = 1 + strchr(arg, '=');
1179     debug_port = atoi(p);
1180   }
1181   if (p && debug_port > 1024 && debug_port <  65536)
1182       return;
1183
1184   fprintf(stderr, "Bad debug option.\n");
1185   if (p) fprintf(stderr, "Debug port must be in range 1025 to 65535.\n");
1186
1187   PrintHelp();
1188   exit(1);
1189 }
1190
1191 static void PrintHelp() {
1192   printf("Usage: node [options] script.js [arguments] \n"
1193          "  -v, --version      print node's version\n"
1194          "  --debug[=port]     enable remote debugging via given TCP port\n"
1195          "                     without stopping the execution\n"
1196          "  --debug-brk[=port] as above, but break in script.js and\n"
1197          "                     wait for remote debugger to connect\n"
1198          "  --cflags           print pre-processor and compiler flags\n"
1199          "  --v8-options       print v8 command line options\n\n"
1200          "Documentation can be found at http://nodejs.org/api.html"
1201          " or with 'man node'\n");
1202 }
1203
1204 // Parse node command line arguments.
1205 static void ParseArgs(int *argc, char **argv) {
1206   // TODO use parse opts
1207   for (int i = 1; i < *argc; i++) {
1208     const char *arg = argv[i];
1209     if (strstr(arg, "--debug") == arg) {
1210       ParseDebugOpt(arg);
1211       argv[i] = const_cast<char*>("");
1212       option_end_index = i;
1213     } else if (strcmp(arg, "--version") == 0 || strcmp(arg, "-v") == 0) {
1214       printf("%s\n", NODE_VERSION);
1215       exit(0);
1216     } else if (strcmp(arg, "--cflags") == 0) {
1217       printf("%s\n", NODE_CFLAGS);
1218       exit(0);
1219     } else if (strcmp(arg, "--help") == 0 || strcmp(arg, "-h") == 0) {
1220       PrintHelp();
1221       exit(0);
1222     } else if (strcmp(arg, "--v8-options") == 0) {
1223       argv[i] = const_cast<char*>("--help");
1224       option_end_index = i+1;
1225     } else if (argv[i][0] != '-') {
1226       option_end_index = i-1;
1227       break;
1228     }
1229   }
1230 }
1231
1232 }  // namespace node
1233
1234
1235 int main(int argc, char *argv[]) {
1236   // Parse a few arguments which are specific to Node.
1237   node::ParseArgs(&argc, argv);
1238   // Parse the rest of the args (up to the 'option_end_index' (where '--' was
1239   // in the command line))
1240   V8::SetFlagsFromCommandLine(&node::option_end_index, argv, false);
1241
1242   // Error out if we don't have a script argument.
1243   if (argc < 2) {
1244     fprintf(stderr, "No script was specified.\n");
1245     node::PrintHelp();
1246     return 1;
1247   }
1248
1249   // Ignore the SIGPIPE
1250   evcom_ignore_sigpipe();
1251
1252   // Initialize the default ev loop.
1253 #ifdef __sun
1254   // TODO(Ryan) I'm experiencing abnormally high load using Solaris's
1255   // EVBACKEND_PORT. Temporarally forcing select() until I debug.
1256   ev_default_loop(EVBACKEND_SELECT);
1257 #else
1258   ev_default_loop(EVFLAG_AUTO);
1259 #endif
1260
1261
1262   ev_timer_init(&node::gc_timer, node::GCTimeout, GC_INTERVAL, GC_INTERVAL);
1263   // Set the gc_timer to max priority so that it runs before all other
1264   // watchers. In this way it can check if the 'tick' has other pending
1265   // watchers by using ev_pending_count() - if it ran with lower priority
1266   // then the other watchers might run before it - not giving us good idea
1267   // of loop idleness.
1268   ev_set_priority(&node::gc_timer, EV_MAXPRI);
1269   ev_timer_start(EV_DEFAULT_UC_ &node::gc_timer);
1270   ev_unref(EV_DEFAULT_UC);
1271
1272
1273   // Setup the EIO thread pool
1274   { // It requires 3, yes 3, watchers.
1275     ev_idle_init(&node::eio_poller, node::DoPoll);
1276
1277     ev_async_init(&node::eio_want_poll_notifier, node::WantPollNotifier);
1278     ev_async_start(EV_DEFAULT_UC_ &node::eio_want_poll_notifier);
1279     ev_unref(EV_DEFAULT_UC);
1280
1281     ev_async_init(&node::eio_done_poll_notifier, node::DonePollNotifier);
1282     ev_async_start(EV_DEFAULT_UC_ &node::eio_done_poll_notifier);
1283     ev_unref(EV_DEFAULT_UC);
1284
1285     eio_init(node::EIOWantPoll, node::EIODonePoll);
1286     // Don't handle more than 10 reqs on each eio_poll(). This is to avoid
1287     // race conditions. See test/mjsunit/test-eio-race.js
1288     eio_set_max_poll_reqs(10);
1289   }
1290
1291   V8::Initialize();
1292   HandleScope handle_scope;
1293
1294   V8::SetFatalErrorHandler(node::OnFatalError);
1295
1296   // If the --debug flag was specified then initialize the debug thread.
1297   if (node::use_debug_agent) {
1298     // Initialize the async watcher for receiving messages from the debug
1299     // thread and marshal it into the main thread. DebugMessageCallback()
1300     // is called from the main thread to execute a random bit of javascript
1301     // - which will give V8 control so it can handle whatever new message
1302     // had been received on the debug thread.
1303     ev_async_init(&node::debug_watcher, node::DebugMessageCallback);
1304     ev_set_priority(&node::debug_watcher, EV_MAXPRI);
1305     // Set the callback DebugMessageDispatch which is called from the debug
1306     // thread.
1307     Debug::SetDebugMessageDispatchHandler(node::DebugMessageDispatch);
1308     // Start the async watcher.
1309     ev_async_start(EV_DEFAULT_UC_ &node::debug_watcher);
1310     // unref it so that we exit the event loop despite it being active.
1311     ev_unref(EV_DEFAULT_UC);
1312
1313     // Start the debug thread and it's associated TCP server on port 5858.
1314     bool r = Debug::EnableAgent("node " NODE_VERSION, node::debug_port);
1315
1316     // Crappy check that everything went well. FIXME
1317     assert(r);
1318     // Print out some information.
1319     printf("debugger listening on port %d\n", node::debug_port);
1320   }
1321
1322   // Create the one and only Context.
1323   Persistent<Context> context = Context::New();
1324   Context::Scope context_scope(context);
1325
1326   // Create all the objects, load modules, do everything.
1327   // so your next reading stop should be node::Load()!
1328   node::Load(argc, argv);
1329
1330   node::Stdio::Flush();
1331
1332 #ifndef NDEBUG
1333   // Clean up.
1334   context.Dispose();
1335   V8::Dispose();
1336 #endif  // NDEBUG
1337   return 0;
1338 }
1339