GNContext.cpp

/*
 * Copyright (c) 2014, 2015, 2016, 2017, 2018, Verisign, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * * Neither the names of the copyright holders nor the
 *   names of its contributors may be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL Verisign, Inc. BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "GNContext.h"
#include "GNUtil.h"
#include "GNConstants.h"

#include <getdns/getdns_extra.h>
#include <arpa/inet.h>
#include <node_buffer.h>
#include <string.h>
#include <nan.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>

using namespace v8;

// Enum to distinguish which helper is being used.
typedef enum LookupType {
    GNAddress = 0,
    GNHostname,
    GNService
} LookupType;

// Callback data passed to getdns callback as userarg
typedef struct CallbackData {
    Nan::Callback* callback;
    GNContext* ctx;
} CallbackData;

// Helper to create an error object for lookup callbacks
static Local<Value> makeErrorObj(const char* msg, int code) {
    Local<Object> obj = Nan::New<Object>();
    Nan::Set(obj, Nan::New<String>("msg").ToLocalChecked(), Nan::New<String>(msg).ToLocalChecked());
    Nan::Set(obj, Nan::New<String>("code").ToLocalChecked(), Nan::New<Integer>(code));
    return obj;
}

static Local<Value> makeTypeErrorWithCode(const char* msg, int code) {
    Local<Object> error = Nan::TypeError(Nan::New<String>(msg).ToLocalChecked()).As<Object>();
    Nan::Set(error, Nan::New<String>("code").ToLocalChecked(), Nan::New<Integer>(code));
    return error;
}

// Helper to create an address dictionary from string
// Must be freed by the user
static getdns_dict* getdns_util_create_ip(const char* ip) {

    getdns_return_t r;
    const char* ipType;
    getdns_bindata ipData;
    uint8_t addrBuff[16];
    size_t addrSize = 0;
    getdns_dict* result = NULL;

    if (!ip) {
        return NULL;
    }
    // convert to bytes
    if (inet_pton(AF_INET, ip, &addrBuff) == 1) {
        addrSize = 4;
    } else if (inet_pton(AF_INET6, ip, &addrBuff) == 1) {
        addrSize = 16;
    }
    if (addrSize == 0) {
        return NULL;
    }
    // create the dict
    result = getdns_dict_create();
    if (!result) {
        return NULL;
    }
    // set fields
    ipType = addrSize == 4 ? "IPv4" : "IPv6";
    r = getdns_dict_util_set_string(result, (char*) "address_type", ipType);
    if (r != GETDNS_RETURN_GOOD) {
        getdns_dict_destroy(result);
        return NULL;
    }
    ipData.data = addrBuff;
    ipData.size = addrSize;
    r = getdns_dict_set_bindata(result, "address_data", &ipData);
    if (r != GETDNS_RETURN_GOOD) {
        getdns_dict_destroy(result);
        return NULL;
    }
    return result;
}

// Setter functions
typedef getdns_return_t (*getdns_context_uint8_t_setter)(getdns_context*, uint8_t);
typedef getdns_return_t (*getdns_context_uint16_t_setter)(getdns_context*, uint16_t);

static getdns_return_t setTransport(getdns_context* context, Local<Value> opt) {
    if (opt->IsNumber()) {
        uint32_t num = Nan::To<uint32_t>(opt).FromJust();
        getdns_return_t r = getdns_context_set_dns_transport(context, (getdns_transport_t) num);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setRedirects(getdns_context* context, Local<Value> opt) {
    if (opt->IsNumber()) {
        uint32_t num = Nan::To<uint32_t>(opt).FromJust();
        getdns_return_t r = getdns_context_set_follow_redirects(context, (getdns_redirects_t) num);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setTlsAuthentication(getdns_context* context, Local<Value> opt) {
    if (opt->IsNumber()) {
        uint32_t num = Nan::To<uint32_t>(opt).FromJust();
        getdns_return_t r = getdns_context_set_tls_authentication(context, (getdns_tls_authentication_t) num);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setTransportList(getdns_context* context, Local<Value> opt) {
    if (opt->IsArray()) {
        Local<Array> transportList = Local<Array>::Cast(opt);
        uint32_t numTransports = transportList->Length();
        // create a getdns_transport_list_t*
        getdns_transport_list_t* transports = new getdns_transport_list_t[numTransports];
        for (uint32_t i = 0; i < numTransports; ++i) {
            uint32_t transport = Nan::To<uint32_t>(Nan::Get(transportList, i).ToLocalChecked()).FromJust();
            transports[i] = (getdns_transport_list_t) transport;
        }
        // set it
        getdns_return_t r = getdns_context_set_dns_transport_list(context, numTransports, transports);
        // free up memory
        delete[] transports;
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setNamespaceList(getdns_context* context, Local<Value> opt) {
    if (opt->IsArray()) {
        Local<Array> namespaceList = Local<Array>::Cast(opt);
        uint32_t numNamespaces = namespaceList->Length();
        // create a getdns_namespace_list_t*
        getdns_namespace_t* namespaces = new getdns_namespace_t[numNamespaces];
        for (uint32_t i = 0; i < numNamespaces; ++i) {
            uint32_t ns = Nan::To<uint32_t>(Nan::Get(namespaceList, i).ToLocalChecked()).FromJust();
            namespaces[i] = (getdns_namespace_t) ns;
        }
        // set it
        getdns_return_t r = getdns_context_set_namespaces(context, numNamespaces, namespaces);
        // free up memory
        delete[] namespaces;
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setStub(getdns_context* context, Local<Value> opt) {
    if (opt->IsBooleanObject() || opt->IsBoolean()) {
        getdns_resolution_t resolution = opt->IsTrue() ? GETDNS_RESOLUTION_STUB : GETDNS_RESOLUTION_RECURSING;
        getdns_return_t r = getdns_context_set_resolution_type(context, resolution);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setResolutionType(getdns_context* context, Local<Value> opt) {
    if (opt->IsNumber()) {
        uint32_t num = Nan::To<uint32_t>(opt).FromJust();
        getdns_return_t r = getdns_context_set_resolution_type(context, (getdns_resolution_t) num);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}


static getdns_return_t setAppendName(getdns_context* context, Local<Value> opt) {
    if (opt->IsNumber()) {
        uint32_t num = Nan::To<uint32_t>(opt).FromJust();
        getdns_return_t r = getdns_context_set_append_name(context, (getdns_append_name_t) num);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

int gqldns_b64_pton(char const *src, uint8_t *target, size_t targsize)
{
        const uint8_t pad64 = 64; /* is 64th in the b64 array */
        const char* s = src;
        uint8_t in[4];
        size_t o = 0, incount = 0;

        while(*s) {
                /* skip any character that is not base64 */
                /* conceptually we do:
                const char* b64 =      pad'=' is appended to array
                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
                const char* d = strchr(b64, *s++);
                and use d-b64;
                */
                char d = *s++;
                if(d <= 'Z' && d >= 'A')
                        d -= 'A';
                else if(d <= 'z' && d >= 'a')
                        d = d - 'a' + 26;
                else if(d <= '9' && d >= '0')
                        d = d - '0' + 52;
                else if(d == '+')
                        d = 62;
                else if(d == '/')
                        d = 63;
                else if(d == '=')
                        d = 64;
                else    continue;
                in[incount++] = (uint8_t)d;
                if(incount != 4)
                        continue;

                /* process whole block of 4 characters into 3 output bytes */
                if(in[3] == pad64 && in[2] == pad64) { /* A B = = */
                        if(o+1 > targsize)
                                return -1;
                        target[o] = (in[0]<<2) | ((in[1]&0x30)>>4);
                        o += 1;
                        break; /* we are done */
                } else if(in[3] == pad64) { /* A B C = */
                        if(o+2 > targsize)
                                return -1;
                        target[o] = (in[0]<<2) | ((in[1]&0x30)>>4);
                        target[o+1]= ((in[1]&0x0f)<<4) | ((in[2]&0x3c)>>2);
                        o += 2;
                        break; /* we are done */
                } else {
                        if(o+3 > targsize)
                                return -1;
                        /* write xxxxxxyy yyyyzzzz zzwwwwww */
                        target[o] = (in[0]<<2) | ((in[1]&0x30)>>4);
                        target[o+1]= ((in[1]&0x0f)<<4) | ((in[2]&0x3c)>>2);
                        target[o+2]= ((in[2]&0x03)<<6) | in[3];
                        o += 3;
                }
                incount = 0;
        }
        return (int)o;
}

