ncr_msg.h

Go to the documentation of this file.

// Copyright (C) 2013-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef NCR_MSG_H
#define NCR_MSG_H
 
 
#include <cc/data.h>
#include <dhcp/duid.h>
#include <dhcp/hwaddr.h>
#include <dns/name.h>
#include <dns/time_utils.h>
#include <exceptions/exceptions.h>
#include <util/buffer.h>
 
#include <time.h>
#include <string>
 
namespace isc {
namespace dhcp_ddns {
 
class NcrMessageError : public isc::Exception {
public:
    NcrMessageError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class DhcidRdataComputeError : public isc::Exception {
public:
    DhcidRdataComputeError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
enum NameChangeType {
  CHG_ADD,
  CHG_REMOVE
};
 
enum NameChangeStatus  {
  ST_NEW,
  ST_PENDING,
  ST_COMPLETED,
  ST_FAILED
};
 
enum NameChangeFormat {
  FMT_JSON
};
 
// DDNS Conflict resolution modes
enum ConflictResolutionMode {
   CHECK_WITH_DHCID,
   NO_CHECK_WITH_DHCID,
   CHECK_EXISTS_WITH_DHCID,
   NO_CHECK_WITHOUT_DHCID
};
 
extern NameChangeFormat stringToNcrFormat(const std::string& fmt_str);
 
extern std::string ncrFormatToString(NameChangeFormat format);
 
ConflictResolutionMode StringToConflictResolutionMode(const std::string& mode_str);
 
std::string ConflictResolutionModeToString(const ConflictResolutionMode& mode);
 
class D2Dhcid {
public:
    D2Dhcid();
 
    D2Dhcid(const std::string& data);
 
    D2Dhcid(const isc::dhcp::HWAddrPtr& hwaddr,
            const std::vector<uint8_t>& wire_fqdn);
 
    D2Dhcid(const std::vector<uint8_t>& clientid_data,
            const std::vector<uint8_t>& wire_fqdn);
 
    D2Dhcid(const isc::dhcp::DUID& duid,
            const std::vector<uint8_t>& wire_fqdn);
 
    std::string toStr() const;
 
    void fromStr(const std::string& data);
 
    void fromClientId(const std::vector<uint8_t>& clientid_data,
                      const std::vector<uint8_t>& wire_fqdn);
 
    void fromDUID(const isc::dhcp::DUID& duid,
                  const std::vector<uint8_t>& wire_fqdn);
 
    void fromHWAddr(const isc::dhcp::HWAddrPtr& hwaddr,
                    const std::vector<uint8_t>& wire_fqdn);
 
    const std::vector<uint8_t>& getBytes() const {
        return (bytes_);
    }
 
    bool operator==(const D2Dhcid& other) const {
        return (this->bytes_ == other.bytes_);
    }
 
    bool operator!=(const D2Dhcid& other) const {
        return (this->bytes_ != other.bytes_);
    }
 
    bool operator<(const D2Dhcid& other) const {
        return (this->bytes_ < other.bytes_);
    }
 
private:
 
    void createDigest(const uint8_t identifier_type,
                      const std::vector<uint8_t>& identifier_data,
                      const std::vector<uint8_t>& wire_fqdn);
 
    std::vector<uint8_t> bytes_;
};
 
std::ostream&
operator<<(std::ostream& os, const D2Dhcid& dhcid);
 
class NameChangeRequest;
typedef boost::shared_ptr<NameChangeRequest> NameChangeRequestPtr;
 
typedef std::map<std::string, isc::data::ConstElementPtr> ElementMap;
 
class NameChangeRequest {
public:
    NameChangeRequest();
 
    NameChangeRequest(const NameChangeType change_type,
                      const bool forward_change, const bool reverse_change,
                      const std::string& fqdn, const std::string& ip_address,
                      const D2Dhcid& dhcid,
                      const uint64_t lease_expires_on,
                      const uint32_t lease_length,
                      const ConflictResolutionMode
                      conflict_resolution_mode = CHECK_WITH_DHCID);
 
    static NameChangeRequestPtr fromFormat(const NameChangeFormat format,
                                           isc::util::InputBuffer& buffer);
 
    void toFormat(const NameChangeFormat format,
                  isc::util::OutputBuffer& buffer) const;
 
    static NameChangeRequestPtr fromJSON(const std::string& json);
 
    std::string toJSON() const;
 
    void validateContent();
 
    NameChangeType getChangeType() const {
        return (change_type_);
    }
 
    void setChangeType(const NameChangeType value);
 
    void setChangeType(isc::data::ConstElementPtr element);
 
    bool isForwardChange() const {
        return (forward_change_);
    }
 
    void setForwardChange(const bool value);
 
    void setForwardChange(isc::data::ConstElementPtr element);
 
    bool isReverseChange() const {
        return (reverse_change_);
    }
 
    void setReverseChange(const bool value);
 
    void setReverseChange(isc::data::ConstElementPtr element);
 
    const std::string getFqdn() const {
        return (fqdn_);
    }
 
    void setFqdn(const std::string& value);
 
    void setFqdn(isc::data::ConstElementPtr element);
 
    std::string getIpAddress() const {
        return (ip_io_address_.toText());
    }
 
    const asiolink::IOAddress& getIpIoAddress() const {
        return (ip_io_address_);
    }
 
    bool isV4 () const {
        return (ip_io_address_.isV4());
    }
 
    bool isV6 () const {
        return (ip_io_address_.isV6());
    }
 
    void setIpAddress(const std::string& value);
 
    void setIpAddress(isc::data::ConstElementPtr element);
 
    const D2Dhcid& getDhcid() const {
        return (dhcid_);
    }
 
    void setDhcid(const std::string& value);
 
    void setDhcid(isc::data::ConstElementPtr element);
 
    std::string getRequestId() const {
        return (dhcid_.toStr());
    }
 
    uint64_t getLeaseExpiresOn() const {
        return (lease_expires_on_);
    }
 
    std::string getLeaseExpiresOnStr() const;
 
    void setLeaseExpiresOn(const std::string& value);
 
    void setLeaseExpiresOn(isc::data::ConstElementPtr element);
 
    uint32_t getLeaseLength() const {
        return (lease_length_);
    }
 
    void setLeaseLength(const uint32_t value);
 
    void setLeaseLength(isc::data::ConstElementPtr element);
 
    ConflictResolutionMode getConflictResolutionMode() const {
        return (conflict_resolution_mode_);
    }
 
    void setConflictResolutionMode(const ConflictResolutionMode value);
 
    void setConflictResolutionMode(isc::data::ConstElementPtr element);
 
    void translateUseConflictResolution(isc::data::ConstElementPtr element);
 
    NameChangeStatus getStatus() const {
        return (status_);
    }
 
    void setStatus(const NameChangeStatus value);
 
    isc::data::ConstElementPtr getElement(const std::string& name,
                                          const ElementMap& element_map) const;
 
    std::string toText() const;
 
    bool operator == (const NameChangeRequest& b) const;
    bool operator != (const NameChangeRequest& b) const;
 
private:
    NameChangeType change_type_;
 
    bool forward_change_;
 
    bool reverse_change_;
 
    std::string fqdn_;
 
    asiolink::IOAddress ip_io_address_;
 
    D2Dhcid dhcid_;
 
    uint64_t lease_expires_on_;
 
    uint32_t lease_length_;
 
    ConflictResolutionMode conflict_resolution_mode_;
 
    NameChangeStatus status_;
};
 
}  // namespace dhcp_ddns
}  // namespace isc
 
#endif