function _RootDSE($filtr)
 {
     $sr = ldap_read($this->conn, '', 'objectClass=*', array($filtr), 0);
     //$sr = ldap_read($this->conn, '', 'objectClass=*');
     $entry = ldap_first_entry($this->conn, $sr);
     $attributes = ldap_get_attributes($this->conn, $entry);
     $values = false;
     if ($attributes['count'] > 0) {
         $values = @ldap_get_values_len($this->conn, $entry, $filtr);
     }
     return $values;
 }

function xldap_user_group_check($ldap, $userdn, $groupdn, $recurs_count = 16)
{
    if ($recurs_count <= 0) {
        return FALSE;
    }
    $attributes = array('memberof');
    $result = ldap_read($ldap, $userdn, '(objectclass=*)', $attributes);
    if ($result === FALSE) {
        return FALSE;
    }
    $entries = ldap_get_entries($ldap, $result);
    if ($entries['count'] <= 0) {
        return FALSE;
    }
    if (empty($entries[0]['memberof'])) {
        return FALSE;
    } else {
        for ($i = 0; $i < $entries[0]['memberof']['count']; $i++) {
            if ($entries[0]['memberof'][$i] == $groupdn) {
                return TRUE;
            } else {
                if ($recurs_count > 1) {
                    if (xldap_user_group_check($ldap, $entries[0]['memberof'][$i], $groupdn, $recurs_count - 1)) {
                        return TRUE;
                    }
                }
            }
        }
    }
    return FALSE;
}

function get_ldap_cn($user, $debug = 0)
{
    try {
        if (!($ds = get_ldap_connection())) {
            throw new Exception('Unable to connect to LDAP Server');
        }
        $dn = "mail={$user}, o=com, dc=mozilla";
        //the object itself instead of the top search level as in ldap_search
        $filter = "(objectclass=inetOrgPerson)";
        // this command requires some filter
        $justthese = array("cn");
        //the attributes to pull, which is much more efficient than pulling all attributes if you don't do this
        if (!($sr = ldap_read($ds, $dn, $filter, $justthese))) {
            throw new Exception('Incorrect Username or filter');
        }
        if (!($entry = ldap_get_entries($ds, $sr))) {
            throw new Exception('Unable to find LDAP entry for ' . $user);
        }
        if ($debug != 0) {
            echo $entry[0]["cn"][0] . " is the name in LDAP for " . $user;
        }
        ldap_close($ds);
        return $entry[0]["cn"][0];
    } catch (Exception $e) {
        echo 'Oops! I countered the following error: ', $e->getMessage(), "\n";
    }
}

 /**
  * @brief reads a given attribute for an LDAP record identified by a DN
  * @param $dn the record in question
  * @param $attr the attribute that shall be retrieved
  * @returns the values in an array on success, false otherwise
  *
  * Reads an attribute from an LDAP entry
  */
 public function readAttribute($dn, $attr)
 {
     if (!$this->checkConnection()) {
         \OCP\Util::writeLog('user_ldap', 'No LDAP Connector assigned, access impossible for readAttribute.', \OCP\Util::WARN);
         return false;
     }
     $cr = $this->connection->getConnectionResource();
     if (!is_resource($cr)) {
         //LDAP not available
         \OCP\Util::writeLog('user_ldap', 'LDAP resource not available.', \OCP\Util::DEBUG);
         return false;
     }
     $rr = @ldap_read($cr, $dn, 'objectClass=*', array($attr));
     if (!is_resource($rr)) {
         \OCP\Util::writeLog('user_ldap', 'readAttribute ' . $attr . ' failed for DN ' . $dn, \OCP\Util::DEBUG);
         //in case an error occurs , e.g. object does not exist
         return false;
     }
     $er = ldap_first_entry($cr, $rr);
     //LDAP attributes are not case sensitive
     $result = \OCP\Util::mb_array_change_key_case(ldap_get_attributes($cr, $er), MB_CASE_LOWER, 'UTF-8');
     $attr = mb_strtolower($attr, 'UTF-8');
     if (isset($result[$attr]) && $result[$attr]['count'] > 0) {
         $values = array();
         for ($i = 0; $i < $result[$attr]['count']; $i++) {
             $values[] = $this->resemblesDN($attr) ? $this->sanitizeDN($result[$attr][$i]) : $result[$attr][$i];
         }
         return $values;
     }
     \OCP\Util::writeLog('user_ldap', 'Requested attribute ' . $attr . ' not found for ' . $dn, \OCP\Util::DEBUG);
     return false;
 }

 public static function readUser($ldapconn, $dn)
 {
     $search = ldap_read($ldapconn, $dn, USER::FILTER_USERS, array("cn", "mail", "displayName", "sn", "givenName", "memberOf"));
     if (ldap_count_entries($ldapconn, $search) > 0) {
         $entry = ldap_first_entry($ldapconn, $search);
         return User::readFromLdapEntry($ldapconn, $entry);
     }
 }

 /**
  * @param string $dn         the dn to read
  * @param string $filter     the filter
  * @param array  $attributes the attributes to be returned
  *
  * @return array
  * @throws \Exception
  */
 public function readEntry($dn, $filter, array $attributes)
 {
     $result = @ldap_read($this->connection, $dn, $filter, $attributes);
     if ($result === false) {
         throw new \Exception("invalid bla");
     }
     $entries = ldap_get_entries($this->connection, $result);
     return $entries;
 }

 /**
  * Get Root DSE
  *
  * @param	array	Attributes to return.  By default all attributes will be returned
  * @return	array	Requested attributes
  */
 protected function getRootDse($attributes = null)
 {
     if ($attributes === null) {
         $result = ldap_read($this->connection, NULL, 'objectClass=*');
     } else {
         $result = ldap_read($this->connection, NULL, 'objectClass=*', $attributes);
     }
     $entries = ldap_get_entries($this->connection, $result);
     return $entries;
 }

