dns.h

/*
 * Copyright (c) 2017, Matias Fontanini
 * 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.
 * 
 * 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 THE COPYRIGHT
 * OWNER OR CONTRIBUTORS 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.
 *
 */

#ifndef TINS_DNS_H
#define TINS_DNS_H

#include <stdint.h>
#include <vector>
#include <cstring>
#include <string>
#include <map>
#include <tins/macros.h>
#include <tins/pdu.h>
#include <tins/endianness.h>

// Undefining some macros that conflict with some symbols here. 
// Eventually, the conflicting names will be removed, but until then
// this is the best we can do.
// - IN is defined by winsock2.h
// - CERT is defined by openssl
#undef IN
#undef CERT

namespace Tins {
namespace Memory {

class InputMemoryStream;

} // Memory

class IPv4Address;
class IPv6Address;

class TINS_API DNS : public PDU {
public:
    static const PDU::PDUType pdu_flag = PDU::DNS;
    
    enum QRType {
        QUERY = 0,
        RESPONSE = 1
    };
    
    enum QueryType {
        A = 1,
        NS,
        MD,
        MF,
        CNAME,
        SOA,
        MB,
        MG,
        MR,
        NULL_R,
        WKS,
        PTR,
        HINFO,
        MINFO,
        MX,
        TXT,
        RP,
        AFSDB,
        X25,
        ISDN,
        RT,
        NSAP,
        NSAP_PTR,
        SIG,
        KEY,
        PX,
        GPOS,
        AAAA,
        LOC,
        NXT,
        EID,
        NIMLOC,
        SRV,
        ATMA,
        NAPTR,
        KX,
        CERTIFICATE,
        A6,
        DNAM,
        SINK,
        OPT,
        APL,
        DS,
        SSHFP,
        IPSECKEY,
        RRSIG,
        NSEC,
        DNSKEY,
        DHCID,
        NSEC3,
        NSEC3PARAM,
        CERT = CERTIFICATE
    };
    
    enum QueryClass {
        INTERNET = 1,
        CHAOS    = 3,
        HESIOD   = 4,
        IN = INTERNET,
        CH = CHAOS,
        HS = HESIOD,
        ANY = 255
    };
    
    class query {
    public:
        #if TINS_IS_CXX11
        query(std::string nm, QueryType tp, QueryClass cl) 
        : name_(std::move(nm)), type_(tp), qclass_(cl) {}
        #else
        query(const std::string& nm, QueryType tp, QueryClass cl) 
        : name_(nm), type_(tp), qclass_(cl) {}
        #endif
        
        query() : type_(), qclass_() {}
        
        void dname(const std::string& nm) {
            name_ = nm;
        }
        
        void query_type(QueryType tp) {
            type_ = tp;
        }

        TINS_DEPRECATED(void type(QueryType tp)) {
            type_ = tp;
        }
        
        void query_class(QueryClass cl) {
            qclass_ = cl;
        }
        
        const std::string& dname() const {
            return name_;
        }
        
        QueryType query_type() const {
            return type_;
        }

        TINS_DEPRECATED(QueryType type() const) {
            return type_;
        }
        
        QueryClass query_class() const {
            return qclass_;
        }
    private:
        std::string name_;
        QueryType type_;
        QueryClass qclass_;
    };
    
    class resource;

    class soa_record {
    public:
        soa_record();

        soa_record(const DNS::resource& resource);

        soa_record(const uint8_t* buffer, uint32_t total_sz);

        soa_record(const std::string& mname,
                   const std::string& rname,
                   uint32_t serial,
                   uint32_t refresh,
                   uint32_t retry,
                   uint32_t expire,
                   uint32_t minimum_ttl);

        const std::string& mname() const {
            return mname_;
        }

        const std::string& rname() const {
            return rname_;
        }

        uint32_t serial() const {
            return serial_;
        }

        uint32_t refresh() const {
            return refresh_;
        }

        uint32_t retry() const {
            return retry_;
        }

        uint32_t expire() const {
            return expire_;
        }

        uint32_t minimum_ttl() const {
            return minimum_ttl_;
        }

        void mname(const std::string& value);

        void rname(const std::string& value);

        void serial(uint32_t value);

        void refresh(uint32_t value);

        void retry(uint32_t value);

        void expire(uint32_t value);

        void minimum_ttl(uint32_t value);

         PDU::serialization_type serialize() const;
    private:
        void init(const uint8_t* buffer, uint32_t total_sz);

        std::string mname_;
        std::string rname_;
        uint32_t serial_;
        uint32_t refresh_;
        uint32_t retry_;
        uint32_t expire_;
        uint32_t minimum_ttl_;
    };

    class resource {
    public:
        #if TINS_IS_CXX11
        resource(std::string dname, 
                 std::string data, 
                 uint16_t type,
                 uint16_t rclass,
                 uint32_t ttl,
                 uint16_t preference = 0) 
        : dname_(std::move(dname)), data_(std::move(data)), type_(type),
          qclass_(rclass), ttl_(ttl), preference_(preference) {}
        #else
        resource(const std::string& dname, 
                 const std::string& data, 
                 uint16_t type,
                 uint16_t rclass,
                 uint32_t ttl,
                 uint16_t preference = 0) 
        : dname_(dname), data_(data), type_(type), qclass_(rclass), 
          ttl_(ttl), preference_(preference) {}
        #endif 
        
        resource() : type_(), qclass_(), ttl_(), preference_() {}
        
        const std::string& dname() const {
            return dname_;
        }
        
        const std::string& data() const {
            return data_;
        }
        
        uint16_t query_type() const {
            return type_;
        }
        
        TINS_DEPRECATED(uint16_t type() const) {
            return type_;
        }

