Inheritance diagram for Sabre\DAVACL\Plugin:

Collaboration diagram for Sabre\DAVACL\Plugin:

Public Member Functions
	getFeatures ()
	Returns a list of features added by this plugin. More...

	getMethods ($uri)
	Returns a list of available methods for a given url. More...

	getPluginName ()
	Returns a plugin name. More...

	getSupportedReportSet ($uri)
	Returns a list of reports this plugin supports. More...

	checkPrivileges ($uri, $privileges, $recursion=self::R_PARENT, $throwExceptions=true)
	Checks if the current user has the specified privilege(s). More...

	getCurrentUserPrincipals ()
	Returns a list of principals that's associated to the current user, either directly or through group membership. More...

	setDefaultAcl (array $acl)
	Sets the default ACL rules. More...

	getDefaultAcl ()
	Returns the default ACL rules. More...

	getPrincipalMembership ($mainPrincipal)
	Returns all the principal groups the specified principal is a member of. More...

	principalMatchesPrincipal ($checkPrincipal, $currentPrincipal=null)
	Find out of a principal equals another principal. More...

	getSupportedPrivilegeSet ($node)
	Returns a tree of supported privileges for a resource. More...

	getFlatPrivilegeSet ($node)
	Returns the supported privilege set as a flat list. More...

	getAcl ($node)
	Returns the full ACL list. More...

	getCurrentUserPrivilegeSet ($node)
	Returns a list of privileges the current user has on a particular node. More...

	getPrincipalByUri ($uri)
	Returns a principal based on its uri. More...

	principalSearch (array $searchProperties, array $requestedProperties, $collectionUri=null, $test='allof')
	Principal property search. More...

	initialize (DAV\Server $server)
	Sets up the plugin. More...

	beforeMethod (RequestInterface $request, ResponseInterface $response)
	Triggered before any method is handled. More...

	beforeBind ($uri)
	Triggered before a new node is created. More...

	beforeUnbind ($uri)
	Triggered before a node is deleted. More...

	beforeUnlock ($uri, DAV\Locks\LockInfo $lock)
	Triggered before a node is unlocked. More...

	propFind (DAV\PropFind $propFind, DAV\INode $node)
	Triggered before properties are looked up in specific nodes. More...

	propPatch ($path, DAV\PropPatch $propPatch)
	This method intercepts PROPPATCH methods and make sure the group-member-set is updated correctly. More...

	report ($reportName, $report, $path)
	This method handles HTTP REPORT requests. More...

	httpAcl (RequestInterface $request, ResponseInterface $response)
	This method is responsible for handling the 'ACL' event. More...

	htmlActionsPanel (DAV\INode $node, &$output)
	This method is used to generate HTML output for the DAV. More...

	getPluginInfo ()
	Returns a bunch of meta-data about the plugin. More...

Public Member Functions inherited from Sabre\DAV\ServerPlugin
	initialize (Server $server)
	This initializes the plugin. More...

	getFeatures ()
	This method should return a list of server-features. More...

	getHTTPMethods ($path)
	Use this method to tell the server this plugin defines additional HTTP methods. More...

	getPluginName ()
	Returns a plugin name. More...

	getSupportedReportSet ($uri)
	Returns a list of reports this plugin supports. More...

	getPluginInfo ()
	Returns a bunch of meta-data about the plugin. More...

Data Fields
const	R_PARENT = 1
	Recursion constants. More...

const	R_RECURSIVE = 2
	Recursion constants. More...

const	R_RECURSIVEPARENTS = 3
	Recursion constants. More...

	$principalCollectionSet

	$hideNodesFromListings = false

	$principalSearchPropertySet

	$adminPrincipals = []

	$allowUnauthenticatedAccess = true

Protected Member Functions
	principalMatchReport ($path, Xml\Request\PrincipalMatchReport $report)
	The principal-match report is defined in RFC3744, section 9.3. More...

	expandPropertyReport ($path, $report)
	The expand-property report is defined in RFC3253 section 3.8. More...

	expandProperties ($path, array $requestedProperties, $depth)
	This method expands all the properties and returns a list with property values. More...

	principalSearchPropertySetReport ($path, $report)
	principalSearchPropertySetReport More...

	principalPropertySearchReport ($path, Xml\Request\PrincipalPropertySearchReport $report)
	principalPropertySearchReport More...

	aclPrincipalPropSetReport ($path, Xml\Request\AclPrincipalPropSetReport $report)
	aclPrincipalPropSet REPORT More...

Protected Attributes
	$server

	$defaultAcl

	$principalMembershipCache = []

Detailed Description

SabreDAV ACL Plugin.

This plugin provides functionality to enforce ACL permissions. ACL is defined in RFC3744.

In addition it also provides support for the {DAV:}current-user-principal property, defined in RFC5397 and the {DAV:}expand-property report, as defined in RFC3253.

