Stefan Bühler
11 years ago
commit
9213b14663
7 changed files with 1147 additions and 0 deletions
@ -0,0 +1,2 @@ |
|||
build |
|||
.lock-wscript |
|||
@ -0,0 +1,369 @@ |
|||
|
|||
#include "dns_parser.h" |
|||
|
|||
#include <node.h> |
|||
#include <v8.h> |
|||
#include <ares.h> |
|||
#include <ares_dns.h> |
|||
|
|||
#include <sys/types.h> |
|||
#include <sys/socket.h> |
|||
#include <netdb.h> |
|||
#include <string.h> |
|||
|
|||
#include <arpa/nameser.h> |
|||
#include <arpa/inet.h> |
|||
|
|||
#ifdef __OpenBSD__ |
|||
# ifndef ns_t_a |
|||
# include <nameser.h> |
|||
# endif |
|||
#endif // __OpenBSD__
|
|||
|
|||
namespace ares { |
|||
|
|||
class Channel : public node::ObjectWrap { |
|||
public: |
|||
Channel(); |
|||
virtual ~Channel(); |
|||
|
|||
static void Initialize(v8::Handle<v8::Object> target); |
|||
|
|||
private: |
|||
static v8::Persistent<v8::FunctionTemplate> constructor_template; |
|||
|
|||
static v8::Handle<v8::Value> New(const v8::Arguments& args); |
|||
static v8::Handle<v8::Value> Query(const v8::Arguments& args); |
|||
static v8::Handle<v8::Value> SetServers(const v8::Arguments& args); |
|||
static v8::Handle<v8::Value> Timeout(const v8::Arguments& args); |
|||
static v8::Handle<v8::Value> ProcessFD(const v8::Arguments& args); |
|||
|
|||
ares_channel channel; |
|||
|
|||
static void SockStateCb(void *data, int sock, int read, int write); |
|||
static void QueryCb(void *arg, int status, int timeouts, unsigned char* abuf, int alen); |
|||
|
|||
struct ares_addr_node *servers; |
|||
}; |
|||
|
|||
|
|||
v8::Persistent<v8::FunctionTemplate> Channel::constructor_template; |
|||
|
|||
static v8::Persistent<v8::String> callback_symbol; |
|||
|
|||
|
|||
static void Initialize(v8::Handle<v8::Object> target) { |
|||
v8::HandleScope scope; |
|||
|
|||
int r = ares_library_init(ARES_LIB_INIT_ALL); |
|||
if (0 != r) { |
|||
// TODO
|
|||
// ThrowException(Exception::Error(String::New(ares_strerror(r))));
|
|||
assert(r == 0); |
|||
} |
|||
|
|||
target->Set(v8::String::NewSymbol("SOCKET_BAD"), v8::Integer::New(ARES_SOCKET_BAD)); |
|||
|
|||
target->Set(v8::String::NewSymbol("AF_INET"), v8::Integer::New(AF_INET)); |
|||
target->Set(v8::String::NewSymbol("AF_INET6"), v8::Integer::New(AF_INET6)); |
|||
|
|||
target->Set(v8::String::NewSymbol("NODATA"), v8::Integer::New(ARES_ENODATA)); |
|||
target->Set(v8::String::NewSymbol("FORMERR"), v8::Integer::New(ARES_EFORMERR)); |
|||
target->Set(v8::String::NewSymbol("BADRESP"), v8::Integer::New(ARES_EBADRESP)); |
|||
target->Set(v8::String::NewSymbol("NOTFOUND"), v8::Integer::New(ARES_ENOTFOUND)); |
|||
target->Set(v8::String::NewSymbol("BADNAME"), v8::Integer::New(ARES_EBADNAME)); |
|||
target->Set(v8::String::NewSymbol("TIMEOUT"), v8::Integer::New(ARES_ETIMEOUT)); |
|||
target->Set(v8::String::NewSymbol("CONNREFUSED"), v8::Integer::New(ARES_ECONNREFUSED)); |
|||
target->Set(v8::String::NewSymbol("NOMEM"), v8::Integer::New(ARES_ENOMEM)); |
|||
target->Set(v8::String::NewSymbol("DESTRUCTION"), v8::Integer::New(ARES_EDESTRUCTION)); |
|||
|
|||
// Only occur if the ARES_FLAG_NOCHECKRESP flag was specified
|
|||
target->Set(v8::String::NewSymbol("NOTIMP"), v8::Integer::New(ARES_ENOTIMP)); |
|||
target->Set(v8::String::NewSymbol("EREFUSED"), v8::Integer::New(ARES_EREFUSED)); |
|||
target->Set(v8::String::NewSymbol("SERVFAIL"), v8::Integer::New(ARES_ESERVFAIL)); |
|||
|
|||
Channel::Initialize(target); |
|||
} |
|||
|
|||
|
|||
void Channel::Initialize(v8::Handle<v8::Object> target) { |
|||
v8::HandleScope scope; |
|||
|
|||
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(Channel::New); |
|||
constructor_template = v8::Persistent<v8::FunctionTemplate>::New(t); |
|||
constructor_template->InstanceTemplate()->SetInternalFieldCount(1); |
|||
constructor_template->SetClassName(v8::String::NewSymbol("Channel")); |
|||
|
|||
using namespace v8; |
|||
NODE_SET_PROTOTYPE_METHOD(constructor_template, "query", Channel::Query); |
|||
NODE_SET_PROTOTYPE_METHOD(constructor_template, "timeout", Channel::Timeout); |
|||
NODE_SET_PROTOTYPE_METHOD(constructor_template, "processFD", Channel::ProcessFD); |
|||
NODE_SET_PROTOTYPE_METHOD(constructor_template, "setServers", Channel::SetServers); |
|||
|
|||
target->Set(v8::String::NewSymbol("Channel"), constructor_template->GetFunction()); |
|||
|
|||
callback_symbol = NODE_PSYMBOL("callback"); |
|||
} |
|||
|
|||
Channel::Channel() : servers(0) { |
|||
} |
|||
Channel::~Channel() { |
|||
delete [] servers; |
|||
} |
|||
|
|||
v8::Handle<v8::Value> Channel::New(const v8::Arguments& args) { |
|||
v8::HandleScope scope; |
|||
|
|||
struct ares_options options; |
|||
int optmask = 0; |
|||
|
|||
Channel *c = new Channel(); |
|||
c->Wrap(args.This()); |
|||
|
|||
if (args.Length() > 0) { |
|||
if(!args[0]->IsObject()) { |
|||
return v8::ThrowException(v8::Exception::TypeError( |
|||
v8::String::New("Bad Options Argument"))); |
|||
} |
|||
|
|||
v8::Local<v8::Object> options_o = v8::Local<v8::Object>::Cast(args[0]); |
|||
|
|||
v8::Local<v8::Value> cb = options_o->Get(v8::String::NewSymbol("SOCK_STATE_CB")); |
|||
if (!cb.IsEmpty()) { |
|||
c->handle_->Set(callback_symbol, cb); |
|||
options.sock_state_cb_data = c; |
|||
options.sock_state_cb = Channel::SockStateCb; |
|||
optmask |= ARES_OPT_SOCK_STATE_CB; |
|||
} |
|||
} |
|||
|
|||
ares_init_options(&c->channel, &options, optmask); |
|||
|
|||
return args.This(); |
|||
} |
|||
|
|||
v8::Handle<v8::Value> Channel::Query(const v8::Arguments& args) { |
|||
v8::HandleScope scope; |
|||
Channel *c = node::ObjectWrap::Unwrap<Channel>(args.Holder()); |
|||
assert(c); |
|||
|
|||
if (!args[0]->IsString()) { |
|||
return v8::ThrowException(v8::Exception::TypeError( |
|||
v8::String::New("First argument must be a name"))); |
|||
} |
|||
|
|||
if (!args[1]->IsInt32()) { |
|||
return v8::ThrowException(v8::Exception::TypeError( |
|||
v8::String::New("Second argument must be a query type!!"))); |
|||
} |
|||
|
|||
if (!args[2]->IsFunction()) { |
|||
return v8::ThrowException(v8::Exception::TypeError( |
|||
v8::String::New("Third argument must be a callback"))); |
|||
} |
|||
|
|||
v8::String::Utf8Value name(args[0]->ToString()); |
|||
int type = args[1]->Int32Value(); |
|||
|
|||
ares_query(c->channel, *name, ns_c_in, type, QueryCb, node::cb_persist(args[2])); |
|||
|
|||
return v8::Undefined(); |
|||
} |
|||
|
|||
v8::Handle<v8::Value> Channel::Timeout(const v8::Arguments& args) { |
|||
v8::HandleScope scope; |
|||
Channel *c = ObjectWrap::Unwrap<Channel>(args.Holder()); |
|||
assert(c); |
|||
|
|||
if (!args[0]->IsInt32()) { |
|||
return v8::ThrowException(v8::Exception::Error( |
|||
v8::String::New("First argument must be an integer number of milliseconds"))); |
|||
} |
|||
|
|||
struct timeval tvbuf, maxtv, *ret; |
|||
|
|||
int64_t time = args[0]->IntegerValue(); |
|||
maxtv.tv_sec = time/1000; |
|||
maxtv.tv_usec = (time % 1000) * 1000; |
|||
|
|||
ret = ares_timeout(c->channel, (time > 0) ? &maxtv : NULL, &tvbuf); |
|||
|
|||
return scope.Close(v8::Integer::New(ret ? ret->tv_sec * 1000 + ret->tv_usec / 1000 : -1)); |
|||
} |
|||
|
|||
v8::Handle<v8::Value> Channel::ProcessFD(const v8::Arguments& args) { |
|||
v8::HandleScope scope; |
|||
Channel *c = ObjectWrap::Unwrap<Channel>(args.Holder()); |
|||
assert(c); |
|||
|
|||
int read_fd, write_fd; |
|||
|
|||
if (!args[0]->IsInt32()) { |
|||
return v8::ThrowException(v8::Exception::Error( |
|||
v8::String::New("First argument must be a file descriptor or SOCKET_BAD"))); |
|||
} |
|||
|
|||
read_fd = args[0]->Int32Value(); |
|||
|
|||
if (args.Length() > 1) { |
|||
if (!args[1]->IsInt32()) { |
|||
return v8::ThrowException(v8::Exception::Error( |
|||
v8::String::New("Second argument must be a file descriptor or SOCKET_BAD"))); |
|||
} |
|||
write_fd = args[1]->Int32Value(); |
|||
|
|||
} else { |
|||
write_fd = ARES_SOCKET_BAD; |
|||
} |
|||
|
|||
ares_process_fd(c->channel, read_fd, write_fd); |
|||
|
|||
return v8::Undefined(); |
|||
} |
|||
|
|||
static bool parse_addr(v8::Handle<v8::Value> v, ares_addr_node &a) { |
|||
memset(&a, 0, sizeof(a)); |
|||
|
|||
if (!v->IsString()) return false; |
|||
|
|||
v8::String::Utf8Value s(v->ToString()); |
|||
|
|||
// avoiding buffer overflows in the following strcat
|
|||
// 2001:0db8:85a3:08d3:1319:8a2e:0370:7334
|
|||
// 39 = max ipv6 address.
|
|||
if (s.length() > INET6_ADDRSTRLEN) return false; |
|||
|
|||
if (inet_pton(AF_INET, *s, &(a.addr.addr4)) > 0) { |
|||
a.family = AF_INET; |
|||
return true; |
|||
} |
|||
if (inet_pton(AF_INET6, *s, &(a.addr.addr6)) > 0) { |
|||
a.family = AF_INET6; |
|||
return true; |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
v8::Handle<v8::Value> Channel::SetServers(const v8::Arguments& args) { |
|||
int status; |
|||
|
|||
v8::HandleScope scope; |
|||
Channel *c = node::ObjectWrap::Unwrap<Channel>(args.Holder()); |
|||
assert(c); |
|||
|
|||
if (args.Length() == 0) { |
|||
status = ares_set_servers(c->channel, NULL); |
|||
if (ARES_SUCCESS != status) return v8::ThrowException(dns_parser::AresException(status)); |
|||
|
|||
delete [] c->servers; |
|||
c->servers = 0; |
|||
return v8::Undefined(); |
|||
} |
|||
|
|||
if (args[0]->IsString()) { |
|||
ares_addr_node *servers = new ares_addr_node[args.Length()]; |
|||
for (int i = 0, l = args.Length(); i < l; i++) { |
|||
if (i > 0) servers[i-1].next = &servers[i]; |
|||
if (!parse_addr(args[i], servers[i])) { |
|||
return v8::ThrowException(v8::Exception::Error( |
|||
v8::String::New("Arguments must be strings with valid IP addresses"))); |
|||
} |
|||
} |
|||
status = ares_set_servers(c->channel, servers); |
|||
if (ARES_SUCCESS != status) return v8::ThrowException(dns_parser::AresException(status)); |
|||
|
|||
return v8::Undefined(); |
|||
} |
|||
|
|||
if (args[0]->IsArray()) { |
|||
v8::Local<v8::Array> a = v8::Local<v8::Array>::Cast(args[0]); |
|||
|
|||
if (args.Length() == 0) { |
|||
status = ares_set_servers(c->channel, NULL); |
|||
if (ARES_SUCCESS != status) return v8::ThrowException(dns_parser::AresException(status)); |
|||
|
|||
delete [] c->servers; |
|||
c->servers = 0; |
|||
return v8::Undefined(); |
|||
} |
|||
|
|||
ares_addr_node *servers = new ares_addr_node[args.Length()]; |
|||
for (int i = 0, l = a->Length(); i < l; i++) { |
|||
if (i > 0) servers[i-1].next = &servers[i]; |
|||
if (!parse_addr(a->Get(i), servers[i])) { |
|||
return v8::ThrowException(v8::Exception::Error( |
|||
v8::String::New("Arguments must be strings with valid IP addresses"))); |
|||
} |
|||
} |
|||
|
|||
status = ares_set_servers(c->channel, servers); |
|||
if (ARES_SUCCESS != status) return v8::ThrowException(dns_parser::AresException(status)); |
|||
|
|||
return v8::Undefined(); |
|||
} |
|||
|
|||
return v8::ThrowException(v8::Exception::Error( |
|||
v8::String::New("Arguments must be strings with valid IP addresses"))); |
|||
} |
|||
|
|||
void Channel::SockStateCb(void *data, int sock, int read, int write) { |
|||
Channel *c = static_cast<Channel*>(data); |
|||
v8::HandleScope scope; |
|||
|
|||
v8::Local<v8::Value> callback_v = c->handle_->Get(callback_symbol); |
|||
if (!callback_v->IsFunction()) return; |
|||
v8::Local<v8::Function> callback = v8::Local<v8::Function>::Cast(callback_v); |
|||
|
|||
v8::Local<v8::Value> argv[3]; |
|||
|
|||
argv[0] = v8::Integer::New(sock); |
|||
argv[1] = v8::Integer::New(read); |
|||
argv[2] = v8::Integer::New(write); |
|||
|
|||
v8::TryCatch try_catch; |
|||
|
|||
callback->Call(c->handle_, 3, argv); |
|||
|
|||
if (try_catch.HasCaught()) { |
|||
node::FatalException(try_catch); |
|||
} |
|||
} |
|||
|
|||
void Channel::QueryCb(void *arg, int status, int timeouts, unsigned char* abuf, int alen) { |
|||
v8::HandleScope scope; |
|||
|
|||
v8::Persistent<v8::Function> *cb = node::cb_unwrap(arg); |
|||
v8::Local<v8::Value> result; |
|||
|
|||
if (status != ARES_SUCCESS && 0 == alen) { |
|||
result = dns_parser::AresException(status); |
|||
} else { |
|||
result = dns_parser::parse_dns_response(abuf, alen, &status); |
|||
} |
|||
|
|||
v8::TryCatch try_catch; |
|||
|
|||
if (status != ARES_SUCCESS) { |
|||
(*cb)->Call(v8::Context::GetCurrent()->Global(), 1, &result); |
|||
} else { |
|||
v8::Local<v8::Value> argv[2] = { v8::Local<v8::Value>::New(v8::Null()), result }; |
|||
|
|||
(*cb)->Call(v8::Context::GetCurrent()->Global(), 2, argv); |
|||
} |
|||
|
|||
node::cb_destroy(cb); |
|||
|
|||
if (try_catch.HasCaught()) { |
|||
node::FatalException(try_catch); |
|||
} |
|||
} |
|||
|
|||
} // namespace ares
|
|||
|
|||
extern "C" void |
|||
init (v8::Handle<v8::Object> target) { |
|||
v8::HandleScope scope; |
|||
ares::Initialize(target); |
|||
dns_parser::Initialize(target); |
|||
} |
|||
@ -0,0 +1,586 @@ |
|||
#include "dns_parser.h" |
|||
|
|||
#include <node.h> |
|||
#include <v8.h> |
|||
|
|||
#include <ares.h> |
|||
#include <ares_dns.h> |
|||
|
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
#include <stdint.h> |
|||
|
|||
#include <arpa/nameser.h> |
|||
#include <arpa/inet.h> |
|||
|
|||
#ifdef __OpenBSD__ |
|||
# ifndef ns_t_a |
|||
# include <nameser.h> |
|||
# endif |
|||
#endif // __OpenBSD__
|
|||
|
|||
namespace dns_parser { |
|||
|
|||
static v8::Persistent<v8::String> question_symbol, answer_symbol, authority_symbol, additional_symbol; |
|||
static v8::Persistent<v8::String> type_symbol, ntype_symbol, class_symbol, nclass_symbol, ttl_symbol, rdata_symbol, text_symbol, data_symbol; |
|||
static v8::Persistent<v8::String> priority_symbol, weight_symbol, port_symbol, name_symbol, exchange_symbol, target_symbol; |
|||
static v8::Persistent<v8::String> mname_symbol, rname_symbol, serial_symbol, refresh_symbol, retry_symbol, expire_symbol, minimum_symbol; |
|||
|
|||
static v8::Persistent<v8::String> space_symbol; |
|||
|
|||
typedef int (*ParseRRData)(const unsigned char *abuf, int alen, const unsigned char *rr_data, int rr_len, v8::Local<v8::Object> &r); |
|||
|
|||
struct RR_TYPE { |
|||
const char *s; |
|||
int n; |
|||
ParseRRData parse_in; /* only parse class IN */ |
|||
v8::Persistent<v8::String> symbol; |
|||
}; |
|||
|
|||
struct RR_CLASS { |
|||
const char *s; |
|||
int n; |
|||
v8::Persistent<v8::String> symbol; |
|||
}; |
|||
|
|||
static int parse_char_string(const unsigned char *&rr_data, int &rr_len, v8::Local<v8::String> &s) { |
|||
if (rr_len <= 0) return ARES_EBADRESP; |
|||
|
|||
int len = (unsigned int) rr_data[0]; |
|||
rr_data++; rr_len--; |
|||
if (len > rr_len) return ARES_EBADRESP; |
|||
|
|||
s = v8::String::New((const char*) rr_data, len); |
|||
rr_data += len; rr_len -= len; |
|||
|
|||
return ARES_SUCCESS; |
|||
} |
|||
|
|||
static int ParseRRData_A(const unsigned char *, int , const unsigned char *rr_data, int rr_len, v8::Local<v8::Object> &r) { |
|||
if (rr_len == sizeof(struct in_addr)) { |
|||
struct in_addr a; |
|||
memcpy(&a, rr_data, sizeof(a)); |
|||
|
|||
char ip[INET_ADDRSTRLEN]; |
|||
ip[0] = '\0'; |
|||
::inet_ntop(AF_INET, &a, ip, INET_ADDRSTRLEN); |
|||
|
|||
v8::Local<v8::String> address = v8::String::New(ip); |
|||
r->Set(text_symbol, address); |
|||
return ARES_SUCCESS; |
|||
} |
|||
return ARES_EBADRESP; |
|||
} |
|||
|
|||
static int ParseRRData_AAAA(const unsigned char *, int , const unsigned char *rr_data, int rr_len, v8::Local<v8::Object> &r) { |
|||
if (rr_len == sizeof(struct in6_addr)) { |
|||
struct in6_addr a; |
|||
memcpy(&a, rr_data, sizeof(a)); |
|||
|
|||
char ip[INET6_ADDRSTRLEN]; |
|||
ip[0] = '\0'; |
|||
::inet_ntop(AF_INET6, &a, ip, INET6_ADDRSTRLEN); |
|||
|
|||
v8::Local<v8::String> address = v8::String::New(ip); |
|||
r->Set(text_symbol, address); |
|||
return ARES_SUCCESS; |
|||
} |
|||
return ARES_EBADRESP; |
|||
} |
|||
|
|||
static int ParseRRData_MX(const unsigned char *abuf, int alen, const unsigned char *rr_data, int rr_len, v8::Local<v8::Object> &r) { |
|||
int status; |
|||
|
|||
if (rr_len < 2) return ARES_EBADRESP; |
|||
|
|||
uint16_t priority; |
|||
memcpy(&priority, rr_data, sizeof(priority)); |
|||
priority = ntohs(priority); |
|||
rr_data += sizeof(priority); rr_len -= 2; |
|||
|
|||
char *hostname; |
|||
long len; |
|||
status = ares_expand_name(rr_data, abuf, alen, &hostname, &len); |
|||
if (status != ARES_SUCCESS) return status; |
|||
v8::Local<v8::String> v8_hostname = v8::String::New(hostname); |
|||
free(hostname); |
|||
if (len != rr_len) return ARES_EBADRESP; |
|||
|
|||
v8::Local<v8::Integer> v8_priority = v8::Integer::New(priority); |
|||
r->Set(priority_symbol, v8_priority); |
|||
r->Set(exchange_symbol, v8_hostname); |
|||
|
|||
v8::Local<v8::String> text = v8::String::Concat(v8_priority->ToString(), space_symbol); |
|||
text = v8::String::Concat(text, v8_hostname); |
|||
r->Set(text_symbol, text); |
|||
return ARES_SUCCESS; |
|||
} |
|||
|
|||
static int ParseRRData_NS(const unsigned char *abuf, int alen, const unsigned char *rr_data, int rr_len, v8::Local<v8::Object> &r) { |
|||
int status; |
|||
|
|||
char *hostname; |
|||
long len; |
|||
status = ares_expand_name(rr_data, abuf, alen, &hostname, &len); |
|||
if (status != ARES_SUCCESS) return status; |
|||
v8::Local<v8::String> v8_hostname = v8::String::New(hostname); |
|||
free(hostname); |
|||
if (len != rr_len) return ARES_EBADRESP; |
|||
|
|||
r->Set(text_symbol, v8_hostname); |
|||
|
|||
return ARES_SUCCESS; |
|||
} |
|||
|
|||
static int ParseRRData_SOA(const unsigned char *abuf, int alen, const unsigned char *rr_data, int rr_len, v8::Local<v8::Object> &r) { |
|||
int status; |
|||
long len; |
|||
|
|||
char *mname; /* primary NS */ |
|||
status = ares_expand_name(rr_data, abuf, alen, &mname, &len); |
|||
if (status != ARES_SUCCESS) return status; |
|||
v8::Local<v8::String> v8_mname = v8::String::New(mname); |
|||
free(mname); |
|||
if (len > rr_len) return ARES_EBADRESP; |
|||
rr_data += len; rr_len -= len; |
|||
|
|||
char *rname; /* owner mailbox */ |
|||
status = ares_expand_name(rr_data, abuf, alen, &rname, &len); |
|||
if (status != ARES_SUCCESS) return status; |
|||
v8::Local<v8::String> v8_rname = v8::String::New(rname); |
|||
free(rname); |
|||
if (len > rr_len) return ARES_EBADRESP; |
|||
rr_data += len; rr_len -= len; |
|||
|
|||
if (rr_len != 20) return ARES_EBADRESP; |
|||
|
|||
uint32_t serial, refresh, retry, expire, minimum; |
|||
memcpy(&serial, rr_data, sizeof(uint32_t)); serial = ntohl(serial); rr_data += sizeof(uint32_t); |
|||
memcpy(&refresh, rr_data, sizeof(uint32_t)); refresh = ntohl(refresh); rr_data += sizeof(uint32_t); |
|||
memcpy(&retry, rr_data, sizeof(uint32_t)); retry = ntohl(retry); rr_data += sizeof(uint32_t); |
|||
memcpy(&expire, rr_data, sizeof(uint32_t)); expire = ntohl(expire); rr_data += sizeof(uint32_t); |
|||
memcpy(&minimum, rr_data, sizeof(uint32_t)); minimum = ntohl(minimum); |
|||
|
|||
v8::Local<v8::Integer> |
|||
v8_serial = v8::Integer:: New(serial), |
|||
v8_refresh = v8::Integer:: New(refresh), |
|||
v8_retry = v8::Integer:: New(retry), |
|||
v8_expire = v8::Integer:: New(expire), |
|||
v8_minimum = v8::Integer:: New(minimum); |
|||
|
|||
v8::Local<v8::String> text = v8::String::Concat(v8_mname, space_symbol); |
|||
text = v8::String::Concat(text, v8_rname); text = v8::String::Concat(text, space_symbol); |
|||
text = v8::String::Concat(text, v8_serial->ToString()); text = v8::String::Concat(text, space_symbol); |
|||
text = v8::String::Concat(text, v8_refresh->ToString()); text = v8::String::Concat(text, space_symbol); |
|||
text = v8::String::Concat(text, v8_retry->ToString()); text = v8::String::Concat(text, space_symbol); |
|||
text = v8::String::Concat(text, v8_expire->ToString()); text = v8::String::Concat(text, space_symbol); |
|||
text = v8::String::Concat(text, v8_minimum->ToString()); |
|||
r->Set(text_symbol, text); |
|||
|
|||
r->Set(mname_symbol, v8_mname); |
|||
r->Set(rname_symbol, v8_rname); |
|||
r->Set(serial_symbol, v8_serial); |
|||
r->Set(refresh_symbol, v8_refresh); |
|||
r->Set(retry_symbol, v8_retry); |
|||
r->Set(expire_symbol, v8_expire); |
|||
r->Set(minimum_symbol, v8_minimum); |
|||
|
|||
return ARES_SUCCESS; |
|||
} |
|||
|
|||
static int ParseRRData_TXT(const unsigned char *, int , const unsigned char *rr_data, int rr_len, v8::Local<v8::Object> &r) { |
|||
int status, i; |
|||
|
|||
if (0 == rr_len) return ARES_EBADRESP; |
|||
|
|||
v8::Local<v8::Array> list = v8::Array::New(); |
|||
v8::Local<v8::String> s, text = v8::String::New(""), quote = v8::String::NewSymbol("\""); |
|||
for (i = 0; 0 < rr_len; i++) { |
|||
status = parse_char_string(rr_data, rr_len, s); |
|||
if (ARES_SUCCESS != status) return status; |
|||
|
|||
list->Set(v8::Integer::New(i), s); |
|||
|
|||
if (i != 0) text = v8::String::Concat(text, space_symbol); |
|||
text = v8::String::Concat(text, quote); |
|||
/* TODO: escaping */ |
|||
text = v8::String::Concat(text, s); |
|||
text = v8::String::Concat(text, quote); |
|||
} |
|||
|
|||
r->Set(data_symbol, list); |
|||
r->Set(text_symbol, text); |
|||
|
|||
return ARES_SUCCESS; |
|||
} |
|||
|
|||
static int ParseRRData_SRV(const unsigned char *abuf, int alen, const unsigned char *rr_data, int rr_len, v8::Local<v8::Object> &r) { |
|||
int status; |
|||
|
|||
if (rr_len < 6) return ARES_EBADRESP; |
|||
|
|||
uint16_t priority, weight, port; |
|||
memcpy(&priority, rr_data, sizeof(uint16_t)); priority = ntohl(priority); rr_data += sizeof(uint16_t); rr_len -= sizeof(uint16_t); |
|||
memcpy(&weight, rr_data, sizeof(uint16_t)); weight = ntohl(weight); rr_data += sizeof(uint16_t); rr_len -= sizeof(uint16_t); |
|||
memcpy(&port, rr_data, sizeof(uint16_t)); port = ntohl(port); rr_data += sizeof(uint16_t); rr_len -= sizeof(uint16_t); |
|||
|
|||
char *target; |
|||
long len; |
|||
status = ares_expand_name(rr_data, abuf, alen, &target, &len); |
|||
if (status != ARES_SUCCESS) return status; |
|||
v8::Local<v8::String> v8_target = v8::String::New(target); |
|||
free(target); |
|||
if (len != rr_len) return ARES_EBADRESP; |
|||
|
|||
v8::Local<v8::Integer> |
|||
v8_priority = v8::Integer:: New(priority), |
|||
v8_weight = v8::Integer:: New(weight), |
|||
v8_port = v8::Integer:: New(port); |
|||
|
|||
r->Set(priority_symbol, v8_priority); |
|||
r->Set(weight_symbol, v8_weight); |
|||
r->Set(port_symbol, v8_port); |
|||
r->Set(target_symbol, v8_target); |
|||
|
|||
v8::Local<v8::String> text = v8::String::Concat(v8_priority->ToString(), space_symbol); |
|||
text = v8::String::Concat(text, v8_weight->ToString()); text = v8::String::Concat(text, space_symbol); |
|||
text = v8::String::Concat(text, v8_port->ToString()); text = v8::String::Concat(text, space_symbol); |
|||
text = v8::String::Concat(text, v8_target); |
|||
r->Set(text_symbol, text); |
|||
|
|||
return ARES_SUCCESS; |
|||
} |
|||
|
|||
/* indented ones are deprecated/experimental */ |
|||
static RR_TYPE rr_types[] = { |
|||
{ "A", 1, ParseRRData_A, v8::Persistent<v8::String>() }, |
|||
{ "NS", 2, ParseRRData_NS, v8::Persistent<v8::String>() }, |
|||
{ "MD", 3, 0, v8::Persistent<v8::String>() }, |
|||
{ "MF", 4, 0, v8::Persistent<v8::String>() }, |
|||
{ "CNAME", 5, ParseRRData_NS, v8::Persistent<v8::String>() }, /* same RRDATA as NS */ |
|||
{ "SOA", 6, ParseRRData_SOA, v8::Persistent<v8::String>() }, |
|||
{ "MB", 7, 0, v8::Persistent<v8::String>() }, |
|||
{ "MG", 8, 0, v8::Persistent<v8::String>() }, |
|||
{ "MR", 9, 0, v8::Persistent<v8::String>() }, |
|||
{ "NULL", 10, 0, v8::Persistent<v8::String>() }, |
|||
{ "WKS", 11, 0, v8::Persistent<v8::String>() }, |
|||
{ "PTR", 12, ParseRRData_NS, v8::Persistent<v8::String>() }, /* same RRDATA as NS */ |
|||
{ "HINFO", 13, 0, v8::Persistent<v8::String>() }, |
|||
{ "MINFO", 14, 0, v8::Persistent<v8::String>() }, |
|||
{ "MX", 15, ParseRRData_MX, v8::Persistent<v8::String>() }, |
|||
{ "TXT", 16, ParseRRData_TXT, v8::Persistent<v8::String>() }, |
|||
{ "RP", 17, 0, v8::Persistent<v8::String>() }, |
|||
{ "AFSDB", 18, 0, v8::Persistent<v8::String>() }, |
|||
{ "SIG", 24, 0, v8::Persistent<v8::String>() }, |
|||
{ "KEY", 25, 0, v8::Persistent<v8::String>() }, |
|||
{ "AAAA", 28, ParseRRData_AAAA, v8::Persistent<v8::String>() }, |
|||
{ "LOC", 29, 0, v8::Persistent<v8::String>() }, |
|||
{ "SRV", 33, ParseRRData_SRV, v8::Persistent<v8::String>() }, |
|||
{ "NAPTR", 35, 0, v8::Persistent<v8::String>() }, |
|||
{ "KX", 36, 0, v8::Persistent<v8::String>() }, |
|||
{ "CERT", 37, 0, v8::Persistent<v8::String>() }, |
|||
{ "DNAME", 39, 0, v8::Persistent<v8::String>() }, |
|||
{ "OPT", 41, 0, v8::Persistent<v8::String>() }, |
|||
{ "APL", 42, 0, v8::Persistent<v8::String>() }, |
|||
{ "DS", 43, 0, v8::Persistent<v8::String>() }, |
|||
{ "SSHFP", 44, 0, v8::Persistent<v8::String>() }, |
|||
{ "IPSECKEY", 45, 0, v8::Persistent<v8::String>() }, |
|||
{ "RRSIG", 46, 0, v8::Persistent<v8::String>() }, |
|||
{ "NSEC", 47, 0, v8::Persistent<v8::String>() }, |
|||
{ "DNSKEY", 48, 0, v8::Persistent<v8::String>() }, |
|||
{ "DHCID", 49, 0, v8::Persistent<v8::String>() }, |
|||
{ "NSEC3", 50, 0, v8::Persistent<v8::String>() }, |
|||
{ "NSEC3PARAM", 51, 0, v8::Persistent<v8::String>() }, |
|||
{ "HIP", 55, 0, v8::Persistent<v8::String>() }, |
|||
{ "SPF", 99, 0, v8::Persistent<v8::String>() }, |
|||
{ "TKEY", 249, 0, v8::Persistent<v8::String>() }, |
|||
{ "TSIG", 250, 0, v8::Persistent<v8::String>() }, |
|||
{ "IXFR", 251, 0, v8::Persistent<v8::String>() }, |
|||
{ "AXFR", 252, 0, v8::Persistent<v8::String>() }, |
|||
{ "MAILB", 253, 0, v8::Persistent<v8::String>() }, |
|||
{ "MAILA", 254, 0, v8::Persistent<v8::String>() }, |
|||
{ "ANY", 255, 0, v8::Persistent<v8::String>() }, /* aka "*" */ |
|||
{ "TA", 32768, 0, v8::Persistent<v8::String>() }, |
|||
{ "DLV", 32769, 0, v8::Persistent<v8::String>() } |
|||
}; |
|||
|
|||
static RR_CLASS rr_classes[] = { |
|||
{ "IN", 1, v8::Persistent<v8::String>() }, /* the Internet */ |
|||
{ "CS", 2, v8::Persistent<v8::String>() }, /* the CSNET class (Obsolete - used only for examples in some obsolete RFCs) */ |
|||
{ "CH", 3, v8::Persistent<v8::String>() }, /* the CHAOS class */ |
|||
{ "HS", 4, v8::Persistent<v8::String>() }, /* Hesiod [Dyer 87] */ |
|||
{ "ANY", 255, v8::Persistent<v8::String>() } /* same value as in rr_type, so no name conflict */ |
|||
}; |
|||
|
|||
void Initialize(v8::Handle<v8::Object> target) { |
|||
v8::HandleScope scope; |
|||
|
|||
using namespace v8; |
|||
|
|||
int r = ares_library_init(ARES_LIB_INIT_ALL); |
|||
if (0 != r) { |
|||
// TODO
|
|||
// ThrowException(Exception::Error(String::New(ares_strerror(r))));
|
|||
assert(r == 0); |
|||
} |
|||
|
|||
question_symbol = NODE_PSYMBOL("question"); |
|||
answer_symbol = NODE_PSYMBOL("answer"); |
|||
authority_symbol = NODE_PSYMBOL("authority"); |
|||
additional_symbol = NODE_PSYMBOL("additional"); |
|||
|
|||
type_symbol = NODE_PSYMBOL("type"); |
|||
ntype_symbol = NODE_PSYMBOL("ntype"); |
|||
class_symbol = NODE_PSYMBOL("class"); |
|||
nclass_symbol = NODE_PSYMBOL("nclass"); |
|||
ttl_symbol = NODE_PSYMBOL("ttl"); |
|||
rdata_symbol = NODE_PSYMBOL("rdata"); |
|||
text_symbol = NODE_PSYMBOL("text"); |
|||
data_symbol = NODE_PSYMBOL("data"); |
|||
|
|||
priority_symbol = NODE_PSYMBOL("priority"); |
|||
weight_symbol = NODE_PSYMBOL("weight"); |
|||
port_symbol = NODE_PSYMBOL("port"); |
|||
name_symbol = NODE_PSYMBOL("name"); |
|||
exchange_symbol = NODE_PSYMBOL("exchange"); |
|||
target_symbol = NODE_PSYMBOL("target"); |
|||
|
|||
mname_symbol = NODE_PSYMBOL("mname"); |
|||
rname_symbol = NODE_PSYMBOL("rname"); |
|||
serial_symbol = NODE_PSYMBOL("serial"); |
|||
refresh_symbol = NODE_PSYMBOL("refresh"); |
|||
retry_symbol = NODE_PSYMBOL("retry"); |
|||
expire_symbol = NODE_PSYMBOL("expire"); |
|||
minimum_symbol = NODE_PSYMBOL("minimum"); |
|||
|
|||
space_symbol = NODE_PSYMBOL(" ");; |
|||
|
|||
v8::Local<v8::Object> types = v8::Object::New(); |
|||
for (unsigned int i = 0; i < sizeof(rr_types)/sizeof(rr_types[0]); i++) { |
|||
rr_types[i].symbol = NODE_PSYMBOL(rr_types[i].s); |
|||
target->Set(rr_types[i].symbol, v8::Integer::New(rr_types[i].n)); |
|||
} |
|||
for (unsigned int i = 0; i < sizeof(rr_classes)/sizeof(rr_classes[0]); i++) { |
|||
rr_classes[i].symbol = NODE_PSYMBOL(rr_classes[i].s); |
|||
target->Set(rr_classes[i].symbol, v8::Integer::New(rr_classes[i].n)); |
|||
} |
|||
} |
|||
|
|||
static inline const char *ares_errno_string(int errorno) { |
|||
#define ERRNO_CASE(e) case ARES_##e: return #e; |
|||
switch (errorno) { |
|||
ERRNO_CASE(SUCCESS) |
|||
ERRNO_CASE(ENODATA) |
|||
ERRNO_CASE(EFORMERR) |
|||
ERRNO_CASE(ESERVFAIL) |
|||
ERRNO_CASE(ENOTFOUND) |
|||
ERRNO_CASE(ENOTIMP) |
|||
ERRNO_CASE(EREFUSED) |
|||
ERRNO_CASE(EBADQUERY) |
|||
ERRNO_CASE(EBADNAME) |
|||
ERRNO_CASE(EBADFAMILY) |
|||
ERRNO_CASE(EBADRESP) |
|||
ERRNO_CASE(ECONNREFUSED) |
|||
ERRNO_CASE(ETIMEOUT) |
|||
ERRNO_CASE(EOF) |
|||
ERRNO_CASE(EFILE) |
|||
ERRNO_CASE(ENOMEM) |
|||
ERRNO_CASE(EDESTRUCTION) |
|||
ERRNO_CASE(EBADSTR) |
|||
ERRNO_CASE(EBADFLAGS) |
|||
ERRNO_CASE(ENONAME) |
|||
ERRNO_CASE(EBADHINTS) |
|||
ERRNO_CASE(ENOTINITIALIZED) |
|||
ERRNO_CASE(ELOADIPHLPAPI) |
|||
ERRNO_CASE(EADDRGETNETWORKPARAMS) |
|||
ERRNO_CASE(ECANCELLED) |
|||
default: |
|||
assert(0 && "Unhandled c-ares errno"); |
|||
return "(UNKNOWN)"; |
|||
} |
|||
} |
|||
|
|||
v8::Local<v8::Value> AresException(int status) { |
|||
v8::Local<v8::String> code = v8::String::NewSymbol(ares_errno_string(status)); |
|||
v8::Local<v8::String> message = v8::String::NewSymbol(ares_strerror(status)); |
|||
|
|||
v8::Local<v8::String> cons1 = v8::String::Concat(code, v8::String::NewSymbol(", ")); |
|||
v8::Local<v8::String> cons2 = v8::String::Concat(cons1, message); |
|||
|
|||
v8::Local<v8::Value> e = v8::Exception::Error(cons2); |
|||
|
|||
v8::Local<v8::Object> obj = e->ToObject(); |
|||
obj->Set(v8::String::NewSymbol("errno"), v8::Integer::New(status)); |
|||
|
|||
return e; |
|||
} |
|||
|
|||
static void set_type(v8::Local<v8::Object> &r, int rr_type) { |
|||
r->Set(ntype_symbol, v8::Integer::New(rr_type)); |
|||
for (unsigned int i = 0; i < sizeof(rr_types)/sizeof(rr_types[0]); i++) { |
|||
if (rr_type == rr_types[i].n) { |
|||
r->Set(type_symbol, rr_types[i].symbol); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
static void set_class(v8::Local<v8::Object> &r, int rr_class) { |
|||
r->Set(nclass_symbol, v8::Integer::New(rr_class)); |
|||
for (unsigned int i = 0; i < sizeof(rr_classes)/sizeof(rr_classes[0]); i++) { |
|||
if (rr_class == rr_classes[i].n) { |
|||
r->Set(class_symbol, rr_classes[i].symbol); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
static int parse_read_questions(const unsigned char *abuf, int alen, const unsigned char * &aptr, int count, v8::Local<v8::Array> list) { |
|||
int status; |
|||
long len; |
|||
|
|||
/* skip each question */ |
|||
for (int i = 0; i < count; i++) { |
|||
int rr_type, rr_class; |
|||
char *rr_name; |
|||
v8::Local<v8::Object> r = v8::Object::New(); |
|||
|
|||
/* Decode the RR up to the data field. */ |
|||
status = ares_expand_name(aptr, abuf, alen, &rr_name, &len); |
|||
if (status != ARES_SUCCESS) return status; |
|||
aptr += len; |
|||
if (aptr + QFIXEDSZ > abuf + alen) { |
|||
free(rr_name); |
|||
return ARES_EBADRESP; |
|||
} |
|||
|
|||
rr_type = DNS_RR_TYPE(aptr); |
|||
rr_class = DNS_RR_CLASS(aptr); |
|||
aptr += QFIXEDSZ; |
|||
|
|||
if (aptr > abuf + alen) { |
|||
free(rr_name); |
|||
return ARES_EBADRESP; |
|||
} |
|||
|
|||
r->Set(name_symbol, v8::String::New(rr_name)); |
|||
set_type(r, rr_type); |
|||
set_class(r, rr_class); |
|||
free(rr_name); |
|||
|
|||
list->Set(v8::Integer::New(i), r); |
|||
} |
|||
|
|||
return ARES_SUCCESS; |
|||
} |
|||
|
|||
static int parse_read_answers(const unsigned char *abuf, int alen, const unsigned char * &aptr, int count, v8::Local<v8::Array> list) { |
|||
int status; |
|||
long len; |
|||
|
|||
/* Examine each resource record (RR) in turn. */ |
|||
for (int i = 0; i < count; i++) { |
|||
int rr_type, rr_class, rr_len, rr_ttl; |
|||
char *rr_name; |
|||
const unsigned char *rr_data; |
|||
v8::Local<v8::Object> r = v8::Object::New(); |
|||
|
|||
/* Decode the RR up to the data field. */ |
|||
status = ares_expand_name(aptr, abuf, alen, &rr_name, &len); |
|||
if (status != ARES_SUCCESS) break; |
|||
aptr += len; |
|||
if (aptr + RRFIXEDSZ > abuf + alen) { |
|||
free(rr_name); |
|||
return ARES_EBADRESP; |
|||
} |
|||
|
|||
rr_type = DNS_RR_TYPE(aptr); |
|||
rr_class = DNS_RR_CLASS(aptr); |
|||
rr_ttl = DNS_RR_TTL(aptr); |
|||
rr_len = DNS_RR_LEN(aptr); |
|||
aptr += RRFIXEDSZ; |
|||
rr_data = aptr; |
|||
aptr += rr_len; |
|||
|
|||
if (aptr > abuf + alen) { |
|||
free(rr_name); |
|||
return ARES_EBADRESP; |
|||
} |
|||
|
|||
r->Set(name_symbol, v8::String::New(rr_name)); |
|||
set_class(r, rr_class); |
|||
r->Set(ttl_symbol, v8::Integer::New(rr_ttl)); |
|||
free(rr_name); |
|||
|
|||
r->Set(ntype_symbol, v8::Integer::New(rr_type)); |
|||
for (unsigned int t = 0; t < sizeof(rr_types)/sizeof(rr_types[0]); t++) { |
|||
if (rr_type == rr_types[t].n) { |
|||
r->Set(type_symbol, rr_types[t].symbol); |
|||
if (C_IN == rr_class && rr_types[t].parse_in) { |
|||
status = rr_types[t].parse_in(abuf, alen, rr_data, rr_len, r); |
|||
if (status != ARES_SUCCESS) return status; |
|||
} |
|||
break; |
|||
} |
|||
} |
|||
|
|||
r->Set(rdata_symbol, v8::String::New((const char*) rr_data, rr_len)); |
|||
|
|||
list->Set(v8::Integer::New(i), r); |
|||
} |
|||
|
|||
return ARES_SUCCESS; |
|||
} |
|||
|
|||
v8::Local<v8::Value> parse_dns_response(const unsigned char *abuf, int alen, int *pstatus) { |
|||
unsigned int qdcount, ancount, nscount, arcount; |
|||
int status; |
|||
const unsigned char *aptr; |
|||
|
|||
if (pstatus) *pstatus = ARES_SUCCESS; |
|||
|
|||
v8::Local<v8::Array> qd = v8::Array::New(), an = v8::Array::New(), ns = v8::Array::New(), ar = v8::Array::New(); |
|||
v8::Local<v8::Object> msg = v8::Object::New(); |
|||
|
|||
/* Give up if abuf doesn't have room for a header. */ |
|||
if (alen < HFIXEDSZ) { |
|||
status = ARES_EBADRESP; |
|||
goto error; |
|||
} |
|||
|
|||
/* Fetch the question and answer count from the header. */ |
|||
qdcount = DNS_HEADER_QDCOUNT(abuf); |
|||
ancount = DNS_HEADER_ANCOUNT(abuf); |
|||
nscount = DNS_HEADER_NSCOUNT(abuf); |
|||
arcount = DNS_HEADER_ARCOUNT(abuf); |
|||
if (qdcount != 1) { |
|||
status = ARES_EBADRESP; |
|||
goto error; |
|||
} |
|||
|
|||
aptr = abuf + HFIXEDSZ; |
|||
|
|||
status = parse_read_questions(abuf, alen, aptr, qdcount, qd); |
|||
if (status != ARES_SUCCESS) goto error; |
|||
|
|||
status = parse_read_answers(abuf, alen, aptr, ancount, an); |
|||
if (status != ARES_SUCCESS) goto error; |
|||
|
|||
status = parse_read_answers(abuf, alen, aptr, nscount, ns); |
|||
if (status != ARES_SUCCESS) goto error; |
|||
|
|||
status = parse_read_answers(abuf, alen, aptr, arcount, ar); |
|||
if (status != ARES_SUCCESS) goto error; |
|||
|
|||
msg->Set(question_symbol, qd); |
|||
msg->Set(answer_symbol, an); |
|||
msg->Set(authority_symbol, ns); |
|||
msg->Set(additional_symbol, ar); |
|||
|
|||
return msg; |
|||
|
|||
error: |
|||
if (pstatus) *pstatus = status; |
|||
return AresException(status); |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,14 @@ |
|||
#ifndef DNS_PARSER_H_ |
|||
#define DNS_PARSER_H_ |
|||
|
|||
#include <v8.h> |
|||
|
|||
namespace dns_parser { |
|||
|
|||
void Initialize(v8::Handle<v8::Object> target); |
|||
|
|||
v8::Local<v8::Value> parse_dns_response(const unsigned char *abuf, int alen, int *status); |
|||
v8::Local<v8::Value> AresException(int status); |
|||
|
|||
} |
|||
#endif // DNS_PARSER_H_
|
|||
@ -0,0 +1,17 @@ |
|||
srcdir = '.' |
|||
blddir = 'build' |
|||
VERSION = '0.0.1' |
|||
|
|||
def set_options(opt): |
|||
opt.tool_options('compiler_cxx') |
|||
|
|||
def configure(conf): |
|||
conf.check_tool('compiler_cxx') |
|||
conf.check_tool('node_addon') |
|||
|
|||
conf.env['CXXFLAGS'] += [ '-O2', '-g', '-Wall', '-Wshadow', '-W' ] |
|||
|
|||
def build(bld): |
|||
obj = bld.new_task_gen('cxx', 'shlib', 'node_addon') |
|||
obj.target = 'ares' |
|||
obj.source = 'ares.cc dns_parser.cc' |
|||
@ -0,0 +1,123 @@ |
|||
var ares = require('./ares/build/default/ares'); |
|||
|
|||
|
|||
function rec_toString() { |
|||
var out = ""; |
|||
|
|||
console.log(this); |
|||
|
|||
out += ";; Question Section:\n"; |
|||
for (var i = 0, len = this.question.length; i < len; i++) { |
|||
var q = this.question[i]; |
|||
out += q.name + "\t" + (q.class || q.nclass) + "\t" + (q.type || q.ntype) + "\n"; |
|||
} |
|||
|
|||
out += ";; Answer Section:\n"; |
|||
for (var i = 0, len = this.answer.length; i < len; i++) { |
|||
var r = this.answer[i]; |
|||
out += r.name + "\t" + r.ttl + "\t" + (r.class || r.nclass) + "\t" + (r.type || r.ntype) + "\t" + (r.text || '<unkown type>') + "\n"; |
|||
} |
|||
out += ";; Authority Section:\n"; |
|||
for (var i = 0, len = this.authority.length; i < len; i++) { |
|||
var r = this.authority[i]; |
|||
out += r.name + "\t" + r.ttl + "\t" + (r.class || r.nclass) + "\t" + (r.type || r.ntype) + "\t" + (r.text || '<unkown type>') + "\n"; |
|||
} |
|||
out += ";; Additional Section:\n"; |
|||
for (var i = 0, len = this.additional.length; i < len; i++) { |
|||
var r = this.additional[i]; |
|||
out += r.name + "\t" + r.ttl + "\t" + (r.class || r.nclass) + "\t" + (r.type || r.ntype) + "\t" + (r.text || '<unkown type>') + "\n"; |
|||
} |
|||
|
|||
return out; |
|||
} |
|||
|
|||
function newChannel(servers) { |
|||
var channel; |
|||
var watchers = {}; |
|||
var activeWatchers = {}; |
|||
var timer = new process.Timer(); |
|||
|
|||
timer.callback = function () { |
|||
channel.processFD(ares.SOCKET_BAD, ares.SOCKET_BAD); |
|||
updateTimer(); |
|||
} |
|||
|
|||
function updateTimer() { |
|||
timer.stop(); |
|||
|
|||
// Were just checking to see if activeWatchers is empty or not
|
|||
for (var socket in activeWatchers) { |
|||
if (activeWatchers.hasOwnProperty(socket)) { |
|||
var timeout = channel.timeout(-1); |
|||
|
|||
timer.start(timeout, 0); |
|||
// Short circuit the loop on first find.
|
|||
return; |
|||
} |
|||
} |
|||
} |
|||
|
|||
channel = new ares.Channel({SOCK_STATE_CB: function (socket, read, write) { |
|||
var watcher; |
|||
|
|||
if (socket in watchers) { |
|||
watcher = watchers[socket].watcher; |
|||
} else { |
|||
watcher = new process.IOWatcher(); |
|||
watchers[socket] = { read: read, write: write, watcher: watcher }; |
|||
|
|||
watcher.callback = function(read, write) { |
|||
channel.processFD(read ? socket : ares.SOCKET_BAD, write ? socket : ares.SOCKET_BAD); |
|||
updateTimer(); |
|||
} |
|||
} |
|||
|
|||
watcher.stop(); |
|||
|
|||
if (!(read || write)) { |
|||
delete activeWatchers[socket]; |
|||
return; |
|||
} else { |
|||
watcher.set(socket, read == 1, write == 1); |
|||
watcher.start(); |
|||
activeWatchers[socket] = watcher; |
|||
} |
|||
|
|||
updateTimer(); |
|||
}}); |
|||
if (servers) { |
|||
channel.setServers(servers); |
|||
} |
|||
/* wrapper mapping type strings to numerical values */ |
|||
channel._query = channel.query; |
|||
channel.query = function(domain, type, callback) { |
|||
channel._query(domain, ares[type], function(err, result) { |
|||
if (result) result.toString = rec_toString; |
|||
// console.log(result);
|
|||
callback(err, result); |
|||
}); |
|||
}; |
|||
|
|||
return channel; |
|||
}; |
|||
|
|||
var channel = newChannel(); |
|||
|
|||
exports.query = channel.query; |
|||
|
|||
exports.newChannel = newChannel; |
|||
|
|||
// ERROR CODES
|
|||
exports.NODATA = ares.NODATA; |
|||
exports.FORMERR = ares.FORMERR; |
|||
exports.BADRESP = ares.BADRESP; |
|||
exports.NOTFOUND = ares.NOTFOUND; |
|||
exports.BADNAME = ares.BADNAME; |
|||
exports.TIMEOUT = ares.TIMEOUT; |
|||
exports.CONNREFUSED = ares.CONNREFUSED; |
|||
exports.NOMEM = ares.NOMEM; |
|||
exports.DESTRUCTION = ares.DESTRUCTION; |
|||
|
|||
exports.NOTIMP = ares.NOTIMP; |
|||
exports.EREFUSED = ares.EREFUSED; |
|||
exports.SERVFAIL = ares.SERVFAIL; |
|||
@ -0,0 +1,36 @@ |
|||
|
|||
var http = require('http'); |
|||
var dns = require('./dns_native'); |
|||
var url = require('url'); |
|||
|
|||
http.createServer(function (req, res) { |
|||
var parts, type, domain, ns; |
|||
|
|||
parts = url.parse(req.url).pathname.slice(1).split("/"); |
|||
|
|||
if (parts.length > 2) { |
|||
type = parts[0]; |
|||
domain = parts[1]; |
|||
ns = [ parts[2] ]; |
|||
} else if (parts.length > 1) { |
|||
type = parts[0]; |
|||
domain = parts[1]; |
|||
} else if (parts.length > 0) { |
|||
type = 'A'; |
|||
domain = parts[0]; |
|||
} else { |
|||
res.writeHead(500, {'Content-Type': 'text/plain'}); |
|||
res.end("Wrong request\n"); |
|||
return; |
|||
} |
|||
res.writeHead(200, {'Content-Type': 'text/plain'}); |
|||
|
|||
c = dns.newChannel(ns); |
|||
c.query(domain, type, function(err, response) { |
|||
if (err) { |
|||
res.end("Error resolving '" + type + "/" + domain + "': " + err.message + "\n"); |
|||
} else { |
|||
res.end(domain + ":\n" + response.toString() + "\n"); |
|||
} |
|||
}); |
|||
}).listen(4000); |
|||
Loading…
Reference in new issue