        uint16_t query_class() const {
            return qclass_;
        }
        
        uint32_t ttl() const {
            return ttl_;
        }

        uint16_t preference() const {
            return preference_;
        }

        void dname(const std::string& data) {
            dname_ = data;
        }

        void data(const std::string& data) {
            data_ = data;
        }

        void data(const soa_record& data) {
            serialization_type buffer = data.serialize();
            data_.assign(buffer.begin(), buffer.end());
        }

        void query_type(uint16_t data) {
            type_ = data;
        }

        TINS_DEPRECATED(void type(uint16_t data)) {
            type_ = data;
        }

        void query_class(uint16_t data) {
            qclass_ = data;
        }

        void ttl(uint32_t data) {
            ttl_ = data;
        }

        void preference(uint16_t data) {
            preference_ = data;
        }
    private:
        std::string dname_, data_;
        uint16_t type_, qclass_;
        uint32_t ttl_;
        uint16_t preference_;
    };

    TINS_DEPRECATED(typedef query Query);
    TINS_DEPRECATED(typedef resource Resource);
    
    typedef std::vector<query> queries_type;
    typedef std::vector<resource> resources_type;
    typedef IPv4Address address_type;
    typedef IPv6Address address_v6_type;
    
    static metadata extract_metadata(const uint8_t *buffer, uint32_t total_sz);
    
    DNS();
    
    DNS(const uint8_t* buffer, uint32_t total_sz);
    
    // Getters
    
    uint16_t id() const { 
        return Endian::be_to_host(header_.id); 
    }
    
    QRType type() const {
        return static_cast<QRType>(header_.qr);
    }
    
    uint8_t opcode() const {
        return header_.opcode;
    }
    
    uint8_t authoritative_answer() const {
        return header_.aa;
    }
    
    uint8_t truncated() const {
        return header_.tc;
    }
    
    uint8_t recursion_desired() const {
        return header_.rd;
    }
    
    uint8_t recursion_available() const {
        return header_.ra;
    }
    
    uint8_t z() const {
        return header_.z;
    }
    
    uint8_t authenticated_data() const {
        return header_.ad;
    }
    
    uint8_t checking_disabled() const {
        return header_.cd;
    }
    
    uint8_t rcode() const {
        return header_.rcode;
    }
    
    uint16_t questions_count() const {
        return Endian::be_to_host(header_.questions);
    }
    
    uint16_t answers_count() const {
        return Endian::be_to_host(header_.answers);
    }
    
    uint16_t authority_count() const {
        return Endian::be_to_host(header_.authority);
    }
    
    uint16_t additional_count() const {
        return Endian::be_to_host(header_.additional);
    }

    PDUType pdu_type() const {
        return pdu_flag;
    }
    
    uint32_t header_size() const;

    // Setters
     
    void id(uint16_t new_id);
    
    void type(QRType new_qr);
    
    void opcode(uint8_t new_opcode);
    
    void authoritative_answer(uint8_t new_aa);
    
    void truncated(uint8_t new_tc);
    
    void recursion_desired(uint8_t new_rd);
    
    void recursion_available(uint8_t new_ra);
    
    void z(uint8_t new_z);
    
    void authenticated_data(uint8_t new_ad);
    
    void checking_disabled(uint8_t new_cd);
    
    void rcode(uint8_t new_rcode);
    
    // Methods
    
    void add_query(const query& query);
    
    void add_answer(const resource& resource);

    void add_authority(const resource& resource);
    
    void add_additional(const resource& resource);
    
    queries_type queries() const;
    
    resources_type answers() const;

    resources_type authority() const;

    resources_type additional() const;
    
    static std::string encode_domain_name(const std::string& domain_name);

    static std::string decode_domain_name(const std::string& domain_name);

    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
    
    DNS* clone() const {
        return new DNS(*this);
    }
private:
    friend class soa_record;

    TINS_BEGIN_PACK
    struct dns_header {
        uint16_t id;
        #if TINS_IS_LITTLE_ENDIAN
            uint16_t 
                rd:1,
                tc:1,
                aa:1,
                opcode:4,
                qr:1,
                rcode:4,
                cd:1,
                ad:1,
                z:1,
                ra:1;
        #elif TINS_IS_BIG_ENDIAN
            uint16_t 
                qr:1,
                opcode:4,
                aa:1,
                tc:1,
                rd:1,
                ra:1,
                z:1,
                ad:1,
                cd:1,
                rcode:4;
        #endif
        uint16_t questions, answers,
                 authority, additional;
    } TINS_END_PACK;
    
    typedef std::vector<std::pair<uint32_t*, uint32_t> > sections_type;
    
    uint32_t compose_name(const uint8_t* ptr, char* out_ptr) const;
    void convert_records(const uint8_t* ptr, 
                         const uint8_t* end,
                         resources_type& res) const;
    void skip_to_section_end(Memory::InputMemoryStream& stream, 
                             const uint32_t num_records) const;
    void skip_to_dname_end(Memory::InputMemoryStream& stream) const;
    void update_records(uint32_t& section_start, 
                        uint32_t num_records,
                        uint32_t threshold,
                        uint32_t offset);
    uint8_t* update_dname(uint8_t* ptr, uint32_t threshold, uint32_t offset);
    static void inline_convert_v4(uint32_t value, char* output);
    static bool contains_dname(uint16_t type);
    void write_serialization(uint8_t* buffer, uint32_t total_sz);
    void add_record(const resource& resource, const sections_type& sections);
    
    dns_header header_;
    byte_array records_data_;
    uint32_t answers_idx_, authority_idx_, additional_idx_;
};

} // Tins

#endif // TINS_DNS_H