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 == sizeof("\r\nAGREE_UNIX_FD") - 1) &&
231 memcmp(e + 2, "AGREE_UNIX_FD", sizeof("AGREE_UNIX_FD") - 1) == 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 snprintf(t, sizeof(t), "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
365 return bus_socket_auth_write(b, t);
368 static int bus_socket_auth_verify_server(sd_bus *b) {
372 bool processed = false;
377 if (b->rbuffer_size < 1)
380 /* First char must be a NUL byte */
381 if (*(char*) b->rbuffer != 0)
384 if (b->rbuffer_size < 3)
387 /* Begin with the first line */
388 if (b->auth_rbegin <= 0)
392 /* Check if line is complete */
393 line = (char*) b->rbuffer + b->auth_rbegin;
394 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
400 if (line_begins(line, l, "AUTH ANONYMOUS")) {
402 r = verify_anonymous_token(b, line + 14, l - 14);
406 r = bus_socket_auth_write(b, "REJECTED\r\n");
408 b->auth = BUS_AUTH_ANONYMOUS;
409 r = bus_socket_auth_write_ok(b);
412 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
414 r = verify_external_token(b, line + 13, l - 13);
418 r = bus_socket_auth_write(b, "REJECTED\r\n");
420 b->auth = BUS_AUTH_EXTERNAL;
421 r = bus_socket_auth_write_ok(b);
424 } else if (line_begins(line, l, "AUTH"))
425 r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
426 else if (line_equals(line, l, "CANCEL") ||
427 line_begins(line, l, "ERROR")) {
429 b->auth = _BUS_AUTH_INVALID;
430 r = bus_socket_auth_write(b, "REJECTED\r\n");
432 } else if (line_equals(line, l, "BEGIN")) {
434 if (b->auth == _BUS_AUTH_INVALID)
435 r = bus_socket_auth_write(b, "ERROR\r\n");
437 /* We can't leave from the auth phase
438 * before we haven't written
439 * everything queued, so let's check
442 if (bus_socket_auth_needs_write(b))
445 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
446 memmove(b->rbuffer, e + 2, b->rbuffer_size);
447 return bus_start_running(b);
450 } else if (line_begins(line, l, "DATA")) {
452 if (b->auth == _BUS_AUTH_INVALID)
453 r = bus_socket_auth_write(b, "ERROR\r\n");
455 if (b->auth == BUS_AUTH_ANONYMOUS)
456 r = verify_anonymous_token(b, line + 4, l - 4);
458 r = verify_external_token(b, line + 4, l - 4);
463 b->auth = _BUS_AUTH_INVALID;
464 r = bus_socket_auth_write(b, "REJECTED\r\n");
466 r = bus_socket_auth_write_ok(b);
468 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
469 if (b->auth == _BUS_AUTH_INVALID || !(b->hello_flags & KDBUS_HELLO_ACCEPT_FD))
470 r = bus_socket_auth_write(b, "ERROR\r\n");
473 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
476 r = bus_socket_auth_write(b, "ERROR\r\n");
481 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
487 static int bus_socket_auth_verify(sd_bus *b) {
491 return bus_socket_auth_verify_server(b);
493 return bus_socket_auth_verify_client(b);
496 static int bus_socket_read_auth(sd_bus *b) {
504 struct cmsghdr cmsghdr;
505 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
506 CMSG_SPACE(sizeof(struct ucred)) +
507 CMSG_SPACE(NAME_MAX)]; /*selinux label */
509 struct cmsghdr *cmsg;
510 bool handle_cmsg = false;
513 assert(b->state == BUS_AUTHENTICATING);
515 r = bus_socket_auth_verify(b);
519 n = MAX(256u, b->rbuffer_size * 2);
521 if (n > BUS_AUTH_SIZE_MAX)
522 n = BUS_AUTH_SIZE_MAX;
524 if (b->rbuffer_size >= n)
527 p = realloc(b->rbuffer, n);
534 iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
535 iov.iov_len = n - b->rbuffer_size;
538 k = readv(b->input_fd, &iov, 1);
543 mh.msg_control = &control;
544 mh.msg_controllen = sizeof(control);
546 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
547 if (k < 0 && errno == ENOTSOCK) {
548 b->prefer_readv = true;
549 k = readv(b->input_fd, &iov, 1);
554 return errno == EAGAIN ? 0 : -errno;
558 b->rbuffer_size += k;
561 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
562 if (cmsg->cmsg_level == SOL_SOCKET &&
563 cmsg->cmsg_type == SCM_RIGHTS) {
566 /* Whut? We received fds during the auth
567 * protocol? Somebody is playing games with
568 * us. Close them all, and fail */
569 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
570 close_many((int*) CMSG_DATA(cmsg), j);
573 } else if (cmsg->cmsg_level == SOL_SOCKET &&
574 cmsg->cmsg_type == SCM_CREDENTIALS &&
575 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
577 /* Ignore bogus data, which we might
578 * get on socketpair() sockets */
579 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
580 memcpy(&b->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
581 b->ucred_valid = true;
584 } else if (cmsg->cmsg_level == SOL_SOCKET &&
585 cmsg->cmsg_type == SCM_SECURITY) {
589 l = cmsg->cmsg_len - CMSG_LEN(0);
591 memcpy(&b->label, CMSG_DATA(cmsg), l);
598 r = bus_socket_auth_verify(b);
605 int bus_socket_setup(sd_bus *b) {
611 /* Enable SO_PASSCRED + SO_PASSEC. We try this on any
612 * socket, just in case. */
613 enable = !b->bus_client;
614 setsockopt(b->input_fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable));
616 enable = !b->bus_client && (b->attach_flags & KDBUS_ATTACH_SECLABEL);
617 setsockopt(b->input_fd, SOL_SOCKET, SO_PASSSEC, &enable, sizeof(enable));
619 /* Increase the buffers to 8 MB */
620 fd_inc_rcvbuf(b->input_fd, SNDBUF_SIZE);
621 fd_inc_sndbuf(b->output_fd, SNDBUF_SIZE);
623 /* Get the peer for socketpair() sockets */
624 l = sizeof(b->ucred);
625 if (getsockopt(b->input_fd, SOL_SOCKET, SO_PEERCRED, &b->ucred, &l) >= 0 && l >= sizeof(b->ucred))
626 b->ucred_valid = b->ucred.pid > 0;
628 b->is_kernel = false;
629 b->message_version = 1;
630 b->message_endian = 0;
635 static int bus_socket_start_auth_client(sd_bus *b) {
637 const char *auth_suffix, *auth_prefix;
641 if (b->anonymous_auth) {
642 auth_prefix = "\0AUTH ANONYMOUS ";
644 /* For ANONYMOUS auth we send some arbitrary "trace" string */
646 b->auth_buffer = hexmem("anonymous", l);
648 char text[20 + 1]; /* enough space for a 64bit integer plus NUL */
650 auth_prefix = "\0AUTH EXTERNAL ";
652 snprintf(text, sizeof(text), "%lu", (unsigned long) geteuid());
656 b->auth_buffer = hexmem(text, l);
662 if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD)
663 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
665 auth_suffix = "\r\nBEGIN\r\n";
667 b->auth_iovec[0].iov_base = (void*) auth_prefix;
668 b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
669 b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
670 b->auth_iovec[1].iov_len = l * 2;
671 b->auth_iovec[2].iov_base = (void*) auth_suffix;
672 b->auth_iovec[2].iov_len = strlen(auth_suffix);
674 return bus_socket_write_auth(b);
677 int bus_socket_start_auth(sd_bus *b) {
680 b->state = BUS_AUTHENTICATING;
681 b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
683 if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
684 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
686 if (b->output_fd != b->input_fd)
687 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
688 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
691 return bus_socket_read_auth(b);
693 return bus_socket_start_auth_client(b);
696 int bus_socket_connect(sd_bus *b) {
700 assert(b->input_fd < 0);
701 assert(b->output_fd < 0);
702 assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
704 b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
708 b->output_fd = b->input_fd;
710 r = bus_socket_setup(b);
714 r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
716 if (errno == EINPROGRESS)
722 return bus_socket_start_auth(b);
725 int bus_socket_exec(sd_bus *b) {
730 assert(b->input_fd < 0);
731 assert(b->output_fd < 0);
732 assert(b->exec_path);
734 r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
746 reset_all_signal_handlers();
748 close_all_fds(s+1, 1);
750 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
751 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
753 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
754 close_nointr_nofail(s[1]);
756 fd_cloexec(STDIN_FILENO, false);
757 fd_cloexec(STDOUT_FILENO, false);
758 fd_nonblock(STDIN_FILENO, false);
759 fd_nonblock(STDOUT_FILENO, false);
762 execvp(b->exec_path, b->exec_argv);
764 const char *argv[] = { b->exec_path, NULL };
765 execvp(b->exec_path, (char**) argv);
771 close_nointr_nofail(s[1]);
772 b->output_fd = b->input_fd = s[0];
774 r = bus_socket_setup(b);
778 return bus_socket_start_auth(b);
781 int bus_socket_take_fd(sd_bus *b) {
785 r = bus_socket_setup(b);
789 return bus_socket_start_auth(b);
792 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
802 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
804 if (*idx >= BUS_MESSAGE_SIZE(m))
807 r = bus_message_setup_iovec(m);
811 n = m->n_iovec * sizeof(struct iovec);
813 memcpy(iov, m->iovec, n);
816 iovec_advance(iov, &j, *idx);
818 if (bus->prefer_writev)
819 k = writev(bus->output_fd, iov, m->n_iovec);
825 struct cmsghdr *control;
826 control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
828 mh.msg_control = control;
829 control->cmsg_level = SOL_SOCKET;
830 control->cmsg_type = SCM_RIGHTS;
831 mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
832 memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
836 mh.msg_iovlen = m->n_iovec;
838 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
839 if (k < 0 && errno == ENOTSOCK) {
840 bus->prefer_writev = true;
841 k = writev(bus->output_fd, iov, m->n_iovec);
846 return errno == EAGAIN ? 0 : -errno;
852 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
859 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
861 if (bus->rbuffer_size < sizeof(struct bus_header)) {
862 *need = sizeof(struct bus_header) + 8;
864 /* Minimum message size:
868 * Method Call: +2 string headers
869 * Signal: +3 string headers
870 * Method Error: +1 string headers
872 * Method Reply: +1 uint32 headers
874 * A string header is at least 9 bytes
875 * A uint32 header is at least 8 bytes
877 * Hence the minimum message size of a valid message
878 * is header + 8 bytes */
883 a = ((const uint32_t*) bus->rbuffer)[1];
884 b = ((const uint32_t*) bus->rbuffer)[3];
886 e = ((const uint8_t*) bus->rbuffer)[0];
887 if (e == BUS_LITTLE_ENDIAN) {
890 } else if (e == BUS_BIG_ENDIAN) {
896 sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
897 if (sum >= BUS_MESSAGE_SIZE_MAX)
900 *need = (size_t) sum;
904 static int bus_socket_make_message(sd_bus *bus, size_t size) {
910 assert(bus->rbuffer_size >= size);
911 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
913 r = bus_rqueue_make_room(bus);
917 if (bus->rbuffer_size > size) {
918 b = memdup((const uint8_t*) bus->rbuffer + size,
919 bus->rbuffer_size - size);
925 r = bus_message_from_malloc(bus,
927 bus->fds, bus->n_fds,
928 bus->ucred_valid ? &bus->ucred : NULL,
929 bus->label[0] ? bus->label : NULL,
937 bus->rbuffer_size -= size;
942 bus->rqueue[bus->rqueue_size++] = t;
947 int bus_socket_read_message(sd_bus *bus) {
955 struct cmsghdr cmsghdr;
956 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
957 CMSG_SPACE(sizeof(struct ucred)) +
958 CMSG_SPACE(NAME_MAX)]; /*selinux label */
960 struct cmsghdr *cmsg;
961 bool handle_cmsg = false;
964 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
966 r = bus_socket_read_message_need(bus, &need);
970 if (bus->rbuffer_size >= need)
971 return bus_socket_make_message(bus, need);
973 b = realloc(bus->rbuffer, need);
980 iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
981 iov.iov_len = need - bus->rbuffer_size;
983 if (bus->prefer_readv)
984 k = readv(bus->input_fd, &iov, 1);
989 mh.msg_control = &control;
990 mh.msg_controllen = sizeof(control);
992 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
993 if (k < 0 && errno == ENOTSOCK) {
994 bus->prefer_readv = true;
995 k = readv(bus->input_fd, &iov, 1);
1000 return errno == EAGAIN ? 0 : -errno;
1004 bus->rbuffer_size += k;
1007 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
1008 if (cmsg->cmsg_level == SOL_SOCKET &&
1009 cmsg->cmsg_type == SCM_RIGHTS) {
1012 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1014 if (!bus->can_fds) {
1015 /* Whut? We received fds but this
1016 * isn't actually enabled? Close them,
1019 close_many((int*) CMSG_DATA(cmsg), n);
1023 f = realloc(bus->fds, sizeof(int) + (bus->n_fds + n));
1025 close_many((int*) CMSG_DATA(cmsg), n);
1029 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1032 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1033 cmsg->cmsg_type == SCM_CREDENTIALS &&
1034 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1036 /* Ignore bogus data, which we might
1037 * get on socketpair() sockets */
1038 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
1039 memcpy(&bus->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
1040 bus->ucred_valid = true;
1043 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1044 cmsg->cmsg_type == SCM_SECURITY) {
1047 l = cmsg->cmsg_len - CMSG_LEN(0);
1049 memcpy(&bus->label, CMSG_DATA(cmsg), l);
1056 r = bus_socket_read_message_need(bus, &need);
1060 if (bus->rbuffer_size >= need)
1061 return bus_socket_make_message(bus, need);
1066 int bus_socket_process_opening(sd_bus *b) {
1068 socklen_t slen = sizeof(error);
1075 assert(b->state == BUS_OPENING);
1081 if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1084 r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1086 b->last_connect_error = errno;
1087 else if (error != 0)
1088 b->last_connect_error = error;
1089 else if (p.revents & (POLLERR|POLLHUP))
1090 b->last_connect_error = ECONNREFUSED;
1092 return bus_socket_start_auth(b);
1094 return bus_next_address(b);
1097 int bus_socket_process_authenticating(sd_bus *b) {
1101 assert(b->state == BUS_AUTHENTICATING);
1103 if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1106 r = bus_socket_write_auth(b);
1110 return bus_socket_read_auth(b);