libidmap/common/utils.c

	utils.c revision 4edd44c51fec55142bfb7fb1ee7aaa13a910a80f
/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * Utility routines
 */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <libintl.h>
#include "idmap_impl.h"

#define _UDT_SIZE_INCR  1

#define _GET_IDS_SIZE_INCR  1

static struct timeval TIMEOUT = { 25, 0 };

idmap_retcode
_udt_extend_batch(idmap_udt_handle_t *udthandle)
{
    idmap_update_op *tmplist;
    size_t      nsize;

    if (udthandle->next >= udthandle->batch.idmap_update_batch_len) {
        nsize = (udthandle->batch.idmap_update_batch_len +
            _UDT_SIZE_INCR) * sizeof (*tmplist);
        tmplist = realloc(
            udthandle->batch.idmap_update_batch_val, nsize);
        if (tmplist == NULL)
            return (IDMAP_ERR_MEMORY);
        (void) memset((uchar_t *)tmplist +
            (udthandle->batch.idmap_update_batch_len *
            sizeof (*tmplist)), 0,
            _UDT_SIZE_INCR * sizeof (*tmplist));
        udthandle->batch.idmap_update_batch_val = tmplist;
        udthandle->batch.idmap_update_batch_len += _UDT_SIZE_INCR;
    }
    udthandle->batch.idmap_update_batch_val[udthandle->next].opnum =
        OP_NONE;
    return (IDMAP_SUCCESS);
}

idmap_retcode
_get_ids_extend_batch(idmap_get_handle_t *gh)
{
    idmap_mapping   *t1;
    idmap_get_res_t *t2;
    size_t      nsize, len;

    len = gh->batch.idmap_mapping_batch_len;
    if (gh->next >= len) {
        /* extend the request array */
        nsize = (len + _GET_IDS_SIZE_INCR) * sizeof (*t1);
        t1 = realloc(gh->batch.idmap_mapping_batch_val, nsize);
        if (t1 == NULL)
            return (IDMAP_ERR_MEMORY);
        (void) memset((uchar_t *)t1 + (len * sizeof (*t1)), 0,
            _GET_IDS_SIZE_INCR * sizeof (*t1));
        gh->batch.idmap_mapping_batch_val = t1;

        /* extend the return list */
        nsize = (len + _GET_IDS_SIZE_INCR) * sizeof (*t2);
        t2 = realloc(gh->retlist, nsize);
        if (t2 == NULL)
            return (IDMAP_ERR_MEMORY);
        (void) memset((uchar_t *)t2 + (len * sizeof (*t2)), 0,
            _GET_IDS_SIZE_INCR * sizeof (*t2));
        gh->retlist = t2;

        gh->batch.idmap_mapping_batch_len += _GET_IDS_SIZE_INCR;
    }
    return (IDMAP_SUCCESS);
}

idmap_stat
_iter_get_next_list(int type, idmap_iter_t *iter,
        void *arg, uchar_t **list, size_t valsize,
        xdrproc_t xdr_arg_proc, xdrproc_t xdr_res_proc)
{

    CLIENT      *clnt;
    enum clnt_stat  clntstat;

    iter->next = 0;
    iter->retlist = NULL;
    _IDMAP_GET_CLIENT_HANDLE(iter->ih, clnt);

    /* init the result */
    if (*list) {
        xdr_free(xdr_res_proc, (caddr_t)*list);
    } else {
        if ((*list = malloc(valsize)) == NULL) {
            errno = ENOMEM;
            return (IDMAP_ERR_MEMORY);
        }
    }
    (void) memset(*list, 0, valsize);

    clntstat = clnt_call(clnt, type,
        xdr_arg_proc, (caddr_t)arg,
        xdr_res_proc, (caddr_t)*list,
        TIMEOUT);
    if (clntstat != RPC_SUCCESS) {
        free(*list);
        return (_idmap_rpc2stat(clnt));
    }
    iter->retlist = *list;
    return (IDMAP_SUCCESS);
}

idmap_stat
_idmap_rpc2stat(CLIENT *clnt)
{
    /*
     * We only deal with door_call(3C) errors here. We look at
     * r_err.re_errno instead of r_err.re_status because we need
     * to differentiate between RPC failures caused by bad door fd
     * and others.
     */
    struct rpc_err r_err;
    if (clnt) {
        clnt_geterr(clnt, &r_err);
        errno = r_err.re_errno;
        switch (r_err.re_errno) {
        case ENOMEM:
            return (IDMAP_ERR_MEMORY);
        case EBADF:
            return (IDMAP_ERR_RPC_HANDLE);
        default:
            return (IDMAP_ERR_RPC);
        }
    }

    /* null handle */
    return (IDMAP_ERR_RPC_HANDLE);
}