source: trunk/library/Zend/Ldap/Dn.php @ 4456

Revision 4456, 23.8 KB checked in by airton, 13 years ago (diff)

Ticket #1991 - Parametrizacao das buscas LDAP no Expresso Mail - Adicionando arquivos e bibliotecas
  • Property svn:executable set to *
Line 
1<?php
2/**
3 * Zend Framework
4 *
5 * LICENSE
6 *
7 * This source file is subject to the new BSD license that is bundled
8 * with this package in the file LICENSE.txt.
9 * It is also available through the world-wide-web at this URL:
10 * http://framework.zend.com/license/new-bsd
11 * If you did not receive a copy of the license and are unable to
12 * obtain it through the world-wide-web, please send an email
13 * to license@zend.com so we can send you a copy immediately.
14 *
15 * @category   Zend
16 * @package    Zend_Ldap
17 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
18 * @license    http://framework.zend.com/license/new-bsd     New BSD License
19 * @version    $Id: Dn.php 22662 2010-07-24 17:37:36Z mabe $
20 */
21
22/**
23 * Zend_Ldap_Dn provides an API for DN manipulation
24 *
25 * @category   Zend
26 * @package    Zend_Ldap
27 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
28 * @license    http://framework.zend.com/license/new-bsd     New BSD License
29 */
30class Zend_Ldap_Dn implements ArrayAccess
31{
32    const ATTR_CASEFOLD_NONE  = 'none';
33    const ATTR_CASEFOLD_UPPER = 'upper';
34    const ATTR_CASEFOLD_LOWER = 'lower';
35
36    /**
37     * The default case fold to use
38     *
39     * @var string
40     */
41    protected static $_defaultCaseFold = self::ATTR_CASEFOLD_NONE;
42
43    /**
44     * The case fold used for this instance
45     *
46     * @var string
47     */
48    protected $_caseFold;
49
50    /**
51     * The DN data
52     *
53     * @var array
54     */
55    protected $_dn;
56
57    /**
58     * Creates a DN from an array or a string
59     *
60     * @param  string|array $dn
61     * @param  string|null  $caseFold
62     * @return Zend_Ldap_Dn
63     * @throws Zend_Ldap_Exception
64     */
65    public static function factory($dn, $caseFold = null)
66    {
67        if (is_array($dn)) {
68            return self::fromArray($dn, $caseFold);
69        } else if (is_string($dn)) {
70            return self::fromString($dn, $caseFold);
71        } else {
72            /**
73             * Zend_Ldap_Exception
74             */
75            require_once 'Zend/Ldap/Exception.php';
76            throw new Zend_Ldap_Exception(null, 'Invalid argument type for $dn');
77        }
78    }
79
80    /**
81     * Creates a DN from a string
82     *
83     * @param  string      $dn
84     * @param  string|null $caseFold
85     * @return Zend_Ldap_Dn
86     * @throws Zend_Ldap_Exception
87     */
88    public static function fromString($dn, $caseFold = null)
89    {
90        $dn = trim($dn);
91        if (empty($dn)) {
92            $dnArray = array();
93        } else {
94            $dnArray = self::explodeDn((string)$dn);
95        }
96        return new self($dnArray, $caseFold);
97    }
98
99    /**
100     * Creates a DN from an array
101     *
102     * @param  array       $dn
103     * @param  string|null $caseFold
104     * @return Zend_Ldap_Dn
105     * @throws Zend_Ldap_Exception
106     */
107    public static function fromArray(array $dn, $caseFold = null)
108    {
109         return new self($dn, $caseFold);
110    }
111
112    /**
113     * Constructor
114     *
115     * @param array       $dn
116     * @param string|null $caseFold
117     */
118    protected function __construct(array $dn, $caseFold)
119    {
120        $this->_dn = $dn;
121        $this->setCaseFold($caseFold);
122    }
123
124    /**
125     * Gets the RDN of the current DN
126     *
127     * @param  string $caseFold
128     * @return array
129     * @throws Zend_Ldap_Exception if DN has no RDN (empty array)
130     */
131    public function getRdn($caseFold = null)
132    {
133        $caseFold = self::_sanitizeCaseFold($caseFold, $this->_caseFold);
134        return self::_caseFoldRdn($this->get(0, 1, $caseFold), null);
135    }
136
137    /**
138     * Gets the RDN of the current DN as a string
139     *
140     * @param  string $caseFold
141     * @return string
142     * @throws Zend_Ldap_Exception if DN has no RDN (empty array)
143     */
144    public function getRdnString($caseFold = null)
145    {
146        $caseFold = self::_sanitizeCaseFold($caseFold, $this->_caseFold);
147        return self::implodeRdn($this->getRdn(), $caseFold);
148    }
149
150    /**
151     * Get the parent DN $levelUp levels up the tree
152     *
153     * @param  int $levelUp
154     * @return Zend_Ldap_Dn
155     */
156    public function getParentDn($levelUp = 1)
157    {
158        $levelUp = (int)$levelUp;
159        if ($levelUp < 1 || $levelUp >= count($this->_dn)) {
160            /**
161             * Zend_Ldap_Exception
162             */
163            require_once 'Zend/Ldap/Exception.php';
164            throw new Zend_Ldap_Exception(null, 'Cannot retrieve parent DN with given $levelUp');
165        }
166        $newDn = array_slice($this->_dn, $levelUp);
167        return new self($newDn, $this->_caseFold);
168    }
169
170    /**
171     * Get a DN part
172     *
173     * @param  int    $index
174     * @param  int    $length
175     * @param  string $caseFold
176     * @return array
177     * @throws Zend_Ldap_Exception if index is illegal
178     */
179    public function get($index, $length = 1, $caseFold = null)
180    {
181        $caseFold = self::_sanitizeCaseFold($caseFold, $this->_caseFold);
182        $this->_assertIndex($index);
183        $length = (int)$length;
184        if ($length <= 0) {
185            $length = 1;
186        }
187        if ($length === 1) {
188            return self::_caseFoldRdn($this->_dn[$index], $caseFold);
189        }
190        else {
191            return self::_caseFoldDn(array_slice($this->_dn, $index, $length, false), $caseFold);
192        }
193    }
194
195    /**
196     * Set a DN part
197     *
198     * @param  int   $index
199     * @param  array $value
200     * @return Zend_Ldap_Dn Provides a fluent interface
201     * @throws Zend_Ldap_Exception if index is illegal
202     */
203    public function set($index, array $value)
204    {
205        $this->_assertIndex($index);
206        self::_assertRdn($value);
207        $this->_dn[$index] = $value;
208        return $this;
209    }
210
211    /**
212     * Remove a DN part
213     *
214     * @param  int $index
215     * @param  int $length
216     * @return Zend_Ldap_Dn Provides a fluent interface
217     * @throws Zend_Ldap_Exception if index is illegal
218     */
219    public function remove($index, $length = 1)
220    {
221        $this->_assertIndex($index);
222        $length = (int)$length;
223        if ($length <= 0) {
224            $length = 1;
225        }
226        array_splice($this->_dn, $index, $length, null);
227        return $this;
228    }
229
230    /**
231     * Append a DN part
232     *
233     * @param  array $value
234     * @return Zend_Ldap_Dn Provides a fluent interface
235     */
236    public function append(array $value)
237    {
238        self::_assertRdn($value);
239        $this->_dn[] = $value;
240        return $this;
241    }
242
243    /**
244     * Prepend a DN part
245     *
246     * @param  array $value
247     * @return Zend_Ldap_Dn Provides a fluent interface
248     */
249    public function prepend(array $value)
250    {
251        self::_assertRdn($value);
252        array_unshift($this->_dn, $value);
253        return $this;
254    }
255
256    /**
257     * Insert a DN part
258     *
259     * @param  int   $index
260     * @param  array $value
261     * @return Zend_Ldap_Dn Provides a fluent interface
262     * @throws Zend_Ldap_Exception if index is illegal
263     */
264    public function insert($index, array $value)
265    {
266        $this->_assertIndex($index);
267        self::_assertRdn($value);
268        $first = array_slice($this->_dn, 0, $index + 1);
269        $second = array_slice($this->_dn, $index + 1);
270        $this->_dn = array_merge($first, array($value), $second);
271        return $this;
272    }
273
274    /**
275     * Assert index is correct and usable
276     *
277     * @param  mixed $index
278     * @return boolean
279     * @throws Zend_Ldap_Exception
280     */
281    protected function _assertIndex($index)
282    {
283        if (!is_int($index)) {
284            /**
285             * Zend_Ldap_Exception
286             */
287            require_once 'Zend/Ldap/Exception.php';
288            throw new Zend_Ldap_Exception(null, 'Parameter $index must be an integer');
289        }
290        if ($index < 0 || $index >= count($this->_dn)) {
291            /**
292             * Zend_Ldap_Exception
293             */
294            require_once 'Zend/Ldap/Exception.php';
295            throw new Zend_Ldap_Exception(null, 'Parameter $index out of bounds');
296        }
297        return true;
298    }
299
300    /**
301     * Assert if value is in a correct RDN format
302     *
303     * @param  array $value
304     * @return boolean
305     * @throws Zend_Ldap_Exception
306     */
307    protected static function _assertRdn(array $value)
308    {
309        if (count($value)<1) {
310            /**
311             * Zend_Ldap_Exception
312             */
313            require_once 'Zend/Ldap/Exception.php';
314            throw new Zend_Ldap_Exception(null, 'RDN Array is malformed: it must have at least one item');
315        }
316
317        foreach (array_keys($value) as $key) {
318            if (!is_string($key)) {
319                /**
320                 * Zend_Ldap_Exception
321                 */
322                require_once 'Zend/Ldap/Exception.php';
323                throw new Zend_Ldap_Exception(null, 'RDN Array is malformed: it must use string keys');
324            }
325        }
326    }
327
328    /**
329     * Sets the case fold
330     *
331     * @param string|null $caseFold
332     */
333    public function setCaseFold($caseFold)
334    {
335        $this->_caseFold = self::_sanitizeCaseFold($caseFold, self::$_defaultCaseFold);
336    }
337
338    /**
339     * Return DN as a string
340     *
341     * @param  string $caseFold
342     * @return string
343     * @throws Zend_Ldap_Exception
344     */
345    public function toString($caseFold = null)
346    {
347        $caseFold = self::_sanitizeCaseFold($caseFold, $this->_caseFold);
348        return self::implodeDn($this->_dn, $caseFold);
349    }
350
351    /**
352     * Return DN as an array
353     *
354     * @param  string $caseFold
355     * @return array
356     */
357    public function toArray($caseFold = null)
358    {
359        $caseFold = self::_sanitizeCaseFold($caseFold, $this->_caseFold);
360
361        if ($caseFold === self::ATTR_CASEFOLD_NONE) {
362            return $this->_dn;
363        } else {
364            return self::_caseFoldDn($this->_dn, $caseFold);
365        }
366    }
367
368    /**
369     * Do a case folding on a RDN
370     *
371     * @param  array  $part
372     * @param  string $caseFold
373     * @return array
374     */
375    protected static function _caseFoldRdn(array $part, $caseFold)
376    {
377        switch ($caseFold) {
378            case self::ATTR_CASEFOLD_UPPER:
379                return array_change_key_case($part, CASE_UPPER);
380            case self::ATTR_CASEFOLD_LOWER:
381                return array_change_key_case($part, CASE_LOWER);
382            case self::ATTR_CASEFOLD_NONE:
383            default:
384                return $part;
385        }
386    }
387
388    /**
389     * Do a case folding on a DN ort part of it
390     *
391     * @param  array  $dn
392     * @param  string $caseFold
393     * @return array
394     */
395    protected static function _caseFoldDn(array $dn, $caseFold)
396    {
397        $return = array();
398        foreach ($dn as $part) {
399            $return[] = self::_caseFoldRdn($part, $caseFold);
400        }
401        return $return;
402    }
403
404    /**
405     * Cast to string representation {@see toString()}
406     *
407     * @return string
408     */
409    public function __toString()
410    {
411        return $this->toString();
412    }
413
414    /**
415     * Required by the ArrayAccess implementation
416     *
417     * @param  int $offset
418     * @return boolean
419     */
420    public function offsetExists($offset)
421    {
422        $offset = (int)$offset;
423        if ($offset < 0 || $offset >= count($this->_dn)) {
424            return false;
425        } else {
426            return true;
427        }
428    }
429
430    /**
431     * Proxy to {@see get()}
432     * Required by the ArrayAccess implementation
433     *
434     * @param  int $offset
435     * @return array
436     */
437     public function offsetGet($offset)
438     {
439         return $this->get($offset, 1, null);
440     }
441
442     /**
443      * Proxy to {@see set()}
444      * Required by the ArrayAccess implementation
445      *
446      * @param int   $offset
447      * @param array $value
448      */
449     public function offsetSet($offset, $value)
450     {
451         $this->set($offset, $value);
452     }
453
454     /**
455      * Proxy to {@see remove()}
456      * Required by the ArrayAccess implementation
457      *
458      * @param int $offset
459      */
460     public function offsetUnset($offset)
461     {
462         $this->remove($offset, 1);
463     }
464
465    /**
466     * Sets the default case fold
467     *
468     * @param string $caseFold
469     */
470    public static function setDefaultCaseFold($caseFold)
471    {
472        self::$_defaultCaseFold = self::_sanitizeCaseFold($caseFold, self::ATTR_CASEFOLD_NONE);
473    }
474
475    /**
476     * Sanitizes the case fold
477     *
478     * @param  string $caseFold
479     * @return string
480     */
481    protected static function _sanitizeCaseFold($caseFold, $default)
482    {
483        switch ($caseFold) {
484            case self::ATTR_CASEFOLD_NONE:
485            case self::ATTR_CASEFOLD_UPPER:
486            case self::ATTR_CASEFOLD_LOWER:
487                return $caseFold;
488                break;
489            default:
490                return $default;
491                break;
492        }
493    }
494
495    /**
496     * Escapes a DN value according to RFC 2253
497     *
498     * Escapes the given VALUES according to RFC 2253 so that they can be safely used in LDAP DNs.
499     * The characters ",", "+", """, "\", "<", ">", ";", "#", " = " with a special meaning in RFC 2252
500     * are preceeded by ba backslash. Control characters with an ASCII code < 32 are represented as \hexpair.
501     * Finally all leading and trailing spaces are converted to sequences of \20.
502     * @see Net_LDAP2_Util::escape_dn_value() from Benedikt Hallinger <beni@php.net>
503     * @link http://pear.php.net/package/Net_LDAP2
504     * @author Benedikt Hallinger <beni@php.net>
505     *
506     * @param  string|array $values An array containing the DN values that should be escaped
507     * @return array The array $values, but escaped
508     */
509    public static function escapeValue($values = array())
510    {
511        /**
512         * @see Zend_Ldap_Converter
513         */
514        require_once 'Zend/Ldap/Converter.php';
515
516        if (!is_array($values)) $values = array($values);
517        foreach ($values as $key => $val) {
518            // Escaping of filter meta characters
519            $val = str_replace(array('\\', ',', '+', '"', '<', '>', ';', '#', '=', ),
520                array('\\\\', '\,', '\+', '\"', '\<', '\>', '\;', '\#', '\='), $val);
521            $val = Zend_Ldap_Converter::ascToHex32($val);
522
523            // Convert all leading and trailing spaces to sequences of \20.
524            if (preg_match('/^(\s*)(.+?)(\s*)$/', $val, $matches)) {
525                $val = $matches[2];
526                for ($i = 0; $i<strlen($matches[1]); $i++) {
527                    $val = '\20' . $val;
528                }
529                for ($i = 0; $i<strlen($matches[3]); $i++) {
530                    $val = $val . '\20';
531                }
532            }
533            if (null === $val) $val = '\0';  // apply escaped "null" if string is empty
534            $values[$key] = $val;
535        }
536        return (count($values) == 1) ? $values[0] : $values;
537    }
538
539    /**
540     * Undoes the conversion done by {@link escapeValue()}.
541     *
542     * Any escape sequence starting with a baskslash - hexpair or special character -
543     * will be transformed back to the corresponding character.
544     * @see Net_LDAP2_Util::escape_dn_value() from Benedikt Hallinger <beni@php.net>
545     * @link http://pear.php.net/package/Net_LDAP2
546     * @author Benedikt Hallinger <beni@php.net>
547     *
548     * @param  string|array $values Array of DN Values
549     * @return array Same as $values, but unescaped
550     */
551    public static function unescapeValue($values = array())
552    {
553        /**
554         * @see Zend_Ldap_Converter
555         */
556        require_once 'Zend/Ldap/Converter.php';
557
558        if (!is_array($values)) $values = array($values);
559        foreach ($values as $key => $val) {
560            // strip slashes from special chars
561            $val = str_replace(array('\\\\', '\,', '\+', '\"', '\<', '\>', '\;', '\#', '\='),
562                array('\\', ',', '+', '"', '<', '>', ';', '#', '=', ), $val);
563            $values[$key] = Zend_Ldap_Converter::hex32ToAsc($val);
564        }
565        return (count($values) == 1) ? $values[0] : $values;
566    }
567
568    /**
569     * Creates an array containing all parts of the given DN.
570     *
571     * Array will be of type
572     * array(
573     *      array("cn" => "name1", "uid" => "user"),
574     *      array("cn" => "name2"),
575     *      array("dc" => "example"),
576     *      array("dc" => "org")
577     * )
578     * for a DN of cn=name1+uid=user,cn=name2,dc=example,dc=org.
579     *
580     * @param  string $dn
581     * @param  array  $keys     An optional array to receive DN keys (e.g. CN, OU, DC, ...)
582     * @param  array  $vals     An optional array to receive DN values
583     * @param  string $caseFold
584     * @return array
585     * @throws Zend_Ldap_Exception
586     */
587    public static function explodeDn($dn, array &$keys = null, array &$vals = null,
588        $caseFold = self::ATTR_CASEFOLD_NONE)
589    {
590        $k = array();
591        $v = array();
592        if (!self::checkDn($dn, $k, $v, $caseFold)) {
593            /**
594             * Zend_Ldap_Exception
595             */
596            require_once 'Zend/Ldap/Exception.php';
597            throw new Zend_Ldap_Exception(null, 'DN is malformed');
598        }
599        $ret = array();
600        for ($i = 0; $i < count($k); $i++) {
601            if (is_array($k[$i]) && is_array($v[$i]) && (count($k[$i]) === count($v[$i]))) {
602                $multi = array();
603                for ($j = 0; $j < count($k[$i]); $j++) {
604                    $key=$k[$i][$j];
605                    $val=$v[$i][$j];
606                    $multi[$key] = $val;
607                }
608                $ret[] = $multi;
609            } else if (is_string($k[$i]) && is_string($v[$i])) {
610                $ret[] = array($k[$i] => $v[$i]);
611            }
612        }
613        if ($keys !== null) $keys = $k;
614        if ($vals !== null) $vals = $v;
615        return $ret;
616    }
617
618    /**
619     * @param  string $dn       The DN to parse
620     * @param  array  $keys     An optional array to receive DN keys (e.g. CN, OU, DC, ...)
621     * @param  array  $vals     An optional array to receive DN values
622     * @param  string $caseFold
623     * @return boolean True if the DN was successfully parsed or false if the string is not a valid DN.
624     */
625    public static function checkDn($dn, array &$keys = null, array &$vals = null,
626        $caseFold = self::ATTR_CASEFOLD_NONE)
627    {
628        /* This is a classic state machine parser. Each iteration of the
629         * loop processes one character. State 1 collects the key. When equals ( = )
630         * is encountered the state changes to 2 where the value is collected
631         * until a comma (,) or semicolon (;) is encountered after which we switch back
632         * to state 1. If a backslash (\) is encountered, state 3 is used to collect the
633         * following character without engaging the logic of other states.
634         */
635        $key = null;
636        $value = null;
637        $slen = strlen($dn);
638        $state = 1;
639        $ko = $vo = 0;
640        $multi = false;
641        $ka = array();
642        $va = array();
643        for ($di = 0; $di <= $slen; $di++) {
644            $ch = ($di == $slen) ? 0 : $dn[$di];
645            switch ($state) {
646                case 1: // collect key
647                    if ($ch === '=') {
648                        $key = trim(substr($dn, $ko, $di - $ko));
649                        if ($caseFold == self::ATTR_CASEFOLD_LOWER) $key = strtolower($key);
650                        else if ($caseFold == self::ATTR_CASEFOLD_UPPER) $key = strtoupper($key);
651                        if (is_array($multi)) {
652                            $keyId = strtolower($key);
653                            if (in_array($keyId, $multi)) {
654                                return false;
655                            }
656                            $ka[count($ka)-1][] = $key;
657                            $multi[] = $keyId;
658                        } else {
659                            $ka[] = $key;
660                        }
661                        $state = 2;
662                        $vo = $di + 1;
663                    } else if ($ch === ',' || $ch === ';' || $ch === '+') {
664                        return false;
665                    }
666                    break;
667                case 2: // collect value
668                    if ($ch === '\\') {
669                        $state = 3;
670                    } else if ($ch === ',' || $ch === ';' || $ch === 0 || $ch === '+') {
671                        $value = self::unescapeValue(trim(substr($dn, $vo, $di - $vo)));
672                        if (is_array($multi)) {
673                            $va[count($va)-1][] = $value;
674                        } else {
675                            $va[] = $value;
676                        }
677                        $state = 1;
678                        $ko = $di + 1;
679                        if ($ch === '+' && $multi === false) {
680                            $lastKey = array_pop($ka);
681                            $lastVal = array_pop($va);
682                            $ka[] = array($lastKey);
683                            $va[] = array($lastVal);
684                            $multi = array(strtolower($lastKey));
685                        } else if ($ch === ','|| $ch === ';' || $ch === 0) {
686                            $multi = false;
687                        }
688                    } else if ($ch === '=') {
689                        return false;
690                    }
691                    break;
692                case 3: // escaped
693                    $state = 2;
694                    break;
695            }
696        }
697
698        if ($keys !== null) {
699            $keys = $ka;
700        }
701        if ($vals !== null) {
702            $vals = $va;
703        }
704
705        return ($state === 1 && $ko > 0);
706    }
707
708    /**
709     * Returns a DN part in the form $attribute = $value
710     *
711     * This method supports the creation of multi-valued RDNs
712     * $part must contain an even number of elemets.
713     *
714     * @param  array  $attribute
715     * @param  string $caseFold
716     * @return string
717     * @throws Zend_Ldap_Exception
718     */
719    public static function implodeRdn(array $part, $caseFold = null)
720    {
721        self::_assertRdn($part);
722        $part = self::_caseFoldRdn($part, $caseFold);
723        $rdnParts = array();
724        foreach ($part as $key => $value) {
725            $value = self::escapeValue($value);
726            $keyId = strtolower($key);
727            $rdnParts[$keyId] =  implode('=', array($key, $value));
728        }
729        ksort($rdnParts, SORT_STRING);
730        return implode('+', $rdnParts);
731    }
732
733    /**
734     * Implodes an array in the form delivered by {@link explodeDn()}
735     * to a DN string.
736     *
737     * $dnArray must be of type
738     * array(
739     *      array("cn" => "name1", "uid" => "user"),
740     *      array("cn" => "name2"),
741     *      array("dc" => "example"),
742     *      array("dc" => "org")
743     * )
744     *
745     * @param  array  $dnArray
746     * @param  string $caseFold
747     * @param  string $separator
748     * @return string
749     * @throws Zend_Ldap_Exception
750     */
751    public static function implodeDn(array $dnArray, $caseFold = null, $separator = ',')
752    {
753        $parts = array();
754        foreach ($dnArray as $p) {
755            $parts[] = self::implodeRdn($p, $caseFold);
756        }
757        return implode($separator, $parts);
758    }
759
760    /**
761     * Checks if given $childDn is beneath $parentDn subtree.
762     *
763     * @param  string|Zend_Ldap_Dn $childDn
764     * @param  string|Zend_Ldap_Dn $parentDn
765     * @return boolean
766     */
767    public static function isChildOf($childDn, $parentDn)
768    {
769        try {
770            $keys = array();
771            $vals = array();
772            if ($childDn instanceof Zend_Ldap_Dn) {
773                $cdn = $childDn->toArray(Zend_Ldap_Dn::ATTR_CASEFOLD_LOWER);
774            } else {
775                $cdn = self::explodeDn($childDn, $keys, $vals, Zend_Ldap_Dn::ATTR_CASEFOLD_LOWER);
776            }
777            if ($parentDn instanceof Zend_Ldap_Dn) {
778                $pdn = $parentDn->toArray(Zend_Ldap_Dn::ATTR_CASEFOLD_LOWER);
779            } else {
780                $pdn = self::explodeDn($parentDn, $keys, $vals, Zend_Ldap_Dn::ATTR_CASEFOLD_LOWER);
781            }
782        }
783        catch (Zend_Ldap_Exception $e) {
784            return false;
785        }
786
787        $startIndex = count($cdn)-count($pdn);
788        if ($startIndex<0) return false;
789        for ($i = 0; $i<count($pdn); $i++) {
790            if ($cdn[$i+$startIndex] != $pdn[$i]) return false;
791        }
792        return true;
793    }
794}
Note: See TracBrowser for help on using the repository browser.