1 /* Basic tests for syslog interfaces.
2 Copyright (C) 2022-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <array_length.h>
20 #include <fcntl.h>
21 #include <paths.h>
22 #include <netinet/in.h>
23 #include <support/capture_subprocess.h>
24 #include <support/check.h>
25 #include <support/xstdio.h>
26 #include <support/xsocket.h>
27 #include <support/xunistd.h>
28 #include <stdarg.h>
29 #include <stdbool.h>
30 #include <stddef.h>
31 #include <stdlib.h>
32 #include <syslog.h>
33 #include <sys/un.h>
34
35 static const int facilities[] =
36 {
37 LOG_KERN,
38 LOG_USER,
39 LOG_MAIL,
40 LOG_DAEMON,
41 LOG_AUTH,
42 LOG_SYSLOG,
43 LOG_LPR,
44 LOG_NEWS,
45 LOG_UUCP,
46 LOG_CRON,
47 LOG_AUTHPRIV,
48 LOG_FTP,
49 LOG_LOCAL0,
50 LOG_LOCAL1,
51 LOG_LOCAL2,
52 LOG_LOCAL3,
53 LOG_LOCAL4,
54 LOG_LOCAL5,
55 LOG_LOCAL6,
56 LOG_LOCAL7,
57 };
58
59 static const int priorities[] =
60 {
61 LOG_EMERG,
62 LOG_ALERT,
63 LOG_CRIT,
64 LOG_ERR,
65 LOG_WARNING,
66 LOG_NOTICE,
67 LOG_INFO,
68 LOG_DEBUG
69 };
70
71 #define IDENT_LENGTH 64
72 #define MSG_LENGTH 1024
73
74 #define SYSLOG_MSG_BASE "syslog_message"
75 #define OPENLOG_IDENT "openlog_ident"
76 static char large_message[MSG_LENGTH];
77
78 struct msg_t
79 {
80 int priority;
81 int facility;
82 char ident[IDENT_LENGTH];
83 char msg[MSG_LENGTH];
84 pid_t pid;
85 };
86
87 static void
88 call_vsyslog (int priority, const char *format, ...)
89 {
90 va_list ap;
91 va_start (ap, format);
92 vsyslog (priority, format, ap);
93 va_end (ap);
94 }
95
96 static void
97 send_vsyslog (int options)
98 {
99 for (size_t i = 0; i < array_length (facilities); i++)
100 {
101 for (size_t j = 0; j < array_length (priorities); j++)
102 {
103 int facility = facilities[i];
104 int priority = priorities[j];
105 call_vsyslog (facility | priority, "%s %d %d", SYSLOG_MSG_BASE,
106 facility, priority);
107 }
108 }
109 }
110
111 static void
112 send_syslog (int options)
113 {
114 for (size_t i = 0; i < array_length (facilities); i++)
115 {
116 for (size_t j = 0; j < array_length (priorities); j++)
117 {
118 int facility = facilities[i];
119 int priority = priorities[j];
120 syslog (facility | priority, "%s %d %d", SYSLOG_MSG_BASE, facility,
121 priority);
122 }
123 }
124 }
125
126 static bool
127 check_syslog_message (const struct msg_t *msg, int msgnum, int options,
128 pid_t pid)
129 {
130 if (msgnum == array_length (facilities) * array_length (priorities) - 1)
131 return false;
132
133 int i = msgnum / array_length (priorities);
134 int j = msgnum % array_length (priorities);
135
136 int expected_facility = facilities[i];
137 /* With no preceding openlog, syslog default to LOG_USER. */
138 if (expected_facility == LOG_KERN)
139 expected_facility = LOG_USER;
140 int expected_priority = priorities[j];
141
142 TEST_COMPARE (msg->facility, expected_facility);
143 TEST_COMPARE (msg->priority, expected_priority);
144
145 return true;
146 }
147
148 static void
149 send_syslog_large (int options)
150 {
151 int facility = LOG_USER;
152 int priority = LOG_INFO;
153
154 syslog (facility | priority, "%s %d %d", large_message, facility,
155 priority);
156 }
157
158 static void
159 send_vsyslog_large (int options)
160 {
161 int facility = LOG_USER;
162 int priority = LOG_INFO;
163
164 call_vsyslog (facility | priority, "%s %d %d", large_message, facility,
165 priority);
166 }
167
168 static bool
169 check_syslog_message_large (const struct msg_t *msg, int msgnum, int options,
170 pid_t pid)
171 {
172 TEST_COMPARE (msg->facility, LOG_USER);
173 TEST_COMPARE (msg->priority, LOG_INFO);
174 TEST_COMPARE_STRING (msg->msg, large_message);
175
176 return false;
177 }
178
179 static void
180 send_openlog (int options)
181 {
182 /* Define a non-default IDENT and a not default facility. */
183 openlog (OPENLOG_IDENT, options, LOG_LOCAL0);
184 for (size_t j = 0; j < array_length (priorities); j++)
185 {
186 int priority = priorities[j];
187 syslog (priority, "%s %d %d", SYSLOG_MSG_BASE, LOG_LOCAL0, priority);
188 }
189 closelog ();
190
191 /* Back to the default IDENT with a non default facility. */
192 openlog (NULL, 0, LOG_LOCAL6);
193 for (size_t j = 0; j < array_length (priorities); j++)
194 {
195 int priority = priorities[j];
196 syslog (LOG_LOCAL7 | priority, "%s %d %d", SYSLOG_MSG_BASE, LOG_LOCAL7,
197 priority);
198 }
199 closelog ();
200
201 /* LOG_KERN does not change the internal default facility. */
202 openlog (NULL, 0, LOG_KERN);
203 for (size_t j = 0; j < array_length (priorities); j++)
204 {
205 int priority = priorities[j];
206 syslog (priority, "%s %d %d", SYSLOG_MSG_BASE, LOG_KERN, priority);
207 }
208 closelog ();
209 }
210
211 static void
212 send_openlog_large (int options)
213 {
214 /* Define a non-default IDENT and a not default facility. */
215 openlog (OPENLOG_IDENT, options, LOG_LOCAL0);
216
217 syslog (LOG_INFO, "%s %d %d", large_message, LOG_LOCAL0, LOG_INFO);
218
219 closelog ();
220 }
221
222 static bool
223 check_openlog_message (const struct msg_t *msg, int msgnum,
224 int options, pid_t pid)
225 {
226 if (msgnum == 3 * array_length (priorities) - 1)
227 return false;
228
229 int expected_priority = priorities[msgnum % array_length (priorities)];
230 TEST_COMPARE (msg->priority, expected_priority);
231
232 char expected_ident[IDENT_LENGTH];
233 snprintf (expected_ident, sizeof (expected_ident), "%s%s%.0d%s:",
234 OPENLOG_IDENT,
235 options & LOG_PID ? "[" : "",
236 options & LOG_PID ? pid : 0,
237 options & LOG_PID ? "]" : "");
238
239 if (msgnum < array_length (priorities))
240 {
241 if (options & LOG_PID)
242 TEST_COMPARE (msg->pid, pid);
243 TEST_COMPARE_STRING (msg->ident, expected_ident);
244 TEST_COMPARE (msg->facility, LOG_LOCAL0);
245 }
246 else if (msgnum < 2 * array_length (priorities))
247 TEST_COMPARE (msg->facility, LOG_LOCAL7);
248 else if (msgnum < 3 * array_length (priorities))
249 TEST_COMPARE (msg->facility, LOG_KERN);
250
251 return true;
252 }
253
254 static bool
255 check_openlog_message_large (const struct msg_t *msg, int msgnum,
256 int options, pid_t pid)
257 {
258 char expected_ident[IDENT_LENGTH];
259 snprintf (expected_ident, sizeof (expected_ident), "%s%s%.0d%s:",
260 OPENLOG_IDENT,
261 options & LOG_PID ? "[" : "",
262 options & LOG_PID ? pid : 0,
263 options & LOG_PID ? "]" : "");
264
265 TEST_COMPARE_STRING (msg->ident, expected_ident);
266 TEST_COMPARE_STRING (msg->msg, large_message);
267 TEST_COMPARE (msg->priority, LOG_INFO);
268 TEST_COMPARE (msg->facility, LOG_LOCAL0);
269
270 return false;
271 }
272
273 static struct msg_t
274 parse_syslog_msg (const char *msg)
275 {
276 struct msg_t r = { .pid = -1 };
277 int number;
278 int wsb, wsa;
279
280 #define STRINPUT(size) XSTRINPUT(size)
281 #define XSTRINPUT(size) "%" # size "s"
282
283 /* The message in the form:
284 <179>Apr 8 14:51:19 tst-syslog: message 176 3 */
285 int n = sscanf (msg, "<%3d>%*s %*d %*d:%*d:%*d%n %n" STRINPUT(IDENT_LENGTH)
286 " " STRINPUT(MSG_LENGTH) " %*d %*d",
287 &number, &wsb, &wsa, r.ident, r.msg);
288 TEST_COMPARE (n, 3);
289 /* It should only one space between timestamp and message. */
290 TEST_COMPARE (wsa - wsb, 1);
291
292 r.facility = number & LOG_FACMASK;
293 r.priority = number & LOG_PRIMASK;
294
295 char *pid_start = strchr (r.ident, '[');
296 if (pid_start != NULL)
297 {
298 char *pid_end = strchr (r.ident, ']');
299 if (pid_end != NULL)
300 r.pid = strtoul (pid_start + 1, NULL, 10);
301 }
302
303 return r;
304 }
305
306 static struct msg_t
307 parse_syslog_console (const char *msg)
308 {
309 int priority;
310 int facility;
311 struct msg_t r;
312
313 /* The message in the form:
314 openlog_ident: syslog_message 128 0 */
315 int n = sscanf (msg, STRINPUT(IDENT_LENGTH) " " STRINPUT(MSG_LENGTH) " %d %d",
316 r.ident, r.msg, &facility, &priority);
317 TEST_COMPARE (n, 4);
318
319 r.facility = facility;
320 r.priority = priority;
321
322 return r;
323 }
324
325 static void
326 check_syslog_udp (void (*syslog_send)(int), int options,
327 bool (*syslog_check)(const struct msg_t *, int, int,
328 pid_t))
329 {
330 struct sockaddr_un addr =
331 {
332 .sun_family = AF_UNIX,
333 .sun_path = _PATH_LOG
334 };
335
336 socklen_t addrlen = sizeof (addr);
337 int server_udp = xsocket (AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0);
338 xbind (server_udp, (struct sockaddr *) &addr, addrlen);
339
340 pid_t sender_pid = xfork ();
341 if (sender_pid == 0)
342 {
343 syslog_send (options);
344 _exit (0);
345 }
346
347 int msgnum = 0;
348 while (1)
349 {
350 char buf[2048];
351 size_t l = xrecvfrom (server_udp, buf, sizeof (buf), 0,
352 (struct sockaddr *) &addr, &addrlen);
353 buf[l] = '\0';
354
355 struct msg_t msg = parse_syslog_msg (buf);
356 if (!syslog_check (&msg, msgnum++, options, sender_pid))
357 break;
358 }
359
360 xclose (server_udp);
361
362 int status;
363 xwaitpid (sender_pid, &status, 0);
364 TEST_COMPARE (status, 0);
365
366 unlink (_PATH_LOG);
367 }
368
369 static void
370 check_syslog_tcp (void (*syslog_send)(int), int options,
371 bool (*syslog_check)(const struct msg_t *, int, int,
372 pid_t))
373 {
374 struct sockaddr_un addr =
375 {
376 .sun_family = AF_UNIX,
377 .sun_path = _PATH_LOG
378 };
379 socklen_t addrlen = sizeof (addr);
380
381 int server_tcp = xsocket (AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
382 xbind (server_tcp, (struct sockaddr *) &addr, addrlen);
383 xlisten (server_tcp, 5);
384
385 pid_t sender_pid = xfork ();
386 if (sender_pid == 0)
387 {
388 syslog_send (options);
389 _exit (0);
390 }
391
392 int client_tcp = xaccept (server_tcp, NULL, NULL);
393
394 char buf[2048], *rb = buf;
395 size_t rbl = sizeof (buf);
396 size_t prl = 0; /* Track the size of the partial record. */
397 int msgnum = 0;
398
399 while (1)
400 {
401 size_t rl = xrecvfrom (client_tcp, rb, rbl - prl, 0, NULL, NULL);
402 if (rl == 0)
403 break;
404
405 /* Iterate over the buffer to find and check the record. */
406 size_t l = rl + prl;
407 char *b = buf;
408 while (1)
409 {
410 /* With TCP each record ends with a '\0'. */
411 char *e = memchr (b, '\0', l);
412 if (e != NULL)
413 {
414 struct msg_t msg = parse_syslog_msg (b);
415 if (!syslog_check (&msg, msgnum++, options, sender_pid))
416 break;
417
418 /* Advance to the next record. */
419 ptrdiff_t diff = e + 1 - b;
420 b += diff;
421 l -= diff;
422 }
423 else
424 {
425 /* Move the partial record to the start of the buffer. */
426 memmove (buf, b, l);
427 rb = buf + l;
428 prl = l;
429 break;
430 }
431 }
432 }
433
434 xclose (client_tcp);
435 xclose (server_tcp);
436
437 int status;
438 xwaitpid (sender_pid, &status, 0);
439 TEST_COMPARE (status, 0);
440
441 unlink (_PATH_LOG);
442 }
443
444 static void
445 check_syslog_console_read (FILE *fp)
446 {
447 char buf[512];
448 int msgnum = 0;
449 while (fgets (buf, sizeof (buf), fp) != NULL)
450 {
451 struct msg_t msg = parse_syslog_console (buf);
452 TEST_COMPARE_STRING (msg.ident, OPENLOG_IDENT ":");
453 TEST_COMPARE (msg.priority, priorities[msgnum]);
454 TEST_COMPARE (msg.facility, LOG_LOCAL0);
455
456 if (++msgnum == array_length (priorities))
457 break;
458 }
459 }
460
461 static void
462 check_syslog_console_read_large (FILE *fp)
463 {
464 char buf[2048];
465 TEST_VERIFY (fgets (buf, sizeof (buf), fp) != NULL);
466 struct msg_t msg = parse_syslog_console (buf);
467
468 TEST_COMPARE_STRING (msg.ident, OPENLOG_IDENT ":");
469 TEST_COMPARE_STRING (msg.msg, large_message);
470 TEST_COMPARE (msg.priority, LOG_INFO);
471 TEST_COMPARE (msg.facility, LOG_LOCAL0);
472 }
473
474 static void
475 check_syslog_console (void (*syslog_send)(int),
476 void (*syslog_check)(FILE *fp))
477 {
478 xmkfifo (_PATH_CONSOLE, 0666);
479
480 pid_t sender_pid = xfork ();
481 if (sender_pid == 0)
482 {
483 syslog_send (LOG_CONS);
484 _exit (0);
485 }
486
487 {
488 FILE *fp = xfopen (_PATH_CONSOLE, "r+");
489 syslog_check (fp);
490 xfclose (fp);
491 }
492
493 int status;
494 xwaitpid (sender_pid, &status, 0);
495 TEST_COMPARE (status, 0);
496
497 unlink (_PATH_CONSOLE);
498 }
499
500 static void
501 send_openlog_callback (void *clousure)
502 {
503 int options = *(int *) clousure;
504 send_openlog (options);
505 }
506
507 static void
508 send_openlog_callback_large (void *clousure)
509 {
510 int options = *(int *) clousure;
511 send_openlog_large (options);
512 }
513
514 static void
515 check_syslog_perror (bool large)
516 {
517 struct support_capture_subprocess result;
518 result = support_capture_subprocess (large
519 ? send_openlog_callback_large
520 : send_openlog_callback,
521 &(int){LOG_PERROR});
522
523 FILE *mfp = fmemopen (result.err.buffer, result.err.length, "r");
524 if (mfp == NULL)
525 FAIL_EXIT1 ("fmemopen: %m");
526 if (large)
527 check_syslog_console_read_large (mfp);
528 else
529 check_syslog_console_read (mfp);
530 xfclose (mfp);
531
532 support_capture_subprocess_check (&result, "tst-openlog-child", 0,
533 sc_allow_stderr);
534 support_capture_subprocess_free (&result);
535 }
536
537 static int
538 do_test (void)
539 {
540 /* Send every combination of facility/priority over UDP and TCP. */
541 check_syslog_udp (send_syslog, 0, check_syslog_message);
542 check_syslog_tcp (send_syslog, 0, check_syslog_message);
543
544 /* Also check vsyslog. */
545 check_syslog_udp (send_vsyslog, 0, check_syslog_message);
546 check_syslog_tcp (send_vsyslog, 0, check_syslog_message);
547
548 /* Run some openlog/syslog/closelog combinations. */
549 check_syslog_udp (send_openlog, 0, check_openlog_message);
550 check_syslog_tcp (send_openlog, 0, check_openlog_message);
551
552 /* Check the LOG_PID option. */
553 check_syslog_udp (send_openlog, LOG_PID, check_openlog_message);
554 check_syslog_tcp (send_openlog, LOG_PID, check_openlog_message);
555
556 /* Check the LOG_CONS option. */
557 check_syslog_console (send_openlog, check_syslog_console_read);
558
559 /* Check the LOG_PERROR option. */
560 check_syslog_perror (false);
561
562 /* Similar tests as before, but with a large message to trigger the
563 syslog path that uses dynamically allocated memory. */
564 memset (large_message, 'a', sizeof large_message - 1);
565 large_message[sizeof large_message - 1] = '\0';
566
567 check_syslog_udp (send_syslog_large, 0, check_syslog_message_large);
568 check_syslog_tcp (send_syslog_large, 0, check_syslog_message_large);
569
570 check_syslog_udp (send_vsyslog_large, 0, check_syslog_message_large);
571 check_syslog_tcp (send_vsyslog_large, 0, check_syslog_message_large);
572
573 check_syslog_udp (send_openlog_large, 0, check_openlog_message_large);
574 check_syslog_tcp (send_openlog_large, 0, check_openlog_message_large);
575
576 check_syslog_udp (send_openlog_large, LOG_PID, check_openlog_message_large);
577 check_syslog_tcp (send_openlog_large, LOG_PID, check_openlog_message_large);
578
579 check_syslog_console (send_openlog_large, check_syslog_console_read_large);
580
581 check_syslog_perror (true);
582
583 return 0;
584 }
585
586 #include <support/test-driver.c>