src/node.cc

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