]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/bus-socket.c
d0b1e3d7dc69873c8e6a727ae9198c903df0e7b1
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/>.
27 #include "sd-daemon.h"
32 #include "formats-util.h"
33 #include "signal-util.h"
36 #include "bus-socket.h"
37 #include "bus-internal.h"
38 #include "bus-message.h"
40 #define SNDBUF_SIZE (8*1024*1024)
42 static void iovec_advance(struct iovec iov
[], unsigned *idx
, size_t size
) {
45 struct iovec
*i
= iov
+ *idx
;
47 if (i
->iov_len
> size
) {
48 i
->iov_base
= (uint8_t*) i
->iov_base
+ size
;
62 static int append_iovec(sd_bus_message
*m
, const void *p
, size_t sz
) {
67 m
->iovec
[m
->n_iovec
].iov_base
= (void*) p
;
68 m
->iovec
[m
->n_iovec
].iov_len
= sz
;
74 static int bus_message_setup_iovec(sd_bus_message
*m
) {
75 struct bus_body_part
*part
;
87 n
= 1 + m
->n_body_parts
;
88 if (n
< ELEMENTSOF(m
->iovec_fixed
))
89 m
->iovec
= m
->iovec_fixed
;
91 m
->iovec
= new(struct iovec
, n
);
98 r
= append_iovec(m
, m
->header
, BUS_MESSAGE_BODY_BEGIN(m
));
102 MESSAGE_FOREACH_PART(part
, i
, m
) {
103 r
= bus_body_part_map(part
);
107 r
= append_iovec(m
, part
->data
, part
->size
);
112 assert(n
== m
->n_iovec
);
121 bool bus_socket_auth_needs_write(sd_bus
*b
) {
125 if (b
->auth_index
>= ELEMENTSOF(b
->auth_iovec
))
128 for (i
= b
->auth_index
; i
< ELEMENTSOF(b
->auth_iovec
); i
++) {
129 struct iovec
*j
= b
->auth_iovec
+ i
;
138 static int bus_socket_write_auth(sd_bus
*b
) {
142 assert(b
->state
== BUS_AUTHENTICATING
);
144 if (!bus_socket_auth_needs_write(b
))
147 if (b
->prefer_writev
)
148 k
= writev(b
->output_fd
, b
->auth_iovec
+ b
->auth_index
, ELEMENTSOF(b
->auth_iovec
) - b
->auth_index
);
153 mh
.msg_iov
= b
->auth_iovec
+ b
->auth_index
;
154 mh
.msg_iovlen
= ELEMENTSOF(b
->auth_iovec
) - b
->auth_index
;
156 k
= sendmsg(b
->output_fd
, &mh
, MSG_DONTWAIT
|MSG_NOSIGNAL
);
157 if (k
< 0 && errno
== ENOTSOCK
) {
158 b
->prefer_writev
= true;
159 k
= writev(b
->output_fd
, b
->auth_iovec
+ b
->auth_index
, ELEMENTSOF(b
->auth_iovec
) - b
->auth_index
);
164 return errno
== EAGAIN
? 0 : -errno
;
166 iovec_advance(b
->auth_iovec
, &b
->auth_index
, (size_t) k
);
170 static int bus_socket_auth_verify_client(sd_bus
*b
) {
178 /* We expect two response lines: "OK" and possibly
181 e
= memmem_safe(b
->rbuffer
, b
->rbuffer_size
, "\r\n", 2);
185 if (b
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
) {
186 f
= memmem(e
+ 2, b
->rbuffer_size
- (e
- (char*) b
->rbuffer
) - 2, "\r\n", 2);
196 /* Nice! We got all the lines we need. First check the OK
199 if (e
- (char*) b
->rbuffer
!= 3 + 32)
202 if (memcmp(b
->rbuffer
, "OK ", 3))
205 b
->auth
= b
->anonymous_auth
? BUS_AUTH_ANONYMOUS
: BUS_AUTH_EXTERNAL
;
207 for (i
= 0; i
< 32; i
+= 2) {
210 x
= unhexchar(((char*) b
->rbuffer
)[3 + i
]);
211 y
= unhexchar(((char*) b
->rbuffer
)[3 + i
+ 1]);
216 peer
.bytes
[i
/2] = ((uint8_t) x
<< 4 | (uint8_t) y
);
219 if (!sd_id128_equal(b
->server_id
, SD_ID128_NULL
) &&
220 !sd_id128_equal(b
->server_id
, peer
))
225 /* And possibly check the second line, too */
229 (f
- e
== strlen("\r\nAGREE_UNIX_FD")) &&
230 memcmp(e
+ 2, "AGREE_UNIX_FD", strlen("AGREE_UNIX_FD")) == 0;
232 b
->rbuffer_size
-= (start
- (char*) b
->rbuffer
);
233 memmove(b
->rbuffer
, start
, b
->rbuffer_size
);
235 r
= bus_start_running(b
);
242 static bool line_equals(const char *s
, size_t m
, const char *line
) {
249 return memcmp(s
, line
, l
) == 0;
252 static bool line_begins(const char *s
, size_t m
, const char *word
) {
259 if (memcmp(s
, word
, l
) != 0)
262 return m
== l
|| (m
> l
&& s
[l
] == ' ');
265 static int verify_anonymous_token(sd_bus
*b
, const char *p
, size_t l
) {
266 _cleanup_free_
char *token
= NULL
;
270 if (!b
->anonymous_auth
)
282 r
= unhexmem(p
, l
, (void **) &token
, &len
);
286 if (memchr(token
, 0, len
))
289 return !!utf8_is_valid(token
);
292 static int verify_external_token(sd_bus
*b
, const char *p
, size_t l
) {
293 _cleanup_free_
char *token
= NULL
;
298 /* We don't do any real authentication here. Instead, we if
299 * the owner of this bus wanted authentication he should have
300 * checked SO_PEERCRED before even creating the bus object. */
302 if (!b
->anonymous_auth
&& !b
->ucred_valid
)
314 r
= unhexmem(p
, l
, (void**) &token
, &len
);
318 if (memchr(token
, 0, len
))
321 r
= parse_uid(token
, &u
);
325 /* We ignore the passed value if anonymous authentication is
327 if (!b
->anonymous_auth
&& u
!= b
->ucred
.uid
)
333 static int bus_socket_auth_write(sd_bus
*b
, const char *t
) {
340 /* We only make use of the first iovec */
341 assert(b
->auth_index
== 0 || b
->auth_index
== 1);
344 p
= malloc(b
->auth_iovec
[0].iov_len
+ l
);
348 memcpy(p
, b
->auth_iovec
[0].iov_base
, b
->auth_iovec
[0].iov_len
);
349 memcpy(p
+ b
->auth_iovec
[0].iov_len
, t
, l
);
351 b
->auth_iovec
[0].iov_base
= p
;
352 b
->auth_iovec
[0].iov_len
+= l
;
354 free(b
->auth_buffer
);
360 static int bus_socket_auth_write_ok(sd_bus
*b
) {
361 char t
[3 + 32 + 2 + 1];
365 xsprintf(t
, "OK " SD_ID128_FORMAT_STR
"\r\n", SD_ID128_FORMAT_VAL(b
->server_id
));
367 return bus_socket_auth_write(b
, t
);
370 static int bus_socket_auth_verify_server(sd_bus
*b
) {
374 bool processed
= false;
379 if (b
->rbuffer_size
< 1)
382 /* First char must be a NUL byte */
383 if (*(char*) b
->rbuffer
!= 0)
386 if (b
->rbuffer_size
< 3)
389 /* Begin with the first line */
390 if (b
->auth_rbegin
<= 0)
394 /* Check if line is complete */
395 line
= (char*) b
->rbuffer
+ b
->auth_rbegin
;
396 e
= memmem(line
, b
->rbuffer_size
- b
->auth_rbegin
, "\r\n", 2);
402 if (line_begins(line
, l
, "AUTH ANONYMOUS")) {
404 r
= verify_anonymous_token(b
, line
+ 14, l
- 14);
408 r
= bus_socket_auth_write(b
, "REJECTED\r\n");
410 b
->auth
= BUS_AUTH_ANONYMOUS
;
411 r
= bus_socket_auth_write_ok(b
);
414 } else if (line_begins(line
, l
, "AUTH EXTERNAL")) {
416 r
= verify_external_token(b
, line
+ 13, l
- 13);
420 r
= bus_socket_auth_write(b
, "REJECTED\r\n");
422 b
->auth
= BUS_AUTH_EXTERNAL
;
423 r
= bus_socket_auth_write_ok(b
);
426 } else if (line_begins(line
, l
, "AUTH"))
427 r
= bus_socket_auth_write(b
, "REJECTED EXTERNAL ANONYMOUS\r\n");
428 else if (line_equals(line
, l
, "CANCEL") ||
429 line_begins(line
, l
, "ERROR")) {
431 b
->auth
= _BUS_AUTH_INVALID
;
432 r
= bus_socket_auth_write(b
, "REJECTED\r\n");
434 } else if (line_equals(line
, l
, "BEGIN")) {
436 if (b
->auth
== _BUS_AUTH_INVALID
)
437 r
= bus_socket_auth_write(b
, "ERROR\r\n");
439 /* We can't leave from the auth phase
440 * before we haven't written
441 * everything queued, so let's check
444 if (bus_socket_auth_needs_write(b
))
447 b
->rbuffer_size
-= (e
+ 2 - (char*) b
->rbuffer
);
448 memmove(b
->rbuffer
, e
+ 2, b
->rbuffer_size
);
449 return bus_start_running(b
);
452 } else if (line_begins(line
, l
, "DATA")) {
454 if (b
->auth
== _BUS_AUTH_INVALID
)
455 r
= bus_socket_auth_write(b
, "ERROR\r\n");
457 if (b
->auth
== BUS_AUTH_ANONYMOUS
)
458 r
= verify_anonymous_token(b
, line
+ 4, l
- 4);
460 r
= verify_external_token(b
, line
+ 4, l
- 4);
465 b
->auth
= _BUS_AUTH_INVALID
;
466 r
= bus_socket_auth_write(b
, "REJECTED\r\n");
468 r
= bus_socket_auth_write_ok(b
);
470 } else if (line_equals(line
, l
, "NEGOTIATE_UNIX_FD")) {
471 if (b
->auth
== _BUS_AUTH_INVALID
|| !(b
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
472 r
= bus_socket_auth_write(b
, "ERROR\r\n");
475 r
= bus_socket_auth_write(b
, "AGREE_UNIX_FD\r\n");
478 r
= bus_socket_auth_write(b
, "ERROR\r\n");
483 b
->auth_rbegin
= e
+ 2 - (char*) b
->rbuffer
;
489 static int bus_socket_auth_verify(sd_bus
*b
) {
493 return bus_socket_auth_verify_server(b
);
495 return bus_socket_auth_verify_client(b
);
498 static int bus_socket_read_auth(sd_bus
*b
) {
500 struct iovec iov
= {};
506 struct cmsghdr cmsghdr
;
507 uint8_t buf
[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX
)];
509 bool handle_cmsg
= false;
512 assert(b
->state
== BUS_AUTHENTICATING
);
514 r
= bus_socket_auth_verify(b
);
518 n
= MAX(256u, b
->rbuffer_size
* 2);
520 if (n
> BUS_AUTH_SIZE_MAX
)
521 n
= BUS_AUTH_SIZE_MAX
;
523 if (b
->rbuffer_size
>= n
)
526 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 struct cmsghdr
*cmsg
;
561 CMSG_FOREACH(cmsg
, &mh
)
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 log_debug("Got unexpected auxiliary data with level=%d and type=%d",
574 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
577 r
= bus_socket_auth_verify(b
);
584 void bus_socket_setup(sd_bus
*b
) {
587 /* Increase the buffers to 8 MB */
588 fd_inc_rcvbuf(b
->input_fd
, SNDBUF_SIZE
);
589 fd_inc_sndbuf(b
->output_fd
, SNDBUF_SIZE
);
591 b
->is_kernel
= false;
592 b
->message_version
= 1;
593 b
->message_endian
= 0;
596 static void bus_get_peercred(sd_bus
*b
) {
601 /* Get the peer for socketpair() sockets */
602 b
->ucred_valid
= getpeercred(b
->input_fd
, &b
->ucred
) >= 0;
604 /* Get the SELinux context of the peer */
605 r
= getpeersec(b
->input_fd
, &b
->label
);
606 if (r
< 0 && r
!= -EOPNOTSUPP
)
607 log_debug_errno(r
, "Failed to determine peer security context: %m");
610 static int bus_socket_start_auth_client(sd_bus
*b
) {
612 const char *auth_suffix
, *auth_prefix
;
616 if (b
->anonymous_auth
) {
617 auth_prefix
= "\0AUTH ANONYMOUS ";
619 /* For ANONYMOUS auth we send some arbitrary "trace" string */
621 b
->auth_buffer
= hexmem("anonymous", l
);
623 char text
[DECIMAL_STR_MAX(uid_t
) + 1];
625 auth_prefix
= "\0AUTH EXTERNAL ";
627 xsprintf(text
, UID_FMT
, geteuid());
630 b
->auth_buffer
= hexmem(text
, l
);
636 if (b
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
637 auth_suffix
= "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
639 auth_suffix
= "\r\nBEGIN\r\n";
641 b
->auth_iovec
[0].iov_base
= (void*) auth_prefix
;
642 b
->auth_iovec
[0].iov_len
= 1 + strlen(auth_prefix
+ 1);
643 b
->auth_iovec
[1].iov_base
= (void*) b
->auth_buffer
;
644 b
->auth_iovec
[1].iov_len
= l
* 2;
645 b
->auth_iovec
[2].iov_base
= (void*) auth_suffix
;
646 b
->auth_iovec
[2].iov_len
= strlen(auth_suffix
);
648 return bus_socket_write_auth(b
);
651 int bus_socket_start_auth(sd_bus
*b
) {
656 b
->state
= BUS_AUTHENTICATING
;
657 b
->auth_timeout
= now(CLOCK_MONOTONIC
) + BUS_DEFAULT_TIMEOUT
;
659 if (sd_is_socket(b
->input_fd
, AF_UNIX
, 0, 0) <= 0)
660 b
->hello_flags
&= ~KDBUS_HELLO_ACCEPT_FD
;
662 if (b
->output_fd
!= b
->input_fd
)
663 if (sd_is_socket(b
->output_fd
, AF_UNIX
, 0, 0) <= 0)
664 b
->hello_flags
&= ~KDBUS_HELLO_ACCEPT_FD
;
667 return bus_socket_read_auth(b
);
669 return bus_socket_start_auth_client(b
);
672 int bus_socket_connect(sd_bus
*b
) {
676 assert(b
->input_fd
< 0);
677 assert(b
->output_fd
< 0);
678 assert(b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
);
680 b
->input_fd
= socket(b
->sockaddr
.sa
.sa_family
, SOCK_STREAM
|SOCK_CLOEXEC
|SOCK_NONBLOCK
, 0);
684 b
->output_fd
= b
->input_fd
;
688 r
= connect(b
->input_fd
, &b
->sockaddr
.sa
, b
->sockaddr_size
);
690 if (errno
== EINPROGRESS
)
696 return bus_socket_start_auth(b
);
699 int bus_socket_exec(sd_bus
*b
) {
704 assert(b
->input_fd
< 0);
705 assert(b
->output_fd
< 0);
706 assert(b
->exec_path
);
708 r
= socketpair(AF_UNIX
, SOCK_STREAM
|SOCK_NONBLOCK
|SOCK_CLOEXEC
, 0, s
);
720 (void) reset_all_signal_handlers();
721 (void) reset_signal_mask();
723 close_all_fds(s
+1, 1);
725 assert_se(dup3(s
[1], STDIN_FILENO
, 0) == STDIN_FILENO
);
726 assert_se(dup3(s
[1], STDOUT_FILENO
, 0) == STDOUT_FILENO
);
728 if (s
[1] != STDIN_FILENO
&& s
[1] != STDOUT_FILENO
)
731 fd_cloexec(STDIN_FILENO
, false);
732 fd_cloexec(STDOUT_FILENO
, false);
733 fd_nonblock(STDIN_FILENO
, false);
734 fd_nonblock(STDOUT_FILENO
, false);
737 execvp(b
->exec_path
, b
->exec_argv
);
739 const char *argv
[] = { b
->exec_path
, NULL
};
740 execvp(b
->exec_path
, (char**) argv
);
747 b
->output_fd
= b
->input_fd
= s
[0];
751 return bus_socket_start_auth(b
);
754 int bus_socket_take_fd(sd_bus
*b
) {
759 return bus_socket_start_auth(b
);
762 int bus_socket_write_message(sd_bus
*bus
, sd_bus_message
*m
, size_t *idx
) {
772 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
774 if (*idx
>= BUS_MESSAGE_SIZE(m
))
777 r
= bus_message_setup_iovec(m
);
781 n
= m
->n_iovec
* sizeof(struct iovec
);
783 memcpy(iov
, m
->iovec
, n
);
786 iovec_advance(iov
, &j
, *idx
);
788 if (bus
->prefer_writev
)
789 k
= writev(bus
->output_fd
, iov
, m
->n_iovec
);
793 .msg_iovlen
= m
->n_iovec
,
797 struct cmsghdr
*control
;
799 mh
.msg_control
= control
= alloca(CMSG_SPACE(sizeof(int) * m
->n_fds
));
800 mh
.msg_controllen
= control
->cmsg_len
= CMSG_LEN(sizeof(int) * m
->n_fds
);
801 control
->cmsg_level
= SOL_SOCKET
;
802 control
->cmsg_type
= SCM_RIGHTS
;
803 memcpy(CMSG_DATA(control
), m
->fds
, sizeof(int) * m
->n_fds
);
806 k
= sendmsg(bus
->output_fd
, &mh
, MSG_DONTWAIT
|MSG_NOSIGNAL
);
807 if (k
< 0 && errno
== ENOTSOCK
) {
808 bus
->prefer_writev
= true;
809 k
= writev(bus
->output_fd
, iov
, m
->n_iovec
);
814 return errno
== EAGAIN
? 0 : -errno
;
820 static int bus_socket_read_message_need(sd_bus
*bus
, size_t *need
) {
827 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
829 if (bus
->rbuffer_size
< sizeof(struct bus_header
)) {
830 *need
= sizeof(struct bus_header
) + 8;
832 /* Minimum message size:
836 * Method Call: +2 string headers
837 * Signal: +3 string headers
838 * Method Error: +1 string headers
840 * Method Reply: +1 uint32 headers
842 * A string header is at least 9 bytes
843 * A uint32 header is at least 8 bytes
845 * Hence the minimum message size of a valid message
846 * is header + 8 bytes */
851 a
= ((const uint32_t*) bus
->rbuffer
)[1];
852 b
= ((const uint32_t*) bus
->rbuffer
)[3];
854 e
= ((const uint8_t*) bus
->rbuffer
)[0];
855 if (e
== BUS_LITTLE_ENDIAN
) {
858 } else if (e
== BUS_BIG_ENDIAN
) {
864 sum
= (uint64_t) sizeof(struct bus_header
) + (uint64_t) ALIGN_TO(b
, 8) + (uint64_t) a
;
865 if (sum
>= BUS_MESSAGE_SIZE_MAX
)
868 *need
= (size_t) sum
;
872 static int bus_socket_make_message(sd_bus
*bus
, size_t size
) {
878 assert(bus
->rbuffer_size
>= size
);
879 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
881 r
= bus_rqueue_make_room(bus
);
885 if (bus
->rbuffer_size
> size
) {
886 b
= memdup((const uint8_t*) bus
->rbuffer
+ size
,
887 bus
->rbuffer_size
- size
);
893 r
= bus_message_from_malloc(bus
,
895 bus
->fds
, bus
->n_fds
,
904 bus
->rbuffer_size
-= size
;
909 bus
->rqueue
[bus
->rqueue_size
++] = t
;
914 int bus_socket_read_message(sd_bus
*bus
) {
916 struct iovec iov
= {};
922 struct cmsghdr cmsghdr
;
923 uint8_t buf
[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX
)];
925 bool handle_cmsg
= false;
928 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
930 r
= bus_socket_read_message_need(bus
, &need
);
934 if (bus
->rbuffer_size
>= need
)
935 return bus_socket_make_message(bus
, need
);
937 b
= realloc(bus
->rbuffer
, need
);
943 iov
.iov_base
= (uint8_t*) bus
->rbuffer
+ bus
->rbuffer_size
;
944 iov
.iov_len
= need
- bus
->rbuffer_size
;
946 if (bus
->prefer_readv
)
947 k
= readv(bus
->input_fd
, &iov
, 1);
952 mh
.msg_control
= &control
;
953 mh
.msg_controllen
= sizeof(control
);
955 k
= recvmsg(bus
->input_fd
, &mh
, MSG_DONTWAIT
|MSG_NOSIGNAL
|MSG_CMSG_CLOEXEC
);
956 if (k
< 0 && errno
== ENOTSOCK
) {
957 bus
->prefer_readv
= true;
958 k
= readv(bus
->input_fd
, &iov
, 1);
963 return errno
== EAGAIN
? 0 : -errno
;
967 bus
->rbuffer_size
+= k
;
970 struct cmsghdr
*cmsg
;
972 CMSG_FOREACH(cmsg
, &mh
)
973 if (cmsg
->cmsg_level
== SOL_SOCKET
&&
974 cmsg
->cmsg_type
== SCM_RIGHTS
) {
977 n
= (cmsg
->cmsg_len
- CMSG_LEN(0)) / sizeof(int);
980 /* Whut? We received fds but this
981 * isn't actually enabled? Close them,
984 close_many((int*) CMSG_DATA(cmsg
), n
);
988 f
= realloc(bus
->fds
, sizeof(int) * (bus
->n_fds
+ n
));
990 close_many((int*) CMSG_DATA(cmsg
), n
);
994 memcpy(f
+ bus
->n_fds
, CMSG_DATA(cmsg
), n
* sizeof(int));
998 log_debug("Got unexpected auxiliary data with level=%d and type=%d",
999 cmsg
->cmsg_level
, cmsg
->cmsg_type
);
1002 r
= bus_socket_read_message_need(bus
, &need
);
1006 if (bus
->rbuffer_size
>= need
)
1007 return bus_socket_make_message(bus
, need
);
1012 int bus_socket_process_opening(sd_bus
*b
) {
1014 socklen_t slen
= sizeof(error
);
1021 assert(b
->state
== BUS_OPENING
);
1027 if (!(p
.revents
& (POLLOUT
|POLLERR
|POLLHUP
)))
1030 r
= getsockopt(b
->output_fd
, SOL_SOCKET
, SO_ERROR
, &error
, &slen
);
1032 b
->last_connect_error
= errno
;
1033 else if (error
!= 0)
1034 b
->last_connect_error
= error
;
1035 else if (p
.revents
& (POLLERR
|POLLHUP
))
1036 b
->last_connect_error
= ECONNREFUSED
;
1038 return bus_socket_start_auth(b
);
1040 return bus_next_address(b
);
1043 int bus_socket_process_authenticating(sd_bus
*b
) {
1047 assert(b
->state
== BUS_AUTHENTICATING
);
1049 if (now(CLOCK_MONOTONIC
) >= b
->auth_timeout
)
1052 r
= bus_socket_write_auth(b
);
1056 return bus_socket_read_auth(b
);