AsyncDnsResourceRecord.h

Go to the documentation of this file.

 
#ifndef ASYNC_DNS_RESOURCE_RECORD_INCLUDED
#define ASYNC_DNS_RESOURCE_RECORD_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <string>
#include <sstream>
#include <map>
#include <memory>
#include <vector>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncIpAddress.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class DnsResourceRecord
{
  public:
    using Name = std::string;
    using Ttl = uint32_t;
 
    enum class Type { ANY, A, PTR, CNAME, SRV };
 
    enum class Class { IN };
 
    using List = std::vector<std::unique_ptr<DnsResourceRecord>>;
 
    static constexpr Ttl MAX_TTL = 0x7fffffff;
 
    static const Type staticType(void) { return Type::ANY; }
 
    static const std::string& typeToString(Type type)
    {
      static const std::map<Type, std::string> type_map = {
        {Type::A, "A"}, {Type::PTR, "PTR"}, {Type::CNAME, "CNAME"},
        {Type::SRV, "SRV"}
      };
      static const std::string UNKNOWN = "?";
      const auto& it = type_map.find(type);
      if (it == type_map.end())
      {
        return UNKNOWN;
      }
      return it->second;
    }
 
    DnsResourceRecord(const Name& name, Ttl ttl)
      : m_name(name), m_ttl(ttl) {}
 
    virtual ~DnsResourceRecord(void) {}
 
    virtual DnsResourceRecord* clone(void) const = 0;
 
    virtual bool operator==(const DnsResourceRecord& other) const
    {
      return (classId() == other.classId()) &&
             (type() == other.type()) &&
             (name() == other.name());
    }
 
    Class classId(void) const { return Class::IN; }
 
    const char* classStr(void) const { return "IN"; }
 
    virtual const Type type(void) const = 0;
 
    const std::string& typeStr(void) const
    {
      return typeToString(type());
    }
 
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << name() << "\t" << ttl() << "\t" << classStr() << "\t"
         << typeStr() << "\t";
      return os.str();
    }
 
    void setName(const Name& name) { m_name = name; }
 
    const Name& name(void) const { return m_name; }
 
    void setTtl(Ttl ttl) { m_ttl = ttl; }
 
    Ttl ttl(void) const { return m_ttl; }
 
  private:
    Name  m_name;
    Ttl   m_ttl;
 
};  /* class DnsResourceRecord */
 
 
template <typename Derived>
class DnsResourceRecordCRTP : public DnsResourceRecord
{
  public:
    using List = std::vector<std::unique_ptr<Derived>>;
 
    DnsResourceRecordCRTP(const Name& name, Ttl ttl)
      : DnsResourceRecord(name, ttl) {}
 
    virtual DnsResourceRecord* clone(void) const
    {
      return new Derived(static_cast<Derived const&>(*this));
    }
 
    virtual bool operator==(const DnsResourceRecord& other) const
    {
      const auto& lhs = static_cast<const Derived&>(*this);
      const auto& rhs = static_cast<const Derived&>(other);
      return lhs == rhs;
    }
 
    virtual bool operator==(const Derived& other) const = 0;
 
    virtual const Type type(void) const override { return Derived::staticType(); }
}; /* DnsResourceRecordCRTP */
 
 
class DnsResourceRecordA : public DnsResourceRecordCRTP<DnsResourceRecordA>
{
  public:
    using Ip = Async::IpAddress;
 
    static const Type staticType(void) { return Type::A; }
 
    DnsResourceRecordA(const Name& name, Ttl ttl, const Ip& ip=Ip())
      : DnsResourceRecordCRTP<DnsResourceRecordA>(name, ttl), m_ip(ip) {}
 
