command_options.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 COMMAND_OPTIONS_H
#define COMMAND_OPTIONS_H
 
#include <dhcp/option.h>
 
#include <cstdint>
#include <string>
#include <vector>
 
#include <boost/noncopyable.hpp>
 
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 : uint16_t {
            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 : uint16_t {
        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;

    void extendedVersion() 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