ncr_msg.h

Go to the documentation of this file.

// Copyright (C) 2013-2026 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 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();

    /// @return the change type
    NameChangeType getChangeType() const {
        return (change_type_);
    }

    void setChangeType(const NameChangeType value);

    void setChangeType(isc::data::ConstElementPtr element);

    /// @return a true if the forward change flag is true.
    bool isForwardChange() const {
        return (forward_change_);
    }

    void setForwardChange(const bool value);

    void setForwardChange(isc::data::ConstElementPtr element);

    /// @return a true if the reverse change flag is true.
    bool isReverseChange() const {
        return (reverse_change_);
    }

    void setReverseChange(const bool value);

    void setReverseChange(isc::data::ConstElementPtr element);

    /// @return a string containing the FQDN
    const std::string getFqdn() const {
        return (fqdn_);
    }

    void setFqdn(const std::string& value);

    void setFqdn(isc::data::ConstElementPtr element);

    /// @return a string containing the IP address
    std::string getIpAddress() const {
        return (ip_io_address_.toText());
    }

    /// @return a asiolink::IOAddress containing the IP address
    const asiolink::IOAddress& getIpIoAddress() const {
        return (ip_io_address_);
    }

    /// @return boolean true if the lease address family is AF_INET.
    bool isV4 () const {
        return (ip_io_address_.isV4());
    }

    /// @return boolean true if the lease address family is AF_INET6.
    bool isV6 () const {
        return (ip_io_address_.isV6());
    }

    void setIpAddress(const std::string& value);

    void setIpAddress(isc::data::ConstElementPtr element);

    /// @return a reference to the request's D2Dhcid
    const D2Dhcid& getDhcid() const {
        return (dhcid_);
    }

    void setDhcid(const std::string& value);

    void setDhcid(isc::data::ConstElementPtr element);

    /// @return a string with the request's request ID (currently DHCID)
    std::string getRequestId() const {
        return (dhcid_.toStr());
    }

    /// @return an integer containing the lease length
    uint32_t getLeaseLength() const {
        return (lease_length_);
    }

    void setLeaseLength(const uint32_t value);

    void setLeaseLength(isc::data::ConstElementPtr element);

    /// @return a true if the conflict resolution is enabled.
    ConflictResolutionMode getConflictResolutionMode() const {
        return (conflict_resolution_mode_);
    }

    void setConflictResolutionMode(const ConflictResolutionMode value);

    void setConflictResolutionMode(isc::data::ConstElementPtr element);

    void translateUseConflictResolution(isc::data::ConstElementPtr element);

    /// @return the request status as a NameChangeStatus
    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_;

    uint32_t lease_length_;

    ConflictResolutionMode conflict_resolution_mode_;

    NameChangeStatus status_;
};
 
}  // namespace dhcp_ddns
}  // namespace isc
 
#endif