function ldap_search_withScope($ds, $basedn, $filter, $attrlist, $scope)
{
    if ($scope == "base") {
        $search = ldap_read($ds, $basedn, $filter, $attrlist);
    } elseif ($scope == "one") {
        $search = ldap_list($ds, $basedn, $filter, $attrlist);
    } elseif ($scope == "sub") {
        $search = ldap_search($ds, $basedn, $filter, $attrlist);
    }
    return $search;
}

 /**
  * Reads all objects.
  *
  * @return array
  */
 public function getUserInfo()
 {
     if ($this->authenticated) {
         if (empty($this->userData)) {
             $rs = ldap_read($this->connection, $this->dn, "(objectclass=*)");
             $this->userData = ldap_get_entries($this->connection, $rs);
         }
         return $this->userData;
     }
     return [];
 }

 /**
  * @brief reads a given attribute for an LDAP record identified by a DN
  * @param $dn the record in question
  * @param $attr the attribute that shall be retrieved
  *        if empty, just check the record's existence
  * @returns an array of values on success or an empty
  *          array if $attr is empty, false otherwise
  *
  * Reads an attribute from an LDAP entry or check if entry exists
  */
 public function readAttribute($dn, $attr, $filter = 'objectClass=*')
 {
     if (!$this->checkConnection()) {
         \OCP\Util::writeLog('user_ldap', 'No LDAP Connector assigned, access impossible for readAttribute.', \OCP\Util::WARN);
         return false;
     }
     $cr = $this->connection->getConnectionResource();
     if (!is_resource($cr)) {
         //LDAP not available
         \OCP\Util::writeLog('user_ldap', 'LDAP resource not available.', \OCP\Util::DEBUG);
         return false;
     }
     $dn = $this->DNasBaseParameter($dn);
     $rr = @ldap_read($cr, $dn, $filter, array($attr));
     if (!is_resource($rr)) {
         if (!empty($attr)) {
             //do not throw this message on userExists check, irritates
             \OCP\Util::writeLog('user_ldap', 'readAttribute failed for DN ' . $dn, \OCP\Util::DEBUG);
         }
         //in case an error occurs , e.g. object does not exist
         return false;
     }
     if (empty($attr)) {
         \OCP\Util::writeLog('user_ldap', 'readAttribute: ' . $dn . ' found', \OCP\Util::DEBUG);
         return array();
     }
     $er = ldap_first_entry($cr, $rr);
     if (!is_resource($er)) {
         //did not match the filter, return false
         return false;
     }
     //LDAP attributes are not case sensitive
     $result = \OCP\Util::mb_array_change_key_case(ldap_get_attributes($cr, $er), MB_CASE_LOWER, 'UTF-8');
     $attr = mb_strtolower($attr, 'UTF-8');
     if (isset($result[$attr]) && $result[$attr]['count'] > 0) {
         $values = array();
         for ($i = 0; $i < $result[$attr]['count']; $i++) {
             if ($this->resemblesDN($attr)) {
                 $values[] = $this->sanitizeDN($result[$attr][$i]);
             } elseif (strtolower($attr) == 'objectguid' || strtolower($attr) == 'guid') {
                 $values[] = $this->convertObjectGUID2Str($result[$attr][$i]);
             } else {
                 $values[] = $result[$attr][$i];
             }
         }
         return $values;
     }
     \OCP\Util::writeLog('user_ldap', 'Requested attribute ' . $attr . ' not found for ' . $dn, \OCP\Util::DEBUG);
     return false;
 }

