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 int 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;
73 static int bus_message_setup_iovec(sd_bus_message *m) {
74 struct bus_body_part *part;
86 n = 1 + !!m->fields + m->n_body_parts;
87 if (n < ELEMENTSOF(m->iovec_fixed))
88 m->iovec = m->iovec_fixed;
90 m->iovec = new(struct iovec, n);
95 r = append_iovec(m, m->header, sizeof(*m->header));
100 r = append_iovec(m, m->fields, ALIGN8(m->header->fields_size));
105 for (i = 0, part = &m->body; i < m->n_body_parts; i++, part = part->next) {
106 r = append_iovec(m, part->data, part->size);
111 assert(n == m->n_iovec);
116 bool bus_socket_auth_needs_write(sd_bus *b) {
120 if (b->auth_index >= ELEMENTSOF(b->auth_iovec))
123 for (i = b->auth_index; i < ELEMENTSOF(b->auth_iovec); i++) {
124 struct iovec *j = b->auth_iovec + i;
133 static int bus_socket_write_auth(sd_bus *b) {
137 assert(b->state == BUS_AUTHENTICATING);
139 if (!bus_socket_auth_needs_write(b))
142 if (b->prefer_writev)
143 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
148 mh.msg_iov = b->auth_iovec + b->auth_index;
149 mh.msg_iovlen = ELEMENTSOF(b->auth_iovec) - b->auth_index;
151 k = sendmsg(b->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
152 if (k < 0 && errno == ENOTSOCK) {
153 b->prefer_writev = true;
154 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
159 return errno == EAGAIN ? 0 : -errno;
161 iovec_advance(b->auth_iovec, &b->auth_index, (size_t) k);
165 static int bus_socket_auth_verify_client(sd_bus *b) {
173 /* We expect two response lines: "OK" and possibly
176 e = memmem(b->rbuffer, b->rbuffer_size, "\r\n", 2);
180 if (b->negotiate_fds) {
181 f = memmem(e + 2, b->rbuffer_size - (e - (char*) b->rbuffer) - 2, "\r\n", 2);
191 /* Nice! We got all the lines we need. First check the OK
194 if (e - (char*) b->rbuffer != 3 + 32)
197 if (memcmp(b->rbuffer, "OK ", 3))
200 b->auth = b->anonymous_auth ? BUS_AUTH_ANONYMOUS : BUS_AUTH_EXTERNAL;
202 for (i = 0; i < 32; i += 2) {
205 x = unhexchar(((char*) b->rbuffer)[3 + i]);
206 y = unhexchar(((char*) b->rbuffer)[3 + i + 1]);
211 peer.bytes[i/2] = ((uint8_t) x << 4 | (uint8_t) y);
214 if (!sd_id128_equal(b->server_id, SD_ID128_NULL) &&
215 !sd_id128_equal(b->server_id, peer))
220 /* And possibly check the second line, too */
224 (f - e == sizeof("\r\nAGREE_UNIX_FD") - 1) &&
225 memcmp(e + 2, "AGREE_UNIX_FD", sizeof("AGREE_UNIX_FD") - 1) == 0;
227 b->rbuffer_size -= (start - (char*) b->rbuffer);
228 memmove(b->rbuffer, start, b->rbuffer_size);
230 r = bus_start_running(b);
237 static bool line_equals(const char *s, size_t m, const char *line) {
244 return memcmp(s, line, l) == 0;
247 static bool line_begins(const char *s, size_t m, const char *word) {
254 if (memcmp(s, word, l) != 0)
257 return m == l || (m > l && s[l] == ' ');
260 static int verify_anonymous_token(sd_bus *b, const char *p, size_t l) {
261 _cleanup_free_ char *token = NULL;
263 if (!b->anonymous_auth)
274 token = unhexmem(p, l);
278 if (memchr(token, 0, l/2))
281 return !!utf8_is_valid(token);
284 static int verify_external_token(sd_bus *b, const char *p, size_t l) {
285 _cleanup_free_ char *token = NULL;
289 /* We don't do any real authentication here. Instead, we if
290 * the owner of this bus wanted authentication he should have
291 * checked SO_PEERCRED before even creating the bus object. */
293 if (!b->anonymous_auth && !b->ucred_valid)
305 token = unhexmem(p, l);
309 if (memchr(token, 0, l/2))
312 r = parse_uid(token, &u);
316 /* We ignore the passed value if anonymous authentication is
318 if (!b->anonymous_auth && u != b->ucred.uid)
324 static int bus_socket_auth_write(sd_bus *b, const char *t) {
331 /* We only make use of the first iovec */
332 assert(b->auth_index == 0 || b->auth_index == 1);
335 p = malloc(b->auth_iovec[0].iov_len + l);
339 memcpy(p, b->auth_iovec[0].iov_base, b->auth_iovec[0].iov_len);
340 memcpy(p + b->auth_iovec[0].iov_len, t, l);
342 b->auth_iovec[0].iov_base = p;
343 b->auth_iovec[0].iov_len += l;
345 free(b->auth_buffer);
351 static int bus_socket_auth_write_ok(sd_bus *b) {
352 char t[3 + 32 + 2 + 1];
356 snprintf(t, sizeof(t), "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
359 return bus_socket_auth_write(b, t);
362 static int bus_socket_auth_verify_server(sd_bus *b) {
366 bool processed = false;
371 if (b->rbuffer_size < 1)
374 /* First char must be a NUL byte */
375 if (*(char*) b->rbuffer != 0)
378 if (b->rbuffer_size < 3)
381 /* Begin with the first line */
382 if (b->auth_rbegin <= 0)
386 /* Check if line is complete */
387 line = (char*) b->rbuffer + b->auth_rbegin;
388 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
394 if (line_begins(line, l, "AUTH ANONYMOUS")) {
396 r = verify_anonymous_token(b, line + 14, l - 14);
400 r = bus_socket_auth_write(b, "REJECTED\r\n");
402 b->auth = BUS_AUTH_ANONYMOUS;
403 r = bus_socket_auth_write_ok(b);
406 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
408 r = verify_external_token(b, line + 13, l - 13);
412 r = bus_socket_auth_write(b, "REJECTED\r\n");
414 b->auth = BUS_AUTH_EXTERNAL;
415 r = bus_socket_auth_write_ok(b);
418 } else if (line_begins(line, l, "AUTH"))
419 r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
420 else if (line_equals(line, l, "CANCEL") ||
421 line_begins(line, l, "ERROR")) {
423 b->auth = _BUS_AUTH_INVALID;
424 r = bus_socket_auth_write(b, "REJECTED\r\n");
426 } else if (line_equals(line, l, "BEGIN")) {
428 if (b->auth == _BUS_AUTH_INVALID)
429 r = bus_socket_auth_write(b, "ERROR\r\n");
431 /* We can't leave from the auth phase
432 * before we haven't written
433 * everything queued, so let's check
436 if (bus_socket_auth_needs_write(b))
439 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
440 memmove(b->rbuffer, e + 2, b->rbuffer_size);
441 return bus_start_running(b);
444 } else if (line_begins(line, l, "DATA")) {
446 if (b->auth == _BUS_AUTH_INVALID)
447 r = bus_socket_auth_write(b, "ERROR\r\n");
449 if (b->auth == BUS_AUTH_ANONYMOUS)
450 r = verify_anonymous_token(b, line + 4, l - 4);
452 r = verify_external_token(b, line + 4, l - 4);
457 b->auth = _BUS_AUTH_INVALID;
458 r = bus_socket_auth_write(b, "REJECTED\r\n");
460 r = bus_socket_auth_write_ok(b);
462 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
463 if (b->auth == _BUS_AUTH_INVALID || !b->negotiate_fds)
464 r = bus_socket_auth_write(b, "ERROR\r\n");
467 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
470 r = bus_socket_auth_write(b, "ERROR\r\n");
475 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
481 static int bus_socket_auth_verify(sd_bus *b) {
485 return bus_socket_auth_verify_server(b);
487 return bus_socket_auth_verify_client(b);
490 static int bus_socket_read_auth(sd_bus *b) {
498 struct cmsghdr cmsghdr;
499 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
500 CMSG_SPACE(sizeof(struct ucred)) +
501 CMSG_SPACE(NAME_MAX)]; /*selinux label */
503 struct cmsghdr *cmsg;
504 bool handle_cmsg = false;
507 assert(b->state == BUS_AUTHENTICATING);
509 r = bus_socket_auth_verify(b);
513 n = MAX(256u, b->rbuffer_size * 2);
515 if (n > BUS_AUTH_SIZE_MAX)
516 n = BUS_AUTH_SIZE_MAX;
518 if (b->rbuffer_size >= n)
521 p = realloc(b->rbuffer, n);
528 iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
529 iov.iov_len = n - b->rbuffer_size;
532 k = readv(b->input_fd, &iov, 1);
537 mh.msg_control = &control;
538 mh.msg_controllen = sizeof(control);
540 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
541 if (k < 0 && errno == ENOTSOCK) {
542 b->prefer_readv = true;
543 k = readv(b->input_fd, &iov, 1);
548 return errno == EAGAIN ? 0 : -errno;
552 b->rbuffer_size += k;
555 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
556 if (cmsg->cmsg_level == SOL_SOCKET &&
557 cmsg->cmsg_type == SCM_RIGHTS) {
560 /* Whut? We received fds during the auth
561 * protocol? Somebody is playing games with
562 * us. Close them all, and fail */
563 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
564 close_many((int*) CMSG_DATA(cmsg), j);
567 } else if (cmsg->cmsg_level == SOL_SOCKET &&
568 cmsg->cmsg_type == SCM_CREDENTIALS &&
569 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
571 /* Ignore bogus data, which we might
572 * get on socketpair() sockets */
573 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
574 memcpy(&b->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
575 b->ucred_valid = true;
578 } else if (cmsg->cmsg_level == SOL_SOCKET &&
579 cmsg->cmsg_type == SCM_SECURITY) {
583 l = cmsg->cmsg_len - CMSG_LEN(0);
585 memcpy(&b->label, CMSG_DATA(cmsg), l);
592 r = bus_socket_auth_verify(b);
599 static int bus_socket_setup(sd_bus *b) {
605 /* Enable SO_PASSCRED + SO_PASSEC. We try this on any
606 * socket, just in case. */
607 enable = !b->bus_client;
608 setsockopt(b->input_fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable));
609 setsockopt(b->input_fd, SOL_SOCKET, SO_PASSSEC, &enable, sizeof(enable));
611 /* Increase the buffers to a MB */
612 fd_inc_rcvbuf(b->input_fd, 1024*1024);
613 fd_inc_sndbuf(b->output_fd, 1024*1024);
615 /* Get the peer for socketpair() sockets */
616 l = sizeof(b->ucred);
617 if (getsockopt(b->input_fd, SOL_SOCKET, SO_PEERCRED, &b->ucred, &l) >= 0 && l >= sizeof(b->ucred))
618 b->ucred_valid = b->ucred.pid > 0;
623 static int bus_socket_start_auth_client(sd_bus *b) {
625 const char *auth_suffix, *auth_prefix;
629 if (b->anonymous_auth) {
630 auth_prefix = "\0AUTH ANONYMOUS ";
632 /* For ANONYMOUS auth we send some arbitrary "trace" string */
634 b->auth_buffer = hexmem("anonymous", l);
636 char text[20 + 1]; /* enough space for a 64bit integer plus NUL */
638 auth_prefix = "\0AUTH EXTERNAL ";
640 snprintf(text, sizeof(text), "%lu", (unsigned long) geteuid());
644 b->auth_buffer = hexmem(text, l);
650 if (b->negotiate_fds)
651 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
653 auth_suffix = "\r\nBEGIN\r\n";
655 b->auth_iovec[0].iov_base = (void*) auth_prefix;
656 b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
657 b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
658 b->auth_iovec[1].iov_len = l * 2;
659 b->auth_iovec[2].iov_base = (void*) auth_suffix;
660 b->auth_iovec[2].iov_len = strlen(auth_suffix);
662 return bus_socket_write_auth(b);
665 static int bus_socket_start_auth(sd_bus *b) {
668 b->state = BUS_AUTHENTICATING;
669 b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
671 if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
672 b->negotiate_fds = false;
674 if (b->output_fd != b->input_fd)
675 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
676 b->negotiate_fds = false;
679 return bus_socket_read_auth(b);
681 return bus_socket_start_auth_client(b);
684 int bus_socket_connect(sd_bus *b) {
688 assert(b->input_fd < 0);
689 assert(b->output_fd < 0);
690 assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
692 b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
696 b->output_fd = b->input_fd;
698 r = bus_socket_setup(b);
702 r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
704 if (errno == EINPROGRESS)
710 return bus_socket_start_auth(b);
713 int bus_socket_exec(sd_bus *b) {
718 assert(b->input_fd < 0);
719 assert(b->output_fd < 0);
720 assert(b->exec_path);
722 r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
734 reset_all_signal_handlers();
736 close_all_fds(s+1, 1);
738 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
739 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
741 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
742 close_nointr_nofail(s[1]);
744 fd_cloexec(STDIN_FILENO, false);
745 fd_cloexec(STDOUT_FILENO, false);
746 fd_nonblock(STDIN_FILENO, false);
747 fd_nonblock(STDOUT_FILENO, false);
750 execvp(b->exec_path, b->exec_argv);
752 const char *argv[] = { b->exec_path, NULL };
753 execvp(b->exec_path, (char**) argv);
759 close_nointr_nofail(s[1]);
760 b->output_fd = b->input_fd = s[0];
762 return bus_socket_start_auth(b);
765 int bus_socket_take_fd(sd_bus *b) {
769 r = bus_socket_setup(b);
773 return bus_socket_start_auth(b);
776 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
786 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
788 if (*idx >= BUS_MESSAGE_SIZE(m))
791 r = bus_message_setup_iovec(m);
795 n = m->n_iovec * sizeof(struct iovec);
797 memcpy(iov, m->iovec, n);
800 iovec_advance(iov, &j, *idx);
802 if (bus->prefer_writev)
803 k = writev(bus->output_fd, iov, m->n_iovec);
809 struct cmsghdr *control;
810 control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
812 mh.msg_control = control;
813 control->cmsg_level = SOL_SOCKET;
814 control->cmsg_type = SCM_RIGHTS;
815 mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
816 memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
820 mh.msg_iovlen = m->n_iovec;
822 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
823 if (k < 0 && errno == ENOTSOCK) {
824 bus->prefer_writev = true;
825 k = writev(bus->output_fd, iov, m->n_iovec);
830 return errno == EAGAIN ? 0 : -errno;
836 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
843 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
845 if (bus->rbuffer_size < sizeof(struct bus_header)) {
846 *need = sizeof(struct bus_header) + 8;
848 /* Minimum message size:
852 * Method Call: +2 string headers
853 * Signal: +3 string headers
854 * Method Error: +1 string headers
856 * Method Reply: +1 uint32 headers
858 * A string header is at least 9 bytes
859 * A uint32 header is at least 8 bytes
861 * Hence the minimum message size of a valid message
862 * is header + 8 bytes */
867 a = ((const uint32_t*) bus->rbuffer)[1];
868 b = ((const uint32_t*) bus->rbuffer)[3];
870 e = ((const uint8_t*) bus->rbuffer)[0];
871 if (e == SD_BUS_LITTLE_ENDIAN) {
874 } else if (e == SD_BUS_BIG_ENDIAN) {
880 sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
881 if (sum >= BUS_MESSAGE_SIZE_MAX)
884 *need = (size_t) sum;
888 static int bus_socket_make_message(sd_bus *bus, size_t size, sd_bus_message **m) {
895 assert(bus->rbuffer_size >= size);
896 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
898 if (bus->rbuffer_size > size) {
899 b = memdup((const uint8_t*) bus->rbuffer + size,
900 bus->rbuffer_size - size);
906 r = bus_message_from_malloc(bus->rbuffer, size,
907 bus->fds, bus->n_fds,
908 bus->ucred_valid ? &bus->ucred : NULL,
909 bus->label[0] ? bus->label : NULL,
917 bus->rbuffer_size -= size;
926 int bus_socket_read_message(sd_bus *bus, sd_bus_message **m) {
934 struct cmsghdr cmsghdr;
935 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
936 CMSG_SPACE(sizeof(struct ucred)) +
937 CMSG_SPACE(NAME_MAX)]; /*selinux label */
939 struct cmsghdr *cmsg;
940 bool handle_cmsg = false;
944 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
946 r = bus_socket_read_message_need(bus, &need);
950 if (bus->rbuffer_size >= need)
951 return bus_socket_make_message(bus, need, m);
953 b = realloc(bus->rbuffer, need);
960 iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
961 iov.iov_len = need - bus->rbuffer_size;
963 if (bus->prefer_readv)
964 k = readv(bus->input_fd, &iov, 1);
969 mh.msg_control = &control;
970 mh.msg_controllen = sizeof(control);
972 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
973 if (k < 0 && errno == ENOTSOCK) {
974 bus->prefer_readv = true;
975 k = readv(bus->input_fd, &iov, 1);
980 return errno == EAGAIN ? 0 : -errno;
984 bus->rbuffer_size += k;
987 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
988 if (cmsg->cmsg_level == SOL_SOCKET &&
989 cmsg->cmsg_type == SCM_RIGHTS) {
992 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
995 /* Whut? We received fds but this
996 * isn't actually enabled? Close them,
999 close_many((int*) CMSG_DATA(cmsg), n);
1003 f = realloc(bus->fds, sizeof(int) + (bus->n_fds + n));
1005 close_many((int*) CMSG_DATA(cmsg), n);
1009 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1012 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1013 cmsg->cmsg_type == SCM_CREDENTIALS &&
1014 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1016 /* Ignore bogus data, which we might
1017 * get on socketpair() sockets */
1018 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
1019 memcpy(&bus->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
1020 bus->ucred_valid = true;
1023 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1024 cmsg->cmsg_type == SCM_SECURITY) {
1027 l = cmsg->cmsg_len - CMSG_LEN(0);
1029 memcpy(&bus->label, CMSG_DATA(cmsg), l);
1036 r = bus_socket_read_message_need(bus, &need);
1040 if (bus->rbuffer_size >= need)
1041 return bus_socket_make_message(bus, need, m);
1046 int bus_socket_process_opening(sd_bus *b) {
1048 socklen_t slen = sizeof(error);
1055 assert(b->state == BUS_OPENING);
1061 if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1064 r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1066 b->last_connect_error = errno;
1067 else if (error != 0)
1068 b->last_connect_error = error;
1069 else if (p.revents & (POLLERR|POLLHUP))
1070 b->last_connect_error = ECONNREFUSED;
1072 return bus_socket_start_auth(b);
1074 return bus_next_address(b);
1077 int bus_socket_process_authenticating(sd_bus *b) {
1081 assert(b->state == BUS_AUTHENTICATING);
1083 if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1086 r = bus_socket_write_auth(b);
1090 return bus_socket_read_auth(b);