XrdAccGroups Class Reference

#include <XrdAccGroups.hh>

Collaboration diagram for XrdAccGroups:

Public Member Functions
	XrdAccGroups ()
	~XrdAccGroups ()
char *	AddName (const XrdAccGroupType gtype, const char *name)
const char *	Domain ()
char *	FindName (const XrdAccGroupType gtype, const char *name)
XrdAccGroupList *	Groups (const char *user)
XrdAccGroupList *	NetGroups (const char *user, const char *host)
void	PurgeCache ()
int	Retran (const gid_t gid)
void	SetDomain (const char *dname)
void	SetLifetime (const int seconds)
void	SetOptions (XrdAccGroups_Options opts)

Detailed Description

Definition at line 96 of file XrdAccGroups.hh.

Constructor & Destructor Documentation

XrdAccGroups()

XrdAccGroups::XrdAccGroups

(

)

Definition at line 83 of file XrdAccGroups.cc.

{
 
// Do standard initialization
//
   retrancnt = 0; 
   HaveGroups = 0;
   HaveNetGroups = 0;
   options = No_Group_Opt;
   domain = 0;
   LifeTime = 60*60*12;
}

References No_Group_Opt.

~XrdAccGroups()

XrdAccGroups::~XrdAccGroups ( )

inline

Definition at line 149 of file XrdAccGroups.hh.

{}  // The group object never gets deleted!!

Member Function Documentation

AddName()

char * XrdAccGroups::AddName	(	const XrdAccGroupType	gtype,
		const char *	name
	)

Definition at line 100 of file XrdAccGroups.cc.

{
   char *np;
   XrdOucHash<char> *hp;
 
// Prepare to add a group name
//
   if (gtype == XrdAccNetGroup) {hp = &NetGroup_Names; HaveNetGroups = 1;}
      else {hp = &Group_Names; HaveGroups = 1;}
 
// Lock the Name hash table
//
   Group_Name_Context.Lock();
 
// Add a name into the name hash table. We need to only keep a single
// read/only copy of the group name to speed multi-threading.
//
   if (!(np = hp->Find(name)))
      {hp->Add(name, 0, 0, Hash_data_is_key);
       if (!(np = hp->Find(name)))
           std::cerr <<"XrdAccGroups: Unable to add group " <<name <<std::endl;
      }
 
// All done.
//
   Group_Name_Context.UnLock();
   return np;
}

References XrdOucHash< T >::Add(), XrdOucHash< T >::Find(), Hash_data_is_key, XrdSysMutex::Lock(), XrdSysMutex::UnLock(), and XrdAccNetGroup.

Here is the call graph for this function:

Domain()

const char* XrdAccGroups::Domain ( )

inline

Definition at line 102 of file XrdAccGroups.hh.

{return domain;}

Referenced by XrdAccCheckNetGroup().

Here is the caller graph for this function:

FindName()

char * XrdAccGroups::FindName	(	const XrdAccGroupType	gtype,
		const char *	name
	)

Definition at line 133 of file XrdAccGroups.cc.

{
   char *np;
 
// Lock the Name hash table
//
   Group_Name_Context.Lock();
 
// Lookup the actual name in the hash table
//
   if (gtype == XrdAccNetGroup) np = NetGroup_Names.Find(name);
      else np = Group_Names.Find(name);
 
// All done.
//
   Group_Name_Context.UnLock();
   return np;
}

References XrdOucHash< T >::Find(), XrdSysMutex::Lock(), XrdSysMutex::UnLock(), and XrdAccNetGroup.

Here is the call graph for this function:

Groups()

XrdAccGroupList * XrdAccGroups::Groups

(

const char *

user

)

Definition at line 158 of file XrdAccGroups.cc.

{
struct group  *gr;
struct passwd *pw;
char **cp;
XrdAccGroupList *glist;
int   gtabi;
char *Gtab[NGROUPS_MAX];
 
// Check if we have any referenced groups
//
   if (!HaveGroups) return (XrdAccGroupList *)0;
 
 
// Check if we already have this user in the group cache. Since we may be
// modifying the cache, we need to have exclusive control over it. We must
// copy the group cache because the original may be deleted at any time.
//
   Group_Cache_Context.Lock();
   if ((glist = Group_Cache.Find(user)))
      {if (glist->First()) glist = new XrdAccGroupList(*glist);
          else glist = 0;
       Group_Cache_Context.UnLock();
       return glist;
      }
   Group_Cache_Context.UnLock();
 
// If the user has no password file entry, then we have no groups for user.
// All code that tries to construct a group list is protected by the
// Group_Build_Context mutex, obtained after we get the pwd entry.
//
   XrdSysPwd thePwd(user, &pw);
   if (pw == NULL) return (XrdAccGroupList *)0;
 
// Build first entry for the primary group. We will ignore the primary group
// listing later. We do this to ensure that the user has at least one group
// regardless of what the groups file actually says.
//
   Group_Build_Context.Lock();
   gtabi = addGroup(user, pw->pw_gid, 0, Gtab, 0);
 
// Now run through all of the group entries getting the list of user's groups
// Do this only when Primary_Only is not turned on (i.e., SVR5 semantics)
//
   if (!(options & Primary_Only))
      {
       setgrent() ;
       while ((gr = getgrent()))
            {
             if (pw->pw_gid == gr->gr_gid) continue; /*Already have this one.*/
             for (cp = gr->gr_mem; cp && *cp; cp++)
                 if (strcmp(*cp, user) == 0)
                    gtabi = addGroup(user, gr->gr_gid,
                               Dotran(gr->gr_gid,gr->gr_name),
                                     Gtab, gtabi);
            }
       endgrent();
      }
 
// All done with non mt-safe routines
//
   Group_Build_Context.UnLock();
 
// Allocate a new GroupList object
//
   glist = new XrdAccGroupList(gtabi, (const char **)Gtab);
 
// Add this user to the group cache to speed things up the next time
//
   Group_Cache_Context.Lock();
   Group_Cache.Add(user, glist, LifeTime);
   Group_Cache_Context.UnLock();
 
// Return a copy of the group list since the original may be deleted
//
   if (!gtabi) return (XrdAccGroupList *)0;
   return new XrdAccGroupList(gtabi, (const char **)Gtab);
}

