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

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

/***
  This file is part of systemd.

  Copyright 2014 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 <arpa/inet.h>

#include "in-addr-util.h"

int in_addr_null(int family, union in_addr_union *u) {
        assert(u);

        if (family == AF_INET)
                return u->in.s_addr == 0;

        if (family == AF_INET6)
                return
                        u->in6.s6_addr32[0] == 0 &&
                        u->in6.s6_addr32[1] == 0 &&
                        u->in6.s6_addr32[2] == 0 &&
                        u->in6.s6_addr32[3] == 0;

        return -EAFNOSUPPORT;
}


int in_addr_equal(int family, union in_addr_union *a, union in_addr_union *b) {
        assert(a);
        assert(b);

        if (family == AF_INET)
                return a->in.s_addr == b->in.s_addr;

        if (family == AF_INET6)
                return
                        a->in6.s6_addr32[0] == b->in6.s6_addr32[0] &&
                        a->in6.s6_addr32[1] == b->in6.s6_addr32[1] &&
                        a->in6.s6_addr32[2] == b->in6.s6_addr32[2] &&
                        a->in6.s6_addr32[3] == b->in6.s6_addr32[3];

        return -EAFNOSUPPORT;
}

int in_addr_prefix_intersect(
                int family,
                const union in_addr_union *a,
                unsigned aprefixlen,
                const union in_addr_union *b,
                unsigned bprefixlen) {

        unsigned m;

        assert(a);
        assert(b);

        /* Checks whether there are any addresses that are in both
         * networks */

        m = MIN(aprefixlen, bprefixlen);

        if (family == AF_INET) {
                uint32_t x, nm;

                x = be32toh(a->in.s_addr ^ b->in.s_addr);
                nm = (m == 0) ? 0 : 0xFFFFFFFFUL << (32 - m);

                return (x & nm) == 0;
        }

        if (family == AF_INET6) {
                unsigned i;

                if (m > 128)
                        m = 128;

                for (i = 0; i < 16; i++) {
                        uint8_t x, nm;

                        x = a->in6.s6_addr[i] ^ b->in6.s6_addr[i];

                        if (m < 8)
                                nm = 0xFF << (8 - m);
                        else
                                nm = 0xFF;

                        if ((x & nm) != 0)
                                return 0;

                        if (m > 8)
                                m -= 8;
                        else
                                m = 0;
                }

                return 1;
        }

        return -EAFNOSUPPORT;
}

int in_addr_prefix_next(int family, union in_addr_union *u, unsigned prefixlen) {
        assert(u);

        /* Increases the network part of an address by one. Returns
         * positive it that succeeds, or 0 if this overflows. */

        if (prefixlen <= 0)
                return 0;

        if (family == AF_INET) {
                uint32_t c, n;

                if (prefixlen > 32)
                        prefixlen = 32;

                c = be32toh(u->in.s_addr);
                n = c + (1UL << (32 - prefixlen));
                if (n < c)
                        return 0;
                n &= 0xFFFFFFFFUL << (32 - prefixlen);

                u->in.s_addr = htobe32(n);
                return 1;
        }

        if (family == AF_INET6) {
                struct in6_addr add = {}, result;
                uint8_t overflow = 0;
                unsigned i;

                if (prefixlen > 128)
                        prefixlen = 128;

                /* First calculate what we have to add */
                add.s6_addr[(prefixlen-1) / 8] = 1 << (7 - (prefixlen-1) % 8);

                for (i = 16; i > 0; i--) {
                        unsigned j = i - 1;

                        result.s6_addr[j] = u->in6.s6_addr[j] + add.s6_addr[j] + overflow;
                        overflow = (result.s6_addr[j] < u->in6.s6_addr[j]);
                }

                if (overflow)
                        return 0;

                u->in6 = result;
                return 1;
        }

        return -EAFNOSUPPORT;
}

