[thirdparty/systemd.git] / src / libsystemd / sd-daemon / sd-daemon.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include <errno.h>
#include <limits.h>
#include <mqueue.h>
#include <netinet/in.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>

#include "sd-daemon.h"

#include "alloc-util.h"
#include "fd-util.h"
#include "fs-util.h"
#include "io-util.h"
#include "parse-util.h"
#include "path-util.h"
#include "process-util.h"
#include "socket-util.h"
#include "strv.h"
#include "util.h"

#define SNDBUF_SIZE (8*1024*1024)

static void unsetenv_all(bool unset_environment) {

        if (!unset_environment)
                return;

        unsetenv("LISTEN_PID");
        unsetenv("LISTEN_FDS");
        unsetenv("LISTEN_FDNAMES");
}

_public_ int sd_listen_fds(int unset_environment) {
        const char *e;
        int n, r, fd;
        pid_t pid;

        e = getenv("LISTEN_PID");
        if (!e) {
                r = 0;
                goto finish;
        }

        r = parse_pid(e, &pid);
        if (r < 0)
                goto finish;

        /* Is this for us? */
        if (getpid_cached() != pid) {
                r = 0;
                goto finish;
        }

        e = getenv("LISTEN_FDS");
        if (!e) {
                r = 0;
                goto finish;
        }

        r = safe_atoi(e, &n);
        if (r < 0)
                goto finish;

        assert_cc(SD_LISTEN_FDS_START < INT_MAX);
        if (n <= 0 || n > INT_MAX - SD_LISTEN_FDS_START) {
                r = -EINVAL;
                goto finish;
        }

        for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
                r = fd_cloexec(fd, true);
                if (r < 0)
                        goto finish;
        }

        r = n;

finish:
        unsetenv_all(unset_environment);
        return r;
}

_public_ int sd_listen_fds_with_names(int unset_environment, char ***names) {
        _cleanup_strv_free_ char **l = NULL;
        bool have_names;
        int n_names = 0, n_fds;
        const char *e;
        int r;

        if (!names)
                return sd_listen_fds(unset_environment);

        e = getenv("LISTEN_FDNAMES");
        if (e) {
                n_names = strv_split_extract(&l, e, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
                if (n_names < 0) {
                        unsetenv_all(unset_environment);
                        return n_names;
                }

                have_names = true;
        } else
                have_names = false;

        n_fds = sd_listen_fds(unset_environment);
        if (n_fds <= 0)
                return n_fds;

        if (have_names) {
                if (n_names != n_fds)
                        return -EINVAL;
        } else {
                r = strv_extend_n(&l, "unknown", n_fds);
                if (r < 0)
                        return r;
        }

        *names = TAKE_PTR(l);

        return n_fds;
}

_public_ int sd_is_fifo(int fd, const char *path) {
        struct stat st_fd;

        assert_return(fd >= 0, -EBADF);

        if (fstat(fd, &st_fd) < 0)
                return -errno;

        if (!S_ISFIFO(st_fd.st_mode))
                return 0;

        if (path) {
                struct stat st_path;

                if (stat(path, &st_path) < 0) {

                        if (IN_SET(errno, ENOENT, ENOTDIR))
                                return 0;

                        return -errno;
                }

                return
                        st_path.st_dev == st_fd.st_dev &&
                        st_path.st_ino == st_fd.st_ino;
        }

        return 1;
}

_public_ int sd_is_special(int fd, const char *path) {
        struct stat st_fd;

        assert_return(fd >= 0, -EBADF);

        if (fstat(fd, &st_fd) < 0)
                return -errno;

        if (!S_ISREG(st_fd.st_mode) && !S_ISCHR(st_fd.st_mode))
                return 0;

        if (path) {
                struct stat st_path;

                if (stat(path, &st_path) < 0) {

                        if (IN_SET(errno, ENOENT, ENOTDIR))
                                return 0;

                        return -errno;
                }

                if (S_ISREG(st_fd.st_mode) && S_ISREG(st_path.st_mode))
                        return
                                st_path.st_dev == st_fd.st_dev &&
                                st_path.st_ino == st_fd.st_ino;
                else if (S_ISCHR(st_fd.st_mode) && S_ISCHR(st_path.st_mode))
                        return st_path.st_rdev == st_fd.st_rdev;
                else
                        return 0;
        }

        return 1;
}

static int sd_is_socket_internal(int fd, int type, int listening) {
        struct stat st_fd;

        assert_return(fd >= 0, -EBADF);
        assert_return(type >= 0, -EINVAL);

        if (fstat(fd, &st_fd) < 0)
                return -errno;

        if (!S_ISSOCK(st_fd.st_mode))
                return 0;

        if (type != 0) {
                int other_type = 0;
                socklen_t l = sizeof(other_type);

                if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &other_type, &l) < 0)
                        return -errno;

                if (l != sizeof(other_type))
                        return -EINVAL;

                if (other_type != type)
                        return 0;
        }

        if (listening >= 0) {
                int accepting = 0;
                socklen_t l = sizeof(accepting);

                if (getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN, &accepting, &l) < 0)
                        return -errno;

                if (l != sizeof(accepting))
                        return -EINVAL;

                if (!accepting != !listening)
                        return 0;
        }

        return 1;
}

