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"
32 #include "formats-util.h"
35 #include "bus-socket.h"
36 #include "bus-internal.h"
37 #include "bus-message.h"
39 #define SNDBUF_SIZE (8*1024*1024)
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->n_body_parts;
87 if (n < ELEMENTSOF(m->iovec_fixed))
88 m->iovec = m->iovec_fixed;
90 m->iovec = new(struct iovec, n);
97 r = append_iovec(m, m->header, BUS_MESSAGE_BODY_BEGIN(m));
101 MESSAGE_FOREACH_PART(part, i, m) {
102 r = bus_body_part_map(part);
106 r = append_iovec(m, part->data, part->size);
111 assert(n == m->n_iovec);
120 bool bus_socket_auth_needs_write(sd_bus *b) {
124 if (b->auth_index >= ELEMENTSOF(b->auth_iovec))
127 for (i = b->auth_index; i < ELEMENTSOF(b->auth_iovec); i++) {
128 struct iovec *j = b->auth_iovec + i;
137 static int bus_socket_write_auth(sd_bus *b) {
141 assert(b->state == BUS_AUTHENTICATING);
143 if (!bus_socket_auth_needs_write(b))
146 if (b->prefer_writev)
147 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
152 mh.msg_iov = b->auth_iovec + b->auth_index;
153 mh.msg_iovlen = ELEMENTSOF(b->auth_iovec) - b->auth_index;
155 k = sendmsg(b->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
156 if (k < 0 && errno == ENOTSOCK) {
157 b->prefer_writev = true;
158 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
163 return errno == EAGAIN ? 0 : -errno;
165 iovec_advance(b->auth_iovec, &b->auth_index, (size_t) k);
169 static int bus_socket_auth_verify_client(sd_bus *b) {
177 /* We expect two response lines: "OK" and possibly
180 e = memmem_safe(b->rbuffer, b->rbuffer_size, "\r\n", 2);
184 if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD) {
185 f = memmem(e + 2, b->rbuffer_size - (e - (char*) b->rbuffer) - 2, "\r\n", 2);
195 /* Nice! We got all the lines we need. First check the OK
198 if (e - (char*) b->rbuffer != 3 + 32)
201 if (memcmp(b->rbuffer, "OK ", 3))
204 b->auth = b->anonymous_auth ? BUS_AUTH_ANONYMOUS : BUS_AUTH_EXTERNAL;
206 for (i = 0; i < 32; i += 2) {
209 x = unhexchar(((char*) b->rbuffer)[3 + i]);
210 y = unhexchar(((char*) b->rbuffer)[3 + i + 1]);
215 peer.bytes[i/2] = ((uint8_t) x << 4 | (uint8_t) y);
218 if (!sd_id128_equal(b->server_id, SD_ID128_NULL) &&
219 !sd_id128_equal(b->server_id, peer))
224 /* And possibly check the second line, too */
228 (f - e == strlen("\r\nAGREE_UNIX_FD")) &&
229 memcmp(e + 2, "AGREE_UNIX_FD", strlen("AGREE_UNIX_FD")) == 0;
231 b->rbuffer_size -= (start - (char*) b->rbuffer);
232 memmove(b->rbuffer, start, b->rbuffer_size);
234 r = bus_start_running(b);
241 static bool line_equals(const char *s, size_t m, const char *line) {
248 return memcmp(s, line, l) == 0;
251 static bool line_begins(const char *s, size_t m, const char *word) {
258 if (memcmp(s, word, l) != 0)
261 return m == l || (m > l && s[l] == ' ');
264 static int verify_anonymous_token(sd_bus *b, const char *p, size_t l) {
265 _cleanup_free_ char *token = NULL;
267 if (!b->anonymous_auth)
278 token = unhexmem(p, l);
282 if (memchr(token, 0, l/2))
285 return !!utf8_is_valid(token);
288 static int verify_external_token(sd_bus *b, const char *p, size_t l) {
289 _cleanup_free_ char *token = NULL;
293 /* We don't do any real authentication here. Instead, we if
294 * the owner of this bus wanted authentication he should have
295 * checked SO_PEERCRED before even creating the bus object. */
297 if (!b->anonymous_auth && !b->ucred_valid)
309 token = unhexmem(p, l);
313 if (memchr(token, 0, l/2))
316 r = parse_uid(token, &u);
320 /* We ignore the passed value if anonymous authentication is
322 if (!b->anonymous_auth && u != b->ucred.uid)
328 static int bus_socket_auth_write(sd_bus *b, const char *t) {
335 /* We only make use of the first iovec */
336 assert(b->auth_index == 0 || b->auth_index == 1);
339 p = malloc(b->auth_iovec[0].iov_len + l);
343 memcpy(p, b->auth_iovec[0].iov_base, b->auth_iovec[0].iov_len);
344 memcpy(p + b->auth_iovec[0].iov_len, t, l);
346 b->auth_iovec[0].iov_base = p;
347 b->auth_iovec[0].iov_len += l;
349 free(b->auth_buffer);
355 static int bus_socket_auth_write_ok(sd_bus *b) {
356 char t[3 + 32 + 2 + 1];
360 xsprintf(t, "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
362 return bus_socket_auth_write(b, t);
365 static int bus_socket_auth_verify_server(sd_bus *b) {
369 bool processed = false;
374 if (b->rbuffer_size < 1)
377 /* First char must be a NUL byte */
378 if (*(char*) b->rbuffer != 0)
381 if (b->rbuffer_size < 3)
384 /* Begin with the first line */
385 if (b->auth_rbegin <= 0)
389 /* Check if line is complete */
390 line = (char*) b->rbuffer + b->auth_rbegin;
391 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
397 if (line_begins(line, l, "AUTH ANONYMOUS")) {
399 r = verify_anonymous_token(b, line + 14, l - 14);
403 r = bus_socket_auth_write(b, "REJECTED\r\n");
405 b->auth = BUS_AUTH_ANONYMOUS;
406 r = bus_socket_auth_write_ok(b);
409 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
411 r = verify_external_token(b, line + 13, l - 13);
415 r = bus_socket_auth_write(b, "REJECTED\r\n");
417 b->auth = BUS_AUTH_EXTERNAL;
418 r = bus_socket_auth_write_ok(b);
421 } else if (line_begins(line, l, "AUTH"))
422 r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
423 else if (line_equals(line, l, "CANCEL") ||
424 line_begins(line, l, "ERROR")) {
426 b->auth = _BUS_AUTH_INVALID;
427 r = bus_socket_auth_write(b, "REJECTED\r\n");
429 } else if (line_equals(line, l, "BEGIN")) {
431 if (b->auth == _BUS_AUTH_INVALID)
432 r = bus_socket_auth_write(b, "ERROR\r\n");
434 /* We can't leave from the auth phase
435 * before we haven't written
436 * everything queued, so let's check
439 if (bus_socket_auth_needs_write(b))
442 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
443 memmove(b->rbuffer, e + 2, b->rbuffer_size);
444 return bus_start_running(b);
447 } else if (line_begins(line, l, "DATA")) {
449 if (b->auth == _BUS_AUTH_INVALID)
450 r = bus_socket_auth_write(b, "ERROR\r\n");
452 if (b->auth == BUS_AUTH_ANONYMOUS)
453 r = verify_anonymous_token(b, line + 4, l - 4);
455 r = verify_external_token(b, line + 4, l - 4);
460 b->auth = _BUS_AUTH_INVALID;
461 r = bus_socket_auth_write(b, "REJECTED\r\n");
463 r = bus_socket_auth_write_ok(b);
465 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
466 if (b->auth == _BUS_AUTH_INVALID || !(b->hello_flags & KDBUS_HELLO_ACCEPT_FD))
467 r = bus_socket_auth_write(b, "ERROR\r\n");
470 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
473 r = bus_socket_auth_write(b, "ERROR\r\n");
478 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
484 static int bus_socket_auth_verify(sd_bus *b) {
488 return bus_socket_auth_verify_server(b);
490 return bus_socket_auth_verify_client(b);
493 static int bus_socket_read_auth(sd_bus *b) {
501 struct cmsghdr cmsghdr;
502 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
503 CMSG_SPACE(sizeof(struct ucred)) +
504 CMSG_SPACE(NAME_MAX)]; /*selinux label */
506 struct cmsghdr *cmsg;
507 bool handle_cmsg = false;
510 assert(b->state == BUS_AUTHENTICATING);
512 r = bus_socket_auth_verify(b);
516 n = MAX(256u, b->rbuffer_size * 2);
518 if (n > BUS_AUTH_SIZE_MAX)
519 n = BUS_AUTH_SIZE_MAX;
521 if (b->rbuffer_size >= n)
524 p = realloc(b->rbuffer, n);
531 iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
532 iov.iov_len = n - b->rbuffer_size;
535 k = readv(b->input_fd, &iov, 1);
540 mh.msg_control = &control;
541 mh.msg_controllen = sizeof(control);
543 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
544 if (k < 0 && errno == ENOTSOCK) {
545 b->prefer_readv = true;
546 k = readv(b->input_fd, &iov, 1);
551 return errno == EAGAIN ? 0 : -errno;
555 b->rbuffer_size += k;
558 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
559 if (cmsg->cmsg_level == SOL_SOCKET &&
560 cmsg->cmsg_type == SCM_RIGHTS) {
563 /* Whut? We received fds during the auth
564 * protocol? Somebody is playing games with
565 * us. Close them all, and fail */
566 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
567 close_many((int*) CMSG_DATA(cmsg), j);
570 } else if (cmsg->cmsg_level == SOL_SOCKET &&
571 cmsg->cmsg_type == SCM_CREDENTIALS &&
572 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
574 /* Ignore bogus data, which we might
575 * get on socketpair() sockets */
576 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
577 memcpy(&b->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
578 b->ucred_valid = true;
581 } else if (cmsg->cmsg_level == SOL_SOCKET &&
582 cmsg->cmsg_type == SCM_SECURITY) {
586 l = cmsg->cmsg_len - CMSG_LEN(0);
588 memcpy(&b->label, CMSG_DATA(cmsg), l);
595 r = bus_socket_auth_verify(b);
602 void bus_socket_setup(sd_bus *b) {
607 /* Enable SO_PASSCRED + SO_PASSEC. We try this on any
608 * socket, just in case. */
609 enable = !b->bus_client;
610 (void) setsockopt(b->input_fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable));
612 enable = !b->bus_client && (b->attach_flags & KDBUS_ATTACH_SECLABEL);
613 (void) setsockopt(b->input_fd, SOL_SOCKET, SO_PASSSEC, &enable, sizeof(enable));
615 /* Increase the buffers to 8 MB */
616 fd_inc_rcvbuf(b->input_fd, SNDBUF_SIZE);
617 fd_inc_sndbuf(b->output_fd, SNDBUF_SIZE);
619 b->is_kernel = false;
620 b->message_version = 1;
621 b->message_endian = 0;
624 static void bus_get_peercred(sd_bus *b) {
627 /* Get the peer for socketpair() sockets */
628 b->ucred_valid = getpeercred(b->input_fd, &b->ucred) >= 0;
631 static int bus_socket_start_auth_client(sd_bus *b) {
633 const char *auth_suffix, *auth_prefix;
637 if (b->anonymous_auth) {
638 auth_prefix = "\0AUTH ANONYMOUS ";
640 /* For ANONYMOUS auth we send some arbitrary "trace" string */
642 b->auth_buffer = hexmem("anonymous", l);
644 char text[DECIMAL_STR_MAX(uid_t) + 1];
646 auth_prefix = "\0AUTH EXTERNAL ";
648 xsprintf(text, UID_FMT, geteuid());
651 b->auth_buffer = hexmem(text, l);
657 if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD)
658 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
660 auth_suffix = "\r\nBEGIN\r\n";
662 b->auth_iovec[0].iov_base = (void*) auth_prefix;
663 b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
664 b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
665 b->auth_iovec[1].iov_len = l * 2;
666 b->auth_iovec[2].iov_base = (void*) auth_suffix;
667 b->auth_iovec[2].iov_len = strlen(auth_suffix);
669 return bus_socket_write_auth(b);
672 int bus_socket_start_auth(sd_bus *b) {
677 b->state = BUS_AUTHENTICATING;
678 b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
680 if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
681 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
683 if (b->output_fd != b->input_fd)
684 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
685 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
688 return bus_socket_read_auth(b);
690 return bus_socket_start_auth_client(b);
693 int bus_socket_connect(sd_bus *b) {
697 assert(b->input_fd < 0);
698 assert(b->output_fd < 0);
699 assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
701 b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
705 b->output_fd = b->input_fd;
709 r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
711 if (errno == EINPROGRESS)
717 return bus_socket_start_auth(b);
720 int bus_socket_exec(sd_bus *b) {
725 assert(b->input_fd < 0);
726 assert(b->output_fd < 0);
727 assert(b->exec_path);
729 r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
741 reset_all_signal_handlers();
743 close_all_fds(s+1, 1);
745 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
746 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
748 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
751 fd_cloexec(STDIN_FILENO, false);
752 fd_cloexec(STDOUT_FILENO, false);
753 fd_nonblock(STDIN_FILENO, false);
754 fd_nonblock(STDOUT_FILENO, false);
757 execvp(b->exec_path, b->exec_argv);
759 const char *argv[] = { b->exec_path, NULL };
760 execvp(b->exec_path, (char**) argv);
767 b->output_fd = b->input_fd = s[0];
771 return bus_socket_start_auth(b);
774 int bus_socket_take_fd(sd_bus *b) {
779 return bus_socket_start_auth(b);
782 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
792 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
794 if (*idx >= BUS_MESSAGE_SIZE(m))
797 r = bus_message_setup_iovec(m);
801 n = m->n_iovec * sizeof(struct iovec);
803 memcpy(iov, m->iovec, n);
806 iovec_advance(iov, &j, *idx);
808 if (bus->prefer_writev)
809 k = writev(bus->output_fd, iov, m->n_iovec);
815 struct cmsghdr *control;
816 control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
818 mh.msg_control = control;
819 control->cmsg_level = SOL_SOCKET;
820 control->cmsg_type = SCM_RIGHTS;
821 mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
822 memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
826 mh.msg_iovlen = m->n_iovec;
828 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
829 if (k < 0 && errno == ENOTSOCK) {
830 bus->prefer_writev = true;
831 k = writev(bus->output_fd, iov, m->n_iovec);
836 return errno == EAGAIN ? 0 : -errno;
842 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
849 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
851 if (bus->rbuffer_size < sizeof(struct bus_header)) {
852 *need = sizeof(struct bus_header) + 8;
854 /* Minimum message size:
858 * Method Call: +2 string headers
859 * Signal: +3 string headers
860 * Method Error: +1 string headers
862 * Method Reply: +1 uint32 headers
864 * A string header is at least 9 bytes
865 * A uint32 header is at least 8 bytes
867 * Hence the minimum message size of a valid message
868 * is header + 8 bytes */
873 a = ((const uint32_t*) bus->rbuffer)[1];
874 b = ((const uint32_t*) bus->rbuffer)[3];
876 e = ((const uint8_t*) bus->rbuffer)[0];
877 if (e == BUS_LITTLE_ENDIAN) {
880 } else if (e == BUS_BIG_ENDIAN) {
886 sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
887 if (sum >= BUS_MESSAGE_SIZE_MAX)
890 *need = (size_t) sum;
894 static int bus_socket_make_message(sd_bus *bus, size_t size) {
900 assert(bus->rbuffer_size >= size);
901 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
903 r = bus_rqueue_make_room(bus);
907 if (bus->rbuffer_size > size) {
908 b = memdup((const uint8_t*) bus->rbuffer + size,
909 bus->rbuffer_size - size);
915 r = bus_message_from_malloc(bus,
917 bus->fds, bus->n_fds,
927 bus->rbuffer_size -= size;
932 bus->rqueue[bus->rqueue_size++] = t;
937 int bus_socket_read_message(sd_bus *bus) {
945 struct cmsghdr cmsghdr;
946 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
947 CMSG_SPACE(sizeof(struct ucred)) +
948 CMSG_SPACE(NAME_MAX)]; /*selinux label */
950 struct cmsghdr *cmsg;
951 bool handle_cmsg = false;
954 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
956 r = bus_socket_read_message_need(bus, &need);
960 if (bus->rbuffer_size >= need)
961 return bus_socket_make_message(bus, need);
963 b = realloc(bus->rbuffer, need);
970 iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
971 iov.iov_len = need - bus->rbuffer_size;
973 if (bus->prefer_readv)
974 k = readv(bus->input_fd, &iov, 1);
979 mh.msg_control = &control;
980 mh.msg_controllen = sizeof(control);
982 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
983 if (k < 0 && errno == ENOTSOCK) {
984 bus->prefer_readv = true;
985 k = readv(bus->input_fd, &iov, 1);
990 return errno == EAGAIN ? 0 : -errno;
994 bus->rbuffer_size += k;
997 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
998 if (cmsg->cmsg_level == SOL_SOCKET &&
999 cmsg->cmsg_type == SCM_RIGHTS) {
1002 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1004 if (!bus->can_fds) {
1005 /* Whut? We received fds but this
1006 * isn't actually enabled? Close them,
1009 close_many((int*) CMSG_DATA(cmsg), n);
1013 f = realloc(bus->fds, sizeof(int) + (bus->n_fds + n));
1015 close_many((int*) CMSG_DATA(cmsg), n);
1019 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1022 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1023 cmsg->cmsg_type == SCM_CREDENTIALS &&
1024 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1026 /* Ignore bogus data, which we might
1027 * get on socketpair() sockets */
1028 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
1029 memcpy(&bus->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
1030 bus->ucred_valid = true;
1033 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1034 cmsg->cmsg_type == SCM_SECURITY) {
1037 l = cmsg->cmsg_len - CMSG_LEN(0);
1039 memcpy(&bus->label, CMSG_DATA(cmsg), l);
1046 r = bus_socket_read_message_need(bus, &need);
1050 if (bus->rbuffer_size >= need)
1051 return bus_socket_make_message(bus, need);
1056 int bus_socket_process_opening(sd_bus *b) {
1058 socklen_t slen = sizeof(error);
1065 assert(b->state == BUS_OPENING);
1071 if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1074 r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1076 b->last_connect_error = errno;
1077 else if (error != 0)
1078 b->last_connect_error = error;
1079 else if (p.revents & (POLLERR|POLLHUP))
1080 b->last_connect_error = ECONNREFUSED;
1082 return bus_socket_start_auth(b);
1084 return bus_next_address(b);
1087 int bus_socket_process_authenticating(sd_bus *b) {
1091 assert(b->state == BUS_AUTHENTICATING);
1093 if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1096 r = bus_socket_write_auth(b);
1100 return bus_socket_read_auth(b);