1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
6 #include <netinet/in.h>
16 #include "sd-daemon.h"
18 #include "alloc-util.h"
22 #include "parse-util.h"
23 #include "path-util.h"
24 #include "process-util.h"
25 #include "socket-util.h"
26 #include "stat-util.h"
28 #include "time-util.h"
30 #define SNDBUF_SIZE (8*1024*1024)
32 static void unsetenv_all(bool unset_environment
) {
33 if (!unset_environment
)
36 assert_se(unsetenv("LISTEN_PID") == 0);
37 assert_se(unsetenv("LISTEN_FDS") == 0);
38 assert_se(unsetenv("LISTEN_FDNAMES") == 0);
41 _public_
int sd_listen_fds(int unset_environment
) {
46 e
= getenv("LISTEN_PID");
52 r
= parse_pid(e
, &pid
);
57 if (getpid_cached() != pid
) {
62 e
= getenv("LISTEN_FDS");
72 assert_cc(SD_LISTEN_FDS_START
< INT_MAX
);
73 if (n
<= 0 || n
> INT_MAX
- SD_LISTEN_FDS_START
) {
78 for (int fd
= SD_LISTEN_FDS_START
; fd
< SD_LISTEN_FDS_START
+ n
; fd
++) {
79 r
= fd_cloexec(fd
, true);
87 unsetenv_all(unset_environment
);
91 _public_
int sd_listen_fds_with_names(int unset_environment
, char ***names
) {
92 _cleanup_strv_free_
char **l
= NULL
;
94 int n_names
= 0, n_fds
;
99 return sd_listen_fds(unset_environment
);
101 e
= getenv("LISTEN_FDNAMES");
103 n_names
= strv_split_full(&l
, e
, ":", EXTRACT_DONT_COALESCE_SEPARATORS
);
105 unsetenv_all(unset_environment
);
113 n_fds
= sd_listen_fds(unset_environment
);
118 if (n_names
!= n_fds
)
121 r
= strv_extend_n(&l
, "unknown", n_fds
);
126 *names
= TAKE_PTR(l
);
131 _public_
int sd_is_fifo(int fd
, const char *path
) {
134 assert_return(fd
>= 0, -EBADF
);
136 if (fstat(fd
, &st_fd
) < 0)
139 if (!S_ISFIFO(st_fd
.st_mode
))
145 if (stat(path
, &st_path
) < 0) {
147 if (IN_SET(errno
, ENOENT
, ENOTDIR
))
153 return stat_inode_same(&st_path
, &st_fd
);
159 _public_
int sd_is_special(int fd
, const char *path
) {
162 assert_return(fd
>= 0, -EBADF
);
164 if (fstat(fd
, &st_fd
) < 0)
167 if (!S_ISREG(st_fd
.st_mode
) && !S_ISCHR(st_fd
.st_mode
))
173 if (stat(path
, &st_path
) < 0) {
175 if (IN_SET(errno
, ENOENT
, ENOTDIR
))
181 if (S_ISREG(st_fd
.st_mode
) && S_ISREG(st_path
.st_mode
))
182 return stat_inode_same(&st_path
, &st_fd
);
183 else if (S_ISCHR(st_fd
.st_mode
) && S_ISCHR(st_path
.st_mode
))
184 return st_path
.st_rdev
== st_fd
.st_rdev
;
192 static int is_socket_internal(int fd
, int type
, int listening
) {
195 assert_return(fd
>= 0, -EBADF
);
196 assert_return(type
>= 0, -EINVAL
);
198 if (fstat(fd
, &st_fd
) < 0)
201 if (!S_ISSOCK(st_fd
.st_mode
))
206 socklen_t l
= sizeof(other_type
);
208 if (getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, &other_type
, &l
) < 0)
211 if (l
!= sizeof(other_type
))
214 if (other_type
!= type
)
218 if (listening
>= 0) {
220 socklen_t l
= sizeof(accepting
);
222 if (getsockopt(fd
, SOL_SOCKET
, SO_ACCEPTCONN
, &accepting
, &l
) < 0)
225 if (l
!= sizeof(accepting
))
228 if (!accepting
!= !listening
)
235 _public_
int sd_is_socket(int fd
, int family
, int type
, int listening
) {
238 assert_return(fd
>= 0, -EBADF
);
239 assert_return(family
>= 0, -EINVAL
);
241 r
= is_socket_internal(fd
, type
, listening
);
246 union sockaddr_union sockaddr
= {};
247 socklen_t l
= sizeof(sockaddr
);
249 if (getsockname(fd
, &sockaddr
.sa
, &l
) < 0)
252 if (l
< sizeof(sa_family_t
))
255 return sockaddr
.sa
.sa_family
== family
;
261 _public_
int sd_is_socket_inet(int fd
, int family
, int type
, int listening
, uint16_t port
) {
262 union sockaddr_union sockaddr
= {};
263 socklen_t l
= sizeof(sockaddr
);
266 assert_return(fd
>= 0, -EBADF
);
267 assert_return(IN_SET(family
, 0, AF_INET
, AF_INET6
), -EINVAL
);
269 r
= is_socket_internal(fd
, type
, listening
);
273 if (getsockname(fd
, &sockaddr
.sa
, &l
) < 0)
276 if (l
< sizeof(sa_family_t
))
279 if (!IN_SET(sockaddr
.sa
.sa_family
, AF_INET
, AF_INET6
))
283 if (sockaddr
.sa
.sa_family
!= family
)
289 r
= sockaddr_port(&sockaddr
.sa
, &sa_port
);
293 return port
== sa_port
;
299 _public_
int sd_is_socket_sockaddr(int fd
, int type
, const struct sockaddr
* addr
, unsigned addr_len
, int listening
) {
300 union sockaddr_union sockaddr
= {};
301 socklen_t l
= sizeof(sockaddr
);
304 assert_return(fd
>= 0, -EBADF
);
305 assert_return(addr
, -EINVAL
);
306 assert_return(addr_len
>= sizeof(sa_family_t
), -ENOBUFS
);
307 assert_return(IN_SET(addr
->sa_family
, AF_INET
, AF_INET6
), -EPFNOSUPPORT
);
309 r
= is_socket_internal(fd
, type
, listening
);
313 if (getsockname(fd
, &sockaddr
.sa
, &l
) < 0)
316 if (l
< sizeof(sa_family_t
))
319 if (sockaddr
.sa
.sa_family
!= addr
->sa_family
)
322 if (sockaddr
.sa
.sa_family
== AF_INET
) {
323 const struct sockaddr_in
*in
= (const struct sockaddr_in
*) addr
;
325 if (l
< sizeof(struct sockaddr_in
) || addr_len
< sizeof(struct sockaddr_in
))
328 if (in
->sin_port
!= 0 &&
329 sockaddr
.in
.sin_port
!= in
->sin_port
)
332 return sockaddr
.in
.sin_addr
.s_addr
== in
->sin_addr
.s_addr
;
335 const struct sockaddr_in6
*in
= (const struct sockaddr_in6
*) addr
;
337 if (l
< sizeof(struct sockaddr_in6
) || addr_len
< sizeof(struct sockaddr_in6
))
340 if (in
->sin6_port
!= 0 &&
341 sockaddr
.in6
.sin6_port
!= in
->sin6_port
)
344 if (in
->sin6_flowinfo
!= 0 &&
345 sockaddr
.in6
.sin6_flowinfo
!= in
->sin6_flowinfo
)
348 if (in
->sin6_scope_id
!= 0 &&
349 sockaddr
.in6
.sin6_scope_id
!= in
->sin6_scope_id
)
352 return memcmp(sockaddr
.in6
.sin6_addr
.s6_addr
, in
->sin6_addr
.s6_addr
,
353 sizeof(in
->sin6_addr
.s6_addr
)) == 0;
357 _public_
int sd_is_socket_unix(int fd
, int type
, int listening
, const char *path
, size_t length
) {
358 union sockaddr_union sockaddr
= {};
359 socklen_t l
= sizeof(sockaddr
);
362 assert_return(fd
>= 0, -EBADF
);
364 r
= is_socket_internal(fd
, type
, listening
);
368 if (getsockname(fd
, &sockaddr
.sa
, &l
) < 0)
371 if (l
< sizeof(sa_family_t
))
374 if (sockaddr
.sa
.sa_family
!= AF_UNIX
)
379 length
= strlen(path
);
383 return l
== offsetof(struct sockaddr_un
, sun_path
);
386 /* Normal path socket */
388 (l
>= offsetof(struct sockaddr_un
, sun_path
) + length
+ 1) &&
389 memcmp(path
, sockaddr
.un
.sun_path
, length
+1) == 0;
391 /* Abstract namespace socket */
393 (l
== offsetof(struct sockaddr_un
, sun_path
) + length
) &&
394 memcmp(path
, sockaddr
.un
.sun_path
, length
) == 0;
400 _public_
int sd_is_mq(int fd
, const char *path
) {
403 /* Check that the fd is valid */
404 assert_return(fcntl(fd
, F_GETFD
) >= 0, -errno
);
406 if (mq_getattr(fd
, &attr
) < 0) {
408 /* A non-mq fd (or an invalid one, but we ruled that out above) */
414 _cleanup_free_
char *fpath
= NULL
;
417 assert_return(path_is_absolute(path
), -EINVAL
);
419 if (fstat(fd
, &a
) < 0)
422 fpath
= path_join("/dev/mqueue", path
);
426 if (stat(fpath
, &b
) < 0)
429 if (!stat_inode_same(&a
, &b
))
436 static int vsock_bind_privileged_port(int fd
) {
437 union sockaddr_union sa
= {
438 .vm
.svm_family
= AF_VSOCK
,
439 .vm
.svm_cid
= VMADDR_CID_ANY
,
447 r
= RET_NERRNO(bind(fd
, &sa
.sa
, sizeof(sa
.vm
)));
448 while (r
== -EADDRINUSE
&& --sa
.vm
.svm_port
> 0);
453 static int pid_notify_with_fds_internal(
458 SocketAddress address
;
460 struct msghdr msghdr
= {
463 .msg_name
= &address
.sockaddr
,
465 _cleanup_close_
int fd
= -EBADF
;
466 struct cmsghdr
*cmsg
= NULL
;
475 if (n_fds
> 0 && !fds
)
478 e
= getenv("NOTIFY_SOCKET");
482 /* Allow AF_UNIX and AF_VSOCK, reject the rest. */
483 r
= socket_address_parse_unix(&address
, e
);
485 r
= socket_address_parse_vsock(&address
, e
);
488 msghdr
.msg_namelen
= address
.size
;
490 /* If we didn't get an address (which is a normal pattern when specifying VSOCK tuples) error out,
491 * we always require a specific CID. */
492 if (address
.sockaddr
.vm
.svm_family
== AF_VSOCK
&& address
.sockaddr
.vm
.svm_cid
== VMADDR_CID_ANY
)
495 type
= address
.type
== 0 ? SOCK_DGRAM
: address
.type
;
497 /* At the time of writing QEMU does not yet support AF_VSOCK + SOCK_DGRAM and returns
498 * ENODEV. Fallback to SOCK_SEQPACKET in that case. */
499 fd
= socket(address
.sockaddr
.sa
.sa_family
, type
|SOCK_CLOEXEC
, 0);
501 if (!(ERRNO_IS_NOT_SUPPORTED(errno
) || errno
== ENODEV
) || address
.sockaddr
.sa
.sa_family
!= AF_VSOCK
|| address
.type
> 0)
502 return log_debug_errno(errno
, "Failed to open %s notify socket to '%s': %m", socket_address_type_to_string(type
), e
);
504 type
= SOCK_SEQPACKET
;
505 fd
= socket(address
.sockaddr
.sa
.sa_family
, type
|SOCK_CLOEXEC
, 0);
506 if (fd
< 0 && ERRNO_IS_NOT_SUPPORTED(errno
)) {
508 fd
= socket(address
.sockaddr
.sa
.sa_family
, type
|SOCK_CLOEXEC
, 0);
511 return log_debug_errno(errno
, "Failed to open %s socket to '%s': %m", socket_address_type_to_string(type
), e
);
514 if (address
.sockaddr
.sa
.sa_family
== AF_VSOCK
) {
515 r
= vsock_bind_privileged_port(fd
);
516 if (r
< 0 && !ERRNO_IS_PRIVILEGE(r
))
517 return log_debug_errno(r
, "Failed to bind socket to privileged port: %m");
520 if (IN_SET(type
, SOCK_STREAM
, SOCK_SEQPACKET
)) {
521 if (connect(fd
, &address
.sockaddr
.sa
, address
.size
) < 0)
522 return log_debug_errno(errno
, "Failed to connect socket to '%s': %m", e
);
524 msghdr
.msg_name
= NULL
;
525 msghdr
.msg_namelen
= 0;
528 (void) fd_inc_sndbuf(fd
, SNDBUF_SIZE
);
530 iovec
= IOVEC_MAKE_STRING(state
);
533 (pid
!= 0 && pid
!= getpid_cached()) ||
534 getuid() != geteuid() ||
535 getgid() != getegid();
537 if (n_fds
> 0 || send_ucred
) {
538 /* CMSG_SPACE(0) may return value different than zero, which results in miscalculated controllen. */
539 msghdr
.msg_controllen
=
540 (n_fds
> 0 ? CMSG_SPACE(sizeof(int) * n_fds
) : 0) +
541 (send_ucred
? CMSG_SPACE(sizeof(struct ucred
)) : 0);
543 msghdr
.msg_control
= alloca0(msghdr
.msg_controllen
);
545 cmsg
= CMSG_FIRSTHDR(&msghdr
);
547 cmsg
->cmsg_level
= SOL_SOCKET
;
548 cmsg
->cmsg_type
= SCM_RIGHTS
;
549 cmsg
->cmsg_len
= CMSG_LEN(sizeof(int) * n_fds
);
551 memcpy(CMSG_DATA(cmsg
), fds
, sizeof(int) * n_fds
);
554 assert_se(cmsg
= CMSG_NXTHDR(&msghdr
, cmsg
));
560 cmsg
->cmsg_level
= SOL_SOCKET
;
561 cmsg
->cmsg_type
= SCM_CREDENTIALS
;
562 cmsg
->cmsg_len
= CMSG_LEN(sizeof(struct ucred
));
564 ucred
= CMSG_TYPED_DATA(cmsg
, struct ucred
);
565 ucred
->pid
= pid
!= 0 ? pid
: getpid_cached();
566 ucred
->uid
= getuid();
567 ucred
->gid
= getgid();
572 /* First try with fake ucred data, as requested */
573 n
= sendmsg(fd
, &msghdr
, MSG_NOSIGNAL
);
576 return log_debug_errno(errno
, "Failed to send notify message to '%s': %m", e
);
578 /* If that failed, try with our own ucred instead */
579 msghdr
.msg_controllen
-= CMSG_SPACE(sizeof(struct ucred
));
580 if (msghdr
.msg_controllen
== 0)
581 msghdr
.msg_control
= NULL
;
586 /* Unless we're using SOCK_STREAM, we expect to write all the contents immediately. */
587 if (type
!= SOCK_STREAM
&& (size_t) n
< IOVEC_TOTAL_SIZE(msghdr
.msg_iov
, msghdr
.msg_iovlen
))
590 /* Make sure we only send fds and ucred once, even if we're using SOCK_STREAM. */
591 msghdr
.msg_control
= NULL
;
592 msghdr
.msg_controllen
= 0;
594 } while (!IOVEC_INCREMENT(msghdr
.msg_iov
, msghdr
.msg_iovlen
, n
));
599 _public_
int sd_pid_notify_with_fds(
601 int unset_environment
,
608 r
= pid_notify_with_fds_internal(pid
, state
, fds
, n_fds
);
610 if (unset_environment
)
611 assert_se(unsetenv("NOTIFY_SOCKET") == 0);
616 _public_
int sd_pid_notify_barrier(pid_t pid
, int unset_environment
, uint64_t timeout
) {
617 _cleanup_close_pair_
int pipe_fd
[2] = PIPE_EBADF
;
620 if (pipe2(pipe_fd
, O_CLOEXEC
) < 0)
623 r
= sd_pid_notify_with_fds(pid
, unset_environment
, "BARRIER=1", &pipe_fd
[1], 1);
627 pipe_fd
[1] = safe_close(pipe_fd
[1]);
629 r
= fd_wait_for_event(pipe_fd
[0], 0 /* POLLHUP is implicit */, timeout
);
638 _public_
int sd_notify_barrier(int unset_environment
, uint64_t timeout
) {
639 return sd_pid_notify_barrier(0, unset_environment
, timeout
);
642 _public_
int sd_pid_notify(pid_t pid
, int unset_environment
, const char *state
) {
643 return sd_pid_notify_with_fds(pid
, unset_environment
, state
, NULL
, 0);
646 _public_
int sd_notify(int unset_environment
, const char *state
) {
647 return sd_pid_notify_with_fds(0, unset_environment
, state
, NULL
, 0);
650 _public_
int sd_pid_notifyf(pid_t pid
, int unset_environment
, const char *format
, ...) {
651 _cleanup_free_
char *p
= NULL
;
657 va_start(ap
, format
);
658 r
= vasprintf(&p
, format
, ap
);
665 return sd_pid_notify(pid
, unset_environment
, p
);
668 _public_
int sd_notifyf(int unset_environment
, const char *format
, ...) {
669 _cleanup_free_
char *p
= NULL
;
675 va_start(ap
, format
);
676 r
= vasprintf(&p
, format
, ap
);
683 return sd_pid_notify(0, unset_environment
, p
);
686 _public_
int sd_pid_notifyf_with_fds(
688 int unset_environment
,
689 const int *fds
, size_t n_fds
,
690 const char *format
, ...) {
692 _cleanup_free_
char *p
= NULL
;
695 /* Paranoia check: we traditionally used 'unsigned' as array size, but we nowadays more correctly use
696 * 'size_t'. sd_pid_notifyf_with_fds() and sd_pid_notify_with_fds() are from different eras, hence
697 * differ in this. Let's catch resulting incompatibilites early, even though they are pretty much
699 if (n_fds
> UINT_MAX
)
705 va_start(ap
, format
);
706 r
= vasprintf(&p
, format
, ap
);
713 return sd_pid_notify_with_fds(pid
, unset_environment
, p
, fds
, n_fds
);
716 _public_
int sd_booted(void) {
717 /* We test whether the runtime unit file directory has been
718 * created. This takes place in mount-setup.c, so is
719 * guaranteed to happen very early during boot. */
721 if (laccess("/run/systemd/system/", F_OK
) >= 0)
730 _public_
int sd_watchdog_enabled(int unset_environment
, uint64_t *usec
) {
731 const char *s
, *p
= ""; /* p is set to dummy value to do unsetting */
735 s
= getenv("WATCHDOG_USEC");
739 r
= safe_atou64(s
, &u
);
742 if (!timestamp_is_set(u
)) {
747 p
= getenv("WATCHDOG_PID");
751 r
= parse_pid(p
, &pid
);
755 /* Is this for us? */
756 if (getpid_cached() != pid
) {
768 if (unset_environment
&& s
)
769 assert_se(unsetenv("WATCHDOG_USEC") == 0);
770 if (unset_environment
&& p
)
771 assert_se(unsetenv("WATCHDOG_PID") == 0);