← Back to branch summary

~ubuntu-branches/ubuntu/precise/nodejs/precise

« back to all changes in this revision

Viewing changes to lib/dns.js

  • Committer: Bazaar Package Importer
  • Author(s): Jérémy Lal
  • Date: 2010-08-20 11:49:04 UTC
  • mfrom: (7.1.6 sid)
  • Revision ID: james.westby@ubuntu.com-20100820114904-lz22w6fkth7yh179
Tags: 0.2.0-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/dns.js
71
71
  updateTimer();
72
72
}});
73
73
 
74
 
 
 
74
exports.isIP = dns.isIP;
75
75
 
76
76
exports.resolve = function (domain, type_, callback_) {
77
77
  var type, callback;
93
93
}
94
94
 
95
95
 
96
 
exports.getHostByName = function (domain, callback) {
97
 
  channel.getHostByName(domain, dns.AF_INET, callback);
98
 
};
 
96
function familyToSym(family) {
 
97
  if (family !== dns.AF_INET && family !== dns.AF_INET6) {
 
98
    family = (family === 6) ? dns.AF_INET6 : dns.AF_INET;
 
99
  }
 
100
  return family;
 
101
}
 
102
 
 
103
 
 
104
exports.getHostByName = function (domain, family/*=4*/, callback) {
 
105
  if (typeof family === 'function') { callback = family; family = null; }
 
106
  channel.getHostByName(domain, familyToSym(family), callback);
 
107
};
 
108
 
 
109
 
 
110
exports.getHostByAddr = function (address, family/*=4*/, callback) {
 
111
  if (typeof family === 'function') { callback = family; family = null; }
 
112
  channel.getHostByAddr(address, familyToSym(family), callback);
 
113
};
 
114
 
99
115
 
100
116
// Easy DNS A/AAAA look up
101
 
exports.lookup = function (domain, callback) {
102
 
  var addressType = dns.isIP(domain);
103
 
  if (addressType) {
104
 
    process.nextTick(function () {
105
 
      callback(null, domain, addressType);
106
 
    });
 
117
// lookup(domain, [family,] callback)
 
118
exports.lookup = function (domain, family, callback) {
 
119
  if (arguments.length === 2) {
 
120
    callback = family;
 
121
    family = undefined;
 
122
  } else if (family && family !== 4 && family !== 6) {
 
123
    family = parseInt(family);
 
124
    if (family === dns.AF_INET) {
 
125
      family = 4;
 
126
    } else if (family === dns.AF_INET6) {
 
127
      family = 6;
 
128
    } else if (family !== 4 && family !== 6) {
 
129
      throw new Error('invalid argument: "family" must be 4 or 6');
 
130
    }
 
131
  }
 
132
  if (!domain) {
 
133
    callback(null, null, family === 6 ? 6 : 4);
 
134
    return;
 
135
  }
 
136
  var matchedFamily = dns.isIP(domain);
 
137
  if (matchedFamily) {
 
138
    callback(null, domain, matchedFamily);
107
139
  } else {
108
 
    channel.getHostByName(domain, dns.AF_INET, function (err, domains4) {
109
 
      if (domains4 && domains4.length) {
110
 
        callback(null, domains4[0], 4);
 
140
    if (/\w\.local\.?$/.test(domain)) {
 
141
      // ANNOYING: In the case of mDNS domains use NSS in the thread pool.
 
142
      // I wish c-ares had better support.
 
143
      process.binding('net').getaddrinfo(domain, 4, function (err, domains4) {
 
144
        callback(err, domains4[0], 4);
 
145
      });
 
146
    } else {
 
147
      if (family) {
 
148
        // resolve names for explicit address family
 
149
        var af = familyToSym(family);
 
150
        channel.getHostByName(domain, af, function (err, domains) {
 
151
          if (!err && domains && domains.length) {
 
152
            if (family !== dns.isIP(domains[0])) {
 
153
              callback(new Error('not found'), []);
 
154
            } else {
 
155
              callback(null, domains[0], family);
 
156
            }
 
157
          } else {
 
158
            callback(err, []);
 
159
          }
 
160
        });
111
161
      } else {
112
 
        channel.getHostByName(domain, dns.AF_INET6, function (err, domains6) {
113
 
          if (domains6 && domains6.length) {
114
 
            callback(null, domains6[0], 6);
 
162
        // first resolve names for v4 and if that fails, try v6
 
163
        channel.getHostByName(domain, dns.AF_INET, function (err, domains4) {
 
164
          if (domains4 && domains4.length) {
 
165
            callback(null, domains4[0], 4);
115
166
          } else {
116
 
            callback(err, []);
 
167
            channel.getHostByName(domain, dns.AF_INET6,
 
168
                                  function (err, domains6) {
 
169
              if (domains6 && domains6.length) {
 
170
                callback(null, domains6[0], 6);
 
171
              } else {
 
172
                callback(err, []);
 
173
              }
 
174
            });
117
175
          }
118
176
        });
119
177
      }
120
 
    });
 
178
    }
121
179
  }
122
180
};
123
181
 
124
182
 
125
 
exports.resolve4    = function(domain, callback) { channel.query(domain, dns.A, callback) };
126
 
exports.resolve6    = function(domain, callback) { channel.query(domain, dns.AAAA, callback) };
127
 
exports.resolveMx   = function(domain, callback) { channel.query(domain, dns.MX, callback) };
128
 
exports.resolveTxt  = function(domain, callback) { channel.query(domain, dns.TXT, callback) };
129
 
exports.resolveSrv  = function(domain, callback) { channel.query(domain, dns.SRV, callback) };
130
 
exports.reverse     = function(domain, callback) { channel.query(domain, dns.PTR, callback) };
131
 
exports.resolveNs   = function(domain, callback) { channel.query(domain, dns.NS, callback) };
132
 
 
 
183
exports.resolve4    = function(domain, callback) {
 
184
  channel.query(domain, dns.A, callback);
 
185
};
 
186
exports.resolve6    = function(domain, callback) {
 
187
  channel.query(domain, dns.AAAA, callback);
 
188
};
 
189
exports.resolveMx   = function(domain, callback) {
 
190
  channel.query(domain, dns.MX, callback);
 
191
};
 
192
exports.resolveTxt  = function(domain, callback) {
 
193
  channel.query(domain, dns.TXT, callback);
 
194
};
 
195
exports.resolveSrv  = function(domain, callback) {
 
196
  channel.query(domain, dns.SRV, callback);
 
197
};
 
198
exports.reverse     = function(domain, callback) {
 
199
  channel.query(domain, dns.PTR, callback);
 
200
};
 
201
exports.resolveNs   = function(domain, callback) {
 
202
  channel.query(domain, dns.NS, callback);
 
203
};
133
204
 
134
205
var resolveMap = {
135
206
  'A'   : exports.resolve4,