lcmaps_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 <grp.h>
#include "lcmaps_defines.h"
#include "lcmaps_types.h"
#include "lcmaps_log.h"

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

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

/******************************************************************************
Function:       lcmaps_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 * lcmaps_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:       lcmaps_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 * lcmaps_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:       lcmaps_findfile()
Description:    Checks for file in standard directories
Parameters:     name
Returns:        returns filename found (should be freeed) or NULL
******************************************************************************/
char * lcmaps_findfile(
        char * name
)
{
    char * newname=NULL;
    char * tmpname=NULL;
    char * names[6]={NULL,NULL,NULL,NULL,NULL,NULL};
    int    i;

    names[0]=lcmaps_genfilename(NULL,name,NULL);
    names[1]=lcmaps_genfilename(getenv("LCMAPS_MODULES_DIR"),name,NULL);
    names[2]=lcmaps_genfilename("modules",name,NULL);
    names[3]=lcmaps_genfilename(LCMAPS_ETC_HOME,name,NULL);
    names[4]=lcmaps_genfilename(LCMAPS_MOD_HOME,name,NULL);
    names[5]=lcmaps_genfilename(LCMAPS_LIB_HOME,name,NULL);

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

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

    return newname;
}

/******************************************************************************
Function:   lcmaps_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 lcmaps_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);
}
/******************************************************************************
Function:   lcmaps_get_gidlist()

Description:
    Finds the list of gids for user in the group file (/etc/group)
    Returns a list of gid_t which should be freed by calling program.

Parameters:
    username:   the name of the user
    ngroups:    ptr to int which will be filled with the number of gids.
    group_list: ptr to an array of gid_t.

Returns:
    0 on success. 
    -1 on realloc failure
    -2 on getgrent failure
    1 on failure
******************************************************************************/
int lcmaps_get_gidlist(
        const char * username,
        int * ngroups,
        gid_t ** group_list
    )
{
    struct group        * group_info = NULL;
    gid_t               * groups = NULL;
    gid_t               * newgroups = NULL;
    int                   i = 0;

    /* rewind the file pointer to the beginning of the /etc/group file */
    setgrent();

    lcmaps_log_debug(2,"\tlcmaps_get_gidlist(): looping through group file\n");
    *ngroups = 0;
    while ( ( group_info = getgrent() ) )
    {
        char ** pgr_mem = group_info->gr_mem;
        char *  gr_mem = NULL;

        lcmaps_log_debug(4,"\tlcmaps_get_gidlist(): group %s\n", group_info->gr_name);
        while ( (gr_mem = *pgr_mem) )
        {
            lcmaps_log_debug(4,"\tlcmaps_get_gidlist(): \tgroup member %s\n", gr_mem);
            if (strncmp(username, gr_mem, strlen(username))==0)
            {
                lcmaps_log_debug(2,"\tlcmaps_get_gidlist(): \t\tfound group %s for %s\n",
                    group_info->gr_name, username);
                (*ngroups)++;
                newgroups = (gid_t *) realloc(groups, ((*ngroups) * sizeof(gid_t)));
                if (newgroups == NULL)
                {
                    lcmaps_log(0,"lcmaps_get_gidlist(): cannot realloc\n");
                    free(groups);
                    return -1;
                }
                groups=newgroups;
                groups[(*ngroups)-1] = group_info->gr_gid;
            }
            ++pgr_mem;
        }
    }
    if (errno==ENOMEM)
    {
        lcmaps_log(0,"lcmaps_get_gidlist(): Cannot read the group file, %s\n", strerror(errno));
        free(groups);
        groups=NULL;
        /* Close the group file */
        endgrent();
        return -2;
    }
    *group_list=groups;
    lcmaps_log_debug(4,"\tlcmaps_get_gidlist(): %d groups found for %s\n", *ngroups, username);
    for (i = 0; i < *ngroups; i++)
    {
        lcmaps_log_debug(4,"\tlcmaps_get_gidlist(): group nr %d ==> gid_t %d\n", i+1, groups[i]);
    }
    /* Close the group file */
    endgrent();
    return 0;
}
/******************************************************************************
CVS Information:
    $Source: /cvs/jra1mw/org.glite.security.lcmaps/src/pluginmanager/lcmaps_utils.c,v $
    $Date: 2005/02/27 01:30:41 $
    $Revision: 1.10 $
    $Author: msteenba $
******************************************************************************/

---