diff options
Diffstat (limited to 'src/bin/perfdhcp/command_options.cc')
| -rw-r--r-- | src/bin/perfdhcp/command_options.cc | 1450 |
1 files changed, 1450 insertions, 0 deletions
diff --git a/src/bin/perfdhcp/command_options.cc b/src/bin/perfdhcp/command_options.cc new file mode 100644 index 0000000..fa6772e --- /dev/null +++ b/src/bin/perfdhcp/command_options.cc @@ -0,0 +1,1450 @@ +// 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/. + +#include <config.h> + +#include <perfdhcp/command_options.h> + +#include <asiolink/io_error.h> +#include <exceptions/exceptions.h> +#include <dhcp/iface_mgr.h> +#include <dhcp/duid.h> +#include <dhcp/option.h> +#include <process/cfgrpt/config_report.h> +#include <util/encode/hex.h> + +#include <boost/lexical_cast.hpp> +#include <boost/date_time/posix_time/posix_time.hpp> +#include <sstream> +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <unistd.h> +#include <fstream> +#include <thread> +#include <getopt.h> + +#ifdef HAVE_OPTRESET +extern int optreset; +#endif + +using namespace std; +using namespace isc; +using namespace isc::dhcp; + +namespace isc { +namespace perfdhcp { + +CommandOptions::LeaseType::LeaseType() + : type_(ADDRESS) { +} + +CommandOptions::LeaseType::LeaseType(const Type lease_type) + : type_(lease_type) { +} + +bool +CommandOptions::LeaseType::is(const Type lease_type) const { + return (lease_type == type_); +} + +bool +CommandOptions::LeaseType::includes(const Type lease_type) const { + return (is(ADDRESS_AND_PREFIX) || (lease_type == type_)); +} + +void +CommandOptions::LeaseType::set(const Type lease_type) { + type_ = lease_type; +} + +void +CommandOptions::LeaseType::fromCommandLine(const std::string& cmd_line_arg) { + if (cmd_line_arg == "address-only") { + type_ = ADDRESS; + + } else if (cmd_line_arg == "prefix-only") { + type_ = PREFIX; + + } else if (cmd_line_arg == "address-and-prefix") { + type_ = ADDRESS_AND_PREFIX; + + } else { + isc_throw(isc::InvalidParameter, "value of lease-type: -e<lease-type>," + " must be one of the following: 'address-only' or" + " 'prefix-only'"); + } +} + +std::string +CommandOptions::LeaseType::toText() const { + switch (type_) { + case ADDRESS: + return ("address-only (IA_NA option added to the client's request)"); + case PREFIX: + return ("prefix-only (IA_PD option added to the client's request)"); + case ADDRESS_AND_PREFIX: + return ("address-and-prefix (Both IA_NA and IA_PD options added to the" + " client's request)"); + default: + isc_throw(Unexpected, "internal error: undefined lease type code when" + " returning textual representation of the lease type"); + } +} + +void +CommandOptions::reset() { + // Default mac address used in DHCP messages + // if -b mac=<mac-address> was not specified + uint8_t mac[6] = { 0x0, 0xC, 0x1, 0x2, 0x3, 0x4 }; + + // Default packet drop time if -D<drop-time> parameter + // was not specified + double dt[2] = { 1., 1. }; + + // We don't use constructor initialization list because we + // will need to reset all members many times to perform unit tests + ipversion_ = 0; + exchange_mode_ = DORA_SARR; + lease_type_.set(LeaseType::ADDRESS); + rate_ = 0; + renew_rate_ = 0; + release_rate_ = 0; + report_delay_ = 0; + clean_report_ = false; + clean_report_separator_ = ""; + clients_num_ = 0; + mac_template_.assign(mac, mac + 6); + duid_template_.clear(); + base_.clear(); + addr_unique_ = false; + mac_list_file_.clear(); + mac_list_.clear(); + relay_addr_list_file_.clear(); + relay_addr_list_.clear(); + multi_subnet_ = false; + num_request_.clear(); + exit_wait_time_ = 0; + period_ = 0; + wait_for_elapsed_time_ = -1; + increased_elapsed_time_ = -1; + drop_time_set_ = 0; + drop_time_.assign(dt, dt + 2); + max_drop_.clear(); + max_pdrop_.clear(); + localname_.clear(); + is_interface_ = false; + preload_ = 0; + local_port_ = 0; + remote_port_ = 0; + seeded_ = false; + seed_ = 0; + broadcast_ = false; + rapid_commit_ = false; + use_first_ = false; + template_file_.clear(); + rnd_offset_.clear(); + xid_offset_.clear(); + elp_offset_ = -1; + sid_offset_ = -1; + rip_offset_ = -1; + diags_.clear(); + wrapped_.clear(); + server_name_.clear(); + v6_relay_encapsulation_level_ = 0; + generateDuidTemplate(); + extra_opts_.clear(); + if (std::thread::hardware_concurrency() == 1) { + single_thread_mode_ = true; + } else { + single_thread_mode_ = false; + } + scenario_ = Scenario::BASIC; + for (uint8_t i = 1; i <= RELAY_OPTIONS_MAX_ENCAPSULATION ; i++) { + OptionCollection option_collection; + relay_opts_[i] = option_collection; + } +} + +bool +CommandOptions::parse(int argc, char** const argv, bool print_cmd_line) { + // Reset internal variables used by getopt + // to eliminate undefined behavior when + // parsing different command lines multiple times + +#ifdef __GLIBC__ + // Warning: non-portable code. This is due to a bug in glibc's + // getopt() which keeps internal state about an old argument vector + // (argc, argv) from last call and tries to scan them when a new + // argument vector (argc, argv) is passed. As the old vector may not + // be main()'s arguments, but heap allocated and may have been freed + // since, this becomes a use after free and results in random + // behavior. According to the NOTES section in glibc getopt()'s + // manpage, setting optind=0 resets getopt()'s state. Though this is + // not required in our usage of getopt(), the bug still happens + // unless we set optind=0. + // + // Setting optind=0 is non-portable code. + optind = 0; +#else + optind = 1; +#endif + + // optreset is declared on BSD systems and is used to reset internal + // state of getopt(). When parsing command line arguments multiple + // times with getopt() the optreset must be set to 1 every time before + // parsing starts. Failing to do so will result in random behavior of + // getopt(). +#ifdef HAVE_OPTRESET + optreset = 1; +#endif + + opterr = 0; + + // Reset values of class members + reset(); + + // Informs if program has been run with 'h' or 'v' option. + bool help_or_version_mode = initialize(argc, argv, print_cmd_line); + if (!help_or_version_mode) { + validate(); + } + return (help_or_version_mode); +} + +const int LONG_OPT_SCENARIO = 300; +const int LONG_OPT_RELAY_OPTION = 400; + +bool +CommandOptions::initialize(int argc, char** argv, bool print_cmd_line) { + int opt = 0; // Subsequent options returned by getopt() + int opt_long_index = 0; // Holds index of long_option inside of long_options[] + std::string drop_arg; // Value of -D<value>argument + size_t percent_loc = 0; // Location of % sign in -D<value> + double drop_percent = 0; // % value (1..100) in -D<value%> + int num_drops = 0; // Max number of drops specified in -D<value> + int num_req = 0; // Max number of dropped + // requests in -n<max-drops> + int offset_arg = 0; // Temporary variable holding offset arguments + std::string sarg; // Temporary variable for string args + + std::ostringstream stream; + stream << "perfdhcp"; + int num_mac_list_files = 0; + int num_subnet_list_files = 0; + + struct option long_options[] = { + {"scenario", required_argument, 0, LONG_OPT_SCENARIO}, + {"or", required_argument, 0, LONG_OPT_RELAY_OPTION}, + {0, 0, 0, 0} + }; + + // In this section we collect argument values from command line + // they will be tuned and validated elsewhere + while((opt = getopt_long(argc, argv, + "huv46A:r:t:R:b:n:p:d:D:l:P:a:L:N:M:s:iBc1" + "J:T:X:O:o:E:S:I:x:W:w:e:f:F:g:C:y:Y:", + long_options, &opt_long_index)) != -1) { + stream << " -"; + opt <= 'z' ? stream << static_cast<char>(opt) : + stream << "-" << long_options[opt_long_index].name; + if (optarg) { + stream << " " << optarg; + } + switch (opt) { + case '1': + use_first_ = true; + break; + + // Simulate DHCPv6 relayed traffic. + case 'A': + // @todo: At the moment we only support simulating a single relay + // agent. In the future we should extend it to up to 32. + // See comment in https://github.com/isc-projects/kea/pull/22#issuecomment-243405600 + v6_relay_encapsulation_level_ = + static_cast<uint8_t>(positiveInteger("-A<encapsulation-level> must" + " be a positive integer")); + if (v6_relay_encapsulation_level_ != 1) { + isc_throw(isc::InvalidParameter, "-A only supports 1 at the moment."); + } + break; + + case 'u': + addr_unique_ = true; + break; + + case '4': + check(ipversion_ == 6, "IP version already set to 6"); + ipversion_ = 4; + break; + + case '6': + check(ipversion_ == 4, "IP version already set to 4"); + ipversion_ = 6; + break; + + case 'b': + check(base_.size() > 3, "-b<value> already specified," + " unexpected occurrence of 5th -b<value>"); + base_.push_back(optarg ? optarg : ""); + decodeBase(base_.back()); + break; + + case 'B': + broadcast_ = true; + break; + + case 'c': + rapid_commit_ = true; + break; + + case 'C': + clean_report_ = true; + clean_report_separator_ = optarg ? optarg : ""; + break; + + case 'd': + check(drop_time_set_ > 1, + "maximum number of drops already specified, " + "unexpected 3rd occurrence of -d<value>"); + try { + drop_time_[drop_time_set_] = + boost::lexical_cast<double>(optarg ? optarg : ""); + } catch (const boost::bad_lexical_cast&) { + isc_throw(isc::InvalidParameter, + "value of drop time: -d<value>" + " must be positive number"); + } + check(drop_time_[drop_time_set_] <= 0., + "drop-time must be a positive number"); + drop_time_set_ = true; + break; + + case 'D': + drop_arg = std::string(optarg ? optarg : ""); + percent_loc = drop_arg.find('%'); + check(max_pdrop_.size() > 1 || max_drop_.size() > 1, + "values of maximum drops: -D<value> already " + "specified, unexpected 3rd occurrence of -D<value>"); + if ((percent_loc) != std::string::npos) { + try { + drop_percent = + boost::lexical_cast<double>(drop_arg.substr(0, percent_loc)); + } catch (const boost::bad_lexical_cast&) { + isc_throw(isc::InvalidParameter, + "value of drop percentage: -D<value%>" + " must be 0..100"); + } + check((drop_percent <= 0) || (drop_percent >= 100), + "value of drop percentage: -D<value%> must be 0..100"); + max_pdrop_.push_back(drop_percent); + } else { + num_drops = positiveInteger("value of max drops number:" + " -D<value> must be a positive integer"); + max_drop_.push_back(num_drops); + } + break; + + case 'e': + initLeaseType(); + break; + + case 'E': + elp_offset_ = nonNegativeInteger("value of time-offset: -E<value>" + " must not be a negative integer"); + break; + + case 'f': + renew_rate_ = positiveInteger("value of the renew rate: -f<renew-rate>" + " must be a positive integer"); + break; + + case 'F': + release_rate_ = positiveInteger("value of the release rate:" + " -F<release-rate> must be a" + " positive integer"); + break; + + case 'g': { + std::string optarg_text(optarg ? optarg : ""); + if (optarg_text == "single") { + single_thread_mode_ = true; + } else if (optarg_text == "multi") { + single_thread_mode_ = false; + } else { + if (optarg) { + isc_throw(InvalidParameter, "value of thread mode (-g) '" << optarg << "' is wrong - should be '-g single' or '-g multi'"); + } else { + isc_throw(InvalidParameter, "value of thread mode (-g) is wrong - should be '-g single' or '-g multi'"); + } + } + break; + } + case 'h': + usage(); + return (true); + + case 'i': + exchange_mode_ = DO_SA; + break; + + case 'I': + rip_offset_ = positiveInteger("value of ip address offset:" + " -I<value> must be a" + " positive integer"); + break; + + case 'J': + check(num_subnet_list_files >= 1, "only one -J option can be specified"); + num_subnet_list_files++; + relay_addr_list_file_ = std::string(optarg ? optarg : ""); + loadRelayAddr(); + break; + + case 'l': + localname_ = std::string(optarg ? optarg : ""); + initIsInterface(); + break; + + case 'L': + local_port_ = nonNegativeInteger("value of local port:" + " -L<value> must not be a" + " negative integer"); + check(local_port_ > + static_cast<int>(std::numeric_limits<uint16_t>::max()), + "local-port must be lower than " + + boost::lexical_cast<std::string>(std::numeric_limits<uint16_t>::max())); + break; + + case 'N': + remote_port_ = nonNegativeInteger("value of remote port:" + " -L<value> must not be a" + " negative integer"); + check(remote_port_ > + static_cast<int>(std::numeric_limits<uint16_t>::max()), + "remote-port must be lower than " + + boost::lexical_cast<std::string>(std::numeric_limits<uint16_t>::max())); + break; + + case 'M': + check(num_mac_list_files >= 1, "only one -M option can be specified"); + num_mac_list_files++; + mac_list_file_ = std::string(optarg ? optarg : ""); + loadMacs(); + break; + + case 'W': + exit_wait_time_ = nonNegativeInteger("value of exist wait time: " + "-W<value> must not be a " + "negative integer"); + break; + + case 'n': + num_req = positiveInteger("value of num-request:" + " -n<value> must be a positive integer"); + if (num_request_.size() >= 2) { + isc_throw(isc::InvalidParameter, + "value of maximum number of requests: -n<value> " + "already specified, unexpected 3rd occurrence" + " of -n<value>"); + } + num_request_.push_back(num_req); + break; + + case 'O': + if (rnd_offset_.size() < 2) { + offset_arg = positiveInteger("value of random offset: " + "-O<value> must be greater than 3"); + } else { + isc_throw(isc::InvalidParameter, + "random offsets already specified," + " unexpected 3rd occurrence of -O<value>"); + } + check(offset_arg < 3, "value of random random-offset:" + " -O<value> must be greater than 3 "); + rnd_offset_.push_back(offset_arg); + break; + case 'o': { + + // we must know how to contruct the option: whether it's v4 or v6. + check( (ipversion_ != 4) && (ipversion_ != 6), + "-4 or -6 must be explicitly specified before -o is used."); + + // custom option (expected format: code,hexstring) + std::string opt_text(optarg ? optarg : ""); + size_t comma_loc = opt_text.find(','); + check(comma_loc == std::string::npos, + "-o option must provide option code, a comma and hexstring for" + " the option content, e.g. -o60,646f63736973 for sending option" + " 60 (class-id) with the value 'docsis'"); + int code = 0; + + // Try to parse the option code + try { + code = boost::lexical_cast<int>(opt_text.substr(0, comma_loc)); + check(code <= 0, "Option code can't be negative"); + } catch (const boost::bad_lexical_cast&) { + isc_throw(InvalidParameter, "Invalid option code specified for " + "-o option, expected format: -o<integer>,<hexstring>"); + } + + // Now try to interpret the hexstring + opt_text = opt_text.substr(comma_loc + 1); + std::vector<uint8_t> bin; + try { + isc::util::encode::decodeHex(opt_text, bin); + } catch (const BadValue& e) { + isc_throw(InvalidParameter, "Error during encoding option -o:" + << e.what()); + } + + // Create and remember the option. + OptionPtr opt(new Option(ipversion_ == 4 ? Option::V4 : Option::V6, + code, bin)); + extra_opts_.insert(make_pair(code, opt)); + break; + } + case 'p': + period_ = positiveInteger("value of test period:" + " -p<value> must be a positive integer"); + break; + + case 'P': + preload_ = nonNegativeInteger("number of preload packets:" + " -P<value> must not be " + "a negative integer"); + break; + + case 'r': + rate_ = positiveInteger("value of rate:" + " -r<value> must be a positive integer"); + break; + + case 'R': + initClientsNum(); + break; + + case 's': + seed_ = static_cast<unsigned int> + (nonNegativeInteger("value of seed:" + " -s <seed> must be non-negative integer")); + seeded_ = seed_ > 0 ? true : false; + break; + + case 'S': + sid_offset_ = positiveInteger("value of server id offset:" + " -S<value> must be a" + " positive integer"); + break; + + case 't': + report_delay_ = positiveInteger("value of report delay:" + " -t<value> must be a" + " positive integer"); + break; + + case 'T': + if (template_file_.size() < 2) { + sarg = nonEmptyString("template file name not specified," + " expected -T<filename>"); + template_file_.push_back(sarg); + } else { + isc_throw(isc::InvalidParameter, + "template files are already specified," + " unexpected 3rd -T<filename> occurrence"); + } + break; + + case 'v': + version(); + return (true); + + case 'w': + wrapped_ = nonEmptyString("command for wrapped mode:" + " -w<command> must be specified"); + break; + + case 'x': + diags_ = nonEmptyString("value of diagnostics selectors:" + " -x<value> must be specified"); + break; + + case 'X': + if (xid_offset_.size() < 2) { + offset_arg = positiveInteger("value of transaction id:" + " -X<value> must be a" + " positive integer"); + } else { + isc_throw(isc::InvalidParameter, + "transaction ids already specified," + " unexpected 3rd -X<value> occurrence"); + } + xid_offset_.push_back(offset_arg); + break; + + case 'Y': + wait_for_elapsed_time_ = nonNegativeInteger("value of time:" + " -Y<value> must be a non negative integer"); + break; + + case 'y': + increased_elapsed_time_ = positiveInteger("value of time:" + " -y<value> must be a positive integer"); + break; + + case LONG_OPT_SCENARIO: { + std::string optarg_text(optarg ? optarg : ""); + if (optarg_text == "basic") { + scenario_ = Scenario::BASIC; + } else if (optarg_text == "avalanche") { + scenario_ = Scenario::AVALANCHE; + } else { + isc_throw(InvalidParameter, "scenario value '" << optarg_text << "' is wrong - should be 'basic' or 'avalanche'"); + } + break; + } + + case LONG_OPT_RELAY_OPTION: { + // for now this is only available for v6 + // and must be used together with -A option. + check((ipversion_ != 6), + "-6 must be explicitly specified before --or is used."); + check(v6_relay_encapsulation_level_ <= 0, + "-A must be explicitly specified before --or is used."); + + // custom option (expected format: encapsulation-level:code,hexstring) + std::string opt_text(optarg ? optarg : ""); + size_t colon_loc = opt_text.find(':'); + size_t comma_loc = opt_text.find(','); + + // if encapsulation level is skipped by user, let's assume it is 1 + uint8_t option_encapsulation_level = 1; + if (colon_loc == std::string::npos) { + // if colon was not found, default encapsulation level will be used + // and let's reset colon_loc to -1 so option code could be parsed later + colon_loc = -1; + } else { + // Try to parse the encapsulation level + try { + option_encapsulation_level = + boost::lexical_cast<int>(opt_text.substr(0, colon_loc)); + check(option_encapsulation_level != 1, "Relayed option encapsulation level " + "supports only value 1 at the moment."); + } catch (const boost::bad_lexical_cast&) { + isc_throw(InvalidParameter, + "Invalid relayed option encapsulation level specified for " + "--or option, expected format: --or <integer>:<integer>,<hexstring>"); + } + } + + check(comma_loc == std::string::npos, + "--or option must provide encapsulation level, a colon, option code, a comma and " + "hexstring for the option content, e.g. --or 1:38,31323334 for sending option" + " 38 (subscriber-id) with the value 1234 at first level of encapsulation"); + int code = 0; + + // Try to parse the option code + try { + code = boost::lexical_cast<int>( + opt_text.substr(colon_loc + 1, comma_loc - colon_loc - 1)); + check(code <= 0, "Option code can't be negative or zero"); + } catch (const boost::bad_lexical_cast&) { + isc_throw(InvalidParameter, + "Invalid option code specified for " + "--or option, expected format: --or <integer>:<integer>,<hexstring>"); + } + + // Now try to interpret the hexstring + opt_text = opt_text.substr(comma_loc + 1); + std::vector<uint8_t> bin; + try { + isc::util::encode::decodeHex(opt_text, bin); + } catch (const BadValue& e) { + isc_throw(InvalidParameter, "Error during decoding option --or:" << e.what()); + } + + // Create and remember the option. + OptionPtr option(new Option(Option::V6, code, bin)); + auto relay_opts = relay_opts_.find(option_encapsulation_level); + relay_opts->second.insert(make_pair(code, option)); + break; + } + default: + isc_throw(isc::InvalidParameter, "wrong command line option"); + } + } + + // If the IP version was not specified in the + // command line, assume IPv4. + if (ipversion_ == 0) { + ipversion_ = 4; + } + + // If template packet files specified for both DISCOVER/SOLICIT + // and REQUEST/REPLY exchanges make sure we have transaction id + // and random duid offsets for both exchanges. We will duplicate + // value specified as -X<value> and -R<value> for second + // exchange if user did not specified otherwise. + if (template_file_.size() > 1) { + if (xid_offset_.size() == 1) { + xid_offset_.push_back(xid_offset_[0]); + } + if (rnd_offset_.size() == 1) { + rnd_offset_.push_back(rnd_offset_[0]); + } + } + + // Get server argument + // NoteFF02::1:2 and FF02::1:3 are defined in RFC 8415 as + // All_DHCP_Relay_Agents_and_Servers and All_DHCP_Servers + // addresses + check(optind < argc -1, "extra arguments?"); + if (optind == argc - 1) { + server_name_ = argv[optind]; + stream << " " << server_name_; + // Decode special cases + if ((ipversion_ == 4) && (server_name_.compare("all") == 0)) { + broadcast_ = true; + // Use broadcast address as server name. + server_name_ = DHCP_IPV4_BROADCAST_ADDRESS; + } else if ((ipversion_ == 6) && (server_name_.compare("all") == 0)) { + server_name_ = ALL_DHCP_RELAY_AGENTS_AND_SERVERS; + } else if ((ipversion_ == 6) && + (server_name_.compare("servers") == 0)) { + server_name_ = ALL_DHCP_SERVERS; + } + } + if (!getCleanReport()) { + if (print_cmd_line) { + std::cout << "Running: " << stream.str() << std::endl; + } + + if (scenario_ == Scenario::BASIC) { + std::cout << "Scenario: basic." << std::endl; + } else if (scenario_ == Scenario::AVALANCHE) { + std::cout << "Scenario: avalanche." << std::endl; + } + + if (!isSingleThreaded()) { + std::cout << "Multi-thread mode enabled." << std::endl; + } + } + + // Handle the local '-l' address/interface + if (!localname_.empty()) { + if (server_name_.empty()) { + if (is_interface_ && (ipversion_ == 4)) { + broadcast_ = true; + server_name_ = DHCP_IPV4_BROADCAST_ADDRESS; + } else if (is_interface_ && (ipversion_ == 6)) { + server_name_ = ALL_DHCP_RELAY_AGENTS_AND_SERVERS; + } + } + } + if (server_name_.empty()) { + isc_throw(InvalidParameter, + "without an interface, server is required"); + } + + // If DUID is not specified from command line we need to + // generate one. + if (duid_template_.empty()) { + generateDuidTemplate(); + } + return (false); +} + +void +CommandOptions::initClientsNum() { + const std::string errmsg = + "value of -R <value> must be non-negative integer"; + + try { + // Declare clients_num as a 64-bit signed value to + // be able to detect negative values provided + // by user. We would not detect negative values + // if we casted directly to unsigned value. + long long clients_num = boost::lexical_cast<long long>(optarg ? optarg : ""); + check(clients_num < 0, errmsg); + clients_num_ = boost::lexical_cast<uint32_t>(optarg ? optarg : ""); + } catch (const boost::bad_lexical_cast&) { + isc_throw(isc::InvalidParameter, errmsg); + } +} + +void +CommandOptions::initIsInterface() { + is_interface_ = false; + if (!localname_.empty()) { + dhcp::IfaceMgr& iface_mgr = dhcp::IfaceMgr::instance(); + if (iface_mgr.getIface(localname_) != NULL) { + is_interface_ = true; + } + } +} + +void +CommandOptions::decodeBase(const std::string& base) { + std::string b(base); + boost::algorithm::to_lower(b); + + // Currently we only support mac and duid + if ((b.substr(0, 4) == "mac=") || (b.substr(0, 6) == "ether=")) { + decodeMacBase(b); + } else if (b.substr(0, 5) == "duid=") { + decodeDuid(b); + } else { + isc_throw(isc::InvalidParameter, + "base value not provided as -b<value>," + " expected -b mac=<mac> or -b duid=<duid>"); + } +} + +void +CommandOptions::decodeMacBase(const std::string& base) { + // Strip string from mac= + size_t found = base.find('='); + static const char* errmsg = "expected -b<base> format for" + " mac address is -b mac=00::0C::01::02::03::04 or" + " -b mac=00:0C:01:02:03:04"; + check(found == std::string::npos, errmsg); + + // Decode mac address to vector of uint8_t + std::istringstream s1(base.substr(found + 1)); + std::string token; + mac_template_.clear(); + // Get pieces of MAC address separated with : (or even ::) + while (std::getline(s1, token, ':')) { + // Convert token to byte value using std::istringstream + if (token.length() > 0) { + unsigned int ui = 0; + try { + // Do actual conversion + ui = convertHexString(token); + } catch (const isc::InvalidParameter&) { + isc_throw(isc::InvalidParameter, + "invalid characters in MAC provided"); + + } + // If conversion succeeded store byte value + mac_template_.push_back(ui); + } + } + // MAC address must consist of 6 octets, otherwise it is invalid + check(mac_template_.size() != 6, errmsg); +} + +void +CommandOptions::decodeDuid(const std::string& base) { + // Strip argument from duid= + std::vector<uint8_t> duid_template; + size_t found = base.find('='); + check(found == std::string::npos, "expected -b<base>" + " format for duid is -b duid=<duid>"); + std::string b = base.substr(found + 1); + + // DUID must have even number of digits and must not be longer than 64 bytes + check(b.length() & 1, "odd number of hexadecimal digits in duid"); + check(b.length() > 128, "duid too large"); + check(b.length() == 0, "no duid specified"); + + // Turn pairs of hexadecimal digits into vector of octets + for (size_t i = 0; i < b.length(); i += 2) { + unsigned int ui = 0; + try { + // Do actual conversion + ui = convertHexString(b.substr(i, 2)); + } catch (const isc::InvalidParameter&) { + isc_throw(isc::InvalidParameter, + "invalid characters in DUID provided," + " expected hex digits"); + } + duid_template.push_back(static_cast<uint8_t>(ui)); + } + // @todo Get rid of this limitation when we manage add support + // for DUIDs other than LLT. Shorter DUIDs may be useful for + // server testing purposes. + check(duid_template.size() < 6, "DUID must be at least 6 octets long"); + // Assign the new duid only if successfully generated. + std::swap(duid_template, duid_template_); +} + +void +CommandOptions::generateDuidTemplate() { + using namespace boost::posix_time; + // Duid template will be most likely generated only once but + // it is ok if it is called more then once so we simply + // regenerate it and discard previous value. + duid_template_.clear(); + const uint8_t duid_template_len = 14; + duid_template_.resize(duid_template_len); + // The first four octets consist of DUID LLT and hardware type. + duid_template_[0] = static_cast<uint8_t>(static_cast<uint16_t>(isc::dhcp::DUID::DUID_LLT) >> 8); + duid_template_[1] = static_cast<uint8_t>(static_cast<uint16_t>(isc::dhcp::DUID::DUID_LLT) & 0xff); + duid_template_[2] = HWTYPE_ETHERNET >> 8; + duid_template_[3] = HWTYPE_ETHERNET & 0xff; + + // As described in RFC 8415: 'the time value is the time + // that the DUID is generated represented in seconds + // since midnight (UTC), January 1, 2000, modulo 2^32.' + ptime now = microsec_clock::universal_time(); + ptime duid_epoch(from_iso_string("20000101T000000")); + time_period period(duid_epoch, now); + uint32_t duration_sec = htonl(period.length().total_seconds()); + memcpy(&duid_template_[4], &duration_sec, 4); + + // Set link layer address (6 octets). This value may be + // randomized before sending a packet to simulate different + // clients. + memcpy(&duid_template_[8], &mac_template_[0], 6); +} + +const isc::dhcp::OptionCollection& +CommandOptions::getRelayOpts(uint8_t encapsulation_level) const { + if (encapsulation_level > RELAY_OPTIONS_MAX_ENCAPSULATION) { + isc_throw(isc::OutOfRange, + "Trying to access relay options at encapsulation level that doesn't exist"); + } + + return relay_opts_.find(encapsulation_level)->second; +} + +uint8_t +CommandOptions::convertHexString(const std::string& text) const { + unsigned int ui = 0; + // First, check if we are dealing with hexadecimal digits only + for (size_t i = 0; i < text.length(); ++i) { + if (!std::isxdigit(text[i])) { + isc_throw(isc::InvalidParameter, + "The following digit: " << text[i] << " in " + << text << "is not hexadecimal"); + } + } + // If we are here, we have valid string to convert to octet + std::istringstream text_stream(text); + text_stream >> std::hex >> ui >> std::dec; + // Check if for some reason we have overflow - this should never happen! + if (ui > 0xFF) { + isc_throw(isc::InvalidParameter, "Can't convert more than" + " two hex digits to byte"); + } + return ui; +} + +bool CommandOptions::validateIP(const std::string& line) { + try { + isc::asiolink::IOAddress ip_address(line); + if ((getIpVersion() == 4 && !ip_address.isV4()) || + (getIpVersion() == 6 && !ip_address.isV6())) { + return (true); + } + } catch (const isc::asiolink::IOError& e) { + return (true); + } + relay_addr_list_.push_back(line); + multi_subnet_ = true; + return (false); +} + +void CommandOptions::loadRelayAddr() { + std::string line; + std::ifstream infile(relay_addr_list_file_.c_str()); + size_t cnt = 0; + while (std::getline(infile, line)) { + cnt++; + stringstream tmp; + tmp << "invalid address or wrong address version in line: " << cnt; + check(validateIP(line), tmp.str()); + } + check(cnt == 0, "file with addresses is empty!"); +} + +void CommandOptions::loadMacs() { + std::string line; + std::ifstream infile(mac_list_file_.c_str()); + size_t cnt = 0; + while (std::getline(infile, line)) { + cnt++; + stringstream tmp; + tmp << "invalid mac in input line " << cnt; + // Let's print more meaningful error that contains line with error. + check(decodeMacString(line), tmp.str()); + } +} + +bool CommandOptions::decodeMacString(const std::string& line) { + // decode mac string into a vector of uint8_t returns true in case of error. + std::istringstream s(line); + std::string token; + std::vector<uint8_t> mac; + while(std::getline(s, token, ':')) { + // Convert token to byte value using std::istringstream + if (token.length() > 0) { + unsigned int ui = 0; + try { + // Do actual conversion + ui = convertHexString(token); + } catch (const isc::InvalidParameter&) { + return (true); + } + // If conversion succeeded store byte value + mac.push_back(ui); + } + } + mac_list_.push_back(mac); + return (false); +} + +void +CommandOptions::validate() { + check((getIpVersion() != 4) && (isBroadcast() != 0), + "-B is not compatible with IPv6 (-6)"); + check((getIpVersion() != 6) && (isRapidCommit() != 0), + "-6 (IPv6) must be set to use -c"); + check(getIpVersion() == 4 && isUseRelayedV6(), + "Can't use -4 with -A, it's a V6 only option."); + check((getExchangeMode() == DO_SA) && (getNumRequests().size() > 1), + "second -n<num-request> is not compatible with -i"); + check((getIpVersion() == 4) && !getLeaseType().is(LeaseType::ADDRESS), + "-6 option must be used if lease type other than '-e address-only'" + " is specified"); + check(!getTemplateFiles().empty() && + !getLeaseType().is(LeaseType::ADDRESS), + "template files may be only used with '-e address-only'"); + check((getExchangeMode() == DO_SA) && (getDropTime()[1] != 1.), + "second -d<drop-time> is not compatible with -i"); + check((getExchangeMode() == DO_SA) && + ((getMaxDrop().size() > 1) || (getMaxDropPercentage().size() > 1)), + "second -D<max-drop> is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (isUseFirst()), + "-1 is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (getTemplateFiles().size() > 1), + "second -T<template-file> is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (getTransactionIdOffset().size() > 1), + "second -X<xid-offset> is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (getRandomOffset().size() > 1), + "second -O<random-offset is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (getElapsedTimeOffset() >= 0), + "-E<time-offset> is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (getServerIdOffset() >= 0), + "-S<srvid-offset> is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (getRequestedIpOffset() >= 0), + "-I<ip-offset> is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (getRenewRate() != 0), + "-f<renew-rate> is not compatible with -i"); + check((getExchangeMode() == DO_SA) && (getReleaseRate() != 0), + "-F<release-rate> is not compatible with -i"); + check((getExchangeMode() != DO_SA) && (isRapidCommit() != 0), + "-i must be set to use -c"); + check((getRate() != 0) && (getRenewRate() + getReleaseRate() > getRate()), + "The sum of Renew rate (-f<renew-rate>) and Release rate" + " (-F<release-rate>) must not be greater than the exchange" + " rate specified as -r<rate>"); + check((getRate() == 0) && (getRenewRate() != 0), + "Renew rate specified as -f<renew-rate> must not be specified" + " when -r<rate> parameter is not specified"); + check((getRate() == 0) && (getReleaseRate() != 0), + "Release rate specified as -F<release-rate> must not be specified" + " when -r<rate> parameter is not specified"); + check((getTemplateFiles().size() < getTransactionIdOffset().size()), + "-T<template-file> must be set to use -X<xid-offset>"); + check((getTemplateFiles().size() < getRandomOffset().size()), + "-T<template-file> must be set to use -O<random-offset>"); + check((getTemplateFiles().size() < 2) && (getElapsedTimeOffset() >= 0), + "second/request -T<template-file> must be set to use -E<time-offset>"); + check((getTemplateFiles().size() < 2) && (getServerIdOffset() >= 0), + "second/request -T<template-file> must be set to " + "use -S<srvid-offset>"); + check((getTemplateFiles().size() < 2) && (getRequestedIpOffset() >= 0), + "second/request -T<template-file> must be set to " + "use -I<ip-offset>"); + check((!getMacListFile().empty() && base_.size() > 0), + "Can't use -b with -M option"); + check((getWaitForElapsedTime() == -1 && getIncreaseElapsedTime() != -1), + "Option -y can't be used without -Y"); + check((getWaitForElapsedTime() != -1 && getIncreaseElapsedTime() == -1), + "Option -Y can't be used without -y"); + auto nthreads = std::thread::hardware_concurrency(); + if (nthreads == 1 && isSingleThreaded() == false) { + std::cout << "WARNING: Currently system can run only 1 thread in parallel." << std::endl + << "WARNING: Better results are achieved when run in single-threaded mode." << std::endl + << "WARNING: To switch use -g single option." << std::endl; + } else if (nthreads > 1 && isSingleThreaded()) { + std::cout << "WARNING: Currently system can run more than 1 thread in parallel." << std::endl + << "WARNING: Better results are achieved when run in multi-threaded mode." << std::endl + << "WARNING: To switch use -g multi option." << std::endl; + } + + if (scenario_ == Scenario::AVALANCHE) { + check(getClientsNum() <= 0, + "in case of avalanche scenario number\nof clients must be specified" + " using -R option explicitly"); + + // in case of AVALANCHE drops ie. long responses should not be observed by perfdhcp + double dt[2] = { 1000.0, 1000.0 }; + drop_time_.assign(dt, dt + 2); + if (drop_time_set_) { + std::cout << "INFO: in avalanche scenario drop time is ignored" << std::endl; + } + } +} + +void +CommandOptions::check(bool condition, const std::string& errmsg) const { + // The same could have been done with macro or just if statement but + // we prefer functions to macros here + std::ostringstream stream; + stream << errmsg << "\n"; + if (condition) { + isc_throw(isc::InvalidParameter, errmsg); + } +} + +int +CommandOptions::positiveInteger(const std::string& errmsg) const { + try { + int value = boost::lexical_cast<int>(optarg ? optarg : ""); + check(value <= 0, errmsg); + return (value); + } catch (const boost::bad_lexical_cast&) { + isc_throw(InvalidParameter, errmsg); + } +} + +int +CommandOptions::nonNegativeInteger(const std::string& errmsg) const { + try { + int value = boost::lexical_cast<int>(optarg ? optarg : ""); + check(value < 0, errmsg); + return (value); + } catch (const boost::bad_lexical_cast&) { + isc_throw(InvalidParameter, errmsg); + } +} + +std::string +CommandOptions::nonEmptyString(const std::string& errmsg) const { + std::string sarg(optarg ? optarg : ""); + if (sarg.length() == 0) { + isc_throw(isc::InvalidParameter, errmsg); + } + return sarg; +} + +void +CommandOptions::initLeaseType() { + std::string lease_type_arg(optarg ? optarg : ""); + lease_type_.fromCommandLine(lease_type_arg); +} + +void +CommandOptions::printCommandLine() const { + std::cout << "IPv" << static_cast<int>(ipversion_) << std::endl; + if (exchange_mode_ == DO_SA) { + if (ipversion_ == 4) { + std::cout << "DISCOVER-OFFER only" << std::endl; + } else { + std::cout << "SOLICIT-ADVERTISE only" << std::endl; + } + } + std::cout << "lease-type=" << getLeaseType().toText() << std::endl; + if (rate_ != 0) { + std::cout << "rate[1/s]=" << rate_ << std::endl; + } + if (getRenewRate() != 0) { + std::cout << "renew-rate[1/s]=" << getRenewRate() << std::endl; + } + if (getReleaseRate() != 0) { + std::cout << "release-rate[1/s]=" << getReleaseRate() << std::endl; + } + if (report_delay_ != 0) { + std::cout << "report[s]=" << report_delay_ << std::endl; + } + if (clients_num_ != 0) { + std::cout << "clients=" << clients_num_ << std::endl; + } + for (size_t i = 0; i < base_.size(); ++i) { + std::cout << "base[" << i << "]=" << base_[i] << std::endl; + } + for (size_t i = 0; i < num_request_.size(); ++i) { + std::cout << "num-request[" << i << "]=" << num_request_[i] << std::endl; + } + if (period_ != 0) { + std::cout << "test-period=" << period_ << std::endl; + } + for (size_t i = 0; i < drop_time_.size(); ++i) { + std::cout << "drop-time[" << i << "]=" << drop_time_[i] << std::endl; + } + for (size_t i = 0; i < max_drop_.size(); ++i) { + std::cout << "max-drop{" << i << "]=" << max_drop_[i] << std::endl; + } + for (size_t i = 0; i < max_pdrop_.size(); ++i) { + std::cout << "max-pdrop{" << i << "]=" << max_pdrop_[i] << std::endl; + } + if (preload_ != 0) { + std::cout << "preload=" << preload_ << std::endl; + } + if (getLocalPort() != 0) { + std::cout << "local-port=" << local_port_ << std::endl; + } + if (getRemotePort() != 0) { + std::cout << "remote-port=" << remote_port_ << std::endl; + } + if (seeded_) { + std::cout << "seed=" << seed_ << std::endl; + } + if (broadcast_) { + std::cout << "broadcast" << std::endl; + } + if (rapid_commit_) { + std::cout << "rapid-commit" << std::endl; + } + if (use_first_) { + std::cout << "use-first" << std::endl; + } + if (!mac_list_file_.empty()) { + std::cout << "mac-list-file=" << mac_list_file_ << std::endl; + } + for (size_t i = 0; i < template_file_.size(); ++i) { + std::cout << "template-file[" << i << "]=" << template_file_[i] << std::endl; + } + for (size_t i = 0; i < xid_offset_.size(); ++i) { + std::cout << "xid-offset[" << i << "]=" << xid_offset_[i] << std::endl; + } + if (elp_offset_ != 0) { + std::cout << "elp-offset=" << elp_offset_ << std::endl; + } + for (size_t i = 0; i < rnd_offset_.size(); ++i) { + std::cout << "rnd-offset[" << i << "]=" << rnd_offset_[i] << std::endl; + } + if (sid_offset_ != 0) { + std::cout << "sid-offset=" << sid_offset_ << std::endl; + } + if (rip_offset_ != 0) { + std::cout << "rip-offset=" << rip_offset_ << std::endl; + } + if (!diags_.empty()) { + std::cout << "diagnostic-selectors=" << diags_ << std::endl; + } + if (!wrapped_.empty()) { + std::cout << "wrapped=" << wrapped_ << std::endl; + } + if (!localname_.empty()) { + if (is_interface_) { + std::cout << "interface=" << localname_ << std::endl; + } else { + std::cout << "local-addr=" << localname_ << std::endl; + } + } + if (!server_name_.empty()) { + std::cout << "server=" << server_name_ << std::endl; + } + if (single_thread_mode_) { + std::cout << "single-thread-mode" << std::endl; + } else { + std::cout << "multi-thread-mode" << std::endl; + } +} + +void +CommandOptions::usage() { + std::cout << +R"(perfdhcp [-1] [-4 | -6] [-A encapsulation-level] [-b base] [-B] [-c] + [-C separator] [-d drop-time] [-D max-drop] [-e lease-type] + [-E time-offset] [-f renew-rate] [-F release-rate] [-g thread-mode] + [-h] [-i] [-I ip-offset] [-J remote-address-list-file] + [-l local-address|interface] [-L local-port] [-M mac-list-file] + [-n num-request] [-N remote-port] [-O random-offset] + [-o code,hexstring] [--or encapsulation-level:code,hexstring] + [-p test-period] [-P preload] [-r rate] + [-R num-clients] [-s seed] [-S srvid-offset] [--scenario name] + [-t report] [-T template-file] [-u] [-v] [-W exit-wait-time] + [-w script_name] [-x diagnostic-selector] [-X xid-offset] [server] + +The [server] argument is the name/address of the DHCP server to +contact. For DHCPv4 operation, exchanges are initiated by +transmitting a DHCP DISCOVER to this address. + +For DHCPv6 operation, exchanges are initiated by transmitting a DHCP +SOLICIT to this address. In the DHCPv6 case, the special name 'all' +can be used to refer to All_DHCP_Relay_Agents_and_Servers (the +multicast address FF02::1:2), or the special name 'servers' to refer +to All_DHCP_Servers (the multicast address FF05::1:3). The [server] +argument is optional only in the case that -l is used to specify an +interface, in which case [server] defaults to 'all'. + +The default is to perform a single 4-way exchange, effectively pinging +the server. +The -r option is used to set up a performance test, without +it exchanges are initiated as fast as possible. +The other scenario is an avalanche which is selected by +--scenario avalanche. It first sends as many Discovery or Solicit +messages as request in -R option then back off mechanism is used for +each simulated client until all requests are answered. At the end +time of whole scenario is reported. + +Options: +-1: Take the server-ID option from the first received message. +-4: DHCPv4 operation (default). This is incompatible with the -6 option. +-6: DHCPv6 operation. This is incompatible with the -4 option. +-b<base>: The base mac, duid, IP, etc, used to simulate different + clients. This can be specified multiple times, each instance is + in the <type>=<value> form, for instance: + (and default) mac=00:0c:01:02:03:04. +-d<drop-time>: Specify the time after which a request is treated as + having been lost. The value is given in seconds and may contain a + fractional component. The default is 1 second. +-e<lease-type>: A type of lease being requested from the server. It + may be one of the following: address-only, prefix-only or + address-and-prefix. The address-only indicates that the regular + address (v4 or v6) will be requested. The prefix-only indicates + that the IPv6 prefix will be requested. The address-and-prefix + indicates that both IPv6 address and prefix will be requested. + The '-e prefix-only' and -'e address-and-prefix' must not be + used with -4. +-E<time-offset>: Offset of the (DHCPv4) secs field / (DHCPv6) + elapsed-time option in the (second/request) template. + The value 0 disables it. +-F<release-rate>: Rate at which Release requests are sent to + a server. This value is only valid when used in conjunction with + the exchange rate (given by -r<rate>). Furthermore the sum of + this value and the renew-rate (given by -f<rate>) must be equal + to or less than the exchange rate. +-f<renew-rate>: Rate at which DHCPv4 or DHCPv6 renew requests are sent + to a server. This value is only valid when used in conjunction + with the exchange rate (given by -r<rate>). Furthermore the sum of + this value and the release-rate (given by -F<rate>) must be equal + to or less than the exchange rate. +-g<thread-mode>: 'single' or 'multi'. In multi-thread mode packets + are received in separate thread. This allows better utilisation of CPUs. + If more than 1 CPU is present then multi-thread mode is the default, + otherwise single-thread is the default. +-h: Print this help. +-i: Do only the initial part of an exchange: DO or SA, depending on + whether -6 is given. +-I<ip-offset>: Offset of the (DHCPv4) IP address in the requested-IP + option / (DHCPv6) IA_NA option in the (second/request) template. +-J<remote-address-list-file>: Text file that include multiple addresses. + If provided perfdhcp will choose randomly one of addresses for each + exchange. +-l<local-addr|interface>: For DHCPv4 operation, specify the local + hostname/address to use when communicating with the server. By + default, the interface address through which traffic would + normally be routed to the server is used. + For DHCPv6 operation, specify the name of the network interface + via which exchanges are initiated. +-L<local-port>: Specify the local port to use + (the value 0 means to use the default). +-M<mac-list-file>: A text file containing a list of MAC addresses, + one per line. If provided, a MAC address will be chosen randomly + from this list for every new exchange. In the DHCPv6 case, MAC + addresses are used to generate DUID-LLs. This parameter must not be + used in conjunction with the -b parameter. +-N<remote-port>: Specify the remote port to use + (the value 0 means to use the default). +-o<code,hexstring>: Send custom option with the specified code and the + specified buffer in hexstring format. +-O<random-offset>: Offset of the last octet to randomize in the template. +-P<preload>: Initiate first <preload> exchanges back to back at startup. +-r<rate>: Initiate <rate> DORA/SARR (or if -i is given, DO/SA) + exchanges per second. A periodic report is generated showing the + number of exchanges which were not completed, as well as the + average response latency. The program continues until + interrupted, at which point a final report is generated. +-R<range>: Specify how many different clients are used. With 1 + (the default), all requests seem to come from the same client. +-s<seed>: Specify the seed for randomization, making it repeatable. +--scenario <name>: where name is 'basic' (default) or 'avalanche'. +-S<srvid-offset>: Offset of the server-ID option in the + (second/request) template. +-T<template-file>: The name of a file containing the template to use + as a stream of hexadecimal digits. +-u: Enable checking address uniqueness. Lease valid lifetime should not be + shorter than test duration and clients should not request address more than + once without releasing it first. +-v: Report the version number of this program. +-W<time>: Specifies exit-wait-time parameter, that makes perfdhcp wait + for <time> us after an exit condition has been met to receive all + packets without sending any new packets. Expressed in microseconds. +-w<wrapped>: Command to call with start/stop at the beginning/end of + the program. +-x<diagnostic-selector>: Include extended diagnostics in the output. + <diagnostic-selector> is a string of single-keywords specifying + the operations for which verbose output is desired. The selector + key letters are: + * 'a': print the decoded command line arguments + * 'e': print the exit reason + * 'i': print rate processing details + * 'l': print received leases + * 's': print first server-id + * 't': when finished, print timers of all successful exchanges + * 'T': when finished, print templates +-X<xid-offset>: Transaction ID (aka. xid) offset in the template. +-Y<time>: time in seconds after which perfdhcp will start sending + messages with increased elapsed time option. +-y<time>: period of time in seconds in which perfdhcp will be sending + messages with increased elapsed time option. +DHCPv4 only options: +-B: Force broadcast handling. + +DHCPv6 only options: +-c: Add a rapid commit option (exchanges will be SA). +-A<encapsulation-level>: Specifies that relayed traffic must be + generated. The argument specifies the level of encapsulation, i.e. + how many relay agents are simulated. Currently the only supported + <encapsulation-level> value is 1, which means that the generated + traffic is an equivalent of the traffic passing through a single + relay agent. +--or encapsulation-level:<code,hexstring>: Send given option included + to simulated DHCPv6 relayed traffic at given level of encapsulation + with the specified code and the specified buffer in hexstring format. + Currently the only supported encapsulation-level value is 1. + Must be used together with -A. + +The remaining options are typically used in conjunction with -r: + +-D<max-drop>: Abort the test immediately if max-drop requests have + been dropped. max-drop must be a positive integer. If max-drop + includes the suffix '%', it specifies a maximum percentage of + requests that may be dropped before abort. In this case, testing + of the threshold begins after 10 requests have been expected to + be received. +-n<num-request>: Initiate <num-request> transactions. No report is + generated until all transactions have been initiated/waited-for, + after which a report is generated and the program terminates. +-p<test-period>: Send requests for the given test period, which is + specified in the same manner as -d. This can be used as an + alternative to -n, or both options can be given, in which case the + testing is completed when either limit is reached. +-t<report>: Delay in seconds between two periodic reports. +-C<separator>: Output reduced, an argument is a separator for periodic + (-t) reports generated in easy parsable mode. Data output won't be + changed, remain identical as in -t option. + +Errors: +- tooshort: received a too short message +- orphans: received a message which doesn't match an exchange + (duplicate, late or not related) +- locallimit: reached to local system limits when sending a message. + +Exit status: +The exit status is: +0 on complete success. +1 for a general error. +2 if an error is found in the command line arguments. +3 if there are no general failures in operation, but one or more + exchanges are not successfully completed. +)"; +} + +void +CommandOptions::version() const { + std::cout << "VERSION: " << VERSION << std::endl; +} + + +} // namespace perfdhcp +} // namespace isc |