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