1 /*
2 * Copyright (c) 1983, 1988, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
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.
16 *
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.
28 */
29
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 */
33
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>
44
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. */
53
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);
58
59 struct cleanup_arg
60 {
61 void *buf;
62 struct sigaction *oldaction;
63 };
64
65 static void
66 cancel_handler (void *ptr)
67 {
68 /* Restore the old signal handler. */
69 struct cleanup_arg *clarg = (struct cleanup_arg *) ptr;
70
71 if (clarg != NULL)
72 /* Free the memstream buffer, */
73 free (clarg->buf);
74
75 /* Free the lock. */
76 __libc_lock_unlock (syslog_lock);
77 }
78
79
80 /*
81 * syslog, vsyslog --
82 * print message on log file; output is intended for syslogd(8).
83 */
84 void
85 __syslog (int pri, const char *fmt, ...)
86 {
87 va_list ap;
88
89 va_start (ap, fmt);
90 __vsyslog_internal (pri, fmt, ap, 0);
91 va_end (ap);
92 }
93 ldbl_hidden_def (__syslog, syslog)
94 ldbl_strong_alias (__syslog, syslog)
95
96 void
97 __vsyslog (int pri, const char *fmt, va_list ap)
98 {
99 __vsyslog_internal (pri, fmt, ap, 0);
100 }
101 ldbl_weak_alias (__vsyslog, vsyslog)
102
103 void
104 ___syslog_chk (int pri, int flag, const char *fmt, ...)
105 {
106 va_list ap;
107
108 va_start (ap, fmt);
109 __vsyslog_internal (pri, fmt, ap, (flag > 0) ? PRINTF_FORTIFY : 0);
110 va_end (ap);
111 }
112 ldbl_hidden_def (___syslog_chk, __syslog_chk)
113 ldbl_strong_alias (___syslog_chk, __syslog_chk)
114
115 void
116 __vsyslog_chk (int pri, int flag, const char *fmt, va_list ap)
117 {
118 __vsyslog_internal (pri, fmt, ap, (flag > 0) ? PRINTF_FORTIFY : 0);
119 }
120
121 void
122 __vsyslog_internal (int pri, const char *fmt, va_list ap,
123 unsigned int mode_flags)
124 {
125 /* Try to use a static buffer as an optimization. */
126 char bufs[1024];
127 char *buf = NULL;
128 size_t bufsize = 0;
129 int msgoff;
130 int saved_errno = errno;
131
132 #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
133 /* Check for invalid bits. */
134 if (pri & ~(LOG_PRIMASK | LOG_FACMASK))
135 {
136 syslog (INTERNALLOG, "syslog: unknown facility/priority: %x", pri);
137 pri &= LOG_PRIMASK | LOG_FACMASK;
138 }
139
140 /* Prepare for multiple users. We have to take care: most syscalls we are
141 using are cancellation points. */
142 struct cleanup_arg clarg = { NULL, NULL };
143 __libc_cleanup_push (cancel_handler, &clarg);
144 __libc_lock_lock (syslog_lock);
145
146 /* Check priority against setlogmask values. */
147 if ((LOG_MASK (LOG_PRI (pri)) & LogMask) == 0)
148 goto out;
149
150 /* Set default facility if none specified. */
151 if ((pri & LOG_FACMASK) == 0)
152 pri |= LogFacility;
153
154 pid_t pid = LogStat & LOG_PID ? __getpid () : 0;
155
156 /* "%b %e %H:%M:%S " */
157 char timestamp[sizeof "MMM DD hh:mm:ss "];
158 __time64_t now = time64_now ();
159 struct tm now_tm;
160 struct tm *now_tmp = __localtime64_r (&now, &now_tm);
161 bool has_ts = now_tmp != NULL;
162
163 /* In the unlikely case of localtime_r failure (tm_year out of int range)
164 skip the hostname so the message is handled as valid PRI but without
165 TIMESTAMP or invalid TIMESTAMP (which should force the relay to add the
166 timestamp itself). */
167 if (has_ts)
168 __strftime_l (timestamp, sizeof timestamp, "%h %e %T ", now_tmp,
169 _nl_C_locobj_ptr);
170
171 #define SYSLOG_HEADER(__pri, __timestamp, __msgoff, pid) \
172 "<%d>%s%n%s%s%.0d%s: ", \
173 __pri, __timestamp, __msgoff, \
174 LogTag == NULL ? __progname : LogTag, \
175 "[" + (pid == 0), pid, "]" + (pid == 0)
176
177 #define SYSLOG_HEADER_WITHOUT_TS(__pri, __msgoff) \
178 "<%d>: %n", __pri, __msgoff
179
180 int l;
181 if (has_ts)
182 l = __snprintf (bufs, sizeof bufs,
183 SYSLOG_HEADER (pri, timestamp, &msgoff, pid));
184 else
185 l = __snprintf (bufs, sizeof bufs,
186 SYSLOG_HEADER_WITHOUT_TS (pri, &msgoff));
187 if (0 <= l && l < sizeof bufs)
188 {
189 va_list apc;
190 va_copy (apc, ap);
191
192 /* Restore errno for %m format. */
193 __set_errno (saved_errno);
194
195 int vl = __vsnprintf_internal (bufs + l, sizeof bufs - l, fmt, apc,
196 mode_flags);
197 if (0 <= vl && vl < sizeof bufs - l)
198 buf = bufs;
199 bufsize = l + vl;
200
201 va_end (apc);
202 }
203
204 if (buf == NULL)
205 {
206 buf = malloc ((bufsize + 1) * sizeof (char));
207 if (buf != NULL)
208 {
209 /* Tell the cancellation handler to free this buffer. */
210 clarg.buf = buf;
211
212 if (has_ts)
213 __snprintf (buf, l + 1,
214 SYSLOG_HEADER (pri, timestamp, &msgoff, pid));
215 else
216 __snprintf (buf, l + 1,
217 SYSLOG_HEADER_WITHOUT_TS (pri, &msgoff));
218
219 va_list apc;
220 va_copy (apc, ap);
221 __vsnprintf_internal (buf + l, bufsize - l + 1, fmt, apc,
222 mode_flags);
223 va_end (apc);
224 }
225 else
226 {
227 /* Nothing much to do but emit an error message. */
228 bufsize = __snprintf (bufs, sizeof bufs,
229 "out of memory[%d]", __getpid ());
230 buf = bufs;
231 }
232 }
233
234 /* Output to stderr if requested. */
235 if (LogStat & LOG_PERROR)
236 __dprintf (STDERR_FILENO, "%s%s", buf + msgoff,
237 "\n" + (buf[bufsize - 1] == '\n'));
238
239 /* Get connected, output the message to the local logger. */
240 if (!connected)
241 openlog_internal (NULL, LogStat | LOG_NDELAY, LogFacility);
242
243 /* If we have a SOCK_STREAM connection, also send ASCII NUL as a record
244 terminator. */
245 if (LogType == SOCK_STREAM)
246 ++bufsize;
247
248 if (!connected || __send (LogFile, buf, bufsize, MSG_NOSIGNAL) < 0)
249 {
250 if (connected)
251 {
252 /* Try to reopen the syslog connection. Maybe it went down. */
253 closelog_internal ();
254 openlog_internal (NULL, LogStat | LOG_NDELAY, LogFacility);
255 }
256
257 if (!connected || __send (LogFile, buf, bufsize, MSG_NOSIGNAL) < 0)
258 {
259 closelog_internal (); /* attempt re-open next time */
260 /*
261 * Output the message to the console; don't worry
262 * about blocking, if console blocks everything will.
263 * Make sure the error reported is the one from the
264 * syslogd failure.
265 */
266 int fd;
267 if (LogStat & LOG_CONS &&
268 (fd = __open (_PATH_CONSOLE, O_WRONLY | O_NOCTTY
269 | O_CLOEXEC, 0)) >= 0)
270 {
271 __dprintf (fd, "%s\r\n", buf + msgoff);
272 __close (fd);
273 }
274 }
275 }
276
277 out:
278 /* End of critical section. */
279 __libc_cleanup_pop (0);
280 __libc_lock_unlock (syslog_lock);
281
282 if (buf != bufs)
283 free (buf);
284 }
285
286 /* AF_UNIX address of local logger */
287 static const struct sockaddr_un SyslogAddr =
288 {
289 .sun_family = AF_UNIX,
290 .sun_path = _PATH_LOG
291 };
292
293 static void
294 openlog_internal (const char *ident, int logstat, int logfac)
295 {
296 if (ident != NULL)
297 LogTag = ident;
298 LogStat = logstat;
299 if ((logfac & ~LOG_FACMASK) == 0)
300 LogFacility = logfac;
301
302 int retry = 0;
303 while (retry < 2)
304 {
305 if (LogFile == -1)
306 {
307 if (LogStat & LOG_NDELAY)
308 {
309 LogFile = __socket (AF_UNIX, LogType | SOCK_CLOEXEC, 0);
310 if (LogFile == -1)
311 return;
312 }
313 }
314 if (LogFile != -1 && !connected)
315 {
316 int old_errno = errno;
317 if (__connect (LogFile, &SyslogAddr, sizeof (SyslogAddr)) == -1)
318 {
319 int saved_errno = errno;
320 int fd = LogFile;
321 LogFile = -1;
322 __close (fd);
323 __set_errno (old_errno);
324 if (saved_errno == EPROTOTYPE)
325 {
326 /* retry with the other type: */
327 LogType = LogType == SOCK_DGRAM ? SOCK_STREAM : SOCK_DGRAM;
328 ++retry;
329 continue;
330 }
331 }
332 else
333 connected = true;
334 }
335 break;
336 }
337 }
338
339 void
340 openlog (const char *ident, int logstat, int logfac)
341 {
342 /* Protect against multiple users and cancellation. */
343 __libc_cleanup_push (cancel_handler, NULL);
344 __libc_lock_lock (syslog_lock);
345
346 openlog_internal (ident, logstat, logfac);
347
348 __libc_cleanup_pop (1);
349 }
350
351 static void
352 closelog_internal (void)
353 {
354 if (!connected)
355 return;
356
357 __close (LogFile);
358 LogFile = -1;
359 connected = false;
360 }
361
362 void
363 closelog (void)
364 {
365 /* Protect against multiple users and cancellation. */
366 __libc_cleanup_push (cancel_handler, NULL);
367 __libc_lock_lock (syslog_lock);
368
369 closelog_internal ();
370 LogTag = NULL;
371 LogType = SOCK_DGRAM; /* this is the default */
372
373 /* Free the lock. */
374 __libc_cleanup_pop (1);
375 }
376
377 /* setlogmask -- set the log mask level */
378 int
379 setlogmask (int pmask)
380 {
381 int omask;
382
383 /* Protect against multiple users. */
384 __libc_lock_lock (syslog_lock);
385
386 omask = LogMask;
387 if (pmask != 0)
388 LogMask = pmask;
389
390 __libc_lock_unlock (syslog_lock);
391
392 return (omask);
393 }