[thirdparty/systemd.git] / src / nss-resolve / nss-resolve.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 <limits.h>
#include <nss.h>
#include <sys/types.h>
#include <netdb.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <net/if.h>
#include <stdlib.h>
#include <arpa/inet.h>

#include "sd-bus.h"
#include "bus-util.h"
#include "bus-errors.h"
#include "macro.h"
#include "nss-util.h"
#include "util.h"
#include "in-addr-util.h"

NSS_GETHOSTBYNAME_PROTOTYPES(resolve);
NSS_GETHOSTBYADDR_PROTOTYPES(resolve);

#define DNS_CALL_TIMEOUT_USEC (45*USEC_PER_SEC)

static int count_addresses(sd_bus_message *m, unsigned af, unsigned *ret) {
        unsigned c = 0;
        int r;

        assert(m);
        assert(ret);

        while ((r = sd_bus_message_enter_container(m, 'r', "yayi")) > 0) {
                unsigned char family;

                r = sd_bus_message_read(m, "y", &family);
                if (r < 0)
                        return r;

                r = sd_bus_message_skip(m, "ayi");
                if (r < 0)
                        return r;

                r = sd_bus_message_exit_container(m);
                if (r < 0)
                        return r;

                if (af != AF_UNSPEC && family != af)
                        continue;

                c ++;
        }
        if (r < 0)
                return r;

        r = sd_bus_message_rewind(m, false);
        if (r < 0)
                return r;

        *ret = c;
        return 0;
}

enum nss_status _nss_resolve_gethostbyname4_r(
                const char *name,
                struct gaih_addrtuple **pat,
                char *buffer, size_t buflen,
                int *errnop, int *h_errnop,
                int32_t *ttlp) {

        _cleanup_bus_message_unref_ sd_bus_message *req = NULL, *reply = NULL;
        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
        struct gaih_addrtuple *r_tuple, *r_tuple_first = NULL;
        _cleanup_bus_unref_ sd_bus *bus = NULL;
        size_t l, ms, idx;
        char *r_name;
        unsigned i = 0, c = 0;
        int r;

        assert(name);
        assert(pat);
        assert(buffer);
        assert(errnop);
        assert(h_errnop);

        r = sd_bus_open_system(&bus);
        if (r < 0)
                goto fail;

        r = sd_bus_message_new_method_call(
                        bus,
                        &req,
                        "org.freedesktop.resolve1",
                        "/org/freedesktop/resolve1",
                        "org.freedesktop.resolve1.Manager",
                        "ResolveHostname");
        if (r < 0)
                goto fail;

        r = sd_bus_message_set_auto_start(req, false);
        if (r < 0)
                goto fail;

        r = sd_bus_message_append(req, "sy", name, AF_UNSPEC);
        if (r < 0)
                goto fail;

        r = sd_bus_call(bus, req, DNS_CALL_TIMEOUT_USEC, &error, &reply);
        if (r < 0) {
                if (sd_bus_error_has_name(&error, _BUS_ERROR_DNS "NXDOMAIN")) {
                        *errnop = ESRCH;
                        *h_errnop = HOST_NOT_FOUND;
                        return NSS_STATUS_NOTFOUND;
                }

                *errnop = -r;
                *h_errnop = NO_RECOVERY;
                return NSS_STATUS_UNAVAIL;
        }

        r = sd_bus_message_enter_container(reply, 'a', "(yayi)");
        if (r < 0)
                goto fail;

        r = count_addresses(reply, AF_UNSPEC, &c);
        if (r < 0)
                goto fail;

        if (c <= 0) {
                *errnop = ESRCH;
                *h_errnop = HOST_NOT_FOUND;
                return NSS_STATUS_NOTFOUND;
        }

        l = strlen(name);
        ms = ALIGN(l+1) + ALIGN(sizeof(struct gaih_addrtuple)) * c;
        if (buflen < ms) {
                *errnop = ENOMEM;
                *h_errnop = TRY_AGAIN;
                return NSS_STATUS_TRYAGAIN;
        }

        /* First, append name */
        r_name = buffer;
        memcpy(r_name, name, l+1);
        idx = ALIGN(l+1);

        /* Second, append addresses */
        r_tuple_first = (struct gaih_addrtuple*) (buffer + idx);
        while ((r = sd_bus_message_enter_container(reply, 'r', "yayi")) > 0) {
                unsigned char family;
                const void *a;
                int ifindex;
                size_t sz;

                r = sd_bus_message_read(reply, "y", &family);
                if (r < 0)
                        goto fail;

                r = sd_bus_message_read_array(reply, 'y', &a, &sz);
                if (r < 0)
                        goto fail;

                r = sd_bus_message_read(reply, "i", &ifindex);
                if (r < 0)
                        goto fail;

                r = sd_bus_message_exit_container(reply);
                if (r < 0)
                        goto fail;

                if (!IN_SET(family, AF_INET, AF_INET6))
                        continue;

                if (sz != PROTO_ADDRESS_SIZE(family)) {
                        r = -EINVAL;
                        goto fail;
                }

                if (ifindex < 0) {
                        r = -EINVAL;
                        goto fail;
                }

                r_tuple = (struct gaih_addrtuple*) (buffer + idx);
                r_tuple->next = i == c-1 ? NULL : (struct gaih_addrtuple*) ((char*) r_tuple + ALIGN(sizeof(struct gaih_addrtuple)));
                r_tuple->name = r_name;
                r_tuple->family = family;
                r_tuple->scopeid = ifindex;
                memcpy(r_tuple->addr, a, sz);

                idx += ALIGN(sizeof(struct gaih_addrtuple));
                i++;
        }

        assert(i == c);

        r = sd_bus_message_exit_container(reply);
        if (r < 0)
                goto fail;

        assert(idx == ms);

        if (*pat)
                **pat = *r_tuple_first;
        else
                *pat = r_tuple_first;

        if (ttlp)
                *ttlp = 0;

        return NSS_STATUS_SUCCESS;

fail:
        *errnop = -r;
        *h_errnop = NO_DATA;
        return NSS_STATUS_UNAVAIL;
}

