[thirdparty/systemd.git] / src / journal / cat.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <fcntl.h>
#include <getopt.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

#include "sd-journal.h"

#include "alloc-util.h"
#include "build.h"
#include "env-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
#include "main-func.h"
#include "parse-argument.h"
#include "pretty-print.h"
#include "string-util.h"
#include "syslog-util.h"

static const char *arg_identifier = NULL;
static const char *arg_namespace = NULL;
static int arg_priority = LOG_INFO;
static int arg_stderr_priority = -1;
static bool arg_level_prefix = true;

static int help(void) {
        _cleanup_free_ char *link = NULL;
        int r;

        r = terminal_urlify_man("systemd-cat", "1", &link);
        if (r < 0)
                return log_oom();

        printf("%s [OPTIONS...] COMMAND ...\n"
               "\n%sExecute process with stdout/stderr connected to the journal.%s\n\n"
               "  -h --help                      Show this help\n"
               "     --version                   Show package version\n"
               "  -t --identifier=STRING         Set syslog identifier\n"
               "  -p --priority=PRIORITY         Set priority value (0..7)\n"
               "     --stderr-priority=PRIORITY  Set priority value (0..7) used for stderr\n"
               "     --level-prefix=BOOL         Control whether level prefix shall be parsed\n"
               "     --namespace=NAMESPACE       Connect to specified journal namespace\n"
               "\nSee the %s for details.\n",
               program_invocation_short_name,
               ansi_highlight(),
               ansi_normal(),
               link);

        return 0;
}

