/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Directory lookup functions.  These are shims that translate from the API
 * into the RPC protocol.
 */

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <malloc.h>
#include <sys/types.h>
#include <netdb.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include "directory.h"
#include "directory_private.h"
#include <rpcsvc/idmap_prot.h>
#include "directory_library_impl.h"
#include "sized_array.h"

static directory_error_t copy_directory_attribute_value(
    directory_attribute_value_t *dav,
    directory_values_rpc *dav_rpc);
static directory_error_t copy_directory_entry(directory_entry_t *ent,
    directory_entry_rpc *ent_rpc);
static void directory_results_free(directory_results_rpc *dr);
static directory_datum_t directory_datum(void *data, size_t len);
static void directory_datum_free(directory_datum_t d);

/*
 * This is the actual implementation of the opaque directory_t structure.
 */
struct directory {
	CLIENT	*client;
};

/*
 * Set up a directory search context.
 */
directory_error_t
directory_open(directory_t *ret)
{
	directory_t d;
	directory_error_t de;
	char host[] = "localhost";

	*ret = NULL;

	d = calloc(1, sizeof (*d));
	if (d == NULL)
		goto nomem;

	d->client = clnt_door_create(IDMAP_PROG, IDMAP_V1, 0);
	if (d->client == NULL) {
		de = directory_error("clnt_create.directory_open",
		    "Error: %1",
		    clnt_spcreateerror(host),
		    NULL);
		goto err;
	}

	*ret = d;
	return (NULL);

nomem:
	de = directory_error("ENOMEM.directory_open",
	    "Insufficient memory setting up directory access", NULL);
err:
	directory_close(d);
	return (de);
}

/*
 * Tear down a directory search context.
 *
 * Does nothing if d==NULL.
 */
void
directory_close(directory_t d)
{
	if (d == NULL)
		return;

	if (d->client != NULL)
		clnt_destroy(d->client);

	free(d);
}

/*
 * Given a list of identifiers, a list of their types, and a list of attributes,
 * return the information.
 */
directory_error_t
directory_get_v(
    directory_t d,
    directory_entry_list_t *ret,
    char **ids,
    int nids,
    char *types,
    char **attr_list)
{
	int nattrs;
	directory_entry_list_t del;
	directory_error_t de;
	directory_results_rpc dr;
	idmap_utf8str_list sl_ids;
	idmap_utf8str_list sl_attrs;
	directory_entry_rpc *users;
	int i;
	enum clnt_stat cs;

	*ret = NULL;
	del = NULL;

	if (nids == 0) {
		for (nids = 0; ids[nids] != NULL; nids++)
			/* LOOP */;
	}

	for (nattrs = 0; attr_list[nattrs] != NULL; nattrs++)
		/* LOOP */;

	sl_ids.idmap_utf8str_list_len = nids;
	sl_ids.idmap_utf8str_list_val = ids;
	sl_attrs.idmap_utf8str_list_len = nattrs;
	sl_attrs.idmap_utf8str_list_val = attr_list;

	(void) memset(&dr, 0, sizeof (dr));
	cs = directory_get_common_1(sl_ids, types, sl_attrs, &dr, d->client);
	if (cs != RPC_SUCCESS) {
		char errbuf[100];	/* well long enough for any integer */
		(void) sprintf(errbuf, "%d", cs);
		de = directory_error("RPC.Get_common",
		    "Get_common RPC (%1)%2", errbuf,
		    clnt_sperror(d->client, ""), NULL);
		goto err;
	}

	if (dr.failed) {
		de = directory_error_from_rpc(
		    &dr.directory_results_rpc_u.err);
		goto err;
	}

	assert(dr.directory_results_rpc_u.entries.entries_len == nids);

	users = dr.directory_results_rpc_u.entries.entries_val;

	del = sized_array(nids, sizeof (directory_entry_t));

	for (i = 0; i < nids; i++) {
		de = copy_directory_entry(&del[i], &users[i]);
		if (de != NULL)
			goto err;
	}

	directory_results_free(&dr);

	*ret = del;
	return (NULL);

err:
	directory_results_free(&dr);
	directory_free(del);
	return (de);
}

/*
 * Free the results from a directory_get_*() request.
 */