    virtual bool operator==(const DnsResourceRecordA& other) const
    {
      return DnsResourceRecord::operator==(other) &&
             (ip() == other.ip());
    }
 
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << DnsResourceRecord::toString() << ip();
      return os.str();
    }
 
    void setIp(const Ip& ip) { m_ip = ip; }
 
    const Ip& ip(void) const { return m_ip; }
 
  private:
    Ip m_ip;
}; /* DnsResourceRecordA */
 
 
class DnsResourceRecordPTR : public DnsResourceRecordCRTP<DnsResourceRecordPTR>
{
  public:
    using DName = std::string;
 
    static const Type staticType(void) { return Type::PTR; }
 
    DnsResourceRecordPTR(const Name& name, Ttl ttl, const DName& dname="")
      : DnsResourceRecordCRTP<DnsResourceRecordPTR>(name, ttl), m_dname(dname)
    {}
 
    virtual bool operator==(const DnsResourceRecordPTR& other) const
    {
      return DnsResourceRecord::operator==(other) &&
             (dname() == other.dname());
    }
 
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << DnsResourceRecord::toString() << dname();
      return os.str();
    }
 
    void setName(const DName& dname) { m_dname = dname; }
 
    const DName& dname(void) const { return m_dname; }
 
  private:
    DName m_dname;
}; /* DnsResourceRecordPTR */
 
 
class DnsResourceRecordCNAME :
  public DnsResourceRecordCRTP<DnsResourceRecordCNAME>
{
  public:
    using CName = std::string;
 
    static const Type staticType(void) { return Type::CNAME; }
 
    DnsResourceRecordCNAME(const Name& name, Ttl ttl, const CName& cname="")
      : DnsResourceRecordCRTP<DnsResourceRecordCNAME>(name, ttl),
        m_cname(cname) {}
 
    virtual bool operator==(const DnsResourceRecordCNAME& other) const
    {
      return DnsResourceRecord::operator==(other) &&
             (cname() == other.cname());
    }
 
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << DnsResourceRecord::toString() << cname();
      return os.str();
    }
 
    void setName(const CName& cname) { m_cname = cname; }
 
    const CName& cname(void) const { return m_cname; }
 
  private:
    CName m_cname;
}; /* DnsResourceRecordCNAME */
 
 
class DnsResourceRecordSRV :
  public DnsResourceRecordCRTP<DnsResourceRecordSRV>
{
  public:
    using Prio    = unsigned int;
    using Weight  = unsigned int;
    using Port    = unsigned int;
    using Target  = std::string;
 
    static const Type staticType(void) { return Type::SRV; }
 
    DnsResourceRecordSRV(const Name& name, Ttl ttl, Prio prio, Weight weight,
                         Port port, const Target& target)
      : DnsResourceRecordCRTP<DnsResourceRecordSRV>(name, ttl),
        m_prio(prio), m_weight(weight), m_port(port), m_target(target) {}
 
    virtual bool operator==(const DnsResourceRecordSRV& other) const
    {
      return DnsResourceRecord::operator==(other) &&
             (prio() == other.prio()) &&
             (weight() == other.weight()) &&
             (port() == other.port()) &&
             (target() == other.target());
    }
 
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << DnsResourceRecord::toString() << prio() << " " << weight()
         << " " << port() << " " << target();
      return os.str();
    }
 
    void setPrio(Prio prio) { m_prio = prio; }
 
    Prio prio(void) const { return m_prio; }
 
    void setWeight(Weight weight) { m_weight = weight; }
 
    Weight weight(void) const { return m_weight; }
 
    void setPort(Port port) { m_port = port; }
 
    Port port(void) const { return m_port; }
 
    void setTarget(const Target& target) { m_target = target; }
 
    const Target& target(void) const { return m_target; }
 
  private:
    Prio    m_prio;
    Weight  m_weight;
    Port    m_port;
    Target  m_target;
}; /* DnsResourceRecordSRV */
 
 
} /* namespace Async */
 
#endif /* ASYNC_DNS_RESOURCE_RECORD_INCLUDED */
 
/*
 * This file has not been truncated
 */