// 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 + (hostname ? ' ' + hostname : ''));

ex.code = err;

ex.errno = err;

ex.syscall = syscall;

} else {

ex = util._errnoException(err, syscall);

}

if (hostname) {

ex.hostname = hostname;

}

return ex;

if (typeof callback !== 'function') {

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

});

}

};

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

}

var hints = 0;

var family = -1;

// Parse arguments

if (hostname && typeof hostname !== 'string') {

throw TypeError('invalid arguments: hostname must be a string or falsey');

} else if (typeof options === 'function') {

callback = options;

family = 0;

} else if (typeof callback !== 'function') {

throw TypeError('invalid arguments: callback must be passed');

} else if (options !== null && typeof options === 'object') {

hints = options.hints >>> 0;

family = options.family >>> 0;

if (hints !== 0 &&

hints !== exports.ADDRCONFIG &&

hints !== exports.V4MAPPED &&

hints !== (exports.ADDRCONFIG | exports.V4MAPPED)) {

throw new TypeError('invalid argument: hints must use valid flags');

}

// FIXME(indutny): V4MAPPED on FreeBSD results in EAI_BADFLAGS, because

// the libc does not support it

if (process.platform === 'freebsd' && family !== 6)

hints &= ~exports.V4MAPPED;

} else {

family = options >>> 0;

}

if (family !== 0 && family !== 4 && family !== 6)

throw new TypeError('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 = new GetAddrInfoReqWrap();

req.callback = callback;

req.family = family;

req.hostname = hostname;

req.oncomplete = onlookup;

var err = cares.getaddrinfo(req, hostname, family, hints);

if (err) {

callback(errnoException(err, 'getaddrinfo', hostname));

return {};

}

callback.immediately = true;

return req;

if (err)

return this.callback(errnoException(err, 'getnameinfo', this.host));

this.callback(null, host, service);

if (arguments.length !== 3)

throw new Error('invalid arguments');

if (cares.isIP(host) === 0)

throw new TypeError('host needs to be a valid IP address');

callback = makeAsync(callback);

var req = new GetNameInfoReqWrap();

req.callback = callback;

req.host = host;

req.port = port;

req.oncomplete = onlookupservice;

var err = cares.getnameinfo(req, host, port);

if (err) throw errnoException(err, 'getnameinfo', host);

callback.immediately = true;

return req;

if (err)

this.callback(errnoException(err, this.bindingName, this.hostname));

else

this.callback(null, result);

var binding = cares[bindingName];

return function query(name, callback) {

if (typeof name !== 'string') {

throw new Error('Name must be a string');

} else if (typeof callback !== 'function') {

throw new Error('Callback must be a function');

}

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 resolver, callback;

if (typeof type_ === 'string') {

resolver = resolveMap[type_];

callback = callback_;

} else if (typeof type_ === 'function') {

resolver = exports.resolve4;

callback = type_;

} else {

throw new Error('Type must be a string');

}

if (typeof resolver === 'function') {

return resolver(hostname, callback);

} else {

throw new Error('Unknown type "' + type_ + '"');

}

// 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 + ']');

}