node_dns_patch.cc

static void AfterResolveMX(struct dns_ctx *ctx,
                           struct dns_rr_mx *result,
                           void *data) {
  assert(ctx == &dns_defctx);

  HandleScope scope;

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

  if (result == NULL) {
    ResolveError(cb);
    cb_destroy(cb);
    return;
  }

  Local<Array> addresses = Array::New(result->dnsmx_nrr);
  for (int i = 0; i < result->dnsmx_nrr; i++) {
    HandleScope loop_scope;

    char ip[INET_ADDRSTRLEN];
    //dns_ntop(AF_INET, &(result->dnsmx_addr[i]), ip, INET_ADDRSTRLEN);
    Local<String> address = String::New(result->dnsmx_mx[i].name);

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

  Local<Value> argv[3] = { addresses, Integer::New(54), String::New("devknowledge.com") };

  TryCatch try_catch;

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

  if (try_catch.HasCaught()) {
    FatalException(try_catch);
  }

  cb_destroy(cb);
}

static Handle<Value> ResolveMX(const Arguments& args) {
  return ResolveA(DNS_T_MX, args);
}

static Handle<Value> ResolveA(int type, const Arguments& args) {
  HandleScope scope;

  if (args.Length() == 0 || !args[0]->IsString()) {
    return ThrowException(Exception::Error(
          String::New("Argument must be a string.")));
  }

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

  struct dns_query *query;
  switch (type) {
    case DNS_T_A:
      query = dns_submit_a4(NULL, *name, 0, AfterResolveA4, cb_persist(args[1]));
      break;

    case DNS_T_AAAA:
      query = dns_submit_a6(NULL, *name, 0, AfterResolveA6, cb_persist(args[1]));
      break;

    case DNS_T_MX:
      query = dns_submit_mx(NULL, *name, 0, AfterResolveMX, cb_persist(args[1]));
      break;

    default:
      return ThrowException(Exception::Error(String::New("Unsupported type")));
  }

  assert(query);  // TODO(ry) better error handling.

  maybe_start();

  return Undefined();
}

void DNS::Initialize(Handle<Object> target) {
  if (dns_init(NULL, 0) < 0) {
    fprintf(stderr, "Error initializing UDNS context\n");
    exit(-2);
  }

  int fd = dns_open(NULL);

  ev_io_init(&io_watcher, ioevent, fd, EV_READ);
  ev_init(&timer_watcher, timeout);

  HandleScope scope;

  errno_symbol = NODE_PSYMBOL("errno");

  target->Set(String::NewSymbol("TEMPFAIL"), Integer::New(DNS_E_TEMPFAIL));
  target->Set(String::NewSymbol("PROTOCOL"), Integer::New(DNS_E_PROTOCOL));
  target->Set(String::NewSymbol("NXDOMAIN"), Integer::New(DNS_E_NXDOMAIN));
  target->Set(String::NewSymbol("NODATA"), Integer::New(DNS_E_NODATA));
  target->Set(String::NewSymbol("NOMEM"), Integer::New(DNS_E_NOMEM));
  target->Set(String::NewSymbol("BADQUERY"), Integer::New(DNS_E_BADQUERY));

  Local<FunctionTemplate> resolve4 = FunctionTemplate::New(ResolveA4);
  target->Set(String::NewSymbol("resolve4"), resolve4->GetFunction());

  Local<FunctionTemplate> resolve6 = FunctionTemplate::New(ResolveA6);
  target->Set(String::NewSymbol("resolve6"), resolve6->GetFunction());

  Local<FunctionTemplate> resolvemx = FunctionTemplate::New(ResolveMX);
  target->Set(String::NewSymbol("resolvemx"), resolvemx->GetFunction());

  Local<FunctionTemplate> reverse = FunctionTemplate::New(Reverse);
  target->Set(String::NewSymbol("reverse"), reverse->GetFunction());
}