PHP Net_LDAP2::isError方法代码示例

/**
 * LDAP Password Driver
 *
 * Driver for passwords stored in LDAP
 * This driver use the PEAR Net_LDAP2 class (http://pear.php.net/package/Net_LDAP2).
 *
 * @version 1.0 (2009-06-24)
 * @author Edouard MOREAU <edouard.moreau@ensma.fr>
 *
 * function hashPassword based on code from the phpLDAPadmin development team (http://phpldapadmin.sourceforge.net/).
 * function randomSalt based on code from the phpLDAPadmin development team (http://phpldapadmin.sourceforge.net/).
 *
 */
function password_save($curpass, $passwd)
{
    $rcmail = rcmail::get_instance();
    require_once 'Net/LDAP2.php';
    // Building user DN
    $userDN = str_replace('%login', $_SESSION['username'], $rcmail->config->get('password_ldap_userDN_mask'));
    $parts = explode('@', $_SESSION['username']);
    if (count($parts) == 2) {
        $userDN = str_replace('%name', $parts[0], $userDN);
        $userDN = str_replace('%domain', $parts[1], $userDN);
    }
    if (empty($userDN)) {
        return PASSWORD_CONNECT_ERROR;
    }
    // Connection Method
    switch ($rcmail->config->get('password_ldap_method')) {
        case 'user':
            $binddn = $userDN;
            $bindpw = $curpass;
            break;
        case 'admin':
            $binddn = $rcmail->config->get('password_ldap_adminDN');
            $bindpw = $rcmail->config->get('password_ldap_adminPW');
            break;
        default:
            $binddn = $userDN;
            $bindpw = $curpass;
            break;
            // default is user mode
    }
    // Configuration array
    $ldapConfig = array('binddn' => $binddn, 'bindpw' => $bindpw, 'basedn' => $rcmail->config->get('password_ldap_basedn'), 'host' => $rcmail->config->get('password_ldap_host'), 'port' => $rcmail->config->get('password_ldap_port'), 'starttls' => $rcmail->config->get('password_ldap_starttls'), 'version' => $rcmail->config->get('password_ldap_version'));
    // Connecting using the configuration array
    $ldap = Net_LDAP2::connect($ldapConfig);
    // Checking for connection error
    if (PEAR::isError($ldap)) {
        return PASSWORD_CONNECT_ERROR;
    }
    // Crypting new password
    $newCryptedPassword = hashPassword($passwd, $rcmail->config->get('password_ldap_encodage'));
    if (!$newCryptedPassword) {
        return PASSWORD_CRYPT_ERROR;
    }
    // Writing new crypted password to LDAP
    $userEntry = $ldap->getEntry($userDN);
    if (Net_LDAP2::isError($userEntry)) {
        return PASSWORD_CONNECT_ERROR;
    }
    if (!$userEntry->replace(array($rcmail->config->get('password_ldap_pwattr') => $newCryptedPassword), $rcmail->config->get('password_ldap_force_replace'))) {
        return PASSWORD_CONNECT_ERROR;
    }
    if (Net_LDAP2::isError($userEntry->update())) {
        return PASSWORD_CONNECT_ERROR;
    }
    // All done, no error
    return PASSWORD_SUCCESS;
}

/**
 * LDAP Password Driver
 *
 * Driver for passwords stored in LDAP
 * This driver use the PEAR Net_LDAP2 class (http://pear.php.net/package/Net_LDAP2).
 *
 * @version 1.1 (2010-04-07)
 * @author Edouard MOREAU <edouard.moreau@ensma.fr>
 *
 * function hashPassword based on code from the phpLDAPadmin development team (http://phpldapadmin.sourceforge.net/).
 * function randomSalt based on code from the phpLDAPadmin development team (http://phpldapadmin.sourceforge.net/).
 *
 */
