interface/modules/zend_modules/library/Zend/Ldap/Collection/DefaultIterator.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Ldap\Collection;
  11
  12 use Countable;
  13 use Iterator;
  14 use Zend\Ldap;
  15 use Zend\Ldap\Exception;
  16 use Zend\Stdlib\ErrorHandler;
  17
  18 /**
  19  * Zend\Ldap\Collection\DefaultIterator is the default collection iterator implementation
  20  * using ext/ldap
  21  */
  22 class DefaultIterator implements Iterator, Countable
  23 {
  24     const ATTRIBUTE_TO_LOWER = 1;
  25     const ATTRIBUTE_TO_UPPER = 2;
  26     const ATTRIBUTE_NATIVE   = 3;
  27
  28     /**
  29      * LDAP Connection
  30      *
  31      * @var \Zend\Ldap\Ldap
  32      */
  33     protected $ldap = null;
  34
  35     /**
  36      * Result identifier resource
  37      *
  38      * @var resource
  39      */
  40     protected $resultId = null;
  41
  42     /**
  43      * Current result entry identifier
  44      *
  45      * @var resource
  46      */
  47     protected $current = null;
  48
  49     /**
  50      * Number of items in query result
  51      *
  52      * @var int
  53      */
  54     protected $itemCount = -1;
  55
  56     /**
  57      * The method that will be applied to the attribute's names.
  58      *
  59      * @var  integer|callable
  60      */
  61     protected $attributeNameTreatment = self::ATTRIBUTE_TO_LOWER;
  62
  63     /**
  64      * Constructor.
  65      *
  66      * @param  \Zend\Ldap\Ldap $ldap
  67      * @param  resource        $resultId
  68      * @throws \Zend\Ldap\Exception\LdapException if no entries was found.
  69      * @return DefaultIterator
  70      */
  71     public function __construct(Ldap\Ldap $ldap, $resultId)
  72     {
  73         $this->ldap      = $ldap;
  74         $this->resultId  = $resultId;
  75
  76         $resource = $ldap->getResource();
  77         ErrorHandler::start();
  78         $this->itemCount = ldap_count_entries($resource, $resultId);
  79         ErrorHandler::stop();
  80         if ($this->itemCount === false) {
  81             throw new Exception\LdapException($this->ldap, 'counting entries');
  82         }
  83     }
  84
  85     public function __destruct()
  86     {
  87         $this->close();
  88     }
  89
  90     /**
  91      * Closes the current result set
  92      *
  93      * @return bool
  94      */
  95     public function close()
  96     {
  97         $isClosed = false;
  98         if (is_resource($this->resultId)) {
  99             ErrorHandler::start();
 100             $isClosed       = ldap_free_result($this->resultId);
 101             ErrorHandler::stop();
 102
 103             $this->resultId = null;
 104             $this->current  = null;
 105         }
 106         return $isClosed;
 107     }
 108
 109     /**
 110      * Gets the current LDAP connection.
 111      *
 112      * @return \Zend\Ldap\Ldap
 113      */
 114     public function getLDAP()
 115     {
 116         return $this->ldap;
 117     }
 118
 119     /**
 120      * Sets the attribute name treatment.
 121      *
 122      * Can either be one of the following constants
 123      * - Zend\Ldap\Collection\DefaultIterator::ATTRIBUTE_TO_LOWER
 124      * - Zend\Ldap\Collection\DefaultIterator::ATTRIBUTE_TO_UPPER
 125      * - Zend\Ldap\Collection\DefaultIterator::ATTRIBUTE_NATIVE
 126      * or a valid callback accepting the attribute's name as it's only
 127      * argument and returning the new attribute's name.
 128      *
 129      * @param  int|callable $attributeNameTreatment
 130      * @return DefaultIterator Provides a fluent interface
 131      */
 132     public function setAttributeNameTreatment($attributeNameTreatment)
 133     {
 134         if (is_callable($attributeNameTreatment)) {
 135             if (is_string($attributeNameTreatment) && !function_exists($attributeNameTreatment)) {
 136                 $this->attributeNameTreatment = self::ATTRIBUTE_TO_LOWER;
 137             } elseif (is_array($attributeNameTreatment)
 138                 && !method_exists($attributeNameTreatment[0], $attributeNameTreatment[1])
 139             ) {
 140                 $this->attributeNameTreatment = self::ATTRIBUTE_TO_LOWER;
 141             } else {
 142                 $this->attributeNameTreatment = $attributeNameTreatment;
 143             }
 144         } else {
 145             $attributeNameTreatment = (int) $attributeNameTreatment;
 146             switch ($attributeNameTreatment) {
 147                 case self::ATTRIBUTE_TO_LOWER:
 148                 case self::ATTRIBUTE_TO_UPPER:
 149                 case self::ATTRIBUTE_NATIVE:
 150                     $this->attributeNameTreatment = $attributeNameTreatment;
 151                     break;
 152                 default:
 153                     $this->attributeNameTreatment = self::ATTRIBUTE_TO_LOWER;
 154                     break;
 155             }
 156         }
 157
 158         return $this;
 159     }
 160
 161     /**
 162      * Returns the currently set attribute name treatment
 163      *
 164      * @return int|callable
 165      */
 166     public function getAttributeNameTreatment()
 167     {
 168         return $this->attributeNameTreatment;
 169     }
 170
 171     /**
 172      * Returns the number of items in current result
 173      * Implements Countable
 174      *
 175      * @return int
 176      */
 177     public function count()
 178     {
 179         return $this->itemCount;
 180     }
 181
 182     /**
 183      * Return the current result item
 184      * Implements Iterator
 185      *
 186      * @return array|null
 187      * @throws \Zend\Ldap\Exception\LdapException
 188      */
 189     public function current()
 190     {
 191         if (!is_resource($this->current)) {
 192             $this->rewind();
 193         }
 194         if (!is_resource($this->current)) {
 195             return null;
 196         }
 197
 198         $entry         = array('dn' => $this->key());
 199         $berIdentifier = null;
 200
 201         $resource = $this->ldap->getResource();
 202         ErrorHandler::start();
 203         $name = ldap_first_attribute(
 204             $resource, $this->current,
 205             $berIdentifier
 206         );
 207         ErrorHandler::stop();
 208
 209         while ($name) {
 210             ErrorHandler::start();
 211             $data = ldap_get_values_len($resource, $this->current, $name);
 212             ErrorHandler::stop();
 213
 214             if (!$data) {
 215                 $data = array();
 216             }
 217
 218             if (isset($data['count'])) {
 219                 unset($data['count']);
 220             }
 221
 222             switch ($this->attributeNameTreatment) {
 223                 case self::ATTRIBUTE_TO_LOWER:
 224                     $attrName = strtolower($name);
 225                     break;
 226                 case self::ATTRIBUTE_TO_UPPER:
 227                     $attrName = strtoupper($name);
 228                     break;
 229                 case self::ATTRIBUTE_NATIVE:
 230                     $attrName = $name;
 231                     break;
 232                 default:
 233                     $attrName = call_user_func($this->attributeNameTreatment, $name);
 234                     break;
 235             }
 236             $entry[$attrName] = $data;
 237
 238             ErrorHandler::start();
 239             $name = ldap_next_attribute(
 240                 $resource, $this->current,
 241                 $berIdentifier
 242             );
 243             ErrorHandler::stop();
 244         }
 245         ksort($entry, SORT_LOCALE_STRING);
 246         return $entry;
 247     }
 248
 249     /**
 250      * Return the result item key
 251      * Implements Iterator
 252      *
 253      * @throws \Zend\Ldap\Exception\LdapException
 254      * @return string|null
 255      */
 256     public function key()
 257     {
 258         if (!is_resource($this->current)) {
 259             $this->rewind();
 260         }
 261         if (is_resource($this->current)) {
 262             $resource = $this->ldap->getResource();
 263             ErrorHandler::start();
 264             $currentDn = ldap_get_dn($resource, $this->current);
 265             ErrorHandler::stop();
 266
 267             if ($currentDn === false) {
 268                 throw new Exception\LdapException($this->ldap, 'getting dn');
 269             }
 270
 271             return $currentDn;
 272         } else {
 273             return null;
 274         }
 275     }
 276
 277     /**
 278      * Move forward to next result item
 279      * Implements Iterator
 280      *
 281      * @throws \Zend\Ldap\Exception\LdapException
 282      */
 283     public function next()
 284     {
 285         $code = 0;
 286
 287         if (is_resource($this->current) && $this->itemCount > 0) {
 288             $resource = $this->ldap->getResource();
 289             ErrorHandler::start();
 290             $this->current = ldap_next_entry($resource, $this->current);
 291             ErrorHandler::stop();
 292             if ($this->current === false) {
 293                 $msg = $this->ldap->getLastError($code);
 294                 if ($code === Exception\LdapException::LDAP_SIZELIMIT_EXCEEDED) {
 295                     // we have reached the size limit enforced by the server
 296                     return;
 297                 } elseif ($code > Exception\LdapException::LDAP_SUCCESS) {
 298                     throw new Exception\LdapException($this->ldap, 'getting next entry (' . $msg . ')');
 299                 }
 300             }
 301         } else {
 302             $this->current = false;
 303         }
 304     }
 305
 306     /**
 307      * Rewind the Iterator to the first result item
 308      * Implements Iterator
 309      *
 310      *
 311      * @throws \Zend\Ldap\Exception\LdapException
 312      */
 313     public function rewind()
 314     {
 315         if (is_resource($this->resultId)) {
 316             $resource = $this->ldap->getResource();
 317             ErrorHandler::start();
 318             $this->current = ldap_first_entry($resource, $this->resultId);
 319             ErrorHandler::stop();
 320             if ($this->current === false
 321                 && $this->ldap->getLastErrorCode() > Exception\LdapException::LDAP_SUCCESS
 322             ) {
 323                 throw new Exception\LdapException($this->ldap, 'getting first entry');
 324             }
 325         }
 326     }
 327
 328     /**
 329      * Check if there is a current result item
 330      * after calls to rewind() or next()
 331      * Implements Iterator
 332      *
 333      * @return bool
 334      */
 335     public function valid()
 336     {
 337         return (is_resource($this->current));
 338     }
 339 }