[thirdparty/systemd.git] / src / shared / socket-util.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <assert.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <net/if.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stddef.h>
#include <sys/ioctl.h>

#include "macro.h"
#include "util.h"
#include "mkdir.h"
#include "path-util.h"
#include "socket-util.h"
#include "missing.h"
#include "fileio.h"

int socket_address_parse(SocketAddress *a, const char *s) {
        char *e, *n;
        unsigned u;
        int r;

        assert(a);
        assert(s);

        zero(*a);
        a->type = SOCK_STREAM;

        if (*s == '[') {
                /* IPv6 in [x:.....:z]:p notation */

                if (!socket_ipv6_is_supported()) {
                        log_warning("Binding to IPv6 address not available since kernel does not support IPv6.");
                        return -EAFNOSUPPORT;
                }

                e = strchr(s+1, ']');
                if (!e)
                        return -EINVAL;

                n = strndupa(s+1, e-s-1);

                errno = 0;
                if (inet_pton(AF_INET6, n, &a->sockaddr.in6.sin6_addr) <= 0)
                        return errno > 0 ? -errno : -EINVAL;

                e++;
                if (*e != ':')
                        return -EINVAL;

                e++;
                r = safe_atou(e, &u);
                if (r < 0)
                        return r;

                if (u <= 0 || u > 0xFFFF)
                        return -EINVAL;

                a->sockaddr.in6.sin6_family = AF_INET6;
                a->sockaddr.in6.sin6_port = htons((uint16_t) u);
                a->size = sizeof(struct sockaddr_in6);

        } else if (*s == '/') {
                /* AF_UNIX socket */

                size_t l;

                l = strlen(s);
                if (l >= sizeof(a->sockaddr.un.sun_path))
                        return -EINVAL;

                a->sockaddr.un.sun_family = AF_UNIX;
                memcpy(a->sockaddr.un.sun_path, s, l);
                a->size = offsetof(struct sockaddr_un, sun_path) + l + 1;

        } else if (*s == '@') {
                /* Abstract AF_UNIX socket */
                size_t l;

                l = strlen(s+1);
                if (l >= sizeof(a->sockaddr.un.sun_path) - 1)
                        return -EINVAL;

                a->sockaddr.un.sun_family = AF_UNIX;
                memcpy(a->sockaddr.un.sun_path+1, s+1, l);
                a->size = offsetof(struct sockaddr_un, sun_path) + 1 + l;

        } else {
                e = strchr(s, ':');
                if (e) {
                        r = safe_atou(e+1, &u);
                        if (r < 0)
                                return r;

                        if (u <= 0 || u > 0xFFFF)
                                return -EINVAL;

                        n = strndupa(s, e-s);

                        /* IPv4 in w.x.y.z:p notation? */
                        r = inet_pton(AF_INET, n, &a->sockaddr.in.sin_addr);
                        if (r < 0)
                                return -errno;

                        if (r > 0) {
                                /* Gotcha, it's a traditional IPv4 address */
                                a->sockaddr.in.sin_family = AF_INET;
                                a->sockaddr.in.sin_port = htons((uint16_t) u);
                                a->size = sizeof(struct sockaddr_in);
                        } else {
                                unsigned idx;

                                if (strlen(n) > IF_NAMESIZE-1)
                                        return -EINVAL;

                                /* Uh, our last resort, an interface name */
                                idx = if_nametoindex(n);
                                if (idx == 0)
                                        return -EINVAL;

                                if (!socket_ipv6_is_supported()) {
                                        log_warning("Binding to interface is not available since kernel does not support IPv6.");
                                        return -EAFNOSUPPORT;
                                }

                                a->sockaddr.in6.sin6_family = AF_INET6;
                                a->sockaddr.in6.sin6_port = htons((uint16_t) u);
                                a->sockaddr.in6.sin6_scope_id = idx;
                                a->sockaddr.in6.sin6_addr = in6addr_any;
                                a->size = sizeof(struct sockaddr_in6);
                        }
                } else {

                        /* Just a port */
                        r = safe_atou(s, &u);
                        if (r < 0)
                                return r;

                        if (u <= 0 || u > 0xFFFF)
                                return -EINVAL;

                        if (socket_ipv6_is_supported()) {
                                a->sockaddr.in6.sin6_family = AF_INET6;
                                a->sockaddr.in6.sin6_port = htons((uint16_t) u);
                                a->sockaddr.in6.sin6_addr = in6addr_any;
                                a->size = sizeof(struct sockaddr_in6);
                        } else {
                                a->sockaddr.in.sin_family = AF_INET;
                                a->sockaddr.in.sin_port = htons((uint16_t) u);
                                a->sockaddr.in.sin_addr.s_addr = INADDR_ANY;
                                a->size = sizeof(struct sockaddr_in);
                        }
                }
        }

        return 0;
}