function password_save($curpass, $passwd)
{
    $rcmail = rcmail::get_instance();
    require_once 'Net/LDAP2.php';
    // Building user DN
    if ($userDN = $rcmail->config->get('password_ldap_userDN_mask')) {
        $userDN = substitute_vars($userDN);
    } else {
        $userDN = search_userdn($rcmail);
    }
    if (empty($userDN)) {
        return PASSWORD_CONNECT_ERROR;
    }
    // Connection Method
    switch ($rcmail->config->get('password_ldap_method')) {
        case 'admin':
            $binddn = $rcmail->config->get('password_ldap_adminDN');
            $bindpw = $rcmail->config->get('password_ldap_adminPW');
            break;
        case 'user':
        default:
            $binddn = $userDN;
            $bindpw = $curpass;
            break;
    }
    // Configuration array
    $ldapConfig = array('binddn' => $binddn, 'bindpw' => $bindpw, 'basedn' => $rcmail->config->get('password_ldap_basedn'), 'host' => $rcmail->config->get('password_ldap_host'), 'port' => $rcmail->config->get('password_ldap_port'), 'starttls' => $rcmail->config->get('password_ldap_starttls'), 'version' => $rcmail->config->get('password_ldap_version'));
    // Connecting using the configuration array
    $ldap = Net_LDAP2::connect($ldapConfig);
    // Checking for connection error
    if (PEAR::isError($ldap)) {
        return PASSWORD_CONNECT_ERROR;
    }
    // Crypting new password
    $newCryptedPassword = hashPassword($passwd, $rcmail->config->get('password_ldap_encodage'));
    if (!$newCryptedPassword) {
        return PASSWORD_CRYPT_ERROR;
    }
    // Writing new crypted password to LDAP
    $userEntry = $ldap->getEntry($userDN);
    if (Net_LDAP2::isError($userEntry)) {
        return PASSWORD_CONNECT_ERROR;
    }
    $pwattr = $rcmail->config->get('password_ldap_pwattr');
    $force = $rcmail->config->get('password_ldap_force_replace');
    if (!$userEntry->replace(array($pwattr => $newCryptedPassword), $force)) {
        return PASSWORD_CONNECT_ERROR;
    }
    if (Net_LDAP2::isError($userEntry->update())) {
        return PASSWORD_CONNECT_ERROR;
    }
    // All done, no error
    return PASSWORD_SUCCESS;
}

 /**
  * Execute the shutdown procedure.
  *
  * @throws     <b>AgaviDatabaseException</b> If an error occurs while shutting
  *                                           down this database.
  *
  * @author     Bram Goessens <bram.goessens@rwo.vlaanderen.be>
  */
 public function shutdown()
 {
     if ($this->connection != null) {
         @($result = $this->connection->done());
         $this->connection = null;
         if (Net_LDAP2::isError($result)) {
             $error = 'Could not close KVDag_LdapDatabase connection';
             throw new AgaviDatabaseException($error);
         }
     }
 }

/**
 * LDAP Password Driver
 *
 * Driver for passwords stored in LDAP
 * This driver use the PEAR Net_LDAP2 class (http://pear.php.net/package/Net_LDAP2).
 *
 * @version 1.1 (2010-04-07)
 * @author Edouard MOREAU <edouard.moreau@ensma.fr>
 *
 * function hashPassword based on code from the phpLDAPadmin development team (http://phpldapadmin.sourceforge.net/).
 * function randomSalt based on code from the phpLDAPadmin development team (http://phpldapadmin.sourceforge.net/).
 *
 */
function password_save($curpass, $passwd)
{
    $rcmail = rcmail::get_instance();
    require_once 'Net/LDAP2.php';
    // Building user DN
    if ($userDN = $rcmail->config->get('password_ldap_userDN_mask')) {
        $userDN = substitute_vars($userDN);
    } else {
        $userDN = search_userdn($rcmail);
    }
    if (empty($userDN)) {
        return PASSWORD_CONNECT_ERROR;
    }
    // Connection Method
    switch ($rcmail->config->get('password_ldap_method')) {
        case 'admin':
            $binddn = $rcmail->config->get('password_ldap_adminDN');
            $bindpw = $rcmail->config->get('password_ldap_adminPW');
            break;
        case 'user':
        default:
            $binddn = $userDN;
            $bindpw = $curpass;
            break;
    }
    // Configuration array
    $ldapConfig = array('binddn' => $binddn, 'bindpw' => $bindpw, 'basedn' => $rcmail->config->get('password_ldap_basedn'), 'host' => $rcmail->config->get('password_ldap_host'), 'port' => $rcmail->config->get('password_ldap_port'), 'starttls' => $rcmail->config->get('password_ldap_starttls'), 'version' => $rcmail->config->get('password_ldap_version'));
    // Connecting using the configuration array
    $ldap = Net_LDAP2::connect($ldapConfig);
    // Checking for connection error
    if (PEAR::isError($ldap)) {
        return PASSWORD_CONNECT_ERROR;
    }
    // Crypting new password
    $newCryptedPassword = hashPassword($passwd, $rcmail->config->get('password_ldap_encodage'));
    if (!$newCryptedPassword) {
        return PASSWORD_CRYPT_ERROR;
    }
    // Writing new crypted password to LDAP
    $userEntry = $ldap->getEntry($userDN);
    if (Net_LDAP2::isError($userEntry)) {
        return PASSWORD_CONNECT_ERROR;
    }
    $pwattr = $rcmail->config->get('password_ldap_pwattr');
    $force = $rcmail->config->get('password_ldap_force_replace');
    if (!$userEntry->replace(array($pwattr => $newCryptedPassword), $force)) {
        return PASSWORD_CONNECT_ERROR;
    }
    // Updating PasswordLastChange Attribute if desired
    if ($lchattr = $rcmail->config->get('password_ldap_lchattr')) {
        $current_day = (int) (time() / 86400);
        if (!$userEntry->replace(array($lchattr => $current_day), $force)) {
            return PASSWORD_CONNECT_ERROR;
        }
    }
    if (Net_LDAP2::isError($userEntry->update())) {
        return PASSWORD_CONNECT_ERROR;
    }
    // Update Samba password fields, ignore errors if attributes are not found
    if ($rcmail->config->get('password_ldap_samba')) {
        $sambaNTPassword = hash('md4', rcube_charset_convert($passwd, RCMAIL_CHARSET, 'UTF-16LE'));
        $userEntry->replace(array('sambaNTPassword' => $sambaNTPassword), $force);
        $userEntry->replace(array('sambaPwdLastSet' => time()), $force);
        $userEntry->update();
    }
    // All done, no error
    return PASSWORD_SUCCESS;
}

 function changePassword($username, $oldpassword, $newpassword)
 {
     if (!isset($this->attributes['password']) || !isset($this->password_encoding)) {
         //throw new Exception(_('Sorry, changing LDAP passwords is not supported at this time'));
         return false;
     }
     $entry = $this->get_user($username, array('dn' => 'dn'));
     if (!$entry) {
         return false;
     } else {
         $config = $this->get_ldap_config();
         $config['binddn'] = $entry->dn();
         $config['bindpw'] = $oldpassword;
         try {
             $ldap = $this->get_ldap_connection($config);
             $entry = $this->get_user($username, array(), $ldap);
             $newCryptedPassword = $this->hashPassword($newpassword, $this->password_encoding);
             if ($newCryptedPassword === false) {
                 return false;
             }
             if ($this->password_encoding == 'ad') {
                 //TODO I believe this code will work once this bug is fixed: http://pear.php.net/bugs/bug.php?id=16796
                 $oldCryptedPassword = $this->hashPassword($oldpassword, $this->password_encoding);
                 $entry->delete(array($this->attributes['password'] => $oldCryptedPassword));
             }
             $entry->replace(array($this->attributes['password'] => $newCryptedPassword), true);
             if (Net_LDAP2::isError($entry->upate())) {
                 return false;
             }
             return true;
         } catch (LdapInvalidCredentialsException $e) {
             return false;
         }
     }
     return false;
 }

 /**
  * @todo Implement testCreateFresh().
  */
 public function testCreateFresh()
 {
     // test failing creation
     $t = Net_LDAP2_Entry::createFresh("cn=test", "I should be an array");
     $this->assertTrue(Net_LDAP2::isError($t), 'Creating fresh entry succeeded but was supposed to fail!');
     // test failing creation
     $t = Net_LDAP2_Entry::createFresh("cn=test", array('attr1' => 'single', 'attr2' => array('mv1', 'mv2')));
     $this->assertInstanceOf('Net_LDAP2_Entry', $t, 'Creating fresh entry failed but was supposed to succeed!');
 }

 public function get_groups($force_reload = false)
 {
     $this->get_user_attributes($force_reload);
     // ensure we have a connection to the ldap server
     if ($this->bind() != 'LDAP_SUCCESS') {
         $this->add_log('ldap', 'Reuse of ldap connection failed: ' . $this->ldaplink->getMessage() . ' at line ' . __LINE__ . ' in ' . __FILE__);
         return false;
     }
     $filter1 = Net_LDAP2_Filter::create('objectClass', 'equals', $this->options['groupoc']);
     if (!empty($this->options['groupmemberattr'])) {
         // get membership from group information
         if ($this->options['groupmemberisdn']) {
             if ($this->user_attributes['dn'] == null) {
                 return false;
             }
             $filter2 = Net_LDAP2_Filter::create($this->options['groupmemberattr'], 'equals', $this->user_dn());
         } else {
             $filter2 = Net_LDAP2_Filter::create($this->options['groupmemberattr'], 'equals', $this->options['username']);
         }
         $filter = Net_LDAP2_Filter::combine('and', array($filter1, $filter2));
     } else {
         if (!empty($this->options['usergroupattr'])) {
             // get membership from user information
             $ugi =& $this->user_attributes[$this->options['usergroupattr']];
             if (!empty($ugi)) {
                 if (!is_array($ugi)) {
                     $ugi = array($ugi);
                 }
                 if (count($ugi) == 1) {
                     // one gid
                     $filter3 = Net_LDAP2_Filter::create($this->options['groupgroupattr'], 'equals', $ugi[0]);
                 } else {
                     // mor gids
                     $filtertmp = array();
                     foreach ($ugi as $g) {
                         $filtertmp[] = Net_LDAP2_Filter::create($this->options['groupgroupattr'], 'equals', $g);
                     }
                     $filter3 = Net_LDAP2_Filter::combine('or', $filtertmp);
                 }
                 $filter = Net_LDAP2_Filter::combine('and', array($filter1, $filter3));
             } else {
                 // User has no group
                 $filter = NULL;
             }
         } else {
             // not possible to get groups - return empty array
             return array();
         }
     }
     if (Net_LDAP2::isError($filter)) {
         $this->add_log('ldap', 'LDAP Filter creation error: ' . $filter->getMessage() . ' at line ' . __LINE__ . ' in ' . __FILE__);
         return false;
     }
     $this->add_log('ldap', 'Searching for group entries with filter: ' . $filter->asString() . ' base ' . $this->groupbase_dn() . ' at line ' . __LINE__ . ' in ' . __FILE__);
     $searchoptions = array('scope' => $this->options['scope']);
     $searchresult = $this->ldaplink->search($this->groupbase_dn(), $filter, $searchoptions);
     if (Net_LDAP2::isError($searchresult)) {
         $this->add_log('ldap', 'Search failed: ' . $searchresult->getMessage() . ' at line ' . __LINE__ . ' in ' . __FILE__);
         return false;
     }
     $this->add_log('ldap', 'Found ' . $searchresult->count() . ' entries. Extracting entries now.');
     $this->groups = array();
     while ($entry = $searchresult->shiftEntry()) {
         if (Net_LDAP2::isError($entry)) {
             $this->add_log('ldap', 'Error fetching group entries: ' . $entry->getMessage() . ' at line ' . __LINE__ . ' in ' . __FILE__);
             return false;
         }
         $this->groups[$entry->dn()] = $entry->getValues();
         // no error checking necessary here
     }
     $this->add_log('ldap', count($this->groups) . ' groups found at line ' . __LINE__ . ' in ' . __FILE__);
     return $this->groups;
 }

 /**
  * @param $username string
  * @param $configFilter string
  * @return void
  */
 private function PopulateUser($username, $configFilter)
 {
     $uidAttribute = $this->options->GetUserIdAttribute();
     Log::Debug('LDAP - uid attribute: %s', $uidAttribute);
     $RequiredGroup = $this->options->GetRequiredGroup();
     $filter = Net_LDAP2_Filter::create($uidAttribute, 'equals', $username);
     if ($configFilter) {
         $configFilter = Net_LDAP2_Filter::parse($configFilter);
         if (Net_LDAP2::isError($configFilter)) {
             $message = 'Could not parse search filter %s: ' . $configFilter->getMessage();
             Log::Error($message, $username);
         }
         $filter = Net_LDAP2_Filter::combine('and', array($filter, $configFilter));
     }
     $attributes = $this->options->Attributes();
     Log::Debug('LDAP - Loading user attributes: %s', implode(', ', $attributes));
     $options = array('attributes' => $attributes);
     Log::Debug('Searching ldap for user %s', $username);
     $searchResult = $this->ldap->search(null, $filter, $options);
     if (Net_LDAP2::isError($searchResult)) {
         $message = 'Could not search ldap for user %s: ' . $searchResult->getMessage();
         Log::Error($message, $username);
     }
     $currentResult = $searchResult->current();
     if ($searchResult->count() == 1 && $currentResult !== false) {
         Log::Debug('Found user %s', $username);
         if (!empty($RequiredGroup)) {
             Log::Debug('LDAP - Required Group: %s', $RequiredGroup);
             $group_filter = Net_LDAP2_Filter::create('uniquemember', 'equals', $currentResult->dn());
             $group_searchResult = $this->ldap->search($RequiredGroup, $group_filter, null);
             if (Net_LDAP2::isError($group_searchResult) && !empty($RequiredGroup)) {
                 $message = 'Could not match Required Group %s: ' . $group_searchResult->getMessage();
                 Log::Error($message, $username);
             }
             if ($group_searchResult->count() == 1 && $group_searchResult !== false) {
                 Log::Debug('Matched Required Group %s', $RequiredGroup);
                 /** @var Net_LDAP2_Entry $entry  */
                 $this->user = new LdapUser($currentResult, $this->options->AttributeMapping());
             }
         } else {
             /** @var Net_LDAP2_Entry $entry  */
             $this->user = new LdapUser($currentResult, $this->options->AttributeMapping());
         }
     } else {
         Log::Debug('Could not find user %s', $username);
     }
 }

 /**
  * testIsError().
  */
 public function testIsError()
 {
     if (!$this->ldapcfg) {
         $this->markTestSkipped('No ldapconfig.ini found. Skipping test!');
     } else {
         $error = PEAR::raiseError('TestError');
         $this->assertTrue(Net_LDAP2::isError($error));
         $this->assertFalse(Net_LDAP2::isError('noerror'));
     }
 }

