util/lcaslcmaps_getaccount_cli/lcaslcmaps_getaccount_cli.c

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Authors: Mischa Sall\'e
 *      NIKHEF Amsterdam, the Netherlands
*      <grid-mw-security@nikhef.nl>
*
*
 * Test program to interact with LCAS and LCMAPS. It can be used to follow from
 * userspace the steps gLExec takes.
 * Compile with e.g.
 *  gcc -ldl -rdynamic -o lcaslcmaps_getaccount_cli lcaslcmaps_getaccount_cli.c
 * or
 *  gcc -ldl -L. -lvomsfix -o lcaslcmaps_getaccount_cli lcaslcmaps_getaccount_cli.c
 * to solve a missing symbol problem with libvomsapi / liblcmaps. The first
 * version uses the functions defined inside this file, the second gets them
 * from the dummy library libvomsfix.so
 */


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

#include <string.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <pwd.h>
#include <grp.h>

#include <dlfcn.h>

/* Dirty hack to fix the missing functions from VOMS API: VOMS API should have
 * defined these extern "C". LCMAPS needs these functions, and if not using the
 * ones from LCAS, you can use these (trivial ones) instead. By compiling with
 * -rdynamic i.e. by linking with -export-dynamic, the following symbols are
 * used instead. */
int getMajorVersionNumber(void) { return 0; }
int getPatchVersionNumber(void) { return 0; }
int getMinorVersionNumber(void) { return 0; }

/* lcas_request_t is defined in lcas_types.h, can just re-typedef it here. */
#if 0
/*#include "lcas_types.h"*/
#else
typedef char *lcas_request_t;
#endif

/* lcmaps_account_info_t is defined in lcmaps_account.h,
 * can just re-typedef it here. */
#if 0
#include "lcmaps_account.h"
#else
typedef struct lcmaps_account_info_s
{
    uid_t          uid;         /* the uid of the local account */
    gid_t *        pgid_list;   /* the list of primary gids */
    int            npgid;       /* the number of primary gids found */
    gid_t *        sgid_list;   /* the list of secondary gids */
    int            nsgid;       /* the number of secondary gids found */
    char *         poolindex;   /* the pool index */
} lcmaps_account_info_t;
#endif

typedef enum {
    LCMAPS_RETURN_ACCOUNT_FROM_PEM,
    LCMAPS_RETURN_ACCOUNT_WITHOUT_GSI,
    LCMAPS_RETURN_POOLINDEX_WITHOUT_GSI,
} lcmaps_mode_t;


/* Define to have getopt() behave POSIX correctly */
#define POSIXLY_CORRECT

/* Struct containing all the lcmaps functions, will be filled using dlsym() */
/* List extended with Without GSI specific functions */
typedef struct {
    void *handle,*helper; /* Needed for dlclose() */
    int (*lcmaps_init)(FILE*);
    int (*lcmaps_account_info_init)(lcmaps_account_info_t*);
    int (*lcmaps_return_account_from_pem)(char*,int,lcmaps_account_info_t*);
    int (*lcmaps_return_poolindex_without_gsi)(char*,char**,int,lcmaps_account_info_t*);
    /* int (*lcmaps_return_poolindex_with_mapcounter)(char*,char**,int,int,lcmaps_account_info_t); */
    int (*lcmaps_return_account_without_gsi)(char*,char**,int,int,lcmaps_account_info_t*);
    int (*lcmaps_term)(void);
} lcmaps_library_t;


/* Struct containing all the lcas functions, will be filled using dlsym() */
typedef struct {
    void *handle; /* Needed for dlclose() */
    int (*lcas_init)(FILE*);
    int (*lcas_pem)(char*,lcas_request_t);
    int (*lcas_term)(void);
} lcas_library_t;

