#include <cctype>
#include <cstdio>
#include <ctime>
#include <sys/param.h>
#include "XrdVersion.hh"
#include "XrdAcc/XrdAccAccess.hh"
#include "XrdAcc/XrdAccEntity.hh"
#include "XrdAcc/XrdAccCapability.hh"
#include "XrdAcc/XrdAccConfig.hh"
#include "XrdAcc/XrdAccGroups.hh"
#include "XrdNet/XrdNetAddrInfo.hh"
#include "XrdOuc/XrdOucUtils.hh"
#include "XrdSec/XrdSecEntityAttr.hh"
#include "XrdSys/XrdSysPlugin.hh"

Include dependency graph for XrdAccAccess.cc:

Macros
#define	XrdAccSWAP(x)

Functions
XrdAccAuthorize *	XrdAccDefaultAuthorizeObject (XrdSysLogger lp, const char cfn, const char *parm, XrdVersionInfo &urVer)

unsigned long	XrdOucHashVal2 (const char *KeyVal, int KeyLen)

Variables
XrdAccConfig	XrdAccConfiguration

Macro Definition Documentation

◆ XrdAccSWAP

#define XrdAccSWAP ( x )

Value:

oldtab.x = Atab.x; Atab.x = newtab.x; \

newtab.x = oldtab.x; oldtab.x = 0;

Definition at line 351 of file XrdAccAccess.cc.

{
   struct XrdAccAccess_Tables oldtab;
   bool hRefX = false, hRefY = false;
 
// Determine if we need to resolve the host name early
//
   XrdAccAccess_ID *xlP = newtab.SXList;
   while(xlP)
        {if (xlP->host) {hRefX = true; break;}
         xlP = xlP->next;
        }
 
// Determine if we need to resolve the hostname at all.
//
   if (!hRefX)
      {if (newtab.D_List || newtab.H_Hash || newtab.N_Hash) hRefY = true;
          else {XrdAccAccess_ID *ylP = newtab.SYList;
                while (ylP)
                      {if (ylP->host) {hRefY = true; break;}
                       ylP = ylP->next;
                      }
               }
      }
 
// Get an exclusive context to change the table pointers
//
   Access_Context.Lock(xs_Exclusive);
 
// Save the old pointer while replacing it with the new pointer
//
   XrdAccSWAP(D_List);
   XrdAccSWAP(E_List);
   XrdAccSWAP(G_Hash);
   XrdAccSWAP(H_Hash);
   XrdAccSWAP(N_Hash);
   XrdAccSWAP(O_Hash);
   XrdAccSWAP(R_Hash);
   XrdAccSWAP(S_Hash);
   XrdAccSWAP(T_Hash);
   XrdAccSWAP(U_Hash);
   XrdAccSWAP(X_List);
   XrdAccSWAP(Z_List);
   XrdAccSWAP(SXList);
   XrdAccSWAP(SYList);
   hostRefX = hRefX;
   hostRefY = hRefY;
 
// When we set new access tables, we should purge the group cache
//
   XrdAccConfiguration.GroupMaster.PurgeCache();
 
// We can now let loose new table searchers
//
   Access_Context.UnLock(xs_Exclusive);
}
 
/******************************************************************************/
/*                                  T e s t                                   */
/******************************************************************************/
 
int XrdAccAccess::Test(const XrdAccPrivs priv,const Access_Operation oper)
{
 
// Warning! This table must be in 1-to-1 correspondence with Access_Operation
//
   static XrdAccPrivs need[] = {XrdAccPriv_None,                 // 0
                                XrdAccPriv_Chmod,                // 1
                                XrdAccPriv_Chown,                // 2
                                XrdAccPriv_Create,               // 3
                                XrdAccPriv_Delete,               // 4
                                XrdAccPriv_Insert,               // 5
                                XrdAccPriv_Lock,                 // 6
                                XrdAccPriv_Mkdir,                // 7
                                XrdAccPriv_Read,                 // 8
                                XrdAccPriv_Readdir,              // 9
                                XrdAccPriv_Rename,               // 10
                                XrdAccPriv_Lookup,               // 11
                                XrdAccPriv_Update,               // 12
                                (XrdAccPrivs)0xffff,             // 13
                                (XrdAccPrivs)0xffff              // 14
                               };
   // Note AOP_Excl* does not have a corresponding XrdAccPrivs; this is on
   // purpose as the Excl* privilege is not modelled within the AuditDB framework.
   if (oper < 0 || oper > AOP_LastOp) return 0;
   return (int)(need[oper] & priv) == need[oper];
}
 
