├── CHANGELOG.md
├── LICENSE.md
├── README.md
├── Vagrantfile
├── composer.json
└── src
    ├── Attribute.php
    ├── Collection.php
    ├── Collection
        └── DefaultIterator.php
    ├── Converter
        ├── Converter.php
        └── Exception
        │   ├── ConverterException.php
        │   ├── ExceptionInterface.php
        │   ├── InvalidArgumentException.php
        │   └── UnexpectedValueException.php
    ├── Dn.php
    ├── ErrorHandler.php
    ├── ErrorHandlerInterface.php
    ├── Exception
        ├── BadMethodCallException.php
        ├── ExceptionInterface.php
        ├── InvalidArgumentException.php
        └── LdapException.php
    ├── Filter.php
    ├── Filter
        ├── AbstractFilter.php
        ├── AbstractLogicalFilter.php
        ├── AndFilter.php
        ├── Exception
        │   ├── ExceptionInterface.php
        │   └── FilterException.php
        ├── MaskFilter.php
        ├── NotFilter.php
        ├── OrFilter.php
        └── StringFilter.php
    ├── Ldap.php
    ├── Ldif
        └── Encoder.php
    ├── Node.php
    └── Node
        ├── AbstractNode.php
        ├── ChildrenIterator.php
        ├── Collection.php
        ├── RootDse.php
        ├── RootDse
            ├── ActiveDirectory.php
            ├── OpenLdap.php
            └── eDirectory.php
        ├── Schema.php
        └── Schema
            ├── AbstractItem.php
            ├── ActiveDirectory.php
            ├── AttributeType
                ├── ActiveDirectory.php
                ├── AttributeTypeInterface.php
                └── OpenLdap.php
            ├── ObjectClass
                ├── ActiveDirectory.php
                ├── ObjectClassInterface.php
                └── OpenLdap.php
            └── OpenLdap.php