_public_ int sd_is_socket(int fd, int family, int type, int listening) {
        int r;

        assert_return(fd >= 0, -EBADF);
        assert_return(family >= 0, -EINVAL);

        r = sd_is_socket_internal(fd, type, listening);
        if (r <= 0)
                return r;

        if (family > 0) {
                union sockaddr_union sockaddr = {};
                socklen_t l = sizeof(sockaddr);

                if (getsockname(fd, &sockaddr.sa, &l) < 0)
                        return -errno;

                if (l < sizeof(sa_family_t))
                        return -EINVAL;

                return sockaddr.sa.sa_family == family;
        }

        return 1;
}

_public_ int sd_is_socket_inet(int fd, int family, int type, int listening, uint16_t port) {
        union sockaddr_union sockaddr = {};
        socklen_t l = sizeof(sockaddr);
        int r;

        assert_return(fd >= 0, -EBADF);
        assert_return(IN_SET(family, 0, AF_INET, AF_INET6), -EINVAL);

        r = sd_is_socket_internal(fd, type, listening);
        if (r <= 0)
                return r;

        if (getsockname(fd, &sockaddr.sa, &l) < 0)
                return -errno;

        if (l < sizeof(sa_family_t))
                return -EINVAL;

        if (!IN_SET(sockaddr.sa.sa_family, AF_INET, AF_INET6))
                return 0;

        if (family != 0)
                if (sockaddr.sa.sa_family != family)
                        return 0;

        if (port > 0) {
                unsigned sa_port;

                r = sockaddr_port(&sockaddr.sa, &sa_port);
                if (r < 0)
                        return r;

                return port == sa_port;
        }

        return 1;
}

_public_ int sd_is_socket_sockaddr(int fd, int type, const struct sockaddr* addr, unsigned addr_len, int listening) {
        union sockaddr_union sockaddr = {};
        socklen_t l = sizeof(sockaddr);
        int r;

        assert_return(fd >= 0, -EBADF);
        assert_return(addr, -EINVAL);
        assert_return(addr_len >= sizeof(sa_family_t), -ENOBUFS);
        assert_return(IN_SET(addr->sa_family, AF_INET, AF_INET6), -EPFNOSUPPORT);

        r = sd_is_socket_internal(fd, type, listening);
        if (r <= 0)
                return r;

        if (getsockname(fd, &sockaddr.sa, &l) < 0)
                return -errno;

        if (l < sizeof(sa_family_t))
                return -EINVAL;

        if (sockaddr.sa.sa_family != addr->sa_family)
                return 0;

        if (sockaddr.sa.sa_family == AF_INET) {
                const struct sockaddr_in *in = (const struct sockaddr_in *) addr;

                if (l < sizeof(struct sockaddr_in) || addr_len < sizeof(struct sockaddr_in))
                        return -EINVAL;

                if (in->sin_port != 0 &&
                    sockaddr.in.sin_port != in->sin_port)
                        return false;

                return sockaddr.in.sin_addr.s_addr == in->sin_addr.s_addr;

        } else {
                const struct sockaddr_in6 *in = (const struct sockaddr_in6 *) addr;

                if (l < sizeof(struct sockaddr_in6) || addr_len < sizeof(struct sockaddr_in6))
                        return -EINVAL;

                if (in->sin6_port != 0 &&
                    sockaddr.in6.sin6_port != in->sin6_port)
                        return false;

                if (in->sin6_flowinfo != 0 &&
                    sockaddr.in6.sin6_flowinfo != in->sin6_flowinfo)
                        return false;

                if (in->sin6_scope_id != 0 &&
                    sockaddr.in6.sin6_scope_id != in->sin6_scope_id)
                        return false;

                return memcmp(sockaddr.in6.sin6_addr.s6_addr, in->sin6_addr.s6_addr,
                              sizeof(in->sin6_addr.s6_addr)) == 0;
        }
}

_public_ int sd_is_socket_unix(int fd, int type, int listening, const char *path, size_t length) {
        union sockaddr_union sockaddr = {};
        socklen_t l = sizeof(sockaddr);
        int r;

        assert_return(fd >= 0, -EBADF);

        r = sd_is_socket_internal(fd, type, listening);
        if (r <= 0)
                return r;

        if (getsockname(fd, &sockaddr.sa, &l) < 0)
                return -errno;

        if (l < sizeof(sa_family_t))
                return -EINVAL;

        if (sockaddr.sa.sa_family != AF_UNIX)
                return 0;

        if (path) {
                if (length == 0)
                        length = strlen(path);

                if (length == 0)
                        /* Unnamed socket */
                        return l == offsetof(struct sockaddr_un, sun_path);

                if (path[0])
                        /* Normal path socket */
                        return
                                (l >= offsetof(struct sockaddr_un, sun_path) + length + 1) &&
                                memcmp(path, sockaddr.un.sun_path, length+1) == 0;
                else
                        /* Abstract namespace socket */
                        return
                                (l == offsetof(struct sockaddr_un, sun_path) + length) &&
                                memcmp(path, sockaddr.un.sun_path, length) == 0;
        }

        return 1;
}

