lcmaps_afs.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>,
 *      Gerben Venekamp <venekamp@nikhef.nl>,
 *      NIKHEF Amsterdam, the Netherlands
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>
#include <gssapi.h>

#include "lcmaps_config.h"
#include "lcmaps_modules.h"
#include "lcmaps_arguments.h"


/*  Default values for options.  */
static const char* default_lifetime = "12:00";

/*  The following option may be set.  */
static char* lifetime = NULL;
static char* port     = NULL;
static char* server   = NULL;
static char* gsiklog  = NULL;
static char* cell     = NULL;
static char* setpag   = NULL;

static int argv_count = 0;

int run_cmd(char* cmd, char* argv[]);
int fail_afs(void);
int check_argument(const char* name, char** value, unsigned int num, int argc, char* argv[], int* pos);
int construct_argv(char* cmd, char** argv[]);
void destruct_argv(char** argv[]);


/******************************************************************************
Function:   plugin_introspect
Description:
    return list of required arguments
Parameters:

Returns:
    LCMAPS_MOD_SUCCESS : succes
    LCMAPS_MOD_FAIL    : failure
******************************************************************************/
int plugin_introspect(int *argc, lcmaps_argument_t **argv)
{
  static lcmaps_argument_t argList[] = {
    { "job_request", "lcmaps_request_t",  1, NULL},
    { "user_cred"  , "gss_cred_id_t"   ,  0, NULL},
    { NULL         , NULL              , -1, NULL}
  };
  
  lcmaps_log_debug(1, "\tlcmaps_afs: plugin_introspect(): introspecting\n");
  
  *argv = argList;
  *argc = lcmaps_cntArgs(argList);
  lcmaps_log_debug(1, "\tlcmaps_afs: plugin_introspect(): address first argument: 0x%x\n",argList);
  
  return LCMAPS_MOD_SUCCESS;
}

/******************************************************************************
Function:   plugin_initialize
Description:
    Initialize plugin
    Everything that is needed to initialize the plugin should be put
    inside this function.  Arguments as read from the LCMAPS database
    (argc, argv) are passed to the plugin.
Parameters:
    argc, argv
    argv[0]: the name of the plugin
Returns:
    LCMAPS_MOD_SUCCESS : succes
    LCMAPS_MOD_FAIL    : failure
    LCMAPS_MOD_NOFILE  : db file not found (will halt LCMAPS initialization)
******************************************************************************/
int plugin_initialize(int argc, char **argv)
{
  int i;
  
  lcmaps_log_debug(1, "\tlcmaps_afs: plugin_initialize(): passed arguments:\n");
  for (i=1; i<argc; i++) {
    if (argv[i][0] != '-') {
      lcmaps_log(0, "\tlcmaps_afs: plugin_initialize(): Could not interpret arg[%d] = '%s'.\n", i, argv[i]);
      lcmaps_log(0, "\tlcmaps_afs:                    : Skipping argument...\n");
      continue;
    }

    lcmaps_log_debug(2, "\tlcmaps_afs: plugin_initialize(): arg %d is %s\n", i, argv[i]);

    if (check_argument("-lifetime", &lifetime, 1, argc, argv, &i) == LCMAPS_MOD_FAIL) return LCMAPS_MOD_FAIL; else continue;
    if (check_argument("-server",   &server,   1, argc, argv, &i) == LCMAPS_MOD_FAIL) return LCMAPS_MOD_FAIL; else continue;
    if (check_argument("-cell",     &cell,     1, argc, argv, &i) == LCMAPS_MOD_FAIL) return LCMAPS_MOD_FAIL; else continue;
    if (check_argument("-port",     &port,     1, argc, argv, &i) == LCMAPS_MOD_FAIL) return LCMAPS_MOD_FAIL; else continue;
    if (check_argument("-setpag",   &setpag,   0, argc, argv, &i) == LCMAPS_MOD_FAIL) return LCMAPS_MOD_FAIL; else continue;
    if (check_argument("-gsiklog",  &gsiklog,  0, argc, argv, &i) == LCMAPS_MOD_FAIL) return LCMAPS_MOD_FAIL; else continue;
  }

  return LCMAPS_MOD_SUCCESS;
}