int socket_address_parse_netlink(SocketAddress *a, const char *s) {
        int family;
        unsigned group = 0;
        _cleanup_free_ char *sfamily = NULL;
        assert(a);
        assert(s);

        zero(*a);
        a->type = SOCK_RAW;

        errno = 0;
        if (sscanf(s, "%ms %u", &sfamily, &group) < 1)
                return errno > 0 ? -errno : -EINVAL;

        family = netlink_family_from_string(sfamily);
        if (family < 0)
                return -EINVAL;

        a->sockaddr.nl.nl_family = AF_NETLINK;
        a->sockaddr.nl.nl_groups = group;

        a->type = SOCK_RAW;
        a->size = sizeof(struct sockaddr_nl);
        a->protocol = family;

        return 0;
}

int socket_address_verify(const SocketAddress *a) {
        assert(a);

        switch (socket_address_family(a)) {

        case AF_INET:
                if (a->size != sizeof(struct sockaddr_in))
                        return -EINVAL;

                if (a->sockaddr.in.sin_port == 0)
                        return -EINVAL;

                if (a->type != SOCK_STREAM && a->type != SOCK_DGRAM)
                        return -EINVAL;

                return 0;

        case AF_INET6:
                if (a->size != sizeof(struct sockaddr_in6))
                        return -EINVAL;

                if (a->sockaddr.in6.sin6_port == 0)
                        return -EINVAL;

                if (a->type != SOCK_STREAM && a->type != SOCK_DGRAM)
                        return -EINVAL;

                return 0;

        case AF_UNIX:
                if (a->size < offsetof(struct sockaddr_un, sun_path))
                        return -EINVAL;

                if (a->size > offsetof(struct sockaddr_un, sun_path)) {

                        if (a->sockaddr.un.sun_path[0] != 0) {
                                char *e;

                                /* path */
                                e = memchr(a->sockaddr.un.sun_path, 0, sizeof(a->sockaddr.un.sun_path));
                                if (!e)
                                        return -EINVAL;

                                if (a->size != offsetof(struct sockaddr_un, sun_path) + (e - a->sockaddr.un.sun_path) + 1)
                                        return -EINVAL;
                        }
                }

                if (a->type != SOCK_STREAM && a->type != SOCK_DGRAM && a->type != SOCK_SEQPACKET)
                        return -EINVAL;

                return 0;

        case AF_NETLINK:

                if (a->size != sizeof(struct sockaddr_nl))
                        return -EINVAL;

                if (a->type != SOCK_RAW && a->type != SOCK_DGRAM)
                        return -EINVAL;

                return 0;

        default:
                return -EAFNOSUPPORT;
        }
}

int socket_address_print(const SocketAddress *a, char **ret) {
        int r;

        assert(a);
        assert(ret);

        r = socket_address_verify(a);
        if (r < 0)
                return r;

        if (socket_address_family(a) == AF_NETLINK) {
                _cleanup_free_ char *sfamily = NULL;

                r = netlink_family_to_string_alloc(a->protocol, &sfamily);
                if (r < 0)
                        return r;

                r = asprintf(ret, "%s %u", sfamily, a->sockaddr.nl.nl_groups);
                if (r < 0)
                        return -ENOMEM;

                return 0;
        }

        return sockaddr_pretty(&a->sockaddr.sa, a->size, false, ret);
}

bool socket_address_can_accept(const SocketAddress *a) {
        assert(a);

        return
                a->type == SOCK_STREAM ||
                a->type == SOCK_SEQPACKET;
}

bool socket_address_equal(const SocketAddress *a, const SocketAddress *b) {
        assert(a);
        assert(b);

        /* Invalid addresses are unequal to all */
        if (socket_address_verify(a) < 0 ||
            socket_address_verify(b) < 0)
                return false;

        if (a->type != b->type)
                return false;

        if (a->size != b->size)
                return false;

        if (socket_address_family(a) != socket_address_family(b))
                return false;

        switch (socket_address_family(a)) {

        case AF_INET:
                if (a->sockaddr.in.sin_addr.s_addr != b->sockaddr.in.sin_addr.s_addr)
                        return false;

                if (a->sockaddr.in.sin_port != b->sockaddr.in.sin_port)
                        return false;

                break;

        case AF_INET6:
                if (memcmp(&a->sockaddr.in6.sin6_addr, &b->sockaddr.in6.sin6_addr, sizeof(a->sockaddr.in6.sin6_addr)) != 0)
                        return false;

                if (a->sockaddr.in6.sin6_port != b->sockaddr.in6.sin6_port)
                        return false;

                break;

        case AF_UNIX:

                if ((a->sockaddr.un.sun_path[0] == 0) != (b->sockaddr.un.sun_path[0] == 0))
                        return false;

                if (a->sockaddr.un.sun_path[0]) {
                        if (!strneq(a->sockaddr.un.sun_path, b->sockaddr.un.sun_path, sizeof(a->sockaddr.un.sun_path)))
                                return false;
                } else {
                        if (memcmp(a->sockaddr.un.sun_path, b->sockaddr.un.sun_path, a->size) != 0)
                                return false;
                }

                break;

        case AF_NETLINK:

                if (a->protocol != b->protocol)
                        return false;

                if (a->sockaddr.nl.nl_groups != b->sockaddr.nl.nl_groups)
                        return false;

                break;

        default:
                /* Cannot compare, so we assume the addresses are different */
                return false;
        }

        return true;
}