References XrdOucHash< T >::Add(), XrdOucHash< T >::Find(), XrdAccGroupList::First(), XrdSysMutex::Lock(), Primary_Only, and XrdSysMutex::UnLock().

Here is the call graph for this function:

NetGroups()

XrdAccGroupList * XrdAccGroups::NetGroups	(	const char *	user,
		const char *	host
	)

Definition at line 241 of file XrdAccGroups.cc.

{
XrdAccGroupList *glist;
int   i, j;
char uh_key[MAXHOSTNAMELEN+96];
struct XrdAccGroupArgs GroupTab;
int XrdAccCheckNetGroup(const char *netgroup, char *key, void *Arg);
 
// Check if we have any Netgroups
//
   if (!HaveNetGroups) return (XrdAccGroupList *)0;
 
// Construct the key for this user
//
   i = strlen(user); j = strlen(host);
   if (i+j+2 > (int)sizeof(uh_key)) return (XrdAccGroupList *)0;
   strcpy(uh_key, user);
   uh_key[i] = '@';
   strcpy(&uh_key[i+1], host);
 
// Check if we already have this user in the group cache. Since we may be
// modifying the cache, we need to have exclusive control over it. We must
// copy the group cache entry because the original may be deleted at any time.
//
   NetGroup_Cache_Context.Lock();
   if ((glist = NetGroup_Cache.Find(uh_key)))
      {if (glist->First()) glist = new XrdAccGroupList(*glist);
          else glist = 0;
       NetGroup_Cache_Context.UnLock();
       return glist;
      }
   NetGroup_Cache_Context.UnLock();
 
// For each known netgroup, check to see if the user is in the netgroup.
//
   GroupTab.user  = user;
   GroupTab.host  = host;
   GroupTab.gtabi = 0;
   Group_Name_Context.Lock();
   NetGroup_Names.Apply(XrdAccCheckNetGroup, (void *)&GroupTab);
   Group_Name_Context.UnLock();
 
// Allocate a new GroupList object
//
   glist = new XrdAccGroupList(GroupTab.gtabi,
                           (const char **)GroupTab.Gtab);
 
// Add this user to the group cache to speed things up the next time
//
   NetGroup_Cache_Context.Lock();
   NetGroup_Cache.Add((const char *)uh_key, glist, LifeTime);
   NetGroup_Cache_Context.UnLock();
 
// Return a copy of the group list
//
   if (!GroupTab.gtabi) return (XrdAccGroupList *)0;
   return new XrdAccGroupList(GroupTab.gtabi,
                          (const char **)GroupTab.Gtab);
}

References XrdOucHash< T >::Add(), XrdOucHash< T >::Apply(), XrdOucHash< T >::Find(), XrdAccGroupList::First(), XrdAccGroupArgs::Gtab, XrdAccGroupArgs::gtabi, XrdAccGroupArgs::host, XrdSysMutex::Lock(), XrdSysMutex::UnLock(), XrdAccGroupArgs::user, and XrdAccCheckNetGroup().

Referenced by XrdAccAccess::Access().

Here is the call graph for this function:

Here is the caller graph for this function:

PurgeCache()

void XrdAccGroups::PurgeCache

(

)

Definition at line 305 of file XrdAccGroups.cc.

{
 
// Purge the group cache
//
   Group_Cache_Context.Lock();
   Group_Cache.Purge();
   Group_Cache_Context.UnLock();
 
// Purge the netgroup cache
//
   NetGroup_Cache_Context.Lock();
   NetGroup_Cache.Purge();
   NetGroup_Cache_Context.UnLock();
}

References XrdSysMutex::Lock(), XrdOucHash< T >::Purge(), and XrdSysMutex::UnLock().

Referenced by XrdAccAccess::SwapTabs().

Here is the call graph for this function:

Here is the caller graph for this function:

Retran()

int XrdAccGroups::Retran

(

const gid_t

gid

)

Definition at line 325 of file XrdAccGroups.cc.

{
    if ((int)gid < 0) retrancnt = 0;
       else {if (retrancnt > (int)(sizeof(retrangid)/sizeof(gid_t))) return -1;
             retrangid[retrancnt++] = gid;
            }
    return 0;
}

SetDomain()

void XrdAccGroups::SetDomain ( const char *  dname )

inline

Definition at line 137 of file XrdAccGroups.hh.

{domain = dname;}

SetLifetime()

void XrdAccGroups::SetLifetime ( const int  seconds )

inline

Definition at line 141 of file XrdAccGroups.hh.

{LifeTime = (int)seconds;}

SetOptions()

void XrdAccGroups::SetOptions ( XrdAccGroups_Options  opts )

inline

Definition at line 145 of file XrdAccGroups.hh.

{options = opts;}

References opts.

---

The documentation for this class was generated from the following files:

• XrdAccGroups.hh
• XrdAccGroups.cc