voms_api.h

Go to the documentation of this file.

/*********************************************************************
 *
 * Authors: Vincenzo Ciaschini - Vincenzo.Ciaschini@cnaf.infn.it 
 *
 * Copyright (c) Members of the EGEE Collaboration. 2004-2010.
 * See http://www.eu-egee.org/partners/ for details on the copyright holders.
 *
 * 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.
 *
 * Parts of this code may be based upon or even include verbatim pieces,
 * originally written by other people, in which case the original header
 * follows.
 *
 *********************************************************************/
 
#ifndef VOMS_API_H
#define VOMS_API_H
 
#include <fstream>
#include <string>
#include <vector>
 
extern "C" {
#ifndef GSSAPI_H_
/*
 *  Also check against _GSSAPI_H_ as that is what the Kerberos 5 code defines and
 *  what header files on some systems look for.
 */
 
#ifndef _GSSAPI_H_
typedef void * gss_cred_id_t;
typedef void * gss_ctx_id_t;
#endif
#endif
 
#include <openssl/x509.h>
#include <openssl/bio.h>
#include <sys/types.h>
#include "newformat.h"
}

struct data {
  std::string group; 
  std::string role;  
  std::string cap;   
};

struct attribute {
  std::string name;      
  std::string qualifier; 
  std::string value;     
};
 
struct attributelist {
  std::string grantor;               
  std::vector<attribute> attributes; 
};
 

enum data_type { 
  TYPE_NODATA,  
  TYPE_STD,     
  TYPE_CUSTOM   
};
 
struct contactdata {   
  std::string  nick;    
  std::string  host;    
  std::string  contact; 
  std::string  vo;      
  int          port;          
 
  int          version;  
};
 
class vomspriv;
 
struct voms {
  friend class vomsdata;
  int version;             
  int siglen;              
  std::string signature;   
  std::string user;        
  std::string userca;      
  std::string server;      
  std::string serverca;    
  std::string voname;      
  std::string uri;         
  std::string date1;       
  std::string date2;       
  data_type type;          
  std::vector<data> std;   
  std::string custom;      
  /* Data below this line only makes sense if version >= 1 */
  std::vector<std::string> fqan; 
  std::string serial;      
  /* Data below this line is private. */
 
private:
  void *realdata;                  
  X509 *holder;
public:
  voms(const voms &);
  voms();
  voms &operator=(const voms &);
  ~voms();
 
private:
  struct vomsr *translate();
  friend int TranslateVOMS(struct vomsdatar *vd, std::vector<voms>&v, int *error);
 
public:
  AC *GetAC();
 
public:
  std::vector<attributelist>& GetAttributes();   
  std::vector<std::string> GetTargets();
 
private:
  vomspriv *vp;
};
 
enum recurse_type { 
  RECURSE_CHAIN, 
  RECURSE_NONE,
  RECURSE_DEEP
};
 
enum verify_type {
  VERIFY_FULL      = 0xffffffff,
  VERIFY_NONE      = 0x00000000,
  VERIFY_DATE      = 0x00000001,
  VERIFY_TARGET    = 0x00000002,
  VERIFY_KEY       = 0x00000004,
  VERIFY_SIGN      = 0x00000008,
  VERIFY_ORDER     = 0x00000010,
  VERIFY_ID        = 0x00000020,
  VERIFY_CERTLIST  = 0x00000040
};

enum verror_type { 
  VERR_NONE,
  VERR_NOSOCKET,   
  VERR_NOIDENT,    
  VERR_COMM,       
  VERR_PARAM,      
  VERR_NOEXT,      
  VERR_NOINIT,     
  VERR_TIME,       
  VERR_IDCHECK,    
  VERR_EXTRAINFO,  
  VERR_FORMAT,     
  VERR_NODATA,     
  VERR_PARSE,      
  VERR_DIR,        
  VERR_SIGN,       
  VERR_SERVER,     
  VERR_MEM,        
  VERR_VERIFY,     
  //  VERR_IDENT, 
  VERR_TYPE,       
  VERR_ORDER,      
  VERR_SERVERCODE, 
  VERR_NOTAVAIL,   
  VERR_FILE        
};
 
typedef bool (*check_sig)(X509 *, void *, verror_type &); 
 
class vomsdatapriv;
 
struct vomsdata {
  private:
  class Initializer {
  public:
    Initializer();
  private:
    Initializer(Initializer &);
  };
 
