test_control.h

Go to the documentation of this file.

// Copyright (C) 2012-2018 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 "packet_storage.h"
#include "rate_control.h"
#include "stats_mgr.h"
 
#include <dhcp/iface_mgr.h>
#include <dhcp/dhcp6.h>
#include <dhcp/pkt4.h>
#include <dhcp/pkt6.h>
#include <util/random/random_number_generator.h>
 
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
 
#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 OptionNotFound : public Exception {
public:
    OptionNotFound(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class TestControl : public boost::noncopyable {
public:
 
    typedef StatsMgr<dhcp::Pkt4> StatsMgr4;
    typedef boost::shared_ptr<StatsMgr4> StatsMgr4Ptr;
    typedef StatsMgr<dhcp::Pkt6> StatsMgr6;
    typedef boost::shared_ptr<StatsMgr6> StatsMgr6Ptr;
    typedef StatsMgr<>::ExchangeType ExchangeType;
    typedef std::vector<uint8_t> TemplateBuffer;
    typedef std::vector<TemplateBuffer> TemplateBufferCollection;
 
    bool waitToExit() const;
 
    bool hasLateExitCommenced() const;
 
    bool haveAllPacketsBeenReceived() const;
 
    struct TestControlSocket : public dhcp::SocketInfo {
        uint16_t ifindex_;
        bool valid_;
 
        TestControlSocket(const int socket);
 
        ~TestControlSocket();
 
    private:
        void initSocketData();
    };
 
    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_; 
    };
 
    static const uint8_t HW_ETHER_LEN = 6;
 
    static TestControl& instance();
 
    int run();
 
    void setTransidGenerator(const NumberGeneratorPtr& generator) {
        transid_gen_.reset();
        transid_gen_ = generator;
    }
 
    void setMacAddrGenerator(const NumberGeneratorPtr& generator) {
        macaddr_gen_.reset();
        macaddr_gen_ = generator;
    }
 
    // 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:
    TestControl();
 
    isc::util::random::UniformRandomIntegerGenerator number_generator_;
 
    bool checkExitConditions() const;
 
    void cleanCachedPackets();
 
    dhcp::Pkt4Ptr createRequestFromAck(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());
    }
 
    uint32_t getCurrentTimeout() const;
 
    TemplateBuffer getTemplateBuffer(const size_t idx) const;
 
    void initPacketTemplates();
 
    void initializeStatsMgr();
 
    int openSocket() const;
 
    void printIntermediateStats();
 
    void printRate() const;
 
    void printStats() const;
 
    void processReceivedPacket4(const TestControlSocket& socket,
                                const dhcp::Pkt4Ptr& pkt4);
 
    void processReceivedPacket6(const TestControlSocket& socket,
                                const dhcp::Pkt6Ptr& pkt6);
 
    uint64_t receivePackets(const TestControlSocket& socket);
 
    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 TestControlSocket& socket,
                       const bool preload = false);
 
    void sendDiscover4(const TestControlSocket& socket,
                       const std::vector<uint8_t>& template_buf,
                       const bool preload = false);
 
    void sendPackets(const TestControlSocket &socket,
                     const uint64_t packets_num,
                     const bool preload = false);
 
    uint64_t sendMultipleRequests(const TestControlSocket& socket,
                                  const uint64_t msg_num);
 
    uint64_t sendMultipleMessages6(const TestControlSocket& socket,
                                   const uint32_t msg_type,
                                   const uint64_t msg_num);
 
    bool sendRequestFromAck(const TestControlSocket& socket);
 
    bool sendMessageFromReply(const uint16_t msg_type,
                              const TestControlSocket& socket);
 
    void sendRequest4(const TestControlSocket& socket,
                      const dhcp::Pkt4Ptr& discover_pkt4,
                      const dhcp::Pkt4Ptr& offer_pkt4);
 
    void sendRequest4(const TestControlSocket& socket,
                      const std::vector<uint8_t>& template_buf,
                      const dhcp::Pkt4Ptr& discover_pkt4,
                      const dhcp::Pkt4Ptr& offer_pkt4);
 
    void sendRequest6(const TestControlSocket& socket,
                      const dhcp::Pkt6Ptr& advertise_pkt6);
 
    void sendRequest6(const TestControlSocket& socket,
                      const std::vector<uint8_t>& template_buf,
                      const dhcp::Pkt6Ptr& advertise_pkt6);
 
    void sendSolicit6(const TestControlSocket& socket,
                      const bool preload = false);
 
    void sendSolicit6(const TestControlSocket& socket,
                      const std::vector<uint8_t>& template_buf,
                      const bool preload = false);
 
    void setDefaults4(const TestControlSocket& socket,
                      const dhcp::Pkt4Ptr& pkt);
 
    void setDefaults6(const TestControlSocket& socket,
                      const dhcp::Pkt6Ptr& pkt);
 
    void addExtraOpts(const dhcp::Pkt4Ptr& pkt4);
 
    void addExtraOpts(const dhcp::Pkt6Ptr& pkt6);
 
    bool testDiags(const char diag) const;
 
protected:
 
    void checkLateMessages(RateControl& rate_control);
 
    void copyIaOptions(const dhcp::Pkt6Ptr& pkt_from, dhcp::Pkt6Ptr& pkt_to);
 
    std::string byte2Hex(const uint8_t b) const;
 
    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;
 
    uint64_t getRcvdPacketsNum(ExchangeType xchg_type) const;
 
    uint64_t getSentPacketsNum(ExchangeType xchg_type) const;
 
    static void handleChild(int sig);
 
    static void handleInterrupt(int sig);
 
    void printDiagnostics() const;
 
    void printTemplate(const uint8_t packet_type) const;
 
    void printTemplates() const;
 
    void readPacketTemplate(const std::string& file_name);
 
    void runWrapped(bool do_stop = false) const;
 
    std::string vector2Hex(const std::vector<uint8_t>& vec,
                           const std::string& separator = "") const;
 
    RateControl basic_rate_control_;
    RateControl renew_rate_control_;
    RateControl release_rate_control_;
 
    boost::posix_time::ptime last_report_; 
 
    StatsMgr4Ptr stats_mgr4_;  
    StatsMgr6Ptr stats_mgr6_;  
 
    PacketStorage<dhcp::Pkt4> ack_storage_; 
    PacketStorage<dhcp::Pkt6> reply_storage_; 
 
    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_;  
};
 
}  // namespace perfdhcp
}  // namespace isc
 
#endif // TEST_CONTROL_H