int in_addr_to_string(int family, const union in_addr_union *u, char **ret) {
        char *x;
        size_t l;

        assert(u);
        assert(ret);

        if (family == AF_INET)
                l = INET_ADDRSTRLEN;
        else if (family == AF_INET6)
                l = INET6_ADDRSTRLEN;
        else
                return -EAFNOSUPPORT;

        x = new(char, l);
        if (!x)
                return -ENOMEM;

        errno = 0;
        if (!inet_ntop(family, u, x, l)) {
                free(x);
                return errno ? -errno : -EINVAL;
        }

        *ret = x;
        return 0;
}

int in_addr_from_string(int family, const char *s, union in_addr_union *ret) {

        assert(s);
        assert(ret);

        if (!IN_SET(family, AF_INET, AF_INET6))
                return -EAFNOSUPPORT;

        errno = 0;
        if (inet_pton(family, s, ret) <= 0)
                return errno ? -errno : -EINVAL;

        return 0;
}

int in_addr_from_string_auto(const char *s, int *family, union in_addr_union *ret) {
        int r;

        assert(s);
        assert(family);
        assert(ret);

        r = in_addr_from_string(AF_INET, s, ret);
        if (r >= 0) {
                *family = AF_INET;
                return 0;
        }

        r = in_addr_from_string(AF_INET6, s, ret);
        if (r >= 0) {
                *family = AF_INET6;
                return 0;
        }

        return -EINVAL;
}
Commit	Line	Data
3b653205 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2014 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 <arpa/inet.h>
	23
	24	#include "in-addr-util.h"
	25
0dd25fb9	26	int in_addr_null(int family, union in_addr_union *u) {
3b653205 LP	27	assert(u);
	28
	29	if (family == AF_INET)
	30	return u->in.s_addr == 0;
	31
	32	if (family == AF_INET6)
	33	return
	34	u->in6.s6_addr32[0] == 0 &&
	35	u->in6.s6_addr32[1] == 0 &&
	36	u->in6.s6_addr32[2] == 0 &&
	37	u->in6.s6_addr32[3] == 0;
	38
	39	return -EAFNOSUPPORT;
	40	}
	41
	42
0dd25fb9	43	int in_addr_equal(int family, union in_addr_union a, union in_addr_union b) {
3b653205 LP	44	assert(a);
	45	assert(b);
	46
	47	if (family == AF_INET)
	48	return a->in.s_addr == b->in.s_addr;
	49
	50	if (family == AF_INET6)
	51	return
	52	a->in6.s6_addr32[0] == b->in6.s6_addr32[0] &&
	53	a->in6.s6_addr32[1] == b->in6.s6_addr32[1] &&
	54	a->in6.s6_addr32[2] == b->in6.s6_addr32[2] &&
	55	a->in6.s6_addr32[3] == b->in6.s6_addr32[3];
	56
	57	return -EAFNOSUPPORT;
	58	}
	59
	60	int in_addr_prefix_intersect(
0dd25fb9	61	int family,
3b653205 LP	62	const union in_addr_union *a,
	63	unsigned aprefixlen,
	64	const union in_addr_union *b,
	65	unsigned bprefixlen) {
	66
	67	unsigned m;
	68
	69	assert(a);
	70	assert(b);
	71
	72	/* Checks whether there are any addresses that are in both
	73	* networks */
	74
	75	m = MIN(aprefixlen, bprefixlen);
	76
	77	if (family == AF_INET) {
	78	uint32_t x, nm;
	79
	80	x = be32toh(a->in.s_addr ^ b->in.s_addr);
	81	nm = (m == 0) ? 0 : 0xFFFFFFFFUL << (32 - m);
	82
	83	return (x & nm) == 0;
	84	}
	85
	86	if (family == AF_INET6) {
	87	unsigned i;
	88
	89	if (m > 128)
	90	m = 128;
	91
	92	for (i = 0; i < 16; i++) {
	93	uint8_t x, nm;
	94
	95	x = a->in6.s6_addr[i] ^ b->in6.s6_addr[i];
	96
	97	if (m < 8)
	98	nm = 0xFF << (8 - m);
	99	else
	100	nm = 0xFF;
	101
	102	if ((x & nm) != 0)
	103	return 0;
	104
	105	if (m > 8)
	106	m -= 8;
	107	else
	108	m = 0;
	109	}
	110
	111	return 1;
	112	}
	113
	114	return -EAFNOSUPPORT;
	115	}
	116