static int parse_argv(int argc, char *argv[]) {

        enum {
                ARG_VERSION = 0x100,
                ARG_STDERR_PRIORITY,
                ARG_LEVEL_PREFIX,
                ARG_NAMESPACE,
        };

        static const struct option options[] = {
                { "help",            no_argument,       NULL, 'h'                 },
                { "version",         no_argument,       NULL, ARG_VERSION         },
                { "identifier",      required_argument, NULL, 't'                 },
                { "priority",        required_argument, NULL, 'p'                 },
                { "stderr-priority", required_argument, NULL, ARG_STDERR_PRIORITY },
                { "level-prefix",    required_argument, NULL, ARG_LEVEL_PREFIX    },
                { "namespace",       required_argument, NULL, ARG_NAMESPACE       },
                {}
        };

        int c, r;

        assert(argc >= 0);
        assert(argv);

        /* Resetting to 0 forces the invocation of an internal initialization routine of getopt_long()
         * that checks for GNU extensions in optstring ('-' or '+' at the beginning). */
        optind = 0;
        while ((c = getopt_long(argc, argv, "+ht:p:", options, NULL)) >= 0)

                switch (c) {

                case 'h':
                        help();
                        return 0;

                case ARG_VERSION:
                        return version();

                case 't':
                        arg_identifier = empty_to_null(optarg);
                        break;

                case 'p':
                        arg_priority = log_level_from_string(optarg);
                        if (arg_priority < 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Failed to parse priority value.");
                        break;

                case ARG_STDERR_PRIORITY:
                        arg_stderr_priority = log_level_from_string(optarg);
                        if (arg_stderr_priority < 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Failed to parse stderr priority value.");
                        break;

                case ARG_LEVEL_PREFIX:
                        r = parse_boolean_argument("--level-prefix=", optarg, &arg_level_prefix);
                        if (r < 0)
                                return r;
                        break;

                case ARG_NAMESPACE:
                        arg_namespace = empty_to_null(optarg);
                        break;

                case '?':
                        return -EINVAL;

                default:
                        assert_not_reached();
                }

        return 1;
}

static int run(int argc, char *argv[]) {
        _cleanup_close_ int outfd = -EBADF, errfd = -EBADF, saved_stderr = -EBADF;
        int r;

        log_setup();

        r = parse_argv(argc, argv);
        if (r <= 0)
                return r;

        outfd = sd_journal_stream_fd_with_namespace(arg_namespace, arg_identifier, arg_priority, arg_level_prefix);
        if (outfd < 0)
                return log_error_errno(outfd, "Failed to create stream fd: %m");

        if (arg_stderr_priority >= 0 && arg_stderr_priority != arg_priority) {
                errfd = sd_journal_stream_fd_with_namespace(arg_namespace, arg_identifier, arg_stderr_priority, arg_level_prefix);
                if (errfd < 0)
                        return log_error_errno(errfd, "Failed to create stream fd: %m");
        }

        saved_stderr = fcntl(STDERR_FILENO, F_DUPFD_CLOEXEC, 3);

        r = rearrange_stdio(STDIN_FILENO, outfd, errfd < 0 ? outfd : errfd); /* Invalidates fd on success + error! */
        TAKE_FD(outfd);
        TAKE_FD(errfd);
        if (r < 0)
                return log_error_errno(r, "Failed to rearrange stdout/stderr: %m");

        if (argc <= optind)
                (void) execl("/bin/cat", "/bin/cat", NULL);
        else {
                struct stat st;

                if (fstat(STDERR_FILENO, &st) < 0)
                        return log_error_errno(errno,
                                               "Failed to fstat(%s): %m",
                                               FORMAT_PROC_FD_PATH(STDERR_FILENO));

                r = setenvf("JOURNAL_STREAM", /* overwrite = */ true, DEV_FMT ":" INO_FMT, (dev_t) st.st_dev, st.st_ino);
                if (r < 0)
                        return log_error_errno(r, "Failed to set environment variable JOURNAL_STREAM: %m");

                (void) execvp(argv[optind], argv + optind);
        }
        r = -errno;

        /* Let's try to restore a working stderr, so we can print the error message */
        if (saved_stderr >= 0)
                (void) dup3(saved_stderr, STDERR_FILENO, 0);

        return log_error_errno(r, "Failed to execute process: %m");
}

DEFINE_MAIN_FUNCTION(run);
Commit	Line	Data
	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
	2
	3	#include <fcntl.h>
	4	#include <getopt.h>
	5	#include <stdio.h>
	6	#include <sys/stat.h>
	7	#include <unistd.h>
	8
	9	#include "sd-journal.h"
	10
	11	#include "alloc-util.h"
	12	#include "build.h"
	13	#include "env-util.h"
	14	#include "fd-util.h"
	15	#include "format-util.h"
	16	#include "log.h"
	17	#include "main-func.h"
	18	#include "parse-argument.h"
	19	#include "pretty-print.h"
	20	#include "string-util.h"
	21	#include "syslog-util.h"
	22
	23	static const char *arg_identifier = NULL;
	24	static const char *arg_namespace = NULL;
	25	static int arg_priority = LOG_INFO;
	26	static int arg_stderr_priority = -1;
	27	static bool arg_level_prefix = true;
	28
	29	static int help(void) {
	30	_cleanup_free_ char *link = NULL;
	31	int r;
	32
	33	r = terminal_urlify_man("systemd-cat", "1", &link);
	34	if (r < 0)
	35	return log_oom();
	36
	37	printf("%s [OPTIONS...] COMMAND ...\n"
	38	"\n%sExecute process with stdout/stderr connected to the journal.%s\n\n"
	39	" -h --help Show this help\n"
	40	" --version Show package version\n"
	41	" -t --identifier=STRING Set syslog identifier\n"
	42	" -p --priority=PRIORITY Set priority value (0..7)\n"
	43	" --stderr-priority=PRIORITY Set priority value (0..7) used for stderr\n"
	44	" --level-prefix=BOOL Control whether level prefix shall be parsed\n"
	45	" --namespace=NAMESPACE Connect to specified journal namespace\n"
	46	"\nSee the %s for details.\n",
	47	program_invocation_short_name,
	48	ansi_highlight(),
	49	ansi_normal(),
	50	link);
	51
	52	return 0;
	53	}
	54
	55	static int parse_argv(int argc, char *argv[]) {
	56
	57	enum {
	58	ARG_VERSION = 0x100,
	59	ARG_STDERR_PRIORITY,
	60	ARG_LEVEL_PREFIX,
	61	ARG_NAMESPACE,
	62	};
	63
	64	static const struct option options[] = {
	65	{ "help", no_argument, NULL, 'h' },
	66	{ "version", no_argument, NULL, ARG_VERSION },
	67	{ "identifier", required_argument, NULL, 't' },
	68	{ "priority", required_argument, NULL, 'p' },
	69	{ "stderr-priority", required_argument, NULL, ARG_STDERR_PRIORITY },
	70	{ "level-prefix", required_argument, NULL, ARG_LEVEL_PREFIX },
	71	{ "namespace", required_argument, NULL, ARG_NAMESPACE },
	72	{}
	73	};
	74
	75	int c, r;
	76
	77	assert(argc >= 0);
	78	assert(argv);
	79
	80	/* Resetting to 0 forces the invocation of an internal initialization routine of getopt_long()
	81	* that checks for GNU extensions in optstring ('-' or '+' at the beginning). */
	82	optind = 0;
	83	while ((c = getopt_long(argc, argv, "+ht:p:", options, NULL)) >= 0)
	84
	85	switch (c) {
	86
	87	case 'h':
	88	help();
	89	return 0;
	90
	91	case ARG_VERSION:
	92	return version();
	93
	94	case 't':
	95	arg_identifier = empty_to_null(optarg);
	96	break;
	97
	98	case 'p':
	99	arg_priority = log_level_from_string(optarg);
	100	if (arg_priority < 0)
	101	return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
	102	"Failed to parse priority value.");
	103	break;
	104
	105	case ARG_STDERR_PRIORITY:
	106	arg_stderr_priority = log_level_from_string(optarg);
	107	if (arg_stderr_priority < 0)
	108	return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
	109	"Failed to parse stderr priority value.");
	110	break;
	111
	112	case ARG_LEVEL_PREFIX:
	113	r = parse_boolean_argument("--level-prefix=", optarg, &arg_level_prefix);
	114	if (r < 0)
	115	return r;
	116	break;
	117
	118	case ARG_NAMESPACE:
	119	arg_namespace = empty_to_null(optarg);
	120	break;
	121
	122	case '?':
	123	return -EINVAL;
	124
	125	default:
	126	assert_not_reached();
	127	}
	128
	129	return 1;
	130	}
	131
	132	static int run(int argc, char *argv[]) {
	133	_cleanup_close_ int outfd = -EBADF, errfd = -EBADF, saved_stderr = -EBADF;
	134	int r;
	135
	136	log_setup();
	137
	138	r = parse_argv(argc, argv);
	139	if (r <= 0)
	140	return r;
	141
	142	outfd = sd_journal_stream_fd_with_namespace(arg_namespace, arg_identifier, arg_priority, arg_level_prefix);
	143	if (outfd < 0)
	144	return log_error_errno(outfd, "Failed to create stream fd: %m");
	145
	146	if (arg_stderr_priority >= 0 && arg_stderr_priority != arg_priority) {
	147	errfd = sd_journal_stream_fd_with_namespace(arg_namespace, arg_identifier, arg_stderr_priority, arg_level_prefix);
	148	if (errfd < 0)
	149	return log_error_errno(errfd, "Failed to create stream fd: %m");
	150	}
	151
	152	saved_stderr = fcntl(STDERR_FILENO, F_DUPFD_CLOEXEC, 3);
	153
	154	r = rearrange_stdio(STDIN_FILENO, outfd, errfd < 0 ? outfd : errfd); /* Invalidates fd on success + error! */
	155	TAKE_FD(outfd);
	156	TAKE_FD(errfd);
	157	if (r < 0)
	158	return log_error_errno(r, "Failed to rearrange stdout/stderr: %m");
	159
	160	if (argc <= optind)
	161	(void) execl("/bin/cat", "/bin/cat", NULL);
	162	else {
	163	struct stat st;
	164
	165	if (fstat(STDERR_FILENO, &st) < 0)
	166	return log_error_errno(errno,
	167	"Failed to fstat(%s): %m",
	168	FORMAT_PROC_FD_PATH(STDERR_FILENO));
	169
	170	r = setenvf("JOURNAL_STREAM", /* overwrite = */ true, DEV_FMT ":" INO_FMT, (dev_t) st.st_dev, st.st_ino);
	171	if (r < 0)
	172	return log_error_errno(r, "Failed to set environment variable JOURNAL_STREAM: %m");
	173
	174	(void) execvp(argv[optind], argv + optind);
	175	}
	176	r = -errno;
	177
	178	/* Let's try to restore a working stderr, so we can print the error message */
	179	if (saved_stderr >= 0)
	180	(void) dup3(saved_stderr, STDERR_FILENO, 0);
	181
	182	return log_error_errno(r, "Failed to execute process: %m");
	183	}
	184
	185	DEFINE_MAIN_FUNCTION(run);