/* Parses the options for LCMAPS and opens the logfile when needed */
int lcmaps_set_vars(char *options,FILE **log)  {
    char *var=options,*value,*end,*pos;
    
    /* If first char of options is a - it's actually the next main option */
    if (options[0]=='-')
        return 0;

    do  {
        /* Find end of current var=value pair */
        end=strchr(var, ',');
        if (end!=NULL) end[0]='\0';
        /* Find end of variable name */
        pos=strchr(var,'=');
        if (pos==NULL)
            fprintf(stderr,"Unrecognized element '%s'\n", var);
        else    {
            pos[0]='\0';
            value=pos+1;
            /* Find the variable */
            if (strcmp(var,"debug")==0)
                setenv("LCMAPS_DEBUG_LEVEL",value,1);
/*          else if (strcmp(var,"log")==0)
                setenv("LCMAPS_LOG_LEVEL",value,1);*/
            else if (strcmp(var,"policy")==0)
                setenv("LCMAPS_POLICY_NAME",value,1);
            else if (strcmp(var,"db")==0)
                setenv("LCMAPS_DB_FILE",value,1);
            else if (strcmp(var,"file")==0) {
                /* Only open when not already linked to stderr */
                if (*log==NULL) {
                    if ( (*log=fopen(value,"a"))==NULL)
                        fprintf(stderr,"Cannot open %s: %s\n",
                                value,strerror(errno));
                }
            }
            else
                fprintf(stderr,"Unrecognized option '%s'\n",var);
            /* reset value at pos */
            pos[0]='=';
        }
        if (end!=NULL)  {
            /* reset value at end */
            end[0]=',';
            /* advance to next option */
            var=end+1;
        }
    } while (end!=NULL);
    return 0;
}

/* Prints contents of account */
void lcmaps_print_account(lcmaps_account_info_t* account)  {
    int i;
    struct passwd *pw;
    struct group *gr;

    /* Check if there is anything */
    if (account->uid==-1)   {
        printf("Account info is empty.\n");
        return;
    }
    /* UID / username */
    pw=getpwuid(account->uid);
    printf("uid=%d(%s)\n",account->uid,pw ? pw->pw_name : "undefined");
    /* Primary groups */
    printf("primary gids: %d\n",account->npgid);
    for (i=0; i<account->npgid; i++)    {
        gr=getgrgid(account->pgid_list[i]);
        printf("pgid[%d]=%d(%s)\n",i,
                account->pgid_list[i],
                gr ? gr->gr_name : "undefined");
    }
    /* Secondary groups */
    printf("secondary gids: %d\n",account->nsgid);
    for (i=0; i<account->nsgid; i++)    {
        gr=getgrgid(account->sgid_list[i]);
        printf("sgid[%d]=%d(%s)\n",i,
                account->sgid_list[i],
                gr ? gr->gr_name : "undefined");
    }
    /* Poolindex */
    printf("poolindex=%s\n",
        (account->poolindex)!=NULL ? account->poolindex : "undefined");
}

