src/kmsg-syslogd.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 <sys/socket.h>
  23 #include <sys/types.h>
  24 #include <assert.h>
  25 #include <time.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <errno.h>
  29 #include <unistd.h>
  30 #include <sys/poll.h>
  31 #include <sys/epoll.h>
  32 #include <sys/un.h>
  33 #include <fcntl.h>
  34 #include <sys/signalfd.h>
  35
  36 #include "util.h"
  37 #include "log.h"
  38 #include "sd-daemon.h"
  39 #include "fdset.h"
  40
  41 #define SERVER_FD_MAX 16
  42
  43 typedef struct Stream Stream;
  44
  45 typedef struct Server {
  46         FDSet *syslog_fds;
  47         int kmsg_fd;
  48         int epoll_fd;
  49         int signal_fd;
  50 } Server;
  51
  52 static void server_done(Server *s) {
  53         assert(s);
  54
  55         if (s->epoll_fd >= 0)
  56                 close_nointr_nofail(s->epoll_fd);
  57
  58         if (s->kmsg_fd >= 0)
  59                 close_nointr_nofail(s->kmsg_fd);
  60
  61         if (s->signal_fd >= 0)
  62                 close_nointr_nofail(s->signal_fd);
  63
  64         if (s->syslog_fds)
  65                 fdset_free(s->syslog_fds);
  66 }
  67
  68 static int server_init(Server *s) {
  69         int i, r, n;
  70         struct epoll_event ev;
  71         sigset_t mask;
  72
  73         assert(s);
  74
  75         zero(*s);
  76         s->kmsg_fd = s->signal_fd = -1;
  77
  78         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
  79         if (s->epoll_fd < 0) {
  80                 log_error("Failed to create epoll object: %m");
  81                 return -errno;
  82         }
  83
  84         s->syslog_fds = fdset_new();
  85         if (!s->syslog_fds) {
  86                 log_error("Failed to allocate file descriptor set: %s", strerror(ENOMEM));
  87                 return -ENOMEM;
  88         }
  89
  90         n = sd_listen_fds(true);
  91         if (n < 0) {
  92                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
  93                 return n;
  94         }
  95
  96         if (n <= 0 || n > SERVER_FD_MAX) {
  97                 log_error("No or too many file descriptors passed.");
  98                 return -EINVAL;
  99         }
 100
 101         for (i = 0; i < n; i++) {
 102                 int fd, one = 1;
 103
 104                 fd = SD_LISTEN_FDS_START+i;
 105
 106                 r = sd_is_socket(fd, AF_UNSPEC, SOCK_DGRAM, -1);
 107                 if (r < 0) {
 108                         log_error("Failed to determine file descriptor type: %s", strerror(-r));
 109                         return r;
 110                 }
 111
 112                 if (!r) {
 113                         log_error("Wrong file descriptor type.");
 114                         return -EINVAL;
 115                 }
 116
 117                 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
 118                         log_error("SO_PASSCRED failed: %m");
 119
 120                 zero(ev);
 121                 ev.events = EPOLLIN;
 122                 ev.data.fd = fd;
 123                 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
 124                         log_error("Failed to add server fd to epoll object: %m");
 125                         return -errno;
 126                 }
 127
 128                 r = fdset_put(s->syslog_fds, fd);
 129                 if (r < 0) {
 130                         log_error("Failed to store file descriptor in set: %s", strerror(-r));
 131                         return r;
 132                 }
 133         }
 134
 135         s->kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
 136         if (s->kmsg_fd < 0) {
 137                 log_error("Failed to open /dev/kmsg for logging: %m");
 138                 return -errno;
 139         }
 140
 141         assert_se(sigemptyset(&mask) == 0);
 142         sigset_add_many(&mask, SIGINT, SIGTERM, -1);
 143         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
 144
 145         s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 146         if (s->signal_fd < 0) {
 147                 log_error("signalfd(): %m");
 148                 return -errno;
 149         }
 150
 151         zero(ev);
 152         ev.events = EPOLLIN;
 153         ev.data.fd = s->signal_fd;
 154
 155         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
 156                 log_error("epoll_ctl(): %m");
 157                 return -errno;
 158         }
 159
 160         return 0;
 161 }
 162
 163 static int read_process(const char **buf, struct iovec *iovec) {
 164         const char *p;
 165         size_t l;
 166
 167         assert(buf);
 168         assert(*buf);
 169         assert(iovec);
 170
 171         p = *buf;
 172
 173         p += strspn(p, WHITESPACE);
 174         l = strcspn(p, WHITESPACE);
 175
 176         if (l <= 0 ||
 177             p[l-1] != ':')
 178                 return 0;
 179
 180         l--;
 181
 182         if (p[l-1] == ']') {
 183                 size_t k = l-1;
 184
 185                 for (;;) {
 186
 187                         if (p[k] == '[') {
 188                                 l = k;
 189                                 break;
 190                         }
 191
 192                         if (k == 0)
 193                                 break;
 194
 195                         k--;
 196                 }
 197         }
 198
 199         iovec->iov_base = (char*) p;
 200         iovec->iov_len = l;
 201         *buf = p + l;
 202         return 1;
 203 }
 204
 205 static int write_message(Server *s, const char *buf, struct ucred *ucred) {
 206         ssize_t k;
 207         char priority[6], pid[16];
 208         struct iovec iovec[5];
 209         unsigned i = 0;
 210         char *process = NULL;
 211         int r = 0;
 212         int prio = LOG_USER | LOG_INFO;
 213
 214         assert(s);
 215         assert(buf);
 216
 217         parse_syslog_priority((char**) &buf, &prio);
 218
 219         if (*buf == 0)
 220                 return 0;
 221
 222         if ((prio & LOG_FACMASK) == 0)
 223                 prio = LOG_USER | LOG_PRI(prio);
 224
 225         /* First, set priority field */
 226         snprintf(priority, sizeof(priority), "<%i>", prio);
 227         char_array_0(priority);
 228         IOVEC_SET_STRING(iovec[i++], priority);
 229
 230         /* Second, skip date */
 231         skip_syslog_date((char**) &buf);
 232
 233         /* Then, add process if set */
 234         if (read_process(&buf, &iovec[i]) > 0)
 235                 i++;
 236         else if (ucred &&
 237                  ucred->pid > 0 &&
 238                  get_process_comm(ucred->pid, &process) >= 0)
 239                 IOVEC_SET_STRING(iovec[i++], process);
 240
 241         /* Skip the stored PID if we have a better one */
 242         if (ucred) {
 243                 snprintf(pid, sizeof(pid), "[%lu]: ", (unsigned long) ucred->pid);
 244                 char_array_0(pid);
 245                 IOVEC_SET_STRING(iovec[i++], pid);
 246
 247                 skip_syslog_pid((char**) &buf);
 248
 249                 if (*buf == ':')
 250                         buf++;
 251
 252                 buf += strspn(buf, WHITESPACE);
 253         }
 254
 255         /* Is the remaining message empty? */
 256         if (*buf) {
 257
 258                 /* And the rest is the message */
 259                 IOVEC_SET_STRING(iovec[i++], buf);
 260                 IOVEC_SET_STRING(iovec[i++], "\n");
 261
 262                 if ((k = writev(s->kmsg_fd, iovec, i)) <= 0) {
 263                         log_error("Failed to write log message to kmsg: %s", k < 0 ? strerror(errno) : "short write");
 264                         r = k < 0 ? -errno : -EIO;
 265                 }
 266         }
 267
 268         free(process);
 269
 270         return r;
 271 }
 272
 273 static int process_event(Server *s, struct epoll_event *ev) {
 274         assert(s);
 275
 276         if (ev->events != EPOLLIN) {
 277                 log_info("Got invalid event from epoll.");
 278                 return -EIO;
 279         }
 280
 281         if (ev->data.fd == s->signal_fd) {
 282                 struct signalfd_siginfo sfsi;
 283                 ssize_t n;
 284
 285                 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
 286                 if (n != sizeof(sfsi)) {
 287
 288                         if (n >= 0)
 289                                 return -EIO;
 290
 291                         if (errno == EINTR || errno == EAGAIN)
 292                                 return 0;
 293
 294                         return -errno;
 295                 }
 296
 297                 log_debug("Received SIG%s", signal_to_string(sfsi.ssi_signo));
 298                 return 0;
 299
 300         } else {
 301                 for (;;) {
 302                         char buf[LINE_MAX+1];
 303                         struct msghdr msghdr;
 304                         struct iovec iovec;
 305                         struct ucred *ucred;
 306                         union {
 307                                 struct cmsghdr cmsghdr;
 308                                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
 309                         } control;
 310                         ssize_t n;
 311                         int k;
 312                         char *e;
 313
 314                         zero(iovec);
 315                         iovec.iov_base = buf;
 316                         iovec.iov_len = sizeof(buf)-1;
 317
 318                         zero(control);
 319                         zero(msghdr);
 320                         msghdr.msg_iov = &iovec;
 321                         msghdr.msg_iovlen = 1;
 322                         msghdr.msg_control = &control;
 323                         msghdr.msg_controllen = sizeof(control);
 324
 325                         n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT);
 326                         if (n < 0) {
 327
 328                                 if (errno == EINTR || errno == EAGAIN)
 329                                         return 1;
 330
 331                                 log_error("recvmsg() failed: %m");
 332                                 return -errno;
 333                         }
 334
 335                         if (msghdr.msg_controllen >= CMSG_LEN(sizeof(struct ucred)) &&
 336                             control.cmsghdr.cmsg_level == SOL_SOCKET &&
 337                             control.cmsghdr.cmsg_type == SCM_CREDENTIALS &&
 338                             control.cmsghdr.cmsg_len == CMSG_LEN(sizeof(struct ucred)))
 339                                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
 340                         else
 341                                 ucred = NULL;
 342
 343                         e = memchr(buf, '\n', n);
 344                         if (e)
 345                                 *e = 0;
 346                         else
 347                                 buf[n] = 0;
 348
 349                         k = write_message(s, strstrip(buf), ucred);
 350                         if (k < 0)
 351                                 return k;
 352                 }
 353         }
 354
 355         return 1;
 356 }
 357
 358 int main(int argc, char *argv[]) {
 359         Server server;
 360         int r;
 361
 362         if (getppid() != 1) {
 363                 log_error("This program should be invoked by init only.");
 364                 return EXIT_FAILURE;
 365         }
 366
 367         if (argc > 1) {
 368                 log_error("This program does not take arguments.");
 369                 return EXIT_FAILURE;
 370         }
 371
 372         log_set_target(LOG_TARGET_KMSG);
 373         log_parse_environment();
 374         log_open();
 375
 376         umask(0022);
 377
 378         r = server_init(&server);
 379         if (r < 0)
 380                 goto finish;
 381
 382         log_debug("systemd-kmsg-syslogd running as pid %lu", (unsigned long) getpid());
 383
 384         sd_notify(false,
 385                   "READY=1\n"
 386                   "STATUS=Processing messages...");
 387
 388         for (;;) {
 389                 struct epoll_event event;
 390
 391                 r = epoll_wait(server.epoll_fd, &event, 1, -1);
 392                 if (r < 0) {
 393
 394                         if (errno == EINTR)
 395                                 continue;
 396
 397                         log_error("epoll_wait() failed: %m");
 398                         r = -errno;
 399                         goto finish;
 400                 } else if (r == 0)
 401                         break;
 402
 403                 r = process_event(&server, &event);
 404                 if (r < 0)
 405                         goto finish;
 406                 else if (r == 0)
 407                         break;
 408         }
 409
 410         log_debug("systemd-kmsg-syslogd stopped as pid %lu", (unsigned long) getpid());
 411
 412 finish:
 413         sd_notify(false,
 414                   "STATUS=Shutting down...");
 415
 416         server_done(&server);
 417
 418         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 419 }