lcmaps_credential.c

Go to the documentation of this file.

/*                                                                                                            
 * Copyright (c) Members of the EGEE Collaboration. 2004.
 * See http://eu-egee.org/partners/ for details on the copyright holders.
 * For license conditions see the license file or
 * http://eu-egee.org/license.html
 */

#ifndef LCMAPS_CREDENTIAL_C
#define LCMAPS_CREDENTIAL_C

/******************************************************************************
                             Include header files
******************************************************************************/
#include "lcmaps_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef LCMAPS_GSI_MODE
#   include <gssapi.h>
#   include "gsi_handling/_lcmaps_gsi_utils.h"
#   include "gsi_handling/_lcmaps_voms_attributes.h"
#endif
#include "_lcmaps_credential.h"

/* LCMAPS includes */
#include "lcmaps_log.h"

#ifdef LCMAPS_GSI_MODE

/******************************************************************************
Function:       lcmaps_credential_store_gss_cred_id_t()
Description:    Fill credential with gss_cred_id_t (internally gsi credential)
                If the lcmaps credential does not yet contain the DN,
                try to retrieve it from the gss credential.
                If the lcmaps credential does not yet contain VOMS
                attributes, try to retrieve them from the gss credential.
Parameters:
                gss_credential:     gss credential (internally gsi credential)
                plcmaps_credential: pointer to lcmaps_credential
Returns:        0:  succes
                1:  failed to retrieve DN from gss_credential
                2:  failed to retrieve VOMS attributes, because the proxy does not
                    contain them (VERR_NOEXT)
                3:  error in retrieving VOMS attributes.
                -1: failure, because lcmaps_credential does not exist
******************************************************************************/
int lcmaps_credential_store_gss_cred_id_t(
        gss_cred_id_t      gss_credential,
        lcmaps_cred_id_t * plcmaps_credential
)
{
    char * logstr = "lcmaps.mod-lcmaps_credential_store_gss_cred_id_t()";

    if (plcmaps_credential == NULL)
    {
        return -1;
    }
    /* Fill credential */
    plcmaps_credential->cred = gss_credential;

    /* Check if the user DN has been filled. If not, try to extract it */
    if ((plcmaps_credential->dn == NULL) && (gss_credential != GSS_C_NO_CREDENTIAL))
    {
        if ((plcmaps_credential->dn = lcmaps_gss_cred_to_dn(gss_credential)) == NULL)
        {
            return 1;
        }
    }

    /* Check if the VOMS attributes have been filled. If not, try to extract them */
    if ((plcmaps_credential->fqan == NULL) && (gss_credential != GSS_C_NO_CREDENTIAL))
    {
        if ( (plcmaps_credential->fqan = lcmaps_gss_cred_to_voms_fqans(
                                            gss_credential,
                                            &(plcmaps_credential->nfqan)
                                        ) ) == NULL)
        {
            if (plcmaps_credential->nfqan == 0)
            {
                lcmaps_log_debug(1, "%s: No FQANs found in gss credentials\n", logstr);
                return 2;
            }
            else
            {
                lcmaps_log_debug(1, "%s: Error retrieving VOMS attributes\n", logstr);
                return 3;
            }
        }
    }
    return 0;
}

/******************************************************************************
Function:       lcmaps_credential_get_gss_cred_id_t()
Description:    returns gss credential (internally gsi credential)
Parameters:
                lcmaps_credential: lcmaps_credential
Returns:        gss credential
******************************************************************************/
gss_cred_id_t lcmaps_credential_get_gss_cred_id_t(
        lcmaps_cred_id_t lcmaps_credential
)
{
    return (lcmaps_credential.cred);
}

/******************************************************************************
Function:       lcmaps_credential_store_gss_ctx_id_t()
Description:    Fill credential with gss_ctx_id_t (gss security context)
Parameters:
                gss_context:        gss security context
                plcmaps_credential: pointer to lcmaps_credential
Returns:        0: succes
                1: failure
******************************************************************************/
int lcmaps_credential_store_gss_ctx_id_t(
        gss_ctx_id_t       gss_context,
        lcmaps_cred_id_t * plcmaps_credential
)
{
    return 1;
}

/******************************************************************************
Function:       lcmaps_credential_get_gss_ctx_id_t()
Description:    returns gss security context
Parameters:
                lcmaps_credential: lcmaps_credential
Returns:        gss security context
******************************************************************************/
gss_ctx_id_t lcmaps_credential_get_gss_ctx_id_t(
        lcmaps_cred_id_t lcmaps_credential
)
{
    return (lcmaps_credential.context);
}

#endif /* LCMAPS_GSI_MODE */


/******************************************************************************
Function:       lcmaps_credential_store_dn()
Description:    Fill credential with dn
Parameters:
                dn:                 distinguished name
                plcmaps_credential: pointer to lcmaps_credential
Returns:        0: succes
                1: failed to fill dn
                -1: failure, because lcmaps_credential does not exist
******************************************************************************/
int lcmaps_credential_store_dn(
        char *             dn,
        lcmaps_cred_id_t * plcmaps_credential
)
{
    if (plcmaps_credential == NULL)
    {
        lcmaps_log(0,"lcmaps.mod-lcmaps_credential_store_dn(): Create lcmaps_cred_id_t first!\n");
        return -1;
    }

    /* DN may have already been filled, from gss_credential */
    if (plcmaps_credential->dn == NULL)
    {
        if (dn != NULL)
        {
            plcmaps_credential->dn = strdup(dn);
        }
        else /* dn is empty and lcmaps_cred_id_t has not been filled with otherwise */
        {
            lcmaps_log(0,"lcmaps.mod-lcmaps_credential_store_dn(): Cannot fill empty DN\n");
            return 1;
        }
    }
    return 0;
}

