SilverStripe\LDAP\Iterators\LDAPIterator

Complexity

Total Complexity

46

Size/Duplication

Total Lines	268
Duplicated Lines	0 %

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getBaseDn()	0	3	1
A	getAttributeRecursive()	0	32	5
A	__construct()	0	8	1
A	getLdap()	0	3	1
A	resolveRangedAttributes()	0	17	3
A	key()	0	10	3
B	fetchPagedResult()	0	53	10
A	getConvertedEntry()	0	24	6
A	getResolveRangedAttributes()	0	3	1
A	getFilter()	0	3	1
A	valid()	0	7	2
A	getReturnAttributes()	0	3	1
A	next()	0	10	2
A	current()	0	10	3
A	getPageSize()	0	3	1
A	getConvertedEntries()	0	13	3
A	rewind()	0	9	2

<?php

namespace SilverStripe\LDAP\Iterators;

use \Iterator;
use Zend\Ldap\Ldap;
use Zend\Ldap\Exception;
use Zend\Ldap\ErrorHandler;
use Zend\Ldap\Exception\LdapException;

/**
 * Class LDAPIterator
 * @package SilverStripe\LDAP\Iterators
 *
 * Original implementation provided by ThaDafinser: https://gist.github.com/ThaDafinser/1d081bed8e5e6505e97bedf5863a187c
 * See also: https://github.com/zendframework/zend-ldap/issues/41
 *
 * This uses the ldap_control_paged_result() and ldap_control_paged_result_response() functions to request multiple
 * pages of data from LDAP as needed, to ensure that the end result is everything that matches the requested filter,
 * regardless of the maximum page size set by the LDAP server.
 *
 * Note: The page size attribute provided to this class must be less than the LDAP server's page size, or objects may
 * still be missing from results.
 */
final class LDAPIterator implements Iterator
{
    private $ldap;
    private $filter;
    private $baseDn;
    private $returnAttributes;
    private $pageSize;
    private $resolveRangedAttributes;
    private $entries;
    private $current;
    /**
     * Required for paging
     *
     * @var unknown

The type SilverStripe\LDAP\Iterators\unknown was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    private $currentResult;

The private property $currentResult is not used, and could be removed.

    /**
     * Required for paging
     *
     * @var unknown
     */
    private $cookie = true;

    /**
     * @param Ldap $ldap The Zend\Ldap\Ldap object that this iterator will use to retrieve results from
     * @param string $filter An LDAP search filter (e.g. "(&(objectClass=user)(!(objectClass=computer)))")
     * @param string|null $baseDn The Base DN to search from (or null to search from the connection root)
     * @param array|null $returnAttributes The attributes to request from the LDAP server, or null to request all
     * @param int $pageSize Number of results per page. This *must* be less than the LDAP server MaxPageSize setting
     * @param bool $resolveRangedAttributes Whether or not to return ranged attributes
     */
    public function __construct(Ldap $ldap, $filter = "", $baseDn = null, array $returnAttributes = null, $pageSize = 250, $resolveRangedAttributes = false)
    {
        $this->ldap = $ldap;
        $this->filter = $filter;
        $this->baseDn = $baseDn;
        $this->returnAttributes = $returnAttributes;
        $this->pageSize = $pageSize;
        $this->resolveRangedAttributes = $resolveRangedAttributes;
    }

    private function getLdap()
    {
        return $this->ldap;
    }

    private function getFilter()
    {
        return $this->filter;
    }

    private function getBaseDn()
    {
        return $this->baseDn;
    }

    private function getReturnAttributes()
    {
        return $this->returnAttributes;
    }

    private function getPageSize()
    {
        return $this->pageSize;
    }

    /**
     * @return bool
     */
    private function getResolveRangedAttributes()
    {
        return $this->resolveRangedAttributes;
    }