int check_argument(const char* name, char** value, unsigned int num,
                   int argc, char* argv[], int* pos)
{
  /*
   *  Value should be a NULL pointer, if not, it should point to
   *  allocated memory; in which case memory is freeed and the
   *  pointer set to NULL.
   */
  if (*value) {
    free(*value);
    *value = NULL;
  }

  /*  Check if the argument is recognized.  */
  if (strcmp(argv[*pos], name)==0) {
    lcmaps_log(0, "\tlcmaps_afs: plugin_initialize(): Found argument %s.\n", name);
    /*  Does the argument need a value?  */
    if (num==1) {
      /*  Protect ourselves to reading past the argv list.  */
      if ((*pos+num)<(argc)) {
        if (!(*value = strdup(argv[*pos+1]))) {
          lcmaps_log(0, "\tlcmaps_afs: plugin_initialize(): Could not allocate memory.\n");
          return LCMAPS_MOD_FAIL;
        }
        lcmaps_log(0, "\tlcmaps_afs:                    : With value = '%s'\n", *value);
      } else {
        /*
         *  We have to have a value for the given argument. Since,
         *  we have reached the end of the argv list the sysadmin
         *  must have forgotten to specify it. We could silently
         *  ignor this mistake and supply a default value. However
         *  it is best that the sysadmin corrects this problem.
         */
        lcmaps_log(0, "\tlcmaps_afs: plugin_initialize(): Could not read additional values.\n");
        lcmaps_log(0, "\tlcmaps_afs:                    : Please correct configuration file.\n");
        return LCMAPS_MOD_FAIL;
      }
    } else if (!(*value = strdup(name))) {
      lcmaps_log(0, "\tlcmaps_afs: plugin_initialize(): Could not allocate memory.\n");
      return LCMAPS_MOD_FAIL;
    }

    *pos += num+1;
    argv_count += num+1;
  }

  return LCMAPS_MOD_SUCCESS;
}


