element:
.Bd -literal -offset indent
96M
.Ed
.Ss "The Gettext Modifier ({g:})"
The gettext modifier is used to translate individual fields using the
gettext domain (typically set using the "{G:}" role) and current
language settings.
Once libxo renders the field value, it is passed
to
.Xr gettext 3 ,
where it is used as a key to find the native language
translation.
.Pp
In the following example, the strings "State" and "full" are passed
to
.Fn gettext
to find locale\-based translated strings.
.Bd -literal -offset indent
xo_emit("{Lgwc:State}{g:state}\\n", "full");
.Ed
.Ss "The Key Modifier ({k:})"
The key modifier is used to indicate that a particular field helps
uniquely identify an instance of list data.
.Bd -literal -offset indent
EXAMPLE:
xo_open_list("user");
for (i = 0; i < num_users; i++) {
xo_open_instance("user");
xo_emit("User {k:name} has {:count} tickets\\n",
user[i].u_name, user[i].u_tickets);
xo_close_instance("user");
}
xo_close_list("user");
.Ed
.Pp
Currently the key modifier is only used when generating XPath values
for the HTML output style when
.Dv XOF_XPATH
is set, but other uses are likely in the near future.
.Ss "The Leaf\-List Modifier ({l:})"
The leaf\-list modifier is used to distinguish lists where each
instance consists of only a single value. In XML, these are
rendered as single elements, where JSON renders them as arrays.
.Bd -literal -offset indent
EXAMPLE:
xo_open_list("user");
for (i = 0; i < num_users; i++) {
xo_emit("Member {l:name}\\n", user[i].u_name);
}
xo_close_list("user");
XML:
phil
pallavi
JSON:
"user": [ "phil", "pallavi" ]
.Ed
.Ss "The No\-Quotes Modifier ({n:})"
The no\-quotes modifier (and its twin, the \(aqquotes\(aq modifier) affect
the quoting of values in the JSON output style.
JSON uses quotes for
string values, but no quotes for numeric, boolean, and null data.
.Xr xo_emit 3
applies a simple heuristic to determine whether quotes are
needed, but often this needs to be controlled by the caller.
.Bd -literal -offset indent
EXAMPLE:
const char *bool = is_true ? "true" : "false";
xo_emit("{n:fancy/%s}", bool);
JSON:
"fancy": true
.Ed
.Ss "The Plural Modifier ({p:})"
The plural modifier selects the appropriate plural form of an
expression based on the most recent number emitted and the current
language settings.
The contents of the field should be the singular
and plural English values, separated by a comma:
.Bd -literal -offset indent
xo_emit("{:bytes} {Ngp:byte,bytes}\\n", bytes);
.Ed
.Pp
The plural modifier is meant to work with the gettext modifier ({g:})
but can work independently.
.Pp
When used without the gettext modifier or when the message does not
appear in the message catalog, the first token is chosen when the last
numeric value is equal to 1; otherwise the second value is used,
mimicking the simple pluralization rules of English.
.Pp
When used with the gettext modifier, the
.Xr ngettext 3
function is
called to handle the heavy lifting, using the message catalog to
convert the singular and plural forms into the native language.
.Ss "The Quotes Modifier ({q:})"
The quotes modifier (and its twin, the \(aqno-quotes\(aq modifier) affect
the quoting of values in the JSON output style.
JSON uses quotes for
string values, but no quotes for numeric, boolean, and null data.
.Xr xo_emit 3
applies a simple heuristic to determine whether quotes are
needed, but often this needs to be controlled by the caller.
.Bd -literal -offset indent
EXAMPLE:
xo_emit("{q:time/%d}", 2014);
JSON:
"year": "2014"
.Ed
.Ss "The White Space Modifier ({w:})"
The white space modifier appends a single space to the data value:
.Bd -literal -offset indent
EXAMPLE:
xo_emit("{Lw:Name}{:name}\\n", "phil");
TEXT:
Name phil
.Ed
.Pp
The white space modifier is only used for the TEXT and HTML output
styles.
It is commonly combined with the colon modifier (\(aq{c:}\(aq).
It is purely a convenience feature.
.Pp
Note that the sense of the \(aqw\(aq modifier is reversed for the units role
({Uw:}); a blank is added before the contents, rather than after it.
.Ss "Field Formatting"
The field format is similar to the format string for
.Xr printf 3 .
Its use varies based on the role of the field, but generally is used to
format the field\(aqs contents.
.Pp
If the format string is not provided for a value field, it defaults
to "%s".
.Pp
Note a field definition can contain zero or more printf\-style
.Dq directives ,
which are sequences that start with a \(aq%\(aq and end with
one of following characters: "diouxXDOUeEfFgGaAcCsSp".
Each directive
is matched by one of more arguments to the
.Xr xo_emit 3
function.
.Pp
The format string has the form:
.Bd -literal -offset indent
\(aq%\(aq format\-modifier * format\-character
.Ed
.Pp
The format\- modifier can be:
.Bl -bullet
.It
a \(aq#\(aq character, indicating the output value should be prefixed with
"0x", typically to indicate a base 16 (hex) value.
.It
a minus sign (\(aq\-\(aq), indicating the output value should be padded on
the right instead of the left.
.It
a leading zero (\(aq0\(aq) indicating the output value should be padded on the
left with zeroes instead of spaces (\(aq \(aq).
.It
one or more digits (\(aq0\(aq \- \(aq9\(aq) indicating the minimum width of the
argument.
If the width in columns of the output value is less than
the minimum width, the value will be padded to reach the minimum.
.It
a period followed by one or more digits indicating the maximum
number of bytes which will be examined for a string argument, or the maximum
width for a non\-string argument.
When handling ASCII strings this
functions as the field width but for multi\-byte characters, a single
character may be composed of multiple bytes.
.Xr xo_emit 3
will never dereference memory beyond the given number of bytes.
.It
a second period followed by one or more digits indicating the maximum
width for a string argument.
This modifier cannot be given for non\-string arguments.
.It
one or more \(aqh\(aq characters, indicating shorter input data.
.It
one or more \(aql\(aq characters, indicating longer input data.
.It
a \(aqz\(aq character, indicating a \(aqsize_t\(aq argument.
.It
a \(aqt\(aq character, indicating a \(aqptrdiff_t\(aq argument.
.It
a \(aq \(aq character, indicating a space should be emitted before
positive numbers.
.It
a \(aq+\(aq character, indicating sign should emitted before any number.
.El
.Pp
Note that \(aqq\(aq, \(aqD\(aq, \(aqO\(aq, and \(aqU\(aq are considered deprecated and will be
removed eventually.
.Pp
The format character is described in the following table:
.Bl -column C "Argument Type12"
.It Sy "C" "Argument Type " "Format"
.It d "int " "base 10 (decimal)"
.It i "int " "base 10 (decimal)"
.It o "int " "base 8 (octal)"
.It u "unsigned " "base 10 (decimal)"
.It x "unsigned " "base 16 (hex)"
.It X "unsigned long " "base 16 (hex)"
.It D "long " "base 10 (decimal)"
.It O "unsigned long " "base 8 (octal)"
.It U "unsigned long " "base 10 (decimal)"
.It e "double " "[\-]d.ddde+\-dd"
.It E "double " "[\-]d.dddE+\-dd"
.It f "double " "[\-]ddd.ddd"
.It F "double " "[\-]ddd.ddd"
.It g "double " "as \(aqe\(aq or \(aqf\(aq"
.It G "double " "as \(aqE\(aq or \(aqF\(aq"
.It a "double " "[\-]0xh.hhhp[+\-]d"
.It A "double " "[\-]0Xh.hhhp[+\-]d"
.It c "unsigned char " "a character"
.It C "wint_t " "a character"
.It s "char * " "a UTF\-8 string"
.It S "wchar_t * " "a unicode/WCS string"
.It p "void * " "\(aq%#lx\(aq"
.El
.Pp
The \(aqh\(aq and \(aql\(aq modifiers affect the size and treatment of the
argument:
.Bl -column "Mod" "d, i " "o, u, x, X "
.It Sy "Mod" "d, i " "o, u, x, X"
.It "hh " "signed char " "unsigned char"
.It "h " "short " "unsigned short"
.It "l " "long " "unsigned long"
.It "ll " "long long " "unsigned long long"
.It "j " "intmax_t " "uintmax_t"
.It "t " "ptrdiff_t " "ptrdiff_t"
.It "z " "size_t " "size_t"
.It "q " "quad_t " "u_quad_t"
.El
.Ss "UTF\-8 and Locale Strings"
All strings for
.Nm libxo
must be UTF\-8.
.Nm libxo
will handle turning them
into locale\-based strings for display to the user.
.Pp
For strings, the \(aqh\(aq and \(aql\(aq modifiers affect the interpretation of
the bytes pointed to argument.
The default \(aq%s\(aq string is a \(aqchar *\(aq
pointer to a string encoded as UTF\-8.
Since UTF\-8 is compatible with
.Em ASCII
data, a normal 7\-bit
.Em ASCII
string can be used.
"%ls" expects a
"wchar_t *" pointer to a wide\-character string, encoded as 32\-bit
Unicode values.
"%hs" expects a "char *" pointer to a multi\-byte
string encoded with the current locale, as given by the
.Ev LC_CTYPE ,
.Ev LANG ,
or
.Ev LC_ALL
environment variables.
The first of this list of
variables is used and if none of the variables are set, the locale defaults to
.Em UTF\-8 .
.Pp
.Nm libxo
will
convert these arguments as needed to either UTF\-8 (for XML, JSON, and
HTML styles) or locale\-based strings for display in text style.
.Bd -literal -offset indent
xo_emit("All strings are utf\-8 content {:tag/%ls}",
L"except for wide strings");
.Ed
.Pp
"%S" is equivalent to "%ls".
.Pp
For example, a function is passed a locale\-base name, a hat size,
and a time value.
The hat size is formatted in a UTF\-8 (ASCII)
string, and the time value is formatted into a wchar_t string.
.Bd -literal -offset indent
void print_order (const char *name, int size,
struct tm *timep) {
char buf[32];
const char *size_val = "unknown";
if (size > 0)
snprintf(buf, sizeof(buf), "%d", size);
size_val = buf;
}
wchar_t when[32];
wcsftime(when, sizeof(when), L"%d%b%y", timep);
xo_emit("The hat for {:name/%hs} is {:size/%s}.\\n",
name, size_val);
xo_emit("It was ordered on {:order\-time/%ls}.\\n",
when);
}
.Ed
.Pp
It is important to note that
.Xr xo_emit 3
will perform the conversion
required to make appropriate output.
Text style output uses the
current locale (as described above), while XML, JSON, and HTML use
UTF\-8.
.Pp
UTF\-8 and locale\-encoded strings can use multiple bytes to encode one
column of data.
The traditional "precision" (aka "max\-width") value
for "%s" printf formatting becomes overloaded since it specifies both
the number of bytes that can be safely referenced and the maximum
number of columns to emit.
.Xr xo_emit 3
uses the precision as the former,
and adds a third value for specifying the maximum number of columns.
.Pp
In this example, the name field is printed with a minimum of 3 columns
and a maximum of 6.
Up to ten bytes are in used in filling those columns.
.Bd -literal -offset indent
xo_emit("{:name/%3.10.6s}", name);
.Ed
.Ss "Characters Outside of Field Definitions"
Characters in the format string that are not part of a field definition are
copied to the output for the TEXT style, and are ignored for the JSON
and XML styles.
For HTML, these characters are placed in a
with class "text".
.Bd -literal -offset indent
EXAMPLE:
xo_emit("The hat is {:size/%s}.\\n", size_val);
TEXT:
The hat is extra small.
XML:
extra small
JSON:
"size": "extra small"
HTML:
The hat is
extra small
.
.Ed
.Ss "\(aq%n\(aq is Not Supported"
.Nm libxo
does not support the \(aq%n\(aq directive.
It is a bad idea and we
just do not do it.
.Ss "The Encoding Format (eformat)"
The "eformat" string is the format string used when encoding the field
for JSON and XML.
If not provided, it defaults to the primary format
with any minimum width removed.
If the primary is not given, both default to "%s".
.Sh EXAMPLE
In this example, the value for the number of items in stock is emitted:
.Bd -literal -offset indent
xo_emit("{P: }{Lwc:In stock}{:in\-stock/%u}\\n",
instock);
.Ed
.Pp
This call will generate the following output:
.Bd -literal -offset indent
TEXT:
In stock: 144
XML:
144
JSON:
"in\-stock": 144,
HTML:
.Ed
.Pp
Clearly HTML wins the verbosity award, and this output does
not include
.Dv XOF_XPATH
or
.Dv XOF_INFO
data, which would expand the penultimate line to:
.Bd -literal -offset indent
144
.Ed
.Sh WHAT MAKES A GOOD FIELD NAME?
To make useful, consistent field names, follow these guidelines:
.Ss "Use lower case, even for TLAs"
Lower case is more civilized.
Even TLAs should be lower case
to avoid scenarios where the differences between "XPath" and
"Xpath" drive your users crazy.
Using "xpath" is simpler and better.
.Ss "Use hyphens, not underscores"
Use of hyphens is traditional in XML, and the
.Dv XOF_UNDERSCORES
flag can be used to generate underscores in JSON, if desired.
But the raw field name should use hyphens.
.Ss "Use full words"
Do not abbreviate especially when the abbreviation is not obvious or
not widely used.
Use "data\-size", not "dsz" or "dsize".
Use
"interface" instead of "ifname", "if\-name", "iface", "if", or "intf".
.Ss "Use
\-"
Using the form \- or \-\- helps in
making consistent, useful names, avoiding the situation where one app
uses "sent\-packet" and another "packets\-sent" and another
"packets\-we\-have\-sent".
The can be dropped when it is
obvious, as can obvious words in the classification.
Use "receive\-after\-window\-packets" instead of
"received\-packets\-of\-data\-after\-window".
.Ss "Reuse existing field names"
Nothing is worse than writing expressions like:
.Bd -literal -offset indent
if ($src1/process[pid == $pid]/name ==
$src2/proc\-table/proc/p[process\-id == $pid]/proc\-name) {
...
}
.Ed
.Pp
Find someone else who is expressing similar data and follow their
fields and hierarchy.
Remember the quote is not
.Dq "Consistency is the hobgoblin of little minds"
but
.Dq "A foolish consistency is the hobgoblin of little minds" .
.Ss "Think about your users"
Have empathy for your users, choosing clear and useful fields that
contain clear and useful data.
You may need to augment the display content with
.Xr xo_attr 3
calls or "{e:}" fields to make the data useful.
.Ss "Do not use an arbitrary number postfix"
What does "errors2" mean?
No one will know.
"errors\-after\-restart" would be a better choice.
Think of your users, and think of the future.
If you make "errors2", the next guy will happily make
"errors3" and before you know it, someone will be asking what is the
difference between errors37 and errors63.
.Ss "Be consistent, uniform, unsurprising, and predictable"
Think of your field vocabulary as an API.
You want it useful,
expressive, meaningful, direct, and obvious.
You want the client
application\(aqs programmer to move between without the need to
understand a variety of opinions on how fields are named.
They should
see the system as a single cohesive whole, not a sack of cats.
.Pp
Field names constitute the means by which client programmers interact
with our system.
By choosing wise names now, you are making their lives better.
.Pp
After using
.Xr xolint 1
to find errors in your field descriptors, use
.Dq "xolint \-V"
to spell check your field names and to detect different
names for the same data.
.Dq dropped\-short
and
.Dq dropped\-too\-short
are both reasonable names, but using them both will lead users to ask the
difference between the two fields.
If there is no difference,
use only one of the field names.
If there is a difference, change the
names to make that difference more obvious.
.Sh SEE ALSO
.Xr libxo 3 ,
.Xr xolint 1 ,
.Xr xo_emit 3
Index: head/contrib/libxo/libxo/xo_syslog.c
===================================================================
--- head/contrib/libxo/libxo/xo_syslog.c (revision 300911)
+++ head/contrib/libxo/libxo/xo_syslog.c (revision 300912)
@@ -1,706 +1,706 @@
/*
* Copyright (c) 2015, Juniper Networks, Inc.
* All rights reserved.
* This SOFTWARE is licensed under the LICENSE provided in the
* ../Copyright file. By downloading, installing, copying, or otherwise
* using the SOFTWARE, you agree to be bound by the terms of that
* LICENSE.
* Phil Shafer, June 2015
*/
/*
* Portions of this file are:
* Copyright (c) 1983, 1988, 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.
* 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.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "xo_config.h"
#include "xo.h"
#include "xo_encoder.h" /* For xo_realloc */
#include "xo_buf.h"
/*
* SYSLOG (RFC 5424) requires an enterprise identifier. This turns
* out to be a fickle little issue. For a single-vendor box, the
* system should have a single EID that all software can use. When
* VendorX turns FreeBSD into a product, all software (kernel and
* utilities) should report VendorX's EID. But when software is
* installed on top of an external operating system, the application
* should report it's own EID, distinct from the base OS.
*
* To make this happen, the kernel should support a sysctl to assign a
* custom enterprise-id ("kern.syslog.enterprise_id"). libxo then
* allows an application to set a custom EID to override that system
* wide value, if needed.
*
* We try to set the stock IANA assigned Enterprise ID value for the
* vendors we know about (FreeBSD, macosx), but fallback to the
* "example" EID defined by IANA. See:
* https://www.iana.org/assignments/enterprise-numbers/enterprise-numbers
*/
#define XO_SYSLOG_ENTERPRISE_ID "kern.syslog.enterprise_id"
#if defined(__FreeBSD__)
#define XO_DEFAULT_EID 2238
#elif defined(__macosx__)
#define XO_DEFAULT_EID 63
#else
-#define XO_DEFAULT_EID 32473 /* Bail; use "example" number */
+#define XO_DEFAULT_EID 32473 /* Fallback to the "example" number */
#endif
#ifdef _SC_HOST_NAME_MAX
#define HOST_NAME_MAX _SC_HOST_NAME_MAX
#else
#define HOST_NAME_MAX 255
#endif /* _SC_HOST_NAME_MAX */
#ifndef UNUSED
#define UNUSED __attribute__ ((__unused__))
#endif /* UNUSED */
static int xo_logfile = -1; /* fd for log */
static int xo_status; /* connection xo_status */
static int xo_opened; /* have done openlog() */
static int xo_logstat = 0; /* xo_status bits, set by openlog() */
static const char *xo_logtag = NULL; /* string to tag the entry with */
static int xo_logfacility = LOG_USER; /* default facility code */
static int xo_logmask = 0xff; /* mask of priorities to be logged */
static pthread_mutex_t xo_syslog_mutex UNUSED = PTHREAD_MUTEX_INITIALIZER;
static int xo_unit_test; /* Fake data for unit test */
#define REAL_VOID(_x) \
do { int really_ignored = _x; if (really_ignored) { }} while (0)
#if !defined(HAVE_DECL___ISTHREADED) || !HAVE_DECL___ISTHREADED
#define __isthreaded 1
#endif
#define THREAD_LOCK() \
do { \
if (__isthreaded) pthread_mutex_lock(&xo_syslog_mutex); \
} while(0)
#define THREAD_UNLOCK() \
do { \
if (__isthreaded) pthread_mutex_unlock(&xo_syslog_mutex); \
} while(0)
static void xo_disconnect_log(void); /* disconnect from syslogd */
static void xo_connect_log(void); /* (re)connect to syslogd */
static void xo_open_log_unlocked(const char *, int, int);
enum {
NOCONN = 0,
CONNDEF,
CONNPRIV,
};
static xo_syslog_open_t xo_syslog_open;
static xo_syslog_send_t xo_syslog_send;
static xo_syslog_close_t xo_syslog_close;
static char xo_syslog_enterprise_id[12];
/*
* Record an enterprise ID, which functions as a namespace for syslog
* messages. The value is pre-formatted into a string. This allows
* applications to customize their syslog message set, when needed.
*/
void
xo_set_syslog_enterprise_id (unsigned short eid)
{
snprintf(xo_syslog_enterprise_id, sizeof(xo_syslog_enterprise_id),
"%u", eid);
}
/*
* Handle the work of transmitting the syslog message
*/
static void
xo_send_syslog (char *full_msg, char *v0_hdr,
char *text_only)
{
if (xo_syslog_send) {
xo_syslog_send(full_msg, v0_hdr, text_only);
return;
}
int fd;
int full_len = strlen(full_msg);
/* Output to stderr if requested. */
if (xo_logstat & LOG_PERROR) {
struct iovec iov[3];
struct iovec *v = iov;
char newline[] = "\n";
v->iov_base = v0_hdr;
v->iov_len = strlen(v0_hdr);
v += 1;
v->iov_base = text_only;
v->iov_len = strlen(text_only);
v += 1;
v->iov_base = newline;
v->iov_len = 1;
v += 1;
REAL_VOID(writev(STDERR_FILENO, iov, 3));
}
/* Get connected, output the message to the local logger. */
if (!xo_opened)
xo_open_log_unlocked(xo_logtag, xo_logstat | LOG_NDELAY, 0);
xo_connect_log();
/*
* If the send() fails, there are two likely scenarios:
* 1) syslogd was restarted
* 2) /var/run/log is out of socket buffer space, which
* in most cases means local DoS.
* If the error does not indicate a full buffer, we address
* case #1 by attempting to reconnect to /var/run/log[priv]
* and resending the message once.
*
* If we are working with a privileged socket, the retry
* attempts end there, because we don't want to freeze a
* critical application like su(1) or sshd(8).
*
* Otherwise, we address case #2 by repeatedly retrying the
* send() to give syslogd a chance to empty its socket buffer.
*/
if (send(xo_logfile, full_msg, full_len, 0) < 0) {
if (errno != ENOBUFS) {
/*
* Scenario 1: syslogd was restarted
* reconnect and resend once
*/
xo_disconnect_log();
xo_connect_log();
if (send(xo_logfile, full_msg, full_len, 0) >= 0) {
return;
}
/*
* if the resend failed, fall through to
* possible scenario 2
*/
}
while (errno == ENOBUFS) {
/*
* Scenario 2: out of socket buffer space
* possible DoS, fail fast on a privileged
* socket
*/
if (xo_status == CONNPRIV)
break;
usleep(1);
if (send(xo_logfile, full_msg, full_len, 0) >= 0) {
return;
}
}
} else {
return;
}
/*
* Output the message to the console; try not to block
* as a blocking console should not stop other processes.
* Make sure the error reported is the one from the syslogd failure.
*/
int flags = O_WRONLY | O_NONBLOCK;
#ifdef O_CLOEXEC
flags |= O_CLOEXEC;
#endif /* O_CLOEXEC */
if (xo_logstat & LOG_CONS
&& (fd = open(_PATH_CONSOLE, flags, 0)) >= 0) {
struct iovec iov[2];
struct iovec *v = iov;
char crnl[] = "\r\n";
char *p;
p = strchr(full_msg, '>') + 1;
v->iov_base = p;
v->iov_len = full_len - (p - full_msg);
++v;
v->iov_base = crnl;
v->iov_len = 2;
REAL_VOID(writev(fd, iov, 2));
(void) close(fd);
}
}
/* Should be called with mutex acquired */
static void
xo_disconnect_log (void)
{
if (xo_syslog_close) {
xo_syslog_close();
return;
}
/*
* If the user closed the FD and opened another in the same slot,
* that's their problem. They should close it before calling on
* system services.
*/
if (xo_logfile != -1) {
close(xo_logfile);
xo_logfile = -1;
}
xo_status = NOCONN; /* retry connect */
}
/* Should be called with mutex acquired */
static void
xo_connect_log (void)
{
if (xo_syslog_open) {
xo_syslog_open();
return;
}
struct sockaddr_un saddr; /* AF_UNIX address of local logger */
if (xo_logfile == -1) {
int flags = SOCK_DGRAM;
#ifdef SOCK_CLOEXEC
flags |= SOCK_CLOEXEC;
#endif /* SOCK_CLOEXEC */
if ((xo_logfile = socket(AF_UNIX, flags, 0)) == -1)
return;
}
if (xo_logfile != -1 && xo_status == NOCONN) {
#ifdef HAVE_SUN_LEN
saddr.sun_len = sizeof(saddr);
#endif /* HAVE_SUN_LEN */
saddr.sun_family = AF_UNIX;
/*
* First try privileged socket. If no success,
* then try default socket.
*/
#ifdef _PATH_LOG_PRIV
(void) strncpy(saddr.sun_path, _PATH_LOG_PRIV,
sizeof saddr.sun_path);
if (connect(xo_logfile, (struct sockaddr *) &saddr,
sizeof(saddr)) != -1)
xo_status = CONNPRIV;
#endif /* _PATH_LOG_PRIV */
#ifdef _PATH_LOG
if (xo_status == NOCONN) {
(void) strncpy(saddr.sun_path, _PATH_LOG,
sizeof saddr.sun_path);
if (connect(xo_logfile, (struct sockaddr *)&saddr,
sizeof(saddr)) != -1)
xo_status = CONNDEF;
}
#endif /* _PATH_LOG */
#ifdef _PATH_OLDLOG
if (xo_status == NOCONN) {
/*
* Try the old "/dev/log" path, for backward
* compatibility.
*/
(void) strncpy(saddr.sun_path, _PATH_OLDLOG,
sizeof saddr.sun_path);
if (connect(xo_logfile, (struct sockaddr *)&saddr,
sizeof(saddr)) != -1)
xo_status = CONNDEF;
}
#endif /* _PATH_OLDLOG */
if (xo_status == NOCONN) {
(void) close(xo_logfile);
xo_logfile = -1;
}
}
}
static void
xo_open_log_unlocked (const char *ident, int logstat, int logfac)
{
if (ident != NULL)
xo_logtag = ident;
xo_logstat = logstat;
if (logfac != 0 && (logfac &~ LOG_FACMASK) == 0)
xo_logfacility = logfac;
if (xo_logstat & LOG_NDELAY) /* open immediately */
xo_connect_log();
xo_opened = 1; /* ident and facility has been set */
}
void
xo_open_log (const char *ident, int logstat, int logfac)
{
THREAD_LOCK();
xo_open_log_unlocked(ident, logstat, logfac);
THREAD_UNLOCK();
}
void
xo_close_log (void)
{
THREAD_LOCK();
if (xo_logfile != -1) {
(void) close(xo_logfile);
xo_logfile = -1;
}
xo_logtag = NULL;
xo_status = NOCONN;
THREAD_UNLOCK();
}
/* xo_set_logmask -- set the log mask level */
int
xo_set_logmask (int pmask)
{
int omask;
THREAD_LOCK();
omask = xo_logmask;
if (pmask != 0)
xo_logmask = pmask;
THREAD_UNLOCK();
return (omask);
}
void
xo_set_syslog_handler (xo_syslog_open_t open_func,
xo_syslog_send_t send_func,
xo_syslog_close_t close_func)
{
xo_syslog_open = open_func;
xo_syslog_send = send_func;
xo_syslog_close = close_func;
}
static size_t
xo_snprintf (char *out, size_t outsize, const char *fmt, ...)
{
int status;
size_t retval = 0;
va_list ap;
if (out && outsize) {
va_start(ap, fmt);
status = vsnprintf(out, outsize, fmt, ap);
if (status < 0) { /* this should never happen, */
*out = 0; /* handle it in the safest way possible if it does */
retval = 0;
} else {
retval = status;
retval = retval > outsize ? outsize : retval;
}
va_end(ap);
}
return retval;
}
static int
xo_syslog_handle_write (void *opaque, const char *data)
{
xo_buffer_t *xbp = opaque;
int len = strlen(data);
int left = xo_buf_left(xbp);
if (len > left - 1)
len = left - 1;
memcpy(xbp->xb_curp, data, len);
xbp->xb_curp += len;
*xbp->xb_curp = '\0';
return len;
}
static void
xo_syslog_handle_close (void *opaque UNUSED)
{
}
static int
xo_syslog_handle_flush (void *opaque UNUSED)
{
return 0;
}
void
xo_set_unit_test_mode (int value)
{
xo_unit_test = value;
}
void
xo_vsyslog (int pri, const char *name, const char *fmt, va_list vap)
{
int saved_errno = errno;
char tbuf[2048];
char *tp = NULL, *ep = NULL;
unsigned start_of_msg = 0;
char *v0_hdr = NULL;
xo_buffer_t xb;
static pid_t my_pid;
unsigned log_offset;
if (my_pid == 0)
my_pid = xo_unit_test ? 222 : getpid();
/* Check for invalid bits */
if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) {
xo_syslog(LOG_ERR | LOG_CONS | LOG_PERROR | LOG_PID,
"syslog-unknown-priority",
"syslog: unknown facility/priority: %#x", pri);
pri &= LOG_PRIMASK|LOG_FACMASK;
}
THREAD_LOCK();
/* Check priority against setlogmask values. */
if (!(LOG_MASK(LOG_PRI(pri)) & xo_logmask)) {
THREAD_UNLOCK();
return;
}
/* Set default facility if none specified. */
if ((pri & LOG_FACMASK) == 0)
pri |= xo_logfacility;
/* Create the primary stdio hook */
xb.xb_bufp = tbuf;
xb.xb_curp = tbuf;
xb.xb_size = sizeof(tbuf);
xo_handle_t *xop = xo_create(XO_STYLE_SDPARAMS, 0);
if (xop == NULL) {
THREAD_UNLOCK();
return;
}
#ifdef HAVE_GETPROGNAME
if (xo_logtag == NULL)
xo_logtag = getprogname();
#endif /* HAVE_GETPROGNAME */
xo_set_writer(xop, &xb, xo_syslog_handle_write, xo_syslog_handle_close,
xo_syslog_handle_flush);
/* Build the message; start by getting the time */
struct tm tm;
struct timeval tv;
/* Unit test hack: fake a fixed time */
if (xo_unit_test) {
tv.tv_sec = 1435085229;
tv.tv_usec = 123456;
} else
gettimeofday(&tv, NULL);
(void) localtime_r(&tv.tv_sec, &tm);
if (xo_logstat & LOG_PERROR) {
/*
* For backwards compatibility, we need to make the old-style
* message. This message can be emitted to the console/tty.
*/
v0_hdr = alloca(2048);
tp = v0_hdr;
ep = v0_hdr + 2048;
if (xo_logtag != NULL)
tp += xo_snprintf(tp, ep - tp, "%s", xo_logtag);
if (xo_logstat & LOG_PID)
tp += xo_snprintf(tp, ep - tp, "[%d]", my_pid);
if (xo_logtag)
tp += xo_snprintf(tp, ep - tp, ": ");
}
log_offset = xb.xb_curp - xb.xb_bufp;
/* Add PRI, PRIVAL, and VERSION */
xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb), "<%d>1 ", pri);
/* Add TIMESTAMP with milliseconds and TZOFFSET */
xb.xb_curp += strftime(xb.xb_curp, xo_buf_left(&xb), "%FT%T", &tm);
xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb),
".%03.3u", tv.tv_usec / 1000);
xb.xb_curp += strftime(xb.xb_curp, xo_buf_left(&xb), "%z ", &tm);
/*
* Add HOSTNAME; we rely on gethostname and don't fluff with
* ip addresses. Might need to revisit.....
*/
char hostname[HOST_NAME_MAX];
hostname[0] = '\0';
if (xo_unit_test)
strcpy(hostname, "worker-host");
else
(void) gethostname(hostname, sizeof(hostname));
xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb), "%s ",
hostname[0] ? hostname : "-");
/* Add APP-NAME */
xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb), "%s ",
xo_logtag ?: "-");
/* Add PROCID */
xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb), "%d ", my_pid);
/*
* Add MSGID. The user should provide us with a name, which we
* prefix with the current enterprise ID, as learned from the kernel.
* If the kernel won't tell us, we use the stock/builtin number.
*/
char *buf UNUSED = NULL;
const char *eid = xo_syslog_enterprise_id;
const char *at_sign = "@";
if (name == NULL) {
name = "-";
eid = at_sign = "";
} else if (*name == '@') {
/* Our convention is to prefix IANA-defined names with an "@" */
name += 1;
eid = at_sign = "";
} else if (eid[0] == '\0') {
#ifdef HAVE_SYSCTLBYNAME
/*
* See if the kernel knows the sysctl for the enterprise ID
*/
size_t size = 0;
if (sysctlbyname(XO_SYSLOG_ENTERPRISE_ID, NULL, &size, NULL, 0) == 0
&& size > 0) {
buf = alloca(size);
if (sysctlbyname(XO_SYSLOG_ENTERPRISE_ID, buf, &size, NULL, 0) == 0
&& size > 0)
eid = buf;
}
#endif /* HAVE_SYSCTLBYNAME */
if (eid[0] == '\0') {
/* Fallback to our base default */
xo_set_syslog_enterprise_id(XO_DEFAULT_EID);
eid = xo_syslog_enterprise_id;
}
}
xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb), "%s [%s%s%s ",
name, name, at_sign, eid);
/*
* Now for the real content. We make two distinct passes thru the
* xo_emit engine, first for the SD-PARAMS and then for the text
* message.
*/
va_list ap;
va_copy(ap, vap);
errno = saved_errno; /* Restore saved error value */
xo_emit_hv(xop, fmt, ap);
xo_flush_h(xop);
va_end(ap);
/* Trim trailing space */
if (xb.xb_curp[-1] == ' ')
xb.xb_curp -= 1;
/* Close the structured data (SD-ELEMENT) */
xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb), "] ");
/*
* Since our MSG is known to be UTF-8, we MUST prefix it with
* that most-annoying-of-all-UTF-8 features, the BOM (0xEF.BB.BF).
*/
xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb),
"%c%c%c", 0xEF, 0xBB, 0xBF);
/* Save the start of the message */
if (xo_logstat & LOG_PERROR)
start_of_msg = xb.xb_curp - xb.xb_bufp;
xo_set_style(xop, XO_STYLE_TEXT);
xo_set_flags(xop, XOF_UTF8);
errno = saved_errno; /* Restore saved error value */
xo_emit_hv(xop, fmt, ap);
xo_flush_h(xop);
/* Remove a trailing newline */
if (xb.xb_curp[-1] == '\n')
*--xb.xb_curp = '\0';
if (xo_get_flags(xop) & XOF_LOG_SYSLOG)
fprintf(stderr, "xo: syslog: %s\n", xb.xb_bufp + log_offset);
xo_send_syslog(xb.xb_bufp, v0_hdr, xb.xb_bufp + start_of_msg);
xo_destroy(xop);
THREAD_UNLOCK();
}
/*
* syslog - print message on log file; output is intended for syslogd(8).
*/
void
xo_syslog (int pri, const char *name, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
xo_vsyslog(pri, name, fmt, ap);
va_end(ap);
}