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 #define SNDBUF_SIZE (8*1024*1024)
43 static void iovec_advance(struct iovec iov[], unsigned *idx, size_t size) {
46 struct iovec *i = iov + *idx;
48 if (i->iov_len > size) {
49 i->iov_base = (uint8_t*) i->iov_base + size;
63 static int append_iovec(sd_bus_message *m, const void *p, size_t sz) {
68 m->iovec[m->n_iovec].iov_base = (void*) p;
69 m->iovec[m->n_iovec].iov_len = sz;
75 static int bus_message_setup_iovec(sd_bus_message *m) {
76 struct bus_body_part *part;
88 n = 1 + m->n_body_parts;
89 if (n < ELEMENTSOF(m->iovec_fixed))
90 m->iovec = m->iovec_fixed;
92 m->iovec = new(struct iovec, n);
99 r = append_iovec(m, m->header, BUS_MESSAGE_BODY_BEGIN(m));
103 MESSAGE_FOREACH_PART(part, i, m) {
104 r = bus_body_part_map(part);
108 r = append_iovec(m, part->data, part->size);
113 assert(n == m->n_iovec);
122 bool bus_socket_auth_needs_write(sd_bus *b) {
126 if (b->auth_index >= ELEMENTSOF(b->auth_iovec))
129 for (i = b->auth_index; i < ELEMENTSOF(b->auth_iovec); i++) {
130 struct iovec *j = b->auth_iovec + i;
139 static int bus_socket_write_auth(sd_bus *b) {
143 assert(b->state == BUS_AUTHENTICATING);
145 if (!bus_socket_auth_needs_write(b))
148 if (b->prefer_writev)
149 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
154 mh.msg_iov = b->auth_iovec + b->auth_index;
155 mh.msg_iovlen = ELEMENTSOF(b->auth_iovec) - b->auth_index;
157 k = sendmsg(b->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
158 if (k < 0 && errno == ENOTSOCK) {
159 b->prefer_writev = true;
160 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
165 return errno == EAGAIN ? 0 : -errno;
167 iovec_advance(b->auth_iovec, &b->auth_index, (size_t) k);
171 static int bus_socket_auth_verify_client(sd_bus *b) {
179 /* We expect two response lines: "OK" and possibly
182 e = memmem(b->rbuffer, b->rbuffer_size, "\r\n", 2);
186 if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD) {
187 f = memmem(e + 2, b->rbuffer_size - (e - (char*) b->rbuffer) - 2, "\r\n", 2);
197 /* Nice! We got all the lines we need. First check the OK
200 if (e - (char*) b->rbuffer != 3 + 32)
203 if (memcmp(b->rbuffer, "OK ", 3))
206 b->auth = b->anonymous_auth ? BUS_AUTH_ANONYMOUS : BUS_AUTH_EXTERNAL;
208 for (i = 0; i < 32; i += 2) {
211 x = unhexchar(((char*) b->rbuffer)[3 + i]);
212 y = unhexchar(((char*) b->rbuffer)[3 + i + 1]);
217 peer.bytes[i/2] = ((uint8_t) x << 4 | (uint8_t) y);
220 if (!sd_id128_equal(b->server_id, SD_ID128_NULL) &&
221 !sd_id128_equal(b->server_id, peer))
226 /* And possibly check the second line, too */
230 (f - e == strlen("\r\nAGREE_UNIX_FD")) &&
231 memcmp(e + 2, "AGREE_UNIX_FD", strlen("AGREE_UNIX_FD")) == 0;
233 b->rbuffer_size -= (start - (char*) b->rbuffer);
234 memmove(b->rbuffer, start, b->rbuffer_size);
236 r = bus_start_running(b);
243 static bool line_equals(const char *s, size_t m, const char *line) {
250 return memcmp(s, line, l) == 0;
253 static bool line_begins(const char *s, size_t m, const char *word) {
260 if (memcmp(s, word, l) != 0)
263 return m == l || (m > l && s[l] == ' ');
266 static int verify_anonymous_token(sd_bus *b, const char *p, size_t l) {
267 _cleanup_free_ char *token = NULL;
269 if (!b->anonymous_auth)
280 token = unhexmem(p, l);
284 if (memchr(token, 0, l/2))
287 return !!utf8_is_valid(token);
290 static int verify_external_token(sd_bus *b, const char *p, size_t l) {
291 _cleanup_free_ char *token = NULL;
295 /* We don't do any real authentication here. Instead, we if
296 * the owner of this bus wanted authentication he should have
297 * checked SO_PEERCRED before even creating the bus object. */
299 if (!b->anonymous_auth && !b->ucred_valid)
311 token = unhexmem(p, l);
315 if (memchr(token, 0, l/2))
318 r = parse_uid(token, &u);
322 /* We ignore the passed value if anonymous authentication is
324 if (!b->anonymous_auth && u != b->ucred.uid)
330 static int bus_socket_auth_write(sd_bus *b, const char *t) {
337 /* We only make use of the first iovec */
338 assert(b->auth_index == 0 || b->auth_index == 1);
341 p = malloc(b->auth_iovec[0].iov_len + l);
345 memcpy(p, b->auth_iovec[0].iov_base, b->auth_iovec[0].iov_len);
346 memcpy(p + b->auth_iovec[0].iov_len, t, l);
348 b->auth_iovec[0].iov_base = p;
349 b->auth_iovec[0].iov_len += l;
351 free(b->auth_buffer);
357 static int bus_socket_auth_write_ok(sd_bus *b) {
358 char t[3 + 32 + 2 + 1];
362 xsprintf(t, "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
364 return bus_socket_auth_write(b, t);
367 static int bus_socket_auth_verify_server(sd_bus *b) {
371 bool processed = false;
376 if (b->rbuffer_size < 1)
379 /* First char must be a NUL byte */
380 if (*(char*) b->rbuffer != 0)
383 if (b->rbuffer_size < 3)
386 /* Begin with the first line */
387 if (b->auth_rbegin <= 0)
391 /* Check if line is complete */
392 line = (char*) b->rbuffer + b->auth_rbegin;
393 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
399 if (line_begins(line, l, "AUTH ANONYMOUS")) {
401 r = verify_anonymous_token(b, line + 14, l - 14);
405 r = bus_socket_auth_write(b, "REJECTED\r\n");
407 b->auth = BUS_AUTH_ANONYMOUS;
408 r = bus_socket_auth_write_ok(b);
411 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
413 r = verify_external_token(b, line + 13, l - 13);
417 r = bus_socket_auth_write(b, "REJECTED\r\n");
419 b->auth = BUS_AUTH_EXTERNAL;
420 r = bus_socket_auth_write_ok(b);
423 } else if (line_begins(line, l, "AUTH"))
424 r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
425 else if (line_equals(line, l, "CANCEL") ||
426 line_begins(line, l, "ERROR")) {
428 b->auth = _BUS_AUTH_INVALID;
429 r = bus_socket_auth_write(b, "REJECTED\r\n");
431 } else if (line_equals(line, l, "BEGIN")) {
433 if (b->auth == _BUS_AUTH_INVALID)
434 r = bus_socket_auth_write(b, "ERROR\r\n");
436 /* We can't leave from the auth phase
437 * before we haven't written
438 * everything queued, so let's check
441 if (bus_socket_auth_needs_write(b))
444 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
445 memmove(b->rbuffer, e + 2, b->rbuffer_size);
446 return bus_start_running(b);
449 } else if (line_begins(line, l, "DATA")) {
451 if (b->auth == _BUS_AUTH_INVALID)
452 r = bus_socket_auth_write(b, "ERROR\r\n");
454 if (b->auth == BUS_AUTH_ANONYMOUS)
455 r = verify_anonymous_token(b, line + 4, l - 4);
457 r = verify_external_token(b, line + 4, l - 4);
462 b->auth = _BUS_AUTH_INVALID;
463 r = bus_socket_auth_write(b, "REJECTED\r\n");
465 r = bus_socket_auth_write_ok(b);
467 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
468 if (b->auth == _BUS_AUTH_INVALID || !(b->hello_flags & KDBUS_HELLO_ACCEPT_FD))
469 r = bus_socket_auth_write(b, "ERROR\r\n");
472 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
475 r = bus_socket_auth_write(b, "ERROR\r\n");
480 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
486 static int bus_socket_auth_verify(sd_bus *b) {
490 return bus_socket_auth_verify_server(b);
492 return bus_socket_auth_verify_client(b);
495 static int bus_socket_read_auth(sd_bus *b) {
503 struct cmsghdr cmsghdr;
504 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
505 CMSG_SPACE(sizeof(struct ucred)) +
506 CMSG_SPACE(NAME_MAX)]; /*selinux label */
508 struct cmsghdr *cmsg;
509 bool handle_cmsg = false;
512 assert(b->state == BUS_AUTHENTICATING);
514 r = bus_socket_auth_verify(b);
518 n = MAX(256u, b->rbuffer_size * 2);
520 if (n > BUS_AUTH_SIZE_MAX)
521 n = BUS_AUTH_SIZE_MAX;
523 if (b->rbuffer_size >= n)
526 p = realloc(b->rbuffer, n);
533 iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
534 iov.iov_len = n - b->rbuffer_size;
537 k = readv(b->input_fd, &iov, 1);
542 mh.msg_control = &control;
543 mh.msg_controllen = sizeof(control);
545 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
546 if (k < 0 && errno == ENOTSOCK) {
547 b->prefer_readv = true;
548 k = readv(b->input_fd, &iov, 1);
553 return errno == EAGAIN ? 0 : -errno;
557 b->rbuffer_size += k;
560 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
561 if (cmsg->cmsg_level == SOL_SOCKET &&
562 cmsg->cmsg_type == SCM_RIGHTS) {
565 /* Whut? We received fds during the auth
566 * protocol? Somebody is playing games with
567 * us. Close them all, and fail */
568 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
569 close_many((int*) CMSG_DATA(cmsg), j);
572 } else if (cmsg->cmsg_level == SOL_SOCKET &&
573 cmsg->cmsg_type == SCM_CREDENTIALS &&
574 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
576 /* Ignore bogus data, which we might
577 * get on socketpair() sockets */
578 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
579 memcpy(&b->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
580 b->ucred_valid = true;
583 } else if (cmsg->cmsg_level == SOL_SOCKET &&
584 cmsg->cmsg_type == SCM_SECURITY) {
588 l = cmsg->cmsg_len - CMSG_LEN(0);
590 memcpy(&b->label, CMSG_DATA(cmsg), l);
597 r = bus_socket_auth_verify(b);
604 void bus_socket_setup(sd_bus *b) {
609 /* Enable SO_PASSCRED + SO_PASSEC. We try this on any
610 * socket, just in case. */
611 enable = !b->bus_client;
612 (void)setsockopt(b->input_fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable));
614 enable = !b->bus_client && (b->attach_flags & KDBUS_ATTACH_SECLABEL);
615 (void)setsockopt(b->input_fd, SOL_SOCKET, SO_PASSSEC, &enable, sizeof(enable));
617 /* Increase the buffers to 8 MB */
618 fd_inc_rcvbuf(b->input_fd, SNDBUF_SIZE);
619 fd_inc_sndbuf(b->output_fd, SNDBUF_SIZE);
621 b->is_kernel = false;
622 b->message_version = 1;
623 b->message_endian = 0;
626 static void bus_get_peercred(sd_bus *b) {
629 /* Get the peer for socketpair() sockets */
630 b->ucred_valid = getpeercred(b->input_fd, &b->ucred) >= 0;
633 static int bus_socket_start_auth_client(sd_bus *b) {
635 const char *auth_suffix, *auth_prefix;
639 if (b->anonymous_auth) {
640 auth_prefix = "\0AUTH ANONYMOUS ";
642 /* For ANONYMOUS auth we send some arbitrary "trace" string */
644 b->auth_buffer = hexmem("anonymous", l);
646 char text[DECIMAL_STR_MAX(uid_t) + 1];
648 auth_prefix = "\0AUTH EXTERNAL ";
650 xsprintf(text, UID_FMT, geteuid());
653 b->auth_buffer = hexmem(text, l);
659 if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD)
660 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
662 auth_suffix = "\r\nBEGIN\r\n";
664 b->auth_iovec[0].iov_base = (void*) auth_prefix;
665 b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
666 b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
667 b->auth_iovec[1].iov_len = l * 2;
668 b->auth_iovec[2].iov_base = (void*) auth_suffix;
669 b->auth_iovec[2].iov_len = strlen(auth_suffix);
671 return bus_socket_write_auth(b);
674 int bus_socket_start_auth(sd_bus *b) {
679 b->state = BUS_AUTHENTICATING;
680 b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
682 if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
683 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
685 if (b->output_fd != b->input_fd)
686 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
687 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
690 return bus_socket_read_auth(b);
692 return bus_socket_start_auth_client(b);
695 int bus_socket_connect(sd_bus *b) {
699 assert(b->input_fd < 0);
700 assert(b->output_fd < 0);
701 assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
703 b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
707 b->output_fd = b->input_fd;
711 r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
713 if (errno == EINPROGRESS)
719 return bus_socket_start_auth(b);
722 int bus_socket_exec(sd_bus *b) {
727 assert(b->input_fd < 0);
728 assert(b->output_fd < 0);
729 assert(b->exec_path);
731 r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
743 reset_all_signal_handlers();
745 close_all_fds(s+1, 1);
747 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
748 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
750 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
753 fd_cloexec(STDIN_FILENO, false);
754 fd_cloexec(STDOUT_FILENO, false);
755 fd_nonblock(STDIN_FILENO, false);
756 fd_nonblock(STDOUT_FILENO, false);
759 execvp(b->exec_path, b->exec_argv);
761 const char *argv[] = { b->exec_path, NULL };
762 execvp(b->exec_path, (char**) argv);
769 b->output_fd = b->input_fd = s[0];
773 return bus_socket_start_auth(b);
776 int bus_socket_take_fd(sd_bus *b) {
781 return bus_socket_start_auth(b);
784 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
794 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
796 if (*idx >= BUS_MESSAGE_SIZE(m))
799 r = bus_message_setup_iovec(m);
803 n = m->n_iovec * sizeof(struct iovec);
805 memcpy(iov, m->iovec, n);
808 iovec_advance(iov, &j, *idx);
810 if (bus->prefer_writev)
811 k = writev(bus->output_fd, iov, m->n_iovec);
817 struct cmsghdr *control;
818 control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
820 mh.msg_control = control;
821 control->cmsg_level = SOL_SOCKET;
822 control->cmsg_type = SCM_RIGHTS;
823 mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
824 memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
828 mh.msg_iovlen = m->n_iovec;
830 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
831 if (k < 0 && errno == ENOTSOCK) {
832 bus->prefer_writev = true;
833 k = writev(bus->output_fd, iov, m->n_iovec);
838 return errno == EAGAIN ? 0 : -errno;
844 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
851 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
853 if (bus->rbuffer_size < sizeof(struct bus_header)) {
854 *need = sizeof(struct bus_header) + 8;
856 /* Minimum message size:
860 * Method Call: +2 string headers
861 * Signal: +3 string headers
862 * Method Error: +1 string headers
864 * Method Reply: +1 uint32 headers
866 * A string header is at least 9 bytes
867 * A uint32 header is at least 8 bytes
869 * Hence the minimum message size of a valid message
870 * is header + 8 bytes */
875 a = ((const uint32_t*) bus->rbuffer)[1];
876 b = ((const uint32_t*) bus->rbuffer)[3];
878 e = ((const uint8_t*) bus->rbuffer)[0];
879 if (e == BUS_LITTLE_ENDIAN) {
882 } else if (e == BUS_BIG_ENDIAN) {
888 sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
889 if (sum >= BUS_MESSAGE_SIZE_MAX)
892 *need = (size_t) sum;
896 static int bus_socket_make_message(sd_bus *bus, size_t size) {
902 assert(bus->rbuffer_size >= size);
903 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
905 r = bus_rqueue_make_room(bus);
909 if (bus->rbuffer_size > size) {
910 b = memdup((const uint8_t*) bus->rbuffer + size,
911 bus->rbuffer_size - size);
917 r = bus_message_from_malloc(bus,
919 bus->fds, bus->n_fds,
920 !bus->bus_client && bus->ucred_valid ? &bus->ucred : NULL,
921 !bus->bus_client && bus->label[0] ? bus->label : NULL,
929 bus->rbuffer_size -= size;
934 bus->rqueue[bus->rqueue_size++] = t;
939 int bus_socket_read_message(sd_bus *bus) {
947 struct cmsghdr cmsghdr;
948 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
949 CMSG_SPACE(sizeof(struct ucred)) +
950 CMSG_SPACE(NAME_MAX)]; /*selinux label */
952 struct cmsghdr *cmsg;
953 bool handle_cmsg = false;
956 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
958 r = bus_socket_read_message_need(bus, &need);
962 if (bus->rbuffer_size >= need)
963 return bus_socket_make_message(bus, need);
965 b = realloc(bus->rbuffer, need);
972 iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
973 iov.iov_len = need - bus->rbuffer_size;
975 if (bus->prefer_readv)
976 k = readv(bus->input_fd, &iov, 1);
981 mh.msg_control = &control;
982 mh.msg_controllen = sizeof(control);
984 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
985 if (k < 0 && errno == ENOTSOCK) {
986 bus->prefer_readv = true;
987 k = readv(bus->input_fd, &iov, 1);
992 return errno == EAGAIN ? 0 : -errno;
996 bus->rbuffer_size += k;
999 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
1000 if (cmsg->cmsg_level == SOL_SOCKET &&
1001 cmsg->cmsg_type == SCM_RIGHTS) {
1004 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1006 if (!bus->can_fds) {
1007 /* Whut? We received fds but this
1008 * isn't actually enabled? Close them,
1011 close_many((int*) CMSG_DATA(cmsg), n);
1015 f = realloc(bus->fds, sizeof(int) + (bus->n_fds + n));
1017 close_many((int*) CMSG_DATA(cmsg), n);
1021 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1024 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1025 cmsg->cmsg_type == SCM_CREDENTIALS &&
1026 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1028 /* Ignore bogus data, which we might
1029 * get on socketpair() sockets */
1030 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
1031 memcpy(&bus->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
1032 bus->ucred_valid = true;
1035 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1036 cmsg->cmsg_type == SCM_SECURITY) {
1039 l = cmsg->cmsg_len - CMSG_LEN(0);
1041 memcpy(&bus->label, CMSG_DATA(cmsg), l);
1048 r = bus_socket_read_message_need(bus, &need);
1052 if (bus->rbuffer_size >= need)
1053 return bus_socket_make_message(bus, need);
1058 int bus_socket_process_opening(sd_bus *b) {
1060 socklen_t slen = sizeof(error);
1067 assert(b->state == BUS_OPENING);
1073 if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1076 r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1078 b->last_connect_error = errno;
1079 else if (error != 0)
1080 b->last_connect_error = error;
1081 else if (p.revents & (POLLERR|POLLHUP))
1082 b->last_connect_error = ECONNREFUSED;
1084 return bus_socket_start_auth(b);
1086 return bus_next_address(b);
1089 int bus_socket_process_authenticating(sd_bus *b) {
1093 assert(b->state == BUS_AUTHENTICATING);
1095 if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1098 r = bus_socket_write_auth(b);
1102 return bus_socket_read_auth(b);