public:

static void Initialize(Handle<Object> target);

private:

static Persistent<FunctionTemplate> constructor_template;

static Handle<Value> New(const Arguments& args);

static Handle<Value> Query(const Arguments& args);

static Handle<Value> GetHostByName(const Arguments& args);

static Handle<Value> GetHostByAddr(const Arguments& args);

static Handle<Value> Timeout(const Arguments& args);

static Handle<Value> ProcessFD(const 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);

typedef void (*ParseAnswerCb)(QueryArg*, unsigned char*, int);

Persistent<Function> js_cb;

ParseAnswerCb parse_cb;

QueryArg(const Local<Value> &js_cb, ParseAnswerCb parse_cb)

: js_cb(Persistent<Function>::New(Local<Function>::Cast(js_cb)))

, parse_cb(parse_cb) {}

~QueryArg() {

js_cb.Dispose();

}

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(String::NewSymbol("SOCKET_BAD"), Integer::New(ARES_SOCKET_BAD));

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->Set(String::NewSymbol("AF_INET"), Integer::New(AF_INET));

target->Set(String::NewSymbol("AF_INET6"), Integer::New(AF_INET6));

target->Set(String::NewSymbol("A"), Integer::New(ns_t_a));

target->Set(String::NewSymbol("AAAA"), Integer::New(ns_t_aaaa));

target->Set(String::NewSymbol("MX"), Integer::New(ns_t_mx));

target->Set(String::NewSymbol("NS"), Integer::New(ns_t_ns));

target->Set(String::NewSymbol("PTR"), Integer::New(ns_t_ptr));

target->Set(String::NewSymbol("TXT"), Integer::New(ns_t_txt));

target->Set(String::NewSymbol("SRV"), Integer::New(ns_t_srv));

target->Set(String::NewSymbol("CNAME"), Integer::New(ns_t_cname));

target->Set(String::NewSymbol("NODATA"), Integer::New(ARES_ENODATA));

target->Set(String::NewSymbol("FORMERR"), Integer::New(ARES_EFORMERR));

target->Set(String::NewSymbol("BADRESP"), Integer::New(ARES_EBADRESP));

target->Set(String::NewSymbol("NOTFOUND"), Integer::New(ARES_ENOTFOUND));

target->Set(String::NewSymbol("BADNAME"), Integer::New(ARES_EBADNAME));

target->Set(String::NewSymbol("TIMEOUT"), Integer::New(ARES_ETIMEOUT));

target->Set(String::NewSymbol("CONNREFUSED"), Integer::New(ARES_ECONNREFUSED));

target->Set(String::NewSymbol("NOMEM"), Integer::New(ARES_ENOMEM));

target->Set(String::NewSymbol("DESTRUCTION"), Integer::New(ARES_EDESTRUCTION));

// Only occur if the ARES_FLAG_NOCHECKRESP flag was specified

target->Set(String::NewSymbol("NOTIMP"), Integer::New(ARES_ENOTIMP));

target->Set(String::NewSymbol("EREFUSED"), Integer::New(ARES_EREFUSED));

target->Set(String::NewSymbol("SERVFAIL"), Integer::New(ARES_ESERVFAIL));

Channel::Initialize(target);

Local<Array> addresses = Array::New();

char ip[INET6_ADDRSTRLEN];

for (int i = 0; hostent->h_addr_list[i]; ++i) {

inet_ntop(hostent->h_addrtype, hostent->h_addr_list[i], ip, sizeof(ip));

Local<String> address = String::New(ip);

addresses->Set(Integer::New(i), address);

}

return addresses;

Local<Array> names = Array::New();

for (int i = 0; hostent->h_aliases[i]; ++i) {

Local<String> address = String::New(hostent->h_aliases[i]);

names->Set(Integer::New(i), address);

}

return names;

HandleScope scope;

Local<String> code = String::NewSymbol(ares_errno_string(status));

Local<String> message = String::NewSymbol(ares_strerror(status));

Local<String> cons1 = String::Concat(code, String::NewSymbol(", "));

