OpenSolaris_b135/lib/libidmap/common/directory_client.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 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);
}