<?php

/**
* This file shows you how to connect to a ldap server  using Net_LDAP2.
*
* It also establishes connections for the other examples;
* they include this file to get a ldap link.
*/
// Class includes; this assumes Net_LDAP2 installed in PHPs include path
// or under subfolder "Net" in the local directory.
require_once 'Net/LDAP2.php';
// Configuration
// host can be a single server (string) or multiple ones - if we define more
// servers here (array), we can implement a basic fail over scenario.
// If no credentials (binddn and bindpw) are given, Net_LDAP2 establishes
// an anonymous bind.
// See the documentation for more information on the configuration items!
$ldap_config = array('host' => array('ldap1.example.org', 'ldap2.example.org'), 'tls' => false, 'base' => 'o=example,dc=org', 'port' => 389, 'version' => 3, 'filter' => '(cn=*)', 'scope' => 'sub');
// Connect to configured ldap server
$ldap = Net_LDAP2::connect($ldap_config);
// It is important to check for errors.
// Nearly every method of Net_LDAP2 returns a Net_LDAP2_Error object
// if something went wrong. Through this object, you can retrieve detailed
// information on what exactly happened.
//
// Here we drop a die with the error message, so the other example
// files will not be calles unless we have a valid link.
if (Net_LDAP2::isError($ldap)) {
    die('BIND FAILED: ' . $ldap->getMessage());
}

 function ldap_get_connection($config = null)
 {
     if ($config == null && isset($this->default_ldap)) {
         return $this->default_ldap;
     }
     //cannot use Net_LDAP2::connect() as StatusNet uses
     //PEAR::setErrorHandling(PEAR_ERROR_CALLBACK, 'handleError');
     //PEAR handling can be overridden on instance objects, so we do that.
     $ldap = new Net_LDAP2(isset($config) ? $config : $this->ldap_get_config());
     $ldap->setErrorHandling(PEAR_ERROR_RETURN);
     $err = $ldap->bind();
     if (Net_LDAP2::isError($err)) {
         // if we were called with a config, assume caller will handle
         // incorrect username/password (LDAP_INVALID_CREDENTIALS)
         if (isset($config) && $err->getCode() == 0x31) {
             return null;
         }
         throw new Exception('Could not connect to LDAP server: ' . $err->getMessage());
         return false;
     }
     if ($config == null) {
         $this->default_ldap = $ldap;
     }
     return $ldap;
 }

