dhcp6/client_handler.h

Go to the documentation of this file.

// Copyright (C) 2020 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/pkt6.h>
#include <boost/noncopyable.hpp>
#include <boost/multi_index_container.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(Pkt6Ptr query, DuidPtr client_id);

        Pkt6Ptr query_;

        std::vector<uint8_t> duid_;

        std::thread::id thread_;

        Pkt6Ptr next_query_;

        ContinuationPtr cont_;
    };

    typedef boost::shared_ptr<Client> ClientPtr;

    typedef boost::multi_index_container<

        // This container stores pointers to client 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::duid_
                >
            >
        >
    > ClientContainer;

    static ClientPtr lookup(const DuidPtr& duid);

    static void add(const ClientPtr& client);

    static void del(const DuidPtr& duid);

    static std::mutex mutex_;

    static ClientContainer clients_;

public:


    ClientHandler();

    virtual ~ClientHandler();

    bool tryLock(Pkt6Ptr query, ContinuationPtr cont = ContinuationPtr());

private:


    void lock();

    void unLock();

    ClientPtr client_;

    DuidPtr locked_;
};

} // namespace isc
} // namespace dhcp

#endif // CLIENT_HANDLER_H