/* Dynamically loads LCMAPS library and all needed symbols */
int loadlcmaps(lcmaps_library_t *lib, lcmaps_mode_t mode) {
    /* Make sure lib->handle has welldefined value */
    lib->handle=lib->helper=NULL;

    /* Load global symbols, so that we can search for getMajorVersionNumber */
    if ((lib->helper=dlopen(NULL,RTLD_NOW | RTLD_GLOBAL))==NULL) {
        fprintf(stderr,"Error loading global symbols: %s\n",dlerror());
        return 1;
    }

    /* Now look for getMajorVersionNumber: first look in global symbols, if not
     * there, try loading vomsfix library, if that fails too, load lcas instead.
     * */
    if (dlsym(lib->helper,"getMajorVersionNumber")==NULL)       {
        dlclose(lib->helper); /* No longer needed, doesn't provide...*/
        fprintf(stderr,"Warning: trying libvomsfix.so for missing get*VersionNumber() functions.\n");
        if ((lib->helper=dlopen("libvomsfix.so",RTLD_NOW | RTLD_GLOBAL))==NULL) {
            /* libvomsfix.so doesn't exist or isn't found. Now use lcas as a
             * backup */
            fprintf(stderr,"Warning: loading LCAS to provide missing get*VersionNumber() functions.\n");
            if ((lib->helper=dlopen("liblcas.so",RTLD_NOW | RTLD_GLOBAL))==NULL) {
                fprintf(stderr,"Error: %s\n",dlerror());
                return 1;
            }
        }
    }
    /* lib->helper now contains the handle containing get*VersionNumber() */

    /* Now load the real library */
    switch (mode) {
    case LCMAPS_RETURN_ACCOUNT_FROM_PEM:
      if ( (lib->handle=dlopen("liblcmaps_return_account_from_pem.so",
                               RTLD_NOW | RTLD_GLOBAL))==NULL ) {
        fprintf(stderr,"Error: %s\n",dlerror());
        return 1;
      }
      break;
    case LCMAPS_RETURN_POOLINDEX_WITHOUT_GSI:
      if ( (lib->handle=dlopen("liblcmaps_return_poolindex_without_gsi.so",
                               RTLD_NOW | RTLD_GLOBAL))==NULL ) {
        fprintf(stderr,"Error: %s\n",dlerror());
        return 1;
      }
      break;
    case LCMAPS_RETURN_ACCOUNT_WITHOUT_GSI:
    /* if ( (lib->handle=dlopen("liblcmaps_without_gsi.so", */
      if ( (lib->handle=dlopen("liblcmaps_return_poolindex_without_gsi.so",
                               RTLD_NOW | RTLD_GLOBAL))==NULL ) {
        fprintf(stderr,"Error: %s\n",dlerror());
        return 1;
      }
    }

#define print_dlerror_and_return { fprintf(stderr,"Error: %s\n",dlerror()); \
        dlclose(lib->handle);                                           \
        dlclose(lib->helper);                                           \
    return 1; }

    /* Load functions */
    if ( (lib->lcmaps_init=
          (int (*)(FILE*)) dlsym(lib->handle,"lcmaps_init"))==NULL ||
         (lib->lcmaps_account_info_init=
          (int (*)(lcmaps_account_info_t*))
          dlsym(lib->handle,"lcmaps_account_info_init"))==NULL ||
         (lib->lcmaps_term=
          (int (*)(void)) dlsym(lib->handle,"lcmaps_term"))==NULL )   {
        fprintf(stderr,"Error: %s\n",dlerror());
        dlclose(lib->handle);
        dlclose(lib->helper);
        return 1;
    }
    
    switch (mode) {
        case  LCMAPS_RETURN_ACCOUNT_FROM_PEM:
            if ( (lib->lcmaps_return_account_from_pem=
                  (int (*)(char*,int,lcmaps_account_info_t*))
                  dlsym(lib->handle,"lcmaps_return_account_from_pem"))==NULL ) {
                fprintf(stderr,"Error: %s\n",dlerror());
                dlclose(lib->handle);
                dlclose(lib->helper);
                return 1;
            }
            break;
        case  LCMAPS_RETURN_POOLINDEX_WITHOUT_GSI:
            if ( (lib->lcmaps_return_poolindex_without_gsi=
             (int (*)(char*,char**,int,lcmaps_account_info_t*))
                  dlsym(lib->handle,"lcmaps_return_poolindex_without_gsi"))==NULL ) 
                print_dlerror_and_return;
            break;
        case LCMAPS_RETURN_ACCOUNT_WITHOUT_GSI:
            if ( (lib->lcmaps_return_account_without_gsi=
             (int (*)(char*,char**,int,int,lcmaps_account_info_t*))
                  dlsym(lib->handle,"lcmaps_return_account_without_gsi"))==NULL )
                print_dlerror_and_return;
    }
    

    return 0;
}


/* Loads LCMAPS library and does a run, for given pemstring and to logfile or
 * syslog when logfile is NULL. */
