2006-12-06 17:25:32 -06:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1983, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
2006-12-06 17:25:39 -06:00
|
|
|
*
|
2013-01-26 10:07:51 -06:00
|
|
|
* 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
|
2006-12-06 17:25:39 -06:00
|
|
|
* - added Native Language Support
|
|
|
|
* Sun Mar 21 1999 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
|
|
|
|
* - fixed strerr(errno) in gettext calls
|
2006-12-06 17:25:32 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <errno.h>
|
2014-05-11 14:26:41 -05:00
|
|
|
#include <limits.h>
|
2006-12-06 17:25:32 -06:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
2014-09-18 18:36:37 -05:00
|
|
|
#include <sys/time.h>
|
2006-12-06 17:25:32 -06:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <string.h>
|
2006-12-06 17:25:39 -06:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/socket.h>
|
2006-12-06 17:25:44 -06:00
|
|
|
#include <sys/un.h>
|
2011-01-28 07:15:20 -06:00
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <netdb.h>
|
2011-02-24 13:16:40 -06:00
|
|
|
#include <getopt.h>
|
2014-06-22 17:29:36 -05:00
|
|
|
#include <pwd.h>
|
2015-10-29 05:18:21 -05:00
|
|
|
#include <signal.h>
|
2016-02-22 10:25:21 -06:00
|
|
|
#include <sys/uio.h>
|
2011-02-24 13:16:40 -06:00
|
|
|
|
2014-06-22 16:59:57 -05:00
|
|
|
#include "all-io.h"
|
2011-02-24 13:16:40 -06:00
|
|
|
#include "c.h"
|
2012-04-04 12:56:48 -05:00
|
|
|
#include "closestream.h"
|
2006-12-06 17:25:39 -06:00
|
|
|
#include "nls.h"
|
2015-02-22 08:41:45 -06:00
|
|
|
#include "pathnames.h"
|
2011-02-24 13:16:40 -06:00
|
|
|
#include "strutils.h"
|
2014-02-21 13:25:30 -06:00
|
|
|
#include "xalloc.h"
|
2015-10-01 07:48:15 -05:00
|
|
|
#include "strv.h"
|
|
|
|
#include "list.h"
|
2006-12-06 17:25:32 -06:00
|
|
|
|
|
|
|
#define SYSLOG_NAMES
|
|
|
|
#include <syslog.h>
|
|
|
|
|
2014-04-09 05:23:30 -05:00
|
|
|
#ifdef HAVE_LIBSYSTEMD
|
2018-07-07 13:11:46 -05:00
|
|
|
# define SD_JOURNAL_SUPPRESS_LOCATION
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
# include <systemd/sd-daemon.h>
|
2014-02-21 13:25:30 -06:00
|
|
|
# include <systemd/sd-journal.h>
|
|
|
|
#endif
|
|
|
|
|
2015-01-18 15:44:54 -06:00
|
|
|
#ifdef HAVE_SYS_TIMEX_H
|
|
|
|
# include <sys/timex.h>
|
|
|
|
#endif
|
|
|
|
|
2013-04-05 15:17:24 -05:00
|
|
|
enum {
|
|
|
|
TYPE_UDP = (1 << 1),
|
|
|
|
TYPE_TCP = (1 << 2),
|
|
|
|
ALL_TYPES = TYPE_UDP | TYPE_TCP
|
|
|
|
};
|
|
|
|
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
enum {
|
|
|
|
AF_UNIX_ERRORS_OFF = 0,
|
|
|
|
AF_UNIX_ERRORS_ON,
|
|
|
|
AF_UNIX_ERRORS_AUTO
|
|
|
|
};
|
|
|
|
|
2013-05-22 06:12:08 -05:00
|
|
|
enum {
|
2014-02-21 13:25:30 -06:00
|
|
|
OPT_PRIO_PREFIX = CHAR_MAX + 1,
|
2014-06-26 10:13:55 -05:00
|
|
|
OPT_JOURNALD,
|
|
|
|
OPT_RFC3164,
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
OPT_RFC5424,
|
2015-02-20 13:42:34 -06:00
|
|
|
OPT_SOCKET_ERRORS,
|
2015-03-10 11:47:30 -05:00
|
|
|
OPT_MSGID,
|
2015-03-16 06:38:46 -05:00
|
|
|
OPT_NOACT,
|
2015-07-15 13:01:48 -05:00
|
|
|
OPT_ID,
|
2015-10-01 07:48:15 -05:00
|
|
|
OPT_STRUCTURED_DATA_ID,
|
|
|
|
OPT_STRUCTURED_DATA_PARAM,
|
2015-07-15 13:01:48 -05:00
|
|
|
OPT_OCTET_COUNT
|
2013-05-22 06:12:08 -05:00
|
|
|
};
|
|
|
|
|
2015-10-01 07:48:15 -05:00
|
|
|
/* rfc5424 structured data */
|
|
|
|
struct structured_data {
|
|
|
|
char *id; /* SD-ID */
|
|
|
|
char **params; /* array with SD-PARAMs */
|
|
|
|
|
|
|
|
struct list_head sds;
|
|
|
|
};
|
|
|
|
|
2014-06-26 15:48:25 -05:00
|
|
|
struct logger_ctl {
|
|
|
|
int fd;
|
|
|
|
int pri;
|
2014-08-20 05:24:40 -05:00
|
|
|
pid_t pid; /* zero when unwanted */
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
char *hdr; /* the syslog header (based on protocol) */
|
2017-04-15 15:56:23 -05:00
|
|
|
char const *tag;
|
2015-03-10 11:47:30 -05:00
|
|
|
char *msgid;
|
2015-03-06 04:05:30 -06:00
|
|
|
char *unix_socket; /* -u <path> or default to _PATH_DEVLOG */
|
2014-07-26 07:10:25 -05:00
|
|
|
char *server;
|
|
|
|
char *port;
|
|
|
|
int socket_type;
|
2015-03-06 08:50:34 -06:00
|
|
|
size_t max_message_size;
|
2015-10-01 07:48:15 -05:00
|
|
|
struct list_head user_sds; /* user defined rfc5424 structured data */
|
|
|
|
struct list_head reserved_sds; /* standard rfc5424 structured data */
|
|
|
|
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
void (*syslogfp)(struct logger_ctl *ctl);
|
2015-10-01 07:48:15 -05:00
|
|
|
|
2014-06-26 10:13:55 -05:00
|
|
|
unsigned int
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
unix_socket_errors:1, /* whether to report or not errors */
|
2015-03-16 06:38:46 -05:00
|
|
|
noact:1, /* do not write to sockets */
|
2016-05-29 16:11:53 -05:00
|
|
|
prio_prefix:1, /* read priority from input */
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
stderr_printout:1, /* output message to stderr */
|
|
|
|
rfc5424_time:1, /* include time stamp */
|
|
|
|
rfc5424_tq:1, /* include time quality markup */
|
2015-03-07 05:14:21 -06:00
|
|
|
rfc5424_host:1, /* include hostname */
|
2015-07-15 13:01:48 -05:00
|
|
|
skip_empty_lines:1, /* do not send empty lines when processing files */
|
|
|
|
octet_count:1; /* use RFC6587 octet counting */
|
2014-06-26 15:48:25 -05:00
|
|
|
};
|
|
|
|
|
2017-10-11 05:35:24 -05:00
|
|
|
#define is_connected(_ctl) ((_ctl)->fd >= 0)
|
2017-10-10 06:56:30 -05:00
|
|
|
static void logger_reopen(struct logger_ctl *ctl);
|
|
|
|
|
2015-03-16 07:26:52 -05:00
|
|
|
/*
|
|
|
|
* For tests we want to be able to control datetime outputs
|
|
|
|
*/
|
|
|
|
#ifdef TEST_LOGGER
|
|
|
|
static inline int logger_gettimeofday(struct timeval *tv, struct timezone *tz)
|
|
|
|
{
|
|
|
|
char *str = getenv("LOGGER_TEST_TIMEOFDAY");
|
|
|
|
uintmax_t sec, usec;
|
|
|
|
|
|
|
|
if (str && sscanf(str, "%ju.%ju", &sec, &usec) == 2) {
|
|
|
|
tv->tv_sec = sec;
|
|
|
|
tv->tv_usec = usec;
|
2015-03-23 05:40:45 -05:00
|
|
|
return tv->tv_sec >= 0 && tv->tv_usec >= 0 ? 0 : -EINVAL;
|
2015-03-16 07:26:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return gettimeofday(tv, tz);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline char *logger_xgethostname(void)
|
|
|
|
{
|
|
|
|
char *str = getenv("LOGGER_TEST_HOSTNAME");
|
|
|
|
return str ? xstrdup(str) : xgethostname();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline pid_t logger_getpid(void)
|
|
|
|
{
|
|
|
|
char *str = getenv("LOGGER_TEST_GETPID");
|
|
|
|
unsigned int pid;
|
|
|
|
|
|
|
|
if (str && sscanf(str, "%u", &pid) == 1)
|
|
|
|
return pid;
|
|
|
|
return getpid();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#undef HAVE_NTP_GETTIME /* force to default non-NTP */
|
|
|
|
|
|
|
|
#else /* !TEST_LOGGER */
|
|
|
|
# define logger_gettimeofday(x, y) gettimeofday(x, y)
|
|
|
|
# define logger_xgethostname xgethostname
|
|
|
|
# define logger_getpid getpid
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2016-03-08 04:23:14 -06:00
|
|
|
static int decode(const char *name, const CODE *codetab)
|
2012-05-23 15:36:00 -05:00
|
|
|
{
|
2016-03-08 04:23:14 -06:00
|
|
|
register const CODE *c;
|
2012-05-23 15:36:00 -05:00
|
|
|
|
2014-05-11 14:26:42 -05:00
|
|
|
if (name == NULL || *name == '\0')
|
|
|
|
return -1;
|
|
|
|
if (isdigit(*name)) {
|
|
|
|
int num;
|
|
|
|
char *end = NULL;
|
|
|
|
|
2015-03-15 08:23:32 -05:00
|
|
|
errno = 0;
|
2014-05-11 14:26:42 -05:00
|
|
|
num = strtol(name, &end, 10);
|
|
|
|
if (errno || name == end || (end && *end))
|
|
|
|
return -1;
|
|
|
|
for (c = codetab; c->c_name; c++)
|
|
|
|
if (num == c->c_val)
|
|
|
|
return num;
|
|
|
|
return -1;
|
|
|
|
}
|
2012-05-23 15:36:00 -05:00
|
|
|
for (c = codetab; c->c_name; c++)
|
|
|
|
if (!strcasecmp(name, c->c_name))
|
|
|
|
return (c->c_val);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pencode(char *s)
|
|
|
|
{
|
2014-07-26 09:19:26 -05:00
|
|
|
int facility, level;
|
|
|
|
char *separator;
|
|
|
|
|
2019-05-23 05:14:10 -05:00
|
|
|
assert(s);
|
|
|
|
|
2014-07-26 09:19:26 -05:00
|
|
|
separator = strchr(s, '.');
|
|
|
|
if (separator) {
|
|
|
|
*separator = '\0';
|
|
|
|
facility = decode(s, facilitynames);
|
|
|
|
if (facility < 0)
|
|
|
|
errx(EXIT_FAILURE, _("unknown facility name: %s"), s);
|
|
|
|
s = ++separator;
|
|
|
|
} else
|
|
|
|
facility = LOG_USER;
|
|
|
|
level = decode(s, prioritynames);
|
|
|
|
if (level < 0)
|
|
|
|
errx(EXIT_FAILURE, _("unknown priority name: %s"), s);
|
2015-03-15 07:54:47 -05:00
|
|
|
if (facility == LOG_KERN)
|
|
|
|
facility = LOG_USER; /* kern is forbidden */
|
2014-07-26 09:19:26 -05:00
|
|
|
return ((level & LOG_PRIMASK) | (facility & LOG_FACMASK));
|
2012-05-23 15:36:00 -05:00
|
|
|
}
|
|
|
|
|
2015-10-06 02:16:33 -05:00
|
|
|
static int unix_socket(struct logger_ctl *ctl, const char *path, int *socket_type)
|
2013-04-02 14:42:57 -05:00
|
|
|
{
|
2019-02-09 03:34:52 -06:00
|
|
|
int fd = -1, i, type = -1;
|
2013-04-02 14:42:57 -05:00
|
|
|
static struct sockaddr_un s_addr; /* AF_UNIX address of local logger */
|
2006-12-06 17:25:39 -06:00
|
|
|
|
2013-04-05 15:17:24 -05:00
|
|
|
if (strlen(path) >= sizeof(s_addr.sun_path))
|
|
|
|
errx(EXIT_FAILURE, _("openlog %s: pathname too long"), path);
|
2006-12-06 17:25:39 -06:00
|
|
|
|
2013-04-02 14:42:57 -05:00
|
|
|
s_addr.sun_family = AF_UNIX;
|
2013-04-05 15:17:24 -05:00
|
|
|
strcpy(s_addr.sun_path, path);
|
|
|
|
|
|
|
|
for (i = 2; i; i--) {
|
|
|
|
int st = -1;
|
2011-02-24 13:16:41 -06:00
|
|
|
|
2015-10-06 02:16:33 -05:00
|
|
|
if (i == 2 && *socket_type & TYPE_UDP) {
|
2013-04-05 15:17:24 -05:00
|
|
|
st = SOCK_DGRAM;
|
2015-10-06 02:16:33 -05:00
|
|
|
type = TYPE_UDP;
|
|
|
|
}
|
|
|
|
if (i == 1 && *socket_type & TYPE_TCP) {
|
2013-04-05 15:17:24 -05:00
|
|
|
st = SOCK_STREAM;
|
2015-10-06 02:16:33 -05:00
|
|
|
type = TYPE_TCP;
|
|
|
|
}
|
2013-04-05 15:17:24 -05:00
|
|
|
if (st == -1 || (fd = socket(AF_UNIX, st, 0)) == -1)
|
|
|
|
continue;
|
2013-04-02 14:42:57 -05:00
|
|
|
if (connect(fd, (struct sockaddr *)&s_addr, sizeof(s_addr)) == -1) {
|
|
|
|
close(fd);
|
2013-04-05 15:17:24 -05:00
|
|
|
continue;
|
2013-04-02 14:42:57 -05:00
|
|
|
}
|
2013-04-05 15:17:24 -05:00
|
|
|
break;
|
2013-04-02 14:42:57 -05:00
|
|
|
}
|
2006-12-06 17:25:39 -06:00
|
|
|
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
if (i == 0) {
|
|
|
|
if (ctl->unix_socket_errors)
|
|
|
|
err(EXIT_FAILURE, _("socket %s"), path);
|
2015-08-05 06:23:34 -05:00
|
|
|
|
2017-10-11 05:35:24 -05:00
|
|
|
/* write_output() will try to reconnect */
|
2015-08-05 06:23:34 -05:00
|
|
|
return -1;
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
}
|
2015-10-06 02:16:33 -05:00
|
|
|
|
|
|
|
/* replace ALL_TYPES with the real TYPE_* */
|
|
|
|
if (type > 0 && type != *socket_type)
|
|
|
|
*socket_type = type;
|
2013-04-02 14:42:57 -05:00
|
|
|
return fd;
|
2006-12-06 17:25:39 -06:00
|
|
|
}
|
|
|
|
|
2015-10-06 02:16:33 -05:00
|
|
|
static int inet_socket(const char *servername, const char *port, int *socket_type)
|
2013-04-05 15:17:24 -05:00
|
|
|
{
|
2015-10-06 02:16:33 -05:00
|
|
|
int fd, errcode, i, type = -1;
|
2012-10-12 15:28:41 -05:00
|
|
|
struct addrinfo hints, *res;
|
2013-04-05 15:17:24 -05:00
|
|
|
const char *p = port;
|
|
|
|
|
|
|
|
for (i = 2; i; i--) {
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
2015-10-06 02:16:33 -05:00
|
|
|
if (i == 2 && *socket_type & TYPE_UDP) {
|
2013-04-05 15:17:24 -05:00
|
|
|
hints.ai_socktype = SOCK_DGRAM;
|
2015-10-06 02:16:33 -05:00
|
|
|
type = TYPE_UDP;
|
2013-04-05 15:17:24 -05:00
|
|
|
if (port == NULL)
|
|
|
|
p = "syslog";
|
|
|
|
}
|
2015-10-06 02:16:33 -05:00
|
|
|
if (i == 1 && *socket_type & TYPE_TCP) {
|
2013-04-05 15:17:24 -05:00
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
2015-10-06 02:16:33 -05:00
|
|
|
type = TYPE_TCP;
|
2013-04-05 15:17:24 -05:00
|
|
|
if (port == NULL)
|
|
|
|
p = "syslog-conn";
|
|
|
|
}
|
|
|
|
if (hints.ai_socktype == 0)
|
|
|
|
continue;
|
|
|
|
hints.ai_family = AF_UNSPEC;
|
|
|
|
errcode = getaddrinfo(servername, p, &hints, &res);
|
|
|
|
if (errcode != 0)
|
2013-05-29 14:52:56 -05:00
|
|
|
errx(EXIT_FAILURE, _("failed to resolve name %s port %s: %s"),
|
2013-04-05 15:17:24 -05:00
|
|
|
servername, p, gai_strerror(errcode));
|
|
|
|
if ((fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1) {
|
|
|
|
freeaddrinfo(res);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (connect(fd, res->ai_addr, res->ai_addrlen) == -1) {
|
|
|
|
freeaddrinfo(res);
|
|
|
|
close(fd);
|
|
|
|
continue;
|
|
|
|
}
|
2012-10-12 15:28:41 -05:00
|
|
|
|
2013-04-05 15:17:24 -05:00
|
|
|
freeaddrinfo(res);
|
|
|
|
break;
|
|
|
|
}
|
2011-01-28 07:15:20 -06:00
|
|
|
|
2013-04-05 15:17:24 -05:00
|
|
|
if (i == 0)
|
2013-05-29 14:52:56 -05:00
|
|
|
errx(EXIT_FAILURE, _("failed to connect to %s port %s"), servername, p);
|
2011-02-24 13:16:41 -06:00
|
|
|
|
2015-10-06 02:16:33 -05:00
|
|
|
/* replace ALL_TYPES with the real TYPE_* */
|
|
|
|
if (type > 0 && type != *socket_type)
|
|
|
|
*socket_type = type;
|
2011-01-28 07:15:20 -06:00
|
|
|
return fd;
|
|
|
|
}
|
2013-04-05 15:17:24 -05:00
|
|
|
|
2014-04-09 05:23:30 -05:00
|
|
|
#ifdef HAVE_LIBSYSTEMD
|
2015-03-16 06:38:46 -05:00
|
|
|
static int journald_entry(struct logger_ctl *ctl, FILE *fp)
|
2014-02-21 13:25:30 -06:00
|
|
|
{
|
|
|
|
struct iovec *iovec;
|
|
|
|
char *buf = NULL;
|
|
|
|
ssize_t sz;
|
2019-01-23 04:41:43 -06:00
|
|
|
int n, lines = 0, vectors = 8, ret = 0, msgline = -1;
|
2014-02-21 13:25:30 -06:00
|
|
|
size_t dummy = 0;
|
|
|
|
|
|
|
|
iovec = xmalloc(vectors * sizeof(struct iovec));
|
2019-01-23 04:41:43 -06:00
|
|
|
while (1) {
|
2014-02-21 13:25:30 -06:00
|
|
|
buf = NULL;
|
|
|
|
sz = getline(&buf, &dummy, fp);
|
2016-07-18 15:49:27 -05:00
|
|
|
if (sz == -1 ||
|
|
|
|
(sz = rtrim_whitespace((unsigned char *) buf)) == 0) {
|
2016-03-13 05:31:40 -05:00
|
|
|
free(buf);
|
2014-02-21 13:25:30 -06:00
|
|
|
break;
|
2016-03-13 05:31:40 -05:00
|
|
|
}
|
2019-01-23 04:41:43 -06:00
|
|
|
|
|
|
|
if (strncmp(buf, "MESSAGE=", 8) == 0) {
|
|
|
|
if (msgline == -1)
|
|
|
|
msgline = lines; /* remember the first message */
|
|
|
|
else {
|
|
|
|
char *p = xrealloc(iovec[msgline].iov_base,
|
|
|
|
iovec[msgline].iov_len + sz - 8 + 2);
|
|
|
|
|
|
|
|
iovec[msgline].iov_base = p;
|
|
|
|
p += iovec[msgline].iov_len;
|
|
|
|
*p++ = '\n';
|
|
|
|
memcpy(p, buf + 8, sz - 8);
|
|
|
|
free(buf);
|
|
|
|
|
|
|
|
iovec[msgline].iov_len += sz - 8 + 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-21 13:25:30 -06:00
|
|
|
if (lines == vectors) {
|
|
|
|
vectors *= 2;
|
2014-05-11 14:26:41 -05:00
|
|
|
if (IOV_MAX < vectors)
|
|
|
|
errx(EXIT_FAILURE, _("maximum input lines (%d) exceeded"), IOV_MAX);
|
2014-02-21 13:25:30 -06:00
|
|
|
iovec = xrealloc(iovec, vectors * sizeof(struct iovec));
|
|
|
|
}
|
|
|
|
iovec[lines].iov_base = buf;
|
|
|
|
iovec[lines].iov_len = sz;
|
2019-01-23 04:41:43 -06:00
|
|
|
++lines;
|
2014-02-21 13:25:30 -06:00
|
|
|
}
|
2015-03-16 06:38:46 -05:00
|
|
|
|
|
|
|
if (!ctl->noact)
|
|
|
|
ret = sd_journal_sendv(iovec, lines);
|
|
|
|
if (ctl->stderr_printout) {
|
|
|
|
for (n = 0; n < lines; n++)
|
|
|
|
fprintf(stderr, "%s\n", (char *) iovec[n].iov_base);
|
|
|
|
}
|
2014-02-21 13:25:30 -06:00
|
|
|
for (n = 0; n < lines; n++)
|
|
|
|
free(iovec[n].iov_base);
|
|
|
|
free(iovec);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-04-15 15:56:23 -05:00
|
|
|
static char const *xgetlogin(void)
|
2014-06-22 17:29:36 -05:00
|
|
|
{
|
2017-04-15 15:56:23 -05:00
|
|
|
char const *cp;
|
2014-06-22 17:29:36 -05:00
|
|
|
struct passwd *pw;
|
|
|
|
|
|
|
|
if (!(cp = getlogin()) || !*cp)
|
|
|
|
cp = (pw = getpwuid(geteuid()))? pw->pw_name : "<someone>";
|
|
|
|
return cp;
|
|
|
|
}
|
|
|
|
|
2015-03-05 08:20:50 -06:00
|
|
|
/* this creates a timestamp based on current time according to the
|
|
|
|
* fine rules of RFC3164, most importantly it ensures in a portable
|
|
|
|
* way that the month day is correctly written (with a SP instead
|
|
|
|
* of a leading 0). The function uses a static buffer which is
|
|
|
|
* overwritten on the next call (just like ctime() does).
|
|
|
|
*/
|
2017-04-15 15:56:23 -05:00
|
|
|
static char const *rfc3164_current_time(void)
|
2015-03-05 08:20:50 -06:00
|
|
|
{
|
|
|
|
static char time[32];
|
|
|
|
struct timeval tv;
|
2020-02-09 16:14:56 -06:00
|
|
|
struct tm tm;
|
2017-04-15 15:56:23 -05:00
|
|
|
static char const * const monthnames[] = {
|
2015-03-15 07:54:47 -05:00
|
|
|
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
|
|
|
|
"Sep", "Oct", "Nov", "Dec"
|
|
|
|
};
|
2015-03-05 08:20:50 -06:00
|
|
|
|
2015-03-16 07:26:52 -05:00
|
|
|
logger_gettimeofday(&tv, NULL);
|
2020-02-09 16:14:56 -06:00
|
|
|
localtime_r(&tv.tv_sec, &tm);
|
2015-03-05 08:20:50 -06:00
|
|
|
snprintf(time, sizeof(time),"%s %2d %2.2d:%2.2d:%2.2d",
|
2020-02-09 16:14:56 -06:00
|
|
|
monthnames[tm.tm_mon], tm.tm_mday,
|
|
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
2015-03-05 08:20:50 -06:00
|
|
|
return time;
|
|
|
|
}
|
|
|
|
|
2015-10-27 12:44:00 -05:00
|
|
|
#define next_iovec(ary, idx) __extension__ ({ \
|
2016-02-22 17:54:41 -06:00
|
|
|
assert(ARRAY_SIZE(ary) > (size_t)idx); \
|
2015-10-27 12:44:00 -05:00
|
|
|
assert(idx >= 0); \
|
|
|
|
&ary[idx++]; \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define iovec_add_string(ary, idx, str, len) \
|
|
|
|
do { \
|
|
|
|
struct iovec *v = next_iovec(ary, idx); \
|
|
|
|
v->iov_base = (void *) str; \
|
|
|
|
v->iov_len = len ? len : strlen(str); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define iovec_memcmp(ary, idx, str, len) \
|
|
|
|
memcmp((ary)[(idx) - 1].iov_base, str, len)
|
|
|
|
|
2015-03-06 05:12:15 -06:00
|
|
|
/* writes generated buffer to desired destination. For TCP syslog,
|
2015-07-15 13:01:48 -05:00
|
|
|
* we use RFC6587 octet-stuffing (unless octet-counting is selected).
|
|
|
|
* This is not great, but doing full blown RFC5425 (TLS) looks like
|
|
|
|
* it is too much for the logger utility. If octet-counting is
|
|
|
|
* selected, we use that.
|
2015-03-06 05:12:15 -06:00
|
|
|
*/
|
2017-10-10 06:56:30 -05:00
|
|
|
static void write_output(struct logger_ctl *ctl, const char *const msg)
|
2015-03-06 04:51:31 -06:00
|
|
|
{
|
2015-10-27 12:44:00 -05:00
|
|
|
struct iovec iov[4];
|
|
|
|
int iovlen = 0;
|
|
|
|
char *octet = NULL;
|
|
|
|
|
2017-10-11 05:35:24 -05:00
|
|
|
/* initial connect failed? */
|
|
|
|
if (!ctl->noact && !is_connected(ctl))
|
|
|
|
logger_reopen(ctl);
|
|
|
|
|
2015-10-27 12:44:00 -05:00
|
|
|
/* 1) octen count */
|
|
|
|
if (ctl->octet_count) {
|
|
|
|
size_t len = xasprintf(&octet, "%zu ", strlen(ctl->hdr) + strlen(msg));
|
|
|
|
iovec_add_string(iov, iovlen, octet, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 2) header */
|
|
|
|
iovec_add_string(iov, iovlen, ctl->hdr, 0);
|
|
|
|
|
|
|
|
/* 3) message */
|
|
|
|
iovec_add_string(iov, iovlen, msg, 0);
|
2015-03-16 06:38:46 -05:00
|
|
|
|
2017-10-11 05:35:24 -05:00
|
|
|
if (!ctl->noact && is_connected(ctl)) {
|
2015-10-31 07:27:36 -05:00
|
|
|
struct msghdr message = { 0 };
|
2016-02-18 18:44:14 -06:00
|
|
|
#ifdef SCM_CREDENTIALS
|
2015-10-29 05:18:21 -05:00
|
|
|
struct cmsghdr *cmhp;
|
|
|
|
struct ucred *cred;
|
|
|
|
union {
|
|
|
|
struct cmsghdr cmh;
|
|
|
|
char control[CMSG_SPACE(sizeof(struct ucred))];
|
|
|
|
} cbuf;
|
2016-02-18 18:44:14 -06:00
|
|
|
#endif
|
2015-10-27 12:44:00 -05:00
|
|
|
|
|
|
|
/* 4) add extra \n to make sure message is terminated */
|
|
|
|
if ((ctl->socket_type == TYPE_TCP) && !ctl->octet_count)
|
|
|
|
iovec_add_string(iov, iovlen, "\n", 1);
|
2015-10-27 07:19:16 -05:00
|
|
|
|
2015-10-31 07:27:36 -05:00
|
|
|
message.msg_iov = iov;
|
|
|
|
message.msg_iovlen = iovlen;
|
2015-10-27 07:19:16 -05:00
|
|
|
|
2016-02-18 18:44:14 -06:00
|
|
|
#ifdef SCM_CREDENTIALS
|
2015-10-29 05:18:21 -05:00
|
|
|
/* syslog/journald may follow local socket credentials rather
|
|
|
|
* than in the message PID. If we use --id as root than we can
|
|
|
|
* force kernel to accept another valid PID than the real logger(1)
|
|
|
|
* PID.
|
|
|
|
*/
|
|
|
|
if (ctl->pid && !ctl->server && ctl->pid != getpid()
|
|
|
|
&& geteuid() == 0 && kill(ctl->pid, 0) == 0) {
|
|
|
|
|
2015-10-31 07:27:36 -05:00
|
|
|
message.msg_control = cbuf.control;
|
|
|
|
message.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
|
2015-10-29 05:18:21 -05:00
|
|
|
|
2015-10-31 07:27:36 -05:00
|
|
|
cmhp = CMSG_FIRSTHDR(&message);
|
2015-10-29 05:18:21 -05:00
|
|
|
cmhp->cmsg_len = CMSG_LEN(sizeof(struct ucred));
|
|
|
|
cmhp->cmsg_level = SOL_SOCKET;
|
|
|
|
cmhp->cmsg_type = SCM_CREDENTIALS;
|
|
|
|
cred = (struct ucred *) CMSG_DATA(cmhp);
|
|
|
|
|
|
|
|
cred->pid = ctl->pid;
|
|
|
|
}
|
2016-02-18 18:44:14 -06:00
|
|
|
#endif
|
2017-10-10 06:56:30 -05:00
|
|
|
/* Note that logger(1) maybe executed for long time (as pipe
|
|
|
|
* reader) and connection endpoint (syslogd) may be restarted.
|
|
|
|
*
|
|
|
|
* The libc syslog() function reconnects on failed send().
|
|
|
|
* Let's do the same to be robust. [kzak -- Oct 2017]
|
2017-10-10 07:45:55 -05:00
|
|
|
*
|
|
|
|
* MSG_NOSIGNAL is POSIX.1-2008 compatible, but it for example
|
2018-02-15 15:02:18 -06:00
|
|
|
* not supported by apple-darwin15.6.0.
|
2017-10-10 06:56:30 -05:00
|
|
|
*/
|
2017-10-10 07:45:55 -05:00
|
|
|
#ifndef MSG_NOSIGNAL
|
|
|
|
# define MSG_NOSIGNAL 0
|
|
|
|
#endif
|
2017-10-10 06:56:30 -05:00
|
|
|
if (sendmsg(ctl->fd, &message, MSG_NOSIGNAL) < 0) {
|
|
|
|
logger_reopen(ctl);
|
|
|
|
if (sendmsg(ctl->fd, &message, MSG_NOSIGNAL) < 0)
|
|
|
|
warn(_("send message failed"));
|
|
|
|
}
|
2015-03-16 06:38:46 -05:00
|
|
|
}
|
2015-10-27 12:44:00 -05:00
|
|
|
|
|
|
|
if (ctl->stderr_printout) {
|
|
|
|
/* make sure it's terminated for stderr */
|
|
|
|
if (iovec_memcmp(iov, iovlen, "\n", 1) != 0)
|
|
|
|
iovec_add_string(iov, iovlen, "\n", 1);
|
|
|
|
|
|
|
|
ignore_result( writev(STDERR_FILENO, iov, iovlen) );
|
|
|
|
}
|
|
|
|
|
|
|
|
free(octet);
|
2015-03-06 04:51:31 -06:00
|
|
|
}
|
|
|
|
|
2015-03-15 07:54:48 -05:00
|
|
|
#define NILVALUE "-"
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
static void syslog_rfc3164_header(struct logger_ctl *const ctl)
|
2013-05-29 03:56:05 -05:00
|
|
|
{
|
2015-03-15 07:54:48 -05:00
|
|
|
char pid[30], *hostname;
|
2014-06-22 17:02:43 -05:00
|
|
|
|
2014-08-09 02:38:58 -05:00
|
|
|
*pid = '\0';
|
2014-08-20 05:24:40 -05:00
|
|
|
if (ctl->pid)
|
|
|
|
snprintf(pid, sizeof(pid), "[%d]", ctl->pid);
|
2014-07-29 04:43:01 -05:00
|
|
|
|
2015-03-16 07:26:52 -05:00
|
|
|
if ((hostname = logger_xgethostname())) {
|
2015-03-15 07:54:48 -05:00
|
|
|
char *dot = strchr(hostname, '.');
|
|
|
|
if (dot)
|
|
|
|
*dot = '\0';
|
|
|
|
} else
|
|
|
|
hostname = xstrdup(NILVALUE);
|
2014-07-29 04:43:01 -05:00
|
|
|
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
xasprintf(&ctl->hdr, "<%d>%.15s %s %.200s%s: ",
|
|
|
|
ctl->pri, rfc3164_current_time(), hostname, ctl->tag, pid);
|
2014-07-29 04:43:01 -05:00
|
|
|
|
|
|
|
free(hostname);
|
2006-12-06 17:25:39 -06:00
|
|
|
}
|
|
|
|
|
2015-10-01 07:48:15 -05:00
|
|
|
static inline struct list_head *get_user_structured_data(struct logger_ctl *ctl)
|
|
|
|
{
|
|
|
|
return &ctl->user_sds;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct list_head *get_reserved_structured_data(struct logger_ctl *ctl)
|
|
|
|
{
|
|
|
|
return &ctl->reserved_sds;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int has_structured_data_id(struct list_head *ls, const char *id)
|
|
|
|
{
|
|
|
|
struct list_head *p;
|
|
|
|
|
|
|
|
if (!ls || list_empty(ls))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
list_for_each(p, ls) {
|
|
|
|
struct structured_data *sd = list_entry(p, struct structured_data, sds);
|
|
|
|
if (sd->id && strcmp(sd->id, id) == 0)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_structured_data_id(struct list_head *ls, const char *id)
|
|
|
|
{
|
|
|
|
struct structured_data *sd;
|
|
|
|
|
|
|
|
assert(id);
|
|
|
|
|
|
|
|
if (has_structured_data_id(ls, id))
|
|
|
|
errx(EXIT_FAILURE, _("structured data ID '%s' is not unique"), id);
|
|
|
|
|
|
|
|
sd = xcalloc(1, sizeof(*sd));
|
|
|
|
INIT_LIST_HEAD(&sd->sds);
|
|
|
|
sd->id = xstrdup(id);
|
|
|
|
|
|
|
|
list_add_tail(&sd->sds, ls);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_structured_data_param(struct list_head *ls, const char *param)
|
|
|
|
{
|
|
|
|
struct structured_data *sd;
|
|
|
|
|
|
|
|
if (list_empty(ls))
|
2016-03-16 03:55:52 -05:00
|
|
|
errx(EXIT_FAILURE, _("--sd-id was not specified for --sd-param %s"), param);
|
2015-10-01 07:48:15 -05:00
|
|
|
|
|
|
|
assert(param);
|
|
|
|
|
|
|
|
sd = list_last_entry(ls, struct structured_data, sds);
|
|
|
|
|
|
|
|
if (strv_extend(&sd->params, param))
|
|
|
|
err_oom();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_structured_data_paramf(struct list_head *ls, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
struct structured_data *sd;
|
|
|
|
va_list ap;
|
|
|
|
int x;
|
|
|
|
|
|
|
|
assert(!list_empty(ls));
|
|
|
|
assert(fmt);
|
|
|
|
|
|
|
|
sd = list_last_entry(ls, struct structured_data, sds);
|
|
|
|
va_start(ap, fmt);
|
|
|
|
x = strv_extendv(&sd->params, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
if (x)
|
|
|
|
err_oom();
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *strdup_structured_data(struct structured_data *sd)
|
|
|
|
{
|
|
|
|
char *res, *tmp;
|
|
|
|
|
|
|
|
if (strv_isempty(sd->params))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
xasprintf(&res, "[%s %s]", sd->id,
|
|
|
|
(tmp = strv_join(sd->params, " ")));
|
|
|
|
free(tmp);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *strdup_structured_data_list(struct list_head *ls)
|
|
|
|
{
|
|
|
|
struct list_head *p;
|
|
|
|
char *res = NULL;
|
|
|
|
|
|
|
|
list_for_each(p, ls) {
|
|
|
|
struct structured_data *sd = list_entry(p, struct structured_data, sds);
|
|
|
|
char *one = strdup_structured_data(sd);
|
|
|
|
char *tmp = res;
|
|
|
|
|
|
|
|
if (!one)
|
|
|
|
continue;
|
|
|
|
res = strappend(tmp, one);
|
|
|
|
free(tmp);
|
|
|
|
free(one);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *get_structured_data_string(struct logger_ctl *ctl)
|
|
|
|
{
|
|
|
|
char *sys = NULL, *usr = NULL, *res;
|
|
|
|
|
|
|
|
if (!list_empty(&ctl->reserved_sds))
|
|
|
|
sys = strdup_structured_data_list(&ctl->reserved_sds);
|
|
|
|
if (!list_empty(&ctl->user_sds))
|
|
|
|
usr = strdup_structured_data_list(&ctl->user_sds);
|
|
|
|
|
|
|
|
if (sys && usr) {
|
|
|
|
res = strappend(sys, usr);
|
|
|
|
free(sys);
|
|
|
|
free(usr);
|
|
|
|
} else
|
|
|
|
res = sys ? sys : usr;
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int valid_structured_data_param(const char *str)
|
|
|
|
{
|
|
|
|
char *eq = strchr(str, '='),
|
|
|
|
*qm1 = strchr(str, '"'),
|
|
|
|
*qm2 = qm1 ? strchr(qm1 + 1, '"') : NULL;
|
|
|
|
|
|
|
|
if (!eq || !qm1 || !qm2) /* something is missing */
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* foo="bar" */
|
|
|
|
return eq > str && eq < qm1 && eq + 1 == qm1 && qm1 < qm2 && *(qm2 + 1) == '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SD-ID format:
|
|
|
|
* name@<private enterprise number>, e.g., "ourSDID@32473"
|
|
|
|
*/
|
|
|
|
static int valid_structured_data_id(const char *str)
|
|
|
|
{
|
|
|
|
char *at = strchr(str, '@');
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
/* standardized IDs without @<digits> */
|
|
|
|
if (!at && (strcmp(str, "timeQuality") == 0 ||
|
|
|
|
strcmp(str, "origin") == 0 ||
|
|
|
|
strcmp(str, "meta") == 0))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (!at || at == str || !*(at + 1))
|
|
|
|
return 0;
|
2017-01-28 05:39:52 -06:00
|
|
|
|
|
|
|
/* <digits> or <digits>.<digits>[...] */
|
|
|
|
for (p = at + 1; p && *p; p++) {
|
|
|
|
const char *end;
|
|
|
|
|
|
|
|
if (isdigit_strend(p, &end))
|
|
|
|
break; /* only digits in the string */
|
|
|
|
|
|
|
|
if (end == NULL || end == p ||
|
|
|
|
*end != '.' || *(end + 1) == '\0')
|
|
|
|
return 0;
|
|
|
|
p = end;
|
|
|
|
}
|
2015-10-01 07:48:15 -05:00
|
|
|
|
|
|
|
/* check for forbidden chars in the <name> */
|
|
|
|
for (p = str; p < at; p++) {
|
|
|
|
if (*p == '[' || *p == '=' || *p == '"' || *p == '@')
|
|
|
|
return 0;
|
2016-10-26 03:13:03 -05:00
|
|
|
if (isblank((unsigned char) *p) || iscntrl((unsigned char) *p))
|
2015-10-01 07:48:15 -05:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Some field mappings may be controversial, thus I give the reason
|
2015-03-10 11:26:14 -05:00
|
|
|
* why this specific mapping was used:
|
|
|
|
* APP-NAME <-- tag
|
|
|
|
* Some may argue that "logger" is a better fit, but we think
|
|
|
|
* this is better inline of what other implementations do. In
|
|
|
|
* rsyslog, for example, the TAG value is populated from APP-NAME.
|
|
|
|
* PROCID <-- pid
|
|
|
|
* This is a relatively straightforward interpretation from
|
|
|
|
* RFC5424, sect. 6.2.6.
|
2015-03-10 11:47:30 -05:00
|
|
|
* MSGID <-- msgid (from --msgid)
|
2015-03-10 11:26:14 -05:00
|
|
|
* One may argue that the string "logger" would be better suited
|
|
|
|
* here so that a receiver can identify the sender process.
|
|
|
|
* However, this does not sound like a good match to RFC5424,
|
2015-03-10 11:47:30 -05:00
|
|
|
* sect. 6.2.7.
|
2015-03-10 11:26:14 -05:00
|
|
|
* Note that appendix A.1 of RFC5424 does not provide clear guidance
|
|
|
|
* of how these fields should be used. This is the case because the
|
|
|
|
* IETF working group couldn't arrive at a clear agreement when we
|
|
|
|
* specified RFC5424. The rest of the field mappings should be
|
|
|
|
* pretty clear from RFC5424. -- Rainer Gerhards, 2015-03-10
|
|
|
|
*/
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
static void syslog_rfc5424_header(struct logger_ctl *const ctl)
|
2014-06-26 10:13:55 -05:00
|
|
|
{
|
2015-03-15 07:54:47 -05:00
|
|
|
char *time;
|
|
|
|
char *hostname;
|
2017-04-15 15:56:23 -05:00
|
|
|
char const *app_name = ctl->tag;
|
2015-03-15 07:54:47 -05:00
|
|
|
char *procid;
|
|
|
|
char *const msgid = xstrdup(ctl->msgid ? ctl->msgid : NILVALUE);
|
2015-10-01 07:48:15 -05:00
|
|
|
char *structured = NULL;
|
|
|
|
struct list_head *sd;
|
2015-03-15 07:54:47 -05:00
|
|
|
|
2014-06-26 10:13:55 -05:00
|
|
|
if (ctl->rfc5424_time) {
|
2015-03-10 11:26:14 -05:00
|
|
|
struct timeval tv;
|
2020-02-20 14:08:00 -06:00
|
|
|
struct tm tm;
|
2015-03-15 07:54:47 -05:00
|
|
|
|
2015-03-16 07:26:52 -05:00
|
|
|
logger_gettimeofday(&tv, NULL);
|
2020-02-20 14:08:00 -06:00
|
|
|
if (localtime_r(&tv.tv_sec, &tm) != NULL) {
|
2014-07-29 04:43:01 -05:00
|
|
|
char fmt[64];
|
2015-03-04 11:50:30 -06:00
|
|
|
const size_t i = strftime(fmt, sizeof(fmt),
|
2020-02-20 14:08:00 -06:00
|
|
|
"%Y-%m-%dT%H:%M:%S.%%06u%z ", &tm);
|
2015-03-04 11:50:30 -06:00
|
|
|
/* patch TZ info to comply with RFC3339 (we left SP at end) */
|
2015-03-15 07:54:47 -05:00
|
|
|
fmt[i - 1] = fmt[i - 2];
|
|
|
|
fmt[i - 2] = fmt[i - 3];
|
|
|
|
fmt[i - 3] = ':';
|
2015-03-10 11:26:14 -05:00
|
|
|
xasprintf(&time, fmt, tv.tv_usec);
|
2014-06-26 10:13:55 -05:00
|
|
|
} else
|
|
|
|
err(EXIT_FAILURE, _("localtime() failed"));
|
2015-03-10 11:26:14 -05:00
|
|
|
} else
|
2015-03-13 07:35:20 -05:00
|
|
|
time = xstrdup(NILVALUE);
|
2014-07-29 04:43:01 -05:00
|
|
|
|
2014-06-26 10:13:55 -05:00
|
|
|
if (ctl->rfc5424_host) {
|
2015-03-16 07:26:52 -05:00
|
|
|
if (!(hostname = logger_xgethostname()))
|
2015-03-15 07:54:48 -05:00
|
|
|
hostname = xstrdup(NILVALUE);
|
2014-06-26 10:13:55 -05:00
|
|
|
/* Arbitrary looking 'if (var < strlen()) checks originate from
|
|
|
|
* RFC 5424 - 6 Syslog Message Format definition. */
|
|
|
|
if (255 < strlen(hostname))
|
|
|
|
errx(EXIT_FAILURE, _("hostname '%s' is too long"),
|
|
|
|
hostname);
|
2015-03-10 11:26:14 -05:00
|
|
|
} else
|
2015-03-13 07:35:20 -05:00
|
|
|
hostname = xstrdup(NILVALUE);
|
2014-07-29 04:43:01 -05:00
|
|
|
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
if (48 < strlen(ctl->tag))
|
|
|
|
errx(EXIT_FAILURE, _("tag '%s' is too long"), ctl->tag);
|
2014-07-29 04:43:01 -05:00
|
|
|
|
2014-08-20 05:24:40 -05:00
|
|
|
if (ctl->pid)
|
2015-03-10 11:26:14 -05:00
|
|
|
xasprintf(&procid, "%d", ctl->pid);
|
|
|
|
else
|
2015-03-13 07:35:20 -05:00
|
|
|
procid = xstrdup(NILVALUE);
|
2015-03-10 11:26:14 -05:00
|
|
|
|
2015-10-01 07:48:15 -05:00
|
|
|
sd = get_reserved_structured_data(ctl);
|
|
|
|
|
2016-05-29 16:11:53 -05:00
|
|
|
/* time quality structured data (maybe overwritten by --sd-id timeQuality) */
|
2015-10-01 07:48:15 -05:00
|
|
|
if (ctl->rfc5424_tq && !has_structured_data_id(sd, "timeQuality")) {
|
|
|
|
|
|
|
|
add_structured_data_id(sd, "timeQuality");
|
|
|
|
add_structured_data_param(sd, "tzKnown=\"1\"");
|
|
|
|
|
2015-03-10 05:37:45 -05:00
|
|
|
#ifdef HAVE_NTP_GETTIME
|
|
|
|
struct ntptimeval ntptv;
|
2015-03-15 07:54:47 -05:00
|
|
|
|
2015-10-01 07:48:15 -05:00
|
|
|
if (ntp_gettime(&ntptv) == TIME_OK) {
|
|
|
|
add_structured_data_param(sd, "isSynced=\"1\"");
|
|
|
|
add_structured_data_paramf(sd, "syncAccuracy=\"%ld\"", ntptv.maxerror);
|
|
|
|
} else
|
2015-01-18 15:44:54 -06:00
|
|
|
#endif
|
2015-10-01 07:48:15 -05:00
|
|
|
add_structured_data_paramf(sd, "isSynced=\"0\"");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* convert all structured data to string */
|
|
|
|
structured = get_structured_data_string(ctl);
|
|
|
|
if (!structured)
|
|
|
|
structured = xstrdup(NILVALUE);
|
2014-07-29 04:43:01 -05:00
|
|
|
|
2015-03-10 11:26:14 -05:00
|
|
|
xasprintf(&ctl->hdr, "<%d>1 %s %s %s %s %s %s ",
|
|
|
|
ctl->pri,
|
|
|
|
time,
|
|
|
|
hostname,
|
|
|
|
app_name,
|
|
|
|
procid,
|
|
|
|
msgid,
|
2015-10-01 07:48:15 -05:00
|
|
|
structured);
|
2014-07-29 04:43:01 -05:00
|
|
|
|
2015-03-10 11:26:14 -05:00
|
|
|
free(time);
|
2014-07-29 04:43:01 -05:00
|
|
|
free(hostname);
|
2015-03-10 11:26:14 -05:00
|
|
|
/* app_name points to ctl->tag, do NOT free! */
|
|
|
|
free(procid);
|
|
|
|
free(msgid);
|
2015-10-01 07:48:15 -05:00
|
|
|
free(structured);
|
2014-06-26 10:13:55 -05:00
|
|
|
}
|
|
|
|
|
2016-07-03 07:20:30 -05:00
|
|
|
static void parse_rfc5424_flags(struct logger_ctl *ctl, char *s)
|
2014-06-26 10:13:55 -05:00
|
|
|
{
|
|
|
|
char *in, *tok;
|
|
|
|
|
2016-07-03 07:20:30 -05:00
|
|
|
in = s;
|
2014-06-26 10:13:55 -05:00
|
|
|
while ((tok = strtok(in, ","))) {
|
|
|
|
in = NULL;
|
|
|
|
if (!strcmp(tok, "notime")) {
|
|
|
|
ctl->rfc5424_time = 0;
|
|
|
|
ctl->rfc5424_tq = 0;
|
|
|
|
} else if (!strcmp(tok, "notq"))
|
|
|
|
ctl->rfc5424_tq = 0;
|
|
|
|
else if (!strcmp(tok, "nohost"))
|
|
|
|
ctl->rfc5424_host = 0;
|
|
|
|
else
|
|
|
|
warnx(_("ignoring unknown option argument: %s"), tok);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-03 07:20:30 -05:00
|
|
|
static int parse_unix_socket_errors_flags(char *s)
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
{
|
2016-07-03 07:20:30 -05:00
|
|
|
if (!strcmp(s, "off"))
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
return AF_UNIX_ERRORS_OFF;
|
2016-07-03 07:20:30 -05:00
|
|
|
if (!strcmp(s, "on"))
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
return AF_UNIX_ERRORS_ON;
|
2016-07-03 07:20:30 -05:00
|
|
|
if (!strcmp(s, "auto"))
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
return AF_UNIX_ERRORS_AUTO;
|
2016-07-03 07:20:30 -05:00
|
|
|
warnx(_("invalid argument: %s: using automatic errors"), s);
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
return AF_UNIX_ERRORS_AUTO;
|
|
|
|
}
|
|
|
|
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
static void syslog_local_header(struct logger_ctl *const ctl)
|
2014-06-26 15:48:25 -05:00
|
|
|
{
|
2015-03-05 08:20:50 -06:00
|
|
|
char pid[32];
|
2014-08-08 18:49:46 -05:00
|
|
|
|
2014-08-20 05:24:40 -05:00
|
|
|
if (ctl->pid)
|
|
|
|
snprintf(pid, sizeof(pid), "[%d]", ctl->pid);
|
2014-08-08 18:49:46 -05:00
|
|
|
else
|
|
|
|
pid[0] = '\0';
|
|
|
|
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
xasprintf(&ctl->hdr, "<%d>%s %s%s: ", ctl->pri, rfc3164_current_time(),
|
|
|
|
ctl->tag, pid);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void generate_syslog_header(struct logger_ctl *const ctl)
|
|
|
|
{
|
|
|
|
free(ctl->hdr);
|
2017-10-12 07:21:27 -05:00
|
|
|
ctl->hdr = NULL;
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
ctl->syslogfp(ctl);
|
2014-06-26 15:48:25 -05:00
|
|
|
}
|
|
|
|
|
2017-10-10 06:56:30 -05:00
|
|
|
/* just open, nothing else */
|
|
|
|
static void __logger_open(struct logger_ctl *ctl)
|
2014-07-26 07:10:25 -05:00
|
|
|
{
|
|
|
|
if (ctl->server) {
|
2015-10-06 02:16:33 -05:00
|
|
|
ctl->fd = inet_socket(ctl->server, ctl->port, &ctl->socket_type);
|
2015-04-06 16:50:46 -05:00
|
|
|
} else {
|
|
|
|
if (!ctl->unix_socket)
|
|
|
|
ctl->unix_socket = _PATH_DEVLOG;
|
2015-03-04 04:17:20 -06:00
|
|
|
|
2015-10-06 02:16:33 -05:00
|
|
|
ctl->fd = unix_socket(ctl, ctl->unix_socket, &ctl->socket_type);
|
2015-04-06 16:50:46 -05:00
|
|
|
}
|
2017-10-10 06:56:30 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* open and initialize relevant @ctl tuff */
|
|
|
|
static void logger_open(struct logger_ctl *ctl)
|
|
|
|
{
|
|
|
|
__logger_open(ctl);
|
|
|
|
|
|
|
|
if (!ctl->syslogfp)
|
|
|
|
ctl->syslogfp = ctl->server ? syslog_rfc5424_header :
|
|
|
|
syslog_local_header;
|
2015-03-15 07:54:47 -05:00
|
|
|
if (!ctl->tag)
|
|
|
|
ctl->tag = xgetlogin();
|
2017-10-10 06:56:30 -05:00
|
|
|
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
generate_syslog_header(ctl);
|
2014-07-26 07:10:25 -05:00
|
|
|
}
|
|
|
|
|
2017-10-10 06:56:30 -05:00
|
|
|
/* re-open; usually after failed connection */
|
|
|
|
static void logger_reopen(struct logger_ctl *ctl)
|
|
|
|
{
|
|
|
|
if (ctl->fd != -1)
|
|
|
|
close(ctl->fd);
|
|
|
|
ctl->fd = -1;
|
|
|
|
|
|
|
|
__logger_open(ctl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void logger_command_line(struct logger_ctl *ctl, char **argv)
|
2014-07-26 07:10:25 -05:00
|
|
|
{
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
/* note: we never re-generate the syslog header here, even if we
|
|
|
|
* generate multiple messages. If so, we think it is the right thing
|
|
|
|
* to do to report them with the same timestamp, as the user actually
|
|
|
|
* intended to send a single message.
|
|
|
|
*/
|
2015-03-06 08:50:34 -06:00
|
|
|
char *const buf = xmalloc(ctl->max_message_size + 1);
|
2014-07-26 07:10:25 -05:00
|
|
|
char *p = buf;
|
2015-03-06 08:50:34 -06:00
|
|
|
const char *endp = buf + ctl->max_message_size - 1;
|
2014-07-26 07:10:25 -05:00
|
|
|
size_t len;
|
|
|
|
|
|
|
|
while (*argv) {
|
|
|
|
len = strlen(*argv);
|
|
|
|
if (endp < p + len && p != buf) {
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
write_output(ctl, buf);
|
2014-07-26 07:10:25 -05:00
|
|
|
p = buf;
|
|
|
|
}
|
2015-03-06 08:50:34 -06:00
|
|
|
if (ctl->max_message_size < len) {
|
|
|
|
(*argv)[ctl->max_message_size] = '\0'; /* truncate */
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
write_output(ctl, *argv++);
|
2014-07-26 07:10:25 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (p != buf)
|
|
|
|
*p++ = ' ';
|
|
|
|
memmove(p, *argv++, len);
|
|
|
|
*(p += len) = '\0';
|
|
|
|
}
|
|
|
|
if (p != buf)
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
write_output(ctl, buf);
|
2015-04-07 02:58:19 -05:00
|
|
|
free(buf);
|
2014-07-26 07:10:25 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void logger_stdin(struct logger_ctl *ctl)
|
|
|
|
{
|
2016-10-20 11:08:57 -05:00
|
|
|
/* note: we re-generate the syslog header for each log message to
|
2016-02-24 03:40:08 -06:00
|
|
|
* update header timestamps and to reflect possible priority changes.
|
|
|
|
* The initial header is generated by logger_open().
|
|
|
|
*/
|
|
|
|
int has_header = 1;
|
2014-07-26 07:10:25 -05:00
|
|
|
int default_priority = ctl->pri;
|
2015-03-07 04:49:00 -06:00
|
|
|
int last_pri = default_priority;
|
|
|
|
size_t max_usrmsg_size = ctl->max_message_size - strlen(ctl->hdr);
|
|
|
|
char *const buf = xmalloc(max_usrmsg_size + 2 + 2);
|
|
|
|
int pri;
|
|
|
|
int c;
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
c = getchar();
|
|
|
|
while (c != EOF) {
|
|
|
|
i = 0;
|
2016-07-04 16:14:41 -05:00
|
|
|
if (ctl->prio_prefix && c == '<') {
|
|
|
|
pri = 0;
|
|
|
|
buf[i++] = c;
|
|
|
|
while (isdigit(c = getchar()) && pri <= 191) {
|
|
|
|
buf[i++] = c;
|
|
|
|
pri = pri * 10 + c - '0';
|
|
|
|
}
|
|
|
|
if (c != EOF && c != '\n')
|
2015-03-07 04:49:00 -06:00
|
|
|
buf[i++] = c;
|
2016-07-04 16:14:41 -05:00
|
|
|
if (c == '>' && 0 <= pri && pri <= 191) {
|
|
|
|
/* valid RFC PRI values */
|
|
|
|
i = 0;
|
|
|
|
if (pri < 8) /* kern facility is forbidden */
|
|
|
|
pri |= 8;
|
|
|
|
ctl->pri = pri;
|
|
|
|
} else
|
|
|
|
ctl->pri = default_priority;
|
|
|
|
|
|
|
|
if (ctl->pri != last_pri) {
|
|
|
|
has_header = 0;
|
|
|
|
max_usrmsg_size =
|
|
|
|
ctl->max_message_size - strlen(ctl->hdr);
|
|
|
|
last_pri = ctl->pri;
|
2015-03-07 04:49:00 -06:00
|
|
|
}
|
2016-07-04 16:14:41 -05:00
|
|
|
if (c != EOF && c != '\n')
|
|
|
|
c = getchar();
|
2015-03-07 04:49:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
while (c != EOF && c != '\n' && i < max_usrmsg_size) {
|
|
|
|
buf[i++] = c;
|
|
|
|
c = getchar();
|
|
|
|
}
|
|
|
|
buf[i] = '\0';
|
|
|
|
|
2016-02-24 03:40:08 -06:00
|
|
|
if (i > 0 || !ctl->skip_empty_lines) {
|
|
|
|
if (!has_header)
|
|
|
|
generate_syslog_header(ctl);
|
2015-03-07 05:14:21 -06:00
|
|
|
write_output(ctl, buf);
|
2016-02-24 03:40:08 -06:00
|
|
|
has_header = 0;
|
|
|
|
}
|
2015-03-07 04:49:00 -06:00
|
|
|
|
2015-03-15 07:54:47 -05:00
|
|
|
if (c == '\n') /* discard line terminator */
|
2015-03-07 04:49:00 -06:00
|
|
|
c = getchar();
|
2014-07-26 07:10:25 -05:00
|
|
|
}
|
2017-09-15 05:54:54 -05:00
|
|
|
|
|
|
|
free(buf);
|
2014-07-26 07:10:25 -05:00
|
|
|
}
|
|
|
|
|
2014-08-09 02:57:51 -05:00
|
|
|
static void logger_close(const struct logger_ctl *ctl)
|
2014-07-26 07:10:25 -05:00
|
|
|
{
|
2015-07-19 15:19:12 -05:00
|
|
|
if (ctl->fd != -1 && close(ctl->fd) != 0)
|
2014-08-08 18:49:46 -05:00
|
|
|
err(EXIT_FAILURE, _("close failed"));
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
free(ctl->hdr);
|
2014-07-26 07:10:25 -05:00
|
|
|
}
|
|
|
|
|
2017-06-20 13:20:29 -05:00
|
|
|
static void __attribute__((__noreturn__)) usage(void)
|
2011-02-24 13:16:40 -06:00
|
|
|
{
|
2017-06-20 13:20:29 -05:00
|
|
|
FILE *out = stdout;
|
2013-05-29 03:54:51 -05:00
|
|
|
fputs(USAGE_HEADER, out);
|
2013-05-29 14:52:56 -05:00
|
|
|
fprintf(out, _(" %s [options] [<message>]\n"), program_invocation_short_name);
|
2011-08-16 05:23:15 -05:00
|
|
|
|
2014-12-22 15:57:17 -06:00
|
|
|
fputs(USAGE_SEPARATOR, out);
|
|
|
|
fputs(_("Enter messages into the system log.\n"), out);
|
|
|
|
|
2013-05-29 03:54:51 -05:00
|
|
|
fputs(USAGE_OPTIONS, out);
|
2015-02-20 13:42:34 -06:00
|
|
|
fputs(_(" -i log the logger command's PID\n"), out);
|
|
|
|
fputs(_(" --id[=<id>] log the given <id>, or otherwise the PID\n"), out);
|
2015-01-26 04:26:40 -06:00
|
|
|
fputs(_(" -f, --file <file> log the contents of this file\n"), out);
|
2015-03-07 05:14:21 -06:00
|
|
|
fputs(_(" -e, --skip-empty do not log empty lines when processing files\n"), out);
|
2015-03-16 06:38:46 -05:00
|
|
|
fputs(_(" --no-act do everything except the write the log\n"), out);
|
2015-01-26 04:26:40 -06:00
|
|
|
fputs(_(" -p, --priority <prio> mark given message with this priority\n"), out);
|
2015-07-15 13:01:48 -05:00
|
|
|
fputs(_(" --octet-count use rfc6587 octet counting\n"), out);
|
2015-01-26 04:26:40 -06:00
|
|
|
fputs(_(" --prio-prefix look for a prefix on every line read from stdin\n"), out);
|
|
|
|
fputs(_(" -s, --stderr output message to standard error as well\n"), out);
|
2015-03-06 08:50:34 -06:00
|
|
|
fputs(_(" -S, --size <size> maximum size for a single message\n"), out);
|
2015-01-26 04:26:40 -06:00
|
|
|
fputs(_(" -t, --tag <tag> mark every line with this tag\n"), out);
|
|
|
|
fputs(_(" -n, --server <name> write to this remote syslog server\n"), out);
|
2016-06-21 06:32:14 -05:00
|
|
|
fputs(_(" -P, --port <port> use this port for UDP or TCP connection\n"), out);
|
2015-01-26 04:26:40 -06:00
|
|
|
fputs(_(" -T, --tcp use TCP only\n"), out);
|
|
|
|
fputs(_(" -d, --udp use UDP only\n"), out);
|
|
|
|
fputs(_(" --rfc3164 use the obsolete BSD syslog protocol\n"), out);
|
2015-03-11 04:51:13 -05:00
|
|
|
fputs(_(" --rfc5424[=<snip>] use the syslog protocol (the default for remote);\n"
|
2015-01-26 04:26:40 -06:00
|
|
|
" <snip> can be notime, or notq, and/or nohost\n"), out);
|
2015-10-01 07:48:15 -05:00
|
|
|
fputs(_(" --sd-id <id> rfc5424 structured data ID\n"), out);
|
|
|
|
fputs(_(" --sd-param <data> rfc5424 structured data name=value\n"), out);
|
2015-03-15 07:54:53 -05:00
|
|
|
fputs(_(" --msgid <msgid> set rfc5424 message id field\n"), out);
|
2015-01-26 04:26:40 -06:00
|
|
|
fputs(_(" -u, --socket <socket> write to this Unix socket\n"), out);
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
fputs(_(" --socket-errors[=<on|off|auto>]\n"
|
|
|
|
" print connection errors when using Unix sockets\n"), out);
|
2014-04-09 05:23:30 -05:00
|
|
|
#ifdef HAVE_LIBSYSTEMD
|
2014-02-21 13:25:30 -06:00
|
|
|
fputs(_(" --journald[=<file>] write journald entry\n"), out);
|
|
|
|
#endif
|
2013-05-29 03:54:51 -05:00
|
|
|
|
|
|
|
fputs(USAGE_SEPARATOR, out);
|
2017-06-29 08:52:16 -05:00
|
|
|
printf(USAGE_HELP_OPTIONS(26));
|
|
|
|
printf(USAGE_MAN_TAIL("logger(1)"));
|
2011-02-24 13:16:40 -06:00
|
|
|
|
2017-06-20 13:20:29 -05:00
|
|
|
exit(EXIT_SUCCESS);
|
2011-02-24 13:16:40 -06:00
|
|
|
}
|
|
|
|
|
2006-12-06 17:25:32 -06:00
|
|
|
/*
|
|
|
|
* logger -- read and log utility
|
|
|
|
*
|
|
|
|
* Reads from an input and arranges to write the result on the system
|
|
|
|
* log.
|
|
|
|
*/
|
2013-05-29 03:56:05 -05:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2014-06-26 15:48:25 -05:00
|
|
|
struct logger_ctl ctl = {
|
|
|
|
.fd = -1,
|
2014-08-20 05:24:40 -05:00
|
|
|
.pid = 0,
|
2015-03-05 09:44:03 -06:00
|
|
|
.pri = LOG_USER | LOG_NOTICE,
|
2014-07-26 07:10:25 -05:00
|
|
|
.prio_prefix = 0,
|
2014-06-26 15:48:25 -05:00
|
|
|
.tag = NULL,
|
2014-07-26 07:10:25 -05:00
|
|
|
.unix_socket = NULL,
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
.unix_socket_errors = 0,
|
2014-07-26 07:10:25 -05:00
|
|
|
.server = NULL,
|
|
|
|
.port = NULL,
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
.hdr = NULL,
|
2015-03-10 11:47:30 -05:00
|
|
|
.msgid = NULL,
|
2014-06-26 10:13:55 -05:00
|
|
|
.socket_type = ALL_TYPES,
|
2015-03-06 08:50:34 -06:00
|
|
|
.max_message_size = 1024,
|
2014-06-26 10:13:55 -05:00
|
|
|
.rfc5424_time = 1,
|
|
|
|
.rfc5424_tq = 1,
|
|
|
|
.rfc5424_host = 1,
|
2015-03-07 05:14:21 -06:00
|
|
|
.skip_empty_lines = 0
|
2014-06-26 15:48:25 -05:00
|
|
|
};
|
2014-07-26 07:10:25 -05:00
|
|
|
int ch;
|
2014-07-27 12:01:09 -05:00
|
|
|
int stdout_reopened = 0;
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
int unix_socket_errors_mode = AF_UNIX_ERRORS_AUTO;
|
2014-04-09 05:23:30 -05:00
|
|
|
#ifdef HAVE_LIBSYSTEMD
|
2014-02-21 13:25:30 -06:00
|
|
|
FILE *jfd = NULL;
|
|
|
|
#endif
|
2011-02-24 13:16:40 -06:00
|
|
|
static const struct option longopts[] = {
|
2015-03-15 07:54:47 -05:00
|
|
|
{ "id", optional_argument, 0, OPT_ID },
|
|
|
|
{ "stderr", no_argument, 0, 's' },
|
|
|
|
{ "file", required_argument, 0, 'f' },
|
2015-03-16 06:38:46 -05:00
|
|
|
{ "no-act", no_argument, 0, OPT_NOACT, },
|
2015-03-15 07:54:47 -05:00
|
|
|
{ "priority", required_argument, 0, 'p' },
|
|
|
|
{ "tag", required_argument, 0, 't' },
|
|
|
|
{ "socket", required_argument, 0, 'u' },
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
{ "socket-errors", required_argument, 0, OPT_SOCKET_ERRORS },
|
2015-03-15 07:54:47 -05:00
|
|
|
{ "udp", no_argument, 0, 'd' },
|
|
|
|
{ "tcp", no_argument, 0, 'T' },
|
|
|
|
{ "server", required_argument, 0, 'n' },
|
|
|
|
{ "port", required_argument, 0, 'P' },
|
|
|
|
{ "version", no_argument, 0, 'V' },
|
|
|
|
{ "help", no_argument, 0, 'h' },
|
2015-07-15 13:01:48 -05:00
|
|
|
{ "octet-count", no_argument, 0, OPT_OCTET_COUNT },
|
2015-03-15 07:54:47 -05:00
|
|
|
{ "prio-prefix", no_argument, 0, OPT_PRIO_PREFIX },
|
|
|
|
{ "rfc3164", no_argument, 0, OPT_RFC3164 },
|
|
|
|
{ "rfc5424", optional_argument, 0, OPT_RFC5424 },
|
|
|
|
{ "size", required_argument, 0, 'S' },
|
|
|
|
{ "msgid", required_argument, 0, OPT_MSGID },
|
|
|
|
{ "skip-empty", no_argument, 0, 'e' },
|
2015-10-01 07:48:15 -05:00
|
|
|
{ "sd-id", required_argument, 0, OPT_STRUCTURED_DATA_ID },
|
|
|
|
{ "sd-param", required_argument, 0, OPT_STRUCTURED_DATA_PARAM },
|
2014-04-09 05:23:30 -05:00
|
|
|
#ifdef HAVE_LIBSYSTEMD
|
2015-03-15 07:54:47 -05:00
|
|
|
{ "journald", optional_argument, 0, OPT_JOURNALD },
|
2014-02-21 13:25:30 -06:00
|
|
|
#endif
|
2015-03-15 07:54:47 -05:00
|
|
|
{ NULL, 0, 0, 0 }
|
2011-02-24 13:16:40 -06:00
|
|
|
};
|
2006-12-06 17:25:39 -06:00
|
|
|
|
|
|
|
setlocale(LC_ALL, "");
|
|
|
|
bindtextdomain(PACKAGE, LOCALEDIR);
|
|
|
|
textdomain(PACKAGE);
|
2019-04-16 08:14:13 -05:00
|
|
|
close_stdout_atexit();
|
2006-12-06 17:25:32 -06:00
|
|
|
|
2015-10-01 07:48:15 -05:00
|
|
|
INIT_LIST_HEAD(&ctl.user_sds);
|
|
|
|
INIT_LIST_HEAD(&ctl.reserved_sds);
|
|
|
|
|
2015-03-07 05:14:21 -06:00
|
|
|
while ((ch = getopt_long(argc, argv, "ef:ip:S:st:u:dTn:P:Vh",
|
2011-02-24 13:16:41 -06:00
|
|
|
longopts, NULL)) != -1) {
|
2013-05-22 06:12:08 -05:00
|
|
|
switch (ch) {
|
2006-12-06 17:25:32 -06:00
|
|
|
case 'f': /* file to log */
|
2011-02-24 13:16:41 -06:00
|
|
|
if (freopen(optarg, "r", stdin) == NULL)
|
2014-07-27 12:01:09 -05:00
|
|
|
err(EXIT_FAILURE, _("file %s"), optarg);
|
|
|
|
stdout_reopened = 1;
|
2006-12-06 17:25:32 -06:00
|
|
|
break;
|
2015-03-07 05:14:21 -06:00
|
|
|
case 'e':
|
|
|
|
ctl.skip_empty_lines = 1;
|
|
|
|
break;
|
2006-12-06 17:25:32 -06:00
|
|
|
case 'i': /* log process id also */
|
2015-03-16 07:26:52 -05:00
|
|
|
ctl.pid = logger_getpid();
|
2015-02-20 13:42:34 -06:00
|
|
|
break;
|
|
|
|
case OPT_ID:
|
2014-06-28 10:08:28 -05:00
|
|
|
if (optarg) {
|
2014-07-29 04:49:00 -05:00
|
|
|
const char *p = optarg;
|
|
|
|
|
|
|
|
if (*p == '=')
|
|
|
|
p++;
|
2014-08-20 05:24:40 -05:00
|
|
|
ctl.pid = strtoul_or_err(optarg, _("failed to parse id"));
|
|
|
|
} else
|
2015-03-16 07:26:52 -05:00
|
|
|
ctl.pid = logger_getpid();
|
2006-12-06 17:25:32 -06:00
|
|
|
break;
|
|
|
|
case 'p': /* priority */
|
2014-06-26 15:48:25 -05:00
|
|
|
ctl.pri = pencode(optarg);
|
2006-12-06 17:25:32 -06:00
|
|
|
break;
|
|
|
|
case 's': /* log to standard error */
|
2014-08-08 19:04:50 -05:00
|
|
|
ctl.stderr_printout = 1;
|
2006-12-06 17:25:32 -06:00
|
|
|
break;
|
|
|
|
case 't': /* tag */
|
2014-06-26 15:48:25 -05:00
|
|
|
ctl.tag = optarg;
|
2006-12-06 17:25:32 -06:00
|
|
|
break;
|
2006-12-06 17:25:39 -06:00
|
|
|
case 'u': /* unix socket */
|
2014-07-26 07:10:25 -05:00
|
|
|
ctl.unix_socket = optarg;
|
2006-12-06 17:25:39 -06:00
|
|
|
break;
|
2015-03-06 08:50:34 -06:00
|
|
|
case 'S': /* max message size */
|
|
|
|
ctl.max_message_size = strtosize_or_err(optarg,
|
|
|
|
_("failed to parse message size"));
|
|
|
|
break;
|
2006-12-06 17:25:44 -06:00
|
|
|
case 'd':
|
2014-07-26 07:10:25 -05:00
|
|
|
ctl.socket_type = TYPE_UDP;
|
2013-04-05 15:17:24 -05:00
|
|
|
break;
|
|
|
|
case 'T':
|
2014-07-26 07:10:25 -05:00
|
|
|
ctl.socket_type = TYPE_TCP;
|
2006-12-06 17:25:44 -06:00
|
|
|
break;
|
2013-04-05 15:17:24 -05:00
|
|
|
case 'n':
|
2014-07-26 07:10:25 -05:00
|
|
|
ctl.server = optarg;
|
2011-01-28 07:15:20 -06:00
|
|
|
break;
|
2013-04-05 15:17:24 -05:00
|
|
|
case 'P':
|
2014-07-26 07:10:25 -05:00
|
|
|
ctl.port = optarg;
|
2011-01-28 07:15:20 -06:00
|
|
|
break;
|
2015-07-15 13:01:48 -05:00
|
|
|
case OPT_OCTET_COUNT:
|
|
|
|
ctl.octet_count = 1;
|
|
|
|
break;
|
2013-05-22 06:12:08 -05:00
|
|
|
case OPT_PRIO_PREFIX:
|
2014-07-26 07:10:25 -05:00
|
|
|
ctl.prio_prefix = 1;
|
2013-05-22 06:12:08 -05:00
|
|
|
break;
|
2014-06-26 10:13:55 -05:00
|
|
|
case OPT_RFC3164:
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
ctl.syslogfp = syslog_rfc3164_header;
|
2014-06-26 10:13:55 -05:00
|
|
|
break;
|
|
|
|
case OPT_RFC5424:
|
logger: refactor message generation
Previously, the message format was generated in one big step. Now
this is refactored to generate the header independently. This not
only provides a better isolation of functionality, but enables
to calculate the size of the header *before* generating the user
part of the message. That in turn is needed in order to precisely
enforce the message size limit. This is especially important while
processing files, as here parts of the message may be lost if the
receiver truncates the message. The file reader itself tries to
guard against this by reading only the permitted number of bytes,
but without knowing the header size, it would mis-guess here.
Note that when --prio-prefix is given, we still do not know exactly
the header length, because the PRI value is between 1 and 3 bytes.
Unfortunately, we do not know the actual size before reading. With
the current (simple) approach, we need to read the full line before
getting the PRI, so this is a hen-egg problem. To solve this, a
more complex reader would be required. It is questionable if this
is necessary for a tool like logger. So currently, we still have a
2-byte window of uncertainty if --prio-prefix is given.
[kzak@redhat.com: - fix compiler warnings [-Wunused-but-set-variable]]
Signed-off-by: Karel Zak <kzak@redhat.com>
2015-03-06 11:52:26 -06:00
|
|
|
ctl.syslogfp = syslog_rfc5424_header;
|
2014-06-26 10:13:55 -05:00
|
|
|
if (optarg)
|
|
|
|
parse_rfc5424_flags(&ctl, optarg);
|
|
|
|
break;
|
2015-03-10 11:47:30 -05:00
|
|
|
case OPT_MSGID:
|
2015-03-15 07:54:47 -05:00
|
|
|
if (strchr(optarg, ' '))
|
2015-03-15 07:54:53 -05:00
|
|
|
errx(EXIT_FAILURE, _("--msgid cannot contain space"));
|
2015-03-10 11:47:30 -05:00
|
|
|
ctl.msgid = optarg;
|
|
|
|
break;
|
2014-04-09 05:23:30 -05:00
|
|
|
#ifdef HAVE_LIBSYSTEMD
|
2014-02-21 13:25:30 -06:00
|
|
|
case OPT_JOURNALD:
|
|
|
|
if (optarg) {
|
|
|
|
jfd = fopen(optarg, "r");
|
|
|
|
if (!jfd)
|
|
|
|
err(EXIT_FAILURE, _("cannot open %s"),
|
|
|
|
optarg);
|
|
|
|
} else
|
|
|
|
jfd = stdin;
|
|
|
|
break;
|
|
|
|
#endif
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
case OPT_SOCKET_ERRORS:
|
|
|
|
unix_socket_errors_mode = parse_unix_socket_errors_flags(optarg);
|
|
|
|
break;
|
2015-03-16 06:38:46 -05:00
|
|
|
case OPT_NOACT:
|
|
|
|
ctl.noact = 1;
|
|
|
|
break;
|
2015-10-01 07:48:15 -05:00
|
|
|
case OPT_STRUCTURED_DATA_ID:
|
|
|
|
if (!valid_structured_data_id(optarg))
|
|
|
|
errx(EXIT_FAILURE, _("invalid structured data ID: '%s'"), optarg);
|
|
|
|
add_structured_data_id(get_user_structured_data(&ctl), optarg);
|
|
|
|
break;
|
|
|
|
case OPT_STRUCTURED_DATA_PARAM:
|
|
|
|
if (!valid_structured_data_param(optarg))
|
|
|
|
errx(EXIT_FAILURE, _("invalid structured data parameter: '%s'"), optarg);
|
|
|
|
add_structured_data_param(get_user_structured_data(&ctl), optarg);
|
|
|
|
break;
|
2019-04-16 08:14:13 -05:00
|
|
|
|
|
|
|
case 'V':
|
|
|
|
print_version(EXIT_SUCCESS);
|
|
|
|
case 'h':
|
|
|
|
usage();
|
2006-12-06 17:25:32 -06:00
|
|
|
default:
|
2016-12-19 06:13:34 -06:00
|
|
|
errtryhelp(EXIT_FAILURE);
|
2006-12-06 17:25:32 -06:00
|
|
|
}
|
2011-02-24 13:16:41 -06:00
|
|
|
}
|
2006-12-06 17:25:32 -06:00
|
|
|
argc -= optind;
|
|
|
|
argv += optind;
|
2014-07-27 12:01:09 -05:00
|
|
|
if (stdout_reopened && argc)
|
|
|
|
warnx(_("--file <file> and <message> are mutually exclusive, message is ignored"));
|
2014-04-09 05:23:30 -05:00
|
|
|
#ifdef HAVE_LIBSYSTEMD
|
2014-02-21 13:25:30 -06:00
|
|
|
if (jfd) {
|
2015-03-16 06:38:46 -05:00
|
|
|
int ret = journald_entry(&ctl, jfd);
|
2014-02-21 13:25:30 -06:00
|
|
|
if (stdin != jfd)
|
|
|
|
fclose(jfd);
|
2014-05-11 14:26:41 -05:00
|
|
|
if (ret)
|
2015-01-18 14:17:09 -06:00
|
|
|
errx(EXIT_FAILURE, _("journald entry could not be written"));
|
2014-05-11 14:26:41 -05:00
|
|
|
return EXIT_SUCCESS;
|
2014-02-21 13:25:30 -06:00
|
|
|
}
|
|
|
|
#endif
|
2015-10-01 07:48:15 -05:00
|
|
|
|
2019-01-14 16:40:34 -06:00
|
|
|
/* user overwrites built-in SD-ELEMENT */
|
2015-10-01 07:48:15 -05:00
|
|
|
if (has_structured_data_id(get_user_structured_data(&ctl), "timeQuality"))
|
|
|
|
ctl.rfc5424_tq = 0;
|
|
|
|
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
switch (unix_socket_errors_mode) {
|
|
|
|
case AF_UNIX_ERRORS_OFF:
|
|
|
|
ctl.unix_socket_errors = 0;
|
|
|
|
break;
|
|
|
|
case AF_UNIX_ERRORS_ON:
|
|
|
|
ctl.unix_socket_errors = 1;
|
|
|
|
break;
|
|
|
|
case AF_UNIX_ERRORS_AUTO:
|
2015-03-26 08:20:29 -05:00
|
|
|
ctl.unix_socket_errors = ctl.noact || ctl.stderr_printout;
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
#ifdef HAVE_LIBSYSTEMD
|
2015-03-26 08:20:29 -05:00
|
|
|
ctl.unix_socket_errors |= !!sd_booted();
|
logger: add --socket-errors compatibility option
Hello,
Depending viewpoint this change is either regression fix, or
re-regression in context of none-systemd init. I ack the change is sent
very late to be part of v2.26, but then again the excess noise was found
only because of -rc1 was tested in sysvinit environment. IMHO it would
contradict purpose of having rc's if faults will not lead to fixes.
I also want to point out the sysvinit scripts are broken, not the
logger(1), but getting them corrected is practically impossible.
Assuming sysvinit script are further developed by various teams and
distributions who maintain them they should use --socket-error=on in
future, and write scripts that pass without noise. Meanwhile trying to
be clever when to silence errors seems like a reasonable thing to do.
--->8----
From: Sami Kerola <kerolasa@iki.fi>
Date: Sat, 14 Feb 2015 19:05:55 +0000
Subject: [PATCH] logger: add --socket-errors compatibility option
Now when logger(1) has stopped using openlog() for Unix sockets, in
commit mentioned in reference, the lack of /dev/log detected will report
error accordingly. According to Gabriele Balducci this makes sysvinit
style boot scripts to print a lot of errors. So make the logger to
detect whether it should be in compatibility mode, and not report errors
if logging device is missing. That imitates behavior of glibc openlog().
To allow full control to users the /dev/log error messages can be forced
to on or off. The automatic error messaging is explained in manual page.
Reference: 1d57503378bdcd838365d625f6d2d0a09da9c29d
Reported-by: Gabriele Balducci <balducci@units.it>
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
2015-02-15 03:50:23 -06:00
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
2014-07-26 07:10:25 -05:00
|
|
|
logger_open(&ctl);
|
|
|
|
if (0 < argc)
|
|
|
|
logger_command_line(&ctl, argv);
|
2006-12-06 17:25:39 -06:00
|
|
|
else
|
2014-07-26 07:10:25 -05:00
|
|
|
/* Note. --file <arg> reopens stdin making the below
|
|
|
|
* function to be used for file inputs. */
|
|
|
|
logger_stdin(&ctl);
|
|
|
|
logger_close(&ctl);
|
2011-02-24 13:16:41 -06:00
|
|
|
return EXIT_SUCCESS;
|
2006-12-06 17:25:32 -06:00
|
|
|
}
|