_public_ int sd_is_mq(int fd, const char *path) {
        struct mq_attr attr;

        /* Check that the fd is valid */
        assert_return(fcntl(fd, F_GETFD) >= 0, -errno);

        if (mq_getattr(fd, &attr) < 0) {
                if (errno == EBADF)
                        /* A non-mq fd (or an invalid one, but we ruled that out above) */
                        return 0;
                return -errno;
        }

        if (path) {
                char fpath[PATH_MAX];
                struct stat a, b;

                assert_return(path_is_absolute(path), -EINVAL);

                if (fstat(fd, &a) < 0)
                        return -errno;

                strncpy(stpcpy(fpath, "/dev/mqueue"), path, sizeof(fpath) - 12);
                fpath[sizeof(fpath)-1] = 0;

                if (stat(fpath, &b) < 0)
                        return -errno;

                if (a.st_dev != b.st_dev ||
                    a.st_ino != b.st_ino)
                        return 0;
        }

        return 1;
}

_public_ int sd_pid_notify_with_fds(
                pid_t pid,
                int unset_environment,
                const char *state,
                const int *fds,
                unsigned n_fds) {

        union sockaddr_union sockaddr = {};
        struct iovec iovec;
        struct msghdr msghdr = {
                .msg_iov = &iovec,
                .msg_iovlen = 1,
                .msg_name = &sockaddr,
        };
        _cleanup_close_ int fd = -1;
        struct cmsghdr *cmsg = NULL;
        const char *e;
        bool send_ucred;
        int r, salen;

        if (!state) {
                r = -EINVAL;
                goto finish;
        }

        if (n_fds > 0 && !fds) {
                r = -EINVAL;
                goto finish;
        }

        e = getenv("NOTIFY_SOCKET");
        if (!e)
                return 0;

        salen = sockaddr_un_set_path(&sockaddr.un, e);
        if (salen < 0) {
                r = salen;
                goto finish;
        }

        fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
        if (fd < 0) {
                r = -errno;
                goto finish;
        }

        (void) fd_inc_sndbuf(fd, SNDBUF_SIZE);

        iovec = IOVEC_MAKE_STRING(state);
        msghdr.msg_namelen = salen;

        send_ucred =
                (pid != 0 && pid != getpid_cached()) ||
                getuid() != geteuid() ||
                getgid() != getegid();

        if (n_fds > 0 || send_ucred) {
                /* CMSG_SPACE(0) may return value different than zero, which results in miscalculated controllen. */
                msghdr.msg_controllen =
                        (n_fds > 0 ? CMSG_SPACE(sizeof(int) * n_fds) : 0) +
                        (send_ucred ? CMSG_SPACE(sizeof(struct ucred)) : 0);

                msghdr.msg_control = alloca0(msghdr.msg_controllen);

                cmsg = CMSG_FIRSTHDR(&msghdr);
                if (n_fds > 0) {
                        cmsg->cmsg_level = SOL_SOCKET;
                        cmsg->cmsg_type = SCM_RIGHTS;
                        cmsg->cmsg_len = CMSG_LEN(sizeof(int) * n_fds);

                        memcpy(CMSG_DATA(cmsg), fds, sizeof(int) * n_fds);

                        if (send_ucred)
                                assert_se(cmsg = CMSG_NXTHDR(&msghdr, cmsg));
                }

                if (send_ucred) {
                        struct ucred *ucred;

                        cmsg->cmsg_level = SOL_SOCKET;
                        cmsg->cmsg_type = SCM_CREDENTIALS;
                        cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));

                        ucred = (struct ucred*) CMSG_DATA(cmsg);
                        ucred->pid = pid != 0 ? pid : getpid_cached();
                        ucred->uid = getuid();
                        ucred->gid = getgid();
                }
        }

        /* First try with fake ucred data, as requested */
        if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) >= 0) {
                r = 1;
                goto finish;
        }

        /* If that failed, try with our own ucred instead */
        if (send_ucred) {
                msghdr.msg_controllen -= CMSG_SPACE(sizeof(struct ucred));
                if (msghdr.msg_controllen == 0)
                        msghdr.msg_control = NULL;

                if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) >= 0) {
                        r = 1;
                        goto finish;
                }
        }

        r = -errno;

finish:
        if (unset_environment)
                unsetenv("NOTIFY_SOCKET");

        return r;
}

_public_ int sd_pid_notify(pid_t pid, int unset_environment, const char *state) {
        return sd_pid_notify_with_fds(pid, unset_environment, state, NULL, 0);
}

_public_ int sd_notify(int unset_environment, const char *state) {
        return sd_pid_notify_with_fds(0, unset_environment, state, NULL, 0);
}

_public_ int sd_pid_notifyf(pid_t pid, int unset_environment, const char *format, ...) {
        _cleanup_free_ char *p = NULL;
        int r;

        if (format) {
                va_list ap;

                va_start(ap, format);
                r = vasprintf(&p, format, ap);
                va_end(ap);

                if (r < 0 || !p)
                        return -ENOMEM;
        }

        return sd_pid_notify(pid, unset_environment, p);
}

_public_ int sd_notifyf(int unset_environment, const char *format, ...) {
        _cleanup_free_ char *p = NULL;
        int r;

        if (format) {
                va_list ap;

                va_start(ap, format);
                r = vasprintf(&p, format, ap);
                va_end(ap);

                if (r < 0 || !p)
                        return -ENOMEM;
        }

        return sd_pid_notify(0, unset_environment, p);
}

_public_ int sd_booted(void) {
        /* We test whether the runtime unit file directory has been
         * created. This takes place in mount-setup.c, so is
         * guaranteed to happen very early during boot. */

        if (laccess("/run/systemd/system/", F_OK) >= 0)
                return true;

        if (errno == ENOENT)
                return false;

        return -errno;
}

