command_options.h

Go to the documentation of this file.

// Copyright (C) 2012-2023 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 COMMAND_OPTIONS_H
#define COMMAND_OPTIONS_H
 
#include <dhcp/option.h>
 
#include <boost/noncopyable.hpp>
#include <stdint.h>
#include <string>
#include <vector>
 
namespace isc {
namespace perfdhcp {
 
enum class Scenario {
    BASIC,
    AVALANCHE
};
 
class CommandOptions : public boost::noncopyable {
public:
 
    CommandOptions() {
        reset();
    }
 
    typedef std::vector<std::vector<uint8_t> > MacAddrsVector;
 
    const static uint8_t RELAY_OPTIONS_MAX_ENCAPSULATION = 1;
 
    class LeaseType {
    public:
 
        enum Type {
            ADDRESS,
            PREFIX,
            ADDRESS_AND_PREFIX
        };
 
        LeaseType();
 
        LeaseType(const Type lease_type);
 
        bool is(const Type lease_type) const;
 
        bool includes(const Type lease_type) const;
 
        void set(const Type lease_type);
 
        void fromCommandLine(const std::string& cmd_line_arg);
 
        std::string toText() const;
 
    private:
        Type type_; 
 
    };
 
    enum ExchangeMode {
        DO_SA,
        DORA_SARR
    };
 
    void reset();
 
    bool parse(int argc, char** const argv, bool print_cmd_line = false);
 
    uint8_t getIpVersion() const { return ipversion_; }
 
    ExchangeMode getExchangeMode() const { return exchange_mode_; }
 
    LeaseType getLeaseType() const { return (lease_type_); }
 
    int getRate() const { return rate_; }
 
    int getRenewRate() const { return (renew_rate_); }
 
    int getReleaseRate() const { return (release_rate_); }
 
    int getReportDelay() const { return report_delay_; }
 
    int getCleanReport() const { return clean_report_; }
 
    std::string getCleanReportSeparator() const { return clean_report_separator_; }
 
    uint32_t getClientsNum() const { return clients_num_; }
 
    std::vector<uint8_t> getMacTemplate() const { return mac_template_; }
 
    std::vector<uint8_t> getDuidTemplate() const { return duid_template_; }
 
    std::vector<std::string> getBase() const { return base_; }
 
    bool getAddrUnique() const { return addr_unique_; }
 
    std::vector<int> getNumRequests() const { return num_request_; }
 
    int getPeriod() const { return period_; }
 
    int getWaitForElapsedTime() const { return wait_for_elapsed_time_; }
 
    int getIncreaseElapsedTime() const { return increased_elapsed_time_; }
 
    std::vector<double> getDropTime() const { return drop_time_; }
 
    std::vector<int> getMaxDrop() const { return max_drop_; }
 
    std::vector<double> getMaxDropPercentage() const { return max_pdrop_; }
 
    std::string getLocalName() const { return localname_; }
 
    bool isInterface() const { return is_interface_; }
 
    int getPreload() const { return preload_; }
 
    int getLocalPort() const { return local_port_; }
 
    int getRemotePort() const { return remote_port_; }
 
    int getExitWaitTime() const { return exit_wait_time_; }
 
    bool isSeeded() const { return seeded_; }
 
    uint32_t getSeed() const { return seed_; }
 
    bool isBroadcast() const { return broadcast_; }
 
    bool isRapidCommit() const { return rapid_commit_; }
 
    bool isUseFirst() const { return use_first_; }
 
    bool isUseRelayedV6() const { return (v6_relay_encapsulation_level_ > 0); }
 
    std::vector<std::string> getTemplateFiles() const { return template_file_; }
 
    std::string getMacListFile() const { return mac_list_file_; }
 
    const MacAddrsVector& getMacsFromFile() const { return mac_list_; }
 
    std::vector<int> getTransactionIdOffset() const { return xid_offset_; }
 
    std::vector<int> getRandomOffset() const { return rnd_offset_; }
 
    int getElapsedTimeOffset() const { return elp_offset_; }
 
    int getServerIdOffset() const { return sid_offset_; }
 
    int getRequestedIpOffset() const { return rip_offset_; }
 
    std::string getDiags() const { return diags_; }
 
    std::string getWrapped() const { return wrapped_; }
 
