lcas_vo_data.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
 */

/*                                                                                                            
 * Copyright (c) 2001 EU DataGrid.                                                                             
 * For license conditions see http://www.eu-datagrid.org/license.html                                          
 *
 * Copyright (c) 2001, 2002 by 
 *     Martijn Steenbakkers <martijn@nikhef.nl>,
 *     David Groep <davidg@nikhef.nl>,
 *     NIKHEF Amsterdam, the Netherlands
 */

/******************************************************************************
                             Include header files
******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

#include "lcas_vo_data.h"
#include "lcas_log.h"

/******************************************************************************
                                Definitions
******************************************************************************/
#define VO_DATA_WHITESPACE_CHARS " \t\n"

/******************************************************************************
Function:   lcas_createVoData
Description:
    Create a VoData structure (store a VO, group, (subgroup,) role, capability
    combination). Allocate the memory. To be freed with lcas_deleteVoData().

Parameters:
    vo: name of the VO
    group: name of the group
    subgroup: name of the subgroup (ignored for the moment)
    role: the role
    capability: the capability (whatever it is)
Returns:
    pointer to the VoData structure or NULL
******************************************************************************/
lcas_vo_data_t *
lcas_createVoData(
    const char * vo,
    const char * group,
    const char * subgroup,
    const char * role,
    const char * capability
)
{
    lcas_vo_data_t * newVoData=NULL;

    newVoData = (lcas_vo_data_t *)malloc(sizeof(lcas_vo_data_t));
    if (!newVoData)
    {
        lcas_log(0,"lcas_createVoData(): error in malloc for new VoData structure\n");
        return NULL;
    }

    newVoData->vo = NULL;
    newVoData->group = NULL;
    newVoData->subgroup = NULL;
    newVoData->role = NULL;
    newVoData->capability = NULL;

    if (vo) newVoData->vo = strdup(vo);
    if (group) newVoData->group = strdup(group);
    if (subgroup) newVoData->subgroup = strdup(subgroup);
    if (role) newVoData->role = strdup(role);
    if (capability) newVoData->capability = strdup(capability);

    return newVoData;
}

/******************************************************************************
Function:   lcas_deleteVoData
Description:
    Delete a VoData structure that was previously created with lcas_createVoData().
    The pointer to the VoData structure is finally set to NULL;

Parameters:
    vo_data: pointer to a pointer to a VoData structure

Returns:
    0: success
    -1: failure (could not delete the structure or no structure found)
******************************************************************************/
int
lcas_deleteVoData(
    lcas_vo_data_t ** vo_data
)
{
    if (!vo_data) {
        lcas_log(0, "lcas_deleteVoData(): empty pointer as input !\n");
        return -1;
    }

    if ( (*vo_data) )
    {
        if ( (*vo_data)->vo) free( (*vo_data)->vo );
        if ( (*vo_data)->group) free( (*vo_data)->group );
        if ( (*vo_data)->subgroup) free( (*vo_data)->subgroup );
        if ( (*vo_data)->role) free( (*vo_data)->role );
        if ( (*vo_data)->capability) free( (*vo_data)->capability );
        free( (*vo_data) );
    }
    else
    {
        lcas_log_debug(2,"lcas_deleteVoData(): no lcas_vo_data_t found\n");
    }
    *vo_data=NULL;
    return 0;
}

/******************************************************************************
Function:   lcas_cleanVoData
Description:
    Clean a VoData structure that was previously filled with lcas_copyVoData().
    The contents are freed and set to zero.

Parameters:
    vo_data: a pointer to a VoData structure

Returns:
    0: success
    -1: failure (could not clean the structure or no structure found)
******************************************************************************/
int
lcas_cleanVoData(
    lcas_vo_data_t * vo_data
)
{
    if (!vo_data) {
        lcas_log(0, "lcas_cleanVoData():: no lcas_vo_data_t found\n");
        return -1;
    }
    else
    {
        if ( (vo_data)->vo)
        {
            free( (vo_data)->vo );
            vo_data->vo = NULL;
        }
        if ( (vo_data)->group) 
        {
            free( (vo_data)->group );
            vo_data->group = NULL;
        }
        if ( (vo_data)->subgroup) 
        {
            free( (vo_data)->subgroup );
            vo_data->subgroup = NULL;
        }
        if ( (vo_data)->role) 
        {
            free( (vo_data)->role );
            vo_data->role = NULL;
        }
        if ( (vo_data)->capability) 
        {
            free( (vo_data)->capability );
            vo_data->capability = NULL;
        }
    }
    return 0;
}