Copyright: Copyright (C) fruux GmbH (https://fruux.com/)

Author: Evert Pot (http://evertpot.com/) http://sabre.io/license/ Modified BSD License

Definition at line 31 of file Plugin.php.

Member Function Documentation

◆ aclPrincipalPropSetReport()

Sabre\DAVACL\Plugin::aclPrincipalPropSetReport	(		$path,
		Xml\Request\AclPrincipalPropSetReport	$report
	)

protected

aclPrincipalPropSet REPORT

This method is responsible for handling the {DAV:}acl-principal-prop-set REPORT, as defined in:

https://tools.ietf.org/html/rfc3744#section-9.2

This REPORT allows a user to quickly fetch information about all principals specified in the access control list. Most commonly this is used to for example generate a UI with ACL rules, allowing you to show names for principals for every entry.

Parameters

string	$path
Xml\Request\AclPrincipalPropSetReport	$report

Returns: void

Definition at line 1544 of file Plugin.php.

References $path.

Referenced by Sabre\DAVACL\Plugin\report().

                                                                                                        {
 
         if ($this->server->getHTTPDepth(0) !== 0) {
             throw new BadRequest('The {DAV:}acl-principal-prop-set REPORT only supports Depth 0');
         }
 
         // Fetching ACL rules for the given path. We're using the property
         // API and not the local getACL, because it will ensure that all
         // business rules and restrictions are applied.
         $acl = $this->server->getProperties($path, '{DAV:}acl');
 
         if (!$acl || !isset($acl['{DAV:}acl'])) {
             throw new Forbidden('Could not fetch ACL rules for this path');
         }
 
         $principals = [];
         foreach ($acl['{DAV:}acl']->getPrivileges() as $ace) {
 
             if ($ace['principal'][0] === '{') {
                 // It's not a principal, it's one of the special rules such as {DAV:}authenticated
                 continue;
             }
 
             $principals[] = $ace['principal'];
 
         }
 
         $properties = $this->server->getPropertiesForMultiplePaths(
             $principals,
             $report->properties
         );
 
         $this->server->httpResponse->setStatus(207);
         $this->server->httpResponse->setHeader('Content-Type', 'application/xml; charset=utf-8');
         $this->server->httpResponse->setBody(
             $this->server->generateMultiStatus($properties)
         );
 
     }

Here is the caller graph for this function:

◆ beforeBind()

Sabre\DAVACL\Plugin::beforeBind ( $uri )

Triggered before a new node is created.

This allows us to check permissions for any operation that creates a new node, such as PUT, MKCOL, MKCALENDAR, LOCK, COPY and MOVE.

Parameters

string $uri

Returns: void

Definition at line 942 of file Plugin.php.

References Sabre\DAVACL\Plugin\checkPrivileges(), and Sabre\Uri\split().

                               {
 
         list($parentUri) = Uri\split($uri);
         $this->checkPrivileges($parentUri, '{DAV:}bind');
 
     }

Here is the call graph for this function:

◆ beforeMethod()

Sabre\DAVACL\Plugin::beforeMethod	(	RequestInterface	$request,
		ResponseInterface	$response
	)

Triggered before any method is handled.

Parameters

RequestInterface	$request
ResponseInterface	$response

Returns: void

Definition at line 873 of file Plugin.php.

References $path, Sabre\DAVACL\Plugin\checkPrivileges(), Sabre\HTTP\RequestInterface\getMethod(), and Sabre\HTTP\RequestInterface\getPath().

                                                                                   {
 
         $method = $request->getMethod();
         $path = $request->getPath();
 
         $exists = $this->server->tree->nodeExists($path);
 
         // If the node doesn't exists, none of these checks apply
         if (!$exists) return;
 
         switch ($method) {
 
             case 'GET' :
             case 'HEAD' :
             case 'OPTIONS' :
                 // For these 3 we only need to know if the node is readable.
                 $this->checkPrivileges($path, '{DAV:}read');
                 break;
 
             case 'PUT' :
             case 'LOCK' :
                 // This method requires the write-content priv if the node
                 // already exists, and bind on the parent if the node is being
                 // created.
                 // The bind privilege is handled in the beforeBind event.
                 $this->checkPrivileges($path, '{DAV:}write-content');
                 break;
 
             case 'UNLOCK' :
                 // Unlock is always allowed at the moment.
                 break;
 
             case 'PROPPATCH' :
                 $this->checkPrivileges($path, '{DAV:}write-properties');
                 break;
 
             case 'ACL' :
                 $this->checkPrivileges($path, '{DAV:}write-acl');
                 break;
 
             case 'COPY' :
             case 'MOVE' :
                 // Copy requires read privileges on the entire source tree.
                 // If the target exists write-content normally needs to be
                 // checked, however, we're deleting the node beforehand and
                 // creating a new one after, so this is handled by the
                 // beforeUnbind event.
                 //
                 // The creation of the new node is handled by the beforeBind
                 // event.
                 //
                 // If MOVE is used beforeUnbind will also be used to check if
                 // the sourcenode can be deleted.
                 $this->checkPrivileges($path, '{DAV:}read', self::R_RECURSIVE);
                 break;
 
         }
 
     }

Here is the call graph for this function:

◆ beforeUnbind()

Sabre\DAVACL\Plugin::beforeUnbind ( $uri )

Triggered before a node is deleted.

This allows us to check permissions for any operation that will delete an existing node.

Parameters

string $uri

Returns: void

Definition at line 958 of file Plugin.php.

References Sabre\DAVACL\Plugin\checkPrivileges(), and Sabre\Uri\split().

                                 {
 
         list($parentUri) = Uri\split($uri);
         $this->checkPrivileges($parentUri, '{DAV:}unbind', self::R_RECURSIVEPARENTS);
 
     }

Here is the call graph for this function:

◆ beforeUnlock()

Sabre\DAVACL\Plugin::beforeUnlock	(		$uri,
		DAV\Locks\LockInfo	$lock
	)

Triggered before a node is unlocked.

Parameters

string	$uri
DAV\Locks\LockInfo	$lock	: not yet implemented

Returns: void

Definition at line 973 of file Plugin.php.

                                                           {
 
     }

◆ checkPrivileges()

Sabre\DAVACL\Plugin::checkPrivileges	(	$uri,
		$privileges,
		$recursion = `self::R_PARENT`,
		$throwExceptions = `true`
	)

Checks if the current user has the specified privilege(s).

You can specify a single privilege, or a list of privileges. This method will throw an exception if the privilege is not available and return true otherwise.

Parameters

string	$uri
array \| string	$privileges
int	$recursion
bool	$throwExceptions	if set to false, this method won't throw exceptions.

Exceptions

NeedPrivileges
NotAuthenticated

Returns: bool

Definition at line 192 of file Plugin.php.

References $authPlugin, $failed, and Sabre\DAVACL\Plugin\getCurrentUserPrivilegeSet().

Referenced by Sabre\DAVACL\Plugin\beforeBind(), Sabre\DAVACL\Plugin\beforeMethod(), Sabre\DAVACL\Plugin\beforeUnbind(), and Sabre\DAVACL\Plugin\propFind().

                                                                                                     {
 
         if (!is_array($privileges)) $privileges = [$privileges];
 
         $acl = $this->getCurrentUserPrivilegeSet($uri);
 
         $failed = [];
         foreach ($privileges as $priv) {
 
             if (!in_array($priv, $acl)) {
                 $failed[] = $priv;
             }
 
         }
 
         if ($failed) {
             if ($this->allowUnauthenticatedAccess && is_null($this->getCurrentUserPrincipal())) {
                 // We are not authenticated. Kicking in the Auth plugin.
                 $authPlugin = $this->server->getPlugin('auth');
                 $reasons = $authPlugin->getLoginFailedReasons();
                 $authPlugin->challenge(
                     $this->server->httpRequest,
                     $this->server->httpResponse
                 );
                 throw new notAuthenticated(implode(', ', $reasons) . '. Login was needed for privilege: ' . implode(', ', $failed) . ' on ' . $uri);
             }
             if ($throwExceptions) {
 
                 throw new NeedPrivileges($uri, $failed);
             } else {
                 return false;
             }
         }
         return true;
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ expandProperties()

Sabre\DAVACL\Plugin::expandProperties	(		$path,
		array	$requestedProperties,
			$depth
	)

protected

This method expands all the properties and returns a list with property values.

Parameters

array	$path
array	$requestedProperties	the list of required properties
int	$depth

Returns: array

Definition at line 1392 of file Plugin.php.

References $path, and $result.

Referenced by Sabre\DAVACL\Plugin\expandPropertyReport().

                                                                                    {
 
         $foundProperties = $this->server->getPropertiesForPath($path, array_keys($requestedProperties), $depth);
 
         $result = [];
 
         foreach ($foundProperties as $node) {
 
             foreach ($requestedProperties as $propertyName => $childRequestedProperties) {
 
                 // We're only traversing if sub-properties were requested
                 if (count($childRequestedProperties) === 0) continue;
 
                 // We only have to do the expansion if the property was found
                 // and it contains an href element.
                 if (!array_key_exists($propertyName, $node[200])) continue;
 
                 if (!$node[200][$propertyName] instanceof DAV\Xml\Property\Href) {
                     continue;
                 }
 
                 $childHrefs = $node[200][$propertyName]->getHrefs();
                 $childProps = [];
 
                 foreach ($childHrefs as $href) {
                     // Gathering the result of the children
                     $childProps[] = [
                         'name'  => '{DAV:}response',
                         'value' => $this->expandProperties($href, $childRequestedProperties, 0)[0]
                     ];
                 }
 
                 // Replacing the property with its expanded form.
                 $node[200][$propertyName] = $childProps;
 
             }
             $result[] = new DAV\Xml\Element\Response($node['href'], $node);
 
         }
 
         return $result;
 
     }

Here is the caller graph for this function:

◆ expandPropertyReport()

Sabre\DAVACL\Plugin::expandPropertyReport	(	$path,
		$report
	)

protected

The expand-property report is defined in RFC3253 section 3.8.

This report is very similar to a standard PROPFIND. The difference is that it has the additional ability to look at properties containing a {DAV:}href element, follow that property and grab additional elements there.

Other rfc's, such as ACL rely on this report, so it made sense to put it in this plugin.

Parameters

string	$path
Xml\Request\ExpandPropertyReport	$report

Returns: void

Definition at line 1366 of file Plugin.php.

References $path, $result, $xml, and Sabre\DAVACL\Plugin\expandProperties().

Referenced by Sabre\DAVACL\Plugin\report().

                                                             {
 
         $depth = $this->server->getHTTPDepth(0);
 
         $result = $this->expandProperties($path, $report->properties, $depth);
 
         $xml = $this->server->xml->write(
             '{DAV:}multistatus',
             new DAV\Xml\Response\MultiStatus($result),
             $this->server->getBaseUri()
         );
         $this->server->httpResponse->setHeader('Content-Type', 'application/xml; charset=utf-8');
         $this->server->httpResponse->setStatus(207);
         $this->server->httpResponse->setBody($xml);
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getAcl()

Sabre\DAVACL\Plugin::getAcl ( $node )

Returns the full ACL list.

Either a uri or a INode may be passed.

null will be returned if the node doesn't support ACLs.

Parameters

string | DAV\INode $node

Returns: array

Definition at line 587 of file Plugin.php.

References Sabre\DAVACL\Plugin\getDefaultAcl().

                            {
 
         if (is_string($node)) {
             $node = $this->server->tree->getNodeForPath($node);
         }
         if (!$node instanceof IACL) {
             return $this->getDefaultAcl();
         }
         $acl = $node->getACL();
         foreach ($this->adminPrincipals as $adminPrincipal) {
             $acl[] = [
                 'principal' => $adminPrincipal,
                 'privilege' => '{DAV:}all',
                 'protected' => true,
             ];
         }
         return $acl;
 
     }

Here is the call graph for this function:

◆ getCurrentUserPrincipals()

Sabre\DAVACL\Plugin::getCurrentUserPrincipals ( )

Returns a list of principals that's associated to the current user, either directly or through group membership.

Returns: array

Definition at line 255 of file Plugin.php.

References Sabre\DAVACL\Plugin\getPrincipalMembership().

Referenced by Sabre\DAVACL\Plugin\principalMatchReport().

                                         {
 
         $currentUser = $this->getCurrentUserPrincipal();
 
         if (is_null($currentUser)) return [];
 
         return array_merge(
             [$currentUser],
             $this->getPrincipalMembership($currentUser)
         );
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCurrentUserPrivilegeSet()

Sabre\DAVACL\Plugin::getCurrentUserPrivilegeSet ( $node )

Returns a list of privileges the current user has on a particular node.

Either a uri or a DAV may be passed.

null will be returned if the node doesn't support ACLs.

Parameters

string | DAV\INode $node

Returns: array

Definition at line 618 of file Plugin.php.

References $current, Sabre\DAVACL\Plugin\getFlatPrivilegeSet(), and Sabre\DAVACL\Plugin\principalMatchesPrincipal().

Referenced by Sabre\DAVACL\Plugin\checkPrivileges(), and Sabre\DAVACL\Plugin\propFind().

                                                {
 
         if (is_string($node)) {
             $node = $this->server->tree->getNodeForPath($node);
         }
 
         $acl = $this->getACL($node);
 
         $collected = [];
 
         $isAuthenticated = $this->getCurrentUserPrincipal() !== null;
 
         foreach ($acl as $ace) {
 
             $principal = $ace['principal'];
 
             switch ($principal) {
 
                 case '{DAV:}owner' :
                     $owner = $node->getOwner();
                     if ($owner && $this->principalMatchesPrincipal($owner)) {
                         $collected[] = $ace;
                     }
                     break;
 
 
                 // 'all' matches for every user
                 case '{DAV:}all' :
                     $collected[] = $ace;
                     break;
 
                 case '{DAV:}authenticated' :
                     // Authenticated users only
                     if ($isAuthenticated) {
                         $collected[] = $ace;
                     }
                     break;
 
                 case '{DAV:}unauthenticated' :
                     // Unauthenticated users only
                     if (!$isAuthenticated) {
                         $collected[] = $ace;
                     }
                     break;
 
                 default :
                     if ($this->principalMatchesPrincipal($ace['principal'])) {
                         $collected[] = $ace;
                     }
                     break;
 
             }
 
 
         }
 
         // Now we deduct all aggregated privileges.
         $flat = $this->getFlatPrivilegeSet($node);
 
         $collected2 = [];
         while (count($collected)) {
 
             $current = array_pop($collected);
             $collected2[] = $current['privilege'];
 
             if (!isset($flat[$current['privilege']])) {
                 // Ignoring privileges that are not in the supported-privileges list.
                 $this->server->getLogger()->debug('A node has the "' . $current['privilege'] . '" in its ACL list, but this privilege was not reported in the supportedPrivilegeSet list. This will be ignored.');
                 continue;
             }
             foreach ($flat[$current['privilege']]['aggregates'] as $subPriv) {
                 $collected2[] = $subPriv;
                 $collected[] = $flat[$subPriv];
             }
 
         }
 
         return array_values(array_unique($collected2));
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDefaultAcl()

Sabre\DAVACL\Plugin::getDefaultAcl ( )

Returns the default ACL rules.

These rules are used for all nodes that don't implement the IACL interface.

Returns: array

Definition at line 289 of file Plugin.php.

References Sabre\DAVACL\Plugin\$defaultAcl.

Referenced by Sabre\DAVACL\Plugin\getAcl().

                              {
 
         return $this->defaultAcl;
 
     }

Here is the caller graph for this function:

◆ getFeatures()

Sabre\DAVACL\Plugin::getFeatures ( )

Returns a list of features added by this plugin.

This list is used in the response of a HTTP OPTIONS request.

Returns: array

Definition at line 123 of file Plugin.php.

                            {
 
         return ['access-control', 'calendarserver-principal-property-search'];
 
     }

◆ getFlatPrivilegeSet()

Sabre\DAVACL\Plugin::getFlatPrivilegeSet ( $node )

final

Returns the supported privilege set as a flat list.

This is much easier to parse.

The returned list will be index by privilege name. The value is a struct containing the following properties:

aggregates
abstract
concrete

Parameters

string | INode $node

Returns: array

Definition at line 529 of file Plugin.php.

References Sabre\DAVACL\Plugin\getSupportedPrivilegeSet().

Referenced by Sabre\DAVACL\Plugin\getCurrentUserPrivilegeSet(), and Sabre\DAVACL\Plugin\httpAcl().

                                               {
 
         $privs = [
             'abstract'   => false,
             'aggregates' => $this->getSupportedPrivilegeSet($node)
         ];
 
         $fpsTraverse = null;
         $fpsTraverse = function($privName, $privInfo, $concrete, &$flat) use (&$fpsTraverse) {
 
             $myPriv = [
                 'privilege'  => $privName,
                 'abstract'   => isset($privInfo['abstract']) && $privInfo['abstract'],
                 'aggregates' => [],
                 'concrete'   => isset($privInfo['abstract']) && $privInfo['abstract'] ? $concrete : $privName,
             ];
 
             if (isset($privInfo['aggregates'])) {
 
                 foreach ($privInfo['aggregates'] as $subPrivName => $subPrivInfo) {
 
                     $myPriv['aggregates'][] = $subPrivName;
 
                 }
 
             }
 
             $flat[$privName] = $myPriv;
 
             if (isset($privInfo['aggregates'])) {
 
                 foreach ($privInfo['aggregates'] as $subPrivName => $subPrivInfo) {
 
                     $fpsTraverse($subPrivName, $subPrivInfo, $myPriv['concrete'], $flat);
 
                 }
 
             }
 
         };
 
         $flat = [];
         $fpsTraverse('{DAV:}all', $privs, null, $flat);
 
         return $flat;
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getMethods()

Sabre\DAVACL\Plugin::getMethods ( $uri )

Returns a list of available methods for a given url.

Parameters

string $uri

Returns: array

Definition at line 135 of file Plugin.php.

                               {
 
         return ['ACL'];
 
     }

◆ getPluginInfo()

Sabre\DAVACL\Plugin::getPluginInfo ( )

Returns a bunch of meta-data about the plugin.

Providing this information is optional, and is mainly displayed by the Browser plugin.

The description key in the returned array may contain html and will not be sanitized.

Returns: array

Definition at line 1627 of file Plugin.php.

References Sabre\DAVACL\Plugin\getPluginName().

                              {
 
         return [
             'name'        => $this->getPluginName(),
             'description' => 'Adds support for WebDAV ACL (rfc3744)',
             'link'        => 'http://sabre.io/dav/acl/',
         ];
 
     }

Here is the call graph for this function:

◆ getPluginName()

Sabre\DAVACL\Plugin::getPluginName ( )

Returns a plugin name.

Using this name other plugins will be able to access other plugins using Sabre::getPlugin

Returns: string

Definition at line 149 of file Plugin.php.

Referenced by Sabre\DAVACL\Plugin\getPluginInfo().

                              {
 
         return 'acl';
 
     }

Here is the caller graph for this function:

◆ getPrincipalByUri()

Sabre\DAVACL\Plugin::getPrincipalByUri ( $uri )

Returns a principal based on its uri.

Returns null if the principal could not be found.

Parameters

string $uri

Returns: null|string

Definition at line 708 of file Plugin.php.

References Sabre\DAVACL\Plugin\$principalCollectionSet, and $result.

Referenced by Sabre\DAVACL\Plugin\initialize().

                                      {
 
         $result = null;
         $collections = $this->principalCollectionSet;
         foreach ($collections as $collection) {
 
             try {
                 $principalCollection = $this->server->tree->getNodeForPath($collection);
             } catch (NotFound $e) {
                 // Ignore and move on
                 continue;
             }
 
             if (!$principalCollection instanceof IPrincipalCollection) {
                 // Not a principal collection, we're simply going to ignore
                 // this.
                 continue;
             }
 
             $result = $principalCollection->findByUri($uri);
             if ($result) {
                 return $result;
             }
 
         }
 
     }

Here is the caller graph for this function:

◆ getPrincipalMembership()

Sabre\DAVACL\Plugin::getPrincipalMembership ( $mainPrincipal )

Returns all the principal groups the specified principal is a member of.

Parameters

string $mainPrincipal

Returns: array

Definition at line 327 of file Plugin.php.

Referenced by Sabre\DAVACL\Plugin\getCurrentUserPrincipals(), and Sabre\DAVACL\Plugin\principalMatchesPrincipal().

                                                     {
 
         // First check our cache
         if (isset($this->principalMembershipCache[$mainPrincipal])) {
             return $this->principalMembershipCache[$mainPrincipal];
         }
 
         $check = [$mainPrincipal];
         $principals = [];
 
         while (count($check)) {
 
             $principal = array_shift($check);
 
             $node = $this->server->tree->getNodeForPath($principal);
             if ($node instanceof IPrincipal) {
                 foreach ($node->getGroupMembership() as $groupMember) {
 
                     if (!in_array($groupMember, $principals)) {
 
                         $check[] = $groupMember;
                         $principals[] = $groupMember;
 
                     }
 
                 }
 
             }
 
         }
 
         // Store the result in the cache
         $this->principalMembershipCache[$mainPrincipal] = $principals;
 
         return $principals;
 
     }

Here is the caller graph for this function:

◆ getSupportedPrivilegeSet()

Sabre\DAVACL\Plugin::getSupportedPrivilegeSet ( $node )

Returns a tree of supported privileges for a resource.

The returned array structure should be in this form:

[ [ 'privilege' => '{DAV:}read', 'abstract' => false, 'aggregates' => [] ] ]

Privileges can be nested using "aggregates". Doing so means that if you assign someone the aggregating privilege, all the sub-privileges will automatically be granted.

Marking a privilege as abstract means that the privilege cannot be directly assigned, but must be assigned via the parent privilege.

So a more complex version might look like this:

[ [ 'privilege' => '{DAV:}read', 'abstract' => false, 'aggregates' => [ [ 'privilege' => '{DAV:}read-acl', 'abstract' => false, 'aggregates' => [], ] ] ] ]

Parameters

string | INode $node

Returns: array

Definition at line 441 of file Plugin.php.

Referenced by Sabre\DAVACL\Plugin\getFlatPrivilegeSet(), and Sabre\DAVACL\Plugin\propFind().

                                              {
 
         if (is_string($node)) {
             $node = $this->server->tree->getNodeForPath($node);
         }
 
         $supportedPrivileges = null;
         if ($node instanceof IACL) {
             $supportedPrivileges = $node->getSupportedPrivilegeSet();
         }
 
         if (is_null($supportedPrivileges)) {
 
             // Default
             $supportedPrivileges = [
                 '{DAV:}read' => [
                     'abstract'   => false,
                     'aggregates' => [
                         '{DAV:}read-acl' => [
                             'abstract'   => false,
                             'aggregates' => [],
                         ],
                         '{DAV:}read-current-user-privilege-set' => [
                             'abstract'   => false,
                             'aggregates' => [],
                         ],
                     ],
                 ],
                 '{DAV:}write' => [
                     'abstract'   => false,
                     'aggregates' => [
                         '{DAV:}write-properties' => [
                             'abstract'   => false,
                             'aggregates' => [],
                         ],
                         '{DAV:}write-content' => [
                             'abstract'   => false,
                             'aggregates' => [],
                         ],
                         '{DAV:}unlock' => [
                             'abstract'   => false,
                             'aggregates' => [],
                         ],
                     ],
                 ],
             ];
             if ($node instanceof DAV\ICollection) {
                 $supportedPrivileges['{DAV:}write']['aggregates']['{DAV:}bind'] = [
                     'abstract'   => false,
                     'aggregates' => [],
                 ];
                 $supportedPrivileges['{DAV:}write']['aggregates']['{DAV:}unbind'] = [
                     'abstract'   => false,
                     'aggregates' => [],
                 ];
             }
             if ($node instanceof IACL) {
                 $supportedPrivileges['{DAV:}write']['aggregates']['{DAV:}write-acl'] = [
                     'abstract'   => false,
                     'aggregates' => [],
                 ];
             }
 
         }
 
         $this->server->emit(
             'getSupportedPrivilegeSet',
             [$node, &$supportedPrivileges]
         );
 
         return $supportedPrivileges;
 
     }

Here is the caller graph for this function:

◆ getSupportedReportSet()

Sabre\DAVACL\Plugin::getSupportedReportSet ( $uri )

Returns a list of reports this plugin supports.

This will be used in the {DAV:}supported-report-set property. Note that you still need to subscribe to the 'report' event to actually implement them

Parameters

string $uri

Returns: array

Definition at line 165 of file Plugin.php.

                                          {
 
         return [
             '{DAV:}expand-property',
             '{DAV:}principal-match',
             '{DAV:}principal-property-search',
             '{DAV:}principal-search-property-set',
         ];
 
     }

◆ htmlActionsPanel()

Sabre\DAVACL\Plugin::htmlActionsPanel	(	DAV\INode	$node,
		&	$output
	)

This method is used to generate HTML output for the DAV.

This allows us to generate an interface users can use to create new calendars.

Parameters

DAV\INode	$node
string	$output

Returns: bool

Definition at line 1596 of file Plugin.php.

References Sabre\VObject\$output.

                                                          {
 
         if (!$node instanceof PrincipalCollection)
             return;
 
         $output .= '<tr><td colspan="2"><form method="post" action="">
             <h3>Create new principal</h3>
             <input type="hidden" name="sabreAction" value="mkcol" />
             <input type="hidden" name="resourceType" value="{DAV:}principal" />
             <label>Name (uri):</label> <input type="text" name="name" /><br />
             <label>Display name:</label> <input type="text" name="{DAV:}displayname" /><br />
             <label>Email address:</label> <input type="text" name="{http://sabredav*DOT*org/ns}email-address" /><br />
             <input type="submit" value="create" />
             </form>
             </td></tr>';
 
         return false;
 
     }

◆ httpAcl()

Sabre\DAVACL\Plugin::httpAcl	(	RequestInterface	$request,
		ResponseInterface	$response
	)

This method is responsible for handling the 'ACL' event.

Parameters

RequestInterface	$request
ResponseInterface	$response

Returns: bool

Definition at line 1166 of file Plugin.php.

References $path, Sabre\HTTP\MessageInterface\getBodyAsString(), Sabre\DAVACL\Plugin\getFlatPrivilegeSet(), Sabre\HTTP\RequestInterface\getPath(), and Sabre\HTTP\ResponseInterface\setStatus().

                                                                              {
 
         $path = $request->getPath();
         $body = $request->getBodyAsString();
 
         if (!$body) {
             throw new DAV\Exception\BadRequest('XML body expected in ACL request');
         }
 
         $acl = $this->server->xml->expect('{DAV:}acl', $body);
         $newAcl = $acl->getPrivileges();
 
         // Normalizing urls
         foreach ($newAcl as $k => $newAce) {
             $newAcl[$k]['principal'] = $this->server->calculateUri($newAce['principal']);
         }
         $node = $this->server->tree->getNodeForPath($path);
 
         if (!$node instanceof IACL) {
             throw new DAV\Exception\MethodNotAllowed('This node does not support the ACL method');
         }
 
         $oldAcl = $this->getACL($node);
 
         $supportedPrivileges = $this->getFlatPrivilegeSet($node);
 
         /* Checking if protected principals from the existing principal set are
            not overwritten. */
         foreach ($oldAcl as $oldAce) {
 
             if (!isset($oldAce['protected']) || !$oldAce['protected']) continue;
 
             $found = false;
             foreach ($newAcl as $newAce) {
                 if (
                     $newAce['privilege'] === $oldAce['privilege'] &&
                     $newAce['principal'] === $oldAce['principal'] &&
                     $newAce['protected']
                 )
                 $found = true;
             }
 
             if (!$found)
                 throw new Exception\AceConflict('This resource contained a protected {DAV:}ace, but this privilege did not occur in the ACL request');
 
         }
 
         foreach ($newAcl as $newAce) {
 
             // Do we recognize the privilege
             if (!isset($supportedPrivileges[$newAce['privilege']])) {
                 throw new Exception\NotSupportedPrivilege('The privilege you specified (' . $newAce['privilege'] . ') is not recognized by this server');
             }
 
             if ($supportedPrivileges[$newAce['privilege']]['abstract']) {
                 throw new Exception\NoAbstract('The privilege you specified (' . $newAce['privilege'] . ') is an abstract privilege');
             }
 
             // Looking up the principal
             try {
                 $principal = $this->server->tree->getNodeForPath($newAce['principal']);
             } catch (NotFound $e) {
                 throw new Exception\NotRecognizedPrincipal('The specified principal (' . $newAce['principal'] . ') does not exist');
             }
             if (!($principal instanceof IPrincipal)) {
                 throw new Exception\NotRecognizedPrincipal('The specified uri (' . $newAce['principal'] . ') is not a principal');
             }
 
         }
         $node->setACL($newAcl);
 
         $response->setStatus(200);
 
         // Breaking the event chain, because we handled this method.
         return false;
 
     }

Here is the call graph for this function:

◆ initialize()

Sabre\DAVACL\Plugin::initialize ( DAV\Server $server )

Sets up the plugin.

This method is automatically called by the server class.

Parameters

DAV\Server $server

Returns: void

Definition at line 804 of file Plugin.php.

References $authPlugin, Sabre\DAVACL\Plugin\$server, and Sabre\DAVACL\Plugin\getPrincipalByUri().

                                             {
 
         if ($this->allowUnauthenticatedAccess) {
             $authPlugin = $server->getPlugin('auth');
             if (!$authPlugin) {
                 throw new \Exception('The Auth plugin must be loaded before the ACL plugin if you want to allow unauthenticated access.');
             }
             $authPlugin->autoRequireLogin = false;
         }
 
         $this->server = $server;
         $server->on('propFind',            [$this, 'propFind'], 20);
         $server->on('beforeMethod',        [$this, 'beforeMethod'], 20);
         $server->on('beforeBind',          [$this, 'beforeBind'], 20);
         $server->on('beforeUnbind',        [$this, 'beforeUnbind'], 20);
         $server->on('propPatch',           [$this, 'propPatch']);
         $server->on('beforeUnlock',        [$this, 'beforeUnlock'], 20);
         $server->on('report',              [$this, 'report']);
         $server->on('method:ACL',          [$this, 'httpAcl']);
         $server->on('onHTMLActionsPanel',  [$this, 'htmlActionsPanel']);
         $server->on('getPrincipalByUri',  function($principal, &$uri) {
 
             $uri = $this->getPrincipalByUri($principal);
 
             // Break event chain
             if ($uri) return false;
 
         });
 
         array_push($server->protectedProperties,
             '{DAV:}alternate-URI-set',
             '{DAV:}principal-URL',
             '{DAV:}group-membership',
             '{DAV:}principal-collection-set',
             '{DAV:}current-user-principal',
             '{DAV:}supported-privilege-set',
             '{DAV:}current-user-privilege-set',
             '{DAV:}acl',
             '{DAV:}acl-restrictions',
             '{DAV:}inherited-acl-set',
             '{DAV:}owner',
             '{DAV:}group'
         );
 
         // Automatically mapping nodes implementing IPrincipal to the
         // {DAV:}principal resourcetype.
         $server->resourceTypeMapping['Sabre\\DAVACL\\IPrincipal'] = '{DAV:}principal';
 
         // Mapping the group-member-set property to the HrefList property
         // class.
         $server->xml->elementMap['{DAV:}group-member-set'] = 'Sabre\\DAV\\Xml\\Property\\Href';
         $server->xml->elementMap['{DAV:}acl'] = 'Sabre\\DAVACL\\Xml\\Property\\Acl';
         $server->xml->elementMap['{DAV:}acl-principal-prop-set'] = 'Sabre\\DAVACL\\Xml\\Request\\AclPrincipalPropSetReport';
         $server->xml->elementMap['{DAV:}expand-property'] = 'Sabre\\DAVACL\\Xml\\Request\\ExpandPropertyReport';
         $server->xml->elementMap['{DAV:}principal-property-search'] = 'Sabre\\DAVACL\\Xml\\Request\\PrincipalPropertySearchReport';
         $server->xml->elementMap['{DAV:}principal-search-property-set'] = 'Sabre\\DAVACL\\Xml\\Request\\PrincipalSearchPropertySetReport';
         $server->xml->elementMap['{DAV:}principal-match'] = 'Sabre\\DAVACL\\Xml\\Request\\PrincipalMatchReport';
 
     }

Here is the call graph for this function:

◆ principalMatchesPrincipal()

Sabre\DAVACL\Plugin::principalMatchesPrincipal	(	$checkPrincipal,
		$currentPrincipal = `null`
	)

Find out of a principal equals another principal.

This is a quick way to find out whether a principal URI is part of a group, or any subgroups.

The first argument is the principal URI you want to check against. For example the principal group, and the second argument is the principal of which you want to find out of it is the same as the first principal, or in a member of the first principal's group or subgroups.

So the arguments are not interchangeable. If principal A is in group B, passing 'B', 'A' will yield true, but 'A', 'B' is false.

If the second argument is not passed, we will use the current user principal.

Parameters

string	$checkPrincipal
string	$currentPrincipal

Returns: bool

Definition at line 386 of file Plugin.php.

References Sabre\DAVACL\Plugin\getPrincipalMembership().

Referenced by Sabre\DAVACL\Plugin\getCurrentUserPrivilegeSet().

                                                                                   {
 
         if (is_null($currentPrincipal)) {
             $currentPrincipal = $this->getCurrentUserPrincipal();
         }
         if ($currentPrincipal === $checkPrincipal) {
             return true;
         }
         return in_array(
             $checkPrincipal,
             $this->getPrincipalMembership($currentPrincipal)
         );
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ principalMatchReport()

Sabre\DAVACL\Plugin::principalMatchReport	(		$path,
		Xml\Request\PrincipalMatchReport	$report
	)

protected

The principal-match report is defined in RFC3744, section 9.3.

This report allows a client to figure out based on the current user, or a principal URL, the principal URL and principal URLs of groups that principal belongs to.

Parameters

string	$path
Xml\Request\PrincipalMatchReport	$report

Returns: void

Definition at line 1259 of file Plugin.php.

References $path, $result, and Sabre\DAVACL\Plugin\getCurrentUserPrincipals().

Referenced by Sabre\DAVACL\Plugin\report().

                                                                                              {
 
         $depth = $this->server->getHTTPDepth(0);
         if ($depth !== 0) {
             throw new BadRequest('The principal-match report is only defined on Depth: 0');
         }
 
         $currentPrincipals = $this->getCurrentUserPrincipals();
 
         $result = [];
 
         if ($report->type === Xml\Request\PrincipalMatchReport::SELF) {
 
             // Finding all principals under the request uri that match the
             // current principal.
             foreach ($currentPrincipals as $currentPrincipal) {
 
                 if ($currentPrincipal === $path || strpos($currentPrincipal, $path . '/') === 0) {
                     $result[] = $currentPrincipal;
                 }
 
             }
 
         } else {
 
             // We need to find all resources that have a property that matches
             // one of the current principals.
             $candidates = $this->server->getPropertiesForPath(
                 $path,
                 [$report->principalProperty],
                 1
             );
 
             foreach ($candidates as $candidate) {
 
                 if (!isset($candidate[200][$report->principalProperty])) {
                     continue;
                 }
 
                 $hrefs = $candidate[200][$report->principalProperty];
 
                 if (!$hrefs instanceof Href) {
                     continue;
                 }
 
                 foreach ($hrefs->getHrefs() as $href) {
                     if (in_array(trim($href, '/'), $currentPrincipals)) {
                         $result[] = $candidate['href'];
                         continue 2;
                     }
                 }
             }
 
         }
 
         $responses = [];
 
         foreach ($result as $item) {
 
             $properties = [];
 
             if ($report->properties) {
 
                 $foo = $this->server->getPropertiesForPath($item, $report->properties);
                 $foo = $foo[0];
                 $item = $foo['href'];
                 unset($foo['href']);
                 $properties = $foo;
 
             }
 
             $responses[] = new DAV\Xml\Element\Response(
                 $item,
                 $properties,
                 '200'
             );
 
         }
 
         $this->server->httpResponse->setHeader('Content-Type', 'application/xml; charset=utf-8');
         $this->server->httpResponse->setStatus(207);
         $this->server->httpResponse->setBody(
             $this->server->xml->write(
                 '{DAV:}multistatus',
                 $responses,
                 $this->server->getBaseUri()
             )
         );
 
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ principalPropertySearchReport()

Sabre\DAVACL\Plugin::principalPropertySearchReport	(		$path,
		Xml\Request\PrincipalPropertySearchReport	$report
	)

protected

principalPropertySearchReport

This method is responsible for handing the {DAV:}principal-property-search report. This report can be used for clients to search for groups of principals, based on the value of one or more properties.

Parameters

string	$path
Xml\Request\PrincipalPropertySearchReport	$report

Returns: void

Definition at line 1503 of file Plugin.php.

References $path, $result, and Sabre\DAVACL\Plugin\principalSearch().

Referenced by Sabre\DAVACL\Plugin\report().

                                                                                                                {
 
         if ($report->applyToPrincipalCollectionSet) {
             $path = null;
         }
         if ($this->server->getHttpDepth('0') !== 0) {
             throw new BadRequest('Depth must be 0');
         }
         $result = $this->principalSearch(
             $report->searchProperties,
             $report->properties,
             $path,
             $report->test
         );
 
         $prefer = $this->server->getHTTPPrefer();
 
         $this->server->httpResponse->setStatus(207);
         $this->server->httpResponse->setHeader('Content-Type', 'application/xml; charset=utf-8');
         $this->server->httpResponse->setHeader('Vary', 'Brief,Prefer');
         $this->server->httpResponse->setBody($this->server->generateMultiStatus($result, $prefer['return'] === 'minimal'));
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ principalSearch()

Sabre\DAVACL\Plugin::principalSearch	(	array	$searchProperties,
		array	$requestedProperties,
			$collectionUri = `null`,
			$test = `'allof'`
	)

Principal property search.

This method can search for principals matching certain values in properties.

This method will return a list of properties for the matched properties.

Parameters

array	$searchProperties	The properties to search on. This is a key-value list. The keys are property names, and the values the strings to match them on.
array	$requestedProperties	This is the list of properties to return for every match.
string	$collectionUri	The principal collection to search on. If this is ommitted, the standard principal collection-set will be used.
string	$test	"allof" to use AND to search the properties. 'anyof' for OR.

Returns: array This method returns an array structure similar to Sabre::getPropertiesForPath. Returned properties are index by a HTTP status code.

Definition at line 759 of file Plugin.php.

References Sabre\DAVACL\Plugin\$principalCollectionSet, $result, $results, and $test.

Referenced by Sabre\DAVACL\Plugin\principalPropertySearchReport().

                                                                                                                           {
 
         if (!is_null($collectionUri)) {
             $uris = [$collectionUri];
         } else {
             $uris = $this->principalCollectionSet;
         }
 
         $lookupResults = [];
         foreach ($uris as $uri) {
 
             $principalCollection = $this->server->tree->getNodeForPath($uri);
             if (!$principalCollection instanceof IPrincipalCollection) {
                 // Not a principal collection, we're simply going to ignore
                 // this.
                 continue;
             }
 
             $results = $principalCollection->searchPrincipals($searchProperties, $test);
             foreach ($results as $result) {
                 $lookupResults[] = rtrim($uri, '/') . '/' . $result;
             }
 
         }
 
         $matches = [];
 
         foreach ($lookupResults as $lookupResult) {
 
             list($matches[]) = $this->server->getPropertiesForPath($lookupResult, $requestedProperties, 0);
 
         }
 
         return $matches;
 
     }

Here is the caller graph for this function:

◆ principalSearchPropertySetReport()

Sabre\DAVACL\Plugin::principalSearchPropertySetReport	(	$path,
		$report
	)

protected

principalSearchPropertySetReport

This method responsible for handing the {DAV:}principal-search-property-set report. This report returns a list of properties the client may search on, using the {DAV:}principal-property-search report.

Parameters

string	$path
Xml\Request\PrincipalSearchPropertySetReport	$report

Returns: void

Definition at line 1448 of file Plugin.php.

References $description.

Referenced by Sabre\DAVACL\Plugin\report().

                                                                         {
 
         $httpDepth = $this->server->getHTTPDepth(0);
         if ($httpDepth !== 0) {
             throw new DAV\Exception\BadRequest('This report is only defined when Depth: 0');
         }
 
         $writer = $this->server->xml->getWriter();
         $writer->openMemory();
         $writer->startDocument();
 
         $writer->startElement('{DAV:}principal-search-property-set');
 
         foreach ($this->principalSearchPropertySet as $propertyName => $description) {
 
             $writer->startElement('{DAV:}principal-search-property');
             $writer->startElement('{DAV:}prop');
 
             $writer->writeElement($propertyName);
 
             $writer->endElement(); // prop
 
             if ($description) {
                 $writer->write([[
                     'name'       => '{DAV:}description',
                     'value'      => $description,
                     'attributes' => ['xml:lang' => 'en']
                 ]]);
             }
 
             $writer->endElement(); // principal-search-property
 
 
         }
 
         $writer->endElement(); // principal-search-property-set
 
         $this->server->httpResponse->setHeader('Content-Type', 'application/xml; charset=utf-8');
         $this->server->httpResponse->setStatus(200);
         $this->server->httpResponse->setBody($writer->outputMemory());
 
     }

Here is the caller graph for this function:

◆ propFind()

Sabre\DAVACL\Plugin::propFind	(	DAV\PropFind	$propFind,
		DAV\INode	$node
	)

Triggered before properties are looked up in specific nodes.

Parameters

DAV\PropFind	$propFind
DAV\INode	$node	really should be broken into multiple methods, or even a class.

Returns: bool

Definition at line 986 of file Plugin.php.

References $path, Sabre\DAVACL\Plugin\$principalCollectionSet, $url, Sabre\DAVACL\Plugin\checkPrivileges(), Sabre\DAVACL\Plugin\getCurrentUserPrivilegeSet(), and Sabre\DAVACL\Plugin\getSupportedPrivilegeSet().

                                                                {
 
         $path = $propFind->getPath();
 
         // Checking the read permission
         if (!$this->checkPrivileges($path, '{DAV:}read', self::R_PARENT, false)) {
             // User is not allowed to read properties
 
             // Returning false causes the property-fetching system to pretend
             // that the node does not exist, and will cause it to be hidden
             // from listings such as PROPFIND or the browser plugin.
             if ($this->hideNodesFromListings) {
                 return false;
             }
 
             // Otherwise we simply mark every property as 403.
             foreach ($propFind->getRequestedProperties() as $requestedProperty) {
                 $propFind->set($requestedProperty, null, 403);
             }
 
             return;
 
         }
 
         /* Adding principal properties */
         if ($node instanceof IPrincipal) {
 
             $propFind->handle('{DAV:}alternate-URI-set', function() use ($node) {
                 return new Href($node->getAlternateUriSet());
             });
             $propFind->handle('{DAV:}principal-URL', function() use ($node) {
                 return new Href($node->getPrincipalUrl() . '/');
             });
             $propFind->handle('{DAV:}group-member-set', function() use ($node) {
                 $members = $node->getGroupMemberSet();
                 foreach ($members as $k => $member) {
                     $members[$k] = rtrim($member, '/') . '/';
                 }
                 return new Href($members);
             });
             $propFind->handle('{DAV:}group-membership', function() use ($node) {
                 $members = $node->getGroupMembership();
                 foreach ($members as $k => $member) {
                     $members[$k] = rtrim($member, '/') . '/';
                 }
                 return new Href($members);
             });
             $propFind->handle('{DAV:}displayname', [$node, 'getDisplayName']);
 
         }
 
         $propFind->handle('{DAV:}principal-collection-set', function() {
 
             $val = $this->principalCollectionSet;
             // Ensuring all collections end with a slash
             foreach ($val as $k => $v) $val[$k] = $v . '/';
             return new Href($val);
 
         });
         $propFind->handle('{DAV:}current-user-principal', function() {
             if ($url = $this->getCurrentUserPrincipal()) {
                 return new Xml\Property\Principal(Xml\Property\Principal::HREF, $url . '/');
             } else {
                 return new Xml\Property\Principal(Xml\Property\Principal::UNAUTHENTICATED);
             }
         });
         $propFind->handle('{DAV:}supported-privilege-set', function() use ($node) {
             return new Xml\Property\SupportedPrivilegeSet($this->getSupportedPrivilegeSet($node));
         });
         $propFind->handle('{DAV:}current-user-privilege-set', function() use ($node, $propFind, $path) {
             if (!$this->checkPrivileges($path, '{DAV:}read-current-user-privilege-set', self::R_PARENT, false)) {
                 $propFind->set('{DAV:}current-user-privilege-set', null, 403);
             } else {
                 $val = $this->getCurrentUserPrivilegeSet($node);
                 return new Xml\Property\CurrentUserPrivilegeSet($val);
             }
         });
         $propFind->handle('{DAV:}acl', function() use ($node, $propFind, $path) {
             /* The ACL property contains all the permissions */
             if (!$this->checkPrivileges($path, '{DAV:}read-acl', self::R_PARENT, false)) {
                 $propFind->set('{DAV:}acl', null, 403);
             } else {
                 $acl = $this->getACL($node);
                 return new Xml\Property\Acl($this->getACL($node));
             }
         });
         $propFind->handle('{DAV:}acl-restrictions', function() {
             return new Xml\Property\AclRestrictions();
         });
 
         /* Adding ACL properties */
         if ($node instanceof IACL) {
             $propFind->handle('{DAV:}owner', function() use ($node) {
                 return new Href($node->getOwner() . '/');
             });
         }
 
     }

Here is the call graph for this function:

◆ propPatch()

Sabre\DAVACL\Plugin::propPatch	(		$path,
		DAV\PropPatch	$propPatch
	)

This method intercepts PROPPATCH methods and make sure the group-member-set is updated correctly.

Parameters

string	$path
DAV\PropPatch	$propPatch

Returns: void

Definition at line 1093 of file Plugin.php.

References $path.

                                                         {
 
         $propPatch->handle('{DAV:}group-member-set', function($value) use ($path) {
             if (is_null($value)) {
                 $memberSet = [];
             } elseif ($value instanceof Href) {
                 $memberSet = array_map(
                     [$this->server, 'calculateUri'],
                     $value->getHrefs()
                 );
             } else {
                 throw new DAV\Exception('The group-member-set property MUST be an instance of Sabre\DAV\Property\HrefList or null');
             }
             $node = $this->server->tree->getNodeForPath($path);
             if (!($node instanceof IPrincipal)) {
                 // Fail
                 return false;
             }
 
             $node->setGroupMemberSet($memberSet);
             // We must also clear our cache, just in case
 
             $this->principalMembershipCache = [];
 
             return true;
         });
 
     }

◆ report()

Sabre\DAVACL\Plugin::report	(	$reportName,
		$report,
		$path
	)

This method handles HTTP REPORT requests.

Parameters

string	$reportName
mixed	$report
mixed	$path

Returns: bool

Definition at line 1130 of file Plugin.php.

References $path, Sabre\DAVACL\Plugin\aclPrincipalPropSetReport(), Sabre\DAVACL\Plugin\expandPropertyReport(), Sabre\DAVACL\Plugin\principalMatchReport(), Sabre\DAVACL\Plugin\principalPropertySearchReport(), and Sabre\DAVACL\Plugin\principalSearchPropertySetReport().

                                                  {
 
         switch ($reportName) {
 
             case '{DAV:}principal-property-search' :
                 $this->server->transactionType = 'report-principal-property-search';
                 $this->principalPropertySearchReport($path, $report);
                 return false;
             case '{DAV:}principal-search-property-set' :
                 $this->server->transactionType = 'report-principal-search-property-set';
                 $this->principalSearchPropertySetReport($path, $report);
                 return false;
             case '{DAV:}expand-property' :
                 $this->server->transactionType = 'report-expand-property';
                 $this->expandPropertyReport($path, $report);
                 return false;
             case '{DAV:}principal-match' :
                 $this->server->transactionType = 'report-principal-match';
                 $this->principalMatchReport($path, $report);
                 return false;
             case '{DAV:}acl-principal-prop-set' :
                 $this->server->transactionType = 'acl-principal-prop-set';
                 $this->aclPrincipalPropSetReport($path, $report);
                 return false;
 
         }
 
     }

Here is the call graph for this function:

◆ setDefaultAcl()

Sabre\DAVACL\Plugin::setDefaultAcl ( array $acl )

Sets the default ACL rules.

These rules are used for all nodes that don't implement the IACL interface.

Parameters

array $acl

Returns: void

Definition at line 276 of file Plugin.php.

                                        {
 
         $this->defaultAcl = $acl;
 
     }

Field Documentation

◆ $adminPrincipals

Sabre\DAVACL\Plugin::$adminPrincipals = []

Definition at line 102 of file Plugin.php.

◆ $allowUnauthenticatedAccess

Sabre\DAVACL\Plugin::$allowUnauthenticatedAccess = true

Definition at line 114 of file Plugin.php.

◆ $defaultAcl

Sabre\DAVACL\Plugin::$defaultAcl

protected

Initial value:

= [
        [
            'principal' => '{DAV:}authenticated',
            'protected' => true

Definition at line 304 of file Plugin.php.

Referenced by Sabre\DAVACL\Plugin\getDefaultAcl().

◆ $hideNodesFromListings

Sabre\DAVACL\Plugin::$hideNodesFromListings = false

Definition at line 80 of file Plugin.php.

◆ $principalCollectionSet

Sabre\DAVACL\Plugin::$principalCollectionSet

Initial value:

= [
        'principals',
    ]

Definition at line 67 of file Plugin.php.

Referenced by Sabre\DAVACL\Plugin\getPrincipalByUri(), Sabre\DAVACL\Plugin\principalSearch(), and Sabre\DAVACL\Plugin\propFind().

◆ $principalMembershipCache

Sabre\DAVACL\Plugin::$principalMembershipCache = []

protected

Definition at line 318 of file Plugin.php.

◆ $principalSearchPropertySet

Sabre\DAVACL\Plugin::$principalSearchPropertySet

Initial value:

= [

'{DAV:}displayname' => 'Display name'

Definition at line 90 of file Plugin.php.

◆ $server

Sabre\DAVACL\Plugin::$server

protected

Definition at line 59 of file Plugin.php.

Referenced by Sabre\DAVACL\Plugin\initialize().

◆ R_PARENT

const Sabre\DAVACL\Plugin::R_PARENT = 1

Recursion constants.

This only checks the base node

Definition at line 38 of file Plugin.php.

Referenced by Sabre\DAVACL\SimplePluginTest\testCheckPrivileges().

◆ R_RECURSIVE

const Sabre\DAVACL\Plugin::R_RECURSIVE = 2

Recursion constants.

This checks every node in the tree

Definition at line 45 of file Plugin.php.

◆ R_RECURSIVEPARENTS

const Sabre\DAVACL\Plugin::R_RECURSIVEPARENTS = 3

Recursion constants.

This checks every parentnode in the tree, but not leaf-nodes.

Definition at line 52 of file Plugin.php.

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

libs/composer/vendor/sabre/dav/lib/DAVACL/Plugin.php

Public Member Functions

Data Fields

Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ aclPrincipalPropSetReport()

◆ beforeBind()

◆ beforeMethod()

◆ beforeUnbind()

◆ beforeUnlock()

◆ checkPrivileges()

◆ expandProperties()

◆ expandPropertyReport()

◆ getAcl()

◆ getCurrentUserPrincipals()

◆ getCurrentUserPrivilegeSet()

◆ getDefaultAcl()

◆ getFeatures()

◆ getFlatPrivilegeSet()

◆ getMethods()

◆ getPluginInfo()

◆ getPluginName()

◆ getPrincipalByUri()

◆ getPrincipalMembership()

◆ getSupportedPrivilegeSet()

◆ getSupportedReportSet()

◆ htmlActionsPanel()

◆ httpAcl()

◆ initialize()

◆ principalMatchesPrincipal()

◆ principalMatchReport()

◆ principalPropertySearchReport()

◆ principalSearch()

◆ principalSearchPropertySetReport()

◆ propFind()

◆ propPatch()

◆ report()

◆ setDefaultAcl()

Field Documentation

◆ $adminPrincipals

◆ $allowUnauthenticatedAccess

◆ $defaultAcl

◆ $hideNodesFromListings

◆ $principalCollectionSet

◆ $principalMembershipCache

◆ $principalSearchPropertySet

◆ $server

◆ R_PARENT

◆ R_RECURSIVE

◆ R_RECURSIVEPARENTS