XrdOucErrInfo.hh

Go to the documentation of this file.

#ifndef __OUC_ERRINFO_H__
#define __OUC_ERRINFO_H__
/******************************************************************************/
/*                                                                            */
/*                      X r d O u c E r r I n f o . h h                       */
/*                                                                            */
/* (c) 2013 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 <string.h>      // For strlcpy()
#include <sys/types.h>

#include "XrdOuc/XrdOucBuffer.hh"
#include "XrdSys/XrdSysPlatform.hh"

/******************************************************************************/
/*                              X r d O u c E I                               */
/******************************************************************************/

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

struct XrdOucEI      // Err information structure
{ 
 static const size_t Max_Error_Len = 2048;
 static const int    Path_Offset   = 1024;

const      char *user;
           int   ucap;
           int   code;
           char  message[Max_Error_Len];

static const int uVMask = 0x0000ffff;  
static const int uAsync = 0x80000000;  
static const int uUrlOK = 0x40000000;  
static const int uMProt = 0x20000000;  
static const int uReadR = 0x10000000;  
static const int uIPv4  = 0x08000000;  
static const int uIPv64 = 0x04000000;  
static const int uPrip  = 0x02000000;  

inline     void clear(const char *usr=0, int uc=0)
                     {code=0; ucap = uc; message[0]='\0';
                      user = (usr ? usr : "?");
                     }

           XrdOucEI &operator =(const XrdOucEI &rhs)
               {code = rhs.code;
                user = rhs.user;
                ucap = rhs.ucap;
                strcpy(message, rhs.message); 
                return *this;
               }
           XrdOucEI(const char *usr, int uc=0) {clear(usr, uc);}
};

/******************************************************************************/
/*                         X r d O u c E r r I n f o                          */
/******************************************************************************/

class XrdOucEICB;
class XrdOucEnv;
class XrdSysSemaphore;

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
  
class XrdOucErrInfo
{
public:

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