/******************************************************************************
Function:   lcas_copyVoData
Description:
    Copy a VoData structure into an empty VoData structure which has to exist.

Parameters:
    dst_vo_data pointer to a empty VoData structure that should be filled
    src_vo_data pointer to the VoData structure that should be copied

Returns:
    0: success
    -1: failure (either src_vo_data or dst_vo_data was empty)
******************************************************************************/
int
lcas_copyVoData(
    lcas_vo_data_t * dst_vo_data,
    const lcas_vo_data_t * src_vo_data
)
{
    if ( (dst_vo_data) && (src_vo_data) )
    {
        if (src_vo_data->vo)
            dst_vo_data->vo = strdup(src_vo_data->vo);
        else
            dst_vo_data->vo = NULL;
        if (src_vo_data->group)
            dst_vo_data->group = strdup(src_vo_data->group);
        else
            dst_vo_data->group = NULL;
        if (src_vo_data->subgroup)
            dst_vo_data->subgroup = strdup(src_vo_data->subgroup);
        else
            dst_vo_data->subgroup = NULL;
        if (src_vo_data->role)
            dst_vo_data->role = strdup(src_vo_data->role);
        else
            dst_vo_data->role = NULL;
        if (src_vo_data->capability)
            dst_vo_data->capability = strdup(src_vo_data->capability);
        else
            dst_vo_data->capability = NULL;

        return 0;
    }
    else
    {
        return -1;
    }
}

/******************************************************************************
Function:   lcas_printVoData
Description:
    Print the contents of a VoData structure

Parameters:
    debug_level: debug_level for which the contents will be printed
    vo_data: pointer to a VoData structure

Returns:
     0 (always)
******************************************************************************/
int
lcas_printVoData(
    int debug_level,
    const lcas_vo_data_t * vo_data
)
{
    if (vo_data)
    {
        lcas_log_debug(debug_level,"lcas_printVoData(): address of vo data struct: %p\n", vo_data);
        lcas_log_debug(debug_level,"lcas_printVoData():                        VO: %s\n", vo_data->vo);
        lcas_log_debug(debug_level,"lcas_printVoData():                     GROUP: %s\n", vo_data->group);
        lcas_log_debug(debug_level,"lcas_printVoData():                  SUBGROUP: %s\n", vo_data->subgroup);
        lcas_log_debug(debug_level,"lcas_printVoData():                      ROLE: %s\n", vo_data->role);
        lcas_log_debug(debug_level,"lcas_printVoData():                CAPABILITY: %s\n", vo_data->capability);
    }
    else
    {
        lcas_log_debug(debug_level,"lcas_printVoData(): empty pointer to vo data struct\n");
    }
    return 0;
}

