src/journal-remote/journal-remote.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <sys/prctl.h>
   9 #include <sys/socket.h>
  10 #include <stdint.h>
  11
  12 #include "sd-daemon.h"
  13
  14 #include "alloc-util.h"
  15 #include "def.h"
  16 #include "escape.h"
  17 #include "fd-util.h"
  18 #include "journal-file.h"
  19 #include "journal-remote-write.h"
  20 #include "journal-remote.h"
  21 #include "journald-native.h"
  22 #include "macro.h"
  23 #include "parse-util.h"
  24 #include "process-util.h"
  25 #include "socket-util.h"
  26 #include "stdio-util.h"
  27 #include "string-util.h"
  28 #include "strv.h"
  29
  30 #define REMOTE_JOURNAL_PATH "/var/log/journal/remote"
  31
  32 #define filename_escape(s) xescape((s), "/ ")
  33
  34 static int open_output(RemoteServer *s, Writer *w, const char* host) {
  35         _cleanup_free_ char *_filename = NULL;
  36         const char *filename;
  37         int r;
  38
  39         switch (s->split_mode) {
  40         case JOURNAL_WRITE_SPLIT_NONE:
  41                 filename = s->output;
  42                 break;
  43
  44         case JOURNAL_WRITE_SPLIT_HOST: {
  45                 _cleanup_free_ char *name;
  46
  47                 assert(host);
  48
  49                 name = filename_escape(host);
  50                 if (!name)
  51                         return log_oom();
  52
  53                 r = asprintf(&_filename, "%s/remote-%s.journal", s->output, name);
  54                 if (r < 0)
  55                         return log_oom();
  56
  57                 filename = _filename;
  58                 break;
  59         }
  60
  61         default:
  62                 assert_not_reached("what?");
  63         }
  64
  65         r = journal_file_open_reliably(filename,
  66                                        O_RDWR|O_CREAT, 0640,
  67                                        s->compress, (uint64_t) -1, s->seal,
  68                                        &w->metrics,
  69                                        w->mmap, NULL,
  70                                        NULL, &w->journal);
  71         if (r < 0)
  72                 return log_error_errno(r, "Failed to open output journal %s: %m", filename);
  73
  74         log_debug("Opened output file %s", w->journal->path);
  75         return 0;
  76 }
  77
  78 /**********************************************************************
  79  **********************************************************************
  80  **********************************************************************/
  81
  82 static int init_writer_hashmap(RemoteServer *s) {
  83         static const struct hash_ops* const hash_ops[] = {
  84                 [JOURNAL_WRITE_SPLIT_NONE] = NULL,
  85                 [JOURNAL_WRITE_SPLIT_HOST] = &string_hash_ops,
  86         };
  87
  88         assert(s);
  89         assert(s->split_mode >= 0 && s->split_mode < (int) ELEMENTSOF(hash_ops));
  90
  91         s->writers = hashmap_new(hash_ops[s->split_mode]);
  92         if (!s->writers)
  93                 return log_oom();
  94
  95         return 0;
  96 }
  97
  98 int journal_remote_get_writer(RemoteServer *s, const char *host, Writer **writer) {
  99         _cleanup_(writer_unrefp) Writer *w = NULL;
 100         const void *key;
 101         int r;
 102
 103         switch(s->split_mode) {
 104         case JOURNAL_WRITE_SPLIT_NONE:
 105                 key = "one and only";
 106                 break;
 107
 108         case JOURNAL_WRITE_SPLIT_HOST:
 109                 assert(host);
 110                 key = host;
 111                 break;
 112
 113         default:
 114                 assert_not_reached("what split mode?");
 115         }
 116
 117         w = hashmap_get(s->writers, key);
 118         if (w)
 119                 writer_ref(w);
 120         else {
 121                 w = writer_new(s);
 122                 if (!w)
 123                         return log_oom();
 124
 125                 if (s->split_mode == JOURNAL_WRITE_SPLIT_HOST) {
 126                         w->hashmap_key = strdup(key);
 127                         if (!w->hashmap_key)
 128                                 return log_oom();
 129                 }
 130
 131                 r = open_output(s, w, host);
 132                 if (r < 0)
 133                         return r;
 134
 135                 r = hashmap_put(s->writers, w->hashmap_key ?: key, w);
 136                 if (r < 0)
 137                         return r;
 138         }
 139
 140         *writer = TAKE_PTR(w);
 141
 142         return 0;
 143 }
 144
 145 /**********************************************************************
 146  **********************************************************************
 147  **********************************************************************/
 148
 149 /* This should go away as soon as µhttpd allows state to be passed around. */
 150 RemoteServer *journal_remote_server_global;
 151
 152 static int dispatch_raw_source_event(sd_event_source *event,
 153                                      int fd,
 154                                      uint32_t revents,
 155                                      void *userdata);
 156 static int dispatch_raw_source_until_block(sd_event_source *event,
 157                                            void *userdata);
 158 static int dispatch_blocking_source_event(sd_event_source *event,
 159                                           void *userdata);
 160 static int dispatch_raw_connection_event(sd_event_source *event,
 161                                          int fd,
 162                                          uint32_t revents,
 163                                          void *userdata);
 164
 165 static int get_source_for_fd(RemoteServer *s,
 166                              int fd, char *name, RemoteSource **source) {
 167         Writer *writer;
 168         int r;
 169
 170         /* This takes ownership of name, but only on success. */
 171
 172         assert(fd >= 0);
 173         assert(source);
 174
 175         if (!GREEDY_REALLOC0(s->sources, s->sources_size, fd + 1))
 176                 return log_oom();
 177
 178         r = journal_remote_get_writer(s, name, &writer);
 179         if (r < 0)
 180                 return log_warning_errno(r, "Failed to get writer for source %s: %m",
 181                                          name);
 182
 183         if (s->sources[fd] == NULL) {
 184                 s->sources[fd] = source_new(fd, false, name, writer);
 185                 if (!s->sources[fd]) {
 186                         writer_unref(writer);
 187                         return log_oom();
 188                 }
 189
 190                 s->active++;
 191         }
 192
 193         *source = s->sources[fd];
 194         return 0;
 195 }
 196
 197 static int remove_source(RemoteServer *s, int fd) {
 198         RemoteSource *source;
 199
 200         assert(s);
 201         assert(fd >= 0 && fd < (ssize_t) s->sources_size);
 202
 203         source = s->sources[fd];
 204         if (source) {
 205                 /* this closes fd too */
 206                 source_free(source);
 207                 s->sources[fd] = NULL;
 208                 s->active--;
 209         }
 210
 211         return 0;
 212 }
 213
 214 int journal_remote_add_source(RemoteServer *s, int fd, char* name, bool own_name) {
 215         RemoteSource *source = NULL;
 216         int r;
 217
 218         /* This takes ownership of name, even on failure, if own_name is true. */
 219
 220         assert(s);
 221         assert(fd >= 0);
 222         assert(name);
 223
 224         if (!own_name) {
 225                 name = strdup(name);
 226                 if (!name)
 227                         return log_oom();
 228         }
 229
 230         r = get_source_for_fd(s, fd, name, &source);
 231         if (r < 0) {
 232                 log_error_errno(r, "Failed to create source for fd:%d (%s): %m",
 233                                 fd, name);
 234                 free(name);
 235                 return r;
 236         }
 237
 238         r = sd_event_add_io(s->events, &source->event,
 239                             fd, EPOLLIN|EPOLLRDHUP|EPOLLPRI,
 240                             dispatch_raw_source_event, source);
 241         if (r == 0) {
 242                 /* Add additional source for buffer processing. It will be
 243                  * enabled later. */
 244                 r = sd_event_add_defer(s->events, &source->buffer_event,
 245                                        dispatch_raw_source_until_block, source);
 246                 if (r == 0)
 247                         sd_event_source_set_enabled(source->buffer_event, SD_EVENT_OFF);
 248         } else if (r == -EPERM) {
 249                 log_debug("Falling back to sd_event_add_defer for fd:%d (%s)", fd, name);
 250                 r = sd_event_add_defer(s->events, &source->event,
 251                                        dispatch_blocking_source_event, source);
 252                 if (r == 0)
 253                         sd_event_source_set_enabled(source->event, SD_EVENT_ON);
 254         }
 255         if (r < 0) {
 256                 log_error_errno(r, "Failed to register event source for fd:%d: %m",
 257                                 fd);
 258                 goto error;
 259         }
 260
 261         r = sd_event_source_set_description(source->event, name);
 262         if (r < 0) {
 263                 log_error_errno(r, "Failed to set source name for fd:%d: %m", fd);
 264                 goto error;
 265         }
 266
 267         return 1; /* work to do */
 268
 269  error:
 270         remove_source(s, fd);
 271         return r;
 272 }
 273
 274 int journal_remote_add_raw_socket(RemoteServer *s, int fd) {
 275         int r;
 276         _cleanup_close_ int fd_ = fd;
 277         char name[STRLEN("raw-socket-") + DECIMAL_STR_MAX(int) + 1];
 278
 279         assert(fd >= 0);
 280
 281         r = sd_event_add_io(s->events, &s->listen_event,
 282                             fd, EPOLLIN,
 283                             dispatch_raw_connection_event, s);
 284         if (r < 0)
 285                 return r;
 286
 287         xsprintf(name, "raw-socket-%d", fd);
 288
 289         r = sd_event_source_set_description(s->listen_event, name);
 290         if (r < 0)
 291                 return r;
 292
 293         fd_ = -1;
 294         s->active++;
 295         return 0;
 296 }
 297
 298 /**********************************************************************
 299  **********************************************************************
 300  **********************************************************************/
 301
 302 int journal_remote_server_init(
 303                 RemoteServer *s,
 304                 const char *output,
 305                 JournalWriteSplitMode split_mode,
 306                 bool compress,
 307                 bool seal) {
 308
 309         int r;
 310
 311         assert(s);
 312
 313         assert(journal_remote_server_global == NULL);
 314         journal_remote_server_global = s;
 315
 316         s->split_mode = split_mode;
 317         s->compress = compress;
 318         s->seal = seal;
 319
 320         if (output)
 321                 s->output = output;
 322         else if (split_mode == JOURNAL_WRITE_SPLIT_NONE)
 323                 s->output = REMOTE_JOURNAL_PATH "/remote.journal";
 324         else if (split_mode == JOURNAL_WRITE_SPLIT_HOST)
 325                 s->output = REMOTE_JOURNAL_PATH;
 326         else
 327                 assert_not_reached("bad split mode");
 328
 329         r = sd_event_default(&s->events);
 330         if (r < 0)
 331                 return log_error_errno(r, "Failed to allocate event loop: %m");
 332
 333         r = init_writer_hashmap(s);
 334         if (r < 0)
 335                 return r;
 336
 337         return 0;
 338 }
 339
 340 #if HAVE_MICROHTTPD
 341 static void MHDDaemonWrapper_free(MHDDaemonWrapper *d) {
 342         MHD_stop_daemon(d->daemon);
 343         sd_event_source_unref(d->io_event);
 344         sd_event_source_unref(d->timer_event);
 345         free(d);
 346 }
 347 #endif
 348
 349 void journal_remote_server_destroy(RemoteServer *s) {
 350         size_t i;
 351
 352 #if HAVE_MICROHTTPD
 353         hashmap_free_with_destructor(s->daemons, MHDDaemonWrapper_free);
 354 #endif
 355
 356         assert(s->sources_size == 0 || s->sources);
 357         for (i = 0; i < s->sources_size; i++)
 358                 remove_source(s, i);
 359         free(s->sources);
 360
 361         writer_unref(s->_single_writer);
 362         hashmap_free(s->writers);
 363
 364         sd_event_source_unref(s->sigterm_event);
 365         sd_event_source_unref(s->sigint_event);
 366         sd_event_source_unref(s->listen_event);
 367         sd_event_unref(s->events);
 368
 369         if (s == journal_remote_server_global)
 370                 journal_remote_server_global = NULL;
 371
 372         /* fds that we're listening on remain open... */
 373 }
 374
 375 /**********************************************************************
 376  **********************************************************************
 377  **********************************************************************/
 378
 379 int journal_remote_handle_raw_source(
 380                 sd_event_source *event,
 381                 int fd,
 382                 uint32_t revents,
 383                 RemoteServer *s) {
 384
 385         RemoteSource *source;
 386         int r;
 387
 388         /* Returns 1 if there might be more data pending,
 389          * 0 if data is currently exhausted, negative on error.
 390          */
 391
 392         assert(fd >= 0 && fd < (ssize_t) s->sources_size);
 393         source = s->sources[fd];
 394         assert(source->importer.fd == fd);
 395
 396         r = process_source(source, s->compress, s->seal);
 397         if (journal_importer_eof(&source->importer)) {
 398                 size_t remaining;
 399
 400                 log_debug("EOF reached with source %s (fd=%d)",
 401                           source->importer.name, source->importer.fd);
 402
 403                 remaining = journal_importer_bytes_remaining(&source->importer);
 404                 if (remaining > 0)
 405                         log_notice("Premature EOF. %zu bytes lost.", remaining);
 406                 remove_source(s, source->importer.fd);
 407                 log_debug("%zu active sources remaining", s->active);
 408                 return 0;
 409         } else if (r == -E2BIG) {
 410                 log_notice("Entry with too many fields, skipped");
 411                 return 1;
 412         } else if (r == -ENOBUFS) {
 413                 log_notice("Entry too big, skipped");
 414                 return 1;
 415         } else if (r == -EAGAIN) {
 416                 return 0;
 417         } else if (r < 0) {
 418                 log_debug_errno(r, "Closing connection: %m");
 419                 remove_source(s, fd);
 420                 return 0;
 421         } else
 422                 return 1;
 423 }
 424
 425 static int dispatch_raw_source_until_block(sd_event_source *event,
 426                                            void *userdata) {
 427         RemoteSource *source = userdata;
 428         int r;
 429
 430         /* Make sure event stays around even if source is destroyed */
 431         sd_event_source_ref(event);
 432
 433         r = journal_remote_handle_raw_source(event, source->importer.fd, EPOLLIN, journal_remote_server_global);
 434         if (r != 1)
 435                 /* No more data for now */
 436                 sd_event_source_set_enabled(event, SD_EVENT_OFF);
 437
 438         sd_event_source_unref(event);
 439
 440         return r;
 441 }
 442
 443 static int dispatch_raw_source_event(sd_event_source *event,
 444                                      int fd,
 445                                      uint32_t revents,
 446                                      void *userdata) {
 447         RemoteSource *source = userdata;
 448         int r;
 449
 450         assert(source->event);
 451         assert(source->buffer_event);
 452
 453         r = journal_remote_handle_raw_source(event, fd, EPOLLIN, journal_remote_server_global);
 454         if (r == 1)
 455                 /* Might have more data. We need to rerun the handler
 456                  * until we are sure the buffer is exhausted. */
 457                 sd_event_source_set_enabled(source->buffer_event, SD_EVENT_ON);
 458
 459         return r;
 460 }
 461
 462 static int dispatch_blocking_source_event(sd_event_source *event,
 463                                           void *userdata) {
 464         RemoteSource *source = userdata;
 465
 466         return journal_remote_handle_raw_source(event, source->importer.fd, EPOLLIN, journal_remote_server_global);
 467 }
 468
 469 static int accept_connection(const char* type, int fd,
 470                              SocketAddress *addr, char **hostname) {
 471         int fd2, r;
 472
 473         log_debug("Accepting new %s connection on fd:%d", type, fd);
 474         fd2 = accept4(fd, &addr->sockaddr.sa, &addr->size, SOCK_NONBLOCK|SOCK_CLOEXEC);
 475         if (fd2 < 0)
 476                 return log_error_errno(errno, "accept() on fd:%d failed: %m", fd);
 477
 478         switch(socket_address_family(addr)) {
 479         case AF_INET:
 480         case AF_INET6: {
 481                 _cleanup_free_ char *a = NULL;
 482                 char *b;
 483
 484                 r = socket_address_print(addr, &a);
 485                 if (r < 0) {
 486                         log_error_errno(r, "socket_address_print(): %m");
 487                         close(fd2);
 488                         return r;
 489                 }
 490
 491                 r = socknameinfo_pretty(&addr->sockaddr, addr->size, &b);
 492                 if (r < 0) {
 493                         log_error_errno(r, "Resolving hostname failed: %m");
 494                         close(fd2);
 495                         return r;
 496                 }
 497
 498                 log_debug("Accepted %s %s connection from %s",
 499                           type,
 500                           socket_address_family(addr) == AF_INET ? "IP" : "IPv6",
 501                           a);
 502
 503                 *hostname = b;
 504
 505                 return fd2;
 506         };
 507         default:
 508                 log_error("Rejected %s connection with unsupported family %d",
 509                           type, socket_address_family(addr));
 510                 close(fd2);
 511
 512                 return -EINVAL;
 513         }
 514 }
 515
 516 static int dispatch_raw_connection_event(sd_event_source *event,
 517                                          int fd,
 518                                          uint32_t revents,
 519                                          void *userdata) {
 520         RemoteServer *s = userdata;
 521         int fd2;
 522         SocketAddress addr = {
 523                 .size = sizeof(union sockaddr_union),
 524                 .type = SOCK_STREAM,
 525         };
 526         char *hostname = NULL;
 527
 528         fd2 = accept_connection("raw", fd, &addr, &hostname);
 529         if (fd2 < 0)
 530                 return fd2;
 531
 532         return journal_remote_add_source(s, fd2, hostname, true);
 533 }