macgyver 0.0.8

data/assets/MacGap.app/Contents/Resources/dns.js

@@ -0,0 +1,274 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// 'Software'), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var net = require('net');
+var util = require('util');
+
+var cares = process.binding('cares_wrap');
+var uv = process.binding('uv');
+
+var isIp = net.isIP;
+
+
+function errnoException(err, syscall, hostname) {
+  // FIXME(bnoordhuis) Remove this backwards compatibility shite and pass
+  // the true error to the user. ENOTFOUND is not even a proper POSIX error!
+  if (err === uv.UV_EAI_MEMORY ||
+      err === uv.UV_EAI_NODATA ||
+      err === uv.UV_EAI_NONAME) {
+    err = 'ENOTFOUND';
+  }
+  var ex = null;
+  if (typeof err === 'string') {  // c-ares error code.
+    ex = new Error(syscall + ' ' + err);
+    ex.code = err;
+    ex.errno = err;
+    ex.syscall = syscall;
+  } else {
+    ex = util._errnoException(err, syscall);
+  }
+  if (hostname) {
+    ex.hostname = hostname;
+  }
+  return ex;
+}
+
+
+// c-ares invokes a callback either synchronously or asynchronously,
+// but the dns API should always invoke a callback asynchronously.
+//
+// This function makes sure that the callback is invoked asynchronously.
+// It returns a function that invokes the callback within nextTick().
+//
+// To avoid invoking unnecessary nextTick(), `immediately` property of
+// returned function should be set to true after c-ares returned.
+//
+// Usage:
+//
+// function someAPI(callback) {
+//   callback = makeAsync(callback);
+//   channel.someAPI(..., callback);
+//   callback.immediately = true;
+// }
+function makeAsync(callback) {
+  if (!util.isFunction(callback)) {
+    return callback;
+  }
+  return function asyncCallback() {
+    if (asyncCallback.immediately) {
+      // The API already returned, we can invoke the callback immediately.
+      callback.apply(null, arguments);
+    } else {
+      var args = arguments;
+      process.nextTick(function() {
+        callback.apply(null, args);
+      });
+    }
+  };
+}
+
+
+function onlookup(err, addresses) {
+  if (err) {
+    return this.callback(errnoException(err, 'getaddrinfo', this.hostname));
+  }
+  if (this.family) {
+    this.callback(null, addresses[0], this.family);
+  } else {
+    this.callback(null, addresses[0], addresses[0].indexOf(':') >= 0 ? 6 : 4);
+  }
+}
+
+
+// Easy DNS A/AAAA look up
+// lookup(hostname, [family,] callback)
+exports.lookup = function(hostname, family, callback) {
+  // parse arguments
+  if (arguments.length === 2) {
+    callback = family;
+    family = 0;
+  } else if (!family) {
+    family = 0;
+  } else {
+    family = +family;
+    if (family !== 4 && family !== 6) {
+      throw new Error('invalid argument: `family` must be 4 or 6');
+    }
+  }
+  callback = makeAsync(callback);
+
+  if (!hostname) {
+    callback(null, null, family === 6 ? 6 : 4);
+    return {};
+  }
+
+  var matchedFamily = net.isIP(hostname);
+  if (matchedFamily) {
+    callback(null, hostname, matchedFamily);
+    return {};
+  }
+
+  var req = {
+    callback: callback,
+    family: family,
+    hostname: hostname,
+    oncomplete: onlookup
+  };
+  var err = cares.getaddrinfo(req, hostname, family);
+  if (err) throw errnoException(err, 'getaddrinfo', hostname);
+
+  callback.immediately = true;
+  return req;
+};
+
+
+function onresolve(err, result) {
+  if (err)
+    this.callback(errnoException(err, this.bindingName, this.hostname));
+  else
+    this.callback(null, result);
+}
+
+
+function resolver(bindingName) {
+  var binding = cares[bindingName];
+
+  return function query(name, callback) {
+    callback = makeAsync(callback);
+    var req = {
+      bindingName: bindingName,
+      callback: callback,
+      hostname: name,
+      oncomplete: onresolve
+    };
+    var err = binding(req, name);
+    if (err) throw errnoException(err, bindingName);
+    callback.immediately = true;
+    return req;
+  }
+}
+
+
+var resolveMap = {};
+exports.resolve4 = resolveMap.A = resolver('queryA');
+exports.resolve6 = resolveMap.AAAA = resolver('queryAaaa');
+exports.resolveCname = resolveMap.CNAME = resolver('queryCname');
+exports.resolveMx = resolveMap.MX = resolver('queryMx');
+exports.resolveNs = resolveMap.NS = resolver('queryNs');
+exports.resolveTxt = resolveMap.TXT = resolver('queryTxt');
+exports.resolveSrv = resolveMap.SRV = resolver('querySrv');
+exports.resolveNaptr = resolveMap.NAPTR = resolver('queryNaptr');
+exports.resolveSoa = resolveMap.SOA = resolver('querySoa');
+exports.reverse = resolveMap.PTR = resolver('getHostByAddr');
+
+
+exports.resolve = function(hostname, type_, callback_) {
+  var resolver, callback;
+  if (util.isString(type_)) {
+    resolver = resolveMap[type_];
+    callback = callback_;
+  } else {
+    resolver = exports.resolve4;
+    callback = type_;
+  }
+
+  if (util.isFunction(resolver)) {
+    return resolver(hostname, callback);
+  } else {
+    throw new Error('Unknown type "' + type_ + '"');
+  }
+};
+
+
+exports.getServers = function() {
+  return cares.getServers();
+};
+
+
+exports.setServers = function(servers) {
+  // cache the original servers because in the event of an error setting the
+  // servers cares won't have any servers available for resolution
+  var orig = cares.getServers();
+
+  var newSet = [];
+
+  servers.forEach(function(serv) {
+    var ver = isIp(serv);
+
+    if (ver)
+      return newSet.push([ver, serv]);
+
+    var match = serv.match(/\[(.*)\](:\d+)?/);
+
+    // we have an IPv6 in brackets
+    if (match) {
+      ver = isIp(match[1]);
+      if (ver)
+        return newSet.push([ver, match[1]]);
+    }
+
+    var s = serv.split(/:\d+$/)[0];
+    ver = isIp(s);
+
+    if (ver)
+      return newSet.push([ver, s]);
+
+    throw new Error('IP address is not properly formatted: ' + serv);
+  });
+
+  var r = cares.setServers(newSet);
+
+  if (r) {
+    // reset the servers to the old servers, because ares probably unset them
+    cares.setServers(orig.join(','));
+
+    var err = cares.strerror(r);
+    throw new Error('c-ares failed to set servers: "' + err +
+                    '" [' + servers + ']');
+  }
+};
+
+
+// ERROR CODES
+exports.NODATA = 'ENODATA';
+exports.FORMERR = 'EFORMERR';
+exports.SERVFAIL = 'ESERVFAIL';
+exports.NOTFOUND = 'ENOTFOUND';
+exports.NOTIMP = 'ENOTIMP';
+exports.REFUSED = 'EREFUSED';
+exports.BADQUERY = 'EBADQUERY';
+exports.ADNAME = 'EADNAME';
+exports.BADFAMILY = 'EBADFAMILY';
+exports.BADRESP = 'EBADRESP';
+exports.CONNREFUSED = 'ECONNREFUSED';
+exports.TIMEOUT = 'ETIMEOUT';
+exports.EOF = 'EOF';
+exports.FILE = 'EFILE';
+exports.NOMEM = 'ENOMEM';
+exports.DESTRUCTION = 'EDESTRUCTION';
+exports.BADSTR = 'EBADSTR';
+exports.BADFLAGS = 'EBADFLAGS';
+exports.NONAME = 'ENONAME';
+exports.BADHINTS = 'EBADHINTS';
+exports.NOTINITIALIZED = 'ENOTINITIALIZED';
+exports.LOADIPHLPAPI = 'ELOADIPHLPAPI';
+exports.ADDRGETNETWORKPARAMS = 'EADDRGETNETWORKPARAMS';
+exports.CANCELLED = 'ECANCELLED';

