src/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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU 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
  30 #include "log.h"
  31 #include "util.h"
  32 #include "macro.h"
  33
  34 #define SYSLOG_TIMEOUT_USEC (5*USEC_PER_SEC)
  35 #define LOG_BUFFER_MAX 1024
  36
  37 static LogTarget log_target = LOG_TARGET_CONSOLE;
  38 static int log_max_level = LOG_INFO;
  39
  40 static int console_fd = STDERR_FILENO;
  41 static int syslog_fd = -1;
  42 static int kmsg_fd = -1;
  43
  44 static bool show_color = false;
  45 static bool show_location = false;
  46
  47 /* Akin to glibc's __abort_msg; which is private and we hance cannot
  48  * use here. */
  49 static char *log_abort_msg = NULL;
  50
  51 void log_close_console(void) {
  52
  53         if (console_fd < 0)
  54                 return;
  55
  56         if (getpid() == 1) {
  57                 if (console_fd >= 3)
  58                         close_nointr_nofail(console_fd);
  59
  60                 console_fd = -1;
  61         }
  62 }
  63
  64 static int log_open_console(void) {
  65
  66         if (console_fd >= 0)
  67                 return 0;
  68
  69         if (getpid() == 1) {
  70
  71                 if ((console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0) {
  72                         log_error("Failed to open /dev/console for logging: %s", strerror(-console_fd));
  73                         return console_fd;
  74                 }
  75
  76                 log_debug("Succesfully opened /dev/console for logging.");
  77         } else
  78                 console_fd = STDERR_FILENO;
  79
  80         return 0;
  81 }
  82
  83 void log_close_kmsg(void) {
  84
  85         if (kmsg_fd < 0)
  86                 return;
  87
  88         close_nointr_nofail(kmsg_fd);
  89         kmsg_fd = -1;
  90 }
  91
  92 static int log_open_kmsg(void) {
  93
  94         if (kmsg_fd >= 0)
  95                 return 0;
  96
  97         if ((kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0) {
  98                 log_info("Failed to open /dev/kmsg for logging: %s", strerror(errno));
  99                 return -errno;
 100         }
 101
 102         log_debug("Succesfully opened /dev/kmsg for logging.");
 103
 104         return 0;
 105 }
 106
 107 void log_close_syslog(void) {
 108
 109         if (syslog_fd < 0)
 110                 return;
 111
 112         close_nointr_nofail(syslog_fd);
 113         syslog_fd = -1;
 114 }
 115
 116 static int log_open_syslog(void) {
 117         union {
 118                 struct sockaddr sa;
 119                 struct sockaddr_un un;
 120         } sa;
 121         struct timeval tv;
 122         int r;
 123
 124         if (syslog_fd >= 0)
 125                 return 0;
 126
 127         if ((syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) {
 128                 r = -errno;
 129                 goto fail;
 130         }
 131
 132         /* Make sure we don't block for more than 5s when talking to
 133          * syslog */
 134         timeval_store(&tv, SYSLOG_TIMEOUT_USEC);
 135         if (setsockopt(syslog_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) {
 136                 r = -errno;
 137                 goto fail;
 138         }
 139
 140         zero(sa);
 141         sa.un.sun_family = AF_UNIX;
 142         strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));
 143
 144         if (connect(syslog_fd, &sa.sa, sizeof(sa)) < 0) {
 145                 r = -errno;
 146                 goto fail;
 147         }
 148
 149         log_debug("Succesfully opened syslog for logging.");
 150
 151         return 0;
 152
 153 fail:
 154         log_close_syslog();
 155         log_info("Failed to open syslog for logging: %s", strerror(-r));
 156         return r;
 157 }
 158
 159 int log_open(void) {
 160         int r;
 161
 162         /* If we don't use the console we close it here, to not get
 163          * killed by SAK. If we don't use syslog we close it here so
 164          * that we are not confused by somebody deleting the socket in
 165          * the fs. If we don't use /dev/kmsg we still keep it open,
 166          * because there is no reason to close it. */
 167
 168         if (log_target == LOG_TARGET_NULL) {
 169                 log_close_syslog();
 170                 log_close_console();
 171                 return 0;
 172         }
 173
 174         if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
 175             log_target == LOG_TARGET_SYSLOG)
 176                 if ((r = log_open_syslog()) >= 0) {
 177                         log_close_console();
 178                         return r;
 179                 }
 180
 181         if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
 182             log_target == LOG_TARGET_KMSG)
 183                 if ((r = log_open_kmsg()) >= 0) {
 184                         log_close_syslog();
 185                         log_close_console();
 186                         return r;
 187                 }
 188
 189         log_close_syslog();
 190         return log_open_console();
 191 }
 192
 193 void log_set_target(LogTarget target) {
 194         assert(target >= 0);
 195         assert(target < _LOG_TARGET_MAX);
 196
 197         log_target = target;
 198 }
 199
 200 void log_set_max_level(int level) {
 201         assert((level & LOG_PRIMASK) == level);
 202
 203         log_max_level = level;
 204 }
 205
 206 static int write_to_console(
 207         int level,
 208         const char*file,
 209         int line,
 210         const char *func,
 211         const char *buffer) {
 212
 213         char location[64];
 214         struct iovec iovec[5];
 215         unsigned n = 0;
 216         bool highlight;
 217
 218         if (console_fd < 0)
 219                 return 0;
 220
 221         snprintf(location, sizeof(location), "(%s:%u) ", file, line);
 222         char_array_0(location);
 223
 224         highlight = LOG_PRI(level) <= LOG_ERR && show_color;
 225
 226         zero(iovec);
 227         if (show_location)
 228                 IOVEC_SET_STRING(iovec[n++], location);
 229         if (highlight)
 230                 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_ON);
 231         IOVEC_SET_STRING(iovec[n++], buffer);
 232         if (highlight)
 233                 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_OFF);
 234         IOVEC_SET_STRING(iovec[n++], "\n");
 235
 236         if (writev(console_fd, iovec, n) < 0)
 237                 return -errno;
 238
 239         return 1;
 240 }
 241
 242 static int write_to_syslog(
 243         int level,
 244         const char*file,
 245         int line,
 246         const char *func,
 247         const char *buffer) {
 248
 249         char header_priority[16], header_time[64], header_pid[16];
 250         struct iovec iovec[5];
 251         struct msghdr msghdr;
 252         union {
 253                 struct cmsghdr cmsghdr;
 254                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
 255         } control;
 256         struct ucred *ucred;
 257         time_t t;
 258         struct tm *tm;
 259
 260         if (syslog_fd < 0)
 261                 return 0;
 262
 263         snprintf(header_priority, sizeof(header_priority), "<%i>", LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(level)));
 264         char_array_0(header_priority);
 265
 266         t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
 267         if (!(tm = localtime(&t)))
 268                 return -EINVAL;
 269
 270         if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
 271                 return -EINVAL;
 272
 273         snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) getpid());
 274         char_array_0(header_pid);
 275
 276         zero(iovec);
 277         IOVEC_SET_STRING(iovec[0], header_priority);
 278         IOVEC_SET_STRING(iovec[1], header_time);
 279         IOVEC_SET_STRING(iovec[2], program_invocation_short_name);
 280         IOVEC_SET_STRING(iovec[3], header_pid);
 281         IOVEC_SET_STRING(iovec[4], buffer);
 282
 283         zero(control);
 284         control.cmsghdr.cmsg_level = SOL_SOCKET;
 285         control.cmsghdr.cmsg_type = SCM_CREDENTIALS;
 286         control.cmsghdr.cmsg_len = CMSG_LEN(sizeof(struct ucred));
 287
 288         ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
 289         ucred->pid = getpid();
 290         ucred->uid = getuid();
 291         ucred->gid = getgid();
 292
 293         zero(msghdr);
 294         msghdr.msg_iov = iovec;
 295         msghdr.msg_iovlen = ELEMENTSOF(iovec);
 296         msghdr.msg_control = &control;
 297         msghdr.msg_controllen = control.cmsghdr.cmsg_len;
 298
 299         if (sendmsg(syslog_fd, &msghdr, MSG_NOSIGNAL) < 0)
 300                 return -errno;
 301
 302         return 1;
 303 }
 304
 305 static int write_to_kmsg(
 306         int level,
 307         const char*file,
 308         int line,
 309         const char *func,
 310         const char *buffer) {
 311
 312         char header_priority[16], header_pid[16];
 313         struct iovec iovec[5];
 314
 315         if (kmsg_fd < 0)
 316                 return 0;
 317
 318         snprintf(header_priority, sizeof(header_priority), "<%i>", LOG_PRI(level));
 319         char_array_0(header_priority);
 320
 321         snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) getpid());
 322         char_array_0(header_pid);
 323
 324         zero(iovec);
 325         IOVEC_SET_STRING(iovec[0], header_priority);
 326         IOVEC_SET_STRING(iovec[1], program_invocation_short_name);
 327         IOVEC_SET_STRING(iovec[2], header_pid);
 328         IOVEC_SET_STRING(iovec[3], buffer);
 329         IOVEC_SET_STRING(iovec[4], "\n");
 330
 331         if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
 332                 return -errno;
 333
 334         return 1;
 335 }
 336
 337 static int log_dispatch(
 338         int level,
 339         const char*file,
 340         int line,
 341         const char *func,
 342         char *buffer) {
 343
 344         int r = 0;
 345
 346         if (log_target == LOG_TARGET_NULL)
 347                 return 0;
 348
 349         do {
 350                 char *e;
 351                 int k = 0;
 352
 353                 buffer += strspn(buffer, NEWLINE);
 354
 355                 if (buffer[0] == 0)
 356                         break;
 357
 358                 if ((e = strpbrk(buffer, NEWLINE)))
 359                         *(e++) = 0;
 360
 361                 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
 362                     log_target == LOG_TARGET_SYSLOG) {
 363
 364                         if ((k = write_to_syslog(level, file, line, func, buffer)) < 0) {
 365                                 log_close_syslog();
 366                                 log_open_kmsg();
 367                         } else if (k > 0)
 368                                 r++;
 369                 }
 370
 371                 if (k <= 0 &&
 372                     (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
 373                      log_target == LOG_TARGET_KMSG)) {
 374
 375                         if ((k = write_to_kmsg(level, file, line, func, buffer)) < 0) {
 376                                 log_close_kmsg();
 377                                 log_open_console();
 378                         } else if (k > 0)
 379                                 r++;
 380                 }
 381
 382                 if (k <= 0 &&
 383                     (k = write_to_console(level, file, line, func, buffer)) < 0)
 384                         return k;
 385
 386                 buffer = e;
 387         } while (buffer);
 388
 389         return r;
 390 }
 391
 392 int log_dump_internal(
 393         int level,
 394         const char*file,
 395         int line,
 396         const char *func,
 397         char *buffer) {
 398
 399         int saved_errno, r;
 400
 401         /* This modifies the buffer... */
 402
 403         if (_likely_(LOG_PRI(level) > log_max_level))
 404                 return 0;
 405
 406         saved_errno = errno;
 407         r = log_dispatch(level, file, line, func, buffer);
 408         errno = saved_errno;
 409
 410         return r;
 411 }
 412
 413 int log_meta(
 414         int level,
 415         const char*file,
 416         int line,
 417         const char *func,
 418         const char *format, ...) {
 419
 420         char buffer[LOG_BUFFER_MAX];
 421         int saved_errno, r;
 422         va_list ap;
 423
 424         if (_likely_(LOG_PRI(level) > log_max_level))
 425                 return 0;
 426
 427         saved_errno = errno;
 428
 429         va_start(ap, format);
 430         vsnprintf(buffer, sizeof(buffer), format, ap);
 431         va_end(ap);
 432
 433         char_array_0(buffer);
 434
 435         r = log_dispatch(level, file, line, func, buffer);
 436         errno = saved_errno;
 437
 438         return r;
 439 }
 440
 441 void log_assert(
 442         const char*file,
 443         int line,
 444         const char *func,
 445         const char *format, ...) {
 446
 447         static char buffer[LOG_BUFFER_MAX];
 448         int saved_errno = errno;
 449         va_list ap;
 450
 451         va_start(ap, format);
 452         vsnprintf(buffer, sizeof(buffer), format, ap);
 453         va_end(ap);
 454
 455         char_array_0(buffer);
 456         log_abort_msg = buffer;
 457
 458         log_dispatch(LOG_CRIT, file, line, func, buffer);
 459         abort();
 460
 461         /* If the user chose to ignore this SIGABRT, we are happy to go on, as if nothing happened. */
 462         errno = saved_errno;
 463 }
 464
 465 int log_set_target_from_string(const char *e) {
 466         LogTarget t;
 467
 468         if ((t = log_target_from_string(e)) < 0)
 469                 return -EINVAL;
 470
 471         log_set_target(t);
 472         return 0;
 473 }
 474
 475 int log_set_max_level_from_string(const char *e) {
 476         int t;
 477
 478         if ((t = log_level_from_string(e)) < 0)
 479                 return -EINVAL;
 480
 481         log_set_max_level(t);
 482         return 0;
 483 }
 484
 485 void log_parse_environment(void) {
 486         const char *e;
 487
 488         if ((e = getenv("SYSTEMD_LOG_TARGET")))
 489                 if (log_set_target_from_string(e) < 0)
 490                         log_warning("Failed to parse log target %s. Ignoring.", e);
 491
 492         if ((e = getenv("SYSTEMD_LOG_LEVEL")))
 493                 if (log_set_max_level_from_string(e) < 0)
 494                         log_warning("Failed to parse log level %s. Ignoring.", e);
 495
 496         if ((e = getenv("SYSTEMD_LOG_COLOR")))
 497                 if (log_show_color_from_string(e) < 0)
 498                         log_warning("Failed to parse bool %s. Ignoring.", e);
 499
 500         if ((e = getenv("SYSTEMD_LOG_LOCATION"))) {
 501                 if (log_show_location_from_string(e) < 0)
 502                         log_warning("Failed to parse bool %s. Ignoring.", e);
 503         }
 504 }
 505
 506 LogTarget log_get_target(void) {
 507         return log_target;
 508 }
 509
 510 int log_get_max_level(void) {
 511         return log_max_level;
 512 }
 513
 514 void log_show_color(bool b) {
 515         show_color = b;
 516 }
 517
 518 void log_show_location(bool b) {
 519         show_location = b;
 520 }
 521
 522 int log_show_color_from_string(const char *e) {
 523         int t;
 524
 525         if ((t = parse_boolean(e)) < 0)
 526                 return -EINVAL;
 527
 528         log_show_color(t);
 529         return 0;
 530 }
 531
 532 int log_show_location_from_string(const char *e) {
 533         int t;
 534
 535         if ((t = parse_boolean(e)) < 0)
 536                 return -EINVAL;
 537
 538         log_show_location(t);
 539         return 0;
 540 }
 541
 542 static const char *const log_target_table[] = {
 543         [LOG_TARGET_CONSOLE] = "console",
 544         [LOG_TARGET_SYSLOG] = "syslog",
 545         [LOG_TARGET_KMSG] = "kmsg",
 546         [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
 547         [LOG_TARGET_NULL] = "null"
 548 };
 549
 550 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);