function install_etape_ldap3_dist()
{
    $adresse_ldap = _request('adresse_ldap');
    $login_ldap = _request('login_ldap');
    $pass_ldap = _request('pass_ldap');
    $port_ldap = _request('port_ldap');
    $base_ldap_text = defined('_INSTALL_BASE_LDAP') ? _INSTALL_BASE_LDAP : "ou=users, dc=mon-domaine, dc=com";
    echo install_debut_html('AUTO', ' onload="document.getElementById(\'suivant\').focus();return false;"');
    echo info_etape(_T('info_chemin_acces_1'), info_progression_etape(3, 'etape_ldap', 'install/')), _T('info_chemin_acces_2');
    $ldap_link = @ldap_connect("{$adresse_ldap}", "{$port_ldap}");
    if ($ldap_link) {
        @ldap_bind($ldap_link, "{$login_ldap}", "{$pass_ldap}");
        $result = @ldap_read($ldap_link, "", "objectclass=*", array("namingContexts"));
        $info = @ldap_get_entries($ldap_link, $result);
        @ldap_close($ldap_link);
    }
    $checked = false;
    $res = '';
    if (is_array($info) and $info["count"] > 0) {
        $res .= "<p>" . _T('info_selection_chemin_acces') . "</p>";
        $res .= "<ul>";
        $n = 0;
        for ($i = 0; $i < $info["count"]; $i++) {
            $names = $info[$i]["namingcontexts"];
            if (is_array($names)) {
                for ($j = 0; $j < $names["count"]; $j++) {
                    $n++;
                    $res .= "<li><input name=\"base_ldap\" value=\"" . spip_htmlspecialchars($names[$j]) . "\" type='radio' id='tab{$n}'";
                    if (!$checked) {
                        $res .= " checked=\"checked\"";
                        $checked = true;
                    }
                    $res .= " />";
                    $res .= "<label for='tab{$n}'>" . spip_htmlspecialchars($names[$j]) . "</label></li>\n";
                }
            }
        }
        $res .= "</ul>";
        $res .= _T('info_ou') . " ";
    }
    $res .= "<br />\n<input name=\"base_ldap\" value=\"\" type='radio' id='manuel'";
    if (!$checked) {
        $res .= " checked=\"checked\"";
        $checked = true;
    }
    $res .= " />" . "\n<label for='manuel'>" . _T('entree_chemin_acces') . "</label> " . "\n<fieldset>" . "<input type='text' name='base_ldap_text' class='text' value=\"{$base_ldap_text}\" size='40' />" . "\n</fieldset>" . "\n<input type='hidden' name='etape' value='ldap4' />" . install_propager(array('adresse_ldap', 'port_ldap', 'login_ldap', 'pass_ldap', 'protocole_ldap', 'tls_ldap')) . bouton_suivant();
    echo generer_form_ecrire('install', $res);
    echo install_fin_html();
}

 public function ReadEntry($dn, $attribs)
 {
     //foreach($attribs as &$attrib)
     //	$attrib = strtolower($attrib);
     $filter = '(objectclass=*)';
     $sr = ldap_read($this->con, $dn, $filter, $attribs);
     if ($sr === false) {
         return false;
     }
     $entry = ldap_get_entries($this->con, $sr);
     if ($entry === false) {
         return false;
     }
     return $entry;
 }

 public function getUserAttributes()
 {
     $fname_tag = qa_opt('ldap_login_fname');
     $sname_tag = qa_opt('ldap_login_sname');
     $mail_tag = qa_opt('ldap_login_mail');
     $filter = qa_opt('ldap_login_filter');
     $attributes = array('dn', $fname_tag, $sname_tag, $mail_tag);
     // The DN is known so just use it to read attributes
     $read = ldap_read($this->con, $this->dn, $filter, $attributes);
     $data = ldap_get_entries($this->con, $read);
     $fname = $data[0][strtolower($fname_tag)][0];
     $sname = $data[0][strtolower($sname_tag)][0];
     $mail = $data[0][strtolower($mail_tag)][0];
     return array($fname, $sname, $mail, $this->authenticatedUser);
 }

 public function read($dn = NULL)
 {
     $dn = $dn ? $dn : $this->dn;
     # default to self
     $attrs = array('givenname', 'surname', 'displayname', 'title', 'mail', 'mobile', 'telephonenumber', 'uid');
     $result = ldap_read($this->conn, $dn, $this->filter, $attrs);
     if (!$result) {
         throw new LDAPAuthError();
     }
     $entries = ldap_get_entries($this->conn, $result);
     if ($entries === false) {
         throw new LDAPAuthError();
     }
     return $this->flatten($entries[0]);
 }

 private function getUserAttributesByDn($userDn)
 {
     $query = @ldap_read($this->ldapConnection, $userDn, "(objectClass=*)", array_values($this->config->s('LdapVootStorage')->s('attributeMapping')->toArray()));
     if (false === $query) {
         throw new VootStorageException("ldap_error", "directory query for user failed");
     }
     $entry = @ldap_first_entry($this->ldapConnection, $query);
     if (false === $entry) {
         throw new VootStorageException("not_found", "user not found");
     }
     $attributes = @ldap_get_attributes($this->ldapConnection, $entry);
     if (false === $attributes) {
         throw new VootStorageException("ldap_error", "unable to get user attributes");
     }
     $filteredAttributes = $this->filterAttributes($attributes);
     return $filteredAttributes;
 }

 protected function getUserLdapPhoto($contactID)
 {
     $ldap_context = $_SESSION['phpgw_info']['expressomail']['ldap_server']['dn'];
     $justthese = array("dn", 'jpegPhoto', 'givenName', 'sn');
     $this->getLdapCatalog()->ldapConnect(true);
     $ds = $this->getLdapCatalog()->ds;
     if ($ds) {
         $resource = @ldap_read($ds, $contactID, "phpgwaccounttype=u");
         $n_entries = @ldap_count_entries($ds, $resource);
         if ($n_entries == 1) {
             $first_entry = ldap_first_entry($ds, $resource);
             $obj = ldap_get_attributes($ds, $first_entry);
             if ($obj['jpegPhoto']) {
                 return ldap_get_values_len($ds, $first_entry, "jpegPhoto");
             }
         }
     }
     return false;
 }

 public function loadUsers()
 {
     $search = ldap_read($this->ldapconn, $this->dn, Group::FILTER_GROUPS, array("member"));
     if (ldap_count_entries($this->ldapconn, $search) > 0) {
         $entry = ldap_first_entry($this->ldapconn, $search);
         $att = ldap_get_attributes($this->ldapconn, $entry);
         if (isset($att['member'])) {
             $this->members = [];
             for ($i = 0; $i < $att['member']['count']; $i++) {
                 $dn = $att['member'][$i];
                 if ($dn != DUMMY_USER_DN) {
                     $this->members[] = User::readUser($this->ldapconn, $dn);
                 }
             }
         } else {
             $this->members = [];
         }
     }
 }

 public function login($username, $password)
 {
     $CI =& get_instance();
     $config = $CI->config->item("auth_ldap");
     if ($username == "" || $password == "") {
         return false;
     }
     $ds = ldap_connect($config['host'], $config['port']);
     if ($ds === false) {
         return false;
     }
     switch ($config["scope"]) {
         case "base":
             $r = ldap_read($ds, $config['basedn'], $config["username_field"] . '=' . $username);
             break;
         case "one":
             $r = ldap_list($ds, $config['basedn'], $config["username_field"] . '=' . $username);
             break;
         case "subtree":
             $r = ldap_search($ds, $config['basedn'], $config["username_field"] . '=' . $username);
             break;
         default:
             throw new \exceptions\ApiException("libraries/duser/ldap/invalid-ldap-scope", "Invalid LDAP scope");
     }
     if ($r === false) {
         return false;
     }
     foreach ($config["options"] as $key => $value) {
         if (ldap_set_option($ds, $key, $value) === false) {
             return false;
         }
     }
     $result = ldap_get_entries($ds, $r);
     if ($result === false || !isset($result[0])) {
         return false;
     }
     // ignore errors from ldap_bind as it will throw an error if the password is incorrect
     if (@ldap_bind($ds, $result[0]['dn'], $password)) {
         ldap_unbind($ds);
         return array("username" => $result[0][$config["username_field"]][0], "userid" => $result[0][$config["userid_field"]][0]);
     }
     return false;
 }

 protected function retrieveResponse()
 {
     $response = $this->initResponse();
     $response->setCode($this->errorNo);
     $response->setResponseError($this->errorMsg);
     if (!$this->filter) {
         return $response;
     }
     $ds = $this->connectToServer();
     if (!$ds) {
         $response->setResponseError("Could not connect to LDAP server");
         return $response;
     }
     if ($this->adminDN) {
         if (!ldap_bind($ds, $this->adminDN, $this->adminPassword)) {
             Kurogo::log(LOG_WARNING, "Error binding to LDAP Server {$this->host} for {$this->adminDN}: " . ldap_error($ds), 'data');
             $response->setResponseError("Could not connect to LDAP server");
             return $response;
         }
     }
     // suppress warnings on non-dev servers
     // about searches that go over the result limit
     if (!$this->debugMode) {
         $error_reporting = ini_get('error_reporting');
         error_reporting($error_reporting & ~E_WARNING);
     }
     if ($this->filter instanceof LDAPFilter) {
         $result = @ldap_search($ds, $this->searchBase, strval($this->filter), $this->getAttributes(), 0, 0, $this->searchTimelimit);
     } else {
         $result = @ldap_read($ds, $this->filter, "(objectclass=*)", $this->getAttributes(), 0, 0, $this->readTimelimit);
     }
     $error_code = ldap_errno($ds);
     $response->setResponse($result);
     $response->setCode($error_code);
     $response->setContext('ldap', $ds);
     if ($error_code) {
         $response->setResponseError($this->generateErrorMessage($error_code));
     }
     if (!$this->debugMode) {
         error_reporting($error_reporting);
     }
     return $response;
 }