/******************************************************************************/
/*              X r d A c c A c c e s s _ I D : : A p p l i e s               */
/******************************************************************************/
  
bool XrdAccAccess_ID::Applies(const XrdAccEntityInfo &Entity)
{
 
// Check single value items in the most probable use order
//
   if (org  && (!Entity.vorg || strcmp(org,  Entity.vorg))) return false;
   if (role && (!Entity.role || strcmp(role, Entity.role))) return false;
   if (grp  && (!Entity.grup || strcmp(grp,  Entity.grup))) return false;
   if (user && (!Entity.name || strcmp(user, Entity.name))) return false;
 
// The check is more complicated as the host field may be a domain.
//
   if (host)
      {const char *hName;
       if (*host == '.')
          {int eLen = strlen(Entity.host);
           if (eLen <= hlen) return false;
           hName = Entity.host + eLen - hlen;
          } else hName = Entity.host;
       if (strcmp(host, hName)) return false;
      }
 
// All done, this rules applies!
//
   return true;
}

Function Documentation

◆ XrdAccDefaultAuthorizeObject()

XrdAccAuthorize * XrdAccDefaultAuthorizeObject	(	XrdSysLogger *	lp,
		const char *	cfn,
		const char *	parm,
		XrdVersionInfo &	urVer
	)

Definition at line 64 of file XrdAccAccess.cc.

{
   static XrdVERSIONINFODEF(myVer, XrdAcc, XrdVNUMBER, XrdVERSION);
   static XrdSysError Eroute(lp, "acc_");
 
// Verify version compatibility
//
   if (urVer.vNum != myVer.vNum && !XrdSysPlugin::VerCmp(urVer,myVer))
      return 0;
 
// Configure the authorization system
//
   if (XrdAccConfiguration.Configure(Eroute, cfn)) return (XrdAccAuthorize *)0;
 
// Set error object pointer
//
   XrdAccEntity::setError(&Eroute);
 
// All is well, return the actual pointer to the object
//
   return (XrdAccAuthorize *)XrdAccConfiguration.Authorization;
}

References XrdAccConfig::Authorization, XrdAccConfig::Configure(), XrdAccEntity::setError(), XrdSysPlugin::VerCmp(), XrdAccConfiguration, and XrdVERSIONINFODEF().

Referenced by main(), and XrdAccAuthorizeObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ XrdOucHashVal2()

unsigned long XrdOucHashVal2	(	const char *	KeyVal,
		int	KeyLen
	)

extern

Definition at line 40 of file XrdOucHashVal.cc.

{  int j;
   unsigned long *lp, lword, hval = 0;
   int hl = sizeof(hval);
 
// If name is shorter than the hash length, use the name.
//
   if (KeyLen <= hl)
      {memcpy(&hval, KeyVal, (size_t)KeyLen);
       return hval;
      }
 
// Compute the length of the name and develop starting hash.
//
   hval = KeyLen;
   j = KeyLen % hl; KeyLen /= hl;
   if (j) 
      {memcpy(&lword, KeyVal, (size_t)hl);
       hval ^= lword;
      }
   lp = (unsigned long *)&KeyVal[j];
 
// Compute and return the full hash.
//
   while(KeyLen--)
        {memcpy(&lword, lp++, (size_t)hl);
         hval ^= lword;
        }
   return (hval ? hval : 1);
}

Referenced by XrdAccCapability::XrdAccCapability(), XrdAccAccess::Access(), XrdAccCapability::Privs(), and XrdAccCapability::Privs().

Here is the caller graph for this function:

Variable Documentation

◆ XrdAccConfiguration

XrdAccConfig XrdAccConfiguration

extern

Definition at line 61 of file XrdAccConfig.cc.

Referenced by XrdAccAccess::Access(), XrdAccAccess::SwapTabs(), XrdAccConfig_Refresh(), and XrdAccDefaultAuthorizeObject().

Macros

Functions