log.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   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_DEBUG;
  39
  40 static int syslog_fd = -1;
  41 static int kmsg_fd = -1;
  42
  43 void log_close_kmsg(void) {
  44
  45         if (kmsg_fd >= 0) {
  46                 close_nointr(kmsg_fd);
  47                 kmsg_fd = -1;
  48         }
  49 }
  50
  51 int log_open_kmsg(void) {
  52
  53         if (log_target != LOG_TARGET_KMSG) {
  54                 log_close_kmsg();
  55                 return 0;
  56         }
  57
  58         if (kmsg_fd >= 0)
  59                 return 0;
  60
  61         if ((kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0)
  62                 return -errno;
  63
  64         log_info("Succesfully opened /dev/kmsg for logging.");
  65
  66         return 0;
  67 }
  68
  69 void log_close_syslog(void) {
  70
  71         if (syslog_fd >= 0) {
  72                 close_nointr(syslog_fd);
  73                 syslog_fd = -1;
  74         }
  75 }
  76
  77 int log_open_syslog(void) {
  78         union {
  79                 struct sockaddr sa;
  80                 struct sockaddr_un un;
  81         } sa;
  82         struct timeval tv;
  83         int r;
  84
  85         if (log_target != LOG_TARGET_SYSLOG) {
  86                 log_close_syslog();
  87                 return 0;
  88         }
  89
  90         if (syslog_fd >= 0)
  91                 return 0;
  92
  93         if ((syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0)
  94                 return -errno;
  95
  96         /* Make sure we don't block for more than 5s when talking to
  97          * syslog */
  98         timeval_store(&tv, SYSLOG_TIMEOUT_USEC);
  99         if (setsockopt(syslog_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) {
 100                 r = -errno;
 101                 log_close_syslog();
 102                 return r;
 103         }
 104
 105         zero(sa);
 106         sa.un.sun_family = AF_UNIX;
 107         strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));
 108
 109         if (connect(syslog_fd, &sa.sa, sizeof(sa)) < 0) {
 110                 r = -errno;
 111                 log_close_syslog();
 112                 return -errno;
 113         }
 114
 115         log_info("Succesfully opened syslog for logging.");
 116
 117         return 0;
 118 }
 119
 120 void log_set_target(LogTarget target) {
 121         assert(target >= 0);
 122         assert(target < _LOG_TARGET_MAX);
 123
 124         log_target = target;
 125 }
 126
 127 void log_set_max_level(int level) {
 128         assert((level & LOG_PRIMASK) == level);
 129
 130         log_max_level = level;
 131 }
 132
 133 static void write_to_console(
 134         int level,
 135         const char*file,
 136         int line,
 137         const char *func,
 138         const char *format,
 139         va_list ap) {
 140
 141         const char *prefix, *suffix;
 142
 143         if (LOG_PRI(level) <= LOG_ERR) {
 144                 prefix = "\x1B[1;31m";
 145                 suffix = "\x1B[0m";
 146         } else {
 147                 prefix = "";
 148                 suffix = "";
 149         }
 150
 151         fprintf(stderr, "(%s:%u) %s", file, line, prefix);
 152         vfprintf(stderr, format, ap);
 153         fprintf(stderr, "%s\n", suffix);
 154 }
 155
 156 static int write_to_syslog(
 157         int level,
 158         const char*file,
 159         int line,
 160         const char *func,
 161         const char *format,
 162         va_list ap) {
 163
 164         char header_priority[16], header_time[64], header_pid[16];
 165         char buffer[LOG_BUFFER_MAX];
 166         struct iovec iovec[5];
 167         struct msghdr msghdr;
 168         time_t t;
 169         struct tm *tm;
 170
 171         if (syslog_fd < 0)
 172                 return -EIO;
 173
 174         snprintf(header_priority, sizeof(header_priority), "<%i>", LOG_MAKEPRI(LOG_DAEMON, LOG_PRI(level)));
 175         char_array_0(header_priority);
 176
 177         t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
 178         if (!(tm = localtime(&t)))
 179                 return -EINVAL;
 180
 181         if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
 182                 return -EINVAL;
 183
 184         snprintf(header_pid, sizeof(header_pid), "[%llu]: ", (unsigned long long) getpid());
 185         char_array_0(header_pid);
 186
 187         vsnprintf(buffer, sizeof(buffer), format, ap);
 188         char_array_0(buffer);
 189
 190         zero(iovec);
 191         IOVEC_SET_STRING(iovec[0], header_priority);
 192         IOVEC_SET_STRING(iovec[1], header_time);
 193         IOVEC_SET_STRING(iovec[2], __progname);
 194         IOVEC_SET_STRING(iovec[3], header_pid);
 195         IOVEC_SET_STRING(iovec[4], buffer);
 196
 197         zero(msghdr);
 198         msghdr.msg_iov = iovec;
 199         msghdr.msg_iovlen = ELEMENTSOF(iovec);
 200
 201         if (sendmsg(syslog_fd, &msghdr, 0) < 0)
 202                 return -errno;
 203
 204         return 0;
 205 }
 206
 207 static int write_to_kmsg(
 208         int level,
 209         const char*file,
 210         int line,
 211         const char *func,
 212         const char *format,
 213         va_list ap) {
 214
 215         char header_priority[16], header_pid[16];
 216         char buffer[LOG_BUFFER_MAX];
 217         struct iovec iovec[5];
 218
 219         if (kmsg_fd < 0)
 220                 return -EIO;
 221
 222         snprintf(header_priority, sizeof(header_priority), "<%i>", LOG_PRI(level));
 223         char_array_0(header_priority);
 224
 225         snprintf(header_pid, sizeof(header_pid), "[%llu]: ", (unsigned long long) getpid());
 226         char_array_0(header_pid);
 227
 228         vsnprintf(buffer, sizeof(buffer), format, ap);
 229         char_array_0(buffer);
 230
 231         zero(iovec);
 232         IOVEC_SET_STRING(iovec[0], header_priority);
 233         IOVEC_SET_STRING(iovec[1], __progname);
 234         IOVEC_SET_STRING(iovec[2], header_pid);
 235         IOVEC_SET_STRING(iovec[3], buffer);
 236         IOVEC_SET_STRING(iovec[4], (char*) "\n");
 237
 238         if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
 239                 return -errno;
 240
 241         return 0;
 242 }
 243
 244 void log_meta(
 245         int level,
 246         const char*file,
 247         int line,
 248         const char *func,
 249         const char *format, ...) {
 250
 251         va_list ap;
 252         bool written;
 253         int saved_errno;
 254
 255         if (LOG_PRI(level) > log_max_level)
 256                 return;
 257
 258         saved_errno = errno;
 259         written = false;
 260
 261         if (log_target == LOG_TARGET_KMSG) {
 262                 va_start(ap, format);
 263                 written = write_to_kmsg(level, file, line, func, format, ap) >= 0;
 264                 va_end(ap);
 265         } else if (log_target == LOG_TARGET_SYSLOG) {
 266                 va_start(ap, format);
 267                 written = write_to_syslog(level, file, line, func, format, ap) >= 0;
 268                 va_end(ap);
 269         }
 270
 271         if (!written) {
 272                 va_start(ap, format);
 273                 write_to_console(level, file, line, func, format, ap);
 274                 va_end(ap);
 275         }
 276
 277         errno = saved_errno;
 278 }
 279
 280 int log_set_target_from_string(const char *e) {
 281         LogTarget t;
 282
 283         if ((t = log_target_from_string(e)) < 0)
 284                 return -EINVAL;
 285
 286         log_set_target(t);
 287         return 0;
 288 }
 289
 290 int log_set_max_level_from_string(const char *e) {
 291         int t;
 292
 293         if ((t = log_level_from_string(e)) < 0)
 294                 return -EINVAL;
 295
 296         log_set_max_level(t);
 297         return 0;
 298 }
 299
 300 void log_parse_environment(void) {
 301         const char *e;
 302
 303         if ((e = getenv("SYSTEMD_LOG_TARGET")))
 304                 if (log_set_target_from_string(e) < 0)
 305                         log_warning("Failed to parse log target %s. Ignoring.", e);
 306
 307         if ((e = getenv("SYSTEMD_LOG_LEVEL")))
 308                 if (log_set_max_level_from_string(e) < 0)
 309                         log_warning("Failed to parse log level %s. Ignoring.", e);
 310 }
 311
 312 static const char *const log_target_table[] = {
 313         [LOG_TARGET_CONSOLE] = "console",
 314         [LOG_TARGET_SYSLOG] = "syslog",
 315         [LOG_TARGET_KMSG] = "kmsg",
 316 };
 317
 318 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);