Local<String> cons2 = String::Concat(cons1, message);

Local<Value> e = Exception::Error(cons2);

Local<Object> obj = e->ToObject();

obj->Set(String::NewSymbol("errno"), Integer::New(status));

TryCatch try_catch;

cb->Call(v8::Context::GetCurrent()->Global(), 1, &e);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

int status,

int timeouts,

struct hostent *hostent) {

HandleScope scope;

Persistent<Function> *cb = cb_unwrap(data);

if (status != ARES_SUCCESS) {

ResolveError(*cb, status);

cb_destroy(cb);

return;

}

TryCatch try_catch;

Local<Array> addresses = HostEntToAddresses(hostent);

Local<Value> argv[2] = { Local<Value>::New(Null()), addresses};

(*cb)->Call(v8::Context::GetCurrent()->Global(), 2, argv);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

cb_destroy(cb);

int status,

int timeouts,

struct hostent *hostent) {

HandleScope scope;

Persistent<Function> *cb = cb_unwrap(data);

if (status != ARES_SUCCESS) {

ResolveError(*cb, status);

cb_destroy(cb);

return;

}

TryCatch try_catch;

Local<Array> names = HostEntToNames(hostent);

Local<Value> argv[2] = { Local<Value>::New(Null()), names };

(*cb)->Call(v8::Context::GetCurrent()->Global(), 2, argv);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

cb_destroy(cb);

TryCatch try_catch;

cb->Call(v8::Context::GetCurrent()->Global(), argc, argv);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

HandleScope scope;

hostent* host;

int status = ares_parse_a_reply(abuf, alen, &host, NULL, NULL);

if (status != ARES_SUCCESS) {

ResolveError(arg->js_cb, status);

return;

}

Local<Array> addresses = HostEntToAddresses(host);

ares_free_hostent(host);

Local<Value> argv[2] = { Local<Value>::New(Null()), addresses };

cb_call(arg->js_cb, 2, argv);

HandleScope scope;

hostent* host;

int status = ares_parse_aaaa_reply(abuf, alen, &host, NULL, NULL);

if (status != ARES_SUCCESS) {

ResolveError(arg->js_cb, status);

return;

}

Local<Array> addresses = HostEntToAddresses(host);

ares_free_hostent(host);

Local<Value> argv[2] = { Local<Value>::New(Null()), addresses};

cb_call(arg->js_cb, 2, argv);

HandleScope scope;

hostent* host;

int status = ares_parse_a_reply(abuf, alen, &host, NULL, NULL);

if (status != ARES_SUCCESS) {

ResolveError(arg->js_cb, status);

return;

}

// a CNAME lookup always returns a single record but

// it's probably best to follow the common API here

Local<Array> addresses = Array::New(1);

addresses->Set(0, String::New(host->h_name));

ares_free_hostent(host);

Local<Value> argv[2] = { Local<Value>::New(Null()), addresses };

cb_call(arg->js_cb, 2, argv);

HandleScope scope;

struct ares_mx_reply *mx_out;

int status = ares_parse_mx_reply(abuf, alen, &mx_out);

if (status != ARES_SUCCESS) {

ResolveError(arg->js_cb, status);

return;

}

Local<Array> mx_records = Array::New();

struct ares_mx_reply *current = mx_out;

for (int i = 0; current; ++i, current = current->next) {

Local<Object> mx = Object::New();

mx->Set(priority_symbol, Integer::New(current->priority));

mx->Set(exchange_symbol, String::New(current->host));

mx_records->Set(Integer::New(i), mx);

}

ares_free_data(mx_out);

Local<Value> argv[2] = { Local<Value>::New(Null()), mx_records };

cb_call(arg->js_cb, 2, argv);

HandleScope scope;

hostent* host;

int status = ares_parse_ns_reply(abuf, alen, &host);

if (status != ARES_SUCCESS) {

ResolveError(arg->js_cb, status);

return;

}

Local<Array> names = HostEntToNames(host);

ares_free_hostent(host);

Local<Value> argv[2] = { Local<Value>::New(Null()), names };

cb_call(arg->js_cb, 2, argv);

HandleScope scope;

struct ares_srv_reply *srv_out;

int status = ares_parse_srv_reply(abuf, alen, &srv_out);

if (status != ARES_SUCCESS) {

ResolveError(arg->js_cb, status);

return;

}

Local<Array> srv_records = Array::New();

struct ares_srv_reply *current = srv_out;

for (int i = 0; current; ++i, current = current->next) {

Local<Object> srv = Object::New();

srv->Set(priority_symbol, Integer::New(current->priority));

srv->Set(weight_symbol, Integer::New(current->weight));

srv->Set(port_symbol, Integer::New(current->port));

srv->Set(name_symbol, String::New(current->host));

srv_records->Set(Integer::New(i), srv);

}

ares_free_data(srv_out);

Local<Value> argv[2] = { Local<Value>::New(Null()), srv_records };

cb_call(arg->js_cb, 2, argv);

HandleScope scope;

struct ares_txt_reply *txt_out;

int status = ares_parse_txt_reply(abuf, alen, &txt_out);

if (status != ARES_SUCCESS) {

ResolveError(arg->js_cb, status);

return;

}

Local<Array> txt_records = Array::New();

struct ares_txt_reply *current = txt_out;

for (int i = 0; current; ++i, current = current->next) {

Local<String> txt = String::New(reinterpret_cast<char*>(current->txt));

txt_records->Set(Integer::New(i), txt);

}

ares_free_data(txt_out);

Local<Value> argv[2] = { Local<Value>::New(Null()), txt_records };

cb_call(arg->js_cb, 2, argv);

int status,

int timeouts,

unsigned char* abuf,

int alen) {

QueryArg *query_arg = static_cast<QueryArg*>(arg);

HandleScope scope;

if (status != ARES_SUCCESS) {

ResolveError(query_arg->js_cb, status);

delete query_arg;

return;

}

query_arg->parse_cb(query_arg, abuf, alen);

delete query_arg;

HandleScope scope;

Local<FunctionTemplate> t = FunctionTemplate::New(Channel::New);

constructor_template = Persistent<FunctionTemplate>::New(t);

constructor_template->InstanceTemplate()->SetInternalFieldCount(1);

constructor_template->SetClassName(String::NewSymbol("Channel"));

NODE_SET_PROTOTYPE_METHOD(constructor_template, "getHostByName", Channel::GetHostByName);

NODE_SET_PROTOTYPE_METHOD(constructor_template, "getHostByAddr", Channel::GetHostByAddr);

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

target->Set(String::NewSymbol("Channel"), constructor_template->GetFunction());

callback_symbol = NODE_PSYMBOL("callback");

if (!args.IsConstructCall()) {

return FromConstructorTemplate(constructor_template, args);

}

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 ThrowException(Exception::TypeError(

String::New("Bad Options Argument")));

}