enum nss_status _nss_resolve_gethostbyname3_r(
                const char *name,
                int af,
                struct hostent *result,
                char *buffer, size_t buflen,
                int *errnop, int *h_errnop,
                int32_t *ttlp,
                char **canonp) {

        _cleanup_bus_message_unref_ sd_bus_message *req = NULL, *reply = NULL;
        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
        char *r_name, *r_aliases, *r_addr, *r_addr_list;
        _cleanup_bus_unref_ sd_bus *bus = NULL;
        unsigned c = 0, i = 0;
        size_t l, idx, ms, alen;
        int r;

        assert(name);
        assert(result);
        assert(buffer);
        assert(errnop);
        assert(h_errnop);

        if (af == AF_UNSPEC)
                af = AF_INET;

        if (af != AF_INET && af != AF_INET6) {
                r = -EAFNOSUPPORT;
                goto fail;
        }

        r = sd_bus_open_system(&bus);
        if (r < 0)
                goto fail;

        r = sd_bus_message_new_method_call(
                        bus,
                        &req,
                        "org.freedesktop.resolve1",
                        "/org/freedesktop/resolve1",
                        "org.freedesktop.resolve1.Manager",
                        "ResolveHostname");
        if (r < 0)
                goto fail;

        r = sd_bus_message_set_auto_start(req, false);
        if (r < 0)
                goto fail;

        r = sd_bus_message_append(req, "sy", name, af);
        if (r < 0)
                goto fail;

        r = sd_bus_call(bus, req, DNS_CALL_TIMEOUT_USEC, &error, &reply);
        if (r < 0) {
                if (sd_bus_error_has_name(&error, _BUS_ERROR_DNS "NXDOMAIN")) {
                        *errnop = ESRCH;
                        *h_errnop = HOST_NOT_FOUND;
                        return NSS_STATUS_NOTFOUND;
                }

                *errnop = -r;
                *h_errnop = NO_RECOVERY;
                return NSS_STATUS_UNAVAIL;
        }

        r = sd_bus_message_enter_container(reply, 'a', "(yayi)");
        if (r < 0)
                goto fail;

        r = count_addresses(reply, af, &c);
        if (r < 0)
                goto fail;

        if (c <= 0) {
                *errnop = ESRCH;
                *h_errnop = HOST_NOT_FOUND;
                return NSS_STATUS_NOTFOUND;
        }

        alen = PROTO_ADDRESS_SIZE(af);
        l = strlen(name);

        ms = ALIGN(l+1) +
                sizeof(char*) +
                (c > 0 ? c : 1) * ALIGN(alen) +
                (c > 0 ? c+1 : 2) * sizeof(char*);

        if (buflen < ms) {
                *errnop = ENOMEM;
                *h_errnop = TRY_AGAIN;
                return NSS_STATUS_TRYAGAIN;
        }

        /* First, append name */
        r_name = buffer;
        memcpy(r_name, name, l+1);
        idx = ALIGN(l+1);

        /* Second, create aliases array */
        r_aliases = buffer + idx;
        ((char**) r_aliases)[0] = NULL;
        idx += sizeof(char*);

        /* Third, append addresses */
        r_addr = buffer + idx;
        while ((r = sd_bus_message_enter_container(reply, 'r', "yayi")) > 0) {
                unsigned char family;
                const void *a;
                int ifindex;
                size_t sz;

                r = sd_bus_message_read(reply, "y", &family);
                if (r < 0)
                        goto fail;

                r = sd_bus_message_read_array(reply, 'y', &a, &sz);
                if (r < 0)
                        goto fail;

                r = sd_bus_message_read(reply, "i", &ifindex);
                if (r < 0)
                        goto fail;

                r = sd_bus_message_exit_container(reply);
                if (r < 0)
                        goto fail;

                if (family != af)
                        continue;

                if (sz != alen) {
                        r = -EINVAL;
                        goto fail;
                }

                if (ifindex < 0) {
                        r = -EINVAL;
                        goto fail;
                }

                memcpy(r_addr + i*ALIGN(alen), a, alen);
                i++;
        }

        assert(i == c);
        idx += c * ALIGN(alen);

        r = sd_bus_message_exit_container(reply);
        if (r < 0)
                goto fail;

        /* Third, append address pointer array */
        r_addr_list = buffer + idx;
        for (i = 0; i < c; i++)
                ((char**) r_addr_list)[i] = r_addr + i*ALIGN(alen);

        ((char**) r_addr_list)[i] = NULL;
        idx += (c+1) * sizeof(char*);

        assert(idx == ms);

        result->h_name = r_name;
        result->h_aliases = (char**) r_aliases;
        result->h_addrtype = af;
        result->h_length = alen;
        result->h_addr_list = (char**) r_addr_list;

        if (ttlp)
                *ttlp = 0;

        if (canonp)
                *canonp = r_name;

        return NSS_STATUS_SUCCESS;

fail:
        *errnop = -r;
        *h_errnop = NO_DATA;
        return NSS_STATUS_UNAVAIL;
}

