dns.coffee

###

dnschain
http://dnschain.net

Copyright (c) 2014 okTurtles Foundation

This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.

###

# TODO: go through 'TODO's!

Packet = require('native-dns-packet')

module.exports = (dnschain) ->
    # expose these into our namespace
    for k of dnschain.globals
        eval "var #{k} = dnschain.globals.#{k};"

    QTYPE_NAME = dns2.consts.QTYPE_TO_NAME
    NAME_QTYPE = dns2.consts.NAME_TO_QTYPE
    NAME_RCODE = dns2.consts.NAME_TO_RCODE
    RCODE_NAME = dns2.consts.RCODE_TO_NAME

    class DNSServer
        constructor: (@dnschain) ->
            @log = gNewLogger 'DNS'
            @log.debug "Loading DNSServer..."
            @method = gConf.get 'dns:oldDNSMethod'
            @rateLimiting = gConf.get 'rateLimiting:dns'

            # this is just for development testing of NODE_DNS method
            # dns.setServers ['8.8.8.8']

            if @method is gConsts.oldDNS.NODE_DNS
                @log.warn "Using".bold.red, "oldDNSMethod = NODE_DNS".bold, "method is strongly discouraged!".bold.red
                if dns.getServers?
                    blacklist = _.intersection ['127.0.0.1', '::1', 'localhost'], dns.getServers()
                    if blacklist.length > 0
                        gErr "Cannot use NODE_DNS method when system DNS lists %j as a resolver! Would lead to infinite loop!", blacklist
                else
                    gErr "Node's DNS module doesn't have 'getServers'. Please upgrade NodeJS."
            else if @method is gConsts.oldDNS.NO_OLD_DNS
                @log.warn "oldDNSMethod is set to refuse queries for traditional DNS!".bold
            else if @method is gConsts.oldDNS.NO_OLD_DNS_EVER
                @log.warn "oldDNSMethod is set to refuse *ALL* queries for traditional DNS (even if the blockchain wants us to)!".bold.red
            else if @method isnt gConsts.oldDNS.NATIVE_DNS
                gErr "No such oldDNSMethod: #{@method}"

            gFillWithRunningChecks @

        start: ->
            @startCheck (cb) =>
                @server = dns2.createServer() or gErr "dns2 create"
                @server.on 'socketError', (err) -> gErr err
                @server.on 'request', (req, res) =>
                    domain = req.question[0]?.name
                    if domain
                        domain = domain.split(".")
                        if domain.length > 3
                            # if there are more than 3 parts to the domain, we use the last
                            # letter of the fourth, and the full parts of the last three
                            # This isn't perfect, especially because of:
                            # https://publicsuffix.org/list/effective_tld_names.dat
                            #
                            # See: https://github.com/okTurtles/dnschain/issues/107 !
                            domain = [domain[-4..][0][-1..]].concat(domain[-3..]).join '.'
                        else
                            domain = domain[-3..].join '.'

                        key = "dns-#{req.address.address}-#{domain}"
                        @log.debug gLineInfo("creating bottleneck on: #{key}")
                        limiter = gThrottle key, => new Bottleneck _.at(@rateLimiting, ['maxConcurrent', 'minTime', 'highWater', 'strategy'])...
                        limiter.changePenalty(@rateLimiting.penalty).submit (@callback.bind @), req, res, null
                    else
                        @log.warn gLineInfo('received empty request!'), {req:req}
                # // end on 'request'
                @server.on 'listening', =>
                    @log.info 'started DNS', gConf.get 'dns'
                    cb()
                @server.serve gConf.get('dns:port'), gConf.get('dns:host')

        shutdown: ->
            @shutdownCheck (cb) =>
                if @server
                    @server.on 'close', cb
                    @server.close()
                else
                    @log.warn gLineInfo '@server not defined!'
                    cb()

        # (Notes on 'native-dns' version <=0.6.x, which I'd like to see changed.)
        #
        # Both `req` and `res` are of type `Packet` (the subclass, as explained next).
        #
        # The packet that's inside of 'native-dns' inherits from the one inside of 'native-dns-packet'.
        # It adds two extra fields (at this time of writing):
        #
        # - address: added by Server.prototype.handleMessage and the Packet subclass constructor
        # - _socket: added by the Packet subclass constructor in lib/packet.js
        #
        # `req` and `res` are both instances of this subclass of 'Packet'.
        # They also have the same 'question' field.
        #
        # See also:
        # - native-dns/lib/server.js
        # - native-dns/lib/packet.js
        # - native-dns-packet/packet.js
        #
        # Separately, there is a 'Request' class defined in 'native-dns/lib/client.js'.
        # Like 'Packet', it has a 'send' method.
        # To understand it see these functions in 'lib/pending.js':
        #
        # - SocketQueue.prototype._dequeue   (sending)
        # - SocketQueue.prototype._onmessage (receiving)
        #
        # When you create a 'new Request' and send it, it will first create a 'new Packet' and copy
        # some of the values from the request into it, and then call 'send' on that.
        # Similarly, in receiving a reply from a Request instance, handle the 'message' event, which
        # will create a new Packet (the subclass, with the _socket field) from the received data.
        #
        # See also:
        # - native-dns/lib/client.js
        # - native-dns/lib/pending.js
        #
        # Ideally we want to be able to reuse the 'req' received here and pass it along
        # to oldDNSLookup without having to recreate or copy any information.
        # See: https://github.com/tjfontaine/node-dns/issues/69
        #
        # Even more ideally we want to be able to simply pass along the raw data without having to parse it.
        # See: https://github.com/okTurtles/dnschain/issues/6
        #
        callback: (req, res, cb) ->
            # answering multiple questions in a query appears to be problematic,
            # and few servers do it, so we only answer the first question:
            # https://stackoverflow.com/questions/4082081/requesting-a-and-aaaa-records-in-single-dns-query
            # At some point we may still want to support this though.
            q = req.question[qIdx=0]
            q.name = q.name.toLowerCase()

            ttl = Math.floor(Math.random() * 3600) + 30 # TODO: pick an appropriate TTL value!
            @log.debug "received question", q

            if (datastore = @dnschain.chainsTLDs[q.name.split('.').pop()])
                @log.debug gLineInfo("resolving via #{datastore.name}..."), {domain:q.name, q:q}

                if not datastore.resources.key?
                    @log.error gLineInfo "#{datastore.name} does not implement `key` resource!".bold
                    return @sendErr(res, NAME_RCODE.SERVFAIL, cb)
                args = [datastore.name , "key", q.name, null, null, {}] # args conform to the datastore API
                resourceRequest = (cb) =>
                    datastore.resources.key.call datastore, args[2..]..., cb
                @dnschain.cache.resolveResource datastore, resourceRequest, JSON.stringify(args), (err, result) =>
                    if err? or !result
                        @log.error gLineInfo("#{datastore.name} failed to resolve"), {err:err?.message, result:result, q:q}
                        @sendErr res, null, cb
                    else
                        @log.debug gLineInfo("#{datastore.name} resolved query"), {q:q, d:q.name, result:result}

                        if not (handler = datastore.dnsHandler[QTYPE_NAME[q.type]])
                            @log.warn gLineInfo("no such DNS handler!"), {datastore: datastore.name, q:q, type: QTYPE_NAME[q.type]}
                            return @sendErr res, NAME_RCODE.NOTIMP, cb

                        handler.call datastore, req, res, qIdx, result.data, (errCode) =>
                            try
                                if errCode
                                    @sendErr res, errCode, cb
                                else
                                    @sendRes res, cb
                            catch e
                                @log.error e.stack
                                @log.error gLineInfo("exception in handler"), {q:q, result:result}
                                return @sendErr res, NAME_RCODE.SERVFAIL, cb

            else if S(q.name).endsWith '.dns'
                res.answer.push gIP2type(q.name,ttl,QTYPE_NAME[q.type])(gConf.get 'dns:externalIP')
                @log.debug gLineInfo('cb|.dns'), {q:q, answer:res.answer}
                @sendRes res, cb
            else
                @log.debug gLineInfo("resolving #{q.name} via oldDNS"), {q:q}
                @dnschain.cache.resolveOldDNS req, (code, packet) =>
                    _.assign res, packet
                    if code
                        @sendErr res, code, cb
                    else
                        @sendRes res, cb
        # / end callback

        oldDNSLookup: (req, cb) ->
            res = new Packet()
            sig = "oldDNS{#{@method}}"
            q = req.question[0]
            filterRes = (p) ->
                _.pick p, ['edns_version', 'edns_options', 'edns', 'answer', 'authority', 'additional']

            @log.debug {fn:sig+':start', q:q}

            if @method is gConsts.oldDNS.NATIVE_DNS
                success = false
                # TODO: retry in TCP-mode on truncated response (like `dig`)
                #       See: https://github.com/tjfontaine/node-dns/issues/70
                req2 = new dns2.Request
                    question: q
                    server  : gConf.get 'dns:oldDNS'
                    try_edns: q.type is NAME_QTYPE.ANY or req.edns?

                # 'answer' is a Packet subclass with the .address and ._socket fields
                req2.on 'message', (err, answer) =>
                    if err?
                        @log.error gLineInfo("should not have an error here!"), {err:err?.message, answer:answer}
                        req2.DNSErr ?= err
                    else
                        @log.debug gLineInfo('message'), {answer:answer}
                        success = true
                        res = answer

                req2.on 'error', (err={message:'unknown error'}) =>
                    @log.error gLineInfo('oldDNS lookup error'), {err:err?.message}
                    req2.DNSErr = err

                req2.on 'timeout', (err={message:'timeout'}) =>
                    @log.warn gLineInfo('oldDNS timeout'), {err:err}
                    req2.DNSErr = err

                req2.on 'end', =>
                    if success
                        @log.debug gLineInfo('success!'), {q:q, res: _.omit(res, '_socket')}
                        cb null, filterRes(res)
                    else
                        # TODO: this is noisy.
                        #       also make log output look good in journalctl
                        # you can log IP with: res._socket.remote.address
                        @log.warn gLineInfo('oldDNS lookup failed'), {q:q, err:req2.DNSErr}
                        cb NAME_RCODE.SERVFAIL, filterRes(res)
                # @log.debug {fn:"beforesend", req:req2}
                req2.send()
            else if @method is gConsts.oldDNS.NODE_DNS
                dns.resolve q.name, QTYPE_NAME[q.type], (err, addrs) =>
                    if err
                        @log.debug {fn:sig+':fail', q:q, err:err?.message}
                        cb NAME_RCODE.SERVFAIL, filterRes(res)
                    else
                        # USING THIS METHOD IS DISCOURAGED BECAUSE IT DOESN'T
                        # PROVIDE US WITH CORRECT TTL VALUES!!
                        # TODO: pick an appropriate TTL value!
                        ttl = Math.floor(Math.random() * 3600) + 30
                        res.answer.push (addrs.map gIP2type(q.name, ttl, QTYPE_NAME[q.type]))...
                        @log.debug {fn:sig+':success', answer:res.answer, q:q.name}
                        cb null, filterRes(res)
            else
                # refuse all such queries
                cb NAME_RCODE.REFUSED, res

        sendRes: (res, cb) ->
            try
                @log.debug gLineInfo("sending response!"), {res:_.omit(res, '_socket')}
                res.send()
                cb()
            catch e
                @log.error gLineInfo('error trying send response back!'), {msg:e.message, res:_.omit(res, '_socket'), stack:e.stack}
                cb e

        sendErr: (res, code=NAME_RCODE.SERVFAIL, cb) ->
            try
                res.header.rcode = code
                @log.debug gLineInfo(), {code:code, name:RCODE_NAME[code]}
                res.send()
            catch e
                @log.error gLineInfo('exception sending error back!'), e.stack
            cb()
            false # helps other functions pass back an error value