dnspacket.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/buffer.h>
#include <promeki/dnsrecord.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/result.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DnsPacket {
        public:
                static constexpr int HeaderSize = 12;
 
                class Builder;
 
                DnsPacket() = default;
 
                static Result<DnsPacket> parse(const Buffer &b);
 
                static Result<DnsPacket> parse(const uint8_t *data, size_t len);
 
                static Result<DnsPacket> parseMdns(const Buffer &b);
                static Result<DnsPacket> parseMdns(const uint8_t *data, size_t len);
 
                uint16_t transactionId() const { return _id; }
 
                void setTransactionId(uint16_t id) { _id = id; }
 
                uint16_t flags() const { return _flags; }
 
                void setFlags(uint16_t f) { _flags = f; }
 
                bool isResponse() const { return (_flags & 0x8000) != 0; }
 
                bool isAuthoritative() const { return (_flags & 0x0400) != 0; }
 
                bool isTruncated() const { return (_flags & 0x0200) != 0; }
 
                bool isRecursionDesired() const { return (_flags & 0x0100) != 0; }
 
                bool isRecursionAvailable() const { return (_flags & 0x0080) != 0; }
 
                uint8_t rcode() const { return static_cast<uint8_t>(_flags & 0x000F); }
 
                uint8_t opcode() const { return static_cast<uint8_t>((_flags >> 11) & 0x0F); }
 
                const List<DnsQuestion> &questions() const { return _questions; }
                List<DnsQuestion> &questions() { return _questions; }
 
                const List<DnsRecord> &records() const { return _records; }
                List<DnsRecord> &records() { return _records; }
 
                List<DnsRecord> recordsInSection(DnsRecord::Section section) const;
 
        private:
                uint16_t          _id    = 0;
                uint16_t          _flags = 0;
                List<DnsQuestion> _questions;
                List<DnsRecord>   _records;
};
 
class DnsPacket::Builder {
        public:
                Builder();
 
                Builder &setTransactionId(uint16_t id);
 
                Builder &setResponse(bool r);
 
                Builder &setAuthoritative(bool aa);
 
                Builder &setTruncated(bool tc);
 
                Builder &setRecursionDesired(bool rd);
 
                Builder &setRecursionAvailable(bool ra);
 
                Builder &setOpcode(uint8_t opcode);
 
                Builder &setRcode(uint8_t rcode);
 
                Builder &setCompressionEnabled(bool enable);
 
                Builder &addQuestion(const String &name, DnsRecord::Type type,
                                     uint16_t klass = 1, bool unicastResponse = false);
 
                Builder &addQuestion(const DnsQuestion &q);
 
                Builder &addAnswer(const DnsRecord &r);
 
                Builder &addAuthority(const DnsRecord &r);
 
                Builder &addAdditional(const DnsRecord &r);
 
                Builder &addEdns0(uint16_t udpPayloadSize = 1232, bool doBit = false);
 
                Buffer finish() const;
 
                bool lastEncodeFailed() const { return _lastEncodeFailed; }
 
        private:
                uint16_t        _id           = 0;
                uint16_t        _flags        = 0;
                bool            _compress     = true;
                mutable bool    _lastEncodeFailed = false;
                List<DnsQuestion> _questions;
                List<DnsRecord> _answers;
                List<DnsRecord> _authority;
                List<DnsRecord> _additional;
};
 
#if PROMEKI_ENABLE_MDNS
using MdnsPacket = DnsPacket;
#endif
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK