[thirdparty/systemd.git] / src / nss-mymachines / nss-mymachines.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 <netdb.h>
#include <nss.h>

#include "sd-bus.h"
#include "sd-login.h"

#include "bus-common-errors.h"
#include "bus-util.h"
#include "hostname-util.h"
#include "in-addr-util.h"
#include "macro.h"
#include "nss-util.h"
#include "string-util.h"
#include "util.h"

NSS_GETHOSTBYNAME_PROTOTYPES(mymachines);
NSS_GETPW_PROTOTYPES(mymachines);
NSS_GETGR_PROTOTYPES(mymachines);

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

        assert(m);
        assert(ret);

        while ((r = sd_bus_message_enter_container(m, 'r', "iay")) > 0) {
                int family;

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

                r = sd_bus_message_skip(m, "ay");
                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_mymachines_gethostbyname4_r(
                const char *name,
                struct gaih_addrtuple **pat,
                char *buffer, size_t buflen,
                int *errnop, int *h_errnop,
                int32_t *ttlp) {

        struct gaih_addrtuple *r_tuple, *r_tuple_first = NULL;
        _cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
        _cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
        _cleanup_free_ int *ifindices = NULL;
        _cleanup_free_ char *class = NULL;
        size_t l, ms, idx;
        unsigned i = 0, c = 0;
        char *r_name;
        int n_ifindices, r;

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

        r = sd_machine_get_class(name, &class);
        if (r < 0)
                goto fail;
        if (!streq(class, "container")) {
                r = -ENOTTY;
                goto fail;
        }

        n_ifindices = sd_machine_get_ifindices(name, &ifindices);
        if (n_ifindices < 0) {
                r = n_ifindices;
                goto fail;
        }

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

        r = sd_bus_call_method(bus,
                               "org.freedesktop.machine1",
                               "/org/freedesktop/machine1",
                               "org.freedesktop.machine1.Manager",
                               "GetMachineAddresses",
                               NULL,
                               &reply,
                               "s", name);
        if (r < 0)
                goto fail;

        r = sd_bus_message_enter_container(reply, 'a', "(iay)");
        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', "iay")) > 0) {
                int family;
                const void *a;
                size_t sz;

                r = sd_bus_message_read(reply, "i", &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_exit_container(reply);
                if (r < 0)
                        goto fail;

                if (!IN_SET(family, AF_INET, AF_INET6)) {
                        r = -EAFNOSUPPORT;
                        goto fail;
                }

                if (sz != FAMILY_ADDRESS_SIZE(family)) {
                        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 = n_ifindices == 1 ? ifindices[0] : 0;
                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;

        /* Explicitly reset all error variables */
        *errnop = 0;
        *h_errnop = NETDB_SUCCESS;
        h_errno = 0;

        return NSS_STATUS_SUCCESS;

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

enum nss_status _nss_mymachines_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* reply = NULL;
        _cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
        _cleanup_free_ char *class = NULL;
        unsigned c = 0, i = 0;
        char *r_name, *r_aliases, *r_addr, *r_addr_list;
        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_machine_get_class(name, &class);
        if (r < 0)
                goto fail;
        if (!streq(class, "container")) {
                r = -ENOTTY;
                goto fail;
        }

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

        r = sd_bus_call_method(bus,
                               "org.freedesktop.machine1",
                               "/org/freedesktop/machine1",
                               "org.freedesktop.machine1.Manager",
                               "GetMachineAddresses",
                               NULL,
                               &reply,
                               "s", name);
        if (r < 0)
                goto fail;

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

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

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

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

        ms = ALIGN(l+1) + c * ALIGN(alen) + (c+2) * sizeof(char*);

        if (buflen < ms) {
                *errnop = ENOMEM;
                *h_errnop = NO_RECOVERY;
                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', "iay")) > 0) {
                int family;
                const void *a;
                size_t sz;

                r = sd_bus_message_read(reply, "i", &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_exit_container(reply);
                if (r < 0)
                        goto fail;

                if (family != af)
                        continue;

                if (sz != alen) {
                        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;

        /* Explicitly reset all error variables */
        *errnop = 0;
        *h_errnop = NETDB_SUCCESS;
        h_errno = 0;

        return NSS_STATUS_SUCCESS;

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

NSS_GETHOSTBYNAME_FALLBACKS(mymachines);

enum nss_status _nss_mymachines_getpwnam_r(
                const char *name,
                struct passwd *pwd,
                char *buffer, size_t buflen,
                int *errnop) {

        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
        _cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
        const char *p, *e, *machine;
        uint32_t mapped;
        uid_t uid;
        size_t l;
        int r;

        assert(name);
        assert(pwd);

        p = startswith(name, "vu-");
        if (!p)
                goto not_found;

        e = strrchr(p, '-');
        if (!e || e == p)
                goto not_found;

        r = parse_uid(e + 1, &uid);
        if (r < 0)
                goto not_found;

        machine = strndupa(p, e - p);
        if (!machine_name_is_valid(machine))
                goto not_found;

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

        r = sd_bus_call_method(bus,
                               "org.freedesktop.machine1",
                               "/org/freedesktop/machine1",
                               "org.freedesktop.machine1.Manager",
                               "MapFromMachineUser",
                               &error,
                               &reply,
                               "su",
                               machine, (uint32_t) uid);
        if (r < 0) {
                if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_USER_MAPPING))
                        goto not_found;

                goto fail;
        }

        r = sd_bus_message_read(reply, "u", &mapped);
        if (r < 0)
                goto fail;

        l = strlen(name);
        if (buflen < l+1) {
                *errnop = ENOMEM;
                return NSS_STATUS_TRYAGAIN;
        }

        memcpy(buffer, name, l+1);

        pwd->pw_name = buffer;
        pwd->pw_uid = mapped;
        pwd->pw_gid = 65534; /* nobody */
        pwd->pw_gecos = buffer;
        pwd->pw_passwd = (char*) "*"; /* locked */
        pwd->pw_dir = (char*) "/";
        pwd->pw_shell = (char*) "/sbin/nologin";

        *errnop = 0;
        return NSS_STATUS_SUCCESS;

not_found:
        *errnop = 0;
        return NSS_STATUS_NOTFOUND;

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

enum nss_status _nss_mymachines_getpwuid_r(
                uid_t uid,
                struct passwd *pwd,
                char *buffer, size_t buflen,
                int *errnop) {

        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
        _cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
        const char *machine, *object;
        uint32_t mapped;
        int r;

        if (!uid_is_valid(uid)) {
                r = -EINVAL;
                goto fail;
        }

        /* We consider all uids < 65536 host uids */
        if (uid < 0x10000)
                goto not_found;

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

        r = sd_bus_call_method(bus,
                               "org.freedesktop.machine1",
                               "/org/freedesktop/machine1",
                               "org.freedesktop.machine1.Manager",
                               "MapToMachineUser",
                               &error,
                               &reply,
                               "u",
                               (uint32_t) uid);
        if (r < 0) {
                if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_USER_MAPPING))
                        goto not_found;

                goto fail;
        }

        r = sd_bus_message_read(reply, "sou", &machine, &object, &mapped);
        if (r < 0)
                goto fail;

        if (snprintf(buffer, buflen, "vu-%s-" UID_FMT, machine, (uid_t) mapped) >= (int) buflen) {
                *errnop = ENOMEM;
                return NSS_STATUS_TRYAGAIN;
        }

        pwd->pw_name = buffer;
        pwd->pw_uid = uid;
        pwd->pw_gid = 65534; /* nobody */
        pwd->pw_gecos = buffer;
        pwd->pw_passwd = (char*) "*"; /* locked */
        pwd->pw_dir = (char*) "/";
        pwd->pw_shell = (char*) "/sbin/nologin";

        *errnop = 0;
        return NSS_STATUS_SUCCESS;

not_found:
        *errnop = 0;
        return NSS_STATUS_NOTFOUND;

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

enum nss_status _nss_mymachines_getgrnam_r(
                const char *name,
                struct group *gr,
                char *buffer, size_t buflen,
                int *errnop) {

        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
        _cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
        const char *p, *e, *machine;
        uint32_t mapped;
        uid_t gid;
        size_t l;
        int r;

        assert(name);
        assert(gr);

        p = startswith(name, "vg-");
        if (!p)
                goto not_found;

        e = strrchr(p, '-');
        if (!e || e == p)
                goto not_found;

        r = parse_gid(e + 1, &gid);
        if (r < 0)
                goto not_found;

        machine = strndupa(p, e - p);
        if (!machine_name_is_valid(machine))
                goto not_found;

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

        r = sd_bus_call_method(bus,
                               "org.freedesktop.machine1",
                               "/org/freedesktop/machine1",
                               "org.freedesktop.machine1.Manager",
                               "MapFromMachineGroup",
                               &error,
                               &reply,
                               "su",
                               machine, (uint32_t) gid);
        if (r < 0) {
                if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_GROUP_MAPPING))
                        goto not_found;

                goto fail;
        }

        r = sd_bus_message_read(reply, "u", &mapped);
        if (r < 0)
                goto fail;

        l = sizeof(char*) + strlen(name) + 1;
        if (buflen < l) {
                *errnop = ENOMEM;
                return NSS_STATUS_TRYAGAIN;
        }

        memzero(buffer, sizeof(char*));
        strcpy(buffer + sizeof(char*), name);

        gr->gr_name = buffer + sizeof(char*);
        gr->gr_gid = gid;
        gr->gr_passwd = (char*) "*"; /* locked */
        gr->gr_mem = (char**) buffer;

        *errnop = 0;
        return NSS_STATUS_SUCCESS;

not_found:
        *errnop = 0;
        return NSS_STATUS_NOTFOUND;

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

enum nss_status _nss_mymachines_getgrgid_r(
                gid_t gid,
                struct group *gr,
                char *buffer, size_t buflen,
                int *errnop) {

        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
        _cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
        const char *machine, *object;
        uint32_t mapped;
        int r;

        if (!gid_is_valid(gid)) {
                r = -EINVAL;
                goto fail;
        }

        /* We consider all gids < 65536 host gids */
        if (gid < 0x10000)
                goto not_found;

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

        r = sd_bus_call_method(bus,
                               "org.freedesktop.machine1",
                               "/org/freedesktop/machine1",
                               "org.freedesktop.machine1.Manager",
                               "MapToMachineGroup",
                               &error,
                               &reply,
                               "u",
                               (uint32_t) gid);
        if (r < 0) {
                if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_GROUP_MAPPING))
                        goto not_found;

                goto fail;
        }

        r = sd_bus_message_read(reply, "sou", &machine, &object, &mapped);
        if (r < 0)
                goto fail;

        if (buflen < sizeof(char*) + 1) {
                *errnop = ENOMEM;
                return NSS_STATUS_TRYAGAIN;
        }

        memzero(buffer, sizeof(char*));
        if (snprintf(buffer + sizeof(char*), buflen - sizeof(char*), "vg-%s-" GID_FMT, machine, (gid_t) mapped) >= (int) buflen) {
                *errnop = ENOMEM;
                return NSS_STATUS_TRYAGAIN;
        }

        gr->gr_name = buffer + sizeof(char*);
        gr->gr_gid = gid;
        gr->gr_passwd = (char*) "*"; /* locked */
        gr->gr_mem = (char**) buffer;

        *errnop = 0;
        return NSS_STATUS_SUCCESS;

not_found:
        *errnop = 0;
        return NSS_STATUS_NOTFOUND;

fail:
        *errnop = -r;
        return NSS_STATUS_UNAVAIL;
}
Commit	Line	Data
cabb0bc6 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
cabb0bc6	22	#include <netdb.h>
07630cea	23	#include <nss.h>
cabb0bc6 LP	24
	25	#include "sd-bus.h"
	26	#include "sd-login.h"
07630cea	27
c01ff965	28	#include "bus-common-errors.h"
07630cea	29	#include "bus-util.h"
25300b5a	30	#include "hostname-util.h"
07630cea LP	31	#include "in-addr-util.h"
	32	#include "macro.h"
	33	#include "nss-util.h"
	34	#include "string-util.h"
	35	#include "util.h"
cabb0bc6 LP	36
cabb0bc6 LP	37	NSS_GETHOSTBYNAME_PROTOTYPES(mymachines);
c01ff965 LP	38	NSS_GETPW_PROTOTYPES(mymachines);
c01ff965 LP	39	NSS_GETGR_PROTOTYPES(mymachines);
cabb0bc6	40
0dd25fb9	41	static int count_addresses(sd_bus_message m, int af, unsigned ret) {
cabb0bc6 LP	42	unsigned c = 0;
	43	int r;
	44
	45	assert(m);
	46	assert(ret);
	47
3a6fb33c	48	while ((r = sd_bus_message_enter_container(m, 'r', "iay")) > 0) {
0dd25fb9	49	int family;
cabb0bc6	50
0dd25fb9	51	r = sd_bus_message_read(m, "i", &family);
cabb0bc6 LP	52	if (r < 0)
	53	return r;
	54
	55	r = sd_bus_message_skip(m, "ay");
	56	if (r < 0)
	57	return r;
	58
	59	r = sd_bus_message_exit_container(m);
	60	if (r < 0)
	61	return r;
	62
	63	if (af != AF_UNSPEC && family != af)
	64	continue;
	65
	66	c ++;
	67	}
	68	if (r < 0)
	69	return r;
	70
	71	r = sd_bus_message_rewind(m, false);
	72	if (r < 0)
	73	return r;
	74
	75	*ret = c;
	76	return 0;
	77	}
	78
	79	enum nss_status _nss_mymachines_gethostbyname4_r(
	80	const char *name,
	81	struct gaih_addrtuple **pat,
	82	char *buffer, size_t buflen,
	83	int errnop, int h_errnop,
	84	int32_t *ttlp) {
	85
	86	struct gaih_addrtuple r_tuple, r_tuple_first = NULL;
	87	_cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
03976f7b	88	_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
634af566	89	_cleanup_free_ int *ifindices = NULL;
cabb0bc6 LP	90	_cleanup_free_ char *class = NULL;
	91	size_t l, ms, idx;
	92	unsigned i = 0, c = 0;
	93	char *r_name;
634af566	94	int n_ifindices, r;
cabb0bc6 LP	95
	96	assert(name);
	97	assert(pat);
	98	assert(buffer);
	99	assert(errnop);
	100	assert(h_errnop);
	101
	102	r = sd_machine_get_class(name, &class);
	103	if (r < 0)
	104	goto fail;
	105	if (!streq(class, "container")) {
	106	r = -ENOTTY;
	107	goto fail;
	108	}
	109
634af566 LP	110	n_ifindices = sd_machine_get_ifindices(name, &ifindices);
	111	if (n_ifindices < 0) {
	112	r = n_ifindices;
cabb0bc6 LP	113	goto fail;
	114	}
	115
	116	r = sd_bus_open_system(&bus);
	117	if (r < 0)
	118	goto fail;
	119
	120	r = sd_bus_call_method(bus,
	121	"org.freedesktop.machine1",
	122	"/org/freedesktop/machine1",
	123	"org.freedesktop.machine1.Manager",
	124	"GetMachineAddresses",
	125	NULL,
	126	&reply,
	127	"s", name);
	128	if (r < 0)
	129	goto fail;
	130
0dd25fb9	131	r = sd_bus_message_enter_container(reply, 'a', "(iay)");
cabb0bc6 LP	132	if (r < 0)
	133	goto fail;
	134
	135	r = count_addresses(reply, AF_UNSPEC, &c);
	136	if (r < 0)
	137	goto fail;
	138
	139	if (c <= 0) {
555bd6e9	140	*errnop = ESRCH;
cabb0bc6 LP	141	*h_errnop = HOST_NOT_FOUND;
	142	return NSS_STATUS_NOTFOUND;
	143	}
	144
	145	l = strlen(name);
	146	ms = ALIGN(l+1) + ALIGN(sizeof(struct gaih_addrtuple)) * c;
	147	if (buflen < ms) {
	148	*errnop = ENOMEM;
555bd6e9	149	*h_errnop = TRY_AGAIN;
cabb0bc6 LP	150	return NSS_STATUS_TRYAGAIN;
	151	}
	152
	153	/* First, append name */
	154	r_name = buffer;
	155	memcpy(r_name, name, l+1);
	156	idx = ALIGN(l+1);
	157
	158	/* Second, append addresses */
	159	r_tuple_first = (struct gaih_addrtuple*) (buffer + idx);
0dd25fb9 LP	160	while ((r = sd_bus_message_enter_container(reply, 'r', "iay")) > 0) {
0dd25fb9 LP	161	int family;
cabb0bc6 LP	162	const void *a;
	163	size_t sz;
	164
0dd25fb9	165	r = sd_bus_message_read(reply, "i", &family);
cabb0bc6 LP	166	if (r < 0)
	167	goto fail;
	168
	169	r = sd_bus_message_read_array(reply, 'y', &a, &sz);
	170	if (r < 0)
	171	goto fail;
	172
	173	r = sd_bus_message_exit_container(reply);
	174	if (r < 0)
	175	goto fail;
	176
555bd6e9 LP	177	if (!IN_SET(family, AF_INET, AF_INET6)) {
	178	r = -EAFNOSUPPORT;
	179	goto fail;
	180	}
	181
9d485985	182	if (sz != FAMILY_ADDRESS_SIZE(family)) {
cabb0bc6 LP	183	r = -EINVAL;
	184	goto fail;
	185	}
	186
	187	r_tuple = (struct gaih_addrtuple*) (buffer + idx);
	188	r_tuple->next = i == c-1 ? NULL : (struct gaih_addrtuple) ((char) r_tuple + ALIGN(sizeof(struct gaih_addrtuple)));
	189	r_tuple->name = r_name;
	190	r_tuple->family = family;
634af566	191	r_tuple->scopeid = n_ifindices == 1 ? ifindices[0] : 0;
cabb0bc6 LP	192	memcpy(r_tuple->addr, a, sz);
	193
	194	idx += ALIGN(sizeof(struct gaih_addrtuple));
	195	i++;
	196	}
	197
	198	assert(i == c);
	199
	200	r = sd_bus_message_exit_container(reply);
	201	if (r < 0)
	202	goto fail;
	203
	204	assert(idx == ms);
	205
	206	if (*pat)
	207	*pat = r_tuple_first;
	208	else
	209	*pat = r_tuple_first;
	210
	211	if (ttlp)
	212	*ttlp = 0;
	213
e70df46b LP	214	/* Explicitly reset all error variables */
	215	*errnop = 0;
	216	*h_errnop = NETDB_SUCCESS;
	217	h_errno = 0;
	218
cabb0bc6 LP	219	return NSS_STATUS_SUCCESS;
	220
	221	fail:
	222	*errnop = -r;
	223	*h_errnop = NO_DATA;
	224	return NSS_STATUS_UNAVAIL;
	225	}
	226
	227	enum nss_status _nss_mymachines_gethostbyname3_r(
	228	const char *name,
	229	int af,
	230	struct hostent *result,
	231	char *buffer, size_t buflen,
	232	int errnop, int h_errnop,
	233	int32_t *ttlp,
	234	char **canonp) {
	235
	236	_cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
03976f7b	237	_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
cabb0bc6 LP	238	_cleanup_free_ char *class = NULL;
	239	unsigned c = 0, i = 0;
	240	char r_name, r_aliases, r_addr, r_addr_list;
	241	size_t l, idx, ms, alen;
	242	int r;
	243
	244	assert(name);
	245	assert(result);
	246	assert(buffer);
	247	assert(errnop);
	248	assert(h_errnop);
	249
	250	if (af == AF_UNSPEC)
	251	af = AF_INET;
	252
	253	if (af != AF_INET && af != AF_INET6) {
	254	r = -EAFNOSUPPORT;
	255	goto fail;
	256	}
	257
	258	r = sd_machine_get_class(name, &class);
	259	if (r < 0)
	260	goto fail;
	261	if (!streq(class, "container")) {
	262	r = -ENOTTY;
	263	goto fail;
	264	}
	265
	266	r = sd_bus_open_system(&bus);
	267	if (r < 0)
	268	goto fail;
	269
	270	r = sd_bus_call_method(bus,
	271	"org.freedesktop.machine1",
	272	"/org/freedesktop/machine1",
	273	"org.freedesktop.machine1.Manager",
	274	"GetMachineAddresses",
	275	NULL,
	276	&reply,
	277	"s", name);
	278	if (r < 0)
	279	goto fail;
	280
0dd25fb9	281	r = sd_bus_message_enter_container(reply, 'a', "(iay)");
cabb0bc6 LP	282	if (r < 0)
	283	goto fail;
	284
	285	r = count_addresses(reply, af, &c);
	286	if (r < 0)
	287	goto fail;
	288
	289	if (c <= 0) {
	290	*errnop = ENOENT;
	291	*h_errnop = HOST_NOT_FOUND;
	292	return NSS_STATUS_NOTFOUND;
	293	}
	294
9d485985	295	alen = FAMILY_ADDRESS_SIZE(af);
cabb0bc6 LP	296	l = strlen(name);
cabb0bc6 LP	297
66a16e7e	298	ms = ALIGN(l+1) + c * ALIGN(alen) + (c+2) * sizeof(char*);
cabb0bc6 LP	299
	300	if (buflen < ms) {
	301	*errnop = ENOMEM;
	302	*h_errnop = NO_RECOVERY;
	303	return NSS_STATUS_TRYAGAIN;
	304	}
	305
	306	/* First, append name */
	307	r_name = buffer;
	308	memcpy(r_name, name, l+1);
	309	idx = ALIGN(l+1);
	310
	311	/* Second, create aliases array */
	312	r_aliases = buffer + idx;
	313	((char**) r_aliases)[0] = NULL;
	314	idx += sizeof(char*);
	315
	316	/* Third, append addresses */
	317	r_addr = buffer + idx;
0dd25fb9 LP	318	while ((r = sd_bus_message_enter_container(reply, 'r', "iay")) > 0) {
0dd25fb9 LP	319	int family;
cabb0bc6 LP	320	const void *a;
	321	size_t sz;
	322
0dd25fb9	323	r = sd_bus_message_read(reply, "i", &family);
cabb0bc6 LP	324	if (r < 0)
	325	goto fail;
	326
	327	r = sd_bus_message_read_array(reply, 'y', &a, &sz);
	328	if (r < 0)
	329	goto fail;
	330
	331	r = sd_bus_message_exit_container(reply);
	332	if (r < 0)
	333	goto fail;
	334
	335	if (family != af)
	336	continue;
	337
	338	if (sz != alen) {
	339	r = -EINVAL;
	340	goto fail;
	341	}
	342
	343	memcpy(r_addr + i*ALIGN(alen), a, alen);
	344	i++;
	345	}
	346
	347	assert(i == c);
	348	idx += c * ALIGN(alen);
	349
	350	r = sd_bus_message_exit_container(reply);
	351	if (r < 0)
	352	goto fail;
	353
	354	/* Third, append address pointer array */
	355	r_addr_list = buffer + idx;
	356	for (i = 0; i < c; i++)
	357	((char*) r_addr_list)[i] = r_addr + iALIGN(alen);
	358
	359	((char**) r_addr_list)[i] = NULL;
	360	idx += (c+1) * sizeof(char*);
	361
	362	assert(idx == ms);
	363
	364	result->h_name = r_name;
	365	result->h_aliases = (char**) r_aliases;
	366	result->h_addrtype = af;
	367	result->h_length = alen;
	368	result->h_addr_list = (char**) r_addr_list;
	369
	370	if (ttlp)
	371	*ttlp = 0;
	372
	373	if (canonp)
	374	*canonp = r_name;
	375
e70df46b LP	376	/* Explicitly reset all error variables */
	377	*errnop = 0;
	378	*h_errnop = NETDB_SUCCESS;
	379	h_errno = 0;
	380
cabb0bc6 LP	381	return NSS_STATUS_SUCCESS;
	382
	383	fail:
	384	*errnop = -r;
	385	*h_errnop = NO_DATA;
	386	return NSS_STATUS_UNAVAIL;
	387	}
	388
c01ff965 LP	389	NSS_GETHOSTBYNAME_FALLBACKS(mymachines);
	390
	391	enum nss_status _nss_mymachines_getpwnam_r(
	392	const char *name,
	393	struct passwd *pwd,
	394	char *buffer, size_t buflen,
	395	int *errnop) {
	396
	397	_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
	398	_cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
	399	_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
	400	const char p, e, *machine;
	401	uint32_t mapped;
	402	uid_t uid;
	403	size_t l;
	404	int r;
	405
	406	assert(name);
	407	assert(pwd);
	408
	409	p = startswith(name, "vu-");
	410	if (!p)
	411	goto not_found;
	412
	413	e = strrchr(p, '-');
	414	if (!e \|\| e == p)
	415	goto not_found;
	416
	417	r = parse_uid(e + 1, &uid);
	418	if (r < 0)
	419	goto not_found;
	420
	421	machine = strndupa(p, e - p);
	422	if (!machine_name_is_valid(machine))
	423	goto not_found;
	424
	425	r = sd_bus_open_system(&bus);
	426	if (r < 0)
	427	goto fail;
	428
	429	r = sd_bus_call_method(bus,
	430	"org.freedesktop.machine1",
	431	"/org/freedesktop/machine1",
	432	"org.freedesktop.machine1.Manager",
	433	"MapFromMachineUser",
	434	&error,
	435	&reply,
	436	"su",
	437	machine, (uint32_t) uid);
	438	if (r < 0) {
	439	if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_USER_MAPPING))
	440	goto not_found;
	441
	442	goto fail;
	443	}
	444
	445	r = sd_bus_message_read(reply, "u", &mapped);
	446	if (r < 0)
	447	goto fail;
	448
	449	l = strlen(name);
	450	if (buflen < l+1) {
	451	*errnop = ENOMEM;
	452	return NSS_STATUS_TRYAGAIN;
453	}
454
455	memcpy(buffer, name, l+1);
456
457	pwd->pw_name = buffer;
458	pwd->pw_uid = mapped;
459	pwd->pw_gid = 65534; /* nobody */
460	pwd->pw_gecos = buffer;
461	pwd->pw_passwd = (char) ""; /* locked */
462	pwd->pw_dir = (char*) "/";
463	pwd->pw_shell = (char*) "/sbin/nologin";
464
465	*errnop = 0;
466	return NSS_STATUS_SUCCESS;
467
468	not_found:
469	*errnop = 0;
470	return NSS_STATUS_NOTFOUND;
471
472	fail:
473	*errnop = -r;
474	return NSS_STATUS_UNAVAIL;
475	}
476
477	enum nss_status _nss_mymachines_getpwuid_r(
478	uid_t uid,
479	struct passwd *pwd,
480	char *buffer, size_t buflen,
481	int *errnop) {
482
483	_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
484	_cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
485	_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
486	const char machine, object;
487	uint32_t mapped;
488	int r;
489
c077529b	490	if (!uid_is_valid(uid)) {
c01ff965 LP	491	r = -EINVAL;
	492	goto fail;
	493	}
	494
	495	/* We consider all uids < 65536 host uids */
	496	if (uid < 0x10000)
	497	goto not_found;
	498
	499	r = sd_bus_open_system(&bus);
	500	if (r < 0)
	501	goto fail;
	502
	503	r = sd_bus_call_method(bus,
	504	"org.freedesktop.machine1",
	505	"/org/freedesktop/machine1",
	506	"org.freedesktop.machine1.Manager",
	507	"MapToMachineUser",
	508	&error,
	509	&reply,
	510	"u",
	511	(uint32_t) uid);
	512	if (r < 0) {
	513	if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_USER_MAPPING))
	514	goto not_found;
	515
	516	goto fail;
	517	}
	518
	519	r = sd_bus_message_read(reply, "sou", &machine, &object, &mapped);
	520	if (r < 0)
	521	goto fail;
	522
	523	if (snprintf(buffer, buflen, "vu-%s-" UID_FMT, machine, (uid_t) mapped) >= (int) buflen) {
	524	*errnop = ENOMEM;
	525	return NSS_STATUS_TRYAGAIN;
	526	}
	527
	528	pwd->pw_name = buffer;
	529	pwd->pw_uid = uid;
	530	pwd->pw_gid = 65534; /* nobody */
	531	pwd->pw_gecos = buffer;
	532	pwd->pw_passwd = (char) ""; /* locked */
	533	pwd->pw_dir = (char*) "/";
	534	pwd->pw_shell = (char*) "/sbin/nologin";
	535
	536	*errnop = 0;
	537	return NSS_STATUS_SUCCESS;
	538
	539	not_found:
	540	*errnop = 0;
	541	return NSS_STATUS_NOTFOUND;
	542
	543	fail:
	544	*errnop = -r;
	545	return NSS_STATUS_UNAVAIL;
	546	}
	547
	548	enum nss_status _nss_mymachines_getgrnam_r(
	549	const char *name,
	550	struct group *gr,
	551	char *buffer, size_t buflen,
	552	int *errnop) {
	553
	554	_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
555	_cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
556	_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
557	const char p, e, *machine;
558	uint32_t mapped;
559	uid_t gid;
560	size_t l;
561	int r;
562
563	assert(name);
564	assert(gr);
565
566	p = startswith(name, "vg-");
567	if (!p)
568	goto not_found;
569
570	e = strrchr(p, '-');
571	if (!e \|\| e == p)
572	goto not_found;
573
574	r = parse_gid(e + 1, &gid);
575	if (r < 0)
576	goto not_found;
577
578	machine = strndupa(p, e - p);
579	if (!machine_name_is_valid(machine))
580	goto not_found;
581
582	r = sd_bus_open_system(&bus);
583	if (r < 0)
584	goto fail;
585
586	r = sd_bus_call_method(bus,
587	"org.freedesktop.machine1",
588	"/org/freedesktop/machine1",
589	"org.freedesktop.machine1.Manager",
590	"MapFromMachineGroup",
591	&error,
592	&reply,
593	"su",
594	machine, (uint32_t) gid);
595	if (r < 0) {
596	if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_GROUP_MAPPING))
597	goto not_found;
598
599	goto fail;
600	}
601
602	r = sd_bus_message_read(reply, "u", &mapped);
603	if (r < 0)
604	goto fail;
605
606	l = sizeof(char*) + strlen(name) + 1;
607	if (buflen < l) {
608	*errnop = ENOMEM;
609	return NSS_STATUS_TRYAGAIN;
610	}
611
612	memzero(buffer, sizeof(char*));
613	strcpy(buffer + sizeof(char*), name);
614
615	gr->gr_name = buffer + sizeof(char*);
616	gr->gr_gid = gid;
617	gr->gr_passwd = (char) ""; /* locked */
618	gr->gr_mem = (char**) buffer;
619
620	*errnop = 0;
621	return NSS_STATUS_SUCCESS;
622
623	not_found:
624	*errnop = 0;
625	return NSS_STATUS_NOTFOUND;
626
627	fail:
628	*errnop = -r;
629	return NSS_STATUS_UNAVAIL;
630	}
631
632	enum nss_status _nss_mymachines_getgrgid_r(
633	gid_t gid,
634	struct group *gr,
635	char *buffer, size_t buflen,
636	int *errnop) {
637
638	_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
639	_cleanup_bus_message_unref_ sd_bus_message* reply = NULL;
640	_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
641	const char machine, object;
642	uint32_t mapped;
643	int r;
644
c077529b	645	if (!gid_is_valid(gid)) {
c01ff965 LP	646	r = -EINVAL;
	647	goto fail;
	648	}
	649
	650	/* We consider all gids < 65536 host gids */
	651	if (gid < 0x10000)
	652	goto not_found;
	653
	654	r = sd_bus_open_system(&bus);
	655	if (r < 0)
	656	goto fail;
	657
	658	r = sd_bus_call_method(bus,
	659	"org.freedesktop.machine1",
	660	"/org/freedesktop/machine1",
	661	"org.freedesktop.machine1.Manager",
	662	"MapToMachineGroup",
	663	&error,
	664	&reply,
	665	"u",
	666	(uint32_t) gid);
	667	if (r < 0) {
	668	if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_GROUP_MAPPING))
	669	goto not_found;
	670
	671	goto fail;
	672	}
	673
	674	r = sd_bus_message_read(reply, "sou", &machine, &object, &mapped);
	675	if (r < 0)
	676	goto fail;
	677
	678	if (buflen < sizeof(char*) + 1) {
	679	*errnop = ENOMEM;
	680	return NSS_STATUS_TRYAGAIN;
	681	}
	682
	683	memzero(buffer, sizeof(char*));
	684	if (snprintf(buffer + sizeof(char), buflen - sizeof(char), "vg-%s-" GID_FMT, machine, (gid_t) mapped) >= (int) buflen) {
	685	*errnop = ENOMEM;
	686	return NSS_STATUS_TRYAGAIN;
	687	}
	688
	689	gr->gr_name = buffer + sizeof(char*);
	690	gr->gr_gid = gid;
	691	gr->gr_passwd = (char) ""; /* locked */
	692	gr->gr_mem = (char**) buffer;
	693
	694	*errnop = 0;
	695	return NSS_STATUS_SUCCESS;
	696
	697	not_found:
	698	*errnop = 0;
	699	return NSS_STATUS_NOTFOUND;
	700
	701	fail:
	702	*errnop = -r;
	703	return NSS_STATUS_UNAVAIL;
	704	}