enum nss_status _nss_resolve_gethostbyaddr2_r(
                const void* addr, socklen_t len,
                int af,
                struct hostent *result,
                char *buffer, size_t buflen,
                int *errnop, int *h_errnop,
                int32_t *ttlp) {

        _cleanup_bus_message_unref_ sd_bus_message *req = NULL, *reply = NULL;
        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
        char *r_name, *r_aliases, *r_addr, *r_addr_list;
        _cleanup_bus_unref_ sd_bus *bus = NULL;
        unsigned c = 0, i = 0;
        size_t ms = 0, idx;
        const char *n;
        int r;

        assert(addr);
        assert(result);
        assert(buffer);
        assert(errnop);
        assert(h_errnop);

        if (!IN_SET(af, AF_INET, AF_INET6)) {
                *errnop = EAFNOSUPPORT;
                *h_errnop = NO_DATA;
                return NSS_STATUS_UNAVAIL;
        }

        if (len != PROTO_ADDRESS_SIZE(af)) {
                *errnop = EINVAL;
                *h_errnop = NO_RECOVERY;
                return NSS_STATUS_UNAVAIL;
        }

        r = sd_bus_open_system(&bus);
        if (r < 0)
                goto fail;

        r = sd_bus_message_new_method_call(
                        bus,
                        &req,
                        "org.freedesktop.resolve1",
                        "/org/freedesktop/resolve1",
                        "org.freedesktop.resolve1.Manager",
                        "ResolveAddress");
        if (r < 0)
                goto fail;

        r = sd_bus_message_set_auto_start(req, false);
        if (r < 0)
                goto fail;

        r = sd_bus_message_append(req, "y", af);
        if (r < 0)
                goto fail;

        r = sd_bus_message_append_array(req, 'y', addr, len);
        if (r < 0)
                goto fail;

        r = sd_bus_message_append(req, "i", 0);
        if (r < 0)
                goto fail;

        r = sd_bus_call(bus, req, DNS_CALL_TIMEOUT_USEC, &error, &reply);
        if (r < 0) {
                if (sd_bus_error_has_name(&error, _BUS_ERROR_DNS "NXDOMAIN")) {
                        *errnop = ESRCH;
                        *h_errnop = HOST_NOT_FOUND;
                        return NSS_STATUS_NOTFOUND;
                }

                *errnop = -r;
                *h_errnop = NO_RECOVERY;
                return NSS_STATUS_UNAVAIL;
        }

        r = sd_bus_message_enter_container(reply, 'a', "s");
        if (r < 0)
                goto fail;

        while ((r = sd_bus_message_read(reply, "s", &n)) > 0) {
                c++;
                ms += ALIGN(strlen(n) + 1);
        }
        if (r < 0)
                goto fail;

        r = sd_bus_message_rewind(reply, false);
        if (r < 0)
                return r;

        if (c <= 0) {
                *errnop = ESRCH;
                *h_errnop = HOST_NOT_FOUND;
                return NSS_STATUS_NOTFOUND;
        }

        ms += ALIGN(len) +              /* the address */
              2 * sizeof(char*) +       /* pointers to the address, plus trailing NULL */
              c * sizeof(char*);        /* pointers to aliases, plus trailing NULL */

        if (buflen < ms) {
                *errnop = ENOMEM;
                *h_errnop = TRY_AGAIN;
                return NSS_STATUS_TRYAGAIN;
        }

        /* First, place address */
        r_addr = buffer;
        memcpy(r_addr, addr, len);
        idx = ALIGN(len);

        /* Second, place address list */
        r_addr_list = buffer + idx;
        ((char**) r_addr_list)[0] = r_addr;
        ((char**) r_addr_list)[1] = NULL;
        idx += sizeof(char*) * 2;

        /* Third, reserve space for the aliases array */
        r_aliases = buffer + idx;
        idx += sizeof(char*) * c;

        /* Fourth, place aliases */
        i = 0;
        r_name = buffer + idx;
        while ((r = sd_bus_message_read(reply, "s", &n)) > 0) {
                char *p;
                size_t l;

                l = strlen(n);
                p = buffer + idx;
                memcpy(p, n, l+1);

                if (i > 1)
                        ((char**) r_aliases)[i-1] = p;
                i++;

                idx += ALIGN(l+1);
        }

        ((char**) r_aliases)[c-1] = NULL;
        assert(idx == ms);

        result->h_name = r_name;
        result->h_aliases = (char**) r_aliases;
        result->h_addrtype = af;
        result->h_length = len;
        result->h_addr_list = (char**) r_addr_list;

        if (ttlp)
                *ttlp = 0;

        return NSS_STATUS_SUCCESS;

fail:
        *errnop = -r;
        *h_errnop = NO_DATA;
        return NSS_STATUS_UNAVAIL;
}