int plugin_run(int argc, lcmaps_argument_t *argv)
{
  char*  cmd      = "gssklog";
  char** cmd_argv = NULL;
  char*  logstr   = "\tlcmaps_afs: plugin_run()";

  gss_cred_id_t *pcred = NULL;
  gss_cred_id_t  cred  = GSS_C_NO_CREDENTIAL;

  lcmaps_log_debug(1, "\tlcmaps_afs: plugin_run():\n");

  if (getuid()==0) {
    lcmaps_log(0, "%s: Afs plugin is run as root.\n", logstr);
    lcmaps_log(0, "%s: Exit afs plugin.\n", logstr);

    return -1;
  }

  /* Fetch user gss credential */
  if ((pcred = (gss_cred_id_t *)lcmaps_getArgValue("user_cred", "gss_cred_id_t", argc, argv))) {
    lcmaps_log_debug(2, "%s: Address user_cred: %p\n", logstr, pcred);
    cred = *pcred;

    if (cred == GSS_C_NO_CREDENTIAL) {
      lcmaps_log(0, "%s: User gss credential is empty.\n", logstr);
      lcmaps_log(0, "%s: Exit afs plugin.\n", logstr);

      return fail_afs();
    }
  } else {
    lcmaps_log(0, "%s: Could not get address of user_cred.\n", logstr);
    lcmaps_log(0, "%s: Exit afs plugin.\n", logstr);

    return fail_afs();
  }

  if (cred) {
    gss_buffer_desc  deleg_proxy_filename;
    OM_uint32        major_status = 0;
    OM_uint32        minor_status = 0;
        
    major_status = gss_export_cred(&minor_status,
                                   cred,
                                   NULL,
                                   1,
                                   &deleg_proxy_filename);

    if (major_status == GSS_S_COMPLETE) {
      char *cp;

      cp = strchr((char *)deleg_proxy_filename.value, '=');
      *cp = '\0';
      cp++;
      setenv((char *)deleg_proxy_filename.value, cp, 1);
      free(deleg_proxy_filename.value);
    } else {
      char *error_str = NULL;
      globus_object_t *error_obj;
      
      error_obj = globus_error_get((globus_result_t)minor_status);
      
      error_str = globus_error_print_chain(error_obj);
      
      lcmaps_log(0, "%s: Error, gss_export_cred(): %s\n", logstr, error_str);
    }
  }

  /* for gssapi_ssleay if we received delegated proxy certificate
   * they will be in a file in tmp pointed at by the 
   * X509_USER_DELEG_PROXY env variable. 
   * This will be owned by the current uid, we need this owned by
   * the user.
   * for other gss, this is a noop, since X509_USER_DELEG_PROXY 
   * should not be defined.
   */

  /*
   * the proxyfile is probably already owned by the current user,
   * so commented out
   */
//    {
//        char *proxyfile;
//        if ((proxyfile = getenv("X509_USER_PROXY")) != NULL)
//        {
//            chown(proxyfile,uid[0],priGid[0]);
//        }
//    }
  
  lcmaps_log_debug(1, "\tlcmaps_afs: plugin_run(): address first argument: 0x%x\n", argv);

  if (construct_argv(cmd, &cmd_argv) && (run_cmd(cmd, cmd_argv) != 0)) {
  lcmaps_log(0, "\tlcmaps_afs: construct_argv: cmd_argv = %x.\n", cmd_argv);
    destruct_argv(&cmd_argv);
    return fail_afs();
  }

  destruct_argv(&cmd_argv);

  //  rc = system(cmd);
  
  //  switch(rc) {
  //  case 0:   /*  Everything seems to be okay.  */
  //    break;
  //  default:
  //    lcmaps_log(0, "%s: gssklog returned unknown error: rc = %d", logstr, rc);
  //  }

  /*  succes  */
  if(getenv("X509_USER_PROXY")) {
    remove(getenv("X509_USER_PROXY"));
  }

  return LCMAPS_MOD_SUCCESS;
}


int construct_argv(char* cmd, char** argv[])
{
  int i;

  lcmaps_log_debug(0, "\tlcmaps_afs: construct_argv: Max number of elements of argv = %d.\n", argv_count);

  if (!(*argv = (char**)calloc(argv_count+2, sizeof(char *)))) {
    lcmaps_log(0, "\tlcmaps_afs: construct_argv: Could not allocate memory.\n");
    return 0;
  }

  i = 0;
  if (!((*argv)[i++] = strdup(cmd))) {
    lcmaps_log(0, "\tlcmaps_afs: construct_argv: Could not allocate memory.\n");
    return 0;
  }

  if (!((*argv)[i++] = strdup("-lifetime"))) {
    lcmaps_log(0, "\tlcmaps_afs: construct_argv: Could not allocate memory.\n");
    return 0;
  }

  if (lifetime)
    (*argv)[i++] = lifetime;
  else {
    if (!((*argv)[i++] = strdup(default_lifetime))) {
      lcmaps_log(0, "\tlcmaps_afs: construct_argv: Could not allocate memory.\n");
      return 0;
    }
  }

  lcmaps_log_debug(0, "\tlcmaps_afs: construct_argv: Constructed argv:\n");
  i = 0;
  while ((*argv)[i]) {
    lcmaps_log_debug(0, "\tlcmaps_afs: construct_argv: arg[%d] = '%s'.\n",i, (*argv)[i]);
    i++;
  }

  return 1;
}


void destruct_argv(char** argv[])
{
  int i;

  if (*argv) {
    for (i=0; i<argv_count; i++) {
      free(argv[i]);
    }
    free(argv);

    *argv = NULL;
  }
}