       void  clear() {Reset(); ErrInfo.clear();}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline void  setErrArg(unsigned long long cbarg=0) {ErrCBarg = cbarg;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline void  setErrCB(XrdOucEICB *cb, unsigned long long cbarg=0)
                     {ErrCB = cb; ErrCBarg = cbarg;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int   setErrCode(int code) {return ErrInfo.code = code;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int   setErrInfo(int code, const char *emsg)
                {strlcpy(ErrInfo.message, emsg, sizeof(ErrInfo.message));
                 if (dataBuff) {dataBuff->Recycle(); dataBuff = 0;}
                 return ErrInfo.code = code;
                }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int   setErrInfo(int code, const char *txtlist[], int n)
                {int i, j = 0, k = sizeof(ErrInfo.message), l;
                 for (i = 0; i < n && k > 1; i++)
                     {l = strlcpy(&ErrInfo.message[j], txtlist[i], k);
                      j += l; k -= l;
                     }
                 if (dataBuff) {dataBuff->Recycle(); dataBuff = 0;}
                 return ErrInfo.code = code;
                }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int   setErrInfo(int code, XrdOucBuffer *buffP)
                {if (dataBuff) dataBuff->Recycle();
                 dataBuff = buffP;
                 return ErrInfo.code = code;
                }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline void  setErrUser(const char *user) {ErrInfo.user = (user ? user : "?");}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline unsigned long long  getErrArg() {return ErrCBarg;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline char        *getMsgBuff(int &mblen)
                       {mblen = sizeof(ErrInfo.message);
                        return ErrInfo.message;
                       }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline XrdOucEICB  *getErrCB() {return ErrCB;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline XrdOucEICB  *getErrCB(unsigned long long &ap)
                            {ap = ErrCBarg; return ErrCB;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int         getErrInfo() {return ErrInfo.code;}

/*
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int          getErrInfo(XrdOucEI &errParm)
                              {errParm = ErrInfo; return ErrInfo.code;}
*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline const char  *getErrText()
                       {if (dataBuff) return dataBuff->Data();
                        return (const char *)ErrInfo.message;
                       }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline const char  *getErrText(int &ecode)
                       {ecode = ErrInfo.code;
                        if (dataBuff) return dataBuff->Data();
                        return (const char *)ErrInfo.message;
                       }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int          getErrTextLen()
                       {if (dataBuff) return dataBuff->DataLen();
                        return strlen(ErrInfo.message);
                       }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline const char  *getErrUser() {return ErrInfo.user;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline XrdOucEnv   *getEnv() {return (ErrCB ? 0 : ErrEnv);}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline XrdOucEnv   *setEnv(XrdOucEnv *newEnv)
                          {XrdOucEnv *oldEnv = (ErrCB ? 0 : ErrEnv);
                           ErrEnv = newEnv;
                           ErrCB  = 0;
                           return oldEnv;
                          }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline const char  *getErrData() {return (dOff < 0 ? 0 : ErrInfo.message+dOff);}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline void         setErrData(const char *Data, int Offs=0)
                              {if (!Data) dOff = -1;
                                  else {strlcpy(ErrInfo.message+Offs, Data,
                                        sizeof(ErrInfo.message)-Offs);
                                        dOff = Offs;
                                       }
                              }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int          getErrMid() {return mID;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline void         setErrMid(int  mid) {mID = mid;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline bool         extData() {return (dataBuff != 0);}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline void         Reset()
                         {if (dataBuff) {dataBuff->Recycle(); dataBuff = 0;}
                          *ErrInfo.message = 0;
                           ErrInfo.code    = 0;
                         }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int          getUCap() {return ErrInfo.ucap;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline void         setUCap(int ucval) {ErrInfo.ucap = ucval;}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

         XrdOucErrInfo &operator =(const XrdOucErrInfo &rhs)
                        {ErrInfo = rhs.ErrInfo;
                         ErrCB   = rhs.ErrCB;
                         ErrCBarg= rhs.ErrCBarg;
                         mID     = rhs.mID;
                         dOff    = -1;
                         if (rhs.dataBuff) dataBuff = rhs.dataBuff->Clone();
                            else dataBuff = 0;
                         return *this;
                        }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

         XrdOucErrInfo(const char *user=0,XrdOucEICB *cb=0,
                       unsigned long long ca=0, int mid=0, int uc=0)
                    : ErrInfo(user, uc), ErrCB(cb), ErrCBarg(ca), mID(mid),
                      dOff(-1), reserved(0), dataBuff(0) {}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

         XrdOucErrInfo(const char *user, XrdOucEnv *envp, int uc=0)
                    : ErrInfo(user, uc), ErrCB(0), ErrEnv(envp), mID(0),
                      dOff(-1), reserved(0), dataBuff(0) {}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

         XrdOucErrInfo(const char *user, int MonID, int uc=0)
                    : ErrInfo(user, uc), ErrCB(0), ErrCBarg(0), mID(MonID),
                      dOff(-1), reserved(0), dataBuff(0) {}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

virtual ~XrdOucErrInfo() {Reset();}

protected:

XrdOucEI            ErrInfo;
XrdOucEICB         *ErrCB;
union {
unsigned long long  ErrCBarg;
XrdOucEnv          *ErrEnv;
      };
int                 mID;
short               dOff;
short               reserved;
XrdOucBuffer       *dataBuff;
};

/******************************************************************************/
/*                            X r d O u c E I C B                             */
/******************************************************************************/

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

class XrdOucEICB
{
public:

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

virtual void        Done(int           &Result,   //I/O: Function result
                         XrdOucErrInfo *eInfo,    // In: Error Info
                         const char    *Path=0)=0;// In: Relevant path

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

virtual int         Same(unsigned long long arg1, unsigned long long arg2)=0;

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

                    XrdOucEICB() {}
virtual            ~XrdOucEICB() {}
};
#endif