data/assets/MacGap.app/Contents/Resources/domain.js

@@ -0,0 +1,292 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var util = require('util');
+var EventEmitter = require('events');
+var inherits = util.inherits;
+
+// communicate with events module, but don't require that
+// module to have to load this one, since this module has
+// a few side effects.
+EventEmitter.usingDomains = true;
+
+// overwrite process.domain with a getter/setter that will allow for more
+// effective optimizations
+var _domain = [null];
+Object.defineProperty(process, 'domain', {
+  enumerable: true,
+  get: function() {
+    return _domain[0];
+  },
+  set: function(arg) {
+    return _domain[0] = arg;
+  }
+});
+
+// objects with external array data are excellent ways to communicate state
+// between js and c++ w/o much overhead
+var _domain_flag = {};
+
+// let the process know we're using domains
+process._setupDomainUse(_domain, _domain_flag);
+
+exports.Domain = Domain;
+
+exports.create = exports.createDomain = function() {
+  return new Domain();
+};
+
+// it's possible to enter one domain while already inside
+// another one.  the stack is each entered domain.
+var stack = [];
+exports._stack = stack;
+// the active domain is always the one that we're currently in.
+exports.active = null;
+
+
+inherits(Domain, EventEmitter);
+
+function Domain() {
+  EventEmitter.call(this);
+
+  this.members = [];
+}
+
+Domain.prototype.members = undefined;
+Domain.prototype._disposed = undefined;
+
+
+// Called by process._fatalException in case an error was thrown.
+Domain.prototype._errorHandler = function errorHandler(er) {
+  var caught = false;
+  // ignore errors on disposed domains.
+  //
+  // XXX This is a bit stupid.  We should probably get rid of
+  // domain.dispose() altogether.  It's almost always a terrible
+  // idea.  --isaacs
+  if (this._disposed)
+    return true;
+
+  er.domain = this;
+  er.domainThrown = true;
+  // wrap this in a try/catch so we don't get infinite throwing
+  try {
+    // One of three things will happen here.
+    //
+    // 1. There is a handler, caught = true
+    // 2. There is no handler, caught = false
+    // 3. It throws, caught = false
+    //
+    // If caught is false after this, then there's no need to exit()
+    // the domain, because we're going to crash the process anyway.
+    caught = this.emit('error', er);
+
+    // Exit all domains on the stack.  Uncaught exceptions end the
+    // current tick and no domains should be left on the stack
+    // between ticks.
+    stack.length = 0;
+    exports.active = process.domain = null;
+  } catch (er2) {
+    // The domain error handler threw!  oh no!
+    // See if another domain can catch THIS error,
+    // or else crash on the original one.
+    // If the user already exited it, then don't double-exit.
+    if (this === exports.active) {
+      stack.pop();
+    }
+    if (stack.length) {
+      exports.active = process.domain = stack[stack.length - 1];
+      caught = process._fatalException(er2);
+    } else {
+      caught = false;
+    }
+    return caught;
+  }
+  return caught;
+};
+
+
+Domain.prototype.enter = function() {
+  if (this._disposed) return;
+
+  // note that this might be a no-op, but we still need
+  // to push it onto the stack so that we can pop it later.
+  exports.active = process.domain = this;
+  stack.push(this);
+  _domain_flag[0] = stack.length;
+};
+
+
+Domain.prototype.exit = function() {
+  // skip disposed domains, as usual, but also don't do anything if this
+  // domain is not on the stack.
+  var index = stack.lastIndexOf(this);
+  if (this._disposed || index === -1) return;
+
+  // exit all domains until this one.
+  stack.splice(index);
+  _domain_flag[0] = stack.length;
+
+  exports.active = stack[stack.length - 1];
+  process.domain = exports.active;
+};
+
+
+// note: this works for timers as well.
+Domain.prototype.add = function(ee) {
+  // If the domain is disposed or already added, then nothing left to do.
+  if (this._disposed || ee.domain === this)
+    return;
+
+  // has a domain already - remove it first.
+  if (ee.domain)
+    ee.domain.remove(ee);
+
+  // check for circular Domain->Domain links.
+  // This causes bad insanity!
+  //
+  // For example:
+  // var d = domain.create();
+  // var e = domain.create();
+  // d.add(e);
+  // e.add(d);
+  // e.emit('error', er); // RangeError, stack overflow!
+  if (this.domain && (ee instanceof Domain)) {
+    for (var d = this.domain; d; d = d.domain) {
+      if (ee === d) return;
+    }
+  }
+
+  ee.domain = this;
+  this.members.push(ee);
+};
+
+
+Domain.prototype.remove = function(ee) {
+  ee.domain = null;
+  var index = this.members.indexOf(ee);
+  if (index !== -1)
+    this.members.splice(index, 1);
+};
+
+
+Domain.prototype.run = function(fn) {
+  if (this._disposed)
+    return;
+  this.enter();
+  var ret = fn.call(this);
+  this.exit();
+  return ret;
+};
+
+
+function intercepted(_this, self, cb, fnargs) {
+  if (self._disposed)
+    return;
+
+  if (fnargs[0] && fnargs[0] instanceof Error) {
+    var er = fnargs[0];
+    util._extend(er, {
+      domainBound: cb,
+      domainThrown: false,
+      domain: self
+    });
+    self.emit('error', er);
+    return;
+  }
+
+  var len = fnargs.length;
+  var args = [];
+  var i, ret;
+
+  self.enter();
+  if (fnargs.length > 1) {
+    for (i = 1; i < fnargs.length; i++)
+      args.push(fnargs[i]);
+    ret = cb.apply(_this, args);
+  } else {
+    ret = cb.call(_this);
+  }
+  self.exit();
+
+  return ret;
+}
+
+
+Domain.prototype.intercept = function(cb) {
+  var self = this;
+
+  function runIntercepted() {
+    return intercepted(this, self, cb, arguments);
+  }
+
+  return runIntercepted;
+};
+
+
+function bound(_this, self, cb, fnargs) {
+  if (self._disposed)
+    return;
+
+  var len = fnargs.length;
+  var args = [];
+  var i, ret;
+
+  self.enter();
+  if (fnargs.length > 0)
+    ret = cb.apply(_this, fnargs);
+  else
+    ret = cb.call(_this);
+  self.exit();
+
+  return ret;
+}
+
+
+Domain.prototype.bind = function(cb) {
+  var self = this;
+
+  function runBound() {
+    return bound(this, self, cb, arguments);
+  }
+
+  runBound.domain = this;
+
+  return runBound;
+};
+
+
+Domain.prototype.dispose = util.deprecate(function() {
+  if (this._disposed) return;
+
+  // if we're the active domain, then get out now.
+  this.exit();
+
+  // remove from parent domain, if there is one.
+  if (this.domain) this.domain.remove(this);
+
+  // kill the references so that they can be properly gc'ed.
+  this.members.length = 0;
+
+  // mark this domain as 'no longer relevant'
+  // so that it can't be entered or activated.
+  this._disposed = true;
+});