/******************************************************************************
Function:   lcas_stringVoData
Description:
    Cast a VoData structure into a string

    The user of this function should create the buffer of size nchars beforehand.
    In buffer a string like the following will be written:
    "/VO=fred/GROUP=fred/flintstone/ROLE=director/CAPABILITY=destroy"

    Currently the SUBGROUP entry is ignored. Only if the information is present in the 
    VoData structure, it is added to the string.
    Both data for VO and GROUP are required (might change).


Parameters:
    vo_data: pointer to a VoData structure
    buffer: pointer to character array of size nchars
    nchars: size of character array

Returns:
    0: success
    -1: failure
******************************************************************************/
int
lcas_stringVoData(
    const lcas_vo_data_t * vo_data,
    char * buffer,
    int nchars
)
{
    int totalchars;
    char * strptr=NULL;
    char * bufptr=NULL;
    int    buflen=0;

    bufptr=buffer;
    buflen=nchars;

    /* write "VO=" */
    /* Skip over leading whitespace */
    if ( (strptr=lcas_parseVostring(vo_data->vo)) )
    {
        /* Convention for solaris 2.8 and glibc-2.1 and higher:
         * totalchars is the number of chars written (excluding \0) if enough space had been 
         * available.
         * negative: error
         */
        totalchars=snprintf(bufptr,(size_t)buflen,"/VO=%s",strptr);
        if ( (totalchars+1) > buflen )
        {
            lcas_log(0,"lcas_stringVoData(): could not write all characters into buffer for VO\n");
            lcas_log(0,"lcas_stringVoData(): excess of characters: %d\n",totalchars+1-buflen);
            return -1;
        }
        else if ( totalchars < 0 )
        {
            lcas_log(0,"lcas_stringVoData(): error in snprintf()\n");
            return -1;
        }
        else
        {
            bufptr+=totalchars;
            buflen-=totalchars;
        }
    }
    else
    {
        lcas_log(0,"lcas_stringVoData(): error no VO found\n");
        return -1;
    }

    /* write "GROUP=" */
    /* Skip over leading whitespace */
    if ( (strptr=lcas_parseVostring(vo_data->group)) )
    {
        totalchars=snprintf(bufptr,(size_t)buflen,"/GROUP=%s",strptr);
        if ( (totalchars+1) > buflen )
        {
            lcas_log(0,"lcas_stringVoData(): could not write all characters into buffer for GROUP\n");
            lcas_log(0,"lcas_stringVoData(): excess of characters: %d\n",totalchars+1-buflen);
            return -1;
        }
        else if ( totalchars < 0 )
        {
            lcas_log(0,"lcas_stringVoData(): error in snprintf()\n");
            return -1;
        }
        else
        {
            bufptr+=totalchars;
            buflen-=totalchars;
        }
    }
    else
    {
        lcas_log(0,"lcas_stringVoData(): error no VO-group found\n");
        return -1;
    }

    /* Skip subgroup for the moment (not clear how VOMS will evolve in this respect) */

    /* write "ROLE=" */
    /* Skip over leading whitespace */
    if ( (strptr=lcas_parseVostring(vo_data->role)) )
    {
        {
            totalchars=snprintf(bufptr,(size_t)buflen,"/ROLE=%s",strptr);
            if ( (totalchars+1) > buflen )
            {
                lcas_log(0,"lcas_stringVoData(): could not write all characters into buffer for ROLE\n");
                lcas_log(0,"lcas_stringVoData(): excess of characters: %d\n",totalchars+1-buflen);
                return -1;
            }
            else if ( totalchars < 0 )
            {
                lcas_log(0,"lcas_stringVoData(): error in snprintf()\n");
                return -1;
            }
            else
            {
                bufptr+=totalchars;
                buflen-=totalchars;
            }
        }
    }

    /* write "CAPABILITY=" */
    /* Skip over leading whitespace */
    if ( (strptr=lcas_parseVostring(vo_data->capability)) )
    {
        {
            totalchars=snprintf(bufptr,(size_t)buflen,"/CAPABILITY=%s",strptr);
            if ( (totalchars+1) > buflen )
            {
                lcas_log(0,"lcas_stringVoData(): could not write all characters into buffer for CAPABILITY\n");
                lcas_log(0,"lcas_stringVoData(): excess of characters: %d\n",totalchars+1-buflen);
                return -1;
            }
            else if ( totalchars < 0 )
            {
                lcas_log(0,"lcas_stringVoData(): error in snprintf()\n");
                return -1;
            }
            else
            {
                bufptr+=totalchars;
                buflen-=totalchars;
            }
        }
    }
    return 0;
}

/******************************************************************************
Function:   lcas_parseVostring
Description:
    Strip leading whitespace and check if string != "NULL"

    This function is needed because VOMS server fills user credential sometimes
    with strings like "   NULL", which is a valid string, but the intention is that the
    data is empty. A string like this is translated into a NULL pointer by this function.
    
Parameters:
    vo_string: string of VO credential

Returns:
    pointer to the parsed string or NULL
******************************************************************************/
char *
lcas_parseVostring(
    char * vo_string
)
{
    char * strptr = NULL;

    if (vo_string == NULL) return NULL;

    strptr=vo_string;
    strptr += strspn(strptr, VO_DATA_WHITESPACE_CHARS);
    if ( (*strptr!='\0') && (strncmp(strptr,"NULL",4)) )
    {
        return strptr;
    }
    else
    {
        return NULL;
    }
}


/******************************************************************************
CVS Information:
    $Source: /cvs/jra1mw/org.glite.security.lcas-plugins-voms/src/voms/lcas_vo_data.c,v $
    $Date: 2004/10/14 16:05:28 $
    $Revision: 1.4 $
    $Author: msteenba $
******************************************************************************/

---