Local<Object> options_o = Local<Object>::Cast(args[0]);

Local<Value> cb = options_o->Get(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();

HandleScope scope;

Channel *c = ObjectWrap::Unwrap<Channel>(args.Holder());

assert(c);

if (!args[0]->IsString()) {

return ThrowException(Exception::TypeError(

String::New("First argument must be a name")));

}

if (!args[1]->IsInt32()) {

return ThrowException(Exception::TypeError(

String::New("Second argument must be a query type")));

}

if (!args[2]->IsFunction()) {

return ThrowException(Exception::TypeError(

String::New("Third argument must be a callback")));

}

String::Utf8Value name(args[0]->ToString());

int type = args[1]->Int32Value();

QueryArg::ParseAnswerCb parse_cb;

switch(type) {

case ns_t_a:

parse_cb = ParseAnswerA;

break;

case ns_t_aaaa:

parse_cb = ParseAnswerAAAA;

break;

case ns_t_mx:

parse_cb = ParseAnswerMX;

break;

case ns_t_ns:

parse_cb = ParseAnswerNS;

break;

case ns_t_txt:

parse_cb = ParseAnswerTXT;

break;

case ns_t_srv:

parse_cb = ParseAnswerSRV;

break;

case ns_t_cname:

parse_cb = ParseAnswerCNAME;

break;

case ns_t_ptr:

int length, family;

char address_b[sizeof(struct in6_addr)];

if (inet_pton(AF_INET, *name, &address_b) == 1) {

length = sizeof(struct in_addr);

family = AF_INET;

} else if (inet_pton(AF_INET6, *name, &address_b) == 1) {

length = sizeof(struct in6_addr);

family = AF_INET6;

} else {

return ThrowException(Exception::Error(String::New("Invalid IP address")));

}

ares_gethostbyaddr(c->channel, address_b, length, family, HostByAddrCb, cb_persist(args[2]));

return Undefined();

default:

return ThrowException(Exception::Error(

String::New("Unsupported query type")));

}

QueryArg *query_arg = new QueryArg(args[2], parse_cb);

ares_query(c->channel, *name, ns_c_in, type, QueryCb, query_arg);

return Undefined();

HandleScope scope;

Channel *c = ObjectWrap::Unwrap<Channel>(args.Holder());

assert(c);

if (!args[0]->IsString()) {

return ThrowException(Exception::Error(

String::New("First argument must be a address")));

}

if (!args[1]->IsInt32()) {

return ThrowException(Exception::Error(

String::New("Second argument must be an address family")));

}

if (!args[2]->IsFunction()) {

return ThrowException(Exception::Error(

String::New("Third argument must be a callback")));

}

int family = args[1]->Int32Value();

if (family != AF_INET6 && family != AF_INET) {

return ThrowException(Exception::Error(

String::New("Unsupported address family")));

}

String::Utf8Value address_s(args[0]->ToString());

char address_b[sizeof(struct in6_addr)];

int r = inet_pton(family, *address_s, address_b);

if (r != 1) {

return ThrowException(Exception::Error(

String::New("Invalid network address")));

}

int length;

if (family == AF_INET6)

length = sizeof(struct in6_addr);

else

length = sizeof(struct in_addr);

ares_gethostbyaddr(c->channel, address_b, length, family, HostByAddrCb, cb_persist(args[2]));

return Undefined();

HandleScope scope;

Channel *c = ObjectWrap::Unwrap<Channel>(args.Holder());

assert(c);

if (!args[0]->IsString()) {

return ThrowException(Exception::Error(

String::New("First argument must be a name")));

}

if (!args[1]->IsInt32()) {

return ThrowException(Exception::Error(

String::New("Second argument must be a family")));

}

if (!args[2]->IsFunction()) {

return ThrowException(Exception::Error(

String::New("Third argument must be a callback")));

}

int family = args[1]->Int32Value();

if (family != AF_INET6 && family != AF_INET) {

return ThrowException(Exception::Error(

String::New("Unsupported address family")));

}

String::Utf8Value name(args[0]->ToString());

ares_gethostbyname(c->channel, *name, family, HostByNameCb, cb_persist(args[2]));

return Undefined();

HandleScope scope;

Channel *c = ObjectWrap::Unwrap<Channel>(args.Holder());

assert(c);

if (!args[0]->IsInt32()) {

return ThrowException(Exception::Error(

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, &maxtv, &tvbuf);

return scope.Close(Integer::New(ret->tv_sec * 1000 + ret->tv_usec / 1000));

HandleScope scope;

Channel *c = ObjectWrap::Unwrap<Channel>(args.Holder());

assert(c);

int read_fd, write_fd;

if (!args[0]->IsInt32()) {

return ThrowException(Exception::Error(

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 ThrowException(Exception::Error(

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

Channel *c = static_cast<Channel*>(data);

HandleScope scope;

Local<Value> callback_v = c->handle_->Get(callback_symbol);

if (!callback_v->IsFunction()) return;

Local<Function> callback = Local<Function>::Cast(callback_v);

Local<Value> argv[3];

argv[0] = Integer::New(sock);

argv[1] = Integer::New(read);

argv[2] = Integer::New(write);

TryCatch try_catch;

callback->Call(c->handle_, 3, argv);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}