/******************************************************************************
Function:       lcmaps_credential_get_dn()
Description:    returns user dn
Parameters:
                lcmaps_credential: lcmaps_credential
Returns:        user dn
******************************************************************************/
char * lcmaps_credential_get_dn(
        lcmaps_cred_id_t lcmaps_credential
)
{
    return (lcmaps_credential.dn);
}

/******************************************************************************
Function:       lcmaps_credential_store_fqan_list()
Description:    Fill credential with list of FQANs
Parameters:
                nfqan:              number of elements of the FQAN list
                fqan_list:          FQAN list (list of strings)
                plcmaps_credential: pointer to lcmaps_credential
Returns:        0: succes
                1: failure, because the presented fqan list is malformed
                2: failure, because of a malloc error
                -1: failure, because lcmaps_credential does not exist
******************************************************************************/
int lcmaps_credential_store_fqan_list(
        int                nfqan,
        char **            fqan_list,
        lcmaps_cred_id_t * plcmaps_credential
)
{
    int     i    = 0;
    char *  fqan = NULL;

    if (plcmaps_credential == NULL)
    {
        lcmaps_log(0,"lcmaps.mod-lcmaps_credential_store_dn(): Create lcmaps_cred_id_t first!\n");
        return -1;
    }

    /* Check if a FQAN list exists already. If so, return happily */
    if ( (plcmaps_credential->fqan == NULL) && (nfqan > 0) )
    {
        plcmaps_credential->nfqan = nfqan;
        plcmaps_credential->fqan = (char **) malloc(nfqan * sizeof(char *));
        if (plcmaps_credential->fqan == NULL) /* malloc error */
        {
            lcmaps_log(0,"lcmaps.mod-lcmaps_credential_store_fqan_list(): Malloc error!\n");
            return 2;
        }
        for (i = 0; i < nfqan; i++)
        {
            if ((fqan = fqan_list[i]) != NULL)
            {
                if ( ((plcmaps_credential->fqan)[i] = strdup(fqan)) == NULL)
                {
                    lcmaps_log(0,"lcmaps.mod-lcmaps_credential_store_fqan_list(): Malloc error!\n");
                    return 2;
                }
            }
            else
            {
                lcmaps_log(0,"lcmaps.mod-lcmaps_credential_store_fqan_list(): malformed fqan list\n");
                return 1;
            }
        }
    }
    return 0;
}

/******************************************************************************
Function:       lcmaps_credential_get_fqan_list()
Description:    returns the list of FQANs and number of elements
Parameters:
                pnfqan:            pointer to the number of FQANs in the list
                lcmaps_credential: lcmaps_credential
Returns:        list of FQANs
******************************************************************************/
char ** lcmaps_credential_get_fqan_list(
        int *            pnfqan,
        lcmaps_cred_id_t lcmaps_credential
)
{
    *pnfqan = lcmaps_credential.nfqan;
    return (lcmaps_credential.fqan);
}

/******************************************************************************
Function:       lcmaps_credential_init()
Description:    initialize the lcmaps_cred_id_t: set the member values to
                the default values
Parameters:
                plcmaps_credential: pointer to lcmaps_credential
Returns:        0:  succes
                1:  failed to set the member values
                -1: failure, because lcmaps_credential does not exist
******************************************************************************/
int lcmaps_credential_init(
        lcmaps_cred_id_t * plcmaps_credential
)
{
    if (plcmaps_credential == NULL)
    {
        lcmaps_log(0,"lcmaps.mod-lcmaps_credential_init(): Create lcmaps_cred_id_t first!\n");
        return -1;
    }
#ifdef LCMAPS_GSI_MODE
    plcmaps_credential->cred    = GSS_C_NO_CREDENTIAL;
    plcmaps_credential->context = GSS_C_NO_CONTEXT;
#endif
    plcmaps_credential->dn      = (char *) NULL;
    plcmaps_credential->fqan    = (char **) NULL;
    plcmaps_credential->nfqan   = -1;

    return 0;
}

/******************************************************************************
Function:       lcmaps_release_cred()
Description:    release lcmaps credential
Parameters:
                plcmaps_credential: pointer to lcmaps_credential
Returns:        0: succes
                1: failure
******************************************************************************/
int lcmaps_release_cred(
        lcmaps_cred_id_t * plcmaps_credential
)
{
    int i = 0;

    if (plcmaps_credential == NULL)
        return 0;

    if (plcmaps_credential->dn != NULL)
        free(plcmaps_credential->dn);

    if (plcmaps_credential->nfqan > 0)
    for (i = 0; i < plcmaps_credential->nfqan; i++)
    {
        if ((plcmaps_credential->fqan)[i] != NULL)
            free((plcmaps_credential->fqan)[i]);
    }
    if (plcmaps_credential->fqan != NULL) /* this removes the whole array of char* */
    {
        free(plcmaps_credential->fqan);
    }
    return 0;
}

#endif /* LCMAPS_CREDENTIAL_C */

/******************************************************************************
CVS Information:
    $Source: /cvs/jra1mw/org.glite.security.lcmaps/src/grid_credential_handling/lcmaps_credential.c,v $
    $Date: 2005/02/27 01:30:41 $
    $Revision: 1.2 $
    $Author: msteenba $
******************************************************************************/

---