test_control.h

Go to the documentation of this file.

// Copyright (C) 2012-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 TEST_CONTROL_H
#define TEST_CONTROL_H
 
#include <perfdhcp/packet_storage.h>
#include <perfdhcp/rate_control.h>
#include <perfdhcp/stats_mgr.h>
#include <perfdhcp/receiver.h>
#include <perfdhcp/command_options.h>
#include <perfdhcp/perf_socket.h>
 
#include <dhcp/iface_mgr.h>
#include <dhcp/dhcp4.h>
#include <dhcp/dhcp6.h>
#include <dhcp/pkt4.h>
#include <dhcp/pkt6.h>
 
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
 
#include <random>
#include <string>
#include <vector>
 
namespace isc {
namespace perfdhcp {

static const size_t DHCPV4_TRANSID_OFFSET = 4;
static const size_t DHCPV4_RANDOMIZATION_OFFSET = 35;
static const size_t DHCPV4_ELAPSED_TIME_OFFSET = 8;
static const size_t DHCPV4_SERVERID_OFFSET = 54;
static const size_t DHCPV4_REQUESTED_IP_OFFSET = 240;
static const size_t DHCPV6_TRANSID_OFFSET = 1;
static const size_t DHCPV6_RANDOMIZATION_OFFSET = 21;
static const size_t DHCPV6_ELAPSED_TIME_OFFSET = 84;
static const size_t DHCPV6_SERVERID_OFFSET = 22;
static const size_t DHCPV6_IA_NA_OFFSET = 40;

class TestControl : public boost::noncopyable {
public:
    TestControl(CommandOptions& options, BasePerfSocket& socket);

    typedef std::vector<uint8_t> TemplateBuffer;
    typedef std::vector<TemplateBuffer> TemplateBufferCollection;

    bool waitToExit();

    bool haveAllPacketsBeenReceived() const;

    class NumberGenerator {
    public:

        virtual ~NumberGenerator() { }

        virtual uint32_t generate() = 0;
    };

    typedef boost::shared_ptr<NumberGenerator> NumberGeneratorPtr;

    class SequentialGenerator : public NumberGenerator {
    public:
        SequentialGenerator(uint32_t range = 0xFFFFFFFF) :
            NumberGenerator(),
            num_(0),
            range_(range) {
            if (range_ == 0) {
                range_ = 0xFFFFFFFF;
            }
        }

        virtual uint32_t generate() {
            uint32_t num = num_;
            num_ = (num_ + 1) % range_;
            return (num);
        }
    private:
        uint32_t num_;   
        uint32_t range_; 
    };

    class RandomGenerator : public NumberGenerator {
    public:
        RandomGenerator(uint32_t min, uint32_t max) :
            NumberGenerator(),
            distribution_(min, max) {
            // Initialize the randomness source with the current time.
            randomness_generator_.seed(time(0));
        }

        virtual uint32_t generate() {
            return distribution_(randomness_generator_);
        }
 
    private:
        std::uniform_int_distribution<> distribution_;

        std::mt19937 randomness_generator_;
    };

    static const uint8_t HW_ETHER_LEN = 6;

    void setTransidGenerator(const NumberGeneratorPtr& generator) {
        transid_gen_.reset();
        transid_gen_ = generator;
    }

    void setMacAddrGenerator(const NumberGeneratorPtr& generator) {
        macaddr_gen_.reset();
        macaddr_gen_ = generator;
    }

    void cleanCachedPackets();

    bool interrupted() const { return interrupted_; }

    StatsMgr& getStatsMgr() { return stats_mgr_; };

    void start() { receiver_.start(); }

    void stop() { receiver_.stop(); }

    void runWrapped(bool do_stop = false) const;

    bool serverIdReceived() const { return first_packet_serverid_.size() > 0; }

    std::string getServerId() const { return vector2Hex(first_packet_serverid_); }

    void sendPackets(const uint64_t packets_num,
                     const bool preload = false);

    uint64_t sendMultipleMessages4(const uint32_t msg_type,
                                   const uint64_t msg_num);

    uint64_t sendMultipleMessages6(const uint32_t msg_type,
                                   const uint64_t msg_num);

    unsigned int consumeReceivedPackets();

