lcas_utils.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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <stdarg.h>
#include <gssapi.h>
#include "lcas_defines.h"
#include "lcas_types.h"

/******************************************************************************
                             Define constants
******************************************************************************/

/******************************************************************************
                          Module specific prototypes
******************************************************************************/
static char * cred_to_dn(gss_cred_id_t);
static int    fexist(char *);


/******************************************************************************
Function:       lcas_fill_cred()
Description:    Fill cedential from dn and globus credential
Parameters:
                dn: distinguished name
                cred: globus credential
                plcas_cred: pointer to lcas_credential
Returns:        0: succes
                1: failure
******************************************************************************/
int lcas_fill_cred(
        char * dn,
        gss_cred_id_t cred,
        lcas_cred_id_t * plcas_cred
)
{
    /* Copy the credential */
    plcas_cred->cred = cred;

    if (cred == GSS_C_NO_CREDENTIAL) /* Empty credential: Fill DN with passed dn */
    {
        plcas_cred->dn = strdup(dn);
    }
    else
    {
        plcas_cred->dn = cred_to_dn(cred);
    }
    if (plcas_cred->dn == NULL)
        return 1; /* Cannot find user dn */
    return 0;
}

/******************************************************************************
Function:       lcas_release_cred()
Description:    release lcas credential
Parameters:
                plcas_cred: pointer to lcas_credential
Returns:        0: succes
                1: failure
******************************************************************************/
int lcas_release_cred(
        lcas_cred_id_t * plcas_cred
)
{
    if (plcas_cred == NULL)
        return 0;

    if (plcas_cred->dn != NULL)
        free(plcas_cred->dn);
    /* Don't release globus credential (not copied) */

    return 0;
}

/******************************************************************************
Function:       lcas_get_dn()
Description:    returns user dn
Parameters:
                lcas_credential: lcas_credential
Returns:        user dn
******************************************************************************/
char * lcas_get_dn(
        lcas_cred_id_t lcas_credential
)
{
    return (lcas_credential.dn);
}

/******************************************************************************
Function:       lcas_get_gss_cred()
Description:    returns globus gss credential
Parameters:
                lcas_credential: lcas_credential
Returns:        globus gss credential
******************************************************************************/
gss_cred_id_t lcas_get_gss_cred(
        lcas_cred_id_t lcas_credential
)
{
    return (lcas_credential.cred);
}

/******************************************************************************
Function:       cred_to_dn() (copied from GLOBUS gatekeeper.c)
Description:    Get the globusid from gssapi
Parameters:
                globus_cred: globus credential
Returns:        globusid string (which could be freeed)
******************************************************************************/
static char * cred_to_dn(
        gss_cred_id_t globus_cred
)
{
    char*                         globusid = NULL;
    char*                         globusid_tmp = NULL;
    gss_name_t                    globus_name = GSS_C_NO_NAME;
    gss_buffer_desc               globus_buffer_desc = GSS_C_EMPTY_BUFFER;
    gss_buffer_t                  globus_buffer = &globus_buffer_desc;
    OM_uint32                     major_status = 0;
    OM_uint32                     minor_status = 0;
    OM_uint32                     minor_status2 = 0;

    if ((major_status = gss_inquire_cred(&minor_status,
                                         globus_cred,
                                         &globus_name,
                                         NULL, NULL, NULL)) == GSS_S_COMPLETE)
    {
        major_status = gss_display_name(&minor_status,
                                        globus_name, globus_buffer, NULL);
        gss_release_name(&minor_status2, &globus_name);
    }
    /*
     * The gssapi_cleartext does not implement gss_inquire_cred,
     * so fall back to using environment variable.
     */
    if (major_status == GSS_S_COMPLETE)
    {
        globusid = globus_buffer_desc.value;
    }
    else
    {
        globusid = getenv("GLOBUSID");
        globusid = (globusid ? globusid : "GLOBUSID");
    }
    globusid_tmp = strdup(globusid);

    if (globus_buffer_desc.value)
    {
        gss_release_buffer(&minor_status2, globus_buffer);
    }
    return globusid_tmp;
}

/******************************************************************************
Function:       lcas_genfilename() (copied from GLOBUS gatekeeper.c)
Description:    generate an absolute file name given a starting prefix,
                a relative or absolute path, and a suffix
                Only use prefix if path is relative.
Parameters:
Returns:        a pointer to a string which could be freeded.
******************************************************************************/
char * lcas_genfilename(
        char * prefixp,
        char * pathp,
        char * suffixp
)
{
    char * newfilename;
    int    prefixl, pathl, suffixl;
    char * prefix,  * path, * suffix;

    prefix = (prefixp) ? prefixp : "";
    path   = (pathp) ? pathp : "";
    suffix  = (suffixp) ? suffixp : "";

    prefixl = strlen(prefix);
    pathl   =  strlen(path);
    suffixl  =  strlen(suffix); 

    newfilename = (char *) calloc(1, (prefixl + pathl + suffixl + 3));
    if (newfilename) 
    {
        if (*path != '/')
        {
            strcat(newfilename, prefix);
            if ((prefixl != 0) && (prefix[prefixl-1] != '/'))
            {
                strcat(newfilename, "/");
            }
        }
        strcat(newfilename, path);
        if ((pathl  != 0) &&
            (suffixl != 0) && 
            (path[pathl-1] != '/') && 
             suffix[0] != '/')
        {
            strcat(newfilename, "/");
        }
        strcat(newfilename, suffix);
    }
    return newfilename;
}

