HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/journal-remote/journal-remote-main.c

47,337 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: ea2d480212b04a01c5d04bc59994e2c39b3e6bd3

Lines 1001–1234 of 1,234

 
                                r = extract_first_word(&p, &word, ",", 0);
                                if (r < 0)
                                        return log_error_errno(r, "Failed to parse --gnutls-log= argument: %m");
                                if (r == 0)
                                        break;
 
                                if (strv_consume(&arg_gnutls_log, TAKE_PTR(word)) < 0)
                                        return log_oom();
                        }
#else
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Option --gnutls-log= is not available.");
#endif
                        break;
 
                OPTION_LONG("max-use", "BYTES", "Maximum disk space to use"):
                        r = parse_size(opts.arg, 1024, &arg_max_use);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --max-use= value: %s", opts.arg);
                        break;
 
                OPTION_LONG("keep-free", "BYTES", "Minimum disk space to keep free"):
                        r = parse_size(opts.arg, 1024, &arg_keep_free);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --keep-free= value: %s", opts.arg);
                        break;
 
                OPTION_LONG("max-file-size", "BYTES", "Maximum size of individual journal files"):
                        r = parse_size(opts.arg, 1024, &arg_max_size);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --max-file-size= value: %s", opts.arg);
                        break;
 
                OPTION_LONG("max-files", "N", "Maximum number of journal files to keep"):
                        r = safe_atou64(opts.arg, &arg_n_max_files);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --max-files= value: %s", opts.arg);
                        break;
 
                OPTION_COMMON_INTROSPECT_CLI:
                        return introspect_cli(SD_JSON_FORMAT_OFF);
                }
 
        arg_files = strv_copy(option_parser_get_args(&opts));
        if (!arg_files)
                return log_oom();
 
        type_a = arg_getter || !strv_isempty(arg_files);
        type_b = arg_url
                || arg_listen_raw
                || arg_listen_http || arg_listen_https
                || sd_listen_fds(false) > 0;
        if (type_a && type_b)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Cannot use file input or --getter= with "
                                       "--listen-...= or socket activation.");
        if (type_a) {
                if (!arg_output)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "Option --output= must be specified with file input or --getter=.");
 
                if (!IN_SET(arg_split_mode, JOURNAL_WRITE_SPLIT_NONE, _JOURNAL_WRITE_SPLIT_INVALID))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "For active sources, only --split-mode=none is allowed.");
 
                arg_split_mode = JOURNAL_WRITE_SPLIT_NONE;
        }
 
        if (arg_split_mode == _JOURNAL_WRITE_SPLIT_INVALID)
                arg_split_mode = JOURNAL_WRITE_SPLIT_HOST;
 
        if (arg_split_mode == JOURNAL_WRITE_SPLIT_NONE && arg_output) {
                if (is_dir(arg_output, true) > 0)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "For SplitMode=none, output must be a file.");
                if (!endswith(arg_output, ".journal"))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "For SplitMode=none, output file name must end with .journal.");
        }
 
        if (arg_split_mode == JOURNAL_WRITE_SPLIT_HOST
            && arg_output && is_dir(arg_output, true) <= 0)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "For SplitMode=host, output must be a directory.");
 
        if (STRPTR_IN_SET(arg_trust, "-", "all")) {
                arg_trust_all = true;
                arg_trust = mfree(arg_trust);
        }
 
        log_debug("Full config: SplitMode=%s Key=%s Cert=%s Trust=%s",
                  journal_write_split_mode_to_string(arg_split_mode),
                  strna(arg_key),
                  strna(arg_cert),
                  strna(arg_trust));
 
        return 1 /* work to do */;
}
 