_public_ int sd_watchdog_enabled(int unset_environment, uint64_t *usec) {
        const char *s, *p = ""; /* p is set to dummy value to do unsetting */
        uint64_t u;
        int r = 0;

        s = getenv("WATCHDOG_USEC");
        if (!s)
                goto finish;

        r = safe_atou64(s, &u);
        if (r < 0)
                goto finish;
        if (u <= 0 || u >= USEC_INFINITY) {
                r = -EINVAL;
                goto finish;
        }

        p = getenv("WATCHDOG_PID");
        if (p) {
                pid_t pid;

                r = parse_pid(p, &pid);
                if (r < 0)
                        goto finish;

                /* Is this for us? */
                if (getpid_cached() != pid) {
                        r = 0;
                        goto finish;
                }
        }

        if (usec)
                *usec = u;

        r = 1;

finish:
        if (unset_environment && s)
                unsetenv("WATCHDOG_USEC");
        if (unset_environment && p)
                unsetenv("WATCHDOG_PID");

        return r;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
8c47c732	2
abbbea81	3	#include <errno.h>
916abb21	4	#include <limits.h>
0ebee881	5	#include <mqueue.h>
8dd4c05b LP	6	#include <netinet/in.h>
	7	#include <stdarg.h>
	8	#include <stddef.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <string.h>
	12	#include <sys/socket.h>
	13	#include <sys/stat.h>
	14	#include <sys/un.h>
	15	#include <unistd.h>
abbbea81	16
07630cea LP	17	#include "sd-daemon.h"
07630cea LP	18
b5efdb8a	19	#include "alloc-util.h"
3ffd4af2	20	#include "fd-util.h"
f4f15635	21	#include "fs-util.h"
cb310866	22	#include "io-util.h"
6bedfcbb	23	#include "parse-util.h"
be8f4e9e	24	#include "path-util.h"
dccca82b	25	#include "process-util.h"
3cb46740	26	#include "socket-util.h"
8dd4c05b LP	27	#include "strv.h"
	28	#include "util.h"
	29
a47806fa LP	30	#define SNDBUF_SIZE (810241024)
a47806fa LP	31
8dd4c05b LP	32	static void unsetenv_all(bool unset_environment) {
	33
	34	if (!unset_environment)
	35	return;
	36
	37	unsetenv("LISTEN_PID");
	38	unsetenv("LISTEN_FDS");
	39	unsetenv("LISTEN_FDNAMES");
	40	}
	41
0ebee881	42	_public_ int sd_listen_fds(int unset_environment) {
abbbea81	43	const char *e;
046c93f8	44	int n, r, fd;
be8f4e9e	45	pid_t pid;
abbbea81	46
50425d16 MS	47	e = getenv("LISTEN_PID");
50425d16 MS	48	if (!e) {
abbbea81 LP	49	r = 0;
	50	goto finish;
	51	}
	52
be8f4e9e LP	53	r = parse_pid(e, &pid);
be8f4e9e LP	54	if (r < 0)
abbbea81	55	goto finish;
abbbea81 LP	56
abbbea81 LP	57	/* Is this for us? */
df0ff127	58	if (getpid_cached() != pid) {
abbbea81 LP	59	r = 0;
	60	goto finish;
	61	}
	62
50425d16 MS	63	e = getenv("LISTEN_FDS");
50425d16 MS	64	if (!e) {
abbbea81 LP	65	r = 0;
	66	goto finish;
	67	}
	68
046c93f8	69	r = safe_atoi(e, &n);
be8f4e9e	70	if (r < 0)
abbbea81	71	goto finish;
8640e111	72
046c93f8 VC	73	assert_cc(SD_LISTEN_FDS_START < INT_MAX);
	74	if (n <= 0 \|\| n > INT_MAX - SD_LISTEN_FDS_START) {
	75	r = -EINVAL;
	76	goto finish;
	77	}
	78
	79	for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
be8f4e9e LP	80	r = fd_cloexec(fd, true);
be8f4e9e LP	81	if (r < 0)
8640e111	82	goto finish;
8640e111 LP	83	}
8640e111 LP	84
046c93f8	85	r = n;
abbbea81 LP	86
abbbea81 LP	87	finish:
8dd4c05b LP	88	unsetenv_all(unset_environment);
	89	return r;
	90	}
	91
	92	_public_ int sd_listen_fds_with_names(int unset_environment, char ***names) {
	93	_cleanup_strv_free_ char **l = NULL;
	94	bool have_names;
	95	int n_names = 0, n_fds;
	96	const char *e;
	97	int r;
	98
	99	if (!names)
	100	return sd_listen_fds(unset_environment);
	101
	102	e = getenv("LISTEN_FDNAMES");
	103	if (e) {
	104	n_names = strv_split_extract(&l, e, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
	105	if (n_names < 0) {
	106	unsetenv_all(unset_environment);
	107	return n_names;
	108	}
	109
	110	have_names = true;
	111	} else
	112	have_names = false;
	113
	114	n_fds = sd_listen_fds(unset_environment);
	115	if (n_fds <= 0)
	116	return n_fds;
	117
	118	if (have_names) {
	119	if (n_names != n_fds)
	120	return -EINVAL;
	121	} else {
	122	r = strv_extend_n(&l, "unknown", n_fds);
	123	if (r < 0)
	124	return r;
abbbea81 LP	125	}
abbbea81 LP	126
ae2a15bc	127	*names = TAKE_PTR(l);
8dd4c05b LP	128
8dd4c05b LP	129	return n_fds;
abbbea81	130	}
7c394faa	131
0ebee881	132	_public_ int sd_is_fifo(int fd, const char *path) {
7c394faa LP	133	struct stat st_fd;
7c394faa LP	134
e6803801	135	assert_return(fd >= 0, -EBADF);
7c394faa	136
7c394faa LP	137	if (fstat(fd, &st_fd) < 0)
	138	return -errno;
	139
	140	if (!S_ISFIFO(st_fd.st_mode))
	141	return 0;
	142
	143	if (path) {
	144	struct stat st_path;
	145
fd8bccfb	146	if (stat(path, &st_path) < 0) {
7c394faa	147
945c2931	148	if (IN_SET(errno, ENOENT, ENOTDIR))
7c394faa LP	149	return 0;
	150
	151	return -errno;
	152	}
	153
	154	return
	155	st_path.st_dev == st_fd.st_dev &&
	156	st_path.st_ino == st_fd.st_ino;
	157	}
	158
	159	return 1;
	160	}
	161
0ebee881	162	_public_ int sd_is_special(int fd, const char *path) {
4160ec67 WD	163	struct stat st_fd;
4160ec67 WD	164
e6803801	165	assert_return(fd >= 0, -EBADF);
4160ec67 WD	166
	167	if (fstat(fd, &st_fd) < 0)
	168	return -errno;
	169
	170	if (!S_ISREG(st_fd.st_mode) && !S_ISCHR(st_fd.st_mode))
	171	return 0;
	172
	173	if (path) {
	174	struct stat st_path;
	175
	176	if (stat(path, &st_path) < 0) {
	177
945c2931	178	if (IN_SET(errno, ENOENT, ENOTDIR))
4160ec67 WD	179	return 0;
	180
	181	return -errno;
	182	}
	183
	184	if (S_ISREG(st_fd.st_mode) && S_ISREG(st_path.st_mode))
	185	return
	186	st_path.st_dev == st_fd.st_dev &&
	187	st_path.st_ino == st_fd.st_ino;
	188	else if (S_ISCHR(st_fd.st_mode) && S_ISCHR(st_path.st_mode))
	189	return st_path.st_rdev == st_fd.st_rdev;
	190	else
	191	return 0;
	192	}
	193
	194	return 1;
	195	}
	196
e6a3081a	197	static int sd_is_socket_internal(int fd, int type, int listening) {
7c394faa LP	198	struct stat st_fd;
7c394faa LP	199
e6803801	200	assert_return(fd >= 0, -EBADF);
be8f4e9e	201	assert_return(type >= 0, -EINVAL);
7c394faa LP	202
	203	if (fstat(fd, &st_fd) < 0)
	204	return -errno;
	205
	206	if (!S_ISSOCK(st_fd.st_mode))
	207	return 0;
	208
	209	if (type != 0) {
	210	int other_type = 0;
	211	socklen_t l = sizeof(other_type);
	212
	213	if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &other_type, &l) < 0)
	214	return -errno;
	215
	216	if (l != sizeof(other_type))
	217	return -EINVAL;
	218
	219	if (other_type != type)
	220	return 0;
	221	}
	222
	223	if (listening >= 0) {
	224	int accepting = 0;
	225	socklen_t l = sizeof(accepting);
	226
	227	if (getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN, &accepting, &l) < 0)
	228	return -errno;
	229
	230	if (l != sizeof(accepting))
	231	return -EINVAL;
	232
