1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
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.
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.
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/>.
34 #include "sd-daemon.h"
37 #include "bus-socket.h"
38 #include "bus-internal.h"
39 #include "bus-message.h"
41 static void iovec_advance(struct iovec iov[], unsigned *idx, size_t size) {
44 struct iovec *i = iov + *idx;
46 if (i->iov_len > size) {
47 i->iov_base = (uint8_t*) i->iov_base + size;
61 static void append_iovec(sd_bus_message *m, const void *p, size_t sz) {
66 m->iovec[m->n_iovec].iov_base = (void*) p;
67 m->iovec[m->n_iovec].iov_len = sz;
71 static void bus_message_setup_iovec(sd_bus_message *m) {
78 append_iovec(m, m->header, sizeof(*m->header));
81 append_iovec(m, m->fields, m->header->fields_size);
83 if (m->header->fields_size % 8 != 0) {
84 static const uint8_t padding[7] = {};
86 append_iovec(m, padding, 8 - (m->header->fields_size % 8));
91 append_iovec(m, m->body, m->header->body_size);
94 bool bus_socket_auth_needs_write(sd_bus *b) {
98 if (b->auth_index >= ELEMENTSOF(b->auth_iovec))
101 for (i = b->auth_index; i < ELEMENTSOF(b->auth_iovec); i++) {
102 struct iovec *j = b->auth_iovec + i;
111 static int bus_socket_write_auth(sd_bus *b) {
115 assert(b->state == BUS_AUTHENTICATING);
117 if (!bus_socket_auth_needs_write(b))
120 if (b->prefer_writev)
121 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
126 mh.msg_iov = b->auth_iovec + b->auth_index;
127 mh.msg_iovlen = ELEMENTSOF(b->auth_iovec) - b->auth_index;
129 k = sendmsg(b->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
130 if (k < 0 && errno == ENOTSOCK) {
131 b->prefer_writev = true;
132 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
137 return errno == EAGAIN ? 0 : -errno;
139 iovec_advance(b->auth_iovec, &b->auth_index, (size_t) k);
143 static int bus_socket_auth_verify_client(sd_bus *b) {
151 /* We expect two response lines: "OK" and possibly
154 e = memmem(b->rbuffer, b->rbuffer_size, "\r\n", 2);
158 if (b->negotiate_fds) {
159 f = memmem(e + 2, b->rbuffer_size - (e - (char*) b->rbuffer) - 2, "\r\n", 2);
169 /* Nice! We got all the lines we need. First check the OK
172 if (e - (char*) b->rbuffer != 3 + 32)
175 if (memcmp(b->rbuffer, "OK ", 3))
178 b->auth = b->anonymous_auth ? BUS_AUTH_ANONYMOUS : BUS_AUTH_EXTERNAL;
180 for (i = 0; i < 32; i += 2) {
183 x = unhexchar(((char*) b->rbuffer)[3 + i]);
184 y = unhexchar(((char*) b->rbuffer)[3 + i + 1]);
189 peer.bytes[i/2] = ((uint8_t) x << 4 | (uint8_t) y);
192 if (!sd_id128_equal(b->server_id, SD_ID128_NULL) &&
193 !sd_id128_equal(b->server_id, peer))
198 /* And possibly check the second line, too */
202 (f - e == sizeof("\r\nAGREE_UNIX_FD") - 1) &&
203 memcmp(e + 2, "AGREE_UNIX_FD", sizeof("AGREE_UNIX_FD") - 1) == 0;
205 b->rbuffer_size -= (start - (char*) b->rbuffer);
206 memmove(b->rbuffer, start, b->rbuffer_size);
208 r = bus_start_running(b);
215 static bool line_equals(const char *s, size_t m, const char *line) {
222 return memcmp(s, line, l) == 0;
225 static bool line_begins(const char *s, size_t m, const char *word) {
232 if (memcmp(s, word, l) != 0)
235 return m == l || (m > l && s[l] == ' ');
238 static int verify_anonymous_token(sd_bus *b, const char *p, size_t l) {
239 _cleanup_free_ char *token = NULL;
241 if (!b->anonymous_auth)
252 token = unhexmem(p, l);
256 if (memchr(token, 0, l/2))
259 return !!utf8_is_valid(token);
262 static int verify_external_token(sd_bus *b, const char *p, size_t l) {
263 _cleanup_free_ char *token = NULL;
267 /* We don't do any real authentication here. Instead, we if
268 * the owner of this bus wanted authentication he should have
269 * checked SO_PEERCRED before even creating the bus object. */
271 if (!b->anonymous_auth && !b->ucred_valid)
283 token = unhexmem(p, l);
287 if (memchr(token, 0, l/2))
290 r = parse_uid(token, &u);
294 /* We ignore the passed value if anonymous authentication is
296 if (!b->anonymous_auth && u != b->ucred.uid)
302 static int bus_socket_auth_write(sd_bus *b, const char *t) {
309 /* We only make use of the first iovec */
310 assert(b->auth_index == 0 || b->auth_index == 1);
313 p = malloc(b->auth_iovec[0].iov_len + l);
317 memcpy(p, b->auth_iovec[0].iov_base, b->auth_iovec[0].iov_len);
318 memcpy(p + b->auth_iovec[0].iov_len, t, l);
320 b->auth_iovec[0].iov_base = p;
321 b->auth_iovec[0].iov_len += l;
323 free(b->auth_buffer);
329 static int bus_socket_auth_write_ok(sd_bus *b) {
330 char t[3 + 32 + 2 + 1];
334 snprintf(t, sizeof(t), "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
337 return bus_socket_auth_write(b, t);
340 static int bus_socket_auth_verify_server(sd_bus *b) {
344 bool processed = false;
349 if (b->rbuffer_size < 1)
352 /* First char must be a NUL byte */
353 if (*(char*) b->rbuffer != 0)
356 if (b->rbuffer_size < 3)
359 /* Begin with the first line */
360 if (b->auth_rbegin <= 0)
364 /* Check if line is complete */
365 line = (char*) b->rbuffer + b->auth_rbegin;
366 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
372 if (line_begins(line, l, "AUTH ANONYMOUS")) {
374 r = verify_anonymous_token(b, line + 14, l - 14);
378 r = bus_socket_auth_write(b, "REJECTED\r\n");
380 b->auth = BUS_AUTH_ANONYMOUS;
381 r = bus_socket_auth_write_ok(b);
384 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
386 r = verify_external_token(b, line + 13, l - 13);
390 r = bus_socket_auth_write(b, "REJECTED\r\n");
392 b->auth = BUS_AUTH_EXTERNAL;
393 r = bus_socket_auth_write_ok(b);
396 } else if (line_begins(line, l, "AUTH"))
397 r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
398 else if (line_equals(line, l, "CANCEL") ||
399 line_begins(line, l, "ERROR")) {
401 b->auth = _BUS_AUTH_INVALID;
402 r = bus_socket_auth_write(b, "REJECTED\r\n");
404 } else if (line_equals(line, l, "BEGIN")) {
406 if (b->auth == _BUS_AUTH_INVALID)
407 r = bus_socket_auth_write(b, "ERROR\r\n");
409 /* We can't leave from the auth phase
410 * before we haven't written
411 * everything queued, so let's check
414 if (bus_socket_auth_needs_write(b))
417 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
418 memmove(b->rbuffer, e + 2, b->rbuffer_size);
419 return bus_start_running(b);
422 } else if (line_begins(line, l, "DATA")) {
424 if (b->auth == _BUS_AUTH_INVALID)
425 r = bus_socket_auth_write(b, "ERROR\r\n");
427 if (b->auth == BUS_AUTH_ANONYMOUS)
428 r = verify_anonymous_token(b, line + 4, l - 4);
430 r = verify_external_token(b, line + 4, l - 4);
435 b->auth = _BUS_AUTH_INVALID;
436 r = bus_socket_auth_write(b, "REJECTED\r\n");
438 r = bus_socket_auth_write_ok(b);
440 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
441 if (b->auth == _BUS_AUTH_INVALID || !b->negotiate_fds)
442 r = bus_socket_auth_write(b, "ERROR\r\n");
445 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
448 r = bus_socket_auth_write(b, "ERROR\r\n");
453 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
459 static int bus_socket_auth_verify(sd_bus *b) {
463 return bus_socket_auth_verify_server(b);
465 return bus_socket_auth_verify_client(b);
468 static int bus_socket_read_auth(sd_bus *b) {
476 struct cmsghdr cmsghdr;
477 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
478 CMSG_SPACE(sizeof(struct ucred)) +
479 CMSG_SPACE(NAME_MAX)]; /*selinux label */
481 struct cmsghdr *cmsg;
482 bool handle_cmsg = false;
485 assert(b->state == BUS_AUTHENTICATING);
487 r = bus_socket_auth_verify(b);
491 n = MAX(256u, b->rbuffer_size * 2);
493 if (n > BUS_AUTH_SIZE_MAX)
494 n = BUS_AUTH_SIZE_MAX;
496 if (b->rbuffer_size >= n)
499 p = realloc(b->rbuffer, n);
506 iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
507 iov.iov_len = n - b->rbuffer_size;
510 k = readv(b->input_fd, &iov, 1);
515 mh.msg_control = &control;
516 mh.msg_controllen = sizeof(control);
518 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
519 if (k < 0 && errno == ENOTSOCK) {
520 b->prefer_readv = true;
521 k = readv(b->input_fd, &iov, 1);
526 return errno == EAGAIN ? 0 : -errno;
530 b->rbuffer_size += k;
533 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
534 if (cmsg->cmsg_level == SOL_SOCKET &&
535 cmsg->cmsg_type == SCM_RIGHTS) {
538 /* Whut? We received fds during the auth
539 * protocol? Somebody is playing games with
540 * us. Close them all, and fail */
541 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
542 close_many((int*) CMSG_DATA(cmsg), j);
545 } else if (cmsg->cmsg_level == SOL_SOCKET &&
546 cmsg->cmsg_type == SCM_CREDENTIALS &&
547 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
549 /* Ignore bogus data, which we might
550 * get on socketpair() sockets */
551 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
552 memcpy(&b->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
553 b->ucred_valid = true;
556 } else if (cmsg->cmsg_level == SOL_SOCKET &&
557 cmsg->cmsg_type == SCM_SECURITY) {
561 l = cmsg->cmsg_len - CMSG_LEN(0);
563 memcpy(&b->label, CMSG_DATA(cmsg), l);
570 r = bus_socket_auth_verify(b);
577 static int bus_socket_setup(sd_bus *b) {
583 /* Enable SO_PASSCRED + SO_PASSEC. We try this on any
584 * socket, just in case. */
585 enable = !b->bus_client;
586 setsockopt(b->input_fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable));
587 setsockopt(b->input_fd, SOL_SOCKET, SO_PASSSEC, &enable, sizeof(enable));
589 /* Increase the buffers to a MB */
590 fd_inc_rcvbuf(b->input_fd, 1024*1024);
591 fd_inc_sndbuf(b->output_fd, 1024*1024);
593 /* Get the peer for socketpair() sockets */
594 l = sizeof(b->ucred);
595 if (getsockopt(b->input_fd, SOL_SOCKET, SO_PEERCRED, &b->ucred, &l) >= 0 && l >= sizeof(b->ucred))
596 b->ucred_valid = b->ucred.pid > 0;
601 static int bus_socket_start_auth_client(sd_bus *b) {
603 const char *auth_suffix, *auth_prefix;
607 if (b->anonymous_auth) {
608 auth_prefix = "\0AUTH ANONYMOUS ";
610 /* For ANONYMOUS auth we send some arbitrary "trace" string */
612 b->auth_buffer = hexmem("anonymous", l);
614 char text[20 + 1]; /* enough space for a 64bit integer plus NUL */
616 auth_prefix = "\0AUTH EXTERNAL ";
618 snprintf(text, sizeof(text), "%lu", (unsigned long) geteuid());
622 b->auth_buffer = hexmem(text, l);
628 if (b->negotiate_fds)
629 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
631 auth_suffix = "\r\nBEGIN\r\n";
633 b->auth_iovec[0].iov_base = (void*) auth_prefix;
634 b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
635 b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
636 b->auth_iovec[1].iov_len = l * 2;
637 b->auth_iovec[2].iov_base = (void*) auth_suffix;
638 b->auth_iovec[2].iov_len = strlen(auth_suffix);
640 return bus_socket_write_auth(b);
643 static int bus_socket_start_auth(sd_bus *b) {
646 b->state = BUS_AUTHENTICATING;
647 b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
649 if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
650 b->negotiate_fds = false;
652 if (b->output_fd != b->input_fd)
653 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
654 b->negotiate_fds = false;
657 return bus_socket_read_auth(b);
659 return bus_socket_start_auth_client(b);
662 int bus_socket_connect(sd_bus *b) {
666 assert(b->input_fd < 0);
667 assert(b->output_fd < 0);
668 assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
670 b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
674 b->output_fd = b->input_fd;
676 r = bus_socket_setup(b);
680 r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
682 if (errno == EINPROGRESS)
688 return bus_socket_start_auth(b);
691 int bus_socket_exec(sd_bus *b) {
696 assert(b->input_fd < 0);
697 assert(b->output_fd < 0);
698 assert(b->exec_path);
700 r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
712 reset_all_signal_handlers();
714 close_all_fds(s+1, 1);
716 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
717 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
719 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
720 close_nointr_nofail(s[1]);
722 fd_cloexec(STDIN_FILENO, false);
723 fd_cloexec(STDOUT_FILENO, false);
724 fd_nonblock(STDIN_FILENO, false);
725 fd_nonblock(STDOUT_FILENO, false);
728 execvp(b->exec_path, b->exec_argv);
730 const char *argv[] = { b->exec_path, NULL };
731 execvp(b->exec_path, (char**) argv);
737 close_nointr_nofail(s[1]);
738 b->output_fd = b->input_fd = s[0];
740 return bus_socket_start_auth(b);
743 int bus_socket_take_fd(sd_bus *b) {
747 r = bus_socket_setup(b);
751 return bus_socket_start_auth(b);
754 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
763 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
765 if (*idx >= BUS_MESSAGE_SIZE(m))
768 bus_message_setup_iovec(m);
770 n = m->n_iovec * sizeof(struct iovec);
772 memcpy(iov, m->iovec, n);
775 iovec_advance(iov, &j, *idx);
777 if (bus->prefer_writev)
778 k = writev(bus->output_fd, iov, m->n_iovec);
784 struct cmsghdr *control;
785 control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
787 mh.msg_control = control;
788 control->cmsg_level = SOL_SOCKET;
789 control->cmsg_type = SCM_RIGHTS;
790 mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
791 memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
795 mh.msg_iovlen = m->n_iovec;
797 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
798 if (k < 0 && errno == ENOTSOCK) {
799 bus->prefer_writev = true;
800 k = writev(bus->output_fd, iov, m->n_iovec);
805 return errno == EAGAIN ? 0 : -errno;
811 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
818 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
820 if (bus->rbuffer_size < sizeof(struct bus_header)) {
821 *need = sizeof(struct bus_header) + 8;
823 /* Minimum message size:
827 * Method Call: +2 string headers
828 * Signal: +3 string headers
829 * Method Error: +1 string headers
831 * Method Reply: +1 uint32 headers
833 * A string header is at least 9 bytes
834 * A uint32 header is at least 8 bytes
836 * Hence the minimum message size of a valid message
837 * is header + 8 bytes */
842 a = ((const uint32_t*) bus->rbuffer)[1];
843 b = ((const uint32_t*) bus->rbuffer)[3];
845 e = ((const uint8_t*) bus->rbuffer)[0];
846 if (e == SD_BUS_LITTLE_ENDIAN) {
849 } else if (e == SD_BUS_BIG_ENDIAN) {
855 sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
856 if (sum >= BUS_MESSAGE_SIZE_MAX)
859 *need = (size_t) sum;
863 static int bus_socket_make_message(sd_bus *bus, size_t size, sd_bus_message **m) {
870 assert(bus->rbuffer_size >= size);
871 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
873 if (bus->rbuffer_size > size) {
874 b = memdup((const uint8_t*) bus->rbuffer + size,
875 bus->rbuffer_size - size);
881 r = bus_message_from_malloc(bus->rbuffer, size,
882 bus->fds, bus->n_fds,
883 bus->ucred_valid ? &bus->ucred : NULL,
884 bus->label[0] ? bus->label : NULL,
892 bus->rbuffer_size -= size;
901 int bus_socket_read_message(sd_bus *bus, sd_bus_message **m) {
909 struct cmsghdr cmsghdr;
910 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
911 CMSG_SPACE(sizeof(struct ucred)) +
912 CMSG_SPACE(NAME_MAX)]; /*selinux label */
914 struct cmsghdr *cmsg;
915 bool handle_cmsg = false;
919 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
921 r = bus_socket_read_message_need(bus, &need);
925 if (bus->rbuffer_size >= need)
926 return bus_socket_make_message(bus, need, m);
928 b = realloc(bus->rbuffer, need);
935 iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
936 iov.iov_len = need - bus->rbuffer_size;
938 if (bus->prefer_readv)
939 k = readv(bus->input_fd, &iov, 1);
944 mh.msg_control = &control;
945 mh.msg_controllen = sizeof(control);
947 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
948 if (k < 0 && errno == ENOTSOCK) {
949 bus->prefer_readv = true;
950 k = readv(bus->input_fd, &iov, 1);
955 return errno == EAGAIN ? 0 : -errno;
959 bus->rbuffer_size += k;
962 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
963 if (cmsg->cmsg_level == SOL_SOCKET &&
964 cmsg->cmsg_type == SCM_RIGHTS) {
967 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
970 /* Whut? We received fds but this
971 * isn't actually enabled? Close them,
974 close_many((int*) CMSG_DATA(cmsg), n);
978 f = realloc(bus->fds, sizeof(int) + (bus->n_fds + n));
980 close_many((int*) CMSG_DATA(cmsg), n);
984 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
987 } else if (cmsg->cmsg_level == SOL_SOCKET &&
988 cmsg->cmsg_type == SCM_CREDENTIALS &&
989 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
991 /* Ignore bogus data, which we might
992 * get on socketpair() sockets */
993 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
994 memcpy(&bus->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
995 bus->ucred_valid = true;
998 } else if (cmsg->cmsg_level == SOL_SOCKET &&
999 cmsg->cmsg_type == SCM_SECURITY) {
1002 l = cmsg->cmsg_len - CMSG_LEN(0);
1004 memcpy(&bus->label, CMSG_DATA(cmsg), l);
1011 r = bus_socket_read_message_need(bus, &need);
1015 if (bus->rbuffer_size >= need)
1016 return bus_socket_make_message(bus, need, m);
1021 int bus_socket_process_opening(sd_bus *b) {
1023 socklen_t slen = sizeof(error);
1030 assert(b->state == BUS_OPENING);
1036 if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1039 r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1041 b->last_connect_error = errno;
1042 else if (error != 0)
1043 b->last_connect_error = error;
1044 else if (p.revents & (POLLERR|POLLHUP))
1045 b->last_connect_error = ECONNREFUSED;
1047 return bus_socket_start_auth(b);
1049 return bus_next_address(b);
1052 int bus_socket_process_authenticating(sd_bus *b) {
1056 assert(b->state == BUS_AUTHENTICATING);
1058 if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1061 r = bus_socket_write_auth(b);
1065 return bus_socket_read_auth(b);