Avoid warning about sys/sysctl.h on glibc-2.30.
[paraslash.git] / filter.c
index 81258a6..d4a2423 100644 (file)
--- a/filter.c
+++ b/filter.c
@@ -1,34 +1,46 @@
-/*
- * Copyright (C) 2005-2012 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
+/* Copyright (C) 2005 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
 
 /** \file filter.c The stand-alone filter program. */
 
 #include <regex.h>
+#include <lopsub.h>
 
+#include "filter.lsg.h"
+#include "filter_cmd.lsg.h"
 #include "para.h"
-#include "filter.cmdline.h"
 #include "list.h"
+#include "lsu.h"
 #include "sched.h"
-#include "ggo.h"
 #include "buffer_tree.h"
 #include "filter.h"
 #include "string.h"
 #include "stdin.h"
 #include "stdout.h"
 #include "error.h"
+#include "fd.h"
 #include "version.h"
 
+/** Array of error strings. */
+DEFINE_PARA_ERRLIST;
+static struct lls_parse_result *lpr; /* command line options */
+
+#define CMD_PTR (lls_cmd(0, filter_suite))
+#define OPT_RESULT(_name) \
+       (lls_opt_result(LSG_FILTER_PARA_FILTER_OPT_ ## _name, lpr))
+#define OPT_GIVEN(_name) (lls_opt_given(OPT_RESULT(_name)))
+#define OPT_UINT32_VAL(_name) (lls_uint32_val(0, OPT_RESULT(_name)))
+
 /** The list of all status items used by para_{server,audiod,gui}. */
-const char *status_item_list[] = {STATUS_ITEM_ARRAY};
+const char *status_item_list[] = {STATUS_ITEMS};
 
+/**
+ * Dummy version which only contains NULL pointers.
+ *
+ * This is used by the amp filter which first tries to obtain the amplification
+ * value from an element in this array.
+ */
 char *stat_item_values[NUM_STAT_ITEMS] = {NULL};
 
-/** Initialize the array of errors for para_filter. */
-INIT_FILTER_ERRLISTS;
-
 /** The task that reads from stdin. */
 static struct stdin_task stdin_task_struct;
 /** pointer to the stdin task. */
@@ -39,56 +51,40 @@ static struct stdout_task stdout_task_struct;
 /** Pointer to the stdout task. */
 static struct stdout_task *sot = &stdout_task_struct;
 
-/** Gengetopt struct that holds the command line args. */
-static struct filter_args_info conf;
-
 static int loglevel;
 INIT_STDERR_LOGGING(loglevel);
 
-__noreturn static void print_help_and_die(void)
+static void handle_help_flag(void)
 {
-       int d = conf.detailed_help_given;
-       const char **p = d? filter_args_info_detailed_help
-               : filter_args_info_help;
-
-       printf_or_die("%s\n\n", FILTER_CMDLINE_PARSER_PACKAGE "-"
-               FILTER_CMDLINE_PARSER_VERSION);
-       printf_or_die("%s\n\n", filter_args_info_usage);
-       for (; *p; p++)
-               printf_or_die("%s\n", *p);
-       print_filter_helps(d);
-       exit(0);
+       char *help;
+
+       if (OPT_GIVEN(DETAILED_HELP))
+               help = lls_long_help(CMD_PTR);
+       else if (OPT_GIVEN(HELP))
+               help = lls_short_help(CMD_PTR);
+       else
+               return;
+       printf("%s\n", help);
+       free(help);
+       print_filter_helps(OPT_GIVEN(DETAILED_HELP));
+       exit(EXIT_SUCCESS);
 }
 
-static int parse_config(int argc, char *argv[])
+static int parse_config(void)
 {
-       static char *cf; /* config file */
-       struct stat statbuf;
-
-       if (filter_cmdline_parser(argc, argv, &conf))
-               return -E_FILTER_SYNTAX;
-       HANDLE_VERSION_FLAG("filter", conf);
-       if (conf.help_given || conf.detailed_help_given)
-               print_help_and_die();
-       loglevel = get_loglevel_by_name(conf.loglevel_arg);
-       if (!cf) {
-               char *home = para_homedir();
-               cf = make_message("%s/.paraslash/filter.conf", home);
-               free(home);
-       }
-       if (!stat(cf, &statbuf)) {
-               struct filter_cmdline_parser_params params = {
-                       .override = 0,
-                       .initialize = 0,
-                       .check_required = 0,
-                       .check_ambiguity = 0,
-                       .print_errors = 1
-               };
-               if (filter_cmdline_parser_config_file(cf, &conf, &params))
-                       return -E_FILTER_SYNTAX;
+       int ret;
+
+       version_handle_flag("filter", OPT_GIVEN(VERSION));
+       handle_help_flag();
+       ret = lsu_merge_config_file_options(NULL, "filter.conf",
+               &lpr, CMD_PTR, filter_suite, 0 /* default flags */);
+       if (ret < 0)
+               return ret;
+       loglevel = OPT_UINT32_VAL(LOGLEVEL);
+       if (!OPT_GIVEN(FILTER)) {
+               print_filter_list();
+               exit(EXIT_SUCCESS);
        }
-       if (!conf.filter_given)
-               return -E_NO_FILTERS;
        return 1;
 }
 
@@ -108,68 +104,78 @@ int main(int argc, char *argv[])
 {
        static struct sched s;
        int i, ret;
-       struct filter *f;
+       const struct filter *f;
        struct btr_node *parent;
        struct filter_node **fns;
+       struct lls_parse_result *filter_lpr; /* per-filter options */
+       char *errctx;
 
-       filter_init();
-       ret = parse_config(argc, argv);
+       ret = lls(lls_parse(argc, argv, CMD_PTR, &lpr, &errctx));
        if (ret < 0)
                goto out;
+       ret = parse_config();
+       if (ret < 0)
+               goto free_lpr;
        sit->btrn = btr_new_node(&(struct btr_node_description)
                EMBRACE(.name = "stdin"));
-       stdin_set_defaults(sit);
-       register_task(&s, &sit->task);
+       stdin_task_register(sit, &s);
 
-       fns = para_malloc(conf.filter_given * sizeof(*fns));
-       for (i = 0, parent = sit->btrn; i < conf.filter_given; i++) {
-               char *fa = conf.filter_arg[i];
+       fns = para_malloc(OPT_GIVEN(FILTER) * sizeof(*fns));
+       for (i = 0, parent = sit->btrn; i < OPT_GIVEN(FILTER); i++) {
+               const char *fa = lls_string_val(i, OPT_RESULT(FILTER));
+               const char *name;
                struct filter_node *fn;
+               struct task_info ti;
 
                fn = fns[i] = para_calloc(sizeof(*fn));
-               ret = check_filter_arg(fa, &fn->conf);
-               if (ret < 0) {
-                       free(fn);
-                       goto out_cleanup;
-               }
-               fn->filter_num = ret;
-               f = filters + fn->filter_num;
-               sprintf(fn->task.status, "%s", f->name);
-               PARA_DEBUG_LOG("filter #%d: %s\n", i, f->name);
+               fn->filter_num = filter_setup(fa, &fn->conf, &filter_lpr);
+               name = filter_name(fn->filter_num);
+               fn->lpr = filter_lpr;
+               PARA_DEBUG_LOG("filter #%d: %s\n", i, name);
+               f = filter_get(fn->filter_num);
                fn->btrn = btr_new_node(&(struct btr_node_description)
-                       EMBRACE(.name = f->name, .parent = parent,
+                       EMBRACE(.name = name, .parent = parent,
                        .handler = f->execute, .context = fn));
-               fn->task.pre_select = f->pre_select;
-               fn->task.post_select = f->post_select;
-               f->open(fn);
-               register_task(&s, &fn->task);
+               ti.name = name;
+               ti.pre_select = f->pre_select;
+               ti.post_select = f->post_select;
+               ti.context = fn;
+               if (f->open)
+                       f->open(fn);
+               fn->task = task_register(&ti, &s);
                parent = fn->btrn;
        }
        sot->btrn = btr_new_node(&(struct btr_node_description)
                EMBRACE(.name = "stdout", .parent = parent));
-       stdout_set_defaults(sot);
-       register_task(&s, &sot->task);
+       stdout_task_register(sot, &s);
 
        s.default_timeout.tv_sec = 1;
        s.default_timeout.tv_usec = 0;
        btr_log_tree(sit->btrn, LL_INFO);
        ret = schedule(&s);
-out_cleanup:
+       sched_shutdown(&s);
        for (i--; i >= 0; i--) {
                struct filter_node *fn = fns[i];
 
-               f = filters + fn->filter_num;
+               f = filter_get(fn->filter_num);
                if (f->close)
                        f->close(fn);
-               btr_free_node(fn->btrn);
-               free(fn->conf);
+               btr_remove_node(&fn->btrn);
+               if (f->teardown)
+                       f->teardown(fn->lpr, fn->conf);
                free(fn);
        }
        free(fns);
-       btr_free_node(sit->btrn);
-       btr_free_node(sot->btrn);
+       btr_remove_node(&sit->btrn);
+       btr_remove_node(&sot->btrn);
+free_lpr:
+       lls_free_parse_result(lpr, CMD_PTR);
 out:
-       if (ret < 0)
-               PARA_EMERG_LOG("%s\n", para_strerror(-ret));
+       if (ret < 0) {
+               if (errctx)
+                       PARA_ERROR_LOG("%s\n", errctx);
+               free(errctx);
+               PARA_ERROR_LOG("%s\n", para_strerror(-ret));
+       }
        exit(ret < 0? EXIT_FAILURE : EXIT_SUCCESS);
 }