dde770cf	233	if (!accepting != !listening)
7c394faa LP	234	return 0;
	235	}
	236
	237	return 1;
	238	}
	239
0ebee881	240	_public_ int sd_is_socket(int fd, int family, int type, int listening) {
88ce42f6 LP	241	int r;
88ce42f6 LP	242
e6803801	243	assert_return(fd >= 0, -EBADF);
be8f4e9e	244	assert_return(family >= 0, -EINVAL);
88ce42f6	245
50425d16 MS	246	r = sd_is_socket_internal(fd, type, listening);
50425d16 MS	247	if (r <= 0)
88ce42f6 LP	248	return r;
	249
	250	if (family > 0) {
1c633045 ZJS	251	union sockaddr_union sockaddr = {};
1c633045 ZJS	252	socklen_t l = sizeof(sockaddr);
88ce42f6 LP	253
	254	if (getsockname(fd, &sockaddr.sa, &l) < 0)
	255	return -errno;
	256
b7f42664	257	if (l < sizeof(sa_family_t))
88ce42f6 LP	258	return -EINVAL;
	259
	260	return sockaddr.sa.sa_family == family;
	261	}
	262
	263	return 1;
	264	}
	265
0ebee881	266	_public_ int sd_is_socket_inet(int fd, int family, int type, int listening, uint16_t port) {
1c633045 ZJS	267	union sockaddr_union sockaddr = {};
1c633045 ZJS	268	socklen_t l = sizeof(sockaddr);
7c394faa LP	269	int r;
7c394faa LP	270
e6803801	271	assert_return(fd >= 0, -EBADF);
be8f4e9e	272	assert_return(IN_SET(family, 0, AF_INET, AF_INET6), -EINVAL);
88ce42f6	273
50425d16 MS	274	r = sd_is_socket_internal(fd, type, listening);
50425d16 MS	275	if (r <= 0)
7c394faa LP	276	return r;
7c394faa LP	277
7c394faa LP	278	if (getsockname(fd, &sockaddr.sa, &l) < 0)
	279	return -errno;
	280
b7f42664	281	if (l < sizeof(sa_family_t))
7c394faa LP	282	return -EINVAL;
7c394faa LP	283
945c2931	284	if (!IN_SET(sockaddr.sa.sa_family, AF_INET, AF_INET6))
7c394faa LP	285	return 0;
7c394faa LP	286
be8f4e9e	287	if (family != 0)
88ce42f6 LP	288	if (sockaddr.sa.sa_family != family)
	289	return 0;
	290
7c394faa	291	if (port > 0) {
dfde7e8c	292	unsigned sa_port;
7c394faa	293
dfde7e8c LP	294	r = sockaddr_port(&sockaddr.sa, &sa_port);
	295	if (r < 0)
	296	return r;
7c394faa	297
dfde7e8c	298	return port == sa_port;
7c394faa LP	299	}
	300
	301	return 1;
	302	}
	303