    private function fetchPagedResult()
    {
        if ($this->cookie === null || $this->cookie === '') {
            return false;
        }

        if ($this->cookie === true) {

The condition $this->cookie is always false. If $this->cookie can have other possible types, add them to src/Iterators/LDAPIterator.php:44

            // First fetch!
            $this->cookie = '';
        }

        $ldap = $this->getLdap();
        $resource = $ldap->getResource();

        $baseDn = $this->getBaseDn();
        if (!$baseDn) {
            $baseDn = $ldap->getBaseDn();
        }

        ldap_control_paged_result($resource, $this->getPageSize(), true, $this->cookie);
        if ($this->getReturnAttributes() !== null) {
            $resultResource = ldap_search($resource, $baseDn, $this->getFilter(), $this->getReturnAttributes());
        } else {
            $resultResource = ldap_search($resource, $baseDn, $this->getFilter());
        }
        if (! is_resource($resultResource)) {
            /*
             * @TODO better exception msg
             */
            throw new \Exception('ldap_search returned something wrong...' . ldap_error($resource));
        }

        $entries = ldap_get_entries($resource, $resultResource);
        if ($entries === false) {
            throw new LdapException($ldap, 'Entries could not get fetched');
        }
        $entries = $this->getConvertedEntries($entries);

        ErrorHandler::start();
        $response = ldap_control_paged_result_response($resource, $resultResource, $this->cookie);
        ErrorHandler::stop();

        if ($response !== true) {
            throw new LdapException($ldap, 'Paged result was empty');
        }

        if ($this->entries === null) {
            $this->entries = [];
        }

        $this->entries = array_merge($this->entries, $entries);

        return true;
    }
    private function getConvertedEntries(array $entries)
    {
        $result = [];

        foreach ($entries as $key => $entry) {
            if ($key === 'count') {
                continue;
            }

            $result[$key] = $this->getConvertedEntry($entry);
        }

        return $result;
    }
    private function getConvertedEntry(array $entry)
    {
        $result = [];

        foreach ($entry as $key => $value) {
            if (is_int($key)) {
                continue;
            }
            if ($key === 'count') {
                continue;
            }

            if (isset($value['count'])) {
                unset($value['count']);
            }

            $result[$key] = $value;
        }

        if ($this->getResolveRangedAttributes() === true) {
            $result = $this->resolveRangedAttributes($result);
        }

        return $result;
    }
    private function resolveRangedAttributes(array $row)
    {
        $result = [];
        foreach ($row as $key => $value) {
            $keyExploded = explode(';range=', $key);

            if (count($keyExploded) === 2) {
                $range = explode('-', $keyExploded[1]);
                $offsetAndLimit = (int) $range[1] + 1;

                $result[$keyExploded[0]] = array_merge($value, $this->getAttributeRecursive($row['dn'], $keyExploded[0], $offsetAndLimit, $offsetAndLimit));
            } else {
                $result[$key] = $value;
            }
        }

        return $result;
    }
    private function getAttributeRecursive(string $dn, string $attrName, int $offset, int $maxPerRequest)
    {
        $attributeValue = [];

        $limit = $offset + $maxPerRequest - 1;
        $searchedAttribute = $attrName . ';range=' . $offset . '-' . $limit;

        $ldap = $this->getLdap();
        $entry = $ldap->getEntry($dn, [
            $searchedAttribute
        ], true);
        foreach ($entry as $key => $value) {
            // skip DN and other fields (if returned)
            if (stripos($key, $attrName) === false) {
                continue;
            }

            $attributeValue = $value;

            // range result (pagination)
            $keyExploded = explode(';range=', $key);

            $range = explode('-', $keyExploded[1]);
            $rangeEnd = (int) $range[1];

            if ($range[0] == $offset && $range[1] == $limit) {
                // more pages, there are more pages to fetch
                $attributeValue = array_merge($attributeValue, $this->getAttributeRecursive($dn, $attrName, $rangeEnd + 1, $maxPerRequest));
            }
        }

        return $attributeValue;
    }
    public function current()
    {
        if (! is_array($this->current)) {
            $this->rewind();
        }
        if (! is_array($this->current)) {
            return;
        }

        return $this->current;
    }
    public function key()
    {
        if (! is_array($this->current)) {
            $this->rewind();
        }
        if (! is_array($this->current)) {
            return;
        }

        return $this->current['dn'];
    }
    public function next()
    {
        // initial
        if ($this->entries === null) {
            $this->fetchPagedResult();
        }

        next($this->entries);

        $this->current = current($this->entries);
    }
    public function rewind()
    {
        // initial
        if ($this->entries === null) {
            $this->fetchPagedResult();
        }

        reset($this->entries);
        $this->current = current($this->entries);
    }
    public function valid()
    {
        if (is_array($this->current)) {
            return true;
        }

        return $this->fetchPagedResult();
    }
}