bulk_lease_query4.h

Go to the documentation of this file.

// Copyright (C) 2023-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 BULK_LEASE_QUERY4_H
#define BULK_LEASE_QUERY4_H
 
#include <config.h>
 
#include <dhcp/dhcp4.h>
#include <dhcpsrv/lease.h>
#include <lease_query/bulk_lease_query.h>
#include <lease_query/lease_query_impl.h>
 
#include <cstdint>
 
namespace isc {
namespace lease_query {

enum BLQStatusCode : uint16_t {
    BLQ_STATUS_Success          = 0,
    BLQ_STATUS_UnspecFail       = 1,
    BLQ_STATUS_QueryTerminated  = 2,
    BLQ_STATUS_MalformedQuery   = 3,
    BLQ_STATUS_NotAllowed       = 4
};

std::string getStatusCodeName(BLQStatusCode status);

enum BLQStates : uint16_t {
    BLQ_STATE_AVAILABLE      = 1,
    BLQ_STATE_ACTIVE         = 2,
    BLQ_STATE_EXPIRED        = 3,
    BLQ_STATE_RELEASED       = 4,
    BLQ_STATE_ABANDONED      = 5,
    BLQ_STATE_RESET          = 6,
    BLQ_STATE_REMOTE         = 7,
    BLQ_STATE_TRANSITIONING  = 8
};

std::string getStateName(BLQStates state);

#ifndef DHO_VSS
#define DHO_VSS 221
#endif

class BulkLeaseQuery4;

typedef boost::shared_ptr<BulkLeaseQuery4> BulkLeaseQuery4Ptr;

class BulkLeaseQuery4 : public BulkLeaseQuery {
public:

    BulkLeaseQuery4(BlqQueryPtr query,
                    const BlqPostCb& post,
                    const BlqPushToSendCb& push_to_send,
                    const BlqQueryCompleteCb& query_complete)
        : BulkLeaseQuery(query, post, push_to_send, query_complete),
          query4_(),
          start_addr_(asiolink::IOAddress::IPV4_ZERO_ADDRESS()),
          page_size_(10),
          query_mask_(0),
          query_client_id_(), query_hwaddr_(),
          query_relay_id_(), query_remote_id_(),
          query_start_time_(0), query_end_time_(0),
          sent_(0) {
        init();
    }

    virtual ~BulkLeaseQuery4() {
    }

    static std::string leaseQueryLabel(const BlqMsgPtr& msg);

    virtual void init();

    virtual void start();

    dhcp::Pkt4Ptr getQuery4() const {
        return (query4_);
    }

    asiolink::IOAddress getStartAddress() const {
        return (start_addr_);
    }

    size_t getPageSize() const {
        return (page_size_);
    }
 
protected:
    void bulkQueryByClientId();

    void bulkQueryByHWAddr();

    void bulkQueryByRelayId();

    void bulkQueryByRemoteId();

    static void doBulkQueryByRelayId(BulkLeaseQuery4Ptr ptr) {
        if (!ptr) {
            // Should not happen.
            return;
        }
        ptr->bulkQueryByRelayId();
    }

    static void doBulkQueryByRemoteId(BulkLeaseQuery4Ptr ptr) {
        if (!ptr) {
            // Should not happen.
            return;
        }
        ptr->bulkQueryByRemoteId();
    }

    virtual void send(dhcp::Pkt4Ptr response);

    virtual void sendDone(BLQStatusCode status,
                          const std::string& message = "");

    virtual void sendActive(const dhcp::Lease4Ptr& lease);

    uint8_t getQueryMask() const {
        return (query_mask_);
    }

    dhcp::OptionPtr getQueryClientId() const {
        return (query_client_id_);
    }

    dhcp::HWAddrPtr getQueryHWAddr() const {
        return (query_hwaddr_);
    }

    dhcp::OptionPtr getQueryRelayId() const {
        return (query_relay_id_);
    }

    dhcp::OptionPtr getQueryRemoteId() const {
        return (query_remote_id_);
    }

    dhcp::Pkt4Ptr query4_;

    asiolink::IOAddress start_addr_;

    size_t page_size_;

    uint8_t query_mask_;

    dhcp::OptionPtr query_client_id_;

    dhcp::HWAddrPtr query_hwaddr_;

    dhcp::OptionPtr query_relay_id_;

    dhcp::OptionPtr query_remote_id_;

    time_t query_start_time_;

    time_t query_end_time_;

    size_t sent_;
};
 
} // end of namespace isc::lease_query
} // end of namespace isc
 
#endif // BULK_LEASE_QUERY4_H