AsyncResourceRecord.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>
 
 
/****************************************************************************
 *
 * 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:
    enum class Type { A, PTR, CNAME, SRV };
    enum class Class { IN };
 
    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 std::string& name, uint32_t ttl)
      : m_name(name), m_ttl(ttl) {}
 
    DnsResourceRecord(const DnsResourceRecord&) = delete;
 
    DnsResourceRecord& operator=(const DnsResourceRecord&) = delete;
 
    virtual ~DnsResourceRecord(void) {}
 
    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 std::string& name) { m_name = name; }
    const std::string& name(void) const { return m_name; }
 
    void setTtl(uint32_t ttl) { m_ttl = ttl; }
    uint32_t ttl(void) const { return m_ttl; }
 
  private:
    std::string   m_name;
    uint32_t      m_ttl;
 
};  /* class DnsResourceRecord */
 
 
class DnsResourceRecordA : public DnsResourceRecord
{
  public:
    static const Type staticType(void) { return Type::A; }
 
    DnsResourceRecordA(const std::string& name, uint32_t ttl,
                       const IpAddress& ip=IpAddress())
      : DnsResourceRecord(name, ttl), m_ip(ip) {}
    ~DnsResourceRecordA(void) {}
 
    virtual const Type type(void) const { return staticType(); }
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << DnsResourceRecord::toString() << ip();
      return os.str();
    }
 
    void setIp(const IpAddress& ip) { m_ip = ip; }
    const IpAddress& ip(void) const { return m_ip; }
 
  private:
    IpAddress m_ip;
};
 
 
class DnsResourceRecordPTR : public DnsResourceRecord
{
  public:
    static const Type staticType(void) { return Type::PTR; }
 
    DnsResourceRecordPTR(const std::string& name, uint32_t ttl,
                         const std::string& dname="")
      : DnsResourceRecord(name, ttl), m_dname(dname) {}
    ~DnsResourceRecordPTR(void) {}
 
    virtual const Type type(void) const { return staticType(); }
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << DnsResourceRecord::toString() << dname();
      return os.str();
    }
 
    void setName(const std::string& dname) { m_dname = dname; }
    const std::string& dname(void) const { return m_dname; }
 
  private:
    std::string m_dname;
};
 
 
class DnsResourceRecordCNAME : public DnsResourceRecord
{
  public:
    static const Type staticType(void) { return Type::CNAME; }
 
    DnsResourceRecordCNAME(const std::string& name, uint32_t ttl,
                           const std::string& cname="")
      : DnsResourceRecord(name, ttl), m_cname(cname) {}
    ~DnsResourceRecordCNAME(void) {}
 
    virtual const Type type(void) const { return staticType(); }
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << DnsResourceRecord::toString() << cname();
      return os.str();
    }
 
    void setName(const std::string& cname) { m_cname = cname; }
    const std::string& cname(void) const { return m_cname; }
 
  private:
    std::string m_cname;
};
 
 
class DnsResourceRecordSRV : public DnsResourceRecord
{
  public:
    static const Type staticType(void) { return Type::SRV; }
 
    DnsResourceRecordSRV(const std::string& name, uint32_t ttl,
                         unsigned int prio, unsigned int weight,
                         unsigned int port, const std::string& target)
      : DnsResourceRecord(name, ttl), m_prio(prio), m_weight(weight),
        m_port(port), m_target(target) {}
    ~DnsResourceRecordSRV(void) {}
 
    virtual const Type type(void) const { return staticType(); }
    virtual std::string toString(void) const
    {
      std::ostringstream os;
      os << DnsResourceRecord::toString() << prio() << " " << weight()
         << " " << port() << " " << target();
      return os.str();
    }
 
    void setPrio(unsigned int prio) { m_prio = prio; }
    unsigned int prio(void) const { return m_prio; }
 
    void setWeight(unsigned int weight) { m_weight = weight; }
    unsigned int weight(void) const { return m_weight; }
 
    void setPort(unsigned int port) { m_port = port; }
    unsigned int port(void) const { return m_port; }
 
    void setTarget(const std::string& target) { m_target = target; }
    const std::string& target(void) const { return m_target; }
 
  private:
    unsigned int  m_prio;
    unsigned int  m_weight;
    unsigned int  m_port;
    std::string   m_target;
};
 
 
} /* namespace Async */
 
#endif /* ASYNC_DNS_RESOURCE_RECORD_INCLUDED */
 
/*
 * This file has not been truncated
 */