    void printIntermediateStats();

    void printStats() const;

    void printTemplates() const;

    std::set<std::string>& getAllUniqueAddrReply() {
        return unique_reply_address_;
    }

    std::set<std::string>& getAllUniqueAddrAdvert() {
        return unique_address_;
    }

    static std::string vector2Hex(const std::vector<uint8_t>& vec,
                                  const std::string& separator = "");

    boost::posix_time::ptime exit_time_;
 
    // We would really like following methods and members to be private but
    // they have to be accessible for unit-testing. Another, possibly better,
    // solution is to make this class friend of test class but this is not
    // what's followed in other classes.
protected:
    dhcp::Pkt4Ptr createMessageFromAck(const uint16_t msg_type,
                                       const dhcp::Pkt4Ptr& ack);

    dhcp::Pkt6Ptr createMessageFromReply(const uint16_t msg_type,
                                         const dhcp::Pkt6Ptr& reply);

    static dhcp::OptionPtr
    factoryElapsedTime6(dhcp::Option::Universe u,
                        uint16_t type,
                        const dhcp::OptionBuffer& buf);

    static dhcp::OptionPtr factoryGeneric(dhcp::Option::Universe u,
                                          uint16_t type,
                                          const dhcp::OptionBuffer& buf);

    static dhcp::OptionPtr factoryIana6(dhcp::Option::Universe u,
                                        uint16_t type,
                                        const dhcp::OptionBuffer& buf);

    static dhcp::OptionPtr factoryIapd6(dhcp::Option::Universe u,
                                        uint16_t type,
                                        const dhcp::OptionBuffer& buf);

    static dhcp::OptionPtr
    factoryOptionRequestOption6(dhcp::Option::Universe u,
                                uint16_t type,
                                const dhcp::OptionBuffer& buf);

    static dhcp::OptionPtr factoryRapidCommit6(dhcp::Option::Universe u,
                                               uint16_t type,
                                               const dhcp::OptionBuffer& buf);
 

    static dhcp::OptionPtr factoryRequestList4(dhcp::Option::Universe u,
                                               uint16_t type,
                                               const dhcp::OptionBuffer& buf);

    dhcp::OptionPtr generateClientId(const dhcp::HWAddrPtr& hwaddr) const;

    std::vector<uint8_t> generateDuid(uint8_t& randomized);

    std::vector<uint8_t> generateMacAddress(uint8_t& randomized);

    uint32_t generateTransid() {
        return (transid_gen_->generate());
    }

    TemplateBuffer getTemplateBuffer(const size_t idx) const;

    void initPacketTemplates();

    void printRate() const;

    void processReceivedPacket4(const dhcp::Pkt4Ptr& pkt4);

    bool validateIA(const dhcp::Pkt6Ptr& pkt6);

    void address6Uniqueness(const dhcp::Pkt6Ptr& pkt6, ExchangeType xchg_type);

    void address4Uniqueness(const dhcp::Pkt4Ptr& pkt4, ExchangeType xchg_type);

    void addUniqeAddr(const std::set<std::string>& current, ExchangeType xchg_type) {
        switch(xchg_type) {
            case ExchangeType::SA: {
                for (auto const& current_it : current) {
                    // addresses should be unique cross packets
                    auto ret = unique_address_.emplace(current_it);
                    if (!ret.second) {
                        stats_mgr_.updateNonUniqueAddrNum(ExchangeType::SA);
                    }
                }
                break;
            }
            case ExchangeType::RR: {
                for (auto const& current_it : current) {
                    // addresses should be unique cross packets
                    auto ret = unique_reply_address_.emplace(current_it);
                    if (!ret.second) {
                        stats_mgr_.updateNonUniqueAddrNum(ExchangeType::RR);
                    }
                }
                break;
            }
            case ExchangeType::RLA:
            case ExchangeType::RL: {
                removeUniqueAddr(current);
                break;
            }
            case ExchangeType::DO: {
                for (auto const& current_it : current) {
                    // addresses should be unique cross packets
                    auto ret = unique_address_.emplace(current_it);
                    if (!ret.second) {
                        stats_mgr_.updateNonUniqueAddrNum(ExchangeType::DO);
                    }
                }
                break;
            }
            case ExchangeType::RA: {
                for (auto const& current_it : current) {
                    // addresses should be unique cross packets
                    auto ret = unique_reply_address_.emplace(current_it);
                    if (!ret.second) {
                        stats_mgr_.updateNonUniqueAddrNum(ExchangeType::RA);
                    }
                }
                break;
            }
            case ExchangeType::RNA:
            case ExchangeType::RN:
            default:
                break;
        }
    }