/**
 * Function that try to load from LDAP the user information...
 *
 * @param $ldap_connection ldap connection descriptor
 * @param $ldap_method LDAP method
 * @param $userdn Basedn of the user
 * @param $login User Login
 */
function getFromLDAP($ldap_connection, $userdn, $login)
{
    global $fields, $ldapsrv, $ldapmap;
    if ($ldap_connection) {
        $fields = array('ldap_login' => $ldapsrv[5], 'ldap_field_email' => $ldapmap[6], 'ldap_field_realname' => 'sn', 'ldap_field_firstname' => 'givenname', 'ldap_field_phone' => $ldapmap[7], 'ldap_field_title' => 'title');
        $fields = array_filter($fields);
        $f = array_values($fields);
        $sr = @ldap_read($ldap_connection, $userdn, "objectClass=*", $f);
        $v = ldap_get_entries($ldap_connection, $sr);
        if (!is_array($v) || count($v) == 0) {
            return false;
        }
        foreach ($fields as $k => $e) {
            if (empty($v[0][$e][0])) {
                switch ($k) {
                    case "title":
                    case "type":
                    default:
                        $fields[$k] = "";
                        //	break;
                }
            } else {
                switch ($k) {
                    case "language":
                    case "title":
                    case "type":
                    default:
                        if (!empty($v[0][$e][0])) {
                            $fields[$k] = addslashes($v[0][$e][0]);
                        } else {
                            $fields[$k] = "";
                            //	    break;
                        }
                }
            }
            $stringData = "Field {$fields[$k]} = ({$v['0']}[{$e}][0]\n";
            fwrite($fh, $stringData);
        }
        return true;
    }
    return false;
}