[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. */

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

_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
52ad194e	1	/* SPDX-License-Identifier: LGPL-2.1+ */
663996b3	2
663996b3	3	#include <errno.h>
663996b3	4	#include <limits.h>
60f067b4	5	#include <mqueue.h>
6300502b MP	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>
663996b3	16
db2df898 MP	17	#include "sd-daemon.h"
	18
	19	#include "alloc-util.h"
	20	#include "fd-util.h"
	21	#include "fs-util.h"
6e866b33	22	#include "io-util.h"
db2df898	23	#include "parse-util.h"
60f067b4	24	#include "path-util.h"
1d42b86d	25	#include "process-util.h"
5eef597e	26	#include "socket-util.h"
6300502b MP	27	#include "strv.h"
	28	#include "util.h"
	29
db2df898	30	#define SNDBUF_SIZE (810241024)
663996b3	31
6300502b MP	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
60f067b4	42	_public_ int sd_listen_fds(int unset_environment) {
663996b3	43	const char *e;
db2df898	44	int n, r, fd;
60f067b4	45	pid_t pid;
663996b3 MS	46
	47	e = getenv("LISTEN_PID");
	48	if (!e) {
	49	r = 0;
	50	goto finish;
	51	}
	52
60f067b4 JS	53	r = parse_pid(e, &pid);
60f067b4 JS	54	if (r < 0)
663996b3	55	goto finish;
663996b3 MS	56
663996b3 MS	57	/* Is this for us? */
f5e65279	58	if (getpid_cached() != pid) {
663996b3 MS	59	r = 0;
	60	goto finish;
	61	}
	62
	63	e = getenv("LISTEN_FDS");
	64	if (!e) {
	65	r = 0;
	66	goto finish;
	67	}
	68
db2df898	69	r = safe_atoi(e, &n);
60f067b4	70	if (r < 0)
663996b3	71	goto finish;
663996b3	72
db2df898 MP	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 ++) {
60f067b4 JS	80	r = fd_cloexec(fd, true);
60f067b4 JS	81	if (r < 0)
663996b3	82	goto finish;
663996b3 MS	83	}
663996b3 MS	84
db2df898	85	r = n;
663996b3 MS	86
663996b3 MS	87	finish:
6300502b MP	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;
663996b3 MS	125	}
663996b3 MS	126
b012e921	127	*names = TAKE_PTR(l);
6300502b MP	128
6300502b MP	129	return n_fds;
663996b3 MS	130	}
663996b3 MS	131
60f067b4	132	_public_ int sd_is_fifo(int fd, const char *path) {
663996b3 MS	133	struct stat st_fd;
663996b3 MS	134
13d276d0	135	assert_return(fd >= 0, -EBADF);
663996b3 MS	136
	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
	146	if (stat(path, &st_path) < 0) {
	147
f5e65279	148	if (IN_SET(errno, ENOENT, ENOTDIR))
663996b3 MS	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
60f067b4	162	_public_ int sd_is_special(int fd, const char *path) {
663996b3 MS	163	struct stat st_fd;
663996b3 MS	164
13d276d0	165	assert_return(fd >= 0, -EBADF);
663996b3 MS	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
f5e65279	178	if (IN_SET(errno, ENOENT, ENOTDIR))
663996b3 MS	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
	197	static int sd_is_socket_internal(int fd, int type, int listening) {
	198	struct stat st_fd;
	199
13d276d0	200	assert_return(fd >= 0, -EBADF);
60f067b4	201	assert_return(type >= 0, -EINVAL);
663996b3 MS	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
	233	if (!accepting != !listening)
	234	return 0;
	235	}
	236
	237	return 1;
	238	}
	239
60f067b4	240	_public_ int sd_is_socket(int fd, int family, int type, int listening) {
663996b3 MS	241	int r;
663996b3 MS	242
13d276d0	243	assert_return(fd >= 0, -EBADF);
60f067b4	244	assert_return(family >= 0, -EINVAL);
663996b3 MS	245
	246	r = sd_is_socket_internal(fd, type, listening);
	247	if (r <= 0)
	248	return r;
	249
	250	if (family > 0) {
	251	union sockaddr_union sockaddr = {};
	252	socklen_t l = sizeof(sockaddr);
	253
	254	if (getsockname(fd, &sockaddr.sa, &l) < 0)
	255	return -errno;
	256
	257	if (l < sizeof(sa_family_t))
	258	return -EINVAL;
	259
	260	return sockaddr.sa.sa_family == family;
	261	}
	262
	263	return 1;
	264	}
	265
60f067b4	266	_public_ int sd_is_socket_inet(int fd, int family, int type, int listening, uint16_t port) {
663996b3 MS	267	union sockaddr_union sockaddr = {};
	268	socklen_t l = sizeof(sockaddr);
	269	int r;
	270
13d276d0	271	assert_return(fd >= 0, -EBADF);
60f067b4	272	assert_return(IN_SET(family, 0, AF_INET, AF_INET6), -EINVAL);
663996b3 MS	273
	274	r = sd_is_socket_internal(fd, type, listening);
	275	if (r <= 0)
	276	return r;
	277
	278	if (getsockname(fd, &sockaddr.sa, &l) < 0)
	279	return -errno;
	280
	281	if (l < sizeof(sa_family_t))
	282	return -EINVAL;
	283
f5e65279	284	if (!IN_SET(sockaddr.sa.sa_family, AF_INET, AF_INET6))
663996b3 MS	285	return 0;
663996b3 MS	286
60f067b4	287	if (family != 0)
663996b3 MS	288	if (sockaddr.sa.sa_family != family)
	289	return 0;
	290
	291	if (port > 0) {
1d42b86d	292	unsigned sa_port;
663996b3	293
1d42b86d MB	294	r = sockaddr_port(&sockaddr.sa, &sa_port);
	295	if (r < 0)
	296	return r;
663996b3	297
1d42b86d	298	return port == sa_port;
663996b3 MS	299	}
	300
	301	return 1;
	302	}
	303
2897b343 MP	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
60f067b4	362	_public_ int sd_is_socket_unix(int fd, int type, int listening, const char *path, size_t length) {
663996b3 MS	363	union sockaddr_union sockaddr = {};
	364	socklen_t l = sizeof(sockaddr);
	365	int r;
	366
13d276d0	367	assert_return(fd >= 0, -EBADF);
60f067b4	368
663996b3 MS	369	r = sd_is_socket_internal(fd, type, listening);
	370	if (r <= 0)
	371	return r;
	372
	373	if (getsockname(fd, &sockaddr.sa, &l) < 0)
	374	return -errno;
	375
	376	if (l < sizeof(sa_family_t))
	377	return -EINVAL;
	378
	379	if (sockaddr.sa.sa_family != AF_UNIX)
	380	return 0;
	381
	382	if (path) {
	383	if (length == 0)
	384	length = strlen(path);
	385
	386	if (length == 0)
	387	/* Unnamed socket */
	388	return l == offsetof(struct sockaddr_un, sun_path);
	389
	390	if (path[0])
	391	/* Normal path socket */
	392	return
	393	(l >= offsetof(struct sockaddr_un, sun_path) + length + 1) &&
	394	memcmp(path, sockaddr.un.sun_path, length+1) == 0;
	395	else
	396	/* Abstract namespace socket */
	397	return
	398	(l == offsetof(struct sockaddr_un, sun_path) + length) &&
	399	memcmp(path, sockaddr.un.sun_path, length) == 0;
	400	}
	401
	402	return 1;
	403	}
	404
60f067b4	405	_public_ int sd_is_mq(int fd, const char *path) {
663996b3 MS	406	struct mq_attr attr;
663996b3 MS	407
6300502b MP	408	/* Check that the fd is valid */
6300502b MP	409	assert_return(fcntl(fd, F_GETFD) >= 0, -errno);
663996b3	410
6300502b MP	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;
663996b3	415	return -errno;
6300502b	416	}
663996b3 MS	417
	418	if (path) {
	419	char fpath[PATH_MAX];
	420	struct stat a, b;
	421
60f067b4	422	assert_return(path_is_absolute(path), -EINVAL);
663996b3 MS	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;
663996b3 MS	439	}
663996b3 MS	440
1d42b86d MB	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
6e866b33 MB	448	union sockaddr_union sockaddr = {};
6e866b33 MB	449	struct iovec iovec;
e735f4d4 MP	450	struct msghdr msghdr = {
	451	.msg_iov = &iovec,
	452	.msg_iovlen = 1,
	453	.msg_name = &sockaddr,
	454	};
e735f4d4 MP	455	_cleanup_close_ int fd = -1;
	456	struct cmsghdr *cmsg = NULL;
	457	const char *e;
1d42b86d	458	bool send_ucred;
6e866b33	459	int r, salen;
663996b3 MS	460
	461	if (!state) {
	462	r = -EINVAL;
	463	goto finish;
	464	}
	465
e735f4d4 MP	466	if (n_fds > 0 && !fds) {
	467	r = -EINVAL;
	468	goto finish;
	469	}
	470
663996b3 MS	471	e = getenv("NOTIFY_SOCKET");
	472	if (!e)
	473	return 0;
	474
6e866b33 MB	475	salen = sockaddr_un_set_path(&sockaddr.un, e);
	476	if (salen < 0) {
	477	r = salen;
db2df898 MP	478	goto finish;
	479	}
	480
663996b3 MS	481	fd = socket(AF_UNIX, SOCK_DGRAM\|SOCK_CLOEXEC, 0);
	482	if (fd < 0) {
	483	r = -errno;
	484	goto finish;
	485	}
	486
1d42b86d	487	(void) fd_inc_sndbuf(fd, SNDBUF_SIZE);
db2df898	488
6e866b33 MB	489	iovec = IOVEC_MAKE_STRING(state);
6e866b33 MB	490	msghdr.msg_namelen = salen;
663996b3	491
1d42b86d MB	492	send_ucred =
	493	(pid != 0 && pid != getpid_cached()) \|\|
	494	getuid() != geteuid() \|\|
	495	getgid() != getegid();
e735f4d4	496
1d42b86d	497	if (n_fds > 0 \|\| send_ucred) {
aa27b158	498	/* CMSG_SPACE(0) may return value different than zero, which results in miscalculated controllen. */
db2df898 MP	499	msghdr.msg_controllen =
db2df898 MP	500	(n_fds > 0 ? CMSG_SPACE(sizeof(int) * n_fds) : 0) +
1d42b86d	501	(send_ucred ? CMSG_SPACE(sizeof(struct ucred)) : 0);
db2df898 MP	502
db2df898 MP	503	msghdr.msg_control = alloca0(msghdr.msg_controllen);
663996b3	504
e3bff60a MP	505	cmsg = CMSG_FIRSTHDR(&msghdr);
	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);
e735f4d4	510
e3bff60a	511	memcpy(CMSG_DATA(cmsg), fds, sizeof(int) * n_fds);
60f067b4	512
1d42b86d	513	if (send_ucred)
e3bff60a MP	514	assert_se(cmsg = CMSG_NXTHDR(&msghdr, cmsg));
e3bff60a MP	515	}
e735f4d4	516
1d42b86d	517	if (send_ucred) {
e3bff60a	518	struct ucred *ucred;
60f067b4	519
e3bff60a MP	520	cmsg->cmsg_level = SOL_SOCKET;
	521	cmsg->cmsg_type = SCM_CREDENTIALS;
	522	cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
60f067b4	523
e3bff60a	524	ucred = (struct ucred*) CMSG_DATA(cmsg);
1d42b86d	525	ucred->pid = pid != 0 ? pid : getpid_cached();
e3bff60a MP	526	ucred->uid = getuid();
	527	ucred->gid = getgid();
	528	}
60f067b4 JS	529	}
	530
	531	/* First try with fake ucred data, as requested */
	532	if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) >= 0) {
	533	r = 1;
663996b3 MS	534	goto finish;
	535	}
	536