// parse string in format ^hmac-md5.tsigs.getdnsapi.net:16G69OTeXW6xSQ==
// to get the TSIG name and secret

void tsigHelper(getdns_dict *ipDict, char *buf) {
    char const *tsig_name_str = ""
         , *tsig_secret_str = ""
         , *tsig_algorithm_str = "";
    int            tsig_secret_size;
    uint8_t        tsig_secret_buf[256]; /* 4 times SHA512 */
    getdns_bindata tsig_secret;

    tsig_name_str = &buf[1];
    if ((buf = (char*)strchr(tsig_name_str, ':'))) {
        *buf = 0;
        tsig_secret_str = buf + 1;
        if ((buf = (char*)strchr(tsig_secret_str, ':'))) {
            *buf = 0;
            tsig_algorithm_str  = tsig_name_str;
            tsig_name_str = tsig_secret_str;
            tsig_secret_str  = buf + 1;
        }
     } else {
         tsig_name_str = "";
    }
    if (*tsig_name_str)
        getdns_dict_util_set_string(ipDict, (char*) "tsig_name", tsig_name_str);
    if (*tsig_algorithm_str)
        getdns_dict_util_set_string(ipDict, (char*) "tsig_algorithm", tsig_algorithm_str);
    if (*tsig_secret_str) {
        tsig_secret_size = gqldns_b64_pton(
            tsig_secret_str, tsig_secret_buf, sizeof(tsig_secret_buf));
            if (tsig_secret_size > 0) {
                tsig_secret.size = tsig_secret_size;
                tsig_secret.data = tsig_secret_buf;
                getdns_dict_set_bindata(ipDict, "tsig_secret", &tsig_secret);
            }
    }
}