int lcmaps_pem(char *pemstring,FILE *logfile)   {
    int rc;
    lcmaps_library_t lib;
    lcmaps_account_info_t account;

    /* Load lcmaps library and symbols */
    if (loadlcmaps(&lib, LCMAPS_RETURN_ACCOUNT_FROM_PEM))
        return 1;

    /* Do a run */
    if ( (rc=lib.lcmaps_init(logfile))  )   {
        fprintf(stderr,"lcmaps_init() failed\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_account_info_init(&account)) )    {
        fprintf(stderr,"lcmaps_account_info_init() failed.\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_return_account_from_pem(pemstring,-1,&account)) )  {
        fprintf(stderr,"lcmaps_return_account_from_pem() failed.\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_term()) )  {
        fprintf(stderr,"lcmaps_term() failed.\n");
        goto finalize;
    }
    /* LCMAPS finished succesfully */
    rc=0;
    printf("LCMAPS succeeded.\n");

    /* Print contents of account */
    lcmaps_print_account(&account);

finalize:
    /* Close library */
    dlclose(lib.handle);
    return rc;
}

int lcmaps_nogsi_pool(char *my_dn, char *fqan, FILE *logfile)   {
    int rc;
    lcmaps_library_t lib;
    lcmaps_account_info_t account;

    char ** fqans = NULL;

    fqans = malloc(sizeof(char*) * 2);
    fqans[0] = fqan;

    /* Load lcmaps library and symbols */
    if (loadlcmaps(&lib,LCMAPS_RETURN_POOLINDEX_WITHOUT_GSI))
        return 1;

    /* Do a run */
    if ( (rc=lib.lcmaps_init(logfile))  )   {
        fprintf(stderr,"lcmaps_init() failed\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_account_info_init(&account)) )    {
        fprintf(stderr,"lcmaps_account_info_init() failed.\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_return_poolindex_without_gsi(my_dn, fqans, 1, &account)) )  {
        fprintf(stderr,"lib.lcmaps_return_poolindex_without_gsi() failed.\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_term()) )  {
        fprintf(stderr,"lcmaps_term() failed.\n");
        goto finalize;
    }
    /* LCMAPS finished succesfully */
    rc=0;
    printf("LCMAPS succeeded.\n");

    /* Print contents of account */
    lcmaps_print_account(&account);

finalize:
    /* Close library */
    dlclose(lib.handle);
    return rc;
}

int lcmaps_nogsi_account(char *my_dn, char *fqan, FILE *logfile) {
    int rc;
    lcmaps_library_t lib;
    lcmaps_account_info_t account;

    char ** fqans = NULL;

    fqans = malloc(sizeof(char*) * 2);
    fqans[0] = fqan;

    /* Load lcmaps library and symbols */
    if (loadlcmaps(&lib, LCMAPS_RETURN_ACCOUNT_WITHOUT_GSI))
        return 1;

    /* Do a run */
    if ( (rc=lib.lcmaps_init(logfile))  )   {
        fprintf(stderr,"lcmaps_init() failed\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_account_info_init(&account)) )    {
        fprintf(stderr,"lcmaps_account_info_init() failed.\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_return_account_without_gsi(my_dn, fqans, 1, 0, &account)) )  {
        fprintf(stderr,"lcmaps_return_account_from_pem() failed.\n");
        goto finalize;
    }
    if ( (rc=lib.lcmaps_term()) )  {
        fprintf(stderr,"lcmaps_term() failed.\n");
        goto finalize;
    }
    /* LCMAPS finished succesfully */
    rc=0;
    printf("LCMAPS succeeded.\n");

    /* Print contents of account */
    lcmaps_print_account(&account);

finalize:
    /* Close library */
    dlclose(lib.handle);
    return rc;
}


/* Parses the options for LCAS and opens the logfile when needed */
int lcas_set_vars(char *options,char **rsl,FILE **log)  {
    char *var=options,*value,*end,*pos;

    /* If first char of options is a - it's actually the next main option */
    if (options[0]=='-')
        return 0;

    do  {
        /* Find end of current var=value pair */
        end=strchr(var, ',');
        if (end!=NULL) end[0]='\0';
        /* Find end of variable name */
        pos=strchr(var,'=');
        if (pos==NULL)
            fprintf(stderr,"Unrecognized element '%s'\n", var);
        else    {
            pos[0]='\0';
            value=pos+1;
            /* Find the variable */
            if (strcmp(var,"debug")==0)
                setenv("LCAS_DEBUG_LEVEL",value,1);
/*          else if (strcmp(var,"log")==0)
                setenv("LCAS_LOG_LEVEL",value,1);*/
            else if (strcmp(var,"db")==0)
                setenv("LCAS_DB_FILE",value,1);
            else if (strcmp(var,"rsl")==0)
                *rsl=strdup(value);
            else if (strcmp(var,"file")==0) {
                /* Only open when not already linked to stderr */
                if (*log==NULL) {
                    if ( (*log=fopen(value,"a"))==NULL)
                        fprintf(stderr,"Cannot open %s: %s\n",
                                value,strerror(errno));
                }
            }
            else
                fprintf(stderr,"Unrecognized option '%s'\n",var);
            /* reset value at pos */
            pos[0]='=';
        }
        if (end!=NULL)  {
            /* reset value at end */
            end[0]=',';
            /* advance to next option */
            var=end+1;
        }
    } while (end!=NULL);
    return 0;
}
/* Dynamically loads LCAS library and all needed symbols */
int loadlcas(lcas_library_t *lib)       {
    void *handle;

    /* Load the library */
    if ( (lib->handle=handle=
                dlopen("liblcas.so",RTLD_NOW | RTLD_GLOBAL))==NULL )    {
        fprintf(stderr,"Error: %s\n",dlerror());
        return 1;
    }

    /* Load functions */
    if ( (lib->lcas_init=
            (int (*)(FILE*))dlsym(handle,"lcas_init"))==NULL ||
         (lib->lcas_pem=
            (int (*)(char*,lcas_request_t))dlsym(handle,"lcas_pem"))==NULL ||
         (lib->lcas_term=
            (int (*)(void))dlsym(handle,"lcas_term"))==NULL )   {
        fprintf(stderr,"Error: %s\n",dlerror());
        dlclose(handle);
        return 1;
    }

    return 0;
}

/* Loads LCAS library and does a run, for given pemstring and to logfile or
 * syslog when logfile is NULL and given rsl (=cmd + argus) */
int lcas(char *pemstring,FILE *logfile,char *rsl)       {
    int rc;
    lcas_library_t lib;
    lcas_request_t request;

    request=(lcas_request_t)rsl;

    /* Load library and symbols */
    if (loadlcas(&lib))
        return 1;

    /* Do a run */
    if ( (rc=lib.lcas_init(logfile))    )   {
        fprintf(stderr,"lcas_init() failed\n"); goto finalize;
    }
    if ( (rc=lib.lcas_pem(pemstring,request)) )  {
        fprintf(stderr,"lcas_pem() failed.\n"); goto finalize;
    }
    if ( (rc=lib.lcas_term()) )  {
        fprintf(stderr,"lcas_term() failed.\n"); goto finalize;
    }
    printf("LCAS succeeded.\n");

finalize:
    /* Close library */
    dlclose(lib.handle);
    return rc;
}

/* Reads in user proxy (on which mapping is based) from filename */
char *readproxy(const char *filename)   {
    int fd,size;
    char *pemstring;
    struct stat st;

    /* Open file and get size */
    if ((fd=open(filename,O_RDONLY))==-1 || fstat(fd,&st)==-1)  {
        fprintf(stderr,"Error: Cannot open or stat file %s: %s\n",
                filename, strerror(errno));
        exit(1);
    }
    /* Reserve memory */
    if ((pemstring=(char *)malloc((size_t)(st.st_size+sizeof(char))))==NULL) {
        fprintf(stderr,"Error: Cannot malloc %d bytes for pemstring\n",
                (int)st.st_size);
        exit(1);
    }
    /* Read file */
    size=read(fd,pemstring,(size_t)st.st_size);
    if (size!=st.st_size)   {
        fprintf(stderr,"Error: Number of bytes read %d != size %d\n",
               size,(int)st.st_size);
        exit(1);
    }
    /* Close file */
    close(fd);
    /* Add '\0' and return */
    pemstring[size]='\0';
    return pemstring;
}

/* Prints out usage information */
void usage(char *prog)   {
    int uid=(int)getuid();

    printf("Usage: %s [options]\n\n",prog);
    printf("Valid options are:\n"
           " -h        print this help text.\n\n"
           " -s        send output to stderr instead of syslog or file.\n"
           " -q        quiet output (no warnings).\n"
           " -p<file>  read pemstring from given file.\n"
           " -x<file>  set or override X509_USER_PROXY to given file.\n\n"
           " -V<dir>   set or override X509_VOMS_DIR to given dir.\n"
           " -C<dir>   set or override X509_CERT_DIR to given dir.\n\n"
           " -L[opts]  run LCAS with given options: "
           "<var>=<value>,<var=value>,...\n"
           "   db=<file>      set or override LCAS_DB_FILE.\n"
           "   debug=<level>  set or override LCAS_DEBUG_LEVEL.\n"
           /*  "   log=<level>    set or override LCAS_LOG_LEVEL (which is ignored).\n"*/
           "   rsl=<string>   set rsl string (needs to be quoted).\n"
           "   file=<file>    send debug/log output to file instead of "
           "syslog, ignored\n                  when -s is specified.\n"
           "\n -l[opts]  run LCMAPS with given options: "
           "<var>=<value>,<var=value>,...\n"
           "   db=<file>      set or override LCMAPS_DB_FILE.\n"
           "   policy=<name>  set or override LCMAPS_POLICY_NAME.\n"
           "   debug=<level>  set or override LCMAPS_DEBUG_LEVEL.\n"
           /*  "   log=<level>    set or override LCMAPS_LOG_LEVEL (which is ignored).\n"*/
           "   file=<file>    send debug/log output to file instead of "
           "syslog, ignored\n                  when -s is specified.\n\n"
           " LCMAPS normally extracts all information from a PEM string (i.e. a proxy \n"
           " certificate), but it can be run in a mode \"without_gsi\" where the data such\n"
           " as the DN and FQAN are passed as plain strings, as set on the command line.\n"
           " with -d and -f.\n"
           " -m pem          run LCMAPS get_account with full pem string (default).\n"
           " -m nogsi_pi     run LCMAPS return_poolindex_without_gsi\n"
           " -m nogsi_ga     run LCMAPS return_account_without_gsi\n"
           " -d<DN>          use DN (in without_gsi mode)\n"
           " -f<FQAN>        use FQAN (in without_gsi mode)\n"
           );
    printf("\nExample:\n");
    printf(" %s -s -p/tmp/x509up_u%d -x/tmp/x509up_u%d \\\n",prog,uid,uid);
    printf("    -L debug=5,db=/tmp/lcas.db \\\n");
    printf("    -l policy=glexec_get_account,debug=5,db=/tmp/lcmaps.db\n");
    printf("\nNotes on reproducing gLExec behaviour:\n");
    printf("- gLExec uses an LCMAPS policy named 'glexec_get_account'\n");
    printf("- the proxy specified with -p is the analog of the GLEXEC_CLIENT_CERT.\n");

    exit(0);
}

int main(int argc, char *argv[])        {
    extern char *optarg;
    extern int optind, optopt;
    int opt,rc=0;

    /* logfile NULL means logging to syslog */
    FILE *lcmaps_logfile=NULL,*lcas_logfile=NULL;
    int do_lcas=0,do_lcmaps=0,verbose=1;
    char *pemstring=NULL,*rsl=NULL;
    lcmaps_mode_t mode = LCMAPS_RETURN_ACCOUNT_FROM_PEM; 
    char *dn = NULL; 
    char *fqan = NULL; 

    /* Parse the commandline options */
    while ((opt = getopt(argc, argv, ":hsqp:x:V:C:l:L:m:d:f:")) != -1) {
        switch (opt) {
            case 'h':
                usage(argv[0]);
            case 's': /* Do not log to file but to stderr */
                if (lcmaps_logfile && lcmaps_logfile!=stderr)
                    fclose(lcmaps_logfile);
                if (lcas_logfile && lcas_logfile!=stderr)
                    fclose(lcas_logfile);
                lcmaps_logfile=lcas_logfile=stderr;
                break;
            case 'q':
                verbose=0;
                break;
            case 'p':
                pemstring=readproxy(optarg);
                break;
            case 'x':
                setenv("X509_USER_PROXY",optarg,1);
                break;
            case 'V':
                setenv("X509_VOMS_DIR",optarg,1);
                break;
            case 'C':
                setenv("X509_CERT_DIR",optarg,1);
                break;
            case 'l':
                do_lcmaps=1;
                lcmaps_set_vars(optarg,&lcmaps_logfile);
                if (optarg[0]=='-') optind--;
                break;
            case 'L':
                do_lcas=1;
                lcas_set_vars(optarg,&rsl,&lcas_logfile);
                if (optarg[0]=='-') optind--;
                break;
            case 'm':
                if (strcmp(optarg, "pem") == 0) {
                    mode = LCMAPS_RETURN_ACCOUNT_FROM_PEM;
                } else if (strcmp(optarg, "nogsi_pi") == 0) {
                    mode = LCMAPS_RETURN_POOLINDEX_WITHOUT_GSI;
                } else if (strcmp(optarg, "nogsi_ga") == 0) {
                    mode = LCMAPS_RETURN_ACCOUNT_WITHOUT_GSI;
                } else {
                    fprintf(stderr, "option -m requires one of pem, nogsi_pi, nogsi_ga.\n"
                            "Use -h for help.\n");
                    exit(EXIT_FAILURE);
                }
                break;
            case 'd':
                dn = optarg;
                break;
            case 'f':
                fqan = optarg;
                break;
            case ':':
                /* Option did not receive an expected argument (only when last
                 * of line get here, otherwise next option is used as argument),
                 * includes those with optional arguments, i.e. -l and -L */
                switch(optopt)  {
                    case 'l':
                        do_lcmaps=1;
                        break;
                    case 'L':
                        do_lcas=1;
                        break;
                    default:
                        fprintf(stderr,"%s: option requires an argument -- '%c'\n",
                                argv[0],optopt);
                        fprintf(stderr,"Try `%s -h` for more information.\n",argv[0]);
                        exit(1);
                }
                break;
            case '?':
                fprintf(stderr,"%s: invalid option -- '%c'\n", argv[0], optopt);
                fprintf(stderr,"Try `%s -h` for more information.\n",argv[0]);
                exit(1);
        }
    }
    
    /* Check if we have something to do... */
    if (do_lcas==0 && do_lcmaps==0) {
        printf("Nothing to do, see %s -h for valid options.\n",argv[0]);
        return 0;
    }

    /* Print warnings when verbose */
    if (verbose)    {
        if (pemstring==NULL)
            fprintf(stderr,"Warning: Empty pemstring for proxy.\n");
        if (getenv("X509_USER_PROXY")==NULL)
            fprintf(stderr,"Warning: X509_USER_PROXY is not set.\n");
        if (do_lcas)    {
            if (lcas_logfile==NULL)
                fprintf(stderr,"Warning: LCAS logging will go to syslog.\n");
            if (getenv("LCAS_DB_FILE")==NULL)
                fprintf(stderr,"Warning: using LCAS default db file.\n");
        }
        if (do_lcmaps)  {
            if (lcmaps_logfile==NULL)
                fprintf(stderr,"Warning: LCMAPS logging will go to syslog.\n");
            if (getenv("LCMAPS_DB_FILE")==NULL)
                fprintf(stderr,"Warning: using LCMAPS default db file.\n");
            if (getenv("LCMAPS_POLICY_NAME")==NULL)
                fprintf(stderr,"Warning: using LCMAPS default policy name.\n");
            if ( (mode == LCMAPS_RETURN_ACCOUNT_WITHOUT_GSI || 
                  mode == LCMAPS_RETURN_POOLINDEX_WITHOUT_GSI) &&
                 dn == NULL) 
                fprintf(stderr,"Warning: running without GSI with NULL DN string.\n");
        }
    }

    /* Do LCAS when requested */
    if (do_lcas)    {
        rc=lcas(pemstring,lcas_logfile,rsl);
        if (rc!=0) fprintf(stderr,"LCAS failed.\n");
        free(rsl);
    }

    /* Do LCMAPS when requested */
    if (do_lcmaps)  {
        switch (mode) {
            case LCMAPS_RETURN_ACCOUNT_FROM_PEM:
                rc=lcmaps_pem(pemstring,lcmaps_logfile);
                break;
            case LCMAPS_RETURN_POOLINDEX_WITHOUT_GSI:
                rc=lcmaps_nogsi_pool(dn,fqan,lcmaps_logfile);
                break;
            case LCMAPS_RETURN_ACCOUNT_WITHOUT_GSI:
                rc=lcmaps_nogsi_account(dn,fqan,lcmaps_logfile);
        }
        if (rc!=0) fprintf(stderr,"LCMAPS failed.\n");
    }

    free(pemstring);

    return rc;
}
grid.support@nikhef.nl	ViewVC Help
Powered by ViewVC 1.1.28