XrdSecInterface.hh

Go to the documentation of this file.

#ifndef __SEC_INTERFACE_H__
#define __SEC_INTERFACE_H__
/******************************************************************************/
/*                                                                            */
/*                    X r d S e c I n t e r f a c e . h h                     */
/*                                                                            */
/* (c) 2005 by the Board of Trustees of the Leland Stanford, Jr., University  */
/*   Produced by Andrew Hanushevsky for Stanford University under contract    */
/*              DE-AC02-76-SFO0515 with the Department of Energy              */
/*                                                                            */
/* This file is part of the XRootD software suite.                            */
/*                                                                            */
/* XRootD is free software: you can redistribute it and/or modify it under    */
/* the terms of the GNU Lesser General Public License as published by the     */
/* Free Software Foundation, either version 3 of the License, or (at your     */
/* option) any later version.                                                 */
/*                                                                            */
/* XRootD is distributed in the hope that it will be useful, but WITHOUT      */
/* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or      */
/* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public       */
/* License for more details.                                                  */
/*                                                                            */
/* You should have received a copy of the GNU Lesser General Public License   */
/* along with XRootD in a file called COPYING.LESSER (LGPL license) and file  */
/* COPYING (GPL license).  If not, see <http://www.gnu.org/licenses/>.        */
/*                                                                            */
/* The copyright holder's institutional names and contributor's names may not */
/* be used to endorse or promote products derived from this software without  */
/* specific prior written permission of the institution or contributor.       */
/******************************************************************************/
 
#include <cerrno>
#ifndef WIN32
#include <sys/param.h>
#endif
#include <cstdlib>
#include <cstdio>
#include <cstring>
 
#include "XrdSec/XrdSecEntity.hh"
 
/******************************************************************************/
/*  X r d S e c C r e d e n t i a l s   &   X r d S e c P a r a m e t e r s   */
/******************************************************************************/
  
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
struct XrdSecBuffer
{
       int   size;    
       char *buffer;  
 
       XrdSecBuffer(char *bp=0, int sz=0) : size(sz), buffer(bp), membuf(bp) {}
      ~XrdSecBuffer() {if (membuf) free(membuf);}
 
private:
        char *membuf; // Stable copy of the buffer address
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
typedef XrdSecBuffer XrdSecCredentials;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
typedef XrdSecBuffer XrdSecParameters;
  
/******************************************************************************/
/*                        X r d S e c P r o t o c o l                         */
/******************************************************************************/
class XrdOucErrInfo;
 
class XrdSecProtocol
{
public:
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
XrdSecEntity               Entity;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual int                Authenticate  (XrdSecCredentials  *cred,
                                          XrdSecParameters  **parms,
                                          XrdOucErrInfo      *einfo=0)=0;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual XrdSecCredentials *getCredentials(XrdSecParameters   *parm=0,
                                          XrdOucErrInfo      *einfo=0)=0;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual int     Encrypt(const char    *inbuff,  // Data to be encrypted
                              int      inlen,   // Length of data in inbuff
                        XrdSecBuffer **outbuff  // Returns encrypted data
                             ) 
{
  (void) inbuff; (void) inlen; (void) outbuff;
  return -ENOTSUP;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual int     Decrypt(const char  *inbuff,   // Data to be decrypted
                              int    inlen,    // Length of data in inbuff
                      XrdSecBuffer **outbuff   // Buffer for decrypted data
                              ) 
{
  (void) inbuff; (void) inlen; (void) outbuff;
  return -ENOTSUP;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual int     Sign(const char  *inbuff,   // Data to be signed
                           int    inlen,    // Length of data in inbuff
                   XrdSecBuffer **outbuff   // Buffer for the signature
                           ) 
{
  (void) inbuff; (void) inlen; (void) outbuff;
  return -ENOTSUP;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual int     Verify(const char  *inbuff,   // Data to be decrypted
                             int    inlen,    // Length of data in inbuff
                       const char  *sigbuff,  // Buffer for signature
                             int    siglen)   // Length if signature
{
  (void) inbuff; (void) inlen; (void) sigbuff; (void) siglen;
  return -ENOTSUP;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual int     getKey(char *buff = 0, int size = 0) 
{
  (void) buff; (void) size;
  return -ENOTSUP;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual int     setKey(char *buff, int size) 
{
  (void) buff; (void) size;
  return -ENOTSUP;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual bool    needTLS() {return false;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual void    Delete()=0; // Normally does "delete this"
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
              XrdSecProtocol(const char *pName) : Entity(pName) {}
protected:
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual      ~XrdSecProtocol() {}
};
 
/******************************************************************************/
/*           P r o t o c o l   N a m i n g   C o n v e n t i o n s            */
/******************************************************************************/
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
/******************************************************************************/
/*            P r o t o c o l   O b j e c t   M a n a g e m e n t             */
/******************************************************************************/
 
  
/******************************************************************************/
/*                     X r d S e c G e t P r o t o c o l                      */
/*                                                                            */
/*                  C l i e n t   S i d e   U S e   O n l y                   */
/******************************************************************************/
  
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
typedef XrdSecProtocol *(*XrdSecGetProt_t)(const char *hostname,
                                           XrdNetAddrInfo &endPoint,
                                           XrdSecParameters &sectoken,
                                           XrdOucErrInfo *einfo);
 
/******************************************************************************/
/*                   X r d S e c G e t P r o t e c t i o n                    */
/*                                                                            */
/*                  C l i e n t   S i d e   U s e   O n l y                   */
/******************************************************************************/
  
/******************************************************************************/
/*                         X r d S e c S e r v i c e                          */
/*                                                                            */
/*                  S e r v e r   S i d e   U s e   O n l y                   */
/******************************************************************************/
  
class XrdSecService
{
public:
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual const char     *getParms(int &size, XrdNetAddrInfo *endPoint=0) = 0;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual XrdSecProtocol *getProtocol(const char              *host,    // In
                                          XrdNetAddrInfo    &endPoint,// In
                                    const XrdSecCredentials *cred,    // In
                                          XrdOucErrInfo     &einfo)=0;// Out
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual bool            PostProcess(XrdSecEntity  &entity,
                                    XrdOucErrInfo &einfo) {return true;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual const char     *protTLS()=0;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
                        XrdSecService() {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
virtual                ~XrdSecService() {}
};
  
/******************************************************************************/
/*                      X r d g e t S e c S e r v i c e                       */
/******************************************************************************/
  
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class XrdSysLogger;
typedef XrdSecService  *(*XrdSecGetServ_t)(XrdSysLogger *, const char *);
 
#endif