vendor/adldap2/adldap2/src/Connections/Ldap.php

   1 <?php
   2
   3 namespace Adldap\Connections;
   4
   5 use Adldap\AdldapException;
   6
   7 /**
   8  * Class Ldap
   9  *
  10  * A class that abstracts PHP's LDAP functions and stores the bound connection.
  11  *
  12  * @package Adldap\Connections
  13  */
  14 class Ldap implements ConnectionInterface
  15 {
  16     use LdapFunctionSupportTrait;
  17
  18     /**
  19      * The active LDAP connection.
  20      *
  21      * @var resource
  22      */
  23     protected $connection;
  24
  25     /**
  26      * Stores the bool whether or not
  27      * the current connection is bound.
  28      *
  29      * @var bool
  30      */
  31     protected $bound = false;
  32
  33     /**
  34      * Stores the bool to tell the connection
  35      * whether or not to use SSL.
  36      *
  37      * To use SSL, your server must support LDAP over SSL.
  38      * http://adldap.sourceforge.net/wiki/doku.php?id=ldap_over_ssl
  39      *
  40      * @var bool
  41      */
  42     protected $useSSL = false;
  43
  44     /**
  45      * Stores the bool to tell the connection
  46      * whether or not to use TLS.
  47      *
  48      * If you wish to use TLS you should ensure that $useSSL is set to false and vice-versa
  49      *
  50      * @var bool
  51      */
  52     protected $useTLS = false;
  53
  54     /**
  55      * {@inheritdoc}
  56      */
  57     public function isUsingSSL()
  58     {
  59         return $this->useSSL;
  60     }
  61
  62     /**
  63      * {@inheritdoc}
  64      */
  65     public function isUsingTLS()
  66     {
  67         return $this->useTLS;
  68     }
  69
  70     /**
  71      * {@inheritdoc}
  72      */
  73     public function isBound()
  74     {
  75         return $this->bound;
  76     }
  77
  78     /**
  79      * {@inheritdoc}
  80      */
  81     public function canChangePasswords()
  82     {
  83         return $this->isUsingSSL() || $this->isUsingTLS();
  84     }
  85
  86     /**
  87      * {@inheritdoc}
  88      */
  89     public function ssl($enabled = true)
  90     {
  91         $this->useSSL = $enabled;
  92
  93         return $this;
  94     }
  95
  96     /**
  97      * {@inheritdoc}
  98      */
  99     public function tls($enabled = true)
 100     {
 101         $this->useTLS = $enabled;
 102
 103         return $this;
 104     }
 105
 106     /**
 107      * {@inheritdoc}
 108      */
 109     public function getConnection()
 110     {
 111         return $this->connection;
 112     }
 113
 114     /**
 115      * {@inheritdoc}
 116      */
 117     public function getEntries($searchResults)
 118     {
 119         return ldap_get_entries($this->getConnection(), $searchResults);
 120     }
 121
 122     /**
 123      * {@inheritdoc}
 124      */
 125     public function getFirstEntry($searchResults)
 126     {
 127         return ldap_first_entry($this->getConnection(), $searchResults);
 128     }
 129
 130     /**
 131      * {@inheritdoc}
 132      */
 133     public function getNextEntry($entry)
 134     {
 135         return ldap_next_entry($this->getConnection(), $entry);
 136     }
 137
 138     /**
 139      * {@inheritdoc}
 140      */
 141     public function getAttributes($entry)
 142     {
 143         return ldap_get_attributes($this->getConnection(), $entry);
 144     }
 145
 146     /**
 147      * {@inheritdoc}
 148      */
 149     public function countEntries($searchResults)
 150     {
 151         return ldap_count_entries($this->getConnection(), $searchResults);
 152     }
 153
 154     /**
 155      * {@inheritdoc}
 156      */
 157     public function compare($dn, $attribute, $value)
 158     {
 159         return ldap_compare($this->getConnection(), $dn, $attribute, $value);
 160     }
 161
 162     /**
 163      * {@inheritdoc}
 164      */
 165     public function getLastError()
 166     {
 167         return ldap_error($this->getConnection());
 168     }
 169
 170     /**
 171      * {@inheritdoc}
 172      */
 173     public function getValuesLen($entry, $attribute)
 174     {
 175         return ldap_get_values_len($this->getConnection(), $entry, $attribute);
 176     }
 177
 178     /**
 179      * {@inheritdoc}
 180      */
 181     public function setOption($option, $value)
 182     {
 183         return ldap_set_option($this->getConnection(), $option, $value);
 184     }
 185
 186     /**
 187      * {@inheritdoc}
 188      */
 189     public function setOptions(array $options = [])
 190     {
 191         foreach ($options as $option => $value) {
 192             $this->setOption($option, $value);
 193         }
 194     }
 195
 196     /**
 197      * {@inheritdoc}
 198      */
 199     public function setRebindCallback(callable $callback)
 200     {
 201         return ldap_set_rebind_proc($this->getConnection(), $callback);
 202     }
 203
 204     /**
 205      * {@inheritdoc}
 206      */
 207     public function startTLS()
 208     {
 209         return ldap_start_tls($this->getConnection());
 210     }
 211
 212     /**
 213      * {@inheritdoc}
 214      */
 215     public function connect($hosts = [], $port = '389')
 216     {
 217         $connections = $this->getConnectionString($hosts, $this->getProtocol(), $port);
 218
 219         return $this->connection = ldap_connect($connections);
 220     }
 221
 222     /**
 223      * {@inheritdoc}
 224      */
 225     public function close()
 226     {
 227         $connection = $this->getConnection();
 228
 229         return is_resource($connection) ? ldap_close($connection) : false;
 230     }
 231
 232     /**
 233      * {@inheritdoc}
 234      */
 235     public function search($dn, $filter, array $fields, $onlyAttributes = false, $size = 0, $time = 0)
 236     {
 237         return ldap_search($this->getConnection(), $dn, $filter, $fields, $onlyAttributes, $size, $time);
 238     }
 239
 240     /**
 241      * {@inheritdoc}
 242      */
 243     public function listing($dn, $filter, array $fields, $onlyAttributes = false, $size = 0, $time = 0)
 244     {
 245         return ldap_list($this->getConnection(), $dn, $filter, $fields, $onlyAttributes, $size, $time);
 246     }
 247
 248     /**
 249      * {@inheritdoc}
 250      */
 251     public function read($dn, $filter, array $fields, $onlyAttributes = false, $size = 0, $time = 0)
 252     {
 253         return ldap_read($this->getConnection(), $dn, $filter, $fields, $onlyAttributes, $size, $time);
 254     }
 255
 256     /**
 257      * {@inheritdoc}
 258      */
 259     public function bind($username, $password, $sasl = false)
 260     {
 261         if ($this->isUsingTLS()) {
 262             $this->startTLS();
 263         }
 264
 265         if ($sasl) {
 266             return $this->bound = ldap_sasl_bind($this->getConnection(), null, null, 'GSSAPI');
 267         }
 268
 269         return $this->bound = ldap_bind($this->getConnection(), $username, $password);
 270     }
 271
 272     /**
 273      * {@inheritdoc}
 274      */
 275     public function add($dn, array $entry)
 276     {
 277         return ldap_add($this->getConnection(), $dn, $entry);
 278     }
 279
 280     /**
 281      * {@inheritdoc}
 282      */
 283     public function delete($dn)
 284     {
 285         return ldap_delete($this->getConnection(), $dn);
 286     }
 287
 288     /**
 289      * {@inheritdoc}
 290      */
 291     public function rename($dn, $newRdn, $newParent, $deleteOldRdn = false)
 292     {
 293         return ldap_rename($this->getConnection(), $dn, $newRdn, $newParent, $deleteOldRdn);
 294     }
 295
 296     /**
 297      * {@inheritdoc}
 298      */
 299     public function modify($dn, array $entry)
 300     {
 301         return ldap_modify($this->getConnection(), $dn, $entry);
 302     }
 303
 304     /**
 305      * {@inheritdoc}
 306      */
 307     public function modifyBatch($dn, array $values)
 308     {
 309         return ldap_modify_batch($this->getConnection(), $dn, $values);
 310     }
 311
 312     /**
 313      * {@inheritdoc}
 314      */
 315     public function modAdd($dn, array $entry)
 316     {
 317         return ldap_mod_add($this->getConnection(), $dn, $entry);
 318     }
 319
 320     /**
 321      * {@inheritdoc}
 322      */
 323     public function modReplace($dn, array $entry)
 324     {
 325         return ldap_mod_replace($this->getConnection(), $dn, $entry);
 326     }
 327
 328     /**
 329      * {@inheritdoc}
 330      */
 331     public function modDelete($dn, array $entry)
 332     {
 333         return ldap_mod_del($this->getConnection(), $dn, $entry);
 334     }
 335
 336     /**
 337      * {@inheritdoc}
 338      */
 339     public function controlPagedResult($pageSize = 1000, $isCritical = false, $cookie = '')
 340     {
 341         if ($this->isPagingSupported()) {
 342             return ldap_control_paged_result($this->getConnection(), $pageSize, $isCritical, $cookie);
 343         }
 344
 345         throw new AdldapException(
 346             'LDAP Pagination is not supported on your current PHP installation.'
 347         );
 348     }
 349
 350     /**
 351      * {@inheritdoc}
 352      */
 353     public function controlPagedResultResponse($result, &$cookie)
 354     {
 355         if ($this->isPagingSupported()) {
 356             return ldap_control_paged_result_response($this->getConnection(), $result, $cookie);
 357         }
 358
 359         throw new AdldapException(
 360             'LDAP Pagination is not supported on your current PHP installation.'
 361         );
 362     }
 363
 364     /**
 365      * {@inheritdoc}
 366      */
 367     public function errNo()
 368     {
 369         return ldap_errno($this->getConnection());
 370     }
 371
 372     /**
 373      * {@inheritdoc}
 374      */
 375     public function getExtendedError()
 376     {
 377         return $this->getDiagnosticMessage();
 378     }
 379
 380     /**
 381      * {@inheritdoc}
 382      */
 383     public function getExtendedErrorHex()
 384     {
 385         if (preg_match("/(?<=data\s).*?(?=\,)/", $this->getExtendedError(), $code)) {
 386             return $code[0];
 387         }
 388     }
 389
 390     /**
 391      * {@inheritdoc}
 392      */
 393     public function getExtendedErrorCode()
 394     {
 395         return $this->extractDiagnosticCode($this->getExtendedError());
 396     }
 397
 398     /**
 399      * {@inheritdoc}
 400      */
 401     public function err2Str($number)
 402     {
 403         return ldap_err2str($number);
 404     }
 405
 406     /**
 407      * {@inheritdoc}
 408      */
 409     public function getDiagnosticMessage()
 410     {
 411         ldap_get_option($this->getConnection(), LDAP_OPT_ERROR_STRING, $diagnosticMessage);
 412
 413         return $diagnosticMessage;
 414     }
 415
 416     /**
 417      * {@inheritdoc}
 418      */
 419     public function extractDiagnosticCode($message)
 420     {
 421         preg_match('/^([\da-fA-F]+):/', $message, $matches);
 422
 423         return isset($matches[1]) ? $matches[1] : false;
 424     }
 425
 426     /**
 427      * Returns the LDAP protocol to utilize for the current connection.
 428      *
 429      * @return string
 430      */
 431     public function getProtocol()
 432     {
 433         return $this->isUsingSSL() ? $this::PROTOCOL_SSL : $this::PROTOCOL;
 434     }
 435
 436     /**
 437      * Generates an LDAP connection string for each host given.
 438      *
 439      * @param string|array  $hosts
 440      * @param string        $protocol
 441      * @param string        $port
 442      *
 443      * @return string
 444      */
 445     protected function getConnectionString($hosts = [], $protocol, $port)
 446     {
 447         // Normalize hosts into an array.
 448         $hosts = is_array($hosts) ? $hosts : [$hosts];
 449
 450         $hosts = array_map(function ($host) use ($protocol, $port) {
 451             return "{$protocol}{$host}:{$port}";
 452         }, $hosts);
 453
 454         return implode(' ', $hosts);
 455     }
 456 }