dnsmessage.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_DNSMESSAGE_HPP
#define JOIN_FABRIC_DNSMESSAGE_HPP
 
// libjoin.
#include <join/ipaddress.hpp>
#include <join/utils.hpp>
#include <join/error.hpp>
 
// C++.
#include <unordered_set>
#include <system_error>
#include <sstream>
#include <vector>
#include <string>
 
// C.
#include <cstdint>
 
namespace join
{
    using AliasList = std::unordered_set<std::string>;
 
    using ServerList = std::unordered_set<std::string>;
 
    using ExchangerList = std::unordered_set<std::string>;
 
    struct QuestionRecord
    {
        std::string host;      
        uint16_t type = 0;     
        uint16_t dnsclass = 0; 
    };
 
    struct ResourceRecord : public QuestionRecord
    {
        uint32_t ttl = 0;              
        IpAddress addr;                
        std::string name;              
        uint16_t priority = 0;         
        uint16_t weight = 0;           
        uint16_t port = 0;             
        std::vector<std::string> txts; 
        std::string mail;              
        uint32_t serial = 0;           
        uint32_t refresh = 0;          
        uint32_t retry = 0;            
        uint32_t expire = 0;           
        uint32_t minimum = 0;          
        uint16_t mxpref = 0;           
    };
 
    struct DnsPacket
    {
        uint16_t id = 0;                         
        uint16_t flags = 0;                      
        IpAddress src;                           
        IpAddress dest;                          
        uint16_t port = 0;                       
        std::vector<QuestionRecord> questions;   
        std::vector<ResourceRecord> answers;     
        std::vector<ResourceRecord> authorities; 
        std::vector<ResourceRecord> additionals; 
    };
 
    class DnsMessage
    {
    public:
        enum RecordType : uint16_t
        {
            A = 1,     
            NS = 2,    
            CNAME = 5, 
            SOA = 6,   
            PTR = 12,  
            MX = 15,   
            TXT = 16,  
            AAAA = 28, 
            SRV = 33,  
            ANY = 255, 
        };
 
        enum RecordClass : uint16_t
        {
            IN = 1, 
        };
 
        DnsMessage () noexcept = default;
 
        DnsMessage (const DnsMessage& other) = delete;
 
        DnsMessage& operator= (const DnsMessage& other) = delete;
 
        DnsMessage (DnsMessage&& other) = delete;
 
        DnsMessage& operator= (DnsMessage&& other) = delete;
 
        ~DnsMessage () noexcept = default;
 