NSS_GETHOSTBYNAME_FALLBACKS(resolve);
NSS_GETHOSTBYADDR_FALLBACKS(resolve);
Commit	Line	Data
4d1cf1e2 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 <limits.h>
	23	#include <nss.h>
	24	#include <sys/types.h>
	25	#include <netdb.h>
	26	#include <errno.h>
	27	#include <string.h>
	28	#include <unistd.h>
	29	#include <net/if.h>
	30	#include <stdlib.h>
	31	#include <arpa/inet.h>
	32
	33	#include "sd-bus.h"
	34	#include "bus-util.h"
	35	#include "bus-errors.h"
	36	#include "macro.h"
	37	#include "nss-util.h"
	38	#include "util.h"
	39	#include "in-addr-util.h"
	40
	41	NSS_GETHOSTBYNAME_PROTOTYPES(resolve);
	42	NSS_GETHOSTBYADDR_PROTOTYPES(resolve);
	43
	44	#define DNS_CALL_TIMEOUT_USEC (45*USEC_PER_SEC)
	45
	46	static int count_addresses(sd_bus_message m, unsigned af, unsigned ret) {
	47	unsigned c = 0;
	48	int r;
	49
	50	assert(m);
	51	assert(ret);
	52
	53	while ((r = sd_bus_message_enter_container(m, 'r', "yayi")) > 0) {
	54	unsigned char family;
	55
	56	r = sd_bus_message_read(m, "y", &family);
	57	if (r < 0)
	58	return r;
	59
	60	r = sd_bus_message_skip(m, "ayi");
	61	if (r < 0)
	62	return r;
	63
	64	r = sd_bus_message_exit_container(m);
65	if (r < 0)
66	return r;
67
68	if (af != AF_UNSPEC && family != af)
69	continue;
70
71	c ++;
72	}
73	if (r < 0)
74	return r;
75
76	r = sd_bus_message_rewind(m, false);
77	if (r < 0)
78	return r;
79
80	*ret = c;
81	return 0;
82	}
83
84	enum nss_status _nss_resolve_gethostbyname4_r(
85	const char *name,
86	struct gaih_addrtuple **pat,
87	char *buffer, size_t buflen,
88	int errnop, int h_errnop,
89	int32_t *ttlp) {
90
91	_cleanup_bus_message_unref_ sd_bus_message req = NULL, reply = NULL;
92	_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
93	struct gaih_addrtuple r_tuple, r_tuple_first = NULL;
94	_cleanup_bus_unref_ sd_bus *bus = NULL;
95	size_t l, ms, idx;
96	char *r_name;
97	unsigned i = 0, c = 0;
98	int r;
99
100	assert(name);
101	assert(pat);
102	assert(buffer);
103	assert(errnop);
104	assert(h_errnop);
105
106	r = sd_bus_open_system(&bus);
107	if (r < 0)
108	goto fail;
109
110	r = sd_bus_message_new_method_call(
111	bus,
112	&req,
113	"org.freedesktop.resolve1",
114	"/org/freedesktop/resolve1",
115	"org.freedesktop.resolve1.Manager",
116	"ResolveHostname");
117	if (r < 0)
118	goto fail;
119
120	r = sd_bus_message_set_auto_start(req, false);
121	if (r < 0)
122	goto fail;
123
124	r = sd_bus_message_append(req, "sy", name, AF_UNSPEC);
125	if (r < 0)
126	goto fail;
127
128	r = sd_bus_call(bus, req, DNS_CALL_TIMEOUT_USEC, &error, &reply);
129	if (r < 0) {
130	if (sd_bus_error_has_name(&error, _BUS_ERROR_DNS "NXDOMAIN")) {
131	*errnop = ESRCH;
132	*h_errnop = HOST_NOT_FOUND;
133	return NSS_STATUS_NOTFOUND;
134	}
135
136	*errnop = -r;
137	*h_errnop = NO_RECOVERY;
138	return NSS_STATUS_UNAVAIL;
139	}
140
141	r = sd_bus_message_enter_container(reply, 'a', "(yayi)");
142	if (r < 0)
143	goto fail;
144
145	r = count_addresses(reply, AF_UNSPEC, &c);
146	if (r < 0)
147	goto fail;
148
149	if (c <= 0) {
150	*errnop = ESRCH;
151	*h_errnop = HOST_NOT_FOUND;
152	return NSS_STATUS_NOTFOUND;
153	}
154
155	l = strlen(name);
156	ms = ALIGN(l+1) + ALIGN(sizeof(struct gaih_addrtuple)) * c;
157	if (buflen < ms) {
158	*errnop = ENOMEM;
159	*h_errnop = TRY_AGAIN;
160	return NSS_STATUS_TRYAGAIN;
161	}
162
163	/* First, append name */
164	r_name = buffer;
165	memcpy(r_name, name, l+1);
166	idx = ALIGN(l+1);
167
168	/* Second, append addresses */
169	r_tuple_first = (struct gaih_addrtuple*) (buffer + idx);
170	while ((r = sd_bus_message_enter_container(reply, 'r', "yayi")) > 0) {
171	unsigned char family;
172	const void *a;
173	int ifindex;
174	size_t sz;
175
176	r = sd_bus_message_read(reply, "y", &family);
177	if (r < 0)
178	goto fail;
179
180	r = sd_bus_message_read_array(reply, 'y', &a, &sz);
181	if (r < 0)
182	goto fail;
183
184	r = sd_bus_message_read(reply, "i", &ifindex);
185	if (r < 0)
186	goto fail;
187
188	r = sd_bus_message_exit_container(reply);
189	if (r < 0)
190	goto fail;
191
192	if (!IN_SET(family, AF_INET, AF_INET6))
193	continue;
194
195	if (sz != PROTO_ADDRESS_SIZE(family)) {
196	r = -EINVAL;
197	goto fail;
198	}
199
200	if (ifindex < 0) {
201	r = -EINVAL;
202	goto fail;
203	}
204
205	r_tuple = (struct gaih_addrtuple*) (buffer + idx);
206	r_tuple->next = i == c-1 ? NULL : (struct gaih_addrtuple) ((char) r_tuple + ALIGN(sizeof(struct gaih_addrtuple)));
207	r_tuple->name = r_name;
208	r_tuple->family = family;
209	r_tuple->scopeid = ifindex;
210	memcpy(r_tuple->addr, a, sz);
211
212	idx += ALIGN(sizeof(struct gaih_addrtuple));
213	i++;
214	}
215
216	assert(i == c);
217
218	r = sd_bus_message_exit_container(reply);
219	if (r < 0)
220	goto fail;
221
222	assert(idx == ms);
223
224	if (*pat)
225	*pat = r_tuple_first;
226	else
227	*pat = r_tuple_first;
228
229	if (ttlp)
230	*ttlp = 0;
231
232	return NSS_STATUS_SUCCESS;
233
234	fail:
235	*errnop = -r;
236	*h_errnop = NO_DATA;
237	return NSS_STATUS_UNAVAIL;
238	}
239
240	enum nss_status _nss_resolve_gethostbyname3_r(
241	const char *name,
242	int af,
243	struct hostent *result,
244	char *buffer, size_t buflen,
245	int errnop, int h_errnop,
246	int32_t *ttlp,
247	char **canonp) {
248
249	_cleanup_bus_message_unref_ sd_bus_message req = NULL, reply = NULL;
250	_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
251	char r_name, r_aliases, r_addr, r_addr_list;
252	_cleanup_bus_unref_ sd_bus *bus = NULL;
253	unsigned c = 0, i = 0;
254	size_t l, idx, ms, alen;
255	int r;
256
257	assert(name);
258	assert(result);
259	assert(buffer);
260	assert(errnop);
261	assert(h_errnop);
262
263	if (af == AF_UNSPEC)
264	af = AF_INET;
265
266	if (af != AF_INET && af != AF_INET6) {
267	r = -EAFNOSUPPORT;
268	goto fail;
269	}
270
271	r = sd_bus_open_system(&bus);
272	if (r < 0)
273	goto fail;
274
275	r = sd_bus_message_new_method_call(
276	bus,
277	&req,
278	"org.freedesktop.resolve1",
279	"/org/freedesktop/resolve1",
280	"org.freedesktop.resolve1.Manager",
281	"ResolveHostname");
282	if (r < 0)
283	goto fail;
284
285	r = sd_bus_message_set_auto_start(req, false);
286	if (r < 0)
287	goto fail;
288
289	r = sd_bus_message_append(req, "sy", name, af);
290	if (r < 0)
291	goto fail;
292
293	r = sd_bus_call(bus, req, DNS_CALL_TIMEOUT_USEC, &error, &reply);
294	if (r < 0) {
295	if (sd_bus_error_has_name(&error, _BUS_ERROR_DNS "NXDOMAIN")) {
296	*errnop = ESRCH;
297	*h_errnop = HOST_NOT_FOUND;
298	return NSS_STATUS_NOTFOUND;
299	}
300
301	*errnop = -r;
302	*h_errnop = NO_RECOVERY;
303	return NSS_STATUS_UNAVAIL;
304	}
305
306	r = sd_bus_message_enter_container(reply, 'a', "(yayi)");
307	if (r < 0)
308	goto fail;
309
310	r = count_addresses(reply, af, &c);
311	if (r < 0)
312	goto fail;
313
314	if (c <= 0) {
315	*errnop = ESRCH;
316	*h_errnop = HOST_NOT_FOUND;
317	return NSS_STATUS_NOTFOUND;
318	}
319
320	alen = PROTO_ADDRESS_SIZE(af);
321	l = strlen(name);
322
323	ms = ALIGN(l+1) +
324	sizeof(char*) +
325	(c > 0 ? c : 1) * ALIGN(alen) +
326	(c > 0 ? c+1 : 2) * sizeof(char*);
327
328	if (buflen < ms) {
329	*errnop = ENOMEM;
330	*h_errnop = TRY_AGAIN;
331	return NSS_STATUS_TRYAGAIN;
332	}
333
334	/* First, append name */
335	r_name = buffer;
336	memcpy(r_name, name, l+1);
337	idx = ALIGN(l+1);
338
339	/* Second, create aliases array */
340	r_aliases = buffer + idx;
341	((char**) r_aliases)[0] = NULL;
342	idx += sizeof(char*);
343
344	/* Third, append addresses */
345	r_addr = buffer + idx;
346	while ((r = sd_bus_message_enter_container(reply, 'r', "yayi")) > 0) {
347	unsigned char family;
348	const void *a;
349	int ifindex;
350	size_t sz;
351
352	r = sd_bus_message_read(reply, "y", &family);
353	if (r < 0)
354	goto fail;
355
356	r = sd_bus_message_read_array(reply, 'y', &a, &sz);
357	if (r < 0)
358	goto fail;
359
360	r = sd_bus_message_read(reply, "i", &ifindex);
361	if (r < 0)
362	goto fail;
363
364	r = sd_bus_message_exit_container(reply);
365	if (r < 0)
366	goto fail;
367
368	if (family != af)
369	continue;
370
371	if (sz != alen) {
372	r = -EINVAL;
373	goto fail;
374	}
375
376	if (ifindex < 0) {
377	r = -EINVAL;
378	goto fail;
379	}
380
381	memcpy(r_addr + i*ALIGN(alen), a, alen);
382	i++;
383	}
384
385	assert(i == c);
386	idx += c * ALIGN(alen);
387
388	r = sd_bus_message_exit_container(reply);
389	if (r < 0)
390	goto fail;
391
392	/* Third, append address pointer array */
393	r_addr_list = buffer + idx;
394	for (i = 0; i < c; i++)
395	((char*) r_addr_list)[i] = r_addr + iALIGN(alen);
396
397	((char**) r_addr_list)[i] = NULL;
398	idx += (c+1) * sizeof(char*);
399
400	assert(idx == ms);
401
402	result->h_name = r_name;
403	result->h_aliases = (char**) r_aliases;
404	result->h_addrtype = af;
405	result->h_length = alen;
406	result->h_addr_list = (char**) r_addr_list;
407
408	if (ttlp)
409	*ttlp = 0;
410
411	if (canonp)
412	*canonp = r_name;
413
414	return NSS_STATUS_SUCCESS;
415
416	fail:
417	*errnop = -r;
418	*h_errnop = NO_DATA;
419	return NSS_STATUS_UNAVAIL;
420	}
421
422	enum nss_status _nss_resolve_gethostbyaddr2_r(
423	const void* addr, socklen_t len,
424	int af,
425	struct hostent *result,
426	char *buffer, size_t buflen,
427	int errnop, int h_errnop,
428	int32_t *ttlp) {
429
430	_cleanup_bus_message_unref_ sd_bus_message req = NULL, reply = NULL;
431	_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
432	char r_name, r_aliases, r_addr, r_addr_list;
433	_cleanup_bus_unref_ sd_bus *bus = NULL;
434	unsigned c = 0, i = 0;
435	size_t ms = 0, idx;
436	const char *n;
437	int r;
438
439	assert(addr);
440	assert(result);
441	assert(buffer);
442	assert(errnop);
443	assert(h_errnop);
444
445	if (!IN_SET(af, AF_INET, AF_INET6)) {
446	*errnop = EAFNOSUPPORT;
447	*h_errnop = NO_DATA;
448	return NSS_STATUS_UNAVAIL;
449	}
450
451	if (len != PROTO_ADDRESS_SIZE(af)) {
452	*errnop = EINVAL;
453	*h_errnop = NO_RECOVERY;
454	return NSS_STATUS_UNAVAIL;
455	}
456
457	r = sd_bus_open_system(&bus);
458	if (r < 0)
459	goto fail;
460
461	r = sd_bus_message_new_method_call(
462	bus,
463	&req,
464	"org.freedesktop.resolve1",
465	"/org/freedesktop/resolve1",
466	"org.freedesktop.resolve1.Manager",
467	"ResolveAddress");
468	if (r < 0)
469	goto fail;
470
471	r = sd_bus_message_set_auto_start(req, false);
472	if (r < 0)
473	goto fail;
474
475	r = sd_bus_message_append(req, "y", af);
476	if (r < 0)
477	goto fail;
478
479	r = sd_bus_message_append_array(req, 'y', addr, len);
480	if (r < 0)
481	goto fail;
482
483	r = sd_bus_message_append(req, "i", 0);
484	if (r < 0)
485	goto fail;
486
487	r = sd_bus_call(bus, req, DNS_CALL_TIMEOUT_USEC, &error, &reply);
488	if (r < 0) {
489	if (sd_bus_error_has_name(&error, _BUS_ERROR_DNS "NXDOMAIN")) {
490	*errnop = ESRCH;
491	*h_errnop = HOST_NOT_FOUND;
492	return NSS_STATUS_NOTFOUND;
493	}
494
495	*errnop = -r;
496	*h_errnop = NO_RECOVERY;
497	return NSS_STATUS_UNAVAIL;
498	}
499
500	r = sd_bus_message_enter_container(reply, 'a', "s");
501	if (r < 0)
502	goto fail;
503
504	while ((r = sd_bus_message_read(reply, "s", &n)) > 0) {
505	c++;
506	ms += ALIGN(strlen(n) + 1);
507	}
508	if (r < 0)
509	goto fail;
510
511	r = sd_bus_message_rewind(reply, false);
512	if (r < 0)
513	return r;
514
515	if (c <= 0) {
516	*errnop = ESRCH;
517	*h_errnop = HOST_NOT_FOUND;
518	return NSS_STATUS_NOTFOUND;
519	}
520
521	ms += ALIGN(len) + /* the address */
522	2 * sizeof(char) + / pointers to the address, plus trailing NULL */
523	c * sizeof(char); / pointers to aliases, plus trailing NULL */
524
525	if (buflen < ms) {
526	*errnop = ENOMEM;
527	*h_errnop = TRY_AGAIN;
528	return NSS_STATUS_TRYAGAIN;
529	}
530
531	/* First, place address */
532	r_addr = buffer;
533	memcpy(r_addr, addr, len);
534	idx = ALIGN(len);
535
536	/* Second, place address list */
537	r_addr_list = buffer + idx;
538	((char**) r_addr_list)[0] = r_addr;
539	((char**) r_addr_list)[1] = NULL;
540	idx += sizeof(char) 2;
541
542	/* Third, reserve space for the aliases array */
543	r_aliases = buffer + idx;
544	idx += sizeof(char) c;
545
546	/* Fourth, place aliases */
547	i = 0;
548	r_name = buffer + idx;
549	while ((r = sd_bus_message_read(reply, "s", &n)) > 0) {
550	char *p;
551	size_t l;
552
553	l = strlen(n);
554	p = buffer + idx;
555	memcpy(p, n, l+1);
556
557	if (i > 1)
558	((char**) r_aliases)[i-1] = p;
559	i++;
560
561	idx += ALIGN(l+1);
562	}
563
564	((char**) r_aliases)[c-1] = NULL;
565	assert(idx == ms);
566
567	result->h_name = r_name;
568	result->h_aliases = (char**) r_aliases;
569	result->h_addrtype = af;
570	result->h_length = len;
571	result->h_addr_list = (char**) r_addr_list;
572
573	if (ttlp)
574	*ttlp = 0;
575
576	return NSS_STATUS_SUCCESS;
577
578	fail:
579	*errnop = -r;
580	*h_errnop = NO_DATA;
581	return NSS_STATUS_UNAVAIL;
582	}
583
584	NSS_GETHOSTBYNAME_FALLBACKS(resolve);
585	NSS_GETHOSTBYADDR_FALLBACKS(resolve);