e735f4d4	537	/* If that failed, try with our own ucred instead */
1d42b86d	538	if (send_ucred) {
e3bff60a MP	539	msghdr.msg_controllen -= CMSG_SPACE(sizeof(struct ucred));
e3bff60a MP	540	if (msghdr.msg_controllen == 0)
e735f4d4	541	msghdr.msg_control = NULL;
60f067b4 JS	542
	543	if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) >= 0) {
	544	r = 1;
	545	goto finish;
	546	}
	547	}
	548
	549	r = -errno;
663996b3 MS	550
	551	finish:
	552	if (unset_environment)
	553	unsetenv("NOTIFY_SOCKET");
	554
663996b3	555	return r;
663996b3 MS	556	}
663996b3 MS	557
e735f4d4 MP	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
60f067b4	562	_public_ int sd_notify(int unset_environment, const char *state) {
e735f4d4	563	return sd_pid_notify_with_fds(0, unset_environment, state, NULL, 0);
60f067b4 JS	564	}
	565
	566	_public_ int sd_pid_notifyf(pid_t pid, int unset_environment, const char *format, ...) {
	567	_cleanup_free_ char *p = NULL;
663996b3 MS	568	int r;
663996b3 MS	569
60f067b4 JS	570	if (format) {
60f067b4 JS	571	va_list ap;
663996b3	572
60f067b4 JS	573	va_start(ap, format);
	574	r = vasprintf(&p, format, ap);
	575	va_end(ap);
663996b3	576
60f067b4 JS	577	if (r < 0 \|\| !p)
	578	return -ENOMEM;
	579	}
663996b3	580
60f067b4	581	return sd_pid_notify(pid, unset_environment, p);
663996b3 MS	582	}
663996b3 MS	583
60f067b4 JS	584	_public_ int sd_notifyf(int unset_environment, const char *format, ...) {
	585	_cleanup_free_ char *p = NULL;
	586	int r;
	587
	588	if (format) {
	589	va_list ap;
	590
	591	va_start(ap, format);
	592	r = vasprintf(&p, format, ap);
	593	va_end(ap);
	594
	595	if (r < 0 \|\| !p)
	596	return -ENOMEM;
	597	}
	598
	599	return sd_pid_notify(0, unset_environment, p);
	600	}
	601
	602	_public_ int sd_booted(void) {
663996b3 MS	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. */
	606
6300502b	607	return laccess("/run/systemd/system/", F_OK) >= 0;
60f067b4 JS	608	}
	609
	610	_public_ int sd_watchdog_enabled(int unset_environment, uint64_t *usec) {
5eef597e	611	const char s, p = ""; /* p is set to dummy value to do unsetting */
60f067b4	612	uint64_t u;
5eef597e	613	int r = 0;
60f067b4	614
5eef597e MP	615	s = getenv("WATCHDOG_USEC");
5eef597e MP	616	if (!s)
60f067b4	617	goto finish;
60f067b4	618
5eef597e	619	r = safe_atou64(s, &u);
60f067b4 JS	620	if (r < 0)
60f067b4 JS	621	goto finish;
db2df898	622	if (u <= 0 \|\| u >= USEC_INFINITY) {
60f067b4 JS	623	r = -EINVAL;
	624	goto finish;
	625	}
	626
5eef597e MP	627	p = getenv("WATCHDOG_PID");
	628	if (p) {
	629	pid_t pid;
	630
	631	r = parse_pid(p, &pid);
	632	if (r < 0)
	633	goto finish;
	634
	635	/* Is this for us? */
f5e65279	636	if (getpid_cached() != pid) {
5eef597e MP	637	r = 0;
	638	goto finish;
	639	}
60f067b4 JS	640	}
	641
	642	if (usec)
	643	*usec = u;
	644
	645	r = 1;
	646
	647	finish:
5eef597e	648	if (unset_environment && s)
60f067b4	649	unsetenv("WATCHDOG_USEC");
5eef597e MP	650	if (unset_environment && p)
5eef597e MP	651	unsetenv("WATCHDOG_PID");
60f067b4 JS	652
60f067b4 JS	653	return r;
663996b3	654	}