ncr_msg.h

Go to the documentation of this file.

// Copyright (C) 2013-2021 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 <exceptions/exceptions.h>
#include <util/buffer.h>
#include <util/time_utilities.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
};

extern NameChangeFormat stringToNcrFormat(const std::string& fmt_str);

extern std::string ncrFormatToString(NameChangeFormat format);

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 bool conflict_resolution = true);

    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);

    bool useConflictResolution() const {
        return (conflict_resolution_);
    }

    void setConflictResolution(const bool value);

    void setConflictResolution(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);
    bool operator != (const NameChangeRequest& b);

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_;

    bool conflict_resolution_;

    NameChangeStatus status_;
};


}; // end of isc::dhcp_ddns namespace
}; // end of isc namespace

#endif