chiark / gitweb /
Get rid of some more unused defines and dirs
[elogind.git] / src / shared / log.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <errno.h>
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <sys/socket.h>
28 #include <sys/un.h>
29 #include <stddef.h>
30 #include <printf.h>
31
32 #include "log.h"
33 #include "util.h"
34 #include "missing.h"
35 #include "macro.h"
36 #include "socket-util.h"
37
38 #define SNDBUF_SIZE (8*1024*1024)
39
40 static LogTarget log_target = LOG_TARGET_CONSOLE;
41 static int log_max_level = LOG_INFO;
42 static int log_facility = LOG_DAEMON;
43
44 static int console_fd = STDERR_FILENO;
45 static int syslog_fd = -1;
46 static int kmsg_fd = -1;
47 static int journal_fd = -1;
48
49 static bool syslog_is_stream = false;
50
51 static bool show_color = false;
52 static bool show_location = false;
53
54 static bool upgrade_syslog_to_journal = false;
55
56 /* Akin to glibc's __abort_msg; which is private and we hence cannot
57  * use here. */
58 static char *log_abort_msg = NULL;
59
60 void log_close_console(void) {
61
62         if (console_fd < 0)
63                 return;
64
65         if (getpid() == 1) {
66                 if (console_fd >= 3)
67                         safe_close(console_fd);
68
69                 console_fd = -1;
70         }
71 }
72
73 static int log_open_console(void) {
74
75         if (console_fd >= 0)
76                 return 0;
77
78         if (getpid() == 1) {
79                 console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
80                 if (console_fd < 0)
81                         return console_fd;
82         } else
83                 console_fd = STDERR_FILENO;
84
85         return 0;
86 }
87
88 void log_close_kmsg(void) {
89         kmsg_fd = safe_close(kmsg_fd);
90 }
91
92 static int log_open_kmsg(void) {
93
94         if (kmsg_fd >= 0)
95                 return 0;
96
97         kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
98         if (kmsg_fd < 0)
99                 return -errno;
100
101         return 0;
102 }
103
104 void log_close_syslog(void) {
105         syslog_fd = safe_close(syslog_fd);
106 }
107
108 static int create_log_socket(int type) {
109         struct timeval tv;
110         int fd;
111
112         fd = socket(AF_UNIX, type|SOCK_CLOEXEC, 0);
113         if (fd < 0)
114                 return -errno;
115
116         fd_inc_sndbuf(fd, SNDBUF_SIZE);
117
118         /* We need a blocking fd here since we'd otherwise lose
119         messages way too early. However, let's not hang forever in the
120         unlikely case of a deadlock. */
121         if (getpid() == 1)
122                 timeval_store(&tv, 10 * USEC_PER_MSEC);
123         else
124                 timeval_store(&tv, 10 * USEC_PER_SEC);
125         (void) setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
126
127         return fd;
128 }
129
130 static int log_open_syslog(void) {
131
132         static const union sockaddr_union sa = {
133                 .un.sun_family = AF_UNIX,
134                 .un.sun_path = "/dev/log",
135         };
136
137         int r;
138
139         if (syslog_fd >= 0)
140                 return 0;
141
142         syslog_fd = create_log_socket(SOCK_DGRAM);
143         if (syslog_fd < 0) {
144                 r = syslog_fd;
145                 goto fail;
146         }
147
148         if (connect(syslog_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
149                 safe_close(syslog_fd);
150
151                 /* Some legacy syslog systems still use stream
152                  * sockets. They really shouldn't. But what can we
153                  * do... */
154                 syslog_fd = create_log_socket(SOCK_STREAM);
155                 if (syslog_fd < 0) {
156                         r = syslog_fd;
157                         goto fail;
158                 }
159
160                 if (connect(syslog_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
161                         r = -errno;
162                         goto fail;
163                 }
164
165                 syslog_is_stream = true;
166         } else
167                 syslog_is_stream = false;
168
169         return 0;
170
171 fail:
172         log_close_syslog();
173         return r;
174 }
175
176 void log_close_journal(void) {
177         journal_fd = safe_close(journal_fd);
178 }
179
180 static int log_open_journal(void) {
181
182         static const union sockaddr_union sa = {
183                 .un.sun_family = AF_UNIX,
184                 .un.sun_path = "/run/systemd/journal/socket",
185         };
186
187         int r;
188
189         if (journal_fd >= 0)
190                 return 0;
191
192         journal_fd = create_log_socket(SOCK_DGRAM);
193         if (journal_fd < 0) {
194                 r = journal_fd;
195                 goto fail;
196         }
197
198         if (connect(journal_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
199                 r = -errno;
200                 goto fail;
201         }
202
203         return 0;
204
205 fail:
206         log_close_journal();
207         return r;
208 }
209
210 int log_open(void) {
211         int r;
212
213         /* If we don't use the console we close it here, to not get
214          * killed by SAK. If we don't use syslog we close it here so
215          * that we are not confused by somebody deleting the socket in
216          * the fs. If we don't use /dev/kmsg we still keep it open,
217          * because there is no reason to close it. */
218
219         if (log_target == LOG_TARGET_NULL) {
220                 log_close_journal();
221                 log_close_syslog();
222                 log_close_console();
223                 return 0;
224         }
225
226         if ((log_target != LOG_TARGET_AUTO && log_target != LOG_TARGET_SAFE) ||
227             getpid() == 1 ||
228             isatty(STDERR_FILENO) <= 0) {
229
230                 if (log_target == LOG_TARGET_AUTO ||
231                     log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
232                     log_target == LOG_TARGET_JOURNAL) {
233                         r = log_open_journal();
234                         if (r >= 0) {
235                                 log_close_syslog();
236                                 log_close_console();
237                                 return r;
238                         }
239                 }
240
241                 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
242                     log_target == LOG_TARGET_SYSLOG) {
243                         r = log_open_syslog();
244                         if (r >= 0) {
245                                 log_close_journal();
246                                 log_close_console();
247                                 return r;
248                         }
249                 }
250
251                 if (log_target == LOG_TARGET_AUTO ||
252                     log_target == LOG_TARGET_SAFE ||
253                     log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
254                     log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
255                     log_target == LOG_TARGET_KMSG) {
256                         r = log_open_kmsg();
257                         if (r >= 0) {
258                                 log_close_journal();
259                                 log_close_syslog();
260                                 log_close_console();
261                                 return r;
262                         }
263                 }
264         }
265
266         log_close_journal();
267         log_close_syslog();
268
269         return log_open_console();
270 }
271
272 void log_set_target(LogTarget target) {
273         assert(target >= 0);
274         assert(target < _LOG_TARGET_MAX);
275
276         if (upgrade_syslog_to_journal) {
277                 if (target == LOG_TARGET_SYSLOG)
278                         target = LOG_TARGET_JOURNAL;
279                 else if (target == LOG_TARGET_SYSLOG_OR_KMSG)
280                         target = LOG_TARGET_JOURNAL_OR_KMSG;
281         }
282
283         log_target = target;
284 }
285
286 void log_close(void) {
287         log_close_journal();
288         log_close_syslog();
289         log_close_kmsg();
290         log_close_console();
291 }
292
293 void log_forget_fds(void) {
294         console_fd = kmsg_fd = syslog_fd = journal_fd = -1;
295 }
296
297 void log_set_max_level(int level) {
298         assert((level & LOG_PRIMASK) == level);
299
300         log_max_level = level;
301 }
302
303 void log_set_facility(int facility) {
304         log_facility = facility;
305 }
306
307 static int write_to_console(
308                 int level,
309                 int error,
310                 const char *file,
311                 int line,
312                 const char *func,
313                 const char *object_field,
314                 const char *object,
315                 const char *buffer) {
316
317         char location[64], prefix[1 + DECIMAL_STR_MAX(int) + 2];
318         struct iovec iovec[6] = {};
319         unsigned n = 0;
320         bool highlight;
321
322         if (console_fd < 0)
323                 return 0;
324
325         if (log_target == LOG_TARGET_CONSOLE_PREFIXED) {
326                 sprintf(prefix, "<%i>", level);
327                 IOVEC_SET_STRING(iovec[n++], prefix);
328         }
329
330         highlight = LOG_PRI(level) <= LOG_ERR && show_color;
331
332         if (show_location) {
333                 snprintf(location, sizeof(location), "(%s:%i) ", file, line);
334                 IOVEC_SET_STRING(iovec[n++], location);
335         }
336
337         if (highlight)
338                 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_RED_ON);
339         IOVEC_SET_STRING(iovec[n++], buffer);
340         if (highlight)
341                 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_OFF);
342         IOVEC_SET_STRING(iovec[n++], "\n");
343
344         if (writev(console_fd, iovec, n) < 0) {
345
346                 if (errno == EIO && getpid() == 1) {
347
348                         /* If somebody tried to kick us from our
349                          * console tty (via vhangup() or suchlike),
350                          * try to reconnect */
351
352                         log_close_console();
353                         log_open_console();
354
355                         if (console_fd < 0)
356                                 return 0;
357
358                         if (writev(console_fd, iovec, n) < 0)
359                                 return -errno;
360                 } else
361                         return -errno;
362         }
363
364         return 1;
365 }
366
367 static int write_to_syslog(
368                 int level,
369                 int error,
370                 const char *file,
371                 int line,
372                 const char *func,
373                 const char *object_field,
374                 const char *object,
375                 const char *buffer) {
376
377         char header_priority[2 + DECIMAL_STR_MAX(int) + 1],
378              header_time[64],
379              header_pid[4 + DECIMAL_STR_MAX(pid_t) + 1];
380         struct iovec iovec[5] = {};
381         struct msghdr msghdr = {
382                 .msg_iov = iovec,
383                 .msg_iovlen = ELEMENTSOF(iovec),
384         };
385         time_t t;
386         struct tm *tm;
387
388         if (syslog_fd < 0)
389                 return 0;
390
391         xsprintf(header_priority, "<%i>", level);
392
393         t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
394         tm = localtime(&t);
395         if (!tm)
396                 return -EINVAL;
397
398         if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
399                 return -EINVAL;
400
401         xsprintf(header_pid, "["PID_FMT"]: ", getpid());
402
403         IOVEC_SET_STRING(iovec[0], header_priority);
404         IOVEC_SET_STRING(iovec[1], header_time);
405         IOVEC_SET_STRING(iovec[2], program_invocation_short_name);
406         IOVEC_SET_STRING(iovec[3], header_pid);
407         IOVEC_SET_STRING(iovec[4], buffer);
408
409         /* When using syslog via SOCK_STREAM separate the messages by NUL chars */
410         if (syslog_is_stream)
411                 iovec[4].iov_len++;
412
413         for (;;) {
414                 ssize_t n;
415
416                 n = sendmsg(syslog_fd, &msghdr, MSG_NOSIGNAL);
417                 if (n < 0)
418                         return -errno;
419
420                 if (!syslog_is_stream ||
421                     (size_t) n >= IOVEC_TOTAL_SIZE(iovec, ELEMENTSOF(iovec)))
422                         break;
423
424                 IOVEC_INCREMENT(iovec, ELEMENTSOF(iovec), n);
425         }
426
427         return 1;
428 }
429
430 static int write_to_kmsg(
431                 int level,
432                 int error,
433                 const char*file,
434                 int line,
435                 const char *func,
436                 const char *object_field,
437                 const char *object,
438                 const char *buffer) {
439
440         char header_priority[2 + DECIMAL_STR_MAX(int) + 1],
441              header_pid[4 + DECIMAL_STR_MAX(pid_t) + 1];
442         struct iovec iovec[5] = {};
443
444         if (kmsg_fd < 0)
445                 return 0;
446
447         xsprintf(header_priority, "<%i>", level);
448         xsprintf(header_pid, "["PID_FMT"]: ", getpid());
449
450         IOVEC_SET_STRING(iovec[0], header_priority);
451         IOVEC_SET_STRING(iovec[1], program_invocation_short_name);
452         IOVEC_SET_STRING(iovec[2], header_pid);
453         IOVEC_SET_STRING(iovec[3], buffer);
454         IOVEC_SET_STRING(iovec[4], "\n");
455
456         if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
457                 return -errno;
458
459         return 1;
460 }
461
462 static int log_do_header(
463                 char *header,
464                 size_t size,
465                 int level,
466                 int error,
467                 const char *file, int line, const char *func,
468                 const char *object_field, const char *object) {
469
470         snprintf(header, size,
471                  "PRIORITY=%i\n"
472                  "SYSLOG_FACILITY=%i\n"
473                  "%s%s%s"
474                  "%s%.*i%s"
475                  "%s%s%s"
476                  "%s%.*i%s"
477                  "%s%s%s"
478                  "SYSLOG_IDENTIFIER=%s\n",
479                  LOG_PRI(level),
480                  LOG_FAC(level),
481                  isempty(file) ? "" : "CODE_FILE=",
482                  isempty(file) ? "" : file,
483                  isempty(file) ? "" : "\n",
484                  line ? "CODE_LINE=" : "",
485                  line ? 1 : 0, line, /* %.0d means no output too, special case for 0 */
486                  line ? "\n" : "",
487                  isempty(func) ? "" : "CODE_FUNCTION=",
488                  isempty(func) ? "" : func,
489                  isempty(func) ? "" : "\n",
490                  error ? "ERRNO=" : "",
491                  error ? 1 : 0, error,
492                  error ? "\n" : "",
493                  isempty(object) ? "" : object_field,
494                  isempty(object) ? "" : object,
495                  isempty(object) ? "" : "\n",
496                  program_invocation_short_name);
497
498         return 0;
499 }
500
501 static int write_to_journal(
502                 int level,
503                 int error,
504                 const char*file,
505                 int line,
506                 const char *func,
507                 const char *object_field,
508                 const char *object,
509                 const char *buffer) {
510
511         char header[LINE_MAX];
512         struct iovec iovec[4] = {};
513         struct msghdr mh = {};
514
515         if (journal_fd < 0)
516                 return 0;
517
518         log_do_header(header, sizeof(header), level, error, file, line, func, object_field, object);
519
520         IOVEC_SET_STRING(iovec[0], header);
521         IOVEC_SET_STRING(iovec[1], "MESSAGE=");
522         IOVEC_SET_STRING(iovec[2], buffer);
523         IOVEC_SET_STRING(iovec[3], "\n");
524
525         mh.msg_iov = iovec;
526         mh.msg_iovlen = ELEMENTSOF(iovec);
527
528         if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
529                 return -errno;
530
531         return 1;
532 }
533
534 static int log_dispatch(
535                 int level,
536                 int error,
537                 const char *file,
538                 int line,
539                 const char *func,
540                 const char *object_field,
541                 const char *object,
542                 char *buffer) {
543
544         assert(buffer);
545
546         if (log_target == LOG_TARGET_NULL)
547                 return -error;
548
549         /* Patch in LOG_DAEMON facility if necessary */
550         if ((level & LOG_FACMASK) == 0)
551                 level = log_facility | LOG_PRI(level);
552
553         if (error < 0)
554                 error = -error;
555
556         do {
557                 char *e;
558                 int k = 0;
559
560                 buffer += strspn(buffer, NEWLINE);
561
562                 if (buffer[0] == 0)
563                         break;
564
565                 if ((e = strpbrk(buffer, NEWLINE)))
566                         *(e++) = 0;
567
568                 if (log_target == LOG_TARGET_AUTO ||
569                     log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
570                     log_target == LOG_TARGET_JOURNAL) {
571
572                         k = write_to_journal(level, error, file, line, func, object_field, object, buffer);
573                         if (k < 0) {
574                                 if (k != -EAGAIN)
575                                         log_close_journal();
576                                 log_open_kmsg();
577                         }
578                 }
579
580                 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
581                     log_target == LOG_TARGET_SYSLOG) {
582
583                         k = write_to_syslog(level, error, file, line, func, object_field, object, buffer);
584                         if (k < 0) {
585                                 if (k != -EAGAIN)
586                                         log_close_syslog();
587                                 log_open_kmsg();
588                         }
589                 }
590
591                 if (k <= 0 &&
592                     (log_target == LOG_TARGET_AUTO ||
593                      log_target == LOG_TARGET_SAFE ||
594                      log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
595                      log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
596                      log_target == LOG_TARGET_KMSG)) {
597
598                         k = write_to_kmsg(level, error, file, line, func, object_field, object, buffer);
599                         if (k < 0) {
600                                 log_close_kmsg();
601                                 log_open_console();
602                         }
603                 }
604
605                 if (k <= 0)
606                         (void) write_to_console(level, error, file, line, func, object_field, object, buffer);
607
608                 buffer = e;
609         } while (buffer);
610
611         return -error;
612 }
613
614 int log_dump_internal(
615         int level,
616         int error,
617         const char *file,
618         int line,
619         const char *func,
620         char *buffer) {
621
622         PROTECT_ERRNO;
623
624         /* This modifies the buffer... */
625
626         if (error < 0)
627                 error = -error;
628
629         if (_likely_(LOG_PRI(level) > log_max_level))
630                 return -error;
631
632         return log_dispatch(level, error, file, line, func, NULL, NULL, buffer);
633 }
634
635 int log_internalv(
636                 int level,
637                 int error,
638                 const char*file,
639                 int line,
640                 const char *func,
641                 const char *format,
642                 va_list ap) {
643
644         PROTECT_ERRNO;
645         char buffer[LINE_MAX];
646
647         if (error < 0)
648                 error = -error;
649
650         if (_likely_(LOG_PRI(level) > log_max_level))
651                 return -error;
652
653         /* Make sure that %m maps to the specified error */
654         if (error != 0)
655                 errno = error;
656
657         vsnprintf(buffer, sizeof(buffer), format, ap);
658
659         return log_dispatch(level, error, file, line, func, NULL, NULL, buffer);
660 }
661
662 int log_internal(
663                 int level,
664                 int error,
665                 const char*file,
666                 int line,
667                 const char *func,
668                 const char *format, ...) {
669
670         va_list ap;
671         int r;
672
673         va_start(ap, format);
674         r = log_internalv(level, error, file, line, func, format, ap);
675         va_end(ap);
676
677         return r;
678 }
679
680 int log_object_internalv(
681                 int level,
682                 int error,
683                 const char*file,
684                 int line,
685                 const char *func,
686                 const char *object_field,
687                 const char *object,
688                 const char *format,
689                 va_list ap) {
690
691         PROTECT_ERRNO;
692         char buffer[LINE_MAX];
693
694         if (error < 0)
695                 error = -error;
696
697         if (_likely_(LOG_PRI(level) > log_max_level))
698                 return -error;
699
700         /* Make sure that %m maps to the specified error */
701         if (error != 0)
702                 errno = error;
703
704         vsnprintf(buffer, sizeof(buffer), format, ap);
705
706         return log_dispatch(level, error, file, line, func, object_field, object, buffer);
707 }
708
709 int log_object_internal(
710                 int level,
711                 int error,
712                 const char*file,
713                 int line,
714                 const char *func,
715                 const char *object_field,
716                 const char *object,
717                 const char *format, ...) {
718
719         va_list ap;
720         int r;
721
722         va_start(ap, format);
723         r = log_object_internalv(level, error, file, line, func, object_field, object, format, ap);
724         va_end(ap);
725
726         return r;
727 }
728
729 static void log_assert(
730                 int level,
731                 const char *text,
732                 const char *file,
733                 int line,
734                 const char *func,
735                 const char *format) {
736
737         static char buffer[LINE_MAX];
738
739         if (_likely_(LOG_PRI(level) > log_max_level))
740                 return;
741
742         DISABLE_WARNING_FORMAT_NONLITERAL;
743         snprintf(buffer, sizeof(buffer), format, text, file, line, func);
744         REENABLE_WARNING;
745
746         log_abort_msg = buffer;
747
748         log_dispatch(level, 0, file, line, func, NULL, NULL, buffer);
749 }
750
751 noreturn void log_assert_failed(const char *text, const char *file, int line, const char *func) {
752         log_assert(LOG_CRIT, text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Aborting.");
753         abort();
754 }
755
756 noreturn void log_assert_failed_unreachable(const char *text, const char *file, int line, const char *func) {
757         log_assert(LOG_CRIT, text, file, line, func, "Code should not be reached '%s' at %s:%u, function %s(). Aborting.");
758         abort();
759 }
760
761 void log_assert_failed_return(const char *text, const char *file, int line, const char *func) {
762         PROTECT_ERRNO;
763         log_assert(LOG_DEBUG, text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Ignoring.");
764 }
765
766 int log_oom_internal(const char *file, int line, const char *func) {
767         log_internal(LOG_ERR, ENOMEM, file, line, func, "Out of memory.");
768         return -ENOMEM;
769 }
770
771 int log_struct_internal(
772                 int level,
773                 int error,
774                 const char *file,
775                 int line,
776                 const char *func,
777                 const char *format, ...) {
778
779         char buf[LINE_MAX];
780         bool found = false;
781         PROTECT_ERRNO;
782         va_list ap;
783
784         if (error < 0)
785                 error = -error;
786
787         if (_likely_(LOG_PRI(level) > log_max_level))
788                 return -error;
789
790         if (log_target == LOG_TARGET_NULL)
791                 return -error;
792
793         if ((level & LOG_FACMASK) == 0)
794                 level = log_facility | LOG_PRI(level);
795
796         if ((log_target == LOG_TARGET_AUTO ||
797              log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
798              log_target == LOG_TARGET_JOURNAL) &&
799             journal_fd >= 0) {
800                 char header[LINE_MAX];
801                 struct iovec iovec[17] = {};
802                 unsigned n = 0, i;
803                 struct msghdr mh = {
804                         .msg_iov = iovec,
805                 };
806                 static const char nl = '\n';
807                 bool fallback = false;
808
809                 /* If the journal is available do structured logging */
810                 log_do_header(header, sizeof(header), level, error, file, line, func, NULL, NULL);
811                 IOVEC_SET_STRING(iovec[n++], header);
812
813                 va_start(ap, format);
814                 while (format && n + 1 < ELEMENTSOF(iovec)) {
815                         va_list aq;
816                         char *m;
817
818                         /* We need to copy the va_list structure,
819                          * since vasprintf() leaves it afterwards at
820                          * an undefined location */
821
822                         if (error != 0)
823                                 errno = error;
824
825                         va_copy(aq, ap);
826                         if (vasprintf(&m, format, aq) < 0) {
827                                 va_end(aq);
828                                 fallback = true;
829                                 goto finish;
830                         }
831                         va_end(aq);
832
833                         /* Now, jump enough ahead, so that we point to
834                          * the next format string */
835                         VA_FORMAT_ADVANCE(format, ap);
836
837                         IOVEC_SET_STRING(iovec[n++], m);
838
839                         iovec[n].iov_base = (char*) &nl;
840                         iovec[n].iov_len = 1;
841                         n++;
842
843                         format = va_arg(ap, char *);
844                 }
845
846                 mh.msg_iovlen = n;
847
848                 (void) sendmsg(journal_fd, &mh, MSG_NOSIGNAL);
849
850         finish:
851                 va_end(ap);
852                 for (i = 1; i < n; i += 2)
853                         free(iovec[i].iov_base);
854
855                 if (!fallback)
856                         return -error;
857         }
858
859         /* Fallback if journal logging is not available or didn't work. */
860
861         va_start(ap, format);
862         while (format) {
863                 va_list aq;
864
865                 if (error != 0)
866                         errno = error;
867
868                 va_copy(aq, ap);
869                 vsnprintf(buf, sizeof(buf), format, aq);
870                 va_end(aq);
871
872                 if (startswith(buf, "MESSAGE=")) {
873                         found = true;
874                         break;
875                 }
876
877                 VA_FORMAT_ADVANCE(format, ap);
878
879                 format = va_arg(ap, char *);
880         }
881         va_end(ap);
882
883         if (!found)
884                 return -error;
885
886         return log_dispatch(level, error, file, line, func, NULL, NULL, buf + 8);
887 }
888
889 int log_set_target_from_string(const char *e) {
890         LogTarget t;
891
892         t = log_target_from_string(e);
893         if (t < 0)
894                 return -EINVAL;
895
896         log_set_target(t);
897         return 0;
898 }
899
900 int log_set_max_level_from_string(const char *e) {
901         int t;
902
903         t = log_level_from_string(e);
904         if (t < 0)
905                 return t;
906
907         log_set_max_level(t);
908         return 0;
909 }
910
911 static int parse_proc_cmdline_item(const char *key, const char *value) {
912
913         /*
914          * The systemd.log_xyz= settings are parsed by all tools, and
915          * so is "debug".
916          *
917          * However, "quiet" is only parsed by PID 1, and only turns of
918          * status output to /dev/console, but does not alter the log
919          * level.
920          */
921
922         if (streq(key, "debug") && !value)
923                 log_set_max_level(LOG_DEBUG);
924
925         else if (streq(key, "systemd.log_target") && value) {
926
927                 if (log_set_target_from_string(value) < 0)
928                         log_warning("Failed to parse log target '%s'. Ignoring.", value);
929
930         } else if (streq(key, "systemd.log_level") && value) {
931
932                 if (log_set_max_level_from_string(value) < 0)
933                         log_warning("Failed to parse log level '%s'. Ignoring.", value);
934
935         } else if (streq(key, "systemd.log_color") && value) {
936
937                 if (log_show_color_from_string(value) < 0)
938                         log_warning("Failed to parse log color setting '%s'. Ignoring.", value);
939
940         } else if (streq(key, "systemd.log_location") && value) {
941
942                 if (log_show_location_from_string(value) < 0)
943                         log_warning("Failed to parse log location setting '%s'. Ignoring.", value);
944         }
945
946         return 0;
947 }
948
949 void log_parse_environment(void) {
950         const char *e;
951
952         if (get_ctty_devnr(0, NULL) < 0)
953                 /* Only try to read the command line in daemons.
954                    We assume that anything that has a controlling
955                    tty is user stuff. */
956                 (void) parse_proc_cmdline(parse_proc_cmdline_item);
957
958         e = secure_getenv("SYSTEMD_LOG_TARGET");
959         if (e && log_set_target_from_string(e) < 0)
960                 log_warning("Failed to parse log target '%s'. Ignoring.", e);
961
962         e = secure_getenv("SYSTEMD_LOG_LEVEL");
963         if (e && log_set_max_level_from_string(e) < 0)
964                 log_warning("Failed to parse log level '%s'. Ignoring.", e);
965
966         e = secure_getenv("SYSTEMD_LOG_COLOR");
967         if (e && log_show_color_from_string(e) < 0)
968                 log_warning("Failed to parse bool '%s'. Ignoring.", e);
969
970         e = secure_getenv("SYSTEMD_LOG_LOCATION");
971         if (e && log_show_location_from_string(e) < 0)
972                 log_warning("Failed to parse bool '%s'. Ignoring.", e);
973 }
974
975 LogTarget log_get_target(void) {
976         return log_target;
977 }
978
979 int log_get_max_level(void) {
980         return log_max_level;
981 }
982
983 void log_show_color(bool b) {
984         show_color = b;
985 }
986
987 bool log_get_show_color(void) {
988         return show_color;
989 }
990
991 void log_show_location(bool b) {
992         show_location = b;
993 }
994
995 bool log_get_show_location(void) {
996         return show_location;
997 }
998
999 int log_show_color_from_string(const char *e) {
1000         int t;
1001
1002         t = parse_boolean(e);
1003         if (t < 0)
1004                 return t;
1005
1006         log_show_color(t);
1007         return 0;
1008 }
1009
1010 int log_show_location_from_string(const char *e) {
1011         int t;
1012
1013         t = parse_boolean(e);
1014         if (t < 0)
1015                 return t;
1016
1017         log_show_location(t);
1018         return 0;
1019 }
1020
1021 bool log_on_console(void) {
1022         if (log_target == LOG_TARGET_CONSOLE ||
1023             log_target == LOG_TARGET_CONSOLE_PREFIXED)
1024                 return true;
1025
1026         return syslog_fd < 0 && kmsg_fd < 0 && journal_fd < 0;
1027 }
1028
1029 static const char *const log_target_table[_LOG_TARGET_MAX] = {
1030         [LOG_TARGET_CONSOLE] = "console",
1031         [LOG_TARGET_CONSOLE_PREFIXED] = "console-prefixed",
1032         [LOG_TARGET_KMSG] = "kmsg",
1033         [LOG_TARGET_JOURNAL] = "journal",
1034         [LOG_TARGET_JOURNAL_OR_KMSG] = "journal-or-kmsg",
1035         [LOG_TARGET_SYSLOG] = "syslog",
1036         [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
1037         [LOG_TARGET_AUTO] = "auto",
1038         [LOG_TARGET_SAFE] = "safe",
1039         [LOG_TARGET_NULL] = "null"
1040 };
1041
1042 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);
1043
1044 void log_received_signal(int level, const struct signalfd_siginfo *si) {
1045         if (si->ssi_pid > 0) {
1046                 _cleanup_free_ char *p = NULL;
1047
1048                 get_process_comm(si->ssi_pid, &p);
1049
1050                 log_full(level,
1051                          "Received SIG%s from PID %"PRIu32" (%s).",
1052                          signal_to_string(si->ssi_signo),
1053                          si->ssi_pid, strna(p));
1054         } else
1055                 log_full(level,
1056                          "Received SIG%s.",
1057                          signal_to_string(si->ssi_signo));
1058
1059 }
1060
1061 void log_set_upgrade_syslog_to_journal(bool b) {
1062         upgrade_syslog_to_journal = b;
1063 }