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->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(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 == sizeof("\r\nAGREE_UNIX_FD") - 1) &&
229 memcmp(e + 2, "AGREE_UNIX_FD", sizeof("AGREE_UNIX_FD") - 1) == 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 snprintf(t, sizeof(t), "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
363 return bus_socket_auth_write(b, t);
366 static int bus_socket_auth_verify_server(sd_bus *b) {
370 bool processed = false;
375 if (b->rbuffer_size < 1)
378 /* First char must be a NUL byte */
379 if (*(char*) b->rbuffer != 0)
382 if (b->rbuffer_size < 3)
385 /* Begin with the first line */
386 if (b->auth_rbegin <= 0)
390 /* Check if line is complete */
391 line = (char*) b->rbuffer + b->auth_rbegin;
392 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
398 if (line_begins(line, l, "AUTH ANONYMOUS")) {
400 r = verify_anonymous_token(b, line + 14, l - 14);
404 r = bus_socket_auth_write(b, "REJECTED\r\n");
406 b->auth = BUS_AUTH_ANONYMOUS;
407 r = bus_socket_auth_write_ok(b);
410 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
412 r = verify_external_token(b, line + 13, l - 13);
416 r = bus_socket_auth_write(b, "REJECTED\r\n");
418 b->auth = BUS_AUTH_EXTERNAL;
419 r = bus_socket_auth_write_ok(b);
422 } else if (line_begins(line, l, "AUTH"))
423 r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
424 else if (line_equals(line, l, "CANCEL") ||
425 line_begins(line, l, "ERROR")) {
427 b->auth = _BUS_AUTH_INVALID;
428 r = bus_socket_auth_write(b, "REJECTED\r\n");
430 } else if (line_equals(line, l, "BEGIN")) {
432 if (b->auth == _BUS_AUTH_INVALID)
433 r = bus_socket_auth_write(b, "ERROR\r\n");
435 /* We can't leave from the auth phase
436 * before we haven't written
437 * everything queued, so let's check
440 if (bus_socket_auth_needs_write(b))
443 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
444 memmove(b->rbuffer, e + 2, b->rbuffer_size);
445 return bus_start_running(b);
448 } else if (line_begins(line, l, "DATA")) {
450 if (b->auth == _BUS_AUTH_INVALID)
451 r = bus_socket_auth_write(b, "ERROR\r\n");
453 if (b->auth == BUS_AUTH_ANONYMOUS)
454 r = verify_anonymous_token(b, line + 4, l - 4);
456 r = verify_external_token(b, line + 4, l - 4);
461 b->auth = _BUS_AUTH_INVALID;
462 r = bus_socket_auth_write(b, "REJECTED\r\n");
464 r = bus_socket_auth_write_ok(b);
466 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
467 if (b->auth == _BUS_AUTH_INVALID || !(b->hello_flags & KDBUS_HELLO_ACCEPT_FD))
468 r = bus_socket_auth_write(b, "ERROR\r\n");
471 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
474 r = bus_socket_auth_write(b, "ERROR\r\n");
479 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
485 static int bus_socket_auth_verify(sd_bus *b) {
489 return bus_socket_auth_verify_server(b);
491 return bus_socket_auth_verify_client(b);
494 static int bus_socket_read_auth(sd_bus *b) {
502 struct cmsghdr cmsghdr;
503 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
504 CMSG_SPACE(sizeof(struct ucred)) +
505 CMSG_SPACE(NAME_MAX)]; /*selinux label */
507 struct cmsghdr *cmsg;
508 bool handle_cmsg = false;
511 assert(b->state == BUS_AUTHENTICATING);
513 r = bus_socket_auth_verify(b);
517 n = MAX(256u, b->rbuffer_size * 2);
519 if (n > BUS_AUTH_SIZE_MAX)
520 n = BUS_AUTH_SIZE_MAX;
522 if (b->rbuffer_size >= n)
525 p = realloc(b->rbuffer, n);
532 iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
533 iov.iov_len = n - b->rbuffer_size;
536 k = readv(b->input_fd, &iov, 1);
541 mh.msg_control = &control;
542 mh.msg_controllen = sizeof(control);
544 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
545 if (k < 0 && errno == ENOTSOCK) {
546 b->prefer_readv = true;
547 k = readv(b->input_fd, &iov, 1);
552 return errno == EAGAIN ? 0 : -errno;
556 b->rbuffer_size += k;
559 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
560 if (cmsg->cmsg_level == SOL_SOCKET &&
561 cmsg->cmsg_type == SCM_RIGHTS) {
564 /* Whut? We received fds during the auth
565 * protocol? Somebody is playing games with
566 * us. Close them all, and fail */
567 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
568 close_many((int*) CMSG_DATA(cmsg), j);
571 } else if (cmsg->cmsg_level == SOL_SOCKET &&
572 cmsg->cmsg_type == SCM_CREDENTIALS &&
573 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
575 /* Ignore bogus data, which we might
576 * get on socketpair() sockets */
577 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
578 memcpy(&b->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
579 b->ucred_valid = true;
582 } else if (cmsg->cmsg_level == SOL_SOCKET &&
583 cmsg->cmsg_type == SCM_SECURITY) {
587 l = cmsg->cmsg_len - CMSG_LEN(0);
589 memcpy(&b->label, CMSG_DATA(cmsg), l);
596 r = bus_socket_auth_verify(b);
603 int 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 setsockopt(b->input_fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable));
614 enable = !b->bus_client && (b->attach_flags & KDBUS_ATTACH_SECLABEL);
615 setsockopt(b->input_fd, SOL_SOCKET, SO_PASSSEC, &enable, sizeof(enable));
617 /* Increase the buffers to a MB */
618 fd_inc_rcvbuf(b->input_fd, 1024*1024);
619 fd_inc_sndbuf(b->output_fd, 1024*1024);
621 /* Get the peer for socketpair() sockets */
622 l = sizeof(b->ucred);
623 if (getsockopt(b->input_fd, SOL_SOCKET, SO_PEERCRED, &b->ucred, &l) >= 0 && l >= sizeof(b->ucred))
624 b->ucred_valid = b->ucred.pid > 0;
626 b->is_kernel = false;
627 b->message_version = 1;
628 b->message_endian = 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[20 + 1]; /* enough space for a 64bit integer plus NUL */
648 auth_prefix = "\0AUTH EXTERNAL ";
650 snprintf(text, sizeof(text), "%lu", (unsigned long) geteuid());
654 b->auth_buffer = hexmem(text, l);
660 if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD)
661 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
663 auth_suffix = "\r\nBEGIN\r\n";
665 b->auth_iovec[0].iov_base = (void*) auth_prefix;
666 b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
667 b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
668 b->auth_iovec[1].iov_len = l * 2;
669 b->auth_iovec[2].iov_base = (void*) auth_suffix;
670 b->auth_iovec[2].iov_len = strlen(auth_suffix);
672 return bus_socket_write_auth(b);
675 int bus_socket_start_auth(sd_bus *b) {
678 b->state = BUS_AUTHENTICATING;
679 b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
681 if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
682 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
684 if (b->output_fd != b->input_fd)
685 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
686 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
689 return bus_socket_read_auth(b);
691 return bus_socket_start_auth_client(b);
694 int bus_socket_connect(sd_bus *b) {
698 assert(b->input_fd < 0);
699 assert(b->output_fd < 0);
700 assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
702 b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
706 b->output_fd = b->input_fd;
708 r = bus_socket_setup(b);
712 r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
714 if (errno == EINPROGRESS)
720 return bus_socket_start_auth(b);
723 int bus_socket_exec(sd_bus *b) {
728 assert(b->input_fd < 0);
729 assert(b->output_fd < 0);
730 assert(b->exec_path);
732 r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
744 reset_all_signal_handlers();
746 close_all_fds(s+1, 1);
748 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
749 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
751 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
752 close_nointr_nofail(s[1]);
754 fd_cloexec(STDIN_FILENO, false);
755 fd_cloexec(STDOUT_FILENO, false);
756 fd_nonblock(STDIN_FILENO, false);
757 fd_nonblock(STDOUT_FILENO, false);
760 execvp(b->exec_path, b->exec_argv);
762 const char *argv[] = { b->exec_path, NULL };
763 execvp(b->exec_path, (char**) argv);
769 close_nointr_nofail(s[1]);
770 b->output_fd = b->input_fd = s[0];
772 r = bus_socket_setup(b);
776 return bus_socket_start_auth(b);
779 int bus_socket_take_fd(sd_bus *b) {
783 r = bus_socket_setup(b);
787 return bus_socket_start_auth(b);
790 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
800 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
802 if (*idx >= BUS_MESSAGE_SIZE(m))
805 r = bus_message_setup_iovec(m);
809 n = m->n_iovec * sizeof(struct iovec);
811 memcpy(iov, m->iovec, n);
814 iovec_advance(iov, &j, *idx);
816 if (bus->prefer_writev)
817 k = writev(bus->output_fd, iov, m->n_iovec);
823 struct cmsghdr *control;
824 control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
826 mh.msg_control = control;
827 control->cmsg_level = SOL_SOCKET;
828 control->cmsg_type = SCM_RIGHTS;
829 mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
830 memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
834 mh.msg_iovlen = m->n_iovec;
836 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
837 if (k < 0 && errno == ENOTSOCK) {
838 bus->prefer_writev = true;
839 k = writev(bus->output_fd, iov, m->n_iovec);
844 return errno == EAGAIN ? 0 : -errno;
850 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
857 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
859 if (bus->rbuffer_size < sizeof(struct bus_header)) {
860 *need = sizeof(struct bus_header) + 8;
862 /* Minimum message size:
866 * Method Call: +2 string headers
867 * Signal: +3 string headers
868 * Method Error: +1 string headers
870 * Method Reply: +1 uint32 headers
872 * A string header is at least 9 bytes
873 * A uint32 header is at least 8 bytes
875 * Hence the minimum message size of a valid message
876 * is header + 8 bytes */
881 a = ((const uint32_t*) bus->rbuffer)[1];
882 b = ((const uint32_t*) bus->rbuffer)[3];
884 e = ((const uint8_t*) bus->rbuffer)[0];
885 if (e == BUS_LITTLE_ENDIAN) {
888 } else if (e == BUS_BIG_ENDIAN) {
894 sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
895 if (sum >= BUS_MESSAGE_SIZE_MAX)
898 *need = (size_t) sum;
902 static int bus_socket_make_message(sd_bus *bus, size_t size) {
908 assert(bus->rbuffer_size >= size);
909 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
911 r = bus_rqueue_make_room(bus);
915 if (bus->rbuffer_size > size) {
916 b = memdup((const uint8_t*) bus->rbuffer + size,
917 bus->rbuffer_size - size);
923 r = bus_message_from_malloc(bus,
925 bus->fds, bus->n_fds,
926 bus->ucred_valid ? &bus->ucred : NULL,
927 bus->label[0] ? bus->label : NULL,
935 bus->rbuffer_size -= size;
940 bus->rqueue[bus->rqueue_size++] = t;
945 int bus_socket_read_message(sd_bus *bus) {
953 struct cmsghdr cmsghdr;
954 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
955 CMSG_SPACE(sizeof(struct ucred)) +
956 CMSG_SPACE(NAME_MAX)]; /*selinux label */
958 struct cmsghdr *cmsg;
959 bool handle_cmsg = false;
962 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
964 r = bus_socket_read_message_need(bus, &need);
968 if (bus->rbuffer_size >= need)
969 return bus_socket_make_message(bus, need);
971 b = realloc(bus->rbuffer, need);
978 iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
979 iov.iov_len = need - bus->rbuffer_size;
981 if (bus->prefer_readv)
982 k = readv(bus->input_fd, &iov, 1);
987 mh.msg_control = &control;
988 mh.msg_controllen = sizeof(control);
990 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
991 if (k < 0 && errno == ENOTSOCK) {
992 bus->prefer_readv = true;
993 k = readv(bus->input_fd, &iov, 1);
998 return errno == EAGAIN ? 0 : -errno;
1002 bus->rbuffer_size += k;
1005 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
1006 if (cmsg->cmsg_level == SOL_SOCKET &&
1007 cmsg->cmsg_type == SCM_RIGHTS) {
1010 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1012 if (!bus->can_fds) {
1013 /* Whut? We received fds but this
1014 * isn't actually enabled? Close them,
1017 close_many((int*) CMSG_DATA(cmsg), n);
1021 f = realloc(bus->fds, sizeof(int) + (bus->n_fds + n));
1023 close_many((int*) CMSG_DATA(cmsg), n);
1027 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1030 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1031 cmsg->cmsg_type == SCM_CREDENTIALS &&
1032 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1034 /* Ignore bogus data, which we might
1035 * get on socketpair() sockets */
1036 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
1037 memcpy(&bus->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
1038 bus->ucred_valid = true;
1041 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1042 cmsg->cmsg_type == SCM_SECURITY) {
1045 l = cmsg->cmsg_len - CMSG_LEN(0);
1047 memcpy(&bus->label, CMSG_DATA(cmsg), l);
1054 r = bus_socket_read_message_need(bus, &need);
1058 if (bus->rbuffer_size >= need)
1059 return bus_socket_make_message(bus, need);
1064 int bus_socket_process_opening(sd_bus *b) {
1066 socklen_t slen = sizeof(error);
1073 assert(b->state == BUS_OPENING);
1079 if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1082 r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1084 b->last_connect_error = errno;
1085 else if (error != 0)
1086 b->last_connect_error = error;
1087 else if (p.revents & (POLLERR|POLLHUP))
1088 b->last_connect_error = ECONNREFUSED;
1090 return bus_socket_start_auth(b);
1092 return bus_next_address(b);
1095 int bus_socket_process_authenticating(sd_bus *b) {
1099 assert(b->state == BUS_AUTHENTICATING);
1101 if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1104 r = bus_socket_write_auth(b);
1108 return bus_socket_read_auth(b);