S390: Enable static PIE
[glibc.git] / misc / syslog.c
blob554089bfc45244e87c08eb0482e61c35dd0fa3ca
1 /*
2 * Copyright (c) 1983, 1988, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
30 #if defined(LIBC_SCCS) && !defined(lint)
31 static char sccsid[] = "@(#)syslog.c 8.4 (Berkeley) 3/18/94";
32 #endif /* LIBC_SCCS and not lint */
34 #include <libio/libioP.h>
35 #include <paths.h>
36 #include <stdarg.h>
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <stdio_ext.h>
40 #include <sys/socket.h>
41 #include <sys/uio.h>
42 #include <sys/un.h>
43 #include <syslog.h>
45 static int LogType = SOCK_DGRAM; /* type of socket connection */
46 static int LogFile = -1; /* fd for log */
47 static bool connected; /* have done connect */
48 static int LogStat; /* status bits, set by openlog() */
49 static const char *LogTag; /* string to tag the entry with */
50 static int LogFacility = LOG_USER; /* default facility code */
51 static int LogMask = 0xff; /* mask of priorities to be logged */
52 extern char *__progname; /* Program name, from crt0. */
54 /* Define the lock. */
55 __libc_lock_define_initialized (static, syslog_lock)
56 static void openlog_internal (const char *, int, int);
57 static void closelog_internal (void);
59 struct cleanup_arg
61 void *buf;
62 struct sigaction *oldaction;
65 static void
66 cancel_handler (void *ptr)
68 /* Restore the old signal handler. */
69 struct cleanup_arg *clarg = (struct cleanup_arg *) ptr;
71 if (clarg != NULL)
72 /* Free the memstream buffer, */
73 free (clarg->buf);
75 /* Free the lock. */
76 __libc_lock_unlock (syslog_lock);
81 * syslog, vsyslog --
82 * print message on log file; output is intended for syslogd(8).
84 void
85 __syslog (int pri, const char *fmt, ...)
87 va_list ap;
89 va_start (ap, fmt);
90 __vsyslog_internal (pri, fmt, ap, 0);
91 va_end (ap);
93 ldbl_hidden_def (__syslog, syslog)
94 ldbl_strong_alias (__syslog, syslog)
96 void
97 __vsyslog (int pri, const char *fmt, va_list ap)
99 __vsyslog_internal (pri, fmt, ap, 0);
101 ldbl_weak_alias (__vsyslog, vsyslog)
103 void
104 __syslog_chk (int pri, int flag, const char *fmt, ...)
106 va_list ap;
108 va_start (ap, fmt);
109 __vsyslog_internal (pri, fmt, ap, (flag > 0) ? PRINTF_FORTIFY : 0);
110 va_end (ap);
113 void
114 __vsyslog_chk (int pri, int flag, const char *fmt, va_list ap)
116 __vsyslog_internal (pri, fmt, ap, (flag > 0) ? PRINTF_FORTIFY : 0);
119 void
120 __vsyslog_internal (int pri, const char *fmt, va_list ap,
121 unsigned int mode_flags)
123 /* Try to use a static buffer as an optimization. */
124 char bufs[1024];
125 char *buf = NULL;
126 size_t bufsize = 0;
127 int msgoff;
128 int saved_errno = errno;
130 #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
131 /* Check for invalid bits. */
132 if (pri & ~(LOG_PRIMASK | LOG_FACMASK))
134 syslog (INTERNALLOG, "syslog: unknown facility/priority: %x", pri);
135 pri &= LOG_PRIMASK | LOG_FACMASK;
138 /* Prepare for multiple users. We have to take care: most syscalls we are
139 using are cancellation points. */
140 struct cleanup_arg clarg = { NULL, NULL };
141 __libc_cleanup_push (cancel_handler, &clarg);
142 __libc_lock_lock (syslog_lock);
144 /* Check priority against setlogmask values. */
145 if ((LOG_MASK (LOG_PRI (pri)) & LogMask) == 0)
146 goto out;
148 /* Set default facility if none specified. */
149 if ((pri & LOG_FACMASK) == 0)
150 pri |= LogFacility;
152 pid_t pid = LogStat & LOG_PID ? __getpid () : 0;
154 /* "%b %e %H:%M:%S " */
155 char timestamp[sizeof "MMM DD hh:mm:ss "];
156 __time64_t now = time64_now ();
157 struct tm now_tm;
158 struct tm *now_tmp = __localtime64_r (&now, &now_tm);
159 bool has_ts = now_tmp != NULL;
161 /* In the unlikely case of localtime_r failure (tm_year out of int range)
162 skip the hostname so the message is handled as valid PRI but without
163 TIMESTAMP or invalid TIMESTAMP (which should force the relay to add the
164 timestamp itself). */
165 if (has_ts)
166 __strftime_l (timestamp, sizeof timestamp, "%h %e %T ", now_tmp,
167 _nl_C_locobj_ptr);
169 #define SYSLOG_HEADER(__pri, __timestamp, __msgoff, pid) \
170 "<%d>%s %n%s%s%.0d%s: ", \
171 __pri, __timestamp, __msgoff, \
172 LogTag == NULL ? __progname : LogTag, \
173 "[" + (pid == 0), pid, "]" + (pid == 0)
175 #define SYSLOG_HEADER_WITHOUT_TS(__pri, __msgoff) \
176 "<%d>: %n", __pri, __msgoff
178 int l;
179 if (has_ts)
180 l = __snprintf (bufs, sizeof bufs,
181 SYSLOG_HEADER (pri, timestamp, &msgoff, pid));
182 else
183 l = __snprintf (bufs, sizeof bufs,
184 SYSLOG_HEADER_WITHOUT_TS (pri, &msgoff));
185 if (0 <= l && l < sizeof bufs)
187 va_list apc;
188 va_copy (apc, ap);
190 /* Restore errno for %m format. */
191 __set_errno (saved_errno);
193 int vl = __vsnprintf_internal (bufs + l, sizeof bufs - l, fmt, apc,
194 mode_flags);
195 if (0 <= vl && vl < sizeof bufs - l)
197 buf = bufs;
198 bufsize = l + vl;
201 va_end (apc);
204 if (buf == NULL)
206 buf = malloc (l * sizeof (char));
207 if (buf != NULL)
209 /* Tell the cancellation handler to free this buffer. */
210 clarg.buf = buf;
212 if (has_ts)
213 __snprintf (bufs, sizeof bufs,
214 SYSLOG_HEADER (pri, timestamp, &msgoff, pid));
215 else
216 __snprintf (bufs, sizeof bufs,
217 SYSLOG_HEADER_WITHOUT_TS (pri, &msgoff));
219 else
221 /* Nothing much to do but emit an error message. */
222 bufsize = __snprintf (bufs, sizeof bufs,
223 "out of memory[%d]", __getpid ());
224 buf = bufs;
228 /* Output to stderr if requested. */
229 if (LogStat & LOG_PERROR)
230 __dprintf (STDERR_FILENO, "%s%s", buf + msgoff,
231 "\n" + (buf[bufsize - 1] == '\n'));
233 /* Get connected, output the message to the local logger. */
234 if (!connected)
235 openlog_internal (NULL, LogStat | LOG_NDELAY, LogFacility);
237 /* If we have a SOCK_STREAM connection, also send ASCII NUL as a record
238 terminator. */
239 if (LogType == SOCK_STREAM)
240 ++bufsize;
242 if (!connected || __send (LogFile, buf, bufsize, MSG_NOSIGNAL) < 0)
244 if (connected)
246 /* Try to reopen the syslog connection. Maybe it went down. */
247 closelog_internal ();
248 openlog_internal (NULL, LogStat | LOG_NDELAY, LogFacility);
251 if (!connected || __send (LogFile, buf, bufsize, MSG_NOSIGNAL) < 0)
253 closelog_internal (); /* attempt re-open next time */
255 * Output the message to the console; don't worry
256 * about blocking, if console blocks everything will.
257 * Make sure the error reported is the one from the
258 * syslogd failure.
260 int fd;
261 if (LogStat & LOG_CONS &&
262 (fd = __open (_PATH_CONSOLE, O_WRONLY | O_NOCTTY
263 | O_CLOEXEC, 0)) >= 0)
265 __dprintf (fd, "%s\r\n", buf + msgoff);
266 __close (fd);
271 out:
272 /* End of critical section. */
273 __libc_cleanup_pop (0);
274 __libc_lock_unlock (syslog_lock);
276 if (buf != bufs)
277 free (buf);
280 /* AF_UNIX address of local logger */
281 static const struct sockaddr_un SyslogAddr =
283 .sun_family = AF_UNIX,
284 .sun_path = _PATH_LOG
287 static void
288 openlog_internal (const char *ident, int logstat, int logfac)
290 if (ident != NULL)
291 LogTag = ident;
292 LogStat = logstat;
293 if ((logfac & ~LOG_FACMASK) == 0)
294 LogFacility = logfac;
296 int retry = 0;
297 while (retry < 2)
299 if (LogFile == -1)
301 if (LogStat & LOG_NDELAY)
303 LogFile = __socket (AF_UNIX, LogType | SOCK_CLOEXEC, 0);
304 if (LogFile == -1)
305 return;
308 if (LogFile != -1 && !connected)
310 int old_errno = errno;
311 if (__connect (LogFile, &SyslogAddr, sizeof (SyslogAddr)) == -1)
313 int saved_errno = errno;
314 int fd = LogFile;
315 LogFile = -1;
316 __close (fd);
317 __set_errno (old_errno);
318 if (saved_errno == EPROTOTYPE)
320 /* retry with the other type: */
321 LogType = LogType == SOCK_DGRAM ? SOCK_STREAM : SOCK_DGRAM;
322 ++retry;
323 continue;
326 else
327 connected = true;
329 break;
333 void
334 openlog (const char *ident, int logstat, int logfac)
336 /* Protect against multiple users and cancellation. */
337 __libc_cleanup_push (cancel_handler, NULL);
338 __libc_lock_lock (syslog_lock);
340 openlog_internal (ident, logstat, logfac);
342 __libc_cleanup_pop (1);
345 static void
346 closelog_internal (void)
348 if (!connected)
349 return;
351 __close (LogFile);
352 LogFile = -1;
353 connected = false;
356 void
357 closelog (void)
359 /* Protect against multiple users and cancellation. */
360 __libc_cleanup_push (cancel_handler, NULL);
361 __libc_lock_lock (syslog_lock);
363 closelog_internal ();
364 LogTag = NULL;
365 LogType = SOCK_DGRAM; /* this is the default */
367 /* Free the lock. */
368 __libc_cleanup_pop (1);
371 /* setlogmask -- set the log mask level */
373 setlogmask (int pmask)
375 int omask;
377 /* Protect against multiple users. */
378 __libc_lock_lock (syslog_lock);
380 omask = LogMask;
381 if (pmask != 0)
382 LogMask = pmask;
384 __libc_lock_unlock (syslog_lock);
386 return (omask);