dhcp4/client_handler.h

Go to the documentation of this file.

// Copyright (C) 2020-2023 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 CLIENT_HANDLER_H
#define CLIENT_HANDLER_H
 
#include <dhcp/pkt4.h>
#include <boost/noncopyable.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/shared_ptr.hpp>
#include <functional>
#include <mutex>
#include <thread>
 
namespace isc {
namespace dhcp {
 
typedef std::function<void()> Continuation;
 
typedef boost::shared_ptr<Continuation> ContinuationPtr;
 
inline ContinuationPtr makeContinuation(Continuation&& cont) {
    return (boost::make_shared<Continuation>(cont));
}
 
class ClientHandler : public boost::noncopyable {
private:
 
 
    struct Client {
 
        Client(Pkt4Ptr query, ClientIdPtr client_id, HWAddrPtr hwaddr);
 
        Pkt4Ptr query_;
 
        std::vector<uint8_t> client_id_;
 
        uint16_t htype_;
 
        std::vector<uint8_t> hwaddr_;
 
        std::thread::id thread_;
 
        Pkt4Ptr next_query_;
 
        ContinuationPtr cont_;
    };
 
    typedef boost::shared_ptr<Client> ClientPtr;
 
    typedef boost::multi_index_container<
 
        // This container stores pointers to client-by-id objects.
        ClientPtr,
 
        // Start specification of indexes here.
        boost::multi_index::indexed_by<
 
            // First index is used to search by Duid.
            boost::multi_index::hashed_unique<
 
                // Client ID binary content as a member of the Client object.
                boost::multi_index::member<
                    Client, std::vector<uint8_t>, &Client::client_id_
                >
            >
        >
    > ClientByIdContainer;
 
    typedef boost::multi_index_container<
 
        // This container stores pointers to client-by-hwaddr objects.
        ClientPtr,
 
        // Start specification of indexes here.
        boost::multi_index::indexed_by<
 
            // First index is used to search by HWAddr.
            boost::multi_index::hashed_unique<
 
                // This is a composite index for type and binary components.
                boost::multi_index::composite_key<
                    Client,
                    boost::multi_index::member<
                        Client, uint16_t, &Client::htype_
                    >,
                    boost::multi_index::member<
                        Client, std::vector<uint8_t>, &Client::hwaddr_
                    >
                >
            >
        >
    > ClientByHWAddrContainer;
 
    static ClientPtr lookup(const ClientIdPtr& client_id);
 
    static ClientPtr lookup(const HWAddrPtr& hwaddr);
 
    static void addById(const ClientPtr& client);
 
    static void addByHWAddr(const ClientPtr& client);
 
    static void del(const ClientIdPtr& client_id);
 
    static void del(const HWAddrPtr& hwaddr);
 
    static std::mutex mutex_;
 
    static ClientByIdContainer clients_client_id_;
 
    static ClientByHWAddrContainer clients_hwaddr_;
 
public:
 
 
    ClientHandler();
 
    virtual ~ClientHandler();
 
    bool tryLock(Pkt4Ptr query, ContinuationPtr cont = ContinuationPtr());
 
private:
 
 
    void lockById();
 
    void lockByHWAddr();
 
    void unLockById();
 
    void unLockByHWAddr();
 
    ClientPtr client_;
 
    ClientIdPtr locked_client_id_;
 
    HWAddrPtr locked_hwaddr_;
};
 
} // namespace isc
} // namespace dhcp
 
#endif // CLIENT_HANDLER_H