/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | All notable changes to this project will be documented in this file, in reverse chronological order by release.
  4 | 
  5 | ## 2.10.2 - TBD
  6 | 
  7 | ### Added
  8 | 
  9 | - Nothing.
 10 | 
 11 | ### Changed
 12 | 
 13 | - Nothing.
 14 | 
 15 | ### Deprecated
 16 | 
 17 | - Nothing.
 18 | 
 19 | ### Removed
 20 | 
 21 | - Nothing.
 22 | 
 23 | ### Fixed
 24 | 
 25 | - Nothing.
 26 | 
 27 | ## 2.10.1 - 2019-10-17
 28 | 
 29 | ### Added
 30 | 
 31 | - [#82](https://github.com/zendframework/zend-ldap/pull/82) adds support for PHP 7.3.
 32 | 
 33 | ### Deprecated
 34 | 
 35 | - Nothing.
 36 | 
 37 | ### Removed
 38 | 
 39 | - Nothing.
 40 | 
 41 | ### Fixed
 42 | 
 43 | - Nothing.
 44 | 
 45 | ## 2.10.0 - 2018-07-05
 46 | 
 47 | ### Added
 48 | 
 49 | - [#64](https://github.com/zendframework/zend-ldap/pull/64) Adds support for SASL-Bind - Thanks to @mbaynton
 50 | - [#66](https://github.com/zendframework/zend-ldap/pull/66) Adds support for automatic reconnection - Thanks to @mbaynton
 51 | - [#73](https://github.com/zendframework/zend-ldap/pull/73) Adds support for modifying attributes - Thanks to @glimac and @mbaynton
 52 | 
 53 | ### Deprecated
 54 | 
 55 | - Nothing.
 56 | 
 57 | ### Removed
 58 | 
 59 | - [#69](https://github.com/zendframework/zend-ldap/pull/69) Drop support for OpenLDAP < 2.2 due to using ldap-URI exclusively - Thanks to @fduch
 60 | 
 61 | ### Fixed
 62 | 
 63 | - [#51](https://github.com/zendframework/zend-ldap/issues/51) Use ldap_escape to escape values instead of own function - Thanks to @KaelBaldwin
 64 | 
 65 | ## 2.9.0 - 2018-04-25
 66 | 
 67 | ### Added
 68 | 
 69 | - [#78](https://github.com/zendframework/zend-ldap/pull/78) Added support for PHP 7.2
 70 | - [#60](https://github.com/zendframework/zend-ldap/pull/60) Adds tests for nightly PHP-builds
 71 | 
 72 | ### Deprecated
 73 | 
 74 | - Nothing.
 75 | 
 76 | ### Removed
 77 | 
 78 | - [#61](https://github.com/zendframework/zend-ldap/pull/61) Removed support for PHP 5.5.
 79 | - [#78](https://github.com/zendframework/zend-ldap/pull/78) Removed support for HHVM.
 80 | 
 81 | ### Fixed
 82 | 
 83 | - [#71](https://github.com/zendframework/zend-ldap/pull/71) Removes composer-flag ```--ignore-platform-deps``` to fix Travis-CI build
 84 | - [#77](https://github.com/zendframework/zend-ldap/pull/77) Fixes links to PR in CHANGELOG.md)
 85 | - [#78](https://github.com/zendframework/zend-ldap/pull/78) Updated Location for docs.
 86 | - [#78](https://github.com/zendframework/zend-ldap/pull/78) Updated PHPUnit.
 87 | 
 88 | ## 2.8.0 - 2017-03-06
 89 | 
 90 | ### Added
 91 | 
 92 | - [#53](https://github.com/zendframework/zend-ldap/pull/53) Adds addAttribute-method
 93 | to Ldap-class
 94 | - [#57](https://github.com/zendframework/zend-ldap/pull/57) adds support for new
 95 | coding-standards.
 96 | 
 97 | ### Deprecated
 98 | 
 99 | - Nothing.
100 | 
101 | ### Removed
102 | 
103 | - Nothing.
104 | 
105 | ### Fixed
106 | 
107 | - Nothing.
108 | 
109 | ## 2.7.1 - 2016-05-23
110 | 
111 | ### Added
112 | 
113 | - [#48](https://github.com/zendframework/zend-ldap/pull/48) adds and publishes
114 |   the documentation to https://zendframework.github.io/zend-ldap/
115 | 
116 | ### Deprecated
117 | 
118 | - Nothing.
119 | 
120 | ### Removed
121 | 
122 | - Nothing.
123 | 
124 | ### Fixed
125 | 
126 | - [#47](https://github.com/zendframework/zend-ldap/pull/47) Fixes a BC-Break caused
127 |   by the missing default-ErrorHandler
128 | 
129 | ## 2.7.0 - 2016-04-21
130 | 
131 | ### Added
132 | 
133 | - [#43](https://github.com/zendframework/zend-ldap/pull/43) Adds possibility
134 |   to use [Zend\StdLib](https://github.com/zendframework/zend-stdlib) and
135 |   [Zend\EventManager](https://github.com/zendframework/zend-eventmanager) in
136 |   Version 3
137 | - Support for PHP7
138 | 
139 | ### Deprecated
140 | 
141 | - Nothing.
142 | 
143 | ### Removed
144 | 
145 | - [#21](https://github.com/zendframework/zend-ldap/pull/21) Removes dependency
146 |   Zend\StdLib
147 | 
148 | ### Fixed
149 | 
150 | - [#17](https://github.com/zendframework/zend-ldap/issues/17) Fixes HHVM builds
151 | - [#44](https://github.com/zendframework/zend-ldap/pull/44) Fixes broken builds
152 |   in PHP7 due to faulty sorting-test
153 | - [#40](https://github.com/zendframework/zend-ldap/pull/40) Fixes connection test
154 |   that failed due to different failure messages in PHP5 and 7
155 | 
156 | ## 2.6.1 - 2016-04-20
157 | 
158 | ### Added
159 | 
160 | - Nothing.
161 | 
162 | ### Deprecated
163 | 
164 | - Nothing.
165 | 
166 | ### Removed
167 | 
168 | - Nothing.
169 | 
170 | ### Fixed
171 | 
172 | - [#20](https://github.com/zendframework/zend-ldap/pull/20) checks whether the
173 |   LDAP-connection shall use SSL or not and decides based on that which port to
174 |   use if no port has been set.
175 | - [#25](https://github.com/zendframework/zend-ldap/issues/25) Check for correct
176 |   Headers in the documentation and fix it
177 | - [#27](https://github.com/zendframework/zend-ldap/issues/27) Check for different
178 |   issues in the documentation and fixed it
179 | - [#29](https://github.com/zendframework/zend-ldap/issues/29) Check for incorrect
180 |   Blockquotes in the documentation and fix it
181 | 
182 | 
183 | ## 2.6.0 - 2016-02-11
184 | 
185 | ### Added
186 | 
187 | - [#6](https://github.com/zendframework/zend-ldap/pull/6) Adds a possibility 
188 |   to delete attributes without having to remove the complete node and add it
189 |   again without the attribute
190 | 
191 | ### Deprecated
192 | 
193 | - Nothing.
194 | 
195 | ### Removed
196 | 
197 | - Nothing.
198 | 
199 | ### Fixed
200 | 
201 | - [#16](https://github.com/zendframework/zend-ldap/pull/16) Fixed the usage of
202 |   ```ldap_sort``` during sorting search-results due to deprecation of 
203 |   ```ldap_sort``` in PHP 7
204 | 
205 | ## 2.5.2 - 2016-02-11
206 | 
207 | ### Added
208 | 
209 | - [#16](https://github.com/zendframework/zend-ldap/pull/16) removes the call
210 |   to the now deprecated ldap_sort-function wile still preserving the
211 |   sort-functionality.
212 | - [#14](https://github.com/zendframework/zend-ldap/pull/14) adds a Vagrant
213 |   environment for running an LDAP server against which to run the tests;
214 |   additionally, it adds Travis-CI scripts for setting up an LDAP server with
215 |   test data.
216 | 
217 | ### Deprecated
218 | 
219 | - Nothing.
220 | 
221 | ### Removed
222 | 
223 | - Nothing.
224 | 
225 | ### Fixed
226 | 
227 | - [#18](https://github.com/zendframework/zend-ldap/pull/18) Fixes an already
228 |   removed second parameter to ```ldap_first_attribute``` and ```ldap_next_attribute```
229 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2005-2019, Zend Technologies USA, Inc.
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without modification,
 5 | are permitted provided that the following conditions are met:
 6 | 
 7 | - Redistributions of source code must retain the above copyright notice, this
 8 |   list of conditions and the following disclaimer.
 9 | 
10 | - Redistributions in binary form must reproduce the above copyright notice, this
11 |   list of conditions and the following disclaimer in the documentation and/or
12 |   other materials provided with the distribution.
13 | 
14 | - Neither the name of Zend Technologies USA, Inc. nor the names of its
15 |   contributors may be used to endorse or promote products derived from this
16 |   software without specific prior written permission.
17 | 
18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
19 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
22 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
25 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # zend-ldap
 2 | 
 3 | > ## Repository abandoned 2019-12-31
 4 | >
 5 | > This repository has moved to [laminas/laminas-ldap](https://github.com/laminas/laminas-ldap).
 6 | 
 7 | [![Build Status](https://secure.travis-ci.org/zendframework/zend-ldap.svg?branch=master)](https://secure.travis-ci.org/zendframework/zend-ldap)
 8 | [![Coverage Status](https://coveralls.io/repos/github/zendframework/zend-ldap/badge.svg?branch=master)](https://coveralls.io/github/zendframework/zend-ldap?branch=master)
 9 | 
10 | zend-ldap provides functionality for performing LDAP operations, including, but
11 | not limited to, binding, searching and modifying entries in an LDAP directory.
12 | 
13 | - File issues at https://github.com/zendframework/zend-ldap/issues
14 | - Documentation is at https://docs.zendframework.com/zend-ldap/
15 | 


--------------------------------------------------------------------------------
/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # -*- mode: ruby -*-
 2 | # vi: set ft=ruby :
 3 | 
 4 | $install_ldap = <<SCRIPT
 5 | export DEBIAN_FRONTEND=noninteractive
 6 | apt-get -yq update
 7 | apt-get -yq --no-install-suggests --no-install-recommends --force-yes install slapd ldap-utils apparmor-utils conntrack php5-cli
 8 | sudo aa-complain /usr/sbin/slapd
 9 | SCRIPT
10 | 
11 | $setup_vagrant_user_environment = <<SCRIPT
12 | if ! grep "cd /vagrant" /home/vagrant/.profile > /dev/null; then
13 |   echo "cd /vagrant" >> /home/vagrant/.profile
14 | fi
15 | SCRIPT
16 | 
17 | Vagrant.configure(2) do |config|
18 |   config.vm.box = 'bento/ubuntu-14.04'
19 | 
20 |   # LDAP port
21 |   config.vm.network 'forwarded_port', guest: 3890, host: 3890
22 |   config.vm.network 'forwarded_port', guest: 6360, host: 6360
23 |   # PHP embedded webserver port, running in .ci/php_scripts
24 |   config.vm.network 'forwarded_port', guest: 3891, host: 3891
25 | 
26 |   config.vm.provision 'shell', privileged: true, inline: '/vagrant/.ci/config_iptables.sh', :run => 'always'
27 |   config.vm.provision 'shell', inline: $install_ldap
28 |   config.vm.provision 'shell', privileged: false, inline: '/vagrant/.ci/OpenLDAP_run.sh', :run => 'always'
29 |   config.vm.provision 'shell', privileged: false, inline: '/vagrant/.ci/load_fixtures.sh', :run => 'always'
30 |   config.vm.provision 'shell', inline: $setup_vagrant_user_environment
31 | end
32 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "zendframework/zend-ldap",
 3 |     "description": "Provides support for LDAP operations including but not limited to binding, searching and modifying entries in an LDAP directory",
 4 |     "license": "BSD-3-Clause",
 5 |     "keywords": [
 6 |         "zf",
 7 |         "zendframework",
 8 |         "ldap"
 9 |     ],
10 |     "support": {
11 |         "docs": "https://docs.zendframework.com/zend-ldap/",
12 |         "issues": "https://github.com/zendframework/zend-ldap/issues",
13 |         "source": "https://github.com/zendframework/zend-ldap",
14 |         "rss": "https://github.com/zendframework/zend-ldap/releases.atom",
15 |         "chat": "https://zendframework-slack.herokuapp.com",
16 |         "forum": "https://discourse.zendframework.com/c/questions/components"
17 |     },
18 |     "require": {
19 |         "php": "^5.6 || ^7.0",
20 |         "ext-ldap": "*"
21 |     },
22 |     "require-dev": {
23 |         "php-mock/php-mock-phpunit": "^1.1.2 || ^2.1.1",
24 |         "phpunit/phpunit": "^5.7.27 || ^6.5.8 || ^7.1.2",
25 |         "zendframework/zend-coding-standard": "~1.0.0",
26 |         "zendframework/zend-config": "^2.5",
27 |         "zendframework/zend-eventmanager": "^2.6.3 || ^3.0.1",
28 |         "zendframework/zend-stdlib": "^2.7 || ^3.0"
29 |     },
30 |     "suggest": {
31 |         "zendframework/zend-eventmanager": "Zend\\EventManager component"
32 |     },
33 |     "autoload": {
34 |         "psr-4": {
35 |             "Zend\\Ldap\\": "src/"
36 |         }
37 |     },
38 |     "autoload-dev": {
39 |         "psr-4": {
40 |             "ZendTest\\Ldap\\": "test/"
41 |         }
42 |     },
43 |     "config": {
44 |         "sort-packages": true
45 |     },
46 |     "extra": {
47 |         "branch-alias": {
48 |             "dev-master": "2.10.x-dev",
49 |             "dev-develop": "2.11.x-dev"
50 |         }
51 |     },
52 |     "scripts": {
53 |         "check": [
54 |             "@cs-check",
55 |             "@test"
56 |         ],
57 |         "cs-check": "phpcs",
58 |         "cs-fix": "phpcbf",
59 |         "test": "phpunit --colors=always",
60 |         "test-coverage": "phpunit --colors=always --coverage-clover clover.xml"
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Attribute.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-2015 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;
 11 | 
 12 | use DateTime;
 13 | 
 14 | /**
 15 |  * Zend\Ldap\Attribute is a collection of LDAP attribute related functions.
 16 |  */
 17 | class Attribute
 18 | {
 19 |     const PASSWORD_HASH_MD5   = 'md5';
 20 |     const PASSWORD_HASH_SMD5  = 'smd5';
 21 |     const PASSWORD_HASH_SHA   = 'sha';
 22 |     const PASSWORD_HASH_SSHA  = 'ssha';
 23 |     const PASSWORD_UNICODEPWD = 'unicodePwd';
 24 | 
 25 |     /**
 26 |      * Sets a LDAP attribute.
 27 |      *
 28 |      * @param  array                     $data
 29 |      * @param  string                    $attribName
 30 |      * @param  string|array|\Traversable $value
 31 |      * @param  bool                   $append
 32 |      * @return void
 33 |      */
 34 |     public static function setAttribute(array &$data, $attribName, $value, $append = false)
 35 |     {
 36 |         $attribName = strtolower($attribName);
 37 |         $valArray   = [];
 38 |         if (is_array($value) || ($value instanceof \Traversable)) {
 39 |             foreach ($value as $v) {
 40 |                 $v = self::valueToLdap($v);
 41 |                 if ($v !== null) {
 42 |                     $valArray[] = $v;
 43 |                 }
 44 |             }
 45 |         } elseif ($value !== null) {
 46 |             $value = self::valueToLdap($value);
 47 |             if ($value !== null) {
 48 |                 $valArray[] = $value;
 49 |             }
 50 |         }
 51 | 
 52 |         if ($append === true && isset($data[$attribName])) {
 53 |             if (is_string($data[$attribName])) {
 54 |                 $data[$attribName] = [$data[$attribName]];
 55 |             }
 56 |             $data[$attribName] = array_merge($data[$attribName], $valArray);
 57 |         } else {
 58 |             $data[$attribName] = $valArray;
 59 |         }
 60 |     }
 61 | 
 62 |     /**
 63 |      * Gets a LDAP attribute.
 64 |      *
 65 |      * @param  array   $data
 66 |      * @param  string  $attribName
 67 |      * @param  int $index
 68 |      * @return array|mixed
 69 |      */
 70 |     public static function getAttribute(array $data, $attribName, $index = null)
 71 |     {
 72 |         $attribName = strtolower($attribName);
 73 |         if ($index === null) {
 74 |             if (! isset($data[$attribName])) {
 75 |                 return [];
 76 |             }
 77 |             $retArray = [];
 78 |             foreach ($data[$attribName] as $v) {
 79 |                 $retArray[] = self::valueFromLdap($v);
 80 |             }
 81 |             return $retArray;
 82 |         } elseif (is_int($index)) {
 83 |             if (! isset($data[$attribName])) {
 84 |                 return;
 85 |             } elseif ($index >= 0 && $index < count($data[$attribName])) {
 86 |                 return self::valueFromLdap($data[$attribName][$index]);
 87 |             } else {
 88 |                 return;
 89 |             }
 90 |         }
 91 | 
 92 |         return;
 93 |     }
 94 | 
 95 |     /**
 96 |      * Checks if the given value(s) exist in the attribute
 97 |      *
 98 |      * @param array       $data
 99 |      * @param string      $attribName
100 |      * @param mixed|array $value
101 |      * @return bool
102 |      */
103 |     public static function attributeHasValue(array &$data, $attribName, $value)
104 |     {
105 |         $attribName = strtolower($attribName);
106 |         if (! isset($data[$attribName])) {
107 |             return false;
108 |         }
109 | 
110 |         if (is_scalar($value)) {
111 |             $value = [$value];
112 |         }
113 | 
114 |         foreach ($value as $v) {
115 |             $v = self::valueToLdap($v);
116 |             if (! in_array($v, $data[$attribName], true)) {
117 |                 return false;
118 |             }
119 |         }
120 | 
121 |         return true;
122 |     }
123 | 
124 |     /**
125 |      * Removes duplicate values from a LDAP attribute
126 |      *
127 |      * @param array  $data
128 |      * @param string $attribName
129 |      * @return void
130 |      */
131 |     public static function removeDuplicatesFromAttribute(array &$data, $attribName)
132 |     {
133 |         $attribName = strtolower($attribName);
134 |         if (! isset($data[$attribName])) {
135 |             return;
136 |         }
137 |         $data[$attribName] = array_values(array_unique($data[$attribName]));
138 |     }
139 | 
140 |     /**
141 |      * Remove given values from a LDAP attribute
142 |      *
143 |      * @param array       $data
144 |      * @param string      $attribName
145 |      * @param mixed|array $value
146 |      * @return void
147 |      */
148 |     public static function removeFromAttribute(array &$data, $attribName, $value)
149 |     {
150 |         $attribName = strtolower($attribName);
151 |         if (! isset($data[$attribName])) {
152 |             return;
153 |         }
154 | 
155 |         if (is_scalar($value)) {
156 |             $value = [$value];
157 |         }
158 | 
159 |         $valArray = [];
160 |         foreach ($value as $v) {
161 |             $v = self::valueToLdap($v);
162 |             if ($v !== null) {
163 |                 $valArray[] = $v;
164 |             }
165 |         }
166 | 
167 |         $resultArray = $data[$attribName];
168 |         foreach ($valArray as $rv) {
169 |             $keys = array_keys($resultArray, $rv);
170 |             foreach ($keys as $k) {
171 |                 unset($resultArray[$k]);
172 |             }
173 |         }
174 |         $resultArray       = array_values($resultArray);
175 |         $data[$attribName] = $resultArray;
176 |     }
177 | 
178 |     /**
179 |      * @param  mixed $value
180 |      * @return string|null
181 |      */
182 |     private static function valueToLdap($value)
183 |     {
184 |         return Converter\Converter::toLdap($value);
185 |     }
186 | 
187 |     /**
188 |      * @param  string $value
189 |      * @return mixed
190 |      */
191 |     private static function valueFromLdap($value)
192 |     {
193 |         try {
194 |             $return = Converter\Converter::fromLdap($value, Converter\Converter::STANDARD, false);
195 |             if ($return instanceof DateTime) {
196 |                 return Converter\Converter::toLdapDateTime($return, false);
197 |             } else {
198 |                 return $return;
199 |             }
200 |         } catch (Converter\Exception\InvalidArgumentException $e) {
201 |             return $value;
202 |         }
203 |     }
204 | 
205 |     /**
206 |      * Sets a LDAP password.
207 |      *
208 |      * @param array  $data
209 |      * @param string $password
210 |      * @param string $hashType   Optional by default MD5
211 |      * @param string $attribName Optional
212 |      */
213 |     public static function setPassword(
214 |         array &$data,
215 |         $password,
216 |         $hashType = self::PASSWORD_HASH_MD5,
217 |         $attribName = null
218 |     ) {
219 |         if ($attribName === null) {
220 |             if ($hashType === self::PASSWORD_UNICODEPWD) {
221 |                 $attribName = 'unicodePwd';
222 |             } else {
223 |                 $attribName = 'userPassword';
224 |             }
225 |         }
226 | 
227 |         $hash = static::createPassword($password, $hashType);
228 |         static::setAttribute($data, $attribName, $hash, false);
229 |     }
230 | 
231 |     /**
232 |      * Creates a LDAP password.
233 |      *
234 |      * @param  string $password
235 |      * @param  string $hashType
236 |      * @return string
237 |      */
238 |     public static function createPassword($password, $hashType = self::PASSWORD_HASH_MD5)
239 |     {
240 |         switch ($hashType) {
241 |             case self::PASSWORD_UNICODEPWD:
242 |                 /* see:
243 |                  * http://msdn.microsoft.com/en-us/library/cc223248(PROT.10).aspx
244 |                  */
245 |                 $password = '"' . $password . '"';
246 |                 if (function_exists('mb_convert_encoding')) {
247 |                     $password = mb_convert_encoding($password, 'UTF-16LE', 'UTF-8');
248 |                 } elseif (function_exists('iconv')) {
249 |                     $password = iconv('UTF-8', 'UTF-16LE', $password);
250 |                 } else {
251 |                     $len = strlen($password);
252 |                     $new = '';
253 |                     for ($i = 0; $i < $len; $i++) {
254 |                         $new .= $password[$i] . "\x00";
255 |                     }
256 |                     $password = $new;
257 |                 }
258 |                 return $password;
259 |             case self::PASSWORD_HASH_SSHA:
260 |                 $salt    = substr(sha1(uniqid(mt_rand(), true), true), 0, 4);
261 |                 $rawHash = sha1($password . $salt, true) . $salt;
262 |                 $method  = '{SSHA}';
263 |                 break;
264 |             case self::PASSWORD_HASH_SHA:
265 |                 $rawHash = sha1($password, true);
266 |                 $method  = '{SHA}';
267 |                 break;
268 |             case self::PASSWORD_HASH_SMD5:
269 |                 $salt    = substr(sha1(uniqid(mt_rand(), true), true), 0, 4);
270 |                 $rawHash = md5($password . $salt, true) . $salt;
271 |                 $method  = '{SMD5}';
272 |                 break;
273 |             case self::PASSWORD_HASH_MD5:
274 |             default:
275 |                 $rawHash = md5($password, true);
276 |                 $method  = '{MD5}';
277 |                 break;
278 |         }
279 |         return $method . base64_encode($rawHash);
280 |     }
281 | 
282 |     /**
283 |      * Sets a LDAP date/time attribute.
284 |      *
285 |      * @param  array                      $data
286 |      * @param  string                     $attribName
287 |      * @param  int|array|\Traversable $value
288 |      * @param  bool                    $utc
289 |      * @param  bool                    $append
290 |      */
291 |     public static function setDateTimeAttribute(
292 |         array &$data,
293 |         $attribName,
294 |         $value,
295 |         $utc = false,
296 |         $append = false
297 |     ) {
298 |         $convertedValues = [];
299 |         if (is_array($value) || ($value instanceof \Traversable)) {
300 |             foreach ($value as $v) {
301 |                 $v = self::valueToLdapDateTime($v, $utc);
302 |                 if ($v !== null) {
303 |                     $convertedValues[] = $v;
304 |                 }
305 |             }
306 |         } elseif ($value !== null) {
307 |             $value = self::valueToLdapDateTime($value, $utc);
308 |             if ($value !== null) {
309 |                 $convertedValues[] = $value;
310 |             }
311 |         }
312 |         static::setAttribute($data, $attribName, $convertedValues, $append);
313 |     }
314 | 
315 |     /**
316 |      * @param  int $value
317 |      * @param  bool $utc
318 |      * @return string|null
319 |      */
320 |     private static function valueToLdapDateTime($value, $utc)
321 |     {
322 |         if (is_int($value)) {
323 |             return Converter\Converter::toLdapDateTime($value, $utc);
324 |         }
325 | 
326 |         return;
327 |     }
328 | 
329 |     /**
330 |      * Gets a LDAP date/time attribute.
331 |      *
332 |      * @param  array   $data
333 |      * @param  string  $attribName
334 |      * @param  int $index
335 |      * @return array|int
336 |      */
337 |     public static function getDateTimeAttribute(array $data, $attribName, $index = null)
338 |     {
339 |         $values = static::getAttribute($data, $attribName, $index);
340 |         if (is_array($values)) {
341 |             for ($i = 0, $count = count($values); $i < $count; $i++) {
342 |                 $newVal = self::valueFromLdapDateTime($values[$i]);
343 |                 if ($newVal !== null) {
344 |                     $values[$i] = $newVal;
345 |                 }
346 |             }
347 |         } else {
348 |             $newVal = self::valueFromLdapDateTime($values);
349 |             if ($newVal !== null) {
350 |                 $values = $newVal;
351 |             }
352 |         }
353 | 
354 |         return $values;
355 |     }
356 | 
357 |     /**
358 |      * @param  string|DateTime $value
359 |      * @return int|null
360 |      */
361 |     private static function valueFromLdapDateTime($value)
362 |     {
363 |         if ($value instanceof DateTime) {
364 |             return $value->format('U');
365 |         } elseif (is_string($value)) {
366 |             try {
367 |                 return Converter\Converter::fromLdapDateTime($value, false)->format('U');
368 |             } catch (Converter\Exception\InvalidArgumentException $e) {
369 |                 return;
370 |             }
371 |         }
372 | 
373 |         return;
374 |     }
375 | }
376 | 


--------------------------------------------------------------------------------
/src/Collection.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-2015 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;
 11 | 
 12 | use Countable;
 13 | use Iterator;
 14 | 
 15 | /**
 16 |  * Zend\Ldap\Collection wraps a list of LDAP entries.
 17 |  */
 18 | class Collection implements Iterator, Countable
 19 | {
 20 |     /**
 21 |      * Iterator
 22 |      *
 23 |      * @var Collection\DefaultIterator
 24 |      */
 25 |     protected $iterator = null;
 26 | 
 27 |     /**
 28 |      * Current item number
 29 |      *
 30 |      * @var int
 31 |      */
 32 |     protected $current = -1;
 33 | 
 34 |     /**
 35 |      * Container for item caching to speed up multiple iterations
 36 |      *
 37 |      * @var array
 38 |      */
 39 |     protected $cache = [];
 40 | 
 41 |     /**
 42 |      * Constructor.
 43 |      *
 44 |      * @param Collection\DefaultIterator $iterator
 45 |      */
 46 |     public function __construct(Collection\DefaultIterator $iterator)
 47 |     {
 48 |         $this->iterator = $iterator;
 49 |     }
 50 | 
 51 |     public function __destruct()
 52 |     {
 53 |         $this->close();
 54 |     }
 55 | 
 56 |     /**
 57 |      * Closes the current result set
 58 |      *
 59 |      * @return bool
 60 |      */
 61 |     public function close()
 62 |     {
 63 |         return $this->iterator->close();
 64 |     }
 65 | 
 66 |     /**
 67 |      * Get all entries as an array
 68 |      *
 69 |      * @return array
 70 |      */
 71 |     public function toArray()
 72 |     {
 73 |         $data = [];
 74 |         foreach ($this as $item) {
 75 |             $data[] = $item;
 76 |         }
 77 |         return $data;
 78 |     }
 79 | 
 80 |     /**
 81 |      * Get first entry
 82 |      *
 83 |      * @return array
 84 |      */
 85 |     public function getFirst()
 86 |     {
 87 |         if ($this->count() > 0) {
 88 |             $this->rewind();
 89 |             return $this->current();
 90 |         }
 91 |         return;
 92 |     }
 93 | 
 94 |     /**
 95 |      * Returns the underlying iterator
 96 |      *
 97 |      * @return Collection\DefaultIterator
 98 |      */
 99 |     public function getInnerIterator()
100 |     {
101 |         return $this->iterator;
102 |     }
103 | 
104 |     /**
105 |      * Returns the number of items in current result
106 |      * Implements Countable
107 |      *
108 |      * @return int
109 |      */
110 |     public function count()
111 |     {
112 |         return $this->iterator->count();
113 |     }
114 | 
115 |     /**
116 |      * Return the current result item
117 |      * Implements Iterator
118 |      *
119 |      * @return array|null
120 |      * @throws Exception\LdapException
121 |      */
122 |     public function current()
123 |     {
124 |         if ($this->count() > 0) {
125 |             if ($this->current < 0) {
126 |                 $this->rewind();
127 |             }
128 |             if (! array_key_exists($this->current, $this->cache)) {
129 |                 $current = $this->iterator->current();
130 |                 if ($current === null) {
131 |                     return;
132 |                 }
133 |                 $this->cache[$this->current] = $this->createEntry($current);
134 |             }
135 |             return $this->cache[$this->current];
136 |         }
137 |         return;
138 |     }
139 | 
140 |     /**
141 |      * Creates the data structure for the given entry data
142 |      *
143 |      * @param  array $data
144 |      * @return array
145 |      */
146 |     protected function createEntry(array $data)
147 |     {
148 |         return $data;
149 |     }
150 | 
151 |     /**
152 |      * Return the current result item DN
153 |      *
154 |      * @return string|null
155 |      */
156 |     public function dn()
157 |     {
158 |         if ($this->count() > 0) {
159 |             if ($this->current < 0) {
160 |                 $this->rewind();
161 |             }
162 |             return $this->iterator->key();
163 |         }
164 |         return;
165 |     }
166 | 
167 |     /**
168 |      * Return the current result item key
169 |      * Implements Iterator
170 |      *
171 |      * @return int|null
172 |      */
173 |     public function key()
174 |     {
175 |         if ($this->count() > 0) {
176 |             if ($this->current < 0) {
177 |                 $this->rewind();
178 |             }
179 |             return $this->current;
180 |         }
181 |         return;
182 |     }
183 | 
184 |     /**
185 |      * Move forward to next result item
186 |      * Implements Iterator
187 |      *
188 |      * @throws Exception\LdapException
189 |      */
190 |     public function next()
191 |     {
192 |         $this->iterator->next();
193 |         $this->current++;
194 |     }
195 | 
196 |     /**
197 |      * Rewind the Iterator to the first result item
198 |      * Implements Iterator
199 |      *
200 |      * @throws Exception\LdapException
201 |      */
202 |     public function rewind()
203 |     {
204 |         $this->iterator->rewind();
205 |         $this->current = 0;
206 |     }
207 | 
208 |     /**
209 |      * Check if there is a current result item
210 |      * after calls to rewind() or next()
211 |      * Implements Iterator
212 |      *
213 |      * @return bool
214 |      */
215 |     public function valid()
216 |     {
217 |         if (isset($this->cache[$this->current])) {
218 |             return true;
219 |         }
220 |         return $this->iterator->valid();
221 |     }
222 | }
223 | 


--------------------------------------------------------------------------------
/src/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-2015 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\ErrorHandler;
 16 | use Zend\Ldap\Exception;
 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 |      * This array holds a list of resources and sorting-values.
 65 |      *
 66 |      * Each result is represented by an array containing the keys <var>resource</var>
 67 |      * which holds a resource of a result-item and the key <var>sortValue</var>
 68 |      * which holds the value by which the array will be sorted.
 69 |      *
 70 |      * The resources will be filled on creating the instance and the sorting values
 71 |      * on sorting.
 72 |      *
 73 |      * @var array
 74 |      */
 75 |     protected $entries = [];
 76 | 
 77 |     /**
 78 |      * The function to sort the entries by
 79 |      *
 80 |      * @var callable
 81 |      */
 82 |     protected $sortFunction;
 83 | 
 84 |     /**
 85 |      * Constructor.
 86 |      *
 87 |      * @param  \Zend\Ldap\Ldap $ldap
 88 |      * @param  resource        $resultId
 89 |      * @throws \Zend\Ldap\Exception\LdapException if no entries was found.
 90 |      * @return DefaultIterator
 91 |      */
 92 |     public function __construct(Ldap\Ldap $ldap, $resultId)
 93 |     {
 94 |         $this->setSortFunction('strnatcasecmp');
 95 |         $this->ldap      = $ldap;
 96 |         $this->resultId  = $resultId;
 97 | 
 98 |         $resource = $ldap->getResource();
 99 |         ErrorHandler::start();
100 |         $this->itemCount = ldap_count_entries($resource, $resultId);
101 |         ErrorHandler::stop();
102 |         if ($this->itemCount === false) {
103 |             throw new Exception\LdapException($this->ldap, 'counting entries');
104 |         }
105 | 
106 |         $identifier = ldap_first_entry(
107 |             $ldap->getResource(),
108 |             $resultId
109 |         );
110 | 
111 |         while (false !== $identifier) {
112 |             $this->entries[] = [
113 |                 'resource' => $identifier,
114 |                 'sortValue' => '',
115 |             ];
116 | 
117 |             $identifier = ldap_next_entry(
118 |                 $ldap->getResource(),
119 |                 $identifier
120 |             );
121 |         }
122 |     }
123 | 
124 |     public function __destruct()
125 |     {
126 |         $this->close();
127 |     }
128 | 
129 |     /**
130 |      * Closes the current result set
131 |      *
132 |      * @return bool
133 |      */
134 |     public function close()
135 |     {
136 |         $isClosed = false;
137 |         if (is_resource($this->resultId)) {
138 |             ErrorHandler::start();
139 |             $isClosed       = ldap_free_result($this->resultId);
140 |             ErrorHandler::stop();
141 | 
142 |             $this->resultId = null;
143 |             $this->current  = null;
144 |         }
145 |         return $isClosed;
146 |     }
147 | 
148 |     /**
149 |      * Gets the current LDAP connection.
150 |      *
151 |      * @return \Zend\Ldap\Ldap
152 |      */
153 |     public function getLDAP()
154 |     {
155 |         return $this->ldap;
156 |     }
157 | 
158 |     /**
159 |      * Sets the attribute name treatment.
160 |      *
161 |      * Can either be one of the following constants
162 |      * - Zend\Ldap\Collection\DefaultIterator::ATTRIBUTE_TO_LOWER
163 |      * - Zend\Ldap\Collection\DefaultIterator::ATTRIBUTE_TO_UPPER
164 |      * - Zend\Ldap\Collection\DefaultIterator::ATTRIBUTE_NATIVE
165 |      * or a valid callback accepting the attribute's name as it's only
166 |      * argument and returning the new attribute's name.
167 |      *
168 |      * @param  int|callable $attributeNameTreatment
169 |      * @return DefaultIterator Provides a fluent interface
170 |      */
171 |     public function setAttributeNameTreatment($attributeNameTreatment)
172 |     {
173 |         if (is_callable($attributeNameTreatment)) {
174 |             if (is_string($attributeNameTreatment) && ! function_exists($attributeNameTreatment)) {
175 |                 $this->attributeNameTreatment = self::ATTRIBUTE_TO_LOWER;
176 |             } elseif (is_array($attributeNameTreatment)
177 |                 && ! method_exists($attributeNameTreatment[0], $attributeNameTreatment[1])
178 |             ) {
179 |                 $this->attributeNameTreatment = self::ATTRIBUTE_TO_LOWER;
180 |             } else {
181 |                 $this->attributeNameTreatment = $attributeNameTreatment;
182 |             }
183 |         } else {
184 |             $attributeNameTreatment = (int) $attributeNameTreatment;
185 |             switch ($attributeNameTreatment) {
186 |                 case self::ATTRIBUTE_TO_LOWER:
187 |                 case self::ATTRIBUTE_TO_UPPER:
188 |                 case self::ATTRIBUTE_NATIVE:
189 |                     $this->attributeNameTreatment = $attributeNameTreatment;
190 |                     break;
191 |                 default:
192 |                     $this->attributeNameTreatment = self::ATTRIBUTE_TO_LOWER;
193 |                     break;
194 |             }
195 |         }
196 | 
197 |         return $this;
198 |     }
199 | 
200 |     /**
201 |      * Returns the currently set attribute name treatment
202 |      *
203 |      * @return int|callable
204 |      */
205 |     public function getAttributeNameTreatment()
206 |     {
207 |         return $this->attributeNameTreatment;
208 |     }
209 | 
210 |     /**
211 |      * Returns the number of items in current result
212 |      * Implements Countable
213 |      *
214 |      * @return int
215 |      */
216 |     public function count()
217 |     {
218 |         return $this->itemCount;
219 |     }
220 | 
221 |     /**
222 |      * Return the current result item
223 |      * Implements Iterator
224 |      *
225 |      * @return array|null
226 |      * @throws \Zend\Ldap\Exception\LdapException
227 |      */
228 |     public function current()
229 |     {
230 |         if (! is_resource($this->current)) {
231 |             $this->rewind();
232 |         }
233 |         if (! is_resource($this->current)) {
234 |             return;
235 |         }
236 | 
237 |         $entry         = ['dn' => $this->key()];
238 | 
239 |         $resource = $this->ldap->getResource();
240 |         ErrorHandler::start();
241 |         $name = ldap_first_attribute($resource, $this->current);
242 |         ErrorHandler::stop();
243 | 
244 |         while ($name) {
245 |             ErrorHandler::start();
246 |             $data = ldap_get_values_len($resource, $this->current, $name);
247 |             ErrorHandler::stop();
248 | 
249 |             if (! $data) {
250 |                 $data = [];
251 |             }
252 | 
253 |             if (isset($data['count'])) {
254 |                 unset($data['count']);
255 |             }
256 | 
257 |             switch ($this->attributeNameTreatment) {
258 |                 case self::ATTRIBUTE_TO_LOWER:
259 |                     $attrName = strtolower($name);
260 |                     break;
261 |                 case self::ATTRIBUTE_TO_UPPER:
262 |                     $attrName = strtoupper($name);
263 |                     break;
264 |                 case self::ATTRIBUTE_NATIVE:
265 |                     $attrName = $name;
266 |                     break;
267 |                 default:
268 |                     $attrName = call_user_func($this->attributeNameTreatment, $name);
269 |                     break;
270 |             }
271 |             $entry[$attrName] = $data;
272 | 
273 |             ErrorHandler::start();
274 |             $name = ldap_next_attribute($resource, $this->current);
275 |             ErrorHandler::stop();
276 |         }
277 |         ksort($entry, SORT_LOCALE_STRING);
278 |         return $entry;
279 |     }
280 | 
281 |     /**
282 |      * Return the result item key
283 |      * Implements Iterator
284 |      *
285 |      * @throws \Zend\Ldap\Exception\LdapException
286 |      * @return string|null
287 |      */
288 |     public function key()
289 |     {
290 |         if (! is_resource($this->current)) {
291 |             $this->rewind();
292 |         }
293 |         if (is_resource($this->current)) {
294 |             $resource = $this->ldap->getResource();
295 |             ErrorHandler::start();
296 |             $currentDn = ldap_get_dn($resource, $this->current);
297 |             ErrorHandler::stop();
298 | 
299 |             if ($currentDn === false) {
300 |                 throw new Exception\LdapException($this->ldap, 'getting dn');
301 |             }
302 | 
303 |             return $currentDn;
304 |         } else {
305 |             return;
306 |         }
307 |     }
308 | 
309 |     /**
310 |      * Move forward to next result item
311 |      *
312 |      * @see Iterator
313 |      *
314 |      * @return void
315 |      */
316 |     public function next()
317 |     {
318 |         next($this->entries);
319 |         $nextEntry = current($this->entries);
320 |         $this->current = $nextEntry['resource'];
321 |     }
322 | 
323 |     /**
324 |      * Rewind the Iterator to the first result item
325 |      *
326 |      * @see Iterator
327 |      *
328 |      * @return void
329 |      */
330 |     public function rewind()
331 |     {
332 |         reset($this->entries);
333 |         $nextEntry = current($this->entries);
334 |         $this->current = $nextEntry['resource'];
335 |     }
336 | 
337 |     /**
338 |      * Check if there is a current result item
339 |      * after calls to rewind() or next()
340 |      * Implements Iterator
341 |      *
342 |      * @return bool
343 |      */
344 |     public function valid()
345 |     {
346 |         return (is_resource($this->current));
347 |     }
348 | 
349 |     /**
350 |      * Set a sorting-algorithm for this iterator
351 |      *
352 |      * The callable has to accept two parameters that will be compared.
353 |      *
354 |      * @param callable $sortingAlgorithm The algorithm to be used for sorting
355 |      *
356 |      * @return DefaultIterator Provides a fluent interface
357 |      */
358 |     public function setSortFunction(callable $sortFunction)
359 |     {
360 |         $this->sortFunction = $sortFunction;
361 | 
362 |         return $this;
363 |     }
364 | 
365 |     /**
366 |      * Sort the iterator
367 |      *
368 |      * Sorting is done using the set sortFunction which is by default strnatcasecmp.
369 |      *
370 |      * The attribute is determined by lowercasing everything.
371 |      *
372 |      * The sort-value will be the first value of the attribute.
373 |      *
374 |      * @param string $sortAttribute The attribute to sort by. If not given the
375 |      *                              value set via setSortAttribute is used.
376 |      *
377 |      * @return void
378 |      */
379 |     public function sort($sortAttribute)
380 |     {
381 |         foreach ($this->entries as $key => $entry) {
382 |             $attributes = ldap_get_attributes(
383 |                 $this->ldap->getResource(),
384 |                 $entry['resource']
385 |             );
386 | 
387 |             $attributes = array_change_key_case($attributes, CASE_LOWER);
388 | 
389 |             if (isset($attributes[$sortAttribute][0])) {
390 |                 $this->entries[$key]['sortValue'] =
391 |                     $attributes[$sortAttribute][0];
392 |             }
393 |         }
394 | 
395 |         $sortFunction = $this->sortFunction;
396 |         $sorted = usort($this->entries, function ($a, $b) use ($sortFunction) {
397 |             return $sortFunction($a['sortValue'], $b['sortValue']);
398 |         });
399 | 
400 |         if (! $sorted) {
401 |             throw new Exception\LdapException($this, 'sorting result-set');
402 |         }
403 |     }
404 | }
405 | 


--------------------------------------------------------------------------------
/src/Converter/Converter.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-2015 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\Converter;
 11 | 
 12 | use DateTime;
 13 | use DateTimeZone;
 14 | use Zend\Ldap\ErrorHandler;
 15 | 
 16 | /**
 17 |  * Zend\Ldap\Converter is a collection of useful LDAP related conversion functions.
 18 |  */
 19 | class Converter
 20 | {
 21 |     const STANDARD         = 0;
 22 |     const BOOLEAN          = 1;
 23 |     const GENERALIZED_TIME = 2;
 24 | 
 25 |     /**
 26 |      * Converts all ASCII chars < 32 to "\HEX"
 27 |      *
 28 |      * @see    Net_LDAP2_Util::asc2hex32() from Benedikt Hallinger <beni@php.net>
 29 |      * @link   http://pear.php.net/package/Net_LDAP2
 30 |      * @author Benedikt Hallinger <beni@php.net>
 31 |      *
 32 |      * @param string $string String to convert
 33 |      * @return string
 34 |      */
 35 |     public static function ascToHex32($string)
 36 |     {
 37 |         for ($i = 0, $len = strlen($string); $i < $len; $i++) {
 38 |             $char = substr($string, $i, 1);
 39 |             if (ord($char) < 32) {
 40 |                 $hex = dechex(ord($char));
 41 |                 if (strlen($hex) == 1) {
 42 |                     $hex = '0' . $hex;
 43 |                 }
 44 |                 $string = str_replace($char, '\\' . $hex, $string);
 45 |             }
 46 |         }
 47 |         return $string;
 48 |     }
 49 | 
 50 |     /**
 51 |      * Converts all Hex expressions ("\HEX") to their original ASCII characters
 52 |      *
 53 |      * @see    Net_LDAP2_Util::hex2asc() from Benedikt Hallinger <beni@php.net>,
 54 |      *         heavily based on work from DavidSmith@byu.net
 55 |      * @link   http://pear.php.net/package/Net_LDAP2
 56 |      * @author Benedikt Hallinger <beni@php.net>, heavily based on work from DavidSmith@byu.net
 57 |      *
 58 |      * @param string $string String to convert
 59 |      * @return string
 60 |      */
 61 |     public static function hex32ToAsc($string)
 62 |     {
 63 |         $string = preg_replace_callback('/\\\([0-9A-Fa-f]{2})/', function ($matches) {
 64 |             return chr(hexdec($matches[1]));
 65 |         }, $string);
 66 |         return $string;
 67 |     }
 68 | 
 69 |     /**
 70 |      * Convert any value to an LDAP-compatible value.
 71 |      *
 72 |      * By setting the <var>$type</var>-parameter the conversion of a certain
 73 |      * type can be forced
 74 |      *
 75 |      *
 76 |      * @param mixed $value The value to convert
 77 |      * @param int   $type  The conversion type to use
 78 |      * @return string|null
 79 |      * @throws Exception\ConverterException
 80 |      */
 81 |     public static function toLdap($value, $type = self::STANDARD)
 82 |     {
 83 |         try {
 84 |             switch ($type) {
 85 |                 case self::BOOLEAN:
 86 |                     return static::toLdapBoolean($value);
 87 |                 case self::GENERALIZED_TIME:
 88 |                     return static::toLdapDatetime($value);
 89 |                 default:
 90 |                     if (is_string($value)) {
 91 |                         return $value;
 92 |                     } elseif (is_int($value) || is_float($value)) {
 93 |                         return (string) $value;
 94 |                     } elseif (is_bool($value)) {
 95 |                         return static::toLdapBoolean($value);
 96 |                     } elseif (is_object($value)) {
 97 |                         if ($value instanceof DateTime) {
 98 |                             return static::toLdapDatetime($value);
 99 |                         } else {
100 |                             return static::toLdapSerialize($value);
101 |                         }
102 |                     } elseif (is_array($value)) {
103 |                         return static::toLdapSerialize($value);
104 |                     } elseif (is_resource($value) && get_resource_type($value) === 'stream') {
105 |                         return stream_get_contents($value);
106 |                     }
107 | 
108 |                     return;
109 |             }
110 |         } catch (\Exception $e) {
111 |             throw new Exception\ConverterException($e->getMessage(), $e->getCode(), $e);
112 |         }
113 |     }
114 | 
115 |     /**
116 |      * Converts a date-entity to an LDAP-compatible date-string
117 |      *
118 |      * The date-entity <var>$date</var> can be either a timestamp, a
119 |      * DateTime Object, a string that is parseable by strtotime().
120 |      *
121 |      * @param int|string|DateTime $date  The date-entity
122 |      * @param  bool                 $asUtc Whether to return the LDAP-compatible date-string as UTC or as local value
123 |      * @return string
124 |      * @throws Exception\InvalidArgumentException
125 |      */
126 |     public static function toLdapDateTime($date, $asUtc = true)
127 |     {
128 |         if (! ($date instanceof DateTime)) {
129 |             if (is_int($date)) {
130 |                 $date = new DateTime('@' . $date);
131 |                 $date->setTimezone(new DateTimeZone(date_default_timezone_get()));
132 |             } elseif (is_string($date)) {
133 |                 $date = new DateTime($date);
134 |             } else {
135 |                 throw new Exception\InvalidArgumentException('Parameter $date is not of the expected type');
136 |             }
137 |         }
138 |         $timezone = $date->format('O');
139 |         if (true === $asUtc) {
140 |             $date->setTimezone(new DateTimeZone('UTC'));
141 |             $timezone = 'Z';
142 |         }
143 |         if ('+0000' === $timezone) {
144 |             $timezone = 'Z';
145 |         }
146 |         return $date->format('YmdHis') . $timezone;
147 |     }
148 | 
149 |     /**
150 |      * Convert a boolean value to an LDAP-compatible string
151 |      *
152 |      * This converts a boolean value of TRUE, an integer-value of 1 and a
153 |      * case-insensitive string 'true' to an LDAP-compatible 'TRUE'. All other
154 |      * other values are converted to an LDAP-compatible 'FALSE'.
155 |      *
156 |      * @param  bool|int|string $value The boolean value to encode
157 |      * @return string
158 |      */
159 |     public static function toLdapBoolean($value)
160 |     {
161 |         $return = 'FALSE';
162 |         if (! is_scalar($value)) {
163 |             return $return;
164 |         }
165 |         if (true === $value || (is_string($value) && 'true' === strtolower($value)) || 1 === $value) {
166 |             $return = 'TRUE';
167 |         }
168 |         return $return;
169 |     }
170 | 
171 |     /**
172 |      * Serialize any value for storage in LDAP
173 |      *
174 |      * @param mixed $value The value to serialize
175 |      * @return string
176 |      */
177 |     public static function toLdapSerialize($value)
178 |     {
179 |         return serialize($value);
180 |     }
181 | 
182 |     /**
183 |      * Convert an LDAP-compatible value to a corresponding PHP-value.
184 |      *
185 |      * By setting the <var>$type</var>-parameter the conversion of a certain
186 |      * type can be forced.
187 |      *
188 |      * @see Converter::STANDARD
189 |      * @see Converter::BOOLEAN
190 |      * @see Converter::GENERALIZED_TIME
191 |      * @param string  $value         The value to convert
192 |      * @param int     $type          The conversion type to use
193 |      * @param  bool $dateTimeAsUtc Return DateTime values in UTC timezone
194 |      * @return mixed
195 |      */
196 |     public static function fromLdap($value, $type = self::STANDARD, $dateTimeAsUtc = true)
197 |     {
198 |         switch ($type) {
199 |             case self::BOOLEAN:
200 |                 return static::fromldapBoolean($value);
201 |             case self::GENERALIZED_TIME:
202 |                 return static::fromLdapDateTime($value);
203 |             default:
204 |                 if (is_numeric($value)) {
205 |                     // prevent numeric values to be treated as date/time
206 |                     return $value;
207 |                 } elseif ('TRUE' === $value || 'FALSE' === $value) {
208 |                     return static::fromLdapBoolean($value);
209 |                 }
210 |                 if (preg_match('/^\d{4}[\d\+\-Z\.]*$/', $value)) {
211 |                     return static::fromLdapDateTime($value, $dateTimeAsUtc);
212 |                 }
213 |                 try {
214 |                     return static::fromLdapUnserialize($value);
215 |                 } catch (Exception\UnexpectedValueException $e) {
216 |                     // Do nothing
217 |                 }
218 |                 break;
219 |         }
220 | 
221 |         return $value;
222 |     }
223 | 
224 |     /**
225 |      * Convert an LDAP-Generalized-Time-entry into a DateTime-Object
226 |      *
227 |      * CAVEAT: The DateTime-Object returned will always be set to UTC-Timezone.
228 |      *
229 |      * @param string  $date  The generalized-Time
230 |      * @param  bool $asUtc Return the DateTime with UTC timezone
231 |      * @return DateTime
232 |      * @throws Exception\InvalidArgumentException if a non-parseable-format is given
233 |      */
234 |     public static function fromLdapDateTime($date, $asUtc = true)
235 |     {
236 |         $datepart = [];
237 |         if (! preg_match('/^(\d{4})/', $date, $datepart)) {
238 |             throw new Exception\InvalidArgumentException('Invalid date format found');
239 |         }
240 | 
241 |         if ($datepart[1] < 4) {
242 |             throw new Exception\InvalidArgumentException('Invalid date format found (too short)');
243 |         }
244 | 
245 |         $time = [
246 |             // The year is mandatory!
247 |             'year'          => $datepart[1],
248 |             'month'         => 1,
249 |             'day'           => 1,
250 |             'hour'          => 0,
251 |             'minute'        => 0,
252 |             'second'        => 0,
253 |             'offdir'        => '+',
254 |             'offsethours'   => 0,
255 |             'offsetminutes' => 0
256 |         ];
257 | 
258 |         $length = strlen($date);
259 | 
260 |         // Check for month.
261 |         if ($length >= 6) {
262 |             $month = substr($date, 4, 2);
263 |             if ($month < 1 || $month > 12) {
264 |                 throw new Exception\InvalidArgumentException('Invalid date format found (invalid month)');
265 |             }
266 |             $time['month'] = $month;
267 |         }
268 | 
269 |         // Check for day
270 |         if ($length >= 8) {
271 |             $day = substr($date, 6, 2);
272 |             if ($day < 1 || $day > 31) {
273 |                 throw new Exception\InvalidArgumentException('Invalid date format found (invalid day)');
274 |             }
275 |             $time['day'] = $day;
276 |         }
277 | 
278 |         // Check for Hour
279 |         if ($length >= 10) {
280 |             $hour = substr($date, 8, 2);
281 |             if ($hour < 0 || $hour > 23) {
282 |                 throw new Exception\InvalidArgumentException('Invalid date format found (invalid hour)');
283 |             }
284 |             $time['hour'] = $hour;
285 |         }
286 | 
287 |         // Check for minute
288 |         if ($length >= 12) {
289 |             $minute = substr($date, 10, 2);
290 |             if ($minute < 0 || $minute > 59) {
291 |                 throw new Exception\InvalidArgumentException('Invalid date format found (invalid minute)');
292 |             }
293 |             $time['minute'] = $minute;
294 |         }
295 | 
296 |         // Check for seconds
297 |         if ($length >= 14) {
298 |             $second = substr($date, 12, 2);
299 |             if ($second < 0 || $second > 59) {
300 |                 throw new Exception\InvalidArgumentException('Invalid date format found (invalid second)');
301 |             }
302 |             $time['second'] = $second;
303 |         }
304 | 
305 |         // Set Offset
306 |         $offsetRegEx = '/([Z\-\+])(\d{2}\'?){0,1}(\d{2}\'?){0,1}$/';
307 |         $off         = [];
308 |         if (preg_match($offsetRegEx, $date, $off)) {
309 |             $offset = $off[1];
310 |             if ($offset == '+' || $offset == '-') {
311 |                 $time['offdir'] = $offset;
312 |                 // we have an offset, so lets calculate it.
313 |                 if (isset($off[2])) {
314 |                     $offsetHours = substr($off[2], 0, 2);
315 |                     if ($offsetHours < 0 || $offsetHours > 12) {
316 |                         throw new Exception\InvalidArgumentException('Invalid date format found (invalid offset hour)');
317 |                     }
318 |                     $time['offsethours'] = $offsetHours;
319 |                 }
320 |                 if (isset($off[3])) {
321 |                     $offsetMinutes = substr($off[3], 0, 2);
322 |                     if ($offsetMinutes < 0 || $offsetMinutes > 59) {
323 |                         throw new Exception\InvalidArgumentException(
324 |                             'Invalid date format found (invalid offset minute)'
325 |                         );
326 |                     }
327 |                     $time['offsetminutes'] = $offsetMinutes;
328 |                 }
329 |             }
330 |         }
331 | 
332 |         // Raw-Data is present, so lets create a DateTime-Object from it.
333 |         $timestring = $time['year'] . '-'
334 |                       . str_pad($time['month'], 2, '0', STR_PAD_LEFT) . '-'
335 |                       . str_pad($time['day'], 2, '0', STR_PAD_LEFT) . ' '
336 |                       . str_pad($time['hour'], 2, '0', STR_PAD_LEFT) . ':'
337 |                       . str_pad($time['minute'], 2, '0', STR_PAD_LEFT) . ':'
338 |                       . str_pad($time['second'], 2, '0', STR_PAD_LEFT)
339 |                       . $time['offdir']
340 |                       . str_pad($time['offsethours'], 2, '0', STR_PAD_LEFT)
341 |                       . str_pad($time['offsetminutes'], 2, '0', STR_PAD_LEFT);
342 |         try {
343 |             $date = new DateTime($timestring);
344 |         } catch (\Exception $e) {
345 |             throw new Exception\InvalidArgumentException(
346 |                 'Invalid date format found',
347 |                 0,
348 |                 $e
349 |             );
350 |         }
351 |         if ($asUtc) {
352 |             $date->setTimezone(new DateTimeZone('UTC'));
353 |         }
354 |         return $date;
355 |     }
356 | 
357 |     /**
358 |      * Convert an LDAP-compatible boolean value into a PHP-compatible one
359 |      *
360 |      * @param string $value The value to convert
361 |      * @return bool
362 |      * @throws Exception\InvalidArgumentException
363 |      */
364 |     public static function fromLdapBoolean($value)
365 |     {
366 |         if ('TRUE' === $value) {
367 |             return true;
368 |         } elseif ('FALSE' === $value) {
369 |             return false;
370 |         } else {
371 |             throw new Exception\InvalidArgumentException('The given value is not a boolean value');
372 |         }
373 |     }
374 | 
375 |     /**
376 |      * Unserialize a serialized value to return the corresponding object
377 |      *
378 |      * @param string $value The value to convert
379 |      * @return mixed
380 |      * @throws Exception\UnexpectedValueException
381 |      */
382 |     public static function fromLdapUnserialize($value)
383 |     {
384 |         ErrorHandler::start(E_NOTICE);
385 |         $v = unserialize($value);
386 |         ErrorHandler::stop();
387 | 
388 |         if (false === $v && $value != 'b:0;') {
389 |             throw new Exception\UnexpectedValueException('The given value could not be unserialized');
390 |         }
391 |         return $v;
392 |     }
393 | }
394 | 


--------------------------------------------------------------------------------
/src/Converter/Exception/ConverterException.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-2015 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\Converter\Exception;
11 | 
12 | class ConverterException extends \Exception implements ExceptionInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Converter/Exception/ExceptionInterface.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-2015 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\Converter\Exception;
11 | 
12 | interface ExceptionInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Converter/Exception/InvalidArgumentException.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-2015 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\Converter\Exception;
11 | 
12 | class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Converter/Exception/UnexpectedValueException.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-2015 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\Converter\Exception;
11 | 
12 | class UnexpectedValueException extends \UnexpectedValueException implements ExceptionInterface
13 | {
14 | }
15 | 


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


--------------------------------------------------------------------------------
/src/ErrorHandler.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-2015 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;
 11 | 
 12 | /**
 13 |  * Handle Errors that might occur during execution of ldap_*-functions
 14 |  *
 15 |  * @package Zend\Ldap\ErrorHandler
 16 |  */
 17 | class ErrorHandler implements ErrorHandlerInterface
 18 | {
 19 |     /**
 20 |      * @var ErrorHandlerInterface The Errror-Handler instance
 21 |      */
 22 |     protected static $errorHandler;
 23 | 
 24 |     /**
 25 |      * Start the Error-Handling
 26 |      *
 27 |      * You can specify which errors to handle by passing a combination of PHPs
 28 |      * Error-constants like E_WARNING or E_NOTICE or E_WARNING ^ E_DEPRECATED
 29 |      *
 30 |      * @param int $level The Error-level(s) to handle by this ErrorHandler
 31 |      *
 32 |      * @return void
 33 |      */
 34 |     public static function start($level = E_WARNING)
 35 |     {
 36 |         self::getErrorHandler()->startErrorHandling($level);
 37 |     }
 38 | 
 39 |     /**
 40 |      * @param bool|false $throw
 41 |      *
 42 |      * @return mixed
 43 |      */
 44 |     public static function stop($throw = false)
 45 |     {
 46 |         return self::getErrorHandler()->stopErrorHandling($throw);
 47 |     }
 48 | 
 49 |     /**
 50 |      * Get an error handler
 51 |      *
 52 |      * @return ErrorHandlerInterface
 53 |      */
 54 |     protected static function getErrorHandler()
 55 |     {
 56 |         if (! self::$errorHandler && ! self::$errorHandler instanceof ErrorHandlerInterface) {
 57 |             self::$errorHandler = new self();
 58 |         }
 59 | 
 60 |         return self::$errorHandler;
 61 |     }
 62 | 
 63 |     /**
 64 |      * This method does nothing on purpose.
 65 |      *
 66 |      * @param int $level
 67 |      *
 68 |      * @see ErrorHandlerInterface::startErrorHandling()
 69 |      * @return void
 70 |      */
 71 |     public function startErrorHandling($level = E_WARNING)
 72 |     {
 73 |         set_error_handler(function ($errNo, $errString) {
 74 |         });
 75 |     }
 76 | 
 77 |     /**
 78 |      * This method does nothing on purpose.
 79 |      *
 80 |      * @param bool|false $throw
 81 |      *
 82 |      * @see ErrorHandlerInterface::stopErrorHandling()
 83 |      * @return void
 84 |      */
 85 |     public function stopErrorHandling($throw = false)
 86 |     {
 87 |         restore_error_handler();
 88 |     }
 89 | 
 90 |     /**
 91 |      * Set the error handler to be used
 92 |      *
 93 |      * @param ErrorHandlerInterface $errorHandler
 94 |      *
 95 |      * @return void
 96 |      */
 97 |     public static function setErrorHandler(ErrorHandlerInterface $errorHandler)
 98 |     {
 99 |         self::$errorHandler = $errorHandler;
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/src/ErrorHandlerInterface.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-2015 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;
11 | 
12 | /**
13 |  * Handle Errors that might occur during execution of ldap_*-functions
14 |  *
15 |  * @package Zend\Ldap\ErrorHandler
16 |  */
17 | interface ErrorHandlerInterface
18 | {
19 |     /**
20 |      * Start the ErrorHandling-process
21 |      *
22 |      * @param int $level
23 |      *
24 |      * @return void
25 |      */
26 |     public function startErrorHandling($level = E_WARNING);
27 | 
28 |     /**
29 |      * Stop the error-handling process.
30 |      *
31 |      * The parameter <var>$throw</var> handles whether the captured errors shall
32 |      * be thrown as Exceptions or not
33 |      *
34 |      * @param bool|false $throw
35 |      *
36 |      * @return mixed
37 |      */
38 |     public function stopErrorHandling($throw = false);
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Exception/BadMethodCallException.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-2015 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\Exception;
11 | 
12 | class BadMethodCallException extends \BadMethodCallException implements ExceptionInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/ExceptionInterface.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-2015 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\Exception;
11 | 
12 | interface ExceptionInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidArgumentException.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-2015 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\Exception;
11 | 
12 | class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/LdapException.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-2015 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\Exception;
 11 | 
 12 | use Zend\Ldap\Ldap;
 13 | 
 14 | class LdapException extends \Exception implements ExceptionInterface
 15 | {
 16 |     const LDAP_SUCCESS                        = 0x00;
 17 |     const LDAP_OPERATIONS_ERROR               = 0x01;
 18 |     const LDAP_PROTOCOL_ERROR                 = 0x02;
 19 |     const LDAP_TIMELIMIT_EXCEEDED             = 0x03;
 20 |     const LDAP_SIZELIMIT_EXCEEDED             = 0x04;
 21 |     const LDAP_COMPARE_FALSE                  = 0x05;
 22 |     const LDAP_COMPARE_TRUE                   = 0x06;
 23 |     const LDAP_AUTH_METHOD_NOT_SUPPORTED      = 0x07;
 24 |     const LDAP_STRONG_AUTH_REQUIRED           = 0x08;
 25 |     const LDAP_PARTIAL_RESULTS                = 0x09;
 26 |     const LDAP_REFERRAL                       = 0x0a;
 27 |     const LDAP_ADMINLIMIT_EXCEEDED            = 0x0b;
 28 |     const LDAP_UNAVAILABLE_CRITICAL_EXTENSION = 0x0c;
 29 |     const LDAP_CONFIDENTIALITY_REQUIRED       = 0x0d;
 30 |     const LDAP_SASL_BIND_IN_PROGRESS          = 0x0e;
 31 |     const LDAP_NO_SUCH_ATTRIBUTE              = 0x10;
 32 |     const LDAP_UNDEFINED_TYPE                 = 0x11;
 33 |     const LDAP_INAPPROPRIATE_MATCHING         = 0x12;
 34 |     const LDAP_CONSTRAINT_VIOLATION           = 0x13;
 35 |     const LDAP_TYPE_OR_VALUE_EXISTS           = 0x14;
 36 |     const LDAP_INVALID_SYNTAX                 = 0x15;
 37 |     const LDAP_NO_SUCH_OBJECT                 = 0x20;
 38 |     const LDAP_ALIAS_PROBLEM                  = 0x21;
 39 |     const LDAP_INVALID_DN_SYNTAX              = 0x22;
 40 |     const LDAP_IS_LEAF                        = 0x23;
 41 |     const LDAP_ALIAS_DEREF_PROBLEM            = 0x24;
 42 |     const LDAP_PROXY_AUTHZ_FAILURE            = 0x2F;
 43 |     const LDAP_INAPPROPRIATE_AUTH             = 0x30;
 44 |     const LDAP_INVALID_CREDENTIALS            = 0x31;
 45 |     const LDAP_INSUFFICIENT_ACCESS            = 0x32;
 46 |     const LDAP_BUSY                           = 0x33;
 47 |     const LDAP_UNAVAILABLE                    = 0x34;
 48 |     const LDAP_UNWILLING_TO_PERFORM           = 0x35;
 49 |     const LDAP_LOOP_DETECT                    = 0x36;
 50 |     const LDAP_NAMING_VIOLATION               = 0x40;
 51 |     const LDAP_OBJECT_CLASS_VIOLATION         = 0x41;
 52 |     const LDAP_NOT_ALLOWED_ON_NONLEAF         = 0x42;
 53 |     const LDAP_NOT_ALLOWED_ON_RDN             = 0x43;
 54 |     const LDAP_ALREADY_EXISTS                 = 0x44;
 55 |     const LDAP_NO_OBJECT_CLASS_MODS           = 0x45;
 56 |     const LDAP_RESULTS_TOO_LARGE              = 0x46;
 57 |     const LDAP_AFFECTS_MULTIPLE_DSAS          = 0x47;
 58 |     const LDAP_OTHER                          = 0x50;
 59 |     const LDAP_SERVER_DOWN                    = 0x51;
 60 |     const LDAP_LOCAL_ERROR                    = 0x52;
 61 |     const LDAP_ENCODING_ERROR                 = 0x53;
 62 |     const LDAP_DECODING_ERROR                 = 0x54;
 63 |     const LDAP_TIMEOUT                        = 0x55;
 64 |     const LDAP_AUTH_UNKNOWN                   = 0x56;
 65 |     const LDAP_FILTER_ERROR                   = 0x57;
 66 |     const LDAP_USER_CANCELLED                 = 0x58;
 67 |     const LDAP_PARAM_ERROR                    = 0x59;
 68 |     const LDAP_NO_MEMORY                      = 0x5a;
 69 |     const LDAP_CONNECT_ERROR                  = 0x5b;
 70 |     const LDAP_NOT_SUPPORTED                  = 0x5c;
 71 |     const LDAP_CONTROL_NOT_FOUND              = 0x5d;
 72 |     const LDAP_NO_RESULTS_RETURNED            = 0x5e;
 73 |     const LDAP_MORE_RESULTS_TO_RETURN         = 0x5f;
 74 |     const LDAP_CLIENT_LOOP                    = 0x60;
 75 |     const LDAP_REFERRAL_LIMIT_EXCEEDED        = 0x61;
 76 |     const LDAP_CUP_RESOURCES_EXHAUSTED        = 0x71;
 77 |     const LDAP_CUP_SECURITY_VIOLATION         = 0x72;
 78 |     const LDAP_CUP_INVALID_DATA               = 0x73;
 79 |     const LDAP_CUP_UNSUPPORTED_SCHEME         = 0x74;
 80 |     const LDAP_CUP_RELOAD_REQUIRED            = 0x75;
 81 |     const LDAP_CANCELLED                      = 0x76;
 82 |     const LDAP_NO_SUCH_OPERATION              = 0x77;
 83 |     const LDAP_TOO_LATE                       = 0x78;
 84 |     const LDAP_CANNOT_CANCEL                  = 0x79;
 85 |     const LDAP_ASSERTION_FAILED               = 0x7A;
 86 |     const LDAP_SYNC_REFRESH_REQUIRED          = 0x1000;
 87 |     const LDAP_X_SYNC_REFRESH_REQUIRED        = 0x4100;
 88 |     const LDAP_X_NO_OPERATION                 = 0x410e;
 89 |     const LDAP_X_ASSERTION_FAILED             = 0x410f;
 90 |     const LDAP_X_NO_REFERRALS_FOUND           = 0x4110;
 91 |     const LDAP_X_CANNOT_CHAIN                 = 0x4111;
 92 | 
 93 |     /* internal error code constants */
 94 | 
 95 |     const LDAP_X_DOMAIN_MISMATCH      = 0x7001;
 96 |     const LDAP_X_EXTENSION_NOT_LOADED = 0x7002;
 97 | 
 98 |     /**
 99 |      * @param Ldap   $ldap Zend\Ldap\Ldap object
100 |      * @param string $str  Informative exception message
101 |      * @param int    $code LDAP error code
102 |      */
103 |     public function __construct(Ldap $ldap = null, $str = null, $code = 0)
104 |     {
105 |         $errorMessages = [];
106 |         $message       = '';
107 |         if ($ldap !== null) {
108 |             $oldCode = $code;
109 |             $message = $ldap->getLastError($code, $errorMessages) . ': ';
110 |             if ($code === 0) {
111 |                 $message = '';
112 |                 $code    = $oldCode;
113 |             }
114 |         }
115 |         if (empty($message)) {
116 |             if ($code > 0) {
117 |                 $message = '0x' . dechex($code) . ': ';
118 |             }
119 |         }
120 | 
121 |         if (! empty($str)) {
122 |             $message .= $str;
123 |         } else {
124 |             $message .= 'no exception message';
125 |         }
126 | 
127 |         parent::__construct($message, $code);
128 |     }
129 | }
130 | 


--------------------------------------------------------------------------------
/src/Filter.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-2015 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;
 11 | 
 12 | /**
 13 |  * Zend\Ldap\Filter.
 14 |  */
 15 | class Filter extends Filter\StringFilter
 16 | {
 17 |     const TYPE_EQUALS         = '=';
 18 |     const TYPE_GREATER        = '>';
 19 |     const TYPE_GREATEROREQUAL = '>=';
 20 |     const TYPE_LESS           = '<';
 21 |     const TYPE_LESSOREQUAL    = '<=';
 22 |     const TYPE_APPROX         = '~=';
 23 | 
 24 |     /**
 25 |      * Creates an 'equals' filter.
 26 |      * (attr=value)
 27 |      *
 28 |      * @param  string $attr
 29 |      * @param  string $value
 30 |      * @return Filter
 31 |      */
 32 |     public static function equals($attr, $value)
 33 |     {
 34 |         return new static($attr, $value, self::TYPE_EQUALS, null, null);
 35 |     }
 36 | 
 37 |     /**
 38 |      * Creates a 'begins with' filter.
 39 |      * (attr=value*)
 40 |      *
 41 |      * @param  string $attr
 42 |      * @param  string $value
 43 |      * @return Filter
 44 |      */
 45 |     public static function begins($attr, $value)
 46 |     {
 47 |         return new static($attr, $value, self::TYPE_EQUALS, null, '*');
 48 |     }
 49 | 
 50 |     /**
 51 |      * Creates an 'ends with' filter.
 52 |      * (attr=*value)
 53 |      *
 54 |      * @param  string $attr
 55 |      * @param  string $value
 56 |      * @return Filter
 57 |      */
 58 |     public static function ends($attr, $value)
 59 |     {
 60 |         return new static($attr, $value, self::TYPE_EQUALS, '*', null);
 61 |     }
 62 | 
 63 |     /**
 64 |      * Creates a 'contains' filter.
 65 |      * (attr=*value*)
 66 |      *
 67 |      * @param  string $attr
 68 |      * @param  string $value
 69 |      * @return Filter
 70 |      */
 71 |     public static function contains($attr, $value)
 72 |     {
 73 |         return new static($attr, $value, self::TYPE_EQUALS, '*', '*');
 74 |     }
 75 | 
 76 |     /**
 77 |      * Creates a 'greater' filter.
 78 |      * (attr>value)
 79 |      *
 80 |      * @param  string $attr
 81 |      * @param  string $value
 82 |      * @return Filter
 83 |      */
 84 |     public static function greater($attr, $value)
 85 |     {
 86 |         return new static($attr, $value, self::TYPE_GREATER, null, null);
 87 |     }
 88 | 
 89 |     /**
 90 |      * Creates a 'greater or equal' filter.
 91 |      * (attr>=value)
 92 |      *
 93 |      * @param  string $attr
 94 |      * @param  string $value
 95 |      * @return Filter
 96 |      */
 97 |     public static function greaterOrEqual($attr, $value)
 98 |     {
 99 |         return new static($attr, $value, self::TYPE_GREATEROREQUAL, null, null);
100 |     }
101 | 
102 |     /**
103 |      * Creates a 'less' filter.
104 |      * (attr<value)
105 |      *
106 |      * @param  string $attr
107 |      * @param  string $value
108 |      * @return Filter
109 |      */
110 |     public static function less($attr, $value)
111 |     {
112 |         return new static($attr, $value, self::TYPE_LESS, null, null);
113 |     }
114 | 
115 |     /**
116 |      * Creates an 'less or equal' filter.
117 |      * (attr<=value)
118 |      *
119 |      * @param  string $attr
120 |      * @param  string $value
121 |      * @return Filter
122 |      */
123 |     public static function lessOrEqual($attr, $value)
124 |     {
125 |         return new static($attr, $value, self::TYPE_LESSOREQUAL, null, null);
126 |     }
127 | 
128 |     /**
129 |      * Creates an 'approx' filter.
130 |      * (attr~=value)
131 |      *
132 |      * @param  string $attr
133 |      * @param  string $value
134 |      * @return Filter
135 |      */
136 |     public static function approx($attr, $value)
137 |     {
138 |         return new static($attr, $value, self::TYPE_APPROX, null, null);
139 |     }
140 | 
141 |     /**
142 |      * Creates an 'any' filter.
143 |      * (attr=*)
144 |      *
145 |      * @param  string $attr
146 |      * @return Filter
147 |      */
148 |     public static function any($attr)
149 |     {
150 |         return new static($attr, '', self::TYPE_EQUALS, '*', null);
151 |     }
152 | 
153 |     /**
154 |      * Creates a simple custom string filter.
155 |      *
156 |      * @param  string $filter
157 |      * @return Filter\StringFilter
158 |      */
159 |     public static function string($filter)
160 |     {
161 |         return new Filter\StringFilter($filter);
162 |     }
163 | 
164 |     /**
165 |      * Creates a simple string filter to be used with a mask.
166 |      *
167 |      * @param string $mask
168 |      * @param string $value
169 |      * @return Filter\MaskFilter
170 |      */
171 |     public static function mask($mask, $value)
172 |     {
173 |         return new Filter\MaskFilter($mask, $value);
174 |     }
175 | 
176 |     /**
177 |      * Creates an 'and' filter.
178 |      *
179 |      * @param  Filter\AbstractFilter $filter,...
180 |      * @return Filter\AndFilter
181 |      */
182 |     public static function andFilter($filter)
183 |     {
184 |         return new Filter\AndFilter(func_get_args());
185 |     }
186 | 
187 |     /**
188 |      * Creates an 'or' filter.
189 |      *
190 |      * @param  Filter\AbstractFilter $filter,...
191 |      * @return Filter\OrFilter
192 |      */
193 |     public static function orFilter($filter)
194 |     {
195 |         return new Filter\OrFilter(func_get_args());
196 |     }
197 | 
198 |     /**
199 |      * Create a filter string.
200 |      *
201 |      * @param  string $attr
202 |      * @param  string $value
203 |      * @param  string $filtertype
204 |      * @param  string $prepend
205 |      * @param  string $append
206 |      * @return string
207 |      */
208 |     private static function createFilterString($attr, $value, $filtertype, $prepend = null, $append = null)
209 |     {
210 |         $str = $attr . $filtertype;
211 |         if ($prepend !== null) {
212 |             $str .= $prepend;
213 |         }
214 |         $str .= ldap_escape($value, null, LDAP_ESCAPE_FILTER);
215 |         if ($append !== null) {
216 |             $str .= $append;
217 |         }
218 |         return $str;
219 |     }
220 | 
221 |     /**
222 |      * Creates a new Zend\Ldap\Filter.
223 |      *
224 |      * @param string $attr
225 |      * @param string $value
226 |      * @param string $filtertype
227 |      * @param string $prepend
228 |      * @param string $append
229 |      */
230 |     public function __construct($attr, $value, $filtertype, $prepend = null, $append = null)
231 |     {
232 |         $filter = static::createFilterString($attr, $value, $filtertype, $prepend, $append);
233 |         parent::__construct($filter);
234 |     }
235 | }
236 | 


--------------------------------------------------------------------------------
/src/Filter/AbstractFilter.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-2015 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\Filter;
 11 | 
 12 | use Zend\Ldap\Converter\Converter;
 13 | 
 14 | /**
 15 |  * Zend\Ldap\Filter\AbstractFilter provides a base implementation for filters.
 16 |  */
 17 | abstract class AbstractFilter
 18 | {
 19 |     /**
 20 |      * Returns a string representation of the filter.
 21 |      *
 22 |      * @return string
 23 |      */
 24 |     abstract public function toString();
 25 | 
 26 |     /**
 27 |      * Returns a string representation of the filter.
 28 |      * @see toString()
 29 |      *
 30 |      * @return string
 31 |      */
 32 |     public function __toString()
 33 |     {
 34 |         return $this->toString();
 35 |     }
 36 | 
 37 |     /**
 38 |      * Negates the filter.
 39 |      *
 40 |      * @return AbstractFilter
 41 |      */
 42 |     public function negate()
 43 |     {
 44 |         return new NotFilter($this);
 45 |     }
 46 | 
 47 |     /**
 48 |      * Creates an 'and' filter.
 49 |      *
 50 |      * @param  AbstractFilter $filter,...
 51 |      * @return AndFilter
 52 |      */
 53 |     public function addAnd($filter)
 54 |     {
 55 |         $fa   = func_get_args();
 56 |         $args = array_merge([$this], $fa);
 57 |         return new AndFilter($args);
 58 |     }
 59 | 
 60 |     /**
 61 |      * Creates an 'or' filter.
 62 |      *
 63 |      * @param  AbstractFilter $filter,...
 64 |      * @return OrFilter
 65 |      */
 66 |     public function addOr($filter)
 67 |     {
 68 |         $fa   = func_get_args();
 69 |         $args = array_merge([$this], $fa);
 70 |         return new OrFilter($args);
 71 |     }
 72 | 
 73 |     /**
 74 |      * Escapes the given VALUES according to RFC 2254 so that they can be safely used in LDAP filters.
 75 |      *
 76 |      * Any control characters with an ACII code < 32 as well as the characters with special meaning in
 77 |      * LDAP filters "*", "(", ")", and "\" (the backslash) are converted into the representation of a
 78 |      * backslash followed by two hex digits representing the hexadecimal value of the character.
 79 |      * @see    Net_LDAP2_Util::escape_filter_value() from Benedikt Hallinger <beni@php.net>
 80 |      * @link   http://pear.php.net/package/Net_LDAP2
 81 |      * @author Benedikt Hallinger <beni@php.net>
 82 |      *
 83 |      * @param  string|array $values Array of values to escape
 84 |      * @return array Array $values, but escaped
 85 |      */
 86 |     public static function escapeValue($values = [])
 87 |     {
 88 |         if (! is_array($values)) {
 89 |             $values = [$values];
 90 |         }
 91 |         foreach ($values as $key => $val) {
 92 |             // Escaping of filter meta characters
 93 |             $val = str_replace(['\\', '*', '(', ')'], ['\5c', '\2a', '\28', '\29'], $val);
 94 |             // ASCII < 32 escaping
 95 |             $val = Converter::ascToHex32($val);
 96 |             if (null === $val) {
 97 |                 $val = '\0'; // apply escaped "null" if string is empty
 98 |             }
 99 |             $values[$key] = $val;
100 |         }
101 |         return (count($values) == 1) ? $values[0] : $values;
102 |     }
103 | 
104 |     /**
105 |      * Undoes the conversion done by {@link escapeValue()}.
106 |      *
107 |      * Converts any sequences of a backslash followed by two hex digits into the corresponding character.
108 |      * @see    Net_LDAP2_Util::escape_filter_value() from Benedikt Hallinger <beni@php.net>
109 |      * @link   http://pear.php.net/package/Net_LDAP2
110 |      * @author Benedikt Hallinger <beni@php.net>
111 |      *
112 |      * @param  string|array $values Array of values to escape
113 |      * @return array Array $values, but unescaped
114 |      */
115 |     public static function unescapeValue($values = [])
116 |     {
117 |         if (! is_array($values)) {
118 |             $values = [$values];
119 |         }
120 |         foreach ($values as $key => $value) {
121 |             // Translate hex code into ascii
122 |             $values[$key] = Converter::hex32ToAsc($value);
123 |         }
124 |         return (count($values) == 1) ? $values[0] : $values;
125 |     }
126 | }
127 | 


--------------------------------------------------------------------------------
/src/Filter/AbstractLogicalFilter.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-2015 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\Filter;
11 | 
12 | /**
13 |  * Zend\Ldap\Filter\AbstractLogicalFilter provides a base implementation for a grouping filter.
14 |  */
15 | abstract class AbstractLogicalFilter extends AbstractFilter
16 | {
17 |     const TYPE_AND = '&';
18 |     const TYPE_OR  = '|';
19 | 
20 |     /**
21 |      * All the sub-filters for this grouping filter.
22 |      *
23 |      * @var array
24 |      */
25 |     private $subfilters;
26 | 
27 |     /**
28 |      * The grouping symbol.
29 |      *
30 |      * @var string
31 |      */
32 |     private $symbol;
33 | 
34 |     /**
35 |      * Creates a new grouping filter.
36 |      *
37 |      * @param array  $subfilters
38 |      * @param string $symbol
39 |      * @throws Exception\FilterException
40 |      */
41 |     protected function __construct(array $subfilters, $symbol)
42 |     {
43 |         foreach ($subfilters as $key => $s) {
44 |             if (is_string($s)) {
45 |                 $subfilters[$key] = new StringFilter($s);
46 |             } elseif (! ($s instanceof AbstractFilter)) {
47 |                 throw new Exception\FilterException('Only strings or Zend\Ldap\Filter\AbstractFilter allowed.');
48 |             }
49 |         }
50 |         $this->subfilters = $subfilters;
51 |         $this->symbol     = $symbol;
52 |     }
53 | 
54 |     /**
55 |      * Adds a filter to this grouping filter.
56 |      *
57 |      * @param  AbstractFilter $filter
58 |      * @return AbstractLogicalFilter
59 |      */
60 |     public function addFilter(AbstractFilter $filter)
61 |     {
62 |         $new               = clone $this;
63 |         $new->subfilters[] = $filter;
64 |         return $new;
65 |     }
66 | 
67 |     /**
68 |      * Returns a string representation of the filter.
69 |      *
70 |      * @return string
71 |      */
72 |     public function toString()
73 |     {
74 |         $return = '(' . $this->symbol;
75 |         foreach ($this->subfilters as $sub) {
76 |             $return .= $sub->toString();
77 |         }
78 |         $return .= ')';
79 |         return $return;
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/src/Filter/AndFilter.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-2015 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\Filter;
11 | 
12 | /**
13 |  * Zend\Ldap\Filter\AndFilter provides an 'and' filter.
14 |  */
15 | class AndFilter extends AbstractLogicalFilter
16 | {
17 |     /**
18 |      * Creates an 'and' grouping filter.
19 |      *
20 |      * @param array $subfilters
21 |      */
22 |     public function __construct(array $subfilters)
23 |     {
24 |         parent::__construct($subfilters, self::TYPE_AND);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Filter/Exception/ExceptionInterface.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-2015 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\Filter\Exception;
11 | 
12 | use Zend\Ldap\Exception\ExceptionInterface as MainLdapException;
13 | 
14 | interface ExceptionInterface extends MainLdapException
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Filter/Exception/FilterException.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-2015 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\Filter\Exception;
11 | 
12 | class FilterException extends \Exception implements ExceptionInterface
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Filter/MaskFilter.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-2015 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\Filter;
11 | 
12 | /**
13 |  * Zend\Ldap\Filter\MaskFilter provides a simple string filter to be used with a mask.
14 |  */
15 | class MaskFilter extends StringFilter
16 | {
17 |     /**
18 |      * Creates a Zend\Ldap\Filter\MaskFilter.
19 |      *
20 |      * @param string $mask
21 |      * @param string $value,...
22 |      */
23 |     public function __construct($mask, $value)
24 |     {
25 |         $args = func_get_args();
26 |         array_shift($args);
27 |         for ($i = 0, $count = count($args); $i < $count; $i++) {
28 |             $args[$i] = static::escapeValue($args[$i]);
29 |         }
30 |         $filter = vsprintf($mask, $args);
31 |         parent::__construct($filter);
32 |     }
33 | 
34 |     /**
35 |      * Returns a string representation of the filter.
36 |      *
37 |      * @return string
38 |      */
39 |     public function toString()
40 |     {
41 |         return $this->filter;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Filter/NotFilter.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-2015 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\Filter;
11 | 
12 | /**
13 |  * Zend\Ldap\Filter\NotFilter provides a negation filter.
14 |  */
15 | class NotFilter extends AbstractFilter
16 | {
17 |     /**
18 |      * The underlying filter.
19 |      *
20 |      * @var AbstractFilter
21 |      */
22 |     private $filter;
23 | 
24 |     /**
25 |      * Creates a Zend\Ldap\Filter\NotFilter.
26 |      *
27 |      * @param AbstractFilter $filter
28 |      */
29 |     public function __construct(AbstractFilter $filter)
30 |     {
31 |         $this->filter = $filter;
32 |     }
33 | 
34 |     /**
35 |      * Negates the filter.
36 |      *
37 |      * @return AbstractFilter
38 |      */
39 |     public function negate()
40 |     {
41 |         return $this->filter;
42 |     }
43 | 
44 |     /**
45 |      * Returns a string representation of the filter.
46 |      *
47 |      * @return string
48 |      */
49 |     public function toString()
50 |     {
51 |         return '(!' . $this->filter->toString() . ')';
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Filter/OrFilter.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-2015 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\Filter;
11 | 
12 | /**
13 |  * Zend\Ldap\Filter\OrFilter provides an 'or' filter.
14 |  */
15 | class OrFilter extends AbstractLogicalFilter
16 | {
17 |     /**
18 |      * Creates an 'or' grouping filter.
19 |      *
20 |      * @param array $subfilters
21 |      */
22 |     public function __construct(array $subfilters)
23 |     {
24 |         parent::__construct($subfilters, self::TYPE_OR);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Filter/StringFilter.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-2015 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\Filter;
11 | 
12 | /**
13 |  * Zend\Ldap\Filter\StringFilter provides a simple custom string filter.
14 |  */
15 | class StringFilter extends AbstractFilter
16 | {
17 |     /**
18 |      * The filter.
19 |      *
20 |      * @var string
21 |      */
22 |     protected $filter;
23 | 
24 |     /**
25 |      * Creates a Zend\Ldap\Filter\StringFilter.
26 |      *
27 |      * @param string $filter
28 |      */
29 |     public function __construct($filter)
30 |     {
31 |         $this->filter = $filter;
32 |     }
33 | 
34 |     /**
35 |      * Returns a string representation of the filter.
36 |      *
37 |      * @return string
38 |      */
39 |     public function toString()
40 |     {
41 |         return '(' . $this->filter . ')';
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Ldif/Encoder.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-2015 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\Ldif;
 11 | 
 12 | use Zend\Ldap;
 13 | 
 14 | /**
 15 |  * Zend\Ldap\Ldif\Encoder provides methods to encode and decode LDAP data into/from Ldif.
 16 |  */
 17 | class Encoder
 18 | {
 19 |     /**
 20 |      * Additional options used during encoding
 21 |      *
 22 |      * @var array
 23 |      */
 24 |     protected $options = [
 25 |         'sort'    => true,
 26 |         'version' => 1,
 27 |         'wrap'    => 78
 28 |     ];
 29 | 
 30 |     /**
 31 |      * @var bool
 32 |      */
 33 |     protected $versionWritten = false;
 34 | 
 35 |     /**
 36 |      * Constructor.
 37 |      *
 38 |      * @param  array $options Additional options used during encoding
 39 |      */
 40 |     protected function __construct(array $options = [])
 41 |     {
 42 |         $this->options = array_merge($this->options, $options);
 43 |     }
 44 | 
 45 |     /**
 46 |      * Decodes the string $string into an array of Ldif items
 47 |      *
 48 |      * @param  string $string
 49 |      * @return array
 50 |      */
 51 |     public static function decode($string)
 52 |     {
 53 |         $encoder = new static([]);
 54 |         return $encoder->_decode($string);
 55 |     }
 56 | 
 57 |     /**
 58 |      * Decodes the string $string into an array of Ldif items
 59 |      *
 60 |      * @param  string $string
 61 |      * @return array
 62 |      */
 63 |     // @codingStandardsIgnoreStart
 64 |     protected function _decode($string)
 65 |     {
 66 |         // @codingStandardsIgnoreEnd
 67 |         $items = [];
 68 |         $item  = [];
 69 |         $last  = null;
 70 |         $inComment = false;
 71 |         foreach (explode("\n", $string) as $line) {
 72 |             $line    = rtrim($line, "\x09\x0A\x0D\x00\x0B");
 73 |             $matches = [];
 74 |             if (substr($line, 0, 1) === ' ' && $last !== null && ! $inComment) {
 75 |                 $last[2] .= substr($line, 1);
 76 |             } elseif (substr($line, 0, 1) === '#') {
 77 |                 $inComment = true;
 78 |                 continue;
 79 |             } elseif (preg_match('/^([a-z0-9;-]+)(:[:<]?\s*)([^<]*)$/i', $line, $matches)) {
 80 |                 $inComment = false;
 81 |                 $name  = strtolower($matches[1]);
 82 |                 $type  = trim($matches[2]);
 83 |                 $value = $matches[3];
 84 |                 if ($last !== null) {
 85 |                     $this->pushAttribute($last, $item);
 86 |                 }
 87 |                 if ($name === 'version') {
 88 |                     continue;
 89 |                 } elseif (count($item) > 0 && $name === 'dn') {
 90 |                     $items[] = $item;
 91 |                     $item    = [];
 92 |                 }
 93 |                 $last = [$name, $type, $value];
 94 |             } elseif (trim($line) === '') {
 95 |                 continue;
 96 |             }
 97 |         }
 98 |         if ($last !== null) {
 99 |             $this->pushAttribute($last, $item);
100 |         }
101 |         $items[] = $item;
102 | 
103 |         return (count($items) > 1) ? $items : $items[0];
104 |     }
105 | 
106 |     /**
107 |      * Pushes a decoded attribute to the stack
108 |      *
109 |      * @param array $attribute
110 |      * @param array $entry
111 |      */
112 |     protected function pushAttribute(array $attribute, array &$entry)
113 |     {
114 |         $name  = $attribute[0];
115 |         $type  = $attribute[1];
116 |         $value = $attribute[2];
117 |         if ($type === '::') {
118 |             $value = base64_decode($value);
119 |         }
120 |         if ($name === 'dn') {
121 |             $entry[$name] = $value;
122 |         } elseif (isset($entry[$name]) && $value !== '') {
123 |             $entry[$name][] = $value;
124 |         } else {
125 |             $entry[$name] = ($value !== '') ? [$value] : [];
126 |         }
127 |     }
128 | 
129 |     /**
130 |      * Encode $value into a Ldif representation
131 |      *
132 |      * @param  mixed $value   The value to be encoded
133 |      * @param  array $options Additional options used during encoding
134 |      * @return string The encoded value
135 |      */
136 |     public static function encode($value, array $options = [])
137 |     {
138 |         $encoder = new static($options);
139 | 
140 |         return $encoder->_encode($value);
141 |     }
142 | 
143 |     /**
144 |      * Recursive driver which determines the type of value to be encoded
145 |      * and then dispatches to the appropriate method.
146 |      *
147 |      * @param  mixed $value The value to be encoded
148 |      * @return string Encoded value
149 |      */
150 |     // @codingStandardsIgnoreStart
151 |     protected function _encode($value)
152 |     {
153 |         // @codingStandardsIgnoreEnd
154 |         if (is_scalar($value)) {
155 |             return $this->encodeString($value);
156 |         } elseif (is_array($value)) {
157 |             return $this->encodeAttributes($value);
158 |         } elseif ($value instanceof Ldap\Node) {
159 |             return $value->toLdif($this->options);
160 |         }
161 | 
162 |         return;
163 |     }
164 | 
165 |     /**
166 |      * Encodes $string according to RFC2849
167 |      *
168 |      * @link http://www.faqs.org/rfcs/rfc2849.html
169 |      *
170 |      * @param  string  $string
171 |      * @param  bool $base64
172 |      * @return string
173 |      */
174 |     protected function encodeString($string, &$base64 = null)
175 |     {
176 |         $string = (string) $string;
177 |         if (! is_numeric($string) && empty($string)) {
178 |             return '';
179 |         }
180 | 
181 |         /*
182 |          * SAFE-INIT-CHAR = %x01-09 / %x0B-0C / %x0E-1F /
183 |          *                  %x21-39 / %x3B / %x3D-7F
184 |          *                ; any value <= 127 except NUL, LF, CR,
185 |          *                ; SPACE, colon (":", ASCII 58 decimal)
186 |          *                ; and less-than ("<" , ASCII 60 decimal)
187 |          *
188 |          */
189 |         $unsafeInitChar = [0, 10, 13, 32, 58, 60];
190 |         /*
191 |          * SAFE-CHAR      = %x01-09 / %x0B-0C / %x0E-7F
192 |          *                ; any value <= 127 decimal except NUL, LF,
193 |          *                ; and CR
194 |          */
195 |         $unsafeChar = [0, 10, 13];
196 | 
197 |         $base64 = false;
198 |         for ($i = 0, $len = strlen($string); $i < $len; $i++) {
199 |             $char = ord(substr($string, $i, 1));
200 |             if ($char >= 127) {
201 |                 $base64 = true;
202 |                 break;
203 |             } elseif ($i === 0 && in_array($char, $unsafeInitChar)) {
204 |                 $base64 = true;
205 |                 break;
206 |             } elseif (in_array($char, $unsafeChar)) {
207 |                 $base64 = true;
208 |                 break;
209 |             }
210 |         }
211 |         // Test for ending space
212 |         if (substr($string, -1) == ' ') {
213 |             $base64 = true;
214 |         }
215 | 
216 |         if ($base64 === true) {
217 |             $string = base64_encode($string);
218 |         }
219 | 
220 |         return $string;
221 |     }
222 | 
223 |     /**
224 |      * Encodes an attribute with $name and $value according to RFC2849
225 |      *
226 |      * @link http://www.faqs.org/rfcs/rfc2849.html
227 |      *
228 |      * @param  string       $name
229 |      * @param  array|string $value
230 |      * @return string
231 |      */
232 |     protected function encodeAttribute($name, $value)
233 |     {
234 |         if (! is_array($value)) {
235 |             $value = [$value];
236 |         }
237 | 
238 |         $output = '';
239 | 
240 |         if (count($value) < 1) {
241 |             return $name . ': ';
242 |         }
243 | 
244 |         foreach ($value as $v) {
245 |             $base64    = null;
246 |             $v         = $this->encodeString($v, $base64);
247 |             $attribute = $name . ':';
248 |             if ($base64 === true) {
249 |                 $attribute .= ': ' . $v;
250 |             } else {
251 |                 $attribute .= ' ' . $v;
252 |             }
253 |             if (isset($this->options['wrap']) && strlen($attribute) > $this->options['wrap']) {
254 |                 $attribute = trim(chunk_split($attribute, $this->options['wrap'], PHP_EOL . ' '));
255 |             }
256 |             $output .= $attribute . PHP_EOL;
257 |         }
258 | 
259 |         return trim($output, PHP_EOL);
260 |     }
261 | 
262 |     /**
263 |      * Encodes a collection of attributes according to RFC2849
264 |      *
265 |      * @link http://www.faqs.org/rfcs/rfc2849.html
266 |      *
267 |      * @param  array $attributes
268 |      * @return string
269 |      */
270 |     protected function encodeAttributes(array $attributes)
271 |     {
272 |         $string     = '';
273 |         $attributes = array_change_key_case($attributes, CASE_LOWER);
274 |         if (! $this->versionWritten && array_key_exists('dn', $attributes) && isset($this->options['version'])
275 |             && array_key_exists('objectclass', $attributes)
276 |         ) {
277 |             $string .= sprintf('version: %d', $this->options['version']) . PHP_EOL;
278 |             $this->versionWritten = true;
279 |         }
280 | 
281 |         if (isset($this->options['sort']) && $this->options['sort'] === true) {
282 |             ksort($attributes, SORT_STRING);
283 |             if (array_key_exists('objectclass', $attributes)) {
284 |                 $oc = $attributes['objectclass'];
285 |                 unset($attributes['objectclass']);
286 |                 $attributes = array_merge(['objectclass' => $oc], $attributes);
287 |             }
288 |             if (array_key_exists('dn', $attributes)) {
289 |                 $dn = $attributes['dn'];
290 |                 unset($attributes['dn']);
291 |                 $attributes = array_merge(['dn' => $dn], $attributes);
292 |             }
293 |         }
294 |         foreach ($attributes as $key => $value) {
295 |             $string .= $this->encodeAttribute($key, $value) . PHP_EOL;
296 |         }
297 | 
298 |         return trim($string, PHP_EOL);
299 |     }
300 | }
301 | 


--------------------------------------------------------------------------------
/src/Node/AbstractNode.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-2015 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\Node;
 11 | 
 12 | use ArrayAccess;
 13 | use Countable;
 14 | use Zend\Ldap;
 15 | use Zend\Ldap\Exception;
 16 | 
 17 | /**
 18 |  * This class provides a base implementation for LDAP nodes
 19 |  */
 20 | abstract class AbstractNode implements ArrayAccess, Countable
 21 | {
 22 |     protected static $systemAttributes = ['createtimestamp', 'creatorsname',
 23 |                                                'entrycsn', 'entrydn', 'entryuuid', 'hassubordinates', 'modifiersname',
 24 |                                                'modifytimestamp', 'structuralobjectclass', 'subschemasubentry',
 25 |                                                'distinguishedname', 'instancetype', 'name', 'objectcategory',
 26 |                                                'objectguid',
 27 |                                                'usnchanged', 'usncreated', 'whenchanged', 'whencreated'];
 28 | 
 29 |     /**
 30 |      * Holds the node's DN.
 31 |      *
 32 |      * @var \Zend\Ldap\Dn
 33 |      */
 34 |     protected $dn;
 35 | 
 36 |     /**
 37 |      * Holds the node's current data.
 38 |      *
 39 |      * @var array
 40 |      */
 41 |     protected $currentData;
 42 | 
 43 |     /**
 44 |      * Constructor.
 45 |      *
 46 |      * Constructor is protected to enforce the use of factory methods.
 47 |      *
 48 |      * @param  \Zend\Ldap\Dn $dn
 49 |      * @param  array         $data
 50 |      * @param  bool       $fromDataSource
 51 |      */
 52 |     protected function __construct(Ldap\Dn $dn, array $data, $fromDataSource)
 53 |     {
 54 |         $this->dn = $dn;
 55 |         $this->loadData($data, $fromDataSource);
 56 |     }
 57 | 
 58 |     /**
 59 |      * @param array   $data
 60 |      * @param  bool $fromDataSource
 61 |      */
 62 |     protected function loadData(array $data, $fromDataSource)
 63 |     {
 64 |         if (array_key_exists('dn', $data)) {
 65 |             unset($data['dn']);
 66 |         }
 67 |         ksort($data, SORT_STRING);
 68 |         $this->currentData = $data;
 69 |     }
 70 | 
 71 |     /**
 72 |      * Reload node attributes from LDAP.
 73 |      *
 74 |      * This is an online method.
 75 |      *
 76 |      * @param  \Zend\Ldap\Ldap $ldap
 77 |      * @return AbstractNode Provides a fluid interface
 78 |      */
 79 |     public function reload(Ldap\Ldap $ldap = null)
 80 |     {
 81 |         if ($ldap !== null) {
 82 |             $data = $ldap->getEntry($this->_getDn(), ['*', '+'], true);
 83 |             $this->loadData($data, true);
 84 |         }
 85 | 
 86 |         return $this;
 87 |     }
 88 | 
 89 |     /**
 90 |      * Gets the DN of the current node as a Zend\Ldap\Dn.
 91 |      *
 92 |      * This is an offline method.
 93 |      *
 94 |      * @return \Zend\Ldap\Dn
 95 |      */
 96 |     // @codingStandardsIgnoreStart
 97 |     protected function _getDn()
 98 |     {
 99 |         // @codingStandardsIgnoreEnd
100 |         return $this->dn;
101 |     }
102 | 
103 |     /**
104 |      * Gets the DN of the current node as a Zend\Ldap\Dn.
105 |      * The method returns a clone of the node's DN to prohibit modification.
106 |      *
107 |      * This is an offline method.
108 |      *
109 |      * @return \Zend\Ldap\Dn
110 |      */
111 |     public function getDn()
112 |     {
113 |         $dn = clone $this->_getDn();
114 |         return $dn;
115 |     }
116 | 
117 |     /**
118 |      * Gets the DN of the current node as a string.
119 |      *
120 |      * This is an offline method.
121 |      *
122 |      * @param  string $caseFold
123 |      * @return string
124 |      */
125 |     public function getDnString($caseFold = null)
126 |     {
127 |         return $this->_getDn()->toString($caseFold);
128 |     }
129 | 
130 |     /**
131 |      * Gets the DN of the current node as an array.
132 |      *
133 |      * This is an offline method.
134 |      *
135 |      * @param  string $caseFold
136 |      * @return array
137 |      */
138 |     public function getDnArray($caseFold = null)
139 |     {
140 |         return $this->_getDn()->toArray($caseFold);
141 |     }
142 | 
143 |     /**
144 |      * Gets the RDN of the current node as a string.
145 |      *
146 |      * This is an offline method.
147 |      *
148 |      * @param  string $caseFold
149 |      * @return string
150 |      */
151 |     public function getRdnString($caseFold = null)
152 |     {
153 |         return $this->_getDn()->getRdnString($caseFold);
154 |     }
155 | 
156 |     /**
157 |      * Gets the RDN of the current node as an array.
158 |      *
159 |      * This is an offline method.
160 |      *
161 |      * @param  string $caseFold
162 |      * @return array
163 |      */
164 |     public function getRdnArray($caseFold = null)
165 |     {
166 |         return $this->_getDn()->getRdn($caseFold);
167 |     }
168 | 
169 |     /**
170 |      * Gets the objectClass of the node
171 |      *
172 |      * @return array
173 |      */
174 |     public function getObjectClass()
175 |     {
176 |         return $this->getAttribute('objectClass', null);
177 |     }
178 | 
179 |     /**
180 |      * Gets all attributes of node.
181 |      *
182 |      * The collection contains all attributes.
183 |      *
184 |      * This is an offline method.
185 |      *
186 |      * @param  bool $includeSystemAttributes
187 |      * @return array
188 |      */
189 |     public function getAttributes($includeSystemAttributes = true)
190 |     {
191 |         $data = [];
192 |         foreach ($this->getData($includeSystemAttributes) as $name => $value) {
193 |             $data[$name] = $this->getAttribute($name, null);
194 |         }
195 |         return $data;
196 |     }
197 | 
198 |     /**
199 |      * Returns the DN of the current node. {@see getDnString()}
200 |      *
201 |      * @return string
202 |      */
203 |     public function toString()
204 |     {
205 |         return $this->getDnString();
206 |     }
207 | 
208 |     /**
209 |      * Cast to string representation {@see toString()}
210 |      *
211 |      * @return string
212 |      */
213 |     public function __toString()
214 |     {
215 |         return $this->toString();
216 |     }
217 | 
218 |     /**
219 |      * Returns an array representation of the current node
220 |      *
221 |      * @param  bool $includeSystemAttributes
222 |      * @return array
223 |      */
224 |     public function toArray($includeSystemAttributes = true)
225 |     {
226 |         $attributes = $this->getAttributes($includeSystemAttributes);
227 |         return array_merge(['dn' => $this->getDnString()], $attributes);
228 |     }
229 | 
230 |     /**
231 |      * Returns a JSON representation of the current node
232 |      *
233 |      * @param  bool $includeSystemAttributes
234 |      * @return string
235 |      */
236 |     public function toJson($includeSystemAttributes = true)
237 |     {
238 |         return json_encode($this->toArray($includeSystemAttributes));
239 |     }
240 | 
241 |     /**
242 |      * Gets node attributes.
243 |      *
244 |      * The array contains all attributes in its internal format (no conversion).
245 |      *
246 |      * This is an offline method.
247 |      *
248 |      * @param  bool $includeSystemAttributes
249 |      * @return array
250 |      */
251 |     public function getData($includeSystemAttributes = true)
252 |     {
253 |         if ($includeSystemAttributes === false) {
254 |             $data = [];
255 |             foreach ($this->currentData as $key => $value) {
256 |                 if (! in_array($key, static::$systemAttributes)) {
257 |                     $data[$key] = $value;
258 |                 }
259 |             }
260 |             return $data;
261 |         }
262 | 
263 |         return $this->currentData;
264 |     }
265 | 
266 |     /**
267 |      * Checks whether a given attribute exists.
268 |      *
269 |      * If $emptyExists is false empty attributes (containing only array()) are
270 |      * treated as non-existent returning false.
271 |      * If $emptyExists is true empty attributes are treated as existent returning
272 |      * true. In this case method returns false only if the attribute name is
273 |      * missing in the key-collection.
274 |      *
275 |      * @param  string  $name
276 |      * @param  bool $emptyExists
277 |      * @return bool
278 |      */
279 |     public function existsAttribute($name, $emptyExists = false)
280 |     {
281 |         $name = strtolower($name);
282 |         if (isset($this->currentData[$name])) {
283 |             if ($emptyExists) {
284 |                 return true;
285 |             }
286 | 
287 |             return count($this->currentData[$name]) > 0;
288 |         }
289 | 
290 |         return false;
291 |     }
292 | 
293 |     /**
294 |      * Checks if the given value(s) exist in the attribute
295 |      *
296 |      * @param  string      $attribName
297 |      * @param  mixed|array $value
298 |      * @return bool
299 |      */
300 |     public function attributeHasValue($attribName, $value)
301 |     {
302 |         return Ldap\Attribute::attributeHasValue($this->currentData, $attribName, $value);
303 |     }
304 | 
305 |     /**
306 |      * Gets a LDAP attribute.
307 |      *
308 |      * This is an offline method.
309 |      *
310 |      * @param  string  $name
311 |      * @param  int $index
312 |      * @return mixed
313 |      * @throws \Zend\Ldap\Exception\LdapException
314 |      */
315 |     public function getAttribute($name, $index = null)
316 |     {
317 |         if ($name == 'dn') {
318 |             return $this->getDnString();
319 |         }
320 | 
321 |         return Ldap\Attribute::getAttribute($this->currentData, $name, $index);
322 |     }
323 | 
324 |     /**
325 |      * Gets a LDAP date/time attribute.
326 |      *
327 |      * This is an offline method.
328 |      *
329 |      * @param  string  $name
330 |      * @param  int $index
331 |      * @return array|int
332 |      * @throws \Zend\Ldap\Exception\LdapException
333 |      */
334 |     public function getDateTimeAttribute($name, $index = null)
335 |     {
336 |         return Ldap\Attribute::getDateTimeAttribute($this->currentData, $name, $index);
337 |     }
338 | 
339 |     /**
340 |      * Sets a LDAP attribute.
341 |      *
342 |      * This is an offline method.
343 |      *
344 |      * @param  string $name
345 |      * @param  mixed  $value
346 |      * @throws \Zend\Ldap\Exception\BadMethodCallException
347 |      */
348 |     public function __set($name, $value)
349 |     {
350 |         throw new Exception\BadMethodCallException();
351 |     }
352 | 
353 |     /**
354 |      * Gets a LDAP attribute.
355 |      *
356 |      * This is an offline method.
357 |      *
358 |      * @param  string $name
359 |      * @return mixed
360 |      * @throws \Zend\Ldap\Exception\LdapException
361 |      */
362 |     public function __get($name)
363 |     {
364 |         return $this->getAttribute($name, null);
365 |     }
366 | 
367 |     /**
368 |      * Deletes a LDAP attribute.
369 |      *
370 |      * This method deletes the attribute.
371 |      *
372 |      * This is an offline method.
373 |      *
374 |      * @param  $name
375 |      * @throws \Zend\Ldap\Exception\BadMethodCallException
376 |      */
377 |     public function __unset($name)
378 |     {
379 |         throw new Exception\BadMethodCallException();
380 |     }
381 | 
382 |     /**
383 |      * Checks whether a given attribute exists.
384 |      *
385 |      * Empty attributes will be treated as non-existent.
386 |      *
387 |      * @param  string $name
388 |      * @return bool
389 |      */
390 |     public function __isset($name)
391 |     {
392 |         return $this->existsAttribute($name, false);
393 |     }
394 | 
395 |     /**
396 |      * Sets a LDAP attribute.
397 |      * Implements ArrayAccess.
398 |      *
399 |      * This is an offline method.
400 |      *
401 |      * @param  string $name
402 |      * @param         $value
403 |      * @throws \Zend\Ldap\Exception\BadMethodCallException
404 |      * @param  mixed  $value
405 |      * @throws \Zend\Ldap\Exception\BadMethodCallException
406 |      */
407 |     public function offsetSet($name, $value)
408 |     {
409 |         throw new Exception\BadMethodCallException();
410 |     }
411 | 
412 |     /**
413 |      * Gets a LDAP attribute.
414 |      * Implements ArrayAccess.
415 |      *
416 |      * This is an offline method.
417 |      *
418 |      * @param  string $name
419 |      * @return mixed
420 |      * @throws \Zend\Ldap\Exception\LdapException
421 |      */
422 |     public function offsetGet($name)
423 |     {
424 |         return $this->getAttribute($name, null);
425 |     }
426 | 
427 |     /**
428 |      * Deletes a LDAP attribute.
429 |      * Implements ArrayAccess.
430 |      *
431 |      * This method deletes the attribute.
432 |      *
433 |      * This is an offline method.
434 |      *
435 |      * @param  $name
436 |      * @throws \Zend\Ldap\Exception\BadMethodCallException
437 |      */
438 |     public function offsetUnset($name)
439 |     {
440 |         throw new Exception\BadMethodCallException();
441 |     }
442 | 
443 |     /**
444 |      * Checks whether a given attribute exists.
445 |      * Implements ArrayAccess.
446 |      *
447 |      * Empty attributes will be treated as non-existent.
448 |      *
449 |      * @param  string $name
450 |      * @return bool
451 |      */
452 |     public function offsetExists($name)
453 |     {
454 |         return $this->existsAttribute($name, false);
455 |     }
456 | 
457 |     /**
458 |      * Returns the number of attributes in node.
459 |      * Implements Countable
460 |      *
461 |      * @return int
462 |      */
463 |     public function count()
464 |     {
465 |         return count($this->currentData);
466 |     }
467 | }
468 | 


--------------------------------------------------------------------------------
/src/Node/ChildrenIterator.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-2015 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\Node;
 11 | 
 12 | use ArrayAccess;
 13 | use Countable;
 14 | use Iterator;
 15 | use RecursiveIterator;
 16 | use Zend\Ldap;
 17 | 
 18 | /**
 19 |  * Zend\Ldap\Node\ChildrenIterator provides an iterator to a collection of children nodes.
 20 |  */
 21 | class ChildrenIterator implements Iterator, Countable, RecursiveIterator, ArrayAccess
 22 | {
 23 |     /**
 24 |      * An array of Zend\Ldap\Node objects
 25 |      *
 26 |      * @var array
 27 |      */
 28 |     private $data;
 29 | 
 30 |     /**
 31 |      * Constructor.
 32 |      *
 33 |      * @param array $data
 34 |      * @return \Zend\Ldap\Node\ChildrenIterator
 35 |      */
 36 |     public function __construct(array $data)
 37 |     {
 38 |         $this->data = $data;
 39 |     }
 40 | 
 41 |     /**
 42 |      * Returns the number of child nodes.
 43 |      * Implements Countable
 44 |      *
 45 |      * @return int
 46 |      */
 47 |     public function count()
 48 |     {
 49 |         return count($this->data);
 50 |     }
 51 | 
 52 |     /**
 53 |      * Return the current child.
 54 |      * Implements Iterator
 55 |      *
 56 |      * @return \Zend\Ldap\Node
 57 |      */
 58 |     public function current()
 59 |     {
 60 |         return current($this->data);
 61 |     }
 62 | 
 63 |     /**
 64 |      * Return the child'd RDN.
 65 |      * Implements Iterator
 66 |      *
 67 |      * @return string
 68 |      */
 69 |     public function key()
 70 |     {
 71 |         return key($this->data);
 72 |     }
 73 | 
 74 |     /**
 75 |      * Move forward to next child.
 76 |      * Implements Iterator
 77 |      */
 78 |     public function next()
 79 |     {
 80 |         next($this->data);
 81 |     }
 82 | 
 83 |     /**
 84 |      * Rewind the Iterator to the first child.
 85 |      * Implements Iterator
 86 |      */
 87 |     public function rewind()
 88 |     {
 89 |         reset($this->data);
 90 |     }
 91 | 
 92 |     /**
 93 |      * Check if there is a current child
 94 |      * after calls to rewind() or next().
 95 |      * Implements Iterator
 96 |      *
 97 |      * @return bool
 98 |      */
 99 |     public function valid()
100 |     {
101 |         return (current($this->data) !== false);
102 |     }
103 | 
104 |     /**
105 |      * Checks if current node has children.
106 |      * Returns whether the current element has children.
107 |      *
108 |      * @return bool
109 |      */
110 |     public function hasChildren()
111 |     {
112 |         if ($this->current() instanceof Ldap\Node) {
113 |             return $this->current()->hasChildren();
114 |         }
115 | 
116 |         return false;
117 |     }
118 | 
119 |     /**
120 |      * Returns the children for the current node.
121 |      *
122 |      * @return ChildrenIterator
123 |      */
124 |     public function getChildren()
125 |     {
126 |         if ($this->current() instanceof Ldap\Node) {
127 |             return $this->current()->getChildren();
128 |         }
129 | 
130 |         return;
131 |     }
132 | 
133 |     /**
134 |      * Returns a child with a given RDN.
135 |      * Implements ArrayAccess.
136 |      *
137 |      * @param  string $rdn
138 |      * @return array|null
139 |      */
140 |     public function offsetGet($rdn)
141 |     {
142 |         if ($this->offsetExists($rdn)) {
143 |             return $this->data[$rdn];
144 |         }
145 | 
146 |         return;
147 |     }
148 | 
149 |     /**
150 |      * Checks whether a given rdn exists.
151 |      * Implements ArrayAccess.
152 |      *
153 |      * @param  string $rdn
154 |      * @return bool
155 |      */
156 |     public function offsetExists($rdn)
157 |     {
158 |         return (array_key_exists($rdn, $this->data));
159 |     }
160 | 
161 |     /**
162 |      * Does nothing.
163 |      * Implements ArrayAccess.
164 |      *
165 |      * @param $name
166 |      */
167 |     public function offsetUnset($name)
168 |     {
169 |     }
170 | 
171 |     /**
172 |      * Does nothing.
173 |      * Implements ArrayAccess.
174 |      *
175 |      * @param  string $name
176 |      * @param         $value
177 |      */
178 |     public function offsetSet($name, $value)
179 |     {
180 |     }
181 | 
182 |     /**
183 |      * Get all children as an array
184 |      *
185 |      * @return array
186 |      */
187 |     public function toArray()
188 |     {
189 |         $data = [];
190 |         foreach ($this as $rdn => $node) {
191 |             $data[$rdn] = $node;
192 |         }
193 |         return $data;
194 |     }
195 | }
196 | 


--------------------------------------------------------------------------------
/src/Node/Collection.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-2015 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\Node;
11 | 
12 | use Zend\Ldap;
13 | 
14 | /**
15 |  * Zend\Ldap\Node\Collection provides a collection of nodes.
16 |  */
17 | class Collection extends Ldap\Collection
18 | {
19 |     /**
20 |      * Creates the data structure for the given entry data
21 |      *
22 |      * @param  array $data
23 |      * @return \Zend\Ldap\Node
24 |      */
25 |     protected function createEntry(array $data)
26 |     {
27 |         $node = Ldap\Node::fromArray($data, true);
28 |         $node->attachLDAP($this->iterator->getLDAP());
29 |         return $node;
30 |     }
31 | 
32 |     /**
33 |      * Return the child key (DN).
34 |      * Implements Iterator and RecursiveIterator
35 |      *
36 |      * @return string
37 |      */
38 |     public function key()
39 |     {
40 |         return $this->iterator->key();
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Node/RootDse.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-2015 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\Node;
 11 | 
 12 | use Zend\Ldap;
 13 | 
 14 | /**
 15 |  * Zend\Ldap\Node\RootDse provides a simple data-container for the RootDse node.
 16 |  */
 17 | class RootDse extends AbstractNode
 18 | {
 19 |     const SERVER_TYPE_GENERIC         = 1;
 20 |     const SERVER_TYPE_OPENLDAP        = 2;
 21 |     const SERVER_TYPE_ACTIVEDIRECTORY = 3;
 22 |     const SERVER_TYPE_EDIRECTORY      = 4;
 23 | 
 24 |     /**
 25 |      * Factory method to create the RootDse.
 26 |      *
 27 |      * @param \Zend\Ldap\Ldap $ldap
 28 |      * @return RootDse
 29 |      */
 30 |     public static function create(Ldap\Ldap $ldap)
 31 |     {
 32 |         $dn   = Ldap\Dn::fromString('');
 33 |         $data = $ldap->getEntry($dn, ['*', '+'], true);
 34 |         if (isset($data['domainfunctionality'])) {
 35 |             return new RootDse\ActiveDirectory($dn, $data);
 36 |         } elseif (isset($data['dsaname'])) {
 37 |             return new RootDse\eDirectory($dn, $data);
 38 |         } elseif (isset($data['structuralobjectclass'])
 39 |             && $data['structuralobjectclass'][0] === 'OpenLDAProotDSE'
 40 |         ) {
 41 |             return new RootDse\OpenLdap($dn, $data);
 42 |         }
 43 | 
 44 |         return new static($dn, $data);
 45 |     }
 46 | 
 47 |     /**
 48 |      * Constructor.
 49 |      *
 50 |      * Constructor is protected to enforce the use of factory methods.
 51 |      *
 52 |      * @param \Zend\Ldap\Dn $dn
 53 |      * @param array         $data
 54 |      */
 55 |     protected function __construct(Ldap\Dn $dn, array $data)
 56 |     {
 57 |         parent::__construct($dn, $data, true);
 58 |     }
 59 | 
 60 |     /**
 61 |      * Gets the namingContexts.
 62 |      *
 63 |      * @return array
 64 |      */
 65 |     public function getNamingContexts()
 66 |     {
 67 |         return $this->getAttribute('namingContexts', null);
 68 |     }
 69 | 
 70 |     /**
 71 |      * Gets the subschemaSubentry.
 72 |      *
 73 |      * @return string|null
 74 |      */
 75 |     public function getSubschemaSubentry()
 76 |     {
 77 |         return $this->getAttribute('subschemaSubentry', 0);
 78 |     }
 79 | 
 80 |     /**
 81 |      * Determines if the version is supported
 82 |      *
 83 |      * @param  string|int|array $versions version(s) to check
 84 |      * @return bool
 85 |      */
 86 |     public function supportsVersion($versions)
 87 |     {
 88 |         return $this->attributeHasValue('supportedLDAPVersion', $versions);
 89 |     }
 90 | 
 91 |     /**
 92 |      * Determines if the sasl mechanism is supported
 93 |      *
 94 |      * @param  string|array $mechlist SASL mechanisms to check
 95 |      * @return bool
 96 |      */
 97 |     public function supportsSaslMechanism($mechlist)
 98 |     {
 99 |         return $this->attributeHasValue('supportedSASLMechanisms', $mechlist);
100 |     }
101 | 
102 |     /**
103 |      * Gets the server type
104 |      *
105 |      * @return int
106 |      */
107 |     public function getServerType()
108 |     {
109 |         return self::SERVER_TYPE_GENERIC;
110 |     }
111 | 
112 |     /**
113 |      * Returns the schema DN
114 |      *
115 |      * @return \Zend\Ldap\Dn
116 |      */
117 |     public function getSchemaDn()
118 |     {
119 |         $schemaDn = $this->getSubschemaSubentry();
120 |         return Ldap\Dn::fromString($schemaDn);
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/src/Node/RootDse/ActiveDirectory.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-2015 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\Node\RootDse;
 11 | 
 12 | use Zend\Ldap;
 13 | use Zend\Ldap\Node;
 14 | 
 15 | /**
 16 |  * Zend\Ldap\Node\RootDse\ActiveDirectory provides a simple data-container for
 17 |  * the RootDse node of an Active Directory server.
 18 |  */
 19 | class ActiveDirectory extends Node\RootDse
 20 | {
 21 |     /**
 22 |      * Gets the configurationNamingContext.
 23 |      *
 24 |      * @return string|null
 25 |      */
 26 |     public function getConfigurationNamingContext()
 27 |     {
 28 |         return $this->getAttribute('configurationNamingContext', 0);
 29 |     }
 30 | 
 31 |     /**
 32 |      * Gets the currentTime.
 33 |      *
 34 |      * @return string|null
 35 |      */
 36 |     public function getCurrentTime()
 37 |     {
 38 |         return $this->getAttribute('currentTime', 0);
 39 |     }
 40 | 
 41 |     /**
 42 |      * Gets the defaultNamingContext.
 43 |      *
 44 |      * @return string|null
 45 |      */
 46 |     public function getDefaultNamingContext()
 47 |     {
 48 |         return $this->getAttribute('defaultNamingContext', 0);
 49 |     }
 50 | 
 51 |     /**
 52 |      * Gets the dnsHostName.
 53 |      *
 54 |      * @return string|null
 55 |      */
 56 |     public function getDnsHostName()
 57 |     {
 58 |         return $this->getAttribute('dnsHostName', 0);
 59 |     }
 60 | 
 61 |     /**
 62 |      * Gets the domainControllerFunctionality.
 63 |      *
 64 |      * @return string|null
 65 |      */
 66 |     public function getDomainControllerFunctionality()
 67 |     {
 68 |         return $this->getAttribute('domainControllerFunctionality', 0);
 69 |     }
 70 | 
 71 |     /**
 72 |      * Gets the domainFunctionality.
 73 |      *
 74 |      * @return string|null
 75 |      */
 76 |     public function getDomainFunctionality()
 77 |     {
 78 |         return $this->getAttribute('domainFunctionality', 0);
 79 |     }
 80 | 
 81 |     /**
 82 |      * Gets the dsServiceName.
 83 |      *
 84 |      * @return string|null
 85 |      */
 86 |     public function getDsServiceName()
 87 |     {
 88 |         return $this->getAttribute('dsServiceName', 0);
 89 |     }
 90 | 
 91 |     /**
 92 |      * Gets the forestFunctionality.
 93 |      *
 94 |      * @return string|null
 95 |      */
 96 |     public function getForestFunctionality()
 97 |     {
 98 |         return $this->getAttribute('forestFunctionality', 0);
 99 |     }
100 | 
101 |     /**
102 |      * Gets the highestCommittedUSN.
103 |      *
104 |      * @return string|null
105 |      */
106 |     public function getHighestCommittedUSN()
107 |     {
108 |         return $this->getAttribute('highestCommittedUSN', 0);
109 |     }
110 | 
111 |     /**
112 |      * Gets the isGlobalCatalogReady.
113 |      *
114 |      * @return string|null
115 |      */
116 |     public function getIsGlobalCatalogReady()
117 |     {
118 |         return $this->getAttribute('isGlobalCatalogReady', 0);
119 |     }
120 | 
121 |     /**
122 |      * Gets the isSynchronized.
123 |      *
124 |      * @return string|null
125 |      */
126 |     public function getIsSynchronized()
127 |     {
128 |         return $this->getAttribute('isSynchronized', 0);
129 |     }
130 | 
131 |     /**
132 |      * Gets the ldapServiceName.
133 |      *
134 |      * @return string|null
135 |      */
136 |     public function getLDAPServiceName()
137 |     {
138 |         return $this->getAttribute('ldapServiceName', 0);
139 |     }
140 | 
141 |     /**
142 |      * Gets the rootDomainNamingContext.
143 |      *
144 |      * @return string|null
145 |      */
146 |     public function getRootDomainNamingContext()
147 |     {
148 |         return $this->getAttribute('rootDomainNamingContext', 0);
149 |     }
150 | 
151 |     /**
152 |      * Gets the schemaNamingContext.
153 |      *
154 |      * @return string|null
155 |      */
156 |     public function getSchemaNamingContext()
157 |     {
158 |         return $this->getAttribute('schemaNamingContext', 0);
159 |     }
160 | 
161 |     /**
162 |      * Gets the serverName.
163 |      *
164 |      * @return string|null
165 |      */
166 |     public function getServerName()
167 |     {
168 |         return $this->getAttribute('serverName', 0);
169 |     }
170 | 
171 |     /**
172 |      * Determines if the capability is supported
173 |      *
174 |      * @param string|string|array $oids capability(s) to check
175 |      * @return bool
176 |      */
177 |     public function supportsCapability($oids)
178 |     {
179 |         return $this->attributeHasValue('supportedCapabilities', $oids);
180 |     }
181 | 
182 |     /**
183 |      * Determines if the control is supported
184 |      *
185 |      * @param string|array $oids control oid(s) to check
186 |      * @return bool
187 |      */
188 |     public function supportsControl($oids)
189 |     {
190 |         return $this->attributeHasValue('supportedControl', $oids);
191 |     }
192 | 
193 |     /**
194 |      * Determines if the version is supported
195 |      *
196 |      * @param string|array $policies policy(s) to check
197 |      * @return bool
198 |      */
199 |     public function supportsPolicy($policies)
200 |     {
201 |         return $this->attributeHasValue('supportedLDAPPolicies', $policies);
202 |     }
203 | 
204 |     /**
205 |      * Gets the server type
206 |      *
207 |      * @return int
208 |      */
209 |     public function getServerType()
210 |     {
211 |         return self::SERVER_TYPE_ACTIVEDIRECTORY;
212 |     }
213 | 
214 |     /**
215 |      * Returns the schema DN
216 |      *
217 |      * @return \Zend\Ldap\Dn
218 |      */
219 |     public function getSchemaDn()
220 |     {
221 |         $schemaDn = $this->getSchemaNamingContext();
222 |         return Ldap\Dn::fromString($schemaDn);
223 |     }
224 | }
225 | 


--------------------------------------------------------------------------------
/src/Node/RootDse/OpenLdap.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-2015 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\Node\RootDse;
11 | 
12 | use Zend\Ldap\Node;
13 | 
14 | /**
15 |  * Zend\Ldap\Node\RootDse\OpenLdap provides a simple data-container for the
16 |  * RootDse node of an OpenLDAP server.
17 |  */
18 | class OpenLdap extends Node\RootDse
19 | {
20 |     /**
21 |      * Gets the configContext.
22 |      *
23 |      * @return string|null
24 |      */
25 |     public function getConfigContext()
26 |     {
27 |         return $this->getAttribute('configContext', 0);
28 |     }
29 | 
30 |     /**
31 |      * Gets the monitorContext.
32 |      *
33 |      * @return string|null
34 |      */
35 |     public function getMonitorContext()
36 |     {
37 |         return $this->getAttribute('monitorContext', 0);
38 |     }
39 | 
40 |     /**
41 |      * Determines if the control is supported
42 |      *
43 |      * @param  string|array $oids control oid(s) to check
44 |      * @return bool
45 |      */
46 |     public function supportsControl($oids)
47 |     {
48 |         return $this->attributeHasValue('supportedControl', $oids);
49 |     }
50 | 
51 |     /**
52 |      * Determines if the extension is supported
53 |      *
54 |      * @param  string|array $oids oid(s) to check
55 |      * @return bool
56 |      */
57 |     public function supportsExtension($oids)
58 |     {
59 |         return $this->attributeHasValue('supportedExtension', $oids);
60 |     }
61 | 
62 |     /**
63 |      * Determines if the feature is supported
64 |      *
65 |      * @param  string|array $oids feature oid(s) to check
66 |      * @return bool
67 |      */
68 |     public function supportsFeature($oids)
69 |     {
70 |         return $this->attributeHasValue('supportedFeatures', $oids);
71 |     }
72 | 
73 |     /**
74 |      * Gets the server type
75 |      *
76 |      * @return int
77 |      */
78 |     public function getServerType()
79 |     {
80 |         return self::SERVER_TYPE_OPENLDAP;
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Node/RootDse/eDirectory.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-2015 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\Node\RootDse;
 11 | 
 12 | use Zend\Ldap\Node;
 13 | 
 14 | /**
 15 |  * Zend\Ldap\Node\RootDse\eDirectory provides a simple data-container for the
 16 |  * RootDse node of a Novell eDirectory server.
 17 |  */
 18 | // @codingStandardsIgnoreStart
 19 | class eDirectory extends Node\RootDse
 20 | {
 21 |     // @codingStandardsIgnoreEnd
 22 |     /**
 23 |      * Determines if the extension is supported
 24 |      *
 25 |      * @param  string|array $oids oid(s) to check
 26 |      * @return bool
 27 |      */
 28 |     public function supportsExtension($oids)
 29 |     {
 30 |         return $this->attributeHasValue('supportedExtension', $oids);
 31 |     }
 32 | 
 33 |     /**
 34 |      * Gets the vendorName.
 35 |      *
 36 |      * @return string|null
 37 |      */
 38 |     public function getVendorName()
 39 |     {
 40 |         return $this->getAttribute('vendorName', 0);
 41 |     }
 42 | 
 43 |     /**
 44 |      * Gets the vendorVersion.
 45 |      *
 46 |      * @return string|null
 47 |      */
 48 |     public function getVendorVersion()
 49 |     {
 50 |         return $this->getAttribute('vendorVersion', 0);
 51 |     }
 52 | 
 53 |     /**
 54 |      * Gets the dsaName.
 55 |      *
 56 |      * @return string|null
 57 |      */
 58 |     public function getDsaName()
 59 |     {
 60 |         return $this->getAttribute('dsaName', 0);
 61 |     }
 62 | 
 63 |     /**
 64 |      * Gets the server statistics "errors".
 65 |      *
 66 |      * @return string|null
 67 |      */
 68 |     public function getStatisticsErrors()
 69 |     {
 70 |         return $this->getAttribute('errors', 0);
 71 |     }
 72 | 
 73 |     /**
 74 |      * Gets the server statistics "securityErrors".
 75 |      *
 76 |      * @return string|null
 77 |      */
 78 |     public function getStatisticsSecurityErrors()
 79 |     {
 80 |         return $this->getAttribute('securityErrors', 0);
 81 |     }
 82 | 
 83 |     /**
 84 |      * Gets the server statistics "chainings".
 85 |      *
 86 |      * @return string|null
 87 |      */
 88 |     public function getStatisticsChainings()
 89 |     {
 90 |         return $this->getAttribute('chainings', 0);
 91 |     }
 92 | 
 93 |     /**
 94 |      * Gets the server statistics "referralsReturned".
 95 |      *
 96 |      * @return string|null
 97 |      */
 98 |     public function getStatisticsReferralsReturned()
 99 |     {
100 |         return $this->getAttribute('referralsReturned', 0);
101 |     }
102 | 
103 |     /**
104 |      * Gets the server statistics "extendedOps".
105 |      *
106 |      * @return string|null
107 |      */
108 |     public function getStatisticsExtendedOps()
109 |     {
110 |         return $this->getAttribute('extendedOps', 0);
111 |     }
112 | 
113 |     /**
114 |      * Gets the server statistics "abandonOps".
115 |      *
116 |      * @return string|null
117 |      */
118 |     public function getStatisticsAbandonOps()
119 |     {
120 |         return $this->getAttribute('abandonOps', 0);
121 |     }
122 | 
123 |     /**
124 |      * Gets the server statistics "wholeSubtreeSearchOps".
125 |      *
126 |      * @return string|null
127 |      */
128 |     public function getStatisticsWholeSubtreeSearchOps()
129 |     {
130 |         return $this->getAttribute('wholeSubtreeSearchOps', 0);
131 |     }
132 | 
133 |     /**
134 |      * Gets the server type
135 |      *
136 |      * @return int
137 |      */
138 |     public function getServerType()
139 |     {
140 |         return self::SERVER_TYPE_EDIRECTORY;
141 |     }
142 | }
143 | 


--------------------------------------------------------------------------------
/src/Node/Schema.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-2015 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\Node;
11 | 
12 | use Zend\Ldap;
13 | 
14 | /**
15 |  * Zend\Ldap\Node\Schema provides a simple data-container for the Schema node.
16 |  */
17 | class Schema extends AbstractNode
18 | {
19 |     const OBJECTCLASS_TYPE_UNKNOWN    = 0;
20 |     const OBJECTCLASS_TYPE_STRUCTURAL = 1;
21 |     const OBJECTCLASS_TYPE_ABSTRACT   = 3;
22 |     const OBJECTCLASS_TYPE_AUXILIARY  = 4;
23 | 
24 |     /**
25 |      * Factory method to create the Schema node.
26 |      *
27 |      * @param  \Zend\Ldap\Ldap $ldap
28 |      * @return Schema
29 |      */
30 |     public static function create(Ldap\Ldap $ldap)
31 |     {
32 |         $dn   = $ldap->getRootDse()->getSchemaDn();
33 |         $data = $ldap->getEntry($dn, ['*', '+'], true);
34 |         switch ($ldap->getRootDse()->getServerType()) {
35 |             case RootDse::SERVER_TYPE_ACTIVEDIRECTORY:
36 |                 return new Schema\ActiveDirectory($dn, $data, $ldap);
37 |             case RootDse::SERVER_TYPE_OPENLDAP:
38 |                 return new Schema\OpenLdap($dn, $data, $ldap);
39 |             case RootDse::SERVER_TYPE_EDIRECTORY:
40 |             default:
41 |                 return new static($dn, $data, $ldap);
42 |         }
43 |     }
44 | 
45 |     /**
46 |      * Constructor.
47 |      *
48 |      * Constructor is protected to enforce the use of factory methods.
49 |      *
50 |      * @param  \Zend\Ldap\Dn   $dn
51 |      * @param  array           $data
52 |      * @param  \Zend\Ldap\Ldap $ldap
53 |      */
54 |     protected function __construct(Ldap\Dn $dn, array $data, Ldap\Ldap $ldap)
55 |     {
56 |         parent::__construct($dn, $data, true);
57 |         $this->parseSchema($dn, $ldap);
58 |     }
59 | 
60 |     /**
61 |      * Parses the schema
62 |      *
63 |      * @param  \Zend\Ldap\Dn   $dn
64 |      * @param  \Zend\Ldap\Ldap $ldap
65 |      * @return Schema Provides a fluid interface
66 |      */
67 |     protected function parseSchema(Ldap\Dn $dn, Ldap\Ldap $ldap)
68 |     {
69 |         return $this;
70 |     }
71 | 
72 |     /**
73 |      * Gets the attribute Types
74 |      *
75 |      * @return array
76 |      */
77 |     public function getAttributeTypes()
78 |     {
79 |         return [];
80 |     }
81 | 
82 |     /**
83 |      * Gets the object classes
84 |      *
85 |      * @return array
86 |      */
87 |     public function getObjectClasses()
88 |     {
89 |         return [];
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/src/Node/Schema/AbstractItem.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-2015 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\Node\Schema;
 11 | 
 12 | use ArrayAccess;
 13 | use Countable;
 14 | use Zend\Ldap\Exception;
 15 | 
 16 | /**
 17 |  * This class provides a base implementation for managing schema
 18 |  * items like objectClass and attributeType.
 19 |  */
 20 | abstract class AbstractItem implements ArrayAccess, Countable
 21 | {
 22 |     /**
 23 |      * The underlying data
 24 |      *
 25 |      * @var array
 26 |      */
 27 |     protected $data;
 28 | 
 29 |     /**
 30 |      * Constructor.
 31 |      *
 32 |      * @param array $data
 33 |      */
 34 |     public function __construct(array $data)
 35 |     {
 36 |         $this->setData($data);
 37 |     }
 38 | 
 39 |     /**
 40 |      * Sets the data
 41 |      *
 42 |      * @param  array $data
 43 |      * @return AbstractItem Provides a fluid interface
 44 |      */
 45 |     public function setData(array $data)
 46 |     {
 47 |         $this->data = $data;
 48 |         return $this;
 49 |     }
 50 | 
 51 |     /**
 52 |      * Gets the data
 53 |      *
 54 |      * @return array
 55 |      */
 56 |     public function getData()
 57 |     {
 58 |         return $this->data;
 59 |     }
 60 | 
 61 |     /**
 62 |      * Gets a specific attribute from this item
 63 |      *
 64 |      * @param  string $name
 65 |      * @return mixed
 66 |      */
 67 |     public function __get($name)
 68 |     {
 69 |         if (array_key_exists($name, $this->data)) {
 70 |             return $this->data[$name];
 71 |         }
 72 | 
 73 |         return;
 74 |     }
 75 | 
 76 |     /**
 77 |      * Checks whether a specific attribute exists.
 78 |      *
 79 |      * @param  string $name
 80 |      * @return bool
 81 |      */
 82 |     public function __isset($name)
 83 |     {
 84 |         return (array_key_exists($name, $this->data));
 85 |     }
 86 | 
 87 |     /**
 88 |      * Always throws Zend\Ldap\Exception\BadMethodCallException
 89 |      * Implements ArrayAccess.
 90 |      *
 91 |      * This method is needed for a full implementation of ArrayAccess
 92 |      *
 93 |      * @param  string $name
 94 |      * @param  mixed  $value
 95 |      * @throws \Zend\Ldap\Exception\BadMethodCallException
 96 |      */
 97 |     public function offsetSet($name, $value)
 98 |     {
 99 |         throw new Exception\BadMethodCallException();
100 |     }
101 | 
102 |     /**
103 |      * Gets a specific attribute from this item
104 |      *
105 |      * @param  string $name
106 |      * @return mixed
107 |      */
108 |     public function offsetGet($name)
109 |     {
110 |         return $this->__get($name);
111 |     }
112 | 
113 |     /**
114 |      * Always throws Zend\Ldap\Exception\BadMethodCallException
115 |      * Implements ArrayAccess.
116 |      *
117 |      * This method is needed for a full implementation of ArrayAccess
118 |      *
119 |      * @param  string $name
120 |      * @throws \Zend\Ldap\Exception\BadMethodCallException
121 |      */
122 |     public function offsetUnset($name)
123 |     {
124 |         throw new Exception\BadMethodCallException();
125 |     }
126 | 
127 |     /**
128 |      * Checks whether a specific attribute exists.
129 |      *
130 |      * @param  string $name
131 |      * @return bool
132 |      */
133 |     public function offsetExists($name)
134 |     {
135 |         return $this->__isset($name);
136 |     }
137 | 
138 |     /**
139 |      * Returns the number of attributes.
140 |      * Implements Countable
141 |      *
142 |      * @return int
143 |      */
144 |     public function count()
145 |     {
146 |         return count($this->data);
147 |     }
148 | }
149 | 


--------------------------------------------------------------------------------
/src/Node/Schema/ActiveDirectory.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-2015 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\Node\Schema;
11 | 
12 | use Zend\Ldap;
13 | use Zend\Ldap\Node;
14 | 
15 | /**
16 |  * Zend\Ldap\Node\Schema\ActiveDirectory provides a simple data-container for the Schema node of
17 |  * an Active Directory server.
18 |  */
19 | class ActiveDirectory extends Node\Schema
20 | {
21 |     /**
22 |      * The attribute Types
23 |      *
24 |      * @var array
25 |      */
26 |     protected $attributeTypes = [];
27 |     /**
28 |      * The object classes
29 |      *
30 |      * @var array
31 |      */
32 |     protected $objectClasses = [];
33 | 
34 |     /**
35 |      * Parses the schema
36 |      *
37 |      * @param \Zend\Ldap\Dn   $dn
38 |      * @param \Zend\Ldap\Ldap $ldap
39 |      * @return ActiveDirectory Provides a fluid interface
40 |      */
41 |     protected function parseSchema(Ldap\Dn $dn, Ldap\Ldap $ldap)
42 |     {
43 |         parent::parseSchema($dn, $ldap);
44 |         foreach ($ldap->search(
45 |             '(objectClass=classSchema)',
46 |             $dn,
47 |             Ldap\Ldap::SEARCH_SCOPE_ONE
48 |         ) as $node) {
49 |             $val                                  = new ObjectClass\ActiveDirectory($node);
50 |             $this->objectClasses[$val->getName()] = $val;
51 |         }
52 |         foreach ($ldap->search(
53 |             '(objectClass=attributeSchema)',
54 |             $dn,
55 |             Ldap\Ldap::SEARCH_SCOPE_ONE
56 |         ) as $node) {
57 |             $val                                   = new AttributeType\ActiveDirectory($node);
58 |             $this->attributeTypes[$val->getName()] = $val;
59 |         }
60 | 
61 |         return $this;
62 |     }
63 | 
64 |     /**
65 |      * Gets the attribute Types
66 |      *
67 |      * @return array
68 |      */
69 |     public function getAttributeTypes()
70 |     {
71 |         return $this->attributeTypes;
72 |     }
73 | 
74 |     /**
75 |      * Gets the object classes
76 |      *
77 |      * @return array
78 |      */
79 |     public function getObjectClasses()
80 |     {
81 |         return $this->objectClasses;
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/Node/Schema/AttributeType/ActiveDirectory.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-2015 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\Node\Schema\AttributeType;
11 | 
12 | use Zend\Ldap\Node\Schema;
13 | 
14 | /**
15 |  * Zend\Ldap\Node\Schema\AttributeType\ActiveDirectory provides access to the attribute type
16 |  * schema information on an Active Directory server.
17 |  */
18 | class ActiveDirectory extends Schema\AbstractItem implements AttributeTypeInterface
19 | {
20 |     /**
21 |      * Gets the attribute name
22 |      *
23 |      * @return string
24 |      */
25 |     public function getName()
26 |     {
27 |         return $this->ldapdisplayname[0];
28 |     }
29 | 
30 |     /**
31 |      * Gets the attribute OID
32 |      *
33 |      * @return string
34 |      */
35 |     public function getOid()
36 |     {
37 |     }
38 | 
39 |     /**
40 |      * Gets the attribute syntax
41 |      *
42 |      * @return string
43 |      */
44 |     public function getSyntax()
45 |     {
46 |     }
47 | 
48 |     /**
49 |      * Gets the attribute maximum length
50 |      *
51 |      * @return int|null
52 |      */
53 |     public function getMaxLength()
54 |     {
55 |     }
56 | 
57 |     /**
58 |      * Returns if the attribute is single-valued.
59 |      *
60 |      * @return bool
61 |      */
62 |     public function isSingleValued()
63 |     {
64 |     }
65 | 
66 |     /**
67 |      * Gets the attribute description
68 |      *
69 |      * @return string
70 |      */
71 |     public function getDescription()
72 |     {
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Node/Schema/AttributeType/AttributeTypeInterface.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-2015 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\Node\Schema\AttributeType;
11 | 
12 | /**
13 |  * This class provides a contract for schema attribute-types.
14 |  */
15 | interface AttributeTypeInterface
16 | {
17 |     /**
18 |      * Gets the attribute name
19 |      *
20 |      * @return string
21 |      */
22 |     public function getName();
23 | 
24 |     /**
25 |      * Gets the attribute OID
26 |      *
27 |      * @return string
28 |      */
29 |     public function getOid();
30 | 
31 |     /**
32 |      * Gets the attribute syntax
33 |      *
34 |      * @return string
35 |      */
36 |     public function getSyntax();
37 | 
38 |     /**
39 |      * Gets the attribute maximum length
40 |      *
41 |      * @return int|null
42 |      */
43 |     public function getMaxLength();
44 | 
45 |     /**
46 |      * Returns if the attribute is single-valued.
47 |      *
48 |      * @return bool
49 |      */
50 |     public function isSingleValued();
51 | 
52 |     /**
53 |      * Gets the attribute description
54 |      *
55 |      * @return string
56 |      */
57 |     public function getDescription();
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Node/Schema/AttributeType/OpenLdap.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-2015 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\Node\Schema\AttributeType;
 11 | 
 12 | use Zend\Ldap\Node\Schema;
 13 | 
 14 | /**
 15 |  * Zend\Ldap\Node\Schema\AttributeType\OpenLdap provides access to the attribute type
 16 |  * schema information on an OpenLDAP server.
 17 |  */
 18 | class OpenLdap extends Schema\AbstractItem implements AttributeTypeInterface
 19 | {
 20 |     /**
 21 |      * Gets the attribute name
 22 |      *
 23 |      * @return string
 24 |      */
 25 |     public function getName()
 26 |     {
 27 |         return $this->name;
 28 |     }
 29 | 
 30 |     /**
 31 |      * Gets the attribute OID
 32 |      *
 33 |      * @return string
 34 |      */
 35 |     public function getOid()
 36 |     {
 37 |         return $this->oid;
 38 |     }
 39 | 
 40 |     /**
 41 |      * Gets the attribute syntax
 42 |      *
 43 |      * @return string
 44 |      */
 45 |     public function getSyntax()
 46 |     {
 47 |         if ($this->syntax === null) {
 48 |             $parent = $this->getParent();
 49 |             if ($parent === null) {
 50 |                 return;
 51 |             } else {
 52 |                 return $parent->getSyntax();
 53 |             }
 54 |         }
 55 | 
 56 |         return $this->syntax;
 57 |     }
 58 | 
 59 |     /**
 60 |      * Gets the attribute maximum length
 61 |      *
 62 |      * @return int|null
 63 |      */
 64 |     public function getMaxLength()
 65 |     {
 66 |         $maxLength = $this->{'max-length'};
 67 |         if ($maxLength === null) {
 68 |             $parent = $this->getParent();
 69 |             if ($parent === null) {
 70 |                 return;
 71 |             } else {
 72 |                 return $parent->getMaxLength();
 73 |             }
 74 |         }
 75 | 
 76 |         return (int) $maxLength;
 77 |     }
 78 | 
 79 |     /**
 80 |      * Returns if the attribute is single-valued.
 81 |      *
 82 |      * @return bool
 83 |      */
 84 |     public function isSingleValued()
 85 |     {
 86 |         return $this->{'single-value'};
 87 |     }
 88 | 
 89 |     /**
 90 |      * Gets the attribute description
 91 |      *
 92 |      * @return string
 93 |      */
 94 |     public function getDescription()
 95 |     {
 96 |         return $this->desc;
 97 |     }
 98 | 
 99 |     /**
100 |      * Returns the parent attribute type in the inheritance tree if one exists
101 |      *
102 |      * @return OpenLdap|null
103 |      */
104 |     public function getParent()
105 |     {
106 |         if (count($this->_parents) === 1) {
107 |             return $this->_parents[0];
108 |         }
109 | 
110 |         return;
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/src/Node/Schema/ObjectClass/ActiveDirectory.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-2015 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\Node\Schema\ObjectClass;
11 | 
12 | use Zend\Ldap\Node\Schema;
13 | 
14 | /**
15 |  * Zend\Ldap\Node\Schema\ObjectClass\ActiveDirectory provides access to the objectClass
16 |  * schema information on an Active Directory server.
17 |  */
18 | class ActiveDirectory extends Schema\AbstractItem implements ObjectClassInterface
19 | {
20 |     /**
21 |      * Gets the objectClass name
22 |      *
23 |      * @return string
24 |      */
25 |     public function getName()
26 |     {
27 |         return $this->ldapdisplayname[0];
28 |     }
29 | 
30 |     /**
31 |      * Gets the objectClass OID
32 |      *
33 |      * @return string
34 |      */
35 |     public function getOid()
36 |     {
37 |     }
38 | 
39 |     /**
40 |      * Gets the attributes that this objectClass must contain
41 |      *
42 |      * @return array
43 |      */
44 |     public function getMustContain()
45 |     {
46 |     }
47 | 
48 |     /**
49 |      * Gets the attributes that this objectClass may contain
50 |      *
51 |      * @return array
52 |      */
53 |     public function getMayContain()
54 |     {
55 |     }
56 | 
57 |     /**
58 |      * Gets the objectClass description
59 |      *
60 |      * @return string
61 |      */
62 |     public function getDescription()
63 |     {
64 |     }
65 | 
66 |     /**
67 |      * Gets the objectClass type
68 |      *
69 |      * @return int
70 |      */
71 |     public function getType()
72 |     {
73 |     }
74 | 
75 |     /**
76 |      * Returns the parent objectClasses of this class.
77 |      * This includes structural, abstract and auxiliary objectClasses
78 |      *
79 |      * @return array
80 |      */
81 |     public function getParentClasses()
82 |     {
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/src/Node/Schema/ObjectClass/ObjectClassInterface.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-2015 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\Node\Schema\ObjectClass;
11 | 
12 | /**
13 |  * This class provides a contract for schema objectClasses.
14 |  */
15 | interface ObjectClassInterface
16 | {
17 |     /**
18 |      * Gets the objectClass name
19 |      *
20 |      * @return string
21 |      */
22 |     public function getName();
23 | 
24 |     /**
25 |      * Gets the objectClass OID
26 |      *
27 |      * @return string
28 |      */
29 |     public function getOid();
30 | 
31 |     /**
32 |      * Gets the attributes that this objectClass must contain
33 |      *
34 |      * @return array
35 |      */
36 |     public function getMustContain();
37 | 
38 |     /**
39 |      * Gets the attributes that this objectClass may contain
40 |      *
41 |      * @return array
42 |      */
43 |     public function getMayContain();
44 | 
45 |     /**
46 |      * Gets the objectClass description
47 |      *
48 |      * @return string
49 |      */
50 |     public function getDescription();
51 | 
52 |     /**
53 |      * Gets the objectClass type
54 |      *
55 |      * @return int
56 |      */
57 |     public function getType();
58 | 
59 |     /**
60 |      * Returns the parent objectClasses of this class.
61 |      * This includes structural, abstract and auxiliary objectClasses
62 |      *
63 |      * @return array
64 |      */
65 |     public function getParentClasses();
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Node/Schema/ObjectClass/OpenLdap.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-2015 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\Node\Schema\ObjectClass;
 11 | 
 12 | use Zend\Ldap\Node\Schema;
 13 | 
 14 | /**
 15 |  * Zend\Ldap\Node\Schema\ObjectClass\OpenLdap provides access to the objectClass
 16 |  * schema information on an OpenLDAP server.
 17 |  */
 18 | class OpenLdap extends Schema\AbstractItem implements ObjectClassInterface
 19 | {
 20 |     /**
 21 |      * All inherited "MUST" attributes
 22 |      *
 23 |      * @var array
 24 |      */
 25 |     protected $inheritedMust = null;
 26 | 
 27 |     /**
 28 |      * All inherited "MAY" attributes
 29 |      *
 30 |      * @var array
 31 |      */
 32 |     protected $inheritedMay = null;
 33 | 
 34 |     /**
 35 |      * Gets the objectClass name
 36 |      *
 37 |      * @return string
 38 |      */
 39 |     public function getName()
 40 |     {
 41 |         return $this->name;
 42 |     }
 43 | 
 44 |     /**
 45 |      * Gets the objectClass OID
 46 |      *
 47 |      * @return string
 48 |      */
 49 |     public function getOid()
 50 |     {
 51 |         return $this->oid;
 52 |     }
 53 | 
 54 |     /**
 55 |      * Gets the attributes that this objectClass must contain
 56 |      *
 57 |      * @return array
 58 |      */
 59 |     public function getMustContain()
 60 |     {
 61 |         if ($this->inheritedMust === null) {
 62 |             $this->resolveInheritance();
 63 |         }
 64 |         return $this->inheritedMust;
 65 |     }
 66 | 
 67 |     /**
 68 |      * Gets the attributes that this objectClass may contain
 69 |      *
 70 |      * @return array
 71 |      */
 72 |     public function getMayContain()
 73 |     {
 74 |         if ($this->inheritedMay === null) {
 75 |             $this->resolveInheritance();
 76 |         }
 77 |         return $this->inheritedMay;
 78 |     }
 79 | 
 80 |     /**
 81 |      * Resolves the inheritance tree
 82 |      *
 83 |      * @return void
 84 |      */
 85 |     protected function resolveInheritance()
 86 |     {
 87 |         $must = $this->must;
 88 |         $may  = $this->may;
 89 |         foreach ($this->getParents() as $p) {
 90 |             $must = array_merge($must, $p->getMustContain());
 91 |             $may  = array_merge($may, $p->getMayContain());
 92 |         }
 93 |         $must = array_unique($must);
 94 |         $may  = array_unique($may);
 95 |         $may  = array_diff($may, $must);
 96 |         sort($must, SORT_STRING);
 97 |         sort($may, SORT_STRING);
 98 |         $this->inheritedMust = $must;
 99 |         $this->inheritedMay  = $may;
100 |     }
101 | 
102 |     /**
103 |      * Gets the objectClass description
104 |      *
105 |      * @return string
106 |      */
107 |     public function getDescription()
108 |     {
109 |         return $this->desc;
110 |     }
111 | 
112 |     /**
113 |      * Gets the objectClass type
114 |      *
115 |      * @return int
116 |      */
117 |     public function getType()
118 |     {
119 |         if ($this->structural) {
120 |             return Schema::OBJECTCLASS_TYPE_STRUCTURAL;
121 |         } elseif ($this->abstract) {
122 |             return Schema::OBJECTCLASS_TYPE_ABSTRACT;
123 |         } elseif ($this->auxiliary) {
124 |             return Schema::OBJECTCLASS_TYPE_AUXILIARY;
125 |         }
126 | 
127 |         return Schema::OBJECTCLASS_TYPE_UNKNOWN;
128 |     }
129 | 
130 |     /**
131 |      * Returns the parent objectClasses of this class.
132 |      * This includes structural, abstract and auxiliary objectClasses
133 |      *
134 |      * @return array
135 |      */
136 |     public function getParentClasses()
137 |     {
138 |         return $this->sup;
139 |     }
140 | 
141 |     /**
142 |      * Returns the parent object classes in the inheritance tree if one exists
143 |      *
144 |      * @return array of OpenLdap
145 |      */
146 |     public function getParents()
147 |     {
148 |         return $this->_parents;
149 |     }
150 | }
151 | 


--------------------------------------------------------------------------------
/src/Node/Schema/OpenLdap.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-2015 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\Node\Schema;
 11 | 
 12 | use Zend\Ldap;
 13 | use Zend\Ldap\Converter;
 14 | use Zend\Ldap\Node;
 15 | 
 16 | /**
 17 |  * Zend\Ldap\Node\Schema\OpenLDAP provides a simple data-container for the Schema node of
 18 |  * an OpenLDAP server.
 19 |  */
 20 | class OpenLdap extends Node\Schema
 21 | {
 22 |     /**
 23 |      * The attribute Types
 24 |      *
 25 |      * @var array
 26 |      */
 27 |     protected $attributeTypes = null;
 28 | 
 29 |     /**
 30 |      * The object classes
 31 |      *
 32 |      * @var array
 33 |      */
 34 |     protected $objectClasses = null;
 35 | 
 36 |     /**
 37 |      * The LDAP syntaxes
 38 |      *
 39 |      * @var array
 40 |      */
 41 |     protected $ldapSyntaxes = null;
 42 | 
 43 |     /**
 44 |      * The matching rules
 45 |      *
 46 |      * @var array
 47 |      */
 48 |     protected $matchingRules = null;
 49 | 
 50 |     /**
 51 |      * The matching rule use
 52 |      *
 53 |      * @var array
 54 |      */
 55 |     protected $matchingRuleUse = null;
 56 | 
 57 |     /**
 58 |      * Parses the schema
 59 |      *
 60 |      * @param \Zend\Ldap\Dn   $dn
 61 |      * @param \Zend\Ldap\Ldap $ldap
 62 |      * @return OpenLdap Provides a fluid interface
 63 |      */
 64 |     protected function parseSchema(Ldap\Dn $dn, Ldap\Ldap $ldap)
 65 |     {
 66 |         parent::parseSchema($dn, $ldap);
 67 |         $this->loadAttributeTypes();
 68 |         $this->loadLdapSyntaxes();
 69 |         $this->loadMatchingRules();
 70 |         $this->loadMatchingRuleUse();
 71 |         $this->loadObjectClasses();
 72 |         return $this;
 73 |     }
 74 | 
 75 |     /**
 76 |      * Gets the attribute Types
 77 |      *
 78 |      * @return array
 79 |      */
 80 |     public function getAttributeTypes()
 81 |     {
 82 |         return $this->attributeTypes;
 83 |     }
 84 | 
 85 |     /**
 86 |      * Gets the object classes
 87 |      *
 88 |      * @return array
 89 |      */
 90 |     public function getObjectClasses()
 91 |     {
 92 |         return $this->objectClasses;
 93 |     }
 94 | 
 95 |     /**
 96 |      * Gets the LDAP syntaxes
 97 |      *
 98 |      * @return array
 99 |      */
100 |     public function getLdapSyntaxes()
101 |     {
102 |         return $this->ldapSyntaxes;
103 |     }
104 | 
105 |     /**
106 |      * Gets the matching rules
107 |      *
108 |      * @return array
109 |      */
110 |     public function getMatchingRules()
111 |     {
112 |         return $this->matchingRules;
113 |     }
114 | 
115 |     /**
116 |      * Gets the matching rule use
117 |      *
118 |      * @return array
119 |      */
120 |     public function getMatchingRuleUse()
121 |     {
122 |         return $this->matchingRuleUse;
123 |     }
124 | 
125 |     /**
126 |      * Loads the attribute Types
127 |      *
128 |      * @return void
129 |      */
130 |     protected function loadAttributeTypes()
131 |     {
132 |         $this->attributeTypes = [];
133 |         foreach ($this->getAttribute('attributeTypes') as $value) {
134 |             $val                                   = $this->parseAttributeType($value);
135 |             $val                                   = new AttributeType\OpenLdap($val);
136 |             $this->attributeTypes[$val->getName()] = $val;
137 |         }
138 |         foreach ($this->attributeTypes as $val) {
139 |             if (! empty($val->sup) && count($val->sup) > 0) {
140 |                 $this->resolveInheritance($val, $this->attributeTypes);
141 |             }
142 |             foreach ($val->aliases as $alias) {
143 |                 $this->attributeTypes[$alias] = $val;
144 |             }
145 |         }
146 |         ksort($this->attributeTypes, SORT_STRING);
147 |     }
148 | 
149 |     /**
150 |      * Parses an attributeType value
151 |      *
152 |      * @param  string $value
153 |      * @return array
154 |      */
155 |     protected function parseAttributeType($value)
156 |     {
157 |         $attributeType = [
158 |             'oid'                  => null,
159 |             'name'                 => null,
160 |             'desc'                 => null,
161 |             'obsolete'             => false,
162 |             'sup'                  => null,
163 |             'equality'             => null,
164 |             'ordering'             => null,
165 |             'substr'               => null,
166 |             'syntax'               => null,
167 |             'max-length'           => null,
168 |             'single-value'         => false,
169 |             'collective'           => false,
170 |             'no-user-modification' => false,
171 |             'usage'                => 'userApplications',
172 |             '_string'              => $value,
173 |             '_parents'             => []];
174 | 
175 |         $tokens               = $this->tokenizeString($value);
176 |         $attributeType['oid'] = array_shift($tokens); // first token is the oid
177 |         $this->parseLdapSchemaSyntax($attributeType, $tokens);
178 | 
179 |         if (array_key_exists('syntax', $attributeType)) {
180 |             // get max length from syntax
181 |             if (preg_match('/^(.+){(\d+)}$/', $attributeType['syntax'], $matches)) {
182 |                 $attributeType['syntax']     = $matches[1];
183 |                 $attributeType['max-length'] = $matches[2];
184 |             }
185 |         }
186 | 
187 |         $this->ensureNameAttribute($attributeType);
188 | 
189 |         return $attributeType;
190 |     }
191 | 
192 |     /**
193 |      * Loads the object classes
194 |      *
195 |      * @return void
196 |      */
197 |     protected function loadObjectClasses()
198 |     {
199 |         $this->objectClasses = [];
200 |         foreach ($this->getAttribute('objectClasses') as $value) {
201 |             $val                                  = $this->parseObjectClass($value);
202 |             $val                                  = new ObjectClass\OpenLdap($val);
203 |             $this->objectClasses[$val->getName()] = $val;
204 |         }
205 |         foreach ($this->objectClasses as $val) {
206 |             if (count($val->sup) > 0) {
207 |                 $this->resolveInheritance($val, $this->objectClasses);
208 |             }
209 |             foreach ($val->aliases as $alias) {
210 |                 $this->objectClasses[$alias] = $val;
211 |             }
212 |         }
213 |         ksort($this->objectClasses, SORT_STRING);
214 |     }
215 | 
216 |     /**
217 |      * Parses an objectClasses value
218 |      *
219 |      * @param string $value
220 |      * @return array
221 |      */
222 |     protected function parseObjectClass($value)
223 |     {
224 |         $objectClass = [
225 |             'oid'        => null,
226 |             'name'       => null,
227 |             'desc'       => null,
228 |             'obsolete'   => false,
229 |             'sup'        => [],
230 |             'abstract'   => false,
231 |             'structural' => false,
232 |             'auxiliary'  => false,
233 |             'must'       => [],
234 |             'may'        => [],
235 |             '_string'    => $value,
236 |             '_parents'   => []];
237 | 
238 |         $tokens             = $this->tokenizeString($value);
239 |         $objectClass['oid'] = array_shift($tokens); // first token is the oid
240 |         $this->parseLdapSchemaSyntax($objectClass, $tokens);
241 | 
242 |         $this->ensureNameAttribute($objectClass);
243 | 
244 |         return $objectClass;
245 |     }
246 | 
247 |     /**
248 |      * Resolves inheritance in objectClasses and attributes
249 |      *
250 |      * @param AbstractItem $node
251 |      * @param array        $repository
252 |      */
253 |     protected function resolveInheritance(AbstractItem $node, array $repository)
254 |     {
255 |         $data    = $node->getData();
256 |         $parents = $data['sup'];
257 |         if ($parents === null || ! is_array($parents) || count($parents) < 1) {
258 |             return;
259 |         }
260 |         foreach ($parents as $parent) {
261 |             if (! array_key_exists($parent, $repository)) {
262 |                 continue;
263 |             }
264 |             if (! array_key_exists('_parents', $data) || ! is_array($data['_parents'])) {
265 |                 $data['_parents'] = [];
266 |             }
267 |             $data['_parents'][] = $repository[$parent];
268 |         }
269 |         $node->setData($data);
270 |     }
271 | 
272 |     /**
273 |      * Loads the LDAP syntaxes
274 |      *
275 |      * @return void
276 |      */
277 |     protected function loadLdapSyntaxes()
278 |     {
279 |         $this->ldapSyntaxes = [];
280 |         foreach ($this->getAttribute('ldapSyntaxes') as $value) {
281 |             $val                             = $this->parseLdapSyntax($value);
282 |             $this->ldapSyntaxes[$val['oid']] = $val;
283 |         }
284 |         ksort($this->ldapSyntaxes, SORT_STRING);
285 |     }
286 | 
287 |     /**
288 |      * Parses an ldapSyntaxes value
289 |      *
290 |      * @param  string $value
291 |      * @return array
292 |      */
293 |     protected function parseLdapSyntax($value)
294 |     {
295 |         $ldapSyntax = [
296 |             'oid'      => null,
297 |             'desc'     => null,
298 |             '_string'  => $value];
299 | 
300 |         $tokens            = $this->tokenizeString($value);
301 |         $ldapSyntax['oid'] = array_shift($tokens); // first token is the oid
302 |         $this->parseLdapSchemaSyntax($ldapSyntax, $tokens);
303 | 
304 |         return $ldapSyntax;
305 |     }
306 | 
307 |     /**
308 |      * Loads the matching rules
309 |      *
310 |      * @return void
311 |      */
312 |     protected function loadMatchingRules()
313 |     {
314 |         $this->matchingRules = [];
315 |         foreach ($this->getAttribute('matchingRules') as $value) {
316 |             $val                               = $this->parseMatchingRule($value);
317 |             $this->matchingRules[$val['name']] = $val;
318 |         }
319 |         ksort($this->matchingRules, SORT_STRING);
320 |     }
321 | 
322 |     /**
323 |      * Parses a matchingRules value
324 |      *
325 |      * @param  string $value
326 |      * @return array
327 |      */
328 |     protected function parseMatchingRule($value)
329 |     {
330 |         $matchingRule = [
331 |             'oid'      => null,
332 |             'name'     => null,
333 |             'desc'     => null,
334 |             'obsolete' => false,
335 |             'syntax'   => null,
336 |             '_string'  => $value];
337 | 
338 |         $tokens              = $this->tokenizeString($value);
339 |         $matchingRule['oid'] = array_shift($tokens); // first token is the oid
340 |         $this->parseLdapSchemaSyntax($matchingRule, $tokens);
341 | 
342 |         $this->ensureNameAttribute($matchingRule);
343 | 
344 |         return $matchingRule;
345 |     }
346 | 
347 |     /**
348 |      * Loads the matching rule use
349 |      *
350 |      * @return void
351 |      */
352 |     protected function loadMatchingRuleUse()
353 |     {
354 |         $this->matchingRuleUse = [];
355 |         foreach ($this->getAttribute('matchingRuleUse') as $value) {
356 |             $val                                 = $this->parseMatchingRuleUse($value);
357 |             $this->matchingRuleUse[$val['name']] = $val;
358 |         }
359 |         ksort($this->matchingRuleUse, SORT_STRING);
360 |     }
361 | 
362 |     /**
363 |      * Parses a matchingRuleUse value
364 |      *
365 |      * @param  string $value
366 |      * @return array
367 |      */
368 |     protected function parseMatchingRuleUse($value)
369 |     {
370 |         $matchingRuleUse = [
371 |             'oid'      => null,
372 |             'name'     => null,
373 |             'desc'     => null,
374 |             'obsolete' => false,
375 |             'applies'  => [],
376 |             '_string'  => $value];
377 | 
378 |         $tokens                 = $this->tokenizeString($value);
379 |         $matchingRuleUse['oid'] = array_shift($tokens); // first token is the oid
380 |         $this->parseLdapSchemaSyntax($matchingRuleUse, $tokens);
381 | 
382 |         $this->ensureNameAttribute($matchingRuleUse);
383 | 
384 |         return $matchingRuleUse;
385 |     }
386 | 
387 |     /**
388 |      * Ensures that a name element is present and that it is single-values.
389 |      *
390 |      * @param array $data
391 |      */
392 |     protected function ensureNameAttribute(array &$data)
393 |     {
394 |         if (! array_key_exists('name', $data) || empty($data['name'])) {
395 |             // force a name
396 |             $data['name'] = $data['oid'];
397 |         }
398 |         if (is_array($data['name'])) {
399 |             // make one name the default and put the other ones into aliases
400 |             $aliases         = $data['name'];
401 |             $data['name']    = array_shift($aliases);
402 |             $data['aliases'] = $aliases;
403 |         } else {
404 |             $data['aliases'] = [];
405 |         }
406 |     }
407 | 
408 |     /**
409 |      * Parse the given tokens into a data structure
410 |      *
411 |      * @param  array $data
412 |      * @param  array $tokens
413 |      * @return void
414 |      */
415 |     protected function parseLdapSchemaSyntax(array &$data, array $tokens)
416 |     {
417 |         // tokens that have no value associated
418 |         $noValue = ['single-value',
419 |                          'obsolete',
420 |                          'collective',
421 |                          'no-user-modification',
422 |                          'abstract',
423 |                          'structural',
424 |                          'auxiliary'];
425 |         // tokens that can have multiple values
426 |         $multiValue = ['must', 'may', 'sup'];
427 | 
428 |         while (count($tokens) > 0) {
429 |             $token = strtolower(array_shift($tokens));
430 |             if (in_array($token, $noValue)) {
431 |                 $data[$token] = true; // single value token
432 |             } else {
433 |                 $data[$token] = array_shift($tokens);
434 |                 // this one follows a string or a list if it is multivalued
435 |                 if ($data[$token] == '(') {
436 |                     // this creates the list of values and cycles through the tokens
437 |                     // until the end of the list is reached ')'
438 |                     $data[$token] = [];
439 | 
440 |                     $tmp = array_shift($tokens);
441 |                     while ($tmp) {
442 |                         if ($tmp == ')') {
443 |                             break;
444 |                         }
445 |                         if ($tmp != '$') {
446 |                             $data[$token][] = Converter\Converter::fromLdap($tmp);
447 |                         }
448 |                         $tmp = array_shift($tokens);
449 |                     }
450 |                 } else {
451 |                     $data[$token] = Converter\Converter::fromLdap($data[$token]);
452 |                 }
453 |                 // create an array if the value should be multivalued but was not
454 |                 if (in_array($token, $multiValue) && ! is_array($data[$token])) {
455 |                     $data[$token] = [$data[$token]];
456 |                 }
457 |             }
458 |         }
459 |     }
460 | 
461 |     /**
462 |      * Tokenizes the given value into an array
463 |      *
464 |      * @param  string $value
465 |      * @return array tokens
466 |      */
467 |     protected function tokenizeString($value)
468 |     {
469 |         $tokens  = [];
470 |         $matches = [];
471 |         // this one is taken from PEAR::Net_LDAP2
472 |         $pattern = "/\\s* (?:([()]) | ([^'\\s()]+) | '((?:[^']+|'[^\\s)])*)') \\s*/x";
473 |         preg_match_all($pattern, $value, $matches);
474 |         $cMatches = count($matches[0]);
475 |         $cPattern = count($matches);
476 |         for ($i = 0; $i < $cMatches; $i++) { // number of tokens (full pattern match)
477 |             for ($j = 1; $j < $cPattern; $j++) { // each subpattern
478 |                 $tok = trim($matches[$j][$i]);
479 |                 if (! empty($tok)) { // pattern match in this subpattern
480 |                     $tokens[$i] = $tok; // this is the token
481 |                 }
482 |             }
483 |         }
484 |         if ($tokens[0] == '(') {
485 |             array_shift($tokens);
486 |         }
487 |         if ($tokens[count($tokens) - 1] == ')') {
488 |             array_pop($tokens);
489 |         }
490 | 
491 |         return $tokens;
492 |     }
493 | }
494 | 


--------------------------------------------------------------------------------