static int load_certificates(char **key, char **cert, char **trust) {
        int r;
 
        assert(trust);
 
        r = read_full_file_full(
                        AT_FDCWD, arg_key ?: PRIV_KEY_FILE, UINT64_MAX, SIZE_MAX,
                        READ_FULL_FILE_SECURE|READ_FULL_FILE_WARN_WORLD_READABLE|READ_FULL_FILE_CONNECT_SOCKET,
                        NULL,
                        key, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to read key from file '%s': %m",
                                       arg_key ?: PRIV_KEY_FILE);
 
        r = read_full_file_full(
                        AT_FDCWD, arg_cert ?: CERT_FILE, UINT64_MAX, SIZE_MAX,
                        READ_FULL_FILE_CONNECT_SOCKET,
                        NULL,
                        cert, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to read certificate from file '%s': %m",
                                       arg_cert ?: CERT_FILE);
 
        if (arg_trust_all)
                log_info("Certificate checking disabled.");
        else {
                r = read_full_file_full(
                                AT_FDCWD, arg_trust ?: TRUST_FILE, UINT64_MAX, SIZE_MAX,
                                READ_FULL_FILE_CONNECT_SOCKET,
                                NULL,
                                trust, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to read CA certificate file '%s': %m",
                                               arg_trust ?: TRUST_FILE);
        }
 
        if ((arg_listen_raw || arg_listen_http) && *trust)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Option --trust= makes all non-HTTPS connections untrusted.");
 
        return 0;
}
 
static int run(int argc, char **argv) {
        _cleanup_(journal_remote_server_destroy) RemoteServer s = {};
        _unused_ _cleanup_(notify_on_cleanup) const char *notify_message = NULL;
        _cleanup_(erase_and_freep) char *key = NULL;
        _cleanup_free_ char *cert = NULL, *trust = NULL;
        int r;
 
        COMPRESS_DEFAULT_NOTE;
        LIBCRYPTO_NOTE(suggested);
        LIBGNUTLS_NOTE(suggested);
        LIBMICROHTTPD_NOTE(required);
        LIBSELINUX_NOTE(recommended);
 
        log_setup();
 
        journal_auth_init();
 
        r = parse_config();
        if (r < 0)
                return r;
 
        r = parse_argv(argc, argv);
        if (r <= 0)
                return r;
 
        r = compression_configs_mangle(&arg_compression);
        if (r < 0)
                return r;
 
        journal_browse_prepare();
 
#if HAVE_MICROHTTPD
        if (arg_listen_http || arg_listen_https) {
                r = setup_gnutls_logger(arg_gnutls_log);
                if (r < 0)
                        return r;
        }
#endif
 
        if (arg_listen_https || https_socket >= 0) {
                r = load_certificates(&key, &cert, &trust);
                if (r < 0)
                        return r;
 
                s.check_trust = !arg_trust_all;
        }
 
        journal_reset_metrics(&s.metrics);
        s.metrics.max_use = arg_max_use;
        s.metrics.max_size = arg_max_size;
        s.metrics.keep_free = arg_keep_free;
        s.metrics.n_max_files = arg_n_max_files;
 
        r = create_remoteserver(&s, key, cert, trust);
        if (r < 0)
                return r;
 
        r = sd_event_set_watchdog(s.event, true);
        if (r < 0)
                return log_error_errno(r, "Failed to enable watchdog: %m");
 
        log_debug("Watchdog is %sd.", enable_disable(r > 0));
 
        log_debug("%s running as pid "PID_FMT,
                  program_invocation_short_name, getpid_cached());
 
        notify_message = notify_start(NOTIFY_READY_MESSAGE, NOTIFY_STOPPING_MESSAGE);
 
        while (s.active) {
                r = sd_event_get_state(s.event);
                if (r < 0)
                        return r;
                if (r == SD_EVENT_FINISHED)
                        break;
 
                r = sd_event_run(s.event, -1);
                if (r < 0)
                        return log_error_errno(r, "Failed to run event loop: %m");
        }
 
        notify_message = NULL;
        (void) sd_notifyf(false,
                          "STOPPING=1\n"
                          "STATUS=Shutting down after writing %" PRIu64 " entries...", s.event_count);
 
        log_info("Finishing after writing %" PRIu64 " entries", s.event_count);
 
        return 0;
}
 
DEFINE_MAIN_FUNCTION(run);