journal-remote: copy positional arguments

This also fixes several memory leaks.

diff --git a/src/journal-remote/journal-gatewayd.c b/src/journal-remote/journal-gatewayd.c
index 646253e1a5e464cf648d926b8e784ce76a58ce7b..ef20eb2ff8374c411ebc83604f4fd38456d7389c 100644 (file)
--- a/src/journal-remote/journal-gatewayd.c
+++ b/src/journal-remote/journal-gatewayd.c
@@ -43,12 +43,13 @@ static char *arg_cert_pem = NULL;
 static char *arg_trust_pem = NULL;
 static bool arg_merge = false;
 static int arg_journal_type = 0;
-static const char *arg_directory = NULL;
+static char *arg_directory = NULL;
 static char **arg_file = NULL;
 
 STATIC_DESTRUCTOR_REGISTER(arg_key_pem, erase_and_freep);
 STATIC_DESTRUCTOR_REGISTER(arg_cert_pem, freep);
 STATIC_DESTRUCTOR_REGISTER(arg_trust_pem, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_directory, freep);
 STATIC_DESTRUCTOR_REGISTER(arg_file, strv_freep);
 
 typedef struct RequestMeta {
@@ -1061,7 +1062,9 @@ static int parse_argv(int argc, char *argv[]) {
                         break;
 
                 case 'D':
-                        arg_directory = optarg;
+                        r = free_and_strdup_warn(&arg_directory, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_FILE:

diff --git a/src/journal-remote/journal-remote-main.c b/src/journal-remote/journal-remote-main.c
index 88ab62a7c7a95d6e9b0ea83ac86f37b8893f6bd1..3579b507efdbd32fb70e3b78b2e93c61c0c5fe41 100644 (file)
--- a/src/journal-remote/journal-remote-main.c
+++ b/src/journal-remote/journal-remote-main.c
@@ -33,13 +33,13 @@
 #define CERT_FILE     CERTIFICATE_ROOT "/certs/journal-remote.pem"
 #define TRUST_FILE    CERTIFICATE_ROOT "/ca/trusted.pem"
 
-static const char *arg_url = NULL;
-static const char *arg_getter = NULL;
-static const char *arg_listen_raw = NULL;
-static const char *arg_listen_http = NULL;
-static const char *arg_listen_https = NULL;
+static char *arg_url = NULL;
+static char *arg_getter = NULL;
+static char *arg_listen_raw = NULL;
+static char *arg_listen_http = NULL;
+static char *arg_listen_https = NULL;
 static CompressionArgs arg_compression = {};
-static char **arg_files = NULL; /* Do not free this. */
+static char **arg_files = NULL;
 static bool arg_compress = true;
 static bool arg_seal = false;
 static int http_socket = -1, https_socket = -1;
@@ -62,6 +62,12 @@ static uint64_t arg_max_size = UINT64_MAX;
 static uint64_t arg_n_max_files = UINT64_MAX;
 static uint64_t arg_keep_free = UINT64_MAX;
 
+STATIC_DESTRUCTOR_REGISTER(arg_url, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_getter, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_listen_raw, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_listen_http, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_listen_https, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_files, strv_freep);
 STATIC_DESTRUCTOR_REGISTER(arg_gnutls_log, strv_freep);
 STATIC_DESTRUCTOR_REGISTER(arg_key, freep);
 STATIC_DESTRUCTOR_REGISTER(arg_cert, freep);
@@ -866,27 +872,21 @@ static int parse_argv(int argc, char *argv[]) {
                         return version();
 
                 case ARG_URL:
-                        if (arg_url)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot currently set more than one --url=");
-
-                        arg_url = optarg;
+                        r = free_and_strdup_warn(&arg_url, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_GETTER:
-                        if (arg_getter)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot currently use --getter= more than once");
-
-                        arg_getter = optarg;
+                        r = free_and_strdup_warn(&arg_getter, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_LISTEN_RAW:
-                        if (arg_listen_raw)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot currently use --listen-raw= more than once");
-
-                        arg_listen_raw = optarg;
+                        r = free_and_strdup_warn(&arg_listen_raw, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_LISTEN_HTTP:
@@ -897,8 +897,11 @@ static int parse_argv(int argc, char *argv[]) {
                         r = negative_fd(optarg);
                         if (r >= 0)
                                 http_socket = r;
-                        else
-                                arg_listen_http = optarg;
+                        else {
+                                r = free_and_strdup_warn(&arg_listen_http, optarg);
+                                if (r < 0)
+                                        return r;
+                        }
                         break;
 
                 case ARG_LISTEN_HTTPS:
@@ -909,53 +912,36 @@ static int parse_argv(int argc, char *argv[]) {
                         r = negative_fd(optarg);
                         if (r >= 0)
                                 https_socket = r;
-                        else
-                                arg_listen_https = optarg;
-
+                        else {
+                                r = free_and_strdup_warn(&arg_listen_https, optarg);
+                                if (r < 0)
+                                        return r;
+                        }
                         break;
 
                 case ARG_KEY:
-                        if (arg_key)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Key file specified twice");
-
-                        arg_key = strdup(optarg);
-                        if (!arg_key)
-                                return log_oom();
-
+                        r = free_and_strdup_warn(&arg_key, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_CERT:
-                        if (arg_cert)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Certificate file specified twice");
-
-                        arg_cert = strdup(optarg);
-                        if (!arg_cert)
-                                return log_oom();
-
+                        r = free_and_strdup_warn(&arg_cert, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_TRUST:
 #if HAVE_GNUTLS
-                        if (arg_trust)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use --trust more= than once");
-
-                        arg_trust = strdup(optarg);
-                        if (!arg_trust)
-                                return log_oom();
+                        r = free_and_strdup_warn(&arg_trust, optarg);
+                        if (r < 0)
+                                return r;
 #else
-                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                               "Option --trust= is not available.");
+                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Option --trust= is not available.");
 #endif
                         break;
 
                 case 'o':
-                        if (arg_output)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use --output=/-o more than once");
-
                         r = parse_path_argument(optarg, /* suppress_root = */ false, &arg_output);
                         if (r < 0)
                                 return r;
@@ -990,16 +976,13 @@ static int parse_argv(int argc, char *argv[]) {
                                 if (r == 0)
                                         break;
 
-                                if (strv_push(&arg_gnutls_log, word) < 0)
+                                if (strv_consume(&arg_gnutls_log, TAKE_PTR(word)) < 0)
                                         return log_oom();
-
-                                word = NULL;
                         }
-                        break;
 #else
-                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                               "Option --gnutls-log= is not available.");
+                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Option --gnutls-log= is not available.");
 #endif
+                        break;
 
                 case '?':
                         return -EINVAL;
@@ -1008,8 +991,9 @@ static int parse_argv(int argc, char *argv[]) {
                         assert_not_reached();
                 }
 
-        if (optind < argc)
-                arg_files = argv + optind;
+        arg_files = strv_copy(strv_skip(argv, optind));
+        if (!arg_files)
+                return log_oom();
 
         type_a = arg_getter || !strv_isempty(arg_files);
         type_b = arg_url

diff --git a/src/journal-remote/journal-upload.c b/src/journal-remote/journal-upload.c
index ca891a4e00e61fd5993f5874fb2f164b6dcfa422..15704c4396c33ce6e63d2c3cd4daa2dfae358984 100644 (file)
--- a/src/journal-remote/journal-upload.c
+++ b/src/journal-remote/journal-upload.c
@@ -42,26 +42,35 @@
 #define TRUST_FILE    CERTIFICATE_ROOT "/ca/trusted.pem"
 #define DEFAULT_PORT  19532
 
-static const char *arg_url = NULL;
-static const char *arg_key = NULL;
-static const char *arg_cert = NULL;
-static const char *arg_trust = NULL;
-static const char *arg_directory = NULL;
+static char *arg_url = NULL;
+static char *arg_key = NULL;
+static char *arg_cert = NULL;
+static char *arg_trust = NULL;
+static char *arg_directory = NULL;
 static char **arg_file = NULL;
-static const char *arg_cursor = NULL;
+static char *arg_cursor = NULL;
 static bool arg_after_cursor = false;
 static int arg_journal_type = 0;
 static int arg_namespace_flags = 0;
-static const char *arg_machine = NULL;
-static const char *arg_namespace = NULL;
+static char *arg_machine = NULL;
+static char *arg_namespace = NULL;
 static bool arg_merge = false;
 static int arg_follow = -1;
-static const char *arg_save_state = NULL;
+static char *arg_save_state = NULL;
 static usec_t arg_network_timeout_usec = USEC_INFINITY;
 static CompressionArgs arg_compression = {};
 static bool arg_force_compression = false;
 
+STATIC_DESTRUCTOR_REGISTER(arg_url, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_key, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_cert, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_trust, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_directory, freep);
 STATIC_DESTRUCTOR_REGISTER(arg_file, strv_freep);
+STATIC_DESTRUCTOR_REGISTER(arg_cursor, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_machine, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_namespace, freep);
+STATIC_DESTRUCTOR_REGISTER(arg_save_state, freep);
 STATIC_DESTRUCTOR_REGISTER(arg_compression, compression_args_clear);
 
 static void close_fd_input(Uploader *u);
@@ -716,35 +725,27 @@ static int parse_argv(int argc, char *argv[]) {
                         return version();
 
                 case 'u':
-                        if (arg_url)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use more than one --url=");
-
-                        arg_url = optarg;
+                        r = free_and_strdup_warn(&arg_url, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_KEY:
-                        if (arg_key)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use more than one --key=");
-
-                        arg_key = optarg;
+                        r = free_and_strdup_warn(&arg_key, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_CERT:
-                        if (arg_cert)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use more than one --cert=");
-
-                        arg_cert = optarg;
+                        r = free_and_strdup_warn(&arg_cert, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_TRUST:
-                        if (arg_trust)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use more than one --trust=");
-
-                        arg_trust = optarg;
+                        r = free_and_strdup_warn(&arg_trust, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_SYSTEM:
@@ -760,36 +761,35 @@ static int parse_argv(int argc, char *argv[]) {
                         break;
 
                 case 'M':
-                        if (arg_machine)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use more than one --machine=/-M");
-
-                        arg_machine = optarg;
+                        r = free_and_strdup_warn(&arg_machine, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_NAMESPACE:
                         if (streq(optarg, "*")) {
                                 arg_namespace_flags = SD_JOURNAL_ALL_NAMESPACES;
-                                arg_namespace = NULL;
+                                arg_namespace = mfree(arg_namespace);
+                                r = 0;
                         } else if (startswith(optarg, "+")) {
                                 arg_namespace_flags = SD_JOURNAL_INCLUDE_DEFAULT_NAMESPACE;
-                                arg_namespace = optarg + 1;
+                                r = free_and_strdup_warn(&arg_namespace, optarg + 1);
                         } else if (isempty(optarg)) {
                                 arg_namespace_flags = 0;
-                                arg_namespace = NULL;
+                                arg_namespace = mfree(arg_namespace);
+                                r = 0;
                         } else {
                                 arg_namespace_flags = 0;
-                                arg_namespace = optarg;
+                                r = free_and_strdup_warn(&arg_namespace, optarg);
                         }
-
+                        if (r < 0)
+                                return r;
                         break;
 
                 case 'D':
-                        if (arg_directory)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use more than one --directory=/-D");
-
-                        arg_directory = optarg;
+                        r = free_and_strdup_warn(&arg_directory, optarg);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case ARG_FILE:
@@ -799,20 +799,11 @@ static int parse_argv(int argc, char *argv[]) {
                         break;
 
                 case ARG_CURSOR:
-                        if (arg_cursor)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use more than one --cursor=/--after-cursor=");
-
-                        arg_cursor = optarg;
-                        break;
-
                 case ARG_AFTER_CURSOR:
-                        if (arg_cursor)
-                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                                       "Cannot use more than one --cursor=/--after-cursor=");
-
-                        arg_cursor = optarg;
-                        arg_after_cursor = true;
+                        r = free_and_strdup_warn(&arg_cursor, optarg);
+                        if (r < 0)
+                                return r;
+                        arg_after_cursor = c == ARG_AFTER_CURSOR;
                         break;
 
                 case ARG_FOLLOW:
@@ -823,7 +814,9 @@ static int parse_argv(int argc, char *argv[]) {
                         break;
 
                 case ARG_SAVE_STATE:
-                        arg_save_state = optarg ?: STATE_FILE;
+                        r = free_and_strdup_warn(&arg_save_state, optarg ?: STATE_FILE);
+                        if (r < 0)
+                                return r;
                         break;
 
                 case '?':