f6f372d2 ZJS	304	_public_ int sd_is_socket_sockaddr(int fd, int type, const struct sockaddr* addr, unsigned addr_len, int listening) {
	305	union sockaddr_union sockaddr = {};
	306	socklen_t l = sizeof(sockaddr);
	307	int r;
	308
	309	assert_return(fd >= 0, -EBADF);
	310	assert_return(addr, -EINVAL);
	311	assert_return(addr_len >= sizeof(sa_family_t), -ENOBUFS);
	312	assert_return(IN_SET(addr->sa_family, AF_INET, AF_INET6), -EPFNOSUPPORT);
	313
	314	r = sd_is_socket_internal(fd, type, listening);
	315	if (r <= 0)
	316	return r;
	317
	318	if (getsockname(fd, &sockaddr.sa, &l) < 0)
	319	return -errno;
	320
	321	if (l < sizeof(sa_family_t))
	322	return -EINVAL;
	323
	324	if (sockaddr.sa.sa_family != addr->sa_family)
	325	return 0;
	326
	327	if (sockaddr.sa.sa_family == AF_INET) {
	328	const struct sockaddr_in in = (const struct sockaddr_in ) addr;
	329
	330	if (l < sizeof(struct sockaddr_in) \|\| addr_len < sizeof(struct sockaddr_in))
	331	return -EINVAL;
	332
	333	if (in->sin_port != 0 &&
	334	sockaddr.in.sin_port != in->sin_port)
	335	return false;
	336
	337	return sockaddr.in.sin_addr.s_addr == in->sin_addr.s_addr;
	338
	339	} else {
	340	const struct sockaddr_in6 in = (const struct sockaddr_in6 ) addr;
	341
	342	if (l < sizeof(struct sockaddr_in6) \|\| addr_len < sizeof(struct sockaddr_in6))
	343	return -EINVAL;
	344
	345	if (in->sin6_port != 0 &&
	346	sockaddr.in6.sin6_port != in->sin6_port)
	347	return false;
	348
	349	if (in->sin6_flowinfo != 0 &&
	350	sockaddr.in6.sin6_flowinfo != in->sin6_flowinfo)
	351	return false;
	352
	353	if (in->sin6_scope_id != 0 &&
	354	sockaddr.in6.sin6_scope_id != in->sin6_scope_id)
	355	return false;
	356
	357	return memcmp(sockaddr.in6.sin6_addr.s6_addr, in->sin6_addr.s6_addr,
	358	sizeof(in->sin6_addr.s6_addr)) == 0;
	359	}
	360	}
	361
0ebee881	362	_public_ int sd_is_socket_unix(int fd, int type, int listening, const char *path, size_t length) {
1c633045 ZJS	363	union sockaddr_union sockaddr = {};
1c633045 ZJS	364	socklen_t l = sizeof(sockaddr);
7c394faa LP	365	int r;
7c394faa LP	366
e6803801	367	assert_return(fd >= 0, -EBADF);
be8f4e9e	368
50425d16 MS	369	r = sd_is_socket_internal(fd, type, listening);
50425d16 MS	370	if (r <= 0)
7c394faa LP	371	return r;
7c394faa LP	372
7c394faa LP	373	if (getsockname(fd, &sockaddr.sa, &l) < 0)
	374	return -errno;
	375
b7f42664	376	if (l < sizeof(sa_family_t))
7c394faa LP	377	return -EINVAL;
	378
	379	if (sockaddr.sa.sa_family != AF_UNIX)
	380	return 0;
	381
	382	if (path) {
d1d7caee	383	if (length == 0)
7c394faa LP	384	length = strlen(path);
7c394faa LP	385
d1d7caee	386	if (length == 0)
7c394faa	387	/* Unnamed socket */
0e098b15	388	return l == offsetof(struct sockaddr_un, sun_path);
7c394faa	389
7c394faa LP	390	if (path[0])
7c394faa LP	391	/* Normal path socket */
cd250a39	392	return
0e098b15	393	(l >= offsetof(struct sockaddr_un, sun_path) + length + 1) &&
cd250a39	394	memcmp(path, sockaddr.un.sun_path, length+1) == 0;
7c394faa LP	395	else
7c394faa LP	396	/* Abstract namespace socket */
cd250a39	397	return
0e098b15	398	(l == offsetof(struct sockaddr_un, sun_path) + length) &&
cd250a39	399	memcmp(path, sockaddr.un.sun_path, length) == 0;
7c394faa LP	400	}
	401
	402	return 1;
	403	}
