libidmap/common/directory_helper.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Some helper routines for directory lookup.  These offer functions that
 * you could implement yourself on top of the generic routines, but since
 * they're a common request we implement them here.  (Well, OK, we cheat a bit
 * and call an internal routine to do the dirty work to reduce code
 * duplication, but you could still implement them using the generic routines.)
 */

#include <stdio.h>
#include <string.h>
#include <libuutil.h>
#include <rpcsvc/idmap_prot.h>
#include "directory.h"
#include "directory_private.h"
#include "directory_library_impl.h"
#include "sidutil.h"

/*
 * Given a username, return a text-form SID.
 *
 * The SID must be free()ed by the caller.
 *
 * d, if non-NULL, specifies an existing directory-search context.
 * If NULL, a temporary one will be created.
 */
directory_error_t
directory_sid_from_name_common(
    directory_t d,
    char *name,
    char *type,
    char **sid,
    uint64_t *classes)
{
	directory_t d1 = NULL;
	static char *attrs[] = {
		"objectSid",
		"objectClass",
		NULL,
	};
	directory_entry_t *ret_list = NULL;
	directory_error_t de;
	struct ret_sid {
		sid_t **objectSid;
		char **objectClass;
	} *ret_sid;

	/* Prep for error cases. */
	*sid = NULL;
	if (classes != NULL)
		*classes = 0;

	if (d == NULL) {
		de = directory_open(&d1);
		if (de != NULL)
			goto out;
	} else {
		d1 = d;
	}

	de = directory_get_v(d1, &ret_list, &name, 1, type, attrs);
	if (de != NULL)
		goto out;
	if (ret_list[0].err != NULL) {
		de = ret_list[0].err;
		ret_list[0].err = NULL;
		goto out;
	}

	ret_sid = (struct ret_sid *)ret_list[0].attrs;
	if (ret_sid == NULL)
		goto out;

	if (ret_sid->objectSid != NULL &&
	    ret_sid->objectSid[0] != NULL) {
		char text_sid[SID_STRSZ+1];
		sid_from_le(ret_sid->objectSid[0]);
		sid_tostr(ret_sid->objectSid[0], text_sid);
		*sid = strdup(text_sid);
		if (*sid == NULL)
			goto nomem;
	}

	if (ret_sid->objectClass != NULL &&
	    classes != NULL)
		*classes = class_bitmap(ret_sid->objectClass);

	goto out;

nomem:
	de = directory_error("ENOMEM.directory_sid_from_name_common",
	    "Insufficient memory retrieving data about SID", NULL);

out:
	directory_free(ret_list);
	if (d == NULL)
		directory_close(d1);
	return (de);
}

directory_error_t
directory_sid_from_name(
    directory_t d,
    char *name,
    char **sid,
    uint64_t *classes)
{
	return (directory_sid_from_name_common(d, name, DIRECTORY_ID_NAME, sid,
	    classes));
}

directory_error_t
directory_sid_from_user_name(directory_t d, char *name, char **sid)
{
	return (directory_sid_from_name_common(d, name, DIRECTORY_ID_USER, sid,
	    NULL));
}

directory_error_t
directory_sid_from_group_name(directory_t d, char *name, char **sid)
{
	return (directory_sid_from_name_common(d, name, DIRECTORY_ID_GROUP, sid,
	    NULL));
}

/*
 * Given a name or text-format SID, return a user@domain.
 *
 * The user@domain returned must be free()ed by the caller.
 *
 * Returns NULL and sets *name to NULL if no error occurred but the specified
 * entity does not exist.
 *
 * d, if non-NULL, specifies an existing directory-search context.
 * If NULL, a temporary one will be created.
 */
static
directory_error_t
directory_canon_common(
    directory_t d,
    char *id,
    char *id_type,
    char **canon,
    uint64_t *classes)
{
	directory_t d1 = NULL;
	directory_entry_t *ret_list = NULL;
	directory_error_t de;
	/*
	 * Attributes required to generate a canonical name, in named-list and
	 * structure form.
	 */
	static char *attrs[] = {
		"x-sun-canonicalName",
		"objectClass",
		NULL,
	};

	struct canon_name_ret {
		char **x_sun_canonicalName;
		char **objectClass;
	} *ret_name;

	/* Prep for error cases. */
	*canon = NULL;
	if (classes != NULL)
		*classes = 0;

	if (d == NULL) {
		de = directory_open(&d1);
		if (de != NULL)
			goto out;
	} else {
		d1 = d;
	}

	de = directory_get_v(d1, &ret_list, &id, 1, id_type, attrs);
	if (de != NULL)
		goto out;
	if (ret_list[0].err != NULL) {
		de = ret_list[0].err;
		ret_list[0].err = NULL;
		goto out;
	}

	ret_name = (struct canon_name_ret *)ret_list[0].attrs;
	if (ret_name == NULL)
		goto out;

	if (ret_name->x_sun_canonicalName != NULL &&
	    ret_name->x_sun_canonicalName[0] != NULL) {
		*canon = strdup(ret_name->x_sun_canonicalName[0]);
		if (*canon == NULL)
			goto nomem;
	}

	if (ret_name->objectClass != NULL &&
	    classes != NULL)
		*classes = class_bitmap(ret_name->objectClass);

	goto out;

nomem:
	de = directory_error("ENOMEM.directory_canon_common",
	    "Insufficient memory retrieving data about name", NULL);

out:
	directory_free(ret_list);
	if (d == NULL)
		directory_close(d1);
	return (de);
}

directory_error_t
directory_name_from_sid(
    directory_t d,
    char *sid,
    char **canon,
    uint64_t *classes)
{
	return (directory_canon_common(d, sid, DIRECTORY_ID_SID, canon,
	    classes));
}

directory_error_t
directory_canon_from_name(
    directory_t d,
    char *name,
    char **canon,
    uint64_t *classes)
{
	return (directory_canon_common(d, name, DIRECTORY_ID_NAME, canon,
	    classes));
}

directory_error_t
directory_canon_from_user_name(directory_t d, char *name, char **canon)
{
	return (
	    directory_canon_common(d, name, DIRECTORY_ID_USER, canon, NULL));
}

directory_error_t
directory_canon_from_group_name(directory_t d, char *name, char **canon)
{
	return (
	    directory_canon_common(d, name, DIRECTORY_ID_GROUP, canon, NULL));
}

boolean_t
is_in_list(char **list, char *val)
{
	for (; *list != NULL; list++) {
		if (uu_strcaseeq(*list, val))
			return (B_TRUE);
	}
	return (B_FALSE);
}

uint64_t
class_bitmap(char **objectClass)
{
	uint64_t ret = 0;

	for (; *objectClass != NULL; objectClass++) {
		if (uu_strcaseeq(*objectClass, "user") ||
		    uu_strcaseeq(*objectClass, "posixAccount"))
			ret |= DIRECTORY_CLASS_USER;

		if (uu_strcaseeq(*objectClass, "group") ||
		    uu_strcaseeq(*objectClass, "posixGroup"))
			ret |= DIRECTORY_CLASS_GROUP;
	}

	return (ret);
}