EIC code displayed by LXR master/​include/​xrootd/​XrdCks/​XrdCksWrapper.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-01-08 10:33:35

 #ifndef __XRDCKSWRAPPER_HH__
 #define __XRDCKSWRAPPER_HH__
 /******************************************************************************/
 /*                                                                            */
 /*                      X r d C k s W r a p p e r . h h                       */
 /*                                                                            */
 /* (c) 2021 by the Board of Trustees of the Leland Stanford, Jr., University  */
 /*                            All Rights Reserved                             */
 /*   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 "XrdCks/XrdCks.hh"
 
 class XrdCksCalc;
 class XrdCksData;
 class XrdOucEnv;
 class XrdOucStream;
 class XrdSysError;
 
 /*! This class defines the wrapper for the checksum management interface.
     It should be used as the base class for a stacked plugin. When used that
     way, the shared library holding the plugin must define a "C" entry point
     named XrdCksAdd2() as described at the end of this include file. Note
     you pass a reference to the previous plugin-in in the plug-in chain as a
     constructor argument as supplied to the XrdCksAdd2() function.
     Override the methods you wish to wrap. Methods that are not overridden
     are forwarded to the previous plug-in.
 */
   
 class XrdCksWrapper : public XrdCks
 {
 public:
 
 //------------------------------------------------------------------------------
 //! Calculate a new checksum for a physical file using the checksum algorithm
 //! named in the Cks parameter.
 //!
 //! @param  Xfn       The logical or physical name of the file to be checksumed.
 //! @param  Cks       For  input, it specifies the checksum algorithm to be used.
 //!                   For output, the checksum value is returned upon success.
 //! @param  doSet     When true, the new value must replace any existing value
 //!                   in the Xfn's extended file attributes.
 //! @param  pcbP      In the second form, the pointer to the callback object.
 //!                   A nil pointer does not invoke any callback.
 //!
 //! @return Success:  zero with Cks structure holding the checksum value.
 //!         Failure: -errno (see significant error numbers below).
 //------------------------------------------------------------------------------
 virtual
 int        Calc( const char *Xfn, XrdCksData &Cks, int doSet=1)
                {return cksPI.Calc(Xfn, Cks, doSet);}
 
 virtual
 int        Calc( const char *Xfn, XrdCksData &Cks, XrdCksPCB *pcbP, int doSet=1)
                {(void)pcbP; return Calc(Xfn, Cks, doSet);}
 
 //------------------------------------------------------------------------------
 //! Delete the checksum from the Xfn's xattrs.
 //!
 //! @param  Xfn      The logical or physical name of the file to be checksumed.
 //! @param  Cks      Specifies the checksum type to delete.
 //!
 //! @return Success: 0
 //!         Failure: -errno (see significant error numbers below).
 //------------------------------------------------------------------------------
 virtual
 int        Del(  const char *Xfn, XrdCksData &Cks)
               {return cksPI.Del(Xfn, Cks);}
 
 //------------------------------------------------------------------------------
 //! Retreive the checksum from the Xfn's xattrs and return it and indicate
 //! whether or not it is stale (i.e. the file modification has changed or the
 //! name and length are not the expected values).
 //!
 //! @param  Xfn      The logical or physical name of the file to be checksumed.
 //! @param  Cks      For  input, it specifies the checksum type to return.
 //!                  For output, the checksum value is returned upon success.
 //!
 //! @return Success: The length of the binary checksum in the Cks structure.
 //!         Failure: -errno (see significant error numbers below).
 //------------------------------------------------------------------------------
 virtual
 int        Get(  const char *Xfn, XrdCksData &Cks)
               {return cksPI.Get(Xfn, Cks);}
 
 //------------------------------------------------------------------------------
 //! Parse a configuration directives specific to the checksum manager.
 //!
 //! @param  Token    Points to the directive that triggered the call.
 //! @param  Line     All the characters after the directive.
 //!
 //! @return Success:  1
 //!         Failure:  0
 //------------------------------------------------------------------------------
 virtual
 int        Config(const char *Token, char *Line)
                  {return cksPI.Config(Token, Line);}
 
 //------------------------------------------------------------------------------
 //! Fully initialize the manager which includes loading any plugins.
 //!
 //! @param  ConfigFN Points to the configuration file path.
 //! @param  DfltCalc Is the default checksum and should be defaulted if NULL.
 //!                  The default implementation defaults this to adler32. A
 //!                  default is only needed should the checksum name in the
 //!                  XrdCksData object be omitted.
 //!
 //!@return Success:  1
 //!        Failure:  0
 //------------------------------------------------------------------------------
 virtual
 int        Init(const char *ConfigFN, const char *DfltCalc=0)
                {return cksPI.Init(ConfigFN, DfltCalc);}
 
 //------------------------------------------------------------------------------
 //! List names of the checksums associated with a Xfn or all supported ones.
 //!
 //! @param  Xfn      The logical or physical file name whose checksum names are
 //!                  to be returned. When Xfn is null, return all supported
 //!                  checksum algorithm names.
 //! @param  Buff     Points to a buffer, at least 64 bytes in length, to hold
 //!                  a "Sep" separated list of checksum names.
 //! @param  Blen     The length of the buffer.
 //! @param  Sep      The separation character to be used between adjacent names.
 //!
 //! @return Success: Pointer to Buff holding at least one checksum name.
 //!         Failure: A nil pointer is returned.
 //------------------------------------------------------------------------------
 virtual
 char      *List(const char *Xfn, char *Buff, int Blen, char Sep=' ')
                {return cksPI.List(Xfn, Buff, Blen, Sep);}
 
 //------------------------------------------------------------------------------
 //! Get the name of the checksums associated with a sequence number. Note that
 //! Name() may be called prior to final config to see if there are any chksums
 //! to configure and avoid unintended errors.
 //!
 //! @param  seqNum   The sequence number. Zero signifies the default name.
 //!                  Higher numbers are alternates.
 //! @return Success: Pointer to the name.
 //!         Failure: A nil pointer is returned (no more alternates exist).
 //------------------------------------------------------------------------------
 virtual const
 char      *Name(int seqNum=0) {return cksPI.Name(seqNum);}
 
 //------------------------------------------------------------------------------
 //! Get a new XrdCksCalc object that can calculate the checksum corresponding to
 //! the specified name or the default object if name is a null pointer. The
 //! object can be used to compute checksums on the fly. The object's Recycle()
 //! method must be used to delete it.
 //!
 //! @param  name     The name of the checksum algorithm. If null, use the
 //!                  default one.
 //!
 //! @return Success: A pointer to the object is returned.
 //!         Failure: Zero if no corresponding object exists.
 //------------------------------------------------------------------------------
 virtual
 XrdCksCalc *Object(const char *name) {return cksPI.Object(name);}
 
 //------------------------------------------------------------------------------
 //! Get the binary length of the checksum with the corresponding name.
 //!
 //! @param  Name     The checksum algorithm name. If null, use the default name.
 //!
 //! @return Success: checksum length.
 //!         Failure: Zero  if the checksum name does not exist.
 //------------------------------------------------------------------------------
 virtual
 int        Size( const char  *Name=0) {return cksPI.Size(Name);}
 
 //------------------------------------------------------------------------------
 //! Set a file's checksum in the extended attributes along with the file's mtime
 //! and the time of setting.
 //!
 //! @param  Xfn      The logical or physical name of the file to be set.
 //! @param  Cks      Specifies the checksum name and value.
 //! @param  myTime   When true then the fmTime and gmTime in the Cks structure
 //!                  are to be used; as opposed to the current time.
 //!
 //! @return Success:  zero is returned.
 //!         Failure: -errno (see significant error numbers below).
 //------------------------------------------------------------------------------
 virtual
 int        Set(  const char *Xfn, XrdCksData &Cks, int myTime=0)
               {return cksPI.Set(Xfn, Cks, myTime);}
 
 //------------------------------------------------------------------------------
 //! Retreive the checksum from the Xfn's xattrs and compare it to the supplied
 //! checksum. If the checksum is not available or is stale, a new checksum is
 //! calculated and written to the extended attributes.
 //!
 //! @param  Xfn      The logical or physical name of the file to be verified.
 //! @param  Cks      Specifies the checksum name and value.
 //! @param  pcbP      In the second form, the pointer to the callback object.
 //!                   A nil pointer does not invoke any callback.
 //!
 //! @return Success: True
 //!         Failure: False (the checksums do not match) or -errno indicating
 //!                  that verification could not be performed (see significant
 //!                  error numbers below).
 //------------------------------------------------------------------------------
 virtual
 int        Ver(  const char *Xfn, XrdCksData &Cks)
               {return cksPI.Ver(Xfn, Cks);}
 
 virtual
 int        Ver(  const char *Xfn, XrdCksData &Cks, XrdCksPCB *pcbP)
               {(void)pcbP; return Ver(Xfn, Cks);}
 
 //------------------------------------------------------------------------------
 //! Constructor
 //!
 //! @param  prevPI   Reference to the antecedent plugin.
 //! @param  errP     Pointer to error message object
 //------------------------------------------------------------------------------
 
            XrdCksWrapper(XrdCks &prevPI, XrdSysError *errP)
                         : XrdCks(errP), cksPI(prevPI) {}
 
 //------------------------------------------------------------------------------
 //! Destructor
 //------------------------------------------------------------------------------
 
 virtual   ~XrdCksWrapper() {}
 
 protected:
 
 XrdCks &cksPI;
 };
 
 /******************************************************************************/
 /*                            X r d C k s A d d 2                             */
 /******************************************************************************/
 
 #define XRDCKSADD2PARMS XrdCks &, XrdSysError *, const char *, \
                         const char *, XrdOucEnv *
   
 //------------------------------------------------------------------------------
 //! Obtain an instance of a stacked checksum manager.
 //!
 //! XrdCksAdd2() is an extern "C" function that is called to obtain an
 //! instance of a stacked checksum manager object that will be used for all
 //! subsequent checksums. This function is passed a refernce to the previous
 //! checksum manager. Overridden methods should, if appropriate, invoke the
 //! previous plug-ins corresponding method to complete the required task.
 //! All the following extern symbols must be defined at file level!
 //!
 //! @param pPI  -> Reference to the previous checksum manager plug-in.
 //! @param eDest-> The XrdSysError object for messages.
 //! @param cFN  -> The name of the configuration file
 //! @param Parm -> Parameters specified on the ckslib directive. If none it is
 //!                zero.
 //! @param pEnv -> Pointer to environmental information or nil.
 //!
 //! @return Success: A pointer to the checksum manager object.
 //!         Failure: Null pointer which causes initialization to fail.
 //------------------------------------------------------------------------------
 
 /*! extern "C" XrdCks *XrdCksAdd2(XrdCks      &pPI,
                                   XrdSysError *eDest,
                                   const char  *cFN,
                                   const char  *Parm,
                                   XrdOucEnv   *envP
                                   );
 */
 //------------------------------------------------------------------------------
 //! Declare the compilation version number.
 //!
 //! Additionally, you *should* declare the xrootd version you used to compile
 //! your plug-in. While not currently required, it is highly recommended to
 //! avoid execution issues should the class definition change. Declare it as:
 //------------------------------------------------------------------------------
 
 /*! #include "XrdVersion.hh"
     XrdVERSIONINFO(XrdCksAdd2,<name>);
 
     where <name> is a 1- to 15-character unquoted name identifying your plugin.
 */
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team