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/>.
31 #include "sd-daemon.h"
34 #include "bus-socket.h"
35 #include "bus-internal.h"
36 #include "bus-message.h"
38 #define SNDBUF_SIZE (8*1024*1024)
40 static void iovec_advance(struct iovec iov[], unsigned *idx, size_t size) {
43 struct iovec *i = iov + *idx;
45 if (i->iov_len > size) {
46 i->iov_base = (uint8_t*) i->iov_base + size;
60 static int append_iovec(sd_bus_message *m, const void *p, size_t sz) {
65 m->iovec[m->n_iovec].iov_base = (void*) p;
66 m->iovec[m->n_iovec].iov_len = sz;
72 static int bus_message_setup_iovec(sd_bus_message *m) {
73 struct bus_body_part *part;
85 n = 1 + m->n_body_parts;
86 if (n < ELEMENTSOF(m->iovec_fixed))
87 m->iovec = m->iovec_fixed;
89 m->iovec = new(struct iovec, n);
96 r = append_iovec(m, m->header, BUS_MESSAGE_BODY_BEGIN(m));
100 MESSAGE_FOREACH_PART(part, i, m) {
101 r = bus_body_part_map(part);
105 r = append_iovec(m, part->data, part->size);
110 assert(n == m->n_iovec);
119 bool bus_socket_auth_needs_write(sd_bus *b) {
123 if (b->auth_index >= ELEMENTSOF(b->auth_iovec))
126 for (i = b->auth_index; i < ELEMENTSOF(b->auth_iovec); i++) {
127 struct iovec *j = b->auth_iovec + i;
136 static int bus_socket_write_auth(sd_bus *b) {
140 assert(b->state == BUS_AUTHENTICATING);
142 if (!bus_socket_auth_needs_write(b))
145 if (b->prefer_writev)
146 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
151 mh.msg_iov = b->auth_iovec + b->auth_index;
152 mh.msg_iovlen = ELEMENTSOF(b->auth_iovec) - b->auth_index;
154 k = sendmsg(b->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
155 if (k < 0 && errno == ENOTSOCK) {
156 b->prefer_writev = true;
157 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
162 return errno == EAGAIN ? 0 : -errno;
164 iovec_advance(b->auth_iovec, &b->auth_index, (size_t) k);
168 static int bus_socket_auth_verify_client(sd_bus *b) {
176 /* We expect two response lines: "OK" and possibly
179 e = memmem(b->rbuffer, b->rbuffer_size, "\r\n", 2);
183 if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD) {
184 f = memmem(e + 2, b->rbuffer_size - (e - (char*) b->rbuffer) - 2, "\r\n", 2);
194 /* Nice! We got all the lines we need. First check the OK
197 if (e - (char*) b->rbuffer != 3 + 32)
200 if (memcmp(b->rbuffer, "OK ", 3))
203 b->auth = b->anonymous_auth ? BUS_AUTH_ANONYMOUS : BUS_AUTH_EXTERNAL;
205 for (i = 0; i < 32; i += 2) {
208 x = unhexchar(((char*) b->rbuffer)[3 + i]);
209 y = unhexchar(((char*) b->rbuffer)[3 + i + 1]);
214 peer.bytes[i/2] = ((uint8_t) x << 4 | (uint8_t) y);
217 if (!sd_id128_equal(b->server_id, SD_ID128_NULL) &&
218 !sd_id128_equal(b->server_id, peer))
223 /* And possibly check the second line, too */
227 (f - e == strlen("\r\nAGREE_UNIX_FD")) &&
228 memcmp(e + 2, "AGREE_UNIX_FD", strlen("AGREE_UNIX_FD")) == 0;
230 b->rbuffer_size -= (start - (char*) b->rbuffer);
231 memmove(b->rbuffer, start, b->rbuffer_size);
233 r = bus_start_running(b);
240 static bool line_equals(const char *s, size_t m, const char *line) {
247 return memcmp(s, line, l) == 0;
250 static bool line_begins(const char *s, size_t m, const char *word) {
257 if (memcmp(s, word, l) != 0)
260 return m == l || (m > l && s[l] == ' ');
263 static int verify_anonymous_token(sd_bus *b, const char *p, size_t l) {
264 _cleanup_free_ char *token = NULL;
266 if (!b->anonymous_auth)
277 token = unhexmem(p, l);
281 if (memchr(token, 0, l/2))
284 return !!utf8_is_valid(token);
287 static int verify_external_token(sd_bus *b, const char *p, size_t l) {
288 _cleanup_free_ char *token = NULL;
292 /* We don't do any real authentication here. Instead, we if
293 * the owner of this bus wanted authentication he should have
294 * checked SO_PEERCRED before even creating the bus object. */
296 if (!b->anonymous_auth && !b->ucred_valid)
308 token = unhexmem(p, l);
312 if (memchr(token, 0, l/2))
315 r = parse_uid(token, &u);
319 /* We ignore the passed value if anonymous authentication is
321 if (!b->anonymous_auth && u != b->ucred.uid)
327 static int bus_socket_auth_write(sd_bus *b, const char *t) {
334 /* We only make use of the first iovec */
335 assert(b->auth_index == 0 || b->auth_index == 1);
338 p = malloc(b->auth_iovec[0].iov_len + l);
342 memcpy(p, b->auth_iovec[0].iov_base, b->auth_iovec[0].iov_len);
343 memcpy(p + b->auth_iovec[0].iov_len, t, l);
345 b->auth_iovec[0].iov_base = p;
346 b->auth_iovec[0].iov_len += l;
348 free(b->auth_buffer);
354 static int bus_socket_auth_write_ok(sd_bus *b) {
355 char t[3 + 32 + 2 + 1];
359 xsprintf(t, "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
361 return bus_socket_auth_write(b, t);
364 static int bus_socket_auth_verify_server(sd_bus *b) {
368 bool processed = false;
373 if (b->rbuffer_size < 1)
376 /* First char must be a NUL byte */
377 if (*(char*) b->rbuffer != 0)
380 if (b->rbuffer_size < 3)
383 /* Begin with the first line */
384 if (b->auth_rbegin <= 0)
388 /* Check if line is complete */
389 line = (char*) b->rbuffer + b->auth_rbegin;
390 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
396 if (line_begins(line, l, "AUTH ANONYMOUS")) {
398 r = verify_anonymous_token(b, line + 14, l - 14);
402 r = bus_socket_auth_write(b, "REJECTED\r\n");
404 b->auth = BUS_AUTH_ANONYMOUS;
405 r = bus_socket_auth_write_ok(b);
408 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
410 r = verify_external_token(b, line + 13, l - 13);
414 r = bus_socket_auth_write(b, "REJECTED\r\n");
416 b->auth = BUS_AUTH_EXTERNAL;
417 r = bus_socket_auth_write_ok(b);
420 } else if (line_begins(line, l, "AUTH"))
421 r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
422 else if (line_equals(line, l, "CANCEL") ||
423 line_begins(line, l, "ERROR")) {
425 b->auth = _BUS_AUTH_INVALID;
426 r = bus_socket_auth_write(b, "REJECTED\r\n");
428 } else if (line_equals(line, l, "BEGIN")) {
430 if (b->auth == _BUS_AUTH_INVALID)
431 r = bus_socket_auth_write(b, "ERROR\r\n");
433 /* We can't leave from the auth phase
434 * before we haven't written
435 * everything queued, so let's check
438 if (bus_socket_auth_needs_write(b))
441 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
442 memmove(b->rbuffer, e + 2, b->rbuffer_size);
443 return bus_start_running(b);
446 } else if (line_begins(line, l, "DATA")) {
448 if (b->auth == _BUS_AUTH_INVALID)
449 r = bus_socket_auth_write(b, "ERROR\r\n");
451 if (b->auth == BUS_AUTH_ANONYMOUS)
452 r = verify_anonymous_token(b, line + 4, l - 4);
454 r = verify_external_token(b, line + 4, l - 4);
459 b->auth = _BUS_AUTH_INVALID;
460 r = bus_socket_auth_write(b, "REJECTED\r\n");
462 r = bus_socket_auth_write_ok(b);
464 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
465 if (b->auth == _BUS_AUTH_INVALID || !(b->hello_flags & KDBUS_HELLO_ACCEPT_FD))
466 r = bus_socket_auth_write(b, "ERROR\r\n");
469 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
472 r = bus_socket_auth_write(b, "ERROR\r\n");
477 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
483 static int bus_socket_auth_verify(sd_bus *b) {
487 return bus_socket_auth_verify_server(b);
489 return bus_socket_auth_verify_client(b);
492 static int bus_socket_read_auth(sd_bus *b) {
500 struct cmsghdr cmsghdr;
501 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
502 CMSG_SPACE(sizeof(struct ucred)) +
503 CMSG_SPACE(NAME_MAX)]; /*selinux label */
505 struct cmsghdr *cmsg;
506 bool handle_cmsg = false;
509 assert(b->state == BUS_AUTHENTICATING);
511 r = bus_socket_auth_verify(b);
515 n = MAX(256u, b->rbuffer_size * 2);
517 if (n > BUS_AUTH_SIZE_MAX)
518 n = BUS_AUTH_SIZE_MAX;
520 if (b->rbuffer_size >= n)
523 p = realloc(b->rbuffer, n);
530 iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
531 iov.iov_len = n - b->rbuffer_size;
534 k = readv(b->input_fd, &iov, 1);
539 mh.msg_control = &control;
540 mh.msg_controllen = sizeof(control);
542 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
543 if (k < 0 && errno == ENOTSOCK) {
544 b->prefer_readv = true;
545 k = readv(b->input_fd, &iov, 1);
550 return errno == EAGAIN ? 0 : -errno;
554 b->rbuffer_size += k;
557 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
558 if (cmsg->cmsg_level == SOL_SOCKET &&
559 cmsg->cmsg_type == SCM_RIGHTS) {
562 /* Whut? We received fds during the auth
563 * protocol? Somebody is playing games with
564 * us. Close them all, and fail */
565 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
566 close_many((int*) CMSG_DATA(cmsg), j);
569 } else if (cmsg->cmsg_level == SOL_SOCKET &&
570 cmsg->cmsg_type == SCM_CREDENTIALS &&
571 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
573 /* Ignore bogus data, which we might
574 * get on socketpair() sockets */
575 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
576 memcpy(&b->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
577 b->ucred_valid = true;
580 } else if (cmsg->cmsg_level == SOL_SOCKET &&
581 cmsg->cmsg_type == SCM_SECURITY) {
585 l = cmsg->cmsg_len - CMSG_LEN(0);
587 memcpy(&b->label, CMSG_DATA(cmsg), l);
594 r = bus_socket_auth_verify(b);
601 void bus_socket_setup(sd_bus *b) {
606 /* Enable SO_PASSCRED + SO_PASSEC. We try this on any
607 * socket, just in case. */
608 enable = !b->bus_client;
609 (void) setsockopt(b->input_fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable));
611 enable = !b->bus_client && (b->attach_flags & KDBUS_ATTACH_SECLABEL);
612 (void) setsockopt(b->input_fd, SOL_SOCKET, SO_PASSSEC, &enable, sizeof(enable));
614 /* Increase the buffers to 8 MB */
615 fd_inc_rcvbuf(b->input_fd, SNDBUF_SIZE);
616 fd_inc_sndbuf(b->output_fd, SNDBUF_SIZE);
618 b->is_kernel = false;
619 b->message_version = 1;
620 b->message_endian = 0;
623 static void bus_get_peercred(sd_bus *b) {
626 /* Get the peer for socketpair() sockets */
627 b->ucred_valid = getpeercred(b->input_fd, &b->ucred) >= 0;
630 static int bus_socket_start_auth_client(sd_bus *b) {
632 const char *auth_suffix, *auth_prefix;
636 if (b->anonymous_auth) {
637 auth_prefix = "\0AUTH ANONYMOUS ";
639 /* For ANONYMOUS auth we send some arbitrary "trace" string */
641 b->auth_buffer = hexmem("anonymous", l);
643 char text[DECIMAL_STR_MAX(uid_t) + 1];
645 auth_prefix = "\0AUTH EXTERNAL ";
647 xsprintf(text, UID_FMT, geteuid());
650 b->auth_buffer = hexmem(text, l);
656 if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD)
657 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
659 auth_suffix = "\r\nBEGIN\r\n";
661 b->auth_iovec[0].iov_base = (void*) auth_prefix;
662 b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
663 b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
664 b->auth_iovec[1].iov_len = l * 2;
665 b->auth_iovec[2].iov_base = (void*) auth_suffix;
666 b->auth_iovec[2].iov_len = strlen(auth_suffix);
668 return bus_socket_write_auth(b);
671 int bus_socket_start_auth(sd_bus *b) {
676 b->state = BUS_AUTHENTICATING;
677 b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
679 if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
680 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
682 if (b->output_fd != b->input_fd)
683 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
684 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
687 return bus_socket_read_auth(b);
689 return bus_socket_start_auth_client(b);
692 int bus_socket_connect(sd_bus *b) {
696 assert(b->input_fd < 0);
697 assert(b->output_fd < 0);
698 assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
700 b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
704 b->output_fd = b->input_fd;
708 r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
710 if (errno == EINPROGRESS)
716 return bus_socket_start_auth(b);
719 int bus_socket_exec(sd_bus *b) {
724 assert(b->input_fd < 0);
725 assert(b->output_fd < 0);
726 assert(b->exec_path);
728 r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
740 reset_all_signal_handlers();
742 close_all_fds(s+1, 1);
744 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
745 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
747 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
750 fd_cloexec(STDIN_FILENO, false);
751 fd_cloexec(STDOUT_FILENO, false);
752 fd_nonblock(STDIN_FILENO, false);
753 fd_nonblock(STDOUT_FILENO, false);
756 execvp(b->exec_path, b->exec_argv);
758 const char *argv[] = { b->exec_path, NULL };
759 execvp(b->exec_path, (char**) argv);
766 b->output_fd = b->input_fd = s[0];
770 return bus_socket_start_auth(b);
773 int bus_socket_take_fd(sd_bus *b) {
778 return bus_socket_start_auth(b);
781 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
791 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
793 if (*idx >= BUS_MESSAGE_SIZE(m))
796 r = bus_message_setup_iovec(m);
800 n = m->n_iovec * sizeof(struct iovec);
802 memcpy(iov, m->iovec, n);
805 iovec_advance(iov, &j, *idx);
807 if (bus->prefer_writev)
808 k = writev(bus->output_fd, iov, m->n_iovec);
814 struct cmsghdr *control;
815 control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
817 mh.msg_control = control;
818 control->cmsg_level = SOL_SOCKET;
819 control->cmsg_type = SCM_RIGHTS;
820 mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
821 memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
825 mh.msg_iovlen = m->n_iovec;
827 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
828 if (k < 0 && errno == ENOTSOCK) {
829 bus->prefer_writev = true;
830 k = writev(bus->output_fd, iov, m->n_iovec);
835 return errno == EAGAIN ? 0 : -errno;
841 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
848 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
850 if (bus->rbuffer_size < sizeof(struct bus_header)) {
851 *need = sizeof(struct bus_header) + 8;
853 /* Minimum message size:
857 * Method Call: +2 string headers
858 * Signal: +3 string headers
859 * Method Error: +1 string headers
861 * Method Reply: +1 uint32 headers
863 * A string header is at least 9 bytes
864 * A uint32 header is at least 8 bytes
866 * Hence the minimum message size of a valid message
867 * is header + 8 bytes */
872 a = ((const uint32_t*) bus->rbuffer)[1];
873 b = ((const uint32_t*) bus->rbuffer)[3];
875 e = ((const uint8_t*) bus->rbuffer)[0];
876 if (e == BUS_LITTLE_ENDIAN) {
879 } else if (e == BUS_BIG_ENDIAN) {
885 sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
886 if (sum >= BUS_MESSAGE_SIZE_MAX)
889 *need = (size_t) sum;
893 static int bus_socket_make_message(sd_bus *bus, size_t size) {
899 assert(bus->rbuffer_size >= size);
900 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
902 r = bus_rqueue_make_room(bus);
906 if (bus->rbuffer_size > size) {
907 b = memdup((const uint8_t*) bus->rbuffer + size,
908 bus->rbuffer_size - size);
914 r = bus_message_from_malloc(bus,
916 bus->fds, bus->n_fds,
917 !bus->bus_client && bus->ucred_valid ? &bus->ucred : NULL,
918 !bus->bus_client && bus->label[0] ? bus->label : NULL,
926 bus->rbuffer_size -= size;
931 bus->rqueue[bus->rqueue_size++] = t;
936 int bus_socket_read_message(sd_bus *bus) {
944 struct cmsghdr cmsghdr;
945 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
946 CMSG_SPACE(sizeof(struct ucred)) +
947 CMSG_SPACE(NAME_MAX)]; /*selinux label */
949 struct cmsghdr *cmsg;
950 bool handle_cmsg = false;
953 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
955 r = bus_socket_read_message_need(bus, &need);
959 if (bus->rbuffer_size >= need)
960 return bus_socket_make_message(bus, need);
962 b = realloc(bus->rbuffer, need);
969 iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
970 iov.iov_len = need - bus->rbuffer_size;
972 if (bus->prefer_readv)
973 k = readv(bus->input_fd, &iov, 1);
978 mh.msg_control = &control;
979 mh.msg_controllen = sizeof(control);
981 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
982 if (k < 0 && errno == ENOTSOCK) {
983 bus->prefer_readv = true;
984 k = readv(bus->input_fd, &iov, 1);
989 return errno == EAGAIN ? 0 : -errno;
993 bus->rbuffer_size += k;
996 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
997 if (cmsg->cmsg_level == SOL_SOCKET &&
998 cmsg->cmsg_type == SCM_RIGHTS) {
1001 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1003 if (!bus->can_fds) {
1004 /* Whut? We received fds but this
1005 * isn't actually enabled? Close them,
1008 close_many((int*) CMSG_DATA(cmsg), n);
1012 f = realloc(bus->fds, sizeof(int) + (bus->n_fds + n));
1014 close_many((int*) CMSG_DATA(cmsg), n);
1018 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1021 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1022 cmsg->cmsg_type == SCM_CREDENTIALS &&
1023 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1025 /* Ignore bogus data, which we might
1026 * get on socketpair() sockets */
1027 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
1028 memcpy(&bus->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
1029 bus->ucred_valid = true;
1032 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1033 cmsg->cmsg_type == SCM_SECURITY) {
1036 l = cmsg->cmsg_len - CMSG_LEN(0);
1038 memcpy(&bus->label, CMSG_DATA(cmsg), l);
1045 r = bus_socket_read_message_need(bus, &need);
1049 if (bus->rbuffer_size >= need)
1050 return bus_socket_make_message(bus, need);
1055 int bus_socket_process_opening(sd_bus *b) {
1057 socklen_t slen = sizeof(error);
1064 assert(b->state == BUS_OPENING);
1070 if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1073 r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1075 b->last_connect_error = errno;
1076 else if (error != 0)
1077 b->last_connect_error = error;
1078 else if (p.revents & (POLLERR|POLLHUP))
1079 b->last_connect_error = ECONNREFUSED;
1081 return bus_socket_start_auth(b);
1083 return bus_next_address(b);
1086 int bus_socket_process_authenticating(sd_bus *b) {
1090 assert(b->state == BUS_AUTHENTICATING);
1092 if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1095 r = bus_socket_write_auth(b);
1099 return bus_socket_read_auth(b);