8c47c732	404
0ebee881	405	_public_ int sd_is_mq(int fd, const char *path) {
916abb21 LP	406	struct mq_attr attr;
916abb21 LP	407
0260d1d5 ZJS	408	/* Check that the fd is valid */
0260d1d5 ZJS	409	assert_return(fcntl(fd, F_GETFD) >= 0, -errno);
916abb21	410
0260d1d5 ZJS	411	if (mq_getattr(fd, &attr) < 0) {
	412	if (errno == EBADF)
	413	/* A non-mq fd (or an invalid one, but we ruled that out above) */
	414	return 0;
916abb21	415	return -errno;
0260d1d5	416	}
916abb21 LP	417
	418	if (path) {
	419	char fpath[PATH_MAX];
	420	struct stat a, b;
	421
be8f4e9e	422	assert_return(path_is_absolute(path), -EINVAL);
916abb21 LP	423
	424	if (fstat(fd, &a) < 0)
	425	return -errno;
	426
	427	strncpy(stpcpy(fpath, "/dev/mqueue"), path, sizeof(fpath) - 12);
	428	fpath[sizeof(fpath)-1] = 0;
	429
	430	if (stat(fpath, &b) < 0)
	431	return -errno;
	432
	433	if (a.st_dev != b.st_dev \|\|
	434	a.st_ino != b.st_ino)
	435	return 0;
	436	}
	437
	438	return 1;
916abb21 LP	439	}
916abb21 LP	440
9e1d021e LP	441	_public_ int sd_pid_notify_with_fds(
	442	pid_t pid,
	443	int unset_environment,
	444	const char *state,
	445	const int *fds,
	446	unsigned n_fds) {
	447
15a3e96f	448	union sockaddr_union sockaddr = {};
cb310866	449	struct iovec iovec;
a354329f LP	450	struct msghdr msghdr = {
	451	.msg_iov = &iovec,
	452	.msg_iovlen = 1,
	453	.msg_name = &sockaddr,
	454	};
a354329f LP	455	_cleanup_close_ int fd = -1;
	456	struct cmsghdr *cmsg = NULL;
	457	const char *e;
9e1d021e	458	bool send_ucred;
15a3e96f	459	int r, salen;
8c47c732 LP	460
	461	if (!state) {
	462	r = -EINVAL;
	463	goto finish;
	464	}
	465
a354329f LP	466	if (n_fds > 0 && !fds) {
	467	r = -EINVAL;
	468	goto finish;
	469	}
	470
50425d16 MS	471	e = getenv("NOTIFY_SOCKET");
50425d16 MS	472	if (!e)
08bfb810	473	return 0;
8c47c732	474
15a3e96f LP	475	salen = sockaddr_un_set_path(&sockaddr.un, e);
	476	if (salen < 0) {
	477	r = salen;
638b56cd LP	478	goto finish;
	479	}
	480
50425d16 MS	481	fd = socket(AF_UNIX, SOCK_DGRAM\|SOCK_CLOEXEC, 0);
50425d16 MS	482	if (fd < 0) {
8c47c732 LP	483	r = -errno;
	484	goto finish;
	485	}
	486
9e1d021e	487	(void) fd_inc_sndbuf(fd, SNDBUF_SIZE);
a47806fa	488
cb310866	489	iovec = IOVEC_MAKE_STRING(state);
15a3e96f	490	msghdr.msg_namelen = salen;
a013bd94	491
9e1d021e LP	492	send_ucred =
	493	(pid != 0 && pid != getpid_cached()) \|\|
	494	getuid() != geteuid() \|\|
	495	getgid() != getegid();
d4a144fa	496
9e1d021e	497	if (n_fds > 0 \|\| send_ucred) {
96d49011	498	/* CMSG_SPACE(0) may return value different than zero, which results in miscalculated controllen. */
c463a6f1 LP	499	msghdr.msg_controllen =
c463a6f1 LP	500	(n_fds > 0 ? CMSG_SPACE(sizeof(int) * n_fds) : 0) +
9e1d021e	501	(send_ucred ? CMSG_SPACE(sizeof(struct ucred)) : 0);
c463a6f1	502
40f44238	503	msghdr.msg_control = alloca0(msghdr.msg_controllen);
a354329f LP	504
a354329f LP	505	cmsg = CMSG_FIRSTHDR(&msghdr);
64144440 ZJS	506	if (n_fds > 0) {
	507	cmsg->cmsg_level = SOL_SOCKET;
	508	cmsg->cmsg_type = SCM_RIGHTS;
	509	cmsg->cmsg_len = CMSG_LEN(sizeof(int) * n_fds);
a354329f	510
64144440	511	memcpy(CMSG_DATA(cmsg), fds, sizeof(int) * n_fds);
be8f4e9e	512
9e1d021e	513	if (send_ucred)
64144440 ZJS	514	assert_se(cmsg = CMSG_NXTHDR(&msghdr, cmsg));
64144440 ZJS	515	}
a354329f	516
9e1d021e	517	if (send_ucred) {
64144440	518	struct ucred *ucred;
be8f4e9e	519
64144440 ZJS	520	cmsg->cmsg_level = SOL_SOCKET;
	521	cmsg->cmsg_type = SCM_CREDENTIALS;
	522	cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
be8f4e9e	523
64144440	524	ucred = (struct ucred*) CMSG_DATA(cmsg);
9e1d021e	525	ucred->pid = pid != 0 ? pid : getpid_cached();
64144440 ZJS	526	ucred->uid = getuid();
	527	ucred->gid = getgid();
	528	}
be8f4e9e LP	529	}
	530
	531	/* First try with fake ucred data, as requested */
	532	if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) >= 0) {
	533	r = 1;
8c47c732 LP	534	goto finish;
	535	}
	536