bool socket_address_is(const SocketAddress *a, const char *s, int type) {
        struct SocketAddress b;

        assert(a);
        assert(s);

        if (socket_address_parse(&b, s) < 0)
                return false;

        b.type = type;

        return socket_address_equal(a, &b);
}

bool socket_address_is_netlink(const SocketAddress *a, const char *s) {
        struct SocketAddress b;

        assert(a);
        assert(s);

        if (socket_address_parse_netlink(&b, s) < 0)
                return false;

        return socket_address_equal(a, &b);
}

const char* socket_address_get_path(const SocketAddress *a) {
        assert(a);

        if (socket_address_family(a) != AF_UNIX)
                return NULL;

        if (a->sockaddr.un.sun_path[0] == 0)
                return NULL;

        return a->sockaddr.un.sun_path;
}

bool socket_ipv6_is_supported(void) {
        _cleanup_free_ char *l = NULL;

        if (access("/sys/module/ipv6", F_OK) != 0)
                return 0;

        /* If we can't check "disable" parameter, assume enabled */
        if (read_one_line_file("/sys/module/ipv6/parameters/disable", &l) < 0)
                return 1;

        /* If module was loaded with disable=1 no IPv6 available */
        return l[0] == '0';
}

bool socket_address_matches_fd(const SocketAddress *a, int fd) {
        union sockaddr_union sa;
        socklen_t salen = sizeof(sa), solen;
        int protocol, type;

        assert(a);
        assert(fd >= 0);

        if (getsockname(fd, &sa.sa, &salen) < 0)
                return false;

        if (sa.sa.sa_family != a->sockaddr.sa.sa_family)
                return false;

        solen = sizeof(type);
        if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &solen) < 0)
                return false;

        if (type != a->type)
                return false;

        if (a->protocol != 0)  {
                solen = sizeof(protocol);
                if (getsockopt(fd, SOL_SOCKET, SO_PROTOCOL, &protocol, &solen) < 0)
                        return false;

                if (protocol != a->protocol)
                        return false;
        }

        switch (sa.sa.sa_family) {

        case AF_INET:
                return sa.in.sin_port == a->sockaddr.in.sin_port &&
                        sa.in.sin_addr.s_addr == a->sockaddr.in.sin_addr.s_addr;

        case AF_INET6:
                return sa.in6.sin6_port == a->sockaddr.in6.sin6_port &&
                        memcmp(&sa.in6.sin6_addr, &a->sockaddr.in6.sin6_addr, sizeof(struct in6_addr)) == 0;

        case AF_UNIX:
                return salen == a->size &&
                        memcmp(sa.un.sun_path, a->sockaddr.un.sun_path, salen - offsetof(struct sockaddr_un, sun_path)) == 0;

        }

        return false;
}