void
directory_free(directory_entry_list_t del)
{
	directory_entry_t *ent;
	directory_attribute_value_t dav;
	int i;
	int j;
	int k;

	if (del == NULL)
		return;

	/* For each directory entry returned */
	for (i = 0; i < sized_array_n(del); i++) {
		ent = &del[i];

		if (ent->attrs != NULL) {
			/* For each attribute */
			for (j = 0; j < sized_array_n(ent->attrs); j++) {
				dav = ent->attrs[j];
				if (dav != NULL) {
					for (k = 0; k < sized_array_n(dav); k++)
						directory_datum_free(dav[k]);

					sized_array_free(dav);
				}
			}
			sized_array_free(ent->attrs);
		}

		directory_error_free(ent->err);
	}

	sized_array_free(del);
}

/*
 * Create a directory datum.  Note that we allocate an extra byte and
 * zero it, so that strings get null-terminated.  Return NULL on error.
 */
static
directory_datum_t
directory_datum(void *data, size_t len)
{
	void *p;

	p = sized_array(len + 1, 1);
	if (p == NULL)
		return (NULL);
	(void) memcpy(p, data, len);
	*((char *)p + len) = '\0';
	return (p);
}

/*
 * Return the size of a directory_datum_t.  Note that this does not include
 * the terminating \0, so it represents the value as returned by LDAP.
 */
size_t
directory_datum_len(directory_datum_t d)
{
	/*
	 * Deduct the terminal \0, so that binary data gets the
	 * expected length.
	 */
	return (sized_array_n(d) - 1);
}

static
void
directory_datum_free(directory_datum_t d)
{
	sized_array_free(d);
}

/*
 * Unmarshall an RPC directory entry into an API directory entry.
 */
static
directory_error_t
copy_directory_entry(
    directory_entry_t *ent,
    directory_entry_rpc *ent_rpc)
{
	int nattrs;
	int i;
	directory_error_t de;

	/* If the entry wasn't found, leave the entry attrs and err NULL. */
	if (ent_rpc->status == DIRECTORY_NOT_FOUND)
		return (NULL);

	if (ent_rpc->status == DIRECTORY_ERROR) {
		ent->err = directory_error_from_rpc(
		    &ent_rpc->directory_entry_rpc_u.err);
		return (NULL);
	}

	nattrs = ent_rpc->directory_entry_rpc_u.attrs.attrs_len;

	ent->attrs = sized_array(nattrs, sizeof (directory_attribute_value_t));
	if (ent->attrs == NULL) {
		return (directory_error("ENOMEM.copy_directory_entry",
		    "Insufficient memory copying directory entry", NULL));
	}
	for (i = 0; i < nattrs; i++) {
		de = copy_directory_attribute_value(&ent->attrs[i],
		    &ent_rpc->directory_entry_rpc_u.attrs.attrs_val[i]);
		if (de != NULL)
			return (de);
	}

	return (NULL);
}

/*
 * Unmarshall an RPC directory attribute value into the API equivalent.
 *
 * Note that on error some entries may have been copied, and so
 * the caller needs to clean up dav.  This is normally not a problem
 * since the caller will have called this function several times and
 * will need to clean up the results from the other calls too.
 */
static
directory_error_t
copy_directory_attribute_value(
    directory_attribute_value_t *dav,
    directory_values_rpc *dav_rpc)
{
	int i;
	int nvals;
	directory_value_rpc *vals;

	/* If it wasn't found, leave the corresponding entry NULL */
	if (!dav_rpc->found)
		return (NULL);

	nvals = dav_rpc->directory_values_rpc_u.values.values_len;
	*dav = sized_array(nvals + 1, sizeof (directory_datum_t));
	if (*dav == NULL) {
		return (directory_error("ENOMEM.copy_directory_attribute_value",
		    "Insufficient memory copying directory entry", NULL));
	}

	vals = dav_rpc->directory_values_rpc_u.values.values_val;
	for (i = 0; i < nvals; i++) {
		(*dav)[i] = directory_datum(vals[i].directory_value_rpc_val,
		    vals[i].directory_value_rpc_len);
		if ((*dav)[i] == NULL) {
			return (directory_error(
			    "ENOMEM.copy_directory_attribute_value",
			    "Insufficient memory copying directory entry",
			    NULL));
		}
	}

	return (NULL);
}

/*
 * Free the results of a directory RPC request.
 */
static
void
directory_results_free(directory_results_rpc *dr)
{
	xdr_free(xdr_directory_results_rpc, (char *)&dr);
}