    void removeUniqueAddr(const std::set<std::string>& addr) {
        for (auto const& addr_it : addr) {
            auto it = unique_address_.find(addr_it);
            if (it != unique_address_.end()) {
                unique_address_.erase(it);
            }
 
            auto it2 = unique_reply_address_.find(addr_it);
            if (it2 != unique_reply_address_.end()) {
                unique_reply_address_.erase(it2);
            }
        }
    }

    void processReceivedPacket6(const dhcp::Pkt6Ptr& pkt6);

    void registerOptionFactories4() const;

    void registerOptionFactories6() const;

    void registerOptionFactories() const;

    void reset();

    inline void saveFirstPacket(const dhcp::Pkt4Ptr& pkt);

    inline void saveFirstPacket(const dhcp::Pkt6Ptr& pkt);

    void sendDiscover4(const bool preload = false);

    void sendDiscover4(const std::vector<uint8_t>& template_buf,
                       const bool preload = false);

    bool sendMessageFromAck(const uint16_t msg_type);

    bool sendMessageFromReply(const uint16_t msg_type);

    void sendRequest4(const dhcp::Pkt4Ptr& discover_pkt4,
                      const dhcp::Pkt4Ptr& offer_pkt4);

    void sendRequest4(const std::vector<uint8_t>& template_buf,
                      const dhcp::Pkt4Ptr& discover_pkt4,
                      const dhcp::Pkt4Ptr& offer_pkt4);

    void sendRequest6(const dhcp::Pkt6Ptr& advertise_pkt6);

    void sendRequest6(const std::vector<uint8_t>& template_buf,
                      const dhcp::Pkt6Ptr& advertise_pkt6);

    void sendSolicit6(const bool preload = false);

    void sendSolicit6(const std::vector<uint8_t>& template_buf,
                      const bool preload = false);

    void setDefaults4(const dhcp::Pkt4Ptr& pkt);

    void setDefaults6(const dhcp::Pkt6Ptr& pkt);

    void addExtraOpts(const dhcp::Pkt4Ptr& pkt4);

    void addExtraOpts(const dhcp::Pkt6Ptr& pkt6);

    void copyIaOptions(const dhcp::Pkt6Ptr& pkt_from, dhcp::Pkt6Ptr& pkt_to);

    template<class T>
    uint32_t getElapsedTime(const T& pkt1, const T& pkt2);

    int getElapsedTimeOffset() const;

    int getRandomOffset(const int arg_idx) const;

    int getRequestedIpOffset() const;

    int getServerIdOffset() const;

    int getTransactionIdOffset(const int arg_idx) const;

    static void handleChild(int sig);

    static void handleInterrupt(int sig);

    void printDiagnostics() const;

    void printTemplate(const uint8_t packet_type) const;

    void readPacketTemplate(const std::string& file_name);

    std::set<std::string> unique_address_;

    std::set<std::string> unique_reply_address_;

    BasePerfSocket &socket_;

    Receiver receiver_;

    boost::posix_time::ptime last_report_;

    StatsMgr stats_mgr_;

    PacketStorage<dhcp::Pkt4> ack_storage_;

    PacketStorage<dhcp::Pkt6> reply_storage_;

    NumberGeneratorPtr random_generator_;

    NumberGeneratorPtr transid_gen_;

    NumberGeneratorPtr macaddr_gen_;

    dhcp::OptionBuffer first_packet_serverid_;

    TemplateBufferCollection template_buffers_;


    std::map<uint8_t, dhcp::Pkt4Ptr> template_packets_v4_;

    std::map<uint8_t, dhcp::Pkt6Ptr> template_packets_v6_;

    static bool interrupted_;

    CommandOptions& options_;
};
 
}  // namespace perfdhcp
}  // namespace isc
 
#endif // TEST_CONTROL_H