[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) {
        int r;
        char *e, *n;
        unsigned u;

        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;
                }

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

                if (!(n = strndup(s+1, e-s-1)))
                        return -ENOMEM;

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

                free(n);

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

                e++;
                if ((r = safe_atou(e, &u)) < 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 {

                if ((e = strchr(s, ':'))) {

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

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

                        if (!(n = strndup(s, e-s)))
                                return -ENOMEM;

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

                        if (r > 0) {
                                /* Gotcha, it's a traditional IPv4 address */
                                free(n);

                                a->sockaddr.in4.sin_family = AF_INET;
                                a->sockaddr.in4.sin_port = htons((uint16_t) u);
                                a->size = sizeof(struct sockaddr_in);
                        } else {
                                unsigned idx;

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

                                /* Uh, our last resort, an interface name */
                                idx = if_nametoindex(n);
                                free(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.in4.sin_family = AF_INET;
                                a->sockaddr.in4.sin_port = htons((uint16_t) u);
                                a->sockaddr.in4.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.in4.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 */
                                if (!(e = memchr(a->sockaddr.un.sun_path, 0, sizeof(a->sockaddr.un.sun_path))))
                                        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 **p) {
        int r;
        assert(a);
        assert(p);

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

        switch (socket_address_family(a)) {

        case AF_INET: {
                char *ret;

                ret = new(char, INET_ADDRSTRLEN+1+5+1);
                if (!ret)
                        return -ENOMEM;

                if (!inet_ntop(AF_INET, &a->sockaddr.in4.sin_addr, ret, INET_ADDRSTRLEN)) {
                        free(ret);
                        return -errno;
                }

                sprintf(strchr(ret, 0), ":%u", ntohs(a->sockaddr.in4.sin_port));
                *p = ret;
                return 0;
        }

        case AF_INET6: {
                char *ret;

                ret = new(char, 1+INET6_ADDRSTRLEN+2+5+1);
                if (!ret)
                        return -ENOMEM;

                ret[0] = '[';
                if (!inet_ntop(AF_INET6, &a->sockaddr.in6.sin6_addr, ret+1, INET6_ADDRSTRLEN)) {
                        free(ret);
                        return -errno;
                }

                sprintf(strchr(ret, 0), "]:%u", ntohs(a->sockaddr.in6.sin6_port));
                *p = ret;
                return 0;
        }

        case AF_UNIX: {
                char *ret;

                if (a->size <= offsetof(struct sockaddr_un, sun_path)) {
                        ret = strdup("<unnamed>");
                        if (!ret)
                                return -ENOMEM;

                } else if (a->sockaddr.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 */

                        ret = new(char, sizeof(a->sockaddr.un.sun_path)+1);
                        if (!ret)
                                return -ENOMEM;

                        ret[0] = '@';
                        memcpy(ret+1, a->sockaddr.un.sun_path+1, sizeof(a->sockaddr.un.sun_path)-1);
                        ret[sizeof(a->sockaddr.un.sun_path)] = 0;

                } else {
                        ret = strdup(a->sockaddr.un.sun_path);
                        if (!ret)
                                return -ENOMEM;
                }

                *p = ret;
                return 0;
        }

        case AF_NETLINK: {
                _cleanup_free_ char *sfamily = NULL;

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

                return 0;
        }

        default:
                return -EINVAL;
        }
}

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.in4.sin_addr.s_addr != b->sockaddr.in4.sin_addr.s_addr)
                        return false;

                if (a->sockaddr.in4.sin_port != b->sockaddr.in4.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) {
        char *l = 0;
        bool enabled;

        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 */
        enabled = l[0] == '0';
        free(l);

        return enabled;
}

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.in4.sin_port == a->sockaddr.in4.sin_port &&
                        sa.in4.sin_addr.s_addr == a->sockaddr.in4.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 getpeername_pretty(int fd, char **ret) {

        union {
                struct sockaddr sa;
                struct sockaddr_un un;
                struct sockaddr_in in;
                struct sockaddr_in6 in6;
                struct sockaddr_storage storage;
        } sa;

        socklen_t salen;
        char *p;

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

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

        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 (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: {
                struct ucred ucred;

                salen = sizeof(ucred);
                if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &salen) < 0)
                        return -errno;

                if (asprintf(&p, "PID %lu/UID %lu", (unsigned long) ucred.pid, (unsigned long) ucred.pid) < 0)
                        return -ENOMEM;

                break;
        }

        default:
                return -ENOTSUP;
        }

        *ret = p;
        return 0;
}

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