int sockaddr_pretty(const struct sockaddr *_sa, socklen_t salen, bool translate_ipv6, char **ret) {
        union sockaddr_union *sa = (union sockaddr_union*) _sa;
        char *p;

        assert(sa);
        assert(salen >= sizeof(sa->sa.sa_family));

        switch (sa->sa.sa_family) {

        case AF_INET: {
                uint32_t a;

                a = ntohl(sa->in.sin_addr.s_addr);

                if (asprintf(&p,
                             "%u.%u.%u.%u:%u",
                             a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
                             ntohs(sa->in.sin_port)) < 0)
                        return -ENOMEM;

                break;
        }

        case AF_INET6: {
                static const unsigned char ipv4_prefix[] = {
                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
                };

                if (translate_ipv6 && memcmp(&sa->in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
                        const uint8_t *a = sa->in6.sin6_addr.s6_addr+12;

                        if (asprintf(&p,
                                     "%u.%u.%u.%u:%u",
                                     a[0], a[1], a[2], a[3],
                                     ntohs(sa->in6.sin6_port)) < 0)
                                return -ENOMEM;
                } else {
                        char a[INET6_ADDRSTRLEN];

                        if (asprintf(&p,
                                     "[%s]:%u",
                                     inet_ntop(AF_INET6, &sa->in6.sin6_addr, a, sizeof(a)),
                                     ntohs(sa->in6.sin6_port)) < 0)
                                return -ENOMEM;
                }

                break;
        }

        case AF_UNIX:
                if (salen <= offsetof(struct sockaddr_un, sun_path)) {
                        p = strdup("<unnamed>");
                        if (!p)
                                return -ENOMEM;

                } else if (sa->un.sun_path[0] == 0) {
                        /* abstract */

                        /* FIXME: We assume we can print the
                         * socket path here and that it hasn't
                         * more than one NUL byte. That is
                         * actually an invalid assumption */

                        p = new(char, sizeof(sa->un.sun_path)+1);
                        if (!p)
                                return -ENOMEM;

                        p[0] = '@';
                        memcpy(p+1, sa->un.sun_path+1, sizeof(sa->un.sun_path)-1);
                        p[sizeof(sa->un.sun_path)] = 0;

                } else {
                        p = strndup(sa->un.sun_path, sizeof(sa->un.sun_path));
                        if (!ret)
                                return -ENOMEM;
                }

                break;

        default:
                return -ENOTSUP;
        }


        *ret = p;
        return 0;
}

int getpeername_pretty(int fd, char **ret) {
        union sockaddr_union sa;
        socklen_t salen;
        int r;

        assert(fd >= 0);
        assert(ret);

        salen = sizeof(sa);
        if (getpeername(fd, &sa.sa, &salen) < 0)
                return -errno;

        if (sa.sa.sa_family == AF_UNIX) {
                struct ucred ucred = {};

                /* UNIX connection sockets are anonymous, so let's use
                 * PID/UID as pretty credentials instead */

                r = getpeercred(fd, &ucred);
                if (r < 0)
                        return r;

                if (asprintf(ret, "PID "PID_FMT"/UID "UID_FMT, ucred.pid, ucred.uid) < 0)
                        return -ENOMEM;

                return 0;
        }

        /* For remote sockets we translate IPv6 addresses back to IPv4
         * if applicable, since that's nicer. */

        return sockaddr_pretty(&sa.sa, salen, true, ret);
}

int getsockname_pretty(int fd, char **ret) {
        union sockaddr_union sa;
        socklen_t salen;

        assert(fd >= 0);
        assert(ret);

        salen = sizeof(sa);
        if (getsockname(fd, &sa.sa, &salen) < 0)
                return -errno;

        /* For local sockets we do not translate IPv6 addresses back
         * to IPv6 if applicable, since this is usually used for
         * listening sockets where the difference between IPv4 and
         * IPv6 matters. */

        return sockaddr_pretty(&sa.sa, salen, false, ret);
}

static const char* const netlink_family_table[] = {
        [NETLINK_ROUTE] = "route",
        [NETLINK_FIREWALL] = "firewall",
        [NETLINK_INET_DIAG] = "inet-diag",
        [NETLINK_NFLOG] = "nflog",
        [NETLINK_XFRM] = "xfrm",
        [NETLINK_SELINUX] = "selinux",
        [NETLINK_ISCSI] = "iscsi",
        [NETLINK_AUDIT] = "audit",
        [NETLINK_FIB_LOOKUP] = "fib-lookup",
        [NETLINK_CONNECTOR] = "connector",
        [NETLINK_NETFILTER] = "netfilter",
        [NETLINK_IP6_FW] = "ip6-fw",
        [NETLINK_DNRTMSG] = "dnrtmsg",
        [NETLINK_KOBJECT_UEVENT] = "kobject-uevent",
        [NETLINK_GENERIC] = "generic",
        [NETLINK_SCSITRANSPORT] = "scsitransport",
        [NETLINK_ECRYPTFS] = "ecryptfs"
};

DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(netlink_family, int, INT_MAX);

static const char* const socket_address_bind_ipv6_only_table[_SOCKET_ADDRESS_BIND_IPV6_ONLY_MAX] = {
        [SOCKET_ADDRESS_DEFAULT] = "default",
        [SOCKET_ADDRESS_BOTH] = "both",
        [SOCKET_ADDRESS_IPV6_ONLY] = "ipv6-only"
};

DEFINE_STRING_TABLE_LOOKUP(socket_address_bind_ipv6_only, SocketAddressBindIPv6Only);
Commit	Line	Data
	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2010 Lennart Poettering
	7
	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.
	12
	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.
	17
	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/>.
	20	***/
	21
	22	#include <assert.h>
	23	#include <string.h>
	24	#include <unistd.h>
	25	#include <errno.h>
	26	#include <stdlib.h>
	27	#include <arpa/inet.h>
	28	#include <stdio.h>
	29	#include <net/if.h>
	30	#include <sys/types.h>
	31	#include <sys/stat.h>
	32	#include <stddef.h>
	33	#include <sys/ioctl.h>
	34
	35	#include "macro.h"
	36	#include "util.h"
	37	#include "mkdir.h"
	38	#include "path-util.h"
	39	#include "socket-util.h"
	40	#include "missing.h"
	41	#include "fileio.h"
	42
	43	int socket_address_parse(SocketAddress a, const char s) {
	44	char e, n;
	45	unsigned u;
	46	int r;
	47
	48	assert(a);
	49	assert(s);
	50
	51	zero(*a);
	52	a->type = SOCK_STREAM;
	53
	54	if (*s == '[') {
	55	/* IPv6 in [x:.....:z]:p notation */
	56
	57	if (!socket_ipv6_is_supported()) {
	58	log_warning("Binding to IPv6 address not available since kernel does not support IPv6.");
	59	return -EAFNOSUPPORT;
	60	}
	61
	62	e = strchr(s+1, ']');
	63	if (!e)
	64	return -EINVAL;
	65
	66	n = strndupa(s+1, e-s-1);
	67
	68	errno = 0;
	69	if (inet_pton(AF_INET6, n, &a->sockaddr.in6.sin6_addr) <= 0)
	70	return errno > 0 ? -errno : -EINVAL;
	71
	72	e++;
	73	if (*e != ':')
	74	return -EINVAL;
	75
	76	e++;
	77	r = safe_atou(e, &u);
	78	if (r < 0)
	79	return r;
	80
	81	if (u <= 0 \|\| u > 0xFFFF)
	82	return -EINVAL;
	83
	84	a->sockaddr.in6.sin6_family = AF_INET6;
	85	a->sockaddr.in6.sin6_port = htons((uint16_t) u);
	86	a->size = sizeof(struct sockaddr_in6);
	87
	88	} else if (*s == '/') {
	89	/* AF_UNIX socket */
	90
	91	size_t l;
	92
	93	l = strlen(s);
	94	if (l >= sizeof(a->sockaddr.un.sun_path))
	95	return -EINVAL;
	96
	97	a->sockaddr.un.sun_family = AF_UNIX;
	98	memcpy(a->sockaddr.un.sun_path, s, l);
	99	a->size = offsetof(struct sockaddr_un, sun_path) + l + 1;
	100
	101	} else if (*s == '@') {
	102	/* Abstract AF_UNIX socket */
	103	size_t l;
	104
	105	l = strlen(s+1);
	106	if (l >= sizeof(a->sockaddr.un.sun_path) - 1)
	107	return -EINVAL;
	108
	109	a->sockaddr.un.sun_family = AF_UNIX;
	110	memcpy(a->sockaddr.un.sun_path+1, s+1, l);
	111	a->size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
	112
	113	} else {
	114	e = strchr(s, ':');
	115	if (e) {
	116	r = safe_atou(e+1, &u);
	117	if (r < 0)
	118	return r;
	119
	120	if (u <= 0 \|\| u > 0xFFFF)
	121	return -EINVAL;
	122
	123	n = strndupa(s, e-s);
	124
	125	/* IPv4 in w.x.y.z:p notation? */
	126	r = inet_pton(AF_INET, n, &a->sockaddr.in.sin_addr);
	127	if (r < 0)
	128	return -errno;
	129
	130	if (r > 0) {
	131	/* Gotcha, it's a traditional IPv4 address */
	132	a->sockaddr.in.sin_family = AF_INET;
	133	a->sockaddr.in.sin_port = htons((uint16_t) u);
	134	a->size = sizeof(struct sockaddr_in);
	135	} else {
	136	unsigned idx;
	137
	138	if (strlen(n) > IF_NAMESIZE-1)
	139	return -EINVAL;
	140
	141	/* Uh, our last resort, an interface name */
	142	idx = if_nametoindex(n);
	143	if (idx == 0)
	144	return -EINVAL;
	145
	146	if (!socket_ipv6_is_supported()) {
	147	log_warning("Binding to interface is not available since kernel does not support IPv6.");
	148	return -EAFNOSUPPORT;
	149	}
	150
	151	a->sockaddr.in6.sin6_family = AF_INET6;
	152	a->sockaddr.in6.sin6_port = htons((uint16_t) u);
	153	a->sockaddr.in6.sin6_scope_id = idx;
	154	a->sockaddr.in6.sin6_addr = in6addr_any;
	155	a->size = sizeof(struct sockaddr_in6);
	156	}
	157	} else {
	158
	159	/* Just a port */
	160	r = safe_atou(s, &u);
	161	if (r < 0)
	162	return r;
	163
	164	if (u <= 0 \|\| u > 0xFFFF)
	165	return -EINVAL;
	166
	167	if (socket_ipv6_is_supported()) {
	168	a->sockaddr.in6.sin6_family = AF_INET6;
	169	a->sockaddr.in6.sin6_port = htons((uint16_t) u);
	170	a->sockaddr.in6.sin6_addr = in6addr_any;
	171	a->size = sizeof(struct sockaddr_in6);
	172	} else {
	173	a->sockaddr.in.sin_family = AF_INET;
	174	a->sockaddr.in.sin_port = htons((uint16_t) u);
	175	a->sockaddr.in.sin_addr.s_addr = INADDR_ANY;
	176	a->size = sizeof(struct sockaddr_in);
	177	}
	178	}
	179	}
	180
	181	return 0;
	182	}
	183
	184	int socket_address_parse_netlink(SocketAddress a, const char s) {
	185	int family;
	186	unsigned group = 0;
	187	_cleanup_free_ char *sfamily = NULL;
	188	assert(a);
	189	assert(s);
	190
	191	zero(*a);
	192	a->type = SOCK_RAW;
	193
	194	errno = 0;
	195	if (sscanf(s, "%ms %u", &sfamily, &group) < 1)
	196	return errno > 0 ? -errno : -EINVAL;
	197
	198	family = netlink_family_from_string(sfamily);
	199	if (family < 0)
	200	return -EINVAL;
	201
	202	a->sockaddr.nl.nl_family = AF_NETLINK;
	203	a->sockaddr.nl.nl_groups = group;
	204
	205	a->type = SOCK_RAW;
	206	a->size = sizeof(struct sockaddr_nl);
	207	a->protocol = family;
	208
	209	return 0;
	210	}
	211
	212	int socket_address_verify(const SocketAddress *a) {
	213	assert(a);
	214
	215	switch (socket_address_family(a)) {
	216
	217	case AF_INET:
	218	if (a->size != sizeof(struct sockaddr_in))
	219	return -EINVAL;
	220
	221	if (a->sockaddr.in.sin_port == 0)
	222	return -EINVAL;
	223
	224	if (a->type != SOCK_STREAM && a->type != SOCK_DGRAM)
	225	return -EINVAL;
	226
	227	return 0;
	228
	229	case AF_INET6:
	230	if (a->size != sizeof(struct sockaddr_in6))
	231	return -EINVAL;
	232
	233	if (a->sockaddr.in6.sin6_port == 0)
	234	return -EINVAL;
	235
	236	if (a->type != SOCK_STREAM && a->type != SOCK_DGRAM)
	237	return -EINVAL;
	238
	239	return 0;
	240
	241	case AF_UNIX:
	242	if (a->size < offsetof(struct sockaddr_un, sun_path))
	243	return -EINVAL;
	244
	245	if (a->size > offsetof(struct sockaddr_un, sun_path)) {
	246
	247	if (a->sockaddr.un.sun_path[0] != 0) {
	248	char *e;
	249
	250	/* path */
	251	e = memchr(a->sockaddr.un.sun_path, 0, sizeof(a->sockaddr.un.sun_path));
	252	if (!e)
	253	return -EINVAL;
	254
	255	if (a->size != offsetof(struct sockaddr_un, sun_path) + (e - a->sockaddr.un.sun_path) + 1)
	256	return -EINVAL;
	257	}
	258	}
	259
	260	if (a->type != SOCK_STREAM && a->type != SOCK_DGRAM && a->type != SOCK_SEQPACKET)
	261	return -EINVAL;
	262
	263	return 0;
	264
	265	case AF_NETLINK:
	266
	267	if (a->size != sizeof(struct sockaddr_nl))
	268	return -EINVAL;
	269
	270	if (a->type != SOCK_RAW && a->type != SOCK_DGRAM)
	271	return -EINVAL;
	272
	273	return 0;
	274
	275	default:
	276	return -EAFNOSUPPORT;
	277	}
	278	}
	279
	280	int socket_address_print(const SocketAddress a, char *ret) {
	281	int r;
	282
	283	assert(a);
	284	assert(ret);
	285
	286	r = socket_address_verify(a);
	287	if (r < 0)
	288	return r;
	289
	290	if (socket_address_family(a) == AF_NETLINK) {
	291	_cleanup_free_ char *sfamily = NULL;
	292
	293	r = netlink_family_to_string_alloc(a->protocol, &sfamily);
	294	if (r < 0)
	295	return r;
	296
	297	r = asprintf(ret, "%s %u", sfamily, a->sockaddr.nl.nl_groups);
	298	if (r < 0)
	299	return -ENOMEM;
	300
	301	return 0;
	302	}
	303
	304	return sockaddr_pretty(&a->sockaddr.sa, a->size, false, ret);
	305	}
	306
	307	bool socket_address_can_accept(const SocketAddress *a) {
	308	assert(a);
	309
	310	return
	311	a->type == SOCK_STREAM \|\|
	312	a->type == SOCK_SEQPACKET;
	313	}
	314
	315	bool socket_address_equal(const SocketAddress a, const SocketAddress b) {
	316	assert(a);
	317	assert(b);
	318
	319	/* Invalid addresses are unequal to all */
	320	if (socket_address_verify(a) < 0 \|\|
	321	socket_address_verify(b) < 0)
	322	return false;
	323
	324	if (a->type != b->type)
	325	return false;
	326
	327	if (a->size != b->size)
	328	return false;
	329
	330	if (socket_address_family(a) != socket_address_family(b))
	331	return false;
	332
	333	switch (socket_address_family(a)) {
	334
	335	case AF_INET:
	336	if (a->sockaddr.in.sin_addr.s_addr != b->sockaddr.in.sin_addr.s_addr)
	337	return false;
	338
	339	if (a->sockaddr.in.sin_port != b->sockaddr.in.sin_port)
	340	return false;
	341
	342	break;
	343
	344	case AF_INET6:
	345	if (memcmp(&a->sockaddr.in6.sin6_addr, &b->sockaddr.in6.sin6_addr, sizeof(a->sockaddr.in6.sin6_addr)) != 0)
	346	return false;
	347
	348	if (a->sockaddr.in6.sin6_port != b->sockaddr.in6.sin6_port)
	349	return false;
	350
	351	break;
	352
	353	case AF_UNIX:
	354
	355	if ((a->sockaddr.un.sun_path[0] == 0) != (b->sockaddr.un.sun_path[0] == 0))
	356	return false;
	357
	358	if (a->sockaddr.un.sun_path[0]) {
	359	if (!strneq(a->sockaddr.un.sun_path, b->sockaddr.un.sun_path, sizeof(a->sockaddr.un.sun_path)))
	360	return false;
	361	} else {
	362	if (memcmp(a->sockaddr.un.sun_path, b->sockaddr.un.sun_path, a->size) != 0)
	363	return false;
	364	}
	365
	366	break;
	367
	368	case AF_NETLINK:
	369
	370	if (a->protocol != b->protocol)
	371	return false;
	372
	373	if (a->sockaddr.nl.nl_groups != b->sockaddr.nl.nl_groups)
	374	return false;
	375
	376	break;
	377
	378	default:
	379	/* Cannot compare, so we assume the addresses are different */
	380	return false;
	381	}
	382
	383	return true;
	384	}
	385
	386	bool socket_address_is(const SocketAddress a, const char s, int type) {
	387	struct SocketAddress b;
	388
	389	assert(a);
	390	assert(s);
	391
	392	if (socket_address_parse(&b, s) < 0)
	393	return false;
	394
	395	b.type = type;
	396
	397	return socket_address_equal(a, &b);
	398	}
	399
	400	bool socket_address_is_netlink(const SocketAddress a, const char s) {
	401	struct SocketAddress b;
	402
	403	assert(a);
	404	assert(s);
	405
	406	if (socket_address_parse_netlink(&b, s) < 0)
	407	return false;
	408
	409	return socket_address_equal(a, &b);
	410	}
	411
	412	const char* socket_address_get_path(const SocketAddress *a) {
	413	assert(a);
	414
	415	if (socket_address_family(a) != AF_UNIX)
	416	return NULL;
	417
	418	if (a->sockaddr.un.sun_path[0] == 0)
	419	return NULL;
	420
	421	return a->sockaddr.un.sun_path;
	422	}
	423
	424	bool socket_ipv6_is_supported(void) {
	425	_cleanup_free_ char *l = NULL;
	426
	427	if (access("/sys/module/ipv6", F_OK) != 0)
	428	return 0;
	429
	430	/* If we can't check "disable" parameter, assume enabled */
	431	if (read_one_line_file("/sys/module/ipv6/parameters/disable", &l) < 0)
	432	return 1;
	433
	434	/* If module was loaded with disable=1 no IPv6 available */
	435	return l[0] == '0';
	436	}
	437
	438	bool socket_address_matches_fd(const SocketAddress *a, int fd) {
	439	union sockaddr_union sa;
	440	socklen_t salen = sizeof(sa), solen;
	441	int protocol, type;
	442
	443	assert(a);
	444	assert(fd >= 0);
	445
	446	if (getsockname(fd, &sa.sa, &salen) < 0)
	447	return false;
	448
	449	if (sa.sa.sa_family != a->sockaddr.sa.sa_family)
	450	return false;
	451
	452	solen = sizeof(type);
	453	if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &solen) < 0)
	454	return false;
	455
	456	if (type != a->type)
	457	return false;
	458
	459	if (a->protocol != 0) {
	460	solen = sizeof(protocol);
	461	if (getsockopt(fd, SOL_SOCKET, SO_PROTOCOL, &protocol, &solen) < 0)
	462	return false;
	463
	464	if (protocol != a->protocol)
	465	return false;
	466	}
	467
	468	switch (sa.sa.sa_family) {
	469
	470	case AF_INET:
	471	return sa.in.sin_port == a->sockaddr.in.sin_port &&
	472	sa.in.sin_addr.s_addr == a->sockaddr.in.sin_addr.s_addr;
	473
	474	case AF_INET6:
	475	return sa.in6.sin6_port == a->sockaddr.in6.sin6_port &&
	476	memcmp(&sa.in6.sin6_addr, &a->sockaddr.in6.sin6_addr, sizeof(struct in6_addr)) == 0;
	477
	478	case AF_UNIX:
	479	return salen == a->size &&
	480	memcmp(sa.un.sun_path, a->sockaddr.un.sun_path, salen - offsetof(struct sockaddr_un, sun_path)) == 0;
	481
	482	}
	483
	484	return false;
	485	}
	486
	487	int sockaddr_pretty(const struct sockaddr _sa, socklen_t salen, bool translate_ipv6, char *ret) {
	488	union sockaddr_union sa = (union sockaddr_union) _sa;
	489	char *p;
	490
	491	assert(sa);
	492	assert(salen >= sizeof(sa->sa.sa_family));
	493
	494	switch (sa->sa.sa_family) {
	495
	496	case AF_INET: {
	497	uint32_t a;
	498
	499	a = ntohl(sa->in.sin_addr.s_addr);
	500
	501	if (asprintf(&p,
	502	"%u.%u.%u.%u:%u",
	503	a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
	504	ntohs(sa->in.sin_port)) < 0)
	505	return -ENOMEM;
	506
	507	break;
	508	}
	509
	510	case AF_INET6: {
	511	static const unsigned char ipv4_prefix[] = {
	512	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
	513	};
	514
	515	if (translate_ipv6 && memcmp(&sa->in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
	516	const uint8_t *a = sa->in6.sin6_addr.s6_addr+12;
	517
	518	if (asprintf(&p,
	519	"%u.%u.%u.%u:%u",
	520	a[0], a[1], a[2], a[3],
	521	ntohs(sa->in6.sin6_port)) < 0)
	522	return -ENOMEM;
	523	} else {
	524	char a[INET6_ADDRSTRLEN];
	525
	526	if (asprintf(&p,
	527	"[%s]:%u",
	528	inet_ntop(AF_INET6, &sa->in6.sin6_addr, a, sizeof(a)),
	529	ntohs(sa->in6.sin6_port)) < 0)
	530	return -ENOMEM;
	531	}
	532
	533	break;
	534	}
	535
	536	case AF_UNIX:
	537	if (salen <= offsetof(struct sockaddr_un, sun_path)) {
	538	p = strdup("<unnamed>");
	539	if (!p)
	540	return -ENOMEM;
	541
	542	} else if (sa->un.sun_path[0] == 0) {
	543	/* abstract */
	544
	545	/* FIXME: We assume we can print the
	546	* socket path here and that it hasn't
	547	* more than one NUL byte. That is
	548	* actually an invalid assumption */
	549
	550	p = new(char, sizeof(sa->un.sun_path)+1);
	551	if (!p)
	552	return -ENOMEM;
	553
	554	p[0] = '@';
	555	memcpy(p+1, sa->un.sun_path+1, sizeof(sa->un.sun_path)-1);
	556	p[sizeof(sa->un.sun_path)] = 0;
	557
	558	} else {
	559	p = strndup(sa->un.sun_path, sizeof(sa->un.sun_path));
	560	if (!ret)
	561	return -ENOMEM;
	562	}
	563
	564	break;
	565
	566	default:
	567	return -ENOTSUP;
	568	}
	569
	570
	571	*ret = p;
	572	return 0;
	573	}
	574
	575	int getpeername_pretty(int fd, char **ret) {
	576	union sockaddr_union sa;
	577	socklen_t salen;
	578	int r;
	579
	580	assert(fd >= 0);
	581	assert(ret);
	582
	583	salen = sizeof(sa);
	584	if (getpeername(fd, &sa.sa, &salen) < 0)
	585	return -errno;
	586
	587	if (sa.sa.sa_family == AF_UNIX) {
	588	struct ucred ucred = {};
	589
	590	/* UNIX connection sockets are anonymous, so let's use
	591	* PID/UID as pretty credentials instead */
	592
	593	r = getpeercred(fd, &ucred);
	594	if (r < 0)
	595	return r;
	596
	597	if (asprintf(ret, "PID "PID_FMT"/UID "UID_FMT, ucred.pid, ucred.uid) < 0)
	598	return -ENOMEM;
	599
	600	return 0;
	601	}
	602
	603	/* For remote sockets we translate IPv6 addresses back to IPv4
	604	* if applicable, since that's nicer. */
	605
	606	return sockaddr_pretty(&sa.sa, salen, true, ret);
	607	}
	608
	609	int getsockname_pretty(int fd, char **ret) {
	610	union sockaddr_union sa;
	611	socklen_t salen;
	612
	613	assert(fd >= 0);
	614	assert(ret);
	615
	616	salen = sizeof(sa);
	617	if (getsockname(fd, &sa.sa, &salen) < 0)
	618	return -errno;
	619
	620	/* For local sockets we do not translate IPv6 addresses back
	621	* to IPv6 if applicable, since this is usually used for
	622	* listening sockets where the difference between IPv4 and
	623	* IPv6 matters. */
	624
	625	return sockaddr_pretty(&sa.sa, salen, false, ret);
	626	}
	627
	628	static const char* const netlink_family_table[] = {
	629	[NETLINK_ROUTE] = "route",
	630	[NETLINK_FIREWALL] = "firewall",
	631	[NETLINK_INET_DIAG] = "inet-diag",
	632	[NETLINK_NFLOG] = "nflog",
	633	[NETLINK_XFRM] = "xfrm",
	634	[NETLINK_SELINUX] = "selinux",
	635	[NETLINK_ISCSI] = "iscsi",
	636	[NETLINK_AUDIT] = "audit",
	637	[NETLINK_FIB_LOOKUP] = "fib-lookup",
	638	[NETLINK_CONNECTOR] = "connector",
	639	[NETLINK_NETFILTER] = "netfilter",
	640	[NETLINK_IP6_FW] = "ip6-fw",
	641	[NETLINK_DNRTMSG] = "dnrtmsg",
	642	[NETLINK_KOBJECT_UEVENT] = "kobject-uevent",
	643	[NETLINK_GENERIC] = "generic",
	644	[NETLINK_SCSITRANSPORT] = "scsitransport",
	645	[NETLINK_ECRYPTFS] = "ecryptfs"
	646	};
	647
	648	DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(netlink_family, int, INT_MAX);
	649
	650	static const char* const socket_address_bind_ipv6_only_table[_SOCKET_ADDRESS_BIND_IPV6_ONLY_MAX] = {
	651	[SOCKET_ADDRESS_DEFAULT] = "default",
	652	[SOCKET_ADDRESS_BOTH] = "both",
	653	[SOCKET_ADDRESS_IPV6_ONLY] = "ipv6-only"
	654	};
	655
	656	DEFINE_STRING_TABLE_LOOKUP(socket_address_bind_ipv6_only, SocketAddressBindIPv6Only);