LCOV - code coverage report
Current view: top level - journal - journal-send.c (source / functions) Hit Total Coverage
Test: systemd test coverage Lines: 151 277 54.5 %
Date: 2015-07-29 18:47:03 Functions: 8 14 57.1 %

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

Generated by: LCOV version 1.11