if (Net_LDAP2::isError($search)) {
    die('LDAP search failed: ' . $search->getMessage());
}
// Lets see what entries we got and print the names and telephone numbers:
if ($search->count() > 0) {
    echo "Found " . $search->count() . ' entries:<br>';
    // Note, this is is only one of several ways to fetch entries!
    // You can also retrieve all entries in an array with
    //   $entries = $search->entries()
    // or the same thing sorted:
    //   $entries = $search->sorted()
    // Since Net_LDAP2 you can also use a foreach loop:
    //   foreach ($search as $dn => $entry) {
    while ($entry = $search->shiftEntry()) {
        $surename = $entry->getValue('sn', 'single');
        if (Net_LDAP2::isError($surename)) {
            die('Unable to get surename: ' . $surename->getMessage());
        }
        $givenname = $entry->getValue('gn', 'single');
        if (Net_LDAP2::isError($givenname)) {
            die('Unable to get givenname: ' . $givenname->getMessage());
        }
        $phone = $entry->getValue('telephonenumber', 'single');
        if (Net_LDAP2::isError($phone)) {
            die('Unable to get phone number: ' . $phone->getMessage());
        }
        echo "<br>{$givenname} {$surename}: {$phone}";
    }
} else {
    die('Sorry, no entries found!');
}

 function authenticate($login, $password)
 {
     if ($login && $password) {
         if (!function_exists('ldap_connect')) {
             trigger_error('auth_ldap requires PHP\'s PECL LDAP package installed.');
             return FALSE;
         }
         if (!(require_once 'Net/LDAP2.php')) {
             trigger_error('auth_ldap requires the PEAR package Net::LDAP2');
             return FALSE;
         }
         $debugMode = defined('LDAP_AUTH_DEBUG') ? LDAP_AUTH_DEBUG : FALSE;
         $anonymousBeforeBind = defined('LDAP_AUTH_ANONYMOUSBEFOREBIND') ? LDAP_AUTH_ANONYMOUSBEFOREBIND : FALSE;
         $parsedURI = parse_url(LDAP_AUTH_SERVER_URI);
         if ($parsedURI === FALSE) {
             $this->_log('Could not parse LDAP_AUTH_SERVER_URI in config.php');
             return FALSE;
         }
         $ldapConnParams = array('host' => $parsedURI['scheme'] . '://' . $parsedURI['host'], 'basedn' => LDAP_AUTH_BASEDN, 'options' => array('LDAP_OPT_REFERRALS' => 0));
         if (!$anonymousBeforeBind) {
             $ldapConnParams['binddn'] = LDAP_AUTH_BINDDN;
             $ldapConnParams['bindpw'] = LDAP_AUTH_BINDPW;
         }
         $ldapConnParams['starttls'] = defined('LDAP_AUTH_USETLS') ? LDAP_AUTH_USETLS : FALSE;
         if (is_int($parsedURI['port'])) {
             $ldapConnParams['port'] = $parsedURI['port'];
         }
         $ldapSchemaCacheEnable = defined('LDAP_AUTH_SCHEMA_CACHE_ENABLE') ? LDAP_AUTH_SCHEMA_CACHE_ENABLE : TRUE;
         $ldapSchemaCacheTimeout = defined('LDAP_AUTH_SCHEMA_CACHE_TIMEOUT') ? LDAP_AUTH_SCHEMA_CACHE_TIMEOUT : 86400;
         $logAttempts = defined('LDAP_AUTH_LOG_ATTEMPTS') ? LDAP_AUTH_LOG_ATTEMPTS : FALSE;
         // Making connection to LDAP server
         if (LDAP_AUTH_ALLOW_UNTRUSTED_CERT === TRUE) {
             putenv('LDAPTLS_REQCERT=never');
         }
         $ldapConn = Net_LDAP2::connect($ldapConnParams);
         if (Net_LDAP2::isError($ldapConn)) {
             $this->_log('Could not connect to LDAP Server: ' . $ldapConn->getMessage());
             return FALSE;
         }
         // Bind with service account if orignal connexion was anonymous
         if ($anonymousBeforeBind) {
             $binding = $ldapConn->bind(LDAP_AUTH_BINDDN, LDAP_AUTH_BINDPW);
             if (Net_LDAP2::isError($binding)) {
                 $this->_log('Cound not bind service account: ' . $binding->getMessage());
                 return FALSE;
             }
         }
         //Cache LDAP Schema
         if ($ldapSchemaCacheEnable) {
             if (!sys_get_temp_dir()) {
                 $tmpFile = tmp;
                 $tmpDir = dirname($tmpFile);
                 unlink($tmpFile);
                 unset($tmpFile);
             } else {
                 $tmpDir = sys_get_temp_dir();
             }
             if (empty($parsedURI['port'])) {
                 $ldapPort = $parsedURI['scheme'] == 'ldaps' ? 636 : 389;
             } else {
                 $ldapPort = $parsedURI['port'];
             }
             $cacheFileLoc = $tmpDir . '/ttrss-ldapCache-' . $parsedURI['host'] . ':' . $ldapPort . '.cache';
             if ($debugMode) {
                 $this->_log('Schema Cache File: ' . $cacheFileLoc, E_USER_NOTICE);
             }
             $schemaCacheConf = array('path' => $cacheFileLoc, 'max_age' => $ldapSchemaCacheTimeout);
             $schemaCacheObj = new Net_LDAP2_SimpleFileSchemaCache($schemaCacheConf);
             $ldapConn->registerSchemaCache($schemaCacheObj);
             $schemaCacheObj->storeSchema($ldapConn->schema());
         }
         //Searching for user
         $completedSearchFiler = str_replace('???', $login, LDAP_AUTH_SEARCHFILTER);
         $filterObj = Net_LDAP2_Filter::parse($completedSearchFiler);
         $searchResults = $ldapConn->search(LDAP_AUTH_BASEDN, $filterObj);
         if (Net_LDAP2::isError($searchResults)) {
             $this->_log('LDAP Search Failed: ' . $searchResults->getMessage());
             return FALSE;
         } elseif ($searchResults->count() === 0) {
             if ($logAttempts) {
                 $this->_logAttempt((string) $login, 'Unknown User');
             }
             return FALSE;
         } elseif ($searchResults->count() > 1) {
             $this->_log('Multiple DNs found for username ' . $login);
             return FALSE;
         }
         //Getting user's DN from search
         $userEntry = $searchResults->shiftEntry();
         $userDN = $userEntry->dn();
         //Binding with user's DN.
         $loginAttempt = $ldapConn->bind($userDN, $password);
         $ldapConn->disconnect();
         if ($loginAttempt === TRUE) {
             if ($logAttempts) {
                 $this->_logAttempt((string) $login, 'successful');
             }
             return $this->base->auto_create_user($login);
         } elseif ($loginAttempt->getCode() == 49) {
             if ($logAttempts) {
//.........这里部分代码省略.........

/**
* This is a short example on how to fetch a specific entry in the
* directory using Net_LDAP2.
*/
// We use the connecting.php example to get a link to our server.
// This file will also include all required basic Net_LDAP2 classes.
include_once 'connecting.php';
// Okay, we should have a valid link now.
// Lets fetch an entry! We want to know the admins first and last name.
// If we need additional attributes later, we must refetch the entry.
// It is a good practice to only select the attributes really needed.
// Since we want to be a little flexible, we make the base
// dynamic, so it is enough to change the base-dn in your
// $ldap_config array.
$entry = $ldap->getEntry('cn=admin,' . $ldap_config['base'], array('gn', 'sn'));
// Error checking is important!
if (Net_LDAP2::isError($entry)) {
    die('Could not fetch entry: ' . $entry->getMessage());
}
// Now fetch the data from the entry
$surename = $entry->getValue('sn', 'single');
if (Net_LDAP2::isError($surename)) {
    die('Unable to get surename: ' . $surename->getMessage());
}
$givenname = $entry->getValue('gn', 'single');
if (Net_LDAP2::isError($givenname)) {
    die('Unable to get surename: ' . $givenname->getMessage());
}
// Finally output the data of the entry:
// This will give something like "Name of cn=admin,o=example,dc=org: Foo Bar"
echo 'Name of ' . $entry->DN() . ': ' . $givenname . ' ' . $surename;

 /**
  * Haal de rollen van de huidige gebruiker op voor een opgegeven applicatie naam
  * In onze LDAP server vertegenwoordigd het veld description de volledige naam van de applicatie
  *
  * @param   KVDutil_Auth_Gebruiker      $gebruiker
  * @param   string                      $applicatieNaam
  *                                      structuur: 'ou='.$applicatieNaam.',ou=productie,ou=groups,dc=vioe,dc=be'
  * @return  KVDutil_AuthRolCollectie    $rollen
  */
 public function getRollenVoorApplicatieNaam(KVDutil_Auth_Gebruiker $gebruiker, $applicatieNaam)
 {
     $filter = Net_LDAP2_Filter::create($this->parameters['gebruiker_bij_rol'], 'contains', $gebruiker->getId());
     $options = array('scope' => 'sub', 'attributes' => array($this->parameters['rol_naam'], $this->parameters['rol_beschrijving']));
     //Voer zoekactie uit op boven meegegeven searchbase met de opgegeven options en filters
     $search = $this->connectie->search($applicatieNaam, $filter, $options);
     if (Net_LDAP2::isError($search)) {
         throw new Exception($search->getMessage());
     }
     $results = array();
     //objecten worden 1 voor 1 volledig geladen en in een array geplaatst.
     foreach ($search as $dn => $entry) {
         $results[$dn] = new KVDutil_Auth_Rol($dn, $entry->getValue($this->parameters['rol_naam'], 'single'), $entry->getValue($this->parameters['rol_beschrijving'], 'single'));
     }
     //De array met objecten wordt in een KVDdom_DomainObjectCollection geplaatst.
     return new KVDutil_Auth_RolCollectie($results);
 }