test_control.h

Go to the documentation of this file.

// Copyright (C) 2012-2024 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 byte2Hex(const uint8_t b);
 
    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