]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/journal-send.c
projects / thirdparty / systemd.git / blob
? search:


ca9199f7187d79657c5c115c4b25758d1ebba340
[thirdparty/systemd.git] / src / journal / journal-send.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2011 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser 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/un.h>
24 #include <errno.h>
25 #include <stddef.h>
26 #include <unistd.h>
27 #include <fcntl.h>
28 #include <printf.h>
29
30 #define SD_JOURNAL_SUPPRESS_LOCATION
31
32 #include "sd-journal.h"
33 #include "util.h"
34 #include "socket-util.h"
35
36 #define SNDBUF_SIZE (8*1024*1024)
37
38 #define ALLOCA_CODE_FUNC(f, func) \
39 do { \
40 size_t _fl; \
41 const char *_func = (func); \
42 char **_f = &(f); \
43 _fl = strlen(_func) + 1; \
44 *_f = alloca(_fl + 10); \
45 memcpy(*_f, "CODE_FUNC=", 10); \
46 memcpy(*_f + 10, _func, _fl); \
47 } while(false)
48
49 /* We open a single fd, and we'll share it with the current process,
50 * all its threads, and all its subprocesses. This means we need to
51 * initialize it atomically, and need to operate on it atomically
52 * never assuming we are the only user */
53
54 static int journal_fd(void) {
55 int fd;
56 static int fd_plus_one = 0;
57
58 retry:
59 if (fd_plus_one > 0)
60 return fd_plus_one - 1;
61
62 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
63 if (fd < 0)
64 return -errno;
65
66 fd_inc_sndbuf(fd, SNDBUF_SIZE);
67
68 if (!__sync_bool_compare_and_swap(&fd_plus_one, 0, fd+1)) {
69 close_nointr_nofail(fd);
70 goto retry;
71 }
72
73 return fd;
74 }
75
76 _public_ int sd_journal_print(int priority, const char *format, ...) {
77 int r;
78 va_list ap;
79
80 va_start(ap, format);
81 r = sd_journal_printv(priority, format, ap);
82 va_end(ap);
83
84 return r;
85 }
86
87 _public_ int sd_journal_printv(int priority, const char *format, va_list ap) {
88
89 /* FIXME: Instead of limiting things to LINE_MAX we could do a
90 C99 variable-length array on the stack here in a loop. */
91
92 char buffer[8 + LINE_MAX], p[11]; struct iovec iov[2];
93
94 assert_return(priority >= 0, -EINVAL);
95 assert_return(priority <= 7, -EINVAL);
96 assert_return(format, -EINVAL);
97
98 snprintf(p, sizeof(p), "PRIORITY=%i", priority & LOG_PRIMASK);
99 char_array_0(p);
100
101 memcpy(buffer, "MESSAGE=", 8);
102 vsnprintf(buffer+8, sizeof(buffer) - 8, format, ap);
103 char_array_0(buffer);
104
105 zero(iov);
106 IOVEC_SET_STRING(iov[0], buffer);
107 IOVEC_SET_STRING(iov[1], p);
108
109 return sd_journal_sendv(iov, 2);
110 }
111
112 _printf_(1, 0) static int fill_iovec_sprintf(const char *format, va_list ap, int extra, struct iovec **_iov) {
113 PROTECT_ERRNO;
114 int r, n = 0, i = 0, j;
115 struct iovec *iov = NULL;
116
117 assert(_iov);
118
119 if (extra > 0) {
120 n = MAX(extra * 2, extra + 4);
121 iov = malloc0(n * sizeof(struct iovec));
122 if (!iov) {
123 r = -ENOMEM;
124 goto fail;
125 }
126
127 i = extra;
128 }
129
130 while (format) {
131 struct iovec *c;
132 char *buffer;
133 va_list aq;
134
135 if (i >= n) {
136 n = MAX(i*2, 4);
137 c = realloc(iov, n * sizeof(struct iovec));
138 if (!c) {
139 r = -ENOMEM;
140 goto fail;
141 }
142
143 iov = c;
144 }
145
146 va_copy(aq, ap);
147 if (vasprintf(&buffer, format, aq) < 0) {
148 va_end(aq);
149 r = -ENOMEM;
150 goto fail;
151 }
152 va_end(aq);
153
154 VA_FORMAT_ADVANCE(format, ap);
155
156 IOVEC_SET_STRING(iov[i++], buffer);
157
158 format = va_arg(ap, char *);
159 }
160
161 *_iov = iov;
162
163 return i;
164
165 fail:
166 for (j = 0; j < i; j++)
167 free(iov[j].iov_base);
168
169 free(iov);
170
171 return r;
172 }
173
174 _public_ int sd_journal_send(const char *format, ...) {
175 int r, i, j;
176 va_list ap;
177 struct iovec *iov = NULL;
178
179 va_start(ap, format);
180 i = fill_iovec_sprintf(format, ap, 0, &iov);
181 va_end(ap);
182
183 if (_unlikely_(i < 0)) {
184 r = i;
185 goto finish;
186 }
187
188 r = sd_journal_sendv(iov, i);
189
190 finish:
191 for (j = 0; j < i; j++)
192 free(iov[j].iov_base);
193
194 free(iov);
195
196 return r;
197 }
198
199 _public_ int sd_journal_sendv(const struct iovec *iov, int n) {
200 PROTECT_ERRNO;
201 int fd, buffer_fd;
202 struct iovec *w;
203 uint64_t *l;
204 int i, j = 0;
205 struct sockaddr_un sa = {
206 .sun_family = AF_UNIX,
207 .sun_path = "/run/systemd/journal/socket",
208 };
209 struct msghdr mh = {
210 .msg_name = &sa,
211 .msg_namelen = offsetof(struct sockaddr_un, sun_path) + strlen(sa.sun_path),
212 };
213 ssize_t k;
214 union {
215 struct cmsghdr cmsghdr;
216 uint8_t buf[CMSG_SPACE(sizeof(int))];
217 } control;
218 struct cmsghdr *cmsg;
219 bool have_syslog_identifier = false;
220
221 assert_return(iov, -EINVAL);
222 assert_return(n > 0, -EINVAL);
223
224 w = alloca(sizeof(struct iovec) * n * 5 + 3);
225 l = alloca(sizeof(uint64_t) * n);
226
227 for (i = 0; i < n; i++) {
228 char *c, *nl;
229
230 if (_unlikely_(!iov[i].iov_base || iov[i].iov_len <= 1))
231 return -EINVAL;
232
233 c = memchr(iov[i].iov_base, '=', iov[i].iov_len);
234 if (_unlikely_(!c || c == iov[i].iov_base))
235 return -EINVAL;
236
237 have_syslog_identifier = have_syslog_identifier ||
238 (c == (char *) iov[i].iov_base + 17 &&
239 startswith(iov[i].iov_base, "SYSLOG_IDENTIFIER"));
240
241 nl = memchr(iov[i].iov_base, '\n', iov[i].iov_len);
242 if (nl) {
243 if (_unlikely_(nl < c))
244 return -EINVAL;
245
246 /* Already includes a newline? Bummer, then
247 * let's write the variable name, then a
248 * newline, then the size (64bit LE), followed
249 * by the data and a final newline */
250
251 w[j].iov_base = iov[i].iov_base;
252 w[j].iov_len = c - (char*) iov[i].iov_base;
253 j++;
254
255 IOVEC_SET_STRING(w[j++], "\n");
256
257 l[i] = htole64(iov[i].iov_len - (c - (char*) iov[i].iov_base) - 1);
258 w[j].iov_base = &l[i];
259 w[j].iov_len = sizeof(uint64_t);
260 j++;
261
262 w[j].iov_base = c + 1;
263 w[j].iov_len = iov[i].iov_len - (c - (char*) iov[i].iov_base) - 1;
264 j++;
265
266 } else
267 /* Nothing special? Then just add the line and
268 * append a newline */
269 w[j++] = iov[i];
270
271 IOVEC_SET_STRING(w[j++], "\n");
272 }
273
274 if (!have_syslog_identifier &&
275 string_is_safe(program_invocation_short_name)) {
276
277 /* Implicitly add program_invocation_short_name, if it
278 * is not set explicitly. We only do this for
279 * program_invocation_short_name, and nothing else
280 * since everything else is much nicer to retrieve
281 * from the outside. */
282
283 IOVEC_SET_STRING(w[j++], "SYSLOG_IDENTIFIER=");
284 IOVEC_SET_STRING(w[j++], program_invocation_short_name);
285 IOVEC_SET_STRING(w[j++], "\n");
286 }
287
288 fd = journal_fd();
289 if (_unlikely_(fd < 0))
290 return fd;
291
292 mh.msg_iov = w;
293 mh.msg_iovlen = j;
294
295 k = sendmsg(fd, &mh, MSG_NOSIGNAL);
296 if (k >= 0)
297 return 0;
298
299 /* Fail silently if the journal is not available */
300 if (errno == ENOENT)
301 return 0;
302
303 if (errno != EMSGSIZE && errno != ENOBUFS)
304 return -errno;
305
306 /* Message doesn't fit... Let's dump the data in a temporary
307 * file and just pass a file descriptor of it to the other
308 * side.
309 *
310 * We use /dev/shm instead of /tmp here, since we want this to
311 * be a tmpfs, and one that is available from early boot on
312 * and where unprivileged users can create files. */
313 buffer_fd = open_tmpfile("/dev/shm", O_RDWR | O_CLOEXEC);
314 if (buffer_fd < 0)
315 return buffer_fd;
316
317 n = writev(buffer_fd, w, j);
318 if (n < 0) {
319 close_nointr_nofail(buffer_fd);
320 return -errno;
321 }
322
323 mh.msg_iov = NULL;
324 mh.msg_iovlen = 0;
325
326 zero(control);
327 mh.msg_control = &control;
328 mh.msg_controllen = sizeof(control);
329
330 cmsg = CMSG_FIRSTHDR(&mh);
331 cmsg->cmsg_level = SOL_SOCKET;
332 cmsg->cmsg_type = SCM_RIGHTS;
333 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
334 memcpy(CMSG_DATA(cmsg), &buffer_fd, sizeof(int));
335
336 mh.msg_controllen = cmsg->cmsg_len;
337
338 k = sendmsg(fd, &mh, MSG_NOSIGNAL);
339 close_nointr_nofail(buffer_fd);
340
341 if (k < 0)
342 return -errno;
343
344 return 0;
345 }
346
347 static int fill_iovec_perror_and_send(const char *message, int skip, struct iovec iov[]) {
348 PROTECT_ERRNO;
349 size_t n, k;
350
351 k = isempty(message) ? 0 : strlen(message) + 2;
352 n = 8 + k + 256 + 1;
353
354 for (;;) {
355 char buffer[n];
356 char* j;
357
358 errno = 0;
359 j = strerror_r(_saved_errno_, buffer + 8 + k, n - 8 - k);
360 if (errno == 0) {
361 char error[6 + 10 + 1]; /* for a 32bit value */
362
363 if (j != buffer + 8 + k)
364 memmove(buffer + 8 + k, j, strlen(j)+1);
365
366 memcpy(buffer, "MESSAGE=", 8);
367
368 if (k > 0) {
369 memcpy(buffer + 8, message, k - 2);
370 memcpy(buffer + 8 + k - 2, ": ", 2);
371 }
372
373 snprintf(error, sizeof(error), "ERRNO=%u", _saved_errno_);
374 char_array_0(error);
375
376 IOVEC_SET_STRING(iov[skip+0], "PRIORITY=3");
377 IOVEC_SET_STRING(iov[skip+1], buffer);
378 IOVEC_SET_STRING(iov[skip+2], error);
379
380 return sd_journal_sendv(iov, skip + 3);
381 }
382
383 if (errno != ERANGE)
384 return -errno;
385
386 n *= 2;
387 }
388 }
389
390 _public_ int sd_journal_perror(const char *message) {
391 struct iovec iovec[3];
392
393 return fill_iovec_perror_and_send(message, 0, iovec);
394 }
395
396 _public_ int sd_journal_stream_fd(const char *identifier, int priority, int level_prefix) {
397 union sockaddr_union sa = {
398 .un.sun_family = AF_UNIX,
399 .un.sun_path = "/run/systemd/journal/stdout",
400 };
401 int fd;
402 char *header;
403 size_t l;
404 ssize_t r;
405
406 assert_return(priority >= 0, -EINVAL);
407 assert_return(priority <= 7, -EINVAL);
408
409 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
410 if (fd < 0)
411 return -errno;
412
413 r = connect(fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
414 if (r < 0) {
415 close_nointr_nofail(fd);
416 return -errno;
417 }
418
419 if (shutdown(fd, SHUT_RD) < 0) {
420 close_nointr_nofail(fd);
421 return -errno;
422 }
423
424 fd_inc_sndbuf(fd, SNDBUF_SIZE);
425
426 if (!identifier)
427 identifier = "";
428
429 l = strlen(identifier);
430 header = alloca(l + 1 + 1 + 2 + 2 + 2 + 2 + 2);
431
432 memcpy(header, identifier, l);
433 header[l++] = '\n';
434 header[l++] = '\n'; /* unit id */
435 header[l++] = '0' + priority;
436 header[l++] = '\n';
437 header[l++] = '0' + !!level_prefix;
438 header[l++] = '\n';
439 header[l++] = '0';
440 header[l++] = '\n';
441 header[l++] = '0';
442 header[l++] = '\n';
443 header[l++] = '0';
444 header[l++] = '\n';
445
446 r = loop_write(fd, header, l, false);
447 if (r < 0) {
448 close_nointr_nofail(fd);
449 return (int) r;
450 }
451
452 if ((size_t) r != l) {
453 close_nointr_nofail(fd);
454 return -errno;
455 }
456
457 return fd;
458 }
459
460 _public_ int sd_journal_print_with_location(int priority, const char *file, const char *line, const char *func, const char *format, ...) {
461 int r;
462 va_list ap;
463
464 va_start(ap, format);
465 r = sd_journal_printv_with_location(priority, file, line, func, format, ap);
466 va_end(ap);
467
468 return r;
469 }
470
471 _public_ int sd_journal_printv_with_location(int priority, const char *file, const char *line, const char *func, const char *format, va_list ap) {
472 char buffer[8 + LINE_MAX], p[11];
473 struct iovec iov[5];
474 char *f;
475
476 assert_return(priority >= 0, -EINVAL);
477 assert_return(priority <= 7, -EINVAL);
478 assert_return(format, -EINVAL);
479
480 snprintf(p, sizeof(p), "PRIORITY=%i", priority & LOG_PRIMASK);
481 char_array_0(p);
482
483 memcpy(buffer, "MESSAGE=", 8);
484 vsnprintf(buffer+8, sizeof(buffer) - 8, format, ap);
485 char_array_0(buffer);
486
487 /* func is initialized from __func__ which is not a macro, but
488 * a static const char[], hence cannot easily be prefixed with
489 * CODE_FUNC=, hence let's do it manually here. */
490 ALLOCA_CODE_FUNC(f, func);
491
492 zero(iov);
493 IOVEC_SET_STRING(iov[0], buffer);
494 IOVEC_SET_STRING(iov[1], p);
495 IOVEC_SET_STRING(iov[2], file);
496 IOVEC_SET_STRING(iov[3], line);
497 IOVEC_SET_STRING(iov[4], f);
498
499 return sd_journal_sendv(iov, ELEMENTSOF(iov));
500 }
501
502 _public_ int sd_journal_send_with_location(const char *file, const char *line, const char *func, const char *format, ...) {
503 int r, i, j;
504 va_list ap;
505 struct iovec *iov = NULL;
506 char *f;
507
508 va_start(ap, format);
509 i = fill_iovec_sprintf(format, ap, 3, &iov);
510 va_end(ap);
511
512 if (_unlikely_(i < 0)) {
513 r = i;
514 goto finish;
515 }
516
517 ALLOCA_CODE_FUNC(f, func);
518
519 IOVEC_SET_STRING(iov[0], file);
520 IOVEC_SET_STRING(iov[1], line);
521 IOVEC_SET_STRING(iov[2], f);
522
523 r = sd_journal_sendv(iov, i);
524
525 finish:
526 for (j = 3; j < i; j++)
527 free(iov[j].iov_base);
528
529 free(iov);
530
531 return r;
532 }
533
534 _public_ int sd_journal_sendv_with_location(
535 const char *file, const char *line,
536 const char *func,
537 const struct iovec *iov, int n) {
538
539 struct iovec *niov;
540 char *f;
541
542 assert_return(iov, -EINVAL);
543 assert_return(n > 0, -EINVAL);
544
545 niov = alloca(sizeof(struct iovec) * (n + 3));
546 memcpy(niov, iov, sizeof(struct iovec) * n);
547
548 ALLOCA_CODE_FUNC(f, func);
549
550 IOVEC_SET_STRING(niov[n++], file);
551 IOVEC_SET_STRING(niov[n++], line);
552 IOVEC_SET_STRING(niov[n++], f);
553
554 return sd_journal_sendv(niov, n);
555 }
556
557 _public_ int sd_journal_perror_with_location(
558 const char *file, const char *line,
559 const char *func,
560 const char *message) {
561
562 struct iovec iov[6];
563 char *f;
564
565 ALLOCA_CODE_FUNC(f, func);
566
567 IOVEC_SET_STRING(iov[0], file);
568 IOVEC_SET_STRING(iov[1], line);
569 IOVEC_SET_STRING(iov[2], f);
570
571 return fill_iovec_perror_and_send(message, 3, iov);
572 }
Unnamed repository; edit this file 'description' to name the repository.