    const isc::dhcp::OptionCollection& getExtraOpts() const { return extra_opts_; }
 
    const isc::dhcp::OptionCollection& getRelayOpts(uint8_t encapsulation_level = 1) const;
 
    bool isSingleThreaded() const { return single_thread_mode_; }
 
    Scenario getScenario() const { return scenario_; }
 
    std::string getServerName() const { return server_name_; }
 
    std::string getRelayAddrListFile() const { return relay_addr_list_file_; }
 
    std::vector<std::string> getRelayAddrList() const { return relay_addr_list_; }
 
    std::string getRandRelayAddr() { return relay_addr_list_[rand() % relay_addr_list_.size()]; }
 
    bool checkMultiSubnet() { return multi_subnet_; }
 
    bool testDiags(const char diag) {
        if (getDiags().find(diag) != std::string::npos) {
            return (true);
        }
        return (false);
    }
 
    void printCommandLine() const;
 
    static void usage();
 
    void version() const;
 
private:
    bool initialize(int argc, char** argv, bool print_cmd_line);
 
    void validate();
 
    inline void check(bool condition, const std::string& errmsg) const;
 
    int positiveInteger(const std::string& errmsg) const;
 
    int nonNegativeInteger(const std::string& errmsg) const;
 
    std::string nonEmptyString(const std::string& errmsg) const;
 
    void initLeaseType();
 
    void initClientsNum();
 
    void initIsInterface();
 
    //  Function will decode 00:01:02:03:04:05 and/or
    void decodeBase(const std::string& base);
 
    void decodeMacBase(const std::string& base);
 
    void decodeDuid(const std::string& base);
 
    void generateDuidTemplate();
 
    uint8_t convertHexString(const std::string& hex_text) const;
 
    void loadMacs();
 
    bool decodeMacString(const std::string& line);
 
    void loadRelayAddr();
 
    bool validateIP(const std::string& line);
 
    uint8_t ipversion_;
 
    ExchangeMode exchange_mode_;
 
    LeaseType lease_type_;
 
    unsigned int rate_;
 
    unsigned int renew_rate_;
 
    unsigned int release_rate_;
 
    int report_delay_;
 
    bool clean_report_;
 
    std::string clean_report_separator_;
 
    uint32_t clients_num_;
 
    std::vector<uint8_t> mac_template_;
 
    std::vector<uint8_t> duid_template_;
 
    bool addr_unique_;
 
    std::vector<std::string> base_;
 
    int exit_wait_time_;
 
    std::vector<int> num_request_;
 
    int period_;
 
    // for how long perfdhcp will wait before start sending
    // messages with increased elapsed time.
    int wait_for_elapsed_time_;
 
    // Amount of time after which perfdhcp will send messages with
    // elapsed time increased.
    int increased_elapsed_time_;
 
    uint8_t drop_time_set_;
 
    std::vector<double> drop_time_;
 
    std::vector<int> max_drop_;
 
    std::vector<double> max_pdrop_;
 
    std::string localname_;
 
    bool is_interface_;
 
    int preload_;
 
    int local_port_;
 
    int remote_port_;
 
    uint32_t seed_;
 
    bool seeded_;
 
    bool broadcast_;
 
    bool rapid_commit_;
 
    bool use_first_;
 
    std::vector<std::string> template_file_;
 
    std::string mac_list_file_;
 
    std::vector<std::vector<uint8_t> > mac_list_;
 
    std::string relay_addr_list_file_;
 
    std::vector<std::string> relay_addr_list_;
 
    bool multi_subnet_;
 
    std::vector<int> xid_offset_;
 
    std::vector<int> rnd_offset_;
 
    int elp_offset_;
 
    int sid_offset_;
 
    int rip_offset_;
 
    std::string diags_;
 
    std::string wrapped_;
 
    std::string server_name_;
 
    uint8_t v6_relay_encapsulation_level_;
 
    isc::dhcp::OptionCollection extra_opts_;
 
    std::map<uint8_t, isc::dhcp::OptionCollection> relay_opts_;
 
    bool single_thread_mode_;
 
    Scenario scenario_;
};
 
}  // namespace perfdhcp
}  // namespace isc
 
#endif // COMMAND_OPTIONS_H