int run_cmd(char* cmd, char* argv[])
{
  int i, rc = 0;
  int child_status;
  pid_t term;
  char c;
  FILE* fr;
  pid_t pid;
  int pipe_fd[2];
  char *logstr = "\tlcmaps_afs: run_cmd()";

  struct sigaction sa, old_sa;

  sa.sa_handler = SIG_DFL;
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = 0;

  if (sigaction(SIGCHLD, &sa, &old_sa) == -1) {
    lcmaps_log(0, "%s: sigaction failed: %s\n", logstr, sys_errlist[errno]);
    return 1;
  }

  //  Create the read and write descriptors for the pipe.
  if (pipe(pipe_fd) < 0 ) {
    lcmaps_log(0, "%s: pipe failed: %s\n", logstr, sys_errlist[errno]);
    return 1;
  }

  lcmaps_log(0, "%s: executing: '%s'\n", logstr, cmd);
  for (i=1; argv[i]!=NULL; ++i)
    lcmaps_log(0, "%s:          :  argv[%d]: '%s'\n", logstr, i, argv[i]);
  
  lcmaps_log(0, "%s: -- begin output of '%s':\n", logstr, cmd);

  if ((pid = fork()) < 0) {
    //  Oops, it's an error!
    lcmaps_log(0, "%s: fork failed: %s\n", logstr, sys_errlist[errno]);
    return -1;
  } if (pid == 0) {
    //  Child process.
    close(pipe_fd[0]);
    dup2(pipe_fd[1], 1);   //  Redirect stdin
    dup2(pipe_fd[1], 2);   //  Redirect stderr
    close(pipe_fd[1]);

    execvp(cmd, argv);  //  Does not return when successful.

    lcmaps_log(0, "%s: execution of %s failed.\n", logstr, cmd);
    lcmaps_log(0, "%s:    %s.\n", logstr, sys_errlist[errno]);

    exit(-1);
  }

  //  Parent process.
  close(pipe_fd[1]);

  fr = fdopen(pipe_fd[0], "r");

  lcmaps_log(0, "\tlcmaps_afs:   gssklog: ");
  c = fgetc(fr);
  if (c != EOF) {
    do {
      if (c == '\n') {
        fprintf(stderr, "%c", c);
        lcmaps_log(0, "\tlcmaps_afs:   gssklog: ");
      } else
        fprintf(stderr, "%c", c);
    } while ((c = fgetc(fr))!=EOF);
  }

  fclose(fr);

  fprintf(stderr, "\n");

  lcmaps_log(0, "%s: -- end output of '%s'\n", logstr, cmd);

  if ((term = wait(&child_status)) > 0) {
    if (WIFEXITED(child_status))
      lcmaps_log_debug(0, "%s: '%s' exit status: rc = %d\n", logstr, cmd, WEXITSTATUS(child_status));
    else if (WIFSIGNALED(child_status))
      lcmaps_log_debug(0, "%s: '%s' terminated by signal %d\n", logstr, cmd, WTERMSIG(child_status));
    else if (WIFSTOPPED(child_status))
      lcmaps_log_debug(0, "%s: '%s' stopped by signal %d\n", logstr, cmd, WSTOPSIG(child_status));
    else
      lcmaps_log(0, "%s: '%s' abnormal exit.\n", logstr, cmd);
  } else {
    lcmaps_log(0, "%s: waiting for '%s' failed:\n", logstr, cmd);
    lcmaps_log(0, "%s: reason: %s\n", logstr, sys_errlist[errno]);
    rc = 1;
  }

  if (sigaction(SIGCHLD, &old_sa, NULL) == -1) {
    lcmaps_log(0, "%s: sigaction failed: %s\n", logstr, sys_errlist[errno]);
    lcmaps_log(0, "%s:                 : Old sigaction value has not been restored.\n", logstr);
    return 1;
  }

  close(pipe_fd[0]);

  return 0;
}


int fail_afs(void) {

  if(getenv("X509_USER_PROXY")) {
    remove(getenv("X509_USER_PROXY"));
  }
  
  return LCMAPS_MOD_FAIL;
}


int plugin_terminate()
{
  lcmaps_log_debug(1,"\tlcmaps_afs: plugin_terminate(): terminating\n");
  
  return LCMAPS_MOD_SUCCESS;
}

---