TEST(function test_lookup_all_mixed(done) {
var req = dns.lookup('www.google.com', {all: true}, function(err, ips) {
if (err) throw err;
assert.ok(Array.isArray(ips));
assert.ok(ips.length > 0);
ips.forEach(function(ip) {
if (isIPv4(ip.address))
assert.equal(ip.family, 4);
else if (isIPv6(ip.address))
assert.equal(ip.family, 6);
else
assert(false);
});
done();
});
checkWrap(req);
});
client.prototype.dnsAvailable = function (name, cb) {
var data = {
provider: 'dns'
};
dns.lookup(name, function (err, address, family) {
data.err = err;
if (err && err.code === dns.NOTFOUND) {
return cb(null, true, data);
} else if (err) {
return cb(err);
}
data.address = address;
data.family = family;
cb(null, false, data);
});
};
ConnectionParameters.prototype.getLibpqConnectionString = function(cb) {
var params = [];
add(params, this, 'user');
add(params, this, 'password');
add(params, this, 'port');
if(this.database) {
params.push("dbname='" + this.database + "'");
}
if(this.isDomainSocket) {
params.push("host=" + this.host);
return cb(null, params.join(' '));
}
if(this.client_encoding) {
params.push("client_encoding='" + this.client_encoding + "'");
}
dns.lookup(this.host, function(err, address) {
if(err) return cb(err, null);
params.push("hostaddr=" + address);
return cb(null, params.join(' '));
});
};
function resolveHost(_url, callback) {
_url = formatUrl(util.setProtocol(_url));
var options = url.parse(_url);
if (!util.isWebProtocol(options.protocol)) {
return callback(null, null);
}
var host = getRule(_url, hosts);
if (host) {
return callback(null, host.matcher);
}
try {
dns.lookup(options.hostname, function(err, ip, addressType) {
callback(err, err ? null : (ip || (!addressType || addressType === 4 ? '127.0.0.1' : '0:0:0:0:0:0:0:1')));
});
} catch(err) {//如果断网，可能直接抛异常，https代理没有用到error-handler
callback(err);
}
}
function resolveDomain(host) {
var future = new Future();
if (haveProxy) {
host = proxyHost;
}
if (dnsCache[host]) {
future.result = {returnValue: true, ip: dnsCache[host]};
} else {
dns.lookup(host, function (err, address) {
if (err) {
future.result = {returnValue: false};
} else {
dnsCache[host] = address;
future.result = {returnValue: true, ip: address};
}
});
}
return future;
}
TEST(function test_lookup_all_ipv6(done) {
const req = dns.lookup(
'www.google.com',
{ all: true, family: 6 },
common.mustCall((err, ips) => {
assert.ifError(err);
assert.ok(Array.isArray(ips));
assert.ok(ips.length > 0);
ips.forEach((ip) => {
assert.ok(isIPv6(ip.address),
`Invalid IPv6: ${ip.address.toString()}`);
assert.strictEqual(ip.family, 6);
});
done();
})
);
checkWrap(req);
});
(function (iter) {
times[iter] = Date.now();
dns.lookup('ngx.discovery', {all: 1}, function (err,ips) {
let timestamp=Date.now();
process.nextTick(()=>{
requests++;
if (timestamp-times[iter]>1000){
console.log(`Resolving takes ${timestamp-times[iter]}ms after ${requests} requests`)
}
if (!ips.startsWith('10.0.')){
console.log(`Wrong ip returned: ${ips}`)
}
if (!--done){
setImmediate(callMe);
}
});
});
done++;
})(i);
validateByForwardDnsLookup = function(ip, hostname){
var p = Q.resolve(), address;
debug('performing forward dns lookup', hostname);
try{
var def = Q.defer();
dns.lookup(hostname, function(err, res){
address = res;
return def.resolve(err);
});
p = p.then(function(){ return def.promise });
}
catch(e){
p = p.then(function(){ return e; });
}
return p.then(function(err){
if (err){
switch(err.code){
case 'ENOTFOUND': // Domain name not found.
case 'ENOTIMP': // DNS server does not implement requested operation. (invalid ip)
case 'EFORMERR': // no data returned
case 'EBADQUERY': // bad query
case 'EBADNAME': // Misformatted hostname
case 'EBADSTR': // Misformatted string.
case 'ENONAME': // Given hostname is not numeric.
case 'ENODATA': // no data
case 'ESERVFAIL': // general server failure
case 'EINVAL': // invalid domain
return false;
default:
return Q.reject(err);
}
}
var ret = address === ip;
if (ret) debug('forward dns lookup is valid', hostname, ip);
return ret;
});
},
(function iter(i) {
if (i < 0) {
next();
return;
}
if (data.hosts[i].host) {
dns.lookup(data.hosts[i].host, 4, function onLookup(err, address, family) {
if (err) {
console.error("Could not resolve " + data.hosts[i].host + "due to", err);
} else {
data.hosts[i].ip = address;
data.hosts[i].family = family;
}
iter(i - 1);
});
} else {
iter(i - 1);
}
})(data.hosts.length - 1);
.on('ready', (server) => {
// cncengine service
cncengine.start(server, options.controller || config.get('controller', ''));
const address = server.address().address;
const port = server.address().port;
const filteredRoutes = routes.reduce((acc, r) => {
const { type, route, directory } = r;
if (type === 'static') {
acc.push({
path: route,
directory: directory
});
}
return acc;
}, []);
callback && callback(null, {
address: address,
port: port,
routes: filteredRoutes
});
if (address !== '0.0.0.0') {
log.info('Starting the server at ' + chalk.yellow(`http://${address}:${port}`));
return;
}
dns.lookup(os.hostname(), { family: 4, all: true }, (err, addresses) => {
if (err) {
log.error('Can\'t resolve host name:', err);
return;
}
addresses.forEach(({ address, family }) => {
log.info('Starting the server at ' + chalk.yellow(`http://${address}:${port}`));
});
});
})
var Client = function (host, port, prefix, suffix, globalize, cacheDns, mock) {
var options = host || {},
self = this;
if(arguments.length > 1 || typeof(host) === 'string'){
options = {
host : host,
port : port,
prefix : prefix,
suffix : suffix,
globalize : globalize,
cacheDns : cacheDns,
mock : mock === true
};
}
this.host = options.host || 'localhost';
this.port = options.port || 8125;
this.prefix = options.prefix || '';
this.suffix = options.suffix || '';
this.mock = options.mock;
if (!this.mock) {
this.socket = dgram.createSocket('udp4');
}
this.mockCallback = options.mockCallback || function () {};
if(options.cacheDns === true){
dns.lookup(options.host, function(err, address, family){
if(err == null){
self.host = address;
}
});
}
if(options.globalize){
global.statsd = this;
}
};
function trace(host,cb) {
dns.lookup(host, function (err) {
if (err && net.isIP(host) === 0)
cb('Invalid host');
else {
var traceroute;
if (isWin) {
traceroute = child.exec('tracert -d ' + host, function (err,stdout,stderr) {
if (!err)
parseOutput(stdout,cb);
});
}
else {
traceroute = child.exec('traceroute -q 1 -n ' + host, function (err,stdout,stderr) {
if (!err)
parseOutput(stdout,cb);
});
}
}
});
}
SSDP.prototype.server = function (ip, portno) {
var self = this
if (!portno) portno = '10293'
this._usns[this._udn] = this._udn
this._logger.trace('Will try to bind to ' + ip + ':' + this._ssdpPort)
if (!ip || ip == '0.0.0.0') {
dns.lookup(os.hostname(), function (err, add) {
self._httphost = 'http://' + add + ':' + portno
bind()
})
} else {
this._httphost = 'http://' + ip + ':' + portno
bind()
}
function bind() {
self.sock.bind(self._ssdpPort, ip, function () {
self._logger.info('UDP socket bound to ' + ip + ':' + self._ssdpPort)
self.advertise(false)
setTimeout(function () {
self.advertise(false)
}, 1000)
// Wake up.
setTimeout(self.advertise.bind(self), 2000)
setTimeout(self.advertise.bind(self), 3000)
// Ad loop.
setInterval(self.advertise.bind(self), 10000)
})
}
}
start: function(fn) {
var cnt = 0, todo = [], dns = require('dns');
for(var i in jobs) {
todo[i] = false;
dns.lookup(jobs[i].host, (function(i) {
return function(err, ip, addrType) {
todo[i] = {
err: err,
ip: ip,
addrType: addrType,
completed: jobs[i].completed
}
var ret = true;
for(; cnt <= i && todo[cnt]; ++cnt) {
if (ret) {
ret = todo[cnt].completed(todo[cnt].err, todo[cnt].ip, todo[cnt].addrType)
}
}
if (fn && cnt >= jobs.length) { fn(ret); }
};
})(i));
}
}
TEST(async function test_lookup_ip_all(done) {
function validateResult(result) {
assert.ok(Array.isArray(result));
assert.ok(result.length > 0);
assert.strictEqual(result[0].address, '127.0.0.1');
assert.strictEqual(result[0].family, 4);
}
validateResult(await dnsPromises.lookup('127.0.0.1', { all: true }));
const req = dns.lookup(
'127.0.0.1',
{ all: true },
function(err, ips, family) {
assert.ifError(err);
assert.strictEqual(family, undefined);
validateResult(ips);
done();
}
);
checkWrap(req);
});
City.prototype.lookup = function(ipORdomain, callback) {
var self = this;
//
if(!isValidIpORdomain(ipORdomain)) {
self.options.silent ? callback(null, null)
: callback(new TypeError('expected string'));
return;
}
dns.lookup(ipORdomain, 4, function(err, address, family) {
if (err) {
// See @http://nodejs.org/api/dns.html#dns_error_codes
debug('Dns error code: %s', err.code);
return callback.call(self, err);
}
info('Address returned from node dns: %s', address);
info('Family number returned from nod dns: %d', family);
callback.call(self, null, self.native.lookupSync(address));
});
};
/**
* Runs a test to check the job server configuration.
* @static
* @param {errorCallback} callback - The callback that handles the test outcome.
*/
function init(callback) {
// Check that the config has all required values set.
var port = parseInt(target_config.port);
if (_.isNaN(port)) {
console.log('Invalid job server port: ' + port);
return callback('Invalid job server port.');
}
var host = target_config.host;
if (host && typeof host === 'string') {
// try to resolve this host
dns.lookup(host, function(err, address, family) {
if (err) {
console.log(err);
return callback(err);
} else {
console.log('Using job server at: ' + host + ' (' + address + ') :' + port);
return callback();
}
});
} else {
return callback('Invalid job host.');
}
}
YunDriver.prototype._scrub_api = function()
{
var self = this;
if (!self.api) {
return
} else if (self.api_scrubbed) {
return;
} else {
self.api_scrubbed = true;
}
var u = url.parse(self.api)
if (/[^0-9.]/.exec(u) == null) {
return;
}
dns.lookup(u.hostname, function(err, address) {
if (err) {
console.log("# YunDriver._scrub_api/dns.lookup", err)
return;
}
var u = url.parse(self.api)
u.host = null
u.hostname = address
var newapi = url.format(u).replace(/\/*$/, "");
console.log("- YunDriver._scrub_api/dns.lookup: changed API using DNS lookup",
"\n was", self.api,
"\n now", newapi
)
self.api = newapi
})
}
that.route = function(from, to) {
if (Array.isArray(from)) {
from.forEach(function(item) {
that.route(item, to);
});
return that;
}
if (!net.isIP(to)) {
dns.lookup(to, function(err, ip) {
if (err) {
return;
}
that.route(from, ip);
});
return that;
}
from = new RegExp('^'+from.replace(/\./g, '\\.').replace(/\*\\\./g, '(.+)\\.')+'$', 'i');
to = numify(to);
routes.push({from:from, to:to});
return that;
};
ConnectionParameters.prototype.getLibpqConnectionString = function (cb) {
var params = []
add(params, this, 'user')
add(params, this, 'password')
add(params, this, 'port')
add(params, this, 'application_name')
add(params, this, 'fallback_application_name')
var ssl = typeof this.ssl === 'object' ? this.ssl : { sslmode: this.ssl }
add(params, ssl, 'sslmode')
add(params, ssl, 'sslca')
add(params, ssl, 'sslkey')
add(params, ssl, 'sslcert')
add(params, ssl, 'sslrootcert')
if (this.database) {
params.push('dbname=' + quoteParamValue(this.database))
}
if (this.replication) {
params.push('replication=' + quoteParamValue(this.replication))
}
if (this.host) {
params.push('host=' + quoteParamValue(this.host))
}
if (this.isDomainSocket) {
return cb(null, params.join(' '))
}
if (this.client_encoding) {
params.push('client_encoding=' + quoteParamValue(this.client_encoding))
}
dns.lookup(this.host, function (err, address) {
if (err) return cb(err, null)
params.push('hostaddr=' + quoteParamValue(address))
return cb(null, params.join(' '))
})
}
process.nextTick(function() {
if (!isIP(cfg.host)) {
lookup(cfg.host, function(err, address, family) {
self._connecting = false;
if (err) {
self.emit('error', err);
// consistent as close event followed by conn.error
return self.emit('close', true);
}
cfg = clone(cfg);
cfg.host = address;
if (cfg.pingInterval)
self.pingInterval = cfg.pingInterval * 1000;
if (!self.destroyed && !self.connecting && !self.connected) {
self.connecting = true;
self._client.connect(cfg);
} else if (self.destroyed) {
// the only scenario is destroy() before DNS resolution success
// emit 'close' for consistency: as long as connect() called, a 'close' event will eventually fire
self.emit('close');
}
});
} else {
self._connecting = false;
if (cfg.pingInterval)
self.pingInterval = cfg.pingInterval * 1000;
if (!self.destroyed && !self.connecting && !self.connected) {
self.connecting = true;
self._client.connect(cfg);
} else if (self.destroyed) {
// the only scenario is connect() followed by a destroy()
// emit 'close' for consistency: as long as connect() called, a 'close' event will eventually fire
self.emit('close');
}
}
});
function getResString(rq, callback){
var respond_string = "";
first = true;
size = 0;
for(e in rq){
size += 1;
}
for(e in rq){
var host = rq[e];
dns.lookup(host,function(err, address, family) {
// if (err) throw err;
try {
var a = geoip.getRecord(address);
if(first && a != null){
first = false;
respond_string = respond_string + String(a.location.latitude) + "/" + String(a.location.longitude);
}else if(a != null){
respond_string = respond_string + "//" + String(a.location.latitude) + "/" + String(a.location.longitude);
}else{
console.log('no locations found for this:');
// console.log(host);
console.log(address);
}
}
catch(err){
console.log(err);
}
size -= 1;
if(size == 0){
// console.log(respond_string);
callback(respond_string);
}
});
}
}
arr[i].forEach(function (item, index) {
dns.lookup([item, rawUrl].join("."), 4, function (err, doc) {
tmpindex++;
// console.log(rawUrl, i, tmpindex, arr[i].length);
if (doc && !/202\.106\.199/.test(doc)) {
var data = {ip: doc, url: item, domain: rawUrl};
task[rawUrl].domain.push(data);
sendMessage(rawUrl, "DOMAIN_DATA", [data]);
}
if (+new Date() - task[rawUrl].t > 1000) {
task[rawUrl].t = +new Date();
sendMessage(rawUrl, "DOMAIN_PROGRESS", {
domain: rawUrl,
pos: (i * Math.floor(dic.length / splitNum) + tmpindex) / dic.length
});
}
//当前分片完成
if (tmpindex == arr[i].length) {
if (i + 1 < arr.length)
dnsLook(arr, rawUrl, i + 1);
else { //所有分片完成
sendMessage(rawUrl, "DOMAIN_PROGRESS", {domain: rawUrl, pos: 1});
//保存记录
db.urldb.findOneAndUpdate({domain: rawUrl}, {
subdomain: task[rawUrl].domain,
updated_at: Date.now()
}, {upsert: true}, function () {
delete task[rawUrl];
})
}
}
});
})
function joinVoiceChannel(server, channel, token, session, endpoint, callback) {
self.internals.voice_endpoint = endpoint;
endpoint = endpoint.split(":")[0];
dns.lookup(endpoint, function(err, address, family) {
self.internals.voice_address = address;
vChannels[channel].address = address;
vChannels[channel].ws = {};
vChannels[channel].udp = {};
vChannels[channel].ready = false;
var vWS = vChannels[channel].ws.connection = new websocket("wss://" + endpoint);
var udpClient = vChannels[channel].udp.connection = udp.createSocket("udp4");
var vKAPayload = {
"op": 3,
"d": null
};
var vKAI;
var vDiscIP = "";
var vDiscPort;
udpClient.bind({exclusive: true});
udpClient.once('message', function(msg, rinfo) {
var buffArr = JSON.parse(JSON.stringify(msg)).data;
for (var i=4; i<buffArr.indexOf(0, i); i++) {
vDiscIP += String.fromCharCode(buffArr[i]);
}
vDiscPort = msg.readUIntLE(msg.length - 2, 2).toString(10);
var wsDiscPayload = {
"op":1,
"d":{
"protocol":"udp",
"data":{
"address":vDiscIP,
"port": Number(vDiscPort),
"mode":vChannels[channel].ws.modes[0] //Plain
}
}
};
vWS.send(JSON.stringify(wsDiscPayload));
});
vWS.once('open', function() {
var vWSinit = {
"op": 0,
"d": {
"server_id": server,
"user_id": self.id,
"session_id": session,
"token": token
}
};
vWS.send(JSON.stringify(vWSinit));
});
vWS.on('message', function(vMessage) {
var vData = JSON.parse(vMessage);
switch (vData.op) {
case 2:
for (var vKey in vData.d) {
vChannels[channel].ws[vKey] = vData.d[vKey];
}
vKAI = setInterval(function() {
vWS.send(JSON.stringify(vKAPayload));
}, vData.d.heartbeat_interval);
var udpDiscPacket = new Buffer(70);
udpDiscPacket.writeUIntBE(vData.d.ssrc, 0, 4);
udpClient.send(udpDiscPacket, 0, udpDiscPacket.length, vData.d.port, address, function(err) { if (err) console.log(err); });
break;
case 4:
vChannels[channel].selectedMode = vData.d.mode;
vChannels[channel].ready = true;
if (callback && typeof(callback) === 'function') {
callback(undefined);
}
break;
}
});
vWS.once('close', function() {
clearInterval(vKAI);
});
});
}
var haveInternet = function () {
return dns.lookup('google.com', onCheckInternet);
};
var dns = require('dns');
var url = 'www.baidu.com';
dns.lookup(url, function onLookup(err, addresses, family) {
console.log('addresses:', addresses);
});
/**
* Get the public IP-address for the machine.
* @param fun Function f(error, address, family)
* Thanks to nodyou: http://stackoverflow.com/a/8440736/1285614
*/
function GetIP(fun)
{
DNS.lookup(OS.hostname(), fun)
}
socket.on('message', function(msg) {
// msg.data is the payload
});
</pre>
*/
/** Set to true to enable debug output for testing the relay itself. */
var debug = true;
var PORT = process.argv[2] ? parseInt(process.argv[2]) : 1080;
var dns = require('dns');
var os = require('os');
dns.lookup(os.hostname(), function (err, addr, fam) {
console.log('Relay running at http://' + os.hostname() + ':' + PORT +
' (http://' + addr + ':' + PORT + ')');
});
var io = require('socket.io').listen(PORT);
if (debug) console.log('PORT = ' + PORT);
//---------------------------------------------------------------------------
/** A server of game. If advertise is false, does not appear in
the browsable list.
*/
function Server(game, name, socket) {
this.game = game;
this.name = name;
this.socket = socket;
var net=require('net');
var dns=require('dns');
var parse=require('url').parse;
var url='http://html5.360.cn/star';
var urlInfo=parse(url);
console.log('urlInfo:',urlInfo);
dns.lookup(urlInfo.hostname,function(err,serverIP){
var serverPort=urlInfo.port||80;
console.log('serverIP:',serverIP);
console.log('serverPort:',serverPort);
console.log('connect to server......');
var client=new net.Socket();
client.connect(serverPort,serverIP,function(){
console.log('ok');
client.on('data',function(data){
console.log('recerive data from server:'+data);
});
console.log('sent request header....');
client.write('GET'+urlInfo.path+'HTTP/1.1\r\n');
client.write('Host:'+urlInfo.hostname+'\r\n');
client.write('Connection:close'+'\r\n');
client.write('\r\n');
});
});
const http = require('http');
const os = require('os');
const dns = require('dns');
const hostname = os.hostname();
dns.lookup(os.hostname(), (err, addr) => {
const host_address = addr;
const server = http.createServer((req, res) => {
res.writeHeader(200, { 'Content-Type': 'text/plain' });
const client = req.headers['x-forwarded-for'] ||
req.connection.remoteAddress ||
req.socket.remoteAddress ||
req.connection.socket.remoteAddress;
const log = `${client}\t → \t ${hostname} @ [${host_address}]`;
res.end(log);
console.log(log);
});
server.on('clientError', (err, socket) => {
socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
});
server.listen(8000, () => {
console.log(`Listening on ${host_address}:8000 ...`);
});
});