fdsdump: options: define component

Author: Lukas Hutak

src/tools/fdsdump/src/options.cpp

@@ -0,0 +1,96 @@
+
+#include <getopt.h>
+#include <unistd.h>
+
+#include "options.hpp"
+
+Options::Options()
+{
+    reset();
+}
+
+Options::Options(int argc, char *argv[])
+{
+    reset();
+    parse(argc, argv);
+    validate();
+}
+
+void Options::reset()
+{
+    m_mode = Mode::undefined;
+
+    m_input_files.clear();
+    m_input_filter.clear();
+
+    m_output_limit = 0;
+    m_output_specifier = "JSON-RAW";
+
+    m_biflow_autoignore = true;
+
+    m_order_by.clear();
+}
+
+/**
+ * @brief Parse command line arguments.
+ *
+ * Previously specified values are not reset. Previous values might be
+ * redefined or extended (e.g. files to process).
+ * @param[in] argc Number of arguments
+ * @param[in] argv Array of arguments
+ */
+void Options::parse(int argc, char *argv[])
+{
+    enum long_opts_vals {
+        OPT_BIFLOW_AUTOIGNORE_OFF = 256, // Value that cannot colide with chars
+    };
+    const struct option long_opts[] = {
+        {"filter",               required_argument, NULL, 'F'},
+        {"output",               required_argument, NULL, 'o'},
+        {"order",                required_argument, NULL, 'O'},
+        {"limit",                required_argument, NULL, 'c'},
+        {"no-biflow-autoignore", no_argument,       NULL, OPT_BIFLOW_AUTOIGNORE_OFF},
+        {0, 0, 0, 0},
+    };
+    const char *short_opts = "r:c:o:O:F:";
+    int opt;
+
+    while ((opt = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
+        switch (opt) {
+        case 'r':
+            m_input_files.add_files(optarg);
+            break;
+        case 'c':
+            m_output_limit = std::stoull(optarg);
+            break;
+        case 'o':
+            m_output_specifier = optarg;
+            break;
+        case 'O':
+            m_order_by = optarg;
+            break;
+        case 'F':
+            m_input_filter = optarg;
+            break;
+        case OPT_BIFLOW_AUTOIGNORE_OFF:
+            m_biflow_autoignore = false;
+            break;
+        case '?':
+            throw OptionsException("invalid command line option(s)");
+        default:
+            throw OptionsException("getopts_long() returned unexpected value " + std::to_string(opt));
+        }
+    }
+
+    if (optind < argc) {
+        const char *arg = argv[optind];
+        throw OptionsException("unknown argument '" + std::string(arg) + "'");
+    }
+}
+
+void Options::validate()
+{
+    if (m_mode == Mode::undefined) {
+        m_mode = Mode::list;
+    }
+}

src/tools/fdsdump/src/options.hpp

@@ -0,0 +1,82 @@
+
+#include <cstddef>
+#include <string>
+#include <stdexcept>
+
+#include "filelist.hpp"
+
+class OptionsException : public std::invalid_argument {
+public:
+    OptionsException(const std::string &what_arg)
+        : std::invalid_argument(what_arg)
+        {};
+
+    OptionsException(const char *what_arg)
+        : std::invalid_argument(what_arg)
+        {};
+};
+
+/**
+ * @brief Command line arguments.
+ *
+ * Parse and validate user-specified command line arguments.
+ */
+class Options {
+public:
+    enum class Mode {
+        undefined,
+        list,
+        aggregate,
+    };
+
+    /**
+     * @brief Create options with default values.
+     */
+    Options();
+    /**
+     * @brief Create options and parse command line arguments.
+     * @param[in] argc Number of arguments
+     * @param[in] argv Array of arguments
+     */
+    Options(int argc, char *argv[]);
+    ~Options() = default;
+
+    /**
+     * @brief Reset all values to default.
+     */
+    void reset();
+
+    const Mode &get_mode() const { return m_mode; };
+
+    /** @brief Get list of files to process.             */
+    const FileList &get_input_files() const { return m_input_files; };
+    /** @brief Get input flow filter.                    */
+    const std::string &get_input_filter() const { return m_input_filter; };
+
+    /** @brief Get number of records to print on output. */
+    size_t get_output_limit() const { return m_output_limit; };
+    /** @brief Get output format specifier.              */
+    const std::string &get_output_specifier() const { return m_output_specifier; };
+
+    /** @brief Whether to ignore biflow direction with zero bytes and packets counter */
+    bool get_biflow_autoignore() const { return m_biflow_autoignore; };
+
+    /** @brief Get output order specificiation           */
+    const std::string &get_order_by() const { return m_order_by; };
+
+private:
+    Mode m_mode;
+
+    FileList    m_input_files;
+    std::string m_input_filter;
+
+    size_t      m_output_limit;
+    std::string m_output_specifier;
+
+    std::string m_order_by;
+
+    bool        m_biflow_autoignore;
+
+    void parse(int argc, char *argv[]);
+    void validate();
+};