// eg:  getdnsapi.net,com for www.verisignlabs
// Will first try to get the addresses for
// www.verisignlabs.getdnsapi.net and will then try and return the
// successfull lookup of the addresses for www.verisignlabs.com.
static getdns_return_t setSuffixesHelper(getdns_context* context, char* buf) {
    getdns_list *suffixes;
    char *suffix;
    getdns_bindata bindata;
    size_t j;

    if (!(suffixes = getdns_list_create())) {
        // TODO handle memory errors.
        return GETDNS_RETURN_MEMORY_ERROR;
    }
    suffix = strtok(buf, ",");
    j = 0;
    while (suffix) {
        bindata.size = strlen(suffix);
        bindata.data = (uint8_t *)suffix;
        (void) getdns_list_set_bindata(
            suffixes, j++, &bindata);
        suffix = strtok(NULL, ",");
   }
   getdns_return_t r = getdns_context_set_suffix(context, suffixes);
   getdns_list_destroy(suffixes);
   return r;
}

static getdns_return_t setSuffixes(getdns_context* context, Local<Value> opt) {
    if (opt->IsString()) {
         Nan::Utf8String suff(opt);
         return setSuffixesHelper(context, (char *)*suff);
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

#define EXAMPLE_PIN "pin-sha256=\"E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=\""

static getdns_return_t setPinset(getdns_context* context, Local<Value> opt) {
    if (opt->IsString()) {
        Nan::Utf8String pin(opt);
        getdns_dict *pubkey_pin = NULL;
        static getdns_list *pubkey_pinset = NULL;
        static size_t pincount = 0;
        getdns_return_t r = GETDNS_RETURN_GOOD;

        pubkey_pin = getdns_pubkey_pin_create_from_string(context, (char *)*pin);
        if (pubkey_pin == NULL) {
            // TODO: remove all fprintf.
            fprintf(stderr, "could not convert '%s' into a " \
                "public key pin.\n" \
                "Good pins look like: " EXAMPLE_PIN "\n" \
                "Please see RFC 7469 for details about " \
                "the format\n", (char *)*pin);
            return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
        }
        if (pubkey_pinset == NULL) {
          pubkey_pinset = getdns_list_create_with_context(context);
          if (r = getdns_list_set_dict(pubkey_pinset, pincount++, pubkey_pin), r) {
              // TODO: remove all fprintf.
              fprintf(stderr, "Failed to add pin to pinset (error %d: %s)\n",
                r, getdns_get_errorstr_by_id(r));
            }
            getdns_dict_destroy(pubkey_pin);
            pubkey_pin = NULL;
            return r;
       }
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setUpstreams(getdns_context* context, Local<Value> opt) {
    if (opt->IsArray()) {
        getdns_list* upstreams = getdns_list_create();
        Local<Array> values = Local<Array>::Cast(opt);
        for (uint32_t i = 0; i < values->Length(); ++i) {
            Local<Value> ipOrTuple = Nan::Get(values, i).ToLocalChecked();
            getdns_dict* ipDict = NULL;
            if (ipOrTuple->IsArray()) {
                // two tuple - first is IP, 2nd is port
                // optional tuple - TLS Hostname
                // optional tuple - TSIG name:algorithm:secret
                // optional tuple - Search Suffix
                Local<Array> tuple = Local<Array>::Cast(ipOrTuple);
                if (tuple->Length() > 0) {
                    Nan::Utf8String asciiStr(Nan::Get(tuple, 0).ToLocalChecked());
                    ipDict = getdns_util_create_ip(*asciiStr);
                    if (ipDict && tuple->Length() > 1 &&
                        Nan::Get(tuple, 1).ToLocalChecked()->IsNumber()) {
                        // port
                        uint32_t port = Nan::To<uint32_t>(Nan::Get(tuple, 1).ToLocalChecked()).FromJust();
                        getdns_dict_set_int(ipDict, "port", port);
                        // TLS hostname or TSIG (TODO: fix to allow this if optional port is not set)
                        Nan::Utf8String asciiBuffer(Nan::Get(tuple, 2).ToLocalChecked());

                        if (((char *)*asciiBuffer)[0] == '^') { // tsig
                            tsigHelper(ipDict, *asciiBuffer);
                        } else if (((char *)*asciiBuffer)[0] == '~') { // suffix
                            setSuffixesHelper(context, &((char *)*asciiBuffer)[1]);
                        }
                        else {
                            getdns_dict_util_set_string(ipDict, (char *)"tls_auth_name", *asciiBuffer);
                       }
                    }
                }
            } else {
                Nan::Utf8String asciiStr(ipOrTuple);
                if (((char *)*asciiStr)[0] == '^') { // tsig
                    tsigHelper(ipDict, *asciiStr);
                } else if (((char *)*asciiStr)[0] == '~') { // suffix
                    setSuffixesHelper(context, &((char *)*asciiStr)[1]);
                }
                else ipDict = getdns_util_create_ip(*asciiStr);
            }
            if (ipDict) {
                size_t len = 0;
                getdns_list_get_length(upstreams, &len);
                getdns_list_set_dict(upstreams, len, ipDict);
                getdns_dict_destroy(ipDict);
            } else {
                return GETDNS_RETURN_CONTEXT_UPDATE_FAIL;
            }
        }
        getdns_return_t r = getdns_context_set_upstream_recursive_servers(context, upstreams);
        getdns_list_destroy(upstreams);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}


static getdns_return_t setTimeout(getdns_context* context, Local<Value> opt) {
    if (opt->IsNumber()) {
        uint32_t num = Nan::To<uint32_t>(opt).FromJust();
        getdns_return_t r = getdns_context_set_timeout(context, num);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setDnssecAllowedSkew(getdns_context* context, Local<Value> opt) {
    if (opt->IsNumber()) {
        uint32_t num = Nan::To<uint32_t>(opt).FromJust();
        getdns_return_t r = getdns_context_set_dnssec_allowed_skew(context, num);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setUseThreads(getdns_context* context, Local<Value> opt) {
    if (opt->IsBooleanObject() || opt->IsBoolean()) {
        int val = opt->IsTrue() ? 1 : 0;
        getdns_return_t r = getdns_context_set_use_threads(context, val);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

static getdns_return_t setReturnDnssecStatus(getdns_context* context, Local<Value> opt) {
    if (opt->IsBooleanObject() || opt->IsBoolean()) {
        int val = opt->IsTrue() ? GETDNS_EXTENSION_TRUE : GETDNS_EXTENSION_FALSE;
        getdns_return_t r = getdns_context_set_return_dnssec_status(context, val);
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}

// set alternate root servers from a file passed in
static getdns_return_t setDnsRootServers(getdns_context* context, Local<Value> opt)
{
    FILE *fh;
    getdns_list *hints = NULL;

    if (opt->IsString()) {
         Nan::Utf8String roots(opt);
        if (!(fh = fopen((char *)*roots, "r"))) {
            // TODO: remove all fprintf.
            fprintf(stderr, "Could not open %s\n", (char *)*roots);
            return GETDNS_RETURN_GENERIC_ERROR;
        }
        if (getdns_fp2rr_list(fh, &hints, NULL, 3600)) {
            // TODO: remove all fprintf.
            fprintf(stderr,"Could not parse "
                "\"%s\"\n", (char *)*roots);
            return GETDNS_RETURN_GENERIC_ERROR;
        }
        fclose(fh);
        getdns_return_t r = getdns_context_set_dns_root_servers(context, hints);
        getdns_list_destroy(hints);
        hints = NULL;
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}


// Read the location of the Trust anchor and pass it to getdns.
// TODO: actually pass in the trust anchor.
static getdns_return_t setTrustAnchor(getdns_context *context, Local<Value> opt)
{
    FILE *fh;
    getdns_list *tas = NULL;

    if (opt->IsString()) {
         Nan::Utf8String ta(opt);

       if (!(fh = fopen((char *)*ta, "r"))) {
           fprintf(stderr, "Could not open %s\n", (char *)*ta);
           return GETDNS_RETURN_GENERIC_ERROR;
        }
        if (getdns_fp2rr_list(fh, &tas, NULL, 3600)) {
            // TODO: remove all fprintf.
            fprintf(stderr,"Could not parse "
                "\"%s\"\n", (char *)*ta);
            return GETDNS_RETURN_GENERIC_ERROR;
        }
        fclose(fh);
        getdns_return_t r = getdns_context_set_dnssec_trust_anchors(context, tas);
        getdns_list_destroy(tas);
        tas = NULL;
        return r;
    }
    return GETDNS_RETURN_INVALID_PARAMETER;
}


typedef getdns_return_t (*context_setter)(getdns_context* context, Local<Value> opt);
typedef struct OptionSetter {
    const char* opt_name;
    context_setter setter;
} OptionSetter;

static OptionSetter SETTERS[] = {
    { "stub", setStub },
    { "upstreams", setUpstreams },
    { "upstream_recursive_servers", setUpstreams },
    { "timeout", setTimeout },
    { "dnssecallowedskew", setDnssecAllowedSkew },
    { "use_threads", setUseThreads },
    { "return_dnssec_status", setReturnDnssecStatus },
    { "dns_transport", setTransport},
    { "follow_redirects", setRedirects},
    { "tls_authentication", setTlsAuthentication},
    { "resolution_type", setResolutionType },
    { "append_name", setAppendName },
    { "namespaces", setNamespaceList },
    { "suffix", setSuffixes },
    { "pinset", setPinset },
    { "trustanchor", setTrustAnchor },
    { "dnsrootserver", setDnsRootServers },
    { "dns_transport_list", setTransportList },
    { "dns_root_server", setDnsRootServers }
};

static size_t NUM_SETTERS = sizeof(SETTERS) / sizeof(OptionSetter);

typedef struct Uint8OptionSetter {
    const char* opt_name;
    getdns_context_uint8_t_setter setter;
} Uint8OptionSetter;

static Uint8OptionSetter UINT8_OPTION_SETTERS[] = {
    { "edns_extended_rcode", getdns_context_set_edns_extended_rcode },
    { "edns_version", getdns_context_set_edns_version },
    { "edns_do_bit", getdns_context_set_edns_do_bit }
};

static size_t NUM_UINT8_SETTERS = sizeof(UINT8_OPTION_SETTERS) / sizeof(Uint8OptionSetter);

typedef struct Uint16OptionSetter {
    const char* opt_name;
    getdns_context_uint16_t_setter setter;
} Uint16OptionSetter;

static Uint16OptionSetter UINT16_OPTION_SETTERS[] = {
    { "limit_outstanding_queries", getdns_context_set_limit_outstanding_queries },
    { "edns_maximum_udp_payloadSize", getdns_context_set_edns_maximum_udp_payload_size }
};

static size_t NUM_UINT16_SETTERS = sizeof(UINT16_OPTION_SETTERS) / sizeof(Uint16OptionSetter);

// End setters
NAN_GETTER(GNContext::GetContextValue) {
    // context has no getters yet
    info.GetReturnValue().Set(Nan::New<Integer>(-1));
}
NAN_SETTER(GNContext::SetContextValue) {
    // walk setters
    Nan::Utf8String name(property);
    GNContext* ctx = Nan::ObjectWrap::Unwrap<GNContext>(info.This());
    if (!ctx) {
        return Nan::ThrowError("Context is invalid.");
    }
    size_t s = 0;
    for (s = 0; s < NUM_SETTERS; ++s) {
        if (strcmp(SETTERS[s].opt_name, *name) == 0) {
            getdns_return_t r = SETTERS[s].setter(ctx->context_, value);
            if (r != GETDNS_RETURN_GOOD) {
                Local<Value> typeError = makeTypeErrorWithCode(*name, r);
                return Nan::ThrowError(typeError);
            }
            return;
        }
    }
    if (!value->IsNumber()) {
        Local<Value> typeError = makeTypeErrorWithCode(*name, GETDNS_RETURN_INVALID_PARAMETER);
        return Nan::ThrowError(typeError);
    }
    for (s = 0; s < NUM_UINT8_SETTERS; ++s) {
        if (strcmp(UINT8_OPTION_SETTERS[s].opt_name, *name) == 0) {
            uint32_t optVal = Nan::To<uint32_t>(value).FromJust();
            getdns_return_t r = UINT8_OPTION_SETTERS[s].setter(ctx->context_, (uint8_t)optVal);
            if (r != GETDNS_RETURN_GOOD) {
                Local<Value> typeError = makeTypeErrorWithCode(*name, r);
                return Nan::ThrowError(typeError);
            }
            return;
        }
    }
    for (s = 0; s < NUM_UINT16_SETTERS; ++s) {
        if (strcmp(UINT16_OPTION_SETTERS[s].opt_name, *name) == 0) {
            uint32_t optVal = Nan::To<uint32_t>(value).FromJust();
            getdns_return_t r = UINT16_OPTION_SETTERS[s].setter(ctx->context_, (uint16_t)optVal);
            if (r != GETDNS_RETURN_GOOD) {
                Local<Value> typeError = makeTypeErrorWithCode(*name, r);
                return Nan::ThrowError(typeError);
            }
            return;
        }
    }
    Local<Value> typeError = makeTypeErrorWithCode(*name, GETDNS_RETURN_INVALID_PARAMETER);
    return Nan::ThrowError(typeError);
}

void GNContext::InitProperties(Local<Object> ctx) {
    size_t s = 0;
    for (s = 0; s < NUM_SETTERS; ++s) {
        Nan::SetAccessor(ctx, Nan::New<String>(SETTERS[s].opt_name).ToLocalChecked(),
            GNContext::GetContextValue, GNContext::SetContextValue);
    }
    for (s = 0; s < NUM_UINT8_SETTERS; ++s) {
        Nan::SetAccessor(ctx, Nan::New<String>(UINT8_OPTION_SETTERS[s].opt_name).ToLocalChecked(),
            GNContext::GetContextValue, GNContext::SetContextValue);
    }
    for (s = 0; s < NUM_UINT16_SETTERS; ++s) {
        Nan::SetAccessor(ctx, Nan::New<String>(UINT16_OPTION_SETTERS[s].opt_name).ToLocalChecked(),
            GNContext::GetContextValue, GNContext::SetContextValue);

    }
}

GNContext::GNContext() : context_(NULL) { }
GNContext::~GNContext() {
    if (context_ != NULL) {
        getdns_context_destroy(context_);
        context_ = NULL;
    }

    // NOTE: same cleanup as in ObjectWrap.
    {
        if (persistent().IsEmpty()) {
          return;
        }

        persistent().ClearWeak();
        persistent().Reset();
    }
}

void GNContext::ApplyOptions(Local<Object> self, Local<Value> optsV) {
    if(optsV->IsUndefined()) {
        // NOTE: can be called without options.
        return;
    }
    if (!GNUtil::isDictionaryObject(optsV)) {
        Local<Value> typeError = makeTypeErrorWithCode("options", GETDNS_RETURN_INVALID_PARAMETER);
        return Nan::ThrowError(typeError);
    }
    Local<Object> selfObj = Nan::To<v8::Object>(self).ToLocalChecked();
    Local<Array> selfNames = Nan::GetOwnPropertyNames(selfObj).ToLocalChecked();
    Local<Object> opts = Nan::To<v8::Object>(optsV).ToLocalChecked();
    Local<Array> names = Nan::GetOwnPropertyNames(opts).ToLocalChecked();
    // check options for matching properties
    if (names->Length() > selfNames->Length()) {
        Local<Value> typeError = makeTypeErrorWithCode("options", GETDNS_RETURN_INVALID_PARAMETER);
        return Nan::ThrowError(typeError);
    }
    bool found = false;
    for(unsigned int i = 0; i < names->Length(); i++) {
        found = false;
        Nan::Utf8String nameVal(Nan::Get(names, i).ToLocalChecked());
        for(unsigned int j = 0; j < selfNames->Length(); j++) {
            Nan::Utf8String selfNameVal(Nan::Get(selfNames, j).ToLocalChecked());
            if (strcmp(*nameVal, *selfNameVal) == 0) {
                found = true;
                break;
            }
        }
        if(!found) {
            Local<Value> typeError = makeTypeErrorWithCode(*nameVal, GETDNS_RETURN_INVALID_PARAMETER);
            return Nan::ThrowError(typeError);
        }
    }
    // walk properties
    Nan::TryCatch try_catch;
    for(unsigned int i = 0; i < names->Length(); i++) {
        Local<Value> nameVal = Nan::Get(names, i).ToLocalChecked();
        Local<Value> opt = Nan::Get(opts, nameVal).ToLocalChecked();
        Nan::Set(self, nameVal, opt);
        if (try_catch.HasCaught()) {
            try_catch.ReThrow();
            return;
        }
    }
}

// Module initialization
void GNContext::Init(Local<Object> target) {
    // prepare context object template
    Local<FunctionTemplate> jsContextTpl = Nan::New<FunctionTemplate>(GNContext::New);
    jsContextTpl->SetClassName(Nan::New<String>("Context").ToLocalChecked());
    jsContextTpl->InstanceTemplate()->SetInternalFieldCount(1);
    // Prototype
    Nan::SetPrototypeMethod(jsContextTpl, "lookup", GNContext::Lookup);
    Nan::SetPrototypeMethod(jsContextTpl, "cancel", GNContext::Cancel);
    Nan::SetPrototypeMethod(jsContextTpl, "destroy", GNContext::Destroy);
    // Helpers - delegate to the same function w/ different data
    Nan::SetPrototypeTemplate(jsContextTpl, "getAddress",
        Nan::New<FunctionTemplate>(GNContext::HelperLookup, Nan::New<Integer>(GNAddress)));
    Nan::SetPrototypeTemplate(jsContextTpl, "getHostname",
        Nan::New<FunctionTemplate>(GNContext::HelperLookup, Nan::New<Integer>(GNHostname)));
    Nan::SetPrototypeTemplate(jsContextTpl, "getService",
        Nan::New<FunctionTemplate>(GNContext::HelperLookup, Nan::New<Integer>(GNService)));

    // Add the constructor
    Nan::Set(target, Nan::New<String>("Context").ToLocalChecked(), Nan::GetFunction(jsContextTpl).ToLocalChecked());

    // Export constants
    GNConstants::Init(target);
}

// Explicity destroy the context
NAN_METHOD(GNContext::Destroy) {
    GNContext* ctx = Nan::ObjectWrap::Unwrap<GNContext>(info.Holder());
    if (!ctx) {
        Nan::ThrowError(Nan::New<String>("Context is invalid.").ToLocalChecked());
        return;
    }
    getdns_context_destroy(ctx->context_);
    ctx->context_ = NULL;
    info.GetReturnValue().Set(Nan::True());
}

// Create a context (new op)
NAN_METHOD(GNContext::New) {
    if (info.IsConstructCall()) {
        if (info.Length() > 1) {
            // NOTE: duplicated in getdns.js and GNContext.cpp.
            // TODO: use new getdns.Context(...args) when not supporting node.js v4 anymore.
            Local<Value> typeError = makeTypeErrorWithCode("Too many arguments.", GETDNS_RETURN_INVALID_PARAMETER);
            return Nan::ThrowError(typeError);
        }

        // new obj
        GNContext* ctx = new GNContext();
        getdns_return_t r = getdns_context_create(&ctx->context_, 1);
        if (r != GETDNS_RETURN_GOOD) {
            // Failed to create an underlying context
            delete ctx;
            return Nan::ThrowError(Nan::New<String>("Unable to create GNContext.").ToLocalChecked());
        }

        // Attach the context to node
        bool attached = GNUtil::attachContextToNode(ctx->context_);
        if (!attached) {
            // Bail
            delete ctx;
            return Nan::ThrowError(Nan::New<String>("Unable to attach to Node.").ToLocalChecked());
        }
        ctx->Wrap(info.This());
        // add setters
        GNContext::InitProperties(info.This());
        // Apply options if needed
        if (info.Length() == 1) {
            // could throw an
            Nan::TryCatch try_catch;
            GNContext::ApplyOptions(info.This(), info[0]);
            if (try_catch.HasCaught()) {
                // Need to bail
                try_catch.ReThrow();
                return;
            }
        }
        info.GetReturnValue().Set(info.This());
    } else {
        return Nan::ThrowError(Nan::New<String>("Must use new.").ToLocalChecked());
    }
    return;
}

void GNContext::Callback(getdns_context *context,
                         getdns_callback_type_t cbType,
                         getdns_dict *response,
                         void *userArg,
                         getdns_transaction_t transId) {
    Nan::HandleScope scope;
    CallbackData* data = static_cast<CallbackData*>(userArg);
    // Setup the callback arguments
    Local<Value> argv[3];
    if (cbType == GETDNS_CALLBACK_COMPLETE) {
        argv[0] = Nan::Null();
        argv[1] = GNUtil::convertToJSObj(response);
        getdns_dict_destroy(response);
    } else {
        argv[0] = makeErrorObj("Lookup failed.", cbType);
        argv[1] = Nan::Null();
    }
    Nan::TryCatch try_catch;
    argv[2] = GNUtil::convertToBuffer(&transId, 8);
    data->callback->Call(Nan::GetCurrentContext()->Global(), 3, argv);

    if (try_catch.HasCaught())
        Nan::FatalException(try_catch);

    // Unref
    data->ctx->Unref();
    delete data->callback;
    delete data;
}

// Cancel a req.  Expect it to be a transaction id as a buffer
NAN_METHOD(GNContext::Cancel) {
    GNContext* ctx = Nan::ObjectWrap::Unwrap<GNContext>(info.Holder());
    if (!ctx || !ctx->context_) {
        info.GetReturnValue().Set(Nan::False());
    }
    if (info.Length() < 1) {
        info.GetReturnValue().Set(Nan::False());
    }
    if (node::Buffer::Length(info[0]) != 8) {
        info.GetReturnValue().Set(Nan::False());
    }
    uint64_t transId;
    memcpy(&transId, node::Buffer::Data(info[0]), 8);
    getdns_return_t r = getdns_cancel_callback(ctx->context_, transId);
    info.GetReturnValue().Set(r == GETDNS_RETURN_GOOD ? Nan::True() : Nan::False());
}

// Handle getdns general
NAN_METHOD(GNContext::Lookup) {
    // name, type, and callback are required
    if (info.Length() < 3) {
        return Nan::ThrowTypeError(Nan::New<String>("At least 3 arguments are required.").ToLocalChecked());
    }
    // last arg must be a callback
    Local<Value> last = info[info.Length() - 1];
    if (!last->IsFunction()) {
        return Nan::ThrowTypeError(Nan::New<String>("Final argument must be a function.").ToLocalChecked());
    }
    Local<Function> localCb = Local<Function>::Cast(last);
    GNContext* ctx = Nan::ObjectWrap::Unwrap<GNContext>(info.Holder());
    if (!ctx || !ctx->context_) {
        Local<Value> err = makeErrorObj("Context is invalid", GETDNS_RETURN_GENERIC_ERROR);
        Local<Value> cbArgs[] = { err };
        Nan::MakeCallback(Nan::GetCurrentContext()->Global(), localCb, 1, cbArgs);
        return;
    }
    // take first arg and make it a string
    Nan::Utf8String name(info[0]);
    // second arg must be a number
    if (!info[1]->IsNumber()) {
        Local<Value> err = makeErrorObj("Second argument must be a number", GETDNS_RETURN_INVALID_PARAMETER);
        Local<Value> cbArgs[] = { err };
        Nan::MakeCallback(Nan::GetCurrentContext()->Global(), localCb, 1, cbArgs);
        return;
    }
    uint16_t type = (uint16_t) Nan::To<uint32_t>(info[1]).FromJust();

    // optional third arg is an object
    getdns_dict* extension = NULL;
    if (info.Length() > 3 && info[2]->IsObject()) {
        extension = GNUtil::convertToDict(Nan::To<v8::Object>(info[2]).ToLocalChecked());
    }

    // create callback data
    CallbackData *data = new CallbackData();
    data->callback = new Nan::Callback(localCb);
    data->ctx = ctx;
    ctx->Ref();

    // issue a query
    getdns_transaction_t transId;
    getdns_return_t r = getdns_general(ctx->context_, *name, type,
                                       extension, data, &transId,
                                       GNContext::Callback);
    if (r != GETDNS_RETURN_GOOD) {
        // fail
        delete data->callback;
        data->ctx->Unref();
        delete data;

        Local<Value> err = makeErrorObj("Error issuing query", r);
        Local<Value> cbArgs[] = { err };
        Nan::MakeCallback(Nan::GetCurrentContext()->Global(), localCb, 1, cbArgs);
        return;
    }
    // done.
    info.GetReturnValue().Set(GNUtil::convertToBuffer(&transId, 8));
}

// Common function to handle getdns_address/service/hostname
NAN_METHOD(GNContext::HelperLookup) {
    // first argument is a string
    // last argument must be a callback
    // optional argument of extensions
    // name, type, and callback are required
    if (info.Length() < 2) {
        return Nan::ThrowTypeError(Nan::New<String>("At least 2 arguments are required.").ToLocalChecked());
    }
    // last arg must be a callback
    Local<Value> last = info[info.Length() - 1];
    if (!last->IsFunction()) {
        return Nan::ThrowTypeError(Nan::New<String>("Final argument must be a function.").ToLocalChecked());
    }
    Local<Function> localCb = Local<Function>::Cast(last);
    GNContext* ctx = Nan::ObjectWrap::Unwrap<GNContext>(info.Holder());
    if (!ctx || !ctx->context_) {
        Local<Value> err = makeErrorObj("Context is invalid", GETDNS_RETURN_GENERIC_ERROR);
        Local<Value> cbArgs[] = { err };
        Nan::Call(localCb, Nan::GetCurrentContext()->Global(), 1, cbArgs);
        return;
    }
    // take first arg and make it a string
    Nan::Utf8String name(info[0]);

    // 2nd arg could be extensions
    // optional third arg is an object
    getdns_dict* extension = NULL;
    if (info.Length() > 2 && info[1]->IsObject()) {
        extension = GNUtil::convertToDict(Nan::To<v8::Object>(info[1]).ToLocalChecked());
    }

    // figure out what called us
    uint32_t funcType = Nan::To<uint32_t>(info.Data()).FromJust();
    // create callback data
    CallbackData *data = new CallbackData();
    data->callback = new Nan::Callback(localCb);
    data->ctx = ctx;
    ctx->Ref();

    getdns_transaction_t transId;
    getdns_return_t r = GETDNS_RETURN_GOOD;
    if (funcType == GNAddress) {
        r = getdns_address(ctx->context_, *name, extension,
                           data, &transId, GNContext::Callback);
    } else if(funcType == GNService) {
        r = getdns_service(ctx->context_, *name, extension,
                           data, &transId, GNContext::Callback);
    } else {
        // hostname
        // convert to a dictionary..
        getdns_dict* ip = getdns_util_create_ip(*name);
        if (ip) {
            r = getdns_hostname(ctx->context_, ip, extension,
                                data, &transId, GNContext::Callback);
            getdns_dict_destroy(ip);
        } else {
            r = GETDNS_RETURN_GENERIC_ERROR;
        }
    }

    if (r != GETDNS_RETURN_GOOD) {
        // fail
        delete data->callback;
        data->ctx->Unref();
        delete data;

        Local<Value> err = makeErrorObj("Error issuing query", r);
        Local<Value> cbArgs[] = { err };
        Nan::MakeCallback(Nan::GetCurrentContext()->Global(), localCb, 1, cbArgs);
        return;
    }
    // done. return as buffer
    info.GetReturnValue().Set(GNUtil::convertToBuffer(&transId, 8));
}

// Init the module
NODE_MODULE(getdns, GNContext::Init)