        int serialize (const DnsPacket& packet, std::stringstream& data) const
        {
            uint16_t id = htons (packet.id);
            data.write (reinterpret_cast<const char*> (&id), sizeof (id));
 
            uint16_t flags = htons (packet.flags);
            data.write (reinterpret_cast<const char*> (&flags), sizeof (flags));
 
            uint16_t qcount = htons (static_cast<uint16_t> (packet.questions.size ()));
            data.write (reinterpret_cast<const char*> (&qcount), sizeof (qcount));
 
            uint16_t ancount = htons (static_cast<uint16_t> (packet.answers.size ()));
            data.write (reinterpret_cast<const char*> (&ancount), sizeof (ancount));
 
            uint16_t nscount = htons (static_cast<uint16_t> (packet.authorities.size ()));
            data.write (reinterpret_cast<const char*> (&nscount), sizeof (nscount));
 
            uint16_t arcount = htons (static_cast<uint16_t> (packet.additionals.size ()));
            data.write (reinterpret_cast<const char*> (&arcount), sizeof (arcount));
 
            for (auto const& question : packet.questions)
            {
                if (encodeQuestion (question, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
 
            for (auto const& answer : packet.answers)
            {
                if (encodeResource (answer, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
 
            for (auto const& authority : packet.authorities)
            {
                if (encodeResource (authority, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
 
            for (auto const& additional : packet.additionals)
            {
                if (encodeResource (additional, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
 
            return 0;
        }
 
        int deserialize (DnsPacket& packet, std::stringstream& data) const
        {
            data.read (reinterpret_cast<char*> (&packet.id), sizeof (packet.id));
            packet.id = ntohs (packet.id);
 
            data.read (reinterpret_cast<char*> (&packet.flags), sizeof (packet.flags));
            packet.flags = ntohs (packet.flags);
 
            uint16_t qcount = 0;
            data.read (reinterpret_cast<char*> (&qcount), sizeof (qcount));
            qcount = ntohs (qcount);
 
            uint16_t ancount = 0;
            data.read (reinterpret_cast<char*> (&ancount), sizeof (ancount));
            ancount = ntohs (ancount);
 
            uint16_t nscount = 0;
            data.read (reinterpret_cast<char*> (&nscount), sizeof (nscount));
            nscount = ntohs (nscount);
 
            uint16_t arcount = 0;
            data.read (reinterpret_cast<char*> (&arcount), sizeof (arcount));
            arcount = ntohs (arcount);
 
            packet.questions.clear ();
            for (uint16_t i = 0; i < qcount; ++i)
            {
                QuestionRecord question;
                if (decodeQuestion (question, data) == -1)
                {
                    return -1;
                }
                packet.questions.emplace_back (std::move (question));
            }
 
            packet.answers.clear ();
            for (uint16_t i = 0; i < ancount; ++i)
            {
                ResourceRecord answer;
                if (decodeResource (answer, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
                packet.answers.emplace_back (std::move (answer));
            }
 
            packet.authorities.clear ();
            for (uint16_t i = 0; i < nscount; ++i)
            {
                ResourceRecord authority;
                if (decodeResource (authority, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
                packet.authorities.emplace_back (std::move (authority));
            }
 
            packet.additionals.clear ();
            for (uint16_t i = 0; i < arcount; ++i)
            {
                ResourceRecord additional;
                if (decodeResource (additional, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
                packet.additionals.emplace_back (std::move (additional));
            }
 
            return 0;
        }
 
        static std::error_code decodeError (uint16_t error) noexcept
        {
            switch (error)
            {
                case 0:
                    return {};
                case 1:
                case 4:
                    return make_error_code (Errc::InvalidParam);
                case 2:
                    return make_error_code (Errc::OperationFailed);
                case 3:
                    return make_error_code (Errc::NotFound);
                case 5:
                    return make_error_code (Errc::PermissionDenied);
                default:
                    return make_error_code (Errc::UnknownError);
            }
        }
 
        static std::string typeName (uint16_t recordType)
        {
            switch (recordType)
            {
                OUT_ENUM (A);
                OUT_ENUM (NS);
                OUT_ENUM (CNAME);
                OUT_ENUM (SOA);
                OUT_ENUM (PTR);
                OUT_ENUM (MX);
                OUT_ENUM (TXT);
                OUT_ENUM (AAAA);
                OUT_ENUM (SRV);
                OUT_ENUM (ANY);
            }
 
            return "UNKNOWN";
        }
 
        static std::string className (uint16_t recordClass)
        {
            switch (recordClass & 0x7FFF)
            {
                OUT_ENUM (IN);
            }
 
            return "UNKNOWN";
        }
 
    private:
        int encodeName (const std::string& name, std::stringstream& data) const
        {
            std::istringstream iss (name);
 
            for (std::string token; std::getline (iss, token, '.');)
            {
                data << static_cast<uint8_t> (token.size ());
                data << token;
            }
 
            data << '\0';
 
            return 0;
        }
 
        int decodeName (std::string& name, std::stringstream& data, int depth = 0) const
        {
            if (depth > 10)
            {
                return -1;
            }
 
            for (;;)
            {
                auto pos = data.tellg ();
 
                uint16_t offset = 0;
                data.read (reinterpret_cast<char*> (&offset), sizeof (offset));
                offset = ntohs (offset);
 
                if (offset & 0xC000)
                {
                    pos = data.tellg ();
                    data.seekg (offset & 0x3FFF);
                    if (decodeName (name, data, depth + 1) == -1)
                    {
                        return -1;
                    }
                    data.seekg (pos);
                    break;
                }
                else
                {
                    data.seekg (pos);
 
                    uint8_t size = 0;
                    data.read (reinterpret_cast<char*> (&size), sizeof (size));
 
                    if (size == 0)
                    {
                        if (!name.empty () && name.back () == '.')
                        {
                            name.pop_back ();
                        }
                        break;
                    }
 
                    name.resize (name.size () + size);
                    data.read (&name[name.size () - size], size);
                    name += '.';
                }
            }
 
            return 0;
        }
 
        int encodeMail (const std::string& mail, std::stringstream& data) const
        {
            std::string encodedMail = mail;
            size_t atPos = encodedMail.find ('@');
 
            if (atPos != std::string::npos)
            {
                encodedMail.replace (atPos, 1, ".");
            }
 
            encodeName (encodedMail, data);
 
            return 0;
        }
 
        int decodeMail (std::string& mail, std::stringstream& data) const
        {
            if (decodeName (mail, data) == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            auto pos = mail.find ('.');
            if (pos != std::string::npos)
            {
                mail[pos] = '@';
            }
 
            return 0;
        }
 
        int encodeQuestion (const QuestionRecord& question, std::stringstream& data) const
        {
            encodeName (question.host, data);
 
            uint16_t type = htons (question.type);
            data.write (reinterpret_cast<const char*> (&type), sizeof (type));
 
            uint16_t dnsclass = htons (question.dnsclass);
            data.write (reinterpret_cast<const char*> (&dnsclass), sizeof (dnsclass));
 
            return 0;
        }
 
        int decodeQuestion (QuestionRecord& question, std::stringstream& data) const
        {
            if (decodeName (question.host, data) == -1)
            {
                return -1;
            }
 
            data.read (reinterpret_cast<char*> (&question.type), sizeof (question.type));
            question.type = ntohs (question.type);
 
            data.read (reinterpret_cast<char*> (&question.dnsclass), sizeof (question.dnsclass));
            question.dnsclass = ntohs (question.dnsclass);
 
            return 0;
        }
 
        int encodeResource (const ResourceRecord& resource, std::stringstream& data) const
        {
            encodeName (resource.host, data);
 
            uint16_t type = htons (resource.type);
            data.write (reinterpret_cast<const char*> (&type), sizeof (type));
 
            uint16_t dnsclass = htons (resource.dnsclass);
            data.write (reinterpret_cast<const char*> (&dnsclass), sizeof (dnsclass));
 
            uint32_t ttl = htonl (resource.ttl);
            data.write (reinterpret_cast<const char*> (&ttl), sizeof (ttl));
 
            uint16_t dataLen = 0;
            auto dataLenPos = data.tellp ();
            data.write (reinterpret_cast<const char*> (&dataLen), sizeof (dataLen));
 
            auto dataBegPos = data.tellp ();
 
            if (resource.type == RecordType::A)
            {
                data.write (reinterpret_cast<const char*> (resource.addr.addr ()), sizeof (in_addr));
            }
            else if (resource.type == RecordType::AAAA)
            {
                data.write (reinterpret_cast<const char*> (resource.addr.addr ()), sizeof (in6_addr));
            }
            else if (resource.type == RecordType::NS)
            {
                encodeName (resource.name, data);
            }
            else if (resource.type == RecordType::CNAME)
            {
                encodeName (resource.name, data);
            }
            else if (resource.type == RecordType::PTR)
            {
                encodeName (resource.name, data);
            }
            else if (resource.type == RecordType::MX)
            {
                uint16_t mxpref = htons (resource.mxpref);
                data.write (reinterpret_cast<const char*> (&mxpref), sizeof (mxpref));
                encodeName (resource.name, data);
            }
            else if (resource.type == RecordType::SOA)
            {
                encodeName (resource.name, data);
                encodeMail (resource.mail, data);
 
                uint32_t serial = htonl (resource.serial);
                data.write (reinterpret_cast<const char*> (&serial), sizeof (serial));
 
                uint32_t refresh = htonl (resource.refresh);
                data.write (reinterpret_cast<const char*> (&refresh), sizeof (refresh));
 
                uint32_t retry = htonl (resource.retry);
                data.write (reinterpret_cast<const char*> (&retry), sizeof (retry));
 
                uint32_t expire = htonl (resource.expire);
                data.write (reinterpret_cast<const char*> (&expire), sizeof (expire));
 
                uint32_t minimum = htonl (resource.minimum);
                data.write (reinterpret_cast<const char*> (&minimum), sizeof (minimum));
            }
            else if (resource.type == RecordType::TXT)
            {
                for (auto const& txt : resource.txts)
                {
                    uint8_t size = static_cast<uint8_t> (txt.size ());
                    data.write (reinterpret_cast<const char*> (&size), sizeof (size));
                    data.write (txt.data (), size);
                }
            }
            else if (resource.type == RecordType::SRV)
            {
                uint16_t priority = htons (resource.priority);
                data.write (reinterpret_cast<const char*> (&priority), sizeof (priority));
 
                uint16_t weight = htons (resource.weight);
                data.write (reinterpret_cast<const char*> (&weight), sizeof (weight));
 
                uint16_t port = htons (resource.port);
                data.write (reinterpret_cast<const char*> (&port), sizeof (port));
 
                encodeName (resource.name, data);
            }
 
            auto dataEndPos = data.tellp ();
            dataLen = static_cast<uint16_t> (dataEndPos - dataBegPos);
 
            data.seekp (dataLenPos);
            dataLen = htons (dataLen);
            data.write (reinterpret_cast<const char*> (&dataLen), sizeof (dataLen));
            data.seekp (dataEndPos);
 
            return 0;
        }
 
        int decodeResource (ResourceRecord& resource, std::stringstream& data) const
        {
            if (decodeName (resource.host, data) == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            data.read (reinterpret_cast<char*> (&resource.type), sizeof (resource.type));
            resource.type = ntohs (resource.type);
 
            data.read (reinterpret_cast<char*> (&resource.dnsclass), sizeof (resource.dnsclass));
            resource.dnsclass = ntohs (resource.dnsclass);
 
            data.read (reinterpret_cast<char*> (&resource.ttl), sizeof (resource.ttl));
            resource.ttl = ntohl (resource.ttl);
 
            uint16_t dataLen = 0;
            data.read (reinterpret_cast<char*> (&dataLen), sizeof (dataLen));
            dataLen = ntohs (dataLen);
 
            auto dataBegPos = data.tellg ();
 
            if (resource.type == RecordType::A)
            {
                struct in_addr addr;
                data.read (reinterpret_cast<char*> (&addr), sizeof (addr));
                resource.addr = IpAddress (&addr, sizeof (struct in_addr));
            }
            else if (resource.type == RecordType::AAAA)
            {
                struct in6_addr addr;
                data.read (reinterpret_cast<char*> (&addr), sizeof (addr));
                resource.addr = IpAddress (&addr, sizeof (struct in6_addr));
            }
            else if (resource.type == RecordType::NS)
            {
                if (decodeName (resource.name, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
            else if (resource.type == RecordType::CNAME)
            {
                if (decodeName (resource.name, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
            else if (resource.type == RecordType::PTR)
            {
                if (decodeName (resource.name, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
            else if (resource.type == RecordType::MX)
            {
                data.read (reinterpret_cast<char*> (&resource.mxpref), sizeof (resource.mxpref));
                resource.mxpref = ntohs (resource.mxpref);
 
                if (decodeName (resource.name, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
            else if (resource.type == RecordType::SOA)
            {
                if (decodeName (resource.name, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
 
                decodeMail (resource.mail, data);
 
                data.read (reinterpret_cast<char*> (&resource.serial), sizeof (resource.serial));
                resource.serial = ntohl (resource.serial);
 
                data.read (reinterpret_cast<char*> (&resource.refresh), sizeof (resource.refresh));
                resource.refresh = ntohl (resource.refresh);
 
                data.read (reinterpret_cast<char*> (&resource.retry), sizeof (resource.retry));
                resource.retry = ntohl (resource.retry);
 
                data.read (reinterpret_cast<char*> (&resource.expire), sizeof (resource.expire));
                resource.expire = ntohl (resource.expire);
 
                data.read (reinterpret_cast<char*> (&resource.minimum), sizeof (resource.minimum));
                resource.minimum = ntohl (resource.minimum);
            }
            else if (resource.type == RecordType::TXT)
            {
                while (data.tellg () != -1 && (data.tellg () - dataBegPos < dataLen))
                {
                    uint8_t size = 0;
                    if (!data.read (reinterpret_cast<char*> (&size), sizeof (size)))
                    {
                        return -1;  // LCOV_EXCL_LINE
                    }
 
                    std::string txt;
                    txt.resize (size);
                    if (!data.read (&txt[0], size))
                    {
                        return -1;  // LCOV_EXCL_LINE
                    }
 
                    resource.txts.emplace_back (std::move (txt));
                }
            }
            else if (resource.type == RecordType::SRV)
            {
                data.read (reinterpret_cast<char*> (&resource.priority), sizeof (resource.priority));
                resource.priority = ntohs (resource.priority);
 
                data.read (reinterpret_cast<char*> (&resource.weight), sizeof (resource.weight));
                resource.weight = ntohs (resource.weight);
 
                data.read (reinterpret_cast<char*> (&resource.port), sizeof (resource.port));
                resource.port = ntohs (resource.port);
 
                if (decodeName (resource.name, data) == -1)
                {
                    return -1;  // LCOV_EXCL_LINE
                }
            }
            else
            {
                data.seekg (dataBegPos + static_cast<std::streamoff> (dataLen));
            }
 
            return 0;
        }
    };
}
 
#endif