/******************************************************************************
Function:       fexist()
Description:    check the existence of file corresponding to <path>
Parameters:     path
Returns:        1, if file exists
******************************************************************************/
static int fexist(
        char * path
)
{
  struct stat sbuf;
  int res;
  
  if(!path || !*path) return 0;

  res=stat(path,&sbuf);
  if (res)
  {
      if (errno==ENOENT)
      {
          return 0;
      }
      else
      {
          return -1;
      }
  }
  return 1;
}

/******************************************************************************
Function:       lcas_getfexist()
Description:    picks the first existing file in argument list
Parameters:     n   : number of paths,
                ... : list of paths
Returns:        returns filename found or NULL
******************************************************************************/
char * lcas_getfexist(
        int n,
        ...
)
{
  va_list pvar;
  int i;
  char *cfilenm=NULL;

  va_start(pvar, n);

  for(i=0;i<n;i++) {
    cfilenm=va_arg(pvar,char*);
    if(*cfilenm) if(fexist(cfilenm)) return cfilenm;
  }
  va_end(pvar);
  return NULL;
}

/******************************************************************************
Function:       lcas_findfile()
Description:    Checks for file in standard directories
Parameters:     name
Returns:        returns filename found (should be freeed) or NULL
******************************************************************************/
char * lcas_findfile(
        char * name
)
{
    char * newname=NULL;
    char * tmpname=NULL;
    char * names[5]={NULL,NULL,NULL,NULL,NULL};
    int    i;

    names[0]=lcas_genfilename(NULL,name,NULL);
    names[1]=lcas_genfilename("modules",name,NULL);
    names[2]=lcas_genfilename(LCAS_ETC_HOME,name,NULL);
    names[3]=lcas_genfilename(LCAS_MOD_HOME,name,NULL);
    names[4]=lcas_genfilename(LCAS_LIB_HOME,name,NULL);

    tmpname=lcas_getfexist(5,names[0],
                      names[1],names[2],
                      names[3],names[4]);
    if (tmpname != NULL)
        newname=strdup(tmpname);
    else
        newname=NULL;

    for (i=0; i < 5; i++)
    {
        if (names[i] != NULL) free(names[i]);
    }

    return newname;
}

/******************************************************************************
Function:   lcas_tokenize() (in modified form from globus_gatekeeper_utils.c)

Description:
    Breakup the command in to args, pointing the args array
    at the tokens. Replace white space at the end of each
    token with a null. A token maybe in quotes. 

Parameters:
    command: The command line to be parsed.
    args:    A pointer to an array of pointers to be filled it
    n:       Size of the array, on input, and set to size used on output. 
    sep:     string of seperating characters

Returns:
    0 on success. 
    -1 on to malloc
    -2 on to many args
    -3 on quote not matched
******************************************************************************/
int lcas_tokenize(
        const char * command, 
        char ** args,
        int * n,
        char * sep
    )
{
    int maxargs;
    int i;
    const char * cp;
    const char * pp;
    const char * qp;
    char ** arg;

    arg = args;
/*    i = *n - 1; */
    i = 0;
    maxargs = *n;

    cp = command;
    while (*cp)
    {
    /* skip leading sep characters */
        while (*cp && strchr(sep, *cp))
        {
            cp++;
        }
        pp = NULL;
        if (*cp == '\"')
        {
            cp++;
            pp = cp;
            if ((qp = strchr(cp,'\"')) == NULL)
            {
                *n = i;
                return -3;
            }
            cp = qp + 1;
        }
        else if (*cp)
        {
            pp = cp;
            if ((qp = strpbrk(cp,sep)) == NULL)
            {
                qp = strchr(cp,'\0');
            }
            cp = qp;
        }
        else
        {
            continue;
        }
        if (pp)
        {
            /*
             * fill at most maxargs-1 arguments; let the last one point to NULL
             */
            i++;
            if (i >= maxargs)
            {
                i--;
                *n = i;
                return(-2); /* too many args */
            }
            *arg = (char*)malloc((qp - pp) + 1);
            if (*arg == NULL)
            {
                i--;
                *n = i;
                return -1;
            }
            memcpy(*arg,pp,qp - pp);
            *(*arg + (qp - pp)) = '\0';
            arg++;
        }
    }
    *arg = NULL;
    *n = i;
    return(0);
}

/******************************************************************************
CVS Information:
    $Source: /cvs/jra1mw/org.glite.security.lcas/src/lcas_utils.c,v $
    $Date: 2005/02/28 11:45:52 $
    $Revision: 2.12 $
    $Author: msteenba $
******************************************************************************/

---