a354329f	537	/* If that failed, try with our own ucred instead */
9e1d021e	538	if (send_ucred) {
64144440 ZJS	539	msghdr.msg_controllen -= CMSG_SPACE(sizeof(struct ucred));
64144440 ZJS	540	if (msghdr.msg_controllen == 0)
a354329f	541	msghdr.msg_control = NULL;
be8f4e9e LP	542
	543	if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) >= 0) {
	544	r = 1;
	545	goto finish;
	546	}
	547	}
	548
	549	r = -errno;
8c47c732 LP	550
	551	finish:
	552	if (unset_environment)
	553	unsetenv("NOTIFY_SOCKET");
	554
8c47c732	555	return r;
8c47c732 LP	556	}
8c47c732 LP	557
a354329f LP	558	_public_ int sd_pid_notify(pid_t pid, int unset_environment, const char *state) {
	559	return sd_pid_notify_with_fds(pid, unset_environment, state, NULL, 0);
	560	}
	561
be8f4e9e	562	_public_ int sd_notify(int unset_environment, const char *state) {
a354329f	563	return sd_pid_notify_with_fds(0, unset_environment, state, NULL, 0);
be8f4e9e LP	564	}
	565
	566	_public_ int sd_pid_notifyf(pid_t pid, int unset_environment, const char *format, ...) {
	567	_cleanup_free_ char *p = NULL;
	568	int r;
	569
	570	if (format) {
	571	va_list ap;
	572
	573	va_start(ap, format);
	574	r = vasprintf(&p, format, ap);
	575	va_end(ap);
	576
	577	if (r < 0 \|\| !p)
	578	return -ENOMEM;
	579	}
	580
	581	return sd_pid_notify(pid, unset_environment, p);
	582	}
	583
0ebee881	584	_public_ int sd_notifyf(int unset_environment, const char *format, ...) {
be8f4e9e	585	_cleanup_free_ char *p = NULL;
8c47c732 LP	586	int r;
8c47c732 LP	587
be8f4e9e LP	588	if (format) {
be8f4e9e LP	589	va_list ap;
8c47c732	590
be8f4e9e LP	591	va_start(ap, format);
	592	r = vasprintf(&p, format, ap);
	593	va_end(ap);
8c47c732	594
be8f4e9e LP	595	if (r < 0 \|\| !p)
	596	return -ENOMEM;
	597	}
8c47c732	598
be8f4e9e	599	return sd_pid_notify(0, unset_environment, p);
8c47c732	600	}
40473a70	601
0ebee881	602	_public_ int sd_booted(void) {
66e41181 LP	603	/* We test whether the runtime unit file directory has been
	604	* created. This takes place in mount-setup.c, so is
	605	* guaranteed to happen very early during boot. */
40473a70	606
21042737 YW	607	if (laccess("/run/systemd/system/", F_OK) >= 0)
	608	return true;
	609
	610	if (errno == ENOENT)
	611	return false;
	612
	613	return -errno;
40473a70	614	}
09812eb7	615
0ebee881	616	_public_ int sd_watchdog_enabled(int unset_environment, uint64_t *usec) {
a9becdd6	617	const char s, p = ""; /* p is set to dummy value to do unsetting */
be8f4e9e	618	uint64_t u;
a9becdd6	619	int r = 0;
09812eb7	620
a9becdd6 ZJS	621	s = getenv("WATCHDOG_USEC");
a9becdd6 ZJS	622	if (!s)
09812eb7	623	goto finish;
09812eb7	624
a9becdd6	625	r = safe_atou64(s, &u);
be8f4e9e	626	if (r < 0)
09812eb7	627	goto finish;
caffe412	628	if (u <= 0 \|\| u >= USEC_INFINITY) {
09812eb7 LP	629	r = -EINVAL;
	630	goto finish;
	631	}
	632
a9becdd6 ZJS	633	p = getenv("WATCHDOG_PID");
	634	if (p) {
	635	pid_t pid;
	636
	637	r = parse_pid(p, &pid);
	638	if (r < 0)
	639	goto finish;
	640
	641	/* Is this for us? */
df0ff127	642	if (getpid_cached() != pid) {
a9becdd6 ZJS	643	r = 0;
	644	goto finish;
	645	}
09812eb7 LP	646	}
	647
	648	if (usec)
be8f4e9e	649	*usec = u;
09812eb7 LP	650
	651	r = 1;
	652
	653	finish:
a9becdd6	654	if (unset_environment && s)
09812eb7	655	unsetenv("WATCHDOG_USEC");
a9becdd6 ZJS	656	if (unset_environment && p)
a9becdd6 ZJS	657	unsetenv("WATCHDOG_PID");
09812eb7 LP	658
09812eb7 LP	659	return r;
09812eb7	660	}