0dd25fb9	117	int in_addr_prefix_next(int family, union in_addr_union *u, unsigned prefixlen) {
3b653205 LP	118	assert(u);
	119
	120	/* Increases the network part of an address by one. Returns
	121	* positive it that succeeds, or 0 if this overflows. */
	122
	123	if (prefixlen <= 0)
	124	return 0;
	125
	126	if (family == AF_INET) {
	127	uint32_t c, n;
	128
	129	if (prefixlen > 32)
	130	prefixlen = 32;
	131
	132	c = be32toh(u->in.s_addr);
	133	n = c + (1UL << (32 - prefixlen));
	134	if (n < c)
	135	return 0;
	136	n &= 0xFFFFFFFFUL << (32 - prefixlen);
	137
	138	u->in.s_addr = htobe32(n);
	139	return 1;
	140	}
	141
	142	if (family == AF_INET6) {
	143	struct in6_addr add = {}, result;
	144	uint8_t overflow = 0;
	145	unsigned i;
	146
	147	if (prefixlen > 128)
	148	prefixlen = 128;
	149
	150	/* First calculate what we have to add */
	151	add.s6_addr[(prefixlen-1) / 8] = 1 << (7 - (prefixlen-1) % 8);
	152
	153	for (i = 16; i > 0; i--) {
	154	unsigned j = i - 1;
	155
	156	result.s6_addr[j] = u->in6.s6_addr[j] + add.s6_addr[j] + overflow;
	157	overflow = (result.s6_addr[j] < u->in6.s6_addr[j]);
	158	}
	159
	160	if (overflow)
	161	return 0;
	162
	163	u->in6 = result;
	164	return 1;
	165	}
	166
	167	return -EAFNOSUPPORT;
	168	}
	169
0dd25fb9	170	int in_addr_to_string(int family, const union in_addr_union u, char *ret) {
3b653205 LP	171	char *x;
	172	size_t l;
	173
	174	assert(u);
	175	assert(ret);
	176
	177	if (family == AF_INET)
	178	l = INET_ADDRSTRLEN;
	179	else if (family == AF_INET6)
	180	l = INET6_ADDRSTRLEN;
	181	else
	182	return -EAFNOSUPPORT;
	183
	184	x = new(char, l);
	185	if (!x)
	186	return -ENOMEM;
	187
	188	errno = 0;
	189	if (!inet_ntop(family, u, x, l)) {
	190	free(x);
	191	return errno ? -errno : -EINVAL;
	192	}
	193
	194	*ret = x;
	195	return 0;
	196	}
	197
0dd25fb9	198	int in_addr_from_string(int family, const char s, union in_addr_union ret) {
3b653205 LP	199
	200	assert(s);
	201	assert(ret);
	202
	203	if (!IN_SET(family, AF_INET, AF_INET6))
	204	return -EAFNOSUPPORT;
	205
	206	errno = 0;
	207	if (inet_pton(family, s, ret) <= 0)
	208	return errno ? -errno : -EINVAL;
	209
	210	return 0;
	211	}
74b2466e	212
0dd25fb9	213	int in_addr_from_string_auto(const char s, int family, union in_addr_union *ret) {
74b2466e LP	214	int r;
	215
	216	assert(s);
	217	assert(family);
	218	assert(ret);
	219
	220	r = in_addr_from_string(AF_INET, s, ret);
	221	if (r >= 0) {
	222	*family = AF_INET;
	223	return 0;
	224	}
	225
	226	r = in_addr_from_string(AF_INET6, s, ret);
	227	if (r >= 0) {
	228	*family = AF_INET6;
	229	return 0;
	230	}
	231
	232	return -EINVAL;
	233	}