]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/bus-socket.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2013 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
27 #include "sd-daemon.h"
29 #include "alloc-util.h"
30 #include "bus-internal.h"
31 #include "bus-message.h"
32 #include "bus-socket.h"
34 #include "format-util.h"
35 #include "hexdecoct.h"
38 #include "selinux-util.h"
39 #include "signal-util.h"
40 #include "stdio-util.h"
41 #include "string-util.h"
42 #include "user-util.h"
46 #define SNDBUF_SIZE (8*1024*1024)
48 static void iovec_advance(struct iovec iov
[], unsigned *idx
, size_t size
) {
51 struct iovec
*i
= iov
+ *idx
;
53 if (i
->iov_len
> size
) {
54 i
->iov_base
= (uint8_t*) i
->iov_base
+ size
;
68 static int append_iovec(sd_bus_message
*m
, const void *p
, size_t sz
) {
73 m
->iovec
[m
->n_iovec
].iov_base
= (void*) p
;
74 m
->iovec
[m
->n_iovec
].iov_len
= sz
;
80 static int bus_message_setup_iovec(sd_bus_message
*m
) {
81 struct bus_body_part
*part
;
93 n
= 1 + m
->n_body_parts
;
94 if (n
< ELEMENTSOF(m
->iovec_fixed
))
95 m
->iovec
= m
->iovec_fixed
;
97 m
->iovec
= new(struct iovec
, n
);
104 r
= append_iovec(m
, m
->header
, BUS_MESSAGE_BODY_BEGIN(m
));
108 MESSAGE_FOREACH_PART(part
, i
, m
) {
109 r
= bus_body_part_map(part
);
113 r
= append_iovec(m
, part
->data
, part
->size
);
118 assert(n
== m
->n_iovec
);
127 bool bus_socket_auth_needs_write(sd_bus
*b
) {
131 if (b
->auth_index
>= ELEMENTSOF(b
->auth_iovec
))
134 for (i
= b
->auth_index
; i
< ELEMENTSOF(b
->auth_iovec
); i
++) {
135 struct iovec
*j
= b
->auth_iovec
+ i
;
144 static int bus_socket_write_auth(sd_bus
*b
) {
148 assert(b
->state
== BUS_AUTHENTICATING
);
150 if (!bus_socket_auth_needs_write(b
))
153 if (b
->prefer_writev
)
154 k
= writev(b
->output_fd
, b
->auth_iovec
+ b
->auth_index
, ELEMENTSOF(b
->auth_iovec
) - b
->auth_index
);
159 mh
.msg_iov
= b
->auth_iovec
+ b
->auth_index
;
160 mh
.msg_iovlen
= ELEMENTSOF(b
->auth_iovec
) - b
->auth_index
;
162 k
= sendmsg(b
->output_fd
, &mh
, MSG_DONTWAIT
|MSG_NOSIGNAL
);
163 if (k
< 0 && errno
== ENOTSOCK
) {
164 b
->prefer_writev
= true;
165 k
= writev(b
->output_fd
, b
->auth_iovec
+ b
->auth_index
, ELEMENTSOF(b
->auth_iovec
) - b
->auth_index
);
170 return errno
== EAGAIN
? 0 : -errno
;
172 iovec_advance(b
->auth_iovec
, &b
->auth_index
, (size_t) k
);
176 static int bus_socket_auth_verify_client(sd_bus
*b
) {
184 /* We expect two response lines: "OK" and possibly
187 e
= memmem_safe(b
->rbuffer
, b
->rbuffer_size
, "\r\n", 2);
191 if (b
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
) {
192 f
= memmem(e
+ 2, b
->rbuffer_size
- (e
- (char*) b
->rbuffer
) - 2, "\r\n", 2);
202 /* Nice! We got all the lines we need. First check the OK
205 if (e
- (char*) b
->rbuffer
!= 3 + 32)
208 if (memcmp(b
->rbuffer
, "OK ", 3))
211 b
->auth
= b
->anonymous_auth
? BUS_AUTH_ANONYMOUS
: BUS_AUTH_EXTERNAL
;
213 for (i
= 0; i
< 32; i
+= 2) {
216 x
= unhexchar(((char*) b
->rbuffer
)[3 + i
]);
217 y
= unhexchar(((char*) b
->rbuffer
)[3 + i
+ 1]);
222 peer
.bytes
[i
/2] = ((uint8_t) x
<< 4 | (uint8_t) y
);
225 if (!sd_id128_is_null(b
->server_id
) &&
226 !sd_id128_equal(b
->server_id
, peer
))
231 /* And possibly check the second line, too */
235 (f
- e
== strlen("\r\nAGREE_UNIX_FD")) &&
236 memcmp(e
+ 2, "AGREE_UNIX_FD", strlen("AGREE_UNIX_FD")) == 0;
238 b
->rbuffer_size
-= (start
- (char*) b
->rbuffer
);
239 memmove(b
->rbuffer
, start
, b
->rbuffer_size
);
241 r
= bus_start_running(b
);
248 static bool line_equals(const char *s
, size_t m
, const char *line
) {
255 return memcmp(s
, line
, l
) == 0;
258 static bool line_begins(const char *s
, size_t m
, const char *word
) {
265 if (memcmp(s
, word
, l
) != 0)
268 return m
== l
|| (m
> l
&& s
[l
] == ' ');
271 static int verify_anonymous_token(sd_bus
*b
, const char *p
, size_t l
) {
272 _cleanup_free_
char *token
= NULL
;
276 if (!b
->anonymous_auth
)
288 r
= unhexmem(p
, l
, (void **) &token
, &len
);
292 if (memchr(token
, 0, len
))
295 return !!utf8_is_valid(token
);
298 static int verify_external_token(sd_bus
*b
, const char *p
, size_t l
) {
299 _cleanup_free_
char *token
= NULL
;
304 /* We don't do any real authentication here. Instead, we if
305 * the owner of this bus wanted authentication he should have
306 * checked SO_PEERCRED before even creating the bus object. */
308 if (!b
->anonymous_auth
&& !b
->ucred_valid
)
320 r
= unhexmem(p
, l
, (void**) &token
, &len
);
324 if (memchr(token
, 0, len
))
327 r
= parse_uid(token
, &u
);
331 /* We ignore the passed value if anonymous authentication is
333 if (!b
->anonymous_auth
&& u
!= b
->ucred
.uid
)
339 static int bus_socket_auth_write(sd_bus
*b
, const char *t
) {
346 /* We only make use of the first iovec */
347 assert(IN_SET(b
->auth_index
, 0, 1));
350 p
= malloc(b
->auth_iovec
[0].iov_len
+ l
);
354 memcpy_safe(p
, b
->auth_iovec
[0].iov_base
, b
->auth_iovec
[0].iov_len
);
355 memcpy(p
+ b
->auth_iovec
[0].iov_len
, t
, l
);
357 b
->auth_iovec
[0].iov_base
= p
;
358 b
->auth_iovec
[0].iov_len
+= l
;
360 free(b
->auth_buffer
);
366 static int bus_socket_auth_write_ok(sd_bus
*b
) {
367 char t
[3 + 32 + 2 + 1];
371 xsprintf(t
, "OK " SD_ID128_FORMAT_STR
"\r\n", SD_ID128_FORMAT_VAL(b
->server_id
));
373 return bus_socket_auth_write(b
, t
);
376 static int bus_socket_auth_verify_server(sd_bus
*b
) {
380 bool processed
= false;
385 if (b
->rbuffer_size
< 1)
388 /* First char must be a NUL byte */
389 if (*(char*) b
->rbuffer
!= 0)
392 if (b
->rbuffer_size
< 3)
395 /* Begin with the first line */
396 if (b
->auth_rbegin
<= 0)
400 /* Check if line is complete */
401 line
= (char*) b
->rbuffer
+ b
->auth_rbegin
;
402 e
= memmem(line
, b
->rbuffer_size
- b
->auth_rbegin
, "\r\n", 2);
408 if (line_begins(line
, l
, "AUTH ANONYMOUS")) {
410 r
= verify_anonymous_token(b
, line
+ 14, l
- 14);
414 r
= bus_socket_auth_write(b
, "REJECTED\r\n");
416 b
->auth
= BUS_AUTH_ANONYMOUS
;
417 r
= bus_socket_auth_write_ok(b
);
420 } else if (line_begins(line
, l
, "AUTH EXTERNAL")) {
422 r
= verify_external_token(b
, line
+ 13, l
- 13);
426 r
= bus_socket_auth_write(b
, "REJECTED\r\n");
428 b
->auth
= BUS_AUTH_EXTERNAL
;
429 r
= bus_socket_auth_write_ok(b
);
432 } else if (line_begins(line
, l
, "AUTH"))
433 r
= bus_socket_auth_write(b
, "REJECTED EXTERNAL ANONYMOUS\r\n");
434 else if (line_equals(line
, l
, "CANCEL") ||
435 line_begins(line
, l
, "ERROR")) {
437 b
->auth
= _BUS_AUTH_INVALID
;
438 r
= bus_socket_auth_write(b
, "REJECTED\r\n");
440 } else if (line_equals(line
, l
, "BEGIN")) {
442 if (b
->auth
== _BUS_AUTH_INVALID
)
443 r
= bus_socket_auth_write(b
, "ERROR\r\n");
445 /* We can't leave from the auth phase
446 * before we haven't written
447 * everything queued, so let's check
450 if (bus_socket_auth_needs_write(b
))
453 b
->rbuffer_size
-= (e
+ 2 - (char*) b
->rbuffer
);
454 memmove(b
->rbuffer
, e
+ 2, b
->rbuffer_size
);
455 return bus_start_running(b
);
458 } else if (line_begins(line
, l
, "DATA")) {
460 if (b
->auth
== _BUS_AUTH_INVALID
)
461 r
= bus_socket_auth_write(b
, "ERROR\r\n");
463 if (b
->auth
== BUS_AUTH_ANONYMOUS
)
464 r
= verify_anonymous_token(b
, line
+ 4, l
- 4);
466 r
= verify_external_token(b
, line
+ 4, l
- 4);
471 b
->auth
= _BUS_AUTH_INVALID
;
472 r
= bus_socket_auth_write(b
, "REJECTED\r\n");
474 r
= bus_socket_auth_write_ok(b
);
476 } else if (line_equals(line
, l
, "NEGOTIATE_UNIX_FD")) {
477 if (b
->auth
== _BUS_AUTH_INVALID
|| !(b
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
478 r
= bus_socket_auth_write(b
, "ERROR\r\n");
481 r
= bus_socket_auth_write(b
, "AGREE_UNIX_FD\r\n");
484 r
= bus_socket_auth_write(b
, "ERROR\r\n");
489 b
->auth_rbegin
= e
+ 2 - (char*) b
->rbuffer
;
495 static int bus_socket_auth_verify(sd_bus
*b
) {
499 return bus_socket_auth_verify_server(b
);
501 return bus_socket_auth_verify_client(b
);
504 static int bus_socket_read_auth(sd_bus
*b
) {
506 struct iovec iov
= {};
512 struct cmsghdr cmsghdr
;
513 uint8_t buf
[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX
)];
515 bool handle_cmsg
= false;
518 assert(b
->state
== BUS_AUTHENTICATING
);
520 r
= bus_socket_auth_verify(b
);
524 n
= MAX(256u, b
->rbuffer_size
* 2);
526 if (n
> BUS_AUTH_SIZE_MAX
)
527 n
= BUS_AUTH_SIZE_MAX
;
529 if (b
->rbuffer_size
>= n
)
532 p
= realloc(b
->rbuffer
, n
);
538 iov
.iov_base
= (uint8_t*) b
->rbuffer
+ b
->rbuffer_size
;
539 iov
.iov_len
= n
- b
->rbuffer_size
;
542 k
= readv(b
->input_fd
, &iov
, 1);
547 mh
.msg_control
= &control
;
548 mh
.msg_controllen
= sizeof(control
);
550 k
= recvmsg(b
->input_fd
, &mh
, MSG_DONTWAIT
|MSG_NOSIGNAL
|MSG_CMSG_CLOEXEC
);
551 if (k
< 0 && errno
== ENOTSOCK
) {
552 b
->prefer_readv
= true;
553 k
= readv(b
->input_fd
, &iov
, 1);
558 return errno
== EAGAIN
? 0 : -errno
;
562 b
->rbuffer_size
+= k
;
565 struct cmsghdr
*cmsg
;
567 CMSG_FOREACH(cmsg
, &mh
)
568 if (cmsg
->cmsg_level
== SOL_SOCKET
&&
569 cmsg
->cmsg_type
== SCM_RIGHTS
) {
572 /* Whut? We received fds during the auth
573 * protocol? Somebody is playing games with
574 * us. Close them all, and fail */
575 j
= (cmsg
->cmsg_len
- CMSG_LEN(0)) / sizeof(int);
576 close_many((int*) CMSG_DATA(cmsg
), j
);
579 log_debug("Got unexpected auxiliary data with level=%d and type=%d",
580 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
583 r
= bus_socket_auth_verify(b
);
590 void bus_socket_setup(sd_bus
*b
) {
593 /* Increase the buffers to 8 MB */
594 fd_inc_rcvbuf(b
->input_fd
, SNDBUF_SIZE
);
595 fd_inc_sndbuf(b
->output_fd
, SNDBUF_SIZE
);
597 b
->message_version
= 1;
598 b
->message_endian
= 0;
601 static void bus_get_peercred(sd_bus
*b
) {
606 /* Get the peer for socketpair() sockets */
607 b
->ucred_valid
= getpeercred(b
->input_fd
, &b
->ucred
) >= 0;
609 /* Get the SELinux context of the peer */
610 if (mac_selinux_use()) {
611 r
= getpeersec(b
->input_fd
, &b
->label
);
612 if (r
< 0 && r
!= -EOPNOTSUPP
)
613 log_debug_errno(r
, "Failed to determine peer security context: %m");
617 static int bus_socket_start_auth_client(sd_bus
*b
) {
619 const char *auth_suffix
, *auth_prefix
;
623 if (b
->anonymous_auth
) {
624 auth_prefix
= "\0AUTH ANONYMOUS ";
626 /* For ANONYMOUS auth we send some arbitrary "trace" string */
628 b
->auth_buffer
= hexmem("anonymous", l
);
630 char text
[DECIMAL_STR_MAX(uid_t
) + 1];
632 auth_prefix
= "\0AUTH EXTERNAL ";
634 xsprintf(text
, UID_FMT
, geteuid());
637 b
->auth_buffer
= hexmem(text
, l
);
643 if (b
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
644 auth_suffix
= "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
646 auth_suffix
= "\r\nBEGIN\r\n";
648 b
->auth_iovec
[0].iov_base
= (void*) auth_prefix
;
649 b
->auth_iovec
[0].iov_len
= 1 + strlen(auth_prefix
+ 1);
650 b
->auth_iovec
[1].iov_base
= (void*) b
->auth_buffer
;
651 b
->auth_iovec
[1].iov_len
= l
* 2;
652 b
->auth_iovec
[2].iov_base
= (void*) auth_suffix
;
653 b
->auth_iovec
[2].iov_len
= strlen(auth_suffix
);
655 return bus_socket_write_auth(b
);
658 int bus_socket_start_auth(sd_bus
*b
) {
663 b
->state
= BUS_AUTHENTICATING
;
664 b
->auth_timeout
= now(CLOCK_MONOTONIC
) + BUS_AUTH_TIMEOUT
;
666 if (sd_is_socket(b
->input_fd
, AF_UNIX
, 0, 0) <= 0)
667 b
->hello_flags
&= ~KDBUS_HELLO_ACCEPT_FD
;
669 if (b
->output_fd
!= b
->input_fd
)
670 if (sd_is_socket(b
->output_fd
, AF_UNIX
, 0, 0) <= 0)
671 b
->hello_flags
&= ~KDBUS_HELLO_ACCEPT_FD
;
674 return bus_socket_read_auth(b
);
676 return bus_socket_start_auth_client(b
);
679 int bus_socket_connect(sd_bus
*b
) {
683 assert(b
->input_fd
< 0);
684 assert(b
->output_fd
< 0);
685 assert(b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
);
687 b
->input_fd
= socket(b
->sockaddr
.sa
.sa_family
, SOCK_STREAM
|SOCK_CLOEXEC
|SOCK_NONBLOCK
, 0);
691 b
->output_fd
= b
->input_fd
;
695 r
= connect(b
->input_fd
, &b
->sockaddr
.sa
, b
->sockaddr_size
);
697 if (errno
== EINPROGRESS
)
703 return bus_socket_start_auth(b
);
706 int bus_socket_exec(sd_bus
*b
) {
711 assert(b
->input_fd
< 0);
712 assert(b
->output_fd
< 0);
713 assert(b
->exec_path
);
715 r
= socketpair(AF_UNIX
, SOCK_STREAM
|SOCK_NONBLOCK
|SOCK_CLOEXEC
, 0, s
);
727 (void) reset_all_signal_handlers();
728 (void) reset_signal_mask();
730 close_all_fds(s
+1, 1);
732 assert_se(dup3(s
[1], STDIN_FILENO
, 0) == STDIN_FILENO
);
733 assert_se(dup3(s
[1], STDOUT_FILENO
, 0) == STDOUT_FILENO
);
735 if (!IN_SET(s
[1], STDIN_FILENO
, STDOUT_FILENO
))
738 fd_cloexec(STDIN_FILENO
, false);
739 fd_cloexec(STDOUT_FILENO
, false);
740 fd_nonblock(STDIN_FILENO
, false);
741 fd_nonblock(STDOUT_FILENO
, false);
744 execvp(b
->exec_path
, b
->exec_argv
);
746 const char *argv
[] = { b
->exec_path
, NULL
};
747 execvp(b
->exec_path
, (char**) argv
);
754 b
->output_fd
= b
->input_fd
= s
[0];
758 return bus_socket_start_auth(b
);
761 int bus_socket_take_fd(sd_bus
*b
) {
766 return bus_socket_start_auth(b
);
769 int bus_socket_write_message(sd_bus
*bus
, sd_bus_message
*m
, size_t *idx
) {
779 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
781 if (*idx
>= BUS_MESSAGE_SIZE(m
))
784 r
= bus_message_setup_iovec(m
);
788 n
= m
->n_iovec
* sizeof(struct iovec
);
790 memcpy_safe(iov
, m
->iovec
, n
);
793 iovec_advance(iov
, &j
, *idx
);
795 if (bus
->prefer_writev
)
796 k
= writev(bus
->output_fd
, iov
, m
->n_iovec
);
800 .msg_iovlen
= m
->n_iovec
,
803 if (m
->n_fds
> 0 && *idx
== 0) {
804 struct cmsghdr
*control
;
806 mh
.msg_control
= control
= alloca(CMSG_SPACE(sizeof(int) * m
->n_fds
));
807 mh
.msg_controllen
= control
->cmsg_len
= CMSG_LEN(sizeof(int) * m
->n_fds
);
808 control
->cmsg_level
= SOL_SOCKET
;
809 control
->cmsg_type
= SCM_RIGHTS
;
810 memcpy(CMSG_DATA(control
), m
->fds
, sizeof(int) * m
->n_fds
);
813 k
= sendmsg(bus
->output_fd
, &mh
, MSG_DONTWAIT
|MSG_NOSIGNAL
);
814 if (k
< 0 && errno
== ENOTSOCK
) {
815 bus
->prefer_writev
= true;
816 k
= writev(bus
->output_fd
, iov
, m
->n_iovec
);
821 return errno
== EAGAIN
? 0 : -errno
;
827 static int bus_socket_read_message_need(sd_bus
*bus
, size_t *need
) {
834 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
836 if (bus
->rbuffer_size
< sizeof(struct bus_header
)) {
837 *need
= sizeof(struct bus_header
) + 8;
839 /* Minimum message size:
843 * Method Call: +2 string headers
844 * Signal: +3 string headers
845 * Method Error: +1 string headers
847 * Method Reply: +1 uint32 headers
849 * A string header is at least 9 bytes
850 * A uint32 header is at least 8 bytes
852 * Hence the minimum message size of a valid message
853 * is header + 8 bytes */
858 a
= ((const uint32_t*) bus
->rbuffer
)[1];
859 b
= ((const uint32_t*) bus
->rbuffer
)[3];
861 e
= ((const uint8_t*) bus
->rbuffer
)[0];
862 if (e
== BUS_LITTLE_ENDIAN
) {
865 } else if (e
== BUS_BIG_ENDIAN
) {
871 sum
= (uint64_t) sizeof(struct bus_header
) + (uint64_t) ALIGN_TO(b
, 8) + (uint64_t) a
;
872 if (sum
>= BUS_MESSAGE_SIZE_MAX
)
875 *need
= (size_t) sum
;
879 static int bus_socket_make_message(sd_bus
*bus
, size_t size
) {
885 assert(bus
->rbuffer_size
>= size
);
886 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
888 r
= bus_rqueue_make_room(bus
);
892 if (bus
->rbuffer_size
> size
) {
893 b
= memdup((const uint8_t*) bus
->rbuffer
+ size
,
894 bus
->rbuffer_size
- size
);
900 r
= bus_message_from_malloc(bus
,
902 bus
->fds
, bus
->n_fds
,
911 bus
->rbuffer_size
-= size
;
916 bus
->rqueue
[bus
->rqueue_size
++] = t
;
921 int bus_socket_read_message(sd_bus
*bus
) {
923 struct iovec iov
= {};
929 struct cmsghdr cmsghdr
;
930 uint8_t buf
[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX
)];
932 bool handle_cmsg
= false;
935 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
937 r
= bus_socket_read_message_need(bus
, &need
);
941 if (bus
->rbuffer_size
>= need
)
942 return bus_socket_make_message(bus
, need
);
944 b
= realloc(bus
->rbuffer
, need
);
950 iov
.iov_base
= (uint8_t*) bus
->rbuffer
+ bus
->rbuffer_size
;
951 iov
.iov_len
= need
- bus
->rbuffer_size
;
953 if (bus
->prefer_readv
)
954 k
= readv(bus
->input_fd
, &iov
, 1);
959 mh
.msg_control
= &control
;
960 mh
.msg_controllen
= sizeof(control
);
962 k
= recvmsg(bus
->input_fd
, &mh
, MSG_DONTWAIT
|MSG_NOSIGNAL
|MSG_CMSG_CLOEXEC
);
963 if (k
< 0 && errno
== ENOTSOCK
) {
964 bus
->prefer_readv
= true;
965 k
= readv(bus
->input_fd
, &iov
, 1);
970 return errno
== EAGAIN
? 0 : -errno
;
974 bus
->rbuffer_size
+= k
;
977 struct cmsghdr
*cmsg
;
979 CMSG_FOREACH(cmsg
, &mh
)
980 if (cmsg
->cmsg_level
== SOL_SOCKET
&&
981 cmsg
->cmsg_type
== SCM_RIGHTS
) {
984 n
= (cmsg
->cmsg_len
- CMSG_LEN(0)) / sizeof(int);
987 /* Whut? We received fds but this
988 * isn't actually enabled? Close them,
991 close_many((int*) CMSG_DATA(cmsg
), n
);
995 f
= realloc(bus
->fds
, sizeof(int) * (bus
->n_fds
+ n
));
997 close_many((int*) CMSG_DATA(cmsg
), n
);
1001 memcpy_safe(f
+ bus
->n_fds
, CMSG_DATA(cmsg
), n
* sizeof(int));
1005 log_debug("Got unexpected auxiliary data with level=%d and type=%d",
1006 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1009 r
= bus_socket_read_message_need(bus
, &need
);
1013 if (bus
->rbuffer_size
>= need
)
1014 return bus_socket_make_message(bus
, need
);
1019 int bus_socket_process_opening(sd_bus
*b
) {
1021 socklen_t slen
= sizeof(error
);
1028 assert(b
->state
== BUS_OPENING
);
1034 if (!(p
.revents
& (POLLOUT
|POLLERR
|POLLHUP
)))
1037 r
= getsockopt(b
->output_fd
, SOL_SOCKET
, SO_ERROR
, &error
, &slen
);
1039 b
->last_connect_error
= errno
;
1040 else if (error
!= 0)
1041 b
->last_connect_error
= error
;
1042 else if (p
.revents
& (POLLERR
|POLLHUP
))
1043 b
->last_connect_error
= ECONNREFUSED
;
1045 return bus_socket_start_auth(b
);
1047 return bus_next_address(b
);
1050 int bus_socket_process_authenticating(sd_bus
*b
) {
1054 assert(b
->state
== BUS_AUTHENTICATING
);
1056 if (now(CLOCK_MONOTONIC
) >= b
->auth_timeout
)
1059 r
= bus_socket_write_auth(b
);
1063 return bus_socket_read_auth(b
);