  private:
  static Initializer init;
  std::string ca_cert_dir;
  std::string voms_cert_dir;
  int duration;
  std::string ordering;
  std::vector<contactdata> servers;
  std::vector<std::string> targets;
 
  public:
  verror_type error; 
 
  static void SkipSslInitialization();
 
  vomsdata(std::string voms_dir = "", 
           std::string cert_dir = ""); 
 
  bool LoadSystemContacts(std::string dir = ""); 
  bool LoadUserContacts(std::string dir = ""); 
 
  std::vector<contactdata> FindByAlias(std::string alias); 
 
 
  std::vector<contactdata> FindByVO(std::string vo); 
 
 
  void Order(std::string att); 
 
  void ResetOrder(void); 
 
  void AddTarget(std::string target);         
 
  std::vector<std::string> ListTargets(void); 
 
  void ResetTargets(void);        
  std::string ServerErrors(void); 
 
  bool Retrieve(X509 *cert, STACK_OF(X509) *chain, 
                recurse_type how = RECURSE_CHAIN);   
  bool Contact(std::string hostname, int port, 
               std::string servsubject, 
               std::string command); 
  bool Contact(std::string hostname, int port, 
               std::string servsubject, 
               std::string command,
               int timeout); 
 
  bool ContactRaw(std::string hostname, int port, 
                  std::string servsubject, 
                  std::string command,
                  std::string &raw,
      int& version);  
  bool ContactRaw(std::string hostname, int port, 
                  std::string servsubject, 
                  std::string command,
                  std::string &raw,
      int& version,
      int timeout);  
 
  void SetVerificationType(verify_type how); 
 
  void SetLifetime(int lifetime); 
 
  bool Import(std::string buffer);
  bool Export(std::string &data); 
  bool DefaultData(voms &); 
 
  std::vector<voms> data; 
  std::string workvo;     
  std::string extra_data; 
private:
  bool loadfile(std::string, uid_t uid, gid_t gid);
  bool loadfile0(std::string, uid_t uid, gid_t gid);
  bool verifydata(std::string &message, std::string subject, std::string ca, 
                  X509 *holder, voms &v);
  bool check_cert(X509 *cert);
  bool retrieve(X509 *cert, STACK_OF(X509) *chain, recurse_type how,
                AC_SEQ **listnew, std::string &subject, std::string &ca,
                X509 **holder);
  verify_type ver_type;
 
  std::string serverrors;
  std::string errmessage;
  
  void seterror(verror_type, std::string);
 
  bool check_sig_ac(X509 *, void *);
  X509 *check(void *);
  bool contact(const std::string&, int, const std::string&,
               const std::string&, std::string&, std::string&,
               std::string&, int timeout);
  bool verifydata(AC *ac, const std::string& subject, const std::string& ca, 
                  X509 *holder, voms &v);
  bool evaluate(AC_SEQ *, const std::string&, const std::string&, X509*);
 
public:
 
  std::string ErrorMessage(void); 
 
  bool RetrieveFromCtx(gss_ctx_id_t context, recurse_type how); 
 
  bool RetrieveFromCred(gss_cred_id_t credential, recurse_type how);  
 
  bool Retrieve(X509_EXTENSION *ext); 
 
  bool RetrieveFromProxy(recurse_type how); 
 
  bool Retrieve(FILE *file, recurse_type how); 
 
  bool Retrieve(AC *ac);
 
  ~vomsdata();
private:
  //  X509 *check_file(void *);
  bool check_cert(STACK_OF(X509) *);
  X509 *check_from_certs(AC *ac, const std::string& voname);
  X509 *check_from_file(AC *, std::ifstream&, const std::string &vo, const std::string &filename);
 
public:
  vomsdata(const vomsdata &);
 
private:
  int retry_count;
  
public:
  void SetRetryCount(int retryCount);
  
public:
  void SetVerificationTime(time_t);
                                  
private:
  time_t verificationtime;
  bool verifyac(X509 *, X509 *, AC*, time_t, voms&);
 
public:
  bool LoadCredentials(X509*, EVP_PKEY *, STACK_OF(X509) *);
  bool ContactRESTRaw(const std::string&, int, const std::string&, std::string&, int, int);
 
private:
  bool InterpretOutput(const std::string&, std::string&);
 
private:
  vomsdatapriv *vdp;
};
 
 
extern "C" {
int getVOMSMajorVersionNumber(void);
int getVOMSMinorVersionNumber(void);
int getVOMSPatchVersionNumber(void);
}
 
#endif