src/basic/log.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <inttypes.h>
  24 #include <limits.h>
  25 #include <stdarg.h>
  26 #include <stddef.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <sys/signalfd.h>
  30 #include <sys/socket.h>
  31 #include <sys/time.h>
  32 #include <sys/uio.h>
  33 #include <sys/un.h>
  34 #include <time.h>
  35 #include <unistd.h>
  36
  37 #include "sd-messages.h"
  38
  39 #include "alloc-util.h"
  40 #include "fd-util.h"
  41 #include "format-util.h"
  42 #include "io-util.h"
  43 #include "log.h"
  44 #include "macro.h"
  45 #include "missing.h"
  46 #include "parse-util.h"
  47 #include "proc-cmdline.h"
  48 #include "process-util.h"
  49 #include "signal-util.h"
  50 #include "socket-util.h"
  51 #include "stdio-util.h"
  52 #include "string-table.h"
  53 #include "string-util.h"
  54 #include "syslog-util.h"
  55 #include "terminal-util.h"
  56 #include "time-util.h"
  57 #include "utf8.h"
  58 #include "util.h"
  59
  60 #define SNDBUF_SIZE (8*1024*1024)
  61
  62 static LogTarget log_target = LOG_TARGET_CONSOLE;
  63 static int log_max_level[] = {LOG_INFO, LOG_INFO};
  64 assert_cc(ELEMENTSOF(log_max_level) == _LOG_REALM_MAX);
  65 static int log_facility = LOG_DAEMON;
  66
  67 static int console_fd = STDERR_FILENO;
  68 static int syslog_fd = -1;
  69 static int kmsg_fd = -1;
  70 static int journal_fd = -1;
  71
  72 static bool syslog_is_stream = false;
  73
  74 static bool show_color = false;
  75 static bool show_location = false;
  76
  77 static bool upgrade_syslog_to_journal = false;
  78 static bool always_reopen_console = false;
  79 static bool open_when_needed = false;
  80 static bool prohibit_ipc = false;
  81
  82 /* Akin to glibc's __abort_msg; which is private and we hence cannot
  83  * use here. */
  84 static char *log_abort_msg = NULL;
  85
  86 /* An assert to use in logging functions that does not call recursively
  87  * into our logging functions (since that might lead to a loop). */
  88 #define assert_raw(expr)                                                \
  89         do {                                                            \
  90                 if (_unlikely_(!(expr))) {                              \
  91                         fputs(#expr "\n", stderr);                      \
  92                         abort();                                        \
  93                 }                                                       \
  94         } while (false)
  95
  96 static void log_close_console(void) {
  97         console_fd = safe_close_above_stdio(console_fd);
  98 }
  99
 100 static int log_open_console(void) {
 101
 102         if (!always_reopen_console) {
 103                 console_fd = STDERR_FILENO;
 104                 return 0;
 105         }
 106
 107         if (console_fd < 3) {
 108                 console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
 109                 if (console_fd < 0)
 110                         return console_fd;
 111
 112                 console_fd = fd_move_above_stdio(console_fd);
 113         }
 114
 115         return 0;
 116 }
 117
 118 static void log_close_kmsg(void) {
 119         kmsg_fd = safe_close(kmsg_fd);
 120 }
 121
 122 static int log_open_kmsg(void) {
 123
 124         if (kmsg_fd >= 0)
 125                 return 0;
 126
 127         kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
 128         if (kmsg_fd < 0)
 129                 return -errno;
 130
 131         kmsg_fd = fd_move_above_stdio(kmsg_fd);
 132         return 0;
 133 }
 134
 135 static void log_close_syslog(void) {
 136         syslog_fd = safe_close(syslog_fd);
 137 }
 138
 139 static int create_log_socket(int type) {
 140         struct timeval tv;
 141         int fd;
 142
 143         fd = socket(AF_UNIX, type|SOCK_CLOEXEC, 0);
 144         if (fd < 0)
 145                 return -errno;
 146
 147         fd = fd_move_above_stdio(fd);
 148         (void) fd_inc_sndbuf(fd, SNDBUF_SIZE);
 149
 150         /* We need a blocking fd here since we'd otherwise lose messages way too early. However, let's not hang forever
 151          * in the unlikely case of a deadlock. */
 152         if (getpid_cached() == 1)
 153                 timeval_store(&tv, 10 * USEC_PER_MSEC);
 154         else
 155                 timeval_store(&tv, 10 * USEC_PER_SEC);
 156         (void) setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
 157
 158         return fd;
 159 }
 160
 161 static int log_open_syslog(void) {
 162
 163         static const union sockaddr_union sa = {
 164                 .un.sun_family = AF_UNIX,
 165                 .un.sun_path = "/dev/log",
 166         };
 167
 168         int r;
 169
 170         if (syslog_fd >= 0)
 171                 return 0;
 172
 173         syslog_fd = create_log_socket(SOCK_DGRAM);
 174         if (syslog_fd < 0) {
 175                 r = syslog_fd;
 176                 goto fail;
 177         }
 178
 179         if (connect(syslog_fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
 180                 safe_close(syslog_fd);
 181
 182                 /* Some legacy syslog systems still use stream
 183                  * sockets. They really shouldn't. But what can we
 184                  * do... */
 185                 syslog_fd = create_log_socket(SOCK_STREAM);
 186                 if (syslog_fd < 0) {
 187                         r = syslog_fd;
 188                         goto fail;
 189                 }
 190
 191                 if (connect(syslog_fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
 192                         r = -errno;
 193                         goto fail;
 194                 }
 195
 196                 syslog_is_stream = true;
 197         } else
 198                 syslog_is_stream = false;
 199
 200         return 0;
 201
 202 fail:
 203         log_close_syslog();
 204         return r;
 205 }
 206
 207 static void log_close_journal(void) {
 208         journal_fd = safe_close(journal_fd);
 209 }
 210
 211 static int log_open_journal(void) {
 212
 213         static const union sockaddr_union sa = {
 214                 .un.sun_family = AF_UNIX,
 215                 .un.sun_path = "/run/systemd/journal/socket",
 216         };
 217
 218         int r;
 219
 220         if (journal_fd >= 0)
 221                 return 0;
 222
 223         journal_fd = create_log_socket(SOCK_DGRAM);
 224         if (journal_fd < 0) {
 225                 r = journal_fd;
 226                 goto fail;
 227         }
 228
 229         if (connect(journal_fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
 230                 r = -errno;
 231                 goto fail;
 232         }
 233
 234         return 0;
 235
 236 fail:
 237         log_close_journal();
 238         return r;
 239 }
 240
 241 int log_open(void) {
 242         int r;
 243
 244         /* Do not call from library code. */
 245
 246         /* If we don't use the console we close it here, to not get
 247          * killed by SAK. If we don't use syslog we close it here so
 248          * that we are not confused by somebody deleting the socket in
 249          * the fs, and to make sure we don't use it if prohibit_ipc is
 250          * set. If we don't use /dev/kmsg we still keep it open,
 251          * because there is no reason to close it. */
 252
 253         if (log_target == LOG_TARGET_NULL) {
 254                 log_close_journal();
 255                 log_close_syslog();
 256                 log_close_console();
 257                 return 0;
 258         }
 259
 260         if (log_target != LOG_TARGET_AUTO ||
 261             getpid_cached() == 1 ||
 262             isatty(STDERR_FILENO) <= 0) {
 263
 264                 if (!prohibit_ipc &&
 265                     IN_SET(log_target, LOG_TARGET_AUTO,
 266                                        LOG_TARGET_JOURNAL_OR_KMSG,
 267                                        LOG_TARGET_JOURNAL)) {
 268                         r = log_open_journal();
 269                         if (r >= 0) {
 270                                 log_close_syslog();
 271                                 log_close_console();
 272                                 return r;
 273                         }
 274                 }
 275
 276                 if (!prohibit_ipc &&
 277                     IN_SET(log_target, LOG_TARGET_SYSLOG_OR_KMSG,
 278                                        LOG_TARGET_SYSLOG)) {
 279                         r = log_open_syslog();
 280                         if (r >= 0) {
 281                                 log_close_journal();
 282                                 log_close_console();
 283                                 return r;
 284                         }
 285                 }
 286
 287                 if (IN_SET(log_target, LOG_TARGET_AUTO,
 288                                        LOG_TARGET_JOURNAL_OR_KMSG,
 289                                        LOG_TARGET_SYSLOG_OR_KMSG,
 290                                        LOG_TARGET_KMSG)) {
 291                         r = log_open_kmsg();
 292                         if (r >= 0) {
 293                                 log_close_journal();
 294                                 log_close_syslog();
 295                                 log_close_console();
 296                                 return r;
 297                         }
 298                 }
 299         }
 300
 301         log_close_journal();
 302         log_close_syslog();
 303
 304         return log_open_console();
 305 }
 306
 307 void log_set_target(LogTarget target) {
 308         assert(target >= 0);
 309         assert(target < _LOG_TARGET_MAX);
 310
 311         if (upgrade_syslog_to_journal) {
 312                 if (target == LOG_TARGET_SYSLOG)
 313                         target = LOG_TARGET_JOURNAL;
 314                 else if (target == LOG_TARGET_SYSLOG_OR_KMSG)
 315                         target = LOG_TARGET_JOURNAL_OR_KMSG;
 316         }
 317
 318         log_target = target;
 319 }
 320
 321 void log_close(void) {
 322         /* Do not call from library code. */
 323
 324         log_close_journal();
 325         log_close_syslog();
 326         log_close_kmsg();
 327         log_close_console();
 328 }
 329
 330 void log_forget_fds(void) {
 331         /* Do not call from library code. */
 332
 333         console_fd = kmsg_fd = syslog_fd = journal_fd = -1;
 334 }
 335
 336 void log_set_max_level_realm(LogRealm realm, int level) {
 337         assert((level & LOG_PRIMASK) == level);
 338         assert(realm < ELEMENTSOF(log_max_level));
 339
 340         log_max_level[realm] = level;
 341 }
 342
 343 void log_set_facility(int facility) {
 344         log_facility = facility;
 345 }
 346
 347 static int write_to_console(
 348                 int level,
 349                 int error,
 350                 const char *file,
 351                 int line,
 352                 const char *func,
 353                 const char *buffer) {
 354
 355         char location[256], prefix[1 + DECIMAL_STR_MAX(int) + 2];
 356         struct iovec iovec[6] = {};
 357         unsigned n = 0;
 358         bool highlight;
 359
 360         if (console_fd < 0)
 361                 return 0;
 362
 363         if (log_target == LOG_TARGET_CONSOLE_PREFIXED) {
 364                 xsprintf(prefix, "<%i>", level);
 365                 iovec[n++] = IOVEC_MAKE_STRING(prefix);
 366         }
 367
 368         highlight = LOG_PRI(level) <= LOG_ERR && show_color;
 369
 370         if (show_location) {
 371                 (void) snprintf(location, sizeof location, "(%s:%i) ", file, line);
 372                 iovec[n++] = IOVEC_MAKE_STRING(location);
 373         }
 374
 375         if (highlight)
 376                 iovec[n++] = IOVEC_MAKE_STRING(ANSI_HIGHLIGHT_RED);
 377         iovec[n++] = IOVEC_MAKE_STRING(buffer);
 378         if (highlight)
 379                 iovec[n++] = IOVEC_MAKE_STRING(ANSI_NORMAL);
 380         iovec[n++] = IOVEC_MAKE_STRING("\n");
 381
 382         if (writev(console_fd, iovec, n) < 0) {
 383
 384                 if (errno == EIO && getpid_cached() == 1) {
 385
 386                         /* If somebody tried to kick us from our
 387                          * console tty (via vhangup() or suchlike),
 388                          * try to reconnect */
 389
 390                         log_close_console();
 391                         log_open_console();
 392
 393                         if (console_fd < 0)
 394                                 return 0;
 395
 396                         if (writev(console_fd, iovec, n) < 0)
 397                                 return -errno;
 398                 } else
 399                         return -errno;
 400         }
 401
 402         return 1;
 403 }
 404
 405 static int write_to_syslog(
 406                 int level,
 407                 int error,
 408                 const char *file,
 409                 int line,
 410                 const char *func,
 411                 const char *buffer) {
 412
 413         char header_priority[2 + DECIMAL_STR_MAX(int) + 1],
 414              header_time[64],
 415              header_pid[4 + DECIMAL_STR_MAX(pid_t) + 1];
 416         struct iovec iovec[5] = {};
 417         struct msghdr msghdr = {
 418                 .msg_iov = iovec,
 419                 .msg_iovlen = ELEMENTSOF(iovec),
 420         };
 421         time_t t;
 422         struct tm *tm;
 423
 424         if (syslog_fd < 0)
 425                 return 0;
 426
 427         xsprintf(header_priority, "<%i>", level);
 428
 429         t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
 430         tm = localtime(&t);
 431         if (!tm)
 432                 return -EINVAL;
 433
 434         if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
 435                 return -EINVAL;
 436
 437         xsprintf(header_pid, "["PID_FMT"]: ", getpid_cached());
 438
 439         iovec[0] = IOVEC_MAKE_STRING(header_priority);
 440         iovec[1] = IOVEC_MAKE_STRING(header_time);
 441         iovec[2] = IOVEC_MAKE_STRING(program_invocation_short_name);
 442         iovec[3] = IOVEC_MAKE_STRING(header_pid);
 443         iovec[4] = IOVEC_MAKE_STRING(buffer);
 444
 445         /* When using syslog via SOCK_STREAM separate the messages by NUL chars */
 446         if (syslog_is_stream)
 447                 iovec[4].iov_len++;
 448
 449         for (;;) {
 450                 ssize_t n;
 451
 452                 n = sendmsg(syslog_fd, &msghdr, MSG_NOSIGNAL);
 453                 if (n < 0)
 454                         return -errno;
 455
 456                 if (!syslog_is_stream ||
 457                     (size_t) n >= IOVEC_TOTAL_SIZE(iovec, ELEMENTSOF(iovec)))
 458                         break;
 459
 460                 IOVEC_INCREMENT(iovec, ELEMENTSOF(iovec), n);
 461         }
 462
 463         return 1;
 464 }
 465
 466 static int write_to_kmsg(
 467                 int level,
 468                 int error,
 469                 const char *file,
 470                 int line,
 471                 const char *func,
 472                 const char *buffer) {
 473
 474         char header_priority[2 + DECIMAL_STR_MAX(int) + 1],
 475              header_pid[4 + DECIMAL_STR_MAX(pid_t) + 1];
 476         struct iovec iovec[5] = {};
 477
 478         if (kmsg_fd < 0)
 479                 return 0;
 480
 481         xsprintf(header_priority, "<%i>", level);
 482         xsprintf(header_pid, "["PID_FMT"]: ", getpid_cached());
 483
 484         iovec[0] = IOVEC_MAKE_STRING(header_priority);
 485         iovec[1] = IOVEC_MAKE_STRING(program_invocation_short_name);
 486         iovec[2] = IOVEC_MAKE_STRING(header_pid);
 487         iovec[3] = IOVEC_MAKE_STRING(buffer);
 488         iovec[4] = IOVEC_MAKE_STRING("\n");
 489
 490         if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
 491                 return -errno;
 492
 493         return 1;
 494 }
 495
 496 static int log_do_header(
 497                 char *header,
 498                 size_t size,
 499                 int level,
 500                 int error,
 501                 const char *file, int line, const char *func,
 502                 const char *object_field, const char *object,
 503                 const char *extra_field, const char *extra) {
 504         int r;
 505
 506         r = snprintf(header, size,
 507                      "PRIORITY=%i\n"
 508                      "SYSLOG_FACILITY=%i\n"
 509                      "%s%.256s%s"        /* CODE_FILE */
 510                      "%s%.*i%s"          /* CODE_LINE */
 511                      "%s%.256s%s"        /* CODE_FUNC */
 512                      "%s%.*i%s"          /* ERRNO */
 513                      "%s%.256s%s"        /* object */
 514                      "%s%.256s%s"        /* extra */
 515                      "SYSLOG_IDENTIFIER=%.256s\n",
 516                      LOG_PRI(level),
 517                      LOG_FAC(level),
 518                      isempty(file) ? "" : "CODE_FILE=",
 519                      isempty(file) ? "" : file,
 520                      isempty(file) ? "" : "\n",
 521                      line ? "CODE_LINE=" : "",
 522                      line ? 1 : 0, line, /* %.0d means no output too, special case for 0 */
 523                      line ? "\n" : "",
 524                      isempty(func) ? "" : "CODE_FUNC=",
 525                      isempty(func) ? "" : func,
 526                      isempty(func) ? "" : "\n",
 527                      error ? "ERRNO=" : "",
 528                      error ? 1 : 0, error,
 529                      error ? "\n" : "",
 530                      isempty(object) ? "" : object_field,
 531                      isempty(object) ? "" : object,
 532                      isempty(object) ? "" : "\n",
 533                      isempty(extra) ? "" : extra_field,
 534                      isempty(extra) ? "" : extra,
 535                      isempty(extra) ? "" : "\n",
 536                      program_invocation_short_name);
 537         assert_raw((size_t) r < size);
 538
 539         return 0;
 540 }
 541
 542 static int write_to_journal(
 543                 int level,
 544                 int error,
 545                 const char *file,
 546                 int line,
 547                 const char *func,
 548                 const char *object_field,
 549                 const char *object,
 550                 const char *extra_field,
 551                 const char *extra,
 552                 const char *buffer) {
 553
 554         char header[LINE_MAX];
 555         struct iovec iovec[4] = {};
 556         struct msghdr mh = {};
 557
 558         if (journal_fd < 0)
 559                 return 0;
 560
 561         log_do_header(header, sizeof(header), level, error, file, line, func, object_field, object, extra_field, extra);
 562
 563         iovec[0] = IOVEC_MAKE_STRING(header);
 564         iovec[1] = IOVEC_MAKE_STRING("MESSAGE=");
 565         iovec[2] = IOVEC_MAKE_STRING(buffer);
 566         iovec[3] = IOVEC_MAKE_STRING("\n");
 567
 568         mh.msg_iov = iovec;
 569         mh.msg_iovlen = ELEMENTSOF(iovec);
 570
 571         if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
 572                 return -errno;
 573
 574         return 1;
 575 }
 576
 577 int log_dispatch_internal(
 578                 int level,
 579                 int error,
 580                 const char *file,
 581                 int line,
 582                 const char *func,
 583                 const char *object_field,
 584                 const char *object,
 585                 const char *extra_field,
 586                 const char *extra,
 587                 char *buffer) {
 588
 589         assert_raw(buffer);
 590
 591         if (error < 0)
 592                 error = -error;
 593
 594         if (log_target == LOG_TARGET_NULL)
 595                 return -error;
 596
 597         /* Patch in LOG_DAEMON facility if necessary */
 598         if ((level & LOG_FACMASK) == 0)
 599                 level = log_facility | LOG_PRI(level);
 600
 601         if (open_when_needed)
 602                 log_open();
 603
 604         do {
 605                 char *e;
 606                 int k = 0;
 607
 608                 buffer += strspn(buffer, NEWLINE);
 609
 610                 if (buffer[0] == 0)
 611                         break;
 612
 613                 if ((e = strpbrk(buffer, NEWLINE)))
 614                         *(e++) = 0;
 615
 616                 if (IN_SET(log_target, LOG_TARGET_AUTO,
 617                                        LOG_TARGET_JOURNAL_OR_KMSG,
 618                                        LOG_TARGET_JOURNAL)) {
 619
 620                         k = write_to_journal(level, error, file, line, func, object_field, object, extra_field, extra, buffer);
 621                         if (k < 0 && k != -EAGAIN)
 622                                 log_close_journal();
 623                 }
 624
 625                 if (IN_SET(log_target, LOG_TARGET_SYSLOG_OR_KMSG,
 626                                        LOG_TARGET_SYSLOG)) {
 627
 628                         k = write_to_syslog(level, error, file, line, func, buffer);
 629                         if (k < 0 && k != -EAGAIN)
 630                                 log_close_syslog();
 631                 }
 632
 633                 if (k <= 0 &&
 634                     IN_SET(log_target, LOG_TARGET_AUTO,
 635                                        LOG_TARGET_SYSLOG_OR_KMSG,
 636                                        LOG_TARGET_JOURNAL_OR_KMSG,
 637                                        LOG_TARGET_KMSG)) {
 638
 639                         if (k < 0)
 640                                 log_open_kmsg();
 641
 642                         k = write_to_kmsg(level, error, file, line, func, buffer);
 643                         if (k < 0) {
 644                                 log_close_kmsg();
 645                                 log_open_console();
 646                         }
 647                 }
 648
 649                 if (k <= 0)
 650                         (void) write_to_console(level, error, file, line, func, buffer);
 651
 652                 buffer = e;
 653         } while (buffer);
 654
 655         if (open_when_needed)
 656                 log_close();
 657
 658         return -error;
 659 }
 660
 661 int log_dump_internal(
 662                 int level,
 663                 int error,
 664                 const char *file,
 665                 int line,
 666                 const char *func,
 667                 char *buffer) {
 668
 669         LogRealm realm = LOG_REALM_REMOVE_LEVEL(level);
 670         PROTECT_ERRNO;
 671
 672         /* This modifies the buffer... */
 673
 674         if (error < 0)
 675                 error = -error;
 676
 677         if (_likely_(LOG_PRI(level) > log_max_level[realm]))
 678                 return -error;
 679
 680         return log_dispatch_internal(level, error, file, line, func, NULL, NULL, NULL, NULL, buffer);
 681 }
 682
 683 int log_internalv_realm(
 684                 int level,
 685                 int error,
 686                 const char *file,
 687                 int line,
 688                 const char *func,
 689                 const char *format,
 690                 va_list ap) {
 691
 692         LogRealm realm = LOG_REALM_REMOVE_LEVEL(level);
 693         char buffer[LINE_MAX];
 694         PROTECT_ERRNO;
 695
 696         if (error < 0)
 697                 error = -error;
 698
 699         if (_likely_(LOG_PRI(level) > log_max_level[realm]))
 700                 return -error;
 701
 702         /* Make sure that %m maps to the specified error */
 703         if (error != 0)
 704                 errno = error;
 705
 706         (void) vsnprintf(buffer, sizeof buffer, format, ap);
 707
 708         return log_dispatch_internal(level, error, file, line, func, NULL, NULL, NULL, NULL, buffer);
 709 }
 710
 711 int log_internal_realm(
 712                 int level,
 713                 int error,
 714                 const char *file,
 715                 int line,
 716                 const char *func,
 717                 const char *format, ...) {
 718
 719         va_list ap;
 720         int r;
 721
 722         va_start(ap, format);
 723         r = log_internalv_realm(level, error, file, line, func, format, ap);
 724         va_end(ap);
 725
 726         return r;
 727 }
 728
 729 _printf_(10,0)
 730 static int log_object_internalv(
 731                 int level,
 732                 int error,
 733                 const char *file,
 734                 int line,
 735                 const char *func,
 736                 const char *object_field,
 737                 const char *object,
 738                 const char *extra_field,
 739                 const char *extra,
 740                 const char *format,
 741                 va_list ap) {
 742
 743         PROTECT_ERRNO;
 744         char *buffer, *b;
 745
 746         if (error < 0)
 747                 error = -error;
 748
 749         if (_likely_(LOG_PRI(level) > log_max_level[LOG_REALM_SYSTEMD]))
 750                 return -error;
 751
 752         /* Make sure that %m maps to the specified error */
 753         if (error != 0)
 754                 errno = error;
 755
 756         /* Prepend the object name before the message */
 757         if (object) {
 758                 size_t n;
 759
 760                 n = strlen(object);
 761                 buffer = newa(char, n + 2 + LINE_MAX);
 762                 b = stpcpy(stpcpy(buffer, object), ": ");
 763         } else
 764                 b = buffer = newa(char, LINE_MAX);
 765
 766         (void) vsnprintf(b, LINE_MAX, format, ap);
 767
 768         return log_dispatch_internal(level, error, file, line, func,
 769                                      object_field, object, extra_field, extra, buffer);
 770 }
 771
 772 int log_object_internal(
 773                 int level,
 774                 int error,
 775                 const char *file,
 776                 int line,
 777                 const char *func,
 778                 const char *object_field,
 779                 const char *object,
 780                 const char *extra_field,
 781                 const char *extra,
 782                 const char *format, ...) {
 783
 784         va_list ap;
 785         int r;
 786
 787         va_start(ap, format);
 788         r = log_object_internalv(level, error, file, line, func, object_field, object, extra_field, extra, format, ap);
 789         va_end(ap);
 790
 791         return r;
 792 }
 793
 794 static void log_assert(
 795                 int level,
 796                 const char *text,
 797                 const char *file,
 798                 int line,
 799                 const char *func,
 800                 const char *format) {
 801
 802         static char buffer[LINE_MAX];
 803         LogRealm realm = LOG_REALM_REMOVE_LEVEL(level);
 804
 805         if (_likely_(LOG_PRI(level) > log_max_level[realm]))
 806                 return;
 807
 808         DISABLE_WARNING_FORMAT_NONLITERAL;
 809         (void) snprintf(buffer, sizeof buffer, format, text, file, line, func);
 810         REENABLE_WARNING;
 811
 812         log_abort_msg = buffer;
 813
 814         log_dispatch_internal(level, 0, file, line, func, NULL, NULL, NULL, NULL, buffer);
 815 }
 816
 817 _noreturn_ void log_assert_failed_realm(
 818                 LogRealm realm,
 819                 const char *text,
 820                 const char *file,
 821                 int line,
 822                 const char *func) {
 823         log_open();
 824         log_assert(LOG_REALM_PLUS_LEVEL(realm, LOG_CRIT), text, file, line, func,
 825                    "Assertion '%s' failed at %s:%u, function %s(). Aborting.");
 826         abort();
 827 }
 828
 829 _noreturn_ void log_assert_failed_unreachable_realm(
 830                 LogRealm realm,
 831                 const char *text,
 832                 const char *file,
 833                 int line,
 834                 const char *func) {
 835         log_open();
 836         log_assert(LOG_REALM_PLUS_LEVEL(realm, LOG_CRIT), text, file, line, func,
 837                    "Code should not be reached '%s' at %s:%u, function %s(). Aborting.");
 838         abort();
 839 }
 840
 841 void log_assert_failed_return_realm(
 842                 LogRealm realm,
 843                 const char *text,
 844                 const char *file,
 845                 int line,
 846                 const char *func) {
 847         PROTECT_ERRNO;
 848         log_assert(LOG_REALM_PLUS_LEVEL(realm, LOG_DEBUG), text, file, line, func,
 849                    "Assertion '%s' failed at %s:%u, function %s(). Ignoring.");
 850 }
 851
 852 int log_oom_internal(LogRealm realm, const char *file, int line, const char *func) {
 853         return log_internal_realm(LOG_REALM_PLUS_LEVEL(realm, LOG_ERR),
 854                                   ENOMEM, file, line, func, "Out of memory.");
 855 }
 856
 857 int log_format_iovec(
 858                 struct iovec *iovec,
 859                 size_t iovec_len,
 860                 size_t *n,
 861                 bool newline_separator,
 862                 int error,
 863                 const char *format,
 864                 va_list ap) {
 865
 866         static const char nl = '\n';
 867
 868         while (format && *n + 1 < iovec_len) {
 869                 va_list aq;
 870                 char *m;
 871                 int r;
 872
 873                 /* We need to copy the va_list structure,
 874                  * since vasprintf() leaves it afterwards at
 875                  * an undefined location */
 876
 877                 if (error != 0)
 878                         errno = error;
 879
 880                 va_copy(aq, ap);
 881                 r = vasprintf(&m, format, aq);
 882                 va_end(aq);
 883                 if (r < 0)
 884                         return -EINVAL;
 885
 886                 /* Now, jump enough ahead, so that we point to
 887                  * the next format string */
 888                 VA_FORMAT_ADVANCE(format, ap);
 889
 890                 iovec[(*n)++] = IOVEC_MAKE_STRING(m);
 891
 892                 if (newline_separator) {
 893                         iovec[*n].iov_base = (char*) &nl;
 894                         iovec[*n].iov_len = 1;
 895                         (*n)++;
 896                 }
 897
 898                 format = va_arg(ap, char *);
 899         }
 900         return 0;
 901 }
 902
 903 int log_struct_internal(
 904                 int level,
 905                 int error,
 906                 const char *file,
 907                 int line,
 908                 const char *func,
 909                 const char *format, ...) {
 910
 911         LogRealm realm = LOG_REALM_REMOVE_LEVEL(level);
 912         char buf[LINE_MAX];
 913         bool found = false;
 914         PROTECT_ERRNO;
 915         va_list ap;
 916
 917         if (error < 0)
 918                 error = -error;
 919
 920         if (_likely_(LOG_PRI(level) > log_max_level[realm]))
 921                 return -error;
 922
 923         if (log_target == LOG_TARGET_NULL)
 924                 return -error;
 925
 926         if ((level & LOG_FACMASK) == 0)
 927                 level = log_facility | LOG_PRI(level);
 928
 929         if (IN_SET(log_target,
 930                    LOG_TARGET_AUTO,
 931                    LOG_TARGET_JOURNAL_OR_KMSG,
 932                    LOG_TARGET_JOURNAL)) {
 933
 934                 if (open_when_needed)
 935                         log_open_journal();
 936
 937                 if (journal_fd >= 0) {
 938                         char header[LINE_MAX];
 939                         struct iovec iovec[17] = {};
 940                         size_t n = 0, i;
 941                         int r;
 942                         struct msghdr mh = {
 943                                 .msg_iov = iovec,
 944                         };
 945                         bool fallback = false;
 946
 947                         /* If the journal is available do structured logging */
 948                         log_do_header(header, sizeof(header), level, error, file, line, func, NULL, NULL, NULL, NULL);
 949                         iovec[n++] = IOVEC_MAKE_STRING(header);
 950
 951                         va_start(ap, format);
 952                         r = log_format_iovec(iovec, ELEMENTSOF(iovec), &n, true, error, format, ap);
 953                         if (r < 0)
 954                                 fallback = true;
 955                         else {
 956                                 mh.msg_iovlen = n;
 957                                 (void) sendmsg(journal_fd, &mh, MSG_NOSIGNAL);
 958                         }
 959
 960                         va_end(ap);
 961                         for (i = 1; i < n; i += 2)
 962                                 free(iovec[i].iov_base);
 963
 964                         if (!fallback) {
 965                                 if (open_when_needed)
 966                                         log_close();
 967
 968                                 return -error;
 969                         }
 970                 }
 971         }
 972
 973         /* Fallback if journal logging is not available or didn't work. */
 974
 975         va_start(ap, format);
 976         while (format) {
 977                 va_list aq;
 978
 979                 if (error != 0)
 980                         errno = error;
 981
 982                 va_copy(aq, ap);
 983                 (void) vsnprintf(buf, sizeof buf, format, aq);
 984                 va_end(aq);
 985
 986                 if (startswith(buf, "MESSAGE=")) {
 987                         found = true;
 988                         break;
 989                 }
 990
 991                 VA_FORMAT_ADVANCE(format, ap);
 992
 993                 format = va_arg(ap, char *);
 994         }
 995         va_end(ap);
 996
 997         if (!found) {
 998                 if (open_when_needed)
 999                         log_close();
1000
1001                 return -error;
1002         }
1003
1004         return log_dispatch_internal(level, error, file, line, func, NULL, NULL, NULL, NULL, buf + 8);
1005 }
1006
1007 int log_struct_iovec_internal(
1008                 int level,
1009                 int error,
1010                 const char *file,
1011                 int line,
1012                 const char *func,
1013                 const struct iovec input_iovec[],
1014                 size_t n_input_iovec) {
1015
1016         LogRealm realm = LOG_REALM_REMOVE_LEVEL(level);
1017         PROTECT_ERRNO;
1018         size_t i;
1019         char *m;
1020
1021         if (error < 0)
1022                 error = -error;
1023
1024         if (_likely_(LOG_PRI(level) > log_max_level[realm]))
1025                 return -error;
1026
1027         if (log_target == LOG_TARGET_NULL)
1028                 return -error;
1029
1030         if ((level & LOG_FACMASK) == 0)
1031                 level = log_facility | LOG_PRI(level);
1032
1033         if (IN_SET(log_target, LOG_TARGET_AUTO,
1034                                LOG_TARGET_JOURNAL_OR_KMSG,
1035                                LOG_TARGET_JOURNAL) &&
1036             journal_fd >= 0) {
1037
1038                 struct iovec iovec[1 + n_input_iovec*2];
1039                 char header[LINE_MAX];
1040                 struct msghdr mh = {
1041                         .msg_iov = iovec,
1042                         .msg_iovlen = 1 + n_input_iovec*2,
1043                 };
1044
1045                 log_do_header(header, sizeof(header), level, error, file, line, func, NULL, NULL, NULL, NULL);
1046                 iovec[0] = IOVEC_MAKE_STRING(header);
1047
1048                 for (i = 0; i < n_input_iovec; i++) {
1049                         iovec[1+i*2] = input_iovec[i];
1050                         iovec[1+i*2+1] = IOVEC_MAKE_STRING("\n");
1051                 }
1052
1053                 if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) >= 0)
1054                         return -error;
1055         }
1056
1057         for (i = 0; i < n_input_iovec; i++) {
1058                 if (input_iovec[i].iov_len < STRLEN("MESSAGE="))
1059                         continue;
1060
1061                 if (memcmp(input_iovec[i].iov_base, "MESSAGE=", STRLEN("MESSAGE=")) == 0)
1062                         break;
1063         }
1064
1065         if (_unlikely_(i >= n_input_iovec)) /* Couldn't find MESSAGE=? */
1066                 return -error;
1067
1068         m = strndupa(input_iovec[i].iov_base + STRLEN("MESSAGE="),
1069                      input_iovec[i].iov_len - STRLEN("MESSAGE="));
1070
1071         return log_dispatch_internal(level, error, file, line, func, NULL, NULL, NULL, NULL, m);
1072 }
1073
1074 int log_set_target_from_string(const char *e) {
1075         LogTarget t;
1076
1077         t = log_target_from_string(e);
1078         if (t < 0)
1079                 return -EINVAL;
1080
1081         log_set_target(t);
1082         return 0;
1083 }
1084
1085 int log_set_max_level_from_string_realm(LogRealm realm, const char *e) {
1086         int t;
1087
1088         t = log_level_from_string(e);
1089         if (t < 0)
1090                 return -EINVAL;
1091
1092         log_set_max_level_realm(realm, t);
1093         return 0;
1094 }
1095
1096 static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
1097
1098         /*
1099          * The systemd.log_xyz= settings are parsed by all tools, and
1100          * so is "debug".
1101          *
1102          * However, "quiet" is only parsed by PID 1, and only turns of
1103          * status output to /dev/console, but does not alter the log
1104          * level.
1105          */
1106
1107         if (streq(key, "debug") && !value)
1108                 log_set_max_level(LOG_DEBUG);
1109
1110         else if (proc_cmdline_key_streq(key, "systemd.log_target")) {
1111
1112                 if (proc_cmdline_value_missing(key, value))
1113                         return 0;
1114
1115                 if (log_set_target_from_string(value) < 0)
1116                         log_warning("Failed to parse log target '%s'. Ignoring.", value);
1117
1118         } else if (proc_cmdline_key_streq(key, "systemd.log_level")) {
1119
1120                 if (proc_cmdline_value_missing(key, value))
1121                         return 0;
1122
1123                 if (log_set_max_level_from_string(value) < 0)
1124                         log_warning("Failed to parse log level '%s'. Ignoring.", value);
1125
1126         } else if (proc_cmdline_key_streq(key, "systemd.log_color")) {
1127
1128                 if (log_show_color_from_string(value ?: "1") < 0)
1129                         log_warning("Failed to parse log color setting '%s'. Ignoring.", value);
1130
1131         } else if (proc_cmdline_key_streq(key, "systemd.log_location")) {
1132
1133                 if (log_show_location_from_string(value ?: "1") < 0)
1134                         log_warning("Failed to parse log location setting '%s'. Ignoring.", value);
1135         }
1136
1137         return 0;
1138 }
1139
1140 void log_parse_environment_realm(LogRealm realm) {
1141         /* Do not call from library code. */
1142
1143         const char *e;
1144
1145         if (get_ctty_devnr(0, NULL) < 0)
1146                 /* Only try to read the command line in daemons.  We assume that anything that has a controlling tty is
1147                    user stuff. */
1148                 (void) proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX);
1149
1150         e = getenv("SYSTEMD_LOG_TARGET");
1151         if (e && log_set_target_from_string(e) < 0)
1152                 log_warning("Failed to parse log target '%s'. Ignoring.", e);
1153
1154         e = getenv("SYSTEMD_LOG_LEVEL");
1155         if (e && log_set_max_level_from_string_realm(realm, e) < 0)
1156                 log_warning("Failed to parse log level '%s'. Ignoring.", e);
1157
1158         e = getenv("SYSTEMD_LOG_COLOR");
1159         if (e && log_show_color_from_string(e) < 0)
1160                 log_warning("Failed to parse bool '%s'. Ignoring.", e);
1161
1162         e = getenv("SYSTEMD_LOG_LOCATION");
1163         if (e && log_show_location_from_string(e) < 0)
1164                 log_warning("Failed to parse bool '%s'. Ignoring.", e);
1165 }
1166
1167 LogTarget log_get_target(void) {
1168         return log_target;
1169 }
1170
1171 int log_get_max_level_realm(LogRealm realm) {
1172         return log_max_level[realm];
1173 }
1174
1175 void log_show_color(bool b) {
1176         show_color = b;
1177 }
1178
1179 bool log_get_show_color(void) {
1180         return show_color;
1181 }
1182
1183 void log_show_location(bool b) {
1184         show_location = b;
1185 }
1186
1187 bool log_get_show_location(void) {
1188         return show_location;
1189 }
1190
1191 int log_show_color_from_string(const char *e) {
1192         int t;
1193
1194         t = parse_boolean(e);
1195         if (t < 0)
1196                 return t;
1197
1198         log_show_color(t);
1199         return 0;
1200 }
1201
1202 int log_show_location_from_string(const char *e) {
1203         int t;
1204
1205         t = parse_boolean(e);
1206         if (t < 0)
1207                 return t;
1208
1209         log_show_location(t);
1210         return 0;
1211 }
1212
1213 bool log_on_console(void) {
1214         if (IN_SET(log_target, LOG_TARGET_CONSOLE,
1215                                LOG_TARGET_CONSOLE_PREFIXED))
1216                 return true;
1217
1218         return syslog_fd < 0 && kmsg_fd < 0 && journal_fd < 0;
1219 }
1220
1221 static const char *const log_target_table[_LOG_TARGET_MAX] = {
1222         [LOG_TARGET_CONSOLE] = "console",
1223         [LOG_TARGET_CONSOLE_PREFIXED] = "console-prefixed",
1224         [LOG_TARGET_KMSG] = "kmsg",
1225         [LOG_TARGET_JOURNAL] = "journal",
1226         [LOG_TARGET_JOURNAL_OR_KMSG] = "journal-or-kmsg",
1227         [LOG_TARGET_SYSLOG] = "syslog",
1228         [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
1229         [LOG_TARGET_AUTO] = "auto",
1230         [LOG_TARGET_NULL] = "null",
1231 };
1232
1233 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);
1234
1235 void log_received_signal(int level, const struct signalfd_siginfo *si) {
1236         assert(si);
1237
1238         if (pid_is_valid(si->ssi_pid)) {
1239                 _cleanup_free_ char *p = NULL;
1240
1241                 (void) get_process_comm(si->ssi_pid, &p);
1242
1243                 log_full(level,
1244                          "Received SIG%s from PID %"PRIu32" (%s).",
1245                          signal_to_string(si->ssi_signo),
1246                          si->ssi_pid, strna(p));
1247         } else
1248                 log_full(level,
1249                          "Received SIG%s.",
1250                          signal_to_string(si->ssi_signo));
1251 }
1252
1253 int log_syntax_internal(
1254                 const char *unit,
1255                 int level,
1256                 const char *config_file,
1257                 unsigned config_line,
1258                 int error,
1259                 const char *file,
1260                 int line,
1261                 const char *func,
1262                 const char *format, ...) {
1263
1264         PROTECT_ERRNO;
1265         char buffer[LINE_MAX];
1266         va_list ap;
1267         const char *unit_fmt = NULL;
1268
1269         if (error < 0)
1270                 error = -error;
1271
1272         if (_likely_(LOG_PRI(level) > log_max_level[LOG_REALM_SYSTEMD]))
1273                 return -error;
1274
1275         if (log_target == LOG_TARGET_NULL)
1276                 return -error;
1277
1278         if (error != 0)
1279                 errno = error;
1280
1281         va_start(ap, format);
1282         (void) vsnprintf(buffer, sizeof buffer, format, ap);
1283         va_end(ap);
1284
1285         if (unit)
1286                 unit_fmt = getpid_cached() == 1 ? "UNIT=%s" : "USER_UNIT=%s";
1287
1288         return log_struct_internal(
1289                         LOG_REALM_PLUS_LEVEL(LOG_REALM_SYSTEMD, level),
1290                         error,
1291                         file, line, func,
1292                         "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
1293                         "CONFIG_FILE=%s", config_file,
1294                         "CONFIG_LINE=%u", config_line,
1295                         LOG_MESSAGE("%s:%u: %s", config_file, config_line, buffer),
1296                         unit_fmt, unit,
1297                         NULL);
1298 }
1299
1300 int log_syntax_invalid_utf8_internal(
1301                 const char *unit,
1302                 int level,
1303                 const char *config_file,
1304                 unsigned config_line,
1305                 const char *file,
1306                 int line,
1307                 const char *func,
1308                 const char *rvalue) {
1309
1310         _cleanup_free_ char *p = NULL;
1311
1312         if (rvalue)
1313                 p = utf8_escape_invalid(rvalue);
1314
1315         log_syntax_internal(unit, level, config_file, config_line, 0, file, line, func,
1316                             "String is not UTF-8 clean, ignoring assignment: %s", strna(p));
1317
1318         return -EINVAL;
1319 }
1320
1321 void log_set_upgrade_syslog_to_journal(bool b) {
1322         upgrade_syslog_to_journal = b;
1323
1324         /* Make the change effective immediately */
1325         if (b) {
1326                 if (log_target == LOG_TARGET_SYSLOG)
1327                         log_target = LOG_TARGET_JOURNAL;
1328                 else if (log_target == LOG_TARGET_SYSLOG_OR_KMSG)
1329                         log_target = LOG_TARGET_JOURNAL_OR_KMSG;
1330         }
1331 }
1332
1333 void log_set_always_reopen_console(bool b) {
1334         always_reopen_console = b;
1335 }
1336
1337 void log_set_open_when_needed(bool b) {
1338         open_when_needed = b;
1339 }
1340
1341 void log_set_prohibit_ipc(bool b) {
1342         prohibit_ipc = b;
1343 }
1344
1345 int log_emergency_level(void) {
1346         /* Returns the log level to use for log_emergency() logging. We use LOG_EMERG only when we are PID 1, as only
1347          * then the system of the whole system is obviously affected. */
1348
1349         return getpid_cached() == 1 ? LOG_EMERG : LOG_ERR;
1350 }